Es posible que parte o toda la información de esta página no se aplique a Cloud de Confiance de S3NS. Para obtener más información, consulta Diferencias con respecto a Google Cloud.

Esta página se ha traducido con Cloud Translation API.

Crear copias de seguridad del almacenamiento de Filestore mediante capturas de volumen

Autopilot Standard

En esta página se explica cómo crear copias de seguridad y restaurar el almacenamiento de Filestore mediante capturas de volúmenes de Kubernetes.

Crear una instantánea de volumen de Kubernetes es lo mismo que crear una copia de seguridad de Filestore. Para obtener más información, consulta el artículo Acerca de las capturas de volúmenes de Kubernetes.

Requisitos

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

Debes desplegar el controlador de CSI para Filestore. Solo se admiten los siguientes niveles de servicio de Filestore:
- HDD básico con GKE 1.21 o versiones posteriores
- HDD básico (de 100 GiB a 63,9 TiB) con la versión 1.33 de GKE o una posterior
- SSD básica con GKE 1.21 o una versión posterior
- Zonal (de 1 a 9,75 TiB) con la versión 1.31 o posterior de GKE
- Zonal (de 10 a 100 TiB) con GKE versión 1.27 o posterior
- Regional con la versión 1.33.4-gke.1172000 de GKE o una posterior
- Enterprise con la versión 1.25 o posterior de GKE
Usa las versiones 1.17 o posteriores del plano de control. Para usar el controlador de CSI para Filestore en un VolumeSnapshot, usa el número de versión de GKE aplicable a tu nivel de servicio.

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

Los volúmenes de instantánea tienen las mismas restricciones de tamaño que los volúmenes normales. Por ejemplo, las copias de seguridad de Filestore deben tener un tamaño igual o superior a 1 TiB en el nivel HDD básico.
El controlador CSI de Filestore no admite el aprovisionamiento dinámico ni los flujos de trabajo de copia de seguridad del nivel de servicio regional de Filestore:
- Solo puedes crear una copia de seguridad de un recurso compartido por instancia a la vez. Esto significa que no puedes crear una copia de seguridad multicompartida ni restaurar una copia de seguridad en una instancia con varios recursos compartidos. Sin embargo, las solicitudes de copia de seguridad de dos recursos compartidos diferentes en dos instancias de Filestore diferentes se ejecutarán al mismo tiempo.
- Puedes restaurar una copia de seguridad de una instancia básica en la instancia de origen del mismo nivel de servicio, en una instancia que ya tengas o en una nueva. Si eliges una instancia nueva, puedes elegir entre una instancia de HDD básico y una de SSD básico, independientemente del nivel de la instancia de origen.
- No puedes restaurar instancias zonales, regionales y empresariales en una instancia de origen o en una instancia ya creada, sino solo en una instancia nueva. El nuevo nivel de instancia no tiene por qué coincidir con el de la instancia de origen. Por ejemplo, puedes restaurar una copia de seguridad de una instancia regional en una instancia zonal. La capacidad aprovisionada de la nueva instancia debe ser igual o superior a la de la instancia de origen.
Para ver una lista completa de las limitaciones de las funciones, consulta Limitaciones de la función de copia de seguridad de Filestore.

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:

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

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

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

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 un PVC de Filestore de nivel Enterprise. Para obtener más información, consulta Acceder a instancias de Filestore con el controlador de CSI de Filestore.
En el caso de spec.storageClassName, puedes especificar cualquier clase de almacenamiento que utilice un controlador CSI compatible.
Aplica el archivo de 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 archivo de manifiesto:
```
kubectl apply -f my-deployment.yaml
```
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

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

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.

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.

Guarda el siguiente archivo de 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 para Filestore.
- 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.

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.

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

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.

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

Elimina el archivo de prueba que has creado:

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

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 un VolumeSnapshot en un PersistentVolumeClaim para aprovisionar un nuevo volumen con datos de un volumen ya creado.

Para hacer referencia a un VolumeSnapshot en un PersistentVolumeClaim, añade el campo dataSource al PersistentVolumeClaim.

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.

Guarda el siguiente archivo de 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 archivo de manifiesto:
```
kubectl apply -f pvc-restore.yaml
```

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

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

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

Comprobar que la instantánea se ha restaurado correctamente

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 otroCloud de Confiance recurso creado en otro clúster.

Busca el nombre de la copia.

Cloud de Confiance 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

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

kubectl apply -f restored-snapshot.yaml

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

Aplica el archivo de manifiesto:

kubectl apply -f restored-snapshot-content.yaml

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: enterprise-rwx
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

Aplica el archivo de manifiesto:
```
kubectl apply -f restored-pvc.yaml
```

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

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

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 Cloud de Confiance by S3NS cuenta por los recursos utilizados en esta página, sigue estos pasos.

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.

Elimina el VolumeSnapshotClass:

kubectl delete volumesnapshotclass my-snapshotclass

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

Crear copias de seguridad del almacenamiento de Filestore mediante capturas de volumen

Requisitos

Limitaciones

Antes de empezar

Crear y usar una captura de volumen

Crear un PersistentVolumeClaim y un Deployment

Filestore

Añade un archivo de prueba al volumen

Crear un objeto VolumeSnapshotClass

Filestore

Crear un VolumeSnapshot

Eliminar el archivo de prueba

Restaurar la captura del volumen

Filestore

Comprobar que la instantánea se ha restaurado correctamente

Importar una copia de seguridad

Cloud de Confiance consola

Google Cloud CLI

Limpieza

Siguientes pasos

Crear un `PersistentVolumeClaim` y un `Deployment`

Crear un objeto `VolumeSnapshotClass`

Crear un `VolumeSnapshot`