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

Questa pagina mostra come creare un cluster Google Kubernetes Engine (GKE) ottimizzato per l'AI che utilizza macchine virtuali (VM) A4X per supportare i carichi di lavoro di AI e ML. Per saperne di più su A4X, vedi Serie A4X.

La serie di macchine A4X è progettata per consentirti di eseguire cluster AI/ML su larga scala con funzionalità come il posizionamento mirato dei carichi di lavoro, controlli avanzati di manutenzione dei cluster e pianificazione in base alla topologia. Per saperne di più, consulta la panoramica della gestione dei cluster.

GKE fornisce una singola piattaforma per eseguire un insieme diversificato di carichi di lavoro per le tue organizzazioni, riducendo il carico operativo della gestione di più piattaforme. Puoi eseguire workload come il pre-addestramento distribuito ad alte prestazioni, la messa a punto del modello, l'inferenza del modello, la distribuzione di applicazioni e i servizi di supporto.

In questa pagina 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. 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 configurazione predefinita.
Per creare un cluster che utilizza A4 o A3 Ultra, consulta Crea un cluster GKE personalizzato ottimizzato per l'AI che utilizza A4 o A3 Ultra.

Opzioni di configurazione del cluster con GPUDirect RDMA

Per creare il cluster con Google Cloud CLI, puoi scegliere una delle seguenti opzioni di configurazione del cluster:

Se prevedi di eseguire carichi di lavoro di AI distribuiti: crea un cluster GKE con GPUDirect RDMA seguendo le istruzioni riportate in questa pagina.
Se non prevedi di eseguire carichi di lavoro di AI distribuiti: crea un cluster GKE senza utilizzare GPUDirect RDMA. Per saperne di più, consulta Creare un cluster senza GPUDirect RDMA.

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.
Nota: per le installazioni esistenti di gcloud CLI, assicurati di impostare la proprietà compute/region. Se utilizzi principalmente cluster zonali, imposta invece compute/zone. Se imposti una località predefinita, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location. Potresti dover specificare la posizione in determinati comandi se la posizione del cluster è diversa da quella predefinita che hai impostato.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per creare e gestire un cluster GKE, chiedi all'amministratore di concederti i seguenti ruoli IAM nel progetto:

Amministratore Kubernetes Engine (roles/container.admin)
Editor Cloud Build (roles/cloudbuild.builds.editor)
Compute Admin (roles/compute.admin)
Project IAM Admin (roles/resourcemanager.projectIamAdmin)
Amministratore service account (roles/iam.serviceAccountAdmin)
Utente Service Account (roles/iam.serviceAccountUser)
Consumer Service Usage (roles/serviceusage.serviceUsageConsumer)
Storage Admin (roles/storage.admin)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Ottieni capacità

Puoi ottenere capacità per le VM A4X creando una prenotazione futura. Per ulteriori informazioni sulle prenotazioni future, consulta la colonna Prenotazioni future in AI Hypercomputer nella tabella Scegli 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 VM A4X:

Per A4X, assicurati di utilizzare, per la versione 1.33 o successive, GKE versione 1.33.4-gke.1036000 o successive. In alternativa, per la versione 1.32, utilizza GKE versione 1.32.8-gke.1108000 o successive. Queste versioni assicurano che A4X utilizzi quanto segue:
- R580, la versione minima del driver GPU per A4X.
- 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, che è consigliato per consentire ai pool di nodi A4X di utilizzare le funzionalità di networking di A4X.
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.
Questa configurazione esegue un test NCCL. Per eseguire questo test NCCL, devi disporre di una quota VM minima di 2 (4 GPU ciascuna se utilizzi a4x-highgpu-4g o a4x-highgpu-4g-nolssd).
Per creare cluster con A4X, devi utilizzare il modello di provisioning con prenotazione. Altri modelli di provisioning non sono supportati.
GPUDirect RDMA non è compatibile con NCCL Fast Socket o GPUDirect TCPX/TCPXO. Non attivare NCCL Fast Socket o installare il plug-in TCPX/TCPXO sui cluster che utilizzano GPUDirect RDMA.

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 Località delle GPU.
- Per le prenotazioni dense, puoi creare un cluster di zona. In questo caso, sostituisci il flag --region con il flag --zone=COMPUTE_ZONE, dove COMPUTE_ZONE è la zona del control plane.
- Quando crei node pool in un cluster regionale, 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 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, come il nome della prenotazione o il nome di un blocco specifico nella 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 carichi di lavoro 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 prenotazione.
  - BLOCK_NAME: il nome di un blocco specifico all'interno della prenotazione.
  Per utilizzare una prenotazione mirata a un blocco secondario in modo che le VM vengano posizionate in un singolo blocco secondario 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.
Suggerimento: se la prenotazione si trova nel progetto corrente, puoi omettere projects/PROJECT_ID/reservations/dal valore della prenotazione.

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

Per i workload di AI distribuiti, spesso vengono collegati più nodi GPU per funzionare come un unico computer. A4X è una piattaforma exascale basata sull'architettura NVIDIA GB200 NVL72 a livello di rack. Questo tipo di macchina consente la scalabilità e la collaborazione su più GPU offrendo un'esperienza cloud ad alte prestazioni per i workload di AI. Per ulteriori informazioni sull'architettura di rete per A4X, inclusi la larghezza di banda della rete e la disposizione delle NIC, consulta Tipi di macchine A4X.

Per creare i cluster GKE Standard con A4X e con GPUDirect RDMA, completa i seguenti passaggi, descritti nelle sezioni successive:

Crea VPC e subnet
Crea il cluster GKE con il multinetworking
Crea gli oggetti di rete GKE
Crea una policy del workload
Crea un pool di nodi con A4X
Installa il binario RDMA e configura NCCL
Installa il driver NVIDIA Compute Domain CRD e DRA

Crea VPC e subnet

Le VM A4X hanno la seguente configurazione:

Quattro GPU NVIDIA B200 per macchina virtuale collegate con NVLink
Due CPU NVIDIA Grace basate su Arm
Quattro schede di interfaccia di rete (NIC) CX-7 da 400 Gbps per il networking da GPU a GPU
Due schede di interfaccia di rete (NIC) Google Titanium da 200 Gbps per servizi esterni

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. Per i workload che richiedono prestazioni elevate, velocità effettiva elevata 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.

Una delle NIC Google Titanium associate alla CPU utilizza la rete predefinita in GKE, quindi non devi creare un nuovo VPC per questa NIC, a condizione che tu disponga di intervalli di indirizzi IP sufficienti per la rete predefinita.

Puoi creare un VPC per la seconda NIC Titanium (gVNIC) della CPU e un altro VPC per le quattro NIC RDMA CX-7 utilizzando i seguenti comandi.

Per massimizzare la larghezza di banda di rete, il comando per creare un VPC per i set GVNIC aggiuntivi imposta l'unità massima di trasmissione (MTU) su 8896. La rete VPC RDMA utilizza per impostazione predefinita l'impostazione consigliata di 8896. Per saperne di più, consulta Impostazioni MTU e tipi di macchine GPU.

Imposta le variabili di ambiente in modo che corrispondano al deployment:
```
export REGION="COMPUTE_REGION"
export ZONE="COMPUTE_ZONE"
export PROJECT="PROJECT_ID"
export GVNIC_NETWORK_PREFIX="GVNIC_NETWORK_PREFIX"
export RDMA_NETWORK_PREFIX="RDMA_NETWORK_PREFIX"
```
Sostituisci le seguenti variabili:
- COMPUTE_REGION: la regione del cluster.
- COMPUTE_ZONE: la zona del pool di nodi.
- PROJECT_ID: il tuo ID progetto Google Cloud .
- GVNIC_NETWORK_PREFIX: il prefisso di rete GVNIC (ad esempio a4x-gvnic).
- RDMA_NETWORK_PREFIX: il prefisso di rete RDMA (ad esempio a4x-rdma).

Crea due reti VPC:

# Create a VPC for the additional GVNIC
gcloud compute --project=${PROJECT} \
  networks create \
  GVNIC_NETWORK_PREFIX-net \
  --subnet-mode=custom \
  --mtu=8896

gcloud compute --project=${PROJECT} \
  networks subnets create \
  GVNIC_NETWORK_PREFIX-sub \
  --network=GVNIC_NETWORK_PREFIX-net \
  --region=${REGION} \
  --range=192.168.0.0/24

gcloud compute --project=${PROJECT} \
  firewall-rules create \
  GVNIC_NETWORK_PREFIX-internal \
  --network=GVNIC_NETWORK_PREFIX-net \
  --action=ALLOW \
  --rules=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=192.168.0.0/16

# Create HPC VPC for the RDMA NICs with 4 subnets.
gcloud compute --project=${PROJECT} \
  networks create RDMA_NETWORK_PREFIX-net \
  --network-profile=${ZONE}-vpc-roce \
  --subnet-mode=custom

# Create subnets for the HPC VPC.
for N in $(seq 0 3); do
  gcloud compute --project=${PROJECT} \
    networks subnets create \
    RDMA_NETWORK_PREFIX-sub-$N \
    --network=RDMA_NETWORK_PREFIX-net \
    --region=${REGION} \
    --range=192.168.$((N+1)).0/24 &  # offset to avoid overlap with gvnics
done

Crea il cluster GKE con il networking multiplo

Crea un cluster GKE Standard con networking multiplo:
```
gcloud container clusters create CLUSTER_NAME \
    --enable-dataplane-v2 --enable-ip-alias --location=COMPUTE_REGION \
    --enable-multi-networking --cluster-version=CLUSTER_VERSION \
    --enable-kubernetes-unstable-apis=resource.k8s.io/v1beta1/deviceclasses,resource.k8s.io/v1beta1/resourceclaims,resource.k8s.io/v1beta1/resourceclaimtemplates,resource.k8s.io/v1beta1/resourceslices \
    [--services-ipv4-cidr=SERVICE_CIDR \
    --cluster-ipv4-cidr=POD_CIDR]
```
Quando prepari questo comando, procedi nel seguente modo:
- Rimuovi il flag --enable-kubernetes-unstable-apis, utilizzato per abilitare DRA, quando crei un cluster che esegue GKE versione 1.34 o successive. Questo flag è necessario solo quando crei un cluster che esegue la versione 1.32 o 1.33. Quando abiliti un'API beta, devi eseguire la migrazione dall'API beta quando questa viene ritirata e rimossa con le versioni secondarie successive di Kubernetes. Per saperne di più, consulta la sezione Ritiri delle API beta.
- Sostituisci quanto segue:
  - CLUSTER_NAME: il nome del tuo cluster.
  - CLUSTER_VERSION: la versione del nuovo cluster. Per ulteriori informazioni 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.

Crea gli oggetti di rete GKE

Devi configurare le reti VPC create nella sezione precedente tramite i set di parametri di rete GKE. Nello specifico, la seconda NIC Titanium (gVNIC) della CPU deve essere configurata in modalità NetDevice e ciascuna delle quattro NIC CX-7 RDMA deve essere configurata in modalità RDMA.

Questo comando utilizza i seguenti nomi:

La scheda di interfaccia di rete (NIC) VPC della CPU Titanium è denominata GVNIC_NETWORK_PREFIX-net con la subnet denominata GVNIC_NETWORK_PREFIX-sub
Il VPC delle NIC RDMA CX-7 è denominato RDMA_NETWORK_PREFIX-net con le subnet denominate RDMA_NETWORK_PREFIX-sub-[0…3]

Crea gli oggetti di rete GKE eseguendo il seguente comando:

kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: gvnic-1
spec:
  vpc: GVNIC_NETWORK_PREFIX-net
  vpcSubnet: GVNIC_NETWORK_PREFIX-sub
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: gvnic-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: gvnic-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-0
spec:
  vpc: RDMA_NETWORK_PREFIX-net
  vpcSubnet: RDMA_NETWORK_PREFIX-sub-0
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-0
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-0
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-1
spec:
  vpc: RDMA_NETWORK_PREFIX-net
  vpcSubnet: RDMA_NETWORK_PREFIX-sub-1
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-2
spec:
  vpc: RDMA_NETWORK_PREFIX-net
  vpcSubnet: RDMA_NETWORK_PREFIX-sub-2
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-2
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-2
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-3
spec:
  vpc: RDMA_NETWORK_PREFIX-net
  vpcSubnet: RDMA_NETWORK_PREFIX-sub-3
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-3
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-3
EOF

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 progetto.
COMPUTE_REGION: il nome della regione di computing.

Crea un pool di nodi con A4X

Ti consigliamo di creare un pool di nodi che utilizzi il plug-in del dispositivo GPU GKE. Questo plug-in fornisce la gestione delle risorse GPU gestite da GKE. Questo approccio presenta i seguenti vantaggi:

Facilità di deployment e upgrade
Installazione automatica del driver
Funzionalità GPU gestite da GKE, come metriche e GPU partizionate
Correzioni essenziali delle vulnerabilità di sicurezza

In alternativa, puoi utilizzare l'operatore GPU NVIDIA, se richiesto dal tuo caso d'uso. Per saperne di più, consulta Perché utilizzare l'operatore GPU NVIDIA?.

Crea un pool di nodi A4X con il plug-in del dispositivo GPU GKE

Crea un pool di nodi A4X che utilizza il plug-in del dispositivo GPU GKE:

gcloud container node-pools create NODE_POOL_NAME \
    --location COMPUTE_REGION \
    --node-locations COMPUTE_ZONE \
    --cluster CLUSTER_NAME \
    --num-nodes=NODE_COUNT \
    --machine-type MACHINE_TYPE \
    --accelerator type=nvidia-gb200,count=4,gpu-driver-version=DRIVER_VERSION \
    --additional-node-network network=GVNIC_NETWORK_PREFIX-net,subnetwork=GVNIC_NETWORK_PREFIX-sub \
    --additional-node-network network=RDMA_NETWORK_PREFIX-net,subnetwork=RDMA_NETWORK_PREFIX-sub-0 \
    --additional-node-network network=RDMA_NETWORK_PREFIX-net,subnetwork=RDMA_NETWORK_PREFIX-sub-1 \
    --additional-node-network network=RDMA_NETWORK_PREFIX-net,subnetwork=RDMA_NETWORK_PREFIX-sub-2 \
    --additional-node-network network=RDMA_NETWORK_PREFIX-net,subnetwork=RDMA_NETWORK_PREFIX-sub-3 \
    --scopes "https://www.googleapis.com/auth/cloud-platform" \
    --reservation-affinity=specific \
    --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME \
    --placement-policy=WORKLOAD_POLICY_NAME

Sostituisci quanto segue:

NODE_POOL_NAME: il nome del pool di nodi.
COMPUTE_REGION: la regione del cluster.
COMPUTE_ZONE: la zona del pool di nodi.
CLUSTER_NAME: il nome del tuo cluster.
NODE_COUNT: il numero di nodi per il pool di nodi, 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.
MACHINE_TYPE: a4x-highgpu-4g o a4x-highgpu-4g-nolssd, a seconda che tu voglia SSD locali.
DRIVER_VERSION: la versione del driver NVIDIA da installare. Può essere uno dei seguenti valori: default, latest o disabled.
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.
WORKLOAD_POLICY_NAME: il nome del criterio del workload creato in precedenza.

Crea un pool di nodi A4X con l'operatore GPU NVIDIA

In alternativa, per utilizzare l'operatore GPU NVIDIA, segui questi passaggi:

Esegui il comando gcloud container node-pools create della sezione precedente con le seguenti modifiche:
- Modifica gpu-driver-version=latest in gpu-driver-version=disabled. Questa modifica ignora l'installazione automatica del driver GPU perché non è supportata quando si utilizza l'operatore GPU NVIDIA.
- Imposta --node-labels="gke-no-default-nvidia-gpu-device-plugin=true" su per disattivare il DaemonSet del plug-in del dispositivo GPU gestito da GKE.
Applica il manifest DaemonSet del programma di installazione dei driver GPU di GKE. Questo manifest esegue il deployment di un pod di installazione del driver GPU su ogni nodo A4X:
```
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml
```

Gestisci lo stack GPU con l'operatore GPU NVIDIA su Google Kubernetes Engine (GKE):

Nella sezione per creare e configurare il pool di nodi GPU, segui le istruzioni a partire dal passaggio per ottenere le credenziali di autenticazione.

Installa l'operatore GPU NVIDIA. Completa tutti i passaggi, ma sostituisci il comando nella sezione a cui viene fatto riferimento che installa l'operatore GPU NVIDIA utilizzando Helm. Utilizza invece il seguente comando:

helm install --wait --generate-name \
  -n gpu-operator \
  nvidia/gpu-operator \
  --version="25.3.0" \
  -f <(cat <<EOF
hostPaths:
  driverInstallDir: /home/kubernetes/bin/nvidia
toolkit:
  installDir: /home/kubernetes/bin/nvidia
cdi:
  enabled: true
  default: true
driver:
  enabled: false

daemonsets:
  tolerations:
    - key: nvidia.com/gpu
      operator: Equal
      value: present
      effect: NoSchedule
    - key: kubernetes.io/arch
      operator: Equal
      value: arm64
      effect: NoSchedule

node-feature-discovery:
  worker:
    tolerations:
      - key: kubernetes.io/arch
        operator: Equal
        value: arm64
        effect: NoSchedule
      - key: "node-role.kubernetes.io/master"
        operator: "Equal"
        value: ""
        effect: "NoSchedule"
      - key: "node-role.kubernetes.io/control-plane"
        operator: "Equal"
        value: ""
        effect: "NoSchedule"
      - key: nvidia.com/gpu
        operator: Exists
        effect: NoSchedule
EOF
)

Installa il binario RDMA e configura NCCL

Applica il seguente DaemonSet per installare i file binari RDMA e la libreria NCCL su ogni nodo. Su ogni VM sottostante, i file binari RDMA vengono installati nella directory /home/kubernetes/bin/gib e la libreria NCCL viene installata nella directory /home/kubernetes/bin/nvidia/lib64.

  kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-rdma/nccl-rdma-installer-a4x.yaml

Installa il driver NVIDIA Compute Domain CRD e DRA

Installa il driver NVIDIA Compute Domain CRD e DRA. Per ulteriori informazioni, vedi Driver NVIDIA DRA per GPU.

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 eseguendo questo comando:
```
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
```

Aggiungi il repository Helm NVIDIA:

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

Crea un 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 due volte superiore al numero di nodi A4X nel cluster più 1. Ad esempio, devi impostare la variabile su almeno 37 se nel cluster sono presenti 18 nodi A4X.

Installa il driver DRA:

helm install nvidia-dra-driver-gpu nvidia/nvidia-dra-driver-gpu \
    --version="DRIVER_VERSION" \
    --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-gb200
              - 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
)

Sostituisci DRIVER_VERSION con la versione 25.3.1 o successiva.

Configura il manifest del workload per il multi-networking, RDMA e il dominio IMEX

Aggiungi le seguenti annotazioni ai metadati del pod:

metadata:
  annotations:
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth2","network":"rdma-0"},
        {"interfaceName":"eth3","network":"rdma-1"},
        {"interfaceName":"eth4","network":"rdma-2"},
        {"interfaceName":"eth5","network":"rdma-3"}
      ]

Aggiungi una regola di affinità nodo per la pianificazione sui nodi Arm:

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

Per maggiori informazioni, consulta Pianificare il workload per una singola architettura.

Aggiungi i seguenti volumi alla specifica del pod:

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

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
    - name: gib
   mountPath: /usr/local/gib
  env:
    - name: LD_LIBRARY_PATH
      value: /usr/local/nvidia/lib64
  resources:
    limits:
      nvidia.com/gpu: 4

Crea la risorsa ComputeDomain per il workload:

apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
  name: a4x-compute-domain
spec:
  numNodes: NUM_NODES
  channel:
    resourceClaimTemplate:
      name: a4x-compute-domain-channel

Sostituisci NUM_NODES con il numero di nodi richiesti dal workload.

Specifica il resourceClaimTemplate che verrà utilizzato dal pod:

spec:
  ...
  volumes:
    ...
  containers:
    - name: my-container
      ...
      resources:
        limits:
          nvidia.com/gpu: 4
  claims:
          - name: compute-domain-channel
        ...
resourceClaims:
  - name: compute-domain-channel
    resourceClaimTemplateName: a4x-compute-domain-channel

Imposta tutte le variabili di ambiente richieste per configurare NCCL. Utilizza lo script shell seguente dal container del workload:
```
source /usr/local/gib/scripts/set_nccl_env.sh
```

Una specifica del pod completata ha il seguente aspetto:

apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
  name: a4x-compute-domain
spec:
  numNodes: NUM_NODES
  channel:
    resourceClaimTemplate:
      name: a4x-compute-domain-channel
---
apiVersion: apps/v1
kind: Pod
metadata:
  name: my-pod
  labels:
    k8s-app: my-pod
  annotations:
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth2","network":"rdma-0"},
        {"interfaceName":"eth3","network":"rdma-1"},
        {"interfaceName":"eth4","network":"rdma-2"},
        {"interfaceName":"eth5","network":"rdma-3"},
      ]
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
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib
  containers:
    - name: my-container
      volumeMounts:
        - name: library-dir-host
          mountPath: /usr/local/nvidia
        - name: gib
       mountPath: /usr/local/gib
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      resources:
        limits:
          nvidia.com/gpu: 4
        claims:
          - name: compute-domain-channel
        ...
resourceClaims:
  - name: compute-domain-channel
    resourceClaimTemplateName: a4x-compute-domain-channel

Testare le prestazioni della rete

Ti consigliamo 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.

Passaggi successivi

Per scoprire di più sulla pianificazione dei workload sui cluster GKE utilizzando TAS e Kueue, consulta Pianifica i workload GKE con Topology Aware Scheduling.
Per scoprire di più sulla gestione degli eventi comuni pertinenti ai cluster GKE e ai carichi di lavoro AI, consulta Gestire i cluster GKE ottimizzati per l'AI.