Crea un cluster GKE personalizzato ottimizzato per l'AI che utilizza A4 o A3 Ultra

Questa pagina mostra come creare un cluster Google Kubernetes Engine (GKE) ottimizzato per l'AI che utilizza macchine virtuali (VM) A4 o A3 Ultra per supportare i tuoi workload di AI e ML. Per A4X, vedi Creare un cluster GKE personalizzato ottimizzato per l'AI che utilizza A4X.

Le serie di macchine A4 e A3 Ultra sono progettate 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 istruzioni su come procedere, consulta Crea un cluster GKE ottimizzato per l'AI con la configurazione predefinita.

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 non prevedi di eseguire carichi di lavoro di AI distribuiti: crea un cluster GKE senza utilizzare GPUDirect RDMA.
Se prevedi di eseguire carichi di lavoro di AI distribuiti: crea un cluster GKE con 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.

Scegli un'opzione di consumo e ottieni la capacità

Scegli un'opzione di consumo. Fai la tua scelta in base a come vuoi ottenere e utilizzare le risorse GPU. Per ulteriori informazioni, vedi Scegliere un'opzione di consumo.

Per GKE, considera le seguenti informazioni aggiuntive quando scegli un'opzione di consumo:
- Per saperne di più su flex-start (anteprima) e GKE, consulta Informazioni sull'ottenimento di GPU con flex-start.
- L'avvio flessibile utilizza il posizionamento compatto con il criterio del "best effort". Per esaminare la topologia, consulta Visualizzare la topologia fisica dei nodi nel cluster GKE.
- Puoi ottenere informazioni sulla topologia quando utilizzi le VM spot solo se configuri il posizionamento compatto.
Ottenere capacità. Scopri come ottenere capacità per l'opzione di consumo.

Requisiti

Al cluster GKE ottimizzato per l'AI si applicano i seguenti requisiti:

Per utilizzare il modello di provisioning con avvio flessibile, devi utilizzare GKE versione 1.32.2-gke.1652000 o successive.
Assicurati di utilizzare la versione minima del driver GPU, a seconda del tipo di macchina:
- A4: le GPU B200 nelle VM A4 richiedono almeno la versione R570 del driver GPU. Per impostazione predefinita, GKE installa automaticamente questa versione del driver su tutti i nodi A4 che eseguono la versione minima richiesta per A4, ovvero 1.32.1-gke.1729000 o versioni successive.
- A3 Ultra: le GPU H200 nelle VM A3 Ultra richiedono almeno la versione 550 del driver GPU, disponibile in GKE versione 1.31 come versione del driver latest. Per le VM A3 Ultra, devi impostare il valore del campo gpu-driver-version=latest con GKE versione 1.31. Per GKE versione 1.31.5-gke.1169000 o successive, GKE installa automaticamente le versioni del driver GPU R550 sui nodi A3 Ultra per impostazione predefinita, anche quando ometti il flag gpu-driver-version.
Per utilizzare GPUDirect RDMA, devi soddisfare anche i seguenti requisiti aggiuntivi:
- Utilizza le seguenti versioni minime, a seconda del tipo di macchina:
  - A4: utilizza la versione 1.32.2-gke.1475000 o successive.
  - A3 Ultra: utilizza la versione 1.31.4-gke.1183000 o successive.
- I nodi GKE devono utilizzare un'immagine del nodo Container-Optimized OS. Le immagini dei nodi Ubuntu e Windows non sono supportate.
- Il tuo carico di lavoro GKE deve utilizzare tutte le GPU disponibili e il tuo pod deve utilizzare tutte le schede di interfaccia di rete (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 (ovvero 16 GPU se utilizzi i tipi di macchina a4-highgpu-8g o a3-ultragpu-8g).
- 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.
Assicurati di utilizzare una località che abbia disponibilità per il tipo di macchina che scegli. Per saperne di più, consulta Località delle GPU.

Crea un cluster GKE ottimizzato per l'AI

Segui le istruzioni in questa sezione per creare un cluster GKE che soddisfi i requisiti per i cluster GKE ottimizzati per l'AI. Puoi scegliere se creare un cluster con o senza GPUDirect RDMA.

Considerazioni per la creazione di un cluster

Quando crei un cluster, tieni presente le seguenti informazioni:

Scegli una posizione del cluster:
- Assicurati di utilizzare una località in cui sia 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.
- Per i carichi di lavoro eseguiti su più di 1000 nodi e che richiedono una bassa latenza di rete tra i nodi, puoi creare un cluster regionale. Per la colocation fisica dei nodi sensibili alle prestazioni, crea i tuoi node pool GPU all'interno di una singola zona utilizzando il flag --node-locations.
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 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 quanto segue:
  - 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.
Suggerimento: se la prenotazione si trova nel progetto corrente, puoi omettere projects/PROJECT_ID/reservations/dal valore della prenotazione.

Crea un cluster senza GPUDirect RDMA

Per creare un cluster senza GPUDirect RDMA, utilizza le seguenti istruzioni per creare un cluster con un pool di nodi predefinito basato su CPU e node pool aggiuntivi con GPU. Questo approccio consente al pool di nodi predefinito di eseguire altri servizi.

Crea il cluster:
```
  gcloud container clusters create CLUSTER_NAME \
      --cluster-version=CLUSTER_VERSION \
      --region=COMPUTE_REGION
```
Sostituisci quanto segue:
- CLUSTER_NAME: il nome del nuovo 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.
- COMPUTE_REGION: la regione del nuovo cluster. Se prevedi di creare un cluster zonale, utilizza il flag --zone anziché il flag --region, ad esempio: --zone=COMPUTE_ZONE. Sostituisci COMPUTE_ZONE con la zona del control plane.
Crea il pool di nodi basato su GPU con uno dei seguenti comandi. Il comando da eseguire dipende dall'opzione di consumo che utilizzi per la tua implementazione. Seleziona la scheda corrispondente al modello di provisioning dell'opzione di consumo.
Con prenotazione
Per il provisioning vincolato alla prenotazione, esegui il comando seguente:
```
  gcloud container node-pools create NODE_POOL_NAME \
      --region COMPUTE_REGION --cluster CLUSTER_NAME \
      --node-locations COMPUTE_ZONE \
      --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
      --machine-type MACHINE_TYPE \
      --num-nodes=NUM_NODES \
      --reservation-affinity=specific \
      --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME
```
Sostituisci quanto segue:
- NODE_POOL_NAME: il nome del pool di nodi.
- COMPUTE_REGION: la regione del nuovo cluster.
- CLUSTER_NAME: il nome del nuovo cluster.
- COMPUTE_ZONE: la zona del pool di nodi.
- GPU_TYPE: il tipo di acceleratore GPU:
  - VM A4: inserisci nvidia-b200.
  - VM A3 Ultra: inserisci nvidia-h200-141gb.
- AMOUNT: il numero di GPU da collegare ai nodi nel pool di nodi. Ad esempio, per le VM a4-highgpu-8g e a3-ultragpu-8g, la quantità di GPU è 8.
- DRIVER_VERSION: la versione del driver NVIDIA da installare. Può essere uno dei seguenti valori: default, latest o disabled.
- MACHINE_TYPE: il tipo di macchina Compute Engine per i nodi. Ad esempio, utilizza a4-highgpu-8g per le VM A4 e a3-ultragpu-8g per le VM A3 Ultra.
- NUM_NODES: il numero di nodi per il node pool.
- 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 Visualizza le richieste di prenotazione futura.
Avvio flessibile

Anteprima

Questo prodotto o funzionalità è soggetto ai "Termini delle Offerte pre-GA" nella sezione Termini di servizio generali dei Termini di servizio specifici. I prodotti e le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni delle fasi di lancio.

Per il provisioning con inizio flessibile, esegui questo comando:
```
  gcloud container node-pools create NODE_POOL_NAME \
      --region COMPUTE_REGION --cluster CLUSTER_NAME \
      --node-locations COMPUTE_ZONE \
      --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
      --machine-type MACHINE_TYPE \
      --flex-start --enable-autoscaling --num-nodes=0 \
      --total-max-nodes TOTAL_MAX_NODES \
      --no-enable-autorepair --location-policy=ANY \
      --reservation-affinity=none [\
      --enable-queued-provisioning]
```
Sostituisci quanto segue:
- NODE_POOL_NAME: il nome del pool di nodi.
- COMPUTE_REGION: la regione del nuovo cluster.
- CLUSTER_NAME: il nome del nuovo cluster.
- COMPUTE_ZONE: la zona del pool di nodi.
- GPU_TYPE: il tipo di acceleratore GPU:
  - VM A4: inserisci nvidia-b200.
  - VM A3 Ultra: inserisci nvidia-h200-141gb.
- AMOUNT: il numero di GPU da collegare ai nodi nel pool di nodi. Ad esempio, per le VM a4-highgpu-8g e a3-ultragpu-8g, la quantità di GPU è 8.
- DRIVER_VERSION: la versione del driver NVIDIA da installare. Può essere uno dei seguenti valori: default, latest o disabled.
- MACHINE_TYPE: il tipo di macchina Compute Engine per i nodi. Ad esempio, utilizza a4-highgpu-8g per le VM A4 e a3-ultragpu-8g per le VM A3 Ultra.
- TOTAL_MAX_NODES: il numero massimo di nodi da scalare automaticamente per l'interopool di nodil.
  
  Se vuoi utilizzare l'avvio flessibile con il provisioning in coda, includi il flag --enable-queued-provisioning.
  
  Per saperne di più sull'utilizzo dell'avvio flessibile, consulta Esegui workload su larga scala con l'avvio flessibile con provisioning in coda.
Spot
Per il provisioning spot, esegui questo comando:
```
  gcloud container node-pools create NODE_POOL_NAME \
      --region COMPUTE_REGION --cluster CLUSTER_NAME \
      --node-locations COMPUTE_ZONE \
      --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
      --machine-type MACHINE_TYPE \
      --num-nodes=NUM_NODES \
      --spot
```
Sostituisci quanto segue:
- NODE_POOL_NAME: il nome del pool di nodi.
- COMPUTE_REGION: la regione del nuovo cluster.
- CLUSTER_NAME: il nome del nuovo cluster.
- COMPUTE_ZONE: la zona del pool di nodi.
- GPU_TYPE: il tipo di acceleratore GPU:
  - VM A4: inserisci nvidia-b200.
  - VM A3 Ultra: inserisci nvidia-h200-141gb.
- AMOUNT: il numero di GPU da collegare ai nodi nel pool di nodi. Ad esempio, per le VM a4-highgpu-8g e a3-ultragpu-8g, la quantità di GPU è 8.
- DRIVER_VERSION: la versione del driver NVIDIA da installare. Può essere uno dei seguenti valori: default, latest o disabled.
- MACHINE_TYPE: il tipo di macchina Compute Engine per i nodi. Ad esempio, utilizza a4-highgpu-8g per le VM A4 e a3-ultragpu-8g per le VM A3 Ultra.
- NUM_NODES: il numero di nodi per il node pool.
  
  Per ulteriori informazioni sulla creazione di cluster con VM spot, consulta Esegui carichi di lavoro a tolleranza di errore a costi inferiori con le VM spot.
Connettiti al cluster per poter eseguire i comandi kubectl nelle sezioni successive:
```
  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 un cluster con GPUDirect RDMA

Per i workload di AI distribuiti, spesso vengono collegati più nodi GPU per funzionare come un unico computer. Le VM A4 e A3 Ultra sono dotate dell'adattatore di rete Titanium ML, basato su NIC NVIDIA ConnectX-7 (CX7). Sia le VM A4 che le VM A3 Ultra forniscono 3,2 Tbps di traffico GPU-GPU non bloccante tra i nodi utilizzando RDMA su Converged Ethernet (RoCE). RoCE consente scalabilità e collaborazione su più GPU offrendo un'esperienza cloud ad alte prestazioni per i workload AI.

Per ulteriori informazioni su come creare i cluster GKE utilizzando la Google Cloud CLI e GPUDirect TCPX (VM A3 High) o TCPXO (VM A3 Mega), consulta Massimizzare la larghezza di banda di rete della GPU nei cluster in modalità Autopilot, o Massimizzare la larghezza di banda di rete della GPU nei cluster in modalità Standard.

Per creare i cluster GKE in modalità Autopilot o Standard con GPUDirect RDMA, completa i seguenti passaggi, descritti nelle sezioni successive:

Crea VPC e subnet
Crea il cluster GKE con il multinetworking
Crea oggetti di rete GKE
Installa il binario RDMA e configura NCCL
Esegui il deployment ed esegui un test NCCL
Configurare i manifest dei pod per GPUDirect-RDMA

Crea VPC e subnet

Le VM A4 e A3 Ultra hanno la seguente configurazione:

Otto GPU NVIDIA B200 (A4) o H200 (A3 Ultra) per macchina virtuale collegate con NVLink
Due CPU Intel Emerald Rapids
Otto NIC CX-7 da 400 Gbps per il networking da GPU a GPU
Due 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 carichi di lavoro che richiedono prestazioni elevate, velocità effettiva elevata e bassa latenza, GPUDirect RDMA riduce gli hop di rete necessari per trasferire i payload alle GPU e dalle GPU, utilizzando in modo più efficiente la larghezza di banda di rete disponibile. GPUDirect RDMA è progettato per migliorare significativamente il throughput su larga scala rispetto alle GPU che non utilizzano GPUDirect.

Una delle NIC Google Titanium associate alla CPU utilizza la rete predefinita in GKE. Non è necessario creare una nuova rete VPC per questa NIC se hai 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 otto NIC CX-7 RDMA utilizzando questi comandi.

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: a4high-gvnic per le VM A4 o a3ultra-gvnic per le VM A3 Ultra.
- RDMA_NETWORK_PREFIX: a4high-rdma per le VM A4 o a3ultra-rdma per le VM A3 Ultra.

Crea due reti VPC:

# Create a VPC for the additional Google Titanium CPU NIC
gcloud compute --project=${PROJECT} \
  networks create \
  ${GVNIC_NETWORK_PREFIX}-net \
  --subnet-mode=custom

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 8 subnets.
gcloud beta 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 7); 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

Autopilot

Crea un cluster GKE Autopilot con funzionalità multi-networking:
```
gcloud container clusters create-auto CLUSTER_NAME \
    --enable-multi-networking \
    --cluster-version=CLUSTER_VERSION \
    --region=COMPUTE_REGION
```
Sostituisci quanto segue:
- CLUSTER_NAME: il nome del tuo cluster.
- CLUSTER_VERSION: la versione del nuovo cluster. Per scoprire quale versione di GKE supporta la tua configurazione, consulta la sezione Requisiti.
- COMPUTE_REGION: il nome della regione di computing.
Connettiti al cluster per poter eseguire i comandi kubectl nelle sezioni successive:
```
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.

Standard

Crea un cluster GKE Standard e pool di nodi GPU con multi-networking:

Crea il cluster:
```
gcloud container clusters create CLUSTER_NAME \
  --region=COMPUTE_REGION \
  --cluster-version=CLUSTER_VERSION \
  --enable-dataplane-v2 --enable-ip-alias --enable-multi-networking [\
  --services-ipv4-cidr=SERVICE_CIDR \
  --cluster-ipv4-cidr=POD_CIDR]
```
Sostituisci quanto segue:
- CLUSTER_NAME: il nome del tuo cluster.
- CLUSTER_VERSION: la versione del nuovo cluster. Per scoprire quale versione di GKE supporta la tua configurazione, consulta la sezione Requisiti.
- 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, gli intervalli nei valori SERVICE_CIDR=10.65.0.0/19 e POD_CIDR=10.64.0.0/19 non si sovrappongono tra loro. Per saperne di più, vedi Aggiunta di intervalli di indirizzi IPv4 dei pod.
Crea il pool di nodi. Il comando da eseguire dipende dall'opzione di consumo che utilizzi per la tua implementazione. Seleziona la scheda corrispondente al modello di provisioning dell'opzione di consumo.
Con prenotazione
Per il provisioning vincolato alla prenotazione, esegui il comando seguente:
```
gcloud container node-pools create NODE_POOL_NAME \
  --region COMPUTE_REGION --cluster CLUSTER_NAME \
  --node-locations COMPUTE_ZONE \
  --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
  --machine-type MACHINE_TYPE \
  --num-nodes=NUM_NODES \
  --reservation-affinity=specific \
  --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME  \
  --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 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-4 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-5 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-6 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-7
```
Sostituisci quanto segue:
- NODE_POOL_NAME: il nome del pool di nodi.
- COMPUTE_REGION: la regione del nuovo cluster.
- CLUSTER_NAME: il nome del nuovo cluster.
- COMPUTE_ZONE: la zona del pool di nodi.
- GPU_TYPE: il tipo di acceleratore GPU:
  - VM A4: inserisci nvidia-b200.
  - VM A3 Ultra: inserisci nvidia-h200-141gb.
- AMOUNT: il numero di GPU da collegare ai nodi nel pool di nodi. Ad esempio, per le VM a4-highgpu-8g e a3-ultragpu-8g, la quantità di GPU è 8.
- DRIVER_VERSION: la versione del driver NVIDIA da installare. Può essere uno dei seguenti valori: default, latest o disabled.
- MACHINE_TYPE: il tipo di macchina Compute Engine per i nodi. Ad esempio, utilizza a4-highgpu-8g per le VM A4 e a3-ultragpu-8g per le VM A3 Ultra.
- MACHINE_TYPE: il tipo di macchina Compute Engine per i nodi. Ad esempio, utilizza a4-highgpu-8g per le VM A4 e a3-ultragpu-8g per le VM A3 Ultra.
- NUM_NODES: il numero di nodi per il node pool. Per l'avvio flessibile, questo valore deve essere impostato su 0.
- 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 Visualizza le richieste di prenotazione futura.
Avvio flessibile

Anteprima

Questo prodotto o funzionalità è soggetto ai "Termini delle Offerte pre-GA" nella sezione Termini di servizio generali dei Termini di servizio specifici. I prodotti e le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni delle fasi di lancio.

Per il provisioning con inizio flessibile, esegui questo comando:
```
gcloud container node-pools create NODE_POOL_NAME \
  --region COMPUTE_REGION --cluster CLUSTER_NAME \
  --node-locations COMPUTE_ZONE \
  --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
  --machine-type MACHINE_TYPE \
  --num-nodes=NUM_NODES \
  --flex-start --num-nodes=0 --enable-autoscaling \
  --total-max-nodes TOTAL_MAX_NODES \
  --no-enable-autorepair --location-policy=ANY \
  --reservation-affinity=none \
  [--enable-queued-provisioning \]
  --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 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-4 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-5 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-6 \
  --additional-node-network network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-7
```
Sostituisci quanto segue:
- NODE_POOL_NAME: il nome del pool di nodi.
- COMPUTE_REGION: la regione del nuovo cluster.
- CLUSTER_NAME: il nome del nuovo cluster.
- COMPUTE_ZONE: la zona del pool di nodi.
- GPU_TYPE: il tipo di acceleratore GPU:
  - VM A4: inserisci nvidia-b200.
  - VM A3 Ultra: inserisci nvidia-h200-141gb.
- AMOUNT: il numero di GPU da collegare ai nodi nel pool di nodi. Ad esempio, per le VM a4-highgpu-8g e a3-ultragpu-8g, la quantità di GPU è 8.
- DRIVER_VERSION: la versione del driver NVIDIA da installare. Può essere uno dei seguenti valori: default, latest o disabled.
- MACHINE_TYPE: il tipo di macchina Compute Engine per i nodi. Ad esempio, utilizza a4-highgpu-8g per le VM A4 e a3-ultragpu-8g per le VM A3 Ultra.
- MACHINE_TYPE: il tipo di macchina Compute Engine per i nodi. Ad esempio, utilizza a4-highgpu-8g per le VM A4 e a3-ultragpu-8g per le VM A3 Ultra.
- NUM_NODES: il numero di nodi per il node pool. Per l'avvio flessibile, questo valore deve essere impostato su 0.
- TOTAL_MAX_NODES: il numero massimo di nodi da scalare automaticamente per l'intero pool di nodi.
Se vuoi utilizzare l'avvio flessibile con il provisioning in coda, includi il flag --enable-queued-provisioning.

Per saperne di più sull'utilizzo dell'avvio flessibile, consulta Esegui workload su larga scala con l'avvio flessibile con provisioning in coda.
Connettiti al cluster per poter eseguire i comandi kubectl nelle sezioni successive:
```
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 gli oggetti di rete GKE

Le reti VPC create nella sezione precedente devono essere configurate 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 otto NIC CX-7 RDMA deve essere configurata in modalità RDMA.

Questo comando utilizza i seguenti nomi:

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

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
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-4
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-4
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-4
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-4
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-5
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-5
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-5
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-5
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-6
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-6
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-6
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-6
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-7
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-7
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-7
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-7
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.

Autopilot

Per la modalità GKE Autopilot, esegui questo comando:

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

Standard

Per la modalità GKE Standard, esegui questo comando:

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

Esegui test NCCL

Per convalidare la funzionalità del cluster di cui è stato eseguito il provisioning, puoi eseguire un test NCCL. Per le istruzioni, vedi Eseguire il deployment e l'esecuzione di un test NCCL.

Configura i manifest dei pod per GPUDirect RDMA

Per eseguire i workload utilizzando GPUDirect RDMA, configura i manifest dei pod con i seguenti passaggi:

Aggiungi le seguenti annotazioni ai metadati del pod.

Autopilot

Utilizza la seguente annotazione per la modalità GKE Autopilot:

metadata:
annotations:
  networking.gke.io/default-interface: 'eth0'
  networking.gke.io/interfaces: |
    [
      {"interfaceName":"eth0","network":"default"},
      {"interfaceName":"eth1","network":"gvnic-1"},
      {"interfaceName":"eth2","network":"rdma-0"},
      {"interfaceName":"eth3","network":"rdma-1"},
      {"interfaceName":"eth4","network":"rdma-2"},
      {"interfaceName":"eth5","network":"rdma-3"},
      {"interfaceName":"eth6","network":"rdma-4"},
      {"interfaceName":"eth7","network":"rdma-5"},
      {"interfaceName":"eth8","network":"rdma-6"},
      {"interfaceName":"eth9","network":"rdma-7"}
    ]

Standard

La seguente annotazione per la modalità GKE Standard non include una specificagvnic-1, ma puoi aggiungerla se i tuoi workload lo richiedono.

Utilizza la seguente annotazione per la modalità GKE Standard:

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"},
      {"interfaceName":"eth6","network":"rdma-4"},
      {"interfaceName":"eth7","network":"rdma-5"},
      {"interfaceName":"eth8","network":"rdma-6"},
      {"interfaceName":"eth9","network":"rdma-7"}
    ]

Specifica il tipo di GPU scelto e la prenotazione specifica utilizzando i selettori di nodi:
```
spec:
  nodeSelector:
    cloud.google.com/gke-accelerator: ACCELERATOR
    cloud.google.com/reservation-name: RESERVATION_NAME
    cloud.google.com/reservation-affinity: "specific"
```
Sostituisci quanto segue:
- ACCELERATOR: l'acceleratore che hai prenotato nella prenotazione di capacità di Compute Engine. Devi utilizzare uno dei seguenti valori:
  - nvidia-b200: NVIDIA B200 (180 GB) per le VM A4
  - nvidia-h200-141gb: NVIDIA H200 (141 GB) per le VM A3 Ultra
- RESERVATION_NAME: il nome della prenotazione di capacità di Compute Engine.
Per utilizzare le prenotazioni condivise o blocchi e sottoblocchi specifici di prenotazioni, consulta le sezioni corrispondenti in Utilizzo di risorse di percorso a livello di zona prenotate.

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, variabili di ambiente e risorse al container che richiede GPU. Il container del workload deve richiedere tutte e otto le GPU:

Autopilot

Per la modalità GKE Autopilot, configura le seguenti risorse:

containers:
  - name: my-container
    volumeMounts:
      - name: library-dir-host
        mountPath: /usr/local/nvidia
        readOnly: true
      - name: gib
        mountPath: /usr/local/gib
        readOnly: true
    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
    resources:
      limits:
        nvidia.com/gpu: 8

Standard

Per la modalità GKE Standard, configura le seguenti risorse:

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: 8

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

Le seguenti schede includono esempi di manifest di pod completi.

Autopilot

Per la modalità GKE Autopilot, un manifest del pod completato dovrebbe essere simile al seguente:

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":"eth1","network":"gvnic-1"},
        {"interfaceName":"eth2","network":"rdma-0"},
        {"interfaceName":"eth3","network":"rdma-1"},
        {"interfaceName":"eth4","network":"rdma-2"},
        {"interfaceName":"eth5","network":"rdma-3"},
        {"interfaceName":"eth6","network":"rdma-4"},
        {"interfaceName":"eth7","network":"rdma-5"},
        {"interfaceName":"eth8","network":"rdma-6"},
        {"interfaceName":"eth9","network":"rdma-7"}
      ]
spec:
  ...
  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
          readOnly: true
        - name: gib
          mountPath: /usr/local/gib
          readOnly: true
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      resources:
        limits:
          nvidia.com/gpu: 8
          ...

Standard

Per la modalità GKE Standard, un manifest del pod completato dovrebbe essere simile al seguente:

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"},
        {"interfaceName":"eth6","network":"rdma-4"},
        {"interfaceName":"eth7","network":"rdma-5"},
        {"interfaceName":"eth8","network":"rdma-6"},
        {"interfaceName":"eth9","network":"rdma-7"}
      ]
spec:
  ...
  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: 8
          ...

Testare le prestazioni di rete per i cluster che utilizzano GPUDirect RDMA

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 saperne di più sulla pianificazione dei workload sui cluster GKE utilizzando Topology Aware Scheduling (TAS) e Kueue, consulta Pianificare i workload GKE con Topology Aware Scheduling.
Per saperne di più sulla gestione degli eventi comuni pertinenti ai cluster GKE e ai workload di AI, consulta Gestire i cluster GKE ottimizzati per l'AI.
Per informazioni su come testare l'ambiente per una configurazione e un'ottimizzazione corrette, consulta Ottimizzare il networking del cluster utilizzando NCCL/gIB.

Crea un cluster GKE personalizzato ottimizzato per l'AI che utilizza A4 o A3 Ultra Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Opzioni di configurazione del cluster con GPUDirect RDMA

Prima di iniziare

Ruoli obbligatori

Scegli un'opzione di consumo e ottieni la capacità

Requisiti

Crea un cluster GKE ottimizzato per l'AI

Considerazioni per la creazione di un cluster

Crea un cluster senza GPUDirect RDMA

Con prenotazione

Avvio flessibile

Spot

Crea un cluster con GPUDirect RDMA

Crea VPC e subnet

Crea il cluster GKE con il networking multiplo

Autopilot

Standard

Con prenotazione

Avvio flessibile

Crea gli oggetti di rete GKE

Installa il binario RDMA e configura NCCL

Autopilot

Standard

Esegui test NCCL

Configura i manifest dei pod per GPUDirect RDMA

Autopilot

Standard

Autopilot

Standard

Autopilot

Standard

Testare le prestazioni di rete per i cluster che utilizzano GPUDirect RDMA

Passaggi successivi

Crea un cluster GKE personalizzato ottimizzato per l'AI che utilizza A4 o A3 Ultra