Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Configurer GPUDirect RDMA avec le programme d'installation NCCL automatisé

Autopilot Standard

Lorsque vous exécutez des charges de travail d'IA/ML distribuées, vos applications nécessitent souvent une communication à haut débit et à faible latence entre les GPU sur plusieurs nœuds. Les instances de machine virtuelle (VM) A4 et les instances de VM A3 Ultra sont équipées de l'adaptateur réseau Titanium ML, qui repose sur des cartes d'interface réseau NVIDIA ConnectX-7 (CX7). Les deux familles de VM fournissent un trafic non bloquant de 3,2 Tbit/s entre les GPU des nœuds à l'aide de RDMA over Converged Ethernet (RoCE). RoCE permet de faire évoluer et de collaborer sur plusieurs GPU en offrant une expérience cloud hautes performances pour les charges de travail d'IA.

Bien que GPUDirect RDMA fournisse ce chemin de communication direct, la configuration manuelle des plug-ins réseau et des revendications de ressources nécessaires peut être complexe et sujette aux erreurs.

Pour résoudre ce problème opérationnel, vous pouvez combiner le programme d'installation RDMA NCCL automatisé avec la mise en réseau automatisée et DRANET géré par Google Kubernetes Engine (GKE) afin de simplifier la configuration de GPUDirect RDMA pour les charges de travail d'IA sur plusieurs hôtes sur GKE. Le programme d'installation NCCL RDMA automatisé déploie automatiquement les binaires NCCL et gIB requis sur les pools de nœuds qui utilisent des types de machines A3 Ultra ou A4. Lorsque vous utilisez ces fonctionnalités ensemble, vous pouvez vous concentrer sur le déploiement de vos charges de travail d'IA plutôt que sur la gestion manuelle de l'infrastructure réseau et des revendications de ressources sous-jacentes.

Pour en savoir plus, consultez Créer un cluster avec GPUDirect RDMA.

Avantages

Le programme d'installation automatisé de RDMA NCCL offre les avantages suivants :

Installation automatique des bibliothèques RDMA NCCL : à partir de la version 1.34.8-gke.1278000 de GKE pour les clusters Standard et de la version 1.36.2-gke.1368000 pour les clusters Autopilot, vous pouvez activer l'installation automatique des bibliothèques RDMA NCCL/gIB conçues pour des performances réseau GPU optimales sur Google Cloud lors de la création du pool de nœuds à l'aide d'un seul flag.
Configuration simplifiée pour l'exécution des charges de travail RDMA : en combinant le programme d'installation NCCL RDMA automatisé, la mise en réseau automatisée pour les VM d'accélérateur et DRANET géré par GKE, vous pouvez déployer des charges de travail d'IA compatibles avec RDMA sans configuration réseau manuelle.
Compatibilité et mises à niveau sécurisées : les binaires NCCL RDMA fournis par le programme d'installation passent des tests de qualification de bout en bout avant chaque version de GKE. Ces tests garantissent que les bibliothèques d'espace utilisateur RDMA restent compatibles avec les versions de noyau spécifiques utilisées dans GKE, ce qui vous permet de mettre à niveau vos clusters et vos pools de nœuds en toute sécurité sans perturber les charges de travail en cours d'exécution.

Limites

Le programme d'installation automatisé de RDMA NCCL présente les limites suivantes :

Le programme d'installation automatisé de RDMA NCCL est compatible avec les clusters GKE Standard à partir de la version 1.34.8-gke.1278000 et avec les clusters Autopilot à partir de la version 1.36.2-gke.1368000.
Vous ne pouvez utiliser le programme d'installation NCCL RDMA automatisé que sur les types de machines a3-ultragpu-8g et a4-highgpu-8g.
Si vous utilisez DRANET géré par GKE pour configurer des charges de travail, consultez les points clés et limites de DRANET géré par GKE.
Vous ne pouvez pas utiliser à la fois l'API multiréseau et DRANET dans le même pool de nœuds. Vous devez choisir une méthode de rattachement de réseau pour vos pods.
Les nœuds GKE doivent utiliser une image de nœud Container-Optimized OS. Les images de nœuds Ubuntu et Windows ne sont pas compatibles.
Vous devez remplir toutes les autres conditions requises pour exécuter A3 Ultra et A4 avec GPUDirect RDMA sur GKE.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

Vérifiez que votre cluster utilise GKE version 1.34.8-gke.1278000 ou ultérieure pour les clusters Standard, ou la version 1.36.2-gke.1368000 ou ultérieure pour les clusters Autopilot.
Vérifiez que vous utilisez la version 550.0.0 ou ultérieure de la Google Cloud CLI.
Assurez-vous de disposer d'un cluster Autopilot ou Standard existant. Pour créer un cluster, consultez la page Créer un cluster Autopilot.
Vérifiez que GKE Dataplane V2 est activé sur votre cluster. (Vous pouvez activer GKE Dataplane V2 lorsque vous créez un cluster en spécifiant l'option --enable-dataplane-v2.) GKE Dataplane V2 est activé par défaut pour tous les nouveaux clusters Autopilot.
Vérifiez que vous avez configuré la mise en réseau des clusters et des pools de nœuds à l'aide de l'une des méthodes suivantes :
- Mise en réseau automatisée avec DRANET (recommandé) : utilisez la mise en réseau automatisée pour les VM d'accélérateur avec un profil réseau d'accélérateur et DRANET géré par GKE pour le rattachement de réseau.
- Mise en réseau manuelle avec l'API multiréseau : suivez le workflow manuel pour créer des réseaux et des sous-réseaux VPC, activer l'API multiréseau GKE et configurer des réseaux de nœuds supplémentaires sur le pool de nœuds d'accélérateur.
Vérifiez que vous disposez d'un quota d'instances de machine virtuelle (VM) d'au moins deux. Ce quota minimal correspond à 16 GPU si vous utilisez les types de machines a4-highgpu-8g ou a3-ultragpu-8g.

Créer un pool de nœuds avec le programme d'installation et la mise en réseau automatisée

Pour activer GPUDirect RDMA pour les charges de travail d'IA multi-hôtes, configurez un pool de nœuds GPU qui combine le programme d'installation RDMA NCCL automatisé, la mise en réseau automatisée et DRANET géré par GKE.

Sélectionnez l'une des options suivantes :

gcloud (Standard)

Pour activer le programme d'installation NCCL RDMA automatisé sur un pool de nœuds Standard, spécifiez rdma comme valeur pour l'option --gpudirect-strategy. GKE déploie automatiquement le plug-in RDMA NCCL compatible avec la version du nœud.

Définissez les variables d'environnement suivantes :
```
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
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster
- CONTROL_PLANE_LOCATION : emplacement du plan de contrôle du cluster.
- PROJECT_ID : ID de votre projet.
- NODE_POOL_NAME : nom du nouveau pool de nœuds.
- NODEPOOL_LOCATION : emplacement du pool de nœuds.
- ACCELERATOR_TYPE : type d'accélérateur, tel que nvidia-h200-141gb ou nvidia-b200.
- ACCELERATOR_COUNT : nombre d'accélérateurs, par exemple 8.
- DRIVER_VERSION : version du pilote de GPU, par exemple default ou latest.
- MACHINE_TYPE : type de machine, qui doit être a3-ultragpu-8g ou a4-highgpu-8g.
- NUM_NODES : nombre de nœuds dans le pool de nœuds.
- RESERVATION_PROJECT : ID du projet dans lequel se trouve la réservation.
- RESERVATION_NAME : nom de la réservation.
- RESERVATION_BLOCK : bloc de réservation.

Créez le pool de nœuds :

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

Pour utiliser le programme d'installation NCCL RDMA automatisé dans des clusters Autopilot ou dans des clusters standards avec création automatique de pools de nœuds, configurez une ressource ComputeClass personnalisée avec gpuDirect: rdma, acceleratorNetworkProfile: auto et DRANET activés.

Enregistrez le manifeste suivant sous le nom 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

Remplacez les éléments suivants :

COMPUTE_CLASS_NAME : nom de la ComputeClass.
ACCELERATOR_TYPE : type d'accélérateur, tel que nvidia-h200-141gb ou nvidia-b200.
ACCELERATOR_COUNT : nombre d'accélérateurs, par exemple 8.
MACHINE_TYPE : type de machine, qui doit être a3-ultragpu-8g ou a4-highgpu-8g.
RESERVATION_NAME : nom de votre réservation.
RESERVATION_ZONE : zone où se trouve la réservation.

Appliquez le fichier manifeste :
```
kubectl apply -f rdma-compute-class.yaml
```
Lorsque vous déployez une charge de travail qui utilise cette ComputeClass, ajoutez le sélecteur de nœud cloud.google.com/compute-class: COMPUTE_CLASS_NAME à la spécification de votre pod.

Terraform

Vous pouvez utiliser Terraform pour provisionner votre cluster GKE et votre pool de nœuds avec le programme d'installation RDMA NCCL automatisé configuré.

Installez Terraform sur votre machine locale en suivant la documentation officielle de Terraform.

Créez un répertoire vide pour stocker votre configuration, puis accédez-y. Créez un fichier nommé main.tf et renseignez-le avec les éléments suivants :

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

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet.
REGION : région de calcul.
ZONE : zone compatible avec les types de machines A3 Ultra ou A4.

Exécutez les commandes suivantes dans le même répertoire pour vous authentifier auprès deGoogle Cloud et initialiser l'état de Terraform :
```
gcloud auth application-default login
terraform init
```

Ajoutez la configuration suivante à votre fichier main.tf ou à un fichier de configuration Terraform distinct. Cette configuration déploie un cluster avec trois nœuds a3-ultragpu-8g dans us-central1-b, configurés pour utiliser le programme d'installation NCCL RDMA automatisé, un profil réseau d'accélérateur automatique et DRANET géré par 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"
    }
  }
}

Exécutez terraform plan -out=tfplan pour afficher les modifications apportées par Terraform en fonction de la configuration actuelle. Après avoir vérifié le plan, exécutez-le à l'aide de la commande suivante :
```
terraform apply tfplan
```
Remarque : La création du cluster et du pool de nœuds peut prendre plusieurs minutes. Exécutez TF_LOG=INFO terraform apply pour obtenir des journaux de progression détaillés.

Créer un ResourceClaimTemplate

Pour permettre aux pods de demander et de recevoir des appareils RDMA de manière dynamique, créez un objet ResourceClaimTemplate, qui permet de fournir une mise en réseau hautes performances pour les charges de travail d'IA. Le paramètre allocationMode: All alloue tous les appareils RDMA mrdma.google.com disponibles. L'allocation de tous les appareils disponibles est essentielle pour les charges de travail d'IA sur plusieurs hôtes qui nécessitent une utilisation complète des capacités des GPU et de RDMA.

Enregistrez le manifeste suivant sous le nom 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

Appliquez le fichier manifeste :

kubectl apply -f all-mrdma-template.yaml

Déployer et exécuter une charge de travail de test RDMA NCCL

Pour vérifier la configuration RDMA, déployez une charge de travail de test, puis exécutez un test NCCL all-gather pour confirmer la configuration.

Enregistrez le manifeste suivant sous le nom 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

Appliquez le fichier manifeste de la charge de travail de test :
```
kubectl apply -f nccl-test-workload.yaml
```

Exécutez un test NCCL complet entre les deux hôtes de 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

Déployer votre charge de travail d'IA/ML

Pour exécuter efficacement vos jobs d'entraînement distribués, vos applications de ML doivent demander les appareils RDMA provisionnés par le programme d'installation. Après avoir vérifié la configuration RDMA avec la charge de travail de test, vous pouvez déployer vos applications d'IA/ML. Les pods de votre application doivent référencer l'objet ResourceClaimTemplate que vous avez créé précédemment (all-mrdma) pour demander et recevoir des appareils RDMA de manière dynamique.

Le fichier manifeste de pod suivant utilise l'objet all-mrdma ResourceClaimTemplate. Remplacez IMAGE par l'image de conteneur de votre charge de travail d'IA/ML et COMMAND par le point d'entrée de votre application.

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"

Pour déployer cette charge de travail, enregistrez le fichier manifeste sous le nom workload.yaml et appliquez-le :

kubectl apply -f workload.yaml

Configurations avancées

Vous pouvez également activer le programme d'installation NCCL RDMA automatisé sur les pools de nœuds qui utilisent des configurations multiréseaux manuelles au lieu de la mise en réseau automatisée avec DRANET.

Créer un pool de nœuds sur un cluster avec le multiréseau activé

Si vous avez suivi les configurations de cluster dans Compatibilité de GPUDirect RDMA sur GKE, vous pouvez suivre les instructions ci-dessous pour créer un pool de nœuds avec le programme d'installation NCCL RDMA automatisé activé sur les clusters existants avec le multiréseau activé.

Pour vérifier si le multinéseau est activé sur votre cluster, exécutez la commande suivante :

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

Pour réutiliser les réseaux VPC pour des cartes d'interface réseau supplémentaires sur les instances de VM A3 Ultra et A4, définissez les variables suivantes :

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

Pour créer un pool de nœuds avec le programme d'installation NCCL RDMA automatisé, exécutez la commande suivante :

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

Étapes suivantes

Apprenez-en plus sur la compatibilité de GPUDirect RDMA sur GKE.