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 node pool TPU dan menjadwalkan slice dinamis di Google Kubernetes Engine (GKE) menggunakan Kueue dan Topology Aware Scheduling (TAS).

Anda juga dapat menggunakan slicing dinamis dengan berinteraksi langsung dengan resource kustom Slice. Untuk mengetahui informasi selengkapnya, lihat Menggunakan slicing dinamis dengan penjadwal kustom.

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

Persyaratan

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

Gunakan cluster Standard di saluran Rapid di salah satu versi berikut:
- Untuk konfigurasi super-slicing dinamis (topologi yang sama dengan atau lebih besar dari 4x4x4), gunakan versi 1.35.2-gke.1842000 atau yang lebih baru.
- Untuk konfigurasi sub-slicing 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. Mode All Capacity adalah fitur yang diaktifkan oleh TPU Cluster Director.
Untuk sub-slicing dinamis, pastikan node Anda memiliki peristiwa pemeliharaan yang tertunda. Pantau instance Anda untuk mengetahui peristiwa pemeliharaan yang tertunda. Jika ada node Anda yang memiliki peristiwa pemeliharaan tertunda dengan waktu berakhir antara 18 September 2026 dan 30 September 2026, Anda harus memicu peristiwa pemeliharaan host secara manual pada 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 menggunakan cluster zona, tetapkan compute/zone. Dengan menetapkan lokasi default, Anda dapat menghindari error di gcloud CLI seperti berikut: One of [--zone, --region] must be supplied: Please specify location. Anda mungkin perlu menentukan lokasi dalam perintah tertentu jika lokasi cluster Anda berbeda dengan default yang Anda tetapkan.

Pastikan Anda memiliki cluster Standard yang 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
Meminta kapasitas TPU dalam mode All Capacity.

Menggunakan slicing dinamis di GKE dengan Kueue

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

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

Mengaktifkan pengontrol slice

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

Update 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

Dalam output perintah berikut, pastikan 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 sudah 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-slicing dinamis, gunakan Kueue v0.18.2 atau yang lebih baru. Untuk super-slicing dinamis, gunakan Kueue v0.16.6 atau yang lebih baru.

Menginstal 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-slicing 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-slicing 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 responsif dengan menempatkan node di bagian mesin host yang responsif dan secara bertahap menyediakan mesin yang tidak responsif saat diperbaiki.

Anda dapat menargetkan node pool agar menjadi bagian dari salah satu hal berikut:

Blok TPU tertentu, yang ditampilkan dalam pemesanan mode All Capacity. Penargetan blok memungkinkan GKE membuat node pool di sub-blok yang tersedia dalam blok yang ditentukan.
Sub-blok tertentu, atau grup VM Ironwood (TPU7x) 16 node 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 yang ditetapkan 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: Project ID Google Cloud Anda.
REGION: region untuk kebijakan workload.

Dalam perintah ini, lakukan hal berikut:

Selalu tetapkan 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 agar menjadi bagian dari 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 yang ditentukan. GKE menempatkan node pool dalam sub-blok yang tersedia di blok tersebut. Anda harus membuat node pool sebanyak sub-blok dalam blok yang ingin Anda gunakan.
Menargetkan sub-blok: setiap node pool dipetakan ke sub-blok tertentu dan tersedia. Saat menggunakan penargetan sub-blok, GKE akan membuat node pool jika setidaknya satu VM responsif. Penyediaan inkremental membantu memastikan bahwa semua node ditempatkan dalam sub-blok yang ditentukan.

Blokir

Untuk mengambil nama blok dalam pemesanan dan jumlah sub-blok yang tersedia dalam blok, selesaikan langkah-langkah berikut dalam dokumen Melihat topologi dan status respons pemesanan Mode Semua 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 node pool terpisah.
Tetapkan jalur pemesanan:
```
export RESERVATION_PATH="projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME"
```
Ganti kode berikut:
- RESERVATION_NAME: nama pemesanan 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 responsivitas reservasi Mode Semua Kapasitas:
1. Untuk mengidentifikasi nama blok, cantumkan semua blok pemesanan 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 sebuah 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 pemesanan:

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

Ganti kode berikut:

RESERVATION_NAME: nama pemesanan 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: Project ID Google Cloud 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) 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 workload dijadwalkan, buat slice dinamis menggunakan salah satu metode berikut:

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

Membuat slice 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 slicing 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 slicing dinamis dengan menentukan resource berikut:
- Topologi slicing dinamis Ironwood (TPU7x) (superslice-topology): topologi menentukan level yang dipertimbangkan Kueue saat menjadwalkan workload slicing dinamis. Level ini adalah sebagai berikut:
  - Label cloud.google.com/gce-topology-block: level 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: level ini mewakili sub-blok Ironwood (TPU7x) individual (topologi 4x4x4).
  - Label kubernetes.io/hostname: level ini diperlukan untuk menetapkan Pod ke VM tertentu dan untuk mengamati label dan taint-nya.
- ResourceFlavor SuperSlice Ironwood (TPU7x) (superslice-rf): ragam resource untuk sub-blok Ironwood (TPU7x) mencakup label cloud.google.com/gke-tpu-accelerator: tpu7x untuk mencocokkan 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 slicing dinamis.
- ClusterQueue (cq) dan LocalQueue (lq): kolom ini mengelola resource google.com/tpu. cq ClusterQueue menyertakan pemeriksaan penerimaan superslice-ac. Kolom nominalQuota untuk google.com/tpu dapat dikonfigurasi dengan dua cara:
  - Kuota tertentu: tetapkan kolom nominalQuota agar sesuai dengan kapasitas yang ada untuk pembagian yang adil dan pengelolaan kuota.
  - Kuota tidak terbatas: tetapkan kolom nominalQuota ke nilai yang sangat tinggi seperti "999999", untuk membuat model kuota tidak terbatas. Untuk berfokus pada TAS dan slicing dinamis, konfigurasi ini mengabaikan fungsi pengelolaan kuota Kueue.

Menentukan pilihan kondisi partisi

Selain kondisi dan kesiapan 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 yang memengaruhi pembentukan slice, seperti status link TPU. Konfigurasi sub-slicing 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 responsif dan berfungsi sepenuhnya.
DEGRADED: infrastruktur partisi dalam status menurun, misalnya, karena penurunan link OCS. Partisi masih dapat membentuk slice, tetapi performa keseluruhan mungkin lebih rendah dibandingkan dengan partisi yang responsif. Status ini hanya berlaku untuk topologi 4x4x4 tingkat teratas. Topologi yang lebih kecil tidak memiliki status menurun.
UNHEALTHY: partisi tidak responsif dan tidak dapat membentuk slice.
UNSET: status tidak ditentukan karena inisialisasi pengontrol slice GKE tidak berhasil.
INCOMPLETE: tidak semua node dalam partisi disediakan.

Webhook Kueue Slice Controller memvalidasi apakah workload menyertakan persyaratan kondisi partisi tertentu. Jika tidak ada preferensi yang ditunjukkan, webhook akan memasukkan afinitas node default.

Perilakunya adalah sebagai berikut:

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

Jika konfigurasi label tersebut tidak ada, webhook akan memasukkan 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 slicing dinamis dengan Kueue

Bagian ini menjelaskan cara men-deploy workload pada slicing dinamis dengan Kueue dan TAS. Artikel ini menyertakan contoh yang menunjukkan cara membuat workload slice dinamis dan workload yang terdiri dari beberapa slice. Workload dikirim sebagai JobSet.

Contoh 1: Workload tunggal menggunakan slice dinamis tunggal

Contoh berikut menjelaskan cara membuat workload 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-slicing 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 merupakan 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 memasukkan 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. Kueue kemudian 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, 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 di jobset.spec.replicatedJobs[].replicas. Jika replika n ditentukan, Kueue akan membuat slice dinamis n untuk workload dan menunggu semua slice menjadi aktif sebelum menerima workload.

Mengoptimalkan penjadwalan workload dengan penggunaan kembali 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 kembali slice, workload baru dapat menggunakan kembali slice TPU yang ada dan tidak ada aktivitas yang memiliki topologi dan batas hardware yang sama. Saat Anda mengaktifkan penggunaan kembali slice, Kueue akan menandai slice sebagai tidak ada aktivitas di akhir tugas, bukan menghapusnya. Tugas baru yang meminta partisi yang sama akan langsung mengklaim dan menggunakan kembali slice, sehingga mengabaikan penundaan penyediaan hardware.

Mengaktifkan penggunaan kembali Slice

Untuk mengoptimalkan penggunaan kembali slice sepenuhnya, Anda harus mengonfigurasi pengontrol Slice dan Kueue agar berfungsi bersama.

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 flag --add-preferred-node-affinity=true.

Catatan: Slice yang dapat digunakan kembali diberi nama secara dinamis dengan awalan s-<topology>, sehingga tidak terkait dengan nama workload tertentu.
Mengonfigurasi Kueue (Direkomendasikan): agar Kueue dapat menggunakan saran afinitas node pilihan pengontrol, Anda harus mengaktifkan feature gate TASRespectNodeAffinityPreferred di 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 kembali slice berfungsi pada versi Kueue yang lebih lama, tetapi peningkatan afinitas node yang direkomendasikan hanya kompatibel dengan Kueue v0.18 atau yang lebih baru.

Menerapkan penghapusan slice per workload

Agar workload tertentu membersihkan slice-nya dan mencegah penggunaan kembali 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 ada aktivitas yang ada. Namun, setelah workload selesai, slice akan dihapus secara permanen, bukan dikembalikan ke pool yang dapat digunakan kembali.
Konfigurasikan Kueue untuk meneruskan label ini dari Tugas 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 slice

Saat slice dibuat atau digunakan secara aktif oleh workload, pengontrol slice akan melampirkan label untuk mengidentifikasi workload yang menggunakannya. Karena nama Slice dibuat secara dinamis (dan dipisahkan dari nama workload saat penggunaan kembali 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 Workload Kueue, yang biasanya sama dengan nama Tugas atau JobSet Anda.
Catatan: Jika WORKLOAD_NAME lebih panjang dari 63 karakter, label akan otomatis dipangkas.
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 mengekspos 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 Kueue Slice

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

Metrik siklus proses slice

Metrik siklus proses slice melacak pembuatan dan penghapusan slice:

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

Metrik penggunaan kembali slice

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

tpu_ac_slices_reused: Pelacakan penghitung berhasil menggunakan kembali slice.
tpu_ac_slices_conflict: Penghitung yang melacak slice yang dihapus karena ketidakcocokan topologi atau bentuk.

Metrik workload dan penerimaan

Metrik workload dan penerimaan melacak durasi dan hasil pemeriksaan penerimaan:

tpu_ac_admission_time: Histogram yang mengukur durasi proses pemeriksaan penerimaan. Catatan: Tindakan ini mengukur durasi pemeriksaan penerimaan pengontrol slice dan tidak mencakup waktu penerimaan workload 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 menyertakan label problem yang menunjukkan jenis error tertentu.

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

Pembersihan

Untuk menghindari tagihan tak terduga, hapus slice Anda sebelum menghapus node pool.

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 akan memastikan 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 slicing dinamis dengan penjadwal Anda sendiri

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

Langkah berikutnya

Pelajari TPU Cluster Director lebih lanjut.
Pelajari cara Mengelola peristiwa pemeliharaan dengan TPU dalam mode All Capacity.
Pelajari cara men-deploy workload Cloud TPU dengan slicing dinamis di Cluster Toolkit.

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

Persyaratan

Sebelum memulai

Menggunakan slicing dinamis di GKE dengan Kueue

Mengaktifkan pengontrol slice

Menginstal Kueue, JobSet, dan LWS

Menginstal Kueue

Menginstal JobSet

Menginstal LWS

Membuat node pool dengan penyediaan inkremental

Membuat kebijakan workload

Menargetkan node pool agar menjadi bagian dari blok atau sub-blok

Blokir

Sub-blok

Membuat slice dinamis dengan Kueue dan TAS

Menginstal pengontrol slice Kueue

Menentukan pilihan kondisi partisi

Menjalankan workload pengujian pada slicing dinamis dengan Kueue

Contoh 1: Workload tunggal menggunakan slice dinamis tunggal

Contoh 2: Workload dengan lebih dari satu replika

Mengoptimalkan penjadwalan workload dengan penggunaan kembali slice

Mengaktifkan penggunaan kembali Slice

Menerapkan penghapusan slice per workload

Memantau slice

Memantau status slice

Memantau metrik slice

Metrik pengontrol Kueue Slice

Pembersihan

(Opsional) Menggunakan slicing dinamis dengan penjadwal Anda sendiri

Langkah berikutnya

Menjadwalkan slice dinamis dengan Kueue dan TAS