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

Autopilot Standard

---

GKE Volume Populator è disponibile solo su invito. Se vuoi richiedere l'accesso a GKE Volume Populator nel tuo progetto Google Cloud, contatta il tuo rappresentante di vendita.

GKE Volume Populator ti consente di precaricare i dati da uno spazio di archiviazione di origine a un PersistentVolumeClaim di destinazione durante il provisioning dinamico, senza dover 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 cambiare tipo 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 una richiesta di volume persistente supportata da un altro tipo di archiviazione Google Cloud (ad esempio Parallelstore).

Interagisci principalmente con GKE Volume Populator tramite l'interfaccia a riga di comando gcloud CLI'interfaccia a riga di comando kubectl. GKE Volume Populator è supportato sia nei cluster Autopilot sia nei cluster Standard. Non è necessario attivare GKE Volume Populator. Si tratta di 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, quindi puoi trasferire i dati mantenendo controllo dell'accesso granulare.

Il diagramma mostra il flusso dei dati dallo spazio di archiviazione di origine allo spazio di archiviazione di destinazione e la creazione del volume permanente per lo spazio di archiviazione di destinazione utilizzando GKE Volume Populator.

Limitazioni

• GKE Volume Populator supporta solo bucket Cloud Storage come archiviazione di origine e istanze Parallelstore come tipo di archiviazione di destinazione.
• GKE Volume Populator supporta solo le risorse StorageClass con volumeBindingMode impostato su Immediate.
• La risorsa personalizzata GCPDataSource deve trovarsi nello stesso spazio dei nomi del workload Kubernetes. I volumi con origini dati in più spazi dei nomi non sono supportati.
• GKE Volume Populator supporta solo la federazione delle identità per i carichi di lavoro per GKE obbligatoria degli account di servizio IAM a un account di servizio Kubernetes. La concessione di autorizzazioni IAM direttamente all'account di servizio 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à, installa e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, ottieni la versione più recente eseguendo gcloud components update.
  Nota: per le installazioni esistenti di gcloud CLI, assicurati di impostare le proprietà compute/region e compute/zone. Se imposti le posizioni predefinite, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location.

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

Requisiti

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

• Utilizza il cluster GKE versione 1.31.1-gke.1729000 o successive.
• Il driver CSI Parallelstore deve essere abilitato. GKE attiva il driver CSI per impostazione predefinita nei cluster GKE Autopilot nuovi ed esistenti. Nei cluster standard nuovi ed esistenti, dovrai attivare il driver CSI.

prepara l'ambiente

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

Configura la rete VPC

Nota: se hai già configurato la tua rete VPC nell'ambito della configurazione del driver CSI Parallelstore, puoi saltare questa sezione.

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

Per configurare la campagna PSA:

1. Configura l'autorizzazione IAM Amministratore rete Compute (roles/compute.networkAdmin) per configurare il peering di rete per il tuo progetto.

   Per concedere il ruolo, esegui il seguente 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 la rete di servizi:

   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 verrà creata l'istanza Parallelstore.
   • PROJECT_ID: il tuo ID progetto Google Cloud.
   Nota: l'impostazione del valore di mtu (unità di trasmissione massima o dimensione del pacchetto IP più grande che può essere trasmesso su questa rete) sul valore massimo consentito di 8896 migliora il rendimento fino al 10% rispetto al valore predefinito di 1460 byte.

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 del firewall per consentire il traffico TCP dall'intervallo IP che creerai.

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 alla 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 di GKE più adatta alle esigenze del tuo carico di lavoro, consulta Scegliere una modalità operativa di GKE.

Autopilot

Per creare un cluster GKE utilizzando Autopilot, esegui il seguente comando:

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

GKE abilita Workload Identity Federation for GKE e il driver CSI Parallelstore per impostazione predefinita nei cluster Autopilot.

Sostituisci i seguenti valori:

• CLUSTER_NAME: il nome del tuo cluster.
• CLUSTER_VERSION : il numero di versione di GKE. Devi specificare 1.31.1-gke.1729000 o una versione successiva.
• NETWORK_NAME: il nome della rete VPC che hai creato per l'istanza Parallelstore. Per scoprire di più, consulta Configurare una rete VPC.
• CLUSTER_LOCATION: la regione in cui vuoi creare il cluster. Per ottenere il massimo delle prestazioni, ti consigliamo di creare il cluster in una posizione Parallelstore supportata. Se vuoi creare il cluster in una posizione Parallelstore non supportata, quando crei un StorageClass Parallelstore devi specificare una topologia personalizzata che utilizzi la posizione Parallelstore supportata, altrimenti il provisioning non andrà a buon fine.

Standard

Crea un cluster standard con il driver CSI Parallelstore e la federazione delle identità per i carichi di lavoro per GKE abilitati utilizzando il seguente 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

Sostituisci i seguenti valori:

• CLUSTER_NAME: il nome del tuo cluster.
• CLUSTER_VERSION: il numero della versione GKE. Devi specificare 1.31.1-gke.1729000 o una versione successiva.
• PROJECT_ID: il tuo ID progetto Google Cloud.
• NETWORK_NAME: il nome della rete VPC che hai creato per l'istanza Parallelstore. Per scoprire di più, consulta Configurare una rete VPC.
• CLUSTER_LOCATION: la regione o la zona in cui vuoi creare il cluster. Per ottenere il massimo delle prestazioni, ti consigliamo di creare il cluster in una posizione Parallelstore supportata. Se vuoi creare il cluster in una posizione Parallelstore non supportata, quando crei un StorageClass Parallelstore devi specificare una topologia personalizzata che utilizzi la posizione Parallelstore supportata, altrimenti il provisioning non andrà a buon fine.

Configura 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 carichi di lavoro.

2. Crea un account di servizio Kubernetes.

   kubectl create serviceaccount KSA_NAME \
       --namespace=NAMESPACE
   

   Sostituisci KSA_NAME con il nome dell'account di servizio Kubernetes utilizzato dal pod per autenticarsi alle API Google Cloud.

   Attenzione: il riutilizzo di questo account di servizio Kubernetes in un carico di lavoro nello stesso spazio dei nomi consentirà al pod di accedere al bucket Cloud Storage. Ti consigliamo di non riutilizzare questo account di servizio per i carichi di lavoro nello spazio dei nomi.

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 tuo account di servizio IAM.
   • PROJECT_ID: il tuo ID progetto Google Cloud.

4. Concedi al tuo account di servizio IAM il ruolo roles/storage.objectViewer in modo che possa accedere al 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 all'account di servizio Kubernetes l'accesso per rubare l'identità dell'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. Aggiungi un'annotazione all'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à di servizio Parallelstore:

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

8. Concedi all'identità di servizio Parallelstore il ruolo roles/iam.serviceAccountTokenCreator per consentirle di rubare l'identità dell'account di servizio IAM. 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 progetto. Per trovare questo valore, consulta Creare e gestire progetti.

9. Concedi all'identità di servizio Parallelstore il ruoloroles/iam.serviceAccountUser per consentirle di accedere a tutte le risorse a cui può accedere l'account di servizio IAM:

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

10. Concedi all'identità di servizio GKE il ruolo roles/iam.serviceAccountUser per consentirle di accedere a tutte le risorse a cui può accedere l'account di servizio IAM. Questo passaggio non è necessario se il cluster GKE e l'account di servizio 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
    

Creare un volume Parallelstore con dati precaricati

Le sezioni seguenti 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 un StorageClass Parallelstore.
3. Crea un oggetto PersistentVolumeClaim per accedere al volume.
4. Verifica che il provisioning di PersistentVolumeClaim sia stato completato.
5. (Facoltativo) Visualizza l'avanzamento del trasferimento dei dati.
6. Crea un workload che consumi 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 la compilazione 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 risorsa GCPDataSource CRD che contiene un riferimento al tuo bucket Cloud Storage. Per ulteriori dettagli, consulta le informazioni di riferimento GCPDataSource CRD.
   • NAMESPACE: lo spazio dei nomi in cui verranno eseguiti i carichi di lavoro. Il valore dello spazio dei nomi deve corrispondere a quello del tuo spazio dei nomi del workload.
   • KSA_NAME: il nome dell'account di servizio Kubernetes utilizzato dal pod per autenticarsi alle API Google Cloud. Il valore cloudStorage.serviceAccountName deve essere l'account di servizio 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 classe di archiviazione Parallelstore

Crea un StorageClass per indicare al driver CSI Parallelstore di eseguire il provisioning delle istanze Parallelstore nella stessa regione del tuo cluster GKE. In questo modo vengono garantite prestazioni I/O ottimali.

1. Salva il seguente manifest come parallelstore-class.yaml. Assicurati che il campo volumeBindingMode nella definizione di StorageClass sia impostato su Immediate.

   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 un StorageClass personalizzato 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 ReadWriteMany modalità di accesso 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 del PersistentVolumeClaim куда vuoi trasferire i dati. Il PersistentVolumeClaim deve essere supportato da un'istanza Parallelstore.
   • NAMESPACE: lo spazio dei nomi in cui verranno eseguiti i 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 risorsa GCPDataSource CRD che contiene un riferimento al tuo bucket Cloud Storage. Per ulteriori dettagli, consulta la documentazione di riferimento GCPDataSource CRD.

2. Crea il PersistentVolumeClaim eseguendo il seguente comando:

   kubectl apply -f volume-populator-pvc.yaml
   

GKE non pianificherà il pod del workload fino al completamento del provisioning di PersistentVolumeClaim. Per controllare lo stato di avanzamento del trasferimento dei dati, vedi Visualizzare lo stato di avanzamento del trasferimento dei dati. Se si verificano errori durante il provisioning, consulta la sezione Risoluzione dei problemi.

Verifica che il provisioning di PersistentVolumeClaim sia stato completato

Attenzione: se utilizzi Autopilot, prima di eseguire questa verifica, assicurati innanzitutto di creare un carico di lavoro che consumi il volume. Questo passaggio è necessario per attivare la creazione di un nodo da parte di GKE. In caso contrario, potrebbe essere visualizzato un errore come questo che persiste per diversi minuti: "error generating accessibility requirements: no available topology found".

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

Il PersistentVolumeClaim temporaneo è essenzialmente uno snapshot del PersistentVolumeClaim ancora in transito (in attesa del caricamento completo dei dati). Il 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 PersistentVolumeClaim temporanea non è stata creata. In questo caso, consulta la sezione Risoluzione dei problemi.

   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"
   

   Nota: gli avvisi nell'output sono previsti, poiché il provisioning CSI sta tentando di riconciliare lo stato del provisioning del volume. Il provisioning del volume Parallelstore richiede in genere circa 10 minuti.

2. Verifica se la creazione dell'istanza Parallelstore è iniziata.

   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 è riuscito, consulta la guida alla risoluzione dei problemi di Parallelstore per ulteriori indicazioni.

(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 associazione di PersistentVolumeClaim richiede troppo tempo.

1. Verifica lo stato del tuo 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'avvio dell'operazione di compilazione può richiedere del tempo. Questa operazione dipende dalle dimensioni del file. Se dopo alcuni minuti non vedi alcun avanzamento del trasferimento dei dati, consulta la sezione Risoluzione dei problemi.

Crea un carico di lavoro che consumi 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 tuo 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 carico di lavoro.
   • NAMESPACE: lo spazio dei nomi in cui verranno eseguiti i carichi di lavoro. Il valore dello spazio dei nomi deve corrispondere a quello del tuo spazio dei nomi del workload.
   • PVC_NAME: il nome del PersistentVolumeClaim куда vuoi trasferire i dati. Il PersistentVolumeClaim deve essere supportato da un'istanza Parallelstore.

2. Esegui il seguente 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 dovrebbe 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 sono ancora in fase di trasferimento durante il provisioning dinamico, hai due opzioni: eliminazione graduale e 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 o correggere rapidamente le configurazioni errate.

Eliminazione controllata

Utilizza questa opzione di eliminazione per assicurarti che la procedura di trasferimento dei dati sia completata prima che GKE elimini le risorse associate.

1. Elimina il pod del workload, se esistente, eseguendo questo comando:

   kubectl delete pod POD_NAME -n NAMESPACE
   

2. Trova il nome della richiesta PersistentVolumeClaim temporanea:

   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. Trova il nome del PersistentVolume:

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

   Se l'output è vuoto, significa che il volume persistente non è stato ancora creato.

4. Elimina il PersistentVolumeClaim eseguendo questo comando. Il finalizer blocca l'operazione di eliminazione. Premi Ctrl+C, quindi vai al passaggio successivo.

   kubectl delete pvc PVC_NAME -n NAMESPACE
   

   Attendi il completamento del trasferimento dei dati. GKE eliminerà infine il PersistentVolumeClaim, il PersistentVolume e l'istanza Parallelstore.

5. Verifica che le risorse temporanee PersistentVolumeClaim, PersistentVolumeClaim e PersistentVolume siano state eliminate:

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

6. Verifica che l'istanza Parallelstore sia stata eliminata. L'istanza Parallelstore condividerà lo stesso nome del volume persistente. Non è necessario eseguire questo comando se nel passaggio 3 hai confermato che il volume persistente non è stato creato.

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

Eliminazione forzata

Utilizza questa opzione di eliminazione quando devi eliminare un PersistentVolumeClaim e le relative risorse associate prima del completamento del processo di trasferimento dei dati. Questo potrebbe essere necessario in situazioni in cui il trasferimento dei dati richiede troppo tempo o ha riscontrato errori oppure se devi recuperare rapidamente le risorse.

1. Elimina il pod del carico di lavoro, se esistente:

   kubectl delete pod POD_NAME -n NAMESPACE
   

2. Aggiorna il criterio di recupero del volume permanente su Delete. In questo modo, il volume permanente, insieme allo spazio di archiviazione sottostante, viene eliminato automaticamente quando viene eliminato il relativo claim volume permanente.

   Salta il comando seguente se si applica una delle seguenti condizioni:

   • Non vuoi eliminare PersistentVolume o lo spazio di archiviazione sottostante.
   • Il tuo criterio di recupero corrente è Retain e vuoi mantenere lo spazio di archiviazione sottostante. Elimina manualmente il PersistentVolume e l'istanza di archiviazione come necessario.
   • Il seguente comando echo $PV_NAME restituisce una stringa vuota, il che significa che il volume persistente non è stato ancora creato.

   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. Trova il nome del volume persistente temporaneo e imposta la variabile di ambiente per un passaggio successivo:

   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 il PersistentVolumeClaim eseguendo questo comando. Il finalizer blocca l'operazione di eliminazione. Premi Ctrl+C, quindi vai al passaggio successivo.

   kubectl delete pvc PVC_NAME -n NAMESPACE
   

5. Rimuovi il finalizzatore datalayer.gke.io/populate-target-protection dal PersistentVolumeClaim. Questo passaggio è necessario dopo aver eliminato il PersistentVolumeClaim, altrimenti gke-volume-populator aggiunge di nuovo il finalizzatore al PersistentVolumeClaim.

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

6. Elimina il PersistentVolumeClaim temporaneo nello spazio dei nomi gke-managed-volumepopulator.

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

7. Verifica che le risorse temporanee PersistentVolumeClaim, PersistentVolumeClaim e PersistentVolume siano state eliminate:

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

8. Verifica che l'istanza Parallelstore sia stata eliminata. L'istanza Parallelstore condividerà lo stesso nome del volume persistente. Non è necessario eseguire questo comando se hai confermato nel passaggio 2 che PersistentVolume non è stato creato.

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

Risoluzione dei problemi

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

Prima di procedere, esegui il seguente comando 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, devi seguire questi passaggi per raccogliere i dati per il team di assistenza:

1. Esegui i comandi seguenti per ottenere il nome della richiesta di volume permanente provvisoria, 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 il comando seguente 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 fornendo il messaggio di errore, il nome del progetto e il nome del volume.

Problemi di autorizzazione

Se durante la compilazione del volume si verificano errori come il seguente, significa che GKE ha riscontrato un problema di autorizzazioni:

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

Per risolvere il problema, verifica quanto segue:

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

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

Errori relativi agli argomenti non validi

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. Verifica la correttezza dell'URI del bucket Cloud Storage e di altri campi pertinenti.

Passaggi successivi

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