Se usó la API de Cloud Translation para traducir esta página.

Maximiza el ancho de banda de red de la GPU con GPUDirect-TCPX y redes múltiples

Estándar

En esta página, se muestra cómo maximizar el ancho de banda de la red y la capacidad de procesamiento para las cargas de trabajo de GPU de alto rendimiento en clústeres de Google Kubernetes Engine (GKE) en modo estándar. Esta página está dirigida a ingenieros de aprendizaje automático (AA) y administradores de plataformas que facilitan las cargas de trabajo de AA. Ya debes estar familiarizado con las tecnologías de redes, como las tarjetas de interfaz de red (NIC) y TCP, y las tecnologías de aceleración como la Biblioteca de comunicaciones colectivas de NVIDIA (NCCL).

Las aplicaciones de inteligencia artificial (IA), AA y computación de alto rendimiento (HPC) requieren una aceleración potente para optimizar el rendimiento reduciendo los tiempos de finalización de los trabajos. Por ejemplo, los modelos de AA que se enfocan en la IA conversacional y en la generación de imágenes requieren alta escalabilidad y potencia de procesamiento.

Acerca de las supercomputadoras de GPU de Google Cloud

Google Cloud tiene supercomputadoras optimizadas para aceleradores que están diseñadas para modelos masivos y escalables. Estas máquinas tienen los siguientes beneficios:

Ocho GPU NVIDIA H100 por máquina.
Hasta 200 Gbps de ancho de banda en la NIC principal.
Hasta cuatro NIC secundarias, cada una de las cuales admite hasta 200 Gbps de ancho de banda para la transferencia de datos de GPU.

Para obtener una lista completa de los beneficios, consulta Serie de máquinas A3 en la documentación de Compute Engine.

Tu carga de trabajo de GKE debe usar todas las GPU disponibles y todas las NIC secundarias disponibles en un solo nodo y usar una parte significativa del ancho de banda disponible. La solución que se describe en este documento es ideal para cargas de trabajo que requieren alto rendimiento, alta capacidad de procesamiento y baja latencia.

Funciones y capacidades obligatorias para maximizar el ancho de banda

Para maximizar el ancho de banda de tu red en los nodos de GPU de supercomputadora, usa todas las siguientes características:

GPUDirect-TCPX: Reduce la sobrecarga necesaria para transferir cargas útiles de paquetes desde y hacia las GPU, lo que mejora significativamente la capacidad de procesamiento a gran escala en comparación con las GPU que no usan GPUDirect-TCPX.
gVNIC: Habilita las funciones de GPUDirect-TCPX, como la división del encabezado del paquete, la dirección del flujo y la administración del búfer. Se requiere gVNIC para usar GPUDirect-TCPX. Para obtener detalles sobre gVNIC, consulta Aumenta la velocidad del tráfico de red para los nodos de GPU.
Varias redes : Agrega NICs secundarias a la máquina optimizada para aceleradores. Para las máquinas A3, agrega cuatro NIC adicionales. Cada NIC está asociada con una subred independiente en su propia VPC para evitar conflictos. Para obtener detalles sobre la compatibilidad con varias redes, consulta Configura la compatibilidad con varias redes para Pods.
Políticas de posición: Usa una política de posición de recursos para colocar todos los nodos de GPU de una carga de trabajo específica en servidores que se encuentran físicamente cerca para minimizar la latencia. Si deseas obtener más detalles, consulta Define la posición compacta para los nodos de GKE.

Esquema del procedimiento

Para usar todas estas funciones juntas, harás lo siguiente:

Crea subredes y nubes privadas virtuales (VPC).
Crea el entorno de GKE:
1. Crea un clúster con varias redes habilitadas.
2. Crea un grupo de nodos con las siguientes características:
  1. gVNIC habilitada
  2. Subredes de varias redes especificadas para cada NIC secundaria
  3. Serie de máquinas A3 con GPU H100 (cuatro NIC secundarias y ocho GPU) que respaldan los nodos
  4. Controladores de NVIDIA más recientes instalados
Instala el objeto binario GPUDirect-TCPX y el complemento NCCL.
Implementa una carga de trabajo de prueba para verificar la configuración de GPUDirect-TCPX.

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

Habilita la API de Google Kubernetes Engine.

Habilitar la API de Google Kubernetes Engine

Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta gcloud components update para obtener la versión más reciente.
Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar las propiedades compute/region y compute/zone. Cuando configuras las ubicaciones predeterminadas, puedes evitar errores en la gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location.

Asegúrate de tener suficiente cuota para las GPU H100. Para solicitar más cuota, consulta Cuotas de GPU.

Requisitos

GPUDirect-TCPX es compatible con la versión 1.27 o posterior de GKE y requiere lo siguiente:
- Para la versión 1.27 de GKE, usa la versión del parche de GKE 1.27.7-gke.1121000 o posterior.
- Para la versión 1.28 de GKE, usa la versión del parche de GKE 1.28.8-gke.1095000 o posterior.
- Para la versión 1.29 de GKE, usa la versión del parche de GKE 1.29.3-gke.1093000 o una posterior.
Tus nodos de GPU deben usar la versión 535 o posterior del controlador NVIDIA.
Debes usar GKE Dataplane V2.

Limitaciones

Se aplica la siguiente limitación:

No puedes usar GPUDirect-TCPX en clústeres en modo Autopilot
Solo puedes usar GPUDirect-TCPX en la versión 1.27 o posterior de GKE y usar las siguientes versiones de parche:
- Para la versión 1.27 de GKE, usa la versión del parche de GKE 1.27.7-gke.1121000 o posterior.
- Para la versión 1.28 de GKE, usa la versión del parche de GKE 1.28.8-gke.1095000 o posterior.
- Para la versión 1.29 de GKE, usa la versión del parche de GKE 1.29.3-gke.1093000 o una posterior.
No puedes usar GPUDirect-TCPX con GPU de instancias múltiples o uso compartido de tiempo de GPU.
No puedes usar NCCL FastSocket.
Tu entorno debe admitir la configuración hostNetwork: true en la especificación del Pod.

Crea VPC y subredes

Crea redes de VPC independientes en tu proyecto para cada NIC virtual que agregues a los nodos. Cada VPC debe tener una subred y una regla de firewall que permita el tráfico de red interno. Para maximizar el ancho de banda, te recomendamos que crees cuatro redes nuevas.

Crea las redes de VPC para GPUDirect-TCPX en tu proyecto, cada una con una subred y una regla de firewall:
```
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
```
Reemplaza lo siguiente:
- PROJECT_ID: tu ID del proyecto de Google Cloud.
- REGION: Es la región de Compute Engine para cada subred.
- SUBNET_RANGE: Es el rango de direcciones IP de cada subred en notación CIDR. En este comando de ejemplo, se itera para cuatro subredes, por lo que debes usar una variable para cambiar la dirección IP para cada subred. Por ejemplo, especifica 192.168.$N.0/24 para que la primera subred use 192.168.1.0/24, la segunda subred use 192.168.2.0/24, etcétera.
- SOURCE_RANGE: El rango de direcciones IP de origen para que la regla de firewall permita el tráfico de entrada, en notación CIDR. Por ejemplo, 192.168.0.0/16
Verifica que se hayan creado las redes:
```
gcloud compute networks list
```

Crea el entorno de GKE

Crea un nuevo clúster de GKE que use varias redes (vista previa) y crea un grupo de nodos de GPU que use máquinas A3 con GPU H100 conectadas y cuatro NIC adicionales. No puedes actualizar un clúster existente para usar redes múltiples.

Crea un clúster:
```
gcloud container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --cluster-version=VERSION \
    --enable-dataplane-v2 --enable-ip-alias \
    --enable-multi-networking \
    --no-enable-autoupgrade \
```
Reemplaza lo siguiente:
- CLUSTER_NAME: es el nombre del clúster nuevo.
- LOCATION: Es la región de Compute Engine del clúster.
- VERSION: Es la versión de GKE que se usa para el clúster. Debe ser una versión compatible, como se describe en la sección Requisitos.
Este comando también especifica de forma explícita la dirección IP secundaria para los Pods y objetos Service del clúster que creaste en la sección anterior.

Crea los recursos de red y GKENetworkParamSet en el clúster que corresponden a las redes de VPC y las subredes que creaste:

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

Estos recursos le indican a GKE que configure las NIC para el tráfico de GPU en modo de transferencia. GKE no aplica la programación de redes incorporadas que usan eBPF a este tráfico.

Crea un grupo de nodos para las 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 \

Reemplaza NODE_POOL_NAME por el nombre del grupo de nodos.

Si este comando falla, es posible que no tengas suficiente cuota de GPU H100 en tu proyecto. Asegúrate de tener una cuota y vuelve a ejecutar el comando.

Obtén una lista de nodos en el clúster:
```
kubectl get nodes
```

Verifica que cada nodo de GPU tenga ocho GPU:

kubectl describe node NODE_NAME

El resultado es similar al siguiente:

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

Instala GPUDirect-TCPX y configura NCCL

En esta sección, se muestra cómo instalar el objeto binario GPUDirect-TCPX y un NCCL específico con un DaemonSet.

Revisa el manifiesto de DaemonSet:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: nccl-tcpx-installer
  namespace: kube-system
  labels:
    k8s-app: nccl-tcpx-installer
spec:
  selector:
    matchLabels:
      k8s-app: nccl-tcpx-installer
  updateStrategy:
    type: RollingUpdate
  template:
    metadata:
      labels:
        name: nccl-tcpx-installer
        k8s-app: nccl-tcpx-installer
    spec:
      priorityClassName: system-node-critical
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
              - matchExpressions:
                  - key: cloud.google.com/gke-accelerator
                    operator: In
                    values:
                      - nvidia-h100-80gb
      tolerations:
        - operator: "Exists"
      hostNetwork: true
      hostPID: true
      volumes:
        - name: var-lib
          hostPath:
            path: /var/lib
        - name: tcpx
          hostPath:
            path: /var/lib/tcpx
        - name: library-dir-host
          hostPath:
            path: /home/kubernetes/bin
      initContainers:
        - image: us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpx/nccl-plugin-gpudirecttcpx-dev:v3.1.9
          name: nccl-tcpx-installer
          resources:
            requests:
              cpu: 150m
          securityContext:
            privileged: true
          volumeMounts:
            - name: var-lib
              mountPath: /var/lib
            - name: library-dir-host
              mountPath: /usr/local
          command: ["/bin/sh", "-c"]
          args:
            - |
              set -ex
              /scripts/container_entry.sh install --install-nccl
              mkdir -p /usr/local/nvidia/lib64
              cp -r /var/lib/tcpx/lib64/. /usr/local/nvidia/lib64
              echo "installation finishes"
      containers:
        - image: "gke.gcr.io/pause:3.8"
          name: pause

Este DaemonSet hace lo siguiente:

Instala una biblioteca NCCL y el objeto binario GPUDirect-TCPX en el nodo.
Almacena la biblioteca y el objeto binario en el directorio /home/kubernetes/bin/nvidia/lib64 en la VM. De forma predeterminada, GKE activa este directorio en la ruta /usr/local/nvidia/lib64 en los contenedores de GPU que necesitan usar NCCL y GPUDirect-TCPX.

Implementa el DaemonSet:

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

El complemento NCCL tarda alrededor de dos minutos en comenzar a ejecutarse.

Verifica el estado de los Pods de DaemonSet:

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

El resultado es similar al siguiente:

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

Implementa una carga de trabajo de prueba

En esta sección, implementarás una carga de trabajo de muestra para verificar que NCCL y GPUDirect-TCPX funcionen como se espera. Esta carga de trabajo incluye un contenedor de sidecar llamado tcpx-daemon, que ejecuta un servicio que permite al Pod usar GPUDirect-TCPX. Debes agregar este contenedor de sidecar a cualquier Pod de tu propio entorno que necesite usar GPUDirect-TCPX. Para obtener un fragmento de los campos obligatorios para agregar a tus manifiestos, consulta Agrega GPUDirect-TCPX a tu manifiesto en este documento.

Revisa el manifiesto de ConfigMap nccl-config.yaml en GitHub. En este manifiesto, se implementan scrips que inicializan una prueba de recopilación de NCCL y se establecen archivos de configuración específicos de NCCL.
Revisa el manifiesto nccl-test.yaml en GitHub. Este manifiesto hace lo siguiente:
1. Implementa dos Pods, cada uno de los cuales se ejecuta en un nodo que tiene GPU H100.
2. Implementa un contenedor de sidecar llamado tcpx-daemon en cada Pod para permitir que esos Pods usen GPUDirect-TCPX.
Precaución: Los Pods GPUDirect-TCPX requieren acceso a la red host (hostNetwork: true). El servicio tcpx-daemon debe ejecutarse como un contenedor con privilegios.

Implementa el ConfigMap y la carga de trabajo de prueba:

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

Ejecuta los siguientes comandos para activar una prueba de recopilación completa de NCCL para los nodos:

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

El resultado es similar al siguiente:

#                                                              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

Configuraciones recomendadas de NCCL

Los siguientes pares clave-valor son la configuración de NCCL recomendada para TCPDirect-TCPX. Cuando implementes tus cargas de trabajo que usan NCCL, deberás configurarlas como variables de entorno para optimizar el rendimiento.

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

Agrega GPUDirect-TCPX a tus manifiestos

En esta sección, se proporcionan los campos obligatorios que debes agregar a los manifiestos de Kubernetes para que los Pods usen GPUDirect-TCPX.

Agrega los siguientes campos a la especificación del Pod:

spec:
  hostNetwork: true
  dnsPolicy: ClusterFirstWithHostNet
  volumes:
  - name: libraries
    hostPath:
      path: /home/kubernetes/bin/nvidia/lib64
  - name: tcpx-socket
    hostPath:
      path: /run/tcpx

Agrega el siguiente contenedor al manifiesto para ejecutar el servicio 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:
    privileged: true
  volumeMounts:
    - name: libraries
      mountPath: /usr/local/nvidia/lib64
    - name: tcpx-socket
      mountPath: /run/tcpx
  env:
    - name: LD_LIBRARY_PATH
      value: /usr/local/nvidia/lib64

Agrega las siguientes activaciones de volumen a cualquier contenedor que solicite GPU:
```
volumeMounts:
- name: tcpx-socket
  mountPath: /tmp
- name: libraries
  mountPath: /usr/local/nvidia/lib64
```
Nota: La ruta de acceso predeterminada de tcpx-socket es /tmp para los contenedores que solicitan GPU. Si configuras la variable de entorno NCCL_GPUDIRECTTCPX_UNIX_CLIENT_PREFIX en un valor distinto de /tmp, GKE activa el volumen tcpx-socket en ese mountPath.
.
Agrega la siguiente variable de entorno a cada contenedor de GPU:
```
env:
- name: LD_LIBRARY_PATH
  value: /usr/local/nvidia/lib64
```
Agrega variables de entorno para configurar las opciones de NCCL. Para obtener más información, consulta la sección Configuraciones recomendadas de NCCL en este documento.

Una especificación de Pod completa se ve de la siguiente manera:

apiVersion: v1
kind: Pod
metadata:
  name: example-pod
  labels:
    name: example-pod
spec:
  hostNetwork: true
  dnsPolicy: ClusterFirstWithHostNet
  containers:
  - 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:
      privileged: true
    volumeMounts:
      - name: libraries
        mountPath: /usr/local/nvidia/lib64
      - name: tcpx-socket
        mountPath: /run/tcpx
    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
    - name: nccl-test
      image: us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpx/nccl-plugin-gpudirecttcpx:v3.1.2
      imagePullPolicy: Always
      command:
        - /bin/sh
        - -c
        - "while true; do echo hello; sleep 1; done"
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      volumeMounts:
        - name: tcpx-socket
          mountPath: /run/tcpx
        - name: libraries
          mountPath: /usr/local/nvidia/lib64
      resources:
        limits:
          nvidia.com/gpu: 8
  volumes:
    - name: libraries
      hostPath:
        path: /home/kubernetes/bin/nvidia/lib64
    - name: tcpx-socket
      hostPath:
        path: /run/tcpx