Men-deploy workload TPU di GKE Standard

Standard

---

Halaman ini menunjukkan cara meminta dan men-deploy workload pelatihan, penyesuaian, dan inferensi model kecerdasan buatan (AI) dan machine learning (ML) berskala besar menggunakan akselerator Cloud TPU (TPU) di cluster Google Kubernetes Engine (GKE) Standard.

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 lakukan inisialisasi gcloud CLI. Jika sebelumnya Anda telah menginstal gcloud CLI, dapatkan versi terbaru dengan menjalankan gcloud components update.
  Catatan: Untuk penginstalan gcloud CLI yang ada, pastikan untuk menyetel properti compute/region dan compute/zone. Dengan menyetel lokasi default, Anda dapat menghindari error di gcloud CLI yang seperti ini: One of [--zone, --region] must be supplied: Please specify location.

Merencanakan konfigurasi TPU

Rencanakan konfigurasi TPU berdasarkan model dan jumlah memori yang diperlukan. Sebelum menggunakan panduan ini untuk men-deploy workload di TPU, selesaikan langkah-langkah perencanaan di Merencanakan konfigurasi TPU.

Pastikan Anda memiliki kuota TPU

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

Kuota untuk VM on-demand atau Spot

Jika membuat node pool slice TPU dengan VM on-demand atau Spot, Anda harus memiliki kuota TPU yang memadai di region yang ingin digunakan.

Membuat node pool slice TPU yang menggunakan pemesanan TPU tidak memerlukan kuota TPU apa pun.¹ Anda dapat dengan aman melewati bagian ini untuk TPU yang direservasi.

Membuat node pool slice TPU on-demand atau Spot 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 saat ini dari kuota Compute Engine API untuk TPU, ikuti langkah-langkah berikut:

1. Buka halaman Kuota di Konsol Google Cloud:

   Buka Kuota

2. Di kotak Filter , lakukan tindakan berikut:

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

   2. Pilih properti Type, lalu pilih Quota.

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

      Versi TPU	Jenis mesin dimulai dengan	Nama kuota untuk instance on demand	Nama kuota untuk instance Spot^2
      TPU v3	ct3-	TPU v3 Device chips	Preemptible TPU v3 Device chips
      TPU v3	ct3p-	TPU v3 PodSlice chips	Preemptible TPU v3 PodSlice chips
      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
      TPU v6e (Pratinjau)	ct6e-	TPU v6e Slice chips	Preemptible TPU v6e Lite PodSlice chips

   4. Pilih properti Dimensions (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 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 peningkatan kuota TPU.

Saat reservasi TPU dibuat, nilai batas dan penggunaan saat ini untuk kuota yang sesuai akan meningkat sesuai dengan jumlah chip dalam reservasi TPU. Misalnya, saat reservasi dibuat untuk 16 chip TPU v5e yang jenis mesinnya dimulai dengan ct5lp-, Batas dan Penggunaan saat ini untuk kuota TPU v5 Lite PodSlice chips di region yang relevan akan bertambah 16.

1. Saat membuat node pool slice TPU, gunakan flag --reservation dan --reservation-affinity=specific untuk membuat instance yang dicadangkan. Pemesanan TPU tersedia saat membeli komitmen. ↩

2. Saat membuat node pool slice TPU, gunakan tanda --spot untuk membuat instance Spot. ↩

Kuota untuk resource GKE tambahan

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

• Kuota SSD Persistent Disk (GB): Disk booting setiap node Kubernetes memerlukan 100 GB secara default. Oleh karena itu, kuota ini harus ditetapkan setidaknya sebesar jumlah maksimum node GKE yang Anda perkirakan akan dibuat dan 100 GB (node * 100 GB).
• Kuota alamat IP yang digunakan: Setiap node Kubernetes menggunakan satu alamat IP. Oleh karena itu, kuota ini harus ditetapkan setidaknya setinggi jumlah maksimum node GKE yang Anda perkirakan akan dibuat.
• Pastikan max-pods-per-node selaras dengan rentang subnet: Setiap node Kubernetes menggunakan rentang IP sekunder untuk Pod. Misalnya, max-pods-per-node dari 32 memerlukan 64 alamat IP yang diterjemahkan menjadi subnet /26 per node. Perhatikan bahwa rentang ini tidak boleh dibagikan dengan cluster lain. Untuk menghindari penggunaan rentang alamat IP secara maksimal, 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 sama dengan jumlah maksimum node GKE yang Anda perkirakan akan dibuat.

Untuk meminta penambahan kuota, lihat Meminta kuota yang lebih tinggi.

Memastikan ketersediaan reservasi

Membuat node pool slice TPU yang direservasi, yang menggunakan reservasi, tidak memerlukan kuota TPU apa pun. Namun, reservasi harus memiliki chip TPU yang tersedia atau tidak digunakan saat node pool dibuat.

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

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

Membuat cluster

Buat cluster GKE dalam mode Standard di region dengan TPU yang tersedia.

Praktik terbaik:

Gunakan cluster regional, yang memberikan panel kontrol Kubernetes dengan ketersediaan tinggi.

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 berdasarkan 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

gcloud container node-pools create POOL_NAME \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --node-locations=NODE_ZONES \
    --machine-type=MACHINE_TYPE

Ganti kode berikut:

• POOL_NAME: Nama node pool baru.
• LOCATION: Nama zona berdasarkan versi TPU yang ingin Anda gunakan. Untuk mengidentifikasi lokasi yang tersedia, lihat Ketersediaan TPU di GKE.
• CLUSTER_NAME: Nama cluster.
• NODE_ZONE: Daftar yang dipisahkan koma untuk satu atau beberapa zona tempat GKE membuat node pool.
• MACHINE_TYPE: Jenis mesin yang akan digunakan untuk node. Untuk mengetahui informasi selengkapnya tentang jenis mesin yang kompatibel dengan TPU, gunakan tabel di Memilih versi TPU.

Secara opsional, Anda juga dapat menggunakan flag berikut:

• --num-nodes=NUM_NODES: Jumlah node awal dalam node pool di setiap zona. Jika Anda menghapus flag ini,GKE akan menetapkan default 3,

  Praktik terbaik:

  Jika Anda menggunakan flag enable-autoscaling untuk node pool, tetapkan num-nodes ke 0 sehingga autoscaler akan menyediakan node tambahan segera setelah workload Anda memintanya.

• --reservation=RESERVATION_NAME: Nama pemesanan yang digunakan GKE saat membuat node pool. Jika flag ini dihapus, GKE akan menggunakan TPU yang tersedia. Untuk mempelajari pemesanan TPU lebih lanjut, lihat Pemesanan TPU.

• --enable-autoscaling: Membuat node pool dengan penskalaan otomatis yang diaktifkan. Memerlukan flag tambahan berikut:

  • --total-min-nodes=TOTAL_MIN_NODES: Jumlah minimum semua node dalam node pool.
  • --total-max-nodes=TOTAL_MAX_NODES: Jumlah maksimum semua node dalam node pool.
  • --location-policy=ANY: memprioritaskan penggunaan reservasi yang tidak digunakan dan mengurangi risiko preemption Spot VM.

• --spot: Menetapkan node pool agar menggunakan Spot VM untuk node di node pool. Nama ini tidak dapat diubah setelah pembuatan node pool.

Untuk mengetahui daftar lengkap semua flag yang dapat Anda tentukan, lihat referensi gcloud container clusters create.

Terraform

1. Pastikan Anda menggunakan penyedia google versi 4.84.0 atau yang lebih baru.
2. Tambahkan blok berikut ke konfigurasi Terraform:

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]

  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
  }
}

Ganti kode berikut:

• NODE_POOL_RESOURCE_NAME: Nama resource node pool di template Terraform.
• PROJECT_ID: Project ID Anda.
• CLUSTER_NAME: Nama cluster yang ada.
• POOL_NAME: Nama node pool yang akan dibuat.
• CLUSTER_LOCATION: Zona komputasi cluster. Tentukan region tempat versi TPU tersedia. Untuk mempelajari lebih lanjut, silakan membaca Memilih topologi dan versi TPU.
• NODE_ZONES: Daftar yang dipisahkan koma untuk satu atau beberapa zona tempat GKE membuat node pool.
• MACHINE_TYPE: Jenis mesin TPU yang akan digunakan. Untuk melihat jenis mesin yang kompatibel dengan TPU, gunakan tabel di Memilih versi TPU.

Secara opsional, Anda juga dapat menggunakan variabel berikut:

• autoscaling: Membuat node pool dengan penskalaan otomatis yang diaktifkan. Untuk slice TPU host tunggal, GKE melakukan penskalaan antara nilai TOTAL_MIN_NODES dan TOTAL_MAX_NODES.
  • TOTAL_MIN_NODES: Jumlah minimum semua node dalam node pool. Kolom ini bersifat opsional kecuali jika penskalaan otomatis juga ditentukan.
  • TOTAL_MAX_NODES: Jumlah maksimum semua node dalam node pool. Kolom ini bersifat opsional kecuali jika penskalaan otomatis juga ditentukan.
• RESERVATION_NAME: Jika Anda menggunakan pemesanan TPU, ini adalah daftar label resource pemesanan yang akan digunakan saat membuat node pool. Untuk mempelajari lebih lanjut cara mengisi RESERVATION_LABEL_VALUES di kolom reservation_affinity, silakan melihat Penyedia Terraform.
• spot: Menetapkan node pool agar menggunakan Spot VM untuk TPU node. Nama ini tidak dapat diubah setelah pembuatan node pool. Untuk mengetahui informasi selengkapnya, silakan membaca Spot VM.

Konsol

Untuk membuat node pool dengan TPU:

1. Buka halaman Google Kubernetes Engine di konsol Google Cloud.

   Buka Google Kubernetes Engine

2. Di daftar cluster, klik nama cluster yang ingin diubah.

3. Klik Add node pool.

4. Di bagian Node pool details, centang kotak Specify node locations.

5. Pilih zona berdasarkan versi TPU yang ingin Anda gunakan. Untuk mengidentifikasi zona yang tersedia, lihat Ketersediaan TPU di GKE.

6. Dari panel navigasi, klik Node.

7. Di bagian Konfigurasi Mesin, pilih TPU.

8. Di menu drop-down Seri, pilih salah satu opsi berikut:

   • CT3: TPU v3, perangkat host tunggal
   • CT3P: TPU v3, slice pod multi-host
   • CT4P: TPU v4
   • CT5LP: TPU v5e
   • CT5P: TPU v5p
   • CT6E: TPU v6e

9. Di menu drop-down Jenis mesin, pilih nama mesin yang akan digunakan untuk node. Gunakan tabel Memilih versi TPU untuk mempelajari cara menentukan jenis mesin dan topologi TPU yang membuat node pool slice TPU host tunggal.

10. Di menu drop-down Topologi TPU, pilih topologi fisik untuk slice TPU.

11. Dalam dialog Perubahan yang diperlukan, klik Buat perubahan.

12. Pastikan Jenis boot disk adalah Persistent disk standar atau Persistent disk SSD.

13. Secara opsional, pilih kotak centang Aktifkan node di Spot VM agar dapat menggunakan Spot VM untuk node di node pool.

14. Klik Buat.

Slice TPU multi-host

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

gcloud

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]

Ganti kode berikut:

• POOL_NAME: Nama node pool baru.
• LOCATION: Nama zona berdasarkan versi TPU yang ingin Anda gunakan. Untuk mengidentifikasi lokasi yang tersedia, lihat Ketersediaan TPU di GKE.
• CLUSTER_NAME: Nama cluster.
• NODE_ZONE: Daftar yang dipisahkan koma untuk satu atau beberapa zona tempat GKE membuat node pool.
• MACHINE_TYPE: Jenis mesin yang akan digunakan untuk node. Untuk mempelajari jenis mesin yang tersedia lebih lanjut, lihat Memilih versi TPU.

• TPU_TOPOLOGY: Topologi fisik untuk slice TPU. Format topologi bergantung pada versi TPU. Untuk mempelajari topologi TPU lebih lanjut, gunakan tabel di Memilih topologi.

  Untuk mempelajari lebih lanjut, lihat Topologi.

• NUM_NODES: Jumlah node di node pool. Nilainya harus nol atau hasil kali nilai yang ditentukan dalam TPU_TOPOLOGY ({A}x{B}x{C}) dibagi dengan jumlah chip di setiap VM. Untuk TPU v4 dan TPU v5e multi-host, jumlah chip di setiap VM adalah empat. Oleh karena itu, jika TPU_TOPOLOGY Anda adalah 2x4x4 (TPU v4 dengan empat chip di setiap VM), maka NUM_NODES adalah 32/4 yang sama dengan 8.

Secara opsional, Anda juga dapat menggunakan flag berikut:

• RESERVATION_NAME: Nama pemesanan yang digunakan GKE saat membuat node pool. Jika flag ini dihapus, GKE akan menggunakan node pool slice TPU yang tersedia. Untuk mempelajari pemesanan TPU lebih lanjut, silakan melihat Pemesanan TPU.
• --spot: Menetapkan node pool agar menggunakan Spot VM untuk node slice TPU. Nama ini tidak dapat diubah setelah pembuatan node pool. Untuk mengetahui informasi selengkapnya, silakan membaca Spot VM.
• --enable-autoscaling: Membuat node pool dengan penskalaan otomatis yang diaktifkan. Saat GKE menskalakan node pool slice TPU multi-host, GKE secara atomik akan meningkatkan skala node pool dari nol hingga ukuran maksimum.
  • MAX_NODES: Ukuran maksimum node pool. Flag --max-nodes diperlukan jika --enable-autoscaling disediakan dan harus sama dengan produk nilai yang ditentukan dalam TPU_TOPOLOGY ({A}x{B}x{C}) dibagi dengan jumlah chip di setiap VM.

Terraform

1. Pastikan Anda menggunakan penyedia google versi 4.84.0 atau yang lebih baru.

2. Tambahkan blok berikut ke konfigurasi Terraform:

   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 {
       max_node_count = 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
     }
   
     placement_policy {
       type = "COMPACT"
       tpu_topology = TPU_TOPOLOGY
     }
   }
   

   Ganti kode berikut:

   • NODE_POOL_RESOURCE_NAME: Nama resource node pool di template Terraform.
   • PROJECT_ID: Project ID Anda.
   • CLUSTER_NAME: Nama cluster yang ada tempat node pool akan ditambahkan.
   • POOL_NAME: Nama node pool yang akan dibuat.
   • CLUSTER_LOCATION: Lokasi komputasi untuk cluster. Sebaiknya Anda memiliki cluster regional untuk keandalan panel kontrol Kubernetes yang lebih tinggi. Anda juga dapat menggunakan cluster zonal. Untuk mempelajari lebih lanjut, silakan membaca Memilih topologi dan versi TPU.
   • NODE_ZONES: Daftar yang dipisahkan koma untuk satu atau beberapa zona tempat GKE membuat node pool.
   • NUM_NODES: Jumlah node dalam node pool. Nilainya harus nol atau hasil kali jumlah TPU chip yang dibagi empat, karena dalam slice TPU multi-host, setiap TPU node memiliki 4 chip. Misalnya, jika TPU_TOPOLOGY adalah 4x8, maka ada 32 chip, yang berarti harus ada 8 NUM_NODES. Untuk mempelajari topologi TPU lebih lanjut, gunakan tabel di Memilih versi TPU.
   • TPU_TOPOLOGY: Ini menunjukkan topologi fisik yang diinginkan untuk slice TPU. Format topologi bergantung pada versi TPU yang Anda gunakan. Untuk mempelajari topologi TPU lebih lanjut, gunakan tabel di Memilih topologi.

   Secara opsional, Anda juga dapat menggunakan variabel berikut:

   • RESERVATION_NAME: Jika Anda menggunakan pemesanan TPU, ini adalah daftar label resource pemesanan yang akan digunakan saat membuat node pool. Untuk mempelajari cara mengisi RESERVATION_LABEL_VALUES di kolom reservation_affinity lebih lanjut, silakan melihat Penyedia Terraform.
   • autoscaling: Membuat node pool dengan penskalaan otomatis yang diaktifkan. Saat GKE menskalakan node pool slice TPU multi-host, GKE secara atomik akan meningkatkan skala node pool dari nol hingga ukuran maksimum.
     • MAX_NODES: Ini adalah ukuran maksimum node pool. Nilai ini harus sama dengan hasil kali nilai yang ditentukan dalam TPU_TOPOLOGY ({A}x{B}x{C}) dibagi dengan jumlah chip di setiap VM.
   • spot: Memungkinkan node pool menggunakan Spot VM untuk node slice TPU. Nama ini tidak dapat diubah setelah pembuatan node pool. Untuk mengetahui informasi selengkapnya, silakan melihat Spot VM.

Konsol

Untuk membuat node pool dengan TPU:

1. Buka halaman Google Kubernetes Engine di konsol Google Cloud.

   Buka Google Kubernetes Engine

2. Di daftar cluster, klik nama cluster yang ingin diubah.

3. Klik Add node pool.

4. Di bagian Node pool details, centang kotak Specify node locations.

5. Pilih nama zona berdasarkan versi TPU yang ingin Anda gunakan. Untuk mengidentifikasi lokasi yang tersedia, lihat Ketersediaan TPU di GKE.

6. Dari panel navigasi, klik Node.

7. Di bagian Konfigurasi Mesin, pilih TPU.

8. Di menu drop-down Seri, pilih salah satu opsi berikut:

   • CT3P: Untuk TPU v3.
   • CT4P: Untuk TPU v4.
   • CT5LP: Untuk TPU v5e.

9. Di menu drop-down Jenis mesin, pilih nama mesin yang akan digunakan untuk node. Gunakan tabel Memilih versi TPU untuk mempelajari cara menentukan jenis mesin dan topologi TPU yang membuat node pool slice TPU multi-host.

10. Di menu drop-down Topologi TPU, pilih topologi fisik untuk slice TPU.

11. Dalam dialog Perubahan yang diperlukan, klik Buat perubahan.

12. Pastikan Jenis boot disk adalah Persistent disk standar atau Persistent disk SSD.

13. Secara opsional, pilih kotak centang Aktifkan node di Spot VM agar dapat menggunakan Spot VM untuk node di node pool.

14. Klik Create.

Status penyediaan

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

Jika Anda membuat node pool 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 node pool 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 tetap berada dalam antrean dalam waktu lama dan tetap dalam status "Penyediaan" saat berada dalam antrean.

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

Jika Anda memerlukan kapasitas lebih cepat, sebaiknya coba Spot VM, meskipun perlu diperhatikan bahwa Spot VM menggunakan kuota yang berbeda dari instance on-demand.

Anda dapat menghapus permintaan TPU yang diantrekan dengan menghapus node pool slice TPU.

Menjalankan workload Anda pada node slice TPU

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 v6e tpu-v6e-slice	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 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 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	jax[tpu] yang direkomendasikan: v0.4.4 atau yang lebih baru torchxla[tpuvm] yang direkomendasikan: v2.0.0 atau yang lebih baru
   TPU v3 tpu-v3-slice tpu-v3-device	jax[tpu] yang direkomendasikan: v0.4.4 atau yang lebih baru torchxla[tpuvm] yang direkomendasikan: 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 nama host VM TPU atau alamat IP 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 secara otomatis memasukkan variabel lingkungan ini menggunakan webhook yang berubah saat Tugas 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.

   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 cluster Ray yang meminta properti google.com/tpu dan pemilih node cloud.google.com/gke-tpu-topology multi-host.

   • 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
       

     Ganti kode berikut:

     • TPU_ACCELERATOR: Nama akselerator TPU.
     • TPU_TOPOLOGY: Topologi fisik untuk slice TPU. Format topologi bergantung pada versi TPU. Untuk mempelajari lebih lanjut, lihat Merencanakan TPU di GKE.

Setelah menyelesaikan persiapan workload, 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 slice

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

• Versi TPU: TPU v4
• Topologi: 2x2x4

Pilihan 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.
           securityContext:
             privileged: true
           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: 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 (slice TPU multi-host). Slice memiliki 16 chip TPU yang saling terhubung.

3. Pastikan bahwa 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 slice TPU

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

• Versi TPU: TPU v5e
• Topologi: 2x4

Pilihan versi dan topologi ini menghasilkan slice satu host.

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.
       securityContext:
         privileged: true
       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
   

Mengupgrade node pool menggunakan akselerator (GPU dan TPU)

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

Anda juga dapat mengonfigurasi strategi upgrade node untuk node pool, seperti upgrade lonjakan 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 untuk lingkungan Anda. Untuk node pool slice TPU multi-host, GKE akan membuat ulang seluruh node pool secara otomatis dalam satu langkah, bukan menggunakan strategi upgrade node yang dikonfigurasi. Untuk mempelajari lebih lanjut, lihat definisi atomicity di Terminologi yang terkait dengan TPU di GKE.

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

Pembersihan

Agar tidak menimbulkan biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam panduan ini, pertimbangkan untuk menghapus TPU slice 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. Menghapus node pool slice TPU:

   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 ke 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 node slice TPU

Jika TPU node dalam node pool slice TPU multi-host tidak responsif, seluruh node pool akan dibuat ulang. Sedangkan, dalam node pool slice TPU host tunggal, hanya node TPU yang tidak responsif yang diperbaiki secara otomatis.

Kondisi yang menyebabkan node slice TPU tidak responsif mencakup berikut ini:

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

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

Mengonfigurasi penghentian tuntas node slice TPU

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

Untuk mengonfigurasi GKE agar menghentikan workload Anda dengan baik dalam jangka waktu notifikasi ini, ikuti langkah-langkah di Mengelola gangguan node GKE untuk GPU dan TPU.

Menjalankan container tanpa mode dengan hak istimewa

Container yang berjalan di node pada GKE versi 1.28 atau yang lebih baru tidak perlu mengaktifkan mode hak istimewa untuk mengakses TPU. Node di GKE versi 1.28 dan yang lebih lama memerlukan mode dengan hak istimewa.

Jika node slice TPU Anda menjalankan versi yang lebih lama dari 1.28, baca bagian berikut:

Container yang berjalan di VM dalam slice TPU memerlukan akses ke batas yang lebih tinggi untuk memori terkunci sehingga driver dapat berkomunikasi dengan TPU chip melalui akses memori langsung (DMA). Untuk mengaktifkannya, 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
   

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

Kemampuan observasi dan metrik

Dasbor

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

Dasbor TPU hanya diisi jika Anda telah 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 penampung 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 dalam slice TPU mengekspor metrik penggunaan 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 pemakaian yang lebih baik.
• Pemakaian bandwidth memori: Persentase dari 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 terletak di skema node Kubernetes (k8s_node) dan penampung 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 node slice TPU baru sebelum node tersebut melaporkan TPU yang tersedia. Autoscaler cluster kemudian dapat melakukan peningkatan skala tambahan dan sebagai hasilnya membuat lebih banyak node daripada yang diperlukan. Autoscaler cluster memperkecil skala node tambahan, jika tidak diperlukan, setelah operasi pengecilan skala reguler.
• Autoscaler cluster membatalkan peningkatan skala TPU node pool slice yang masih dalam status menunggu selama lebih dari 10 jam. 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 node pool slice TPU.
• Metrik penggunaan bandwidth memori tidak tersedia untuk TPU v5e.

Langkah selanjutnya

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