Membuat cluster GKE yang dioptimalkan untuk AI dan menggunakan A4X

Halaman ini menunjukkan cara membuat cluster Google Kubernetes Engine (GKE) yang dioptimalkan untuk AI yang menggunakan virtual machine (VM) A4X untuk mendukung workload AI dan ML Anda. Untuk mengetahui informasi selengkapnya tentang A4X, lihat seri A4X.

Seri mesin A4X dirancang untuk memungkinkan Anda menjalankan cluster AI/ML skala besar dengan fitur seperti penempatan workload yang ditargetkan, kontrol pemeliharaan cluster lanjutan, dan penjadwalan yang sesuai topologi. Untuk mengetahui informasi selengkapnya, lihat Ringkasan pengelolaan cluster.

GKE menyediakan satu platform untuk menjalankan beragam set 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.

Di halaman ini, Anda akan mempelajari cara membuat cluster GKE dengan Google Cloud CLI untuk mendapatkan fleksibilitas maksimum dalam mengonfigurasi cluster berdasarkan kebutuhan workload Anda. 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.
Untuk membuat cluster yang menggunakan A4 atau A3 Ultra, lihat Membuat cluster GKE yang dioptimalkan untuk AI kustom yang menggunakan A4 atau A3 Ultra.

Opsi konfigurasi cluster dengan GPUDirect RDMA

Untuk membuat cluster dengan Google Cloud CLI, Anda dapat memilih salah satu opsi konfigurasi cluster berikut:

Jika Anda berencana menjalankan workload AI terdistribusi: buat cluster GKE dengan GPUDirect RDMA menggunakan petunjuk di halaman ini.
Jika Anda tidak berencana menjalankan workload AI terdistribusi: buat cluster GKE tanpa menggunakan GPUDirect RDMA. Untuk mengetahui informasi selengkapnya, lihat Membuat cluster tanpa GPUDirect RDMA.

Sebelum memulai

Sebelum memulai, pastikan Anda telah melakukan tugas berikut:

Aktifkan Google Kubernetes Engine API.

Aktifkan Google Kubernetes Engine API

Jika ingin 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. gcloud CLI versi sebelumnya mungkin tidak mendukung menjalankan perintah dalam dokumen ini.
Catatan: Untuk penginstalan gcloud CLI yang ada, pastikan untuk menyetel properti compute/region. Jika Anda terutama menggunakan cluster zona, tetapkan compute/zone. Dengan menyetel lokasi default, Anda dapat menghindari error di gcloud CLI yang seperti ini: One of [--zone, --region] must be supplied: Please specify location. Anda mungkin perlu menentukan lokasi dalam perintah tertentu jika lokasi cluster Anda berbeda dengan lokasi default yang Anda tetapkan.

Peran yang diperlukan

Untuk mendapatkan izin yang Anda perlukan guna membuat dan mengelola cluster GKE, minta administrator untuk memberi Anda peran IAM berikut pada project:

Kubernetes Engine Admin (roles/container.admin)
Editor Cloud Build (roles/cloudbuild.builds.editor)
Compute Admin (roles/compute.admin)
Project IAM Admin (roles/resourcemanager.projectIamAdmin)
Service Account Admin (roles/iam.serviceAccountAdmin)
Pengguna Akun Layanan (roles/iam.serviceAccountUser)
Service Usage Consumer (roles/serviceusage.serviceUsageConsumer)
Storage Admin (roles/storage.admin)

Untuk mengetahui informasi selengkapnya tentang pemberian peran, lihat Mengelola akses ke project, folder, dan organisasi.

Anda mungkin juga bisa mendapatkan izin yang diperlukan melalui peran khusus atau peran bawaan lainnya.

Mendapatkan kapasitas

Anda dapat memperoleh kapasitas untuk VM A4X dengan membuat pemesanan untuk masa mendatang. Untuk mengetahui informasi selengkapnya tentang pemesanan untuk masa mendatang, lihat kolom Pemesanan untuk masa mendatang di AI Hypercomputer dalam tabel untuk Pilih opsi penggunaan.

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 VM A4X:

Untuk A4X, pastikan Anda menggunakan, untuk 1.33 atau yang lebih baru, GKE versi 1.33.4-gke.1036000 atau yang lebih baru. Atau, untuk 1.32, gunakan GKE versi 1.32.8-gke.1108000 atau yang lebih baru. Versi ini memastikan bahwa A4X menggunakan hal berikut:
- R580, versi driver GPU minimum untuk A4X.
- Pengelolaan Memori Berbasis Driver yang Koheren (CDMM), yang diaktifkan secara default. NVIDIA merekomendasikan agar cluster Kubernetes mengaktifkan mode ini untuk mengatasi masalah pelaporan berlebih memori. CDMM memungkinkan memori GPU dikelola melalui driver, bukan sistem operasi (OS). Pendekatan ini membantu Anda menghindari pengaktifan memori GPU oleh OS, 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.
- GPUDirect RDMA, yang direkomendasikan untuk mengaktifkan node pool A4X agar dapat menggunakan kemampuan jaringan A4X.
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 pada satu node GKE. Beberapa Pod tidak dapat berbagi RDMA pada satu node GKE.
Penyiapan ini menjalankan pengujian NCCL. Untuk menjalankan pengujian NCCL ini, Anda harus memiliki kuota VM minimum 2 (masing-masing 4 GPU saat menggunakan a4x-highgpu-4g atau a4x-highgpu-4g-nolssd).
Anda harus menggunakan model penyediaan terikat reservasi untuk membuat cluster dengan A4X. Model penyediaan lainnya tidak didukung.
GPUDirect RDMA tidak kompatibel dengan NCCL Fast Socket atau GPUDirect TCPX/TCPXO. Jangan mengaktifkan NCCL Fast Socket atau menginstal plugin TCPX/TCPXO di cluster yang menggunakan GPUDirect RDMA.

Pertimbangan untuk membuat cluster

Saat Anda membuat cluster, pertimbangkan informasi berikut:

Pilih lokasi cluster:
- Pastikan Anda menggunakan lokasi yang memiliki ketersediaan untuk jenis mesin yang Anda pilih. Untuk mengetahui informasi selengkapnya, lihat Lokasi GPU.
- Untuk reservasi padat, Anda dapat membuat cluster zonal. Dalam hal ini, ganti flag --region dengan flag --zone=COMPUTE_ZONE, dengan COMPUTE_ZONE adalah zona bidang kontrol Anda.
- Saat membuat node pool di cluster regional, Anda dapat menggunakan flag --node-locations untuk menentukan zona bagi node GKE Anda.
Pilih 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.
Pilih afinitas reservasi:
- Anda dapat menemukan informasi tentang reservasi Anda, seperti nama reservasi atau nama blok tertentu dalam reservasi 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 reservasi tertentu.
- Saat Anda menggunakan reservasi tertentu, termasuk reservasi bersama, tentukan nilai flag --reservation dalam format berikut:
```
projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME
```
  Ganti nilai berikut:
  - PROJECT_ID: Google Cloud Project ID Anda.
  - RESERVATION_NAME: nama pemesanan Anda.
  - BLOCK_NAME: nama blok tertentu dalam reservasi.
  Untuk menggunakan reservasi yang menargetkan sub-blok sehingga VM ditempatkan pada satu sub-blok dalam BLOCK_NAME, tambahkan berikut ini di 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.

Buat cluster GKE yang dioptimalkan untuk AI yang menggunakan A4X dan GPUDirect RDMA

Untuk beban kerja AI terdistribusi, beberapa node GPU sering kali ditautkan bersama untuk bekerja sebagai satu komputer. A4X adalah platform exascale berdasarkan arsitektur skala rak NVL72 NVIDIA GB200. 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, termasuk bandwidth jaringan dan pengaturan NIC, lihat Jenis mesin A4X.

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

Membuat VPC dan subnet
Membuat cluster GKE dengan multi-networking
Buat objek jaringan GKE
Membuat kebijakan workload
Membuat node pool dengan A4X
Instal biner RDMA dan konfigurasi NCCL
Instal driver DRA dan CRD Domain Komputasi NVIDIA

Membuat VPC dan subnet

VM A4X memiliki konfigurasi berikut:

Empat GPU NVIDIA B200 per virtual machine yang terhubung dengan NVLink
Dua CPU NVIDIA Grace berbasis Arm
Empat kartu antarmuka jaringan (NIC) CX-7 400 Gbps untuk jaringan antar-GPU
Dua kartu antarmuka jaringan (NIC) Google Titanium 200 Gbps untuk layanan eksternal

Workload AI dan ML, seperti pelatihan terdistribusi, memerlukan akselerasi yang canggih untuk mengoptimalkan performa dengan mengurangi waktu penyelesaian tugas. 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.

Salah satu NIC Google Titanium yang terkait dengan CPU menggunakan jaringan default di GKE, sehingga Anda tidak perlu membuat VPC baru untuk NIC ini selama Anda memiliki rentang alamat IP yang cukup untuk jaringan default.

Anda dapat membuat satu VPC untuk NIC Titanium CPU kedua (gVNIC) dan VPC lain untuk empat NIC RDMA CX-7 menggunakan perintah berikut.

Untuk memaksimalkan bandwidth jaringan, perintah untuk membuat VPC bagi set GVNIC tambahan menetapkan unit transmisi maksimum (MTU) ke 8896. VPC RDMA secara default menggunakan setelan yang direkomendasikan, yaitu 8896. Untuk mengetahui informasi selengkapnya, lihat Setelan MTU dan jenis mesin GPU.

Tetapkan variabel lingkungan agar sesuai dengan deployment Anda:
```
export REGION="COMPUTE_REGION"
export ZONE="COMPUTE_ZONE"
export PROJECT="PROJECT_ID"
export GVNIC_NETWORK_PREFIX="GVNIC_NETWORK_PREFIX"
export RDMA_NETWORK_PREFIX="RDMA_NETWORK_PREFIX"
```
Ganti variabel berikut:
- COMPUTE_REGION: region cluster Anda.
- COMPUTE_ZONE: zona node pool Anda.
- PROJECT_ID: Google Cloud Project ID Anda.
- GVNIC_NETWORK_PREFIX: awalan jaringan GVNIC (misalnya, a4x-gvnic).
- RDMA_NETWORK_PREFIX: awalan jaringan RDMA (misalnya, a4x-rdma).

Buat dua jaringan VPC:

# Create a VPC for the additional GVNIC
gcloud compute --project=${PROJECT} \
  networks create \
  GVNIC_NETWORK_PREFIX-net \
  --subnet-mode=custom \
  --mtu=8896

gcloud compute --project=${PROJECT} \
  networks subnets create \
  GVNIC_NETWORK_PREFIX-sub \
  --network=GVNIC_NETWORK_PREFIX-net \
  --region=${REGION} \
  --range=192.168.0.0/24

gcloud compute --project=${PROJECT} \
  firewall-rules create \
  GVNIC_NETWORK_PREFIX-internal \
  --network=GVNIC_NETWORK_PREFIX-net \
  --action=ALLOW \
  --rules=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=192.168.0.0/16

# Create HPC VPC for the RDMA NICs with 4 subnets.
gcloud compute --project=${PROJECT} \
  networks create RDMA_NETWORK_PREFIX-net \
  --network-profile=${ZONE}-vpc-roce \
  --subnet-mode=custom

# Create subnets for the HPC VPC.
for N in $(seq 0 3); do
  gcloud compute --project=${PROJECT} \
    networks subnets create \
    RDMA_NETWORK_PREFIX-sub-$N \
    --network=RDMA_NETWORK_PREFIX-net \
    --region=${REGION} \
    --range=192.168.$((N+1)).0/24 &  # offset to avoid overlap with gvnics
done

Membuat cluster GKE dengan multi-jaringan

Buat cluster Standard GKE dengan multi-jaringan:
```
gcloud container clusters create CLUSTER_NAME \
    --enable-dataplane-v2 --enable-ip-alias --location=COMPUTE_REGION \
    --enable-multi-networking --cluster-version=CLUSTER_VERSION \
    --enable-kubernetes-unstable-apis=resource.k8s.io/v1beta1/deviceclasses,resource.k8s.io/v1beta1/resourceclaims,resource.k8s.io/v1beta1/resourceclaimtemplates,resource.k8s.io/v1beta1/resourceslices \
    [--services-ipv4-cidr=SERVICE_CIDR \
    --cluster-ipv4-cidr=POD_CIDR]
```
Saat menyiapkan perintah ini, lakukan hal berikut:
- Hapus flag --enable-kubernetes-unstable-apis, yang digunakan untuk mengaktifkan DRA, saat Anda membuat cluster yang menjalankan GKE versi 1.34 atau yang lebih baru. Flag ini hanya diperlukan saat Anda membuat cluster yang menjalankan versi 1.32 atau 1.33. Saat mengaktifkan API beta, Anda harus bermigrasi dari API beta tersebut saat API beta tidak digunakan lagi dan dihapus dengan versi minor Kubernetes yang lebih baru. Untuk mengetahui informasi selengkapnya, lihat Penghentian penggunaan API Beta.
- 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 secara eksplisit untuk layanan dan Pod. 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.

Membuat objek jaringan GKE

Anda harus mengonfigurasi jaringan VPC yang dibuat di bagian sebelumnya melalui kumpulan parameter jaringan GKE. Secara khusus, NIC Titanium CPU kedua (gVNIC) harus dikonfigurasi dalam mode NetDevice dan setiap NIC RDMA CX-7 dari empat NIC tersebut harus dikonfigurasi dalam mode RDMA.

Perintah ini menggunakan nama berikut:

VPC CPU Titanium NIC (gVNIC) diberi nama GVNIC_NETWORK_PREFIX-net dengan subnet bernama GVNIC_NETWORK_PREFIX-sub
VPC NIC RDMA CX-7 diberi nama RDMA_NETWORK_PREFIX-net dengan subnet yang diberi nama RDMA_NETWORK_PREFIX-sub-[0…3]

Buat objek jaringan GKE dengan menjalankan perintah berikut:

kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: gvnic-1
spec:
  vpc: GVNIC_NETWORK_PREFIX-net
  vpcSubnet: GVNIC_NETWORK_PREFIX-sub
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: gvnic-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: gvnic-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-0
spec:
  vpc: RDMA_NETWORK_PREFIX-net
  vpcSubnet: RDMA_NETWORK_PREFIX-sub-0
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-0
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-0
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-1
spec:
  vpc: RDMA_NETWORK_PREFIX-net
  vpcSubnet: RDMA_NETWORK_PREFIX-sub-1
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-2
spec:
  vpc: RDMA_NETWORK_PREFIX-net
  vpcSubnet: RDMA_NETWORK_PREFIX-sub-2
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-2
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-2
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-3
spec:
  vpc: RDMA_NETWORK_PREFIX-net
  vpcSubnet: RDMA_NETWORK_PREFIX-sub-3
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-3
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-3
EOF

Membuat kebijakan beban kerja

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

Buat kebijakan workload HIGH_THROUGHPUT dengan kolom accelerator_topology 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

Sebaiknya buat node pool yang menggunakan plugin perangkat GPU GKE. Plugin ini menyediakan pengelolaan resource GPU yang dikelola GKE. Pendekatan ini memiliki manfaat sebagai berikut:

Kemudahan deployment dan upgrade
Penginstalan otomatis driver
Fitur GPU yang dikelola GKE, seperti metrik dan GPU yang dipartisi
Perbaikan kerentanan keamanan penting

Atau, Anda dapat menggunakan Operator GPU NVIDIA, jika diperlukan oleh kasus penggunaan Anda. Untuk mengetahui informasi selengkapnya, lihat Mengapa harus menggunakan Operator GPU NVIDIA?.

Membuat node pool A4X dengan plugin perangkat GPU GKE

Buat node pool A4X yang menggunakan plugin perangkat GPU GKE:

gcloud container node-pools create NODE_POOL_NAME \
    --location COMPUTE_REGION \
    --node-locations COMPUTE_ZONE \
    --cluster CLUSTER_NAME \
    --num-nodes=NODE_COUNT \
    --machine-type MACHINE_TYPE \
    --accelerator type=nvidia-gb200,count=4,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 \
    --scopes "https://www.googleapis.com/auth/cloud-platform" \
    --reservation-affinity=specific \
    --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME \
    --placement-policy=WORKLOAD_POLICY_NAME

Ganti kode berikut:

NODE_POOL_NAME: nama node pool.
COMPUTE_REGION: region cluster Anda.
COMPUTE_ZONE: zona node pool Anda.
CLUSTER_NAME: nama cluster 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.
MACHINE_TYPE: a4x-highgpu-4g atau a4x-highgpu-4g-nolssd, bergantung pada apakah Anda menginginkan SSD Lokal.
DRIVER_VERSION: versi driver NVIDIA yang akan diinstal. Nilainya dapat berupa salah satu nilai berikut: default, latest, atau disabled.
RESERVATION_NAME: nama pemesanan Anda. Untuk menemukan nilai ini, lihat Melihat permintaan pemesanan untuk masa mendatang.
BLOCK_NAME: nama blok tertentu dalam reservasi. Untuk menemukan nilai ini, lihat Melihat permintaan pemesanan untuk masa mendatang.
WORKLOAD_POLICY_NAME: nama kebijakan beban kerja yang Anda buat sebelumnya.

Membuat node pool A4X dengan Operator GPU NVIDIA

Atau, untuk menggunakan Operator GPU NVIDIA, lakukan langkah-langkah berikut:

Jalankan perintah gcloud container node-pools create dari bagian sebelumnya dengan perubahan berikut:
- Ubah gpu-driver-version=latest menjadi gpu-driver-version=disabled. Modifikasi ini melewati penginstalan driver GPU otomatis karena tidak didukung saat menggunakan NVIDIA GPU Operator.
- Tetapkan --node-labels="gke-no-default-nvidia-gpu-device-plugin=true" ke nonaktifkan DaemonSet plugin perangkat GPU yang dikelola GKE.

Terapkan manifes DaemonSet penginstal driver GPU GKE. Manifest ini men-deploy Pod penginstal driver GPU di setiap node A4X:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

Mengelola Stack GPU dengan Operator GPU NVIDIA di Google Kubernetes Engine (GKE):

Di bagian untuk membuat dan menyiapkan node pool GPU, ikuti petunjuk yang dimulai dari langkah-langkah untuk mendapatkan kredensial autentikasi.

Instal Operator GPU NVIDIA. Selesaikan semua langkah, tetapi ganti perintah di bagian yang dirujuk yang menginstal NVIDIA GPU Operator menggunakan Helm. Gunakan perintah berikut sebagai gantinya:

helm install --wait --generate-name \
  -n gpu-operator \
  nvidia/gpu-operator \
  --version="25.3.0" \
  -f <(cat <<EOF
hostPaths:
  driverInstallDir: /home/kubernetes/bin/nvidia
toolkit:
  installDir: /home/kubernetes/bin/nvidia
cdi:
  enabled: true
  default: true
driver:
  enabled: false

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

node-feature-discovery:
  worker:
    tolerations:
      - key: kubernetes.io/arch
        operator: Equal
        value: arm64
        effect: NoSchedule
      - key: "node-role.kubernetes.io/master"
        operator: "Equal"
        value: ""
        effect: "NoSchedule"
      - key: "node-role.kubernetes.io/control-plane"
        operator: "Equal"
        value: ""
        effect: "NoSchedule"
      - key: nvidia.com/gpu
        operator: Exists
        effect: NoSchedule
EOF
)

Instal biner RDMA dan konfigurasi NCCL

Terapkan DaemonSet berikut untuk menginstal biner RDMA dan library NCCL di setiap node. Di setiap VM pokok, biner RDMA diinstal di direktori /home/kubernetes/bin/gib, dan library NCCL diinstal di direktori /home/kubernetes/bin/nvidia/lib64.

  kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-rdma/nccl-rdma-installer-a4x.yaml

Menginstal driver DRA dan CRD Compute Domain NVIDIA

Instal driver DRA dan CRD Compute Domain NVIDIA. Untuk mengetahui informasi selengkapnya, lihat Driver DRA NVIDIA untuk GPU.

Pastikan Anda telah menginstal Helm di lingkungan pengembangan. Helm sudah terinstal 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 dengan menjalankan perintah ini:
```
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 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 yang setidaknya 2 kali jumlah node A4X dalam cluster ditambah 1. Misalnya, Anda harus menyetel variabel ke minimal 37 jika memiliki 18 node A4X di cluster.

Instal driver DRA:

helm install nvidia-dra-driver-gpu nvidia/nvidia-dra-driver-gpu \
    --version="DRIVER_VERSION" \
    --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-gb200
              - 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
)

Ganti DRIVER_VERSION dengan versi 25.3.1 atau yang lebih baru.

Mengonfigurasi manifes workload untuk multi-networking, RDMA, dan domain IMEX

Tambahkan anotasi berikut ke metadata Pod:

metadata:
  annotations:
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth2","network":"rdma-0"},
        {"interfaceName":"eth3","network":"rdma-1"},
        {"interfaceName":"eth4","network":"rdma-2"},
        {"interfaceName":"eth5","network":"rdma-3"}
      ]

Tambahkan aturan afinitas node untuk menjadwalkan pada node Arm:

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

Untuk mengetahui informasi selengkapnya, lihat Menjadwalkan workload ke satu arsitektur.

Tambahkan volume berikut ke spesifikasi Pod:

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

Tambahkan pemasangan volume, 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
    - name: gib
   mountPath: /usr/local/gib
  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-compute-domain
spec:
  numNodes: NUM_NODES
  channel:
    resourceClaimTemplate:
      name: a4x-compute-domain-channel

Ganti NUM_NODES dengan jumlah node yang diperlukan workload.

Tentukan resourceClaimTemplate yang akan digunakan Pod:

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

Tetapkan semua variabel lingkungan yang diperlukan untuk mengonfigurasi NCCL. Gunakan skrip shell berikut dari container workload:
```
source /usr/local/gib/scripts/set_nccl_env.sh
```

Spesifikasi Pod yang sudah selesai akan terlihat seperti berikut:

apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
  name: a4x-compute-domain
spec:
  numNodes: NUM_NODES
  channel:
    resourceClaimTemplate:
      name: a4x-compute-domain-channel
---
apiVersion: apps/v1
kind: Pod
metadata:
  name: my-pod
  labels:
    k8s-app: my-pod
  annotations:
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth2","network":"rdma-0"},
        {"interfaceName":"eth3","network":"rdma-1"},
        {"interfaceName":"eth4","network":"rdma-2"},
        {"interfaceName":"eth5","network":"rdma-3"},
      ]
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
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib
  containers:
    - name: my-container
      volumeMounts:
        - name: library-dir-host
          mountPath: /usr/local/nvidia
        - name: gib
       mountPath: /usr/local/gib
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      resources:
        limits:
          nvidia.com/gpu: 4
        claims:
          - name: compute-domain-channel
        ...
resourceClaims:
  - name: compute-domain-channel
    resourceClaimTemplateName: a4x-compute-domain-channel

Menguji performa jaringan

Sebaiknya Anda memvalidasi fungsi cluster yang disediakan. Untuk melakukannya, gunakan uji NCCL/gIB, yaitu uji NVIDIA Collective Communications Library (NCCL) yang dioptimalkan untuk lingkungan Google.

Langkah berikutnya

Untuk mempelajari cara menjadwalkan workload di cluster GKE dengan 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.