Docker Compose : déployer une application multi-conteneurs en 15 minutes

Docker Compose, c'est quoi ?

Docker Compose est un outil qui permet de définir et d'exécuter des applications Docker composées de plusieurs conteneurs. Toute la configuration de vos services, réseaux et volumes est centralisée dans un seul fichier : docker-compose.yml.

L'analogie la plus parlante : imaginez un chef d'orchestre. Chaque musicien (conteneur) joue sa partition, mais c'est le chef (Compose) qui coordonne l'ensemble : qui démarre quand, qui communique avec qui, et où sont stockées les partitions (données).

Concrètement, Docker Compose vous permet de :

• Décrire votre stack complète dans un fichier versionnable (Git)
• Lancer tous vos conteneurs en une seule commande : docker compose up
• Arrêter tout proprement avec docker compose down
• Reproduire le même environnement partout : dev, test, production
• Partager votre configuration avec n'importe quel membre de l'équipe

Avec vs sans Docker Compose

Pour comprendre l'intérêt de Compose, comparons deux approches pour déployer la même application : un blog WordPress avec sa base de données MySQL.

Sans Docker Compose : commandes manuelles

Vous devez exécuter chaque conteneur séparément, dans le bon ordre, en vous souvenant de toutes les options :

# 1. Créer un réseau pour que les conteneurs communiquent
docker network create wp-network

# 2. Lancer MySQL avec toutes les variables
docker run -d \
  --name mysql-db \
  --network wp-network \
  -e MYSQL_ROOT_PASSWORD=monmotdepasse \
  -e MYSQL_DATABASE=wordpress \
  -e MYSQL_USER=wpuser \
  -e MYSQL_PASSWORD=wppass \
  -v mysql-data:/var/lib/mysql \
  mysql:8.0

# 3. Lancer WordPress en le reliant à MySQL
docker run -d \
  --name wordpress-app \
  --network wp-network \
  -e WORDPRESS_DB_HOST=mysql-db \
  -e WORDPRESS_DB_USER=wpuser \
  -e WORDPRESS_DB_PASSWORD=wppass \
  -e WORDPRESS_DB_NAME=wordpress \
  -p 8080:80 \
  -v wp-content:/var/www/html \
  wordpress:latest

Problèmes : commandes longues, ordre de lancement important, configuration dispersée, difficile à partager.

Avec Docker Compose : un seul fichier

La même chose en un fichier docker-compose.yml :

services:
  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: monmotdepasse
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wpuser
      MYSQL_PASSWORD: wppass
    volumes:
      - mysql-data:/var/lib/mysql

  wordpress:
    image: wordpress:latest
    depends_on:
      - mysql
    ports:
      - "8080:80"
    environment:
      WORDPRESS_DB_HOST: mysql
      WORDPRESS_DB_USER: wpuser
      WORDPRESS_DB_PASSWORD: wppass
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - wp-content:/var/www/html

volumes:
  mysql-data:
  wp-content:

Puis une seule commande :

docker compose up -d

Anatomie d'un fichier docker-compose.yml

Un fichier Compose repose sur 3 concepts fondamentaux :

Voici la structure type d'un fichier docker-compose.yml annoté :

# Pas besoin de "version:" depuis Compose V2

services:
  # Service 1 : votre application web
  web:
    image: nginx:latest          # Image à utiliser
    ports:
      - "8080:80"                # Port hôte:port conteneur
    volumes:
      - ./html:/usr/share/nginx/html  # Bind mount (dev)
    depends_on:
      - db                       # Lance db avant web
    restart: unless-stopped      # Redémarre sauf arrêt manuel

  # Service 2 : base de données
  db:
    image: mysql:8.0
    environment:                 # Variables d'environnement
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: app
    volumes:
      - db-data:/var/lib/mysql   # Volume nommé (persistant)

# Déclaration des volumes nommés
volumes:
  db-data:

Exercice pratique : déployer WordPress + MySQL

Passons à la pratique. En 5 étapes, vous allez déployer un blog WordPress complet avec sa base de données.

1. Créer un dossier de projet

   mkdir mon-wordpress && cd mon-wordpress

2. Créer le fichier docker-compose.yml

   Créez un fichier docker-compose.yml avec le contenu suivant :

   services:
     db:
       image: mysql:8.0
       restart: unless-stopped
       environment:
         MYSQL_ROOT_PASSWORD: rootpassword
         MYSQL_DATABASE: wordpress
         MYSQL_USER: wpuser
         MYSQL_PASSWORD: wppassword
       volumes:
         - db-data:/var/lib/mysql
   
     wordpress:
       image: wordpress:latest
       restart: unless-stopped
       depends_on:
         - db
       ports:
         - "8080:80"
       environment:
         WORDPRESS_DB_HOST: db
         WORDPRESS_DB_USER: wpuser
         WORDPRESS_DB_PASSWORD: wppassword
         WORDPRESS_DB_NAME: wordpress
       volumes:
         - wp-data:/var/www/html
   
   volumes:
     db-data:
     wp-data:

3. Lancer la stack

   docker compose up -d

   Le flag -d lance les conteneurs en arrière-plan. La première exécution télécharge les images (environ 1 minute).

4. Vérifier que tout fonctionne

   docker compose ps

   Vous devriez voir 2 conteneurs avec le statut "Up".

5. Ouvrir WordPress dans le navigateur

   Rendez-vous sur http://localhost:8080. L'assistant d'installation WordPress s'affiche. Votre stack fonctionne.

Pour tout arrêter et nettoyer :

# Arrêter les conteneurs (conserve les données)
docker compose down

# Arrêter ET supprimer les volumes (perte des données)
docker compose down -v

Les commandes essentielles

Volumes et persistance des données

Sans volume, les données d'un conteneur disparaissent lorsqu'il est supprimé. En production, c'est inacceptable pour une base de données ou des fichiers uploadés. Docker Compose gère deux types de volumes :

Les volumes nommés sont déclarés dans la section volumes: en bas du fichier. Ils survivent à docker compose down (sauf avec le flag -v). Les bind mounts lient un dossier de votre machine au conteneur, ce qui est idéal en développement pour voir vos modifications en temps réel.

Réseaux et communication entre services

Docker Compose crée automatiquement un réseau interne pour votre stack. Chaque service est accessible par les autres via son nom de service comme nom d'hôte.

Dans notre exemple WordPress, le service wordpress se connecte à MySQL en utilisant simplement db comme adresse. Pas besoin d'adresse IP, pas besoin de configuration réseau manuelle :

WORDPRESS_DB_HOST: db    # "db" = le nom du service MySQL

Ce DNS interne est l'un des atouts majeurs de Docker Compose : chaque service peut contacter les autres par leur nom, de manière transparente et fiable.

Variables d'environnement et fichier .env

Mettre des mots de passe en clair dans docker-compose.yml est une mauvaise pratique, surtout si le fichier est versionné sur Git. La solution : utiliser un fichier .env.

Créez un fichier .env à côté de votre docker-compose.yml :

# .env
MYSQL_ROOT_PASSWORD=monmotdepasse_securise
MYSQL_DATABASE=wordpress
MYSQL_USER=wpuser
MYSQL_PASSWORD=wppassword_securise

Puis référencez ces variables dans votre docker-compose.yml :

services:
  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
      MYSQL_DATABASE: ${MYSQL_DATABASE}
      MYSQL_USER: ${MYSQL_USER}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD}

Bonnes pratiques Docker Compose

• Toujours utiliser restart: unless-stopped — Vos services redémarrent automatiquement après un crash ou un reboot serveur, sauf si vous les arrêtez manuellement.
• Utiliser depends_on — Définit l'ordre de démarrage des services. WordPress dépend de MySQL ? Compose lance MySQL en premier.
• Nommer vos volumes — Un volume nommé (db-data) est plus facile à identifier et gérer qu'un volume anonyme.
• Séparer les environnements — Utilisez un fichier docker-compose.override.yml pour les spécificités de développement (bind mounts, ports de debug).
• Utiliser des images officielles — Privilégiez les images avec le badge "Official" sur Docker Hub. Elles sont maintenues et auditées.
• Valider avant de lancer — docker compose config vérifie la syntaxe de votre fichier et affiche la configuration résolue.
• Externaliser les secrets — Ne jamais commiter de mots de passe. Utilisez un fichier .env ajouté au .gitignore.

Pour aller plus loin

Vous maîtrisez les fondamentaux de Docker Compose. Les sujets suivants vous permettront de passer au niveau supérieur :

• Dockerfile + Compose : construire vos propres images directement dans le fichier Compose avec build:
• Multi-environnement : utiliser des overrides pour adapter la config dev / staging / production
• Healthchecks : vérifier qu'un service est réellement opérationnel avant de démarrer ceux qui en dépendent
• Scaling : lancer plusieurs instances d'un service avec docker compose up --scale web=3
• Docker Swarm / Kubernetes : passer à l'orchestration multi-serveurs pour la production à grande échelle