Cette page a été traduite par l'API Cloud Translation.

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

L'outil GKE Volume Populator n'est disponible que sur invitation. Si vous souhaitez demander l'accès à GKE Volume Populator dans votre projet Google Cloud , contactez votre représentant commercial.

Le remplisseur de volume GKE vous permet de précharger des données à partir d'un stockage source vers un PersistentVolumeClaim de destination lors du provisionnement dynamique, sans avoir à exécuter des scripts ou des commandes CLI supplémentaires pour le transfert manuel des données. Cette fonctionnalité gère l'automatisation et la simplification du processus de transfert de données en exploitant la fonctionnalité Kubernetes Volume Populator. Il offre une portabilité des données fluide, ce qui vous permet d'échanger des types 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 compatible avec un autre type de stockageGoogle Cloud (par exemple, Parallelstore).

Vous interagissez principalement avec le remplisseur de volumes GKE via gcloud CLI et la CLI kubectl. GKE Volume Populator est compatible avec les clusters Autopilot et Standard. Vous n'avez pas besoin d'activer le remplisseur de volumes GKE. Il s'agit d'un composant géré par GKE 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 le remplisseur de volume GKE pour simplifier le transfert de données.
Le remplisseur de volume GKE permet la portabilité des données. Vous pouvez déplacer des données en fonction de vos besoins.
Le remplisseur de volume GKE est compatible avec l'authentification basée sur IAM, ce qui vous permet de transférer des données tout en conservant un contrôle précis des accès.

Transfert de données depuis l'espace de stockage de données source et création d'un PV pour l'espace de stockage de destination à l'aide de l'outil de remplissage de volume GKE

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

Limites

Le remplisseur de volume GKE n'est compatible qu'avec les buckets Cloud Storage comme stockage source et les instances Parallelstore comme type de stockage de destination.
L'outil GKE Volume Populator n'est compatible qu'avec les ressources StorageClass dont l'attribut volumeBindingMode est défini sur Immediate.
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 multi-espaces de noms ne sont pas acceptés.
Le remplisseur de volume GKE n'est compatible qu'avec la liaison 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.
Remarque : Pour les installations de gcloud CLI existantes, veillez à définir les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

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

Conditions requises

Pour utiliser le remplisseur de volumes GKE, 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 par défaut sur les clusters GKE Autopilot nouveaux et existants. Sur les clusters standards 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 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 en privé aux services Google Cloudsans exposer le trafic à Internet public, vous devez effectuer une configuration unique de l'accès aux services privés (PSA), si vous ne l'avez pas déjà fait.

Pour configurer PSA, procédez comme suit:

Configurez l'autorisation IAM Administrateur de réseaux Compute (roles/compute.networkAdmin) afin de configurer l'appairage de réseaux pour votre projet.

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.

Activez le service networking:

gcloud services enable servicenetworking.googleapis.com

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
Remarque :Définir la valeur de mtu (unité de transmission maximale, ou taille du plus grand paquet IP pouvant être transmis sur ce réseau) sur la valeur maximale autorisée de 8 896 améliore les performances jusqu'à 10% par rapport à la valeur par défaut de 1 460 octets.
Créez une plage d'adresses IP.

L'accès aux services privés nécessite une plage d'adresses IP (bloc CIDR) dont la longueur de préfixe est 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.

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

Créez une règle de pare-feu pour autoriser le trafic TCP à partir 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 allez créer.

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é aux besoins de votre charge de travail, consultez la section Choisir un mode de fonctionnement GKE.

Autopilot

Pour créer un cluster GKE à l'aide d'Autopilot, exécutez la commande suivante:

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

GKE active la fédération d'identité de charge de travail pour GKE et le pilote CSI Parallelstore par défaut dans les clusters Autopilot.

Remplacez les valeurs suivantes :

CLUSTER_NAME : nom du cluster
CLUSTER_VERSION : numéro de version de GKE. Vous devez spécifier la version 1.31.1-gke.1729000 ou une version ultérieure.
NETWORK_NAME: nom du réseau VPC que vous avez créé pour l'instance Parallelstore. Pour en savoir plus, consultez la section Configurer un réseau VPC.
CLUSTER_LOCATION: région dans laquelle vous souhaitez créer votre cluster. Pour des performances optimales, nous vous recommandons de créer le cluster dans un emplacement Parallelstore compatible. Si vous souhaitez créer votre cluster dans un emplacement Parallelstore non compatible, vous devez spécifier une topologie personnalisée qui utilise un emplacement Parallelstore compatible lorsque vous créez une classe de stockage Parallelstore. Sinon, le provisionnement échouera.

Standard

Créez un cluster standard avec le pilote CSI Parallelstore et la fédération d'identité de charge de travail pour GKE activées à l'aide de la commande suivante:

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

Remplacez les valeurs suivantes :

CLUSTER_NAME : nom du cluster
CLUSTER_VERSION: numéro de version de GKE. Vous devez spécifier la version 1.31.1-gke.1729000 ou ultérieure.
PROJECT_ID: ID de votre projet Google Cloud
NETWORK_NAME: nom du réseau VPC que vous avez créé pour l'instance Parallelstore. Pour en savoir plus, consultez la section Configurer un réseau VPC.
CLUSTER_LOCATION: région ou zone dans laquelle vous souhaitez créer votre cluster. Pour des performances optimales, nous vous recommandons de créer le cluster dans un emplacement Parallelstore compatible. Si vous souhaitez créer votre cluster dans un emplacement Parallelstore non compatible, vous devez spécifier une topologie personnalisée qui utilise un emplacement Parallelstore compatible lorsque vous créez une classe de stockage Parallelstore. Sinon, le provisionnement échouera.

Configurer les autorisations nécessaires

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

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

Attention :Si vous réutilisez ce compte de service Kubernetes dans une charge de travail du même espace de noms, ce pod pourra accéder au bucket Cloud Storage. Nous vous recommandons de ne pas réutiliser ce compte de service pour les charges de travail de l'espace de noms.
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

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.

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

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

Créez l'identité du service Parallelstore:

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

Attribuez le rôle roles/iam.serviceAccountTokenCreator à l'identité de service Parallelstore pour lui permettre d'usurper l'identité du compte de service IAM. Définissez la variable d'environnement PROJECT_NUMBER afin de pouvoir l'utiliser dans les é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 la section Créer et gérer des projets.

Accordez le rôle roles/iam.serviceAccountUser à l'identité de service Parallelstore pour lui permettre d'accéder à toutes les ressources auxquelles le compte de service IAM peut accéder:

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

Attribuez le rôle roles/iam.serviceAccountUser à l'identité de service GKE pour lui permettre d'accéder à toutes les ressources auxquelles le compte de service IAM peut accéder. 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 remplisseur de volume GKE.

Créez une ressource GCPDataSource.
Créez une ressource StorageClass Parallelstore.
Créez un objet PersistentVolumeClaim pour accéder au volume.
Vérifiez que le provisionnement du PersistentVolumeClaim est terminé.
(Facultatif) Afficher la progression du transfert de données
Créer une charge de travail qui utilise le volume.

Créer une ressource `GCPDataSource`

Pour utiliser le remplisseur de volume GKE, créez une ressource personnalisée GCPDataSource. Cette ressource définit les propriétés de stockage source à utiliser pour la population de volumes.

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 de la CRD GCPDataSource contenant une référence à votre bucket Cloud Storage. Pour en savoir plus, consultez la documentation de référence sur le CRD GCPDataSource.
- NAMESPACE: espace de noms sur lequel vos charges de travail s'exécuteront. La valeur de l'espace de noms doit être identique à celle de votre espace de noms de 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.
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 garantit des performances d'E/S optimales.

Enregistrez le fichier manifeste suivant sous le nom parallelstore-class.yaml. Assurez-vous que le champ volumeBindingMode de la définition de StorageClass est défini sur Immediate.

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

Créez l'objet StorageClass en exécutant la commande suivante :
```
kubectl apply -f parallelstore-class.yaml
```

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

Créer un objet 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.

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 pris en charge 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 votre espace de noms de charge de travail.
- GCP_DATA_SOURCE: nom de la CRD GCPDataSource contenant une référence à votre bucket Cloud Storage. Pour en savoir plus, consultez la documentation de référence sur le CRD GCPDataSource.
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.

Vérifier que le provisionnement du PersistentVolumeClaim est terminé

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

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

Pour vérifier son état:

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 la sortie est vide, cela signifie que l'objet PersistentVolumeClaim temporaire n'a pas été créé. Dans ce cas, consultez la section Dépannage.

Si le provisionnement réussit, le résultat est semblable à celui-ci. 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"

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 la création de l'instance Parallelstore terminée, son é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 a échoué, consultez le guide de dépannage Parallelstore pour obtenir des conseils supplémentaires.

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

Cette section explique comment suivre la progression de vos transferts de données d'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 correctement copiées. Vous devez également exécuter cette commande si votre opération de liaison PersistentVolumeClaim prend trop de temps.

Vérifiez l'état de votre PersistentVolumeClaim en exécutant la commande suivante:
```
kubectl describe pvc PVC_NAME -n NAMESPACE
```

Vérifiez le message des événements PersistentVolumeClaim pour connaître la progression 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, car elle dépend de la taille du fichier. Si aucune progression du transfert de données ne s'affiche au bout de 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.

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 votre espace de noms de charge de travail.
- PVC_NAME: nom du PersistentVolumeClaim vers lequel vous souhaitez transférer vos données. Le PersistentVolumeClaim doit être pris en charge par une instance Parallelstore.
Exécutez la commande suivante pour appliquer le fichier manifeste au cluster :
```
kubectl apply -f pod.yaml
```
Vérifiez l'état de votre pod et attendez qu'il soit RUNNING. Votre PersistentVolumeClaim doit être lié avant que la charge de travail puisse s'exécuter.
```
kubectl describe pod POD_NAME -n NAMESPACE
```
Vérifiez que les fichiers ont bien été transférés et que votre charge de travail peut y accéder.
```
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 présents 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 toujours transférées lors du provisionnement dynamique, deux options s'offrent à vous: la suppression élégante et la suppression forcée.

La suppression élégante nécessite moins d'efforts, mais peut être plus longue et ne tient pas compte des erreurs de configuration de l'utilisateur qui empêchent le transfert de données d'être effectué. La suppression forcée offre 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.

Suppression élégante

Utilisez cette option de suppression pour vous assurer que le processus de transfert de données est terminé avant que GKE ne supprime les ressources associées.

Supprimez le pod de la charge de travail s'il existe en exécutant la commande suivante:
```
kubectl delete pod POD_NAME -n NAMESPACE
```

Recherchez le nom du PersistentVolumeClaim temporaire:

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

echo $TEMP_PVC

Recherchez le nom du PersistentVolume:

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

echo ${PV_NAME?}

Si la sortie est vide, cela signifie que l'objet PersistentVolume n'a pas encore été créé.

Supprimez votre PersistentVolumeClaim en exécutant cette commande. Le finaliseur bloquera votre opération de suppression. Appuyez sur Ctrl+C, puis passez à l'étape suivante.
```
kubectl delete pvc PVC_NAME -n NAMESPACE
```
Attendez que le transfert de données soit terminé. GKE finira par supprimer les instances PersistentVolumeClaim, PersistentVolume et Parallelstore.
Vérifiez que les ressources PersistentVolumeClaim, PersistentVolumeClaim et PersistentVolume temporaires sont supprimées:
```
kubectl get pvc,pv -A | grep -E "${TEMP_PVC?}|PVC_NAME|${PV_NAME?}"
```
Vérifiez que l'instance Parallelstore est supprimée. L'instance Parallelstore portera le même nom que le PersistentVolume. Vous n'avez pas besoin d'exécuter cette commande si vous avez confirmé à l'étape 3 que le PersistentVolume n'a pas été créé.
```
gcloud beta parallelstore instances list \
    --project=PROJECT_ID \
    --location=- | grep ${PV_NAME?}
```

Suppression forcée

Utilisez cette option de suppression lorsque vous devez supprimer un PersistentVolumeClaim et les ressources associées avant la fin du processus de transfert de données. Cela peut être nécessaire lorsque le transfert de données prend trop de temps ou a rencontré des erreurs, ou si vous devez récupérer rapidement des ressources.

Supprimez le pod de charge de travail s'il existe:
```
kubectl delete pod POD_NAME -n NAMESPACE
```
Mettez à jour la règle de récupération de PersistentVolume sur Delete. Cela garantit que le PersistentVolume, ainsi que le stockage sous-jacent, est automatiquement supprimé lorsque le PersistentVolumeClaim associé est supprimé.

Ignorez la commande suivante si l'une des conditions suivantes est remplie:
- Vous ne souhaitez pas supprimer le PersistentVolume ni le stockage sous-jacent.
- Votre règle de récupération actuelle est Retain, et vous souhaitez conserver l'espace de stockage sous-jacent. Nettoyez manuellement le PersistentVolume et l'instance de stockage si nécessaire.
- La commande echo $PV_NAME suivante génère une chaîne vide, ce qui signifie que le PersistentVolume n'a pas encore été créé.
```
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"}}'
```

Recherchez le nom de l'objet PersistentVolumeClaim temporaire et définissez la variable d'environnement pour une étape ultérieure:

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

TEMP_PVC=prime-$PVC_UID

echo $TEMP_PVC

Supprimez le PersistentVolumeClaim en exécutant cette commande. Le finaliseur bloquera votre opération de suppression. Appuyez sur Ctrl+C, puis passez à l'étape suivante.
```
kubectl delete pvc PVC_NAME -n NAMESPACE
```
Supprimez le finaliseur datalayer.gke.io/populate-target-protection de votre objet PersistentVolumeClaim. Cette étape est nécessaire après la suppression du PersistentVolumeClaim, sinon gke-volume-populator ajoute à nouveau le finaliseur au PersistentVolumeClaim.
```
kubectl get pvc PVC_NAME -n NAMESPACE -o=json | \
jq '.metadata.finalizers = null' | kubectl apply -f -
```
Supprimez le PersistentVolumeClaim temporaire dans l'espace de noms gke-managed-volumepopulator.
```
kubectl delete pvc $TEMP_PVC -n gke-managed-volumepopulator
```
Vérifiez que les ressources PersistentVolumeClaim, PersistentVolumeClaim et PersistentVolume temporaires sont supprimées:
```
kubectl get pvc,pv -A | grep -E "${TEMP_PVC?}|PVC_NAME|${PV_NAME?}"
```
Vérifiez que l'instance Parallelstore est supprimée. L'instance Parallelstore portera le même nom que le PersistentVolume. Vous n'avez pas besoin d'exécuter cette commande si vous avez confirmé à l'étape 2 que le PersistentVolume n'a pas été créé.
```
gcloud beta parallelstore instances list \
    --project=PROJECT_ID \
    --location=- | grep ${PV_NAME?}
```

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 rechercher des avertissements d'événements PersistentVolumeClaim:

kubectl describe pvc PVC_NAME -n NAMESPACE

Erreur : `An internal error has occurred`

Si l'erreur suivante s'affiche, 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 pour collecter des données pour l'assistance:

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?}
```

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}')

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

Problèmes d'autorisation

Si vous rencontrez des erreurs telles que celles-ci lors de la population d'un volume, cela signifie que GKE a rencontré un problème d'autorisation:

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 problèmes, vérifiez les points suivants:

Accès au bucket Cloud Storage: vérifiez que le bucket existe et que le compte de service dispose de l'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 qu'il existe et qu'il dispose des autorisations nécessaires (roles/iam.serviceAccountTokenCreator et roles/iam.serviceAccountUser sur le compte IAM).

Pour connaître la procédure détaillée et les commandes de validation, consultez Configurer les autorisations nécessaires. Si les erreurs persistent, contactez l'assistance en indiquant le message d'erreur, le nom de votre projet et le nom du bucket Cloud Storage.

Erreurs d'argument incorrect

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