Rust पर vLLM के साथ Gemma 4 सर्व करना: मेरा वीकेंड एक्सपेरिमेंट जो सफल रहा 🦀

Rust पर vLLM के साथ Gemma 4 सर्व करना: मेरा वीकेंड एक्सपेरिमेंट जो सफल रहा 🦀

पिछले शनिवार मैं एक AWS बिल देख रहा था जिसने मेरा कॉफी ठंडा कर दिया। एक साइड प्रोजेक्ट के लिए तीन GPU इंस्टेंस PyTorch सर्विंग एंडपॉइंट्स चला रहे थे — दो दिन में $47। कोई न कोई बेहतर तरीका तो होना ही था।

फिर आए vLLM का Rust फ्रंटएंड (`vllm-rs`), Gemma 4, और एक Graviton2 इंस्टेंस T4G GPU के साथ। जो "चलो देखते हैं ये कंपाइल होता है या नहीं" दोपहर से शुरू हुआ, वो प्रोडक्शन-ग्रेड सर्विंग स्टैक बन गया जो पैसे में चलता है और कंकरेंट रिक्वेस्ट्स को चैंप की तरह हैंडल करता है।

यह रहा पूरा ब्रेकडाउन — कमियाँ, जीतें, और वो एक कॉन्फिग फ्लैग जिसने मुझे छह घंटे की डिबगिंग से बचाया।

ये स्टैक क्यों? (और अभी क्यों)

अगर आपने प्रोडक्शन में LLMs सर्व किए हैं, तो आप दर्द जानते हैं: Python का GIL लोड अंडर थ्रूपुट को मार देता है, CUDA मेमोरी फ्रैगमेंटेशन VRAM खा जाता है, और हर फ्रेमवर्क को अपना स्पेशल डॉकर इमेज चाहिए।

vLLM ने मेमोरी पार्ट PagedAttention से सॉल्व किया। लेकिन Python फ्रंटएंड? स्केल पर अभी भी बॉटलनेck है।

Rust इक्वेशन बदल देता है:
- **नो GIL** — असली पैरेलल रिक्वेस्ट हैंडलिंग
- **प्रिडिक्टेबल लेटेंसी** — जेनरेशन के बीच में कोई GC पॉज नहीं
- **सिंगल बाइनरी डिप्लॉयमेंट** — कॉपी करो, चलाओ, हो गया
- **Graviton2 + T4G** — ARM64 कंप्यूट + NVIDIA GPU स्पॉट पर $0.75/hr में

Gemma 4 (9B वैरिएंट) 16GB VRAM में आराम से फिट हो जाता है KV cache के लिए जगह छोड़कर। T4G के लिए परफेक्ट।

हार्डवेयर रियलिटी चेक

इंस्टेंस स्पिन अप करने से पहले, जान लो क्या मिल रहा है:

| कंपोनेंट | स्पेक | रियलिटी |
|-----------|------|---------|
| इंस्टेंस | `g5g.xlarge` | 4 vCPU, 16GB RAM, 1× T4G (16GB VRAM) |
| OS | Ubuntu 22.04 ARM64 | आउट ऑफ द बॉक्स काम करता है |
| स्टोरेज | 100GB gp3 | मॉडल + कैश + लॉग्स |
| नेटवर्क | अप टू 10 Gbps | काफी से ज्यादा |

**कॉस्ट**: ~$0.75/hr स्पॉट, ~$2.03/hr ऑन-डिमांड। मेरा टेस्ट वर्कलोड (200 रिक्वेस्ट/मिन, 512 टोकन एवरेज) $12/दिन में चला vs पुराने स्टैक पर $47।

स्टेप 1: Rust टूलचेन — इसे स्किप मत करना

```bash
rustup इंस्टॉल करो (ARM64 नेटिव)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
source "$HOME/.cargo/env"

क्रिटिकल: सही टारगेट यूज़ करो
rustup target add aarch64-unknown-linux-gnu

वेरिफाई करो
rustc --version
rustc 1.82.0 (f6e511eec 2024-10-15) — गुड
cargo --version
cargo 1.82.0 — गुड
```

**गोटचा**: अगर तुम x86_64 मशीन पर हो ARM के लिए बिल्ड कर रहे हो, तो क्रॉस-कंपाइलेशन चाहिए। बस ग्रैविटॉन2 इंस्टेंस *पर* बिल्ड करो। `cross` और लिंकर एरर्स से लड़ने से तेज़ है।

स्टेप 2: vLLM Rust फ्रंटएंड — `vllm-rs` बिल्ड करना

रेपो रहता है `github.com/vllm-project/vllm-rs` पर। क्लोन करो और बिल्ड करो:

```bash
git clone https://github.com/vllm-project/vllm-rs.git
cd vllm-rs

ये vLLM कोर को सबमॉड्यूल की तरह खींचता है — 5-10 मिनट लगते हैं
git submodule update --init --recursive

रिलीज बिल्ड करो (कॉफी पी लो, ~15 मिनट g5g.xlarge पर)
cargo build --release --features cuda
```

**वो फीचर फ्लैग जिसने मुझे काटा**: `--features cuda` मैंडेटरी है। इसके बिना CPU-ओनली बिल्ड मिलता है जो *दिखता* तो है जैसे काम कर रहा है लेकिन `llama.cpp` स्पीड पर फॉलबैक करता है। अपना बाइनरी चेक करो:

```bash
./target/release/vllm --help | grep -i cuda
दिखना चाहिए: CUDA support: true
```

स्टेप 3: Gemma 4 — वेट्स सही करना

Gemma 4 अभी तक हगिंग फेस हब पर सिंगल `safetensors` फाइल के रूप में नहीं है (लिखने के टाइम तक)। दो रास्ते हैं:

ऑप्शन A: HF से कन्वर्ट करो (रिकमेंडेड)
```bash
कन्वर्जन टूल्स इंस्टॉल करो
pip install huggingface_hub safetensors torch --index-url https://download.pytorch.org/whl/cu121

डाउनलोड और कन्वर्ट
python -c "
from huggingface_hub import snapshot_download
from safetensors.torch import save_file
import torch

path = snapshot_download('google/gemma-4-9b', allow_patterns='*.safetensors')
कन्वर्जन लॉजिक यहां — एक्जैक्ट स्क्रिप्ट के लिए vLLM डॉक्स देखो
"
```

ऑप्शन B: प्री-क्वांटाइज़्ड AWQ यूज़ करो (मैंने यही किया)
```bash
4-बिट AWQ ~6GB VRAM में फिट होता है, 10GB KV cache के लिए छोड़ देता है
wget https://huggingface.co/TheBloke/gemma-4-9b-AWQ/resolve/main/gemma-4-9b-awq.safetensors
```

**मेरा टेक**: AWQ 4-बिट ज्यादातर चैट यूज केसेज के लिए FP16 से अलग नहीं पहचाना जा सकता। थ्रूपुट गेन (2.3x टोकन/सेक) रियल है। अगर एक्जैक्ट लॉजिट्स चाहिए डिस्टिलेशन या इवैल के लिए, तो FP16 खुद कन्वर्ट करो।

स्टेप 4: वो कॉन्फिग जो असल में काम करता है

ये रहा मेरा `config.toml` — कॉपी करो, ट्वीक करो, डिप्लॉय करो:

```toml
config.toml
[model]
path = "/models/gemma-4-9b-awq.safetensors"
dtype = "float16" # AWQ इंटरनली FP16 की तरह लोड होता है
max_model_len = 8192

[server]
host = "0.0.0.0"
port = 8000
workers = 4 # vCPU काउंट से मैच करो
max_concurrent_requests = 128

[engine]
gpu_memory_utilization = 0.90
swap_space = 4 # GiB, CPU ऑफलोड बफर
block_size = 16
max_num_batched_tokens = 4096
max_num_seqs = 256

[logging]
level = "info"
access_log = true
```

**की फ्लैग्स एक्सप्लेन्ड**:
- `gpu_memory_utilization = 0.90` — 10% हेडरूम छोड़ो CUDA कॉन्टेक्स्ट + फ्रैगमेंटेशन के लिए। 0.95 पुश करो और बर्स्ट लोड अंडर OOM हो जाएगा।
- `swap_space = 4` — लॉन्ग कॉन्टेक्स्ट के लिए क्रिटिकल। लीस्ट-रिसेंटली-यूज़्ड KV ब्लॉक्स CPU RAM में ऑफलोड करता है। मुझे बचाया जब एक यूजर ने 12k टोकन का डॉक पेस्ट किया।
- `max_num_batched_tokens` — इसे ट्यून करो। बहुत लो = अंडरयूटिलाइज़्ड GPU। बहुत हाई = OOM। 4096 T4G + Gemma 4 9B के लिए स्वीट स्पॉट है।

स्टेप 5: Systemd — रीबूट के बाद भी जिंदा रखो

```ini
/etc/systemd/system/vllm-gemma.service
[Unit]
Description=vLLM Gemma 4 Rust Server
After=network.target nvidia-persistenced.service
Requires=nvidia-persistenced.service

[Service]
Type=simple
User=ubuntu
WorkingDirectory=/opt/vllm-rs
ExecStart=/opt/vllm-rs/target/release/vllm --config /opt/vllm-rs/config.toml
Restart=on-failure
RestartSec=10
Environment=RUST_LOG=info
Environment=CUDA_VISIBLE_DEVICES=0

रिसोर्स लिमिट्स
LimitNOFILE=65536
LimitNPROC=32768

[Install]
WantedBy=multi-user.target
```

इनेबल और स्टार्ट:
```bash
sudo systemctl daemon-reload
sudo systemctl enable --now vllm-gemma
journalctl -u vllm-gemma -f # लॉग्स देखो
```

रियल-वर्ल्ड टेस्ट: तीन सिनेरियो

सिनेरियो 1: डॉक्स बॉट के लिए चैट API (मेरा एक्चुअल यूज केस)
**लोड**: 50 कंकरेंट यूजर्स, 200 रिक्वेस्ट/मिन, एवरेज 512 आउटपुट टोकन
**रिजल्ट**:
- P50 लेटेंसी: 340ms (फर्स्ट टोकन)
- P99 लेटेंसी: 1.2s
- थ्रूपुट: 1,850 टोकन/सेक सस्टेन्ड
- VRAM: 11.2GB / 16GB
- 72 घंटे में जीरो OOMs

सिनेरियो 2: कोड कम्पलीशन बर्स्ट
**लोड**: 20 पैरेलल रिक्वेस्ट्स, 2k टोकन प्रॉम्प्ट्स, 512 कम्पलीशन
**रिजल्ट**:
- फर्स्ट टोकन: 410ms (लॉन्ग प्रॉम्प्ट प्रोसेसिंग)
- थ्रूपुट: 2,100 टोकन/सेक
- `swap_space` 14GB VRAM पर किक इन हुआ — सीमलेस

सिनेरियो 3: स्ट्रेस टेस्ट (Locust, 500 यूजर्स)
**लोड**: 5 मिनट में 500 कंकरेंट तक रैम्प
**रिजल्ट**:
- 300+ कंकरेंट पर क्यू टाइम डोमिनेटेड
- एरर रेट: 0.3% (टाइमआउट्स, क्रैश नहीं)
- रिकवरी: लोड गिरते ही इंस्टेंट

**टेकअवे**: Rust फ्रंटएंड बैकप्रेशर ग्रेसफुली हैंडल करता है। Python vLLM होता तो वर्कर प्रोसेस क्रैश हो गए होते।

मॉनिटरिंग: अंधे में मत उड़ो

Prometheus मेट्रिक्स ऐड करो (बिल्ट-इन `vllm-rs` में):

```bash
मेट्रिक्स एंडपॉइंट एक्सपोज़ करो
config.toml में ऐड करो:
[metrics]
enabled = true
port = 9090
```

की डैशबोर्ड्स जिन पर नज़र रखनी है:
- `vllm_requests_active` — करंट कंकरेंसी
- `vllm_gpu_memory_usage_bytes` — VRAM प्रेशर
- `vllm_iteration_tokens_total` — थ्रूपुट हेल्थ
- `vllm_request_duration_seconds` — लेटेंसी डिस्ट्रीब्यूशन

ग्राफाना डैशबोर्ड JSON: `github.com/vllm-project/vllm-rs/tree/main/monitoring/grafana`

"मैंने ये पहले क्यों नहीं किया" वाले मोमेंट्स

1. **सिंगल बाइनरी डिप्लॉयमेंट** — `scp` करो बाइनरी, `systemctl start`, हो गया। न डॉकर, न पायथन एन्व ड्रिफ्ट।
2. **कोल्ड स्टार्ट** — `systemctl start` से सर्विंग रिक्वेस्ट तक 2.3 सेकंड। Python vLLM: 18-25s (मॉडल लोड + वर्कर स्पॉन)।
3. **मेमोरी स्टेबिलिटी** — 72 घंटे, नो रीस्टार्ट। Python वर्कर्स को डेली रीस्टार्ट चाहिए था मेमोरी लीक्स के लिए।
4. **ARM64 नेटिव** — नो इमुलेशन टैक्स। ग्रैविटॉन2 इसे x86_64 से *बेहतर* चलाता है प्राइस/परफॉरमेंस पर।

क्या अभी भी चिढ़ाता है

- **मॉडल फॉर्मेट चर्न** — Gemma 4 AWQ ऑफिशियल नहीं है। नेक्स्ट रिलीज़ मेरा कन्वर्जन स्क्रिप्ट तोड़ सकती है।
- **लिमिटेड सैंपलिंग पैराम्स** — `vllm-rs` टेम्परेचर, top_p, top_k एक्सपोज़ करता है, लेकिन `min_p` या `typical_p` अभी नहीं। PR वेलकम।
- **नो मल्टी-GPU** — अभी सिंगल GPU ओनली। रोडमैप कहता है टेंसर पैरेललिज़्म Q1 2025 में आ रहा है।
- **लॉगिंग वर्बोसिटी** — `RUST_LOG=debug` 50MB/मिन उगलता है। प्रोड में `info` यूज़ करो।

FAQ

Q: क्या मैं इसे x86_64 इंस्टेंस पर A10G के साथ चला सकता हूँ?
**A**: बिल्कुल। इंस्टेंस टाइप चेंज करो `g5.xlarge` (A10G, 24GB VRAM) पर, x86_64 पर बिल्ड करो, और `gpu_memory_utilization` को 0.93 तक बम्प करो। Gemma 4 9B पर ~3,200 टोकन/सेक मिलेगा। कॉस्ट ~$1.00/hr स्पॉट पर जाता है।

Q: ये TGI (Text Generation Inference) से कैसे कम्पेयर करता है?
**A**: TGI ज्यादा फीचर-कम्पलीट है (क्वांटाइज़ेशन, शार्डिंग, फाइन-ग्रेन्ड स्ट्रीमिंग)। `vllm-rs` रॉ थ्रूपुट और Rust-नेटिव इंटीग्रेशन पर जीतता है। अगर आज LoRA अडैप्टर्स या स्पेक्युलेटिव डिकोडिंग चाहिए — TGI। अगर सिंगल GPU पर मैक्स टोकन/डॉलर चाहिए — `vllm-rs`।

Q: Gemma 4 27B का क्या?
**A**: T4G पर फिट नहीं होगा (16GB VRAM)। `g5g.2xlarge` चाहिए (2× T4G, 32GB कंबाइंड) टेंसर पैरेललिज़्म के साथ — अभी `vllm-rs` में सपोर्टेड नहीं। 27B के लिए TGI या vLLM Python पर A100/H100 के साथ रहो।

Q: क्या OpenAI-कम्पैटिबल API फुली इम्प्लीमेंटेड है?
**A**: `/v1/chat/completions` और `/v1/completions` काम करते हैं। `/v1/embeddings` 501 रिटर्न करता है (नॉट इम्प्लीमेंटेड)। स्ट्रीमिंग (`stream: true`) SSE के जरिए काम करती है। फंक्शन कॉलिंग — अभी नहीं।

---

TL;DR

**स्टैक**: Gemma 4 9B AWQ + vLLM Rust (`vllm-rs`) + Graviton2 + T4G
**कॉस्ट**: ~$12/दिन 200 रिक्वेस्ट/मिन सस्टेन्ड के लिए
**परफॉरमेंस**: 1,800-2,100 टोकन/सेक, P99 < 1.2s
**ऑप्स**: सिंगल बाइनरी, systemd, 2.3s कोल्ड स्टार्ट, 72घंटे में जीरो रीस्टार्ट

**रेपो**: `github.com/vllm-project/vllm-rs`
**मॉडल**: `huggingface.co/TheBloke/gemma-4-9b-AWQ`
**इंस्टेंस**: AWS `g5g.xlarge` स्पॉट

क्या मैं इसे प्रोडक्शन में चलाऊँगा पेइंग प्रोडक्ट के लिए? **हाँ** — इस चेतावनी के साथ कि तुम `vllm-rs` के ब्लीडिंग एज पर हो। अपना कमिट हैश पिन करो, रेपो वॉच करो, और Python vLLM फॉलबैक तैयार रखो।

लेकिन इंटरनल टूल्स, साइड प्रोजेक्ट्स, और कॉस्ट-सेंसिटिव वर्कलोड्स के लिए? ये स्टैक *यहाँ* है। Rust फ्रंटएंड vLLM को "ग्रेट इंजन, पेनफुल सर्विंग" से "ग्रेट इंजन, ग्रेट सर्विंग" में ट्रांसफॉर्म कर देता है।

अब अगर तुम माफ़ करो, मुझे एक AWS बिल श्रिंक करना है। ☕