הפעלת יחידות 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 זמין בדף יחידות GPU של Google Cloud. מידע נוסף על מעבדי GPU ב-GKE ועל ההבדלים בין מצב רגיל למצב אוטומטי זמין במאמר בנושא מעבדי GPU ב-GKE.

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

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

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

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

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

הדרישות לגבי יחידות GPU ב-GKE

הדרישות לשימוש ב-GPU ב-GKE הן:

  • מכסת GPU: כדי ליצור צמתי GPU, צריך לוודא שיש לכם מכסת GPU ב-Compute Engine באזור שבחרתם. כדי לוודא שיש לכם מספיק מכסת GPU בפרויקט, אפשר לעיין במאמר בנושא מכסות במסוף 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:

      • ‫L4 GPUs ו-H100 GPUs: דרייבר NVIDIA בגרסה 535 ואילך

      • מעבדי H200 GPU: דרייבר NVIDIA בגרסה 550 ואילך

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

      • מעבדי GPU מסוג RTX PRO 6000: גרסה 580 ומעלה של מנהל ההתקן של NVIDIA. התאימות של הגרסה הזו לא כוללת סוגי מכונות 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, חשוב לזכור את המגבלות הבאות:

זמינות של מעבדי GPU לפי אזורים ואזורי זמינות

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

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

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

gcloud compute accelerator-types list

תמחור

למידע על תמחור של יחידות GPU, אפשר לעיין בטבלת התמחור בדף של Google Cloud יחידות GPU.

מוודאים שיש מספיק מכסת GPU

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

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

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

בקשת מכסת 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. ממלאים את השדה תיאור הבקשה בפרטים לגבי הבקשה.

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

  8. בתיבת הדו-שיח Override confirmation, לוחצים על Confirm.

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

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

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

הפעלת יחידות GPU באשכולות GKE Standard

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

שיטה מומלצת:

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

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

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

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

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

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

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

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

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

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

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

הגבלת התזמון באופן אוטומטי באמצעות סבילות

התכונה Tolerations מאפשרת להגדיר פודים שאפשר להשתמש בהם בצמתים מסוג tainted. ‫GKE מחיל אוטומטית סבילות, כך שרק פודים שמבקשים GPU מתוזמנים בצמתי 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

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

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 (GPU אחד)

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

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

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

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

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

    • מעבדי NVIDIA B200 GPU (שמתאימים לסוג המאיץ nvidia-b200 ולסדרת המכונות A4)
    • מעבדי GPU מסוג NVIDIA H200 141GB (תואמים לסוג המאיץ nvidia-h200-141gb ולסוג המכונה A3 Ultra), מעבדי GPU מסוג NVIDIA H100 80GB (תואמים לסוג המאיץ nvidia-h100-80gb ולסוג המכונה A3 High) או מעבדי GPU מסוג NVIDIA H100 80GB Mega (תואמים לסוג המאיץ nvidia-h100-mega-80gb ולסוג המכונה A3 Mega). למידע נוסף, אפשר לקרוא את המאמר סדרת המכונות A3 במסמכי התיעוד של Compute Engine.
    • מעבדי NVIDIA A100 40 GB 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).

    לכל שאר המעבדים הגרפיים, הדגל הזה הוא אופציונלי.

  • ‫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. בחלונית הניווט, בוחרים באפשרות צמתים.

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

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

  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 הבאים:

      • מעבדי NVIDIA B200 GPU (שמתאימים לסוג המאיץ nvidia-b200 ולסדרת המכונות A4)
      • מעבדי GPU‏ NVIDIA H200‏ 141 GB (שמתאימים לסוג המאיץ nvidia-h200-141gb ולסוג המכונה A3 Ultra), או מעבדי GPU‏ NVIDIA H100‏ 80 GB (שמתאימים לסוג המאיץ nvidia-h100-80gb ולסוג המכונה A3 High), או מעבדי GPU‏ NVIDIA H100‏ 80GB Mega (שמתאימים לסוג המאיץ 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.
      • מעבדי NVIDIA L4 GPU (שמתאימים לסוג המאיץ nvidia-l4 ולסדרת המכונות G2).
      • מעבדי GPU מסוג NVIDIA RTX PRO 6000 (שמתאימים nvidia-rtx-pro-6000 לסוג המאיץ ולסדרת המכונות G4).

      לכל שאר המעבדים הגרפיים, הדגל הזה הוא אופציונלי.

  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 כדי ליצור אשכול חדש עם מאגר צמתים שמשתמש ב-GPU. במאגר הצמתים יש בהתחלה שלושה צמתים, והוא מוגדר עם שינוי גודל אוטומטי. מידע נוסף על Terraform זמין בgoogle_container_node_pool resource spec ב-terraform.io.

שיטה מומלצת:

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

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

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

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

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

מומלץ להשתמש בהתקנה אוטומטית של דרייברים ככל האפשר. כדי לעשות את זה, מציינים את האפשרות gpu-driver-version בדגל --accelerator כשיוצרים את אשכול Standard. אם השתמשתם ב-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

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

לכל גרסה של מערכת הפעלה שמותאמת לקונטיינרים יש לפחות גרסה אחת נתמכת של מנהל התקן של NVIDIA GPU. כדי לקבל מידע נוסף על מיפוי של גרסת מנהל ההתקן של ה-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 GPU, מריצים את הפקודה הבאה:

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

  • עבור יחידות GPU מסוג NVIDIA H200, מתקינים את הדרייבר 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. בוחרים את אבן הדרך של גרסת קובץ האימג' של הצומת של מערכת ההפעלה שמותאמת לקונטיינרים בהערות לגבי הגרסה של מערכת ההפעלה שמותאמת לקונטיינרים. לדוגמה, בוחרים באבן דרך 121 עבור cos-121-18867-90-4.
  3. בדף הערות הגרסה של אבן הדרך הספציפית, מאתרים את הערת הגרסה שמתאימה לגרסה הספציפית של תמונת הצומת של מערכת ההפעלה שמותאמת לקונטיינרים. לדוגמה, בהערות לגבי גרסה של מערכת הפעלה שמותאמת לקונטיינרים: אבן דרך 121, אפשר לראות את cos-121-18867-90-4. בטבלה בעמודה GPU Drivers, לוחצים על See List כדי לראות את פרטי הגרסה של מנהל ההתקן של ה-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 ואילך.

ב-GKE בגרסה 1.29.2-gke.1108000 ואילך, אפשר לבחור גרסה של מנהל התקן של 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, זוהי אפשרות ברירת המחדל אם משמיטים את בורר הצמתים.

מידע נוסף על הקצאת משאבים אוטומטית זמין במאמר שימוש בהקצאת משאבים אוטומטית של צמתים.

הגדרת Pods לשימוש ב-GPU

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

  • מקרא: nvidia.com/gpu
  • ‫Value: מספר יחידות ה-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
  • Value: סוג מאיץ ה-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יש קיבולת מוגבלת למשאבים של מאגר הצמתים – לדוגמה, אם מוצגות לכם שגיאות של זמינות משאבים כשאתם מנסים ליצור עוד צמתים עם GPU או TPU – כדאי לעיין במאמר שדרוג בסביבה עם משאבים מוגבלים.

מידע על ספריות 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.
  • שימוש בזיכרון (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.

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

אפשר לאסוף ולהציג חזותית מדדים של NVIDIA DCGM באמצעות השירות המנוהל של Google Cloud ל-Prometheus. באשכולות Autopilot, ‏ GKE מתקין את מנהלי ההתקנים. באשכולות Standard, צריך להתקין את מנהלי ההתקנים של 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

מדדי הבריאות של הצומת

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

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

מדדי ההפרעה לצומת וההפרעה למאגר הצמתים חלים גם על צמתים שאינם 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 device injector כ-DaemonSet ולהוסיף הערות (annotations) למאגרי התמונות (containers). כך פורסים את ה-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 של מעבדי GPU ו-TPU.

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