Démarrez rapidement avec le mode Swarm de Docker Engine !

Présentation

Swarm, ça sonne comme un groupe de punk rock. Mais il s'agit bien d'un nouveau mécanisme d'orchestration, ou d'une amélioration du mécanisme d'orchestration existant de Docker. En termes simples, si vous utilisez une ancienne version de Docker, vous devez configurer manuellement Swarm pour créer un cluster Docker. À partir de la version 1.12, le moteur Docker intègre une implémentation native (annotation LCTT : voir ci-dessous) pour prendre en charge une configuration transparente du cluster. C'est pourquoi cet article existe.

Dans ce tutoriel, je vais vous faire découvrir ce que Docker orchestré peut faire. Cet article n’est pas censé contenir tous les détails (comme les BnB) ni vous donner toutes les réponses, mais il devrait vous aider à démarrer votre chemin vers le clustering. Commençons par mon leadership.

Teaser

Résumé technique

Il serait dommage de copier ici la documentation détaillée et utile de Docker, je vais donc donner un bref aperçu de la technologie. Nous avons déjà Docker, n'est-ce pas. Désormais, vous souhaitez que davantage de serveurs servent d'hôtes Docker, mais en même temps, vous souhaitez qu'ils appartiennent à la même entité logique. Autrement dit, vous souhaitez configurer un cluster.

Commençons par un cluster d'hôtes. Lorsque vous initialisez un cluster Swarm sur un hôte, l'hôte devient le gestionnaire du cluster. D'un point de vue technique, il devient un nœud du groupe de consensus. La logique mathématique derrière cela est basée sur l’algorithme Raft. Le gestionnaire est responsable de la planification des tâches. Des tâches spécifiques seront déléguées à chaque nœud de travail ayant rejoint le cluster Swarm. Ces opérations seront gérées par l'API Node. Même si je déteste le mot API, je dois l'utiliser ici.

L'API de service est le deuxième composant de cette implémentation. Il permet au nœud gestionnaire de créer un service distribué sur tous les nœuds du cluster Swarm. Ce service peut être répliqué, ce qui signifie qu'ils (Annotation LCTT : fait référence à ces services) seront distribués au cluster par le mécanisme d'équilibrage (Annotation LCTT : fait référence au mode répliqué, plusieurs instances de conteneur planifieront automatiquement des tâches pour certaines dans le cluster ) nœuds qui remplissent les conditions), ou peuvent être affectés au global (annotation LCTT : fait référence au mode global), ce qui signifie que chaque nœud exécutera une instance de conteneur.

Il y a encore du travail à faire, mais ces informations sont suffisantes pour vous aider à démarrer. Passons maintenant aux choses pratiques. Notre plate-forme cible est CentOS 7.2, qui, curieusement, n'a que la version 1.10 de Docker dans son référentiel au moment où j'écris ce tutoriel, ce qui signifie que je dois la mettre à jour manuellement pour utiliser Swarm. Nous en discuterons dans un autre tutoriel. Nous avons un guide de suivi qui explique comment ajouter de nouveaux nœuds à notre cluster existant, et nous utiliserons Fedora pour une configuration asymétrique. À ce stade, assurez-vous que la configuration correcte est en place et que vous disposez d'un cluster fonctionnel opérationnel (Annotation LCTT : fait référence au Docker du premier nœud en cours d'installation et passe en mode Swarm, mais je n'ai pas expliqué comment initialiser Swarm jusqu’à présent, mais ne vous inquiétez pas, nous y reviendrons dans le prochain chapitre).

Configurer les images et les services

Je vais essayer de configurer un service Apache à charge équilibrée et d'utiliser plusieurs instances de conteneur pour diffuser le contenu de la page via des adresses IP uniques. Assez standard (annotation de traduction LCTT : fait référence à ce serveur Web à charge équilibrée). Cet exemple met également en évidence la plupart des raisons pour lesquelles vous souhaiterez peut-être utiliser un cluster : disponibilité, redondance, évolutivité et performances. Bien sûr, vous devez prendre en compte à la fois la mise en réseau et le stockage, mais ils dépassent le cadre de ce guide.

Ce modèle Dockerfile peut en fait être trouvé sous httpd dans le référentiel d'images officiel. Tout ce dont vous avez besoin est une configuration simple pour commencer. Pour savoir comment télécharger ou créer votre propre image, veuillez vous référer à mon guide de démarrage, le lien se trouve en haut de ce tutoriel.

docker build -t my-apache2 .
Sending build context to Docker daemon 2.048 kB
Step 1 : FROM httpd:2.4
Trying to pull repository docker.io/library/httpd ...
2.4: Pulling from docker.io/library/httpd
8ad8b3f87b37: Pull complete
c95e1f92326d: Pull complete
96e8046a7a4e: Pull complete
00a0d292c371: Pull complete
3f7586acab34: Pull complete
Digest: sha256:3ad4d7c4f1815bd1c16788a57f81b413...a915e50a0d3a4
Status: Downloaded newer image for docker.io/httpd:2.4
---> fe3336dd034d
Step 2 : COPY ../public-html/ /usr/local/apache2/htdocs/
...

Image créée

Avant de poursuivre les étapes suivantes, vous devez vous assurer que vous pouvez démarrer une instance de conteneur sans erreur et vous connecter au serveur Web (annotation LCTT : utilisez la commande suivante). Une fois que vous vous êtes assuré que vous pouvez vous connecter, nous pouvons commencer à créer un service distribué.

docker run -dit --name my-running-app my-apache2

Mettez cette adresse IP dans votre navigateur et voyez ce qui se passe.

Initialisation et configuration de Swarm

La prochaine étape consiste à démarrer le cluster Swarm. Vous aurez besoin de ces commandes les plus élémentaires pour commencer, qui sont très similaires aux exemples du blog Docker :

docker service create --name frontend --replicas 5 -p 80:80/tcp my-apache2:latest

Qu'avons-nous fait ici ? Nous avons créé un service appelé frontent avec cinq instances de conteneur. Dans le même temps, nous lions également le port 80 de l'hôte au port 80 de ces conteneurs. Nous utiliserons l'image Apache nouvellement créée pour ce test. Cependant, lorsque vous tapez la commande ci-dessus directement sur votre ordinateur, vous verrez l'erreur suivante :

docker service create --name frontend --replicas 5 -p 80:80/tcp my-apache2:latest
Error response from daemon: This node is not a swarm manager. Use "docker swarm init" or "docker swarm join" to connect this node to swarm and try again.

这意味着你没有将你的主机（节点）配置成一个 Swarm 管理者manager。你可以在这台主机上初始化 Swarm 集群或是让它加入一个现有的集群。由于我们目前还没有一个现成的集群，我们将初始化它（LCTT 译注：指初始化 Swarm 集群并使当前节点成为 manager）：

docker swarm init
Swarm initialized: current node (dm58mmsczqemiikazbfyfwqpd) is now a manager.

为了向这个 Swarm 集群添加一个工作者worker，请执行下面的指令：

docker swarm join \
--token SWMTKN-1-4ofd46a2nfyvrqwu8w5oeetukrbylyznxla
9srf9vxkxysj4p8-eu5d68pu5f1ci66s7w4wjps1u \
10.0.2.15:2377

为了向这个 Swarm 集群添加一个管理者manager，请执行 docker swarm join-token manager 并按照指示操作。

操作后的输出不用解释已经很清楚明了。我们成功的创建了一个 Swarm 集群。新的节点们将需要正确的令牌token来加入这个 Swarm 集群。如果你需要配置防火墙，你还需找到它的 IP 地址和端口（LCTT 译注：指 Docker 的 Swarm 模式通讯所需的端口，默认 2377）。此外，你还可以向 Swarm 集群中添加管理者节点。现在，重新执行刚刚的服务创建指令：

docker service create --name frontend --replicas 5 -p 80:80/tcp my-apache2:latest
6lrx1vhxsar2i50is8arh4ud1

测试连通性

现在，我们来验证下我们的服务是否真的工作了。从某些方面讲，这很像我们在 Vagrant 和 coreOS 中做的事情那样。毕竟它们的原理几乎相同。相同指导思想的不同实现罢了（LCTT 译注：笔者观点，无法苟同）。首先需要确保 docker ps 能够给出正确的输出。你应该能看到所创建服务的多个容器副本。

docker ps
CONTAINER ID        IMAGE               COMMAND              CREATED             STATUS              PORTS              
NAMES
cda532f67d55        my-apache2:latest   "httpd-foreground"  
2 minutes ago       Up 2 minutes        80/tcp              frontend.1.2sobjfchdyucschtu2xw6ms9a
75fe6e0aa77b        my-apache2:latest   "httpd-foreground"  
2 minutes ago       Up 2 minutes        80/tcp              frontend.4.ag77qtdeby9fyvif5v6c4zcpc
3ce824d3151f        my-apache2:latest   "httpd-foreground"  
2 minutes ago       Up 2 minutes        80/tcp              frontend.2.b6fqg6sf4hkeqs86ps4zjyq65
eda01569181d        my-apache2:latest   "httpd-foreground"  
2 minutes ago       Up 2 minutes        80/tcp              frontend.5.0rmei3zeeh8usagg7fn3olsp4
497ef904e381        my-apache2:latest   "httpd-foreground"  
2 minutes ago       Up 2 minutes        80/tcp              frontend.3.7m83qsilli5dk8rncw3u10g5a

我也测试了不同的、非常规的端口，它们都能正常工作。对于你如何连接服务器和收取请求你将会有很多可配置的余地。你可以使用 localhost 或者 Docker 网络接口（笔者注：应该是指 Docker 的默认网桥 docker0，其网关为 172.17.0.1） 的 IP 地址的正确端口去访问。下面的例子使用了端口 1080：

Replicated Web service works

至此，这是一个非常粗略、简单的开始。真正的挑战是创建一个优化过的、可扩展的服务，但是它们需要一个准确的技术用例。此外，你还会用到 docker info 和 docker service（还有 inspect 和 ps）命令来详细了解你的集群是如何工作的。

可能会遇到的问题

你可能会在把玩 Docker 和 Swarm 时遇到一些小的问题（也许没那么小）。比如 SELinux 也许会抱怨你正在执行一些非法的操作（LCTT 译注：指在强制访问控制策略中没有权限的操作）。然而，这些错误和警告应该不会对你造成太多阻碍。

SELinux alert

• docker service 不是一条命令（docker service is not a docker command）当你尝试执行必须的命令去创建一个复制模式replicated的服务时，你可能会遇到一条错误说 docker: 'service' is not a docker command（LCTT 译注：见下面的例子）。这表示你的 Docker 版本不对（使用 -v 选项来检查）。我们将在将来的教程讨论如何修复这个问题。

  docker service create --name frontend --replicas 5 -p 80:80/tcp my-apache2:latest
  docker: 'service' is not a docker command.

• docker tag 无法识别（docker tag not recognized）你也许会看到下面的错误：

  docker service create -name frontend -replicas 5 -p 80:80/tcp my-apache2:latest
  Error response from daemon: rpc error: code = 3 desc = ContainerSpec: "-name" is not a valid repository/tag

  关于这个错误已经有多个相关的讨论和帖子了。其实这个错误也许相当无辜。你也许是从浏览器粘贴的命令，在浏览器中的横线也许没被正确解析（笔者注：应该用 --name 而不是 -name）。就是这么简单的原因所导致的。

扩展阅读

关于这个话题还有很多可谈的，包含 1.12 版之前的 Swarm 集群实现（笔者注：旧的 Swarm 集群实现，下文亦作独立版本，需要 Consul 等应用提供服务发现），以及当前的 Docker 版本提供的（笔者注：新的 Swarm 集群实现，亦被称为 Docker 引擎的 Swarm 模式）。也就是说，请别偷懒花些时间阅读以下内容：

• Présentation de Docker Swarm (version autonome de l'installation du cluster Swarm)
• Créer un cluster Swarm pour l'environnement de production (installation de version indépendante)
• Installer et créer un cluster Docker Swarm (installation de la version autonome)
• Présentation de Docker Engine Swarm (pour la version 1.12)
• Démarrez avec le mode Swarm (pour la version 1.12)

Résumé

Vous le voyez enfin ici. Il n’y a toujours aucune garantie que vous ayez appris quoi que ce soit à ce stade, mais je pense que cet article vous sera toujours utile. Il couvre quelques concepts de base et un aperçu du fonctionnement du mode cluster Swarm et de ce qu'il peut faire. Nous avons également téléchargé et créé avec succès une image de notre serveur Web, puis l'avons exécuté sur cette base. Bien que nous n'ayons mené les expériences ci-dessus que sur un seul nœud, nous l'expliquerons clairement dans le futur (traduction LCTT : pour expliquer le fonctionnement du cluster Swarm multi-nœuds). Et nous avons résolu certains problèmes courants.

J'espère que vous avez trouvé ce guide suffisamment intéressant. Combinés avec les articles que j'ai écrits sur Docker dans le passé, ces articles devraient vous donner une explication décente, notamment : comment faire fonctionner les images, les piles réseau, le stockage et maintenant les clusters. Considérez-le simplement comme un échauffement. En effet, profitez-en et au plaisir de vous retrouver dans le nouveau tutoriel Docker. Je ne peux pas contrôler ce dont je me souviens.

Bonne journée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!