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

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

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

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

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

תמחור

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

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

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

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

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

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

    • מעבדי GPU מסוג NVIDIA B200 (180GB): גרסה 1.32.2-gke.1422000 ואילך
    • מעבדי NVIDIA RTX PRO 6000 GPU:
      • סוגי מכונות עם GPU אחד או יותר: 1.34.1-gke.1829001 ואילך
      • סוגי מכונות עם פחות מ-GPU אחד: 1.35.2-gke.1485000 ואילך

    כל שאר סוגי ה-GPU נתמכים בכל הגרסאות הזמינות של GKE.

מגבלות

  • הזמינות של ה-GPU תלויה באזור של אשכול Autopilot ובמכסת ה-GPU. Google Cloud כדי למצוא מודל GPU לפי אזור או תחום, אפשר לעיין במאמר זמינות של GPU לפי אזורים ותחומים.
  • במעבדי GPU מסוג NVIDIA A100 (80GB), אתם מחויבים במחיר קבוע על כונני ה-SSD המקומיים שמחוברים לצמתים, גם אם ה-Pods לא משתמשים בנפח האחסון הזה.
  • אם רוצים שכמה פודים של GPU יתאימו לצומת אחד, סכום הבקשות ל-GPU של הפודים האלה חייב להיות קטן ממספר משאבי ה-GPU שמצורפים לצומת הזה או שווה לו. לדוגמה, צומת עם gke-accelerator-count של 4 יכול להכיל עד ארבעה Pods שכל אחד מהם מבקש GPU אחד.

הצבת כמה Pods בצומת GPU אחד שימושית במצבים כמו:

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

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

  • ‫GPU_COUNT: המספר הכולל של מעבדי GPU שאפשר לצרף לצומת. הערך חייב להיות גדול מ-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

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

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

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

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

הפעלת DaemonSets בכל צומת

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

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

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 (גרסת טרום-השקה (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
  • nvidia-l4: NVIDIA L4
  • nvidia-tesla-t4: NVIDIA T4
או אם משתמשים ב-GKE Sandbox, אחת מהגרסאות הבאות:

מידע נוסף זמין במאמר תמיכה במודלים של GPU.

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

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

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

כמויות GPU נתמכות

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

כמויות נתמכות של GPU לפי סוג GPU
סוג ה-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/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.
  • ‫Memory Usage (container/accelerator/memory_used): כמות הזיכרון של המאיץ שהוקצתה, בבייטים.
  • ‫Memory Capacity (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, הקיבולת של זיכרון ה-GPU ומחזור העבודה של ה-GPU.

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

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

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

מדדי תקינות של JobSet וצמתים לעומסי עבודה ב-GPU

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

מדדי JobSet

המדדים הבאים רלוונטיים גם ל-JobSets של GPU וגם ל-JobSets של TPU עם Job משוכפל אחד:

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

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

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

מעבר אל Deployments

מדדי תקינות של צמתים

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

  • ‫kubernetes.io/node/status_condition: המדד הזה דורש את גרסה 1.32.1-gke.1357001 ומעלה של GKE.

המדדים של הפסקות בצמתים ובמאגרי צמתים חלים גם על צמתים שהם לא TPU.

‫Kube-state-metrics ל-JobSets

אפשר להשתמש ב-kube-state-metrics של JobSets עם GPUs. כדי לאסוף את המדדים האלה, צריך להשתמש ב-GKE מגרסה 1.32.1-gke.1357001 ואילך. מידע נוסף זמין במאמרי העזרה בנושא מדדי JobSet.

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