Google menggunakan teknologi AI untuk menerjemahkan konten ke dalam bahasa pilihan Anda. Terjemahan AI mungkin mengandung kesalahan.

Membuat cluster GKE yang dioptimalkan untuk AI dan menggunakan A4X Max

Dokumen ini menunjukkan cara membuat cluster Google Kubernetes Engine (GKE) yang dioptimalkan untuk AI dan menggunakan instance Compute Engine A4X Max untuk mendukung workload AI dan ML Anda.

Seri A4X Max dan A4X memungkinkan Anda menjalankan cluster AI/ML berskala besar menggunakan sistem NVIDIA Multi-Node NVLink (MNNVL), solusi skala rak yang memungkinkan daya dan performa GPU yang lebih tinggi. Mesin ini menawarkan fitur seperti penempatan workload yang ditargetkan, penjadwalan yang sesuai topologi, dan kontrol pemeliharaan cluster lanjutan. Untuk mengetahui informasi selengkapnya, lihat Kemampuan pengelolaan cluster. Dengan A4X Max, GKE juga menyediakan penyiapan jaringan otomatis yang menyederhanakan konfigurasi cluster.

Workload AI dan ML, seperti pelatihan terdistribusi, memerlukan akselerasi yang kuat untuk mengoptimalkan performa dengan mengurangi waktu penyelesaian tugas. GKE menyediakan satu platform untuk menjalankan berbagai workload bagi organisasi Anda, sehingga mengurangi beban operasional dalam mengelola beberapa platform. Anda dapat menjalankan workload seperti pra-pelatihan terdistribusi berperforma tinggi, penyesuaian model, inferensi model, penayangan aplikasi, dan layanan pendukung. Untuk workload yang memerlukan performa tinggi, throughput tinggi, dan latensi rendah, GPUDirect RDMA mengurangi hop jaringan yang diperlukan untuk mentransfer payload ke dan dari GPU. Pendekatan ini menggunakan bandwidth jaringan yang tersedia secara lebih efisien. Untuk mengetahui informasi selengkapnya, lihat Stack jaringan GPU.

Dalam dokumen ini, Anda akan mempelajari cara membuat cluster GKE dengan Google Cloud CLI untuk mendapatkan fleksibilitas maksimum dalam mengonfigurasi cluster berdasarkan kebutuhan workload Anda. Untuk menggunakan gcloud CLI guna membuat cluster dengan jenis mesin lain, lihat hal berikut:

A4X: Membuat cluster GKE kustom yang dioptimalkan untuk AI dan menggunakan A4X.
A4 atau A3 Ultra: Untuk membuat cluster yang menggunakan A4 atau A3 Ultra, lihat Membuat cluster GKE kustom yang dioptimalkan untuk AI dan menggunakan A4 atau A3 Ultra. Anda dapat menggunakan seri mesin ini untuk menjalankan workload dengan atau tanpa GPUDirect RDMA.

Atau, Anda dapat memilih untuk menggunakan Cluster Toolkit guna men-deploy cluster dengan cepat menggunakan setelan default yang mencerminkan praktik terbaik untuk banyak kasus penggunaan. Untuk mengetahui informasi selengkapnya, lihat Membuat cluster GKE yang dioptimalkan untuk AI dengan konfigurasi default.

Sebelum memulai

Sebelum memulai, pastikan Anda telah melakukan tugas berikut:

Aktifkan Google Kubernetes Engine API.

Mengaktifkan Google Kubernetes Engine API

Untuk menggunakan Google Cloud CLI untuk tugas ini, instal lalu lakukan inisialisasi gcloud CLI. Jika sebelumnya Anda telah menginstal gcloud CLI, dapatkan versi terbaru dengan menjalankan perintah gcloud components update. Versi gcloud CLI yang lebih lama mungkin tidak mendukung perintah yang ada dalam dokumen ini.
Catatan: Untuk penginstalan gcloud CLI yang ada, pastikan untuk menyetel compute/region properti . Jika Anda terutama menggunakan cluster zona, tetapkan compute/zone sebagai gantinya. Dengan menetapkan lokasi default, Anda dapat menghindari error di gcloud CLI seperti berikut: One of [--zone, --region] must be supplied: Please specify location. Anda mungkin perlu menentukan lokasi dalam perintah tertentu jika lokasi cluster Anda berbeda dengan default yang Anda tetapkan.

Mendapatkan kapasitas

Anda dapat memperoleh kapasitas untuk instance komputasi A4X Max dengan membuat pemesanan untuk masa mendatang. Untuk mengetahui informasi selengkapnya tentang pemesanan untuk masa mendatang, lihat kolom Future reservations in AI Hypercomputer dalam tabel untuk Choose a consumption option.

Untuk mendapatkan kapasitas dengan pemesanan untuk masa mendatang, lihat baris Pemesanan untuk masa mendatang di AI Hypercomputer dalam tabel untuk Cara mendapatkan kapasitas.

Persyaratan

Persyaratan berikut berlaku untuk cluster GKE yang dioptimalkan untuk AI dengan instance komputasi A4X Max:

Untuk A4X Max, Anda harus menggunakan salah satu versi berikut:
- Untuk 1.35 atau yang lebih baru, gunakan GKE versi 1.35.0-gke.2745000 atau yang lebih baru.
- Untuk 1.34, gunakan GKE versi 1.34.3-gke.1318000 atau yang lebih baru.
Versi ini membantu memastikan bahwa A4X Max menggunakan hal berikut:
- R580.95.05, versi driver GPU minimum untuk A4X Max, yang diaktifkan secara default.
- Coherent Driver-based Memory Management (CDMM), yang diaktifkan secara default. NVIDIA merekomendasikan agar cluster Kubernetes mengaktifkan mode ini untuk mengatasi pelaporan memori yang berlebihan. CDMM memungkinkan memori GPU dikelola melalui driver, bukan sistem operasi (OS). Pendekatan ini membantu Anda menghindari OS onlining memori GPU, dan mengekspos memori GPU sebagai node Non-Uniform Memory Access (NUMA) ke OS. GPU multi-instance tidak didukung saat CDMM diaktifkan. Untuk mengetahui informasi selengkapnya tentang CDMM, lihat Dukungan Hardware dan Software Support.
- GPUDirect RDMA dan MNNVL, yang direkomendasikan untuk mengaktifkan node pool A4X Max agar dapat menggunakan kemampuan jaringan A4X Max.
Node GKE harus menggunakan image node Container-Optimized OS. Image node Ubuntu dan Windows tidak didukung.
Workload GKE Anda harus menggunakan semua GPU yang tersedia dan Pod Anda harus menggunakan semua NIC sekunder yang tersedia di satu node GKE. Beberapa Pod tidak dapat berbagi RDMA di satu node GKE.
Anda harus menggunakan model penyediaan yang terikat dengan pemesanan untuk membuat cluster dengan A4X Max. Model penyediaan lainnya tidak didukung.
Petunjuk ini menggunakan DRANET untuk mengonfigurasi cluster GKE yang dioptimalkan untuk AI dengan A4X Max. Multi-jaringan tidak didukung untuk jenis mesin a4x-maxgpu-4g-metal.

Pertimbangan untuk membuat cluster

Saat membuat cluster, pertimbangkan informasi berikut:

Memilih lokasi cluster:
- Pastikan Anda menggunakan lokasi yang memiliki ketersediaan untuk jenis mesin yang Anda pilih. Untuk mengetahui informasi selengkapnya, lihat Ketersediaan akselerator.
- Saat membuat node pool di cluster regional—yang direkomendasikan untuk workload produksi—Anda dapat menggunakan flag untuk menentukan zona bagi node GKE Anda.--node-locations
Memilih versi driver:
- Versi driver dapat berupa salah satu nilai berikut:
  - default: menginstal versi driver default untuk versi node GKE Anda. Untuk mengetahui informasi selengkapnya tentang persyaratan untuk versi driver default, lihat bagian Persyaratan.
  - latest: menginstal versi driver terbaru yang tersedia untuk versi GKE Anda. Opsi ini hanya tersedia untuk node yang menggunakan Container-Optimized OS.
  - disabled: melewati penginstalan driver otomatis. Anda harus menginstal driver secara manual setelah membuat node pool.
- Untuk mengetahui informasi selengkapnya tentang versi driver GPU default dan terbaru untuk versi node GKE, lihat tabel di bagian Menginstal driver GPU NVIDIA secara manual.
Memilih afinitas pemesanan:
- Anda dapat menemukan informasi tentang pemesanan Anda, seperti nama pemesanan atau nama blok tertentu dalam pemesanan Anda. Untuk menemukan nilai ini, lihat Melihat permintaan pemesanan untuk masa mendatang.
- Flag --reservation-affinity dapat mengambil nilai specific atau any. Namun, untuk workload AI terdistribusi berperforma tinggi, sebaiknya gunakan pemesanan tertentu.
- Saat menggunakan pemesanan tertentu, termasuk bersama pemesanan, tentukan nilai flag --reservation dalam format berikut:
```
projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME
```
  Ganti nilai berikut:
  - PROJECT_ID: Project ID Google Cloud Anda.
  - RESERVATION_NAME: nama pemesanan Anda.
  - BLOCK_NAME: nama blok tertentu dalam pemesanan.
  Sebaiknya gunakan pemesanan yang ditargetkan ke sub-blok sehingga instance komputasi ditempatkan di satu sub-blok dalam BLOCK_NAME. Tambahkan hal berikut ke akhir jalur:
```
/reservationSubBlocks/SUB_BLOCK_NAME
```
  Ganti SUB_BLOCK_NAME dengan nama sub-blok.
  
  Tips: Jika pemesanan berada di project saat ini, Anda dapat menghapus projects/PROJECT_ID/reservations/dari nilai pemesanan.

Membuat cluster GKE yang dioptimalkan untuk AI dan menggunakan A4X Max dan GPUDirect RDMA

Untuk workload AI terdistribusi, beberapa node GPU sering ditautkan bersama untuk berfungsi sebagai satu komputer. A4X Max adalah platform exascale yang didasarkan pada arsitektur skala rak NVIDIA GB300 NVL72. Instance komputasi A4X Max menggunakan arsitektur jaringan hierarkis berlapis dengan desain yang selaras dengan rel untuk mengoptimalkan performa berbagai jenis komunikasi. Jenis mesin ini memungkinkan penskalaan dan kolaborasi di beberapa GPU dengan memberikan pengalaman cloud berperforma tinggi untuk workload AI. Untuk mengetahui informasi selengkapnya tentang arsitektur jaringan untuk A4X Max, termasuk bandwidth jaringan dan pengaturan NIC, lihat Jenis mesin A4X Max (bare metal).

Untuk membuat cluster GKE Standard dengan A4X Max yang menggunakan GPUDirect RDMA dan MNNVL, selesaikan langkah-langkah yang dijelaskan di bagian berikut:

Membuat cluster GKE
Membuat kebijakan workload
Membuat node pool dengan A4X Max
Mengonfigurasi NIC MRDMA dengan asapd-lite
Menginstal driver CRD dan DRA NVIDIA Compute Domain
Mengonfigurasi manifes workload untuk domain RDMA dan IMEX

Petunjuk ini menggunakan profil jaringan akselerator untuk mengonfigurasi jaringan dan subnet VPC secara otomatis untuk node A4X Max Anda. Atau, Anda dapat menentukan jaringan dan subnet VPC secara eksplisit.

Membuat cluster GKE

Buat cluster GKE Standard:
```
gcloud container clusters create CLUSTER_NAME \
  --enable-dataplane-v2 \
  --enable-ip-alias \
  --location=COMPUTE_REGION \
  --cluster-version=CLUSTER_VERSION \
  --no-enable-shielded-nodes [\
  --services-ipv4-cidr=SERVICE_CIDR \
  --cluster-ipv4-cidr=POD_CIDR \
  --addons=GcpFilestoreCsiDriver=ENABLED]
```
Ganti kode berikut:
- CLUSTER_NAME: nama cluster Anda.
- CLUSTER_VERSION: versi cluster baru Anda. Untuk mengetahui informasi selengkapnya tentang versi GKE yang mendukung konfigurasi Anda, lihat Persyaratan dalam dokumen ini.
- COMPUTE_REGION: nama region komputasi.
- Secara opsional, Anda dapat memberikan rentang CIDR sekunder untuk layanan dan Pod secara eksplisit. Jika Anda menggunakan flag opsional ini, ganti variabel berikut:
  - SERVICE_CIDR: rentang CIDR sekunder untuk layanan.
  - POD_CIDR: rentang CIDR sekunder untuk Pod.
  Saat menggunakan flag ini, Anda harus memverifikasi bahwa rentang CIDR tidak tumpang-tindih dengan rentang subnet untuk jaringan node tambahan. Misalnya, pertimbangkan SERVICE_CIDR=10.65.0.0/19 dan POD_CIDR=10.64.0.0/19. Untuk mengetahui informasi selengkapnya, lihat Menambahkan rentang alamat IPv4 Pod.
Untuk menjalankan perintah kubectl di bagian berikutnya, hubungkan ke cluster Anda:
```
gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGION
```
Ganti kode berikut:
- CLUSTER_NAME: nama cluster Anda.
- COMPUTE_REGION: nama region komputasi.
Untuk mengetahui informasi selengkapnya, lihat Menginstal kubectl dan mengonfigurasi akses cluster access.

Membuat kebijakan workload

Kebijakan workload diperlukan untuk membuat partisi. Untuk mengetahui informasi selengkapnya, lihat Kebijakan workload untuk MIG.

Buat kebijakan workload HIGH_THROUGHPUT dengan kolom accelerator_topology yang ditetapkan ke 1x72.

gcloud beta compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \
    --type HIGH_THROUGHPUT \
    --accelerator-topology 1x72 \
    --project PROJECT \
    --region COMPUTE_REGION

Ganti kode berikut:

WORKLOAD_POLICY_NAME: nama kebijakan workload Anda.
PROJECT: nama project Anda.
COMPUTE_REGION: nama region komputasi.

Membuat node pool dengan A4X Max

Buat file konfigurasi berikut untuk mengalokasikan hugepage dengan node pool:

cat > node_custom.yaml <<EOF
linuxConfig:
  hugepageConfig:
    hugepage_size2m: 4096
EOF

export NODE_CUSTOM=node_custom.yaml

Buat node pool A4X Max:
```
gcloud container node-pools create NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=COMPUTE_REGION \
    --node-locations=COMPUTE_ZONE \
    --num-nodes=NODE_COUNT \
    --placement-policy=WORKLOAD_POLICY_NAME \
    --machine-type=a4x-maxgpu-4g-metal \
    --accelerator=type=nvidia-gb300,count=4,gpu-driver-version=latest \
    --system-config-from-file=${NODE_CUSTOM} \
    --accelerator-network-profile=auto \
    --node-labels=cloud.google.com/gke-networking-dra-driver=true,cloud.google.com/gke-dpv2-unified-cni=cni-migration \
    --reservation-affinity=specific \
    --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME/reservationSubBlocks/SUB_BLOCK_NAME
```
Ganti kode berikut:
- NODE_POOL_NAME: nama node pool.
- CLUSTER_NAME: nama cluster Anda.
- COMPUTE_REGION: region komputasi cluster.
- COMPUTE_ZONE: zona node pool Anda.
- NODE_COUNT: jumlah node untuk node pool, yang harus 18 node atau kurang. Sebaiknya gunakan 18 node untuk mendapatkan topologi GPU 1x72 dalam satu sub-blok menggunakan domain NVLink.
- WORKLOAD_POLICY_NAME: nama kebijakan workload yang Anda buat sebelumnya.
- RESERVATION_NAME: nama pemesanan Anda. Untuk menemukan nilai ini, lihat Melihat permintaan pemesanan untuk masa mendatang.
- BLOCK_NAME: nama blok tertentu dalam pemesanan. Untuk menemukan nilai ini, lihat Melihat permintaan pemesanan untuk masa mendatang.
Perintah ini secara otomatis membuat jaringan yang menghubungkan semua node A4X Max dalam satu zona menggunakan profil jaringan akselerator auto. Saat Anda membuat node pool dengan flag --accelerator-network-profile=auto, GKE akan otomatis menambahkan label gke.networks.io/accelerator-network-profile: auto ke node. Untuk menjadwalkan workload di node ini, Anda harus menyertakan label ini di kolom nodeSelector workload Anda.

Mengonfigurasi NIC MRDMA dengan `asapd-lite`

DaemonSet asapd-lite mengonfigurasi NIC MRDMA. DaemonSet asapd-lite yang tidak sehat mungkin menunjukkan tidak adanya konektivitas RDMA.

Instal DaemonSet:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/asapd-lite-installer/asapd-lite-installer-a4x-max-bm-cos.yaml

Validasi replika di DaemonSet asapd-lite:

kubectl get daemonset -n kube-system asapd-lite

Outputnya mirip dengan hal berikut ini:

NAME         DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
asapd-lite   18        18        18      18           18          <none>          5m

Jumlah replika READY harus cocok dengan jumlah node yang dibuat dan sehat di node pool.

Menginstal driver CRD dan DRA NVIDIA Compute Domain

Langkah-langkah berikut menginstal driver CRD dan DRA NVIDIA Compute Domain untuk mengaktifkan penggunaan MNNVL. Untuk mengetahui informasi selengkapnya, lihat Driver DRA NVIDIA untuk GPU.

Pastikan Anda telah menginstal Helm di lingkungan pengembangan Anda. Helm sudah terinstal secara default di Cloud Shell.

Meskipun tidak ada persyaratan versi Helm tertentu, Anda dapat menggunakan perintah berikut untuk memverifikasi bahwa Anda telah menginstal Helm.
```
helm version
```
Jika output-nya mirip dengan Command helm not found, Anda dapat menginstal Helm CLI:
```
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 \
  && chmod 700 get_helm.sh \
  && ./get_helm.sh
```

Tambahkan repositori Helm NVIDIA:

helm repo add nvidia https://helm.ngc.nvidia.com/nvidia \
  && helm repo update

Buat objek ResourceQuota untuk Driver DRA:

export POD_QUOTA=POD_QUOTA

kubectl create ns nvidia-dra-driver-gpu

kubectl apply -n nvidia-dra-driver-gpu -f - << EOF
apiVersion: v1
kind: ResourceQuota
metadata:
  name: nvidia-dra-driver-gpu-quota
spec:
  hard:
    pods: ${POD_QUOTA}
  scopeSelector:
    matchExpressions:
    - operator: In
      scopeName: PriorityClass
      values:
        - system-node-critical
        - system-cluster-critical
EOF

Ganti POD_QUOTA dengan angka setidaknya 2 kali jumlah node A4X Max di cluster ditambah 1. Misalnya, Anda harus menetapkan variabel ke setidaknya 37 jika memiliki 18 node A4X Max di cluster Anda.

Instal driver ComputeDomain CRD dan DRA:

helm install nvidia-dra-driver-gpu nvidia/nvidia-dra-driver-gpu \
    --set controller.args.v=4 --set kubeletPlugin.args.v=4 \
    --version="25.8.0" \
    --create-namespace \
    --namespace nvidia-dra-driver-gpu \
    -f <(cat <<EOF
nvidiaDriverRoot: /home/kubernetes/bin/nvidia
resources:
  gpus:
    enabled: false

controller:
  affinity:
      nodeAffinity:
        requiredDuringSchedulingIgnoredDuringExecution:
          nodeSelectorTerms:
          - matchExpressions:
            - key: "nvidia.com/gpu"
              operator: "DoesNotExist"

kubeletPlugin:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: cloud.google.com/gke-accelerator
                operator: In
                values:
                  - nvidia-gb300
              - key: kubernetes.io/arch
                operator: In
                values:
                  - arm64

  tolerations:
    - key: nvidia.com/gpu
      operator: Equal
      value: present
      effect: NoSchedule
    - key: kubernetes.io/arch
      operator: Equal
      value: arm64
      effect: NoSchedule
EOF
)

Mengonfigurasi manifes workload untuk domain RDMA dan IMEX

Tambahkan aturan afinitas node untuk menjadwalkan workload di node Arm:

spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        -   matchExpressions:
          -   key: kubernetes.io/arch
            operator: In
            values:
            -   arm64

Tambahkan volume berikut ke spesifikasi Pod:

spec:
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia

Tambahkan volume mount, variabel lingkungan, dan resource berikut ke container yang meminta GPU. Container workload Anda harus meminta keempat GPU:

containers:
  - name: my-container
    volumeMounts:
      - name: library-dir-host
        mountPath: /usr/local/nvidia

    env:
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
    resources:
      limits:
        nvidia.com/gpu: 4

Buat resource ComputeDomain untuk workload:

apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
  name: a4x-max-compute-domain
spec:
  numNodes: NUM_NODES
  channel:
    resourceClaimTemplate:
      name: a4x-max-compute-domain-channel

Ganti NUM_NODES dengan jumlah node yang diperlukan workload.

Buat ResourceClaimTemplate untuk mengalokasikan resource jaringan menggunakan DRANET dan meminta perangkat RDMA untuk Pod Anda:

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

Tentukan ResourceClaimTemplate yang digunakan Pod:

spec:
  ...
  volumes:
    ...
  containers:
    - name: my-container
      ...
      resources:
        limits:
          nvidia.com/gpu: 4
  claims:
          - name: compute-domain-channel
          - name: rdma
        ...
resourceClaims:
  - name: compute-domain-channel
    resourceClaimTemplateName: a4x-max-compute-domain-channel
  - name: rdma
    resourceClaimTemplateName: all-mrdma

Instal library userspace terbaru di image container Anda:

Debian 12+/Ubuntu 20.04+ (paket .deb)

apt update
apt install curl

# Fetch DOCA OFED userspace libraries
export DOCA_URL="https://linux.mellanox.com/public/repo/doca/latest/ubuntu22.04/arm64-sbsa/"
export BASE_URL="https://linux.mellanox.com/public/repo/doca"
curl "${BASE_URL}/GPG-KEY-Mellanox.pub" | gpg --dearmor -o /etc/apt/trusted.gpg.d/GPG-KEY-Mellanox.pub
echo "deb [signed-by=/etc/apt/trusted.gpg.d/GPG-KEY-Mellanox.pub] ${DOCA_URL} ./" | tee /etc/apt/sources.list.d/doca.list

apt update
apt install doca-ofed-userspace

# Upgrade to latest NCCL for best compatibility
apt install --only-upgrade --allow-change-held-packages libnccl2 libnccl-dev

Spesifikasi Pod yang telah selesai akan terlihat seperti berikut:

apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
  name: a4x-max-compute-domain
spec:
  numNodes:  NUM_NODES
  channel:
    resourceClaimTemplate:
      name: a4x-max-compute-domain-channel
---
apiVersion: apps/v1
kind: Pod
metadata:
  name: my-pod
  labels:
    k8s-app: my-pod
spec:
  ...
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: kubernetes.io/arch
            operator: In
            values:
            - arm64
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
  hostNetwork: true
  containers:
    - name: my-container
      volumeMounts:
        - name: library-dir-host
          mountPath: /usr/local/nvidia
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      resources:
        limits:
          nvidia.com/gpu: 4
        claims:
          - name: compute-domain-channel
          - name: rdma
        ...
  resourceClaims:
    - name: compute-domain-channel
      resourceClaimTemplateName: a4x-max-compute-domain-channel
    - name: rdma
      resourceClaimTemplateName: all-mrdma

Menguji performa jaringan

Sebaiknya validasi fungsi cluster yang disediakan. Untuk melakukannya, gunakan pengujian NCCL/gIB, yang merupakan pengujian NVIDIA Collective Communications Library (NCCL) yang dioptimalkan untuk lingkungan Google.

Untuk mengetahui informasi selengkapnya, lihat Menjalankan NCCL di cluster GKE kustom yang menggunakan A4X Max.

Langkah berikutnya

Untuk mempelajari cara menjadwalkan workload di cluster GKE menggunakan TAS dan Kueue, lihat Menjadwalkan workload GKE dengan Topology Aware Scheduling.
Untuk mempelajari cara mengelola peristiwa umum yang relevan dengan cluster GKE dan workload AI, lihat Mengelola cluster GKE yang dioptimalkan untuk AI.