abonnel-www/0297ae4d-23ba-44cc-ba52-ec6ed48a4cbc/index.md

Étude d'une configuration Docker Compose

Docker Compose est un outil qui permet de décrire et de gérer des applications multi-conteneurs. Le fichier docker-compose.yml est utilisé pour définir la configuration des services d'une application et les paramètres nécessaires à son exécution.

Le fichier docker-compose.yml est généralement écrit en format YAML (Yet Another Markup Language) et il contient les informations suivantes :

• Services : Il s'agit des différents conteneurs qui composent votre application. Chaque service est défini avec un nom et peut spécifier l'image Docker à utiliser, les volumes à monter, les ports à exposer, les variables d'environnement, etc.
• Réseaux : Vous pouvez spécifier les réseaux auxquels les conteneurs doivent être connectés, ainsi que les paramètres réseau spécifiques à chaque service.
• Volumes : Vous pouvez définir des volumes pour partager des données entre les conteneurs ou pour stocker des données persistantes.
• Variables d'environnement : Vous pouvez définir des variables d'environnement spécifiques à chaque service, qui seront accessibles depuis les conteneurs.
• Dépendances : Vous pouvez spécifier des dépendances entre les services, ce qui permet de contrôler l'ordre de démarrage et de garantir que les services dépendants sont prêts avant que d'autres services ne démarrent.

Une fois que vous avez défini votre configuration dans le fichier docker-compose.yml, vous pouvez utiliser la commande docker compose up pour démarrer tous les conteneurs et les services correspondants en fonction de cette configuration.

---

1. Pourquoi utiliser Docker Compose ?

Avant Docker Compose, démarrer une application composée de plusieurs services (par exemple une application web + une base de données + un cache Redis) imposait de lancer manuellement chaque conteneur avec docker run, en précisant à chaque fois les ports, les volumes, les variables d'environnement et les liens réseau. Cette approche est :

• répétitive : la même commande complexe doit être tapée à chaque démarrage,
• source d'erreurs : un paramètre oublié et l'application ne fonctionne plus,
• peu reproductible : difficile de partager exactement la même configuration entre développeurs.

Docker Compose résout ces problèmes en regroupant toute la description de l'application dans un seul fichier versionnable (que l'on peut placer sous Git). Un nouveau développeur peut cloner le projet et lancer toute la stack avec une seule commande.

2. Structure générale d'un fichier docker-compose.yml

Voici un exemple commenté pour une application web avec une base de données :

services:
  web:
    image: nginx:latest          # Image Docker à utiliser
    ports:
      - "8080:80"                # Port hôte:Port conteneur
    volumes:
      - ./html:/usr/share/nginx/html
    depends_on:
      - db                       # Démarre après le service "db"
    networks:
      - frontend

  db:
    image: postgres:16
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: monapp
    volumes:
      - db-data:/var/lib/postgresql/data
    networks:
      - frontend

volumes:
  db-data:                       # Volume nommé, géré par Docker

networks:
  frontend:                      # Réseau personnalisé
    driver: bridge

Analyse pédagogique de cet exemple

Deux services sont définis : web (un serveur Nginx) et db (une base PostgreSQL). Le service web expose le port 80 du conteneur sur le port 8080 de la machine hôte, ce qui signifie qu'en ouvrant http://localhost:8080 dans un navigateur, on accède au Nginx du conteneur. Le service db n'expose aucun port vers l'extérieur : il ne sera accessible que depuis les autres conteneurs du même réseau frontend, ce qui est une bonne pratique de sécurité.

Le volume nommé db-data permet à PostgreSQL de persister ses données même si le conteneur est détruit et recréé. Sans cela, toutes les données seraient perdues à chaque redémarrage.

La directive depends_on garantit que db démarre avant web. Attention : cela garantit l'ordre de démarrage des conteneurs, mais pas que la base de données soit prête à accepter des connexions. Pour cela, il faut utiliser une healthcheck.

3. Les sections principales en détail

Les services

Chaque service correspond à un conteneur (ou un groupe de conteneurs si on utilise la directive replicas). Les clés les plus courantes sont :

Clé	Rôle
image	Image Docker à télécharger depuis un registre (Docker Hub par défaut)
build	Alternative à image : construit l'image à partir d'un Dockerfile local
ports	Mappe les ports entre l'hôte et le conteneur
volumes	Monte des dossiers ou volumes dans le conteneur
environment	Définit des variables d'environnement
depends_on	Indique les services qui doivent démarrer avant
restart	Politique de redémarrage (no, always, on-failure, unless-stopped)
networks	Réseaux auxquels le conteneur est connecté

Les volumes

Il existe trois types de volumes :

1. Bind mount : ./html:/usr/share/nginx/html — un dossier de l'hôte est monté dans le conteneur. Pratique en développement pour voir ses modifications en direct.
2. Volume nommé : db-data:/var/lib/postgresql/data — Docker gère lui-même l'emplacement de stockage. Recommandé en production.
3. Volume anonyme : /var/lib/postgresql/data — sans nom, plus difficile à réutiliser.

Les réseaux

Par défaut, Docker Compose crée automatiquement un réseau pour le projet, et tous les services y sont connectés. Au sein de ce réseau, les services se trouvent par leur nom : depuis le conteneur web, on peut joindre la base de données simplement avec le nom d'hôte db (par exemple postgresql://admin:secret@db:5432/monapp). C'est une notion fondamentale et souvent mal comprise des débutants.

4. Les commandes essentielles

docker compose up              # Démarre tous les services (mode interactif)
docker compose up -d           # Démarre en arrière-plan (detached)
docker compose down            # Arrête et supprime les conteneurs
docker compose down -v         # Idem + supprime les volumes (⚠️ perte de données)
docker compose ps              # Liste les services en cours
docker compose logs -f web     # Affiche les logs du service "web" en continu
docker compose exec web bash   # Ouvre un shell dans le conteneur "web"
docker compose build           # (Re)construit les images définies avec "build:"
docker compose restart db      # Redémarre uniquement le service "db"

Note : la version moderne s'écrit docker compose (avec un espace), intégrée au CLI Docker. L'ancienne forme docker-compose (avec un tiret) correspond à un binaire Python séparé, encore fonctionnel mais en voie de dépréciation.

5. Le cycle de vie d'une application Compose

Lorsqu'on exécute docker compose up, Docker effectue dans l'ordre :

1. Lecture et validation du fichier docker-compose.yml.
2. Création des réseaux déclarés (s'ils n'existent pas).
3. Création des volumes déclarés (s'ils n'existent pas).
4. Téléchargement des images manquantes (ou construction si build: est utilisé).
5. Création et démarrage des conteneurs, en respectant l'ordre imposé par depends_on.
6. Connexion des conteneurs aux réseaux et montage des volumes.

À l'arrêt avec docker compose down, Docker fait l'inverse : il arrête puis supprime les conteneurs et les réseaux. Les volumes sont conservés par défaut pour préserver les données.

6. Bonnes pratiques pédagogiques à retenir

Quand on enseigne ou découvre Docker Compose, quelques principes méritent d'être martelés :

• Un service = un processus principal. Ne pas chercher à faire tourner Nginx + PHP + MySQL dans le même conteneur : on perd tout l'intérêt de Compose.
• Ne jamais mettre de mots de passe en clair dans le fichier YAML versionné. Utiliser un fichier .env (référencé par Compose) ou les secrets Docker.
• Toujours nommer ses volumes pour les données importantes ; les volumes anonymes sont difficiles à retrouver.
• Vérifier qu'un service est réellement prêt avec une healthcheck, pas seulement démarré.
• Versionner le docker-compose.yml mais pas le .env (le mettre dans .gitignore).

7. Exercice de compréhension suggéré

Pour fixer les notions, un exercice classique consiste à demander aux apprenants de :

1. écrire un docker-compose.yml pour une application WordPress (service wordpress + service mysql),
2. faire en sorte que les données MySQL et les fichiers WordPress soient persistants,
3. exposer WordPress sur le port 8000 de l'hôte,
4. vérifier qu'en supprimant les conteneurs et en les recréant, les articles publiés sont toujours là.

Cet exercice mobilise tous les concepts clés : services, images, ports, volumes nommés, variables d'environnement et communication inter-conteneurs par nom de service.