Infra

Travaux pratiques Intermédiaire Gratuit

TP Docker & Docker Compose

Trois ateliers progressifs : construire, paramétrer puis exposer une application multi-services avec Compose.

  • 3 ateliers
  • 53 étapes
Commencer le TP

Fondations Docker Compose

Construire et lancer une application multi-services avec deux Dockerfiles personnalisés.

3h30 · indicatif Fondations 18 étapes

Résultat attendu

Une page HTML appelle l’API PHP ; MariaDB est accessible dans phpMyAdmin ; un message de test apparaît dans Mailpit.

Prérequis

  • Docker Engine ou Docker Desktop et Docker Compose V2 disponibles
  • Terminal, navigateur et connexion Internet pour le premier build
  • Pack étudiants : dossier ateliers/niveau-1/

Étapes du TP

Prendre en main le projet

  1. Étape 1 : Vérifier les prérequis

    Expliquer la différence entre Docker Engine, image, conteneur et Compose.

    docker version && docker compose version

    Les versions s’affichent sans erreur.

  2. Étape 2 : Explorer l’arborescence

    Dans ateliers/niveau-1, identifier compose.yaml, api/Dockerfile, app/Dockerfile et les sources PHP/HTML/SCSS.

    Les deux services construits et les trois images utilisées directement sont identifiés.

  3. Étape 3 : Définir le rôle des cinq services

    Relier api, app, db, phpmyadmin et mailer à leurs fonctions ; préciser que Mailpit reçoit des emails uniquement à titre de test.

    Le schéma des échanges navigateur → app/API → base ou SMTP est expliqué.

Créer les images personnalisées

  1. Étape 4 : Dockerfile API : partir de Debian

    Compléter FROM, WORKDIR et la copie des sources ; montrer que Debian ne contient pas PHP prêt à l’emploi.

    cat api/Dockerfile

    Le Dockerfile identifie correctement son image de base et son répertoire de travail.

  2. Étape 5 : Installer PHP avec RUN

    Ajouter php-cli, php-mysql, php-mbstring et les dépendances via apt-get ; nettoyer les listes APT.

    Les commandes RUN préparent les dépendances lors du build.

  3. Étape 6 : Installer Composer et les dépendances PHP

    Installer Composer avec vérification de signature ; exécuter composer install à partir de composer.json.

    Composer est présent dans l’image, les dépendances sont installées.

  4. Étape 7 : Démarrer l’API PHP

    Renseigner EXPOSE 8000 et CMD du serveur PHP de développement. Distinguer documentation de port et publication du port par Compose.

    L’API écoute sur 0.0.0.0:8000 dans le conteneur.

  5. Étape 8 : Dockerfile app : compiler les SCSS avec Node

    Utiliser une étape Node pour installer Sass et construire les fichiers CSS.

    La génération CSS se fait pendant docker build.

  6. Étape 9 : Servir le frontend avec Nginx

    Créer une seconde étape FROM nginx et copier les ressources produites depuis l’étape Node.

    L’image finale sert HTML/CSS/JS sans moteur Node d’exécution.

Assembler la stack Compose

  1. Étape 10 : Configurer MariaDB

    Déclarer db via image, environment et volume nommé ; expliquer l’intérêt de la persistance.

    db_data protège les fichiers de données contre la recréation ordinaire du conteneur.

  2. Étape 11 : Configurer phpMyAdmin et Mailpit

    Utiliser leurs images existantes. Définir PMA_HOST=db et l’interface web Mailpit sur 8025.

    phpMyAdmin cible db ; Mailpit reçoit le SMTP de l’API sur mailer:1025.

  3. Étape 12 : Configurer api et app avec build

    Renseigner build.context et dockerfile pour les deux services personnalisés. Définir la connexion db et SMTP, les dépendances et les ports.

    Les cinq services disposent de leurs paramètres essentiels.

  4. Étape 13 : Valider et builder le projet

    Corriger les erreurs remontées par Docker Compose ; créer et lancer les images.

    docker compose config && docker compose up -d --build

    La commande termine sans erreur et construit api et app.

  5. Étape 14 : Observer les conteneurs et diagnostiquer

    Identifier les services démarrés, consulter les logs API ou base de données si nécessaire.

    docker compose ps && docker compose logs --tail=60 api

    Les services utiles sont en cours d’exécution et MariaDB devient healthy.

Vérifier le fonctionnement de bout en bout

  1. Étape 15 : Vérifier l’interface et le Hello World

    Ouvrir http://localhost:8080 puis tester la réponse JSON du backend à travers le proxy Nginx.

    curl -i http://localhost:8080/api/hello

    La page affiche les informations transmises par l’API.

  2. Étape 16 : Tester la base de données

    Accéder à http://localhost:8081, se connecter avec les identifiants fictifs du TP et repérer la base tp_docker.

    La connexion phpMyAdmin à MariaDB fonctionne.

  3. Étape 17 : Envoyer un message de test

    Soumettre le formulaire, observer l’enregistrement en base et le message dans http://localhost:8025.

    curl -s -X POST http://localhost:8080/api/messages -H "Content-Type: application/json" -d '{"sender":"TP","content":"Bonjour Docker"}'

    Une ligne est créée en base et un mail apparaît dans Mailpit.

  4. Étape 18 : Arrêter sans perdre les volumes

    Arrêter la stack et expliquer la différence entre down et down -v.

    docker compose down

    Les conteneurs et le réseau sont supprimés ; les volumes nommés sont conservés.

Ressources

Configuration dynamique avec .env

Externaliser les valeurs, paramétrer les builds et distinguer ARG, ENV et interpolation Compose.

3h30 · indicatif Paramétrage 17 étapes

Résultat attendu

La stack est reconstruite depuis des versions et paramètres définis dans .env, et les étudiants expliquent ce qui agit au build ou à l’exécution.

Prérequis

  • Niveau 1 acquis ou fonctionnement Docker Compose déjà maîtrisé
  • Pack étudiants : dossier ateliers/niveau-2/
  • Comprendre les différences entre fichier .env, interpolation YAML et variables dans le conteneur

Étapes du TP

Préparer les valeurs du projet

  1. Étape 1 : Créer le fichier .env

    Copier le modèle livré dans le dossier de niveau 2 ; vérifier la différence entre modèle partagé et valeurs propres au poste.

    cp .env.example .env

    Un fichier .env est présent et n’est pas destiné à être versionné.

  2. Étape 2 : Identifier les variables d’images

    Repérer DEBIAN_TAG, PHP_VERSION, NODE_VERSION, NGINX_VERSION, MARIADB_VERSION, PHPMYADMIN_VERSION et MAILPIT_VERSION.

    Les versions servent à sélectionner une base de build ou un tag d’image.

  3. Étape 3 : Identifier les ports et identifiants

    Repérer APP_PORT, API_PORT, PHPMYADMIN_PORT, MAILPIT_PORT et les paramètres DB_*.

    La correspondance entre valeurs .env et ports/variables runtime est expliquée.

  4. Étape 4 : Distinguer .env et environment

    Comprendre qu’une variable du .env n’apparaît pas automatiquement dans un conteneur : elle doit être référencée dans Compose si nécessaire.

    Les variables injectées dans api et db sont précisément identifiées.

Paramétrer Dockerfiles avec ARG et ENV

  1. Étape 5 : Configurer Debian et PHP au build

    Introduire ARG DEBIAN_TAG avant FROM, puis ARG PHP_VERSION pour choisir le nom des paquets installés par APT.

    Le rôle des deux ARG et leur portée sont connus.

  2. Étape 6 : Vérifier la disponibilité réelle de PHP

    Ne pas supposer qu’une valeur arbitraire de PHP_VERSION existe dans les dépôts de l’image Debian sélectionnée.

    L’étudiant sait expliquer un échec d’apt-get dû à une version non disponible.

  3. Étape 7 : Renseigner ENV pour l’API

    Utiliser ENV APP_ENV=development et reconnaître qu’une valeur ENV peut être surchargée par Compose.

    APP_ENV est visible à l’exécution et distinct des ARG de build.

  4. Étape 8 : Paramétrer le build multi-stage du front

    Définir NODE_VERSION avant FROM node et NGINX_VERSION avant FROM nginx, avec une portée correcte pour chaque étape.

    Les deux étapes du Dockerfile sélectionnent les versions attendues.

Interpréter et appliquer Compose

  1. Étape 9 : Injecter les arguments de build

    Compléter build.args pour api et app en utilisant les variables `${…}` du fichier .env.

    La configuration résolue contient les arguments de build attendus.

  2. Étape 10 : Rendre images et ports paramétrables

    Utiliser l’interpolation sur les tags MariaDB/phpMyAdmin/Mailpit et les ports publiés côté hôte.

    Les valeurs sont centralisées sans modifier les sources Compose.

  3. Étape 11 : Connaître les valeurs par défaut et obligatoires

    Expliquer `${VAR:-valeur}` et `${VAR:?message}` ; analyser l’erreur produite en cas de variable requise manquante.

    Compose refuse une configuration privée d’une variable obligatoire.

  4. Étape 12 : Afficher la configuration effectivement résolue

    Vérifier l’interpolation en évitant de partager les sorties contenant des identifiants.

    docker compose config --environment && docker compose config

    Les tags, ports et build.args correspondent au .env.

  5. Étape 13 : Reconstruire et redémarrer la stack

    Reconstruire les images personnalisées et vérifier les services, puis l’accès HTML/API.

    docker compose up -d --build && docker compose ps

    Les cinq services sont actifs et le Hello World fonctionne.

Tester les conséquences d’un changement

  1. Étape 14 : Tester un port personnalisé

    Changer temporairement APP_PORT dans .env, recréer les services si nécessaire, puis contrôler la nouvelle URL.

    docker compose up -d && docker compose ps

    Le navigateur répond sur le port hôte indiqué dans .env.

  2. Étape 15 : Vérifier l’environnement du conteneur

    Observer APP_ENV dans le conteneur API et décrire la différence entre build et runtime.

    docker compose exec api printenv APP_ENV

    La valeur retournée est cohérente avec la configuration.

  3. Étape 16 : Comprendre les limites du volume MariaDB

    Expliquer pourquoi modifier DB_PASSWORD ne change pas automatiquement un utilisateur déjà créé dans le volume existant.

    L’étudiant identifie le risque associé à down -v (destruction des données).

  4. Étape 17 : Justifier la protection des secrets

    Contrôler .gitignore, ne pas publier les mots de passe du TP, citer une solution de secrets pour un contexte réel.

    Le fichier .env sensible est exclu du dépôt et les limites de la méthode sont comprises.

Ressources

Traefik et reverse proxy

Centraliser l’entrée HTTP, router par hôte et chemin et isoler les réseaux.

3h30 · indicatif Réseau et exposition 18 étapes

Résultat attendu

Traefik expose l’application, l’API, phpMyAdmin et Mailpit depuis un seul port HTTP local, tandis que MariaDB reste sur le réseau interne.

Prérequis

  • Niveaux 1 et 2 acquis ou architecture Docker maîtrisée
  • Pack étudiants : dossier ateliers/niveau-3/
  • Comprendre publication de ports, résolution DNS et reverse proxy

Étapes du TP

Introduire le reverse proxy

  1. Étape 1 : Récupérer le niveau 3 et son environnement

    Copier .env.example vers .env, examiner le compose.yaml fourni et comparer les ports à ceux du niveau 2.

    cp .env.example .env

    Le fichier d’environnement existe et les services sont identifiés.

  2. Étape 2 : Décrire un reverse proxy

    Expliquer comment un point d’entrée HTTP reçoit une requête puis l’envoie vers un service interne sur la base d’une règle.

    Le chemin navigateur → Traefik → app/API/outils est correctement décrit.

  3. Étape 3 : Configurer le service Traefik

    Déclarer une image Traefik, le provider Docker, l’entrypoint web et le tableau de bord, en limitant l’exposition au poste local.

    Traefik écoute sur l’entrée HTTP configurée.

  4. Étape 4 : Comprendre le socket Docker

    Analyser le montage /var/run/docker.sock:ro nécessaire à la découverte automatique et son risque de sécurité.

    Le montage est identifié comme sensible, non adapté tel quel à une exposition Internet.

  5. Étape 5 : Publier un seul port HTTP

    Publier 127.0.0.1:8088:80 sur Traefik et retirer les publications directes inutiles des services applicatifs.

    L’accès HTTP externe se fait uniquement via Traefik.

Créer les routes via labels Docker

  1. Étape 6 : Activer explicitement la découverte

    Configurer exposedbydefault=false, puis les labels traefik.enable=true uniquement pour les services à exposer.

    Un service sans label approprié n’est pas publié.

  2. Étape 7 : Router le frontend

    Créer la règle Host(`tp.localhost`) vers le port interne Nginx 80.

    L’interface est accessible à http://tp.localhost:8088.

  3. Étape 8 : Router l’API sur /api

    Configurer Host(`tp.localhost`) && PathPrefix(`/api`) vers le port 8000 ; régler la priorité si nécessaire.

    L’appel /api/hello est pris en charge par l’API, pas par Nginx.

  4. Étape 9 : Router phpMyAdmin

    Créer db.tp.localhost vers le port interne 80.

    phpMyAdmin répond sur son sous-domaine de laboratoire.

  5. Étape 10 : Router Mailpit

    Créer mail.tp.localhost vers le port interne 8025.

    L’interface Mailpit est accessible via Traefik.

  6. Étape 11 : Activer un tableau de bord de laboratoire

    Configurer un routeur vers api@internal puis ouvrir /dashboard/ avec le slash terminal.

    Le dashboard Traefik local décrit les routeurs et services détectés.

Séparer les communications réseau

  1. Étape 12 : Définir un réseau proxy

    Raccorder Traefik et les services web au réseau proxy ; fixer le label traefik.docker.network lorsqu’un service possède plusieurs réseaux.

    Traefik joint app, api, phpMyAdmin et mailer.

  2. Étape 13 : Définir un réseau backend interne

    Raccorder db, api, phpmyadmin et mailer au réseau backend: internal: true ; exclure db du réseau proxy.

    La base n’a aucune publication de port sur l’hôte.

  3. Étape 14 : Expliquer le DNS interne

    Justifier pourquoi DB_HOST=db et SMTP_HOST=mailer restent utilisables entre services même après introduction de Traefik.

    La communication interne ne dépend pas des noms *.localhost.

Démarrer, vérifier et sécuriser

  1. Étape 15 : Analyser et lancer Compose

    Résoudre les références de réseaux, labels et ports, puis démarrer la stack.

    docker compose config && docker compose up -d --build

    La stack est opérationnelle et Traefik démarre correctement.

  2. Étape 16 : Tester le routage de l’API

    Vérifier Host et PathPrefix en appelant le port Traefik ; utiliser Host explicite si *.localhost n’est pas résolu.

    curl -i -H "Host: tp.localhost" http://127.0.0.1:8088/api/hello

    La réponse JSON de l’API est renvoyée par Traefik.

  3. Étape 17 : Valider les quatre interfaces

    Tester tp.localhost:8088, db.tp.localhost:8088, mail.tp.localhost:8088, et traefik.tp.localhost:8088/dashboard/.

    Chaque interface répond et l’API envoie toujours les mails vers Mailpit.

  4. Étape 18 : Inspecter puis nettoyer

    Examiner les logs de Traefik et les réseaux ; arrêter proprement sans supprimer le volume DB.

    docker compose logs --tail=80 traefik && docker compose down

    Les routes sont comprises ; les données du volume ne sont pas effacées.

Ressources

Dans la même série Étape 2 sur 2

  1. 1 Cours Docker & Docker Compose — Le cours
  2. 2 TP TP Docker & Docker Compose Vous êtes ici

Partager cet article

Dans la même catégorie

Cours

Infra · Intermédiaire

Docker & Docker Compose — Le cours

Images, conteneurs, volumes, réseaux et Compose : le lexique, les commandes essentielles et les bonnes pratiques.

3 guides · 132 notions Dans la même série

Cours

Infra · Intermédiaire

Kubernetes — Le cours

Pods, déploiements, services, configuration et stockage : orchestrer des conteneurs, de la théorie à kubectl.

3 guides · 159 notions Dans la même série

Cours

Infra · Intermédiaire

Terraform & Ansible — Le cours

Décrire l'infrastructure avec Terraform et la configurer avec Ansible : providers, playbooks, rôles et idempotence.

3 guides · 146 notions Dans la même série