GKE fornisce una singola piattaforma per eseguire un insieme diversificato di workload per le tue organizzazioni, riducendo il carico operativo della gestione di più piattaforme. Puoi eseguire workload come il pre-addestramento distribuito ad alte prestazioni, la messa a punto del modello, l'inferenza del modello, la distribuzione di applicazioni e i servizi di supporto.
In questa pagina scopri come creare cluster Google Kubernetes Engine (GKE) Standard e Autopilot utilizzando GPUDirect-TCPX, gVNIC e il multi-networking.
Questa pagina è destinata agli ingegneri di machine learning (ML) e agli amministratori della piattaforma che facilitano i carichi di lavoro ML. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei Google Cloud contenuti, consulta la pagina Ruoli e attività comuni degli utenti GKE.
Le applicazioni di intelligenza artificiale (AI), ML e computing ad alte prestazioni (HPC) richiedono un'accelerazione potente per ottimizzare le prestazioni riducendo i tempi di completamento dei job. Ad esempio, i modelli ML incentrati sull'AI conversazionale e sulla generazione di immagini richiedono elevata scalabilità e potenza di calcolo.
Questa pagina presuppone che tu abbia familiarità con le tecnologie di rete come le schede di interfaccia di rete (NIC) e TCP, nonché con le tecnologie di accelerazione come la NVIDIA Collective Communications Library (NCCL).
Informazioni sui Google Cloud supercomputer con GPU
Google Cloud dispone di supercomputer ottimizzati per l'acceleratore, creati per modelli scalabili e di grandi dimensioni. Questi tipi di macchine con GPU possono ottenere fino a 3600 Gbps di larghezza di banda di rete.
Il workload GKE deve utilizzare tutte le GPU disponibili e tutte le NIC secondarie disponibili su un singolo nodo e utilizzare una parte significativa della larghezza di banda disponibile. La soluzione descritta in questo documento è progettata per carichi di lavoro che richiedono prestazioni elevate, throughput elevato e bassa latenza.
Funzionalità e capacità richieste per massimizzare la larghezza di banda
Per massimizzare la larghezza di banda di rete nei nodi del supercomputer GPU, devi utilizzare le seguenti funzionalità:
- Stack di rete GPUDirect: A3 Edge supporta tre stack di rete per l'accesso diretto alla memoria remota (RDMA) personalizzato. Le macchine A3 Edge utilizzano GPUDirect-TCPX per ridurre l'overhead necessario per trasferire i payload dei pacchetti a e da GPU, il che migliora significativamente il throughput su larga scala rispetto alle GPU che non utilizzano GPUDirect.
- gVNIC: attiva le funzionalità GPUDirect come la suddivisione dell'intestazione dei pacchetti, lo steering del flusso e la gestione dei buffer. gVNIC è necessario per utilizzare GPUDirect-TCPX. Per informazioni dettagliate su gVNIC, consulta Aumentare la velocità del traffico di rete per i nodi GPU.
Devi anche attivare e configurare le seguenti funzionalità:
- Multi-networking: aggiungi NIC secondarie alla macchina ottimizzata per l'acceleratore. Ogni NIC è associata a una subnet separata nel proprio VPC per evitare conflitti. Per informazioni dettagliate sul supporto di più reti, vedi Configurare il supporto di più reti per i pod.
- Criteri di posizionamento: utilizza un criterio di posizionamento delle risorse per posizionare tutti i nodi GPU per un workload specifico su server fisicamente vicini per ridurre al minimo la latenza. Per maggiori dettagli, vedi Definire il posizionamento compatto per i nodi GKE.
Struttura della procedura
Per utilizzare insieme GPUDirect-TCPX, gVNIC, il multi-networking e le policy di posizionamento compatto, devi:
- Crea Virtual Private Cloud (VPC) e subnet
- Crea l'ambiente GKE
- Installa il file binario GPUDirect e il plug-in NCCL
- Eseguire il deployment del plug-in di inserimento dei dispositivi NRI
- Esegui il deployment di un carico di lavoro di test per verificare la configurazione di GPUDirect
- Adotta GPUDirect per i tuoi workload
Prima di iniziare
Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:
- Attiva l'API Google Kubernetes Engine. Attiva l'API Google Kubernetes Engine
- Per 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.
- Assicurati di avere capacità per le VM A3 Edge. Per ottenere questa capacità, scegli prima una delle opzioni di consumo. Per seguire le istruzioni riportate in questa pagina, puoi utilizzare la capacità on demand, le prenotazioni on demand o le prenotazioni future fino a 90 giorni (in modalità calendario). Dopo aver scelto un'opzione di consumo, segui le istruzioni rispettive per ottenere la capacità utilizzando l'opzione di consumo che hai scelto.
- Assicurati di disporre di una quota sufficiente per le GPU H100. Per richiedere una quota maggiore, vedi Quote di GPU.
Requisiti
Si applicano i seguenti requisiti a GPUDirect-TCPX:
Standard
- GPUDirect-TCPX è supportato con tutte le versioni secondarie di GKE disponibili utilizzando versioni patch specifiche:
- Per GKE 1.30-1.33, utilizza qualsiasi versione patch.
- Per GKE 1.34, utilizza la versione patch 1.34.5-gke.1153000 o successive.
- Per GKE 1.35, utilizza la versione patch 1.35.2-gke.1485000 o successive.
- Per GKE 1.36 o versioni successive, utilizza qualsiasi versione patch.
- Il nodo GKE deve utilizzare un'immagine del nodo Container-Optimized OS (COS). Le immagini dei nodi Ubuntu e Windows non sono supportate.
- I nodi GPU devono utilizzare la versione 535 o successive del driver NVIDIA.
- Devi utilizzare GKE Dataplane V2.
- Su GKE versione 1.34 e successive, devi utilizzare la versione 3.1.9 o successive del programma di installazione di GPUDirect-TCPX e la versione 2.0.12 o successive del sidecar GPUDirect-TCPX. Le versioni dell'installer e del sidecar hanno una mappatura uno a uno e devono corrispondere. Ad esempio, la versione del programma di installazione 3.1.12 corrisponde alla versione del sidecar 2.0.15. Per ulteriori informazioni sulle versioni dell'installer e del sidecar, consulta le note di rilascio di GPUDirect-TCPX.
- Per i carichi di lavoro GPUDirect-TCPX eseguiti su più pool di nodi, tutti i pool di nodi devono trovarsi nelle stesse zone Compute Engine e devono utilizzare gli stessi set di rete, come VPC e subnet.
Autopilot
- Per utilizzare GPUDirect-TCPX, il cluster deve eseguire le seguenti versioni patch GKE minime:
- Per GKE 1.31, utilizza la patch 1.31.1-gke.1621000 o versioni successive.
- Per GKE 1.32-1.33, utilizza qualsiasi versione patch.
- Per GKE 1.34, utilizza la versione patch 1.34.5-gke.1153000 o successive.
- Per GKE 1.35, utilizza la versione patch 1.35.2-gke.1485000 o successive.
- Per GKE 1.36 o versioni successive, utilizza qualsiasi versione patch.
- I nodi GPU devono utilizzare la versione 535 o successive del driver NVIDIA.
- Devi utilizzare GKE Dataplane V2.
- Su GKE versione 1.34 e successive, devi utilizzare la versione 3.1.9 o successive del programma di installazione di GPUDirect-TCPX e la versione 2.0.12 o successive del sidecar GPUDirect-TCPX. Le versioni dell'installer e del sidecar hanno un mapping uno a uno e devono corrispondere. Ad esempio, la versione 3.1.12 del programma di installazione corrisponde alla versione 2.0.15 del sidecar. Per ulteriori informazioni sulle versioni dell'installer e del sidecar, consulta le note di rilascio di GPUDirect-TCPX.
- Per i carichi di lavoro GPUDirect-TCPX eseguiti su più pool di nodi, tutti i pool di nodi devono trovarsi nelle stesse zone Compute Engine e devono utilizzare gli stessi set di rete, come VPC e subnet.
Limitazioni
Si applicano le seguenti limitazioni:
- GPUDirect-TCPX non è supportato con GPU multi-istanza, condivisione del tempo della GPU o NVIDIA MPS.
- Non puoi utilizzare NCCL FastSocket con GPUDirect-TCPX.
- Il tuo workload GKE deve utilizzare tutte le GPU disponibili e tutte le NIC secondarie disponibili su un singolo nodo. Più pod non possono utilizzare GPUDirect-TCPX su un singolo nodo.
Crea VPC e subnet
Crea reti VPC separate nel tuo progetto per ogni NIC virtuale che aggiungerai ai tuoi nodi. Ogni rete VPC deve avere una subnet e una regola firewall che consenta il traffico di rete interno.
Per massimizzare la larghezza di banda, ti consigliamo di creare quattro nuove reti.
for N in $(seq 1 4); do gcloud compute networks create PREFIX-net-$N \ --subnet-mode=custom \ --mtu=8244 gcloud compute networks subnets create PREFIX-sub-$N \ --network=PREFIX-net-$N \ --region=REGION \ --range=SUBNET_RANGE gcloud compute firewall-rules create PREFIX-internal-$N \ --network=PREFIX-net-$N \ --action=ALLOW \ --rules=tcp:0-65535,udp:0-65535,icmp \ --source-ranges=SOURCE_RANGE doneSostituisci quanto segue:
PROJECT_ID: il tuo ID progetto Google Cloud .REGION: la regione Compute Engine per ogni subnet.SUBNET_RANGE: l'intervallo di indirizzi IP di ogni subnet in notazione CIDR. Questo comando di esempio esegue l'iterazione per quattro subnet, quindi devi utilizzare una variabile per modificare l'indirizzo IP per ogni subnet. Ad esempio, specifica192.168.$N.0/24in modo che la prima subnet utilizzi192.168.1.0/24, la seconda subnet utilizzi192.168.2.0/24e così via.SOURCE_RANGE: l'intervallo di indirizzi IP di origine per la regola firewall per consentire il traffico in entrata, in notazione CIDR. Ad esempio,192.168.0.0/16.
Verifica che le reti siano state create:
gcloud compute networks list
Crea l'ambiente GKE
Crea un nuovo cluster GKE che utilizzi il networking multiplo (anteprima) e crea un pool di nodi GPU con le seguenti caratteristiche:
- gVNIC abilitato
- Subnet multi-networking specificate per ogni NIC secondaria
- Serie di macchine A3 Edge con GPU H100 che supportano i nodi
- Sono installati i driver NVIDIA più recenti
Non puoi aggiornare un cluster esistente per utilizzare più reti.
Crea un cluster:
Standard
gcloud beta container clusters create CLUSTER_NAME \ --enable-dataplane-v2 \ --enable-ip-alias \ --location=CONTROL_PLANE_LOCATION \ --enable-multi-networking \ --cluster-version=VERSION \ --no-enable-autoupgrade \ --project=PROJECT_IDSostituisci quanto segue:
Autopilot
gcloud beta container clusters create-auto CLUSTER_NAME \ --project=PROJECT_ID \ --location=CONTROL_PLANE_LOCATION \ --cluster-version=VERSION \ --enable-multi-networking \ --workload-policies=allow-net-adminSostituisci quanto segue:
Crea risorse Network e GKENetworkParamSet nel cluster che corrispondono alle reti e alle subnet VPC che hai creato:
kubectl apply -f - <<EOF apiVersion: networking.gke.io/v1 kind: Network metadata: name: vpc1 spec: parametersRef: group: networking.gke.io kind: GKENetworkParamSet name: vpc1 type: Device --- apiVersion: networking.gke.io/v1 kind: Network metadata: name: vpc2 spec: parametersRef: group: networking.gke.io kind: GKENetworkParamSet name: vpc2 type: Device --- apiVersion: networking.gke.io/v1 kind: Network metadata: name: vpc3 spec: parametersRef: group: networking.gke.io kind: GKENetworkParamSet name: vpc3 type: Device --- apiVersion: networking.gke.io/v1 kind: Network metadata: name: vpc4 spec: parametersRef: group: networking.gke.io kind: GKENetworkParamSet name: vpc4 type: Device --- apiVersion: networking.gke.io/v1 kind: GKENetworkParamSet metadata: name: vpc1 spec: vpc: PREFIX-net-1 vpcSubnet: PREFIX-sub-1 deviceMode: NetDevice --- apiVersion: networking.gke.io/v1 kind: GKENetworkParamSet metadata: name: vpc2 spec: vpc: PREFIX-net-2 vpcSubnet: PREFIX-sub-2 deviceMode: NetDevice --- apiVersion: networking.gke.io/v1 kind: GKENetworkParamSet metadata: name: vpc3 spec: vpc: PREFIX-net-3 vpcSubnet: PREFIX-sub-3 deviceMode: NetDevice --- apiVersion: networking.gke.io/v1 kind: GKENetworkParamSet metadata: name: vpc4 spec: vpc: PREFIX-net-4 vpcSubnet: PREFIX-sub-4 deviceMode: NetDevice EOFQueste risorse indicano a GKE di configurare le NIC per il traffico GPU in modalità passthrough. GKE non applica a questo traffico la programmazione di rete integrata utilizzando eBPF.
Crea un pool di nodi GPU (solo Standard)
Crea un pool di nodi per le GPU H100:
gcloud container node-pools create NODE_POOL_NAME \ --cluster=CLUSTER_NAME \ --location=CONTROL_PLANE_LOCATION \ --machine-type=a3-edgegpu-8g \ --accelerator=type=nvidia-h100-80gb,count=8,gpu-driver-version=LATEST \ --additional-node-network=network=PREFIX-net-1,subnetwork=PREFIX-sub-1 \ --additional-node-network=network=PREFIX-net-2,subnetwork=PREFIX-sub-2 \ --additional-node-network=network=PREFIX-net-3,subnetwork=PREFIX-sub-3 \ --additional-node-network=network=PREFIX-net-4,subnetwork=PREFIX-sub-4 \ --enable-gvnic \ --no-enable-autoupgrade \ --placement-policy=POLICY_NAME \ --reservation-affinity=specific \ --reservation=projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAMESostituisci
NODE_POOL_NAMEcon il nome del pool di nodi.Per utilizzare una prenotazione, utilizza i flag
--placement-policy,--reservation-affinitye--reservation. Specifica questi flag per configurare il nome della policy e la prenotazione nel pool di nodi. Se la prenotazione non richiede una policy delle risorse, ometti il flag--placement-policy.Il flag
--reservation-affinitypuò assumere i valorispecificoany. Tuttavia, per i carichi di lavoro di AI distribuita ad alte prestazioni, ti consigliamo di utilizzare una prenotazione specifica. Puoi trovare informazioni sulla tua prenotazione, ad esempio il nome della prenotazione o il nome di un blocco specifico della prenotazione. Per trovare questi valori per le prenotazioni on demand, visualizza un elenco delle tue prenotazioni oppure visualizza le richieste di prenotazione future.Sostituisci quanto segue per utilizzare una prenotazione:
PROJECT_ID: (facoltativo) il tuo ID progetto Google Cloud. Se la prenotazione si trova nel progetto corrente (non una prenotazione condivisa), puoi omettereprojects/PROJECT_ID/reservations/dal valore della prenotazione.RESERVATION_NAME: il nome della prenotazione.BLOCK_NAME: (facoltativo) il nome di un blocco specifico all'interno della prenotazione. Ometti/reservationBlocks/BLOCK_NAMEse non vuoi utilizzare un blocco specifico.
Se questo comando non funziona, potresti non disporre di una quota sufficiente di GPU H100 nel tuo progetto. Assicurati di disporre di una quota e riprova a eseguire il comando.
Dopo aver creato il pool di nodi, verifica che ogni nodo abbia le GPU collegate:
Recupera un elenco dei nodi nel cluster:
kubectl get nodesVerifica che ogni nodo GPU abbia otto GPU:
kubectl describe node NODE_NAMESostituisci
NODE_NAMEcon il nome del nodo da descrivere.L'output è simile al seguente:
Capacity: ... nvidia.com/gpu: 8 Allocatable: ... nvidia.com/gpu: 8
Installa il file binario GPUDirect e il plug-in NCCL
Questa sezione mostra come installare il file binario GPUDirect-TCPX e una versione specifica della libreria NCCL utilizzando un DaemonSet.
Questo DaemonSet esegue le seguenti operazioni:
- Installa la libreria NCCL e il file binario GPUDirect-TCPX sul nodo.
- Memorizza la libreria e il binario nella directory
/home/kubernetes/bin/nvidia/lib64della VM. Per impostazione predefinita, GKE monta questa directory nel percorso/usr/local/nvidia/lib64nei container GPU che devono utilizzare NCCL e GPUDirect-TCPX.
Per installare il file binario e configurare NCCL:
Standard
Esamina il
nccl-tcpx-installer.yamlmanifesto Daemonset in GitHub.Esegui il deployment di DaemonSet:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-tcpx-installer.yamlL'avvio del plug-in NCCL richiede circa due minuti.
Verifica lo stato dei pod DaemonSet:
kubectl get pods -n=kube-system -l=name=nccl-tcpx-installerL'output è simile al seguente:
nccl-tcpx-installer-6c2pv 1/1 Running 0 2m11s nccl-tcpx-installer-qgg82 1/1 Running 0 2m11s
Autopilot
Esamina il
nccl-tcpx-installer-autopilot.yamlmanifest di Daemonset in GitHub.Crea uno spazio dei nomi dedicato:
kubectl create ns gpudirect-systemEsegui il deployment di DaemonSet:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-tcpx-installer-autopilot.yamlL'avvio del plug-in NCCL richiede circa due minuti.
Esegui il deployment del plug-in di inserimento dei dispositivi NRI
Questa sezione mostra come installare lo strumento di inserimento dei dispositivi NRI utilizzando un DaemonSet. Questo plug-in esegue le seguenti operazioni:
- Attiva Node Resource Interface (NRI) sul nodo con GPU H100. NRI è abilitato per impostazione predefinita su GKE 1.29 e versioni successive.
- Esegue il deployment di un container plug-in NRI device injector che inserisce i dispositivi GPU nei container specificati dalle annotazioni del pod.
Per installare il plug-in:
Standard
Esamina il manifest di deployment di
nri-device-injector.yamlin GitHub.Esegui il deployment di DaemonSet:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nri_device_injector/nri-device-injector.yamlL'avvio del plug-in NCCL richiede circa due minuti.
Verifica lo stato dei pod DaemonSet:
kubectl get pods -n=kube-system -l=name=device-injectorL'output è simile al seguente:
# Output device-injector-md6hb 1/1 Running 0 4h54m device-injector-vh9bm 1/1 Running 0 4h54m
Autopilot
Esamina il manifest di deployment di
nri-device-injector-autopilot.yamlin GitHub.Esegui il deployment di DaemonSet:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nri_device_injector/nri-device-injector-autopilot.yamlL'avvio del plug-in NCCL richiede circa due minuti.
Esegui il deployment di un carico di lavoro di test
In questa sezione, esegui il deployment di un carico di lavoro di esempio per verificare che NCCL e GPUDirect-TCPX funzionino come previsto. Questo carico di lavoro di esempio esegue le seguenti operazioni:
- Esegue il deployment di due pod, ognuno dei quali viene eseguito in un nodo con GPU H100.
- Esegue il deployment di un container sidecar in ogni pod per consentire a questi pod di utilizzare GPUDirect-TCPX.
Questo carico di lavoro include un container sidecar denominato tcpx-daemon, che esegue un servizio che consente al pod di utilizzare GPUDirect-TCPX. Devi aggiungere questo container sidecar a tutti i pod nel tuo ambiente che devono utilizzare GPUDirect-TCPX. Per un snippet dei campi obbligatori da aggiungere ai manifest, vedi Aggiungere GPUDirect al manifest.
Esamina il
nccl-config.yamlmanifest ConfigMap in GitHub. Questo manifest esegue il deployment di script che inizializzano un test di raccolta NCCL e impostano le impostazioni di configurazione specifiche di NCCL.A seconda della modalità cluster, procedi nel seguente modo:
Standard
Esamina il manifest di deployment di
nccl-test-latest.yamlin GitHub.Autopilot
Esamina il manifest di deployment di
nccl-test-latest-autopilot.yamlin GitHub.Esegui il deployment di ConfigMap e del carico di lavoro di test:
Standard
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-config.yaml kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-test-latest.yamlAutopilot
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-config.yaml kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-test-latest-autopilot.yamlVerifica che i pod siano in esecuzione e pronti. Tieni presente che le immagini sono di grandi dimensioni (circa 5 GB) e il download può richiedere diversi minuti.
kubectl get pods -wIl comando monitora gli aggiornamenti e stampa una nuova riga quando lo stato di un pod cambia. L'output è simile al seguente:
NAME READY STATUS RESTARTS AGE nccl-test-host-1 0/2 ContainerCreating 0 23s nccl-test-host-2 2/2 Running 0 23s nccl-test-host-1 2/2 Running 0 46sPrima di procedere al passaggio successivo, attendi che il messaggio
STATUSper tutti i pod siaRunninge che il valore diREADYsia2/2.Esegui i seguenti comandi per attivare un test NCCL all-gather per i nodi:
kubectl exec \ --stdin --tty --container=nccl-test nccl-test-host-1 \ -- /configs/allgather.sh nccl-host-1 nccl-host-2L'output è simile al seguente:
Standard
# out-of-place in-place # size count type redop root time algbw busbw #wrong time algbw busbw #wrong # (B) (elements) (us) (GB/s) (GB/s) (us) (GB/s) (GB/s) 0 0 float none -1 0.24 0.00 0.00 0 0.18 0.00 0.00 0 0 0 float none -1 0.19 0.00 0.00 0 0.17 0.00 0.00 0 0 0 float none -1 0.17 0.00 0.00 0 0.17 0.00 0.00 0 0 0 float none -1 0.17 0.00 0.00 0 0.17 0.00 0.00 0 0 0 float none -1 0.17 0.00 0.00 0 0.17 0.00 0.00 0 256 4 float none -1 235.2 0.00 0.00 0 235.1 0.00 0.00 0 512 8 float none -1 241.0 0.00 0.00 0 236.1 0.00 0.00 0 1024 16 float none -1 236.3 0.00 0.00 0 233.3 0.00 0.00 0 2048 32 float none -1 234.1 0.01 0.01 0 233.4 0.01 0.01 0 4096 64 float none -1 237.1 0.02 0.02 0 235.3 0.02 0.02 0 8192 128 float none -1 236.2 0.03 0.03 0 235.2 0.03 0.03 0 16384 256 float none -1 236.6 0.07 0.06 0 238.5 0.07 0.06 0 32768 512 float none -1 237.9 0.14 0.13 0 238.8 0.14 0.13 0 65536 1024 float none -1 242.3 0.27 0.25 0 239.4 0.27 0.26 0 131072 2048 float none -1 263.0 0.50 0.47 0 275.1 0.48 0.45 0 262144 4096 float none -1 279.2 0.94 0.88 0 269.9 0.97 0.91 0 524288 8192 float none -1 273.5 1.92 1.80 0 273.5 1.92 1.80 0 1048576 16384 float none -1 315.1 3.33 3.12 0 314.1 3.34 3.13 0 2097152 32768 float none -1 319.2 6.57 6.16 0 311.5 6.73 6.31 0 4194304 65536 float none -1 331.8 12.64 11.85 0 331.3 12.66 11.87 0 8388608 131072 float none -1 356.3 23.54 22.07 0 353.8 23.71 22.23 0 16777216 262144 float none -1 409.1 41.01 38.45 0 405.2 41.40 38.81 0 33554432 524288 float none -1 451.4 74.34 69.69 0 447.7 74.94 70.26 0 67108864 1048576 float none -1 713.4 94.07 88.19 0 713.8 94.01 88.13 0 134217728 2097152 float none -1 1122.1 119.62 112.14 0 1116.3 120.23 112.72 0 268435456 4194304 float none -1 1785.8 150.32 140.92 0 1769.2 151.72 142.24 0 536870912 8388608 float none -1 2859.7 187.74 176.00 0 2852.6 188.20 176.44 0 1073741824 16777216 float none -1 5494.1 195.44 183.22 0 5568.2 192.83 180.78 0 2147483648 33554432 float none -1 10841 198.09 185.71 0 10798 198.88 186.45 0 4294967296 67108864 float none -1 21453 200.21 187.70 0 21490 199.86 187.37 0 8589934592 134217728 float none -1 42603 201.63 189.03 0 42670 201.31 188.73 0 # Out of bounds values : 0 OK # Avg bus bandwidth : 45.7587 # ```Autopilot
# out-of-place in-place # size count type redop root time algbw busbw #wrong time algbw busbw #wrong # (B) (elements) (us) (GB/s) (GB/s) (us) (GB/s) (GB/s) 1048576 16384 float none -1 696.8 1.50 1.41 0 729.0 1.44 1.35 0 2097152 32768 float none -1 776.4 2.70 2.53 0 726.7 2.89 2.71 0 4194304 65536 float none -1 774.3 5.42 5.08 0 805.1 5.21 4.88 0 8388608 131072 float none -1 812.1 10.33 9.68 0 817.6 10.26 9.62 0 16777216 262144 float none -1 1035.2 16.21 15.19 0 1067.8 15.71 14.73 0 33554432 524288 float none -1 1183.3 28.36 26.59 0 1211.8 27.69 25.96 0 67108864 1048576 float none -1 1593.4 42.12 39.49 0 1510.5 44.43 41.65 0 134217728 2097152 float none -1 2127.8 63.08 59.13 0 2312.7 58.03 54.41 0 268435456 4194304 float none -1 3603.0 74.50 69.85 0 3586.2 74.85 70.17 0 536870912 8388608 float none -1 7101.7 75.60 70.87 0 7060.9 76.03 71.28 0 # Out of bounds values : 0 OK # Avg bus bandwidth : 29.8293
Adottare GPUDirect per i tuoi carichi di lavoro
Dopo aver verificato che la rete del cluster funzioni correttamente con il carico di lavoro di test di esempio, il passaggio successivo consiste nell'adottare GPUDirect per i tuoi carichi di lavoro effettivi. Per adottare GPUDirect, devi aggiornare le impostazioni NCCL e i manifest dei pod Kubernetes.
Utilizza le impostazioni di configurazione NCCL richieste per migliorare le prestazioni
Le seguenti coppie chiave-valore sono le impostazioni di configurazione NCCL richieste per GPUDirect-TCPX. Quando esegui il deployment dei tuoi workload che utilizzano NCCL, impostali come variabili di ambiente per ottimizzare il rendimento.
"LD_LIBRARY_PATH=\"${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64\"",
"NCCL_SOCKET_IFNAME=\"eth0\"",
"NCCL_ALGO=Ring",
"NCCL_PROTO=Simple",
"NCCL_CROSS_NIC=0",
"NCCL_NET_GDR_LEVEL=PIX",
"NCCL_P2P_PXN_LEVEL=0",
"NCCL_GPUDIRECTTCPX_SOCKET_IFNAME=eth1,eth2,eth3,eth4",
"NCCL_GPUDIRECTTCPX_CTRL_DEV=eth0",
"NCCL_DYNAMIC_CHUNK_SIZE=524288",
"NCCL_P2P_NET_CHUNKSIZE=524288",
"NCCL_P2P_PCI_CHUNKSIZE=524288",
"NCCL_P2P_NVL_CHUNKSIZE=1048576",
"NCCL_BUFFSIZE=4194304",
"NCCL_NSOCKS_PERTHREAD=4",
"NCCL_SOCKET_NTHREADS=1",
"NCCL_GPUDIRECTTCPX_TX_BINDINGS=\"eth1:8-21,112-125;eth2:8-21,112-125;eth3:60-73,164-177;eth4:60-73,164-177\"",
"NCCL_GPUDIRECTTCPX_RX_BINDINGS=\"eth1:22-35,126-139;eth2:22-35,126-139;eth3:74-87,178-191;eth4:74-87,178-191\"",
"NCCL_GPUDIRECTTCPX_PROGRAM_FLOW_STEERING_WAIT_MICROS=500000"
Aggiungere GPUDirect ai manifest
Questa sezione mostra i campi obbligatori che devi aggiungere ai manifest Kubernetes affinché i pod utilizzino GPUDirect.
A seconda della modalità del cluster, procedi nel seguente modo:
Standard
Aggiungi le seguenti annotazioni ai metadati del pod. Senza queste annotazioni,
hostNetwork:truesarà obbligatorio per il pod eprivileged:truesarà obbligatorio per il containertcpx-daemon.metadata: annotations: devices.gke.io/container.tcpx-daemon: |+ - path: /dev/nvidia0 - path: /dev/nvidia1 - path: /dev/nvidia2 - path: /dev/nvidia3 - path: /dev/nvidia4 - path: /dev/nvidia5 - path: /dev/nvidia6 - path: /dev/nvidia7 - path: /dev/nvidiactl - path: /dev/nvidia-uvm networking.gke.io/default-interface: 'eth0' networking.gke.io/interfaces: | [ {"interfaceName":"eth0","network":"default"}, {"interfaceName":"eth1","network":"vpc1"}, {"interfaceName":"eth2","network":"vpc2"}, {"interfaceName":"eth3","network":"vpc3"}, {"interfaceName":"eth4","network":"vpc4"}, ]Aggiungi i seguenti campi alla specifica del pod:
spec: volumes: - name: libraries hostPath: path: /home/kubernetes/bin/nvidia/lib64 - name: sys hostPath: path: /sys - name: proc-sys hostPath: path: /proc/sysAggiungi il seguente container al manifest per eseguire il servizio tcpx-daemon:
- name: tcpx-daemon image: us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpx/tcpgpudmarxd-dev:v2.0.9 command: - /tcpgpudmarxd/build/app/tcpgpudmarxd - --gpu_nic_preset - a3vm - --gpu_shmem_type - fd - --uds_path - /run/tcpx - --setup_param - \"--verbose 128 2 0 \" securityContext: capabilities: add: - NET_ADMIN volumeMounts: - name: libraries mountPath: /usr/local/nvidia/lib64 - name: tcpx-socket mountPath: /run/tcpx - name: sys mountPath: /hostsysfs - name: proc-sys mountPath: /hostprocsysfs env: - name: LD_LIBRARY_PATH value: /usr/local/nvidia/lib64Aggiungi i seguenti montaggi volumi a tutti i container che richiedono GPU:
volumeMounts: - name: tcpx-socket mountPath: /tmp - name: libraries mountPath: /usr/local/nvidia/lib64Aggiungi variabili di ambiente per configurare le opzioni NCCL. Per maggiori dettagli, consulta la sezione Utilizzare le impostazioni di configurazione NCCL consigliate per migliorare le prestazioni in questo documento.
Aggiungi la seguente variabile di ambiente a ogni container GPU:
env: - name: LD_LIBRARY_PATH value: /usr/local/nvidia/lib64
Per un esempio di specifica del pod completata, consulta il manifest nccl-test-latest.yaml su GitHub.
Autopilot
Per la modalità Autopilot, devi anche selezionare le GPU appropriate nei manifest dei pod in modo che GKE esegua il provisioning dell'hardware.
Aggiungi i seguenti selettori di nodi al pod:
nodeSelector:
cloud.google.com/gke-accelerator: a3-edgegpu-8g
cloud.google.com/gke-gpu-driver-version: latest
Inoltre, se vuoi utilizzare la capacità riservata, puoi fornire informazioni sulla prenotazione. Per saperne di più, consulta le sottosezioni sull'utilizzo delle prenotazioni in Utilizzare le prenotazioni di capacità nei cluster Autopilot.
Aggiungi le seguenti annotazioni ai metadati del pod:
metadata: annotations: devices.gke.io/container.tcpx-daemon: |+ - path: /dev/nvidia0 - path: /dev/nvidia1 - path: /dev/nvidia2 - path: /dev/nvidia3 - path: /dev/nvidia4 - path: /dev/nvidia5 - path: /dev/nvidia6 - path: /dev/nvidia7 - path: /dev/nvidiactl - path: /dev/nvidia-uvm networking.gke.io/default-interface: 'eth0' networking.gke.io/interfaces: | [ {"interfaceName":"eth0","network":"default"}, {"interfaceName":"eth1","network":"vpc1"}, {"interfaceName":"eth2","network":"vpc2"}, {"interfaceName":"eth3","network":"vpc3"}, {"interfaceName":"eth4","network":"vpc4"}, ]Aggiungi i seguenti campi alla specifica del pod:
spec: volumes: - name: libraries hostPath: path: /home/kubernetes/bin/nvidia/lib64 - name: sys hostPath: path: /sys - name: proc-sys hostPath: path: /proc/sysAggiungi il seguente container al manifest per eseguire il servizio tcpx-daemon:
- name: tcpx-daemon image: us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpx/tcpgpudmarxd-dev:v2.0.9 command: - /tcpgpudmarxd/build/app/tcpgpudmarxd - --gpu_nic_preset - a3vm - --gpu_shmem_type - fd - --uds_path - /run/tcpx - --setup_param - \"--verbose 128 2 0 \" securityContext: capabilities: add: - NET_ADMIN volumeMounts: - name: libraries mountPath: /usr/local/nvidia/lib64 - name: tcpx-socket mountPath: /run/tcpx - name: sys mountPath: /hostsysfs - name: proc-sys mountPath: /hostprocsysfs env: - name: LD_LIBRARY_PATH value: /usr/local/nvidia/lib64Aggiungi i seguenti montaggi volumi a tutti i container che richiedono GPU:
volumeMounts: - name: tcpx-socket mountPath: /tmp - name: libraries mountPath: /usr/local/nvidia/lib64Aggiungi variabili di ambiente per configurare le opzioni NCCL. Per maggiori dettagli, consulta la sezione Utilizzare le impostazioni di configurazione NCCL consigliate per migliorare le prestazioni in questo documento.
Per un esempio di specifica del pod completata, consulta il manifest nccl-test-latest-autopilot.yaml su GitHub.
Raccogliere i log di debug NCCL
Per registrare gli errori NCCL, ti consigliamo di aggiungere la seguente configurazione NCCL:
NCCL_DEBUG=INFO
NCCL_DEBUG_SUBSYS=INIT,NET,ENV,COLL,GRAPH
NCCL_DEBUG_FILE=/DIRECTORY/FILE_NAME.%h.%p
NCCL_DEBUG=INFO: stampa le informazioni di debug.- Per i workload su larga scala (64 nodi o più), può verificarsi una registrazione estesa. Per evitare questo scenario, e a meno che tu non abbia specificato
NCCL_DEBUG_FILE, ti consigliamo di impostareNCCL_DEBUG=WARNper limitare i log ai soli errori.
- Per i workload su larga scala (64 nodi o più), può verificarsi una registrazione estesa. Per evitare questo scenario, e a meno che tu non abbia specificato
NCCL_DEBUG_SUBSYS: filtra i sottosistemi per i quali NCCL raccoglie informazioni di debug. Ti consigliamo di raccogliere i log per i seguenti sottosistemi:INIT: la fase di inizializzazione di NCCL.NET: la rete NCCL.ENV: le variabili di ambiente utilizzate da NCCL.COLL: operazioni collettive.GRAPH: rilevamento della topologia e ricerca nel grafico.
Se vuoi raccogliere log per diversi sottosistemi, consulta
NCCL_DEBUG_SUBSYSnella documentazione di NCCL per un elenco dei valori accettati.NCCL_DEBUG_FILE(facoltativo): indirizza l'output di logging di debug NCCL a un file specificato. Questa variabile scrive i log NCCL in file standard, il che impedisce all'output del log di mescolarsi con l'output dell'applicazione. Questa variabile scrive anche i log di diversi ranghi NCCL in file diversi, il che impedisce la combinazione dei log.Utilizza il seguente formato del nome file:
/DIRECTORY/FILE_NAME.%h.%pSostituisci quanto segue:
DIRECTORY: la directory in cui vuoi archiviare i file di log.FILE_NAME: il nome dei file di log.
Il segnaposto
%hviene risolto nel nome host del nodo, mentre%pviene risolto nell'ID processo (PID) del processo che genera il log.
Per ulteriori informazioni sul debug dei log NCCL, consulta Risolvere i problemi relativi alle GPU in GKE.
Passaggi successivi
- Per saperne di più sulla pianificazione dei workload sui cluster GKE utilizzando Topology Aware Scheduling (TAS) e Kueue, consulta Pianificare i workload GKE con Topology Aware Scheduling.
- Per saperne di più sulla gestione degli eventi comuni pertinenti ai cluster GKE e ai carichi di lavoro AI, consulta Gestire i cluster GKE ottimizzati per l'AI.