Über GKE-Arbeitslasten bei Google Cloud APIs authentifizieren

Autopilot Standard

In diesem Dokument erfahren Sie, wie Sie mithilfe von Workload Identity Federation für GKE von Ihren Arbeitslasten, die in Google Kubernetes Engine-Clustern (GKE) ausgeführt werden, sicherer auf Google Cloud APIs zugreifen. Weitere Informationen finden Sie unter Identitätsföderation von Arbeitslasten für GKE.

Hinweise

Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:

Aktivieren Sie die Google Kubernetes Engine API.

Google Kubernetes Engine API aktivieren

Wenn Sie die Google Cloud CLI für diese Aufgabe verwenden möchten, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit gcloud components update ab.
Hinweis: Legen Sie für vorhandene Installationen der gcloud CLI die compute/region- und compute/zone-Attribute fest. Durch das Festlegen von Standardspeicherorten können Sie in der gcloud CLI Fehler wie One of [--zone, --region] must be supplied: Please specify location vermeiden.

Achten Sie darauf, dass die Google Cloud APIs, auf die Sie zugreifen möchten, von Workload Identity Federation for GKE unterstützt werden. Eine Liste der unterstützten APIs finden Sie unter Unterstützte Produkte und Einschränkungen. Wenn die API nicht unterstützt wird oder Ihr Anwendungsfall durch die Einschränkungen der Workload Identity-Föderation für diesen Dienst blockiert wird, finden Sie weitere Informationen unter Alternativen: Kubernetes-ServiceAccounts mit IAM verknüpfen in dieses Dokument.
Achten Sie darauf, dass die IAM Service Account Credentials API aktiviert ist.

IAM Credentials API aktivieren
Prüfen Sie, ob Sie die folgenden IAM-Rollen haben:
- roles/container.admin
- roles/iam.serviceAccountAdmin
Machen Sie sich mit den Einschränkungen der Identitätsföderation von Arbeitslasten für GKE vertraut.

Workload Identity-Föderation für GKE in Clustern und Knotenpools aktivieren

In Autopilot ist Workload Identity-Föderation für GKE standardmäßig aktiviert. Fahren Sie mit dem Abschnitt Anwendungen für die Verwendung von Workload Identity-Föderation für GKE konfigurieren fort.

In Standard aktivieren Sie die Workload Identity-Föderation für GKE in Clustern und Knotenpools mithilfe der Google Cloud CLI oder der Google Cloud Console. Die Identitätsföderation von Arbeitslasten für GKE muss auf Clusterebene aktiviert werden, bevor Sie die Workload Identity-Föderation für GKE in Knotenpools aktivieren können.

Neuen Cluster erstellen

Sie können die Identitätsföderation von Arbeitslasten für GKE in einem neuen Standardcluster mit der gcloud CLI oder der Google Cloud Console aktivieren.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Führen Sie den folgenden Befehl aus, um die Identitätsföderation von Arbeitslasten für GKE in einem neuen Cluster zu aktivieren:
```
gcloud container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --workload-pool=PROJECT_ID.svc.id.goog
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME: Der Name des neuen Clusters.
- LOCATION: der Compute Engine-Standort für den Cluster.
- PROJECT_ID ist Ihre Google Cloud-Projekt-ID.

Console

So aktivieren Sie die Identitätsföderation von Arbeitslasten für GKE für einen neuen Cluster:

Rufen Sie in der Google Cloud Console die Seite Google Kubernetes Engine auf.

Zur Seite „Google Kubernetes Engine“
Klicken Sie auf Erstellen.
Klicken Sie im Dialogfeld Cluster erstellen für GKE Standard auf Konfigurieren.
Klicken Sie im Navigationsmenü im Bereich Cluster auf Sicherheit.
Klicken Sie das Kästchen Workload Identity aktivieren an.
Fahren Sie mit der Konfiguration des Clusters fort und klicken Sie dann auf Erstellen.

Vorhandenen Cluster aktualisieren

Sie können die Identitätsföderation von Arbeitslasten für GKE in einem vorhandenen Standardcluster mit der gcloud CLI oder der Google Cloud Console aktivieren. Vorhandene Knotenpools sind davon nicht betroffen, aber alle neuen Knotenpools im Cluster verwenden die Identitätsföderation von Arbeitslasten für GKE.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Führen Sie den folgenden Befehl aus, um die Identitätsföderation von Arbeitslasten für GKE in einem vorhandenen Cluster zu aktivieren:
```
gcloud container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --workload-pool=PROJECT_ID.svc.id.goog
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME ist der Name Ihres vorhandenen Clusters.
- LOCATION ist der Compute Engine-Standort des Clusters.
- PROJECT_ID ist Ihre Google Cloud-Projekt-ID.

Console

So aktivieren Sie die Identitätsföderation von Arbeitslasten für GKE in einem vorhandenen Cluster:

Rufen Sie in der Google Cloud Console die Seite Google Kubernetes Engine auf.

Zur Seite „Google Kubernetes Engine“
Klicken Sie in der Clusterliste auf den Namen des Clusters, den Sie ändern möchten.
Klicken Sie auf der Seite mit den Clusterdetails im Abschnitt Sicherheit auf Workload Identity bearbeiten.
Klicken Sie im Dialogfeld Workload Identity bearbeiten das Kästchen Workload Identity aktivieren an.
Klicken Sie auf Änderungen speichern.

Vorhandene Arbeitslasten zur Identitätsföderation von Arbeitslasten für GKE migrieren

Nachdem Sie die Identitätsföderation von Arbeitslasten für GKE in einem vorhandenen Cluster aktiviert haben, können Sie die laufenden Arbeitslasten migrieren, um die Identitätsföderation von Arbeitslasten für GKE zu verwenden. Wählen Sie die für Ihre Umgebung am besten geeignete Migrationsstrategie aus. Sie können neue Knotenpools mit aktiviertem Identitätsföderation von Arbeitslasten für GKE erstellen oder vorhandene Knotenpools aktualisieren, um die Identitätsföderation von Arbeitslasten für GKE zu aktivieren.

Es ist empfehlenswert, neue Knotenpools zu erstellen, wenn Sie Ihre Anwendungen ebenfalls ändern müssen, damit sie mit der Identitätsföderation von Arbeitslasten für GKE kompatibel sind.

Einen neuen Knotenpool erstellen

Alle neuen Knotenpools, die Sie erstellen, verwenden standardmäßig die Identitätsföderation von Arbeitslasten für GKE, wenn für den Cluster die Identitätsföderation von Arbeitslasten für GKE aktiviert ist. Führen Sie den folgenden Befehl aus, um einen neuen Knotenpool mit aktivierter Identitätsföderation von Arbeitslasten für GKE zu erstellen:

gcloud container node-pools create NODEPOOL_NAME \
    --cluster=CLUSTER_NAME \
    --region=COMPUTE_REGION \
    --workload-metadata=GKE_METADATA

Ersetzen Sie Folgendes:

NODEPOOL_NAME: der Name des neuen Knotenpools.
CLUSTER_NAME: der Name des vorhandenen Clusters, für den die Identitätsföderation von Arbeitslasten für GKE aktiviert ist.

Das Flag --workload-metadata=GKE_METADATA konfiguriert den Knotenpool für die Verwendung des GKE-Metadatenservers. Wir empfehlen, das Flag anzugeben, damit die Erstellung des Knotenpools fehlschlägt, wenn die Identitätsföderation von Arbeitslasten für GKE nicht im Cluster aktiviert ist.

Vorhandenen Knotenpool aktualisieren

Sie können die Identitätsföderation von Arbeitslasten für GKE in vorhandenen Knotenpools manuell aktivieren, nachdem Sie die Identitätsföderation von Arbeitslasten für GKE auf dem Cluster aktiviert haben.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Führen Sie den folgenden Befehl aus, um einen vorhandenen Knotenpool für die Verwendung der Identitätsföderation von Arbeitslasten für GKE zu ändern:
```
gcloud container node-pools update NODEPOOL_NAME \
    --cluster=CLUSTER_NAME \
    --region=COMPUTE_REGION \
    --workload-metadata=GKE_METADATA
```
Wenn für einen Cluster die Identitätsföderation von Arbeitslasten für GKE aktiviert ist, können Sie sie gezielt für einen bestimmten Knotenpool deaktivieren, indem Sie --workload-metadata=GCE_METADATA angeben. Weitere Informationen finden Sie unter Clustermetadaten schützen.

Console

Führen Sie die folgenden Schritte aus, um einen vorhandenen Knotenpool für die Verwendung der Identitätsföderation von Arbeitslasten für GKE zu ändern:

Rufen Sie in der Google Cloud Console die Seite Google Kubernetes Engine auf.

Zur Seite „Google Kubernetes Engine“
Klicken Sie in der Clusterliste auf den Namen des Clusters, den Sie ändern möchten.
Klicken Sie auf den Tab Knoten.
Klicken Sie im Bereich Knotenpools auf den Namen des Knotenpools, dessen Größe Sie anpassen möchten.
Klicken Sie auf der Seite Knotenpooldetails auf Bearbeiten.
Klicken Sie auf der Seite Knotenpool bearbeiten im Abschnitt Sicherheit das Kästchen GKE-Metadatenserver aktivieren an.
Klicken Sie auf Speichern.

Anwendungen für die Verwendung der Identitätsföderation von Arbeitslasten für GKE konfigurieren

Damit sich Ihre GKE-Anwendungen mithilfe von Workload Identity Federation for GKE bei Google Cloud APIs authentifizieren können, erstellen Sie IAM-Richtlinien für die jeweiligen APIs. Das Hauptkonto in diesen Richtlinien ist eine IAM-Hauptkonto-ID, die den Arbeitslasten, Namespaces oder ServiceAccounts entspricht.

Autorisierung und Hauptkonten konfigurieren

Rufen Sie Anmeldedaten für Ihren Cluster ab:
```
gcloud container clusters get-credentials CLUSTER_NAME \
    --location=LOCATION
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME: der Name Ihres Clusters, für den die Workload Identity-Föderation für GKE aktiviert ist.
- LOCATION: Der Standort Ihres Clusters.
Erstellen Sie einen Namespace, der für das Kubernetes-Dienstkonto verwendet werden soll. Sie können auch den Namespace default oder einen vorhandenen Namespace verwenden.
```
kubectl create namespace NAMESPACE
```
Erstellen Sie ein Kubernetes-ServiceAccount für die Anwendung: Sie können auch ein beliebiges Kubernetes-ServiceAccount in einem beliebigen Namespace verwenden. Wenn Sie Ihrer Arbeitslast kein ServiceAccount zuweisen, weist Kubernetes das ServiceAccount default im Namespace zu.
```
kubectl create serviceaccount KSA_NAME \
    --namespace NAMESPACE
```
Ersetzen Sie Folgendes:
- KSA_NAME ist der Name des neuen Kubernetes-ServiceAccount.
- NAMESPACE: Den Name des Kubernetes-Namespace für das ServiceAccount.
Erstellen Sie eine IAM-Zulassungsrichtlinie, die auf das Kubernetes-ServiceAccount verweist. Es empfiehlt sich, bestimmten Google Cloud-Ressourcen Berechtigungen zu gewähren, auf die Ihre Anwendung zugreifen muss. Sie benötigen entsprechende IAM-Berechtigungen, um Zulassungsrichtlinien in Ihrem Projekt zu erstellen.

Mit dem folgenden Befehl wird beispielsweise dem von Ihnen erstellten ServiceAccount die Rolle Kubernetes Engine-Clusterbetrachter (roles/container.clusterViewer) zugewiesen:
```
gcloud projects add-iam-policy-binding projects/PROJECT_ID \
    --role=roles/container.clusterViewer \
    --member=principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/NAMESPACE/sa/KSA_NAME \
    --condition=None
```
Ersetzen Sie Folgendes:
- PROJECT_ID ist Ihre Google Cloud-Projekt-ID.
- PROJECT_NUMBER: Ihre numerische Google Cloud-Projektnummer.
Sie können jeder Google Cloud-Ressource Rollen zuweisen, die IAM-Zulassungsrichtlinien unterstützt. Die Syntax der Hauptkonto-ID hängt von der Kubernetes-Ressource ab. Eine Liste der unterstützten Kennzeichnungen finden Sie unter Hauptkonto-IDs für Workload Identity-Föderation für GKE.

Identitätsföderation von Arbeitslasten für die GKE-Einrichtung prüfen

In diesem Abschnitt erstellen Sie einen Cloud Storage-Bucket und gewähren dem Kubernetes-ServiceAccount, das Sie im vorherigen Abschnitt erstellt haben, Lesezugriff auf den Bucket. Anschließend stellen Sie eine Arbeitslast bereit und testen, ob der Container Cluster im Projekt auflisten kann.

Erstellen Sie einen leeren Cloud Storage-Bucket:
```
gcloud storage buckets create gs://BUCKET
```
Ersetzen Sie dabei BUCKET durch einen Namen für den neuen Bucket.
Weisen Sie dem erstellten ServiceAccount die Rolle Storage-Objekt-Betrachter (roles/storage.objectViewer) zu:
```
gcloud storage buckets add-iam-policy-binding gs://BUCKET \
    --role=roles/storage.objectViewer \
    --member=principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/NAMESPACE/sa/KSA_NAME \
    --condition=None
```
Ersetzen Sie Folgendes:
- PROJECT_ID ist Ihre Google Cloud-Projekt-ID.
- PROJECT_NUMBER: Ihre numerische Google Cloud-Projektnummer.
- NAMESPACE: der Kubernetes-Namespace, der das ServiceAccount enthält.
- KSA_NAME: der Name des ServiceAccount.

Speichern Sie das folgende Manifest als test-app.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: test-pod
  namespace: NAMESPACE
spec:
  serviceAccountName: KSA_NAME
  containers:
  - name: test-pod
    image: google/cloud-sdk:slim
    command: ["sleep","infinity"]
    resources:
      requests:
        cpu: 500m
        memory: 512Mi
        ephemeral-storage: 10Mi

Fügen Sie nur in Standardclustern dem Feld template.spec Folgendes hinzu, um die Pods in Knotenpools zu platzieren, die Workload Identity-Föderation für GKE verwenden.

Überspringen Sie diesen Schritt in Autopilot-Clustern, die diesen nodeSelector ablehnen, da jeder Knoten Workload Identity-Föderation für GKE verwendet.
```
spec:
  nodeSelector:
    iam.gke.io/gke-metadata-server-enabled: "true"
```
Wenden Sie die Konfiguration auf Ihren Cluster an:
```
kubectl apply -f test-app.yaml
```
Warten Sie, bis der Pod bereit ist. Führen Sie folgenden Befehl aus, um den Status des Pods zu überprüfen:
```
kubectl get pods --namespace=NAMESPACE
```
Wenn der Pod bereit ist, sieht die Ausgabe in etwa so aus:
```
NAME       READY   STATUS    RESTARTS   AGE
test-pod   1/1     Running   0          5m27s
```

Öffnen Sie eine Shell-Sitzung im Pod:

kubectl exec -it pods/test-pod --namespace=NAMESPACE -- /bin/bash

Rufen Sie eine Liste der Objekte im Bucket ab:

curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    "https://storage.googleapis.com/storage/v1/b/BUCKET/o"

Die Ausgabe sieht so aus:

{
  "kind": "storage#objects"
}

Diese Ausgabe zeigt, dass Ihr Pod auf Objekte im Bucket zugreifen kann.

Alternative: Kubernetes-ServiceAccounts mit IAM verknüpfen

Wir empfehlen, IAM-Hauptkonto-IDs zu verwenden, um Workload Identity-Föderation für GKE zu konfigurieren. Diese föderierte Identität hat jedoch bestimmte Einschränkungen für jede unterstützte Google Cloud API. Eine Liste der Einschränkungen finden Sie unter Unterstützte Produkte und Einschränkungen.

Wenn diese Einschränkungen für Sie gelten, führen Sie die folgenden Schritte aus, um den Zugriff auf diese APIs über Ihre GKE-Arbeitslasten zu konfigurieren:

Erstellen Sie einen Kubernetes-Namespace:
```
kubectl create namespace NAMESPACE
```

Erstellen Sie ein Kubernetes-ServiceAccount:

kubectl create serviceaccount KSA_NAME \
    --namespace=NAMESPACE

IAM-Dienstkonto erstellen. Sie können auch ein beliebiges IAM-Dienstkonto in einem Projekt in Ihrer Organisation verwenden.
```
gcloud iam service-accounts create IAM_SA_NAME \
    --project=IAM_SA_PROJECT_ID
```
Ersetzen Sie Folgendes:
- IAM_SA_NAME: Ein Name für das neue IAM-Dienstkonto.
- IAM_SA_PROJECT_ID: die Projekt-ID für Ihr IAM-Dienstkonto.
Informationen zur Autorisierung von IAM-Dienstkonten für den Zugriff auf Google Cloud APIs finden Sie unter Details zu Dienstkonten.
Gewähren Sie Ihrem IAM-Dienstkonto die Rollen, die es für bestimmte Google Cloud APIs benötigt:
```
gcloud projects add-iam-policy-binding IAM_SA_PROJECT_ID \
    --member "serviceAccount:IAM_SA_NAME@IAM_SA_PROJECT_ID.iam.gserviceaccount.com" \
    --role "ROLE_NAME"
```
Ersetzen Sie ROLE_NAME durch den Namen der Rolle, z. B. roles/spanner.viewer.

Erstellen Sie eine IAM-Zulassungsrichtlinie, die dem Kubernetes-ServiceAccount Zugriff gewährt, um die Identität des IAM-Dienstkontos zu übernehmen:

gcloud iam service-accounts add-iam-policy-binding IAM_SA_NAME@IAM_SA_PROJECT_ID.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[NAMESPACE/KSA_NAME]"

Annotieren Sie das Kubernetes-ServiceAccount, damit GKE die Verknüpfung zwischen den Dienstkonten sieht:
```
kubectl annotate serviceaccount KSA_NAME \
    --namespace NAMESPACE \
    iam.gke.io/gcp-service-account=IAM_SA_NAME@IAM_SA_PROJECT_ID.iam.gserviceaccount.com
```
Hinweis: Wenn Sie diese Methode verwenden, sind sowohl die IAM-Zulassungsrichtlinie als auch die Annotation erforderlich.

Identitätsföderation von Arbeitslasten für GKE aus Ihrem Code verwenden

Die Authentifizierung bei Google Cloud-Diensten über Ihren Code erfolgt genauso wie bei der Authentifizierung mit dem Compute Engine-Metadatenserver. Wenn Sie Workload Identity-Föderation für GKE verwenden, werden Ihre Anfragen an den Instanzmetadatenserver zum GKE-Metadatenserver geleitet. Vorhandener Code, der über den Metadatenserver der Instanz authentifiziert wird (z. B. Code, der die Google Cloud-Clientbibliotheken verwendet), sollte ohne Änderungen funktionieren.

Kontingente aus einem anderen Projekt mit Identitätsföderation von Arbeitslasten für GKE verwenden

Auf Clustern, auf denen GKE Version 1.24 oder höher läuft, können Sie Ihr Kubernetes-Dienstkonto optional so konfigurieren, dass bei Aufrufen der Methoden GenerateAccessToken und GenerateIdToken in der IAM Service Account Credentials API Kontingente aus einem anderen Google Cloud-Projekt verwendet werden. So können Sie vermeiden, das gesamte Kontingent in Ihrem Hauptprojekt zu verbrauchen, und stattdessen Kontingente aus anderen Projekten für diese Dienste in Ihrem Cluster verwenden.

So konfigurieren Sie ein Kontingentprojekt mit Workload Identity-Föderation für GKE:

Erteilen Sie dem Kubernetes-Dienstkonto die Berechtigung serviceusage.services.use für das Kontingentprojekt.

gcloud projects add-iam-policy-binding QUOTA_PROJECT_ID \
    --role=roles/serviceusage.serviceUsageConsumer \
    --member='principalSet://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/serviceaccount/NAMESPACE/KSA_NAME' \

Ersetzen Sie QUOTA_PROJECT_ID durch die Projekt-ID des Kontingentprojekts.

Annotieren Sie das Kubernetes-Dienstkonto mit dem Kontingentprojekt:

kubectl annotate serviceaccount KSA_NAME \
    --namespace NAMESPACE \
    iam.gke.io/credential-quota-project=QUOTA_PROJECT_ID

Prüfen Sie so, ob die Konfiguration ordnungsgemäß funktioniert:

Erstellen Sie einen Pod und starten Sie eine Shell-Sitzung. Weitere Informationen zum Abrufen einer Shell zu einem laufenden Container finden Sie in der Kubernetes-Dokumentation.

Stellen Sie eine Anfrage an den Metadatenserver:

curl -H "Metadata-Flavor: Google" http://169.254.169.254/computeMetadata/v1/instance/service-accounts/default/token

Rufen Sie in der Google Cloud Console die Seite IAM Service Accounts Credentials API für Ihr Kontingentprojekt auf:

Zu „APIs“
Prüfen Sie auf Traffic-Änderungen.

Bereinigen

Wenn Sie die Verwendung von Workload Identity-Föderation für GKE beenden möchten, widerrufen Sie den Zugriff auf das IAM-Dienstkonto und deaktivieren Sie Workload Identity-Föderation für GKE im Cluster.

Zugriff widerrufen

Wenn Sie den Zugriff auf das Hauptkonto widerrufen möchten, entfernen Sie die IAM-Zulassungsrichtlinie, die Sie im Abschnitt Anwendungen für die Verwendung von Workload Identity-Föderation für GKE konfigurieren erstellt haben.

Führen Sie beispielsweise den folgenden Befehl aus, um den Zugriff auf ein Artifact Registry-Repository zu widerrufen:

gcloud artifacts repositories remove-iam-policy-binding REPOSITORY_NAME \
    --location=REPOSITORY_LOCATION \
    --member='principalSet://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/serviceaccount/NAMESPACE/KSA_NAME' \
    --role='roles/artifactregistry.reader' \
    --all

Identitätsföderation von Arbeitslasten für GKE deaktivieren

Sie können Workload Identity-Föderation für GKE nur auf Standardclustern deaktivieren.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Deaktivieren Sie Workload Identity-Föderation für GKE in jedem Knotenpool:
```
gcloud container node-pools update NODEPOOL_NAME \
    --cluster=CLUSTER_NAME \
    --workload-metadata=GCE_METADATA
```
Wiederholen Sie diesen Befehl für jeden Knotenpool im Cluster.

Deaktivieren Sie Workload Identity-Föderation für GKE im Cluster:

gcloud container clusters update CLUSTER_NAME \
    --disable-workload-identity

Console

Rufen Sie in der Google Cloud Console die Seite Google Kubernetes Engine auf:

Zur Seite „Google Kubernetes Engine“
Klicken Sie in der Clusterliste auf den Namen des Clusters, den Sie ändern möchten.
Klicken Sie auf den Tab Knoten.
So deaktivieren Sie Workload Identity-Föderation für GKE für jeden Knotenpool im Abschnitt Knotenpools für jeden Knotenpool:
1. Klicken Sie auf den Namen des Knotenpools, den Sie ändern möchten.
2. Klicken Sie auf der Seite Knotenpooldetails auf Bearbeiten.
3. Entfernen Sie auf der Seite Knotenpool bearbeiten im Abschnitt Sicherheit das Häkchen aus dem Kästchen GKE-Metadatenserver aktivieren.
4. Klicken Sie auf Speichern.
So deaktivieren Sie Workload Identity-Föderation für GKE für den Cluster:
1. Klicken Sie auf den Tab Details.
2. Klicken Sie im Abschnitt Sicherheit neben Workload Identity auf Bearbeiten.
3. Entfernen Sie im Dialogfeld Workload Identity bearbeiten das Häkchen aus dem Kästchen Workload Identity aktivieren.
4. Klicken Sie auf Änderungen speichern.

Identitätsföderation von Arbeitslasten für GKE in Ihrer Organisation deaktivieren

Im Hinblick auf die Sicherheit kann GKE mithilfe von Workload Identity-Föderation für GKE Identitäten von Kubernetes-Dienstkonten durchsetzen, die authentifiziert und für Google Cloud-Ressourcen autorisiert werden können. Wenn Sie ein Administrator sind, der Maßnahmen ergriffen hat, um Arbeitslasten von Google Cloud-Ressourcen zu isolieren, z. B. indem Sie die Erstellung von Dienstkonten deaktiviert oder die Erstellung von Dienstkontoschlüsseln deaktiviert haben, möchten Sie möglicherweise auch Workload Identity für Ihre Organisation deaktivieren.

Hier finden Sie eine Anleitung zum Deaktivieren von Workload Identity-Föderation für GKE für Ihre Organisation.

Fehlerbehebung

Informationen zur Fehlerbehebung finden Sie unter Fehlerbehebung bei Workload Identity-Föderation für GKE.

Nächste Schritte

Workload Identity-Föderation für GKE
Übersicht zur GKE-Sicherheit lesen
Mehr über den Schutz von Clustermetadaten erfahren
IAM-Dienstkonten