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

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

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

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

כדי לבקש יחידות GPU, משתמשים ב-ComputeClasses או בבוררי צמתים במפרט של ה-Pod. ‫GKE מציב את ה-Pods האלה בצמתים שיש להם יחידות GPU. אפשר גם להשתמש ביכולות שיתוף של GPU, כמו שיתוף זמן.

תמחור

מודל החיוב מבוסס הצמתים של Autopilot חל על GPU Pods. גם עלות הניהול של Autopilot לצמתים וגם חומרת ה-GPU בפועל ב-Compute Engine עומדות בדרישות להנחות גמישות תמורת התחייבות לשימוש (CUD) במשאבי המחשוב.

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

  • כל צמתי ה-GPU מסוג A100 ‏ (80GB) משתמשים ב-SSD מקומיים לדיסקים של אתחול הצומת בגדלים קבועים על סמך מספר יחידות ה-GPU. תחויבו בנפרד על כונני ה-SSD המקומיים המצורפים. התמחור הזה לא רלוונטי ל-GPU מסוג A100 (40GB).
  • התמחור של GKE Sandbox זהה לתמחור ברירת המחדל של Autopilot. מידע נוסף על הרצה בארגז חול של עומסי עבודה של מאיצים זמין במאמרים GKE Sandbox ותחילת העבודה עם GKE Sandbox.
  • אם אתם משתמשים ב-GPU מסוג NVIDIA RTX PRO 6000 (סדרת מכונות G4) במצב Autopilot, החל מ-1 באוקטובר 2026, מערכת GKE תחייב אתכם על שירות הפרימיום לניהול צמתים ב-Autopilot, בנוסף לחיובים הקיימים שחלים על החומרה הבסיסית. החיובים הקיימים האלה ימשיכו לחול גם לפני התאריך הזה וגם אחריו. למידע נוסף על אופן החיוב כשמבקשים חומרה ספציפית עם עומסי עבודה ב-Autopilot, קראו את המאמר עומסי עבודה ב-Autopilot שבוחרים חומרה ספציפית.

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

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

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

מגבלות

  • הזמינות של ה-GPU תלויה באזור Cloud de Confiance by S3NS של אשכול Autopilot ובמכסת ה-GPU. כדי למצוא מודל GPU לפי אזור או אזור זמינות, קראו את המאמר זמינות של GPUs לפי אזורים ואזורי זמינות.
  • במעבדי GPU מסוג NVIDIA A100 ‏ (80GB), אתם מחויבים במחיר קבוע על כונני ה-SSD המקומיים שמצורפים לצמתים, גם אם ה-Pods שלכם לא משתמשים בקיבולת הזו.
  • אם רוצים שכמה פודים של 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 (גרסת Preview)
    • ‫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 (תצוגה מקדימה) (חוץ מסוגי מכונות G4 שיש להן פחות מ-GPU אחד)
    • ‫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 של הצומת. אם רוצים, אפשר להתקין את גרסת הדרייבר העדכנית ביותר לגרסת GKE הזו, על ידי הוספת בורר הצמתים הבא למניפסט:

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

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

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

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

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

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

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

  • משתמשים ב-GPU מסוג NVIDIA RTX PRO 6000 ומריצים גרסת תיקון של GKE שעומדת בדרישות הגרסה שמפורטות בקטע לפני שמתחילים. ההגדרה של שמינית GPU לא תומכת באחסון זמני.
  • שימוש במעבדי GPU מסוג NVIDIA L4.

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

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

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

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

סוגי המכונות G4 משתמשים ב-GPU‏ NVIDIA RTX PRO 6000. כדי לבקש סוגי מכונות G4 עם פחות מ-GPU אחד, צריך לפעול לפי ההוראות בקטע הקודם ולהגדיר את השדות הבאים:

  • machineType לאחד מהערכים הבאים:

    • ‫g4-standard-6 (שמינית GPU)
    • ‫g4-standard-12 (רבע GPU)
    • g4-standard-24 (חצי GPU)

  • gpu.count: 1

  • gpu.type: nvidia-rtx-pro-6000

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

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

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

הרצת 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 (גרסת Preview)
  • ‫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 (תצוגה מקדימה) (למעט סוגי מכונות G4 שיש להן פחות מ-GPU אחד)
  • nvidia-l4: NVIDIA L4
  • ‫nvidia-tesla-t4: NVIDIA T4
מידע נוסף זמין במאמר תמיכה במודלים של GPU.

תרחישים לדוגמה לשימוש ב-GPU ב-Autopilot

אתם יכולים להקצות מעבדים גרפיים למאגרים ב-Pods של Autopilot כדי להקל על עומסי עבודה כמו:

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

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

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

כמויות של 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/8, ‏ 1/4, ‏ 1/2, ‏ 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): כמות הזיכרון של המאיץ שהוקצתה, בבייטים.
  • ‫Memory Capacity (container/accelerator/memory_total): נפח הזיכרון הכולל של המאיץ, בבייטים.

המדדים האלה חלים ברמת הקונטיינר (container/accelerator) ולא נאספים עבור קונטיינרים שמתוזמנים ב-GPU שמשתמש בשיתוף זמן GPU או ב-NVIDIA MPS.

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

הצגת מדדי השימוש של עומסי עבודה

אפשר לראות את מדדי השימוש ב-GPU של עומסי העבודה בלוח הבקרה Workloads במסוף Cloud de Confiance .

כדי לראות את השימוש ב-GPU בעומס העבודה:

  1. נכנסים לדף Workloads במסוף Cloud de Confiance .

    כניסה לדף Workloads
  2. בוחרים עומס עבודה.

בלוח הבקרה Workloads מוצגים תרשימים של השימוש בזיכרון ה-GPU והקיבולת שלו, ושל מחזור הפעולה של ה-GPU.

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

אתם יכולים לאסוף מדדי NVIDIA DCGM ולהציג אותם באמצעות השירות המנוהל של Google Cloud ל-Prometheus. באשכולות Autopilot, ‏ GKE מתקין את מנהלי ההתקנים. באשכולות Standard, צריך להתקין את מנהלי ההתקנים של NVIDIA.

הוראות לפריסת חבילת DCGM שמנוהלת על ידי GKE מפורטות במאמר איסוף והצגה של מדדי NVIDIA Data Center GPU Manager (DCGM)‎.

מדדי בריאות של צמתים ושל JobSet לעומסי עבודה של GPU

בנוסף למדדי DCGM, אתם יכולים להשתמש במדדים הבאים כדי לעקוב אחרי התקינות והביצועים של עומסי העבודה ב-GPU, במיוחד כשמריצים אותם כ-JobSets.

מדדי JobSet

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

  • kubernetes.io/jobset/times_between_interruptions
  • kubernetes.io/jobset/times_to_recover
  • kubernetes.io/jobset/uptime

למידע נוסף על מדדי המערכת האלה, ראו מדדי Kubernetes.

אפשר גם להשתמש בלוח הבקרה JobSet במסוף Cloud de Confiance כדי להציג באופן חזותי את עומסי העבודה של ה-GPU ולעקוב אחריהם:

מעבר אל Deployments

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

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

  • ‫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.

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