Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Configura GPUDirect RDMA con il programma di installazione automatica di NCCL

Autopilot Standard

Quando esegui workload AI/ML distribuiti, le tue applicazioni spesso richiedono una comunicazione ad alto throughput e bassa latenza tra le GPU su più nodi. Le istanze di macchine virtuali (VM) A4 e le istanze VM A3 Ultra sono dotate dell'adattatore di rete Titanium ML, basato sui controller di interfaccia di rete (NIC) NVIDIA ConnectX-7 (CX7). Entrambe le famiglie di VM offrono un traffico GPU-GPU tra nodi non bloccante di 3,2 Tbps utilizzando RDMA su Converged Ethernet (RoCE). RoCE consente la scalabilità e la collaborazione tra più GPU, offrendo un'esperienza cloud ad alte prestazioni per i workload di AI.

Sebbene GPUDirect RDMA fornisca questo percorso di comunicazione diretto, la configurazione manuale dei plug-in di rete e delle richieste di risorse necessarie può essere complessa e soggetta a errori.

Per risolvere questa sfida operativa, puoi combinare il programma di installazione NCCL RDMA automatizzato con il networking automatizzato e DRANET gestito da Google Kubernetes Engine (GKE) per semplificare la configurazione di GPUDirect RDMA per i workload AI su più host su GKE. Il programma di installazione NCCL RDMA automatico esegue automaticamente il deployment dei file binari NCCL e gIB richiesti nei pool di nodi che utilizzano tipi di macchine A3 Ultra o A4. Quando utilizzi queste funzionalità insieme, puoi concentrarti sul deployment dei workload di AI anziché sulla gestione manuale dell'infrastruttura di rete e delle richieste di risorse sottostanti.

Per saperne di più, consulta Crea un cluster con GPUDirect RDMA.

Vantaggi

Il programma di installazione NCCL RDMA automatico offre i seguenti vantaggi:

Installazione automatica delle librerie NCCL RDMA: a partire dalla versione GKE 1.34.8-gke.1278000 per i cluster Standard e dalla versione 1.36.2-gke.1368000 per i cluster Autopilot, puoi attivare l'installazione automatica delle librerie NCCL/gIB RDMA progettate per prestazioni di networking GPU ottimali su Google Cloud durante la creazione del pool di nodi utilizzando un singolo flag.
Configurazione semplificata per l'esecuzione di workload RDMA: combinando il programma di installazione NCCL RDMA automatizzato, il networking automatizzato per le VM acceleratore e DRANET gestito da GKE, puoi eseguire il deployment di workload AI abilitati per RDMA senza configurazione di rete manuale.
Compatibilità e upgrade sicuri: i binari NCCL RDMA forniti dal programma di installazione superano i test di qualificazione end-to-end prima di ogni release di GKE. Questo test garantisce che le librerie dello spazio utente RDMA rimangano compatibili con le versioni kernel specifiche utilizzate in GKE, in modo da poter eseguire l'upgrade dei cluster e dei node pool in sicurezza senza interrompere i workload in esecuzione.

Limitazioni

Il programma di installazione NCCL RDMA automatico presenta le seguenti limitazioni:

Il programma di installazione NCCL RDMA automatico è supportato sui cluster GKE Standard a partire dalla versione 1.34.8-gke.1278000 e sui cluster Autopilot a partire dalla versione 1.36.2-gke.1368000.
Puoi utilizzare il programma di installazione NCCL RDMA automatico solo sui tipi di macchine a3-ultragpu-8g e a4-highgpu-8g.
Se utilizzi DRANET gestito da GKE per configurare i workload, consulta le considerazioni principali e le limitazioni per DRANET gestito da GKE.
Non puoi utilizzare sia l'API multi-rete sia DRANET nello stesso pool di nodi. Devi scegliere un metodo per il collegamento di rete per i tuoi pod.
I nodi GKE devono utilizzare un'immagine nodo Container-Optimized OS. Le immagini dei nodi Ubuntu e Windows non sono supportate.
Devi soddisfare tutti gli altri requisiti per l'esecuzione di A3 Ultra e A4 con GPUDirect RDMA su GKE.

Prima di iniziare

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

Verifica che il cluster utilizzi GKE versione 1.34.8-gke.1278000 o successive per i cluster Standard o versione 1.36.2-gke.1368000 o successive per i cluster Autopilot.
Verifica di utilizzare Google Cloud CLI versione 550.0.0 o successiva.
Assicurati di avere un cluster Autopilot o Standard esistente. Per creare un nuovo cluster, vedi Crea un cluster Autopilot.
Verifica che nel cluster sia abilitato GKE Dataplane V2. (Puoi attivare GKE Dataplane V2 quando crei un nuovo cluster specificando il flag --enable-dataplane-v2.) GKE Dataplane V2 è abilitato per impostazione predefinita per tutti i nuovi cluster Autopilot.
Verifica di aver configurato il networking dei cluster e pool di nodi utilizzando uno dei seguenti metodi:
- Networking automatizzato con DRANET (consigliato): utilizza il networking automatizzato per le VM con acceleratore con un profilo di rete dell'acceleratore e DRANET gestito da GKE per il collegamento di rete.
- Networking manuale con l'API multi-rete: segui il flusso di lavoro manuale per creare reti e subnet VPC, abilitare l'API multi-rete GKE e configurare reti di nodi aggiuntive sul pool di nodi dell'acceleratore.
Verifica di avere una quota minima di istanze di macchine virtuali (VM) pari a due. Questa quota minima corrisponde a 16 GPU se utilizzi i tipi di macchina a4-highgpu-8g o a3-ultragpu-8g.

Crea un pool di nodi con il programma di installazione e il networking automatico

Per abilitare GPUDirect RDMA per i workload di AI multi-host, configura un pool di nodi GPU che combini il programma di installazione NCCL RDMA automatizzato, il networking automatizzato e DRANET gestito da GKE.

Seleziona una delle seguenti opzioni:

gcloud (Standard)

Per attivare il programma di installazione NCCL RDMA automatico su un pool di nodi Standard, specifica rdma come valore per il flag --gpudirect-strategy. GKE esegue automaticamente il deployment del plug-in NCCL RDMA compatibile con la versione del nodo.

Imposta le seguenti variabili di ambiente:
```
export CLUSTER_NAME=CLUSTER_NAME
export CONTROL_PLANE_LOCATION=CONTROL_PLANE_LOCATION
export PROJECT_ID=PROJECT_ID
export NODE_POOL_NAME=NODE_POOL_NAME
export NODEPOOL_LOCATION=NODEPOOL_LOCATION
export ACCELERATOR_TYPE=ACCELERATOR_TYPE
export ACCELERATOR_COUNT=ACCELERATOR_COUNT
export DRIVER_VERSION=DRIVER_VERSION
export MACHINE_TYPE=MACHINE_TYPE
export NUM_NODES=NUM_NODES
export RESERVATION_PROJECT=RESERVATION_PROJECT
export RESERVATION_NAME=RESERVATION_NAME
export RESERVATION_BLOCK=RESERVATION_BLOCK
```
Sostituisci quanto segue:
- CLUSTER_NAME: il nome del tuo cluster.
- CONTROL_PLANE_LOCATION: la località del control plane del cluster.
- PROJECT_ID: il tuo ID progetto.
- NODE_POOL_NAME: il nome del nuovo node pool.
- NODEPOOL_LOCATION: la località del pool di nodi.
- ACCELERATOR_TYPE: il tipo di acceleratore, ad esempio nvidia-h200-141gb o nvidia-b200.
- ACCELERATOR_COUNT: il numero di acceleratori, ad esempio 8.
- DRIVER_VERSION: la versione del driver della GPU, ad esempio default o latest.
- MACHINE_TYPE: il tipo di macchina, che deve essere a3-ultragpu-8g o a4-highgpu-8g.
- NUM_NODES: il numero di nodi nel node pool.
- RESERVATION_PROJECT: l'ID progetto in cui si trova la prenotazione.
- RESERVATION_NAME: il nome della prenotazione.
- RESERVATION_BLOCK: il blocco di prenotazione.

Crea il pool di nodi:

gcloud container node-pools create ${NODE_POOL_NAME} \
  --location=${CONTROL_PLANE_LOCATION} \
  --cluster=${CLUSTER_NAME} \
  --project=${PROJECT_ID} \
  --node-locations=${NODEPOOL_LOCATION} \
  --accelerator type=${ACCELERATOR_TYPE},count=${ACCELERATOR_COUNT},gpu-driver-version=${DRIVER_VERSION} \
  --machine-type=${MACHINE_TYPE} \
  --num-nodes=${NUM_NODES} \
  --reservation-affinity=specific \
  --reservation=projects/${RESERVATION_PROJECT}/reservations/${RESERVATION_NAME}/reservationBlocks/${RESERVATION_BLOCK} \
  --accelerator-network-profile=auto \
  --node-labels=cloud.google.com/gke-networking-dra-driver=true \
  --gpudirect-strategy=rdma

ComputeClass (Autopilot e Standard)

Per utilizzare il programma di installazione NCCL RDMA automatico nei cluster Autopilot o nei cluster Standard con la creazione automatica pool di nodi, configura una risorsa ComputeClass personalizzata con gpuDirect: rdma, acceleratorNetworkProfile: auto e DRANET abilitati.

Salva il seguente manifest come rdma-compute-class.yaml:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: COMPUTE_CLASS_NAME
spec:
  nodePoolConfig:
    dra:
      networking:
        enabled: true
  priorities:
  - gpu:
      type: ACCELERATOR_TYPE
      count: ACCELERATOR_COUNT
    machineType: MACHINE_TYPE
    # Optional: include the reservations block if you use a reservation
    reservations:
      affinity: Specific
      specific:
      - name: RESERVATION_NAME
        zones:
        - RESERVATION_ZONE
    acceleratorNetworkProfile: auto
    gpuDirect: rdma
  nodePoolAutoCreation:
    enabled: true

Sostituisci quanto segue:

COMPUTE_CLASS_NAME: il nome della classe ComputeClass.
ACCELERATOR_TYPE: il tipo di acceleratore, ad esempio nvidia-h200-141gb o nvidia-b200.
ACCELERATOR_COUNT: il numero di acceleratori, ad esempio 8.
MACHINE_TYPE: il tipo di macchina, che deve essere a3-ultragpu-8g o a4-highgpu-8g.
RESERVATION_NAME: il nome della tua prenotazione.
RESERVATION_ZONE: la zona in cui si trova la prenotazione.

Applica il manifest:
```
kubectl apply -f rdma-compute-class.yaml
```
Quando esegui il deployment di un workload che utilizza questa classe ComputeClass, aggiungi il selettore di nodi cloud.google.com/compute-class: COMPUTE_CLASS_NAME alla specifica del pod.

Terraform

Puoi utilizzare Terraform per eseguire il provisioning del cluster GKE e del node pool con il programma di installazione NCCL RDMA automatico configurato.

Installa Terraform sulla tua macchina locale seguendo la documentazione ufficiale di Terraform.

Crea una directory vuota in cui inserire la configurazione e passa a questa directory. Crea un file denominato main.tf e compilalo con i seguenti dati:

# main.tf

terraform {
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = ">= 7.34.0" # Min version that supports the automated RDMA NCCL installer
    }
  }
}

provider "google" {
  project = "PROJECT_ID"
  region  = "REGION"
  zone    = "ZONE"
}

Sostituisci quanto segue:

PROJECT_ID: il tuo ID progetto.
REGION: la regione di computing.
ZONE: una zona che supporta i tipi di macchine A3 Ultra o A4.

Esegui i seguenti comandi nella stessa directory per autenticarti conGoogle Cloud e inizializzare lo stato di Terraform:
```
gcloud auth application-default login
terraform init
```

Aggiungi la seguente configurazione al tuo main.tf o a un file di configurazione Terraform separato. Questa configurazione esegue il deployment di un cluster con tre nodi a3-ultragpu-8g in us-central1-b configurati per utilizzare il programma di installazione NCCL RDMA automatico, un profilo di rete dell'acceleratore automatico e DRANET gestito da GKE:

resource "google_container_cluster" "cluster" {
  name               = "example-rdma-tf"
  location           = "us-central1-b"

  initial_node_count  = 3 # Number of CPU nodes in default pool
  deletion_protection = false # Optional, allows Terraform to delete clusters

  min_master_version      = "1.34.8-gke.1278000" # Required, min version for Standard clusters with automated RDMA NCCL installer support
  datapath_provider       = "ADVANCED_DATAPATH" # Required, enable GKE Dataplane v2
}

resource "google_container_node_pool" "rdma_pool" {
  name       = "rdma-pool"
  cluster    = google_container_cluster.cluster.name
  location   = google_container_cluster.cluster.location
  node_count = 3

  network_config {
    accelerator_network_profile = "auto" # Required if per-NIC networks are not manually configured
  }

  node_config {
    machine_type = "a3-ultragpu-8g"
    guest_accelerator {
      type  = "nvidia-h200-141gb"
      count = 8
    }

    ephemeral_storage_local_ssd_config { # Required, see https://github.com/hashicorp/terraform-provider-google/issues/17068
      data_cache_count = 0
      local_ssd_count = 32
    }

    gpudirect_strategy = "RDMA"

    labels = {
      "cloud.google.com/gke-networking-dra-driver"  = "true" # Automatically install DRANET driver
      "gke.networks.io/accelerator-network-profile" = "auto"
    }
  }
}

Esegui terraform plan -out=tfplan per visualizzare le modifiche apportate da Terraform in base alla configurazione attuale. Dopo aver verificato il piano, eseguilo utilizzando il seguente comando:
```
terraform apply tfplan
```
Nota: la creazione del cluster e pool di nodi può richiedere diversi minuti. Esegui TF_LOG=INFO terraform apply per i log di avanzamento dettagliati.

Crea un ResourceClaimTemplate

Per consentire ai pod di richiedere e ricevere dinamicamente dispositivi RDMA, crea un oggetto ResourceClaimTemplate, che contribuisce a fornire un networking ad alte prestazioni per i workload AI. L'impostazione allocationMode: All alloca tutti i dispositivi RDMA mrdma.google.com disponibili. L'allocazione di tutti i dispositivi disponibili è fondamentale per i workload AI su più host che richiedono l'utilizzo completo delle funzionalità GPU e RDMA.

Salva il seguente manifest come all-mrdma-template.yaml:

apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: all-mrdma
spec:
  spec:
    devices:
      requests:
      - name: req-mrdma
        exactly:
          deviceClassName: mrdma.google.com
          allocationMode: All

Applica il manifest:

kubectl apply -f all-mrdma-template.yaml

Esegui il deployment e l'esecuzione di un workload di test RDMA NCCL

Per verificare la configurazione RDMA, esegui il deployment di un workload di test, quindi esegui un test all-gather NCCL per confermare la configurazione.

Salva il seguente manifest come nccl-test-workload.yaml:

apiVersion: v1
kind: Service
metadata:
  name: nccl-host-1
spec:
  selector:
    name: nccl-host-1
  clusterIP: None
---
apiVersion: v1
kind: Service
metadata:
  name: nccl-host-2
spec:
  selector:
    name: nccl-host-2
  clusterIP: None
---
apiVersion: v1
kind: Pod
metadata:
  name: nccl-test-host-1
  labels:
    name: nccl-host-1
spec:
  # Uncomment the following lines if you use a custom ComputeClass:
  # nodeSelector:
  #   cloud.google.com/compute-class: COMPUTE_CLASS_NAME
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib
    - name: shared-memory
      emptyDir:
        medium: "Memory"
        sizeLimit: 250Gi
  resourceClaims:
  - name: rdma
    resourceClaimTemplateName: all-mrdma
  containers:
    - image: us-docker.pkg.dev/gce-ai-infra/gpudirect-gib/nccl-plugin-gib-diagnostic:v1.1.2
      name: test
      resources:
        requests:
          cpu: 150m
        limits:
          nvidia.com/gpu: 8
        claims:
        - name: rdma
      volumeMounts:
        - name: library-dir-host
          mountPath: /usr/local/nvidia
        - name: gib
          mountPath: /usr/local/gib
        - name: shared-memory
          mountPath: /dev/shm
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      command: ["/bin/bash", "-c"]
      args:
        - |
          /scripts/container_entry.sh shell
          source /usr/local/gib/scripts/set_nccl_env.sh
          sleep infinity
---
apiVersion: v1
kind: Pod
metadata:
  name: nccl-test-host-2
  labels:
    name: nccl-host-2
spec:
  # Uncomment the following lines if you use a custom ComputeClass:
  # nodeSelector:
  #   cloud.google.com/compute-class: COMPUTE_CLASS_NAME
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib
    - name: shared-memory
      emptyDir:
        medium: "Memory"
        sizeLimit: 250Gi
  resourceClaims:
  - name: rdma
    resourceClaimTemplateName: all-mrdma
  containers:
    - image: us-docker.pkg.dev/gce-ai-infra/gpudirect-gib/nccl-plugin-gib-diagnostic:v1.1.2
      name: test
      resources:
        requests:
          cpu: 150m
        limits:
          nvidia.com/gpu: 8
        claims:
        - name: rdma
      volumeMounts:
        - name: library-dir-host
          mountPath: /usr/local/nvidia
        - name: gib
          mountPath: /usr/local/gib
        - name: shared-memory
          mountPath: /dev/shm
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      command: ["/bin/bash", "-c"]
      args:
        - |
          /scripts/container_entry.sh shell
          source /usr/local/gib/scripts/set_nccl_env.sh
          sleep infinity

Applica il manifest del workload di test:

kubectl apply -f nccl-test-workload.yaml

Esegui un test NCCL all-gather tra i due host di test:

kubectl exec nccl-test-host-1 -it -- /usr/local/gib/scripts/run_nccl_tests.sh -t all_gather -b 1K -e 8G nccl-host-1 nccl-host-2

Esegui il deployment del workload AI/ML

Per eseguire i job di addestramento distribuito in modo efficiente, le tue applicazioni ML devono richiedere i dispositivi RDMA di cui il programma di installazione ha eseguito il provisioning. Dopo aver verificato la configurazione RDMA con il workload di test, puoi eseguire il deployment delle tue applicazioni AI/ML. I pod dell'applicazione devono fare riferimento all'oggetto ResourceClaimTemplate che hai creato in precedenza (all-mrdma) per richiedere e ricevere dinamicamente i dispositivi RDMA.

Il seguente manifest del pod utilizza l'oggetto ResourceClaimTemplate all-mrdma. Sostituisci IMAGE con l'immagine container del workload AI/ML e COMMAND con l'entry point dell'applicazione.

apiVersion: v1
kind: Pod
metadata:
  name: my-rdma-workload
spec:
  restartPolicy: OnFailure
  # Uncomment the following lines if you use a custom ComputeClass:
  # nodeSelector:
  #   cloud.google.com/compute-class: COMPUTE_CLASS_NAME
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib
    - name: shared-memory
      emptyDir:
        medium: "Memory"
        sizeLimit: 250Gi
  resourceClaims:
  - name: mrdma-claim
    resourceClaimTemplateName: all-mrdma
  containers:
  - name: my-container
    image: IMAGE # Replace with your AI/ML workload image, for example, gcr.io/your-project/your-ai-app:latest
    command: ["/bin/bash", "-c"]
    args:
      - |
        source /usr/local/gib/scripts/set_nccl_env.sh
        COMMAND # Replace with your workload command, for example, python3 train.py
    resources:
      limits:
        nvidia.com/gpu: 8 # Specify the required GPU count
      claims:
      - name: mrdma-claim
    volumeMounts:
      - name: library-dir-host
        mountPath: /usr/local/nvidia
      - name: gib
        mountPath: /usr/local/gib
      - name: shared-memory
        mountPath: /dev/shm
    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
      - name: MASTER_ADDR
        value: "nccl-test-host-1" # Example for distributed training
      - name: MASTER_PORT
        value: "29500"

Per eseguire il deployment di questo workload, salva il manifest come workload.yaml e applicalo:

kubectl apply -f workload.yaml

Configurazioni avanzate

Puoi anche attivare il programma di installazione NCCL RDMA automatico sui pool di nodi che utilizzano configurazioni di rete multiple manuali anziché il networking automatico con DRANET.

Crea un pool di nodi su un cluster con più reti abilitate

Se hai seguito le configurazioni del cluster in Supporto di GPUDirect RDMA su GKE, puoi utilizzare le seguenti istruzioni per creare un nuovo pool di nodi con il programma di installazione NCCL RDMA automatico abilitato sui cluster esistenti con più reti abilitate.

Per verificare se il cluster ha più reti abilitate, esegui questo comando:

export CLUSTER_NAME=CLUSTER_NAME
export CONTROL_PLANE_LOCATION=CONTROL_PLANE_LOCATION
export PROJECT_ID=PROJECT_ID
export CLUSTER_VERSION=CLUSTER_VERSION

gcloud container clusters describe ${CLUSTER_NAME} \
  --location ${CONTROL_PLANE_LOCATION} --project ${PROJECT_ID} \
  --format="value(networkConfig.enableMultiNetworking)"

Per riutilizzare le reti VPC per NIC aggiuntive sulle istanze VM A3 Ultra e VM A4, imposta le seguenti variabili:

export REGION=REGION
export ZONE=ZONE
export GVNIC_NETWORK_PREFIX=GVNIC_NETWORK_PREFIX
export RDMA_NETWORK_PREFIX=RDMA_NETWORK_PREFIX

Per creare un pool di nodi con il programma di installazione NCCL RDMA automatico, esegui questo comando:

export NODE_POOL_NAME=NODE_POOL_NAME
export PROJECT_ID=PROJECT_ID
export NODE_COUNT=NODE_COUNT
export ACCELERATOR_TYPE=ACCELERATOR_TYPE
export ACCELERATOR_COUNT=ACCELERATOR_COUNT
export DRIVER_VERSION=DRIVER_VERSION
export MACHINE_TYPE=MACHINE_TYPE
export RESERVATION=RESERVATION

gcloud container node-pools create ${NODE_POOL_NAME} --project ${PROJECT_ID} \
  --location ${CONTROL_PLANE_LOCATION} --node-locations ${ZONE} --cluster ${CLUSTER_NAME} --num-nodes=${NODE_COUNT} \
  --machine-type ${MACHINE_TYPE} \
  --accelerator type=${ACCELERATOR_TYPE},count=${ACCELERATOR_COUNT},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 \
  --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 \
  --scopes "https://www.googleapis.com/auth/cloud-platform" \
  --reservation-affinity=specific \
  --reservation=${RESERVATION} \
  --gpudirect-strategy=rdma

Passaggi successivi

Scopri di più sul supporto di GPUDirect RDMA su GKE.