Mengonfigurasi TPU dengan penslicingan dinamis GKE

Dokumen ini menjelaskan cara menggunakan pengirisan dinamis di Google Kubernetes Engine (GKE). Dengan slicing dinamis, Anda dapat mengonfigurasi sub-blok TPU yang disediakan ke dalam topologi yang berbeda. Kemampuan ini mengurangi kebutuhan untuk membuat ulang kumpulan node, meningkatkan toleransi fault dengan memungkinkan pemulihan otomatis saat terjadi kegagalan, dan mengoptimalkan pemanfaatan resource.

Dokumen ini ditujukan untuk engineer AI/ML dan administrator platform yang ingin mengoptimalkan pemanfaatan TPU, mengurangi waktu penyediaan, dan meningkatkan toleransi kesalahan untuk workload inferensi dan pelatihan skala besar.

Sebelum membaca dokumen ini, pastikan Anda memahami hal-hal berikut:

Apa itu pengelompokan dinamis?

Pengirisan dinamis memberikan fleksibilitas dalam mengelola kapasitas Cloud TPU dengan memungkinkan Anda memisahkan penyediaan TPU. Pengirisan dinamis melibatkan proses berikut:

  1. Anda menyediakan sumber daya sebagai unit yang lebih kecil yang disebut sub-blok. Sub-blok adalah unit penyusun logis mendasar dari kapasitas Ironwood (TPU7x). Untuk Ironwood (TPU7x), ini merepresentasikan grup 16 node VM TPU dengan topologi 4x4x4 dari chip TPU yang saling terhubung. Dalam konteks mode Semua Kapasitas TPU dan slicing dinamis, node pool dipetakan langsung ke sub-blok.
  2. Pengirisan dinamis kemudian menggabungkan sub-blok ini menjadi irisan yang lebih besar.

Manfaat pengirisan dinamis

Pengelompokan dinamis membantu Anda mencapai hal berikut:

  • Mengurangi waktu penyediaan: penyediaan sub-blok secara individual menghasilkan penyediaan keseluruhan yang lebih cepat karena meminimalkan dampak dari satu kegagalan.
  • Mengurangi waktu pemulihan: jika terjadi kegagalan chip TPU, unit kegagalan terkecil adalah sub-blok. Pengelompokan dinamis mengisolasi sub-blok yang rusak sehingga workload dapat dijadwalkan ulang pada sub-blok yang berfungsi dengan lebih cepat daripada memulihkan seluruh slice besar.
  • Membentuk ulang kapasitas: jika Anda memiliki beragam persyaratan workload, Anda tidak perlu menghapus dan membuat ulang kumpulan node untuk perubahan topologi, yang diperlukan tanpa pengirisan dinamis. Sebagai gantinya, Anda dapat mengonfigurasi ulang node pool yang disediakan secara dinamis agar sesuai dengan bentuk yang ditentukan.

Elemen utama pengirisan dinamis

Pengirisan dinamis memperkenalkan konsep utama berikut:

  • Penyediaan inkremental node pool: pengirisan dinamis menggunakan penyediaan inkremental, yang merupakan model penyediaan node pool yang toleran terhadap kesalahan. Model ini mengonversi semua kapasitas TPU Anda menjadi node pool grup 16 node VM TPU.
  • Pengontrol slice: pengontrol Resource Kustom Kubernetes yang berjalan dalam bidang kontrol GKE yang mengelola slicing dinamis. Pengontrol slice mengelola siklus proses resource kustom Slice, yang merepresentasikan slice dinamis. Pengontrol slice menangani pembuatan, pemantauan berkelanjutan, dan penghapusan Slice. Saat Anda menggunakan penjadwal, penjadwal akan mengarahkan pembuatan dan penghapusan resource kustom Slice.
  • Resource kustom slice: menggabungkan sub-blok ini secara dinamis berdasarkan topologi TPU yang diminta. Proses ini mengandalkan konfigurasi ulang dinamis jaringan OCS untuk menghubungkan kumpulan node TPU, yang membantu memastikan performa yang dioptimalkan. Anda dapat memeriksa progres atau kondisi pembentukan slice dinamis dengan memeriksa kolom status resource kustom Slice.

Persyaratan

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

  • Gunakan cluster Standard dalam versi 1.35.0-gke.274500 atau yang lebih baru, di saluran Cepat.
  • 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.

Sebelum memulai

Sebelum memulai, pastikan Anda telah melakukan tugas berikut:

  • Aktifkan Google Kubernetes Engine API.
    • Aktifkan Google Kubernetes Engine API
  • Jika ingin 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. gcloud CLI versi sebelumnya mungkin tidak mendukung menjalankan perintah dalam dokumen ini.

Batasan

  • Satu slice harus menggunakan sub-blok dalam blok TPU yang sama dalam reservasi. Untuk menggunakan sub-blok di seluruh blok TPU, gunakan TPU Multislice.
  • Pengirisan dinamis tidak mendukung topologi yang lebih kecil dari 4x4x4.

Menggunakan pengelompokan 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. Buat node pool TPU.
  4. Konfigurasi Kueue untuk membuat resource kustom Slice.
  5. Menjalankan workload pada slicing dinamis dengan Kueue.
  6. Pembersihan.

Aktifkan pengontrol slice

Untuk menggunakan pengelompokan dinamis, aktifkan pengontrol pengelompokan 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

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 grup 16 node VM TPU, atau sub-blok. GKE menyediakan node pool ini meskipun tidak dapat menemukan semua 16 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 tertentu dari VM TPU, untuk kontrol yang lebih terperinci.

Membuat kebijakan beban kerja

Untuk membuat node pool slice TPU dengan Ironwood (TPU7x), Anda harus membuat kebijakan beban kerja terlebih dahulu dengan kolom accelerator-topology-mode yang ditetapkan 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 disetel, 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 yang ditentukan. 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 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 gantinya, 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.

Menginstal resource JobSet dan Kueue untuk pengirisan dinamis

  1. Instal JobSet:

    helm install jobset oci://registry.k8s.io/jobset/charts/jobset \
        --version 0.10.1 \
        --namespace jobset-system \
        --create-namespace \
        --set controller.resources.requests.cpu=4 \
        --set controller.resources.requests.memory=16Gi

  2. Instal Kueue:

    helm install kueue oci://registry.k8s.io/kueue/charts/kueue \
        --version 0.16.1 \
        --namespace kueue-system \
        --create-namespace \
        --wait \
        --set controllerManager.replicas=3 \
        --set controllerManager.manager.resources.requests.cpu=16 \
        --set controllerManager.manager.resources.requests.memory=64Gi

  3. Instal pengontrol slice Kueue:

    kubectl apply -f https://gist.githubusercontent.com/mwysokin/cd90010d0d375b3bf57c536905692547/raw/506c36dd070f4ac222ba8a5e58ba28bbfcfa8ed3/kueue-slice-controller-v0.8.0-130.yaml

  4. Untuk mengonfigurasi Kueue untuk pengelompokan dinamis, simpan manifes berikut sebagai dynamic-slice-topology.yaml:

    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

  5. 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.
    • Ironwood (TPU7x) SuperSlice ResourceFlavor (superslice-rf): ResourceFlavor untuk sub-blok Ironwood (TPU7x) mencakup label cloud.google.com/gke-tpu-accelerator: tpu7x agar cocok dengan node yang memiliki 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. nominalQuota untuk google.com/tpu dapat dikonfigurasi dengan dua cara:
      • Kuota spesifik: tetapkan nominalQuota agar sesuai dengan kapasitas yang ada untuk pengelolaan kuota dan pembagian yang adil.
      • Kuota tidak terbatas: tetapkan 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 sub-blok

Selain kondisi dan kesiapan node standar, GKE mengekspos status spesifik setiap sub-blok menggunakan label cloud.google.com/gke-tpu-partition-4x4x4-state. Label ini memungkinkan GKE memperhitungkan faktor-faktor yang memengaruhi pembentukan slice, seperti status link TPU.

Anda dapat menentukan nilai label cloud.google.com/gke-tpu-partition-4x4x4-state sebagai berikut:

  • HEALTHY: infrastruktur dalam kondisi baik.
  • DEGRADED: infrastruktur sub-blok dalam kondisi menurun, misalnya, karena penurunan kualitas link OCS. Sub-blok masih dapat membentuk slice, tetapi performa keseluruhan mungkin lebih rendah dibandingkan dengan sub-blok yang sehat. Jika Anda dapat mentoleransi potensi penurunan performa, Anda dapat mengonfigurasi workload untuk menggunakan sub-blok DEGRADED dengan menggunakan afinitas node, seperti yang ditunjukkan dalam Contoh 3.
  • UNHEALTHY: sub-blok tidak berfungsi dengan baik dan tidak dapat membentuk slice.

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

Perilakunya adalah sebagai berikut:

  • Jika nodeSelector atau nodeAffinity yang menargetkan label cloud.google.com/gke-tpu-partition-4x4x4-state ada, label tersebut tidak akan berubah.

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

    nodeSelector:
  cloud.google.com/gke-tpu-partition-4x4x4-state: "HEALTHY"

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. Contoh ini mencakup tiga 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:

    apiVersion: jobset.x-k8s.io/v1alpha2
kind: JobSet
metadata:
  name: big-super-slice
  labels:
    kueue.x-k8s.io/queue-name: lq
  annotations:
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
                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

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

    • cloud.google.com/gke-tpu-slice-topology: menentukan "4x12x16" sebagai topologi slice dinamis. Persyaratan untuk topologi akselerator tpu7x mencakup aturan berikut:
      • Topologi minimum adalah 4x4x4.
      • Topologi harus berupa string tiga dimensi dalam format AxBxC. Contoh, 4x8x8.
      • Setiap dimensi (A, B, dan C) harus kelipatan empat.
      • 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 Kueue LocalQueue.

  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 beban kerja yang menggunakan dua slice dinamis, yang masing-masing terdiri dari empat sub-blok.

  1. Simpan manifes berikut sebagai two-super-slices.yaml:

    apiVersion: jobset.x-k8s.io/v1alpha2
kind: JobSet
metadata:
name: two-super-slices
labels:
    kueue.x-k8s.io/queue-name: lq
annotations:
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 replicas: 2 di kolom 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.

Contoh 3: Beban kerja dengan slice dinamis tunggal dan NodeAffinity

Mulai dari Kueue 0.15, Kueue mendukung NodeAffinity untuk pemilihan node TAS. Fungsi ini dapat digunakan untuk memungkinkan node HEALTHY dan DEGRADED menjadi bagian dari slice dinamis. Contoh berikut menunjukkan cara mengonfigurasi beban kerja dengan slice dinamis tunggal dan NodeAffinity:

  1. Simpan manifes berikut sebagai slice-8x8x8-na.yaml:

    apiVersion: jobset.x-k8s.io/v1alpha2
kind: JobSet
metadata:
  name: slice-8x8x8-na
  labels:
    kueue.x-k8s.io/queue-name: lq
spec:
  replicatedJobs:
    - name: rj1
      replicas: 1
      template:
        spec:
          parallelism: 128
          completions: 128
          backoffLimit: 10
          template:
            metadata:
              annotations:
                cloud.google.com/gke-tpu-slice-topology: 8x8x8
            spec:
              tolerations:
                - key: "google.com/tpu"
                  operator: "Equal"
                  value: "present"
                  effect: "NoSchedule"
              nodeSelector:
                cloud.google.com/gke-tpu-accelerator: tpu7x
              affinity:
                nodeAffinity:
                  requiredDuringSchedulingIgnoredDuringExecution:
                    nodeSelectorTerms:
                      - matchExpressions:
                          - key: cloud.google.com/gke-tpu-partition-4x4x4-state
                            operator: In
                            values:
                              - "HEALTHY"
                              - "DEGRADED"
              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 slice-8x8x8-na.yaml:

    kubectl apply -f slice-8x8x8-na.yaml

    Setelah Anda menerapkan manifes, Kueue akan membuat JobSet bernama slice-8x8x8-na. Kemudian, Kueue mencoba membentuk satu slice dinamis dengan topologi 8x8x8, yang memungkinkan node HEALTHY dan DEGRADED disertakan karena NodeAffinity yang ditentukan. Setelah slice aktif, Kueue akan menerima workload, dan 128 Pod akan dijadwalkan di node yang membentuk slice dinamis.

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 terdiri dari 54 karakter atau kurang. 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).

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