En esta página se explica cómo maximizar el ancho de banda y el rendimiento de la red para cargas de trabajo de GPU de alto rendimiento en clústeres Autopilot de Google Kubernetes Engine (GKE) mediante GPUDirect-TCPXO, GPUDirect-TCPX, gVNIC y la función de multirred. Si utilizas clústeres estándar, consulta Maximizar el ancho de banda de la red de la GPU en clústeres del modo estándar.
Esta página está dirigida a ingenieros de aprendizaje automático y administradores de plataformas que facilitan las cargas de trabajo de aprendizaje automático. Para obtener más información sobre los roles habituales y las tareas de ejemplo a las que hacemos referencia en el contenido, consulta Roles y tareas habituales de los usuarios de GKE. Google Cloud
Las aplicaciones de inteligencia artificial (IA), aprendizaje automático y computación de alto rendimiento (HPC) requieren una aceleración potente para optimizar el rendimiento y reducir el tiempo de finalización de los trabajos. Por ejemplo, los modelos de aprendizaje automático que se centran en la IA conversacional y la generación de imágenes requieren una gran escalabilidad y potencia de computación.
Antes de leer esta página, asegúrate de que conoces las tecnologías de redes, como las tarjetas de interfaz de red (NIC) y TCP, así como las tecnologías de aceleración, como la biblioteca de comunicaciones colectivas de NVIDIA (NCCL).
Acerca de los Google Cloud superordenadores con GPU
Google Cloud tiene superordenadores optimizados para aceleradores que se han creado para modelos masivos y escalables. Estas máquinas tienen las siguientes ventajas:
- Ocho GPUs NVIDIA B200, H200 o H100 por máquina.
- Hasta 200 Gbps de ancho de banda en la NIC principal.
- NICs 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 ellas admite hasta 200 Gbps de ancho de banda para la transferencia de datos de la GPU.
Tu carga de trabajo de GKE debe usar todas las GPUs y todas las NICs secundarias disponibles en un solo nodo, así como una parte significativa del ancho de banda disponible. La solución descrita en este documento es ideal para cargas de trabajo que requieren alto rendimiento, alto volumen de procesamiento y baja latencia.
Funciones y capacidades necesarias para maximizar el ancho de banda
Para maximizar el ancho de banda de tu red en los nodos de superordenadores con GPU, usa todas las funciones siguientes:
- Pila de redes GPUDirect: la serie de máquinas A3 admite tres pilas de redes para el acceso directo a memoria remota (RDMA) personalizado:
- En los tipos de máquinas A3 High y las GPUs NVIDIA H100, utiliza GPUDirect-TCPX para reducir la sobrecarga necesaria para transferir cargas útiles de paquetes a las GPUs y desde ellas, lo que mejora significativamente el rendimiento a gran escala en comparación con las GPUs que no usan GPUDirect.
- En los tipos de máquinas A3 Mega y las GPUs NVIDIA H100 Mega, utiliza GPUDirect-TCPXO, que mejora aún más la comunicación entre la GPU y la VM.
- En los tipos de máquinas A3 Ultra y las GPUs NVIDIA H200, así como en los tipos de máquinas A4 y las GPUs NVIDIA B200, utiliza GPUDirect RDMA para ejecutar cargas de trabajo de IA distribuidas con mejoras adicionales en el rendimiento. Para empezar, crea un clúster de GKE personalizado optimizado para IA.
- gVNIC habilita funciones de GPUDirect, como la división de encabezados de paquetes, la dirección de flujo y la gestión de búferes. gVNIC es necesario para usar GPUDirect-TCPX o GPUDirect-TCPXO. Para obtener más información sobre gVNIC, consulta el artículo Aumentar la velocidad del tráfico de red de los nodos de GPU.
- Redes múltiples: añade NICs secundarios a la máquina optimizada para aceleradores. Cada NIC está asociado a una subred independiente de su propia VPC para evitar conflictos. Para obtener más información sobre la compatibilidad con varias redes, consulta el artículo sobre cómo configurar la compatibilidad con varias redes para pods.
- Políticas de emplazamiento: usa una política de emplazamiento de recursos para colocar todos los nodos de GPU de una carga de trabajo específica en servidores físicamente cercanos para minimizar la latencia. Para obtener más información, consulta Definir la colocación compacta de nodos de GKE.
Esquema del procedimiento
Para usar todas estas funciones juntas, haz lo siguiente:
- Crear nubes privadas virtuales (VPCs) y subredes
- Crea el entorno de GKE.
- Instalar el archivo binario de GPUDirect y el complemento NCCL
- Implementar el complemento de inyección de dispositivos NRI
- Desplegar una carga de trabajo de prueba para verificar la configuración de GPUDirect
Antes de empezar
Antes de empezar, asegúrate de haber realizado las siguientes tareas:
- Habilita la API de Google Kubernetes Engine. Habilitar la API de Google Kubernetes Engine
- Si quieres usar Google Cloud CLI para esta tarea, instálala y, a continuación, inicialízala. Si ya has instalado la gcloud CLI, obtén la versión más reciente ejecutando
gcloud components update.
- Asegúrate de que tienes suficiente cuota para las GPUs H100. Para solicitar más cuota, consulta Cuotas de GPU.
Requisitos
Los siguientes requisitos se aplican tanto a GPUDirect-TCPX como a GPUDirect-TCPXO, a menos que se indique lo contrario.
- Tu clúster debe usar la versión 1.31.1-gke.1621000 de GKE o una posterior.
- Tus nodos de GPU deben usar la versión 535 o posterior del controlador de NVIDIA.
- Debes usar GKE Dataplane V2.
- En el caso de las cargas de trabajo de GPUDirect-TCPX o GPUDirect-TCPXO que se ejecutan en varios grupos de nodos, todos los grupos de nodos deben estar en las mismas zonas de Compute Engine y usar los mismos conjuntos de redes, como VPCs y subredes.
Limitaciones
Se aplican las siguientes limitaciones:
- GPUDirect-TCPX y GPUDirect-TCPXO no son compatibles con GPUs de varias instancias, tiempo compartido de GPU ni MPS de NVIDIA.
- No puedes usar NCCL FastSocket con GPUDirect-TCPX o GPUDirect-TCPXO .
- 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 mismo nodo.
- Solo puedes usar los tipos de máquina
a3-highgpu-8gya3-megagpu-8g. No se admiten otros tipos de máquinas A3.
Crear VPCs y subredes
Crea redes de VPC independientes en tu proyecto para cada NIC virtual que añadas a tus nodos. Cada red de VPC debe tener una subred y una regla de cortafuegos que permita el tráfico de red interno.
Crea las redes de VPC para GPUDirect en tu proyecto. Cada una debe tener una subred y una regla de cortafuegos. Elige la pestaña GPUDirect-TCPX para los tipos de máquina A3 High o la pestaña GPUDirect-TCPXO para los tipos de máquina A3 Mega y, a continuación, sigue estas 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 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 doneHaz los cambios siguientes:
PROJECT_ID: tu ID de proyecto Google Cloud .REGION: la región de Compute Engine de cada subred.SUBNET_RANGE: el intervalo de direcciones IP de cada subred en notación CIDR. Este comando de ejemplo itera en ocho subredes, por lo que debes usar una variable para cambiar la dirección IP de cada subred. Por ejemplo, especifica192.168.$N.0/24para que la primera subred use192.168.1.0/24, la segunda subred use192.168.2.0/24, y así sucesivamente.SOURCE_RANGE: el intervalo de direcciones IP de origen de la regla de cortafuegos para permitir el tráfico entrante, 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 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 doneHaz los cambios siguientes:
PROJECT_ID: tu ID de proyecto Google Cloud .REGION: la región de Compute Engine de cada subred.SUBNET_RANGE: el intervalo de direcciones IP de cada subred en notación CIDR. Este comando de ejemplo itera en cuatro subredes, por lo que debes usar una variable para cambiar la dirección IP de cada subred. Por ejemplo, especifica192.168.$N.0/24para que la primera subred use192.168.1.0/24, la segunda subred use192.168.2.0/24, etc.SOURCE_RANGE: el intervalo de direcciones IP de origen de la regla de cortafuegos para permitir el tráfico entrante, en notación CIDR. Por ejemplo,192.168.0.0/16.
Comprueba que se hayan creado las redes:
gcloud compute networks list
Crear el entorno de GKE
Crea un clúster de GKE que use varias redes (vista previa). No puedes actualizar un clúster para que use varias redes.GPUDirect-TCPXO
Elige una versión de GKE disponible que admita GPUDirect-TCPXO. Para enumerar las versiones, ejecuta este comando:
gcloud container get-server-config \ --format="yaml(validMasterVersions)" \ --region=REGION \ --project=PROJECT_IDHaz los cambios siguientes:
REGION: la región de computación del plano de control del clúster.PROJECT_ID: tu ID de proyecto Google Cloud .
Para crear un clúster, sigue estos pasos:
gcloud beta container clusters create-auto CLUSTER_NAME \ --project=PROJECT_ID \ --location=CONTROL_PLANE_LOCATION \ --cluster-version=VERSION \ --enable-multi-networking \ --workload-policies=allow-net-adminHaz los cambios siguientes:
CLUSTER_NAME: el nombre del nuevo clúster.CONTROL_PLANE_LOCATION: la región de Compute Engine del plano de control de tu clúster.VERSION: una versión de GKE que admita GPUDirect-TCPXO, tal como se describe en la sección Requisitos.
Crea recursos de Network y GKENetworkParamSet en el clúster que correspondan a las redes de VPC y las subredes que hayas creado:
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 EOFEstos recursos indican a GKE que configure las NICs para el tráfico de GPU en modo de transferencia. GKE no aplica la programación de redes integrada con eBPF a este tráfico.
GPUDirect-TCPX
Para crear un clúster, sigue estos pasos:
gcloud beta container clusters create-auto CLUSTER_NAME \ --project=PROJECT_ID \ --location=CONTROL_PLANE_LOCATION \ --cluster-version=VERSION \ --enable-multi-networking \ --workload-policies=allow-net-adminHaz los cambios siguientes:
CLUSTER_NAME: el nombre del nuevo clúster.CONTROL_PLANE_LOCATION: la región de Compute Engine del plano de control de tu clúster.VERSION: una versión de GKE que admita GPUDirect-TCPX, tal como se describe en Requisitos.
Crea recursos de Network y GKENetworkParamSet en el clúster que correspondan a las redes de VPC y las subredes que hayas creado:
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 EOFEstos recursos indican a GKE que configure las NICs para el tráfico de GPU en modo de transferencia. GKE no aplica la programación de redes integrada con eBPF a este tráfico.
Instalar el archivo binario de GPUDirect y configurar NCCL
En esta sección se muestra cómo instalar el archivo binario de GPUDirect en función del tipo de máquina A3 (GPUDirect-TCPX para A3 High y GPUDirect-TCPXO para A3 Mega) y de una versión específica de la biblioteca NCCL mediante un DaemonSet.
GPUDirect-TCPXO
Este DaemonSet hace lo siguiente:
- Preinstalación para configurar las configuraciones relacionadas con GPUDirect-TCPXO.
- Instala la biblioteca NCCL y el archivo binario GPUDirect-TCPXO en el nodo.
- Almacena la biblioteca y el archivo binario en el directorio
/home/kubernetes/bin/nvidia/lib64de la VM. De forma predeterminada, GKE monta este directorio en la ruta/usr/local/nvidia/lib64de los contenedores de GPU que necesitan usar NCCL y GPUDirect-TCPXO.
Para instalar el archivo binario y configurar NCCL, sigue estos pasos:
Consulta el manifiesto de DaemonSet en GitHub.
nccl-tcpxo-installer-autopilot.yamlCrea un espacio de nombres específico:
kubectl create ns gpudirect-systemDespliega el DaemonSet:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpxo/nccl-tcpxo-installer-autopilot.yamlEl complemento NCCL tarda aproximadamente dos minutos en empezar a ejecutarse.
GPUDirect-TCPX
Este DaemonSet hace lo siguiente:
- Instala la biblioteca NCCL y el archivo binario GPUDirect-TCPX en el nodo.
- Almacena la biblioteca y el archivo binario en el directorio
/home/kubernetes/bin/nvidia/lib64de la VM. De forma predeterminada, GKE monta este directorio en la ruta/usr/local/nvidia/lib64de los contenedores de GPU que necesitan usar NCCL y GPUDirect-TCPX.
Para instalar el archivo binario y configurar NCCL, haz lo siguiente:
Consulta el manifiesto de DaemonSet en GitHub.
nccl-tcpx-installer-autopilot.yamlCrea un espacio de nombres específico:
kubectl create ns gpudirect-systemDespliega el DaemonSet:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-tcpx-installer-autopilot.yamlEl complemento NCCL tarda aproximadamente dos minutos en empezar a ejecutarse.
Implementar el complemento de inyector de dispositivos de NRI
En esta sección se muestra cómo instalar el inyector de dispositivos NRI mediante un DaemonSet. Ambos tipos de máquinas con GPU H100 instalan el mismo complemento de inyector de dispositivos NRI. Este complemento hace lo siguiente:
- Habilita la interfaz de recursos de nodos (NRI) en el nodo que tiene GPUs H100. La NRI está habilitada de forma predeterminada en GKE 1.29 y versiones posteriores.
- Despliega un contenedor de complementos de inyector de dispositivos NRI que inyecta dispositivos de GPU en contenedores especificados por anotaciones de Pod.
Para instalar el complemento, sigue estos pasos:
Consulta el
nri-device-injector-autopilot.yamlmanifiesto de implementación en GitHub.Despliega el DaemonSet:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nri_device_injector/nri-device-injector-autopilot.yamlEl complemento NCCL tarda aproximadamente dos minutos en empezar a ejecutarse.
Desplegar una carga de trabajo de prueba
En esta sección, implementarás una carga de trabajo de ejemplo para verificar que NCCL y GPUDirect-TCPX o GPUDirect-TCPXO funcionan correctamente. Esta carga de trabajo de ejemplo hace lo siguiente:
- Despliega dos pods, cada uno de los cuales se ejecuta en un nodo que tiene GPUs H100.
- Despliega un contenedor adicional en cada pod para que esos pods puedan usar GPUDirect-TCPXO o GPUDirect-TCPX.
Para implementar esta carga de trabajo de ejemplo, haz lo siguiente:
GPUDirect-TCPXO
Esta carga de trabajo incluye un contenedor sidecar llamado tcpxo-daemon, que ejecuta un servicio que permite que el pod use GPUDirect-TCPXO. Debes añadir este contenedor sidecar a cualquier pod de tu entorno que necesite usar GPUDirect-TCPXO. Para ver un fragmento de los campos obligatorios que debes añadir a tus archivos de manifiesto, consulta Añadir GPUDirect a tu archivo de manifiesto.
Consulta el
nccl-test-latest-autopilot.yamlmanifiesto en GitHub.Despliega 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-autopilot.yamlUna vez que se hayan desplegado los pods, activa una prueba de all-gather:
kubectl exec --stdin --tty --container=nccl-test nccl-test-host-1 -- /scripts/allgather.sh nccl-host-1 nccl-host-2El resultado debería ser 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) 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
Esta carga de trabajo incluye un contenedor sidecar llamado tcpx-daemon, que ejecuta un servicio que permite que el pod use GPUDirect-TCPX. Debes añadir este contenedor sidecar a cualquier pod de tu entorno que necesite usar GPUDirect-TCPX. Para ver un fragmento de los campos obligatorios que debes añadir a tus archivos de manifiesto, consulta Añadir GPUDirect a tu archivo de manifiesto.
Consulta el manifiesto de ConfigMap en GitHub.
nccl-config.yamlEste manifiesto implementa secuencias de comandos que inicializan una prueba de recopilación de NCCL y definen ajustes de configuración específicos de NCCL.Consulta el
nccl-test-latest-autopilot.yamlmanifiesto de implementación en GitHub.Despliega 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-autopilot.yamlEjecuta los siguientes comandos para activar una prueba de recolección de todos los nodos de NCCL:
kubectl exec \ --stdin --tty --container=nccl-test nccl-test-host-1 \ -- /configs/allgather.sh nccl-host-1 nccl-host-2El resultado debería ser 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
Usar los ajustes de configuración de NCCL obligatorios para mejorar el rendimiento
Los siguientes pares clave-valor son los ajustes de configuración de NCCL necesarios para GPUDirect-TCPX y GPUDirect-TCPXO. Cuando despliegues tus cargas de trabajo que usen NCCL, configúralas como variables de entorno para optimizar el rendimiento.
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"
También puedes configurar todos los ajustes a la vez siguiendo estos pasos:
En el manifiesto del contenedor de la carga de trabajo, añade el siguiente par clave-valor como variable de entorno:
NCCL_LIB_DIR="/usr/local/nvidia/lib64"Asegúrate de que la secuencia de comandos
nccl-env-profile.shse ejecute cuando se inicie el contenedor de tu carga de trabajo. Por ejemplo, puedes hacerlo en la especificación de tu pod. Para ello, anula el comando del contenedor para incluir lo siguiente:source ${NCCL_LIB_DIR}/nccl-env-profile.sh
Compatibilidad con LL128
El protocolo de comunicación LL128 (128 de baja latencia) de NVIDIA puede mejorar significativamente el rendimiento de los colectivos de tamaño pequeño o mediano. GPUDirect-TCPXO es compatible con el protocolo LL128.
Para usar LL128, asegúrate de que el archivo nccl-tcpxo-installer.yaml de la sección Instalar el archivo binario de GPUDirect y configurar NCCL use la siguiente versión de imagen de contenedor o una posterior:
us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx-
dev:v1.0.8-1
Para configurar LL128, sigue estos pasos:
Para la versión del complemento
us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx- dev:v1.0.8-1NCCL, sigue estos pasos:En el manifiesto de la carga de trabajo, define la siguiente variable de entorno:
NCCL_LIB_DIR="/usr/local/nvidia/lib64Configura tu carga de trabajo para que ejecute la secuencia de comandos
nccl-env-profile-ll128.shcuando se inicie el contenedor. En el manifiesto de la carga de trabajo, define el siguiente comando:source ${NCCL_LIB_DIR}/nccl-env-profile-ll128.shLa secuencia de comandos
nccl-env-profile-ll128.shtiene las siguientes variables de entorno: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
En el caso de la versión del complemento NCCL
us-docker.pkg.dev/gce-ai-infra/gpudirect-tcpxo/nccl-plugin-gpudirecttcpx-dev:v1.0.9-1y posteriores, LL128 se convierte en un parámetro predeterminado, por lo que, si se usa la secuencia de comandosnccl-env-profile.sho la secuencia de comandosnccl-env-profile-ll128.sh, se habilita LL128. Para inhabilitar LL128, sigue estos pasos:En el manifiesto de la carga de trabajo, define la siguiente variable de entorno:
NCCL_LIB_DIR="/usr/local/nvidia/lib64Configura tu carga de trabajo para que ejecute la secuencia de comandos
nccl-env-profile-ll128.shcuando se inicie el contenedor. En el manifiesto de la carga de trabajo, define el siguiente comando:source ${NCCL_LIB_DIR}/nccl-env-profile-simple.shLa secuencia de comandos
nccl-env-profile-simple.shtiene las siguientes variables de entorno: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"
Recoger registros de depuración de NCCL
Para registrar errores de NCCL, te recomendamos que añadas la siguiente configuración de NCCL:
NCCL_DEBUG=INFO
NCCL_DEBUG_SUBSYS=INIT,NET,ENV,COLL,GRAPH
NCCL_DEBUG_FILE=/DIRECTORY/FILE_NAME.%h.%p
NCCL_DEBUG=INFO: imprime información de depuración.- En el caso de las cargas de trabajo a gran escala (64 nodos o más), se pueden producir registros extensos. Para evitar esta situación (a menos que hayas especificado
NCCL_DEBUG_FILE), te recomendamos que definasNCCL_DEBUG=WARNpara limitar los registros a los errores.
- En el caso de las cargas de trabajo a gran escala (64 nodos o más), se pueden producir registros extensos. Para evitar esta situación (a menos que hayas especificado
NCCL_DEBUG_SUBSYS: filtra los subsistemas de los que NCCL recoge información de depuración. Te recomendamos que recojas los registros de los siguientes subsistemas:INIT: la fase de inicialización de NCCL.NET: la red NCCL.ENV: las variables de entorno que usa NCCL.COLL: operaciones colectivas.GRAPH: detección de topologías y búsqueda de gráficos.
Si quieres recoger registros de diferentes subsistemas, consulta la
NCCL_DEBUG_SUBSYSen la documentación de NCCL para ver una lista de los valores aceptados.NCCL_DEBUG_FILE(Opcional): dirige el resultado del registro de depuración de NCCL a un archivo que especifiques. Esta variable escribe los registros de NCCL en archivos estándar, lo que evita que la salida del registro se mezcle con la salida de la aplicación. Esta variable también escribe registros de diferentes rangos de NCCL en archivos diferentes, lo que evita que se mezclen los registros.Utiliza el siguiente formato de nombre de archivo:
/DIRECTORY/FILE_NAME.%h.%pHaz los cambios siguientes:
DIRECTORY: el directorio en el que quieras almacenar los archivos de registro.FILE_NAME: el nombre de los archivos de registro.
El marcador de posición
%hse resuelve en el nombre de host del nodo, mientras que%pse resuelve en el ID de proceso (PID) del proceso que genera el registro.
Para obtener más información sobre cómo depurar los registros de NCCL, consulta el artículo Solucionar problemas con las GPUs en GKE.
Añadir GPUDirect a tus manifiestos
En esta sección se muestran los campos obligatorios que debe añadir a los manifiestos de Kubernetes para que sus pods usen GPUDirect.
En el modo Autopilot, también debes seleccionar las GPUs adecuadas en los manifiestos de tu pod para que GKE aprovisione el hardware. En el caso de las GPUs H100 Mega, usa GPUDirect-TCPXO. En el caso de las GPUs H100, usa GPUDirect-TCPX.Añade los siguientes selectores de nodos a tu pod:
nodeSelector:
cloud.google.com/gke-accelerator: GPU_NAME
cloud.google.com/gke-gpu-driver-version: latest
Sustituye GPU_NAME por el nombre de la GPU. Estos son los valores admitidos:
nvidia-h100-mega-80gbnvidia-h100-80gb
En función del tipo de GPUDirect, haga lo siguiente:
GPUDirect-TCPXO
Añade las siguientes anotaciones a los metadatos 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"} ]Añade 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_devicesAñade el siguiente contenedor al archivo de manifiesto para ejecutar el servicio
tcpxo-daemon. Sustituye (TCPXO_DAEMON_IMAGE) por la imagen más reciente: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: /hostprocsysfsAñade la siguiente variable de entorno a cada contenedor de GPU:
env: - name: NCCL_FASTRAK_LLCM_DEVICE_DIRECTORY value: /dev/aperture_devicesAñade los siguientes elementos volumeMounts a cada contenedor de GPU. Sin configuraciones de
aperture_devices, se necesitaprivileged:truepara los contenedores de GPU:volumeMounts: - name: aperture-devices mountPath: /dev/aperture_devicesAñade variables de entorno para configurar las opciones de NCCL. Para obtener más información, consulta Usar los ajustes de configuración de NCCL recomendados para mejorar el rendimiento.
Una especificación de Pod completa tiene el siguiente aspecto:
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
Añade las siguientes anotaciones a los metadatos 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"}, ]Añade 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/sysAñade 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: /hostprocsysfsAñade los siguientes montajes de volumen a los contenedores que soliciten GPUs:
volumeMounts: - name: tcpx-socket mountPath: /tmp - name: libraries mountPath: /usr/local/nvidia/lib64Añade variables de entorno para configurar las opciones de NCCL. Para obtener más información, consulta la sección Usar los ajustes de configuración de NCCL recomendados para mejorar el rendimiento de este documento.
Una especificación de Pod completa tiene el siguiente aspecto:
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
Siguientes pasos
- Consulta las notas de la versión de GPUDirect-TCPXO.
- Consulta más información sobre la práctica recomendada para ejecutar cargas de trabajo con GPUDirect-TCPX(O).
- Consulta las prácticas recomendadas para las redes de GKE.
- Consulta más información sobre la familia de tecnologías Nvidia GPUDirect para el movimiento y el acceso a datos en GPUs Nvidia.
- Consulta la disponibilidad de la versión actual de la GPU y cómo solicitar GPUs en GKE.