Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Menggunakan pengirisan dinamis dengan penjadwal kustom

Standard

Dokumen ini menjelaskan cara menggunakan pengelompokan dinamis dengan berinteraksi langsung dengan resource kustom Slice. Anda dapat membuat slice, memantau status partisi, dan memverifikasi status slice.

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

Mengapa menggunakan pengirisan dinamis dengan penjadwal kustom?

Gunakan penjadwal Anda sendiri untuk mengelola resource kustom Slice jika Anda memiliki persyaratan penjadwalan yang kompleks atau jika Anda ingin mengintegrasikan pengirisan dinamis dengan infrastruktur penjadwalan yang ada.

Jika Anda lebih memilih menggunakan penjadwal daripada mengelola resource kustom Slice secara langsung, GKE menyediakan integrasi dengan Kueue dan Penjadwalan yang Mendukung Topologi (TAS). Untuk mengetahui informasi selengkapnya, lihat Menjadwalkan slice dinamis dengan Kueue dan TAS.

Ringkasan alur kerja

Untuk menggunakan pengirisan dinamis dengan penjadwal kustom, Anda akan melakukan tugas berikut dalam dokumen ini:

Aktifkan pengontrol slice.
Buat node pool dengan penyediaan inkremental.
Buat resource kustom Slice berdasarkan persyaratan workload Anda. Terapkan resource kustom Slice ke cluster Anda.
Pantau status partisi dan kondisi slice.
Hapus irisan setelah selesai.

Untuk mengetahui informasi selengkapnya tentang kolom dan status resource kustom Slice, lihat informasi referensi resource kustom Slice.

Persyaratan

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

Gunakan cluster Standard di versi 1.35.2-gke.1842000 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.
Catatan: Untuk penginstalan gcloud CLI yang ada, pastikan untuk menyetel properti compute/region. Jika Anda terutama menggunakan cluster zona, tetapkan compute/zone. Dengan menyetel lokasi default, Anda dapat menghindari error di gcloud CLI yang seperti ini: One of [--zone, --region] must be supplied: Please specify location. Anda mungkin perlu menentukan lokasi dalam perintah tertentu jika lokasi cluster Anda berbeda dengan lokasi default yang Anda tetapkan.

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

Aktifkan pengontrol slice

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

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

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

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

Di output perintah berikut, 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
```

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 grup VM TPU 16 node, 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 diekspos 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 TPU 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 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 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 semua node ditempatkan dalam sub-blok yang ditentukan.

Blokir

Untuk mengambil nama blok dalam reservasi dan jumlah sub-blok yang tersedia di 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.
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.
Buat node pool untuk setiap sub-blok yang diidentifikasi pada langkah sebelumnya. Misalnya, jika jumlahnya adalah 4, jalankan perintah ini empat kali. Gunakan nama unik untuk setiap node pool.
```
gcloud container node-pools create NODE_POOL_NAME \
      --cluster=CLUSTER_NAME \
      --node-locations=ZONE \
      --machine-type=tpu7x-standard-4t \
      --num-nodes=16 \
      --placement-policy=WORKLOAD_POLICY_NAME \
      --reservation-affinity=specific \
      --reservation=${RESERVATION_PATH}
```
Ganti kode berikut:
- NODE_POOL_NAME: nama node pool baru.
- CLUSTER_NAME: nama cluster GKE Anda.
- WORKLOAD_POLICY_NAME: nama kebijakan workload yang Anda buat.
- ZONE: zona untuk node pool, misalnya, us-central1-a.

Sub-blok

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

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.

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 beban kerja dijadwalkan, 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 akan diaktifkan oleh pengontrol slice.
Menjadwalkan workload GKE dengan Kueue dan TAS. Kueue secara otomatis menangani pembuatan dan penghapusan resource kustom Slice. Hindari mengubah resource kustom Slice yang dibuat oleh Kueue secara manual.

Membentuk irisan dinamis

Setelah membuat kumpulan node, Anda dapat membentuk slice dinamis yang lebih besar dengan membuat resource kustom Slice. Alih-alih Pod, Anda menggunakan resource kustom Slice untuk menentukan topologi yang ditentukan, yang kemudian diaktifkan oleh pengontrol slice.

Verifikasi status node dan partisi

Untuk mendapatkan nama node dari node pool, jalankan perintah berikut:

kubectl get nodes -l cloud.google.com/gke-nodepool=${NODE_POOL_NAME}

Output-nya mirip dengan berikut ini:

NAME                                 STATUS   ROLES    AGE    VERSION
gke-np-status-update-7b4c890c-0jhp   Ready    <none>   2d1h   v1.35.1-gke.1396002
gke-np-status-update-7b4c890c-377r   Ready    <none>   2d1h   v1.35.1-gke.1396002
gke-np-status-update-7b4c890c-gb51   Ready    <none>   2d1h   v1.35.1-gke.1396002

Verifikasi model penyediaan node:
```
kubectl describe node NODE_NAME | grep "cloud.google.com/gke-accelerator-topology-mode"
```
Output-nya mirip dengan berikut ini:
```
cloud.google.com/gke-accelerator-topology-mode: PROVISION_ONLY
```
Nilai ini cocok dengan setelan accelerator-topology-mode=provision_only yang ditentukan saat Anda membuat kebijakan beban kerja.
Ambil informasi label node:
```
kubectl describe node NODE_NAME | grep "cloud.google.com/gke-tpu-partition-4x4x4-id"
```
Ganti NODE_NAME dengan nama salah satu node di node pool.

Output-nya mirip dengan berikut ini:
```
cloud.google.com/gke-tpu-partition-4x4x4-id=fba785f80d18552357dcdef6d3d16c27
```
Anotasi cloud.google.com/gke-tpu-partition-4x4x4-state menunjukkan apakah node tersedia untuk membentuk slice dinamis. Label ini mendukung nilai berikut:
- HEALTHY: node dalam kondisi baik dan berfungsi penuh.
- DEGRADED: node terganggu, tetapi masih dapat digunakan untuk pembentukan slice dinamis.
- UNHEALTHY: node tidak berfungsi dan tidak dapat digunakan untuk membentuk slice.
- UNSET: status tidak ditentukan karena jumlah node di node pool tidak mencukupi.
- INCOMPLETE: tidak semua node dalam partisi disediakan.
Verifikasi bahwa node menyertakan anotasi node.gke.io/created-by-mig:
```
kubectl describe node NODE_NAME | grep "node.gke.io/created-by-mig"
```
Ganti NODE_NAME dengan nama salah satu node di node pool.

Output-nya mirip dengan berikut ini:
```
node.gke.io/created-by-mig: projects/735972712744/zones/us-central1-ai1a/team/string
```
Output mencakup label node.gke.io/created-by-mig, yang memungkinkan bidang kontrol GKE menautkan node Kubernetes ke resource Compute Engine yang mendasarinya.

Membuat resource kustom Slice

Tentukan resource kustom Slice:
```
apiVersion: accelerator.gke.io/v1beta1
kind: Slice
metadata:
  # Name of the slice resource
  name: SLICE_NAME
spec:
  # Specify the type of accelerator for this slice
  type: "tpu7x"
  # Define the desired topology for the accelerator slice
  topology: TOPOLOGY
  partitionIds:
    - PARTITION_ID # Example: a9476d1b02bd4f4e75ffffae3bd23c01
    - PARTITION_ID_2
    # ... add more partition IDs as needed
```
Ganti kode berikut:
- SLICE_NAME: nama untuk irisan Anda. Nama harus memenuhi kondisi metadata.name.
- TOPOLOGY: topologi untuk slice dinamis. Topologi harus memenuhi kondisi berikut:
  - Setiap dimensi topologi yang diminta harus kelipatan empat, misalnya 4A x 4B x 4C.
  - Tiga nilai dalam dimensi topologi, AxBxC, harus dalam urutan tidak menurun (A ≤ B ≤ C). Misalnya, 4x4x8 valid, tetapi 4x8x4 tidak. Urutan ini membantu memastikan pembentukan irisan yang konsisten dan menghindari perilaku yang tidak terduga.
  - Hasil perkalian ketiga nilai dalam dimensi topologi, A × B × C,tidak boleh melebihi 9.216.
- PARTITION_ID: daftar string yang mengidentifikasi partisi 4x4x4 yang membentuk slice. Hitung jumlah partisi berdasarkan jumlah total chip, dengan setiap partisi terdiri dari 64 chip. Jumlah item dalam daftar spec.partitionIds harus sama persis dengan jumlah partisi yang dihitung ((A × B × C) / 64). partitionIds harus memenuhi kondisi berikut:
  - Setiap partisi harus dipetakan ke sub-blok reservasi.
  - Semua sub-blok terkait harus termasuk dalam reservasi yang sama.
  - Semua blok terkait harus berada dalam reservasi yang sama.
  - Kumpulan node terkait harus memiliki semua node dalam status ready.
- Nilai kolom type harus tpu7x.
- Jika ingin mengaktifkan pengontrol slice untuk mencoba lagi secara otomatis selama pembentukan slice, Anda dapat menambahkan anotasi slice.gke.io/retry-on-failure: "true" ke resource kustom slice. Jika slice tidak dibuat karena alasan status SliceCreationFailed, pengontrol akan mencoba lagi hingga slice berhasil dibentuk.
Misalnya, untuk membuat irisan 4x8x8, Anda harus memberikan empat ID partisi unik.
```
apiVersion: accelerator.gke.io/v1beta1
kind: Slice
metadata:
    name: test-slice-example
    annotations:
      slice.gke.io/retry-on-failure: "true" # Optional annotation to retry slice formation
spec:
    type: "tpu7x"
    topology: "4x8x8" # (4*8*8)/64 = 4 partitions
    partitionIds:
        - "p0"
        - "p1"
        - "p2"
        - "p3"
```
Terapkan resource kustom Slice:
```
kubectl apply -f test-slice-example.yaml
```
Pada tahap ini, GKE mencoba membuat slice. Jika salah satu masalah berikut terjadi, pembuatan slice akan gagal, dan alasan status di resource kustom Slice akan diperbarui menjadi SliceCreationFailed atau FAILED:
- Jika node yang dipilih di resource kustom tidak ada, alasan statusnya adalah SliceCreationFailed.
- Jika ada node pada resource kustom yang digunakan oleh slice lain, alasan statusnya adalah SliceCreationFailed.
- Jika node pada resource kustom bukan bagian dari blok pemesanan yang sama, alasan statusnya adalah FAILED.
- Jika node tidak berada dalam reservasi yang sama, alasan statusnya adalah FAILED.
- Jika topologi tidak cocok dengan jumlah partisi, alasan statusnya adalah SliceCreationFailed.
Untuk mempelajari lebih lanjut status resource kustom Slice, lihat Status slice.

Memantau status resource kustom Slice

Untuk memeriksa status resource kustom Slice, jalankan perintah berikut:

kubectl describe slice SLICE_NAME

Ganti SLICE_NAME dengan nama slice.

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-01-11T23:45:15Z
  Finalizers:
    accelerator.gke.io/slice-finalizer
  Generation:        1
  Resource Version:  1768175347356335006
  UID:               d0b71e5c-be3f-4788-aead-930c7afec4f2
Spec:
  Partition Ids:
    2c79463990ff67c4e3c2648666bfedfa
    ba898ffcac0ad0946e8ff036d771ee53
    [more partition IDs]
  Topology:  8x16x16
  Type:      tpu7x
Status:
  Conditions:
    Last Transition Time:  2026-01-11T23:45:38Z
    Message:               ""
    
    Reason:                FAILED
    
    Status:                False
    Type:                  Ready
Events:

Kolom reason dalam status resource kustom Slice menunjukkan status slice saat ini. Siklus proses resource kustom Slice mengikuti progres ini:

SliceNotCreated: pengontrol melakukan inisialisasi dan pemeriksaan resource.
- Jika prasyarat tidak terpenuhi, status akan bertransisi ke SliceCreationFailed.
- Jika validasi lulus, status akan bertransisi ke ACTIVATING.
ACTIVATING: GKE sedang membentuk slice.
- Jika berhasil, status akan bertransisi ke ACTIVE.
- Jika sub-blok mengalami penurunan kualitas, tetapi slice dapat digunakan, status akan bertransisi ke ACTIVE_DEGRADED.
- Jika pembentukan gagal, status akan bertransisi ke FAILED.
DEACTIVATING: jika resource kustom Slice dihapus atau terjadi kegagalan kritis dalam status aktif atau gagal, slice akan mulai dibongkar.
INCOMPLETE: langkah terakhir sebelum resource dihapus sepenuhnya.

Untuk mempelajari lebih lanjut status resource kustom Slice, lihat Status slice.

Menjalankan workload pada pengirisan dinamis

Saat resource kustom Slice dalam status ACTIVE, Anda dapat menjalankan workload di dalamnya. Bagian berikut menyertakan contoh workload yang menggunakan pengelompokan dinamis. Workload dikirimkan sebagai Tugas atau JobSet.

Contoh 1: satu workload menggunakan satu slice

Contoh berikut menunjukkan beban kerja yang menggunakan slice sub-blok tunggal.

Simpan manifes contoh berikut sebagai tpu-job-jax-v7x-64.yaml:

apiVersion: v1
kind: Service
metadata:
name: headless-svc
spec:
clusterIP: None
selector:
    job-name: tpu-job-jax-v7x-64
---
apiVersion: batch/v1
kind: Job
metadata:
name: tpu-job-jax-v7x-64
spec:
backoffLimit: 0
completions: 16
parallelism: 16
completionMode: Indexed
template:
    metadata:
    annotations:
        cloud.google.com/gke-tpu-slice-topology: 4x4x4
    spec:
    nodeSelector:
        cloud.google.com/gke-tpu-topology: 4x4x4
        cloud.google.com/gke-tpu-accelerator: tpu7x
        cloud.google.com/gke-tpu-slice: test-slice
    subdomain: headless-svc
    restartPolicy: Never
    containers:
    - name: tpu-job-jax
        env:
        - name: TPU_ACCELERATOR_TYPE
          value: tpu7x-128
        image: python:3.12
        securityContext:
        privileged: false
        command:
        - bash
        - -c
        - |
        set -ex
        pip install -U --pre jax jaxlib libtpu requests -i https://us-python.pkg.dev/ml-oss-artifacts-published/jax/simple/ -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
        pip list
        python -c 'import jax; print("Total TPU devices (cores):", jax.device_count())'
        resources:
        requests:
            google.com/tpu: 4
        limits:
            google.com/tpu: 4

Dalam manifes ini:

cloud.google.com/gke-tpu-slice-topology dan cloud.google.com/gke-tpu-topology menentukan topologi slice dinamis.
env.value: tpu7x-128 adalah jenis akselerator TPU dan jumlah total inti dalam slice. Jumlah core dihitung dengan mengalikan dimensi topologi dengan jumlah core per chip. Misalnya, untuk topologi 4x4x4, perhitungannya adalah 4 × 4 × 4 × 2 = 128, dengan 2 adalah jumlah core per chip untuk tpu7x (Ironwood (TPU7x)). Oleh karena itu, TPU_ACCELERATOR_TYPE adalah tpu7x-128.

Terapkan manifes tpu-job-jax-v7x-64.yaml:

kubectl apply -f tpu-job-jax-v7x-64.yaml

Contoh 2: men-deploy workload pada kumpulan node multislice menggunakan JobSet

Contoh ini menunjukkan cara men-deploy workload di kumpulan node multiris menggunakan JobSet.

Instal JobSet:

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

Simpan manifes contoh berikut sebagai tpu-multislice-jax.yaml:

apiVersion: jobset.x-k8s.io/v1alpha2
kind: JobSet
metadata:
  name: tpu-multislice-jax
  annotations:
    alpha.jobset.sigs.k8s.io/exclusive-topology: cloud.google.com/gke-tpu-slice
spec:
  failurePolicy:
    maxRestarts: 3
  replicatedJobs:
  - name: slice-job
    replicas: 2
    template:
      spec:
        parallelism: 16
        completions: 16
        backoffLimit: 0
        completionMode: Indexed
        template:
          metadata:
            annotations:
              # The shape of the slice
              cloud.google.com/gke-tpu-slice-topology: 4x4x4
          spec:
            hostNetwork: true
            dnsPolicy: ClusterFirstWithHostNet
            nodeSelector:
              cloud.google.com/gke-tpu-topology: 4x4x4
              cloud.google.com/gke-tpu-accelerator: tpu7x
              # IMPORTANT: Do NOT put 'cloud.google.com/gke-tpu-slice' here manually.
              # The exclusive-topology annotation handles the slice assignment automatically.
            containers:
            - name: jax-worker
              image: python:3.12
              securityContext:
                privileged: true
              ports:
              - containerPort: 8471
              command:
              - bash
              - -c
              - |
                set -ex
                pip install -U --pre jax jaxlib libtpu requests -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
                # Verify JobSet injected the specific slice ID for this worker
                echo "JobSet Index: $JOB_COMPLETION_INDEX"
                python -c 'import jax; print("Total TPU devices:", jax.device_count())'
              resources:
                requests:
                  google.com/tpu: 4
                limits:
                  google.com/tpu: 4

Terapkan manifes tpu-multislice-jax.yaml:
```
kubectl apply -f tpu-multislice-jax.yaml
```
Dalam manifes ini:
- Kolom replicas: 2 di bagian replicatedJobs menunjukkan bahwa JobSet membuat dua Tugas terpisah, yang masing-masing sesuai dengan slice TPU 4x4x4.
- Anotasi alpha.jobset.sigs.k8s.io/exclusive-topology: cloud.google.com/gke-tpu-slice membantu memastikan bahwa setiap Tugas ditetapkan ke slice TPU yang unik.
- Anotasi cloud.google.com/gke-tpu-slice-topology: 4x4x4 menentukan topologi setiap slice dinamis.
- Variabel lingkungan TPU_ACCELERATOR_TYPE tidak ditetapkan secara eksplisit dalam contoh ini, karena JobSet menangani penetapan slice. Kode JAX secara otomatis mendeteksi perangkat TPU yang tersedia dalam slice yang ditetapkan.
Penting: Jangan edit label cloud.google.com/gke-tpu-slice secara manual.

Menghapus irisan

Hapus slice:

kubectl patch slice $SLICE_NAME --type json \
  -p='[{"op": "remove", "path": "/metadata/finalizers"}]'

Pastikan irisan dihapus:
```
kubectl get slices
```

Menonaktifkan Pengontrol Slice

Untuk menonaktifkan pengontrol slice, hapus dari cluster.

Periksa apakah resource kustom Slice kosong:
```
kubectl get slice -A
```

Perbarui cluster untuk menonaktifkan pengontrol slice:

gcloud container clusters update ${CLUSTER_NAME} \
    --location=${REGION} \
    --no-enable-slice-controller

Hapus resource kustom Slice :

kubectl delete crd slices.accelerator.gke.io

Pastikan resource kustom Slice dihapus:

kubectl get crd | grep slices.accelerator.gke.io

Menghapus label yang ditambahkan oleh pengontrol irisan. Perlu menghapus label ini:

cloud.google.com/gke-tpu-slice
cloud.google.com/gke-tpu-topology

Untuk menghapus dari node tertentu, perbarui nama node

export NODE_NAME="gke-tpu-bdac9600-3bdg"
kubectl label node $NODE_NAME cloud.google.com/gke-tpu-slice- cloud.google.com/gke-tpu-slice-topology-

Jika Anda ingin menghapus label ini dari setiap node di cluster Anda:

kubectl label nodes --all cloud.google.com/gke-tpu-slice- cloud.google.com/gke-tpu-slice-topology-

Periksa label node dan pastikan label tersebut kosong:

export NODE_NAME="gke-tpu-bdac9600-3bdg"
kubectl describe node $NODE_NAME | grep "cloud.google.com/gke-tpu-slice"

Langkah berikutnya

Pelajari lebih lanjut konsep pengelompokan dinamis.
Pelajari resource kustom Slice.

Menggunakan pengirisan dinamis dengan penjadwal kustom Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Mengapa menggunakan pengirisan dinamis dengan penjadwal kustom?

Ringkasan alur kerja

Persyaratan

Sebelum memulai

Aktifkan pengontrol slice

Membuat node pool dengan penyediaan inkremental

Membuat kebijakan beban kerja

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

Blokir

Sub-blok

Membentuk irisan dinamis

Verifikasi status node dan partisi

Membuat resource kustom Slice

Memantau status resource kustom Slice

Menjalankan workload pada pengirisan dinamis

Contoh 1: satu workload menggunakan satu slice

Contoh 2: men-deploy workload pada kumpulan node multislice menggunakan JobSet

Menghapus irisan

Menonaktifkan Pengontrol Slice

Langkah berikutnya

Menggunakan pengirisan dinamis dengan penjadwal kustom