Hilfestellung für die Migration mit Mesh-Netzwerkerweiterung von Istio: Anleitung

In dieser Anleitung wird beschrieben, wie Sie ein Service Mesh initialisieren und konfigurieren, um eine funktionsspezifische Migration von einem lokalen Rechenzentrum (Legacy) zu Google Cloud Platform (GCP) zu unterstützen. Die Anleitung und der zugehörige konzeptionelle Artikel richten sich an Systemadministratoren und Entwickler, die ein Service Mesh verwenden möchten, das Traffic dynamisch an die alte Umgebung oder die GCP weiterleitet.

Ein Service Mesh kann die Komplexität sowohl der Migrationsaufgabe als auch des Refaktorierungsaufwands erheblich verringern, da es die Netzwerkfunktionen von den Dienstfunktionen entkoppelt. Es reduziert auch die Komplexität des Netzwerkbetriebs, da es Load-Balancing, Trafficverwaltung, Monitoring und Sichtbarkeit bietet.

Das folgende Diagramm zeigt, wie Sie ein Service Mesh verwenden können, um Traffic an Mikrodienste in der alten Umgebung oder an die GCP weiterzuleiten:

Service Mesh verwenden, um Traffic an Mikrodienste, die in der alten Umgebung ausgeführt werden, oder an die GCP weiterzuleiten

In dieser Anleitung verwenden Sie folgende Software:

  • Ubuntu Server und Container-Optimized OS: In dieser Anleitung verwendete Betriebssysteme
  • Docker Community Edition: Plattform zum Ausführen von containerisierten Arbeitslasten
  • Docker Compose: Ein Tool, um Docker-Anwendungen zu definieren und auszuführen
  • Helm: Ein Tool, um die Kubernetes-Anwendung zu installieren und zu verwalten
  • Istio: Ein Open-Source-Service Mesh
  • Kiali: Ein Tool, um Service Meshes von Istio zu visualisieren
  • Envoy: Sidecar-Proxy, der beim Beitritt zum Service Mesh von Istio verwendet wird

Ziele

  • Umgebung initialisieren, die das lokale Rechenzentrum simuliert.
  • Beispielarbeitslasten im lokalen Rechenzentrum bereitstellen.
  • Arbeitslasten testen, die im lokalen Rechenzentrum ausgeführt werden.
  • Zielumgebung auf der GCP konfigurieren.
  • Arbeitslast vom lokalen Rechenzentrum zur Zielumgebung migrieren.
  • In der Zielumgebung ausgeführte Arbeitslasten testen.
  • Das lokale Rechenzentrum deaktivieren.

Kosten

In dieser Anleitung werden unter anderem diese kostenpflichtigen GCP-Komponenten verwendet:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung erstellen.

Hinweise

  1. Melden Sie sich in Ihrem Google-Konto an.

    Wenn Sie noch kein Konto haben, registrieren Sie sich hier für ein neues Konto.

  2. Wählen Sie ein Google Cloud Platform-Projekt aus oder erstellen Sie eines.

    Zur Seite "Ressourcen verwalten"

  3. Prüfen Sie, ob die Abrechnung für Ihr Google Cloud Platform-Projekt aktiviert ist.

    Informationen zum Aktivieren der Abrechnung

  4. Aktivieren Sie die Compute Engine and GKE erforderlichen APIs.

    Aktivieren Sie die APIs.

Nach Abschluss dieser Anleitung können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Umgebung vorbereiten

Die meisten Schritte in dieser Anleitung werden in Cloud Shell ausgeführt.

  1. Öffnen Sie Cloud Shell:

    Cloud Shell ÖFFNEN

  2. Ändern Sie das Arbeitsverzeichnis in das Verzeichnis $HOME.

    cd "$HOME"
    
  3. Klonen Sie das Git-Repository, das die Skripts und Manifestdateien enthält, um die Demoanwendung bereitzustellen und zu konfigurieren:

    git clone https://github.com/GoogleCloudPlatform/solutions-istio-mesh-expansion-migration
    
  4. Legen Sie die Standardregion und -zone fest:

    gcloud config set compute/region us-east1
    gcloud config set compute/zone us-east1-b
    
  5. Initialisieren Sie eine Umgebungsvariable, in der die Versionskennung von Istio gespeichert ist:

    export ISTIO_VERSION=1.1.1
    
  6. Laden Sie Istio herunter und extrahieren Sie es:

    wget https://github.com/istio/istio/releases/download/"$ISTIO_VERSION"/istio-"$ISTIO_VERSION"-linux.tar.gz
    tar -xvzf istio-"$ISTIO_VERSION"-linux.tar.gz
    
  7. Initialisieren Sie Umgebungsvariablen, die den Pfad enthalten, an dem Sie Istio extrahiert haben, sowie die ID der Helm-Version und den Pfad, an dem Sie Helm extrahieren:

    ISTIO_PATH="$HOME"/istio-"$ISTIO_VERSION"
    HELM_VERSION=v2.13.0
    HELM_PATH="$HOME"/helm-"$HELM_VERSION"
    
  8. Laden Sie den Paketmanager Helm herunter und extrahieren Sie ihn:

    wget https://storage.googleapis.com/kubernetes-helm/helm-"$HELM_VERSION"-linux-amd64.tar.gz
    tar -xvzf helm-"$HELM_VERSION"-linux-amd64.tar.gz
    mv linux-amd64 "$HELM_PATH"
    

Beispielarbeitslast

In dieser Anleitung verwenden Sie die Anwendung Bookinfo. Sie ist eine 4-stufige, mehrsprachige Anwendung für Mikrodienste, die Informationen über Bücher anzeigt. Diese Anwendung ist für die Ausführung auf Kubernetes vorgesehen. Sie stellen sie jedoch zuerst mit Docker und Docker Compose auf einer Compute Engine-Instanz bereit. Mit Docker Compose beschreiben Sie Anwendungen in mehreren Containern mithilfe von YAML-Deskriptoren. Sie können die Anwendung dann starten, indem Sie einen einzelnen Befehl ausführen.

Obwohl diese Beispielarbeitslast bereits containerisiert ist, gilt dieser Ansatz auch für nicht-containerisierte Dienste. In solchen Fällen können Sie eine "Modernisierungsphase" hinzufügen, in der Sie Dienste containerisieren, die Sie migrieren möchten.

Die Anwendung Bookinfo verfügt über vier Mikrodienstkomponenten:

  • productpage: Ruft die Mikrodienste details, ratings und reviews auf, um die Informationsseite zum Buch zu füllen
  • details: Bietet Informationen zu Büchern
  • reviews: Enthält Buchrezensionen
  • ratings: Gibt Informationen zum Buchranking zurück, die einer Buchrezension beigefügt sind

Umgebungen einrichten

Der erste Schritt besteht darin, die Umgebungen zu konfigurieren, die Sie für diese Anleitung benötigen:

  • Eine Umgebung, die das lokale (Legacy) Rechenzentrum simuliert
  • Eine Umgebung, die das Migrationsziel simuliert

Diese Anleitung soll Ihnen bei der Migration von einer Nicht-GCP-Umgebung (z. B. einem lokalen oder einem anderen Cloudanbieter) zur GCP helfen. Solche Migrationen in einem Netzwerk sind komplexer, da ein sicherer Kommunikationskanal zwischen der Nicht-GCP-Umgebung und der GCP-Umgebung eingerichtet werden muss.

In dieser Anleitung werden beide Umgebungen in der GCP ausgeführt. Dies vereinfacht die Einrichtung, da nur eine Bootstrapping-Phase erforderlich ist.

Alte Umgebung bereitstellen

In diesem Abschnitt konfigurieren Sie eine GCP-Umgebung, um eine separate Nicht-GCP-Umgebung zu emulieren, indem Sie Compute Engine-Instanzen initialisieren und die zu migrierenden Arbeitslasten bereitstellen. Das folgende Diagramm zeigt die Zielarchitektur der alten Umgebung:

Architektur für die Bereitstellung der alten Umgebung

Firewallregeln erstellen

Sie erstellen Firewallregeln, um externen Zugriff auf die Mikrodienste und die Datenbank zuzulassen.

  • Erstellen Sie in Cloud Shell die Firewallregeln, die für die Kommunikation zwischen Knoten erforderlich sind:

    gcloud compute firewall-rules create bookinfo \
        --description="Bookinfo App rules" \
        --action=ALLOW \
        --rules=tcp:9080,tcp:9081,tcp:9082,tcp:9083,tcp:9084 \
        --target-tags=bookinfo-legacy-vm
    

Dienstkonto zum Verwalten von Compute Engine-Instanzen initialisieren

In dieser Anleitung erstellen Sie ein Dienstkonto zur Verwaltung von Compute Engine-Instanzen. Es ist eine bewährte Vorgehensweise, das Dienstkonto auf die Rollen und Zugriffsberechtigungen zu beschränken, die zum Ausführen der Anwendung erforderlich sind. Für diese Anleitung ist die Rolle "Compute-Betrachter" (roles/compute.viewer) die einzige Rolle, die für das Dienstkonto erforderlich ist. Diese Rolle bietet schreibgeschützten Zugriff auf Compute Engine-Ressourcen.

  1. Initialisieren Sie in Cloud Shell eine Umgebungsvariable, in der der Name des Dienstkontos gespeichert wird:

    GCE_SERVICE_ACCOUNT_NAME=istio-migration-gce
    
  2. Erstellen Sie ein Dienstkonto:

    gcloud iam service-accounts create "$GCE_SERVICE_ACCOUNT_NAME" --display-name="$GCE_SERVICE_ACCOUNT_NAME"
    
  3. Initialisieren Sie eine Umgebungsvariable, in der die vollständige E-Mail-Adresse des Dienstkontos gespeichert wird:

    GCE_SERVICE_ACCOUNT_EMAIL="$(gcloud iam service-accounts list \
        --format='value(email)' \
        --filter=displayName:"$GCE_SERVICE_ACCOUNT_NAME")"
    
  4. Binden Sie die Rolle compute.viewer an das Dienstkonto:

    gcloud projects add-iam-policy-binding "$(gcloud config get-value project 2> /dev/null)" \
        --member serviceAccount:"$GCE_SERVICE_ACCOUNT_EMAIL" \
        --role roles/compute.viewer
    

Laufzeitumgebung initialisieren

Als Nächstes wird eine Compute Engine-Instanz zum Hosten der zu migrierenden Arbeitslasten erstellt und konfiguriert.

  1. Initialisieren und exportieren Sie in Cloud Shell eine Variable mit dem Namen der Compute Engine-Instanz:

    export GCE_INSTANCE_NAME=legacy-vm
    
  2. Erstellen Sie eine Compute Engine-Instanz:

    gcloud compute instances create "$GCE_INSTANCE_NAME" \
        --boot-disk-device-name="$GCE_INSTANCE_NAME" \
        --boot-disk-size=10GB \
        --boot-disk-type=pd-ssd \
        --image-family=ubuntu-1804-lts \
        --image-project=ubuntu-os-cloud \
        --machine-type=n1-standard-1 \
        --metadata-from-file startup-script="$HOME"/solutions-istio-mesh-expansion-migration/gce-startup.sh \
        --scopes=storage-ro,logging-write,monitoring-write,service-control,service-management,trace \
        --service-account="$GCE_SERVICE_ACCOUNT_EMAIL" \
        --tags=bookinfo-legacy-vm
    

    Der in diesem Befehl angegebene Maschinentyp n1-standard-1 ist der kleinste, mit dem Sie die Beispielarbeitslast ausführen können, ohne die Leistung zu beeinträchtigen. Wenn dieser Befehl ausgeführt wurde, zeigt die Konsole Details zur neuen Instanz an:

    NAME           ZONE        MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP   STATUS
    legacy-vm      us-east1-b  n1-standard-1               10.142.0.38  34.73.53.145  RUNNING
    

Das Startskript konfiguriert die Compute Engine-Instanz folgendermaßen:

  • Docker wird installiert
  • Docker Compose wird installiert
  • Dnsmasq wird installiert

Arbeitslast in der alten Umgebung bereitstellen

In dieser Anleitung stellen Sie die Anwendung Istio Bookinfo als Arbeitslast für die Migration bereit.

  1. Kopieren Sie in Cloud Shell Deskriptoren von Docker Compose in die Compute Engine-Instanz:

    gcloud compute scp --recurse \
    "$HOME"/solutions-istio-mesh-expansion-migration/compose \
    "$GCE_INSTANCE_NAME":/tmp --zone=us-east1-b
    
  2. Warten Sie, bis die Installation von Docker Compose abgeschlossen ist:

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='while ! command -v docker-compose; do echo "Waiting for docker-compose to be installed"; sleep 5; done'
    
  3. Starten Sie mit Docker Compose die Anwendung Bookinfo:

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo docker-compose -f /tmp/compose/bookinfo.yaml up -d'
    

Bereitstellung in alter Umgebung testen

Sie haben die Konfiguration der Beispielarbeitslast abgeschlossen und können sie jetzt testen.

  1. Suchen Sie in Cloud Shell die externe IP-Adresse der Compute Engine-Instanz, auf der die Beispielarbeitslast ausgeführt wird:

    gcloud compute instances describe "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --format='value(networkInterfaces[0].accessConfigs[0].natIP)'
    
  2. Öffnen Sie einen Browser und rufen Sie die folgende URL auf, wobei [EXTERNAL_IP] die IP-Adresse aus dem vorherigen Schritt ist:

    http://[EXTERNAL_IP]:9083/productpage
    

    Es wird eine Seite mit Details zu Büchern und relevanten Bewertungen angezeigt:

    Details zu Büchern und relevanten Bewertungen

Laufzeitumgebung für Ziel bereitstellen

In diesem Abschnitt konfigurieren Sie die Zielumgebung auf der GCP, indem Sie einen GKE-Cluster initialisieren und den alten Dienst mithilfe von Istio verfügbar machen. Das folgende Diagramm zeigt die Zielarchitektur der Laufzeitumgebung für das Ziel:

Architektur zur Bereitstellung der Laufzeitumgebung für das Ziel

Dienstkonto zum Verwalten von GKE-Clustern initialisieren

In dieser Anleitung erstellen Sie ein Dienstkonto, um Compute Engine-Instanzen im GKE-Cluster zu verwalten. Die GKE-Clusterknoten verwenden dieses Dienstkonto anstelle des Standarddienstkontos, da Sie weniger Berechtigungen bereitstellen möchten als dem Standarddienstkonto gewährt wurden.

Die für das Dienstkonto erforderlichen Rollen lauten monitoring.viewer, monitoring.metricWriter und logging.logWriter, wie unter Clustersicherheit erhöhen beschrieben.

  1. Initialisieren Sie in Cloud Shell eine Umgebungsvariable, in der der Name des Dienstkontos gespeichert wird:

    GKE_SERVICE_ACCOUNT_NAME=istio-migration-gke
    
  2. Erstellen Sie ein Dienstkonto:

    gcloud iam service-accounts create "$GKE_SERVICE_ACCOUNT_NAME" \
        --display-name="$GKE_SERVICE_ACCOUNT_NAME"
    
  3. Initialisieren Sie eine Umgebungsvariable, in der der E-Mail-Kontoname des Dienstkontos gespeichert ist:

    GKE_SERVICE_ACCOUNT_EMAIL="$(gcloud iam service-accounts list \
        --format='value(email)' \
        --filter=displayName:"$GKE_SERVICE_ACCOUNT_NAME")"
    
  4. Weisen Sie dem Dienstkonto die Rollen monitoring.viewer, monitoring.metricWriter und logging.logWriter zu:

    gcloud projects add-iam-policy-binding \
        "$(gcloud config get-value project 2> /dev/null)" \
        --member serviceAccount:"$GKE_SERVICE_ACCOUNT_EMAIL" \
        --role roles/monitoring.viewer
    gcloud projects add-iam-policy-binding \
        "$(gcloud config get-value project 2> /dev/null)" \
        --member serviceAccount:"$GKE_SERVICE_ACCOUNT_EMAIL" \
        --role roles/monitoring.metricWriter
    gcloud projects add-iam-policy-binding \
        "$(gcloud config get-value project 2> /dev/null)" \
        --member serviceAccount:"$GKE_SERVICE_ACCOUNT_EMAIL" \
        --role roles/logging.logWriter
    

GKE-Cluster vorbereiten

In diesem Abschnitt starten Sie den GKE-Cluster, installieren Istio, geben Istio-Dienste frei und schließen die Clusterkonfiguration ab. Erstellen und starten Sie als Erstes den GKE-Cluster.

  1. Initialisieren und exportieren Sie in Cloud Shell eine Umgebungsvariable, in der der GKE-Clustername gespeichert ist:

    export GKE_CLUSTER_NAME=istio-migration
    
  2. Erstellen Sie einen regionalen GKE-Cluster mit einem Knotenpool und einem einzelnen Knoten in jeder Zone:

    gcloud container clusters create "$GKE_CLUSTER_NAME" \
        --addons=HorizontalPodAutoscaling,HttpLoadBalancing \
        --enable-autoupgrade \
        --enable-network-policy \
        --enable-ip-alias \
        --machine-type=n1-standard-4 \
        --metadata disable-legacy-endpoints=true \
        --node-locations us-east1-b,us-east1-c,us-east1-d \
        --no-enable-legacy-authorization \
        --no-enable-basic-auth \
        --no-issue-client-certificate \
        --num-nodes=1 \
        --region us-east1 \
        --service-account="$GKE_SERVICE_ACCOUNT_EMAIL"
    

    Dieser Befehl erstellt einen GKE-Cluster mit dem Namen istio-migration. Es kann bis zu fünf Minuten dauern, bis der Befehl ausgeführt ist. Wenn der Befehl ausgeführt ist, zeigt die Konsole Details zum neu erstellten Cluster an:

    NAME             LOCATION  MASTER_VERSION  MASTER_IP      MACHINE_TYPE   NODE_VERSION  NUM_NODES  STATUS
    istio-migration  us-east1  1.11.7-gke.4    35.196.136.88  n1-standard-8  1.11.7-gke.4  3          RUNNING
    

Als Nächstes installieren Sie Istio mithilfe von Helm im Cluster.

  1. Initialisieren und exportieren Sie in Cloud Shell eine Umgebungsvariable, die den Namen des Istio-Namespace speichert:

    export ISTIO_NAMESPACE=istio-system
    
  2. Erstellen Sie den Istio-Namespace:

    kubectl apply -f "$ISTIO_PATH"/install/kubernetes/namespace.yaml
    
  3. Erstellen Sie ein Kubernetes-Dienstkonto für Tiller, dem Serverabschnitt von Helm:

    kubectl apply -f "$ISTIO_PATH"/install/kubernetes/helm/helm-service-account.yaml
    
  4. Installieren Sie Tiller in Ihrem Cluster:

    "$HELM_PATH"/helm init --service-account tiller
    
  5. Installieren Sie das istio-init-Diagramm, um alle benutzerdefinierten Ressourcendefinitionen von Istio mithilfe von Bootstrapping zu verknüpfen:

    "$HELM_PATH"/helm install "$ISTIO_PATH"/install/kubernetes/helm/istio-init --name istio-init --namespace "$ISTIO_NAMESPACE"
    

    Wenn dieser Befehl abgeschlossen ist, zeigt die Konsole eine Zusammenfassung der neuen Objekte an, die im GKE-Cluster installiert wurden:

    NAME:   istio-init
    LAST DEPLOYED: Wed Mar 20 11:39:12 2019
    NAMESPACE: istio-system
    STATUS: DEPLOYED
    RESOURCES:
    ==> v1/ClusterRole
    NAME                     AGE
    istio-init-istio-system  1s
    ==> v1/ClusterRoleBinding
    NAME                                        AGE
    istio-init-admin-role-binding-istio-system  1s
    ==> v1/ConfigMap
    NAME          DATA  AGE
    istio-crd-10  1     1s
    istio-crd-11  1     1s
    ==> v1/Job
    NAME               COMPLETIONS  DURATION  AGE
    istio-init-crd-10  0/1          1s        1s
    istio-init-crd-11  0/1          1s        1s
    ==> v1/Pod(related)
    NAME                     READY  STATUS             RESTARTS  AGE
    istio-init-crd-10-2s28z  0/1    ContainerCreating  0         1s
    istio-init-crd-11-28n9r  0/1    ContainerCreating  0         1s
    ==> v1/ServiceAccount
    NAME                        SECRETS  AGE
    istio-init-service-account  1        1s
    
  6. Überprüfen Sie, ob die CRDs von Istio an den Kubernetes-api-server festgeschrieben wurden:

    kubectl get crds | grep 'istio.io\|certmanager.k8s.io' | wc -l
    

    Die erwartete Ausgabe ist 53.

  7. Installieren Sie das Istio-Diagramm:

    "$HELM_PATH"/helm install "$ISTIO_PATH"/install/kubernetes/helm/istio \
        --name istio \
        --namespace "$ISTIO_NAMESPACE" \
        --set gateways.istio-ilbgateway.enabled=true \
        --set global.meshExpansion.enabled=true \
        --set global.meshExpansion.useILB=true \
        --set grafana.enabled=true \
        --set kiali.enabled=true \
        --set kiali.createDemoSecret=true \
        --set kiali.dashboard.grafanaURL=http://grafana:3000 \
        --set prometheus.enabled=true \
        --set tracing.enabled=true
    

    Es kann bis zu zwei Minuten dauern, bis der Befehl ausgeführt ist. Wenn der Befehl ausgeführt ist, zeigt die Konsole eine Zusammenfassung der neuen Objekte an, die im GKE-Cluster installiert wurden:

    NAME:   istio
    LAST DEPLOYED: Wed Mar 20 11:43:08 2019
    NAMESPACE: istio-system
    STATUS: DEPLOYED
    RESOURCES:
    

    Dieser Zusammenfassung folgt eine Liste der bereitgestellten Ressourcen.

Da Compute Engine-Instanzen, die Sie dem Service Mesh hinzufügen möchten, Zugriff auf die Steuerungsebenendienste (Pilot, Mixer, Citadel) von Istio haben müssen, müssen Sie diese Dienste über die Dienste istio-ingressgateway und istio-ilbgateway verfügbar machen. Sie können den Kubernetes-DNS-Server auch mithilfe eines internen Load-Balancers bereitstellen, sodass der Server abgefragt werden kann, um Namen für Dienste aufzulösen, die im Cluster ausgeführt werden. Sie stellen außerdem Kiali zur Verfügung, um das Service Mesh zu visualisieren.

  1. Erstellen Sie in der Cloud Shell den internen Load-Balancer, um den Kubernetes-DNS-Server verfügbar zu machen:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/kube-dns-ilb.yaml
    
  2. Warten Sie, bis dem Dienstobjekt mit dem Namen kube-dns-ilb eine externe IP-Adresse zugewiesen wurde:

    kubectl get svc kube-dns-ilb -n kube-system --watch
    

    Die Ausgabe zeigt eine IP-Adresse für EXTERNAL-IP:

    NAME           TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
    kube-dns-ilb   LoadBalancer   10.35.252.144   10.128.0.3    53:31054/UDP   4d
    

    Drücken Sie Control+C, um den Befehl zu beenden.

  3. Warten Sie, bis dem Dienstobjekt mit dem Namen istio-ingressgateway eine externe IP-Adresse zugewiesen wurde:

    kubectl get svc istio-ingressgateway -n "$ISTIO_NAMESPACE" --watch
    

    Die Ausgabe zeigt eine IP-Adresse für EXTERNAL-IP:

    NAME                   TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)                                                                                                                   AGE
    istio-ingressgateway   LoadBalancer   10.48.2.195   34.73.84.179   80:31380/TCP,443:31390/TCP,31400:31400/TCP,15011:31145/TCP,8060:30381/TCP,853:30784/TCP,15030:32124/TCP,15031:32703/TCP   4d
    

    Drücken Sie Control+C, um den Befehl zu beenden.

  4. Warten Sie, bis dem Dienstobjekt mit dem Namen istio-ilbgateway eine externe IP-Adresse zugewiesen wurde:

    kubectl get svc istio-ilbgateway -n "$ISTIO_NAMESPACE" --watch
    

    Die Ausgabe zeigt eine IP-Adresse für EXTERNAL-IP:

    NAME               TYPE           CLUSTER-IP     EXTERNAL-IP   PORT(S)                                                         AGE
    istio-ilbgateway   LoadBalancer   10.48.14.190   10.142.0.31   15011:30805/TCP,15010:31082/TCP,8060:30953/TCP,5353:30536/TCP   2m
    

    Drücken Sie Control+C, um den Befehl zu beenden.

  5. Geben Sie Kiali mit einem Gateway und einem VirtualService frei:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/kiali.yaml
    

Mesh-Netzwerkerweiterung von Istio konfigurieren

In diesem Abschnitt konfigurieren Sie die Mesh-Netzwerkerweiterung von Istio, damit Compute Engine-Instanzen dem Service Mesh beitreten können. Zuerst müssen die Konfigurationsdateien generiert werden, die in jeder Compute Engine-Instanz bereitgestellt werden sollen, die Sie dem Netz hinzufügen möchten.

  1. Initialisieren und exportieren Sie in Cloud Shell eine Umgebungsvariable, die den Standardnamen des Namespace speichert:

    export SERVICE_NAMESPACE=default
    
  2. Extrahieren Sie die Schlüssel für das von Istio verwendete Dienstkonto:

    "$ISTIO_PATH"/install/tools/setupMeshEx.sh machineCerts default "$SERVICE_NAMESPACE" all
    
  3. Initialisieren und exportieren Sie eine Umgebungsvariable, in der die Optionen für das Skript zur Generierung der Konfiguration gespeichert sind:

    export GCP_OPTS="--region $(gcloud config get-value compute/region 2> /dev/null)"
    
  4. Führen Sie das Skript zur Generierung der Cluster-Umgebungskonfiguration aus:

    "$ISTIO_PATH"/install/tools/setupMeshEx.sh generateClusterEnv "$GKE_CLUSTER_NAME"
    
  5. Führen Sie das Skript zur Generierung der DNS-Konfiguration aus:

    "$HOME"/solutions-istio-mesh-expansion-migration/gce-mesh-expansion-setup.sh
    

Dann konfigurieren Sie die Compute Engine-Instanz, die Sie dem Mesh-Netzwerk hinzufügen möchten.

  1. Deaktivieren Sie die Variable GCP_OPTS, damit das Initialisierungsskript die Standardeinstellungen auswählt:

    unset GCP_OPTS
    
  2. Initialisieren und exportieren Sie eine Umgebungsvariable, die den Pfad für das Setupskript speichert:

    export SETUP_ISTIO_VM_SCRIPT="$ISTIO_PATH"/install/tools/setupIstioVM.sh
    
  3. Bereiten Sie den Versionsdeskriptor von Istio für die Compute Engine-Instanzinitialisierung vor:

    cp "$ISTIO_PATH"/istio.VERSION "$HOME"
    
  4. Führen Sie das Skript zur Generierung der Cluster-Umgebungskonfiguration aus:

    "$ISTIO_PATH"/install/tools/setupMeshEx.sh gceMachineSetup "$GCE_INSTANCE_NAME"
    
  5. Konfigurieren Sie die lokalen Ports, die die Sidecar-Datei von Envoy für eingehende Dienste verwenden:

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo sed -i -e "\$aISTIO_INBOUND_PORTS=9081,9082,9083,9084" /var/lib/istio/envoy/sidecar.env'
    
  6. Konfigurieren Sie den Namespace des Clusters:

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo sed -i -e "\$aISTIO_NAMESPACE='"$SERVICE_NAMESPACE"'" /var/lib/istio/envoy/sidecar.env'
    
  7. Starten Sie Istio neu:

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo systemctl restart istio'
    
  8. Überprüfen Sie, ob Istio korrekt gestartet wurde:

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo systemctl --type=service --state=running list-units | grep "dnsmasq\|istio\|systemd-resolved"'
    

    Die Ausgabe zeigt, dass die Dienste dnsmasq, istio, istio-auth-node-agent und systemd-resolved geladen wurden, aktiv sind und ausgeführt werden:

    dnsmasq.service                  loaded active running dnsmasq - A lightweight DHCP and caching DNS server
    istio-auth-node-agent.service    loaded active running istio-auth-node-agent: The Istio auth node agent
    istio.service                    loaded active running istio-sidecar: The Istio sidecar
    systemd-resolved.service         loaded active running Network Name Resolution
    

Anschließend fügen Sie im Service Mesh von Istio Dienste hinzu, die auf der Compute Engine-Instanz ausgeführt werden.

  1. Erstellen Sie in Cloud Shell die Kubernetes-Dienste ohne Selektoren, um die Dienste anzuzeigen, die in der Compute Engine-Instanz ausgeführt werden:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/selectorless-services.yaml
    
  2. Initialisieren Sie eine Umgebungsvariable, in der die IP-Adresse der Compute Engine-Instanz gespeichert ist, auf der die Beispielarbeitslast ausgeführt wird:

    GCE_INSTANCE_IP="$(gcloud compute instances describe "$GCE_INSTANCE_NAME" --format='value(networkInterfaces[].networkIP)')"
    
  3. Registrieren Sie die Dienste im Mesh-Netzwerk:

    "$ISTIO_PATH"/bin/istioctl register details "$GCE_INSTANCE_IP" http:9082 -n "$SERVICE_NAMESPACE"
    "$ISTIO_PATH"/bin/istioctl register productpage "$GCE_INSTANCE_IP" http:9083 -n "$SERVICE_NAMESPACE"
    "$ISTIO_PATH"/bin/istioctl register ratings "$GCE_INSTANCE_IP" http:9081 -n "$SERVICE_NAMESPACE"
    "$ISTIO_PATH"/bin/istioctl register reviews "$GCE_INSTANCE_IP" http:9084 -n "$SERVICE_NAMESPACE"
    

Abschließend konfigurieren Sie die VirtualServices und die zugehörigen Routingregeln für die Dienste im Mesh-Netzwerk, die derzeit in der Compute Engine-Instanz ausgeführt werden. Außerdem stellen Sie den Dienst productpage über ein Ingress-Gateway von Istio bereit.

  1. Stellen Sie in der Cloud Shell ein Gateway-Objekt bereit, um Dienste verfügbar zu machen:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/gateway.yaml
    
  2. Stellen Sie den VirtualService bereit, der Traffic vom Gateway-Objekt an die in Compute Engine ausgeführte productpage weiterleitet:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-productpage-vm.yaml
    
  3. Erstellen Sie die ServiceEntries, um die Diensterkennung für die in den Compute Engine-Instanzen ausgeführten Dienste zu aktivieren:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/serviceentry.yaml
    
  4. Warten Sie, bis dem Dienstobjekt mit dem Namen istio-ingressgateway eine externe IP-Adresse zugewiesen wurde:

    kubectl get svc istio-ingressgateway -n istio-system --watch
    

    In der Ausgabe sollte eine IP-Adresse für EXTERNAL-IP angezeigt werden:

    NAME                   TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)                                                                                                                   AGE
    istio-ingressgateway   LoadBalancer   10.48.2.195   34.73.84.179   80:31380/TCP,443:31390/TCP,31400:31400/TCP,15011:31145/TCP,8060:30381/TCP,853:30784/TCP,15030:32124/TCP,15031:32703/TCP   4d
    
  5. Bestätigen Sie, dass ein Gateway-Objekt mit dem Namen bookinfo-gateway erstellt wurde:

    kubectl get gateway --watch
    

    In der Ausgabe sollte das bookinfo-gateway in der Liste der Gateway-Objekte angezeigt werden:

    NAME               AGE
    bookinfo-gateway   3h
    

Mesh-Netzwerkerweiterung von Istio testen

Nachdem Sie die in der Compute Engine-Instanz ausgeführte Beispielarbeitslast mit Istio verfügbar gemacht haben, können Sie sie testen:

  1. Suchen Sie in Cloud Shell nach der externen IP-Adresse des Ingress-Gateways von Istio:

    kubectl get svc istio-ingressgateway -n istio-system
    
  2. Öffnen Sie einen Browser und rufen Sie die folgende URL auf, wobei [EXTERNAL_IP] die IP-Adresse aus dem vorherigen Schritt ist:

    http://[EXTERNAL_IP]/productpage
    

    Es wird eine Seite mit Informationen zu Büchern und relevanten Bewertungen angezeigt:

    Bücher und relevante Bewertungen

Service Mesh visualisieren

In diesem Abschnitt verwenden Sie Kiali, um eine visuelle Darstellung des Service Mesh anzuzeigen.

  1. Suchen Sie in Cloud Shell nach der externen IP-Adresse des Ingress-Gateways von Istio:

    kubectl get svc istio-ingressgateway -n istio-system
        EXTERNAL_IP="$(kubectl get svc istio-ingressgateway -n istio-system -o=jsonpath="{.status.loadBalancer.ingress[0].ip}")"
    
  2. Öffnen Sie einen Browser und rufen Sie die folgende URL auf, wobei [EXTERNAL_IP] die IP-Adresse aus dem vorherigen Schritt ist:

    http://[EXTERNAL_IP]:15029/kiali/console/graph/namespaces/?  edges=requestsPercentOfTotal&graphType=versionedApp&namespaces=default&injectServiceNodes=true&duration=60&pi=5000&layout=dagre
    
  3. Melden Sie sich auf dem Anmeldebildschirm von Kiali mit den folgenden Anmeldedaten an:

    • Username (Nutzername): admin
    • Password (Passwort): admin

    Kiali-Anmeldebildschirm

  4. Führen Sie mehrmals eine Anfrage für die Hauptseite der Beispielarbeitslast aus:

    for i in {1..10000}; do curl -s -o /dev/null -w "%{http_code}\n"  http://"$EXTERNAL_IP"/productpage; done
    

    Mit diesem Befehl generieren Sie Traffic zur Anwendung Bookinfo. Die erwartete Ausgabe ist eine Liste der HTTP-Rückgabecodes jeder Anfrage (in diesem Fall 200 OK):

    200
    200
    200
    [...]
    

    Im Dienst-Dashboard von Kiali sollte ein Diagramm des aktuellen Mesh-Netzwerks mit dem gesamten Traffic angezeigt werden, der an Dienste weitergeleitet wird, die in Compute Engine ausgeführt werden. Der gesamte Traffic wird vom istio-ingressgateway zum Kubernetes-Dienst productpage.default.svc.cluster.local weitergeleitet und verweist auf den Mikrodienst productpage, der auf der Compute Engine-Instanz ausgeführt wird. Die anderen Mikrodienste werden in der Grafik nicht angezeigt (details, reviews, ratings), da Docker Compose die Weiterleitung lokal auf der Compute Engine-Instanz verwaltet.

    Wenn das Diagramm nicht angezeigt wird, aktualisieren Sie die Dashboard-Seite von Kiali.

    Diagramm des aktuellen Mesh-Netzwerks

Arbeitslast migrieren

In diesem Abschnitt migrieren Sie die Komponenten der Beispielarbeitslast von der Compute Engine-Instanz in den GKE-Cluster. Führen Sie für jeden Dienst der Beispielarbeitslast folgende Schritte aus:

  1. Stellen Sie einen Pod bereit, auf dem der Dienst im GKE-Cluster ausgeführt wird.
  2. Konfigurieren Sie Regeln zur Aufteilung des Traffics zwischen dem im GKE-Cluster ausgeführten Dienst und dem in der Compute Engine-Instanz ausgeführten Dienst.
  3. Migrieren Sie den Traffic schrittweise vom in der Compute Engine-Instanz ausgeführten Dienst zum GKE-Cluster.
  4. Beenden Sie den Dienst, der in der Compute Engine-Instanz ausgeführt wird.

Das folgende Diagramm zeigt die Zielarchitektur des Systems für diesen Abschnitt:

Architektur zur Migration der Arbeitslast

Einfügen der Istio-Sidecar-Datei aktivieren

Jeder Dienst benötigt einen Envoy-Sidecar-Proxy, der ausgeführt wird, um sich im Service Mesh von Istio anzumelden. Sie können das automatische Einfügen der Sidecar-Datei aktivieren, um manuelle Änderungen an der Konfiguration Ihrer Pods zu vermeiden.

  1. Beenden Sie in der Cloud Shell den Befehl zur Trafficgenerierung, indem Sie Control+C drücken.

  2. Aktivieren Sie für den Kubernetes-Namespace, in dem Sie Dienstinstanzen bereitstellen möchten, das von Istio verwaltete automatische Einfügen der Sidecar-Datei:

    kubectl label namespace "$SERVICE_NAMESPACE" istio-injection=enabled
    

Dienste im GKE-Cluster bereitstellen

In diesem Abschnitt stellen Sie Instanzen im GKE-Cluster bereit und leiten einen Teil des Traffics zu diesen Instanzen weiter.

  1. Löschen Sie in Cloud Shell die ServiceEntries, bevor Sie andere Dienste im Mesh-Netzwerk bereitstellen. Wenn Sie diese Einträge löschen, verhindern Sie damit das Weiterleiten von Anforderungen an Instanzen, die noch nicht bereit sind:

    kubectl delete -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/serviceentry.yaml
    
  2. Stellen Sie Pods und Kubernetes-Dienste für die Mikrodienste productpage, details, reviews und ratings im Cluster bereit:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/productpage.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/details.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/ratings.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/reviews.yaml
    
  3. Aktualisieren Sie die VirtualServices-Konfiguration, um den eingehenden Traffic zwischen den Instanzen auf dem Compute Engine-Rechner und denen aufzuteilen, die im GKE-Cluster ausgeführt werden:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-productpage-split.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-details-split.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-ratings-split.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-reviews-split.yaml
    
  4. Erstellen Sie die ServiceEntries, um die Diensterkennung für die in den Compute Engine-Instanzen ausgeführten Dienste zu aktivieren:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/serviceentry.yaml
    

Als Nächstes überprüfen Sie die hybride Bereitstellung. Überprüfen Sie dazu den Traffic, der an alle Mikrodienstinstanzen in Ihren beiden Umgebungen (Compute Engine und GKE) gerichtet ist.

Mit Kiali können Sie eine visuelle Darstellung des Service Mesh ansehen:

  1. Suchen Sie in Cloud Shell nach der externen IP-Adresse des Ingress-Gateways von Istio:

    kubectl get svc istio-ingressgateway -n istio-system
    EXTERNAL_IP="$(kubectl get svc istio-ingressgateway -n istio-system -o=jsonpath="{.status.loadBalancer.ingress[0].ip}")"
    
  2. Öffnen Sie einen Browser und rufen Sie die folgende URL auf, wobei [EXTERNAL_IP] die IP-Adresse aus dem vorherigen Schritt ist:

    http://[EXTERNAL_IP]:15029/kiali/console/graph/namespaces/?edges=requestsPercentOfTotal&graphType=versionedApp&namespaces=default&injectServiceNodes=true&duration=60&pi=5000&layout=dagre
    
  3. Melden Sie sich auf dem Anmeldebildschirm von Kiali bei Bedarf mit den folgenden Anmeldedaten an:

    • Username (Nutzername): admin
    • Password (Passwort): admin
  4. Führen Sie mehrmals eine Anfrage für die Hauptseite der Beispielarbeitslast aus:

    for i in {1..10000}; do curl -s -o /dev/null -w "%{http_code}\n"  http://"$EXTERNAL_IP"/productpage; done
    

    Mit diesem Befehl generieren Sie Traffic zur Anwendung Bookinfo. Die erwartete Ausgabe ist eine Liste der HTTP-Rückgabecodes jeder Anfrage (in diesem Fall 200 OK):

    200
    200
    200
    [...]
    

    Im Dienst-Dashboard von Kiali sollten Sie sehen, dass der Traffic nahezu gleichmäßig auf die in Compute Engine ausgeführten Mikrodienstinstanzen und diejenigen in GKE (mit dem Suffix -gke im ersten Teil der Dienstkennzeichnung) aufgeteilt wird. Dies liegt daran, dass Sie die Routen im VirtualService so konfiguriert haben, dass sie dieselbe Gewichtung haben.

    Wenn das Diagramm nicht angezeigt wird, aktualisieren Sie die Dashboard-Seite von Kiali.

    Dashboard mit Trafficaufteilung

Traffic nur an GKE-Cluster weiterleiten

Wenn Sie von der Bereitstellung im GKE-Cluster überzeugt sind, können Sie Services und VirtualServices so aktualisieren, dass der Traffic nur zum Cluster weitergeleitet wird.

Das folgende Diagramm zeigt die Zielarchitektur des Systems für diesen Abschnitt:

Traffic nur an den GKE-Cluster weiterleiten

  1. Beenden Sie in der Cloud Shell den Befehl zur Trafficgenerierung, indem Sie Control+C drücken.

  2. Aktualisieren Sie Services und VirtualServices, um Traffic an Mikrodienstinstanzen im GKE-Cluster weiterzuleiten:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-gke.yaml
    

Sie können Ihre Bereitstellung validieren, indem Sie den Traffic überprüfen, der an alle Mikrodienstinstanzen in Ihren beiden Umgebungen (Compute Engine und GKE) gerichtet ist.

Mit Kiali können Sie eine visuelle Darstellung des Service Mesh ansehen:

  1. Suchen Sie in Cloud Shell nach der externen IP-Adresse des Ingress-Gateways von Istio:

    kubectl get svc istio-ingressgateway -n istio-system
    EXTERNAL_IP="$(kubectl get svc istio-ingressgateway -n istio-system -o=jsonpath="{.status.loadBalancer.ingress[0].ip}")"
    
  2. Öffnen Sie einen Browser und rufen Sie die folgende URL auf, wobei [EXTERNAL_IP] die IP-Adresse aus dem vorherigen Schritt ist:

    http://[EXTERNAL_IP]:15029/kiali/console/graph/namespaces/?edges=requestsPercentOfTotal&graphType=versionedApp&namespaces=default&injectServiceNodes=true&duration=60&pi=5000&layout=dagre

  3. Melden Sie sich auf dem Anmeldebildschirm von Kiali bei Bedarf mit den folgenden Anmeldedaten an:

    • Username (Nutzername): admin
    • Password (Passwort): admin
  4. Führen Sie mehrmals eine Anfrage für die Hauptseite der Beispielarbeitslast aus:

    for i in {1..10000}; do curl -s -o /dev/null -w "%{http_code}\n"  http://"$EXTERNAL_IP"/productpage; done
    

    Mit diesem Befehl generieren Sie Traffic zur Anwendung Bookinfo. Die erwartete Ausgabe ist eine Liste der HTTP-Rückgabecodes jeder Anfrage (in diesem Fall 200 OK):

    200
    200
    200
    [...]
    

    Im Dienst-Dashboard von Kiali sollten Sie sehen, dass der Traffic an im GKE-Cluster ausgeführte Mikrodienstinstanzen geleitet wird (mit dem laufenden Suffix -gke im ersten Teil der Dienstkennzeichnung). An die in Compute Engine ausgeführten Instanzen wird hingegen kein Traffic weitergeleitet. Wenn das Diagramm nicht angezeigt wird, aktualisieren Sie die Dashboard-Seite von Kiali. Sie haben zwar zwei Instanzen jedes Mikrodienstes bereitgestellt (eine in der Compute Engine-Instanz und die andere im GKE-Cluster), aber Sie haben VirtualServices so konfiguriert, dass der Traffic nur an die im GKE-Cluster ausgeführten Mikrodienstinstanzen weitergeleitet wird.

    Wenn das Diagramm nicht angezeigt wird, aktualisieren Sie die Dashboard-Seite von Kiali.

    Traffic wird nur an Instanzen weitergeleitet, die im GKE-Cluster ausgeführt werden

Altes Rechenzentrum deaktivieren

Da der gesamte Traffic an den GKE-Cluster weitergeleitet wird, können Sie jetzt die ServiceEntries für die in Compute Engine ausgeführten Mikrodienste löschen und Docker Compose beenden.

Das folgende Diagramm zeigt die Zielarchitektur des Systems für diesen Abschnitt:

Architektur zur Deaktivierung des alten Rechenzentrums

  1. Beenden Sie in der Cloud Shell den Befehl zur Trafficgenerierung, indem Sie Control+C drücken.

  2. Löschen Sie die ServiceEntries, bevor Sie andere Dienste im Mesh-Netzwerk bereitstellen:

    kubectl delete -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/serviceentry.yaml
    
  3. Beenden Sie die mit Docker Compose ausgeführte Beispielarbeitslast:

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo docker-compose -f /tmp/compose/bookinfo.yaml down --remove-orphans -v'
    

Erweitertes Mesh-Netzwerk visualisieren, das nur in GKE ausgeführt wird

In diesem Abschnitt überprüfen Sie Ihre Bereitstellung. Überprüfen Sie dazu den Traffic, der an alle Mikrodienstinstanzen in Ihren beiden Umgebungen (Compute Engine und GKE) gerichtet ist.

Mit Kiali können Sie eine visuelle Darstellung des Service Mesh ansehen:

  1. Suchen Sie in Cloud Shell nach der externen IP-Adresse des Ingress-Gateways von Istio:

    kubectl get svc istio-ingressgateway -n istio-system
    EXTERNAL_IP="$(kubectl get svc istio-ingressgateway -n istio-system -o=jsonpath="{.status.loadBalancer.ingress[0].ip}")"
    
  2. Öffnen Sie einen Browser und rufen Sie die folgende URL auf, wobei [EXTERNAL_IP] die IP-Adresse aus dem vorherigen Schritt ist:

    http://[EXTERNAL_IP]:15029/kiali/console/graph/namespaces/?edges=requestsPercentOfTotal&graphType=versionedApp&namespaces=default&injectServiceNodes=true&duration=60&pi=5000&layout=dagre
    
  3. Melden Sie sich auf dem Anmeldebildschirm von Kiali bei Bedarf mit den folgenden Anmeldedaten an:

    • Username (Nutzername): admin
    • Password (Passwort): admin
  4. Führen Sie mehrmals eine Anfrage für die Hauptseite der Beispielarbeitslast aus:

    for i in {1..10000}; do curl -s -o /dev/null -w "%{http_code}\n"  http://"$EXTERNAL_IP"/productpage; done
    

    Mit diesem Befehl generieren Sie Traffic zur Anwendung Bookinfo. Die erwartete Ausgabe ist eine Liste der HTTP-Rückgabecodes jeder Anfrage (in diesem Fall 200 OK):

    200
    200
    200
    [...]
    

    Im Dienst-Dashboard von Kiali sollten nur Dienste angezeigt werden, die auf Instanzen im GKE-Cluster verweisen (mit dem Suffix -gke im ersten Teil der Dienstkennzeichnung). Dienste, die auf in Compute Engine ausgeführte Instanzen verweisen, gehören hingegen nicht mehr zum Mesh-Netzwerk, da Sie die zugehörigen ServiceEntries gelöscht haben.

    Wenn das Diagramm nicht angezeigt wird, aktualisieren Sie die Dashboard-Seite von Kiali:

    Erweitertes Mesh-Netzwerk visualisieren

Bereinigen

So vermeiden Sie, dass Ihrem Google Cloud Platform-Konto die in dieser Anleitung verwendeten Ressourcen in Rechnung gestellt werden:

  1. Rufen Sie in der GCP Console die Seite Projekte auf.

    Zur Seite Projekte

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie auf Löschen delete.
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Beenden, um das Projekt zu löschen.

Weitere Informationen

Hat Ihnen diese Seite weitergeholfen? Teilen Sie uns Ihr Feedback mit:

Feedback geben zu...