Multi-Cloud- oder Hybrid-Mesh einrichten

w

Vorschau — Hybrid and multi-cloud mesh

Diese Funktion unterliegt den „Nutzungsbedingungen für Pre-GA-Angebote“ im Abschnitt „Allgemeine Nutzungsbedingungen“ der dienstspezifischen Nutzungsbedingungen. Pre-GA-Funktionen sind „wie besehen“ verfügbar und werden möglicherweise nur eingeschränkt unterstützt. Weitere Informationen finden Sie in den Beschreibungen der Startphase.

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 Google Distributed Cloud (Vorschau)
• Hybrid: GKE on Google Cloud und Google Distributed Cloud (Vorabversion)
• Multi-Cloud: GKE in Google Cloud und Amazon EKS (Vorschau)

<ph type="x-smartling-placeholder">

</ph> Warnung:Support kontaktieren bevor Sie ein Multi-Cloud-Mesh einrichten.

<ph type="x-smartling-placeholder">

</ph> Hinweis zur Plattform:Der von Ihnen verwendete asmcli create-mesh-Befehl um die Endpunkterkennung zu aktivieren erfordert, dass alle Cluster im Mesh einer der Multi-Cloud-/Hybrid-Cluster sind. Plattformkombinationen aus der obigen Liste. Andere Kombinationen von Multi-Cloud- oder Hybrid-Mesh-Netzwerke auf anderen Plattformen werden nicht unterstützt. Verwaltetes Cloud 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 GKE-Cluster, die sich befinden, sollten zum Erstellen berechtigt sein Typen des externen Load-Balancings. 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 verwenden, Google Distributed Cloud und Google Distributed Cloud, Die Adresse der Kubernetes-Steuerungsebene und die Gateway-Adresse müssen erreichbar sein von Pods in GKE-Clustern. 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 Cloud 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:

• Erforderliche Tools installieren
• asmcli herunterladen
• Clusteradministratorberechtigungen erteilen
• Projekt 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.

Warnung: Verwenden Sie nur kubeconfig-Dateien aus vertrauenswürdigen Quellen. Die Verwendung einer speziell erstellten kubeconfig-Datei kann zur Ausführung von schädlichem Code oder zu Dateisichtbarkeit führen. Wenn Sie eine nicht vertrauenswürdige kubeconfig-Datei verwenden müssen, prüfen Sie sie zuerst sorgfältig, ähnlich wie ein Shell-Skript.

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 Cloud Service Mesh auf anderen Clustern mit unterschiedlichen Werten für --network_id, dann sollten Sie dieselben Werte als Wert an NETWORK_2 übergeben.

east-west-Gateway installieren

1. Installieren Sie in CLUSTER_1 (Ihrem GKE-Cluster) ein Gateway, das speziell für east-west Traffic zu CLUSTER_2 (Ihrem Multi-Cloud- oder lokalen Cluster):

   asm/istio/expansion/gen-eastwest-gateway.sh \
       --mesh ${MESH_ID} \
       --network ${NETWORK_1}  \
       --revision  | \
       ./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.

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

   asm/istio/expansion/gen-eastwest-gateway.sh \
       --mesh ${MESH_ID} \
       --network ${NETWORK_2} \
       --revision  | \
       ./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

Hinweis: Weitere Informationen zur Endpunkterkennung finden Sie unter Endpunkterkennung mit mehreren Steuerungsebenen.

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

Plattformhinweis: Diese Schritte gelten nur, wenn Sie eine clusterinterne Steuerungsebene verwenden. Informationen zum verwalteten Cloud Service Mesh finden Sie unter Sidecar-Proxys einfügen oder Wenden Sie die verwaltete Datenebene an.

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.

Hinweis: Diese Beispieldienste befinden sich in der Istio samples-Verzeichnis in der TAR-Datei istioctl (in OUTPUT_DIR/istio-${ASM_VERSION%+*}/samples) und nicht der Verzeichnis samples von asmcli heruntergeladen (in OUTPUT_DIR/samples).

Sidecar-Injektion aktivieren

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

Hinweis: Wenn Ihre Cluster unterschiedliche Versionen von Cloud Service Mesh haben, müssen Sie Führen Sie für jeden Cluster den folgenden Befehl aus.

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

Hinweis: Im Beispiel HelloWorld wird Docker Hub verwendet. In einem privaten Cluster kann die Containerlaufzeit Container-Images standardmäßig aus Artifact Registry abrufen. Die Containerlaufzeit kann keine Images aus einer anderen Container-Image-Registry im Internet abrufen. Sie können das Image herunterladen und in Artifact Registry hochladen oder Cloud NAT verwenden, um ausgehenden Internetzugriff für bestimmte private Knoten bereitzustellen. Weitere Informationen finden Sie unter Externe Container migrieren und Private Cluster erstellen.

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

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

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

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

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

2. 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:

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

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

Herzlichen Glückwunsch, Sie haben Ihr Cloud 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}