Anthos Service Mesh 1.4 ist abgelaufen und wird nicht mehr unterstützt. Informationen zum Upgraden finden Sie unter Upgrade von früheren Versionen. Lesen Sie die aktuelle Dokumentation oder wählen Sie eine andere Version aus:

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.

Ziele

  • Cloud-Projekt einrichten:
    1. Richten Sie Ihr Cloud-Projekt ein, um die Berechtigungen zu erteilen 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 dieser Anleitung werden die folgenden kostenpflichtigen Komponenten von Google Cloud verwendet:

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 dieser Anleitung können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweis

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 9443 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 der Cloud Shell über die Befehlszeile zugreifen.

So verwenden Sie Cloud Shell:

  1. Gehen Sie zur Cloud Console.
  2. Wählen Sie Ihr Cloud-Projekt aus.
  3. Klicken Sie im oberen Bereich des Cloud Console-Fensters auf Cloud Shell aktivieren.

    Google Cloud Platform Console

    Im unteren Bereich der Cloud Console wird ein neuer Frame 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 Cloud SDK 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 auf Ihrem lokalen Computer das Cloud SDK (das gcloud-Befehlszeilentool).

Wenn Sie das Cloud SDK bereits installiert haben:

  1. Authentifizieren Sie sich beim Cloud SDK:

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

In diesem Abschnitt werden die Grundlagen zum Erstellen eines GKE-Clusters mit den für Anthos Service Mesh erforderlichen Optionen beschrieben. Weitere Informationen finden Sie unter Cluster erstellen.

So richten Sie einen neuen Cluster ein:

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

    • Wenn Sie einen Einzelzonencluster erstellen, führen Sie den folgenden Befehl aus, um eine Liste der verfügbaren GCP-Zonen abzurufen:

      gcloud compute zones list
      
    • Wenn Sie einen regionalen Cluster erstellen, führen Sie den folgenden Befehl aus, um eine Liste der verfügbaren Regionen abzurufen:

      gcloud compute regions 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 entweder auf Ihre Clusterzone oder Clusterregion fest:

      export CLUSTER_LOCATION=YOUR_ZONE_OR_REGION
    • 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}"
    • Legen Sie die Release-Version fest. Ersetzen Sie YOUR_CHANNEL durch einen der folgenden Werte: regular, stable oder rapid.

      export CHANNEL=YOUR_CHANNEL

      Eine Beschreibung der einzelnen Versionen finden Sie unter Welche Kanäle sind verfügbar?.

  3. Legen Sie die Standardzone oder -region für das gcloud-Befehlszeilentool fest.

    • Legen Sie für einen Einzelzonencluster die Standardzone fest:

      gcloud config set compute/zone ${CLUSTER_LOCATION}
    • Legen Sie für einen regionalen Cluster die Standardregion fest:

      gcloud config set compute/region ${CLUSTER_LOCATION}

    Tipp: Um die Einrichtung Ihrer Shell-Umgebung in Zukunft zu erleichtern, können Sie die export-Anweisungen für jede Umgebungsvariable kopieren und in ein einfaches Shell-Skript einfügen, das Sie beim Start einer neuen Shell beziehen (source). Außerdem können Sie die gcloud-Befehle hinzufügen, die Standardwerte zum Skript festlegen. Sie können auch gcloud init verwenden, um eine benannte gcloud-Konfiguration zu erstellen und zu aktivieren.

  4. Erstellen Sie den Cluster mit den von Anthos Service Mesh benötigten Optionen. Mit dem folgenden Befehl wird ein Cluster mit 4 Knoten des Maschinentyps e2-standard-4 mit 4 vCPUs erstellt. 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} \
        --machine-type=e2-standard-4 \
        --num-nodes=4 \
        --workload-pool=${WORKLOAD_POOL} \
        --enable-stackdriver-kubernetes \
        --subnetwork=default \
        --labels=mesh_id=${MESH_ID} \
        --release-channel=${CHANNEL}

    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 den Anthos Service Mesh-Seiten in der Cloud Console angezeigt werden.

    • release-channel ${CHANNEL}: Registriert den Cluster in der angegebenen Release-Version.

Installation von Anthos Service Mesh vorbereiten

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 durch den vorherigen Befehl nichts ausgegeben wird, kehren Sie zum Abschnitt Anmeldedaten und Berechtigungen festlegen zurück und führen 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.4.10-asm.18-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.4.10-asm.18-linux.tar.gz.1.sig
    openssl dgst -verify - -signature istio-1.4.10-asm.18-linux.tar.gz.1.sig istio-1.4.10-asm.18-linux.tar.gz <<'EOF'
    -----BEGIN PUBLIC KEY-----
    MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
    wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
    -----END PUBLIC KEY-----
    EOF

    Die erwartete Ausgabe ist Verified OK.

  3. 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.4.10-asm.18-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.4.10-asm.18-osx.tar.gz.1.sig
    openssl dgst -sha256 -verify /dev/stdin -signature istio-1.4.10-asm.18-osx.tar.gz.1.sig istio-1.4.10-asm.18-osx.tar.gz <<'EOF'
    -----BEGIN PUBLIC KEY-----
    MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
    wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
    -----END PUBLIC KEY-----
    EOF

    Die erwartete Ausgabe ist Verified OK.

  6. 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.4.10-asm.18-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.4.10-asm.18-win.zip.1.sig
    openssl dgst -verify - -signature istio-1.4.10-asm.18-win.zip.1.sig istio-1.4.10-asm.18-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.4.10-asm.18-linux.tar.gz

    Mit diesem Befehl wird in Ihrem aktuellen Arbeitsverzeichnis istio-1.4.10-asm.18 ein Installationsverzeichnis 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.4.10-asm.18
  11. Fügen Sie die Tools der Einfachheit halber im Verzeichnis /bin Ihrem PATH hinzu.
    export PATH=$PWD/bin:$PATH

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 \
  --set values.gateways.istio-ingressgateway.type=NodePort \
  --set values.global.trustDomain=${WORKLOAD_POOL} \
  --set values.global.sds.token.aud=${WORKLOAD_POOL} \
  --set values.nodeagent.env.GKE_CLUSTER_URL=https://container.googleapis.com/v1/projects/${PROJECT_ID}/locations/${CLUSTER_LOCATION}/clusters/${CLUSTER_NAME} \
  --set values.global.meshID=${MESH_ID} \
  --set values.global.proxy.env.GCP_METADATA="${PROJECT_ID}|${PROJECT_NUMBER}|${CLUSTER_NAME}|${CLUSTER_LOCATION}"

STRICT-mTLS

istioctl manifest apply --set profile=asm \
  --set values.gateways.istio-ingressgateway.type=NodePort \
  --set values.global.trustDomain=${WORKLOAD_POOL} \
  --set values.global.sds.token.aud=${WORKLOAD_POOL} \
  --set values.nodeagent.env.GKE_CLUSTER_URL=https://container.googleapis.com/v1/projects/${PROJECT_ID}/locations/${CLUSTER_LOCATION}/clusters/${CLUSTER_NAME} \
  --set values.global.meshID=${MESH_ID} \
  --set values.global.proxy.env.GCP_METADATA="${PROJECT_ID}|${PROJECT_NUMBER}|${CLUSTER_NAME}|${CLUSTER_LOCATION}" \
  --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.

Komponenten der Steuerungsebene prüfen

Prüfen Sie, ob die Pods der Steuerungsebene in istio-system aktiv sind:

kubectl get pod -n istio-system

Die Ausgabe sollte in etwa so aussehen:

NAME                                      READY   STATUS      RESTARTS   AGE
istio-galley-5c65896ff7-m2pls             2/2     Running     0          18m
istio-ingressgateway-587cd459f-q6hqt      2/2     Running     0          18m
istio-nodeagent-74w69                     1/1     Running     0          18m
istio-nodeagent-7524w                     1/1     Running     0          18m
istio-nodeagent-7652w                     1/1     Running     0          18m
istio-nodeagent-7948w                     1/1     Running     0          18m
istio-pilot-9db77b99f-7wfb6               2/2     Running     0          18m
istio-sidecar-injector-69c4d9f875-dt8rn   1/1     Running     0          18m
promsd-55f464d964-lqs7w                   2/2     Running     0          18m

Für jeden Knoten in Ihrem Cluster sollte eine Instanz von istio-nodeagent angezeigt werden. Das Feature „Mesh CA“, das die OSS-Istio-Komponente „Citadel“ ersetzt, erstellt die Knoten-Agents, um mTLS-Zertifikate für die in Ihrem Service Mesh ausgeführten Arbeitslasten auszustellen.

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.

Zur Weiterleitung von Anfragen an Bookinfo richten Sie einen HTTP(S)-Load-Balancer in Ihrem Cloud-Projekt 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
    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: Verbindet verschiedene Instanzgruppen über einen bestimmten NodePort-Dienst.

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

      • Systemdiagnose: Dies ist die standardmäßige Systemdiagnose, die bei der Bereitstellung von Ingress automatisch erstellt wird.

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

      • Ingress-Port für Systemdiagnose: Dies ist der Port der Systemdiagnose für istio-ingress.

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

      • Ingress-Pfad für Systemdiagnose: Dies ist der Pfad der Systemdiagnose für istio-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 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 alpha 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 alpha 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 alpha iap oauth-clients create projects/PROJECT_ID/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

Pod-Sicherheitsrichtlinien aktivieren

Wenn Sie Pod-Sicherheitsrichtlinien aktivieren, achten Sie darauf, dass manipulierte Namespaces (außer istio-system) die Sicherheit anderer Namespaces, die sich die gleichen Knoten teilen, nicht beeinträchtigen. Beispiel-PodSecurityPolicy-Ressourcendateien, die mit Mesh-CA funktionieren, werden mit Anthos Service Mesh bereitgestellt. Sie können diese Dateien bei Bedarf ändern. Im Folgenden wenden Sie zuerst die Pod-Sicherheitsrichtlinien an und aktivieren dann die Pod-Sicherheitsrichtlinie für den GKE-Cluster.

  1. Wenden Sie die standardmäßige Pod-Sicherheitsrichtlinie auf alle Dienstkonten im Cluster an:

    kubectl apply -f "samples/security/psp/all-pods-psp.yaml"
    
  2. Wenden Sie die Pod-Sicherheitsrichtlinie an, um den Secret Discovery Service (SDS) zu schützen:

    kubectl apply -f "samples/security/psp/citadel-agent-psp.yaml"
    

    Dadurch erhält der Citadel-Agent (auch Knoten-Agent genannt) die Berechtigung, den UDS-Pfad /var/run/sds auf der Host-VM zu erstellen.

  3. Führen Sie den folgenden Befehl aus, um die Pod-Sicherheitsrichtlinie zu aktivieren:

    gcloud beta container clusters update ${CLUSTER_NAME} \
        --enable-pod-security-policy
    

    Das Aktivieren der Pod-Sicherheitsrichtlinien kann einige Minuten dauern. Bestehende Arbeitslasten können während dieses Vorgangs keine Verbindung zum Kubernetes-Master herstellen. Warten Sie, bis der Kubernetes-Master wieder einsatzbereit ist. Sie können den Clusterstatus in der Google Cloud Console auf der Seite "Kubernetes-Cluster" prüfen.

    Weitere Informationen finden Sie unter Pod-Sicherheitsrichtlinien verwenden.

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 des Clusters gelöscht, z. B. die Compute-Instanzen, Laufwerke und Netzwerkressourcen:

    gcloud container clusters delete ${CLUSTER_NAME}