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

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Snapshot di un oggetto PersistentVolume

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

Gli snapshot dei volumi 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 gli snapshot dei volumi in GKE su Azure, devi disporre di quanto segue:

Un volume che utilizza un driver Container Storage Interface (CSI) che supporta gli snapshot. I driver Azure Disk e Azure File utilizzati per impostazione predefinita da GKE su Azure supportano gli snapshot.

Nota: il driver CSI di Azure File non supporta il ripristino da uno snapshot. Per saperne di più, consulta la panoramica degli snapshot delle condivisioni per File di Azure.

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. L'oggetto PersistentVolume che utilizzi per un'origine snapshot deve essere gestito da un driver CSI. Puoi verificare di utilizzare un driver CSI controllando che la PersistentVolume specifica abbia una sezione csi con driver: disk.csi.azure.com o file.csi.azure.com. Se il cluster esegue il provisioning dinamico di PersistentVolume dal driver CSI come descritto nelle sezioni seguenti, viene gestito da il 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 oggetto PersistentVolumeClaim e un Pod di esempio.
Crea un oggetto VolumeSnapshot.
Ripristina lo snapshot del volume.
Verifica che il ripristino sia andato a buon fine.

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

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

Creare un oggetto `PersistentVolumeClaim` e un `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. Questo esempio utilizza 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
```

Creare un oggetto 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 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

Verificare che lo snapshot del volume sia pronto

Dopo aver 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 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

Ripristinare lo snapshot del volume

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

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

In questo esempio, fai riferimento all'oggetto VolumeSnapshot che hai creato in un nuovo oggetto PersistentVolumeClaim e crei un pod che monta l'oggetto 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
```

Verificare che lo snapshot sia stato ripristinato correttamente

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 dovrebbe includere un timestamp dello snapshot.

Libera spazio

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

Elimina l'oggetto VolumeSnapshot:
```
kubectl delete volumesnapshot example-snapshot
```
Nota: se l'oggetto VolumeSnapshotClass di uno snapshot del volume ha deletionPolicy:Delete, vengono eliminati anche l'oggetto VolumeSnapshotContent corrispondente e lo snapshot fisico sul sistema di archiviazione. Se ha un oggetto 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 di Kubernetes Volume Snapshot.
Installa driver CSI aggiuntivi.