Men-deploy workload TPU di Autopilot GKE

Halaman ini menjelaskan cara mempercepat beban kerja machine learning (ML) dengan menggunakan akselerator Cloud TPU (TPU) di cluster Autopilot Google Kubernetes Engine (GKE). Panduan ini dapat membantu Anda memilih pustaka yang tepat untuk framework aplikasi ML, menyiapkan workload TPU agar berjalan secara optimal di GKE, dan memantau workload setelah deployment.

Halaman ini ditujukan bagi admin dan operator Platform, spesialis Data dan AI, serta developer Aplikasi yang ingin menyiapkan dan menjalankan beban kerja ML di TPU. Untuk mempelajari lebih lanjut peran, tanggung jawab, dan contoh tugas umum yang kami referensikan dalam konten Google Cloud , lihat Peran dan tugas pengguna GKE umum.

Sebelum membaca halaman ini, pastikan Anda memahami referensi berikut:

Cara kerja TPU di Autopilot

Untuk menggunakan TPU di workload Autopilot, Anda menentukan hal berikut dalam manifes workload:

  • Versi TPU di kolom spec.nodeSelector.
  • Topologi TPU di kolom spec.nodeSelector. Topologi harus didukung oleh versi TPU yang ditentukan.
  • Jumlah chip TPU di kolom spec.containers.resources.requests dan spec.containers.resources.limits.

Saat Anda men-deploy workload, GKE akan menyediakan node yang memiliki konfigurasi TPU yang diminta dan menjadwalkan Pod Anda di node tersebut. GKE menempatkan setiap beban kerja di nodenya sendiri sehingga setiap Pod dapat mengakses seluruh resource node dengan risiko gangguan yang minimal.

TPU di Autopilot kompatibel dengan kemampuan berikut:

  1. Spot Pods
  2. Reservasi kapasitas tertentu
  3. Pod dengan waktu proses yang diperpanjang
  4. Flex-start

Merencanakan konfigurasi TPU

Sebelum menggunakan panduan ini untuk men-deploy workload TPU, rencanakan konfigurasi TPU Anda berdasarkan model dan jumlah memori yang diperlukan. Untuk mengetahui detailnya, lihat Merencanakan konfigurasi TPU.

Harga

Untuk mengetahui informasi harga, lihat harga Autopilot.

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.
  • Pastikan Anda memiliki cluster Autopilot yang menjalankan GKE versi 1.32.3-gke.1927000 atau yang lebih baru. Untuk mengetahui petunjuknya, lihat Membuat cluster Autopilot.
  • Untuk menggunakan TPU yang dipesan, pastikan Anda memiliki reservasi kapasitas khusus yang sudah ada. Untuk mendapatkan petunjuk, lihat Menggunakan pemesanan.

Memastikan kuota untuk TPU dan resource GKE lainnya

Bagian berikut membantu Anda memastikan bahwa Anda memiliki kuota yang cukup saat menggunakan TPU di GKE.

Untuk membuat node slice TPU, Anda harus memiliki kuota TPU yang tersedia, kecuali jika Anda menggunakan pemesanan kapasitas yang ada. Jika Anda menggunakan TPU yang dicadangkan, lewati bagian ini.

Membuat node slice TPU di GKE memerlukan kuota Compute Engine API (compute.googleapis.com), bukan kuota Cloud TPU API (tpu.googleapis.com). Nama kuota berbeda di Pod Autopilot reguler dan di Pod Spot.

Untuk memeriksa batas dan penggunaan saat ini kuota Compute Engine API Anda untuk TPU, ikuti langkah-langkah berikut:

  1. Buka halaman Quotas di konsol Google Cloud :

    Buka Quotas

  2. Di kotak Filter , lakukan tindakan berikut:

    1. Gunakan tabel berikut untuk memilih dan menyalin properti kuota berdasarkan versi TPU dan nilai di pemilih node cloud.google.com/gke-tpu-accelerator. Misalnya, jika Anda berencana membuat node TPU v5e sesuai permintaan yang nilainya di pemilih node cloud.google.com/gke-tpu-accelerator adalah tpu-v5-lite-podslice, masukkan Name: TPU v5 Lite PodSlice chips.

      Versi TPU, cloud.google.com/gke-tpu-accelerator Properti dan nama kuota untuk instance on-demand Properti dan nama kuota untuk instance Spot2
      TPU v3,
      tpu-v3-device 
      Dimensions (e.g. location):
      tpu_family:CT3
      		 Tidak berlaku
      TPU v3,
      tpu-v3-slice 
      Dimensions (e.g. location):
      tpu_family:CT3P
      		 Tidak berlaku
      TPU v4,
      tpu-v4-podslice 
      Name:
      TPU v4 PodSlice chips
      		 
      Name:
      Preemptible TPU v4 PodSlice chips
      TPU v5e,
      tpu-v5-lite-podslice 
      Name:
      TPU v5 Lite PodSlice chips
      		 
      Name:
      Preemptible TPU v5 Lite Podslice
      chips
      TPU v5p,
      tpu-v5p-slice 
      Name:
      TPU v5p chips
      		 
      Name:
      Preemptible TPU v5p chips
      TPU Trillium,
      tpu-v6e-slice 
      Dimensions (e.g. location):
      tpu_family:CT6E
      		 
      Name:
      Preemptible TPU slices v6e
      Ironwood (TPU7x) (Pratinjau),
      tpu7x 
      Dimensions (e.g. location):
      tpu_family:tpu7x
      		 
      Name:
      Preemptible TPU slices tpu7x

    2. Pilih properti Dimensi (misalnya, lokasi) dan masukkan region: diikuti dengan nama region tempat Anda berencana membuat TPU di GKE. Misalnya, masukkan region:us-west4 jika Anda berencana membuat node slice TPU di zona us-west4-a. Kuota TPU bersifat regional, sehingga semua zona dalam region yang sama menggunakan kuota TPU yang sama.

Jika tidak ada kuota yang cocok dengan filter yang Anda masukkan, berarti project belum diberi kuota yang ditentukan untuk region yang Anda butuhkan, dan Anda harus meminta penyesuaian kuota TPU.

Saat reservasi TPU dibuat, nilai batas dan penggunaan saat ini untuk kuota yang sesuai akan bertambah sesuai jumlah chip dalam reservasi TPU. Misalnya, saat reservasi dibuat untuk 16 chip TPU v5e yang nilainya di pemilih node cloud.google.com/gke-tpu-accelerator adalah tpu-v5-lite-podslice, maka Batas dan Penggunaan saat ini untuk kuota TPU v5 Lite PodSlice chips di region yang relevan akan bertambah 16.

Kuota untuk resource GKE tambahan

Anda mungkin perlu meningkatkan kuota terkait GKE berikut di region tempat GKE membuat resource Anda.

  • Kuota Persistent Disk SSD (GB): Boot disk setiap node Kubernetes memerlukan 100 GB secara default. Oleh karena itu, kuota ini harus ditetapkan setidaknya setinggi produk dari jumlah maksimum node GKE yang akan Anda buat dan 100 GB (node * 100 GB).
  • Kuota alamat IP yang sedang digunakan: Setiap node Kubernetes menggunakan satu alamat IP. Oleh karena itu, kuota ini harus ditetapkan setidaknya setinggi jumlah maksimum node GKE yang akan Anda buat.
  • Pastikan max-pods-per-node selaras dengan rentang subnet: Setiap node Kubernetes menggunakan rentang IP sekunder untuk Pod. Misalnya, max-pods-per-node 32 memerlukan 64 alamat IP yang diterjemahkan ke subnet /26 per node. Perhatikan bahwa rentang ini tidak boleh dibagikan dengan cluster lain. Untuk menghindari kehabisan rentang alamat IP, gunakan flag --max-pods-per-node untuk membatasi jumlah pod yang diizinkan untuk dijadwalkan di node. Kuota untuk max-pods-per-node harus ditetapkan setidaknya setinggi jumlah maksimum node GKE yang Anda perkirakan akan dibuat.

Untuk meminta penambahan kuota, lihat Meminta penyesuaian kuota.

Menyiapkan aplikasi TPU

Workload TPU memiliki persyaratan persiapan berikut.

  1. Framework seperti JAX, PyTorch, dan TensorFlow mengakses VM TPU menggunakan library bersama libtpu. libtpu mencakup compiler XLA, software runtime TPU, dan driver TPU. Setiap rilis PyTorch dan JAX memerlukan versi libtpu.so tertentu. Untuk menghindari konflik versi paket, sebaiknya gunakan image AI JAX. Untuk menggunakan TPU di GKE, pastikan Anda menggunakan versi berikut: tpu7x
    Jenis TPU libtpu.so versi
    Ironwood (TPU7x) (Pratinjau)
    TPU Trillium (v6e)
    tpu-v6e-slice
    TPU v5e
    tpu-v5-lite-podslice
    TPU v5p
    tpu-v5p-slice
    TPU v4
    tpu-v4-podslice
    TPU v3
    tpu-v3-slice
    tpu-v3-device
  2. Dalam manifes workload, tambahkan pemilih node Kubernetes untuk memastikan GKE menjadwalkan workload TPU Anda pada jenis mesin TPU dan topologi TPU yang Anda tentukan:

      nodeSelector:
    cloud.google.com/gke-tpu-accelerator: TPU_ACCELERATOR
    cloud.google.com/gke-tpu-topology: TPU_TOPOLOGY
    cloud.google.com/placement-policy-name: WORKLOAD_POLICY # Required only for Ironwood (TPU7x)

    Ganti kode berikut:

    • TPU_ACCELERATOR: nama akselerator TPU. Misalnya, gunakan tpu7x-standard-4t.
    • TPU_TOPOLOGY: topologi fisik untuk slice TPU. Format topologi bergantung pada versi TPU. Misalnya, gunakan 2x2x2. Untuk mempelajari lebih lanjut, lihat Merencanakan TPU di GKE.
    • WORKLOAD_POLICY: nama kebijakan beban kerja yang ingin Anda gunakan untuk menempatkan Pod TPU. Pemilih node ini hanya diperlukan untuk Ironwood (TPU7x).

Setelah menyelesaikan persiapan workload, Anda dapat menjalankan Tugas yang menggunakan TPU.

Opsi untuk menyediakan TPU di GKE

Untuk menyediakan TPU di GKE, Anda memiliki opsi konfigurasi berikut:
  • Permintaan workload: Anda menentukan versi dan topologi TPU di kolom spec.nodeSelector serta jumlah chip TPU di bagian spec.containers.resources. Saat Anda men-deploy workload, GKE secara otomatis menyediakan node dengan konfigurasi TPU yang benar dan menempatkan setiap workload di node khusus miliknya sendiri untuk memastikan akses penuh ke resource node. Untuk mengetahui petunjuknya, lihat Meminta TPU dalam workload.

    • Menyediakan TPU secara terpusat dengan class komputasi kustom

    Bagian berikut menunjukkan cara membuat ComputeClass kustom, lalu membuat Job yang menggunakan TPU yang ditentukan dalam ComputeClass.

    Membuat ComputeClass kustom

    Langkah-langkah untuk membuat ComputeClass kustom yang mengikuti aturan TPU berbeda-beda, bergantung pada apakah Anda menggunakan Ironwood (TPU7x) atau versi TPU yang lebih lama.

    Ironwood (TPU7x)

    1. Buat kebijakan beban kerja. Langkah ini hanya diperlukan jika Anda membuat node pool multi-host, yang bergantung pada topologi yang Anda pilih. Jika Anda menggunakan node pool host tunggal, lewati langkah ini.

      gcloud compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \
    --type=HIGH_THROUGHPUT \
    --accelerator-topology=TPU_TOPOLOGY \
    --project=PROJECT_ID \
    --region=REGION

      Ganti kode berikut:

      • WORKLOAD_POLICY_NAME: nama untuk kebijakan workload Anda.
      • TPU_TOPOLOGY: topologi TPU Ironwood (TPU7x). Misalnya, gunakan 2x2x2. Untuk mengetahui informasi selengkapnya tentang semua topologi Ironwood (TPU7x) yang didukung, lihat bagian topologi.
      • PROJECT_ID: Project ID Google Cloud Anda.
      • REGION: Region untuk kebijakan workload. Kebijakan workload adalah resource regional dan Anda dapat menggunakannya di seluruh node pool.

    2. Simpan manifes berikut sebagai tpu-compute-class.yaml:

      apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: tpu-class
spec:
  priorities:
    - tpu:
        type: tpu7x
        topology: TPU_TOPOLOGY
        count: 4
      placement:
        policyName: WORKLOAD_POLICY_NAME
  nodePoolAutoCreation:
    enabled: true

    3. (Opsional) Anda dapat menggunakan reservasi atau sub-blok tertentu. Misalnya, Anda dapat menambahkan specs berikut ke manifes ComputeClass:

        reservations:
    affinity: Specific
    specific:
      - name: RESERVATION_NAME
        reservationBlock:
          name: RESERVATION_BLOCK_NAME
          reservationSubBlock:
            name: RESERVATION_SUB_BLOCK_NAME

      Ganti kode berikut:

      • RESERVATION_NAME: nama reservasi kapasitas Compute Engine.
      • RESERVATION_BLOCK_NAME: nama blok reservasi kapasitas Compute Engine.
      • RESERVATION_SUB_BLOCK_NAME: nama sub-blok reservasi kapasitas Compute Engine.

      Untuk mengetahui informasi selengkapnya, lihat Menggunakan resource zona yang dicadangkan.

    Versi TPU lainnya

    Untuk menyediakan TPU v3, v4, v5p, v5e, atau v6e (Trillium) menggunakan ComputeClass kustom yang dikonfigurasi untuk TPU, selesaikan langkah-langkah berikut:

    1. Simpan manifes berikut sebagai tpu-compute-class.yaml:

      apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: tpu-class
spec:
  priorities:
  - tpu:
      type: TPU_TYPE
      count: NUMBER_OF_CHIPS
      topology: TOPOLOGY
  - spot: true
    tpu:
      type: {"<var>"}}TPU_TYPE
      count: NUMBER_OF_CHIPS
      topology: TOPOLOGY
  - flexStart:
      enabled: true
    tpu:
      type: {"<var>"}}TPU_TYPE
      count: NUMBER_OF_CHIPS
      topology: TOPOLOGY
  nodePoolAutoCreation:
    enabled: true

      Ganti kode berikut:

      • TPU_TYPE: jenis TPU yang akan digunakan, seperti tpu-v4-podslice. Harus berupa nilai yang didukung oleh GKE.
      • TOPOLOGY: pengaturan chip TPU dalam slice, seperti 2x2x4. Harus berupa topologi yang didukung untuk jenis TPU yang dipilih.
      • NUMBER_OF_CHIPS: jumlah chip TPU yang akan digunakan oleh container. Harus memiliki nilai yang sama untuk limits dan requests.

    2. Deploy ComputeClass:

      kubectl apply -f tpu-compute-class.yaml

      Untuk mengetahui informasi selengkapnya tentang ComputeClass kustom dan TPU, lihat Konfigurasi TPU.

    Membuat Tugas yang menggunakan TPU

    1. Simpan manifes berikut sebagai tpu-job.yaml:

      apiVersion: v1
kind: Service
metadata:
  name: headless-svc
spec:
  clusterIP: None
  selector:
    job-name: tpu-job
---
apiVersion: batch/v1
kind: Job
metadata:
  name: tpu-job
spec:
  backoffLimit: 0
  completions: 4
  parallelism: 4
  completionMode: Indexed
  template:
    spec:
      subdomain: headless-svc
      restartPolicy: Never
      nodeSelector:
        cloud.google.com/compute-class: tpu-class
      containers:
      - name: tpu-job
        image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
        ports:
        - containerPort: 8471 # Default port using which TPU VMs communicate
        - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
        command:
        - bash
        - -c
        - |
          python -c 'import jax; print("TPU cores:", jax.device_count())'
        resources:
          requests:
            cpu: 10
            memory: MEMORY_SIZE
            google.com/tpu: NUMBER_OF_CHIPS
          limits:
            cpu: 10
            memory: MEMORY_SIZE
            google.com/tpu: NUMBER_OF_CHIPS

      Ganti kode berikut:

      • NUMBER_OF_CHIPS: jumlah chip TPU yang akan digunakan oleh container. Harus memiliki nilai yang sama untuk limits dan requests, sama dengan nilai CHIP_COUNT di ComputeClass kustom yang dipilih.
      • MEMORY_SIZE: Jumlah maksimum memori yang digunakan TPU. Batas memori bergantung pada versi dan topologi TPU yang Anda gunakan. Untuk mempelajari lebih lanjut, lihat Nilai minimum dan maksimum untuk akselerator.
      • NUMBER_OF_CHIPS: jumlah chip TPU yang akan digunakan oleh container. Harus memiliki nilai yang sama untuk limits dan requests.

    2. Deploy Job:

      kubectl create -f tpu-job.yaml

      Saat Anda membuat Tugas ini, GKE akan otomatis melakukan hal berikut:

      • Menyediakan node untuk menjalankan Pod. Bergantung pada jenis TPU, topologi, dan permintaan resource yang Anda tentukan, node ini berupa slice host tunggal atau slice multi-host. Bergantung pada ketersediaan resource TPU dalam prioritas teratas, GKE mungkin beralih ke prioritas yang lebih rendah untuk memaksimalkan ketersediaan.
      • Menambahkan taint ke Pod dan toleransi ke node untuk mencegah workload lain Anda berjalan di node yang sama dengan workload TPU.

      Untuk mempelajari lebih lanjut, lihat artikel Tentang ComputeClass kustom.

    3. Setelah menyelesaikan bagian ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat:

      kubectl delete -f tpu-job.yaml

    Meminta TPU dalam workload

    Bagian ini menunjukkan cara membuat Job yang meminta TPU di Autopilot. Di workload apa pun yang memerlukan TPU, Anda harus menentukan hal berikut:

    • Pemilih node untuk versi dan topologi TPU
    • Jumlah TPU chip untuk container dalam workload Anda

    Untuk mengetahui daftar versi dan topologi TPU yang didukung, serta jumlah chip dan node TPU yang sesuai dalam slice, lihat Memilih versi TPU.

    Pertimbangan untuk permintaan TPU dalam workload

    Hanya satu container dalam Pod yang dapat menggunakan TPU. Jumlah chip TPU yang diminta oleh container harus sama dengan jumlah chip TPU yang terpasang ke node dalam slice. Misalnya, jika Anda meminta TPU v5e (tpu-v5-lite-podslice) dengan topologi 2x4, Anda dapat meminta salah satu dari berikut ini:

    • chip 4, yang membuat dua node multi-host dengan masing-masing 4 chip TPU
    • chip 8, yang membuat satu node host tunggal dengan 8 chip TPU

    Sebagai praktik terbaik untuk memaksimalkan efisiensi biaya, selalu gunakan semua TPU dalam slice yang Anda minta. Jika Anda meminta slice multi-host dua node dengan masing-masing 4 TPU chip, Anda harus men-deploy workload yang berjalan di kedua node dan menggunakan semua 8 TPU chip dalam slice.

    Buat workload yang meminta TPU

    Langkah-langkah berikut membuat Tugas yang meminta TPU. Jika memiliki workload yang berjalan di slice TPU multi-host, Anda juga harus membuat Service tanpa header yang memilih workload Anda berdasarkan nama. Service headless ini memungkinkan Pod di slice multi-host pada node yang berbeda untuk berkomunikasi satu sama lain dengan memperbarui konfigurasi DNS Kubernetes agar mengarah ke Pod dalam beban kerja.

    1. Simpan manifes berikut sebagai tpu-autopilot.yaml:

      apiVersion: v1
kind: Service
metadata:
  name: headless-svc
spec:
  clusterIP: None
  selector:
    job-name: tpu-job
---
apiVersion: batch/v1
kind: Job
metadata:
  name: tpu-job
spec:
  backoffLimit: 0
  completions: 4
  parallelism: 4
  completionMode: Indexed
  template:
    spec:
      # Optional: Run in GKE Sandbox
      # runtimeClassName: gvisor
      subdomain: headless-svc
      restartPolicy: Never
      nodeSelector:
        cloud.google.com/gke-tpu-accelerator: TPU_TYPE
        cloud.google.com/gke-tpu-topology: TOPOLOGY
      containers:
      - name: tpu-job
        image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
        ports:
        - containerPort: 8471 # Default port using which TPU VMs communicate
        - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
        command:
        - bash
        - -c
        - |
          python -c 'import jax; print("TPU cores:", jax.device_count())'
        resources:
          requests:
            cpu: 10
            memory: MEMORY_SIZE
            google.com/tpu: NUMBER_OF_CHIPS
          limits:
            cpu: 10
            memory: MEMORY_SIZE
            google.com/tpu: NUMBER_OF_CHIPS

      Ganti kode berikut:

      • TPU_TYPE: jenis TPU yang akan digunakan, seperti tpu-v4-podslice. Harus berupa nilai yang didukung oleh GKE.
      • TOPOLOGY: pengaturan chip TPU dalam slice, seperti 2x2x4. Harus berupa topologi yang didukung untuk jenis TPU yang dipilih.
      • NUMBER_OF_CHIPS: jumlah chip TPU yang akan digunakan oleh container. Harus memiliki nilai yang sama untuk limits dan requests.
      • MEMORY_SIZE: Jumlah maksimum memori yang digunakan TPU. Batas memori bergantung pada versi dan topologi TPU yang Anda gunakan. Untuk mempelajari lebih lanjut, lihat Nilai minimum dan maksimum untuk akselerator.

      Secara opsional, Anda juga dapat mengubah kolom berikut:

      • image: gambar AI JAX yang akan digunakan. Dalam manifes contoh, kolom ini disetel ke image AI JAX terbaru. Untuk menyetel versi yang berbeda, lihat daftar image AI JAX saat ini.
      • runtimeClassname: gvisor: setelan yang memungkinkan Anda menjalankan Pod ini di GKE Sandbox. Untuk menggunakannya, hapus komentar pada baris ini. GKE Sandbox mendukung TPU versi v4 dan yang lebih baru. Untuk mempelajari lebih lanjut, lihat GKE Sandbox.

    2. Deploy Job:

      kubectl create -f tpu-autopilot.yaml

      Saat Anda membuat Tugas ini, GKE akan otomatis melakukan hal berikut:

      1. Menyediakan node untuk menjalankan Pod. Bergantung pada jenis TPU, topologi, dan permintaan resource yang Anda tentukan, node ini berupa slice host tunggal atau slice multi-host.
      2. Menambahkan taint ke Pod dan toleransi ke node untuk mencegah workload lain Anda berjalan di node yang sama dengan workload TPU.

    3. Setelah menyelesaikan bagian ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus beban kerja yang Anda buat:

      kubectl delete -f tpu-autopilot.yaml

    Buat workload yang meminta TPU dan penjadwalan pengumpulan

    Di TPU Trillium, Anda dapat menggunakan penjadwalan pengumpulan untuk mengelompokkan node slice TPU. Mengelompokkan node slice TPU ini akan mempermudah penyesuaian jumlah replika untuk memenuhi permintaan workload. Google Cloud mengontrol update software untuk memastikan bahwa slice yang cukup dalam koleksi selalu tersedia untuk melayani traffic.

    TPU Trillium mendukung penjadwalan pengumpulan untuk node pool host tunggal dan multi-host yang menjalankan workload inferensi. Berikut ini menjelaskan cara kerja penjadwalan pengumpulan yang bergantung pada jenis slice TPU yang Anda gunakan:

    • Slice TPU multi-host: GKE mengelompokkan slice TPU multi-host untuk membentuk koleksi. Setiap node pool GKE adalah replika dalam koleksi ini. Untuk menentukan koleksi, buat slice TPU multi-host dan tetapkan nama unik ke koleksi. Untuk menambahkan lebih banyak slice TPU ke koleksi, buat node pool slice TPU multi-host lain dengan nama koleksi dan jenis workload yang sama.
    • Slice TPU host tunggal: GKE menganggap seluruh node pool slice TPU host tunggal sebagai kumpulan. Untuk menambahkan lebih banyak slice TPU ke koleksi, Anda dapat mengubah ukuran node pool slice TPU host tunggal.

    Untuk mempelajari batasan penjadwalan pengumpulan, lihat Cara kerja penjadwalan pengumpulan

    Menggunakan slice TPU multi-host

    Penjadwalan pengumpulan di node slice TPU multi-host tersedia untuk cluster Autopilot di versi 1.31.2-gke.1537000 dan yang lebih baru. Node slice TPU multi-host dengan topologi 2x4 hanya didukung di 1.31.2-gke.1115000 atau yang lebih baru. Untuk membuat node slice TPU multi-host dan mengelompokkannya sebagai koleksi, tambahkan label Kubernetes berikut ke spesifikasi workload Anda:

    • cloud.google.com/gke-nodepool-group-name: setiap koleksi harus memiliki nama unik di tingkat cluster. Nilai dalam label cloud.google.com/gke-nodepool-group-name harus mematuhi persyaratan untuk label cluster.

    • cloud.google.com/gke-workload-type: HIGH_AVAILABILITY

      Misalnya, blok kode berikut menentukan koleksi dengan slice TPU multi-host:

        nodeSelector:
    cloud.google.com/gke-nodepool-group-name: ${COLLECTION_NAME}
    cloud.google.com/gke-workload-type: HIGH_AVAILABILITY
    cloud.google.com/gke-tpu-accelerator: tpu-v6e-slice
    cloud.google.com/gke-tpu-topology: 4x4
...

    Menggunakan slice TPU host tunggal

    Penjadwalan pengumpulan di node slice TPU host tunggal tersedia untuk cluster Autopilot di versi 1.31.2-gke.1088000 dan yang lebih baru. Untuk membuat node slice TPU host tunggal dan mengelompokkannya sebagai koleksi, tambahkan label cloud.google.com/gke-workload-type:HIGH_AVAILABILITY dalam spesifikasi workload Anda.

    Misalnya, blok kode berikut menentukan koleksi dengan slice TPU host tunggal:

      nodeSelector:
    cloud.google.com/gke-tpu-accelerator: tpu-v6e-slice
    cloud.google.com/gke-tpu-topology: 2x2
    cloud.google.com/gke-workload-type: HIGH_AVAILABILITY
  ...

    Menggunakan class komputasi kustom untuk men-deploy koleksi

    Untuk mengetahui informasi selengkapnya tentang men-deploy workload yang meminta penjadwalan pengumpulan dan workload TPU menggunakan class komputasi kustom, lihat Pengumpulan multi-host TPU dan Menentukan jenis workload untuk SLO TPU.

    Contoh: Menampilkan total chip TPU dalam slice multi-host

    Workload berikut menampilkan jumlah chip TPU di semua node dalam slice TPU multi-host. Untuk membuat slice multi-host, workload memiliki parameter berikut:

    • Versi TPU: TPU v4
    • Topologi: 2x2x4

    Pemilihan versi dan topologi ini menghasilkan slice multi-host.

    1. Simpan manifes berikut sebagai available-chips-multihost.yaml: 
      apiVersion: v1
kind: Service
metadata:
  name: headless-svc
spec:
  clusterIP: None
  selector:
    job-name: tpu-available-chips
---
apiVersion: batch/v1
kind: Job
metadata:
  name: tpu-available-chips
spec:
  backoffLimit: 0
  completions: 4
  parallelism: 4
  completionMode: Indexed
  template:
    spec:
      subdomain: headless-svc
      restartPolicy: Never
      nodeSelector:
        cloud.google.com/gke-tpu-accelerator: tpu-v4-podslice # Node selector to target TPU v4 slice nodes.
        cloud.google.com/gke-tpu-topology: 2x2x4 # Specifies the physical topology for the TPU slice.
      containers:
      - name: tpu-job
        image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
        ports:
        - containerPort: 8471 # Default port using which TPU VMs communicate
        - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
        command:
        - bash
        - -c
        - |
          python -c 'import jax; print("TPU cores:", jax.device_count())' # Python command to count available TPU chips.
        resources:
          requests:
            cpu: 10
            memory: 407Gi
            google.com/tpu: 4 # Request 4 TPU chips for this workload.
          limits:
            cpu: 10
            memory: 407Gi
            google.com/tpu: 4 # Limit to 4 TPU chips for this workload.
    2. Deploy manifes: 
      kubectl create -f available-chips-multihost.yaml

      GKE menjalankan slice TPU v4 dengan empat VM (slice TPU multi-host). Slice memiliki 16 chip TPU yang saling terhubung.

    3. Pastikan bahwa Job membuat empat Pod: 
      kubectl get pods

      Outputnya mirip dengan yang berikut ini:

      NAME                       READY   STATUS      RESTARTS   AGE
tpu-job-podslice-0-5cd8r   0/1     Completed   0          97s
tpu-job-podslice-1-lqqxt   0/1     Completed   0          97s
tpu-job-podslice-2-f6kwh   0/1     Completed   0          97s
tpu-job-podslice-3-m8b5c   0/1     Completed   0          97s
    4. Dapatkan log salah satu Pod: 
      kubectl logs POD_NAME

      Ganti POD_NAME dengan nama salah satu Pod yang dibuat. Contoh, tpu-job-podslice-0-5cd8r.

      Outputnya mirip dengan hal berikut ini: 

      TPU cores: 16
    5. Opsional: Hapus workload: 
      kubectl delete -f available-chips-multihost.yaml

    Contoh: Menampilkan chip TPU dalam satu node

    Workload berikut adalah Pod statis yang menampilkan jumlah chip TPU yang terpasang ke node tertentu. Untuk membuat node host tunggal, workload memiliki parameter berikut:

    • Versi TPU: TPU v5e
    • Topologi: 2x4

    Pemilihan versi dan topologi ini menghasilkan slice host tunggal.

    1. Simpan manifes berikut sebagai available-chips-singlehost.yaml: 
      apiVersion: v1
kind: Pod
metadata:
  name: tpu-job-jax-v5
spec:
  restartPolicy: Never
  nodeSelector:
    cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice # Node selector to target TPU v5e slice nodes.
    cloud.google.com/gke-tpu-topology: 2x4 # Specify the physical topology for the TPU slice.
  containers:
  - name: tpu-job
    image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
    ports:
    - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
    command:
    - bash
    - -c
    - |
      python -c 'import jax; print("Total TPU chips:", jax.device_count())'
    resources:
      requests:
        google.com/tpu: 8 # Request 8 TPU chips for this container.
      limits:
        google.com/tpu: 8 # Limit to 8 TPU chips for this container.
    2. Deploy manifes: 
      kubectl create -f available-chips-singlehost.yaml

      GKE menyediakan node dengan delapan slice TPU host tunggal yang menggunakan TPU v5e. Setiap node TPU memiliki delapan chip TPU (slice TPU host tunggal).

    3. Dapatkan log Pod: 
      kubectl logs tpu-job-jax-v5

      Outputnya mirip dengan hal berikut ini: 

      Total TPU chips: 8
    4. Opsional: Hapus workload: 
        kubectl delete -f available-chips-singlehost.yaml

    Mengamati dan memantau TPU

    Dasbor

    Kemampuan pengamatan node pool di konsolGoogle Cloud tersedia secara umum. Untuk melihat status node pool multi-host TPU di GKE, buka dasbor Status Node Pool TPU GKE yang disediakan oleh Cloud Monitoring:

    Buka Status Kumpulan Node TPU GKE

    Dasbor ini memberi Anda insight komprehensif tentang kondisi node pool TPU multi-host Anda. Untuk mengetahui informasi selengkapnya, lihat Memantau metrik kondisi untuk node dan node pool TPU.

    Di halaman Kubernetes Clusters di konsol Google Cloud , tab Observability juga menampilkan metrik kemampuan observasi TPU, seperti penggunaan TPU, di bagian heading Accelerators > TPU. Untuk mengetahui informasi selengkapnya, lihat Melihat metrik kemampuan observasi.

    Dasbor TPU diisi hanya jika Anda telah mengaktifkan metrik sistem di cluster GKE Anda.

    Metrik runtime

    Pada GKE versi 1.27.4-gke.900 atau yang lebih baru, workload TPU yang menggunakan JAX versi 0.4.14 atau yang lebih baru dan menentukan containerPort: 8431 akan mengekspor metrik pemakaian TPU sebagai metrik sistem GKE. Metrik berikut tersedia di Cloud Monitoring untuk memantau performa runtime workload TPU Anda:

    • Siklus tugas: persentase waktu selama periode pengambilan sampel terakhir (60 detik) saat TensorCore secara aktif memproses TPU chip. Persentase yang lebih besar berarti pemakaian TPU yang lebih baik.
    • Memori yang digunakan: jumlah memori akselerator yang dialokasikan dalam byte. Sampelnya dibuat setiap 60 detik.
    • Total memori: total memori akselerator dalam byte. Dibuat sampelnya setiap 60 detik.

    Metrik ini berada di skema node Kubernetes (k8s_node) dan container Kubernetes (k8s_container).

    Container Kubernetes:

    • kubernetes.io/container/accelerator/duty_cycle
    • kubernetes.io/container/accelerator/memory_used
    • kubernetes.io/container/accelerator/memory_total

    Node Kubernetes:

    • kubernetes.io/node/accelerator/duty_cycle
    • kubernetes.io/node/accelerator/memory_used
    • kubernetes.io/node/accelerator/memory_total

    Memantau metrik kesehatan untuk node dan node pool TPU

    Jika tugas pelatihan mengalami error atau berakhir dengan kegagalan, Anda dapat memeriksa metrik yang terkait dengan infrastruktur yang mendasarinya untuk mengetahui apakah gangguan tersebut disebabkan oleh masalah pada node atau node pool yang mendasarinya.

    Status node

    Pada GKE versi 1.32.1-gke.1357001 atau yang lebih baru, metrik sistem GKE berikut mengekspos kondisi node GKE:

    • kubernetes.io/node/status_condition

    Kolom condition melaporkan kondisi pada node, seperti Ready, DiskPressure, dan MemoryPressure. Kolom status menampilkan status kondisi yang dilaporkan, yang dapat berupa True, False, atau Unknown. Ini adalah metrik dengan jenis resource yang dimonitor k8s_node.

    Kueri PromQL ini menunjukkan apakah node tertentu Ready:

    kubernetes_io:node_status_condition{
    monitored_resource="k8s_node",
    cluster_name="CLUSTER_NAME",
    node_name="NODE_NAME",
    condition="Ready",
    status="True"}

    Untuk membantu memecahkan masalah dalam cluster, Anda mungkin ingin melihat node yang telah menunjukkan kondisi lain:

    kubernetes_io:node_status_condition{
    monitored_resource="k8s_node",
    cluster_name="CLUSTER_NAME",
    condition!="Ready",
    status="True"}

    Anda mungkin ingin melihat secara khusus node yang tidak Ready:

    kubernetes_io:node_status_condition{
    monitored_resource="k8s_node",
    cluster_name="CLUSTER_NAME",
    condition="Ready",
    status="False"}

    Jika tidak ada data, node sudah siap. Kondisi status diambil sampelnya setiap 60 detik.

    Anda dapat menggunakan kueri berikut untuk memahami status node di seluruh armada:

    avg by (condition,status)(
  avg_over_time(
    kubernetes_io:node_status_condition{monitored_resource="k8s_node"}[${__interval}]))

    Status node pool

    Metrik sistem GKE berikut untuk resource yang dipantau k8s_node_pool mengekspos status node pool GKE:

    • kubernetes.io/node_pool/status

    Metrik ini hanya dilaporkan untuk node pool TPU multi-host.

    Kolom status melaporkan status node pool, seperti Provisioning, Running, Error, Reconciling, atau Stopping. Pembaruan status terjadi setelah operasi GKE API selesai.

    Untuk memverifikasi apakah node pool tertentu memiliki status Running, gunakan kueri PromQL berikut:

    kubernetes_io:node_pool_status{
    monitored_resource="k8s_node_pool",
    cluster_name="CLUSTER_NAME",
    node_pool_name="NODE_POOL_NAME",
    status="Running"}

    Untuk memantau jumlah node pool di project Anda yang dikelompokkan berdasarkan statusnya, gunakan kueri PromQL berikut:

    count by (status)(
  count_over_time(
    kubernetes_io:node_pool_status{monitored_resource="k8s_node_pool"}[${__interval}]))

    Ketersediaan node pool

    Metrik sistem GKE berikut menunjukkan apakah node pool TPU multi-host tersedia:

    • kubernetes.io/node_pool/multi_host/available

    Metrik ini memiliki nilai True jika semua node di node pool tersedia, dan False jika tidak. Metrik ini diambil sampelnya setiap 60 detik.

    Untuk memeriksa ketersediaan node pool TPU multi-host di project Anda, gunakan kueri PromQL berikut:

    avg by (node_pool_name)(
  avg_over_time(
    kubernetes_io:node_pool_multi_host_available{
      monitored_resource="k8s_node_pool",
      cluster_name="CLUSTER_NAME"}[${__interval}]))

    Jumlah gangguan node

    Metrik sistem GKE berikut melaporkan jumlah gangguan untuk node GKE sejak sampel terakhir (metrik diambil sampelnya setiap 60 detik):

    • kubernetes.io/node/interruption_count

    Kolom interruption_type (seperti TerminationEvent, MaintenanceEvent, atau PreemptionEvent) dan interruption_reason (seperti HostError, Eviction, atau AutoRepair) dapat membantu memberikan alasan mengapa node terganggu.

    Untuk mendapatkan perincian gangguan dan penyebabnya di node TPU dalam cluster di project Anda, gunakan kueri PromQL berikut:

      sum by (interruption_type,interruption_reason)(
    sum_over_time(
      kubernetes_io:node_interruption_count{monitored_resource="k8s_node"}[${__interval}]))

    Untuk hanya melihat peristiwa pemeliharaan host, perbarui kueri untuk memfilter nilai HW/SW Maintenance untuk interruption_reason. Gunakan kueri PromQL berikut:

      sum by (interruption_type,interruption_reason)(
    sum_over_time(
      kubernetes_io:node_interruption_count{monitored_resource="k8s_node", interruption_reason="HW/SW Maintenance"}[${__interval}]))

    Untuk melihat jumlah gangguan yang dikelompokkan menurut node pool, gunakan kueri PromQL berikut:

      sum by (node_pool_name,interruption_type,interruption_reason)(
    sum_over_time(
      kubernetes_io:node_pool_interruption_count{monitored_resource="k8s_node_pool", interruption_reason="HW/SW Maintenance", node_pool_name=NODE_POOL_NAME }[${__interval}]))

    Waktu pemulihan (TTR) kumpulan node

    Metrik sistem GKE berikut melaporkan distribusi durasi periode pemulihan untuk node pool TPU multi-host GKE:

    • kubernetes.io/node_pool/accelerator/times_to_recover

    Setiap sampel yang dicatat dalam metrik ini menunjukkan satu peristiwa pemulihan untuk kumpulan node dari periode nonaktif.

    Metrik ini berguna untuk melacak waktu pemulihan node pool TPU multi-host dan waktu antar-gangguan.

    Anda dapat menggunakan kueri PromQL berikut untuk menghitung waktu rata-rata pemulihan (MTTR) selama 7 hari terakhir di cluster Anda:

    sum(sum_over_time(
  kubernetes_io:node_pool_accelerator_times_to_recover_sum{
    monitored_resource="k8s_node_pool", cluster_name="CLUSTER_NAME"}[7d]))
/
sum(sum_over_time(
  kubernetes_io:node_pool_accelerator_times_to_recover_count{
    monitored_resource="k8s_node_pool",cluster_name="CLUSTER_NAME"}[7d]))

    Waktu antara gangguan (TBI) kumpulan node

    Waktu kumpulan node di antara gangguan mengukur berapa lama infrastruktur Anda berjalan sebelum mengalami gangguan. Metrik ini dihitung sebagai rata-rata selama jangka waktu tertentu, dengan pembilang mengukur total waktu infrastruktur Anda aktif dan penyebut mengukur total gangguan pada infrastruktur Anda.

    Contoh PromQL berikut menunjukkan waktu rata-rata antar-gangguan (MTBI) selama 7 hari untuk cluster tertentu:

    sum(count_over_time(
  kubernetes_io:node_memory_total_bytes{
    monitored_resource="k8s_node", node_name=~"gke-tpu.*|gk3-tpu.*", cluster_name="CLUSTER_NAME"}[7d]))
/
sum(sum_over_time(
  kubernetes_io:node_interruption_count{
    monitored_resource="k8s_node", node_name=~"gke-tpu.*|gk3-tpu.*", cluster_name="CLUSTER_NAME"}[7d]))

    Metrik host

    Pada GKE versi 1.28.1-gke.1066000 atau yang lebih baru, VM dalam slice TPU mengekspor metrik pemakaian TPU sebagai metrik sistem GKE. Metrik berikut tersedia di Cloud Monitoring untuk memantau performa host TPU Anda:

    • Penggunaan TensorCore: persentase TensorCore yang saat ini digunakan. Nilai TensorCore sama dengan jumlah unit perkalian matriks (MXU) ditambah unit vektor. Nilai pemakaian TensorCore adalah pembagian dari operasi TensorCore yang dilakukan selama periode sampel terakhir (60 detik) dengan jumlah operasi TensorCore yang didukung selama periode yang sama. Nilai yang lebih besar berarti pemakaian yang lebih baik.
    • Penggunaan bandwidth memori: persentase bandwidth memori akselerator yang saat ini sedang digunakan. Dihitung dengan membagi bandwidth memori yang digunakan selama periode sampel (60 detik) dengan bandwidth maksimum yang didukung selama periode sampel yang sama.

    Metrik ini berada di skema node Kubernetes (k8s_node) dan container Kubernetes (k8s_container).

    Container Kubernetes:

    • kubernetes.io/container/accelerator/tensorcore_utilization
    • kubernetes.io/container/accelerator/memory_bandwidth_utilization

    Node Kubernetes:

    • kubernetes.io/node/accelerator/tensorcore_utilization
    • kubernetes.io/node/accelerator/memory_bandwidth_utilization

    Untuk mengetahui informasi selengkapnya, lihat Metrik Kubernetes dan Metrik sistem GKE.

    Logging

    Log yang dikeluarkan oleh container yang berjalan di node GKE, termasuk VM TPU, dikumpulkan oleh agen logging GKE, dikirim ke Logging, dan terlihat di Logging.

    Rekomendasi untuk workload TPU di Autopilot

    Rekomendasi berikut dapat meningkatkan efisiensi workload TPU Anda:

    • Gunakan Pod waktu proses yang diperpanjang untuk masa tenggang hingga tujuh hari sebelum GKE menghentikan Pod Anda untuk penurunan skala atau upgrade node. Anda dapat menggunakan periode pemeliharaan dan pengecualian dengan Pod waktu proses yang diperpanjang untuk menunda lebih lanjut upgrade node otomatis.
    • Gunakan reservasi kapasitas untuk memastikan bahwa workload Anda menerima TPU yang diminta tanpa dimasukkan dalam antrean untuk ketersediaan.

    Untuk mempelajari cara menyiapkan Cloud TPU di GKE, lihat referensi Google Cloud berikut: