Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Prepararsi per gli snapshot dei pod

Autopilot Standard

Scopri come abilitare e configurare gli snapshot dei pod di Google Kubernetes Engine (GKE) sul cluster e come configurare Cloud Storage per archiviare gli snapshot.

Per saperne di più su come funzionano gli snapshot dei pod, consulta Informazioni sugli snapshot dei pod.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

Abilita l'API Google Kubernetes Engine.

Abilita l'API Google Kubernetes Engine

Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo il gcloud components update comando. Le versioni precedenti di gcloud CLI potrebbero non supportare l'esecuzione dei comandi in questo documento.
Nota: per le installazioni esistenti di gcloud CLI assicurati di impostare la compute/region proprietà. Se utilizzi principalmente cluster zonali, imposta invece compute/zone. Se imposti una località predefinita, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location. Potresti dover specificare la posizione in determinati comandi se la posizione del cluster è diversa da quella predefinita che hai impostato.

Abilita gli snapshot dei pod

Per abilitare gli snapshot dei pod, crea o aggiorna un cluster con la funzionalità di snapshot dei pod abilitata. Per i cluster Standard, devi anche creare o aggiornare un pool di nodi da eseguire in GKE Sandbox. GKE Sandbox è supportato per impostazione predefinita con i cluster Autopilot.

Per abilitare gli snapshot dei pod su un cluster, completa una delle seguenti procedure, a seconda della modalità di funzionamento di GKE che vuoi utilizzare:

Autopilot

Per abilitare gli snapshot dei pod su un nuovo cluster, esegui il seguente comando:
```
  gcloud container clusters create-auto CLUSTER_NAME \
      --enable-pod-snapshots \
      --location=CONTROL_PLANE_LOCATION \
      --cluster-version=CLUSTER_VERSION
```
Sostituisci quanto segue:
- CLUSTER_NAME: il nome del tuo cluster.
- CONTROL_PLANE_LOCATION: la località del piano di controllo del cluster.
- CLUSTER_VERSION: la versione del nuovo cluster, che deve essere 1.35.3-gke.1234000 o successive.
Per abilitare gli snapshot dei pod su un cluster esistente, completa i seguenti passaggi:
1. Esegui l'upgrade del cluster alla versione 1.35.3-gke.1234000 o successive:
```
  gcloud container clusters upgrade CLUSTER_NAME \
      --cluster-version=CLUSTER_VERSION \
      --location=CONTROL_PLANE_LOCATION
```
  Sostituisci quanto segue:
  - CLUSTER_NAME: il nome del tuo cluster.
  - CONTROL_PLANE_LOCATION: la località del piano di controllo del cluster.
  - CLUSTER_VERSION: la versione del nuovo cluster, che deve essere 1.35.3-gke.1234000 o successive.
2. Abilita gli snapshot dei pod sul cluster:
```
  gcloud container clusters update CLUSTER_NAME \
      --enable-pod-snapshots \
      --location=CONTROL_PLANE_LOCATION
```
Gli snapshot dei pod con ambito whole-pod predefinito non supportano i tipi di macchine E2. In Autopilot, GKE potrebbe utilizzare per impostazione predefinita tipi di macchine che non supportano gli snapshot dei pod. Se utilizzi whole-pod snapshot con ambito, per assicurarti che i tuoi workload vengano eseguiti su hardware compatibile, devi utilizzare un ComputeClass personalizzato per dare la priorità alle famiglie di macchine compatibili. Gli snapshot del file system (rootfs-only) supportano i tipi di macchine E2.

Per creare e utilizzare un ComputeClass personalizzato, completa i seguenti passaggi:

Salva il seguente manifest come 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

Applica il manifest:
```
  kubectl apply -f non-e2-class.yaml
```
Nella specifica del pod, fai riferimento a ComputeClass utilizzando il cloud.google.com/compute-class selettore di nodi:
```
  spec:
    nodeSelector:
      cloud.google.com/compute-class: non-e2-class
    ...
```

Standard

Per abilitare gli snapshot dei pod su un nuovo cluster, esegui il seguente comando:
```
  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
```
Sostituisci quanto segue:
- CLUSTER_NAME: il nome del tuo cluster.
- CLUSTER_VERSION: la versione del nuovo cluster, che deve essere 1.35.3-gke.1234000 o successive.
- PROJECT_ID: il tuo ID progetto.
- CONTROL_PLANE_LOCATION: la località del piano di controllo del cluster.
Per abilitare gli snapshot dei pod su un cluster esistente, completa i seguenti passaggi:
1. Esegui l'upgrade del cluster alla versione 1.35.3-gke.1234000 o successive:
```
  gcloud container clusters upgrade CLUSTER_NAME \
      --node-pool=NODEPOOL_NAME \
      --cluster-version=CLUSTER_VERSION \
      --location=CONTROL_PLANE_LOCATION
```
  Sostituisci quanto segue:
  - CLUSTER_NAME: il nome del tuo cluster.
  - NODEPOOL_NAME: il nome del tuo pool di nodi.
  - CLUSTER_VERSION: la versione a cui aggiornare il nuovo cluster, che deve essere 1.35.3-gke.1234000 o successive.
  - CONTROL_PLANE_LOCATION: la località del piano di controllo del cluster.
2. Abilita gli snapshot dei pod sul cluster:
```
  gcloud beta container clusters update CLUSTER_NAME \
    --enable-pod-snapshots \
    --location=CONTROL_PLANE_LOCATION
```
  Sostituisci quanto segue:
  - CLUSTER_NAME: il nome del tuo cluster.
  - CONTROL_PLANE_LOCATION: la località del piano di controllo del cluster.

Per eseguire i pod in GKE Sandbox su un cluster Standard, crea o aggiorna un pool di nodi con gVisor abilitato. Per aggiornare un pool di nodi, utilizza il flag --sandbox type=gvisor. Per creare un pool di nodi con gVisor abilitato, esegui il seguente comando:

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

Sostituisci le seguenti variabili:

NODE_POOL_NAME: il nome del nuovo pool di nodi.
CLUSTER_NAME: il nome del tuo cluster.
NODE_VERSION: la versione da utilizzare per il pool di nodi.
MACHINE_TYPE: il tipo di macchina da utilizzare per i nodi.
CONTROL_PLANE_LOCATION: la località del piano di controllo del cluster.

Per saperne di più sull'utilizzo di gVisor, consulta Isolare i workload con GKE Sandbox.

Archivia gli snapshot

Gli snapshot dei pod vengono archiviati in un bucket Cloud Storage, che contiene la memoria e (facoltativamente) lo stato della GPU. Gli snapshot dei pod richiedono Workload Identity Federation for GKE per abilitare e utilizzare il account di servizio del pod per l'autenticazione a Cloud Storage.

Gli snapshot dei pod richiedono la seguente configurazione per il bucket:

Spazi dei nomi gerarchici: devono essere abilitati per consentire un numero maggiore di query di lettura e scrittura al secondo. Gli spazi dei nomi gerarchici richiedono anche che l'accesso uniforme a livello di bucket sia abilitato.
Eliminazione temporanea: poiché gli snapshot dei pod utilizzano caricamenti compositi paralleli, devi disabilitare le funzionalità di protezione dei dati come l'eliminazione temporanea. Se queste funzionalità rimangono abilitate, le eliminazioni temporanee degli oggetti temporanei possono aumentare notevolmente la fattura di archiviazione.
Località: la località del bucket Cloud Storage deve essere la stessa del cluster GKE, perché le prestazioni potrebbero risentire del trasferimento degli snapshot tra regioni diverse.

Per creare sia il bucket che le autorizzazioni richieste, completa i seguenti passaggi:

Creare un bucket Cloud Storage. Il seguente comando crea un bucket con la configurazione richiesta:
```
gcloud storage buckets create "gs://BUCKET_NAME" \
   --uniform-bucket-level-access \
   --enable-hierarchical-namespace \
   --soft-delete-duration=0d \
   --location="LOCATION"
```
Sostituisci quanto segue:
- BUCKET_NAME: il nome del tuo bucket.
- LOCATION: la località del tuo bucket.
Per un elenco completo delle opzioni per la creazione di bucket, consulta le opzioni di buckets create.

Concedi ai workload l'accesso al bucket Cloud Storage

Per impostazione predefinita, GKE non ha accesso a Cloud Storage. Per leggere e scrivere i file di snapshot, devi concedere un ruolo IAM che contenga le autorizzazioni corrispondenti al service account Kubernetes (KSA) utilizzato dai pod del workload oppure concedere token di breve durata.

Concedi ruoli a service account Kubernetes specifici

Ottieni le credenziali per poter comunicare con il cluster utilizzando i comandi kubectl:
```
gcloud container clusters get-credentials "CLUSTER_NAME"
```

Per ogni pod, completa i seguenti passaggi:

Crea un KSA per ogni pod:
```
kubectl create serviceaccount "KSA_NAME" \
    --namespace "NAMESPACE"
```
Sostituisci quanto segue:
- KSA_NAME: il nome del tuo KSA.
- NAMESPACE: lo spazio dei nomi per i tuoi pod.

Concedi al KSA l'autorizzazione ad accedere al 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"

Sostituisci quanto segue:

BUCKET_NAME: il nome del tuo bucket.
PROJECT_NUMBER: il numero del tuo progetto.
PROJECT_ID: il tuo ID progetto.
NAMESPACE: lo spazio dei nomi per i tuoi pod.
KSA_NAME: il nome del tuo KSA.

Abilita la multitenancy utilizzando token di breve durata

In alternativa alla concessione delle autorizzazioni ai singoli KSA, puoi abilitare la multitenancy con token di breve durata con ambito limitato. Questo approccio consente di evitare il ritardo di propagazione associato ai binding IAM manuali. Anziché concedere le autorizzazioni a ogni KSA, esegui una concessione una tantum del ruolo roles/storage.admin sul bucket di archiviazione degli snapshot al account di servizio dei nodi GKE. Il account di servizio dei nodi crea quindi token di breve durata on demand per percorsi specifici.

L'abilitazione dei token con gli snapshot dei pod richiede GKE versione 1.35.3-gke.1737000 o successive.

Per abilitare la multitenancy, completa i seguenti passaggi:

Per concedere al account di servizio dei nodi l'autorizzazione ad accedere al bucket, esegui il seguente comando:

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"

Quando configuri l'archiviazione per gli snapshot, imposta il valore del tokenSource campo su federatedP4SA.

Concedi al controller degli snapshot dei pod l'accesso al bucket Cloud Storage

Per consentire al controller degli snapshot dei pod di eliminare gli snapshot all'interno del bucket Cloud Storage, al service agent GKE deve essere concesso il ruolo Utente oggetti Storage (roles/storage.objectUser) nel progetto. Concedi il ruolo roles/storage.objectUser eseguendo il seguente comando:

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"

Sostituisci quanto segue:

PROJECT_NUMBER: il numero del tuo progetto.
PROJECT_ID: il tuo ID progetto.
BUCKET_NAME: il nome del tuo bucket.

(Facoltativo) Crea cartelle gestite per il bucket Cloud Storage

La creazione di cartelle consente di isolare le autorizzazioni per gli snapshot da pod reciprocamente non attendibili, il che è utile nei casi d'uso multitenant. Per configurare le cartelle gestite, completa i seguenti passaggi:

Crea un ruolo IAM personalizzato che contenga solo le autorizzazioni necessarie per gli snapshot dei pod:

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

Concedi il ruolo roles/storage.bucketViewer a tutti i KSA nello spazio dei nomi di destinazione. Questo ruolo consente ai KSA di leggere i metadati dei bucket, ma non concede autorizzazioni di lettura o scrittura agli oggetti nel 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"
```
Sostituisci quanto segue:
- BUCKET_NAME: il nome del tuo bucket.
- PROJECT_NUMBER: il numero del tuo progetto.
- PROJECT_ID: il tuo ID progetto.
- NAMESPACE: lo spazio dei nomi per i tuoi pod.
Per ogni KSA che deve archiviare gli snapshot dei pod, completa i seguenti passaggi:
1. Crea una cartella gestita per il KSA:
```
gcloud storage managed-folders create "gs://BUCKET_NAME/FOLDER_PATH/"
```
  Sostituisci quanto segue:
  - BUCKET_NAME: il nome del tuo bucket.
  - FOLDER_PATH: il percorso della cartella gestita, ad esempio my-app-snapshots.
2. Concedi al KSA il ruolo personalizzato podSnapshotGcsReadWriter nella cartella gestita:
```
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"
```
  Sostituisci quanto segue:
  - BUCKET_NAME: il nome del tuo bucket.
  - FOLDER_PATH: il percorso della cartella gestita, ad esempio my-app-snapshots.
  - PROJECT_NUMBER: il numero del tuo progetto.
  - PROJECT_ID: il tuo ID progetto.
  - NAMESPACE: lo spazio dei nomi per i tuoi pod.
  - KSA_NAME: il nome del tuo KSA.
Nota: la propagazione delle policy IAM in GKE può richiedere diversi minuti.

Configura l'archiviazione per gli snapshot

Per specificare dove archiviare i file di snapshot, crea una risorsa PodSnapshotStorageConfig.

Il seguente esempio configura GKE per archiviare gli snapshot dei pod nel percorso FOLDER_PATH/ all'interno del bucket Cloud Storage BUCKET_NAME. Salva il seguente manifest come 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"
```
Sostituisci quanto segue:
- BUCKET_NAME: il nome del tuo bucket Cloud Storage.
- FOLDER_PATH: il percorso della cartella gestita di Cloud Storage.
- TOKEN_SOURCE: il provider di identità per l'accesso. Utilizza podKSA (impostazione predefinita) o federatedP4SA per la multitenancy.

Applica il manifest:

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

Passaggi successivi

Scopri come attivare uno snapshot dei pod.