Detailliertes Tutorial zum Erstellen eines ETCD-Clusters für Docker-Mikroservices

Detailliertes Tutorial zum Erstellen eines ETCD-Clusters für Docker-Mikroservices

etcd ist ein hochverfügbares Schlüssel-Wert-Speichersystem, das hauptsächlich für die gemeinsame Konfiguration und Diensterkennung verwendet wird. etcd wird von CoreOS entwickelt und gepflegt. Es ist von ZooKeeper und Doozer inspiriert. Es ist in Go geschrieben und handhabt die Protokollreplikation durch den Raft-Konsensalgorithmus, um starke Konsistenz sicherzustellen. Raft ist ein neuer Konsistenzalgorithmus von Stanford, der für die Protokollreplikation in verteilten Systemen geeignet ist. Raft erreicht Konsistenz durch Wahlen. In Raft kann jeder Knoten zum Leader werden. Das Container-Cluster-Verwaltungssystem Kubernetes von Google, die Open-Source-PaaS-Plattform Cloud Foundry und Fleet von CoreOS verwenden etcd in großem Umfang.

Funktionen von etcd

Einfach: Über curl zugängliche Benutzer-API (HTTP+JSON) Gut definierte, benutzerorientierte API (gRPC)

Sicherheit: Optionale SSL-Client-Zertifikatauthentifizierung

Schnell: 1000 Schreibvorgänge pro Sekunde pro Instanz

Zuverlässig: Verwenden Sie Raft, um Konsistenz sicherzustellen

Es gibt drei Hauptformen von etcd, die einen eigenen Hochverfügbarkeitscluster aufbauen

1) Statische Erkennung: Wissen Sie im Voraus, welche Knoten sich im Etcd-Cluster befinden, und geben Sie beim Start direkt die Adresse jedes Etcd-Knotens an. 2) Dynamische Etcd-Erkennung: Verwenden Sie den vorhandenen Etcd-Cluster als Dateninteraktionspunkt und implementieren Sie dann beim Erweitern des neuen Clusters den Diensterkennungsmechanismus über den vorhandenen Cluster. 3) Dynamische DNS-Erkennung: Erhalten Sie andere Knotenadressinformationen durch DNS-Abfrage

Die grundlegende Umgebung für diese Konstruktion

Zugrundeliegendes Betriebssystem: Centos7
Docker-Version: Docker-Version 18.06.1-ce
IP-Adresse:
Server A: 192.167.0.168
Server B: 192.167.0.170
Server C: 192.167.0.172
Laden Sie zunächst das neueste etcd-Image auf jeden Server herunter

# Docker-Pull quay.io/coreos/etcd

Aufgrund begrenzter Maschinenressourcen habe ich 3 Container auf einer Maschine konfiguriert und ein Subnetz auf der Maschine erstellt. Die drei Container befinden sich in einem Netzwerk.

# Docker-Netzwerk erstellen --subnet=192.167.0.0/16 etcdnet

Als Nächstes habe ich zwei Methoden zum Erstellen des Clusters verwendet: 1. Die drei Server nacheinander zum Cluster hinzufügen; 2. Die drei Server gleichzeitig zum Cluster hinzufügen. Die folgenden mit A gekennzeichneten Befehle werden auf Maschine A ausgeführt, und in ähnlicher Weise für B und C.

1. Fügen Sie dem Cluster nacheinander Server hinzu

A führt eine ETCD-Instanz mit dem Namen autumn-client0 auf Container/Server A aus. Beachten Sie, dass ihr Status neu ist und sich nur ihre eigene IP in „-initial-cluster“ befindet.

# Docker Run -d -p 2379: 2379 -P 2380: 2380 --net usw. P: //0.0.0.0: 2379 -initial-advertise-peer-urls http://192.167.0.168:2380 -Listen-peer-urls http:/0.0.0.0:2380 -initial-token-12.12.12.12.12. 68: 2380 "-Initial-Cluster-Staat Neu

Parameter Beschreibung

--data-dir gibt das Datenspeicherverzeichnis des Knotens an. Die Daten umfassen Knoten-ID, Cluster-ID, Cluster-Initialisierungskonfiguration und Snapshot-Dateien. Wenn --wal-dir nicht angegeben ist, werden auch WAL-Dateien gespeichert.
—wal-dir gibt das Speicherverzeichnis der Was-Dateien des Knotens an. Wenn dieser Parameter angegeben ist, werden die Wal-Dateien getrennt von anderen Datendateien gespeichert.
--name Knotenname --initial-advertise-peer-urls informiert den Cluster über andere Knoten-URLs.
— listen-peer-urls hört auf die URL für die Kommunikation mit anderen Knoten — advertise-client-urls informiert die Client-URL, die die Service-URL ist
— initial-cluster-token Cluster-ID
— alle Knoten im Initial-Cluster-Cluster

Beschreibung der Konfigurationsdatei, wie

# [Mitglied]
# Knotenname ETCD_NAME=node1
#Datenspeicherort ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
#ETCD_WAL_DIR=""
#ETCD_SNAPSHOT_COUNT="10000"
#ETCD_HEARTBEAT_INTERVAL="100"
#ETCD_ELECTION_TIMEOUT="1000"
#Hören Sie auf die Adressen anderer Etcd-Instanzen ETCD_LISTEN_PEER_URLS="http://0.0.0.0:2380"
# Clientadresse abhören ETCD_LISTEN_CLIENT_URLS="http://0.0.0.0:2379,http://0.0.0.0:4001"
#ETCD_MAX_SNAPSHOTS="5"
#ETCD_MAX_WALS="5"
#ETCD_CORS=""
#
#[Cluster]
# Andere Etcd-Instanzadressen benachrichtigen ETCD_INITIAL_ADVERTISE_PEER_URLS="http://node1:2380"
# wenn Sie einen anderen ETCD_NAME verwenden (z. B. Test), legen Sie den ETCD_INITIAL_CLUSTER-Wert für diesen Namen fest, d. h. „test=http://...“
# Initialisieren Sie die Knotenadressen im Cluster ETCD_INITIAL_CLUSTER="node1=http://node1:2380,node2=http://node2:2380,etcd2=http://etcd2:2380"
# Initialisiere den Clusterstatus, neu bedeutet das Erstellen eines neuen ETCD_INITIAL_CLUSTER_STATE="new"
# Cluster-Token initialisieren
ETCD_INITIAL_CLUSTER_TOKEN="mritd-etcd-cluster"
# Clientadresse benachrichtigen ETCD_ADVERTISE_CLIENT_URLS=http://node1:2379,http://node1:4001

A Fügen Sie im etcd-Dienst von Server A einen neuen Knoten hinzu, indem Sie die API aufrufen: 192.167.0.170

# curl http://127.0.0.1:2379/v2/members -XPOST -H "Inhaltstyp: application/json" -d '{"peerURLs": ["http://192.167.0.170:2480"]}'

B führt eine ETCD-Instanz mit dem Namen autumn-client1 auf Container/Server B aus. Beachten Sie, dass ihr Status „vorhanden“ ist und die vorherige IP und ihre eigene IP sich in „-initial-cluster“ befinden.

# Docker Run -d -p 2479: 2479 -P 2480: 2480 -Name etcd1 quay.io/coreos/etcd/usr/local/tecd -NAME AUTUMEN -CLIENS1 -ADVERTISCHE -CLIENS -URLS HTTP :/192.167.0.170:2379 -urls -CLIENT -CLIALILS -H -0.0.0:2379 -CLIENT -CLIENT -CLIABT -CLIABTE -CLIABTE -CLIEILICE. Initial-Advertise-Peer-urls http://192.167.0.170:2380 -Listen-peer-urls http://0.0.0:2480 -initial-cluster-token-cluster -initial-cluster-client0 = http: //192.167.0.0.0.0.0.0.0.0.0.080.080, 2380, //192.167.0.0.0.080.080. : //192.167.0.170: 2480 "-Initial-Cluster-Status vorhanden

A Fügen Sie im etcd-Dienst von Server A einen neuen Knoten hinzu, indem Sie die API aufrufen: 192.168.7.172

# curl http://127.0.0.1:2379/v2/members -XPOST -H "Inhaltstyp: application/json" -d '{"peerURLs": ["http://192.167.0.172:2580"]}'

C Führen Sie auf Server C eine ETCD-Instanz mit dem Namen autumn-client2 aus. Beachten Sie, dass der Status „existierend“ lautet. „-initial-cluster“ enthält die IP-Adressen aller vorherigen Knoten und seine eigene IP-Adresse.

# Docker Run -d -p 2579: 2579 -P 2580: 2580-Name usw. Quay.io/coreos/etcd -name Herbst-Client2 -Antverti-client-urls S http://192.167.0.172:2580 -Listen-peer-urls http://0.0.0.0:2380 -initial-cluster-teka-tecd-cluster -initial-cluster "Herumn-Client0 = http: //192.167.0.168: 2380, AUTUMN. 170: 2480, Herbst-Client2 = http: //192.167.0.172: 2580 "-Initial-Cluster-Status vorhanden

2. Server zum Cluster hinzufügen

(„-initial-cluster“ enthält die IP-Adressen aller Knoten und der Status ist neu)

Ausführen auf A

# docker run -d -p 2379:2379 -p 2380:2380 --restart=always --net etcdnet --ip 192.167.0.168 --name etcd0 quay.io/coreos/etcd /usr/local/bin/etcd --name autumn-client0 -advertise-client-urls http://192.167.0.168:2379 -listen-client-urls http://0.0.0.0:2379 -initial-advertise-peer-urls http://192.167.0.168:2380 -listen-peer-urls http://0.0.0.0:2380 -initial-cluster-token etcd-cluster -initial-cluster autumn-client0=http://192.167.0.168:2380,autumn-client1=http://192.167.0.170:2480,autumn-client2=http://192.167.0.172:2580 -initial-cluster-state new

Ausführen auf B

# docker run -d -p 2479:2479 -p 2480:2480 --restart=always --net etcdnet --ip 192.167.0.170 --name etcd1 quay.io/coreos/etcd /usr/local/bin/etcd --name autumn-client1 -advertise-client-urls http://192.167.0.170:2479 -listen-client-urls http://0.0.0.0:2479 -initial-advertise-peer-urls http://192.167.0.170:2480 -listen-peer-urls http://0.0.0.0:2480 -initial-cluster-token etcd-cluster -initial-cluster autumn-client0=http://192.167.0.168:2380,autumn-client1=http://192.167.0.170:2480,autumn-client2=http://192.167.0.172:2580 -initial-cluster-state new

Ausführen auf C

# Docker Run -d -p 2579: 2579 -p 2580: 2580 --Restart = immer --NET usw. URLS http://0.0.0.0:2579 -initial-advertise-peer-urls http://192.167.0.172:2580 -listen-peer-urls http://0.0.0.0:2580 -initial-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-Cluster-CLUSTIAL 0.-NITIAL0/INITIAL 0 7.0.168: 2380, Herbst-Client1 = http: //192.167.0.170: 2480, Herbst-Client2 = http: //192.167.0.172: 2580 -Initial-Cluster-State New

Cluster-Verifizierung. Die mit den beiden Methoden erstellten Cluster können mit den folgenden Methoden überprüft werden:

1. Überprüfen Sie die Clustermitglieder. Überprüfen Sie die Mitglieder auf jedem Computer im Cluster. Die Ergebnisse sollten gleich sein.

[root@localhost ~]# curl -L http://127.0.0.1:2379/v2/members
{"members":[{"id":"1a661f2b9997ba39","name":"autumn-client0","peerURLs":["http://192.167.0.168:2380"],"clientURLs":["http://192.168.7.168:2379"]},{"id":"4932c8ea462e079c","name":"autumn-client2","peerURLs":["http://192.167.0.172:2580"],"clientURLs":["http://192.167.0.172:2579"]},{"id":"c1dbdde07e61741e","name":"autumn-client1","peerURLs":["http://192.167.0.170:2480"],"clientURLs":[http://192.167.0.170:2479]}]}

2. Fügen Sie Daten auf einem Computer hinzu und überprüfen Sie die Daten auf anderen Computern. Die Ergebnisse sollten dieselben sein. Führen Sie dies auf A aus.

[root@localhost ~]# curl -L http://127.0.0.1:2379/v2/keys/message -XPUT -d value="Hallo Herbst"
{"action":"set","node":{"key":"/message","value":"Hallo Herbst","modifiedIndex":13,"createdIndex":13},"prevNode":{"key":"/message","value":"Hallo Welt1","modifiedIndex":11,"createdIndex":11}}

Ausführen auf B und C

[root@localhost ~]# curl -L http://127.0.0.1:2379/v2/keys/message
{"action":"get","node":{"key":"/message","value":"Hallo Herbst","modifiedIndex":13,"createdIndex":13}}

etcd API-Schnittstelle

  Grundlegende Betriebs-API: https://github.com/coreos/etcd/blob/6acb3d67fbe131b3b2d5d010e00ec80182be4628/Documentation/v2/api.md
 
  API für Clusterkonfiguration: https://github.com/coreos/etcd/blob/6acb3d67fbe131b3b2d5d010e00ec80182be4628/Documentation/v2/members_api.md
 
  Authentifizierungs-API: https://github.com/coreos/etcd/blob/6acb3d67fbe131b3b2d5d010e00ec80182be4628/Documentation/v2/auth_api.md
 
  Konfigurationselemente: https://github.com/coreos/etcd/blob/master/Documentation/op-guide/configuration.md
  
  https://coreos.com/etcd/docs/latest/runtime-configuration.html
  https://coreos.com/etcd/docs/latest/clustering.html
  https://coreos.com/etcd/docs/latest/runtime-configuration.html
  https://coreos.com/etcd/docs/latest/
  https://coreos.com/etcd/docs/latest/admin_guide.html#disaster-recovery
  Es verwendet eine standardmäßige RESTful-Schnittstelle und unterstützt sowohl HTTP- als auch HTTPS-Protokolle.

Dienstregistrierung und -erkennung


Herkömmliche Serviceaufrufe werden im Allgemeinen durch Lesen der IP-Adresse über die Konfigurationsdatei getätigt. Hier gibt es viele Einschränkungen, wie z. B. mangelnde Flexibilität, Unfähigkeit, den Status des Dienstes wahrzunehmen, und komplexe Lastverteilung für Serviceaufrufe. Nach der Einführung von etcd wird das Problem erheblich vereinfacht. Hier sind einige Schritte

Nachdem der Dienst gestartet wurde, registriert er sich bei etcd, meldet seinen Abhörport, den aktuellen Gewichtungsfaktor und andere Informationen und legt den TTL-Wert für diese Informationen fest.

Der Dienst meldet regelmäßig Informationen wie Gewichtungsfaktoren innerhalb des TTL-Zeitraums.

Wenn der Client einen Dienst aufruft, erhält er Informationen von etcd, führt den Aufruf durch und überwacht, ob sich der Dienst ändert (implementiert durch die Watch-Methode).
Wenn ein neuer Dienst hinzugefügt wird, überwacht die Überwachungsmethode die Änderung und fügt den Dienst der Ersatzliste hinzu. Wenn der Dienst auflegt, wird die TTL ungültig. Der Client erkennt die Änderung und wirft den Dienst aus der Anrufliste, wodurch eine dynamische Erweiterung des Dienstes realisiert wird.

Andererseits verwendet die Clientseite den aus jeder Änderung erhaltenen Gewichtungsfaktor, um eine gewichtete Aufrufstrategie auf der Clientseite zu implementieren und so den Lastausgleich des Backend-Dienstes sicherzustellen.

Oben finden Sie den detaillierten Inhalt des Tutorials zum Einrichten des ETCD-Clusters von Docker-Mikroservices. Weitere Informationen zum Einrichten des ETCD-Clusters von Docker-Mikroservices finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!

Das könnte Sie auch interessieren:
  • Erfahren Sie in zehn Minuten, wie Sie Microservices mit Docker bereitstellen
  • Ein Beispiel für die Verwendung von Dapr zur Vereinfachung von Microservices von Grund auf

<<:  Funktionen in TypeScript

>>:  So implementieren Sie abgerundete Ecken mit CSS3 unter Verwendung von JS

Artikel empfehlen

So installieren Sie Solr 8.6.2 in Docker und konfigurieren den chinesischen Wortsegmentierer

1. Umgebungsversion Docker-Version 19.03.12 cento...

Detaillierte Erklärung der Dreieckszeichnung und clevere Anwendungsbeispiele in CSS

führen Einige gängige Dreiecke auf Webseiten könn...

Detaillierte Erläuterung der Verwendung des DockerHub-Image-Repository

Bisher wurden die von uns verwendeten Images alle...

Einführung in den Befehl „Linux-Typversion-Speicherfestplattenabfrage“

1. Lassen Sie uns zunächst eine allgemeine Einfüh...

So führen Sie eine reibungslose if-Beurteilung in js durch

Inhaltsverzeichnis Vorwort Code-Implementierung I...

Miniprogramm zur Implementierung der Token-Generierung und -Verifizierung

Inhaltsverzeichnis Verfahren Demo Mini-Programm B...

Vier Möglichkeiten, CSS und HTML zu kombinieren

(1) Jedes HTML-Tag hat ein Attribut style, das CS...

Detaillierte Erläuterung der Architektur und Funktionen von InnoDB (Zusammenfassung der Lesehinweise zur InnoDB-Speicher-Engine)

Hintergrund-Threads •Hauptthread Der Kern-Hinterg...

Reiner CSS3-Code zur Implementierung einer laufenden Uhr

Wirkung der OperationCode-Implementierung html &l...

Vue verwendet ECharts zur Implementierung von Liniendiagrammen und Kreisdiagrammen

Bei der Entwicklung eines Backend-Verwaltungsproj...

Detaillierte Erklärung des durch einen Schrägstrich / verursachten Mordes in Nginx proxy_pass

Hintergrund Ein Nginx-Servermodul muss als Proxy ...

Detaillierte Erklärung zur Installation der PHP-Curl-Erweiterung unter Linux

Dieser Artikel beschreibt, wie man die PHP-Curl-E...

Detaillierte Erklärung des Server-ID-Beispiels bei der MySQL-Master-Slave-Synchronisierung

Vorwort Wenn wir einen MySQL-Cluster erstellen, m...

Einführung in die Verwendung von CSS3-Filterattributen

1. Einleitung Beim Schreiben von Animationseffekt...

Vergleich der Effizienz zwischen Einzeltabellenabfrage und Mehrtabellen-Joinabfrage in der MySql-Datenbank

Während dieser Zeit stieß ich bei der Arbeit an e...