Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Préparer les instantanés de pods

Autopilot Standard

Découvrez comment activer et configurer les instantanés de pods Google Kubernetes Engine (GKE) sur votre cluster, et comment configurer Cloud Storage pour stocker les instantanés.

Pour en savoir plus sur le fonctionnement des instantanés de pods, consultez À propos des instantanés de pods.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

Activez l'API Google Kubernetes Engine.

Activer l'API Google Kubernetes Engine

Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez la gcloud CLI. Si vous avez déjà installé la gcloud CLI, obtenez la dernière version en exécutant la gcloud components update commande. Il est possible que les versions antérieures de la gcloud CLI ne permettent pas d'exécuter les commandes de ce document.
Remarque : Pour les installations de la gcloud CLI existantes, veillez à définir la propriété compute/region. Si vous utilisez principalement des clusters zonaux, définissez plutôt compute/zone. En définissant un emplacement par défaut, vous pouvez éviter les erreurs gcloud CLI de ce type : One of [--zone, --region] must be supplied: Please specify location. Vous devrez peut-être spécifier l'emplacement dans certaines commandes si celui de votre cluster diffère de l'emplacement par défaut que vous avez défini.

Activer les instantanés de pods

Pour activer les instantanés de pods, créez ou mettez à jour un cluster avec la fonctionnalité d'instantané de pods activée. Pour les clusters Standard, vous devez également créer ou mettre à jour un pool de nœuds à exécuter dans GKE Sandbox. GKE Sandbox est compatible par défaut avec les clusters Autopilot.

Pour activer les instantanés de pods sur un cluster, effectuez l'une des procédures suivantes, en fonction du mode de fonctionnement GKE que vous souhaitez utiliser :

Autopilot

Pour activer les instantanés de pods sur un nouveau cluster, exécutez la commande suivante :
```
  gcloud container clusters create-auto CLUSTER_NAME \
      --enable-pod-snapshots \
      --location=CONTROL_PLANE_LOCATION \
      --cluster-version=CLUSTER_VERSION
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster
- CONTROL_PLANE_LOCATION : l'emplacement du plan de contrôle de votre cluster
- CLUSTER_VERSION : version de votre nouveau cluster, qui doit être 1.35.3-gke.1234000 ou ultérieure
Pour activer les instantanés de pods sur un cluster existant, procédez comme suit :
1. Mettez à niveau le cluster vers la version 1.35.3-gke.1234000 ou ultérieure :
```
  gcloud container clusters upgrade CLUSTER_NAME \
      --cluster-version=CLUSTER_VERSION \
      --location=CONTROL_PLANE_LOCATION
```
  Remplacez les éléments suivants :
  - CLUSTER_NAME : nom du cluster
  - CONTROL_PLANE_LOCATION : l'emplacement du plan de contrôle de votre cluster
  - CLUSTER_VERSION : version de votre nouveau cluster, qui doit être 1.35.3-gke.1234000 ou ultérieure
2. Activez les instantanés de pods sur votre cluster :
```
  gcloud container clusters update CLUSTER_NAME \
      --enable-pod-snapshots \
      --location=CONTROL_PLANE_LOCATION
```
Les instantanés de pods avec le champ d'application whole-pod par défaut ne sont pas compatibles avec les types de machines E2. Dans Autopilot, GKE peut utiliser par défaut des types de machines qui ne sont pas compatibles avec les instantanés de pods. Si vous utilisez whole-pod des instantanés avec le champ d'application, pour vous assurer que vos charges de travail s'exécutent sur du matériel compatible, vous devez utiliser une ComputeClass personnalisée pour hiérarchiser les familles de machines compatibles. Les instantanés du système de fichiers (rootfs-only) sont compatibles avec les types de machines E2.

Pour créer et utiliser une ComputeClass personnalisée, procédez comme suit :

Enregistrez le manifeste suivant sous le nom 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

Appliquez le fichier manifeste :
```
  kubectl apply -f non-e2-class.yaml
```
Dans la spécification de votre pod, référencez la ComputeClass à l'aide du cloud.google.com/compute-class sélecteur de nœuds :
```
  spec:
    nodeSelector:
      cloud.google.com/compute-class: non-e2-class
    ...
```

Standard

Pour activer les instantanés de pods sur un nouveau cluster, exécutez la commande suivante :
```
  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
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster
- CLUSTER_VERSION : version de votre nouveau cluster, qui doit être 1.35.3-gke.1234000 ou ultérieure
- PROJECT_ID : ID de votre projet
- CONTROL_PLANE_LOCATION : l'emplacement du plan de contrôle de votre cluster
Pour activer les instantanés de pods sur un cluster existant, procédez comme suit :
1. Mettez à niveau le cluster vers la version 1.35.3-gke.1234000 ou ultérieure :
```
  gcloud container clusters upgrade CLUSTER_NAME \
      --node-pool=NODEPOOL_NAME \
      --cluster-version=CLUSTER_VERSION \
      --location=CONTROL_PLANE_LOCATION
```
  Remplacez les éléments suivants :
  - CLUSTER_NAME : nom du cluster
  - NODEPOOL_NAME : nom de votre pool de nœuds
  - CLUSTER_VERSION : version de votre nouveau cluster, qui doit être 1.35.3-gke.1234000 ou ultérieure
  - CONTROL_PLANE_LOCATION : l'emplacement du plan de contrôle de votre cluster
2. Activez les instantanés de pods sur votre cluster :
```
  gcloud beta container clusters update CLUSTER_NAME \
    --enable-pod-snapshots \
    --location=CONTROL_PLANE_LOCATION
```
  Remplacez les éléments suivants :
  - CLUSTER_NAME : nom du cluster
  - CONTROL_PLANE_LOCATION : l'emplacement du plan de contrôle de votre cluster

Pour exécuter des pods dans GKE Sandbox sur un cluster Standard, créez ou mettez à jour un pool de nœuds avec gVisor activé. Pour mettre à jour un pool de nœuds, utilisez l'indicateur --sandbox type=gvisor. Pour créer un pool de nœuds avec gVisor activé, exécutez la commande suivante :

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

Remplacez les variables suivantes :

NODE_POOL_NAME : nom de votre nouveau pool de nœuds.
CLUSTER_NAME : nom du cluster
NODE_VERSION : version à utiliser pour le pool de nœuds
MACHINE_TYPE : le type de machine à utiliser pour les nœuds
CONTROL_PLANE_LOCATION : l'emplacement du plan de contrôle de votre cluster

Pour en savoir plus sur l'utilisation de gVisor, consultez Isoler vos charges de travail à l'aide de GKE Sandbox.

Stocker les instantanés

Les instantanés de pods sont stockés dans un bucket Cloud Storage, qui contient l'état de la mémoire et (facultativement) du GPU. Les instantanés de pods nécessitent Workload Identity Federation for GKE afin d'activer et d'utiliser le compte de service du pod pour s'authentifier auprès de Cloud Storage.

Les instantanés de pods nécessitent la configuration suivante pour le bucket :

Espaces de noms hiérarchiques : ils doivent être activés pour autoriser un plus grand nombre de requêtes par seconde en lecture et en écriture. Les espaces de noms hiérarchiques nécessitent également que l'accès uniforme au niveau du bucket soit activé.
Suppression réversible : étant donné que les instantanés de pods utilisent des importations composites parallèles, vous devez désactiver les fonctionnalités de protection des données telles que la suppression réversible. Si ces fonctionnalités restent activées, les suppressions réversibles des objets temporaires peuvent augmenter considérablement votre facture de stockage.
Emplacement : l'emplacement du bucket Cloud Storage doit être le même que celui du cluster GKE, car les performances peuvent être affectées si les instantanés sont transférés entre différentes régions.

Pour créer le bucket et les autorisations requis, procédez comme suit :

Créez un bucket Cloud Storage. La commande suivante crée un bucket avec la configuration requise :
```
gcloud storage buckets create "gs://BUCKET_NAME" \
   --uniform-bucket-level-access \
   --enable-hierarchical-namespace \
   --soft-delete-duration=0d \
   --location="LOCATION"
```
Remplacez les éléments suivants :
- BUCKET_NAME : nom de votre bucket
- LOCATION : emplacement de votre bucket
Pour obtenir la liste complète des options de création de buckets, consultez les buckets create options.

Accorder aux charges de travail l'accès au bucket Cloud Storage

Par défaut, GKE n'a pas accès à Cloud Storage. Pour lire et écrire des fichiers d'instantanés, vous devez accorder un rôle IAM contenant les autorisations correspondantes au Kubernetes ServiceAccount (KSA) utilisé par les pods de votre charge de travail, ou accorder des jetons éphémères.

Accorder des rôles à des Kubernetes ServiceAccounts spécifiques

Obtenez des identifiants pour pouvoir communiquer avec votre cluster à l'aide des commandes kubectl :
```
gcloud container clusters get-credentials "CLUSTER_NAME"
```

Pour chaque pod, procédez comme suit :

Créez un KSA pour chaque pod :
```
kubectl create serviceaccount "KSA_NAME" \
    --namespace "NAMESPACE"
```
Remplacez les éléments suivants :
- KSA_NAME : nom de votre KSA
- NAMESPACE : espace de noms de vos pods

Accordez au KSA l'autorisation d'accéder au 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"

Remplacez les éléments suivants :

BUCKET_NAME : nom de votre bucket
PROJECT_NUMBER : numéro de votre projet
PROJECT_ID : ID de votre projet
NAMESPACE : espace de noms de vos pods
KSA_NAME : nom de votre KSA

Activer l'architecture mutualisée à l'aide de jetons éphémères

Au lieu d'accorder des autorisations à des KSA individuels, vous pouvez activer l'architecture mutualisée avec des jetons éphémères à champ d'application limité. Cette approche permet d'éviter le délai de propagation associé aux liaisons IAM manuelles. Au lieu d'accorder des autorisations à chaque KSA, vous accordez une seule fois le rôle roles/storage.admin sur le bucket de stockage d'instantanés au compte de service de nœud GKE. Le compte de service de nœud crée ensuite des jetons éphémères à la demande pour des chemins d'accès spécifiques.

L'activation des jetons avec les instantanés de pods nécessite GKE version 1.35.3-gke.1737000 ou ultérieure.

Pour activer l'architecture mutualisée, procédez comme suit :

Pour accorder au compte de service de nœud l'autorisation d'accéder au bucket, exécutez la commande suivante :

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"

Lorsque vous configurez le stockage pour les instantanés, définissez la valeur du champ tokenSource sur federatedP4SA.

Accorder au contrôleur d'instantanés de pods l'accès au bucket Cloud Storage

Pour autoriser le contrôleur d'instantanés de pods à supprimer des instantanés dans le bucket Cloud Storage, le compte de service de l'agent de service GKE doit disposer du rôle Utilisateur d'objets Storage (roles/storage.objectUser) sur le projet. Accordez le rôle roles/storage.objectUser en exécutant la commande suivante :

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"

Remplacez les éléments suivants :

PROJECT_NUMBER : numéro de votre projet
PROJECT_ID : ID de votre projet
BUCKET_NAME : nom de votre bucket

(Facultatif) Créer des dossiers gérés pour le bucket Cloud Storage

La création de dossiers vous permet d'isoler les autorisations pour les instantanés de pods mutuellement non approuvés, ce qui est utile dans les cas d'utilisation mutualisés. Pour configurer des dossiers gérés, procédez comme suit :

Créez un rôle IAM personnalisé qui ne contient que les autorisations nécessaires pour les instantanés de pods :

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

Accordez le rôle roles/storage.bucketViewer à tous les KSA de l'espace de noms cible. Ce rôle permet aux KSA de lire les métadonnées du bucket, mais n'accorde pas d'autorisations de lecture ou d'écriture aux objets du 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"
```
Remplacez les éléments suivants :
- BUCKET_NAME : nom de votre bucket
- PROJECT_NUMBER : numéro de votre projet
- PROJECT_ID : ID de votre projet
- NAMESPACE : espace de noms de vos pods
Pour chaque KSA qui doit stocker des instantanés de pods, procédez comme suit :
1. Créez un dossier géré pour le KSA :
```
gcloud storage managed-folders create "gs://BUCKET_NAME/FOLDER_PATH/"
```
  Remplacez les éléments suivants :
  - BUCKET_NAME : nom de votre bucket
  - FOLDER_PATH : chemin d'accès au dossier géré, par exemple my-app-snapshots
2. Accordez au KSA le rôle personnalisé podSnapshotGcsReadWriter sur le dossier géré :
```
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"
```
  Remplacez les éléments suivants :
  - BUCKET_NAME : nom de votre bucket
  - FOLDER_PATH : chemin d'accès au dossier géré, par exemple my-app-snapshots
  - PROJECT_NUMBER : numéro de votre projet
  - PROJECT_ID : ID de votre projet
  - NAMESPACE : espace de noms de vos pods
  - KSA_NAME : nom de votre KSA
Remarque : Les règles IAM peuvent mettre plusieurs minutes à s'afficher dans GKE.

Configurer le stockage pour les instantanés

Pour spécifier où stocker les fichiers d'instantanés, créez une ressource PodSnapshotStorageConfig.

L'exemple suivant configure GKE pour stocker les instantanés de pods dans le chemin d'accès FOLDER_PATH/ à l'intérieur du bucket Cloud Storage BUCKET_NAME. Enregistrez le manifeste suivant sous le nom 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"
```
Remplacez les éléments suivants :
- BUCKET_NAME : nom de votre bucket Cloud Storage
- FOLDER_PATH : chemin d'accès au dossier géré Cloud Storage
- TOKEN_SOURCE : fournisseur d'identité pour l'accès Utilisez podKSA (par défaut) ou federatedP4SA pour l'architecture mutualisée.

Appliquez le fichier manifeste :

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

Étape suivante

Découvrez comment déclencher un instantané de pod.