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

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

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

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

סקירה כללית

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

מידע נוסף על תרחישים לדוגמה לשימוש ביחידות GPU זמין בדף יחידות GPU של Google Cloud. מידע נוסף על מעבדי GPU ב-GKE ועל ההבדלים בין מצב רגיל למצב אוטומטי זמין במאמר בנושא מעבדי 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: מעבדי GPU מסוג GB300.
  • סדרת מכונות A4X: מעבדי GPU מדגם GB200.
  • סדרת מכונות A4: מעבדי GPU מסוג B200.
  • סדרת מכונות A3: יחידות GPU מסוג H200‏ (A3 Ultra) ויחידות GPU מסוג H100‏ (A3 Mega,‏ High,‏ Edge).
  • סדרת מכונות A2: מעבדי GPU מסוג A100.
  • סדרת מכונות G4: מעבדים גרפיים RTX PRO 6000.
  • סדרת מכונות G2: מעבדי GPU מסוג L4.
  • סדרת מכונות N1: מעבדי GPU‏ NVIDIA T4,‏ NVIDIA V100,‏ NVIDIA P100 (מתקרב סוף התמיכה) או NVIDIA P4.

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

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

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

  • סדרת מכונות 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 ואילך

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

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

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

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

    • ‫1.32.7-gke.1067000 ואילך ל-GKE גרסה 1.32
    • ‫1.33.3-gke.1247000 ואילך ל-GKE גרסה 1.33

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

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

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

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

  • סדרת מכונות A4X Max: מעבדי GPU מסוג GB300.
  • סדרת מכונות A4X: מעבדי GPU מדגם GB200.
  • סדרת מכונות A4: מעבדי GPU מסוג B200.
  • סדרת מכונות A3: יחידות GPU מסוג H200‏ (A3 Ultra) ויחידות GPU מסוג H100‏ (A3 Mega,‏ High,‏ Edge).
  • סדרת מכונות A2: מעבדי GPU מסוג A100.
  • סדרת מכונות G4: מעבדים גרפיים 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 ברמה L4. עם זאת, באשכולות שפועלות בהם גרסאות קודמות יש תמיכה בשינוי גודל של מאגרי צמתים קיימים באמצעות התאמה אוטומטית של גודל האשכול.

• לסוגי מכונות 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 (for example, locations) (מאפיינים (לדוגמה, מיקומים)), מוסיפים את השם של האזור או האזור שבו אתם משתמשים ולוחצים על Enter.

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

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

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

6. ממלאים את השדה תיאור הבקשה בפרטים לגבי הבקשה.

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

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

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

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

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

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

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

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

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

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

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

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

gcloud container node-pools update t4 \
  --accelerator type=nvidia-tesla-t4,count=2,gpu-driver-version=latest \
  --cluster t4-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.

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

המדדים הבאים חלים על מערכי משימות (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, צריך לפרוס את ה-injector של מכשיר ה-NRI כ-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
• איך משתמשים בצומתי GKE סודיים במאגרי צמתים של GPU (גרסת Preview)
• מידע על שימוש בארגז חול (Sandbox) לעומסי עבודה של GPU עם GKE Sandbox