Mode d’emploi Docker Compose – Les commandes les plus utiles avec des exemples

Voici une fiche mémo Docker Compose avec des exemples commentés pour vous aider à maîtriser rapidement les fichiers et les commandes Compose.

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

Prérequis

Docker Engine 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 de base :

version: '3'       # Version du format de 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 des conteneurs individuels, consultez la Fiche mémo 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 mapping 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 depuis le Dockerfile du répertoire actuel.

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 sur demande à partir du Dockerfile spécifié dans docker-compose.yaml.

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 du fichier Compose

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

Exemple :

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

Démarre 3 instances web ; ne contrôle que l’ordre de démarrage (pas la disponibilité).

Commandes Docker Compose essentielles

Modèles de composition 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 BDD persistent dans le volume mysql_data lors des redémarrages des conteneurs.

• Montage par lien du code pour le développement

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

  Éditez le code en direct sur l’hôte, il est automatiquement reflété dans le conteneur.

Drapeaux utiles

• -d : Mode détaché (exécuter en arrière-plan).
• --build : Force la reconstruction des images avant le démarrage.
• --force-recreate : Recrée les conteneurs même s’ils n’ont pas changé.
• --remove-orphans : Supprime 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 tirant parti du fichier docker-compose.yml, qui centralise tous vos besoins de configuration et d’orchestration de votre application.

• Les Services sont définis sous la clé services.
• Chaque service représente une configuration de conteneur, où vous pouvez définir :
  • Image : Sélectionnez une image depuis Docker Hub ou un autre registre.
  • Ports : Mappez les ports du conteneur vers les ports de l’hôte.
  • Variables d’environnement : Passez des valeurs de configuration.
  • Volumes : Persistez des données ou partagez des fichiers/dossiers avec l’hôte ou d’autres services.
  • Réseaux : Contrôlez 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 tant que 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

• Les Réseaux contrôlent les services qui peuvent communiquer. Compose crée un réseau par défaut, mais vous pouvez en définir davantage, spécifier des pilotes personnalisés, définir des options et déterminer à quel réseau chaque service se joint 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"

• Attachez des 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 réseau backend.

Personnalisation des volumes

• Les Volumes sont définis sous la clé de niveau supérieur volumes. Montez-les sur des 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 persistant 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 par lien 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 par lien depuis le chemin de l’hôte /data/db_data vers le conteneur.

Résumé des bonnes 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 des fichiers Compose multiples et des fichiers de substitution, permettant des configurations modulaires, spécifiques à l’environnement et évolutives. Voici comment cela fonctionne :

1. Structure de fichier de base et de substitution

• Créez un fichier de base (compose.yaml ou docker-compose.yml) contenant toutes les définitions de service communes par défaut.
• Ajoutez 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-du-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 fichier de substitution personnalise les paramètres pour un environnement ou un cas spécifique.

2. Fonctionnement des substitutions de fichiers

• Fusion : Lorsque vous exécutez docker compose up, Docker Compose fusionne le fichier de base avec les substitutions dans l’ordre ; les fichiers suivants substituent, étendent ou ajoutent des paramètres aux 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 : S’il existe, 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 un fichier de substitution par environnement : dev, test, prod, etc.
• Microservices et équipes : Découpez 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 optionnelles pour des besoins temporaires (par exemple, un compose.debug.yml pour des journaux supplémentaires).

5. Avantages

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

6. Exemple : Changement d’environnement

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 pour lui, avec toute la configuration partagée dans le fichier de base.

L’organisation de 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 un déploiement en production sur un seul hôte Linux — démarrage au boot, arrêt propre, mises à jour et rotation des journaux — consultez Exécuter Docker Compose en tant que service Linux avec systemd. Pour une comparaison avec Podman Quadlet, consultez Podman Quadlet vs Docker Compose pour les services Linux.

Liens utiles

• https://docs.docker.com/compose/
• Fiche mémo Docker
• Fiche mémo Kubernetes
• Conteneuriser une application web Flutter avec une construction Flutter conteneurisée et Nginx
• Installer Portainer sur Linux
• Sauvegarde et restauration du serveur Gitea