Comment utiliser Docker Compose

Qu'est-ce que Docker Compose ?

Si votre application Docker comprend plusieurs conteneurs (par exemple, un serveur Web et une base de données s'exécutant dans des conteneurs distincts), la création, l'exécution et la connexion des conteneurs à partir de Dockerfiles distincts sont fastidieuses et chronophages. Docker Compose résout ce problème en vous permettant d'utiliser un fichier YAML pour définir des applications multi-conteneurs. Vous pouvez configurer autant de conteneurs que vous le souhaitez, comment ils doivent être construits et connectés, et où les données doivent être stockées. Une fois le fichier YAML terminé, vous pouvez exécuter une seule commande pour créer, exécuter et configurer tous les conteneurs.

Ce guide vous expliquera comment le docker-compose.yml est organisé et montrez comment l'utiliser pour créer plusieurs configurations d'application de base.

Remarque Généralement, les conteneurs d'une application créée à l'aide de Docker Compose s'exécutent tous sur le même hôte. La gestion des conteneurs s'exécutant sur différents hôtes nécessite généralement un outil supplémentaire, tel que Docker Swarm ou Kubernetes.

Avant de commencer

Installer Docker CE

Vous aurez besoin d'un Linode avec Docker CE installé pour suivre les étapes de ce guide.

Pour installer Docker CE (Community Edition), suivez les instructions de l'un des guides ci-dessous :

Installation et utilisation de Docker sur Ubuntu et Debian
Installation et utilisation de Docker sur CentOS et Fedora

Pour obtenir des instructions complètes sur encore plus de distributions Linux, consultez la section Install Docker Engine de la documentation officielle de Docker.

Installer Docker Compose

Téléchargez la dernière version de Docker Compose. Consultez la page des versions et remplacez 1.25.4 dans la commande ci-dessous avec la version marquée comme Dernière version :
```
 sudo curl -L https://github.com/docker/compose/releases/download/1.25.4/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
```

Définir les autorisations de fichier :

 sudo chmod +x /usr/local/bin/docker-compose

Utilisation de base

Cette section passera en revue un exemple de fichier Docker Compose tiré de la documentation officielle de Docker.

Ouvrez docker-compose.yml dans un éditeur de texte et ajoutez le contenu suivant :

Fichier :menu fixe -compose.yml

version: '3'

services:
   db:
     image: mysql:5.7
     volumes:
       - db_data:/var/lib/mysql
     restart: always
     environment:
       MYSQL_ROOT_PASSWORD: somewordpress
       MYSQL_DATABASE: wordpress
       MYSQL_USER: wordpress
       MYSQL_PASSWORD: wordpress

   wordpress:
     depends_on:
       - db
     image: wordpress:latest
     ports:
       - "8000:80"
     restart: always
     environment:
       WORDPRESS_DB_HOST: db:3306
       WORDPRESS_DB_USER: wordpress
       WORDPRESS_DB_PASSWORD: wordpress
volumes:
    db_data:

Enregistrez le fichier et exécutez Docker Compose depuis le même répertoire :
```
docker-compose up -d
```
Cela construira et exécutera la db et wordpress conteneurs. Tout comme lors de l'exécution d'un seul conteneur avec docker run , le -d flag démarre les conteneurs en mode détaché.
Vous avez maintenant un conteneur WordPress et un conteneur MySQL en cours d'exécution sur votre hôte. Accédez à 192.0.8.1:8000/wordpress dans un navigateur Web pour voir votre application WordPress nouvellement installée. Vous pouvez également utiliser docker ps pour explorer davantage la configuration résultante :
```
docker ps
```
Arrêtez et retirez les conteneurs :
```
docker-compose down
```

Composer la syntaxe du fichier

Un docker-compose.yml le fichier est organisé en quatre sections :

Directive	Utiliser
version	Spécifie la version de la syntaxe du fichier Compose. Ce guide utilisera la version 3 tout au long.
services	Dans Docker, un service est le nom d'un "Conteneur en production". Cette section définit les conteneurs qui seront démarrés dans le cadre de l'instance Docker Compose.
réseaux	Cette section est utilisée pour configurer la mise en réseau de votre application. Vous pouvez modifier les paramètres du réseau par défaut, vous connecter à un réseau externe ou définir des réseaux spécifiques à une application.
volumes	Monte un chemin lié sur la machine hôte qui peut être utilisé par le conteneur.

La majeure partie de ce guide se concentrera sur la configuration des conteneurs à l'aide des services section. Voici quelques-unes des directives courantes utilisées pour installer et configurer les conteneurs :

Directive	Utiliser
image	Définit l'image qui sera utilisée pour construire le conteneur. L'utilisation de cette directive suppose que l'image spécifiée existe déjà sur l'hôte ou sur Docker Hub.
construire	Cette directive peut être utilisée à la place de `image` . Spécifie l'emplacement du Dockerfile qui sera utilisé pour construire ce conteneur.
db	Dans le cas de l'exemple de fichier Dockercompose, `db` est une variable pour le conteneur que vous êtes sur le point de définir.
redémarrer	Dit au conteneur de redémarrer si le système redémarre.
volumes	Monte un chemin lié sur la machine hôte qui peut être utilisé par le conteneur
environnement	Définissez les variables d'environnement à transmettre à la commande d'exécution de Docker.
dépend de	Définit un service en tant que dépendance pour le conteneur actuel défini par bloc
port	Mappe un port du conteneur à l'hôte de la manière suivante :`host:container`
liens	Liez ce service à tout autre service du fichier Docker Compose en spécifiant leurs noms ici.

De nombreuses autres directives de configuration sont disponibles. Voir la référence Compose File pour plus de détails.

Attention L'exemple docker-compose.yml ci-dessus utilise l'environment pour stocker les mots de passe des utilisateurs MySQL directement dans le fichier YAML à importer dans le conteneur en tant que variables d'environnement. Ceci n'est pas recommandé pour les informations sensibles dans les environnements de production. Au lieu de cela, les informations sensibles peuvent être stockées dans un .env séparé fichier (qui n'est pas archivé dans le contrôle de version ou rendu public) et accessible depuis docker-compose.yml en utilisant le env_file directive.

Créer une application à partir de zéro

Créez un docker-compose.yml classez une section à la fois pour illustrer les étapes de création d'une application multi-conteneurs.

Définir un service simple :

Créez un nouveau docker-compose.yml dans un éditeur de texte et ajoutez le contenu suivant :
Fichier :menu fixe -compose.yml
1 2 3 4 5 6 7 8

version: '3' services: distro: image: alpine restart: always container_name: Alpine_Distro entrypoint: tail -f /dev/null
Chaque entrée dans les services La section créera un conteneur séparé lorsque docker-compose est exécuté. À ce stade, la section contient un seul conteneur basé sur la distribution officielle Alpine :
- Le restart est utilisée pour indiquer que le conteneur doit toujours redémarrer (après un crash ou un redémarrage du système, par exemple).
- Le container_name est utilisée pour remplacer le nom du conteneur généré aléatoirement et le remplacer par un nom plus facile à retenir et à utiliser.
- Les conteneurs Docker se ferment par défaut si aucun processus ne s'y exécute. tail -f est un processus continu, il s'exécutera donc indéfiniment et empêchera le conteneur de s'arrêter. Le entrypoint par défaut est remplacé pour maintenir le conteneur en cours d'exécution.
Affichez votre conteneur :
```
docker-compose up -d
```

Vérifiez l'état de votre conteneur :

 docker ps

Le résultat devrait ressembler à ce qui suit :

CONTAINER ID        IMAGE               COMMAND               CREATED             STATUS              PORTS               NAMES
967013c36a27        alpine              "tail -f /dev/null"   3 seconds ago       Up 2 seconds                            Alpine_Distro

Descendez le conteneur :
```
 docker-compose down
```

Ajouter des services supplémentaires

À partir de là, vous pouvez commencer à créer un écosystème de conteneurs. Vous pouvez définir comment ils travaillent ensemble et communiquent.

Rouvrez docker-compos.yml et ajoutez la database services ci-dessous :

Fichier :menu fixe -compose.yml

version: '3'

services:
  distro:
    image: alpine
    container_name: Alpine_Distro
    restart: always
    entrypoint: tail -f /dev/null

  database:
    image: postgres:latest
    container_name: postgres_db
    volumes:
      - ../dumps:/tmp/
    ports:
      - "5432:5432"

Deux services sont désormais définis :

Distro
Base de données

Le service Distro est le même qu'avant. Le serveur de base de données contient les instructions pour un conteneur postgres et les directives :volumes: - ../dumps:/tmp et ports:-"5432:5432" , la première directive mappe le conteneur et /dumps dossier dans notre /tmp local dossier. La deuxième directive mappe les ports des conteneurs sur les ports de l'hôte local.

Vérifiez les conteneurs en cours d'exécution :

docker ps

Cette commande affiche l'état des conteneurs, le mappage des ports, les noms et la dernière commande exécutée sur eux. Il est important de noter que le conteneur postgres lit "docker-entrypoint…" sous les commandes. Le script PostgresDocker Entrypoint est la dernière chose qui se lance au démarrage du conteneur.

CONTAINER ID        IMAGE               COMMAND                  CREATED              STATUS              PORTS                    NAMES
ecc37246f6ef        postgres:latest     "docker-entrypoint..."   About a minute ago   Up About a minute   0.0.0.0:5432->5432/tcp   postgres_db
35dab3e712d6        alpine              "tail -f /dev/null"      About a minute ago   Up About a minute                            Alpine_Distro

Abattez les deux conteneurs :
```
 docker-compose down
```

Ajouter un service nginx

Ajoutez un conteneur nginx pour que votre application puisse servir des sites Web :

Fichier :menu fixe -compose.yml

version: '3'

services:
  distro:
    image: alpine
    container_name: Alpine_Distro
    restart: always
    entrypoint: tail -f /dev/null

  database:
    image: postgres:latest
    container_name: postgres_db
    volumes:
      - ../dumps:/tmp/
    ports:
      - "5432:5432"
  web:
    image: nginx:latest
    container_name: nginx
    volumes:
      - ./mysite.template:/etc/nginx/conf.d/mysite.template
    ports:
      - "8080:80"
    environment:
      - NGINX_HOST=example.com
      - NGINX_port=80
    links:
      - database:db
      - distro

Ce docker-compose le fichier contient de nouvelles directives :environnement et liens . La première directive définit les options de niveau d'exécution dans le conteneur. links crée un réseau de dépendance entre les conteneurs. Le conteneur nginx dépend des deux autres pour s'exécuter. De plus, les conteneurs correspondants seront accessibles à un nom d'hôte indiqué par l'alias. Dans ce cas, cingler db depuis le web le conteneur atteindra la database un service. Bien que vous n'ayez pas besoin des links directive pour que les conteneurs communiquent entre eux, links peut servir de sécurité intégrée lors du démarrage de l'application docker-compose.

Démarrez Docker Compose et vérifiez l'état du conteneur :

 docker-compose up -d
 docker ps

Le résultat devrait ressembler à :

CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
55d573674e49        nginx:latest        "nginx -g 'daemon ..."   3 minutes ago       Up 3 minutes        0.0.0.0:8080->80/tcp     nginx
ad9e48b2b82a        alpine              "tail -f /dev/null"      3 minutes ago       Up 3 minutes                                 Alpine_Distro
736cf2f2239e        postgres:latest     "docker-entrypoint..."   3 minutes ago       Up 3 minutes        0.0.0.0:5432->5432/tcp   postgres_db

Testez nginx en accédant à l'adresse IP publique de votre Linode, port 8080 dans un navigateur (par exemple 192.0.2.0:8080 ). Vous devriez voir la page de destination nginx par défaut affichée.

Stockage de données persistantes

Stocker des données PostgreSQL directement dans un conteneur n'est pas recommandé. Les conteneurs Docker sont destinés à être traités comme éphémères :les conteneurs de votre application sont créés à partir de zéro lors de l'exécution de docker-compose up et détruit lors de l'exécution de docker-compose down . De plus, tout plantage ou redémarrage inattendu de votre système entraînera la perte de toutes les données stockées dans un conteneur.

Pour ces raisons, il est important de configurer un volume persistant sur l'hôte que les conteneurs de base de données utiliseront pour stocker leurs données.

Ajouter un volumes section vers docker-compose.yml et modifiez la database service pour faire référence au volume :

Fichier :menu fixe -compose.yml

version: '3'

services:
  distro:
    image: alpine
    container_name: Alpine_Distro
    restart: always
    entrypoint: tail -f /dev/null

  database:
    image: postgres:latest
    container_name: postgres_db
    volumes:
      - data:/var/lib/postgresql
    ports:
      - "5432:5432"
  web:
    image: nginx:latest
    container_name: nginx
    volumes:
      - ./mysite.template:/etc/nginx/conf.d/mysite.template
    ports:
      - "8080:80"
    environment:
      - NGINX_HOST=example.com
      - NGINX_port=80
    links:
      - database:db
      - distro
volumes:
  data:
    external: true

external: true indique à Docker Compose d'utiliser un volume de données externe préexistant. Si aucun volume n'est nommé data est présent, le démarrage de l'application provoquera une erreur. Créez le volume :
```
docker volume create --name=data
```
Démarrez l'application comme avant :
```
docker-compose up -d
```

Étapes suivantes

Docker Compose est un outil puissant pour orchestrer des ensembles de conteneurs qui peuvent fonctionner ensemble. Des choses comme une application ou un environnement de développement peuvent utiliser Docker-compose. Le résultat est un environnement modulaire et configurable qui peut être déployé n'importe où.