Esegui il backup e ripristina lo spazio di archiviazione permanente per i tuoi cluster GKE

Questa pagina mostra come eseguire il backup e il ripristino dello spazio di archiviazione Filestore sottostante associato ai tuoi cluster GKE utilizzando gli snapshot di volume di Kubernetes.

Creare uno snapshot di volume Kubernetes è equivalente a creare un backup di Filestore.

Per ulteriori informazioni, consulta Informazioni sugli snapshot dei volumi Kubernetes.

Requisiti

Per utilizzare gli snapshot del volume su GKE, devi soddisfare i seguenti requisiti:

• Devi eseguire il deployment del driver CSI Filestore, che supporta i seguenti livelli di servizio Filestore:

  • HDD base con GKE versione 1.21 o successive
  • SSD base con GKE versione 1.21 o successive
  • A livello di zona (da 10 TiB a 100 TiB) con GKE versione 1.27 o successiva
  • Enterprise con GKE versione 1.25 o successive

• Utilizza le versions 1.17 o successive del piano di controllo. Per utilizzare il driver CSI Filestore in un VolumeSnapshot, utilizza il numero di versione GKE applicabile al livello di servizio.

• 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 se stai utilizzando 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 effettuato dinamicamente dal driver CSI, come descritto nelle sezioni seguenti, l'elemento viene gestito dal driver CSI.

Limitazioni

• I volumi di snapshot hanno le stesse limitazioni di dimensioni dei volumi normali. Ad esempio, gli snapshot di Filestore devono avere una dimensione maggiore o uguale a 1 TiB per il livello HDD di base.

• Il driver CSI Filestore non supporta il provisioning dinamico o i flussi di lavoro di backup per i seguenti livelli di servizio Filestore:

  • A livello di zona (da 1 TiB a 9,75 TiB)
  • Regionale

• Puoi eseguire il backup di una sola condivisione alla volta per istanza. Per quanto riguarda i pool di archiviazione, le richieste di backup emesse da due condivisioni diverse di due istanze Filestore diverse verranno eseguite contemporaneamente.

• I backup a condivisione singola possono essere ripristinati solo in volumi singleshare. Utilizzando il driver CSI Filestore, puoi ripristinare solo un volume singleshare in una nuova istanza Filestore.

  • La nuova istanza deve utilizzare lo stesso livello di servizio del backup.
  • La nuova istanza deve corrispondere alla stessa capacità minima del backup.

• Le operazioni backup restore di Filestore sull'origine o su un'istanza Filestore esistente non sono supportate. Per un elenco completo delle limitazioni delle funzionalità, vedi Limitazioni delle funzionalità di backup di Filestore.

• I backup multishare non sono supportati.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

• Abilita l'API Google Kubernetes Engine.
Abilita l'API Google Kubernetes Engine
• Se vuoi utilizzare Google Cloud CLI per questa attività, installa e quindi initialize 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 località predefinite, puoi evitare errori in gcloud CLI, come quelli che seguono: 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à:

1. Crea un PersistentVolumeClaim e un Deployment.
2. Aggiungi un file alla cartella PersistentVolume utilizzata da Deployment.
3. Crea un VolumeSnapshotClass per configurare lo snapshot.
4. Crea uno snapshot del volume di PersistentVolume.
5. Elimina il file di test.
6. Ripristina PersistentVolume nello 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 il criterio 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 nello snapshot o per 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:

   Filestore

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: my-pvc
    spec:
      storageClassName: enterprise-rwx
      accessModes:
      - ReadWriteMany
      resources:
        requests:
          storage: 1Ti
   

   Questo esempio crea una PVC Filestore di livello enterprise. Per maggiori informazioni, consulta Accedere alle istanze Filestore con il driver CSI Filestore.

   Per spec.storageClassName, puoi specificare qualsiasi classe di archiviazione che utilizza 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 di Deployment:

   kubectl get deployment hello-app
   

   Potrebbe essere necessario un po' di tempo prima che il Deployment sia pronto. Puoi eseguire il comando precedente fino a quando non vedi 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 del 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 a VolumeSnapshotClass oggetti quando crei VolumeSnapshot oggetti.

1. Salva il seguente manifest come volumesnapshotclass.yaml.

   Filestore

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshotClass
   metadata:
     name: my-snapshotclass
   driver: filestore.csi.storage.gke.io
   parameters:
     type: backup
   deletionPolicy: Delete
   

   In questo esempio:

   • Il campo driver viene utilizzato dal driver CSI per eseguire il provisioning dello snapshot. In questo esempio, filestore.csi.storage.gke.io utilizza il driver CSI Filestore.
   • Il campo deletionPolicy 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.

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 archivia lo snapshot e le associazioni degli oggetti VolumeSnapshot. Non interagisci direttamente con gli oggetti VolumeSnapshotContents.

3. Conferma che GKE ha 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 in VolumeSnapshotClass crea uno snapshot sul sistema di archiviazione corrispondente. Dopo che GKE ha creato uno snapshot sul sistema di archiviazione e lo associa a un oggetto VolumeSnapshot nel cluster, lo snapshot è pronto per l'uso. Puoi verificare 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
my-snapshot        true

Elimina 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

1. Salva il seguente manifest come pvc-restore.yaml:

   Filestore

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: pvc-restore
   spec:
     dataSource:
       name: my-snapshot
       kind: VolumeSnapshot
       apiGroup: snapshot.storage.k8s.io
     storageClassName: enterprise-rwx
     accessModes:
     - ReadWriteMany
     resources:
       requests:
         storage: 1Ti
   

   Nota: lo spazio dei nomi del PersistentVolumeClaim deve essere lo stesso dello spazio dei nomi di VolumeSnapshot.

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 lo snapshot sia stato ripristinato correttamente

1. Ottieni il nome del nuovo Pod creato da GKE per l'elemento 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!

Importa uno snapshot preesistente

Puoi utilizzare uno snapshot del volume esistente creato all'esterno del cluster attuale per eseguire manualmente il provisioning dell'oggetto VolumeSnapshotContents. Ad esempio, puoi compilare un volume in GKE con uno snapshot di un'altra risorsa Google Cloud creata in un cluster diverso.

1. Individua il nome dello snapshot.

   Console Google Cloud

   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. Affinché l'associazione bidirezionale sia valida, sia volumeSnapshotRef.name sia volumeSnapshotRef.namespace devono puntare al VolumeSnapshot creato in precedenza.

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshotContent
   metadata:
     name: restored-snapshot-content
   spec:
     deletionPolicy: Retain
     driver: filestore.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 di 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: enterprise-rwx
     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 che fa riferimento a PersistentVolumeClaim. Il driver CSI eseguirà il provisioning di un PersistentVolume e lo completerà 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 Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa pagina, segui questi passaggi.

1. Elimina VolumeSnapshot:

   kubectl delete volumesnapshot my-snapshot
   

   Nota: se il valore VolumeSnapshotClass di uno snapshot di volume ha deletionPolicy:Delete, vengono eliminati anche il VolumeSnapshotContent corrispondente e lo snapshot fisico sul sistema di archiviazione. Se ha un oggetto deletionPolicy:Retain, GKE conserva lo snapshot sottostante.

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 relativa allo snapshot del volume Kubernetes.
• Scopri di più sull'espansione del volume.
• Scopri come installare manualmente un driver CSI.
• Scopri di più su Filestore come opzione di archiviazione di file per GKE.