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

Autopilot Estándar

---

El GKE Volume Populator solo está disponible por invitación. Si deseas solicitar acceso al GKE Volume Populator en tu proyecto de Google Cloud , comunícate con tu representante de ventas.

El propagador de volúmenes de GKE te permite precargar datos de un almacenamiento de origen a un PersistentVolumeClaim de destino durante el aprovisionamiento dinámico, sin necesidad de ejecutar secuencias de comandos adicionales ni comandos de CLI 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 los buckets de Cloud Storage a un PersistentVolumeClaim respaldado por otro tipo de almacenamiento deGoogle Cloud (como Parallelstore).

La principal forma de interactuar con GKE Volume Populator es a través de gcloud CLI y la CLI de kubectl. GKE Volume Populator es compatible con los clústeres de Autopilot y Standard. No es necesario que habilites el propagador de volúmenes de GKE. 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 el propagador de volúmenes de GKE para simplificar la transferencia de datos.
• El propagador de volúmenes de GKE permite la portabilidad de datos. Puedes mover datos según tus necesidades.
• El propagador de volúmenes de GKE admite la autenticación basada en IAM para que puedas transferir datos y, al mismo tiempo, mantener un control de acceso detallado.

El diagrama muestra cómo fluyen los datos del almacenamiento de origen al almacenamiento de destino y la creación del PersistentVolume para el almacenamiento de destino con el GKE Volume Populator.

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 propagador de volúmenes de GKE solo admite recursos de StorageClass que tengan su volumeBindingMode configurado en Immediate.
• 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 de varios espacios de nombres.
• El propagador de volúmenes de GKE 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.
  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.

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

Requisitos

Para usar el propagador de volúmenes 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.
• Habilita el controlador de CSI de Parallelstore. GKE habilita el controlador de CSI por ti de forma predeterminada en los clústeres de GKE Autopilot nuevos y existentes. En los clústeres de Standard nuevos y existentes, deberás habilitar el controlador de 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

Nota: Si ya configuraste tu red de VPC como parte de la configuración del controlador de CSI de Parallelstore, puedes omitir esta sección.

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 permitir que la VPC se conecte de forma privada a los servicios de Google Cloud sin exponer el tráfico a la Internet pública, debes realizar una configuración única del acceso a servicios privados (PSA), si aún no lo hiciste.

Para configurar PSA, sigue estos pasos:

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

   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 red 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: El ID del proyecto de Google Cloud .
   Nota: Si estableces el valor de mtu (unidad de transmisión máxima, o el tamaño del paquete IP más grande que se puede transmitir en esta red) en el valor máximo permitido de 8,896, se mejora el rendimiento hasta en un 10% en comparación con el valor predeterminado de 1,460 bytes.

4. Crea un rango de IP.

   El acceso a servicios privados 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 con el 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 TCP desde el rango de IP que crearás.

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

Autopilot

Para crear un clúster de GKE con Autopilot, ejecuta el siguiente comando:

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

GKE habilita la federación de identidades para cargas de trabajo para GKE y el controlador de CSI de Parallelstore de forma predeterminada en los clústeres de Autopilot.

Reemplaza los siguientes valores:

• CLUSTER_NAME: El nombre de tu clúster.
• CLUSTER_VERSION : Es el número de versión de GKE. Debes especificar 1.31.1-gke.1729000 o una versión posterior.
• NETWORK_NAME: Es el nombre de la red de VPC que creaste para la instancia de Parallelstore. Para obtener más información, consulta Cómo configurar una red de VPC.
• CLUSTER_LOCATION: Es la región en la que deseas crear el clúster. Te recomendamos que crees el clúster en una ubicación de Parallelstore compatible para obtener el mejor rendimiento. Si deseas crear tu clúster en una ubicación de Parallelstore que no es compatible, cuando crees una StorageClass de Parallelstore, debes especificar una topología personalizada que use una ubicación de Parallelstore compatible. De lo contrario, fallará el aprovisionamiento.

Estándar

Crea un clúster estándar con el controlador de CSI de Parallelstore y la federación de identidades para cargas de trabajo para GKE habilitados con el siguiente comando:

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

Reemplaza los siguientes valores:

• CLUSTER_NAME: El nombre de tu clúster.
• CLUSTER_VERSION: El número de versión de GKE. Debes especificar 1.31.1-gke.1729000 o una versión posterior.
• PROJECT_ID: El ID del proyecto de Google Cloud .
• NETWORK_NAME: Es el nombre de la red de VPC que creaste para la instancia de Parallelstore. Para obtener más información, consulta Cómo configurar una red de VPC.
• CLUSTER_LOCATION: Es la región o zona en la que deseas crear el clúster. Te recomendamos que crees el clúster en una ubicación de Parallelstore compatible para obtener el mejor rendimiento. Si deseas crear tu clúster en una ubicación de Parallelstore que no es compatible, cuando crees una StorageClass de Parallelstore, debes especificar una topología personalizada que use una ubicación de Parallelstore compatible. De lo contrario, fallará el aprovisionamiento.

Configura los permisos necesarios

Para transferir datos desde un bucket de Cloud Storage, debes configurar los permisos de la federación de identidades para cargas de trabajo para 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 usa tu pod para autenticarse en las APIs de Google Cloud .

   Precaución: Si vuelves a usar esta cuenta de servicio de Kubernetes en una carga de trabajo dentro del mismo espacio de nombres, ese pod podrá acceder al bucket de Cloud Storage. Te recomendamos que no vuelvas a usar esta cuenta de servicio para las cargas de trabajo en el espacio de nombres.

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: El ID del proyecto de Google Cloud .

4. Otorga el rol roles/storage.objectViewer a tu cuenta de servicio de IAM 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 otorgue 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. Otorga el rol roles/iam.serviceAccountTokenCreator a la identidad del servicio de Parallelstore para permitir que imite la cuenta de servicio de IAM. 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 PROJECT_NUMBER es el identificador único generado automáticamente para tu proyecto. Para encontrar este valor, consulta Cómo crear y administrar proyectos.

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

   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. Otórgale el rol roles/iam.serviceAccountUser a la identidad de servicio de GKE para permitir que acceda a todos los recursos a los que puede acceder la cuenta de servicio de IAM. Este paso no es obligatorio 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 GKE Volume Populator.

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

Crea un recurso GCPDataSource

Para usar el GKE Volume Populator, crea un recurso personalizado GCPDataSource. Este recurso define las propiedades de almacenamiento de origen que se usarán para la propagación de volúmenes.

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 de la 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 espacio de nombres de carga de trabajo.
   • KSA_NAME: Es el nombre de la cuenta de servicio de Kubernetes que usa tu Pod 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 StorageClass para dirigir al controlador de CSI de Parallelstore a aprovisionar instancias de Parallelstore en la misma región que tu clúster de GKE. Esto garantiza un rendimiento de E/S óptimo.

1. Guarda el siguiente manifiesto como parallelstore-class.yaml. Asegúrate de que el campo volumeBindingMode en la definición de StorageClass esté configurado como Immediate.

   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 un StorageClass personalizado con una topología específica, consulta la guía de CSI de Parallelstore.

Crea un 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. El PersistentVolumeClaim debe estar respaldado 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 carga de trabajo.
   • GCP_DATA_SOURCE: Es el nombre de la CRD GCPDataSource que contiene una referencia a tu bucket de Cloud Storage. Consulta la referencia de CRD de GCPDataSource para obtener más detalles.

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

   kubectl apply -f volume-populator-pvc.yaml
   

GKE no programará el Pod de la 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.

Verifica que se haya completado el aprovisionamiento de PersistentVolumeClaim

Precaución: Si usas Autopilot, antes de realizar esta verificación, asegúrate de crear una carga de trabajo que consuma el volumen. Este paso es necesario para activar GKE y que cree un nodo. De lo contrario, es posible que se genere un error como este que persistirá durante varios minutos: "error generating accessibility requirements: no available topology found".

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

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

Para verificar el 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. En ese caso, consulta la sección Solución de problemas.

   Si el aprovisionamiento se realiza de forma correcta, el resultado es similar al siguiente. Busca el registro 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"
   

   Nota: Se esperan las advertencias en el resultado, ya que el aprovisionamiento de CSI intenta conciliar el estado de aprovisionamiento del volumen. El aprovisionamiento de volúmenes de Parallelstore suele tardar alrededor de 10 minutos.

2. Verifica si comenzó 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 el aprovisionamiento falló, consulta la guía de solución de problemas de Parallelstore para obtener más orientación.

(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. Verifica el mensaje de eventos de PersistentVolumeClaim para encontrar 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 de 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 carga de trabajo.
   • PVC_NAME: Es el nombre del PersistentVolumeClaim al que deseas transferir tus datos. El PersistentVolumeClaim debe estar respaldado 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 mostrar todos los archivos que existen en el URI del bucket de Cloud Storage.

Borra un PersistentVolumeClaim durante el aprovisionamiento dinámico

Si necesitas borrar tu PersistentVolumeClaim mientras se transfieren los datos durante el aprovisionamiento dinámico, tienes dos opciones: la eliminación elegante y la eliminación forzada.

La eliminación elegante requiere menos esfuerzo, pero puede llevar más tiempo y no tiene en cuenta la configuración incorrecta del usuario que impide que se complete la transferencia de datos. La eliminación forzosa ofrece una alternativa más rápida que permite una mayor flexibilidad y control. Esta opción es adecuada cuando necesitas reiniciar o corregir rápidamente parámetros de configuración incorrectos.

Eliminación elegante

Usa esta opción de eliminación para asegurarte de que el proceso de transferencia de datos se complete antes de que GKE borre los recursos asociados.

1. Ejecuta el siguiente comando para borrar el Pod de la carga de trabajo, si existe:

   kubectl delete pod POD_NAME -n NAMESPACE
   

2. Busca el nombre del PersistentVolumeClaim temporal:

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

3. Busca el nombre del PersistentVolume:

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

   Si el resultado está vacío, significa que aún no se creó el PersistentVolume.

4. Ejecuta este comando para borrar tu PersistentVolumeClaim. El finalizador bloqueará tu operación de eliminación. Presiona Ctrl+C y, luego, continúa con el siguiente paso.

   kubectl delete pvc PVC_NAME -n NAMESPACE
   

   Espera a que se complete la transferencia de datos. Con el tiempo, GKE borrará la instancia de PersistentVolumeClaim, PersistentVolume y Parallelstore.

5. Verifica que se hayan borrado los recursos PersistentVolumeClaim, PersistentVolumeClaim y PersistentVolume temporales:

   kubectl get pvc,pv -A | grep -E "${TEMP_PVC?}|PVC_NAME|${PV_NAME?}"
   

6. Verifica que se haya borrado la instancia de Parallelstore. La instancia de Parallelstore compartirá el mismo nombre que el PersistentVolume. No es necesario que ejecutes este comando si confirmaste en el paso 3 que no se creó el PersistentVolume.

   gcloud beta parallelstore instances list \
       --project=PROJECT_ID \
       --location=- | grep ${PV_NAME?}
   

Eliminación forzada

Usa esta opción de eliminación cuando necesites borrar un PersistentVolumeClaim y sus recursos asociados antes de que se complete el proceso de transferencia de datos. Esto puede ser necesario en situaciones en las que la transferencia de datos tarda demasiado o se producen errores, o si necesitas recuperar recursos con rapidez.

1. Borra el Pod de la carga de trabajo si existe:

   kubectl delete pod POD_NAME -n NAMESPACE
   

2. Actualiza la política de recuperación de PersistentVolume a Delete. Esto garantiza que el PersistentVolume, junto con el almacenamiento subyacente, se borre automáticamente cuando se borre la PersistentVolumeClaim asociada.

   Omite el siguiente comando si se cumple alguna de las siguientes condiciones:

   • No quieres borrar el PersistentVolume ni el almacenamiento subyacente.
   • Tu política de recuperación actual es Retain y deseas conservar el almacenamiento subyacente. Limpia el PersistentVolume y la instancia de almacenamiento manualmente según sea necesario.
   • El siguiente comando echo $PV_NAME muestra una cadena vacía, lo que significa que aún no se creó el PersistentVolume.

   PV_NAME=$(kubectl describe pvc $TEMP_PVC -n gke-managed-volumepopulator | grep "Volume:" | awk '{print $2}')
   
   echo $PV_NAME
   
   kubectl patch pv $PV_NAME -p '{"spec":{"persistentVolumeReclaimPolicy":"Delete"}}'
   

3. Busca el nombre de la PersistentVolumeClaim temporal y configura la variable de entorno para un paso posterior:

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

4. Ejecuta este comando para borrar la PersistentVolumeClaim. El finalizador bloqueará tu operación de eliminación. Presiona Ctrl+C y, luego, continúa con el siguiente paso.

   kubectl delete pvc PVC_NAME -n NAMESPACE
   

5. Quita el finalizador datalayer.gke.io/populate-target-protection de tu PersistentVolumeClaim. Este paso es necesario después de borrar PersistentVolumeClaim. De lo contrario, gke-volume-populator volverá a agregar el finalizador a PersistentVolumeClaim.

   kubectl get pvc PVC_NAME -n NAMESPACE -o=json | \
   jq '.metadata.finalizers = null' | kubectl apply -f -
   

6. Borra el PersistentVolumeClaim temporal en el espacio de nombres gke-managed-volumepopulator.

   kubectl delete pvc $TEMP_PVC -n gke-managed-volumepopulator
   

7. Verifica que se hayan borrado los recursos PersistentVolumeClaim, PersistentVolumeClaim y PersistentVolume temporales:

   kubectl get pvc,pv -A | grep -E "${TEMP_PVC?}|PVC_NAME|${PV_NAME?}"
   

8. Verifica que se haya borrado la instancia de Parallelstore. La instancia de Parallelstore compartirá el mismo nombre que el PersistentVolume. No es necesario que ejecutes este comando si confirmaste en el paso 2 que no se creó el PersistentVolume.

   gcloud beta parallelstore instances list \
       --project=PROJECT_ID \
       --location=- | grep ${PV_NAME?}
   

Soluciona problemas

En esta sección, se muestra cómo resolver problemas relacionados con el propagador de volúmenes de GKE.

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 del 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 envía el mensaje de error, el nombre del proyecto y el nombre del volumen.

Problemas de permisos

Si encuentras errores como los siguientes durante la propagación de volúmenes, significa que GKE encontró 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 problemas, verifica lo siguiente:

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

Para obtener pasos detallados y comandos de verificación, consulta Configura los permisos necesarios. Si los errores persisten, comunícate con el equipo de asistencia y envía el mensaje de error, el nombre de tu proyecto y el nombre del bucket de Cloud Storage.

Errores de argumentos no válidos

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

¿Qué sigue?

• Explora la documentación de referencia de CSI de Parallelstore.
• Obtén información para usar la biblioteca de intercepción de Parallelstore y mejorar el rendimiento de la carga de trabajo.
• Consulta el instructivo para entrenar un modelo de TensorFlow con Keras en GKE.