Créer un cluster GKE personnalisé optimisé pour l'IA qui utilise A4X Max

Ce document explique comment créer un cluster Google Kubernetes Engine (GKE) optimisé pour l'IA qui utilise des instances Compute Engine A4X Max pour prendre en charge vos charges de travail d'IA et de ML.

Les séries A4X Max et A4X vous permettent d'exécuter des clusters d'IA/ML à grande échelle à l'aide du système NVIDIA Multi-Node NVLink (MNNVL), une solution à l'échelle du rack qui permet d'augmenter la puissance et les performances des GPU. Ces machines offrent des fonctionnalités telles que le placement ciblé des charges de travail, la planification tenant compte de la topologie et des contrôles avancés de maintenance des clusters. Pour en savoir plus, consultez Fonctionnalités de gestion des clusters. Avec A4X Max, GKE fournit également une configuration réseau automatisée qui simplifie la configuration des clusters.

Les charges de travail d'IA et de ML, telles que l'entraînement distribué, nécessitent une accélération puissante pour optimiser les performances en réduisant les délais d'exécution des tâches. GKE fournit une plate-forme unique pour exécuter un ensemble varié de charges de travail pour vos organisations, ce qui réduit la charge opérationnelle liée à la gestion de plusieurs plates-formes. Vous pouvez exécuter des charges de travail telles que le pré-entraînement distribué hautes performances, le réglage précis des modèles, l'inférence de modèles, la diffusion d'applications et les services d'assistance. Pour les charges de travail qui nécessitent de hautes performances, un débit élevé et une faible latence, GPUDirect RDMA réduit le nombre de sauts réseau nécessaires pour transférer des charges utiles vers et depuis les GPU. Cette approche utilise plus efficacement la bande passante réseau disponible. Pour en savoir plus, consultez Piles de mise en réseau des GPU.

Dans ce document, vous allez apprendre à créer un cluster GKE avec la Google Cloud CLI pour configurer votre cluster de manière aussi flexible que possible en fonction des besoins de votre charge de travail. Pour utiliser la gcloud CLI afin de créer des clusters avec d'autres types de machines, consultez les ressources suivantes :

Vous pouvez également choisir d'utiliser Cluster Toolkit pour déployer rapidement votre cluster avec des paramètres par défaut qui reflètent les bonnes pratiques pour de nombreux cas d'utilisation. Pour en savoir plus, consultez Créer un cluster GKE optimisé pour l'IA avec la configuration par défaut.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

  • Activez l'API Google Kubernetes Engine.
    • Activer l'API Google Kubernetes Engine
  • Si vous souhaitez utiliser la Google Cloud CLI pour cette tâche, installez et initialisez la gcloud CLI. Si vous avez déjà installé la gcloud CLI, obtenez la dernière version en exécutant la commande gcloud components update. Il est possible que les versions antérieures de la gcloud CLI ne permettent pas d'exécuter les commandes de ce document.

Obtenir de la capacité

Vous pouvez obtenir de la capacité pour les instances de calcul A4X Max en créant une réservation future. Pour en savoir plus sur les réservations futures, consultez la colonne Réservations futures dans AI Hypercomputer du tableau Choisir une option de consommation.

Pour obtenir de la capacité avec une réservation future, consultez la ligne Réservations futures dans AI Hypercomputer du tableau Obtenir de la capacité.

Conditions requises

Les exigences suivantes s'appliquent à un cluster GKE optimisé pour l'IA avec des instances de calcul A4X Max :

  • Pour A4X Max, vous devez utiliser l'une des versions suivantes :

    • Pour la version 1.35 ou ultérieure, utilisez GKE version 1.35.0-gke.2745000 ou ultérieure.
    • Pour la version 1.34, utilisez GKE version 1.34.3-gke.1318000 ou ultérieure.

    Ces versions permettent de s'assurer qu'A4X Max utilise les éléments suivants :

    • R580.95.05, la version minimale du pilote GPU pour A4X Max, qui est activée par défaut.
    • Coherent Driver-based Memory Management (CDMM), qui est activé par défaut. NVIDIA recommande aux clusters Kubernetes d'activer ce mode pour résoudre le problème de surdéclaration de la mémoire. CDMM permet de gérer la mémoire GPU via le pilote au lieu du système d'exploitation. Cette approche vous aide à éviter la mise en ligne de la mémoire GPU par l'OS et expose la mémoire GPU en tant que nœud NUMA (Non-Uniform Memory Access) à l'OS. Les GPU multi-instances ne sont pas compatibles lorsque CDMM est activé. Pour en savoir plus sur CDMM, consultez Assistance matérielle et logicielle.
    • GPUDirect RDMA et MNNVL, qui sont recommandés pour permettre aux pools de nœuds A4X Max d'utiliser les fonctionnalités réseau d'A4X Max.

  • Les nœuds GKE doivent utiliser une image de nœud Container-Optimized OS. Les images de nœuds Ubuntu et Windows ne sont pas acceptées.

  • Votre charge de travail GKE doit utiliser tous les GPU disponibles, et votre pod doit utiliser toutes les cartes d'interface réseau secondaires disponibles sur un seul nœud GKE. Plusieurs pods ne peuvent pas partager RDMA sur un même nœud GKE.

  • Vous devez utiliser le modèle de provisionnement lié à la réservation pour créer des clusters avec A4X Max. Les autres modèles de provisionnement ne sont pas compatibles.

  • Ces instructions utilisent DRANET pour configurer un cluster GKE optimisé pour l'IA avec A4X Max. Le multiréseau n'est pas compatible avec le type de machine a4x-maxgpu-4g-metal.

Éléments à prendre en compte pour créer un cluster

Lorsque vous créez un cluster, tenez compte des informations suivantes :

  • Choisissez l'emplacement d'un cluster :
    • Vérifiez que vous utilisez un emplacement où le type de machine que vous choisissez est disponible. Pour en savoir plus, consultez Disponibilité des accélérateurs.
    • Lorsque vous créez des pools de nœuds dans un cluster régional (recommandés pour les charges de travail de production), vous pouvez utiliser l'option --node-locations pour spécifier les zones de vos nœuds GKE.
  • Choisissez une version du pilote :
    • La version du pilote peut être l'une des valeurs suivantes :
      • default : installe la version par défaut du pilote pour la version de nœud GKE. Pour en savoir plus sur les exigences concernant les versions de pilote par défaut, consultez la section Exigences.
      • latest : installe la dernière version de pilote disponible pour votre version de GKE. Cette option n'est disponible que pour les nœuds qui utilisent Container-Optimized OS.
      • disabled : ignorer l'installation automatique du pilote. Vous devez installer manuellement un pilote après avoir créé le pool de nœuds.
    • Pour en savoir plus sur les versions de pilote de GPU par défaut et les plus récentes pour les versions de nœud GKE, consultez le tableau de la section Installer manuellement les pilotes de GPU NVIDIA.

  • Choisir une affinité de réservation :

    • Vous pouvez trouver des informations sur votre réservation, comme son nom ou celui d'un bloc spécifique. Pour trouver ces valeurs, consultez Afficher les demandes de réservations futures.
    • L'indicateur --reservation-affinity peut prendre les valeurs specific ou any. Toutefois, pour les charges de travail d'IA distribuées à hautes performances, nous vous recommandons d'utiliser une réservation spécifique.

    • Lorsque vous utilisez une réservation spécifique, y compris les réservations partagées, spécifiez la valeur de l'indicateur --reservation au format suivant :

      projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME

      Remplacez les valeurs suivantes :

      • PROJECT_ID : ID de votre projet Google Cloud .
      • RESERVATION_NAME : nom de votre réservation.
      • BLOCK_NAME : nom d'un bloc spécifique dans la réservation.

      Nous vous recommandons également d'utiliser une réservation ciblée sur un sous-bloc afin que les instances de calcul soient placées sur un seul sous-bloc dans BLOCK_NAME. Ajoutez les éléments suivants à la fin du chemin d'accès :

      /reservationSubBlocks/SUB_BLOCK_NAME

      Remplacez SUB_BLOCK_NAME par le nom du sous-bloc.

Créer un cluster GKE optimisé pour l'IA qui utilise A4X Max et GPUDirect RDMA

Pour les charges de travail d'IA distribuées, plusieurs nœuds GPU sont souvent associés pour fonctionner comme un seul ordinateur. A4X Max est une plate-forme exaflopique basée sur l'architecture rack NVIDIA GB300 NVL72. Les instances de calcul A4X Max utilisent une architecture réseau hiérarchique multicouche avec une conception alignée sur rails pour optimiser les performances pour différents types de communication. Ce type de machine permet de mettre à l'échelle et de collaborer sur plusieurs GPU en offrant une expérience cloud hautes performances pour les charges de travail d'IA. Pour en savoir plus sur l'architecture réseau d'A4X Max, y compris sur la bande passante réseau et la configuration des cartes d'interface réseau, consultez Type de machine A4X Max (bare metal).

Pour créer un cluster GKE Standard avec A4X Max qui utilise GPUDirect RDMA et MNNVL, suivez les étapes décrites dans les sections suivantes :

  1. Créer le cluster GKE
  2. Créer une règle de charge de travail
  3. Créer un pool de nœuds avec A4X Max
  4. Configurer les cartes d'interface réseau MRDMA avec asapd-lite
  5. Installer le pilote CRD et DRA du domaine de calcul NVIDIA
  6. Configurer le fichier manifeste de votre charge de travail pour le domaine RDMA et IMEX

Ces instructions utilisent des profils de réseau d'accélérateur pour configurer automatiquement les réseaux et sous-réseaux VPC pour vos nœuds A4X Max. Vous pouvez également spécifier explicitement votre réseau VPC et vos sous-réseaux.

Créer le cluster GKE

  1. Créez un cluster 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]

    Remplacez les éléments suivants :

    • CLUSTER_NAME : nom du cluster
    • CLUSTER_VERSION : version de votre nouveau cluster Pour savoir quelle version de GKE est compatible avec votre configuration, consultez la section Exigences de ce document.
    • COMPUTE_REGION : nom de la région de calcul.

    • Vous pouvez éventuellement fournir explicitement les plages CIDR secondaires pour les services et les pods. Si vous utilisez ces indicateurs facultatifs, remplacez les variables suivantes :

      • SERVICE_CIDR : plage CIDR secondaire pour les services.
      • POD_CIDR : plage CIDR secondaire des pods.

      Lorsque vous utilisez ces indicateurs, vous devez vérifier que les plages CIDR ne chevauchent pas les plages de sous-réseaux pour les réseaux de nœuds supplémentaires. Par exemple, prenons SERVICE_CIDR=10.65.0.0/19 et POD_CIDR=10.64.0.0/19. Pour en savoir plus, consultez Ajouter des plages d'adresses IPv4 de pods.

  2. Pour exécuter les commandes kubectl dans les sections suivantes, connectez-vous à votre cluster :

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

    Remplacez les éléments suivants :

    • CLUSTER_NAME : nom du cluster
    • COMPUTE_REGION : nom de la région de calcul.

    Pour en savoir plus, consultez Installer kubectl et configurer l'accès au cluster.

Créer une règle de charge de travail

Vous devez disposer d'une règle de charge de travail pour créer une partition. Pour en savoir plus, consultez la Règle de charge de travail pour les MIG.

Créez une règle de charge de travail HIGH_THROUGHPUT avec le champ accelerator_topology défini sur 1x72.

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

Remplacez les éléments suivants :

  • WORKLOAD_POLICY_NAME : nom de votre règle de charge de travail.
  • PROJECT : nom de votre projet.
  • COMPUTE_REGION : nom de la région de calcul.

Créer un pool de nœuds avec A4X Max

  1. Créez le fichier de configuration suivant pour préallouer des huge pages avec le pool de nœuds :

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

export NODE_CUSTOM=node_custom.yaml

  2. Créez un pool de nœuds 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

    Remplacez les éléments suivants :

    • NODE_POOL_NAME : nom du pool de nœuds.
    • CLUSTER_NAME : nom du cluster
    • COMPUTE_REGION : région de calcul du cluster.
    • COMPUTE_ZONE : zone de votre pool de nœuds.
    • NODE_COUNT : nombre de nœuds pour le pool de nœuds, qui doit être inférieur ou égal à 18. Nous vous recommandons d'utiliser 18 nœuds pour obtenir la topologie GPU 1x72 dans un sous-bloc à l'aide d'un domaine NVLink.
    • WORKLOAD_POLICY_NAME : nom de la règle de charge de travail que vous avez créée précédemment.
    • RESERVATION_NAME : nom de votre réservation. Pour trouver cette valeur, consultez Afficher les demandes de réservations futures.
    • BLOCK_NAME : nom d'un bloc spécifique dans la réservation. Pour trouver cette valeur, consultez Afficher les demandes de réservations futures.

    Cette commande crée automatiquement un réseau qui connecte tous les nœuds A4X Max d'une même zone à l'aide du profil de réseau d'accélérateurs auto. Lorsque vous créez un pool de nœuds avec l'indicateur --accelerator-network-profile=auto, GKE ajoute automatiquement le libellé gke.networks.io/accelerator-network-profile: auto aux nœuds. Pour planifier des charges de travail sur ces nœuds, vous devez inclure ce libellé dans le champ nodeSelector de votre charge de travail.

Configurez les cartes d'interface réseau MRDMA avec asapd-lite

Le DaemonSet asapd-lite configure les cartes d'interface réseau MRDMA. Un DaemonSet asapd-lite non opérationnel peut indiquer une absence de connectivité RDMA.

  1. Installez le 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. Validez les répliques dans le DaemonSet asapd-lite :

    kubectl get daemonset -n kube-system asapd-lite

    Le résultat ressemble à ce qui suit :

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

    Le nombre de répliques READY doit correspondre au nombre de nœuds créés et opérationnels dans le pool de nœuds.

Installer le pilote CRD et DRA du domaine de calcul NVIDIA

La procédure suivante installe le pilote NVIDIA Compute Domain CRD et DRA pour permettre l'utilisation de MNNVL. Pour en savoir plus, consultez Pilote NVIDIA DRA pour les GPU.

  1. Vérifiez que Helm est installé dans votre environnement de développement. Helm est préinstallé sur Cloud Shell.

    Bien qu'aucune version Helm spécifique ne soit requise, vous pouvez utiliser la commande suivante pour vérifier que Helm est bien installé.

    helm version

    Si le résultat renvoie Command helm not found, vous pouvez installer la CLI 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. Ajoutez le dépôt Helm NVIDIA :

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

  3. Créez un objet ResourceQuota pour le pilote 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

    Remplacez POD_QUOTA par un nombre au moins deux fois supérieur au nombre de nœuds A4X Max dans le cluster, plus 1. Par exemple, vous devez définir la variable sur au moins 37 si votre cluster comporte 18 nœuds A4X Max.

  4. Installez le CRD ComputeDomain et le pilote 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
)

Configurer le fichier manifeste de votre charge de travail pour le domaine RDMA et IMEX

  1. Ajoutez une règle d'affinité de nœuds pour planifier la charge de travail sur les nœuds Arm :

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

  2. Ajoutez le volume suivant à la spécification de pod :

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

  3. Ajoutez les installations de volume, la variable d'environnement et la ressource suivantes au conteneur qui demande des GPU. Le conteneur de votre charge de travail doit demander les quatre 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. Créez la ressource ComputeDomain pour la charge de travail :

    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

    Remplacez NUM_NODES par le nombre de nœuds requis par la charge de travail.

  5. Créez un ResourceClaimTemplate pour allouer des ressources réseau à l'aide de DRANET et demandez des appareils RDMA pour votre 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. Spécifiez le ResourceClaimTemplate utilisé par le 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. Assurez-vous que les bibliothèques userspace et les packages libnccl sont installés dans l'image de conteneur utilisateur :

    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

Une spécification de pod terminée ressemble à ce qui suit :

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

Tester les performances du réseau

Nous vous recommandons de valider le fonctionnement des clusters provisionnés. Pour ce faire, utilisez les tests NCCL/gIB, qui sont des tests NVIDIA Collective Communications Library (NCCL) optimisés pour l'environnement Google.

Pour en savoir plus, consultez Exécuter NCCL sur des clusters GKE personnalisés qui utilisent A4X Max.

Étapes suivantes