Docker Compose 🎼

Pourquoi Docker Compose ?

Quand une application a plusieurs services (app, BDD, cache…), gérer chaque conteneur séparément est un cauchemar :

# Sans Compose : 4 commandes pour démarrer
docker network create app-net
docker run -d --name postgres --network app-net -e POSTGRES_PASSWORD=secret postgres:15
docker run -d --name redis --network app-net redis:alpine
docker run -d --name app --network app-net -p 3000:3000 mon-app

Avec Docker Compose : un seul fichier docker-compose.yml.

---

Le fichier docker-compose.yml

version: '3.8'

services:
  # Service 1 : Application Node.js
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DB_HOST=postgres
      - DB_PORT=5432
      - REDIS_HOST=redis
    depends_on:
      - postgres
      - redis
    networks:
      - app-network
    restart: unless-stopped

  # Service 2 : PostgreSQL
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: mabase
    volumes:
      - pgdata:/var/lib/postgresql/data
    networks:
      - app-network
    restart: unless-stopped

  # Service 3 : Redis
  redis:
    image: redis:alpine
    networks:
      - app-network
    restart: unless-stopped

# Volumes persistants
volumes:
  pgdata:

# Réseau dédié
networks:
  app-network:
    driver: bridge

---

Commandes Docker Compose

# Démarrer tous les services (arrière-plan)
docker compose up -d

# Voir les services en cours
docker compose ps

# Résultat :
# NAME       IMAGE                  STATUS          PORTS
# app        mon-app                Up 2 minutes   0.0.0.0:3000->3000/tcp
# postgres   postgres:15-alpine     Up 2 minutes   5432/tcp
# redis      redis:alpine           Up 2 minutes   6379/tcp

# Voir les logs
docker compose logs -f app

# Arrêter tous les services
docker compose down

# Arrêter et supprimer les volumes
docker compose down -v

# Reconstruire les images
docker compose build

# Redémarrer un service
docker compose restart app

# Exécuter une commande dans un service
docker compose exec app bash

---

Les clés essentielles

---

Exemple : Application Laravel + MySQL + Redis

version: '3.8'

services:
  laravel:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "8000:80"
    environment:
      DB_CONNECTION: mysql
      DB_HOST: mysql
      DB_PORT: 3306
      DB_DATABASE: laravel
      DB_USERNAME: laravel
      DB_PASSWORD: secret
      REDIS_HOST: redis
    volumes:
      - ./src:/var/www/html
    depends_on:
      - mysql
      - redis
    networks:
      - laravel-network

  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: rootsecret
      MYSQL_DATABASE: laravel
      MYSQL_USER: laravel
      MYSQL_PASSWORD: secret
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - laravel-network

  redis:
    image: redis:alpine
    networks:
      - laravel-network

volumes:
  mysql-data:

networks:
  laravel-network:
    driver: bridge

---

Exemple : Application React + Nginx

version: '3.8'

services:
  frontend:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "80:80"
    depends_on:
      - api

  api:
    build:
      context: ../api
      dockerfile: Dockerfile
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgres://user:pass@db:5432/mydb
    depends_on:
      - db

  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
      POSTGRES_DB: mydb
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

---

Variables d'environnement avec .env

# .env (à la racine du projet)
DB_PASSWORD=secret123
APP_PORT=3000

# docker-compose.yml
services:
  app:
    ports:
      - "${APP_PORT}:3000"
    environment:
      - DB_PASSWORD=${DB_PASSWORD}

---

Exercices 🎯

1. Setup : Créez un docker-compose.yml avec Node.js + PostgreSQL.
2. Lancement : Lancez avec docker compose up -d et vérifiez avec docker compose ps.
3. Logs : Voyez les logs de chaque service avec docker compose logs.
4. Multi-service : Ajoutez Redis à votre architecture.

Prochaine leçon : Dockeriser une application Node.js.