‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

הגדרת GPUDirect RDMA באמצעות מנהל ההתקנה האוטומטי של NCCL

Autopilot Standard

כשמריצים עומסי עבודה מבוזרים של AI/ML, האפליקציות בדרך כלל דורשות תקשורת עם תפוקה גבוהה וזמן אחזור קצר בין יחידות ה-GPU בצמתים שונים. המכונות הווירטואליות (VM) מסוג A4 ו-A3 Ultra כוללות את מתאם הרשת Titanium ML, שמבוסס על בקרי ממשק הרשת (NIC) של NVIDIA ConnectX-7 (CX7). בשתי משפחות המכונות הווירטואליות, תעבורת הנתונים בין הצמתים מ-GPU ל-GPU היא בנפח של 3.2Tbps ללא חסימה, באמצעות RDMA over Converged Ethernet‏ (RoCE). ‫RoCE מאפשר התאמה לעומס ושיתוף פעולה בין כמה יחידות GPU, ומספק חוויית ענן עם ביצועים גבוהים לעומסי עבודה של AI.

למרות ש-GPUDirect RDMA מספק את נתיב התקשורת הישיר הזה, הגדרה ידנית של הפלאגינים הנדרשים לרשת ושל בקשות המשאבים יכולה להיות מורכבת ומועדת לשגיאות.

כדי לפתור את האתגר התפעולי הזה, אתם יכולים לשלב את תוכנת ההתקנה האוטומטית של RDMA NCCL עם רשתות אוטומטיות ו-DRANET שמנוהל על ידי Google Kubernetes Engine ‏ (GKE). כך תוכלו לפשט את ההגדרה של GPUDirect RDMA לעומסי עבודה של AI בכמה מארחים ב-GKE. ההתקנה האוטומטית של RDMA NCCL פורסת באופן אוטומטי את קובצי ה-gIB וה-NCCL הנדרשים במאגרי צמתים שמשתמשים במכונות מסוג A3 Ultra או A4. כשמשתמשים בתכונות האלה ביחד, אפשר להתמקד בפריסת עומסי העבודה של ה-AI במקום לנהל באופן ידני את תשתית הרשת הבסיסית ואת בקשות המשאבים.

מידע נוסף זמין במאמר יצירת אשכול עם GPUDirect RDMA.

יתרונות

ההתקנה האוטומטית של RDMA NCCL מספקת את היתרונות הבאים:

התקנה אוטומטית של ספריות RDMA NCCL: החל מגרסה 1.34.8-gke.1278000 של GKE לאשכולות Standard ומגרסה 1.36.2-gke.1368000 לאשכולות Autopilot, אתם יכולים להפעיל התקנה אוטומטית של ספריות RDMA NCCL/gIB שמיועדות לביצועים אופטימליים של רשת ה-GPU ב- Google Cloud במהלך יצירת מאגר הצמתים, באמצעות דגל יחיד.
הגדרה פשוטה יותר להרצת עומסי עבודה של RDMA: שילוב של תוכנת ההתקנה האוטומטית של RDMA NCCL, רשתות אוטומטיות למכונות וירטואליות של מאיצים ו-DRANET בניהול GKE מאפשר לפרוס עומסי עבודה של AI עם RDMA בלי להגדיר את הרשת באופן ידני.
תאימות ושדרוגים בטוחים: קובצי ה-RDMA NCCL הבינאריים שסופקו על ידי תוכנת ההתקנה עוברים בדיקות התאמה מקצה לקצה לפני כל גרסה של GKE. הבדיקה הזו מבטיחה שספריות מרחב המשתמש של RDMA יישארו תואמות לגרסאות הליבה הספציפיות שבהן משתמשים ב-GKE, כדי שתוכלו לשדרג בבטחה את האשכולות ואת מאגרי הצמתים בלי לשבש את עומסי העבודה שפועלים.

מגבלות

למנהל ההתקנה האוטומטי של RDMA NCCL יש את המגבלות הבאות:

ההתקנה האוטומטית של RDMA NCCL נתמכת באשכולות GKE Standard החל מגרסה 1.34.8-gke.1278000 ובאשכולות Autopilot החל מגרסה 1.36.2-gke.1368000.
אפשר להשתמש במתקין האוטומטי של RDMA NCCL רק במכונות מסוג a3-ultragpu-8g ו-a4-highgpu-8g.
אם אתם משתמשים ב-DRANET בניהול GKE כדי להגדיר עומסי עבודה, כדאי לעיין בנקודות מרכזיות ובמגבלות של DRANET בניהול GKE.
אי אפשר להשתמש גם ב-API של כמה רשתות וגם ב-DRANET באותו מאגר צמתים. צריך לבחור שיטה אחת לחיבור Pods לרשת.
הצמתים של GKE צריכים להשתמש בתמונת צומת של מערכת הפעלה שמותאמת לקונטיינרים. אין תמיכה בתמונות של צומתי Ubuntu ו-Windows.
אתם צריכים לעמוד בכל הדרישות האחרות להפעלת A3 Ultra ו-A4 עם GPUDirect RDMA ב-GKE.

לפני שמתחילים

לפני שמתחילים, חשוב לוודא שביצעתם את המשימות הבאות:

מוודאים שהאשכול משתמש בגרסת GKE‏ 1.34.8-gke.1278000 ואילך לאשכולות Standard, או בגרסה 1.36.2-gke.1368000 ואילך לאשכולות Autopilot.
מוודאים שאתם משתמשים בגרסה 550.0.0 ואילך של Google Cloud CLI.
מוודאים שיש לכם אשכול קיים במצב Autopilot או במצב Standard. כדי ליצור אשכול חדש, קראו את המאמר יצירת אשכול Autopilot.
מוודאים שGKE Dataplane V2 מופעל באשכול. (כדי להפעיל את GKE Dataplane V2 כשיוצרים אשכול חדש, צריך לציין את הדגל --enable-dataplane-v2). ‫GKE Dataplane V2 מופעל כברירת מחדל בכל אשכולות Autopilot החדשים.
כדי לוודא שהגדרתם את הרשת של האשכול ומאגר הצמתים, אתם יכולים להשתמש באחת מהשיטות הבאות:
- רשת אוטומטית עם DRANET (מומלץ): משתמשים ברשת אוטומטית למכונות וירטואליות של מאיצי חומרה עם פרופיל רשת של מאיץ חומרה ו-DRANET בניהול GKE לחיבור רשת.
- יצירת רשתות באופן ידני באמצעות ה-API של ריבוי רשתות: פועלים לפי תהליך העבודה הידני כדי ליצור רשתות VPC ורשתות משנה, מפעילים את ה-API של ריבוי רשתות ב-GKE ומגדירים רשתות נוספות של צמתים במאגר הצמתים של המאיץ.
מוודאים שיש לכם מכסה של שתי מכונות וירטואליות (VM) לפחות. המכסה המינימלית הזו תואמת ל-16 יחידות GPU אם משתמשים בסוגי המכונות a4-highgpu-8g או a3-ultragpu-8g.

יצירת מאגר צמתים באמצעות מנהל ההתקנה ורשתות אוטומטיות

כדי להפעיל את GPUDirect RDMA לעומסי עבודה של AI בכמה מארחים, צריך להגדיר מאגר צומתי GPU שמשלב את תוכנת ההתקנה האוטומטית של RDMA NCCL, רשתות אוטומטיות ו-DRANET שמנוהל על ידי GKE.

בוחרים באחת מהאפשרויות הבאות:

‫gcloud (רגיל)

כדי להפעיל את תוכנת ההתקנה האוטומטית של RDMA NCCL במאגר צמתים מסוג Standard, מציינים את הערך rdma בדגל --gpudirect-strategy. ‫GKE פורס באופן אוטומטי את הפלאגין RDMA NCCL שתואם לגרסת הצומת.

מגדירים את משתני הסביבה הבאים:
```
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
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫CLUSTER_NAME: שם האשכול.
- ‫CONTROL_PLANE_LOCATION: המיקום של מישור הבקרה של האשכול.
- PROJECT_ID: מזהה הפרויקט.
- ‫NODE_POOL_NAME: השם של מאגר הצמתים החדש.
- ‫NODEPOOL_LOCATION: המיקום של מאגר הצמתים.
- ‫ACCELERATOR_TYPE: סוג מאיץ החומרה, למשל nvidia-h200-141gb או nvidia-b200.
- ‫ACCELERATOR_COUNT: מספר המאיצים, למשל 8.
- ‫DRIVER_VERSION: גרסת מנהל ההתקן של ה-GPU, למשל default או latest.
- ‫MACHINE_TYPE: סוג המכונה, שיכול להיות a3-ultragpu-8g או a4-highgpu-8g.
- ‫NUM_NODES: מספר הצמתים במאגר הצמתים.
- ‫RESERVATION_PROJECT: מזהה הפרויקט שבו נמצאת ההזמנה.
- ‫RESERVATION_NAME: שם ההזמנה.
- ‫RESERVATION_BLOCK: בלוק ההזמנה.

יוצרים את מאגר הצמתים:

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 ובמצב רגיל)

כדי להשתמש בכלי ההתקנה האוטומטי של RDMA NCCL באשכולות Autopilot או באשכולות Standard עם יצירה אוטומטית של מאגרי צמתים, צריך להגדיר משאב ComputeClass בהתאמה אישית עם gpuDirect: rdma,‏ acceleratorNetworkProfile: auto ו-DRANET מופעלים.

שומרים את המניפסט הבא בתור 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

מחליפים את מה שכתוב בשדות הבאים:

‫COMPUTE_CLASS_NAME: השם של ComputeClass.
‫ACCELERATOR_TYPE: סוג מאיץ החומרה, למשל nvidia-h200-141gb או nvidia-b200.
‫ACCELERATOR_COUNT: מספר המאיצים, למשל 8.
‫MACHINE_TYPE: סוג המכונה, שיכול להיות a3-ultragpu-8g או a4-highgpu-8g.
‫RESERVATION_NAME: שם ההזמנה.
‫RESERVATION_ZONE: האזור שבו נמצאת ההזמנה.

מחילים את המניפסט:
```
kubectl apply -f rdma-compute-class.yaml
```
כשפורסים עומס עבודה שמשתמש ב-ComputeClass הזה, מוסיפים את בורר הצמתים cloud.google.com/compute-class: COMPUTE_CLASS_NAME למפרט ה-Pod.

Terraform

אתם יכולים להשתמש ב-Terraform כדי להקצות את אשכול ה-GKE ואת מאגר הצמתים עם מתקין ה-NCCL האוטומטי של RDMA.

מתקינים את Terraform במחשב המקומי לפי המסמכים הרשמיים של Terraform.
יוצרים ספרייה ריקה שתכיל את ההגדרות האישיות, ועוברים אליה. יוצרים קובץ בשם main.tf וממלאים אותו בתוכן הבא:
```
# 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"
}
```
מחליפים את מה שכתוב בשדות הבאים:
- PROJECT_ID: מזהה הפרויקט.
- ‫REGION: אזור המחשוב.
- ‫ZONE: אזור שתומך במכונות מסוג A3 Ultra או A4.
מריצים את הפקודות הבאות באותה ספרייה כדי לאמת אתGoogle Cloud ולאתחל את המצב של Terraform:
```
gcloud auth application-default login
terraform init
```

מוסיפים את ההגדרות הבאות לקובץ main.tf או לקובץ תצורה נפרד של Terraform. ההגדרה הזו פורסת אשכול עם שלושה צומתי a3-ultragpu-8g ב-us-central1-b שמוגדרים להשתמש במתקין האוטומטי של RDMA NCCL, בפרופיל רשת אוטומטי של מאיץ חומרה וב-DRANET שמנוהל על ידי 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"
    }
  }
}

מריצים את הפקודה terraform plan -out=tfplan כדי לראות את השינויים ש-Terraform מבצעת על סמך ההגדרות הנוכחיות. אחרי שמאמתים את התוכנית, מריצים אותה באמצעות הפקודה הבאה:
```
terraform apply tfplan
```
הערה: יכול להיות שיצירת האשכול ומאגר הצמתים תימשך כמה דקות. כדי לקבל יומני התקדמות מפורטים, מריצים את TF_LOG=INFO terraform apply.

יצירת ResourceClaimTemplate

כדי לאפשר לפודים לבקש ולקבל באופן דינמי מכשירי RDMA, יוצרים אובייקט ResourceClaimTemplate, שעוזר לספק רשתות עם ביצועים גבוהים לעומסי עבודה של AI. ההגדרה allocationMode: All מקצה את כל מכשירי ה-RDMA הזמינים ב-mrdma.google.com. הקצאת כל המכשירים הזמינים היא קריטית לעומסי עבודה של AI בכמה מארחים שדורשים ניצול מלא של יכולות ה-GPU וה-RDMA.

שומרים את המניפסט הבא בתור 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

מחילים את המניפסט:

kubectl apply -f all-mrdma-template.yaml

פריסה והרצה של עומס עבודה לבדיקת NCCL RDMA

כדי לאמת את הגדרת ה-RDMA, פורסים עומס עבודה לבדיקה ואז מריצים בדיקת NCCL all-gather כדי לאשר את ההגדרה.

שומרים את המניפסט הבא בתור 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

מחילים את המניפסט של עומס העבודה לבדיקה:
```
kubectl apply -f nccl-test-workload.yaml
```

מריצים בדיקת NCCL all-gather בין שני המארחים לבדיקה:

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

פריסת עומס העבודה של AI או למידת מכונה

כדי להריץ ביעילות את משימות האימון המבוזרות, אפליקציות ה-ML צריכות לבקש את מכשירי ה-RDMA שהוקצו על ידי תוכנת ההתקנה. אחרי שמאמתים את הגדרת ה-RDMA באמצעות עומס העבודה לבדיקה, אפשר לפרוס את אפליקציות ה-AI/ML. ה-Pods של האפליקציה צריכים להפנות לאובייקט ResourceClaimTemplate שיצרתם קודם (all-mrdma) כדי לבקש ולקבל באופן דינמי מכשירי RDMA.

במניפסט הבא של Pod נעשה שימוש באובייקט all-mrdma ResourceClaimTemplate. מחליפים את IMAGE בקובץ האימג' של הקונטיינר של עומס העבודה של ה-AI/ML, ואת COMMAND בנקודת הכניסה של האפליקציה.

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"

כדי לפרוס את עומס העבודה הזה, שומרים את המניפסט בתור workload.yaml ומחילים אותו:

kubectl apply -f workload.yaml

הגדרות מתקדמות

אתם יכולים גם להפעיל את ההתקנה האוטומטית של RDMA NCCL במאגרי צמתים שמשתמשים בהגדרות ידניות של כמה רשתות, במקום ברשתות אוטומטיות עם DRANET.

יצירת מאגר צמתים באשכול עם כמה רשתות

אם פעלתם לפי הגדרות האשכולות שמפורטות במאמר תמיכה ב-GPUDirect RDMA ב-GKE, אתם יכולים להשתמש בהוראות הבאות כדי ליצור מאגר צמתים חדש עם מנהל ההתקנה האוטומטי של RDMA NCCL, שמופעל באשכולות קיימים עם כמה רשתות.

כדי לבדוק אם באשכול מופעלת האפשרות "רשתות מרובות", מריצים את הפקודה הבאה:

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

כדי להשתמש שוב ברשתות ה-VPC לכרטיסי רשת נוספים במכונות הווירטואליות מסוג A3 Ultra ו-A4, מגדירים את המשתנים הבאים:

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

כדי ליצור מאגר צמתים עם תוכנת ההתקנה האוטומטית של RDMA NCCL, מריצים את הפקודה הבאה:

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

המאמרים הבאים

מידע נוסף על התמיכה ב-GPUDirect RDMA ב-GKE