Crea un cluster GKE personalizzato ottimizzato per l'AI che utilizza A4X Max

Questo documento mostra come creare un cluster Google Kubernetes Engine (GKE) ottimizzato per l'AI che utilizza le istanze di Compute Engine A4X Max per supportare i carichi di lavoro di AI e ML.

Le serie A4X Max e A4X consentono di eseguire cluster AI/ML su larga scala utilizzando il sistema NVIDIA Multi-Node NVLink (MNNVL), una soluzione a livello di rack che consente una maggiore potenza e prestazioni della GPU. Queste macchine offrono funzionalità come il posizionamento mirato dei carichi di lavoro, la pianificazione in base alla topologia e i controlli avanzati di manutenzione dei cluster. Per saperne di più, consulta Funzionalità di gestione dei cluster. Con A4X Max, GKE fornisce anche una configurazione di rete automatizzata che semplifica la configurazione del cluster.

I carichi di lavoro di AI e ML, come l'addestramento distribuito, richiedono un'accelerazione potente per ottimizzare le prestazioni riducendo i tempi di completamento dei job. GKE fornisce una singola superficie della piattaforma per eseguire un insieme diversificato di carichi di lavoro per le tue organizzazioni, riducendo l'onere operativo della gestione di più piattaforme. Puoi eseguire carichi di lavoro come il pre-addestramento distribuito ad alte prestazioni, l'ottimizzazione dei modelli, l'inferenza dei modelli, la pubblicazione delle applicazioni e i servizi di supporto. Per i carichi di lavoro che richiedono prestazioni elevate, throughput elevato e bassa latenza, GPUDirect RDMA riduce gli hop di rete necessari per trasferire i payload da e verso le GPU. Questo approccio utilizza in modo più efficiente la larghezza di banda di rete disponibile. Per saperne di più, consulta Stack di rete GPU.

In questo documento imparerai a creare un cluster GKE con Google Cloud CLI per la massima flessibilità nella configurazione del cluster in base alle esigenze del tuo carico di lavoro. Per utilizzare gcloud CLI per creare cluster con altri tipi di macchine, consulta quanto segue:

In alternativa, puoi scegliere di utilizzare Cluster Toolkit per eseguire rapidamente il deployment del cluster con le impostazioni predefinite che riflettono le best practice per molti casi d'uso. Per saperne di più, consulta Crea un cluster GKE ottimizzato per l'AI con la configurazione predefinita.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

  • Abilita l'API Google Kubernetes Engine.
    • Abilita l'API Google Kubernetes Engine
  • Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo il gcloud components update comando. Le versioni precedenti di gcloud CLI potrebbero non supportare l'esecuzione dei comandi in questo documento.

Acquisisci capacità

Puoi ottenere la capacità per le istanze di computing A4X Max creando una prenotazione futura. Per saperne di più sulle prenotazioni future, consulta la colpa Future prenotazioni future in AI Hypercomputer nella tabella per Scegliere un'opzione di consumo.

Per ottenere la capacità con una prenotazione futura, consulta la riga Prenotazioni future in AI Hypercomputer nella tabella per Come ottenere la capacità.

Requisiti

I seguenti requisiti si applicano a un cluster GKE ottimizzato per l'AI con istanze di computing A4X Max:

  • Per A4X Max, devi utilizzare una delle seguenti versioni:

    • Per la versione 1.35 o successive, utilizza la versione GKE 1.35.0-gke.2745000 o successive.
    • Per la versione 1.34, utilizza la versione GKE 1.34.3-gke.1318000 o successive.

    Queste versioni contribuiscono a garantire che A4X Max utilizzi quanto segue:

    • R580.95.05, la versione minima del driver GPU per A4X Max, che è abilitata per impostazione predefinita.
    • Gestione della memoria basata su driver coerente (CDMM), che è abilitata per impostazione predefinita. NVIDIA consiglia ai cluster Kubernetes di abilitare questa modalità per risolvere il problema della segnalazione eccessiva della memoria. CDMM consente di gestire la memoria GPU tramite il driver anziché il sistema operativo. Questo approccio consente di evitare l'online del sistema operativo della memoria GPU ed espone la memoria GPU come nodo NUMA (Non-Uniform Memory Access) al sistema operativo. Le GPU multi-istanza non sono supportate quando CDMM è abilitato. Per saperne di più su CDMM, consulta Supporto hardware e software Supporto.
    • GPUDirect RDMA e MNNVL, che sono consigliati per consentire ai pool di nodi A4X Max di utilizzare le funzionalità di rete di A4X Max.

  • I nodi GKE devono utilizzare un'immagine del nodo Container-Optimized OS. Le immagini dei nodi Ubuntu e Windows non sono supportate.

  • Il carico di lavoro GKE deve utilizzare tutte le GPU disponibili e il pod deve utilizzare tutte le NIC secondarie disponibili su un singolo nodo GKE. Più pod non possono condividere RDMA su un singolo nodo GKE.

  • Devi utilizzare il modello di provisioning con prenotazione per creare cluster con A4X Max. Gli altri modelli di provisioning non sono supportati.

  • Queste istruzioni utilizzano DRANET per configurare un cluster GKE ottimizzato per l'AI con A4X Max. Il multi-networking non è supportato per il tipo di macchina a4x-maxgpu-4g-metal.

Considerazioni per la creazione di un cluster

Quando crei un cluster, tieni presente le seguenti informazioni:

  • Scegli una località del cluster:
  • Scegli una versione del driver:
    • La versione del driver può essere uno dei seguenti valori:
      • default: installa la versione del driver predefinita per la versione del nodo GKE. Per saperne di più sui requisiti per le versioni dei driver predefinite, consulta la sezione Requisiti.
      • latest: installa l'ultima versione del driver disponibile per la tua versione di GKE. Questa opzione è disponibile solo per i nodi che utilizzano Container-Optimized OS.
      • disabled: salta l'installazione automatica del driver. Devi manualmente installare un driver dopo aver creato il pool di nodi.
    • Per saperne di più sulle versioni dei driver GPU predefinite e più recenti per le versioni dei nodi GKE, consulta la tabella nella sezione Installare manualmente i driver GPU NVIDIA.

  • Scegli un'affinità di prenotazione:

    • Puoi trovare informazioni sulla tua prenotazione, ad esempio il nome della prenotazione o il nome di un blocco specifico nella prenotazione. Per trovare questi valori, consulta Visualizza le richieste di prenotazione futura.
    • Il flag --reservation-affinity può assumere i valori specific o any. Tuttavia, per i carichi di lavoro di AI distribuiti ad alte prestazioni, ti consigliamo di utilizzare una prenotazione specifica.

    • Quando utilizzi una prenotazione specifica, incluse le prenotazioni condivise, specifica il valore del flag --reservation nel seguente formato:

      projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME

      Sostituisci i seguenti valori:

      • PROJECT_ID: il tuo Google Cloud ID progetto.
      • RESERVATION_NAME: il nome della prenotazione.
      • BLOCK_NAME: il nome di un blocco specifico all'interno della prenotazione.

      Ti consigliamo inoltre di utilizzare una prenotazione mirata a un sottoblocco in modo che le istanze di computing vengano inserite in un singolo sottoblocco all'interno di BLOCK_NAME. Aggiungi quanto segue alla fine del percorso:

      /reservationSubBlocks/SUB_BLOCK_NAME

      Sostituisci SUB_BLOCK_NAME con il nome del sottoblocco.

      projects/PROJECT_ID/reservations/

Crea un cluster GKE ottimizzato per l'AI che utilizza A4X Max e GPUDirect RDMA

Per i carichi di lavoro di AI distribuiti, più nodi GPU sono spesso collegati tra loro per funzionare come un singolo computer. A4X Max è una piattaforma exascale basata sull'architettura a livello di rack NVIDIA GB300 NVL72. Le istanze di computing A4X Max utilizzano un'architettura di rete gerarchica a più livelli con un design con allineamento ai rail per ottimizzare le prestazioni per vari tipi di comunicazione. Questo tipo di macchina consente la scalabilità e la collaborazione su più GPU offrendo un'esperienza cloud ad alte prestazioni per i carichi di lavoro di AI. Per saperne di più sull'architettura di rete per A4X Max, inclusi la larghezza di banda di rete e la disposizione delle NIC, consulta Tipo di macchina A4X Max (bare metal).

Per creare un cluster GKE Standard con A4X Max che utilizza GPUDirect RDMA e MNNVL, completa i passaggi descritti nelle seguenti sezioni:

  1. Crea il cluster GKE
  2. Crea una policy del workload
  3. Crea un pool di nodi con A4X Max
  4. Configura le NIC MRDMA con asapd-lite
  5. Installa il CRD del dominio di calcolo NVIDIA e il driver DRA
  6. Configura il manifest del carico di lavoro per il dominio RDMA e IMEX

Queste istruzioni utilizzano i profili di rete dell'acceleratore per configurare automaticamente le reti VPC e le subnet per i nodi A4X Max. In alternativa, puoi specificare esplicitamente la rete VPC e le subnet.

Crea il cluster GKE

  1. Crea 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]

    Sostituisci quanto segue:

    • CLUSTER_NAME: il nome del tuo cluster.
    • CLUSTER_VERSION: la versione del nuovo cluster. Per saperne di più sulla versione di GKE che supporta la tua configurazione, consulta la sezione Requisiti in questo documento.
    • COMPUTE_REGION: il nome della regione di computing.

    • Facoltativamente, puoi fornire esplicitamente gli intervalli CIDR secondari per servizi e pod. Se utilizzi questi flag facoltativi, sostituisci le seguenti variabili:

      • SERVICE_CIDR: l'intervallo CIDR secondario per i servizi.
      • POD_CIDR: l'intervallo CIDR secondario per i pod.

      Quando utilizzi questi flag, devi verificare che gli intervalli CIDR non si sovrappongano agli intervalli di subnet per le reti di nodi aggiuntive. Ad esempio, considera SERVICE_CIDR=10.65.0.0/19 e POD_CIDR=10.64.0.0/19. Per saperne di più, consulta Aggiungere intervalli di indirizzi IPv4 dei pod.

  2. Per eseguire i comandi kubectl nelle sezioni successive, connettiti al cluster:

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

    Sostituisci quanto segue:

    • CLUSTER_NAME: il nome del tuo cluster.
    • COMPUTE_REGION: il nome della regione di computing.

    Per saperne di più, consulta Installare kubectl e configurare l'accesso al cluster access.

Crea una policy del workload

Per creare una partizione è necessaria una policy del workload. Per saperne di più, consulta Policy del workload per i MIG.

Crea una policy del workload HIGH_THROUGHPUT con il campo accelerator_topology impostato su 1x72.

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

Sostituisci quanto segue:

  • WORKLOAD_POLICY_NAME: il nome della policy del workload.
  • PROJECT: il nome del tuo progetto.
  • COMPUTE_REGION: il nome della regione di computing.

Crea un pool di nodi con A4X Max

  1. Crea il seguente file di configurazione per preallocare pagine enormi con il pool di nodi:

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

export NODE_CUSTOM=node_custom.yaml

  2. Crea un pool di nodi 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

    Sostituisci quanto segue:

    • NODE_POOL_NAME: il nome del pool di nodi.
    • CLUSTER_NAME: il nome del tuo cluster.
    • COMPUTE_REGION: la regione di computing del cluster.
    • COMPUTE_ZONE: la zona del pool di nodi.
    • NODE_COUNT: il numero di nodi per il pool di nodi, che deve essere pari o inferiore a 18 nodi. Ti consigliamo di utilizzare 18 nodi per ottenere la topologia GPU di 1x72 in un sottoblocco utilizzando un dominio NVLink.
    • WORKLOAD_POLICY_NAME: il nome della policy del workload creata in precedenza.
    • RESERVATION_NAME: il nome della prenotazione. Per trovare questo valore, consulta Visualizza le richieste di prenotazione futura.
    • BLOCK_NAME: il nome di un blocco specifico all'interno della prenotazione. Per trovare questo valore, consulta Visualizza le richieste di prenotazione futura.

    Questo comando crea automaticamente una rete che collega tutti i nodi A4X Max all'interno di una singola zona utilizzando il profilo di rete dell'acceleratore auto. Quando crei un pool di nodi con il flag --accelerator-network-profile=auto, GKE aggiunge automaticamente l'etichetta gke.networks.io/accelerator-network-profile: auto ai nodi. Per pianificare i carichi di lavoro su questi nodi, devi includere questa etichetta nel campo nodeSelector del carico di lavoro.

Configura le NIC MRDMA con asapd-lite

Il DaemonSet asapd-lite configura le NIC MRDMA. Un DaemonSet asapd-lite non integro potrebbe indicare l'assenza di connettività RDMA.

  1. Installa il 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. Convalida le repliche nel DaemonSet asapd-lite:

    kubectl get daemonset -n kube-system asapd-lite

    L'output è simile al seguente:

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

    Il numero di repliche READY deve corrispondere al numero di nodi creati e integri nel pool di nodi.

Installa il CRD del dominio di calcolo NVIDIA e il driver DRA

I seguenti passaggi installano il CRD del dominio di calcolo NVIDIA e il driver DRA per consentire l'utilizzo di MNNVL. Per saperne di più, consulta Driver NVIDIA DRA per GPU.

  1. Verifica di aver installato Helm nel tuo ambiente di sviluppo. Helm è preinstallato in Cloud Shell.

    Sebbene non esista un requisito specifico per la versione di Helm, puoi utilizzare il seguente comando per verificare di aver installato Helm.

    helm version

    Se l'output è simile a Command helm not found, puoi installare l'interfaccia a riga di comando 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. Aggiungi il repository Helm NVIDIA:

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

  3. Crea un oggetto ResourceQuota per il driver 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

    Sostituisci POD_QUOTA con un numero almeno 2 volte il numero di nodi A4X Max nel cluster più 1. Ad esempio, devi impostare la variabile su almeno 37 se hai 18 nodi A4X Max nel cluster.

  4. Installa il CRD ComputeDomain e il driver 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 il manifest del carico di lavoro per il dominio RDMA e IMEX

  1. Aggiungi una regola di affinità dei nodi per pianificare il carico di lavoro sui nodi Arm:

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

  2. Aggiungi il seguente volume alla specifica del pod:

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

  3. Aggiungi i seguenti montaggi di volumi, variabile di ambiente e risorse al container che richiede le GPU. Il container del carico di lavoro deve richiedere tutte e quattro le 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 la risorsa ComputeDomain per il carico di lavoro:

    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

    Sostituisci NUM_NODES con il numero di nodi richiesti dal carico di lavoro.

  5. Crea un ResourceClaimTemplate per allocare le risorse di rete utilizzando DRANET e richiedere i dispositivi RDMA per il 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. Specifica il ResourceClaimTemplate utilizzato dal 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. Assicurati che le librerie dello spazio utente e i pacchetti libnccl siano installati nell'immagine container utente:

    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 specifica del pod completata è simile alla seguente:

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

Testare le prestazioni di rete

Ti consigliamo di convalidare la funzionalità dei cluster di cui è stato eseguito il provisioning. Per farlo, utilizza i test NCCL/gIB, che sono test NVIDIA Collective Communications Library (NCCL) ottimizzati per l' ambiente Google.

Per saperne di più, consulta Esegui NCCL su cluster GKE personalizzati che utilizzano A4X Max.

Passaggi successivi