הפעלת יחידות GPU במאגרי צמתים של GKE Standard

בדף הזה מוסבר איך להריץ ולשפר את עומסי העבודה שדורשים משאבי מחשוב רבים, כמו בינה מלאכותית (AI) ועיבוד גרפי, על ידי צירוף מאיצי חומרה של יחידות עיבוד גרפי (GPU) של NVIDIA®‎ לצמתים של אשכולות Standard ב-Google Kubernetes Engine ‏(GKE) ושימוש בהם. אם אתם משתמשים ב-Autopilot Pods, קראו את המאמר פריסת עומסי עבודה של GPU ב-Autopilot.

אם אתם רוצים לפרוס אשכולות עם מעבדי GPU מסוג NVIDIA B300,‏ NVIDIA B200 או NVIDIA H200 141GB, אתם יכולים להיעזר במקורות המידע הבאים:

סקירה כללית

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

מידע נוסף על תרחישים לדוגמה של שימוש ב-GPU זמין בדף GPUs של Google Cloud. למידע נוסף על מעבדי GPU ב-GKE ועל ההבדלים בין מצב Standard למצב Autopilot, קראו את המאמר מידע על מעבדי GPU ב-GKE.

אם עומסי העבודה שלכם יכולים לסבול שיבושים תכופים בצמתים, אתם יכולים להשתמש במעבדי GPU גם עם VM במודל Spot. שימוש ב-VM במודל Spot מפחית את מחיר ההפעלה של יחידות GPU. מידע נוסף זמין במאמר שימוש ב-VM במודל Spot עם מאגרי צמתים של GPU.

החל מגרסה 1.29.2-gke.1108000, אפשר ליצור מאגרי צמתים של GPU ב-GKE Sandbox. מידע נוסף זמין במאמרים GKE Sandbox והגדרת GKE Sandbox.

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

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

  • מפעילים את Google Kubernetes Engine API.
    • הפעלת Google Kubernetes Engine API
  • כדי להשתמש ב-Google Cloud CLI למשימה הזו, מתקינים ואז מאתחלים את ה-CLI של gcloud. אם כבר התקנתם את ה-CLI של gcloud, הריצו את הפקודה gcloud components update כדי להוריד את הגרסה העדכנית. יכול להיות שבגרסאות קודמות של ה-CLI של gcloud אי אפשר להריץ את הפקודות שבמסמך הזה.

הדרישות לשימוש במעבדים גרפיים ב-GKE

אלה הדרישות לשימוש במעבדים גרפיים ב-GKE:

  • מכסת GPU: כדי ליצור צומתי GPU, צריך שתהיה לכם מכסת GPU ב-Compute Engine באזור שבחרתם. כדי לוודא שיש לכם מספיק מכסת GPU בפרויקט, עיינו בקטע Quotas במסוף Google Cloud .

    אם אתם צריכים מכסה נוספת של GPU, אתם צריכים לבקש מכסה של GPU במסוף Google Cloud . אם יש לכם חשבון לחיוב קיים, הפרויקט יקבל מכסה באופן אוטומטי אחרי שתשלחו את הבקשה למכסה.

    כברירת מחדל, חשבונות בתקופת ניסיון בחינם לא מקבלים מכסת GPU.

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

  • סדרת מכונות: סוג ה-GPU שאפשר להשתמש בו תלוי בסדרת המכונות, באופן הבא:

    חשוב לוודא שיש לכם מספיק מכסה בפרויקט לסדרת המכונות שתואמת לסוג ולכמות של ה-GPU שבחרתם.

  • ‫גרסאות GKE: צריך להשתמש בגרסאות GKE ספציפיות לסדרות ולתצורות מסוימות של מכונות:

    • סדרה A עם אופטימיזציה למאיצים: דרישות הגרסה מפורטות במדריכים ליצירת אשכולות.

    • סדרת מכונות G4 במצב רגיל:

      • סוגי מכונות עם GPU אחד או יותר: גרסה ‎1.34.0-gke.1662000 ואילך

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

        • ‫1.34: ‏ 1.34.5-gke.1153000
        • ‫1.35 ואילך: 1.35.3-gke.1389000

  • מעבדי GPU בצומתי Ubuntu: אם אתם משתמשים במעבדי GPU עם צומתי Ubuntu, חלות הדרישות הבאות:

    • תאימות מנהלי התקנים של Ubuntu:

      • מעבדי GPU מסוג L4 ומעבדי GPU מסוג H100: מנהל התקן של NVIDIA בגרסה 535 ואילך

      • ‫H200 GPUs: גרסה 550 ומעלה של מנהל ההתקן של NVIDIA

      • ‫B200 GPU: דרייבר של NVIDIA בגרסה 570 ואילך

      • ‫RTX PRO 6000 GPUs: גרסת מנהל ההתקן של NVIDIA‏ 580 ואילך. התאימות לגרסה הזו לא כוללת סוגי מכונות G4 עם פחות מ-GPU אחד, כי הם לא תומכים בתמונות של צומתי Ubuntu.

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

    • תאימות לגרסאות של Ubuntu:

      כשמשתמשים בסדרת המכונות A4 במאגרי צמתים של Ubuntu, צריך להשתמש בגרסת GKE שכוללת את קובץ האימג' ubuntu-gke-2404-1-32-amd64-v20250730 או בגרסה מאוחרת יותר של קובץ האימג' של הצומת. אלה הגרסאות המינימליות של GKE:

      • ‫‎1.32.7-gke.1067000 ואילך ל-GKE בגרסה 1.32
      • ‫‎1.33.3-gke.1247000 ואילך ל-GKE בגרסה 1.33
שיטה מומלצת:

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

מגבלות על השימוש ב-GPU ב-GKE

לפני שמשתמשים במעבדי GPU ב-GKE, חשוב לזכור את המגבלות הבאות:

זמינות של GPUs לפי אזורים ו-zones

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

לרשימה מלאה של אזורים ותחומים רלוונטיים, עיינו ב-GPUs ב-Compute Engine.

אפשר גם לראות את יחידות ה-GPU שזמינות באזור שלכם באמצעות Google Cloud CLI. כדי לראות רשימה של כל סוגי מאיצי ה-GPU שנתמכים בכל אזור, מריצים את הפקודה הבאה:

gcloud compute accelerator-types list

תמחור

למידע על מחירי GPU, עיינו בטבלת המחירים בדף Google Cloud GPU.

מוודאים שיש מספיק מכסה ל-GPU

מכסת ה-GPU היא המספר הכולל של מעבדי GPU שיכולים לפעול בפרויקט ב-Google Cloud . כדי ליצור אשכולות עם GPUs, לפרויקט צריכה להיות מכסת GPU מספיקה.

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

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

בקשת מכסת GPU

כדי לבקש מכסת GPU, צריך להשתמש במסוף Google Cloud . למידע נוסף על בקשת מכסות, קראו את המאמר מכסות GPU במרכז העזרה של Compute Engine.

כדי לחפש מכסת GPU ולשלוח בקשה להגדלת המכסה, משתמשים במסוף Google Cloud :

  1. נכנסים לדף Quotas בקטע IAM & Admin במסוף Google Cloud .

    לפתיחת הדף Quotas

  2. בתיבה Filter:

    1. בוחרים את המאפיין Quota, מזינים את השם של מודל ה-GPU ולוחצים על Enter.
    2. (אופציונלי) כדי להחיל מסננים מתקדמים יותר לצמצום התוצאות, בוחרים במאפיין Dimensions (לדוגמה, מיקומים), מוסיפים את שם האזור או התחום שבהם אתם משתמשים ולוחצים על Enter.

  3. ברשימת המכסות של ה-GPU, בוחרים את המכסה שרוצים לשנות.

  4. לוחצים על Edit quotas. ייפתח טופס בקשה.

  5. ממלאים את השדה New quota limit לכל בקשה להגדלת מכסה.

  6. ממלאים את השדה Request description בפרטים על הבקשה.

  7. לוחצים על הבא.

  8. בתיבת הדו-שיח אישור שינוי, לוחצים על אישור.

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

  10. לוחצים על Submit request.

  11. תקבלו הודעת אישור באימייל כדי לעקוב אחרי השינוי במכסה.

הפעלת GPUs באשכולות GKE Standard

כדי להריץ מעבדי GPU באשכולות GKE Standard, צריך ליצור מאגר צמתים עם מעבדי GPU מצורפים.

שיטה מומלצת:

כדי לשפר את היעילות מבחינת עלות, את האמינות ואת הזמינות של מעבדי GPU ב-GKE, בצעו את הפעולות הבאות:

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

כפי שמתואר בקטעים הבאים, GKE משתמש ב-taints וב-tolerations של צמתים כדי להבטיח ש-Pods לא יתוזמנו לצמתים לא מתאימים.

הוספת טיינט למאגר צומתי GPU כדי למנוע תזמון לא מתאים

הכתמת צומת מאפשרת לסמן צומת כדי שהמתזמן יימנע משימוש בו או ימנע שימוש בו לפודים מסוימים. בהתאם לתרחישים הבאים, GKE מוסיף את ה-taint‏ nvidia.com/gpu=present:NoSchedule באופן אוטומטי, או שאתם יכולים להוסיף אותו באופן ידני:

  • כשמוסיפים מאגר צמתים של GPU לאשכול קיים שכבר פועל בו מאגר צמתים ללא GPU, ‏ GKE מכתים באופן אוטומטי את צומתי ה-GPU בכתם הצומת הבא:

    • מפתח: nvidia.com/gpu
    • ערך: present
    • השפעה: NoSchedule

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

  • כשמוסיפים מאגר של צומתי GPU לאשכול שיש בו רק מאגרים של צומתי GPU, או כשיוצרים אשכול חדש שבו למאגר הצמתים שמוגדר כברירת מחדל מצורפים רכיבי GPU, אפשר להגדיר באופן ידני taints למאגר הצמתים החדש עם הערכים הבאים:

    • מפתח: nvidia.com/gpu
    • ערך: present
    • השפעה: NoSchedule

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

הגבלה אוטומטית של תזמון עם סובלנות

בעזרת Tolerations אפשר להגדיר פודים שאפשר להשתמש בהם בצמתים "פגומים". ‫GKE מחיל באופן אוטומטי toleration, כך שרק Pods שמבקשים GPUs מתוזמנים בצומתי GPU. כך אפשר לבצע התאמה אוטומטית לעומס בצורה יעילה יותר, כי צומתי ה-GPU יכולים להצטמצם במהירות אם אין מספיק Pods שמבקשים GPU. כדי לעשות את זה, GKE מריץ את בקרת אישור הבקשות ExtendedResourceToleration.

יצירת מאגר צמתים של GPU

כדי ליצור מאגר צמתים נפרד של GPU באשכול קיים, אתם יכולים להשתמש במסוףGoogle Cloud או ב-Google Cloud CLI. אתם יכולים להשתמש ב-Terraform גם כדי להקצות את אשכולות ה-GKE ואת מאגר הצמתים של ה-GPU.

ב-GKE אפשר להתקין באופן אוטומטי מנהלי התקנים של NVIDIA בתרחישים הבאים:

  • באשכולות GKE עם גרסת מישור בקרה 1.32.2-gke.1297000 ואילך, GKE מתקין באופן אוטומטי את גרסת ברירת המחדל של מנהל ההתקן של NVIDIA לכל צומתי ה-GPU, כולל אלה שנוצרו באמצעות הקצאת צמתים אוטומטית.
  • באשכולות GKE עם גרסת מישור בקרה מ-1.30.1-gke.1156000 עד 1.32.2-gke.1297000, ‏ GKE מתקין באופן אוטומטי את גרסת ברירת המחדל של מנהל ההתקן של NVIDIA לצמתים שלא נוצרו באמצעות הקצאת צמתים אוטומטית.
  • אפשר לבחור את גרסת הדרייבר העדכנית ביותר או להשבית באופן מפורש את ההתקנה האוטומטית של הדרייבר. בגרסאות שקודמות ל-1.30.1-gke.1156000, ‏ GKE לא מתקין מנהל התקן כברירת מחדל אם לא מציינים גרסת מנהל התקן כשיוצרים או מעדכנים את מאגר הצמתים.

gcloud

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

gcloud container node-pools create POOL_NAME \
  --accelerator type=GPU_TYPE,count=AMOUNT,gpu-driver-version=DRIVER_VERSION \
  --machine-type MACHINE_TYPE \
  --cluster CLUSTER_NAME \
  --location CONTROL_PLANE_LOCATION \
  --node-locations COMPUTE_ZONE1[,COMPUTE_ZONE2] \
  [--sandbox=type=gvisor]
  [--enable-autoscaling \
   --min-nodes MIN_NODES \
   --max-nodes MAX_NODES] \
  [--scopes=SCOPES] \
  [--service-account=SERVICE_ACCOUNT] \
  [--reservation-affinity=specific --reservation=RESERVATION_NAME]

מחליפים את מה שכתוב בשדות הבאים:

  • ‫POOL_NAME: השם שבחרתם למאגר הצמתים.
  • ‫GPU_TYPE: סוג מאיץ ה-GPU שבו אתם משתמשים. לדוגמה, nvidia-tesla-t4.

  • ‫AMOUNT: מספר ה-GPU שצריך לצרף לצמתים במאגר הצמתים. המספר הזה צריך להיות זהה למספר ה-GPU של סוג המכונה. לדוגמה, אם מגדירים את MACHINE_TYPE לערך g4-standard-384, צריך להגדיר את AMOUNT לערך 8, שהוא מספר יחידות ה-GPU שמחוברות לסוג המכונה הזה. עם זאת, אם משתמשים במכונה מסוג G4 עם פחות מ-GPU אחד, צריך להגדיר את AMOUNT לערך 1. ההגדרה הזו נדרשת כשמגדירים את GPU_TYPE לערך nvidia-rtx-pro-6000 ואת MACHINE_TYPE לאחד מהערכים הבאים:

    • ‫g4-standard-6 (שמינית GPU)
    • ‫g4-standard-12 (רבע GPU)
    • ‫g4-standard-24 (חצי GPU)
    • g4-standard-48 (מעבד גרפי אחד)

    בנוסף, באשכולות שבהם פועלות גרסאות GKE שקודמות ל-1.36, חשוב לפעול לפי ההוראות להכנת עומסי עבודה לסוגי מכונות G4 עם פחות מ-GPU אחד.

  • ‫DRIVER_VERSION: גרסת הדרייבר של NVIDIA שרוצים להתקין. יכול להיות אחת מהאפשרויות הבאות:

    • ‫default: התקנת גרסת ברירת המחדל של מנהל ההתקן לגרסת GKE של הצומת. בגרסה 1.30.1-gke.1156000 של GKE ואילך, אם משמיטים את הדגל gpu-driver-version, זו אפשרות ברירת המחדל. בגרסאות קודמות, GKE לא מתקין מנהל התקן אם משמיטים את הדגל הזה.
    • ‫latest: התקנת הגרסה העדכנית ביותר של מנהל ההתקן שזמינה לגרסת GKE שלכם. זמין רק לצמתים שמשתמשים במערכת הפעלה שמותאמת לקונטיינרים.
    • ‫disabled: דילוג על התקנה אוטומטית של מנהל ההתקן. חובה להתקין מנהל התקן באופן ידני אחרי שיוצרים את מאגר הצמתים. בגרסאות GKE שקודמות ל-1.30.1-gke.1156000, זו אפשרות ברירת המחדל.

    האפשרות gpu-driver-version זמינה רק בגרסה 1.27.2-gke.1200 של GKE ואילך. בגרסאות קודמות, צריך להשמיט את הדגל הזה ולהתקין מנהל התקן באופן ידני אחרי שיוצרים את מאגר הצמתים. אם משדרגים אשכול או מאגר צמתים קיימים לגרסה הזו או לגרסה מאוחרת יותר, GKE מתקין באופן אוטומטי את גרסת ברירת המחדל של מנהל ההתקן שתואמת לגרסת GKE, אלא אם מציינים אחרת כשמתחילים את השדרוג.

  • MACHINE_TYPE: סוג המכונה של Compute Engine לצמתים. נדרש לסוגי ה-GPU הבאים:

    • מעבדי NVIDIA B200 GPU (תואמים לסוג המאיץ nvidia-b200 ולסדרת המכונות A4)
    • מעבדי NVIDIA H200 141GB GPU (תואמים לסוג המאיץ nvidia-h200-141gb ולסוג המכונה A3 Ultra), מעבדי NVIDIA H100 80GB GPU (תואמים לסוג המאיץ nvidia-h100-80gb ולסוג המכונה A3 High) או מעבדי NVIDIA H100 80GB Mega GPU (תואמים לסוג המאיץ nvidia-h100-mega-80gb ולסוג המכונה A3 Mega). למידע נוסף, קראו על סדרת המכונות A3 במאמרי העזרה של Compute Engine.
    • מעבדי NVIDIA A100 40GB GPU (תואמים לסוג המאיץ nvidia-tesla-a100 ולסוג המכונה A2 Standard), או מעבדי NVIDIA A100 80GB GPU (תואמים לסוג המאיץ nvidia-a100-80gb ולסוג המכונה A2 Ultra). למידע נוסף, קראו את המאמר סדרת המכונות A2 במאמרי העזרה של Compute Engine.
    • מעבדי GPU מסוג NVIDIA L4 (תואמים לסוג המאיץ nvidia-l4 ולסדרת המכונות G2).
    • מעבדי GPU מסוג NVIDIA RTX PRO 6000 (שתואמים לסוג המאיץ nvidia-rtx-pro-6000 ולסדרת המכונות G4).

    לכל שאר ה-GPU, הדגל הזה הוא אופציונלי.

  • ‫CLUSTER_NAME: שם האשכול שבו רוצים ליצור את מאגר הצמתים.

  • ‫CONTROL_PLANE_LOCATION: המיקום ב-Compute Engine של מישור הבקרה של האשכול. מציינים אזור לאשכולות אזוריים, או תחום לאשכולות של תחומים.

  • ‫COMPUTE_ZONE1,COMPUTE_ZONE2,[...]: האזורים הספציפיים שבהם GKE יוצר את צומתי ה-GPU. האזורים צריכים להיות באותו אזור של האשכול, שצוין בדגל --location. סוגי ה-GPU שאתם מגדירים חייבים להיות זמינים בכל אזור שנבחר. אם אתם משתמשים בהזמנה, אתם צריכים לציין את האזורים שבהם יש לה קיבולת. מומלץ תמיד להשתמש בדגל --node-locations כשיוצרים את מאגר הצמתים, כדי לציין את האזור או האזורים שמכילים את יחידות ה-GPU המבוקשות.

  • אפשר גם ליצור מאגרי צמתים כדי להריץ עומסי עבודה בארגז חול באמצעות gVisor. למידע נוסף, קראו את המאמר GKE Sandbox.

  • ‫MIN_NODES: המספר המינימלי של צמתים בכל אזור במאגר הצמתים בכל זמן נתון. הערך הזה רלוונטי רק אם משתמשים בדגל --enable-autoscaling.

  • ‫MAX_NODES: המספר המקסימלי של צמתים בכל אזור במאגר הצמתים בכל זמן נתון. הערך הזה רלוונטי רק אם משתמשים בדגל --enable-autoscaling.

  • אם רוצים, אפשר ליצור את מאגר הצמתים של ה-GPU באמצעות חשבון שירות בהתאמה אישית, על ידי הוספת הדגלים הבאים. אם לא מציינים חשבון שירות, מאגר הצמתים משתמש בחשבון השירות שמוגדר כברירת מחדל ב-Compute Engine:

    • ‫SERVICE_ACCOUNT: השם של חשבון השירות ב-IAM שבו משתמשים הצמתים.
    • ‫SCOPES: רשימה מופרדת בפסיקים של היקפי הגישה שרוצים לתת. מוודאים שאחד מההיקפים הוא storage-ro או https://www.googleapis.com/auth/devstorage.read_only. מידע נוסף על היקפים זמין במאמר הגדרת היקפי גישה. אם לא תציינו את הדגל scope, יצירת מאגר הצמתים של ה-GPU תיכשל עם שגיאת AccessDenied failed to download gpu_driver_versions.bin from GCS bucket.

  • ‫RESERVATION_NAME: השם של הקצאת ה-GPU שבה רוצים להשתמש. מציינים את הדגל --reservation עם --reservation-affinity=specific כדי להשתמש בקיבולת ה-GPU מהזמנה ספציפית. מידע נוסף זמין במאמר שימוש במקום שמור לפרויקט יחיד ספציפי.

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

gcloud container node-pools create t4 \
  --accelerator type=nvidia-tesla-t4,count=2,gpu-driver-version=default \
  --cluster t4-cluster \
  --location us-central1 \
  --node-locations us-central1-c \
  --min-nodes 0 --max-nodes 5 --enable-autoscaling

אפשר גם לעדכן מאגר צמתים קיים. לדוגמה, אם רוצים לעדכן את מנהל ההתקן של ה-GPU כדי לעבור לגרסה העדכנית ביותר:

gcloud container node-pools update t4 \
  --accelerator type=nvidia-tesla-t4,count=2,gpu-driver-version=latest \
  --cluster t4-cluster \
  --location us-central1

המסוף

כדי ליצור מאגר צמתים עם GPUs:

  1. נכנסים לדף Google Kubernetes Engine במסוף Google Cloud .

    כניסה ל-Google Kubernetes Engine

  2. ברשימת האשכולות, לוחצים על שם האשכול שרוצים לשנות.

  3. לוחצים על הכרטיסייה Nodes.

  4. ‫לוחצים על Create user-managed node pool.

  5. אם רוצים, בדף פרטי מאגר הצמתים מסמנים את התיבה הפעלת התאמה אוטומטית לעומס.

  6. מגדירים את מאגר הצמתים לפי הצורך.

  7. בחלונית הניווט, בוחרים באפשרות Nodes.

  8. בקטע Machine configuration, לוחצים על GPU.

  9. בוחרים סוג GPU ומספר GPUs להפעלה בכל צומת.

  10. קוראים את האזהרה ולוחצים על ההגבלות ברורות לי.

  11. בקטע GPU Driver installation, בוחרים אחת מהשיטות הבאות:

    • בניהול Google: GKE מתקין את הדרייבר באופן אוטומטי. אם בוחרים באפשרות הזו, צריך לבחור אחת מהאפשרויות הבאות בתפריט הנפתח Version:
      • ברירת מחדל: התקנה של גרסת ברירת המחדל של מנהל ההתקן.
      • הגרסה האחרונה: התקנת הגרסה האחרונה של מנהל ההתקן.
    • בניהול הלקוח: GKE לא מתקין מנהל התקן. חובה להתקין באופן ידני מנהל התקן תואם, לפי ההוראות במאמר התקנת מנהלי התקנים של NVIDIA GPU.

  12. לוחצים על יצירה.

Terraform

אתם יכולים ליצור אשכול אזורי עם Terraform עם מעבדי GPU באמצעות מודול Terraform.

  1. מגדירים את המשתנים של Terraform על ידי הוספת הבלוק הבא לקובץ variables.tf:

    variable "project_id" {
  default     = PROJECT_ID
  description = "the gcp_name_short project where GKE creates the cluster"
}

variable "region" {
  default     = CLUSTER_REGION
  description = "the gcp_name_short region where GKE creates the cluster"
}

variable "zone" {
  default     = "COMPUTE_ZONE"
  description = "the GPU nodes zone"
}

variable "cluster_name" {
  default     = "CLUSTER_NAME"
  description = "the name of the cluster"
}

variable "gpu_type" {
  default     = "GPU_TYPE"
  description = "the GPU accelerator type"
}

variable "gpu_driver_version" {
  default = "DRIVER_VERSION"
  description = "the NVIDIA driver version to install"
}

variable "machine_type" {
  default = "MACHINE_TYPE"
  description = "The Compute Engine machine type for the VM"
}

    מחליפים את מה שכתוב בשדות הבאים:

    • PROJECT_ID: מזהה הפרויקט.
    • ‫CLUSTER_NAME: השם של אשכול GKE.
    • ‫CLUSTER_REGION: אזור המחשוב של האשכול.
    • ‫COMPUTE_ZONE: האזור הספציפי שבו GKE יוצר את צומתי ה-GPU. האזור חייב להיות באותו אזור שצוין במשתנה region. באזורים האלה צריכים להיות זמינים סוגי ה-GPU שהגדרתם. מידע נוסף מופיע במאמר זמינות של GPUs לפי אזורים ותחומים.
    • ‫GPU_TYPE: סוג מאיץ ה-GPU שבו אתם משתמשים. לדוגמה, nvidia-tesla-t4.

    • ‫DRIVER_VERSION: גרסת מנהל ההתקן של ה-GPU ש-GKE יתקין באופן אוטומטי. השדה הזה הוא אופציונלי. אלה הערכים הנתמכים:

      • ‫INSTALLATION_DISABLED: השבתת ההתקנה האוטומטית של מנהל ההתקן של ה-GPU. חובה להתקין ידנית מנהלי התקנים כדי להפעיל את ה-GPU. בגרסאות GKE שקודמות ל-1.30.1-gke.1156000, זו אפשרות ברירת המחדל אם משמיטים את השדה הזה.
      • ‫DEFAULT: התקנה אוטומטית של גרסת ברירת המחדל של מנהל ההתקן, בהתאם לגרסת מערכת ההפעלה של הצומת. בגרסה 1.30.1-gke.1156000 ואילך של GKE, אם משמיטים את השדה הזה, זו אפשרות ברירת המחדל. בגרסאות קודמות, אם משמיטים את השדה הזה, GKE לא מתקין מנהל התקן.
      • ‫LATEST: התקנה אוטומטית של גרסת הדרייבר העדכנית ביותר שזמינה לגרסת מערכת ההפעלה של הצומת. זמין רק לצמתים שמשתמשים במערכת הפעלה שמותאמת לקונטיינרים.

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

    • MACHINE_TYPE: סוג המכונה של Compute Engine לצמתים. נדרש לסוגי ה-GPU הבאים:

      • מעבדי GPU מסוג NVIDIA B200 (תואמים לסוג המאיץ nvidia-b200 ולסדרת המכונות A4)
      • מעבדי NVIDIA H200 141GB GPU (תואמים לסוג המאיץ nvidia-h200-141gb ולסוג המכונה A3 Ultra), מעבדי NVIDIA H100 80GB GPU (תואמים לסוג המאיץ nvidia-h100-80gb ולסוג המכונה A3 High) או מעבדי NVIDIA H100 80GB Mega GPU (תואמים לסוג המאיץ nvidia-h100-mega-80gb ולסוג המכונה A3 Mega). למידע נוסף, קראו על סדרת המכונות A3 במאמרי העזרה של Compute Engine.
      • מעבדי NVIDIA A100 40GB GPU (תואמים לסוג המאיץ nvidia-tesla-a100 ולסוג המכונה A2 Standard), או מעבדי NVIDIA A100 80GB GPU (תואמים לסוג המאיץ nvidia-a100-80gb ולסוג המכונה A2 Ultra). למידע נוסף, קראו את המאמר סדרת המכונות A2 במאמרי העזרה של Compute Engine.
      • מעבדי GPU מסוג NVIDIA L4 (תואמים לסוג המאיץ nvidia-l4 ולסדרת המכונות G2).
      • מעבדי GPU מסוג NVIDIA RTX PRO 6000 (שתואמים לסוג המאיץ nvidia-rtx-pro-6000 ולסדרת המכונות G4).

      לכל שאר ה-GPU, הדגל הזה הוא אופציונלי.

  2. מוסיפים את הבלוק הבא להגדרות ב-Terraform:

    provider "google" {
  project = var.project_id
  region  = var.region
}

resource "google_container_cluster" "ml_cluster" {
  name               = var.cluster_name
  location           = var.region
  initial_node_count = 1
}

resource "google_container_node_pool" "gpu_pool" {
  name           = google_container_cluster.ml_cluster.name
  location       = var.region
  node_locations = [var.zones]
  cluster        = google_container_cluster.ml_cluster.name
  node_count     = 3

  autoscaling {
    total_min_node_count = "1"
    total_max_node_count = "5"
  }

  management {
    auto_repair  = "true"
    auto_upgrade = "true"
  }

  node_config {
    oauth_scopes = [
      "https://www.googleapis.com/auth/logging.write",
      "https://www.googleapis.com/auth/monitoring",
      "https://www.googleapis.com/auth/devstorage.read_only",
      "https://www.googleapis.com/auth/trace.append",
      "https://www.googleapis.com/auth/service.management.readonly",
      "https://www.googleapis.com/auth/servicecontrol",
    ]

    labels = {
      env = var.project_id
    }

    guest_accelerator {
      type  = var.gpu_type
      count = 1
      gpu_driver_installation_config {
        gpu_driver_version = var.gpu_driver_version
      }
    }

    image_type   = "cos_containerd"
    machine_type = var.machine_type
    tags         = ["gke-node", "${var.project_id}-gke"]

    disk_size_gb = "30"
    disk_type    = "pd-standard"

    metadata = {
      disable-legacy-endpoints = "true"
    }
  }
}

תישלח מ-Terraform בקשה ל- Google Cloud APIs ליצירת אשכול חדש עם מאגר צמתים שמשתמש ב-GPUs. במאגר הצמתים יש בהתחלה שלושה צמתים, וההתאמה האוטומטית לעומס מופעלת. למידע נוסף על Terraform, קראו את מפרט המשאבים של google_container_node_pool באתר terraform.io.

שיטה מומלצת:

כדי להימנע מעלויות נוספות, צריך להסיר את כל המשאבים שהוגדרו בקובץ התצורה באמצעות הפקודה terraform destroy.

שיטה מומלצת: אתם יכולים גם ליצור אשכול חדש עם מעבדי GPU ולציין אזורים באמצעות הדגל --node-locations. עם זאת, מומלץ ליצור מאגר צמתים נפרד של GPU באשכול קיים, כמו שמוצג בקטע הזה.

התקנה ידנית של מנהלי התקנים של NVIDIA GPU

כדי להתקין באופן ידני מנהלי התקנים של NVIDIA GPU בצמתים, אפשר לפרוס DaemonSet של התקנה בצמתים האלה. כדאי להשתמש בהתקנה ידנית במקרים הבאים:

  • בחרתם להשבית את ההתקנה האוטומטית של מנהלי ההתקנים כשאתם יוצרים מאגר צומתי GPU.
  • אתם משתמשים בגרסת GKE שמוקדמת מהגרסה המינימלית שנתמכת להתקנה אוטומטית.
  • עומס העבודה שלכם דורש גרסה ספציפית של מנהל התקן של NVIDIA שלא זמינה כמנהל ההתקן שמוגדר כברירת מחדל או כמנהל ההתקן העדכני ביותר עם התקנה אוטומטית. לדוגמה, שימוש ב-GPU עם Confidential GKE Nodes.
שיטה מומלצת:

השתמשו בהתקנה אוטומטית של מנהלי התקנים כשאפשר. כדי לעשות את זה, מציינים את האפשרות gpu-driver-version בדגל --accelerator כשיוצרים את האשכול הרגיל. אם השתמשתם ב-DaemonSet להתקנה ידנית של מנהלי התקנים של GPU ב-25 בינואר 2023 או לפני כן, יכול להיות שתצטרכו להחיל מחדש את ה-DaemonSet כדי לקבל גרסה שמתעלמת מצמתים שמשתמשים בהתקנה אוטומטית של מנהלי התקנים.

כדי להריץ את DaemonSet להתקנה, מאגר הצמתים של ה-GPU דורש את ההיקף https://www.googleapis.com/auth/devstorage.read_only לתקשורת עם Cloud Storage. בלי ההיקף הזה, ההורדה של מניפסט DaemonSet להתקנה תיכשל. ההיקף הזה הוא אחד מהיקפי ההרשאות שמוגדרים כברירת מחדל, ובדרך כלל הוא מתווסף כשיוצרים את האשכול.

בהוראות הבאות מוסבר איך להתקין את הדרייברים בצומתי מערכת הפעלה שמותאמת לקונטיינרים (COS) ו-Ubuntu, ואיך להשתמש ב-Terraform.

COS

  • כדי לפרוס את ההתקנה של DaemonSet ולהתקין את גרסת ברירת המחדל של מנהל ההתקן של ה-GPU, מריצים את הפקודה הבאה:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

  • כדי להתקין גרסה חדשה יותר של מנהל התקן GPU מטבלת גרסאות מנהלי ההתקנים שבקטע הזה, מריצים את הפקודה הבאה:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded-latest.yaml

  • כדי להתקין גרסה של מנהל התקן GPU שתומכת בהפעלה של עומסי עבודה ב-GPU בצומתי GKE חסויים, מריצים את הפקודה הבאה:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/nvidia-driver-installer/cos/daemonset-confidential.yaml

ההתקנה נמשכת כמה שניות. בסיום ההתקנה, הפלאגין של מכשיר ה-GPU של NVIDIA משתמש ב-Kubernetes API כדי להפוך את הקיבולת של ה-GPU של NVIDIA לזמינה.

לכל גרסה של מערכת הפעלה שמותאמת לקונטיינרים יש לפחות גרסה אחת נתמכת של מנהל התקן ל-GPU של NVIDIA. כדי לקבל מידע נוסף על מיפוי גרסת מנהל ההתקן של ה-GPU לגרסת GKE, אתם יכולים:

גרסאות הדרייברים של NVIDIA ב-GKE
1.33 ‫R535 (ברירת מחדל), R570,‏ R575 או R580
1.32 ‫R535 (ברירת מחדל), R570,‏ R575 או R580
1.31 ‫R535 (ברירת מחדל), R570,‏ R575 או R580
1.30 ‫R535 (ברירת מחדל) או R550
1.29 ‫R535 (ברירת מחדל) או R550
1.28 ‫R535 (ברירת מחדל) או R550
1.27 ‫R470 (ברירת מחדל),‏ R525,‏ R535 או R550
1.26 ‫R470 (ברירת מחדל),‏ R525,‏ R535 או R550

Ubuntu

ה-DaemonSet להתקנה שפורסים תלוי בסוג ה-GPU ובגרסת הצומת ב-GKE, באופן הבא:

  • לכל ה-GPU חוץ מ-NVIDIA H200, מריצים את הפקודה הבאה:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/ubuntu/daemonset-preloaded.yaml

  • למעבדי NVIDIA H200 GPU, מתקינים את הדרייבר R550:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/nvidia-driver-installer/ubuntu/daemonset-preloaded-R550.yaml

ההתקנה נמשכת כמה שניות. אחרי ההתקנה, הפלאגין של מכשיר ה-GPU של NVIDIA משתמש ב-Kubernetes API כדי להפוך את הקיבולת של ה-GPU של NVIDIA לזמינה.

בטבלה הבאה מפורטות גרסאות הדרייבר שזמינות בכל גרסה של GKE:

מנהלי התקנים של GPU ב-Ubuntu וגרסאות GKE
1.33 R535 (ברירת מחדל)
1.32 R535 (ברירת מחדל)
1.31 R535 (ברירת מחדל)
1.30 R470 או R535
1.29 R470 או R535
1.28 R470 או R535
1.27 R470 או R535
1.26 R470 או R535

Terraform

אתם יכולים להשתמש ב-Terraform כדי להתקין את גרסת ברירת המחדל של מנהל ההתקן של ה-GPU, בהתאם לסוג הצמתים. בשני המקרים, צריך להגדיר את סוג המשאב kubectl_manifest של Terraform.

  • כדי להתקין את DaemonSet ב-COS, מוסיפים את הבלוק הבא להגדרות ב-Terraform:

      data "http" "nvidia_driver_installer_manifest" {
    url = "https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml"
  }

  resource "kubectl_manifest" "nvidia_driver_installer" {
    yaml_body = data.http.nvidia_driver_installer_manifest.body
  }

  • כדי להתקין את DaemonSet ב-Ubuntu, מוסיפים את הבלוק הבא להגדרות ב-Terraform:

      data "http" "nvidia_driver_installer_manifest" {
    url = "https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/ubuntu/daemonset-preloaded.yaml"
  }

  resource "kubectl_manifest" "nvidia_driver_installer" {
    yaml_body = data.http.nvidia_driver_installer_manifest.body
  }

מיפוי גרסת GKE וגרסת תמונת הצומת של מערכת ההפעלה שמותאמת לקונטיינרים לגרסת מנהל ההתקן של ה-GPU

כדי למצוא את גרסאות מנהלי ההתקנים של ה-GPU שממופות לגרסאות GKE ולגרסאות של קובצי אימג' של צומתי מערכת הפעלה שמותאמת לקונטיינרים, מבצעים את הפעולות הבאות:
  1. ממפים את גרסאות קובצי האימג' של צומת מערכת ההפעלה שמותאמת לקונטיינרים לגרסאות התיקונים של GKE, בהתאם לגרסת ה-GKE הספציפית שבה רוצים למצוא את גרסת מנהל ההתקן של ה-GPU. לדוגמה, בגרסה 1.33.0-gke.1552000 נעשה שימוש ב-cos-121-18867-90-4.
  2. בוחרים את אבן הדרך של גרסת קובץ האימג' של הצומת של מערכת ההפעלה שמותאמת לקונטיינרים בנתוני הגרסה של מערכת ההפעלה שמותאמת לקונטיינרים. לדוגמה, בוחרים בגרסה Milestone 121 עבור cos-121-18867-90-4.
  3. בדף של נתוני הגרסה של אבן הדרך הספציפית, מחפשים את נתוני הגרסה שתואמים לגרסה הספציפית של קובץ האימג' של הצומת של מערכת ההפעלה שמותאמת לקונטיינרים. לדוגמה, בנתוני הגרסה של מערכת הפעלה שמותאמת לקונטיינרים: אבן דרך 121, ראו cos-121-18867-90-4. בטבלה, בעמודה מנהלי התקנים של GPU, לוחצים על הצגת הרשימה כדי לראות את פרטי הגרסה של מנהל ההתקן של ה-GPU.

בגרסה 1.36.0-gke.3302004 ואילך של GKE, גרסת מנהל ההתקן של NVIDIA שמותקנת מתפרסמת באופן אוטומטי כהערות בצומתי GPU שפועלים. כדי להציג את ההערות של גרסת מנהל ההתקן בצומת GPU, מריצים את הפקודה הבאה:

kubectl get node GPU_NODE_NAME -o jsonpath='{.metadata.annotations}'

מחליפים את GPU_NODE_NAME בשם של צומת ה-GPU.

הפלט כולל הערות דומות לאלה:

{
  "cloud.google.com/cuda.driver-version.full": "580.126.20",
  "cloud.google.com/cuda.driver-version.major": "580",
  "cloud.google.com/cuda.driver-version.minor": "126",
  "cloud.google.com/cuda.driver-version.revision": "20"
}

התקנת מנהלי התקנים באמצעות הקצאת צמתים אוטומטית (NAP) עם מעבדי GPU

כשמשתמשים בהקצאת צמתים אוטומטית עם יחידות GPU, כברירת מחדל למאגרי הצמתים שהוקצו באופן אוטומטי אין מספיק היקפי הרשאות כדי להתקין את מנהלי ההתקנים. כדי להעניק את ההיקפים הנדרשים, משנים את היקפי ברירת המחדל להקצאת צמתים אוטומטית ומוסיפים את logging.write,‏ monitoring,‏ devstorage.read_only ו-compute, כמו בדוגמה הבאה.

gcloud container clusters update CLUSTER_NAME --enable-autoprovisioning \
    --min-cpu=1 --max-cpu=10 --min-memory=1 --max-memory=32 \
    --autoprovisioning-scopes=https://www.googleapis.com/auth/logging.write,https://www.googleapis.com/auth/monitoring,https://www.googleapis.com/auth/devstorage.read_only,https://www.googleapis.com/auth/compute

באשכולות שבהם פועלת גרסת GKE‏ 1.32.2-gke.1297000 ואילך, GKE מתקין באופן אוטומטי את גרסת ברירת המחדל של מנהל ההתקן של NVIDIA לכל צומתי ה-GPU, כולל אלה שנוצרו באמצעות הקצאת צמתים אוטומטית. אתם יכולים לדלג על ההוראות הבאות באשכולות שבהם פועלת גרסת GKE‏ 1.32.2-gke.1297000 ואילך.

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

spec:
  nodeSelector:
    cloud.google.com/gke-gpu-driver-version: "DRIVER_VERSION"

מחליפים את DRIVER_VERSION באחד מהערכים הבאים:

  • ‫default: מנהל ההתקן היציב שמוגדר כברירת מחדל לגרסת GKE של הצומת.
  • ‫latest: גרסת הדרייבר העדכנית ביותר שזמינה לגרסת ה-GKE של הצומת.
  • ‫disabled: השבתת ההתקנה האוטומטית של מנהל ההתקן של ה-GPU. אם בוחרים בערך הזה, צריך להתקין באופן ידני מנהלי התקנים כדי להריץ את ה-GPU. בגרסאות GKE שקודמות ל-1.32.2-gke.1297000, זו אפשרות ברירת המחדל אם משמיטים את בורר הצמתים.

איך משתמשים בהקצאת צמתים אוטומטית (NAP)

הגדרת Pods לצריכת GPU

כדי להגדיר Pods לצריכת GPUs, משתמשים במגבלת משאבים. מגדירים מגבלת משאבים במפרט Pod באמצעות צמד המפתח/ערך הבא:

  • מפתח: nvidia.com/gpu
  • ערך: מספר יחידות ה-GPU שרוצים להשתמש בהן

אי אפשר להשתמש ב-alpha.kubernetes.io/nvidia-gpu כשם של משאב ב-GKE. במקום זאת, צריך להשתמש ב-nvidia.com/gpu בתור שם המשאב.

המניפסט הבא הוא דוגמה למפרט של Pod שמשתמש במעבדי GPU:

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  # Optional: Use GKE Sandbox
  # runtimeClassName: gvisor
  containers:
  - name: my-gpu-container
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
       nvidia.com/gpu: 2

שימוש בכמה סוגי GPU

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

  • מפתח: cloud.google.com/gke-accelerator
  • ערך: סוג מאיץ ה-GPU שבו אתם משתמשים. לדוגמה, nvidia-tesla-t4.

כדי לטרגט סוגים מסוימים של GPU, אפשר להוסיף את בורר הצמתים הזה למפרט ה-Pod של עומס העבודה. לדוגמה:

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  containers:
  - name: my-gpu-container
    image: nvidia/cuda:11.0.3-runtime-ubuntu20.04
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
       nvidia.com/gpu: 2
  nodeSelector:
    cloud.google.com/gke-accelerator: nvidia-tesla-t4

שדרוג מאגרי צמתים באמצעות מאיצים (GPU ו-TPU)

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

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

כשמשתמשים באסטרטגיית שדרוג של צומת, GKE צריך להקצות באופן זמני משאבים נוספים, בהתאם להגדרות האישיות. אם הקיבולת של Google Cloudלמשאבים של מאגר הצמתים מוגבלת – לדוגמה, אם מופיעות שגיאות של זמינות משאבים כשמנסים ליצור עוד צמתים עם GPUs או TPUs – קראו את המאמר שדרוג בסביבה עם משאבים מוגבלים.

מידע על ספריות NVIDIA CUDA-X

‫CUDA היא פלטפורמת המחשוב המקבילי ומודל התכנות של NVIDIA למעבדי GPU. כדי להשתמש באפליקציות CUDA, צריך להשתמש בתמונה שכוללת את הספריות. כדי להוסיף את הספריות של NVIDIA CUDA-X, אתם יכולים ליצור קובץ אימג' משלכם ולהשתמש בו. לשם כך, צריך לכלול את הערכים הבאים במשתנה הסביבה LD_LIBRARY_PATH במפרט של הקונטיינר:

  • ‫/usr/local/nvidia/lib64: המיקום של מנהלי ההתקנים של NVIDIA.
  • ‫/usr/local/cuda-CUDA_VERSION/lib64: המיקום של ספריות NVIDIA CUDA-X בצומת.

    מחליפים את CUDA_VERSION בגרסת האימג' של CUDA-X שבה השתמשתם. בחלק מהגרסאות יש גם כלי ניפוי באגים ב-/usr/local/nvidia/bin. פרטים נוספים זמינים בתמונת NVIDIA CUDA ב-DockerHub.

    כדי לבדוק מהי הגרסה המינימלית של מנהל ההתקן של ה-GPU שנדרשת לגרסת ה-CUDA שלכם, עיינו במאמר CUDA Toolkit and Compatible Driver Versions.

חשוב לוודא שגרסת התיקון של GKE שפועלת בצמתים כוללת גרסה של מנהל התקן GPU שתואמת לגרסת CUDA שבחרתם. למידע נוסף על מיפוי גרסת מנהל ההתקן של ה-GPU לגרסת GKE, ראו מיפוי גרסת GKE וגרסת קובץ האימג' של צומת מערכת ההפעלה שמותאמת לקונטיינרים לגרסת מנהל ההתקן של ה-GPU.

מעקב אחרי הביצועים של עומס העבודה בצומת GPU

אם באשכול GKE מופעלים מדדי מערכת, המדדים הבאים זמינים ב-Cloud Monitoring כדי לעקוב אחרי הביצועים של עומסי העבודה ב-GPU:

  • מחזור פעילות (container/accelerator/duty_cycle): אחוז הזמן בתקופת הדגימה האחרונה (10 שניות) שבה המאיץ עיבד באופן פעיל. בין 1 ל-100.
  • ‫Memory Usage (container/accelerator/memory_used): כמות הזיכרון של המאיץ שהוקצתה, בבייטים.
  • ‫Memory Capacity (container/accelerator/memory_total): נפח הזיכרון הכולל של המאיץ, בבייטים.

המדדים האלה חלים ברמת הקונטיינר (container/accelerator) ולא נאספים בקונטיינרים שתוזמנו ב-GPU שמשתמש בשיתוף זמן של GPU או ב-NVIDIA MPS.

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

הצגת מדדי השימוש של עומסי עבודה

אתם יכולים לראות את מדדי השימוש ב-GPU של עומס העבודה במרכז הבקרה Workloads במסוף Google Cloud .

כדי לראות את השימוש ב-GPU של עומס העבודה:

  1. נכנסים לדף Workloads במסוף Google Cloud .

    כניסה לדף Workloads
  2. בוחרים עומס עבודה.

בלוח הבקרה Workloads מוצגים תרשימים של השימוש בזיכרון ה-GPU, הקיבולת של זיכרון ה-GPU ומחזור העבודה של ה-GPU.

הצגת מדדים של NVIDIA Data Center GPU Manager ‏(DCGM)

אתם יכולים לאסוף מדדי NVIDIA DCGM ולהציג אותם באמצעות השירות המנוהל של Google Cloud ל-Prometheus. באשכולות Autopilot, ‏ GKE מתקין את מנהלי ההתקנים. באשכולות רגילים, צריך להתקין את מנהלי ההתקנים של NVIDIA.

הוראות לפריסת חבילת DCGM שמנוהלת על ידי GKE מפורטות במאמר איסוף והצגה של מדדי NVIDIA Data Center GPU Manager (DCGM)‎.

מדדי תקינות של JobSet וצמתים לעומסי עבודה ב-GPU

בנוסף למדדי DCGM, אתם יכולים להשתמש במדדים הבאים כדי לעקוב אחרי התקינות והביצועים של עומסי העבודה ב-GPU, במיוחד כשמריצים אותם כ-JobSets.

מדדי JobSet

המדדים הבאים רלוונטיים גם ל-JobSets של GPU וגם ל-JobSets של TPU עם Job משוכפל אחד:

  • kubernetes.io/jobset/times_between_interruptions
  • kubernetes.io/jobset/times_to_recover
  • kubernetes.io/jobset/uptime

למידע נוסף על מדדי המערכת האלה, ראו מדדי Kubernetes.

אפשר גם להשתמש בלוח הבקרה של JobSet במסוף Google Cloud כדי להציג ולנטר את עומסי העבודה ב-GPU:

מעבר אל Deployments

מדדי תקינות של צמתים

המדדים הבאים ברמת הצומת רלוונטיים לכל הצמתים, כולל אלה עם מעבדים גרפיים:

  • ‫kubernetes.io/node/status_condition: המדד הזה דורש את גרסה 1.32.1-gke.1357001 ומעלה של GKE.

המדדים של הפסקות בצמתים ובמאגרי צמתים חלים גם על צמתים שהם לא TPU.

‫Kube-state-metrics ל-JobSets

אפשר להשתמש ב-kube-state-metrics של JobSets עם GPUs. כדי לאסוף את המדדים האלה, צריך להשתמש ב-GKE מגרסה 1.32.1-gke.1357001 ואילך. מידע נוסף זמין במאמרי העזרה בנושא מדדי JobSet.

הכנת עומסי עבודה לסוגי מכונות G4 עם פחות מ-GPU אחד

כדי להריץ עומסי עבודה עם CUDA במכונות מסוג G4 עם פחות מ-GPU אחד, באשכולות שבהם פועלות גרסאות GKE שקודמות ל-1.36, צריך לפרוס את מזרק המכשירים של NRI בתור DaemonSet ולהוסיף הערות למאגרים. כך פורסים את ה-DaemonSet ומגדירים את הפודים:

  1. יוצרים את ה-DaemonSet:

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/nri_device_injector/nri-device-injector.yaml

  2. מוסיפים את ההערה הבאה למפרט של ה-Pod:

    devices.gke.io/container.CONTAINER_NAME:
  - path: /dev/nvidia-caps/nvidia-cap1
  - path: /dev/nvidia-caps/nvidia-cap2
  - path: /dev/nvidia-caps/nvidia-cap3
  - path: /dev/nvidia-caps/nvidia-cap4

    מחליפים את CONTAINER_NAME בשם של הקונטיינר של ה-Pod.

הגדרת סגירה מבוקרת של צומתי GPU

באשכולות GKE שבהם מישור הבקרה מריץ את גרסה ‎1.29.1-gke.1425000 ואילך, צומתי GPU תומכים באותות SIGTERM שמתריעים לצומת על השבתה קרובה. בצומתי GPU, אפשר להגדיר את ההתראה על השבתה קרובה עד 60 דקות.

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

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