Halaman ini diterjemahkan oleh Cloud Translation API.

Menyajikan LLM menggunakan TPU Trillium (v6e) di GKE dengan vLLM

Standard Autopilot

Tutorial ini menunjukkan cara menayangkan model bahasa besar (LLM) menggunakan Unit Pemrosesan Tensor (TPU) di Google Kubernetes Engine (GKE) dengan framework penayangan vLLM. Dalam tutorial ini, Anda akan menayangkan Llama 3.1 70b, menggunakan TPU Trillium (v6e), dan menyiapkan penskalaan otomatis Pod horizontal menggunakan metrik server vLLM.

Dokumen ini adalah titik awal yang baik jika Anda memerlukan kontrol terperinci, skalabilitas, ketahanan, portabilitas, dan efektivitas biaya Kubernetes terkelola saat men-deploy dan menayangkan beban kerja AI/ML.

Latar belakang

Dengan menggunakan TPU v6e di GKE, Anda dapat menerapkan solusi penayangan yang andal dan siap produksi dengan semua manfaat Kubernetes terkelola, termasuk skalabilitas yang efisien dan ketersediaan yang lebih tinggi. Bagian ini menjelaskan teknologi utama yang digunakan dalam panduan ini.

TPU Trillium (v6e)

TPU adalah sirkuit terintegrasi khusus aplikasi (ASIC) Google yang dikembangkan secara khusus. TPU digunakan untuk mempercepat model machine learning dan AI yang dibuat menggunakan framework seperti TensorFlow, PyTorch, dan JAX. Tutorial ini menggunakan TPU v6e, yang merupakan akselerator AI generasi terbaru Google.

Sebelum menggunakan TPU di GKE, sebaiknya selesaikan jalur pembelajaran berikut:

Pelajari arsitektur sistem TPU v6e.
Pelajari TPU di GKE.

vLLM

vLLM adalah framework open source yang sangat dioptimalkan untuk menayangkan LLM. vLLM dapat meningkatkan throughput penayangan di GPU, dengan fitur seperti berikut:

Penerapan transformer yang dioptimalkan dengan PagedAttention.
Pengelompokan berkelanjutan untuk meningkatkan throughput penayangan secara keseluruhan.
Paralelisme tensor dan penayangan terdistribusi di beberapa TPU.

Untuk mempelajari lebih lanjut, lihat dokumentasi vLLM.

Cloud Storage FUSE

Cloud Storage FUSE menyediakan akses dari cluster GKE Anda ke Cloud Storage untuk bobot model yang berada di bucket penyimpanan objek. Dalam tutorial ini, bucket Cloud Storage yang dibuat awalnya akan kosong. Saat vLLM dimulai, GKE akan mendownload model dari Hugging Face dan menyimpan bobot ke dalam cache ke bucket Cloud Storage. Saat Pod dimulai ulang, atau penskalaan deployment, pemuatan model berikutnya akan mendownload data yang di-cache dari bucket Cloud Storage, yang memanfaatkan download paralel untuk performa yang optimal.

Untuk mempelajari lebih lanjut, lihat dokumentasi driver CSI Cloud Storage FUSE.

Tujuan

Tutorial ini ditujukan untuk engineer MLOps atau DevOps atau administrator platform yang ingin menggunakan kemampuan orkestrasi GKE untuk menayangkan LLM.

Tutorial ini membahas langkah-langkah berikut:

Buat cluster GKE dengan topologi TPU v6e yang direkomendasikan berdasarkan karakteristik model.
Deploy framework vLLM di node pool dalam cluster Anda.
Gunakan framework vLLM untuk menayangkan Llama 3.1 70b menggunakan load balancer.
Menyiapkan penskalaan otomatis Pod horizontal menggunakan metrik server vLLM.
Menayangkan model.

Sebelum memulai

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the required API.

Enable the API

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the required API.

Enable the API

Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin, roles/iam.securityAdmin, roles/artifactregistry.writer, roles/container.clusterAdmin
Check for the roles
1. In the Google Cloud console, go to the IAM page.
  Go to IAM
2. Select the project.
3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.
4. For all rows that specify or include you, check the Role colunn to see whether the list of roles includes the required roles.
Grant the roles
1. In the Google Cloud console, go to the IAM page.
  Buka IAM
2. Pilih project.
3. Klik Berikan akses.
4. Di kolom New principals, masukkan ID pengguna Anda. Ini biasanya adalah alamat email untuk Akun Google.
5. Di daftar Pilih peran, pilih peran.
6. Untuk memberikan peran tambahan, klik Tambahkan peran lain, lalu tambahkan setiap peran tambahan.
7. Klik Simpan.

Buat akun Hugging Face, jika Anda belum memilikinya.
Pastikan project Anda memiliki kuota yang memadai untuk Cloud TPU di GKE.

Menyiapkan lingkungan

Di bagian ini, Anda akan menyediakan resource yang diperlukan untuk men-deploy vLLM dan model.

Mendapatkan akses ke model

Anda harus menandatangani perjanjian izin untuk menggunakan Llama 3.1 70b di repositori Hugging Face.

Membuat token akses

Jika Anda belum memilikinya, buat token Hugging Face baru:

Klik Profil Anda > Setelan > Token Akses.
Pilih New Token.
Tentukan Nama pilihan Anda dan Peran minimal Read.
Pilih Buat token.

Meluncurkan Cloud Shell

Dalam tutorial ini, Anda akan menggunakan Cloud Shell untuk mengelola resource yang dihosting di Google Cloud. Cloud Shell telah diinstal dengan software yang Anda perlukan untuk tutorial ini, termasuk kubectl dan gcloud CLI.

Untuk menyiapkan lingkungan Anda dengan Cloud Shell, ikuti langkah-langkah berikut:

Di konsol Google Cloud, luncurkan sesi Cloud Shell dengan mengklik Aktifkan Cloud Shell di konsol Google Cloud. Tindakan ini akan meluncurkan sesi di panel bawah Konsol Google Cloud.
Tetapkan variabel lingkungan default:
```
gcloud config set project PROJECT_ID && \
export PROJECT_ID=$(gcloud config get project) && \
export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)") && \
export CLUSTER_NAME=CLUSTER_NAME && \
export ZONE=ZONE && \
export HF_TOKEN=HUGGING_FACE_TOKEN && \
export CLUSTER_VERSION=CLUSTER_VERSION && \
export GSBUCKET=GSBUCKET && \
export KSA_NAME=KSA_NAME && \
export NAMESPACE=NAMESPACE
```
Ganti nilai berikut:
- PROJECT_ID: project ID Google Cloud Anda.
- CLUSTER_NAME: nama cluster GKE Anda.
- ZONE: zona yang mendukung TPU v6e.
- CLUSTER_VERSION: versi GKE, yang harus mendukung jenis mesin yang ingin Anda gunakan. Perhatikan bahwa versi GKE default mungkin tidak tersedia untuk TPU target Anda. TPU v6e didukung di GKE versi 1.31.2-gke.1115000 atau yang lebih baru.
- GSBUCKET: nama bucket Cloud Storage yang akan digunakan untuk Cloud Storage FUSE.
- KSA_NAME: nama ServiceAccount Kubernetes yang digunakan untuk mengakses bucket Cloud Storage. Akses bucket diperlukan agar Cloud Storage FUSE berfungsi.
- NAMESPACE: namespace Kubernetes tempat Anda ingin men-deploy aset vLLM.

Membuat cluster GKE

Anda dapat menayangkan LLM di TPU dalam cluster GKE Autopilot atau Standard. Sebaiknya gunakan cluster Autopilot untuk pengalaman Kubernetes yang dikelola sepenuhnya. Untuk memilih mode operasi GKE yang paling sesuai untuk workload Anda, lihat Memilih mode operasi GKE.

Autopilot

Buat cluster GKE Autopilot:
```
gcloud container clusters create-auto CLUSTER_NAME \
    --cluster-version=CLUSTER_VERSION \
    --release-channel=rapid
```
Ganti PROJECT_ID dengan project ID Google Cloud Anda.

Catatan: Jika instance Cloud Shell Anda terputus selama eksekusi tutorial, ulangi langkah sebelumnya.

Standard

Buat cluster GKE Standard:

gcloud container clusters create CLUSTER_NAME \
    --project=PROJECT_ID \
    --zone=ZONE \
    --cluster-version=CLUSTER_VERSION \
    --release-channel=rapid \
    --workload-pool=PROJECT_ID.svc.id.goog \
    --addons GcsFuseCsiDriver

Buat node pool slice TPU:
```
gcloud container node-pools create tpunodepool \
    --zone=ZONE \
    --num-nodes=1 \
    --machine-type=ct6e-standard-8t \
    --cluster=CLUSTER_NAME \
    --enable-autoscaling --total-min-nodes=1 --total-max-nodes=2
```
GKE membuat resource berikut untuk LLM:
- Cluster GKE Standard yang menggunakan Workload Identity Federation untuk GKE dan mengaktifkan driver CSI Cloud Storage FUSE.
- Node pool TPU v6e dengan jenis mesin ct6e-standard-8t. Node pool ini memiliki satu node, delapan chip TPU, dan penskalaan otomatis diaktifkan.

Mengonfigurasi kubectl untuk berkomunikasi dengan cluster Anda

Untuk mengonfigurasi kubectl agar dapat berkomunikasi dengan cluster Anda, jalankan perintah berikut:

  gcloud container clusters get-credentials CLUSTER_NAME --location=ZONE

Membuat Secret Kubernetes untuk kredensial Hugging Face

Membuat namespace. Anda dapat melewati langkah ini jika menggunakan namespace default:
```
kubectl create namespace NAMESPACE
```

Buat Secret Kubernetes yang berisi token Hugging Face, jalankan perintah berikut:

kubectl create secret generic hf-secret \
    --from-literal=hf_api_token=HUGGING_FACE_TOKEN \
    --namespace NAMESPACE

Membuat bucket Cloud Storage

Jalankan perintah berikut di Cloud Shell:

gcloud storage buckets create gs://GSBUCKET \
    --uniform-bucket-level-access

Tindakan ini akan membuat bucket Cloud Storage untuk menyimpan file model yang Anda download dari Hugging Face.

Menyiapkan Akun Layanan Kubernetes untuk mengakses bucket

Buat Akun Layanan Kubernetes:

kubectl create serviceaccount KSA_NAME --namespace NAMESPACE

Berikan akses baca-tulis ke Akun Layanan Kubernetes untuk mengakses bucket Cloud Storage:

gcloud storage buckets add-iam-policy-binding gs://GSBUCKET \
  --member "principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/NAMESPACE/sa/KSA_NAME" \
  --role "roles/storage.objectUser"

Atau, Anda dapat memberikan akses baca-tulis ke semua bucket Cloud Storage dalam project:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
--member "principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/NAMESPACE/sa/KSA_NAME" \
--role "roles/storage.objectUser"
```
GKE membuat resource berikut untuk LLM:
1. Bucket Cloud Storage untuk menyimpan model yang didownload dan cache kompilasi. Driver CSI Cloud Storage FUSE membaca konten bucket.
2. Volume dengan caching file diaktifkan dan fitur download paralel Cloud Storage FUSE.
Praktik terbaik:
Gunakan cache file yang didukung oleh tmpfs atau Hyperdisk / Persistent Disk bergantung pada ukuran konten model yang diharapkan, misalnya, file bobot. Dalam tutorial ini, Anda akan menggunakan cache file Cloud Storage FUSE yang didukung oleh RAM.

Mem-build dan men-deploy image TPU

Buat penampung server vLLM:

Clone repositori vLLM dan build image:

git clone https://github.com/vllm-project/vllm && cd vllm && git reset --hard cd34029e91ad2d38a58d190331a65f9096c0b157 && docker build -f Dockerfile.tpu . -t vllm-tpu

Mengirim image ke Artifact Registry:

gcloud artifacts repositories create vllm-tpu --repository-format=docker --location=REGION_NAME && \
gcloud auth configure-docker REGION_NAME-docker.pkg.dev && \
docker image tag vllm-tpu REGION_NAME-docker.pkg.dev/PROJECT_ID/vllm-tpu/vllm-tpu:latest && \
docker push REGION_NAME-docker.pkg.dev/PROJECT_ID/vllm-tpu/vllm-tpu:latest

Men-deploy server model vLLM

Untuk men-deploy server model vLLM, ikuti langkah-langkah berikut:

Periksa manifes Deployment yang disimpan sebagai vllm-llama3-70b.yaml. Deployment adalah API Kubernetes yang memungkinkan Anda menjalankan beberapa replika Pod di antara node dalam cluster:


apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-tpu
spec:
  replicas: 1
  selector:
    matchLabels:
      app: vllm-tpu
  template:
    metadata:
      labels:
        app: vllm-tpu
      annotations:
        gke-gcsfuse/volumes: "true"
        gke-gcsfuse/cpu-limit: "0"
        gke-gcsfuse/memory-limit: "0"
        gke-gcsfuse/ephemeral-storage-limit: "0"
    spec:
      serviceAccountName: KSA_NAME
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x4
        cloud.google.com/gke-tpu-accelerator: tpu-v6e-slice
      containers:
      - name: vllm-tpu
        image: REGION_NAME-docker.pkg.dev/PROJECT_ID/vllm-tpu/vllm-tpu:latest
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --host=0.0.0.0
        - --port=8000
        - --tensor-parallel-size=8
        - --max-model-len=8192
        - --model=meta-llama/Meta-Llama-3.1-70B
        - --download-dir=/data
        env: 
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        - name: VLLM_XLA_CACHE_PATH
          value: "/data"
        ports:
        - containerPort: 8000
        resources:
          limits:
            google.com/tpu: 8
        readinessProbe:
          tcpSocket:
            port: 8000
          initialDelaySeconds: 15
          periodSeconds: 10
        volumeMounts:
        - name: gcs-fuse-csi-ephemeral
          mountPath: /data
        - name: dshm
          mountPath: /dev/shm
      volumes:
      - name: gke-gcsfuse-cache
        emptyDir:
          medium: Memory
      - name: dshm
        emptyDir:
          medium: Memory
      - name: gcs-fuse-csi-ephemeral
        csi:
          driver: gcsfuse.csi.storage.gke.io
          volumeAttributes:
            bucketName: GSBUCKET
            mountOptions: "implicit-dirs,file-cache:enable-parallel-downloads:true,file-cache:parallel-downloads-per-file:100,file-cache:max-parallel-downloads:-1,file-cache:download-chunk-size-mb:10,file-cache:max-size-mb:-1"
---
apiVersion: v1
kind: Service
metadata:
  name: vllm-service
spec:
  selector:
    app: vllm-tpu
  type: LoadBalancer	
  ports:
    - name: http
      protocol: TCP
      port: 8000  
      targetPort: 8000

Terapkan manifes dengan menjalankan perintah berikut:

kubectl apply -f vllm-llama3-70b.yaml -n NAMESPACE

Lihat log dari server model yang berjalan:

kubectl logs -f -l app=vllm-tpu -n NAMESPACE

Output-nya akan terlihat seperti berikut:

INFO 09-20 19:03:48 launcher.py:19] Available routes are:
INFO 09-20 19:03:48 launcher.py:27] Route: /openapi.json, Methods: GET, HEAD
INFO 09-20 19:03:48 launcher.py:27] Route: /docs, Methods: GET, HEAD
INFO 09-20 19:03:48 launcher.py:27] Route: /docs/oauth2-redirect, Methods: GET, HEAD
INFO 09-20 19:03:48 launcher.py:27] Route: /redoc, Methods: GET, HEAD
INFO 09-20 19:03:48 launcher.py:27] Route: /health, Methods: GET
INFO 09-20 19:03:48 launcher.py:27] Route: /tokenize, Methods: POST
INFO 09-20 19:03:48 launcher.py:27] Route: /detokenize, Methods: POST
INFO 09-20 19:03:48 launcher.py:27] Route: /v1/models, Methods: GET
INFO 09-20 19:03:48 launcher.py:27] Route: /version, Methods: GET
INFO 09-20 19:03:48 launcher.py:27] Route: /v1/chat/completions, Methods: POST
INFO 09-20 19:03:48 launcher.py:27] Route: /v1/completions, Methods: POST
INFO 09-20 19:03:48 launcher.py:27] Route: /v1/embeddings, Methods: POST
INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8080 (Press CTRL+C to quit)
(RayWorkerWrapper pid=25987) INFO 09-20 19:03:46 tpu_model_runner.py:290] Compilation for decode done in 202.93 s.
(RayWorkerWrapper pid=25987) INFO 09-20 19:03:46 tpu_model_runner.py:283] batch_size: 256, seq_len: 1 [repeated 7x across cluster]
INFO 09-20 19:03:53 metrics.py:351] Avg prompt throughput: 0.0 tokens/s, Avg generation throughput: 0.0 tokens/s, Running: 0 reqs, Swapped: 0 reqs, Pending: 0 reqs, GPU KV cache usage: 0.0%, CPU KV cache usage: 0.0%.

Menayangkan model

Jalankan perintah berikut untuk mendapatkan alamat IP eksternal Layanan:

export vllm_service=$(kubectl get service vllm-service -o jsonpath='{.status.loadBalancer.ingress[0].ip}')

Di terminal baru, berinteraksilah dengan model menggunakan curl:

curl http://$vllm_service:8000/v1/completions \
-H "Content-Type: application/json" \
-d '{
    "model": "meta-llama/Meta-Llama-3.1-70B",
    "prompt": "San Francisco is a",
    "max_tokens": 7,
    "temperature": 0
}'

Outputnya akan mirip dengan berikut ini:

{"id":"cmpl-6b4bb29482494ab88408d537da1e608f","object":"text_completion","created":1727822657,"model":"meta-llama/Meta-Llama-3-8B","choices":[{"index":0,"text":" top holiday destination featuring scenic beauty and","logprobs":null,"finish_reason":"length","stop_reason":null,"prompt_logprobs":null}],"usage":{"prompt_tokens":5,"total_tokens":12,"completion_tokens":7}}

Menyiapkan autoscaler kustom

Di bagian ini, Anda akan menyiapkan penskalaan otomatis Pod horizontal menggunakan metrik Prometheus kustom. Anda menggunakan metrik Google Cloud Managed Service for Prometheus dari server vLLM.

Untuk mempelajari lebih lanjut, lihat Google Cloud Managed Service for Prometheus. Fitur ini harus diaktifkan secara default di cluster GKE.

Siapkan Adaptor Stackdriver Metrik Kustom di cluster Anda:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml

Tambahkan peran Monitoring Viewer ke akun layanan yang digunakan Adaptor Stackdriver Metrik Kustom:

gcloud projects add-iam-policy-binding projects/PROJECT_ID \
    --role roles/monitoring.viewer \
    --member=principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/custom-metrics/sa/custom-metrics-stackdriver-adapter

Simpan manifes berikut sebagai vllm_pod_monitor.yaml:


apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
 name: vllm-pod-monitoring
spec:
 selector:
   matchLabels:
     app: vllm-tpu
 endpoints:
 - path: /metrics
   port: 8000
   interval: 15s

Terapkan ke cluster:
```
kubectl apply -f vllm_pod_monitor.yaml
```

Membuat beban di endpoint vLLM

Buat beban ke server vLLM untuk menguji cara GKE melakukan penskalaan otomatis dengan metrik vLLM kustom.

Jalankan skrip bash (load.sh) untuk mengirim N jumlah permintaan paralel ke endpoint vLLM:

#!/bin/bash
N=PARALLEL_PROCESSES
export vllm_service=$(kubectl get service vllm-service -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
for i in $(seq 1 $N); do
  while true; do
    curl http://$vllm_service:8000/v1/completions -H "Content-Type: application/json" -d '{"model": "meta-llama/Meta-Llama-3.1-70B", "prompt": "Write a story about san francisco", "max_tokens": 100, "temperature": 0}'
  done &  # Run in the background
done
wait

Ganti PARALLEL_PROCESSES dengan jumlah proses paralel yang ingin Anda jalankan.

Jalankan skrip bash:
```
nohup ./load.sh &
```

Memastikan bahwa Google Cloud Managed Service for Prometheus menyerap metrik

Setelah Google Cloud Managed Service for Prometheus mengambil metrik dan Anda menambahkan beban ke endpoint vLLM, Anda dapat melihat metrik di Cloud Monitoring.

Di Konsol Google Cloud, buka halaman Metrics Explorer.

Buka Metrics Explorer
Klik < > PromQL.

Masukkan kueri berikut untuk mengamati metrik traffic:

vllm:avg_generation_throughput_toks_per_s{cluster='CLUSTER_NAME_HERE'}

Dalam grafik garis, metrik vLLM diskalakan dari 0 (pramuat) ke nilai (pascamuat). Grafik ini mengonfirmasi bahwa metrik vLLM Anda sedang diserap ke dalam Google Cloud Managed Service for Prometheus.

Gambar berikut adalah contoh grafik setelah eksekusi skrip pemuatan. Dalam hal ini, server model menayangkan sekitar 2.000 token generasi per detik.

uji

Men-deploy konfigurasi Horizontal Pod Autoscaler

Di bagian ini, Anda akan men-deploy konfigurasi Horizontal Pod Autoscaler.

Simpan manifes berikut sebagai vllm-hpa.yaml:


apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
 name: vllm-hpa
spec:
 scaleTargetRef:
   apiVersion: apps/v1
   kind: Deployment
   name: vllm-tpu
 minReplicas: 1
 maxReplicas: 2
 metrics:
   - type: Pods
     pods:
       metric:
         name: prometheus.googleapis.com|vllm:num_requests_waiting|gauge
       target:
         type: AverageValue
         averageValue: 1

Metrik vLLM di Google Cloud Managed Service for Prometheus mengikuti format vllm:metric_name.

Praktik terbaik:

Gunakan num_requests_waiting untuk menskalakan throughput. Gunakan gpu_cache_usage_perc untuk kasus penggunaan TPU yang sensitif terhadap latensi.

Deploy konfigurasi Horizontal Pod Autoscaler:
```
kubectl apply -f vllm-hpa.yaml
```
GKE menjadwalkan Pod lain untuk di-deploy, yang memicu autoscaler kumpulan node untuk menambahkan node kedua sebelum men-deploy replika vLLM kedua.

Lihat progres penskalaan otomatis Pod:

kubectl get hpa --watch

Outputnya mirip dengan hal berikut ini:

NAME       REFERENCE             TARGETS       MINPODS   MAXPODS   REPLICAS   AGE
vllm-hpa   Deployment/vllm-tpu   <unknown>/5   1         2         0          6s
vllm-hpa   Deployment/vllm-tpu   34972m/5      1         2         1          16s
vllm-hpa   Deployment/vllm-tpu   25112m/5      1         2         2          31s
vllm-hpa   Deployment/vllm-tpu   35301m/5      1         2         2          46s
vllm-hpa   Deployment/vllm-tpu   25098m/5      1         2         2          62s
vllm-hpa   Deployment/vllm-tpu   35348m/5      1         2         2          77s

Tunggu selama 10 menit dan ulangi langkah-langkah di bagian Memverifikasi bahwa Google Cloud Managed Service for Prometheus menyerap metrik. Google Cloud Managed Service for Prometheus menyerap metrik dari kedua endpoint vLLM.

test2

Pembersihan

Agar tidak perlu membayar biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus setiap resource.

Menghapus resource yang di-deploy

Agar tidak menimbulkan biaya pada akun Google Cloud Anda untuk resource yang dibuat dalam panduan ini, jalankan perintah berikut:

ps -ef | grep load.sh | awk '{print $2}' | xargs -n1 kill -9

gcloud container clusters delete CLUSTER_NAME \
  --location=ZONE

Langkah selanjutnya

Pelajari TPU di GKE lebih lanjut.
Pelajari lebih lanjut metrik yang tersedia untuk menyiapkan Autoscaler Pod Horizontal.
Pelajari repositori GitHub dan dokumentasi vLLM.