פריסת עומסי עבודה של GPU ב-Autopilot

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

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

לפני שממשיכים, חשוב לוודא שאתם מכירים את המושגים הבאים:

בחירת מאיצים ב-Pods

‫Autopilot משתמש במחלקת המחשוב המיוחדת Accelerator כדי להריץ תרמילי GPU. במכונות וירטואליות (VM) מסוג GPU, ‏ GKE ממקם את ה-Pods בצמתי GPU, וכך מאפשר ל-Pods גישה ליכולות מתקדמות. כדי להשתמש במחלקה הזו בעומס עבודה של GPU, מבצעים אחת מהפעולות הבאות בהתאם לגרסת GKE:

  • ‫Version 1.29.4-gke.1427000 ואילך: בקשת יחידות GPU במניפסט של עומס העבודה. אפשר גם להשתמש ביכולות שיתוף של GPU, כמו שיתוף זמן. ‫GKE לא משנה את מניפסטים של עומסי העבודה כדי להוסיף בורר צמתים או הערה עבור מחלקת המאיץ.
  • ‫Version 1.29 up to, but not including, version 1.29.4-gke.142700: Specify the cloud.google.com/compute-class: Accelerator node selector in your Pod manifest and request GPUs. אם מציינים את בורר הצמתים הזה, אפשר גם להשתמש ביכולות שיתוף של GPU, כמו שיתוף זמן.
  • ‫Version 1.28.9-gke.1069000 up to, but not including, version 1.29: Specify the cloud.google.com/compute-class: Accelerator node selector in your Pod manifest alongside the GPU selectors. אם מציינים את בורר הצמתים הזה, אפשר גם להשתמש ביכולות שיתוף של GPU, כמו שיתוף זמן.

מחלקת המחשוב Accelerator לא נתמכת בגרסאות קודמות ל-1.28.9-gke.1069000. במקום זאת, ב-GKE, יחידות GPU Pod בגרסאות האלה מטופלות באופן דומה ליחידות Autopilot Pod אחרות, ותחויבו על בקשות המשאבים. פרטים נוספים מופיעים במאמר בנושא תמחור.

תאימות של מאיצים ליכולות של GKE

בטבלה הבאה מוצגות היכולות התואמות של GKE לכל שיטה לבחירת מאיצים ב-GKE Autopilot:

נבחרה מחלקת מחשוב אחת (Accelerator) תאימות ליכולות של GKE

תמחור

בטבלה הבאה מוסבר איך מודל החיוב שבו משתמש GKE תלוי בגרסת GKE של האשכול. תיאור של מודלים לחיוב ב-GKE Autopilot מופיע במאמר תמחור של Autopilot.

גרסת GKE תמחור
‫1.29.4-gke.1427000 ואילך

מודל חיוב מבוסס-צמתים. כל ה-GPU Pods משתמשים במחלקת המחשוב Accelerator. תחויבו על החומרה של Compute Engine שמריצה את עומסי העבודה של ה-GPU, וגם על Autopilot Premium לניהול צמתים ולשינוי גודל. פרטים נוספים זמינים במאמר בנושא תמחור במצב אוטומטי.
מגרסה 1.29 עד גרסה 1.29.4-gke.1427000, לא כולל

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

  • ‫cloud.google.com/compute-class: Accelerator: משתמש במודל חיוב מבוסס-צומת ובסוג המחשוב של המאיץ.
  • אין אפשרות לבחור סוג מחשוב: נעשה שימוש במודל החיוב מבוסס-ה-Pod.

אפשר להשתמש בתכונות כמו GPU עם כמה מופעים במקביל או שיתוף זמן רק אם מציינים באופן מפורש את בורר הצמתים cloud.google.com/compute-class: Accelerator.

פרטים נוספים מופיעים בקטע 'Pods with specific hardware requirements' במאמר בנושא תמחור של Kubernetes Engine.
מגרסה 1.28.6-gke.1095000 עד גרסה 1.29, לא כולל

מודל חיוב מבוסס-צומת, בלי קשר לשאלה אם מציינים את מחלקת המחשוב של המאיץ במניפסטים של ה-Pod.

אפשר להשתמש בתכונות כמו GPU עם כמה מופעים במקביל או שיתוף זמן רק אם מציינים באופן מפורש את בורר הצמתים cloud.google.com/compute-class: Accelerator.

פרטים נוספים מופיעים בקטע 'Pods with specific hardware requirements' במאמר בנושא תמחור של Kubernetes Engine.
גרסאות קודמות ל-1.28.6-gke.1095000

מודל חיוב מבוסס-Pod. החיוב מתבצע על סמך בקשות המשאבים של GPU Pod. פרטים נוספים מופיעים בקטע 'Pods with specific hardware requirements' במאמר בנושא תמחור של Kubernetes Engine.

חשוב לשים לב לשיקולים הבאים בנוגע לתמחור של יחידות GPU ב-Autopilot:

  • כל צמתי ה-GPU מסוג A100 (80GB) משתמשים ב-SSD מקומיים לדיסקים של אתחול הצומת בגדלים קבועים על סמך מספר יחידות ה-GPU. אתם מחויבים בנפרד על כונני ה-SSD המקומיים המצורפים. התמחור הזה לא רלוונטי למעבדי GPU מדגם A100 ‏ (40GB).

  • התמחור של GKE Sandbox זהה לתמחור של Autopilot שמוגדר כברירת מחדל. מידע נוסף על הרצת עומסי עבודה של Accelerator בארגז חול זמין במאמרים GKE Sandbox ותחילת העבודה עם GKE Sandbox.

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

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

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

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

    • מעבדי GPU‏ NVIDIA B200‏ (180GB): גרסה ‎1.32.2-gke.1422000 ואילך
    • מעבדי GPU‏ NVIDIA H200‏ (141GB): גרסה ‎1.31.4-gke.1183000 ואילך
    • מעבדי GPU‏ NVIDIA H100 Mega ‏ (80GB): גרסה ‎1.28.9-gke.1250000 ואילך, וגרסה ‎1.29.4-gke.1542000 ואילך
    • מעבדי GPU‏ NVIDIA H100 ‏ (80GB): גרסה 1.28.6-gke.1369000 ואילך, וגרסה 1.29.1-gke.1575000 ואילך
    • מעבדי GPU‏ NVIDIA RTX PRO 6000: ‏ 1.34.1-gke.1829001 ואילך
    • ‫Multiple GPU Pods per VM: 1.29.2-gke.1355000 or later
    • מעבדי GPU אחרים: כל הגרסאות הנתמכות

מגבלות

  • ‫Time-sharing GPUs ו-multi-instance GPUs זמינים ב-Autopilot בגרסה ‎1.29.3-gke.1093000 של GKE ואילך.
  • הזמינות של ה-GPU תלויה באזור של אשכול Autopilot ובמכסת ה-GPU. Google Cloud כדי למצוא מודל GPU לפי אזור או אזור זמינות, אפשר לעיין במאמר זמינות של GPU לפי אזורים ואזורי זמינות.
  • במקרים של GPU מסוג NVIDIA A100 ‏ (80GB), אתם מחויבים במחיר קבוע על כונני ה-SSD המקומיים שמצורפים לצמתים, גם אם ה-Pods שלכם לא משתמשים בקיבולת הזו.
  • בגרסאות GKE שקודמות ל-1.29.2-gke.1355000, אם מבקשים במפורש צומת GPU קיים ספציפי בשביל ה-Pod, ה-Pod חייב לצרוך את כל משאבי ה-GPU בצומת. לדוגמה, אם בצומת הקיים יש 8 יחידות GPU והקונטיינרים של ה-Pod מבקשים בסך הכול 4 יחידות GPU, מצב Autopilot דוחה את ה-Pod.
  • ב-GKE גרסה ‎1.29.2-gke.1355000 ואילך, אם רוצים שכמה פודים של GPU יתאימו לצומת יחיד, סכום בקשות ה-GPU של הפודים האלה צריך להיות קטן או שווה למספר משאבי ה-GPU שמצורפים לצומת הזה. לדוגמה, בצומת עם gke-accelerator-count של 4 אפשר להציב עד ארבעה Pods שמבקשים כל אחד GPU אחד.

הצבת כמה תרמילי Pod בצומת GPU יחיד שימושית במצבים כמו הבאים:

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

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

בקשת יחידות GPU במאגרי התמונות שלכם

כדי לבקש משאבי GPU עבור הקונטיינרים, מוסיפים את השדות הבאים למפרט ה-Pod. בהתאם לדרישות של עומס העבודה, אפשר להשמיט את בורר cloud.google.com/gke-accelerator-count.

apiVersion: v1
kind: Pod
metadata:
  name: my-gpu-pod
spec:
  # Optional: Use GKE Sandbox
  # runtimeClassName: gvisor
  nodeSelector:
    cloud.google.com/gke-accelerator: GPU_TYPE
    cloud.google.com/gke-accelerator-count: "GPU_COUNT"
  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: GPU_QUANTITY

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

  • ‫GPU_TYPE: סוג חומרת ה-GPU. הערכים המותרים הם:

    • ‫nvidia-gb200: NVIDIA GB200 (תצוגה מקדימה)
    • ‫nvidia-b200: NVIDIA B200 ‏ (180GB)
    • ‫nvidia-h200-141gb: NVIDIA H200 (141GB)
    • ‫nvidia-h100-mega-80gb: NVIDIA H100 Mega (80GB)
    • ‫nvidia-h100-80gb: NVIDIA H100 (80GB)
    • ‫nvidia-a100-80gb: NVIDIA A100 (80GB)
    • ‫nvidia-tesla-a100: NVIDIA A100 (40GB)
    • ‫nvidia-rtx-pro-6000: NVIDIA RTX PRO 6000
    • ‫nvidia-l4: NVIDIA L4
    • ‫nvidia-tesla-t4: NVIDIA T4
    או אם אתם משתמשים ב-GKE Sandbox, אחת מהאפשרויות הבאות:
    • ‫nvidia-gb200: NVIDIA GB200 (תצוגה מקדימה)
    • ‫nvidia-b200: NVIDIA B200 (180GB) (תצוגה מקדימה)
    • ‫nvidia-h200-141gb: NVIDIA H200 ‏ (141GB) (תצוגה מקדימה)
    • ‫nvidia-h100-mega-80gb: NVIDIA H100 Mega (80GB)
    • ‫nvidia-h100-80gb: NVIDIA H100 (80GB)
    • ‫nvidia-a100-80gb: NVIDIA A100 (80GB)
    • ‫nvidia-tesla-a100: NVIDIA A100 (40GB)
    • ‫nvidia-rtx-pro-6000: NVIDIA RTX PRO 6000 (תצוגה מקדימה)
    • ‫nvidia-l4: NVIDIA L4
    • ‫nvidia-tesla-t4: NVIDIA T4
    מידע נוסף זמין במאמר בנושא תמיכה בדגמי GPU.

  • ‫GPU_COUNT: המספר הכולל של המעבדים הגרפיים שאפשר לצרף לצומת. הערך חייב להיות גדול מ-GPU_QUANTITY או שווה לו, וגם כמות ה-GPU הנתמכת עבור סוג ה-GPU שבחרתם. אם לא מציינים את nodeSelector, ‏ Autopilot מציב Pod אחד בכל צומת GPU.

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

  • אופציונלי runtimeClassname: gvisor: ההגדרה שמאפשרת להריץ את ה-Pod הזה ב-GKE Sandbox. כדי להשתמש, מבטלים את ההערה בשורה הזו. מידע נוסף זמין במאמר GKE Sandbox.

פרטים על החיוב על השימוש במאיץ במצב אוטומטי זמינים בקטע תמחור.

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

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

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

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

  • ‫default – מנהל ההתקן היציב שמוגדר כברירת מחדל לגרסת GKE של הצומת. אם לא מציינים את nodeSelector במניפסט, זו אפשרות ברירת המחדל.
  • ‫latest – הגרסה האחרונה של מנהל ההתקן שזמינה לגרסת GKE של הצומת.

בקשת מעבד (CPU) וזיכרון ל-Pods של GPU ב-Autopilot

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

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

apiVersion: v1
kind: Pod
metadata:
  name: t4-pod
spec:
  # Optional: Use GKE Sandbox
  # runtimeClassName: gvisor
  nodeSelector:
    cloud.google.com/gke-accelerator: "nvidia-tesla-t4"
  containers:
  - name: t4-container-1
    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: 3
        cpu: "54"
        memory: "54Gi"
      requests:
        cpu: "54"
        memory: "54Gi"
  - name: t4-container-2
    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: 1
        cpu: "18"
        memory: "18Gi"
      requests:
        cpu: "18"
        memory: "18Gi"
  • אופציונלי runtimeClassname: gvisor: ההגדרה שמאפשרת להריץ את ה-Pod הזה ב-GKE Sandbox. כדי להשתמש, מבטלים את ההערה בשורה הזו. מידע נוסף זמין במאמר GKE Sandbox.

בקובץ המניפסט הזה מוגדרים limits למשאבי מעבד וזיכרון. אם משמיטים את limits עבור CPU או זיכרון ב-GKE בגרסה 1.29.2-gke.1060000 ואילך, GKE מקצה ל-Pods את מחלקת QoS‏ Burstable ומאפשר ל-Pods להשתמש במשאבים לא מנוצלים מתוך סכום בקשות המשאבים בצומת. מידע נוסף זמין במאמר בנושא הגדרת Pod bursting ב-GKE.

בקשת אחסון זמני ל-Pods של GPU ב-Autopilot

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

  • משתמשים במעבדי NVIDIA RTX PRO 6000 GPU ובסוג המחשוב Accelerator, ומריצים את גרסת התיקון GKE 1.34.1-gke.1829001 ואילך.
  • משתמשים ב-GPU מסוג NVIDIA L4 ובסוג המחשוב Accelerator, ומריצים את גרסת התיקון GKE 1.28.6-gke.1369000 ואילך, או 1.29.1-gke.1575000 ואילך.

כדי להשתמש ב-SSD מקומי לאחסון זמני, מוסיפים את ‫nodeSelector‏ cloud.google.com/gke-ephemeral-storage-local-ssd: "true" למניפסט של עומס העבודה. אפשר לראות דוגמה לקובץ מניפסט במאמר שימוש באחסון זמני מקומי שמגובה על ידי SSD עם אשכולות Autopilot. כרטיסי ה-GPU‏ NVIDIA H100 ‏ (80GB) ו-NVIDIA A100 ‏ (80GB) תמיד משתמשים בכונני SSD מקומיים לאחסון זמני, ואי אפשר לציין את בורר הצמתים הזה עבור כרטיסי ה-GPU האלה.

בקשה של סוגי מכונות ספציפיים באמצעות ComputeClasses בהתאמה אישית

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

מידע כללי על ComputeClasses זמין במאמר מידע על ComputeClasses בהתאמה אישית.

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

  1. יוצרים קובץ מניפסט בשביל ComputeClass בהתאמה אישית. בדוגמה הזו, שומרים את הקובץ הבא בשם a3-computeclass.yaml:

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: a3-edge-gpu
spec:
  priorities:
  - machineType: a3-edgegpu-8g-nolssd
    gpu:
     count: 8
     type: nvidia-h100-80gb
  nodePoolAutoCreation:
    enabled: true

    במניפסט הזה:

    • ‫metadata.name הוא השם של ComputeClass המותאם אישית, שאליו תתייחסו במפרט של ה-Pod.
    • ‫machineType היא המכונה הספציפית שצריך להקצות לה הרשאות.
    • השדות gpu מציינים את הסוג והמספר של מעבדי ה-GPU שמצורפים למכונה. הערכים בשדות האלה צריכים להתאים ליכולות של machineType שצוין.

  2. מריצים את הפקודה הבאה כדי להחיל את המניפסט:

    kubectl apply -f a3-computeclass.yaml

  3. במניפסט של ה-Pod, מבקשים את ComputeClass באמצעות בורר הצמתים cloud.google.com/compute-class:

    apiVersion: v1
kind: Pod
metadata:
  name: gpu-cc-pod
spec:
  nodeSelector:
    cloud.google.com/compute-class: a3-edge-gpu
  containers:
  - name: my-gpu-container
    image: nvidia/cuda:latest
    command: ["/bin/bash", "-c", "--"]
    args: ["while true; do sleep 600; done;"]
    resources:
      limits:
        nvidia.com/gpu: 1

    ‫GKE מקצה צומת חדש שתואם להגדרה ב-a3-edge-gpu ComputeClass כדי להריץ את ה-Pod.

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

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

kubectl describe node NODE_NAME

מחליפים את NODE_NAME בשם הצומת שבו ה-Pod תוכנן.

הפלט אמור להיראות כך:


apiVersion: v1
kind: Node
metadata:
...
  labels:
    ...
    cloud.google.com/gke-accelerator: nvidia-tesla-t4
    cloud.google.com/gke-accelerator-count: "1"
    cloud.google.com/machine-family: custom-48
    ...
...

בדיקת גרסת הדרייבר של ה-GPU

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

kubectl logs --selector=k8s-app=nvidia-gpu-device-plugin \
    --container="nvidia-gpu-device-plugin" \
    --tail=-1 \
    --namespace=kube-system | grep Driver

הפלט אמור להיראות כך:

I1206 18:37:08.251742    5851 metrics.go:144] nvml initialized successfully. Driver version: 535.104.12

איך מתבצעת הקצאת GPU ב-Autopilot

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

  1. אם לא קיים צומת GPU שניתן להקצאה, Autopilot יקצה צומת GPU חדש כדי לתזמן את ה-Pod. ‫Autopilot מתקין באופן אוטומטי את מנהלי ההתקנים (דרייברים) של NVIDIA כדי להקל על השימוש בחומרה.
  2. מצב Autopilot מוסיף node taints לצומת ה-GPU ומוסיף את ה-tolerations המתאימים ל-Pod. כך נמנע מ-GKE לתזמן Pods אחרים בצומת ה-GPU.

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

הרצת DaemonSets בכל צומת

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

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

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: logging-agent
spec:
  tolerations:
  - key: ""
    operator: "Exists"
    effect: ""
  containers:
  - name: logging-agent-v1
    image: IMAGE_PATH

מחליפים את IMAGE_PATH בנתיב לקובץ אימג' של קונטיינר.

כדי להריץ DaemonSets בצמתי GPU ספציפיים באשכול, מוסיפים את השורות הבאות למפרט:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: logging-agent
spec:
  nodeSelector:
    cloud.google.com/gke-accelerator: "GPU_TYPE"
  tolerations:
  - key: ""
    operator: "Exists"
    effect: ""
  containers:
  - name: logging-agent-v1
    image: IMAGE_PATH

מחליפים את GPU_TYPE בסוג ה-GPU בצמתי היעד. אלה האפשרויות:

  • ‫nvidia-gb200: NVIDIA GB200 (תצוגה מקדימה)
  • ‫nvidia-b200: NVIDIA B200 ‏ (180GB)
  • ‫nvidia-h200-141gb: NVIDIA H200 (141GB)
  • ‫nvidia-h100-mega-80gb: NVIDIA H100 Mega (80GB)
  • ‫nvidia-h100-80gb: NVIDIA H100 (80GB)
  • ‫nvidia-a100-80gb: NVIDIA A100 (80GB)
  • ‫nvidia-tesla-a100: NVIDIA A100 (40GB)
  • ‫nvidia-rtx-pro-6000: NVIDIA RTX PRO 6000
  • ‫nvidia-l4: NVIDIA L4
  • ‫nvidia-tesla-t4: NVIDIA T4
או אם אתם משתמשים ב-GKE Sandbox, אחת מהאפשרויות הבאות:

  • ‫nvidia-gb200: NVIDIA GB200 (תצוגה מקדימה)
  • ‫nvidia-b200: NVIDIA B200 (180GB) (תצוגה מקדימה)
  • ‫nvidia-h200-141gb: NVIDIA H200 ‏ (141GB) (תצוגה מקדימה)
  • ‫nvidia-h100-mega-80gb: NVIDIA H100 Mega (80GB)
  • ‫nvidia-h100-80gb: NVIDIA H100 (80GB)
  • ‫nvidia-a100-80gb: NVIDIA A100 (80GB)
  • ‫nvidia-tesla-a100: NVIDIA A100 (40GB)
  • ‫nvidia-rtx-pro-6000: NVIDIA RTX PRO 6000 (תצוגה מקדימה)
  • ‫nvidia-l4: NVIDIA L4
  • ‫nvidia-tesla-t4: NVIDIA T4
מידע נוסף זמין במאמר בנושא תמיכה במודלים של GPU.

תרחישי שימוש ב-GPU במצב Autopilot

אתם יכולים להקצות GPU לקונטיינרים ב-Autopilot Pods כדי להקל על עומסי עבודה כמו:

  • הסקת מסקנות (inference) בלמידת מכונה (ML)
  • הדרכה בנושא למידת מכונה
  • עיבוד

כמויות נתמכות של GPU

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

כמויות GPU
‫NVIDIA B200‏ (180GB)
nvidia-b200		 8
‫NVIDIA H200‏ (141GB)
nvidia-h200-141gb		 8
‫NVIDIA H100 Mega (80GB)
nvidia-h100-mega-80gb		 8
NVIDIA H100 (80GB)
nvidia-h100-80gb		 ‫1, 2, 4, 8
NVIDIA A100 (80GB)
nvidia-a100-80gb		 ‫1, 2, 4, 8
‫NVIDIA A100 (40GB)
nvidia-tesla-a100		 ‫1, 2, 4, 8, 16
NVIDIA RTX PRO 6000
nvidia-rtx-pro-6000		 ‫1, 2, 4, 8
NVIDIA L4
nvidia-l4		 ‫1, 2, 4, 8
NVIDIA T4
nvidia-tesla-t4		 1, 2, 4

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

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