Docker : orchestration d’applications multi-conteneurs avec Swarm et Compose

Avec le logiciel de gestion de conteneurs Docker, vous pouvez répartir rapidement, efficacement et de manière confortable les applications dans le réseau en tant que tâches. Tout ce dont vous avez besoin est le gestionnaire 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 plateforme de conteneurs. Docker Swarm vous permet de mettre à l’échelle les applications de conteneurs 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 application multi-conteneurs dans un cluster, nommée « Stack » (pile) sur Docker, il faut recourir à l’outil Docker Compose. Nous expliquons les concepts de base de l’orchestration Docker avec Swarm et Compose et illustrons la mise en œuvre à l’aide d’exemples de code.

Docker Swarm

Swarm (essaim en français) est un logiciel développé par les développeurs 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’orchestration des conteneurs. Jusqu’à la version 1.11 de Docker, Swarm devait être implémenté comme un outil séparé. Les nouvelles versions de la plateforme de conteneur prennent en charge un mode Swarm natif. Le cluster manager, est ainsi à la disposition de chaque utilisateur Docker avec l’installation du moteur Docker.

Docker Swarm est basé sur une architecture maître-esclave. Chaque cluster Docker (l’essaim) se compose d’au moins un nœud de gestion et d’un nombre quelconque de nœuds de type « Workers ». Alors que le gestionnaire (Swarm Manager) est responsable de la gestion du cluster et de la répartition des tâches, les « Swarm Workers » prennent en charge l’exécution des unités de travail « Tasks ». Les applications de conteneurs sont distribuées en un certain nombre de nœuds Docker en tant que « Services ».

Dans la terminologie de Docker, le terme « service » se réfère à une structure abstraite avec laquelle vous définissez les tâches qui doivent être exécutées dans un cluster. Chaque service consiste en un ensemble de tâches individuelles, 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éterminez 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 lesquelles les services Swarm sont définis : choisissez 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’utilisateur. 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 supplémentaires. 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 disponible dans le cluster démarre une tâche pour le service correspondant. Lorsqu’un nouveau nœud est ajouté au cluster, le gestionnaire Swarm lui assigne immédiatement une tâche pour le service global. Les services globaux sont adaptés, par exemple, à la surveillance d’applications ou de programmes anti-virus.

Un domaine d’application central de Docker Swarm est la répartition de la charge. En mode Swarm, Docker dispose de fonctions de répartition de charge (load balancing) intégrées. Par exemple, si vous exécutez un serveur Web NGINX avec 4 instances, Docker distribue intelligemment les requêtes entrantes aux instances du serveur Web disponibles.

Docker Compose

Docker Compose vous permet de définir des applications multi-conteneurs, appelées piles (Stacks), et de les exécuter soit sur un seul nœud Docker, soit dans un cluster. L’outil fournit des programmes en ligne de commande que vous pouvez utiliser pour gérer le cycle de vie complet de vos applications.

Docker définit les piles comme des groupes de services interconnectés qui partagent des dépendances logicielles et qui sont orchestrées et mises à l’échelle ensemble. Une pile de dockers vous permet de stocker les différentes fonctionnalités d’une application dans un fichier central : le docker-compose.yml. Démarrez-le à partir de là, exécutez-le dans un environnement d’exécution isolé et gérez-le de manière centralisée.

Selon le système d’exploitation sur lequel vous utilisez Docker, Compose doit parfois être installé séparément.

Si vous utilisez Docker pour Mac ou Docker pour Windows dans le cadre des installations de bureau, Docker Compose est déjà inclus. Il en va de même pour la Docker Toolbox, qui est disponible pour les anciens systèmes Mac ou Windows. Si vous utilisez Docker sous Linux ou Windows Server 2016, une installation manuelle de l’outil est alors nécessaire.

Installation de Compose sous Linux

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

sudo curl -L https://github.com/docker/compose/releases/download/1.18  .0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

Accordez à tous les utilisateurs le droit d‘exécuter les fichiers binaires.

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

Pour tester si l’outil a été installé correctement, vous pouvez utiliser la commande suivante :

docker-compose -version

Si l’installation a réussi, vous recevrez le numéro de version de l’outil comme sortie de terminal.

Installation de Compose sous Windows Server 2016 (seulement Docker EE pour Windows)

Démarrez le PowerShell en tant qu’administrateur et exécutez la commande suivante pour démarrer le téléchargement des fichiers binaires Compose à partir du dépôt (repository) GitHub :

Invoke-WebRequest 
"https://github.com/docker/compose/releases/download/1.18.0/docker-compose-
Windows-x86_64.exe" -UseBasicParsing -OutFile
$Env:ProgramFiles\docker\docker-compose.exe

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

Note

pour plus d’informations sur les outils de Docker comme Swarm et Compose, voir notre article sur l‘écosystème de Docker.

Tutoriel : utilisation de Docker Swarm et Compose

Pour exécuter des applications multi-conteneurs 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 apprendrez comment accéder à votre propre essaim en quelques étapes avec Docker. La deuxième partie traite de la création d’applications multi-conteneurs avec Docker Compose et du déploiement dans le cluster.

Conseil

une introduction à Docker et des instructions étape par étape pour l’installation du moteur Docker sous Linux se trouvent dans notre article de base sur la plateforme de conteneurs.

Partie 1 : Docker en mode Swarm

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

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

  1. Implémenter les hôtes Docker
  2. Initialiser Swarm
  3. Intégrer les hôtes Docker dans l‘essaim
Note

alternativement, un seul moteur Docker peut être réglé en mode Swarm dans un environnement de développement local. C’est ce que l’on nomme un Single Node Swarm.

Étape 1 : implémenter les hôtes Docker

L’outil d’approvisionnement Docker Machine est recommandé pour le déploiement des nœuds Docker. Cela simplifie l’implémentation des hôtes Docker (aussi les « Dockerized hosts », les hôtes virtuels, y compris le moteur Docker). Avec Docker Machine vous implémentez des comptes pour votre essaim sur n’importe quelle infrastructure et pouvez les gérer à distance.

Les plugins de pilote pour Docker Machine, sont fournis par différentes plateformes de Cloud. Ceci réduit l’effort de provisionnement des hôtes Docker chez les fournisseurs 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’infrastructure Digital Ocean.

$ docker-machine create --driver digitalocean --digitalocean-access-token xxxxx docker-sandbox

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

$ docker-machine create --driver amazonec2 --amazonec2-access-key AKI******* --amazonec2-secret-key 8T93C******* aws-sandbox
Note

les caractères xxxxx et ****** servent de caractères de remplacement pour les jetons d’accès individuels ou les clefs que vous pouvez générer via votre compte client auprès du fournisseur respectif.

Étape 2 : initialiser Swarm

Après avoir implé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.

docker-machine ssh MACHINE-NAME
Note

remplacez MACHINE-NAME par le nom de l’hôte Docker auquel vous voulez accéder.

Si la connexion au nœud désiré est établie, utilisez la commande suivante pour initialiser un essaim.

docker swarm init [OPTIONS]

La commande docker swarm init, au choix avec des options, vous pouvez voir la documention. La commande définit le nœud actuellement sélectionné comme un gestionnaire d’essaim et crée deux tokens aléatoires : un token Manager et un token Worker.

Swarm initialized: current node (1ia0jlt0ylmnfofyfj2n71w0z) is now a manager.

To add a worker to this swarm, run the following command:

docker swarm join \
--token SWMTKN-1-511cy9taxx5w47n80vopivx6ii6cjpi71vfncqhcfcawxfcb14-6cng4m8lhlrdfuq9jgzznre1p \
10.0.2.15:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

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

Note

habituellement, le docker swarm init est utilisé avec le drapeau (flag) --advertise-addr. Ceci spécifie l’adresse IP à utiliser pour l’accès API et le Overlay-Networking. Si l’adresse IP n’a pas été explicitement définie, Docker vérifie automatiquement sous quelle adresse IP le système sélectionné est accessible et le sélectionne. Si un nœud possède plus d’une adresse IP, le drapeau correspondant doit être activé. Sauf indication contraire, Docker utilise le port 2377.

Étape 3 : intégrer les hôtes Docker dans l’essaim

Après avoir initialisé votre essaim avec le nœud sélectionné en tant que gestionnaire d’essaim, ajoutez un nombre quelconque de nœuds en tant que Manager ou Worker. Utilisez la commande docker swarm join en combinaison avec le Token correspondant.

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 correspondant via docker-machine et exécutez la commande suivante :

docker swarm join [OPTIONS] HOST:PORT

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

docker swarm join \
--token SWMTKN-1-511cy9taxx5w47n80vopivx6ii6cjpi71vfncqhcfcawxfcb14-6cng4m8lhlrdfuq9jgzznre1p \
10.0.2.15:2377

Dans l’exemple actuel, la commande contient le Token Worker généré précédemment ainsi que l’adresse IP sous laquelle le Swarm Manager est disponible.

Si vous n’avez pas le Token correspondants à portée de main, déterminez 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éterminer le token Manager. Exécutez la commande docker swarm join-token manager sur le compte Manager où vous avez initialisé l’essaim et suivez les instructions sur le terminal.

Docker génère un token Manager, qui peut être exécuté sur n’importe quel hôte Docker en combinaison 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.

$ sudo docker swarm join-token manager
To add a manager to this swarm, run the following command:

docker swarm join \
--token SWMTKN-1-511cy9taxx5w47n80vopivx6ii6cjpi71vfncqhcfcawxfcb14-ed2ct6pg5rc6vp8bj46t08d0i \
10.0.2.15:2377

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 management docker node ls sur l’un de vos nœuds Manager.

ID                           HOSTNAME  STATUS  AVAILABILITY  MANAGER
jhy7ur9hvzvwd4o1pl8veqms3    worker2   Ready   Active
jukrzzii3azdnub9jia04onc5    worker1   Ready   Active
1ia0jlt0ylmnfofyfj2n71w0z *  osboxes   Ready   Active        Leader

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

Hinweis

pour supprimer un nœud de votre essaim, connectez-vous à l’hôte approprié et exécutez la commande docker swarm leave. Si le nœud est un Swarm Manager, vous devez forcer l‘exécution de la commande avec le drapeau --force.

Partie 2 : exécuter l’application multi-conteneurs dans le cluster.

Dans la première partie de notre tutoriel Docker, vous avez implémenté les hôtes Docker avec Docker Machine et les avez regroupés en mode Swarm sous forme de cluster. Nous allons maintenant vous montrer comment utiliser Docker Compose pour définir divers services en tant qu’applications multi-conteneurs compactes et les exécuter dans un cluster.

La préparation d’applications multi-conteneurs dans un cluster comporte cinq étapes :

  1. Créer un registre local Docker
  2. Définir l’application multi-conteneurs comme pile
  3. Tester l’application multi-conteneurs avec Compose
  4. Charger l’image dans le registre.
  5. Exécuter la pile dans le cluster

Étape 1 : démarrer le registre local Docker en tant que service.

Puisqu’un essaim Docker se compose d’un nombre quelconque de moteurs Docker, les applications ne peuvent fonctionner en cluster que si tous les moteurs Docker concernés ont accès à l’image de l’application. Vous avez donc besoin d’un service central qui vous permet de gérer les images et de les rendre disponibles dans le cluster. Un tel service se nomme registre (registry).

Note

une image est une ressemblance compacte et exécutable d’une application. En plus du code de l’application, cela comporte toutes les interdépendances (environnement d’exécution, bibliothèques, variables d’environnement et fichiers de configuration) dont Docker a besoin pour exécuter l’application en tant que conteneur. Chaque conteneur est donc une instance d’exécution d’une image.

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.

docker service create --name registry --publish 5000:5000 registry:2

La commande demande à Docker de démarrer un service nommé registry qui écoute le port 5000. La première valeur après le drapeau --publish spécifie le port hôte, la seconde le port du conteneur. Le service est basé sur l’image registry:2, qui contient une implémentation du registre Docker HTTP API V2 et est disponible gratuitement via le Docker.Hub.

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.

$ sudo docker service ls
ID            NAME      MODE        REPLICAS  IMAGE          PORTS
K2hq2ivnwuq4  registry  replicated  1/1       registry:2     *:5000->5000/tcp

La commande docker service ls apporte une liste de tous les services en cours d‘exécution dans votre cluster Docker.

1.3 Vérification 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 :

$ curl http://localhost:5000/v2/

Si votre registre fonctionne comme prévu, cURL devrait renvoyer la sortie suivante :

{}
Note

cURL est un programme en ligne de commande pour appeler des adresses Web et télécharger des fichiers. Vous pouvez en savoir plus sur cURL sur le site du projet Web du logiciel open source curl.haxx.se.

Étape 2 : créer une application multi-conteneurs et la définir comme une pile

Dans l’étape suivante, créez tous les fichiers nécessaires au déploiement d’une pile dans le cluster Docker et stockez-les dans un répertoire de projet partagé.

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

$ mkdir stackdemo

Naviguez jusqu’au répertoire de votre projet.

$ cd stackdemo

Votre répertoire de projet agit comme un dossier collectif pour tous les fichiers dont vous avez besoin pour exécuter votre application multi-conteneur. Ceux-ci incluent un fichier avec le code source de l’application, un fichier texte dans lequel vous définissez le logiciel dont vous avez besoin pour exécuter votre application, ainsi qu’un Dockerfile et un Compose-File.

2.2 Créer une application : créez une application Python avec le contenu suivant et placez-la dans le répertoire du projet sous le nom app.py.

from flask import Flask
from redis import Redis

app = Flask(__name__)
redis = Redis(host='redis', port=6379)

@app.route('/')
def hello():
    count = redis.incr('hits')
    return 'Hello World! I have been seen {} times.\n'.format(count)

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000, debug=True)

L’exemple d’application app.py est une simple application 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 conditions préalables : créez un fichier texte requirements.txt avec le contenu suivant et enregistrez-le dans le répertoire du projet.

flask
redis

Dans le fichier requirements.txt, vous définissez sur quel logiciel votre application est basée.

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

FROM python:3.4-alpine
ADD . /code
WORKDIR /code
RUN pip install -r requirements.txt
CMD ["python", "app.py"]

Le Dockerfile contient toutes les instructions nécessaires pour créer une image d’une application. Par exemple, le fichier Docker se réfère au fichier requirements.txt et spécifie comment le logiciel doit être installé pour exécuter l’application.

Le Dockerfile de l’exemple permet de créer une image de l’application Web app.py incluant toutes les conditions requises (Flask et Redis).

2. 5 Créer un Compose-File : créer un fichier de configuration avec le contenu suivant et enregistrez-le en tant que  docker-compose.yml.

version: '3'

services:
  web:
    image: 127.0.0.1:5000/stackdemo
    build: .
    ports:
      - "8000:8000"
  redis:
    image: redis:alpine

Le docker-compose.yml permet de relier les différents services entre eux, de les exécuter ensemble en tant qu’unité et de les gérer de manière centralisée.

Note

Compose-File est écrit en YAML, c’est un langage de balisage simplifié utilisé pour représenter les données structurées. Il est principalement utilisé dans les fichiers de configuration. Docker utilise docker-compose.yml de la configuration centrale des services d’une application multi-conteneurs.

Dans l’exemple actuel, nous définissons deux services : un service Web et un service Redis.

  • Service Web : le service Web est basé sur une image créée dans le répertoire 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 accessible au public (redis:alpine), qui est disponible via le Docker-Hub.

Étape 3 : tester l’application multi-conteneurs avec Compose

Testez l’application multi-conteneurs localement en l’exécutant sur le nœud de votre manager.

3.1 Lancer l’application : utilisez la commande docker-compose up en combinaison avec le drapeau -d, pour démarrer votre pile. Le drapeau active le « Detached mode », où tous les conteneurs sont exécutés en arrière-plan. Votre terminal est maintenant prêt à recevoir d’autres commandes.

$ sudo docker-compose up -d
WARNING: The Docker Engine you're using is running in swarm mode.

Compose does not use swarm mode to deploy services to multiple nodes in a swarm. All containers will be scheduled on the current node.

To deploy your application across the swarm, use the bundle feature of the Docker experimental build.

More info:
https://docs.docker.com/compose/bundles

Creating network "stackdemo_default" with the default driver
Creating stackdemo_web_1
Creating stackdemo_redis_1

3.2 Vérifier l’état de la pile : lancez la commande docker-compose ps, pour vérifier l’état de votre pile. Vous recevrez une sortie de terminal similaire à l’exemple suivant :

$ sudo docker-compose ps
      Name             Command             State              Ports       
-------------------------------------------------------------------------
stackdemo_redis_   docker-            Up                 6379/tcp         
1                  entrypoint.sh                                          
                   redis ...                                              
stackdemo_web_1    python app.py      Up                 0.0.0.0:8000->80 
                                                         00/tcp           

La commande docker-compose ps vous donne une vue d’ensemble de tous les conteneurs lancés dans votre application multi-conteneurs. Dans l’exemple actuel, la liste contient deux conteneurs, un pour les services Redis et Web.

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).

$ curl http://localhost:8000
Hello World! I have been seen 1 times.

$ curl http://localhost:8000
Hello World! I have been seen 2 times.

$ curl http://localhost:8000
Hello World! I have been seen 3 times.

Alternativement, l’application Web peut être appelée dans le navigateur Web.

3.4 Désactiver l’application : si vous voulez désactiver la pile, exécutez la commande docker-compose down avec le drapeau --volumes.

$ sudo docker-compose down --volumes
Stopping stackdemo_redis_1 ... done
Stopping stackdemo_web_1 ... done
Removing stackdemo_redis_1 ... done
Removing stackdemo_web_1 ... done
Removing network stackdemo_default

Étape 4 : charger l’image dans le registre

Avant de pouvoir exécuter votre application multi-conteneurs en tant qu’application distribuée dans un cluster, vous devez préparer toutes les images nécessaires 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 disponible via un registre public dans le Docker-Hub).

Docker appelle le téléchargement d’une image créée localement dans un registre central « push ». Docker Compose apporte pour cela la commande docker-compose push. Exécutez-la dans le répertoire de votre projet.

Toutes les images mentionnées  docker-compose.yml qui ont été créés localement sont chargés dans le registre.

$ sudo docker-compose push
Pushing web (127.0.0.1:5000/stackdemo:latest)...
The push refers to a repository [127.0.0.1:5000/stackdemo]
5b5a49501a76: Pushed
be44185ce609: Pushed
bd7330a79bcf: Pushed
c9fc143a069a: Pushed
011b303988d2: Pushed
latest: digest: sha256:a81840ebf5ac24b42c1c676cbda3b2cb144580ee347c07e1bc80e35e5ca76507 size: 1372

Dans l’exemple actuel docker-compose push charge l’image de la pile stackdemo avec le drapeau latest dans le registre local sous 127.0.0.1:5000.

Étape 5 : exécuter la pile dans le cluster

Si l’image de votre pile est disponible via le service de registre local, l’application 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 plateforme de conteneurs dispose de la commande suivante :

docker stack deploy [OPTIONS] STACK
Note

au lieu du champ STACK, entrez le nom de l’image de la pile que vous voulez exécuter.

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

$ sudo docker stack deploy --compose-file docker-compose.yml stackdemo
Ignoring unsupported options: build

Creating network stackdemo_default
Creating service stackdemo_web
Creating service stackdemo_redis

Le drapeau --compose-file donne le chemin d’accès de Compose-File.

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

docker stack services [OPTIONS] STACK

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

$ sudo docker stack services stackdemo
ID                  NAME                MODE                REPLICAS            IMAGE                             PORTS
cxyp7srukffy        stackdemo_web       replicated          1/1                 127.0.0.1:5000/stackdemo:latest   *:8000->8000/tcp
z0i2rtjbrj9s        stackdemo_redis     replicated          1/1                 redis:alpine                     

5.3 Tester l’application avec cURL : pour tester votre application multi-conteneurs, appelez-la via l’adresse de l‘hôte local sur le port 8000.

$ curl http://localhost:8000
Hello World! I have been seen 1 times.

$ curl http://localhost:8000
Hello World! I have been seen 2 times.

$ curl http://localhost:8000
Hello World! I have been seen 3 times.

Comme alternative à cURL, l’application peut être appelée via le navigateur Web. Utilisez l’adresse de l’hôte local ou l’adresse de n’importe quel nœud. Grâce au réseau de routage interne, vous pouvez accéder à chaque nœud de votre essaim sur le port 8000 afin d’être redirigé vers votre application.

5.4 Désactiver la pile : si vous voulez désactiver votre pile, utilisez la commande docker stack rm en combinaison avec le nom de la pile.

$ docker stack rm stackdemo

Removing service stackdemo_web
Removing service stackdemo_redis
Removing network stackdemo_default

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

$ docker service rm registry

Conclusion

Docker Swarm et Compose étendent les fonctionnalités de base de la plateforme de conteneurs avec des outils qui vous permettent d’exécuter des applications complexes dans des systèmes distribués avec un minimum de gestion. Le leader du marché dans le domaine de la virtualisation de conteneurs offre ainsi aux utilisateurs une solution complète pour l’orchestration de conteneurs à partir d’une source unique. Les deux outils sont bien documentés et sont mis à jour à intervalles réguliers. Swarm et Compose se positionnent ainsi comme une bonne alternative aux outils tiers établis tels que Kubernetes ou Panamax.