08

Le Pouvoir Declaratif (Docker Compose)

Fuir les commandes à rallonge pour l'orchestration locale en YAML

À mesure qu'une application backend évolue, un simple serveur monolithique explose en micro-services (Une BDD Postgres, un Cache Redis, un Proxy nginx, 3 Workers Python, une API Node.js).

Lancer manuellement chaque docker run avec ses 15 flags de port / réseau / variable est inhumain et non versionnable. C'est ici qu'intervient le miracle de l'infrastructure as Code (IaC) : **Docker Compose**.

Impératif vs Déclaratif

❌ Impératif (L'Enfer d'intégration)

docker network create app-net
docker volume create pg-data
docker run -d --name redis --network app-net redis:alpine
docker run -d --name db -v pg-data:/var/lib/postgresql/data -e POSTGRES_PASSWORD=sec --network app-net postgres
docker run -d --name api -p 3000:3000 -e REDIS_URL=redis:6379 -e DB_URL=postgres://db --network app-net mon-api

✅ Déclaratif (Le Saint Graal Compose)

Vous écrivez l'Éttat Final Désiré dans un unique fichier central : docker-compose.yml. Docker s'occupe de créer les réseaux, volumes et de démarrer les conteneurs intelligemment. Vous mettez ce fichier sur Git, et n'importe quel dev peut cloner et lancer le projet avec UNE commande.

Anatomie du docker-compose.yml

Le fichier Compose YAML est structuré autour de clés maîtresses. La plus vitale est services:. (Note : Compose v2 ne nécessite plus de spécifier une `version: '3.x'` en première ligne, c'est obsolète).

docker-compose.yml (Exemple Stack MERN complète)
# On liste nos différents processus vitaux (nos conteneurs)
services:

  # 1. Le Frontend Web React
  react-frontend:
    build: 
      context: ./frontend      # Indique à Compose de builder le Dockerfile localement
    ports:
      - "80:80"                # Expose le trafic Web
    depends_on:
      - node-backend           # Bloque le démarrage jusqu'à que l'API soit lancée

  # 2. Le Backend Node.js / Express
  node-backend:
    build: ./backend
    environment:               # Remplace les innombrables flags -e de docker run
      - MONGO_URI=mongodb://mongo-db:27017/myapp  # Magie DNS : Le nom du service en dessous !
      - JWT_SECRET=super_secret
    ports:
      - "3000:3000"
    restart: unless-stopped    # Auto-Heal (La cicatrisation s'il crash)

  # 3. La Base de Données NoSQL (MongoDB) Isolée
  mongo-db:
    image: mongo:6.0
    volumes:                   # Redirection vitale des données pour la persistance
      - mongo_data:/data/db
    # Pas de ports exposés ici ! Sécurité maximale.

# Déclaration expresse du Volume Hôte (Nécessaire)
volumes:
  mongo_data:
🪄 La Magie Souterraine du Réseau Vous remarquez qu'il n'y a pas de section networks: dans cet exemple. Par défaut, Docker Compose crée automatiquement un pont réseau isolé au nom du dossier projet, et y engloutit tous vos services. Ils peuvent alors se "pinger" via leur nom (ex: database ou api_backend).

La Baguette Magique : Commandes Compose v2

⚠️ Attention : Ne tapez plus `docker-compose` avec un tiret (c'est l'ancienne version Python v1 obsolète). Tapez docker compose (avec un espace), natif en Go dans le Daemon Docker.

Terminal
# Démarrer la galaxie complète (Le -d rend la main au terminal)
docker compose up -d

# Arrêter l'univers complet ET nettoyer le réseau bridge (-v purgera aussi les volumes ! Prudence avec le flag -v)
docker compose down

# Voir le statut de tous les conteneurs (Up, Exited, Ports)
docker compose ps

# Regarder le flux de logs MÊLÉ et colloré de l'ensemble des conteneurs 
docker compose logs -f

# Stopper subtilement seulement un élément sans toucher la BDD
docker compose stop node-backend
docker compose start node-backend

# Retrigger un Build local complet (très utile si vous modifiez le package.json)
docker compose build --no-cache

# Entrer dans le terminal Bash d'un conteneur en cours d'exécution (Plus besoin de chercher l'ID aléatoire !)
docker compose exec node-backend sh

La Révolution du Hot Reload : compose watch (2024+)

Historiquement, pour développer en direct, on montait des volumes (Bind Mounts) fastidieux pour synchroniser le code de notre IDE avec les conteneurs. Récemment, Docker a sorti une fonctionnalité surpuissante : Docker Compose Watch.

Complétez votre fichier `docker-compose.yml` avec l'attribut develop. Au lieu d'utiliser le système de fichiers lent de Windows/Mac, le Daemon Docker observe vos fichiers locaux scrupuleusement et injecte les changements à la volée, ou re-construit l'image seulement si justifié.

Extrait du docker-compose.yml
services:
  react-frontend:
    build: ./frontend
    develop:
      watch:
        # Action Sync : Copie instantanée du JS/CSS sans redémarrer (Hot Module Replacement)
        - action: sync
          path: ./frontend/src
          target: /app/src
        
        # Action Rebuild : Si on touche au package.json, on a besoin d'un NPM INSTALL, donc on Rebuild !
        - action: rebuild
          path: ./frontend/package.json
On utilise "watch" au lieu de "up"
# Lance les conteneurs ET active l'observation des fichiers en live
docker compose watch
← Précédent