Tutoriel : Créer des applications à plusieurs conteneurs avec MySQL et Docker Compose

2025-06-09

Cet article explique comment créer des applications à plusieurs conteneurs avec MySQL et Docker Compose. Une application avec plusieurs conteneurs vous permet de dédier des conteneurs pour des tâches spécialisées, afin que chaque conteneur puisse se concentrer sur une seule tâche. Il existe de nombreux avantages à l’utilisation d’applications multiconteneurs :

Les conteneurs distincts vous permettent de gérer les API et les ressources frontales différemment des bases de données.
Plusieurs conteneurs vous permettent de versionner et de mettre à jour les versions de manière isolée.
Les bases de données locales peuvent être conservées dans des conteneurs et des services managés utilisés pour les bases de données en production.
Les applications multi-conteneurs sont plus efficaces que l’exécution de plusieurs processus avec un gestionnaire de processus, ce qui ajoute de la complexité au démarrage/à l’arrêt du conteneur.

Dans ce tutoriel, vous allez :

Démarrer MySQL
Exécuter votre application multiconteneur avec MySQL
Créer un fichier Docker Compose pour votre application
Exécuter la pile d’applications avec Docker Compose

Conditions préalables

Cet article fait partie d’une série de tutoriels. Les procédures s’appuient sur un exemple établi qui nécessite Docker Desktop pour les conteneurs Linux.

L’approche recommandée consiste à suivre le premier didacticiel, créer une application conteneur, y compris satisfaire les conditions préalables, ainsi que le didacticiel , conserver les données dans votre application. Une fois que vous avez suivi ces didacticiels, suivez les procédures décrites dans cet article.
L’exemple de cet article utilise Docker Compose.
- Fenêtres
- Linux
Docker Desktop pour Windows inclut Docker Compose.

Exécutez la commande suivante pour vérifier votre installation docker :
```
docker-compose version
```
Pour Linux, suivez les instructions pour installer Docker Compose.

Visual Studio Code

Cette série de tutoriels décrit les procédures pour Visual Studio Code (VS Code). Passez en revue les considérations suivantes pour travailler dans cet environnement :

Utilisez le menu de gauche pour basculer entre l’explorateur de conteneurs ou l’affichage EXPLORATEUR (fichier et dossier) :
Ouvrez une fenêtre de ligne de commande dans VS Code en sélectionnant Terminal>Nouveau terminal. Vous pouvez également utiliser le raccourci clavier Ctrl+Maj+` (graduation arrière).
Sauf indication contraire, exécutez des commandes dans une fenêtre Bash. La plupart des commandes étiquetées pour Bash s’exécutent dans une fenêtre Bash ou dans la fenêtre de ligne de commande VS Code.

Démarrer le système de gestion de base de données MySQL

Par défaut, les conteneurs s’exécutent en isolement. Un conteneur ne connaît pas d’autres processus ou d’autres conteneurs sur le même ordinateur.

Pour permettre la communication entre les conteneurs, elles doivent être attachées au même réseau. Plusieurs conteneurs sur le même réseau peuvent partager des données et traiter des informations entre elles.

Il existe deux façons d’attacher un conteneur à un réseau. Vous pouvez attacher un conteneur à un réseau pendant la création ou attacher un conteneur existant à un réseau ultérieurement.

Dans cet exemple, vous créez le réseau et attachez le conteneur MySQL au démarrage.

Créez un réseau nommé todo-app:
```
docker network create todo-app
```
Démarrez un conteneur MySQL nommé todo-mysql-data et attachez-le au réseau todo-app. La commande crée un alias réseau mysql pour la base de données MySQL todos.

Lorsque vous exécutez la commande, entrez votre mot de passe racine MySQL pour l’espace réservé <your-password>.
```
docker run -d --network todo-app --network-alias mysql -v todo-mysql-data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=<your-password> -e MYSQL_DATABASE=todos mysql:lts
```
Cette commande définit également les variables d’environnement MYSQL_ROOT_PASSWORD et MYSQL_DATABASE. Pour plus d’informations, consultez la liste MySQL sur le Hub Docker .

Avertissement

Ce tutoriel illustre les informations d’identification de mot de passe à authentifier avec une base de données MySQL, ce qui n’est pas la méthode la plus sécurisée. Reportez-vous à la documentation MySQL pour en savoir plus sur les méthodes d’authentification plus sécurisées.
Obtenez votre ID de conteneur à utiliser à l’étape suivante.
```
docker ps
```
Vérifiez que vous pouvez vous connecter au conteneur sur le réseau mysql.

Lorsque vous exécutez la commande, entrez votre identifiant de conteneur pour l’espace réservé <mysql-container-id>.
```
docker exec -it <mysql-container-id> mysql -p
```
À l’invite, entrez le mot de passe que vous avez fourni lors de la création du conteneur todo-mysql-data.

Dans l'interpréteur de commandes MySQL, énumérez les bases de données et vérifiez que vous voyez la base de données todos.

SHOW DATABASES;

La sortie suivante doit s’afficher :

+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
| todos              |
+--------------------+
5 rows in set (0.00 sec)

Pour terminer la connexion et revenir à l’invite de ligne de commande, entrez quitter.

Exécuter votre application avec MySQL

L’application todo prend en charge la définition de certaines variables d’environnement pour spécifier vos paramètres de connexion MySQL. Le tableau suivant répertorie les variables prises en charge et les valeurs utilisées dans l’exemple présenté dans cette section.

Nom de la variable	Exemple de valeur	Descriptif
`MYSQL_HOST`	`mysql`	Nom d’hôte du serveur MySQL.
`MYSQL_USER`	`root`	Nom d’utilisateur à utiliser pour la connexion.
`MYSQL_PASSWORD`	`<your-password>`	Mot de passe à utiliser pour la connexion. Dans cet exemple, remplacez votre mot de passe racine par le symbole de remplacement `<your-password>`.
`MYSQL_DATABASE`	`todos`	Nom de la base de données à utiliser une fois la connexion établie.

Avertissement

L’utilisation de variables d’environnement pour définir les paramètres de connexion est acceptable pour le développement, mais cette pratique n’est pas recommandée pour l’exécution d’applications en production. Pour plus d’informations, consultez Pourquoi vous ne devez pas utiliser de variables d’environnement pour les données secrètes.

Un mécanisme plus sécurisé consiste à utiliser la prise en charge secrète fournie par votre infrastructure d’orchestration de conteneurs. Dans la plupart des cas, ces secrets sont montés en tant que fichiers dans le conteneur en cours d’exécution.

Dans l’exemple suivant, vous démarrez votre application et connectez votre conteneur d’application à votre conteneur MySQL.

Exécutez la commande docker suivante. Notez comment la commande spécifie les variables d’environnement décrites précédemment.

Lorsque vous exécutez la commande, n’oubliez pas d’entrer votre mot de passe racine MySQL pour l’espace réservé <your-password>.
```
docker run -dp 3000:3000 -w /app -v ${PWD}:/app --network todo-app -e MYSQL_HOST=mysql -e MYSQL_USER=root -e MYSQL_PASSWORD=<your-password> -e MYSQL_DB=todos node:lts-alpine sh -c "yarn install && yarn run dev"
```
Dans l’éditeur VS Code, ouvrez l’Explorateur de conteneurs, cliquez avec le bouton droit sur votre conteneur d’applications, puis sélectionnez Afficher les journaux.

Vous pouvez également afficher les journaux depuis la ligne de commande à l’aide de la commande docker logs.

Passez en revue la sortie du journal. Notez la ligne qui indique que l’application est connectée à la base de données MySQL : Connected to mysql db at host mysql.

# Previous log messages omitted
$ nodemon src/index.js
[nodemon] 1.19.2
[nodemon] to restart at any time, enter `rs`
[nodemon] watching dir(s): *.*
[nodemon] starting `node src/index.js`
Connected to mysql db at host mysql
Listening on port 3000

Dans votre navigateur Internet, accédez à votre application en cours d’exécution : http://localhost:3000.
Dans votre application en cours d’exécution, ajoutez des éléments à votre liste de tâches.
Connectez-vous à la base de données de conteneur MySQL sur le réseau mysql afin de pouvoir vérifier la base de données.

Lorsque vous exécutez la commande, entrez votre identifiant de conteneur pour l’espace réservé <mysql-container-id>.
```
docker exec -ti <mysql-container-id> mysql -p todos
```
À l’invite, entrez le mot de passe que vous avez fourni lors de la création du conteneur todo-mysql-data.

Dans l’interpréteur de commandes MySQL, vérifiez que les todo_items que vous avez ajoutées sont écrites dans la base de données todos.

use todos;
select * from todo_items;

Vous devez voir une sortie similaire à l’exemple suivant :

+--------------------------------------+--------------------+-----------+
| id                                   | name               | completed |
+--------------------------------------+--------------------+-----------+
| c906ff08-60e6-44e6-8f49-ed56a0853e85 | Do amazing things! |         0 |
| 2912a79e-8486-4bc3-a4c5-460793a575ab | Be awesome!        |         0 |
+--------------------------------------+--------------------+-----------+

Vous disposez maintenant d’une application qui stocke des données dans une base de données externe s’exécutant dans un conteneur distinct. Cette procédure montre comment activer la communication entre les conteneurs à l’aide de la mise en réseau.

Créer un fichier Docker Compose

Docker Compose vous aide à définir et partager des applications multiconteneurs. Un fichier Docker Compose peut spécifier tous vos services requis. Vous pouvez donc démarrer ou mettre fin à tous les processus associés avec une seule commande. Vous pouvez définir votre pile d’applications dans un fichier Docker Compose à la racine de votre dépôt de projet et gérer votre configuration sous contrôle de version. Cette approche permet aux autres utilisateurs de contribuer à votre projet lorsqu’ils clonent votre dépôt.

Dans l’exemple suivant, vous configurez un fichier Docker Compose pour votre application multiconteneur todo.

À la racine de votre projet d’application todo, créez un fichier Docker Compose nommé docker-compose.yml.

Remarque

Par défaut, la version du schéma YAML est définie sur la version la plus récente. Lorsque vous exécutez votre application, si votre version de schéma est obsolète, vous recevez un message d’avertissement. Pour passer en revue les versions actuelles du schéma et une matrice de compatibilité, consultez Vue d’ensemble (fichier Compose).
Dans le fichier docker-compose.yml, ajoutez les éléments suivants. Spécifiez votre application name et démarrez la liste des services (ou conteneurs) que vous souhaitez exécuter dans le cadre de votre application.
```
name: todo

services:
```
La liste des services est unique pour votre application. Les exemples incluent app, web, db, proxy, et ainsi de suite. Vous étendez la définition de l’élément services dans une étape ultérieure.

Conseil

La mise en retrait est significative dans les fichiers .yml. Si vous modifiez dans VS Code, IntelliSense indique les erreurs dans le format ou la syntaxe.
Revenez à la définition services dans le fichier docker-compose.yml. Étendez la définition en ajoutant une entrée pour définir l’élément de service app, qui inclut l’image du conteneur.
```
services:
  app:
    image: node:lts-alpine
```
Vous pouvez choisir n’importe quel nom pour le service. Le nom devient automatiquement un alias réseau, ce qui est utile lorsque vous définissez le service MySQL.

Étendez la définition d’élément app pour spécifier une command à exécuter.

  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"

Définissez le ports à utiliser avec le service app. Notez que ces ports correspondent à l’argument -p 3000:3000 de la commande utilisée pour exécuter l’application avec MySQL.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
```
Identifiez le répertoire de travail working_dir pour le service app et également le volumesmappé.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
```
Lorsque vous définissez des volumes Docker Compose, vous pouvez utiliser des chemins relatifs basés sur le répertoire actif.

Spécifiez les définitions de variables environment à utiliser lorsque vous exécutez des commandes pour le service app.

  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
    environment:
      MYSQL_HOST: mysql
      MYSQL_USER: root
      MYSQL_PASSWORD: <your-password>
      MYSQL_DB: todos

N'oubliez pas de saisir votre mot de passe root MySQL pour le placeholder <your-password>.

Ajoutez la définition du service MySQL mysql après la définition du service app. Spécifiez les noms et les valeurs des éléments comme indiqué et avec la même mise en retrait.
```
services:
  app:
    ...
  mysql:
    image: mysql:lts
```
La définition du service mysql correspond à la commande que vous avez utilisée précédemment pour démarrer MySQL. Lorsque vous définissez le service, il reçoit automatiquement l’alias réseau.

Identifiez le volumes mappé pour le service mysql.

services:
  app:
    ...
  mysql:
    image: mysql:lts
    volumes:
      - todo-mysql-data:/var/lib/mysql

Spécifiez les définitions de variables environment à utiliser lorsque vous exécutez des commandes pour le service mysql.
```
services:
  app:
    ...
  mysql:
    image: mysql:lts
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment: 
      MYSQL_ROOT_PASSWORD: <your-password>
      MYSQL_DATABASE: todos
```
N'oubliez pas de saisir votre mot de passe root MySQL pour le placeholder <your-password>.
Définissez le mappage de volume pour l’ensemble de l’application. Ajoutez une section volumes: après la section services: et avec la même mise en retrait.
```
services:
   ...

volumes:
  todo-mysql-data:
```

Vérifiez que votre fichier docker-compose.yml terminé ressemble à l’exemple suivant. Vous devez voir votre mot de passe racine MySQL pour l’espace réservé <your-password>.

name: todo

services:
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
    environment:
      MYSQL_HOST: mysql
      MYSQL_USER: root
      MYSQL_PASSWORD: <your-password>
      MYSQL_DB: todos

  mysql:
    image: mysql:lts
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment: 
      MYSQL_ROOT_PASSWORD: <your-password>
      MYSQL_DATABASE: todos

volumes:
  todo-mysql-data:

Exécuter la pile d’applications avec Docker Compose

Vous pouvez maintenant essayer d’exécuter votre fichier docker-compose.yml.

Arrêtez les instances en cours d’exécution de votre application et de votre base de données.
- Visual Studio Code
- Ligne de commande
Procédez comme suit dans VS Code :
1. Ouvrez CONTAINER EXPLORER (extension Container Tools).
2. Pour chaque conteneur en cours d’exécution, cliquez avec le bouton droit sur le conteneur, puis sélectionnez Supprimer.
Exécutez les commandes suivantes dans une fenêtre de ligne de commande ou un terminal :
1. Obtenez la liste des conteneurs en cours d’exécution et leurs identificateurs <container-id> :
```
docker ps
```
2. Arrêtez et supprimez chaque conteneur actif :
```
docker stop <container-id>
docker rm <container-id>
```
Démarrez votre application multiconteneur et tous les services.
- Visual Studio Code
- Ligne de commande
Procédez comme suit dans VS Code :
1. Ouvrez la vue EXPLORER (fichier et dossier).
2. Cliquez avec le bouton droit sur le fichier docker-compose.yml, puis sélectionnez Compose Up.
Exécutez la commande suivante avec l’argument -d, qui exécute la commande en tant que processus en arrière-plan :
```
docker-compose up -d
```
Vous devez voir une sortie similaire à l’exemple suivant :
```
[+] Building 0.0s (0/0)
[+] Running 2/2
✔ Container app-app-1    Started  0.9s 
✔ Container app-mysql-1  Running
```
Cette opération crée le volume mappé pour l’application et le réseau. Par défaut, Docker Compose crée un réseau spécifiquement pour la pile d’applications.
Passez en revue les journaux d’activité du conteneur en cours d’exécution.
- Visual Studio Code
- Ligne de commande
Procédez comme suit dans VS Code :
1. Ouvrez CONTAINER EXPLORER (extension Container Tools).
2. Faites un clic droit sur le conteneur de l’application, puis sélectionnez Afficher les journaux.
Exécutez la commande suivante :
```
docker logs
```
Vous pouvez afficher les journaux d’activité d’un service spécifique en ajoutant le nom du service, tel que app à la fin de la commande logs :
```
docker logs <service-name>
```
Vous devez voir une sortie similaire à l’exemple suivant :
```
mysql_1  | 2019-10-03T03:07:16.083639Z 0 [Note] mysqld: ready for connections.
mysql_1  | Version: '5.7.27'  socket: '/var/run/mysqld/mysqld.sock'  port: 3306  MySQL Community Server (GPL)
app_1    | Connected to mysql db at host mysql
app_1    | Listening on port 3000
```
Les journaux affichent, au début de chaque ligne, le nom du service et le numéro d'instance, tels que app_1. Ce format vous permet de distinguer les messages par service et par instance. Les journaux de chaque service est entrelacé dans un seul flux. Cette approche vous permet de surveiller les problèmes liés au minutage.
Vous pouvez maintenant accéder à votre application en cours d’exécution dans votre navigateur Internet : http://localhost:3000.

Arrêter Docker Compose et les conteneurs en cours d'exécution

Lorsque vous avez terminé avec l’application et les conteneurs, vous pouvez les supprimer.

Visual Studio Code
Ligne de commande

Procédez comme suit dans VS Code :

Ouvrez la vue EXPLORER (fichier et dossier).
Faites un clic droit sur le fichier docker-compose.yml, puis sélectionnez Composer vers le bas.

Exécutez la commande suivante pour arrêter l’application et les conteneurs en cours d’exécution :

docker-compose down

Cette opération arrête tous les conteneurs actuellement actifs et supprime le réseau.

Par défaut, les volumes nommés dans votre fichier de composition ne sont pas supprimés. Si vous souhaitez supprimer ces volumes, vous pouvez utiliser la commande docker-compose down --volumes.

Nettoyer les ressources

Si vous avez appliqué les composants prérequis de cette série de tutoriels à votre installation, vous pouvez réutiliser la configuration pour le développement Docker ultérieur. Il n’est pas essentiel de supprimer ou de désinstaller un composant.

Partager via