Menyajikan model terbuka Gemma menggunakan GPU di GKE dengan vLLM

Autopilot Standard

Untuk menyajikan model bahasa besar (LLM) Gemma 4 di Google Kubernetes Engine (GKE) dengan framework vLLM menggunakan GPU, Anda harus menyediakan cluster GKE dengan akselerator yang didukung, seperti GPU NVIDIA B200, H100, RTX Pro 6000, atau L4.

Untuk mendapatkan bobot model Gemma 4, Anda dapat mengonfigurasi container vLLM bawaan untuk mendownloadnya dari repositori Hugging Face. Atau, container dapat memuat bobot model dari penyimpanan persisten yang ada—seperti dengan menyimpan dalam cache bucket model Cloud Storage Anda di instance Google Cloud Managed Lustre.

Setelah bobot dimuat, penampung vLLM akan mengekspos endpoint API yang kompatibel dengan OpenAI untuk inferensi throughput tinggi.

Tutorial ini ditujukan untuk engineer Machine Learning (ML), Admin dan operator platform, serta spesialis Data dan AI yang tertarik untuk menggunakan kemampuan orkestrasi container Kubernetes untuk menyajikan workload AI/ML di hardware GPU H200, H100, A100, dan L4. Untuk mempelajari lebih lanjut peran umum dan contoh tugas yang kami referensikan dalam konten, lihat Peran dan tugas pengguna GKE umum. Google Cloud

Jika Anda memerlukan platform AI terkelola terpadu yang dirancang untuk membangun dan menyajikan model ML dengan cepat dan hemat biaya, sebaiknya coba solusi deployment Vertex AI kami.

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

Latar belakang

Bagian ini menjelaskan teknologi utama yang digunakan dalam panduan ini.

GPU

GPU memungkinkan Anda mempercepat workload tertentu yang berjalan di node, seperti machine learning dan pemrosesan data. GKE menyediakan berbagai opsi jenis mesin untuk konfigurasi node, termasuk jenis mesin dengan GPU NVIDIA H200, H100, L4, dan A100.

vLLM

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

Penerapan transformer yang dioptimalkan dengan PagedAttention
Batch berkelanjutan untuk meningkatkan throughput penayangan secara keseluruhan
Paralelisme tensor dan inferensi terdistribusi pada beberapa GPU

Untuk mengetahui informasi selengkapnya, lihat dokumentasi vLLM.

Tujuan

Tutorial ini memberikan dasar untuk memahami dan menjelajahi deployment LLM praktis untuk inferensi di lingkungan Kubernetes terkelola.

Siapkan lingkungan Anda dengan cluster GKE dalam mode Autopilot atau Standard.
Deploy container vLLM ke cluster Anda.
Gunakan vLLM untuk menyajikan model Gemma 4 melalui curl dan antarmuka chat web.

Sebelum memulai

Login ke akun Google Cloud Anda. Jika Anda baru menggunakan Google Cloud, buat akun untuk mengevaluasi performa produk kami dalam skenario dunia nyata. Pelanggan baru juga mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.

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

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

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

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

Pastikan Anda memiliki peran berikut di project: roles/container.admin, roles/iam.serviceAccountAdmin
Memeriksa peran
1. Di konsol Google Cloud , buka halaman IAM.
  Buka IAM
2. Pilih project.
3. Di kolom Akun utama, temukan semua baris yang mengidentifikasi Anda atau grup yang Anda ikuti. Untuk mengetahui grup mana saja yang Anda ikuti, hubungi administrator Anda.
4. Untuk semua baris yang menentukan atau menyertakan Anda, periksa kolom Peran untuk melihat apakah daftar peran menyertakan peran yang diperlukan.
Memberikan peran
1. Di konsol Google Cloud , buka halaman IAM.
  Buka IAM
2. Pilih project.
3. Klik Grant access.
4. Di kolom New principals, masukkan ID pengguna Anda. Biasanya, ini adalah alamat email untuk Akun Google.
5. Klik Pilih peran, lalu telusuri peran.
6. Untuk memberikan peran tambahan, klik Add another role, lalu tambahkan tiap peran tambahan.
7. Klik Simpan.

Pastikan project Anda memiliki kuota yang cukup untuk GPU L4. Untuk mengetahui informasi selengkapnya, lihat Tentang GPU dan Kuota alokasi.

Menyiapkan lingkungan Anda

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 konsolGoogle Cloud . Tindakan ini akan meluncurkan sesi di panel bawah konsol Google Cloud .
Tetapkan variabel lingkungan default:
```
gcloud config set project PROJECT_ID
gcloud config set billing/quota_project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export REGION=REGION
export ZONE=ZONE
export CLUSTER_NAME=CLUSTER_NAME
```
Ganti nilai berikut:
- PROJECT_ID: Project ID Google Cloud Anda.
- REGION: region yang mendukung jenis akselerator yang ingin Anda gunakan, misalnya, us-central1 untuk GPU L4. Anda dapat menemukan GPU mana yang tersedia di region mana.
- ZONE: zona yang mendukung jenis akselerator yang ingin Anda gunakan, misalnya, us-central1-b dan us-central1-f untuk GPU RTX PRO 6000. Anda dapat menemukan zona mana yang menyediakan GPU tertentu.
- CLUSTER_NAME: nama cluster Anda.

Membuat dan mengonfigurasi resource Google Cloud

Ikuti petunjuk berikut untuk membuat resource yang diperlukan.

Membuat cluster dan node pool GKE

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

Autopilot

Jalankan perintah berikut di Cloud Shell:

gcloud container clusters create-auto CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --release-channel=rapid

Ganti nilai berikut:

PROJECT_ID: Project ID Google Cloud Anda.
CONTROL_PLANE_LOCATION: region Compute Engine dari bidang kontrol cluster Anda. Berikan region yang mendukung jenis akselerator yang ingin Anda gunakan, misalnya, us-central1 untuk GPU L4.
CLUSTER_NAME: nama cluster Anda.

GKE membuat cluster Autopilot dengan node CPU dan GPU seperti yang diminta oleh workload yang di-deploy.

Standar

Di Cloud Shell, jalankan perintah berikut untuk membuat cluster Standar:
```
gcloud container clusters create CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --workload-pool=PROJECT_ID.svc.id.goog \
    --release-channel=rapid \
    --num-nodes=1
```
Ganti nilai berikut:
- PROJECT_ID: Project ID Google Cloud Anda.
- CONTROL_PLANE_LOCATION: region Compute Engine dari bidang kontrol cluster Anda. Berikan region yang mendukung jenis akselerator yang ingin Anda gunakan, misalnya, us-central1 untuk GPU L4.
- CLUSTER_NAME: nama cluster Anda.
Pembuatan cluster mungkin memerlukan waktu beberapa menit.

Untuk membuat node pool bagi cluster Anda dengan ukuran disk yang sesuai, jalankan perintah berikut:

  gcloud container node-pools create gpupool \
      --accelerator type=nvidia-rtx-pro-6000,count=1,gpu-driver-version=latest \
      --project=PROJECT_ID \
      --location=REGION \
      --node-locations=ZONE \
      --cluster=CLUSTER_NAME \
      --machine-type=g4-standard-48 \
      --num-nodes=1

GKE membuat satu node pool yang berisi RTX PRO. 6000 GPU untuk setiap node.

Men-deploy model Gemma 4 di vLLM menggunakan bobot Hugging Face

Untuk men-deploy model Gemma 4 menggunakan bobot Hugging Face, terapkan manifes Deployment Kubernetes untuk ukuran model yang Anda pilih. Deployment adalah objek Kubernetes API yang memungkinkan Anda menjalankan beberapa replika Pod yang didistribusikan di antara node dalam cluster.

Prosedur

Penerapan manifes ini akan menarik image container vLLM, meminta GPU NVIDIA, dan otomatis mendownload bobot dari Hugging Face untuk memulai mesin inferensi vLLM.

Gemma 4 E2B-it

Ikuti petunjuk ini untuk men-deploy model yang di-tune dengan petunjuk E2B Gemma 4 (input hanya teks).

Buat manifes vllm-4-e2b-it.yaml berikut:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-4-e2b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4
        resources:
          requests:
            cpu: "2"
            memory: "10Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "2"
            memory: "10Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: "1"
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
          - --model=$(MODEL_ID)
          - --host=0.0.0.0
          - --port=8000
          - --tensor-parallel-size=1
          - --enable-log-requests
          - --enable-chunked-prefill
          - --enable-prefix-caching
          - --enable-auto-tool-choice
          - --generation-config=auto
          - --tool-call-parser=gemma4
          - --dtype=bfloat16
          - --max-num-seqs=16
          - --max-model-len=32768
          - --gpu-memory-utilization=0.95
          - --reasoning-parser=gemma4
          - --trust-remote-code
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-4-E2B-it
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-rtx-pro-6000
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Terapkan manifes:
```
kubectl apply -f vllm-4-e2b-it.yaml
```

Gemma 4 E4B-it

Ikuti petunjuk berikut untuk men-deploy model yang di-tune dengan petunjuk Gemma 4 E4B.

Buat manifes vllm-4-e4b-it.yaml berikut:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-4-e4b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4
        resources:
          requests:
            cpu: "4"
            memory: "20Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "4"
            memory: "20Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: "1"
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
          - --model=$(MODEL_ID)
          - --host=0.0.0.0
          - --port=8000
          - --tensor-parallel-size=1
          - --enable-log-requests
          - --enable-chunked-prefill
          - --enable-prefix-caching
          - --enable-auto-tool-choice
          - --generation-config=auto
          - --tool-call-parser=gemma4
          - --dtype=bfloat16
          - --max-num-seqs=16
          - --max-model-len=32768
          - --gpu-memory-utilization=0.95
          - --reasoning-parser=gemma4
          - --trust-remote-code
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-4-E4b-it
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-rtx-pro-6000
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Terapkan manifes:
```
kubectl apply -f vllm-4-E4b-it.yaml
```
Dalam contoh ini, kita membatasi jendela konteks hingga 32 K menggunakan opsi vLLM --max-model-len=32768. Jika Anda menginginkan ukuran jendela konteks yang lebih besar (hingga 128 K), sesuaikan manifes dan konfigurasi node pool dengan kapasitas GPU yang lebih besar.

Gemma 4 26B-A4B-it

Ikuti petunjuk ini untuk men-deploy model yang di-tune untuk perintah Gemma 4 26B-A4B.

Buat manifes vllm-4-26b-a4b-it.yaml berikut:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-4-26b-a4b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4
        resources:
          requests:
            cpu: "20"
            memory: "80Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "20"
            memory: "80Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
          - --model=$(MODEL_ID)
          - --host=0.0.0.0
          - --port=8000
          - --tensor-parallel-size=1
          - --enable-log-requests
          - --enable-chunked-prefill
          - --enable-prefix-caching
          - --enable-auto-tool-choice
          - --generation-config=auto
          - --tool-call-parser=gemma4
          - --dtype=bfloat16
          - --max-num-seqs=16
          - --max-model-len=16384
          - --gpu-memory-utilization=0.95
          - --reasoning-parser=gemma4
          - --trust-remote-code
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-4-26B-A4B-it
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-rtx-pro-6000
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Terapkan manifes:
```
kubectl apply -f vllm-4-26b-a4b-it.yaml
```
Dalam contoh ini, kita membatasi ukuran jendela konteks hingga 16 K menggunakan opsi vLLM --max-model-len=16384. Jika Anda menginginkan ukuran jendela konteks yang lebih besar (hingga 128 K), sesuaikan konfigurasi manifes dan node pool Anda dengan kapasitas GPU yang lebih besar.

Gemma 4 31B-it

Ikuti petunjuk berikut untuk men-deploy model yang di-tune dengan perintah Gemma 4 31B.

Buat manifes vllm-4-31b-it.yaml berikut:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-4-31b-it
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:gemma4
        resources:
          requests:
            cpu: "22"
            memory: "100Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
          limits:
            cpu: "22"
            memory: "100Gi"
            ephemeral-storage: "80Gi"
            nvidia.com/gpu: "1"
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
          - --model=$(MODEL_ID)
          - --host=0.0.0.0
          - --port=8000
          - --tensor-parallel-size=1
          - --enable-log-requests
          - --enable-chunked-prefill
          - --enable-prefix-caching
          - --enable-auto-tool-choice
          - --generation-config=auto
          - --tool-call-parser=gemma4
          - --dtype=bfloat16
          - --max-num-seqs=16
          - --max-model-len=16384
          - --gpu-memory-utilization=0.95
          - --reasoning-parser=gemma4
          - --trust-remote-code
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-4-31B-it
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-rtx-pro-6000
        cloud.google.com/gke-gpu-driver-version: latest
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Terapkan manifes:
```
kubectl apply -f vllm-4-31b-it.yaml
```
Dalam contoh ini, kita membatasi ukuran jendela konteks hingga 16 K menggunakan opsi vLLM --max-model-len=16384. Jika Anda menginginkan ukuran jendela konteks yang lebih besar (hingga 128 K), sesuaikan manifes dan konfigurasi node pool dengan kapasitas GPU yang lebih besar.

Verifikasi

Tunggu hingga Deployment tersedia:

kubectl wait --for=condition=Available --timeout=1800s deployment/vllm-gemma-deployment

Lihat log dari Deployment yang sedang berjalan:

kubectl logs -f -l app=gemma-server

Resource Deployment mendownload data model Gemma. Proses ini dapat memerlukan waktu beberapa menit. Outputnya mirip dengan hal berikut ini:

  ...
  ...
  (APIServer pid=1) INFO:     Started server process [1]
  (APIServer pid=1) INFO:     Waiting for application startup.
  (APIServer pid=1) INFO:     Application startup complete.

Setelah deployment Hugging Face tersedia, siapkan penerusan port untuk berinteraksi dengan model.

Men-deploy Gemma yang telah disesuaikan dari Managed Lustre

Untuk menyajikan model Gemma yang telah di-fine-tune (seperti Gemma 3 27B) yang sudah disimpan di instance Google Cloud Managed Lustre, Anda harus memasang PersistentVolumeClaim (PVC) yang sesuai ke penampung vLLM.

Prasyarat

Pastikan Anda memiliki PVC yang sudah ada di cluster GKE yang terhubung ke instance Lustre Anda. Dalam contoh ini, PVC diberi nama gemma-lustre-pvc.

Untuk mempelajari cara membuat PVC dan PersistentVolume (PV) untuk instance yang ada, lihat Mengakses instance Managed Lustre yang ada.

Prosedur

Simpan manifes YAML berikut sebagai vllm-lustre-gemma.yaml. Dalam contoh ini, Deployment memasang PVC Lustre ke /data dan menginstruksikan vLLM untuk memuat bobot model dari jalur lokal tersebut.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gemma-lustre
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
    spec:
      containers:
      - name: vllm
        image: vllm/vllm-openai:latest
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=/data/gemma-3-27b
        - --tensor-parallel-size=1
        resources:
          limits:
            nvidia.com/gpu: "1"
        volumeMounts:
        - name: model-weights
          mountPath: /data
      volumes:
      - name: model-weights
        persistentVolumeClaim:
          claimName: gemma-lustre-pvc
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
        cloud.google.com/gke-gpu-driver-version: latest

Terapkan manifes ke cluster GKE:

kubectl apply -f vllm-lustre-gemma.yaml

Verifikasi

Untuk mengonfirmasi bahwa model berhasil dimuat dari volume Lustre, periksa log Pod untuk urutan startup vLLM:

kubectl logs -l app=gemma-server

Menyajikan model

Di bagian ini, Anda akan berinteraksi dengan model. Pastikan model didownload sepenuhnya sebelum melanjutkan.

Menyiapkan penerusan port

Jalankan perintah berikut untuk menyiapkan penerusan port ke model:

kubectl port-forward service/llm-service 8000:8000

Outputnya mirip dengan hal berikut ini:

Forwarding from 127.0.0.1:8000 -> 8000

Berinteraksi dengan model menggunakan curl

Bagian ini menunjukkan cara melakukan pengujian cepat dasar untuk memverifikasi model yang di-tune dengan perintah Gemma 4 yang di-deploy. Untuk model lainnya, ganti gemma-4-e4b-it dengan nama model masing-masing.

Contoh ini menunjukkan cara menguji model yang di-tune untuk mengikuti perintah Gemma 4 E4B dengan input khusus teks.

Dalam sesi terminal baru, gunakan curl untuk memulai percakapan dengan model Anda:

curl http://127.0.0.1:8000/v1/chat/completions \
-X POST \
-H "Content-Type: application/json" \
-d '{
    "model": "google/gemma-4-26B-A4B-it",
    "messages": [
        {
          "role": "user",
          "content": "Why is the sky blue?"
        }
    ],
    "chat_template_kwargs": {
         "enable_thinking": true
    },
    "skip_special_tokens": false
}'

Outputnya akan terlihat mirip seperti berikut:

{
  "id": "chatcmpl-be75ccfcbdf753d1",
  "object": "chat.completion",
  "created": 1775006187,
  "model": "google/gemma-4-26B-A4B-it",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "The short answer is a phenomenon called **Rayleigh scattering**.\n\nTo understand how it works, you have to look at three things: sunlight, the Earth's atmosphere, and how light travels.\n\n### 1. Sunlight is a Rainbow\nAlthough sunlight looks white to us, it is actually made up of all the colors of the rainbow (red, orange, yellow, green, blue, indigo, and violet). Light travels as **waves**, and each color has a different wavelength:\n*   **Red light** travels in long, lazy, wide waves.\n*   **Blue and violet light** travel in short, choppy, tight waves.\n\n### 2. The Atmosphere is an Obstacle Course\nEarth's atmosphere is filled with gases (mostly nitrogen and oxygen). As sunlight travels through the atmosphere, it strikes the molecules of these gases. \n\nBecause the gas molecules are very small, they affect the colors differently based on their wavelength:\n*   The **long waves** (reds and yellows) pass through the atmosphere mostly straight, without hitting much. They are like large ocean waves that roll right over small pebbles.\n*   The **short waves** (blues and violets) strike the gas molecules and get scattered in every direction. They are like small ripples that hit a pebble and splash everywhere.\n\nBecause this blue light is being scattered in every direction by the air, when you look up, your eyes are catching that scattered blue light coming from every part of the sky.\n\n### 3. Why isn't the sky violet?\nIf violet light has an even shorter wavelength than blue light, you might wonder why the sky doesn't look purple. There are two main reasons:\n1.  **The Sun's output:** The Sun emits much more blue light than violet light.\n2.  **Human Biology:** Human eyes are much more sensitive to blue than to violet. Our eyes interpret the scatter of mixed blue and violet light simply as pale blue.\n\n---\n\n### Bonus: Why are sunsets red?\nWhen the sun is setting, it is much lower on the horizon. This means the sunlight has to travel through a much **thicker** layer of the atmosphere to reach your eyes. \n\nBy the time the light gets to you, the blue light has been scattered away completely로. Only the long-wavelength colors—the reds, oranges, and pinks—are able to make it through that thick layer of air without being scattered away, creating the beautiful colors of a sunset.",
        "refusal": null,
        "annotations": null,
        "audio": null,
        "function_call": null,
        "tool_calls": [],
        "reasoning": "\"Why is the sky blue?\"\nScience/Physics (Atmospheric scattering).\nExplain the phenomenon clearly, accurately, and engagingly.\n\n    *   Sunlight (white light) is made of a spectrum of colors (ROYGBIV).\n    *   Earth's atmosphere is filled with gases (nitrogen, oxygen) and particles.\n    *   Rayleigh Scattering: Shorter wavelengths (blue/violet) scatter more easily than longer wavelengths (red/yellow) when hitting small gas molecules.\n    *   The human eye's sensitivity: Why isn't it violet?\n\n    A good scientific explanation should follow a logical flow:\n    *   *Direct Answer:* The core mechanism (Rayleigh Scattering).\n    *   *The Components:* Sunlight and the Atmosphere.\n    *   *The Mechanism:* How light interacts with gas molecules.\n    *   *The Wavelength Factor:* Comparing colors.\n    *   *The \"Wait, why not violet?\" question:* Addressing human perception.\n    *   *Bonus/Related concept:* Why sunsets are red.\n\n        *   Use the term **Rayleigh Scattering**.\n        *   Summarize: Its how sunlight interacts with the Earth's atmosphere.\n\n        *   Sunlight looks white, but it's actually a mix of all colors (the rainbow).\n        *   Each color travels as a different wavelength. Red = long/lazy waves; Blue/Violet = short/choppy waves.\n\n        *   The atmosphere is mostly Nitrogen and Oxygen.\n        *   When sunlight hits these tiny gas molecules, the light gets scattered in all directions.\n\n        *   Blue light travels in shorter, smaller waves.\n        *   Because these waves are small, they strike the gas molecules more frequently and get scattered more easily than the longer red/yellow waves.\n        *   Result: When you look up, your eyes are catching this \"scattered\" blue light coming from every direction.\n\n        *   *Technically*, violet light has an even shorter wavelength than blue, so it scatters *even more*. Why isn't the sky violet?\n        *   Two reasons: 1. The Sun emits more blue light than violet light. 2. Human eyes are much more sensitive to blue than violet.\n\n        *   Briefly mention sunsets to provide a complete picture.\n        *   At sunset, light travels through *more* atmosphere. The blue is scattered away completely, leaving only the long red/orange waves to reach your eyes.\n\n    *   *Tone Check:* Is it too academic? Use analogies (like waves in water or skipping stones) if needed, but keep it concise.\n    *   *Clarity:* Ensure the distinction between wavelength and scattering is clear."
      },
      "logprobs": null,
      "finish_reason": "stop",
      "stop_reason": 106,
      "token_ids": null
    }
  ],
  "service_tier": null,
  "system_fingerprint": null,
  "usage": {
    "prompt_tokens": 21,
    "total_tokens": 1122,
    "completion_tokens": 1101,
    "prompt_tokens_details": null
  },
  "prompt_logprobs": null,
  "prompt_token_ids": null,
  "kv_transfer_params": null
}

(Opsional) Berinteraksi dengan model melalui antarmuka chat Gradio

Di bagian ini, Anda akan membuat aplikasi chat web yang memungkinkan Anda berinteraksi dengan model yang telah disesuaikan untuk mengikuti perintah Anda. Agar mudah, bagian ini hanya menjelaskan pendekatan pengujian menggunakan model 4B-it.

Gradio adalah library Python yang memiliki wrapper ChatInterface yang membuat antarmuka pengguna untuk chatbot.

Men-deploy antarmuka chat

Di Cloud Shell, simpan manifes berikut sebagai gradio.yaml. Ubah google/gemma-4-E4B-it menjadi nama model Gemma 4 yang Anda gunakan dalam deployment.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gradio
  labels:
    app: gradio
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gradio
  template:
    metadata:
      labels:
        app: gradio
    spec:
      containers:
      - name: gradio
        image: us-docker.pkg.dev/google-samples/containers/gke/gradio-app:v1.0.7
        resources:
          requests:
            cpu: "250m"
            memory: "512Mi"
          limits:
            cpu: "500m"
            memory: "512Mi"
        env:
        - name: CONTEXT_PATH
          value: "/v1/chat/completions"
        - name: HOST
          value: "http://llm-service:8000"
        - name: LLM_ENGINE
          value: "openai-chat"
        - name: MODEL_ID
          value: "google/gemma-4-E4B-it"
        - name: DISABLE_SYSTEM_MESSAGE
          value: "true"
        ports:
        - containerPort: 7860
---
apiVersion: v1
kind: Service
metadata:
  name: gradio
spec:
  selector:
    app: gradio
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 7860
  type: ClusterIP

Terapkan manifes:
```
kubectl apply -f gradio.yaml
```

Tunggu hingga deployment tersedia:

kubectl wait --for=condition=Available --timeout=900s deployment/gradio

Menggunakan antarmuka chat

Jalankan perintah berikut di Cloud Shell:
```
kubectl port-forward service/gradio 8080:8080
```
Tindakan ini akan membuat penerusan port dari Cloud Shell ke layanan Gradio.
Klik tombol Web Preview yang dapat ditemukan di kanan atas panel tugas Cloud Shell. Klik Preview on Port 8080. Tab baru akan terbuka di browser Anda.
Berinteraksi dengan Gemma menggunakan antarmuka chat Gradio. Tambahkan perintah, lalu klik Kirim.

Memecahkan masalah

Jika Anda mendapatkan pesan Empty reply from server, kemungkinan penampung belum selesai mendownload data model. Periksa log Pod lagi untuk melihat pesan Connected yang menunjukkan bahwa model siap ditayangkan.
Jika Anda melihat Connection refused, pastikan penerusan port Anda aktif.

Mengamati performa model

Untuk melihat dasbor metrik kemampuan pengamatan model, ikuti langkah-langkah berikut:

Di konsol Google Cloud , buka halaman Deployed Models.

Buka Model yang Di-deploy
Untuk melihat detail tentang deployment tertentu, termasuk metrik, log, dan dasbornya, klik nama model dalam daftar.
Di halaman detail model, klik tab Observability untuk melihat dasbor berikut. Jika diminta, klik Enable untuk mengaktifkan pengumpulan metrik untuk cluster.
- Dasbor Penggunaan infrastruktur menampilkan metrik penggunaan.
- Dasbor DCGM menampilkan metrik DCGM.
- Jika Anda menggunakan vLLM, dasbor Performa model tersedia dan menampilkan metrik untuk performa model vLLM.

Anda juga dapat melihat metrik di integrasi dasbor vLLM di Cloud Monitoring. Metrik ini diagregasi untuk semua deployment vLLM tanpa filter preset

Untuk menggunakan dasbor di Cloud Monitoring, Anda harus mengaktifkan Google Cloud Managed Service for Prometheus, yang mengumpulkan metrik dari vLLM, di cluster GKE Anda. vLLM mengekspos metrik dalam format Prometheus secara default; Anda tidak perlu menginstal pengekspor tambahan. Untuk mengetahui informasi tentang cara menggunakan Google Cloud Managed Service for Prometheus untuk mengumpulkan metrik dari model Anda, lihat panduan kejelasan vLLM dalam dokumentasi Cloud Monitoring.

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 Anda buat dalam panduan ini, jalankan perintah berikut:

gcloud container clusters delete CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION

Ganti nilai berikut:

CONTROL_PLANE_LOCATION: region Compute Engine dari bidang kontrol cluster Anda.
CLUSTER_NAME: nama cluster Anda.

Langkah berikutnya

Pelajari lebih lanjut GPU di GKE.
Pelajari cara menggunakan Gemma dengan vLLM di akselerator lain, termasuk GPU A100 dan H100, dengan melihat kode contoh di GitHub.
Pelajari cara men-deploy workload GPU di Autopilot.
Pelajari cara men-deploy workload GPU di Standard.
Pelajari repositori GitHub dan dokumentasi vLLM.
Jelajahi Vertex AI Model Garden.
Pelajari cara menjalankan workload AI/ML yang dioptimalkan dengan kemampuan orkestrasi platform GKE.

Menyajikan model terbuka Gemma menggunakan GPU di GKE dengan vLLM Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Latar belakang

GPU

vLLM

Tujuan

Sebelum memulai

Memeriksa peran

Memberikan peran

Menyiapkan lingkungan Anda

Membuat dan mengonfigurasi resource Google Cloud

Membuat cluster dan node pool GKE

Autopilot

Standar

Men-deploy model Gemma 4 di vLLM menggunakan bobot Hugging Face

Prosedur

Gemma 4 E2B-it

Gemma 4 E4B-it

Gemma 4 26B-A4B-it

Gemma 4 31B-it

Verifikasi

Men-deploy Gemma yang telah disesuaikan dari Managed Lustre

Prasyarat

Prosedur

Verifikasi

Menyajikan model

Menyiapkan penerusan port

Berinteraksi dengan model menggunakan curl

(Opsional) Berinteraksi dengan model melalui antarmuka chat Gradio

Men-deploy antarmuka chat

Menggunakan antarmuka chat

Memecahkan masalah

Mengamati performa model

Pembersihan

Menghapus resource yang di-deploy

Langkah berikutnya

Menyajikan model terbuka Gemma menggunakan GPU di GKE dengan vLLM