Pod-Snapshots vorbereiten

Mit Pod-Snapshots in Google Kubernetes Engine (GKE) können Sie den Status von ausgeführten Pods speichern und wiederherstellen, um die Startlatenz von Arbeitslasten zu verbessern. Bevor Sie Snapshots Ihrer Arbeitslasten erstellen können, müssen Sie Ihren Cluster und Ihre Speicherumgebung vorbereiten.

In diesem Dokument erfahren Sie, wie Sie Pod-Snapshots in Ihrem Cluster aktivieren und konfigurieren und Cloud Storage zum Speichern der Snapshots einrichten. Weitere Informationen zur Funktionsweise von Pod-Snapshots finden Sie unter GKE-Pod-Snapshots.

Plattformadministratoren und -operatoren sowie Anwendungsentwickler können dieses Dokument verwenden, um Cluster zu konfigurieren, Speicher-Buckets zu erstellen und Zugriffsberechtigungen für Pod-Snapshots einzurichten. Weitere Informationen zu den häufig verwendeten Rollen und Beispielaufgaben, auf die in den Cloud de Confiance by S3NS Inhalten verwiesen wird, finden Sie unter Häufig verwendete GKE-Nutzerrollen und Aufgaben.

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.

Pod-Snapshots aktivieren

Sie können Pod-Snapshots in einem neuen oder vorhandenen Cluster aktivieren. Für Pod-Snapshots sind GKE Sandbox und die Workload Identity-Föderation für GKE erforderlich. Für Autopilot-Cluster sind beide Funktionen standardmäßig aktiviert. Für Standardcluster müssen Sie die Workload Identity-Föderation für GKE im Cluster aktivieren und einen Knotenpool für die Ausführung in GKE Sandbox konfigurieren.

Führen Sie die Schritte für den gewünschten GKE-Betriebsmodus 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: the Standort der Steuerungsebene Ihres Clusters.
    • CLUSTER_VERSION: Die Version Ihres neuen Clusters, die 1.35.3-gke.1234000 oder höher sein muss.

  • So aktivieren Sie Pod-Snapshots in einem vorhandenen Cluster:

    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.
      • CLUSTER_VERSION: Die Version, auf die Sie Ihren Cluster aktualisieren möchten. Sie muss 1.35.3-gke.1234000 oder höher sein.
      • CONTROL_PLANE_LOCATION: the Standort der Steuerungsebene Ihres Clusters.

    2. Aktivieren Sie Pod-Snapshots in Ihrem Cluster:

        gcloud container clusters update CLUSTER_NAME \
      --enable-pod-snapshots \
      --location=CONTROL_PLANE_LOCATION

      Ersetzen Sie Folgendes:

      • CLUSTER_NAME: Der Name Ihres Clusters.
      • CONTROL_PLANE_LOCATION: the Standort der Steuerungsebene Ihres Clusters.

Pod-Snapshots mit dem Standardbereich whole-pod unterstützen keine E2-Maschinentypen, Dateisystem-Snapshots (rootfs-only) jedoch schon. In Autopilot-Clustern plant GKE Pods standardmäßig auf E2-Knoten. Wenn Sie den whole-pod Bereich verwenden, verwenden Sie eine benutzerdefinierte ComputeClass-Ressource, um sicherzustellen, dass Ihre Arbeitslasten auf kompatibler Hardware ausgeführt werden.

So erstellen und verwenden Sie eine benutzerdefinierte ComputeClass-Ressource:

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

  2. Wenden Sie das Manifest an:

      kubectl apply -f non-e2-class.yaml

  3. Verweisen Sie in Ihrer Pod-Spezifikation mit der Knotenauswahl cloud.google.com/compute-class auf die benutzerdefinierte ComputeClass-Ressource:

      spec:
    nodeSelector:
      cloud.google.com/compute-class: non-e2-class
    # Multiple lines are omitted here

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.s3ns.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: the Standort der Steuerungsebene Ihres Clusters.

  • So aktivieren Sie Pod-Snapshots in einem vorhandenen Cluster:

    1. Aktualisieren Sie den Cluster auf Version 1.35.3-gke.1234000 oder höher:

        gcloud container clusters upgrade CLUSTER_NAME \
      --node-pool=NODE_POOL_NAME \
      --cluster-version=CLUSTER_VERSION \
      --location=CONTROL_PLANE_LOCATION

      Ersetzen Sie Folgendes:

      • CLUSTER_NAME: Der Name Ihres Clusters.
      • NODE_POOL_NAME: Der Name Ihres Knotenpools.
      • CLUSTER_VERSION: Die Version, auf die Sie Ihren Cluster aktualisieren möchten. Sie muss 1.35.3-gke.1234000 oder höher sein.
      • CONTROL_PLANE_LOCATION: the 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: the Standort der Steuerungsebene Ihres Clusters.

Wenn Sie Pods in GKE Sandbox in einem Standardcluster ausführen möchten, müssen Sie einen Knotenpool mit aktivierter GKE Sandbox erstellen oder aktualisieren. Verwenden Sie das Flag --sandbox type=gvisor, um einen Knotenpool zu aktualisieren. Führen Sie den folgenden Befehl aus, um einen Knotenpool mit aktivierter GKE Sandbox 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 Folgendes:

  • NODE_POOL_NAME: Der Name des neuen Knotenpools.
  • CLUSTER_NAME: Der Name Ihres Clusters.
  • NODE_VERSION: 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 zu GKE Sandbox finden Sie unter Isolierung von Arbeitslasten mit GKE Sandbox härten.

Snapshots speichern

GKE speichert Pod-Snapshots in einem Cloud Storage-Bucket. Jeder Snapshot enthält den Anwendungsspeicher und optional den GPU-Status des Pods. Zur Authentifizierung bei Cloud Storage verwenden Pod-Snapshots das ServiceAccount-Objekt des Pods, für das die Workload Identity-Föderation für GKE erforderlich ist.

Für Pod-Snapshots sind die folgenden Bucket-Konfigurationen erforderlich:

  • Hierarchische Namespaces: Sie müssen hierarchische Namespaces aktivieren, um mehr Lese- und Schreibabfragen pro Sekunde zu unterstützen. Für hierarchische Namespaces müssen Sie auch den einheitlichen Zugriff auf Bucket-Ebene aktivieren.
  • Vorläufiges Löschen: Da Pod-Snapshots parallele zusammengesetzte Uploads verwenden, deaktivieren Sie Datenschutzfunktionen wie das vorläufige Löschen. Wenn Sie diese Funktionen aktiviert lassen, können vorläufige Löschungen der temporären Objekte Ihre Speicherrechnung erheblich in die Höhe treiben.
  • Standort: Der Standort des Cloud Storage-Bucket muss mit dem Standort des GKE-Cluster übereinstimmen, da die Übertragung von Snapshots zwischen verschiedenen Regionen die Leistung beeinträchtigen kann.

Führen Sie den folgenden Befehl aus, um einen Bucket mit den erforderlichen Konfigurationen zu erstellen:

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 für die Bucket-Erstellung finden Sie unter Flags in der Dokumentation zum buckets create Befehl.

Arbeitslasten Zugriff auf den Cloud Storage-Bucket gewähren

Standardmäßig hat GKE keinen Zugriff auf Cloud Storage. Wenn Sie Pod-Snapshots lesen und schreiben möchten, müssen Sie dem Kubernetes-ServiceAccount Objekt, das von Ihren Arbeitslast-Pods verwendet wird, eine IAM-Rolle mit den entsprechenden Berechtigungen zuweisen oder die Mehrmandantenfähigkeit mit kurzlebigen Tokens aktivieren.

Bestimmten Kubernetes-ServiceAccount-Objekten Rollen zuweisen

So weisen Sie bestimmten Kubernetes-ServiceAccount-Objekten Rollen zu:

  1. Rufen Sie Anmeldedaten für Ihren Cluster ab, um mit kubectl-Befehlen mit Ihrem Cluster zu kommunizieren:

    gcloud container clusters get-credentials CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION

    Ersetzen Sie Folgendes:

    • CLUSTER_NAME: Der Name Ihres Clusters.
    • CONTROL_PLANE_LOCATION: Der Standort der Steuerungsebene Ihres Clusters.

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

    1. Erstellen Sie ein ServiceAccount-Objekt:

      kubectl create serviceaccount SERVICEACCOUNT_NAME \
    --namespace=NAMESPACE

      Ersetzen Sie Folgendes:

      • SERVICEACCOUNT_NAME: Der Name Ihres ServiceAccount-Objekts.
      • NAMESPACE: Der Namespace für Ihre Pods.

    2. Damit das ServiceAccount-Objekt Bucket-Metadaten lesen kann, weisen Sie ihm die Rolle „Storage Bucket Viewer“ (roles/storage.bucketViewer) zu:

      gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
    --member="principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.s3ns.svc.id.goog/subject/ns/NAMESPACE/sa/SERVICEACCOUNT_NAME" \
    --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.
      • SERVICEACCOUNT_NAME: Der Name Ihres ServiceAccount-Objekts.

    3. Damit das ServiceAccount-Objekt Snapshot-Objekte im Bucket lesen und schreiben kann, weisen Sie ihm die Rolle „Storage Object User“ (roles/storage.objectUser) zu:

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

Mehrmandantenfähigkeit mit kurzlebigen Tokens aktivieren

Alternativ zum Zuweisen von Berechtigungen zu einzelnen ServiceAccount-Objekten können Sie die Mehrmandantenfähigkeit mit kurzlebigen, bereichsbeschränkten Tokens aktivieren. Dieser Ansatz trägt dazu bei, die mit manuellen IAM-Bindungen verbundene Weitergabeverzögerung zu vermeiden. Anstatt Berechtigungen für jedes ServiceAccount-Objekt zu erteilen, weisen Sie dem GKE-Knoten-Dienstkonto einmalig die Rolle „Storage-Administrator“ (roles/storage.admin) für den Snapshot-Speicher-Bucket zu. Das Knoten-Dienstkonto erstellt dann bei Bedarf kurzlebige Tokens für bestimmte Pfade.

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

So aktivieren Sie die Mehrmandantenfähigkeit:

  1. Führen Sie den folgenden Befehl aus, um dem Knoten-Dienstkonto die Berechtigung zur Verwendung des Buckets zu erteilen:

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

    Ersetzen Sie Folgendes:

    • BUCKET_NAME: Der Name Ihres Buckets.
    • PROJECT_NUMBER: Ihre Projektnummer.

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

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

Damit der Pod-Snapshot-Controller Snapshots im Cloud Storage-Bucket löschen kann, müssen Sie dem GKE-Dienst-Agenten im Projekt die Rolle „Storage Object User“ (roles/storage.objectUser) zuweisen. Führen Sie den folgenden Befehl aus, um die Rolle zuzuweisen:

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:service-PROJECT_NUMBER@container-engine-robot.s3ns-system.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_ID: Ihre Projekt-ID.
  • PROJECT_NUMBER: Ihre Projektnummer.
  • BUCKET_NAME: Der Name Ihres Buckets.

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

Erstellen Sie verwaltete Ordner, um Berechtigungen für Snapshots von nicht vertrauenswürdigen Pods zu isolieren. Dies ist in Mehrmandanten-Anwendungsfällen nützlich. So richten Sie verwaltete Ordner ein:

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

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

    Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID.

  2. Weisen Sie allen ServiceAccount-Objekten im Ziel-Namespace die Rolle „Storage Bucket Viewer“ (roles/storage.bucketViewer) zu. Mit dieser Rolle können die ServiceAccount-Objekte Bucket-Metadaten lesen, aber sie erhalten keine Berechtigungen zum Lesen oder Schreiben der Objekte im Bucket.

    gcloud storage buckets add-iam-policy-binding gs://BUCKET_NAME \
    --member="principalSet://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.s3ns.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.

  3. Führen Sie für jedes ServiceAccount-Objekt, das Pod-Snapshots speichern muss, die folgenden Schritte aus:

    1. Erstellen Sie einen verwalteten Ordner für das ServiceAccount-Objekt:

      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. Weisen Sie dem ServiceAccount-Objekt die benutzerdefinierte Rolle podSnapshotGcsReadWriter für den verwalteten Ordner zu:

      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.s3ns.svc.id.goog/subject/ns/NAMESPACE/sa/SERVICEACCOUNT_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.
      • SERVICEACCOUNT_NAME: Der Name Ihres ServiceAccount-Objekts.

Speicher für Snapshots konfigurieren

Erstellen Sie eine benutzerdefinierte PodSnapshotStorageConfig-Ressource, um anzugeben, wo Pod-Snapshots gespeichert werden sollen:

  1. Speichern Sie das folgende Manifest als example-pod-snapshot-storage-config.yaml. In diesem Beispiel wird GKE so konfiguriert, dass Pod-Snapshots im FOLDER_PATH/ Pfad im Cloud Storage-Bucket BUCKET_NAME gespeichert werden:

    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.

  2. Wenden Sie das Manifest an:

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

Nächste Schritte

Informationen zum Auslöfen eines Pod-Snapshots Informationen zum Auslösen eines Pod-Snapshots.