Men-deploy Ray yang diakselerasi GPU untuk workload AI di GKE

Membuat cluster dalam mode GKE Autopilot

Dalam mode Autopilot, Google mengelola konfigurasi cluster Anda, termasuk penskalaan, keamanan, dan setelan lainnya yang telah dikonfigurasi sebelumnya. Cluster Autopilot dioptimalkan untuk menjalankan sebagian besar workload produksi dan menyediakan resource komputasi berdasarkan manifes Kubernetes Anda.

1. Di terminal, jalankan perintah berikut:

   gcloud container clusters create-auto my-ray-enabled-cluster \
       --enable-ray-operator \
       --enable-ray-cluster-monitoring \
       --enable-ray-cluster-logging \
       --location=us-central1
   

   Perintah Google Cloud CLI ini membuat cluster Autopilot bernama my-ray-enabled-cluster, dengan setelan berikut:

   • --enable-ray-operator: menginstal Ray Operator di cluster, yang menyederhanakan pengelolaan cluster Ray dalam Kubernetes.
   • --enable-ray-cluster-monitoring: menyiapkan integrasi dengan Cloud Monitoring untuk metrik cluster Ray.
   • --enable-ray-cluster-logging: mengonfigurasi integrasi dengan Cloud Logging untuk mengumpulkan log dari cluster Ray Anda.
   • --location=us-central1: menentukan wilayah geografis tempat cluster GKE akan dibuat. Perhatikan bahwa ketersediaan accelerator dan jenis yang didukung bervariasi menurut lokasi. Untuk informasi selengkapnya, lihat Region dan zona GPU.

   Cluster Autopilot secara otomatis menyediakan dan menskalakan node (termasuk node yang mendukung GPU dan menggunakan class komputasi) berdasarkan permintaan workload, yang mengoptimalkan penggunaan dan biaya. Penyediaan dan penskalaan resource otomatis ini di cluster Autopilot menyederhanakan pengelolaan resource, dan memungkinkan Anda berfokus pada model, bukan infrastruktur.

   Jika Anda menggunakan cluster GKE Standard, flag dan setelan untuk mengaktifkan Ray mungkin berbeda. Untuk informasi selengkapnya, lihat Mengaktifkan Operator Ray di GKE.

2. Konfigurasi kubectl untuk berkomunikasi dengan cluster Anda:

   gcloud container clusters get-credentials my-ray-enabled-cluster \
       --region=us-central1
   

Menginstal plugin kubectl ray KubeRay

Plugin kubectl ray menyederhanakan alur kerja Ray umum di Kubernetes. Untuk petunjuk penginstalan terbaru, lihat dokumentasi KubeRay.

1. Buka halaman rilis dan download biner untuk platform Anda. Misalnya, untuk menginstal plugin kubectl ray versi 1.3.2 di Linux amd64, jalankan perintah berikut:

   curl -LO https://github.com/ray-project/kuberay/releases/download/v1.3.2/kubectl-ray_v1.3.2_linux_amd64.tar.gz
   tar -xvf kubectl-ray_v1.3.2_linux_amd64.tar.gz
   cp kubectl-ray ~/.local/bin
   

   Ganti ~/.local/bin dengan direktori di PATH Anda.

2. Verifikasi penginstalan Anda:

   kubectl ray version
   

   Jika melihat peringatan seperti KubeRay operator installation cannot be found: no KubeRay operator deployments found in any namespace., Anda dapat mengabaikannya dengan aman. Jika penginstalan berhasil, output-nya adalah versi plugin kubectl ray.

Membuat class komputasi kustom di cluster Anda

Kelas komputasi kustom di GKE memungkinkan Anda menentukan persyaratan hardware tertentu, seperti jenis dan jumlah GPU, berdasarkan prioritas. Autopilot menggunakan prioritas ini saat menyediakan node untuk workload Anda.

Untuk membuat contoh class komputasi kustom untuk panduan ini, ikuti langkah-langkah berikut:

1. Simpan spesifikasi class komputasi berikut sebagai nvidia-l4-compute-class.yaml:

   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: gpu-compute-class
   spec:
     priorities:
     - gpu:
         type: nvidia-l4
         count: 1
       spot: true
     - gpu:
         type: nvidia-l4
         count: 4
       spot: false
     nodePoolAutoCreation:
       enabled: true
     whenUnsatisfiable: DoNotScaleUp
   

2. Buat class komputasi dengan menjalankan perintah ini:

   kubectl apply -f nvidia-l4-compute-class.yaml
   

   Apa yang terjadi setelah Anda menerapkan class komputasi kustom? Setelah menerapkan file YAML class komputasi, Autopilot akan otomatis menyediakan node dengan satu GPU NVIDIA L4 saat cluster Ray Anda memintanya. Tindakan ini akan memprioritaskan Spot VM seperti yang ditentukan dalam manifes Anda. Setelan whenUnsatisfiable: DoNotScaleUp menginstruksikan GKE untuk tidak membuat node yang tidak memenuhi persyaratan yang ditentukan.

Membuat dan memverifikasi cluster Ray

Sekarang Anda dapat membuat cluster Ray di cluster Autopilot.

1. Buat cluster Ray. Gunakan perintah kubectl ray create cluster untuk menentukan dan membuat cluster Ray Anda. Perintah ini menyederhanakan proses dengan menangani pembuatan resource Kubernetes yang mendasarinya.

     kubectl ray create cluster my-ray-cluster \
         --worker-replicas=1 \
         --worker-cpu=2 \
         --worker-memory=4Gi \
         --worker-gpu=1 \
         --worker-node-selectors="cloud.google.com/compute-class=gpu-compute-class"
   

   Perintah kubectl ray create cluster menggunakan plugin KubeRay untuk menerjemahkan spesifikasi Anda menjadi definisi resource kustom RayCluster dan mengirimkannya ke Kubernetes API untuk membuat objek RayCluster. Objek ini berfungsi sebagai blueprint, yang memberi tahu Ray Operator cara menyediakan dan mengelola komponen cluster Ray yang sebenarnya (node head dan pekerja) dalam GKE. Secara default, GKE menjadwalkan Pod head di node dari seri mesin E2.

   Contoh perintah menggunakan setelan ini:

   • kubectl ray create cluster my-ray-cluster: menentukan nama cluster Ray yang ingin Anda buat.
   • --worker-node-selectors: memberi tahu Kubernetes untuk menjadwalkan Pod pekerja di node yang diberi label cloud.google.com/compute-class=gpu-compute-class.

2. Verifikasi status cluster Ray. Gunakan perintah ini untuk memverifikasi bahwa cluster Ray Anda sudah aktif dan berjalan.

   • Periksa resource RayCluster dengan menjalankan perintah ini:

     kubectl ray get cluster
     

     Perintah ini mencantumkan semua cluster Ray di namespace Kubernetes Anda. Anda akan melihat my-ray-cluster tercantum. Mungkin perlu waktu beberapa menit hingga cluster diinisialisasi.

   • Periksa Pod Kubernetes dengan menjalankan perintah ini:

     kubectl get pods
     

     Perintah ini mencantumkan semua Pod yang berjalan di namespace Kubernetes Anda. Anda akan melihat Pod yang terkait dengan cluster Ray Anda:

     • Pod untuk node head Ray, dengan nama seperti my-ray-cluster-head-0.
     • Satu atau beberapa Pod untuk node pekerja Ray, dengan nama seperti my-ray-cluster-worker-group-0-xxxxx. Jumlah Pod pekerja bergantung pada konfigurasi awal cluster Ray Anda dan penskalaan otomatis yang mungkin terjadi.

Mengirim tugas Ray

Setelah cluster Ray siap, Anda dapat mengirimkan tugas Ray ke cluster Ray yang berjalan di GKE.

Untuk melakukannya, gunakan perintah kubectl ray session untuk memulai sesi interaktif, dan perintah ray job submit untuk memulai eksekusi tugas.

1. Mulai sesi interaktif Ray. Untuk membuat koneksi lokal ke cluster Ray Anda, jalankan perintah ini:

     kubectl ray session my-ray-cluster
   

   Perintah ini memulai penerusan port antara komputer lokal dan node kepala Ray di cluster GKE Anda. Perhatikan bahwa terminal Anda akan digunakan saat sesi ini aktif; untuk melanjutkan, buka instance terminal terpisah.

2. Buat kode contoh untuk dijalankan. Simpan contoh kode berikut ke file bernama sample_code.py.

     import ray
     import os
     import requests
   
     ray.init()
   
     @ray.remote
     class Counter:
         def __init__(self):
             # Used to verify runtimeEnv
             self.name = os.getenv("counter_name")
             assert self.name == "test_counter"
             self.counter = 0
   
         def inc(self):
             self.counter += 1
   
         def get_counter(self):
             return "{} got {}".format(self.name, self.counter)
   
     counter = Counter.remote()
   
     for _ in range(5):
             ray.get(counter.inc.remote())
             print(ray.get(counter.get_counter.remote()))
   
     # Verify that the correct runtime env was used for the job.
     assert requests.__version__ == "2.26.0"
   

3. Buka terminal baru dan kirim tugas Ray.

   1. Buka terminal baru di komputer lokal Anda. Jika Anda membuat lingkungan virtual untuk penginstalan Ray, pastikan Anda juga mengaktifkannya di terminal baru ini.
   2. Buka direktori tempat Anda menyimpan file sample_code.py.

   3. Jalankan perintah berikut:

        ray job submit \
            --working-dir=. \
            --runtime-env-json='{"pip": ["requests==2.26.0"], "env_vars": {"counter_name": "test_counter"}}' \
            --address http://localhost:8265 python sample_code.py
      

      Contoh perintah menggunakan setelan ini:

      • --working-dir=.: menentukan direktori saat ini sebagai direktori kerja yang akan disediakan untuk tugas Ray di cluster. Idealnya, direktori ini hanya berisi kode sumber aplikasi yang ingin Anda jalankan di Ray. Dalam contoh kita, ini adalah file sample_code.py.
      • --runtime-env-json='{"pip": ["requests==2.26.0"], "env_vars": {"counter_name": "test_counter"}}': menentukan lingkungan runtime untuk tugas. File ini menentukan versi library Python yang diperlukan (requests==2.26.0) dan menetapkan variabel lingkungan (counter_name) untuk eksekusi tugas.

4. Lihat tugas Ray. Anda dapat memantau tugas dengan salah satu cara berikut:

   • Dasbor Ray: buka browser web Anda, lalu buka http://localhost:8265. URL ini akan membuka dasbor Ray, tempat Anda dapat melihat informasi tentang tugas yang sedang berjalan, termasuk status, log, dan penggunaan resource-nya.
   • Metrics Explorer: gunakan dasbor metrik bawaan di konsolGoogle Cloud . Untuk mengetahui informasi selengkapnya, lihat Mengumpulkan dan melihat log serta metrik untuk cluster Ray di GKE.

5. Hentikan sesi Ray. Setelah selesai berinteraksi dengan cluster Ray atau memantau tugas, Anda dapat menghentikan sesi interaktif dengan menekan Ctrl+C di terminal tempat Anda menjalankan perintah kubectl ray session.