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 usa instancias A4X Max de Compute Engine 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 ubicación de cargas de trabajo segmentadas, la programación consciente de la topología y los controles avanzados de mantenimiento de clústeres. Para obtener más información, consulta Capacidades 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 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 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 para 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 de este documento.

Obtén capacidad

Para obtener capacidad para instancias de procesamiento de A4X Max, crea una reserva futura. Para obtener más información sobre las reservas futuras, consulta la columna Future reservations in AI Hypercomputer en la tabla para Choose a consumption option.

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

Requisitos

Los siguientes requisitos se aplican a un clúster de GKE optimizado para IA con instancias de procesamiento de 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 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 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 controladores (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 GPU se administre a través del controlador en lugar del sistema operativo (SO). Este enfoque te ayuda a evitar la conexión en línea del SO de la memoria de GPU y expone la memoria de GPU como un nodo de acceso a la memoria no uniforme (NUMA) al SO. No se admiten las GPU de instancias múltiples cuando CDMM está habilitado. Para obtener más información sobre CDMM, consulta Compatibilidad de hardware y software Support.
    • GPUDirect RDMA y MNNVL, que se recomiendan para habilitar los grupos de nodos de A4X Max para usar 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 GPU 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 varias redes para el tipo de máquina a4x-maxgpu-4g-metal.

Consideraciones para crear un clúster

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

  • Elige una ubicación del 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 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 tener 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 predeterminadas del controlador, 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 del controlador de GPU para las versiones de nodo 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 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 usas 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 Google Cloud proyecto de.
      • 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 segmentada de subbloque para que las instancias de procesamiento se coloquen en un solo subbloque dentro de 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

Para 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 de rack NVIDIA GB300 NVL72. Las instancias de procesamiento de A4X Max usan una arquitectura de redes 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 GPU, 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 para A4X Max, incluido el ancho de banda de 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. Crear una política de cargas de trabajo
  3. Crea un grupo de nodos con A4X Max
  4. Configura las NICs de MRDMA con asapd-lite
  5. Instala la CRD de 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 IMEX

En estas instrucciones, se usan perfiles de red de acelerador para configurar automáticamente las redes de VPC y las subredes para tus nodos de 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: 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: El rango CIDR secundario para los servicios.
      • POD_CIDR: El rango CIDR secundario para los Pods.

      Cuando usas estas marcas, debes verificar que los rangos de CIDR no se superpongan con los rangos de subred 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 Agrega rangos de direcciones IPv4 de Pods.

  2. Para ejecutar los comandos 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: 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 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 cargas de trabajo.
  • PROJECT: El nombre de tu proyecto.
  • COMPUTE_REGION: 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 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 de 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: La región de procesamiento del clúster.
    • COMPUTE_ZONE: La zona de tu grupo de nodos.
    • NODE_COUNT: La cantidad de nodos para el grupo de nodos, que debe ser de 18 nodos o menos. Te recomendamos que uses 18 nodos para obtener la topología de GPU de 1x72 en un subbloque con un dominio NVLink.
    • WORKLOAD_POLICY_NAME: 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 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.

    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 de 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 NICs de MRDMA con asapd-lite

El DaemonSet asapd-lite configura las NICs 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 este:

    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 READY debe coincidir con la cantidad de nodos que se crearon y están en buen estado en el grupo de nodos.

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

En los siguientes pasos, se instala la CRD de dominio de procesamiento 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 2 veces la cantidad de nodos de A4X Max en el clúster más 1. Por ejemplo, debes establecer la variable en al menos 37 si tienes 18 nodos de 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 GPU. 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 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 de usuario y los paquetes 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 las redes

Te recomendamos que valides la funcionalidad de los clústeres aprovisionados. Para ello, usa las pruebas 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 personalizados que usan A4X Max.

¿Qué sigue?