Massimizzare la larghezza di banda della rete della GPU con GPUDirect e multi-networking

Questa pagina mostra come massimizzare la larghezza di banda e il throughput della rete per i carichi di lavoro GPU ad alte prestazioni in Google Kubernetes Engine (GKE) utilizzando i cluster standard con GPUDirect-TCPXO, GPUDirect-TCPX, gVNIC e la multi-networking.

Questa pagina è Destinato agli ingegneri del machine learning (ML) e amministratori di piattaforme che facilitano i carichi di lavoro di ML. Prima di leggere questa pagina, assicurati di conoscere le tecnologie di networking, come le schede di interfaccia di rete (NIC) e il TCP, e le tecnologie di accelerazione come la 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 che si concentrano dell'AI conversazionale e la generazione di immagini richiede scalabilità e computing elevati corrente.

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 sui tipi di macchine A3 Mega e fino a quattro tipi di macchine A3 High), ciascuna che supporta una larghezza di banda fino a 200 Gbit/s per Trasferimento dei dati 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 questa pagina è ideale per i carichi di lavoro che richiedono prestazioni elevate, throughput elevato 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 macchine A3 High, utilizza GPUDirect-TCPX per ridurre il sovraccarico necessario per trasferire i payload dei pacchetti alle e dalle GPU, il che migliora notevolmente il throughput su larga scala rispetto alle GPU che non utilizzano GPUDirect.
    • Sui tipi di macchine A3 Mega, utilizza GPUDirect-TCPXO, che migliora ulteriormente la comunicazione tra GPU e 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.
  • Multi-networking: aggiungi NIC secondarie alla macchina ottimizzata per l'acceleratore. Ogni NIC è associata a una sottorete distinta 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, in modo da 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:
    1. Crea un cluster con più reti abilitate
    2. Crea un pool di nodi con le caratteristiche seguenti:
      1. gVNIC attivato
      2. Subnet a più reti specificate per ogni NIC secondario
      3. Serie di macchine A3 con GPU H100 che supportano i nodi
      4. Ultimi driver NVIDIA installati
  3. Installa il programma binario GPUDirect e il plug-in NCCL
  4. Implementa il plug-in di injector dei dispositivi 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à, install e poi inizializzare con gcloud CLI. Se hai già installato gcloud CLI, scarica la versione più recente eseguendo gcloud components update.
  • Assicurati di avere 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 che GPUDirect-TCPXO salvo diversa indicazione.

  • GPUDirect-TCPX è supportato in GKE 1.27 o versioni successive e richiede:
    • Tipo di macchina A3 High (ad esempio a3-highgpu-8g).
    • Per la versione 1.27 di GKE, utilizza la versione della patch GKE 1.27.7-gke.1121000 o successiva.
    • Per la versione 1.28 di GKE, utilizza la patch GKE 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.
    • Per la versione 1.30 di GKE, utilizza la versione della patch GKE 1.30.2-gke.1023000 o successive.
  • GPUDirect-TCPXO è supportato in GKE 1.28 o versioni successive e richiede:
    • Tipo di macchina A3 Mega (ad esempio, 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.
    • Per la versione 1.30 di GKE, utilizza la versione della patch GKE 1.30.4-gke.1129000 o successiva.
  • I nodi GPU devono utilizzare il driver NVIDIA 535 o versioni successive.
  • Devi utilizzare GKE Dataplane V2.
  • Il nodo GKE deve utilizzare un nodo Container-Optimized OS (COS) dell'immagine. Le immagini dei nodi Ubuntu e Windows non sono supportate.

Limitazioni

Si applicano le seguenti limitazioni:

  • GPUDirect-TCPX e GPUDirect-TCPXO non sono supportati nei cluster Autopilot
  • 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 disponibili le NIC secondarie disponibili su un singolo nodo. Più pod non possono utilizzare GPUDirect-TCPX o GPUDirect-TCPXO su un singolo nodo.

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: il tuo ID progetto Google Cloud.
    • REGION: la regione di Compute Engine per ogni una subnet.
    • SUBNET_RANGE: l'intervallo di indirizzi IP di ogni subnet in notazione CIDR. Questo comando di esempio esegue l'iterazione per otto subnet, quindi dovresti 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 utilizza 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.

    GPUDirect-TCPX

    Per massimizzare 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: il tuo ID progetto Google Cloud.
    • REGION: la regione di Compute Engine per ogni una 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 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 la regola firewall che consente 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 utilizzi la multi-networking (anteprima) e un pool di nodi GPU che utilizzi macchine A3 con GPU H100 e NIC aggiuntive. Non puoi aggiornare un cluster esistente per utilizzare il networking multiplo.

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)" \
  --zone=ZONE \
  --project=PROJECT_ID

    Sostituisci quanto segue:

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

  2. Crea un cluster:

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

    Sostituisci quanto segue:

    • CLUSTER_NAME: il nome del nuovo cluster.
    • VERSION: una versione di GKE che supporta GPUDirect-TCPXO, come descritto nella sezione Requisiti.
    • REGION: la regione Compute Engine per il cluster.
    • ZONE: la zona di computing per il cluster.

  3. Creare risorse Network e GKENetworkParamSet nel cluster che corrispondono alle reti e alle subnet VPC 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.

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

    Usa --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 va a buon fine, la quota GPU H100 potrebbe non essere sufficiente nel tuo progetto. Assicurati di disporre di una quota sufficiente e riprova a eseguire il comando.

  5. Visualizza un elenco dei nodi del cluster:

    kubectl get nodes

  6. Verifica che ogni nodo GPU abbia otto GPU:

    kubectl describe node NODE_NAME

    L'output è simile al seguente:

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

GPUDirect-TCPX

  1. Crea un cluster standard:

    gcloud container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --cluster-version=VERSION \
    --enable-dataplane-v2 --enable-ip-alias \
    --enable-multi-networking \
    --no-enable-autoupgrade \

    Sostituisci quanto segue:

    • CLUSTER_NAME: il nome del nuovo cluster.
    • LOCATION: la regione di Compute Engine. per il cluster
    • VERSION: la versione GKE dell'agente in un cluster Kubernetes. Utilizza una versione supportata come descritto nella sezione Requisiti.

  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 a questo traffico la programmazione di rete integrata che utilizza eBPF.

  3. 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 va a buon fine, la quota GPU H100 potrebbe non essere sufficiente nel tuo progetto. Assicurati di disporre di quota e riprova a eseguire il comando.

  4. Ottieni un elenco di nodi nel cluster:

    kubectl get nodes

  5. Verifica che ogni nodo GPU abbia otto GPU:

    kubectl describe node NODE_NAME

    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

  1. Esamina il file manifest del nccl-tcpxo-installer.yaml daemonset in GitHub. Questo DaemonSet esegue le seguenti operazioni:

    1. Preinstallazione per configurare le configurazioni correlate a GPUDirect-TCPXO.
    2. Installa la libreria NCCL e il programma binario GPUDirect-TCPXO sul nodo.
    3. Archivia la libreria e il programma 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.

  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'esecuzione 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

  1. Esamina il file manifest del nccl-tcpx-installer.yaml daemonset in GitHub. 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.

  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'esecuzione 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 H100 (GPUDirect-TCPX per A3 High, GPUDirect-TCPXO per A3 Mega) installano lo stesso plug-in di iniezione del dispositivo NRI.

  1. Esamina il nri-device-injector.yaml manifest di deployment in GitHub. Questo DaemonSet esegue le seguenti operazioni:

    1. Attiva l'interfaccia di risorse del nodo (NRI) sul nodo con GPU H100. NRI è abilitato per impostazione predefinita su GKE 1.29 e versioni successive.
    2. Esegue il deployment di un container di plug-in di iniettori di dispositivi NRI che inserisce i dispositivi GPU nei container specificati dalle annotazioni dei pod.

  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'esecuzione 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.

GPUDirect-TCPXO

Questo carico di lavoro include un container collaterale denominato 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 del modulo campi da aggiungere ai manifest, consulta Aggiungi GPUDirect al manifest.

  1. Esamina il manifest di nccl-test-latest.yaml in GitHub. Il file manifest esegue le seguenti operazioni:

    1. Esegue il deployment di due pod, ognuno dei quali viene eseguito in un nodo con GPU H100.
    2. Esegue il deployment di un container collaterale denominato tcpxo-daemon in ogni pod per consentire I pod usano GPUDirect-TCPXO.

  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. Esegui i seguenti comandi per attivare un test all-gather NCCL per i due nodi:

    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 del modulo campi da aggiungere ai manifest, consulta Aggiungi GPUDirect al manifest.

  1. Esamina il file manifest ConfigMap di nccl-config.yaml 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. Questo manifest esegue le seguenti operazioni:

    1. Esegue il deployment di due pod, ognuno dei quali viene eseguito in un nodo con GPU H100.
    2. Esegue il deployment di un container sidecar denominato tcpx-daemon in ogni pod per consentire a questi pod di utilizzare GPUDirect-TCPX.

  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 questi comandi per attivare un test NCCL "all-gather" per il 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. Durante il deployment dei carichi di lavoro che utilizzano l'NCCL, impostale 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"

Facoltativamente, puoi impostare tutte le configurazioni contemporaneamente seguendo questa procedura:

  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 overriding il comando del contenitore in modo da includere quanto segue:

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

GPUDirect-TCPX

## required
"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"
"NCCL_NVLS_ENABLE=0"

Aggiungere GPUDirect ai manifest

Questa sezione mostra i campi obbligatori che devi aggiungere ai manifest Kubernetes per consentire ai pod di utilizzare GPUDirect.

GPUDirect-TCPXO

  1. Aggiungi le seguenti annotazioni ai metadati dei pod. Senza queste annotazioni, sarà necessario hostNetwork:true per il pod e privileged:true per il container 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 contenitore 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 volumiMount a ogni container GPU. Senza configurazioni aperture_devices, privileged:true è obbligatorio 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 del pod. Senza queste annotazioni, sarà necessario hostNetwork:true per il pod e privileged:true per il container 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 contenitore 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/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 la seguente variabile di ambiente a ogni contenitore GPU:

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

  6. Aggiungi variabili di ambiente per configurare le opzioni NCCL. Per maggiori dettagli, consulta Utilizza le impostazioni di configurazione NCCL consigliate per migliorare le prestazioni in questa pagina.

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