Anthos Service Mesh und Traffic Director heißen jetzt Cloud Service Mesh. Weitere Informationen finden Sie in der Cloud Service Mesh-Übersicht.

Multi-Cloud- oder Hybrid-Mesh einrichten

Auf dieser Seite wird erläutert, wie Sie ein Multi-Cloud- oder Hybrid-Mesh für die folgenden Plattformen einrichten:

Hybrid: GKE in Google Cloud und GKE auf VMware (Vorabversion)
Hybrid: GKE in Google Cloud und GKE on Bare Metal (Vorabversion)
Multi-Cloud: GKE in Google Cloud und Amazon EKS (Vorschau)

Hinweis zur Plattform: Für den Befehl asmcli create-mesh, mit dem Sie die Endpunkterkennung aktivieren, müssen alle Cluster im Mesh-Netzwerk eine der Kombinationen aus Multi-Cloud/Hybridplattform aus der obigen Liste sein. Andere Kombinationen von Multi-Cloud- oder Hybrid-Mesh-Netzwerke auf anderen Plattformen werden nicht unterstützt. Managed Anthos Service Mesh wird in Multi-Cloud- oder Hybrid-Mesh-Netzwerken nicht unterstützt.

Mit dieser Anleitung richten Sie zwei Cluster ein. Sie können diesen Prozess jedoch erweitern, um eine beliebige Anzahl von Clustern in Ihr Mesh-Netzwerk einzubinden.

Vorbereitung

Alle Cluster müssen im selben Flotten-Hostprojekt registriert sein.
Alle GKE-Cluster müssen sich in einer freigegebenen VPC-Konfiguration im selben Netzwerk befinden.
Die Adresse des Kubernetes-Steuerungsebenen und die Gateway-Adresse des Clusters müssen von jedem Cluster im Mesh-Netzwerk aus erreichbar sein. Das Google Cloud-Projekt, in dem sich GKE-Cluster befinden, sollte externe Load-Balancing-Typen erstellen dürfen. Wir empfehlen, autorisierte Netzwerke und VPC-Firewallregeln zu verwenden, um den Zugriff einzuschränken.
Private Cluster, einschließlich privater GKE-Cluster, werden nicht unterstützt. Wenn Sie lokale Cluster wie GKE on VMware und GKE on Bare Metal verwenden, müssen die Adresse der Kubernetes-Steuerungsebene und die Gateway-Adresse über Pods in GKE-Clustern erreichbar sein. Wir empfehlen die Verwendung von CloudVPN, um das Subnetz des GKE-Clusters mit dem Netzwerk des lokalen Clusters zu verbinden.
Wenn Sie die Istio-Zertifizierungsstelle nutzen, verwenden Sie für alle Cluster dasselbe benutzerdefinierte Root-Zertifikat.

Hinweise

In dieser Anleitung wird davon ausgegangen, dass Sie Anthos Service Mesh mit dem asmcli-Tool installiert haben. Sie benötigen asmcli und das Konfigurationspaket, das von asmcli in das Verzeichnis heruntergeladen wird, das Sie bei der Ausführung von in asmcli install angegeben haben. Weitere Informationen finden Sie unter Abhängige Tools installieren und Cluster validieren:

Sie benötigen Zugriff auf die kubeconfig-Dateien für alle Cluster, die Sie im Mesh-Netzwerk einrichten. Zum Erstellen einer neuen kubeconfig-Datei für den Cluster können Sie im GKE-Cluster KUBECONFIG-Umgebung mit dem vollständigen Dateipfad als Wert in Ihrem Terminal exportieren und den kubeconfig-Eintrag generieren.

Umgebungsvariablen und Platzhalter einrichten

Sie benötigen die folgenden Umgebungsvariablen, wenn Sie das east-west-Gateway installieren.

Erstellen Sie Umgebungsvariablen für die Netzwerknamen:

Für GKE-Cluster wird standardmäßig der Name des Clusternetzwerks verwendet:
```
export NETWORK_1="PROJECT_ID-CLUSTER_NETWORK"
``````
```
Andere Cluster verwenden default:
```
export NETWORK_2="default"
``````
```

Wenn Sie Anthos Service Mesh auf anderen Clustern mit unterschiedlichen Werten für --network_id installiert haben, sollten Sie dieselben Werte an NETWORK_2 übergeben.

east-west-Gateway installieren

Installieren Sie ein Gateway in CLUSTER_1 (Ihr GKE-Cluster), das Ost-West-Traffic an CLUSTER_2 (Ihren Multi-Cloud- oder lokalen Cluster) ermöglicht:
```
asm/istio/expansion/gen-eastwest-gateway.sh \
    --network ${NETWORK_1}  \
    --revision asm-1233-2 | \
    ./istioctl --kubeconfig=PATH_TO_KUBECONFIG_1 install -y -f -
```
Beachten Sie, dass dieses Gateway standardmäßig öffentlich im Internet öffentlich ist. Für Produktionssysteme sind möglicherweise zusätzliche Zugriffseinschränkungen erforderlich, z. B. Firewallregeln, um externe Angriffe zu verhindern.

Installieren Sie in CLUSTER_2 ein Gateway für east-west-Traffic für CLUSTER_1.

asm/istio/expansion/gen-eastwest-gateway.sh \
    --network ${NETWORK_2} \
    --revision asm-1233-2 | \
    ./istioctl --kubeconfig=PATH_TO_KUBECONFIG_2 install -y -f -

Dienste freigeben

Da sich die Cluster in separaten Netzwerken befinden, müssen Sie alle Dienste (\*.local) auf dem east-west-Gateway in beiden Clustern verfügbar machen. Während dieses Gateway öffentlich im Internet verfügbar ist, können Dienste nur mit Diensten mit einem vertrauenswürdigen mTLS-Zertifikat und einer Arbeitslast-ID aufgerufen werden, genauso wie sie sich im selben Netzwerk befinden.

Dienste über das east-west-Gateway für jeden Cluster freigeben

    kubectl --kubeconfig=PATH_TO_KUBECONFIG_1 apply -n istio-system -f \
        asm/istio/expansion/expose-services.yaml
    kubectl --kubeconfig=PATH_TO_KUBECONFIG_2 apply -n istio-system -f \
        asm/istio/expansion/expose-services.yaml

Endpunkterkennung aktivieren

Führen Sie den Befehl asmcli create-mesh aus, um die Endpunkterkennung zu aktivieren. In diesem Beispiel werden nur zwei Cluster gezeigt. Sie können aber den Befehl ausführen, um die Endpunkterkennung für zusätzliche Cluster zu aktivieren, wobei das GKE Hub-Dienstlimit gilt.

  ./asmcli create-mesh \
      FLEET_PROJECT_ID \
      PATH_TO_KUBECONFIG_1 \
      PATH_TO_KUBECONFIG_2

Multicluster-Konnektivität prüfen

In diesem Abschnitt wird erläutert, wie Sie die Beispieldienste HelloWorld und Sleep in Ihrer Multi-Cluster-Umgebung bereitstellen, um zu überprüfen, ob das clusterübergreifende Load-Balancing funktioniert.

Sidecar-Injektion aktivieren

Suchen Sie den Wert des Überarbeitungslabels, den Sie in späteren Schritten verwenden.

Ermitteln Sie mit folgendem Befehl das Überarbeitungslabel, das Sie in späteren Schritten verwenden werden.

kubectl -n istio-system get pods -l app=istiod --show-labels

Die Ausgabe sieht dann ungefähr so aus:

NAME                                READY   STATUS    RESTARTS   AGE   LABELS
istiod-asm-173-3-5788d57586-bljj4   1/1     Running   0          23h   app=istiod,istio.io/rev=asm-173-3,istio=istiod,pod-template-hash=5788d57586
istiod-asm-173-3-5788d57586-vsklm   1/1     Running   1          23h   app=istiod,istio.io/rev=asm-173-3,istio=istiod,pod-template-hash=5788d57586

Notieren Sie sich den Wert des Überarbeitungslabels istiod aus der Ausgabe in der Spalte LABELS, das auf das Präfix istio.io/rev= folgt. In diesem Beispiel ist der Wert asm-173-3. Verwenden Sie den Überarbeitungswert in den Schritten im nächsten Abschnitt.

HelloWorld-Dienst installieren

Erstellen Sie den Beispiel-Namespace und die Dienstdefinition in jedem Cluster. Ersetzen Sie im folgenden Befehl REVISION durch das Überarbeitungslabel istiod, das Sie im vorherigen Schritt notiert haben.
```
for CTX in ${CTX_1} ${CTX_2}
do
    kubectl create --context=${CTX} namespace sample
    kubectl label --context=${CTX} namespace sample \
        istio-injection- istio.io/rev=REVISION --overwrite
done
```
Dabei ist REVISION das Versionslabel istiod, das Sie zuvor notiert haben.

Die Ausgabe sieht so aus:
```
label "istio-injection" not found.
namespace/sample labeled
```
Sie können label "istio-injection" not found. ignorieren.

Erstellen Sie in beiden Clustern den HelloWorld-Dienst:

kubectl create --context=${CTX_1} \
    -f ${SAMPLES_DIR}/samples/helloworld/helloworld.yaml \
    -l service=helloworld -n sample

kubectl create --context=${CTX_2} \
    -f ${SAMPLES_DIR}/samples/helloworld/helloworld.yaml \
    -l service=helloworld -n sample

HelloWorld v1 und v2 in jedem Cluster bereitstellen

Stellen Sie HelloWorld v1 in CLUSTER_1 und v2 in CLUSTER_2 bereit. Das erleichtert später die Prüfung des clusterübergreifenden Load-Balancings.

kubectl create --context=${CTX_1} \
  -f ${SAMPLES_DIR}/samples/helloworld/helloworld.yaml \
  -l version=v1 -n sample

kubectl create --context=${CTX_2} \
  -f ${SAMPLES_DIR}/samples/helloworld/helloworld.yaml \
  -l version=v2 -n sample

Prüfen Sie mit den folgenden Befehlen, ob HelloWorld v1 und v2 ausgeführt werden. Prüfen Sie, ob die Ausgabe in etwa so aussieht:

kubectl get pod --context=${CTX_1} -n sample

NAME                            READY     STATUS    RESTARTS   AGE
helloworld-v1-86f77cd7bd-cpxhv  2/2       Running   0          40s

kubectl get pod --context=${CTX_2} -n sample

NAME                            READY     STATUS    RESTARTS   AGE
helloworld-v2-758dd55874-6x4t8  2/2       Running   0          40s

Sleep-Dienst bereitstellen

Stellen Sie den Sleep-Dienst in beiden Clustern bereit. Dieser Pod generiert künstlichen Netzwerktraffic zur Veranschaulichung:

for CTX in ${CTX_1} ${CTX_2}
do
    kubectl apply --context=${CTX} \
        -f ${SAMPLES_DIR}/samples/sleep/sleep.yaml -n sample
done

Warten Sie, bis der Sleep-Dienst in jedem Cluster gestartet wurde. Prüfen Sie, ob die Ausgabe in etwa so aussieht:

kubectl get pod --context=${CTX_1} -n sample -l app=sleep

NAME                             READY   STATUS    RESTARTS   AGE
sleep-754684654f-n6bzf           2/2     Running   0          5s

kubectl get pod --context=${CTX_2} -n sample -l app=sleep

NAME                             READY   STATUS    RESTARTS   AGE
sleep-754684654f-dzl9j           2/2     Running   0          5s

Clusterübergreifendes Load-Balancing prüfen

Rufen Sie den HelloWorld-Dienst mehrmals auf und prüfen Sie die Ausgabe, um abwechselnde Antworten von v1 und v2 zu prüfen:

Rufen Sie den Dienst HelloWorld auf:

kubectl exec --context="${CTX_1}" -n sample -c sleep \
    "$(kubectl get pod --context="${CTX_1}" -n sample -l \
    app=sleep -o jsonpath='{.items[0].metadata.name}')" \
    -- /bin/sh -c 'for i in $(seq 1 20); do curl -sS helloworld.sample:5000/hello; done'

Die Ausgabe sollte in etwa so aussehen:

Hello version: v2, instance: helloworld-v2-758dd55874-6x4t8
Hello version: v1, instance: helloworld-v1-86f77cd7bd-cpxhv
...

Rufen Sie den Dienst HelloWorld noch einmal auf:

kubectl exec --context="${CTX_2}" -n sample -c sleep \
    "$(kubectl get pod --context="${CTX_2}" -n sample -l \
    app=sleep -o jsonpath='{.items[0].metadata.name}')" \
    -- /bin/sh -c 'for i in $(seq 1 20); do curl -sS helloworld.sample:5000/hello; done'

Die Ausgabe sollte in etwa so aussehen:

Hello version: v2, instance: helloworld-v2-758dd55874-6x4t8
Hello version: v1, instance: helloworld-v1-86f77cd7bd-cpxhv
...

Sie haben Ihr Anthos Service Mesh mit Load-Balancing und mehreren Clustern geprüft.

Bereinigen

Entfernen Sie nach der Prüfung des Load-Balancings die Dienste HelloWorld und Sleep aus dem Cluster.

kubectl delete ns sample --context ${CTX_1}
kubectl delete ns sample --context ${CTX_2}