Transférer des données depuis Cloud Storage lors du provisionnement dynamique à l'aide de l'outil GKE Volume Populator

GKE Volume Populator vous permet de précharger des données depuis un stockage source vers un PersistentVolumeClaim de destination lors du provisionnement dynamique, sans exécuter de scripts ni de commandes CLI supplémentaires pour le transfert manuel des données. Cette fonctionnalité automatise et simplifie le processus de transfert de données en tirant parti de la fonctionnalité Kubernetes Volume Populator. Il offre une portabilité des données fluide, ce qui vous permet de changer de type de stockage pour bénéficier d'optimisations de prix ou de performances.

Utilisez cette fonctionnalité si vous devez transférer de grandes quantités de données depuis des buckets Cloud Storage vers un PersistentVolumeClaim reposant sur un autre type de stockageGoogle Cloud (tel que Parallelstore).

Vous interagissez principalement avec GKE Volume Populator via les CLI de ligne de commande gcloud et kubectl. GKE Volume Populator est compatible avec les clusters Autopilot et Standard. Vous n'avez pas besoin d'activer le GKE Volume Populator. Il s'agit d'un composant géré par GKE qui est activé par défaut.

Avantages

• Si vous souhaitez profiter des performances d'un système de fichiers parallèles géré, mais que vos données sont stockées dans Cloud Storage, vous pouvez utiliser GKE Volume Populator pour simplifier le transfert de données.
• GKE Volume Populator permet la portabilité des données. Vous pouvez déplacer des données selon vos besoins.
• GKE Volume Populator est compatible avec l'authentification basée sur IAM. Vous pouvez ainsi transférer des données tout en conservant un contrôle d'accès précis.

Le diagramme montre comment les données circulent du stockage source vers le stockage de destination, et comment le PersistentVolume est créé pour le stockage de destination à l'aide de GKE Volume Populator.

Limites

• GKE Volume Populator n'accepte que les buckets Cloud Storage comme stockage source et les instances Parallelstore comme type de stockage de destination.
• La ressource personnalisée GCPDataSource doit se trouver dans le même espace de noms que votre charge de travail Kubernetes. Les volumes avec des sources de données inter-espaces de noms ne sont pas acceptés.
• GKE Volume Populator n'est compatible qu'avec l'association Workload Identity Federation for GKE des comptes de service IAM à un compte de service Kubernetes. Il n'est pas possible d'accorder directement des autorisations IAM au compte de service Kubernetes.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

• Activez l'API Parallelstore et l'API Google Kubernetes Engine.
Activer les API
• Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.

• Consultez la présentation du pilote CSI Parallelstore pour connaître les limites et les conditions requises.
• Créez vos buckets Cloud Storage, remplis avec les données que vous souhaitez transférer.

Conditions requises

Pour utiliser GKE Volume Populator, vos clusters doivent répondre aux exigences suivantes :

• Utilisez la version 1.31.1-gke.1729000 ou ultérieure du cluster GKE.
• Le pilote CSI Parallelstore doit être activé. GKE active le pilote CSI pour vous par défaut sur les clusters GKE Autopilot nouveaux et existants. Sur les clusters Standard nouveaux et existants, vous devez activer le pilote CSI.

Préparer votre environnement

Cette section décrit les étapes à suivre pour créer vos clusters GKE et configurer les autorisations nécessaires pour utiliser GKE Volume Populator.

Configurer votre réseau VPC

Vous devez spécifier le même réseau de cloud privé virtuel (VPC) lorsque vous créez l'instance Parallelstore et les VM Compute Engine ou les clusters GKE clients. Pour permettre au VPC de se connecter de manière privée aux services Google Cloudsans exposer le trafic à l'Internet public, vous devez configurer l'accès aux services privés (PSA) une seule fois, si vous ne l'avez pas déjà fait.

Pour configurer PSA, procédez comme suit :

1. Pour configurer l'appairage de réseaux pour votre projet, configurez l'autorisation IAM Administrateur de réseaux Compute (roles/compute.networkAdmin).

   Pour accorder le rôle, exécutez la commande suivante :

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

   Remplacez EMAIL_ADDRESS par votre adresse e-mail.

2. Activez le service de mise en réseau :

   gcloud services enable servicenetworking.googleapis.com
   

3. Créez un réseau VPC :

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

   Remplacez les éléments suivants :

   • NETWORK_NAME : nom du réseau VPC dans lequel vous allez créer votre instance Parallelstore.
   • PROJECT_ID : ID de votre projet Google Cloud .

4. Créez une plage d'adresses IP.

   L'accès aux services privés nécessite une plage d'adresses IP (bloc CIDR) avec une longueur de préfixe d'au moins /24 (256 adresses). Parallelstore réserve 64 adresses par instance, ce qui signifie que vous pouvez réutiliser cette plage d'adresses IP avec d'autres services ou d'autres instances Parallelstore si nécessaire.

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

   Remplacez IP_RANGE_NAME par le nom de la plage d'adresses IP du réseau VPC.

5. Définissez une variable d'environnement avec la plage CIDR associée à la plage que vous avez créée à l'étape précédente :

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

6. Créez une règle de pare-feu pour autoriser le trafic TCP provenant de la plage d'adresses IP que vous avez créée :

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

   Remplacez FIREWALL_NAME par le nom de la règle de pare-feu pour autoriser le trafic TCP à partir de la plage d'adresses IP que vous avez créée.

7. Connectez l'appairage :

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

Si vous rencontrez des problèmes lors de la configuration du réseau VPC, consultez le guide de dépannage Parallelstore.

Créer votre cluster GKE

Nous vous recommandons d'utiliser un cluster Autopilot pour une expérience Kubernetes entièrement gérée. Pour choisir le mode de fonctionnement GKE le mieux adapté à vos besoins en termes de charge de travail, consultez Choisir un mode de fonctionnement 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

Configurer les autorisations nécessaires

Pour transférer des données depuis un bucket Cloud Storage, vous devez configurer des autorisations pour la fédération d'identité de charge de travail pour GKE.

1. Créez un espace de noms Kubernetes :

   kubectl create namespace NAMESPACE
   

   Remplacez NAMESPACE par l'espace de noms sur lequel vos charges de travail s'exécuteront.

2. Créez un compte de service Kubernetes.

   kubectl create serviceaccount KSA_NAME \
       --namespace=NAMESPACE
   

   Remplacez KSA_NAME par le nom du compte de service Kubernetes que votre pod utilise pour s'authentifier auprès des API Google Cloud .

3. Créez un compte de service IAM. Vous pouvez également utiliser n'importe quel compte de service IAM existant dans n'importe quel projet de votre organisation :

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

   Remplacez les éléments suivants :

   • IAM_SA_NAME : nom de votre compte de service IAM.
   • PROJECT_ID : ID de votre projet Google Cloud .

4. Attribuez le rôle roles/storage.objectViewer à votre compte de service IAM afin qu'il puisse accéder à votre bucket 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"
   

   Remplacez GCS_BUCKET par le nom de votre bucket Cloud Storage.

5. Créez la stratégie d'autorisation IAM qui permet au compte de service Kubernetes d'emprunter l'identité du compte de service 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. Annotez le compte de service Kubernetes afin que GKE voie le lien entre les comptes de service.

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

7. Créez l'identité du service Parallelstore :

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

8. Pour autoriser l'identité de service Parallelstore à emprunter l'identité du compte de service IAM, accordez le rôle roles/iam.serviceAccountTokenCreator à l'identité de service Parallelstore. Définissez la variable d'environnement PROJECT_NUMBER pour pouvoir l'utiliser lors des étapes suivantes.

   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
   

   La valeur PROJECT_NUMBER est l'identifiant unique généré automatiquement pour votre projet. Pour trouver cette valeur, consultez Créer et gérer des projets.

9. Pour autoriser l'identité de service Parallelstore à accéder à toutes les ressources auxquelles le compte de service IAM peut accéder, accordez le rôle roles/iam.serviceAccountUser à l'identité de service 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. Pour permettre à l'identité de service GKE d'accéder à toutes les ressources auxquelles le compte de service IAM peut accéder, accordez le rôle roles/iam.serviceAccountUser à l'identité de service GKE. Cette étape n'est pas nécessaire si le cluster GKE et le compte de service IAM se trouvent dans le même projet.

    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
    

Créer un volume Parallelstore avec des données préchargées

Les sections suivantes décrivent la procédure standard de création d'un volume Parallelstore avec des données préchargées à partir d'un bucket Cloud Storage, à l'aide du GKE Volume Populator.

1. Créez une ressource GCPDataSource.
2. Créez une ressource StorageClass Parallelstore.
3. Créer un PersistentVolumeClaim pour accéder au volume
4. (Facultatif) Affichez la progression du transfert de données.
5. Créer une charge de travail qui utilise le volume.

Créer une ressource GCPDataSource

Pour utiliser GKE Volume Populator, créez une ressource personnalisée GCPDataSource. Cette ressource définit les propriétés de stockage source à utiliser pour le remplissage du volume.

1. Enregistrez le fichier manifeste suivant dans un fichier nommé 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/
   

   Remplacez les valeurs suivantes :

   • GCP_DATA_SOURCE : nom du CRD GCPDataSource qui contient une référence à votre bucket Cloud Storage. Pour en savoir plus, consultez la documentation de référence sur les CRD GCPDataSource.
   • NAMESPACE : espace de noms sur lequel vos charges de travail seront exécutées. La valeur de l'espace de noms doit être identique à celle de l'espace de noms de votre charge de travail.
   • KSA_NAME : nom du compte de service Kubernetes que votre pod utilise pour s'authentifier auprès des API Google Cloud . La valeur cloudStorage.serviceAccountName doit correspondre au compte de service Kubernetes que vous avez configuré pour la fédération d'identité de charge de travail pour GKE à l'étape Configurer les autorisations nécessaires.
   • GCS_BUCKET : nom de votre bucket Cloud Storage. Vous pouvez également spécifier gs://GCS_BUCKET/PATH_INSIDE_BUCKET/ pour le champ uri.

2. Créez la ressource GCPDataSource en exécutant la commande suivante :

   kubectl apply -f gcpdatasource.yaml
   

Créer une StorageClass Parallelstore

Créez un StorageClass pour indiquer au pilote CSI Parallelstore de provisionner des instances Parallelstore dans la même région que votre cluster GKE. Cela permet d'assurer des performances d'E/S optimales.

1. Enregistrez le fichier manifeste suivant sous le nom 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. Créez l'objet StorageClass en exécutant la commande suivante :

   kubectl apply -f parallelstore-class.yaml
   

Si vous souhaitez créer une StorageClass personnalisée avec une topologie spécifique, consultez le guide CSI Parallelstore.

Créer un PersistentVolumeClaim pour accéder au volume

Le fichier manifeste suivant montre un exemple de création d'un PersistentVolumeClaim en mode d'accès ReadWriteMany qui référence la StorageClass que vous avez créée précédemment.

1. Enregistrez le fichier manifeste suivant dans un fichier nommé 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
   

   Remplacez les valeurs suivantes :

   • PVC_NAME : nom du PersistentVolumeClaim vers lequel vous souhaitez transférer vos données. Le PersistentVolumeClaim doit être soutenu par une instance Parallelstore.
   • NAMESPACE : espace de noms dans lequel vos charges de travail seront exécutées. La valeur de l'espace de noms doit être identique à celle de l'espace de noms de votre charge de travail.
   • GCP_DATA_SOURCE : nom du CRD GCPDataSource qui contient une référence à votre bucket Cloud Storage. Pour en savoir plus, consultez la documentation de référence sur le CRD GCPDataSource.

2. Créez la PersistentVolumeClaim en exécutant la commande suivante :

   kubectl apply -f volume-populator-pvc.yaml
   

GKE ne planifie pas le pod de charge de travail tant que le provisionnement de PersistentVolumeClaim n'est pas terminé. Pour vérifier la progression du transfert de vos données, consultez Afficher la progression du transfert de données. Si vous rencontrez des erreurs lors du provisionnement, consultez la section Dépannage.

(Facultatif) Afficher la progression du transfert de données

Cette section explique comment suivre la progression de vos transferts de données depuis un bucket Cloud Storage vers un volume Parallelstore. Vous pouvez le faire pour surveiller l'état de votre transfert et vous assurer que vos données sont copiées correctement. Vous devez également exécuter cette commande si l'opération d'association de votre PersistentVolumeClaim prend trop de temps.

1. Vérifiez l'état de votre PersistentVolumeClaim en exécutant la commande suivante :

   kubectl describe pvc PVC_NAME -n NAMESPACE
   

2. Consultez le message d'événement PersistentVolumeClaim pour connaître l'état du transfert de données. GKE consigne les messages environ une fois par minute. Le résultat ressemble à ce qui suit :

   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
   

L'opération de remplissage peut prendre un certain temps, en fonction de la taille du fichier. Si vous ne constatez aucune progression dans le transfert de données après plusieurs minutes, consultez la section Dépannage.

Créer un pod qui utilise le volume

Cette section présente un exemple de création d'un pod qui utilise la ressource PersistentVolumeClaim que vous avez créée précédemment.

1. Enregistrez le fichier manifeste YAML suivant pour votre pod sous le nom 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
   

   Remplacez les valeurs suivantes :

   • POD_NAME : nom du pod qui exécute votre charge de travail.
   • NAMESPACE : espace de noms dans lequel vos charges de travail seront exécutées. La valeur de l'espace de noms doit être identique à celle de l'espace de noms de votre charge de travail.
   • PVC_NAME : nom du PersistentVolumeClaim vers lequel vous souhaitez transférer vos données. Le PersistentVolumeClaim doit être soutenu par une instance Parallelstore.

2. Exécutez la commande suivante pour appliquer le fichier manifeste au cluster :

   kubectl apply -f pod.yaml
   

3. Vérifiez l'état de votre pod et attendez qu'il soit RUNNING. Votre PersistentVolumeClaim doit être lié pour que la charge de travail puisse s'exécuter.

   kubectl describe pod POD_NAME -n NAMESPACE
   

4. Vérifiez que les fichiers ont bien été transférés et qu'ils sont accessibles à votre charge de travail.

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

   Accédez au répertoire /mnt/data et exécutez ls :

   cd /mnt/data
   ls
   

   La sortie doit lister tous les fichiers qui existent dans l'URI de votre bucket Cloud Storage.

Supprimer un PersistentVolumeClaim lors du provisionnement dynamique

Si vous devez supprimer votre PersistentVolumeClaim alors que des données sont encore en cours de transfert lors du provisionnement dynamique, deux options s'offrent à vous : la suppression progressive et la suppression forcée.

La suppression progressive nécessite moins d'efforts, mais peut prendre plus de temps et ne tient pas compte des erreurs de configuration de l'utilisateur qui empêchent le transfert de données de se terminer. La suppression forcée est une alternative plus rapide qui offre plus de flexibilité et de contrôle. Cette option est adaptée lorsque vous devez redémarrer rapidement ou corriger des erreurs de configuration.

Dépannage

Cette section explique comment résoudre les problèmes liés à GKE Volume Populator.

Avant de continuer, exécutez la commande suivante pour vérifier s'il existe des avertissements d'événements PersistentVolumeClaim :

kubectl describe pvc PVC_NAME -n NAMESPACE

Erreur : An internal error has occurred

Si vous rencontrez l'erreur suivante, cela signifie qu'une erreur interne de l'API Parallelstore s'est produite.

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")

Pour résoudre ce problème, vous devez suivre ces étapes afin de collecter des données pour l'assistance :

1. Exécutez les commandes suivantes pour obtenir le nom de l'objet PersistentVolumeClaim temporaire, en remplaçant les espaces réservés par les noms réels :

   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. Exécutez la commande suivante pour obtenir le nom du volume :

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

3. Contactez l'équipe d'assistance en lui fournissant le message d'erreur, le nom de votre projet et le nom du volume.

Problèmes d'autorisation

Si vous rencontrez des erreurs semblables à celles-ci lors du remplissage du volume, cela indique que GKE a rencontré un problème d'autorisations :

• Le bucket Cloud Storage n'existe pas : PopulateOperationStartError avec code = PermissionDenied
• Autorisations manquantes sur le bucket Cloud Storage ou les comptes de service : PopulateOperationFailed avec "code: "xxx" message:"Verify if bucket "xxx" exists and grant access".
• Compte de service introuvable : PopulateOperationStartError avec code = Unauthenticated.

Pour résoudre ces erreurs, vérifiez les points suivants :

• Accès au bucket Cloud Storage : vérifiez que le bucket existe et que le compte de service dispose du rôle roles/storage.objectViewer permission.
• Comptes de service : vérifiez que le compte de service Kubernetes et le compte de service IAM existent et sont correctement associés.
• Compte de service Parallelstore : assurez-vous que le compte de service Parallelstore existe et qu'il dispose des autorisations nécessaires (roles/iam.serviceAccountTokenCreator et roles/iam.serviceAccountUser sur le compte IAM).

Pour obtenir des instructions détaillées et des commandes de validation, consultez Configurer les autorisations nécessaires. Si des erreurs persistent, contactez l'assistance en lui fournissant le message d'erreur, le nom de votre projet et le nom du bucket Cloud Storage.

Erreurs d'argument incorrect

Si vous rencontrez des erreurs InvalidArgument, cela signifie que vous avez probablement fourni des valeurs incorrectes dans GCPDataSource ou PersistentVolumeClaim. Le journal des erreurs indiquera précisément les champs contenant les données non valides. Vérifiez l'exactitude de l'URI de votre bucket Cloud Storage et des autres champs concernés.

Vérifier que le provisionnement de PersistentVolumeClaim est terminé

Le module de remplissage de volumes GKE utilise un PersistentVolumeClaim temporaire dans l'espace de noms gke-managed-volumepopulator pour le provisionnement de volumes.

Le PersistentVolumeClaim temporaire est essentiellement un instantané de votre PersistentVolumeClaim qui est toujours en transit (en attente du chargement complet des données). Son nom est au format prime-YOUR_PVC_UID.

Pour vérifier son état :

1. Exécutez les commandes suivantes :

   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 le résultat est vide, cela signifie que la PersistentVolumeClaim temporaire n'a pas été créée. Exécutez la commande suivante pour rechercher les avertissements d'événements PersistentVolumeClaim :

   kubectl describe pvc PVC_NAME -n NAMESPACE
   

   Si le provisionnement réussit, le résultat est semblable à ce qui suit. Recherchez le journal 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. Vérifiez si la création de l'instance Parallelstore a commencé.

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

   Le résultat renvoyé ressemble à ceci : Vérifiez que votre volume est à l'état CREATING. Une fois l'instance Parallelstore créée, l'état passe à 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 le provisionnement échoue, consultez le guide de dépannage de Parallelstore pour obtenir de l'aide.

Étapes suivantes

• Consultez la documentation de référence sur le CSI Parallelstore.
• Découvrez comment utiliser la bibliothèque d'interception Parallelstore pour améliorer les performances des charges de travail.
• Suivez le tutoriel pour entraîner un modèle TensorFlow avec Keras sur GKE.