Crea un clúster de GKE personalizado y 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/AA a gran escala con el sistema NVIDIA Multi-Node NVLink (MNNVL), una solución a nivel de rack que permite una mayor potencia y rendimiento de la GPU. Estas máquinas ofrecen funciones como la colocación de cargas de trabajo segmentadas, la programación que considera la topología y los controles avanzados de mantenimiento del clúster. 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 redes 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 superficie de plataforma para ejecutar un conjunto diverso de cargas de trabajo para tus organizaciones, lo que reduce la carga operativa de administrar múltiples 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. Para las cargas de trabajo que requieren alto rendimiento, alta capacidad de procesamiento y baja latencia, GPUDirect RDMA reduce los saltos de red necesarios para transferir cargas útiles hacia y desde las GPUs. Este enfoque usa de manera más eficiente el ancho de banda de la 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 tener la máxima flexibilidad a la hora de configurar 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 rápidamente 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 la configuración predeterminada.

Antes de comenzar

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

  • Habilita la API de Google Kubernetes Engine.
    • Habilitar la API de Google Kubernetes Engine
  • Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta 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 que se describen en este documento.

Cómo obtener 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 de la tabla en Elige una opción de consumo.

Para obtener capacidad con una reserva futura, consulta la fila Reservas futuras en AI Hypercomputer en la tabla de 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:

  • En el caso del 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 de GKE o una posterior.
    • Para la versión 1.34, usa la versión 1.34.3-gke.1318000 de GKE o una posterior.

    Estas versiones ayudan a garantizar que el 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 memoria coherente basada en el controlador (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. El 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. No se admiten GPUs de varias instancias cuando CDMM está habilitado. Para obtener más información sobre el CDMM, consulta Compatibilidad con hardware y software.
    • GPUDirect RDMA y MNNVL, que se recomiendan para habilitar los grupos de nodos A4X Max para que usen las capacidades de redes de A4X Max.

  • Los nodos de GKE deben usar una imagen de nodo de Container-Optimized OS. No se admiten las imágenes de nodos de Ubuntu y Windows.

  • 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. Las redes múltiples no son compatibles con 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 la ubicación de un 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 los aceleradores.
    • Cuando creas grupos de nodos en un clúster regional (que se recomienda 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 nodo de GKE. Para obtener más información sobre los requisitos de las versiones de controladores predeterminadas, 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 la reserva o el nombre de un bloque específico en ella. Para encontrar estos valores, consulta Cómo ver solicitudes de reserva futuras.
    • La marca --reservation-affinity puede tomar los valores 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: 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 segmentada por sub-bloque para que las instancias de procesamiento se coloquen en un solo sub-bloque dentro de la BLOCK_NAME. Agrega lo siguiente al final de la ruta de acceso:

      /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 GPUDirect RDMA

En el caso de las cargas de trabajo de IA distribuidas, a menudo se vinculan varios nodos de GPU para que funcionen como una sola computadora. A4X Max es una plataforma de exaescala basada en la arquitectura a nivel de rack NVIDIA GB300 NVL72. Las instancias de procesamiento A4X Max usan una arquitectura de redes jerárquica de varias capas con un diseño alineado con rieles 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 la red y la disposición de la NIC, consulta Tipo de máquina A4X Max (metal desnudo).

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 del dominio de procesamiento de NVIDIA y el controlador de DRA
  6. Configura el manifiesto de tu carga de trabajo para el dominio de RDMA y de IMEX

En estas instrucciones, se usan perfiles de red de aceleradores para configurar automáticamente las redes de VPC y las subredes de tus nodos A4X Max. Como alternativa, puedes especificar de forma explícita tu red de VPC y tus 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 \
  --no-enable-shielded-nodes [\
  --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 los Pods. Si usas estas marcas opcionales, reemplaza las siguientes variables:

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

      Cuando uses estas marcas, debes verificar que los rangos CIDR no se superpongan con los rangos de subredes para 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 Cómo agregar rangos de direcciones IPv4 de Pods.

  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 Cómo instalar kubectl y configurar 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 la política de cargas de trabajo para MIGs.

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: 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 preasignar páginas enormes 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:

    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: Es 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 del grupo de nodos, que debe ser de 18 nodos o menos. 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 cargas de trabajo que creaste anteriormente.
    • RESERVATION_NAME: Es el nombre de tu reserva. Para encontrar este valor, consulta Cómo ver solicitudes de reserva futuras.
    • BLOCK_NAME: Es el nombre de un bloque específico dentro de la reserva. Para encontrar este valor, consulta Cómo ver solicitudes de reserva futuras.

    Este comando crea automáticamente una red que conecta todos los nodos de A4X Max dentro de una sola zona con el perfil de red del acelerador auto. Cuando creas un grupo de nodos con la marca --accelerator-network-profile=auto, GKE agrega automáticamente la etiqueta gke.networks.io/accelerator-network-profile: auto a los nodos. Para programar cargas de trabajo en estos nodos, debes incluir esta etiqueta en el campo nodeSelector de tu carga de trabajo.

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 de 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 del dominio de procesamiento de NVIDIA y el controlador de DRA

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

  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, 2 veces 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, la variable de entorno y el recurso al contenedor que solicita GPUs. El contenedor de tu carga de trabajo debe solicitar las cuatro GPUs:

    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 solicita 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 el 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. Asegúrate de que las bibliotecas del espacio del usuario y los paquetes de libnccl estén instalados en la imagen del contenedor del usuario:

    apt update -y
apt install -y curl
export DOCA_URL="https://linux.mellanox.com/public/repo/doca/3.1.0/ubuntu22.04/arm64-sbsa/"
BASE_URL=$([ "${DOCA_PREPUBLISH:-false}" = "true" ] && echo https://doca-repo-prod.nvidia.com/public/repo/doca || echo https://linux.mellanox.com/public/repo/doca)
DOCA_SUFFIX=${DOCA_URL#*public/repo/doca/}; DOCA_URL="$BASE_URL/$DOCA_SUFFIX"
curl $BASE_URL/GPG-KEY-Mellanox.pub | gpg --dearmor > /etc/apt/trusted.gpg.d/GPG-KEY-Mellanox.pub
echo "deb [signed-by=/etc/apt/trusted.gpg.d/GPG-KEY-Mellanox.pub] $DOCA_URL ./" > /etc/apt/sources.list.d/doca.list
apt update
apt -y install doca-ofed-userspace
# The installed libnccl2 is 2.27.7, to upgrade to 2.28.9 as we recommend
apt install --only-upgrade --allow-change-held-packages -y 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 la red

Te recomendamos que valides la funcionalidad de los clústeres aprovisionados. Para ello, usa las pruebas de NCCL/gIB, que son pruebas de la biblioteca de comunicación colectiva de NVIDIA (NCCL) optimizadas para el entorno de Google.

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

¿Qué sigue?