TOC

Verwendung des Ambassador-Musters zum dynamischen Konfigurieren von Diensten unter CoreOS

Einführung

Die Docker Links-Funktion ermöglicht eine Methode zum dynamischen Konfigurieren von Netzwerkverbindungen zwischen Containern, die als "Botschaftermuster" bezeichnet wird. Das Ambassador-Muster fördert die Service-Portabilität zwischen provider und consumer Containern. In CoreOS kann "+ etcd +" verwendet werden, um das auf mehrere Computer in einem Cluster verteilte Ambassador-Muster zu implementieren.

In diesem Tutorial wird die Bereitstellung eines Apache-HTTP-Containers demonstriert, der mit "+ etcd +" registriert ist. Der Apache-Container wird unseren Provider-Container darstellen, und wir werden HAProxy als unseren Consumer-Container verwenden. Wir werden Docker-Images von this CoreOS-Ambassador-Demo für unsere Ambassador-Container verwenden und unseren eigenen Apache- und HAProxy-Docker erstellen Bilder von Grund auf neu.

Voraussetzungen

Auf DigitalOcean muss ein CoreOS-Cluster vorhanden sein, der aus mindestens drei Computern besteht. Hier finden Sie ein Tutorial zum Einrichten: https://www.digitalocean.com/community/tutorials/how-to-create-and-run-a-service-on-a-coreos-cluster[How To Create und Ausführen eines Dienstes auf einem CoreOS-Cluster

Sie benötigen Grundkenntnisse in der Verwendung von CoreOS, etcdctl, fleetctl, dem Einrichten von Diensten und dem Ausführen von Docker-Containern. Diese Themen werden in der Getting Started with CoreOS tutorial series behandelt.

Sie müssen über ein Docker Hub-Konto oder eine private Docker-Registrierung verfügen. Dies wird in Creating behandelt the Docker Container im Abschnitt Anlegen und Ausführen eines Dienstes in einem CoreOS Cluster-Lernprogramm.

Ausführliche Informationen zur Funktionsweise des Ambassador-Musters finden Sie im Artikel Link via a Ambassador Container von Docker. Lesen Sie auch diesen Artikel im CoreOS-Blog: Dynamic Docker-Links mit einem von etcd unterstützten Botschafter.

Unser Ziel

Am Ende dieses Tutorials werden sechs Container auf zwei Computern ausgeführt. Dieser Abschnitt enthält eine kurze Beschreibung der einzelnen Elemente und deren Gruppierung. Diese genaue Konfiguration ist für die meisten Benutzer nicht hilfreich, kann jedoch angepasst werden, um eine dynamische Diensterkennung für Ihre eigenen Dienste zu ermöglichen.

Maschine A

Maschine A wird den Provider-Container ausführen, d.h. Apache-Webserver und einige andere Container, die ihn unterstützen.

  • * Apache-Webserver *: Ein grundlegender Apache-Container, den wir von Grund auf neu erstellen, ähnlich dem in https://www.digitalocean.com/community/tutorials/how-to-create-and-run-a- beschriebenen. service-on-a-coreos-cluster [Erstellen und Ausführen eines Dienstes in einem CoreOS-Cluster] Tutorial. Das ist unser Produzent

  • * polvi / docker-register *: Ein registration container, der die IP-Adresse und den Port von Apache über die Docker-API liest und in "+ etcd +" schreibt

  • * polvi / simple-amb *: Ein einfacher Botschafter-Container, der den Datenverkehr an einen bestimmten Ort weiterleitet. In diesem Fall leiten wir den Datenverkehr an "+ etcd " weiter und verknüpfen ihn mit dem Container " docker-register ", um diesem Container Zugriff auf " etcd " zu gewähren. Da in CoreOS die Position von " etcd " statisch ist, kann diese entfernt werden, wenn " docker-register " geändert wurde, um direkt auf " etcd +" zuzugreifen

Maschine B

Maschine B ist eine CoreOS-Maschine, auf der der Consumer-Container ausgeführt wird, d. H. HAProxy und der Hauptbotschafter-Container.

  • * HAProxy Reverse Proxy *: Ein grundlegender HAProxy-Container, den wir von Grund auf neu erstellen und der unseren Consumer darstellt. Dies wird verwendet, um zu demonstrieren, dass das Ambassador-Setup funktioniert

  • * polvi / dynamic-etcd-amb *: Der Hauptcontainer für Botschafter. Ein dynamischer Proxy, der einen angegebenen "+ etcd +" - Schlüssel für die IP-Adresse und den Port des Provider-Containers überwacht und den gesamten Datenverkehr an den Provider-Container weiterleitet. Der Wert des Schlüssels kann aktualisiert werden, und der Proxy aktualisiert sich selbst

  • * polvi / simple-amb *: Derselbe Container, der auf der anderen Maschine verwendet wurde, aber zum Verknüpfen von + dynamic-etcd-amb + mit + etcd +

Erstellen Sie ein Apache Docker-Image

SSH an einen Ihrer CoreOS-Rechner und übergeben Sie Ihren SSH-Agenten (Ersatz in der öffentlichen IP-Adresse):

ssh -A core@

Dann melden Sie sich bei Docker an:

docker login

Geben Sie Ihr Passwort und Ihre E-Mail-Adresse ein, wenn Sie dazu aufgefordert werden.

Als nächstes erstellen Sie ein neues Verzeichnis, in das Sie Ihr Apache Dockerfile schreiben können:

mkdir -p ambassador/apache

Wechseln Sie nun in das Verzeichnis und öffnen Sie + Dockerfile + zum Bearbeiten:

cd ambassador/apache
vi Dockerfile

Basierend auf dem Apache-Container-Setup von https://www.digitalocean.com/community/tutorials/how-to-create-and-run-a-service-on-a-coreos-cluster#creating-the-docker-container [So erstellen Sie einen Dienst und führen ihn auf einem CoreOS-Cluster aus], können Sie die folgende Docker-Datei erstellen (ersetzen Sie "+ user_name +" durch Ihren eigenen Docker-Benutzernamen):

FROM ubuntu:14.04
MAINTAINER

RUN apt-get update && \
   DEBIAN_FRONTEND=noninteractive apt-get -y install apache2 && \
   echo "<h1>Running from Docker on CoreOS</h1>" > /var/www/html/index.html

EXPOSE 80

ENTRYPOINT ["/usr/sbin/apache2ctl"]
CMD ["-D", "FOREGROUND"]

Speichern und Beenden.

Nachdem wir nun eine Docker-Datei haben, die Apache installiert und index.html durch eine grundlegende Meldung ersetzt, erstellen Sie Ihr Docker-Image und nennen Sie es "apache" mit dem folgenden Befehl (ersetzen Sie Ihren eigenen Benutzernamen):

docker build --tag="/apache" .

Um das Image nun für Ihre anderen CoreOS-Computer verfügbar zu machen, drücken Sie mit dem folgenden Befehl auf die Docker-Registrierung, um es zu speichern:

docker push /apache

Jetzt ist Ihr Apache-Image einsatzbereit. Fahren wir mit der Erstellung eines HAProxy-Images fort.

Erstellen Sie ein HAProxy Docker-Image

Wir werden ein HAProxy Docker-Image erstellen, das auf der https://github.com/dockerfile/haproxy[HAproxy Dockerfile für vertrauenswürdige automatisierte Docker-Builds basiert. Wir werden die bereitgestellten Dateien + haproxy.cfg + und + start.bash + leicht modifizieren.

Verwenden Sie im Verzeichnis "+ ambassador " " git +", um das HAProxy-Repository zu klonen:

cd ~/ambassador
git clone https://github.com/dockerfile/haproxy.git

Dadurch wird ein "+ haproxy " -Verzeichnis mit " Dockerfile " -, " haproxy.cfg " - und " start.bash +" -Dateien erstellt.

Das Dockerfile installiert im Grunde HAProxy und macht die Ports 80 und 443 verfügbar, sodass wir es so lassen können, wie es ist.

Wir werden die Datei "+ haproxy.cfg " modifizieren, um ein " Frontend " und " Backend " hinzuzufügen. Öffne ` haproxy.cfg +` zum Bearbeiten:

cd haproxy
vi haproxy.cfg

Suchen und löschen Sie nun die folgenden Zeilen:

listen stats :80
 stats enable
 stats uri /

Fügen Sie dann die folgenden Zeilen am Ende der Datei hinzu:

frontend www-http
       bind :80
       default_backend www-backend

backend www-backend
       server apache :80 check

Dadurch wird HAProxy so konfiguriert, dass es Port 80 überwacht und eingehenden Datenverkehr an das aus einem einzelnen Server bestehende "+ www-backend" weiterleitet. Wir werden das Skript + start.bash + verwenden, um + private_ipv4 + durch die private IP-Adresse des CoreOS-Rechners zu ersetzen, auf dem dieser Container ausgeführt wird, wenn der HAProxy-Container gestartet wird. Unser dynamischer Ambassador-Container, über den HAProxy den Datenverkehr an den Apache-Container weiterleitet, wird auf demselben Computer ausgeführt.

Öffnen Sie die Datei + start.bash + zum Bearbeiten:

vi start.bash

Am Ende der Datei finden Sie eine Zeile, die den HAProxy-Prozess in diesem Container startet. Es sieht aus wie das:

haproxy -f /etc/haproxy/haproxy.cfg -p "$PIDFILE"

Fügen Sie direkt über dieser Zeile die folgenden Zeilen ein:

# Set backend IP address to machine's private IP address
PRIVATE_IPV4=$(curl -sw "\n" http://169.254.169.254/metadata/v1/interfaces/private/0/ipv4/address)
sed -i -e "s/server apache private_ipv4:80 check/server apache ${PRIVATE_IPV4}:80 check/g" $HAPROXY/$CONFIG

Speichern und schließen. Der Befehl "+ curl " ruft die private IP-Adresse des Computers ab, auf dem der Container über den DigitalOcean-Metadatendienst ausgeführt wird. Der Befehl " sed " ersetzt die Zeichenfolge " private_ipv4 " in " haproxy.cfg +" durch die tatsächliche IP-Adresse, die aus den Metadaten abgerufen wurde. Dieses Skript wird im HAProxy-Container ausgeführt, sodass die private IP-Adresse zur Laufzeit konfiguriert wird.

Jetzt können Sie das HAProxy-Docker-Image erstellen. Erstellen Sie Ihr Docker-Image und nennen Sie es "haproxy" mit dem folgenden Befehl (ersetzen Sie Ihren eigenen Benutzernamen):

docker build --tag="/haproxy" .

Um das Image nun für Ihre anderen CoreOS-Computer verfügbar zu machen, drücken Sie mit dem folgenden Befehl auf die Docker-Registrierung, um es zu speichern:

docker push /haproxy

Ihr HAProxy-Image ist einsatzbereit. Wir sind bereit, die Dateien unserer Flotten-Serviceeinheiten zu schreiben!

Dateien der Flotten-Service-Einheiten

Nachdem alle erforderlichen Docker-Images für unseren CoreOS-Cluster verfügbar sind, können Sie mit der Arbeit an den Dateien beginnen, die für die Bereitstellung unserer Container erforderlich sind. Da wir einen CoreOS-Cluster verwenden, können wir alle Dateien unserer Flotten-Serviceeinheiten von einem einzigen CoreOS-Computer aus erstellen und planen.

Wir werden alle Servicedateien im Verzeichnis "+ ~ / ambassador +" erstellen, das wir zuvor erstellt haben. Wechseln Sie jetzt in dieses Verzeichnis:

cd ~/ambassador

apache.service

Die Einheit "+ apache.service +" wird auf Host A ausgeführt.

Die erste Service-Datei, die wir erstellen, ist für den Apache-Webserver-Container "+ Benutzername / Apache ". Öffne eine Datei mit dem Namen " apache.service +" zum Bearbeiten:

vi apache.service

Fügen Sie die folgenden Zeilen hinzu (ersetzen Sie Ihren Docker-Benutzernamen an beiden Stellen):

[Unit]
Description=Apache web server service

[Service]
EnvironmentFile=/etc/environment
ExecStartPre=-/usr/bin/docker kill %n
ExecStartPre=-/usr/bin/docker rm %n
ExecStartPre=/usr/bin/docker pull /apache
ExecStart=/usr/bin/docker run --rm --name %n -p ${COREOS_PRIVATE_IPV4}::80 /apache
ExecStop=/usr/bin/docker stop -t 3 %n
Speichern und schließen. Dies ist eine recht unkomplizierte Servicedatei, die Apache im Vordergrundmodus startet. Besonders hervorzuheben ist, dass wir Port 80 im Container an einen dynamischen Port der privaten Netzwerkschnittstelle binden (`+ -p $ {COREOS_PRIVATE_IPV4}

80 +`).

etcd-amb-apache.service

Die Einheit "+ etcd-amb-apache.service +" wird auf "Host A" ausgeführt.

Als nächstes wollen wir eine Service-Datei für unseren einfachen Ambassador-Container ("+ simple-amb ") erstellen, die es dem Apache-Registrierungscontainer ermöglicht, auf " etcd " zuzugreifen. Öffnen Sie jetzt eine Datei mit dem Namen " etcd-amb-apache.service +":

vi etcd-amb-apache.service

Fügen Sie die folgenden Zeilen hinzu:

[Unit]
Description=Simple Apache ambassador
After=apache.service
BindsTo=apache.service

[Service]
ExecStartPre=-/usr/bin/docker kill %n
ExecStartPre=-/usr/bin/docker rm %n
ExecStart=/usr/bin/docker run --rm --name %n polvi/simple-amb 172.17.42.1:4001
ExecStop=/usr/bin/docker stop -t 3 %n

[X-Fleet]
X-ConditionMachineOf=apache.service

Speichern und schließen.

Der "+ simple-amb " - Container leitet den gesamten auf Port 10000 empfangenen Datenverkehr an das Argument weiter, das beim Start angegeben wurde, d. H. `+172.17.42.1: 4001 +`, der Standardspeicherort von ` etcd +` in CoreOS.

+ X-ConditionMachineOf = apache.service + weist die Flotte an, dies auf demselben Computer wie der Apache-Container zu planen. Dies ist kritisch, da der Container + docker-register + die IP-Adresse und den Port registriert, der Apache ist mit zu + etcd +.

apache-docker-reg.service

Die Einheit "+ Apache-Docker-reg.service +" wird auf Host A ausgeführt.

Erstellen wir die Servicedatei für unseren Container, in der die IP-Adresse und der Port von Apache unter "+ etcd ", " docker-register " registriert werden. Öffnen Sie jetzt eine Datei mit dem Namen " apache-docker-reg.service +":

vi apache-docker-reg.service

Fügen Sie folgende Zeilen ein:

[Unit]
Description=Register Apache
After=etcd-amb-apache.service
BindsTo=etcd-amb-apache.service

[Service]
ExecStartPre=-/usr/bin/docker kill %n
ExecStartPre=-/usr/bin/docker rm %n
ExecStart=/usr/bin/docker run --link etcd-amb-apache.service:etcd -v /var/run/docker.sock:/var/run/docker.sock --rm polvi/docker-register apache.service 80 apache-A

[X-Fleet]
X-ConditionMachineOf=etcd-amb-apache.service

Speichern und schließen. Hier ist eine Aufschlüsselung der bemerkenswerten Teile des Befehls + docker run +:

  • + - link etcd-amb-apache.service: etcd + verknüpft diesen Container mit dem einfachen Botschafter, der verwendet wird, um Apaches Verbindungsinformationen an + etcd + zu übergeben

  • Mit + -v /var/run/docker.sock: /var / run / docker.sock + kann dieser Container den dynamischen Port bestimmen, an den Apache über die Docker-API des Computers bindet, auf dem er ausgeführt wird.

  • + apache.service 80 apache-A + übergibt diese Argumente an den Container. Die ersten beiden Argumente geben den Namen und den Port des Docker-Containers an, in den gesucht werden soll, und das dritte Argument gibt den Namen des Schlüssels "+ etcd " an, in den geschrieben werden soll. Nach dem Start dieses Containers werden der dynamische Port und die IP-Adresse von " apache.service " in den Schlüssel " / services / apache-A / apache.service +" geschrieben.

+ X-ConditionMachineOf = etcd-amb-apache.service + weist die Flotte an, dies auf demselben Computer wie der einfache Botschaftercontainer zu planen, was wichtig ist, da sie mit einem Docker-Link verbunden sind, um dem Registrierungscontainer eine Möglichkeit zu bieten, zu finden ` + etcd + `.

etcd-amb-apache2.service

Die Einheit "+ etcd-amb-apache2.service +" wird auf Host B ausgeführt.

Erstellen Sie eine Servicedatei für unseren zweiten einfachen Ambassador-Container ("+ simple-amb "), mit der der dynamische Ambassador-Container auf " etcd " zugreifen kann. Öffnen Sie jetzt eine Datei mit dem Namen " etcd-amb-apache2.service +":

vi etcd-amb-apache2.service

Fügen Sie die folgenden Zeilen hinzu:

[Unit]
Description=Simple Apache ambassador 2

[Service]
ExecStartPre=-/usr/bin/docker kill %n
ExecStartPre=-/usr/bin/docker rm %n
ExecStart=/usr/bin/docker run --rm --name %n polvi/simple-amb 172.17.42.1:4001
ExecStop=/usr/bin/docker stop -t 3 %n

[X-Fleet]
X-Conflicts=apache.service

Speichern und schließen.

Dies ist so ziemlich die gleiche Servicedatei wie "+ etcd-amb-apache.service ", mit der Ausnahme, dass " X-Conflicts = apache.service " Flotte anweist, dies auf einem anderen Computer als dem Apache-Container zu planen Verknüpfen Sie den dynamischen Botschafter mit " etcd +".

apache-dyn-amb.service

Die Einheit "+ apache-dyn-amb.service +" wird auf Host B ausgeführt.

Erstellen Sie eine Servicedatei für unseren dynamischen Ambassador-Container ("+ dynamic-etd-amb "), mit der der dynamische Ambassador-Container auf " etcd " zugreifen kann. Öffnen Sie jetzt eine Datei mit dem Namen " apache-dyn-amd.service":

vi apache-dyn-amb.service

Fügen Sie die folgenden Zeilen hinzu:

[Unit]
Description=Dynamic ambassador for Apache
After=etcd-amb-apache2.service
BindsTo=etcd-amb-apache2.service

[Service]
EnvironmentFile=/etc/environment
ExecStartPre=-/usr/bin/docker kill %n
ExecStartPre=-/usr/bin/docker rm %n
ExecStartPre=/usr/bin/docker pull polvi/dynamic-etcd-amb
ExecStart=/usr/bin/docker run --link etcd-amb-apache2.service:etcd --rm --name %n -p ${COREOS_PRIVATE_IPV4}:80:80 polvi/dynamic-etcd-amb apache-A 80
ExecStop=/usr/bin/docker stop -t 3 %n

[X-Fleet]
X-ConditionMachineOf=etcd-amb-apache2.service

Speichern und schließen. Hier ist eine Aufschlüsselung der bemerkenswerten Teile des Befehls + docker run +:

  • + - link etcd-amb-apache2.service: etcd + verknüpft diesen Container mit dem zweiten einfachen Botschafter, der zum Abrufen der Apache-Verbindungsinformationen von + etcd + verwendet wird

  • + -p $ {COREOS_PRIVATE_IPV4}: 80: 80 + macht den Port 80 des Containers und der privaten Netzwerkschnittstelle des Computers verfügbar

  • + apache-A 80 + sind zwei Argumente, die angeben, dass Port 80-Verkehr (d. h. Port 80 auf der privaten Netzwerkschnittstelle) sollte an den Dienst weitergeleitet werden, der unter "+ etcd " als " apache-A +" registriert ist

+ X-ConditionMachineOf = etcd-amb-apache2.service + weist die Flotte an, dies auf demselben Computer wie der zweite einfache Ambassador-Container zu planen, was wichtig ist, da sie mit einer Docker-Verknüpfung verbunden sind, um dem dynamischen Ambassador-Container eine Möglichkeit zu bieten finde + etcd +.

haproxy.service

Die Einheit "+ haproxy.service +" wird auf Host B ausgeführt.

Erstellen Sie eine Servicedatei für unseren HAProxy-Container (+ haproxy +), die verwendet wird, um über den dynamischen Ambassador-Container eine Verbindung zum Apache-Container herzustellen. Öffnen Sie jetzt eine Datei mit dem Namen "+ haproxy.service +":

vi haproxy.service

Fügen Sie die folgenden Zeilen hinzu (ersetzen Sie Ihren Docker-Benutzernamen an beiden Stellen):

[Unit]
Description=HAProxy consumer

[Service]
EnvironmentFile=/etc/environment
ExecStartPre=-/usr/bin/docker kill %n
ExecStartPre=-/usr/bin/docker rm %n
ExecStartPre=/usr/bin/docker pull /haproxy
ExecStart=/usr/bin/docker run --name %n -p ${COREOS_PUBLIC_IPV4}:80:80 /haproxy
ExecStop=/usr/bin/docker stop -t 3 %n

[X-Fleet]
X-ConditionMachineOf=apache-dyn-amb.service

Speichern und schließen. Dies ist eine unkomplizierte Servicedatei, die HAProxy startet und den Port 80 auf der öffentlichen IP-Adresse des Host-Computers freigibt. Denken Sie daran, dass der Back-End-Server auf die private IP-Adresse des Host-Rechners an Port 80 konfiguriert wird, an dem der dynamische Botschafter zufällig auf Datenverkehr zum Proxy des Apache-Diensts wartet.

+ X-ConditionMachineOf = apache-dyn-amb.service + weist die Flotte an, dies auf demselben Computer wie der dynamische Ambassador-Container zu planen. Dies ist wichtig, da der dynamische Ambassador dem HAProxy-Container eine Route zum Apache-Container bereitstellt.

Mit Flotte bereitstellen

Nachdem wir alle erforderlichen Dateien für den Flottenservice haben, können wir endlich unser Ambassador-Setup bereitstellen. Führen Sie in dem Verzeichnis, das alle Ihre Servicedateien enthält, die folgenden Befehle aus:

fleetctl start apache.service
fleetctl start etcd-amb-apache.service
fleetctl start apache-docker-reg.service
fleetctl start etcd-amb-apache2.service
fleetctl start apache-dyn-amb.service
fleetctl start haproxy.service

Sie sollten Meldungen sehen, die besagen, dass jeder Dienst geladen ist. Führen Sie den folgenden Befehl aus, um den Status Ihrer Flotteneinheiten zu überprüfen:

fleetctl list-units

Sie sollten eine Ausgabe sehen, die der folgenden ähnelt:

UNIT                       MACHINE                      ACTIVE   SUB
apache-docker-reg.service  ceb3ead2.../10.132.233.107   active   running
apache-dyn-amb.service     3ce87ca7.../10.132.233.106   active   running
apache.service             ceb3ead2.../10.132.233.107   active   running
etcd-amb-apache.service    ceb3ead2.../10.132.233.107   active   running
etcd-amb-apache2.service   3ce87ca7.../10.132.233.106   active   running
haproxy.service            3ce87ca7.../10.132.233.106   active   running

Alle Statuen sollten "+ aktiv" und "+ laufend" sein. Zu beachten ist auch, dass sich die „Maschine A“ -Einheiten auf demselben Computer und die „Maschine B“ -Einheiten auf einem anderen Computer befinden sollten. Überprüfen Sie die IP-Adressen der einzelnen Einheiten, um dies zu bestätigen.

Testen Sie Ihr Setup

Stellen Sie sicher, dass HAProxy Apache erreichen kann

Da wir nicht angegeben haben, dass der HAProxy-Container auf einem bestimmten Computer ausgeführt werden soll, müssen wir herausfinden, wo er ausgeführt wird. Eine einfache Möglichkeit, dies zu tun, ist die Verwendung des Befehls + fleetctl ssh +:

fleetctl ssh haproxy.service

Dadurch werden Sie mit dem Computer verbunden, auf dem der Container "+ haproxy.service " ausgeführt wird. Jetzt können Sie die Datei " / etc / environment +" als Quelle verwenden, um die öffentliche IP-Adresse des CoreOS-Computers abzurufen, auf dem HAProxy ausgeführt wird:

. /etc/environment
echo $COREOS_PUBLIC_IPV4

Nehmen Sie die resultierende IP-Adresse und rufen Sie sie mit einem Webbrowser auf. Sie sehen folgendes Bild:

image: https://assets.digitalocean.com/articles/coreos_basic/web_page.png [Ausführen von Docker unter CoreOS]

Beachten Sie, dass Sie auf HAProxy zugreifen und HAProxy über den dynamischen Ambassador-Proxy auf Apache zugreift.

Jetzt können Sie Ihre aktuelle SSH-Sitzung beenden, um zu Ihrer ursprünglichen SSH-Sitzung zurückzukehren:

exit

Testen Sie das Failover

Nachdem Sie bestätigt haben, dass das Ambassador-Setup funktioniert, sehen wir uns an, was passiert, wenn der Provider-Dienst ("+ apache.service +") seine IP-Adresse und seinen Port ändert.

Verwenden Sie "+ fleetctl", um eine Verbindung zu dem Computer herzustellen, auf dem "+ apache.service" ausgeführt wird:

fleetctl ssh apache.service

Starten Sie nun den Rechner neu, auf dem Apache läuft:

sudo reboot

  • Hinweis: * Wenn auf dem Computer, mit dem Sie ursprünglich über SSH verbunden waren, "+ apache.service" ausgeführt wurde, wird die Verbindung getrennt. Wenn dies der Fall ist, senden Sie SSH einfach an einen anderen Computer im selben CoreOS-Cluster.

Warten Sie jetzt eine Minute und überprüfen Sie, welche Geräte laufen:

fleetctl list-units

Je nachdem, wie lange Sie gewartet haben, können Sie feststellen, dass sich die drei Einheiten auf "Host A" ("+ apache.service ", " etcd-amb-apache.service " und " apache-docker-reg.service +") beziehen ) neu starten oder aktiv sind. Schließlich sollten sie alle in den aktiven Zustand zurückkehren. Beachten Sie, dass sie jetzt auf einem anderen Computer als zuvor ausgeführt werden.

Kehren Sie nun zu Ihrem Webbrowser zurück, der eine Verbindung zu HAProxy hergestellt hat, und klicken Sie auf Aktualisieren. Sie sollten dieselbe Testseite wie zuvor sehen, um anzuzeigen, dass HAProxy weiterhin über den dynamischen Botschafter eine Verbindung zu Apache herstellen kann!

Fazit

Nachdem Sie Ihr eigenes Botschaftermuster erstellt haben, sollten Sie in der Lage sein, die in diesem Lernprogramm vorgestellten Konzepte an Ihre eigenen Dienste anzupassen. Dies ist eine einzigartige Möglichkeit, Ihre Consumer-Services zur Laufzeit zu konfigurieren, sodass Sie Ihre Back-End-Provider-Services problemlos zwischen Computern verschieben können. In einer realistischeren Konfiguration würden Sie den Apache-Dienst wahrscheinlich durch einen oder mehrere Anwendungscontainer ersetzen und HAProxy möglicherweise mit mehreren Back-End-Servern konfigurieren (oder einen völlig anderen Verbraucherdienst verwenden).

Related