Crear copias de seguridad del almacenamiento de Persistent Disk mediante capturas de volumen

Autopilot Standard

En esta página se explica cómo crear copias de seguridad y restaurar el almacenamiento en discos persistentes mediante capturas de volumen.

Para obtener una introducción, consulta Acerca de las copias de seguridad de volúmenes de Kubernetes.

Requisitos

Para usar capturas de volumen en GKE, debes cumplir los siguientes requisitos:

• Usa un controlador de CSI que admita las copias de seguridad. El controlador Persistent Disk integrado no admite instantáneas. Para crear y gestionar capturas, debes usar el mismo controlador de CSI que el PersistentVolumeClaim (PVC) subyacente.

  • Para las capturas de volumen de Persistent Disk (PD), usa el controlador de CSI para Persistent Disk en Compute Engine. El controlador de CSI para Persistent Disk en Compute Engine se instala de forma predeterminada en los clústeres Linux nuevos que ejecutan GKE 1.18.10-gke.2100 o versiones posteriores, o bien 1.19.3-gke.2100 o versiones posteriores. También puedes habilitar el controlador de CSI para Persistent Disk en Compute Engine en un clúster.

  • Para ver una lista de todos los controladores CSI que admiten snapshots, consulta la columna Otras funciones de Controladores en la documentación de Kubernetes.

• Usa las versiones 1.17 o posteriores del plano de control. Para usar el controlador de CSI para Persistent Disk en Compute Engine en un VolumeSnapshot, usa GKE 1.17.6-gke.4 o una versión posterior.

• Tener un PersistentVolumeClaim que quieras usar para una captura. El PersistentVolume que uses para una fuente de captura debe gestionarse mediante un controlador CSI. Para comprobar si estás usando un controlador CSI, verifica que la especificación PersistentVolume tenga una sección csi con driver: pd.csi.storage.gke.io o filestore.csi.storage.gke.io. Si el PersistentVolume se aprovisiona dinámicamente mediante el controlador CSI, tal como se describe en las siguientes secciones, lo gestiona el controlador CSI.

Limitaciones

Todas las restricciones para crear una instantánea de disco en Compute Engine también se aplican a GKE.

Prácticas recomendadas

Asegúrate de seguir las prácticas recomendadas para las capturas de discos de Compute Engine cuando uses capturas de Volume Persistent Disk en GKE.

Antes de empezar

Antes de empezar, asegúrate de que has realizado las siguientes tareas:

• Habilita la API de Google Kubernetes Engine.
Habilitar la API de Google Kubernetes Engine
• Si quieres usar Google Cloud CLI para esta tarea, instálala y, a continuación, inicialízala. Si ya has instalado la CLI de gcloud, obtén la versión más reciente ejecutando el comando gcloud components update. Es posible que las versiones anteriores de la interfaz de línea de comandos de gcloud no admitan la ejecución de los comandos de este documento.
  Nota: Si ya tienes instalada la CLI gcloud, asegúrate de definir la compute/region propiedad. Si usas principalmente clústeres zonales, define compute/zone en su lugar. Si defines una ubicación predeterminada, puedes evitar errores en gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location. Es posible que tengas que especificar la ubicación en determinados comandos si la ubicación de tu clúster es diferente de la predeterminada que hayas definido.

Crear y usar una captura de volumen

En los ejemplos de este documento se muestra cómo realizar las siguientes tareas:

1. Crea un PersistentVolumeClaim y un Deployment.
2. Añade un archivo al PersistentVolume que usa el Deployment.
3. Crea una VolumeSnapshotClass para configurar la captura.
4. Crea una captura de volumen de PersistentVolume.
5. Elimina el archivo de prueba.
6. Restaura el PersistentVolume a la captura que has creado.
7. Verifica que la restauración se haya realizado correctamente.

Para usar una copia de seguridad de un volumen, debes completar los siguientes pasos:

1. Crea un objeto VolumeSnapshotClass para especificar el controlador CSI y la política de eliminación de tu snapshot.
2. Crea un objeto VolumeSnapshot para solicitar una captura de un PersistentVolumeClaim.
3. Haz referencia a la VolumeSnapshot en un PersistentVolumeClaim para restaurar un volumen a esa captura o crear un volumen nuevo a partir de la captura.

Crear un PersistentVolumeClaim y un Deployment

1. Para crear el objeto PersistentVolumeClaim, guarda el siguiente manifiesto como my-pvc.yaml:

   Persistent Disk

    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: my-pvc
    spec:
      storageClassName: standard-rwo
      accessModes:
      - ReadWriteOnce
      resources:
        requests:
          storage: 1Gi
   

   En este ejemplo se usa la clase de almacenamiento standard-rwo instalada de forma predeterminada con el controlador de CSI para Persistent Disk en Compute Engine. Para obtener más información, consulta Usar el controlador de CSI para Persistent Disk en Compute Engine.

   En el caso de spec.storageClassName, puedes especificar cualquier clase de almacenamiento que utilice un controlador CSI compatible.

2. Aplica el archivo de manifiesto:

   kubectl apply -f my-pvc.yaml
   

3. Para crear un Deployment, guarda el siguiente manifiesto 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. Aplica el archivo de manifiesto:

   kubectl apply -f my-deployment.yaml
   

5. Comprueba el estado de la Deployment:

   kubectl get deployment hello-app
   

   Puede que el Deployment tarde un poco en estar listo. Puedes ejecutar el comando anterior hasta que veas un resultado similar al siguiente:

   NAME        READY   UP-TO-DATE   AVAILABLE   AGE
   hello-app   1/1     1            1           2m55s
   

Añade un archivo de prueba al volumen

1. Enumera los Pods de la Deployment:

   kubectl get pods -l app=hello-app
   

   El resultado debería ser similar al siguiente:

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

2. Crea un archivo de prueba en un Pod:

   kubectl exec POD_NAME \
       -- sh -c 'echo "Hello World!" > /usr/share/hello/hello.txt'
   

   Sustituye POD_NAME por el nombre de la Pod.

3. Comprueba que el archivo exista:

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

   El resultado debería ser similar al siguiente:

   Hello World!
   

Crear un objeto VolumeSnapshotClass

Crea un objeto VolumeSnapshotClass para especificar el controlador CSI y deletionPolicy de tu instantánea de volumen. Puedes hacer referencia a objetos VolumeSnapshotClass al crear objetos VolumeSnapshot.

1. Guarda el siguiente archivo de manifiesto como volumesnapshotclass.yaml.

   Persistent Disk

   Usa la versión v1 de la API para los clústeres que ejecuten la versión 1.21 o una posterior.

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshotClass
   metadata:
     name: my-snapshotclass
   driver: pd.csi.storage.gke.io
   deletionPolicy: Delete
   

   En este ejemplo:

   • El controlador de CSI usa el campo driver para aprovisionar la instantánea. En este ejemplo, pd.csi.storage.gke.io usa el controlador de CSI para Persistent Disk en Compute Engine.

   • El campo deletionPolicy indica a GKE qué debe hacer con el objeto VolumeSnapshotContent y la instantánea subyacente cuando se elimine el objeto VolumeSnapshot enlazado. Especifica Delete para eliminar el objeto VolumeSnapshotContent y la instantánea subyacente. Especifica Retain si quieres conservar el VolumeSnapshotContent y la instantánea subyacente.

     Para usar una ubicación de almacenamiento personalizada, añade un parámetro storage-locations a la clase de la instantánea. Para usar este parámetro, tus clústeres deben usar la versión 1.21 o una 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 crear una imagen de disco, añade lo siguiente al campo parameters:

     parameters:
       snapshot-type: images
       image-family: IMAGE_FAMILY
     

     Sustituye IMAGE_FAMILY por el nombre de la familia de imágenes que prefieras, como preloaded-data.

2. Aplica el archivo de manifiesto:

   kubectl apply -f volumesnapshotclass.yaml
   

Crear un VolumeSnapshot

Un objeto VolumeSnapshot es una solicitud de una instantánea de un objeto PersistentVolumeClaim. Cuando creas un objeto VolumeSnapshot, GKE lo crea y lo vincula automáticamente con un objeto VolumeSnapshotContent, que es un recurso de tu clúster, como un objeto PersistentVolume.

1. Guarda el siguiente archivo de manifiesto como volumesnapshot.yaml.

   apiVersion: snapshot.storage.k8s.io/v1
   kind: VolumeSnapshot
   metadata:
     name: my-snapshot
   spec:
     volumeSnapshotClassName: my-snapshotclass
     source:
       persistentVolumeClaimName: my-pvc
   

2. Aplica el archivo de manifiesto:

   kubectl apply -f volumesnapshot.yaml
   

   Después de crear una Volume instantánea, GKE crea un objeto VolumeSnapshotContent correspondiente en el clúster. Este objeto almacena la instantánea y las vinculaciones de los objetos VolumeSnapshot. No interactúas directamente con los objetos VolumeSnapshotContents.

3. Confirma que GKE ha creado el objeto VolumeSnapshotContents:

   kubectl get volumesnapshotcontents
   

   El resultado debería ser similar al siguiente:

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

Una vez que se haya creado el contenido de la captura Volume, el controlador CSI que hayas especificado en VolumeSnapshotClass creará una captura en el sistema de almacenamiento correspondiente. Una vez que GKE crea una instantánea en el sistema de almacenamiento y la vincula a un objeto VolumeSnapshot en el clúster, la instantánea está lista para usarse. Para comprobar el estado, ejecuta el siguiente comando:

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

Si la instantánea está lista para usarse, el resultado será similar al siguiente:

NAME               READY
my-snapshot        true

Eliminar el archivo de prueba

1. Elimina el archivo de prueba que has creado:

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

2. Comprueba que el archivo ya no existe:

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

   El resultado debería ser similar al siguiente:

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

Restaurar la captura del volumen

Puedes hacer referencia a una VolumeSnapshot en un PersistentVolumeClaim para aprovisionar un volumen nuevo con datos de un volumen ya creado o restaurar un volumen a un estado que hayas capturado en la captura.

Para hacer referencia a un VolumeSnapshot en un PersistentVolumeClaim, añade el campo dataSource al PersistentVolumeClaim. Se sigue el mismo proceso tanto si VolumeSnapshotContents hace referencia a una imagen de disco como a una instantánea.

En este ejemplo, se hace referencia al VolumeSnapshot que has creado en un nuevo PersistentVolumeClaim y se actualiza el Deployment para que use la nueva reclamación.

1. Comprueba si estás usando una copia de seguridad de disco o de imagen, que se diferencian en lo siguiente:

   • Capturas de disco: haz capturas con frecuencia y restaura con poca frecuencia.
   • Capturas de imágenes: haz capturas con poca frecuencia y restaura con frecuencia. Las capturas de imágenes también pueden tardar más en crearse que las capturas de discos.

   Para obtener más información, consulta Límites de frecuencia de las copias de seguridad. Conocer el tipo de copia te ayudará a solucionar cualquier problema.

   Inspecciona el VolumeSnapshot:

   kubectl describe volumesnapshot SNAPSHOT_NAME
   

   El campo volumeSnapshotClassName especifica la clase de la instantánea.

   kubectl describe volumesnapshotclass SNAPSHOT_CLASS_NAME
   

   El parámetro snapshot-type especificará snapshots o images. Si no se indica, el valor predeterminado es snapshots.

   Si no hay ninguna clase de captura (por ejemplo, si la captura se ha creado de forma estática), inspecciona VolumeSnapshotContents. sh kubectl describe volumesnapshotcontents SNAPSHOT_CONTENTS_NAME El formato de un identificador de captura en la salida indica el tipo de captura, de la siguiente manera: * projects/PROJECT_NAME/global/snapshots/SNAPSHOT_NAME: captura de disco

   • projects/PROJECT_NAME/global/images/IMAGE_NAME: imagen de la captura

1. Guarda el siguiente archivo de manifiesto 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
   

   Nota: El espacio de nombres de PersistentVolumeClaim debe ser el mismo que el espacio de nombres de VolumeSnapshot.

2. Aplica el archivo de manifiesto:

   kubectl apply -f pvc-restore.yaml
   

3. Actualiza el archivo my-deployment.yaml para usar el nuevo PersistentVolumeClaim:

   ...
   volumes:
   - name: my-volume
     persistentVolumeClaim:
       claimName: pvc-restore
   

4. Aplica el archivo de manifiesto actualizado:

   kubectl apply -f my-deployment.yaml
   

Comprobar que la instantánea se ha restaurado correctamente

1. Obtén el nombre del nuevo Pod que GKE crea para el Deployment actualizado:

    kubectl get pods -l app=hello-app
   

Verifica que el archivo de prueba exista:

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

Sustituye NEW_POD_NAME por el nombre del nuevo Pod que ha creado GKE.

El resultado debería ser similar al siguiente:

   Hello World!

Importar una copia de seguridad

Puedes usar una instantánea de volumen creada fuera del clúster actual para aprovisionar manualmente el objeto VolumeSnapshotContents. Por ejemplo, puedes rellenar un volumen en GKE con una instantánea de otroGoogle Cloud recurso creado en otro clúster.

1. Busca el nombre de la copia.

   Google Cloud consola

   Ir a la página Capturas

   Google Cloud CLI

   Ejecuta el siguiente comando:

   gcloud compute snapshots list
   

   El resultado debería ser similar al siguiente:

   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. Guarda el siguiente manifiesto 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. Aplica el archivo de manifiesto:

   kubectl apply -f restored-snapshot.yaml
   

4. Guarda el siguiente manifiesto VolumeSnapshotContent como restored-snapshot-content.yaml. Sustituye el campo snapshotHandle por el ID de tu proyecto y el nombre de la instantánea. Tanto volumeSnapshotRef.name como volumeSnapshotRef.namespace deben apuntar al VolumeSnapshot creado anteriormente para que el enlace bidireccional sea válido.

   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. Aplica el archivo de manifiesto:

   kubectl apply -f restored-snapshot-content.yaml
   

6. Guarda el siguiente manifiesto PersistentVolumeClaim como restored-pvc.yaml. El controlador de almacenamiento de Kubernetes buscará un VolumeSnapshot llamado restored-snapshot y, a continuación, intentará encontrar o crear dinámicamente un PersistentVolume como fuente de datos. Después, puedes usar este PVC en un pod para acceder a los datos 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. Aplica el archivo de manifiesto:

   kubectl apply -f restored-pvc.yaml
   

8. Guarda el siguiente manifiesto Pod como restored-pod.yaml haciendo referencia a la PersistentVolumeClaim. El controlador de CSI aprovisionará un PersistentVolume y lo rellenará con la información de la instantánea.

   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. Aplica el archivo de manifiesto:

   kubectl apply -f restored-pod.yaml
   

10. Verifica que el archivo se haya restaurado:

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

Limpieza

Para evitar que se apliquen cargos en tu Google Cloud cuenta por los recursos utilizados en esta página, sigue estos pasos.

1. Elimina el VolumeSnapshot:

   kubectl delete volumesnapshot my-snapshot
   

   Nota: Si el VolumeSnapshotClass de una instantánea de volumen tiene deletionPolicy:Delete, también se eliminan el VolumeSnapshotContent correspondiente y la instantánea física del sistema de almacenamiento. Si tiene un deletionPolicy:Retain, GKE conserva la instantánea subyacente.

2. Elimina el VolumeSnapshotClass:

   kubectl delete volumesnapshotclass my-snapshotclass
   

3. Elimina el Deployment:

   kubectl delete deployments hello-app
   

4. Elimina los PersistentVolumeClaim objetos:

   kubectl delete pvc my-pvc pvc-restore
   

Siguientes pasos

• Consulta la documentación sobre creación de copias de seguridad de volúmenes de Kubernetes.
• Consulta información sobre la ampliación de volumen.
• Consulta cómo instalar manualmente un controlador de CSI.
• Consulta información sobre el almacenamiento en bloque (Persistent Disk) para GKE.