Référence Docker Compose - Les commandes les plus utiles avec des exemples

Voici une cheat sheet Docker Compose avec des exemples annotés pour vous aider à maîtriser rapidement les fichiers et commandes Compose.

Ce guide fait partie de Outils de développement : Le guide complet des workflows de développement modernes.

Prérequis

Le moteur Docker doit être installé avant d’utiliser Compose. Sur Ubuntu, suivez Installer Docker sur Ubuntu pour choisir la bonne méthode d’installation et configurer le plugin docker compose.

Référence du fichier Compose : docker-compose.yml

Structure principale :

version: '3'       # Version du format du fichier Compose

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Port hôte 8080 : Port conteneur 80
  db:
    image: postgres
    environment:            # Variables d'environnement
      POSTGRES_PASSWORD: example
    volumes:
      - db_data:/var/lib/postgresql/data

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

volumes:           # Volume nommé
  db_data:

• services : Chaque conteneur de votre application multi-conteneurs. Dans l’exemple ci-dessus, nous avons deux services : web et db. Pour les opérations sur les conteneurs individuels, consultez la Cheat sheet Docker.
• networks & volumes : Définissent des réseaux isolés et un stockage persistant - nous avons ici le réseau appnet et le volume db_data.

Exemples

Service unique avec mappage de ports

services:
  app:
    build: .
    ports:
      - "8000:80"   # Port hôte 8000 : Port conteneur 80

Expose l’application sur le port 8000 de l’hôte et construit à partir du Dockerfile dans le répertoire courant.

Multi-services avec volume partagé et réseau personnalisé

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - type: bind
        source: ./app
        target: /app
    networks:
      - mynet
  db:
    image: postgres
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - mynet

networks:
  mynet:

volumes:
  db_data:

Web et DB sur le même réseau ; DB utilise un volume nommé persistant - db_data.

Utilisation du contexte de build et du chemin du Dockerfile

Vous pouvez construire une image Docker à la demande à partir du Dockerfile spécifié dans docker-compose.yml.

services:
  app:
    build:
      context: .
      dockerfile: docker/MyDockerfile

Partage de données entre services

services:
  web:
    image: nginx
    volumes:
      - shared_data:/usr/share/nginx/html
  worker:
    image: myworker
    volumes:
      - shared_data:/usr/src/app/data

volumes:
  shared_data:

Les deux services accèdent au même volume (pour les fichiers statiques ou les échanges de données) - shared_data.

Options avancées des fichiers Compose

• environment : Définir les variables ENV pour les conteneurs.
• depends_on : Contrôler l’ordre de démarrage des services.
• deploy.replicas : Mettre à l’échelle le service en mode Swarm.

Exemple :

services:
  web:
    image: nginx
    deploy:
      replicas: 3
    depends_on:
      - db

Démarrage de 3 instances web ; contrôle uniquement l’ordre de démarrage (pas l’état de préparation).

Commandes essentielles Docker Compose

Modèles Compose courants

• Bases de données avec données persistantes

  services:
    mysql:
      image: mysql
      environment:
        MYSQL_ROOT_PASSWORD: password
      volumes:
        - mysql_data:/var/lib/mysql
  
  volumes:
    mysql_data:
  

  Les données de la base de données persistent dans le volume mysql_data entre les redémarrages des conteneurs.

• Montage de liaison du code pour le développement

  services:
    app:
      build: .
      volumes:
        - .:/app
  

  Édition en direct du code sur l’hôte, automatiquement reflétée dans le conteneur.

Drapeaux utiles

• -d : Mode détaché (exécution en arrière-plan).
• --build : Forcer la reconstruction des images avant le démarrage.
• --force-recreate : Recréer les conteneurs même s’ils n’ont pas changé.
• --remove-orphans : Supprimer les conteneurs non définis dans le fichier Compose.

Définition et personnalisation des services

Vous pouvez définir et personnaliser les services, réseaux et volumes dans Docker Compose en utilisant le fichier docker-compose.yml, qui centralise toute la configuration et les besoins d’orchestration de votre application.

• Services sont définis sous la clé services.
• Chaque service représente une configuration de conteneur, où vous pouvez définir :
  • Image : Sélectionner une image depuis Docker Hub ou un autre registre.
  • Ports : Mapper les ports du conteneur aux ports de l’hôte.
  • Variables d’environnement : Transmettre des valeurs de configuration.
  • Volumes : Persister des données ou partager des fichiers/dossiers avec l’hôte ou d’autres services.
  • Réseaux : Contrôler les réseaux auxquels le service peut accéder.

Exemple :

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Port hôte 8080 : Port conteneur 80
    environment:
      - NGINX_HOST=localhost
    volumes:
      - web_data:/usr/share/nginx/html
    networks:
      - frontend

  db:
    image: postgres:13
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - backend

• Ici, le service web utilise l’image nginx, définit une variable d’environnement, attache un volume, ouvre le port 80 en 8080 sur l’hôte et se connecte au réseau frontend. Le service db fait quelque chose de similaire pour PostgreSQL.

Personnalisation des réseaux

• Réseaux contrôlent quels services peuvent communiquer. Compose crée un réseau par défaut, mais vous pouvez en définir d’autres, spécifier des pilotes personnalisés, définir des options et déterminer quel service rejoint quel réseau pour une isolation fine.
• Définissez les réseaux au niveau supérieur sous networks, et listez les réseaux auxquels un service doit se connecter avec la clé networks au niveau du service.

Exemple :

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    driver_opts:
      com.docker.network.bridge.host_binding_ipv4: "127.0.0.1"

• Attacher les réseaux aux services :

services:
  app:
    networks:
      - frontend
      - backend
  db:
    networks:
      - backend

• Cette configuration permet au service app d’accéder aux utilisateurs sur les réseaux frontend et backend, tandis que db n’est accessible que dans le backend.

Personnalisation des volumes

• Volumes sont définis sous la clé de niveau supérieur volumes. Montez-les dans les conteneurs en utilisant la clé volumes sous un service.
• Les volumes peuvent être nommés, utiliser des pilotes personnalisés et être partagés entre plusieurs services pour la persistance et le partage de données.

Exemple :

volumes:
  web_data:                # Volume nommé pour le contenu web
  db_data:                 # Volume nommé pour la base de données

services:
  web:
    volumes:
      - web_data:/usr/share/nginx/html

  db:
    volumes:
      - db_data:/var/lib/postgresql/data

• Dans cet exemple, web_data est persisté et disponible pour tout conteneur qui le monte. db_data garantit que les données de la base de données ne sont jamais perdues lors de la recréation du conteneur.
• Vous pouvez définir des montages de liaison avec des options de pilote personnalisées pour des cas avancés :

volumes:
  db_data:
    driver: local
    driver_opts:
      type: none
      device: /data/db_data
      o: bind

• Cette configuration met en place un montage de liaison depuis le chemin de l’hôte /data/db_data vers le conteneur.

Résumé des meilleures pratiques :

• Utilisez le nom du service comme nom d’hôte DNS pour la communication inter-services.
• Attachez les services à plusieurs réseaux selon les besoins pour contrôler l’accès.
• Utilisez des volumes nommés pour le stockage persistant et le partage de données.
• Définissez tout en utilisant YAML, permettant le contrôle de version et des scripts de déploiement faciles.
• Pour la gestion et la visualisation des conteneurs, envisagez Installer Portainer sur Linux.

Fichiers Compose multiples

Pour organiser des configurations complexes multi-services dans Docker Compose, vous pouvez utiliser plusieurs fichiers Compose et des fichiers de substitution, permettant des configurations modulaires, spécifiques à l’environnement et évolutives. Voici comment cela fonctionne :

1. Structure des fichiers de base et de substitution

• Créer un fichier de base (compose.yaml ou docker-compose.yml) contenant toutes les définitions de services communes et par défaut.
• Ajouter des fichiers de substitution spécifiques à l’environnement (par exemple, docker-compose.override.yml, docker-compose.dev.yml, docker-compose.prod.yml).

Exemple de structure de fichiers :

/répertoire-projet
|-- docker-compose.yml           # Configuration de base
|-- docker-compose.override.yml  # Substitutions locales/dev (appliquées automatiquement)
|-- docker-compose.prod.yml      # Substitutions de production
|-- docker-compose.test.yml      # Substitutions de test (si nécessaire)

La configuration de base définit les services principaux, tandis que chaque substitution personnalise les paramètres pour un environnement ou un cas spécifique.

2. Comment fonctionnent les substitutions de fichiers

• Fusion : Lorsque vous exécutez docker compose up, Docker Compose fusionne la base avec toutes les substitutions dans l’ordre ; les fichiers ultérieurs substituent, étendent ou ajoutent aux paramètres des fichiers précédents.
• Substitution des champs : Si un service ou un champ est défini dans plusieurs fichiers, la valeur du fichier spécifié en dernier est utilisée. Les nouveaux champs sont ajoutés.

Exemple de fusion :

• docker-compose.yml:

  services:
    web:
      image: myapp
      ports:
        - "8000:80"
  

• docker-compose.override.yml:

  services:
    web:
      environment:
        - DEBUG=true
  

• Résultat : Le service web utilise à la fois l’image et le port de base ainsi que la variable d’environnement DEBUG substituée.

3. Utilisation des commandes pour plusieurs fichiers

• Comportement par défaut : Si présents, Docker Compose charge automatiquement docker-compose.override.yml avec docker-compose.yml lorsque vous exécutez une commande.
• Spécification manuelle des fichiers : Utilisez les drapeaux -f pour contrôler quels fichiers sont fusionnés et dans quel ordre :

  docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d
  

  • Cela ignore la substitution par défaut et utilise les paramètres spécifiques à la production.

4. Stratégies d’organisation pratiques

• Séparation des environnements : Utilisez une substitution par environnement : dev, test, prod, etc.
• Microservices et équipes : Divisez la configuration en fichiers séparés pour différents services ou équipes, et combinez-les selon les besoins.
• Bascules de fonctionnalités : Des fichiers supplémentaires peuvent introduire ou supprimer des services ou des configurations optionnels pour des besoins temporaires (par exemple, un compose.debug.yml pour une journalisation supplémentaire).

5. Avantages

• Clarté : Garde les fichiers individuels petits et ciblés.
• Évolutivité : Ajoutez facilement de nouveaux services, environnements ou paramètres.
• Maintenabilité : Modifiez ou révisez uniquement les sections pertinentes pour un déploiement donné.

6. Exemple : Changement d’environnements

Développement :

docker compose -f docker-compose.yml -f docker-compose.dev.yml up

Production :

docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d

Chaque environnement ne reçoit que la configuration nécessaire, avec toute la configuration partagée dans le fichier de base.

L’organisation des configurations Compose complexes avec plusieurs fichiers - et l’exploitation du système de substitution/fusion - assure la modularité, la personnalisation spécifique à l’environnement et une évolutivité facile pour les grandes applications Docker multi-services.

Pour le déploiement en production sur un seul hôte Linux — démarrage au lancement, arrêt propre, mises à jour et rotation des journaux — consultez Exécuter Docker Compose comme service Linux avec systemd.

Liens utiles

• https://docs.docker.com/compose/
• Cheat sheet Docker
• Cheat sheet Kubernetes
• Dockerisation d’une application Web Flutter avec build Flutter dockerisé et Nginx
• Installer Portainer sur Linux