Version 1.9

Compute Engine-VMs zu Anthos Service Mesh hinzufügen

Einführung

Mit Anthos Service Mesh können Sie Dienste, die in verwalteten Instanzgruppen (Managed Instance Groups, MIGs) ausgeführt werden, zusammen mit Diensten ausführen, die in GKE-Clustern (Google Kubernetes Engine) im Mesh-Netzwerk ausgeführt werden. Dadurch können Sie mit den Compute Engine-Instanzen in Ihrem Mesh-Netzwerk Folgendes tun:

  • Traffic verwalten.
  • mTLS erzwingen.
  • Zugriffssteuerung auf Diensttraffic anwenden.
  • Sicher auf Google Cloud-Dienste zugreifen.
  • Messwerte erfassen sowie Logging und Tracing von Daten.
  • Dienste mit der Google Cloud Console überwachen.

Dadurch können Legacy-Anwendungen für die Nutzung von Anthos Service Mesh-Funktionen aktiviert werden, die sich nicht für die Containerisierung eignen. Außerdem ist die Einbindung dieser Arbeitslasten in die übrigen Dienste möglich.

So gehts

ASM bietet zwei zugehörige benutzerdefinierte Ressourcendefinitionen (CRDs) zur Darstellung von Arbeitslasten für virtuelle Maschinen:

  • WorkloadGroup steht für eine logische Gruppe von VM-Arbeitslasten, die gemeinsame Attribute haben. Dies ähnelt einem Deployment in Kubernetes.
  • WorkloadEntry steht für eine einzelne Instanz der Arbeitslast einer virtuellen Maschine. Dies ähnelt einem Pod in Kubernetes.
  • Ein Service kann dann die WorkloadGroup auswählen und ASM veranlassen, den Traffic zur VM-Instanz auf ähnliche Weise wie zu einem Pod weiterzuleiten. Dadurch kann die VM wie jede andere Arbeitslast im Mesh-Netzwerk ausgeführt werden.

Sie erstellen für jede Compute Engine-Instanzgruppe eine Compute Engine-Instanzvorlage, die einen Dienst-Proxy-Agent für jede Compute Engine-Instanz in dieser Gruppe angibt. Während der Installation bootet der Agent den Dienstproxy, richtet das Abfangen von Traffic ein und überwacht den Zustand des Dienstproxys während der Lebensdauer der Compute Engine-Instanz. Der Proxy stellt eine Verbindung zur Anthos Service Mesh-Steuerungsebene her und registriert jede Compute Engine-Instanz automatisch als WorkloadEntry der entsprechenden WorkloadGroup. Dadurch kann Anthos Service Mesh jede Instanz als Dienstendpunkt behandeln, wie etwa die Kubernetes-Pods im Cluster. Sie können Kubernetes-Dienste auch für VM-Arbeitslasten erstellen, genau wie für Kubernetes-Pods.

Informationen zur vertikalen oder horizontalen Skalierung von Arbeitslasten auf Compute Engine-Instanzen, beginnend mit einer MIG-Mindestgröße von null, finden Sie unter Autoscaling von Instanzgruppen.

Der Dienst-Proxy-Agent stützt sich auf VM-Manager, um dafür zu sorgen, dass der Agent auf jeder VM in der MIG installiert wird. Weitere Informationen zu Instanzgruppen und zur VM-Verwaltung finden Sie unter Verwaltete Instanzgruppe (Managed Instance Group, MIG) und VM Manager.

Beschränkungen

  • Die Steuerungsebene des Mesh-Netzwerks muss Anthos Service Mesh 1.9 oder höher sein.
  • Es werden nur von Compute Engine verwaltete Instanzgruppen unterstützt, die aus einer Compute Engine-Instanzvorlage erstellt wurden.
  • Nur das Debian-Betriebssystem in Compute Engine wird unterstützt. Weitere Informationen finden Sie unter Debian-Support.
  • Der Cluster und die VMs müssen sich im selben Netzwerk und im selben Projekt befinden und eine einzige Netzwerkschnittstelle verwenden.
  • Sie können dieses Feature ohne Anthos-Abo nutzen. Bestimmte UI-Elemente und Features in der Google Cloud Console sind jedoch nur für Anthos-Abonnenten verfügbar. Informationen dazu, welche Features Abonnenten und Nicht-Abonnenten zur Verfügung stehen, finden Sie unter Unterschiede zwischen Anthos und Anthos Service Mesh in der Benutzeroberfläche.

Vorbereitung

Prüfen Sie die folgenden Voraussetzungen, bevor Sie beginnen.

Cluster

Im Rahmen der Schritte auf dieser Seite können Sie Anthos Service Mesh installieren oder einen Cluster aktualisieren, auf dem Anthos Service Mesh bereits installiert ist. In beiden Fällen sind für diese Schritte Anthos Service Mesh 1.9 und ein Cluster erforderlich, der diese Anforderungen erfüllt. Darüber hinaus hat die Anthos Service Mesh-VM-Unterstützung zusätzliche Anforderungen:

  • Die Steuerungsebene muss in einem von Ihnen kontrollierten Cluster installiert werden. Von Google verwaltete Steuerungsebenen werden nicht unterstützt. Weitere Informationen finden Sie unter Von Google verwaltete Steuerungsebenen.
  • Verwendet Mesh-CA als Zertifizierungsstelle.
  • Verwendet Stackdriver für Telemetrie.
  • Das Canonical Service-Deployment ist aktiviert, sodass der Anthos Service Mesh-Installationsprozess automatisch aktiviert wird.

Ihr Cluster muss in einer Umgebung registriert sein. Wenn Sie den Cluster noch nicht registriert haben, kann er vom Prozess der VM-Installation im angegebenen Projekt für Sie registriert werden.

Wenn Sie ein Anthos-Abo haben, aktivieren Sie die Anthos API.

API aktivieren

Befehlszeilentools

Für den Installationsprozess sind die folgenden Tools erforderlich, die bereits bei Verwendung der Google Cloud Shell installiert sind:

  • gcloud
  • kubectl
  • kpt
  • curl
  • jq
  • awk
  • printf
  • tr
  • grep
  • tail

Skript herunterladen

In diesem Abschnitt wird beschrieben, wie Sie das Skript für VM-Onboarding herunterladen.

  1. Laden Sie das VM-Skript für Anthos Service Mesh 1.9.2 in das aktuelle Arbeitsverzeichnis herunter:

    curl https://storage.googleapis.com/csm-artifacts/asm/asm_vm_1.9 > asm_vm
    
  2. Laden Sie das SHA-256 der Datei in das aktuelle Arbeitsverzeichnis herunter:

    curl https://storage.googleapis.com/csm-artifacts/asm/asm_vm_1.9.sha256 > asm_vm.sha256
    
  3. Prüfen Sie den Download, wenn beide Dateien im selben Verzeichnis sind:

    sha256sum -c --ignore-missing asm_vm.sha256
    

    Ist die Prüfung erfolgreich, wird mit dem Befehl Folgendes ausgegeben: asm_vm: OK. Aus Gründen der Kompatibilität ist im vorherigen Befehl das Flag --ignore-missing angegeben, damit jede Version des Skripts in asm_vm umbenannt werden kann.

  4. Machen Sie das Skript ausführbar:

    chmod +x asm_vm
    

Erste Schritte

In diesem Abschnitt werden die Schritte zum Hinzufügen von Compute Engine-Instanzen zu Anthos Service Mesh erläutert.

Umgebung einrichten

  1. Verwenden Sie gcloud, um das kubectl-Tool so zu konfigurieren, dass es auf den angegebenen Cluster verweist, da Sie für einige der unten aufgeführten Schritte Änderungen direkt am Cluster vornehmen müssen.

    gcloud container clusters get-credentials CLUSTER_NAME --zone CLUSTER_LOCATION --project PROJECT_ID
    

Cluster vorbereiten

Richten Sie den Anthos Service Mesh-Cluster für VMs ein, indem Sie die Anthos Service Mesh 1.9-Steuerungsebene vorbereiten.

Wählen Sie Ihren nächsten Schritt aus, je nachdem, ob Anthos Service Mesh 1.9 im Cluster installiert ist.

Nicht installiert

Wenn Anthos Service Mesh 1.9 nicht auf Ihrem Cluster installiert ist, wird im folgenden Beispiel gezeigt, wie Sie die Optionen vm und hub-meshca hinzufügen, um die üblichen Installationsschritte für Anthos Service Mesh in Installation, Migration und Upgrade für GKE zu ändern. Außerdem wird erläutert, wie Sie das im folgenden Beispiel verwendete Skript install_asm herunterladen.

Nachdem Sie das Skript install_asm heruntergeladen haben, können Sie Anthos Service Mesh in Ihrem Cluster installieren, indem Sie die Flags --option hub-meshca, --option vm und --enable_all angeben. Weitere Informationen finden Sie unter Mesh-CA mit Environ aktivieren und Flags für die Aktivierung.

./install_asm --project_id PROJECT_ID \
--cluster_name CLUSTER_NAME \
--cluster_location CLUSTER_LOCATION \
--mode install --option vm --option hub-meshca \
--enable_all

Installiert

Wenn Anthos Service Mesh 1.9 bereits auf Ihrem Cluster installiert ist, aktualisieren Sie einfach die Steuerungsebene von Anthos Service Mesh, um VM-basierte Arbeitslasten zu unterstützen. Mit dem Skript können Sie außerdem prüfen, ob Ihre Anthos Service Mesh-Installation im Cluster für VM-Arbeitslasten bereit ist. Insbesondere aktualisiert der Unterbefehl prepare_cluster alle Überarbeitungen in Anthos Service Mesh 1.9, um für VM-Arbeitslasten bereit zu sein.

./asm_vm prepare_cluster \
--project_id PROJECT_ID \
--cluster_name CLUSTER_NAME \
--cluster_location CLUSTER_LOCATION

In den vorherigen Schritten wurden die folgenden Aktionen ausgeführt:

  1. Automatische VM-Registrierung aktivieren: Dazu wird die Variable PILOT_ENABLE_WORKLOAD_ENTRY_AUTOREGISTRATION auf "true" gesetzt. Wenn diese Option aktiviert ist, werden neue VM-Instanzen bei der WorkloadGroup registriert und neue WorkloadEntry-CRs werden erstellt, um Traffic an die VMs weiterzuleiten. In allen Anthos Service Mesh 1.9-Steuerungsebenen, die mit install_asm installiert sind, ist dies standardmäßig enthalten.

  2. Erweiterungs-Gateway installieren: Dieses Gateway heißt eastwest-Gateway und ist im Anthos Service Mesh-Konfigurationspaket definiert. Dadurch wird auch die Steuerungsebene für die VMs verfügbar gemacht.

  3. Installieren Sie die CRD IdentityProvider und registrieren Sie die Google-CR IdentityProvider, um VMs zur Authentifizierung bei der Anthos Service Mesh-Steuerungsebene zu aktivieren und mit dem Rest des Service Mesh sicher zu kommunizieren.

  4. Registrieren Sie den Cluster in einer Umgebung und aktivieren Sie Workload Identity, wenn Sie --enable_all oder --enable_registration im install_asm-Skript verwenden.

  5. Aktivieren Sie das Service Mesh-Feature in der Umgebung. Dieses Feature verwaltet die Richtlinien, die erforderlich sind, damit VMs sicher mit dem Mesh-Netzwerk kommunizieren können.

VMs hinzufügen

In diesem Abschnitt fügen Sie Ihrem Mesh-Netzwerk Compute Engine-Instanzen anhand der Instanzvorlage hinzu, die Sie mit dem Skript asm_vm erstellt haben. Das Skript generiert nur die erforderliche Konfiguration für den Dienst-Proxy-Agent. Wenn Sie weitere Konfigurationen in Ihre Instanzvorlage aufnehmen möchten, erstellen Sie eine Quellinstanzvorlage und fügen Sie diese dem Skript hinzu.

So fügen Sie Ihrem Mesh-Netzwerk VMs hinzu:

  1. Legen Sie die folgenden Umgebungsvariablen fest, um sie in späteren Schritten verwenden zu können. Legen Sie diese Variablen für jede VM-Arbeitslast fest:

    • WORKLOAD_NAME ist der Name der Arbeitslast, zu der die VM gehört. Dabei muss es sich um eine DNS-1123-konforme Subdomain handeln, die aus aus alphanumerischen Zeichen in Kleinbuchstaben besteht.
    • WORKLOAD_VERSION ist die Version der Arbeitslast, zu der die VM gehört. Optional.
    • WORKLOAD_SERVICE_ACCOUNT ist das GCP-Dienstkonto, als das die VM ausgeführt wird.
    • WORKLOAD_NAMESPACE ist der Namespace für die Arbeitslast.
    • ASM_INSTANCE_TEMPLATE ist der Name der zu erstellenden Instanzvorlage. In Compute Engine-Instanzvorlagen sind keine Unterstriche erlaubt.
    • SOURCE_INSTANCE_TEMPLATE ist der Name der Vorlage, auf der die generierte Vorlage basiert. Optional.
  2. Erstellen Sie den Namespace für die VM-Arbeitslasten, sofern noch nicht vorhanden:

    kubectl create ns WORKLOAD_NAMESPACE
    
  3. Kennzeichnen Sie den Namespace mit der Überarbeitung der Steuerungsebene. Ein Beispiel dafür, wie Sie die Überarbeitung der Steuerungsebene finden, die als REVISION im folgenden Beispiel angezeigt wird, finden Sie unter Arbeitslasten bereitstellen und noch einmal bereitstellen.

    kubectl label ns WORKLOAD_NAMESPACE istio-injection- istio.io/rev=REVISION --overwrite
    
  4. Erstellen Sie WorkloadGroup für die zu registrierenden VMs:

    kubectl apply -f - << EOF
    apiVersion: networking.istio.io/v1alpha3
    kind: WorkloadGroup
    metadata:
     name: WORKLOAD_NAME
     namespace: WORKLOAD_NAMESPACE
    spec:
     metadata:
       labels:
         app.kubernetes.io/name: WORKLOAD_NAME
         app.kubernetes.io/version: WORKLOAD_VERSION
       annotations:
         security.cloud.google.com/IdentityProvider: google
     template:
       serviceAccount: WORKLOAD_SERVICE_ACCOUNT
    EOF
    
    Feld Beschreibung
    name Der Name der Arbeitslast, zu der die VM gehört.
    namespace Der Namespace, zu dem die Arbeitslast gehört.
    app.kubernetes.io/name Die empfohlenen Labels für Kubernetes-Anwendungen Sie können für Ihre VM-Arbeitslasten eigene Labels verwenden.
    app.kubernetes.io/version Die empfohlenen Labels für Kubernetes-Anwendungen Sie können für Ihre VM-Arbeitslasten eigene Labels verwenden.
    serviceAccount Die von der VM und dem Projekt verwendete Dienstkontoidentität, die als Teil der Identität der Arbeitslast im SPIFFE-Format verwendet wird. Weitere Informationen finden Sie unter Dienstkonten.
    security.cloud.google.com/IdentityProvider Der Identitätsanbieter, der von der VM verwendet wird und bereits in Ihrem Cluster registriert sein sollte. Für Compute Engine-VMs sollte er auf google festgelegt sein. Der "IdentityProvider" gibt der Steuerungsebene an, wie die Anmeldedaten der VM authentifiziert und das Dienstkonto der VM extrahiert werden soll.
  5. Führen Sie das Skript asm_vm mit den folgenden Optionen und Flags aus, um eine Instanzvorlage für Ihre Anthos Service Mesh Compute Engine-Instanzen zu erstellen.

    Das Skript prüft die Voraussetzungen für Cluster, fügt VM-Labels für Anthos Service Mesh hinzu, generiert die benutzerdefinierte Metadatenkonfiguration für den Dienst-Proxy-Agent und erstellt eine neue Instanzvorlage.

    Wenn Sie bereits eine Instanzvorlage haben, auf der das Skript basieren soll, können Sie die Option --source_instance_template angeben. Wenn Ihre vorhandene Instanzvorlage ein Startskript enthält, das eine Netzwerkverbindung erfordert, sollte das Skript gegenüber temporären Netzwerkverbindungsprobleme robust sein. In der Demoanwendung finden Sie ein Beispiel für das Erhöhen von Ausfallsicherheit gegenüber vorübergehenden Netzwerkunterbrechungen.

    ./asm_vm create_gce_instance_template \
    ASM_INSTANCE_TEMPLATE \
    --project_id PROJECT_ID \
    --cluster_location CLUSTER_LOCATION \
    --cluster_name CLUSTER_NAME \
    --workload_name WORKLOAD_NAME \
    --workload_namespace WORKLOAD_NAMESPACE \
    --source_instance_template SOURCE_INSTANCE_TEMPLATE
    

    Optionen

    Option Beschreibung
    -p|--project_id PROJECT_ID Die Projekt-ID des Projekts, in dem der Cluster erstellt wurde.
    -n|--cluster_name CLUSTER_NAME Der Name des Clusters.
    -l|--cluster_location CLUSTER_LOCATION Entweder die Zone (bei Einzelzonenclustern) oder die Region (bei regionalen Clustern), in der der Cluster erstellt wurde.
    -w|--workload_name WORKLOAD_NAME Der Name der Arbeitslast, die die Compute Engine-Instanzen darstellen.
    --workload_namespace WORKLOAD_NAMESPACE Optional. Der Namespace der Arbeitslast. Die Standardeinstellung ist "default".
    -s|--source_instance_template SOURCE_INSTANCE_TEMPLATE_NAME Optional. Eine vorhandene Instanzvorlage, die als Basis für die Anthos Service Mesh-Instanzvorlage in Compute Engine verwendet wird. Wenn nichts angegeben ist, wird eine Instanzvorlage mit Standardwerten erstellt.

    Flags

    Flag Beschreibung
    -v|--verbose Befehle vor und nach der Ausführung ausgeben.
    --dry_run Befehle ausgeben, aber nicht ausführen.
    --only_validate Validierung ausführen, aber keine neue Compute Engine-Instanzvorlage erstellen.
    -h|--help Zeigt eine Hilfemeldung an, in der die Optionen und Flags beschrieben werden und der Vorgang beendet wird.
  6. Legen Sie die folgenden Umgebungsvariablen für jede von Ihnen erstellte MIG fest:

    • INSTANCE_GROUP_NAME ist der Name der zu erstellenden Compute Engine-Instanzgruppe.
    • ASM_INSTANCE_TEMPLATE ist der Name der zu erstellenden Instanzvorlage. In den Namen von Compute Engine-Instanzvorlagen sind keine Unterstriche erlaubt.
    • INSTANCE_GROUP_ZONE ist die Zone der zu erstellenden Compute Engine-Instanzgruppe.
    • PROJECT_ID ist die Projekt-ID des Projekts, in dem der Cluster erstellt wurde.
    • SIZE ist die Größe der zu erstellenden Instanzgruppe. Sie kann nach dem Erstellen der Instanzgruppe geändert werden.
    • WORKLOAD_NAME ist der Name der Arbeitslast, zu der die VM gehört.
    • WORKLOAD_NAMESPACE ist der Namespace für die Arbeitslast.
  7. Erstellen Sie mit den in den vorherigen Schritten erstellten Variablen eine verwaltete Instanzgruppe für die VM-Arbeitslasten:

    gcloud compute instance-groups managed create \
    INSTANCE_GROUP_NAME \
    --template ASM_INSTANCE_TEMPLATE \
    --zone=INSTANCE_GROUP_ZONE \
    --project=PROJECT_ID \
    --size=SIZE
    

    Informationen zur vertikalen oder horizontalen Skalierung von Arbeitslasten auf Compute Engine-Instanzen, beginnend mit einer zonalen oder regionalen MIG-Größe von null, finden Sie unter Autoscaling von Instanzgruppen. Weitere Informationen zum Erstellen von Gruppen finden Sie unter gcloud compute instance-groups managed create.

    Beim Starten der Instanz wird sie automatisch mit der Anthos Service Mesh-Steuerungsebene im Cluster authentifiziert. Die Steuerungsebene registriert dann jede VM als WorkloadEntry.

  8. Wenn die VM-Instanz in der MIG den Startvorgang abgeschlossen hat, können Sie die registrierten VMs mit dem folgenden Befehl im Namespace der Arbeitslast anzeigen lassen:

       kubectl get workloadentry -n WORKLOAD_NAMESPACE
    
  9. Fügen Sie einen Kubernetes-Dienst hinzu, um VM-Arbeitslasten bereitzustellen, die oben hinzugefügt wurden. Achten Sie darauf, dass der Dienst das entsprechende Label auf der oben registrierten VM WorkloadGroup auswählt, damit der Traffic richtig weitergeleitet wird.

    Im folgenden Beispiel wird ein Kubernetes-Dienst mit dem Namen WORKLOAD_NAME im Namespace WORKLOAD_NAMESPACE erstellt, der VM-Arbeitslasten mit dem Label app.kubernetes.io/name: WORKLOAD_NAME unter HTTP-Port 80 verfügbar macht.

    kubectl apply -f - << EOF
    apiVersion: v1
    kind: Service
    metadata:
     name: WORKLOAD_NAME
     namespace: WORKLOAD_NAMESPACE
     labels:
       asm_resource_type: VM
    spec:
     ports:
     - port: 80
       name: http
     selector:
       app.kubernetes.io/name: WORKLOAD_NAME
    EOF
    

    Weitere Informationen zum Erstellen eines Kubernetes-Dienstes finden Sie unter https://kubernetes.io/docs/concepts/services-networking/service/#defining-a-service.

  10. Wie Sie eine Beispielanwendung auf Ihrer VM verwenden, erfahren Sie unter Beispielanwendung bereitstellen.

Upgrade der Anthos Service Mesh-Steuerungsebene

Aktualisieren Sie die Anthos Service Mesh-Steuerungsebene auf eine neue Version. Folgen Sie dazu der Anleitung unter Anthos Service Mesh auf die neueste Version aktualisieren. Nach der Installation einer neuen Version der Anthos Service Mesh-Steuerungsebene stellen Sie Ihre Kubernetes-Arbeitslasten neu bereit, wie unter Arbeitslasten bereitstellen und neu bereitstellen beschrieben.

Erstellen Sie für VM-Arbeitslasten eine neue Instanzvorlage und führen Sie ein Rolling Update für die VMs in der MIG durch:

  1. Verwenden Sie den folgenden Befehl, um das Überarbeitungslabel für istiod zu finden:

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

    Die Ausgabe des Befehls sieht in etwa so aus: Beachten Sie, dass sich die Ausgabe für Migrationen geringfügig von der Ausgabe für Upgrades unterscheidet. Die folgende Beispielausgabe stammt von einer Migration.

    NAME                                READY   STATUS    RESTARTS   AGE   LABELS
    istiod-7744bc8dd7-qhlss             1/1     Running   0          49m   app=istiod,istio.io/rev=default,istio=pilot,pod-template-hash=7744bc8dd7
    istiod-asm-192-1-85d86774f7-flrt2   1/1     Running   0          26m   app=istiod,istio.io/rev=asm-192-1,istio=istiod,pod-template-hash=85d86774f7
    istiod-asm-192-1-85d86774f7-tcwtn   1/1     Running   0          26m   app=istiod,istio.io/rev=asm-192-1,istio=istiod,pod-template-hash=85d86774f7
    1. Notieren Sie sich aus der Ausgabe in der Spalte LABELS den Wert des istiod-Überarbeitungslabels für die neue Version, der auf das Präfix istio.io/rev= folgt. In diesem Beispiel lautet der Wert asm-192-1.

    2. Notieren Sie sich außerdem den Wert im Überarbeitungslabel der alten istiod-Version. Diesen Wert benötigen Sie, um die alte Version von istiod zu löschen, wenn Sie die Arbeitslasten in die neue Version verschoben haben. In der Beispielausgabe lautet der Wert im Überarbeitungslabel für die alte istiod-Version default.

  2. Fügen Sie das Überarbeitungslabel einem Namespace hinzu und entfernen Sie das istio-injection-Label (falls vorhanden). Geben Sie im folgenden Befehl für REVISION den Wert an, der der neuen Überarbeitung von istiod entspricht.

    kubectl label namespace NAMESPACE istio.io/rev=REVISION istio-injection- --overwrite

    Wenn in der Ausgabe "istio-injection not found" angezeigt wird, können Sie dies ignorieren. Das bedeutet, dass der Namespace bisher nicht das Label istio-injection hatte. Da die automatische Injektion fehlschlägt, wenn ein Namespace sowohl das istio-injection als auch das Überarbeitungslabel enthält, enthalten alle kubectl label-Befehle in der Anthos Service Mesh-Dokumentation das Label istio-injection.

  3. Erstellen Sie mithilfe des Skripts asm_vm eine neue Instanzvorlage. Achten Sie darauf, einen neuen Instanzvorlagennamen zu verwenden und dieselbe Quellinstanzvorlage anzugeben, wenn Sie für dieselbe Arbeitslast eine solche Vorlage haben.

    ./asm_vm create_gce_instance_template \
    NEW_ASM_INSTANCE_TEMPLATE \
    --project_id PROJECT_ID \
    --cluster_location CLUSTER_LOCATION \
    --cluster_name CLUSTER_NAME \
    --workload_name WORKLOAD_NAME \
    --workload_namespace WORKLOAD_NAMESPACE \
    --source_instance_template SOURCE_INSTANCE_TEMPLATE
    
  4. Führen Sie ein Rolling Update für Ihre vorhandene MIG für die Arbeitslast durch.

    Weitere Informationen finden Sie unter Einfaches Rolling Update starten.

    gcloud compute instance-groups managed rolling-action start-update INSTANCE_GROUP_NAME \
    --version=template=NEW_ASM_INSTANCE_TEMPLATE \
    --zone=INSTANCE_GROUP_ZONE
    
  5. Testen Sie die VM-Arbeitslast, um zu prüfen, ob sie wie erwartet funktioniert.

VM-Anwendungen aktualisieren

Wenn Änderungen an der Anwendung vorgenommen wurden, einschließlich Änderungen an der WorkloadGroup und/oder Änderungen an der Quellinstanzvorlage, ist eine neue Instanzvorlage erforderlich, um die MIG Ihrer VM-Arbeitslasten zu aktualisieren.

Wenn die Änderung WorkloadGroup angewendet und/oder die neue Quellinstanzvorlage erstellt wird, erstellen Sie eine neue Instanzvorlage für Anthos Service Mesh und führen ein Rolling Update für die VMs in der MIG durch.

  1. Erstellen Sie mithilfe des Skripts asm_vm eine neue Instanzvorlage. Achten Sie darauf, dass Sie einen neuen Instanzvorlagennamen verwenden. Geben Sie außerdem die neue Quellinstanzvorlage an, wenn Sie eine für die Anwendungsaktualisierung erstellt haben.

    ./asm_vm create_gce_instance_template \
    NEW_ASM_INSTANCE_TEMPLATE \
    --project_id PROJECT_ID \
    --cluster_location CLUSTER_LOCATION \
    --cluster_name CLUSTER_NAME \
    --workload_name WORKLOAD_NAME \
    --workload_namespace WORKLOAD_NAMESPACE \
    --source_instance_template NEW_SOURCE_INSTANCE_TEMPLATE
    
  2. Führen Sie ein Rolling Update für Ihre vorhandene MIG für die Arbeitslast durch. Weitere Informationen zur Verwendung von Rolling Updates von MIGs finden Sie unter Einfaches Rolling Update starten.

    gcloud compute instance-groups managed rolling-action start-update INSTANCE_GROUP_NAME \
    --version=template=NEW_ASM_INSTANCE_TEMPLATE \
    --zone=INSTANCE_GROUP_ZONE
    
  3. Testen Sie die VM-Arbeitslast, um zu prüfen, ob sie wie erwartet funktioniert.

Beispielanwendung bereitstellen

Installieren Sie die Beispielanwendung für BookInfo, um zu zeigen, dass Ihre neue Mesh-Konfiguration ordnungsgemäß funktioniert. In diesem Beispiel wird eine MySQL-Datenbank auf der VM ausgeführt und der Bewertungsdienst liest die Bewertungswerte aus der Datenbank.

BookInfo auf dem Cluster installieren

Führen Sie die folgenden Schritte aus, um die Dienste der BookInfo-Anwendung mit den in jedem Dienst eingefügten Sidecar-Proxys bereitzustellen. Die BookInfo-Anwendung wird im Namespace default bereitgestellt.

  1. Wechseln Sie in der Befehlszeile des Computers, auf dem Sie Anthos Service Mesh installiert haben, zum Stammverzeichnis des Anthos Service Mesh-Installationsverzeichnisses, das Sie im Schritt Skript herunterladen erstellt haben.

  2. Verwenden Sie den folgenden Befehl, um das automatische Sidecar-Injektion zu aktivieren und das Label auf istiod zu finden. Dieses enthält den Wert des Überarbeitungslabels, der in späteren Schritten verwendet werden soll.

    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-192-1-5788d57586-bljj4   1/1     Running   0          23h   app=istiod,istio.io/rev=asm-192-1,istio=istiod,pod-template-hash=5788d57586
    istiod-asm-192-1-5788d57586-vsklm   1/1     Running   1          23h   app=istiod,istio.io/rev=asm-192-1,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-192-1.

  3. Wenden Sie das Überarbeitungslabel auf den default-Namespace an. Im folgenden Befehl ist REVISION der Wert des Überarbeitungslabels istiod, den Sie im vorherigen Schritt notiert haben.

    kubectl label namespace default istio-injection- istio.io/rev=REVISION --overwrite
    

    Sie können die Nachricht "istio-injection not found" in der Ausgabe ignorieren. Das bedeutet, dass der Namespace bisher nicht das Label istio-injection hatte, was bei Neuinstallationen von Anthos Service Mesh oder neuen Bereitstellungen zu erwarten wäre. Da die automatische Injektion fehlschlägt, wenn ein Namespace sowohl das istio-injection als auch das Überarbeitungslabel enthält, enthalten alle kubectl label-Befehle in der Anthos Service Mesh-Dokumentation das Label istio-injection.

  4. Stellen Sie die Anwendung mit kubectl im Standard-Namespace bereit:

    kubectl apply -f samples/bookinfo/platform/kube/bookinfo.yaml
    
  5. Führen Sie die folgenden Befehle aus, um zu bestätigen, dass die Anwendung fehlerfrei bereitgestellt wurde:

    kubectl get services
    

    Erwartete Ausgabe:

    NAME                       CLUSTER-IP   EXTERNAL-IP   PORT(S)              AGE
    details                    10.0.0.31    <none>        9080/TCP             6m
    kubernetes                 10.0.0.1     <none>        443/TCP              7d
    productpage                10.0.0.120   <none>        9080/TCP             6m
    ratings                    10.0.0.15    <none>        9080/TCP             6m
    reviews                    10.0.0.170   <none>        9080/TCP             6m

    und

    kubectl get pod
    

    Erwartete Ausgabe:

    NAME                                        READY     STATUS    RESTARTS   AGE
    details-v1-1520924117-48z17                 2/2       Running   0          6m
    productpage-v1-560495357-jk1lz              2/2       Running   0          6m
    ratings-v1-734492171-rnr5l                  2/2       Running   0          6m
    reviews-v1-874083890-f0qf0                  2/2       Running   0          6m
    reviews-v2-1343845940-b34q5                 2/2       Running   0          6m
    reviews-v3-1813607990-8ch52                 2/2       Running   0          6m
  6. Definieren Sie abschließend das Ingress-Gateway-Routing für die Anwendung:

    kubectl apply -f samples/bookinfo/networking/bookinfo-gateway.yaml
    

    Erwartete Ausgabe:

    gateway.networking.istio.io/bookinfo-gateway created
    virtualservice.networking.istio.io/bookinfo created
  7. Prüfen Sie, ob die Produktseite zugänglich ist.

    export INGRESS_HOST=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
    export INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].port}')
    export GATEWAY_URL="${INGRESS_HOST}:${INGRESS_PORT}"
    curl -s "http://${GATEWAY_URL}/productpage" | grep -o "<title>.*</title>"
    

    Erwartete Ausgabe:

    <title>Simple Bookstore App</title>
    

Compute Engine-Instanzen erstellen und MySQL installieren

In diesem Schritt erstellen Sie eine Compute Engine-Instanzvorlage für die auf der VM ausgeführte MySQL-Instanz. Ausführlichere Schritte finden Sie unter Bookinfo mit einer virtuellen Maschine.

  1. Erstellen Sie eine Compute Engine-Instanzvorlage, die ein Startskript enthält, um MySQL zu installieren und beim Start eine Bewertungsdatenbank hinzuzufügen.

    cat << "EOF" > init-mysql
    #!/bin/bash
    
    # Wait until Envoy is ready before installing mysql
    while true; do
      rt=$(curl -s 127.0.0.1:15000/ready)
      if [[ $? -eq 0 ]] && [[ "${rt}" -eq "LIVE" ]]; then
        echo "envoy is ready"
        break
      fi
      sleep 1
    done
    
    sudo apt-get update && sudo apt-get install -y mariadb-server
    
    sudo sed -i '/bind-address/c\bind-address  = 0.0.0.0' /etc/mysql/mariadb.conf.d/50-server.cnf
    
    cat <<EOD | sudo mysql
    # Grant access to root
    GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;
    
    # Grant root access to other IPs
    CREATE USER 'root'@'%' IDENTIFIED BY 'password';
    GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' WITH GRANT OPTION;
    FLUSH PRIVILEGES;
    quit;
    EOD
    
    sudo systemctl restart mysql
    
    curl -LO https://raw.githubusercontent.com/istio/istio/release-1.9/samples/bookinfo/src/mysql/mysqldb-init.sql
    
    mysql -u root -ppassword < mysqldb-init.sql
    EOF
    
    gcloud compute \
    --project=PROJECT_ID \
    instance-templates create mysql-instance-template \
    --machine-type=e2-medium \
    --metadata-from-file=startup-script=init-mysql \
    --image=debian-10-buster-v20201014 \
    --image-project=debian-cloud \
    --boot-disk-size=10GB
    
  2. Erstellen Sie eine WorkloadGroup für die MySQL-Arbeitslast

    kubectl apply -f - << EOF
    apiVersion: networking.istio.io/v1alpha3
    kind: WorkloadGroup
    metadata:
     name: mysql
     namespace: default
    spec:
     metadata:
       labels:
         app.kubernetes.io/name: mysql
       annotations:
         security.cloud.google.com/IdentityProvider: google
     template:
       serviceAccount: WORKLOAD_SERVICE_ACCOUNT
    EOF
    
  3. Erstellen Sie mithilfe des VM-Skripts oben eine neue Instanzvorlage, um die Instanzen für Ihr Mesh-Netzwerk vorzubereiten.

    ./asm_vm create_gce_instance_template \
    asm-mysql-instance-template \
    --project_id PROJECT_ID \
    --cluster_location CLUSTER_LOCATION \
    --cluster_name CLUSTER_NAME \
    --workload_name mysql \
    --source_instance_template mysql-instance-template
    
  4. Erstellen Sie eine Compute Engine-MIG mit der neu erstellten Instanzvorlage.

    gcloud compute instance-groups managed create mysql-instance \
    --template asm-mysql-instance-template \
    --zone=us-central1-c \
    --project=PROJECT_ID \
    --size=1
    

Dienste erstellen

Erstellen Sie einen Kubernetes-Dienst für den MySQL-Dienst.

  1. Erstellen Sie mit dem folgenden Befehl einen Kubernetes-Dienst:

    kubectl apply -f - << EOF
    apiVersion: v1
    kind: Service
    metadata:
     name: mysql
     namespace: default
     labels:
       asm_resource_type: VM
    spec:
     ports:
     - name: mysql
       port: 3306
       protocol: TCP
       targetPort: 3306
     selector:
       app.kubernetes.io/name: mysql
    EOF
    

Anthos-UI-Dashboard verwenden

Klicken Sie in der linken Hauptnavigationsleiste auf Anthos > Service Mesh, um den VM-basierten Dienst aufzurufen, den Sie erstellt haben. Es wird eine Tabelle der Dienste angezeigt, die in Ihrem Mesh-Netzwerk ausgeführt werden. Der Dienst, den Sie hinzugefügt haben, sollte in der Tabelle mit dem Type-Wert VM und einigen übergeordneten Messwerten angezeigt werden. Klicken Sie zum Aufrufen weiterer Telemetriedaten aus Ihrem VM-basierten Dienst auf den Dienstnamen. Daraufhin wird das Dashboard auf Dienstebene angezeigt.

Weitere Informationen zur Verwendung des Anthos-UI-Dashboards finden Sie unter Anthos Service Mesh in der Cloud Console kennenlernen.

Traffic zu den VM-Arbeitslasten verwalten

Sie können die Netzwerkregeln ändern, um den ein- und ausgehenden Traffic der VM(s) zu steuern.

Traffic zu einem neuen Bewertungsdienst (Pod-zu-VM) steuern

Erstellen Sie einen weiteren Bewertungsdienst in BookInfo, der die oben erstellte MySQL-Instanz als Datenquelle verwendet, und geben Sie eine Routingregel an, die den Rezensionsdienst zur Verwendung des neuen Bewertungsdienstes zwingt.

  1. Erstellen Sie einen neuen Bewertungsdienst zur Verwendung der MySQL-Instanz.

    kubectl apply -f - << EOF
    apiVersion: apps/v1
    kind: Deployment
    metadata:
     name: ratings-v2-mysql-vm
     labels:
       app: ratings
       version: v2-mysql-vm
    spec:
     replicas: 1
     selector:
       matchLabels:
         app: ratings
         version: v2-mysql-vm
     template:
       metadata:
         labels:
           app: ratings
           version: v2-mysql-vm
       spec:
         serviceAccountName: bookinfo-ratings
         containers:
         - name: ratings
           image: docker.io/istio/examples-bookinfo-ratings-v2:1.16.2
           imagePullPolicy: IfNotPresent
           env:
             - name: DB_TYPE
               value: "mysql"
             - name: MYSQL_DB_HOST
               value: mysql.default.svc.cluster.local
             - name: MYSQL_DB_PORT
               value: "3306"
             - name: MYSQL_DB_USER
               value: root
             - name: MYSQL_DB_PASSWORD
               value: password
           ports:
           - containerPort: 9080
    EOF
    
  2. Erstellen Sie eine Routingregel.

    kubectl apply -f - << EOF
    apiVersion: networking.istio.io/v1alpha3
    kind: VirtualService
    metadata:
     name: reviews
    spec:
     hosts:
     - reviews
     http:
     - route:
       - destination:
           host: reviews
           subset: v3
    ---
    apiVersion: networking.istio.io/v1alpha3
    kind: VirtualService
    metadata:
     name: ratings
    spec:
     hosts:
     - ratings
     http:
     - route:
       - destination:
           host: ratings
           subset: v2-mysql-vm
    EOF
    
  3. Wenden Sie Zielregeln für die erstellten Dienste an.

    kubectl apply -f - << EOF
    apiVersion: networking.istio.io/v1alpha3
    kind: DestinationRule
    metadata:
     name: reviews
    spec:
     host: reviews
     subsets:
     - name: v1
       labels:
         version: v1
     - name: v2
       labels:
         version: v2
     - name: v3
       labels:
         version: v3
    ---
    apiVersion: networking.istio.io/v1alpha3
    kind: DestinationRule
    metadata:
     name: ratings
    spec:
     host: ratings
     subsets:
     - name: v1
       labels:
         version: v1
     - name: v2
       labels:
         version: v2
     - name: v2-mysql
       labels:
         version: v2-mysql
     - name: v2-mysql-vm
       labels:
         version: v2-mysql-vm
    EOF
    

Anwendungsbereitstellung validieren

Zum Prüfen, ob die BookInfo-Anwendung funktioniert, müssen Sie Traffic an das Ingress-Gateway senden.

  • Wenn Sie Anthos Service Mesh in GKE installiert haben, rufen Sie die externe IP-Adresse des Ingress-Gateways ab, das Sie in den vorherigen Schritten erstellt haben:

    kubectl get svc istio-ingressgateway -n istio-system
    

    Ausgabe:

    NAME                   TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)                                      AGE
    istio-ingressgateway   LoadBalancer   10.19.247.233   35.239.7.64   80:31380/TCP,443:31390/TCP,31400:31400/TCP   27m

    In diesem Beispiel lautet die IP-Adresse des Ingress-Dienstes 35.239.7.64.

Anwendung testen

  1. Prüfen Sie, ob die BookInfo-Anwendung mit curl ausgeführt wird:

    curl -I http://EXTERNAL_IP/productpage
    

    Wenn in der Antwort 200 angezeigt wird, bedeutet dies, dass die Anwendung fehlerfrei mit Anthos Service Mesh funktioniert.

  2. Geben Sie die folgende Adresse in Ihren Browser ein, um die BookInfo-Webseite aufzurufen:

    http://EXTERNAL_IP/productpage
    
  3. Prüfen Sie auf der Startseite der BookInfo-Anwendung, dass fünf Sterne von Reviewer1 und vier Sternen von Reviewer2 angezeigt werden.

Sicherheit auf VM-Arbeitslasten erzwingen

Das Erzwingen der Sicherheit auf den VM-Arbeitslasten entspricht dem Erzwingen der Sicherheit auf den Kubernetes-Arbeitslasten. Weitere Informationen finden Sie unter Istio-Sicherheit.

Nachdem Sie die vorherigen Schritte abgeschlossen haben, verfügt Ihre Compute Engine-VM über ein von Google ausgestelltes Arbeitslastzertifikat. Der Wert SubjectAlternativeName im Zertifikat zeigt die Anthos Workload Identity der VM im Format spiffe://<workload_identity_pool>/ns/WORKLOAD_NAMESPACE/sa/WORKLOAD_SERVICE_ACCOUNT an.

Weitere Informationen finden Sie unter Workload Identity-Pool.

Strikten mTLS-Modus für das Mesh-Netzwerk aktivieren

Wenden Sie die folgende YAML-Datei an, um im gesamten Mesh-Netzwerk den strikten mTLS-Modus zu erzwingen.

kubectl apply -f - << EOF
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: default
  namespace: istio-system
spec:
  mtls:
    mode: STRICT
EOF

Autorisierung für Traffic von Dienst zu Dienst

Verwenden Sie AuthorizationPolicy, um den Zugriff zwischen den Anwendungen auf Ihrer Compute Engine-VM und anderen Mesh-Arbeitslasten (z. B. im GKE-Cluster) zu steuern.

Beispiel: Kubernetes-Arbeitslasten Zugriff auf Compute Engine-VMs verweigern

Die folgende Autorisierungsrichtlinie verweigert einer Kubernetes-Arbeitslast ratings den Zugriff auf Compute Engine-VM-Arbeitslasten, die den MySQL-Server ratings bereitstellen.

kubectl apply -f - << EOF
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: mysql-deny
  namespace: default
spec:
  selector:
    matchLabels:
      app: ratings
      app.kubernetes.io/name: mysql
  action: DENY
  rules:
  - from:
    - source:
        principals: ["cluster.local/ns/default/sa/bookinfo-ratings"]
EOF

Nachdem Sie das Beispiel AuthorizationPolicy angewendet haben, sollte auf der Produktseite im Abschnitt zu Buchrezensionen die Fehlermeldung Ratings service is currently unavailable angezeigt werden.

Cloud Monitoring-Agent installieren

Sie können den Cloud Monitoring-Agent installieren, um System- und Anwendungsmesswerte aus Ihren VM-Instanzen zu erfassen und zu überwachen. So können Sie wichtige Messwerte überwachen, z. B. die CPU- und Speicherauslastung für den Agent.

Weitere Informationen finden Sie in der Dokumentation zum Cloud Monitoring-Agent.

Fehlerbehebung

Tipps zur Fehlerbehebung finden Sie unter Fehlerbehebung bei der VM-Unterstützung.