Esta documentação é referente à versão mais recente do GKE no Azure, lançada em novembro de 2021. Consulte as Notas de lançamento para mais informações.

Snapshot de um PersistentVolume

É possível usar o recurso de snapshot de volume do Kubernetes para volumes permanentes e provisionamento dinâmico nos clusters do GKE.

Eles permitem criar uma cópia do seu volume em um momento específico. Use essa cópia para trazer um volume de volta a um estado anterior ou para provisionar uma nova substituição.

É possível provisionar e anexar snapshots de volume com os seguintes componentes:

Requisitos

Para usar snapshots de volume no GKE no Azure, você precisa ter o seguinte:

Um volume usando um driver da interface de armazenamento em contêiner (CSI, na sigla em inglês) com suporte para snapshots. Os drivers de disco e de arquivo do Azure que o GKE no Azure usa por padrão dão suporte a snapshots.

Observação: o driver CSI do Azure File não é compatível com a restauração de um snapshot. Para mais informações, consulte Visão geral dos snapshots de compartilhamento para os Arquivos do Azure.

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.
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: disk.csi.azure.com ou file.csi.azure.com. Se o cluster provisionar PersistentVolumes dinamicamente pelo driver CSI conforme descrito nas seções a seguir, ele será gerenciado pelo driver CSI.

Antes de começar

Criar e usar um snapshot de volume

Os exemplos neste documento mostram como fazer o seguinte:

Criar um exemplo de PersistentVolumeClaim e Pod.
Criar um VolumeSnapshot.
Restaurar o snapshot do volume.
Verificar se a restauração funcionou.

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

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 exemplo `PersistentVolumeClaim` e `Pod`.

Para criar o objeto PersistentVolumeClaim, salve o manifesto a seguir como example-pvc.yaml:
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: example-pvc
spec:
  storageClassName: standard-rwo
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
```
Para spec.storageClassName, é possível especificar qualquer classe de armazenamento que use um driver CSI compatível. Neste exemplo, usamos a classe de armazenamento standard-rwo padrão.
Aplique o manifesto:
```
kubectl apply -f example-pvc.yaml
```

Crie um pod que grave a data e a hora atuais no volume. Para criar um pod, salve o manifesto a seguir como snapshot-shell.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: snapshot-shell
spec:
  terminationGracePeriodSeconds: 10
  containers:
  - name: linux
    image: ubuntu:bionic
    command: ["/bin/sh"]
    args: ["-c", "echo $(date -u) >> /data/out.txt"]
    volumeMounts:
    - name: snapshot-volume
      mountPath: /data
  restartPolicy: Never
  volumes:
  - name: snapshot-volume
    persistentVolumeClaim:
      claimName: example-pvc

Aplique o manifesto:
```
kubectl apply -f snapshot-shell.yaml
```
Verifique o status do pod:
```
kubectl get pod snapshot-shell
```
Pode levar algum tempo para que o pod seja executado e concluído. Execute o comando anterior até ver uma saída semelhante a esta:
```
NAME             READY   STATUS      RESTARTS   AGE
snapshot-shell   0/1     Completed   0          24s
```

Criar um VolumeSnapshot

Um objeto VolumeSnapshot é uma solicitação para um snapshot de um objeto PersistentVolumeClaim atual. Quando você cria um objeto VolumeSnapshot, o cluster faz a criação 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: example-snapshot
spec:
  source:
    persistentVolumeClaimName: example-pvc

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

Confirme se o cluster criou o objeto VolumeSnapshotContents:

kubectl get volumesnapshotcontents

O resultado será assim:

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

Confirmar se o snapshot do volume está pronto

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 cluster criar um snapshot no sistema de armazenamento e o vincular a um objeto VolumeSnapshot, o snapshot vai estar 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
example-snapshot        true

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.

Neste exemplo, você faz referência ao VolumeSnapshot criado em um novo PersistentVolumeClaim e cria um pod que monta o PersistentVolumeClaim.

Salve o seguinte manifesto como pvc-restore.yaml:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
 name: pvc-restore
spec:
 dataSource:
   name: example-snapshot
   kind: VolumeSnapshot
   apiGroup: snapshot.storage.k8s.io
 storageClassName: standard-rwo
 accessModes:
   - ReadWriteOnce
 resources:
   requests:
     storage: 1Gi

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

Iniciar um pod temporário que ativa o PVC no pod e exibe o conteúdo de out.txt nos registros.

Salve o seguinte manifesto como restore-log.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: restore-verify
spec:
  volumes:
    - name: restore-data
      persistentVolumeClaim:
        claimName: pvc-restore
  containers:
    - name: shell-container
      image: ubuntu:bionic
      volumeMounts:
        - mountPath: "/data"
          name: restore-data
      command: [ "/bin/sh" ]
      args: ["-c", "cat /data/out.txt", "exit", "1"]
  restartPolicy: Never

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

Verificar se o snapshot foi restaurado

O pod criado na etapa anterior lê o snapshot. Para visualizar os dados do snapshot, use o comando kubectl logs.

kubectl logs restore-verify

A saída precisa incluir um carimbo de data/hora do snapshot.

Limpar

Para evitar cobranças pelos recursos usados nesta página, siga estas etapas.

Exclua o VolumeSnapshot:
```
kubectl delete volumesnapshot example-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 snapshot subjacente vai ser retido.
Exclua o pod temporário:
```
kubectl delete -f restore-log.yaml
```
Exclua o pod:
```
kubectl delete -f snapshot-shell.yaml
```

Excluir os objetos PersistentVolumeClaim:

kubectl delete pvc example-pvc pvc-restore

A seguir

Leia a documentação do Snapshot de volume do Kubernetes.
Instalar outros drivers CSI