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.
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.
- 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:
- Aprovisiona el disco persistente existente como un PersistentVolume.
- Vincula el PersistentVolume a un PersistentVolumeClaim.
- 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.
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 nuevoSTORAGE_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 esprojects/{project_id}/zones/{zone_name}/disks/{disk_name}
para los discos persistentes zonales oprojects/{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 usarxfs
. Si tus clústeres usan un grupo de nodos de Windows Server, debes cambiar esto aNTFS
.
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 nuevoVOLUME_NAME
: el nombre del volumenPV_CLAIM_NAME
: el nombre del PersistentVolumeClaim que creaste en el paso anteriorCONTAINER_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.
- Elige un nombre para tu StatefulSet nuevo, un nombre para tu plantilla PersistentVolumeClaim y la cantidad de réplicas en el StatefulSet.
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, usa0
y1
.
Crea los PersistentVolumes. Debes crear un PersistentVolume para cada réplica en el StatefulSet.
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.
Aplica la configuración:
kubectl apply -f FILE_PATH
Reemplaza
FILE_PATH
por la ruta de acceso al archivo YAML.
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.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.
Aplica la configuración:
kubectl apply -f FILE_PATH
Reemplaza
FILE_PATH
por la ruta de acceso al archivo YAML.