Il prodotto descritto da questa documentazione, GKE su AWS, è ora in modalità di manutenzione e verrà chiuso 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 dei volumi ti consentono di creare una copia del volume in un determinato momento nel tempo. Puoi utilizzare questa copia per ripristinare lo stato precedente di un volume 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 dei volumi 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 contenga una sezione csi con driver: ebs.csi.aws.com. Se il tuo cluster esegue il provisioning dinamico dei volumi persistenti da parte del driver CSI come descritto nelle sezioni seguenti, è gestito dal driver CSI.

Prima di iniziare

Creare e utilizzare uno snapshot del volume

Gli esempi in questo documento mostrano come eseguire 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 allo snapshot o per creare un nuovo volume utilizzandolo.

Crea un esempio di `PersistentVolumeClaim` e `Pod`

Per creare l'oggetto PersistentVolumeClaim, salva il seguente manifest comeexample-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. In questo esempio viene utilizzata la classe di archiviazione standard-rwo predefinita.
Applica il manifest:
```
kubectl apply -f example-pvc.yaml
```

Crea un pod che scriva 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 uno 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 del cluster, ad esempio 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 corrispondenteVolumeSnapshotContent. Questo oggetto memorizza l'istantanea e le associazioni 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

Verifica che lo snapshot del volume sia pronto

Dopo aver creato i contenuti dello snapshot del volume, il driver CSI specificato in VolumeSnapshotClass crea uno snapshot sul sistema di archiviazione corrispondente. Dopo che il cluster ha creato uno snapshot sul sistema di archiviazione e lo ha associato a un oggetto VolumeSnapshot, lo snapshot è pronto per l'uso. Puoi controllare lo stato eseguendo il seguente 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 al VolumeSnapshot che hai creato in un nuovo PersistentVolumeClaim e crei un pod che monta il 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 lo snapshot sia stato ripristinato correttamente

Il pod creato nel passaggio precedente legge lo 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 di incorrere in costi per le risorse utilizzate in questa pagina, segui questi passaggi.

Elimina VolumeSnapshot:
```
kubectl delete volumesnapshot example-snapshot
```
Nota: se VolumeSnapshotClass di uno snapshot del volume ha deletionPolicy:Delete, vengono eliminati anche VolumeSnapshotContent e lo snapshot fisico sul sistema di archiviazione corrispondente. Se è presente un valore deletionPolicy:Retain, lo snapshot sottostante viene mantenuto.
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 relativa agli snapshot dei volumi di Kubernetes.
Installa driver CSI aggiuntivi.