Pod-Snapshots vorbereiten

Mit Pod-Snapshots in der Google Kubernetes Engine (GKE) können Sie den Status laufender 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 Informationen zu GKE-Pod-Snapshots.

Plattformadministratoren und -operatoren sowie Anwendungsentwickler können dieses Dokument verwenden, um Cluster zu konfigurieren, Storage-Buckets zu erstellen und Zugriffsberechtigungen für Pod-Snapshots einzurichten. Weitere Informationen zu den gängigen Rollen und Beispielaufgaben, auf die in Google Cloud -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, 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. Ä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 für einen neuen oder vorhandenen Cluster aktivieren. Für Pod-Snapshots sind GKE Sandbox und die Workload Identity Federation for GKE erforderlich. Autopilot-Cluster aktivieren beide Features standardmäßig. Bei Standard-Clustern 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: Der 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. Diese 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 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.

Pod-Snapshots mit dem Standardbereich whole-pod unterstützen keine E2-Maschinentypen, Dateisystem-Snapshots (rootfs-only) hingegen schon. In Autopilot-Clustern plant GKE Pods standardmäßig möglicherweise auf E2-Knoten. Wenn Sie den Bereich whole-pod verwenden, können Sie mit einer benutzerdefinierten ComputeClass-Ressource dafür sorgen, 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.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.

  • 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 des Knotenpools.
      • CLUSTER_VERSION: die Version, auf die Sie Ihren Cluster aktualisieren möchten. Diese 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 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 aktiviertem 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 ist 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 für die Knoten zu verwendende Maschinentyp.
  • 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

Die 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 muss außerdem der einheitliche Zugriff auf Bucket-Ebene aktiviert sein.
  • Vorläufiges Löschen: Da Pod-Snapshots parallele zusammengesetzte Uploads verwenden, müssen Sie Datenschutzfunktionen wie das vorläufige Löschen deaktivieren. Wenn Sie diese Funktionen aktiviert lassen, kann das vorläufige Löschen der temporären Objekte Ihre Speicherrechnung erheblich erhöhen.
  • Standort: Der Cloud Storage-Bucket muss sich am selben Standort wie der GKE-Cluster befinden, 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 Speicherort Ihres Buckets.

Eine vollständige Liste der Optionen für die Bucket-Erstellung finden Sie in der Dokumentation zum Befehl buckets create unter Flags.

Arbeitslasten Zugriff auf den Cloud Storage-Bucket gewähren

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

Bestimmten Kubernetes-ServiceAccount-Objekten Rollen zuweisen

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

  1. Wenn Sie mit kubectl-Befehlen mit Ihrem Cluster kommunizieren möchten, rufen Sie die Anmeldedaten für Ihren Cluster ab:

    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. Gehen Sie für jeden Pod so vor:

    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. Gewähren Sie dem ServiceAccount-Objekt die Berechtigung, auf den Bucket zuzugreifen. Wählen Sie je nach Sicherheitsanforderungen eine der folgenden Optionen aus:

      • Standardberechtigungen: Gewährt vollständigen Lese-, Schreib- und Löschzugriff.
      • Write-Once-Berechtigungen: Verhindert das Überschreiben oder Löschen abgeschlossener Snapshot-Dateien, gewährt aber die Berechtigung zum Löschen temporärer Objekte für parallele zusammengesetzte Uploads.

      Führen Sie die Befehle für die ausgewählte Option aus, um die Berechtigung zu erteilen:

      Standardberechtigungen 

      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/SERVICEACCOUNT_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/SERVICEACCOUNT_NAME" \
    --role="roles/storage.objectUser"

      Einmalige Schreibberechtigungen 

      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/SERVICEACCOUNT_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/SERVICEACCOUNT_NAME" \
    --role="roles/storage.objectCreator"

      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/SERVICEACCOUNT_NAME" \
    --role="roles/storage.objectViewer"

      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/SERVICEACCOUNT_NAME" \
    --role="roles/storage.objectUser" \
    --condition='expression=resource.type == "storage.googleapis.com/Object" && (resource.name.extract("/pages.img_{part}") != "" || resource.name.extract("/fs_checkpoint_pages.img_{part}") != ""),title=allow_pcu_temp_part_cleanup,description=Allow deleting temporary parallel composite upload part objects only'

      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.

Mehrmandantenfähigkeit mit kurzlebigen Tokens aktivieren

Als Alternative zur Gewährung von Berechtigungen für einzelne ServiceAccount-Objekte können Sie die Mehrmandantenfähigkeit mit kurzlebigen, bereichsbeschränkten Tokens aktivieren. So lässt sich die mit manuellen IAM-Bindungen verbundene Weiterleitungsverzögerung vermeiden. Anstatt jedem ServiceAccount-Objekt Berechtigungen zu erteilen, weisen Sie dem GKE-Knotendienstkonto einmalig die Rolle „Storage-Administrator“ (roles/storage.admin) für den Snapshot-Storage-Bucket zu. Das Knoten-Dienstkonto erstellt dann bei Bedarf kurzlebige Tokens für bestimmte Pfade.

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

So aktivieren Sie die Mandantenfähigkeit:

  1. Führen Sie den folgenden Befehl aus, um dem Knotendienstkonto 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.iam.gserviceaccount.com" \
    --role="roles/storage.admin"

    Ersetzen Sie Folgendes:

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

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

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-Agent im Projekt die Rolle „Storage-Objekt-Nutzer“ (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.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

Wenn Sie Berechtigungen für Snapshots von Pods isolieren möchten, die sich gegenseitig nicht vertrauen, was in Mehrmandanten-Anwendungsfällen nützlich ist, erstellen Sie verwaltete Ordner. So richten Sie verwaltete Ordner ein:

  1. Erstellen Sie eine benutzerdefinierte IAM-Rolle, die nur die erforderlichen Berechtigungen für Pod-Snapshots enthält. Führen Sie den Befehl für die ausgewählte Option aus:

    Standardberechtigungen 

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

    Einmalige Schreibberechtigungen 

    gcloud iam roles create podSnapshotGcsReadWriter \
    --project=PROJECT_ID \
    --permissions="storage.objects.get,storage.objects.list,storage.objects.create,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.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. Führen Sie die Befehle für die ausgewählte Option aus, um die Berechtigung zu erteilen:

      Standardberechtigungen 

      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/SERVICEACCOUNT_NAME" \
    --role="projects/PROJECT_ID/roles/podSnapshotGcsReadWriter"

      Einmalige Schreibberechtigungen 

      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/SERVICEACCOUNT_NAME" \
    --role="projects/PROJECT_ID/roles/podSnapshotGcsReadWriter"

      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/SERVICEACCOUNT_NAME" \
    --role="roles/storage.objectUser" \
    --condition='expression=resource.type == "storage.googleapis.com/Object" && (resource.name.extract("/pages.img_{part}") != "" || resource.name.extract("/fs_checkpoint_pages.img_{part}") != ""),title=allow_pcu_temp_part_cleanup,description=Allow deleting temporary parallel composite upload part objects only'

      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

Wenn Sie angeben möchten, wo Pod-Snapshots gespeichert werden sollen, erstellen Sie eine benutzerdefinierte PodSnapshotStorageConfig-Ressource:

  1. Speichern Sie das folgende Manifest als example-pod-snapshot-storage-config.yaml. In diesem Beispiel wird GKE so konfiguriert, dass Pod-Snapshots im Pfad FOLDER_PATH/ 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

Pod-Snapshot auslösen