Anthos Service Mesh 1.8 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

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

In diesem Abschnitt wird erläutert, wie Sie die IAP-Integration für die Neuinstallation von Anthos Service Mesh und Upgrades einrichten.

Neuinstallationen

Aktivieren Sie iap.googleapis.com. Ersetzen Sie im folgenden Befehl PROJECT_ID durch das Projekt, in dem Sie Anthos Service Mesh installieren:
```
gcloud services enable \
  --project=PROJECT_ID \
  iap.googleapis.com
```
Für den Cluster, den Sie aktualisieren, muss die Option --addons=HttpLoadBalancing festgelegt sein. Das HttpLoadBalancing-Add-on aktiviert einen HTTP (L7)-Load-Balancing-Controller für den Cluster. Führen Sie den folgenden Befehl aus, um den Cluster mit den für Anthos Service Mesh erforderlichen Optionen zu aktualisieren: Sofern Sie keine Standardzone oder -region festgelegt haben, müssen Sie in dem Befehl die Region (--region=REGION) oder Zone (--zone=ZONE) angeben.
```
gcloud container clusters update CLUSTER_NAME \
  --project=PROJECT_ID \
  --update-addons=HttpLoadBalancing=ENABLED
```
Laden Sie das Paket asm herunter, das eine Konfigurationsdatei mit dem Namen iap-operator.yaml im Verzeichnis asm/istio/options enthält:
```
kpt pkg get \
https://github.com/GoogleCloudPlatform/anthos-service-mesh-packages.git/asm@release-1.8-asm asm
```
Wenn Sie Anthos Service Mesh installieren, legt die Datei iap-operator.yaml das Feld type für den Dienst istio-ingressgateway auf NodePort fest. Dadurch wird das Gateway so konfiguriert, dass ein bestimmter Port im Service Mesh. Dadurch können Sie einen Load-Balancer einrichten, der den an Ihren Domainnamen gesendeten Traffic an diesen Port weiterleitet.

Standardmäßig ist für die Datei iap-operator.yaml Port 31223 als Statusport und Port 31224 als HTTP-Port festgelegt.
Wenn Port 31223 im Cluster bereits verwendet wird, führen Sie den folgenden Befehl aus, um einen anderen Statusport einzurichten:
```
kpt cfg set asm gcloud.container.cluster.ingress.statusPort STATUS_PORT
```
Wenn Port 31224 in Ihrem Cluster bereits verwendet wird, führen Sie den folgenden Befehl aus, um einen anderen HTTP-Port einzustellen:
```
kpt cfg set asm gcloud.container.cluster.ingress.httpPort HTTP_PORT
```

Folgen Sie der Anleitung unter Anthos Service Mesh in GKE installieren, um Anthos Service Mesh mit einem von Google bereitgestellten Skript zu installieren. Schließen Sie beim Ausführen des Skripts die folgende Option ein:

--custom_overlay asm/istio/options/iap-operator.yaml

Beispiel:

./install_asm \
  --project_id PROJECT_ID \
  --cluster_name CLUSTER_NAME \
  --cluster_location CLUSTER_LOCATION \
  --mode install \
  --enable_all \
  --custom_overlay asm/istio/options/iap-operator.yaml

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

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 ist in Ihrem Projekt bereits iap.googleapis.com für das Projekt und das Add-on HttpLoadBalancing aktiviert. Fahren Sie mit Schritt 3 fort, um das Paket asm herunterzuladen und Anthos Service Mesh zu aktualisieren.
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. Ersetzen Sie im folgenden Befehl PROJECT_ID durch das Projekt, in dem Sie Anthos Service Mesh installieren:
```
gcloud services enable \
  --project=PROJECT_ID \
  iap.googleapis.com
```
Für den Cluster, den Sie aktualisieren, muss die Option --addons=HttpLoadBalancing festgelegt sein. Das HttpLoadBalancing-Add-on aktiviert einen HTTP (L7)-Load-Balancing-Controller für den Cluster. Führen Sie den folgenden Befehl aus, um den Cluster mit den für Anthos Service Mesh erforderlichen Optionen zu aktualisieren: Sofern Sie keine Standardzone oder -region festgelegt haben, müssen Sie in dem Befehl die Region (--region=REGION) oder Zone (--zone=ZONE) angeben.
```
gcloud container clusters update CLUSTER_NAME \
  --project=PROJECT_ID
  --update-addons=HttpLoadBalancing=ENABLED
```
Laden Sie das Paket asm herunter, das eine Konfigurationsdatei mit dem Namen iap-operator.yaml im Verzeichnis asm/istio/options enthält:
```
kpt pkg get \
https://github.com/GoogleCloudPlatform/anthos-service-mesh-packages.git/asm@release-1.8-asm asm
```
Wenn Sie Anthos Service Mesh aktualisieren, legt die Datei iap-operator.yaml das Feld type für den Dienst istio-ingressgateway auf NodePort fest. Dadurch wird das Gateway so konfiguriert, dass ein bestimmter Port im Service Mesh. Dadurch können Sie einen Load-Balancer einrichten, der den an Ihren Domainnamen gesendeten Traffic an diesen Port weiterleitet.

Standardmäßig ist für die Datei iap-operator.yaml Port 31223 als Statusport und Port 31224 als HTTP-Port festgelegt.

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

Führen Sie die Schritte unter Anthos Service Mesh in GKE upgraden aus, um ein von Google bereitgestelltes Skript zum Upgrade von Anthos Service Mesh zu verwenden. Schließen Sie beim Ausführen des Skripts die folgende Option ein:
```
--custom_overlay asm/istio/options/iap-operator.yaml
```
Beispiel:
```
./install_asm \
  --project_id PROJECT_ID \
  --cluster_name CLUSTER_NAME \
  --cluster_location CLUSTER_LOCATION \
  --mode upgrade \
  --enable_all \
  --custom_overlay asm/revisioned-istio-ingressgateway.yaml \
  --custom_overlay asm/istio/options/iap-operator.yaml
```
Achten Sie beim Ausführen des Skripts darauf, revisioned-istio-ingressgateway.yaml wie im vorherigen Beispiel anzugeben. Mit dieser Option erstellt das Skript ein überarbeitetes istio-ingressgateway-Deployment. So können Sie steuern, wann Sie zur neuen Version wechseln. Wenn Sie diese Option nicht angeben, führt das Skript ein direktes Upgrade von istio-ingressgateway durch.
Schließen Sie das Upgrade ab, um das automatische einfügen des Sidecar-Proxys für Ihre Arbeitslasten auszulösen. Weitere Informationen finden Sie unter Arbeitslasten bereitstellen und bereitstellen.

Kehren Sie nach Abschluss des Upgrades zu dieser Anleitung zurück und fahren Sie mit dem nächsten Abschnitt fort, um die Integration mit IAP einzurichten.

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=YOUR_PROJECT_NUMBER --resource-type=compute --service=BACKEND_SERVICE > 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=YOUR_PROJECT_NUMBER --resource-type=compute --service=BACKEND_SERVICE

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

Optional: Prüfen Sie, ob Anfragen ohne gültige JWTs abgelehnt werden:

  apiVersion: security.istio.io/v1beta1
  kind: AuthorizationPolicy
  metadata:
    name: iap-gateway-require-jwt
    namespace: istio-system
  spec:
    selector:
      matchLabels:
        app: istio-iap-ingressgateway
    action: DENY
    rules:
      - from:
          - source:
              notRequestPrincipals: ["*"]

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/YOUR_PROJECT_NUMBER/iap_web/compute/services/BACKEND_SERVICE",
   "applicationSettings": {
     "csmSettings": {
       "rctokenAud": "some-other-arbitrary-string"
     }
   }
 }
EOF
) > request.txt

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

gcloud beta iap settings update request.txt --project=YOUR_PROJECT_NUMBER --resource-type=compute --service=${BACKEND_SERVICE}

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}
```