IAP in Anthos Service Mesh einbinden

In dieser Anleitung wird beschrieben, wie Sie Identity-Aware Proxy (IAP) in Anthos Service Mesh einbinden. Mit der IAP-Einbindung in Anthos Service Mesh können Sie sicher auf Dienste zugreifen, die auf den BeyondCorp-Prinzipien von Google beruhen. IAP überprüft die Nutzeridentität und den Kontext der Anfrage, um festzustellen, ob ein Nutzer Zugriff auf eine Anwendung oder eine Ressource erhält. Die IAP-Integration in Anthos Service Mesh bietet folgende Vorteile:

  • Vollständige Steuerung des kontextsensitiven Zugriffs auf die Arbeitslasten, die in Anthos Service Mesh ausgeführt werden. Sie können detaillierte Zugriffsrichtlinien anhand von Attributen der ursprünglichen Anfrage festlegen, z. B. Nutzeridentität, IP-Adresse und Gerätetyp. Sie können Ihre Zugriffsrichtlinien mit Einschränkungen kombinieren, die auf dem Hostnamen und Pfad einer Anfrage-URL beruhen.

  • Aktivieren Sie die Unterstützung für kontextsensitive Anforderungen in der Anthos Service Mesh-Autorisierung.

  • Skalierbarer, sicherer und hochverfügbarer Zugriff auf Ihre Anwendung über einen Google Cloud-Load-Balancer. Das leistungsfähige Load-Balancing bietet einen integrierten Schutz vor DDoS-Angriffen (Distributed Denial-of-Service) und Unterstützung für eine globale Anycast-IP-Adressierung.

Lernziele

  • Richten Sie das Gerät ein:
    1. Richten Sie Ihr Google Cloud-Projekt ein, um die Berechtigungen zu gewähren und die für IAP erforderlichen Google APIs zu aktivieren.
    2. Reservieren Sie eine externe statische IP-Adresse und konfigurieren Sie einen Domainnamen für die Verwendung der IP-Adresse, die der Load-Balancer benötigt.
    3. Richten Sie einen neuen GKE-Cluster (Google Kubernetes Engine) mit den für die Einbindung von IAP in Anthos Service Mesh erforderlichen Optionen ein.
    4. Installieren Sie Anthos Service Mesh mit den für die Einbindung erforderlichen Optionen.
    5. Beispielanwendung bereitstellen
    6. Stellen Sie den Load-Balancer bereit:

  • Aktivieren Sie IAP.

  • RCToken-Unterstützung im Service Mesh aktivieren

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweise

Voraussetzungen

  • Sie benötigen eine Anthos-Testlizenz oder ein Anthos-Abo. Weitere Informationen finden Sie in der Preisübersicht zu Anthos.

  • Ihr GKE-Cluster muss die folgenden Anforderungen erfüllen:

    • Mindestens vier Knoten.
    • Der minimale Maschinentyp ist e2-standard-4 und enthält vier vCPUs.
    • Verwenden Sie eine Release-Version anstelle einer statischen Version von GKE.

  • Für die Aufnahme in das Service Mesh müssen Dienstports benannt werden und der Name muss das Protokoll des Ports in der folgenden Syntax enthalten: name: protocol[-suffix], wobei die eckigen Klammern ein optionales Suffix angeben, das mit einem Bindestrich beginnen muss. Weitere Informationen finden Sie unter Dienstports benennen.

  • Wenn Sie Anthos Service Mesh auf einem privaten Cluster installieren, müssen Sie eine Firewallregel zum Öffnen von Port 15017 hinzufügen, um die automatische Sidecar-Injektion zu verwenden. Wenn Sie die Firewallregel nicht hinzufügen und die automatische Sidecar-Injektion aktiviert ist, erhalten Sie beim Bereitstellen von Arbeitslasten eine Fehlermeldung. Weitere Informationen zum Hinzufügen einer Firewallregel finden Sie unter Firewallregeln für bestimmte Anwendungsfälle hinzufügen.

  • Wenn Sie in Ihrer Organisation einen Dienstperimeter erstellt haben, müssen Sie möglicherweise den Mesh CA-Dienst dem Perimeter hinzufügen. Weitere Informationen finden Sie unter Mesh CA einem Dienstperimeter hinzufügen.

Umgebung einrichten

Bei Installationen in Google Kubernetes Engine können Sie den Installationsanleitungen mit Cloud Shell, einer browserinternen Befehlszeile zu Ihren Google Cloud-Ressourcen oder auf Ihrem Computer mit Linux oder macOS folgen.

Option A: Cloud Shell verwenden

Cloud Shell stellt eine g1-small Compute Engine-VM bereit, auf der ein Debian-basiertes Linux-Betriebssystem ausgeführt wird. Cloud Shell bietet folgende Vorteile:

  • Cloud Shell enthält die benötigten Befehlszeilentools gcloud, kubectl und helm.

  • Ihr $HOME-Verzeichnis in Cloud Shell verfügt über 5 GB nichtflüchtigen Speicher.

  • Es stehen verschiedene Texteditoren zur Auswahl:

    • Code-Editor, auf den Sie zugreifen, indem Sie oben im Cloud Shell-Fenster auf klicken.

    • Emacs, Vim oder Nano, auf die Sie in Cloud Shell über die Befehlszeile zugreifen.

So verwenden Sie Cloud Shell:

  1. Öffnen Sie die Google Cloud Console.
  2. Wählen Sie Ihr Google Cloud-Projekt aus.

  3. Klicken Sie im oberen Bereich des Google Cloud Console-Fensters auf Cloud Shell aktivieren.

    Google Cloud Platform Console

    Im unteren Bereich der Google Cloud Console wird ein neues Feld mit einer Cloud Shell-Sitzung und einer Befehlszeilen-Eingabeaufforderung geöffnet.

    Cloud Shell-Sitzung

  4. Aktualisieren Sie die Komponenten:

    gcloud components update

    Der Befehl meldet eine Ausgabe, die in etwa so aussieht:

    ERROR: (gcloud.components.update)
You cannot perform this action because the gcloud CLI component manager
is disabled for this installation. You can run the following command
to achieve the same result for this installation:

sudo apt-get update && sudo apt-get --only-upgrade install ...

  5. Kopieren Sie den langen Befehl und fügen Sie ihn ein, um die Komponenten zu aktualisieren.

  6. Installieren Sie kubectl:

    sudo apt-get install kubectl

  7. Installieren Sie kpt:

    sudo apt-get install google-cloud-sdk-kpt

Option B: Befehlszeilentools lokal verwenden

Installieren und initialisieren Sie die gcloud CLI auf Ihrem lokalen Rechner.

  1. Authentifizieren Sie sich mit Google Cloud-CLI:

    gcloud auth login

  2. Aktualisieren Sie die Komponenten:

    gcloud components update

  3. Installieren Sie kubectl:

    gcloud components install kubectl

  4. Installieren Sie kpt:

    gcloud components install kpt

Projekt einrichten

  1. Rufen Sie die Projekt-ID des Projekts ab, in dem der Cluster erstellt wird:

    gcloud

    gcloud projects list

    Console

    1. Rufen Sie in der Google Cloud Console die Seite Dashboard auf:

      Zur Seite "Dashboard"

    2. Klicken Sie oben auf der Seite auf die Drop-down-Liste Auswählen aus. Wählen Sie im angezeigten Fenster Auswählen aus Ihr Projekt aus.

      Die Projekt-ID wird auf der Dashboard-Karte Projektinformationen des Projekts angezeigt.

  2. Erstellen Sie eine Umgebungsvariable für die Projekt-ID: 
    export PROJECT_ID=YOUR_PROJECT_ID
  3. Legen Sie die Standardprojekt-ID für das gcloud-Befehlszeilentool fest: 
    gcloud config set project ${PROJECT_ID}
  4. Erstellen Sie eine Umgebungsvariable für die Projektnummer: 
    export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")

  5. Legen Sie die erforderlichen IAM-Rollen (Identitäts- und Zugriffsverwaltung) fest. Wenn Sie ein Projektinhaber sind, haben Sie alle erforderlichen Berechtigungen, um die Installation abzuschließen und Ihren Cluster in Ihrer Umgebung zu registrieren. Wenn Sie kein Projektinhaber sind, benötigen Sie jemanden, der Ihnen die folgenden spezifischen IAM-Rollen zuweisen kann. Ändern Sie im folgenden Befehl GCP_EMAIL_ADDRESS in das Konto, mit dem Sie sich bei Google Cloud anmelden. 
    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
     --member user:GCP_EMAIL_ADDRESS \
     --role=roles/editor \
     --role=roles/compute.admin \
     --role=roles/container.admin \
     --role=roles/resourcemanager.projectIamAdmin \
     --role=roles/iam.serviceAccountAdmin \
     --role=roles/iam.serviceAccountKeyAdmin \
     --role=roles/gkehub.admin

    Weitere Informationen zum Zuweisen von IAM-Rollen finden Sie unter Zugriff auf Ressourcen erteilen, ändern und entziehen. Eine Beschreibung dieser Rollen finden Sie unter Erforderliche Berechtigungen für die Installation von Anthos Service Mesh.

  6. Aktivieren Sie folgende APIs: 
    gcloud services enable \
    container.googleapis.com \
    compute.googleapis.com \
    monitoring.googleapis.com \
    logging.googleapis.com \
    cloudtrace.googleapis.com \
    meshca.googleapis.com \
    meshtelemetry.googleapis.com \
    meshconfig.googleapis.com \
    iamcredentials.googleapis.com \
    anthos.googleapis.com \
    gkeconnect.googleapis.com \
    gkehub.googleapis.com \
    cloudresourcemanager.googleapis.com \
    iap.googleapis.com

    Die Aktivierung der APIs kann einige Minuten dauern. Wenn die APIs aktiviert sind, sieht die Ausgabe in etwa so aus:

    Operation "operations/acf.601db672-88e6-4f98-8ceb-aa3b5725533c" finished
successfully.

Statische IP-Adresse reservieren und DNS konfigurieren

Für die Integration von Identity-Aware Proxy in Anthos Service Mesh müssen Sie einen Google Cloud HTTP(S)-Load-Balancer einrichten. Dafür ist ein Domainname erforderlich, der auf eine statische IP-Adresse verweist. Sie können eine statische externe IP-Adresse reservieren, die Ihrem Projekt die Adresse unbegrenzt zuweist, bis Sie sie explizit freigeben.

  1. Reservieren Sie eine statische externe IP-Adresse:

    gcloud compute addresses create example-static-ip --global

  2. Rufen Sie die statische IP-Adresse ab:

    gcloud compute addresses describe example-static-ip --global

  3. Konfigurieren Sie in Ihrem Domainnamenregistrator einen voll qualifizierten Domainnamen (FQDN) mit der statischen IP-Adresse. In der Regel fügen Sie den DNS-Einstellungen den Eintrag A hinzu. Die Konfigurationsschritte und die Terminologie zum Hinzufügen eines A-Eintrags für einen FQDN variieren je nach Domainnamenregistrator.

  4. Legen Sie den Domainnamen in einer Umgebungsvariablen fest:

    export DOMAIN_NAME=YOUR_DOMAIN_NAME

    Es kann 24 bis 48 Stunden dauern, bis die DNS-Einstellung weitergeleitet wird. Sie können weiterhin alles in dieser Anleitung einrichten, aber Sie können die Einrichtung erst testen, wenn die DNS-Einstellungen weitergeleitet wurden.

Neuen GKE-Cluster einrichten

So richten Sie einen neuen Cluster ein:

  1. Wählen Sie eine Zone, einen Maschinentyp und eine Release-Version für den neuen Cluster aus. Der von Anthos Service Mesh benötigte Maschinentyp ist mindestens n1-standard-4. Sie können eine beliebige Option für die Release-Version verwenden.

    • So rufen Sie eine Liste der verfügbaren GCP-Zonen ab:

      gcloud compute zones list

    • So rufen Sie eine Liste der Maschinentypen ab:

      gcloud compute machine-types list | more

  2. Erstellen Sie die folgenden Umgebungsvariablen:

    • Legen Sie den Clusternamen fest:

      export CLUSTER_NAME=YOUR_CLUSTER_NAME

      Der Clustername darf nur kleingeschriebene, alphanumerische Zeichen und "-" enthalten und muss mit einem Buchstaben beginnen und mit einem alphanumerischen Zeichen enden. Er darf nicht länger als 40 Zeichen sein.

    • Legen Sie CLUSTER_LOCATION auf Ihre Clusterzone fest:

      export CLUSTER_LOCATION=YOUR_ZONE

    • Legen Sie den Arbeitslastpool fest:

      export WORKLOAD_POOL=${PROJECT_ID}.svc.id.goog

    • Legen Sie die Mesh-ID fest:

      export MESH_ID="proj-${PROJECT_NUMBER}"

  3. Erstellen Sie den Cluster mit den von Anthos Service Mesh benötigten Optionen. Mit dem folgenden Befehl wird ein Cluster mit vier Knoten des Maschinentyps n1-standard-4 erstellt, der vier vCPUs hat. Dies sind der minimale Maschinentyp und die Anzahl der Knoten, die für Anthos Service Mesh erforderlich sind. Sie können einen anderen Maschinentyp angeben, solange er mindestens 4 vCPUs hat. Die Anzahl der Knoten kann entsprechend Ihren Systemanforderungen erhöht werden.

    gcloud beta container clusters create ${CLUSTER_NAME} \
    --project=${PROJECT_ID} \
    --zone=${CLUSTER_LOCATION} \
    --machine-type=n1-standard-4 \
    --num-nodes=4 \
    --workload-pool=${WORKLOAD_POOL} \
    --enable-stackdriver-kubernetes \
    --subnetwork=default \
    --labels mesh_id=${MESH_ID} \
    --addons=HttpLoadBalancing \
    --release-channel=regular

    Der Befehl clusters create umfasst Folgendes:

    • workload-pool=${WORKLOAD_POOL}: Aktiviert Workload Identity. Dies ist die empfohlene Methode für den sicheren Zugriff auf Google Cloud-Dienste aus GKE-Anwendungen.

    • enable-stackdriver-kubernetes: Aktiviert Cloud Monitoring und Cloud Logging in GKE.

    • subnetwork=default: Erstellt ein standardmäßiges Subnetzwerk.

    • labels mesh_id=${MESH_ID}: Legt das Label mesh_id auf dem Cluster fest. Dies ist erforderlich, damit Messwerte auf dem Anthos Service Mesh-Dashboard in der Google Cloud Console angezeigt werden.

    • Das HttpLoadBalancing-Add-on aktiviert einen HTTP (L7)-Load-Balancing-Controller für den Cluster.

    • release-channel regular: Meldet den Cluster in der Release-Version regular an. Sie können jedoch stable auswählen, wenn Sie eine höhere Stabilität benötigen, oder rapid, wenn Sie neue (nicht unterstützte) GKE-Features testen möchten.

Anmeldedaten und Berechtigungen festlegen

  1. Initialisieren Sie Ihr Projekt, um es für die Installation vorzubereiten. Mit diesem Befehl wird unter anderem ein Dienstkonto erstellt, mit dem Istio-Komponenten wie der Sidecar-Proxy sicher auf die Daten und Ressourcen Ihres Projekts zugreifen können: 
    curl --request POST \
  --header "Authorization: Bearer $(gcloud auth print-access-token)" \
  --data '' \
  https://meshconfig.googleapis.com/v1alpha1/projects/${PROJECT_ID}:initialize

    Der Befehl gibt ein Paar leere geschweifte Klammern zurück: {}

    Wenn Sie in Zukunft eine neue Version von Anthos Service Mesh auf diesem Cluster installieren, müssen Sie den Befehl nicht noch einmal ausführen. Die weitere Ausführung des Befehls hat jedoch keine Auswirkungen auf die Installation.

  2. Rufen Sie Anmeldedaten für die Authentifizierung ab, um mit dem Cluster zu interagieren: 
    gcloud container clusters get-credentials ${CLUSTER_NAME}
  3. Gewähren Sie dem aktuellen Nutzer Cluster-Administratorberechtigungen. Sie benötigen diese Berechtigungen, um die erforderlichen Regeln für die rollenbasierte Zugriffssteuerung (Role Based Access Control, RBAC) für Anthos Service Mesh zu erstellen: 
    kubectl create clusterrolebinding cluster-admin-binding \
  --clusterrole=cluster-admin \
  --user="$(gcloud config get-value core/account)"

    Wenn der Fehler "cluster-admin-binding" already exists angezeigt wird, können Sie ihn ignorieren und mit der vorhandenen Cluster-Administratorbindung fortfahren.

Cluster registrieren

Sie müssen den Cluster in der Flotte des Projekts registrieren, um Zugriff auf die einheitliche Benutzeroberfläche in der Google Cloud Console zu erhalten. Eine Flotte ermöglicht die einheitliche Anzeige und Verwaltung der Cluster und ihrer Arbeitslasten, einschließlich Clustern außerhalb von Google Cloud.

Google Cloud-Dienstkonto und -Schlüsseldatei erstellen

Zum Registrieren eines Clusters ist eine JSON-Datei mit den Dienstkonto-Anmeldedaten erforderlich. Um das Prinzip der geringsten Berechtigung anzuwenden, empfehlen wir, dass Sie für jeden registrierten Cluster ein eigenes Dienstkonto erstellen.

So erstellen Sie ein Dienstkonto und eine Schlüsseldatei:

  1. Wählen Sie einen Namen für das Dienstkonto aus und erstellen Sie eine Umgebungsvariable dafür:

    export SERVICE_ACCOUNT_NAME=SERVICE_ACCOUNT_NAME

  2. Erstellen Sie das Dienstkonto:

    gcloud iam service-accounts create ${SERVICE_ACCOUNT_NAME}

  3. Listen Sie alle Dienstkonten eines Projekts auf, um zu prüfen, ob das Dienstkonto erstellt wurde:

    gcloud iam service-accounts list

  4. Weisen Sie dem Dienstkonto die IAM-Rolle „gkehub.connect“ zu:

    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
   --member="serviceAccount:${SERVICE_ACCOUNT_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" \
   --role="roles/gkehub.connect"

  5. Erstellen Sie eine Umgebungsvariable für den lokalen Dateipfad, unter dem Sie die JSON-Datei speichern möchten. Es empfiehlt sich, die Datei nach dem Namen des Dienstkontos und Ihrer Projekt-ID zu benennen. Beispiel: /tmp/creds/${SERVICE_ACCOUNT_NAME}-${PROJECT_ID}.json.

    export SERVICE_ACCOUNT_KEY_PATH=LOCAL_KEY_PATH

  6. Laden Sie die JSON-Datei des Dienstkontos mit dem privaten Schlüssel herunter:

    gcloud iam service-accounts keys create ${SERVICE_ACCOUNT_KEY_PATH} \
   --iam-account=${SERVICE_ACCOUNT_NAME}@${PROJECT_ID}.iam.gserviceaccount.com

Cluster registrieren

Ersetzen Sie im folgenden Befehl MEMBERSHIP_NAME durch einen Namen, der sich eindeutig auf den im Hub registrierten Cluster bezieht.

gcloud container hub memberships register MEMBERSHIP_NAME \
    --gke-cluster=${CLUSTER_LOCATION}/${CLUSTER_NAME} \
    --service-account-key-file=${SERVICE_ACCOUNT_KEY_PATH}

Der Befehl meldet eine Ausgabe, die in etwa so aussieht: 

kubeconfig entry generated for CLUSTER_NAME.
Waiting for membership to be created...done.
Created a new membership [projects/PROJECT_ID/locations/global/memberships/MEMBERSHIP_NAME] for the cluster [MEMBERSHIP_NAME]
Generating the Connect Agent manifest...
Deploying the Connect Agent on cluster [MEMBERSHIP_NAME] in namespace [gke-connect]...
Deployed the Connect Agent on cluster [MEMBERSHIP_NAME] in namespace [gke-connect].
Finished registering the cluster [MEMBERSHIP_NAME] with the Hub.

Dieser Dienstkontoschlüssel wird als Secret mit dem Namen creds-gcp im Namespace gke-connect gespeichert.

Weitere Informationen zur Clusterregistrierung finden Sie unter Cluster registrieren in der Connect-Dokumentation.

Installationsdatei herunterladen

Bevor Sie fortfahren, prüfen Sie, ob das ASM Mesh Data Plane-Dienstkonto Mitglied des Projekts ist:

gcloud projects get-iam-policy ${PROJECT_ID} | grep -B 1 'roles/meshdataplane.serviceAgent'

Wenn mit dem vorherigen Befehl nichts ausgegeben wird, kehren Sie zum Abschnitt Anmeldedaten und Berechtigungen festlegen zurück und führen Sie den Befehl curl aus.

    Linux

  1. Laden Sie die Anthos Service Mesh-Installationsdatei in Ihr aktuelles Arbeitsverzeichnis herunter: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-linux.tar.gz
  2. Laden Sie die Signaturdatei herunter und bestätigen Sie die Signatur mit openssl: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-linux.tar.gz.1.sig
openssl dgst -verify - -signature istio-1.5.10-asm.2-linux.tar.gz.1.sig istio-1.5.10-asm.2-linux.tar.gz <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

    Die erwartete Ausgabe ist Verified OK.

  3. Entpacken Sie die Inhalte der Datei in einem Verzeichnis Ihres Dateisystems. So extrahieren Sie beispielsweise den Inhalt in das aktuelle Arbeitsverzeichnis: 
    tar xzf istio-1.5.10-asm.2-linux.tar.gz

    Mit dem Befehl wird ein Installationsverzeichnis im aktuellen Arbeitsverzeichnis istio-1.5.10-asm.2 erstellt, das Folgendes enthält:

    • Beispielanwendungen in samples
    • Die folgenden Tools im Verzeichnis bin:
      • istioctl: Sie verwenden istioctl, um Anthos Service Mesh zu installieren.
      • asmctl: Sie verwenden asmctl, um Ihre Sicherheitskonfiguration nach der Installation von Anthos Service Mesh zu validieren. (asmctl wird derzeit nicht in Anthos-Cluster auf VMware unterstützt.)

    4. macOS

  4. Laden Sie die Anthos Service Mesh-Installationsdatei in Ihr aktuelles Arbeitsverzeichnis herunter: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-osx.tar.gz
  5. Laden Sie die Signaturdatei herunter und bestätigen Sie die Signatur mit openssl: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-osx.tar.gz.1.sig
openssl dgst -sha256 -verify /dev/stdin -signature istio-1.5.10-asm.2-osx.tar.gz.1.sig istio-1.5.10-asm.2-osx.tar.gz <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

    Die erwartete Ausgabe ist Verified OK.

  6. Entpacken Sie die Inhalte der Datei in einem Verzeichnis Ihres Dateisystems. So extrahieren Sie beispielsweise den Inhalt in das aktuelle Arbeitsverzeichnis: 
    tar xzf istio-1.5.10-asm.2-osx.tar.gz

    Mit dem Befehl wird ein Installationsverzeichnis im aktuellen Arbeitsverzeichnis istio-1.5.10-asm.2 erstellt, das Folgendes enthält:

    • Beispielanwendungen in samples
    • Die folgenden Tools im Verzeichnis bin:
      • istioctl: Sie verwenden istioctl, um Anthos Service Mesh zu installieren.
      • asmctl: Sie verwenden asmctl, um Ihre Sicherheitskonfiguration nach der Installation von Anthos Service Mesh zu validieren. (asmctl wird derzeit nicht in Anthos-Cluster auf VMware unterstützt.)

    7. Windows

  7. Laden Sie die Anthos Service Mesh-Installationsdatei in Ihr aktuelles Arbeitsverzeichnis herunter: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-win.zip
  8. Laden Sie die Signaturdatei herunter und bestätigen Sie die Signatur mit openssl: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-win.zip.1.sig
openssl dgst -verify - -signature istio-1.5.10-asm.2-win.zip.1.sig istio-1.5.10-asm.2-win.zip <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

    Die erwartete Ausgabe ist Verified OK.

  9. Entpacken Sie die Inhalte der Datei in einem Verzeichnis Ihres Dateisystems. So extrahieren Sie beispielsweise den Inhalt in das aktuelle Arbeitsverzeichnis: 
    tar xzf istio-1.5.10-asm.2-win.zip

    Mit dem Befehl wird ein Installationsverzeichnis im aktuellen Arbeitsverzeichnis istio-1.5.10-asm.2 erstellt, das Folgendes enthält:

    • Beispielanwendungen in samples
    • Die folgenden Tools im Verzeichnis bin:
      • istioctl: Sie verwenden istioctl, um Anthos Service Mesh zu installieren.
      • asmctl: Sie verwenden asmctl, um Ihre Sicherheitskonfiguration nach der Installation von Anthos Service Mesh zu validieren. (asmctl wird derzeit nicht auf Anthos-Cluster in VMware unterstützt.)

  10. Prüfen Sie, ob Sie sich im Stammverzeichnis der Anthos Service Mesh-Installation befinden. 
    cd istio-1.5.10-asm.2
  11. Fügen Sie die Tools der Einfachheit halber im Verzeichnis /bin Ihrem PATH hinzu. 
    export PATH=$PWD/bin:$PATH

Ressourcenkonfigurationsdateien vorbereiten

Wenn Sie den istioctl apply command ausführen, um Anthos Service Mesh zu installieren, geben Sie -f istio-operator.yaml in der Befehlszeile an. Diese Datei enthält Informationen zu Ihrem Projekt und Cluster, die zum Aktivieren der Mesh-Telemetrie- und Mesh-Sicherheitsfunktionen erforderlich sind. Laden Sie die Datei istio-operator.yaml und andere Ressourcenkonfigurationsdateien herunter und legen Sie die Projekt- und Clusterinformationen fest.

So bereiten Sie die Ressourcenkonfigurationsdateien vor:

  1. Installieren Sie kpt, falls noch nicht geschehen:

    gcloud components install kpt

  2. Erstellen Sie optional ein neues Verzeichnis für die Ressourcenkonfigurationsdateien des Anthos Service Mesh-Pakets. Wenn Sie mehrere Cluster einrichten möchten, ist es möglicherweise sinnvoll, den Clusternamen als Verzeichnisnamen zu verwenden.

  3. Wechseln Sie zu dem Verzeichnis, in das Sie das Anthos Service Mesh-Paket herunterladen möchten.

  4. Laden Sie das Anthos Service Mesh-Paket in das aktuelle Arbeitsverzeichnis herunter:

    kpt pkg get \
https://github.com/GoogleCloudPlatform/anthos-service-mesh-packages.git/asm@release-1.5-asm .

  5. Legen Sie den Clusternamen fest:

      kpt cfg set asm gcloud.container.cluster ${CLUSTER_NAME}

  6. Optional können Sie die Ressourcenkonfigurationsdateien mithilfe der kpt-Setter anpassen. Diese Setter verwenden standardmäßig die Standardwerte für gcloud config. Wenn Sie die Standardwerte für gcloud config festlegen oder die Werte ändern möchten, führen Sie die folgenden Setter aus:

    • Legen Sie die Projekt-ID fest:

      kpt cfg set asm gcloud.core.project ${PROJECT_ID}

    • Legen Sie die Standardzone oder -region fest:

      kpt cfg set asm gcloud.compute.location ${CLUSTER_LOCATION}

  7. Optional können Sie die Ressourcenkonfigurationsdateien in Ihr eigenes Versionsverwaltungssystem wie Cloud Source Repositories einchecken, damit Sie Änderungen an den Dateien verfolgen können.

Anthos Service Mesh installieren

Installieren Sie Anthos Service Mesh und legen Sie die Optionen zur Einbindung von Anthos Service Mesh in IAP fest.

PERMISSIVE-mTLS

istioctl manifest apply --set profile=asm \
  -f asm/cluster/istio-operator.yaml \
  --set values.gateways.istio-ingressgateway.type=NodePort

STRICT-mTLS

istioctl manifest apply --set profile=asm \
  -f asm/cluster/istio-operator.yaml \
  --set values.gateways.istio-ingressgateway.type=NodePort \
  --set values.global.mtls.enabled=true

Sie geben NodePort für istio-ingressgateway an, wodurch {[mesh_name]} konfiguriert wird, um einen bestimmten Port im Service Mesh zu öffnen. Dadurch können Sie einen Load-Balancer einrichten, der den an Ihren Domainnamen gesendeten Traffic an diesen Port weiterleitet. Mit den anderen Optionen wird die Anthos Service Mesh-Zertifizierungsstelle (Mesh CA) aktiviert.

Installation prüfen

Wir empfehlen die Verwendung des Analysetools asmctl, um die grundlegende Konfiguration Ihres Projekts, Ihres Clusters und Ihrer Arbeitslasten zu prüfen. Wenn ein asmctl-Test fehlschlägt, empfiehlt asmctl Lösungen, sofern möglich. Mit dem Befehl asmctl validate werden einfache Tests durchgeführt, mit denen Folgendes geprüft wird:

  1. Die von Anthos Service Mesh benötigten APIs sind für das Projekt aktiviert.
  2. Das Istio-Ingress-Gateway ist ordnungsgemäß für den Aufruf von Mesh CA konfiguriert.
  3. Der allgemeine Zustand von Istiod und Istio-Ingressgateway.

Wenn Sie den Befehl asmctl validate mit dem optionalen Flag --with-testing-workloads zusätzlich zu den grundlegenden Tests ausführen, führt asmctl die Sicherheitstests aus, die Folgendes prüfen:

  1. Die gegenseitige TLS-Kommunikation (mTLS) ist richtig konfiguriert.
  2. Die Mesh CA kann Zertifikate ausstellen.

Zum Ausführen der Sicherheitstests stellt asmctl Arbeitslasten in Ihrem Cluster in einem Test-Namespace bereit, führt die mTLS-Kommunikationstests aus, gibt die Ergebnisse aus und löscht den Test-Namespace.

So führen Sie asmctl aus:

  1. Achten Sie darauf, dass gcloud-Standardanmeldedaten für Anwendungen festgelegt ist:

     gcloud auth application-default login

  2. Rufen Sie, falls noch nicht geschehen, Authentifizierungsdaten für die Interaktion mit dem Cluster ab:

     gcloud container clusters get-credentials ${CLUSTER_NAME}

  3. So führen Sie sowohl die grundlegenden als auch die Sicherheitstests durch (sofern die istio-1.5.10-asm.2/bin) im PATH enthalten ist):

    asmctl validate --with-testing-workloads

    Bei Erfolg meldet der Befehl eine Ausgabe, die in etwa so aussieht:

    [asmctl version 0.3.0]
Using Kubernetes context: example-project_us-central1-example-cluster
To change the context, use the --context flag
Validating enabled APIs
OK
Validating ingressgateway configuration
OK
Validating istio system
OK
Validating sample traffic
Launching example services...
Sent traffic to example service http code: 200
verified mTLS configuration
OK
Validating issued certs
OK

Beispielanwendung bereitstellen

Bevor Sie IAP aktivieren, müssen Sie eine Anwendung in Ihrem GKE-Cluster ausführen, damit Sie prüfen können, ob alle Anfragen eine Identität haben. In dieser Anleitung wird anhand des Bookinfo-Beispiels gezeigt, wie Sie den HTTP(S)-Load-Balancer einrichten und IAP aktivieren.

Anwendungsdienste starten

  1. Wechseln Sie in das Stammverzeichnis der Anthos Service Mesh-Installation.

  2. Kennzeichnen Sie den Namespace default zur Verwendung der automatischen Sidecar-Injektion:

    kubectl label namespace default istio-injection=enabled

  3. Stellen Sie die Anwendung bereit:

    kubectl apply -f samples/bookinfo/platform/kube/bookinfo.yaml

  4. Prüfen Sie, ob alle bookinfo-Dienste ausgeführt werden:

    kubectl get services

    Die erwartete Ausgabe sieht in etwa so aus:

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

  5. Prüfen Sie, ob alle Pods ausgeführt werden:

    kubectl get pods

    Die erwartete Ausgabe sieht in etwa so aus:

    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. Prüfen Sie, ob die Anwendung „Bookinfo“ ausgeführt wird:

    kubectl exec -it $(kubectl get pod -l app=ratings -o jsonpath='{.items[0].metadata.name}') -c ratings -- curl productpage:9080/productpage | grep -o "<title>.*</title>"

    Erwartete Ausgabe:

    <title>Simple Bookstore App</title>

  7. Definieren Sie das Ingress-Gateway und den virtuellen Dienst für die Anwendung:

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

  8. Prüfen Sie, ob das Gateway erstellt wurde:

    kubectl get gateway

    Die erwartete Ausgabe sieht in etwa so aus:

    NAME                AGE
bookinfo-gateway    32s

Externe Anfragen

Die Gateway-Ressource von Bookinfo (definiert in samples/bookinfo/networking/bookinfo-gateway.yaml) verwendet das vorkonfigurierte istio-ingressgateway. Denken Sie daran, dass Sie bei der Bereitstellung von Anthos Service Mesh NodePort für das istio-ingressgateway angegeben haben, wodurch ein bestimmter Port im Service Mesh geöffnet wird. Die Bookinfo-Anwendung ist nur außerhalb Ihres GKE-Clusters (z. B. über einen Browser) zugänglich, bis Sie den Load-Balancer eingerichtet haben. Obwohl die Knoten in Ihrem Cluster externe IP-Adressen haben, werden Anfragen von außerhalb des Clusters durch Google Cloud-Firewallregeln blockiert. Mit IAP erfolgt die ordnungsgemäße Bereitstellung dieser Anwendung im öffentlichen Internet über einen Load-Balancer. Stellen Sie die Knotenadressen nicht mit Firewallregeln bereit. Dies würde IAP umgehen.

Zum Weiterleiten von Anfragen an Bookinfo richten Sie in Ihrem Google Cloud-Projekt einen HTTP(S)-Load-Balancer ein. Da der Load-Balancer in Ihrem Projekt ist, befindet er sich innerhalb der Firewall und kann auf die Knoten in Ihrem Cluster zugreifen. Nachdem Sie den Load-Balancer mit der statischen IP-Adresse und Ihrem Domainnamen konfiguriert haben, können Sie Anfragen an den Domainnamen senden. Der Load-Balancer leitet dann die Anfragen an die Knoten im Cluster weiter.

Load-Balancer bereitstellen

Sie können eine Ingress-Ressource verwenden, um einen HTTP(S)-Load-Balancer mit automatisch konfigurierten SSL-Zertifikaten zu erstellen. Von Google verwaltete SSL-Zertifikate werden für Ihre Domain bereitgestellt, verlängert und verwaltet.

  1. Erstellen Sie eine ManagedCertificate-Ressource. Diese Ressource gibt die Domain für das SSL-Zertifikat an. Die Liste spec.domains darf nur eine Domain enthalten. Domains mit Platzhaltern werden nicht unterstützt.

    cat <<EOF | kubectl apply -f -
apiVersion: networking.gke.io/v1beta1
kind: ManagedCertificate
metadata:
  name: example-certificate
  namespace: istio-system
spec:
  domains:
    - ${DOMAIN_NAME}
EOF

  2. Erstellen Sie den Load-Balancer, indem Sie die Ingress-Ressource definieren.

    • Geben Sie für die Annotation networking.gke.io/managed-certificates den Namen des im vorherigen Schritt erstellten Zertifikats an (example-certificate).

    • Geben Sie für die Annotation kubernetes.io/ingress.global-static-ip-name den Namen der von Ihnen reservierten statischen IP-Adresse an (example-static-ip).

    • Legen Sie den serviceName auf istio-ingressgateway fest. Dieser wird in der Gateway-Ressource für das Bookinfo-Beispiel verwendet.

    cat <<EOF | kubectl create -f -
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: example-ingress
  namespace: istio-system
  annotations:
    kubernetes.io/ingress.global-static-ip-name: example-static-ip
    networking.gke.io/managed-certificates: example-certificate
spec:
  backend:
    serviceName: istio-ingressgateway
    servicePort: 80
EOF

  3. Rufen Sie in der Cloud Console die Seite Kubernetes Engine > Dienste und Ingress auf:

    Zur Seite "Dienste und Ingress"

    In der Spalte Status sollte eine Meldung über die Erstellung von Ingress angezeigt werden. Warten Sie, bis GKE das Ingress vollständig bereitgestellt hat, bevor Sie fortfahren. Aktualisieren Sie die Seite alle paar Minuten, um den aktuellsten Status des Ingress zu erhalten. Nachdem der Ingress bereitgestellt wurde, wird möglicherweise der Status "OK" oder der Fehler "Back-End-Dienste arbeiten nicht fehlerfrei" angezeigt. Eine der von GKE bereitgestellten Ressourcen ist eine standardmäßige Systemdiagnose. Wenn die Fehlermeldung angezeigt wird, weist dies darauf hin, dass die Ingress-Ressource bereitgestellt und die standardmäßige Systemdiagnose ausgeführt wurde. Wenn entweder der Status "OK" oder der Fehler angezeigt werden, fahren Sie mit dem nächsten Abschnitt fort, um die Systemdiagnosen für den Load-Balancer zu konfigurieren.

Systemdiagnosen für Load-Balancer konfigurieren

Zum Konfigurieren der Systemdiagnosen müssen Sie die ID der vom Ingress erstellten standardmäßigen Systemdiagnose abrufen und dann die Systemdiagnose aktualisieren, um den Pfad und Port der Systemdiagnose des Istio-Ingress zu verwenden.

  1. Rufen Sie neue Nutzeranmeldedaten für die Standardanmeldedaten für Anwendungen ab:

      gcloud auth application-default login

  2. Rufen Sie die ID der standardmäßigen Systemdiagnose ab, die von Ingress erstellt wurde:

    1. Legen Sie die folgenden Umgebungsvariablen fest:

      • Back-End-Dienst: Brücket verschiedene Instanzgruppen über einen bestimmten Dienst-Portport. 

        BACKEND_SERVICE=$(gcloud compute url-maps list | grep example-ingress | awk '{print $2}' | cut -d'/' -f 2)

      • Systemdiagnose: Dies ist die Standard-Systemdiagnose, die automatisch erstellt wird, wenn der Ingress bereitgestellt wird. 

        HC=$(gcloud compute backend-services describe ${BACKEND_SERVICE} --global | grep healthChecks | cut -d'/' -f 10 | tail -n 1)

      • Eingehender Systemdiagnose-Port: Dies ist der Systemdiagnose-Port von Istio-Ingress. 

        export HC_INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="status-port")].nodePort}')

      • Systemdiagnose-Ingress-Pfad: Dies ist der Systemdiagnosepfad von firebase-Ingress. 

        export HC_INGRESS_PATH=$(kubectl -n istio-system get deployments istio-ingressgateway -o jsonpath='{.spec.template.spec.containers[?(@.name=="istio-proxy")].readinessProbe.httpGet.path}')

      • Health Check API: Dies ist die API, die Sie zum Konfigurieren der Systemdiagnose aufrufen. 
        export HC_API=https://compute.googleapis.com/compute/v1/projects/${PROJECT_ID}/global/healthChecks/${HC}

    2. Rufen Sie die standardmäßige Systemdiagnose durch Aufrufen der healthChecks API in eine JSON-Datei ab:

      curl --request GET  --header "Authorization: Bearer $(gcloud auth application-default print-access-token)" ${HC_API} > health_check.json

  3. Aktualisieren Sie die Systemdiagnose, damit der Pfad und der Port von istio-ingress verwendet werden:

    1. Aktualisieren Sie die Datei health_check.json so:

      • Setzen Sie httpHealthCheck.port auf den Wert ${HC_INGRESS_PORT}.
      • Setzen Sie httpHealthCheck.requestPath auf den Wert ${HC_INGRESS_PATH}.
      • Fügen Sie das folgende Attribut hinzu und legen Sie es auf einen leeren String fest: httpHealthCheck.portSpecification=""

      Die einfachste Methode hierfür ist die Verwendung von jq, das in Cloud Shell vorinstalliert ist:

      jq ".httpHealthCheck.port=${HC_INGRESS_PORT} | .httpHealthCheck.requestPath=\"${HC_INGRESS_PATH}\" | .httpHealthCheck.portSpecification=\"\"" health_check.json > updated_health_check.json

      Wenn Sie cat mit der resultierenden updated_health_check.json-Datei ausführen, sieht sie ungefähr so aus:

      {
"id": "5062913090021441698",
"creationTimestamp": "2019-11-12T10:47:41.934-08:00",
"name": "${HC}",
"description": "Default kubernetes L7 Loadbalancing health check.",
"checkIntervalSec": 60,
"timeoutSec": 60,
"unhealthyThreshold": 10,
"healthyThreshold": 1,
"type": "HTTP",
"httpHealthCheck": {
  "port": 32394,
  "requestPath": "/healthz/ready",
  "proxyHeader": "NONE",
  "portSpecification": ""
},
"selfLink": "https://www.googleapis.com/compute/v1/projects/${PROJECT_ID}/global/healthChecks/${HC}",
"kind": "compute#healthCheck"
}

      Wenn Sie die JSON-Datei manuell bearbeitet haben, statt den Befehl jq zu verwenden, speichern Sie die Datei als updated_health_check.json, damit sie im nächsten Befehl mit dem Dateinamen übereinstimmt.

    2. Aktualisieren Sie die Systemdiagnose:

      curl --request PATCH --header "Authorization: Bearer $(gcloud auth application-default print-access-token)" --header "Content-Type: application/json" --data @updated_health_check.json ${HC_API}

    Es dauert einige Minuten, bis GKE die Systemdiagnose aktualisiert hat. Aktualisieren Sie in der Google Cloud Console etwa einmal pro Minute die Seite Kubernetes Engine > Dienste und Ingress, bis sich der Status von Ingress in "OK" ändert.

  4. Testen Sie den Load-Balancer. Öffnen Sie in Ihrem Browser folgende Adresse:

    http://YOUR_DOMAIN_NAME/productpage

    Dabei ist YOUR_DOMAIN_NAME der Domainname, den Sie mit der externen statischen IP-Adresse konfiguriert haben.

    Sie sollten die productpage der Bookinfo-Anwendung sehen. Wenn Sie die Seite mehrmals aktualisieren, sollten verschiedene Versionen von Rezensionen in zufälliger Reihenfolge angezeigt werden: rote Sterne, schwarze Sterne, keine Sterne.

    Sie sollten auch den https-Zugriff auf Bookinfo testen.

IAP aktivieren

In den folgenden Schritten wird beschrieben, wie IAP aktiviert wird.

  1. Prüfen Sie mit dem Befehl list, ob bereits eine Marke vorhanden ist. Sie können nur eine Marke pro Projekt haben.

    gcloud iap oauth-brands list

    Hier sehen Sie ein Beispiel für eine gcloud-Antwort, wenn die Marke vorhanden ist:

    name: projects/[PROJECT_NUMBER]/brands/[BRAND_ID]
applicationTitle: [APPLICATION_TITLE]
supportEmail: [SUPPORT_EMAIL]
orgInternalOnly: true

  2. Wenn keine Marke vorhanden ist, verwenden Sie den Befehl create:

    gcloud iap oauth-brands create --application_title=APPLICATION_TITLE --support_email=SUPPORT_EMAIL

    Die obigen Felder sind für den Aufruf dieser API erforderlich:

    • supportEmail: Die Support-E-Mail-Adresse, die auf dem OAuth-Zustimmungsbildschirm angezeigt wird. Diese E-Mail-Adresse kann entweder die Adresse eines Nutzers oder ein Google Groups-Alias sein. Dienstkonten haben auch eine E-Mail-Adresse. Sie sind aber keine tatsächlich gültigen E-Mail-Adressen und können nicht beim Erstellen einer Marke verwendet werden. Ein Dienstkonto kann jedoch der Inhaber einer Google-Gruppe sein. Erstellen Sie entweder eine neue Google-Gruppe oder konfigurieren Sie eine vorhandene Gruppe und legen Sie das gewünschte Dienstkonto als Inhaber der Gruppe fest.

    • applicationTitle: Der Anwendungsname, der auf dem OAuth-Zustimmungsbildschirm angezeigt wird.

    Die Antwort umfasst die folgenden Felder:

    name: projects/[PROJECT_NUMBER]/brands/[BRAND_ID]
applicationTitle: [APPLICATION_TITLE]
supportEmail: [SUPPORT_EMAIL]
orgInternalOnly: true

IAP-OAuth-Client erstellen

  1. Verwenden Sie den Befehl "create", um einen Client zu erstellen. Verwenden Sie die Marke name aus dem vorherigen Schritt.

    gcloud iap oauth-clients create projects/PROJECT_NUMBER/brands/BRAND-ID --display_name=NAME

    Die Antwort umfasst die folgenden Felder:

    name: projects/[PROJECT_NUMBER]/brands/[BRAND_NAME]/identityAwareProxyClients/[CLIENT_ID]
secret: [CLIENT_SECRET]
displayName: [NAME]

IAP für Ihren Dienst aktivieren

Aktivieren Sie mit dem folgenden Befehl IAP für Ihren Dienst. Ersetzen Sie CLIENT_ID und CLIENT_SECRET durch Ihre OAuth-Client-ID und den Clientschlüssel aus dem zuvor erstellten Client.

gcloud beta iap web enable \
    --oauth2-client-id=CLIENT_ID \
    --oauth2-client-secret=CLIENT_SECRET \
    --resource-type=backend-services \
    --service=${BACKEND_SERVICE}

IAP-Zugriffsliste konfigurieren

Fügen Sie der Zugriffsrichtlinie für IAP einen Nutzer hinzu:

gcloud beta iap web add-iam-policy-binding \
    --member=user:EMAIL_ADDRESS \
    --role=roles/iap.httpsResourceAccessor \
    --resource-type=backend-services \
    --service=$BACKEND_SERVICE

Dabei ist EMAIL_ADDRESS die vollständige E-Mail-Adresse des Nutzers, z. B. alice@example.com.

RCToken-Unterstützung im Service Mesh aktivieren

Standardmäßig generiert IAP ein JSON Web Token (JWT), das auf den OAuth-Client beschränkt ist. Für Anthos Service Mesh können Sie IAP so konfigurieren, dass ein RequestContextToken (RCToken) generiert wird. Dabei handelt es sich um ein JWT, aber mit einer konfigurierbaren Zielgruppe. Mit RCToken können Sie die Zielgruppe des JWT auf einen beliebigen String konfigurieren, der für eine differenzierte Autorisierung in den Anthos Service Mesh-Richtlinien verwendet werden kann.

So konfigurieren Sie das RCToken:

  1. Erstellen Sie eine Umgebungsvariable für Ihre Projektnummer: Diese Nummer wurde automatisch generiert und Ihrem Projekt zugewiesen, als Sie es erstellt haben. (Diese ist nicht mit der Projekt-ID identisch.)

    export PROJECT_NUMBER=YOUR_PROJECT_NUMBER

  2. Erstellen Sie eine Umgebungsvariable für die RCToken-Zielgruppe. Dies kann ein beliebiger String sein.

    export RCTOKEN_AUD="your-rctoken-aud"

  3. Rufen Sie die vorhandenen IAP-Einstellungen ab:

    gcloud beta iap settings get --format json \
--project=${PROJECT_NUMBER} --resource-type=compute \
--service=${BACKEND_SERVICE} > iapSettings.json

  4. Aktualisieren Sie IapSettings mit der RCToken-Zielgruppe.

    cat iapSettings.json | jq --arg RCTOKEN_AUD_STR $RCTOKEN_AUD \
'. + {applicationSettings: {csmSettings: {rctokenAud: $RCTOKEN_AUD_STR}}}' \
> updatedIapSettings.json

    gcloud beta iap settings set updatedIapSettings.json --format json \
--project=${PROJECT_NUMBER} --resource-type=compute --service=${BACKEND_SERVICE}

  5. Aktivieren Sie die RCToken-Authentifizierung auf dem Istio-Ingress-Gateway.

    cat <<EOF | kubectl apply -f -
apiVersion: "authentication.istio.io/v1alpha1"
kind: "Policy"
metadata:
  name: "ingressgateway"
  namespace: istio-system
spec:
  targets:
  - name: "istio-ingressgateway"
  origins:
  - jwt:
      issuer: "https://cloud.google.com/iap"
      jwksUri: "https://www.gstatic.com/iap/verify/public_key-jwk"
      audiences:
      - "$RCTOKEN_AUD"
      jwt_headers:
      - "ingress-authorization"
      trigger_rules:
      - excluded_paths:
        - exact: /healthz/ready
  principalBinding: USE_ORIGIN
EOF

  6. Stellen Sie sicher, dass Anfragen an die Bookinfo-productpage weiterhin erfolgreich sind:

    http://DOMAIN_NAME/productpage

So testen Sie die Richtlinie:

  1. Erstellen Sie ein IapSettings-Anfrageobjekt und setzen Sie rctokenAud auf einen anderen String:

    echo $(cat <<EOF
{
   "name": "projects/${PROJECT_NUMBER}/iap_web/compute/services/${BACKEND_SERVICE}",
   "applicationSettings": {
     "csmSettings": {
       "rctokenAud": "some-other-arbitrary-string"
     }
   }
 }
EOF
) > request.txt

  2. Rufen Sie die IapSettings API auf, um die RCToken-Zielgruppe festzulegen.

    curl --request PATCH --header "Authorization: Bearer $(gcloud beta auth application-default print-access-token)" ${IAP_SETTINGS_API}

  3. Stellen Sie eine Anfrage an die Bookinfo-productpage. Sie sollte fehlschlagen:

    http://DOMAIN_NAME/productpage

Bereinigen

Entfernen Sie nach Abschluss dieser Anleitung die folgenden Ressourcen, um unerwünschte Kosten für Ihr Konto zu vermeiden:

  1. Löschen Sie das verwaltete Zertifikat:

    kubectl delete managedcertificates example-certificate

  2. Löschen Sie das Ingress, wodurch die Zuweisung der Load-Balancing-Ressourcen aufgehoben wird: 

    kubectl -n istio-system delete ingress example-ingress

  3. Löschen Sie die statische IP-Adresse: 

    gcloud compute addresses delete example-static-ip --global

    Löschen Sie in diesem Fall die IP-Adresse aus Ihrem Domain-Registrator.

  4. Löschen Sie den Cluster. Dadurch werden die Ressourcen gelöscht, die das Cluster bilden, z. B. die Compute-Instanzen, Laufwerke und Netzwerkressourcen: 

    gcloud container clusters delete ${CLUSTER_NAME}