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

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:

  • 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 o comando gcloud components update para obter a versão mais recente. As versões anteriores da CLI gcloud podem não suportar a execução dos comandos neste documento.

Criar e usar um instantâneo de volume

Os exemplos neste documento mostram como realizar as seguintes tarefas:

  1. Crie um PersistentVolumeClaim e um Deployment.
  2. Adicione um ficheiro ao PersistentVolume que o Deployment usa.
  3. Crie um VolumeSnapshotClass para configurar o instantâneo.
  4. Crie um instantâneo de volume do PersistentVolume.
  5. Elimine o ficheiro de teste.
  6. Restaure o PersistentVolume para o instantâneo que criou.
  7. Verifique se o restauro funcionou.

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

  1. Crie um objeto VolumeSnapshotClass para especificar o controlador CSI e a política de eliminação para a sua captura instantânea.
  2. Crie um objeto VolumeSnapshot para pedir um instantâneo de um PersistentVolumeClaim existente.
  3. 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

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

  2. Aplique o manifesto:

    kubectl apply -f my-pvc.yaml

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

  4. Aplique o manifesto:

    kubectl apply -f my-deployment.yaml

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

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

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

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

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

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

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

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

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

  1. Elimine o ficheiro de teste que criou:

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

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

  1. Verifique se está a usar um disco ou uma captura instantânea de imagem, que diferem da seguinte forma:

    • Instantâneos de discos: faça instantâneos com frequência e restaure-os com pouca frequência.
    • 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

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

  2. Aplique o manifesto:

    kubectl apply -f pvc-restore.yaml

  3. Atualize o ficheiro 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

Verifique se o instantâneo foi restaurado com êxito

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

  1. Localize o nome do instantâneo.

    Google Cloud consola

    Aceda à página Instantâneos

    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

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

  3. Aplique o manifesto:

    kubectl apply -f restored-snapshot.yaml

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

  5. Aplique o manifesto:

    kubectl apply -f restored-snapshot-content.yaml

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

  7. Aplique o manifesto:

    kubectl apply -f restored-pvc.yaml

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

  9. Aplique o manifesto:

    kubectl apply -f restored-pod.yaml

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

  1. Elimine o VolumeSnapshot:

    kubectl delete volumesnapshot my-snapshot

  2. Elimine o VolumeSnapshotClass:

    kubectl delete volumesnapshotclass my-snapshotclass

  3. Elimine o Deployment:

    kubectl delete deployments hello-app

  4. Elimine os PersistentVolumeClaim objetos:

    kubectl delete pvc my-pvc pvc-restore

O que se segue?