Utiliser Docker Compose

Table des matières

Docker Compose est un outil qui vous aide à définir et partager des applications multi-conteneurs. Avec Compose, vous pouvez créer un fichier YAML pour définir les services et avec une seule commande, vous pouvez tout faire tourner ou tout arrêter.

Le grand avantage d'utiliser Compose est que vous pouvez définir votre pile d'applications dans un fichier, le garder à la racine de votre dépôt de projet (il est maintenant sous contrôle de version), et facilement permettre à quelqu'un d'autre de contribuer à votre projet. Quelqu'un n'aurait qu'à cloner votre dépôt et démarrer l'application en utilisant Compose. En fait, vous pourriez voir pas mal de projets sur GitHub/GitLab faire exactement cela maintenant.

Créer le fichier Compose

Dans le répertoire getting-started-app, créez un fichier nommé compose.yaml.

├── getting-started-app/
│ ├── Dockerfile
│ ├── compose.yaml
│ ├── node_modules/
│ ├── package.json
│ ├── spec/
│ ├── src/
│ └── yarn.lock

Définir le service d'application

Dans la partie 6, vous avez utilisé la commande suivante pour démarrer le service d'application.

$ docker run -dp 127.0.0.1:3000:3000 \
  -w /app -v "$(pwd):/app" \
  --network todo-app \
  -e MYSQL_HOST=mysql \
  -e MYSQL_USER=root \
  -e MYSQL_PASSWORD=secret \
  -e MYSQL_DB=todos \
  node:18-alpine \
  sh -c "yarn install && yarn run dev"

Vous allez maintenant définir ce service dans le fichier compose.yaml.

Ouvrez compose.yaml dans un éditeur de texte ou de code, et commencez par définir le nom et l'image du premier service (ou conteneur) que vous voulez exécuter dans le cadre de votre application. Le nom deviendra automatiquement un alias de réseau, ce qui sera utile lors de la définition de votre service MySQL.
services: app: image: node:18-alpine
Typiquement, vous verrez command près de la définition image, bien qu'il n'y ait aucune exigence sur l'ordre. Ajoutez la command à votre fichier compose.yaml.
services: app: image: node:18-alpine command: sh -c "yarn install && yarn run dev"

Maintenant migrez la partie -p 127.0.0.1:3000:3000 de la commande en définissant les ports pour le service.

services:
  app:
    image: node:18-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 127.0.0.1:3000:3000

Ensuite, migrez à la fois le répertoire de travail (-w /app) et le mappage de volume (-v "$(pwd):/app") en utilisant les définitions working_dir et volumes.

Un avantage des définitions de volume Docker Compose est que vous pouvez utiliser des chemins relatifs depuis le répertoire courant.
services: app: image: node:18-alpine command: sh -c "yarn install && yarn run dev" ports: - 127.0.0.1:3000:3000 working_dir: /app volumes: - ./:/app

Enfin, vous devez migrer les définitions de variables d'environnement en utilisant la clé environment.

services:
  app:
    image: node:18-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 127.0.0.1:3000:3000
    working_dir: /app
    volumes:
      - ./:/app
    environment:
      MYSQL_HOST: mysql
      MYSQL_USER: root
      MYSQL_PASSWORD: secret
      MYSQL_DB: todos

Définir le service MySQL

Maintenant, il est temps de définir le service MySQL. La commande que vous avez utilisée pour ce conteneur était la suivante :

$ docker run -d \
  --network todo-app --network-alias mysql \
  -v todo-mysql-data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=secret \
  -e MYSQL_DATABASE=todos \
  mysql:8.0

Définissez d'abord le nouveau service et nommez-le mysql pour qu'il obtienne automatiquement l'alias de réseau. Spécifiez aussi l'image à utiliser.
services: app: # La définition du service app mysql: image: mysql:8.0
Ensuite, définissez le mappage de volume. Quand vous avez exécuté le conteneur avec docker run, Docker a créé le volume nommé automatiquement. Cependant, cela n'arrive pas lors de l'exécution avec Compose. Vous devez définir le volume dans la section volumes: de niveau supérieur puis spécifier le point de montage dans la configuration du service. En fournissant simplement le nom du volume, les options par défaut sont utilisées.
services: app: # La définition du service app mysql: image: mysql:8.0 volumes: - todo-mysql-data:/var/lib/mysql volumes: todo-mysql-data:

Enfin, vous devez spécifier les variables d'environnement.

services:
  app:
    # La définition du service app
  mysql:
    image: mysql:8.0
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: todos

volumes:
  todo-mysql-data:

À ce stade, votre compose.yaml complet devrait ressembler à ceci :

services:
  app:
    image: node:18-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 127.0.0.1:3000:3000
    working_dir: /app
    volumes:
      - ./:/app
    environment:
      MYSQL_HOST: mysql
      MYSQL_USER: root
      MYSQL_PASSWORD: secret
      MYSQL_DB: todos

  mysql:
    image: mysql:8.0
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: todos

volumes:
  todo-mysql-data:

Exécuter la pile d'applications

Maintenant que vous avez votre fichier compose.yaml, vous pouvez démarrer votre application.

Assurez-vous qu'aucune autre copie des conteneurs n'est en cours d'exécution d'abord. Utilisez docker ps pour lister les conteneurs et docker rm -f <ids> pour les supprimer.
Démarrez la pile d'applications en utilisant la commande docker compose up. Ajoutez le flag -d pour tout exécuter en arrière-plan.
$ docker compose up -d
Quand vous exécutez la commande précédente, vous devriez voir une sortie comme la suivante :
Creating network "app_default" with the default driver Creating volume "app_todo-mysql-data" with default driver Creating app_app_1 ... done Creating app_mysql_1 ... done
Vous remarquerez que Docker Compose a créé le volume ainsi qu'un réseau. Par défaut, Docker Compose crée automatiquement un réseau spécifiquement pour la pile d'applications (c'est pourquoi vous n'en avez pas défini un dans le fichier Compose).
Regardez les journaux en utilisant la commande docker compose logs -f. Vous verrez les journaux de chacun des services entrelacés dans un seul flux. C'est incroyablement utile quand vous voulez surveiller les problèmes liés au timing. Le flag -f suit le journal, donc vous donnera une sortie en direct au fur et à mesure qu'elle est générée.

Si vous avez déjà exécuté la commande, vous verrez une sortie qui ressemble à ceci :
mysql_1 | 2019-10-03T03:07:16.083639Z 0 [Note] mysqld: ready for connections. mysql_1 | Version: '8.0.31' 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
Le nom du service est affiché au début de la ligne (souvent coloré) pour aider à distinguer les messages. Si vous voulez voir les journaux pour un service spécifique, vous pouvez ajouter le nom du service à la fin de la commande logs (par exemple, docker compose logs -f app).
À ce stade, vous devriez pouvoir ouvrir votre application dans votre navigateur sur http://localhost:3000 et la voir s'exécuter.

Voir la pile d'applications dans le tableau de bord Docker Desktop

Si vous regardez le tableau de bord Docker Desktop, vous verrez qu'il y a un groupe nommé getting-started-app. C'est le nom du projet de Docker Compose et utilisé pour regrouper les conteneurs ensemble. Par défaut, le nom du projet est simplement le nom du répertoire où le compose.yaml était situé.

Si vous développez la pile, vous verrez les deux conteneurs que vous avez définis dans le fichier Compose. Les noms sont aussi un peu plus descriptifs, car ils suivent le modèle de <nom-service>-<numéro-réplique>. Donc, il est très facile de voir rapidement quel conteneur est votre application et quel conteneur est la base de données mysql.

Tout démolir

Quand vous êtes prêt à tout démolir, exécutez simplement docker compose down ou cliquez sur la corbeille sur le tableau de bord Docker Desktop pour toute l'application. Les conteneurs s'arrêteront et le réseau sera supprimé.

Warning

Par défaut, les volumes nommés dans votre fichier compose ne sont pas supprimés quand vous exécutez docker compose down. Si vous voulez supprimer les volumes, vous devez ajouter le flag --volumes.

Le tableau de bord Docker Desktop ne supprime pas les volumes quand vous supprimez la pile d'applications.

Résumé

Dans cette section, vous avez appris Docker Compose et comment il vous aide à simplifier la façon dont vous définissez et partagez des applications multi-services.

Informations connexes :

Étapes suivantes

Ensuite, vous apprendrez quelques meilleures pratiques que vous pouvez utiliser pour améliorer votre Dockerfile.

Meilleures pratiques de construction d'images