Esegui il provisioning di Managed Lustre su GKE utilizzando XPK

Questo documento spiega come integrare Managed Lustre con GKE per creare un ambiente ottimizzato per workload impegnativi e ad alta intensità di dati come l'intelligenza artificiale (AI), il machine learning (ML) e il computing ad alte prestazioni (HPC).

In questo documento, esegui il provisioning di un cluster GKE con XPK, crei un'istanza Managed Lustre e la colleghi al cluster. Per testare questa configurazione, esegui un workload sui nodi di cui viene eseguito il provisioning con avvio flessibile.

Questo documento è destinato agli ingegneri di machine learning (ML) e agli specialisti di dati e AI interessati a esplorare le funzionalità di orchestrazione dei container Kubernetes supportate dalle istanze Managed Lustre. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui si fa riferimento nel Google Cloud contenuto, consulta Ruoli e attività comuni degli utenti GKE.

Sfondo

Questa sezione descrive le tecnologie chiave utilizzate in questo documento:

XPK

XPK è uno strumento che semplifica il provisioning e la gestione dei cluster e dei workload GKE, in particolare per le attività di AI/ML. XPK aiuta a generare un'infrastruttura preconfigurata e ottimizzata per l'addestramento, il che la rende una buona opzione per le prove di fattibilità e gli ambienti di test.

Puoi creare un cluster che utilizza le TPU utilizzando Google Cloud CLI o un Accelerated Processing Kit (XPK).

  • Utilizza gcloud CLI per creare manualmente l'istanza del cluster GKE per una personalizzazione precisa o per l'espansione degli ambienti GKE di produzione esistenti.
  • Utilizza XPK per creare rapidamente cluster GKE ed eseguire workload per prove di fattibilità e test. Per saperne di più, consulta il file README di XPK.

Questo documento utilizza XPK esclusivamente per il provisioning e la gestione delle risorse.

Per saperne di più, consulta la documentazione di Accelerated Processing Kit (XPK).

Avvio flessibile

L'avvio flessibile ti consente di ottimizzare il provisioning delle TPU pagando solo le risorse di cui hai bisogno. L'avvio flessibile è consigliato se il tuo workload richiede risorse di cui viene eseguito il provisioning dinamico in base alle esigenze, per un massimo di sette giorni e con accesso a costi contenuti.

Questo documento utilizza l'avvio flessibile come esempio di opzione di consumo, ma puoi utilizzare anche altre opzioni, ad esempio prenotazioni o Spot. Per saperne di più, consulta Informazioni sulle opzioni di consumo degli acceleratori per i workload AI/ML in GKE.

Managed Lustre

Managed Lustre è un servizio di sistema di file parallelo ad alte prestazioni progettato per workload impegnativi. Il driver CSI Managed Lustre ti consente di integrare le istanze Managed Lustre con GKE, utilizzando PersistentVolumeClaim (PVC) e PersistentVolume (PV) Kubernetes standard. Questo driver è particolarmente utile per i workload AI, ML e HPC che richiedono spazio di archiviazione persistente, scalabile e ad alto throughput.

Per saperne di più, consulta Informazioni sul driver CSI Managed Lustre.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

  • Abilita l'API Google Cloud Managed Lustre e l'API Kubernetes Engine.
    • Abilita le API
  • Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo il gcloud components update comando. Le versioni precedenti di gcloud CLI potrebbero non supportare l'esecuzione dei comandi in questo documento.

Prepara l'ambiente

Questa sezione mostra come preparare l'ambiente del cluster.

  1. Nella nuova finestra del terminale, crea un ambiente virtuale:

    VENV_DIR=~/venvp4;python3 -m venv $VENV_DIR;source $VENV_DIR/bin/activate

  2. Installa XPK seguendo i passaggi descritti nel file di installazione di XPK. Utilizza pip install anziché clonare dal codice sorgente.

  3. Imposta le variabili di ambiente predefinite:

    gcloud config set project PROJECT_ID
gcloud config set billing/quota_project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export LOCATION=LOCATION
export CLUSTER_NAME=CLUSTER_NAME
export GKE_VERSION=VERSION
export NETWORK_NAME=NETWORK_NAME
export IP_RANGE_NAME=IP_RANGE_NAME
export FIREWALL_RULE_NAME=FIREWALL_RULE_NAME
export ACCELERATOR_TYPE=v6e-16
export NUM_SLICES=1

    Sostituisci i seguenti valori:

    I comandi precedenti configurano un tipo di acceleratore v6e-16. Questa configurazione include le seguenti variabili:

    • ACCELERATOR_TYPE=v6e-16: corrisponde a TPU Trillium con una topologia 4x4. Questa versione di TPU indica a GKE di eseguire il provisioning di un pool di nodi di slice multi-host. v6e-16 esegue il mapping al tipo di macchina ct6e-standard-4t in GKE.
    • NUM_SLICES=1: il numero di node pool di slice TPU che XPK crea per ACCELERATOR_TYPE selezionato.

    Se vuoi personalizzare le variabili ACCELERATOR_TYPE e NUM_SLICES, consulta i seguenti documenti per trovare le combinazioni disponibili:

Prepara una rete VPC

Prepara una rete Virtual Private Cloud per l'istanza Managed Lustre e il cluster GKE.

  1. Abilita l'API Service Networking:

    gcloud services enable servicenetworking.googleapis.com \
        --project=${PROJECT_ID}

  2. Crea una rete VPC:

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

  3. Crea un intervallo di indirizzi IP per il peering VPC:

    gcloud compute addresses create ${IP_RANGE_NAME} \
        --global \
        --purpose=VPC_PEERING \
        --prefix-length=20 \
        --description="Managed Lustre VPC Peering" \
        --network=${NETWORK_NAME} \
        --project=${PROJECT_ID}

  4. Ottieni l'intervallo CIDR dell'intervallo di indirizzi IP:

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

  5. Crea una regola firewall per consentire il traffico TCP dall'intervallo di indirizzi IP:

    gcloud compute firewall-rules create ${FIREWALL_RULE_NAME} \
        --allow=tcp:988,tcp:6988 \
        --network=${NETWORK_NAME} \
        --source-ranges=${CIDR_RANGE} \
        --project=${PROJECT_ID}

  6. Connetti il peering VPC.

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

Crea un'istanza di archiviazione Managed Lustre

Crea un'istanza di archiviazione Managed Lustre.

  1. Imposta le variabili dell'istanza di archiviazione:

    export STORAGE_NAME=STORAGE_NAME
export STORAGE_THROUGHPUT=STORAGE_THROUGHPUT
export STORAGE_CAPACITY=STORAGE_CAPACITY_GIB
export STORAGE_FS=lfs

    Sostituisci i seguenti valori:

    • STORAGE_NAME: il nome dell'istanza Managed Lustre.
    • STORAGE_THROUGHPUT: il throughput dell'istanza Managed Lustre, in MiB/s per TiB. Per i valori di throughput validi, consulta Calcolare la nuova capacità.
    • STORAGE_CAPACITY_GIB: la capacità dell'istanza Managed Lustre, in GiB. Per i valori di capacità validi, consulta Valori di capacità e throughput consentiti.

  2. Crea l'istanza Managed Lustre:

    gcloud lustre instances create ${STORAGE_NAME} \
        --per-unit-storage-throughput=${STORAGE_THROUGHPUT} \
        --capacity-gib=${STORAGE_CAPACITY} \
        --filesystem=${STORAGE_FS} \
        --location=${LOCATION} \
        --network=projects/${PROJECT_ID}/global/networks/${NETWORK_NAME} \
        --project=${PROJECT_ID} \
        --async # Creates the instance asynchronously

    Il flag --async crea l'istanza in modo asincrono e fornisce un ID operazione per monitorarne lo stato.

  3. Controlla lo stato dell'operazione:

    gcloud lustre operations describe OPERATION_ID  \
        --location=${LOCATION} \
        --project=${PROJECT_ID}

    Sostituisci OPERATION_ID con l'ID dell'output del comando asincrono precedente. Se non hai l'ID, puoi elencare tutte le operazioni:

    gcloud lustre operations list \
        --location=${LOCATION} \
        --project=${PROJECT_ID}

    L'istanza è pronta quando l'output comando mostra done: true.

Utilizza XPK per creare un cluster GKE

Utilizza XPK per creare un cluster GKE con un pool di nodi.

Crea un cluster GKE:

xpk cluster create --cluster ${CLUSTER_NAME} \
        --num-slices=${NUM_SLICES} \
        --tpu-type=${ACCELERATOR_TYPE} \
        --zone=${LOCATION} \
        --project=${PROJECT_ID} \
        --gke-version=${GKE_VERSION} \
        --custom-cluster-arguments="--network=${NETWORK_NAME}" \
        --enable-lustre-csi-driver \
        --flex

Questo comando crea un cluster GKE utilizzando XPK. Il cluster è configurato per utilizzare l'avvio flessibile per il provisioning dei nodi e il driver CSI Managed Lustre è abilitato.

Collega l'istanza di archiviazione al cluster

Per configurare PersistentVolume (PV) e PersistentVolumeClaim (PVC), questa sezione utilizza il comando XPK storage attach (xpk storage attach) con un file manifest. Questa sezione utilizza un file manifest di esempio dal codice sorgente XPK.

Per collegare l'istanza di archiviazione Managed Lustre al cluster GKE:

  1. Scarica il file manifest di esempio nella directory di lavoro corrente e salvalo come lustre-manifest-attach.yaml.

  2. Aggiorna il file manifest con le informazioni dell'istanza Managed Lustre:

    1. Nella sezione PersistentVolume, sostituisci i seguenti valori:

      • STORAGE_SIZE: le dimensioni dell'istanza Managed Lustre, in GiB.
      • PROJECT_ID/ZONE/INSTANCE_NAME: il percorso completo della risorsa dell'istanza Managed Lustre.
      • IP_ADDRESS: l'indirizzo IP dell'istanza Managed Lustre.
      • FILE_SYSTEM: il tipo di file system, che è lfs.

    2. Nella sezione PersistentVolumeClaim, sostituisci i seguenti valori:

      • STORAGE_SIZE: le dimensioni di PersistentVolumeClaim, in GiB.

  3. Collega l'istanza di archiviazione al cluster:

    xpk storage attach ${STORAGE_NAME} \
        --cluster=${CLUSTER_NAME} --project=${PROJECT_ID} --zone=${LOCATION} \
        --type=lustre \
        --mount-point='/lustre-data' \
        --readonly=false \
        --auto-mount=true \
        --manifest='./lustre-manifest-attach.yaml'

  4. Verifica di aver collegato lo spazio di archiviazione per il cluster:

    xpk storage list \
        --cluster=${CLUSTER_NAME} --project=${PROJECT_ID} --zone=${LOCATION}

Esegui un workload

Esegui un workload con l'istanza Managed Lustre collegata . Il seguente comando di esempio elenca i dischi disponibili e crea un file "hello" nella directory dell'istanza Managed Lustre.

Crea ed esegui il workload:

xpk workload create --workload test-lustre \
--cluster=${CLUSTER_NAME} --project=${PROJECT_ID} --zone=${LOCATION} \
--command="df -h && echo 'hello' > /lustre-data/hello.txt && cat /lustre-data/hello.txt" \
--tpu-type=${ACCELERATOR_TYPE} \
--num-slices=1 \
--flex

Libera spazio

Dopo aver completato i passaggi descritti in questo documento, per evitare addebiti indesiderati sul tuo account, elimina il cluster:

  xpk cluster delete --cluster ${CLUSTER_NAME} \
        --zone ${LOCATION} \
        --project ${PROJECT_ID}

Passaggi successivi