Déployer une pile vers un swarm

Table des matières

Lors de l'exécution de Docker Engine en mode swarm, vous pouvez utiliser docker stack deploy pour déployer une pile d'application complète vers le swarm. La commande deploy accepte une description de pile sous la forme d'un fichier Compose.

Note

La commande docker stack deploy utilise l'ancien format de fichier Compose version 3 utilisé par Compose V1. Le dernier format, défini par la spécification Compose n'est pas compatible avec la commande docker stack deploy.

Pour plus d'informations sur l'évolution de Compose, consultez Historique de Compose.

Pour suivre ce tutoriel, vous avez besoin de :

Un Docker Engine s'exécutant en mode Swarm. Si vous n'êtes pas familier avec le mode Swarm, vous pourriez vouloir lire Concepts clés du mode Swarm et Comment fonctionnent les services.

Note

Si vous essayez des choses dans un environnement de développement local, vous pouvez mettre votre moteur en mode Swarm avec docker swarm init.

Si vous avez déjà un swarm multi-nœuds en cours d'exécution, gardez à l'esprit que toutes les commandes docker stack et docker service doivent être exécutées depuis un nœud gestionnaire.
Une version actuelle de Docker Compose.

Configurer un registre Docker

Parce qu'un swarm consiste en plusieurs Docker Engines, un registre est requis pour distribuer les images à tous. Vous pouvez utiliser le Docker Hub ou maintenir le vôtre. Voici comment créer un registre jetable, que vous pouvez jeter par la suite.

Démarrez le registre comme un service sur votre swarm :

$ docker service create --name registry --publish published=5000,target=5000 registry:2

Vérifiez son statut avec docker service ls :

$ docker service ls

ID            NAME      REPLICAS  IMAGE                                                                               COMMAND
l7791tpuwkco  registry  1/1       registry:2@sha256:1152291c7f93a4ea2ddc95e46d142c31e743b6dd70e194af9e6ebe530f782c17

Une fois qu'il lit 1/1 sous REPLICAS, il fonctionne. S'il lit 0/1, il tire probablement encore l'image.

Vérifiez qu'il fonctionne avec curl :
$ curl http://127.0.0.1:5000/v2/ {}

Créer l'application exemple

L'application utilisée dans ce guide est basée sur l'application compteur de succès dans le guide Commencer avec Docker Compose. Elle consiste en une application Python qui maintient un compteur dans une instance Redis et incrémente le compteur chaque fois que vous la visitez.

Créez un répertoire pour le projet :
$ mkdir stackdemo $ cd stackdemo

Créez un fichier appelé app.py dans le répertoire du projet et collez ceci dedans :

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)

Créez un fichier appelé requirements.txt et collez ces deux lignes dedans :
```
flask
redis
```

Créez un fichier appelé Dockerfile et collez ceci dedans :

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

Créez un fichier appelé compose.yaml et collez ceci dedans :
services: web: image: 127.0.0.1:5000/stackdemo build: . ports: - "8000:8000" redis: image: redis:alpine
L'image pour l'application web est construite en utilisant le Dockerfile défini ci-dessus. Elle est également taguée avec 127.0.0.1:5000 - l'adresse du registre créé plus tôt. Ceci est important lors de la distribution de l'application au swarm.

Tester l'application avec Compose

Démarrez l'application avec docker compose up. Ceci construit l'image de l'application web, tire l'image Redis si vous ne l'avez pas déjà, et crée deux conteneurs.

Vous voyez un avertissement concernant le moteur en mode swarm. C'est parce que Compose ne tire pas parti du mode swarm, et déploie tout sur un seul nœud. Vous pouvez ignorer cet avertissement en toute sécurité.

$ 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 are scheduled on the current node.

To deploy your application across the swarm, use `docker stack deploy`.

Creating network "stackdemo_default" with the default driver
Building web
...(build output)...
Creating stackdemo_redis_1
Creating stackdemo_web_1

Vérifiez que l'application fonctionne avec docker compose ps :

$ docker compose ps

      Name                     Command               State           Ports
-----------------------------------------------------------------------------------
stackdemo_redis_1   docker-entrypoint.sh redis ...   Up      6379/tcp
stackdemo_web_1     python app.py                    Up      0.0.0.0:8000->8000/tcp

Vous pouvez tester l'application avec curl :

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

Arrêtez l'application :

$ docker compose down --volumes

Stopping stackdemo_web_1 ... done
Stopping stackdemo_redis_1 ... done
Removing stackdemo_web_1 ... done
Removing stackdemo_redis_1 ... done
Removing network stackdemo_default

Pousser l'image générée vers le registre

Pour distribuer l'image de l'application web à travers le swarm, elle doit être poussée vers le registre que vous avez configuré plus tôt. Avec Compose, c'est très simple :

$ 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

La pile est maintenant prête à être déployée.

Déployer la pile vers le swarm

Créez la pile avec docker stack deploy :

$ docker stack deploy --compose-file compose.yaml stackdemo

Ignoring unsupported options: build

Creating network stackdemo_default
Creating service stackdemo_web
Creating service stackdemo_redis

Le dernier argument est le nom de la pile. Chaque réseau, volume et service nom est préfixé avec le nom de la pile.

Vérifiez qu'il fonctionne avec docker stack services stackdemo :

$ docker stack services stackdemo

ID            NAME             MODE        REPLICAS  IMAGE
orvjk2263y1p  stackdemo_redis  replicated  1/1       redis:3.2-alpine@sha256:f1ed3708f538b537eb9c2a7dd50dc90a706f7debd7e1196c9264edeea521a86d
s1nf0xy8t1un  stackdemo_web    replicated  1/1       127.0.0.1:5000/stackdemo@sha256:adb070e0805d04ba2f92c724298370b7a4eb19860222120d43e0f6351ddbc26f

Une fois qu'il fonctionne, vous devriez voir 1/1 sous REPLICAS pour les deux services. Cela pourrait prendre du temps si vous avez un swarm multi-nœuds, car les images doivent être tirées.

Comme avant, vous pouvez tester l'application avec curl :

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

Avec le routage intégré de Docker, vous pouvez accéder à n'importe quel nœud du swarm sur le port 8000 et être routé vers l'application :

$ curl http://address-of-other-node:8000
Hello World! I have been seen 4 times.

Supprimez la pile avec docker stack rm :

$ docker stack rm stackdemo

Removing service stackdemo_web
Removing service stackdemo_redis
Removing network stackdemo_default

Supprimez le registre avec docker service rm :
$ docker service rm registry
Si vous testez simplement sur une machine locale et souhaitez mettre votre Docker Engine hors du mode Swarm, utilisez docker swarm leave :
$ docker swarm leave --force Node left the swarm.