Mengonfigurasi GPUDirect RDMA dengan penginstal NCCL otomatis

Autopilot Standard

Saat Anda menjalankan workload AI/ML terdistribusi, aplikasi Anda sering kali memerlukan komunikasi dengan throughput tinggi dan latensi rendah antara GPU di beberapa node. Instance virtual machine (VM) A4 dan instance VM A3 Ultra dilengkapi dengan adaptor jaringan Titanium ML, yang dibangun di atas pengontrol antarmuka jaringan (NIC) NVIDIA ConnectX-7 (CX7). Kedua kelompok VM ini memberikan traffic GPU-ke-GPU antar-node 3,2 Tbps non-blocking dengan menggunakan RDMA over Converged Ethernet (RoCE). RoCE memungkinkan penskalaan dan kolaborasi di beberapa GPU dengan memberikan pengalaman cloud berperforma tinggi untuk workload AI.

Meskipun GPUDirect RDMA menyediakan jalur komunikasi langsung ini, mengonfigurasi plugin jaringan dan klaim resource yang diperlukan secara manual dapat menjadi rumit dan rentan terhadap error.

Untuk mengatasi tantangan operasional ini, Anda dapat menggabungkan penginstal NCCL RDMA otomatis dengan jaringan otomatis dan DRANET terkelola Google Kubernetes Engine (GKE) untuk menyederhanakan konfigurasi RDMA GPUDirect untuk workload AI di beberapa host di GKE. Penginstal NCCL RDMA otomatis akan otomatis men-deploy biner NCCL dan gIB yang diperlukan di node pool yang menggunakan jenis mesin A3 Ultra atau A4. Saat menggunakan fitur ini bersama-sama, Anda dapat berfokus pada men-deploy workload AI, bukan mengelola infrastruktur jaringan dan klaim resource yang mendasarinya secara manual.

Untuk mengetahui informasi selengkapnya, lihat Membuat cluster dengan GPUDirect RDMA.

Catatan: Penginstal NCCL RDMA otomatis hanya tersedia di Saluran rilis cepat.

Manfaat

Penginstal NCCL RDMA otomatis memberikan manfaat berikut:

• Penginstalan otomatis library RDMA NCCL: mulai dari GKE versi 1.34.8-gke.1278000 untuk cluster Standard dan versi 1.36.2-gke.1368000 untuk cluster Autopilot, Anda dapat mengaktifkan penginstalan otomatis library RDMA NCCL/gIB yang dirancang untuk performa jaringan GPU yang optimal di Google Cloud selama pembuatan node pool menggunakan satu flag.
• Konfigurasi yang disederhanakan untuk menjalankan workload RDMA: dengan menggabungkan penginstal NCCL RDMA otomatis, jaringan otomatis untuk VM akselerator, dan DRANET yang dikelola GKE, Anda dapat men-deploy workload AI yang mendukung RDMA tanpa konfigurasi jaringan manual.
• Kompatibilitas dan upgrade yang aman: biner NCCL RDMA yang disediakan oleh penginstal lulus pengujian kualifikasi menyeluruh sebelum setiap rilis GKE. Pengujian ini memastikan bahwa library ruang pengguna RDMA tetap kompatibel dengan versi kernel tertentu yang digunakan di GKE, sehingga Anda dapat mengupgrade cluster dan node pool dengan aman tanpa mengganggu workload yang sedang berjalan.

Batasan

Penginstal NCCL RDMA otomatis memiliki batasan berikut:

• Penginstal NCCL RDMA otomatis didukung di cluster GKE Standard mulai versi 1.34.8-gke.1278000 dan di cluster Autopilot mulai versi 1.36.2-gke.1368000.
• Anda hanya dapat menggunakan penginstal NCCL RDMA otomatis pada jenis mesin a3-ultragpu-8g dan a4-highgpu-8g.
• Jika Anda menggunakan DRANET terkelola GKE untuk mengonfigurasi workload, tinjau pertimbangan dan batasan utama untuk DRANET terkelola GKE.
• Anda tidak dapat menggunakan API multi-jaringan dan DRANET di node pool yang sama. Anda harus memilih satu metode untuk lampiran jaringan untuk Pod Anda.
• Node GKE harus menggunakan image node Container-Optimized OS. Image node Ubuntu dan Windows tidak didukung.
• Anda harus memenuhi semua persyaratan lainnya untuk menjalankan A3 Ultra dan A4 dengan GPUDirect RDMA di GKE.

Sebelum memulai

Sebelum memulai, pastikan Anda telah menjalankan tugas berikut:

• Pastikan cluster Anda menggunakan GKE versi 1.34.8-gke.1278000 atau yang lebih baru untuk cluster Standard, atau versi 1.36.2-gke.1368000 atau yang lebih baru untuk cluster Autopilot.
• Pastikan Anda menggunakan Google Cloud CLI versi 550.0.0 atau yang lebih baru.
• Pastikan Anda sudah memiliki cluster Autopilot atau Standard. Untuk membuat cluster baru, lihat Membuat cluster Autopilot.
• Pastikan cluster Anda telah mengaktifkan GKE Dataplane V2. (Anda dapat mengaktifkan GKE Dataplane V2 saat membuat cluster baru dengan menentukan flag --enable-dataplane-v2.) GKE Dataplane V2 diaktifkan secara default untuk semua cluster Autopilot baru.
• Pastikan Anda menyiapkan jaringan cluster dan node pool menggunakan salah satu metode berikut:
  • Jaringan otomatis dengan DRANET (direkomendasikan): gunakan jaringan otomatis untuk VM akselerator dengan profil jaringan akselerator dan DRANET yang dikelola GKE untuk lampiran jaringan.
  • Jaringan manual dengan API multi-jaringan: ikuti alur kerja manual untuk membuat jaringan dan subnet VPC, mengaktifkan API multi-jaringan GKE, dan mengonfigurasi jaringan node tambahan di node pool akselerator.
• Pastikan Anda memiliki kuota instance virtual machine (VM) minimum dua. Kuota minimum ini setara dengan 16 GPU jika Anda menggunakan jenis mesin a4-highgpu-8g atau a3-ultragpu-8g.

Membuat node pool dengan penginstal dan jaringan otomatis

Untuk mengaktifkan GPUDirect RDMA bagi workload AI multi-host, konfigurasikan node pool GPU yang menggabungkan penginstal NCCL RDMA otomatis, jaringan otomatis, dan DRANET terkelola GKE.

Pilih salah satu opsi berikut:

gcloud (Standard)

Untuk mengaktifkan penginstal NCCL RDMA otomatis di node pool Standar, tentukan rdma sebagai nilai untuk flag --gpudirect-strategy. GKE otomatis men-deploy plugin NCCL RDMA yang kompatibel dengan versi node.

1. Tetapkan variabel lingkungan berikut:

   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
   

   Ganti kode berikut:

   • CLUSTER_NAME: nama cluster Anda.
   • CONTROL_PLANE_LOCATION: lokasi untuk bidang kontrol cluster.
   • PROJECT_ID: project ID Anda.
   • NODE_POOL_NAME: nama untuk node pool baru.
   • NODEPOOL_LOCATION: lokasi untuk node pool.
   • ACCELERATOR_TYPE: jenis akselerator, seperti nvidia-h200-141gb atau nvidia-b200.
   • ACCELERATOR_COUNT: jumlah akselerator, seperti 8.
   • DRIVER_VERSION: versi driver GPU, seperti default atau latest.
   • MACHINE_TYPE: jenis mesin, yang harus berupa a3-ultragpu-8g atau a4-highgpu-8g.
   • NUM_NODES: jumlah node dalam node pool.
   • RESERVATION_PROJECT: project ID tempat pemesanan berada.
   • RESERVATION_NAME: nama pemesanan.
   • RESERVATION_BLOCK: blok pemesanan.

2. Buat node pool:

   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 dan Standard)

Untuk menggunakan penginstal NCCL RDMA otomatis di cluster Autopilot atau di cluster Standard dengan pembuatan otomatis node pool, konfigurasikan resource ComputeClass kustom dengan gpuDirect: rdma, acceleratorNetworkProfile: auto, dan DRANET diaktifkan.

1. Simpan manifes berikut sebagai 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
   

   Ganti kode berikut:

   • COMPUTE_CLASS_NAME: nama untuk ComputeClass.
   • ACCELERATOR_TYPE: jenis akselerator, seperti nvidia-h200-141gb atau nvidia-b200.
   • ACCELERATOR_COUNT: jumlah akselerator, seperti 8.
   • MACHINE_TYPE: jenis mesin, yang harus berupa a3-ultragpu-8g atau a4-highgpu-8g.
   • RESERVATION_NAME: nama pemesanan Anda.
   • RESERVATION_ZONE: zona tempat pemesanan berada.

2. Terapkan manifes:

   kubectl apply -f rdma-compute-class.yaml
   

   Saat Anda men-deploy workload yang menggunakan ComputeClass ini, tambahkan pemilih node cloud.google.com/compute-class: COMPUTE_CLASS_NAME ke spesifikasi Pod Anda.

Terraform

Anda dapat menggunakan Terraform untuk menyediakan cluster GKE dan node pool dengan penginstal NCCL RDMA otomatis yang dikonfigurasi.

1. Instal Terraform di komputer lokal Anda dengan mengikuti dokumentasi resmi Terraform.

2. Buat direktori kosong untuk menyimpan konfigurasi Anda dan pindah ke direktori tersebut. Buat file bernama main.tf dan isi dengan kode berikut:

   # 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"
   }
   

   Ganti kode berikut:

   • PROJECT_ID: project ID Anda.
   • REGION: region komputasi.
   • ZONE: zona yang mendukung jenis mesin A3 Ultra atau A4.

3. Jalankan perintah berikut di direktori yang sama untuk melakukan autentikasi dengan Google Cloud dan menginisialisasi status Terraform:

   gcloud auth application-default login
   terraform init
   

4. Tambahkan konfigurasi berikut ke main.tf atau file konfigurasi Terraform terpisah. Konfigurasi ini men-deploy cluster dengan tiga node a3-ultragpu-8g di us-central1-b yang dikonfigurasi untuk menggunakan penginstal NCCL RDMA otomatis, profil jaringan akselerator otomatis, dan DRANET yang dikelola 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"
       }
     }
   }
   

5. Jalankan terraform plan -out=tfplan untuk melihat perubahan yang dilakukan Terraform berdasarkan konfigurasi saat ini. Setelah memverifikasi rencana, jalankan dengan menggunakan perintah berikut:

   terraform apply tfplan
   

   Catatan: Pembuatan cluster dan node pool dapat memerlukan waktu beberapa menit untuk diselesaikan. Jalankan TF_LOG=INFO terraform apply untuk log progres mendetail.

Membuat ResourceClaimTemplate

Untuk mengizinkan Pod meminta dan menerima perangkat RDMA secara dinamis, buat objek ResourceClaimTemplate, yang membantu menyediakan jaringan berperforma tinggi untuk workload AI. Setelan allocationMode: All mengalokasikan semua perangkat RDMA mrdma.google.com yang tersedia. Mengalokasikan semua perangkat yang tersedia sangat penting untuk workload AI di beberapa host yang memerlukan pemanfaatan penuh kemampuan GPU dan RDMA.

1. Simpan manifes berikut sebagai 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
   

2. Terapkan manifes:

   kubectl apply -f all-mrdma-template.yaml
   

Men-deploy dan menjalankan workload pengujian RDMA NCCL

Untuk memverifikasi konfigurasi RDMA, deploy workload pengujian, lalu jalankan pengujian all-gather NCCL untuk mengonfirmasi penyiapan.

1. Simpan manifes berikut sebagai 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
   

2. Terapkan manifes workload pengujian:

   kubectl apply -f nccl-test-workload.yaml
   

3. Jalankan pengujian all-gather NCCL antara dua host pengujian:

   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
   

Men-deploy workload AI/ML Anda

Untuk menjalankan tugas pelatihan terdistribusi secara efisien, aplikasi ML Anda harus meminta perangkat RDMA yang disediakan oleh penginstal. Setelah memverifikasi konfigurasi RDMA dengan workload pengujian, Anda dapat men-deploy aplikasi AI/ML. Pod aplikasi Anda harus mereferensikan objek ResourceClaimTemplate yang Anda buat sebelumnya (all-mrdma) untuk meminta dan menerima perangkat RDMA secara dinamis.

Manifes Pod berikut menggunakan objek ResourceClaimTemplate all-mrdma. Ganti IMAGE dengan image container workload AI/ML Anda dan COMMAND dengan titik entri aplikasi Anda.

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"

Untuk men-deploy workload ini, simpan manifes sebagai workload.yaml dan terapkan:

kubectl apply -f workload.yaml

Konfigurasi lanjutan

Anda juga dapat mengaktifkan penginstal NCCL RDMA otomatis di node pool yang menggunakan konfigurasi multi-jaringan manual, bukan jaringan otomatis dengan DRANET.

Membuat node pool di cluster dengan multi-jaringan diaktifkan

Jika Anda mengikuti konfigurasi cluster di Dukungan GPUDirect RDMA di GKE, Anda dapat menggunakan petunjuk berikut untuk membuat node pool baru dengan penginstal NCCL RDMA otomatis yang diaktifkan di cluster yang ada dengan multi-jaringan diaktifkan.

Untuk memeriksa apakah cluster Anda telah mengaktifkan multi-jaringan, jalankan perintah berikut:

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)"

Untuk menggunakan kembali jaringan VPC untuk NIC tambahan di instance VM A3 Ultra dan A4, tetapkan variabel berikut:

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

Untuk membuat node pool dengan penginstal NCCL RDMA otomatis, jalankan perintah berikut:

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

Langkah berikutnya

• Pelajari lebih lanjut dukungan GPUDirect RDMA di GKE.