Men-deploy workload TPU di GKE Standard

Halaman ini menunjukkan cara meminta dan men-deploy workload yang menggunakan akselerator Cloud TPU (TPU) di Google Kubernetes Engine (GKE).

Sebelum mengonfigurasi dan men-deploy workload TPU di GKE, Anda harus memahami konsep berikut:

1. Pengantar Cloud TPU.
2. Arsitektur sistem Cloud TPU.
3. Tentang TPU di GKE.

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 initialize gcloud CLI. Jika sebelumnya Anda telah menginstal gcloud CLI, dapatkan versi terbaru dengan menjalankan gcloud components update.

Ketersediaan TPU di GKE

Gunakan GKE untuk membuat dan mengelola node pool dengan TPU. Anda dapat menggunakan akselerator yang dibuat secara khusus ini untuk melakukan pelatihan, penyesuaian, dan inferensi model AI berskala besar.

Lihat daftar versi TPU yang didukung di GKE.

Merencanakan konfigurasi TPU

Rencanakan konfigurasi TPU berdasarkan model machine learning dan jumlah memori yang diperlukan. Berikut adalah langkah-langkah yang relevan saat merencanakan konfigurasi TPU:

1. Pilih topologi dan versi TPU.
2. Pilih jenis node pool yang akan digunakan.

Pastikan kuota yang cukup untuk on-demand atau Spot VM

Membuat kumpulan node TPU yang menggunakan reservasi TPU tidak memerlukan kuota TPU.¹ Anda dapat melewati bagian ini untuk TPU yang telah dipesan.

Pembuatan kumpulan node on-demand atau Spot TPU di GKE memerlukan kuota Compute Engine API. Kuota Compute Engine API (compute.googleapis.com) tidak sama dengan kuota Cloud TPU API (tpu.googleapis.com), yang diperlukan saat membuat TPU dengan Cloud TPU API.

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

1. Buka halaman Kuota di Konsol Google Cloud:

   Buka Quotas

2. Di kotak Filter filter_list, lakukan hal berikut:

   1. Pilih properti Layanan, masukkan Compute Engine API, lalu tekan Enter.

   2. Pilih properti Jenis, lalu pilih Kuota.

   3. Pilih properti Name dan masukkan nama kuota berdasarkan versi TPU dan jenis mesin. Misalnya, jika Anda berencana untuk membuat node TPU v5e on demand yang jenis mesinnya diawali dengan ct5lp-, masukkan TPU v5 Lite PodSlice chips.

      Versi TPU	Jenis mesin dimulai dengan	Nama kuota untuk instance on demand	Nama kuota untuk instance Spot2
      TPU v4	ct4p-	TPU v4 PodSlice chips	Preemptible TPU v4 PodSlice chips
      TPU v5e	ct5l-	TPU v5 Lite Device chips	Preemptible TPU v5 Lite Device chips
      TPU v5e	ct5lp-	TPU v5 Lite PodSlice chips	Preemptible TPU v5 Lite PodSlice chips
      TPU v5p	ct5p-	TPU v5p chips	Preemptible TPU v5p chips

   4. Pilih properti Dimension (e.g. locations) dan masukkan region: diikuti dengan nama region tempat Anda berencana membuat TPU di GKE. Misalnya, masukkan region:us-west4 jika Anda berencana untuk membuat node 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 diinginkan, dan Anda harus meminta peningkatan kuota TPU.

Memastikan ketersediaan reservasi

Membuat kumpulan node TPU yang dicadangkan, yang berarti kumpulan node TPU yang menggunakan reservasi, tidak memerlukan kuota TPU. Namun, reservasi harus memiliki chip yang memadai atau tidak digunakan pada saat kumpulan node dibuat.

Untuk melihat reservasi yang ada dalam project, lihat daftar reservasi Anda.

Untuk melihat jumlah chip dalam reservasi TPU yang tersedia, lihat detail reservasi.

Membuat cluster

Buat cluster GKE dalam mode Standard di region dengan TPU yang tersedia. Sebaiknya gunakan cluster regional, yang memberikan panel kontrol Kubernetes dengan ketersediaan tinggi. Anda dapat menggunakan Google Cloud CLI atau Konsol Google Cloud.

gcloud container clusters create CLUSTER_NAME \
  --location LOCATION \
  --cluster-version VERSION

Ganti kode berikut:

• CLUSTER_NAME: nama cluster baru.
• LOCATION: region dengan kapasitas TPU yang tersedia.
• VERSION: versi GKE, yang harus mendukung jenis mesin yang ingin Anda gunakan. Perhatikan bahwa versi GKE default mungkin tidak tersedia untuk TPU target Anda. Untuk mempelajari versi GKE minimum yang tersedia menurut jenis mesin TPU, lihat Ketersediaan TPU di GKE

Membuat node pool

Slice TPU host tunggal

Anda dapat membuat node pool slice TPU host tunggal menggunakan Google Cloud CLI, Terraform, atau Konsol Google Cloud.

gcloud container node-pools create POOL_NAME \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --node-locations=NODE_ZONES \
    --machine-type=MACHINE_TYPE \
    [--num-nodes=NUM_NODES \]
    [--spot \]
    [--enable-autoscaling \]
    [--reservation-affinity=specific \
    --reservation=RESERVATION_NAME \]
    [--total-min-nodes TOTAL_MIN_NODES \]
    [--total-max-nodes TOTAL_MAX_NODES \]
    [--location-policy=ANY]

resource "google_container_node_pool" "NODE_POOL_RESOURCE_NAME" {
  provider           = google
  project            = PROJECT_ID
  cluster            = CLUSTER_NAME
  name               = POOL_NAME
  location           = CLUSTER_LOCATION
  node_locations     = [NODE_ZONES]
  initial_node_count = NUM_NODES
  autoscaling {
    total_min_node_count = TOTAL_MIN_NODES
    total_max_node_count = TOTAL_MAX_NODES
    location_policy      = "ANY"
  }

  node_config {
    machine_type = MACHINE_TYPE
    reservation_affinity {
      consume_reservation_type = "SPECIFIC_RESERVATION"
      key = "compute.googleapis.com/reservation-name"
      values = [RESERVATION_LABEL_VALUES]
    }
    spot = true
  }
}

Slice TPU multi-host

Anda dapat membuat node pool slice TPU multi-host menggunakan Google Cloud CLI, Terraform, atau Konsol Google Cloud.

gcloud container node-pools create POOL_NAME \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --node-locations=NODE_ZONE \
    --machine-type=MACHINE_TYPE \
    --tpu-topology=TPU_TOPOLOGY \
    --num-nodes=NUM_NODES \
    [--spot \]
    [--enable-autoscaling \
      --max-nodes MAX_NODES]
    [--reservation-affinity=specific \
    --reservation=RESERVATION_NAME]

Status penyediaan

Jika GKE tidak dapat membuat kumpulan node TPU slice karena kapasitas TPU yang tersedia tidak memadai, GKE akan menampilkan pesan error yang menunjukkan bahwa TPU node tidak dapat dibuat karena kurangnya kapasitas.

Jika Anda membuat kumpulan node slice TPU host tunggal, pesan error akan terlihat seperti ini:

2 nodes cannot be created due to lack of capacity. The missing nodes will be
created asynchronously once capacity is available. You can either wait for the
nodes to be up, or delete the node pool and try re-creating it again later.

Jika Anda membuat kumpulan node slice TPU multi-host, pesan error akan terlihat seperti ini:

The nodes (managed by ...) cannot be created now due to lack of capacity. They
will be created asynchronously once capacity is available. You can either wait
for the nodes to be up, or delete the node pool and try re-creating it again
later.

Permintaan penyediaan TPU Anda dapat berada dalam antrean untuk waktu yang lama dan akan tetap dalam status "Penyediaan" saat berada dalam antrean.

Setelah kapasitas tersedia, GKE akan membuat node yang tersisa yang belum dibuat.

Jika Anda membutuhkan kapasitas lebih cepat, pertimbangkan untuk mencoba Spot VM, meskipun perlu diketahui bahwa Spot VM menggunakan kuota yang berbeda dari instance on-demand.

Anda dapat menghapus permintaan TPU yang ada dalam antrean dengan menghapus kumpulan node slice TPU.

Menjalankan workload Anda pada TPU node

Persiapan workload

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	Versi libtpu.so
   TPU v5e tpu-v5-lite-podslice tpu-v5-lite-device	Versi jax[tpu] yang direkomendasikan: v0.4.9 atau yang lebih baru Versi torchxla[tpuvm] yang direkomendasikan: v2.1.0 atau yang lebih baru
   TPU v5p	Versi jax[tpu] yang direkomendasikan: 0.4.19 atau yang lebih baru. Versi torchxla[tpuvm] yang direkomendasikan: disarankan untuk menggunakan build versi malam pada 23 Oktober 2023.
   TPU v4 tpu-v4-podslice	jax[tpu]: v0.4.4 atau yang lebih baru torchxla[tpuvm]: v2.0.0 atau yang lebih baru

2. Tetapkan variabel lingkungan berikut untuk penampung 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 yang dipisahkan koma dari nama host VM TPU atau alamat IP 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 nol diindeks oleh TPU_WORKER_ID.

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

   Saat men-deploy resource multi-host TPU dengan Kuberay, GKE menyediakan webhook yang dapat di-deploy sebagai bagian dari template Terraform untuk menjalankan Ray di GKE. Petunjuk untuk menjalankan Ray di GKE dengan TPU dapat ditemukan di Panduan Pengguna TPU. Webhook yang berubah akan memasukkan variabel lingkungan ini ke dalam cluster Ray yang meminta properti google.com/tpu dan pemilih node cloud.go888ogle.com.fqhub.com/gke-tpu-topology multi-host.

   • Dalam manifes beban kerja, tambahkan pemilih node Kubernetes untuk memastikan bahwa GKE menjadwalkan beban kerja TPU Anda pada jenis mesin TPU dan topologi TPU yang Anda tentukan:

       nodeSelector:
         cloud.go888ogle.com.fqhub.com/gke-tpu-accelerator: TPU_ACCELERATOR
         cloud.go888ogle.com.fqhub.com/gke-tpu-topology: TPU_TOPOLOGY
       

     Ganti kode berikut:

     • TPU_ACCELERATOR: Nama akselerator TPU:
       • Untuk TPU v4, gunakan tpu-v4-podslice
       • Untuk jenis mesin TPU v5e yang dimulai dengan ct5l-, gunakan tpu-v5-lite-device
       • Untuk jenis mesin TPU v5e yang dimulai dengan ct5lp-, gunakan tpu-v5-lite-podslice
       • Untuk TPU v5p, gunakan tpu-v5p-slice
     • TPU_TOPOLOGY: Topologi fisik untuk slice TPU. Format topologi bergantung pada versi TPU sebagai berikut:
       • TPU v4: Menentukan topologi dalam 3 tuple ({A}x{B}x{C}), misalnya 4x4x4.
       • TPU v5e: Menentukan topologi dalam 2 tuple ({A}x{B}), misalnya 2x2.
       • TPU v5p: Menentukan topologi dalam 3 tuple ({A}x{B}x{C}), misalnya 4x4x4.

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

Bagian berikut menunjukkan contoh cara menjalankan Tugas yang melakukan komputasi sederhana dengan TPU.

Contoh 1: Menjalankan workload yang menampilkan jumlah TPU chip yang tersedia di TPU node pool

Workload berikut menampilkan jumlah chip TPU di semua node dalam slice TPU multi-host. Untuk membuat slice multi-host, beban kerja 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.go888ogle.com.fqhub.com/gke-tpu-accelerator: tpu-v4-podslice
           cloud.go888ogle.com.fqhub.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.
           securityContext:
             privileged: true
           command:
           - bash
           - -c
           - |
             pip install 'jax[tpu]' -f http://storage.googleapis.com/jax-releases/libtpu_releases.html
             python -c 'import jax; print("TPU cores:", jax.device_count())'
           resources:
             requests:
               cpu: 10
               memory: 500Gi
               google.com/tpu: 4
             limits:
               cpu: 10
               memory: 500Gi
               google.com/tpu: 4
   

2. Deploy manifes:

   kubectl create -f available-chips-multihost.yaml
   

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

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

Contoh 2: menjalankan workload yang menampilkan jumlah TPU chip yang tersedia di VM TPU

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

• Versi TPU: TPU v5e
• Topologi: 2x4

Pilihan versi dan topologi ini menghasilkan irisan 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.go888ogle.com.fqhub.com/gke-tpu-accelerator: tpu-v5-lite-podslice
       cloud.go888ogle.com.fqhub.com/gke-tpu-topology: 2x4
     containers:
     - name: tpu-job
       image: python:3.10
       ports:
       - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
       securityContext:
         privileged: true
       command:
       - bash
       - -c
       - |
         pip install 'jax[tpu]' -f http://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 irisan TPU host tunggal yang menggunakan TPU v5e. Setiap VM TPU memiliki delapan chip (slice TPU host tunggal).

3. Dapatkan log Pod:

   kubectl logs tpu-job-jax-v5
   

   Outputnya mirip dengan hal berikut ini:

   Total TPU chips: 8
   

Mengupgrade node pool menggunakan akselerator (GPU dan TPU)

GKE otomatis mengupgrade Cluster standar, termasuk node pool. Anda juga dapat mengupgrade kumpulan node secara manual jika ingin node Anda pada versi yang lebih baru lebih cepat. Untuk mengontrol cara kerja upgrade untuk cluster Anda, gunakan saluran rilis, periode pemeliharaan dan pengecualian, dan urutan peluncuran.

Anda juga dapat mengonfigurasi strategi upgrade node untuk kumpulan node, seperti upgrade surge atau upgrade biru-hijau. Dengan mengonfigurasi strategi ini, Anda dapat memastikan bahwa node pool diupgrade dengan cara yang mencapai keseimbangan optimal antara kecepatan dan gangguan bagi lingkungan Anda. Untuk kumpulan node slice TPU multi-host, daripada menggunakan strategi upgrade node yang telah dikonfigurasi, GKE membuat ulang seluruh kumpulan node secara atomik dalam satu langkah. Untuk mempelajari lebih lanjut, lihat definisi atomicity dalam Terminologi terkait TPU di GKE.

Penggunaan strategi upgrade node akan memerlukan GKE untuk menyediakan resource tambahan untuk sementara, bergantung pada konfigurasinya. Jika Google Cloud memiliki kapasitas terbatas untuk resource node pool—misalnya, Anda melihat error ketersediaan resource saat mencoba membuat lebih banyak node dengan GPU atau TPU—lihat Mengupgrade di lingkungan dengan resource terbatas.

Pembersihan

Agar tidak menimbulkan biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam panduan ini, pertimbangkan untuk menghapus TPU node pool yang tidak lagi memiliki workload terjadwal. Jika workload yang berjalan harus dihentikan secara terkontrol, gunakan kubectl drain untuk membersihkan workload sebelum Anda menghapus node.

1. Hapus TPU node pool:

   gcloud container node-pools delete POOL_NAME \
       --location=LOCATION \
       --cluster=CLUSTER_NAME
   

   Ganti kode berikut:

   • POOL_NAME: Nama node pool.
   • CLUSTER_NAME: Nama cluster.
   • LOCATION: Lokasi komputasi cluster.

Konfigurasi tambahan

Bagian berikut menjelaskan konfigurasi tambahan yang dapat Anda terapkan pada workload TPU.

Multi-slice

Anda dapat menggabungkan slice yang lebih kecil dalam Multi-slice untuk menangani workload pelatihan yang lebih besar. Untuk mengetahui informasi selengkapnya, silakan melihat TPU multi-slice di GKE.

Memigrasikan pemesanan TPU

Jika sudah memiliki pemesanan TPU, Anda harus memigrasikan pemesanan TPU terlebih dahulu ke sistem pemesanan berbasis Compute Engine yang baru. Anda juga dapat membuat sistem pemesanan berbasis Compute Engine yang tidak memerlukan migrasi. Untuk mempelajari cara memigrasikan pemesanan TPU, silakan melihat pemesanan TPU.

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.

Menggunakan penyediaan otomatis node GKE

Anda dapat mengonfigurasi GKE untuk membuat dan menghapus node pool secara otomatis guna memenuhi permintaan resource dari workload TPU Anda. Untuk mengetahui informasi selengkapnya, silakan melihat Mengonfigurasi Cloud TPU.

Perbaikan otomatis TPU node

Jika TPU node dalam node pool slice TPU multi-host tidak responsif, seluruh node pool akan dibuat ulang. Kondisi yang menyebabkan TPU node tidak responsif mencakup berikut ini:

• Semua TPU node dengan conditions node umum.
• Semua TPU node dengan jumlah TPU yang tidak dapat dialokasikan yang lebih besar dari nol.
• Semua instance VM TPU yang diakhiri (karena preemption) atau dihentikan.
• Pemeliharaan node: Jika ada TPU node (VM) dalam node pool slice TPU multi-host menjadi tidak aktif karena pemeliharaan host, GKE akan membuat ulang seluruh slice TPU.

Anda dapat melihat status perbaikan (termasuk alasan kegagalan) di histori operasi. Jika kegagalan disebabkan oleh kuota yang tidak mencukupi, hubungi perwakilan akun Google Cloud Anda untuk meningkatkan kuota yang sesuai.

Konfigurasi penghentian halus node TPU

Di cluster GKE dengan bidang kontrol yang menjalankan 1.29.1-gke.1425000 atau yang lebih baru, node TPU mendukung sinyal SIGTERM yang memberi tahu node tentang penonaktifan dalam waktu dekat. Notifikasi penonaktifan yang akan segera dapat dikonfigurasi hingga lima menit di TPU node.

Anda dapat mengonfigurasi GKE untuk menghentikan workload ML dengan lancar dalam jangka waktu notifikasi ini. Selama penghentian tuntas, beban kerja Anda dapat melakukan proses pembersihan, seperti menyimpan data beban kerja untuk mengurangi kehilangan data. Untuk mendapatkan waktu notifikasi maksimum, dalam manifes Pod, tetapkan kolom spec.terminationGracePeriodSeconds ke 300 detik (lima menit) sebagai berikut:

    spec:
      terminationGracePeriodSeconds: 300

GKE berusaha sebaik mungkin untuk menghentikan Pod ini dengan baik dan menjalankan tindakan penghentian yang Anda tentukan, misalnya, menyimpan status pelatihan.

Menjalankan container tanpa mode hak istimewa

Jika TPU node Anda menjalankan versi yang lebih lama dari 1.28, silakan membaca bagian berikut:

Container yang berjalan pada VM TPU memerlukan akses ke batas yang lebih tinggi untuk memori terkunci sehingga driver dapat berkomunikasi dengan TPU chip melalui akses memori langsung (DMA). Untuk mengaktifkan opsi ini, Anda harus mengonfigurasi ulimit yang lebih tinggi. Jika Anda ingin mengurangi cakupan izin di container, selesaikan langkah-langkah berikut:

1. Edit securityContext untuk menyertakan kolom berikut:

   securityContext:
     capabilities:
       add: ["SYS_RESOURCE"]
   

2. Tingkatkan ulimit dengan menjalankan perintah berikut di dalam container sebelum menyiapkan workload Anda untuk menggunakan TPU resource:

   ulimit -l 68719476736
   

Catatan: Untuk TPU v5e, menjalankan container tanpa mode hak istimewa tersedia dalam cluster di versi 1.27.4-gke.900 dan yang lebih baru.

Kemampuan observasi dan metrik

Dasbor

Di halaman Cluster Kubernetes di Google Cloud Console, tab Observability menampilkan metrik kemampuan observasi TPU. Untuk informasi selengkapnya, lihat metrik kemampuan observasi GKE.

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

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 dalam 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 terletak 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

Metrik host

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

• Pemakaian TensorCore: Persentase TensorCore yang saat ini dipakai. 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 pemanfaatan yang lebih baik.
• Pemakaian bandwidth memori: Persentase saat ini dari bandwidth memori akselerator yang sedang digunakan. Dihitung dengan membagi bandwidth memori yang digunakan selama periode sampel (60 dtk) dengan bandwidth maksimum yang didukung selama periode sampel yang sama.

Metrik ini terletak 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/container/node/tensorcore_utilization
• kubernetes.io/container/node/memory_bandwidth_utilization

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

Masalah umum

• Autoscaler cluster mungkin salah menghitung kapasitas untuk TPU node baru sebelum node tersebut melaporkan TPU yang tersedia. Autoscaler cluster kemudian dapat melakukan peningkatan skala tambahan dan akibatnya membuat lebih banyak node daripada yang diperlukan. Autoscaler cluster akan memperkecil skala node tambahan, jika tidak diperlukan, setelah operasi pengecilan skala reguler.
• Autoscaler cluster membatalkan peningkatan skala TPU node pool yang masih dalam status menunggu selama lebih dari 15 menit. Autoscaler Cluster akan mencoba kembali operasi peningkatan skala tersebut nanti. Perilaku ini dapat mengurangi ketersediaan TPU bagi pelanggan yang tidak menggunakan pemesanan.
• Workload non-TPU yang memiliki toleransi terhadap taint TPU dapat mencegah pengecilan skala node pool jika workload tersebut sedang dibuat ulang selama proses pengosongan TPU node pool.

Langkah selanjutnya

• Menayangkan Model Bahasa Besar dengan Saxml di TPU
• Pelajari cara menyiapkan Ray di GKE dengan TPU lebih lanjut
• Bangun machine learning berskala besar di Cloud TPU dengan GKE
• Menayangkan Model Bahasa Besar dengan KubeRay di TPU
• Memecahkan masalah TPU di GKE