Automatizza il trasferimento dei dati da Cloud Storage a un volume Hyperdisk ML utilizzando GKE Volume Populator

Questa guida descrive come precaricare grandi quantità di dati da un bucket Cloud Storage a un volume Hyperdisk ML di Google Kubernetes Engine (GKE) durante il provisioning dinamico utilizzando GKE Volume Populator. Per maggiori informazioni, consulta Informazioni su GKE Volume Populator.

Questa guida è pensata per gli esperti di archiviazione che creano e allocano spazio di archiviazione e gestiscono la sicurezza e l'accesso ai dati. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei contenuti di Trusted Cloud by S3NS , consulta Ruoli utente e attività comuni di GKE.

Gestione dei node pool per GKE Volume Populator con Hyperdisk ML

Il dimensionamento, il provisioning e lo scaling efficienti del pool di nodi sono fondamentali per eseguire correttamente i job di trasferimento dei dati creati da GKE Volume Populator per popolare i volumi Hyperdisk ML. Utilizzi una classe di calcolo per definire i requisiti dei nodi, come il tipo e le dimensioni della macchina, per questi job di trasferimento dei dati specifici. Una classe di calcolo ti consente di controllare il costo e le prestazioni del processo di trasferimento dei dati. Per ulteriori informazioni, consulta Vantaggi delle classi di computing personalizzate.

Per scegliere un cluster più adatto ai tuoi job di trasferimento dei dati, scopri come funzionano le classi di calcolo con diversi tipi di cluster per Hyperdisk ML.

Obiettivi

In questa guida imparerai a:

• Configura l'ambiente del cluster GKE per supportare i trasferimenti di dati utilizzando GKE Volume Populator, inclusi la creazione del cluster, la definizione della classe di calcolo e la configurazione delle autorizzazioni.
• Crea una risorsa personalizzata GCPDataSource per specificare il bucket Cloud Storage di origine.
• Definisci un StorageClass per Hyperdisk ML.
• Crea un PersistentVolumeClaim che faccia riferimento a GCPDataSource per attivare il popolamento dei dati in un volume Hyperdisk ML.
• Verifica il trasferimento dei dati.
• Utilizza il volume compilato in un pod.
• Esegui la pulizia delle risorse.

Prima di iniziare

Assicurati di aver eseguito le seguenti attività:

1. Abilita le API GKE e Cloud Storage.

   Abilita le API

2. Verifica che la fatturazione sia attivata per il tuo Trusted Cloud by S3NS progetto.

3. Scarica e installa lo strumento a riga di comando Google Cloud CLI o utilizza Cloud Shell per eseguire i comandi gcloud CLI e kubectl. Cloud Shell è un ambiente shell per la gestione delle risorse ospitate su Trusted Cloud by S3NS. È preinstallato con gli strumento a riga di comando gcloud e kubectl.

4. Imposta un'area geografica e una zona predefinite.

5. Crea o utilizza un bucket Cloud Storage esistente. Questa guida presuppone che tu abbia già un bucket Cloud Storage compilato con i dati di addestramento del modello.

6. Abilita il driver CSI per il disco permanente di Compute Engine nei cluster Standard esistenti in cui il driver potrebbe essere disabilitato in modo esplicito. Nei nuovi cluster Autopilot e Standard, GKE abilita il driver per impostazione predefinita. L'archiviazione Hyperdisk ML di destinazione che crei deve essere gestita dal driver CSI per il disco permanente di Compute Engine.

7. Abilita Workload Identity Federation for GKE sul cluster. Ciò consente al account di servizio Kubernetes utilizzato da GKE Volume Populator di accedere al bucket Cloud Storage di origine. Per saperne di più, vedi Configurare le autorizzazioni necessarie.

Requisiti

Per trasferire i dati utilizzando GKE Volume Populator, soddisfa i seguenti requisiti:

• Il cluster GKE deve eseguire la versione 1.33.2-gke.4780000 o successive.
• La risorsa personalizzata GCPDataSource deve trovarsi nello stesso spazio dei nomi del carico di lavoro GKE. Le origini dati che si estendono su spazi dei nomi diversi non sono supportate.
• Seleziona una VM supportata quando crei la classe di computing. Verifica che il tuo progetto disponga di una quota sufficiente per il tipo di macchina selezionato.
• Il nome della classe di calcolo gcs-to-hdml-compute-class è predefinito per il job di trasferimento e deve essere specificato esattamente quando crei la classe di calcolo.

Costi

Sebbene non vi sia alcun costo diretto per l'utilizzo di GKE Volume Populator, l'archiviazione e i trasferimenti di dati comportano addebiti di fatturazione. I costi indiretti associati includono:

• Istanze Compute Engine utilizzate da GKE: il costo dei nodi utilizzati per eseguire i job di trasferimento dei dati. La gestione dei nodi e le implicazioni sui costi variano in base ai tipi di cluster. Per maggiori informazioni, consulta i rispettivi tipi di cluster in Crea il cluster GKE.
• Dimensioni nodo job di trasferimento: per prestazioni di trasferimento ottimali, un job di trasferimento esegue lo scale up di un nodo con 24 vCPU per impostazione predefinita. Ciò vale per tutti i tipi di cluster. Se vuoi modificare le dimensioni e il tipo di nodo per ottimizzazioni specifiche dei costi o del rendimento, puoi farlo quando crei la classe di computing.
• Spazio di archiviazione utilizzato nel bucket Cloud Storage: per maggiori informazioni, consulta Prezzi di Cloud Storage.
• Costi del volume Hyperdisk ML: sono inclusi la capacità di archiviazione e le prestazioni (IOPS/throughput) dei volumi Hyperdisk ML che crei. Per ulteriori informazioni, consulta la sezione Prezzi di Hyperdisk.

prepara l'ambiente

In questa sezione, crei l'infrastruttura del cluster GKE con l'hardware appropriato e configuri le autorizzazioni necessarie per accedere ai tuoi dati in Cloud Storage.

Prima di creare il cluster per utilizzare GKE Volume Populator con Hyperdisk ML, scopri come viene applicata una classe di calcolo a diversi tipi di cluster e chi è responsabile della gestione dei nodi: GKE o tu.

Come funzionano le classi di calcolo con diversi tipi di cluster per Hyperdisk ML

GKE Volume Populator utilizza una classe di calcolo personalizzata per determinare i tipi di nodi da utilizzare per i job di trasferimento dei dati. La tabella seguente descrive il comportamento della classe di calcolo a seconda della configurazione del cluster:

GKE avvia il job di trasferimento dei dati dopo il provisioning di PersistentVolume per PersistentVolumeClaim. Per popolare il volume Hyperdisk ML, questo PersistentVolumeClaim deve fare riferimento a GCPDataSource, che definisce i dati di origine in Cloud Storage.

Crea il cluster GKE

Puoi scegliere di eseguire il deployment della pipeline di trasferimento dei dati utilizzando un cluster standard o Autopilot con GKE versione 1.33.2-gke.4780000 o successive. Ogni tipo di cluster ha i propri vantaggi e modelli di prezzo diversi.

• Scegli Autopilot per una gestione più semplice del cluster, l'efficienza dei costi e la scalabilità automatica.
• Scegli Standard con il provisioning automatico dei nodi abilitato se hai bisogno della scalabilità automatica con un maggiore controllo sul provisioning dei nodi.
• Scegli Standard senza il provisioning automatico dei nodi abilitato se hai bisogno del massimo controllo e ti senti a tuo agio a gestire tutti gli aspetti del provisioning, della scalabilità e della manutenzione dei nodi.

    gcloud container clusters create-auto CLUSTER_NAME \
        --location=LOCATION \
        --cluster-version=CLUSTER_VERSION
    

    gcloud container clusters create CLUSTER_NAME \
        --cluster-version=CLUSTER_VERSION \
        --location=LOCATION \
        --project=PROJECT_ID \
        --workload-pool=PROJECT_ID.svc.id.goog \
        --enable-autoprovisioning \
        --min-cpu MINIMUM_CPU \
        --min-memory MINIMUM_MEMORY \
        --max-cpu MAXIMUM_CPU \
        --max-memory MAXIMUM_MEMORY \
    --autoprovisioning-scopes=https://www.googleapis.com/auth/logging.write,https://www.googleapis.com/auth/monitoring,https://www.googleapis.com/auth/devstorage.read_only
    

    gcloud container clusters create CLUSTER_NAME \
        --cluster-version=CLUSTER_VERSION \
        --location=LOCATION \
        --num-nodes=1 \
        --project=PROJECT_ID \
        --workload-pool=PROJECT_ID.svc.id.goog

    gcloud container node-pools create NODE_POOL_NAME\
        --cluster=CLUSTER_NAME \
        --location=LOCATION \
        --num-nodes=1 \
        --machine-type=c3-standard-44 \
        --node-labels="cloud.google.com/compute-class=gcs-to-hdml-compute-class" \
        --node-taints="cloud.google.com/compute-class=gcs-to-hdml-compute-class:NoSchedule"
    

Crea la tua classe di computing

Per creare una classe di calcolo per specificare e dare la priorità ai tipi di VM che possono essere utilizzati come nodi nel cluster, segui questi passaggi:

1. Salva il seguente manifest come computeclass.yaml:

   Con il provisioning automatico dei nodi

   Per i cluster Autopilot e i cluster Standard con il provisioning automatico dei nodi abilitato, definisci la classe di computing con la sezione nodePoolAutoCreation nel seguente modo. Quando il provisioning automatico dei nodi è abilitato, GKE crea automaticamente nuovi node pool con l'etichetta della classe di calcolo gcs-to-hdml-compute-class.

       apiVersion: cloud.google.com/v1
       kind: ComputeClass
       metadata:
         name: gcs-to-hdml-compute-class
       spec:
         priorities:
         - machineFamily: c3
         - machineFamily: c3d
         nodePoolAutoCreation:
           enabled: true
         whenUnsatisfiable: DoNotScaleUp
       

   Senza il provisioning automatico dei nodi

   Per i cluster Standard senza il provisioning automatico dei nodi abilitato, definisci la classe di computing senza la sezione nodePoolAutoCreation come segue. Assicurati di aver già creato un pool di nodi con l'etichetta della classe di calcolo gcs-to-hdml-compute-class.

       apiVersion: cloud.google.com/v1
       kind: ComputeClass
       metadata:
         name: gcs-to-hdml-compute-class
       spec:
         priorities:
         - machineFamily: c3
         - machineFamily: c3d
         whenUnsatisfiable: DoNotScaleUp
       

   Puoi specificare qualsiasi machineFamily compatibile per soddisfare le tue esigenze di trasferimento dei dati. Per saperne di più sulla selezione di un tipo di macchina adatto, consulta Supporto delle serie di macchine per Hyperdisk ML.

2. Per creare la classe di computing, applica il manifest:

   kubectl apply -f computeclass.yaml

Configurare le autorizzazioni necessarie

Per trasferire i dati da un bucket Cloud Storage, configura le autorizzazioni richieste per Workload Identity Federation for GKE. Con le autorizzazioni appropriate, il job di trasferimento creato da GKE Volume Populator può accedere al tuo bucket Cloud Storage. Questa guida presuppone che tu disponga già di un bucket Cloud Storage compilato con i dati di addestramento del modello che vuoi trasferire.

1. Crea uno spazio dei nomi Kubernetes:

   kubectl create namespace NAMESPACE
   

   Sostituisci NAMESPACE con lo spazio dei nomi su cui vuoi eseguire i carichi di lavoro.

   Ignora questo passaggio se utilizzi uno spazio dei nomi esistente.

2. Crea un account di servizio Kubernetes:

   kubectl create serviceaccount KSA_NAME \
       --namespace=NAMESPACE
   

   Sostituisci quanto segue:

   • KSA_NAME: il nome del account di servizio Kubernetes che specificherai nella risorsa GCPDataSource. Il job di trasferimento creato da GKE Volume Populator utilizza questo account di servizio per l'autenticazione alle API. Trusted Cloud by S3NS
   • NAMESPACE: lo spazio dei nomi Kubernetes creato nel passaggio precedente.

3. Concedi al tuo service account IAM il ruolo appropriato per accedere al tuo bucket Cloud Storage:

   gcloud storage buckets \
       add-iam-policy-binding gs://GCS_BUCKET \
       --member "principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/NAMESPACE/sa/KSA_NAME" \
       --role "ROLE"
   

   Sostituisci quanto segue:

   • GCS_BUCKET: il nome del bucket Cloud Storage.
   • PROJECT_NUMBER: l'identificatore numerico del tuo Trusted Cloud by S3NS progetto in cui hai creato il cluster. Per trovare il numero di progetto, consulta Identificazione dei progetti.
   • PROJECT_ID: il tuo ID progetto Trusted Cloud by S3NS .
   • NAMESPACE: lo spazio dei nomi creato in precedenza in cui verranno eseguiti i workload.
   • KSA_NAME: il nome del account di servizio Kubernetes specificato nella risorsa GCPDataSource. Il job di trasferimento creato da GKE Volume Populator utilizza questo account di servizio per l'autenticazione alle API. Trusted Cloud by S3NS
   • ROLE: il ruolo IAM che vuoi concedere al tuo account di servizio. Ai fini di questa guida, assegna il ruolo roles/storage.objectViewer per consentire la lettura dal bucket.

   PROJECT_NUMBER, PROJECT_ID, NAMESPACE e KSA_NAME vengono utilizzati per creare l'identificatore principale di Workload Identity Federation for GKE per il tuo progetto.

Crea un volume Hyperdisk ML con dati precaricati

Per configurare l'infrastruttura e la configurazione GKE necessarie per creare un volume Hyperdisk ML e per attivare e gestire il processo di trasferimento automatico dei dati utilizzando GKE Volume Populator, segui questi passaggi:

1. Crea una GCPDataSource risorsa personalizzata per definire l'origine dei dati.
2. Crea un oggetto StorageClass per definire il tipo di spazio di archiviazione permanente (un volume Hyperdisk ML) da utilizzare.
3. Crea un PersistentVolumeClaim per attivare il provisioning dinamico dello spazio di archiviazione e l'accesso al volume Hyperdisk ML appena sottoposto a provisioning.
4. (Facoltativo) Visualizza l'avanzamento del trasferimento dei dati.
5. Crea e implementa un pod che utilizza il volume Hyperdisk ML.

Crea una risorsa personalizzata GCPDataSource

Crea una risorsa personalizzata GCPDataSource in GKE per specificare la posizione del bucket Cloud Storage di origine e il account di servizio con le autorizzazioni necessarie per accedere a questo bucket. Questa definizione di risorsa personalizzata (CRD) è specifica per GKE Volume Populator.

1. Salva il seguente manifest come 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 saperne di più, consulta il riferimento CRD di GCPDataSource.
   • NAMESPACE: lo stesso spazio dei nomi in cui vengono eseguiti i workload. La risorsa personalizzata GCPDataSource viene creata in questo spazio dei nomi.
   • KSA_NAME: il nome del account di servizio Kubernetes specificato nella risorsa GCPDataSource. Il job di trasferimento creato da GKE Volume Populator utilizza questo account di servizio per l'autenticazione alle API. Trusted Cloud by S3NS Il valore di cloudStorage.serviceAccountName è il service account Kubernetes che hai configurato per Workload Identity Federation for GKE nella sezione Configura le autorizzazioni necessarie.
   • GCS_BUCKET: il nome del bucket Cloud Storage. Il campo uri specifica i dati di origine.
     • Per copiare l'intero bucket, utilizza gs://GCS_BUCKET/.
     • Per copiare i dati da una cartella specifica all'interno del bucket, utilizza il formato gs://GCS_BUCKET/PATH_INSIDE_BUCKET/. Ad esempio, per copiare i dati dalla cartella gemma/v1.0/weights/ all'interno del bucket my-project-llm-models, l'URI sarebbe gs://my-project-llm-models/gemma/v1.0/weights/. Assicurati che il percorso termini con una barra finale per indicare una cartella.

2. Per creare la risorsa GCPDataSource, applica il manifest:

   kubectl apply -f gcpdatasource.yaml
   

Crea una StorageClass Hyperdisk ML

Crea una StorageClass che utilizzi il provisioner pd.csi.storage.gke.io per eseguire il provisioning di un volume Hyperdisk ML nella zona scelta. Se vuoi che le copie dei tuoi dati siano accessibili in più di una zona, puoi creare una StorageClass multizona. Ecco un esempio di StorageClass multizona.

1. Salva il seguente manifest come hdml-class.yaml.

   apiVersion: storage.k8s.io/v1
   kind: StorageClass
   metadata:
     name: hyperdisk-ml-single-zone
   parameters:
     type: hyperdisk-ml
     provisioned-throughput-on-create: "2400Mi"
   provisioner: pd.csi.storage.gke.io
   allowVolumeExpansion: false
   reclaimPolicy: Delete
   volumeBindingMode: Immediate
   allowedTopologies:
   - matchLabelExpressions:
     - key: topology.gke.io/zone
       values:
       - ZONE
   

   Sostituisci ZONE con la zona di destinazione in cui vuoi creare il volume Hyperdisk ML:

   • Per il cluster GKE Standard senza il provisioning automatico dei nodi, il valore di ZONE deve essere la località in cui hai creato i nodi.
   • Per i cluster GKE Autopilot o Standard con il provisioning automatico dei nodi, il valore di ZONE deve essere la località in cui il cluster può scalare orizzontalmente e creare nuovi nodi, se necessario.

2. (Facoltativo) Per elencare le posizioni dei nodi del cluster, esegui questo comando:

   gcloud container clusters describe CLUSTER_NAME --location=LOCATION --format="value(locations)"
   

   Sostituisci quanto segue:

   • CLUSTER_NAME: il nome del tuo cluster.
   • LOCATION: la zona di computing o la regione del cluster. Ad esempio, us-central1-a o us-central1.

3. Per creare StorageClass, applica il manifest :

   kubectl apply -f hdml-class.yaml
   

Crea un oggetto PersistentVolumeClaim per accedere al volume

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

1. Salva il seguente manifest come volume-populator-pvc.yaml:

   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: PVC_NAME
     namespace: NAMESPACE
   spec:
     accessModes:
     - ReadOnlyMany
     storageClassName: hyperdisk-ml-single-zone
     resources:
       requests:
         storage: DISK_SIZE
     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.
   • NAMESPACE: lo spazio dei nomi in cui verranno eseguiti i tuoi workload.
   • DISK_SIZE: le dimensioni, in gigabyte, del disco che verrà creato per popolare i dati. Per popolare correttamente i dati, assicurati che le dimensioni del disco richieste siano maggiori delle dimensioni dei dati del modello presenti nel bucket Cloud Storage. Per rispettare l'intervallo supportato per i volumi Hyperdisk ML, il valore di DISK_SIZE deve essere maggiore di 4 Gi. Per saperne di più, consulta Limiti di dimensioni dei volumi Hyperdisk.
   • GCP_DATA_SOURCE: il nome della CRD GCPDataSource che contiene un riferimento al tuo bucket Cloud Storage.

   Puoi personalizzare il trasferimento dei dati aggiungendo annotazioni facoltative al tuo PVC. Queste annotazioni influiscono sul comportamento del job di trasferimento sottostante che copia i dati nel volume Hyperdisk ML.

   • volume-populator.datalayer.gke.io/cpu-request: utilizza questa annotazione per specificare una richiesta di risorse CPU diversa per il trasferimento Job. Se non specifichi una richiesta di risorse CPU diversa, la PVC richiede 24 vCPU per impostazione predefinita per ottimizzare le prestazioni di trasferimento.

   • volume-populator.datalayer.gke.io/transfer-path: utilizza questa annotazione per specificare il percorso di destinazione all'interno del nuovo volume che archivierà i dati copiati dalla risorsa GCPDataSource. Se non specifichi un percorso diverso, i dati vengono copiati nel percorso principale all'interno del volume Hyperdisk ML.

2. Per creare la PVC, applica il manifest:

   kubectl apply -f volume-populator-pvc.yaml
   

Tieni presente quanto segue:

• Se imposti il campo volumeBindingMode in StorageClass su immediate, il trasferimento dei dati viene attivato immediatamente dopo il deployment del PVC.
• Se imposti il campo volumeBindingMode in StorageClass su WaitForFirstConsumer, il trasferimento dei dati viene attivato solo dopo aver deployato un pod che richiede il PVC e il pod viene pianificato correttamente su un nodo. Anche se il pod può essere pianificato, i suoi container attenderanno l'avvio fino al completamento del trasferimento dei dati e alla preparazione del volume per l'uso.

Per controllare l'avanzamento del trasferimento dei dati, vedi Visualizzare l'avanzamento del trasferimento dei dati. Se riscontri errori durante il provisioning delle risorse o il trasferimento dei dati, consulta Risoluzione dei problemi di trasferimento dei dati di GKE Volume Populator.

(Facoltativo) Visualizzare l'avanzamento del trasferimento dei dati

Questa sezione mostra come monitorare l'avanzamento e la riuscita dei trasferimenti di dati da un bucket Cloud Storage a un volume Hyperdisk ML.

1. Per verificare lo stato di PersistentVolumeClaim, esegui il comando seguente. Puoi eseguire questo comando anche se l'operazione di binding di PersistentVolumeClaim richiede troppo tempo per essere completata.

   kubectl describe pvc PVC_NAME -n NAMESPACE
   

   Sostituisci quanto segue:

   • PVC_NAME: il nome del PVC creato nella sezione Crea un PersistentVolumeClaim per accedere al volume.
   • NAMESPACE: lo spazio dei nomi utilizzato in questa guida, che hai creato nella sezione Configurare le autorizzazioni necessarie.

2. Nell'output, esamina gli eventi PersistentVolumeClaim per monitorare l'avanzamento del trasferimento dei dati. GKE registra gli eventi circa una volta al minuto. L'output è simile al seguente:

   Name:          vp-pvc
   Namespace:     default
   StorageClass:  hyperdisk-ml-single-zone
   Status:        Bound
   Volume:        pvc-f7ae2ee2-106d-4b87-b458-481a3ff82b62
   Labels:        <none>
   Annotations:   pv.kubernetes.io/bind-completed: yes
                 pv.kubernetes.io/bound-by-controller: yes
                 volume.beta.kubernetes.io/storage-provisioner: pd.csi.storage.gke.io
                 volume.kubernetes.io/storage-provisioner: pd.csi.storage.gke.io
   Finalizers:    [kubernetes.io/pvc-protection]
   Capacity:      200Gi
   Access Modes:  ROX
   VolumeMode:    Filesystem
   DataSource:
     APIGroup:  datalayer.gke.io
     Kind:      GCPDataSource
     Name:      vp-gds
   Used By:     verify-data-665cfd4dbf-mwc7t
               verify-data-665cfd4dbf-n7xw9
   Events:
     Type     Reason                         Age                     From                                                                                              Message
     ----     ------                         ----                    ----                                                                                              -------
     Warning  ProvisioningFailed             9m8s                    persistentvolume-controller                                                                       Error saving claim: Operation cannot be fulfilled on persistentvolumeclaims "vp-pvc": the object has been modified; please apply your changes to the latest version and try again
     Normal   Provisioning                   9m5s                    pd.csi.storage.gke.io_gke-f110123a1cbd44cdaa7a-921b-b1f4-vm_1a100bd9-5231-4f20-8e65-1f8e995a03c0  External provisioner is provisioning volume for claim "default/vp-pvc"
     Normal   Provisioning                   9m5s                    external-provisioner                                                                              Assuming an external populator will provision the volume
     Normal   PopulateOperationStartSuccess  8m58s                   gkevolumepopulator-populator                                                                      populateFn: Populate operation started for zone us-central1-c
     Normal   TransferInProgress             8m58s (x2 over 8m58s)   gkevolumepopulator-populator                                                                      populateCompleteFn: For PVC vp-pvc in namespace default, transfer job with request ID populator-job-2304531e-4937-4534-a1a4-3eb11e5cb39f in zone us-central1-c waiting for pod to get created
     Normal   TransferInProgress             6m10s (x14 over 8m57s)  gkevolumepopulator-populator                                                                      populateCompleteFn: For PVC vp-pvc in namespace default, transfer job in zone us-central1-c with request ID populator-job-2304531e-4937-4534-a1a4-3eb11e5cb39f is still active with pod status as - Phase: Pending
     Normal   ExternalProvisioning           3m35s (x24 over 9m5s)   persistentvolume-controller                                                                       Waiting for a volume to be created either by the external provisioner 'pd.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   TransferJobCompleted           3m24s (x2 over 3m26s)   gkevolumepopulator-populator                                                                      populateCompleteFn: For PVC vp-pvc in namespace default, job with request ID populator-job-2304531e-4937-4534-a1a4-3eb11e5cb39f for zone us-central1-c completed successfully
     Normal   TransferJobCompleted           3m24s (x2 over 3m26s)   gkevolumepopulator-populator                                                                      populateCompleteFn: For PVC vp-pvc in namespace default, transfer job for all zones have completed successfully
     Normal   PopulateOperationFinished      3m24s (x2 over 3m26s)   gkevolumepopulator-populator                                                                      Populate operation finished
     Normal   PopulatorFinished              3m19s (x3 over 3m20s)   gkevolumepopulator-populator                                                                      Populator finished
   

L'operazione di compilazione potrebbe richiedere diversi minuti per avviarsi, a seconda delle dimensioni dei dati. Se dopo diversi minuti non vedi alcun avanzamento del trasferimento dei dati, consulta Risoluzione dei problemi di trasferimento dei dati di GKE Volume Populator per ricevere assistenza.

Per i trasferimenti di dati dei volumi Hyperdisk ML multizona, il job viene contrassegnato come completato solo se i dati vengono trasferiti correttamente a tutte le zone specificate in StorageClass. Se il job di trasferimento non va a buon fine per una o più zone, GKE Volume Populator riprova a trasferire i dati all'infinito finché esiste la PVC.

Crea e implementa un pod che utilizza il volume

Per creare un pod per verificare i contenuti di una PVC popolata con i dati:

1. Salva il seguente manifest come verify-data.yaml:

   apiVersion: v1
   kind: Pod
   metadata:
     name: verify-data
     namespace: NAMESPACE
   spec:
     nodeSelector:
       cloud.google.com/compute-class: gcs-to-hdml-compute-class
     containers:
     - name: verify-data
       image: busybox
       command:
       - sleep
       - infinity
       volumeMounts:
         - mountPath: /models
           name: mypvc
     volumes:
     - name: mypvc
       persistentVolumeClaim:
         claimName: PVC_NAME
   

   Sostituisci quanto segue:

   • NAMESPACE: lo spazio dei nomi in cui si trova il PVC e in cui vuoi creare il pod verify-data.
   • PVC_NAME: il nome della PVC creata per il popolamento dei dati nella sezione Crea un oggetto PersistentVolumeClaim per accedere al volume.

2. Crea il pod con il seguente comando:

   kubectl create -f verify-data.yaml
   

3. Per elencare i file, esegui questo comando:

   kubectl exec -it verify-data -- /bin/sh
   # cd /models && ls
   

Se il comando ha esito positivo, puoi trovare i dati compilati nella directory /models all'interno del bucket Cloud Storage.

Esegui la pulizia

Per evitare costi inutili e rimuovere risorse orfane o con configurazione errata, segui i passaggi per eliminare PersistentVolumeClaim in modo controllato.

Elimina PersistentVolumeClaim durante il provisioning dinamico

Se devi eliminare PersistentVolumeClaim mentre i dati vengono ancora trasferiti durante il provisioning dinamico, segui questi passaggi per l'eliminazione controllata. Il completamento dell'eliminazione controllata potrebbe richiedere del tempo.

Sostituisci le seguenti variabili pertinenti durante la procedura di eliminazione:

• POD_NAME: il nome del pod creato nella sezione Crea ed esegui il deployment di un pod che utilizza il volume.
• NAMESPACE: lo spazio dei nomi in cui si trova la PVC.
• PVC_NAME: il nome del PVC che hai creato nella sezione Crea un oggetto PersistentVolumeClaim per accedere al volume.
• GCP_DATA_SOURCE: il nome della risorsa personalizzata GCPDataSource che hai creato nella sezione Crea una risorsa personalizzata GCPDataSource.

1. Elimina il pod del workload:

   kubectl delete pod POD_NAME -n NAMESPACE
   

2. Trova il nome di PersistentVolumeClaim temporaneo:

   # Store the relevant environment variables
   export PVC_NAME=PVC_NAME
   export NAMESPACE=NAMESPACE
   

   # Check the status
   export PVC_UID=$(kubectl get pvc ${PVC_NAME} -n ${NAMESPACE} -o jsonpath='{.metadata.uid}')
   export TEMP_PVC=prime-${PVC_UID}
   echo ${TEMP_PVC}
   

3. Elimina la PVC creata nello spazio dei nomi:

   kubectl delete pvc PVC_NAME -n NAMESPACE
   

4. Il PVC potrebbe essere bloccato nello stato Terminating:

   NAME           STATUS        VOLUME   CAPACITY   ACCESS MODES   STORAGECLASS               VOLUMEATTRIBUTESCLASS   AGE
   vp-pvc   Terminating                                      hyperdisk-ml   <unset>                 7m23s
   

   In questo caso, pulisci manualmente la PVC rimuovendo i finalizer:

   kubectl patch pvc PVC_NAME -n NAMESPACE  -p '{"metadata":{"finalizers":null}}'
   

5. Elimina la risorsa GCPDataSource solo dopo l'eliminazione della PVC. L'eliminazione della risorsa GCPDataSource prima causerà il blocco dell'eliminazione della PVC.

   kubectl delete gcpdatasource GCP_DATA_SOURCE -n NAMESPACE
   

6. Verifica che le risorse temporanee siano eliminate.

Passaggi successivi

• Scopri di più su GKE Volume Populator.
• Per assistenza in caso di problemi di trasferimento dei dati, consulta Risolvere i problemi di trasferimento dei dati di GKE Volume Populator.
• Per un esempio avanzato di workload Hyperdisk ML, consulta Accelerare il caricamento dei dati AI/ML con Hyperdisk ML.