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

Dokumen ini menjelaskan cara men-deploy GKE Inference Gateway.

Dokumen ini ditujukan untuk 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:

GKE Inference Gateway meningkatkan Gateway Google Kubernetes Engine (GKE) untuk mengoptimalkan penyajian aplikasi dan workload AI generatif di GKE. Platform ini menyediakan pengelolaan dan penskalaan workload AI yang efisien, memungkinkan tujuan performa khusus workload seperti latensi, serta 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
  • 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.
  • Aktifkan Compute Engine API, Kubernetes Engine API, Network Services API, dan Model Armor API jika diperlukan.

    Buka Mengaktifkan 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 memadai untuk GPU H100. Untuk mempelajari lebih lanjut, lihat Merencanakan kuota GPU dan Kuota alokasi.

  • Buat akun Hugging Face jika Anda belum memilikinya. Anda akan memerlukan ini untuk mengakses resource model untuk tutorial ini.

  • Minta akses ke model Llama 3.1 dan buat token akses. Akses ke model ini memerlukan permintaan persetujuan 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, buka Your Profile > Settings > Access Tokens, buat token baru dengan setidaknya izin Read, lalu salin ke papan klip Anda.
  • Konfigurasi subnet khusus proxy untuk jaringan VPC Anda. Pengontrol Gateway memerlukan subnet khusus proxy yang aktif di region untuk menyediakan Load Balancer Aplikasi.

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 VPC native.
  • 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 menggunakan VPC Bersama, maka dalam project host, Anda perlu menetapkan peran Compute Network User ke akun Layanan GKE untuk project layanan.

Batas dan pembatasan

Batasan dan pembatasan berikut berlaku:

  • 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 maksimal delapan targetPorts.

Mengonfigurasi GKE Inference Gateway

Untuk mengonfigurasi GKE Inference Gateway, pertimbangkan contoh ini. Sebuah tim menjalankan model vLLM dan Llama3 serta secara aktif bereksperimen dengan dua adaptor yang disesuaikan dengan LoRA yang berbeda: "food-review" dan "cad-fabricator".

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

  1. Menyiapkan lingkungan Anda: siapkan infrastruktur dan komponen yang diperlukan.
  2. Membuat pool inferensi: tentukan pool server model menggunakan Resource Kustom InferencePool.
  3. Menentukan tujuan inferensi: tentukan tujuan inferensi menggunakan Resource Kustom InferenceObjective
  4. Membuat Gateway: mengekspos layanan inferensi menggunakan Gateway API.
  5. Buat HTTPRoute: tentukan cara traffic HTTP dirutekan ke layanan inferensi.
  6. Mengirim permintaan inferensi: membuat permintaan ke model yang di-deploy.

Membuat Gateway

Resource Gateway adalah titik entri untuk traffic eksternal ke cluster Kubernetes Anda. 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 Class Gateway.

Untuk membuat Gateway, lakukan langkah-langkah berikut:

  1. 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.
  2. 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

  1. Instal Helm.

  2. 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.
    • Konfigurasikan node dengan kelompok komputasi dan akselerator pilihan Anda.
    • Gunakan Panduan Memulai Inferensi GKE untuk manifes deployment yang telah dikonfigurasi dan diuji sebelumnya, berdasarkan akselerator, model, dan kebutuhan performa yang Anda pilih.
  3. 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.5.0/config/crd/bases/inference.networking.x-k8s.io_inferenceobjectives.yaml
      
    • Untuk GKE versi sebelum 1.34.0-gke.1626000, instal CRD InferencePool v1 dan InferenceObjective alfa:

      kubectl apply -f  https://github.com/kubernetes-sigs/gateway-api-inference-extension/releases/download/v1.5.0/manifests.yaml
      

      Untuk mengetahui informasi selengkapnya, lihat matriks kompatibilitas.

  4. Jika Anda menggunakan GKE versi sebelum 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
    
  5. 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
    
  6. Instal definisi resource kustom (CRD) Gateway API Inference Extension 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}"
    
  7. 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 penampung server model dan model, port penyajian model, serta nama deployment Anda sendiri. Anda juga dapat mengonfigurasi adaptor LoRA dalam deployment, atau men-deploy model dasar. Langkah-langkah berikut menjelaskan cara membuat resource Kubernetes yang diperlukan.

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

  2. Deploy server model vLLM menggunakan overlay Kustomize khusus GKE dari panduan llm-d optimized-baseline. Menetapkan INFRA_PROVIDER=gke akan 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 lebih suka menggunakannya.

Jika server model Anda memerlukan beberapa port, pastikan spesifikasi container 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 model bahasa besar (LLM) dasar dan konfigurasi komputasi yang sama. Kolom selector menentukan Pod mana yang termasuk dalam kumpulan ini. Label di 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 pool 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 InferencePool multi-port

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 server model yang dipilih InferencePool sudah berjalan.

Clone resep dan rekomendasi untuk InferencePool dari repositori GitHub llm-d. Langkah ini wajib dilakukan.:

git clone https://github.com/llm-d/llm-d -b v0.7.0 && cd llm-d

Untuk membuat InferencePool dan Endpoint Picker 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 diagram Helm. Contoh, v1.5.0.
  • LLM_D_REGISTRY_PATH: jalur registry OCI untuk diagram Helm. Contoh, registry.k8s.io/gateway-api-inference-extension/charts/inferencepool.

Di file guides/recipes/scheduler/base.values.yaml, ubah kolom berikut agar sesuai dengan label Pod Deployment model Anda:

  • inferencePool.modelServers.matchLabels: kunci dan nilai label yang digunakan untuk memilih Pod server model Anda.

    Catatan: Kunci dan nilai selaras dengan contoh panduan optimized-baseline, jadi kami menggantinya agar sesuai dengan label Pod Deployment Anda.

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

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

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

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

Men-deploy Pemilih Endpoint dengan ketersediaan tinggi

Men-deploy Endpoint Picker (EPP) dengan backend pilihan memungkinkan topologi pemilihan rute aktif-pasif yang didukung oleh Cloud Load Balancing.

Menggunakan Pemilih Endpoint dengan backend pilihan akan membantu Anda mencapai hal berikut:

  • Konsistensi status: Cloud Load Balancing mengarahkan 100% traffic ext_proc status stabil ke replika Endpoint Picker utama (epp-0), sehingga mempertahankan status cache nilai kunci (KV) dan konteks penjadwalan permintaan.
  • Failover tanpa periode nonaktif: Jika Pod Endpoint Picker utama mengalami error atau menjalani pemeliharaan, Cloud Load Balancing akan mendeteksi kegagalan menggunakan health check gRPC aktif dan segera mengalihkan traffic ke replika standby (epp-1).
  • Ketahanan fail-open: Jika dipasangkan dengan failureMode: FailOpen, kegagalan perutean sementara akan mengabaikan Endpoint Picker dan memungkinkan permintaan diteruskan langsung ke server model tanpa mengabaikan permintaan pengguna.

Saat Anda mengaktifkan backend pilihan, GKE akan mengubah arsitektur dan pemilihan rute dengan cara berikut:

  • Arsitektur StatefulSet Endpoint Picker: Endpoint Picker di-deploy sebagai StatefulSet, bukan Deployment. Ordinal Pod menetapkan peran replika: ordinal epp-0 berfungsi sebagai replika utama yang disematkan ke tingkat backend PREFERRED, dan ordinal epp-1 berfungsi sebagai replika standby yang disematkan ke tingkat DEFAULT.
  • Status pemilihan rute tetap terpusat: Traffic ext_proc steady-state dirutekan secara eksklusif ke replika Endpoint Picker utama (epp-0) untuk menjaga pelacakan cache nilai kunci (KV) dan status penjadwalan permintaan tetap terpusat. Jika epp-0 menjadi tidak responsif, Cloud Load Balancing akan mengalihkan traffic ke replika standby (epp-1).
  • Arsitektur Dual-Service: Chart Helm membuat Service utama (Service/${GUIDE_NAME}-epp) dan Service cadangan standby (Service/${GUIDE_NAME}-epp-backup). Resource InferencePool secara deklaratif menargetkan Service cadangan standby. Menambatkan kepemilikan Gateway deklaratif ke Service standby memastikan bahwa loop rekonsiliasi pengontrol Gateway GKE tidak melepaskan grup endpoint jaringan (NEG) utama yang Anda lampirkan ke layanan backend.

Untuk membuat InferencePool dan Endpoint Picker dengan ketersediaan tinggi menggunakan Helm, lakukan langkah-langkah berikut:

  1. Deploy InferencePool dan Endpoint Picker dengan backend pilihan menggunakan Helm:

    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 \
      --set provider.gke.preferredBackends.enabled=true \
      --set provider.gke.preferredBackends.preferredReplicas=1 \
      --set provider.gke.preferredBackends.defaultReplicas=1 \
      -n ${NAMESPACE} \
      --version ${GAIE_VERSION} \
      oci://LLM_D_REGISTRY_PATH
    

    Ganti kode berikut:

    • GAIE_VERSION: versi Gateway API Inference Extension (GAIE) dari diagram Helm. Contoh, v1.5.0. Backend pilihan memerlukan Helm chart versi v1.5.0 atau yang lebih baru.
    • LLM_D_REGISTRY_PATH: jalur registry OCI untuk chart Helm. Contoh, registry.k8s.io/gateway-api-inference-extension/charts/inferencepool.

    Untuk mengetahui daftar lengkap parameter, lihat values.yaml.

  2. Lampirkan NEG utama ke BackendService:

    export PROJECT_ID=PROJECT_ID
    export REGION=REGION
    
    export BACKEND_SERVICE=$(gcloud compute backend-services list --project=${PROJECT_ID} --format="value(name)" | grep "${GUIDE_NAME}-epp")
    
    export PRIMARY_NEG=$(kubectl get svc ${GUIDE_NAME}-epp -n ${NAMESPACE} -o jsonpath='{.metadata.annotations.cloud\.google\.com/neg-status}' | jq -r '.network_endpoint_groups["9002"]')
    
    for ZONE in $(kubectl get svc ${GUIDE_NAME}-epp -n ${NAMESPACE} -o jsonpath='{.metadata.annotations.cloud\.google\.com/neg-status}' | jq -r '.zones[]'); do
      gcloud compute backend-services add-backend ${BACKEND_SERVICE} \
        --network-endpoint-group=${PRIMARY_NEG} \
        --network-endpoint-group-zone=${ZONE} \
        --region=${REGION} \
        --project=${PROJECT_ID} \
        --balancing-mode=RATE \
        --max-rate-per-endpoint=100 \
        --preference=PREFERRED
      sleep 15
    done
    

    Ganti kode berikut:

    • PROJECT_ID: Project ID Google Cloud Anda.
    • REGION: region Google Cloud cluster dan layanan backend Anda.

Setelah NEG zona dilampirkan ke Google Cloud BackendService, penskalaan jumlah replika (preferredReplicas atau defaultReplicas) atau memulai ulang Pod tidak memerlukan menjalankan perintah gcloud lagi. Pengontrol NEG GKE otomatis menyinkronkan alamat IP Pod individual ke dalam NEG zona yang terdaftar.

Jika Anda menghapus dan membuat ulang resource Gateway atau InferencePool induk, pengontrol Gateway GKE akan membuat ulang Google Cloud BackendService yang mendasarinya dengan ID cloud baru. Jika demikian, jalankan alur kerja lampiran sebelumnya untuk melampirkan NEG zona utama ke BackendService yang baru dibuat.

Membuat HTTPRoute

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

  1. 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 semua.
    • INFERENCE_POOL_NAME: nama resource InferencePool yang ingin Anda gunakan untuk merutekan traffic. Contoh, vllm-llama3-8b-instruct.
  2. Terapkan manifes ke cluster Anda:

    kubectl apply -f httproute.yaml
    

Menentukan tujuan inferensi

Resource kustom InferenceObjective memungkinkan Anda menentukan prioritas permintaan.

Kolom metadata.name dari resource InferenceObjective menentukan nama Inference Objective, kolom Priority menentukan tingkat kekritisan inferensinya, dan kolom poolRef menentukan InferencePool tempat model inferensi disajikan.

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. Nilai 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:

  1. Simpan manifes berikut sebagai inference-objectives.yaml. Manifes ini membuat dua resource InferenceObjective. Yang pertama mengonfigurasi Tujuan Inferensi food-review di InferencePool vllm-llama3-8b-instruct dengan prioritas 10. Aturan kedua mengonfigurasi Tujuan Inferensi llama3-base-model agar ditayangkan dengan prioritas 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
    
  2. 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:

  1. 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.
  2. 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}
    
  3. 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 contoh permintaan 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 selain 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 Gateway API Inference Extension open source (OSS), termasuk persyaratan versi tertentu dan catatan penginstalan.

Nama CustomResourceDefinition Versi API CustomResourceDefinition Dukungan Terkelola GKE Dukungan OSS (Gateway API Inference Extension)
InferencePool V1 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 Gateway API Inference Extension v1.0.0
InferencePool Alfa (Sebaiknya pengguna memulai dengan InferencePool v1 karena versi InferencePool alfa 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 Gateway API Inference Extension. Didukung mulai dari Gateway API Inference Extension v0.2.0
Alpha InferenceObjective inference.networking.x-k8s.io/v1alpha2 GKE tidak mengelola InferenceObjective Didukung mulai dari Gateway API Inference Extension v1.0.0
InferenceModel Alfa (Sebaiknya pengguna memulai dengan InferenceObjective karena InferenceModel tidak digunakan lagi) inference.networking.x-k8s.io/v1alpha2 GKE tidak mengelola InferenceModel Didukung mulai dari Gateway API Inference Extension v0.2.0.

Mengamankan backend inferensi dengan TLS backend

TLS backend memungkinkan load balancer GKE Gateway memverifikasi identitas backend inferensi yang terhubung dengannya. TLS backend menambahkan langkah verifikasi eksplisit selama TLS handshake antara Gateway dan Pod backend. Verifikasi ini membantu memastikan bahwa Gateway hanya berkomunikasi dengan server model dan ekstensi Endpoint Picker tepercaya.

Untuk mengonfigurasi TLS backend untuk workload inferensi Anda, lampirkan BackendTLSPolicy ke resource InferencePool atau GCPInferencePoolImport. Untuk mengonfigurasi Gateway agar dapat memverifikasi sertifikat Endpoint Picker, lampirkan BackendTLSPolicy ke Endpoint Picker Service yang direferensikan oleh kolom spec.endpointPickerRef InferencePool.

Untuk mengetahui informasi selengkapnya, lihat Mengonfigurasi TLS backend.

Langkah berikutnya