GKE proporciona una sola plataforma para ejecutar un conjunto diverso de cargas de trabajo para tus organizaciones, lo que reduce la carga operativa de administrar varias plataformas. Puedes ejecutar cargas de trabajo, como el entrenamiento previo distribuido de alto rendimiento, el ajuste de modelos, la inferencia de modelos, la entrega de aplicaciones y los servicios de asistencia.
En esta página, aprenderás a crear clústeres estándar y de Autopilot de Google Kubernetes Engine (GKE) con 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. Para obtener más información sobre los roles comunes y las tareas de ejemplo a las que hacemos referencia en el contenido de Google Cloud , consulta Roles y tareas comunes del usuario de GKE.
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.
En esta página, se supone que estás familiarizado con las tecnologías de redes, como las tarjetas de interfaz de red (NIC) y TCP, y con las tecnologías de aceleración, como la biblioteca de comunicaciones colectivas de NVIDIA (NCCL).
Acerca de las supercomputadoras con Google Cloud GPU
Google Cloud tiene supercomputadoras optimizadas para aceleradores que están diseñadas para modelos masivos y escalables. Estos tipos de máquinas con GPU pueden obtener hasta 3,600 Gbps de ancho de banda de red.
Tu carga de trabajo de GKE debe usar todas las GPUs 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 está diseñada 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, debes usar las siguientes características:
- Pila de redes GPUDirect: A3 Edge admite tres pilas de redes para el acceso directo a la memoria (RDMA) personalizado y remoto. Las máquinas A3 Edge usan GPUDirect-TCPX para reducir la sobrecarga necesaria para transferir cargas útiles de paquetes desde y hacia las GPUs, lo que mejora significativamente la capacidad de procesamiento a gran escala en comparación con las GPUs que no usan GPUDirect.
- 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. Para obtener detalles sobre gVNIC, consulta Aumenta la velocidad del tráfico de red para los nodos de GPU.
También debes habilitar y configurar las siguientes funciones:
- 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. Para obtener más detalles, consulta Define la posición compacta para los nodos de GKE.
Esquema del procedimiento
Para usar GPUDirect-TCPX, gVNIC, varias redes y políticas de posición de compactación en conjunto, haz lo siguiente:
- Crea subredes y nubes privadas virtuales (VPC).
- Crea el entorno de GKE
- Instala el objeto binario GPUDirect-y el complemento NCCL.
- Implementa el complemento NRI Device Injector
- Implementa una carga de trabajo de prueba para verificar la configuración de GPUDirect.
- Adopta GPUDirect para tus propias cargas de trabajo
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 la gcloud CLI, ejecuta el comando
gcloud components updatepara obtener la versión más reciente. Es posible que las versiones anteriores de gcloud CLI no admitan la ejecución de los comandos que se indican en este documento.
- Asegúrate de tener capacidad para las VMs de A3 Edge. Para obtener esta capacidad, primero elige entre las opciones de consumo. Para seguir las instrucciones de esta página, puedes usar la capacidad on demand, las reservas on demand o las reservas futuras con hasta 90 días de anticipación (en el modo de calendario). Después de elegir una opción de consumo, sigue las instrucciones correspondientes para obtener capacidad con la opción que elegiste.
- Asegúrate de tener suficiente cuota para las GPU H100. Para solicitar más cuota, consulta Cuotas de GPU.
Requisitos
Se aplican los siguientes requisitos a GPUDirect-TCPX:
Estándar
- GPUDirect-TCPX es compatible con todas las versiones secundarias de GKE disponibles con versiones de parche específicas:
- Para las versiones 1.30 a 1.33 de GKE, usa cualquier versión del parche.
- Para la versión 1.34 de GKE, usa la versión del parche 1.34.5-gke.1153000 o posterior.
- Para la versión 1.35 de GKE, usa la versión del parche 1.35.2-gke.1485000 o posterior.
- Para la versión 1.36 de GKE o posterior, usa cualquier versión del parche.
- El nodo de GKE debe usar una imagen de nodo de Container-Optimized OS (COS). No se admiten las imágenes de nodos de Ubuntu y Windows.
- Tus nodos de GPU deben usar la versión 535 o posterior del controlador NVIDIA.
- Debes usar GKE Dataplane V2.
- En la versión 1.34 y posteriores de GKE, debes usar la versión 3.1.9 o posterior del instalador de GPUDirect-TCPX y la versión 2.0.12 o posterior del sidecar de GPUDirect-TCPX. Las versiones del instalador y del sidecar tienen una asignación uno a uno y deben corresponderse. Por ejemplo, la versión 3.1.12 del instalador corresponde a la versión 2.0.15 del sidecar. Para obtener más información sobre las versiones del instalador y del sidecar, consulta las Notas de la versión de GPUDirect-TCPX.
- En el caso de las cargas de trabajo de GPUDirect-TCPX que se ejecutan en varios grupos de nodos, todos los grupos de nodos deben estar en las mismas zonas de Compute Engine y deben usar los mismos conjuntos de redes, como VPCs y subredes.
Autopilot
- Para usar GPUDirect-TCPX, tu clúster debe ejecutar las siguientes versiones de parche mínimas de GKE:
- Para la versión 1.31 de GKE, usa la versión del parche 1.31.1-gke.1621000 o posterior.
- Para las versiones 1.32 y 1.33 de GKE, usa cualquier versión del parche.
- Para la versión 1.34 de GKE, usa la versión del parche 1.34.5-gke.1153000 o posterior.
- Para la versión 1.35 de GKE, usa la versión del parche 1.35.2-gke.1485000 o posterior.
- Para la versión 1.36 de GKE o posterior, usa cualquier versión del parche.
- Tus nodos de GPU deben usar la versión 535 o posterior del controlador NVIDIA.
- Debes usar GKE Dataplane V2.
- En la versión 1.34 y posteriores de GKE, debes usar la versión 3.1.9 o posterior del instalador de GPUDirect-TCPX y la versión 2.0.12 o posterior del sidecar de GPUDirect-TCPX. Las versiones del instalador y del sidecar tienen una asignación uno a uno y deben corresponderse. Por ejemplo, la versión 3.1.12 del instalador corresponde a la versión 2.0.15 del sidecar. Para obtener más información sobre las versiones del instalador y del sidecar, consulta las Notas de la versión de GPUDirect-TCPX.
- En el caso de las cargas de trabajo de GPUDirect-TCPX que se ejecutan en varios grupos de nodos, todos los grupos de nodos deben estar en las mismas zonas de Compute Engine y deben usar los mismos conjuntos de redes, como VPCs y subredes.
Limitaciones
Se aplica la siguiente limitación:
- GPUDirect-TCPX no es compatible con GPU de varias instancias, uso compartido de tiempo de GPU ni NVIDIA MPS.
- No puedes usar NCCL FastSocket con GPUDirect-TCPX.
- 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 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.
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 doneReemplaza lo siguiente:
PROJECT_ID: Es el 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, especifica192.168.$N.0/24para que la primera subred use192.168.1.0/24, la segunda subred use192.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 tenga las siguientes características:
- gVNIC habilitada
- Subredes de varias redes especificadas para cada NIC secundaria
- Serie de máquinas A3 Edge con GPU H100 que respaldan los nodos
- Controladores de NVIDIA más recientes instalados
No puedes actualizar un clúster existente para usar redes múltiples.
Crea un clúster:
Estándar
gcloud beta container clusters create CLUSTER_NAME \ --enable-dataplane-v2 \ --enable-ip-alias \ --location=CONTROL_PLANE_LOCATION \ --enable-multi-networking \ --cluster-version=VERSION \ --no-enable-autoupgrade \ --project=PROJECT_IDReemplaza lo siguiente:
CLUSTER_NAME: Es el nombre del clúster nuevo.CONTROL_PLANE_LOCATION: Es la ubicación de Compute Engine del plano de control de tu clúster. Proporciona una región para los clústeres regionales o una zona para los clústeres zonales.VERSION: Una versión de GKE que admita GPUDirect-TCPX, como se describe en Requisitos.
Autopilot
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-adminReemplaza lo siguiente:
CLUSTER_NAME: Es el nombre del clúster nuevo.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, como se describe en 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: 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 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 de GPU (solo en Standard)
Crea un grupo de nodos para las GPU H100:
gcloud container node-pools create NODE_POOL_NAME \ --cluster=CLUSTER_NAME \ --location=CONTROL_PLANE_LOCATION \ --machine-type=a3-edgegpu-8g \ --accelerator=type=nvidia-h100-80gb,count=8,gpu-driver-version=LATEST \ --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 \ --enable-gvnic \ --no-enable-autoupgrade \ --placement-policy=POLICY_NAME \ --reservation-affinity=specific \ --reservation=projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAMEReemplaza
NODE_POOL_NAMEpor el nombre del grupo de nodos.Para usar una reserva, usa las marcas
--placement-policy,--reservation-affinityy--reservation. Especifica estos parámetros para configurar el nombre de la política y la reserva en el grupo de nodos. Si la reserva no requiere una política de recursos, omite la marca--placement-policy.La marca
--reservation-affinitypuede tomar los valoresspecificoany. Sin embargo, para las cargas de trabajo de IA distribuidas de alto rendimiento, te recomendamos que uses una reserva específica. Puedes encontrar información sobre tu reserva, como su nombre o el de un bloque específico. Para encontrar estos valores en las reservas según demanda, consulta una lista de tus reservas o visualiza las solicitudes de reserva futuras.Reemplaza lo siguiente para usar una reserva:
PROJECT_ID: Opcionalmente, el ID del proyecto de Google Cloud. Si la reserva se encuentra en el proyecto actual (no es una reserva compartida), puedes omitirprojects/PROJECT_ID/reservations/del valor de la reserva.RESERVATION_NAME: Es el nombre de tu reserva.BLOCK_NAME: De manera opcional, el nombre de un bloque específico dentro de la reserva. Omite/reservationBlocks/BLOCK_NAMEsi no quieres usar un bloque específico.
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.
Después de crear el grupo de nodos, verifica que cada nodo tenga las GPUs adjuntas:
Obtén una lista de nodos en el clúster:
kubectl get nodesVerifica que cada nodo de GPU tenga ocho GPU:
kubectl describe node NODE_NAMEReemplaza
NODE_NAMEpor el nombre del nodo que se describirá.El resultado es similar a lo siguiente:
Capacity: ... nvidia.com/gpu: 8 Allocatable: ... nvidia.com/gpu: 8
Instala el objeto binario GPUDirect y el complemento NCCL
En esta sección, se muestra cómo instalar el objeto binario GPUDirect-TCPX y una versión específica de la biblioteca NCCL con un DaemonSet.
Este DaemonSet hace lo siguiente:
- Instala la 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/lib64de la VM. De forma predeterminada, GKE activa este directorio en la ruta/usr/local/nvidia/lib64en los contenedores de GPU que necesitan usar NCCL y GPUDirect-TCPX.
Para instalar el archivo binario y configurar NCCL, haz lo siguiente:
Estándar
Revisa el manifiesto de DaemonSet
nccl-tcpx-installer.yamlen GitHub.Implementa el DaemonSet:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-tcpx-installer.yamlEl 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-installerEl resultado es similar a lo siguiente:
nccl-tcpx-installer-6c2pv 1/1 Running 0 2m11s nccl-tcpx-installer-qgg82 1/1 Running 0 2m11s
Autopilot
Revisa el manifiesto de DaemonSet
nccl-tcpx-installer-autopilot.yamlen GitHub.Crea un espacio de nombres dedicado:
kubectl create ns gpudirect-systemImplementa el DaemonSet:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-tcpx/nccl-tcpx-installer-autopilot.yamlEl complemento NCCL tarda alrededor de dos minutos en comenzar a ejecutarse.
Implementa el complemento del inyector de dispositivos de NRI
En esta sección, se muestra cómo instalar el inyector de dispositivos NRI con un DaemonSet. Este complemento hace lo siguiente:
- Habilita la interfaz de recursos del nodo (NRI) en el nodo que tiene GPU H100. El NRI está habilitado de forma predeterminada en la versión 1.29 de GKE y versiones posteriores.
- Implementa un contenedor de complemento del inyector de dispositivos de NRI que inserta dispositivos de GPU en los contenedores especificados por las anotaciones de Pod.
Para instalar el complemento, haz lo siguiente:
Estándar
Revisa el manifiesto de Deployment
nri-device-injector.yamlen GitHub.Implementa el DaemonSet:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nri_device_injector/nri-device-injector.yamlEl 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-injectorEl resultado es similar a lo siguiente:
# Output device-injector-md6hb 1/1 Running 0 4h54m device-injector-vh9bm 1/1 Running 0 4h54m
Autopilot
Revisa el manifiesto de Deployment
nri-device-injector-autopilot.yamlen GitHub.Implementa 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 alrededor de dos minutos en comenzar a ejecutarse.
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 de ejemplo hace lo siguiente:
- Implementa dos Pods, cada uno de los cuales se ejecuta en un nodo que tiene GPU H100.
- Implementa un contenedor sidecar en cada Pod para permitir que esos Pods usen GPUDirect-TCPX.
Esta carga de trabajo incluye un contenedor sidecar llamado tcpx-daemon, que ejecuta un servicio que permite al Pod usar GPUDirect-TCPX. Debes agregar este contenedor sidecar a cualquier Pod de tu propio entorno que necesite usar GPUDirect-TCPX. Para obtener un fragmento de los campos obligatorios que debes agregar a tus manifiestos, consulta Agrega GPUDirect a tu manifiesto.
Revisa el manifiesto de ConfigMap
nccl-config.yamlen GitHub. Este manifiesto implementa secuencias de comandos que inicializan una prueba NCCL all-gather y establecen parámetros de configuración específicos de NCCL.Según el modo del clúster, haz lo siguiente:
Estándar
Revisa el manifiesto de Deployment
nccl-test-latest.yamlen GitHub.Autopilot
Revisa el manifiesto de Deployment
nccl-test-latest-autopilot.yamlen GitHub.Implementa el ConfigMap y la carga de trabajo de prueba:
Estándar
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.yamlAutopilot
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.yamlVerifica que los Pods se estén ejecutando y estén listos. Ten en cuenta que las imágenes son grandes (aproximadamente 5 GB) y pueden tardar varios minutos en descargarse.
kubectl get pods -wEl comando supervisa las actualizaciones y muestra una línea nueva cuando cambia el estado de un Pod. El resultado es similar a lo siguiente:
NAME READY STATUS RESTARTS AGE nccl-test-host-1 0/2 ContainerCreating 0 23s nccl-test-host-2 2/2 Running 0 23s nccl-test-host-1 2/2 Running 0 46sEspera hasta que el mensaje
STATUSpara todos los Pods seaRunningy el valor deREADYsea2/2antes de continuar con el siguiente paso.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-2El resultado es similar a lo siguiente:
Estándar
# 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 # ```Autopilot
# 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
Adopta GPUDirect para tus propias cargas de trabajo
Después de verificar que la red de tu clúster funciona correctamente con la carga de trabajo de prueba de muestra, el siguiente paso es adoptar GPUDirect para tus cargas de trabajo reales. Para adoptar GPUDirect, debes actualizar la configuración de NCCL y los manifiestos de Pod de Kubernetes.
Usa la configuración requerida de NCCL para mejorar el rendimiento
Los siguientes pares clave-valor son los parámetros de configuración de NCCL necesarios para GPUDirect-TCPX. Cuando implementes tus cargas de trabajo que usan NCCL, configúralas como variables de entorno para optimizar el rendimiento.
"LD_LIBRARY_PATH=\"${LD_LIBRARY_PATH}:/usr/local/nvidia/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"
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.
Según el modo del clúster, haz lo siguiente:
Estándar
Agrega las siguientes anotaciones a los metadatos del Pod. Sin estas anotaciones, se requerirá
hostNetwork:truepara el Pod yprivileged:truepara el contenedortcpx-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/sysAgrega 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/lib64Agrega las siguientes activaciones de volumen a cualquier contenedor que solicite GPU:
volumeMounts: - name: tcpx-socket mountPath: /tmp - name: libraries mountPath: /usr/local/nvidia/lib64Agrega variables de entorno para configurar las opciones de NCCL. Para obtener más información, consulta la sección Usa la configuración recomendada de NCCL para mejorar el rendimiento de este documento.
Agrega la siguiente variable de entorno a cada contenedor de GPU:
env: - name: LD_LIBRARY_PATH value: /usr/local/nvidia/lib64
Para ver un ejemplo de una especificación de Pod completa, consulta el manifiesto nccl-test-latest.yaml en GitHub.
Autopilot
En el modo Autopilot, también debes seleccionar las GPUs adecuadas en los manifiestos de Pod para que GKE aprovisione el hardware.
Agrega los siguientes selectores de nodos a tu Pod:
nodeSelector:
cloud.google.com/gke-accelerator: a3-edgegpu-8g
cloud.google.com/gke-gpu-driver-version: latest
Además, si deseas usar capacidad reservada, puedes proporcionar información sobre la reserva. Para obtener más información, consulta las subsecciones sobre el consumo de reservas en Consume reservas de capacidad en clústeres de Autopilot.
Agrega 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"}, ]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/sysAgrega 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/lib64Agrega las siguientes activaciones de volumen a cualquier contenedor que solicite GPU:
volumeMounts: - name: tcpx-socket mountPath: /tmp - name: libraries mountPath: /usr/local/nvidia/lib64Agrega variables de entorno para configurar las opciones de NCCL. Para obtener más información, consulta la sección Usa la configuración recomendada de NCCL para mejorar el rendimiento de este documento.
Para ver un ejemplo de una especificación de Pod completa, consulta el manifiesto nccl-test-latest-autopilot.yaml en GitHub.
Recopila registros de depuración de NCCL
Para registrar los errores de NCCL, te recomendamos que agregues 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.- Para cargas de trabajo a gran escala (64 nodos o más), se puede producir un registro extenso. Para evitar esta situación, y a menos que hayas especificado
NCCL_DEBUG_FILE, te recomendamos que establezcasNCCL_DEBUG=WARNpara limitar los registros solo a los errores.
- Para cargas de trabajo a gran escala (64 nodos o más), se puede producir un registro extenso. Para evitar esta situación, y a menos que hayas especificado
NCCL_DEBUG_SUBSYS: Filtra los subsistemas para los que NCCL recopila información de depuración. Te recomendamos que recopiles registros de los siguientes subsistemas:INIT: Es la fase de inicialización de NCCL.NET: Es la red de NCCL.ENV: Son las variables de entorno que usa NCCL.COLL: Operaciones colectivas.GRAPH: Detección de topología y búsqueda de grafos.
Si deseas recopilar registros para diferentes subsistemas, consulta
NCCL_DEBUG_SUBSYSen la documentación de NCCL para obtener 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 de 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.Usa el siguiente formato de nombre de archivo:
/DIRECTORY/FILE_NAME.%h.%pReemplaza lo siguiente:
DIRECTORY: Es el directorio en el que deseas almacenar los archivos de registro.FILE_NAME: Es el nombre de los archivos de registro.
El marcador de posición
%hse resuelve como el nombre de host del nodo, mientras que%pse resuelve como el ID de proceso (PID) del proceso que genera el registro.
Para obtener más información sobre la depuración de registros de NCCL, consulta Soluciona problemas relacionados con las GPUs en GKE.
¿Qué sigue?
- Para obtener más información sobre la programación de cargas de trabajo en tus clústeres de GKE con la programación consciente de la topología (TAS) y Kueue, consulta Programa cargas de trabajo de GKE con la programación consciente de la topología.
- Para obtener más información sobre la administración de eventos comunes relevantes para los clústeres de GKE y las cargas de trabajo de IA, consulta Administra clústeres de GKE optimizados para IA.