Fazer backup do armazenamento do Persistent Disk usando snapshots de volume

Autopilot Standard

---

Esta página mostra como fazer backup e restaurar o armazenamento do Persistent Disk usando snapshots de volume.

Para uma introdução, consulte Sobre snapshots de volume do Kubernetes.

Requisitos

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

• Use um driver CSI que seja compatível com snapshots. O driver de Persistent Disk na árvore não é compatível com snapshots. Para criar e gerenciar snapshots, você precisa usar o mesmo driver CSI que o PersistentVolumeClaim (PVC) subjacente.

  • Para snapshots de volume de Persistent Disk (PD, na sigla em inglês), use o driver CSI do Persistent Disk do Compute Engine. O driver CSI do Persistent Disk do Compute Engine é instalado por padrão em novos clusters do Linux que executam o GKE versão 1.18.10-gke.2100 ou posterior ou versão 1.19.3-gke.2100 ou posterior. Também é possível ativar o driver CSI de Persistent Disk do Compute Engine em um cluster atual.

  • Para ver uma lista de todos os drivers CSI compatíveis com snapshots, consulte a coluna Outros recursos em Drivers na documentação do Kubernetes.

• Use as versões 1.17 ou mais recentes do plano de controle. Para usar o driver CSI de Persistent Disk do Compute Engine em um VolumeSnapshot, use as versões GKE 1.17.6-gke.4 ou posteriores.

• 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

Todas as restrições para criar um snapshot de disco no Compute Engine também se aplicam ao GKE.

Práticas recomendadas

Siga as práticas recomendadas para snapshots de disco do Compute Engine ao usar snapshots Volume de Persistent Disk no GKE.

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 CLI do Google Cloud para essa tarefa, instale e, em seguida, inicialize a CLI gcloud. Se você instalou a gcloud CLI anteriormente, instale a versão mais recente executando gcloud components update.
  Observação: para instalações atuais da gcloud CLI, defina as propriedades compute/region e compute/zone. Ao definir locais padrão, é possível evitar erros na gcloud CLI, 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:

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

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

1. Crie um objeto VolumeSnapshotClass para especificar o driver CSI e a política de exclusão do snapshot.
2. Crie um objeto VolumeSnapshot para solicitar um snapshot de um PersistentVolumeClaim existente.
3. 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

1. Para criar o objeto PersistentVolumeClaim, salve o manifesto a seguir como my-pvc.yaml:

   Persistent Disk

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: my-pvc
    spec:
      storageClassName: standard-rwo
      accessModes:
      - ReadWriteOnce
      resources:
        requests:
          storage: 1Gi
   

   Este exemplo usa a classe de armazenamento standard-rwo instalada por padrão com o driver CSI de Persistent Disk do Compute Engine. Para saber mais, consulte Como usar o driver CSI do Persistent Disk do Compute Engine.

   Para spec.storageClassName, é possível especificar qualquer classe de armazenamento que use um driver CSI compatível.

2. Aplique o manifesto:

   kubectl apply -f my-pvc.yaml
   

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

4. Aplique o manifesto:

   kubectl apply -f my-deployment.yaml
   

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

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

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

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

1. Salve o seguinte manifesto volumesnapshotclass.yaml como :

   Persistent Disk

   Use a versão da API v1 para clusters que executam as versões 1.21 ou posteriores.

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

   Neste exemplo:

   • O campo driver é usado pelo driver CSI para provisionar o snapshot. Neste exemplo, pd.csi.storage.gke.io usa o driver CSI de Persistent Disk do Compute Engine.

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

     Para usar um local de armazenamento personalizado, adicione um parâmetro storage-locations à classe de snapshot. Para usar esse parâmetro, os clusters precisam usar a versão 1.21 ou posterior.

     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
     

   • Para criar uma imagem de disco, adicione o seguinte ao campo parameters:

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

     Substitua IMAGE_FAMILY pelo nome da família de imagens preferida, como preloaded-data.

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

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

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

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

1. Exclua o arquivo de teste que você criou:

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

2. 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 ou restaurar um volume para um estado capturado no snapshot.

Para fazer referência a um VolumeSnapshot em um PersistentVolumeClaim, adicione o campo dataSource ao seu PersistentVolumeClaim. O mesmo processo é usado se VolumeSnapshotContents se referir a uma imagem de disco ou um snapshot.

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

1. Verifique se você está usando um snapshot de disco ou de imagem, que é diferente da seguinte:

   • Instantâneos de disco: tire snapshots com frequência e restaure-os com pouca frequência.
   • Snapshots de imagem: tire snapshots com pouca frequência e restaure-os com frequência. A criação de snapshots de imagem também pode ser mais lenta do que a de snapshots de disco.

   Para detalhes, consulte Limites de frequência de snapshots. Conhecer o tipo de snapshot ajuda a resolver problemas.

   Inspecione o VolumeSnapshot:

   kubectl describe volumesnapshot SNAPSHOT_NAME
   

   O campo volumeSnapshotClassName especifica a classe de snapshot.

   kubectl describe volumesnapshotclass SNAPSHOT_CLASS_NAME
   

   O parâmetro snapshot-type especificará snapshots ou images. Se não for fornecido, o padrão será snapshots.

   Se não houver classe de snapshot (por exemplo, se o snapshot foi criado estaticamente), inspecione o VolumeSnapshotContents. sh kubectl describe volumesnapshotcontents SNAPSHOT_CONTENTS_NAME O formato de um gerenciador de snapshot na saída informa o tipo de snapshot da seguinte maneira: * projects/PROJECT_NAME/global/snapshots/SNAPSHOT_NAME: snapshot do disco

   • projects/PROJECT_NAME/global/images/IMAGE_NAME: snapshot da imagem

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

   Observação: o namespace do PersistentVolumeClaim deve ser o mesmo que o namespace do VolumeSnapshot.

2. Aplique o manifesto:

   kubectl apply -f pvc-restore.yaml
   

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

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

4. Aplique o manifesto atualizado:

   kubectl apply -f my-deployment.yaml
   

Verificar se o snapshot foi restaurado

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

Importar um snapshot preexistente

É possível usar um snapshot de volume atual criado fora do cluster atual para provisionar manualmente o objeto VolumeSnapshotContents. Por exemplo, é possível preencher um volume no GKE com um snapshot de outro recurso do Google Cloud criado em um cluster diferente.

1. Localize o nome do snapshot.

   Console do Google Cloud

   Acesse https://console.cloud.google.com/compute/snapshots.

   Google Cloud CLI

   Execute este comando:

   gcloud compute snapshots list
   

   O resultado será assim:

   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. Salve o seguinte manifesto VolumeSnapshot como 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. Aplique o manifesto:

   kubectl apply -f restored-snapshot.yaml
   

4. Salve o seguinte manifesto VolumeSnapshotContent como restored-snapshot-content.yaml. Substitua o campo snapshotHandle pelo ID do projeto e nome do snapshot. Tanto volumeSnapshotRef.name quanto volumeSnapshotRef.namespace precisam apontar para a VolumeSnapshot criada anteriormente para que a vinculação bidirecional seja válida.

   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. Aplique o manifesto:

   kubectl apply -f restored-snapshot-content.yaml
   

6. Salve o seguinte manifesto PersistentVolumeClaim como restored-pvc.yaml. O controlador de armazenamento do Kubernetes encontrará um VolumeSnapshot chamado restored-snapshot e tentará encontrar ou criar dinamicamente um PersistentVolume como a fonte de dados. Depois, use esse PVC em um pod para acessar os dados restaurados.

   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. Aplique o manifesto:

   kubectl apply -f restored-pvc.yaml
   

8. Salve o manifesto Pod a seguir como restored-pod.yaml se referindo a PersistentVolumeClaim. O driver CSI provisionará um PersistentVolume e o preencherá a partir do 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. Aplique o manifesto:

   kubectl apply -f restored-pod.yaml
   

10. Verifique se o arquivo foi restaurado:

    kubectl exec restored-pod -- sh -c 'cat /demo/data/hello.txt'
    

Limpar

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

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

2. Exclua o VolumeSnapshotClass:

   kubectl delete volumesnapshotclass my-snapshotclass
   

3. Exclua o Deployment:

   kubectl delete deployments hello-app
   

4. 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 em blocos (Persistent Disk) para o GKE.