Crea un clúster de GKE optimizado para IA que use A4X Max

En este documento, se muestra cómo crear un clúster de Google Kubernetes Engine (GKE) optimizado para IA que use instancias de Compute Engine A4X Max para admitir tus cargas de trabajo de IA y AA.

Las series A4X Max y A4X te permiten ejecutar clústeres de IA y AA a gran escala con el sistema NVLink de varios nodos (MNNVL) de NVIDIA, una solución a escala de bastidor que permite una mayor potencia y rendimiento de la GPU. Estas máquinas ofrecen funciones como la ubicación de cargas de trabajo orientadas, la programación basada en la topología y los controles avanzados de mantenimiento de clústeres. Para obtener más información, consulta Funciones de administración de clústeres. Con A4X Max, GKE también proporciona una configuración de red automatizada que simplifica la configuración del clúster.

Las cargas de trabajo de IA y AA, como el entrenamiento distribuido, requieren una aceleración potente para optimizar el rendimiento reduciendo los tiempos de finalización de los trabajos. 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 entrenamiento previo distribuido de alto rendimiento, ajuste de modelos, inferencia de modelos, entrega de aplicaciones y servicios de asistencia. Para las cargas de trabajo que requieren un alto rendimiento, una alta capacidad de procesamiento y una baja latencia, el RDMA de GPUDirect reduce los saltos de red que se necesitan para transferir cargas útiles desde y hacia las GPU. Este enfoque usa de manera más eficiente el ancho de banda de red disponible. Para obtener más información, consulta Pilas de redes de GPU.

En este documento, aprenderás a crear un clúster de GKE con Google Cloud CLI para obtener la máxima flexibilidad en la configuración de tu clúster según las necesidades de tu carga de trabajo. Para usar gcloud CLI y crear clústeres con otros tipos de máquinas, consulta lo siguiente:

Como alternativa, puedes usar Cluster Toolkit para implementar con rapidez tu clúster con la configuración predeterminada que refleja las prácticas recomendadas para muchos casos de uso. Para obtener más información, consulta Crea un clúster de GKE optimizado para IA con Cluster Toolkit.

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
  • Para usar Google Cloud CLI en esta tarea, instala y, luego, inicializa la gcloud CLI. Si ya instalaste gcloud CLI, ejecuta el comando gcloud components update para obtener la versión más reciente. Es posible que las versiones anteriores de gcloud CLI no admitan la ejecución de los comandos de este documento.

Roles obligatorios

Para obtener los permisos que necesitas para crear y administrar un clúster de GKE, pídele a tu administrador que te otorgue los siguientes roles de IAM:

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Obtén capacidad

Puedes obtener capacidad para las instancias de procesamiento A4X Max creando una reserva futura. Para obtener más información sobre las reservas futuras, consulta la columna Reservas futuras en AI Hypercomputer en la tabla Elige una opción de consumo.

Para obtener capacidad con una reserva futura, consulta la fila Reservas futuras en AI Hypercomputer en la tabla Cómo obtener capacidad.

Requisitos

Los siguientes requisitos se aplican a un clúster de GKE optimizado para IA con instancias de procesamiento A4X Max:

  • Para A4X Max, debes usar una de las siguientes versiones:

    • Para la versión 1.35 o posterior, usa la versión 1.35.0-gke.2745000 o posterior de GKE.
    • Para la versión 1.34, usa la versión 1.34.3-gke.1318000 o una posterior de GKE.

    Estas versiones ayudan a garantizar que A4X Max use lo siguiente:

    • R580.95.05, la versión mínima del controlador de GPU para A4X Max, que está habilitada de forma predeterminada.
    • Administración de la memoria basada en controladores coherentes (CDMM), que está habilitada de forma predeterminada. NVIDIA recomienda que los clústeres de Kubernetes habiliten este modo para resolver el exceso de informes de memoria. CDMM permite que la memoria de la GPU se administre a través del controlador en lugar del sistema operativo (SO). Este enfoque te ayuda a evitar que el SO ponga en línea la memoria de la GPU y expone la memoria de la GPU como un nodo de acceso no uniforme a memoria (NUMA) para el SO. Las GPU de instancias múltiples no se admiten cuando la CDMM está habilitada. Para obtener más información sobre CDMM, consulta Asistencia de hardware y software.
    • GPUDirect RDMA y MNNVL, que se recomiendan para habilitar los grupos de nodos de A4X Max y usar las capacidades de red de A4X Max.

  • Los nodos de GKE deben usar una imagen de nodo de Container-Optimized OS. Las imágenes de nodos de Ubuntu y Windows no son compatibles.

  • Tu carga de trabajo de GKE debe usar todas las GPUs disponibles y tu Pod debe usar todas las NICs secundarias disponibles en un solo nodo de GKE. Varios Pods no pueden compartir RDMA en un solo nodo de GKE.

  • Debes usar el modelo de aprovisionamiento vinculado a la reserva para crear clústeres con A4X Max. No se admiten otros modelos de aprovisionamiento.

  • En estas instrucciones, se usa DRANET para configurar un clúster de GKE optimizado para IA con A4X Max. No se admiten las redes múltiples para el tipo de máquina a4x-maxgpu-4g-metal.

Consideraciones para crear un clúster

Cuando crees un clúster, ten en cuenta la siguiente información:

  • Elige una ubicación para el clúster:
    • Verifica que uses una ubicación que tenga disponibilidad para el tipo de máquina que elijas. Para obtener más información, consulta Disponibilidad de aceleradores.
    • Cuando creas grupos de nodos en un clúster regional, que se recomiendan para las cargas de trabajo de producción, puedes usar la marca --node-locations para especificar las zonas de tus nodos de GKE.
  • Elige una versión del controlador:
    • La versión del controlador puede ser uno de los siguientes valores:
      • default: Instala la versión predeterminada del controlador para tu versión de GKE de nodos. Para obtener más información sobre los requisitos de las versiones predeterminadas de los controladores, consulta la sección Requisitos.
      • latest: Instala la última versión del controlador disponible para tu versión de GKE. Esta opción solo está disponible para los nodos que usan Container-Optimized OS.
      • disabled: Omite la instalación automática del controlador. Debes instalar un controlador de forma manual después de crear el grupo de nodos.
    • Para obtener más información sobre las versiones predeterminadas y más recientes de los controladores de GPU para las versiones de nodos de GKE, consulta la tabla en la sección Instala controladores de GPU de NVIDIA de forma manual.

  • Elige una afinidad de reserva:

    • Puedes encontrar información sobre tu reserva, como el nombre de tu reserva o el nombre de un bloque específico en tu reserva. Para encontrar estos valores, consulta Visualiza las solicitudes de reserva futura.
    • La marca --reservation-affinity puede tomar los valores de specific o any. Sin embargo, para las cargas de trabajo de IA distribuidas de alto rendimiento, te recomendamos que uses una reserva específica.

    • Cuando uses una reserva específica, incluidas las reservas compartidas, especifica el valor de la marca --reservation en el siguiente formato:

      projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME

      Reemplaza los siguientes valores:

      • PROJECT_ID: Es el ID del proyecto de Google Cloud .
      • RESERVATION_NAME: Es el nombre de tu reserva.
      • BLOCK_NAME: Es el nombre de un bloque específico dentro de la reserva.

      También te recomendamos que uses una reserva orientada a un subbloque para que las instancias de procesamiento se ubiquen en un solo subbloque dentro del BLOCK_NAME. Agrega lo siguiente al final de la ruta:

      /reservationSubBlocks/SUB_BLOCK_NAME

      Reemplaza SUB_BLOCK_NAME por el nombre del subbloque.

Crea un clúster de GKE optimizado para IA que use A4X Max y RDMA de GPUDirect

En el caso de las cargas de trabajo de IA distribuidas, se suelen vincular varios nodos de GPU para que funcionen como una sola computadora. A4X Max es una plataforma de exaescala basada en la arquitectura de escala de bastidor NVIDIA GB300 NVL72. Las instancias de procesamiento A4X Max usan una arquitectura de red jerárquica de varias capas con un diseño encarrilado para optimizar el rendimiento de varios tipos de comunicación. Este tipo de máquina permite el escalamiento y la colaboración en varias GPUs, ya que ofrece una experiencia de nube de alto rendimiento para las cargas de trabajo de IA. Para obtener más información sobre la arquitectura de red de A4X Max, incluido el ancho de banda de red y la disposición de las NIC, consulta Tipo de máquina A4X Max (bare metal).

Para crear un clúster de GKE Standard con A4X Max que use GPUDirect RDMA y MNNVL, completa los pasos que se describen en las siguientes secciones:

  1. Crea el clúster de GKE
  2. Crea una política de cargas de trabajo
  3. Crea un grupo de nodos con A4X Max
  4. Configura las NIC de MRDMA con asapd-lite
  5. Instala el CRD de Compute Domain de NVIDIA y el controlador de DRA
  6. Configura el manifiesto de tu carga de trabajo para el dominio de RDMA y IMEX

En estas instrucciones, se usan perfiles de red de acelerador para configurar automáticamente las redes y subredes de VPC para tus nodos A4X Max. Como alternativa, puedes especificar de forma explícita tu red de VPC y subredes.

Crea el clúster de GKE

  1. Crea un clúster de GKE Standard:

    gcloud container clusters create CLUSTER_NAME \
  --enable-dataplane-v2 \
  --enable-ip-alias \
  --location=COMPUTE_REGION \
  --cluster-version=CLUSTER_VERSION [\
  --services-ipv4-cidr=SERVICE_CIDR \
  --cluster-ipv4-cidr=POD_CIDR \
  --addons=GcpFilestoreCsiDriver=ENABLED]

    Reemplaza lo siguiente:

    • CLUSTER_NAME: El nombre de tu clúster.
    • CLUSTER_VERSION: es la versión del clúster nuevo. Para obtener más información sobre qué versión de GKE admite tu configuración, consulta los Requisitos en este documento.
    • COMPUTE_REGION: Es el nombre de la región de procesamiento.

    • De manera opcional, puedes proporcionar de forma explícita los rangos de CIDR secundarios para los servicios y Pods. Si usas estas marcas opcionales, reemplaza las siguientes variables:

      • SERVICE_CIDR: Es el rango CIDR secundario para los servicios.
      • POD_CIDR: Es el rango CIDR secundario para los Pods.

      Cuando usas estas marcas, debes verificar que los rangos CIDR no se superpongan con los rangos de subred de las redes de nodos adicionales. Por ejemplo, considera SERVICE_CIDR=10.65.0.0/19 y POD_CIDR=10.64.0.0/19. Para obtener más información, consulta Agrega rangos de direcciones IPv4 de Pod.

  2. Para ejecutar los comandos de kubectl en las siguientes secciones, conéctate a tu clúster:

    gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGION

    Reemplaza lo siguiente:

    • CLUSTER_NAME: El nombre de tu clúster.
    • COMPUTE_REGION: Es el nombre de la región de procesamiento.

    Para obtener más información, consulta Instala kubectl y configura el acceso al clúster.

Crear una política de cargas de trabajo

Se requiere una política de cargas de trabajo para crear una partición. Para obtener más información, consulta Política de cargas de trabajo para MIG.

Crea una política de cargas de trabajo HIGH_THROUGHPUT con el campo accelerator_topology establecido en 1x72.

gcloud beta compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \
    --type HIGH_THROUGHPUT \
    --accelerator-topology 1x72 \
    --project PROJECT \
    --region COMPUTE_REGION

Reemplaza lo siguiente:

  • WORKLOAD_POLICY_NAME: Es el nombre de tu política de carga de trabajo.
  • PROJECT: nombre del proyecto.
  • COMPUTE_REGION: Es el nombre de la región de procesamiento.

Crea un grupo de nodos con A4X Max

  1. Crea el siguiente archivo de configuración para asignar previamente páginas grandes con el grupo de nodos:

    cat > node_custom.yaml <<EOF
linuxConfig:
  hugepageConfig:
    hugepage_size2m: 4096
EOF

export NODE_CUSTOM=node_custom.yaml

  2. Crea un grupo de nodos A4X Max. La marca --accelerator-network-profile=auto crea automáticamente una red que conecta todos los nodos de A4X Max dentro de una sola zona:

    gcloud container node-pools create NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=COMPUTE_REGION \
    --node-locations=COMPUTE_ZONE \
    --num-nodes=NODE_COUNT \
    --placement-policy=WORKLOAD_POLICY_NAME \
    --machine-type=a4x-maxgpu-4g-metal \
    --accelerator=type=nvidia-gb300,count=4,gpu-driver-version=latest \
    --system-config-from-file=${NODE_CUSTOM} \
    --accelerator-network-profile=auto \
    --node-labels=cloud.google.com/gke-networking-dra-driver=true,cloud.google.com/gke-dpv2-unified-cni=cni-migration \
    --reservation-affinity=specific \
    --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME/reservationSubBlocks/SUB_BLOCK_NAME

    Reemplaza lo siguiente:

    • NODE_POOL_NAME: el nombre del grupo de nodos
    • CLUSTER_NAME: El nombre de tu clúster.
    • COMPUTE_REGION: la región de procesamiento del clúster.
    • COMPUTE_ZONE: Es la zona de tu grupo de nodos.
    • NODE_COUNT: Es la cantidad de nodos para el grupo de nodos, que debe ser de 18 nodos o menos. Te recomendamos usar 18 nodos para obtener la topología de GPU de 1x72 en un subbloque con un dominio de NVLink.
    • WORKLOAD_POLICY_NAME: Es el nombre de la política de carga de trabajo que creaste antes.
    • RESERVATION_NAME: Es el nombre de tu reserva. Para encontrar este valor, consulta Visualiza las solicitudes de reserva futuras.
    • BLOCK_NAME: Es el nombre de un bloque específico dentro de la reserva. Para encontrar este valor, consulta Visualiza las solicitudes de reserva futuras.

Configura las NIC de MRDMA con asapd-lite

El DaemonSet asapd-lite configura las NIC de MRDMA. Un DaemonSet asapd-lite en mal estado podría indicar que no hay conectividad RDMA.

  1. Instala el DaemonSet:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/asapd-lite-installer/asapd-lite-installer-a4x-max-bm-cos.yaml

  2. Valida las réplicas en el DaemonSet asapd-lite:

    kubectl get daemonset -n kube-system asapd-lite

    El resultado es similar a lo siguiente:

    NAME         DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
asapd-lite   18        18        18      18           18          <none>          5m

    La cantidad de réplicas de READY debe coincidir con la cantidad de nodos que se crearon y están en buen estado en el grupo de nodos.

Instala el CRD de dominio de procesamiento de NVIDIA y el controlador de DRA

En los siguientes pasos, se instalan el CRD de Compute Domain de NVIDIA y el controlador de DRA para habilitar el uso de MNNVL. Para obtener más información, consulta Controlador de DRA de NVIDIA para GPU.

  1. Verifica que tengas Helm instalado en tu entorno de desarrollo. Helm forma parte de las herramientas instaladas previamente en Cloud Shell.

    Si bien no hay un requisito específico de una versión de Helm, puedes usar el siguiente comando para verificar que tengas Helm instalado.

    helm version

    Si el resultado es similar a Command helm not found, puedes instalar la CLI de Helm:

    curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 \
  && chmod 700 get_helm.sh \
  && ./get_helm.sh

  2. Agrega el repositorio de Helm para NVIDIA:

    helm repo add nvidia https://helm.ngc.nvidia.com/nvidia \
  && helm repo update

  3. Crea un objeto ResourceQuota para el controlador de DRA:

    export POD_QUOTA=POD_QUOTA

kubectl create ns nvidia-dra-driver-gpu

kubectl apply -n nvidia-dra-driver-gpu -f - << EOF
apiVersion: v1
kind: ResourceQuota
metadata:
  name: nvidia-dra-driver-gpu-quota
spec:
  hard:
    pods: ${POD_QUOTA}
  scopeSelector:
    matchExpressions:
    - operator: In
      scopeName: PriorityClass
      values:
        - system-node-critical
        - system-cluster-critical
EOF

    Reemplaza POD_QUOTA por un número que sea, al menos, el doble de la cantidad de nodos A4X Max en el clúster más 1. Por ejemplo, debes establecer la variable en al menos 37 si tienes 18 nodos A4X Max en tu clúster.

  4. Instala la CRD de ComputeDomain y el controlador de DRA:

    helm install nvidia-dra-driver-gpu nvidia/nvidia-dra-driver-gpu \
    --set controller.args.v=4 --set kubeletPlugin.args.v=4 \
    --version="25.8.0" \
    --create-namespace \
    --namespace nvidia-dra-driver-gpu \
    -f <(cat <<EOF
nvidiaDriverRoot: /home/kubernetes/bin/nvidia
resources:
  gpus:
    enabled: false

controller:
  affinity:
      nodeAffinity:
        requiredDuringSchedulingIgnoredDuringExecution:
          nodeSelectorTerms:
          - matchExpressions:
            - key: "nvidia.com/gpu"
              operator: "DoesNotExist"

kubeletPlugin:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: cloud.google.com/gke-accelerator
                operator: In
                values:
                  - nvidia-gb300
              - key: kubernetes.io/arch
                operator: In
                values:
                  - arm64

  tolerations:
    - key: nvidia.com/gpu
      operator: Equal
      value: present
      effect: NoSchedule
    - key: kubernetes.io/arch
      operator: Equal
      value: arm64
      effect: NoSchedule
EOF
)

Configura el manifiesto de tu carga de trabajo para el dominio de RDMA y IMEX

  1. Agrega una regla de afinidad de nodos para programar la carga de trabajo en nodos Arm:

    spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        -   matchExpressions:
          -   key: kubernetes.io/arch
            operator: In
            values:
            -   arm64

  2. Agrega el siguiente volumen a la especificación del Pod:

    spec:
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia

  3. Agrega las siguientes activaciones de volumen, variable de entorno y recurso al contenedor que solicita GPUs. El contenedor de tu carga de trabajo debe solicitar las cuatro GPU:

    containers:
  - name: my-container
    volumeMounts:
      - name: library-dir-host
        mountPath: /usr/local/nvidia

    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
    resources:
      limits:
        nvidia.com/gpu: 4

  4. Crea el recurso ComputeDomain para la carga de trabajo:

    apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
  name: a4x-max-compute-domain
spec:
  numNodes: NUM_NODES
  channel:
    resourceClaimTemplate:
      name: a4x-max-compute-domain-channel

    Reemplaza NUM_NODES por la cantidad de nodos que requiere la carga de trabajo.

  5. Crea un ResourceClaimTemplate para asignar recursos de red con DRANET y solicitar dispositivos RDMA para tu Pod:

    apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: all-mrdma
spec:
  spec:
    devices:
      requests:
      - name: req-mrdma
        exactly:
          deviceClassName: mrdma.google.com
          allocationMode: ExactCount
          count: 8

  6. Especifica la ResourceClaimTemplate que usa el Pod:

    spec:
  ...
  volumes:
    ...
  containers:
    - name: my-container
      ...
      resources:
        limits:
          nvidia.com/gpu: 4
  claims:
          - name: compute-domain-channel
          - name: rdma
        ...
resourceClaims:
  - name: compute-domain-channel
    resourceClaimTemplateName: a4x-max-compute-domain-channel
  - name: rdma
    resourceClaimTemplateName: all-mrdma

  7. Instala las bibliotecas de espacio de usuario más recientes en tu imagen de contenedor:

    Debian 12+/Ubuntu 20.04+ (paquete .deb)

    apt update
apt install curl

# Fetch DOCA OFED userspace libraries
export DOCA_URL="https://linux.mellanox.com/public/repo/doca/latest/ubuntu22.04/arm64-sbsa/"
export BASE_URL="https://linux.mellanox.com/public/repo/doca"
curl "${BASE_URL}/GPG-KEY-Mellanox.pub" | gpg --dearmor -o /etc/apt/trusted.gpg.d/GPG-KEY-Mellanox.pub
echo "deb [signed-by=/etc/apt/trusted.gpg.d/GPG-KEY-Mellanox.pub] ${DOCA_URL} ./" | tee /etc/apt/sources.list.d/doca.list

apt update
apt install doca-ofed-userspace

# Upgrade to latest NCCL for best compatibility
apt install --only-upgrade --allow-change-held-packages libnccl2 libnccl-dev

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

apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
  name: a4x-max-compute-domain
spec:
  numNodes:  NUM_NODES
  channel:
    resourceClaimTemplate:
      name: a4x-max-compute-domain-channel
---
apiVersion: apps/v1
kind: Pod
metadata:
  name: my-pod
  labels:
    k8s-app: my-pod
spec:
  ...
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: kubernetes.io/arch
            operator: In
            values:
            - arm64
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
  hostNetwork: true
  containers:
    - name: my-container
      volumeMounts:
        - name: library-dir-host
          mountPath: /usr/local/nvidia
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      resources:
        limits:
          nvidia.com/gpu: 4
        claims:
          - name: compute-domain-channel
          - name: rdma
        ...
  resourceClaims:
    - name: compute-domain-channel
      resourceClaimTemplateName: a4x-max-compute-domain-channel
    - name: rdma
      resourceClaimTemplateName: all-mrdma

Prueba el rendimiento de las redes

Te recomendamos que valides la funcionalidad de los clústeres aprovisionados. Para hacerlo, usa las pruebas de NCCL/gIB, que son pruebas de la biblioteca de comunicaciones colectivas de NVIDIA (NCCL) optimizadas para el entorno de Google.

Para obtener más información, consulta Ejecuta NCCL en clústeres de GKE que usan A4X Max.

¿Qué sigue?