אתם יכולים לבקש מעבדים גרפיים כדי להאיץ משימות בעומסי העבודה של 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 זמינות בפרויקט. צריכה להיות לכם מספיק מכסה ל-GPU ב-Compute Engine בשביל המודלים של ה-GPU שאתם רוצים ליצור בכל אזור. אם אתם צריכים מכסה נוספת של GPU, אתם יכולים לבקש שינוי של המכסה.
אם אתם רוצים להשתמש בסוגי מכונות G4 עם פחות מ-NVIDIA RTX PRO 6000 GPU אחד, אתם צריכים לבצע את הפעולות הבאות, בנוסף לעמידה בדרישות הגרסה שצוינו:
- מבקשים במפורש סוגי מכונות G4 עם פחות מ-GPU אחד.
- אם באשכול פועלת גרסה של GKE שקודמת ל-1.36, הכינו את עומסי העבודה.
מגבלות
- הזמינות של ה-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 L4nvidia-tesla-t4: NVIDIA T4
-
nvidia-gb200: NVIDIA GB200 (גרסת טרום-השקה (Preview)) -
nvidia-b200: NVIDIA B200 (180GB) (גרסת טרום-השקה (Preview)) nvidia-h200-141gb: NVIDIA H200 (141GB) (גרסת טרום-השקה (Preview))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 (גרסת טרום-השקה (Preview)) (חוץ ממכונות מסוג G4 עם פחות מ-GPU אחד)nvidia-l4: NVIDIA L4nvidia-tesla-t4: NVIDIA T4
-
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, מבצעים את השלבים הבאים:
יוצרים מניפסט ל-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שצוין.
-
מריצים את הפקודה הבאה כדי להחיל את המניפסט:
kubectl apply -f a3-computeclass.yamlבמניפסט של ה-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: 1GKE מקצה צומת חדש שתואם להגדרה ב-
a3-edge-gpuComputeClass כדי להריץ את ה-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:1gpu.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, קורים הדברים הבאים:
- אם לא קיים צומת GPU שניתן להקצות, Autopilot מקצה צומת GPU חדש כדי לתזמן את ה-Pod. Autopilot מתקין באופן אוטומטי את מנהלי ההתקנים של NVIDIA כדי להפעיל את החומרה.
- במצב 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 L4nvidia-tesla-t4: NVIDIA T4
-
nvidia-gb200: NVIDIA GB200 (גרסת טרום-השקה (Preview)) -
nvidia-b200: NVIDIA B200 (180GB) (גרסת טרום-השקה (Preview)) nvidia-h200-141gb: NVIDIA H200 (141GB) (גרסת טרום-השקה (Preview))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 (גרסת טרום-השקה (Preview)) (חוץ ממכונות מסוג G4 עם פחות מ-GPU אחד)nvidia-l4: NVIDIA L4nvidia-tesla-t4: NVIDIA T4
תרחישים לדוגמה לשימוש ב-GPU ב-Autopilot
אתם יכולים להקצות מעבדים גרפיים לקונטיינרים ב-Pods של Autopilot כדי להקל על עומסי עבודה כמו:
- הסקת מסקנות באמצעות למידת מכונה (ML)
- אימון מודלים של למידת מכונה
- עיבוד
כמויות GPU נתמכות
אם תבקשו במפרט ה-Pod כמות של GPU שלא נתמכת בסוג ה-GPU הזה, Autopilot ידחה את ה-Pod. כשמבקשים יחידות GPU במפרט של ה-Pod, צריך להשתמש בכמויות הבאות בהתאם לסוג ה-GPU:
| סוג ה-GPU | כמויות GPU נתמכות |
|---|---|
|
NVIDIA B200 (180GB)
|
8 |
|
NVIDIA H200 (141GB)
|
8 |
|
NVIDIA H100 Mega (80GB)
|
8 |
|
NVIDIA H100 (80GB)
|
1, 2, 4, 8 |
|
NVIDIA A100 (80GB)
|
1, 2, 4, 8 |
|
NVIDIA A100 (40GB)
|
1, 2, 4, 8, 16 |
|
NVIDIA RTX PRO 6000
|
1/8, 1/4, 1/2, 1, 2, 4, 8 |
|
NVIDIA L4
|
1, 2, 4, 8 |
|
NVIDIA 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 של עומס העבודה:
-
נכנסים לדף Workloads במסוף Google Cloud .
כניסה לדף Workloads - בוחרים עומס עבודה.
בלוח הבקרה 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_interruptionskubernetes.io/jobset/times_to_recoverkubernetes.io/jobset/uptime
למידע נוסף על מדדי המערכת האלה, ראו מדדי Kubernetes.
אפשר גם להשתמש בלוח הבקרה של JobSet במסוף Google Cloud כדי להציג ולנטר את עומסי העבודה ב-GPU:
מדדי תקינות של צמתים
המדדים הבאים ברמת הצומת רלוונטיים לכל הצמתים, כולל אלה עם מעבדים גרפיים:
-
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.
המאמרים הבאים
- מידע נוסף על תמיכה ב-GPU ב-GKE
- איך מתבצעת אופטימיזציה של ComputeClasses במצב Autopilot לתרחישי שימוש מיוחדים
- איך פורסים מעבדים גרפיים לעומסי עבודה באצווה באמצעות מתזמן משימות לפריסת workload דינמית (DWS)
- מידע על הרצה בארגז חול (Sandbox) של עומסי עבודה ב-GPU באמצעות GKE Sandbox