Einige oder alle Informationen auf dieser Seite gelten möglicherweise nicht für Cloud de Confiance von S3NS. Weitere Informationen finden Sie unter Unterschiede zu Google Cloud.

Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

etcd- und Bootlaufwerke der Steuerungsebene verschlüsseln

Autopilot Standard

In diesem Dokument wird beschrieben, wie Sie Daten verschlüsseln, die in Ihrer GKE-Steuerungsebene (Google Kubernetes Engine) gespeichert sind, indem Sie Schlüssel verwenden, die Sie in Cloud Key Management Service (Cloud KMS) verwalten. Sie sollten bereits mit Konzepten wie etcd, der GKE-Clusterarchitektur und Cloud KMS vertraut sein.

Auf dieser Seite wird ein Teil einer Reihe optionaler Steuerungsebenenfunktionen in GKE beschrieben, mit denen Sie Aufgaben wie das Überprüfen des Sicherheitsstatus der Steuerungsebene oder das Konfigurieren der Verschlüsselung und der Anmeldedatensignierung in der Steuerungsebene mit von Ihnen verwalteten Schlüsseln ausführen können. Weitere Informationen finden Sie unter GKE Control Plane Authority.

Standardmäßig werden in Cloud de Confiance verschiedene Sicherheitsmaßnahmen auf die verwaltete Steuerungsebene angewendet. Auf dieser Seite werden optionale Funktionen beschrieben, mit denen Sie mehr Einblick in die GKE-Steuerungsebene erhalten oder mehr Kontrolle darüber haben.

Bootlaufwerk und etcd-Verschlüsselung der Steuerungsebene

Standardmäßig verschlüsselt GKE das Bootlaufwerk eines Steuerungsebenenknotens, das Laufwerk, auf dem Daten in etcd gespeichert werden, und die Cloud de Confiance by S3NS interne Betriebssicherung von etcd mit Verschlüsselungsschlüsseln, die Cloud de Confiance verwaltet. Weitere Informationen zu dieser Standardverschlüsselung finden Sie unter Verschlüsselung ruhender Daten. Sie können diese Ressourcen optional mit Ihren eigenen Verschlüsselungsschlüsseln verschlüsseln, die Sie mit Cloud KMS verwalten. Weitere Informationen finden Sie unter Bootlaufwerk der Steuerungsebene und etcd-Verschlüsselung.

Sie erstellen Schlüssel in Cloud KMS, die von GKE zum Verschlüsseln Ihrer Steuerungsebenenressourcen verwendet werden. Beachten Sie beim Erstellen dieser Ressourcen Folgendes:

Sie können einen Schlüsselbund für alle Schlüssel in einem Cluster verwenden, unabhängig vom Zweck der einzelnen Schlüssel. Wenn Sie bereits einen Schlüsselbund haben, den Sie für einen anderen Zweck verwendet haben, z. B. zum Einrichten eigener Zertifizierungsstellen, können Sie diesen Schlüsselbund für diese Anleitung verwenden.
Sie sollten die Schlüssel am selben Cloud de Confiance Standort wie Ihren Cluster erstellen, um die Latenz zu optimieren.
In den meisten Anwendungsfällen können Sie die Cloud KMS-Schlüssel-Schutzstufe Software verwenden. Sie können auch Hardwareschlüssel mit Cloud HSM verwenden.
Sie müssen das Flag --purpose mit dem Wert encryption angeben, da diese Schlüssel für die symmetrische Verschlüsselung verwendet werden.
Sie sollten die Standarddauer für die Schlüssellöschung nicht ändern.

Verwendung mit anderen GKE Control Plane Authority-Funktionen

Die GKE Control Plane Authority bietet die folgenden Funktionen im Zusammenhang mit selbstverwalteten Schlüsseln, die Sie gleichzeitig beim Erstellen eines Clusters aktivieren müssen:

Komponenten der Steuerungsebene verschlüsseln (dieses Dokument)
Eigene Zertifizierungsstellen und Schlüssel verwalten

Sie können diese Funktionen nur aktivieren, wenn Sie einen neuen GKE-Cluster erstellen. Sie können vorhandene Cluster nicht aktualisieren, um diese Funktionen zu verwenden. Wenn Sie beide Funktionen im selben Cluster verwenden möchten, führen Sie alle Schlüssel- und CA-Konfigurationsverfahren in beiden Anleitungen aus und führen Sie dann den Befehl zum Erstellen des Clusters aus, mit dem beide Funktionsgruppen aktiviert werden, wie im Abschnitt Cluster erstellen beschrieben.

Hinweis

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 dem Befehl gcloud components update ab. In früheren gcloud CLI-Versionen werden die Befehle in diesem Dokument möglicherweise nicht unterstützt.
Hinweis: Legen Sie für vorhandene Installationen der gcloud CLI das compute/region-Attribut fest. Wenn Sie hauptsächlich zonale Cluster verwenden, legen Sie stattdessen compute/zone fest. Wenn Sie einen standardmäßigen Speicherort festlegen, können Sie in der gcloud CLI Fehler wie diesen vermeiden: One of [--zone, --region] must be supplied: Please specify location. Bei bestimmten Befehlen müssen Sie möglicherweise den Speicherort angeben, wenn er sich von dem von Ihnen festgelegten Standard unterscheidet.

Achten Sie darauf, dass Ihr Schlüsselprojekt einen Cloud KMS-Schlüsselbund für Ihren Cluster enthält. Sie können einen beliebigen vorhandenen Schlüsselbund am Standort Ihres Clusters verwenden. Informationen zum Erstellen eines neuen Schlüsselbunds finden Sie unter Schlüsselbund erstellen.
Aktivieren Sie die Cloud Key Management Service API, falls sie noch nicht aktiviert ist.
Rollen, die zum Aktivieren von APIs erforderlich sind
Zum Aktivieren von APIs benötigen Sie die Berechtigung serviceusage.services.enable. Wenn Sie das Projekt erstellt haben, haben Sie diese Berechtigung wahrscheinlich bereits über die Rolle „Inhaber“ (roles/owner). Andernfalls können Sie diese Berechtigung über die Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin) erhalten. Informationen zum Zuweisen von Rollen
API aktivieren

Projekte identifizieren

Wir empfehlen, separate Cloud de Confiance Projekte wie folgt zu verwenden:

Schlüsselprojekt: enthält alle Schlüssel.
Clusterprojekt: enthält Ihre GKE-Cluster.

Sie können optional dasselbe Projekt für Ihre Schlüssel und GKE-Cluster verwenden. Wir empfehlen jedoch, separate Projekte zu verwenden, damit die Teams, die Ihre Schlüssel und kryptografischen Vorgänge verwalten, von den Teams getrennt sind, die Ihre Cluster verwalten.

Erforderliche Rollen und Berechtigungen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Ausführen eigener Verschlüsselungsschlüssel benötigen:

Cloud KMS-Schlüssel erstellen: Cloud KMS-Administrator (roles/cloudkms.admin) in Ihrem Schlüsselprojekt
GKE-Cluster erstellen: Kubernetes Engine-Clusteradministrator (roles/container.clusterAdmin) für Ihr Clusterprojekt

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Voraussetzungen

Für die Verschlüsselung von Steuerungsebenenlaufwerken mit eigenen Schlüsseln gelten die folgenden Anforderungen:

Ihr Cluster muss die GKE-Version 1.31.1-gke.1846000 oder höher ausführen.
Sie müssen Ihren Cluster in einer der folgenden Regionen erstellen:
- asia-east1
- asia-northeast1
- asia-southeast1
- europe-west1
- europe-west4
- us-central1
- us-central2
- us-east1
- us-east4
- us-east5
- us-south1
- us-west1
- us-west3
- us-west4
Hinweis: Unabhängig von der GKE-Steuerungsebene können Sie den Vertraulichen Modus für Hyperdisk Balanced für Ihre Knotenlaufwerke verwenden. Wenn Sie den vertraulichen Modus für Hyperdisk Balanced für Ihre Knoten verwenden und die Steuerungsebene-Laufwerke mit Ihren eigenen Schlüsseln verschlüsseln möchten, müssen Sie den Cluster in einer Region erstellen, die den vertraulichen Modus für Hyperdisk Balanced unterstützt. Wenn Sie den Cluster in einer anderen Region erstellen, können Sie den Modus „Vertraulich“ für Hyperdisk Balanced für Ihre Knoten nicht verwenden.

Beschränkungen

Sie können Bootlaufwerk- und etcd-Verschlüsselungsschlüssel nur während der Clustererstellung konfigurieren.
Bei regionalen Clustern im Standardmodus und bei Autopilot-Clustern muss die Region, in der Sie einen Cluster erstellen, Kapazität für den vertraulichen Modus für Hyperdisk Balanced in mindestens drei Zonen in dieser Region haben.

Für zonale Cluster im Standardmodus muss in der Clusterzone Hyperdisk Balanced-Kapazität verfügbar sein. Wenn Sie Hilfe bei der Kapazität benötigen, wenden Sie sich an Cloud Customer Care.
GKE unterstützt nur Schlüssel aus Cloud KMS. Sie können keinen anderen Kubernetes-KMS-Anbieter oder einen anderen Verschlüsselungsanbieter verwenden.
Cloud External Key Manager-Schlüssel (Cloud EKM) werden nicht unterstützt.
Sie können nicht auf die Cloud de Confiance internen Betriebs-Back-ups von etcd zugreifen oder mit ihnen interagieren. Sie sind nur für die Notfallwiederherstellung vorgesehen.
Multiregionale Keyrings werden nicht unterstützt. Sie müssen einen regionalen Schlüsselbund verwenden.

Schlüssel erstellen

In diesem Abschnitt erstellen Sie einen Verschlüsselungsschlüssel für die Boot- und etcd-Laufwerke in der Steuerungsebene und einen separaten Verschlüsselungsschlüssel für die Cloud de Confianceinterne operative Sicherung von etcd. Sie können alle diese Schlüssel und alle anderen Schlüssel für den Cluster an einem Schlüsselring befestigen.

Erstellen Sie den Verschlüsselungsschlüssel für die Bootlaufwerke und etcd-Laufwerke der Steuerungsebene:
```
gcloud kms keys create KCP_DISK_KEY_NAME \
    --keyring=KEYRING_NAME \
    --location=LOCATION \
    --purpose="encryption" \
    --protection-level=PROTECTION_LEVEL \
    --project=KEY_PROJECT_ID
```
Ersetzen Sie Folgendes:
- KCP_DISK_KEY_NAME: der Name des Verschlüsselungsschlüssels für Ihre Bootlaufwerke und etcd-Laufwerke der Steuerungsebene.
- KEYRING_NAME: der Name des Schlüsselbunds, der Ihre Verschlüsselungsschlüssel für den Cluster enthält.
- LOCATION: der Cloud de Confiance Speicherort für den Schlüsselbund. Dieser muss mit dem Standort Ihres Clusters übereinstimmen. Eine Liste der Regionen finden Sie in der Tabelle mit Cloud KMS-Standorten, indem Sie nach „Region“ filtern.
- PROTECTION_LEVEL: Das Schutzniveau für den Schlüssel, z. B. software oder hsm.
- KEY_PROJECT_ID: Die Projekt-ID Ihres Schlüsselprojekts.

Erstellen Sie den internen etcd-Sicherungsschlüssel:

gcloud kms keys create ETCD_BACKUP_KEY_NAME \
    --keyring=KEYRING_NAME \
    --location=LOCATION \
    --purpose="encryption" \
    --protection-level=PROTECTION_LEVEL \
    --project=KEY_PROJECT_ID

Ersetzen Sie ETCD_BACKUP_KEY_NAME durch einen Namen für den internen etcd-Verschlüsselungsschlüssel für Sicherungen.

GKE-Dienst-Agent IAM-Rollen zuweisen

In diesem Abschnitt weisen Sie dem GKE-Dienst-Agent im Clusterprojekt IAM-Rollen für die von Ihnen erstellten Schlüssel zu. Der GKE-Dienst-Agent benötigt diese Rollen, um die entsprechenden Steuerungsebenenressourcen mit diesen Schlüsseln zu verschlüsseln.

So finden Sie die Projektnummer Ihres Clusters:
```
gcloud projects describe CLUSTER_PROJECT_ID \
    --format='value(projectNumber)'
```
Ersetzen Sie CLUSTER_PROJECT_ID durch die Projekt-ID Ihres GKE-Clusterprojekts.

Die Ausgabe sieht etwa so aus:
```
1234567890
```
Weisen Sie dem GKE-Dienst-Agenten im Clusterprojekt die Rolle Cloud KMS CryptoKey-Verschlüsseler/Entschlüsseler (roles/cloudkms.cryptoKeyEncrypterDecrypter) für den Verschlüsselungsschlüssel für Bootlaufwerke und etcd-Laufwerke zu:
```
gcloud kms keys add-iam-policy-binding KCP_DISK_KEY_NAME \
    --location=LOCATION \
    --keyring=KEYRING_NAME \
    --member="serviceAccount:service-CLUSTER_PROJECT_NUMBER@container-engine-robot.s3ns-system.iam.gserviceaccount.com" \
    --role=roles/cloudkms.cryptoKeyEncrypterDecrypter \
    --project=KEY_PROJECT_ID
```
Ersetzen Sie Folgendes:
- KCP_DISK_KEY_NAME: der Name des Laufwerkverschlüsselungsschlüssels.
- LOCATION: Der Cloud de Confiance Speicherort für den Schlüssel.
- KEYRING_NAME: der Name des Schlüsselbunds, der den Verschlüsselungsschlüssel enthält
- CLUSTER_PROJECT_NUMBER: Die numerische Projektnummer des Clusterprojekts, die Sie im vorherigen Schritt ermittelt haben.
- KEY_PROJECT_ID: Die Projekt-ID Ihres Schlüsselprojekts.

Weisen Sie dem GKE-Dienst-Agenten im Clusterprojekt die Rolle Cloud KMS CryptoKey Encrypter/Decrypter Via Delegation (roles/cloudkms.cryptoKeyEncrypterDecrypterViaDelegation) für den Verschlüsselungsschlüssel für Bootlaufwerke und etcd-Laufwerke zu:

gcloud kms keys add-iam-policy-binding KCP_DISK_KEY_NAME \
    --location=LOCATION \
    --keyring=KEYRING_NAME \
    --member="serviceAccount:service-CLUSTER_PROJECT_NUMBER@container-engine-robot.s3ns-system.iam.gserviceaccount.com" \
    --role=roles/cloudkms.cryptoKeyEncrypterDecrypterViaDelegation \
    --project=KEY_PROJECT_ID

Weisen Sie dem GKE-Dienst-Agent im Clusterprojekt für die Schlüsselrotation die Rolle Cloud KMS-Schlüsselnutzer für die Verschlüsselungsschlüssel für Bootlaufwerke und etcd-Laufwerke zu:

gcloud kms keys add-iam-policy-binding KCP_DISK_KEY_NAME \
    --location=LOCATION \
    --keyring=KEYRING_NAME \
    --member="serviceAccount:service-CLUSTER_PROJECT_NUMBER@container-engine-robot.s3ns-system.iam.gserviceaccount.com" \
    --role=roles/container.cloudKmsKeyUser \
    --project=KEY_PROJECT_ID

Weisen Sie dem GKE-Dienst-Agenten im Clusterprojekt die Rolle Cloud KMS CryptoKey Encrypter (roles/cloudkms.cryptoKeyEncrypter) für den internen etcd-Verschlüsselungsschlüssel für Back-ups zu:
```
gcloud kms keys add-iam-policy-binding ETCD_BACKUP_KEY_NAME \
    --location=LOCATION \
    --keyring=KEYRING_NAME \
    --member="serviceAccount:service-CLUSTER_PROJECT_NUMBER@container-engine-robot.s3ns-system.iam.gserviceaccount.com" \
    --role=roles/cloudkms.cryptoKeyEncrypter \
    --project=KEY_PROJECT_ID
```
Ersetzen Sie ETCD_BACKUP_KEY_NAME durch den Namen des etcd-Verschlüsselungsschlüssels für operative Back-ups.

Wenn Sie die Rolle roles/cloudkms.cryptoKeyEncrypter zuweisen, kann GKE keine Datenbankwiederherstellungen in Ihrem Namen durchführen. Außerdem dauert es dann deutlich länger, bis die Funktionen wiederhergestellt sind, wenn ein Datenbankproblem auftritt. Wenn GKE Wiederherstellungen für Sie ausführen soll, weisen Sie stattdessen die Rolle roles/cloudkms.cryptoKeyEncrypterDecrypter zu.

Verschlüsselungsschlüssel in einem Cluster verwenden

In diesem Abschnitt erfahren Sie, wie Sie die Pfade zu Ihren Verschlüsselungsschlüsseln ermitteln.

Ermitteln Sie den Pfad zu Ihrem Laufwerksverschlüsselungsschlüssel:
```
gcloud kms keys describe KCP_DISK_KEY_NAME \
    --keyring=KEYRING_NAME \
    --location=LOCATION \
    --project=KEY_PROJECT_ID \
    --format="value(name)"
```
Ersetzen Sie Folgendes:
- KCP_DISK_KEY_NAME: der Name des Verschlüsselungsschlüssels für Bootlaufwerke der Steuerungsebene und etcd-Laufwerke.
- KEYRING_NAME: der Name des Schlüsselbunds, der den Schlüssel enthält
- LOCATION: Der Cloud de Confiance Speicherort des Schlüssels.
- KEY_PROJECT_ID: Die Projekt-ID Ihres Schlüsselprojekts.
Die Ausgabe sieht etwa so aus:
```
projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEYRING_NAME/cryptoKeys/disk-encryption-key
```

Ermitteln Sie den Pfad zu Ihrem internen etcd-Verschlüsselungsschlüssel für Sicherungen:

gcloud kms keys describe ETCD_BACKUP_KEY_NAME \
    --keyring=KEYRING_NAME \
    --location=LOCATION \
    --project=KEY_PROJECT_ID \
    --format="value(name)"

Ersetzen Sie ETCD_BACKUP_KEY_NAME durch den Namen des etcd-Verschlüsselungsschlüssels für operative Back-ups.

Die Ausgabe sieht etwa so aus:

projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEYRING_NAME/cryptoKeys/etcd-backup-encryption-key

Cluster erstellen

In diesem Abschnitt erstellen Sie einen Cluster mit verschiedenen Optionen, je nachdem, welche GKE-Steuerungsebenenautorisierungsfunktionen Sie konfigurieren möchten. Sie können diese Funktionen nur bei der Clustererstellung für einen Cluster konfigurieren. Mit den folgenden Befehlen werden Cluster im Standardmodus erstellt. Wenn Sie stattdessen Autopilot-Cluster erstellen möchten, verwenden Sie dieselben Flags mit dem Befehl gcloud container clusters create-auto.

So erstellen Sie einen Cluster, in dem die Festplattenverschlüsselung konfiguriert wird und Ihre eigenen CAs und Dienstkonto-Signaturschlüssel ausgeführt werden:
1. Führen Sie alle Konfigurationsschritte für Schlüssel und Zertifizierungsstellen unter Eigene Zertifizierungsstellen und Schlüssel verwenden aus.
2. Suchen Sie die Pfade zu den einzelnen Dienstkontoschlüsseln und Zertifizierungsstellen anhand der Anleitung unter Zertifizierungsstellen und Schlüssel in einem neuen Cluster einrichten.
3. Erstellen Sie einen Cluster.
```
gcloud container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --project=CLUSTER_PROJECT_ID \
    --control-plane-disk-encryption-key=PATH_TO_DISK_KEY \
    --gkeops-etcd-backup-encryption-key=PATH_TO_ETCD_BACKUP_KEY \
    --service-account-signing-keys=PATH_TO_SIGNING_KEY_VERSION \
    --service-account-verification-keys=PATH_TO_VERIFICATION_KEY_VERSION \
    --cluster-ca=PATH_TO_CLUSTER_CA \
    --etcd-peer-ca=PATH_TO_ETCD_PEER_CA \
    --etcd-api-ca=PATH_TO_ETCD_API_CA \
    --aggregation-ca=PATH_TO_AGGREGATION_CA
```
  Ersetzen Sie Folgendes:
  - CLUSTER_NAME: Der Name des neuen Clusters.
  - LOCATION: Der Standort Ihres neuen Clusters.
  - CLUSTER_PROJECT_ID: die Projekt-ID Ihres Clusterprojekts.
  - PATH_TO_DISK_KEY: der Pfad zu Ihrem Laufwerkverschlüsselungsschlüssel aus den vorherigen Schritten in diesem Dokument.
  - PATH_TO_ETCD_BACKUP_KEY: der Pfad zu Ihrem internen etcd-Sicherungsschlüssel aus den vorherigen Schritten in diesem Dokument.
  - PATH_TO_SIGNING_KEY_VERSION: der Pfad zur Signaturschlüsselversion des Kubernetes-Dienstkontos in Cloud KMS.
  - PATH_TO_VERIFICATION_KEY_VERSION: Der Pfad zur Version des Kubernetes-Dienstkontoverifizierungsschlüssels in Cloud KMS.
  - PATH_TO_CLUSTER_CA: der Pfad zum Cluster-CA-Pool.
  - PATH_TO_ETCD_PEER_CA: der Pfad zum etcd-Peer-CA-Pool.
  - PATH_TO_ETCD_API_CA: der Pfad zum etcd-API-CA-Pool.
  - PATH_TO_AGGREGATION_CA: der Pfad zum Aggregations-CA-Pool.
Führen Sie den folgenden Befehl aus, um einen Cluster zu erstellen, in dem die Laufwerkverschlüsselung nur mit den Schlüsseln konfiguriert wird, die Sie in dieser Anleitung erstellt haben:
```
gcloud container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --project=CLUSTER_PROJECT_ID \
    --control-plane-disk-encryption-key=PATH_TO_DISK_KEY \
    --gkeops-etcd-backup-encryption-key=PATH_TO_ETCD_BACKUP_KEY
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME: Der Name des neuen Clusters.
- LOCATION: Der Standort Ihres neuen Clusters.
- CLUSTER_PROJECT_ID: die Projekt-ID Ihres Clusterprojekts.
- PATH_TO_DISK_KEY: der Pfad zu Ihrem Laufwerkverschlüsselungsschlüssel aus den vorherigen Schritten.
- PATH_TO_ETCD_BACKUP_KEY: der Pfad zu Ihrem internen etcd-Sicherungsverschlüsselungsschlüssel aus den vorherigen Schritten.

Sie können alle diese Flags auch angeben, wenn Sie einen neuen Cluster im Standardmodus erstellen.

Status des Verschlüsselungsschlüssels prüfen

In diesem Abschnitt wird beschrieben, wie Sie den Verschlüsselungsschlüssel überprüfen, der beim Erstellen des Clusters verwendet wurde. Sie können diese Überprüfung mit Cloud Logging oder der Google Cloud CLI durchführen.

Logging zum Überprüfen von Schlüsseln verwenden

So prüfen Sie die Schlüssel mit Logging:

Rufen Sie in der Cloud de Confiance Console die Seite Log-Explorer auf:

Zum Log-Explorer

Rufen Sie das Log zur Clustererstellung mit der folgenden Abfrage ab:

resource.type="gke_cluster"
resource.labels.cluster_name="CLUSTER_NAME"
resource.labels.location="CLUSTER_LOCATION"
protoPayload.serviceName="container.googleapis.com"
protoPayload.methodName=~"google.container.v(1|1alpha1|1beta1).ClusterManager.CreateCluster"
protoPayload.request.cluster.userManagedKeysConfig:*

Klicken Sie auf Abfrage ausführen.

Prüfen Sie in der Ausgabe, ob die Parameter für die Clustererstellung einen Schlüsselpfad enthalten, der dem Schlüssel entspricht, den Sie in Cloud KMS eingerichtet haben, wie im folgenden Beispiel:

# lines omitted for clarity
userManagedKeysConfig: {
  controlPlaneDiskEncryptionKey: "projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING_NAME/cryptoKeys/KCP_DISK_KEY_NAME"
  gkeopsEtcdBackupEncryptionKey: "projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING_NAME/cryptoKeys/ETCD_BACKUP_KEY_NAME"
}

Schlüssel mit der gcloud CLI prüfen

So prüfen Sie den Verschlüsselungsschlüssel mit der gcloud CLI:

Führen Sie für den Festplattenverschlüsselungsschlüssel den folgenden Befehl aus:

gcloud container clusters describe CLUSTER_NAME \
    --location=LOCATION \
    --format="value(userManagedKeysConfig.controlPlaneDiskEncryptionKey)"

Führen Sie für den internen etcd-Sicherungsschlüssel den folgenden Befehl aus:

gcloud container clusters describe CLUSTER_NAME \
    --location=LOCATION \
    --format="value(userManagedKeysConfig.gkeopsEtcdBackupEncryptionKey)"

Verschlüsselungsschlüssel für etcd- und Steuerungsebenenlaufwerke rotieren

Die von Ihnen erstellten Verschlüsselungsschlüssel laufen nicht ab. Um Ihren Sicherheitsstatus zu verbessern, sollten Sie diese Schlüssel regelmäßig rotieren und Ihre Ressourcen mit neuen Schlüsselversionen neu verschlüsseln. Weitere Informationen finden Sie unter Verschlüsselungsschlüssel für etcd- und Bootlaufwerke der Steuerungsebene rotieren.