פריסת עומסי עבודה של TPU ב-GKE Standard

במסמך הזה מוסבר איך להאיץ את עומסי העבודה של למידת המכונה (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, מבצעים את השלבים הבאים:

  1. נכנסים לדף Quotas במסוף Google Cloud :

    לפתיחת הדף Quotas

  2. בתיבה Filter:

    1. אתם יכולים להיעזר בטבלה הבאה כדי לבחור ולהעתיק את מאפיין המכסה, בהתאם לגרסת ה-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 chips
      Name:
      Preemptible TPU v4 PodSlice chips
      ‫TPU v5e,
      ct5lp-
      Name:
      TPU v5 Lite PodSlice chips
      Name:
      Preemptible TPU v5 Lite Podslice
      chips
      TPU v5p,
      ct5p-
      Name:
      TPU v5p chips
      Name:
      Preemptible TPU v5p chips
      ‫TPU Trillium,
      ct6e-
      Dimensions (e.g. location):
      tpu_family:CT6E
      Name:
      Preemptible TPU slices v6e
      ‫Ironwood‏ (TPU7x),
      tpu7x-standard-4t
      Dimensions (e.g. location):
      tpu_family:tpu7x
      Name:
      Preemptible TPU slices tpu7x
    2. בוחרים את המאפיין 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.

  1. כשיוצרים מאגר צמתים של פרוסות TPU, משתמשים בדגלים --reservation ו---reservation-affinity=specific כדי ליצור מכונה שמורה. אפשר להזמין TPU כשרוכשים התחייבות. ↩

  2. כשיוצרים מאגר צמתים של פרוסות 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

  1. הגדרת Cluster Toolkit.
  2. פורסים אשכול 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

  1. חשוב לוודא שאתם משתמשים בגרסה 4.84.0 ואילך של הספק google.
  2. מוסיפים את הבלוק הבא להגדרות ב-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:

  1. נכנסים לדף Google Kubernetes Engine במסוף Google Cloud .

    כניסה ל-Google Kubernetes Engine

  2. ברשימת האשכולות, לוחצים על שם האשכול שרוצים לשנות.

  3. לוחצים על הכרטיסייה Nodes.

  4. ‫לוחצים על Create user-managed node pool.

  5. בקטע פרטי מאגר צמתים, מסמנים את התיבה ציון מיקומי צמתים.

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

  7. בחלונית הניווט, לוחצים על Nodes.

  8. בקטע Machine Configuration, בוחרים באפשרות TPUs.

  9. בתפריט הנפתח סדרה, בוחרים באחת מהאפשרויות הבאות:

    • ‫CT3: TPU v3, מכשיר מארח יחיד
    • ‫CT3P: TPU v3, פרוסת pod עם כמה מארחים
    • ‫CT4P: TPU v4
    • ‫CT5LP: TPU v5e
    • ‫CT5P: TPU v5p
    • ‫CT6E: TPU Trillium (v6e)
  10. בתפריט הנפתח Machine type, בוחרים את שם המכונה שבה רוצים להשתמש לצמתים. בטבלה בחירת גרסת ה-TPU מוסבר איך להגדיר את סוג המכונה ואת הטופולוגיה של ה-TPU שיוצרים מאגר צמתים של פרוסות TPU במארח יחיד.

  11. בתפריט הנפתח TPU Topology, בוחרים את הטופולוגיה הפיזית של פרוסת ה-TPU.

  12. בתיבת הדו-שיח נדרשים שינויים, לוחצים על ביצוע שינויים.

  13. מוודאים שסוג דיסק האתחול הוא דיסק מתמיד סטנדרטי או דיסק מתמיד שמבוסס על SSD.

  14. אם רוצים להשתמש ב-VM במודל Spot לצמתים במאגר הצמתים, מסמנים את התיבה Enable nodes on spot VMs.

  15. לוחצים על יצירה.

יצירת מאגר צמתים של פרוסת TPU עם כמה מארחים

השלבים ליצירת מאגר של צומתי פרוסות TPU עם כמה מארחים משתנים בהתאם לשימוש ב-Ironwood (TPU7x) או בגרסת TPU קודמת.

‫Ironwood‏ (TPU7x)

אתם יכולים ליצור מאגר של צומתי פרוסות TPU עם כמה מארחים בגרסה Ironwood ‏(TPU7x) באמצעות Google Cloud CLI או Terraform:

gcloud

כדי ליצור מאגר של פרוסות TPU עם כמה מארחים באמצעות Ironwood‏ (TPU7x), קודם צריך ליצור מדיניות של עומסי עבודה.

  1. יוצרים מדיניות עומסי עבודה:

    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: האזור של מדיניות עומס העבודה. מדיניות עומסי העבודה היא משאב אזורי, ואפשר להשתמש בה שוב במאגרי צמתים שחולקים את אותה טופולוגיה.
  2. יוצרים את מאגר הצמתים עם מדיניות עומסי העבודה:

    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, כמו us-central1-ai1a. אזורי AI הם מיקומים ייעודיים שמותאמים לעומסי עבודה של AI/ML בתוך Google Cloud אזורים.

      כדי לזהות מיקום זמין, עיינו במאמר זמינות של TPU ב-GKE.
    • ‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud .
    • ‫RESERVATION_NAME: שם ההזמנה שבה רוצים להשתמש.

    בפקודה הזו, הדגל --tpu-topology הוחלף בדגל --placement-policy.

Terraform

  1. חשוב לוודא שאתם משתמשים בגרסה 4.84.0 ואילך של הספק google.
  2. יוצרים מדיניות עומסי עבודה:

    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.

  3. מוסיפים את הבלוק הבא להגדרות ב-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

  1. חשוב לוודא שאתם משתמשים בגרסה 4.84.0 ואילך של הספק google.
  2. מוסיפים את הבלוק הבא להגדרות ב-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:

  1. נכנסים לדף Google Kubernetes Engine במסוף Google Cloud .

    כניסה ל-Google Kubernetes Engine

  2. ברשימת האשכולות, לוחצים על שם האשכול שרוצים לשנות.

  3. לוחצים על הכרטיסייה Nodes.

  4. ‫לוחצים על Create user-managed node pool.

  5. בקטע פרטי מאגר צמתים, מסמנים את התיבה ציון מיקומי צמתים.

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

  7. בחלונית הניווט, לוחצים על Nodes.

  8. בקטע Machine Configuration, בוחרים באפשרות TPUs.

  9. בתפריט הנפתח סדרה, בוחרים באחת מהאפשרויות הבאות:

    • ‫CT3: TPU v3, מכשיר עם מארח יחיד
    • ‫CT3P: TPU v3, פרוסת Pod עם כמה מארחים
    • ‫CT4P: TPU v4
    • ‫CT5LP: TPU v5e
    • ‫CT5P: TPU v5p
    • ‫CT6E: TPU Trillium (v6e)
  10. בתפריט הנפתח Machine type, בוחרים את שם המכונה שבה רוצים להשתמש לצמתים. בטבלה בחירת גרסת ה-TPU מוסבר איך להגדיר את סוג המכונה ואת הטופולוגיה של ה-TPU שיוצרים מאגר של צומתי פרוסות TPU עם מארחים מרובים.

  11. בתפריט הנפתח TPU Topology, בוחרים את הטופולוגיה הפיזית של פרוסת ה-TPU.

  12. בתיבת הדו-שיח נדרשים שינויים, לוחצים על ביצוע שינויים.

  13. מוודאים שסוג דיסק האתחול הוא דיסק מתמיד סטנדרטי או דיסק מתמיד שמבוסס על SSD.

  14. לחלופין, כדי להשתמש ב-VM במודל Spot עבור הצמתים במאגר הצמתים, סמנו את התיבה Enable nodes on spot VMs.

  15. לוחצים על יצירה.

שימוש בהקצאת צמתים אוטומטית (NAP) ב-GKE

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

  1. כדי להפעיל הקצאת משאבים אוטומטית למאגר הצמתים, עורכים את מגבלות המשאבים של ה-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)

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

    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: האזור של מדיניות עומס העבודה. מדיניות עומס העבודה היא משאב אזורי, ואפשר להשתמש בה במאגרי צמתים.
  2. שומרים את המניפסט הבא בתור 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
    
  3. (אופציונלי) אתם יכולים להשתמש בהזמנה ספציפית או בבלוק משנה. לדוגמה, אפשר להוסיף את ה-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, מבצעים את הפעולות הבאות:

  1. שומרים את המניפסט הבא בתור 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 צריך להיות זהה.
  2. פורסים את ה-ComputeClass:

    kubectl apply -f tpu-compute-class.yaml
    

    מידע נוסף על ComputeClasses בהתאמה אישית ו-TPU זמין במאמר הגדרת TPU.

יצירת משימה שצורכת יחידות TPU

  1. שומרים את המניפסט הבא בתור 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 צריך להיות זהה.
  2. פורסים את המשימה:

    kubectl create -f tpu-job.yaml
    

    כשיוצרים את המשימה הזו, GKE מבצע באופן אוטומטי את הפעולות הבאות:

    • מקצה צמתים להרצת ה-Pods. בהתאם לסוג ה-TPU, לטופולוגיה ולבקשות למשאבים שציינתם, הצמתים האלה הם פרוסות של מארח יחיד או פרוסות של כמה מארחים. בהתאם לזמינות של משאבי TPU בעדיפות הגבוהה ביותר, יכול להיות ש-GKE יחזור לעדיפויות נמוכות יותר כדי למקסם את הגמישות, היעילות והזמינות של קיבולת המאיץ.
    • מוסיף taints לפודים ו-tolerations לצמתים כדי למנוע מעומסי עבודה אחרים לפעול באותם צמתים כמו עומסי העבודה של ה-TPU.

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

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

    kubectl delete -f tpu-job.yaml
    

הכנת עומסי העבודה (workloads)

לעומסי עבודה של TPU יש את דרישות ההכנה הבאות.

  1. מסגרות כמו JAX,‏ PyTorch ו-TensorFlow ניגשות למכונות וירטואליות של TPU באמצעות הספרייה המשותפת libtpu. ‫libtpu כולל את מהדר ה-XLA, תוכנת זמן הריצה של ה-TPU ומנהל ההתקן של ה-TPU. כל גרסה של PyTorch ו-JAX דורשת גרסה מסוימת של libtpu.so. כדי למנוע התנגשויות בין גרסאות של חבילות, מומלץ להשתמש בתמונה מ-AI של JAX. כדי להשתמש ביחידות TPU ב-GKE, צריך לוודא שמשתמשים בגרסאות הבאות: tpu7x
    סוג ה-TPU גרסה libtpu.so
    ‫Ironwood‏ (TPU7x)
    ‫TPU Trillium (v6e)
    tpu-v6e-slice
    ‫TPU v5e
    tpu-v5-lite-podslice
    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
    TPU v3
    tpu-v3-slice
    tpu-v3-device
  2. במניפסט של עומס העבודה, מוסיפים בוררי צמתים של 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:

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

הבחירה בגרסה ובטופולוגיה הזו יוצרת פרוסה עם כמה מארחים.

  1. שומרים את המניפסט הבא בתור 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.
  2. פורסים את המניפסט:
    kubectl create -f available-chips-multihost.yaml
    

    ‫GKE מריץ פרוסת TPU v4 עם ארבע מכונות וירטואליות (פרוסת TPU עם כמה מארחים). הפרוסה כוללת 16 שבבי TPU שמחוברים ביניהם.

  3. מוודאים שהמשימה יצרה ארבעה 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
    
  4. משיגים את היומנים של אחד מה-Pods:
    kubectl logs POD_NAME
    

    מחליפים את POD_NAME בשם של אחד מהפודים שנוצרו. לדוגמה, tpu-job-podslice-0-5cd8r.

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

    TPU cores: 16
    
  5. אופציונלי: מסירים את עומס העבודה:
    kubectl delete -f available-chips-multihost.yaml
    

דוגמה 3: הרצת עומס עבודה שמציג את מספר שבבי ה-TPU הזמינים בפרוסת ה-TPU

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

  • גרסת ה-TPU: ‏TPU v5e
  • טופולוגיה: 2x4

הבחירה בגרסה ובטופולוגיה הזו יוצרת פרוסה של מארח יחיד.

  1. שומרים את המניפסט הבא בתור 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.
  2. פורסים את המניפסט:
    kubectl create -f available-chips-singlehost.yaml
    

    ‫GKE מקצה צמתים עם שמונה פרוסות TPU במארח יחיד שמשתמשות ב-TPU v5e. לכל צומת TPU יש שמונה שבבי TPU (פרוסת TPU במארח יחיד).

  3. משיגים את היומנים של ה-Pod:
    kubectl logs tpu-job-jax-v5
    

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

    Total TPU chips: 8
    
  4. אופציונלי: מסירים את עומס העבודה:
      kubectl delete -f available-chips-singlehost.yaml
      

דוגמה 4: הפעלת עומס עבודה שמטרגט שני צומתי NUMA

כדי לשפר את הביצועים של עומסי העבודה, ב-GKE אפשר לפרוס את עומסי העבודה בהגדרה של כמה קונטיינרים. כך כל קונטיינר מקושר למשאבי המעבד (CPU), הזיכרון וה-TPU בצומת NUMA נתון. מידע נוסף על קישור NUMA זמין במאמר מידע על Ironwood‏ (TPU7x) ב-GKE.

  1. יוצרים קובץ בשם topology-manager-config.yaml עם התוכן הבא:

    kubeletConfig:
      cpuManagerPolicy: static
      topologyManager:
        policy: best-effort
        scope: container
    

    ההגדרה הזו מתאימה את המשאבים שנדרשים על ידי קונטיינר לצומת NUMA יחיד. ההגדרה הזו נדרשת כדי ש-GKE יקבל ויקצה שבבים בצורה נכונה לעומסי עבודה של TPU עם כמה קונטיינרים. אפשרויות מדיניות נוספות מפורטות במאמר Topology Manager Policies.

  2. מחילים את ההגדרה 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: שם האשכול.
  3. יוצרים קובץ בשם 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 נפרדים ולהשתמש בהם.

  4. מחילים את המניפסט:

    kubectl apply -f tpu-jobset.yaml
    

דוגמה 5: הפעלת עומס עבודה של TPU עם כמה קונטיינרים באמצעות אמצעי אחסון של Cloud Storage FUSE עם כמה כרטיסי רשת

הדוגמה הזו מרחיבה את דוגמה 4 וכוללת טעינה של קטגוריות Cloud Storage FUSE כנפחים באמצעות Cloud Storage FUSE. ההגדרה הזו משתמשת ביכולות של multi-NIC כדי לשפר את ביצועי הרשת.

  1. יוצרים קובץ בשם 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.

  2. מחילים את המניפסט:

    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. כדי לצמצם את היקף ההרשאות במאגר, צריך לבצע את הפעולות הבאות:

  1. עורכים את securityContext כך שיכלול את השדות הבאים:

    securityContext:
      capabilities:
        add: ["SYS_RESOURCE"]
    
  2. כדי להגדיל את 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_cycle
  • kubernetes.io/container/accelerator/memory_used
  • kubernetes.io/container/accelerator/memory_total

צומת Kubernetes:

  • kubernetes.io/node/accelerator/duty_cycle
  • kubernetes.io/node/accelerator/memory_used
  • kubernetes.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_utilization
  • kubernetes.io/container/accelerator/memory_bandwidth_utilization

צומת Kubernetes:

  • kubernetes.io/node/accelerator/tensorcore_utilization
  • kubernetes.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_AVAILABILITY
    • cloud.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.

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