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

Questa pagina mostra come massimizzare la larghezza di banda e il throughput della rete per i workload GPU ad alte prestazioni nei cluster Google Kubernetes Engine (GKE) Autopilot utilizzando GPUDirect-TCPXO, GPUDirect-TCPX, gVNIC e il multi-networking. Se utilizzi cluster Standard, consulta Massimizzare la larghezza di banda di rete della GPU nei cluster in modalità Standard.

Questa pagina è destinata agli ingegneri di machine learning (ML) e agli amministratori delle piattaforme che facilitano i workload ML. Per scoprire di più sui ruoli comuni e sulle attività di esempio a cui facciamo riferimento nei contenuti, consulta Ruoli e attività comuni degli utenti GKE. Trusted Cloud by S3NS

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.

Prima di leggere questa pagina, assicurati di conoscere le tecnologie di rete, come le schede di interfaccia di rete (NIC) e TCP, e le tecnologie di accelerazione come la NVIDIA Collective Communications Library (NCCL).

Informazioni sui Trusted Cloud supercomputer con GPU

Trusted Cloud dispone di supercomputer ottimizzati per l'acceleratore e creati per modelli scalabili e di grandi dimensioni. Queste macchine offrono i seguenti vantaggi:

  • Otto GPU NVIDIA B200, H200 o 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 sui tipi di macchine A3 High), ognuna delle quali supporta una larghezza di banda fino a 200 Gbps per il trasferimento di dati della GPU.

Il tuo 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 è ideale 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, utilizza tutte le seguenti funzionalità:

  • Stack di rete GPUDirect: la serie di macchine A3 supporta tre stack di rete per l'accesso diretto alla memoria remota (RDMA) personalizzato:
    • Sui tipi di macchine A3 High e sulle GPU NVIDIA H100, utilizza GPUDirect-TCPX per ridurre l'overhead necessario per trasferire i payload dei pacchetti da e verso le GPU, il che migliora significativamente il throughput su larga scala rispetto alle GPU che non utilizzano GPUDirect.
    • Sui tipi di macchine A3 Mega e sulle GPU NVIDIA H100 Mega, utilizza GPUDirect-TCPXO, che migliora ulteriormente la comunicazione tra GPU e VM.
    • Sui tipi di macchine A3 Ultra e sulle GPU NVIDIA H200, nonché sui tipi di macchine A4 e sulle GPU NVIDIA B200, utilizza GPUDirect RDMA per eseguire workload di AI distribuiti con ulteriori miglioramenti del throughput. Per iniziare, crea un cluster GKE personalizzato ottimizzato per l'AI.
  • gVNIC: abilita 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 o GPUDirect-TCPXO. Per maggiori dettagli su gVNIC, vedi 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 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 carico di lavoro specifico su server fisicamente vicini per ridurre al minimo la latenza. Per maggiori dettagli, vedi Definisci il posizionamento compatto per i nodi GKE.

Struttura della procedura

Per utilizzare tutte queste funzionalità insieme, procedi nel seguente modo:

  1. Crea Virtual Private Cloud (VPC) e subnet
  2. Crea l'ambiente GKE.
  3. Installa il file binario GPUDirect e il plug-in NCCL
  4. Eseguire il deployment del plug-in di inserimento 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à, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo gcloud components update.
  • Assicurati di disporre di una quota sufficiente per le GPU H100. Per richiedere una quota maggiore, consulta Quote di GPU.

Requisiti

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

  • Il cluster deve utilizzare GKE 1.31.1-gke.1621000 o versioni successive.
  • I nodi GPU devono utilizzare la versione 535 o successive del driver NVIDIA.
  • Devi utilizzare GKE Dataplane V2.
  • Per i workload GPUDirect-TCPX o GPUDirect-TCPXO 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 e GPUDirect-TCPXO non sono supportati con GPU multi-istanza, condivisione della GPU o NVIDIA MPS.
  • Non puoi utilizzare NCCL FastSocket con GPUDirect-TCPX o GPUDirect-TCPXO .
  • 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 o GPUDirect-TCPXO su un singolo nodo.
  • Puoi utilizzare solo i tipi di macchina a3-highgpu-8g e a3-megagpu-8g. Gli altri tipi di macchine A3 non sono supportati.

Crea VPC e subnet

Crea reti VPC separate nel tuo progetto per ogni NIC virtuale 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 macchina A3 High o la scheda GPUDirect-TCPXO per i tipi di macchina A3 Mega, poi completa le seguenti istruzioni:

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

    Sostituisci quanto segue:

    • PROJECT_ID: il tuo ID progetto Trusted Cloud .
    • REGION: la regione Compute Engine per ogni subnet.
    • SUBNET_RANGE: l'intervallo di indirizzi IP di ogni subnet nella notazione CIDR. Questo comando di esempio esegue l'iterazione per otto subnet, quindi devi utilizzare 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 utilizzi 192.168.2.0/24 e 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.

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

    Sostituisci quanto segue:

    • PROJECT_ID: il tuo ID progetto Trusted Cloud .
    • REGION: la regione Compute Engine per ogni subnet.
    • SUBNET_RANGE: l'intervallo di indirizzi IP di ogni subnet nella 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 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 multi-networking (anteprima). Non puoi aggiornare un cluster esistente per utilizzare più reti.

GPUDirect-TCPXO

  1. Scegli una versione di 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 control plane del cluster.
    • PROJECT_ID: il tuo ID progetto Trusted Cloud .

  2. Crea un cluster:

    gcloud beta container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=LOCATION \
    --cluster-version=VERSION \
    --enable-multi-networking \
    --workload-policies=allow-net-admin

    Sostituisci quanto segue:

    • CLUSTER_NAME: il nome del nuovo cluster.
    • VERSION: una versione di GKE che supporta GPUDirect-TCPXO, come descritto in Requisiti.
    • LOCATION: la posizione di Compute Engine per il cluster.

  3. Crea risorse Network e GKENetworkParamSet nel cluster che corrispondono alle reti VPC e alle subnet 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: 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
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc5
spec:
  vpc: PREFIX-net-5
  vpcSubnet: PREFIX-sub-5
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc6
spec:
  vpc: PREFIX-net-6
  vpcSubnet: PREFIX-sub-6
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc7
spec:
  vpc: PREFIX-net-7
  vpcSubnet: PREFIX-sub-7
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: vpc8
spec:
  vpc: PREFIX-net-8
  vpcSubnet: PREFIX-sub-8
  deviceMode: NetDevice
EOF

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

GPUDirect-TCPX

  1. Crea un cluster:

    gcloud beta container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=LOCATION \
    --cluster-version=VERSION \
    --enable-multi-networking \
    --workload-policies=allow-net-admin

    Sostituisci quanto segue:

    • CLUSTER_NAME: il nome del nuovo cluster.
    • VERSION: una versione di GKE che supporta GPUDirect-TCPX, come descritto in Requisiti.
    • LOCATION: la posizione di Compute Engine per il cluster.

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

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

Installa il file binario GPUDirect e configura NCCL

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

GPUDirect-TCPXO

Questo DaemonSet esegue le seguenti operazioni:

  1. Pre-installazione per configurare le impostazioni relative a GPUDirect-TCPXO.
  2. Installa la libreria NCCL e il file binario GPUDirect-TCPXO sul nodo.
  3. Memorizza la libreria e il binario nella directory /home/kubernetes/bin/nvidia/lib64 della VM. Per impostazione predefinita, GKE monta questa directory nel percorso /usr/local/nvidia/lib64 nei container GPU che devono utilizzare NCCL e GPUDirect-TCPXO.

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

  1. Esamina il manifest di DaemonSet in GitHub.nccl-tcpxo-installer-autopilot.yaml

  2. Crea uno spazio dei nomi dedicato:

    kubectl create ns gpudirect-system

  3. Esegui il deployment di DaemonSet:

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

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

GPUDirect-TCPX

Questo DaemonSet esegue le seguenti operazioni:

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

Per installare il file binario e configurare NCCL:

  1. Esamina il manifest di DaemonSet in GitHub.nccl-tcpx-installer-autopilot.yaml

  2. Crea uno spazio dei nomi dedicato:

    kubectl create ns gpudirect-system

  3. Esegui il deployment di DaemonSet:

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

    L'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 l'iniettore di dispositivi NRI utilizzando un DaemonSet. Entrambi i tipi di macchine con GPU H100 installano lo stesso plug-in di inserimento dei dispositivi NRI. Questo plug-in esegue le seguenti operazioni:

  1. Attiva 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 container plug-in di inserimento di dispositivi NRI che inserisce i dispositivi GPU nei container specificati dalle annotazioni del pod.

Per installare il plug-in:

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

  2. Esegui il deployment di DaemonSet:

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

    L'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 o GPUDirect-TCPXO funzionino come previsto. Questo carico di lavoro di esempio 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 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 container sidecar denominato tcpxo-daemon, che esegue un servizio che consente al pod di utilizzare GPUDirect-TCPXO. Devi aggiungere questo container sidecar a tutti i pod nel tuo ambiente che devono utilizzare GPUDirect-TCPXO. Per un snippet dei campi obbligatori da aggiungere ai manifest, vedi Aggiungere GPUDirect al manifest.

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

  2. Esegui il deployment di due pod con il workload di test:

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

  3. Dopo il deployment dei pod, attiva un test di raccolta:

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

  1. Esamina il manifesto ConfigMap nccl-config.yaml su GitHub. Questo manifest esegue il deployment di script che inizializzano un test all-gather NCCL e impostano le impostazioni di configurazione specifiche di NCCL.

  2. Esamina il manifesto di deployment nccl-test-latest-autopilot.yaml in GitHub.

  3. Esegui il deployment di 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-autopilot.yaml

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

Utilizzare le impostazioni di configurazione NCCL richieste per migliorare le prestazioni

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

GPUDirect-TCPXO


"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,LL128",
"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"

(Facoltativo) Puoi impostare tutte le configurazioni contemporaneamente seguendo questi passaggi:

  1. Nel manifest del container del carico di lavoro, aggiungi la seguente coppia chiave-valore come variabile di ambiente:

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

  2. Assicurati che lo script nccl-env-profile.sh venga eseguito all'avvio del container del tuo workload. Ad esempio, puoi farlo nella specifica del pod eseguendo l'override del comando del container per includere quanto segue:

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

Supporto LL128

Il protocollo di comunicazione NVIDIA LL128 (low-latency 128) NCCL può migliorare significativamente le prestazioni per i collettivi di dimensioni piccole e medie. GPUDirect-TCPXO supporta il protocollo LL128.

Per utilizzare LL128, assicurati che il file nccl-tcpxo-installer.yaml nella sezione Installa il binario GPUDirect e configura NCCL utilizzi la seguente versione dell'immagine container o una successiva:

us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx-
dev:v1.0.8-1

Per configurare LL128:

  • Per la us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx- dev:v1.0.8-1 versione del plug-in NCCL, segui questi passaggi:

    1. Nel manifest del workload, imposta la seguente variabile di ambiente:

      NCCL_LIB_DIR="/usr/local/nvidia/lib64

    2. Configura il workload per eseguire lo script nccl-env-profile-ll128.sh all'avvio del container. Nel manifest del workload, imposta il seguente comando:

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

      Lo script nccl-env-profile-ll128.sh ha le seguenti variabili di ambiente:

      NCCL_PROTO=Simple,LL128
NCCL_TUNER_CONFIG_PATH=/usr/local/nvidia/lib64/a3plus_tuner_config_ll128.textproto
NCCL_SHIMNET_GUEST_CONFIG_CHECKER_CONFIG_FILE=/usr/local/nvidia/lib64/a3plus_guest_config_ll128.textproto

  • Per la versione us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx-dev:v1.0.9-1 del plug-in NCCL e successive, LL128 diventa un parametro predefinito, quindi l'utilizzo dello script nccl-env-profile.sh o dello script nccl-env-profile-ll128.sh attiva LL128. Per disattivare LL128:

    1. Nel manifest del workload, imposta la seguente variabile di ambiente:

      NCCL_LIB_DIR="/usr/local/nvidia/lib64

    2. Configura il workload per eseguire lo script nccl-env-profile-ll128.sh all'avvio del container. Nel manifest del workload, imposta il seguente comando:

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

      Lo script nccl-env-profile-simple.sh ha le seguenti variabili di ambiente:

      NCCL_PROTO=Simple
NCCL_TUNER_CONFIG_PATH=/usr/local/nvidia/lib64/a3plus_tuner_config_simple.textproto
NCCL_SHIMNET_GUEST_CONFIG_CHECKER_CONFIG_FILE=/usr/local/nvidia/lib64/a3plus_tuner_config_simple.textproto

GPUDirect-TCPX


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

Raccogliere i log di debug di 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 carichi di lavoro 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 impostare NCCL_DEBUG=WARN per limitare i log ai soli errori.

  • 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_SUBSYS nella documentazione di NCCL per un elenco dei valori accettati.

  • NCCL_DEBUG_FILE (facoltativo): indirizza l'output di logging di debug NCCL a un file che specifichi. 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.%p

    Sostituisci quanto segue:

    • DIRECTORY: la directory in cui vuoi archiviare i file di log.
    • FILE_NAME: il nome dei file di log.

    Il segnaposto %h viene risolto nel nome host del nodo, mentre %p viene 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.

Aggiungere GPUDirect ai manifest

Questa sezione mostra i campi obbligatori che devi aggiungere ai manifest Kubernetes affinché i tuoi pod utilizzino GPUDirect.

Per la modalità Autopilot, devi anche selezionare le GPU appropriate nei manifest dei pod in modo che GKE esegua il provisioning dell'hardware. Per le GPU H100 Mega, utilizza GPUDirect-TCPXO. Per le GPU H100, utilizza GPUDirect-TCPX.

Aggiungi i seguenti selettori di nodi al pod:

nodeSelector:
  cloud.google.com/gke-accelerator: GPU_NAME
  cloud.google.com/gke-gpu-driver-version: latest

Sostituisci GPU_NAME con il nome della GPU. I valori supportati sono i seguenti:

  • nvidia-h100-mega-80gb
  • nvidia-h100-80gb

A seconda del tipo di GPUDirect, procedi nel seguente modo:

GPUDirect-TCPXO

  1. Aggiungi le seguenti annotazioni ai metadati del pod. 

    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'ultima immagine, us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/tcpgpudmarxd-dev:v1.0.17:

    - 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

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

    env:

- name: NCCL_FASTRAK_LLCM_DEVICE_DIRECTORY
  value: /dev/aperture_devices

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

    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
    
  - name: main-application-container
...
   
      - 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. 

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

  4. Aggiungi i seguenti montaggi 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.

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