Usa instantáneas de volumen

En Google Kubernetes Engine (GKE), puedes usar la función de instantánea de volumen de Kubernetes para volúmenes persistentes en los clústeres de GKE.

Las instantáneas de volumen te permiten crear una copia del volumen en un momento específico. Puedes usar esta copia para hacer que un volumen vuelva a su estado anterior o para aprovisionar un volumen nuevo.

A partir de la versión 1.17 o posterior, puedes aprovisionar y adjuntar instantáneas de volumen con los siguientes componentes:

Requisitos

Debes cumplir con los siguientes requisitos para usar las instantáneas de volumen en GKE:

Usa un controlador CSI que admita instantáneas. Las instantáneas no son compatibles con el controlador de disco persistente en el árbol.
- El controlador CSI de disco persistente 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 disco persistente de Compute Engine en un clúster existente.
- También puedes implementar de forma automática el controlador CSI de Filestore. Para obtener una lista de todos los controladores CSI que admiten instantáneas, consulta la columna “Other features” en Controladores en la documentación de Kubernetes.
Usa versiones del plano de control (instancia principal) que sean versiones de GKE 1.17 o posteriores. Para usar el controlador CSI de disco persistente de Compute Engine en una VolumeSnapshot, usa la versión de GKE 1.17.6-gke.4 o posteriores. Para usar el controlador CSI de Filestore en una VolumeSnapshot, usa la versión de GKE 1.21 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.

Antes de comenzar

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

Asegúrate de que habilitaste la API de Google Kubernetes Engine.

Habilitar la API de Google Kubernetes Engine

Asegúrate de que instalaste el SDK de Cloud.

Establece la configuración de gcloud predeterminada mediante uno de los siguientes métodos:

Usa gcloud init si deseas ver una explicación sobre cómo configurar parámetros predeterminados.
Usa gcloud config para establecer el ID, la zona y la región del proyecto de manera individual.

Usa gcloud init

Si recibes el error One of [--zone, --region] must be supplied: Please specify location, completa esta sección.

Ejecuta gcloud init y sigue las instrucciones:
```
gcloud init
```
Si usas SSH en un servidor remoto, usa la marca --console-only para evitar que el comando abra un navegador:
```
gcloud init --console-only
```
Sigue las instrucciones a fin de autorizar a gcloud para que use tu cuenta de Google Cloud.
Crea una configuración nueva o selecciona una existente.
Elige un proyecto de Google Cloud.
Elige una zona predeterminada de Compute Engine para clústeres zonales o una región para clústeres regionales o de Autopilot.

Nota: Puedes anular esta configuración predeterminada en los comandos de gcloud mediante las marcas --project, --zone y --region.

Usa gcloud config

Establece tu ID del proyecto predeterminado:
```
gcloud config set project PROJECT_ID
```
Si trabajas con clústeres zonales, establece tu zona de procesamiento predeterminada:
```
gcloud config set compute/zone COMPUTE_ZONE
```
Si trabajas con clústeres de Autopilot o regionales, configura tu región de procesamiento predeterminada:
```
gcloud config set compute/region COMPUTE_REGION
```
Actualiza gcloud a la versión más reciente:
```
gcloud components update
```

Nota: Puedes anular esta configuración predeterminada en los comandos de gcloud mediante las marcas --project, --zone y --region.

Crea y usa una instantánea de volumen

En los ejemplos de este documento, se muestra cómo hacer lo siguiente:

Crear un PersistentVolumeClaim y Deployment.
Agregar un archivo al recurso PersistentVolume que usa el 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:
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: my-pvc
spec:
  storageClassName: standard-rwo
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
```
Para spec.storageClassName, puedes especificar cualquier clase de almacenamiento que use un controlador CSI compatible. En este ejemplo, se usa la clase de almacenamiento standard-rwo instalada de forma predeterminada con el controlador CSI del disco persistente de Compute Engine. Para obtener más información, consulta Usa el controlador CSI del disco persistente de Compute Engine.
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 del Deployment:
```
kubectl get deployment hello-app
```
Nota: Es posible que el Deployment tarde un poco en estar listo.

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 con el nombre del 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. Puedes usar las versiones v1beta1 o v1 de la API, según la versión de GKE en tu clúster.
v1beta1
Usa la versión de la API v1beta1 para clústeres que ejecutan las versiones 1.21 o anteriores.
```
apiVersion: snapshot.storage.k8s.io/v1beta1
kind: VolumeSnapshotClass
metadata:
  name: my-snapshotclass
driver: pd.csi.storage.gke.io
deletionPolicy: Delete
```
v1
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 campo driver es el controlador CSI que se usa para aprovisionar la instantánea. pd.csi.storage.gke.io usa el controlador CSI de disco persistente 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. También puedes especificar Retain si deseas conservar el 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. Puedes usar la versión de API v1beta1 o v1.

v1beta1

Usa la versión de la API v1beta1 para clústeres que ejecutan las versiones 1.21 o anteriores.

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

v1

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: 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 de volumen, 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.

Para confirmar que GKE creó el objeto VolumeSnapshotContents, ejecuta el siguiente comando:

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 de volumen, 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 instantánea de volumen 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 está listo 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 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.

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

Guarda el siguiente manifiesto como pvc-restore.yaml:

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

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

Actualiza my-deployment.yaml para usar la nueva PersistentVolumeClaim:

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

A fin de verificar que la instantánea se restableció de forma correcta, obtén el nombre del Pod nuevo 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 con el nombre del pod de GKE nuevo creado.

El resultado es similar al siguiente:

Hello World!

Realice una limpieza

Borra VolumeSnapshot:
```
kubectl delete volumesnapshot my-snapshot
```
Nota: Si el VolumeSnapshotClass de una instantánea de volumen tiene deletionPolicy:Delete, también se borran la VolumeSnapshotContent correspondiente 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 la implementación:
```
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 forma manual.

Usa instantáneas de volumen

Requisitos

Antes de comenzar

Usa gcloud init

Usa gcloud config

Crea y usa una instantánea de volumen

Crea un PersistentVolumeClaim y un Deployment

Agrega un archivo de prueba al volumen

Crea un objeto VolumeSnapshotClass

v1beta1

v1

Crea una VolumeSnapshot

v1beta1

v1

Borra el archivo de prueba

Restablece la instantánea de volumen

Verifica que la instantánea se haya restablecido correctamente

Realice una limpieza

¿Qué sigue?

Crea un objeto `VolumeSnapshotClass`