Legen Sie schnell los mit dem Swarm-Modus der Docker Engine!

Einführung

Swarm, klingt wie eine Punkrockband. Aber es handelt sich tatsächlich um einen neuen Orchestrierungsmechanismus bzw. eine Verbesserung des bestehenden Orchestrierungsmechanismus von Docker. Einfach ausgedrückt: Wenn Sie eine ältere Version von Docker verwenden, müssen Sie Swarm manuell konfigurieren, um einen Docker-Cluster zu erstellen. Ab Version 1.12 integriert die Docker-Engine eine native Implementierung (LCTT-Anmerkung: siehe unten), um einen nahtlosen Cluster-Aufbau zu unterstützen. Deshalb gibt es diesen Artikel.

In diesem Tutorial werde ich Ihnen zeigen, was orchestriertes Docker leisten kann. Dieser Artikel soll nicht alle Details (wie BnBs) enthalten oder Ihnen alle Antworten geben, aber er soll Ihnen den Einstieg auf Ihren Weg zum Clustering erleichtern. Beginnen wir mit meiner Führung.

Teaser

Technische Zusammenfassung

Es wäre eine Schande, die detaillierte und nützliche Dokumentation von Docker hier zu kopieren, daher werde ich einen kurzen Überblick über die Technologie geben. Wir haben Docker bereits, richtig. Jetzt möchten Sie, dass mehr Server als Docker-Hosts fungieren, aber gleichzeitig möchten Sie, dass sie zur gleichen logischen Einheit gehören. Das heißt, Sie möchten einen Cluster einrichten.

Beginnen wir mit einem Cluster von Hosts. Wenn Sie einen Swarm-Cluster auf einem Host initialisieren, wird der Host zum Manager des Clusters. Aus technischer Sicht wird es zu einem Knoten in der Konsensgruppe. Die mathematische Logik dahinter basiert auf dem Raft-Algorithmus. Der Manager ist für die Planung der Aufgaben verantwortlich. Spezifische Aufgaben werden an jeden Worker-Knoten delegiert, der dem Swarm-Cluster beigetreten ist. Diese Vorgänge werden von der Node-API verwaltet. Auch wenn ich das Wort API hasse, muss ich es hier verwenden.

Service API ist die zweite Komponente in dieser Implementierung. Es ermöglicht dem Manager-Knoten, einen verteilten Dienst auf allen Swarm-Cluster-Knoten zu erstellen. Dieser Dienst kann repliziert werden, was bedeutet, dass er (LCTT-Anmerkung: bezieht sich auf diese Dienste) über den Ausgleichsmechanismus (LCTT-Anmerkung: bezieht sich auf den replizierten Modus) auf den Cluster verteilt wird. Mehrere Containerinstanzen planen automatisch Aufgaben für einige im Cluster ) Knoten, die die Bedingungen erfüllen) oder dem globalen Modus zugewiesen werden (LCTT-Anmerkung: bezieht sich auf den globalen Modus), was bedeutet, dass jeder Knoten eine Containerinstanz ausführt.

Es gibt noch viel zu tun, aber diese Informationen reichen aus, um Ihnen den Einstieg zu erleichtern. Kommen wir nun zum praktischen Teil. Unsere Zielplattform ist CentOS 7.2, das interessanterweise nur Version 1.10 von Docker in seinem Repository hat, während ich dieses Tutorial schreibe, was bedeutet, dass ich es manuell aktualisieren muss, um Swarm verwenden zu können. Wir werden dies in einem anderen Tutorial besprechen. Wir haben eine Folgeanleitung, die beschreibt, wie wir neue Knoten zu unserem bestehenden Cluster hinzufügen, und wir werden Fedora für eine asymmetrische Konfiguration verwenden. Stellen Sie an dieser Stelle bitte sicher, dass die richtige Konfiguration vorhanden ist und dass Sie über einen funktionierenden Cluster verfügen (LCTT-Anmerkung: Bezieht sich darauf, dass der Docker des ersten Knotens installiert wird und in den Swarm-Modus wechselt, aber ich habe nicht behandelt, wie Swarm initialisiert wird bis zu diesem Punkt. Aber keine Sorge, dazu kommen wir im nächsten Kapitel.

Bilder und Dienste konfigurieren

Ich werde versuchen, einen Apache-Dienst mit Lastenausgleich zu konfigurieren und mehrere Containerinstanzen zu verwenden, um Seiteninhalte über eindeutige IP-Adressen bereitzustellen. Ziemlich normal (LCTT-Übersetzungsanmerkung: bezieht sich auf diesen Webserver mit Lastausgleich). Dieses Beispiel verdeutlicht auch die meisten Gründe, warum Sie möglicherweise einen Cluster verwenden möchten: Verfügbarkeit, Redundanz, Skalierung und Leistung. Natürlich müssen Sie sowohl Netzwerk als auch Speicher berücksichtigen, diese gehen jedoch über den Rahmen dieses Leitfadens hinaus.

Diese Dockerfile-Vorlage ist tatsächlich unter httpd im offiziellen Image-Repository zu finden. Alles, was Sie brauchen, ist eine einfache Einrichtung, um loszulegen. Informationen zum Herunterladen oder Erstellen eines eigenen Bildes finden Sie in meinem Leitfaden „Erste Schritte“. Den Link finden Sie oben in diesem Tutorial.

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

Bild erstellt

Bevor Sie mit den folgenden Schritten fortfahren, sollten Sie sicherstellen, dass Sie eine Containerinstanz fehlerfrei starten und eine Verbindung zum Webserver herstellen können (LCTT-Anmerkung: Verwenden Sie den folgenden Befehl). Sobald Sie sichergestellt haben, dass Sie eine Verbindung herstellen können, können wir mit der Erstellung eines verteilten Dienstes beginnen.

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

Geben Sie diese IP-Adresse in Ihren Browser ein und sehen Sie, was angezeigt wird.

Schwarminitialisierung und -konfiguration

Der nächste Schritt besteht darin, den Swarm-Cluster zu starten. Um loszulegen, benötigen Sie diese grundlegendsten Befehle, die den Beispielen im Docker-Blog sehr ähnlich sind:

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

Was haben wir hier gemacht? Wir haben einen Dienst namens frontent mit fünf Containerinstanzen erstellt. Gleichzeitig binden wir auch Port 80 des Hosts an Port 80 dieser Container. Für diesen Test verwenden wir das neu erstellte Apache-Image. Wenn Sie jedoch den obigen Befehl direkt auf Ihrem Computer eingeben, wird die folgende Fehlermeldung angezeigt:

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 模式）。也就是说，请别偷懒花些时间阅读以下内容：

• Docker Swarm-Übersicht (eigenständige Version der Swarm-Cluster-Installation)
• Erstellen Sie einen Swarm-Cluster für die Produktionsumgebung (unabhängige Versionsinstallation)
• Installieren und erstellen Sie einen Docker Swarm-Cluster (Installation der eigenständigen Version)
• Docker Engine Swarm-Übersicht (für Version 1.12)
• Erste Schritte mit dem Schwarmmodus (für Version 1.12)

Zusammenfassung

Endlich sehen Sie es hier. Es gibt noch keine Garantie dafür, dass Sie zu diesem Zeitpunkt etwas gelernt haben, aber ich glaube, dass Sie diesen Artikel dennoch nützlich finden werden. Es behandelt einige grundlegende Konzepte und einen Überblick darüber, wie der Swarm-Cluster-Modus funktioniert und was er kann. Außerdem haben wir erfolgreich ein Image unseres Webservers heruntergeladen und dann darauf basierend mehrere Cluster-Container-Instanzen ausgeführt. Obwohl wir die oben genannten Experimente derzeit nur an einem einzelnen Knoten durchgeführt haben, werden wir sie in Zukunft klar erklären (LCTT-Übersetzung: um den Betrieb des Multi-Node-Swarm-Clusters klar zu erklären). Und wir haben einige häufig auftretende Probleme gelöst.

Ich hoffe, Sie fanden diesen Leitfaden interessant genug. In Kombination mit den Artikeln, die ich in der Vergangenheit über Docker geschrieben habe, sollten diese Artikel Ihnen eine anständige Erklärung geben, einschließlich der Bedienung von Bildern, Netzwerkstapeln, Speicher und jetzt auch Clustern. Betrachten Sie es einfach als Aufwärmübung. Viel Spaß und wir freuen uns darauf, Sie im neuen Docker-Tutorial zu sehen. Ich kann nicht kontrollieren, wie viel ich mich erinnere.

Einen schönen Tag noch.

Das obige ist der detaillierte Inhalt vonLegen Sie schnell los mit dem Swarm-Modus der Docker Engine!. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!