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

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

אם רוצים לפרוס אשכולות עם מעבדי GPU של NVIDIA B200 או NVIDIA H200 בנפח 141GB, אפשר לעיין במשאבים הבאים:

סקירה כללית

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

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

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

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

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

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

  • מפעילים את ממשק Google Kubernetes Engine API.
    • הפעלת Google Kubernetes Engine API
  • אם רוצים להשתמש ב-CLI של Google Cloud למשימה הזו, צריך להתקין ואז להפעיל את ה-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 שבחרתם.

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

    • תאימות לדרייבר:

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

      • ‫H200 GPUs: NVIDIA driver version 550 or later

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

      • יחידות GPU מסוג RTX PRO 6000: דרייבר NVIDIA בגרסה 580 ואילך

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

    • תאימות גרסאות:

      כשמשתמשים בסדרת מכונות 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 כדי למנוע תזמון לא מתאים

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

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

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

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

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

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

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

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

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

  • ‫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‏ 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.
    • מעבדי GPU‏ NVIDIA A100 40 GB (שמתאימים לסוג המאיץ nvidia-tesla-a100 ולסוג המכונה A2 Standard), או מעבדי GPU‏ NVIDIA A100 80GB (שמתאימים לסוג המאיץ nvidia-a100-80gb ולסוג המכונה A2 Ultra). מידע נוסף זמין במאמר סדרת מכונות A2 במסמכי התיעוד של Compute Engine.
    • ‫NVIDIA L4 GPUs (מתאים לסוג המאיץ 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 מהזמנה ספציפית. מידע נוסף זמין במאמר בנושא שימוש בהזמנה ספציפית לפרויקט יחיד.

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

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

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

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

המסוף

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

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

    מעבר אל Google Kubernetes Engine

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

  3. לוחצים על הוספת מאגר צמתים.

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

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

  6. בחלונית הניווט, בוחרים באפשרות צמתים.

  7. בקטע Machine configuration (הגדרת המכונה), לוחצים על GPU (מעבד גרפי).

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

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

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

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

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

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 שהגדרתם. מידע נוסף זמין במאמר זמינות של GPU לפי אזורים ותחומים.
    • ‫GPU_TYPE: הסוג של מאיץ ה-GPU שבו אתם משתמשים. לדוגמה, nvidia-tesla-t4.

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

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

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

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

      • ‫GPU מסוג NVIDIA B200 (מתאים לסוג המאיץ 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.
      • מעבדי GPU‏ NVIDIA A100 40 GB (שמתאימים לסוג המאיץ nvidia-tesla-a100 ולסוג המכונה A2 Standard) או מעבדי GPU‏ NVIDIA A100 80GB (שמתאימים לסוג המאיץ nvidia-a100-80gb ולסוג המכונה A2 Ultra). מידע נוסף זמין במאמר סדרת מכונות A2 במסמכי התיעוד של Compute Engine.
      • ‫NVIDIA L4 GPUs (מתאים לסוג המאיץ 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 בקשה ל-APIs כדי ליצור אשכול חדש עם מאגר צמתים שמשתמשים ב-GPU. Google Cloud במאגר הצמתים יש בהתחלה שלושה צמתים, והסקלביליות האוטומטית מופעלת. מידע נוסף על 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 כשיוצרים את אשכול 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

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

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

    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.

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

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

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

משתמשים במגבלת משאבים כדי להגדיר ל-Pods צריכת GPU. מגדירים מגבלת משאבים במפרט של 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 מצרף node selector ייחודי לצמתי 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יש קיבולת מוגבלת למשאבים של מאגר הצמתים – לדוגמה, אם אתם רואים שגיאות של זמינות משאבים כשאתם מנסים ליצור עוד צמתים עם 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): כמות הזיכרון של המאיץ שהוקצתה בבייטים.
  • נפח הזיכרון (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 והקיבולת שלו, ושל דיוטי סייקל (Duty cycle) ב-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

המדדים הבאים חלים על מערכי משימות של GPU ו-TPU שיש להם משימה אחת משוכפלת:

  • 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 עם יחידות GPU. כדי לאסוף את המדדים האלה, צריך להשתמש ב-GKE בגרסה 1.32.1-gke.1357001 ואילך. מידע נוסף זמין במסמכי התיעוד בנושא מדדי JobSet.

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

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

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

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