במסמך הזה מוסבר איך להאיץ את עומסי העבודה של למידת המכונה (ML) באמצעות יחידות TPU ב-Google Kubernetes Engine (GKE). יחידות TPU מיועדות לעיבוד של כפל מטריצות, כמו אימון של מודלים של למידה עמוקה בקנה מידה גדול. יחידות TPU מותאמות לטיפול במערכי נתונים עצומים ובמודלים מורכבים של למידת מכונה, ולכן הן חסכוניות יותר בעלויות ובאנרגיה לעומסי עבודה של למידת מכונה, בזכות הביצועים המעולים שלהן. במדריך הזה נסביר איך לפרוס עומסי עבודה של ML באמצעות מאיצי Cloud TPU, להגדיר מכסות ל-TPU, להגדיר שדרוגים למאגרי צמתים שמריצים TPU ולעקוב אחרי מדדי עומסי העבודה של TPU.
המדריך הזה מיועד למהנדסי למידת מכונה (ML) ולמנהלי פלטפורמות ומפעילים שרוצים להשתמש בתזמור קונטיינרים של Kubernetes כדי לנהל עומסי עבודה של אימון, כוונון והסקת מסקנות של מודלים בקנה מידה גדול באמצעות יחידות TPU. למידע נוסף על תפקידים נפוצים ומשימות לדוגמה שמוזכרות בתוכן של Google Cloud , קראו את המאמר תפקידים ומשימות נפוצים של משתמשי GKE.
לפני שאתם קוראים את הדף הזה, חשוב שתכירו את המושגים הבאים:
לפני שמתחילים
לפני שמתחילים, חשוב לוודא שביצעתם את המשימות הבאות:
- מפעילים את Google Kubernetes Engine API. הפעלת Google Kubernetes Engine API
- כדי להשתמש ב-Google Cloud CLI למשימה הזו, מתקינים ואז מאתחלים את ה-CLI של gcloud. אם כבר התקנתם את ה-CLI של gcloud, הריצו את הפקודה
gcloud components updateכדי לקבל את הגרסה העדכנית. יכול להיות שבגרסאות קודמות של ה-CLI של gcloud אי אפשר להריץ את הפקודות שבמסמך הזה.
תכנון ההגדרה של ה-TPU
תכננו את הגדרת ה-TPU בהתאם למודל ולכמות הזיכרון שהוא דורש. לפני שאתם משתמשים במדריך הזה כדי לפרוס את עומסי העבודה ב-TPU, אתם צריכים להשלים את שלבי התכנון שמפורטים במאמר תכנון ההגדרה של TPU.
מוודאים שיש לכם מכסת TPU
בקטעים הבאים מוסבר איך לוודא שיש לכם מספיק מכסה כשאתם משתמשים ב-TPU ב-GKE.מכסה למכונות וירטואליות על פי דרישה או במודל Spot
אם אתם יוצרים מאגר של צומתי פרוסות TPU עם מכונות וירטואליות על פי דרישה או במחיר Spot, אתם צריכים לוודא שיש לכם מספיק מכסת TPU באזור שבו אתם רוצים להשתמש.
כדי ליצור מאגר צמתים של פרוסות TPU שצורכים מקום שמור של TPU, לא נדרשת מכסת TPU.1 אתם יכולים לדלג על הקטע הזה לגבי יחידות TPU שמורים.
כדי ליצור מאגר של צומתי פרוסות TPU על פי דרישה או מסוג Spot ב-GKE, צריך מכסה של Compute Engine API. המכסה של Compute Engine API (compute.googleapis.com) שונה מהמכסה של Cloud TPU API (tpu.googleapis.com), שנדרשת כשיוצרים יחידות TPU באמצעות Cloud TPU API.
כדי לבדוק את המגבלה ואת השימוש הנוכחי במכסת Compute Engine API ליחידות TPU, מבצעים את השלבים הבאים:
נכנסים לדף Quotas במסוף Google Cloud :
בתיבה Filter:
אתם יכולים להיעזר בטבלה הבאה כדי לבחור ולהעתיק את מאפיין המכסה, בהתאם לגרסת ה-TPU ולסוג המכונה. לדוגמה, אם אתם מתכננים ליצור צומתי TPU v5e על פי דרישה שסוג המכונה שלהם מתחיל ב-
ct5lp-, הזינוName: TPU v5 Lite PodSlice chips.גרסת TPU, סוג המכונה מתחיל ב- המאפיין והשם של המכסה למכונות זמינות בהתאם לעומס המאפיין והשם של המכסה למכונות Spot2 TPU v3,
ct3-Dimensions (e.g. location):
tpu_family:CT3לא רלוונטי TPU v3,
ct3p-Dimensions (e.g. location):
tpu_family:CT3Pלא רלוונטי TPU v4,
ct4p-Name:
TPU v4 PodSlice chipsName:
Preemptible TPU v4 PodSlice chipsTPU v5e,
ct5lp-Name:
TPU v5 Lite PodSlice chipsName:
Preemptible TPU v5 Lite Podslice
chipsTPU v5p,
ct5p-Name:
TPU v5p chipsName:
Preemptible TPU v5p chipsTPU Trillium,
ct6e-Dimensions (e.g. location):
tpu_family:CT6EName:
Preemptible TPU slices v6eIronwood (TPU7x),
tpu7x-standard-4tDimensions (e.g. location):
tpu_family:tpu7xName:
Preemptible TPU slices tpu7xבוחרים את המאפיין Dimensions (e.g. locations) ומזינים את הערך
region:ואחריו את שם האזור שבו מתכננים ליצור יחידות TPU ב-GKE. לדוגמה, הזינוregion:us-west4אם אתם מתכננים ליצור צומתי פרוסות TPU באזורus-west4-a. המכסה של TPU היא אזורית, כך שכל האזורים באותו אזור צורכים את אותה מכסת TPU.
אם אין מכסות שתואמות למסנן שהזנתם, סימן שהפרויקט לא קיבל את המכסה שציינתם לאזור שאתם צריכים, ואתם צריכים לבקש שינוי במכסת ה-TPU.
כשיוצרים הזמנת TPU, גם ערך המגבלה וגם ערך השימוש הנוכחי במכסה המתאימה גדלים לפי מספר הצ'יפים בהזמנת ה-TPU. לדוגמה, כשיוצרים הזמנה ל-16 שבבי TPU v5e שסוג המכונה שלהם מתחיל ב-ct5lp-, גם המגבלה וגם השימוש הנוכחי במכסת TPU v5 Lite PodSlice chips באזור הרלוונטי גדלים ב-16.
-
כשיוצרים מאגר צמתים של פרוסות TPU, משתמשים בדגלים
--reservationו---reservation-affinity=specificכדי ליצור מכונה שמורה. אפשר להזמין TPU כשרוכשים התחייבות. ↩ -
כשיוצרים מאגר צמתים של פרוסות TPU, משתמשים בדגל
--spotכדי ליצור מכונה של Spot. ↩
מכסות למשאבים נוספים של GKE
יכול להיות שתצטרכו להגדיל את המכסות הבאות שקשורות ל-GKE באזורים שבהם GKE יוצר את המשאבים שלכם.
- מכסת Persistent Disk SSD (GB): דיסק האתחול של כל צומת Kubernetes דורש 100GB כברירת מחדל. לכן, המכסה הזו צריכה להיות לפחות בגודל של מכפלת המספר המקסימלי של צומתי GKE שאתם צופים שתיצרו ב-100GB (צמתים * 100GB).
- מכסת כתובות ה-IP שבשימוש: כל צומת Kubernetes צורך כתובת IP אחת. לכן, המכסה הזו צריכה להיות לפחות בגודל של מספר הצמתים המקסימלי של GKE שאתם צופים שתיצרו.
- מוודאים ש-
max-pods-per-nodeתואם לטווח של רשת המשנה: כל צומת של Kubernetes משתמש בטווחי IP משניים ל-Pods. לדוגמה, אם הערך שלmax-pods-per-nodeהוא 32, נדרשות 64 כתובות IP, כלומר רשת משנה /26 לכל צומת. חשוב לזכור שאסור לשתף את הטווח הזה עם אשכול אחר. כדי לא לחרוג מטווח כתובות ה-IP, השתמשו בדגל--max-pods-per-nodeכדי להגביל את מספר ה-Pods שאפשר לתזמן בצומת. המכסה שלmax-pods-per-nodeצריכה להיות לפחות בגודל של המספר המקסימלי של צומתי GKE שאתם צופים שתיצרו.
כדי לבקש להגדיל את המכסה, קראו את המאמר איך שולחים בקשה לשינוי המכסות.
לוודא שיש מקומות פנויים להזמנה
כדי ליצור מאגר צמתים של פרוסות TPU באמצעות הזמנה, בהזמנה צריכים להיות מספיק שבבי TPU זמינים בזמן יצירת מאגר הצמתים.
כדי לראות אילו הזמנות קיימות בפרויקט וכמה שבבי TPU זמינים בהזמנת TPU, הציגו את רשימת ההזמנות.
יצירת אשכול
gcloud
יוצרים אשכול GKE במצב רגיל באזור שבו יש יחידות TPU זמינות.
להשתמש באשכולות אזוריים, שמספקים זמינות גבוהה של מישור הבקרה של Kubernetes.
gcloud container clusters create CLUSTER_NAME \
--location LOCATION \
--cluster-version VERSION
מחליפים את מה שכתוב בשדות הבאים:
-
CLUSTER_NAME: השם של האשכול החדש. -
LOCATION: האזור שבו קיבולת ה-TPU זמינה. -
VERSION: גרסת GKE, שצריכה לתמוך בסוג המכונה שבה רוצים להשתמש. חשוב לזכור שיכול להיות שגרסת ברירת המחדל של GKE לא תהיה זמינה ל-TPU היעד. כדי לדעת מהן גרסאות GKE המינימליות שזמינות לפי סוג מכונת TPU, קראו את המאמר זמינות TPU ב-GKE.
Cluster Toolkit
- הגדרת Cluster Toolkit.
פורסים אשכול GKE TPU באמצעות תוכנית של Cluster Toolkit (למשל
gke-tpu-v6eאוgke-tpu-7x; לתוכניות של TPU v4, v5e ו-v5p, ראו מאגר Cluster Toolkit ב-GitHub):gcluster deploy examples/gke-tpu-7x/gke-tpu-7x.yaml \ --vars project_id=PROJECT_ID,deployment_name=DEPLOYMENT_NAME,zone=ZONEמחליפים את מה שכתוב בשדות הבאים:
-
DEPLOYMENT_NAME: שם לפריסה של Cluster Toolkit (שהוא גם השם של אשכול GKE). -
PROJECT_ID: מזהה הפרויקט ב- Google Cloud . -
ZONE: שם האזור בהתאם לגרסת ה-TPU שבה רוצים להשתמש. כדי לזהות מיקום זמין, עיינו במאמר זמינות של TPU ב-GKE. כדי להשתמש בקיבולת שמורה, צריך להשתמש באזור שבו שמרתם את הקיבולת.
-
יצרתם אשכול GKE עם מאגר צמתים שכולל את משאבי ה-TPU שצוינו. עכשיו אפשר לבצע את השלבים שמפורטים בקטע הרצת עומס העבודה בצומתי פרוסות TPU במסמך הזה.
הקצאת מעבדי TPU
כדי להקצות יחידות TPU ב-GKE, אתם יכולים לבחור באחת מאפשרויות ההגדרה הבאות:- יצירה ידנית של מאגר צמתים: אתם יכולים ליצור מאגר צמתים עם גרסה וטופולוגיה ספציפיות של TPU.
- שימוש בהקצאת צמתים אוטומטית (NAP) ב-GKE: אתם יכולים להפעיל הקצאת צמתים אוטומטית ברמת האשכול, ואז להשתמש ב-nodeSelector במניפסט של ה-Pod כדי לציין את גרסת ה-TPU והטופולוגיה. כשה-Pod בהמתנה תואם לבוררים האלה, GKE יוצר באופן אוטומטי מאגר צמתים חדש שעומד בדרישות. בשיטה הזו צריך להגדיר מגבלות משאבים ברמת האשכול ליחידות ה-TPU.
- הגדרת ComputeClasses בהתאמה אישית: אתם יכולים לבקש יחידות TPU באמצעות ComputeClasses בהתאמה אישית. מנהלי פלטפורמות יכולים להשתמש ב-ComputeClasses בהתאמה אישית כדי להגדיר היררכיה של הגדרות אישיות של צמתים, ש-GKE יתעדף כשהוא יקבל החלטות לגבי שינוי קנה המידה של הצמתים, כדי שעומסי העבודה יפעלו בחומרה שנבחרה.
יצירה ידנית של מאגר צמתים
אפשר ליצור מאגר צמתים של פרוסות TPU עם מארח יחיד או עם כמה מארחים.
יצירת מאגר צמתים של פרוסות TPU עם מארח יחיד
אפשר ליצור מאגר של צומתי פרוסות TPU במארח יחיד באמצעות ה-CLI של Google Cloud, Terraform או מסוף Google Cloud .
gcloud
gcloud container node-pools create NODE_POOL_NAME \
--location=LOCATION \
--cluster=CLUSTER_NAME \
--node-locations=NODE_ZONES \
--machine-type=MACHINE_TYPE \
[--sandbox=type=gvisor]
מחליפים את מה שכתוב בשדות הבאים:
-
NODE_POOL_NAME: השם של מאגר הצמתים החדש. -
LOCATION: שם האזור בהתאם לגרסת ה-TPU שבה רוצים להשתמש. כדי לזהות מיקום זמין, עיינו במאמר זמינות של TPU ב-GKE. -
CLUSTER_NAME: שם האשכול. -
NODE_ZONES: רשימה מופרדת בפסיקים של אזור אחד או יותר שבהם GKE יוצר את מאגר הצמתים.אופציונלי: אפשר להשתמש באזור AI, כמו
us-central1-ai1a. אזורי AI הם מיקומים ייעודיים שמותאמים לעומסי עבודה של AI/ML בתוך Google Cloud אזורים. -
MACHINE_TYPE: הגרסה והסוג של ה-TPU. לדוגמה, משתמשים ב-tpu7x-standard-4tל-Ironwood (TPU7x).
אפשר גם להשתמש בדגלים הבאים:
--num-nodes=NUM_NODES: המספר הראשוני של הצמתים במאגר הצמתים בכל אזור.שיטה מומלצת: אם משתמשים בדגל
enable-autoscalingלמאגר הצמתים, מגדירים אתnum-nodesלערך0כדי שהמידרוג האוטומטי יקצה צמתים נוספים ברגע שעומסי העבודה דורשים זאת.
--reservation=RESERVATION_NAME: שם ההזמנה שבה GKE משתמש כשיוצרים את מאגר הצמתים. אם לא משתמשים בדגל הזה, GKE משתמש ביחידות ה-TPU הזמינות. מידע נוסף על הקצאות של Cloud TPU
--node-labels cloud.google.com/gke-workload-type=HIGH_AVAILABILITY: אומר ל-GKE שמאגר הצמתים של פרוסת TPU במארח יחיד הוא חלק מאוסף. כדאי להשתמש בדגל הזה אם מתקיימים התנאים הבאים:- מאגר הצמתים מריץ עומס עבודה של הסקה במאגר הצמתים החדש.
- מאגר הצמתים משתמש ב-TPU Trillium.
- מאגר הצמתים לא משתמש ב-VM במודל Spot.
מידע נוסף על ניהול תזמון האיסוף זמין במאמר ניהול תזמון האיסוף בפרוסות TPU של מארח יחיד.
--enable-autoscaling: יצירת מאגר צמתים עם התאמה אוטומטית לעומס. נדרשים הדגלים הנוספים הבאים:-
--total-min-nodes=TOTAL_MIN_NODES: המספר המינימלי של כל הצמתים במאגר הצמתים. -
--total-max-nodes=TOTAL_MAX_NODES: המספר המקסימלי של כל הצמתים במאגר הצמתים. -
--location-policy=ANY: לתת עדיפות לשימוש בהזמנות שלא נוצלו ולהפחית את הסיכון להפקעה של מכונות וירטואליות במודל Spot.
-
--spot: מגדיר את מאגר הצמתים כך שישתמש במכונות וירטואליות במודל Spot לצמתים במאגר הצמתים. אי אפשר לשנות את ההגדרה הזו אחרי שיוצרים את מאגר הצמתים.
--flex-start: מגדיר את מאגר הצמתים לשימוש ב-Flex-start VM. כדי ליצור מכונות וירטואליות מסוג Flex-start, משתמשים באפשרות הצריכה flex-start. מידע נוסף זמין במאמר הרצת עומס עבודה של אצווה קטנה באמצעות יחידות TPU ומכונות וירטואליות מסוג Flex-start.
רשימה מלאה של כל הדגלים שאפשר לציין מופיעה במאמרי העזרה בנושא gcloud container clusters create.
Terraform
- חשוב לוודא שאתם משתמשים בגרסה 4.84.0 ואילך של הספק
google. - מוסיפים את הבלוק הבא להגדרות ב-Terraform:
resource "google_container_node_pool" "NODE_POOL_RESOURCE_NAME" {
provider = google
project = PROJECT_ID
cluster = CLUSTER_NAME
name = POOL_NAME
location = CLUSTER_LOCATION
node_locations = [NODE_ZONES]
node_config {
machine_type = MACHINE_TYPE
reservation_affinity {
consume_reservation_type = "SPECIFIC_RESERVATION"
key = "compute.googleapis.com/reservation-name"
values = [RESERVATION_LABEL_VALUES]
}
spot = true
flex_start = false
}
}
מחליפים את מה שכתוב בשדות הבאים:
-
NODE_POOL_RESOURCE_NAME: השם של משאב מאגר הצמתים בתבנית של Terraform. PROJECT_ID: מזהה הפרויקט.-
CLUSTER_NAME: השם של האשכול הקיים. -
POOL_NAME: השם של מאגר הצמתים שרוצים ליצור. -
CLUSTER_LOCATION: אזורי המחשוב של האשכול. מציינים את האזור שבו גרסת ה-TPU זמינה. למידע נוסף, קראו את המאמר בחירת גרסה וטופולוגיה של TPU. -
NODE_ZONES: רשימה מופרדת בפסיקים של אזור אחד או יותר שבהם GKE יוצר את מאגר הצמתים.אופציונלי: אפשר להשתמש באזור AI, כמו
us-central1-ai1a. אזורי AI הם מיקומים ייעודיים שמותאמים לעומסי עבודה של AI/ML בתוך Google Cloud אזורים. -
MACHINE_TYPE: סוג מכונת ה-TPU שבה משתמשים. כדי לראות את סוגי המכונות שתואמים ל-TPU, השתמשו בטבלה שבקטע בחירת גרסת ה-TPU.
אפשר גם להשתמש במשתנים הבאים:
-
autoscaling: יצירת מאגר צמתים עם התאמה אוטומטית לעומס. בפרוסת TPU עם מארח יחיד, GKE משנה את קנה המידה בין הערכיםTOTAL_MIN_NODESו-TOTAL_MAX_NODES.-
TOTAL_MIN_NODES: המספר המינימלי של כל הצמתים במאגר הצמתים. השדה הזה הוא אופציונלי, אלא אם צוין גם התאמה אוטומטית לעומס. -
TOTAL_MAX_NODES: המספר המקסימלי של כל הצמתים במאגר הצמתים. השדה הזה הוא אופציונלי, אלא אם צוין גם התאמה אוטומטית לעומס.
-
-
RESERVATION_NAME: אם אתם משתמשים במידע על הקצאות מקום ב-Cloud TPU, זו רשימת התוויות של משאבי הקצאת המקום שבהם צריך להשתמש כשיוצרים את מאגר הצמתים. במאמר ספק Terraform מוסבר איך לאכלס אתRESERVATION_LABEL_VALUESבשדהreservation_affinity. -
spot: מגדיר את מאגר הצמתים כך שישתמש ב-VM במודל Spot בשביל צומתי ה-TPU. אי אפשר לשנות את ההגדרה הזו אחרי שיוצרים את מאגר הצמתים. מידע נוסף זמין במאמר VM במודל Spot. -
flex_start: מגדיר את מאגר הצמתים כך שישתמש באפשרות הצריכה flex-start. אי אפשר להגדיר את הערךtrueאם המדיניותspotמופעלת. אפשר להשתמש ב-Flex-start ב-GKE מגרסה 1.33.0-gke.1712000 ואילך.
המסוף
כדי ליצור מאגר צמתים עם יחידות TPU:
נכנסים לדף Google Kubernetes Engine במסוף Google Cloud .
ברשימת האשכולות, לוחצים על שם האשכול שרוצים לשנות.
לוחצים על הכרטיסייה Nodes.
לוחצים על add_box Create user-managed node pool.
בקטע פרטי מאגר צמתים, מסמנים את התיבה ציון מיקומי צמתים.
בוחרים את האזור בהתאם לגרסת ה-TPU שבה רוצים להשתמש. כדי לזהות אזור זמין, אפשר לעיין במאמר זמינות של TPU ב-GKE.
בחלונית הניווט, לוחצים על Nodes.
בקטע Machine Configuration, בוחרים באפשרות TPUs.
בתפריט הנפתח סדרה, בוחרים באחת מהאפשרויות הבאות:
- CT3: TPU v3, מכשיר מארח יחיד
- CT3P: TPU v3, פרוסת pod עם כמה מארחים
- CT4P: TPU v4
- CT5LP: TPU v5e
- CT5P: TPU v5p
- CT6E: TPU Trillium (v6e)
בתפריט הנפתח Machine type, בוחרים את שם המכונה שבה רוצים להשתמש לצמתים. בטבלה בחירת גרסת ה-TPU מוסבר איך להגדיר את סוג המכונה ואת הטופולוגיה של ה-TPU שיוצרים מאגר צמתים של פרוסות TPU במארח יחיד.
בתפריט הנפתח TPU Topology, בוחרים את הטופולוגיה הפיזית של פרוסת ה-TPU.
בתיבת הדו-שיח נדרשים שינויים, לוחצים על ביצוע שינויים.
מוודאים שסוג דיסק האתחול הוא דיסק מתמיד סטנדרטי או דיסק מתמיד שמבוסס על SSD.
אם רוצים להשתמש ב-VM במודל Spot לצמתים במאגר הצמתים, מסמנים את התיבה Enable nodes on spot VMs.
לוחצים על יצירה.
יצירת מאגר צמתים של פרוסת TPU עם כמה מארחים
השלבים ליצירת מאגר של צומתי פרוסות TPU עם כמה מארחים משתנים בהתאם לשימוש ב-Ironwood (TPU7x) או בגרסת TPU קודמת.
Ironwood (TPU7x)
אתם יכולים ליצור מאגר של צומתי פרוסות TPU עם כמה מארחים בגרסה Ironwood (TPU7x) באמצעות Google Cloud CLI או Terraform:
gcloud
כדי ליצור מאגר של פרוסות TPU עם כמה מארחים באמצעות Ironwood (TPU7x), קודם צריך ליצור מדיניות של עומסי עבודה.
יוצרים מדיניות עומסי עבודה:
gcloud compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \ --type=HIGH_THROUGHPUT \ --accelerator-topology=TPU_TOPOLOGY \ --project=PROJECT_ID \ --region=REGIONמחליפים את מה שכתוב בשדות הבאים:
-
WORKLOAD_POLICY_NAME: שם למדיניות של עומס העבודה. -
TPU_TOPOLOGY: הטופולוגיה של TPU Ironwood (TPU7x). לדוגמה,2x2x2. בקטע על טופולוגיה מפורטות כל הטופולוגיות שנתמכות ב-Ironwood (TPU7x). -
PROJECT_ID: מזהה הפרויקט ב- Google Cloud . -
REGION: האזור של מדיניות עומס העבודה. מדיניות עומסי העבודה היא משאב אזורי, ואפשר להשתמש בה שוב במאגרי צמתים שחולקים את אותה טופולוגיה.
-
יוצרים את מאגר הצמתים עם מדיניות עומסי העבודה:
gcloud container node-pools create NODE_POOL_NAME \ --cluster=CLUSTER_NAME \ --machine-type=tpu7x-standard-4t \ --placement-policy=WORKLOAD_POLICY_NAME \ --location=CONTROL_PLANE_LOCATION \ --node-locations=NODE_ZONE \ --project=PROJECT_ID \ --reservation=RESERVATION_NAME \ --reservation-affinity=specificמחליפים את מה שכתוב בשדות הבאים:
-
NODE_POOL_NAME: השם של מאגר הצמתים החדש. -
CLUSTER_NAME: השם של אשכול GKE. -
WORKLOAD_POLICY_NAME: השם של מדיניות עומסי העבודה שיצרתם. -
CONTROL_PLANE_LOCATION: המיקום ב-Compute Engine של מישור הבקרה של האשכול. מציינים אזור לאשכולות אזוריים, או תחום לאשכולות של תחומים. -
NODE_ZONE: שם האזור בהתאם לגרסת ה-TPU שבה רוצים להשתמש.אופציונלי: אפשר להשתמש באזור AI, כמו
כדי לזהות מיקום זמין, עיינו במאמר זמינות של TPU ב-GKE.us-central1-ai1a. אזורי AI הם מיקומים ייעודיים שמותאמים לעומסי עבודה של AI/ML בתוך Google Cloud אזורים. -
PROJECT_ID: מזהה הפרויקט ב- Google Cloud . -
RESERVATION_NAME: שם ההזמנה שבה רוצים להשתמש.
בפקודה הזו, הדגל
--tpu-topologyהוחלף בדגל--placement-policy.-
Terraform
- חשוב לוודא שאתם משתמשים בגרסה 4.84.0 ואילך של הספק
google. יוצרים מדיניות עומסי עבודה:
resource "google_compute_resource_policy" { name = "WORKLOAD_POLICY_NAME" region = CLUSTER_LOCATION workload_policy { type = "HIGH_THROUGHPUT" accelerator_topology = "TPU_TOPOLOGY" } }מחליפים את מה שכתוב בשדות הבאים:
-
WORKLOAD_POLICY_NAME: שם למדיניות של עומס העבודה. -
CLUSTER_LOCATION: מיקום המחשוב של האשכול. כדי לשפר את האמינות של מישור הבקרה של Kubernetes, מומלץ להשתמש באשכול אזורי. אפשר גם להשתמש באשכול אזורי. מידע נוסף זמין במאמר בחירת גרסה וטופולוגיה של TPU. -
TPU_TOPOLOGY: הטופולוגיה של TPU Ironwood (TPU7x). לדוגמה,2x2x2. במאמר הזה מפורטות כל הטופולוגיות שנתמכות ב-Ironwood (TPU7x).
למידע נוסף על חומר העזר בנושא
google_compute_resource_policy, קראו את המאמר ספק Terraform.-
מוסיפים את הבלוק הבא להגדרות ב-Terraform:
resource "google_container_node_pool" "NODE_POOL_RESOURCE_NAME" { provider = google project = PROJECT_ID cluster = CLUSTER_NAME name = POOL_NAME location = CLUSTER_LOCATION node_locations = [NODE_ZONES] initial_node_count = NUM_NODES autoscaling { max_node_count = MAX_NODES location_policy = "ANY" } node_config { machine_type = MACHINE_TYPE reservation_affinity { consume_reservation_type = "SPECIFIC_RESERVATION" key = "compute.googleapis.com/reservation-name" values = [RESERVATION_LABEL_VALUES] } flex_start = false spot = true } placement_policy { policy_name = WORKLOAD_POLICY_NAME } }מחליפים את מה שכתוב בשדות הבאים:
-
NODE_POOL_RESOURCE_NAME: השם של משאב מאגר הצמתים בתבנית של Terraform. PROJECT_ID: מזהה הפרויקט.-
CLUSTER_NAME: שם האשכול הקיים שאליו רוצים להוסיף את מאגר הצמתים. -
POOL_NAME: השם של מאגר הצמתים שרוצים ליצור. -
NODE_ZONES: רשימה מופרדת בפסיקים של אזור אחד או יותר שבהם GKE יוצר את מאגר הצמתים.אופציונלי: אפשר להשתמש באזור AI, כמו
us-central1-ai1a. אזורי AI הם מיקומים ייעודיים שמותאמים לעומסי עבודה של AI או למידת מכונה בתוך Google Cloud אזורים. -
NUM_NODES: מספר הצמתים במאגר הצמתים. הערך חייב להיות אפס או המכפלה של מספר שבבי ה-TPU חלקי ארבע, כי בפרוסות TPU עם כמה מארחים, לכל צומת של פרוסת TPU יש ארבעה שבבים. לדוגמה, אםTPU_TOPOLOGYהוא4x8, יש 32 צ'יפים, כלומרNUM_NODESצריך להיות 8. בטבלה שבקטע בחירת גרסת ה-TPU מפורט מידע נוסף על טופולוגיות של TPU. -
TPU_TOPOLOGY: מציין את הטופולוגיה הפיזית שנבחרה לפרוסת ה-TPU. הפורמט של הטופולוגיה תלוי בגרסת ה-TPU שבה אתם משתמשים. למידע נוסף על טופולוגיות של TPU, עיינו בטבלה שבקטע בחירת טופולוגיה.
אפשר גם להשתמש במשתנים הבאים:
-
RESERVATION_NAME: אם אתם משתמשים בהזמנת TPU, צריך לספק רשימה של תוויות למשאבי ההזמנה שבהן תשתמשו כשתיצרו את מאגר הצמתים. במאמר Terraform Provider מוסבר איך לאכלס אתRESERVATION_LABEL_VALUESבשדהreservation_affinity. -
autoscaling: יצירת מאגר צמתים עם התאמה אוטומטית לעומס. כשמגדילים את מאגר הצמתים של פרוסת TPU עם כמה מארחים ב-GKE, המאגר גדל באופן אטומי מאפס לגודל המקסימלי.-
MAX_NODES: הגודל המקסימלי של מאגר הצמתים. הערך חייב להיות שווה למכפלה של הערכים שמוגדרים ב-TPU_TOPOLOGY({A}x{B}x{C}) חלקי מספר הצ'יפים בכל VM. לדוגמה, אם הערך שלTPU_TOPOLOGYהוא2x2x2, המכפלה היא 8. בכל מכונה וירטואלית ב-tpu7x-standard-4tיש 4 צ'יפים, ולכן מספר הצמתים הוא 2.
-
-
spot: מאגר הצמתים שישתמש במכונות וירטואליות במודל Spot בשביל צומתי פרוסת ה-TPU. אי אפשר לשנות את ההגדרה הזו אחרי שיוצרים את מאגר הצמתים. מידע נוסף זמין במאמר VM במודל Spot. -
flex_start: מאגר הצמתים שישתמש באפשרות הצריכה flex-start. אי אפשר להגדיר את ההגדרה הזו לערךtrueאם ההגדרהspotמופעלת.
-
גרסאות אחרות של TPU
אתם יכולים ליצור מאגר של צומתי פרוסות TPU עם כמה מארחים בגרסאות v3, v4, v5p, v5e ו-Trillium (v6e) באמצעות Google Cloud CLI, Terraform או מסוף Google Cloud .
gcloud
gcloud container node-pools create POOL_NAME \
--location=CONTROL_PLANE_LOCATION \
--cluster=CLUSTER_NAME \
--node-locations=NODE_ZONE \
--machine-type=MACHINE_TYPE \
--tpu-topology=TPU_TOPOLOGY \
[--num-nodes=NUM_NODES] \
[--spot \]
[--flex-start \]
[--enable-autoscaling \
--max-nodes MAX_NODES]
[--reservation-affinity=specific \
--reservation=RESERVATION_NAME] \
[--node-labels cloud.google.com/gke-nodepool-group-name=COLLECTION_NAME,cloud.google.com/gke-workload-type=HIGH_AVAILABILITY]
[--placement-type=COMPACT]
מחליפים את מה שכתוב בשדות הבאים:
-
POOL_NAME: השם של מאגר הצמתים החדש. -
CONTROL_PLANE_LOCATION: שם האזור בהתאם לגרסת ה-TPU שבה רוצים להשתמש. כדי לזהות מיקום זמין, עיינו במאמר זמינות של TPU ב-GKE. -
CLUSTER_NAME: שם האשכול. -
NODE_ZONES: רשימה מופרדת בפסיקים של אזור אחד או יותר שבהם GKE יוצר את מאגר הצמתים.אופציונלי: אפשר להשתמש באזור AI, כמו
us-central1-ai1a. אזורי AI הם מיקומים ייעודיים שמותאמים לעומסי עבודה של AI או למידת מכונה בתוך Google Cloud אזורים. -
MACHINE_TYPE: סוג המכונה שבה משתמשים לצמתים. מידע נוסף על סוגי המכונות הזמינים מופיע במאמר בחירת גרסת ה-TPU.
TPU_TOPOLOGY: הטופולוגיה הפיזית של פרוסת ה-TPU. הפורמט של הטופולוגיה תלוי בגרסת ה-TPU. למידע נוסף על טופולוגיות של TPU, עיינו בטבלה שבקטע בחירת טופולוגיה.מידע נוסף זמין במאמר בנושא טופולוגיה.
אפשר גם להשתמש בדגלים הבאים:
NUM_NODES: מספר הצמתים במאגר הצמתים. הערך צריך להיות אפס או המכפלה של הערכים שמוגדרים ב-TPU_TOPOLOGY({A}x{B}x{C}) חלקי מספר הצ'יפים בכל מכונה וירטואלית. ב-TPU v4 וב-TPU v5e עם כמה מארחים, יש ארבעה צ'יפים בכל מכונה וירטואלית. לכן, אם הערך שלTPU_TOPOLOGYהוא2x4x4(TPU v4 עם ארבעה שבבים בכל VM), הערך שלNUM_NODESהוא 32/4, כלומר 8. אם לא מציינים את הדגל הזה, מספר הצמתים מחושב ומוגדר כברירת מחדל על סמך הטופולוגיה וסוג המכונה.
RESERVATION_NAME: שם ההזמנה שבה GKE משתמש כשיוצרים את מאגר הצמתים. אם לא מציינים את הדגל הזה, GKE משתמש במאגרי הצמתים הזמינים של פרוסות TPU. מידע נוסף על הזמנות של TPU זמין במאמר הזמנות של TPU.
--spot: הגדרת מאגר הצמתים לשימוש ב-VM במודל Spot בשביל צומתי פרוסות ה-TPU. אי אפשר לשנות את ההגדרה הזו אחרי שיוצרים את מאגר הצמתים. מידע נוסף זמין במאמר VM במודל Spot.
--flex-start: מגדיר את מאגר הצמתים לשימוש ב-Flex-start VM. כדי ליצור מכונות וירטואליות מסוג Flex-start, משתמשים באפשרות הצריכה flex-start, שנתמכת ב-GKE מגרסה 1.33.0-gke.1712000 ואילך.
--enable-autoscaling: יצירת מאגר צמתים עם התאמה אוטומטית לעומס. כשמגדילים את מאגר הצמתים של פרוסת TPU עם כמה מארחים ב-GKE, המאגר גדל באופן אטומי מאפס לגודל המקסימלי.-
MAX_NODES: הגודל המקסימלי של מאגר הצמתים. הדגל--max-nodesנדרש אם צוין--enable-autoscaling, והוא חייב להיות שווה למכפלה של הערכים שהוגדרו ב-TPU_TOPOLOGY({A}x{B}x{C}) חלקי מספר הצ'יפים בכל מכונה וירטואלית.
-
--node-label=cloud.google.com/gke-nodepool-group-name=COLLECTION_NAME, cloud.google.com/gke-workload-type=HIGH_AVAILABILITY: מציין ל-GKE שמאגר הצמתים של פרוסת ה-TPU עם כמה מארחים הוא אוסף. כדאי להשתמש בדגל הזה אם מתקיימים התנאים הבאים:- מאגר הצמתים מריץ עומסי עבודה של הסקת מסקנות.
- מאגר הצמתים משתמש ב-TPU Trillium.
- אי אפשר לתזמן איסוף של מכונות וירטואליות במודל Spot.
מידע נוסף על ניהול תזמון האיסוף זמין במאמר ניהול תזמון האיסוף בפרוסות TPU עם כמה מארחים.
--placement-type=COMPACT: יצירת מאגר צמתים עם מיקום קומפקטי. צריך להשתמש באפשרות הזו עם הדגל--tpu-topology. מידע נוסף זמין במאמרים יצירת מדיניות למיקום קומפקטי וטופולוגיית TPU.
Terraform
- חשוב לוודא שאתם משתמשים בגרסה 4.84.0 ואילך של הספק
google. מוסיפים את הבלוק הבא להגדרות ב-Terraform:
resource "google_container_node_pool" "NODE_POOL_RESOURCE_NAME" { provider = google project = PROJECT_ID cluster = CLUSTER_NAME name = POOL_NAME location = CLUSTER_LOCATION node_locations = [NODE_ZONES] initial_node_count = NUM_NODES autoscaling { max_node_count = MAX_NODES location_policy = "ANY" } node_config { machine_type = MACHINE_TYPE reservation_affinity { consume_reservation_type = "SPECIFIC_RESERVATION" key = "compute.googleapis.com/reservation-name" values = [RESERVATION_LABEL_VALUES] } flex_start = false spot = true } placement_policy { type = "COMPACT" tpu_topology = TPU_TOPOLOGY } }מחליפים את מה שכתוב בשדות הבאים:
-
NODE_POOL_RESOURCE_NAME: השם של משאב מאגר הצמתים בתבנית של Terraform. PROJECT_ID: מזהה הפרויקט.-
CLUSTER_NAME: שם האשכול הקיים שאליו רוצים להוסיף את מאגר הצמתים. -
POOL_NAME: השם של מאגר הצמתים שרוצים ליצור. -
CLUSTER_LOCATION: מיקום המחשוב של האשכול. כדי לשפר את האמינות של מישור הבקרה של Kubernetes, מומלץ להשתמש באשכול אזורי. אפשר גם להשתמש באשכול אזורי. מידע נוסף זמין במאמר בחירת גרסה וטופולוגיה של TPU. -
NODE_ZONES: רשימה מופרדת בפסיקים של אזור אחד או יותר שבהם GKE יוצר את מאגר הצמתים.אופציונלי: אפשר להשתמש באזור AI, כמו
us-central1-ai1a. אזורי AI הם מיקומים ייעודיים שמותאמים לעומסי עבודה של AI/ML בתוך Google Cloud אזורים. -
NUM_NODES: מספר הצמתים במאגר הצמתים. הערך חייב להיות אפס או המכפלה של מספר שבבי ה-TPU חלקי ארבע, כי בפרוסות TPU עם כמה מארחים, לכל צומת של פרוסת TPU יש 4 שבבים. לדוגמה, אם הערך שלTPU_TOPOLOGYהוא4x8, יש 32 צ'יפים, כלומר הערך שלNUM_NODESצריך להיות 8. בטבלה שבקטע בחירת גרסת ה-TPU מפורט מידע נוסף על טופולוגיות של TPU. -
TPU_TOPOLOGY: מציין את הטופולוגיה הפיזית של פרוסת ה-TPU. הפורמט של הטופולוגיה תלוי בגרסת ה-TPU שבה אתם משתמשים. למידע נוסף על טופולוגיות של TPU, עיינו בטבלה שבקטע בחירת טופולוגיה.
אפשר גם להשתמש במשתנים הבאים:
-
RESERVATION_NAME: אם משתמשים בהזמנת TPU, זו רשימת התוויות של משאבי ההזמנה שבהם צריך להשתמש כשיוצרים את מאגר הצמתים. במאמר Terraform Provider מוסבר איך לאכלס אתRESERVATION_LABEL_VALUESבשדהreservation_affinity. -
autoscaling: יצירת מאגר צמתים עם התאמה אוטומטית לעומס. כשמגדילים את מאגר הצמתים של פרוסת TPU עם כמה מארחים ב-GKE, המאגר גדל באופן אטומי מאפס לגודל המקסימלי.-
MAX_NODES: הגודל המקסימלי של מאגר הצמתים. הערך צריך להיות שווה למכפלה של הערכים שמוגדרים ב-TPU_TOPOLOGY({A}x{B}x{C}) חלקי מספר הצ'יפים בכל VM).
-
-
spot: מאפשר למאגר הצמתים להשתמש ב-VM במודל Spot בשביל צומתי פרוסת ה-TPU. אי אפשר לשנות את ההגדרה הזו אחרי שיוצרים את מאגר הצמתים. מידע נוסף זמין במאמר VM במודל Spot. -
flex_start: מגדיר את מאגר הצמתים כך שישתמש באפשרות הצריכה flex-start. אי אפשר להגדיר את הערךtrueאם המדיניותspotמופעלת.
-
המסוף
כדי ליצור מאגר צמתים עם יחידות TPU:
נכנסים לדף Google Kubernetes Engine במסוף Google Cloud .
ברשימת האשכולות, לוחצים על שם האשכול שרוצים לשנות.
לוחצים על הכרטיסייה Nodes.
לוחצים על add_box Create user-managed node pool.
בקטע פרטי מאגר צמתים, מסמנים את התיבה ציון מיקומי צמתים.
בוחרים את שם האזור בהתאם לגרסת ה-TPU שבה רוצים להשתמש. כדי לזהות מיקום זמין, עיינו במאמר זמינות של TPU ב-GKE.
בחלונית הניווט, לוחצים על Nodes.
בקטע Machine Configuration, בוחרים באפשרות TPUs.
בתפריט הנפתח סדרה, בוחרים באחת מהאפשרויות הבאות:
- CT3: TPU v3, מכשיר עם מארח יחיד
- CT3P: TPU v3, פרוסת Pod עם כמה מארחים
- CT4P: TPU v4
- CT5LP: TPU v5e
- CT5P: TPU v5p
- CT6E: TPU Trillium (v6e)
בתפריט הנפתח Machine type, בוחרים את שם המכונה שבה רוצים להשתמש לצמתים. בטבלה בחירת גרסת ה-TPU מוסבר איך להגדיר את סוג המכונה ואת הטופולוגיה של ה-TPU שיוצרים מאגר של צומתי פרוסות TPU עם מארחים מרובים.
בתפריט הנפתח TPU Topology, בוחרים את הטופולוגיה הפיזית של פרוסת ה-TPU.
בתיבת הדו-שיח נדרשים שינויים, לוחצים על ביצוע שינויים.
מוודאים שסוג דיסק האתחול הוא דיסק מתמיד סטנדרטי או דיסק מתמיד שמבוסס על SSD.
לחלופין, כדי להשתמש ב-VM במודל Spot עבור הצמתים במאגר הצמתים, סמנו את התיבה Enable nodes on spot VMs.
לוחצים על יצירה.
שימוש בהקצאת צמתים אוטומטית (NAP) ב-GKE
אתם יכולים להגדיר את GKE כך שייצור וימחק באופן אוטומטי מאגרי צמתים כדי לעמוד בדרישות המשאבים של עומסי העבודה ב-TPU.
כדי להפעיל הקצאת משאבים אוטומטית למאגר הצמתים, עורכים את מגבלות המשאבים של ה-TPU באשכול:
gcloud container clusters update CLUSTER_NAME \ --location=CONTROL_PLANE_LOCATION \ --enable-autoprovisioning \ --min-cpu=MINIMUM_CPU \ --min-memory=MINIMUM_MEMORY \ --max-cpu=MAXIMUM_CPU \ --max-memory=MAXIMUM_MEMORY \ --min-accelerator=type=TPU_TYPE,count=MINIMUM_TPU_COUNT \ --max-accelerator=type=TPU_TYPE,count=MAXIMUM_TPU_COUNTמחליפים את מה שכתוב בשדות הבאים:
-
TPU_TYPE: סוג ה-TPU. לדוגמה, משתמשים ב-tpu7xל-Ironwood (TPU7x). -
MINIMUM_TPU_COUNT: המספר המינימלי של שבבי TPU מהסוג שצוין שיכולים להיות באשכול. אם הערך שציינתם גדול ממספר שבבי ה-TPU בפרוסת TPU עם כמה מארחים, GKE מסיר את כל הצמתים בפרוסה. מאגרי צמתים עם כמה מארחים משתנים בין 0 למספר הצמתים בפרוסה, בלי ערכי ביניים. -
MAXIMUM_TPU_COUNT: המספר המקסימלי של שבבי TPU מהסוג שצוין שיכולים להיות באשכול. בפרוסות TPU עם כמה מארחים, צריך לציין ערך שגדול ממספר הצ'יפים בכל פרוסה כדי ש-GKE יוכל לשנות את קנה המידה של הפרוסה באופן אטומי. מספר הצ'יפים בפרוסה הוא המכפלה של טופולוגיית ה-TPU. לדוגמה, אם הטופולוגיה היא2x2x2, מספר הצ'יפים בפרוסה הוא8, כלומר הערך שלMAXIMUM_TPU_COUNTחייב להיות גדול מ-8.
-
הגדרת ComputeClasses בהתאמה אישית
אתם יכולים גם להגדיר את GKE כך שיבקש יחידות TPU במהלך פעולות התאמה לעומס שיוצרות צמתים חדשים באמצעות ComputeClasses בהתאמה אישית.
אתם יכולים לציין אפשרויות להגדרת TPU במפרט של ComputeClass בהתאמה אישית. כשעומס עבודה ב-GKE משתמש ב-ComputeClass בהתאמה אישית, GKE מנסה להקצות יחידות TPU שמשתמשות בהגדרה שציינתם כשמגדילים את הנפח.
בקטעים הבאים מוסבר איך ליצור ComputeClass בהתאמה אישית, ואז ליצור משימה שמשתמשת ביחידות ה-TPU שהוגדרו ב-ComputeClass.
יצירת ComputeClass בהתאמה אישית
השלבים ליצירת ComputeClass בהתאמה אישית לפי כללי TPU משתנים בהתאם לשימוש ב-Ironwood (TPU7x) או בגרסת TPU קודמת.
Ironwood (TPU7x)
יוצרים מדיניות של עומס עבודה. השלב הזה נדרש רק אם אתם יוצרים מאגר של צמתים עם כמה מארחים, בהתאם לטופולוגיה שבחרתם. אם אתם משתמשים במאגר צמתים עם מארח יחיד, דלגו על השלב הזה.
gcloud compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \ --type=HIGH_THROUGHPUT \ --accelerator-topology=TPU_TOPOLOGY \ --project=PROJECT_ID \ --region=REGIONמחליפים את מה שכתוב בשדות הבאים:
-
WORKLOAD_POLICY_NAME: שם למדיניות של עומס העבודה. -
TPU_TOPOLOGY: הטופולוגיה של TPU Ironwood (TPU7x). לדוגמה, אפשר להשתמש ב-2x2x2. מידע נוסף על כל הטופולוגיות הנתמכות של Ironwood (TPU7x) זמין בקטע בנושא טופולוגיה. -
PROJECT_ID: מזהה הפרויקט ב- Google Cloud . -
REGION: האזור של מדיניות עומס העבודה. מדיניות עומס העבודה היא משאב אזורי, ואפשר להשתמש בה במאגרי צמתים.
-
שומרים את המניפסט הבא בתור
tpu-compute-class.yaml:apiVersion: cloud.google.com/v1 kind: ComputeClass metadata: name: tpu-class spec: priorities: - tpu: type: tpu7x topology: TPU_TOPOLOGY count: 4 placement: policyName: WORKLOAD_POLICY_NAME nodePoolAutoCreation: enabled: true(אופציונלי) אתם יכולים להשתמש בהזמנה ספציפית או בבלוק משנה. לדוגמה, אפשר להוסיף את ה-
specsהבא למניפסט שלComputeClass:reservations: affinity: Specific specific: - name: RESERVATION_NAME reservationBlock: name: RESERVATION_BLOCK_NAME reservationSubBlock: name: RESERVATION_SUB_BLOCK_NAMEמחליפים את מה שכתוב בשדות הבאים:
-
RESERVATION_NAME: השם של המקום השמור לקיבולת ב-Compute Engine. -
RESERVATION_BLOCK_NAME: השם של בלוק המקום השמור ב-Compute Engine. -
RESERVATION_SUB_BLOCK_NAME: השם של בלוק המשנה של המקום השמור לקיבולת ב-Compute Engine.
מידע נוסף זמין במאמר צריכת משאבים שמורים של תחום מוגדר.
-
גרסאות אחרות של TPU
כדי להקצות יחידות TPU מדור v3, v4, v5p, v5e או v6e (Trillium) באמצעות ComputeClass בהתאמה אישית שמוגדר ליחידות TPU, מבצעים את הפעולות הבאות:
שומרים את המניפסט הבא בתור
tpu-compute-class.yaml:apiVersion: cloud.google.com/v1 kind: ComputeClass metadata: name: tpu-class spec: priorities: - tpu: type: TPU_TYPE count: NUMBER_OF_CHIPS topology: TOPOLOGY - spot: true tpu: type: TPU_TYPE count: NUMBER_OF_CHIPS topology: TOPOLOGY - flexStart: enabled: true tpu: type: TPU_TYPE count: NUMBER_OF_CHIPS topology: TOPOLOGY nodePoolAutoCreation: enabled: trueמחליפים את מה שכתוב בשדות הבאים:
-
TPU_TYPE: סוג ה-TPU שבו רוצים להשתמש, למשלtpu-v4-podslice. הערך חייב להיות נתמך על ידי GKE. -
TOPOLOGY: סידור שבבי ה-TPU בפרוסה, למשל2x2x4. הטופולוגיה צריכה להיות נתמכת בסוג ה-TPU שנבחר. -
NUMBER_OF_CHIPS: מספר שבבי ה-TPU שהקונטיינר ישתמש בהם. הערך שלlimitsו-requestsצריך להיות זהה.
-
פורסים את ה-ComputeClass:
kubectl apply -f tpu-compute-class.yamlמידע נוסף על ComputeClasses בהתאמה אישית ו-TPU זמין במאמר הגדרת TPU.
יצירת משימה שצורכת יחידות TPU
שומרים את המניפסט הבא בתור
tpu-job.yaml:apiVersion: v1 kind: Service metadata: name: headless-svc spec: clusterIP: None selector: job-name: tpu-job --- apiVersion: batch/v1 kind: Job metadata: name: tpu-job spec: backoffLimit: 0 completions: 4 parallelism: 4 completionMode: Indexed template: spec: subdomain: headless-svc restartPolicy: Never nodeSelector: cloud.google.com/compute-class: tpu-class containers: - name: tpu-job image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest ports: - containerPort: 8471 # Default port using which TPU VMs communicate - containerPort: 8431 # Port to export TPU runtime metrics, if supported. command: - bash - -c - | python -c 'import jax; print("TPU cores:", jax.device_count())' resources: requests: cpu: 10 memory: MEMORY_SIZE google.com/tpu: NUMBER_OF_CHIPS limits: cpu: 10 memory: MEMORY_SIZE google.com/tpu: NUMBER_OF_CHIPSמחליפים את מה שכתוב בשדות הבאים:
-
NUMBER_OF_CHIPS: מספר שבבי ה-TPU שהקונטיינר ישתמש בהם. הערך שלlimitsו-requestsצריך להיות זהה, ושווה לערך שלCHIP_COUNTב-ComputeClass בהתאמה אישית שנבחר. -
MEMORY_SIZE: כמות הזיכרון המקסימלית שבה ה-TPU משתמש. מגבלות הזיכרון תלויות בגרסה ובטופולוגיה של ה-TPU שבהם אתם משתמשים. מידע נוסף זמין במאמר ערכי מינימום ומקסימום למאיצים. -
NUMBER_OF_CHIPS: מספר שבבי ה-TPU שהקונטיינר ישתמש בהם. הערך שלlimitsו-requestsצריך להיות זהה.
-
פורסים את המשימה:
kubectl create -f tpu-job.yamlכשיוצרים את המשימה הזו, GKE מבצע באופן אוטומטי את הפעולות הבאות:
- מקצה צמתים להרצת ה-Pods. בהתאם לסוג ה-TPU, לטופולוגיה ולבקשות למשאבים שציינתם, הצמתים האלה הם פרוסות של מארח יחיד או פרוסות של כמה מארחים. בהתאם לזמינות של משאבי TPU בעדיפות הגבוהה ביותר, יכול להיות ש-GKE יחזור לעדיפויות נמוכות יותר כדי למקסם את הגמישות, היעילות והזמינות של קיבולת המאיץ.
- מוסיף taints לפודים ו-tolerations לצמתים כדי למנוע מעומסי עבודה אחרים לפעול באותם צמתים כמו עומסי העבודה של ה-TPU.
מידע נוסף זמין במאמר מידע על ComputeClasses בהתאמה אישית.
כדי להימנע מחיובים נוספים אחרי שסיימתם את החלק הזה, אתם יכולים למחוק את המשאבים שיצרתם:
kubectl delete -f tpu-job.yaml
הכנת עומסי העבודה (workloads)
לעומסי עבודה של TPU יש את דרישות ההכנה הבאות.
- מסגרות כמו JAX, PyTorch ו-TensorFlow ניגשות למכונות וירטואליות של TPU באמצעות הספרייה המשותפת
libtpu. libtpuכולל את מהדר ה-XLA, תוכנת זמן הריצה של ה-TPU ומנהל ההתקן של ה-TPU. כל גרסה של PyTorch ו-JAX דורשת גרסה מסוימת שלlibtpu.so. כדי למנוע התנגשויות בין גרסאות של חבילות, מומלץ להשתמש בתמונה מ-AI של JAX. כדי להשתמש ביחידות TPU ב-GKE, צריך לוודא שמשתמשים בגרסאות הבאות:tpu7xסוג ה-TPU גרסה libtpu.soIronwood (TPU7x) - קובץ אימג' מומלץ של JAX AI: jax0.8.1-rev1 ואילך
- גרסת jax[tpu] מומלצת: v0.8.1
TPU Trillium (v6e)
tpu-v6e-slice
- קובץ אימג' מומלץ של JAX AI: jax0.4.35-rev1 ואילך
- גרסת jax[tpu] מומלצת: v0.4.9 ואילך
- גרסת torchxla[tpuvm] מומלצת: גרסה 2.1.0 ואילך
TPU v5e
tpu-v5-lite-podslice
- קובץ אימג' מומלץ של JAX AI: jax0.4.35-rev1 ואילך
- גרסת jax[tpu] מומלצת: v0.4.9 ואילך
- גרסת torchxla[tpuvm] מומלצת: גרסה 2.1.0 ואילך
TPU v5p
tpu-v5p-slice- קובץ אימג' מומלץ של JAX AI: jax0.4.35-rev1 ואילך
- גרסת jax[tpu] מומלצת: 0.4.19 ואילך.
- גרסת torchxla[tpuvm] מומלצת: מומלץ להשתמש בגרסת build לילית מ-23 באוקטובר 2023.
TPU v4
tpu-v4-podslice- קובץ אימג' מומלץ של JAX AI: jax0.4.35-rev1 ואילך
- jax[tpu] מומלץ: גרסה 0.4.4 ואילך
- torchxla[tpuvm] מומלץ: גרסה 2.0.0 ואילך
TPU v3
tpu-v3-slice
tpu-v3-device- קובץ אימג' מומלץ של JAX AI: jax0.4.35-rev1 ואילך
- jax[tpu] מומלץ: גרסה 0.4.4 ואילך
- torchxla[tpuvm] מומלץ: גרסה 2.0.0 ואילך
- במניפסט של עומס העבודה, מוסיפים בוררי צמתים של Kubernetes כדי לוודא ש-GKE מתזמן את עומס העבודה של ה-TPU בסוג המכונה ובטופולוגיה של ה-TPU שהגדרתם:
nodeSelector: cloud.google.com/gke-tpu-accelerator: TPU_ACCELERATOR cloud.google.com/gke-tpu-topology: TPU_TOPOLOGY cloud.google.com/placement-policy-name: WORKLOAD_POLICY # Required only for Ironwood (TPU7x)מחליפים את מה שכתוב בשדות הבאים:
-
TPU_ACCELERATOR: השם של מאיץ ה-TPU. לדוגמה, אפשר להשתמש ב-tpu7x-standard-4t. -
TPU_TOPOLOGY: הטופולוגיה הפיזית של פרוסת ה-TPU. הפורמט של הטופולוגיה תלוי בגרסת ה-TPU. לדוגמה, אפשר להשתמש ב-2x2x2. מידע נוסף זמין במאמר תכנון יחידות TPU ב-GKE. -
WORKLOAD_POLICY: השם של מדיניות עומס העבודה שבה רוצים להשתמש כדי למקם את ה-TPU Pods. בורר הצמתים הזה נדרש רק ל-Ironwood (TPU7x).
-
אחרי שמסיימים להכין את עומס העבודה, אפשר להריץ משימה שמשתמשת ב-TPU.
בקטעים הבאים מוצגות דוגמאות להרצת משימה שמבצעת חישוב בסיסי באמצעות יחידות TPU.
הרצת עומס העבודה בצומתי פרוסות TPU
בקטע הזה מוסבר איך להכין את עומסי העבודה ומוצגות דוגמאות להרצת עומסי העבודה.
דוגמה 1: הפעלת פריסה שמבקשת יחידות TPU במפרט של ה-Pod
gcloud
GKE משתמש בהגדרות ב-Pod או ב-ComputeClass כדי לקבוע את ההגדרות של צומתי ה-TPU. המניפסט הבא הוא דוגמה למפרט פריסה שמבקש יחידות TPU במפרט Pod. אם ההגדרה של הקצאת צמתים אוטומטית ברמת האשכול מופעלת, הפריסה הזו מפעילה יצירה אוטומטית של מאגר צמתים. כשיוצרים את ה-Deployment לדוגמה, GKE יוצר מאגר צמתים שמכיל פרוסת TPU v4 עם טופולוגיית 2x2x2 ושתי מכונות ct4p-hightpu-4t.
apiVersion: apps/v1
kind: Deployment
metadata:
name: tpu-workload
labels:
app: tpu-workload
spec:
replicas: 2
template:
spec:
nodeSelector:
cloud.google.com/gke-tpu-accelerator: tpu-v4-podslice
cloud.google.com/gke-tpu-topology: 2x2x2
containers:
- name: tpu-job
image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
ports:
- containerPort: 8431 # Port to export TPU runtime metrics, if supported.
securityContext:
privileged: true # Required for GKE versions earlier than 1.28 to access TPUs.
command:
- bash
- -c
- |
python -c 'import jax; print("Total TPU chips:", jax.device_count())'
resources:
requests:
google.com/tpu: 4
limits:
google.com/tpu: 4
ports:
- containerPort: 80
במניפסט הזה, השדות הבאים מגדירים את הגדרות ה-TPU:
-
cloud.google.com/gke-tpu-accelerator: הגרסה והסוג של ה-TPU. לדוגמה, משתמשים ב-tpu7x-standard-4tל-Ironwood (TPU7x). -
cloud.google.com/gke-tpu-topology: הטופולוגיה עם המספר והסידור הפיזי של שבבי TPU בתוך פרוסת TPU. לדוגמה, משתמשים ב-2x2x2. -
limits.google.com/tpu: מספר שבבי ה-TPU לכל מכונה וירטואלית. לדוגמה, אם משתמשים ב-tpu7x-standard-4t, מספר שבבי ה-TPU לכל VM הוא4.
Cluster Toolkit
שולחים את עומס העבודה באמצעות הפקודה gcluster job submit. מידע נוסף על האפשרויות לשליחת משימות מופיע במדריך לשליחת משימות ב-Cluster Toolkit:
gcluster job submit \
--name=WORKLOAD_NAME \
--cluster=DEPLOYMENT_NAME \
--project=PROJECT_ID \
--location=ZONE \
--compute-type=COMPUTE_TYPE \
--topology=TOPOLOGY \
--num-slices=1 \
--image=us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest \
--command="python -c 'import jax; print(\"TPU cores:\", jax.device_count())'"
מחליפים את מה שכתוב בשדות הבאים:
-
WORKLOAD_NAME: השם של עומס העבודה. -
DEPLOYMENT_NAME: השם של פריסת Cluster Toolkit (שהוא גם השם של אשכול GKE). -
PROJECT_ID: מזהה הפרויקט ב- Google Cloud . -
ZONE: שם האזור בהתאם לגרסת ה-TPU שבה רוצים להשתמש. כדי לזהות מיקום זמין, עיינו במאמר זמינות של TPU ב-GKE. -
COMPUTE_TYPE: סוג המחשוב שתואם לסוג המאיץ של מאגר הצמתים, לדוגמהv6e-16,tpu7x-standard-4tאוv5e-8. -
TOPOLOGY: הטופולוגיה הפיזית שתואמת למאגר הצמתים, לדוגמה,2x4או2x2x2.
דוגמה 2: הרצת עומס עבודה שמציג את מספר שבבי ה-TPU הזמינים במאגר צמתים של פרוסת TPU
עומס העבודה הבא מחזיר את מספר שבבי ה-TPU בכל הצמתים בפרוסת TPU עם כמה מארחים. כדי ליצור פרוסה עם כמה מארחים, עומס העבודה צריך לכלול את הפרמטרים הבאים:
- גרסת ה-TPU: TPU v4
- טופולוגיה: 2x2x4
הבחירה בגרסה ובטופולוגיה הזו יוצרת פרוסה עם כמה מארחים.
- שומרים את המניפסט הבא בתור
available-chips-multihost.yaml:apiVersion: v1 kind: Service metadata: name: headless-svc spec: clusterIP: None selector: job-name: tpu-available-chips --- apiVersion: batch/v1 kind: Job metadata: name: tpu-available-chips spec: backoffLimit: 0 completions: 4 parallelism: 4 completionMode: Indexed template: spec: subdomain: headless-svc restartPolicy: Never nodeSelector: cloud.google.com/gke-tpu-accelerator: tpu-v4-podslice # Node selector to target TPU v4 slice nodes. cloud.google.com/gke-tpu-topology: 2x2x4 # Specifies the physical topology for the TPU slice. containers: - name: tpu-job image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest ports: - containerPort: 8471 # Default port using which TPU VMs communicate - containerPort: 8431 # Port to export TPU runtime metrics, if supported. securityContext: privileged: true # Required for GKE versions earlier than 1.28 to access TPUs. command: - bash - -c - | python -c 'import jax; print("TPU cores:", jax.device_count())' # Python command to count available TPU chips. resources: requests: cpu: 10 memory: 407Gi google.com/tpu: 4 # Request 4 TPU chips for this workload. limits: cpu: 10 memory: 407Gi google.com/tpu: 4 # Limit to 4 TPU chips for this workload.
- פורסים את המניפסט:
kubectl create -f available-chips-multihost.yaml
GKE מריץ פרוסת TPU v4 עם ארבע מכונות וירטואליות (פרוסת TPU עם כמה מארחים). הפרוסה כוללת 16 שבבי TPU שמחוברים ביניהם.
- מוודאים שהמשימה יצרה ארבעה Pods:
kubectl get pods
הפלט אמור להיראות כך:
NAME READY STATUS RESTARTS AGE tpu-job-podslice-0-5cd8r 0/1 Completed 0 97s tpu-job-podslice-1-lqqxt 0/1 Completed 0 97s tpu-job-podslice-2-f6kwh 0/1 Completed 0 97s tpu-job-podslice-3-m8b5c 0/1 Completed 0 97s
- משיגים את היומנים של אחד מה-Pods:
kubectl logs POD_NAME
מחליפים את
POD_NAMEבשם של אחד מהפודים שנוצרו. לדוגמה,tpu-job-podslice-0-5cd8r.הפלט אמור להיראות כך:
TPU cores: 16
- אופציונלי: מסירים את עומס העבודה:
kubectl delete -f available-chips-multihost.yaml
דוגמה 3: הרצת עומס עבודה שמציג את מספר שבבי ה-TPU הזמינים בפרוסת ה-TPU
עומס העבודה הבא הוא Pod סטטי שמציג את מספר שבבי ה-TPU שמחוברים לצומת ספציפי. כדי ליצור צומת מארח יחיד, עומס העבודה כולל את הפרמטרים הבאים:
- גרסת ה-TPU: TPU v5e
- טופולוגיה: 2x4
הבחירה בגרסה ובטופולוגיה הזו יוצרת פרוסה של מארח יחיד.
- שומרים את המניפסט הבא בתור
available-chips-singlehost.yaml:apiVersion: v1 kind: Pod metadata: name: tpu-job-jax-v5 spec: restartPolicy: Never nodeSelector: cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice # Node selector to target TPU v5e slice nodes. cloud.google.com/gke-tpu-topology: 2x4 # Specify the physical topology for the TPU slice. containers: - name: tpu-job image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest ports: - containerPort: 8431 # Port to export TPU runtime metrics, if supported. securityContext: privileged: true # Required for GKE versions earlier than 1.28 to access TPUs. command: - bash - -c - | python -c 'import jax; print("Total TPU chips:", jax.device_count())' resources: requests: google.com/tpu: 8 # Request 8 TPU chips for this container. limits: google.com/tpu: 8 # Limit to 8 TPU chips for this container.
- פורסים את המניפסט:
kubectl create -f available-chips-singlehost.yaml
GKE מקצה צמתים עם שמונה פרוסות TPU במארח יחיד שמשתמשות ב-TPU v5e. לכל צומת TPU יש שמונה שבבי TPU (פרוסת TPU במארח יחיד).
- משיגים את היומנים של ה-Pod:
kubectl logs tpu-job-jax-v5
הפלט אמור להיראות כך:
Total TPU chips: 8
- אופציונלי: מסירים את עומס העבודה:
kubectl delete -f available-chips-singlehost.yaml
דוגמה 4: הפעלת עומס עבודה שמטרגט שני צומתי NUMA
כדי לשפר את הביצועים של עומסי העבודה, ב-GKE אפשר לפרוס את עומסי העבודה בהגדרה של כמה קונטיינרים. כך כל קונטיינר מקושר למשאבי המעבד (CPU), הזיכרון וה-TPU בצומת NUMA נתון. מידע נוסף על קישור NUMA זמין במאמר מידע על Ironwood (TPU7x) ב-GKE.
יוצרים קובץ בשם
topology-manager-config.yamlעם התוכן הבא:kubeletConfig: cpuManagerPolicy: static topologyManager: policy: best-effort scope: containerההגדרה הזו מתאימה את המשאבים שנדרשים על ידי קונטיינר לצומת NUMA יחיד. ההגדרה הזו נדרשת כדי ש-GKE יקבל ויקצה שבבים בצורה נכונה לעומסי עבודה של TPU עם כמה קונטיינרים. אפשרויות מדיניות נוספות מפורטות במאמר Topology Manager Policies.
מחילים את ההגדרה
kubeletעל מאגר צמתים על ידי יצירת מאגר צמתים חדש או עדכון של מאגר קיים. מאגר הצמתים הזה חייב להשתמש בצמתים של Ironwood (TPU7x), כמו סוג המכונהtpu7x-standard-4t, כדי להתאים לבורר הצמתים בשלב הבא.כדי ליצור מאגר צמתים חדש עם Topology Manager מופעל:
gcloud container node-pools create NODE_POOL_NAME \ --location=LOCATION \ --cluster=CLUSTER_NAME \ --node-locations=NODE_ZONES \ --machine-type=tpu7x-standard-4t \ --system-config-from-file=topology-manager-config.yamlמחליפים את מה שכתוב בשדות הבאים:
-
NODE_POOL_NAME: השם של מאגר הצמתים החדש. -
LOCATION: האזור של האשכול. -
CLUSTER_NAME: שם האשכול. -
NODE_ZONES: רשימה מופרדת בפסיקים של אזור אחד או יותר למאגר הצמתים.
-
כדי לעדכן מאגר צמתים קיים שבו מנהל הטופולוגיה מופעל:
gcloud container node-pools update NODE_POOL_NAME \ --location=LOCATION \ --cluster=CLUSTER_NAME \ --system-config-from-file=topology-manager-config.yamlמחליפים את מה שכתוב בשדות הבאים:
-
NODE_POOL_NAME: שם מאגר הצמתים. -
LOCATION: האזור של האשכול. -
CLUSTER_NAME: שם האשכול.
-
יוצרים קובץ בשם
tpu-jobset.yamlעם המניפסט הבא:apiVersion: jobset.x-k8s.io/v1alpha2 kind: JobSet metadata: name: tpu7x-test spec: failurePolicy: maxRestarts: 0 replicatedJobs: - name: tpu7x replicas: 1 template: spec: parallelism: 2 completions: 2 backoffLimit: 0 template: spec: subdomain: test restartPolicy: Never nodeSelector: cloud.google.com/gke-tpu-accelerator: tpu7x cloud.google.com/gke-tpu-topology: 2x2x2 containers: - name: jax-tpu-1 image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest securityContext: privileged: false command: - bash - -c - | set -ex python -c 'import jax; print("local devices:", jax.local_device_count(), "devices:", jax.device_count())' resources: requests: google.com/tpu: 2 limits: google.com/tpu: 2 - name: jax-tpu-2 image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest securityContext: privileged: false command: - bash - -c - | set -ex python -c 'import jax; print("local devices:", jax.local_device_count(), "devices:", jax.device_count())' resources: requests: google.com/tpu: 2 limits: google.com/tpu: 2המניפסט הזה מגדיר
JobSetבשםtpu7x-test, שמריץ שני קונטיינרים ראשיים,jax-tpu-1ו-jax-tpu-2. כל מאגר תגים מבקש שני צ'יפים שלgoogle.com/tpu. שני השבבים האלה מגיעים מאותו צומת NUMA. כל קונטיינר מריץ סקריפט Python כדי לאמת את הגישה של JAX ל-TPU.ההגדרה הזו של JobSet מראה שכמה קונטיינרים באותו Pod יכולים לגשת לשבבי TPU נפרדים ולהשתמש בהם.
מחילים את המניפסט:
kubectl apply -f tpu-jobset.yaml
דוגמה 5: הפעלת עומס עבודה של TPU עם כמה קונטיינרים באמצעות אמצעי אחסון של Cloud Storage FUSE עם כמה כרטיסי רשת
הדוגמה הזו מרחיבה את דוגמה 4 וכוללת טעינה של קטגוריות Cloud Storage FUSE כנפחים באמצעות Cloud Storage FUSE. ההגדרה הזו משתמשת ביכולות של multi-NIC כדי לשפר את ביצועי הרשת.
יוצרים קובץ בשם
tpu7x-gcsfuse-multinic.yamlעם המניפסט הבא:apiVersion: jobset.x-k8s.io/v1alpha2 kind: JobSet metadata: name: tpu7x-gcsfuse-multinic spec: failurePolicy: maxRestarts: 0 replicatedJobs: - name: tpu7x replicas: 1 template: spec: parallelism: 2 completions: 2 backoffLimit: 0 template: spec: subdomain: test restartPolicy: Never nodeSelector: cloud.google.com/gke-tpu-accelerator: tpu7x cloud.google.com/gke-tpu-topology: 2x2x2 hostNetwork: true volumes: - name: gcs0 csi: driver: gcsfuse.csi.storage.gke.io volumeAttributes: bucketName: BUCKET_NAME multiNICIndex: "0" mountOptions: implicit-dirs hostNetworkPodKSA: "true" - name: gcs1 csi: driver: gcsfuse.csi.storage.gke.io volumeAttributes: bucketName: BUCKET_NAME multiNICIndex: "1" mountOptions: implicit-dirs hostNetworkPodKSA: "true" containers: - name: jax-tpu-1 image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest securityContext: privileged: false command: - bash - -c - | set -ex python -c 'import jax; print("local devices:", jax.local_device_count(), "devices:", jax.device_count())' echo "Use /gcs${WORKLOAD_NIC_PREFERRED_NUMA}/ for Cloud Storage access" resources: requests: google.com/tpu: 2 limits: google.com/tpu: 2 volumeMounts: - name: gcs0 mountPath: /gcs0 readOnly: false - name: gcs1 mountPath: /gcs1 readOnly: false - name: jax-tpu-2 image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest securityContext: privileged: false command: - bash - -c - | set -ex python -c 'import jax; print("local devices:", jax.local_device_count(), "devices:", jax.device_count())' echo "Use /gcs${WORKLOAD_NIC_PREFERRED_NUMA}/ for Cloud Storage access" resources: requests: google.com/tpu: 2 limits: google.com/tpu: 2 volumeMounts: - name: gcs0 mountPath: /gcs0 readOnly: false - name: gcs1 mountPath: /gcs1 readOnly: falseהמניפסט הזה מוסיף את נקודות ה-mount הבאות של Cloud Storage FUSE לדוגמה 4.
- הערך
multiNICIndexמצוין במאפייני אמצעי האחסון כדי להשתמש בממשק הרשת בצומת NUMA המתאים לכל אמצעי אחסון. - עומס העבודה משתמש במשתנה הסביבה
${WORKLOAD_NIC_PREFERRED_NUMA}כדי לבחור את הנפח של Cloud Storage FUSE שמשויך לצומת ה-NUMA שהקונטיינר מוקצה לו. GKE מוסיף את המשתנה הזה לקונטיינרים בעומסי עבודה של Cloud TPU.
מחליפים את
BUCKET_NAMEבשם הקטגוריה שלכם ב-Cloud Storage.- הערך
מחילים את המניפסט:
kubectl apply -f tpu7x-gcsfuse-multinic.yaml
שדרוג מאגרי צמתים באמצעות מאיצים (GPU ו-TPU)
GKE משדרג באופן אוטומטי אשכולות Standard, כולל מאגרי צמתים. אם אתם רוצים שהצמתים יפעלו בגרסה מאוחרת יותר, אתם יכולים גם לשדרג ידנית את מאגרי הצמתים. כדי לשלוט באופן השדרוג של האשכול, אתם יכולים להשתמש בערוצי הפצה, בחלונות זמן לתחזוקה והחרגות וברצף השקות.
אתם יכולים גם להגדיר אסטרטגיית שדרוג צמתים למאגר הצמתים, כמו שדרוגי מתח, שדרוגים כחולים-ירוקים או שדרוגים קצרי-מועד. הגדרת האסטרטגיות האלה מאפשרת לשדרג את מאגרי הצמתים באופן שמאזן בצורה אופטימלית בין המהירות לבין ההפרעה לסביבה. במאגרי צמתים של פרוסות TPU עם כמה מארחים, במקום להשתמש באסטרטגיית השדרוג שהוגדרה לצמתים, GKE יוצר מחדש באופן אטומי את כל מאגר הצמתים בשלב אחד. למידע נוסף, קראו את ההגדרה של אטומיות במאמר טרמינולוגיה שקשורה ל-TPU ב-GKE.
כשמשתמשים באסטרטגיית שדרוג של צומת, GKE צריך להקצות באופן זמני משאבים נוספים, בהתאם להגדרות האישיות. אם הקיבולת של Google Cloudלמשאבים של מאגר הצמתים מוגבלת – לדוגמה, אם מופיעות שגיאות של זמינות משאבים כשמנסים ליצור עוד צמתים עם GPUs או TPUs – קראו את המאמר שדרוג בסביבה עם משאבים מוגבלים.
הסרת המשאבים
כדי להימנע מחיובים בחשבון Google Cloud על המשאבים שבהם השתמשתם במדריך הזה, כדאי למחוק את מאגרי הצמתים של פרוסות ה-TPU שאין בהם יותר עומסי עבודה מתוזמנים. אם צריך לסיים את עומסי העבודה שפועלים בצורה תקינה, השתמשו ב-kubectl drain כדי לנקות את עומסי העבודה לפני שאתם מוחקים את הצומת.
gcloud
מחיקת מאגר צמתים של פרוסת TPU:
gcloud container node-pools delete POOL_NAME \
--location=LOCATION \
--cluster=CLUSTER_NAME
מחליפים את מה שכתוב בשדות הבאים:
-
POOL_NAME: שם מאגר הצמתים. -
LOCATION: מיקום המחשוב של האשכול. -
CLUSTER_NAME: שם האשכול.
Cluster Toolkit
מוחקים את הפריסה של Cluster Toolkit:
gcluster destroy DEPLOYMENT_NAME
מחליפים את DEPLOYMENT_NAME בשם של ספריית הפריסה שנוצרה כשפרסתם את התוכנית.
קביעת הגדרות נוספות
בקטעים הבאים מתוארות הגדרות נוספות שאפשר להחיל על עומסי העבודה של ה-TPU.
שימוש בריבוי-פרוסות (Multislice)
אפשר לצבור פרוסות קטנות יותר יחד בריבוי-פרוסות (Multislice) כדי לטפל בעומסי עבודה גדולים יותר של אימון. מידע נוסף זמין במאמר יחידות TPU עם ריבוי פרוסות ב-GKE.
העברת ההזמנה של ה-TPU
אם יש לכם מקומות שמורים קיימים ל-TPU, קודם אתם צריכים להעביר אותם למערכת חדשה של מקומות שמורים שמבוססת על Compute Engine. אתם יכולים גם ליצור מערכת להזמנת מקומות שמבוססת על Compute Engine, שבה אין צורך בהעברה. במאמר הזמנת TPU מוסבר איך מעבירים את הזמנות ה-TPU.
הפעלת הרישום ביומן
היומנים שנוצרים על ידי קונטיינרים שפועלים בצומתי GKE, כולל מכונות וירטואליות של TPU, נאספים על ידי סוכן Logging של GKE, נשלחים ל-Logging ומוצגים ב-Logging.
הגדרת תיקון אוטומטי לצומתי פרוסות TPU
אם צומת של פרוסת TPU במאגר צמתים של פרוסות TPU עם כמה מארחים לא תקין, כל מאגר הצמתים נוצר מחדש. לעומת זאת, במאגר צמתים של פרוסות TPU עם מארח יחיד, רק צומת ה-TPU הלא תקין מתוקן באופן אוטומטי.
התנאים שגורמים לצומתי פרוסות TPU לא תקינים כוללים:
- כל צומת של פרוסת TPU עם תנאים נפוצים של צומת.
- כל צומת של פרוסת TPU עם מספר יחידות TPU שלא ניתן להקצות שגדול מאפס.
- כל מכונה וירטואלית בפרוסת TPU שנעצרה (בגלל הפקעה) או שהופסקה.
- תחזוקת צמתים: אם צומת פרוסת TPU כלשהו במאגר צמתים של פרוסות TPU עם כמה מארחים מושבת לצורך תחזוקת המארח, GKE יוצר מחדש את כל מאגר הצמתים של פרוסות ה-TPU.
אפשר לראות את סטטוס התיקון (כולל הסיבה לכישלון) בהיסטוריית הפעולות. אם הכשל נגרם בגלל מכסה לא מספיקה, פנו לאיש הקשר האחראי לחשבון שלכם ב-Google Cloud כדי להגדיל את המכסה המתאימה.
הגדרת סגירה מבוקרת לצומתי פרוסות TPU
באשכולות GKE שבהם מישור הבקרה מריץ את גרסה 1.29.1-gke.1425000 ואילך, צומתי פרוסות TPU תומכים באותות SIGTERM שמתריעים לצומת על השבתה קרובה. בצומתי TPU, אפשר להגדיר את ההתראה על השבתה קרובה עד חמש דקות.
כדי להגדיר את GKE כך שיסיים את עומסי העבודה בצורה תקינה במסגרת הזמן של ההתראה, פועלים לפי השלבים שמפורטים במאמר ניהול השיבושים בצומתי GKE עבור GPUs ו-TPUs.
מניעת מצבים שבהם אי אפשר לקבוע פגישות
כשמריצים כמה משימות TPU או כמה רפליקות של משימה, אפשר לתזמן פודים ממשימות שונות באותו מאגר צמתים של TPU. זה יכול לגרום למבוי סתום בתזמון, שבו אף אחד מה-Jobs לא יכול להבטיח מספיק צמתים כדי להשלים את הטופולוגיה שלו.
כדי להפחית את הסיכון למבוי סתום בתזמון, אפשר להשתמש באחת מההגדרות הבאות:
- משתמשים בכללי Pod anti-affinity כדי לוודא שפודים ממשימות שונות לא מתוזמנים באותו מאגר צמתים או באותו דומיין טופולוגיה של TPU.
- משתמשים בהערה
jobset.sigs.k8s.io/exclusive-topology, שגורמת ל-JobSet לתבוע את דומיין הטופולוגיה שצוין (כמו מאגר צמתים) באופן בלעדי לפודים שלו.
דוגמאות מפורטות להגדרות ושלבים לפתרון בעיות מופיעים במאמר מבוי סתום בתזמון.
הפעלת קונטיינרים בלי מצב הרשאות
בקונטיינרים שפועלים בצמתים ב-GKE בגרסה 1.28 ואילך, לא צריך להפעיל מצב הרשאות כדי לגשת ל-TPU. צמתים ב-GKE בגרסה 1.28 ומטה דורשים מצב הרשאות.
אם בצומת של פרוסת ה-TPU פועלת גרסה ישנה יותר מ-1.28, קראו את הקטע הבא:
קונטיינר שפועל ב-VM בפרוסת TPU צריך גישה למגבלות גבוהות יותר בזיכרון הנעול, כדי שמנהל ההתקן יוכל לתקשר עם שבבי ה-TPU באמצעות גישה ישירה לזיכרון (DMA). כדי להפעיל את האפשרות הזו, צריך להגדיר ערך גבוה יותר של ulimit. כדי לצמצם את היקף ההרשאות במאגר, צריך לבצע את הפעולות הבאות:
עורכים את
securityContextכך שיכלול את השדות הבאים:securityContext: capabilities: add: ["SYS_RESOURCE"]כדי להגדיל את
ulimit, מריצים את הפקודה הבאה בתוך הקונטיינר לפני שמגדירים את עומסי העבודה לשימוש במשאבי TPU:ulimit -l 68719476736
ב-TPU v5e, אפשר להריץ קונטיינרים בלי מצב הרשאות באשכולות בגרסה 1.27.4-gke.900 ואילך.
ניראות ומדדים
מרכז שליטה
התכונה "תצפיתיות על מאגר צמתים" זמינה לכלל המשתמשים במסוףGoogle Cloud . כדי לראות את הסטטוס של מאגרי הצמתים של TPU עם כמה מארחים ב-GKE, נכנסים ללוח הבקרה GKE TPU Node Pool Status שסופק על ידי Cloud Monitoring:
מעבר לסטטוס של מאגר הצמתים של TPU ב-GKE
בלוח הבקרה הזה אפשר לקבל תובנות מקיפות על התקינות של מאגרי הצמתים של TPU עם כמה מארחים. מידע נוסף זמין במאמר מעקב אחרי מדדי תקינות של צומתי TPU ומאגרי צמתים.
במסוףGoogle Cloud , בדף Kubernetes Clusters, בכרטיסייה Observability מוצגים גם מדדי תצפית של TPU, כמו השימוש ב-TPU, בכותרת Accelerators > TPU. מידע נוסף זמין במאמר הצגת מדדי ניראות.
לוח הבקרה של ה-TPU מאוכלס רק אם הפעלתם את מדדי המערכת באשכול GKE.
מדדי זמן ריצה
ב-GKE בגרסה 1.27.4-gke.900 ואילך, עומסי עבודה של TPU שמשתמשים ב-JAX בגרסה 0.4.14 ואילך ומציינים את containerPort: 8431 מייצאים מדדי ניצול של TPU כמדדי מערכת של GKE.
המדדים הבאים זמינים ב-Cloud Monitoring כדי לעקוב אחרי ביצועי זמן הריצה של עומס העבודה ב-TPU:
- Duty cycle: אחוז הזמן בתקופת הדגימה האחרונה (60 שניות) שבה ליבות Tensor עיבדו באופן פעיל בשבב TPU. ככל שהאחוז גבוה יותר, כך ניצול ה-TPU טוב יותר.
- זיכרון בשימוש: כמות הזיכרון של המאיץ שהוקצתה, בבייטים. נדגמים כל 60 שניות.
- Memory total: סך הזיכרון של המאיץ בבייטים. נדגם כל 60 שניות.
המדדים האלה נמצאים בסכימה של צומת Kubernetes (k8s_node) ושל קונטיינר Kubernetes (k8s_container).
קונטיינר של Kubernetes:
kubernetes.io/container/accelerator/duty_cyclekubernetes.io/container/accelerator/memory_usedkubernetes.io/container/accelerator/memory_total
צומת Kubernetes:
kubernetes.io/node/accelerator/duty_cyclekubernetes.io/node/accelerator/memory_usedkubernetes.io/node/accelerator/memory_total
מעקב אחרי מדדי התקינות של צומתי TPU ומאגרי צמתים
אם משימת אימון נכשלת או מסתיימת בשגיאה, אתם יכולים לבדוק את המדדים שקשורים לתשתית הבסיסית כדי להבין אם ההפרעה נגרמה בגלל בעיה בצומת או במאגר הצמתים הבסיסי.
סטטוס הצומת
בגרסה 1.32.1-gke.1357001 ואילך של GKE, המדד הבא של מערכת GKE חושף את המצב של צומת GKE:
kubernetes.io/node/status_condition
בשדה condition מדווחים התנאים בצומת, כמו Ready, DiskPressure ו-MemoryPressure. בשדה status מוצג הסטטוס המדווח של התנאי, שיכול להיות True, False או Unknown. זהו מדד עם סוג המשאב במעקב k8s_node.
השאילתה הזו ב-PromQL מראה אם צומת מסוים הוא Ready:
kubernetes_io:node_status_condition{
monitored_resource="k8s_node",
cluster_name="CLUSTER_NAME",
node_name="NODE_NAME",
condition="Ready",
status="True"}
כדי לפתור בעיות באשכול, כדאי לבדוק צמתים שבהם התקיימו תנאים אחרים:
kubernetes_io:node_status_condition{
monitored_resource="k8s_node",
cluster_name="CLUSTER_NAME",
condition!="Ready",
status="True"}
כדאי לבדוק באופן ספציפי צמתים שהם לא Ready:
kubernetes_io:node_status_condition{
monitored_resource="k8s_node",
cluster_name="CLUSTER_NAME",
condition="Ready",
status="False"}
אם אין נתונים, הצמתים מוכנים. מצב הסטטוס נדגם כל 60 שניות.
אתם יכולים להשתמש בשאילתה הבאה כדי להבין את סטטוס הצומת בכל ה-fleet:
avg by (condition,status)(
avg_over_time(
kubernetes_io:node_status_condition{monitored_resource="k8s_node"}[${__interval}]))
סטטוס מאגר הצמתים
מדד המערכת של GKE הבא, למשאב k8s_node_pool שבמעקב, חושף את הסטטוס של מאגר הצמתים ב-GKE:
kubernetes.io/node_pool/status
המדד הזה מדווח רק למאגרי צמתים של TPU עם כמה מארחים.
בשדה status מדווח הסטטוס של מאגר הצמתים, למשל Provisioning, Running, Error, Reconciling או Stopping. עדכוני הסטטוס מתרחשים אחרי שפעולות ה-API של GKE מסתיימות.
כדי לבדוק אם למאגר צמתים מסוים יש סטטוס Running, משתמשים בשאילתת PromQL הבאה:
kubernetes_io:node_pool_status{
monitored_resource="k8s_node_pool",
cluster_name="CLUSTER_NAME",
node_pool_name="NODE_POOL_NAME",
status="Running"}
כדי לעקוב אחרי מספר מאגרי הצמתים בפרויקט, מקובצים לפי הסטטוס שלהם, משתמשים בשאילתת PromQL הבאה:
count by (status)(
count_over_time(
kubernetes_io:node_pool_status{monitored_resource="k8s_node_pool"}[${__interval}]))
זמינות של מאגר צמתים
המדד הבא של מערכת GKE מראה אם מאגר צומתי TPU עם כמה מארחים זמין:
kubernetes.io/node_pool/multi_host/available
הערך של המדד הוא True אם כל הצמתים במאגר הצמתים זמינים, ואחרת הערך הוא False. המדד נדגם כל 60 שניות.
כדי לבדוק את הזמינות של מאגרי צמתים של TPU עם כמה מארחים בפרויקט, משתמשים בשאילתת PromQL הבאה:
avg by (node_pool_name)(
avg_over_time(
kubernetes_io:node_pool_multi_host_available{
monitored_resource="k8s_node_pool",
cluster_name="CLUSTER_NAME"}[${__interval}]))
מספר ההפרעות בצומת
המדד הבא של מערכת GKE מדווח על מספר ההפרעות לצומת GKE מאז הדגימה האחרונה (המדד נדגם כל 60 שניות):
kubernetes.io/node/interruption_count
השדות interruption_type (כמו TerminationEvent, MaintenanceEvent או PreemptionEvent) ו-interruption_reason (כמו HostError, Eviction או AutoRepair) יכולים לעזור להבין למה הצומת הופסק.
כדי לקבל פירוט של ההפרעות והגורמים להן בצומתי TPU באשכולות בפרויקט, משתמשים בשאילתת PromQL הבאה:
sum by (interruption_type,interruption_reason)(
sum_over_time(
kubernetes_io:node_interruption_count{monitored_resource="k8s_node"}[${__interval}]))
כדי לראות רק את אירועי התחזוקה של המארח, מעדכנים את השאילתה כדי לסנן את הערך HW/SW Maintenance של interruption_reason. משתמשים בשאילתת PromQL הבאה:
sum by (interruption_type,interruption_reason)(
sum_over_time(
kubernetes_io:node_interruption_count{monitored_resource="k8s_node", interruption_reason="HW/SW Maintenance"}[${__interval}]))
כדי לראות את מספר ההפסקות המצטבר לפי מאגר צמתים, משתמשים בשאילתת PromQL הבאה:
sum by (node_pool_name,interruption_type,interruption_reason)(
sum_over_time(
kubernetes_io:node_pool_interruption_count{monitored_resource="k8s_node_pool", interruption_reason="HW/SW Maintenance", node_pool_name=NODE_POOL_NAME }[${__interval}]))
זמני השחזור (TTR) של מאגר הצמתים
המדד הבא של מערכת GKE מדווח על התפלגות משך תקופת השחזור של מאגרי צמתים של TPU עם כמה מארחים ב-GKE:
kubernetes.io/node_pool/accelerator/times_to_recover
כל דגימה שמתועדת במדד הזה מציינת אירוע שחזור אחד של מאגר הצמתים מתקופת השבתה.
המדד הזה שימושי למעקב אחרי הזמן עד לשחזור והזמן בין ההפרעות של מאגר צומתי TPU עם כמה מארחים.
אתם יכולים להשתמש בשאילתת PromQL הבאה כדי לחשב את הזמן הממוצע להתאוששות (MTTR) ב-7 הימים האחרונים באשכול:
sum(sum_over_time(
kubernetes_io:node_pool_accelerator_times_to_recover_sum{
monitored_resource="k8s_node_pool", cluster_name="CLUSTER_NAME"}[7d]))
/
sum(sum_over_time(
kubernetes_io:node_pool_accelerator_times_to_recover_count{
monitored_resource="k8s_node_pool",cluster_name="CLUSTER_NAME"}[7d]))
זמן בין הפרעות (TBI) במאגר צמתים
המדד הבא של מערכת GKE מדווח על התפלגות הזמנים בין סוף ההפרעה האחרונה לבין תחילת ההפרעה הנוכחית, במאגרים של צומתי TPU עם כמה מארחים ב-GKE:
kubernetes.io/node_pool/accelerator/times_between_interruptions
כל דגימה שמתועדת במדד הזה מציינת משך זמן אחד בין ההפרעה האחרונה להפרעה הנוכחית.
כדי לחשב את הזמן הממוצע בין הפסקות (MTBI) באשכול ב-7 הימים הקודמים, משתמשים בשאילתת PromQL הבאה:
sum(sum_over_time(
kubernetes_io:node_pool_accelerator_times_between_interruptions_sum{
monitored_resource="k8s_node_pool", cluster_name="CLUSTER_NAME"}[7d]))
/
sum(sum_over_time(
kubernetes_io:node_pool_accelerator_times_between_interruptions_count{
monitored_resource="k8s_node_pool",cluster_name="CLUSTER_NAME"}[7d]))
מדדי מארחים
בגרסה 1.28.1-gke.1066000 של GKE ואילך, מכונות וירטואליות בפרוסת TPU מייצאות מדדי ניצול של TPU כמדדי מערכת של GKE. המדדים הבאים זמינים ב-Cloud Monitoring כדי לעקוב אחרי הביצועים של מארח ה-TPU:
- TensorCore utilization: אחוז הניצול הנוכחי של TensorCore. הערך של TensorCore שווה לסכום של יחידות הכפל של המטריצה (MXU) פלוס היחידה הווקטורית. ערך הניצול של TensorCore הוא חלוקה של פעולות TensorCore שבוצעו בתקופת הדגימה האחרונה (60 שניות) במספר פעולות TensorCore שנתמכות באותה תקופה. ככל שהערך גדול יותר, כך הניצול טוב יותר.
- Memory bandwidth utilization: האחוז הנוכחי של רוחב הפס של זיכרון המאיץ שנמצא בשימוש. הערך מחושב על ידי חלוקת רוחב הפס של הזיכרון שנעשה בו שימוש בתקופת דגימה (60 שניות) ברוחב הפס המקסימלי שנתמך באותה תקופת דגימה.
המדדים האלה נמצאים בסכימה של צומת Kubernetes (k8s_node) ושל קונטיינר Kubernetes (k8s_container).
קונטיינר של Kubernetes:
kubernetes.io/container/accelerator/tensorcore_utilizationkubernetes.io/container/accelerator/memory_bandwidth_utilization
צומת Kubernetes:
kubernetes.io/node/accelerator/tensorcore_utilizationkubernetes.io/node/accelerator/memory_bandwidth_utilization
למידע נוסף, קראו את המאמרים מדדי Kubernetes ומדדי מערכת של GKE.
ניהול התזמון של הקולקציות
ב-TPU Trillium, אתם יכולים להשתמש בתזמון אוסף כדי לקבץ צומתי פרוסות TPU. קיבוץ הצמתים של פרוסות ה-TPU מאפשר להתאים בקלות את מספר הרפליקות לעומס העבודה. Google Cloud שולט בעדכוני התוכנה כדי לוודא שתמיד יש מספיק פרוסות זמינות באוסף לטיפול בתנועה.
ב-TPU Trillium אפשר לתזמן איסוף של מאגרי צמתים עם מארח יחיד ומארחים מרובים שמריצים עומסי עבודה של הסקה. כאן מוסבר איך התזמון של איסוף הנתונים משתנה בהתאם לסוג פרוסת ה-TPU שבה משתמשים:
- פרוסת TPU עם כמה מארחים: GKE מקבץ פרוסות TPU עם כמה מארחים כדי ליצור אוסף. כל מאגר צמתים ב-GKE הוא רפליקה באוסף הזה. כדי להגדיר אוסף, יוצרים פרוסת TPU עם כמה מארחים ומקצים לאוסף שם ייחודי. כדי להוסיף עוד פרוסות TPU לאוסף, יוצרים עוד מאגר צמתים של פרוסות TPU עם כמה מארחים, עם אותו שם אוסף ואותו סוג עומס עבודה.
- פרוסת TPU במארח יחיד: GKE מתייחס לכל מאגר הצמתים של פרוסת ה-TPU במארח יחיד כאוסף. כדי להוסיף עוד פרוסות TPU לאוסף, אתם יכולים לשנות את הגודל של מאגר הצמתים של פרוסות TPU עם מארח יחיד.
כדי לנהל אוסף, מבצעים את אחת מהפעולות הבאות בהתאם לסוג מאגר הצמתים שבו משתמשים.
ניהול תזמון האיסוף במאגרי צמתים של פרוסות TPU עם כמה מארחים
כדי לנהל מאגרי קשרים של פרוסות TPU עם כמה מארחים, אתם יכולים להשתמש במשימות הבאות.
כדי לבדוק אם מאגר של פרוסות TPU עם כמה מארחים הוא חלק מאוסף, מריצים את הפקודה הבאה:
gcloud container node-pools describe NODE_POOL_NAME \ --location LOCATION \ --cluster CLUSTER_NAME \ --format="json" | jq -r \ '"nodepool-group-name: \(.config.labels["cloud.google.com/gke-nodepool-group-name"] // "")\ngke-workload-type: \(.config.labels["cloud.google.com/gke-workload-type"] // "")"'הפלט אמור להיראות כך:
nodepool-group-name: <code><var>NODE_POOL_COLLECTION_NAME</var></code> gke-workload-type: HIGH_AVAILABILITYאם מאגר פרוסות ה-TPU עם כמה מארחים הוא חלק מאוסף, הפלט כולל את התוויות הבאות:
cloud.google.com/gke-workload-type: HIGH_AVAILABILITYcloud.google.com/gke-nodepool-group-name: <code><var>COLLECTION_NAME</var></code>
כדי לקבל את רשימת האוספים באשכול, מריצים את הפקודה הבאה:
#!/bin/bash # Replace with your cluster name, project, and location CLUSTER_NAME=CLUSTER_NAME PROJECT=PROJECT_ID LOCATION=LOCATION declare -A collection_names node_pools=$(gcloud container node-pools list --cluster "$CLUSTER_NAME" --project "$PROJECT" --location "$LOCATION" --format="value(name)") # Iterate over each node pool for pool in $node_pools; do # Describe the node pool and extract labels using jq collection_name=$(gcloud container node-pools describe "$pool" \ --cluster "$CLUSTER_NAME" \ --project "$PROJECT" \ --location "$LOCATION" \ --format="json" | jq -r '.config.labels["cloud.google.com/gke-nodepool-group-name"]') # Add the collection name to the associative array if it's not empty if [[ -n "$collection_name" ]]; then collection_names["$collection_name"]=1 fi done # Print the unique node pool collection names echo "Unique cloud.google.com/gke-nodepool-group-name values:" for name in "${!collection_names[@]}"; do echo "$name" doneהפלט אמור להיראות כך:
Unique cloud.google.com/gke-nodepool-group-name values: {COLLECTION_NAME_1}, {COLLECTION_NAME_2}, {COLLECTION_NAME_3}כדי לקבל רשימה של מאגרי צמתים ששייכים לאוסף, מריצים את הפקודה הבאה:
#!/bin/bash TARGET_COLLECTION_NAME=COLLECTION_NAME CLUSTER_NAME=CLUSTER_NAME PROJECT=PROJECT_ID LOCATION=LOCATION matching_node_pools=() # Get the list of all node pools in the cluster node_pools=$(gcloud container node-pools list --cluster "$CLUSTER_NAME" --project "$PROJECT" --location "$LOCATION" --format="value(name)") # Iterate over each node pool for pool in $node_pools; do # Get the value of the cloud.google.com/gke-nodepool-group-name label collection_name=$(gcloud container node-pools describe "$pool" \ --cluster "$CLUSTER_NAME" \ --project "$PROJECT" \ --location "$LOCATION" \ --format="json" | jq -r '.config.labels["cloud.google.com/gke-nodepool-group-name"]') # Check if the group name matches the target value if [[ "$collection_name" == "$TARGET_COLLECTION_NAME" ]]; then matching_node_pools+=("$pool") fi done # Print the list of matching node pools echo "Node pools with collection name '$TARGET_COLLECTION_NAME':" for pool in "${matching_node_pools[@]}"; do echo "$pool" doneהפלט אמור להיראות כך:
Node pools with collection name 'COLLECTION_NAME': {NODE_POOL_NAME_1} {NODE_POOL_NAME_2} {NODE_POOL_NAME_3}כדי להגדיל את המערך, יוצרים עוד מאגר של צומתי פרוסות TPU עם כמה מארחים ומוסיפים את
cloud.google.com/gke-workload-typeו-cloud.google.com/gke-nodepool-group-name. משתמשים באותו שם של אוסף ב-cloud.google.com/gke-nodepool-group-nameומריצים את אותו סוג של עומס עבודה. אם הקצאת צמתים אוטומטית מופעלת באשכול, GKE יוצר באופן אוטומטי מאגרים על סמך הדרישות של עומס העבודה.כדי לצמצם את האוסף, מוחקים את מאגר הצמתים.
כדי למחוק את האוסף, צריך להסיר את כל מאגרי הצמתים המצורפים. אתם יכולים למחוק את מאגר הצמתים או למחוק את האשכול. אם מוחקים את האשכול, כל האוספים שבו נמחקים.
ניהול תזמון האיסוף במאגרי צמתים של פרוסות TPU עם מארח יחיד
כדי לנהל מאגרי קומפקטיים של פרוסות TPU עם מארח יחיד, אתם יכולים להשתמש במשימות הבאות.
כדי לבדוק אם במאגר פרוסות TPU עם מארח יחיד מופעל תזמון איסוף, מריצים את הפקודה הבאה:
gcloud container node-pools describe NODE_POOL_NAME \ --cluster CLUSTER_NAME \ --project PROJECT_NAME \ --location LOCATION \ --format="json" | jq -r '.config.labels["cloud.google.com/gke-workload-type"]'הפלט אמור להיראות כך:
gke-workload-type: HIGH_AVAILABILITYאם מאגר פרוסות ה-TPU במארח יחיד הוא חלק מאוסף, הפלט כולל את התווית
cloud.google.com/gke-workload-type: HIGH_AVAILABILITY.כדי להגדיל את האיסוף, משנים את הגודל של מאגר הצמתים באופן ידני או באופן אוטומטי באמצעות הקצאת צמתים אוטומטית (NAP).
כדי לצמצם את האוסף, מוחקים את מאגר הצמתים.
כדי למחוק את האוסף, צריך להסיר את כל מאגרי הצמתים המצורפים. אתם יכולים למחוק את מאגר הצמתים או למחוק את האשכול. מחיקת האשכול תסיר את כל האוספים שבו.
בעיות מוכרות
- יכול להיות שהמידרוג האוטומטי של אשכולות יחשב באופן שגוי את הקיבולת של צומתי פרוסות TPU חדשים, לפני שהצמתים האלה ידווחו על יחידות TPU זמינות. יכול להיות שהמידרוג האוטומטי של האשכול יבצע הגדלה נוספת, וכתוצאה מכך ייווצרו יותר צמתים מהנדרש. המידרוג האוטומטי של האשכול מצמצם אנכית בהתאם לעומס (scale down) צמתים נוספים, אם אין בהם צורך, אחרי פעולת צמצום רגילה.
- מידרוג אוטומטי של אשכול מבטל את ההרחבה האנכית של מאגרי הצמתים של פרוסות TPU שנשארים בסטטוס המתנה במשך יותר מ-10 שעות. הכלי Cluster Autoscaler מנסה שוב לבצע את פעולות ההרחבה האלה מאוחר יותר. ההתנהגות הזו עלולה להפחית את הזמינות של TPU ללקוחות שלא משתמשים בהזמנות.
- עומסי עבודה שהם לא TPU עם סבילות ל-taint של TPU יכולים למנוע צמצום אנכי בהתאם לעומס של מאגר הצמתים, אם הם נוצרים מחדש במהלך הניקוז של מאגר הצמתים של פרוסת ה-TPU.
- המדד "ניצול רוחב הפס של הזיכרון" לא זמין ל-TPU מדור v5e.
המאמרים הבאים
- מידע נוסף על הגדרת Ray ב-GKE עם יחידות TPU
- איך מפתחים למידת מכונה בקנה מידה גדול ב-Cloud TPU באמצעות GKE
- הצגת מודלים גדולים של שפה (LLM) באמצעות KubeRay ב-TPU
- פתרון בעיות שקשורות ל-TPU ב-GKE
- מידע על הרצה בארגז חול (Sandbox) של עומסי עבודה ב-TPU באמצעות GKE Sandbox