Cómo transferir datos de Cloud Storage durante el aprovisionamiento dinámico con el propagador de volúmenes de GKE

El propagador de volúmenes de GKE te permite cargar previamente datos de un almacenamiento de origen a un PersistentVolumeClaim de destino durante el aprovisionamiento dinámico, sin ejecutar secuencias de comandos ni comandos de CLI adicionales para la transferencia manual de datos. Esta función se encarga de automatizar y optimizar el proceso de transferencia de datos aprovechando la función Kubernetes Volume Populator. Proporciona una portabilidad de datos sin inconvenientes para que puedas intercambiar tipos de almacenamiento y beneficiarte de las optimizaciones de precio o rendimiento.

Usa esta función si necesitas transferir grandes cantidades de datos de buckets de Cloud Storage a una PersistentVolumeClaim respaldada por otro tipo de almacenamientoGoogle Cloud (como Parallelstore).

Principalmente, interactúas con GKE Volume Populator a través de las CLI de gcloud y kubectl. GKE Volume Populator es compatible con los clústeres de Autopilot y Standard. No es necesario que habilites el GKE Volume Populator. Es un componente administrado por GKE que está habilitado de forma predeterminada.

Beneficios

• Si deseas aprovechar el rendimiento de un sistema de archivos paralelo administrado, pero tus datos se almacenan en Cloud Storage, puedes usar GKE Volume Populator para simplificar la transferencia de datos.
• GKE Volume Populator permite la portabilidad de datos. Puedes mover los datos según tus necesidades.
• El propagador de volúmenes de GKE admite la autenticación basada en IAM, por lo que puedes transferir datos y, al mismo tiempo, mantener un control de acceso detallado.

En el diagrama, se muestra cómo fluyen los datos del almacenamiento de origen al de destino, y la creación del PersistentVolume para el almacenamiento de destino con el propagador de volúmenes de GKE.

Limitaciones

• El propagador de volúmenes de GKE solo admite buckets de Cloud Storage como almacenamiento de origen y instancias de Parallelstore como tipo de almacenamiento de destino.
• El recurso personalizado GCPDataSource debe estar en el mismo espacio de nombres que tu carga de trabajo de Kubernetes. No se admiten volúmenes con fuentes de datos entre espacios de nombres.
• GKE Volume Populator solo admite la vinculación de Workload Identity Federation for GKE de cuentas de servicio de IAM a una cuenta de servicio de Kubernetes. No se admite otorgar permisos de IAM directamente a la cuenta de servicio de Kubernetes.

Antes de comenzar

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

• Habilita la API de Parallelstore y la API de Google Kubernetes Engine.
Habilita las APIs
• 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.

• Consulta la descripción general del controlador de CSI de Parallelstore para conocer las limitaciones y los requisitos.
• Crea tus buckets de Cloud Storage y complétalos con los datos que deseas transferir.

Requisitos

Para usar el Volume Populator de GKE, tus clústeres deben cumplir con los siguientes requisitos:

• Usa la versión 1.31.1-gke.1729000 o posterior del clúster de GKE.
• Tener habilitado el controlador de CSI de Parallelstore GKE habilita el controlador de CSI de forma predeterminada en los clústeres de GKE Autopilot nuevos y existentes. En los clústeres estándar nuevos y existentes, debes habilitar el controlador CSI.

Prepara el entorno

En esta sección, se describen los pasos para crear tus clústeres de GKE y configurar los permisos necesarios para usar GKE Volume Populator.

Configura tu red de VPC

Debes especificar la misma red de nube privada virtual (VPC) cuando crees la instancia de Parallelstore y las VMs de Compute Engine o los clústeres de GKE del cliente. Para habilitar la conexión privada de la VPC a los servicios de Google Cloudsin exponer el tráfico a Internet público, debes configurar el acceso privado a servicios (PSA) por única vez, si aún no lo hiciste.

Para configurar la PSA, sigue estos pasos:

1. Para configurar el intercambio de tráfico entre redes de tu proyecto, configura el permiso de IAM Administrador de red de Compute (roles/compute.networkAdmin).

   Para otorgar el rol, ejecuta el siguiente comando:

   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member="user:EMAIL_ADDRESS" \
       --role=roles/compute.networkAdmin
   

   Reemplaza EMAIL_ADDRESS por tu dirección de correo electrónico.

2. Habilita la conexión de redes de servicios:

   gcloud services enable servicenetworking.googleapis.com
   

3. Crea una red de VPC:

   gcloud compute networks create NETWORK_NAME \
     --subnet-mode=auto \
     --mtu=8896 \
     --project=PROJECT_ID
   

   Reemplaza lo siguiente:

   • NETWORK_NAME: Es el nombre de la red de VPC en la que crearás tu instancia de Parallelstore.
   • PROJECT_ID: Es el Google Cloud ID del proyecto.

4. Crea un rango de IP.

   El acceso privado a servicios requiere un rango de direcciones IP (bloque CIDR) con una longitud de prefijo de al menos /24 (256 direcciones). Parallelstore reserva 64 direcciones por instancia, lo que significa que puedes volver a usar este rango de IP con otros servicios o instancias de Parallelstore si es necesario.

   gcloud compute addresses create IP_RANGE_NAME \
     --global \
     --purpose=VPC_PEERING \
     --prefix-length=24 \
     --description="Parallelstore VPC Peering" \
     --network=NETWORK_NAME \
     --project=PROJECT_ID
   

   Reemplaza IP_RANGE_NAME por el nombre del rango de IP de la red de VPC.

5. Establece una variable de entorno con el rango CIDR asociado al rango que creaste en el paso anterior:

   CIDR_RANGE=$(
     gcloud compute addresses describe IP_RANGE_NAME \
       --global  \
       --format="value[separator=/](address, prefixLength)" \
       --project=PROJECT_ID \
   )
   

6. Crea una regla de firewall para permitir el tráfico de TCP desde el rango de IP que creaste:

   gcloud compute firewall-rules create FIREWALL_NAME \
     --allow=tcp \
     --network=NETWORK_NAME \
     --source-ranges=$CIDR_RANGE \
     --project=PROJECT_ID
   

   Reemplaza FIREWALL_NAME por el nombre de la regla de firewall para permitir el tráfico de TCP desde el rango de IP que creaste.

7. Conecta el intercambio de tráfico:

   gcloud services vpc-peerings connect \
     --network=NETWORK_NAME \
     --ranges=IP_RANGE_NAME \
     --project=PROJECT_ID \
     --service=servicenetworking.googleapis.com
   

Si tienes problemas mientras configuras la red de VPC, consulta la guía de solución de problemas de Parallelstore.

Crea tu clúster de GKE

Te recomendamos que uses un clúster de Autopilot para una experiencia de Kubernetes completamente administrada. Para elegir el modo de operación de GKE que se adapte mejor a las necesidades de tu carga de trabajo, consulta Elige un modo de operación de GKE.

gcloud container clusters create-auto CLUSTER_NAME  \
    --network=NETWORK_NAME  \
    --cluster-version=CLUSTER_VERSION \
    --location=CLUSTER_LOCATION

gcloud container clusters create CLUSTER_NAME \
    --addons=ParallelstoreCsiDriver \
    --cluster-version=CLUSTER_VERSION \
    --workload-pool=PROJECT_ID.svc.id.goog \
    --network=NETWORK_NAME \
    --location=CLUSTER_LOCATION

Configura los permisos necesarios

Para transferir datos desde un bucket de Cloud Storage, debes configurar permisos para la federación de identidades para cargas de trabajo de GKE.

1. Crea un espacio de nombres de Kubernetes:

   kubectl create namespace NAMESPACE
   

   Reemplaza NAMESPACE por el espacio de nombres en el que se ejecutarán tus cargas de trabajo.

2. Crea una cuenta de servicio de Kubernetes.

   kubectl create serviceaccount KSA_NAME \
       --namespace=NAMESPACE
   

   Reemplaza KSA_NAME por el nombre de la cuenta de servicio de Kubernetes que tu Pod usa para autenticarse en las APIs de Google Cloud .

3. Crea una cuenta de servicio de IAM. También puedes usar cualquier cuenta de servicio de IAM existente en cualquier proyecto de tu organización:

   gcloud iam service-accounts create IAM_SA_NAME \
       --project=PROJECT_ID
   

   Reemplaza lo siguiente:

   • IAM_SA_NAME: Es el nombre de tu cuenta de servicio de IAM.
   • PROJECT_ID: Es el Google Cloud ID del proyecto.

4. Otorga a tu cuenta de servicio de IAM el rol roles/storage.objectViewer para que pueda acceder a tu bucket de Cloud Storage:

   gcloud storage buckets \
       add-iam-policy-binding gs://GCS_BUCKET \
       --member "serviceAccount:IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
       --role "roles/storage.objectViewer"
   

   Reemplaza GCS_BUCKET por el nombre de tu bucket de Cloud Storage.

5. Crea la política de permisos de IAM que otorga a la cuenta de servicio de Kubernetes acceso para actuar en nombre de la cuenta de servicio de IAM:

   gcloud iam service-accounts \
       add-iam-policy-binding IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:PROJECT_ID.svc.id.goog[NAMESPACE/KSA_NAME]"
   

6. Anota la cuenta de servicio de Kubernetes para que GKE vea el vínculo entre las cuentas de servicio.

   kubectl annotate serviceaccount KSA_NAME \
       --namespace NAMESPACE \
       iam.gke.io/gcp-service-account=IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com
   

7. Crea la identidad del servicio de Parallelstore:

   gcloud beta services identity create \
       --service=parallelstore.googleapis.com \
       --project=PROJECT_ID
   

8. Para permitir que la identidad del servicio de Parallelstore actúe en nombre de la cuenta de servicio de IAM, otorga el rol roles/iam.serviceAccountTokenCreator a la identidad del servicio de Parallelstore. Configura la variable de entorno PROJECT_NUMBER para que puedas usarla en los pasos posteriores.

   export PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")
   gcloud iam service-accounts \
       add-iam-policy-binding "IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
       --member=serviceAccount:"service-${PROJECT_NUMBER?}@gcp-sa-parallelstore.iam.gserviceaccount.com" \
       --role=roles/iam.serviceAccountTokenCreator
   

   El valor de PROJECT_NUMBER es el identificador único generado automáticamente para tu proyecto. Para encontrar este valor, consulta Crea y administra proyectos.

9. Para permitir que la identidad del servicio de Parallelstore acceda a todos los recursos a los que puede acceder la cuenta de servicio de IAM, otorga el rol roles/iam.serviceAccountUser a la identidad del servicio de Parallelstore:

   gcloud iam service-accounts \
       add-iam-policy-binding "IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
       --member=serviceAccount:"service-${PROJECT_NUMBER?}@gcp-sa-parallelstore.iam.gserviceaccount.com" \
       --role=roles/iam.serviceAccountUser
   

10. Para permitir que la identidad de servicio de GKE acceda a todos los recursos a los que puede acceder la cuenta de servicio de IAM, otorga el rol de roles/iam.serviceAccountUser a la identidad de servicio de GKE. Este paso no es necesario si el clúster de GKE y la cuenta de servicio de IAM están en el mismo proyecto.

    gcloud iam service-accounts \
        add-iam-policy-binding "IAM_SA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
        --member=serviceAccount:"service-${PROJECT_NUMBER?}@container-engine-robot.iam.gserviceaccount.com" \
        --role=roles/iam.serviceAccountUser
    

Crea un volumen de Parallelstore con datos precargados

En las siguientes secciones, se describe el proceso típico para crear un volumen de Parallelstore con datos precargados desde un bucket de Cloud Storage, con el propagador de volúmenes de GKE.

1. Crea un recurso GCPDataSource.
2. Crea un StorageClass de Parallelstore.
3. Crea un objeto PersistentVolumeClaim para acceder al volumen.
4. (Opcional) Consulta el progreso de la transferencia de datos.
5. Crea una carga de trabajo que consuma el volumen

Crea un recurso GCPDataSource

Para usar GKE Volume Populator, crea un recurso personalizado GCPDataSource. Este recurso define las propiedades de almacenamiento de origen que se usarán para completar el volumen.

1. Guarda el siguiente manifiesto como un archivo llamado gcpdatasource.yaml.

   apiVersion: datalayer.gke.io/v1
   kind: GCPDataSource
   metadata:
     name: GCP_DATA_SOURCE
     namespace: NAMESPACE
   spec:
     cloudStorage:
       serviceAccountName: KSA_NAME
       uri: gs://GCS_BUCKET/
   

   Reemplaza los siguientes valores:

   • GCP_DATA_SOURCE: Es el nombre del CRD GCPDataSource que contiene una referencia a tu bucket de Cloud Storage. Consulta la referencia de CRD de GCPDataSource para obtener más detalles.
   • NAMESPACE: Es el espacio de nombres en el que se ejecutarán tus cargas de trabajo. El valor del espacio de nombres debe ser el mismo que el de tu carga de trabajo.
   • KSA_NAME: Es el nombre de la cuenta de servicio de Kubernetes que tu Pod usa para autenticarse en las APIs de Google Cloud . El valor de cloudStorage.serviceAccountName debe ser la cuenta de servicio de Kubernetes que configuraste para Workload Identity Federation for GKE en el paso Configura los permisos necesarios.
   • GCS_BUCKET: el nombre de tu bucket de Cloud Storage. Como alternativa, también puedes especificar gs://GCS_BUCKET/PATH_INSIDE_BUCKET/ para el campo uri.

2. Ejecuta este comando para crear el recurso GCPDataSource:

   kubectl apply -f gcpdatasource.yaml
   

Crea una StorageClass de Parallelstore

Crea un objeto StorageClass para indicarle al controlador de CSI de Parallelstore que aprovisione instancias de Parallelstore en la misma región que tu clúster de GKE. Esto ayuda a garantizar un rendimiento de E/S óptimo.

1. Guarda el siguiente manifiesto como parallelstore-class.yaml.

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
     name: parallelstore-class
   provisioner: parallelstore.csi.storage.gke.io
   volumeBindingMode: Immediate
   reclaimPolicy: Delete
   

2. Para crear una StorageClass, ejecuta este comando:

   kubectl apply -f parallelstore-class.yaml
   

Si deseas crear una StorageClass personalizada con una topología específica, consulta la guía del CSI de Parallelstore.

Crea un objeto PersistentVolumeClaim para acceder al volumen

En el siguiente archivo de manifiesto, se muestra un ejemplo de cómo crear un PersistentVolumeClaim en el modo de acceso ReadWriteMany que hace referencia a la StorageClass que creaste antes.

1. Guarda el siguiente manifiesto como un archivo llamado volume-populator-pvc.yaml:

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: PVC_NAME
     namespace: NAMESPACE
   spec:
     accessModes:
     -   ReadWriteMany
     storageClassName: parallelstore-class
     resources:
       requests:
         storage: 12Gi
     dataSourceRef:
       apiGroup: datalayer.gke.io
       kind: GCPDataSource
       name: GCP_DATA_SOURCE
   

   Reemplaza los siguientes valores:

   • PVC_NAME: Es el nombre del PersistentVolumeClaim al que deseas transferir tus datos. La PersistentVolumeClaim debe estar respaldada por una instancia de Parallelstore.
   • NAMESPACE: Es el espacio de nombres en el que se ejecutarán tus cargas de trabajo. El valor del espacio de nombres debe ser el mismo que el de tu espacio de nombres de la carga de trabajo.
   • GCP_DATA_SOURCE: Es el nombre del CRD GCPDataSource que contiene una referencia a tu bucket de Cloud Storage. Para obtener más detalles, consulta la referencia del CRD de GCPDataSource.

2. Crea la PersistentVolumeClaim mediante la ejecución del siguiente comando:

   kubectl apply -f volume-populator-pvc.yaml
   

GKE no programará el Pod de carga de trabajo hasta que se complete el aprovisionamiento de PersistentVolumeClaim. Para verificar el progreso de la transferencia de datos, consulta Cómo ver el progreso de la transferencia de datos. Si encuentras errores durante el aprovisionamiento, consulta Solución de problemas.

(Opcional) Consulta el progreso de la transferencia de datos

En esta sección, se muestra cómo puedes hacer un seguimiento del progreso de tus transferencias de datos desde un bucket de Cloud Storage a un volumen de Parallelstore. Puedes hacerlo para supervisar el estado de la transferencia y asegurarte de que tus datos se copien correctamente. También debes ejecutar este comando si la operación de vinculación de PersistentVolumeClaim tarda demasiado.

1. Ejecuta el siguiente comando para verificar el estado de tu PersistentVolumeClaim:

   kubectl describe pvc PVC_NAME -n NAMESPACE
   

2. Consulta el mensaje de eventos de PersistentVolumeClaim para conocer el progreso de la transferencia de datos. GKE registra los mensajes aproximadamente una vez por minuto. El resultado es similar al siguiente:

   Reason                          Message
   ------                          -------
   PopulateOperationStartSuccess   Populate operation started
   PopulateOperationStartSuccess   Populate operation started
   Provisioning                    External provisioner is provisioning volume for claim "my-namespace/my-pvc"
   Provisioning                    Assuming an external populator will provision the volume
   ExternalProvisioning            Waiting for a volume to be created either by the external provisioner 'parallelstore.csi.storage.gke.io' or manually by the system administrator. If volume creation is delayed, please verify that the provisioner is running and correctly registered.
   PopulateOperationStartSuccess   Populate operation started
   PopulatorPVCCreationProgress    objects found 7, objects copied 7, objects skipped 0. bytes found 1000020010, bytes copied 1000020010, bytes skipped 0
   PopulateOperationFinished       Populate operation finished
   PopulatorFinished               Populator finished
   

La operación de propagación puede tardar un poco en comenzar, ya que depende del tamaño del archivo. Si no ves ningún progreso en la transferencia de datos después de varios minutos, consulta la sección Solución de problemas.

Crea una carga de trabajo que consuma el volumen

En esta sección, se muestra un ejemplo de cómo crear un Pod que consuma el recurso de PersistentVolumeClaim que creaste antes.

1. Guarda el siguiente manifiesto YAML para tu Pod como pod.yaml.

   apiVersion: v1
   kind: Pod
   metadata:
     name: POD_NAME
     namespace: NAMESPACE
   spec:
     volumes:
     -   name: parallelstore-volume
       persistentVolumeClaim:
         claimName: PVC_NAME
     containers:
     -   image: nginx
       name: nginx
       volumeMounts:
       -   name: parallelstore-volume
         mountPath: /mnt/data
   

   Reemplaza los siguientes valores:

   • POD_NAME: Es el nombre del Pod que ejecuta tu carga de trabajo.
   • NAMESPACE: Es el espacio de nombres en el que se ejecutarán tus cargas de trabajo. El valor del espacio de nombres debe ser el mismo que el de tu espacio de nombres de la carga de trabajo.
   • PVC_NAME: Es el nombre del PersistentVolumeClaim al que deseas transferir tus datos. La PersistentVolumeClaim debe estar respaldada por una instancia de Parallelstore.

2. Ejecuta el siguiente comando para aplicar el manifiesto al clúster:

   kubectl apply -f pod.yaml
   

3. Verifica el estado del Pod y espera hasta que sea RUNNING. Tu PersistentVolumeClaim debe estar vinculado antes de que se pueda ejecutar la carga de trabajo.

   kubectl describe pod POD_NAME -n NAMESPACE
   

4. Verifica que los archivos se hayan transferido correctamente y que tu carga de trabajo pueda acceder a ellos.

   kubectl exec -it POD_NAME -n NAMESPACE -c nginx -- /bin/sh
   

   Cambia al directorio /mnt/data y ejecuta ls:

   cd /mnt/data
   ls
   

   El resultado debe enumerar todos los archivos que existen en el URI de tu bucket de Cloud Storage.

Borra un PersistentVolumeClaim durante el aprovisionamiento dinámico

Si necesitas borrar tu PersistentVolumeClaim mientras aún se transfieren datos durante el aprovisionamiento dinámico, tienes dos opciones: borrado correcto y borrado forzado.

La eliminación gradual requiere menos esfuerzo, pero puede llevar más tiempo y no tiene en cuenta los errores de configuración del usuario que impiden que se complete la transferencia de datos. La eliminación forzada ofrece una alternativa más rápida que permite mayor flexibilidad y control. Esta opción es adecuada cuando necesitas reiniciar rápidamente o corregir configuraciones incorrectas.

Soluciona problemas

En esta sección, se muestra cómo resolver problemas relacionados con GKE Volume Populator.

Antes de continuar, ejecuta el siguiente comando para verificar si hay advertencias de eventos de PersistentVolumeClaim:

kubectl describe pvc PVC_NAME -n NAMESPACE

Error: An internal error has occurred

Si encuentras el siguiente error, significa que se produjo un error interno de la API de Parallelstore.

Warning  PopulateOperationStartError  gkevolumepopulator-populator  Failed to start populate operation: populate data for PVC "xxx". Import data failed, error: rpc error: code = Internal desc = An internal error has occurred ("xxx")

Para resolver este problema, deberás seguir estos pasos para recopilar datos para el equipo de asistencia:

1. Ejecuta los siguientes comandos para obtener el nombre de la PersistentVolumeClaim temporal y reemplaza los marcadores de posición por los nombres reales:

   PVC_UID=$(kubectl get pvc PVC_NAME -n NAMESPACE -o yaml | grep uid | awk '{print $2}')
   
   TEMP_PVC=prime-${PVC_UID?}
   
   echo ${TEMP_PVC?}
   

2. Ejecuta el siguiente comando para obtener el nombre del volumen:

   PV_NAME=$(kubectl describe pvc ${TEMP_PVC?} -n gke-managed-volumepopulator | grep "Volume:" | awk '{print $2}')
   

3. Comunícate con el equipo de asistencia al cliente y proporciona el mensaje de error, el nombre del proyecto y el nombre del volumen.

Problemas de permisos

Si detectas errores como los siguientes durante la propagación del volumen, significa que GKE tuvo un problema de permisos:

• El bucket de Cloud Storage no existe: PopulateOperationStartError con code = PermissionDenied
• Faltan permisos en el bucket de Cloud Storage o en las cuentas de servicio: PopulateOperationFailed con "code: "xxx" message:"Verify if bucket "xxx" exists and grant access".
• No se encontró la cuenta de servicio: PopulateOperationStartError con code = Unauthenticated.

Para resolver estos errores, verifica lo siguiente:

• Acceso al bucket de Cloud Storage: Verifica que el bucket exista y que la cuenta de servicio tenga el rol roles/storage.objectViewer permission.
• Cuentas de servicio: Confirma que existan la cuenta de servicio de Kubernetes y la cuenta de servicio de IAM, y que estén vinculadas correctamente.
• Cuenta de servicio de Parallelstore: Asegúrate de que la cuenta de servicio de Parallelstore exista y tenga los permisos necesarios (roles/iam.serviceAccountTokenCreator y roles/iam.serviceAccountUser en la cuenta de IAM).

Para conocer los pasos detallados y los comandos de verificación, consulta Cómo configurar los permisos necesarios. Si los errores persisten, comunícate con el equipo de asistencia al cliente y proporciona el mensaje de error, el nombre de tu proyecto y el nombre del bucket de Cloud Storage.

Errores de argumento no válido

Si encuentras errores de InvalidArgument, es probable que hayas proporcionado valores incorrectos en GCPDataSource o PersistentVolumeClaim. El registro de errores indicará los campos exactos que contienen los datos no válidos. Verifica que el URI del bucket de Cloud Storage y otros campos relevantes sean correctos.

Verifica que se haya completado el aprovisionamiento de PersistentVolumeClaim

El propagador de volúmenes de GKE usa una PersistentVolumeClaim temporal en el espacio de nombres gke-managed-volumepopulator para el aprovisionamiento de volúmenes.

La PersistentVolumeClaim temporal es, básicamente, una instantánea de tu PersistentVolumeClaim que aún está en tránsito (esperando que los datos se carguen por completo). Su nombre tiene el formato prime-YOUR_PVC_UID.

Para verificar su estado, haz lo siguiente:

1. Ejecuta los siguientes comandos:

   PVC_UID=$(kubectl get pvc PVC_NAME -n NAMESPACE -o yaml | grep uid | awk '{print $2}')
   
   TEMP_PVC=prime-$PVC_UID
   
   echo $TEMP_PVC
   
   kubectl describe pvc ${TEMP_PVC?} -n gke-managed-volumepopulator
   

   Si el resultado está vacío, significa que no se creó el PersistentVolumeClaim temporal. Ejecuta el siguiente comando para verificar si hay advertencias de eventos de PersistentVolumeClaim:

   kubectl describe pvc PVC_NAME -n NAMESPACE
   

   Si el aprovisionamiento se realiza de forma correcta, el resultado es similar al siguiente. Busca el registro de ProvisioningSucceeded:

   Warning  ProvisioningFailed     9m12s                   parallelstore.csi.storage.gke.io_gke-10fedd76bae2494db688-2237-793f-vm_5f284e53-b25c-46bb-b231-49e894cbba6c  failed to provision volume with StorageClass "parallelstore-class": rpc error: code = DeadlineExceeded desc = context deadline exceeded
   Warning  ProvisioningFailed     3m41s (x11 over 9m11s)  parallelstore.csi.storage.gke.io_gke-10fedd76bae2494db688-2237-793f-vm_5f284e53-b25c-46bb-b231-49e894cbba6c  failed to provision volume with StorageClass "parallelstore-class": rpc error: code = DeadlineExceeded desc = Volume pvc-808e41a4-b688-4afe-9131-162fe5d672ec not ready, current state: CREATING
   Normal   ExternalProvisioning   3m10s (x43 over 13m)    persistentvolume-controller                                                                                  Waiting for a volume to be created either by the external provisioner 'parallelstore.csi.storage.gke.io' or manually by the system administrator. If volume creation is delayed, please verify that the provisioner is running and correctly registered.
   Normal  Provisioning  8s (x13 over 10m)  "xxx"  External provisioner is provisioning volume for claim "xxx"
   Normal  ProvisioningSucceeded  7s  "xxx"  Successfully provisioned volume "xxx"
   

2. Comprueba si se inició la creación de la instancia de Parallelstore.

   gcloud beta parallelstore instances list \
       --project=PROJECT_ID \
       --location=-
   

   El resultado es similar al siguiente. Verifica que el volumen esté en estado CREATING. Cuando finalice la creación de la instancia de Parallelstore, el estado cambiará a ACTIVE.

   "projects/PROJECT_ID/locations/<my-location>/<my-volume>"  12000  2024-10-09T17:59:42.582857261Z  2024-10-09T17:59:42.582857261Z  CREATING  projects/PROJECT_ID/global/NETWORK_NAME
   

Si falla el aprovisionamiento, consulta la guía de solución de problemas de Parallelstore para obtener orientación adicional.

¿Qué sigue?

• Explora la documentación de referencia del CSI de Parallelstore.
• Obtén información para usar la biblioteca de interceptación de Parallelstore y mejorar el rendimiento de las cargas de trabajo.
• Prueba el instructivo para entrenar un modelo de TensorFlow con Keras en GKE.