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 istanze Compute Engine A4X Max per supportare i carichi di lavoro di AI e ML.

Le serie A4X Max e A4X ti 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à quali il posizionamento mirato dei carichi di lavoro, la pianificazione in base alla topologia e controlli avanzati per la 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 workload 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 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 workload come il pre-addestramento distribuito ad alte prestazioni, l'ottimizzazione dei modelli, l'inferenza dei modelli, la pubblicazione di applicazioni e i servizi di supporto. Per i workload che richiedono prestazioni elevate, throughput elevato e bassa latenza, GPUDirect RDMA riduce gli hop di rete necessari per trasferire i payload alle GPU e dalle GPU. Questo approccio utilizza in modo più efficiente la larghezza di banda di rete disponibile. Per ulteriori informazioni, 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 workload. 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 impostazioni predefinite che riflettono le best practice per molti casi d'uso. Per saperne di più, consulta Creare un cluster GKE ottimizzato per l'AI con la configurazione predefinita.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:

  • Attiva l'API Google Kubernetes Engine.
    • Attiva 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 comando gcloud components update. Le versioni precedenti di gcloud CLI potrebbero non supportare l'esecuzione dei comandi in questo documento.

Ottieni capacità

Puoi ottenere capacità per le istanze di computing A4X Max creando una prenotazione futura. Per ulteriori informazioni sulle prenotazioni future, consulta la colonna 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 Come ottenere la capacità.

Requisiti

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

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

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

    Queste versioni contribuiscono a garantire che A4X Max utilizzi:

    • R580.95.05, la versione minima del driver GPU per A4X Max, che è abilitata per impostazione predefinita.
    • Coherent Driver-based Memory Management (CDMM), che è abilitato per impostazione predefinita. NVIDIA consiglia di attivare questa modalità nei cluster Kubernetes 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 ulteriori informazioni su CDMM, vedi Assistenza hardware e software.
    • 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 tuo workload GKE deve utilizzare tutte le GPU disponibili e il tuo 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 posizione del cluster:
    • Verifica di utilizzare una località in cui è disponibile il tipo di macchina che scegli. Per saperne di più, consulta Disponibilità dell'acceleratore.
    • Quando crei node pool in un cluster regionale, che sono consigliati per i carichi di lavoro di produzione, puoi utilizzare il flag --node-locations per specificare le zone per i nodi GKE.
  • Scegli una versione del driver:
    • La versione del driver può essere uno dei seguenti valori:
      • default: installa la versione predefinita del driver per la tua versione del nodo GKE. Per ulteriori informazioni sui requisiti per le versioni predefinite dei driver, 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 dei driver. Devi installare manualmente un driver dopo aver creato il pool di nodi.
    • Per ulteriori informazioni sulle versioni predefinite e più recenti dei driver GPU 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 della prenotazione. Per trovare questi valori, consulta Visualizzare le richieste di prenotazione futura.
    • Il flag --reservation-affinity può assumere i valori specific o any. Tuttavia, per i workload di AI distribuita 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 ID progetto Google Cloud .
      • RESERVATION_NAME: il nome della tua prenotazione.
      • BLOCK_NAME: il nome di un blocco specifico all'interno della prenotazione.

      Ti consigliamo inoltre di utilizzare una prenotazione con targeting a un sub-blocco in modo che le istanze di Compute siano posizionate in un unico sub-blocco 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.

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

Per i carichi di lavoro di AI distribuiti, spesso vengono collegati più nodi GPU per funzionare come un unico computer. A4X Max è una piattaforma exascale basata sull'architettura NVIDIA GB300 NVL72 a livello di rack. Le istanze di calcolo A4X Max utilizzano un'architettura di rete gerarchica a più livelli con un design allineato alle guide 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 workload AI. Per ulteriori informazioni 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 sezioni seguenti:

  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 driver NVIDIA Compute Domain CRD e DRA
  6. Configurare il manifest del workload 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 di questo documento.
    • COMPUTE_REGION: il nome della regione di computing.

    • Se vuoi, 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 Aggiunta di intervalli di indirizzi IPv4 di 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.

Crea una policy del workload

Per creare una partizione è necessaria una policy del workload. Per saperne di più, consulta la 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 tuo workload.
  • PROJECT: il nome del 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 hugepages 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 node pool, che deve essere pari o inferiore a 18. Ti consigliamo di utilizzare 18 nodi per ottenere la topologia della 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 Visualizzare le richieste di prenotazione futura.
    • BLOCK_NAME: il nome di un blocco specifico all'interno della prenotazione. Per trovare questo valore, consulta Visualizzare le richieste di prenotazione futura.

    Questo comando crea automaticamente una rete che connette 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 workload su questi nodi, devi includere questa etichetta nel campo nodeSelector del tuo workload.

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 di READY deve corrispondere al numero di nodi creati e integri nel pool di nodi.

Installa il driver NVIDIA Compute Domain CRD e DRA

I seguenti passaggi installano la CRD NVIDIA Compute Domain e il driver DRA per abilitare l'utilizzo di MNNVL. Per ulteriori informazioni, consulta Driver NVIDIA DRA per GPU.

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

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

    helm version

    Se l'output è simile a Command helm not found, puoi installare l'interfaccia a riga di comando di 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 nel cluster sono presenti 18 nodi A4X Max.

  4. Installa la 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 workload per RDMA e il dominio IMEX

  1. Aggiungi una regola di affinità nodo per pianificare il workload 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 volumi montati, la variabile di ambiente e la risorsa al container che richiede GPU. Il container del workload 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 workload:

    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 workload.

  5. Crea un ResourceClaimTemplate per allocare le risorse di rete utilizzando DRANET e richiedi dispositivi RDMA per il tuo 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 userspace 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 ha il seguente aspetto:

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 della rete

Ti abbiamo consigliato di convalidare la funzionalità dei cluster di cui è stato eseguito il provisioning. Per farlo, utilizza i test NCCL/gIB, ovvero i 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