Recherche sur le site Web

Comment installer et utiliser Docker Compose sur Ubuntu

Introduction

Docker simplifie le processus de gestion des processus d'application dans des conteneurs. Bien que les conteneurs soient similaires aux machines virtuelles à certains égards, ils sont plus légers et utilisent moins de ressources. Cela permet aux développeurs de décomposer un environnement applicatif en plusieurs services isolés.

Pour les applications dépendant de plusieurs services, orchestrer le démarrage, la communication et l'arrêt simultané de tous les conteneurs peut rapidement devenir difficile à gérer. Docker Compose est un outil qui vous permet d'exécuter des environnements d'applications multi-conteneurs basés sur des définitions établies dans un fichier YAML. Il utilise des définitions de services pour construire des environnements entièrement personnalisables avec plusieurs conteneurs pouvant partager des réseaux et des volumes de données.

Ce guide vous expliquera comment installer Docker Compose sur un serveur Ubuntu et exécuter un conteneur simple. Ensuite, vous apprendrez à créer un environnement multi-services en utilisant une application WordPress et une base de données MySQL. Nous aborderons également des sujets plus avancés, tels que la mise à l’échelle des services, la définition de réseaux personnalisés, et l’utilisation de directives d’inclusion modulaires. Enfin, cet article fournit un guide de migration de l’ancien docker-compose (v1) vers le moderne docker compose (v2) ainsi qu’une section détaillée sur le dépannage des problèmes courants tels que les conflits de ports et les erreurs de permissions.

Points clés à retenir :

  • Docker Compose est un outil permettant de définir et d’exécuter des applications multi-conteneurs en utilisant un seul fichier YAML pour configurer les services, les réseaux et les volumes.
  • Docker Compose est installé sur Ubuntu en ajoutant le dépôt officiel de Docker et en utilisant apt pour installer le paquet docker-compose-plugin.
  • La commande moderne est docker compose (avec un espace). Cela remplace l’outil v1 docker-compose (avec un trait d’union), qui est obsolète.
  • Utilisez docker compose up -d pour démarrer une application en mode détaché et docker compose down pour arrêter et supprimer tous ses conteneurs et réseaux.
  • La directive depends_on aide à contrôler l'ordre de démarrage des services, par exemple en s'assurant qu'un conteneur de base de données démarre avant un conteneur d'application web.
  • Les problèmes les plus fréquents sont « Permission refusée » (résolu en ajoutant votre utilisateur au groupe docker), les conflits de ports (résolu en changeant le port hôte dans le fichier YAML) et les erreurs de syntaxe YAML (résolu en corrigeant l'indentation).
  • Vous pouvez exécuter plusieurs instances d’un service en utilisant la commande docker compose up --scale <nom_du_service>=<nombre>.
  • La directive include vous permet de diviser un grand fichier docker-compose.yml en fichiers de configuration plus petits et plus faciles à gérer.

Prérequis

Pour suivre cet article, vous aurez besoin de :

  • Accès à une machine locale Ubuntu ou à un serveur de développement en tant qu'utilisateur non root avec des privilèges sudo. Si vous utilisez un serveur distant, il est conseillé d'avoir un pare-feu actif installé. Pour configurer cela, veuillez vous référer à notre Guide de configuration initiale du serveur pour Ubuntu.
  • Docker installé sur votre serveur ou machine locale, en suivant les étapes 1 et 2 de Comment installer Docker sur Ubuntu – Guide étape par étape.

Remarque : À partir de Docker Compose v2, Docker a migré vers l'utilisation de la commande plugin CLI compose, et s'éloigne du docker-compose original comme documenté dans notre guide Comment Installer Docker Compose sur Ubuntu (Guide étape par étape). Bien que l'installation soit différente, en général, l'utilisation réelle consiste à supprimer le trait d'union des appels docker-compose pour devenir docker compose. Pour des détails complets sur la compatibilité, consultez la documentation officielle de Docker sur la compatibilité des commandes entre le nouveau compose et l'ancien docker-compose.

Étape 1 — Installer Docker Compose

Il existe deux façons d’installer Docker Compose sur Ubuntu :

  • Installer à l'aide du dépôt
  • Installer manuellement

Nous discuterons des deux façons dans cette section.

Installer Docker Compose en utilisant le dépôt apt

Tout d’abord, configurons le dépôt Docker apt.

# Add Docker's official GPG key:

sudo apt-get update

sudo apt-get install ca-certificates curl

sudo install -m 0755 -d /etc/apt/keyrings

sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc

sudo chmod a+r /etc/apt/keyrings/docker.asc



# Add the repository to Apt sources:

echo \

  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \

  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \

  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt-get update

Vous pouvez maintenant installer Docker Compose en utilisant la commande suivante :

sudo apt install docker-compose-plugin

Docker Compose est maintenant installé avec succès sur votre système. Pour vérifier que l'installation a réussi, vous pouvez exécuter :

docker compose version

Vous verrez une sortie similaire à ceci :

Docker Compose version v2.3.3

Installer Docker Compose manuellement

Pour vous assurer d'obtenir la version stable la plus récente de Docker Compose, vous devrez télécharger ce logiciel depuis son dépôt officiel sur Github.

Tout d'abord, confirmez la dernière version disponible sur leur page de versions. Au moment de la rédaction de ce texte, la version stable la plus récente est v2.40.2.

Utilisez la commande suivante pour télécharger :

mkdir -p ~/.docker/cli-plugins/

curl -SL https://github.com/docker/compose/releases/download/v2.40.2/docker-compose-linux-x86_64 -o ~/.docker/cli-plugins/docker-compose

Ensuite, configurez les permissions appropriées afin que la commande docker compose soit exécutable :

chmod +x ~/.docker/cli-plugins/docker-compose

Dans la section suivante, vous verrez comment configurer un fichier docker-compose.yml et mettre en marche un environnement conteneurisé avec cet outil.

Étape 2 — Configuration d'un fichier docker-compose.yml

Pour démontrer comment configurer un fichier docker-compose.yml et travailler avec Docker Compose, vous allez créer un environnement de serveur Web en utilisant l'image officielle Nginx de Docker Hub, le registre public de Docker. Cet environnement conteneurisé servira un seul fichier HTML statique.

Commencez par créer un nouveau dossier dans votre dossier personnel, puis entrez dedans :

mkdir ~/compose-demo

cd ~/compose-demo

Dans ce répertoire, créez un dossier d'application qui servira de racine des documents pour votre environnement Nginx :

mkdir app

En utilisant votre éditeur de texte préféré, créez un nouveau fichier index.html dans le dossier app :

nano app/index.html

Mettez le contenu suivant dans ce fichier :

<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Docker Compose Demo</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/kognise/water.css@latest/dist/dark.min.css">
</head>
<body>

    <h1>This is a Docker Compose Demo Page.</h1>
    <p>This content is being served by an Nginx container.</p>

</body>
</html>

Enregistrez et fermez le fichier lorsque vous avez terminé. Si vous utilisez nano, vous pouvez le faire en tapant CTRL+X, puis Y et ENTRÉE pour confirmer.

Ensuite, créez le fichier docker-compose.yml :

nano docker-compose.yml

Insérez le contenu suivant dans votre fichier docker-compose.yml :

services:
  web:
    image: nginx:alpine
    ports:
      - "8000:80"
    volumes:
      - ./app:/usr/share/nginx/html

Dans Docker Compose moderne, le champ version est optionnel et souvent omis, car Compose peut détecter automatiquement la version de la configuration. L'exemple ci-dessus n'inclut pas de champ version, ce qui est l'approche recommandée pour la plupart des nouveaux projets. Vous n'avez besoin de spécifier version que pour la compatibilité avec les versions héritées.

Vous avez ensuite le bloc services, où vous configurez les services qui font partie de cet environnement. Dans votre cas, vous n’avez qu’un seul service appelé web. Ce service utilise l’image nginx:alpine et configure une redirection de port avec la directive ports. Toutes les requêtes sur le port 8000 de la machine hôte (le système depuis lequel vous exécutez Docker Compose) seront redirigées vers le conteneur web sur le port 80, où Nginx sera en fonctionnement.

La directive volumes créera un volume partagé entre la machine hôte et le conteneur. Cela partagera le dossier local app avec le conteneur, et le volume sera situé à /usr/share/nginx/html à l'intérieur du conteneur, ce qui remplacera alors la racine de documents par défaut pour Nginx.

Enregistrez et fermez le fichier.

Vous avez configuré une page de démonstration et un fichier docker-compose.yml pour créer un environnement de serveur web conteneurisé qui la diffusera. À l'étape suivante, vous allez lancer cet environnement avec Docker Compose.

Étape 3 — Exécution de Docker Compose

Avec le fichier docker-compose.yml en place, vous pouvez maintenant exécuter Docker Compose pour lancer votre environnement. La commande suivante téléchargera les images Docker nécessaires, créera un conteneur pour le service web et exécutera l'environnement conteneurisé en mode arrière-plan :

docker compose up -d

Docker Compose recherchera d'abord l'image définie sur votre système local, et s'il ne peut pas trouver l'image, il la téléchargera depuis Docker Hub. Vous verrez une sortie comme celle-ci :

Creating network "compose-demo_default" with the default driver
Pulling web (nginx:alpine)...
alpine: Pulling from library/nginx
cbdbe7a5bc2a: Pull complete
10c113fb0c77: Pull complete
9ba64393807b: Pull complete
c829a9c40ab2: Pull complete
61d685417b2f: Pull complete
Digest: sha256:57254039c6313fe8c53f1acbf15657ec9616a813397b74b063e32443427c5502
Status: Downloaded newer image for nginx:alpine
Creating compose-demo_web_1 ... done

Remarque : Si vous rencontrez une erreur « permission refusée » lors de l'exécution de docker compose up, cela signifie généralement que votre utilisateur non root n'a pas la permission d'accéder au socket du démon Docker.

Par défaut, le démon Docker se lie à un socket Unix (/var/run/docker.sock) qui est détenu par l’utilisateur root. Pour résoudre ce problème, vous devez ajouter votre utilisateur non-root au groupe docker, qui est créé lors de l’installation de Docker.

Exécutez la commande suivante pour ajouter votre utilisateur au groupe docker :

sudo usermod -aG docker ${USER}

Après avoir exécuté cette commande, vous devrez vous déconnecter puis vous reconnecter pour que les changements de groupe prennent effet. Vous pouvez également activer les changements pour la session de terminal en cours en tapant :

newgrp docker

Cette commande devrait résoudre toutes les erreurs d'autorisation liées à la socket Docker. Pour un guide complet, veuillez vous référer à l'Étape 2 de Comment installer Docker sur Ubuntu – Guide étape par étape.

Votre environnement fonctionne maintenant en arrière-plan. Pour vérifier que le conteneur est actif, vous pouvez exécuter :

docker compose ps

Cette commande vous montrera des informations sur les conteneurs en cours d'exécution et leur état, ainsi que toutes les redirections de ports actuellement en place :

       Name                     Command               State          Ports        
----------------------------------------------------------------------------------
compose-demo_web_1   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:8000->80/tcp

Vous pouvez maintenant accéder à l'application de démonstration en dirigeant votre navigateur vers localhost:8000 si vous exécutez cette démonstration sur votre machine locale, ou votre_domaine_ou_IP_du_serveur:8000 si vous exécutez cette démonstration sur un serveur distant.

Vous verrez une page comme celle-ci :

Le volume partagé que vous avez configuré dans le fichier docker-compose.yml permet de garder vos fichiers du dossier app synchronisés avec le répertoire racine du conteneur. Si vous apportez des modifications au fichier index.html, elles seront automatiquement prises en compte par le conteneur et donc reflétées dans votre navigateur lorsque vous actualiserez la page.

Dans l'étape suivante, vous verrez comment gérer votre environnement conteneurisé avec les commandes Docker Compose.

Étape 4 — Se familiariser avec les commandes Docker Compose

Vous avez vu comment configurer un fichier docker-compose.yml et lancer votre environnement avec docker compose up. Vous allez maintenant voir comment utiliser les commandes Docker Compose pour gérer et interagir avec votre environnement conteneurisé.

Pour consulter les journaux générés par votre conteneur Nginx, vous pouvez utiliser la commande logs :

docker compose logs

Vous verrez une sortie similaire à ceci :

Attaching to compose-demo_web_1
web_1  | /docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
web_1  | /docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
web_1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
web_1  | 10-listen-on-ipv6-by-default.sh: Getting the checksum of /etc/nginx/conf.d/default.conf
web_1  | 10-listen-on-ipv6-by-default.sh: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
web_1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
web_1  | /docker-entrypoint.sh: Configuration complete; ready for start up
web_1  | 172.22.0.1 - - [02/Jun/2020:10:47:13 +0000] "GET / HTTP/1.1" 200 353 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36" "-"

Si vous voulez mettre l'exécution de l'environnement en pause sans modifier l'état actuel de vos conteneurs, vous pouvez utiliser :

docker compose pause
Pausing compose-demo_web_1 ... done

Pour reprendre l'exécution après avoir mis en pause :

docker compose unpause
Unpausing compose-demo_web_1 ... done

La commande stop arrêtera l'exécution du conteneur, mais ne détruira aucune donnée associée à vos conteneurs :

docker compose stop
Stopping compose-demo_web_1 ... done

Si vous voulez supprimer les conteneurs, réseaux et volumes associés à cet environnement conteneurisé, utilisez la commande down :

docker compose down
Removing compose-demo_web_1 ... done
Removing network compose-demo_default

Remarquez que cela ne supprimera pas l'image de base utilisée par Docker Compose pour démarrer votre environnement (dans votre cas, nginx:alpine). Ainsi, chaque fois que vous relancerez votre environnement avec un docker compose up, le processus sera beaucoup plus rapide puisque l'image est déjà sur votre système.

Au cas où vous voudriez également supprimer l'image de base de votre système, vous pouvez utiliser :

docker image rm nginx:alpine
Untagged: nginx:alpine
Untagged: nginx@sha256:b89a6ccbda39576ad23fd079978c967cecc6b170db6e7ff8a769bf2259a71912
Deleted: sha256:7d0cdcc60a96a5124763fddf5d534d058ad7d0d8d4c3b8be2aefedf4267d0270
Deleted: sha256:05a0eaca15d731e0029a7604ef54f0dda3b736d4e987e6ac87b91ac7aac03ab1
Deleted: sha256:c6bbc4bdac396583641cb44cd35126b2c195be8fe1ac5e6c577c14752bbe9157
Deleted: sha256:35789b1e1a362b0da8392ca7d5759ef08b9a6b7141cc1521570f984dc7905eb6
Deleted: sha256:a3efaa65ec344c882fe5d543a392a54c4ceacd1efd91662d06964211b1be4c08
Deleted: sha256:3e207b409db364b595ba862cdc12be96dcdad8e36c59a03b7b3b61c946a5741a

Remarque : Veuillez consulter notre guide sur Comment installer Docker sur Ubuntu – Guide étape par étape pour une référence plus détaillée sur les commandes Docker.

Étape 5 — Création d’une application multi-services

Le véritable pouvoir de Docker Compose réside dans la gestion de plusieurs services qui fonctionnent ensemble. L’exemple de Nginx était un service unique. Créons une application plus pratique comprenant plusieurs services : un site WordPress connecté à une base de données MySQL.

Cette configuration implique deux services : wordpress (exécutant l'application) et db (exécutant la base de données). Nous utiliserons également des volumes Docker pour garantir que les données de la base de données persistent même si le conteneur est supprimé.

Créons un nouveau répertoire pour cette application :

mkdir -p ~/compose-demo/wordpressapp

cd ~/compose-demo/wordpressapp

Pour cet exemple, nous n’avons pas besoin de fichiers locaux, car les images contiendront tous les logiciels nécessaires.

Créez un nouveau fichier docker-compose.yml :

nano docker-compose.yml

Collez la configuration suivante. Ce fichier est plus complexe, nous allons donc examiner chaque partie.

services:
  db:
    image: mysql:8.0
    container_name: mysql_db
    volumes:
      - db_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: <^your_root_password_here<^>
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress_user
      MYSQL_PASSWORD: <^your_wordpress_password_here<^>
    restart: unless-stopped

  wordpress:
    image: wordpress:latest
    container_name: wordpress_app
    ports:
      - "8001:80"
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress_user
      WORDPRESS_DB_PASSWORD: <^your_wordpress_password_here<^>
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - ./wp_content:/var/www/html/wp-content
    depends_on:
      - db
    restart: unless-stopped

volumes:
  db_data:

Remarque : Nous avons codé en dur les valeurs du mot de passe ici à des fins d’illustration. Lors de l’utilisation dans un environnement réel, assurez-vous d’utiliser des variables d’environnement dans le fichier .env pour éviter d’exposer vos identifiants.

Enregistrez et fermez le fichier. N'oubliez pas de remplacer les espaces réservés <^...^> par des mots de passe forts et sécurisés.

Décomposons les nouvelles directives dans ce fichier :

  • services : Ce bloc définit toujours nos conteneurs. Nous en avons maintenant deux : db et wordpress.
  • image : Nous utilisons mysql:8.0 pour la base de données et l'image wordpress:latest pour l'application.
  • container_name : Cela définit un nom spécifique et lisible par l'humain pour le conteneur, ce qui est plus facile à référencer que les noms générés automatiquement.
  • environment : Ceci est une liste de variables d'environnement transmises au conteneur. L'image mysql les utilise pour définir le mot de passe root et créer une base de données et un utilisateur initiaux. L'image wordpress les utilise pour savoir comment se connecter à sa base de données.

  • volumes (niveau de service) :

    • Pour le service db, db_data:/var/lib/mysql associe un volume géré par Docker nommé db_data au répertoire de données MySQL à l'intérieur du conteneur. Cela permet de sécuriser vos données.
    • Pour le service wordpress, ./wp_content:/var/www/html/wp-content mappe un répertoire local (wp_content) au répertoire de contenu de WordPress. Cela vous permet de modifier directement les thèmes et les plugins depuis votre machine hôte.
  • depends_on : Cela indique à Compose de démarrer le service db avant de démarrer le service wordpress. C’est important, car WordPress échouera s’il ne trouve pas sa base de données au démarrage.
  • volumes (niveau supérieur) : Ce bloc définit les volumes nommés. db_data : crée un volume géré par Docker, ce qui est la méthode recommandée pour gérer les données persistantes.

Maintenant, lancez cette application multiservices :

docker compose up -d

Compose téléchargera à la fois les images mysql et wordpress, puis créera les conteneurs en démarrant d'abord le service db.

Creating network "compose-demo_default" with the default driver
Creating volume "compose-demo_db_data" with default driver
Pulling db (mysql:8.0)...
...
Pulling wordpress (wordpress:latest)...
...
Creating mysql_db        ... done
Creating wordpress_app ... done

Vous pouvez maintenant accéder à votre nouveau site WordPress en allant à localhost:8001 ou <^votre_domaine_ou_IP_du_serveur<^>:8001 dans votre navigateur. Vous devriez voir l'écran d'installation de WordPress. Pour un exemple plus détaillé, consultez notre article sur Comment Installer WordPress Avec Docker Compose

Étape 6 — Utiliser Docker Compose pour le développement en IA/ML

Au-delà des applications web, Docker Compose est un outil extrêmement utile pour créer des environnements de science des données et d'apprentissage automatique (IA/ML) reproductibles. Les projets d'IA/ML sont connus pour leurs dépendances complexes, incluant des versions spécifiques de Python, des bibliothèques comme TensorFlow ou PyTorch, ainsi que des pilotes au niveau du système comme le NVIDIA CUDA Toolkit. Docker Compose capture tout cet environnement dans des fichiers de configuration, résolvant ainsi le problème du « ça fonctionne sur ma machine », ce qui est crucial pour la recherche reproductible.

Dans cet exemple, vous allez créer un environnement IA/ML multi-services composé de :

  • JupyterLab : Un conteneur pour le développement interactif, construit à partir d'un Dockerfile personnalisé.
  • PostgreSQL : Un conteneur de base de données pour stocker les résultats des expériences et les métadonnées.
  • Accès GPU : Le conteneur JupyterLab sera configuré pour accéder au GPU NVIDIA de la machine hôte, ce qui est courant pour l’entraînement de modèles.

Prérequis : Cet exemple nécessite un GPU NVIDIA sur votre machine hôte et que le NVIDIA Container Toolkit soit installé. Sans cela, le conteneur ne pourra pas démarrer lors de la demande de ressources GPU.

Structure des fichiers

Tout d'abord, créez un répertoire pour votre projet. À l'intérieur, vous allez créer un fichier docker-compose.yml, un répertoire jupyter, un Dockerfile pour Jupyter, et un fichier requirements.txt. La structure devrait ressembler à ceci :

ai-project/
├── docker-compose.yml
└── jupyter/
    ├── Dockerfile
    └── requirements.txt

Création des fichiers de composant

1. Le fichier requirements.txt

Ce fichier répertorie les packages Python pour votre environnement de science des données.

nano jupyter/requirements.txt

Ajoutez vos packages requis. Pour cet exemple, nous inclurons des bibliothèques pour la manipulation de données, la connexion à une base de données et un framework d’apprentissage profond.

pandas
scikit-learn
tensorflow
jupyterlab
psycopg2-binary

Enregistrez et fermez le fichier.

2. Le Dockerfile

Ce fichier définit votre service personnalisé JupyterLab. Il utilise une image officielle de Jupyter comme base et installe les packages à partir de requirements.txt.

nano jupyter/Dockerfile

Collez le contenu suivant :

# Start from a base image that includes Jupyter and scientific libraries
FROM jupyter/scipy-notebook:latest

# Copy our local requirements file into the container
COPY requirements.txt /tmp/requirements.txt

# Install the Python packages
RUN pip install --no-cache-dir -r /tmp/requirements.txt

Ce fichier indique à Docker d'utiliser jupyter/scipy-notebook comme point de départ, de copier votre requirements.txt dans le conteneur, puis d'utiliser pip pour installer les paquets.

Définir l'environnement avec docker-compose.yml

Maintenant, créez le fichier principal docker-compose.yml. Ce fichier orchestrera à la fois le service db et votre service personnalisé jupyter.

nano docker-compose.yml

Collez la configuration suivante en remplaçant les espaces réservés <^...^> par vos propres identifiants sécurisés.

services:
  db:
    image: postgres:15-alpine
    container_name: ai_postgres_db
    environment:
      POSTGRES_USER: <^your_db_user^>
      POSTGRES_PASSWORD: <^your_db_pass^>
      POSTGRES_DB: experiments
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U <^your_db_user^> -d experiments"]
      interval: 10s
      timeout: 5s
      retries: 5
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped
    networks:
      - ai_net

  jupyter:
    build: ./jupyter
    container_name: ai_jupyter_lab
    ports:
      - "8888:8888"
    volumes:
      - ./notebooks:/home/jovyan/work
    environment:
      - POSTGRES_HOST=db
      - POSTGRES_USER=<^your_db_user^>
      - POSTGRES_PASSWORD=<^your_db_pass^>
      - POSTGRES_DB=experiments
    restart: unless-stopped
    networks:
      - ai_net
    depends_on:
      db:
        condition: service_healthy
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

volumes:
  postgres_data:
    name: ai_project_data

networks:
  ai_net:
    driver: bridge

Ce fichier de configuration présente plusieurs concepts importants :

  • build : ./jupyter : Cela indique à Docker Compose de construire une image personnalisée pour le service jupyter. Il cherche un Dockerfile à l'intérieur du répertoire spécifié ./jupyter.
  • volumes: - ./notebooks:/home/jovyan/work : Cela monte en liaison un répertoire local nommé notebooks dans le conteneur. Cela garantit que tous les notebooks Jupyter que vous créez sont sauvegardés directement sur votre machine hôte, les conservant même après la suppression du conteneur.
  • healthcheck : Comme indiqué dans la section de dépannage, cette vérification valide que le service db n'est pas seulement en cours d'exécution, mais qu'il est prêt à accepter des connexions avant que les autres services ne démarrent.
  • depends_on: ... condition: service_healthy : Cela indique au service jupyter d'attendre que le test de santé de db réussisse avant de démarrer.

  • deploy.resources.reservations.devices : Il s'agit du bloc qui demande l'accès au GPU.

    • driver: nvidia : Spécifie le pilote hôte à utiliser.
    • count: 1 : Demande un GPU.
    • capacités : [gpu] : Assure que le conteneur dispose des capacités nécessaires pour utiliser le GPU.

Exécution de l'environnement IA/ML

Avec vos fichiers en place, vous êtes prêt à créer et exécuter les services.

  1. Depuis votre répertoire ai-project, exécutez la commande docker compose up. Vous devez ajouter l'option --build la première fois pour indiquer à Compose de construire votre image jupyter personnalisée.

    docker compose up -d --build

  2. Compose construira d'abord l'image jupyter (ce qui peut prendre quelques minutes le temps de télécharger TensorFlow), puis récupérera l'image postgres, et enfin démarrera les deux conteneurs.

    [+] Building 5.8s (9/9) FINISHED
 => [internal] load build definition from Dockerfile
...
[+] Running 3/3
 ✔ Network ai-project_ai_net        Created
 ✔ Container ai_postgres_db         Started
 ✔ Container ai_jupyter_lab         Started

  3. Vous pouvez maintenant accéder à l'interface JupyterLab en naviguant vers http://localhost:8888 (ou <^votre_ip_serveur^>:8888) dans votre navigateur. Il vous sera demandé un jeton, que vous pouvez obtenir à partir des journaux du conteneur :

    docker compose logs jupyter

    Cherchez une ligne semblable à http://127.0.0.1:8888/lab?token=a1b2c3d4e5f6...

  4. Dans un carnet Jupyter, vous pouvez maintenant vous connecter à votre base de données en utilisant le nom d'hôte db et les informations d'identification que vous avez fournies. Votre environnement a également accès au GPU de l'hôte pour l'entraînement du modèle.

Mise à l'échelle des services et utilisation de réseaux personnalisés

Docker Compose comprend des fonctionnalités pour la mise à l'échelle des services et la gestion des réseaux sur lesquels ils communiquent.

Mise à l'échelle du service avec des réplicas

Imaginez que votre serveur web Nginx de l'étape 2 reçoit trop de trafic. Vous pouvez faire évoluer le service web pour exécuter plusieurs instances de conteneurs. Docker Compose peut gérer cela automatiquement.

Il existe deux méthodes principales pour faire évoluer un service.

1. Utilisation de la clé replicas (Préféré en v2)

Vous pouvez définir le nombre d'instances souhaité directement dans votre fichier docker-compose.yml en utilisant les clés deploy et replicas. Cette fonctionnalité faisait à l'origine partie de Docker Swarm, mais elle est maintenant disponible pour les déploiements Compose standard.

Modifiez votre docker-compose.yml Nginx de l'étape 2 :

services:
  web:
    image: nginx:alpine
    ports:
      - "8000:80"
    volumes:
      - ./app:/usr/share/nginx/html
    deploy:
      replicas: 3

Lorsque vous exécutez docker compose up -d, Compose créera trois conteneurs web. Cependant, vous rencontrerez un problème : les trois tenteront de se lier au port 8000 de l’hôte. Cela provoquera une erreur « le port est déjà alloué » pour le deuxième et le troisième conteneur. Pour résoudre ce problème dans un environnement de production, vous devriez supprimer le mappage ports du service web. De cette façon, les conteneurs web ne seront accessibles qu’au sein du réseau Docker. Un service de répartition de charge séparé serait le seul à disposer d’un port public. Il répartirait ensuite le trafic vers les trois réplicas web.

Un exemple de configuration ressemblerait à ceci (il s'agit d'un exemple avancé) :

services:
  web:
    image: nginx:alpine
    # No 'ports' mapping here.
    # The service is only accessible inside the 'web-net' network.
    volumes:
      - ./app:/usr/share/nginx/html
    deploy:
      replicas: 3
    networks:
      - web-net

  load_balancer:
    image: nginx:latest
    ports:
      - "80:80" # The load_balancer is the only service with a public port.
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf # A config file that load balances to 'web'.
    networks:
      - web-net
    depends_on:
      - web

networks:
  web-net:

Dans cette configuration, le load_balancer écoute sur le port 80 et dirige les requêtes vers web_1, web_2 et web_3 en interne.

Cette clé replicas est particulièrement utile lorsqu'elle est utilisée avec un proxy inverse (comme Traefik ou une autre instance Nginx) capable de répartir les requêtes entre les réplicas au sein du réseau Docker, sans que chaque réplique ait besoin d’exposer un port sur l’hôte.

2. Utilisation de l’option --scale

Une méthode courante pour la mise à l'échelle est le paramètre --scale, hérité de Compose v1. Ce paramètre s'applique lors de l'exécution et remplace toute clé replicas.

Cependant, vous devez être prudent avec les définitions de ports. Si votre service définit un mappage de port hôte fixe (par exemple, "8000:80"), exécuter docker compose up --scale provoquera une erreur pour le deuxième et le troisième conteneur, car ils tenteront tous de se lier au même port hôte.

Pour utiliser --scale pour des services qui exposent des ports, vous ne devez pas utiliser de mappage de port hôte fixe.

  • Option 1 : Mapper vers des ports hôtes aléatoires (Bon pour le développement)

    Vous pouvez modifier votre docker-compose.yml pour ne spécifier que le port du conteneur. Cela indique à Docker de mapper le port 80 de chaque conteneur vers un port aléatoire disponible sur votre machine hôte.

    services:
  web:
    image: nginx:alpine
    ports:
      - "80" # No fixed host port
    volumes:
      - ./app:/usr/share/nginx/html

    Maintenant, lorsque vous exécutez la commande scale :

    docker compose up -d --scale web=3

    Exécutez docker compose ps pour voir le résultat. Chaque conteneur fonctionnera sur un port hôte différent, attribué au hasard :

          Name                     Command               State          Ports        
----------------------------------------------------------------------------------
compose-demo_web_1   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:49154->80/tcp
compose-demo-web_2   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:49155->80/tcp
compose-demo-web_3   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:49156->80/tcp

    • docker-compose.yml - Correct pour --scale

  • Option 2 : Utiliser un proxy inverse (Idéal pour la production)

    L'autre solution, comme mentionné dans la section replicas, est de supprimer complètement la directive ports du service web. Vous utiliseriez alors un conteneur de répartition de charge séparé (qui possède le seul port public) pour gérer et distribuer le trafic vers les répliques mises à l'échelle à l'intérieur du réseau Docker.

    Pour arrêter et supprimer les trois conteneurs, la commande reste la même :

    docker compose down

Configuration réseau personnalisée

Par défaut, Docker Compose crée un seul réseau bridge pour votre application. Chaque service dans le fichier y est attaché, ce qui a permis au conteneur wordpress de trouver le conteneur db simplement en utilisant son nom de service (db).

Cependant, vous pouvez définir vos propres réseaux personnalisés pour une meilleure isolation et un meilleur contrôle.

Modifions l'exemple WordPress pour utiliser un réseau bridge personnalisé.

services:
  db:
    image: mysql:8.0
    ...
    networks:
      - app_net

  wordpress:
    image: wordpress:latest
    ...
    ports:
      - "8001:80"
    depends_on:
      - db
    networks:
      - app_net

volumes:
  db_data:

networks:
  app_net:
    driver: bridge

Voici ce que nous avons ajouté :

  • réseaux (niveau supérieur) : Cela définit un nouveau réseau nommé app_net et précise qu'il doit utiliser le pilote standard bridge.
  • réseaux (niveau service) : Sous db et wordpress, cette clé les connecte à notre réseau app_net.

Si vous aviez un troisième service (comme un outil d'analyse) que vous n'attachez pas à app_net, il serait complètement isolé et incapable de communiquer avec les conteneurs db ou wordpress.

Pour le clustering multi-hôtes avec Docker Swarm, vous devez changer le driver de bridge à overlay. Le pilote bridge est utilisé pour la communication entre conteneurs sur un seul hôte, ce qui est la norme pour la plupart des cas d'utilisation de Docker Compose.

Utilisation des fichiers de configuration modulaires

Au fur et à mesure que vos applications se développent, votre fichier docker-compose.yml peut devenir volumineux et difficile à gérer. Docker Compose prend en charge une directive include, vous permettant de répartir votre configuration sur plusieurs fichiers.

Imaginez que vous voulez séparer vos définitions WordPress et de base de données, et peut-être avoir un docker-compose.override.yml commun pour les paramètres spécifiques au développement (comme lier un port sur la base de données).

La structure de votre répertoire pourrait ressembler à ceci :

compose-demo/
├── docker-compose.yml
├── docker-compose.db.yml
├── docker-compose.web.yml

Ce fichier définira uniquement le service db.

services:
  db:
    image: mysql:8.0
    container_name: mysql_db
    volumes:
      - db_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: <^your_root_password_here<^>
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress_user
      MYSQL_PASSWORD: <^your_wordpress_password_here<^>
    restart: unless-stopped

volumes:
  db_data:

Ce fichier définira uniquement le service wordpress.

services:
  wordpress:
    image: wordpress:latest
    container_name: wordpress_app
    ports:
      - "8001:80"
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress_user
      WORDPRESS_DB_PASSWORD: <^your_wordpress_password_here<^>
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - ./wp_content:/var/www/html/wp-content
    depends_on:
      - db
    restart: unless-stopped

Maintenant, votre fichier principal docker-compose.yml devient très simple. Il utilise simplement include pour intégrer les autres fichiers.

include:
  - docker-compose.db.yml
  - docker-compose.web.yml

Lorsque vous exécutez docker compose up -d, Compose lira les trois fichiers, fusionnera les configurations et démarrera les services db et wordpress exactement comme s'ils étaient définis dans un seul fichier. Cette approche rend votre configuration beaucoup plus modulaire et réutilisable.

Remarque : La directive include : nécessite Docker Compose v2.20 ou une version ultérieure. Si votre système utilise une version plus ancienne, vous pouvez combiner les fichiers en utilisant docker compose -f docker-compose.db.yml -f docker-compose.web.yml up.

Migration de docker-compose (v1) vers docker compose (v2)

La commande docker compose que vous avez installée à l’étape 1 est « Compose v2 ». Il s’agit d’un plugin basé sur Go intégré directement dans l’interface de ligne de commande Docker.

La version originale, « Compose v1 », était un outil Python séparé invoqué avec docker-compose (avec un trait d'union). Depuis juillet 2023, Compose v1 n'est plus pris en charge et a été abandonné.

Principales modifications et compatibilité ascendante

  • La commande : Le changement le plus évident est la commande. Le trait d'union (docker-compose) est maintenant un espace (docker compose).
  • Installation : la version 1 a été installée avec pip. La version 2 est incluse avec Docker Desktop ou installée en tant que plugin CLI, comme vous l'avez fait à l'Étape 1.
  • Fichiers YAML : Vos fichiers docker-compose.yml sont presque 100 % compatibles avec les versions précédentes. Compose v2 prend entièrement en charge les versions de fichiers 3.x. Vous n'avez pas besoin de modifier vos fichiers YAML pour la migration, seulement vos commandes.
  • --project-name option : L'option -p fonctionne toujours, mais l'option complète est maintenant --project-name au lieu de --project_name.

Guide de migration des commandes

La plupart des commandes sont identiques, seulement le trait d'union a été retiré. Voici un tableau comparant les commandes v1 courantes à leurs équivalents v2.

Commande docker-compose (v1)Commande docker compose (v2)Notes
docker-compose up -d
docker compose up -d
Aucun changement dans la syntaxe.
docker-compose down
docker compose down
Aucun changement dans la syntaxe.
docker-compose ps
docker compose ps
Aucun changement dans la syntaxe.
docker-compose logs
docker compose logs
Aucun changement dans la syntaxe.
docker-compose stop
docker compose stop
Aucun changement dans la syntaxe.
docker-compose build
docker compose build
Aucun changement dans la syntaxe.
docker-compose exec web bash
docker compose exec web bash
Aucun changement dans la syntaxe.
docker-compose run web bash
docker compose run web bash
run crée un nouveau conteneur. exec s'exécute dans un conteneur existant.
docker-compose up --scale web=3
docker compose up --scale web=3
L'option --scale est toujours prise en charge dans la version 2.

Comme vous pouvez le voir, pour la plupart des utilisations quotidiennes, le seul changement est docker-compose -> docker compose. Si vous utilisez des scripts, vous pouvez les mettre à jour simplement en enlevant le trait d’union.

Si vous avez encore l'ancienne version v1 de docker-compose installée, vous pouvez la supprimer pour éviter toute confusion :

sudo pip3 uninstall docker-compose

Ou, si cela a été installé par apt :

sudo apt remove docker-compose

Résolution des problèmes courants de Docker Compose

Lorsque vous travaillez avec Docker Compose, vous pouvez rencontrer des problèmes liés à la syntaxe des fichiers, aux permissions ou aux conflits d'exécution des conteneurs. La plupart des problèmes peuvent être diagnostiqués et résolus en vérifiant méthodiquement votre configuration, vos permissions et les journaux des conteneurs.

Examinons quelques-unes des erreurs les plus courantes et leurs solutions.

Permission refusée (Socket Docker)

C'est l'une des erreurs les plus courantes pour les nouveaux utilisateurs de Docker. Vous exécutez docker compose up et voyez un message d'erreur concernant le socket du démon Docker.

permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock

  • Problème : Votre utilisateur non-root n'a pas la permission de communiquer avec le démon Docker, qui s'exécute en tant que root.

  • Solution : Vous devez ajouter votre utilisateur au groupe docker, qui a été créé lors de l’installation de Docker.

    1. Ajoutez votre utilisateur au groupe docker :

      sudo usermod -aG docker ${USER}

    2. Pour que la nouvelle adhésion au groupe entre en vigueur, vous devez vous déconnecter et vous reconnecter.

    3. Sinon, vous pouvez activer les modifications de groupe pour votre session de terminal actuelle en tapant :

      newgrp docker

    Cela devrait résoudre toutes les erreurs de permission liées au socket Docker.

Erreurs de syntaxe et d'indentation YAML

Docker Compose ne parvient pas à s'exécuter et indique que votre fichier docker-compose.yml est invalide.

ERROR: The Compose file './docker-compose.yml' is invalid because:
services.web.ports contains an invalid type, it should be a list

Mais :

mapping values are not allowed in this context at line 5
  • Problème : Le fichier docker-compose.yml repose sur une syntaxe YAML stricte. L'erreur la plus courante est une mauvaise indentation. YAML utilise des espaces, et non des tabulations, pour définir la structure.

  • Solution : Vérifiez attentivement l'indentation de votre fichier docker-compose.yml.

    • La norme est deux espaces pour chaque niveau d'indentation.
    • Assurez-vous que toutes les clés au même niveau (comme version, services, volumes) commencent dans la même colonne.
    • Assurez-vous que toutes les sous-clés (comme image, ports, volumes sous un service) soient indentées de deux espaces de plus que leur service parent (par exemple, web).
    • Utilisez un éditeur de code avec un linter YAML pour mettre en évidence automatiquement les erreurs de syntaxe.

Conflits portuaires

Vous essayez de démarrer votre environnement, mais la commande échoue avec un message d'erreur indiquant que l'adresse est déjà utilisée.

Error starting userland proxy: listen tcp 0.0.0.0:8000: bind: address already in use

  • Problème : Un autre processus sur votre machine hôte utilise déjà le port que vous essayez de mapper (dans ce cas, le port 8000). Il s'agit souvent d'un autre conteneur Docker ou d'un serveur de développement local.

  • Solution : Vous avez deux options :

    1. Arrêtez l'autre processus. Vous pouvez trouver le processus utilisant le port avec cette commande :

      sudo lsof -i :8000

      S'il s'agit d'un autre conteneur Docker, arrêtez-le avec docker stop <container_id>.

    2. Modifiez le port hôte dans votre fichier docker-compose.yml. C'est souvent la solution la plus simple. Changez le mappage des ports de "8000:80" à un autre port, comme "8001:80".

      ...
ports:
  - "8001:80" # Changed from 8000
...

      3. docker-compose.yml

Le service échoue avec Connexion refusée (depends_on)

Dans une application multi-services (comme l'exemple WordPress et MySQL), le conteneur wordpress démarre, mais ses journaux affichent Connexion refusée ou Le serveur MySQL a disparu lorsqu'il essaie de se connecter au service db.

  • Problème : Vous avez utilisé depends_on, mais cette directive attend seulement que le conteneur db démarre. Elle ne garantit pas que l'application MySQL à l'intérieur du conteneur soit entièrement initialisée et prête à accepter des connexions.

  • Solution : L'application (dans ce cas, WordPress) doit être configurée pour réessayer sa connexion. La plupart des images modernes ont cette logique de réessai intégrée. Pour les images qui ne l'ont pas, vous devez implémenter un contrôle de santé.

    Vous pouvez ajouter un healthcheck à votre service db. Le depends_on du service wordpress peut ensuite être configuré pour attendre que la base de données soit « en bonne santé » et non simplement « démarrée ».

Exemple de vérification de santé pour MySQL :

services:
  db:
    image: mysql:8.0
    ...
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-p<^your_root_password_here<^>"]
      interval: 10s
      timeout: 5s
      retries: 5

  wordpress:
    image: wordpress:latest
    ...
    depends_on:
      db:
        condition: service_healthy # This now waits for the healthcheck
    ...

Erreurs avec les volumes et les montages liés

Vous pourriez rencontrer des erreurs de permission dans les journaux de votre conteneur, ou constater que le répertoire de données de votre conteneur est vide.

Autorisations de fichier/dossier

  • Problème : Le conteneur s'exécute en tant qu'utilisateur spécifique (par exemple, www-data avec l'ID utilisateur 33), mais le répertoire de l'hôte que vous avez monté est détenu par votre utilisateur (par exemple, ubuntu avec l'ID utilisateur 1000). L'utilisateur du conteneur n'a pas la permission d'écrire dans le répertoire de l'hôte.

  • Solution : Changez la propriété du répertoire de l’hôte pour qu’elle corresponde à l’ID utilisateur à l’intérieur du conteneur. Vous pouvez trouver l’ID utilisateur du conteneur en exécutant docker compose exec <service_name> id. Par exemple, si l’ID est 33 (courant pour www-data) :

    sudo chown -R 33:33 ./wp_content

Problèmes de chemin relatif

  • Problème : Votre docker-compose.yml utilise un chemin relatif comme ./app, mais votre fichier index.html n'est pas servi.

  • Solution : Docker Compose interprète les chemins relatifs à partir du répertoire dans lequel vous exécutez la commande docker compose up. Exécutez toujours les commandes Compose à partir du même répertoire que celui contenant votre fichier docker-compose.yml.

Mise en réseau et découverte de services

Les journaux de votre conteneur d'application montrent Hôte introuvable ou Impossible de résoudre l'hôte : db.

  • Problème : Votre conteneur wordpress ne peut pas trouver le conteneur db sur le réseau.

  • Solution : Par défaut, Docker Compose crée un réseau et y connecte tous les services. Les services peuvent se trouver entre eux en utilisant leurs noms de service.

    1. Vérifier les noms de service : Assurez-vous que le nom d’hôte dans la configuration de votre application (par exemple, la variable d’environnement WORDPRESS_DB_HOST) correspond exactement au nom du service dans votre docker-compose.yml (par exemple, db).

    2. Inspecter le réseau : Utilisez docker compose ps pour trouver le nom de votre projet (par exemple, compose-demo). Ensuite, inspectez le réseau par défaut :

      docker network inspect compose-demo_default

      La sortie JSON listera tous les conteneurs connectés à ce réseau. Si l'un de vos services est manquant, vérifiez votre docker-compose.yml pour toute configuration personnalisée de networks qui pourrait l'isoler.

Incompatibilité de commande (v1 vs. v2)

Vous tapez docker-compose up (avec un trait d’union) et voyez une erreur « commande introuvable ».

docker-compose: command not found
  • Problème : Vous essayez d'utiliser la commande pour Compose v1, qui est un outil Python obsolète. Ce guide installe Compose v2, qui est un plugin intégré directement dans l'interface en ligne de commande Docker.
  • Solution : Utilisez la commande correcte en remplaçant le tiret (-) par un espace.
docker-compose (v1)docker compose (v2)
docker-compose updocker compose up
docker-compose downdocker compose down
docker-compose psdocker compose ps
docker-compose logsdocker compose logs

Utilisez toujours docker compose (espace) lorsque vous suivez ce guide.

FAQ

1. À quoi sert Docker Compose ?

Docker Compose est un outil pour définir et exécuter des applications Docker multi-conteneurs.

Il utilise un seul fichier YAML (par défaut, docker-compose.yml) pour configurer tous les composants de votre application, appelés services. Ce fichier définit également les réseaux qui permettent aux services de communiquer entre eux et les volumes utilisés pour les données persistantes.

Avec ce seul fichier, vous pouvez gérer l’ensemble de votre pile d’applications avec des commandes simples :

  • docker compose up démarre et exécute l'intégralité de votre application, y compris tous les conteneurs, réseaux et volumes spécifiés.
  • docker compose down arrête et supprime tous les conteneurs, réseaux et volumes créés par votre application.

Il est particulièrement utile pour gérer des applications nécessitant plusieurs composants, comme un site web qui a besoin d’un serveur web (comme Nginx), d’un backend d’application (comme WordPress) et d’une base de données (comme MySQL).

2. Comment installer Docker Compose sur Ubuntu ?

La méthode recommandée est d’installer Docker Compose en tant que plugin pour l’interface en ligne de commande Docker (CLI). Cela se fait en installant le paquet docker-compose-plugin depuis le dépôt officiel apt de Docker.

  1. Tout d'abord, assurez-vous d'avoir suivi la documentation officielle de Docker pour configurer le dépôt apt de Docker sur votre système Ubuntu.

  2. Mettez à jour votre liste de paquets :

    sudo apt update

  3. Installez le plugin Docker Compose :

    sudo apt install docker-compose-plugin

  4. Vérifiez l'installation en vérifiant la version. La commande utilise un espace, pas un trait d'union.

    docker compose version

3. Comment mettre Docker Compose à jour vers la dernière version ?

Puisque Docker Compose (v2) est installé comme un paquet système en utilisant apt, vous pouvez le mettre à jour en utilisant le processus standard de mise à jour des logiciels d’Ubuntu.

  1. Actualisez votre index de paquets local :

    sudo apt update

  2. Exécutez une mise à niveau du système complet, qui inclura le plugin Compose :

    sudo apt upgrade

    Sinon, si vous voulez seulement mettre à jour le plugin lui-même, vous pouvez exécuter :

    sudo apt install --only-upgrade docker-compose-plugin

4. Docker Compose peut-il être utilisé dans des environnements de production ?

Oui, Docker Compose est fréquemment utilisé en production, en particulier pour les applications qui s'exécutent sur un hôte unique.

Il fournit une manière simple de définir, déployer et gérer le cycle de vie des services, réseaux et volumes de votre application. Pour un déploiement sur un seul serveur, c’est une solution très efficace et facile à gérer.

Pour des scénarios plus complexes nécessitant de coordonner des conteneurs sur plusieurs hôtes (un cluster), d'autres outils sont plus couramment utilisés. Il s'agit notamment de Docker Swarm (qui utilise une syntaxe de fichier Compose similaire) et de Kubernetes (qui est la norme de l'industrie pour l'orchestration de conteneurs à grande échelle).

5. Quelle est la différence entre Docker et Docker Compose ?

Ce tableau présente les principales différences entre l'interface en ligne de commande Docker et l'interface en ligne de commande Docker Compose.

Fonctionnalitédocker (Moteur Docker)docker compose (Plugin Compose)
PortéeGère les objets Docker individuels.Gère une application complète multi-conteneurs comme une seule unité.
Utilisation principaleCréation d'images (docker build), exécution de conteneurs uniques (docker run), gestion des conteneurs (docker ps), des images, des volumes et des réseaux.Orchestrer plusieurs services définis dans un fichier docker-compose.yml.
CommandesCommandes de bas niveau ciblant un seul objet. Exemple : docker run -d -p 80:80 -v ./:/app nginxCommandes de haut niveau pour l’ensemble de l’application. Exemple : docker compose up
AnalogieUn élément de base (un seul conteneur).Le plan et le gestionnaire de construction de l’ensemble du bâtiment (la demande).

En résumé, vous utilisez docker pour interagir avec un seul conteneur. Vous utilisez docker compose pour gérer l'ensemble de votre pile d'applications (par exemple, web, application, base de données) en même temps.

6. Comment exécuter plusieurs conteneurs avec Docker Compose ?

Vous exécutez plusieurs conteneurs en les définissant comme des services dans votre fichier docker-compose.yml.

  1. Créez un fichier nommé docker-compose.yml.

  2. Dans ce fichier, utilisez la clé services : pour définir chaque conteneur que vous souhaitez exécuter.

    Voici un exemple pratique qui définit et exécute deux conteneurs : un site WordPress et une base de données MySQL.

    services:
  db:
    # This is the first service (container)
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: <^your_password_here<^>
      MYSQL_DATABASE: wordpress
    volumes:
      - db_data:/var/lib/mysql

  wordpress:
    # This is the second service (container)
    image: wordpress:latest
    ports:
      - "8001:80"
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_PASSWORD: <^your_password_here<^>
    depends_on:
      - db

volumes:
  db_data:

    3. docker-compose.yml

  3. Enregistrez le fichier et ouvrez un terminal dans le même répertoire.

  4. Exécutez une seule commande pour démarrer les deux conteneurs :

    docker compose up -d

Docker Compose lira le fichier, créera un réseau partagé pour les services, téléchargera les images mysql et wordpress, et démarrera un conteneur pour chaque service.

7. Pourquoi utiliser Docker Compose pour le développement ?

Docker Compose est un outil standard pour les environnements de développement parce qu'il résout plusieurs problèmes courants.

  • Environnements cohérents : Cela garantit que chaque développeur d'une équipe utilise exactement les mêmes services (base de données, cache, serveur web) avec les mêmes versions et configurations. Cela est défini dans le fichier docker-compose.yml, qui est enregistré dans le contrôle de version. Cela élimine le problème du « ça fonctionne sur ma machine ».

  • Simplicité : Il remplace les scripts d'installation complexes et les longues commandes docker run. Un développeur n'a qu'à exécuter docker compose up pour démarrer l'ensemble de la pile d'applications et docker compose down pour l'arrêter.

  • Isolation des services : Les développeurs peuvent travailler sur plusieurs projets sur la même machine sans conflits de dépendances. Le projet A peut utiliser PostgreSQL 9.6 et le projet B peut utiliser PostgreSQL 14, car chaque base de données s'exécute dans un conteneur isolé géré par son propre fichier Compose.

  • Tests d’intégration faciles : Puisque Compose démarre toutes les dépendances d’une application ensemble, il crée un environnement local idéal pour exécuter des tests d’intégration qui vérifient comment les services interagissent entre eux.

Conclusion

Dans ce guide, vous avez installé Docker Compose et configuré une application complète à plusieurs conteneurs. Vous avez commencé avec un fichier docker-compose.yml de base pour un serveur web Nginx et êtes passé à une pile plus complexe et réaliste impliquant une application WordPress et une base de données MySQL. Vous avez appris à gérer tout le cycle de vie de l'application, depuis la création et l'exécution des services jusqu'à leur arrêt et leur suppression.

Vous êtes maintenant familiarisé avec les concepts clés pour gérer efficacement les applications, y compris la mise à l'échelle des services, les définitions de réseau personnalisées et la séparation de votre configuration en fichiers modulaires à l'aide de la directive include. En suivant le guide de migration et les étapes de dépannage, vous pouvez également résoudre des problèmes courants tels que les conflits de ports, les erreurs « Permission refusée » et les erreurs de syntaxe YAML. Les compétences abordées ici vous permettront de créer des environnements de développement cohérents et reproductibles et de déployer des applications sur un serveur unique en toute confiance.

Pour une référence complète de toutes les commandes docker compose disponibles, consultez la documentation officielle.

Pour d'autres tutoriels liés à Docker, consultez les articles suivants :

  • Comment installer Docker sur Ubuntu – Guide étape par étape
  • Comment installer WordPress avec Docker Compose

Merci de apprendre avec la communauté Linux-Console.net.