‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

תזמון פלחים דינמיים באמצעות Kueue ו-TAS

רגילה

במאמר הזה מוסבר איך להקצות מאגרי צמתים של TPU ולתזמן פרוסות דינמיות ב-Google Kubernetes Engine‏ (GKE) באמצעות Kueue וTopology Aware Scheduling (TAS).

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

לפני שמבצעים את ההוראות האלה, חשוב להבין את המושגים של חלוקה דינמית.

דרישות

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

משתמשים באשכול Standard בערוץ מהיר באחת מהגרסאות הבאות:
- כדי להגדיר חלוקה דינמית של רשתות (טופולוגיות ששווה ל-4x4x4 או גדולות ממנו), צריך להשתמש בגרסה 1.35.2-gke.1842000 ואילך.
- כדי להגדיר חלוקה דינמית למקטעי משנה (טופולוגיות קטנות מ-4x4x4), צריך להשתמש בגרסה 1.36.0-gke.3712000 ואילך.
שימוש בגרסת Ironwood‏ (TPU7x).
משתמשים בקובץ אימג' של מערכת הפעלה שמותאמת לקונטיינרים עבור הצמתים.
כדי להשתמש בהקצאת משאבים מצטברת, צריך להשתמש בהזמנות במצב 'כל הקיבולת'. כל מצב הקיבולת הוא תכונה שמופעלת על ידי TPU Cluster Director.
כדי להשתמש בחלוקת משנה דינמית, צריך לוודא שיש בצמתים אירועי תחזוקה בהמתנה. מעקב אחר אירועי תחזוקה בהמתנה במכונות שלכם. אם יש צמתים עם אירוע תחזוקה בהמתנה וזמן סיום בין 18 בספטמבר 2026 ל-30 בספטמבר 2026, צריך להפעיל ידנית את אירוע התחזוקה של המארח בצמתים האלה כדי להשתמש בחלוקת משנה.

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

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

מפעילים את ממשק Google Kubernetes Engine API.

הפעלת Google Kubernetes Engine API

כדי להשתמש ב-CLI של Google Cloud למשימה הזו, צריך להתקין ואז לאתחל את ה-CLI של gcloud. אם התקנתם בעבר את ה-CLI של gcloud, מריצים את הפקודה gcloud components update כדי לקבל את הגרסה העדכנית. יכול להיות שגרסאות קודמות של ה-CLI של gcloud לא יתמכו בהרצת הפקודות שמופיעות במסמך הזה.
הערה: אם כבר התקנתם את ה-CLI של gcloud, הקפידו להגדיר את compute/region המאפיין. אם אתם משתמשים בעיקר באשכולות אזוריים, עליכם להגדיר את compute/zone במקום זאת. אם מגדירים מיקום ברירת מחדל, אפשר להימנע משגיאות ב-CLI של gcloud כמו השגיאה הבאה: One of [--zone, --region] must be supplied: Please specify location. יכול להיות שתצטרכו לציין את המיקום בפקודות מסוימות אם המיקום של האשכול שונה מברירת המחדל שהגדרתם.

מוודאים שיש לכם אשכול קיים מסוג Standard בגרסה 1.35.2-gke.1842000 ואילך, בערוץ מהיר. כדי ליצור אשכול חדש, אפשר לעיין במאמר בנושא יצירת אשכול אזורי.
מוודאים שיש לכם מספיק מכסת שימוש ב-Ironwood ‏ (TPU7x) באזור שלכם.
אם אתם מתכננים להריץ עומסי עבודה של חלוקת נתונים, תצטרכו להתקין את JobSet בגרסה 0.10.1 ואילך.
בקשה לקיבולת TPU במצב 'כל הקיבולת'.

שימוש בפריסה דינמית ב-GKE עם Kueue

בקטע הזה מתואר תהליך העבודה לשימוש בפילוח דינמי ב-GKE.

איך רואים את הטופולוגיה ואת סטטוס התקינות של כל ההזמנות במצב 'כל הקיבולת'
הפעלת בקר הפרוסות באשכול.
התקנה של Kueue,‏ JobSet ו-LWS
יצירת מאגרי צמתים של TPU.
הגדרת Kueue ליצירת משאב מותאם אישית של Slice
הפעלת עומסי עבודה בפריסה דינמית באמצעות Kueue
ניקוי.

הפעלת אמצעי הבקרה של התבנית

כדי להשתמש בפילוח דינמי, צריך להפעיל את בקר הפילוח באשכול.

מעדכנים את האשכול:
```
gcloud container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --enable-slice-controller
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫CLUSTER_NAME: השם של האשכול.
- ‫LOCATION: האזור שבו נמצא קיבולת ה-TPU הזמינה.

כדי לתקשר עם האשכול באמצעות פקודות kubectl, צריך לקבל פרטי כניסה:

gcloud config set container/cluster CLUSTER_NAME
gcloud container clusters get-credentials CLUSTER_NAME \
    --location=LOCATION

בפלט של הפקודה הבאה, מוודאים שהערך slices.accelerator.gke.io מופיע:
```
kubectl get crd slices.accelerator.gke.io
```
הפלט אמור להיראות כך:
```
slices.accelerator.gke.io                2026-01-09T23:58:02Z
```

התקנה של Kueue,‏ JobSet ו-LWS

אם כבר התקנתם את Kueue,‏ JobSet ו-LWS, אתם יכולים לדלג על הקטע הזה.

התקנת Kueue

פועלים לפי ההוראות בתיעוד של Kueue או מריצים את הפקודה הבאה:

kubectl apply --server-side -f https://github.com/kubernetes-sigs/kueue/releases/download/KUEUE_VERSION/manifests.yaml

מחליפים את KUEUE_VERSION בגרסת Kueue הנדרשת בהתאם לדרישות הטופולוגיה. כדי להשתמש בחלוקת משנה דינמית, צריך להשתמש ב-Kueue בגרסה 0.18.2 ואילך. כדי להשתמש בפריסה דינמית של נתונים, צריך להשתמש ב-Kueue מגרסה 0.16.6 ואילך.

התקנת JobSet

פועלים לפי ההוראות שמפורטות במסמכי התיעוד של JobSet או מריצים את הפקודה הבאה:

kubectl apply --server-side -f https://github.com/kubernetes-sigs/jobset/releases/download/JOBSET_VERSION/manifests.yaml

מחליפים את JOBSET_VERSION בגרסת JobSet הנדרשת בהתאם לדרישות הטופולוגיה. כדי להשתמש בחלוקת משנה דינמית, צריך להשתמש ב-JobSet בגרסה 0.12.0 ואילך. כדי להשתמש ב-dynamic super-slicing, צריך להשתמש ב-JobSet מגרסה 0.11.1 ואילך.

התקנת LWS

הגדרת LeaderWorkerSet ‏ (LWS) נדרשת רק לחלוקת משנה דינמית.

פועלים לפי ההוראות בתיעוד של LWS או מריצים את הפקודה הבאה:

kubectl apply --server-side -f https://github.com/kubernetes-sigs/lws/releases/download/LWS_VERSION/manifests.yaml

מחליפים את LWS_VERSION בגרסה הנדרשת של LWS. להשתמש ב-LWS בגרסה 0.8.0 ואילך.

יצירת מאגרי צמתים עם הקצאת משאבים מצטברת

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

אתם יכולים לטרגט את מאגר הצמתים כך שישתייך לאחת מהקטגוריות הבאות:

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

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

כדי ליצור מאגר צמתים של פרוסת TPU עם Ironwood‏ (TPU7x), קודם צריך ליצור מדיניות עומס עבודה עם השדה accelerator-topology-mode שמוגדר ל-provision_only. ההגדרה הזו מפעילה את תהליך ההקצאה המצטבר.

יוצרים מדיניות של עומס עבודה:

gcloud compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \
        --project=PROJECT_ID \
        --region=REGION  \
        --type=HIGH_THROUGHPUT \
        --accelerator-topology=4x4x4 \
        --accelerator-topology-mode=provision_only

מחליפים את מה שכתוב בשדות הבאים:

‫WORKLOAD_POLICY_NAME: שם למדיניות של עומס העבודה.
‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud .
‫REGION: האזור של מדיניות עומס העבודה.

בפקודה הזו, מבצעים את הפעולות הבאות::

תמיד מגדירים את השדה accelerator-topology לערך 4x4x4 כדי להתאים למספר הכולל של הצ'יפים בתוך בלוק משנה יחיד.
כדי להפעיל את תהליך ההקצאה המצטבר, צריך תמיד להגדיר את השדה accelerator-topology-mode לערך provision_only. כשמגדירים את השדה provision_only, מאגר הצמתים מקצה צמתי TPU בלי ליצור קישורי ICI או OCS.

טירגוט מאגר הצמתים כך שישתייך לבלוק או לתת-בלוק

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

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

חסימה

כדי לאחזר את שם הבלוק בהזמנה ואת מספר תתי הבלוקים שזמינים בבלוק, צריך לבצע את השלבים הבאים במסמך View the topology and health status of All Capacity Mode reservations:
1. מזהים את שם הבלוק על ידי הצגת רשימה של כל בלוקי ההזמנות והעתקת הערך בשדה name:. הערך הזה הוא שם הבלוק או BLOCK_NAME במסמך הזה.
2. כדי לקבוע כמה מאגרי צמתים צריך ליצור, מתארים בלוק של הזמנה ומזהים את הערך בשדה reservationSubBlockCount. הערך הזה הוא מספר תתי-הבלוקים הזמינים. לדוגמה, הערך reservationSubBlockCount: 4 מציין שיש ארבעה בלוקים משניים זמינים בבלוק, וצריך ליצור ארבעה מאגרי צמתים נפרדים.
מגדירים את נתיב ההזמנה:
```
export RESERVATION_PATH="projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME"
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫RESERVATION_NAME: השם של הזמנת ה-TPU.
- ‫BLOCK_NAME: השם של הבלוק.
יוצרים מאגר צמתים לכל תת-בלוק שזוהה בשלב הקודם. לדוגמה, אם המספר הוא 4, מריצים את הפקודה הזו ארבע פעמים. צריך להשתמש בשם ייחודי לכל מאגר צמתים.
```
gcloud container node-pools create NODE_POOL_NAME \
      --cluster=CLUSTER_NAME \
      --node-locations=ZONE \
      --machine-type=tpu7x-standard-4t \
      --num-nodes=16 \
      --placement-policy=WORKLOAD_POLICY_NAME \
      --reservation-affinity=specific \
      --reservation=${RESERVATION_PATH}
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫NODE_POOL_NAME: השם של מאגר הצמתים החדש.
- ‫CLUSTER_NAME: השם של אשכול GKE.
- ‫WORKLOAD_POLICY_NAME: השם של מדיניות עומס העבודה שיצרתם.
- ‫ZONE: האזור של מאגר הצמתים, לדוגמה, us-central1-a.

Sub-block

כדי לאחזר את השם של הבלוק ואת המזהים של תתי-הבלוקים הזמינים, מבצעים את השלבים הבאים במסמך View the topology and health status of All Capacity Mode reservations:
1. כדי לזהות את השם של הבלוק, מציגים רשימה של כל בלוקי ההזמנות ומעתיקים את הערך בשדה name:. הערך הזה הוא השם של הבלוק או של BLOCK_NAME במסמך הזה.
2. כדי לזהות את השם של תת-הבלוקים, מפרטים את כל תת-הבלוקים של בלוק ומעתיקים את הערך בשדה name: לכל רשומה בקטע reservationSubBlocks. הערך הזה הוא השם של בלוק המשנה או SUBBLOCK_NAME במסמך הזה.
מגדירים את נתיב ההזמנה:
```
export RESERVATION_PATH="projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME/reservationSubBlocks/SUBBLOCK_NAME"
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫RESERVATION_NAME: השם של הזמנת ה-TPU.
- ‫BLOCK_NAME: השם של הבלוק.
- ‫SUBBLOCK_NAME: השם של בלוק המשנה.
יוצרים את מאגר הצמתים:
```
gcloud container node-pools create NODE_POOL_NAME \
        --project=PROJECT_ID \
        --cluster=CLUSTER_NAME \
        --node-locations=ZONE \
        --machine-type=tpu7x-standard-4t \
        --num-nodes=16 \
        --placement-policy=WORKLOAD_POLICY_NAME \
        --reservation-affinity=specific \
        --reservation=${RESERVATION_PATH}
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫NODE_POOL_NAME: שם ייחודי למאגר הצמתים החדש, לדוגמה, sub-block-pool-1.
- ‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud .
- ‫CLUSTER_NAME: השם של אשכול GKE.
- ‫ZONE: האזור של מאגר הצמתים, לדוגמה, us-central2-b.
- WORKLOAD_POLICY_NAME: השם של מדיניות העומס שיצרתם.

בשלב הזה, הצמתים נוצרים, אבל הקישורים שלהם לחיבור בין-שבבי (ICI) עדיין לא פעילים. לכן, אי אפשר להריץ עומסי עבודה ישירות במאגרי הצמתים האלה.

כדי להפעיל את כל הקישורים הדרושים של ICI כדי ליצור את הפרוסה ולאפשר תזמון של עומסי עבודה, צריך ליצור פרוסה דינמית באחת מהשיטות הבאות:

יוצרים משאב מותאם אישית של Slice. במקום Pods, משתמשים במשאב מותאם אישית מסוג Slice כדי להגדיר את הטופולוגיה שצוינה, והבקר של ה-Slice מפעיל אותה.
תזמון עומסי עבודה ב-GKE באמצעות Kueue ו-TAS. ‫Kueue מטפל אוטומטית ביצירה ובמחיקה של משאבים מותאמים אישית מסוג Slice. מומלץ להימנע משינוי ידני של משאבים מותאמים אישית של Slice שנוצרו על ידי Kueue.

יצירת פלח דינמי באמצעות Kueue ו-TAS

בקטע הזה נסביר איך לתזמן עומסי עבודה ב-GKE באמצעות Kueue ו-TAS.

התקנה של בקר פרוסות Kueue

כדי להתקין את בקר הפרוסות של Kueue, שומרים את המניפסט הבא כ-slice-controller.yaml:

# Copyright 2026 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: v1
kind: Namespace
metadata:
  labels:
    app.kubernetes.io/managed-by: kustomize
    app.kubernetes.io/name: slice-controller
    control-plane: controller-manager
  name: slice-controller-system
---
apiVersion: v1
kind: ServiceAccount
metadata:
  labels:
    app.kubernetes.io/managed-by: kustomize
    app.kubernetes.io/name: slice-controller
    control-plane: controller-manager
  name: slice-controller-controller-manager
  namespace: slice-controller-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  labels:
    app.kubernetes.io/managed-by: kustomize
    app.kubernetes.io/name: slice-controller
    control-plane: controller-manager
  name: slice-controller-leader-election-role
  namespace: slice-controller-system
rules:
- apiGroups:
  - ""
  resources:
  - configmaps
  verbs:
  - get
  - list
  - watch
  - create
  - update
  - patch
  - delete
- apiGroups:
  - coordination.k8s.io
  resources:
  - leases
  verbs:
  - get
  - list
  - watch
  - create
  - update
  - patch
  - delete
- apiGroups:
  - ""
  resources:
  - events
  verbs:
  - create
  - patch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  labels:
    app.kubernetes.io/managed-by: kustomize
    app.kubernetes.io/name: slice-controller
    control-plane: controller-manager
  name: slice-controller-webhook-secrets-role
  namespace: slice-controller-system
rules:
- apiGroups:
  - ""
  resources:
  - secrets
  verbs:
  - get
  - list
  - watch
  - update
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  labels:
    control-plane: controller-manager
  name: slice-controller-manager-role
rules:
- apiGroups:
  - ""
  resources:
  - nodes
  - pods
  verbs:
  - get
  - list
  - watch
- apiGroups:
  - accelerator.gke.io
  resources:
  - slices
  verbs:
  - create
  - delete
  - get
  - list
  - patch
  - update
  - watch
- apiGroups:
  - accelerator.gke.io
  resources:
  - slices/finalizers
  verbs:
  - update
- apiGroups:
  - accelerator.gke.io
  resources:
  - slices/status
  verbs:
  - get
  - patch
  - update
- apiGroups:
  - admissionregistration.k8s.io
  resources:
  - mutatingwebhookconfigurations
  verbs:
  - get
  - list
  - update
  - watch
- apiGroups:
  - batch
  resources:
  - jobs
  verbs:
  - get
  - list
  - patch
  - update
  - watch
- apiGroups:
  - events.k8s.io
  resources:
  - events
  verbs:
  - create
  - patch
  - update
  - watch
- apiGroups:
  - jobset.x-k8s.io
  resources:
  - jobsets
  verbs:
  - get
  - list
  - patch
  - update
  - watch
- apiGroups:
  - kueue.x-k8s.io
  resources:
  - admissionchecks
  verbs:
  - get
  - list
  - watch
- apiGroups:
  - kueue.x-k8s.io
  resources:
  - admissionchecks/status
  - workloads/status
  verbs:
  - get
  - patch
  - update
- apiGroups:
  - kueue.x-k8s.io
  resources:
  - workloads
  verbs:
  - create
  - get
  - list
  - patch
  - update
  - watch
- apiGroups:
  - leaderworkerset.x-k8s.io
  resources:
  - leaderworkersets
  verbs:
  - get
  - list
  - patch
  - update
  - watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  labels:
    control-plane: controller-manager
  name: slice-controller-metrics-auth-role
rules:
- apiGroups:
  - authentication.k8s.io
  resources:
  - tokenreviews
  verbs:
  - create
- apiGroups:
  - authorization.k8s.io
  resources:
  - subjectaccessreviews
  verbs:
  - create
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  labels:
    control-plane: controller-manager
  name: slice-controller-metrics-reader
rules:
- nonResourceURLs:
  - /metrics
  verbs:
  - get
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  labels:
    app.kubernetes.io/managed-by: kustomize
    app.kubernetes.io/name: slice-controller
    control-plane: controller-manager
  name: slice-controller-leader-election-rolebinding
  namespace: slice-controller-system
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: slice-controller-leader-election-role
subjects:
- kind: ServiceAccount
  name: slice-controller-controller-manager
  namespace: slice-controller-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  labels:
    app.kubernetes.io/managed-by: kustomize
    app.kubernetes.io/name: slice-controller
    control-plane: controller-manager
  name: slice-controller-webhook-secrets-rolebinding
  namespace: slice-controller-system
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: slice-controller-webhook-secrets-role
subjects:
- kind: ServiceAccount
  name: slice-controller-controller-manager
  namespace: slice-controller-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  labels:
    app.kubernetes.io/managed-by: kustomize
    app.kubernetes.io/name: slice-controller
    control-plane: controller-manager
  name: slice-controller-manager-rolebinding
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: slice-controller-manager-role
subjects:
- kind: ServiceAccount
  name: slice-controller-controller-manager
  namespace: slice-controller-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  labels:
    control-plane: controller-manager
  name: slice-controller-metrics-auth-rolebinding
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: slice-controller-metrics-auth-role
subjects:
- kind: ServiceAccount
  name: slice-controller-controller-manager
  namespace: slice-controller-system
---
apiVersion: v1
kind: Secret
metadata:
  labels:
    control-plane: controller-manager
  name: slice-controller-webhook-server-cert
  namespace: slice-controller-system
---
apiVersion: v1
kind: Service
metadata:
  labels:
    app.kubernetes.io/managed-by: kustomize
    app.kubernetes.io/name: slice-controller
    control-plane: controller-manager
  name: slice-controller-controller-manager-metrics-service
  namespace: slice-controller-system
spec:
  ports:
  - name: https
    port: 8443
    protocol: TCP
    targetPort: 8443
  selector:
    app.kubernetes.io/name: slice-controller
    control-plane: controller-manager
---
apiVersion: v1
kind: Service
metadata:
  labels:
    control-plane: controller-manager
  name: slice-controller-webhook-service
  namespace: slice-controller-system
spec:
  ports:
  - port: 443
    protocol: TCP
    targetPort: 9443
  selector:
    control-plane: controller-manager
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app.kubernetes.io/managed-by: kustomize
    app.kubernetes.io/name: slice-controller
    control-plane: controller-manager
  name: slice-controller-controller-manager
  namespace: slice-controller-system
spec:
  replicas: 1
  selector:
    matchLabels:
      app.kubernetes.io/name: slice-controller
      control-plane: controller-manager
  template:
    metadata:
      annotations:
        kubectl.kubernetes.io/default-container: manager
      labels:
        app.kubernetes.io/name: slice-controller
        control-plane: controller-manager
    spec:
      containers:
      - args:
        - --metrics-bind-address=:8443
        - --leader-elect
        - --health-probe-bind-address=:8081
        - --zap-log-level=3
        - --feature-gates=UseRetryMechanismForSliceCreation=true
        - --activation-timeout=60m
        - --kube-api-qps=100
        - --kube-api-burst=200
        - --default-slice-health-node-affinity=HEALTHY_AND_DEGRADED
        - --reuse-slices=true
        - --add-preferred-node-affinity=true
        command:
        - /manager
        image: tpuongke/kueue-slice-controller:v0.9
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8081
          initialDelaySeconds: 15
          periodSeconds: 20
        name: manager
        ports:
        - containerPort: 9443
          name: webhook-server
          protocol: TCP
        readinessProbe:
          httpGet:
            path: /readyz
            port: 8081
          initialDelaySeconds: 5
          periodSeconds: 10
        resources:
          limits:
            cpu: 12
            memory: 32Gi
          requests:
            cpu: 8
            memory: 16Gi
        securityContext:
          allowPrivilegeEscalation: false
          capabilities:
            drop:
            - ALL
        volumeMounts:
        - mountPath: /tmp/k8s-webhook-server/serving-certs
          name: cert
          readOnly: true
      securityContext:
        runAsNonRoot: true
        seccompProfile:
          type: RuntimeDefault
      serviceAccountName: slice-controller-controller-manager
      terminationGracePeriodSeconds: 10
      volumes:
      - name: cert
        secret:
          defaultMode: 420
          secretName: slice-controller-webhook-server-cert
---
apiVersion: admissionregistration.k8s.io/v1
kind: MutatingWebhookConfiguration
metadata:
  labels:
    control-plane: controller-manager
  name: slice-controller-mutating-webhook-configuration
webhooks:
- admissionReviewVersions:
  - v1
  clientConfig:
    service:
      name: slice-controller-webhook-service
      namespace: slice-controller-system
      path: /mutate-batch-v1-job
  failurePolicy: Fail
  name: mjob.kb.io
  rules:
  - apiGroups:
    - batch
    apiVersions:
    - v1
    operations:
    - CREATE
    resources:
    - jobs
  sideEffects: None
- admissionReviewVersions:
  - v1
  clientConfig:
    service:
      name: slice-controller-webhook-service
      namespace: slice-controller-system
      path: /mutate-jobset-x-k8s-io-v1alpha2-jobset
  failurePolicy: Fail
  name: mjobset.kb.io
  rules:
  - apiGroups:
    - jobset.x-k8s.io
    apiVersions:
    - v1alpha2
    operations:
    - CREATE
    resources:
    - jobsets
  sideEffects: None
- admissionReviewVersions:
  - v1
  clientConfig:
    service:
      name: slice-controller-webhook-service
      namespace: slice-controller-system
      path: /mutate-leaderworkerset-x-k8s-io-v1-leaderworkerset
  failurePolicy: Fail
  name: mleaderworkerset.kb.io
  rules:
  - apiGroups:
    - leaderworkerset.x-k8s.io
    apiVersions:
    - v1
    operations:
    - CREATE
    resources:
    - leaderworkersets
  sideEffects: None

החלת המניפסט slice-controller.yaml:
```
kubectl apply -f slice-controller.yaml
```

כדי להגדיר את Kueue לפריסה דינמית, שומרים את המניפסט הבא כמו dynamic-slice-topology.yaml:

# Copyright 2026 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: kueue.x-k8s.io/v1beta1
kind: Topology
metadata:
  name: superslice-topology
spec:
  levels:
  # Label to identify the physical block a sub-block belongs to.
  # Only sub-blocks from the same block can form a slice.
  - nodeLabel: cloud.google.com/gce-topology-block
  # Label to identify individual TPU sub-blocks (4x4x4 topology).
  - nodeLabel: cloud.google.com/gke-tpu-partition-4x4x4-id
  # Standard Kubernetes label for individual nodes.
  # Required to assign Pods to specific VMs.
  - nodeLabel: kubernetes.io/hostname
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: ResourceFlavor
metadata:
  name: superslice-rf
spec:
  nodeLabels:
    cloud.google.com/gke-tpu-accelerator: tpu7x
  topologyName: superslice-topology
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: AdmissionCheck
metadata:
  name: superslice-ac
spec:
  controllerName: accelerator.gke.io/slice
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: ClusterQueue
metadata:
  name: cq
spec:
  namespaceSelector: {}
  admissionChecks:
  - superslice-ac
  resourceGroups:
  - coveredResources:
    - google.com/tpu
    flavors:
    - name: superslice-rf
      resources:
      - name: google.com/tpu
        nominalQuota: "999999"  # modeling unlimited quota
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: LocalQueue
metadata:
  name: lq
  namespace: default
spec:
  clusterQueue: cq

החלת המניפסט dynamic-slice-topology.yaml:
```
kubectl apply -f dynamic-slice-topology.yaml
```
במניפסט הזה, מגדירים את Kueue לחלוקה דינמית על ידי הגדרת המשאבים הבאים:
- טופולוגיית פרוסות דינמיות של Ironwood‏ (TPU7x) (superslice-topology): הטופולוגיה מגדירה את הרמות ש-Kueue לוקח בחשבון כשהוא מתזמן עומסי עבודה של פרוסות דינמיות. הרמות האלה הן:
  - תווית cloud.google.com/gce-topology-block: הרמה הזו נדרשת כדי להבין אילו בלוקים משניים שייכים לאילו בלוקים, כי רק בלוקים משניים מאותו בלוק יכולים ליצור פרוסה.
  - תווית cloud.google.com/gke-tpu-partition-4x4x4-id: הרמה הזו מייצגת תת-בלוקים נפרדים של Ironwood‏ (TPU7x) (4x4x4 טופולוגיה).
  - תווית kubernetes.io/hostname: הרמה הזו נדרשת כדי להקצות Pod למכונות וירטואליות ספציפיות וכדי לראות את התוויות וה-taint שלהן.
- ‫Ironwood (TPU7x) SuperSlice ResourceFlavor ‏ (superslice-rf): סוג המשאב של בלוקי המשנה של Ironwood ‏ (TPU7x) כולל את התווית cloud.google.com/gke-tpu-accelerator: tpu7x כדי להתאים לצמתים עם מכונות Ironwood ‏ (TPU7x).
- ‫SuperSlice AdmissionCheck ‏ (superslice-ac): בדיקת הקבלה הזו מודיעה ל-Kueue לא לתזמן עומס עבודה עד שבקר הפרוסה של GKE מאשר שהפרוסה הפכה לפעילה. קודם מגדירים את בדיקת הגישה ואז מוסיפים אותה ל-ClusterQueue שמטפל בעומסי עבודה של פריסה דינמית.
- ‫ClusterQueue (cq) ו-LocalQueue (lq): השדות האלה מנהלים משאבי google.com/tpu. התור cq ClusterQueue כולל את superslice-ac בדיקת ההרשאה. אפשר להגדיר את השדה nominalQuota עבור google.com/tpu בשתי דרכים:
  - מכסה ספציפית: מגדירים את השדה nominalQuota כך שיתאים לקיבולת הקיימת כדי לנהל את המכסה ולשתף את הקיבולת באופן הוגן.
  - מכסה ללא הגבלה: מגדירים את השדה nominalQuota לערך גבוה מאוד כמו "999999", כדי לדמות מכסה ללא הגבלה. כדי להתמקד ב-TAS ובחלוקה דינמית, ההגדרה הזו עוקפת את הפונקציונליות של ניהול המכסות ב-Kueue.

הגדרת הבחירה של תקינות המחיצה

בנוסף לבדיקת תקינות ומוכנות רגילה של הצומת, GKE חושף את המצב הספציפי של כל צורה של מחיצה באמצעות התווית cloud.google.com/gke-tpu-partition-[shape]-state (כאשר [shape] תואם לצורה של מזהה המחיצה, כמו 2x2x1,‏ 2x2x2,‏ 2x2x4,‏ 2x4x4 או 4x4x4). התווית הזו מאפשרת ל-GKE להתחשב בגורמים שמשפיעים על יצירת פרוסות, כמו המצב של קישורי TPU. הגדרה של חלוקת משנה דינמית (טופולוגיות קטנות מ-4x4x4) דורשת GKE בגרסה ‎1.36.0-gke.3712000 ואילך.

אפשר להגדיר את הערך של תווית מצב המחיצה באופן הבא:

‫HEALTHY: המחיצה תקינה ופועלת באופן מלא.
‫DEGRADED: התשתית של המחיצה במצב ירוד, למשל, בגלל ירידה באיכות הקישור של OCS. המחיצה עדיין יכולה ליצור פלח, אבל יכול להיות שהביצועים הכוללים יהיו נמוכים יותר בהשוואה למחיצות תקינות. הסטטוס הזה רלוונטי רק לטופולוגיה 4x4x4 ברמה העליונה. בטופולוגיות קטנות יותר אין מצב של ירידה ברמת השירות.
‫UNHEALTHY: המחיצה לא תקינה ואי אפשר ליצור ממנה פרוסה.
‫UNSET: המצב לא מוגדר בגלל אתחול לא מוצלח של בקר הפרוסות של GKE.
‫INCOMPLETE: לא כל הצמתים במחיצה הוקצו.

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

ההתנהגות היא כזו:

אם יש תג nodeSelector או nodeAffinity שמטרגט את התווית cloud.google.com/gke-tpu-partition-[shape]-state, הוא לא ישתנה.

אם לא קיימת הגדרת תווית כזו, ה-webhook מוסיף את הקרבה הבאה של צומת ברירת המחדל כדי להבטיח שייעשה שימוש רק במחיצות זמינות:

nodeAffinity:
  requiredDuringSchedulingIgnoredDuringExecution:
    nodeSelectorTerms:
    - matchExpressions:
      - key: cloud.google.com/gke-tpu-partition-4x4x4-state
        operator: In
        values:
        - "HEALTHY"
        - "DEGRADED"

בקטע הבא יש דוגמאות שבהן התווית cloud.google.com/gke-tpu-partition-4x4x4-state מוגדרת כדי לציין את ההגדרות השונות של תקינות תת-הבלוקים.

הפעלת עומסי עבודה לבדיקה בפריסה דינמית באמצעות Kueue

בקטע הזה מוסבר איך פורסים עומסי עבודה בפריסה דינמית באמצעות Kueue ו-TAS. הוא כולל דוגמאות שמראות איך ליצור עומס עבודה של פלח דינמי ועומס עבודה שמורכב מכמה פלחים. עומסי העבודה נשלחים כ-JobSets.

דוגמה 1: עומס עבודה יחיד משתמש בפרוסת נפח דינמית אחת

בדוגמה הבאה מתואר איך ליצור עומס עבודה באמצעות פרוסה עם טופולוגיה של 4x12x16, שמורכבת מ-12 בלוקים משניים. מספר ה-Pods חושב כך: (4 * 12 * 16) / 4 שבבים לכל צומת = 192 Pods.

שומרים את קובץ המניפסט הבא בשם big-super-slice.yaml:

# Copyright 2026 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: jobset.x-k8s.io/v1alpha2
kind: JobSet
metadata:
  name: big-super-slice
  labels:
    kueue.x-k8s.io/queue-name: lq
spec:
  replicatedJobs:
    - name: job-jax
      replicas: 1
      template:
        spec:
          parallelism: 192  # pods per slice calculation: 4*12*16 / 4 = 192
          completions: 192
          backoffLimit: 10
          template:
            metadata:
              annotations:
                cloud.google.com/gke-tpu-slice-topology: 4x12x16
            spec:
              tolerations:
                - key: "google.com/tpu"
                  operator: "Equal"
                  value: "present"
                  effect: "NoSchedule"
              nodeSelector:
                cloud.google.com/gke-tpu-accelerator: tpu7x
              containers:
                - name: jax
                  image: python:latest
                  command:
                    - bash
                    - -c
                    - |
                      printenv
                      pip install "jax[tpu]" -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
                      python -c 'import jax; print("Global device count:", jax.device_count(), "Local device count:", jax.local_device_count())'
                  resources:
                    limits:
                      google.com/tpu: 4
              restartPolicy: Never

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

‫cloud.google.com/gke-tpu-slice-topology: מציין את "4x12x16" כטופולוגיית הפרוסות הדינמיות. הדרישות לטופולוגיית המאיץ tpu7x כוללות את הכללים הבאים:
- לפילוח דינמי של רשתות משנה: אפשר לציין טופולוגיות קטנות יותר מ-4x4x4, כמו 2x2x1, ‏2x2x2, ‏2x2x4 או 2x4x4. כדי להשתמש בטופולוגיות הקטנות האלה, צריך GKE בגרסה ‎1.36.0-gke.3712000 ואילך.
- לפילוח דינמי מתקדם: אפשר לציין טופולוגיות ששווות ל-4x4x4 או גדולות ממנו. כדי להגדיר חיתוך-על דינמי, כל מאפיין בטופולוגיה המבוקשת צריך להיות כפולה של ארבע, לדוגמה 4A x 4B x 4C.
- הטופולוגיה צריכה להיות מחרוזת תלת-ממדית בפורמט AxBxC, למשל 4x8x8.
- המידות צריכות להיות ממוינות בסדר לא יורד: A <= B <= C. לדוגמה, הערך 4x8x4 לא תקין, והוא צריך להיות 4x4x8.
- מכפלת המידות (אורךרוחבגובה) לא יכולה להיות גדולה מ-9,216.
- הטופולוגיות הגדולות ביותר של פלחים שנתמכות יכולות לכלול עד 32 תת-בלוקים. לדוגמה, 8x16x16 עם 32 תת-בלוקים,8x12x20 עם 30 תת-בלוקים או 12x12x12 עם 27 תת-בלוקים הם במסגרת המגבלות המותרות.
‫cloud.google.com/gke-tpu-accelerator: tpu7x: מתזמן את ה-Pods במכונות וירטואליות שמריצות Ironwood ‏ (TPU7x).
‫kueue.x-k8s.io/queue-name: מקצה את JobSet ל-LocalQueue של Kueue.
ה-webhook מוסיף את זיקת הצומת שמוגדרת כברירת מחדל כדי לוודא שנעשה שימוש בצמתים HEALTHY ו-DEGRADED.

החלת המניפסט big-super-slice.yaml:
```
kubectl apply -f big-super-slice.yaml
```
אחרי שמחילים את המניפסט, Kueue יוצר JobSet בשם big-super-slice. לאחר מכן, Kueue מנסה ליצור פלח דינמי יחיד עם טופולוגיה של 4x12x16. אחרי שהפרוסה פעילה, Kueue מאשר את עומס העבודה, ו-192 הפודים מתוזמנים בצמתים כדי ליצור את הפרוסה הדינמית שמריצה את עומסי העבודה.

דוגמה 2: עומס עבודה עם יותר משכפול אחד

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

שומרים את קובץ המניפסט הבא בשם two-super-slices.yaml:

# Copyright 2026 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: jobset.x-k8s.io/v1alpha2
kind: JobSet
metadata:
  name: two-super-slices
  labels:
    kueue.x-k8s.io/queue-name: lq
spec:
  replicatedJobs:
    - name: job-jax
      replicas: 2
      template:
        spec:
          parallelism: 64  # Pods per slice calculation: (4*8*8) / 4 = 64
          completions: 64
          backoffLimit: 10
          template:
            metadata:
              annotations:
                cloud.google.com/gke-tpu-slice-topology: 4x8x8
            spec:
              tolerations:
                - key: "google.com/tpu"
                  operator: "Equal"
                  value: "present"
                  effect: "NoSchedule"
              nodeSelector:
                cloud.google.com/gke-tpu-accelerator: tpu7x
                cloud.google.com/gke-tpu-partition-4x4x4-state: "HEALTHY"
              containers:
                - name: jax
                  image: python:latest
                  command:
                    - bash
                    - -c
                    - |
                      printenv
                      pip install "jax[tpu]" -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
                      python -c 'import jax; print("Global device count:", jax.device_count(), "Local device count:", jax.local_device_count())'
                  resources:
                    limits:
                      google.com/tpu: 4
              restartPolicy: Never

החלת המניפסט two-super-slices.yaml:
```
kubectl apply -f two-super-slices.yaml
```

במניפסט הזה, מגדירים את השדה replicas לערך 2 בקטע replicatedJobs. אחרי שמחילים את המניפסט, Kueue מנסה ליצור שני פלחים נפרדים עם טופולוגיה של 4x8x8. ‫Kueue יוצר פרוסה דינמית לכל רפליקה שמוגדרת ב-jobset.spec.replicatedJobs[].replicas. אם מציינים n רפליקות, Kueue יוצר n פרוסות דינמיות לעומס העבודה וממתין עד שכל הפרוסות יהפכו לפעילות לפני שהוא מאשר את עומס העבודה.

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

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

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

הפעלת שימוש חוזר בתבניות תוכן דינמי

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

מגדירים את בקר הפרוסות: מעדכנים את ארגומנטי הפריסה של בקר הפרוסות של Kueue כדי לכלול את הדגל --reuse-slices=true. כדי לוודא שהעומסים מתוזמנים בצורה אופטימלית בפרוסות הקיימות, מוסיפים גם את הדגל --add-preferred-node-affinity=true.

הערה: לשכבות שניתן לעשות בהן שימוש חוזר ניתן שם באופן דינמי עם הקידומת s-<topology>, כך שהן לא מקושרות לשמות ספציפיים של עומסי עבודה.
הגדרה של Kueue (מומלץ): כדי לאפשר ל-Kueue להשתמש בהצעות של בקר לגבי העדפת צומת, צריך להפעיל את ה-Feature Gate TASRespectNodeAffinityPreferred בהגדרות של Kueue.

לדוגמה, עורכים את kueue-manager-config ConfigMap כדי להוסיף את Feature Gate:
```
apiVersion: v1
kind: ConfigMap
metadata:
  name: kueue-manager-config
  namespace: kueue-system
data:
  controller_manager_config.yaml: |
    apiVersion: config.kueue.x-k8s.io/v1beta1
    kind: Configuration
    featureGates:
      TASRespectNodeAffinityPreferred: true
    # ...
```
אחרי שמשנים את ConfigMap, מפעילים מחדש את הפריסה של kueue-controller-manager כדי לאכוף את השינוי:
```
kubectl rollout restart deploy kueue-controller-manager -n kueue-system
```
הערה: אפשר לעשות שימוש חוזר בפרוסות בגרסאות ישנות יותר של Kueue, אבל שיפור ההעדפה של שיוך צמתים תואם רק ל-Kueue גרסה 0.18 ואילך.

אכיפת מחיקה של פרוסות לפי עומס עבודה

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

מחילים את התווית הבאה על ההגדרה של Job או JobSet:
```
kueue.gke.io/tpu-enforce-slice-deletion: "true"
```
אחרי שמחילים את התווית הזו, עדיין אפשר לתזמן את עומס העבודה בפלח קיים של זמן המתנה. עם זאת, אחרי שכוח העבודה יסיים את הפעולה, הפרוסה תימחק באופן סופי ולא תחזור למאגר לשימוש חוזר.
כדי להגדיר את Kueue כך שהתווית הזו תועבר מהמסגרת Job לאובייקט Kueue Workload, מוסיפים את התווית לרשימה labelKeysToCopy בהגדרת Kueue:
```
labelKeysToCopy:
- "kueue.gke.io/tpu-enforce-slice-deletion"
```

מעקב אחרי הפלח

אפשר לראות את הסטטוס של הפלח ולעקוב אחרי מדדי הפלח באמצעות מדדי המערכת של GKE.

מעקב אחרי הסטטוס של הפרוסה

כשיוצרים פרוסה או כשעומס עבודה משתמש בה באופן פעיל, בקר הפרוסה מצרף תוויות כדי לזהות את עומס העבודה שמשתמש בה. מכיוון ששמות ה-Slice נוצרים באופן דינמי (ולא מקושרים לשם של עומס העבודה כשמופעלת האפשרות לשימוש חוזר), כדאי להשתמש בתוויות האלה כדי למצוא את ה-Slice שהוקצה לעומס העבודה.

כדי למצוא את הפרוסות שהוקצו לעומס עבודה, מריצים את הפקודה הבאה:
```
kubectl get slice -l kueue.gke.io/tpu-slice-used-by-namespace=NAMESPACE,kueue.gke.io/tpu-slice-used-by-workload=WORKLOAD_NAME
```
מחליפים את מה שכתוב בשדות הבאים:
- ‫NAMESPACE: מרחב השמות של עומס העבודה.
- ‫WORKLOAD_NAME: השם של עומס העבודה ב-Kueue, שבדרך כלל זהה לשם של Job או JobSet.
הערה: אם הערך של WORKLOAD_NAME ארוך מ-63 תווים, הוא ייחתך אוטומטית כדי להתאים לתווית.
מעתיקים את שם הפלח מהפלט של הפקודה הקודמת.
כדי לבדוק את הסטטוס המפורט של הפלח הדינמי, משתמשים בשם הפלח:
```
kubectl describe slice SLICE_NAME
```
מחליפים את SLICE_NAME בשם של הפרוסה.

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

Name:         s-4x4x4-74d3fb0b
Namespace:
Labels:       <none>
Annotations:  <none>
API Version:  accelerator.gke.io/v1beta1
Kind:         Slice
Metadata:
  Creation Timestamp:  2026-02-12T23:44:28Z
  Finalizers:
    accelerator.gke.io/slice-finalizer
  Generation:        1
  Resource Version:  1770939905695871008
  UID:               6dbbfe14-4486-4462-864d-e078d0ca8b5b
Spec:
  Partition Ids:
    5eae6a4f59d59cf30a9bf49de618eb2b
  Topology:  4x4x4
  Type:      tpu7x
Status:
  Conditions:
    Last Transition Time:  2026-02-12T23:45:05Z
    Message:
    Reason:                ACTIVE
    Status:                True
    Type:                  Ready
    Last Transition Time:  2026-02-12T23:45:05Z
    Message:               NodeLabelingCompleted
    Reason:                NodeLabelIsAdded
    Status:                True
    Type:                  NodeLabeled
Events:                    <none>

מעקב אחרי המדדים של הפלח

אפשר לעקוב אחרי מדדי המערכת הבאים של GKE שחושפים את מצב הפלח:

kubernetes.io/accelerator/slice/state
kubernetes.io/accelerator/partition/state
kubernetes.io/accelerator/slice/deformation_durations
kubernetes.io/accelerator/slice/formation_durations

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

מדדים של בקר Kueue Slice

אפשר גם לעקוב אחרי מדדי Prometheus הבאים שנחשפים על ידי Kueue Slice Controller כדי לבחון את מחזור החיים של הפרוסה, את השימוש החוזר ואת בדיקות הגישה:

מדדים של מחזור חיים לפי פלח

מדדים של מחזור החיים של פלחים עוקבים אחרי היצירה והמחיקה של פלחים:

‫tpu_ac_slice_create_time: היסטוגרמה שמודדת כמה זמן לקח ליצור פרוסה.
‫tpu_ac_slices_created: חלקי נתונים שנוצרו על ידי מעקב אחר מונה (כולל התווית is_reusable).
‫tpu_ac_slices_status: מד שמציג את מספר הפרוסות הנוכחי לפי סטטוס, כולל התוויות is_reusable ו-in_use.
‫tpu_ac_slice_delete_time: היסטוגרמה שמודדת כמה זמן לקח למחוק פרוסה.
‫tpu_ac_slices_deleted: מונה למעקב אחרי פרוסות שנמחקו.
‫tpu_ac_slices_gc: מעקב אחר מונה ניקה באופן אוטומטי את הפרוסות.

מדדים של שימוש חוזר בפלחים

מדדי השימוש החוזר בפרוסות עוקבים אחרי השימוש החוזר המוצלח בפרוסות TPU ואחרי קונפליקטים:

‫tpu_ac_slices_reused: מונה המעקב השתמש מחדש בפרוסות בהצלחה.
‫tpu_ac_slices_conflict: פרוסות מעקב של מונה נמחקו בגלל אי התאמות בטופולוגיה או בצורה.

מדדים של עומס עבודה וקבלה

מדדי עומס העבודה והקבלה עוקבים אחרי משך הזמן והתוצאות של בדיקות הקבלה:

‫tpu_ac_admission_time: היסטוגרמה שמודדת את משך תהליך בדיקת ההרשאה. הערה: המדד הזה מודד את משך הזמן של בדיקת ההרשאה של בקר הפרוסות, והוא לא כולל את זמן ההרשאה הכולל של עומס העבודה של Kueue.
‫tpu_ac_workload_processed: מונה של החלטות בדיקת הרשאה, שמכיל תווית target_state.

מדדים כלליים

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

‫tpu_ac_problem: מונה שעוקב אחרי בעיות או שגיאות תפעוליות. המדד הזה כולל את התווית problem שמציינת את סוג השגיאה הספציפי.

הערה: בגלל תהליך ההתאמה המקביל, יכול להיות שתראו מדי פעם שגיאות בשרת ה-API (מסומנות ב-API_SERVER_ERROR). השגיאות האלה יכולות להתרחש, למשל, כשהמערכת משנה משאב לא עדכני. הן לא מצביעות בהכרח על כשל במערכת.

הסרת המשאבים

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

מוחקים את JobSet. הפעולה הזו גורמת ל-Kueue למחוק את משאבי ה-Slice המותאמים אישית שמשויכים אליה.
```
kubectl delete jobset JOBSET_NAME
```
מחליפים את JOBSET_NAME בשם של JobSet, לדוגמה, big-super-slice.

הערה: משאבים מותאמים אישית של Active Slice חוסמים מחיקה של מאגר צמתים כדי לוודא שהמשאבים ינוקו בצורה תקינה. מחיקת ה-JobSet מבטיחה ש-Kueue ינקה את משאבי ה-Slice בהתאמה אישית לפני שתמשיכו במחיקה של מאגר הצמתים.

מוחקים את מאגר הצמתים של ה-TPU:

gcloud container node-pools delete NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location=LOCATION

(אופציונלי) שימוש בפריסה דינמית עם כלי לתזמון משלכם

במאמר הזה אנחנו מתמקדים בשימוש ב-Kueue וב-TAS. עם זאת, אפשר גם לנהל פריסה דינמית באמצעות מתזמן מותאם אישית משלכם. אם אתם בוחרים להשתמש בכלי תזמון אחר, אתם יכולים להיעזר במידע על משאב מותאם אישית מסוג Slice.