Comment lancer des conteneurs avec Docker Compose

Cet article va présenter Docker Compose et montrer comment l’utiliser pour répondre à vos besoins. Nous allons l’installer, écrire un simple fichier Compose et lancer le conteneur.

Nous verrons ensuite comment lancer plusieurs conteneurs. Ensuite, nous verrons comment construire des images et dernièrement comment utiliser plusieurs fichiers Compose pour lancer des conteneurs dans différents environnements, comme le développement et la production, par exemple.

Dans ce tutoriel, vous allez apprendre :

Comment installer Docker Compose
Comment écrire un fichier Compose simple
Comment exécuter des commandes docker-compose pour démarrer et arrêter des conteneurs
Comment lancer plusieurs conteneurs
Comment créer des images avec Docker Compose
Comment remplacer à l’aide de plusieurs fichiers Docker Compose

PHPMyAdmin.

Configuration logicielle requise et conventions utilisées

Introduction

Nous avons jusqu’à présent vu à quel point Docker est idéal pour gérer des images et démarrer des conteneurs. Mais souvent, les applications nécessitent que différents conteneurs soient opérationnels et communiquent entre eux. Leur connexion via le réseau, leur faire partager des volumes de disque et transmettre des variables d’environnement peut facilement se transformer en une séquence de commandes difficiles à documenter et à gérer au fil du temps. C’est là qu’entre en jeu Docker Compose. Commençons par l’installer, puis écrivons le fichier Compose.

Installation de Docker Compose

Dans Ubuntu 18.04, l’installation de Docker Composer est simple :

apt install docker-compose

Pour tester qu’il est installé, vous pouvez vérifier sa version :

docker-compose -v
docker-compose version 1.17.1, build unknown

Les versions Docker Engine et Docker Compose sont importantes car leurs mises à jour sont fréquentes et des fonctionnalités sont ajoutées et supprimées. La version présentée ci-dessus (1.17.1) a été publiée en novembre 2017. Si vous avez besoin d’une version plus récente, vous pouvez soit activer le référentiel Universe d’Ubuntu et obtenir un paquet plus récent, soit même télécharger et installer la dernière version directement depuis le site Web de Docker Compose :

curl -L "https://github.com/docker/compose/releases/download/1.23.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Le fichier Docker Compose

Docker Compose lit un fichier YAML, qui est généralement nommé docker-compose.yml.

version: "3"

services:
  apache:
    image: php:7.3-apache
    container_name: 'apache'
    ports:
      - "80:80"
    volumes: 
      - ./www:/var/www/html

Au début, la version de la syntaxe est renseignée comme 3. Ensuite, dans la section services, un seul conteneur est spécifié (apache) et les balises image, container_name, ports et volumes sont utilisées pour décrire la façon dont il doit être exécuté.

Créez maintenant un répertoire nommé www et déposez ce fichier index.html à l’intérieur.

<html>
        <body>
                Hello       
        </body> 
</html>

Ensuite, pour tester le fonctionnement de PHP, il suffit de déposer ce fichier dans www.

<?php
        phpinfo();
?>

Commandes Docker Compose

La commande up s’occupera de tout : télécharger les images depuis Docker Hub si elles n’existent pas encore dans le cache local, construire des images personnalisées (ce qui n’est pas le cas, nous y reviendrons dans la section suivante) et démarrer les conteneurs.

docker-compose up -d

Le commutateur -d indique à Docker Compose d’exécuter les conteneurs en arrière-plan. Dans le cas où un autre nom de fichier est utilisé, au lieu de docker-compose.yml, il peut être informé avec -f.

Notez que la commande launch est beaucoup plus simple que son homologue docker run. Il présente deux autres avantages : il ne change pas quel que soit le contenu du fichier Compose, et si le fichier Compose spécifie plus d’un conteneur, tous seront démarrés. À titre de comparaison, la commande docker run serait :

docker run -d --name='apache-alone' -p 80:80 -v $PWD/www:/var/www/html php:7.3-apache

Étant donné que la syntaxe du fichier Compose est YAML, l’indentation est importante. Si vous obtenez des erreurs de syntaxe, vérifiez la syntaxe YAML avec un analyseur en ligne, comme celui-ci.

Vous pouvez vérifier que le conteneur est en cours d’exécution.

docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                NAMES
3937d997e029        php:7.3-apache      "docker-php-entrypoi…"   8 minutes ago       Up 8 minutes        0.0.0.0:80->80/tcp   apache

Accédez maintenant à http://localhost dans votre navigateur préféré, puis http://localhost/phpinfo.php.

Lancement de plusieurs conteneurs

Voyons maintenant un fichier Compose plus complexe. Imaginons que nous allons mettre en place un environnement local pour développer une application LAMP. Nous avons besoin d’un conteneur avec Apache et PHP, d’un autre conteneur avec MySQL, et éventuellement d’un conteneur PHPMyAdmin pour interagir avec MySQL. Les docker-compose.yml seront :

version: "3"

services:
  apache:
    image: php:7.3-apache
    container_name: 'apache'
    restart: 'always'
    ports:
      - "80:80"
      - "443:443"
    volumes: 
      - ./www:/var/www/html
      - ./php/php.ini:/usr/local/etc/php/php.ini
      - ./sites-enabled:/etc/apache2/sites-enabled
      - apache-logs:/var/log/apache2
  mysql:
    image: mariadb:10.4
    container_name: 'mysql'
    restart: 'always'
    volumes: 
      - mysql-data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: somepassword
      MYSQL_DATABASE: db_site
      MYSQL_USER: user
      MYSQL_PASSWORD: password
  phpmyadmin:
    image: phpmyadmin/phpmyadmin:4.8
    container_name: 'phpmyadmin'
    environment:
      PMA_HOST: mysql
      PMA_PORT: 3306
    ports:
      - '8080:80'      
volumes:
  apache-logs:
  mysql-data:

Ce fichier Compose lance trois conteneurs, chacun ayant une section sous services. Notez que nous définissons certaines variables d’environnement sous environnement. La définition restart : always indique à Docker de démarrer automatiquement les conteneurs au démarrage du service Docker (en cas de redémarrage, par exemple).

La commande pour démarrer les trois conteneurs est la même que dans l’exemple simple précédent. Facile à retenir, n’est-ce pas ?

docker-compose up -d

Vérifiez que les conteneurs sont créés.

docker ps
CONTAINER ID        IMAGE                       COMMAND                  CREATED             STATUS              PORTS                                      NAMES
f76ece3508fe        phpmyadmin/phpmyadmin:4.8   "/run.sh supervisord…"   20 seconds ago      Up 4 seconds        9000/tcp, 0.0.0.0:8080->80/tcp             phpmyadmin
69b1b5054f3d        mariadb:10.4                "docker-entrypoint.s…"   20 seconds ago      Up 6 seconds        3306/tcp                                   mysql
6747d7580dac        php:7.3-apache              "docker-php-entrypoi…"   2 days ago          Up 14 seconds       0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp   apache

Il est intéressant de noter que les conteneurs peuvent communiquer via leurs noms et accéder aux ports de l’autre sans avoir besoin d’exposer leurs ports à l’hôte. Par exemple, nous n’avons pas exposé le port 3306 du service MySQL (comme on peut le voir dans la sortie ci-dessus), mais PHPMyAdmin est capable d’accéder à ce port. Pour accéder à PHPMyAdmin, rendez-vous sur http://localhost:8080 et connectez-vous avec l’utilisateur et le mot de passe définis dans le service MySQL (utilisateur/mot de passe).

Création d’images avec Docker Compose

Si vous avez besoin de créer une image, au lieu d’utiliser une image existante, il vous suffit d’ajouter une balise de construction. Dans l’exemple ci-dessous, nous disons à Docker Compose de rechercher un Dockerfile dans le répertoire actuel. La balise image sera utilisée pour nommer la nouvelle image.

version: "3"

services:
  apache:
    build: .
    image: my-image-name
    container_name: 'apache'
    restart: 'always'
    ports:
      - "80:80"

Remplacement à l’aide de plusieurs fichiers Docker Compose

Docker Compose facilite la personnalisation du lancement de conteneurs pour différents environnements. Il vous suffit de créer les fichiers de remplacement appelés et de lancer les conteneurs qui les spécifient. Elles remplaceront les définitions précédentes faites dans le fichier Compose de base.

Par exemple, nous allons créer un fichier de remplacement nommé docker-compose-prod.yml et définir un mot de passe différent pour MySQL.

version: "3"

services:

  mysql:
    environment:
      MYSQL_ROOT_PASSWORD: somepassword_other
      MYSQL_DATABASE: db_site_other
      MYSQL_USER: user_other
      MYSQL_PASSWORD: password_other

Vous pouvez utiliser un autre hôte pour démarrer les conteneurs. Si vous utilisez le même hôte, il est nécessaire de supprimer le conteneur mysql et son volume associé. Sinon, le conteneur existant avec les anciennes informations d’identification sera utilisé.

docker stop mysql
docker rm mysql
docker volume ls
docker volume rm directory_mysql-data

Ensuite, vous pouvez exécuter la commande ci-dessous. Il est important de garder l’ordre des fichiers. Plusieurs fichiers peuvent être utilisés. Dans notre exemple, seule la section d’environnement du service mysql sera remplacée.

docker-compose -f docker-compose.yml -f docker-compose-prod.yml up -d

Après avoir vérifié que les conteneurs sont en cours d’exécution, essayez d’accéder à PHPMyAdmin en utilisant les nouvelles informations d’identification.

Conclusion

Cet article a présenté Docker Compose, un outil pratique permettant d’orchestrer le lancement de plusieurs conteneurs dans le même hôte. Les possibilités sont nombreuses et la lecture du manuel Docker Compose est fortement recommandée. Dans les prochains articles, nous allons explorer les moyens d’orchestrer les conteneurs Docker entre plusieurs hôtes.

Plus d’informations dans cette série d’articles Docker

Une introduction pratique aux conteneurs Docker
Comment interagir avec les conteneurs Docker
Comment personnaliser les images Docker avec Dockerfiles