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, lihat Peran dan tugas pengguna umum GKE Enterprise. Google Cloud

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 runtime 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 menjalankan 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 gcloud components update.
  • 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 resource zona yang dicadangkan.

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 Kuota

  2. Di kotak Filter , lakukan tindakan berikut:

    1. Gunakan tabel berikut untuk memilih dan menyalin properti kuota berdasarkan versi dan nilai TPU 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

    2. Pilih properti Dimensi (mis. 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.

Opsi untuk menyediakan TPU di GKE

Autopilot GKE memungkinkan Anda menggunakan TPU secara langsung di setiap workload dengan menggunakan nodeSelector Kubernetes.

Atau, Anda dapat meminta TPU menggunakan kelas komputasi kustom. Dengan class komputasi kustom, administrator platform dapat menentukan hierarki konfigurasi node agar GKE memprioritaskannya selama keputusan penskalaan node, sehingga beban kerja berjalan di hardware yang Anda pilih.

Untuk mengetahui petunjuknya, lihat bagian Menyediakan TPU secara terpusat dengan class komputasi kustom.

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 menggunakan TPU di GKE, pastikan Anda menggunakan versi berikut:
    Jenis TPU libtpu.so versi
    TPU Trillium (v6e)
    tpu-v6e-slice
    TPU v5e
    tpu-v5-lite-podslice
    TPU v5p
    tpu-v5p-slice
    • Versi jax[tpu] yang direkomendasikan: 0.4.19 atau yang lebih baru.
    • Versi torchxla[tpuvm] yang direkomendasikan: disarankan untuk menggunakan build versi setiap malam pada 23 Oktober 2023.
    TPU v4
    tpu-v4-podslice
    TPU v3
    tpu-v3-slice
    tpu-v3-device
  2. Tetapkan variabel lingkungan berikut untuk container yang meminta resource TPU:
    • TPU_WORKER_ID: Bilangan bulat unik untuk setiap Pod. ID ini menunjukkan worker-id unik di slice TPU. Nilai yang didukung untuk kolom ini berkisar dari nol hingga jumlah Pod dikurangi satu.
    • TPU_WORKER_HOSTNAMES: Daftar nama host atau alamat IP VM TPU yang dipisahkan koma yang perlu berkomunikasi satu sama lain dalam slice. Harus ada nama host atau alamat IP untuk setiap VM TPU dalam slice. Daftar alamat IP atau nama host diurutkan dan dimulai dengan indeks nol oleh TPU_WORKER_ID.

      • GKE otomatis menyuntikkan variabel lingkungan ini menggunakan webhook mutasi saat Job dibuat dengan properti completionMode: Indexed, subdomain, parallelism > 1, dan meminta google.com/tpu. GKE menambahkan Service headless sehingga data DNS ditambahkan untuk Pod yang mendukung Service.

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

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 chip TPU 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 hal berikut:

  • 4 chip, 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.

Membuat 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 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: python:3.10
        ports:
        - containerPort: 8471 # Default port using which TPU VMs communicate
        - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
        command:
        - bash
        - -c
        - |
          pip install 'jax[tpu]' -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
          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.
    • ** Opsional 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 data 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
  ...

Menyediakan TPU secara terpusat dengan class komputasi kustom

Untuk menyediakan TPU dengan class komputasi kustom yang mengikuti aturan TPU dan men-deploy workload, 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-v5-lite-podslice
      count: 4
      topology: 2x4
  - spot: true
    tpu:
      type: tpu-v5-lite-podslice
      count: 4
      topology: 2x4
  - flexStart:
      enabled: true
    tpu:
      type: tpu-v6e-slice
      count: 4
      topology: 2x4
  nodePoolAutoCreation:
    enabled: true

  2. Deploy class komputasi:

    kubectl apply -f tpu-compute-class.yaml

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

  3. 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: python:3.10
        ports:
        - containerPort: 8471 # Default port using which TPU VMs communicate
        - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
        command:
        - bash
        - -c
        - |
          pip install 'jax[tpu]' -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
          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 di kolom tpu.count dalam class komputasi 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.

  4. 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 melakukan penggantian 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 class komputasi kustom.

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

    kubectl delete -f tpu-job.yaml

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
        cloud.google.com/gke-tpu-topology: 2x2x4
      containers:
      - name: tpu-job
        image: python:3.10
        ports:
        - containerPort: 8471 # Default port using which TPU VMs communicate
        - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
        command:
        - bash
        - -c
        - |
          pip install 'jax[tpu]' -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
          python -c 'import jax; print("TPU cores:", jax.device_count())'
        resources:
          requests:
            cpu: 10
            memory: 407Gi
            google.com/tpu: 4
          limits:
            cpu: 10
            memory: 407Gi
            google.com/tpu: 4
  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
    cloud.google.com/gke-tpu-topology: 2x4
  containers:
  - name: tpu-job
    image: python:3.10
    ports:
    - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
    command:
    - bash
    - -c
    - |
      pip install 'jax[tpu]' -f https://storage.googleapis.com/jax-releases/libtpu_releases.html
      python -c 'import jax; print("Total TPU chips:", jax.device_count())'
    resources:
      requests:
        google.com/tpu: 8
      limits:
        google.com/tpu: 8
  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 kini 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 kondisi 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 dipantau 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 di 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 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:

```promql
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:

```promql
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: