Questa documentazione si riferisce alla versione attuale di GKE su AWS, rilasciata a novembre 2021. Consulta le Note di rilascio per ulteriori informazioni.

Snapshot di un oggetto PersistentVolume

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

Gli snapshot dei volumi consentono di creare una copia del volume in un momento specifico. 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 snapshot di volumi con i seguenti componenti:

Requisiti

Per utilizzare gli snapshot di volumi su GKE su AWS, devi avere quanto segue:

Un volume che utilizza un driver Container Storage Interface (CSI) che supporta gli snapshot. I driver Elastic Block Store (EBS) utilizzati da GKE su AWS 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 oggetto PersistentVolumeClaim esistente da utilizzare per uno snapshot. Il valore PersistentVolume che utilizzi per un'origine snapshot deve essere gestito da un driver CSI. Puoi verificare se stai utilizzando un driver CSI controllando che la specifica PersistentVolume abbia una sezione csi con driver: ebs.csi.aws.com. Se il cluster esegue il provisioning dinamico di oggetti PersistentVolume dal driver CSI, come descritto nelle sezioni seguenti, viene gestito dal driver CSI.

Prima di iniziare

Crea e utilizza uno snapshot del volume

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

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 al VolumeSnapshot in un PersistentVolumeClaim per ripristinare un volume in quello snapshot o crearne uno nuovo utilizzando lo snapshot.

Crea `PersistentVolumeClaim` e `Pod` di esempio

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 utilizza 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 potrebbe richiedere del tempo. Puoi eseguire il comando precedente finché non vedi un output simile al seguente:
```
NAME             READY   STATUS      RESTARTS   AGE
snapshot-shell   0/1     Completed   0          24s
```

Creazione di 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 le associazioni di VolumeSnapshot oggetti. 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 nel 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 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 una PersistentVolumeClaim per eseguire il provisioning di un nuovo volume con i dati di un volume esistente o ripristinare uno stato acquisito nello snapshot.

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

In questo esempio, farai riferimento all'oggetto VolumeSnapshot che hai creato in una nuova PersistentVolumeClaim e creerai un pod che monta l' 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 nel 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 venga ripristinato

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 dell'istantanea.

Esegui la pulizia

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

Elimina VolumeSnapshot:
```
kubectl delete volumesnapshot example-snapshot
```
Nota: se VolumeSnapshotClass di uno snapshot di volume contiene deletionPolicy:Delete, vengono eliminati anche il valore 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 PersistentVolumeClaim oggetto:

kubectl delete pvc example-pvc pvc-restore

Passaggi successivi

Leggi la documentazione di Kubernetes Istantanea volume.
Installa i driver CSI aggiuntivi.