Anthos Service Mesh 1.6 ist abgelaufen und wird nicht mehr unterstützt. Siehe Upgraden von früheren Versionen.

Lesen Sie die aktuelle Dokumentation oder wählen Sie eine andere verfügbare Version aus:

Verfügbare Versionen

1.20 (aktuell)
1.19
1.18
1.17
1.16
1.15
1.13
1.12
1.12
1.12
1.12

IAP in Anthos Service Mesh einbinden

In diesem Leitfaden wird beschrieben, wie Sie Identity-Aware Proxy (IAP) in Anthos Service Mesh einbinden. Mit der IAP-Integration 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.

Vorbereitung

In diesem Leitfaden wird Folgendes vorausgesetzt:

Cluster mit Anthos Service Mesh einrichten

Die IAP-Integration erfordert bestimmte Einstellungen für Ihr Projekt, Ihren Cluster und die Konfigurationsdateien, die Sie bei der Installation von Anthos Service Mesh verwenden.

Neuinstallationen

Die Schritte in diesem Abschnitt ergänzen die Schritte in der Anleitung Erweiterte Installation in GKE. In diesen Schritten werden die Umgebungsvariablen verwendet, die Sie im Installationsleitfaden erstellen.

Aktivieren Sie beim Einrichten des Projekts zusätzlich zu den anderen erforderlichen APIs iap.googleapis.com.
```
gcloud services enable \
  --project=PROJECT_ID \
  iap.googleapis.com
```
Aktivieren Sie beim Aktualisieren Ihres Clusters zusätzlich zu den anderen erforderlichen Clusteraktualisierungen das Add-on HttpLoadBalancing. Das Add-on HttpLoadBalancing aktiviert einen HTTP (L7)-Load-Balancing-Controller für den Cluster.
```
gcloud container clusters update ${CLUSTER_NAME} \
  --project=PROJECT_ID \
  --update-addons=HttpLoadBalancing=ENABLED
```
Wenn Sie keine Standardzone oder -region festgelegt haben, müssen Sie im vorherigen Befehl die Region (--region=${CLUSTER_LOCATION}) oder Zone (--zone=${CLUSTER_LOCATION}) angeben.
Folgen Sie nach der Aktualisierung des Clusters der Installationsanleitung, um Anmeldedaten und Berechtigungen festzulegen, und laden Sie die Installationsdatei herunter. Stoppen Sie bei Ressourcenkonfigurationsdateien vorbereiten und führen Sie stattdessen die folgenden Schritte aus.
1. Erstellen Sie ein neues Verzeichnis für die Ressourcenkonfigurationsdateien des Anthos Service Mesh-Pakets. Es empfiehlt sich, den Clusternamen als Verzeichnisnamen zu verwenden.
2. Wechseln Sie zu dem Verzeichnis, in das Sie das Anthos Service Mesh-Paket herunterladen möchten.
3. Laden Sie das Paket asm-iap herunter: Für dieses Paket wird das Feld type für den Dienst istio-ingressgateway auf NodePort gesetzt. In dieser Konfiguration öffnet istio-ingressgateway einen bestimmten Port im Service Mesh. Dadurch können Sie einen Load-Balancer einrichten, der den an Ihren Domainnamen gesendeten Traffic an diesen Port weiterleitet.
```
kpt pkg get https://github.com/GoogleCloudPlatform/anthos-service-mesh-packages.git/asm-iap@release-1.6-asm asm
```
4. Legen Sie die Projekt-ID für das Projekt fest, in dem der Cluster erstellt wurde:
```
kpt cfg set asm gcloud.core.project PROJECT_ID
```
5. Legen Sie die Projektnummer für das Flotten-Hostprojekt fest:
```
kpt cfg set asm gcloud.project.environProjectNumber ${FLEET_PROJECT_NUMBER}
```
6. Legen Sie den Clusternamen fest:
```
kpt cfg set asm gcloud.container.cluster ${CLUSTER_NAME}
```
7. Legen Sie die Standardzone oder -region fest:
```
kpt cfg set asm gcloud.compute.location ${CLUSTER_LOCATION}
```
8. Legen Sie den Validierungs-Webhook so fest, dass er ein Überarbeitungslabel verwendet:
```
kpt cfg set asm anthos.servicemesh.rev asm-1614-2
```
9. Legen Sie das Konfigurationsprofil fest Legen Sie für die IAP-Integration das Profil asm-gcp fest:
```
kpt cfg set asm anthos.servicemesh.profile asm-gcp
```
10. Legen Sie die HTTP- und Statusports für den Load-Balancer fest. Der Standardstatusport ist 31223 und der Standard-HTTP-Port ist 31224. Wenn diese Ports bereits verwendet werden, legen Sie folgende Ports fest:
```
kpt cfg set asm gcloud.container.cluster.ingress.httpPort HTTP_PORT
```
```
kpt cfg set asm gcloud.container.cluster.ingress.statusPort STATUS_PORT
```
11. Geben Sie die Werte der kpt-Setter aus:
```
kpt cfg list-setters asm
```
  Überprüfen Sie in der Ausgabe des Befehls, ob die Werte für die folgenden Setter korrekt sind:
  - anthos.servicemesh.rev
  - gcloud.compute.location
  - gcloud.container.cluster
  - gcloud.container.cluster.ingress.httpPort
  - gcloud.container.cluster.ingress.statusPort
  - gcloud.core.project
  - gcloud.project.environProjectNumber
Folgen Sie der Installationsanleitung im Abschnitt Anthos Service Mesh installieren. Nachdem Sie Anthos Service Mesh installiert haben, kehren Sie zu dieser Anleitung zurück und fahren mit dem nächsten Abschnitt fort, um die Integration in IAP einzurichten.

Upgrades

Die Schritte in diesem Abschnitt ergänzen die Schritte in der Anleitung Upgrade von Anthos Service Mesh auf GKE durchführen. In diesen Schritten werden die Umgebungsvariablen verwendet, die Sie im Upgrade-Leitfaden erstellen. In diesem Abschnitt werden folgende Anwendungsfälle für das Upgrade vorgestellt:

Sie haben die IAP-Integration bereits eingerichtet und führen ein Upgrade von Anthos Service Mesh durch. In diesem Fall haben Sie iap.googleapis.com für Ihr Projekt und das Add-on HttpLoadBalancing auf Ihrem Cluster bereits aktiviert. Sie können nun mit Schritt 3 fortfahren.
Sie führen ein Upgrade von Anthos Service Mesh durch und möchten die Verknüpfung zum ersten Mal mit IAP einrichten. In diesem Fall müssen Sie alle folgenden Schritte ausführen, das Upgrade von Anthos Service Mesh vornehmen und nach dem Upgrade zu dieser Anleitung zurückkehren, um die Integration abzuschließen.

Aktivieren Sie iap.googleapis.com.

gcloud services enable \
  --project=$PROJECT_ID \
  iap.googleapis.com

Aktivieren Sie das Add-on HttpLoadBalancing. Das HttpLoadBalancing-Add-on aktiviert einen HTTP (L7)-Load-Balancing-Controller für den Cluster.
```
gcloud container clusters update ${CLUSTER_NAME} \
  --project=PROJECT_ID \
  --update-addons=HttpLoadBalancing=ENABLED
```
Wenn Sie keine Standardzone oder -region festgelegt haben, müssen Sie im vorherigen Befehl die Region (--region=${CLUSTER_LOCATION}) oder Zone (--zone=${CLUSTER_LOCATION}) angeben.
Folgen Sie der Anleitung zum Festlegen von Anmeldedaten und Berechtigungen und laden Sie die Installationsdatei herunter. Stoppen Sie bei Ressourcenkonfigurationsdateien vorbereiten und führen Sie stattdessen die folgenden Schritte aus.
1. Erstellen Sie ein neues Verzeichnis für die Ressourcenkonfigurationsdateien des Anthos Service Mesh-Pakets. Es empfiehlt sich, den Clusternamen als Verzeichnisnamen zu verwenden.
2. Wechseln Sie zu dem Verzeichnis, in das Sie das Anthos Service Mesh-Paket herunterladen möchten.
3. Laden Sie das Paket asm-iap herunter: Für dieses Paket wird das Feld type für den Dienst istio-ingressgateway auf NodePort gesetzt. In dieser Konfiguration öffnet istio-ingressgateway einen bestimmten Port im Service Mesh. Dadurch können Sie einen Load-Balancer einrichten, der den an Ihren Domainnamen gesendeten Traffic an diesen Port weiterleitet.
```
kpt pkg get https://github.com/GoogleCloudPlatform/anthos-service-mesh-packages.git/asm-iap@release-1.6-asm asm
```
4. Legen Sie die Projekt-ID für das Projekt fest, in dem der Cluster erstellt wurde:
```
kpt cfg set asm gcloud.core.project PROJECT_ID
```
5. Legen Sie die Projektnummer für das Flotten-Hostprojekt fest:
```
kpt cfg set asm gcloud.project.environProjectNumber ${FLEET_PROJECT_NUMBER}
```
6. Legen Sie den Clusternamen fest:
```
kpt cfg set asm gcloud.container.cluster ${CLUSTER_NAME}
```
7. Legen Sie die Standardzone oder -region fest:
```
kpt cfg set asm gcloud.compute.location ${CLUSTER_LOCATION}
```
8. Legen Sie den Validierungs-Webhook so fest, dass er ein Überarbeitungslabel verwendet:
```
kpt cfg set asm anthos.servicemesh.rev asm-1614-2
```
9. Legen Sie das Konfigurationsprofil fest Legen Sie für die IAP-Integration das Profil asm-gcp fest:
```
kpt cfg set asm anthos.servicemesh.profile asm-gcp
```
10. Legen Sie die HTTP- und Statusports für den Load-Balancer fest. Der Standardstatusport ist 31223 und der Standard-HTTP-Port ist 31224.
  
  Wenn Sie einen vorhandenen HTTP-Cloud-Load-Balancer aktualisieren, führen Sie folgenden Befehl aus, um Ihre vorhandenen HTTP- und Status-Ports beizubehalten:
```
kpt cfg set asm gcloud.container.cluster.ingress.httpPort $(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].nodePort}')
```
```
kpt cfg set asm gcloud.container.cluster.ingress.statusPort $(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="status-port")].nodePort}')
```
  Bei Bedarf können Sie mit den vorherigen kpt-Settern andere Werte für die Ports festlegen.
11. Geben Sie die Werte der kpt-Setter aus:
```
kpt cfg list-setters asm
```
  Überprüfen Sie in der Ausgabe des Befehls, ob die Werte für die folgenden Setter korrekt sind:
  - anthos.servicemesh.rev
  - gcloud.compute.location
  - gcloud.container.cluster
  - gcloud.container.cluster.ingress.httpPort
  - gcloud.container.cluster.ingress.statusPort
  - gcloud.core.project
  - gcloud.project.environProjectNumber
Folgen Sie der Upgrade-Anleitung im Abschnitt Anthos Service Mesh aktualisieren.

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.

Reservieren Sie eine statische externe IP-Adresse:

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

Rufen Sie die statische IP-Adresse ab:

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

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.

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.

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.

Befolgen Sie die Schritte unter Bookinfo bereitstellen. Solange Sie den Load-Balancer nicht bereitstellen, kann außerhalb Ihres GKE-Clusters (z. B. über einen Browser) nicht auf die Bookinfo-Anwendung zugegriffen werden.

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. Obwohl die Knoten in Ihrem Cluster externe IP-Adressen haben, werden Anfragen von außerhalb des Clusters durch Google Cloud-Firewallregeln blockiert. Mit IAP können Anwendungen mithilfe eines Load-Balancers korrekt im öffentlichen Internet zugänglich gemacht werden. 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.

IAP aktivieren

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

Zustimmungsbildschirm konfigurieren

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
```
Hinweis: Wenn bereits eine Marke für ein Projekt vorhanden ist und für externe Nutzer (orgInternalOnly: false) konfiguriert wurde, sie aber auf interne Nutzer beschränkt werden soll, müssen Sie diese Änderung manuell über den OAuth-Zustimmungsbildschirm vornehmen, um OAuth-Clients mit dieser API zu erstellen.
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.
  
  Hinweis: Der Nutzer, der die Anfrage stellt, muss ein Inhaber der angegebenen Support-E-Mail-Adresse sein.
- 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

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]

Verwenden Sie die Client-ID (im obigen Beispiel CLIENT_ID) und CLIENT_SECRET, um IAP zu aktivieren. Erstellen Sie ein Kubernetes-Secret mit den Materialien aus Ihrem OAuth-Client:
```
kubectl create secret generic -n istio-system my-secret --from-literal=client_id=CLIENT_ID \
--from-literal=client_secret=CLIENT_SECRET
```

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.

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. Ersetzen Sie in der folgenden YAML-Datei DOMAIN_NAME durch den Domainnamen, den Sie für die externe statische IP-Adresse konfiguriert haben.
```
cat <<EOF | kubectl apply -f -
apiVersion: networking.gke.io/v1beta1
kind: ManagedCertificate
metadata:
  name: example-certificate
  namespace: istio-system
spec:
  domains:
    - DOMAIN_NAME
EOF
```

Erstellen Sie eine BackendConfig-Ressource. Diese Ressource weist GCLB an, wie Systemdiagnosen auf dem Ingress-Gateway durchgeführt und Identity-Aware Proxy konfiguriert werden. Erfassen Sie zuerst einige Werte aus dem Ingress-Gateway zu Systemdiagnosen:

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}')

cat <<EOF | kubectl apply -n istio-system -f -
apiVersion: cloud.google.com/v1beta1
kind: BackendConfig
metadata:
  name: http-hc-config
spec:
  healthCheck:
    checkIntervalSec: 2
    timeoutSec: 1
    healthyThreshold: 1
    unhealthyThreshold: 10
    port: ${HC_INGRESS_PORT}
    type: HTTP
    requestPath: ${HC_INGRESS_PATH}
  iap:
    enabled: true
    oauthclientCredentials:
      secretName: my-secret
EOF

Kommentieren Sie den Ingress-Dienst mit Ihrer BackendConfig-Ressource:

    kubectl annotate -n istio-system service/istio-ingressgateway --overwrite \
      cloud.google.com/backend-config='{"default": "http-hc-config"}' \
      cloud.google.com/neg='{"ingress":false}'

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
```
Hinweis: Es kann 10–20 Minuten dauern, bis der Load-Balancer funktioniert.
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.

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

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

Testen Sie den Load-Balancer. Öffnen Sie in Ihrem Browser folgende Adresse:
```
http://DOMAIN_NAME/productpage
```
Dabei ist 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.

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:

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
```
Erstellen Sie eine Umgebungsvariable für die RCToken-Zielgruppe. Dies kann ein beliebiger String sein.
```
export RCTOKEN_AUD="your-rctoken-aud"
```

Rufen Sie die vorhandenen IAP-Einstellungen ab:

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

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

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

cat <<EOF | kubectl apply -f -
apiVersion: "security.istio.io/v1beta1"
kind: "RequestAuthentication"
metadata:
  name: "ingressgateway-jwt-policy"
  namespace: "istio-system"
spec:
  selector:
    matchLabels:
      app: istio-ingressgateway
  jwtRules:
  - issuer: "https://cloud.google.com/iap"
    jwksUri: "https://www.gstatic.com/iap/verify/public_key-jwk"
    audiences:
    - $RCTOKEN_AUD
    fromHeaders:
    - name: ingress-authorization
      prefix: "Istio "
    outputPayloadToHeader: "verified-jwt"
    forwardOriginalToken: true
EOF

Stellen Sie sicher, dass Anfragen an die Bookinfo-productpage weiterhin erfolgreich sind:
```
http://DOMAIN_NAME/productpage
```

So testen Sie die Richtlinie:

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

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

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}

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:

Löschen Sie das verwaltete Zertifikat:

kubectl delete managedcertificates example-certificate

Löschen Sie das Ingress, wodurch die Zuweisung der Load-Balancing-Ressourcen aufgehoben wird:
```
kubectl -n istio-system delete ingress example-ingress
```
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.
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}
```