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

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

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

Requisiti

Per utilizzare le istantanee del volume su GKE, devi soddisfare i seguenti requisiti:

• Utilizza un driver CSI che supporti 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, utilizza il driver CSI per il disco permanente di Compute Engine. Il driver CSI del disco permanente di Compute Engine è installato per impostazione predefinita sui nuovi cluster Linux che eseguono GKE versione 1.18.10-gke.2100 o successive oppure versione 1.19.3-gke.2100 o successive. Puoi anche abilitare il driver CSI per il disco permanente di Compute Engine su 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 le versioni del control plane 1.17 o successive. Per utilizzare il driver CSI del disco permanente di Compute Engine in un VolumeSnapshot, utilizza GKE versione 1.17.6-gke.4 o successive.

• 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: pd.csi.storage.gke.io o filestore.csi.storage.gke.io. Se PersistentVolume viene provisionato dinamicamente dal driver CSI come descritto nelle sezioni seguenti, viene 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 Volume Persistent Disk 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à, installala e poi inizializzala. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo gcloud components update.

Creazione e utilizzo di uno snapshot del volume

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

1. Crea un PersistentVolumeClaim e un Deployment.
2. Aggiungi un file al PersistentVolume utilizzato da Deployment.
3. Crea un VolumeSnapshotClass per configurare lo snapshot.
4. Crea uno snapshot del volume PersistentVolume.
5. Elimina il file di test.
6. Ripristina PersistentVolume allo snapshot che hai creato.
7. Verifica che il ripristino abbia funzionato.

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

1. Crea un oggetto VolumeSnapshotClass per specificare il driver CSI e la norma di eliminazione per lo snapshot.
2. Crea un oggetto VolumeSnapshot per richiedere uno snapshot di un PersistentVolumeClaim esistente.
3. Fai riferimento a VolumeSnapshot in un PersistentVolumeClaim per ripristinare un volume a quello snapshot o creare un nuovo volume utilizzando lo snapshot.

Crea un PersistentVolumeClaim e un Deployment

1. Per creare l'oggetto PersistentVolumeClaim, salva il seguente manifest come my-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.

2. Applica il manifest:

   kubectl apply -f my-pvc.yaml
   

3. 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
   

4. Applica il manifest:

   kubectl apply -f my-deployment.yaml
   

5. Controlla lo stato del Deployment:

   kubectl get deployment hello-app
   

   Potrebbe essere necessario un po' di tempo prima che Deployment sia pronto. Puoi eseguire il comando precedente finché non visualizzi 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

1. Elenca Pods in 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
   

2. 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 di Pod.

3. 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 VolumeSnapshot.

1. Salva il seguente manifest come volumesnapshotclass.yaml.

   Persistent Disk

   Utilizza la versione dell'API v1 per i cluster che eseguono la versione 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'oggetto VolumeSnapshotContent e lo snapshot sottostante quando l'oggetto VolumeSnapshot associato viene eliminato. 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 snapshot. Per utilizzare questo parametro, i 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.

2. Applica il manifest:

   kubectl apply -f volumesnapshotclass.yaml
   

Crea un VolumeSnapshot

Un oggetto VolumeSnapshot è una richiesta di 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 nel tuo cluster come un oggetto PersistentVolume.

1. 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
   

2. 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 i binding degli oggetti VolumeSnapshot. Non interagisci direttamente con gli oggetti VolumeSnapshotContents.

3. 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
   

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

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

Eliminare il file di test

1. Elimina il file di test che hai creato:

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

2. 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
   

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

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

1. Verifica se stai utilizzando uno snapshot del disco o dell'immagine, che differiscono come segue:

   • Snapshot dei dischi: acquisisci snapshot di frequente e ripristina raramente.
   • Snapshot delle immagini: acquisisci snapshot di rado e ripristinali di frequente. Anche la creazione di snapshot delle immagini potrebbe essere più lenta rispetto a quella degli snapshot dei dischi.

   Per maggiori dettagli, vedi Limiti di frequenza degli snapshot. Conoscere il tipo di snapshot è utile se devi risolvere eventuali problemi.

   Ispeziona il VolumeSnapshot:

   kubectl describe volumesnapshot SNAPSHOT_NAME
   

   Il campo volumeSnapshotClassName specifica la classe dello snapshot.

   kubectl describe volumesnapshotclass SNAPSHOT_CLASS_NAME
   

   Il parametro snapshot-type specifica snapshots o images. Se non viene specificato, il valore predefinito è snapshots.

   Se non è presente una classe di snapshot (ad esempio, se lo snapshot è stato creato staticamente), ispeziona VolumeSnapshotContents. sh kubectl describe volumesnapshotcontents SNAPSHOT_CONTENTS_NAME Il formato di un handle di 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: snapshot dell'immagine

1. 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
   

2. Applica il manifest:

   kubectl apply -f pvc-restore.yaml
   

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

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

4. Applica il manifest aggiornato:

   kubectl apply -f my-deployment.yaml
   

Verifica che il ripristino dello snapshot sia andato a buon fine

1. Recupera il nome del nuovo Pod creato da GKE per l'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 che GKE ha creato.

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 popolare un volume in GKE con uno snapshot di un'altra risorsaTrusted Cloud creata in un cluster diverso.

1. Individua il nome dello snapshot.

   Trusted Cloud console

   Vai a 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
   

2. 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
   

3. Applica il manifest:

   kubectl apply -f restored-snapshot.yaml
   

4. Salva il seguente manifest VolumeSnapshotContent come restored-snapshot-content.yaml. Sostituisci il campo snapshotHandle con l'ID progetto e il nome dello snapshot. Sia volumeSnapshotRef.name che volumeSnapshotRef.namespace devono puntare a VolumeSnapshot creato in precedenza affinché il binding 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
   

5. Applica il manifest:

   kubectl apply -f restored-snapshot-content.yaml
   

6. Salva il seguente manifest PersistentVolumeClaim come restored-pvc.yaml. Il controller 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
   

7. Applica il manifest:

   kubectl apply -f restored-pvc.yaml
   

8. Salva il seguente manifest Pod come restored-pod.yaml facendo riferimento a PersistentVolumeClaim. Il driver CSI eseguirà il provisioning di un PersistentVolume e lo compilerà dallo snapshot.

   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
   

9. Applica il manifest:

   kubectl apply -f restored-pod.yaml
   

10. 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 Trusted Cloud by S3NS vengano addebitati costi relativi alle risorse utilizzate in questa pagina, segui questi passaggi.

1. Elimina VolumeSnapshot:

   kubectl delete volumesnapshot my-snapshot
   

2. Elimina VolumeSnapshotClass:

   kubectl delete volumesnapshotclass my-snapshotclass
   

3. Elimina Deployment:

   kubectl delete deployments hello-app
   

4. Elimina gli oggetti PersistentVolumeClaim:

   kubectl delete pvc my-pvc pvc-restore
   

Passaggi successivi

• Leggi la documentazione sullo snapshot del volume 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.