Docker : or­ches­tra­tion d’ap­pli­ca­tions multi-con­te­neurs avec Swarm et Compose

Avec le logiciel de gestion de con­te­neurs Docker, vous pouvez répartir ra­pi­de­ment, ef­fi­ca­ce­ment et de manière con­for­table les ap­pli­ca­tions dans le réseau en tant que tâches. Tout ce dont vous avez besoin est le ges­tion­naire de cluster Swarm, qui est depuis la version 1.12.0 de Docker, la partie native sous le nom «Swarm Mode » du moteur Docker et donc le logiciel de base de la pla­te­forme de con­te­neurs. Docker Swarm vous permet de mettre à l’échelle les ap­pli­ca­tions de con­te­neurs en les exécutant dans n’importe quel nombre d’instances sur n’importe quel nombre de nœuds de votre réseau. Si vous voulez exécuter une ap­pli­ca­tion multi-con­te­neurs dans un cluster, nommée « Stack » (pile) sur Docker, il faut recourir à l’outil Docker Compose. Nous ex­pli­quons les concepts de base de l’or­ches­tra­tion Docker avec Swarm et Compose et il­lus­trons la mise en œuvre à l’aide d’exemples de code.

Swarm (essaim en français) est un logiciel développé par les dé­ve­lop­peurs de Docker qui consolide n’importe quel nombre d’hôtes Docker dans un cluster et permet la gestion centrale de celui-ci ainsi que l’or­ches­tra­tion des con­te­neurs. Jusqu’à la version 1.11 de Docker, Swarm devait être im­plé­menté comme un outil séparé. Les nouvelles versions de la pla­te­forme de conteneur prennent en charge un mode Swarm natif. Le cluster manager, est ainsi à la dis­po­si­tion de chaque uti­li­sa­teur Docker avec l’ins­tal­la­tion du moteur Docker.

Docker Swarm est basé sur une ar­chi­tec­ture maître-esclave. Chaque cluster Docker (l’essaim) se compose d’au moins un nœud de gestion et d’un nombre quel­conque de nœuds de type « Workers ». Alors que le ges­tion­naire (Swarm Manager) est res­pon­sable de la gestion du cluster et de la ré­par­ti­tion des tâches, les « Swarm Workers » prennent en charge l’exécution des unités de travail « Tasks ». Les ap­pli­ca­tions de con­te­neurs sont dis­tri­buées en un certain nombre de nœuds Docker en tant que « Services ».

Dans la ter­mi­no­lo­gie de Docker, le terme « service » se réfère à une structure abstraite avec laquelle vous dé­fi­nis­sez les tâches qui doivent être exécutées dans un cluster. Chaque service consiste en un ensemble de tâches in­di­vi­duelles, dont chacune est traitée dans son propre conteneur sur l’un des nœuds du cluster. Lorsque vous créez un service, vous dé­ter­mi­nez sur quelle image de conteneur il est basé et quelles commandes s’exécutent dans le conteneur qui est exécuté sur la base de l’image. Docker Swarm supporte deux modes dans les­quelles les services Swarm sont définis : choi­sis­sez entre le service répliqué et le service global.

• Services répliqués : un service répliqué est une tâche qui s’exécute dans un nombre de répliques défini par l’uti­li­sa­teur. Chaque réplique est une instance du conteneur Docker défini dans le service. Les services répliqués peuvent être mis à l’échelle en créant des répliques sup­plé­men­taires. Par exemple, un serveur Web comme NGINX peut être mis à l’échelle à 2,4 ou 100 instances avec une seule ligne de commande.
• Services globaux : lorsqu’un service s’exécute en mode global, chaque nœud dis­po­nible dans le cluster démarre une tâche pour le service cor­res­pon­dant. Lorsqu’un nouveau nœud est ajouté au cluster, le ges­tion­naire Swarm lui assigne im­mé­dia­te­ment une tâche pour le service global. Les services globaux sont adaptés, par exemple, à la sur­veil­lance d’ap­pli­ca­tions ou de pro­grammes anti-virus.

Un domaine d’ap­pli­ca­tion central de Docker Swarm est la ré­par­ti­tion de la charge. En mode Swarm, Docker dispose de fonctions de ré­par­ti­tion de charge (load balancing) intégrées. Par exemple, si vous exécutez un serveur Web NGINX avec 4 instances, Docker distribue in­tel­li­gem­ment les requêtes entrantes aux instances du serveur Web dis­po­nibles.

Docker Compose vous permet de définir des ap­pli­ca­tions multi-con­te­neurs, appelées piles (Stacks), et de les exécuter soit sur un seul nœud Docker, soit dans un cluster. L’outil fournit des pro­grammes en ligne de commande que vous pouvez utiliser pour gérer le cycle de vie complet de vos ap­pli­ca­tions.

Docker définit les piles comme des groupes de services in­ter­con­nec­tés qui partagent des dé­pen­dances lo­gi­cielles et qui sont or­ches­trées et mises à l’échelle ensemble. Une pile de dockers vous permet de stocker les dif­fé­rentes fonc­tion­na­li­tés d’une ap­pli­ca­tion dans un fichier central : le docker-compose.yml. Démarrez-le à partir de là, exécutez-le dans un en­vi­ron­ne­ment d’exécution isolé et gérez-le de manière cen­tra­li­sée.

Selon le système d’ex­ploi­ta­tion sur lequel vous utilisez Docker, Compose doit parfois être installé sé­pa­ré­ment.

Si vous utilisez Docker pour Mac ou Docker pour Windows dans le cadre des ins­tal­la­tions de bureau, Docker Compose est déjà inclus. Il en va de même pour la Docker Toolbox, qui est dis­po­nible pour les anciens systèmes Mac ou Windows. Si vous utilisez Docker sous Linux ou Windows Server 2016, une ins­tal­la­tion manuelle de l’outil est alors né­ces­saire.

Ouvrez le Terminal et exécutez la commande suivante pour té­lé­char­ger les fichiers binaires de Compose à partir du dépôt GitHub :

Accordez à tous les uti­li­sa­teurs le droit d‘exécuter les fichiers binaires.

Pour tester si l’outil a été installé cor­rec­te­ment, vous pouvez utiliser la commande suivante :

Si l’ins­tal­la­tion a réussi, vous recevrez le numéro de version de l’outil comme sortie de terminal.

Démarrez le Po­wer­Shell en tant qu’ad­mi­nis­tra­teur et exécutez la commande suivante pour démarrer le té­lé­char­ge­ment des fichiers binaires Compose à partir du dépôt (re­po­si­tory) GitHub :

Lancez le fichier d’exécution pour installer Docker Compose.

Pour exécuter des ap­pli­ca­tions multi-con­te­neurs avec Docker dans un cluster, vous avez besoin d’un essaim, un cluster de moteur Docker en mode Swarm, comme l’outil Docker Compose.

Dans la première partie de notre tutoriel, vous ap­pren­drez comment accéder à votre propre essaim en quelques étapes avec Docker. La deuxième partie traite de la création d’ap­pli­ca­tions multi-con­te­neurs avec Docker Compose et du dé­ploie­ment dans le cluster.

Un essaim est un nombre quel­conque de moteurs Docker en mode Swarm. Chaque moteur Docker fonc­tionne sur un nœud séparé et l’intègre dans le cluster.

La création d’un cluster Docker comprend trois étapes :

1. Im­plé­men­ter les hôtes Docker
2. Ini­tia­li­ser Swarm
3. Intégrer les hôtes Docker dans l‘essaim

L’outil d’ap­pro­vi­sion­ne­ment Docker Machine est re­com­mandé pour le dé­ploie­ment des nœuds Docker. Cela simplifie l’im­plé­men­ta­tion des hôtes Docker (aussi les « Do­cke­ri­zed hosts », les hôtes virtuels, y compris le moteur Docker). Avec Docker Machine vous im­plé­men­tez des comptes pour votre essaim sur n’importe quelle in­fras­truc­ture et pouvez les gérer à distance.

Les plugins de pilote pour Docker Machine, sont fournis par dif­fé­rentes pla­te­formes de Cloud. Ceci réduit l’effort de pro­vi­sion­ne­ment des hôtes Docker chez les four­nis­seurs tels qu’Amazon Web Services (AWS) ou Digital Ocean via une seule ligne de code.

Utilisez le code suivant pour créer un hôte Docker (ici : docker-sandbox) dans l’in­fras­truc­ture Digital Ocean.

AWS permet de créer un Docker-Host (ici : aws-sandbox) avec la commande suivante :

Après avoir im­plé­menté le nombre souhaité d’hôtes virtuels pour votre essaim, vous pouvez les gérer via Docker Machine et les regrouper avec Docker Swarm. Accédez d’abord au nœud que vous souhaitez utiliser comme Swarm Manager. Docker Machine fournit la commande suivante pour établir une connexion cryptée SSH avec l’hôte Docker.

Si la connexion au nœud désiré est établie, utilisez la commande suivante pour ini­tia­li­ser un essaim.

La commande docker swarm init, au choix avec des options, vous pouvez voir la do­cu­men­tion. La commande définit le nœud ac­tuel­le­ment sé­lec­tionné comme un ges­tion­naire d’essaim et crée deux tokens aléa­toires : un token Manager et un token Worker.

De plus, la commande docker swarm init génère une sortie de terminal qui comporte toutes les in­for­ma­tions dont vous avez besoin pour ajouter plus de comptes à votre Swarm.

Après avoir ini­tia­lisé votre essaim avec le nœud sé­lec­tionné en tant que ges­tion­naire d’essaim, ajoutez un nombre quel­conque de nœuds en tant que Manager ou Worker. Utilisez la commande docker swarm join en com­bi­nai­son avec le Token cor­res­pon­dant.

3.1 ajouter un nœud Worker : si vous souhaitez ajouter un nœud Worker (nœud de travail) à votre essaim, accédez au nœud cor­res­pon­dant via docker-machine et exécutez la commande suivante :

La partie obli­ga­toire de la commande docker swarm join est le drapeau --token, qui contient le token d’accès au cluster.

Dans l’exemple actuel, la commande contient le Token Worker généré pré­cé­dem­ment ainsi que l’adresse IP sous laquelle le Swarm Manager est dis­po­nible.

Si vous n’avez pas le Token cor­res­pon­dants à portée de main, dé­ter­mi­nez le docker swarm join-token worker.

3.2 Ajouter un nœud maître : si vous voulez ajouter un autre nœud Manager à votre essaim, il faut tout d’abord dé­ter­mi­ner le token Manager. Exécutez la commande docker swarm join-token manager sur le compte Manager où vous avez ini­tia­lisé l’essaim et suivez les ins­truc­tions sur le terminal.

Docker génère un token Manager, qui peut être exécuté sur n’importe quel hôte Docker en com­bi­nai­son avec la commande docker swarm join et l’adresse IP que vous avez définie afin de l’inclure en tant que Manager de l’essaim.

3.3 Aperçu de tous les nœuds de l’essaim : vous pouvez obtenir une vue d’ensemble de tous les nœuds inclus dans votre essaim en exécutant la commande de ma­na­ge­ment docker node ls sur l’un de vos nœuds Manager.

Les nœuds Manager sont marqués comme -Leader dans la vue d’ensemble.

Dans la première partie de notre tutoriel Docker, vous avez im­plé­menté les hôtes Docker avec Docker Machine et les avez regroupés en mode Swarm sous forme de cluster. Nous allons main­te­nant vous montrer comment utiliser Docker Compose pour définir divers services en tant qu’ap­pli­ca­tions multi-con­te­neurs compactes et les exécuter dans un cluster.

La pré­pa­ra­tion d’ap­pli­ca­tions multi-con­te­neurs dans un cluster comporte cinq étapes :

1. Créer un registre local Docker
2. Définir l’ap­pli­ca­tion multi-con­te­neurs comme pile
3. Tester l’ap­pli­ca­tion multi-con­te­neurs avec Compose
4. Charger l’image dans le registre.
5. Exécuter la pile dans le cluster

Puisqu’un essaim Docker se compose d’un nombre quel­conque de moteurs Docker, les ap­pli­ca­tions ne peuvent fonc­tion­ner en cluster que si tous les moteurs Docker concernés ont accès à l’image de l’ap­pli­ca­tion. Vous avez donc besoin d’un service central qui vous permet de gérer les images et de les rendre dis­po­nibles dans le cluster. Un tel service se nomme registre (registry).

1.1 ​​​​​​​Démarrer le registre en tant que Service dans le cluster : utilisez la commande docker service create selon le schéma suivant pour démarrer un serveur de registre local en tant que service dans le cluster.

1.2 ​​​​​​​Vérifier le statut du service registre : utilisez la commande docker service ls, pour vérifier l’état du service registre qui vient de démarrer.

1.3 Vé­ri­fi­ca­tion de la connexion au registre avec cURL : assurez-vous que vous pouvez accéder à votre registre via cURL. Pour ce faire, saisir la commande suivante :

Si votre registre fonc­tionne comme prévu, cURL devrait renvoyer la sortie suivante :

Dans l’étape suivante, créez tous les fichiers né­ces­saires au dé­ploie­ment d’une pile dans le cluster Docker et stockez-les dans un ré­per­toire de projet partagé.

2.1 Créer un dossier de projet : créez un ré­per­toire de projet avec n’importe quel nom, par exemple stackdemo.

Votre ré­per­toire de projet agit comme un dossier collectif pour tous les fichiers dont vous avez besoin pour exécuter votre ap­pli­ca­tion multi-conteneur. Ceux-ci incluent un fichier avec le code source de l’ap­pli­ca­tion, un fichier texte dans lequel vous dé­fi­nis­sez le logiciel dont vous avez besoin pour exécuter votre ap­pli­ca­tion, ainsi qu’un Do­cker­file et un Compose-File.

2.2 Créer une ap­pli­ca­tion : créez une ap­pli­ca­tion Python avec le contenu suivant et placez-la dans le ré­per­toire du projet sous le nom app.py.

L’exemple d’ap­pli­ca­tion app.py est une simple ap­pli­ca­tion Web dont la page de démarrage affiche le message de bienvenue « Hello World! ». La base est le framework Web open source Flask ainsi que le système de gestion de base de données open source Redis.

2.3 Définir les con­di­tions préa­lables : créez un fichier texte re­qui­re­ments.txt avec le contenu suivant et en­re­gis­trez-le dans le ré­per­toire du projet.

Dans le fichier re­qui­re­ments.txt, vous dé­fi­nis­sez sur quel logiciel votre ap­pli­ca­tion est basée.

2.4 Créer un fichier Docker : créez un fichier texte nommé Do­cker­file, ajoutez le contenu suivant et placez-le dans le dossier du projet.

Le docker-compose.yml permet de relier les dif­fé­rents services entre eux, de les exécuter ensemble en tant qu’unité et de les gérer de manière cen­tra­li­sée.

Dans l’exemple actuel, nous dé­fi­nis­sons deux services : un service Web et un service Redis.

• Service Web : le service Web est basé sur une image créée dans le ré­per­toire stackdemo en fonction du fichier Docker que vous avez créé.
• Service Redis : nous n’utilisons pas notre propre image pour le service Redis. Mais plutôt une image Redis ac­ces­sible au public (redis:alpine), qui est dis­po­nible via le Docker-Hub.

Testez l’ap­pli­ca­tion multi-con­te­neurs lo­ca­le­ment en l’exécutant sur le nœud de votre manager.

3.1 Lancer l’ap­pli­ca­tion : utilisez la commande docker-compose up en com­bi­nai­son avec le drapeau -d, pour démarrer votre pile. Le drapeau active le « Detached mode », où tous les con­te­neurs sont exécutés en arrière-plan. Votre terminal est main­te­nant prêt à recevoir d’autres commandes.

3.3 Tester votre pile avec cURL : testez votre pile en exécutant le programme en ligne de commande cURL avec l’adresse de l’hôte local ( localhost ou 127.0.0.1).

3.4 Dé­sac­ti­ver l’ap­pli­ca­tion : si vous voulez dé­sac­ti­ver la pile, exécutez la commande docker-compose down avec le drapeau --volumes.

Avant de pouvoir exécuter votre ap­pli­ca­tion multi-con­te­neurs en tant qu’ap­pli­ca­tion dis­tri­buée dans un cluster, vous devez préparer toutes les images né­ces­saires via le service de registre. Dans l’exemple actuel, ceci n’inclut que l’image créée par le service Web (l’image Redis est dis­po­nible via un registre public dans le Docker-Hub).

Docker appelle le té­lé­char­ge­ment d’une image créée lo­ca­le­ment dans un registre central « push ». Docker Compose apporte pour cela la commande docker-compose push. Exécutez-la dans le ré­per­toire de votre projet.

Toutes les images men­tion­nées  docker-compose.yml qui ont été créés lo­ca­le­ment sont chargés dans le registre.

Si l’image de votre pile est dis­po­nible via le service de registre local, l’ap­pli­ca­tion multi-App peut être exécutée dans le cluster.

5.1 Exécuter la pile dans le cluster : vous pouvez aussi exécuter des piles dans un cluster à l’aide d’une simple ligne de commande. Pour ce faire, la pla­te­forme de con­te­neurs dispose de la commande suivante :

Lancez la commande docker stack deploy sur l’un des nœuds de gestion de votre essaim.

5.2 Appeler l’état de la pile : utilisez la commande suivante pour obtenir l‘état de votre pile :

Docker donne les ID, noms, modes, répliques, images et ports de tous les services fonc­tion­nant sur votre pile.

5.3 Tester l’ap­pli­ca­tion avec cURL : pour tester votre ap­pli­ca­tion multi-con­te­neurs, appelez-la via l’adresse de l‘hôte local sur le port 8000.

5.4 Dé­sac­ti­ver la pile : si vous voulez dé­sac­ti­ver votre pile, utilisez la commande docker stack rm en com­bi­nai­son avec le nom de la pile.

5.5 Dé­sac­ti­ver le service du registre : si vous voulez dé­sac­ti­ver le service de registre, utilisez la commande docker service rm avec le nom du service, ici: registry.