Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui il backup dello spazio di archiviazione Filestore utilizzando gli snapshot dei volumi

Autopilota Standard

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

La creazione di uno snapshot del volume Kubernetes equivale alla creazione di un backup di Filestore. Per ulteriori informazioni, vedi Informazioni sugli snapshot di volumi Kubernetes.

Requisiti

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

Devi eseguire il deployment Driver CSI Filestore. Solo i seguenti livelli di servizio Filestore sono supportati:
- HDD di base con GKE 1.21 o versioni successive
- SSD di base con GKE 1.21 o versioni successive
- A livello di zona (da 10 a 100 TiB) con GKE versione 1.27 o successive
- Enterprise con GKE 1.25 o versioni successive
Utilizza il control plane versioni 1.17 o successive. Per utilizzare Driver CSI Filestore in VolumeSnapshot, utilizza il numero di versione GKE applicabile il livello di servizio.

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

I volumi di snapshot hanno le stesse limitazioni di dimensioni dei volumi normali. Per esempio, gli snapshot di Filestore devono essere maggiori o uguali a 1 TiB per il livello HDD di base.
Il driver CSI Filestore non supporta il provisioning dinamico o flussi di lavoro di backup per i seguenti livelli di servizio Filestore:
- Per zona (da 1 TiB a 9,75 TiB)
- Regionale
Puoi eseguire il backup di una sola condivisione per istanza alla volta. Per quanto riguarda l'archiviazione pool, richieste di backup emesse da due azioni diverse da due diversi Le istanze Filestore verranno eseguite contemporaneamente.
I backup con condivisione singola possono essere ripristinati solo nei volumi con condivisione singola. L'utilizzo del Driver CSI Filestore, puoi ripristinare solo un volume singleshare o 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 con l'origine o con un'istanza Filestore esistente non sono supportate. Per un elenco completo delle funzionalità vedi le 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à:

Attiva l'API Google Kubernetes Engine.

Attiva 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.
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 i seguenti: 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 l'eliminazione criterio per lo snapshot.
Crea un oggetto VolumeSnapshot per richiedere uno snapshot di un oggetto esistente PersistentVolumeClaim.
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:
Filestore
```
 apiVersion: v1
 kind: PersistentVolumeClaim
 metadata:
   name: my-pvc
 spec:
   storageClassName: enterprise-rwx
   accessModes:
   - ReadWriteMany
   resources:
     requests:
       storage: 1Ti
```
Questo esempio crea un PVC Filestore di livello Enterprise. A per saperne di più, consulta Accedi alle istanze Filestore con il driver CSI Filestore.
Per spec.storageClassName, puoi specificare qualsiasi classe di archiviazione che utilizza 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 un po' di tempo prima che il 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 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

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

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

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 VolumeSnapshotContent, che è una risorsa nel tuo cluster come un PersistentVolume oggetto.

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

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

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

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.

Per fare riferimento a un VolumeSnapshot in un PersistentVolumeClaim, aggiungi il parametro dataSource alle PersistentVolumeClaim.

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

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

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

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 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: filestore.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 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: enterprise-rwx
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

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

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

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. in questa pagina, procedi nel seguente modo.

Elimina VolumeSnapshot:
```
kubectl delete volumesnapshot my-snapshot
```
Nota: se lo snapshot del volume VolumeSnapshotClass ha deletionPolicy:Delete, il VolumeSnapshotContent corrispondente e lo snapshot fisico sul vengono eliminati anche il sistema di archiviazione di Google. Se ha un 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 Istantanea del volume Kubernetes documentazione.
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.

Esegui il backup dello spazio di archiviazione Filestore utilizzando gli snapshot dei volumi

Requisiti

Limitazioni

Prima di iniziare

Creazione e utilizzo di uno snapshot del volume

Crea un PersistentVolumeClaim e un Deployment

Filestore

Aggiungi un file di test al volume

Crea un oggetto VolumeSnapshotClass

Filestore

Crea un VolumeSnapshot

Elimina il file di test

Ripristina lo snapshot del volume

Filestore

Verifica che lo snapshot sia stato ripristinato correttamente

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