Fazer backup do armazenamento do Filestore usando snapshots de volume

Autopilot Standard

Nesta página, mostramos como fazer backup e restaurar o armazenamento do Filestore usando snapshots de volume do Kubernetes.

Criar um snapshot de volume do Kubernetes é equivalente a criar um backup do Filestore. Para mais informações, consulte Sobre snapshots de volume do Kubernetes.

Requisitos

Para usar snapshots de volume no GKE, você precisa atender aos seguintes requisitos:

Você precisa implantar o driver CSI do Filestore, que é compatível com os seguintes níveis de serviço do Filestore:
- HDD básico com o GKE versão 1.21 ou posterior
- SSD básico com o GKE versão 1.21 ou posterior
- Enterprise com o GKE versão 1.25 ou posterior
Use as versões 1.17 ou mais recentes do plano de controle. Para usar o Driver CSI do Filestore em um VolumeSnapshot, use o GKE versões 1.21 ou posterior.

Tenha um PersistentVolumeClaim para usar em um snapshot. O PersistentVolume que você usa para uma origem de snapshot precisa ser gerenciado por um driver CSI. Para saber se você está usando um driver CSI, verifique se a especificação do PersistentVolume tem uma seção csi com driver: pd.csi.storage.gke.io ou filestore.csi.storage.gke.io. Se o PersistentVolume for provisionado dinamicamente pelo driver CSI conforme descrito nas seções a seguir, ele será gerenciado pelo driver CSI.

Limitações

Os volumes de snapshots têm as mesmas restrições de tamanho que os volumes regulares. Por exemplo, os snapshots do Filestore precisam ser maiores ou iguais a 1 TiB para o nível HDD básico.
O driver CSI do Filestore não oferece suporte a fluxos de trabalho dinâmicos de provisionamento ou backup para os seguintes níveis de serviço do Filestore:
- Zonal
- Regional
Só é possível fazer backup de um compartilhamento por instância por vez. Em relação aos pools de armazenamento, as solicitações de backup emitidas por dois compartilhamentos distintos de duas instâncias diferentes do Filestore são executadas simultaneamente.
Os backups de compartilhamento único só podem ser restaurados para volumes de compartilhamento único. Usando o driver CSI do Filestore, só é possível restaurar um volume de compartilhamento único para uma nova instância do Filestore.
- A nova instância precisa usar o mesmo nível de serviço do backup.
- A nova instância precisa corresponder à mesma capacidade mínima que o backup.
As operações backup restore do Filestore para a origem ou uma instância atual do Filestore não são compatíveis. Para ver uma lista completa das limitações de recursos, consulte Limitações de recursos de backup do Filestore.
Os backups de compartilhamento múltiplo não são compatíveis.

Antes de começar

Antes de começar, verifique se você realizou as tarefas a seguir:

Ativar a API Google Kubernetes Engine.

Ativar a API Google Kubernetes Engine

Se você quiser usar a Google Cloud CLI para essa tarefa, instale e, em seguida, inicialize a CLI gcloud. Se você instalou a CLI gcloud anteriormente, instale a versão mais recente executando gcloud components update.
Observação: para instalações atuais da CLI gcloud, defina as propriedades compute/region e compute/zone. Ao definir locais padrão, é possível evitar erros na CLI gcloud, como: One of [--zone, --region] must be supplied: Please specify location.

Como criar e usar um snapshot de volume

Os exemplos neste documento mostram como fazer o seguinte:

Crie um PersistentVolumeClaim e um Deployment.
Adicione um arquivo a PersistentVolume usado pelo Deployment.
Crie um VolumeSnapshotClass para configurar o snapshot.
Crie um snapshot de volume do PersistentVolume.
Exclua o arquivo de teste.
Restaure o PersistentVolume para o snapshot criado.
Verifique se a restauração funcionou.

Para usar um snapshot de volume, conclua as etapas a seguir:

Crie um objeto VolumeSnapshotClass para especificar o driver CSI e a política de exclusão do snapshot.
Crie um objeto VolumeSnapshot para solicitar um snapshot de um PersistentVolumeClaim existente.
Faça referência ao VolumeSnapshot em um PersistentVolumeClaim para restaurar um volume para esse snapshot ou criar um novo volume usando o snapshot.

Criar um `PersistentVolumeClaim` e um `Deployment`

Para criar o objeto PersistentVolumeClaim, salve o manifesto a seguir como my-pvc.yaml:
Filestore
```
 apiVersion: v1
 kind: PersistentVolumeClaim
 metadata:
   name: my-pvc
 spec:
   storageClassName: enterprise-rwx
   accessModes:
   - ReadWriteMany
   resources:
     requests:
       storage: 1Ti
```
Este exemplo cria um PVC do Filestore de nível empresarial. Para saber mais, consulte Acessar instâncias do Filestore com o driver CSI do Filestore.
Para spec.storageClassName, é possível especificar qualquer classe de armazenamento que use um driver CSI compatível.
Aplique o manifesto:
```
kubectl apply -f my-pvc.yaml
```

Para criar um Deployment, salve o seguinte manifesto como 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

Aplique o manifesto:
```
kubectl apply -f my-deployment.yaml
```
Verifique o status de Deployment.
```
kubectl get deployment hello-app
```
Pode levar algum tempo para Deployment ficar pronto. Execute o comando anterior até ver uma saída semelhante a esta:
```
NAME        READY   UP-TO-DATE   AVAILABLE   AGE
hello-app   1/1     1            1           2m55s
```

Adicionar um arquivo de teste ao volume

Liste o Pods no Deployment:

kubectl get pods -l app=hello-app

O resultado será assim:

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

Crie um arquivo de teste em um Pod:

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

Substitua POD_NAME pelo nome do Pod.

Verifique se o arquivo existe.

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

O resultado será assim:

Hello World!

Criar um objeto `VolumeSnapshotClass`.

Crie um objeto VolumeSnapshotClass para especificar o driver CSI e deletionPolicy para o snapshot de volume. É possível referenciar objetos VolumeSnapshotClass ao criar objetos VolumeSnapshot.

Salve o seguinte manifesto volumesnapshotclass.yaml como :
Filestore
```
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: my-snapshotclass
driver: filestore.csi.storage.gke.io
parameters:
  type: backup
deletionPolicy: Delete
```
Neste exemplo:
- O campo driver é usado pelo driver CSI para provisionar o snapshot. Neste exemplo, filestore.csi.storage.gke.io usa o driver CSI do Filestore (em inglês).
- O campo deletionPolicy informa ao GKE o que fazer com o objeto VolumeSnapshotContent e o snapshot subjacente quando o objeto VolumeSnapshot vinculado é excluído. Especifique Delete para excluir o objeto VolumeSnapshotContent e o snapshot subjacente. Especifique Retain se quiser manter VolumeSnapshotContent e o snapshot subjacente.

Aplique o manifesto:

kubectl apply -f volumesnapshotclass.yaml

Criar um `VolumeSnapshot`

Um objeto VolumeSnapshot é uma solicitação para um snapshot de um objeto PersistentVolumeClaim atual. Quando você cria um objeto VolumeSnapshot, o GKE o cria e o vincula automaticamente a um objeto VolumeSnapshotContent, que é um recurso no cluster como um objeto PersistentVolume.

Salve o seguinte manifesto volumesnapshot.yaml como :

apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshot
metadata:
  name: my-snapshot
spec:
  volumeSnapshotClassName: my-snapshotclass
  source:
    persistentVolumeClaimName: my-pvc

Aplique o manifesto:
```
kubectl apply -f volumesnapshot.yaml
```
Depois de criar um snapshot Volume, o GKE cria um objeto VolumeSnapshotContent correspondente no cluster. Esse objeto armazena o snapshot e as vinculações dos objetos VolumeSnapshot. Você não interage diretamente com objetos VolumeSnapshotContents.

Confirme se o GKE criou o objeto VolumeSnapshotContents:

kubectl get volumesnapshotcontents

O resultado será assim:

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

Depois que o conteúdo do snapshot de Volume é criado, o driver CSI especificado em VolumeSnapshotClass cria um snapshot no sistema de armazenamento correspondente. Depois que o GKE cria um snapshot no sistema de armazenamento e o vincula a um objeto VolumeSnapshot no cluster, o snapshot está pronto para uso. Verifique o status executando o seguinte comando:

kubectl get volumesnapshot \
  -o custom-columns='NAME:.metadata.name,READY:.status.readyToUse'

Se o snapshot estiver pronto para uso, a saída será semelhante a esta:

NAME               READY
my-snapshot        true

Excluir o arquivo de teste

Exclua o arquivo de teste que você criou:

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

Verifique se o arquivo não existe mais:

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

O resultado será assim:

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

Restaurar o snapshot do volume

É possível referenciar um VolumeSnapshot em um PersistentVolumeClaim para provisionar um novo volume com dados de um volume atual.

Para fazer referência a um VolumeSnapshot em um PersistentVolumeClaim, adicione o campo dataSource ao seu PersistentVolumeClaim.

Neste exemplo, você faz referência ao VolumeSnapshot criado em um novo PersistentVolumeClaim e atualiza o Deployment para usar a nova declaração.

Salve o seguinte manifesto como 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

Aplique o manifesto:
```
kubectl apply -f pvc-restore.yaml
```

Atualize o arquivo my-deployment.yaml para usar o novo PersistentVolumeClaim:

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

Aplique o manifesto atualizado:
```
kubectl apply -f my-deployment.yaml
```

Verificar se o snapshot foi restaurado

Obtenha o nome do novo Pod que o GKE cria para o Deployment atualizado:
```
 kubectl get pods -l app=hello-app
```

Verifique se o arquivo de teste existe:

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

Substitua NEW_POD_NAME pelo nome do novo Pod criado pelo GKE.

O resultado será assim:

   Hello World!

Limpeza

Para evitar cobranças na conta do Google Cloud pelos recursos usados nesta página, siga estas etapas.

Exclua o VolumeSnapshot:
```
kubectl delete volumesnapshot my-snapshot
```
Observação: se o VolumeSnapshotClass de um snapshot de volume tiver deletionPolicy:Delete, o VolumeSnapshotContent correspondente e o snapshot físico no sistema de armazenamento também vão ser excluídos. Se ele tiver um deletionPolicy:Retain, o GKE manterá o snapshot subjacente.

Exclua o VolumeSnapshotClass:

kubectl delete volumesnapshotclass my-snapshotclass

Exclua o Deployment:
```
kubectl delete deployments hello-app
```
Excluir os objetos PersistentVolumeClaim:
```
kubectl delete pvc my-pvc pvc-restore
```

A seguir

Leia a documentação do Snapshot de volume do Kubernetes.
Saiba mais sobre a expansão de volume.
Saiba como instalar manualmente um driver CSI.
Saiba mais sobre o armazenamento de arquivos (Filestore) para GKE.

Fazer backup do armazenamento do Filestore usando snapshots de volume

Requisitos

Limitações

Antes de começar

Como criar e usar um snapshot de volume

Criar um PersistentVolumeClaim e um Deployment

Filestore

Adicionar um arquivo de teste ao volume

Criar um objeto VolumeSnapshotClass.

Filestore

Criar um VolumeSnapshot

Excluir o arquivo de teste

Restaurar o snapshot do volume

Filestore

Verificar se o snapshot foi restaurado

Limpeza

A seguir

Criar um `PersistentVolumeClaim` e um `Deployment`

Criar um objeto `VolumeSnapshotClass`.

Criar um `VolumeSnapshot`