Automatizar la transferencia de datos de Cloud Storage a Parallelstore mediante GKE Volume Populator

GKE Volume Populator solo está disponible mediante invitación. Si quieres solicitar acceso a GKE Volume Populator en tu proyecto Google Cloud , ponte en contacto con tu representante de ventas.

En esta guía se describe cómo puedes precargar grandes cantidades de datos de un bucket de Cloud Storage en un volumen de Parallelstore de Google Kubernetes Engine (GKE) durante el aprovisionamiento dinámico mediante GKE Volume Populator. Para obtener más información, consulta Acerca de GKE Volume Populator.

Esta guía está dirigida a especialistas en almacenamiento que crean y asignan almacenamiento, y gestionan la seguridad y el acceso a los datos. Para obtener más información sobre los roles habituales y las tareas de ejemplo a las que hacemos referencia en el Google Cloud contenido, consulta Roles y tareas habituales de los usuarios de GKE Enterprise.

Limitaciones

  • 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 federación de Workload Identity para GKE de cuentas de servicio de IAM a una cuenta de servicio de Kubernetes. No se admite la concesión directa de permisos de gestión de identidades y accesos a la cuenta de servicio de Kubernetes.

Antes de empezar

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

  • Habilita la API Parallelstore y la API de Google Kubernetes Engine.
    • Habilitar APIs
  • Si quieres usar Google Cloud CLI para esta tarea, instálala y, a continuación, inicialízala. Si ya has instalado la gcloud CLI, obtén la versión más reciente ejecutando gcloud components update.

Requisitos

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

  • Usa la versión 1.31.1-gke.1729000 o una 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 Autopilot de GKE nuevos y actuales. En los clústeres Standard nuevos y actuales, debes habilitar el controlador CSI.

Prepara tu entorno

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

Configurar tu red de VPC

Debes especificar la misma red de nube privada virtual (VPC) al crear la instancia de Parallel Store y las máquinas virtuales 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 Internet público, debes configurar Acceso a servicios privados (PSA) una sola vez, si aún no lo has hecho.

Para configurar los mensajes predefinidos, sigue estos pasos:

  1. Para configurar el emparejamiento de redes en tu proyecto, configura el permiso de gestión de identidades y accesos Administrador de red de Compute (roles/compute.networkAdmin).

    Para asignar el rol, ejecuta el siguiente comando:

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

    Sustituye EMAIL_ADDRESS por tu dirección de correo.

  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

    Haz los cambios siguientes:

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

  4. Crea un intervalo de IPs.

    El acceso a servicios privados requiere un intervalo 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 reutilizar este intervalo de IP con otros servicios u otras 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

    Sustituye IP_RANGE_NAME por el nombre del intervalo de IPs de la red VPC.

  5. Define una variable de entorno con el intervalo CIDR asociado al intervalo que has creado 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 cortafuegos para permitir el tráfico TCP desde el intervalo de IPs que has creado:

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

    Sustituye FIREWALL_NAME por el nombre de la regla de cortafuegos para permitir el tráfico TCP desde el intervalo de IPs que has creado.

  7. Conecta el intercambio de tráfico entre redes:

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

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

Crear un clúster de GKE

Te recomendamos que uses un clúster de Autopilot para disfrutar de una experiencia de Kubernetes totalmente gestionada. Para elegir el modo de funcionamiento de GKE que mejor se adapte a las necesidades de tu carga de trabajo, consulta Elegir un modo de funcionamiento 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 Workload Identity Federation para GKE y el controlador CSI de Parallelstore de forma predeterminada en los clústeres de Autopilot.

Sustituye 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.
  • NETWORK_NAME: el nombre de la red VPC que has creado para la instancia de Parallelstore. Para obtener más información, consulta Configurar una red de VPC.
  • CLUSTER_LOCATION: la región en la que quieras crear el clúster. Te recomendamos que crees el clúster en una ubicación de Parallelstore admitida para obtener el mejor rendimiento. Si quieres crear tu clúster en una ubicación de Parallelstore no admitida, cuando crees una StorageClass de Parallelstore, debes especificar una topología personalizada que use una ubicación de Parallelstore admitida. De lo contrario, el aprovisionamiento fallará.

Estándar

Crea un clúster estándar con el controlador CSI de Parallelstore y Workload Identity Federation para GKE habilitados mediante 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

Sustituye 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: tu Google Cloud ID de proyecto.
  • NETWORK_NAME: el nombre de la red VPC que has creado para la instancia de Parallelstore. Para obtener más información, consulta Configurar una red VPC.
  • CLUSTER_LOCATION: la región o zona en la que quieras crear el clúster. Te recomendamos que crees el clúster en una ubicación de Parallelstore admitida para obtener el mejor rendimiento posible. Si quieres crear tu clúster en una ubicación de Parallelstore no admitida, cuando crees una StorageClass de Parallelstore, debes especificar una topología personalizada que use una ubicación de Parallelstore admitida. De lo contrario, el aprovisionamiento fallará.

Configurar los permisos necesarios

Para transferir datos desde un segmento de Cloud Storage, debes configurar los permisos de Workload Identity Federation para GKE.

  1. Crea un espacio de nombres de Kubernetes:

    kubectl create namespace NAMESPACE

    Sustituye 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

    Sustituye KSA_NAME por el nombre de la cuenta de servicio de Kubernetes que usa tu pod 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 de cualquier proyecto de tu organización:

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

    Haz los cambios siguientes:

    • IAM_SA_NAME: el nombre de tu cuenta de servicio de gestión de identidades y accesos.
    • PROJECT_ID: tu Google Cloud ID de proyecto.

  4. Concede a tu cuenta de servicio de gestión de identidades y accesos el rol roles/storage.objectViewer para que pueda acceder a tu segmento 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"

    Sustituye GCS_BUCKET por el nombre de tu segmento de Cloud Storage.

  5. Crea la política de permiso de gestión de identidades y accesos que da acceso a la cuenta de servicio de Kubernetes para suplantar la cuenta de servicio de gestión de identidades y accesos:

    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 la vinculación 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 de servicio de Parallelstore:

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

  8. Para permitir que la identidad de servicio de Parallelstore suplante a la cuenta de servicio de IAM, asigna el rol roles/iam.serviceAccountTokenCreator a la identidad de servicio de Parallelstore. Define la variable de entorno PROJECT_NUMBER para poder usarla en los pasos siguientes.

    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 el artículo Crea y gestiona proyectos.

  9. Para permitir que la identidad de servicio de Parallelstore acceda a todos los recursos a los que puede acceder la cuenta de servicio de IAM, asigna el rol roles/iam.serviceAccountUser a la identidad de 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, asigna el rol 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 gestión de identidades y accesos 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

Crear un volumen de Parallelstore con datos precargados

En las siguientes secciones se describe el proceso habitual para crear un volumen de Parallelstore con datos precargados desde un bucket de Cloud Storage mediante GKE Volume Populator.

  1. Crea un GCPDataSource recurso.
  2. Crea un StorageClass de Parallelstore.
  3. Crea un 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.

Crear un recurso GCPDataSource

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

  1. Guarda el siguiente manifiesto en 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/

    Sustituye los siguientes valores:

    • GCP_DATA_SOURCE: el nombre del GCPDataSource CRD que contiene una referencia a tu segmento de Cloud Storage. Consulta la referencia del CRD GCPDataSource para obtener más información.
    • NAMESPACE: 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 del espacio de nombres de tu carga de trabajo.
    • KSA_NAME: 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 hayas configurado para la federación de identidades de cargas de trabajo en GKE en el paso Configurar los permisos necesarios.
    • GCS_BUCKET: el nombre de tu segmento de Cloud Storage. También puedes especificar gs://GCS_BUCKET/PATH_INSIDE_BUCKET/ en el campo uri.

  2. Crea el recurso GCPDataSource ejecutando este comando:

    kubectl apply -f gcpdatasource.yaml

Crear un StorageClass de Parallelstore

Crea un StorageClass para dirigir el controlador CSI de Parallelstore y aprovisionar instancias de Parallelstore en la misma región que tu clúster de GKE. De esta forma, se asegura un rendimiento de E/S óptimo.

  1. Guarda el siguiente archivo de 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. Crea el objeto StorageClass ejecutando este comando:

    kubectl apply -f parallelstore-class.yaml

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

Crear un PersistentVolumeClaim para acceder al volumen

El siguiente archivo de manifiesto muestra un ejemplo de cómo crear un PersistentVolumeClaim en ReadWriteMany con el modo de acceso que hace referencia al StorageClass que has creado anteriormente.

  1. Guarda el siguiente manifiesto en 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

    Sustituye los siguientes valores:

    • PVC_NAME: el nombre del PersistentVolumeClaim al que quieres transferir tus datos. La PersistentVolumeClaim debe estar respaldada por una instancia de Parallelstore.
    • NAMESPACE: 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 del espacio de nombres de tu carga de trabajo.
    • GCP_DATA_SOURCE: el nombre del GCPDataSource CRD que contiene una referencia a tu segmento de Cloud Storage. Para obtener más información, consulta la GCPDataSourcereferencia de CRD.

  2. Para crear el PersistentVolumeClaim, ejecuta el 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 comprobar el progreso de la transferencia de datos, consulta Ver el progreso de la transferencia de datos. Si se producen errores durante el aprovisionamiento, consulta la sección Solución de problemas.

(Opcional) Ver el progreso de la transferencia de datos

En esta sección se explica cómo puedes monitorizar el progreso de las transferencias de datos desde un segmento de Cloud Storage a un volumen de Parallelstore. Puedes hacerlo para monitorizar el estado de la transferencia y asegurarte de que los datos se copian correctamente. También debes ejecutar este comando si la operación de enlace PersistentVolumeClaim tarda demasiado.

  1. Verifica el estado de tu PersistentVolumeClaim ejecutando el siguiente comando:

    kubectl describe pvc PVC_NAME -n NAMESPACE

  2. Consulta el mensaje de eventos de PersistentVolumeClaim para ver 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 rellenado puede tardar un tiempo en iniciarse. Esta operación 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 PersistentVolumeClaim que has creado anteriormente.

  1. Guarda el siguiente manifiesto YAML de 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

    Sustituye los siguientes valores:

    • POD_NAME: el nombre del pod que ejecuta tu carga de trabajo.
    • NAMESPACE: 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 del espacio de nombres de tu carga de trabajo.
    • PVC_NAME: el nombre del PersistentVolumeClaim al que quieres 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. Comprueba el estado de tu Pod y espera hasta que sea RUNNING. Tu PersistentVolumeClaim debe estar enlazado para que la carga de trabajo se pueda ejecutar.

    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

    En la salida se deben enumerar todos los archivos que haya en el URI del segmento de Cloud Storage.

Eliminar un PersistentVolumeClaim durante el aprovisionamiento dinámico

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

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

Eliminación suave

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

  1. Elimina el pod de la carga de trabajo, si existe, ejecutando este comando:

    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 la salida está vacía, significa que el PersistentVolume aún no se ha creado.

  4. Elimina tu PersistentVolumeClaim ejecutando este comando.

    kubectl delete pvc PVC_NAME -n NAMESPACE

    Espera a que se complete la transferencia de datos. GKE acabará eliminando el PersistentVolumeClaim, el PersistentVolume y la instancia de Parallelstore.

  5. Comprueba que se hayan eliminado los recursos PersistentVolumeClaim, PersistentVolumeClaim y PersistentVolume temporales:

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

  6. Comprueba que la instancia de Parallelstore se haya eliminado. La instancia de Parallelstore tendrá el mismo nombre que 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 eliminar un PersistentVolumeClaim y sus recursos asociados antes de que se complete el proceso de transferencia de datos. Es posible que tengas que usar esta opción en situaciones en las que la transferencia de datos tarde demasiado o se produzcan errores, o si necesitas recuperar recursos rápidamente.

  1. Elimina el pod de la carga de trabajo, si existe:

    kubectl delete pod POD_NAME -n NAMESPACE

  2. Actualiza el valor de PersistentVolume reclaim policy a Delete. Este ajuste asegura que el PersistentVolume, junto con el almacenamiento subyacente, se elimine automáticamente cuando se elimine el PersistentVolumeClaim asociado.

    Omite el siguiente comando si se da alguna de estas circunstancias:

    • No quieres eliminar el PersistentVolume ni el almacenamiento subyacente.
    • Tu política de recuperación actual es Retain y quieres conservar el almacenamiento subyacente. Limpia el PersistentVolume y la instancia de almacenamiento manualmente según sea necesario.

    • El siguiente comando echo $PV_NAME devuelve una cadena vacía, lo que significa que el PersistentVolume aún no se ha creado.

      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 del PersistentVolumeClaim temporal y define 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. Elimina el PersistentVolumeClaim ejecutando este comando. El finalizador bloqueará la operación de eliminación. Pulsa Control+C y, a continuación, ve al paso siguiente.

    kubectl delete pvc PVC_NAME -n NAMESPACE

  5. Elimina el finalizador datalayer.gke.io/populate-target-protection de tu PersistentVolumeClaim. Este paso es necesario después de eliminar el PersistentVolumeClaim. De lo contrario, gke-volume-populator vuelve a añadir el finalizador a PersistentVolumeClaim.

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

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

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

  7. Comprueba que se hayan eliminado los recursos PersistentVolumeClaim, PersistentVolumeClaim y PersistentVolume temporales:

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

  8. Comprueba que la instancia de Parallelstore se haya eliminado. La instancia de Parallelstore tendrá el mismo nombre que el PersistentVolume.

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

Solución de problemas

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

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

kubectl describe pvc PVC_NAME -n NAMESPACE

Error: An internal error has occurred

Si aparece el siguiente error, significa que se ha producido un error interno de la API 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 solucionar este problema, debes seguir estos pasos para recoger datos para el equipo de Asistencia:

  1. Ejecuta los siguientes comandos para obtener el nombre de la PersistentVolumeClaim temporal. Sustituye 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. Ponte en contacto con el equipo de Asistencia e indícales el mensaje de error, el nombre del proyecto y el nombre del volumen.

Problemas con los permisos

Si se producen errores como los siguientes durante el llenado del volumen, significa que GKE ha detectado un problema de permisos:

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

Para solucionar estos errores, compruebe lo siguiente:

  • Acceso al segmento de Cloud Storage: comprueba que el segmento exista y que la cuenta de servicio tenga el rol roles/storage.objectViewer permission.
  • Cuentas de servicio: confirma que tanto la cuenta de servicio de Kubernetes como la cuenta de servicio de gestión de identidades y accesos existen y están vinculadas correctamente.
  • Cuenta de servicio de Parallelstore: comprueba que la cuenta de servicio de Parallelstore exista y tenga los permisos necesarios (roles/iam.serviceAccountTokenCreator y roles/iam.serviceAccountUser en la cuenta de gestión de identidades y accesos).

Para ver los pasos detallados y los comandos de verificación, consulta Configurar los permisos necesarios. Si los errores persisten, ponte en contacto con el equipo de Asistencia e indica el mensaje de error, el nombre del proyecto y el nombre del bucket de Cloud Storage.

Errores de argumentos no válidos

Si se producen errores InvalidArgument, significa que probablemente has proporcionado valores incorrectos en el recurso GCPDataSource o en PersistentVolumeClaim. El registro de errores indicará los campos exactos que contienen los datos no válidos. Comprueba que el URI del segmento de Cloud Storage y otros campos relevantes sean correctos.

Verificar que se ha completado el aprovisionamiento de PersistentVolumeClaim

GKE Volume Populator usa un PersistentVolumeClaim temporal en el espacio de nombres gke-managed-volumepopulator para aprovisionar el volumen.

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

Para comprobar su estado, sigue estos pasos:

  1. Ejecuta estos 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 la salida está vacía, significa que no se ha creado el PersistentVolumeClaim temporal. Ejecuta el siguiente comando para comprobar si hay advertencias de eventos de PersistentVolumeClaim:

    kubectl describe pvc PVC_NAME -n NAMESPACE

    Si el aprovisionamiento se realiza correctamente, el resultado será 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"

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

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

    La salida es similar a la siguiente. Comprueba que el volumen esté en el estado CREATING. Cuando se haya terminado de crear 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 falla, consulta la guía para solucionar problemas de Parallelstore para obtener más información.

Siguientes pasos