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
Fondations Docker Compose
Construire et lancer une application multi-services avec deux Dockerfiles personnalisés.
3h30 · indicatif Fondations 18 étapes
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/
Prendre en main le projet
-
Étape 1 : Vérifier les prérequis
Expliquer la différence entre Docker Engine, image, conteneur et Compose.
docker version && docker compose versionLes versions s’affichent sans erreur.
-
É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.
-
É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
-
É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/DockerfileLe Dockerfile identifie correctement son image de base et son répertoire de travail.
-
É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.
-
É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.
-
É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.
-
É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.
-
É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
-
É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.
-
É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.
-
É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.
-
É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 --buildLa commande termine sans erreur et construit api et app.
-
É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 apiLes services utiles sont en cours d’exécution et MariaDB devient healthy.
Vérifier le fonctionnement de bout en bout
-
É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/helloLa page affiche les informations transmises par l’API.
-
É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.
-
É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.
-
Étape 18 : Arrêter sans perdre les volumes
Arrêter la stack et expliquer la différence entre down et down -v.
docker compose downLes conteneurs et le réseau sont supprimés ; les volumes nommés sont conservés.
Ressources
- Docker Compose — concepts — Comprendre projet, service, réseau et volume
- Référence du Dockerfile — Définition des instructions FROM, RUN, COPY, CMD, ARG et ENV
- Docker Compose — référence des services — Syntaxe des services, ports, environment, build et depends_on
- Build multi-stage — Utiliser Node au build sans le conserver dans le conteneur final
- Sass — CLI — Compiler des fichiers SCSS
- Mailpit — images Docker — Interface de capture de mails et port SMTP interne
- phpMyAdmin — image Docker — Paramètres PMA_HOST et connexion à MariaDB
Configuration dynamique avec .env
Externaliser les valeurs, paramétrer les builds et distinguer ARG, ENV et interpolation Compose.
3h30 · indicatif Paramétrage 17 étapes
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
Préparer les valeurs du projet
-
É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 .envUn fichier .env est présent et n’est pas destiné à être versionné.
-
É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.
-
É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.
-
É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
-
É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.
-
É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.
-
É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.
-
É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
-
É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.
-
É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.
-
É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.
-
É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 configLes tags, ports et build.args correspondent au .env.
-
É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 psLes cinq services sont actifs et le Hello World fonctionne.
Tester les conséquences d’un changement
-
É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 psLe navigateur répond sur le port hôte indiqué dans .env.
-
É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_ENVLa valeur retournée est cohérente avec la configuration.
-
É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).
-
É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
- Docker Compose — concepts — Comprendre projet, service, réseau et volume
- Référence du Dockerfile — Définition des instructions FROM, RUN, COPY, CMD, ARG et ENV
- Variables et interpolation Compose — Syntaxes ${VAR}, ${VAR:-defaut} et ${VAR:?obligatoire}
- Variables dans les conteneurs — Comportement de la clé environment
- ARG et ENV dans Dockerfile — Portée et usages des arguments de build et variables d’environnement
- Sécurité des secrets Docker — Pourquoi .env ne constitue pas un coffre-fort à secrets
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
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
Introduire le reverse proxy
-
É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 .envLe fichier d’environnement existe et les services sont identifiés.
-
É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.
-
É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.
-
É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.
-
É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
-
É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é.
-
É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.
-
É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.
-
Étape 9 : Router phpMyAdmin
Créer db.tp.localhost vers le port interne 80.
phpMyAdmin répond sur son sous-domaine de laboratoire.
-
Étape 10 : Router Mailpit
Créer mail.tp.localhost vers le port interne 8025.
L’interface Mailpit est accessible via Traefik.
-
É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
-
É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.
-
É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.
-
É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
-
É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 --buildLa stack est opérationnelle et Traefik démarre correctement.
-
É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/helloLa réponse JSON de l’API est renvoyée par Traefik.
-
É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.
-
É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 downLes routes sont comprises ; les données du volume ne sont pas effacées.
Ressources
- Docker Compose — concepts — Comprendre projet, service, réseau et volume
- Référence du Dockerfile — Définition des instructions FROM, RUN, COPY, CMD, ARG et ENV
- Traefik — provider Docker — Découverte des services via le provider Docker
- Traefik — routeurs HTTP — Règles Host, PathPrefix et priorité des routes
- Réseaux Compose — Réseaux isolés, DNS Docker et connectivité des services
- Sécurité de Docker Engine — Risques liés à l’accès au daemon et au socket Docker
Dans la même série Étape 2 sur 2
- 1 Cours Docker & Docker Compose — Le cours
-
2 TP TP Docker & Docker Compose Vous êtes ici
Dans la même catégorie
Infra · Intermédiaire
Docker & Docker Compose — Le cours
Images, conteneurs, volumes, réseaux et Compose : le lexique, les commandes essentielles et les bonnes pratiques.
Infra · Intermédiaire
Kubernetes — Le cours
Pods, déploiements, services, configuration et stockage : orchestrer des conteneurs, de la théorie à kubectl.
Infra · Intermédiaire
Terraform & Ansible — Le cours
Décrire l'infrastructure avec Terraform et la configurer avec Ansible : providers, playbooks, rôles et idempotence.