Crea copias de seguridad del almacenamiento en Persistent Disk mediante instantáneas de volumen

Autopilot estándar

En esta página se muestra cómo crear una copia de seguridad y restablecer el almacenamiento en Persistent Disk mediante instantáneas de volumen.

Para obtener una introducción, consulta Acerca de las instantáneas de volumen de Kubernetes.

Requisitos

Para usar instantáneas de volumen en GKE, debes cumplir con los siguientes requisitos:

• Usa un controlador CSI que admita instantáneas. El controlador de Persistent Disk en el árbol no admite instantáneas. Para crear y administrar instantáneas, debes usar el mismo controlador de CSI que el PersistentVolumeClaim (PVC) subyacente.

  • Para instantáneas de volumen de Persistent Disk (PD), usa el controlador de CSI de Persistent Disk para Compute Engine. El controlador CSI de Persistent Disk de Compute Engine se instala de forma predeterminada en los clústeres nuevos de Linux que ejecutan la versión 1.18.10-gke.2100 o posterior, o la versión 1.19.3-gke.2100 o posterior. También puedes habilitar el controlador de CSI de Persistent Disk de Compute Engine en un clúster existente.

  • Para obtener una lista de todos los controladores de CSI que admiten instantáneas, consulta la columna Other features en Controladores en la documentación de Kubernetes.

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

• Tienes un PersistentVolumeClaim existente para usar en una instantánea. El PersistentVolume que usas para una fuente de instantáneas debe ser administrado por un controlador CSI. Puedes verificar que usas un controlador CSI si verificas que la especificación de PersistentVolume tenga una sección csi con driver: pd.csi.storage.gke.io o filestore.csi.storage.gke.io. Si el controlador CSI aprovisiona de forma dinámica el PersistentVolume como se describe en las siguientes secciones, entonces lo administra 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 instantáneas de discos de Compute Engine cuando uses instantáneas Volume de Persistent Disk en GKE.

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

• Habilita la API de Google Kubernetes Engine.
Habilitar la API de Google Kubernetes Engine
• Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta el comando gcloud components update para obtener la versión más reciente. Es posible que las versiones anteriores de gcloud CLI no admitan la ejecución de los comandos que se describen en este documento.
  Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar la propiedad compute/region. Si usas principalmente clústeres zonales, configura compute/zone en su lugar. Cuando configuras 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 debas especificar la ubicación en ciertos comandos si la ubicación de tu clúster difiere de la predeterminada que estableciste.

Crea y usa una instantánea de volumen

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

1. Crea un PersistentVolumeClaim y un Deployment.
2. Agrega un archivo a PersistentVolume que usa Deployment.
3. Crear un VolumeSnapshotClass para configurar la instantánea.
4. Crear una instantánea de volumen del PersistentVolume
5. Borrar el archivo de prueba.
6. Restablecer el PersistentVolume en la instantánea que creaste.
7. Verificar que la restauración funcionó.

Para usar una instantánea de volumen, debes completar los siguientes pasos:

1. Crea un objeto VolumeSnapshotClass a fin de especificar el controlador CSI y la política de eliminación para tu instantánea.
2. Crea un objeto VolumeSnapshot para solicitar una instantánea de un PersistentVolumeClaim existente.
3. Haz referencia a VolumeSnapshot en una PersistentVolumeClaim para restablecer un volumen en esa instantánea o crear un volumen nuevo con la instantánea.

Crea 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 Persistent Disk para Compute Engine. Para obtener más información, consulta Usa el controlador Persistent Disk de CSI para Compute Engine.

   Para spec.storageClassName, puedes especificar cualquier clase de almacenamiento que use un controlador CSI compatible.

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

   kubectl apply -f my-deployment.yaml
   

5. Verifica el estado de Deployment:

   kubectl get deployment hello-app
   

   Es posible que 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
   

Agrega un archivo de prueba al volumen

1. Enumera los Pods en el Deployment:

   kubectl get pods -l app=hello-app
   

   El resultado es 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'
   

   Reemplaza POD_NAME por el nombre del Pod.

3. Verifica que el archivo exista:

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

   El resultado es similar al siguiente:

   Hello World!
   

Crea un objeto VolumeSnapshotClass

Crea un objeto VolumeSnapshotClass a fin de especificar el controlador CSI y deletionPolicy para la instantánea de volumen. Puedes hacer referencia a objetos VolumeSnapshotClass cuando creas objetos VolumeSnapshot.

1. Guarda el siguiente manifiesto como volumesnapshotclass.yaml.

   Persistent Disk

   Usa la versión de la API v1 para clústeres que ejecutan la versión 1.21 o 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 CSI de Persistent Disk de Compute Engine.

   • El campo deletionPolicy le indica a GKE qué hacer con el objeto VolumeSnapshotContent y la instantánea subyacente cuando se borra el objeto VolumeSnapshot vinculado. Especifica Delete para borrar el objeto VolumeSnapshotContent y la instantánea subyacente. Especifica Retain si deseas conservar VolumeSnapshotContent y la instantánea subyacente.

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

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

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

2. Aplica el manifiesto:

   kubectl apply -f volumesnapshotclass.yaml
   

Crea una VolumeSnapshot

Un objeto VolumeSnapshot es una solicitud de una instantánea de un objeto PersistentVolumeClaim existente. Cuando creas un objeto VolumeSnapshot, GKE lo crea y lo vincula de forma automática con un objeto VolumeSnapshotContent, que es un recurso en el clúster similar a un objeto PersistentVolume.

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

   kubectl apply -f volumesnapshot.yaml
   

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

3. Confirma que GKE creó el objeto VolumeSnapshotContents:

   kubectl get volumesnapshotcontents
   

   El resultado es similar al siguiente:

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

Después de crear el contenido de la instantánea Volume, el controlador CSI que especificaste en VolumeSnapshotClass crea una instantánea 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 de VolumeSnapshot del clúster, la instantánea está lista para usarse. Para verificar 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 es similar al siguiente:

NAME               READY
my-snapshot        true

Borra el archivo de prueba

1. Borra el archivo de prueba que creaste:

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

2. Verifica que el archivo ya no exista:

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

   El resultado es similar al siguiente:

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

Restablece la instantánea de volumen

Puedes hacer referencia a una VolumeSnapshot en un PersistentVolumeClaim para aprovisionar un volumen nuevo con datos de un volumen existente o restablecer un volumen a un estado que capturaste en la instantánea.

Para hacer referencia a una VolumeSnapshot en un PersistentVolumeClaim, agrega el campo dataSource a tu PersistentVolumeClaim. Se usa el mismo proceso, ya sea que VolumeSnapshotContents haga referencia a una imagen de disco o a una instantánea.

En este ejemplo, debes hacer referencia a la VolumeSnapshot que creaste en un PersistentVolumeClaim nueva y actualizar Deployment para que use la reclamación nueva.

1. Verifica si usas una instantánea de disco o de imagen, que difieren de la siguiente manera:

   • Instantáneas de disco: toma instantáneas con frecuencia y restablece de vez en cuando.
   • Instantáneas de imágenes: Toma instantáneas con poca frecuencia y restablece con frecuencia. Las instantáneas de imágenes también pueden tardar más en crearse que las instantáneas de discos.

   Para obtener más información, consulta Límites de frecuencia de instantáneas. Conocer el tipo de instantánea te ayudará si necesitas solucionar algún problema.

   Inspecciona el VolumeSnapshot:

   kubectl describe volumesnapshot SNAPSHOT_NAME
   

   El campo volumeSnapshotClassName especifica la clase de instantánea.

   kubectl describe volumesnapshotclass SNAPSHOT_CLASS_NAME
   

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

   Si no hay una clase de instantánea (por ejemplo, si la instantánea se creó de forma estática), inspecciona el VolumeSnapshotContents. sh kubectl describe volumesnapshotcontents SNAPSHOT_CONTENTS_NAME El formato del controlador de instantánea en el resultado indica el tipo de instantánea de la siguiente manera: * projects/PROJECT_NAME/global/snapshots/SNAPSHOT_NAME: instantánea de disco

   • projects/PROJECT_NAME/global/images/IMAGE_NAME: instantánea de la imagen

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

   kubectl apply -f pvc-restore.yaml
   

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

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

4. Aplica el manifiesto actualizado:

   kubectl apply -f my-deployment.yaml
   

Verifica que la instantánea se haya restablecido 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'

Reemplaza NEW_POD_NAME por el nombre del nuevo Pod que creó GKE.

El resultado es similar al siguiente:

   Hello World!

Importa una instantánea preexistente

Puedes usar una instantánea de volumen existente creada fuera del clúster actual para aprovisionar de forma manual el objeto VolumeSnapshotContents. Por ejemplo, puedes propagar un volumen en GKE con una instantánea de otro recurso deGoogle Cloud creado en un clúster diferente.

1. Ubica el nombre de tu instantánea.

   Consola de Google Cloud

   Ir a la página Instantáneas

   Google Cloud CLI

   Ejecuta el siguiente comando:

   gcloud compute snapshots list
   

   El resultado es 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 manifiesto:

   kubectl apply -f restored-snapshot.yaml
   

4. Guarda el siguiente manifiesto VolumeSnapshotContent como restored-snapshot-content.yaml. Reemplaza el campo snapshotHandle con el ID del proyecto y el nombre de la instantánea. Tanto volumeSnapshotRef.name como volumeSnapshotRef.namespace deben apuntar al VolumeSnapshot que se creó previamente para que la vinculación bidireccional sea 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. Aplica el manifiesto:

   kubectl apply -f restored-snapshot-content.yaml
   

6. Guarda el siguiente manifiesto PersistentVolumeClaim como restored-pvc.yaml. El controlador de almacenamiento de Kubernetes encontrará un VolumeSnapshot llamado restored-snapshot y, luego, intentará buscar o crear de forma dinámica un PersistentVolume como la fuente de datos. Luego, puedes usar este PVC en un Pod para acceder a los datos restablecidos.

   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 manifiesto:

   kubectl apply -f restored-pvc.yaml
   

8. Guarda el siguiente manifiesto Pod como restored-pod.yaml que hace referencia a PersistentVolumeClaim. El controlador CSI aprovisionará un PersistentVolume y lo propagará a partir 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 manifiesto:

   kubectl apply -f restored-pod.yaml
   

10. Verifica que el archivo se haya restablecido:

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

Limpia

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta página.

1. Borra VolumeSnapshot:

   kubectl delete volumesnapshot my-snapshot
   

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

2. Borra VolumeSnapshotClass:

   kubectl delete volumesnapshotclass my-snapshotclass
   

3. Borra Deployment:

   kubectl delete deployments hello-app
   

4. Borra los objetos PersistentVolumeClaim:

   kubectl delete pvc my-pvc pvc-restore
   

¿Qué sigue?

• Lee la documentación de Instantáneas de volumen de Kubernetes.
• Obtenga información sobre volume expansion (expansión de volumen).
• Obtén más información sobre cómo instalar un controlador CSI de forma manual.
• Obtén más información sobre el almacenamiento en bloque (Persistent Disk) para GKE.