Massimizzare la larghezza di banda della rete GPU nei cluster in modalità standard

Questa pagina mostra come massimizzare la larghezza di banda e la velocità effettiva di rete per carichi di lavoro GPU ad alte prestazioni in Google Kubernetes Engine (GKE) Standard utilizzando GPUDirect-TCPXO, GPUDirect-TCPX, gVNIC e networking multiplo. Se usi i cluster Autopilot, Massimizza la larghezza di banda della rete GPU nei cluster in modalità Autopilot.

Questa pagina è rivolta agli ingegneri di machine learning (ML) e agli amministratori della piattaforma che gestiscono i carichi di lavoro ML. Prima di leggere questa pagina, assicurati di acquisire familiarità con il networking tecnologie come le schede di interfaccia di rete, (NIC) e TCP e con tecnologie di acceleratore come NVIDIA Collective Communications Library (NCCL).

Le applicazioni di intelligenza artificiale (IA), 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'IA conversazionale e sulla generazione di immagini richiedono elevata scalabilità e potenza di calcolo.

Informazioni sui supercomputer GPU di Google Cloud

Google Cloud dispone di supercomputer ottimizzati per gli acceleratori progettati per modelli di grandi dimensioni e scalabili. Queste macchine offrono i seguenti vantaggi:

  • Otto GPU NVIDIA H100 per macchina.
  • Larghezza di banda fino a 200 Gbps sulla NIC principale.
  • NIC secondarie (fino a otto nei tipi di macchine A3 Mega e fino a quattro nei tipi di macchine A3 High), ciascuna con una larghezza di banda fino a 200 Gbps per il trasferimento dei dati della GPU.

Per un elenco completo dei vantaggi, vedi Serie di macchine A3 nella documentazione di Compute Engine.

Il carico di lavoro GKE deve utilizzare tutte le GPU e tutte le GPU disponibili NIC secondarie su un singolo nodo e utilizzano una parte significativa larghezza di banda disponibile. La soluzione descritta in questo documento è ideale per carichi di lavoro che richiedono prestazioni elevate, velocità effettiva elevata e bassa latenza.

Funzionalità e capacità richieste per ottimizzare la larghezza di banda

Per massimizzare la larghezza di banda della rete nei nodi del supercomputer GPU, utilizza tutti le seguenti funzionalità:

  • Stack di rete GPUDirect: la serie di macchine A3 supporta due stack di rete per l'accesso diretto alla memoria (RDMA) personalizzato e remoto:
    • Sui tipi di macchina A3 High e sulle GPU NVIDIA H100, utilizza GPUDirect-TCPX per ridurre l’overhead richiesto per trasferire i payload di pacchetti da e verso GPU, che migliorano significativamente la velocità effettiva su larga scala rispetto alle GPU che non utilizzare GPUDirect.
    • Sui tipi di macchine A3 Mega e sulle GPU NVIDIA H100 Mega, utilizza GPUDirect-TCPXO migliorando ulteriormente la comunicazione da GPU a VM.
  • gVNIC: abilita le funzionalità GPUDirect, come la suddivisione dell'intestazione dei pacchetti, la gestione del flusso e la gestione dei buffer. gVNIC è necessario per utilizzare GPUDirect-TCPX o GPUDirect-TCPXO. Per maggiori dettagli sulla gVNIC, consulta Aumentare la velocità del traffico di rete per i nodi GPU.
  • Networking multiplo: aggiungi NIC secondarie a la macchina ottimizzata per l'acceleratore. Ogni NIC è associato a un nel proprio VPC per evitare conflitti. Per informazioni dettagliate sul supporto di più reti, consulta 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 carico di lavoro 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 tutte queste funzionalità contemporaneamente:

  1. Creare reti e subnet Virtual Private Cloud (VPC)
  2. Crea l'ambiente GKE.
  3. Installa il programma binario GPUDirect e il plug-in NCCL
  4. Eseguire il deployment del plug-in di iniezione del dispositivo NRI
  5. Esegui il deployment di un carico di lavoro di test per verificare la configurazione di GPUDirect

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
  • 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.
  • Assicurati di disporre di una quota sufficiente per le GPU H100. Per richiedere una quota maggiore, consulta le quote delle GPU.

Requisiti

I seguenti requisiti si applicano sia a GPUDirect-TCPX sia a GPUDirect-TCPXO se non diversamente indicato.

  • GPUDirect-TCPX è supportato su GKE versione 1.27 o successive e richiede:
    • * Il tipo di macchina a3-highgpu-8g.
    • Per la versione 1.27 di GKE, utilizza la versione della patch GKE 1.27.7-gke.1121000 o successiva.
    • Per GKE versione 1.28, usa GKE patch versione 1.28.8-gke.1095000 o successiva.
    • Per la versione 1.29 di GKE, utilizza la versione della patch GKE 1.29.3-gke.1093000 o successiva.
  • GPUDirect-TCPXO è supportato su GKE versione 1.28 o successive e richiede:
    • Il tipo di macchina a3-megagpu-8g.
    • Per la versione 1.28 di GKE, utilizza la patch GKE 1.28.9-gke.1250000 o successiva.
    • Per la versione 1.29 di GKE, utilizza la versione della patch GKE 1.29.4-gke.1542000 o successiva.
  • Il nodo GKE deve utilizzare un nodo Container-Optimized OS (COS) dell'immagine. Le immagini dei nodi Ubuntu e Windows non sono supportate.
  • I nodi GPU devono utilizzare il driver NVIDIA 535 o versioni successive.
  • Devi utilizzare GKE Dataplane V2.

Limitazioni

Si applicano le seguenti limitazioni:

  • GPUDirect-TCPX e GPUDirect-TCPXO non sono supportati con GPU multi-istanza, condivisione in tempo della GPU o NVIDIA MPS.
  • Non puoi utilizzare NCCL FastSocket.
  • Il carico di lavoro GKE deve utilizzare tutte le GPU e tutte le NIC secondarie disponibili su un singolo nodo. Non è possibile utilizzare più pod con GPUDirect-TCPX o GPUDirect-TCPXO su un singolo nodo.
  • Puoi utilizzare solo i tipi di macchine a3-highgpu-8g e a3-megagpu-8g. Non sono supportati altri tipi di macchine A3.

Crea VPC e subnet

Crea reti VPC separate nel progetto per ogni NIC che aggiungerai ai nodi. Ogni rete VPC deve avere una subnet e una regola firewall che consenta il traffico di rete interno.

  1. Crea le reti VPC per GPUDirect nel tuo progetto, ciascuna con una subnet e una regola firewall. Scegli la scheda GPUDirect-TCPX per i tipi di macchine A3 High o la scheda GPUDirect-TCPXO per i tipi di macchine A3 Mega e poi segui le istruzioni riportate di seguito:

    GPUDirect-TCPXO

    Per massimizzare la larghezza di banda, ti consigliamo di creare otto nuove reti.

    for N in $(seq 1 8); do
gcloud compute networks create PROJECT_ID-net-$N \
    --subnet-mode=custom \
    --mtu=8244

gcloud compute networks subnets create PROJECT_ID-sub-$N \
    --network=PROJECT_ID-net-$N \
    --region=REGION \
    --range=SUBNET_RANGE

gcloud compute firewall-rules create PROJECT_ID-internal-$N \
  --network=PROJECT_ID-net-$N \
  --action=ALLOW \
  --rules=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=SOURCE_RANGE
done

    Sostituisci quanto segue:

    • PROJECT_ID: l'ID del tuo progetto Google Cloud.
    • REGION: la regione Compute Engine per ogni subrete.
    • SUBNET_RANGE: l'intervallo di indirizzi IP di ogni subnet in notazione CIDR. Questo esempio esegue l'iterazione per otto subnet, devi usare una variabile per modificare l'indirizzo IP per ogni subnet. Ad esempio, specifica 192.168.$N.0/24 in modo che la prima subnet utilizzi 192.168.1.0/24, la seconda subnet utilizza 192.168.2.0/24 e così via.
    • SOURCE_RANGE: l'intervallo di indirizzi IP di origine per la regola firewall che consente il traffico in entrata, in notazione CIDR. Ad esempio: 192.168.0.0/16.

    GPUDirect-TCPX

    Per ottimizzare la larghezza di banda, ti consigliamo di creare quattro nuove reti.

    for N in $(seq 1 4); do
gcloud compute networks create PROJECT_ID-net-$N \
    --subnet-mode=custom \
    --mtu=8244

gcloud compute networks subnets create PROJECT_ID-sub-$N \
    --network=PROJECT_ID-net-$N \
    --region=REGION \
    --range=SUBNET_RANGE

gcloud compute firewall-rules create PROJECT_ID-internal-$N \
  --network=PROJECT_ID-net-$N \
  --action=ALLOW \
  --rules=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=SOURCE_RANGE
done

    Sostituisci quanto segue:

    • PROJECT_ID: l'ID del tuo progetto Google Cloud.
    • REGION: la regione Compute Engine per ogni subrete.
    • 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 di ogni subnet. Ad esempio, specifica 192.168.$N.0/24 in modo che la prima subnet utilizzi 192.168.1.0/24, la seconda subnet utilizzi 192.168.2.0/24 e così via.
    • SOURCE_RANGE: l'intervallo di indirizzi IP di origine per il regola firewall per consentire il traffico in entrata, in notazione CIDR. Ad esempio: 192.168.0.0/16.

  2. Verifica che le reti siano state create:

    gcloud compute networks list

crea l'ambiente GKE

Crea un nuovo cluster GKE che utilizza il networking multiplo (anteprima) e crea un pool di nodi GPU con le seguenti caratteristiche:

  • gVNIC attivato
  • Subnet a più reti specificate per ogni NIC secondario
  • Serie di macchine A3 con GPU H100 di supporto per i nodi
  • Driver NVIDIA più recenti installati

Non puoi aggiornare un cluster esistente per utilizzare più reti.

GPUDirect-TCPXO

  1. Scegli una versione GKE disponibile che supporti GPUDirect-TCPXO. Per elencare le versioni, esegui questo comando:

    gcloud container get-server-config \
    --format="yaml(validMasterVersions)" \
    --region=REGION \
    --project=PROJECT_ID

    Sostituisci quanto segue:

    • REGION: la regione di computing per il piano di controllo del cluster.
    • PROJECT_ID: l'ID del tuo progetto Google Cloud.

  2. Crea un cluster:

    gcloud beta container clusters create CLUSTER_NAME \
  --enable-dataplane-v2 --enable-ip-alias --zone=ZONE \
  --enable-multi-networking --cluster-version=VERSION \
  --no-enable-autoupgrade \
  --project=PROJECT_ID

    Sostituisci quanto segue:

    • CLUSTER_NAME: il nome del nuovo cluster.
    • VERSION: una versione GKE supporta GPUDirect-TCPXO, come descritto in Requisiti.
    • ZONE: la zona di computing per il cluster.

  3. Crea nel cluster le risorse Network e GKENetworkParamSet corrispondenti 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: Network
metadata:
  name: vpc5
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc5
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc6
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc6
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc7
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc7
  type: Device
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: vpc8
spec:
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: vpc8
  type: Device
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc1
spec:
  vpc: PROJECT_ID-net-1
  vpcSubnet: PROJECT_ID-sub-1
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc2
spec:
  vpc: PROJECT_ID-net-2
  vpcSubnet: PROJECT_ID-sub-2
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc3
spec:
  vpc: PROJECT_ID-net-3
  vpcSubnet: PROJECT_ID-sub-3
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc4
spec:
  vpc: PROJECT_ID-net-4
  vpcSubnet: PROJECT_ID-sub-4
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc5
spec:
  vpc: PROJECT_ID-net-5
  vpcSubnet: PROJECT_ID-sub-5
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc6
spec:
  vpc: PROJECT_ID-net-6
  vpcSubnet: PROJECT_ID-sub-6
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc7
spec:
  vpc: PROJECT_ID-net-7
  vpcSubnet: PROJECT_ID-sub-7
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc8
spec:
  vpc: PROJECT_ID-net-8
  vpcSubnet: PROJECT_ID-sub-8
  deviceMode: NetDevice
EOF

    Queste 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 che utilizza eBPF.

GPUDirect-TCPX

  1. Crea un cluster:

    gcloud beta container clusters create CLUSTER_NAME \
  --enable-dataplane-v2 --enable-ip-alias --zone=ZONE \
  --enable-multi-networking --cluster-version=VERSION \
  --no-enable-autoupgrade \
  --project=PROJECT_ID

    Sostituisci quanto segue: * CLUSTER_NAME: il nome del nuovo cluster. * VERSION: una versione di GKE che supporta GPUDirect-TCPX, come descritto nella sezione Requisiti. * ZONE: la zona di computing per il cluster.

  2. Crea nel cluster le risorse Network e GKENetworkParamSet corrispondenti 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: PROJECT_ID-net-1
  vpcSubnet: PROJECT_ID-sub-1
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc2
spec:
  vpc: PROJECT_ID-net-2
  vpcSubnet: PROJECT_ID-sub-2
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc3
spec:
  vpc: PROJECT_ID-net-3
  vpcSubnet: PROJECT_ID-sub-3
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc4
spec:
  vpc: PROJECT_ID-net-4
  vpcSubnet: PROJECT_ID-sub-4
  deviceMode: NetDevice
EOF

    Queste risorse indicano a GKE di configurare le NIC per il traffico GPU in modalità passthrough. GKE non applica i programmazione di networking utilizzando eBPF per questo traffico.

Crea un pool di nodi GPU

GPUDirect-TCPXO

Crea un pool di nodi per le GPU H100:

gcloud beta container node-pools create NODE_POOL_NAME \
    --zone=ZONE \
    --cluster=CLUSTER_NAME \
    --project=PROJECT_ID \
    --accelerator=type=nvidia-h100-mega-80gb,count=8,gpu-driver-version=LATEST \
    --machine-type=a3-megagpu-8g \
    --num-nodes=2 \
    --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 \
    --additional-node-network network=PREFIX-net-5,subnetwork=PREFIX-sub-5 \
    --additional-node-network network=PREFIX-net-6,subnetwork=PREFIX-sub-6 \
    --additional-node-network network=PREFIX-net-7,subnetwork=PREFIX-sub-7 \
    --additional-node-network network=PREFIX-net-8,subnetwork=PREFIX-sub-8 \
    --enable-gvnic \
    --no-enable-autoupgrade \
    --scopes "https://www.googleapis.com/auth/cloud-platform" \
    [--placement-policy=POLICY_NAME \
    --reservation-affinity=specific \
    --reservation=RESERVATION_NAME \
    --host-maintenance-interval=PERIODIC]

Sostituisci NODE_POOL_NAME con il nome del pool di nodi.

Nell'esempio, --scopes "https://www.googleapis.com/auth/cloud-platform" imposta l'ambito dell'istanza del nodo su cloud-platform per praticità dei test. Per la produzione, ti consigliamo di limitare l'ambito e configurare credenziali più granulari.

Utilizza i flag --placement-policy, --reservation-affinity e --reservation se utilizzi una prenotazione. Specifica questi flag per configurare il nome e la prenotazione del criterio nel pool di nodi.

Se questo comando non funziona, potresti non disporre di una quota GPU H100 sufficiente nel tuo progetto. Assicurati di disporre di una quota sufficiente e riprova a eseguire il comando.

GPUDirect-TCPX

Crea un pool di nodi per le GPU H100:

gcloud container node-pools create NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=LOCATION \
    --machine-type=a3-highgpu-8g \
    --accelerator=type=nvidia-h100-80gb,count=8,gpu-driver-version=LATEST \
    --additional-node-network=network=PROJECT_ID-net-1,subnetwork=PROJECT_ID-sub-1 \
    --additional-node-network=network=PROJECT_ID-net-2,subnetwork=PROJECT_ID-sub-2 \
    --additional-node-network=network=PROJECT_ID-net-3,subnetwork=PROJECT_ID-sub-3 \
    --additional-node-network=network=PROJECT_ID-net-4,subnetwork=PROJECT_ID-sub-4 \
    --enable-gvnic \
    --no-enable-autoupgrade

Sostituisci NODE_POOL_NAME con il nome del pool di nodi.

Se questo comando non funziona, potresti non disporre di una quota GPU H100 sufficiente nel tuo progetto. Assicurati di disporre di quota e riprova a eseguire il comando.

Dopo aver creato il pool di nodi, verifica che ogni nodo abbia le GPU collegate:

  1. Visualizza un elenco dei nodi del cluster:

    kubectl get nodes

  2. Verifica che ogni nodo GPU abbia otto GPU:

    kubectl describe node NODE_NAME

    Sostituisci NODE_NAME con il nome del nodo da descrive.

    L'output è simile al seguente:

    Capacity:
  ...
  nvidia.com/gpu:             8
Allocatable:
  ...
  nvidia.com/gpu:             8

Installare il programma binario GPUDirect e configurare NCCL

Questa sezione mostra come installare il programma binario GPUDirect, in base alle tipo di macchina A3 (GPUDirect-TCPX per A3 High, GPUDirect-TCPXO per A3 Mega) di una specifica versione della libreria NCCL utilizzando un oggetto DaemonSet.

GPUDirect-TCPXO

Questo DaemonSet esegue le seguenti operazioni:

  1. Preinstallazione per configurare le configurazioni relative a GPUDirect-TCPXO.
  2. Installa la libreria NCCL e il file binario GPUDirect-TCPXO sul nodo.
  3. Archivia la libreria e il file binario /home/kubernetes/bin/nvidia/lib64 sulla VM. Per impostazione predefinita, GKE monta questa directory nel percorso/usr/local/nvidia/lib64 nei contenitori GPU che devono utilizzare NCCP e GPUDirect-TCPXO.

Per installare il file binario e configurare NCCL, segui questi passaggi:

  1. Esamina il file manifest del nccl-tcpxo-installer.yaml daemonset in GitHub.

  2. Esegui il deployment del DaemonSet:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpxo/nccl-tcpxo-installer.yaml

    L'avvio del plug-in NCCL richiede circa due minuti.

  3. Verifica lo stato dei pod DaemonSet:

    kubectl get pods -n=kube-system -l=name=nccl-tcpxo-installer

    L'output è simile al seguente:

    # Output
nccl-tcpxo-installer-6c2pv                    1/1     Running   0          2m11s
nccl-tcpxo-installer-qgg82                    1/1     Running   0          2m11s

GPUDirect-TCPX

Questo DaemonSet esegue le seguenti operazioni:

  1. Installa la libreria NCCL e il programma binario GPUDirect-TCPX sul nodo.
  2. Memorizza la libreria e il file binario nella directory /home/kubernetes/bin/nvidia/lib64 sulla VM. Per impostazione predefinita, GKE monta questa directory Percorso /usr/local/nvidia/lib64 nei container GPU che devono essere utilizzati NCCL e GPUDirect-TCPX.

Per installare il file binario e configurare NCCL:

  1. Esamina il nccl-tcpx-installer.yaml manifest del daemonset in GitHub.

  2. Esegui il deployment del DaemonSet:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-tcpx-installer.yaml

    L'avvio del plug-in NCCL richiede circa due minuti.

  3. Verifica lo stato dei pod DaemonSet:

    kubectl get pods -n=kube-system -l=name=nccl-tcpx-installer

    L'output è simile al seguente:

    nccl-tcpx-installer-6c2pv                    1/1     Running   0          2m11s
nccl-tcpx-installer-qgg82                    1/1     Running   0          2m11s

Esegui il deployment del plug-in di iniettore di dispositivi NRI

Questa sezione mostra come installare l'iniettore di dispositivo NRI utilizzando un DaemonSet. Entrambi i tipi di macchine GPU H100 installano lo stesso iniettore di dispositivi NRI . Questo plug-in esegue le seguenti operazioni:

  1. Abilita Node Resource Interface (NRI) sul nodo con GPU H100. NRI è abilitato per impostazione predefinita su GKE 1.29 e versioni successive.
  2. Esegue il deployment di un contenitore del plug-in di iniettore di dispositivi NRI che inserisce i dispositivi GPU nei contenuti specificati dalle annotazioni del pod.

Per installare il plug-in:

  1. Esamina il nri-device-injector.yaml manifest di deployment in GitHub.

  2. Esegui il deployment del DaemonSet:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nri_device_injector/nri-device-injector.yaml

    L'avvio del plug-in NCCL richiede circa due minuti.

  3. Verifica lo stato dei pod DaemonSet:

    kubectl get pods -n=kube-system -l=name=device-injector

    L'output è simile al seguente:

    # Output
device-injector-md6hb                         1/1     Running   0       4h54m
device-injector-vh9bm                         1/1     Running   0       4h54m

esegui il deployment di un carico di lavoro di test

In questa sezione eseguirai il deployment di un carico di lavoro di esempio per verificare che NCCL e GPUDirect-TCPX o GPUDirect-TCPXO funzionano come previsto. Questo carico di lavoro di esempio esegue le seguenti operazioni:

  1. Esegue il deployment di due pod, ciascuno dei quali viene eseguito in un nodo con GPU H100.
  2. Esegue il deployment di un container collaterale in ogni pod per consentire a questi pod di utilizzare GPUDirect-TCPXO o GPUDirect-TCPX.

Per eseguire il deployment di questo carico di lavoro di esempio:

GPUDirect-TCPXO

Questo carico di lavoro include un contenitore sidecar chiamato tcpxo-daemon, che esegue un servizio che consente al pod di utilizzare GPUDirect-TCPXO. Devi aggiungere questo contenitore sidecar a tutti i pod nel tuo ambiente che devono utilizzare GPUDirect-TCPXO. Per uno snippet dei campi obbligatori da aggiungere ai manifest, consulta Aggiungere GPUDirect al manifest.

  1. Esamina il manifest nccl-test-latest.yaml in GitHub.

  2. Esegui il deployment di due pod con il carico di lavoro di test:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpxo/nccl-test-latest.yaml

  3. Dopo il deployment dei pod, attiva un test "all-gather":

    kubectl exec --stdin --tty --container=nccl-test nccl-test-host-1 -- /scripts/allgather.sh nccl-host-1 nccl-host-2

    L'output è simile al seguente:

    #                                                              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
#

GPUDirect-TCPX

Questo carico di lavoro include un contenitore sidecar chiamato tcpx-daemon, che esegue un servizio che consente al pod di utilizzare GPUDirect-TCPX. Devi aggiungere questo container collaterale a qualsiasi pod nel tuo che deve usare GPUDirect-TCPX. Per uno snippet dei campi obbligatori da aggiungere ai manifest, consulta Aggiungere GPUDirect al manifest.

  1. Esamina il file manifest nccl-config.yaml ConfigMap in GitHub. Questo manifest esegue il deployment di script che inizializzano un test NCCL "all-gather" e consente di configurare impostazioni di configurazione specifiche per l'NCCL.

  2. Esamina il manifest del deployment di nccl-test-latest.yaml in GitHub.

  3. Esegui il deployment del ConfigMap e del carico di lavoro di test:

    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.yaml

  4. Esegui i seguenti comandi per attivare un test all-gather NCCL per i nodi:

    kubectl exec \
  --stdin --tty --container=nccl-test nccl-test-host-1 \
  -- /configs/allgather.sh nccl-host-1 nccl-host-2

    L'output è simile al seguente:

    #                                                              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

Utilizza le impostazioni di configurazione NCCL richieste per migliorare le prestazioni

Le seguenti coppie chiave-valore costituiscono la configurazione NCCL richiesta le impostazioni per GPUDirect-TCPX e GPUDirect-TCPXO. Quando esegui il deployment dei carichi di lavoro che utilizzano NCCL, impostali come variabili di ambiente per ottimizzare le prestazioni.

GPUDirect-TCPXO

## required

"LD_LIBRARY_PATH=\"${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64\"",
"NCCL_FASTRAK_CTRL_DEV=eth0",
"NCCL_FASTRAK_IFNAME=eth1,eth2,eth3,eth4,eth5,eth6,eth7,eth8",
"NCCL_SOCKET_IFNAME=eth0",
"NCCL_CROSS_NIC=0",
"NCCL_ALGO=Ring,Tree",
"NCCL_PROTO=Simple",
"NCCL_MIN_NCHANNELS=4",
"NCCL_TUNER_PLUGIN=libnccl-tuner.so",
"NCCL_TUNER_CONFIG_PATH=/usr/local/nvidia/lib64/a3plus_tuner_config.textproto",
"NCCL_SHIMNET_GUEST_CONFIG_CHECKER_CONFIG_FILE=/usr/local/nvidia/lib64/a3plus_guest_config.textproto",
"NCCL_DYNAMIC_CHUNK_SIZE=524288",
"NCCL_P2P_NET_CHUNKSIZE=524288",
"NCCL_P2P_PCI_CHUNKSIZE=524288",
"NCCL_P2P_NVL_CHUNKSIZE=1048576",
"NCCL_FASTRAK_NUM_FLOWS=2",
"NCCL_FASTRAK_USE_SNAP=1",
"NCCL_FASTRAK_PLUGIN_ACCEPT_TIMEOUT_MS=600000",
"NCCL_FASTRAK_ENABLE_CONTROL_CHANNEL=0",
"NCCL_BUFFSIZE=8388608",
"CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7",
"NCCL_NET_GDR_LEVEL=PIX",
"NCCL_FASTRAK_ENABLE_HOTPATH_LOGGING=0",
"NCCL_FASTRAK_USE_LLCM=1",
"NCCL_NVLS_ENABLE=0"
## recommended, to log NCCL errors
"NCCL_DEBUG=WARN",
"NCCL_DEBUG_SUBSYS=INIT,NET,ENV,COLL,GRAPH"

Se vuoi, puoi impostare tutte le configurazioni contemporaneamente seguendo questi passaggi:

  1. Aggiungi la seguente coppia chiave-valore come variabile di ambiente nel manifest del container dei carichi di lavoro:

    NCCL_LIB_DIR="/usr/local/nvidia/lib64"

  2. Assicurati che lo script nccl-env-profile.sh venga eseguito durante il carico di lavoro del container. Ad esempio, puoi farlo nella specifica del pod eseguendo l'override del comando del container in modo da includere quanto segue:

    source ${NCCL_LIB_DIR}/nccl-env-profile.sh

GPUDirect-TCPX

"LD_LIBRARY_PATH=\"${LD_LIBRARY_PATH}:/usr/local/tcpx/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 per consentire ai pod di utilizzare GPUDirect.

A seconda del tipo di GPUDirect:

GPUDirect-TCPXO

  1. Aggiungi le seguenti annotazioni ai metadati del pod. Senza queste annotazioni, hostNetwork:true sarà obbligatorio per il pod e privileged:true per il contenitore tcpxo-daemon. 

    metadata:
  annotations:
    devices.gke.io/container.tcpxo-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
      - path: /dev/dmabuf_import_helper
    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"},
        {"interfaceName":"eth5","network":"vpc5"},
        {"interfaceName":"eth6","network":"vpc6"},
        {"interfaceName":"eth7","network":"vpc7"},
        {"interfaceName":"eth8","network":"vpc8"}
      ]

  2. 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/sys
  - name: aperture-devices
    hostPath:
      path: /dev/aperture_devices

  3. Aggiungi il seguente container al manifest per eseguire il servizio tcpxo-daemon. Sostituisci (TCPXO_DAEMON_IMAGE) con l'immagine più recente us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/tcpgpudmarxd-dev:v1.0.11:

    - name: tcpxo-daemon
  image: TCPXO_DAEMON_IMAGE
  imagePullPolicy: Always
  command: ["/bin/sh", "-c"]
  args:
    - |
      set -ex
      chmod 755 /fts/entrypoint_rxdm_container.sh
      /fts/entrypoint_rxdm_container.sh --num_hops=2 --num_nics=8 --uid= --alsologtostderr
  securityContext:
    capabilities:
      add:
        - NET_ADMIN
        - NET_BIND_SERVICE
  volumeMounts:
    - name: libraries
      mountPath: /usr/local/nvidia
    - name: sys
      mountPath: /hostsysfs
    - name: proc-sys
      mountPath: /hostprocsysfs
  env:
    - name: LD_LIBRARY_PATH
      value: /usr/local/nvidia/lib64

  4. Aggiungi la seguente variabile di ambiente a ogni container GPU:

    env:
- name: LD_LIBRARY_PATH
  value: /usr/local/nvidia/lib64
- name: NCCL_FASTRAK_LLCM_DEVICE_DIRECTORY
  value: /dev/aperture_devices

  5. Aggiungi i seguenti volumeMounts a ogni contenitore GPU. Senza configurazioni di aperture_devices, è richiesto privileged:true per i container GPU:

    volumeMounts:
  - name: aperture-devices
    mountPath: /dev/aperture_devices

  6. Aggiungi variabili di ambiente per configurare le opzioni NCCL. Per maggiori dettagli, vedi Utilizzare le impostazioni di configurazione NCCL consigliate per migliorare le prestazioni.

Una specifica del pod completata ha il seguente aspetto:

apiVersion: v1
kind: Pod
metadata:
name: a3plus-workloads
annotations:
  devices.gke.io/container.tcpxo-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
    - path: /dev/dmabuf_import_helper
  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"},
      {"interfaceName":"eth5","network":"vpc5"},
      {"interfaceName":"eth6","network":"vpc6"},
      {"interfaceName":"eth7","network":"vpc7"},
      {"interfaceName":"eth8","network":"vpc8"}
    ]
...
containers:
  - name: tcpxo-daemon
    image: TCPXO_DAEMON_IMAGE
    imagePullPolicy: Always
    command: ["/bin/sh", "-c"]
    args:
      - |
        set -ex
        chmod 755 /fts/entrypoint_rxdm_container.sh
        /fts/entrypoint_rxdm_container.sh --num_hops=2 --num_nics=8 --uid= --alsologtostderr
    securityContext:
      capabilities:
        add:
          - NET_ADMIN
          - NET_BIND_SERVICE
    volumeMounts:
      - name: libraries
        mountPath: /usr/local/nvidia
      - name: sys
        mountPath: /hostsysfs
      - name: proc-sys
        mountPath: /hostprocsysfs
    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
  - name: main-application-container
...
   env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
      - name: NCCL_FASTRAK_LLCM_DEVICE_DIRECTORY
        value: /dev/aperture_devices
    securityContext:
    volumeMounts:
      - name: aperture-devices
        mountPath: /dev/aperture_devices
    resources:
      limits:
        nvidia.com/gpu: 8
volumes:
  - name: libraries
    hostPath:
      path: /home/kubernetes/bin/nvidia
  - name: sys
    hostPath:
      path: /sys
  - name: proc-sys
    hostPath:
      path: /proc/sys
  - name: aperture-devices
    hostPath:
      path: /dev/aperture_devices

GPUDirect-TCPX

  1. Aggiungi le seguenti annotazioni ai metadati dei pod. Senza queste annotazioni, hostNetwork:true sarà obbligatorio per il pod e privileged:true per il contenitore tcpx-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"},
      ]

  2. 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/sys

  3. Aggiungi il seguente container al manifest per eseguire 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/lib64

  4. Aggiungi i seguenti montaggi dei volumi a tutti i container che richiedono GPU:

    volumeMounts:
- name: tcpx-socket
  mountPath: /tmp
- name: libraries
  mountPath: /usr/local/nvidia/lib64

  5. Aggiungi 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 di questo documento.

  6. Aggiungi la seguente variabile di ambiente a ogni contenitore GPU:

    env:
- name: LD_LIBRARY_PATH
  value: /usr/local/nvidia/lib64

Una specifica del pod completata ha il seguente aspetto:

apiVersion: v1
kind: Pod
metadata:
name: a3-gpu-workloads-example
labels:
  name: a3-gpu-workloads-example
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"}
    ]
spec:
containers:
  - name: tcpx-daemon
    image: us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpx/tcpgpudmarxd-dev:v2.0.11
    imagePullPolicy: Always
    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
        readOnly: true
      - name: tcpx-socket
        mountPath: /run/tcpx
      - name: sys
        mountPath: /hostsysfs
      - name: proc-sys
        mountPath: /hostprocsysfs
    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
  - name: a3-gpu-workloads-example
    ...
    volumeMounts:
      - name: tcpx-socket
        mountPath: /tmp
      - name: libraries
        mountPath: /usr/local/nvidia/lib64
        readOnly: true
    resources:
      limits:
        nvidia.com/gpu: 8
    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
...
volumes:
  - name: libraries
    hostPath:
      path: /home/kubernetes/bin/nvidia/lib64
  - name: tcpx-socket
    emptyDir:
  - name: sys
    hostPath:
      path: /sys
  - name: proc-sys
    hostPath:
      path: /proc/sys

Passaggi successivi