Usa discos persistentes preexistentes como PersistentVolumes

Autopilot Estándar

---

En esta página, se explica cómo crear un PersistentVolume mediante discos persistentes existentes propagados con datos, y cómo usar el PersistentVolume en un Pod.

Descripción general

Hay dos situaciones comunes en las que se usa un disco persistente preexistente.

• Crear un PersistentVolumeClaim y un PersistentVolume de forma manual, vincularlos y hacer referencia al PersistentVolumeClaim en una especificación del Pod.
• Usar un StatefulSet para generar PersistentVolumeClaims de forma automática, que están vinculados a los PersistentVolumes generados manualmente correspondientes a una serie de discos persistentes preexistentes.

En los ejemplos de esta página, se usan discos persistentes de Compute Engine existentes.

Si bien ext4 es el tipo de sistema de archivos predeterminado, puedes usar un disco persistente preexistente con el sistema de archivos xfs en su lugar, siempre que tu imagen de nodo lo admita. Para usar un disco xfs, cambia spec.csi.fsType por xfs en el manifiesto de PersistentVolume.

Windows no admite el tipo de sistema de archivos ext4. Debes usar el sistema de archivos NTFS para los grupos de nodos de Windows Server. Para usar un disco NTFS, cambia spec.csi.fsType por NTFS en el manifiesto de PersistentVolume.

Nota: Si el tipo de sistema de archivos del disco persistente que usas no coincide con el fsType que especificas en el manifiesto de PersistentVolume, los pods que creas que consumen los volúmenes no se iniciarán y verás errores en la descripción del Pod. Del mismo modo, los volúmenes de CSI de Persistent Disk solo admiten una partición. Los volúmenes creados fuera de GKE con varias particiones no se pueden usar con esta técnica.

Antes de comenzar

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

• Habilita la API de Kubernetes Engine de Google.
Habilitar la API de Kubernetes Engine de Google
• Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa 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 CLI de gcloud como el siguiente: One of [--zone, --region] must be supplied: Please specify location.

• Asegúrate de tener discos persistentes existentes. Para aprovisionar un disco, consulta Aprovisiona discos persistentes regionales.
• Asegúrate de que tu clúster use el controlador CSI de disco persistente de Compute Engine.

Usa un PersistentVolumeClaim vinculado al PersistentVolume

Sigue estos pasos para que un contenedor acceda a tu disco persistente preexistente:

1. Aprovisiona el disco persistente existente como un PersistentVolume.
2. Vincula el PersistentVolume a un PersistentVolumeClaim.
3. Otorga acceso al PersistentVolume a los contenedores del Pod.

Crea el PersistentVolume y el PersistentVolumeClaim

Hay varias formas de vincular una PersistentVolumeClaim a un PersistentVolume específico. Por ejemplo, el siguiente manifiesto YAML crea un nuevo PersistentVolume y PersistentVolumeClaim y, luego, vincula la reclamación al volumen con un claimRef, lo que garantiza que el PersistentVolume solo se pueda vincular a esa PersistentVolumeClaim.

Para vincular un PersistentVolume a una PersistentVolumeClaim, el storageClassName de ambos recursos debe coincidir, así como capacity, accessModes y volumeMode. Puedes omitir el storageClassName, pero debes especificar "" para evitar que Kubernetes use el StorageClass predeterminado.

No es necesario que storageClassName se refiera a un objeto StorageClass existente. Si lo único que necesitas es vincular la reclamación a un volumen, puedes usar el nombre que quieras. Sin embargo, si necesitas una funcionalidad adicional configurada por una StorageClass, como el cambio de tamaño de volumen, storageClassName debe hacer referencia a un objeto StorageClass existente.

Para obtener más detalles, consulta la documentación de Kubernetes sobre PersistentVolumes.

Nota: El disco persistente debe estar en la misma zona que los nodos del clúster.

1. Guarda el siguiente manifiesto YAML:

   apiVersion: v1
   kind: PersistentVolume
   metadata:
     name: PV_NAME
   spec:
     storageClassName: "STORAGE_CLASS_NAME"
     capacity:
       storage: DISK_SIZE
     accessModes:
       - ReadWriteOnce
     claimRef:
       namespace: default
       name: PV_CLAIM_NAME
     csi:
       driver: pd.csi.storage.gke.io
       volumeHandle: DISK_ID
       fsType: FS_TYPE
   ---
   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     namespace: default
     name: PV_CLAIM_NAME
   spec:
     storageClassName: "STORAGE_CLASS_NAME"
     volumeName: PV_NAME
     accessModes:
       - ReadWriteOnce
     resources:
       requests:
         storage: DISK_SIZE
   

   Reemplaza lo siguiente:

   • PV_NAME: el nombre del PersistentVolume nuevo
   • STORAGE_CLASS_NAME: Es el nombre de tu StorageClass nueva.
   • DISK_SIZE: el tamaño de tu disco persistente preexistente. Por ejemplo, 500G
   • PV_CLAIM_NAME: Es el nombre de tu PersistentVolumeClaim nuevo.
   • DISK_ID: el identificador de tu disco persistente preexistente. El formato es projects/{project_id}/zones/{zone_name}/disks/{disk_name} para los discos persistentes zonales o projects/{project_id}/regions/{region_name}/disks/{disk_name} para los discos persistentes regionales.
   • FS_TYPE: Es el tipo de sistema de archivos. Puedes dejarlo como el predeterminado (ext4) o usar xfs. Si tus clústeres usan un grupo de nodos de Windows Server, debes cambiar esto a NTFS.

2. Para aplicar la configuración y crear los recursos de PersistentVolume y PersistentVolumeClaim, ejecuta el siguiente comando:

   kubectl apply -f FILE_PATH
   

   Reemplaza FILE_PATH por la ruta de acceso al archivo YAML.

Usa el PersistentVolume en un Pod

Después de crear y vincular el PersistentVolume y el PersistentVolumeClaim, puedes otorgar acceso a los contenedores de un Pod al volumen si especificas los valores en el campo volumeMounts.

Con la siguiente configuración de YAML, se crea un nuevo Pod y un contenedor que ejecuta una imagen nginx y, luego, se activa el PersistentVolume en el pod:

kind: Pod
apiVersion: v1
metadata:
  name: POD_NAME
spec:
  volumes:
    - name: VOLUME_NAME
      persistentVolumeClaim:
        claimName: PV_CLAIM_NAME
  containers:
    - name: CONTAINER_NAME
      image: nginx
      ports:
        - containerPort: 80
          name: "http-server"
      volumeMounts:
        - mountPath: "/usr/share/nginx/html"
          name: VOLUME_NAME

Reemplaza lo siguiente:

• POD_NAME: el nombre del Pod nuevo
• VOLUME_NAME: el nombre del volumen
• PV_CLAIM_NAME: el nombre del PersistentVolumeClaim que creaste en el paso anterior
• CONTAINER_NAME: el nombre de tu contenedor nuevo

Aplica la configuración:

kubectl apply -f FILE_PATH

Reemplaza FILE_PATH por la ruta de acceso al archivo YAML.

Para verificar que se haya activado el volumen, ejecuta el siguiente comando:

kubectl describe pods POD_NAME

En el resultado, verifica que PersistentVolumeClaim se haya activado:

...
Volumes:
  VOLUME_NAME:
    Type:       PersistentVolumeClaim (a reference to a PersistentVolumeClaim in the same namespace)
    ClaimName:  PV_CLAIM_NAME
    ReadOnly:   false
Events:
  Type    Reason                  Age   From                     Message
  ----    ------                  ----  ----                     -------
  Normal  Scheduled               29s   default-scheduler        Successfully assigned default/POD_NAME to gke-cluster-1-default-pool-d5cde866-o4g4
  Normal  SuccessfulAttachVolume  21s   attachdetach-controller  AttachVolume.Attach succeeded for volume "PV_NAME"
  Normal  Pulling                 19s   kubelet                  Pulling image "nginx"
  Normal  Pulled                  19s   kubelet                  Successfully pulled image "nginx"
  Normal  Created                 18s   kubelet                  Created container CONTAINER_NAME
  Normal  Started                 18s   kubelet                  Started container CONTAINER_NAME

Usa un disco preexistente en un StatefulSet

Puedes usar discos persistentes preexistentes de Compute Engine en un StatefulSet mediante PersistentVolumes. StatefulSet genera automáticamente un PersistentVolumeClaim para cada réplica. Puedes predecir los nombres de los PersistentVolumeClaims generados y vincularlos a PersistentVolumes con claimRef.

En el siguiente ejemplo, toma dos discos persistentes preexistentes, crea PersistentVolumes para usar los discos y, luego, activa los volúmenes en un StatefulSet con dos réplicas en el espacio de nombres predeterminado.

1. Elige un nombre para tu StatefulSet nuevo, un nombre para tu plantilla PersistentVolumeClaim y la cantidad de réplicas en el StatefulSet.

2. Determina los nombres de los PersistentVolumeClaims generados de forma automática. StatefulSet usa el siguiente formato para los nombres de PersistentVolumeClaim:

   PVC_TEMPLATE_NAME-STATEFULSET_NAME-REPLICA_INDEX
   

   Reemplaza lo siguiente:

   • PVC_TEMPLATE_NAME: El nombre de tu nueva plantilla PersistentVolumeClaim.
   • STATEFULSET_NAME: El nombre de tu StatefulSet nuevo.
   • REPLICA_INDEX: el índice de la réplica del StatefulSet En este ejemplo, usa 0 y 1.

3. Crea los PersistentVolumes. Debes crear un PersistentVolume para cada réplica en el StatefulSet.

   1. Guarda el siguiente manifiesto YAML:

      apiVersion: v1
      kind: PersistentVolume
      metadata:
        name: pv-ss-demo-0
      spec:
        storageClassName: "STORAGE_CLASS_NAME"
        capacity:
          storage: DISK1_SIZE
        accessModes:
          - ReadWriteOnce
        claimRef:
          namespace: default
          name: PVC1_NAME
        csi:
          driver: pd.csi.storage.gke.io
          volumeHandle: DISK1_ID
          fsType: FS_TYPE
       ---
      apiVersion: v1
      kind: PersistentVolume
      metadata:
        name: pv-ss-demo-1
      spec:
        storageClassName: "STORAGE_CLASS_NAME"
        capacity:
          storage: DISK2_SIZE
        accessModes:
          - ReadWriteOnce
        claimRef:
          namespace: default
          name: PVC2_NAME
        csi:
          driver: pd.csi.storage.gke.io
          volumeHandle: DISK2_ID
          fsType: FS_TYPE
      

      Reemplaza lo siguiente:

      • DISK1_SIZE and DISK2_SIZE: los tamaños de tus discos persistentes preexistentes.
      • DISK1_ID and DISK2_ID: los identificadores de tus discos persistentes preexistentes.
      • PVC1_NAME and PVC2_NAME: los nombres de los PersistentVolumeClaims generados automáticamente.
      • STORAGE_CLASS_NAME: Es el nombre de tu StorageClass.

   2. Aplica la configuración:

      kubectl apply -f FILE_PATH
      

      Reemplaza FILE_PATH por la ruta de acceso al archivo YAML.

4. Crea un StatefulSet con los valores que elegiste en el paso 1. Asegúrate de que el almacenamiento que especifiques en volumeClaimTemplates sea menor o igual que la capacidad de PersistentVolumes.

   1. Guarda el siguiente manifiesto YAML:

      apiVersion: apps/v1
      kind: StatefulSet
      metadata:
        name: STATEFULSET_NAME
      spec:
        selector:
          matchLabels:
            app: nginx
        serviceName: "nginx"
        replicas: 2
        template:
          metadata:
            labels:
              app: nginx
          spec:
            terminationGracePeriodSeconds: 10
            containers:
            - name: nginx
              image: registry.k8s.io/nginx-slim:0.8
              ports:
              - containerPort: 80
                name: web
              volumeMounts:
              - name: PVC_TEMPLATE_NAME
                mountPath: /usr/share/nginx/html
        volumeClaimTemplates:
        - metadata:
            name: PVC_TEMPLATE_NAME
          spec:
            accessModes: [ "ReadWriteOnce" ]
            storageClassName: "STORAGE_CLASS_NAME"
            resources:
              requests:
                storage: 100Gi
      

      Reemplaza lo siguiente:

      • STATEFULSET_NAME: El nombre de tu StatefulSet nuevo.
      • PVC_TEMPLATE_NAME: El nombre de tu nueva plantilla PersistentVolumeClaim.
      • STORAGE_CLASS_NAME: Es el nombre de tu StorageClass.
      Nota: Asegúrate de que el nombre del StatefulSet y el nombre de PersistentVolumeClaim coincidan con los valores que elegiste en el paso 1.
      .

   2. Aplica la configuración:

      kubectl apply -f FILE_PATH
      

      Reemplaza FILE_PATH por la ruta de acceso al archivo YAML.

¿Qué sigue?

• Obtener más información para implementar una aplicación con estado