Menjadwalkan slice dinamis dengan Kueue dan TAS

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 pengelompokan dinamis di GKE, Anda harus memenuhi persyaratan berikut:

  • Gunakan cluster Standard 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-slice 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.

Menggunakan slicing dinamis di GKE dengan Kueue

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

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

Aktifkan pengontrol slice

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

  1. Perbarui cluster Anda:

    gcloud container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --enable-slice-controller

    Ganti kode berikut:

  2. 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

  3. 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 kumpulan node 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 kumpulan node 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 beban kerja

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 akan memicu proses penyediaan inkremental.

Buat kebijakan beban kerja:

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 reservasi 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 ada satu VM yang berfungsi dengan baik. Penyediaan inkremental membantu memastikan bahwa semua node ditempatkan dalam sub-blok yang ditentukan.

Blokir

  1. 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 reservasi 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.

  2. Menetapkan 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.

  3. 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

  1. 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.

  2. Menetapkan 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.

  3. 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. Sebagai ganti Pod, 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 slice dinamis dengan Kueue dan TAS

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

Instal pengontrol slice Kueue

  1. 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: ClusterRole
metadata:
  labels:
    control-plane: controller-manager
  name: slice-controller-manager-role
rules:
- apiGroups:
  - ""
  resources:
  - events
  verbs:
  - create
  - patch
  - update
  - watch
- apiGroups:
  - ""
  resources:
  - nodes
  - pods
  verbs:
  - get
  - list
  - watch
- apiGroups:
  - ""
  resources:
  - secrets
  verbs:
  - get
  - list
  - update
  - 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:
  - admissionregistration.k8s.io
  resources:
  - mutatingwebhookconfigurations
  verbs:
  - get
  - list
  - update
  - watch
- apiGroups:
  - batch
  resources:
  - jobs
  verbs:
  - get
  - list
  - patch
  - update
  - watch
- apiGroups:
  - jobset.x-k8s.io
  resources:
  - jobsets
  verbs:
  - get
  - list
  - patch
  - update
  - watch
- apiGroups:
  - leaderworkerset.x-k8s.io
  resources:
  - leaderworkersets
  verbs:
  - get
  - list
  - patch
  - update
  - watch
- apiGroups:
  - kueue.x-k8s.io
  resources:
  - admissionchecks
  - admissionchecks/status
  - workloads/status
  verbs:
  - get
  - patch
  - update
- apiGroups:
  - kueue.x-k8s.io
  resources:
  - workloads
  verbs:
  - create
  - 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: 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=6m
        command:
        - /manager
        image: tpuongke/kueue-slice-controller:latest
        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: 12000m
            memory: 32Gi
          requests:
            cpu: 8000m
            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

  2. Terapkan manifes slice-controller.yaml:

    kubectl apply -f slice-controller.yaml

  3. 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

  4. 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 tingkat yang dipertimbangkan Kueue saat menjadwalkan workload slice dinamis. Level ini 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).
      • label kubernetes.io/hostname: tingkat ini diperlukan untuk menetapkan Pod ke VM tertentu dan untuk mengamati label dan taint-nya.
    • ResourceFlavor SuperSlice Ironwood (TPU7x) (superslice-rf): ResourceFlavor 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 menjadi 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. ClusterQueue cq mencakup 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 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 dalam kondisi 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 Kueue Slice Controller memvalidasi apakah workload menyertakan persyaratan kondisi 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, nodeSelector atau nodeAffinity 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 kesehatan 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: Workload tunggal menggunakan slice dinamis tunggal

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.

  1. 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.

  2. 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 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.

  1. 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

  2. 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 mengizinkan beban kerja.

Memantau slice

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

Memantau status slice

Untuk memeriksa status slice dinamis, jalankan perintah berikut:

kubectl describe slice SLICE_NAME

Ganti SLICE_NAME dengan nama slice Anda. Nama slice biasanya berasal dari nama JobSet dan indeks replika. Untuk Contoh 1, slice yang dibuat oleh Kueue akan memiliki nama yang mirip dengan default-jobset-big-super-slice-yyyyy-job-jax-0.

Outputnya mirip dengan hal berikut ini:

Name:         test-slice
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>

Nama slice mematuhi aturan berikut untuk memastikan kompatibilitas dengan konvensi penamaan resource Compute Engine yang mendasarinya:

  • Template: {namespace}-jobset-{jobset.metadata.name}-kueueHash[5-character]-{jobset.spec.replicatedJobs[].name}-sliceIndex.
  • Panjang: nama memiliki 49 karakter atau kurang. Aplikasi pengontrol menambahkan tanda hubung dan hash cluster 8 karakter untuk membuat nama resource Compute Engine, yang memiliki batas 63 karakter.
  • Format: nama cocok dengan ekspresi reguler ^[a-z]([-a-z0-9]*[a-z0-9])?$. Nama tersebut memiliki karakteristik berikut:
    • Dimulai dengan huruf kecil.
    • Hanya berisi huruf kecil, angka, dan tanda hubung (-).
    • Diakhiri dengan huruf kecil atau angka (tidak boleh diakhiri dengan tanda hubung).

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.

Pembersihan

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

  1. 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.

  2. 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