Crea una copia de seguridad del almacenamiento de Filestore 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 de Filestore mediante instantáneas de volumen de Kubernetes.

Crear una instantánea de volumen de Kubernetes es equivalente a crear una copia de seguridad de Filestore. Para obtener más informació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:

Debes implementar el controlador de CSI de Filestore, que admite los siguientes niveles de servicio de Filestore:
- HDD básico con GKE versión 1.21 o posterior
- SSD básico con versión 1.21 de GKE o posterior
- Zonal (de 10 TiB a 100 TiB) con la versión 1.27 de GKE o una posterior
- Enterprise con la versión 1.25 de GKE o posterior
Usa las versions 1.17 o posteriores del plano de control. Para usar el controlador CSI de Filestore en un VolumeSnapshot, usa el número de versión de GKE aplicable a tu nivel de servicio.

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

Los volúmenes de instantáneas tienen las mismas restricciones de tamaño que los volúmenes regulares. Por ejemplo, las instantáneas de Filestore deben ser mayores o iguales que 1 TiB en tamaño para el nivel HDD básico.
El controlador de CSI de Filestore no admite el aprovisionamiento dinámico ni los flujos de trabajo de copia de seguridad para los siguientes niveles de servicio de Filestore:
- Zonal (de 1 TiB a 9.75 TiB)
- Regional
Solo puedes crear una copia de seguridad de un recurso compartido por instancia a la vez. Con respecto a los grupos de almacenamiento, las solicitudes de copia de seguridad emitidas desde dos recursos compartidos diferentes de dos instancias diferentes de Filestore se ejecutarán de manera simultánea.
Las copias de seguridad de un solo recurso compartido solo se pueden restablecer en volúmenes de recurso compartido único. Con el controlador de CSI de Filestore, solo puedes restablecer un volumen de recurso compartido único en una instancia de Filestore nueva.
- La instancia nueva debe usar el mismo nivel de servicio que la copia de seguridad.
- La instancia nueva debe coincidir con la capacidad mínima que la copia de seguridad.
No se admiten las operaciones backup restore de Filestore a la fuente o a una instancia de Filestore existente. Para obtener una lista completa de las limitaciones de las funciones, consulta Limitaciones de las funciones de la copia de seguridad de Filestore.
No se admiten las copias de seguridad de archivos compartidos múltiples.

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, initialize gcloud CLI. Si ya instalaste gcloud CLI, ejecuta gcloud components update para obtener la versión más reciente.
Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar las propiedades compute/region y compute/zone. Cuando configuras las ubicaciones predeterminadas, puedes evitar errores en la gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location.

Crea y usa una instantánea de volumen

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

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

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

Crea un objeto VolumeSnapshotClass a fin de especificar el controlador CSI y la política de eliminación para tu instantánea.
Crea un objeto VolumeSnapshot para solicitar una instantánea de un PersistentVolumeClaim existente.
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`.

Para crear el objeto PersistentVolumeClaim, guarda el siguiente manifiesto como my-pvc.yaml:
Filestore
```
 apiVersion: v1
 kind: PersistentVolumeClaim
 metadata:
   name: my-pvc
 spec:
   storageClassName: enterprise-rwx
   accessModes:
   - ReadWriteMany
   resources:
     requests:
       storage: 1Ti
```
En este ejemplo se crea una PVC de nivel empresarial de Filestore. Para obtener más información, consulta Accede a instancias de Filestore con el controlador de CSI de Filestore.
Para spec.storageClassName, puedes especificar cualquier clase de almacenamiento que use un controlador CSI compatible.
Aplica el manifiesto:
```
kubectl apply -f my-pvc.yaml
```

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

Aplica el manifiesto:
```
kubectl apply -f my-deployment.yaml
```
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

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

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

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.

Guarda el siguiente manifiesto como volumesnapshotclass.yaml.
Filestore
```
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: my-snapshotclass
driver: filestore.csi.storage.gke.io
parameters:
  type: backup
deletionPolicy: Delete
```
En este ejemplo:
- El controlador de CSI usa el campo driver para aprovisionar la instantánea. En este ejemplo, filestore.csi.storage.gke.io usa el controlador de CSI de Filestore.
- 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.

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.

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

Aplica el manifiesto:
```
kubectl apply -f volumesnapshot.yaml
```
Después de crear una instantánea 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.

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

Borra el archivo de prueba que creaste:

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

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.

Para hacer referencia a una VolumeSnapshot en un PersistentVolumeClaim, agrega el campo dataSource a tu PersistentVolumeClaim.

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.

Guarda el siguiente manifiesto como pvc-restore.yaml:

Filestore

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-restore
spec:
  dataSource:
    name: my-snapshot
    kind: VolumeSnapshot
    apiGroup: snapshot.storage.k8s.io
  storageClassName: enterprise-rwx
  accessModes:
  - ReadWriteMany
  resources:
    requests:
      storage: 1Ti

Aplica el manifiesto:
```
kubectl apply -f pvc-restore.yaml
```

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

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

Aplica el manifiesto actualizado:
```
kubectl apply -f my-deployment.yaml
```

Verifica que la instantánea se haya restablecido correctamente

Obtén el nombre de la Pod nueva 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 Pod nuevo 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 de Google Cloud creado en un clúster diferente.

Ubica el nombre de tu instantánea.

Consola de Google Cloud

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

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

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

Aplica el manifiesto:

kubectl apply -f restored-snapshot.yaml

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: filestore.csi.storage.gke.io
  source:
    snapshotHandle: projects/PROJECT_ID/global/snapshots/SNAPSHOT_NAME
  volumeSnapshotRef:
    kind: VolumeSnapshot
    name: restored-snapshot
    namespace: default

Aplica el manifiesto:

kubectl apply -f restored-snapshot-content.yaml

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: enterprise-rwx
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
```
Aplica el manifiesto:
```
kubectl apply -f restored-pvc.yaml
```

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

Aplica el manifiesto:
```
kubectl apply -f restored-pod.yaml
```

Verifica que el archivo se haya restablecido:

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

Realiza una limpieza

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

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.

Borra VolumeSnapshotClass:

kubectl delete volumesnapshotclass my-snapshotclass

Borra Deployment:
```
kubectl delete deployments hello-app
```
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 acerca de Filestore como una opción de almacenamiento de archivos para GKE.

Crea una copia de seguridad del almacenamiento de Filestore mediante instantáneas de volumen

Requisitos

Limitaciones

Antes de comenzar

Crea y usa una instantánea de volumen

Crea un PersistentVolumeClaim y un Deployment.

Filestore

Agrega un archivo de prueba al volumen

Crea un objeto VolumeSnapshotClass

Filestore

Crea una VolumeSnapshot

Borra el archivo de prueba

Restablece la instantánea de volumen

Filestore

Verifica que la instantánea se haya restablecido correctamente

Importa una instantánea preexistente

Consola de Google Cloud

Google Cloud CLI

Realiza una limpieza

¿Qué sigue?

Crea un `PersistentVolumeClaim` y un `Deployment`.

Crea un objeto `VolumeSnapshotClass`

Crea una `VolumeSnapshot`