Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

GPUDirect RDMA mit dem automatischen NCCL-Installationsprogramm konfigurieren

Autopilot Standard

Wenn Sie verteilte KI-/ML-Arbeitslasten ausführen, benötigen Ihre Anwendungen häufig eine Kommunikation mit hohem Durchsatz und niedriger Latenz zwischen GPUs auf mehreren Knoten. Die A4-VM-Instanzen und A3 Ultra-VM-Instanzen sind mit dem Titanium ML-Netzwerkadapter ausgestattet, der auf NVIDIA ConnectX-7 (CX7)-Netzwerkschnittstellen-Controllern (NICs) basiert. Beide VM-Familien bieten einen nicht blockierenden GPU-zu-GPU-Traffic zwischen Knoten von 3,2 Tbit/s über RDMA-RoCE (Remote Direct Memory Access over Converged Ethernet). RoCE ermöglicht die Skalierung und Zusammenarbeit über mehrere GPUs hinweg, indem es eine leistungsstarke Cloud-Umgebung für KI-Arbeitslasten bietet.

GPUDirect RDMA bietet zwar diesen direkten Kommunikationspfad, die manuelle Konfiguration der erforderlichen Netzwerk-Plug-ins und Ressourcenanforderungen kann jedoch komplex und fehleranfällig sein.

Um diese betriebliche Herausforderung zu lösen, können Sie den automatisierten RDMA-NCCL-Installer mit automatisiertem Netzwerk und dem von der Google Kubernetes Engine (GKE) verwalteten DRANET kombinieren, um die GPUDirect-RDMA-Konfiguration für KI-Arbeitslasten auf mehreren Hosts in der GKE zu vereinfachen. Das automatisierte RDMA-NCCL-Installationsprogramm stellt die erforderlichen NCCL- und gIB-Binärdateien automatisch in Knotenpools bereit, die A3 Ultra- oder A4-Maschinentypen verwenden. Wenn Sie diese Funktionen zusammen verwenden, können Sie sich auf die Bereitstellung Ihrer KI-Arbeitslasten konzentrieren, anstatt die zugrunde liegende Netzwerkinfrastruktur und Ressourcenansprüche manuell zu verwalten.

Weitere Informationen finden Sie unter Cluster mit GPUDirect RDMA erstellen.

Vorteile

Das automatisierte RDMA-NCCL-Installationsprogramm bietet folgende Vorteile:

Automatische Installation von RDMA-NCCL-Bibliotheken: Ab GKE-Version 1.34.8-gke.1278000 für Standard-Cluster und Version 1.36.2-gke.1368000 für Autopilot-Cluster können Sie die automatische Installation der RDMA-NCCL/gIB-Bibliotheken aktivieren, die für eine optimale GPU-Netzwerkleistung auf Google Cloud bei der Erstellung von Knotenpools mit einem einzigen Flag entwickelt wurden.
Vereinfachte Konfiguration für die Ausführung von RDMA-Arbeitslasten: Durch die Kombination des automatisierten RDMA-NCCL-Installationsprogramms, der automatisierten Netzwerke für Beschleuniger-VMs und des von GKE verwalteten DRANET können Sie RDMA-fähige KI-Arbeitslasten ohne manuelle Netzwerkkonfiguration bereitstellen.
Kompatibilität und sichere Upgrades: Die vom Installationsprogramm bereitgestellten RDMA-NCCL-Binärdateien durchlaufen vor jedem GKE-Release End-to-End-Qualifizierungstests. Durch diese Tests wird sichergestellt, dass die RDMA-Nutzerbereichsbibliotheken mit den spezifischen Kernel-Versionen kompatibel bleiben, die in GKE verwendet werden. So können Sie Ihre Cluster und Knotenpools sicher aktualisieren, ohne laufende Arbeitslasten zu beeinträchtigen.

Beschränkungen

Für das automatisierte RDMA-NCCL-Installationsprogramm gelten die folgenden Einschränkungen:

Das automatisierte RDMA-NCCL-Installationsprogramm wird in GKE Standard-Clustern ab Version 1.34.8-gke.1278000 und in Autopilot-Clustern ab Version 1.36.2-gke.1368000 unterstützt.
Sie können das automatisierte RDMA-NCCL-Installationsprogramm nur auf den Maschinentypen a3-ultragpu-8g und a4-highgpu-8g verwenden.
Wenn Sie von GKE verwaltetes DRANET zum Konfigurieren von Arbeitslasten verwenden, lesen Sie die wichtigen Überlegungen und Einschränkungen für von GKE verwaltetes DRANET.
Sie können die Multi-Network API und DRANET nicht im selben Knotenpool verwenden. Sie müssen eine Methode für den Netzwerkanhang für Ihre Pods auswählen.
Die GKE-Knoten müssen ein Knoten-Image für Container-Optimized OS verwenden. Ubuntu- und Windows-Knoten-Images werden nicht unterstützt.
Sie müssen alle anderen Anforderungen für die Ausführung von A3 Ultra und A4 mit GPUDirect RDMA in GKE erfüllen.

Hinweis

Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:

Prüfen Sie, ob Ihr Cluster die GKE-Version 1.34.8-gke.1278000 oder höher für Standard-Cluster oder die Version 1.36.2-gke.1368000 oder höher für Autopilot-Cluster verwendet.
Prüfen Sie, ob Sie die Google Cloud CLI-Version 550.0.0 oder höher verwenden.
Prüfen Sie, ob Sie einen vorhandenen Autopilot- oder Standardcluster haben. Informationen zum Erstellen eines neuen Clusters finden Sie unter Autopilot-Cluster erstellen.
Prüfen Sie, ob in Ihrem Cluster GKE Dataplane V2 aktiviert ist. (Sie können GKE Dataplane V2 aktivieren, wenn Sie einen neuen Cluster erstellen, indem Sie das Flag --enable-dataplane-v2 angeben.) GKE Dataplane V2 ist für alle neuen Autopilot-Cluster standardmäßig aktiviert.
Prüfen Sie mit einer der folgenden Methoden, ob Sie das Cluster- und Knotenpoolnetzwerk eingerichtet haben:
- Automatische Netzwerke mit DRANET (empfohlen): Verwenden Sie automatische Netzwerke für Beschleuniger-VMs mit einem Netzwerkprofil für Beschleuniger und von GKE verwaltetem DRANET für den Netzwerkanhang.
- Manuelle Netzwerkkonfiguration mit der Multi-Netzwerk-API: Folgen Sie dem manuellen Workflow, um VPC-Netzwerke und Subnetze zu erstellen, die GKE Multi-Netzwerk-API zu aktivieren und zusätzliche Knotennetzwerke im Beschleuniger-Knotenpool zu konfigurieren.
Prüfen Sie, ob Sie ein Kontingent von mindestens zwei VM-Instanzen haben. Dieses Mindestkontingent entspricht 16 GPUs, wenn Sie die Maschinentypen a4-highgpu-8g oder a3-ultragpu-8g verwenden.

Knotenpool mit dem Installationsprogramm und automatisiertem Netzwerk erstellen

Wenn Sie GPUDirect RDMA für KI-Arbeitslasten mit mehreren Hosts aktivieren möchten, konfigurieren Sie einen GPU-Knotenpool, der den automatisierten RDMA-NCCL-Installer, automatisiertes Netzwerk und von der GKE verwaltetes DRANET kombiniert.

Wählen Sie eine der folgenden Optionen aus:

gcloud (Standard)

Wenn Sie das automatisierte RDMA-NCCL-Installationsprogramm für einen Standardknotenpool aktivieren möchten, geben Sie rdma als Wert für das Flag --gpudirect-strategy an. GKE stellt automatisch das RDMA-NCCL-Plug-in bereit, das mit der Knotenversion kompatibel ist.

Legen Sie die folgenden Umgebungsvariablen fest:
```
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
```
Ersetzen Sie Folgendes:
- CLUSTER_NAME: Der Name Ihres Clusters.
- CONTROL_PLANE_LOCATION: Der Standort für die Clustersteuerungsebene.
- PROJECT_ID: Ihre Projekt-ID.
- NODE_POOL_NAME ist der Name des neuen Knotenpools.
- NODEPOOL_LOCATION: der Standort des Knotenpools.
- ACCELERATOR_TYPE: der Beschleunigertyp, z. B. nvidia-h200-141gb oder nvidia-b200.
- ACCELERATOR_COUNT: die Anzahl der Beschleuniger, z. B. 8.
- DRIVER_VERSION: die GPU-Treiberversion, z. B. default oder latest.
- MACHINE_TYPE: der Maschinentyp, der a3-ultragpu-8g oder a4-highgpu-8g sein muss.
- NUM_NODES: Die Anzahl der Knoten im Knotenpool.
- RESERVATION_PROJECT: die Projekt-ID, in der sich die Reservierung befindet.
- RESERVATION_NAME: der Name der Reservierung.
- RESERVATION_BLOCK: der Reservierungsblock.

Erstellen Sie den Knotenpool:

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

Wenn Sie das automatisierte RDMA-NCCL-Installationsprogramm in Autopilot-Clustern oder in Standard-Clustern mit automatischer Erstellung von Knotenpools verwenden möchten, konfigurieren Sie eine benutzerdefinierte ComputeClass-Ressource mit aktiviertem gpuDirect: rdma, acceleratorNetworkProfile: auto und DRANET.

Speichern Sie das folgende Manifest als 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

Ersetzen Sie Folgendes:

COMPUTE_CLASS_NAME: der Name der ComputeClass.
ACCELERATOR_TYPE: der Beschleunigertyp, z. B. nvidia-h200-141gb oder nvidia-b200.
ACCELERATOR_COUNT: die Anzahl der Beschleuniger, z. B. 8.
MACHINE_TYPE: der Maschinentyp, der a3-ultragpu-8g oder a4-highgpu-8g sein muss.
RESERVATION_NAME: der Name Ihrer Reservierung.
RESERVATION_ZONE: die Zone, in der sich die Reservierung befindet.

Wenden Sie das Manifest an:
```
kubectl apply -f rdma-compute-class.yaml
```
Wenn Sie eine Arbeitslast bereitstellen, die diese ComputeClass verwendet, fügen Sie Ihrer Pod-Spezifikation die Knotenauswahl cloud.google.com/compute-class: COMPUTE_CLASS_NAME hinzu.

Terraform

Sie können Terraform verwenden, um Ihren GKE-Cluster und Knotenpool mit dem konfigurierten automatisierten RDMA-NCCL-Installer bereitzustellen.

Installieren Sie Terraform auf Ihrem lokalen Computer gemäß der offiziellen Terraform-Dokumentation.

Erstellen Sie ein leeres Verzeichnis für Ihre Konfiguration und wechseln Sie dorthin. Erstellen Sie eine Datei mit dem Namen main.tf und fügen Sie Folgendes hinzu:

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

Ersetzen Sie Folgendes:

PROJECT_ID: Ihre Projekt-ID.
REGION: die Compute-Region.
ZONE: Eine Zone, die A3 Ultra- oder A4-Maschinentypen unterstützt.

Führen Sie die folgenden Befehle im selben Verzeichnis aus, um sich beiGoogle Cloud zu authentifizieren und den Terraform-Status zu initialisieren:
```
gcloud auth application-default login
terraform init
```

Fügen Sie Ihrer main.tf-Datei oder einer separaten Terraform-Konfigurationsdatei die folgende Konfiguration hinzu. Mit dieser Konfiguration wird ein Cluster mit drei a3-ultragpu-8g-Knoten in us-central1-b bereitgestellt, die für die Verwendung des automatisierten RDMA-NCCL-Installationsprogramms, eines automatischen Netzwerkprofils für Beschleuniger und des von GKE verwalteten DRANET konfiguriert sind:

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

Führen Sie terraform plan -out=tfplan aus, um die Änderungen aufzurufen, die Terraform basierend auf der aktuellen Konfiguration vornimmt. Nachdem Sie den Plan überprüft haben, führen Sie ihn mit dem folgenden Befehl aus:
```
terraform apply tfplan
```
Hinweis: Die Erstellung von Clustern und Knotenpools kann einige Minuten dauern. Führen Sie TF_LOG=INFO terraform apply aus, um detaillierte Fortschrittslogs zu erhalten.

ResourceClaimTemplate erstellen

Wenn Sie Pods erlauben möchten, RDMA-Geräte dynamisch anzufordern und zu empfangen, erstellen Sie ein ResourceClaimTemplate-Objekt, um ein leistungsstarkes Netzwerk für KI-Arbeitslasten bereitzustellen. Mit der Einstellung allocationMode: All werden alle verfügbaren mrdma.google.com-RDMA-Geräte zugewiesen. Die Zuweisung aller verfügbaren Geräte ist für KI-Arbeitslasten auf mehreren Hosts, die eine vollständige Nutzung der GPU- und RDMA-Funktionen erfordern, von entscheidender Bedeutung.

Speichern Sie das folgende Manifest als 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

Wenden Sie das Manifest an:

kubectl apply -f all-mrdma-template.yaml

NCCL-RDMA-Testarbeitslast bereitstellen und ausführen

Um die RDMA-Konfiguration zu prüfen, stellen Sie eine Testarbeitslast bereit und führen Sie dann einen NCCL-All-Gather-Test aus, um die Einrichtung zu bestätigen.

Speichern Sie das folgende Manifest als 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

Wenden Sie das Manifest für die Testarbeitslast an:
```
kubectl apply -f nccl-test-workload.yaml
```

Führen Sie einen NCCL-All-Gather-Test zwischen den beiden Testhosts aus:

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

KI/ML-Arbeitslast bereitstellen

Damit Ihre verteilten Trainingsjobs effizient ausgeführt werden, müssen Ihre ML-Anwendungen die vom Installationsprogramm bereitgestellten RDMA-Geräte anfordern. Nachdem Sie die RDMA-Konfiguration mit der Testarbeitslast überprüft haben, können Sie Ihre KI/ML-Anwendungen bereitstellen. Ihre Anwendungs-Pods müssen auf das zuvor erstellte ResourceClaimTemplate-Objekt (all-mrdma) verweisen, um RDMA-Geräte dynamisch anzufordern und zu empfangen.

Das folgende Pod-Manifest verwendet das ResourceClaimTemplate-Objekt all-mrdma. Ersetzen Sie IMAGE durch das Container-Image Ihrer KI/ML-Arbeitslast und COMMAND durch den Einstiegspunkt Ihrer Anwendung.

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"

Speichern Sie das Manifest als workload.yaml und wenden Sie es an, um diese Arbeitslast bereitzustellen:

kubectl apply -f workload.yaml

Erweiterte Konfigurationen

Sie können das automatisierte RDMA-NCCL-Installationsprogramm auch für Knotenpools aktivieren, die manuelle Konfigurationen mit mehreren Netzwerken anstelle von automatisierten Netzwerken mit DRANET verwenden.

Knotenpool in einem Cluster mit aktiviertem Multi-Netzwerk erstellen

Wenn Sie die Clusterkonfigurationen unter GPUDirect RDMA-Unterstützung in GKE befolgt haben, können Sie mit der folgenden Anleitung einen neuen Knotenpool mit dem automatisierten RDMA-NCCL-Installationsprogramm auf vorhandenen Clustern mit aktiviertem Multi-Netzwerk erstellen.

Führen Sie den folgenden Befehl aus, um zu prüfen, ob Multi-Netzwerk für Ihren Cluster aktiviert ist:

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

Wenn Sie die VPC-Netzwerke für zusätzliche NICs auf den A3 Ultra- und A4-VM-Instanzen wiederverwenden möchten, legen Sie die folgenden Variablen fest:

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

Führen Sie den folgenden Befehl aus, um einen Knotenpool mit dem automatisierten RDMA-NCCL-Installationsprogramm zu erstellen:

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

Nächste Schritte

Weitere Informationen zur GPUDirect RDMA-Unterstützung in GKE