Compose : Docker, l’appli pour or­ches­trer les con­te­neurs

Compose facilite la mise à l’échelle et le dé­ploie­ment d’ap­pli­ca­tions dans Docker en au­to­ma­ti­sant la gestion de con­te­neurs. Dans ce tutoriel, nous allons voir en détail comment mettre en place et utiliser Docker Compose dans votre propre en­vi­ron­ne­ment de pro­duc­tion.

Docker Compose, c’est quoi ?

Docker Compose sert à gérer les ap­pli­ca­tions et augmente l’ef­fi­ca­cité du dé­ve­lop­pe­ment de con­te­neurs. Les con­fi­gu­ra­tions sont définies dans un seul fichier YAML afin de faciliter la création et la mise à l’échelle des ap­pli­ca­tions. Si on recourt souvent à Docker Compose pour mettre en place un en­vi­ron­ne­ment local, il peut également faire partie d’un flux de travail d’in­té­gra­tion continue / de livraison continue (CI/CD). Les personnes en charge du dé­ve­lop­pe­ment peuvent définir une version spé­ci­fique de con­te­neurs pour les tests ou pour une phase par­ti­cu­lière du pipeline. De quoi faciliter l’iden­ti­fi­ca­tion des problèmes et la cor­rec­tion des bugs avant le passage en pro­duc­tion pro­pre­ment dite.

Docker Compose : les prérequis

Pour l’or­ches­tra­tion de con­te­neurs, vous avez besoin à la fois du Docker Engine et de Docker Compose. Vous devez donc avoir l’une des deux con­fi­gu­ra­tions suivantes :

• soit Docker Engine et Docker Compose installés en tant que binaires autonomes ;
• soit Docker Desktop en en­vi­ron­ne­ment de dé­ve­lop­pe­ment avec interface uti­li­sa­teur graphique, qui inclut déjà le Docker Engine et Compose.

Utiliser Docker Compose étape par étape

Nous allons à présent expliquer les concepts de Docker Compose avec une simple ap­pli­ca­tion Web Python dont les appels seront comp­ta­bi­li­sés. Nous allons pour cela utiliser le framework Python Flask et la base de données en mémoire Redis. Il n’est pas né­ces­saire d’installer Python ou Redis, car ils sont fournis sous forme d’images Docker.

Étape 1 : créer les fichiers du projet

Ouvrez le terminal et créez un nouveau dossier pour le projet.

$ mkdir composedemo

Passez ensuite dans le ré­per­toire.

$ cd composedemo

Dans ce dossier, créez le fichier app.py et ajoutez-y le code suivant :

import time
import redis
from flask import Flask
app = Flask(__name__)
cache = redis.Redis(host=‘redis’, port=6379)
def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr(‘hits’)
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)
@app.route(‘/’)
def hello():
    count = get_hit_count()
    return ‘Hello World! I was here {} times.\n’.format(count)

Nous uti­li­se­rons le nom d’hôte « Redis » et le port standard « 6379 ». De plus, nous indiquons que la fonction get_hit_count() devra faire plusieurs ten­ta­tives de connexion au service. Nous proposons ce processus car il se peut que Redis ne soit pas encore dis­po­nible au démarrage de l’ap­pli­ca­tion ou qu’il y ait des problèmes de connexion en cours d’exécution.

Créez enfin le fichier re­qui­re­ments.txt avec les dé­pen­dances :

flask
redis

Étape 2 : con­fi­gu­rer le do­cker­file

Le do­cker­file est utilisé pour l’image Docker. Il indique toutes les dé­pen­dances dont l’ap­pli­ca­tion Python a besoin.

# syntax=docker/dockerfile:1
FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP=app.py
ENV FLASK_RUN_HOST=0.0.0.0
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
EXPOSE 5000
COPY . .
CMD ["flask", "run"]

Docker reçoit ainsi l’ins­truc­tion d’utiliser l’image Python 3.7. De plus, nous avons défini les variables d’en­vi­ron­ne­ment pour la commande Flask. Avec apk add, nous ins­tal­lons gcc et d’autres dé­pen­dances. EXPOSE indique que le conteneur doit sur­veil­ler le port 5000. Avec COPY, le contenu du dossier actuel est copié dans le ré­per­toire de travail /code. Comme commande standard pour le conteneur, nous choi­sis­sons flask run.

Vérifiez que le do­cker­file a bien été en­re­gis­tré sans extension de fichier, car certains éditeurs ajoutent au­to­ma­ti­que­ment le suffixe .txt.

Étape 3 : créer le fichier YAML

Dans docker-compose.yml, nous con­fi­gu­rons les services « redis » et « web ».

version: "3.9"
services:
    web:
        build: .
        ports:
            - "8000:5000"
    redis:
        image: "redis:alpine"

Le service Web utilise l’image créée par le do­cker­file. Il associe le conteneur et l’or­di­na­teur hôte au port 8000, tandis que le serveur Web Flask fonc­tionne sur le port 5000. En revanche, l’image Redis est sim­ple­ment obtenue à partir du hub officiel de Docker.

Étape 4 : exécuter l’ap­pli­ca­tion avec Compose

Démarrez l’ap­pli­ca­tion à partir de votre dossier projet.

docker compose up

Appelez http://localhost:8000 dans votre na­vi­ga­teur. Vous pouvez aussi saisir http://127.0.0.1:8000.

Vous devriez voir s’afficher le message suivant :

Close

Ac­tua­li­sez la page. Le nombre de vues devrait main­te­nant avoir augmenté de 1.

Close

Vous pouvez arrêter l’ap­pli­ca­tion avec :

$ docker compose down

Vous pouvez aussi appuyer sur Ctrl + C dans le terminal dans lequel vous avez lancé l’ap­pli­ca­tion.

Étape 5 : ajouter un Bind Mount

Si vous souhaitez ajouter un Bind Mount (ou mappage de ré­per­toire) pour le service Web, vous pouvez le faire dans docker-compose.yml.

version: "3.9"
services:
    web:
        build: .
        ports:
            - "8000:5000"
        volumes:
            - .:/code
        environment:
            FLASK_DEBUG: "true"
    redis:
        image: "redis:alpine"

Sous Volumes, nous indiquons que le dossier projet actuel doit être rattaché au ré­per­toire /code à l’intérieur du conteneur. Cela permet de modifier le code sans devoir recréer l’image. La variable d’en­vi­ron­ne­ment FLASK_DEBUG ordonne à flask run de s’exécuter en mode dé­ve­lop­pe­ment.

Étape 6 : recréer et exécuter l’ap­pli­ca­tion

Saisissez la commande suivante dans le terminal pour réi­ni­tia­li­ser le fichier Compose :

docker compose up

Étape 7 : mettre à jour l’ap­pli­ca­tion

Comme vous utilisez main­te­nant un mappage de ré­per­toire pour votre ap­pli­ca­tion, vous pouvez modifier votre code et voir au­to­ma­ti­que­ment les chan­ge­ments sans avoir à recréer l’image.

Écrivez un nouveau texte d’accueil dans app.py.

return ‘Hello from Docker! I was here {} times.\n’.format(count)

Ac­tua­li­sez votre na­vi­ga­teur pour voir si les mo­di­fi­ca­tions ont bien été prises en compte.

Close

Étape 8 : commandes sup­plé­men­taires

L’option --help affiche une liste de commandes dis­po­nibles pour Docker Compose :

docker compose --help

Pour laisser Docker Compose s’exécuter en arrière-plan, ajoutez l’argument -d :

docker compose up -d

Avec down, tous les con­te­neurs sont supprimés. L’option --volumes supprime aussi les volumes utilisés par le conteneur Redis.

docker compose down --volumes