Men-deploy workload TPU di GKE Standard

Dokumen 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 berskala besar. TPU dioptimalkan untuk menangani set data yang sangat besar dan model ML yang kompleks, sehingga lebih hemat biaya dan hemat energi untuk workload 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 menggunakan orkestrasi container Kubernetes untuk mengelola workload pelatihan, penyesuaian, dan inferensi model berskala besar menggunakan TPU. Untuk mempelajari lebih lanjut peran umum dan contoh tugas yang dirujuk dalam konten Google Cloud , 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
  • Untuk 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. Versi gcloud CLI yang lebih lama mungkin tidak mendukung menjalankan perintah dalam dokumen ini.

Merencanakan konfigurasi TPU

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

Memastikan 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 Spot atau on-demand, Anda harus memiliki kuota TPU yang memadai di region yang ingin Anda gunakan.

Membuat node pool slice TPU yang menggunakan pemesanan TPU tidak memerlukan kuota TPU.1 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 dari kuota Compute Engine API untuk TPU, ikuti langkah-langkah berikut:

  1. Buka halaman Quotas di konsol Google Cloud :

    Buka Quotas

  2. Dalam kotak Filter , lakukan hal berikut:

    1. Gunakan tabel berikut untuk memilih dan menyalin properti kuota berdasarkan versi TPU dan jenis mesin. Misalnya, jika Anda berencana membuat node TPU v5e on-demand yang jenis mesinnya dimulai 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 Spot2
      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),
      tpu7x-standard-4t
      Dimensions (e.g. location):
      tpu_family:tpu7x
      Name:
      Preemptible TPU slices tpu7x
    2. 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 tersebut belum diberi kuota yang ditentukan untuk region yang Anda perlukan, dan Anda harus meminta penyesuaian kuota TPU.

Saat pemesanan TPU dibuat, nilai batas dan penggunaan saat ini untuk kuota yang sesuai akan meningkat sebesar jumlah chip dalam pemesanan TPU. Misalnya, saat pemesanan dibuat untuk 16 chip TPU v5e yang jenis mesinnya diawali dengan ct5lp- , Limit dan Current usage untuk kuota TPU v5 Lite PodSlice chips di region yang relevan akan meningkat sebesar 16.

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

  2. 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 hasil perkalian 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 32 memerlukan 64 alamat IP yang berarti subnet /26 per node. Perhatikan bahwa rentang ini tidak boleh digunakan bersama dengan cluster lain. Untuk menghindari kehabisan rentang alamat IP, gunakan flag --max-pods-per-node untuk membatasi jumlah pod yang diizinkan untuk dijadwalkan pada sebuah 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 pemesanan

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

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

Membuat cluster

gcloud

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

Praktik terbaik:

Gunakan cluster regional, yang memberikan bidang 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 menurut jenis mesin TPU, lihat Ketersediaan TPU di GKE.

Cluster Toolkit

  1. Siapkan Cluster Toolkit.
  2. Deploy cluster TPU GKE menggunakan blueprint Cluster Toolkit (seperti gke-tpu-v6e atau gke-tpu-7x; untuk blueprint TPU v4, v5e, dan v5p, lihat repositori GitHub Cluster Toolkit):

    gcluster deploy examples/gke-tpu-7x/gke-tpu-7x.yaml \
      --vars project_id=PROJECT_ID,deployment_name=DEPLOYMENT_NAME,zone=ZONE
    

    Ganti kode berikut:

    • DEPLOYMENT_NAME: nama untuk deployment Cluster Toolkit (yang juga merupakan nama cluster GKE).
    • PROJECT_ID: Project ID Google Cloud Anda.
    • ZONE: nama zona berdasarkan versi TPU yang ingin Anda gunakan. Untuk mengidentifikasi lokasi yang tersedia, lihat Ketersediaan TPU di GKE. Untuk menggunakan kapasitas yang dipesan, pastikan Anda menggunakan zona tempat Anda memesan kapasitas.

Anda telah membuat cluster GKE dengan node pool yang menyertakan resource TPU yang ditentukan. Sekarang Anda dapat mengikuti langkah-langkah di bagian menjalankan workload Anda pada node slice TPU dalam dokumen ini.

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.
  • Gunakan node auto-provisioning GKE: Anda dapat mengaktifkan node auto-provisioning 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.
  • Menentukan ComputeClass kustom: Anda dapat meminta TPU menggunakan ComputeClass kustom. ComputeClass Kustom memungkinkan administrator platform menentukan hierarki konfigurasi node yang akan diprioritaskan 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 konsol Google Cloud .

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.

    Opsional: gunakan zona AI, seperti us-central1-ai1a. Zona AI adalah lokasi khusus yang dioptimalkan untuk workload AI/ML dalam region Google Cloud .

  • 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 node awal 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 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 lebih lanjut pemesanan TPU, 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 flag 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 pemesanan 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 Flex-start VM. Flex-start VM dibuat menggunakan opsi konsumsi flex-start. Untuk mengetahui informasi selengkapnya, lihat Menjalankan workload batch kecil dengan TPU dan Flex-start VM.

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

    Opsional: gunakan zona AI, seperti us-central1-ai1a. Zona AI adalah lokasi khusus yang dioptimalkan untuk workload AI/ML dalam region Google Cloud .

  • 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 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 untuk menggunakan opsi konsumsi flex-start. Tidak dapat ditetapkan ke true jika spot diaktifkan. Flex-start didukung di GKE versi 1.33.0-gke.1712000 atau yang lebih baru.

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 tab Nodes.

  4. Klik Create user-managed node pool.

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

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

  7. Dari panel navigasi, klik Node.

  8. Di bagian Konfigurasi Mesin, pilih TPU.

  9. 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 Trillium (v6e)
  10. 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.

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

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

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

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

  15. Klik Create.

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.

  1. Buat kebijakan workload:

    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: Project ID Google Cloud Anda.
    • REGION: region untuk kebijakan workload. Kebijakan workload adalah resource regional dan dapat digunakan kembali di seluruh node pool yang memiliki topologi yang sama.
  2. 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 Anda.
    • CLUSTER_NAME: nama cluster GKE Anda.
    • WORKLOAD_POLICY_NAME: nama kebijakan workload yang Anda buat.
    • CONTROL_PLANE_LOCATION: lokasi Compute Engine dari 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.

      Opsional: gunakan zona AI, seperti us-central1-ai1a. Zona AI adalah lokasi khusus yang dioptimalkan untuk workload AI/ML dalam region Google Cloud .

      Untuk mengidentifikasi lokasi yang tersedia, lihat Ketersediaan TPU di GKE.
    • PROJECT_ID: Project ID Google Cloud Anda.
    • RESERVATION_NAME: nama pemesanan yang akan digunakan.

    Dalam perintah ini, flag --tpu-topology telah diganti dengan flag --placement-policy.

Terraform

  1. Pastikan Anda menggunakan penyedia google versi 4.84.0 atau yang lebih baru.
  2. Buat kebijakan workload:

    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 bidang kontrol Kubernetes yang lebih tinggi. Anda juga dapat menggunakan cluster zona. 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.

  3. Dalam konfigurasi Terraform Anda, 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.

      Opsional: gunakan zona AI, seperti us-central1-ai1a. Zona AI adalah lokasi khusus yang dioptimalkan untuk workload AI/ML dalam region Google Cloud .

    • 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. Nilainya harus sama dengan hasil kali 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-nya 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 pemakaian flex-start. Setelan ini tidak dapat ditetapkan 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: 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.

    Opsional: gunakan zona AI, seperti us-central1-ai1a. Zona AI adalah lokasi khusus yang dioptimalkan untuk workload AI/ML dalam region Google Cloud .

  • MACHINE_TYPE: jenis mesin yang akan digunakan untuk node. Untuk mempelajari lebih lanjut jenis mesin yang tersedia, lihat Memilih versi TPU.
  • TPU_TOPOLOGY: topologi fisik untuk slice TPU. Format topologi bergantung pada versi TPU. Untuk mempelajari lebih lanjut 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 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. Jika Anda menghapus flag ini, jumlah node akan dihitung dan ditetapkan secara default berdasarkan topologi dan jenis mesin.

  • 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 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 Flex-start VM. Flex-start VM 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 produk dari 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 koleksi. Gunakan flag 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 flag --tpu-topology. Untuk mengetahui informasi selengkapnya, lihat Membuat kebijakan penempatan rapat dan Topologi TPU.

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]
        }
        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 bidang kontrol Kubernetes yang lebih tinggi. Anda juga dapat menggunakan cluster zona. 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.

      Opsional: gunakan zona AI, seperti us-central1-ai1a. Zona AI adalah lokasi khusus yang dioptimalkan untuk workload AI/ML dalam region Google Cloud .

    • 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 ditetapkan ke true jika spot diaktifkan.

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 tab Nodes.

  4. Klik Create user-managed node pool.

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

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

  7. Dari panel navigasi, klik Node.

  8. Di bagian Konfigurasi Mesin, pilih TPU.

  9. 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 Trillium (v6e)
  10. 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.

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

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

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

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

  15. Klik Create.

Menggunakan node auto-provisioning GKE

Anda dapat mengonfigurasi GKE untuk membuat dan menghapus node pool secara otomatis guna memenuhi permintaan resource dari workload TPU Anda.

  1. 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 untuk Ironwood (TPU7x).
    • MINIMUM_TPU_COUNT: jumlah minimum TPU chip dari jenis yang ditentukan yang dapat dimiliki cluster. Jika nilai yang Anda tentukan lebih besar dari jumlah TPU chip dalam slice TPU multi-host, GKE akan menghapus semua node dalam slice tersebut. Node pool multi-host diskalakan antara 0 dan jumlah node dalam slice, tanpa nilai perantara.
    • MAXIMUM_TPU_COUNT: jumlah maksimum TPU chip dari jenis yang ditentukan yang dapat dimiliki cluster. Untuk slice TPU multi-host, tentukan nilai yang lebih besar dari jumlah chip di setiap slice agar GKE dapat menskalakan slice secara atomik. Jumlah chip dalam sebuah slice adalah produk dari 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 Tugas yang menggunakan TPU yang ditentukan dalam ComputeClass.

Membuat ComputeClass kustom

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

Ironwood (TPU7x)

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

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

    Ganti kode berikut:

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

    apiVersion: cloud.google.com/v1
    kind: ComputeClass
    metadata:
      name: tpu-class
    spec:
      priorities:
        - tpu:
            type: tpu7x
            topology: TPU_TOPOLOGY
            count: 4
          placement:
            policyName: WORKLOAD_POLICY_NAME
      nodePoolAutoCreation:
        enabled: true
    
  3. (Opsional) Anda dapat menggunakan pemesanan 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 pemesanan kapasitas Compute Engine.
    • RESERVATION_BLOCK_NAME: nama blok pemesanan kapasitas Compute Engine.
    • RESERVATION_SUB_BLOCK_NAME: nama sub-blok pemesanan kapasitas Compute Engine.

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

Versi TPU lainnya

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

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

    apiVersion: cloud.google.com/v1
    kind: ComputeClass
    metadata:
      name: tpu-class
    spec:
      priorities:
      - tpu:
          type: TPU_TYPE
          count: NUMBER_OF_CHIPS
          topology: TOPOLOGY
      - spot: true
        tpu:
          type: TPU_TYPE
          count: NUMBER_OF_CHIPS
          topology: TOPOLOGY
      - flexStart:
          enabled: true
        tpu:
          type: 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 TPU chip dalam slice, seperti 2x2x4. Harus berupa topologi yang didukung untuk jenis TPU yang dipilih.
    • NUMBER_OF_CHIPS: jumlah TPU chip yang akan digunakan container. Harus berupa nilai yang sama untuk limits dan requests.
  2. Deploy ComputeClass:

    kubectl apply -f tpu-compute-class.yaml
    

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

Membuat Tugas yang menggunakan TPU

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

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

    Ganti kode berikut:

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

    kubectl create -f tpu-job.yaml
    

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

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

    Untuk mempelajari lebih lanjut, lihat Tentang ComputeClass kustom.

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

    kubectl delete -f tpu-job.yaml
    

Menyiapkan workload Anda

Workload TPU memiliki persyaratan persiapan berikut.

  1. Framework seperti JAX, PyTorch, dan TensorFlow mengakses VM TPU menggunakan pustaka 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)
    TPU Trillium (v6e)
    tpu-v6e-slice
    TPU v5e
    tpu-v5-lite-podslice
    TPU v5p
    tpu-v5p-slice
    TPU v4
    tpu-v4-podslice
    TPU v3
    tpu-v3-slice
    tpu-v3-device
  2. Dalam manifes workload, tambahkan pemilih node Kubernetes untuk memastikan GKE menjadwalkan workload TPU Anda pada jenis mesin TPU dan topologi TPU yang Anda tentukan:

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

    Ganti kode berikut:

    • TPU_ACCELERATOR: nama akselerator TPU. Misalnya, gunakan tpu7x-standard-4t.
    • TPU_TOPOLOGY: topologi fisik untuk slice TPU. Format topologi bergantung pada versi TPU. Misalnya, gunakan 2x2x2. Untuk mempelajari lebih lanjut, lihat Merencanakan TPU di GKE.
    • WORKLOAD_POLICY: nama kebijakan workload 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 Tugas 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

gcloud

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 node auto-provisioning tingkat cluster diaktifkan, Deployment ini akan memicu pembuatan otomatis node pool. Saat Anda membuat contoh Deployment 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 TPU chip per VM. Misalnya, jika Anda menggunakan tpu7x-standard-4t, jumlah TPU chip per VM adalah 4.

Cluster Toolkit

Kirim workload menggunakan perintah gcluster job submit. Untuk mengetahui informasi selengkapnya tentang opsi pengiriman tugas, lihat Panduan Pengiriman Tugas Cluster Toolkit:

gcluster job submit \
  --name=WORKLOAD_NAME \
  --cluster=DEPLOYMENT_NAME \
  --project=PROJECT_ID \
  --location=ZONE \
  --compute-type=COMPUTE_TYPE \
  --topology=TOPOLOGY \
  --num-slices=1 \
  --image=us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest \
  --command="python -c 'import jax; print(\"TPU cores:\", jax.device_count())'"

Ganti kode berikut:

  • WORKLOAD_NAME: nama workload Anda.
  • DEPLOYMENT_NAME: nama deployment Cluster Toolkit Anda (yang juga merupakan nama cluster GKE).
  • PROJECT_ID: Project ID Google Cloud Anda.
  • ZONE: nama zona berdasarkan versi TPU yang ingin Anda gunakan. Untuk mengidentifikasi lokasi yang tersedia, lihat Ketersediaan TPU di GKE.
  • COMPUTE_TYPE: jenis komputasi yang cocok dengan jenis akselerator node pool Anda, misalnya, v6e-16, tpu7x-standard-4t, atau v5e-8.
  • TOPOLOGY: topologi fisik yang cocok dengan node pool Anda, misalnya, 2x4 atau 2x2x2.

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

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 # 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.
  2. Deploy manifes:
    kubectl create -f available-chips-multihost.yaml
    

    GKE menjalankan slice TPU v4 dengan empat VM (slice TPU multi-host). Slice ini memiliki 16 TPU chip 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
    
  5. 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 TPU chip yang terpasang ke node tertentu. Untuk membuat node host tunggal, workload memiliki parameter berikut:

  • Versi TPU: TPU v5e
  • Topologi: 2x4

Pemilihan versi dan topologi ini menghasilkan slice host tunggal.

  1. Simpan manifes berikut sebagai available-chips-singlehost.yaml:
    apiVersion: v1
    kind: Pod
    metadata:
      name: tpu-job-jax-v5
    spec:
      restartPolicy: Never
      nodeSelector:
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice # Node selector to target TPU v5e slice nodes.
        cloud.google.com/gke-tpu-topology: 2x4 # Specify the physical topology for the TPU slice.
      containers:
      - name: tpu-job
        image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
        ports:
        - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
        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.
  2. Deploy manifes:
    kubectl create -f available-chips-singlehost.yaml
    

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

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

    Outputnya mirip dengan hal berikut ini:

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

Contoh 4: Menjalankan workload yang menargetkan dua node NUMA

Untuk mengoptimalkan performa workload, GKE memungkinkan Anda men-deploy workload dalam penyiapan multi-container. Tindakan ini mengikat setiap container ke resource CPU, memori, dan TPU dalam node NUMA tertentu. Untuk mengetahui informasi selengkapnya tentang binding NUMA, lihat Tentang Ironwood (TPU7x) di GKE.

  1. Buat file bernama topology-manager-config.yaml dengan konten berikut:

    kubeletConfig:
      cpuManagerPolicy: static
      topologyManager:
        policy: best-effort
        scope: container
    

    Konfigurasi ini menyelaraskan resource yang diminta oleh container ke satu node NUMA. Konfigurasi ini diperlukan agar GKE dapat menerima dan menetapkan chip dengan benar ke workload TPU multi-container. Untuk opsi kebijakan lainnya, lihat Kebijakan Topology Manager.

  2. Terapkan konfigurasi kubelet ke node pool dengan membuat node pool baru atau memperbarui node pool yang ada. Node pool ini harus menggunakan node Ironwood (TPU7x), seperti jenis mesin tpu7x-standard-4t agar cocok dengan pemilih node di langkah berikutnya.

    • Untuk membuat node pool baru dengan Topology Manager yang diaktifkan:

      gcloud container node-pools create NODE_POOL_NAME \
          --location=LOCATION \
          --cluster=CLUSTER_NAME \
          --node-locations=NODE_ZONES \
          --machine-type=tpu7x-standard-4t \
          --system-config-from-file=topology-manager-config.yaml
      

      Ganti kode berikut:

      • NODE_POOL_NAME: nama node pool baru.
      • LOCATION: region cluster.
      • CLUSTER_NAME: nama cluster.
      • NODE_ZONES: comma separated list dari satu atau beberapa zona untuk node pool.
    • Untuk mengupdate node pool yang ada dengan Topology Manager yang diaktifkan:

      gcloud container node-pools update NODE_POOL_NAME \
          --location=LOCATION \
          --cluster=CLUSTER_NAME \
          --system-config-from-file=topology-manager-config.yaml
      

      Ganti kode berikut:

      • NODE_POOL_NAME: nama node pool Anda.
      • LOCATION: region cluster.
      • CLUSTER_NAME: nama cluster.
  3. Buat file bernama tpu-jobset.yaml dengan manifes berikut:

    apiVersion: jobset.x-k8s.io/v1alpha2
    kind: JobSet
    metadata:
      name: tpu7x-test
    spec:
      failurePolicy:
        maxRestarts: 0
      replicatedJobs:
        - name: tpu7x
          replicas: 1
          template:
            spec:
              parallelism: 2
              completions: 2
              backoffLimit: 0
              template:
                spec:
                  subdomain: test
                  restartPolicy: Never
                  nodeSelector:
                    cloud.google.com/gke-tpu-accelerator: tpu7x
                    cloud.google.com/gke-tpu-topology: 2x2x2
                  containers:
                  - name: jax-tpu-1
                    image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
                    securityContext:
                      privileged: false
                    command:
                    - bash
                    - -c
                    - |
                      set -ex
                      python -c 'import jax; print("local devices:", jax.local_device_count(), "devices:", jax.device_count())'
                    resources:
                      requests:
                        google.com/tpu: 2
                      limits:
                        google.com/tpu: 2
                  - name: jax-tpu-2
                    image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
                    securityContext:
                      privileged: false
                    command:
                    - bash
                    - -c
                    - |
                      set -ex
    
                      python -c 'import jax; print("local devices:", jax.local_device_count(), "devices:", jax.device_count())'
                    resources:
                      requests:
                        google.com/tpu: 2
                      limits:
                        google.com/tpu: 2
    

    Manifes ini menentukan JobSet bernama tpu7x-test, yang menjalankan dua container utama, jax-tpu-1 dan jax-tpu-2. Setiap container meminta dua chip google.com/tpu. Kedua chip ini berasal dari node NUMA yang sama. Setiap container kemudian menjalankan skrip Python untuk memverifikasi akses JAX ke TPU.

    Konfigurasi JobSet ini menunjukkan bahwa beberapa container dalam Pod yang sama dapat mengakses dan menggunakan chip TPU yang terpisah.

  4. Terapkan manifes:

    kubectl apply -f tpu-jobset.yaml
    

Contoh 5: Menjalankan workload TPU multi-container dengan volume Cloud Storage FUSE Multi-NIC

Contoh ini memperluas Contoh 4 untuk menyertakan pemasangan bucket Cloud Storage FUSE sebagai volume menggunakan Cloud Storage FUSE. Konfigurasi ini memanfaatkan kemampuan multi-NIC untuk meningkatkan performa jaringan.

  1. Buat file bernama tpu7x-gcsfuse-multinic.yaml dengan manifes berikut:

    apiVersion: jobset.x-k8s.io/v1alpha2
    kind: JobSet
    metadata:
      name: tpu7x-gcsfuse-multinic
    spec:
      failurePolicy:
        maxRestarts: 0
      replicatedJobs:
        - name: tpu7x
          replicas: 1
          template:
            spec:
              parallelism: 2
              completions: 2
              backoffLimit: 0
              template:
                spec:
                  subdomain: test
                  restartPolicy: Never
                  nodeSelector:
                    cloud.google.com/gke-tpu-accelerator: tpu7x
                    cloud.google.com/gke-tpu-topology: 2x2x2
                  hostNetwork: true
                  volumes:
                  - name: gcs0
                    csi:
                      driver: gcsfuse.csi.storage.gke.io
                      volumeAttributes:
                        bucketName: BUCKET_NAME
                        multiNICIndex: "0"
                        mountOptions: implicit-dirs
                        hostNetworkPodKSA: "true"
                  - name: gcs1
                    csi:
                      driver: gcsfuse.csi.storage.gke.io
                      volumeAttributes:
                        bucketName: BUCKET_NAME
                        multiNICIndex: "1"
                        mountOptions: implicit-dirs
                        hostNetworkPodKSA: "true"
                  containers:
                  - name: jax-tpu-1
                    image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
                    securityContext:
                      privileged: false
                    command:
                    - bash
                    - -c
                    - |
                      set -ex
                      python -c 'import jax; print("local devices:", jax.local_device_count(), "devices:", jax.device_count())'
                      echo "Use /gcs${WORKLOAD_NIC_PREFERRED_NUMA}/ for Cloud Storage access"
                    resources:
                      requests:
                        google.com/tpu: 2
                      limits:
                        google.com/tpu: 2
                    volumeMounts:
                    - name: gcs0
                      mountPath: /gcs0
                      readOnly: false
                    - name: gcs1
                      mountPath: /gcs1
                      readOnly: false
                  - name: jax-tpu-2
                    image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
                    securityContext:
                      privileged: false
                    command:
                    - bash
                    - -c
                    - |
                      set -ex
    
                      python -c 'import jax; print("local devices:", jax.local_device_count(), "devices:", jax.device_count())'
                      echo "Use /gcs${WORKLOAD_NIC_PREFERRED_NUMA}/ for Cloud Storage access"
                    resources:
                      requests:
                        google.com/tpu: 2
                      limits:
                        google.com/tpu: 2
                    volumeMounts:
                    - name: gcs0
                      mountPath: /gcs0
                      readOnly: false
                    - name: gcs1
                      mountPath: /gcs1
                      readOnly: false
    

    Manifes ini menambahkan pemasangan volume Cloud Storage FUSE berikut ke Contoh 4.

    • multiNICIndex ditentukan dalam atribut volume untuk menggunakan antarmuka jaringan pada node NUMA yang sesuai untuk setiap volume.
    • Workload menggunakan variabel lingkungan ${WORKLOAD_NIC_PREFERRED_NUMA} untuk memilih volume Cloud Storage FUSE, yang terkait dengan node NUMA yang ditetapkan ke container. GKE memasukkan variabel ini ke dalam container pada workload Cloud TPU.

    Ganti BUCKET_NAME dengan nama bucket Cloud Storage Anda.

  2. Terapkan manifes:

    kubectl apply -f tpu7x-gcsfuse-multinic.yaml
    

Mengupgrade node pool menggunakan akselerator (GPU dan TPU)

GKE secara otomatis mengupgrade cluster Standard, termasuk node pool. 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 pemeliharaan dan pengecualian, dan urutan peluncuran.

Anda juga dapat mengonfigurasi strategi upgrade node untuk node pool, seperti upgrade lonjakan, upgrade blue-green, atau upgrade sementara. 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 atomik dalam satu langkah, bukan menggunakan strategi upgrade node yang dikonfigurasi. Untuk mempelajari lebih lanjut, lihat definisi atomisitas dalam Terminologi yang terkait dengan TPU di GKE.

Penggunaan strategi upgrade node mengharuskan GKE untuk menyediakan resource tambahan untuk sementara, bergantung pada konfigurasinya. 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 resource terbatas.

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.

gcloud

Hapus node pool slice TPU:

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

Ganti kode berikut:

  • POOL_NAME: nama node pool.
  • LOCATION: lokasi komputasi cluster.
  • CLUSTER_NAME: nama cluster.

Cluster Toolkit

Hapus deployment Cluster Toolkit:

  gcluster destroy DEPLOYMENT_NAME

Ganti DEPLOYMENT_NAME dengan nama direktori deployment yang dibuat saat Anda men-deploy blueprint.

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, dalam node pool slice TPU host tunggal, hanya TPU node yang tidak responsif yang akan diperbaiki secara 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, hubungi Google Cloud account representative 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 segera dapat dikonfigurasi hingga lima menit di TPU node.

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

Mencegah deadlock penjadwalan

Saat menjalankan beberapa Tugas TPU atau beberapa replika Tugas, Pod dari Tugas yang berbeda dapat dijadwalkan di node pool TPU yang sama. Hal ini dapat menyebabkan deadlock penjadwalan, di mana tidak ada Tugas yang dapat mengamankan cukup node untuk menyelesaikan topologinya.

Untuk mengurangi risiko deadlock penjadwalan, terapkan salah satu konfigurasi berikut:

  • Gunakan aturan anti-afinitas Pod untuk memastikan bahwa Pod dari Tugas yang berbeda tidak dijadwalkan pada node pool TPU atau domain topologi yang sama.
  • Gunakan anotasi jobset.sigs.k8s.io/exclusive-topology, yang menyebabkan JobSet mengklaim domain topologi yang ditentukan (seperti node pool) secara eksklusif untuk Pod-nya sendiri.

Untuk mengetahui contoh konfigurasi mendetail dan langkah-langkah pemecahan masalah, lihat Deadlock penjadwalan.

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 hak istimewa.

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

Container yang berjalan pada VM di 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 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 observasi node pool di konsolGoogle Cloud tersedia secara umum. Untuk melihat status node pool multi-host TPU di GKE, buka dasbor GKE TPU Node Pool Status yang disediakan oleh Cloud Monitoring:

Buka Status Node Pool TPU GKE

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

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

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 container Kubernetes (k8s_container).

Container Kubernetes:

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

Node Kubernetes:

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

Memantau metrik kondisi untuk TPU node dan node pool

Jika tugas pelatihan mengalami error atau berhenti karena 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

Di 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 adalah 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 bukan Ready:

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

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

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

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 dimonitor 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 menurut 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 sebaliknya. 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}]))

Agar 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 digabungkan berdasarkan 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) node pool

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 node pool dari periode nonaktif.

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

Anda dapat menggunakan kueri PromQL berikut untuk menghitung waktu rata-rata untuk 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 node pool di antara gangguan (TBI)

Metrik sistem GKE berikut melaporkan distribusi waktu antara akhir gangguan terbaru dan awal gangguan saat ini untuk node pool TPU multi-host GKE:

  • kubernetes.io/node_pool/accelerator/times_between_interruptions

Setiap sampel yang dicatat dalam metrik ini menunjukkan satu durasi antara gangguan terbaru dan saat ini.

Gunakan kueri PromQL berikut untuk menghitung waktu rata-rata antara gangguan (MTBI) di cluster Anda selama 7 hari sebelumnya:

sum(sum_over_time(
  kubernetes_io:node_pool_accelerator_times_between_interruptions_sum{
    monitored_resource="k8s_node_pool", cluster_name="CLUSTER_NAME"}[7d]))
/
sum(sum_over_time(
  kubernetes_io:node_pool_accelerator_times_between_interruptions_count{
    monitored_resource="k8s_node_pool",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:

  • Pemakaian TensorCore: persentase TensorCore yang saat ini dipakai. Nilai TensorCore sama dengan jumlah matrix-multiply unit (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 dtk) dengan bandwidth maksimum yang didukung selama periode sampel yang sama.

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

Container Kubernetes:

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

Node Kubernetes:

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

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

Mengelola penjadwalan koleksi

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

TPU Trillium mendukung penjadwalan pengumpulan untuk node pool host tunggal dan multi-host yang menjalankan workload inferensi. Berikut ini penjelasan tentang bagaimana perilaku penjadwalan pengumpulan 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 untuk koleksi tersebut. 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 koleksi. 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 node pool 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 pool 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-nya 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 workload yang sama. Jika penyediaan otomatis node diaktifkan di cluster, GKE akan otomatis membuat pool berdasarkan permintaan workload.

  • Untuk memperkecil skala koleksi, hapus node pool.

  • Untuk menghapus koleksi, hapus semua node pool yang terpasang. Anda dapat menghapus node pool atau menghapus cluster. Menghapus cluster akan menghapus semua koleksi di dalamnya.

Mengelola penjadwalan pengumpulan di node pool slice TPU host tunggal

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

  • Untuk memeriksa apakah pool slice TPU host tunggal telah mengaktifkan penjadwalan pengumpulan, 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-nya akan memiliki label cloud.google.com/gke-workload-type: HIGH_AVAILABILITY.

  • Untuk meningkatkan skala pengumpulan, ubah ukuran node pool secara manual atau otomatis dengan node auto-provisioning.

  • Untuk memperkecil skala koleksi, hapus node pool.

  • Untuk menghapus koleksi, hapus semua node pool yang terpasang. 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. Autoscaler cluster kemudian dapat melakukan peningkatan skala tambahan dan akibatnya 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 node pool slice TPU 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 TPU slice node pool.
  • Metrik pemakaian bandwidth memori tidak tersedia untuk TPU v5e.

Langkah berikutnya