פריסת Ray עם האצת GPU לעומסי עבודה של AI ב-GKE

בדף הזה מוסבר איך להגדיר ולהריץ אשכול Ray עם GPU ב-Google Kubernetes Engine ‏ (GKE) כדי לשנות את גודל עומסי העבודה של AI/ML.

למה כדאי להשתמש ב-Ray?

שימוש ב-Ray ב-GKE, בעזרת KubeRay, מאפשר לכם להרחיב את אפליקציות ה-AI ו-Python. ‫Ray מטפל בהתאמת גודל האפליקציה, ו-GKE מנהל את השרתים והמשאבים הבסיסיים.

השילוב הזה מקל על ניהול המשאבים, על התאמה אוטומטית של הקיבולת, על הבטחת האמינות ועל פריסת האפליקציות בסביבות שונות. אם תקשרו את אפליקציות Ray המבוזרות עם תשתית הענן והכלים הקיימים שלכם ב-GKE, תוכלו לפשט את הפעולות ולספק פלטפורמה חזקה וניתנת להרחבה למשימות מורכבות באמצעות שיטות Kubernetes רגילות.

מידע נוסף זמין בפוסט בבלוג למה כדאי להשתמש ב-GKE לעומסי עבודה של AI ב-Ray.

לפני שמתחילים

לפני שמתחילים, חשוב לוודא שביצעתם את המשימות הבאות:

  1. 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.

    Go to project selector

  2. Verify that billing is enabled for your Google Cloud project.

  3. Enable the GKE API, if it is not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the API

  4. Install the Google Cloud CLI.

  5. Configure the gcloud CLI to use your federated identity.

    For more information, see Sign in to the gcloud CLI with your federated identity.

  6. To initialize the gcloud CLI, run the following command: 

    gcloud init
  7. התקנה של kubectl: kubectl הוא כלי שורת הפקודה העיקרי לאינטראקציה עם אשכולות GKE. אם אתם משתמשים ב-Cloud Shell,‏ kubectl כבר מותקן. אם לא, מריצים את הפקודה gcloud components install kubectl כדי להתקין אותו במסוף.

    כדי לוודא שההתקנה בוצעה, מריצים את הפקודה הבאה: kubectl version --client

  8. התקנת Ray: מומלץ מאוד ליצור סביבה וירטואלית של Python (venv) ולהיכנס אליה לפני שמתקינים את Ray, כדי לבודד את התלות שלה.
    1. מתקינים את Python.
    2. יוצרים ומפעילים סביבה וירטואלית חדשה.
    3. כדי להתקין את הגרסה היציבה העדכנית ביותר של Ray, מריצים את הפקודה pip install -U "ray[default]" בתוך הסביבה הווירטואלית.
    4. כדי לוודא שההתקנה בוצעה, מריצים את הפקודה ray --version. שימו לב לגרסת Ray (לדוגמה, 2.44.1) בפלט.
  9. מוודאים שלפרויקט Google Cloud יש מכסה מספקת ליחידות GPU מסוג L4. מידע נוסף זמין במאמרים מידע על יחידות GPU ומכסות הקצאה.

יצירת אשכול GKE

אפשר לפרוס את עומס העבודה באשכול GKE Autopilot או באשכול רגיל. מומלץ להשתמש באשכול Autopilot כדי ליהנות מחוויית Kubernetes מנוהלת באופן מלא. כדי לבחור את מצב ההפעלה של GKE שהכי מתאים לעומסי העבודה שלכם, קראו את המאמר בחירת מצב הפעלה של GKE.

טייס אוטומטי

במצב טייס אוטומטי, Google מנהלת את הגדרת האשכול, כולל שינוי גודל, אבטחה והגדרות אחרות שהוגדרו מראש. אשכולות Autopilot מותאמים להרצת רוב עומסי העבודה בסביבת הייצור, ולהקצאת משאבי מחשוב על סמך המניפסטים של Kubernetes.

  1. במסוף, מריצים את הפקודה gcloud container clusters create-auto:

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

    הפקודה הזו של Google Cloud CLI יוצרת אשכול Autopilot בשם my-ray-enabled-cluster, עם ההגדרות הבאות:

    • ‫--enable-ray-operator: מתקין את Ray Operator באשכול, מה שמפשט את הניהול של אשכולות Ray ב-Kubernetes.
    • ‫--enable-ray-cluster-monitoring: הגדרת שילוב עם Cloud Monitoring למדדי אשכול Ray.
    • ‫--enable-ray-cluster-logging: הגדרת שילוב עם Cloud Logging כדי לאסוף יומנים מאשכול Ray.
    • ‫--location=us-central1: מציין את האזור הגיאוגרפי שבו ייווצר אשכול GKE. חשוב לזכור שהזמינות של המאיצים והסוגים הנתמכים משתנים בהתאם למיקום. מידע נוסף זמין במאמר אזורים ותחומים של GPU.

    אשכולות Autopilot מקצים ומגדילים אוטומטית את קנה המידה של הצמתים (כולל צמתים עם GPU שמשתמשים במחלקות מחשוב) בהתאם לדרישות של עומסי העבודה, כדי לבצע אופטימיזציה של הניצול והעלות. הקצאה אוטומטית של הרשאות והתאמה אוטומטית של העומס על המשאבים באשכולות של Autopilot מפשטות את ניהול המשאבים, ומאפשרות לכם להתמקד במודלים במקום בתשתית.

    אם אתם משתמשים באשכול GKE Standard, יכול להיות שהדגלים וההגדרות להפעלת Ray יהיו שונים. מידע נוסף זמין במאמר הפעלת Ray Operator ב-GKE.

  2. מגדירים את kubectl כדי לתקשר עם האשכול:

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

רגילה

במצב רגיל, יש לכם יותר שליטה על התשתית הבסיסית של אשכול GKE. אתם מנהלים את מאגרי הצמתים, את גודלי הצמתים והגדרות אחרות באופן ישיר, וכך יכולים לבצע התאמה אישית רבה יותר. אשכולות רגילים מתאימים לעומסי עבודה שנדרשות להם הגדרות ספציפיות או שליטה הדוקה במשאבים.

  1. במסוף, מריצים את הפקודה gcloud container clusters create:

    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

    הפקודה הזו של Google Cloud CLI יוצרת אשכול Standard בשם my-ray-enabled-cluster, עם ההגדרות הבאות:

    • ‫--addons=RayOperator: מתקין את Ray Operator באשכול, מה שמפשט את הניהול של אשכולות Ray ב-Kubernetes.
    • ‫--enable-ray-cluster-monitoring: הגדרת שילוב עם Cloud Monitoring למדדי אשכול Ray.
    • ‫--enable-ray-cluster-logging: הגדרת שילוב עם Cloud Logging כדי לאסוף יומנים מאשכול Ray.
    • ‫--location=us-central1: מציין את האזור הגיאוגרפי שבו ייווצר אשכול GKE. חשוב לדעת שהזמינות של מאיצים וסוגי המאיצים הנתמכים משתנה בהתאם למיקום. מידע נוסף זמין במאמר אזורים ותחומים של GPU.
    • ‫--enable-autoprovisioning: יוצר ומוחק אוטומטית מאגרי צמתים ומשנה את מספר הצמתים במאגרים האלה בהתאם לדרישות של עומס העבודה.
    • ‫--max-cpu: מספר הליבות המקסימלי שאליו אפשר להרחיב את האשכול.
    • ‫--max-memory: מספר הג'יגה-בייט המקסימלי של זיכרון שאליו האשכול יכול להתרחב.

  2. מגדירים את kubectl כדי לתקשר עם האשכול:

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

מתקינים את הפלאגין kubectl ray של KubeRay.

תוסף kubectl ray מפשט תהליכי עבודה נפוצים של Ray ב-Kubernetes. הוראות ההתקנה העדכניות מפורטות במסמכי התיעוד של KubeRay.

  1. עוברים אל דף הגרסאות ומורידים את הקובץ הבינארי של הפלטפורמה שלכם. לדוגמה, כדי להתקין את הפלאגין kubectl ray בגרסה 1.3.2 ב-Linux amd64, מריצים את הפקודות הבאות:

    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

    מחליפים את ~/.local/bin בספרייה ב-PATH.

  2. מאמתים את ההתקנה:

    kubectl ray version

    אם אתם רואים אזהרה כמו KubeRay operator installation cannot be found: no KubeRay operator deployments found in any namespace., אפשר להתעלם ממנה. אם ההתקנה בוצעה בהצלחה, הפלט הוא הגרסה של הפלאגין של kubectl ray.

יצירת מחלקת מחשוב בהתאמה אישית באשכול

סוג מחשוב בהתאמה אישית ב-GKE מאפשר להגדיר דרישות חומרה ספציפיות, כמו סוג ה-GPU והמספר שלו, לפי סדר עדיפויות. ‫GKE משתמש בעדיפות הזו כשמוקצים צמתים לעומסי העבודה.

כדי ליצור את הדוגמה של מחלקת מחשוב בהתאמה אישית שמופיעה במדריך הזה, פועלים לפי השלבים הבאים:

  1. שומרים את המפרט הבא של מחלקת המחשוב בתור 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

  2. מריצים את הפקודה הבאה כדי ליצור את מחלקת המחשוב:

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

    מה קורה אחרי שמחילים את מחלקת המחשוב המותאמת אישית? אחרי שמחילים את קובץ ה-YAML של מחלקת המחשוב, GKE יקצה באופן אוטומטי צמתים עם GPU אחד של NVIDIA L4 כשמתקבלת בקשה מאשכול Ray. הוא ייתן עדיפות למכונות וירטואליות מסוג Spot כפי שמוגדר במניפסט. ההגדרה whenUnsatisfiable: DoNotScaleUp מורה ל-GKE לא ליצור צמתים שלא עומדים בדרישות שצוינו.

יצירה ואימות של אשכול Ray

עכשיו אפשר ליצור את אשכול Ray באשכול GKE.

  1. יוצרים את אשכול Ray. משתמשים בפקודה kubectl ray create cluster כדי להגדיר וליצור את אשכול Ray. הפקודה הזו מפשטת את התהליך כי היא מטפלת ביצירת משאבי Kubernetes הבסיסיים.

      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"

    הפקודה kubectl ray create cluster משתמשת בפלאגין KubeRay כדי לתרגם את המפרטים שלכם להגדרת משאב מותאם אישית של RayCluster ושולחת אותו ל-Kubernetes API כדי ליצור את אובייקט RayCluster. האובייקט הזה משמש כתוכנית, ומציין ל-Ray Operator איך להקצות ולנהל את הרכיבים בפועל של אשכול Ray (צומת ראשי וצומתי עובדים) ב-GKE. כברירת מחדל, GKE מתזמן את ה-Pod הראשי בצומת מסדרת המכונות E2.

    בפקודה לדוגמה נעשה שימוש בהגדרות הבאות:

    • ‫kubectl ray create cluster my-ray-cluster: מציין את השם של אשכול Ray שרוצים ליצור.
    • ‫--worker-node-selectors: אומר ל-Kubernetes לתזמן קבוצות Pod של עובדים בצמתים שמסומנים בתווית cloud.google.com/compute-class=gpu-compute-class.

  2. בודקים את הסטטוס של אשכול Ray. הפקודות האלה משמשות כדי לוודא שאשכול Ray פועל.

    • מריצים את הפקודה הבאה כדי לבדוק את המשאב של RayCluster:

      kubectl ray get cluster

      הפקודה הזו מציגה את כל אשכולות Ray במרחב השמות של Kubernetes. השם my-ray-cluster אמור להופיע ברשימה. יכול להיות שיחלפו כמה דקות עד שהאשכול יופעל.

    • כדי לבדוק את ה-Pods של Kubernetes, מריצים את הפקודה הבאה:

      kubectl get pods

      הפקודה הזו מציגה רשימה של כל ה-Pods שפועלים במרחב השמות של Kubernetes. אמורים להופיע Pods שקשורים לאשכול Ray:

      • Pod לצומת הראשי של Ray, עם שם כמו my-ray-cluster-head-0.
      • ‫Pod אחד או יותר לצמתי העובדים של Ray, עם שמות כמו my-ray-cluster-worker-group-0-xxxxx. מספר ה-Pods של ה-Workers תלוי בהגדרות האישיות הראשוניות של אשכול Ray ובהתאמה האוטומטית לעומס (אם הייתה כזו).

שליחת משימת Ray

אחרי שקלאסטר Ray מוכן, אפשר לשלוח משימת Ray לקלאסטר Ray הפועל ב-GKE.

כדי לעשות את זה, משתמשים בפקודה kubectl ray session כדי להתחיל סשן אינטראקטיבי, ובפקודה ray job submit כדי להתחיל את ביצוע המשימה.

  1. מתחילים סשן אינטראקטיבי של Ray. כדי ליצור חיבור מקומי לאשכול Ray, מריצים את הפקודה הבאה:

      kubectl ray session my-ray-cluster

    הפקודה הזו מתחילה העברת נתונים בין המכונה המקומית לבין צומת ה-head של Ray באשכול GKE. שימו לב שהטרמינל יהיה תפוס בזמן שהסשן הזה פעיל. כדי להמשיך, צריך לפתוח מופע נפרד של הטרמינל.

  2. יצירת הקוד לדוגמה להרצה. שומרים את קוד הדוגמה הבא בקובץ בשם 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. פותחים טרמינל חדש ושולחים את משימת Ray.

    1. פותחים טרמינל חדש במחשב המקומי. אם יצרתם סביבה וירטואלית להתקנת Ray, הקפידו להפעיל אותה גם במסוף החדש הזה.
    2. עוברים לספרייה שבה שמרתם את הקובץ sample_code.py.

    3. מריצים את הפקודה הבאה:

        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

      בדוגמה של הפקודה נעשה שימוש בהגדרות האלה:

      • ‫--working-dir=.: מציין את הספרייה הנוכחית כספריית העבודה שתהיה זמינה למשימת Ray באשכול. הספרייה הזו צריכה להכיל רק את קוד המקור של האפליקציה שרוצים להפעיל ב-Ray. בדוגמה שלנו, זה קובץ sample_code.py.
      • ‫--runtime-env-json='{"pip": ["requests==2.26.0"], "env_vars": {"counter_name": "test_counter"}}': מגדיר את סביבת זמן הריצה של המשימה. הוא מציין את גרסת ספריית Python הנדרשת (requests==2.26.0) ומגדיר משתנה סביבה (counter_name) להרצת המשימה.

  4. צפייה במשימת Ray. אפשר לעקוב אחרי המשימה באחת מהדרכים הבאות:

    • מרכז הבקרה של Ray: פותחים את דפדפן האינטרנט ועוברים אל http://localhost:8265. כתובת ה-URL הזו פותחת את לוח הבקרה של Ray, שבו אפשר לראות מידע על העבודה שמופעלת, כולל הסטטוס שלה, היומנים וניצול המשאבים.
    • Metrics Explorer: שימוש במרכזי הבקרה המובְנים של המדדים במסוףGoogle Cloud . מידע נוסף זמין במאמר איסוף והצגה של יומנים ומדדים של אשכולות Ray ב-GKE.

  5. סיום סשן Ray. אחרי שמסיימים את האינטראקציה עם אשכול Ray או את המעקב אחרי המשימה, אפשר לסיים את הסשן האינטראקטיבי על ידי הקשה על Ctrl+C במסוף שבו הפעלתם את הפקודה kubectl ray session.

הסרת המשאבים

כדי לא לצבור חיובים לחשבון Google Cloud על המשאבים שבהם השתמשתם בדף הזה:

אם פרסתם את המדריך למתחילים בפרויקט חדש ב- Google Cloud ואתם לא צריכים יותר את הפרויקט, תוכלו למחוק אותו באמצעות השלבים הבאים:

  1. נכנסים לדף Manage resources במסוף Google Cloud .
  2. ברשימת הפרויקטים, בוחרים את הפרויקט שרוצים למחוק ולוחצים על מחיקה.
  3. בתיבת הדו-שיח, מזינים את מזהה הפרויקט ולוחצים על Shut down כדי למחוק את הפרויקט.

אם לא יצרתם פרויקט חדש ב- Google Cloud , ואתם לא צריכים יותר את אשכול GKE, אתם יכולים למחוק אותו באמצעות הפקודה הבאה:

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

המאמרים הבאים

  • דוגמאות נוספות, שיטות מומלצות וכלים ל-Ray ב-GKE: מידע נוסף זמין במאגר ai-on-gke GitHub.
  • מידע נוסף על שימוש במאיצים ב-GKE: שימוש ב-GPU לעיבוד מקביל במשימות של למידת מכונה וניתוח נתונים. שימוש ב-TPU להאצת אימון והסקת מסקנות של מודלים של למידה עמוקה בקנה מידה גדול.
  • מידע נוסף על Ray Operator: במאמר מידע על Ray ב-GKE מוסבר איך להשתמש ב-Ray Operator כדי לנהל פריסות של Ray, כולל משימות של Ray.
  • שימוש ב-Kueue לתור משימות: איך Kueue, מערכת לתור משימות שמותאמת ל-Kubernetes, יכולה לעזור לכם לנהל את עומסי העבודה של AI/ML ולתעדף אותם, כדי לשפר את ניצול המשאבים. מידע נוסף מופיע במאמר אופטימיזציה של ניצול המשאבים ב-GKE לעומסי עבודה מעורבים של אימון והסקה ב-AI/ML.