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

Questa pagina mostra come eseguire il backup e ripristinare lo spazio di archiviazione su Persistent Disk utilizzando snapshot di volumi.

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

Requisiti

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

  • Avere un PersistentVolumeClaim esistente da utilizzare per uno snapshot. La PersistentVolume che utilizzi per un'origine snapshot deve essere gestito da un CSI conducente. Puoi verificare di utilizzare un driver CSI controllando che il parametro La specifica PersistentVolume ha una sezione csi con driver: pd.csi.storage.gke.io o filestore.csi.storage.gke.io. Se PersistentVolume è provisioning dinamico dal driver CSI, come descritto nelle sezioni seguenti, è gestito il driver CSI.

Limitazioni

Tutte le restrizioni 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 di Compute Engine. quando si utilizzano snapshot di Persistent Disk Volume su GKE.

Prima di iniziare

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

  • Attiva l'API Google Kubernetes Engine.
    • Abilita l'API Google Kubernetes Engine
  • Se vuoi utilizzare Google Cloud CLI per questa attività, install e poi inizializzare con gcloud CLI. Se hai già installato gcloud CLI, scarica la versione più recente eseguendo gcloud components update.

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 l'eliminazione criterio per lo snapshot.
  2. Crea un oggetto VolumeSnapshot per richiedere uno snapshot di un oggetto esistente PersistentVolumeClaim.
  3. Fai riferimento a VolumeSnapshot in un PersistentVolumeClaim per ripristinare un 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:

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

  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 VolumeSnapshotClass oggetti quando crei VolumeSnapshot oggetti.

  1. Salva il seguente manifest come volumesnapshotclass.yaml.

    Persistent Disk

    Utilizza la versione 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 la classe Driver CSI per il disco permanente di Compute Engine.

    • Il campo deletionPolicy indica a GKE cosa fare con VolumeSnapshotContent e lo snapshot sottostante quando viene applicato L'oggetto VolumeSnapshot è stato eliminato. Specifica Delete per eliminare 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, nei cluster deve essere usata la versione 1.21 o successiva.

      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 del disco, aggiungi nel campo parameters:

      parameters:
  snapshot-type: images
  image-family: IMAGE_FAMILY

      Sostituisci IMAGE_FAMILY con il nome del tuo famiglia di immagini preferita, 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 esistente Oggetto PersistentVolumeClaim. Quando crei un oggetto VolumeSnapshot, GKE lo crea e lo associa automaticamente VolumeSnapshotContent, che è una risorsa nel tuo cluster come un PersistentVolume oggetto.

  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 uno snapshot oggetto VolumeSnapshotContent corrispondente nel cluster. Questo oggetto archivia lo snapshot e le associazioni di VolumeSnapshot oggetti. Non interagisci con VolumeSnapshotContents oggetti direttamente.

  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 sullo spazio di archiviazione corrispondente di un sistema operativo completo. Dopo che GKE ha creato uno snapshot sul sistema di archiviazione lo associa a un oggetto VolumeSnapshot nel cluster, lo snapshot è pronto per gli utilizzi odierni. 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

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

Per fare riferimento a un VolumeSnapshot in un PersistentVolumeClaim, aggiungi il parametro dataSource alle PersistentVolumeClaim. Viene utilizzata la stessa procedura se VolumeSnapshotContents si riferisce a un'immagine disco o a uno snapshot.

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

  1. Verifica se stai utilizzando uno snapshot di disco o immagini, che differiscono come segue:

    • Snapshot del disco: scatta spesso gli snapshot e ripristinali raramente.
    • Istantanee di immagini: acquisisci istantanee non di frequente e ripristinale spesso. Immagine la creazione di snapshot può essere più lenta rispetto a quella di snapshot del disco.

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

    Controlla VolumeSnapshot:

    kubectl describe volumesnapshot SNAPSHOT_NAME

    Il campo volumeSnapshotClassName specifica la classe snapshot.

    kubectl describe volumesnapshotclass SNAPSHOT_CLASS_NAME

    Il parametro snapshot-type specificherà snapshots o images. In caso contrario specificato, il valore predefinito è snapshots.

    Se non esiste una classe snapshot (ad esempio, se è stato creato in modo statico), ispeziona VolumeSnapshotContents. sh kubectl describe volumesnapshotcontents SNAPSHOT_CONTENTS_NAME Il formato dell'handle di uno 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 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 lo snapshot sia stato ripristinato correttamente

  1. Ottieni il nome del nuovo Pod creato da GKE per l'aggiornamento Deployment:

     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 completa un volume in GKE con uno snapshot di un altro 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. Sia volumeSnapshotRef.name che volumeSnapshotRef.namespace deve puntare all'elemento creato in precedenza VolumeSnapshot per rendere valida l'associazione bidirezionale.

    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 prova a trovare o a creare in modo dinamico una 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 che fa riferimento al PersistentVolumeClaim. Il conducente CSI eseguirà il provisioning di un PersistentVolume e compilarlo 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, procedi nel seguente modo.

  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