Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

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

Autopilot Standard

Halaman ini menunjukkan cara menyiapkan dan menjalankan cluster Ray yang mendukung GPU di Google Kubernetes Engine (GKE) untuk menskalakan workload AI/ML Anda.

Mengapa menggunakan Ray?

Dengan menggunakan Ray di GKE, yang difasilitasi oleh KubeRay, Anda dapat menskalakan aplikasi Python dan AI. Ray menangani penskalaan aplikasi, dan GKE mengelola server dan resource yang mendasarinya.

Kombinasi ini memudahkan pengelolaan resource, menyesuaikan kapasitas secara otomatis, memastikan keandalan, dan men-deploy aplikasi Anda di berbagai lingkungan. Dengan menghubungkan aplikasi Ray terdistribusi dengan infrastruktur dan alat cloud yang ada di GKE, Anda dapat menyederhanakan operasi dan menyediakan platform yang tangguh dan skalabel untuk tugas yang kompleks menggunakan metode Kubernetes standar.

Untuk mengetahui informasi selengkapnya, lihat postingan blog Mengapa GKE untuk workload AI Ray Anda.

Sebelum memulai

Sebelum memulai, pastikan Anda telah menjalankan tugas berikut:

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
- Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector
Verify that billing is enabled for your Google Cloud project.
Enable the GKE API.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the API

Instal Google Cloud CLI.
Konfigurasi gcloud CLI agar menggunakan identitas gabungan Anda.

Untuk mengetahui informasi selengkapnya, lihat Login ke gcloud CLI dengan identitas gabungan Anda.
Untuk melakukan inisialisasi gcloud CLI, jalankan perintah berikut:
```
gcloud init
```
Instal kubectl: kubectl adalah alat command line utama untuk berinteraksi dengan cluster GKE. Jika Anda menggunakan Cloud Shell, kubectl sudah terinstal. Jika tidak, instal di terminal Anda dengan menjalankan perintah gcloud components install kubectl.
Untuk memverifikasi penginstalan, jalankan perintah ini: kubectl version --client
Instal Ray: sebaiknya buat dan masukkan lingkungan virtual Python (venv) sebelum menginstal Ray agar Anda dapat mengisolasi dependensinya.
1. Instal Python.
2. Buat dan aktifkan lingkungan virtual baru.
3. Instal versi stabil Ray terbaru dengan menjalankan perintah ini di dalam lingkungan virtual Anda: pip install -U "ray[default]".
4. Untuk memverifikasi penginstalan, jalankan perintah ini: ray --version. Perhatikan versi Ray (misalnya, 2.44.1) dalam output.
Pastikan Google Cloud project Anda memiliki kuota yang cukup untuk GPU L4. Untuk mengetahui informasi selengkapnya, lihat Tentang GPU dan Kuota alokasi.

Membuat cluster GKE

Anda dapat men-deploy workload di cluster GKE Autopilot atau Standar. Sebaiknya gunakan cluster Autopilot untuk pengalaman Kubernetes yang dikelola sepenuhnya. Untuk memilih mode operasi GKE yang paling sesuai untuk workload Anda, lihat Memilih mode operasi 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.

Di terminal, jalankan perintah gcloud container clusters create-auto 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 region geografis tempat cluster GKE akan dibuat. Perhatikan bahwa ketersediaan akselerator dan jenis yang didukung berbeda-beda menurut lokasi. Untuk mengetahui informasi selengkapnya, lihat Region dan zona GPU.
Cluster Autopilot otomatis menyediakan dan menskalakan node (termasuk node yang mendukung GPU yang menggunakan class komputasi) berdasarkan permintaan workload, sehingga mengoptimalkan penggunaan dan biaya. Penyediaan dan penskalaan resource otomatis di cluster Autopilot menyederhanakan pengelolaan resource, dan memungkinkan Anda berfokus pada model, bukan infrastruktur.

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

Konfigurasi kubectl untuk berkomunikasi dengan cluster Anda:

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

Standar

Dalam mode Standar, Anda memiliki lebih banyak kontrol atas infrastruktur dasar cluster GKE. Anda mengelola node pool, ukuran node, dan konfigurasi lainnya secara langsung, sehingga memungkinkan penyesuaian yang lebih besar. Cluster Standar cocok untuk workload yang memerlukan konfigurasi tertentu atau kontrol ketat atas resource.

Di terminal, jalankan perintah gcloud container clusters create berikut:
```
gcloud container clusters create my-ray-enabled-cluster \
    --addons=RayOperator \
    --enable-ray-cluster-monitoring \
    --enable-ray-cluster-logging \
    --location=us-central1 \
    --enable-autoprovisioning \
    --max-cpu=10 \
    --max-memory=64
```
Perintah Google Cloud CLI ini membuat cluster Standar bernama my-ray-enabled-cluster, dengan setelan berikut:
- --addons=RayOperator: 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 region geografis tempat cluster GKE akan dibuat. Perhatikan bahwa ketersediaan akselerator dan jenis yang didukung berbeda-beda menurut lokasi. Untuk mengetahui informasi selengkapnya, lihat Region dan zona GPU.
- --enable-autoprovisioning: otomatis membuat dan menghapus node pool serta menskalakan node dalam pool tersebut berdasarkan permintaan workload Anda.
- --max-cpu: jumlah maksimum core yang dapat diskalakan oleh cluster.
- --max-memory: jumlah maksimum gigabyte memori yang dapat diskalakan oleh cluster.

Konfigurasi kubectl untuk berkomunikasi dengan cluster Anda:

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

Menginstal plugin KubeRay `kubectl ray`

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

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.
Verifikasi penginstalan Anda:
```
kubectl ray version
```
Jika Anda 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, outputnya adalah versi plugin kubectl ray.

Membuat class komputasi kustom di cluster Anda

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

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

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: 1
    spot: false
  nodePoolAutoCreation:
    enabled: true
  whenUnsatisfiable: DoNotScaleUp

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, GKE akan otomatis menyediakan node dengan satu GPU NVIDIA L4 saat cluster Ray Anda memintanya. GKE 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 GKE.

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 ke dalam definisi resource kustom RayCluster dan mengirimkannya ke Kubernetes API untuk membuat objek RayCluster. Objek ini bertindak sebagai cetak biru, yang memberi tahu Ray Operator cara menyediakan dan mengelola komponen cluster Ray yang sebenarnya (node utama dan pekerja) dalam GKE. Secara default, GKE menjadwalkan Pod utama di node dari seri mesin E2.

Perintah contoh menggunakan setelan berikut:
- 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.
Penting: Untuk mendapatkan hasil terbaik, gunakan flag --ray-version dengan perintah kubectl ray create cluster agar versi Ray dan Python lokal Anda cocok dengan versi yang sesuai di cluster Ray. Menjaga versi tetap selaras umumnya akan meningkatkan stabilitas.
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 utama 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 mengirim 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.

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 mesin lokal Anda dan node utama Ray di cluster GKE Anda. Perhatikan bahwa terminal Anda akan digunakan saat sesi ini aktif; untuk melanjutkan, buka instance terminal terpisah.

Buat kode contoh untuk dijalankan. Simpan kode contoh 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"

Buka terminal baru dan kirim tugas Ray.
1. Buka terminal baru di mesin 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
```
  Perintah contoh menggunakan setelan berikut:
  - --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 kami, 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. Tindakan ini menentukan versi library Python yang diperlukan (requests==2.26.0) dan menetapkan variabel lingkungan (counter_name) untuk eksekusi tugas.
Lihat tugas Ray. Anda dapat memantau tugas dengan salah satu cara berikut:
- Dasbor Ray: buka browser web Anda dan 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.
- Metrics Explorer: gunakan dasbor metrik bawaan di Google Cloud konsol. Untuk mengetahui informasi selengkapnya, lihat Mengumpulkan dan melihat log dan metrik untuk cluster Ray di GKE.
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.

Pembersihan

Agar akunAnda tidak dikenai biaya untuk resource yang digunakan pada halaman ini, ikuti langkah-langkah berikut. Google Cloud

Jika Anda men-deploy panduan memulai diproject baru Google Cloud , dan tidak lagi memerlukan project tersebut, hapus dengan melakukan langkah-langkah berikut:

Di Google Cloud konsol, buka halaman Manage resources.
Dalam daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
Di dialog, masukkan project ID, lalu klik Shut down untuk menghapus project.

Jika Anda tidak membuat Google Cloud project baru, dan tidak lagi memerlukan cluster GKE, Anda dapat menghapusnya dengan menjalankan perintah ini:

gcloud container clusters delete my-ray-enabled-cluster \
    --location=us-central1

Langkah berikutnya

Pelajari contoh, praktik terbaik, dan alat tambahan untuk Ray di GKE: Untuk mengetahui informasi selengkapnya, lihat repositori GitHub ai-on-gke.
Pelajari lebih lanjut cara menggunakan akselerator di GKE: Gunakan GPU untuk pemrosesan paralel dalam tugas machine learning dan analisis data. Gunakan TPU untuk mempercepat pelatihan dan inferensi model deep learning berskala besar.
Pelajari lebih lanjut Ray Operator: Untuk mengetahui informasi selengkapnya tentang cara menggunakan Ray Operator untuk mengelola Deployment Ray, termasuk tugas Ray, lihat Tentang Ray di GKE.
Gunakan Kueue untuk pengantrean tugas: Temukan cara Kueue, sistem pengantrean tugas berbasis Kubernetes, dapat membantu mengelola dan memprioritaskan workload AI/ML Anda, yang dapat meningkatkan penggunaan resource. Untuk mengetahui informasi selengkapnya, lihat Mengoptimalkan penggunaan resource GKE untuk workload pelatihan dan inferensi AI/ML campuran.