Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Men-deploy GKE Inference Gateway yang didukung oleh llm-d

Autopilot Standard

Dokumen ini menjelaskan cara men-deploy GKE Inference Gateway.

Dokumen ini ditujukan bagi spesialis Jaringan yang bertanggung jawab mengelola infrastruktur GKE dan administrator platform yang mengelola workload AI.

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

Tentang GKE Inference Gateway.
Orkestrasi AI/ML di GKE.
Glosarium AI generatif.
Load balancing di Google Cloud, terutama cara load balancer berinteraksi dengan GKE.
Ekstensi Layanan GKE. Untuk mengetahui informasi selengkapnya, lihat dokumentasi pengontrol GKE Gateway.
Menyesuaikan traffic GKE Gateway menggunakan Ekstensi Layanan.

GKE Inference Gateway meningkatkan kualitas Google Kubernetes Engine (GKE) Gateway untuk mengoptimalkan penyajian aplikasi dan workload AI generatif di GKE. Layanan ini menyediakan pengelolaan dan penskalaan workload AI yang efisien, memungkinkan tujuan performa khusus workload seperti latensi, dan meningkatkan pemanfaatan resource, kemampuan observasi, dan keamanan AI.

Sebelum memulai

Sebelum memulai, pastikan Anda telah melakukan tugas berikut:

Aktifkan Google Kubernetes Engine API.

Aktifkan Google Kubernetes Engine API

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

Aktifkan Compute Engine API, Kubernetes Engine API, Network Services API, dan Model Armor API jika diperlukan.

Buka Aktifkan akses ke API dan ikuti petunjuknya.
Pastikan Anda memiliki peran berikut di project: roles/container.admin, roles/iam.serviceAccountAdmin.
Pastikan project Anda memiliki kuota yang cukup untuk GPU H100. Untuk mempelajari lebih lanjut, lihat Merencanakan kuota GPU dan Kuota alokasi.
Buat akun Hugging Face jika Anda belum memilikinya. Anda akan memerlukannya untuk mengakses resource model untuk tutorial ini.
Minta akses ke model Llama 3.1 dan buat token akses. Akses ke model ini memerlukan permintaan yang disetujui di Hugging Face, dan deployment akan gagal jika akses belum diberikan.
- Menandatangani perjanjian izin lisensi: Anda harus menandatangani perjanjian izin untuk menggunakan model Llama 3.1. Buka halaman model di Hugging Face, verifikasi akun Anda, dan setujui persyaratannya.
- Buat token akses: Untuk mengakses model, Anda memerlukan token Hugging Face. Di akun Hugging Face Anda, buka Your Profile > Settings > Access Tokens, buat token baru dengan izin Baca minimal, lalu salin ke papan klip Anda.

Persyaratan GKE Gateway Controller

GKE versi 1.32.3 atau yang lebih baru.
Google Cloud CLI versi 407.0.0 atau yang lebih baru.
Gateway API hanya didukung di cluster native VPC.
Anda harus mengaktifkan subnet khusus proxy.
Cluster Anda harus mengaktifkan add-on HttpLoadBalancing.
Jika menggunakan Istio, Anda harus mengupgrade Istio ke salah satu versi berikut:
- 1.15.2 atau yang lebih baru
- 1.14.5 atau yang lebih baru
- 1.13.9 atau yang lebih baru
Jika Anda menggunakan VPC Bersama, di project host, Anda harus menetapkan peran Compute Network User ke akun layanan GKE untuk project layanan.

Batas dan pembatasan

Batasan dan batasan berikut berlaku:

Gateway multi-cluster tidak didukung.
GKE Inference Gateway hanya didukung di resource GatewayClass gke-l7-regional-external-managed dan gke-l7-rilb.
Load Balancer Aplikasi internal lintas region tidak didukung.
InferencePool dapat memiliki maksimum delapan targetPorts.

Mengonfigurasi GKE Inference Gateway

Untuk mengonfigurasi GKE Inference Gateway, perhatikan contoh berikut. Tim menjalankan model vLLM dan Llama3 serta bereksperimen secara aktif dengan dua adaptor yang di-fine-tune LoRA yang berbeda: "food-review" dan "cad-fabricator".

Alur kerja tingkat tinggi untuk mengonfigurasi GKE Inference Gateway adalah sebagai berikut:

Siapkan lingkungan Anda: siapkan infrastruktur dan komponen yang diperlukan.
Buat kumpulan inferensi: tentukan kumpulan server model menggunakan Resource Kustom InferencePool.
Tentukan tujuan inferensi: tentukan tujuan inferensi menggunakan Resource Kustom InferenceObjective
Buat Gateway: ekspos layanan inferensi menggunakan Gateway API.
Buat HTTPRoute: tentukan cara traffic HTTP dirutekan ke layanan inferensi.
Mengirim permintaan inferensi: membuat permintaan ke model yang di-deploy.

Buat Gateway

Resource Gateway adalah titik entri untuk traffic eksternal ke dalam cluster Kubernetes Anda. Objek ini menentukan pemroses yang menerima koneksi masuk.

GKE Inference Gateway berfungsi dengan Class Gateway berikut:

gke-l7-rilb: untuk Load Balancer Aplikasi internal regional.
gke-l7-regional-external-managed: untuk Load Balancer Aplikasi eksternal regional.

Untuk mengetahui informasi selengkapnya, lihat dokumentasi Gateway Classes.

Untuk membuat Gateway, lakukan langkah-langkah berikut:

Simpan manifes contoh berikut sebagai gateway.yaml:
```
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: GATEWAY_NAME
spec:
  gatewayClassName: GATEWAY_CLASS
  listeners:
    - protocol: HTTP
      port: 80
      name: http
```
Ganti kode berikut:
- GATEWAY_NAME: nama unik untuk resource Gateway Anda. Contoh, inference-gateway.
- GATEWAY_CLASS: Gateway Class yang ingin Anda gunakan. Contoh, gke-l7-regional-external-managed.
Terapkan manifes ke cluster Anda:
```
kubectl apply -f gateway.yaml
```

Catatan: Untuk mengetahui informasi selengkapnya tentang cara mengonfigurasi TLS untuk mengamankan Gateway Anda dengan HTTPS, lihat dokumentasi GKE tentang konfigurasi TLS.

Menyiapkan lingkungan Anda

Instal Helm.
Buat cluster GKE:
- Buat cluster GKE Autopilot atau Standard dengan versi 1.32.3 atau yang lebih baru. Untuk penyiapan referensi deployment sekali klik, lihat contoh cluster-toolkit gke-a3-highgpu.
- Konfigurasi node dengan akselerator dan kelompok komputasi pilihan Anda.
- Gunakan Panduan Memulai Inferensi GKE untuk manifes deployment yang telah dikonfigurasi sebelumnya dan diuji, berdasarkan akselerator, model, dan kebutuhan performa yang Anda pilih.
Instal Definisi Resource Kustom (CRD) yang diperlukan di cluster GKE Anda:
- Untuk GKE versi 1.34.0-gke.1626000 atau yang lebih baru, CRD InferencePool disertakan secara default. Oleh karena itu, instal hanya CRD InferenceObjective alfa:
```
kubectl apply -f https://github.com/kubernetes-sigs/gateway-api-inference-extension/raw/v1.4.0/config/crd/bases/inference.networking.x-k8s.io_inferenceobjectives.yaml
```
- Untuk versi GKE sebelum 1.34.0-gke.1626000, instal InferencePool v1 dan CRD InferenceObjective alfa:
```
kubectl apply -f  https://github.com/kubernetes-sigs/gateway-api-inference-extension/releases/download/v1.4.0/manifests.yaml
```
  Untuk mengetahui informasi selengkapnya, lihat matriks kompatibilitas.

Jika Anda menggunakan versi GKE yang lebih lama dari v1.32.2-gke.1182001 dan ingin menggunakan Model Armor dengan GKE Inference Gateway, Anda harus menginstal CRD ekstensi perutean dan traffic:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-gateway-api/refs/heads/main/config/crd/networking.gke.io_gcptrafficextensions.yaml
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-gateway-api/refs/heads/main/config/crd/networking.gke.io_gcproutingextensions.yaml

Tetapkan variabel lingkungan berikut:

export GAIE_VERSION=v1.5.0
export GUIDE_NAME="optimized-baseline"
export NAMESPACE=llm-d-optimized-baseline
export INFRA_PROVIDER=gke   # gke | base

Instal definisi resource kustom (CRD) Ekstensi Inferensi Gateway API yang diperlukan oleh pemilih endpoint (EPP) llm-d:

kubectl apply -k \
  "https://github.com/kubernetes-sigs/gateway-api-inference-extension/config/crd?ref=${GAIE_VERSION}"

Buat namespace target:
```
kubectl create namespace ${NAMESPACE}
```

Membuat server model dan deployment model

Bagian ini menunjukkan cara men-deploy server model dan model. Contoh ini menggunakan server model vLLM dengan model Llama3. Deployment diberi label sebagai app:vllm-llama3-8b-instruct. Deployment ini juga menggunakan dua adaptor LoRA bernama food-review dan cad-fabricator dari Hugging Face.

Anda dapat menyesuaikan contoh ini dengan container server model dan model Anda sendiri, port penyaluran, dan nama deployment. Anda juga dapat mengonfigurasi adaptor LoRA dalam deployment, atau men-deploy model dasar. Langkah-langkah berikut menjelaskan cara membuat resource Kubernetes yang diperlukan.

Buat Secret Kubernetes untuk menyimpan token Hugging Face Anda. Token ini digunakan untuk mengakses model dasar dan adaptor LoRA:
```
kubectl create secret generic hf-token --from-literal=token=HF_TOKEN
```
Ganti HF_TOKEN dengan token Hugging Face Anda.
Deploy server model vLLM menggunakan overlay Kustomize khusus GKE dari panduan llm-d optimized-baseline. Menetapkan INFRA_PROVIDER=gke menerapkan konfigurasi khusus GKE, termasuk integrasi Cloud Monitoring:
```
kubectl apply -n ${NAMESPACE} \
  -k guides/${GUIDE_NAME}/modelserver/gpu/vllm/${INFRA_PROVIDER}/
```

Catatan: GKE menyediakan pemantauan aplikasi otomatis secara default. Stack pemantauan llm-d tidak diperlukan untuk GKE, tetapi tersedia jika Anda ingin menggunakannya.

Jika server model Anda memerlukan beberapa port, pastikan spesifikasi penampung mengekspos setiap port. Contoh berikut menentukan Deployment tempat container mengekspos tiga port:

Contoh Deployment Multiport

apiVersion: apps/v1
kind: Deployment
metadata:
  name: multiport-model-server
spec:
  replicas: 3
  selector:
    matchLabels:
      app: multiport-model-server
  template:
    metadata:
      labels:
        app: multiport-model-server
    spec:
      containers:
      - name: model-server
        image: your-model-server-image
        ports:
        - containerPort: 8080
        - containerPort: 8081
        - containerPort: 9000

Membuat kumpulan inferensi

Resource kustom Kubernetes InferencePool menentukan grup Pod dengan konfigurasi komputasi dan model bahasa besar (LLM) dasar yang sama. Kolom selector menentukan Pod mana yang termasuk dalam kumpulan ini. Label dalam pemilih ini harus sama persis dengan label yang diterapkan ke Pod server model Anda. Kolom targetPorts menentukan port yang digunakan server model dalam Pod. Anda dapat menentukan hingga delapan port. Kolom extensionRef mereferensikan layanan ekstensi yang memberikan kemampuan tambahan untuk kumpulan inferensi. InferencePool memungkinkan GKE Inference Gateway merutekan traffic ke Pod server model Anda.

Manifes InferencePool berikut menentukan beberapa targetPort yang sesuai dengan port yang diekspos oleh Deployment server model:

Contoh Multiport InferencePool

apiVersion: inference.networking.k8s.io/v1
kind: InferencePool
metadata:
  name: my-multiport-pool
  namespace: default
spec:
  selector:
    matchLabels:
      app: multiport-model-server
  targetPorts:
    - number: 8080
    - number: 8081
    - number: 9000

Sebelum membuat InferencePool, pastikan Pod yang dipilih InferencePool sudah berjalan.

Untuk membuat InferencePool menggunakan Helm, lakukan langkah-langkah berikut:

helm install ${GUIDE_NAME} \
  -f guides/recipes/scheduler/base.values.yaml \
  -f guides/${GUIDE_NAME}/scheduler/${GUIDE_NAME}.values.yaml \
  --set provider.name=gke \
  --set inferenceExtension.monitoring.gke.enabled=true \
  -n ${NAMESPACE} \
  --version ${GAIE_VERSION} \
  oci://LLM_D_REGISTRY_PATH

Ganti kode berikut:

GAIE_VERSION: versi Helm chart. Contoh, v1.5.0.
LLM_D_REGISTRY_PATH: jalur registry OCI untuk Helm chart. Contoh, us-central1-docker.pkg.dev/cloud-ai-gke/gke-inference-gateway/charts/inferencepool.

Ubah kolom berikut agar sesuai dengan Deployment Anda:

inferencePool.modelServers.matchLabels.app: kunci label yang digunakan untuk memilih Pod server model Anda.

Untuk pemantauan, pengambilan metrik untuk Google Cloud Managed Service for Prometheus diaktifkan secara default.

Untuk menonaktifkan fitur ini, tambahkan tanda --set inferenceExtension.monitoring.prometheus.enabled=false ke perintah.
Jika Anda menggunakan pemantauan default di cluster GKE Autopilot, Anda juga harus menambahkan tanda --set provider.gke.autopilot=true.

Penginstalan Helm akan otomatis menginstal kebijakan waktu tunggu yang diperlukan, pemilih endpoint, dan Pod yang diperlukan untuk kemampuan pengamatan.

Tindakan ini akan membuat objek InferencePool: vllm-llama3-8b-instruct yang mereferensikan layanan endpoint model dalam Pod. Tindakan ini juga membuat deployment Endpoint Picker bernama app:vllm-llama3-8b-instruct-epp untuk InferencePool yang dibuat ini.

Buat `HTTPRoute`

Resource HTTPRoute menentukan cara GKE Gateway merutekan permintaan HTTP masuk ke layanan backend, seperti InferencePool Anda. Resource HTTPRoute menentukan aturan pencocokan (misalnya, header atau jalur) dan backend tempat traffic harus diteruskan.

Untuk membuat HTTPRoute, simpan contoh manifes berikut sebagai httproute.yaml:
```
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: HTTPROUTE_NAME
spec:
  parentRefs:
  - name: GATEWAY_NAME
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: PATH_PREFIX
    backendRefs:
    - name: INFERENCE_POOL_NAME
      group: "inference.networking.k8s.io"
      kind: InferencePool
```
Ganti kode berikut:
- HTTPROUTE_NAME: nama unik untuk resource HTTPRoute Anda. Misalnya, my-route.
- GATEWAY_NAME: nama resource Gateway yang Anda buat. Misalnya, inference-gateway.
- PATH_PREFIX: awalan jalur yang Anda gunakan untuk mencocokkan permintaan masuk. Misalnya, / untuk mencocokkan semuanya.
- INFERENCE_POOL_NAME: nama resource InferencePool yang ingin Anda tuju untuk merutekan traffic. Contoh, vllm-llama3-8b-instruct.
Terapkan manifes ke cluster Anda:
```
kubectl apply -f httproute.yaml
```

Tentukan tujuan inferensi

Resource kustom InferenceObjective memungkinkan Anda menentukan prioritas permintaan.

Kolom metadata.name resource InferenceObjective menentukan nama Inference Objective, kolom Priority menentukan tingkat kritis penayangannya, dan kolom poolRef menentukan InferencePool tempat model ditayangkan.

apiVersion: inference.networking.x-k8s.io/v1alpha2
kind: InferenceObjective
metadata:
  name: NAME
spec:
  priority: VALUE
  poolRef:
    name: INFERENCE_POOL_NAME
    group: "inference.networking.k8s.io"

Ganti kode berikut:

NAME: nama Inference Objective Anda. Contoh, food-review.
VALUE: prioritas untuk Tujuan Inferensi. Ini adalah bilangan bulat dengan nilai yang lebih tinggi menunjukkan permintaan yang lebih penting. Misalnya, 10.
INFERENCE_POOL_NAME: nama InferencePool yang Anda buat di langkah sebelumnya. Contoh, vllm-llama3-8b-instruct.

Untuk membuat InferenceObjective, lakukan langkah-langkah berikut:

Simpan manifes berikut sebagai inference-objectives.yaml. Manifes ini membuat dua resource InferenceObjective. Yang pertama mengonfigurasi Tujuan Inferensi food-review pada vllm-llama3-8b-instruct InferencePool dengan prioritas 10. Yang kedua mengonfigurasi Tujuan Inferensi llama3-base-model agar ditayangkan dengan prioritas yang lebih tinggi, yaitu 20.

apiVersion: inference.networking.x-k8s.io/v1alpha2
kind: InferenceObjective
metadata:
  name: food-review
spec:
  priority: 10
  poolRef:
    name: vllm-llama3-8b-instruct
    group: "inference.networking.k8s.io"
---
apiVersion: inference.networking.x-k8s.io/v1alpha2
kind: InferenceObjective
metadata:
  name: llama3-base-model
spec:
  priority: 20 # Higher priority
  poolRef:
    name: vllm-llama3-8b-instruct

Terapkan manifes contoh ke cluster Anda:

kubectl apply -f inference-objectives.yaml

Memverifikasi deployment

Untuk memverifikasi bahwa semua komponen berjalan, jalankan perintah berikut:

kubectl get inferencepool
kubectl get inferenceobjective
kubectl get pods -l app=vllm-llama3-8b-instruct-epp

Mengirim permintaan inferensi

Setelah mengonfigurasi GKE Inference Gateway, Anda dapat mengirim permintaan inferensi ke model yang di-deploy. Dengan demikian, Anda dapat membuat teks berdasarkan perintah input dan parameter yang ditentukan.

Untuk mengirim permintaan inferensi, lakukan langkah-langkah berikut:

Tetapkan variabel lingkungan berikut:
```
export GATEWAY_NAME=GATEWAY_NAME
export PORT_NUMBER=PORT_NUMBER # Use 80 for HTTP
```
Ganti kode berikut:
- GATEWAY_NAME: nama resource Gateway Anda.
- PORT_NUMBER: nomor port yang Anda konfigurasi di Gateway.

Untuk mendapatkan endpoint Gateway, jalankan perintah berikut:

echo "Waiting for the Gateway IP address..."
IP=""
while [ -z "$IP" ]; do
  IP=$(kubectl get gateway/${GATEWAY_NAME} -o jsonpath='{.status.addresses[0].value}' 2>/dev/null)
  if [ -z "$IP" ]; then
    echo "Gateway IP not found, waiting 5 seconds..."
    sleep 5
  fi
done

echo "Gateway IP address is: $IP"
PORT=${PORT_NUMBER}

Untuk mengirim permintaan ke endpoint /v1/completions menggunakan curl, jalankan perintah berikut:
```
curl -i -X POST ${IP}:${PORT}/v1/completions \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer $(gcloud auth application-default print-access-token)' \
-d '{
    "model": "MODEL_NAME",
    "prompt": "PROMPT_TEXT",
    "max_tokens": MAX_TOKENS,
    "temperature": "TEMPERATURE"
}'
```
Ganti kode berikut:
- MODEL_NAME: nama model atau adaptor LoRA yang akan digunakan.
- PROMPT_TEXT: perintah input untuk model.
- MAX_TOKENS: jumlah maksimum token yang akan dibuat dalam respons.
- TEMPERATURE: mengontrol keacakan output. Gunakan nilai 0 untuk output deterministik, atau angka yang lebih tinggi untuk output yang lebih kreatif.

Contoh berikut menunjukkan cara mengirim permintaan contoh ke GKE Inference Gateway:

curl -i -X POST ${IP}:${PORT}/v1/completions -H 'Content-Type: application/json' -H 'Authorization: Bearer $(gcloud auth application-default print-access-token)' -d '{
    "model": "food-review-1",
    "prompt": "What is the best pizza in the world?",
    "max_tokens": 2048,
    "temperature": 0
}'

Perhatikan perilaku berikut:

Isi permintaan: isi permintaan dapat menyertakan parameter tambahan seperti stop dan top_p. Lihat spesifikasi OpenAI API untuk mengetahui daftar lengkap opsi.
Penanganan error: terapkan penanganan error yang tepat dalam kode klien Anda untuk menangani potensi error dalam respons. Misalnya, periksa kode status HTTP dalam respons curl. Kode status non-200 umumnya menunjukkan error.
Autentikasi dan otorisasi: untuk deployment produksi, amankan endpoint API Anda dengan mekanisme autentikasi dan otorisasi. Sertakan header yang sesuai (misalnya, Authorization) dalam permintaan Anda.

Matriks kompatibilitas

Tabel ini menguraikan matriks kompatibilitas dan dukungan untuk Definisi Resource Kustom (CRD) Ekstensi Inferensi Gateway API. Dokumen ini menjelaskan versi CustomResourceDefinition yang didukung oleh GKE dibandingkan dengan project Ekstensi Inferensi Gateway API open source (OSS), termasuk persyaratan versi tertentu dan catatan penginstalan.

Nama CustomResourceDefinition	Versi API CustomResourceDefinition	Dukungan Terkelola GKE	Dukungan OSS (Ekstensi Inferensi Gateway API)
V1 InferencePool	inference.networking.k8s.io/v1	Didukung di GKE 1.32.3 atau yang lebih baru dan CustomResourceDefinition diinstal secara default di GKE 1.34.0-gke.1626000 atau yang lebih baru	Didukung mulai dari Ekstensi Inferensi Gateway API v1.0.0
Alpha InferencePool (Sebaiknya pengguna memulai dengan InferencePool v1 karena versi alpha InferencePool sudah tidak digunakan lagi)	inference.networking.x-k8s.io/v1alpha2	Didukung di GKE 1.32.3 atau yang lebih baru. Namun, CustomResourceDefinition tidak diinstal secara default di GKE. Pengguna harus menginstal CustomResourceDefinition secara manual dari Ekstensi Inferensi Gateway API.	Didukung mulai dari Ekstensi Inferensi Gateway API v0.2.0
Alpha InferenceObjective	inference.networking.x-k8s.io/v1alpha2	GKE tidak mengelola InferenceObjective	Didukung mulai dari Ekstensi Inferensi Gateway API v1.0.0
Alpha InferenceModel (Sebaiknya pengguna memulai dengan InferenceObjective karena InferenceModel tidak digunakan lagi)	inference.networking.x-k8s.io/v1alpha2	GKE tidak mengelola InferenceModel	Didukung mulai dari Ekstensi Inferensi Gateway API v0.2.0.