Il prodotto descritto in questa documentazione, GKE su AWS, è ora in modalità di manutenzione e verrà ritirato il 17 marzo 2027.

Questa pagina è stata tradotta dall'API Cloud Translation.

Snapshot di un oggetto PersistentVolume

Puoi utilizzare la funzionalità di snapshot dei volumi Kubernetes per volumi permanenti e provisioning dinamico nei tuoi cluster GKE.

Gli snapshot del volume ti consentono di creare una copia del volume in un momento specifico. Puoi utilizzare questa copia per riportare un volume a uno stato precedente o per eseguire il provisioning di un volume sostitutivo.

Puoi eseguire il provisioning e collegare gli snapshot dei volumi con i seguenti componenti:

Requisiti

Per utilizzare le istantanee del volume su GKE su AWS, devi disporre di quanto segue:

Un volume che utilizza un driver Container Storage Interface (CSI) che supporta gli snapshot. I driver Elastic Block Store (EBS) che GKE su AWS utilizza per impostazione predefinita supportano gli snapshot.

Per un elenco di tutti i driver CSI che supportano gli snapshot, consulta la colonna "Altre funzionalità" in Driver nella documentazione di Kubernetes.
Avere un PersistentVolumeClaim esistente da utilizzare per uno snapshot. Il PersistentVolume che utilizzi per un'origine snapshot deve essere gestito da un driver CSI. Puoi verificare di utilizzare un driver CSI controllando che la specifica PersistentVolume abbia una sezione csi con driver: ebs.csi.aws.com . Se il tuo cluster esegue il provisioning dinamico di PersistentVolumes tramite il driver CSI come descritto nelle sezioni seguenti, viene gestito dal driver CSI.

Prima di iniziare

Creare e utilizzare uno snapshot del volume

Gli esempi riportati in questo documento mostrano come svolgere le seguenti attività:

Crea un esempio di PersistentVolumeClaim e Pod.
Crea un VolumeSnapshot.
Ripristina lo snapshot del volume.
Verifica che il ripristino abbia funzionato.

Per utilizzare uno snapshot del volume, devi completare i seguenti passaggi:

Crea un oggetto VolumeSnapshot per richiedere uno snapshot di un PersistentVolumeClaim esistente.
Fai riferimento a VolumeSnapshot in un PersistentVolumeClaim per ripristinare un volume in quello snapshot o creare un nuovo volume utilizzando lo snapshot.

Crea un esempio di `PersistentVolumeClaim` e `Pod`

Per creare l'oggetto PersistentVolumeClaim, salva il seguente manifest come example-pvc.yaml:
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: example-pvc
spec:
  storageClassName: standard-rwo
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
```
Per spec.storageClassName, puoi specificare qualsiasi classe di archiviazione che utilizzi un driver CSI supportato. Questo esempio utilizza la classe di archiviazione standard-rwo predefinita.
Applica il manifest:
```
kubectl apply -f example-pvc.yaml
```

Crea un pod che scrive la data e l'ora correnti nel volume. Per creare un pod, salva il seguente manifest come snapshot-shell.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: snapshot-shell
spec:
  terminationGracePeriodSeconds: 10
  containers:
  - name: linux
    image: ubuntu:bionic
    command: ["/bin/sh"]
    args: ["-c", "echo $(date -u) >> /data/out.txt"]
    volumeMounts:
    - name: snapshot-volume
      mountPath: /data
  restartPolicy: Never
  volumes:
  - name: snapshot-volume
    persistentVolumeClaim:
      claimName: example-pvc

Applica il manifest:
```
kubectl apply -f snapshot-shell.yaml
```
Controlla lo stato del pod:
```
kubectl get pod snapshot-shell
```
L'esecuzione e il completamento del pod potrebbero richiedere del tempo. Puoi eseguire il comando precedente finché non visualizzi un output simile al seguente:
```
NAME             READY   STATUS      RESTARTS   AGE
snapshot-shell   0/1     Completed   0          24s
```

Crea un VolumeSnapshot

Un oggetto VolumeSnapshot è una richiesta di snapshot di un oggetto PersistentVolumeClaim esistente. Quando crei un oggetto VolumeSnapshot, il cluster lo crea e lo associa automaticamente a un oggetto VolumeSnapshotContent, che è una risorsa nel cluster come un oggetto PersistentVolume.

Salva il seguente manifest come volumesnapshot.yaml.

apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshot
metadata:
  name: example-snapshot
spec:
  source:
    persistentVolumeClaimName: example-pvc

Applica il manifest:
```
kubectl apply -f volumesnapshot.yaml
```
Dopo aver creato uno snapshot del volume, il cluster crea un oggetto VolumeSnapshotContent corrispondente. Questo oggetto archivia lo snapshot e i binding degli oggetti VolumeSnapshot. Non interagisci direttamente con gli oggetti VolumeSnapshotContents.

Verifica che il cluster abbia creato l'oggetto VolumeSnapshotContents:

kubectl get volumesnapshotcontents

L'output è simile al seguente:

NAME                                               AGE
snapcontent-cee5fb1f-5427-11ea-a53c-42010a1000da   55s

Conferma che lo snapshot del volume sia pronto

Una volta creato il contenuto dello snapshot del volume, il driver CSI specificato in VolumeSnapshotClass crea uno snapshot sul sistema di archiviazione corrispondente. Dopo che il cluster crea uno snapshot sul sistema di archiviazione e lo associa a un oggetto VolumeSnapshot, lo snapshot è pronto per l'uso. Puoi controllare lo stato eseguendo questo comando:

kubectl get volumesnapshot \
  -o custom-columns='NAME:.metadata.name,READY:.status.readyToUse'

Se lo snapshot è pronto per l'uso, l'output è simile al seguente:

NAME                    READY
example-snapshot        true

Ripristina lo snapshot del volume

Puoi fare riferimento a un VolumeSnapshot in un PersistentVolumeClaim per eseguire il provisioning di un nuovo volume con i dati di un volume esistente o ripristinare un volume a uno stato acquisito nello snapshot.

Per fare riferimento a un VolumeSnapshot in un PersistentVolumeClaim, aggiungi il campo dataSource al PersistentVolumeClaim.

In questo esempio, fai riferimento a VolumeSnapshot che hai creato in un nuovo PersistentVolumeClaim e crei un pod che monta PersistentVolumeClaim.

Salva il seguente manifest come pvc-restore.yaml:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
 name: pvc-restore
spec:
 dataSource:
   name: example-snapshot
   kind: VolumeSnapshot
   apiGroup: snapshot.storage.k8s.io
 storageClassName: standard-rwo
 accessModes:
   - ReadWriteOnce
 resources:
   requests:
     storage: 1Gi

Applica il manifest:
```
kubectl apply -f pvc-restore.yaml
```

Avvia un pod temporaneo che monta la PVC sul pod e stampa i contenuti di out.txt nei log.

Salva il seguente manifest come restore-log.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: restore-verify
spec:
  volumes:
    - name: restore-data
      persistentVolumeClaim:
        claimName: pvc-restore
  containers:
    - name: shell-container
      image: ubuntu:bionic
      volumeMounts:
        - mountPath: "/data"
          name: restore-data
      command: [ "/bin/sh" ]
      args: ["-c", "cat /data/out.txt", "exit", "1"]
  restartPolicy: Never

Applica il manifest:
```
kubectl apply -f restore-log.yaml
```

Verifica che il ripristino dello snapshot sia andato a buon fine

Il pod creato nel passaggio precedente legge dallo snapshot. Per visualizzare i dati dello snapshot, utilizza il comando kubectl logs.

kubectl logs restore-verify

L'output deve includere un timestamp dello snapshot.

Esegui la pulizia

Per evitare che ti vengano addebitati costi per le risorse utilizzate in questa pagina, segui questi passaggi.

Elimina il VolumeSnapshot:
```
kubectl delete volumesnapshot example-snapshot
```
Nota: se il VolumeSnapshotClass di uno snapshot del volume ha deletionPolicy:Delete, vengono eliminati anche il VolumeSnapshotContent corrispondente e lo snapshot fisico sul sistema di archiviazione. Se ha un deletionPolicy:Retain, lo snapshot sottostante viene conservato.
Elimina il pod temporaneo:
```
kubectl delete -f restore-log.yaml
```
Elimina il pod:
```
kubectl delete -f snapshot-shell.yaml
```

Elimina gli oggetti PersistentVolumeClaim:

kubectl delete pvc example-pvc pvc-restore

Passaggi successivi

Leggi la documentazione Volume Snapshot di Kubernetes.
Installa driver CSI aggiuntivi.