Maximiza el ancho de banda de red de la GPU con GPUDirect 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 Google Kubernetes Engine (GKE) mediante clústeres estándar con GPUDirect-TCPXO, GPUDirect-TCPX, gVNIC y varias redes.

Esta página está dirigida a ingenieros de aprendizaje automático (AA) y administradores de plataformas que facilitan las cargas de trabajo de AA. Antes de leer esta página, asegúrate de 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.
NIC secundarias (hasta ocho en los tipos de máquinas A3 Mega y hasta cuatro en los tipos de máquinas A3 High), 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 esta página 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:

Pila de redes GPUDirect: La serie de máquinas A3 admite dos pilas de redes para el acceso directo a la memoria (RDMA) personalizado y remoto:
- En los tipos de máquinas A3 High, usa GPUDirect-TCPX para reducir 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.
- En los tipos de máquinas A3 Mega, usa GPUDirect-TCPXO, que mejora aún más la comunicación de la GPU con la VM.
gVNIC: Habilita las funciones de GPUDirect, 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 o GPUDirect-TCPXO. 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. 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 que respaldan los nodos
  4. Controladores de NVIDIA más recientes instalados
Instala el objeto binario GPUDirect-y el complemento NCCL.
Implementa el complemento del inyector de dispositivos NRI
Implementa una carga de trabajo de prueba para verificar la configuración de GPUDirect.

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

Los siguientes requisitos se aplican a GPUDirect-TCPX y GPUDirect-TCPXO, a menos que se indique lo contrario.

GPUDirect-TCPX es compatible con la versión 1.27 o posterior de GKE y requiere lo siguiente:
- Tipo de máquina A3 High (por ejemplo, a3-highgpu-8g)
- 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.
- Para la versión 1.30 de GKE, usa la versión del parche de 1.30.2-gke.1023000 o posterior.
GPUDirect-TCPXO es compatible con la versión 1.28 o posterior de GKE y requiere lo siguiente:
- Tipo de máquina A3 Mega (por ejemplo, a3-megagpu-8g)
- Para la versión 1.28 de GKE, usa la versión del parche de GKE 1.28.9-gke.1250000 o posterior.
- Para la versión 1.29 de GKE, usa la versión del parche de 1.29.4-gke.1542000 o una posterior.
- Para la versión 1.30 de GKE, usa la versión del parche de 1.30.4-gke.1129000 o posterior.

Tus nodos de GPU deben usar la versión 535 o posterior del controlador NVIDIA.
Debes usar GKE Dataplane V2.
El nodo de GKE debe usar una imagen de nodo de Container-Optimized OS (COS). Las imágenes de nodos de Ubuntu y Windows no son compatibles.

Limitaciones

Se aplica la siguiente limitación:

GPUDirect-TCPX y GPUDirect-TCPXO no son compatibles con los clústeres de Autopilot
GPUDirect-TCPX y GPUDirect-TCPXO no son compatibles con GPU de varias instancias, uso compartido de tiempo de GPU ni NVIDIA MPS.
No puedes usar NCCL FastSocket.
Tu carga de trabajo de GKE debe usar todas las GPUs disponibles y todas las NICs secundarias disponibles en un solo nodo. Varios Pods no pueden usar GPUDirect-TCPX ni GPUDirect-TCPXO en un solo nodo.

Crea VPC y subredes

Crea redes de VPC independientes en tu proyecto para cada NIC virtual que agregues a los nodos. Cada red de VPC debe tener una subred y una regla de firewall que permita el tráfico de red interno.

Crea las redes de VPC para GPUDirect en tu proyecto, cada una con una subred y una regla de firewall: Elige la pestaña GPUDirect-TCPX para los tipos de máquinas A3 de alta gama o la pestaña GPUDirect-TCPXO para los tipos de máquinas A3 Mega y, luego, completa las siguientes instrucciones:
GPUDirect-TCPXO
Para maximizar el ancho de banda, te recomendamos que crees ocho redes nuevas.
```
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
```
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 ocho 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
GPUDirect-TCPX
Para maximizar el ancho de banda, te recomendamos que crees cuatro redes nuevas.
```
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 y cuatro NIC adicionales. No puedes actualizar un clúster existente para usar redes múltiples.

GPUDirect-TCPXO

Elige una versión de GKE disponible que admita GPUDirect-TCPXO. Para obtener una lista de las versiones, ejecuta el siguiente comando:
```
gcloud container get-server-config \
  --format="yaml(validMasterVersions)" \
  --zone=ZONE \
  --project=PROJECT_ID
```
Reemplaza lo siguiente:
- ZONE: Es la zona de procesamiento del plano de control del clúster.
- PROJECT_ID: Es el ID de tu proyecto de Google Cloud.
Crea un clúster:
```
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
```
Reemplaza lo siguiente:
- CLUSTER_NAME: Es el nombre del clúster nuevo.
- VERSION: Es una versión de GKE que es compatible con GPUDirect-TCPXO, como se describe en Requisitos.
- REGION: La región de Compute Engine del clúster.
- ZONE: es la zona de procesamiento del clúster.

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

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

Reemplaza NODE_POOL_NAME por el nombre de tu grupo de nodos.

En el ejemplo, el argumento --scopes “https://www.googleapis.com/auth/cloud-platform” establece el alcance de la instancia del nodo en cloud-platform para facilitar las pruebas. Para la producción, te recomendamos que limites el alcance para configurar credenciales más detalladas.

Usa las marcas --placement-policy, --reservation-affinity y --reservation si usas una reserva. Especifica estas marcas para configurar el nombre y la reserva de la política en el 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 suficiente 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 a este:

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

GPUDirect-TCPX

Crea un clúster estándar:
```
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: La región de Compute Engine del clúster.
- VERSION: Es la versión de GKE que se usa para el clúster. Usa una versión compatible, como se describe en la sección Requisitos.

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 a este:

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

Instala el objeto binario de GPUDirect y configura NCCL

En esta sección, se muestra cómo instalar el objeto binario de GPUDirect, según tu tipo de máquina A3 (GPUDirect-TCPX para A3 High, GPUDirect-TCPXO para A3 Mega) y una versión específica de la biblioteca NCCL con un DaemonSet.

GPUDirect-TCPXO

Revisa el manifiesto de nccl-tcpxo-installer.yaml Daemonset en GitHub. Este DaemonSet hace lo siguiente:
1. Configuración previa a la instalación para configurar parámetros relacionados con GPUDirect-TCPXO.
2. Instala la biblioteca NCCL y el objeto binario GPUDirect-TCPXO en el nodo.
3. 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-TCPXO.

Implementa el DaemonSet:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpxo/nccl-tcpxo-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-tcpxo-installer

El resultado es similar a este:

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

GPUDirect-TCPX

Revisa el manifiesto de nccl-tcpx-installer.yaml Daemonset en GitHub. Este DaemonSet hace lo siguiente:
1. Instala la biblioteca NCCL y el objeto binario GPUDirect-TCPX en el nodo.
2. 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 a este:

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

Implementa el complemento del inyector de dispositivos NRI

En esta sección, se muestra cómo instalar el inyector de dispositivos NRI con un DaemonSet. Ambos tipos de máquinas H100(GPUDirect-TCPX para A3 High y GPUDirect-TCPXO para A3 Mega) instalan el mismo complemento del inyector de dispositivos NRI.

Revisa el manifiesto de implementación de nri-device-injector.yaml en GitHub. Este DaemonSet hace lo siguiente:
1. Habilita la interfaz de recursos de nodos (NRI) en el nodo que tiene GPUs H100.
2. Implementa un contenedor de complementos del inyector de dispositivos NRI que inyecta dispositivos de GPU en contenedores especificados por anotaciones de pod.

Implementa el DaemonSet:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nri_device_injector/nri-device-injector.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=device-injector

El resultado es similar al siguiente:

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

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 o GPUDirect-TCPXO funcionen como se espera.

GPUDirect-TCPXO

Esta carga de trabajo incluye un contenedor sidecar llamado tcpxo-daemon, que ejecuta un servicio que permite al Pod usar GPUDirect-TCPXO. Debes agregar este contenedor sidecar a cualquier Pod de tu propio entorno que necesite usar GPUDirect-TCPXO. Para obtener un fragmento de los campos obligatorios para agregar a tus manifiestos, consulta Agrega GPUDirect a tu manifiesto.

Revisa el manifiesto nccl-test-latest.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 sidecar llamado tcpxo-daemon en cada Pod para permitir que esos Pods usen GPUDirect-TCPXO.

Implementa dos Pods con la carga de trabajo de prueba:

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

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

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

El resultado es similar a este:

#                                                              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   4654.5    0.23    0.21      0   3890.9    0.27    0.25      0
    2097152         32768     float    none      -1   4117.2    0.51    0.48      0   5153.5    0.41    0.38      0
    4194304         65536     float    none      -1   6417.4    0.65    0.61      0   7295.5    0.57    0.54      0
    8388608        131072     float    none      -1   7872.1    1.07    1.00      0   6451.4    1.30    1.22      0
    16777216        262144     float    none      -1   6990.7    2.40    2.25      0   5609.3    2.99    2.80      0
    33554432        524288     float    none      -1   8254.0    4.07    3.81      0   7415.1    4.53    4.24      0
    67108864       1048576     float    none      -1   5546.3   12.10   11.34      0   6484.0   10.35    9.70      0
  134217728       2097152     float    none      -1   6507.3   20.63   19.34      0   6015.4   22.31   20.92      0
  268435456       4194304     float    none      -1   6744.1   39.80   37.32      0   7023.1   38.22   35.83      0
  536870912       8388608     float    none      -1   8939.8   60.05   56.30      0    11706   45.86   43.00      0
  1073741824      16777216     float    none      -1   8241.7  130.28  122.14      0   8375.2  128.20  120.19      0
# Out of bounds values : 0 OK
# Avg bus bandwidth    : 22.449

GPUDirect-TCPX

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 a tu manifiesto.

Revisa el manifiesto de ConfigMap nccl-config.yaml en GitHub. Este manifiesto implementa secuencias de comandos que inicializan una prueba NCCL all-gather y configura parámetros de configuración específicos de NCCL.
Revisa el manifiesto de implementación de nccl-test-latest.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.

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

Usa la configuración de NCCL necesaria para mejorar el rendimiento

Los siguientes pares clave-valor son los parámetros de configuración de NCCL necesarios para GPUDirect-TCPX y GPUDirect-TCPXO. Cuando implementes tus cargas de trabajo que usan NCCL, configúralas como variables de entorno para optimizar el rendimiento.

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"

De manera opcional, puedes configurar todos los parámetros de configuración a la vez siguiendo estos pasos:

Agrega el siguiente par clave-valor como una variable de entorno en el manifiesto de tu contenedor de carga de trabajo:
```
NCCL_LIB_DIR="/usr/local/nvidia/lib64"
```
Asegúrate de que se ejecute la secuencia de comandos nccl-env-profile.sh cuando se inicie el contenedor de carga de trabajo. Por ejemplo, puedes hacerlo en la especificación de tu Pod a través de la anulación del comando del contenedor para incluir lo siguiente:
```
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"

Agrega GPUDirect a tus manifiestos

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

GPUDirect-TCPXO

Agrega las siguientes anotaciones a los metadatos del Pod. Sin estas anotaciones, se requerirá hostNetwork:true para el Pod y privileged:true para el contenedor 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"}
      ]

Agrega los siguientes campos a la especificación 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

Agrega el siguiente contenedor al manifiesto para ejecutar el servicio tcpxo-daemon. Reemplaza (TCPXO_DAEMON_IMAGE) por la imagen más reciente 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

Agrega la siguiente variable de entorno a cada contenedor de GPU:

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

Agrega los siguientes volumeMounts a cada contenedor de GPU. Sin configuraciones de aperture_devices, se requiere privileged:true para los contenedores de GPU:
```
volumeMounts:
  - name: aperture-devices
    mountPath: /dev/aperture_devices
```
Agrega variables de entorno para configurar las opciones de NCCL. Para obtener más información, consulta Usa la configuración recomendada de NCCL para mejorar el rendimiento.

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

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

Agrega las siguientes anotaciones a los metadatos del Pod. Sin estas anotaciones, se requerirá hostNetwork:true para el Pod y privileged:true para el contenedor 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"},
      ]

Agrega los siguientes campos a la especificación 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

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

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 GPUs. 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 detalles, consulta la sección Usa la configuración recomendada de NCCL para mejorar el rendimiento en esta página.

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

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

¿Qué sigue?

Obtén información sobre las prácticas recomendadas para las herramientas de redes de GKE.
Obtén más información sobre la familia de tecnologías de Nvidia GPUDirect para el movimiento y el acceso de datos en las GPUs de Nvidia.
Obtén información sobre la disponibilidad actual de la versión de GPU y cómo solicitar GPUs en GKE.