Cara Deploy Gemma 4 di Produksi (vLLM + Docker)

Menjalankan Gemma 4 di laptopmu dengan Ollama itu bagus untuk pengembangan. Tapi saat kamu butuh melayani ratusan user concurrent, menangani ribuan permintaan per menit, dan menjaga latensi di bawah satu detik — kamu butuh inference engine grade produksi.

Di situlah vLLM berperan. Ini standar emas untuk melayani model bahasa besar di produksi, dan bekerja indah dengan Gemma 4.

Mengapa vLLM?

vLLM menggunakan PagedAttention, yang mengelola memori GPU seperti sistem operasi mengelola RAM — secara dinamis mengalokasikan dan membebaskan memori saat permintaan datang dan pergi. Hasilnya:

Throughput 2-4x lebih tinggi vs. inferensi naif
API yang kompatibel OpenAI — tukar Gemma 4 tanpa mengubah kode klien
Continuous batching — tidak ada siklus GPU yang terbuang antar permintaan
Tensor parallelism — pecah model besar ke beberapa GPU

Menginstal vLLM

# Buat environment bersih
python -m venv vllm-env
source vllm-env/bin/activate

# Instal vLLM dengan dukungan GPU
pip install vllm

Pastikan kamu punya driver CUDA yang tepat. vLLM butuh CUDA 12.1+ dan GPU dengan setidaknya 16GB VRAM untuk model Gemma 4 yang lebih kecil.

Melayani Gemma 4 dengan API yang Kompatibel OpenAI

Cara paling sederhana untuk memulai — satu perintah dan kamu punya endpoint API:

vllm serve google/gemma-4-26b \
  --host 0.0.0.0 \
  --port 8000 \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.90 \
  --dtype bfloat16

Sekarang kamu bisa memanggilnya dengan klien OpenAI SDK apa pun:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed",  # vLLM tidak butuh key secara default
)

response = client.chat.completions.create(
    model="google/gemma-4-26b",
    messages=[
        {"role": "user", "content": "Jelaskan quantum computing dalam satu paragraf."}
    ],
    temperature=0.7,
    max_tokens=256,
)

print(response.choices[0].message.content)

Keindahan ini: jika aplikasimu sudah menggunakan API OpenAI, kamu secara harfiah hanya mengubah base_url dan nama model. Semua yang lain tetap sama.

Perencanaan Memori GPU

Ini bagian yang sebagian besar orang keliru. Berikut apa yang sebenarnya kamu butuhkan:

Model	Presisi	VRAM Min	VRAM Direkomendasikan	Konteks Maks
Gemma 4 E4B	FP16	10 GB	16 GB	32K
Gemma 4 E4B	INT8	6 GB	10 GB	16K
Gemma 4 26B	BF16	52 GB	80 GB (A100)	32K
Gemma 4 26B	INT8	28 GB	40 GB (A100)	32K
Gemma 4 31B	BF16	62 GB	80 GB (A100)	32K

Tips pro: Flag --gpu-memory-utilization (default 0.9) mengontrol berapa banyak VRAM yang vLLM pra-alokasikan. Turunkan ke 0.8 jika kamu menjalankan proses lain di GPU yang sama. Butuh bantuan memikirkan hardware-mu? Cek panduan hardware kami.

Untuk setup multi-GPU:

# Bagi Gemma 4 26B di 2 GPU
vllm serve google/gemma-4-26b \
  --tensor-parallel-size 2 \
  --host 0.0.0.0 \
  --port 8000

Setup Docker

Docker adalah cara yang tepat untuk deploy di produksi. Berikut docker-compose.yml lengkap:

version: "3.8"

services:
  vllm:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - model-cache:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}
    command: >
      --model google/gemma-4-26b
      --host 0.0.0.0
      --port 8000
      --max-model-len 8192
      --gpu-memory-utilization 0.90
      --dtype bfloat16
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

volumes:
  model-cache:

Jalankan:

# Set token HuggingFace
export HF_TOKEN=your_token_here

# Mulai service
docker compose up -d

# Cek logs
docker compose logs -f vllm

# Verifikasi berjalan
curl http://localhost:8000/v1/models

Untuk pembahasan lebih mendalam tentang setup spesifik Docker, lihat panduan Docker kami.

Batch Inference

Saat kamu butuh memproses dataset besar — katakanlah, mengklasifikasi 10.000 dokumen — batch inference jauh lebih efisien daripada mengirim satu permintaan pada satu waktu:

from openai import OpenAI
import asyncio
import aiohttp

client = OpenAI(base_url="http://localhost:8000/v1", api_key="none")

async def process_batch(items, max_concurrent=50):
    semaphore = asyncio.Semaphore(max_concurrent)
    
    async def process_one(item):
        async with semaphore:
            response = client.chat.completions.create(
                model="google/gemma-4-26b",
                messages=[{"role": "user", "content": item}],
                max_tokens=128,
            )
            return response.choices[0].message.content
    
    tasks = [process_one(item) for item in items]
    return await asyncio.gather(*tasks)

# Proses 1000 item dengan hingga 50 permintaan concurrent
items = ["Klasifikasi teks ini: " + text for text in your_texts]
results = asyncio.run(process_batch(items))

vLLM menangani batching secara internal melalui continuous batching — ia mengelompokkan permintaan bersama-sama secara otomatis untuk utilisasi GPU maksimum.

Load Balancing

Untuk high availability, jalankan beberapa instance vLLM di belakang load balancer:

# nginx.conf
upstream vllm_backend {
    least_conn;
    server vllm-1:8000;
    server vllm-2:8000;
    server vllm-3:8000;
}

server {
    listen 80;

    location /v1/ {
        proxy_pass http://vllm_backend;
        proxy_set_header Host $host;
        proxy_read_timeout 120s;
    }
}

Vertex AI: Opsi Managed

Jika kamu tidak ingin mengelola infrastruktur sama sekali, Vertex AI Google menawarkan deployment Gemma 4 yang dikelola:

# Deploy via gcloud CLI
gcloud ai endpoints create \
  --region=us-central1 \
  --display-name=gemma4-endpoint

gcloud ai models upload \
  --region=us-central1 \
  --display-name=gemma-4-26b \
  --container-image-uri=us-docker.pkg.dev/vertex-ai/prediction/vllm-serve:latest \
  --artifact-uri=gs://your-bucket/gemma-4-26b

Vertex AI menangani scaling, monitoring, dan alokasi GPU. Kamu bayar per prediksi. Lebih mahal per query tapi overhead operasional jauh lebih sedikit.

Untuk perbandingan dengan Google AI Studio (tier gratis), cek panduan Google AI Studio kami.

Monitoring

Kamu harus memantau metrik ini di produksi:

import requests

# vLLM mengekspos metrik Prometheus
metrics = requests.get("http://localhost:8000/metrics").text

# Metrik kunci untuk dilacak:
# vllm:num_requests_running    — permintaan concurrent saat ini
# vllm:num_requests_waiting    — kedalaman antrian
# vllm:avg_generation_throughput — token per detik
# vllm:gpu_cache_usage_perc   — utilisasi KV cache

Setup alert untuk:

Kedalaman antrian > 100: Kamu butuh lebih banyak instance atau GPU lebih besar
GPU cache > 95%: Kurangi max-model-len atau tambah memori
p99 latency > 5 dtk: Waktunya scale secara horizontal
Tingkat error > 1%: Cek error OOM dan kesehatan model

Dashboard Grafana cepat dengan empat metrik ini akan menangkap sebagian besar masalah produksi sebelum user-mu menyadarinya.

Langkah Selanjutnya

Setup container Docker untuk deployment reproducible
Aktifkan structured JSON output untuk API consumer
Bandingkan arsitektur Gemma 4 untuk memilih model yang tepat untuk beban kerjamu
Pelajari tentang fine-tuning untuk menyesuaikan model dengan kasus penggunaanmu

gemma4 — interact