Sie sehen die Dokumentation zum Service Mesh für Version 1.21.

Verfügbare Versionen

Cloud Service Mesh
1.22-Archiv
1.21-Archiv
1.20-Archiv
1.19-Archiv
1.18-Archiv

Diese Seite wurde von der Cloud Translation API übersetzt.

IAP in das Cloud Service Mesh einbinden

In diesem Leitfaden wird beschrieben, wie Sie Identity-Aware Proxy (IAP) mit Cloud Service Mesh. Die IAP-Integration in Cloud Service Mesh ermöglicht es Ihnen, sicher auf Dienste zuzugreifen, BeyondCorp-Prinzipien. 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. IAP-Einbindung in Cloud Service Mesh bietet folgende Vorteile:

Vollständige Steuerung des kontextsensitiven Zugriffs auf Arbeitslasten, die in Cloud 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 Cloud 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

<ph type="x-smartling-placeholder"> Führen Sie die Schritte unter Abhängige Tools installieren und Cluster validieren aus, um Folgendes zu tun:

Außerdem wird für diese Anleitung Folgendes benötigt:

Cluster mit Anthos Service Mesh einrichten

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

Neuinstallationen

Aktivieren Sie iap.googleapis.com. Ersetzen Sie im folgenden Befehl PROJECT_IDdurch das Projekt, das Sie installieren Cloud Service Mesh in:
```
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, Aktualisieren Sie den Cluster mit den für das Cloud Service Mesh erforderlichen Optionen. 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
```
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:

Wichtig: Sie müssen eine kpt-Version vor Version 1.0 verwenden.
```
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 in Standardfeatures und Mesh CA installieren ein von Google bereitgestelltes Skript zum Installieren von Cloud Service Mesh zu verwenden. Schließen Sie beim Ausführen des Skripts die folgende Option ein:
```
--option iap-operator
```
Beispiel:
```
./asmcli install \
  --project_id "PROJECT_ID" \
  --cluster_name "CLUSTER_NAME" \
  --cluster_location "CLUSTER_LOCATION" \
  --fleet_id FLEET_PROJECT_ID \
  --output_dir DIR_PATH \
  --enable_all \
  --option iap-operator
```
Wenn Sie Cloud Service Mesh installieren, iap-operator.yaml wird für das Feld type im Dienst istio-ingressgateway festgelegt: NodePort, die das Gateway so konfiguriert, dass ein bestimmter Port auf dem Service Mesh. Dadurch können Sie einen Load-Balancer einrichten, der den an Ihren Domainnamen gesendeten Traffic an diesen Port weiterleitet.
Wenn Sie das verwaltete Cloud Service Mesh installieren, führen Sie auch die folgenden Schritten:
1. Wenden Sie das Überarbeitungslabel auf den istio-system-Namespace an.
2. Laden Sie die Istio-Ingress-Gateway-Dienstspezifikation für IAP herunter und nennen Sie sie iap_operator.yaml.
3. Installieren Sie das Ingress als NodePort-Dienst. Weitere Informationen finden Sie unter Von IstioOperator migrieren.
```
asmcli experimental mcp-migrate-check -f iap_operator.yaml

istioctl install -f /asm-generated-configs/gateways-istiooperator/"GATEWAY_NAME".yaml
```

Kehren Sie nach der Installation von Cloud Service Mesh zu dieser Anleitung zurück und fahren Sie mit dem um die IAP-Integration einzurichten.

Upgrades

In diesem Abschnitt werden folgende Anwendungsfälle für das Upgrade vorgestellt:

Sie haben die IAP-Integration bereits eingerichtet Cloud Service Mesh wird aktualisiert. 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 asm-Paket herunterzuladen und ein Upgrade des Cloud Service Mesh ausführen.
Sie führen ein Upgrade des Cloud Service Mesh durch und möchten die Integration mit für In-App-Käufe bereitstellen. In diesem Fall müssen Sie Führen Sie alle folgenden Schritte aus, führen Sie ein Upgrade des Cloud Service Mesh durch und kehren Sie zu diesem Leitfaden zurück nach dem Upgrade, um die Integration abzuschließen.

Aktivieren Sie iap.googleapis.com. Ersetzen Sie im folgenden Befehl PROJECT_IDdurch das Projekt, das Sie installieren Cloud Service Mesh eingebunden.
```
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, Aktualisieren Sie den Cluster mit den für das Cloud Service Mesh erforderlichen Optionen. 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
```

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

Folgen Sie der Anleitung in Cloud Service Mesh aktualisieren ein von Google bereitgestelltes Skript zum Upgraden von Cloud Service Mesh zu verwenden.

Wenn Sie ein Cloud Service Mesh-Upgrade durchführen, legt die Datei iap-operator.yaml Folgendes fest: type für den istio-ingressgateway-Dienst auf NodePort, die konfiguriert das Gateway so, dass ein bestimmter Port im Service Mesh geöffnet wird. 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.

Schließen Sie beim Ausführen des Skripts die folgende Option ein:
```
--option iap-operator
```
Beispiel:
```
./asmcli install \
  --project_id "PROJECT_ID" \
  --cluster_name "CLUSTER_NAME" \
  --cluster_location "CLUSTER_LOCATION" \
  --fleet_id FLEET_PROJECT_ID \
  --output_dir DIR_PATH \
  --enable_all \
  --option iap-operator
```
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

Wenn Sie Identity-Aware Proxy in Cloud Service Mesh einbinden möchten, müssen Sie ein Google Cloud HTTP(S)-Load-Balancer, für den ein Domainname erforderlich ist, der auf einer statischen IP-Adresse. 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. Sie haben bei der Bereitstellung des Cloud Service Mesh NodePort für das istio-ingressgateway, 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 einen HTTP(S)-Load-Balancer in Ihrem Google Cloud-Projekt 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.

Verwenden Sie die Client-ID (im obigen Schritt CLIENT_ID) und CLIENT_SECRET, um Cloud Service Mesh 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. 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/v1
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:

Ingress-Port für Systemdiagnose: 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}')

Ingress-Pfad der Systemdiagnose: Dies ist der Pfad für die Systemdiagnose von istio-ingress.

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

cat <<EOF | kubectl apply -n istio-system -f -
apiVersion: cloud.google.com/v1
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 apply -f -
apiVersion: networking.k8s.io/v1
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:
  defaultBackend:
    service:
      name: istio-ingressgateway
      port:
        number: 80
EOF
```
Hinweis: Es kann 10 bis 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 Cloud Service Mesh können Sie IAP so konfigurieren, dass ein RequestContextToken (RCToken), das ein JWT mit einer konfigurierbaren Zielgruppe ist. Mit RCToken können Sie die Zielgruppe des JWT auf einen beliebigen String konfigurieren, können in den Cloud Service Mesh-Richtlinien für eine detaillierte Autorisierung verwendet werden.

So konfigurieren Sie das RCToken:

Erstellen Sie eine Umgebungsvariable für die RCToken-Zielgruppe. Dies kann ein beliebiger String sein.
```
export RCTOKEN_AUD="your-rctoken-aud"
```
Optional: Für folgenden Schritt ist BACKEND_SERVICE_ID erforderlich. Wenn Sie den BACKEND_SERVICE_ID ermitteln möchten, führen Sie folgenden Befehl aus:
```
kubectl -n istio-system get Ingress example-ingress -o json | jq \
 '.metadata.annotations."ingress.kubernetes.io/backends"'
```
Die erwartete Ausgabe ähnelt "{\"BACKEND_SERVICE_ID\":\"HEALTHY\"}". Beispiel: "ingress.kubernetes.io/backends": "{\"k8s-be-31224--51f3b55cd1457fb6\":\"HEALTHY\"}" Die BACKEND_SERVICE_ID in diesem Beispiel ist k8s-be-31224--51f3b55cd1457fb6.

Rufen Sie die vorhandenen IAP-Einstellungen ab.

gcloud iap settings get --format json \
--project=${PROJECT_ID} --resource-type=compute --service=BACKEND_SERVICE_ID > 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 iap settings set updatedIapSettings.json --format json \
--project=${PROJECT_ID} --resource-type=compute --service=BACKEND_SERVICE_ID

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:

  cat <<EOF | kubectl apply -f -
  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: ["*"]
  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:

cat iapSettings.json | jq --arg RCTOKEN_AUD_STR wrong-rctoken-aud \
'. + {applicationSettings: {csmSettings: {rctokenAud: $RCTOKEN_AUD_STR}}}' \
> wrongIapSettings.json

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

gcloud beta iap settings set wrongIapSettings.json --project=PROJECT_ID --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.
Cluster löschen, wodurch die Ressourcen gelöscht werden, aus denen die Cluster wie die Compute-Instanzen, Laufwerke und Netzwerkressourcen:
```
gcloud container clusters delete CLUSTER_NAME
```