Halaman ini diterjemahkan oleh Cloud Translation API.

Men-deploy workload TPU di GKE Standard

Standard

Halaman ini memberikan dasar untuk mempelajari cara mempercepat workload machine learning (ML) menggunakan TPU di Google Kubernetes Engine (GKE). TPU dirancang untuk pemrosesan perkalian matriks, seperti pelatihan model deep learning skala besar. TPU dioptimalkan untuk menangani set data yang sangat besar dan model ML yang kompleks, sehingga lebih hemat biaya dan hemat energi untuk beban kerja ML karena performanya yang unggul. Dalam panduan ini, Anda akan mempelajari cara men-deploy workload ML menggunakan akselerator Cloud TPU, mengonfigurasi kuota untuk TPU, mengonfigurasi upgrade untuk node pool yang menjalankan TPU, dan memantau metrik workload TPU.

Tutorial ini ditujukan untuk engineer Machine Learning (ML) serta admin dan operator Platform yang tertarik untuk menggunakan orkestrasi penampung Kubernetes guna mengelola workload pelatihan, penyesuaian, dan inferensi model berskala besar menggunakan TPU. Untuk mempelajari lebih lanjut peran umum dan contoh tugas yang dirujuk dalam Google Cloud konten, lihat Peran dan tugas pengguna GKE umum.

Sebelum membaca halaman ini, pastikan Anda memahami hal-hal berikut:

Sebelum memulai

Sebelum memulai, pastikan Anda telah melakukan tugas berikut:

Aktifkan Google Kubernetes Engine API.

Aktifkan Google Kubernetes Engine API

Jika ingin menggunakan Google Cloud CLI untuk tugas ini, instal lalu lakukan inisialisasi gcloud CLI. Jika sebelumnya Anda telah menginstal gcloud CLI, dapatkan versi terbaru dengan menjalankan perintah gcloud components update. gcloud CLI versi sebelumnya mungkin tidak mendukung menjalankan perintah dalam dokumen ini.
Catatan: Untuk penginstalan gcloud CLI yang ada, pastikan untuk menyetel properti compute/region. Jika Anda terutama menggunakan cluster zona, tetapkan compute/zone. Dengan menyetel lokasi default, Anda dapat menghindari error di gcloud CLI yang seperti ini: One of [--zone, --region] must be supplied: Please specify location. Anda mungkin perlu menentukan lokasi dalam perintah tertentu jika lokasi cluster Anda berbeda dengan lokasi default yang Anda tetapkan.

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 VM

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

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

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 kuota Compute Engine API Anda untuk TPU, ikuti langkah-langkah berikut:

Buka halaman Quotas di konsol Google Cloud :

Buka Quotas

Di kotak Filter , lakukan tindakan berikut:

Gunakan tabel berikut untuk memilih dan menyalin properti kuota berdasarkan versi TPU dan jenis mesin. Misalnya, jika Anda berencana membuat node TPU v5e sesuai permintaan yang jenis mesinnya diawali dengan ct5lp-, masukkan Name: TPU v5 Lite PodSlice chips.

Versi TPU, jenis mesin dimulai dengan	Properti dan nama kuota untuk instance on-demand	Properti dan nama kuota untuk instance Spot²
TPU v3, `ct3-`	Dimensions (e.g. location): tpu_family:CT3	Tidak berlaku
TPU v3, `ct3p-`	Dimensions (e.g. location): tpu_family:CT3P	Tidak berlaku
TPU v4, `ct4p-`	Name: TPU v4 PodSlice chips	Name: Preemptible TPU v4 PodSlice chips
TPU v5e, `ct5lp-`	Name: TPU v5 Lite PodSlice chips	Name: Preemptible TPU v5 Lite Podslice chips
TPU v5p, `ct5p-`	Name: TPU v5p chips	Name: Preemptible TPU v5p chips
TPU Trillium, `ct6e-`	Dimensions (e.g. location): tpu_family:CT6E	Name: Preemptible TPU slices v6e
Ironwood (TPU7x) (Pratinjau), `tpu7x-standard-4t`	Dimensions (e.g. location): tpu_family:tpu7x	Name: Preemptible TPU slices tpu7x

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

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

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

Saat membuat node pool slice TPU, gunakan flag --reservation dan --reservation-affinity=specific untuk membuat instance yang dicadangkan. Pemesanan TPU tersedia saat membeli komitmen. ↩
Saat membuat node pool slice TPU, gunakan flag --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 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.

Memastikan ketersediaan reservasi

Untuk membuat node pool slice TPU menggunakan reservasi, reservasi harus memiliki chip TPU yang tersedia dalam jumlah yang cukup pada saat pembuatan node pool.

Untuk melihat reservasi yang ada dalam project dan jumlah chip TPU dalam reservasi TPU yang tersedia, lihat daftar reservasi Anda.

Membuat cluster

Anda dapat membuat cluster yang menggunakan TPU dengan menggunakan Google Cloud CLI atau Accelerated Processing Kit (XPK).

Gunakan Google Cloud CLI untuk membuat instance cluster GKE secara manual guna melakukan penyesuaian atau perluasan yang tepat pada lingkungan GKE produksi yang ada.
Gunakan XPK untuk membuat cluster GKE dengan cepat dan menjalankan workload untuk bukti konsep dan pengujian. Untuk mengetahui informasi dan petunjuk selengkapnya, lihat README XPK.

Dokumen berikut menjelaskan cara mengonfigurasi TPU menggunakan Google Cloud CLI.

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

Praktik terbaik:

Gunakan cluster regional, yang memberikan ketersediaan tinggi untuk bidang kontrol Kubernetes.

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.

Menyediakan TPU

Untuk menyediakan TPU di GKE, Anda memiliki opsi konfigurasi berikut:

Membuat node pool secara manual: Anda dapat membuat node pool dengan versi dan topologi TPU tertentu.
Menggunakan penyediaan otomatis node GKE: Anda dapat mengaktifkan penyediaan otomatis node di tingkat cluster, lalu dalam manifes Pod, gunakan nodeSelector untuk menentukan versi dan topologi TPU. Saat Pod yang tertunda cocok dengan pemilih ini, GKE akan otomatis membuat node pool baru yang memenuhi permintaan. Metode ini mengharuskan Anda menetapkan batas resource tingkat cluster untuk TPU.
Tentukan ComputeClass kustom: Anda dapat meminta TPU menggunakan ComputeClass kustom. Custom ComputeClass memungkinkan administrator platform menentukan hierarki konfigurasi node agar diprioritaskan oleh GKE selama keputusan penskalaan node, sehingga workload berjalan di hardware yang Anda pilih.

Membuat node pool secara manual

Anda dapat membuat node pool slice TPU host tunggal atau multi-host.

Membuat node pool slice TPU host tunggal

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

gcloud

gcloud container node-pools create NODE_POOL_NAME \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --node-locations=NODE_ZONES \
    --machine-type=MACHINE_TYPE \
    [--sandbox=type=gvisor]

Ganti kode berikut:

NODE_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_ZONES: daftar yang dipisahkan koma untuk satu atau beberapa zona tempat GKE membuat node pool.
MACHINE_TYPE: versi dan jenis TPU. Misalnya, gunakan tpu7x-standard-4t untuk Ironwood (TPU7x).

Secara opsional, Anda juga dapat menggunakan flag berikut:

--num-nodes=NUM_NODES: Jumlah awal node dalam node pool di setiap zona.

Praktik terbaik:
Jika Anda menggunakan flag enable-autoscaling untuk node pool, tetapkan num-nodes ke 0 agar autoscaler menyediakan node tambahan segera setelah workload Anda membutuhkannya.
--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 Tentang pemesanan Cloud TPU.
--node-labels cloud.google.com/gke-workload-type=HIGH_AVAILABILITY: Memberi tahu GKE bahwa node pool slice TPU host tunggal adalah bagian dari koleksi. Gunakan tanda ini jika kondisi berikut berlaku:
- Node pool menjalankan workload inferensi di node pool baru.
- Node pool menggunakan TPU Trillium.
- Node pool tidak menggunakan Spot VM.
Untuk mempelajari lebih lanjut pengelolaan penjadwalan pengumpulan, lihat Mengelola penjadwalan pengumpulan di slice TPU host tunggal.
--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.
--flex-start: Menetapkan node pool agar menggunakan VM mulai fleksibel. VM mulai fleksibel dibuat menggunakan opsi konsumsi mulai fleksibel. Untuk mengetahui informasi selengkapnya, lihat Menjalankan workload batch kecil dengan TPU dan VM mulai fleksibel.

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

Terraform

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

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
    flex_start = false
  }
}

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 Pilih 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 Tentang pemesanan Cloud 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.
flex_start: Menetapkan node pool agar menggunakan opsi konsumsi flex-start. Tidak dapat disetel ke true jika spot diaktifkan. Mulai fleksibel didukung di GKE versi 1.33.0-gke.1712000 atau yang lebih baru.

Konsol

Untuk membuat node pool dengan TPU:

Buka halaman Google Kubernetes Engine di konsol Google Cloud .

Buka Google Kubernetes Engine
Di daftar cluster, klik nama cluster yang ingin diubah.
Klik Add node pool.
Di bagian Node pool details, centang kotak Specify node locations.
Pilih zona berdasarkan versi TPU yang ingin Anda gunakan. Untuk mengidentifikasi zona yang tersedia, lihat Ketersediaan TPU di GKE.
Dari panel navigasi, klik Node.
Di bagian Konfigurasi Mesin, pilih TPU.
Di menu drop-down Seri, pilih salah satu opsi berikut:
- CT3: TPU v3, perangkat host tunggal
- CT3P: Slice pod multi-host TPU v3
- CT4P: TPU v4
- CT5LP: TPU v5e
- CT5P: TPU v5p
- CT6E: TPU Trillium (v6e)
Di menu drop-down Jenis mesin, pilih nama mesin yang akan digunakan untuk node. Gunakan tabel Pilih versi TPU untuk mempelajari cara menentukan jenis mesin dan topologi TPU yang membuat TPU node pool host tunggal.
Di menu drop-down Topologi TPU, pilih topologi fisik untuk slice TPU.
Dalam dialog Perubahan yang diperlukan, klik Buat perubahan.
Pastikan Jenis boot disk adalah Persistent disk standar atau Persistent disk SSD.
Secara opsional, pilih kotak centang Aktifkan node di Spot VM agar dapat menggunakan Spot VM untuk node di node pool.
Klik Buat.

Membuat node pool slice TPU multi-host

Langkah-langkah untuk membuat node pool slice TPU multi-host berbeda-beda, bergantung pada apakah Anda menggunakan Ironwood (TPU7x) atau versi TPU yang lebih lama.

Ironwood (TPU7x)

Anda dapat membuat node pool slice TPU multi-host di versi Ironwood (TPU7x) menggunakan Google Cloud CLI atau Terraform:

gcloud

Untuk membuat node pool slice TPU multi-host dengan Ironwood (TPU7x), Anda harus membuat kebijakan workload terlebih dahulu.

Buat kebijakan beban kerja:
```
gcloud compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \
    --type=HIGH_THROUGHPUT \
    --accelerator-topology=TPU_TOPOLOGY \
    --project=PROJECT_ID \
    --region=REGION
```
Ganti kode berikut:
- WORKLOAD_POLICY_NAME: nama untuk kebijakan workload Anda.
- TPU_TOPOLOGY: topologi TPU Ironwood (TPU7x). Contoh, 2x2x2. Untuk melihat semua topologi Ironwood (TPU7x) yang didukung, lihat bagian topologi.
- PROJECT_ID: Google Cloud Project ID Anda.
- REGION: region untuk kebijakan workload. Kebijakan workload adalah resource regional dan dapat digunakan kembali di seluruh node pool yang memiliki topologi yang sama.
Buat node pool dengan kebijakan workload:
```
gcloud container node-pools create NODE_POOL_NAME \
  --cluster=CLUSTER_NAME \
  --machine-type=tpu7x-standard-4t \
  --placement-policy=WORKLOAD_POLICY_NAME \
  --location=CONTROL_PLANE_LOCATION \
  --node-locations=NODE_ZONE \
  --project=PROJECT_ID \
  --reservation=RESERVATION_NAME \
  --reservation-affinity=specific
```
Ganti kode berikut:
- NODE_POOL_NAME: nama untuk node pool baru.
- CLUSTER_NAME: nama cluster GKE Anda.
- WORKLOAD_POLICY_NAME: nama kebijakan workload yang Anda buat.
- CONTROL_PLANE_LOCATION: lokasi Compute Engine bidang kontrol cluster Anda. Berikan region untuk cluster regional, atau zona untuk cluster zona.
- NODE_ZONE: nama zona berdasarkan versi TPU yang ingin Anda gunakan. Untuk mengidentifikasi lokasi yang tersedia, lihat Ketersediaan TPU di GKE.
- PROJECT_ID: Google Cloud Project ID Anda.
- RESERVATION_NAME: nama reservasi yang akan digunakan.
Dalam perintah ini, flag --tpu-topology telah diganti dengan flag --placement-policy.

Terraform

Pastikan Anda menggunakan versi 4.84.0 atau yang lebih baru dari penyedia google.
Buat kebijakan beban kerja:
```
resource "google_compute_resource_policy" {
  name   = "WORKLOAD_POLICY_NAME"
  region = CLUSTER_LOCATION
  workload_policy {
    type = "HIGH_THROUGHPUT"
    accelerator_topology = "TPU_TOPOLOGY"
  }
}
```
Ganti kode berikut:
- WORKLOAD_POLICY_NAME: nama untuk kebijakan workload Anda.
- 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 mengetahui informasi selengkapnya, lihat Memilih topologi dan versi TPU.
- TPU_TOPOLOGY: topologi TPU Ironwood (TPU7x). Contoh, 2x2x2. Untuk melihat semua topologi Ironwood (TPU7x) yang didukung, lihat Merencanakan TPU.
Untuk mengetahui informasi selengkapnya tentang referensi google_compute_resource_policy, lihat Penyedia Terraform.
Dalam konfigurasi Terraform, tambahkan blok berikut:
```
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]
    }
    flex_start = false
    spot = true
  }

  placement_policy {
    policy_name = WORKLOAD_POLICY_NAME
  }
}
```
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.
- 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 node slice TPU memiliki empat chip. Misalnya, jika TPU_TOPOLOGY adalah 4x8, maka ada 32 chip, yang berarti NUM_NODES harus 8. Untuk mempelajari topologi TPU lebih lanjut, gunakan tabel di Memilih versi TPU.
- TPU_TOPOLOGY: ini menunjukkan topologi fisik yang dipilih untuk slice TPU. Format topologi bergantung pada versi TPU yang Anda gunakan. Untuk mempelajari lebih lanjut topologi TPU, gunakan tabel di Memilih topologi.
Secara opsional, Anda juga dapat menggunakan variabel berikut:
- RESERVATION_NAME: jika Anda menggunakan pemesanan TPU, berikan 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: ukuran maksimum node pool. Nilai harus sama dengan hasil perkalian nilai yang ditentukan dalam TPU_TOPOLOGY ({A}x{B}x{C}) dibagi dengan jumlah chip di setiap VM. Misalnya, jika TPU_TOPOLOGY adalah 2x2x2, produknya adalah 8. Karena setiap VM di tpu7x-standard-4t memiliki 4 chip, jumlah node adalah 2.
- spot: node pool yang akan menggunakan Spot VM untuk node slice TPU. Setelan ini tidak dapat diubah setelah node pool dibuat. Untuk mengetahui informasi selengkapnya, silakan melihat Spot VM.
- flex_start: node pool yang akan menggunakan opsi konsumsi flex-start. Setelan ini tidak dapat disetel ke true jika spot diaktifkan.

Versi TPU lainnya

Anda dapat membuat node pool slice TPU multi-host di versi v3, v4, v5p, v5e, dan Trillium (v6e) menggunakan Google Cloud CLI, Terraform, atau konsol Google Cloud .

gcloud

  gcloud container node-pools create POOL_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --cluster=CLUSTER_NAME \
      --node-locations=NODE_ZONE \
      --machine-type=MACHINE_TYPE \
      --tpu-topology=TPU_TOPOLOGY \
      [--num-nodes=NUM_NODES] \
      [--spot \]
      [--flex-start \]
      [--enable-autoscaling \
        --max-nodes MAX_NODES]
      [--reservation-affinity=specific \
      --reservation=RESERVATION_NAME] \
      [--node-labels cloud.google.com/gke-nodepool-group-name=COLLECTION_NAME,cloud.google.com/gke-workload-type=HIGH_AVAILABILITY]
      [--placement-type=COMPACT]

Ganti kode berikut:

POOL_NAME: nama node pool baru.
CONTROL_PLANE_LOCATION: lokasi Compute Engine untuk bidang kontrol cluster Anda. Berikan region untuk cluster regional, atau zona untuk cluster zona.
CLUSTER_NAME: nama cluster.
NODE_ZONES: nama zona berdasarkan versi TPU yang ingin Anda gunakan. Untuk mengidentifikasi lokasi yang tersedia, lihat Ketersediaan TPU di GKE.
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 mengetahui informasi selengkapnya tentang topologi TPU, gunakan tabel di Memilih topologi.

Untuk mengetahui informasi selengkapnya, lihat Topologi.

Secara opsional, Anda juga dapat menggunakan flag berikut:
NUM_NODES: jumlah node dalam 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. Jika Anda menghapus tanda ini, jumlah node akan dihitung dan ditetapkan secara default berdasarkan topologi dan jenis mesin.
RESERVATION_NAME: nama reservasi yang digunakan GKE saat membuat node pool. Jika Anda menghapus flag ini, GKE akan menggunakan node pool slice TPU yang tersedia. Untuk mengetahui informasi selengkapnya tentang pemesanan TPU, lihat 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.
--flex-start: menetapkan node pool agar menggunakan VM mulai fleksibel. VM mulai fleksibel dibuat menggunakan opsi konsumsi flex-start, yang didukung di GKE versi 1.33.0-gke.1712000 atau yang lebih baru.
--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 diberikan dan harus sama dengan hasil perkalian nilai yang ditentukan dalam TPU_TOPOLOGY ({A}x{B}x{C}) dibagi dengan jumlah chip di setiap VM.
--node-label=cloud.google.com/gke-nodepool-group-name=COLLECTION_NAME, cloud.google.com/gke-workload-type=HIGH_AVAILABILITY: Memberi tahu GKE bahwa node pool slice TPU multi-host adalah kumpulan. Gunakan tanda ini jika kondisi berikut berlaku:
- Node pool menjalankan workload inferensi.
- Node pool menggunakan TPU Trillium.
- Spot VM tidak mendukung penjadwalan pengumpulan.
Untuk mengetahui informasi selengkapnya tentang pengelolaan penjadwalan pengumpulan, lihat Mengelola penjadwalan pengumpulan di slice TPU multi-host.
--placement-type=COMPACT: Membuat node pool dengan penempatan rapat yang diaktifkan. Opsi ini harus digunakan dengan tanda --tpu-topology. Untuk mengetahui informasi selengkapnya, lihat Membuat kebijakan penempatan yang ringkas dan Topologi TPU.

Terraform

Pastikan Anda menggunakan versi 4.84.0 atau yang lebih baru dari penyedia google.
Tambahkan blok berikut ke konfigurasi Terraform Anda:
```
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]
    }
    flex_start = false
    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 node slice TPU 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 untuk slice TPU. Format topologi bergantung pada versi TPU yang Anda gunakan. Untuk mempelajari lebih lanjut topologi TPU, 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. Nilainya 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.
- flex_start: Menetapkan node pool agar menggunakan opsi konsumsi flex-start. Tidak dapat disetel ke true jika spot diaktifkan.

Konsol

Untuk membuat node pool dengan TPU:

Buka halaman Google Kubernetes Engine di konsol Google Cloud .

Buka Google Kubernetes Engine
Di daftar cluster, klik nama cluster yang ingin diubah.
Klik Add node pool.
Di bagian Node pool details, centang kotak Specify node locations.
Pilih nama zona berdasarkan versi TPU yang ingin Anda gunakan. Untuk mengidentifikasi lokasi yang tersedia, lihat Ketersediaan TPU di GKE.
Dari panel navigasi, klik Node.
Di bagian Konfigurasi Mesin, pilih TPU.
Di menu drop-down Seri, pilih salah satu opsi berikut:
- CT3: Perangkat TPU v3, host tunggal
- CT3P: Slice pod multi-host TPU v3
- CT4P: TPU v4
- CT5LP: TPU v5e
- CT5P: TPU v5p
- CT6E: TPU Trillium (v6e)
Di menu drop-down Jenis mesin, pilih nama mesin yang akan digunakan untuk node. Gunakan tabel Pilih versi TPU untuk mempelajari cara menentukan jenis mesin dan topologi TPU yang membuat TPU slice node pool multi-host.
Di menu drop-down Topologi TPU, pilih topologi fisik untuk slice TPU.
Dalam dialog Perubahan yang diperlukan, klik Buat perubahan.
Pastikan Jenis boot disk adalah Persistent disk standar atau Persistent disk SSD.
Secara opsional, pilih kotak centang Aktifkan node di Spot VM agar dapat menggunakan Spot VM untuk node di node pool.
Klik Buat.

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 mengaktifkan penyediaan otomatis node pool, edit batas resource TPU cluster Anda:
```
  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --enable-autoprovisioning \
      --min-cpu=MINIMUM_CPU \
      --min-memory=MINIMUM_MEMORY \
      --max-cpu=MAXIMUM_CPU \
      --max-memory=MAXIMUM_MEMORY \
      --min-accelerator=type=TPU_TYPE,count=MINIMUM_TPU_COUNT \
      --max-accelerator=type=TPU_TYPE,count=MAXIMUM_TPU_COUNT
```
Ganti kode berikut:
- TPU_TYPE: jenis TPU. Misalnya, gunakan tpu7x-standard-4t untuk Ironwood (TPU7x).
- MINIMUM_TPU_COUNT: jumlah minimum chip TPU dari jenis yang ditentukan yang dapat dimiliki cluster. Jika nilai yang Anda tentukan lebih besar daripada jumlah chip TPU dalam slice TPU multi-host, GKE akan menghapus semua node dalam slice. Kumpulan node multi-host menskalakan antara 0 dan jumlah node dalam slice, tanpa nilai perantara.
- MAXIMUM_TPU_COUNT: jumlah maksimum chip TPU dari jenis yang ditentukan yang dapat dimiliki cluster. Untuk slice TPU multi-host, tentukan nilai yang lebih besar dari jumlah chip di setiap slice sehingga GKE dapat menskalakan slice secara atomik. Jumlah chip dalam slice adalah hasil kali topologi TPU. Misalnya, jika topologinya adalah 2x2x2, jumlah chip dalam slice adalah 8, yang berarti nilai MAXIMUM_TPU_COUNT harus lebih besar dari 8.

Menentukan ComputeClass kustom

Anda juga dapat mengonfigurasi GKE untuk meminta TPU selama operasi penskalaan yang membuat node baru menggunakan ComputeClass kustom.

Anda dapat menentukan opsi konfigurasi TPU dalam spesifikasi ComputeClass kustom. Saat workload GKE menggunakan ComputeClass kustom tersebut, GKE akan mencoba menyediakan TPU yang menggunakan konfigurasi yang Anda tentukan saat melakukan penskalaan.

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

Membuat ComputeClass kustom

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

Ironwood (TPU7x)

Buat kebijakan beban kerja. Langkah ini hanya diperlukan jika Anda membuat node pool multi-host, yang bergantung pada topologi yang Anda pilih. Jika Anda menggunakan node pool host tunggal, lewati langkah ini.
```
gcloud compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \
    --type=HIGH_THROUGHPUT \
    --accelerator-topology=TPU_TOPOLOGY \
    --project=PROJECT_ID \
    --region=REGION
```
Ganti kode berikut:
- WORKLOAD_POLICY_NAME: nama untuk kebijakan workload Anda.
- TPU_TOPOLOGY: topologi TPU Ironwood (TPU7x). Misalnya, gunakan 2x2x2. Untuk mengetahui informasi selengkapnya tentang semua topologi Ironwood (TPU7x) yang didukung, lihat bagian topologi.
- PROJECT_ID: Project ID Google Cloud Anda.
- REGION: Region untuk kebijakan workload. Kebijakan workload adalah resource regional dan Anda dapat menggunakannya di seluruh node pool.

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

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

(Opsional) Anda dapat menggunakan reservasi atau sub-blok tertentu. Misalnya, Anda dapat menambahkan specs berikut ke manifes ComputeClass:
```
  reservations:
    affinity: Specific
    specific:
      - name: RESERVATION_NAME
        reservationBlock:
          name: RESERVATION_BLOCK_NAME
          reservationSubBlock:
            name: RESERVATION_SUB_BLOCK_NAME
```
Ganti kode berikut:
- RESERVATION_NAME: nama reservasi kapasitas Compute Engine.
- RESERVATION_BLOCK_NAME: nama blok reservasi kapasitas Compute Engine.
- RESERVATION_SUB_BLOCK_NAME: nama sub-blok reservasi kapasitas Compute Engine.
Untuk mengetahui informasi selengkapnya, lihat Menggunakan resource zona yang dicadangkan.

Versi TPU lainnya

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

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

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

Ganti kode berikut:

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

Deploy ComputeClass:
```
kubectl apply -f tpu-compute-class.yaml
```
Untuk mengetahui informasi selengkapnya tentang ComputeClass kustom dan TPU, lihat Konfigurasi TPU.

Membuat Tugas yang menggunakan TPU

Simpan manifes berikut sebagai tpu-job.yaml:

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

Ganti kode berikut:

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

Deploy Job:
```
kubectl create -f tpu-job.yaml
```
Saat Anda membuat Tugas ini, GKE akan otomatis melakukan hal berikut:
- Menyediakan node untuk menjalankan Pod. Bergantung pada jenis TPU, topologi, dan permintaan resource yang Anda tentukan, node ini berupa slice host tunggal atau slice multi-host. Bergantung pada ketersediaan resource TPU dalam prioritas teratas, GKE mungkin beralih ke prioritas yang lebih rendah untuk memaksimalkan ketersediaan.
- Menambahkan taint ke Pod dan toleransi ke node untuk mencegah workload lain Anda berjalan di node yang sama dengan workload TPU.
Untuk mempelajari lebih lanjut, lihat artikel Tentang ComputeClass kustom.
Setelah menyelesaikan bagian ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat:
```
kubectl delete -f tpu-job.yaml
```

Menyiapkan workload Anda

Workload TPU memiliki persyaratan persiapan berikut.

Framework seperti JAX, PyTorch, dan TensorFlow mengakses VM TPU menggunakan library bersama libtpu. libtpu mencakup compiler XLA, software runtime TPU, dan driver TPU. Setiap rilis PyTorch dan JAX memerlukan versi libtpu.so tertentu. Untuk menghindari konflik versi paket, sebaiknya gunakan image AI JAX. Untuk menggunakan TPU di GKE, pastikan Anda menggunakan versi berikut: tpu7x

Jenis TPU	`libtpu.so` versi
Ironwood (TPU7x) (Pratinjau)	Gambar AI JAX yang direkomendasikan: jax0.8.1-rev1 atau yang lebih baru Versi jax[tpu] yang direkomendasikan: v0.8.1
TPU Trillium (v6e) `tpu-v6e-slice`	Image AI JAX yang direkomendasikan: jax0.4.35-rev1 atau yang lebih baru 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`	Image AI JAX yang direkomendasikan: jax0.4.35-rev1 atau yang lebih baru 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`	Image AI JAX yang direkomendasikan: jax0.4.35-rev1 atau yang lebih baru 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`	Image AI JAX yang direkomendasikan: jax0.4.35-rev1 atau yang lebih baru 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`	Image AI JAX yang direkomendasikan: jax0.4.35-rev1 atau yang lebih baru jax[tpu] yang direkomendasikan: v0.4.4 atau yang lebih baru torchxla[tpuvm] yang direkomendasikan: v2.0.0 atau yang lebih baru

Dalam manifes workload, tambahkan pemilih node Kubernetes untuk memastikan GKE menjadwalkan workload TPU Anda pada jenis mesin TPU dan topologi TPU yang Anda tentukan:
```
  nodeSelector:
    cloud.google.com/gke-tpu-accelerator: TPU_ACCELERATOR
    cloud.google.com/gke-tpu-topology: TPU_TOPOLOGY
    cloud.google.com/placement-policy-name: WORKLOAD_POLICY # Required only for Ironwood (TPU7x)
  
```
Ganti kode berikut:
- TPU_ACCELERATOR: nama akselerator TPU. Misalnya, gunakan tpu7x-standard-4t.
- TPU_TOPOLOGY: topologi fisik untuk slice TPU. Format topologi bergantung pada versi TPU. Misalnya, gunakan 2x2x2. Untuk mempelajari lebih lanjut, lihat Merencanakan TPU di GKE.
- WORKLOAD_POLICY: nama kebijakan beban kerja yang ingin Anda gunakan untuk menempatkan Pod TPU. Pemilih node ini hanya diperlukan untuk Ironwood (TPU7x).

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

Bagian berikut menunjukkan contoh cara menjalankan Job yang melakukan komputasi dasar dengan TPU.

Menjalankan workload Anda pada node slice TPU

Bagian ini menjelaskan cara menyiapkan workload dan contoh cara menjalankan workload.

Contoh 1: Menjalankan Deployment yang meminta TPU dalam spesifikasi Pod

GKE menggunakan konfigurasi di Pod atau ComputeClass Anda untuk menentukan konfigurasi node TPU Anda. Manifes berikut adalah contoh spesifikasi Deployment yang meminta TPU dalam spesifikasi Pod. Jika setelan penyediaan otomatis node tingkat cluster diaktifkan, Deployment ini akan memicu pembuatan otomatis node pool. Saat Anda membuat Deployment contoh ini, GKE akan membuat node pool yang berisi slice TPU v4 dengan topologi 2x2x2 dan dua mesin ct4p-hightpu-4t.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tpu-workload
  labels:
    app: tpu-workload
spec:
  replicas: 2
  template:
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-accelerator: tpu-v4-podslice
        cloud.google.com/gke-tpu-topology: 2x2x2
      containers:
      - name: tpu-job
        image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
        ports:
        - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
        securityContext:
          privileged: true # Required for GKE versions earlier than 1.28 to access TPUs.
        command:
        - bash
        - -c
        - |
          python -c 'import jax; print("Total TPU chips:", jax.device_count())'
        resources:
          requests:
            google.com/tpu: 4
          limits:
            google.com/tpu: 4
        ports:
        - containerPort: 80

Dalam manifes ini, kolom berikut menentukan konfigurasi TPU:

cloud.google.com/gke-tpu-accelerator: versi dan jenis TPU. Misalnya, gunakan tpu7x-standard-4t untuk Ironwood (TPU7x).
cloud.google.com/gke-tpu-topology: topologi dengan jumlah dan pengaturan fisik TPU chip dalam slice TPU. Misalnya, gunakan 2x2x2.
limits.google.com/tpu: jumlah chip TPU per VM. Misalnya, jika Anda menggunakan tpu7x-standard-4t, jumlah chip TPU per VM adalah 4.

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

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.

Simpan manifes berikut sebagai available-chips-multihost.yaml:

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

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.

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

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

Opsional: Hapus workload:

kubectl delete -f available-chips-multihost.yaml

Contoh 3: 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 host tunggal, workload memiliki parameter berikut:

Versi TPU: TPU v5e
Topologi: 2x4

Pemilihan versi dan topologi ini menghasilkan slice host tunggal.

Simpan manifes berikut sebagai available-chips-singlehost.yaml:

apiVersion: v1
kind: Pod
metadata:
  name: tpu-job-jax-v5
spec:
  restartPolicy: Never
  nodeSelector:
    cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice # Node selector to target TPU v5e slice nodes.
    cloud.google.com/gke-tpu-topology: 2x4 # Specify the physical topology for the TPU slice.
  containers:
  - name: tpu-job
    image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
    ports:
    - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
    securityContext:
      privileged: true # Required for GKE versions earlier than 1.28 to access TPUs.
    command:
    - bash
    - -c
    - |
      python -c 'import jax; print("Total TPU chips:", jax.device_count())'
    resources:
      requests:
        google.com/tpu: 8 # Request 8 TPU chips for this container.
      limits:
        google.com/tpu: 8 # Limit to 8 TPU chips for this container.

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).
Dapatkan log Pod:
```
kubectl logs tpu-job-jax-v5
```
Outputnya mirip dengan hal berikut ini:
```
Total TPU chips: 8
```

Opsional: Hapus workload:

  kubectl delete -f available-chips-singlehost.yaml

Mengupgrade node pool menggunakan akselerator (GPU dan TPU)

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

Anda juga dapat mengonfigurasi strategi upgrade node untuk node pool, seperti upgrade lonjakan, upgrade biru-hijau, atau upgrade singkat. 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, alih-alih menggunakan strategi upgrade node yang dikonfigurasi, GKE akan membuat ulang seluruh node pool secara atomik dalam satu langkah. Untuk mempelajari lebih lanjut, lihat definisi atomisitas dalam Terminologi terkait 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 dengan 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.

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.

Mengonfigurasi setelan tambahan

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

Menggunakan Multislice

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.

Aktifkan 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.

Mengonfigurasi perbaikan otomatis untuk node slice TPU

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

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

Semua node slice TPU dengan kondisi node umum.
Semua node slice TPU dengan jumlah TPU yang tidak dapat dialokasikan yang lebih besar dari nol.
Semua instance VM dalam slice TPU yang dihentikan (karena preemption) atau diakhiri.
Pemeliharaan node: Jika ada node slice TPU 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 mencukupi, hubungiGoogle Cloud perwakilan akun Anda untuk meningkatkan kuota yang sesuai.

Mengonfigurasi penghentian tuntas untuk 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 penonaktifan yang akan segera terjadi dapat dikonfigurasi hingga lima menit di node TPU.

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

Menjalankan container tanpa mode 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 hak istimewa.

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

Container yang berjalan pada VM dalam slice TPU memerlukan akses ke batas yang lebih tinggi untuk memori terkunci sehingga driver dapat berkomunikasi dengan chip TPU 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:

Edit securityContext untuk menyertakan kolom berikut:

securityContext:
  capabilities:
    add: ["SYS_RESOURCE"]

Tingkatkan ulimit dengan menjalankan perintah berikut di dalam container sebelum menyiapkan workload Anda untuk menggunakan TPU resource:
```
ulimit -l 68719476736
```

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

Kemampuan observasi dan metrik

Dasbor

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

Buka Status Kumpulan Node TPU GKE

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

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

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

Metrik runtime

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

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

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

Container Kubernetes:

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

Node Kubernetes:

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

Memantau metrik kesehatan untuk node dan node pool TPU

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

Status node

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

kubernetes.io/node/status_condition

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

Kueri PromQL ini menunjukkan apakah node tertentu Ready:

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

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

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

Anda mungkin ingin melihat secara khusus node yang tidak Ready:

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

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

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

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

Status node pool

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

kubernetes.io/node_pool/status

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

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

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

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

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

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

Ketersediaan node pool

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

kubernetes.io/node_pool/multi_host/available

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

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

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

Jumlah gangguan node

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

kubernetes.io/node/interruption_count

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

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

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

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

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

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

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

Waktu pemulihan (TTR) kumpulan node

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

kubernetes.io/node_pool/accelerator/times_to_recover

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

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

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

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

Waktu antara gangguan (TBI) kumpulan node

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

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

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

Metrik host

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

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

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

Container Kubernetes:

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

Node Kubernetes:

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

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

Mengelola penjadwalan pengumpulan

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

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

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

Untuk mengelola koleksi, lakukan salah satu tindakan berikut berdasarkan jenis kumpulan node yang Anda gunakan.

Mengelola penjadwalan pengumpulan di node pool slice TPU multi-host

Gunakan tugas berikut untuk mengelola node pool slice TPU multi-host.

Untuk memeriksa apakah kumpulan slice TPU multi-host adalah bagian dari koleksi, jalankan perintah berikut:

gcloud container node-pools describe NODE_POOL_NAME \
    --location LOCATION \
    --cluster CLUSTER_NAME \
    --format="json" | jq -r \
    '"nodepool-group-name: \(.config.labels["cloud.google.com/gke-nodepool-group-name"] // "")\ngke-workload-type: \(.config.labels["cloud.google.com/gke-workload-type"] // "")"'

Outputnya mirip dengan hal berikut ini:

nodepool-group-name: <code><var>NODE_POOL_COLLECTION_NAME</var></code>
gke-workload-type: HIGH_AVAILABILITY

Jika pool slice TPU multi-host adalah bagian dari koleksi, output akan memiliki label berikut:

cloud.google.com/gke-workload-type: HIGH_AVAILABILITY
cloud.google.com/gke-nodepool-group-name: <code><var>COLLECTION_NAME</var></code>

Untuk mendapatkan daftar koleksi di cluster, jalankan perintah berikut:

#!/bin/bash

# Replace with your cluster name, project, and location
CLUSTER_NAME=CLUSTER_NAME
PROJECT=PROJECT_ID
LOCATION=LOCATION

declare -A collection_names

node_pools=$(gcloud container node-pools list --cluster "$CLUSTER_NAME" --project "$PROJECT" --location "$LOCATION" --format="value(name)")

# Iterate over each node pool
for pool in $node_pools; do
    # Describe the node pool and extract labels using jq
    collection_name=$(gcloud container node-pools describe "$pool" \
        --cluster "$CLUSTER_NAME" \
        --project "$PROJECT" \
        --location "$LOCATION" \
        --format="json" | jq -r '.config.labels["cloud.google.com/gke-nodepool-group-name"]')

    # Add the collection name to the associative array if it's not empty
    if [[ -n "$collection_name" ]]; then
        collection_names["$collection_name"]=1
    fi
done

# Print the unique node pool collection names
echo "Unique cloud.google.com/gke-nodepool-group-name values:"
for name in "${!collection_names[@]}"; do
    echo "$name"
done

Outputnya mirip dengan hal berikut ini:

Unique cloud.google.com/gke-nodepool-group-name values: {COLLECTION_NAME_1}, {COLLECTION_NAME_2}, {COLLECTION_NAME_3}

Untuk mendapatkan daftar node pool yang termasuk dalam koleksi, jalankan perintah berikut:

#!/bin/bash

TARGET_COLLECTION_NAME=COLLECTION_NAME
CLUSTER_NAME=CLUSTER_NAME
PROJECT=PROJECT_ID
LOCATION=LOCATION

matching_node_pools=()

# Get the list of all node pools in the cluster
node_pools=$(gcloud container node-pools list --cluster "$CLUSTER_NAME" --project "$PROJECT" --location "$LOCATION" --format="value(name)")

# Iterate over each node pool
for pool in $node_pools; do
    # Get the value of the cloud.google.com/gke-nodepool-group-name label
    collection_name=$(gcloud container node-pools describe "$pool" \
        --cluster "$CLUSTER_NAME" \
        --project "$PROJECT" \
        --location "$LOCATION" \
        --format="json" | jq -r '.config.labels["cloud.google.com/gke-nodepool-group-name"]')

    # Check if the group name matches the target value
    if [[ "$collection_name" == "$TARGET_COLLECTION_NAME" ]]; then
        matching_node_pools+=("$pool")
    fi
done

# Print the list of matching node pools
echo "Node pools with collection name '$TARGET_COLLECTION_NAME':"
for pool in "${matching_node_pools[@]}"; do
    echo "$pool"
done

Outputnya mirip dengan hal berikut ini:

Node pools with collection name 'COLLECTION_NAME':
{NODE_POOL_NAME_1}
{NODE_POOL_NAME_2}
{NODE_POOL_NAME_3}

Untuk meningkatkan skala koleksi, buat node pool slice TPU multi-host lain dan tambahkan cloud.google.com/gke-workload-type dan cloud.google.com/gke-nodepool-group-name. Gunakan nama koleksi yang sama di cloud.google.com/gke-nodepool-group-name dan jalankan jenis beban kerja yang sama. Jika penyediaan otomatis node diaktifkan di cluster, GKE akan otomatis membuat pool berdasarkan permintaan workload.
Untuk menskalakan koleksi, hapus node pool.
Untuk menghapus koleksi, hapus semua node pool yang terlampir. Anda dapat menghapus node pool atau menghapus cluster. Menghapus cluster akan menghapus semua koleksi di dalamnya.

Mengelola penjadwalan pengumpulan dalam node pool slice TPU host tunggal

Gunakan tugas berikut untuk mengelola node pool slice TPU host tunggal.

Untuk memeriksa apakah penjadwalan pengumpulan diaktifkan pada kumpulan slice TPU host tunggal, jalankan perintah berikut:
```
gcloud container node-pools describe NODE_POOL_NAME \
    --cluster CLUSTER_NAME \
    --project PROJECT_NAME \
    --location LOCATION \
    --format="json" | jq -r '.config.labels["cloud.google.com/gke-workload-type"]'
```
Outputnya mirip dengan hal berikut ini:
```
gke-workload-type: HIGH_AVAILABILITY
```
Jika pool slice TPU host tunggal adalah bagian dari koleksi, output akan memiliki label cloud.google.com/gke-workload-type: HIGH_AVAILABILITY.
Untuk menskalakan koleksi, ubah ukuran node pool secara manual atau otomatis dengan penyediaan otomatis node.
Untuk menskalakan koleksi, hapus node pool.
Untuk menghapus koleksi, hapus semua kumpulan node yang terlampir. Anda dapat menghapus node pool atau menghapus cluster. Menghapus cluster akan menghapus semua koleksi di dalamnya.

Masalah umum

Autoscaler cluster mungkin salah menghitung kapasitas untuk node slice TPU baru sebelum node tersebut melaporkan TPU yang tersedia. Kemudian, autoscaler cluster dapat melakukan penskalaan 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 slice node pool yang masih dalam status menunggu selama lebih dari 10 jam. Cluster Autoscaler akan mencoba kembali operasi penskalaan naik 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 pemakaian bandwidth memori tidak tersedia untuk TPU v5e.

Men-deploy workload TPU di GKE Standard Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Sebelum memulai

Merencanakan konfigurasi TPU

Pastikan Anda memiliki kuota TPU

Kuota untuk VM on-demand atau Spot VM

Kuota untuk resource GKE tambahan

Memastikan ketersediaan reservasi

Membuat cluster

Menyediakan TPU

Membuat node pool secara manual

Membuat node pool slice TPU host tunggal

gcloud

Terraform

Konsol

Membuat node pool slice TPU multi-host

Ironwood (TPU7x)

gcloud

Terraform

Versi TPU lainnya

gcloud

Terraform

Konsol

Menggunakan penyediaan otomatis node GKE

Menentukan ComputeClass kustom

Membuat ComputeClass kustom

Ironwood (TPU7x)

Versi TPU lainnya

Membuat Tugas yang menggunakan TPU

Menyiapkan workload Anda

Menjalankan workload Anda pada node slice TPU

Contoh 1: Menjalankan Deployment yang meminta TPU dalam spesifikasi Pod

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

Contoh 3: Menjalankan workload yang menampilkan jumlah TPU chip yang tersedia di slice TPU

Mengupgrade node pool menggunakan akselerator (GPU dan TPU)

Pembersihan

Mengonfigurasi setelan tambahan

Menggunakan Multislice

Memigrasikan pemesanan TPU

Aktifkan logging

Mengonfigurasi perbaikan otomatis untuk node slice TPU

Mengonfigurasi penghentian tuntas untuk node slice TPU

Menjalankan container tanpa mode hak istimewa

Kemampuan observasi dan metrik

Dasbor

Metrik runtime

Memantau metrik kesehatan untuk node dan node pool TPU

Status node

Status node pool

Ketersediaan node pool

Jumlah gangguan node

Waktu pemulihan (TTR) kumpulan node

Waktu antara gangguan (TBI) kumpulan node

Metrik host

Mengelola penjadwalan pengumpulan

Mengelola penjadwalan pengumpulan di node pool slice TPU multi-host

Mengelola penjadwalan pengumpulan dalam node pool slice TPU host tunggal

Masalah umum

Langkah berikutnya

Men-deploy workload TPU di GKE Standard