O produto descrito nesta documentação, GKE na AWS, agora está em modo de manutenção e será encerrado em 17 de março de 2027.

Esta página foi traduzida pela API Cloud Translation.

Snapshot de um PersistentVolume

Você pode usar o recurso de instantâneo de volume do Kubernetes para volumes persistentes e provisionamento dinâmico em seus clusters do GKE.

Os snapshots de volume permitem criar uma cópia do seu volume em um momento específico. Você pode usar essa cópia para restaurar um volume a um estado anterior ou provisionar um volume de substituição.

Você pode provisionar e anexar snapshots de volume com os seguintes componentes:

Requisitos

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

Um volume que usa um driver CSI (Container Storage Interface) que suporta snapshots. Os drivers EBS (Elásticos de Armazenamento de Blocos) que o GKE na AWS usa por padrão suportam snapshots.
Para obter uma lista de todos os drivers CSI que oferecem suporte a snapshots, consulte a coluna "Outros recursos" em Drivers na documentação do Kubernetes.
Tenha um PersistentVolumeClaim existente para usar em um snapshot. O PersistentVolume usado para a origem de um snapshot deve ser gerenciado por um driver CSI. Você pode verificar se está usando um driver CSI verificando se a especificação PersistentVolume tem uma seção csi com driver: ebs.csi.aws.com . Se o seu cluster provisiona PersistentVolumes dinamicamente pelo driver CSI, conforme descrito nas seções a seguir, ele é gerenciado pelo driver CSI.

Antes de começar

Criar e usar um instantâneo de volume

Os exemplos neste documento mostram como executar as seguintes tarefas:

Crie um exemplo de PersistentVolumeClaim e Pod .
Crie um VolumeSnapshot .
Restaure o instantâneo do volume .
Verifique se a restauração funcionou .

Para usar um instantâneo de volume, você deve concluir as seguintes etapas:

Crie um objeto VolumeSnapshot para solicitar um instantâneo 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.

Crie um exemplo de `PersistentVolumeClaim` e `Pod`

Para criar o objeto PersistentVolumeClaim , salve o seguinte manifesto 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 , você pode especificar qualquer classe de armazenamento que utilize um driver CSI compatível. Este exemplo usa a classe de armazenamento padrão standard-rwo .
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 seguinte manifesto 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 o Pod ser executado e concluído. Você pode executar o comando anterior até ver uma saída semelhante à seguinte:
```
NAME             READY   STATUS      RESTARTS   AGE
snapshot-shell   0/1     Completed   0          24s
```

Criar um VolumeSnapshot

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

Salve o seguinte manifesto como volumesnapshot.yaml .

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
```
Após criar um snapshot de volume, o cluster cria um objeto VolumeSnapshotContent correspondente. Este objeto armazena o snapshot e as vinculações dos objetos VolumeSnapshot . Você não interage diretamente com os objetos VolumeSnapshotContents .

Confirme se o seu cluster criou o objeto VolumeSnapshotContents :

kubectl get volumesnapshotcontents

A saída é semelhante à seguinte:

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

Confirme se o instantâneo do volume está pronto

Após a criação do conteúdo do snapshot de volume, o driver CSI especificado na classe VolumeSnapshotClass cria um snapshot no sistema de armazenamento correspondente. Depois que o cluster cria um snapshot no sistema de armazenamento e o vincula a um objeto VolumeSnapshot , o snapshot está pronto para uso. Você pode verificar o status executando o seguinte comando:

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

Se o instantâneo estiver pronto para uso, a saída será semelhante à seguinte:

NAME                    READY
example-snapshot        true

Restaurar o instantâneo do volume

Você pode referenciar um VolumeSnapshot em um PersistentVolumeClaim para provisionar um novo volume com dados de um volume existente ou restaurar um volume para um estado que você capturou no snapshot.

Para referenciar um VolumeSnapshot em um PersistentVolumeClaim , adicione o campo dataSource ao seu PersistentVolumeClaim .

Neste exemplo, você faz referência ao VolumeSnapshot que criou 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
```

Inicie um Pod temporário que monta o PVC no Pod e imprime o conteúdo de out.txt nos logs.

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

Verifique se o snapshot foi restaurado com sucesso

O Pod que você criou na etapa anterior lê o snapshot. Para visualizar os dados do snapshot, use o comando kubectl logs .

kubectl logs restore-verify

A saída deve incluir um registro de data e hora do instantâneo.

Limpar

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

Excluir o VolumeSnapshot :
```
kubectl delete volumesnapshot example-snapshot
```
Observação: se a VolumeSnapshotClass de um snapshot de volume tiver deletionPolicy:Delete , o VolumeSnapshotContent correspondente e o snapshot físico no sistema de armazenamento também serão excluídos. Se tiver deletionPolicy:Retain o snapshot subjacente será mantido.
Exclua o Pod temporário:
```
kubectl delete -f restore-log.yaml
```
Excluir o Pod:
```
kubectl delete -f snapshot-shell.yaml
```

Exclua os objetos PersistentVolumeClaim :

kubectl delete pvc example-pvc pvc-restore

O que vem a seguir

Leia a documentação do Kubernetes Volume Snapshot .
Instalar drivers CSI adicionais .