Google menggunakan teknologi AI untuk menerjemahkan konten ke dalam bahasa pilihan Anda. Terjemahan AI mungkin mengandung kesalahan.

Menjadwalkan slice dinamis dengan Kueue dan TAS

Standard

Dokumen ini menjelaskan cara menyediakan kumpulan node TPU dan menjadwalkan slice dinamis di Google Kubernetes Engine (GKE) menggunakan Kueue dan Penjadwalan yang Mendukung Topologi (TAS).

Anda juga dapat menggunakan pengirisan dinamis dengan berinteraksi langsung dengan Slice custom resources. Untuk mengetahui informasi selengkapnya, lihat Menggunakan pengirisan dinamis dengan penjadwal kustom.

Sebelum mengikuti petunjuk ini, pastikan Anda memahami konsep pengirisan dinamis.

Persyaratan

Untuk menggunakan pengirisan dinamis di GKE, Anda harus memenuhi persyaratan berikut:

Gunakan cluster Standar di saluran Cepat dalam salah satu versi berikut:
- Untuk konfigurasi super-slicing dinamis (topologi sama dengan atau lebih besar dari 4x4x4), gunakan versi 1.35.2-gke.1842000 atau yang lebih baru.
- Untuk konfigurasi sub-pengirisan dinamis (topologi yang lebih kecil dari 4x4x4), gunakan versi 1.36.0-gke.3712000 atau yang lebih baru.
Gunakan versi Ironwood (TPU7x).
Gunakan image Container-Optimized OS untuk node Anda.
Untuk menggunakan penyediaan inkremental, gunakan pemesanan mode Semua Kapasitas. Semua Mode kapasitas adalah fitur yang diaktifkan oleh TPU Cluster Director.
Untuk sub-pengirisan dinamis, pastikan node Anda memiliki peristiwa pemeliharaan tertunda. Pantau instance Anda untuk mengetahui peristiwa pemeliharaan yang tertunda. Jika ada node yang memiliki peristiwa pemeliharaan tertunda dengan waktu berakhir antara 18 September 2026 dan 30 September 2026, Anda harus memicu peristiwa pemeliharaan host secara manual di node tersebut sebelum dapat menggunakan sub-slicing.

Sebelum memulai

Sebelum memulai, pastikan Anda telah melakukan tugas berikut:

Aktifkan Google Kubernetes Engine API.

Aktifkan Google Kubernetes Engine API

Untuk menggunakan Google Cloud CLI untuk tugas ini, instal lalu lakukan inisialisasi gcloud CLI. Jika sebelumnya Anda telah menginstal gcloud CLI, dapatkan versi terbaru dengan menjalankan perintah gcloud components update. Versi gcloud CLI yang lebih lama mungkin tidak mendukung menjalankan perintah dalam dokumen ini.
Catatan: Untuk penginstalan gcloud CLI yang ada, pastikan untuk menyetel properti compute/region. Jika Anda terutama menggunakan cluster zona, tetapkan compute/zone sebagai gantinya. Dengan menyetel lokasi default, Anda dapat menghindari error di gcloud CLI yang seperti ini: One of [--zone, --region] must be supplied: Please specify location. Anda mungkin perlu menentukan lokasi dalam perintah tertentu jika lokasi cluster Anda berbeda dengan lokasi default yang Anda tetapkan.

Pastikan Anda memiliki cluster Standard yang sudah ada dalam versi 1.35.2-gke.1842000 atau yang lebih baru, di saluran Cepat. Untuk membuat cluster baru, lihat Membuat cluster regional.
Pastikan Anda memiliki kuota yang cukup untuk Ironwood (TPU7x) di region Anda.
Jika Anda berencana menjalankan workload multislice, instal JobSet v0.10.1 atau yang lebih baru
Minta kapasitas TPU dalam mode Semua Kapasitas.

Menggunakan pengelompokan dinamis di GKE dengan Kueue

Bagian ini menjelaskan alur kerja untuk menggunakan pengelompokan dinamis di GKE.

Melihat topologi dan status respons pemesanan mode Semua Kapasitas.
Aktifkan pengontrol slice di cluster Anda.
Instal Kueue, JobSet, dan LWS.
Buat node pool TPU.
Konfigurasi Kueue untuk membuat resource kustom Slice.
Menjalankan workload pada slicing dinamis dengan Kueue.
Pembersihan.

Mengaktifkan pengontrol irisan

Untuk menggunakan pengelompokan dinamis, aktifkan pengontrol slice di cluster Anda.

Perbarui cluster Anda:
```
gcloud container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --enable-slice-controller
```
Ganti kode berikut:
- CLUSTER_NAME: nama cluster Anda.
- LOCATION: region dengan kapasitas TPU yang tersedia.

Dapatkan kredensial agar Anda dapat berkomunikasi dengan cluster menggunakan perintah kubectl:

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

Di output perintah berikut, verifikasi bahwa nilai slices.accelerator.gke.io ada:
```
kubectl get crd slices.accelerator.gke.io
```
Outputnya mirip dengan hal berikut ini:
```
slices.accelerator.gke.io                2026-01-09T23:58:02Z
```

Menginstal Kueue, JobSet, dan LWS

Jika Anda telah menginstal Kueue, JobSet, dan LWS, Anda dapat melewati bagian ini.

Menginstal Kueue

Ikuti petunjuk dari dokumentasi Kueue atau jalankan perintah berikut:

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

Ganti KUEUE_VERSION dengan versi Kueue yang diperlukan berdasarkan persyaratan topologi Anda. Untuk sub-pengirisan dinamis, gunakan Kueue v0.18.2 atau yang lebih baru. Untuk super-slicing dinamis, gunakan Kueue v0.16.6 atau yang lebih baru.

Instal JobSet

Ikuti petunjuk dari dokumentasi JobSet atau jalankan perintah berikut:

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

Ganti JOBSET_VERSION dengan versi JobSet yang diperlukan berdasarkan persyaratan topologi Anda. Untuk sub-pengirisan dinamis, gunakan JobSet v0.12.0 atau yang lebih baru. Untuk super-slicing dinamis, gunakan JobSet v0.11.1 atau yang lebih baru.

Menginstal LWS

LeaderWorkerSet (LWS) hanya diperlukan untuk sub-pengirisan dinamis.

Ikuti petunjuk dari dokumentasi LWS atau jalankan perintah berikut:

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

Ganti LWS_VERSION dengan versi LWS yang diperlukan. Gunakan LWS v0.8.0 atau yang lebih baru.

Membuat node pool dengan penyediaan inkremental

Bagian ini menjelaskan cara membuat node pool TPU dengan penyediaan inkremental. GKE mengonversi semua kapasitas TPU Anda menjadi node pool yang terdiri dari grup 16 node VM Ironwood (TPU7x), atau sub-blok. GKE menyediakan node pool ini meskipun tidak dapat menemukan semua VM yang sehat dengan menempatkan node di bagian yang sehat dari mesin host dan menyediakan mesin yang tidak sehat secara bertahap saat diperbaiki.

Anda dapat menargetkan node pool agar termasuk dalam salah satu opsi berikut:

Blok TPU tertentu, yang ditampilkan dalam pemesanan mode Semua Kapasitas. Penargetan blok memungkinkan GKE membuat node pool di sub-blok yang tersedia dalam blok yang ditentukan.
Sub-blok tertentu, atau grup 16 node VM Ironwood (TPU7x) tertentu, dari TPU untuk kontrol yang lebih terperinci.

Membuat kebijakan workload

Untuk membuat node pool slice TPU dengan Ironwood (TPU7x), Anda harus membuat kebijakan workload terlebih dahulu dengan kolom accelerator-topology-mode disetel ke provision_only. Setelan ini memicu proses penyediaan inkremental.

Buat kebijakan workload:

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

Ganti kode berikut:

WORKLOAD_POLICY_NAME: nama untuk kebijakan workload Anda.
PROJECT_ID: Google Cloud Project ID Anda.
REGION: region untuk kebijakan workload.

Dalam perintah ini, lakukan hal berikut::

Selalu setel kolom accelerator-topology ke 4x4x4 agar sesuai dengan jumlah total chip dalam satu sub-blok.
Selalu tetapkan kolom accelerator-topology-mode ke provision_only untuk memastikan proses penyediaan inkremental dipicu. Jika kolom provision_only ditetapkan, node pool akan menyediakan node TPU tanpa membentuk link ICI atau OCS.

Menargetkan node pool Anda agar termasuk dalam blok atau sub-blok

Anda dapat menargetkan sub-blok atau blok tertentu dalam pemesanan mode Semua Kapasitas.

Menargetkan blok: setiap node pool menggunakan kapasitas dari blok tertentu. GKE menempatkan node pool dalam sub-blok yang tersedia di blok tersebut. Anda harus membuat node pool sebanyak jumlah sub-blok dalam blok yang ingin Anda gunakan.
Menargetkan sub-blok: setiap node pool dipetakan ke sub-blok tertentu yang tersedia. Saat menggunakan penargetan sub-blok, GKE akan membuat node pool jika setidaknya satu VM dalam kondisi baik. Penyediaan inkremental membantu memastikan bahwa semua node ditempatkan dalam sub-blok yang ditentukan.

Blokir

Untuk mengambil nama blok dalam reservasi dan jumlah sub-blok yang tersedia dalam blok, selesaikan langkah-langkah berikut dalam dokumen Melihat topologi dan status kondisi semua reservasi Mode Kapasitas:
1. Identifikasi nama blok dengan mencantumkan semua blok pemesanan dan menyalin nilai di kolom name:. Nilai ini adalah nama blok atau BLOCK_NAME dalam dokumen ini.
2. Tentukan jumlah node pool yang akan dibuat dengan mendeskripsikan blok pemesanan dan mengidentifikasi nilai di kolom reservationSubBlockCount. Nilai ini adalah jumlah sub-blok yang tersedia. Misalnya, nilai reservationSubBlockCount: 4 menunjukkan bahwa blok memiliki empat sub-blok yang tersedia, dan Anda perlu membuat empat kumpulan node terpisah.
Tetapkan jalur reservasi:
```
export RESERVATION_PATH="projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME"
```
Ganti kode berikut:
- RESERVATION_NAME: nama reservasi TPU Anda.
- BLOCK_NAME: nama blok.
Buat node pool untuk setiap sub-blok yang diidentifikasi pada langkah sebelumnya. Misalnya, jika jumlahnya adalah 4, jalankan perintah ini empat kali. Gunakan nama unik untuk setiap node pool.
```
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}
```
Ganti kode berikut:
- NODE_POOL_NAME: nama node pool baru.
- CLUSTER_NAME: nama cluster GKE Anda.
- WORKLOAD_POLICY_NAME: nama kebijakan workload yang Anda buat.
- ZONE: zona untuk node pool, misalnya, us-central1-a.

Sub-blok

Untuk mengambil nama blok dan ID sub-blok yang tersedia, selesaikan langkah-langkah berikut dalam dokumen Melihat topologi dan status kondisi reservasi Semua Mode Kapasitas:
1. Untuk mengidentifikasi nama blok, cantumkan semua blok reservasi dan salin nilai di kolom name:. Nilai ini adalah nama blok atau BLOCK_NAME pada dokumen ini.
2. Untuk mengidentifikasi nama sub-blok, cantumkan semua sub-blok dari suatu blok dan salin nilai di kolom name: untuk setiap entri di bagian reservationSubBlocks. Nilai ini adalah nama sub-blok atau SUBBLOCK_NAME dalam dokumen ini.

Tetapkan jalur reservasi:

export RESERVATION_PATH="projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME/reservationSubBlocks/SUBBLOCK_NAME"

Ganti kode berikut:

RESERVATION_NAME: nama reservasi TPU Anda.
BLOCK_NAME: nama blok.
SUBBLOCK_NAME: nama sub-blok.

Buat node pool:

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}

Ganti kode berikut:

NODE_POOL_NAME: nama unik untuk node pool baru Anda, misalnya, sub-block-pool-1.
PROJECT_ID: Google Cloud Project ID Anda.
CLUSTER_NAME: nama cluster GKE Anda.
ZONE: zona untuk node pool, misalnya, us-central2-b.
WORKLOAD_POLICY_NAME: nama kebijakan workload yang Anda buat.

Pada tahap ini, node dibuat, tetapi link Inter-Chip Interconnect (ICI)-nya belum aktif. Oleh karena itu, Anda tidak dapat menjalankan workload di node pool ini secara langsung.

Untuk mengaktifkan semua link ICI yang diperlukan untuk membentuk slice dan memungkinkan penjadwalan beban kerja, buat slice dinamis menggunakan salah satu metode berikut:

Buat Slice custom resource. Alih-alih Pods, Anda menggunakan resource kustom Slice untuk menentukan topologi yang ditentukan, yang diaktifkan oleh pengontrol slice.
Menjadwalkan workload GKE dengan Kueue dan TAS. Kueue secara otomatis menangani pembuatan dan penghapusan resource kustom Slice. Hindari memodifikasi secara manual resource kustom Slice yang dibuat oleh Kueue.

Membuat irisan dinamis dengan Kueue dan TAS

Di bagian ini, Anda akan menjadwalkan workload GKE dengan Kueue dan TAS.

Menginstal pengontrol slice Kueue

Untuk menginstal pengontrol slice Kueue, simpan manifes berikut sebagai 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
- apiGroups:
  - ray.io
  resources:
  - rayclusters
  - rayjobs
  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.10
        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
- admissionReviewVersions:
  - v1
  clientConfig:
    service:
      name: slice-controller-webhook-service
      namespace: slice-controller-system
      path: /mutate-ray-io-v1-raycluster
  failurePolicy: Fail
  name: mraycluster.kb.io
  rules:
  - apiGroups:
    - ray.io
    apiVersions:
    - v1
    operations:
    - CREATE
    resources:
    - rayclusters
  sideEffects: None
- admissionReviewVersions:
  - v1
  clientConfig:
    service:
      name: slice-controller-webhook-service
      namespace: slice-controller-system
      path: /mutate-ray-io-v1-rayjob
  failurePolicy: Fail
  name: mrayjob.kb.io
  rules:
  - apiGroups:
    - ray.io
    apiVersions:
    - v1
    operations:
    - CREATE
    resources:
    - rayjobs
  sideEffects: None

Terapkan manifes slice-controller.yaml:
```
kubectl apply -f slice-controller.yaml
```

Untuk mengonfigurasi Kueue untuk pengelompokan dinamis, simpan manifes berikut sebagai 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

Terapkan manifes dynamic-slice-topology.yaml:
```
kubectl apply -f dynamic-slice-topology.yaml
```
Dalam manifes ini, Anda mengonfigurasi Kueue untuk pengirisan dinamis dengan menentukan resource berikut:
- Topologi slice dinamis Ironwood (TPU7x) (superslice-topology): topologi menentukan level yang dipertimbangkan Kueue saat menjadwalkan workload slice dinamis. Tingkat tersebut adalah sebagai berikut:
  - Label cloud.google.com/gce-topology-block: tingkat ini diperlukan untuk memahami sub-blok mana yang termasuk dalam blok mana, karena hanya sub-blok dari blok yang sama yang dapat membentuk slice.
  - Label cloud.google.com/gke-tpu-partition-4x4x4-id: tingkat ini merepresentasikan sub-blok Ironwood (TPU7x) individual (topologi 4x4x4).
  - kubernetes.io/hostname label: tingkat ini diperlukan untuk menetapkan Pod ke VM tertentu dan untuk mengamati label dan taint-nya.
- ResourceFlavor SuperSlice Ironwood (TPU7x) (superslice-rf): Resource flavor untuk sub-blok Ironwood (TPU7x) mencakup label cloud.google.com/gke-tpu-accelerator: tpu7x agar cocok dengan node dengan mesin Ironwood (TPU7x).
- SuperSlice AdmissionCheck (superslice-ac): pemeriksaan penerimaan ini memberi tahu Kueue untuk tidak menjadwalkan workload hingga pengontrol slice GKE mengonfirmasi bahwa slice telah aktif. Pemeriksaan penerimaan pertama-tama ditentukan, lalu ditambahkan ke ClusterQueue yang menangani workload pengirisan dinamis.
- ClusterQueue (cq) dan LocalQueue (lq): kolom ini mengelola resource google.com/tpu. cq ClusterQueue mencakup pemeriksaan penerimaan superslice-ac. Kolom nominalQuota untuk google.com/tpu dapat dikonfigurasi dengan dua cara:
  - Kuota spesifik: tetapkan kolom nominalQuota agar sesuai dengan kapasitas yang ada untuk pengelolaan kuota dan pembagian yang adil.
  - Kuota tidak terbatas: tetapkan kolom nominalQuota ke nilai yang sangat tinggi seperti "999999", untuk memodelkan kuota tidak terbatas. Untuk berfokus pada TAS dan pengelompokan dinamis, konfigurasi ini melewati fungsi pengelolaan kuota Kueue.

Menentukan pilihan kesehatan partisi

Selain kesiapan dan kondisi node standar, GKE mengekspos status spesifik setiap bentuk partisi menggunakan label cloud.google.com/gke-tpu-partition-[shape]-state (dengan [shape] cocok dengan bentuk ID partisi, seperti 2x2x1, 2x2x2, 2x2x4, 2x4x4, atau 4x4x4). Label ini memungkinkan GKE memperhitungkan faktor-faktor yang memengaruhi pembentukan slice, seperti status link TPU. Konfigurasi sub-pengirisan dinamis (topologi yang lebih kecil dari 4x4x4) memerlukan GKE versi 1.36.0-gke.3712000 atau yang lebih baru.

Anda dapat menentukan nilai label status partisi sebagai berikut:

HEALTHY: partisi dalam kondisi baik dan berfungsi penuh.
DEGRADED: infrastruktur partisi dalam kondisi menurun, misalnya, karena penurunan kualitas link OCS. Partisi masih dapat membentuk slice, tetapi performa keseluruhan mungkin lebih rendah dibandingkan dengan partisi yang sehat. Status ini hanya berlaku untuk topologi 4x4x4 tingkat teratas. Topologi yang lebih kecil tidak memiliki status yang menurun.
UNHEALTHY: partisi tidak berfungsi dengan baik dan tidak dapat membentuk slice.
UNSET: status tidak ditentukan karena inisialisasi pengontrol slice GKE tidak berhasil.
INCOMPLETE: tidak semua node dalam partisi disediakan.

Webhook Pengontrol Slice Kueue memvalidasi apakah workload menyertakan persyaratan kesehatan partisi tertentu. Jika tidak ada preferensi yang ditunjukkan, webhook akan menyuntikkan afinitas node default.

Perilakunya adalah sebagai berikut:

Jika nodeSelector atau nodeAffinity yang menargetkan label cloud.google.com/gke-tpu-partition-[shape]-state ada, atau tersebut tidak akan berubah.

Jika tidak ada konfigurasi label seperti itu, webhook akan menyuntikkan afinitas node default berikut untuk memastikan hanya partisi yang tersedia yang digunakan:

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

Bagian berikut mencakup contoh saat label cloud.google.com/gke-tpu-partition-4x4x4-state dikonfigurasi untuk menentukan konfigurasi kondisi sub-blok yang berbeda.

Menjalankan workload pengujian pada pengirisan dinamis dengan Kueue

Bagian ini menjelaskan cara men-deploy workload pada pengirisan dinamis dengan Kueue dan TAS. Bagian ini mencakup contoh yang menunjukkan cara membuat workload slice dinamis dan workload yang terdiri dari beberapa slice. Workload dikirimkan sebagai JobSet.

Contoh 1: Satu workload menggunakan satu slice dinamis

Contoh berikut menjelaskan cara membuat beban kerja menggunakan slice dengan topologi 4x12x16, yang terdiri dari 12 sub-blok. Jumlah Pod dihitung sebagai: (4 * 12 * 16) / 4 chip per node = 192 Pod.

Simpan manifes berikut sebagai 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

Dalam manifes ini, anotasi berikut memberi tahu Kueue karakteristik dan topologi slice untuk mengonfigurasi hal berikut:

cloud.google.com/gke-tpu-slice-topology: menentukan "4x12x16" sebagai topologi slice dinamis. Persyaratan untuk topologi akselerator tpu7x mencakup aturan berikut:
- Untuk sub-pengirisan dinamis: Anda dapat menentukan topologi yang lebih kecil dari 4x4x4, seperti 2x2x1, 2x2x2, 2x2x4, atau 2x4x4. Topologi yang lebih kecil ini memerlukan GKE versi 1.36.0-gke.3712000 atau yang lebih baru.
- Untuk super-slicing dinamis: Anda dapat menentukan topologi yang sama dengan atau lebih besar dari 4x4x4. Untuk konfigurasi super-slicing dinamis, setiap dimensi topologi yang diminta harus kelipatan empat, misalnya 4A x 4B x 4C.
- Topologi harus berupa string tiga dimensi dalam format AxBxC, misalnya 4x8x8.
- Dimensi harus diurutkan dalam urutan tidak menurun: A <= B <= C. Misalnya, 4x8x4 tidak valid; seharusnya 4x4x8.
- Hasil perkalian dimensi (ABC) tidak boleh melebihi 9.216.
- Topologi slice terbesar yang didukung dapat mencakup hingga 32 sub-blok. Misalnya, 8x16x16 dengan 32 sub-blok,8x12x20 dengan 30 sub-blok, atau 12x12x12 dengan 27 sub-blok berada dalam batas yang diterima.
cloud.google.com/gke-tpu-accelerator: tpu7x: menjadwalkan Pod di VM yang menjalankan Ironwood (TPU7x).
kueue.x-k8s.io/queue-name: menetapkan JobSet ke LocalQueue Kueue.
Webhook menyuntikkan afinitas node default untuk memastikan node HEALTHY dan DEGRADED digunakan.

Terapkan manifes big-super-slice.yaml:
```
kubectl apply -f big-super-slice.yaml
```
Setelah Anda menerapkan manifes, Kueue akan membuat JobSet bernama big-super-slice. Kemudian, Kueue mencoba membentuk satu slice dinamis dengan topologi 4x12x16. Setelah slice aktif, Kueue akan menerima workload, dan 192 Pod akan dijadwalkan di node untuk membentuk slice dinamis yang menjalankan workload Anda.

Contoh 2: Workload dengan lebih dari satu replika

Contoh berikut menunjukkan cara membuat workload yang menggunakan dua slice dinamis, yang masing-masing terdiri dari empat sub-blok yang hanya menargetkan node HEALTHY.

Simpan manifes berikut sebagai 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

Terapkan manifes two-super-slices.yaml:
```
kubectl apply -f two-super-slices.yaml
```

Dalam manifes ini, Anda menetapkan kolom replicas ke 2 di bagian replicatedJobs. Setelah Anda menerapkan manifes, Kueue akan mencoba membentuk dua slice terpisah dengan topologi 4x8x8. Kueue membuat slice dinamis untuk setiap replika yang ditentukan dalam jobset.spec.replicatedJobs[].replicas. Jika n replika ditentukan, Kueue akan membuat n slice dinamis untuk beban kerja dan menunggu hingga semua slice menjadi aktif sebelum menerima beban kerja.

Mengoptimalkan penjadwalan beban kerja dengan penggunaan ulang slice

Secara default, Kueue menginstruksikan pengontrol slice untuk menyediakan slice TPU baru untuk setiap eksekusi workload dan menghapusnya saat workload selesai. Perilaku ini dapat menyebabkan churn dan overhead pada infrastruktur yang mendasarinya.

Dengan penggunaan ulang slice, workload baru dapat menggunakan kembali slice TPU yang ada dan tidak digunakan yang memiliki topologi dan batas hardware yang identik. Saat Anda mengaktifkan penggunaan ulang slice, Kueue menandai slice sebagai tidak aktif di akhir tugas, bukan menghapusnya. Tugas baru yang meminta partisi yang sama akan langsung mengklaim dan menggunakan kembali slice, yang melewati penundaan penyediaan hardware.

Mengaktifkan penggunaan ulang Slice

Untuk mengoptimalkan penggunaan ulang slice sepenuhnya, Anda harus mengonfigurasi pengontrol Slice dan Kueue agar dapat bekerja sama.

Konfigurasi pengontrol slice: perbarui argumen deployment pengontrol slice Kueue untuk menyertakan flag --reuse-slices=true. Untuk membantu memastikan workload dijadwalkan secara optimal pada slice yang ada, tambahkan juga tanda --add-preferred-node-affinity=true.

Catatan: Slice yang dapat digunakan kembali diberi nama secara dinamis dengan awalan s-<topology>, sehingga tidak terikat dengan nama beban kerja tertentu.
Konfigurasi Kueue (Direkomendasikan): Agar Kueue dapat menggunakan saran afinitas node pilihan pengontrol, Anda harus mengaktifkan gerbang fitur TASRespectNodeAffinityPreferred dalam konfigurasi Kueue.

Misalnya, edit ConfigMap kueue-manager-config untuk menambahkan 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
    # ...
```
Setelah mengubah ConfigMap, mulai ulang deployment kueue-controller-manager untuk menerapkan perubahan:
```
kubectl rollout restart deploy kueue-controller-manager -n kueue-system
```
Catatan: Penggunaan ulang slice berfungsi pada versi Kueue yang lebih lama, tetapi peningkatan afinitas node yang lebih disukai hanya kompatibel dengan Kueue v0.18 atau yang lebih baru.

Menerapkan penghapusan slice per workload

Agar workload tertentu membersihkan slice-nya dan mencegah penggunaan ulang slice, selesaikan langkah-langkah berikut:

Terapkan label berikut ke definisi Job atau JobSet Anda:
```
kueue.gke.io/tpu-enforce-slice-deletion: "true"
```
Setelah Anda menerapkan label ini, workload masih dapat dijadwalkan pada slice tidak aktif yang ada. Namun, setelah workload selesai, slice akan dihapus secara permanen, bukan dikembalikan ke kumpulan yang dapat digunakan kembali.
Konfigurasi Kueue untuk meneruskan label ini dari Job framework ke objek Workload Kueue dengan menambahkan label ke daftar labelKeysToCopy dalam konfigurasi Kueue Anda:
```
labelKeysToCopy:
- "kueue.gke.io/tpu-enforce-slice-deletion"
```

Memantau slice

Anda dapat melihat status slice dan memantau metrik slice dengan metrik sistem GKE.

Memantau status irisan

Saat slice dibuat atau digunakan secara aktif oleh beban kerja, pengontrol slice akan melampirkan label untuk mengidentifikasi beban kerja yang menggunakannya. Karena nama Slice dibuat secara dinamis (dan tidak terkait dengan nama workload saat penggunaan ulang diaktifkan), Anda harus menggunakan label ini untuk menemukan slice yang ditetapkan ke workload Anda.

Untuk menemukan slice yang ditetapkan ke workload, jalankan perintah berikut:
```
kubectl get slice -l kueue.gke.io/tpu-slice-used-by-namespace=NAMESPACE,kueue.gke.io/tpu-slice-used-by-workload=WORKLOAD_NAME
```
Ganti kode berikut:
- NAMESPACE: namespace workload Anda.
- WORKLOAD_NAME: nama Kueue Workload, yang biasanya sama dengan nama Job atau JobSet Anda.
Catatan: Jika WORKLOAD_NAME lebih panjang dari 63 karakter, akan otomatis dipangkas untuk label.
Salin nama slice dari output perintah sebelumnya.
Gunakan nama slice untuk memeriksa status mendetail slice dinamis Anda:
```
kubectl describe slice SLICE_NAME
```
Ganti SLICE_NAME dengan nama slice Anda.

Outputnya mirip dengan hal berikut ini:

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>

Memantau metrik slice

Anda dapat memantau metrik sistem GKE berikut yang menunjukkan kondisi slice:

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

Untuk mengetahui informasi selengkapnya tentang metrik, lihat Metrik sistem GKE.

Metrik pengontrol Slice Kueue

Anda juga dapat memantau metrik Prometheus berikut yang diekspos oleh Kueue Slice Controller untuk mengamati siklus proses slice, penggunaan ulang, dan pemeriksaan penerimaan:

Metrik siklus proses slice

Metrik siklus proses slice melacak pembuatan dan penghapusan slice:

tpu_ac_slice_create_time: Histogram yang mengukur durasi pembuatan irisan.
tpu_ac_slices_created: Slice pelacakan penghitung yang dibuat (mencakup label is_reusable).
tpu_ac_slices_status: Pengukur yang melacak jumlah slice saat ini menurut status, termasuk label is_reusable dan in_use.
tpu_ac_slice_delete_time: Histogram yang mengukur durasi penghapusan irisan.
tpu_ac_slices_deleted: Penghitung yang melacak irisan yang dihapus.
tpu_ac_slices_gc: Pelacakan penghitung otomatis membersihkan slice.

Metrik penggunaan ulang irisan

Metrik penggunaan ulang slice melacak keberhasilan penggunaan ulang dan konflik slice TPU:

tpu_ac_slices_reused: Pelacakan penghitung berhasil menggunakan kembali irisan.
tpu_ac_slices_conflict: Slice pelacakan penghitung dihapus karena topologi atau bentuk tidak cocok.

Metrik workload dan penerimaan

Metrik beban kerja dan penerimaan melacak durasi dan hasil pemeriksaan penerimaan:

tpu_ac_admission_time: Histogram yang mengukur durasi proses pemeriksaan penerimaan. Catatan: Metrik ini mengukur durasi pemeriksaan penerimaan pengontrol slice dan tidak mencakup waktu penerimaan beban kerja Kueue secara keseluruhan.
tpu_ac_workload_processed: Penghitung keputusan pemeriksaan penerimaan, yang berisi label target_state.

Metrik umum

Metrik umum melacak masalah dan error operasional:

tpu_ac_problem: Penghitung yang melacak masalah atau error operasional. Metrik ini mencakup label problem yang menunjukkan jenis error tertentu.

Catatan: Karena rekonsiliasi serentak, Anda mungkin melihat error server API sesekali (berlabel API_SERVER_ERROR). Error ini dapat terjadi, misalnya, saat sistem mengubah resource yang tidak berlaku. Peristiwa ini tidak selalu menunjukkan kegagalan sistem.

Pembersihan

Untuk menghindari tagihan yang tidak terduga, hapus slice Anda sebelum menghapus kumpulan node.

Hapus JobSet. Tindakan ini akan memicu Kueue untuk menghapus resource kustom Slice terkait.
```
kubectl delete jobset JOBSET_NAME
```
Ganti JOBSET_NAME dengan nama JobSet Anda, misalnya, big-super-slice.

Catatan: Resource kustom Active Slice memblokir penghapusan node pool untuk memastikan resource dibersihkan dengan benar. Menghapus JobSet memastikan bahwa Kueue membersihkan resource kustom Slice sebelum Anda melanjutkan penghapusan node pool.

Hapus TPU node pool:

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

(Opsional) Menggunakan pengirisan dinamis dengan penjadwal Anda sendiri

Dokumen ini berfokus pada penggunaan Kueue dan TAS. Namun, Anda juga dapat mengelola pengirisan dinamis dengan penjadwal kustom Anda sendiri. Jika Anda memilih untuk menggunakan penjadwal lain, ikuti informasi referensi Slice custom resource.

Langkah berikutnya

Pelajari TPU Cluster Director lebih lanjut.
Pelajari cara Mengelola peristiwa pemeliharaan dengan TPU dalam mode Semua Kapasitas.

Menjadwalkan slice dinamis dengan Kueue dan TAS Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Persyaratan

Sebelum memulai

Menggunakan pengelompokan dinamis di GKE dengan Kueue

Mengaktifkan pengontrol irisan

Menginstal Kueue, JobSet, dan LWS

Menginstal Kueue

Instal JobSet

Menginstal LWS

Membuat node pool dengan penyediaan inkremental

Membuat kebijakan workload

Menargetkan node pool Anda agar termasuk dalam blok atau sub-blok

Blokir

Sub-blok

Membuat irisan dinamis dengan Kueue dan TAS

Menginstal pengontrol slice Kueue

Menentukan pilihan kesehatan partisi

Menjalankan workload pengujian pada pengirisan dinamis dengan Kueue

Contoh 1: Satu workload menggunakan satu slice dinamis

Contoh 2: Workload dengan lebih dari satu replika

Mengoptimalkan penjadwalan beban kerja dengan penggunaan ulang slice

Mengaktifkan penggunaan ulang Slice

Menerapkan penghapusan slice per workload

Memantau slice

Memantau status irisan

Memantau metrik slice

Metrik pengontrol Slice Kueue

Pembersihan

(Opsional) Menggunakan pengirisan dinamis dengan penjadwal Anda sendiri

Langkah berikutnya

Menjadwalkan slice dinamis dengan Kueue dan TAS