Esta página foi traduzida pela API Cloud Translation.

Faça uma cópia de segurança do armazenamento do Persistent Disk através de instantâneos de volumes

Autopilot Padrão

Esta página mostra como fazer uma cópia de segurança e restaurar o armazenamento do disco persistente através de instantâneos de volumes.

Para uma introdução, consulte o artigo Acerca dos resumos de volumes do Kubernetes.

Requisitos

Para usar as imagens instantâneas de volume no GKE, tem de cumprir os seguintes requisitos:

Use um controlador CSI que suporte instantâneos. O controlador de disco persistente na árvore não suporta instantâneos. Para criar e gerir instantâneos, tem de usar o mesmo controlador CSI que o PersistentVolumeClaim (PVC) subjacente.
- Para instantâneos de volumes de Persistent Disk (PD), use o controlador CSI de Persistent Disk do Compute Engine. O controlador CSI do Persistent Disk do Compute Engine é instalado por predefinição em novos clusters Linux com a versão 1.18.10-gke.2100 ou posterior do GKE, ou a versão 1.19.3-gke.2100 ou posterior. Também pode ativar o controlador CSI do Persistent Disk do Compute Engine num cluster existente.
- Para ver uma lista de todos os controladores CSI que suportam instantâneos, consulte a coluna Outras funcionalidades em Controladores na documentação do Kubernetes.
Use versões 1.17 ou posteriores do plano de controlo. Para usar o controlador CSI do Persistent Disk do Compute Engine num VolumeSnapshot, use as versões 1.17.6-gke.4 ou posteriores do GKE.

Ter um PersistentVolumeClaim existente para usar num instantâneo. O PersistentVolume que usa para uma origem de instantâneo tem de ser gerido por um controlador CSI. Pode verificar se está a usar um controlador CSI verificando se a especificação PersistentVolume tem uma secção csi com driver: pd.csi.storage.gke.io ou filestore.csi.storage.gke.io. Se o PersistentVolume for aprovisionado dinamicamente pelo controlador CSI, conforme descrito nas secções seguintes, é gerido pelo controlador CSI.

Limitações

Todas as restrições para criar uma captura instantânea de disco no Compute Engine também se aplicam ao GKE.

Práticas recomendadas

Certifique-se de que segue as práticas recomendadas para instantâneos de disco do Compute Engine quando usar instantâneos de Volume disco persistente no GKE.

Antes de começar

Antes de começar, certifique-se de que realizou as seguintes tarefas:

Ative a API Google Kubernetes Engine.

Ative a API Google Kubernetes Engine

Se quiser usar a CLI gcloud para esta tarefa, instale-a e, em seguida, inicialize-a. Se instalou anteriormente a CLI gcloud, execute gcloud components update para obter a versão mais recente.
Nota: para instalações existentes da CLI gcloud, certifique-se de que define a compute/region propriedade. Se usar principalmente clusters zonais, defina o compute/zone. Ao definir uma localização predefinida, pode evitar erros na CLI gcloud, como os seguintes: One of [--zone, --region] must be supplied: Please specify location. Pode ter de especificar a localização em determinados comandos se a localização do seu cluster for diferente da predefinição que definiu.

Criar e usar um instantâneo de volume

Os exemplos neste documento mostram como realizar as seguintes tarefas:

Para usar uma análise detalhada do volume, tem de concluir os seguintes passos:

Crie um objeto VolumeSnapshotClass para especificar o controlador CSI e a política de eliminação para a sua captura instantânea.
Crie um objeto VolumeSnapshot para pedir um instantâneo de um PersistentVolumeClaim existente.
Faça referência ao VolumeSnapshot num PersistentVolumeClaim para restaurar um volume para essa imagem instantânea ou criar um novo volume com a imagem instantânea.

Crie um `PersistentVolumeClaim` e um `Deployment`

Para criar o objeto PersistentVolumeClaim, guarde o seguinte manifesto 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-rwoinstalada por predefinição com o controlador CSI do Persistent Disk do Compute Engine. Para saber mais, consulte o artigo Usar o controlador CSI do disco persistente do Compute Engine.
Para spec.storageClassName, pode especificar qualquer classe de armazenamento que use um controlador CSI suportado.
Aplique o manifesto:
```
kubectl apply -f my-pvc.yaml
```

Para criar um Deployment, guarde 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 estado do Deployment:
```
kubectl get deployment hello-app
```
O Deployment pode demorar algum tempo a ficar pronto. Pode executar o comando anterior até ver um resultado semelhante ao seguinte:
```
NAME        READY   UP-TO-DATE   AVAILABLE   AGE
hello-app   1/1     1            1           2m55s
```

Adicione um ficheiro de teste ao volume

Indica os Pods no Deployment:

kubectl get pods -l app=hello-app

O resultado é semelhante ao seguinte:

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

Crie um ficheiro de teste num 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 ficheiro existe:

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

O resultado é semelhante ao seguinte:

Hello World!

Crie um objeto `VolumeSnapshotClass`

Crie um objeto VolumeSnapshotClass para especificar o controlador CSI e o deletionPolicy para a sua cópia instantânea do volume. Pode fazer referência a objetos VolumeSnapshotClass quando cria objetos VolumeSnapshot.

Guarde o seguinte manifesto como volumesnapshotclass.yaml.
Persistent Disk
Use a versão da API v1 para clusters com 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 controlador CSI para aprovisionar a captura de ecrã. Neste exemplo, o pd.csi.storage.gke.io usa o controlador CSI do Persistent Disk do Compute Engine.
- O campo deletionPolicy indica ao GKE o que fazer com o objeto VolumeSnapshotContent e a imagem instantânea subjacente quando o objeto VolumeSnapshot associado é eliminado. Especifique Delete para eliminar o objeto VolumeSnapshotContent e a captura de ecrã subjacente. Especifique Retain se quer manter o VolumeSnapshotContent e a imagem subjacente.
  
  Para usar uma localização de armazenamento personalizada, adicione um parâmetro storage-locations à classe de instantâneo. Para usar este parâmetro, os seus clusters têm de 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 sua família de imagens preferida, como preloaded-data.

Aplique o manifesto:

kubectl apply -f volumesnapshotclass.yaml

Crie um `VolumeSnapshot`

Um objeto VolumeSnapshot é um pedido de uma captura de ecrã de um objeto PersistentVolumeClaim existente. Quando cria um objeto VolumeSnapshot, o GKE cria e associa-o automaticamente a um objeto VolumeSnapshotContent, que é um recurso no seu cluster, como um objeto PersistentVolume.

Guarde o seguinte manifesto como volumesnapshot.yaml.

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 uma Volume cópia instantânea, o GKE cria um objeto VolumeSnapshotContent correspondente no cluster. Este objeto armazena a imagem instantânea e as associações de VolumeSnapshot objetos. Não interage diretamente com objetos VolumeSnapshotContents.

Confirme se o GKE criou o objeto VolumeSnapshotContents:

kubectl get volumesnapshotcontents

O resultado é semelhante ao seguinte:

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

Depois de criar o conteúdo da captura instantânea Volume, o controlador CSI especificado no VolumeSnapshotClass cria uma captura instantânea no sistema de armazenamento correspondente. Depois de o GKE criar um instantâneo no sistema de armazenamento e o associar a um objeto VolumeSnapshot no cluster, o instantâneo está pronto a ser usado. Pode verificar o estado executando o seguinte comando:

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

Se o instantâneo estiver pronto a usar, o resultado é semelhante ao seguinte:

NAME               READY
my-snapshot        true

Elimine o ficheiro de teste

Elimine o ficheiro de teste que criou:

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

Verifique se o ficheiro já não existe:

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

O resultado é semelhante ao seguinte:

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

Restaure o instantâneo de volume

Pode fazer referência a um VolumeSnapshot num PersistentVolumeClaim para aprovisionar um novo volume com dados de um volume existente ou restaurar um volume para um estado capturado na captura de ecrã.

Para fazer referência a um VolumeSnapshot num PersistentVolumeClaim, adicione o campo dataSource ao seu PersistentVolumeClaim. O mesmo processo é usado, quer o VolumeSnapshotContents se refira a uma imagem de disco ou a uma captura de ecrã.

Neste exemplo, faz referência ao VolumeSnapshot que criou num novo PersistentVolumeClaim e atualiza o Deployment para usar a nova reivindicação.

Verifique se está a usar um disco ou uma captura instantânea de imagem, que diferem da seguinte forma:
- Instantâneos de discos: tire instantâneos com frequência e restaure-os raramente.
- Instantâneos de imagens: tire instantâneos com pouca frequência e restaure-os com frequência. Os instantâneos de imagem também podem ser mais lentos de criar do que os instantâneos de disco.
Para ver detalhes, consulte os limites de frequência de instantâneos. Conhecer o tipo de instantâneo ajuda se precisar de resolver problemas.

Inspecione o VolumeSnapshot:
```
kubectl describe volumesnapshot SNAPSHOT_NAME
```
O campo volumeSnapshotClassName especifica a classe de imagem instantânea.
```
kubectl describe volumesnapshotclass SNAPSHOT_CLASS_NAME
```
O parâmetro snapshot-type especifica snapshots ou images. Se não for indicado, o valor predefinido é snapshots.

Se não existir uma classe de instantâneo (por exemplo, se o instantâneo foi criado estaticamente), inspecione o VolumeSnapshotContents. sh kubectl describe volumesnapshotcontents SNAPSHOT_CONTENTS_NAME O formato de um identificador de instantâneo na saída indica o tipo de instantâneo, da seguinte forma: * projects/PROJECT_NAME/global/snapshots/SNAPSHOT_NAME: instantâneo do disco
- projects/PROJECT_NAME/global/images/IMAGE_NAME: instantâneo de imagem

Guarde 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

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

Atualize o ficheiro 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
```

Verifique se o instantâneo foi restaurado com êxito

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

Verifique se o ficheiro 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 que o GKE criou.

O resultado é semelhante ao seguinte:

   Hello World!

Importe um Snapshot pré-existente

Pode usar uma captura instantânea de volume existente criada fora do cluster atual para aprovisionar manualmente o objeto VolumeSnapshotContents. Por exemplo, pode preencher um volume no GKE com uma captura de ecrã de outro recursoGoogle Cloud criado num cluster diferente.

Localize o nome do instantâneo.

Google Cloud consola

Aceda a https://console.cloud.google.com/compute/snapshots.

CLI do Google Cloud

Execute o seguinte comando:

gcloud compute snapshots list

O resultado é semelhante ao seguinte:

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

Guarde 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

Aplique o manifesto:

kubectl apply -f restored-snapshot.yaml

Guarde o seguinte manifesto VolumeSnapshotContent como restored-snapshot-content.yaml. Substitua o campo snapshotHandle pelo ID do projeto e o nome da captura instantânea. Ambos os elementos volumeSnapshotRef.name e volumeSnapshotRef.namespace têm de apontar para o elemento VolumeSnapshot criado anteriormente para que a associaçã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

Aplique o manifesto:

kubectl apply -f restored-snapshot-content.yaml

Guarde o seguinte manifesto PersistentVolumeClaim como restored-pvc.yaml. O controlador de armazenamento do Kubernetes encontra um VolumeSnapshot com o nome restored-snapshot e, em seguida, tenta encontrar ou criar dinamicamente um PersistentVolume como origem de dados. Em seguida, pode usar este PVC num pod para aceder aos 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

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

Guarde o seguinte manifesto Pod como restored-pod.yaml, referindo-se ao PersistentVolumeClaim. O controlador CSI aprovisiona um PersistentVolume e preenche-o a partir do instantâneo.

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

Aplique o manifesto:
```
kubectl apply -f restored-pod.yaml
```

Verifique se o ficheiro foi restaurado:

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

Limpar

Para evitar incorrer em cobranças na sua Google Cloud conta pelos recursos usados nesta página, siga estes passos.

Elimine o VolumeSnapshot:
```
kubectl delete volumesnapshot my-snapshot
```
Nota: se o VolumeSnapshotClass de uma imagem instantânea de volume tiver deletionPolicy:Delete, o VolumeSnapshotContent correspondente e a imagem instantânea física no sistema de armazenamento também são eliminados. Se tiver um deletionPolicy:Retain, o GKE retém a imagem instantânea subjacente.

Elimine o VolumeSnapshotClass:

kubectl delete volumesnapshotclass my-snapshotclass

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

O que se segue?

Leia a documentação sobre a funcionalidade de instantâneo de volume do Kubernetes.
Saiba mais acerca da expansão do volume.
Saiba como instalar manualmente um controlador CSI.
Saiba mais sobre o armazenamento de blocos (disco persistente) para o GKE.

Faça uma cópia de segurança do armazenamento do Persistent Disk através de instantâneos de volumes Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Requisitos

Limitações

Práticas recomendadas

Antes de começar

Criar e usar um instantâneo de volume

Crie um PersistentVolumeClaim e um Deployment

Persistent Disk

Adicione um ficheiro de teste ao volume

Crie um objeto VolumeSnapshotClass

Persistent Disk

Crie um VolumeSnapshot

Elimine o ficheiro de teste

Restaure o instantâneo de volume

Persistent Disk

Verifique se o instantâneo foi restaurado com êxito

Importe um Snapshot pré-existente

Google Cloud consola

CLI do Google Cloud

Limpar

O que se segue?

Faça uma cópia de segurança do armazenamento do Persistent Disk através de instantâneos de volumes

Crie um `PersistentVolumeClaim` e um `Deployment`

Crie um objeto `VolumeSnapshotClass`

Crie um `VolumeSnapshot`