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

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

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

• כדי ליצור אשכולות GKE, אפשר לעיין במאמר יצירת אשכול Google Kubernetes Engine שעבר אופטימיזציה ל-AI עם הגדרת ברירת מחדל.
• כדי ליצור אשכולות Slurm, אפשר לעיין במאמרים הבאים:
  • יצירת אשכול Slurm מנוהל באופן מלא
  • יצירת אשכול Slurm בניהול עצמי.

סקירה כללית

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

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

  • סדרת מכונות A4X Max: מעבדים גרפיים GB300.
  • סדרת מכונות A4X: יחידות GPU מדגם GB200.
  • סדרת מכונות A4: יחידות GPU מדגם B200.
  • סדרת מכונות A3: יחידות GPU מדגם H200‏ (A3 Ultra) ויחידות GPU מדגם H100‏ (A3 Mega,‏ High,‏ Edge).
  • סדרת מכונות A2: מעבדי GPU מסוג A100.
  • סדרת מכונות G4: יחידות GPU מסוג RTX PRO 6000.
  • סדרת מכונות G2: מעבדי GPU מסוג L4.
  • סדרת מכונות N1: מעבדי GPU מסוג NVIDIA T4,‏ NVIDIA V100,‏ NVIDIA P100 או NVIDIA P4.

  צריך לוודא שיש לכם מספיק מכסה בפרויקט לסדרת המכונות שמתאימה לסוג ולכמות ה-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 GPU: דרייבר NVIDIA בגרסה 570 ואילך

    • מעבדים גרפיים (GPU) מסוג RTX PRO 6000: דרייבר NVIDIA בגרסה 580 ואילך. התאימות של הגרסה הזו לא כוללת מכונות מסוג G4 עם פחות ממעבד גרפי אחד, ��י הן לא תומכות בתמונות של צומתי 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 ב-GKE, חשוב להביא בחשבון את המגבלות הבאות:

• אי אפשר להוסיף יחידות GPU למאגרי צמתים קיימים.
• אי אפשר לבצע העברה פעילה של צמתי GPU במהלך אירועי תחזוקה.

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

  • סדרת מכונות A4X Max: מעבדים גרפיים GB300.
  • סדרת מכונות A4X: יחידות GPU מדגם GB200.
  • סדרת מכונות A4: יחידות GPU מדגם B200.
  • סדרת מכונות A3: יחידות GPU מדגם H200‏ (A3 Ultra) ויחידות GPU מדגם H100‏ (A3 Mega,‏ High,‏ Edge).
  • סדרת מכונות A2: מעבדים גרפיים מסוג A100.
  • סדרת מכונות G4: יחידות GPU מסוג RTX PRO 6000.
  • סדרת מכונות G2: מעבדי GPU מסוג L4.
  • סדרת מכונות N1: מעבדי GPU מסוג NVIDIA T4,‏ NVIDIA V100,‏ NVIDIA P100 או NVIDIA P4.

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

• אין תמיכה ב-GPU במאגרי צמתים של Windows Server.

• אשכולות GKE Standard שפועלים בגרסאות מוקדמות יותר מ-1.34.1-gke.1279000 לא תומכים בהקצאה אוטומטית של צמתים ליצירת מאגרי צמתים עם GPUs מסוג RTX PRO 6000. עם זאת, באשכולות שמופעלות בהם גרסאות קודמות יש תמיכה בשינוי הגודל של מאגרי צמתים קיימים באמצעות התאמה אוטומטית של גודל האשכול.

• אשכולות GKE Standard שמריצים גרסה 1.28.2-gke.1098000 או גרסה מוקדמת יותר לא תומכים בהקצאה אוטומטית של צמתים ליצירת מאגרי צמתים עם GPUs ברמה 4. עם זאת, באשכולות שפועלות בהם גרסאות קודמות יש תמיכה בשינוי גודל של מאגרי צמתים קיימים באמצעות התאמת גודל האשכול באופן אוטומטי.

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

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

זמינות של מעבדי 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 מצורף.

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

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

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

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

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

התקנה ידנית של דרייברים של NVIDIA GPU

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

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

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

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

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

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

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

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

מעקב אחר ביצועי עומס העבודה של צומת ה-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.

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

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

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.

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

• מידע נוסף על מאגרי צמתים
• איך משתמשים בפלטפורמת CPU מינימלית לצמתים
• איך יוצרים ומגדירים קונטיינר מקומי ללמידה עמוקה באמצעות Docker
• איך משתמשים ב-Confidential GKE Nodes במאגרי צומתי GPU (גרסת Preview)
• מידע על שימוש בארגז חול (Sandbox) לעומסי עבודה של GPU עם GKE Sandbox