Docker Compose

Docker Compose est un outil d'orchestration qui permet de définir, configurer et exécuter des applications multi-conteneurs Docker. Grâce à un fichier YAML unique (docker-compose.yml), il simplifie radicalement le déploiement d'architectures complexes comportant plusieurs services interconnectés. Cette approche déclarative transforme des commandes docker run multiples et complexes en une configuration lisible et versionnable.

Fondements de Docker Compose

• Configuration déclarative : définition de l'ensemble de l'infrastructure applicative dans un fichier docker-compose.yml versionnable
• Gestion du cycle de vie : commandes unifiées (up, down, restart) pour contrôler simultanément tous les conteneurs d'un projet
• Réseau isolé : création automatique d'un réseau virtuel permettant la communication inter-conteneurs via des noms de services
• Gestion des dépendances : orchestration du démarrage selon les relations définies entre services (depends_on, healthchecks)

Avantages stratégiques

• Reproductibilité environnementale : garantie d'un environnement de développement identique pour toute l'équipe, éliminant le syndrome "ça marche sur ma machine"
• Simplification opérationnelle : réduction drastique du temps de setup d'un nouveau développeur (de heures à minutes)
• Documentation vivante : le fichier compose sert de documentation technique à jour de l'architecture applicative
• Agilité de développement : facilite les tests d'intégration locaux avec toutes les dépendances (bases de données, caches, services tiers)
• Transition progressive vers production : facilite l'adoption ultérieure de Kubernetes en structurant déjà l'application en services découplés

Exemple concret d'application web complète

version: '3.8'

services:
  # Application Node.js
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=development
      - DATABASE_URL=postgresql://user:pass@db:5432/myapp
      - REDIS_URL=redis://cache:6379
    volumes:
      - ./src:/app/src
      - /app/node_modules
    depends_on:
      db:
        condition: service_healthy
      cache:
        condition: service_started
    networks:
      - app-network

  # Base de données PostgreSQL
  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=myapp
    volumes:
      - postgres-data:/var/lib/postgresql/data
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U user"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - app-network

  # Cache Redis
  cache:
    image: redis:7-alpine
    command: redis-server --appendonly yes
    volumes:
      - redis-data:/data
    networks:
      - app-network

  # Reverse proxy Nginx
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - app
    networks:
      - app-network

volumes:
  postgres-data:
  redis-data:

networks:
  app-network:
    driver: bridge

Cette configuration déploie une stack complète avec application, base de données, cache et reverse proxy. Les services communiquent via un réseau isolé, les données persistent dans des volumes nommés, et les healthchecks garantissent un démarrage ordonné.

Mise en œuvre opérationnelle

1. Installation : installer Docker Desktop (inclut Compose) ou docker-compose standalone via le gestionnaire de paquets système
2. Structuration : créer le fichier docker-compose.yml à la racine du projet avec la définition des services
3. Configuration des services : définir pour chaque service l'image ou le build, les ports, variables d'environnement et volumes
4. Gestion des réseaux : configurer les réseaux personnalisés pour isoler les communications (frontend/backend/data)
5. Lancement : exécuter 'docker-compose up -d' pour démarrer tous les services en arrière-plan
6. Surveillance : utiliser 'docker-compose logs -f' pour suivre les logs agrégés de tous les conteneurs
7. Mise à jour : modifier le fichier compose puis exécuter 'docker-compose up -d' pour appliquer les changements
8. Nettoyage : utiliser 'docker-compose down -v' pour arrêter et supprimer conteneurs, réseaux et volumes

Outils et écosystème associés

• Docker Desktop : intégration GUI pour gérer visuellement les stacks Compose et leurs ressources
• docker-compose-viz : génération automatique de diagrammes d'architecture à partir du fichier compose
• kompose : outil de conversion des fichiers docker-compose.yml vers des manifests Kubernetes
• Portainer : interface web d'administration pour gérer les stacks Compose en production
• docker-compose-wait : utilitaire pour gérer précisément les dépendances de démarrage entre services
• Lazydocker : TUI (Terminal UI) pour monitorer et gérer les conteneurs Docker Compose de manière interactive

Docker Compose représente un investissement stratégique pour toute équipe de développement moderne. En standardisant les environnements et en simplifiant l'orchestration locale, il réduit significativement les frictions techniques, accélère l'onboarding et libère du temps pour la création de valeur métier. Son adoption constitue souvent la première étape vers une architecture microservices et une culture DevOps mature.