Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui il backup dell'archiviazione su Persistent Disk utilizzando gli snapshot dei volumi

Autopilot Standard

Questa pagina mostra come eseguire il backup e il ripristino dello spazio di archiviazione Persistent Disk utilizzando gli snapshot dei volumi.

Per un'introduzione, consulta Informazioni sugli snapshot dei volumi Kubernetes.

Requisiti

Per utilizzare le istantanee dei volumi su GKE, devi soddisfare i seguenti requisiti:

Utilizza un driver CSI che supporta gli snapshot. Il driver Persistent Disk in-tree non supporta gli snapshot. Per creare e gestire gli snapshot, devi utilizzare lo stesso driver CSI del PersistentVolumeClaim (PVC) sottostante.
- Per gli snapshot dei volumi del disco permanente (DP), utilizza il driver CSI per il disco permanente di Compute Engine. Il driver CSI del disco permanente di Compute Engine viene installato per impostazione predefinita sui nuovi cluster Linux che eseguono GKE nella versione 1.18.10-gke.2100 o successive o nella versione 1.19.3-gke.2100 o successive. Puoi anche abilitare il driver CSI per il disco permanente di Compute Engine in un cluster esistente.
- Per un elenco di tutti i driver CSI che supportano gli snapshot, consulta la colonna Altre funzionalità in Driver nella documentazione di Kubernetes.
Utilizza il control plane versioni 1.17 o successive. Per utilizzare il driver CSI del disco permanente di Compute Engine in un VolumeSnapshot, utilizza le versioni GKE 1.17.6-gke.4 o successive.

Avere un PersistentVolumeClaim esistente da utilizzare per uno snapshot. Il PersistentVolume utilizzato 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: pd.csi.storage.gke.io o filestore.csi.storage.gke.io. Se il PersistentVolume è sottoposto a provisioning dinamico dal driver CSI come descritto nelle sezioni seguenti, è gestito dal driver CSI.

Limitazioni

Tutte le limitazioni per la creazione di uno snapshot del disco su Compute Engine si applicano anche a GKE.

Best practice

Assicurati di seguire le best practice per gli snapshot dei dischi Compute Engine quando utilizzi gli snapshot dei Persistent Disk Volume su GKE.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:

Attiva l'API Google Kubernetes Engine.

Attiva l'API Google Kubernetes Engine

Se vuoi utilizzare Google Cloud CLI per questa attività, installa e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, ottieni la versione più recente eseguendo gcloud components update.
Nota: per le installazioni esistenti di gcloud CLI, assicurati di impostare le proprietà compute/region e compute/zone. Se imposti le posizioni predefinite, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location.

Creazione e utilizzo di uno snapshot del volume

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

Crea un PersistentVolumeClaim e un Deployment.
Aggiungi un file al PersistentVolume utilizzato dal Deployment.
Crea un VolumeSnapshotClass per configurare lo snapshot.
Crea uno snapshot del volume di PersistentVolume.
Elimina il file di test.
Ripristina PersistentVolume nello snapshot che hai creato.
Verifica che il ripristino abbia funzionato.

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

Crea un oggetto VolumeSnapshotClass per specificare il driver CSI e il criterio di eliminazione per lo snapshot.
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 utilizzandolo.

Crea un `PersistentVolumeClaim` e un `Deployment`

Per creare l'oggetto PersistentVolumeClaim, salva il seguente manifest comemy-pvc.yaml:
Persistent Disk
```
 apiVersion: v1
 kind: PersistentVolumeClaim
 metadata:
   name: my-pvc
 spec:
   storageClassName: standard-rwo
   accessModes:
   - ReadWriteOnce
   resources:
     requests:
       storage: 1Gi
```
Questo esempio utilizza la classe di archiviazione standard-rwo installata per impostazione predefinita con il driver CSI per il disco permanente di Compute Engine. Per saperne di più, consulta Utilizzo del driver CSI per il disco permanente di Compute Engine.
Per spec.storageClassName, puoi specificare qualsiasi classe di archiviazione che utilizzi un driver CSI supportato.
Applica il manifest:
```
kubectl apply -f my-pvc.yaml
```

Per creare un Deployment, salva il seguente manifest come my-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-app
spec:
  selector:
    matchLabels:
      app: hello-app
  template:
    metadata:
      labels:
        app: hello-app
    spec:
      containers:
      - name: hello-app
        image: google/cloud-sdk:slim
        args: [ "sleep", "3600" ]
        volumeMounts:
        - name: sdk-volume
          mountPath: /usr/share/hello/
      volumes:
      - name: sdk-volume
        persistentVolumeClaim:
          claimName: my-pvc

Applica il manifest:
```
kubectl apply -f my-deployment.yaml
```
Controlla lo stato del Deployment:
```
kubectl get deployment hello-app
```
Potrebbe essere necessario del tempo prima che Deployment sia pronto. Puoi eseguire il comando precedente finché non viene visualizzato un output simile al seguente:
```
NAME        READY   UP-TO-DATE   AVAILABLE   AGE
hello-app   1/1     1            1           2m55s
```

Aggiungi un file di test al volume

Elenca i Pods nel Deployment:

kubectl get pods -l app=hello-app

L'output è simile al seguente:

NAME                         READY   STATUS    RESTARTS   AGE
hello-app-6d7b457c7d-vl4jr   1/1     Running   0          2m56s

Crea un file di test in un Pod:

kubectl exec POD_NAME \
    -- sh -c 'echo "Hello World!" > /usr/share/hello/hello.txt'

Sostituisci POD_NAME con il nome del Pod.

Verifica che il file esista:

kubectl exec POD_NAME \
    -- sh -c 'cat /usr/share/hello/hello.txt'

L'output è simile al seguente:

Hello World!

Crea un oggetto `VolumeSnapshotClass`

Crea un oggetto VolumeSnapshotClass per specificare il driver CSI e deletionPolicy per lo snapshot del volume. Puoi fare riferimento agli oggetti VolumeSnapshotClass quando crei oggetti VolumeSnapshotClass.VolumeSnapshot

Salva il seguente manifest come volumesnapshotclass.yaml.
Persistent Disk
Utilizza la versione dell'API v1 per i cluster che eseguono le versioni 1.21 o successive.
```
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: my-snapshotclass
driver: pd.csi.storage.gke.io
deletionPolicy: Delete
```
In questo esempio:
- Il campo driver viene utilizzato dal driver CSI per eseguire il provisioning dello snapshot. In questo esempio, pd.csi.storage.gke.io utilizza il driver CSI per il disco permanente di Compute Engine.
- Il campodeletionPolicy indica a GKE cosa fare con l'oggettoVolumeSnapshotContent e con lo snapshot sottostante quando viene eliminato l'oggettoVolumeSnapshot vincolato. Specifica Delete per eliminare l'oggetto VolumeSnapshotContent e lo snapshot sottostante. Specifica Retain se vuoi conservare VolumeSnapshotContent e lo snapshot sottostante.
  
  Per utilizzare una posizione di archiviazione personalizzata, aggiungi un parametro storage-locations alla classe di snapshot. Per utilizzare questo parametro, i tuoi cluster devono utilizzare la versione 1.21 o successive.
  apiVersion: snapshot.storage.k8s.io/v1 kind: VolumeSnapshotClass metadata: name: my-snapshotclass parameters: storage-locations: us-east2 driver: pd.csi.storage.gke.io deletionPolicy: Delete
- Per creare un'immagine disco, aggiungi quanto segue al campo parameters:
  parameters: snapshot-type: images image-family: IMAGE_FAMILY
  Sostituisci IMAGE_FAMILY con il nome della famiglia di immagini che preferisci, ad esempio preloaded-data.

Applica il manifest:

kubectl apply -f volumesnapshotclass.yaml

Crea un `VolumeSnapshot`

Un oggetto VolumeSnapshot è una richiesta di uno snapshot di un oggetto PersistentVolumeClaim esistente. Quando crei un oggetto VolumeSnapshot, GKE 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: my-snapshot
spec:
  volumeSnapshotClassName: my-snapshotclass
  source:
    persistentVolumeClaimName: my-pvc

Applica il manifest:
```
kubectl apply -f volumesnapshot.yaml
```
Dopo aver creato uno snapshot Volume, GKE crea un oggetto VolumeSnapshotContent corrispondente nel cluster. Questo oggetto memorizza lo snapshot e le associazioni degli oggetti VolumeSnapshot. Non interagisci direttamente con gli oggetti VolumeSnapshotContents.

Verifica che GKE abbia creato l'oggetto VolumeSnapshotContents:

kubectl get volumesnapshotcontents

L'output è simile al seguente:

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

Dopo aver creato i contenuti dello snapshot Volume, il driver CSI specificato nel VolumeSnapshotClass crea uno snapshot sul sistema di archiviazione corrispondente. Dopo che GKE ha creato uno snapshot sul sistema di archiviazione e lo ha associato a un oggetto VolumeSnapshot nel cluster, lo snapshot è pronto per essere utilizzato. Per controllare lo stato, esegui 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
my-snapshot        true

Elimina il file di test

Elimina il file di test che hai creato:

kubectl exec POD_NAME \
    -- sh -c 'rm /usr/share/hello/hello.txt'

Verifica che il file non esista più:

kubectl exec POD_NAME \
    -- sh -c 'cat /usr/share/hello/hello.txt'

L'output è simile al seguente:

cat: /usr/share/hello/hello.txt: No such file or directory

Ripristinare 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. Viene utilizzato lo stesso processo indipendentemente dal fatto che VolumeSnapshotContents si riferisca a un'immagine disco o a uno snapshot.

In questo esempio, fai riferimento al VolumeSnapshot che hai creato in un nuovo PersistentVolumeClaim e aggiorna il Deployment per utilizzare la nuova rivendicazione.

Verifica se utilizzi uno snapshot di un disco o di un'immagine, che differiscono come segue:
- Snapshot dei dischi: acquisisci snapshot di frequente e ripristina di rado.
- Snapshot delle immagini: acquisisci snapshot di rado e ripristina di frequente. La creazione degli snapshot delle immagini può anche essere più lenta rispetto a quella degli snapshot dei dischi.
Per maggiori dettagli, consulta Limiti di frequenza degli snapshot. Conoscere il tipo di istantanea è utile per risolvere eventuali problemi.

Controlla il VolumeSnapshot:
```
kubectl describe volumesnapshot SNAPSHOT_NAME
```
Il campo volumeSnapshotClassName specifica la classe di istantanea.
```
kubectl describe volumesnapshotclass SNAPSHOT_CLASS_NAME
```
Il parametro snapshot-type specifica snapshots o images. Se non viene fornito, il valore predefinito è snapshots.

Se non esiste una classe di snapshot (ad esempio, se lo snapshot è stato creato in modo statico), esamina VolumeSnapshotContents. sh kubectl describe volumesnapshotcontents SNAPSHOT_CONTENTS_NAME Il formato di un handle dello snapshot nell'output indica il tipo di snapshot, come segue: * projects/PROJECT_NAME/global/snapshots/SNAPSHOT_NAME: snapshot del disco
- projects/PROJECT_NAME/global/images/IMAGE_NAME: istantanea dell'immagine

Salva il seguente manifest come pvc-restore.yaml:

Persistent Disk

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-restore
spec:
  dataSource:
    name: my-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
```

Aggiorna il file my-deployment.yaml per utilizzare il nuovo PersistentVolumeClaim:

...
volumes:
- name: my-volume
  persistentVolumeClaim:
    claimName: pvc-restore

Applica il manifest aggiornato:
```
kubectl apply -f my-deployment.yaml
```

Verifica che lo snapshot sia stato ripristinato correttamente

Ottieni il nome del nuovo Pod creato da GKE per il Deployment aggiornato:
```
 kubectl get pods -l app=hello-app
```

Verifica che il file di test esista:

   kubectl exec NEW_POD_NAME \
       -- sh -c 'cat /usr/share/hello/hello.txt'

Sostituisci NEW_POD_NAME con il nome del nuovo Pod creato da GKE.

L'output è simile al seguente:

   Hello World!

Importare uno snapshot preesistente

Puoi utilizzare uno snapshot del volume esistente creato al di fuori del cluster corrente per eseguire il provisioning manuale dell'oggetto VolumeSnapshotContents. Ad esempio, puoi compilare un volume in GKE con uno snapshot di un'altra risorsa Google Cloud creata in un altro cluster.

Individua il nome dello snapshot.

Console Google Cloud

Vai alla pagina https://console.cloud.google.com/compute/snapshots.

Google Cloud CLI

Esegui questo comando:

gcloud compute snapshots list

L'output è simile al seguente:

NAME                                           DISK_SIZE_GB  SRC_DISK                                                     STATUS
snapshot-5e6af474-cbcc-49ed-b53f-32262959a0a0  1             us-central1-b/disks/pvc-69f80fca-bb06-4519-9e7d-b26f45c1f4aa READY

Salva il seguente manifest VolumeSnapshot come restored-snapshot.yaml.

apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshot
metadata:
  name: restored-snapshot
spec:
  volumeSnapshotClassName: my-snapshotclass
  source:
    volumeSnapshotContentName: restored-snapshot-content

Applica il manifest:

kubectl apply -f restored-snapshot.yaml

Salva il seguente manifest VolumeSnapshotContent come restored-snapshot-content.yaml. Sostituisci il campo snapshotHandle con il tuo ID progetto e il nome dello snapshot. Sia volumeSnapshotRef.name sia volumeSnapshotRef.namespace devono puntare al valore VolumeSnapshot creato in precedenza affinché il vincolo bidirezionale sia valido.

apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotContent
metadata:
  name: restored-snapshot-content
spec:
  deletionPolicy: Retain
  driver: pd.csi.storage.gke.io
  source:
    snapshotHandle: projects/PROJECT_ID/global/snapshots/SNAPSHOT_NAME
  volumeSnapshotRef:
    kind: VolumeSnapshot
    name: restored-snapshot
    namespace: default

Applica il manifest:

kubectl apply -f restored-snapshot-content.yaml

Salva il seguente manifest PersistentVolumeClaim come restored-pvc.yaml. Il controller dello spazio di archiviazione Kubernetes troverà un VolumeSnapshot denominato restored-snapshot e poi tenterà di trovare o creare dinamicamente un PersistentVolume come origine dati. Puoi quindi utilizzare questa PVC in un pod per accedere ai dati ripristinati.

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

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

Salva il seguente manifest Pod come restored-pod.yaml facendo riferimento a PersistentVolumeClaim. Il driver CSI eseguirà il provisioning di un PersistentVolume e lo completerà dall'istantanea.

apiVersion: v1
kind: Pod
metadata:
  name: restored-pod
spec:
  containers:
  - name: busybox
    image: busybox
    args:
    - sleep
    - "3600"
    volumeMounts:
    - name: source-data
      mountPath: /demo/data
  volumes:
  - name: source-data
    persistentVolumeClaim:
      claimName: restored-pvc
      readOnly: false

Applica il manifest:
```
kubectl apply -f restored-pod.yaml
```

Verifica che il file sia stato ripristinato:

kubectl exec restored-pod -- sh -c 'cat /demo/data/hello.txt'

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate su questa pagina, segui questi passaggi.

Elimina VolumeSnapshot:
```
kubectl delete volumesnapshot my-snapshot
```
Nota: se VolumeSnapshotClass di uno snapshot del volume contiene deletionPolicy:Delete, vengono eliminati anche VolumeSnapshotContent e lo snapshot fisico sul sistema di archiviazione corrispondente. Se è presente un valore deletionPolicy:Retain, GKE conserva lo snapshot sottostante.

Elimina VolumeSnapshotClass:

kubectl delete volumesnapshotclass my-snapshotclass

Elimina Deployment:
```
kubectl delete deployments hello-app
```
Elimina gli oggetti PersistentVolumeClaim:
```
kubectl delete pvc my-pvc pvc-restore
```

Passaggi successivi

Leggi la documentazione relativa agli snapshot dei volumi Kubernetes.
Scopri di più sull'espansione del volume.
Scopri come installare manualmente un driver CSI.
Scopri di più sull'archiviazione a blocchi (Persistent Disk) per GKE.

Esegui il backup dell'archiviazione su Persistent Disk utilizzando gli snapshot dei volumi

Requisiti

Limitazioni

Best practice

Prima di iniziare

Creazione e utilizzo di uno snapshot del volume

Crea un PersistentVolumeClaim e un Deployment

Persistent Disk

Aggiungi un file di test al volume

Crea un oggetto VolumeSnapshotClass

Persistent Disk

Crea un VolumeSnapshot

Elimina il file di test

Ripristinare lo snapshot del volume

Persistent Disk

Verifica che lo snapshot sia stato ripristinato correttamente

Importare uno snapshot preesistente

Console Google Cloud

Google Cloud CLI

Esegui la pulizia

Passaggi successivi

Crea un `PersistentVolumeClaim` e un `Deployment`

Crea un oggetto `VolumeSnapshotClass`

Crea un `VolumeSnapshot`