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

Pod-Snapshots vorbereiten

Autopilot Standard

Informationen zum Aktivieren und Konfigurieren von Google Kubernetes Engine-Pod-Snapshots (GKE) in Ihrem Cluster und zum Einrichten von Cloud Storage zum Speichern der Snapshots.

Weitere Informationen zur Funktionsweise von Pod-Snapshots finden Sie unter Pod-Snapshots.

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, installieren und dann initialisieren Sie die gcloud CLI. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit dem gcloud components update Befehl ab. Ältere gcloud CLI-Versionen unterstützen möglicherweise nicht die Ausführung der Befehle in diesem Dokument.
Hinweis: Legen Sie für vorhandene Installationen der gcloud CLI das Attribut compute/region 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.

Pod-Snapshots aktivieren

Wenn Sie Pod-Snapshots aktivieren möchten, erstellen oder aktualisieren Sie einen Cluster mit aktivierter Pod-Snapshot-Funktion. Für Standard-Cluster müssen Sie auch einen Knotenpool erstellen oder aktualisieren, der in GKE Sandbox ausgeführt wird. GKE Sandbox wird standardmäßig von Autopilot-Clustern unterstützt.

Führen Sie je nach dem gewünschten GKE-Betriebsmodus einen der folgenden Schritte aus, um Pod-Snapshots in einem Cluster zu aktivieren:

Autopilot

Führen Sie den folgenden Befehl aus, um Pod-Snapshots in einem neuen Cluster zu aktivieren:
```
  gcloud container clusters create-auto CLUSTER_NAME \
      --enable-pod-snapshots \
      --location=CONTROL_PLANE_LOCATION \
      --cluster-version=CLUSTER_VERSION
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME: Der Name Ihres Clusters.
- CONTROL_PLANE_LOCATION: der Standort der Steuerungsebene Ihres Clusters.
- CLUSTER_VERSION: Die Version Ihres neuen Clusters, die 1.35.3-gke.1234000 oder höher sein muss.
Führen Sie die folgenden Schritte aus, um Pod-Snapshots in einem vorhandenen Cluster zu aktivieren:
1. Aktualisieren Sie den Cluster auf Version 1.35.3-gke.1234000 oder höher:
```
  gcloud container clusters upgrade CLUSTER_NAME \
      --cluster-version=CLUSTER_VERSION \
      --location=CONTROL_PLANE_LOCATION
```
  Ersetzen Sie Folgendes:
  - CLUSTER_NAME: Der Name Ihres Clusters.
  - CONTROL_PLANE_LOCATION: der Standort der Steuerungsebene Ihres Clusters.
  - CLUSTER_VERSION: Die Version Ihres neuen Clusters, die 1.35.3-gke.1234000 oder höher sein muss.
2. Aktivieren Sie Pod-Snapshots in Ihrem Cluster:
```
  gcloud container clusters update CLUSTER_NAME \
      --enable-pod-snapshots \
      --location=CONTROL_PLANE_LOCATION
```
Pod-Snapshots mit dem Standardbereich whole-pod unterstützen keine E2-Maschinentypen. In Autopilot verwendet GKE möglicherweise standardmäßig Maschinentypen, die keine Pod-Snapshots unterstützen. Wenn Sie whole-pod Snapshots verwenden, sollten Sie eine benutzerdefinierte ComputeClass verwenden, um kompatible Maschinenfamilien zu priorisieren, damit Ihre Arbeitslasten auf kompatibler Hardware ausgeführt werden. Dateisystem-Snapshots (rootfs-only) unterstützen E2-Maschinentypen.

So erstellen und verwenden Sie eine benutzerdefinierte ComputeClass:

Speichern Sie das folgende Manifest als non-e2-class.yaml:

  apiVersion: cloud.google.com/v1
  kind: ComputeClass
  metadata:
    name: non-e2-class
  spec:
    priorities:
    - machineFamily: n2
    - machineFamily: c3
    activeMigration:
      optimizeRulePriority: false
    whenUnsatisfiable: DoNotScaleUp

Wenden Sie das Manifest an:
```
  kubectl apply -f non-e2-class.yaml
```
Verweisen Sie in der Pod-Spezifikation mit der cloud.google.com/compute-class Knotenauswahl auf die ComputeClass:
```
  spec:
    nodeSelector:
      cloud.google.com/compute-class: non-e2-class
    ...
```

Standard

Führen Sie den folgenden Befehl aus, um Pod-Snapshots in einem neuen Cluster zu aktivieren:
```
  gcloud container clusters create CLUSTER_NAME \
      --enable-pod-snapshots \
      --cluster-version=CLUSTER_VERSION \
      --workload-pool=PROJECT_ID.svc.id.goog \
      --workload-metadata=GKE_METADATA \
      --location=CONTROL_PLANE_LOCATION
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME: Der Name Ihres Clusters.
- CLUSTER_VERSION: Die Version Ihres neuen Clusters, die 1.35.3-gke.1234000 oder höher sein muss.
- PROJECT_ID: Ihre Projekt-ID.
- CONTROL_PLANE_LOCATION: der Standort der Steuerungsebene Ihres Clusters.
Führen Sie die folgenden Schritte aus, um Pod-Snapshots in einem vorhandenen Cluster zu aktivieren:
1. Aktualisieren Sie den Cluster auf Version 1.35.3-gke.1234000 oder höher:
```
  gcloud container clusters upgrade CLUSTER_NAME \
      --node-pool=NODEPOOL_NAME \
      --cluster-version=CLUSTER_VERSION \
      --location=CONTROL_PLANE_LOCATION
```
  Ersetzen Sie Folgendes:
  - CLUSTER_NAME: Der Name Ihres Clusters.
  - NODEPOOL_NAME: Der Name des Knotenpools.
  - CLUSTER_VERSION: Die Version, auf die Sie Ihren neuen Cluster aktualisieren möchten, sie muss 1.35.3-gke.1234000 oder höher sein.
  - CONTROL_PLANE_LOCATION: der Standort der Steuerungsebene Ihres Clusters.
2. Aktivieren Sie Pod-Snapshots in Ihrem Cluster:
```
  gcloud beta container clusters update CLUSTER_NAME \
    --enable-pod-snapshots \
    --location=CONTROL_PLANE_LOCATION
```
  Ersetzen Sie Folgendes:
  - CLUSTER_NAME: Der Name Ihres Clusters.
  - CONTROL_PLANE_LOCATION: der Standort der Steuerungsebene Ihres Clusters.

Wenn Sie Pods in GKE Sandbox in einem Standard-Cluster ausführen möchten, erstellen oder aktualisieren Sie einen Knotenpool mit aktiviertem gVisor. Verwenden Sie das Flag --sandbox type=gvisor, um einen Knotenpool zu aktualisieren. Führen Sie den folgenden Befehl aus, um einen Knotenpool mit aktiviertem gVisor zu erstellen:

gcloud container node-pools create NODE_POOL_NAME \
  --cluster=CLUSTER_NAME \
  --node-version=NODE_VERSION \
  --machine-type=MACHINE_TYPE \
  --location=CONTROL_PLANE_LOCATION \
  --image-type=cos_containerd \
  --sandbox type=gvisor

Ersetzen Sie die folgenden Variablen:

NODE_POOL_NAME ist der Name des neuen Knotenpools.
CLUSTER_NAME: Der Name Ihres Clusters.
NODE_VERSION: ist die Version, die für den Knotenpool verwendet werden soll.
MACHINE_TYPE: der Maschinentyp, der für die Knoten verwendet werden soll.
CONTROL_PLANE_LOCATION: der Standort der Steuerungsebene Ihres Clusters.

Weitere Informationen zur Verwendung von gVisor finden Sie unter Arbeitslasten mit GKE Sandbox isolieren.

Snapshots speichern

Pod-Snapshots werden in einem Cloud Storage-Bucket gespeichert, der den Arbeitsspeicher und optional den GPU-Status enthält. Für Pod-Snapshots ist Workload Identity Federation for GKE erforderlich, um das Dienstkonto des Pods zu aktivieren und zu verwenden, um sich bei Cloud Storage zu authentifizieren.

Für Pod-Snapshots ist die folgende Konfiguration für den Bucket erforderlich:

Hierarchische Namespaces: Diese müssen aktiviert sein, um mehr Lese- und Schreibabfragen pro Sekunde zu ermöglichen. Für hierarchische Namespaces muss auch der einheitliche Zugriff auf Bucket-Ebene aktiviert sein.
Vorläufiges Löschen: Da für Pod-Snapshots parallele zusammengesetzte Uploadsverwendet werden, sollten Sie Datenschutzfunktionen wie das vorläufige Löschen deaktivieren. Wenn diese Funktionen aktiviert bleiben, können vorläufige Löschungen der temporären Objekte Ihre Speicherrechnung erheblich erhöhen.
Standort: Der Standort des Cloud Storage-Bucket muss mit dem Standort des GKE-Cluster übereinstimmen, da die Leistung beeinträchtigt werden kann, wenn Snapshots zwischen verschiedenen Regionen übertragen werden.

Führen Sie die folgenden Schritte aus, um sowohl den erforderlichen Bucket als auch die Berechtigungen zu erstellen:

Erstellen Sie einen Cloud Storage-Bucket. Mit dem folgenden Befehl wird ein Bucket mit der erforderlichen Konfiguration erstellt:
```
gcloud storage buckets create "gs://BUCKET_NAME" \
   --uniform-bucket-level-access \
   --enable-hierarchical-namespace \
   --soft-delete-duration=0d \
   --location="LOCATION"
```
Ersetzen Sie Folgendes:
- BUCKET_NAME: Der Name Ihres Buckets.
- LOCATION: Der Standort Ihres Buckets.
Eine vollständige Liste der Optionen zum Erstellen von Buckets finden Sie unter buckets create Optionen.

Arbeitslasten Zugriff auf den Cloud Storage-Bucket gewähren

Standardmäßig hat GKE keinen Zugriff auf Cloud Storage. Wenn Sie Snapshot-Dateien lesen und schreiben möchten, müssen Sie dem Kubernetes-Dienstkonto (KSA), das von Ihren Arbeitslast-Pods verwendet wird, eine IAM-Rolle mit den entsprechenden Berechtigungen gewähren oder kurzlebige Tokens gewähren.

Rollen bestimmten Kubernetes-Dienstkonten gewähren

Rufen Sie die Anmeldedaten ab, damit Sie mit kubectl-Befehlen mit Ihrem Cluster kommunizieren können:
```
gcloud container clusters get-credentials "CLUSTER_NAME"
```

Führen Sie für jeden Pod die folgenden Schritte aus:

Erstellen Sie für jeden Pod ein KSA:
```
kubectl create serviceaccount "KSA_NAME" \
    --namespace "NAMESPACE"
```
Ersetzen Sie Folgendes:
- KSA_NAME: Der Name Ihres KSA.
- NAMESPACE: Der Namespace für Ihre Pods.

Gewähren Sie dem KSA die Berechtigung für den Zugriff auf den Bucket:

gcloud storage buckets add-iam-policy-binding "gs://BUCKET_NAME" \
    --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/NAMESPACE/sa/KSA_NAME" \
    --role="roles/storage.bucketViewer"

gcloud storage buckets add-iam-policy-binding "gs://BUCKET_NAME" \
    --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/NAMESPACE/sa/KSA_NAME" \
    --role="roles/storage.objectUser"

Ersetzen Sie Folgendes:

BUCKET_NAME: Der Name Ihres Buckets.
PROJECT_NUMBER: Ihre Projektnummer.
PROJECT_ID: Ihre Projekt-ID.
NAMESPACE: Der Namespace für Ihre Pods.
KSA_NAME: Der Name Ihres KSA.

Mehrmandantenfähigkeit mit kurzlebigen Tokens aktivieren

Alternativ zum Gewähren von Berechtigungen für einzelne KSAs können Sie die Mehrmandantenfähigkeit mit kurzlebigen, bereichsbeschränkten Tokens aktivieren. Dieser Ansatz hilft, die mit manuellen IAM-Bindungen verbundene Weiterleitungsverzögerung zu vermeiden. Anstatt jedem KSA Berechtigungen zu gewähren, gewähren Sie dem GKE-Knotendienstkonto einmalig die Rolle roles/storage.admin für den Snapshot-Speicher-Bucket. Das Knotendienstkonto erstellt dann bei Bedarf kurzlebige Tokens für bestimmte Pfade.

Für das Aktivieren von Tokens mit Pod-Snapshots ist die GKE-Version 1.35.3-gke.1737000 oder höher erforderlich.

Führen Sie die folgenden Schritte aus, um die Mehrmandantenfähigkeit zu aktivieren:

Führen Sie den folgenden Befehl aus, um dem Knotendienstkonto die Berechtigung für den Zugriff auf den Bucket zu gewähren:

gcloud storage buckets add-iam-policy-binding "gs://BUCKET_NAME" \
    --member="serviceAccount:service-PROJECT_NUMBER@gcp-sa-gkenode.iam.gserviceaccount.com" \
    --role="roles/storage.admin"

Wenn Sie Speicher für Snapshots konfigurieren, legen Sie den Wert des tokenSource Felds auf federatedP4SA fest.

Dem Pod-Snapshot-Controller Zugriff auf den Cloud Storage-Bucket gewähren

Damit der Pod-Snapshot-Controller Snapshots im Cloud Storage-Bucket löschen kann, muss dem GKE-Dienst-Agenten die Rolle Storage-Objekt-Nutzer (roles/storage.objectUser) für das Projekt gewährt werden. Gewähren Sie die Rolle roles/storage.objectUser, indem Sie den folgenden Befehl ausführen:

gcloud projects add-iam-policy-binding "PROJECT_ID" \
  --member="serviceAccount:service-PROJECT_NUMBER@container-engine-robot.iam.gserviceaccount.com" \
  --role="roles/storage.objectUser" \
  --condition="expression=resource.name.startsWith(\"projects/_/buckets/BUCKET_NAME\"),title=restrict_to_bucket,description=Restricts access to one bucket only"

Ersetzen Sie Folgendes:

PROJECT_NUMBER: Ihre Projektnummer.
PROJECT_ID: Ihre Projekt-ID.
BUCKET_NAME: Der Name Ihres Buckets.

(Optional) Verwaltete Ordner für den Cloud Storage-Bucket erstellen

Durch das Erstellen von Ordnern können Sie Berechtigungen für Snapshots von einander nicht vertrauenswürdigen Pods isolieren. Dies ist in Mehrmandanten-Anwendungsfällen nützlich. So richten Sie verwaltete Ordner ein:

Erstellen Sie eine benutzerdefinierte IAM-Rolle, die nur die für Pod-Snapshots erforderlichen Berechtigungen enthält:

gcloud iam roles create podSnapshotGcsReadWriter \
    --project="PROJECT_ID" \
    --permissions="storage.objects.get,storage.objects.create,storage.objects.delete,storage.folders.create"

Gewähren Sie allen KSAs im Ziel-Namespace die Rolle roles/storage.bucketViewer. Mit dieser Rolle können KSAs Bucket-Metadaten lesen, aber keine Lese- oder Schreibberechtigungen für Objekte im Bucket gewähren.
```
gcloud storage buckets add-iam-policy-binding "gs://BUCKET_NAME" \
    --member="principalSet://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/namespace/NAMESPACE" \
    --role="roles/storage.bucketViewer"
```
Ersetzen Sie Folgendes:
- BUCKET_NAME: Der Name Ihres Buckets.
- PROJECT_NUMBER: Ihre Projektnummer.
- PROJECT_ID: Ihre Projekt-ID.
- NAMESPACE: Der Namespace für Ihre Pods.
Führen Sie für jedes KSA, das Pod-Snapshots speichern muss, die folgenden Schritte aus:
1. Erstellen Sie einen verwalteten Ordner für das KSA:
```
gcloud storage managed-folders create "gs://BUCKET_NAME/FOLDER_PATH/"
```
  Ersetzen Sie Folgendes:
  - BUCKET_NAME: Der Name Ihres Buckets.
  - FOLDER_PATH: Der Pfad für den verwalteten Ordner, z. B. my-app-snapshots.
2. Gewähren Sie dem KSA die benutzerdefinierte Rolle podSnapshotGcsReadWriter für den verwalteten Ordner:
```
gcloud storage managed-folders add-iam-policy-binding "gs://BUCKET_NAME/FOLDER_PATH/" \
    --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/NAMESPACE/sa/KSA_NAME" \
    --role="projects/PROJECT_ID/roles/podSnapshotGcsReadWriter"
```
  Ersetzen Sie Folgendes:
  - BUCKET_NAME: Der Name Ihres Buckets.
  - FOLDER_PATH: Der Pfad für den verwalteten Ordner, z. B. my-app-snapshots.
  - PROJECT_NUMBER: Ihre Projektnummer.
  - PROJECT_ID: Ihre Projekt-ID.
  - NAMESPACE: Der Namespace für Ihre Pods.
  - KSA_NAME: Der Name Ihres KSA.
Hinweis: Es kann einige Minuten dauern, bis IAM-Richtlinien in GKE übernommen werden.

Speicher für Snapshots konfigurieren

Wenn Sie angeben möchten, wo Snapshot-Dateien gespeichert werden sollen, erstellen Sie eine PodSnapshotStorageConfig-Ressource.

Im folgenden Beispiel wird GKE so konfiguriert, dass Pod-Snapshots im Pfad FOLDER_PATH/ im Cloud Storage-Bucket BUCKET_NAME gespeichert werden. Speichern Sie das folgende Manifest als example-pod-snapshot-storage-config:
```
apiVersion: podsnapshot.gke.io/v1
kind: PodSnapshotStorageConfig
metadata:
  name: example-pod-snapshot-storage-config
spec:
  snapshotStorageConfig:
    gcs:
      bucket: "BUCKET_NAME"
      path: "FOLDER_PATH"
      tokenSource: "TOKEN_SOURCE"
```
Ersetzen Sie Folgendes:
- BUCKET_NAME: Der Name Ihres Cloud Storage-Bucket.
- FOLDER_PATH: Der Pfad für den verwalteten Cloud Storage-Ordner.
- TOKEN_SOURCE: Der Identitätsanbieter für den Zugriff. Verwenden Sie podKSA (Standard) oder federatedP4SA für die Mehrmandantenfähigkeit.

Wenden Sie das Manifest an:

kubectl apply -f example-pod-snapshot-storage-config.yaml

Nächste Schritte

Informationen zum Auslösen eines Pod-Snapshots.