Bereitstellung eines Multicluster Service Mesh auf GKE mit Anthos

Anthos Service Mesh ist eine Suite von Tools, mit denen Sie ein zuverlässiges Service Mesh vor Ort oder in der Google Cloud überwachen und verwalten können. Ich habe es kürzlich als Alternative zu einer nicht verwalteten Istio-Installation getestet und war überrascht, wie viel einfacher Anthos die Bereitstellung eines Service Mesh auf Kubernetes-Clustern macht. In diesem Artikel erkläre ich Schritt für Schritt, wie ich mit Anthos Service Mesh ein Service Mesh mit mehreren Clustern und Regionen bereitgestellt habe. Während meines Proof of Concept habe ich die Dokumentation unter https://cloud.google.com/service-mesh/docs/install gelesen, aber keiner der Leitfäden deckte genau meine Anforderungen ab, die da lauten:

• Multicluster, multiregionales Dienstnetz
• Von Google verwaltete Istio-Kontrollebene (für zusätzliche Ausfallsicherheit und um meinen Aufwand zu minimieren)
• Von Google verwaltete CA-Zertifikate für Istio mTLS

Stellen Sie die GKE-Cluster bereit

Setzen Sie die beiden GKE-Cluster ein. Ich nannte sie und (leichter zu merken) und setzte sie in zwei verschiedenen Regionen ein ( und ). Da Anthos Service Mesh erfordert, dass die Knoten über mindestens 4 vCPUs verfügen (und ein paar weitere Anforderungen, siehe die vollständige Liste unter:) https://cloud.google.com/service-mesh/docs/scripted-install/asm-onboarding), verwenden Sie mindestens die e2-standard-4 Maschinen.

Speichern Sie zur Vorbereitung die Google Cloud Project ID in einer Umgebungsvariablen, damit die übrigen Befehle direkt kopiert und eingefügt werden können.

export PROJECT_ID=$(gcloud info --format='value(config.project)')

Um die Cluster zu verteilen, führen Sie dann aus:

gcloud container clusters create asm-a 
  --zone us-west2-a 
  --machine-type "e2-standard-4" 
  --disk-size "100" 
  --num-nodes "2" 
  --workload-pool=${PROJECT_ID}.svc.id.goog --async

gcloud container clusters create asm-b 
  --zone us-central1-a 
  --machine-type "e2-standard-4" 
  --disk-size "100" 
  --num-nodes "2" 
  --workload-pool=${PROJECT_ID}.svc.id.goog --async

Die Befehle ermöglichen auch die Workload-Identität, über die Sie mehr erfahren können unter: https://cloud.google.com/kubernetes-engine/docs/how-to/workload-identity.

Holen Sie die Zugangsdaten zu den Clustern

Sobald die Cluster erstellt sind, holen Sie sich die Anmeldeinformationen, die Sie benötigen, um sich über kubectl mit ihnen zu verbinden. Verwenden Sie die folgenden Befehle:

gcloud container clusters get-credentials asm-a 
  --zone us-west2-a --project ${PROJECT_ID}
gcloud container clusters get-credentials asm-b 
  --zone us-central1-a --project ${PROJECT_ID}

Einfacher Wechsel des kubectl-Kontexts mit kubectx

kubectx erleichtert den Wechsel zwischen Clustern und Namespaces in kubectl (auch als Kontext bekannt), indem es einen einprägsamen Alias für sie erstellt (in diesem Fall asma und asmb). Erfahren Sie mehr über dieses Tool unter: kubectx + kubens: Leistungsstarke Werkzeuge für kubectl.

kubectx asma=gke_${PROJECT_ID}_us-west2-a_asm-a
kubectx asmb=gke_${PROJECT_ID}_us-central1-a_asm-b

Legen Sie die Mesh-ID-Beschriftung für die Cluster fest

Legen Sie vor der Installation von Anthos Service Mesh das Label mesh_id auf den Clustern fest, das von Anthos benötigt wird, um zu erkennen, welche Cluster zu welchem Mesh gehören. Die mesh_id hat immer das Format proj-<your-project-number>, und die Projektnummer für das Projekt finden Sie durch Ausführen von:

gcloud projects list

Verwenden Sie diese Befehle, um das Label mesh_id auf beiden Clustern zu erstellen (ersetzen Sie <your-project-number> durch die mit dem vorherigen Befehl gefundene Projektnummer:

export MESH_ID="proj-<your-project-number>"
gcloud container clusters update asm-a 
  --region us-west2-a 
  --project=${PROJECT_ID} 
  --update-labels=mesh_id=${MESH_ID}

gcloud container clusters update asm-b 
  --region us-central1-a 
  --project=${PROJECT_ID} 
  --update-labels=mesh_id=${MESH_ID}

StackDriver einschalten

Aktivieren Sie StackDriver auf den Clustern, damit Sie die Protokolle sehen können, falls bei der Einrichtung etwas schief geht!

gcloud container clusters update asm-a  
  --region us-west2-a 
  --project=${PROJECT_ID} 
  --enable-stackdriver-kubernetes

gcloud container clusters update asm-b 
  --region us-central1-a 
  --project=${PROJECT_ID} 
  --enable-stackdriver-kubernetes

Erstellen Sie Firewall-Regeln für die regionsübergreifende Kommunikation

Die Cluster befinden sich in verschiedenen Regionen, daher muss eine neue Firewall-Regel erstellt werden, um die Kommunikation zwischen ihnen und ihren Pods zu ermöglichen. Bash-Raserei im Anmarsch!

ASMA_POD_CIDR=$(gcloud container clusters describe asm-a 
  --zone us-west2-a --format=json | jq -r '.clusterIpv4Cidr')
ASMB_POD_CIDR=$(gcloud container clusters describe asm-b 
  --zone us-central1-a --format=json | jq -r '.clusterIpv4Cidr')
ASMA_PRIMARY_CIDR=$(gcloud compute networks subnets describe default 
  --region=us-west2 --format=json | jq -r '.ipCidrRange')
ASMB_PRIMARY_CIDR=$(gcloud compute networks subnets describe default 
  --region=us-central1 --format=json | jq -r '.ipCidrRange')
ALL_CLUSTER_CIDRS=$ASMA_POD_CIDR,$ASMB_POD_CIDR,$ASMA_PRIMARY_CIDR,$ASMB_PRIMARY_CIDR

gcloud compute firewall-rules create asm-multicluster-rule 
    --allow=tcp,udp,icmp,esp,ah,sctp 
    --direction=INGRESS 
    --priority=900 
    --source-ranges="${ALL_CLUSTER_CIDRS}" 
    --target-tags="${ALL_CLUSTER_NETTAGS}" --quiet

Anthos Service Mesh installieren

Installieren Sie zunächst die erforderlichen lokalen Tools, wie hier erklärt: Installation der erforderlichen Tools.

Das Tool install_asm wird Anthos Service Mesh auf den Clustern installieren. Übergeben Sie diese Optionen, um die anfänglichen Anforderungen zu erfüllen:

• --managed: Von Google verwaltete Istio-Kontrollebene
• --ca mesh_ca: Von Google verwaltete CA-Zertifikate für Istio mTLS
• --enable_registration: registriert die Cluster automatisch bei Anthos (dies kann später auch manuell erfolgen)
• --enable_allAlle Google APIs, die für die Installation benötigt werden, werden automatisch vom Skript aktiviert.

./install_asm --project_id ${PROJECT_ID} --cluster_name asm-a 
  --cluster_location us-west2-a 
  --mode install --managed 
  --ca mesh_ca 
  --output_dir asma 
  --enable_registration --enable_all

./install_asm --project_id ${PROJECT_ID} --cluster_name asm-b 
  --cluster_location us-central1-a 
  --mode install 
  --managed 
  --ca mesh_ca 
  --output_dir asmb 
  --enable_registration --enable_all

Konfigurieren Sie die Endpunktsuche zwischen Clustern

Die Endpunktsuche ermöglicht die Kommunikation zwischen den Clustern, z. B. die Erkennung von Service-Endpunkten zwischen den Clustern.

Installieren Sie die erforderlichen lokalen Tools wie hier beschrieben: Download von istioctl, führen Sie dann die folgenden Befehle aus:

istioctl x create-remote-secret 
  --context=asma --name=asm-a| 
kubectl apply -f - --context=asmb

istioctl x create-remote-secret 
  --context=asmb --name=asm-b| 
kubectl apply -f - --context=asma

Testen des Dienstnetzes

Anthos Service Mesh ist jetzt bereit! Lassen Sie uns eine Beispielanwendung einsetzen, um den clusterübergreifenden Datenverkehr und Failover zu überprüfen.

Erstellen Sie den Namespace für die Hello World-Anwendung

Erstellen Sie einen neuen Namespace auf beiden Clustern und aktivieren Sie die automatische Istio Sidecar Injection für beide. Da die Istio-Kontrollebene von Google verwaltet wird, wird das Label istio-injection- istio.io/rev= auf asm-managed gesetzt.

kubectl create --context=asma namespace sample

kubectl label --context=asma namespace sample 
  istio-injection- istio.io/rev=asm-managed --overwrite

kubectl create --context=asmb namespace sample

kubectl label --context=asmb namespace sample istio-injection- 
  istio.io/rev=asm-managed --overwrite

Erstellen Sie den Dienst Hello World

Stellen Sie die Dienste für die Anwendung Hello World auf beiden Clustern mit bereit:

kubectl create --context=asma -f https://raw.githubusercontent.com/istio/istio/1.9.5/samples/helloworld/helloworld.yaml -l service=helloworld -n sample

kubectl create --context=asmb -f https://raw.githubusercontent.com/istio/istio/1.9.5/samples/helloworld/helloworld.yaml -l service=helloworld -n sample

Erstellen Sie die Bereitstellung von Hello World

Setzen Sie die Beispielanwendung Hello World ein, die einen Endpunkt bereitstellt, der die Versionsnummer der Anwendung (die Versionsnummer ist in den beiden Clustern unterschiedlich) und eine dazugehörige Hello World Nachricht zurückgibt.

kubectl create --context=asma -f https://raw.githubusercontent.com/istio/istio/1.9.5/samples/helloworld/helloworld.yaml -l version=v1 -n sample

kubectl create --context=asmb -f https://raw.githubusercontent.com/istio/istio/1.9.5/samples/helloworld/helloworld.yaml -l version=v2 -n sample

Einsetzen des Sleep Pods

Die Anwendung Sleep simuliert eine Ausfallzeit. Lassen Sie uns damit die Ausfallsicherheit des Dienstnetzes testen! Um die Sleep-Anwendung einzusetzen, verwenden Sie:

kubectl apply --context=asma -f https://raw.githubusercontent.com/istio/istio/1.9.5/samples/sleep/sleep.yaml -n sample

kubectl apply --context=asmb -f https://raw.githubusercontent.com/istio/istio/1.9.5/samples/sleep/sleep.yaml -n sample

Überprüfen Sie den clusterübergreifenden Verkehr

Um zu überprüfen, ob der clusterübergreifende Lastausgleich wie erwartet funktioniert (sprich: Kann das Dienstnetz regionale Ausfälle tatsächlich überstehen?), rufen Sie den Dienst HelloWorld mehrmals mit dem Sleep-Pod auf. Um sicherzustellen, dass der Lastausgleich ordnungsgemäß funktioniert, rufen Sie den Dienst HelloWorld von allen Clustern in Ihrem Einsatz aus auf.

kubectl exec --context=asma -n sample -c sleep "$(kubectl get pod --context=asma -n sample -l app=sleep -o jsonpath='{.items[0].metadata.name}')" -- curl -sS helloworld.sample:5000/hello

kubectl exec --context=asmb -n sample -c sleep "$(kubectl get pod --context=asmb -n sample -l app=sleep -o jsonpath='{.items[0].metadata.name}')" -- curl -sS helloworld.sample:5000/hello

Wiederholen Sie diese Anfrage mehrmals und überprüfen Sie, ob die Version HelloWorld zwischen v1 und v2 wechseln sollte. Das bedeutet, dass die Anfrage an den gesunden Cluster weitergeleitet wird, wenn der andere Cluster nicht antwortet!

Zusammenfassung

In diesem Artikel habe ich erklärt, wie ich Anthos Service Mesh auf zwei GKE-Clustern in verschiedenen Regionen mit von Google verwalteter Istio-Kontrollebene und CA-Zertifikaten eingesetzt habe. Mit Anthos Service Mesh ist es ganz einfach, ein Service Mesh mit mehreren Clustern einzurichten, da der größte Teil der Komplexität von Istio jetzt von Google verwaltet wird.

Credits: Kopfzeilenbild von Luca Cavallin auf nylavak.com