Ray-fürtök méretezése az Azure Databricksben

Megtudhatja, hogyan hangolhatja a Ray-fürt méretét az optimális teljesítmény érdekében, beleértve az automatikus skálázást, a főcsomópont konfigurációját, a heterogén fürtöket és az erőforrás-lefoglalást.

Ray-fürt létrehozása automatikus skálázási módban

A Ray 2.8.0-s és újabb verziókban az Azure Databricksen elindított Ray-fürtök támogatják az Azure Databricks automatikus skálázásával való integrációt. Ez az automatikus skálázási integráció aktiválja az Azure Databricks-fürt automatikus skálázását az Azure Databricks-környezetben belül.

Az automatikus skálázás engedélyezéséhez futtassa a következő parancsot:

A Ray 2.10 alatti verziója esetén:

from ray.util.spark import setup_ray_cluster

setup_ray_cluster(
  num_worker_nodes=8,
  autoscale=True,
)

A Ray 2.10-es és újabb verziói esetén:

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)

Az ray.util.spark.setup_ray_cluster API létrehoz egy Ray-fürtöt az Apache Sparkban. Belsőleg létrehoz egy háttérben futó Apache Spark-feladatot. A feladat minden Apache Spark-feladata létrehoz egy Ray-feldolgozó csomópontot, a Ray head csomópont pedig az illesztőn jön létre. Az argumentumok min_worker_nodes és max_worker_nodes a Ray-számítási feladatokhoz létrehozandó és használható Ray-feldolgozó csomópontok tartományát jelölik. Ha az argumentum min_worker_nodes nincs meghatározva, a program egy rögzített méretű Ray-fürtöt indít el a rendelkezésre álló feldolgozók számával max_worker_nodes . Az egyes Ray-feldolgozó csomópontokhoz rendelt CPU- vagy GPU-magok számának megadásához állítsa be az argumentumot num_cpus_worker_node (alapértelmezett érték: 1) vagy num_gpus_worker_node (alapértelmezett érték: 0).

A Ray 2.10 alatti verziója esetén, ha az automatikus skálázás engedélyezve van, num_worker_nodes a Ray-feldolgozó csomópontok maximális számát jelzi. A Ray-feldolgozó csomópontok alapértelmezett minimális száma nulla. Ez az alapértelmezett beállítás azt jelenti, hogy ha a Ray-fürt tétlen, az nulla Ray-feldolgozó csomópontra skálázható le. Ez nem feltétlenül ideális a gyors válaszkészséghez minden helyzetben, de ha engedélyezve van, jelentősen csökkentheti a költségeket.

Automatikus skálázási módban num_worker_nodes nem állítható be ray.util.spark.MAX_NUM_WORKER_NODES.

A következő argumentumok konfigurálják a felskálázási és leskálázási sebességet:

• autoscale_upscaling_speed A függőben lévő csomópontok számát jelöli az aktuális csomópontok számának többszöröseként. Minél magasabb az érték, annál agresszívabb a felskálázás. Ha például 1,0-ra van állítva, a fürt mérete bármikor legfeljebb 100%-kal nőhet.
• autoscale_idle_timeout_minutes Azoknak a perceknek a száma, amelyeket el kell telnie ahhoz, hogy az automatikus skálázó eltávolítson egy tétlen munkavégző csomópontot. Minél kisebb az érték, annál agresszívabb a leskálázás.

A Ray 2.9.0-s vagy újabb verziója esetén azt is beállíthatja autoscale_min_worker_nodes , hogy a Ray-fürt nullára skálázható legyen, ha a Ray-fürt tétlen, ami a fürt leállását okozhatja.

A Ray head csomópont által használt erőforrások konfigurálása

Alapértelmezés szerint a Ray on Spark-konfiguráció esetében az Azure Databricks a Ray-főcsomóponthoz lefoglalt erőforrásokat a következőre korlátozza:

• 0 processzormag
• 0 GPU
• 128 MB halommemória
• 128 MB objektumtároló memória

Ennek az az oka, hogy a Ray-fej csomópontot általában csak a globális koordinációhoz használják, a Ray-feladatok futtatásához nem. Az Apache Spark-illesztőprogram csomópont erőforrásai több felhasználóval vannak megosztva, így az alapértelmezett beállítás az Apache Spark-illesztőprogram oldalán menti az erőforrásokat. A Ray 2.8.0-s és újabb verziókban konfigurálhatja a Ray head csomópont által használt erőforrásokat. Használja az alábbi argumentumokat a setup_ray_cluster API-ban:

• num_cpus_head_node: a Ray-fej csomópont által használt processzormagok beállítása
• num_gpus_head_node: a Ray-fejcsomópont által használt GPU beállítása
• object_store_memory_head_node: az objektumtár memóriaméretének beállítása Ray head node szerint

Heterogén fürtök támogatása

Létrehozhat egy Ray on Spark-fürtöt a hatékonyabb és költséghatékonyabb betanítási futtatásokhoz, és különböző konfigurációkat állíthat be a Ray-fej csomópontja és a Ray-feldolgozó csomópontok között. Azonban minden Ray-feldolgozó csomópontnak ugyanazzal a konfigurációval kell rendelkeznie. Az Azure Databricks-fürtök nem támogatják teljes mértékben a heterogén fürtöket, de fürtszabályzat beállításával létrehozhat egy Azure Databricks-fürtöt különböző illesztőprogram- és feldolgozópéldány-típusokkal. Példa:

{
  "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"
  }
}

A Ray-fürt konfigurációjának finomhangolása

Az egyes Ray-feldolgozó csomópontok ajánlott konfigurációja a következő: Ray-feldolgozó csomópontonként legalább 4 processzormag. Legalább 10 GB halommemória minden Ray-feldolgozó csomóponthoz.

Híváskor ray.util.spark.setup_ray_clustertehát az Azure Databricks azt javasolja, hogy 4-nél nagyobb vagy egyenlő értéket állítsunk be num_cpus_per_node .

Az egyes Ray-feldolgozó csomópontok halommemóriának finomhangolásával kapcsolatos részletekért tekintse meg a következő szakaszt.

Memóriafoglalás Ray-feldolgozó csomópontokhoz

Minden Ray-feldolgozó csomópont kétféle memóriát használ: a halommemóriát és az objektumtároló memóriát.

Az egyes típusokhoz lefoglalt memóriaméretet az alábbiakban leírtak szerint határozzuk meg.

Az egyes Ray-feldolgozó csomópontok számára lefoglalt teljes memória a következő: 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 Az Apache Spark-feldolgozó csomóponton indítható Ray-feldolgozó csomópontok maximális száma. Ezt az argumentum num_cpus_per_node vagy num_gpus_per_nodea .

Ha nem állítja be az argumentumot object_store_memory_per_node, akkor az egyes Ray-feldolgozó csomópontok számára lefoglalt halommemória és objektumtároló memóriamérete a következő: RAY_WORKER_NODE_HEAP_MEMORY = RAY_WORKER_NODE_TOTAL_MEMORY * 0.7OBJECT_STORE_MEMORY_PER_NODE = RAY_WORKER_NODE_TOTAL_MEMORY * 0.3

Ha beállítja az argumentumot object_store_memory_per_node: RAY_WORKER_NODE_HEAP_MEMORY = RAY_WORKER_NODE_TOTAL_MEMORY - argument_object_store_memory_per_node

Emellett az objektumtár ray-feldolgozó csomópontonkénti memóriaméretét az operációs rendszer megosztott memóriája korlátozza. A maximális érték a következő: 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/dev/shm Az Apache Spark feldolgozó csomóponthoz konfigurált lemezméret.

Skálázás – ajánlott eljárás

Az egyes Ray-feldolgozó csomópontok PROCESSZOR- és GPU-számának beállítása

Javasoljuk, hogy állítsa az argumentumot num_cpus_worker_node az Apache Spark feldolgozócsomópontonkénti processzormagok számára. Hasonlóképpen, az Apache Spark-feldolgozó csomópontonkénti GPU-k számának beállítása num_gpus_worker_node optimális. Ezzel a konfigurációval minden Apache Spark-feldolgozó csomópont elindít egy Ray-feldolgozó csomópontot, amely teljes mértékben kihasználja az egyes Apache Spark-feldolgozó csomópontok erőforrásait.

Állítsa be a környezeti változót RAY_memory_monitor_refresh_ms 0 az Azure Databricks-fürt konfigurációjába az Apache Spark-fürt indításakor.

Memóriaerőforrás-konfiguráció hibrid Apache Spark- és Ray-számítási feladatokhoz

Ha hibrid Spark- és Ray-számítási feladatokat futtat egy Azure Databricks-fürtben, az Azure Databricks azt javasolja, hogy csökkentse a Spark-végrehajtó memóriáját egy kis értékre. Állítsa be például spark.executor.memory 4g az Azure Databricks-fürt konfigurációjában.

Az Apache Spark-végrehajtó egy Java-folyamat, amely lazán aktiválja a GC-t, és az Apache Spark adatkészlet-gyorsítótára sok Apache Spark-végrehajtó memóriát használ. Ez csökkenti a Ray által használható memóriát. A memóriakihasználtság esetleges hibáinak elkerülése érdekében csökkentse a konfigurációt spark.executor.memory .

Számítási erőforrás konfigurációja apache Spark- és Ray-hibrid számítási feladatokhoz

Ha hibrid Spark- és Ray-számítási feladatokat futtat egy Azure Databricks-fürtben, javasoljuk, hogy a fürtcsomópontokat vagy a Ray-feldolgozó csomópontokat automatikusan skálázhatóvá tegye. Példa:

Ha rögzített számú feldolgozó csomópont érhető el az Azure Databricks-fürt elindításához, javasoljuk, hogy engedélyezze a Ray-on-Spark automatikus skálázását. Ha nem fut Ray-számítási feladat, a Ray-fürt leskálázható, így az Erőforrások felszabadíthatók az Apache Spark-feladatok számára. Ha az Apache Spark-feladatok befejeződnek, és a Ray újra használatban van, a Ray-on-Spark-fürt ismét felskálázható az igényeknek megfelelően.

Emellett automatikusan méretezhetővé teheti az Azure Databricks és a Ray-on-spark fürtöket. Ha például az Azure Databricks-fürt automatikusan méretezhető csomópontjait legfeljebb 10 csomópontra konfigurálja, a Ray-on-Spark feldolgozó csomópontokat legfeljebb négy csomópontra konfigurálja, és az egyes Ray-feldolgozó csomópontokat úgy konfigurálja, hogy teljes mértékben kihasználják az Egyes Apache Spark-feldolgozók erőforrásait, a Ray-számítási feladatok legfeljebb négy csomópont-erőforrást használhatnak egy ilyen fürtkonfigurációban. Ehhez képest az Apache Spark-feladatok legfeljebb hat csomópontnyi erőforrást foglalhatnak le.