Trasferisci i dati da Cloud Storage durante il provisioning dinamico utilizzando GKE Volume Populator

GKE Volume Populator consente di precaricare i dati da un'origine di archiviazione a un oggetto PersistentVolumeClaim di destinazione durante il provisioning dinamico, senza eseguire script o comandi CLI aggiuntivi per il trasferimento manuale dei dati. Questa funzionalità gestisce l'automazione e la semplificazione del processo di trasferimento dei dati sfruttando la funzionalità Kubernetes Volume Populator. Offre una portabilità dei dati senza interruzioni, in modo da poter scambiare i tipi di archiviazione per usufruire di ottimizzazioni di prezzo o prestazioni.

Utilizza questa funzionalità se devi trasferire grandi quantità di dati dai bucket Cloud Storage a un PersistentVolumeClaim supportato da un altro tipo di archiviazioneGoogle Cloud (ad esempio Parallelstore).

Interagisci principalmente con GKE Volume Populator tramite la gcloud CLI e la CLI kubectl. GKE Volume Populator è supportato sia sui cluster Autopilot sia su quelli Standard. Non è necessario abilitare GKE Volume Populator. È un componente gestito da GKE abilitato per impostazione predefinita.

Vantaggi

• Se vuoi sfruttare le prestazioni di un file system parallelo gestito, ma i tuoi dati sono archiviati in Cloud Storage, puoi utilizzare GKE Volume Populator per semplificare il trasferimento dei dati.
• GKE Volume Populator consente la portabilità dei dati. Puoi spostare i dati in base alle tue esigenze.
• GKE Volume Populator supporta l'autenticazione basata su IAM, in modo da poter trasferire i dati mantenendocontrollo dell'accessoo dell'accesso granulare.

Il diagramma mostra il flusso dei dati dallo spazio di archiviazione di origine a quello di destinazione e la creazione di PersistentVolume per lo spazio di archiviazione di destinazione utilizzando GKE Volume Populator.

Limitazioni

• GKE Volume Populator supporta solo i bucket Cloud Storage come archiviazione di origine e le istanze Parallelstore come tipo di archiviazione di destinazione.
• La risorsa personalizzata GCPDataSource deve trovarsi nello stesso spazio dei nomi del tuo workload Kubernetes. I volumi con origini dati tra spazi dei nomi non sono supportati.
• GKE Volume Populator supporta solo l'associazione di Workload Identity Federation for GKE di service account IAM a un service account Kubernetes. La concessione diretta delle autorizzazioni IAM al service account Kubernetes non è supportata.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:

• Abilita l'API Parallelstore e l'API Google Kubernetes Engine.
Abilita le API
• Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializzala. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo gcloud components update.

• Consulta la panoramica del driver CSI Parallelstore per limitazioni e requisiti.
• Crea i bucket Cloud Storage, compilati con i dati che vuoi trasferire.

Requisiti

Per utilizzare GKE Volume Populator, i cluster devono soddisfare i seguenti requisiti:

• Utilizza la versione del cluster GKE 1.31.1-gke.1729000 o successive.
• Avere il driver CSI Parallelstore abilitato. GKE abilita il driver CSI per impostazione predefinita nei cluster GKE Autopilot nuovi ed esistenti. Nei cluster Standard nuovi ed esistenti, devi attivare il driver CSI.

prepara l'ambiente

Questa sezione descrive i passaggi per creare i cluster GKE e configurare le autorizzazioni necessarie per utilizzare GKE Volume Populator.

Configura la rete VPC

Devi specificare la stessa rete Virtual Private Cloud (VPC) quando crei l'istanza Parallelstore e le VM Compute Engine client o i cluster GKE. Per consentire al VPC di connettersi privatamente ai servizi senza esporre il traffico alla rete internet pubblica, devi eseguire una configurazione una tantum dell'accesso ai servizi privati (PSA), se non l'hai già fatto. Google Cloud

Per configurare gli annunci di servizio pubblico:

1. Per configurare il peering di rete per il tuo progetto, configura l'autorizzazione IAM Compute Network Admin (roles/compute.networkAdmin).

   Per concedere il ruolo, esegui questo comando:

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

   Sostituisci EMAIL_ADDRESS con il tuo indirizzo email.

2. Attiva il service networking:

   gcloud services enable servicenetworking.googleapis.com
   

3. Crea una rete VPC:

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

   Sostituisci quanto segue:

   • NETWORK_NAME: il nome della rete VPC in cui creerai l'istanza Parallelstore.
   • PROJECT_ID: il tuo Google Cloud ID progetto.

4. Crea un intervallo IP.

   L'accesso privato ai servizi richiede un intervallo di indirizzi IP (blocco CIDR) con una lunghezza del prefisso di almeno /24 (256 indirizzi). Parallelstore riserva 64 indirizzi per istanza, il che significa che puoi riutilizzare questo intervallo IP con altri servizi o altre istanze Parallelstore, se necessario.

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

   Sostituisci IP_RANGE_NAME con il nome dell'intervallo IP della rete VPC.

5. Imposta una variabile di ambiente con l'intervallo CIDR associato all'intervallo che hai creato nel passaggio precedente:

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

6. Crea una regola firewall per consentire il traffico TCP dall'intervallo IP che hai creato:

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

   Sostituisci FIREWALL_NAME con il nome della regola firewall per consentire il traffico TCP dall'intervallo IP che hai creato.

7. Connetti il peering:

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

Se riscontri problemi durante la configurazione della rete VPC, consulta la guida per la risoluzione dei problemi di Parallelstore.

Crea il cluster GKE

Ti consigliamo di utilizzare un cluster Autopilot per un'esperienza Kubernetes completamente gestita. Per scegliere la modalità operativa GKE più adatta alle tue esigenze di carico di lavoro, consulta Scegliere una modalità operativa 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

Configurare le autorizzazioni necessarie

Per trasferire i dati da un bucket Cloud Storage, devi configurare le autorizzazioni per Workload Identity Federation for GKE.

1. Crea uno spazio dei nomi Kubernetes:

   kubectl create namespace NAMESPACE
   

   Sostituisci NAMESPACE con lo spazio dei nomi in cui verranno eseguiti i tuoi workload.

2. Crea un account di servizio Kubernetes.

   kubectl create serviceaccount KSA_NAME \
       --namespace=NAMESPACE
   

   Sostituisci KSA_NAME con il nome del account di servizio Kubernetes utilizzato dal pod per l'autenticazione alle API Google Cloud .

3. Crea un account di servizio IAM. Puoi anche utilizzare qualsiasi account di servizio IAM esistente in qualsiasi progetto della tua organizzazione:

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

   Sostituisci quanto segue:

   • IAM_SA_NAME: il nome del account di servizio IAM.
   • PROJECT_ID: il tuo Google Cloud ID progetto.

4. Concedi al tuo account di servizio IAM il ruolo roles/storage.objectViewer in modo che possa accedere al tuo 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"
   

   Sostituisci GCS_BUCKET con il nome del tuo bucket Cloud Storage.

5. Crea il criterio di autorizzazione IAM che concede al service account Kubernetes l'accesso per rappresentare l'account di servizio 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. Annota l'account di servizio Kubernetes in modo che GKE veda il collegamento tra gli account di servizio.

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

7. Crea l'identità del servizio Parallelstore:

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

8. Per consentire all'identità di servizio Parallelstore di rappresentare l'account di servizio IAM, concedi il ruolo roles/iam.serviceAccountTokenCreator all'identità di servizio Parallelstore. Imposta la variabile di ambiente PROJECT_NUMBER in modo da poterla utilizzare nei passaggi successivi.

   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
   

   Il valore PROJECT_NUMBER è l'identificatore univoco generato automaticamente per il tuo progetto. Per trovare questo valore, consulta la pagina Creazione e gestione dei progetti.

9. Per consentire all'identità di servizio Parallelstore di accedere a tutte le risorse a cui può accedere il account di servizio IAM, concedi il ruolo roles/iam.serviceAccountUser all'identità di servizio 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. Per consentire all'identità di servizio GKE di accedere a tutte le risorse a cui può accedere il account di servizio IAM, concedi il ruolo roles/iam.serviceAccountUser all'identità di servizio GKE. Questo passaggio non è necessario se il cluster GKE e ilaccount di serviziot IAM si trovano nello stesso progetto.

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

Crea un volume Parallelstore con dati precaricati

Le seguenti sezioni descrivono la procedura tipica per creare un volume Parallelstore con dati precaricati da un bucket Cloud Storage utilizzando GKE Volume Populator.

1. Crea una risorsa GCPDataSource.
2. Crea una StorageClass Parallelstore.
3. Crea un oggetto PersistentVolumeClaim per accedere al volume.
4. (Facoltativo) Visualizza l'avanzamento del trasferimento dei dati.
5. Crea un workload che utilizzi il volume.

Crea una risorsa GCPDataSource

Per utilizzare GKE Volume Populator, crea una risorsa personalizzata GCPDataSource. Questa risorsa definisce le proprietà di archiviazione di origine da utilizzare per il popolamento del volume.

1. Salva il seguente manifest in un file denominato 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/
   

   Sostituisci i seguenti valori:

   • GCP_DATA_SOURCE: il nome della CRD GCPDataSource che contiene un riferimento al tuo bucket Cloud Storage. Per maggiori dettagli, consulta il riferimento CRD GCPDataSource.
   • NAMESPACE: lo spazio dei nomi su cui verranno eseguiti i tuoi carichi di lavoro. Il valore dello spazio dei nomi deve corrispondere a quello del tuo workload.
   • KSA_NAME: il nome del service account Kubernetes che il pod utilizza per l'autenticazione alle API Google Cloud . Il valore di cloudStorage.serviceAccountName deve essere il service account Kubernetes che hai configurato per la federazione delle identità per i carichi di lavoro per GKE nel passaggio Configura le autorizzazioni necessarie.
   • GCS_BUCKET: il nome del bucket Cloud Storage. In alternativa, puoi anche specificare gs://GCS_BUCKET/PATH_INSIDE_BUCKET/ per il campo uri.

2. Crea la risorsa GCPDataSource eseguendo questo comando:

   kubectl apply -f gcpdatasource.yaml
   

Crea una StorageClass Parallelstore

Crea una StorageClass per indirizzare il driver CSI Parallelstore al provisioning delle istanze Parallelstore nella stessa regione del cluster GKE. Ciò contribuisce a garantire prestazioni I/O ottimali.

1. Salva il seguente manifest come 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 StorageClass eseguendo questo comando:

   kubectl apply -f parallelstore-class.yaml
   

Se vuoi creare una StorageClass personalizzata con una topologia specifica, consulta la guida CSI Parallelstore.

Crea un oggetto PersistentVolumeClaim per accedere al volume

Il seguente file manifest mostra un esempio di come creare un PersistentVolumeClaim in modalità di accesso ReadWriteMany che fa riferimento alla StorageClass creata in precedenza.

1. Salva il seguente manifest in un file denominato 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
   

   Sostituisci i seguenti valori:

   • PVC_NAME: il nome di PersistentVolumeClaim in cui vuoi trasferire i dati. PersistentVolumeClaim deve essere supportato da un'istanza Parallelstore.
   • NAMESPACE: lo spazio dei nomi in cui verranno eseguiti i tuoi carichi di lavoro. Il valore dello spazio dei nomi deve corrispondere a quello del tuo spazio dei nomi del workload.
   • GCP_DATA_SOURCE: il nome della CRD GCPDataSource che contiene un riferimento al tuo bucket Cloud Storage. Per ulteriori dettagli, consulta il riferimento CRD GCPDataSource.

2. Crea l'oggetto PersistentVolumeClaim eseguendo il seguente comando:

   kubectl apply -f volume-populator-pvc.yaml
   

GKE non pianificherà il pod del workload finché il provisioning di PersistentVolumeClaim non sarà completato. Per controllare l'avanzamento del trasferimento dei dati, vedi Visualizzare l'avanzamento del trasferimento dei dati. Se riscontri errori durante il provisioning, consulta Risoluzione dei problemi.

(Facoltativo) Visualizzare l'avanzamento del trasferimento dei dati

Questa sezione mostra come monitorare l'avanzamento dei trasferimenti di dati da un bucket Cloud Storage a un volume Parallelstore. Puoi farlo per monitorare lo stato del trasferimento e assicurarti che i dati vengano copiati correttamente. Dovresti eseguire questo comando anche se l'operazione di binding di PersistentVolumeClaim richiede troppo tempo.

1. Verifica lo stato di PersistentVolumeClaim eseguendo il seguente comando:

   kubectl describe pvc PVC_NAME -n NAMESPACE
   

2. Controlla il messaggio degli eventi PersistentVolumeClaim per trovare lo stato di avanzamento del trasferimento dei dati. GKE registra i messaggi circa una volta al minuto. L'output è simile al seguente:

   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'operazione di compilazione può richiedere del tempo per iniziare e dipende dalle dimensioni del file. Se dopo diversi minuti non vedi alcun avanzamento nel trasferimento dei dati, consulta la sezione Risoluzione dei problemi.

Crea un workload che utilizzi il volume

Questa sezione mostra un esempio di come creare un pod che utilizza la risorsa PersistentVolumeClaim creata in precedenza.

1. Salva il seguente manifest YAML per il pod come 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
   

   Sostituisci i seguenti valori:

   • POD_NAME: il nome del pod che esegue il tuo carico di lavoro.
   • NAMESPACE: lo spazio dei nomi in cui verranno eseguiti i tuoi carichi di lavoro. Il valore dello spazio dei nomi deve corrispondere a quello del tuo spazio dei nomi del workload.
   • PVC_NAME: il nome di PersistentVolumeClaim in cui vuoi trasferire i dati. PersistentVolumeClaim deve essere supportato da un'istanza Parallelstore.

2. Esegui questo comando per applicare il manifest al cluster:

   kubectl apply -f pod.yaml
   

3. Controlla lo stato del pod e attendi che sia RUNNING. Il tuo PersistentVolumeClaim deve essere associato prima che il workload possa essere eseguito.

   kubectl describe pod POD_NAME -n NAMESPACE
   

4. Verifica che i file siano stati trasferiti correttamente e che il tuo carico di lavoro possa accedervi.

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

   Passa alla directory /mnt/data ed esegui ls:

   cd /mnt/data
   ls
   

   L'output deve elencare tutti i file esistenti nell'URI del bucket Cloud Storage.

Eliminare un PersistentVolumeClaim durante il provisioning dinamico

Se devi eliminare PersistentVolumeClaim mentre i dati vengono ancora trasferiti durante il provisioning dinamico, hai due opzioni: eliminazione controllata ed eliminazione forzata.

L'eliminazione controllata richiede meno impegno, ma può richiedere più tempo e non tiene conto della configurazione errata dell'utente che impedisce il completamento del trasferimento dei dati. L'eliminazione forzata offre un'alternativa più rapida che consente maggiore flessibilità e controllo. Questa opzione è adatta quando devi riavviare rapidamente o correggere configurazioni errate.

Risoluzione dei problemi

Questa sezione mostra come risolvere i problemi relativi a GKE Volume Populator.

Prima di procedere, esegui il comando seguente per verificare la presenza di avvisi relativi agli eventi PersistentVolumeClaim:

kubectl describe pvc PVC_NAME -n NAMESPACE

Errore: An internal error has occurred

Se si verifica il seguente errore, significa che si è verificato un errore interno dell'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")

Per risolvere il problema, segui questi passaggi per raccogliere i dati per l'assistenza:

1. Esegui i seguenti comandi per ottenere il nome di PersistentVolumeClaim temporaneo, sostituendo i segnaposto con i nomi effettivi:

   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. Esegui questo comando per ottenere il nome del volume:

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

3. Contatta il team di assistenza comunicando il messaggio di errore, il nome del progetto e il nome del volume.

Problemi di autorizzazione

Se durante il popolamento del volume si verificano errori come i seguenti, significa che GKE ha riscontrato un problema di autorizzazioni:

• Il bucket Cloud Storage non esiste: PopulateOperationStartError con code = PermissionDenied
• Autorizzazioni mancanti per il bucket Cloud Storage o i service account: PopulateOperationFailed con "code: "xxx" message:"Verify if bucket "xxx" exists and grant access".
• Service account non trovato: PopulateOperationStartError con code = Unauthenticated.

Per risolvere questi errori, controlla quanto segue:

• Accesso al bucket Cloud Storage: verifica che il bucket esista e che il account di servizio disponga di roles/storage.objectViewer permission.
• Service account: verifica che esistano sia il account di servizio Kubernetes sia il account di servizio IAM e che siano collegati correttamente.
• Service account Parallelstore: assicurati che il account di servizio Parallelstore esista e disponga delle autorizzazioni necessarie (roles/iam.serviceAccountTokenCreator e roles/iam.serviceAccountUser sull'account IAM).

Per i passaggi dettagliati e i comandi di verifica, consulta Configurare le autorizzazioni necessarie. Se gli errori persistono, contatta l'assistenza e fornisci il messaggio di errore, il nome del progetto e il nome del bucket Cloud Storage.

Errori di argomento non valido

Se riscontri errori InvalidArgument, significa che probabilmente hai fornito valori errati in GCPDataSource o PersistentVolumeClaim. Il log degli errori indicherà i campi esatti contenenti i dati non validi. Controlla l'URI del bucket Cloud Storage e altri campi pertinenti per verificarne l'accuratezza.

Verifica che il provisioning di PersistentVolumeClaim sia stato completato

GKE Volume Populator utilizza un oggetto PersistentVolumeClaim temporaneo nello spazio dei nomi gke-managed-volumepopulator per il provisioning del volume.

Il PersistentVolumeClaim temporaneo è essenzialmente uno snapshot del tuo PersistentVolumeClaim ancora in transito (in attesa che i dati vengano caricati completamente). Il suo nome ha il formato prime-YOUR_PVC_UID.

Per controllare lo stato:

1. Esegui questi comandi:

   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
   

   Se l'output è vuoto, significa che la richiesta di volume permanente temporanea non è stata creata. Esegui questo comando per verificare la presenza di avvisi relativi all'evento PersistentVolumeClaim:

   kubectl describe pvc PVC_NAME -n NAMESPACE
   

   Se il provisioning è riuscito, l'output è simile al seguente. Cerca il log 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. Controlla se è iniziata la creazione dell'istanza Parallelstore.

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

   L'output è simile al seguente. Verifica che il volume sia impostato sullo stato CREATING. Al termine della creazione dell'istanza Parallelstore, lo stato cambierà in 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
   

Se il provisioning non riesce, consulta la guida alla risoluzione dei problemi di Parallelstore per ulteriori indicazioni.

Passaggi successivi

• Esplora la documentazione di riferimento del driver CSI Parallelstore.
• Scopri come utilizzare la libreria di intercettazione Parallelstore per migliorare le prestazioni del carico di lavoro.
• Prova il tutorial per addestrare un modello TensorFlow con Keras su GKE.