Menskalakan kluster Ray di Azure Databricks

Pelajari cara menyetel ukuran kluster Ray Anda untuk performa optimal, termasuk penskalaan otomatis, konfigurasi head node, kluster heterogen, dan alokasi sumber daya.

Membuat kluster Ray dalam mode autoscaling

Di Ray 2.8.0 ke atas, kluster Ray dimulai di Azure Databricks mendukung integrasi dengan penskalakan otomatis Azure Databricks. Integrasi autoscaling ini memicu autoscaling kluster Azure Databricks secara internal dalam lingkungan Azure Databricks.

Untuk mengaktifkan autoscaling, jalankan perintah berikut:

Untuk Ray versi di bawah 2.10:

from ray.util.spark import setup_ray_cluster

setup_ray_cluster(
  num_worker_nodes=8,
  autoscale=True,
)

Untuk Ray versi 2.10 dan seterusnya:

from ray.util.spark import setup_ray_cluster, shutdown_ray_cluster

setup_ray_cluster(
  min_worker_nodes=2,
  max_worker_nodes=4,
  num_cpus_per_node=4,
  collect_log_to_path="/dbfs/path/to/ray_collected_logs"
)

# Pass any custom Ray configuration with ray.init
ray.init(ignore_reinit_error=True)

ray.util.spark.setup_ray_cluster API membuat kluster Ray pada Apache Spark. Secara internal, ini membuat pekerjaan Apache Spark latar belakang. Setiap tugas Apache Spark dalam pekerjaan membuat simpul pekerja Ray, dan simpul kepala Ray dibuat pada pengemudi. Argumen min_worker_nodes dan max_worker_nodes mewakili rentang simpul pekerja Ray untuk membuat dan memanfaatkan beban kerja Ray. Jika argumen min_worker_nodes dibiarkan tidak ditentukan, kluster Ray ukuran tetap akan dimulai dengan max_worker_nodes jumlah pekerja yang tersedia. Untuk menentukan jumlah inti CPU atau GPU yang ditetapkan ke setiap simpul pekerja Ray, atur argumen num_cpus_worker_node (nilai default: 1) atau num_gpus_worker_node (nilai default: 0).

Untuk Ray versi di bawah 2.10, jika penskalaan otomatis diaktifkan, num_worker_nodes menunjukkan jumlah maksimum simpul pekerja Ray. Jumlah minimum default simpul pekerja Ray adalah nol. Pengaturan default ini berarti bahwa ketika kluster Ray diam, ia menurunkan skala ke nol simpul pekerja Ray. Ini mungkin tidak ideal untuk responsivitas cepat dalam semua skenario, tetapi dapat secara signifikan mengurangi biaya ketika diaktifkan.

Dalam mode autoscaling, num_worker_nodes tidak dapat diatur ke ray.util.spark.MAX_NUM_WORKER_NODES.

Argumen berikut mengonfigurasi kecepatan peningkatan dan penurunan skala:

• autoscale_upscaling_speed menunjukkan jumlah simpul yang diizinkan untuk ditunda sebagai kelipatan dari jumlah simpul saat ini. Semakin tinggi nilainya, semakin agresif peningkatan skalanya. Misalnya, jika ini diatur ke 1,0, kluster dapat tumbuh dalam ukuran paling banyak 100% kapan saja.
• autoscale_idle_timeout_minutes mewakili jumlah menit yang perlu diteruskan sebelum autoscaler menghapus simpul pekerja menganggur. Semakin kecil nilainya, semakin agresif penurunan skalanya.

Dengan Ray 2.9.0 ke atas, Anda juga dapat mengatur autoscale_min_worker_nodes untuk mencegah kluster Ray menurunkan skala ke nol pekerja ketika kluster Ray diam, yang akan menyebabkan kluster dihentikan.

Mengonfigurasi sumber daya yang digunakan oleh simpul kepala Ray

Secara default, untuk konfigurasi Ray on Spark, Azure Databricks membatasi sumber daya yang dialokasikan ke simpul kepala Ray untuk:

• 0 inti CPU
• 0 GPU
• Memori timbunan 128 MB
• Memori penyimpanan objek 128 MB

Ini karena simpul kepala Ray biasanya digunakan hanya untuk koordinasi global, bukan untuk menjalankan tugas Ray. Sumber daya simpul driver Apache Spark dibagikan dengan beberapa pengguna, sehingga pengaturan default menyimpan sumber daya di sisi driver Apache Spark. Dengan Ray 2.8.0 ke atas, Anda dapat mengonfigurasi sumber daya yang digunakan oleh simpul kepala Ray. Gunakan argumen berikut di API setup_ray_cluster:

• num_cpus_head_node: mengatur inti CPU yang digunakan oleh simpul kepala Ray
• num_gpus_head_node: mengatur GPU yang digunakan oleh node head Ray
• object_store_memory_head_node: mengatur ukuran memori penyimpanan objek oleh node kepala Ray

Dukungan untuk kluster heterogen

Anda dapat membuat kluster Ray on Spark untuk pelatihan yang lebih efisien dan hemat biaya dan mengatur konfigurasi yang berbeda antara simpul kepala Ray dan simpul pekerja Ray. Namun, semua simpul pekerja Ray harus memiliki konfigurasi yang sama. Kluster Azure Databricks tidak sepenuhnya mendukung kluster heterogen, tetapi Anda dapat membuat kluster Azure Databricks dengan jenis instans driver dan pekerja yang berbeda dengan mengatur kebijakan kluster. Contohnya:

{
  "node_type_id": {
    "type": "fixed",
    "value": "i3.xlarge"
  },
  "driver_node_type_id": {
    "type": "fixed",
    "value": "g4dn.xlarge"
  },
  "spark_version": {
    "type": "fixed",
    "value": "13.x-snapshot-gpu-ml-scala2.12"
  }
}

Menyetel konfigurasi kluster Ray

Konfigurasi yang direkomendasikan untuk setiap simpul pekerja Ray adalah sebagai berikut: Minimum 4 inti CPU per simpul pekerja Ray. Memori tumpukan minimum 10GB untuk setiap simpul pekerja Ray.

Jadi, saat memanggil ray.util.spark.setup_ray_cluster, Azure Databricks merekomendasikan pengaturan num_cpus_per_node ke nilai yang lebih besar dari atau sama dengan 4.

Lihat bagian berikutnya untuk detail tentang menyetel memori timbunan untuk setiap simpul pekerja Ray.

Alokasi memori untuk simpul pekerja Ray

Setiap simpul pekerja Ray menggunakan dua jenis memori: memori timbunan dan memori penyimpanan objek.

Ukuran memori yang dialokasikan untuk setiap jenis ditentukan seperti yang dijelaskan di bawah ini.

Total memori yang dialokasikan untuk setiap simpul pekerja Ray adalah: RAY_WORKER_NODE_TOTAL_MEMORY = (SPARK_WORKER_NODE_PHYSICAL_MEMORY / MAX_NUMBER_OF_LOCAL_RAY_WORKER_NODES * 0.8)

MAX_NUMBER_OF_LOCAL_RAY_WORKER_NODES adalah jumlah maksimum simpul pekerja Ray yang dapat diluncurkan pada simpul pekerja Apache Spark. Ini ditentukan oleh argumen num_cpus_per_node atau num_gpus_per_node.

Jika Anda tidak mengatur argumen object_store_memory_per_node, maka ukuran memori tumpukan dan ukuran memori penyimpanan objek yang dialokasikan untuk setiap simpul pekerja Ray adalah: RAY_WORKER_NODE_HEAP_MEMORY = RAY_WORKER_NODE_TOTAL_MEMORY * 0.7OBJECT_STORE_MEMORY_PER_NODE = RAY_WORKER_NODE_TOTAL_MEMORY * 0.3

Jika Anda mengatur argumen object_store_memory_per_node: RAY_WORKER_NODE_HEAP_MEMORY = RAY_WORKER_NODE_TOTAL_MEMORY - argument_object_store_memory_per_node

Selain itu, ukuran memori penyimpanan objek per simpul pekerja Ray dibatasi oleh memori bersama sistem operasi. Nilai maksimumnya adalah: OBJECT_STORE_MEMORY_PER_NODE_CAP = (SPARK_WORKER_NODE_OS_SHARED_MEMORY / MAX_NUMBER_OF_LOCAL_RAY_WORKER_NODES * 0.8)

SPARK_WORKER_NODE_OS_SHARED_MEMORY adalah ukuran disk yang dikonfigurasi /dev/shm untuk simpul pekerja Apache Spark.

Praktik terbaik penskalakan

Atur nomor CPU dan GPU untuk setiap simpul pekerja Ray

Sebaiknya atur argumen num_cpus_worker_node ke jumlah inti CPU per simpul pekerja Apache Spark. Demikian pula, pengaturan num_gpus_worker_node ke jumlah GPU per simpul pekerja Apache Spark optimal. Dengan konfigurasi ini, setiap simpul pekerja Apache Spark meluncurkan satu simpul pekerja Ray yang akan sepenuhnya menggunakan sumber daya setiap simpul pekerja Apache Spark.

Atur variabel RAY_memory_monitor_refresh_ms lingkungan ke 0 dalam konfigurasi kluster Azure Databricks saat memulai kluster Apache Spark Anda.

Konfigurasi sumber daya memori untuk beban kerja hibrid Apache Spark dan Ray

Jika Anda menjalankan beban kerja Spark dan Ray hibrid di kluster Azure Databricks, Azure Databricks menyarankan Anda mengurangi memori eksekutor Spark ke nilai kecil. Misalnya, atur spark.executor.memory 4g dalam konfigurasi kluster Azure Databricks.

Eksekutor Apache Spark adalah proses Java yang memicu GC dengan malas, dan cache himpunan data Apache Spark menggunakan banyak memori eksekutor Apache Spark. Ini mengurangi memori yang tersedia yang dapat digunakan Ray. Untuk menghindari potensi kesalahan di luar memori, kurangi spark.executor.memory konfigurasi.

Konfigurasi sumber daya komputasi untuk beban kerja hibrid Apache Spark dan Ray

Jika Anda menjalankan beban kerja Spark dan Ray hibrid di kluster Azure Databricks, kami sarankan Anda membuat node kluster atau simpul pekerja Ray yang dapat diskalakan secara otomatis. Contohnya:

Jika Anda memiliki jumlah simpul pekerja tetap yang tersedia untuk memulai kluster Azure Databricks, kami sarankan Anda mengaktifkan penskalaan otomatis Ray-on-Spark. Ketika tidak ada beban kerja Ray yang berjalan, kluster Ray akan menurunkan skala, memungkinkan sumber daya dibebaskan untuk digunakan oleh tugas Apache Spark. Ketika tugas Apache Spark selesai, dan Ray digunakan lagi, kluster Ray-on-Spark akan kembali ditingkatkan untuk memenuhi permintaan.

Selain itu, Anda dapat membuat kluster Azure Databricks dan Ray-on-spark dapat diskalakan secara otomatis. Misalnya, jika Anda mengonfigurasi simpul kluster Azure Databricks yang dapat diskalakan secara otomatis ke maksimum 10 simpul, konfigurasikan simpul pekerja Ray-on-Spark ke maksimum empat simpul, dan konfigurasikan setiap simpul pekerja Ray untuk sepenuhnya menggunakan sumber daya setiap pekerja Apache Spark, beban kerja Ray dapat menggunakan paling banyak empat sumber daya node pada konfigurasi kluster tersebut. Sebagai perbandingan, pekerjaan Apache Spark dapat mengalokasikan paling banyak enam node sumber daya.