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 con uso intensivo di dati come intelligenza artificiale (AI), machine learning (ML) e computing ad alte prestazioni (HPC).

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

Questo documento è destinato a machine learning engineer e specialisti di dati e AI interessati a esplorare le funzionalità di orchestrazione dei container Kubernetes supportate dalle istanze Managed Lustre. Per saperne di più sui ruoli comuni e sulle attività di esempio a cui viene fatto riferimento nei contenuti di Google Cloud , 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 di cluster e workload GKE, in particolare per le attività di AI/ML. XPK consente di generare un'infrastruttura preconfigurata e ottimizzata per l'addestramento, il che la rende una buona opzione per le prove concettuali e gli ambienti di test.

Puoi creare un cluster che utilizza le TPU utilizzando Google Cloud CLI o un kit di elaborazione accelerata (XPK).

  • Utilizza gcloud CLI per creare manualmente l'istanza del cluster GKE per una personalizzazione o un'espansione precisa degli ambienti GKE di produzione esistenti.
  • Utilizza XPK per creare rapidamente cluster GKE ed eseguire workload per prove concettuali 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 relativa al kit di elaborazione accelerata (XPK).

Avvio flessibile

L'avvio flessibile consente di ottimizzare il provisioning delle TPU pagando solo le risorse necessarie. L'avvio flessibile è consigliato se il tuo workload richiede risorse di cui viene eseguito il provisioning dinamico in base alle necessità, per un massimo di sette giorni e un accesso conveniente.

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

Managed Lustre

Managed Lustre è un servizio di file system parallelo ad alte prestazioni progettato per carichi di lavoro impegnativi. Il driver CSI di Managed Lustre consente di integrare le istanze Managed Lustre con GKE utilizzando le richieste di volumi permanenti (PVC) e i volumi permanenti (PV) standard di Kubernetes. Questo driver è particolarmente utile per i carichi di lavoro AI, ML e HPC che richiedono spazio di archiviazione persistente, scalabile e ad alta velocità effettiva.

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

Prima di iniziare

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

  • Abilita l'API Google Cloud Managed Lustre e l'API Google 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 comando gcloud components update. 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 Installazione di XPK. Utilizza pip install anziché la clonazione dall'origine.

  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 della TPU indica a GKE di eseguire il provisioning di un pool di nodi slice multi-host. v6e-16 corrisponde al tipo di macchina ct6e-standard-4t in GKE.
    • NUM_SLICES=1: il numero di node pool di sezioni TPU che XPK crea per ACCELERATOR_TYPE che selezioni.

    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 la sezione Calcola 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 del comando mostra done: true.

Utilizzare 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 flex-start per il provisioning dei nodi e ha 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 di collegamento dell'archiviazione XPK (xpk storage attach) con un file manifest. Questa sezione utilizza un manifest di esempio dal codice sorgente XPK.

Collega l'istanza di archiviazione Managed Lustre al tuo cluster GKE completando questi passaggi:

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

  2. Aggiorna il file manifest con le informazioni della tua 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 della tua istanza Managed Lustre.
      • IP_ADDRESS: l'indirizzo IP dell'istanza Managed Lustre.
      • FILE_SYSTEM: il tipo di file system, ovvero 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 carico di lavoro

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

Esegui la pulizia

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