Pengantar TPU di GKE

Pelanggan Google Kubernetes Engine (GKE) kini dapat membuat kumpulan node Kubernetes yang berisi Pod TPU v4 dan v5e. Pod TPU adalah grup perangkat TPU yang terhubung oleh interkoneksi berkecepatan tinggi. Untuk workload yang tidak memerlukan Pod TPU lengkap, Anda dapat menggunakan subset Pod TPU lengkap yang disebut slice TPU. Seperti Pod TPU lengkap, setiap perangkat TPU dalam sebuah slice memiliki VM TPU sendiri. Kami menyebut VM TPU dan perangkat yang terhubung sebagai host atau node TPU. Untuk mengetahui informasi selengkapnya tentang Pod TPU, lihat Arsitektur Sistem.

Karena istilah Pod yang digunakan dalam konteks GKE biasanya berarti Pod Kubernetes, untuk menghindari kebingungan, kami akan selalu menyebut kumpulan satu atau beberapa perangkat TPU sebagai slice.

Saat menggunakan GKE, Anda harus membuat cluster GKE terlebih dahulu.

Selanjutnya, tambahkan kumpulan node ke cluster Anda. Kumpulan node GKE adalah kumpulan VM yang memiliki atribut yang sama. Untuk workload TPU, node pool terdiri dari VM TPU.

Jenis kumpulan node

GKE mendukung dua jenis kumpulan node TPU:

Kumpulan node slice TPU multi-host

Kumpulan node slice TPU multi-host adalah kumpulan node yang berisi dua atau lebih VM TPU yang saling terhubung. Setiap VM memiliki perangkat TPU yang terhubung dengannya. TPU dalam slice multi-host terhubung melalui interkoneksi berkecepatan tinggi (ICI). Kumpulan node slice TPU multi-host tidak dapat diubah. Setelah kumpulan node slice multi-host dibuat, Anda tidak dapat menambahkan node ke dalamnya. Misalnya, Anda tidak dapat membuat kumpulan node v4-32, lalu menambahkan node Kubernetes (TPU VM) tambahan ke kumpulan node tersebut. Untuk menambahkan slice TPU tambahan ke cluster GKE, Anda harus membuat node pool baru.

Host dalam kumpulan node slice TPU multi-host diperlakukan sebagai unit atom tunggal. Jika GKE tidak dapat men-deploy satu node dalam slice, semua node dalam slice akan gagal di-deploy.

Jika node dalam slice TPU multi-host perlu diperbaiki, GKE akan menonaktifkan semua VM TPU (node) dalam slice, sehingga semua Pod GKE dalam workload harus dikeluarkan. Setelah semua VM TPU di slice siap dan berjalan, Pod GKE dapat dijadwalkan di VM TPU di slice baru.

Diagram berikut menunjukkan contoh slice multi-host TPU v5litepod-16 (v5e). Slice ini memiliki empat VM TPU. Setiap VM TPU memiliki empat chip TPU v5e yang terhubung dengan interkoneksi berkecepatan tinggi (ICI), dan setiap chip TPU v5e memiliki satu TensorCore.

Diagram slice TPU multi-host

Diagram berikut menunjukkan cluster GKE yang berisi satu slice TPU v5litepod-16 (v5e) (topologi: 4x4) dan satu slice TPU v5litepod-8 (v5e) (topologi: 2x4):

Diagram Pod TPU v5e

Untuk contoh menjalankan beban kerja pada slice TPU multi-host, lihat Menjalankan beban kerja pada slice TPU multi-host.

Kumpulan node slice TPU host tunggal

Kumpulan node slice host tunggal adalah kumpulan node yang berisi satu atau beberapa VM TPU independen. Setiap VM ini memiliki perangkat TPU yang terhubung ke VM tersebut. Meskipun VM dalam kumpulan node slice host tunggal dapat berkomunikasi melalui Jaringan Pusat Data (DCN), TPU yang terpasang ke VM tidak saling terhubung. Diagram berikut menunjukkan contoh slice TPU host tunggal dengan tujuh mesin v4-8:

Diagram kumpulan node slice host tunggal

Untuk contoh menjalankan beban kerja pada slice TPU host tunggal, lihat Menjalankan beban kerja pada node TPU.

Jenis mesin TPU untuk kumpulan node GKE

Sebelum membuat node pool, Anda harus memilih versi TPU dan ukuran potongan TPU yang diperlukan workload. TPU v4 didukung di GKE Versi Standar 1.26.1-gke.1500 dan yang lebih baru, v5e di GKE Versi standar 1.27.2-gke.2100 dan yang lebih baru, serta v5p di GKE Standard versi 1.28.3-gke.1024000 dan yang lebih baru.

TPU v4, v5e, dan v5p didukung di GKE Autopilot versi 1.29.2-gke.1521000 dan yang lebih baru.

Untuk mengetahui informasi selengkapnya tentang spesifikasi hardware dari berbagai versi TPU, lihat Arsitektur sistem. Saat membuat kumpulan TPU node, pilih ukuran irisan TPU (topologi TPU) berdasarkan ukuran model Anda dan jumlah memori yang diperlukan. Jenis mesin yang Anda tentukan saat membuat node pool bergantung pada versi dan ukuran slice Anda.

V5e

Berikut adalah jenis mesin dan topologi TPU v5e yang didukung untuk kasus penggunaan pelatihan dan inferensi:

Machine Type Topologi Jumlah chip TPU Jumlah VM Kasus penggunaan yang direkomendasikan
ct5lp-hightpu-1t 1x1 1 1 Pelatihan, inferensi host tunggal
ct5lp-hightpu-4t 2x2 4 1 Pelatihan, inferensi host tunggal
ct5lp-hightpu-8t 2x4 8 1 Pelatihan, inferensi host tunggal
ct5lp-hightpu-4t 2x4 8 2 Pelatihan, inferensi multi-host
ct5lp-hightpu-4t 4x4 16 4 Pelatihan skala besar, inferensi multi-host
ct5lp-hightpu-4t 4x8 32 8 Pelatihan skala besar, inferensi multi-host
ct5lp-hightpu-4t 8x8 64 16 Pelatihan skala besar, inferensi multi-host
ct5lp-hightpu-4t 8x16 128 32 Pelatihan skala besar, inferensi multi-host
ct5lp-hightpu-4t 16x16 256 64 Pelatihan skala besar, inferensi multi-host

Cloud TPU v5e adalah produk pelatihan dan inferensi gabungan. Tugas pelatihan dioptimalkan untuk throughput dan ketersediaan, sementara tugas inferensi dioptimalkan untuk latensi. Untuk mengetahui informasi selengkapnya, lihat Jenis akselerator pelatihan v5e dan Jenis akselerator inferensi v5e.

Mesin TPU v5e tersedia di us-west4-a, us-east5-b, dan us-east1-c. Cluster GKE Standard harus menjalankan bidang kontrol versi 1.27.2-gke.2100 atau yang lebih baru. GKE Autopilot harus menjalankan bidang kontrol versi 1.29.2-gke.1521000 atau yang lebih baru. Untuk mengetahui informasi selengkapnya tentang v5e, lihat Pelatihan Cloud TPU v5e.

Perbandingan jenis mesin:

Machine Type ct5lp-hightpu-1t ct5lp-hightpu-4t ct5lp-hightpu-8t
Jumlah chip v5e 1 4 8
Jumlah vCPU 24 112 224
RAM (GB) 48 192 384
Jumlah NUMA node 1 1 2
Kemungkinan preemption Tinggi Sedang Rendah

Untuk memberi ruang bagi VM dengan lebih banyak chip, penjadwal GKE dapat melakukan preempt dan menjadwalkan ulang VM dengan chip yang lebih sedikit. Jadi VM 8-chip cenderung mendahului VM 1 dan 4-chip.

v4 dan v5p

Berikut adalah jenis mesin TPU v4 dan v5p:

Machine type Jumlah vCPU Memori (GB) Jumlah node NUMA
ct4p-hightpu-4t 240 407 2
ct5p-hightpu-4t 208 448 2

Saat membuat slice TPU v4, gunakan jenis mesin ct4p-hightpu-4t yang memiliki satu host dan berisi 4 chip. Lihat topologi v4 dan arsitektur sistem TPU untuk mengetahui informasi selengkapnya. Jenis mesin Pod TPU v4 tersedia di us-central2-b. Cluster GKE Standard Anda harus menjalankan bidang kontrol versi 1.26.1-gke.1500 atau yang lebih baru. Cluster GKE Autopilot harus menjalankan bidang kontrol versi 1.29.2-gke.1521000 atau yang lebih baru.

Saat membuat slice TPU v5p, gunakan jenis mesin ct5p-hightpu-4t yang memiliki satu host dan berisi 4 chip. Jenis mesin Pod TPU v5p tersedia di us-west4-a dan us-east5-a. Cluster GKE Standard harus menjalankan bidang kontrol versi 1.28.3-gke.1024000 atau yang lebih baru. GKE Autopilot harus menjalankan 1.29.2-gke.1521000 atau yang lebih baru. Untuk informasi selengkapnya tentang v5p, lihat pengantar pelatihan v5p.

Masalah umum dan batasan

  • Jumlah maksimum pod Docker: Anda dapat menjalankan maksimum 256 pod Docker dalam satu VM TPU.
  • Khusus reservasi khusus: Saat menggunakan TPU di GKE, SPECIFIC adalah satu-satunya nilai yang didukung untuk flag --reservation-affinity dari perintah gcloud container node-pools create.
  • Hanya varian Spot VM dari preemptible TPU yang didukung: Spot VM serupa dengan preemptible VM dan memiliki batasan ketersediaan yang sama, tetapi tidak memiliki durasi maksimum 24 jam.
  • Tidak ada dukungan alokasi biaya: Alokasi biaya GKE dan pengukuran penggunaan tidak mencakup data apa pun tentang penggunaan atau biaya TPU.
  • Autoscaler mungkin menghitung kapasitas: Autoscaler cluster mungkin salah menghitung kapasitas untuk node TPU baru sebelum node tersebut tersedia. Autoscaler cluster kemudian mungkin melakukan peningkatan skala tambahan dan akibatnya membuat lebih banyak node daripada yang diperlukan. Autoscaler cluster akan menurunkan skala node tambahan, jika tidak diperlukan, setelah operasi penurunan skala reguler.
  • Autoscaler membatalkan peningkatan skala: Autoscaler cluster membatalkan peningkatan skala kumpulan node TPU yang masih dalam status menunggu selama lebih dari 15 menit. Cluster Autoscaler akan mencoba kembali operasi peningkatan skala tersebut nanti. Perilaku ini dapat mengurangi ketersediaan TPU bagi pelanggan yang tidak menggunakan reservasi.
  • Taint dapat mencegah penurunan skala: Workload non-TPU yang memiliki toleransi terhadap taint TPU dapat mencegah penurunan skala kumpulan node jika dibuat ulang selama pengosongan kumpulan node TPU.

Memastikan kuota TPU dan GKE yang memadai

Anda mungkin perlu meningkatkan kuota tertentu terkait GKE di region tempat resource Anda dibuat.

Kuota berikut memiliki nilai default yang mungkin perlu ditingkatkan:

  • Kuota Persistent Disk SSD (GB): Boot disk dari setiap node Kubernetes memerlukan 100 GB secara default. Oleh karena itu, kuota ini harus ditetapkan minimal setinggi (jumlah maksimum node GKE yang Anda perkirakan untuk dibuat) * 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 diperkirakan akan dibuat.

Untuk meminta penambahan kuota, lihat Meminta kuota yang lebih tinggi. Untuk mengetahui informasi selengkapnya tentang jenis kuota TPU, lihat Kuota TPU.

Mungkin perlu waktu beberapa hari agar permintaan penambahan kuota Anda disetujui. Jika Anda mengalami kesulitan untuk menyetujui permintaan penambahan kuota dalam beberapa hari, hubungi tim Akun Google Anda.

Memigrasikan pemesanan TPU

Jika Anda tidak berencana untuk menggunakan reservasi TPU yang sudah ada dengan TPU di GKE, lewati bagian ini dan buka Membuat cluster Google Kubernetes Engine.

Untuk menggunakan TPU yang dicadangkan dengan GKE, Anda harus terlebih dahulu memigrasikan reservasi TPU ke sistem reservasi berbasis Compute Engine yang baru.

Ada beberapa hal penting yang perlu diketahui tentang migrasi ini:

  • Kapasitas TPU yang dimigrasikan ke sistem reservasi berbasis Compute Engine baru tidak dapat digunakan dengan Queued Resource API Cloud TPU. Jika ingin menggunakan resource dalam antrean TPU dengan reservasi Anda, Anda hanya perlu memigrasikan sebagian reservasi TPU ke sistem reservasi berbasis Compute Engine yang baru.
  • Tidak ada beban kerja yang dapat berjalan secara aktif di TPU saat dimigrasikan ke sistem reservasi berbasis Compute Engine baru.
  • Pilih waktu untuk melakukan migrasi, dan bekerjasamalah dengan tim akun Google Cloud Anda untuk menjadwalkan migrasi. Periode waktu migrasi harus selama jam kerja (Senin - Jumat, 09.00-17.00 Waktu Pasifik).

Membuat cluster Google Kubernetes Engine

Lihat Membuat cluster di dokumentasi Google Kubernetes Engine.

Membuat kumpulan node TPU

Lihat Membuat kumpulan node di dokumentasi Google Kubernetes Engine.

Berjalan tanpa mode hak istimewa

Jika Anda ingin mengurangi cakupan izin pada penampung, lihat Mode hak istimewa TPU.

Menjalankan workload pada TPU node

Lihat Menjalankan beban kerja Anda pada node TPU dalam dokumentasi Google Kubernetes Engine.

Pemilih node

Agar Kubernetes dapat menjadwalkan beban kerja di TPU node, Anda harus menentukan dua pemilih untuk setiap node TPU di manifes Google Kubernetes Engine:

  • Tetapkan cloud.google.com/gke-accelerator-type ke tpu-v5-lite-podslice atau tpu-v4-podslice.
  • Tetapkan cloud.google.com/gke-tpu-topology ke topologi TPU node TPU.

Bagian Beban kerja pelatihan dan Beban kerja inferensi berisi contoh manifes yang menggambarkan penggunaan pemilih node ini.

Pertimbangan penjadwalan workload

TPU memiliki karakteristik unik yang memerlukan penjadwalan dan pengelolaan beban kerja khusus di Kubernetes. Untuk informasi selengkapnya, lihat Pertimbangan penjadwalan beban kerja di dokumentasi GKE.

Perbaikan node TPU

Jika TPU node dalam node pool slice TPU multi-host tidak responsif, seluruh node pool akan dibuat ulang. Untuk informasi selengkapnya, lihat Perbaikan otomatis node di dokumentasi GKE.

Multislice - melampaui satu irisan tunggal

Anda dapat menggabungkan irisan yang lebih kecil dalam multislice untuk menangani beban kerja pelatihan yang lebih besar. Untuk mengetahui informasi selengkapnya, lihat Cloud TPU Multislice.

Tutorial beban kerja pelatihan

Tutorial ini berfokus pada workload pelatihan pada slice TPU multi-host (misalnya, 4 mesin v5e). Solusi tersebut mencakup model berikut:

  • Model FLAX Wajah Memeluk: Difusi Kereta di Pokémon
  • PyTorch/XLA: GPT2 di WikiText

Download referensi tutorial

Download tutorial skrip Python dan spesifikasi YAML untuk setiap model terlatih dengan perintah berikut:

git clone https://github.com/GoogleCloudPlatform/ai-on-gke.git

Buat & hubungkan ke cluster

Buat cluster GKE regional, sehingga bidang kontrol Kubernetes direplikasi dalam tiga zona, sehingga memberikan ketersediaan yang lebih tinggi. Buat cluster Anda di us-west4, us-east1, atau us-central2, bergantung pada versi TPU yang Anda gunakan. Untuk mengetahui informasi selengkapnya tentang TPU dan zona, lihat Region dan zona Cloud TPU.

Perintah berikut membuat cluster regional GKE baru yang berlangganan saluran rilis cepat dengan kumpulan node yang awalnya berisi satu node per zona. Perintah ini juga mengaktifkan fitur driver CSI Workload Identity dan Cloud Storage FUSE di cluster Anda karena contoh inferensi workload dalam panduan ini menggunakan bucket Cloud Storage untuk menyimpan model terlatih.

gcloud container clusters create cluster-name \
  --region your-region \
  --release-channel rapid \
  --num-nodes=1 \
  --workload-pool=project-id.svc.id.goog \
  --addons GcsFuseCsiDriver

Untuk mengaktifkan fitur driver CSI Workload Identity dan Cloud Storage FUSE untuk cluster yang ada, jalankan perintah berikut:

gcloud container clusters update cluster-name \
  --region your-region \
  --update-addons GcsFuseCsiDriver=ENABLED \
  --workload-pool=project-id.svc.id.goog

Contoh beban kerja dikonfigurasi dengan asumsi berikut:

  • kumpulan node menggunakan tpu-topology=4x4 dengan empat node
  • kumpulan node menggunakan machine-type ct5lp-hightpu-4t

Jalankan perintah berikut untuk terhubung ke cluster yang baru Anda buat:

gcloud container clusters get-credentials cluster-name \
--location=cluster-region

Model FLAX Wajah Memeluk: Difusi Kereta di Pokémon

Contoh ini melatih model Difusi Stabil dari HuggingFace menggunakan set data Pokémon.

Model Difusi Stabil adalah model teks ke gambar laten yang menghasilkan gambar realistik foto dari input teks apa pun. Untuk mengetahui informasi selengkapnya tentang Difusi Stabil, lihat:

Membuat image Docker

Dockerfile berada dalam folder ai-on-gke/gke-tpu-examples/training/diffusion/. Jalankan perintah berikut untuk membangun dan mengirim image Docker.

cd ai-on-gke/gke-tpu-examples/training/diffusion/
docker build -t gcr.io/project-id/diffusion:latest .
docker push gcr.io/project-id/diffusion:latest

Men-deploy beban kerja

Buat file dengan konten berikut dan beri nama tpu_job_diffusion.yaml. Isi kolom gambar dengan gambar yang baru saja Anda buat.

apiVersion: v1
kind: Service
metadata:
  name: headless-svc
spec:
  clusterIP: None
  selector:
    job-name: tpu-job-diffusion
---
apiVersion: batch/v1
kind: Job
metadata:
  name: tpu-job-diffusion
spec:
  backoffLimit: 0
  # Completions and parallelism should be the number of chips divided by 4.
  # (e.g. 4 for a v5litepod-16)
  completions: 4
  parallelism: 4
  completionMode: Indexed
  template:
    spec:
      subdomain: headless-svc
      restartPolicy: Never
      nodeSelector:
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
        cloud.google.com/gke-tpu-topology: 4x4
      containers:
      - name: tpu-job-diffusion
        image: gcr.io/<var>project-name</var>/diffusion:latest
        ports:
        - containerPort: 8471 # Default port using which TPU VMs communicate
        - containerPort: 8431 # Port to export TPU usage metrics, if supported
        command:
        - bash
        - -c
        - |
          cd examples/text_to_image
          python3 train_text_to_image_flax.py --pretrained_model_name_or_path=duongna/stable-diffusion-v1-4-flax --dataset_name=lambdalabs/pokemon-blip-captions --resolution=128 --center_crop --random_flip --train_batch_size=4 --mixed_precision=fp16 --max_train_steps=1500 --learning_rate=1e-05 --max_grad_norm=1 --output_dir=sd-pokemon-model
        resources:
          requests:
            google.com/tpu: 4
          limits:
            google.com/tpu: 4

Kemudian deploy menggunakan:

kubectl apply -f tpu_job_diffusion.yaml

Pembersihan

Setelah Tugas Anda selesai berjalan, Anda dapat menghapusnya menggunakan:

kubectl delete -f tpu_job_diffusion.yaml

PyTorch/XLA: GPT2 di WikiText

Tutorial ini menunjukkan cara menjalankan GPT2 pada TPU v5e menggunakan HuggingFace pada PyTorch/XLA menggunakan set data wikitext.

Membuat image Docker

Dockerfile terletak di dalam folder ai-on-gke/gke-tpu-examples/training/gpt/. Jalankan perintah berikut untuk membangun dan mengirim image Docker.

cd ai-on-gke/gke-tpu-examples/training/gpt/
docker build -t gcr.io/project-id/gpt:latest .
docker push gcr.io/project-id/gpt:latest

Men-deploy beban kerja

Salin YAML berikut dan simpan dalam file bernama tpu_job_gpt.yaml. Isi kolom gambar dengan gambar yang baru saja Anda buat.

kind: Service
metadata:
  name: headless-svc
spec:
  clusterIP: None
  selector:
    job-name: tpu-job-gpt
---
apiVersion: batch/v1
kind: Job
metadata:
  name: tpu-job-gpt
spec:
  backoffLimit: 0
  # Completions and parallelism should be the number of chips divided by 4.
  # (for example, 4 for a v5litepod-16)
  completions: 4
  parallelism: 4
  completionMode: Indexed
  template:
    spec:
      subdomain: headless-svc
      restartPolicy: Never
      nodeSelector:
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
        cloud.google.com/gke-tpu-topology: 4x4
      containers:
      - name: tpu-job-gpt
        image: gcr.io/<var>project-name</var>/gpt:latest
        ports:
        - containerPort: 8479
        - containerPort: 8478
        - containerPort: 8477
        - containerPort: 8476
        - containerPort: 8431 # Port to export TPU usage metrics, if supported.
        env:
        - name: PJRT_DEVICE
          value: 'TPU_C_API'
        - name: XLA_USE_BF16
          value: '1'
        command:
        - bash
        - -c
        - |
          numactl --cpunodebind=0 python3 -u examples/pytorch/xla_spawn.py   --num_cores 4 examples/pytorch/language-modeling/run_clm.py    --num_train_epochs 3 --dataset_name wikitext     --dataset_config_name wikitext-2-raw-v1 --per_device_train_batch_size 16    --per_device_eval_batch_size 16 --do_train --do_eval  --output_dir /tmp/test-clm     --overwrite_output_dir --config_name my_config_2.json --cache_dir /tmp --tokenizer_name gpt2  --block_size 1024 --optim adafactor --adafactor true --save_strategy no --logging_strategy no --fsdp "full_shard" --fsdp_config fsdp_config.json
        resources:
          requests:
            google.com/tpu: 4
          limits:
            google.com/tpu: 4

Deploy alur kerja menggunakan:

kubectl apply -f tpu_job_gpt.yaml

Pembersihan

Setelah tugas selesai berjalan, Anda dapat menghapusnya menggunakan:

kubectl delete -f tpu_job_gpt.yaml

Tutorial: Workload inferensi Host Tunggal

Tutorial ini menunjukkan cara menjalankan workload inferensi host tunggal di TPU GKE v5e untuk model terlatih dengan JAX, TensorFlow, dan PyTorch. Pada level yang tinggi, ada empat langkah terpisah yang harus dilakukan di cluster GKE:

  1. Membuat bucket Cloud Storage dan menyiapkan akses ke bucket tersebut. Anda menggunakan bucket Cloud Storage yang digunakan untuk menyimpan model terlatih.

  2. Download dan konversi model terlatih menjadi model yang kompatibel dengan TPU. Terapkan Pod GKE yang mendownload model terlatih, menggunakan Konverter Cloud TPU, dan menyimpan model yang dikonversi ke dalam bucket Cloud Storage menggunakan driver CSI Cloud Storage FUSE. Cloud TPU Converter tidak memerlukan hardware khusus. Tutorial ini menunjukkan cara mendownload model dan menjalankan Konverter Cloud TPU di kumpulan node CPU.

  3. Luncurkan server untuk model yang dikonversi. Terapkan Deployment yang menyalurkan model menggunakan framework server yang didukung oleh volume yang tersimpan di Volume Persisten ReadOnlyMany (ROX). Replika deployment harus dijalankan di node TPU Pod v5e dengan satu Pod Kubernetes per node.

  4. Deploy load balancer untuk menguji server model. Server terekspos ke permintaan eksternal menggunakan Layanan LoadBalancer. Skrip Python telah disediakan dengan permintaan contoh untuk menguji server model.

Diagram berikut menunjukkan cara permintaan dirutekan oleh Load Balancer.

Diagram yang menunjukkan pemilihan rute load balancer

Contoh deployment server

Contoh beban kerja ini dikonfigurasi dengan asumsi berikut:

  • Cluster berjalan menggunakan kumpulan node TPU v5 dengan 3 node
  • Kumpulan node menggunakan jenis mesin ct5lp-hightpu-1t dengan:
    • topologi adalah 1x1
    • jumlah chip TPU adalah 1

Manifes GKE berikut menentukan Deployment server host tunggal.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: bert-deployment
spec:
  selector:
    matchLabels:
      app: tf-bert-server
  replicas: 3 # number of nodes in node pool
  template:
    metadata:
      annotations:
        gke-gcsfuse/volumes: "true"
      labels:
        app: tf-bert-server
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 1x1  # target topology
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice  # target version
      containers:
      - name: serve-bert
        image: us-docker.pkg.dev/cloud-tpu-images/inference/tf-serving-tpu:2.13.0
        env:
        - name: MODEL_NAME
          value: "bert"
        volumeMounts:
        - mountPath: "/models/"
          name: bert-external-storage
        ports:
        - containerPort: 8500
        - containerPort: 8501
        - containerPort: 8431 # Port to export TPU usage metrics, if supported.
        resources:
          requests:
            google.com/tpu: 1 # TPU chip request
          limits:
            google.com/tpu: 1 # TPU chip request
      volumes:
      - name: bert-external-storage
        persistentVolumeClaim:
          claimName: external-storage-pvc

Jika Anda menggunakan jumlah node yang berbeda dalam kumpulan node TPU, ubah kolom replicas menjadi jumlah node.

Jika cluster Standar Anda menjalankan GKE versi 1.27 atau yang lebih lama, tambahkan kolom berikut ke manifes Anda: 

spec:
  securityContext:
    privileged: true

Anda tidak perlu menjalankan pod dalam Mode hak istimewa di GKE versi 1.28 atau yang lebih baru. Untuk mengetahui detailnya, lihat Menjalankan container tanpa mode hak istimewa.

Jika Anda menggunakan jenis mesin yang berbeda:

  • Tetapkan cloud.google.com/gke-tpu-topology ke topologi untuk jenis mesin yang Anda gunakan.
  • Tetapkan kedua kolom google.com/tpu di bawah resources agar cocok dengan jumlah chip untuk jenis mesin yang sesuai.

Penyiapan

Download skrip Python dan manifes YAML menggunakan perintah berikut:

git clone https://github.com/GoogleCloudPlatform/ai-on-gke.git

Buka direktori single-host-inference:

cd ai-on-gke/gke-tpu-examples/single-host-inference/

Menyiapkan lingkungan Python

Skrip Python yang Anda gunakan dalam tutorial ini memerlukan Python versi 3.9 atau yang lebih baru. Jangan lupa menginstal requirements.txt untuk setiap tutorial sebelum menjalankan skrip pengujian Python.

Jika tidak memiliki penyiapan Python yang tepat di lingkungan lokal, Anda dapat menggunakan Cloud Shell untuk mendownload dan menjalankan skrip Python dalam tutorial ini.

Menyiapkan cluster

  1. Buat cluster menggunakan jenis mesin e2-standard-4.

    gcloud container clusters create cluster-name \
--region your-region \
--release-channel rapid \
--num-nodes=1 \
--machine-type=e2-standard-4 \
--workload-pool=project-id.svc.id.goog \
--addons GcsFuseCsiDriver

  2. Buat kumpulan node TPU host tunggal.

Contoh beban kerja mengasumsikan hal berikut:

  • Cluster Anda berjalan dengan kumpulan node TPU v5e dengan 3 node.
  • Kumpulan node TPU menggunakan jenis mesin ct5lp-hightpu-1t.

Jika menggunakan konfigurasi cluster yang berbeda dari yang dijelaskan sebelumnya, Anda perlu mengedit manifes deployment server.

Untuk demo Difusi Stabil JAX, Anda memerlukan kumpulan node CPU dengan jenis mesin yang memiliki memori lebih dari 16 Gi (misalnya e2-standard-4). Hal ini dikonfigurasi dalam perintah gcloud container clusters create atau dengan menambahkan kumpulan node tambahan ke cluster yang ada dengan perintah berikut:

gcloud beta container node-pools create your-pool-name \
  --zone=your-cluster-zone \
  --cluster=your-cluster-name \
  --machine-type=e2-standard-4 \
  --num-nodes=1

Ganti kode berikut:

  • your-pool-name: Nama node pool yang akan dibuat.
  • your-cluster-zone: Zona tempat cluster Anda dibuat.
  • your-cluster-name: Nama cluster tempat untuk menambahkan kumpulan node.
  • your-machine-type: Jenis mesin node yang akan dibuat di kumpulan node Anda.

Menyiapkan penyimpanan model

Ada beberapa cara untuk menyimpan model agar dapat disalurkan. Dalam tutorial ini, kita akan menggunakan pendekatan berikut:

  • Untuk mengonversi model terlatih agar berfungsi di TPU, kita akan menggunakan Virtual Private Cloud yang didukung oleh Persistent Disk dengan akses ReadWriteMany (RWX).
  • Untuk menyajikan model di beberapa TPU host tunggal, kita akan menggunakan VPC yang sama yang didukung oleh bucket Cloud Storage.

Jalankan perintah berikut untuk membuat bucket Cloud Storage.

gcloud storage buckets create gs://your-bucket-name \
  --project=your-bucket-project-id \
  --location=your-bucket-location

Ganti kode berikut:

  • your-bucket-name: Nama bucket Cloud Storage.
  • your-bucket-project-id: Project ID tempat Anda membuat bucket Cloud Storage.
  • your-bucket-location: Lokasi bucket Cloud Storage Anda. Untuk meningkatkan performa, tentukan lokasi cluster GKE Anda berjalan.

Gunakan langkah-langkah berikut untuk memberi cluster GKE akses ke bucket. Untuk menyederhanakan penyiapan, contoh berikut menggunakan namespace default dan akun layanan Kubernetes default. Untuk mengetahui detailnya, lihat Mengonfigurasi akses ke bucket Cloud Storage menggunakan GKE Workload Identity.

  1. Buat akun layanan IAM untuk aplikasi Anda atau gunakan akun layanan IAM yang ada. Anda dapat menggunakan akun layanan IAM apa pun di project bucket Cloud Storage Anda.

    gcloud iam service-accounts create your-iam-service-acct \
--project=your-bucket-project-id

    Ganti kode berikut:

    • your-iam-service-acct: nama akun layanan IAM baru.
    • your-bucket-project-id: ID project tempat Anda membuat akun layanan IAM. Akun layanan IAM harus berada dalam project yang sama dengan bucket Cloud Storage Anda.

  2. Pastikan akun layanan IAM Anda memiliki peran penyimpanan yang diperlukan.

    gcloud storage buckets add-iam-policy-binding gs://your-bucket-name \
--member "serviceAccount:your-iam-service-acct@your-bucket-project-id.iam.gserviceaccount.com" \
--role "roles/storage.objectAdmin"

    Ganti kode berikut:

    • your-bucket-name: Nama bucket Cloud Storage Anda.
    • your-iam-service-acct: nama akun layanan IAM baru.
    • your-bucket-project-id: ID project tempat Anda membuat akun layanan IAM.

  3. Izinkan akun layanan Kubernetes meniru identitas akun layanan IAM dengan menambahkan binding kebijakan IAM antara kedua akun layanan tersebut. Dengan binding ini, akun layanan Kubernetes dapat bertindak sebagai akun layanan IAM.

    gcloud iam service-accounts add-iam-policy-binding your-iam-service-acct@your-bucket-project-id.iam.gserviceaccount.com \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:your-project-id.svc.id.goog[default/default]"

    Ganti kode berikut:

    • your-iam-service-acct: nama akun layanan IAM baru.
    • your-bucket-project-id: ID project tempat Anda membuat akun layanan IAM.
    • your-project-id: ID project tempat Anda membuat cluster GKE. Bucket Cloud Storage dan cluster GKE Anda dapat berada di project yang sama atau berbeda.

  4. Anotasikan akun layanan Kubernetes dengan alamat email akun layanan IAM.

    kubectl annotate serviceaccount default \
  --namespace default \
  iam.gke.io/gcp-service-account=your-iam-service-acct@your-bucket-project-id.iam.gserviceaccount.com

    Ganti kode berikut:

    • your-iam-service-acct: nama akun layanan IAM baru.
    • your-bucket-project-id: ID project tempat Anda membuat akun layanan IAM.

  5. Jalankan perintah berikut untuk mengisi nama bucket Anda dalam file YAML di demo ini:

    find . -type f -name "*.yaml" | xargs sed -i "s/BUCKET_NAME/your-bucket-name/g"

    Ganti your-bucket-name dengan nama bucket Cloud Storage Anda.

  6. Buat Klaim Volume Persisten dan Volume Persisten dengan perintah berikut:

    kubectl apply -f pvc-pv.yaml

Inferensi dan inferensi Model JAX

Instal dependensi Python untuk menjalankan skrip Python tutorial yang mengirim permintaan ke layanan model JAX.

pip install -r jax/requirements.txt

Jalankan demo penyajian JAX BERT E2E:

Demo ini menggunakan model BERT yang telah dilatih sebelumnya dari Wajah Memeluk.

Pod Kubernetes melakukan langkah-langkah berikut:

  1. Mendownload dan menggunakan skrip Python export_bert_model.py dari resource contoh untuk mendownload model bert yang telah dilatih sebelumnya ke direktori sementara.
  2. Menggunakan image Konverter Cloud TPU untuk mengonversi model terlatih dari CPU ke TPU dan menyimpan model tersebut di bucket Cloud Storage yang Anda buat selama setup.

Pod Kubernetes ini dikonfigurasi untuk berjalan di CPU kumpulan node default. Jalankan Pod dengan perintah berikut:

kubectl apply -f jax/bert/install-bert.yaml

Pastikan model telah diinstal dengan benar dengan hal berikut:

kubectl get pods install-bert

Perlu waktu beberapa menit bagi STATUS untuk membaca Completed.

Meluncurkan server model TF untuk model tersebut

Contoh beban kerja dalam tutorial ini mengasumsikan hal berikut:

  • Cluster berjalan menggunakan kumpulan node TPU v5 dengan tiga node
  • Kumpulan node menggunakan jenis mesin ct5lp-hightpu-1t yang berisi satu chip TPU.

Jika menggunakan konfigurasi cluster yang berbeda dari yang dijelaskan sebelumnya, Anda perlu mengedit manifes deployment server.

Terapkan deployment
kubectl apply -f jax/bert/serve-bert.yaml

Pastikan server berjalan dengan beberapa hal berikut:

kubectl get deployment bert-deployment

AVAILABLE memerlukan waktu satu menit untuk membaca 3.

Menerapkan layanan load balancer
kubectl apply -f jax/bert/loadbalancer.yaml

Verifikasi bahwa load balancer siap untuk traffic eksternal dengan hal berikut:

kubectl get svc tf-bert-service

Mungkin perlu waktu beberapa menit bagi EXTERNAL_IP untuk memiliki IP yang terdaftar.

Mengirim permintaan ke server model

Mendapatkan IP eksternal dari layanan load balancer:

EXTERNAL_IP=$(kubectl get services tf-bert-service --output jsonpath='{.status.loadBalancer.ingress[0].ip}')

Jalankan skrip untuk mengirim permintaan ke server:

python3 jax/bert/bert_request.py $EXTERNAL_IP

Output yang diharapkan:

For input "The capital of France is [MASK].", the result is ". the capital of france is paris.."
For input "Hello my name [MASK] Jhon, how can I [MASK] you?", the result is ". hello my name is jhon, how can i help you?."
Pembersihan

Untuk membersihkan resource, jalankan kubectl delete dalam urutan terbalik.

kubectl delete -f jax/bert/loadbalancer.yaml
kubectl delete -f jax/bert/serve-bert.yaml
kubectl delete -f jax/bert/install-bert.yaml

Jalankan demo penayangan JAX Stable Diffusion E2E

Demo ini menggunakan model Difusi Stabil yang telah dilatih sebelumnya dari Wajah Memeluk.

Ekspor model tersimpan TF2 yang kompatibel dengan TPU dari model Flax Stable Diffusion

Untuk mengekspor model difusi stabil, cluster harus memiliki kumpulan node CPU dengan jenis mesin yang memiliki memori yang tersedia lebih dari 16Gi+ seperti yang dijelaskan dalam Penyiapan cluster.

Pod Kubernetes menjalankan langkah-langkah berikut:

  1. Mendownload dan menggunakan skrip Python export_stable_diffusion_model.py dari resource contoh untuk mendownload model difusi stabil yang telah dilatih sebelumnya ke direktori sementara.
  2. Menggunakan image Konverter Cloud TPU untuk mengonversi model terlatih dari CPU ke TPU dan menyimpan model tersebut di bucket Cloud Storage yang Anda buat selama penyiapan penyimpanan.

Pod Kubernetes ini dikonfigurasi untuk berjalan di kumpulan node CPU default. Jalankan Pod dengan perintah berikut:

kubectl apply -f jax/stable-diffusion/install-stable-diffusion.yaml

Pastikan model telah diinstal dengan benar dengan hal berikut:

kubectl get pods install-stable-diffusion

Perlu waktu beberapa menit bagi STATUS untuk membaca Completed.

Meluncurkan penampung server model TF untuk model tersebut

Contoh beban kerja telah dikonfigurasi dengan asumsi berikut:

  • cluster berjalan menggunakan kumpulan node TPU v5 dengan tiga node
  • kumpulan node menggunakan jenis mesin ct5lp-hightpu-1t, dengan:
    • topologi adalah 1x1
    • jumlah chip TPU adalah 1

Jika menggunakan konfigurasi cluster yang berbeda dari yang dijelaskan sebelumnya, Anda perlu mengedit manifes deployment server.

Terapkan deployment:

kubectl apply -f jax/stable-diffusion/serve-stable-diffusion.yaml

Pastikan server berjalan seperti yang diharapkan:

kubectl get deployment stable-diffusion-deployment

AVAILABLE memerlukan waktu satu menit untuk membaca 3.

Terapkan layanan load balancer:

kubectl apply -f jax/stable-diffusion/loadbalancer.yaml

Verifikasi bahwa load balancer siap untuk traffic eksternal dengan hal berikut:

kubectl get svc tf-stable-diffusion-service

Mungkin perlu waktu beberapa menit bagi EXTERNAL_IP untuk memiliki IP yang terdaftar.

Mengirim permintaan ke server model

Dapatkan IP eksternal dari load balancer:

EXTERNAL_IP=$(kubectl get services tf-stable-diffusion-service --output jsonpath='{.status.loadBalancer.ingress[0].ip}')

Menjalankan skrip untuk mengirim permintaan ke server

python3 jax/stable-diffusion/stable_diffusion_request.py $EXTERNAL_IP

Output yang diharapkan:

Perintahnya adalah Painting of a squirrel skating in New York dan gambar output akan disimpan sebagai stable_diffusion_images.jpg di direktori Anda saat ini.

Pembersihan

Untuk membersihkan resource, jalankan kubectl delete dalam urutan terbalik.

kubectl delete -f jax/stable-diffusion/loadbalancer.yaml
kubectl delete -f jax/stable-diffusion/serve-stable-diffusion.yaml
kubectl delete -f jax/stable-diffusion/install-stable-diffusion.yaml

Jalankan demo penyaluran TensorFlow ResNet-50 E2E:

Instal dependensi Python untuk menjalankan skrip Python tutorial yang mengirim permintaan ke layanan model TF.

pip install -r tf/resnet50/requirements.txt
Langkah 1: Konversikan model

Terapkan konversi model:

kubectl apply -f tf/resnet50/model-conversion.yml

Pastikan model telah diinstal dengan benar dengan hal berikut:

kubectl get pods resnet-model-conversion

Perlu waktu beberapa menit bagi STATUS untuk membaca Completed.

Langkah 2: Tayangkan model dengan TensorFlow Serve

Terapkan deployment penyaluran model:

kubectl apply -f tf/resnet50/deployment.yml

Pastikan server berjalan seperti yang diharapkan dengan perintah berikut:

kubectl get deployment resnet-deployment

AVAILABLE memerlukan waktu satu menit untuk membaca 3.

Terapkan layanan load balancer:

kubectl apply -f tf/resnet50/loadbalancer.yml

Verifikasi bahwa load balancer siap untuk traffic eksternal dengan hal berikut:

kubectl get svc resnet-service

Mungkin perlu waktu beberapa menit bagi EXTERNAL_IP untuk memiliki IP yang terdaftar.

Langkah 3: Kirim permintaan pengujian ke server model

Dapatkan IP eksternal dari load balancer:

EXTERNAL_IP=$(kubectl get services resnet-service --output jsonpath='{.status.loadBalancer.ingress[0].ip}')

Jalankan skrip permintaan pengujian (HTTP) untuk mengirim permintaan ke server model.

python3 tf/resnet50/request.py --host $EXTERNAL_IP

Responsnya akan terlihat seperti berikut:

Predict result: ['ImageNet ID: n07753592, Label: banana, Confidence: 0.94921875',
'ImageNet ID: n03532672, Label: hook, Confidence: 0.0223388672', 'ImageNet ID: n07749582,
Label: lemon, Confidence: 0.00512695312
Langkah 4: Pembersihan

Untuk membersihkan resource, jalankan perintah kubectl delete berikut:

kubectl delete -f tf/resnet50/loadbalancer.yml
kubectl delete -f tf/resnet50/deployment.yml
kubectl delete -f tf/resnet50/model-conversion.yml

Pastikan Anda menghapus kumpulan node dan cluster GKE setelah selesai.

Inferensi dan inferensi model PyTorch

Instal dependensi Python untuk menjalankan skrip Python tutorial yang mengirim permintaan ke layanan model PyTorch:

pip install -r pt/densenet161/requirements.txt

Jalankan demo penyajian TorchServe Densenet161 E2E:

  1. Buat arsip model.

    1. Terapkan arsip model:
    kubectl apply -f pt/densenet161/model-archive.yml
    1. Pastikan model telah diinstal dengan benar dengan hal berikut:
    kubectl get pods densenet161-model-archive

    Perlu waktu beberapa menit bagi STATUS untuk membaca Completed.

  2. Menyajikan Model dengan TorchServe:

    1. Terapkan Deployment Penyajian Model:

      kubectl apply -f pt/densenet161/deployment.yml

    2. Pastikan server berjalan seperti yang diharapkan dengan perintah berikut:

      kubectl get deployment densenet161-deployment

      AVAILABLE memerlukan waktu satu menit untuk membaca 3.

    3. Terapkan layanan load balancer:

      kubectl apply -f pt/densenet161/loadbalancer.yml

      Pastikan load balancer siap untuk traffic eksternal menggunakan perintah berikut:

      kubectl get svc densenet161-service

      Mungkin perlu waktu beberapa menit bagi EXTERNAL_IP untuk memiliki IP yang terdaftar.

  3. Kirim permintaan pengujian ke server model:

    1. Dapatkan IP eksternal dari load balancer:

      EXTERNAL_IP=$(kubectl get services densenet161-service --output jsonpath='{.status.loadBalancer.ingress[0].ip}')

    2. Jalankan skrip permintaan pengujian untuk mengirim permintaan (HTTP) ke server model.:

      python3 pt/densenet161/request.py --host $EXTERNAL_IP

      Anda akan melihat respons seperti ini:

      Request successful. Response: {'tabby': 0.47878125309944153, 'lynx': 0.20393909513950348, 'tiger_cat': 0.16572578251361847, 'tiger': 0.061157409101724625, 'Egyptian_cat': 0.04997897148132324

  4. Bersihkan resource dengan menjalankan perintah kubectl delete berikut:

    kubectl delete -f pt/densenet161/loadbalancer.yml
kubectl delete -f pt/densenet161/deployment.yml
kubectl delete -f pt/densenet161/model-archive.yml

    Pastikan Anda menghapus kumpulan node dan cluster GKE setelah selesai.

Memecahkan masalah umum

Anda dapat menemukan informasi pemecahan masalah GKE di Memecahkan masalah TPU diGKE.

Inisialisasi TPU gagal

Jika mengalami error berikut, pastikan Anda menjalankan penampung TPU dalam mode hak istimewa atau telah meningkatkan ulimit di dalam container. Untuk informasi selengkapnya, lihat Menjalankan tanpa mode hak istimewa.

TPU platform initialization failed: FAILED_PRECONDITION: Couldn't mmap: Resource
temporarily unavailable.; Unable to create Node RegisterInterface for node 0,
config: device_path:      "/dev/accel0" mode: KERNEL debug_data_directory: ""
dump_anomalies_only: true crash_in_debug_dump: false allow_core_dump: true;
could not create driver instance

Deadlock penjadwalan

Misalkan Anda memiliki dua tugas (Pekerjaan A dan Tugas B) dan keduanya dijadwalkan pada irisan TPU dengan topologi TPU tertentu (misalnya, v4-32). Selain itu, anggaplah Anda memiliki dua irisan TPU v4-32 dalam cluster GKE; kita akan memanggil potongan X dan irisan Y tersebut. Karena cluster Anda memiliki kapasitas yang cukup untuk menjadwalkan kedua tugas, secara teori kedua tugas harus dijadwalkan dengan cepat – satu tugas di masing-masing dari dua irisan v4-32 TPU.

Namun, tanpa perencanaan yang cermat, Anda mungkin dapat mengalami deadlock penjadwalan. Misalkan penjadwal Kubernetes menjadwalkan satu Pod dari Tugas A pada slice X, lalu menjadwalkan satu Pod dari Tugas B pada slice X. Dalam hal ini, mengingat aturan afinitas Pod untuk Tugas A, penjadwal akan mencoba menjadwalkan semua Pod yang tersisa untuk Tugas A di slice X. Begitu juga untuk Pekerjaan B. Dengan demikian, Tugas A maupun Tugas B tidak dapat dijadwalkan sepenuhnya pada satu irisan. Hasilnya akan berupa deadlock penjadwalan.

Untuk menghindari risiko deadlock penjadwalan, Anda dapat menggunakan anti-afinitas Pod dengan cloud.google.com/gke-nodepool sebagai topologyKey seperti yang ditunjukkan pada contoh berikut:

apiVersion: batch/v1
kind: Job
metadata:
 name: pi
spec:
 parallelism: 2
 template:
   metadata:
     labels:
       job: pi
   spec:
     affinity:
       podAffinity:
         requiredDuringSchedulingIgnoredDuringExecution:
         - labelSelector:
             matchExpressions:
             - key: job
               operator: In
               values:
               - pi
           topologyKey: cloud.google.com/gke-nodepool
       podAntiAffinity:
         requiredDuringSchedulingIgnoredDuringExecution:
         - labelSelector:
             matchExpressions:
             - key: job
               operator: NotIn
               values:
               - pi
           topologyKey: cloud.google.com/gke-nodepool
           namespaceSelector:
             matchExpressions:
             - key: kubernetes.io/metadata.name
               operator: NotIn
               values:
               - kube-system
     containers:
     - name: pi
       image: perl:5.34.0
       command: ["sleep",  "60"]
     restartPolicy: Never
 backoffLimit: 4

Membuat resource kumpulan node TPU dengan Terraform

Anda juga dapat menggunakan Terraform untuk mengelola resource cluster dan node pool.

Membuat kumpulan node slice TPU multi-host di Cluster GKE yang ada

Jika sudah memiliki Cluster dan ingin membuat kumpulan node TPU multi-host, Anda dapat menggunakan cuplikan Terraform berikut:

resource "google_container_cluster" "cluster_multi_host" {
  …
  release_channel {
    channel = "RAPID"
  }
  workload_identity_config {
    workload_pool = "my-gke-project.svc.id.goog"
  }
  addons_config {
    gcs_fuse_csi_driver_config {
      enabled = true
    }
  }
}

resource "google_container_node_pool" "multi_host_tpu" {
  provider           = google-beta
  project            = "<var>your-project</var>"
  name               = "<var>your-node-pool</var>"
  location           = "<var>us-central2</var>"
  node_locations     = ["<var>us-central2-b</var>"]
  cluster            = google_container_cluster.cluster_multi_host.name
  initial_node_count = 2

  node_config {
    machine_type = "ct4p-hightpu-4t"
    reservation_affinity {
      consume_reservation_type = "SPECIFIC_RESERVATION"
      key = "compute.googleapis.com/reservation-name"
      values = ["<var>your-reservation-name</var>"]
    }
    workload_metadata_config {
      mode = "GKE_METADATA"
    }
  }

  placement_policy {
    type = "COMPACT"
    tpu_topology = "2x2x2"
  }
}

Ganti nilai berikut:

  • your-project: Project Google Cloud tempat Anda menjalankan beban kerja.
  • your-node-pool: Nama kumpulan node yang Anda buat.
  • us-central2: Region tempat Anda menjalankan beban kerja.
  • us-central2-b: Zona tempat Anda menjalankan beban kerja.
  • your-reservation-name: Nama pemesanan Anda.

Membuat kumpulan node slice TPU host tunggal di Cluster GKE yang ada

Gunakan cuplikan Terraform berikut:

resource "google_container_cluster" "cluster_single_host" {
  …
  cluster_autoscaling {
    autoscaling_profile = "OPTIMIZE_UTILIZATION"
  }
  release_channel {
    channel = "RAPID"
  }
  workload_identity_config {
  workload_pool = "<var>your-project-id</var>.svc.id.goog"
  }
  addons_config {
    gcs_fuse_csi_driver_config {
      enabled = true
    }
  }
}

resource "google_container_node_pool" "single_host_tpu" {
  provider           = google-beta
  project            = "<var>your-project</var>"
  name               = "<var>your-node-pool</var>"
  location           = "<var>us-central2</var>"
  node_locations     = ["<var>us-central2-b</var>"]
  cluster            = google_container_cluster.cluster_single_host.name
  initial_node_count = 0
  autoscaling {
    total_min_node_count = 2
    total_max_node_count = 22
    location_policy      = "ANY"
  }

  node_config {
    machine_type = "ct4p-hightpu-4t"
    workload_metadata_config {
      mode = "GKE_METADATA"
    }
  }
}

Ganti nilai berikut:

  • your-project: Project Google Cloud tempat Anda menjalankan beban kerja.
  • your-node-pool: Nama kumpulan node yang Anda buat.
  • us-central2: Region tempat Anda menjalankan beban kerja.
  • us-central2-b: Zona tempat Anda menjalankan beban kerja.