Como usar instantâneos de volume

No Google Kubernetes Engine (GKE), é possível usar o recurso de snapshot de volume do Kubernetes para volumes permanentes 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 um novo volume.

A partir da versão GKE 1.17, é possível provisionar e anexar snapshots de volume com os seguintes componentes:

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 disco permanente na árvore não é compatível com snapshots.
- O driver CSI do disco permanente 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 superior Também é possível ativar o driver CSI de disco permanente do Compute Engine em um cluster atual.
- Também é possível implantar automaticamente o driver CSI do Filestore. Para ver uma lista de todos os drivers CSI compatíveis com snapshots, consulte a coluna "Outros recursos" em Drivers (em inglês) na documentação do Kubernetes.
Use as versões 1.17 ou mais recentes do plano de controle. Para usar o driver CSI de disco permanente do Compute Engine, use as versões 1.17.6-gke.4 ou posteriores em um VolumeSnapshot. Para usar o Driver CSI do Filestore em um VolumeSnapshot, use as versões 1.21 ou posteriores do GKE.
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.

Antes de começar

Antes de começar, veja se você realizou as seguintes tarefas:

Veja se você ativou a API do Google Kubernetes Engine.

Ativar a API Google Kubernetes Engine

Confirme se você instalou a Google Cloud CLI.
Defina as configurações padrão da Google Cloud CLI para o projeto usando um dos seguintes métodos:

Use gcloud init se quiser orientações para definir os padrões do projeto.
Use gcloud config para definir individualmente a região, a zona e o ID do projeto.

gcloud init

Execute gcloud init e siga as instruções:
```
gcloud init
```
Se você estiver usando SSH em um servidor remoto, utilize a sinalização --console-only para impedir que o comando inicie um navegador:
```
gcloud init --console-only
```
Siga as instruções para autorizar a CLI gcloud a usar a conta do Google Cloud.
Crie uma nova configuração ou selecione uma atual.
Escolha um projeto do Google Cloud.
Escolha uma zona padrão do Compute Engine.
Escolha uma região padrão do Compute Engine.

Observação: para modificar essas configurações padrão na CLI gcloud, use as sinalizações --project, --zone e --region

gcloud config

Defina o ID do projeto padrão:
```
gcloud config set project PROJECT_ID
```
Defina a região padrão do Compute Engine (por exemplo, us-central1):
```
gcloud config set compute/region COMPUTE_REGION
```
Defina a zona padrão do Compute Engine (por exemplo, us-central1-c):
```
gcloud config set compute/zone COMPUTE_ZONE
```
Atualize gcloud para a versão mais recente:
```
gcloud components update
```

Observação: para modificar essas configurações padrão na CLI gcloud, use as sinalizações --project, --zone e --region

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 uma implantação.
Adicione um arquivo ao PersistentVolume que a implantação usa.
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 uma implantação

Para criar o objeto PersistentVolumeClaim, salve o manifesto a seguir como my-pvc.yaml:
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-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. Este exemplo usa a classe de armazenamento standard-rwo instalada por padrão com o driver CSI de disco permanente do Compute Engine. Para mais informações, consulte Como usar o driver CSI de disco permanente do Compute Engine.
Aplique o manifesto:
```
kubectl apply -f my-pvc.yaml
```

Para criar uma implantação, salve o manifesto a seguir 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 da implantação:
```
kubectl get deployment hello-app
```
Pode levar algum tempo para a implantação ficar pronta. 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 os pods na implantação:

kubectl get pods -l app=hello-app

A saída 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'

A saída 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 :
v1
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
```
v1beta1
Use a versão da API v1beta1 para clusters que executam as versões 1.21 ou anteriores.
```
apiVersion: snapshot.storage.k8s.io/v1beta1
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 disco permanente 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
```

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 :

v1

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: VolumeSnapshot
metadata:
  name: my-snapshot
spec:
  volumeSnapshotClassName: my-snapshotclass
  source:
    persistentVolumeClaimName: my-pvc

v1beta1

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

apiVersion: snapshot.storage.k8s.io/v1beta1
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 de 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 os objetos VolumeSnapshotContents.

Confirme se o GKE criou o objeto VolumeSnapshotContents:

kubectl get volumesnapshotcontents

A saída 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'

A saída 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.

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

Salve o seguinte manifesto como pvc-restore.yaml:

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

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

Receba o nome do novo pod que o GKE cria para a implantação atualizada:
```
 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 do GKE criado.

A saída será assim:

   Hello World!

Limpar

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 serão excluídos. Se ele tiver um deletionPolicy:Retain, o GKE manterá o snapshot subjacente.

Exclua o VolumeSnapshotClass:

kubectl delete volumesnapshotclass my-snapshotclass

Exclua a implantação:
```
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.

Como usar instantâneos de volume

Requisitos

Antes de começar

gcloud init

gcloud config

Como criar e usar um snapshot de volume

Criar um PersistentVolumeClaim e uma implantação

Adicionar um arquivo de teste ao volume

Criar um objeto VolumeSnapshotClass.

v1

v1beta1

Criar um VolumeSnapshot

v1

v1beta1

Excluir o arquivo de teste

Restaurar o snapshot do volume

Verificar se o snapshot foi restaurado

Limpar

A seguir

Criar um objeto `VolumeSnapshotClass`.