vLLM Quickstart: Pengiriman LLM Berkinerja Tinggi

Inferensi LLM yang Cepat dengan API OpenAI

Konten Halaman

vLLM adalah mesin inferensi dan pelayanan (serving) berbasis throughput tinggi dan efisien penggunaan memori untuk Large Language Models (LLMs) yang dikembangkan oleh Sky Computing Lab dari UC Berkeley.

Dengan algoritma PagedAttention revolusionernya, vLLM mencapai throughput 14-24 kali lebih tinggi dibandingkan metode pelayanan tradisional, menjadikannya pilihan utama untuk penerapan LLM di produksi.

vllm logo

Apa itu vLLM?

vLLM (virtual LLM) adalah perpustakaan open-source untuk inferensi dan pelayanan LLM yang dengan cepat menjadi standar industri untuk penerapan produksi. Dirilis pada tahun 2023, ia memperkenalkan PagedAttention, teknik manajemen memori inovatif yang secara dramatis meningkatkan efisiensi pelayanan.

Fitur Utama

Kinerja Throughput Tinggi: vLLM memberikan throughput 14-24 kali lebih tinggi dibandingkan HuggingFace Transformers dengan perangkat keras yang sama. Kenaikan kinerja yang besar ini berasal dari batching kontinu, kernel CUDA yang dioptimalkan, dan algoritma PagedAttention yang menghilangkan fragmentasi memori.

Kompatibilitas API OpenAI: vLLM mencakup server API bawaan yang sepenuhnya kompatibel dengan format OpenAI. Ini memungkinkan migrasi yang mulus dari OpenAI ke infrastruktur self-hosted tanpa mengubah kode aplikasi. Cukup arahkan klien API Anda ke endpoint vLLM dan berjalan secara transparan.

Algoritma PagedAttention: Inovasi inti di balik kinerja vLLM adalah PagedAttention, yang menerapkan konsep paging memori virtual ke mekanisme perhatian. Sebaliknya dari mengalokasikan blok memori kontinu untuk cache KV (yang menyebabkan fragmentasi), PagedAttention membagi memori menjadi blok ukuran tetap yang dapat dialokasikan secara on-demand. Ini mengurangi pemborosan memori hingga 4 kali dan memungkinkan ukuran batch yang jauh lebih besar.

Batching Kontinu: Berbeda dengan batching statis di mana Anda harus menunggu semua urutan selesai, vLLM menggunakan batching kontinu (rolling). Sebagai segera satu urutan selesai, urutan baru dapat ditambahkan ke batch. Ini memaksimalkan penggunaan GPU dan meminimalkan latensi untuk permintaan masuk.

Dukungan Multi-GPU: vLLM mendukung tensor parallelism dan pipeline parallelism untuk mendistribusikan model besar ke beberapa GPU. Ini dapat melayani model yang tidak muat dalam memori satu GPU, mendukung konfigurasi dari 2 hingga 8+ GPU.

Dukungan Model Luas: Kompatibel dengan arsitektur model populer seperti LLaMA, Mistral, Mixtral, Qwen, Phi, Gemma, dan banyak lainnya. Mendukung model yang dilatih untuk instruksi dan model dasar dari HuggingFace Hub.

Kapan Menggunakan vLLM

vLLM unggul dalam skenario tertentu di mana kekuatannya terlihat:

Layanan API Produksi: Ketika Anda perlu melayani LLM untuk banyak pengguna koncurrent melalui API, throughput tinggi dan batching efisien vLLM menjadi pilihan terbaik. Perusahaan yang menjalankan chatbot, asisten kode, atau layanan pembuatan konten manfaat dari kemampuannya untuk menangani ratusan permintaan per detik.

Workload Konkurensi Tinggi: Jika aplikasi Anda memiliki banyak pengguna simultan yang membuat permintaan, batching kontinu dan PagedAttention vLLM memungkinkan pelayanan lebih banyak pengguna dengan perangkat keras yang sama dibandingkan alternatif.

Optimasi Biaya: Ketika biaya GPU menjadi kekhawatiran, throughput unggul vLLM berarti Anda dapat melayani lalu lintas yang sama dengan lebih sedikit GPU, langsung mengurangi biaya infrastruktur. Efisiensi memori 4 kali dari PagedAttention juga memungkinkan penggunaan instansi GPU yang lebih kecil dan murah.

Deployments Kubernetes: Desain stateless dan arsitektur ramah kontainer vLLM membuatnya ideal untuk klaster Kubernetes. Kinerjanya yang konsisten di bawah beban dan manajemen sumber daya yang sederhana terintegrasi dengan baik dengan infrastruktur native cloud.

Kapan Tidak Menggunakan vLLM: Untuk pengembangan lokal, eksperimen, atau skenario single-user, alat seperti Ollama memberikan pengalaman pengguna yang lebih baik dengan setup yang lebih sederhana. Kompleksitas vLLM dibenarkan ketika Anda membutuhkan keunggulan kinerjanya untuk beban kerja produksi.

Cara Menginstal vLLM

Prasyarat

Sebelum menginstal vLLM, pastikan sistem Anda memenuhi persyaratan berikut:

  • GPU: NVIDIA GPU dengan compute capability 7.0+ (V100, T4, A10, A100, H100, RTX 20/30/40 series)
  • CUDA: Versi 11.8 atau lebih tinggi
  • Python: 3.8 hingga 3.11
  • VRAM: Minimum 16GB untuk model 7B, 24GB+ untuk 13B, 40GB+ untuk model yang lebih besar
  • Driver: NVIDIA driver 450.80.02 atau lebih baru

Instalasi via pip

Metode instalasi paling sederhana adalah menggunakan pip. Ini berfungsi pada sistem dengan CUDA 11.8 atau lebih baru:

# Membuat lingkungan virtual (direkomendasikan)
python3 -m venv vllm-env
source vllm-env/bin/activate

# Menginstal vLLM
pip install vllm

# Memverifikasi instalasi
python -c "import vllm; print(vllm.__version__)"

Untuk sistem dengan versi CUDA berbeda, instal roda yang sesuai:

# Untuk CUDA 12.1
pip install vllm==0.4.2+cu121 -f https://github.com/vllm-project/vllm/releases

# Untuk CUDA 11.8
pip install vllm==0.4.2+cu118 -f https://github.com/vllm-project/vllm/releases

Instalasi dengan Docker

Docker menyediakan metode deployment yang paling andal, terutama untuk produksi:

# Tarik gambar vLLM resmi
docker pull vllm/vllm-openai:latest

# Jalankan vLLM dengan dukungan GPU
docker run --runtime nvidia --gpus all \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:latest \
    --model mistralai/Mistral-7B-Instruct-v0.2

Flag --ipc=host penting untuk setup multi-GPU karena memungkinkan komunikasi antar-proses yang tepat.

Membangun dari Sumber

Untuk fitur terbaru atau modifikasi khusus, bangun dari sumber:

git clone https://github.com/vllm-project/vllm.git
cd vllm
pip install -e .

Panduan Quickstart vLLM

Menjalankan Model Pertama Anda

Mulai vLLM dengan model menggunakan antarmuka perintah:

# Unduh dan layani Mistral-7B dengan API yang kompatibel dengan OpenAI
python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --port 8000

vLLM akan secara otomatis mengunduh model dari HuggingFace Hub (jika belum dikach) dan memulai server. Anda akan melihat output yang menunjukkan server siap:

INFO:     Started server process [12345]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000

Membuat Permintaan API

Setelah server berjalan, Anda dapat membuat permintaan menggunakan klien Python OpenAI atau curl:

Menggunakan curl:

curl http://localhost:8000/v1/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "mistralai/Mistral-7B-Instruct-v0.2",
        "prompt": "Jelaskan apa itu vLLM dalam satu kalimat:",
        "max_tokens": 100,
        "temperature": 0.7
    }'

Menggunakan Klien Python OpenAI:

from openai import OpenAI

# Arahkan ke server vLLM Anda
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"  # vLLM tidak memerlukan autentikasi secara default
)

response = client.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    prompt="Jelaskan apa itu vLLM dalam satu kalimat:",
    max_tokens=100,
    temperature=0.7
)

print(response.choices[0].text)

API Chat Completions:

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[
        {"role": "system", "content": "Anda adalah asisten yang ramah."},
        {"role": "user", "content": "Apa itu PagedAttention?"}
    ],
    max_tokens=200
)

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

Konfigurasi Lanjutan

vLLM menawarkan berbagai parameter untuk mengoptimalkan kinerja:

python -m vllm.entrypoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --port 8000 \
    --gpu-memory-utilization 0.95 \  # Gunakan 95% memori GPU
    --max-model-len 8192 \            # Panjang maksimum urutan
    --tensor-parallel-size 2 \        # Gunakan 2 GPU dengan tensor parallelism
    --dtype float16 \                 # Gunakan presisi FP16
    --max-num-seqs 256                # Ukuran batch maksimum

Penjelasan Parameter Penting:

  • --gpu-memory-utilization: Seberapa banyak memori GPU yang digunakan (0.90 = 90%). Nilai yang lebih tinggi memungkinkan batch yang lebih besar tetapi meninggalkan sedikit margin untuk lonjakan memori.
  • --max-model-len: Panjang konteks maksimum. Mengurangi ini menghemat memori untuk batch yang lebih besar.
  • --tensor-parallel-size: Jumlah GPU untuk membagi model.
  • --dtype: Tipe data untuk bobot (float16, bfloat16, atau float32). FP16 biasanya optimal.
  • --max-num-seqs: Jumlah maksimum urutan yang diproses dalam satu batch.

Perbandingan vLLM vs Ollama

Kedua vLLM dan Ollama adalah pilihan populer untuk hosting LLM lokal, tetapi mereka menargetkan skenario penggunaan yang berbeda. Memahami kapan menggunakan alat masing-masing dapat secara signifikan memengaruhi keberhasilan proyek Anda.

Kinerja dan Throughput

vLLM dirancang untuk throughput maksimal dalam skenario multi-pengguna. Algoritma PagedAttention dan batching kontinu memungkinkan pelayanan ratusan permintaan koncurrent secara efisien. Uji kinerja menunjukkan vLLM mencapai throughput 14-24 kali lebih tinggi dibandingkan implementasi standar dan 2-4 kali lebih tinggi dibandingkan Ollama di bawah konkurensi tinggi.

Ollama mengoptimalkan untuk penggunaan interaktif single-pengguna dengan fokus pada latensi rendah untuk permintaan individu. Meskipun tidak cocok dengan throughput multi-pengguna vLLM, ia menyediakan kinerja yang sangat baik untuk pengembangan dan penggunaan pribadi dengan waktu cold-start yang lebih cepat dan konsumsi sumber daya idle yang lebih rendah.

Kemudahan Penggunaan

Ollama menang secara tegas dalam kesederhanaan. Instalasi hanya memerlukan satu perintah (curl | sh), dan menjalankan model seederhana seperti ollama run llama2. Ia mencakup perpustakaan model dengan versi yang dikuantisasi yang dioptimalkan untuk berbagai profil perangkat keras. Pengalaman pengguna mirip dengan Docker – tarik, jalankan, dan pergi.

vLLM memerlukan lebih banyak pengaturan: manajemen lingkungan Python, instalasi CUDA, pemahaman tentang parameter pelayanan, dan spesifikasi model manual. Kurva pembelajaran lebih curam, tetapi Anda mendapatkan kontrol halus terhadap optimasi kinerja. Kompleksitas ini dibenarkan untuk deployment produksi di mana Anda perlu memaksimalkan kinerja perangkat keras.

API dan Integrasi

vLLM menyediakan API REST yang kompatibel dengan OpenAI secara langsung, menjadikannya pengganti drop-in untuk API OpenAI dalam aplikasi yang ada. Ini sangat penting untuk memigrasikan layanan produksi dari penyedia cloud ke infrastruktur self-hosted tanpa perubahan kode.

Ollama menyediakan API REST yang lebih sederhana dan perpustakaan Python/JavaScript khusus. Meskipun fungsional, ia tidak kompatibel dengan OpenAI, memerlukan perubahan kode saat mengintegrasikan dengan aplikasi yang mengharapkan format OpenAI. Namun, proyek komunitas seperti Ollama-OpenAI adapters mengisi celah ini.

Manajemen Memori

vLLM algoritma PagedAttention menyediakan efisiensi memori yang lebih unggul untuk permintaan koncurrent. Ia dapat melayani 2-4 kali lebih banyak pengguna koncurrent dengan VRAM yang sama dibandingkan implementasi sederhana. Ini secara langsung mengubah ke dalam penghematan biaya di deployment produksi.

Ollama menggunakan manajemen memori yang lebih sederhana yang cocok untuk skenario single-pengguna. Ia secara otomatis mengelola pemuatan/unloading model berdasarkan aktivitas, yang nyaman untuk pengembangan tetapi tidak optimal untuk penggunaan produksi konkurensi tinggi.

Dukungan Multi-GPU

vLLM unggul dengan parallelism tensor dan pipeline parallelism bawaan, mendistribusikan model secara efisien di 2-8+ GPU. Ini sangat penting untuk melayani model besar seperti LLM dengan 70B parameter yang tidak muat dalam memori satu GPU.

Ollama saat ini memiliki dukungan multi-GPU yang terbatas, bekerja terbaik dengan satu GPU. Ini membuatnya kurang cocok untuk model besar yang memerlukan inferensi terdistribusi.

Rekomendasi Penggunaan

Pilih vLLM ketika:

  • Melayani API produksi dengan banyak pengguna koncurrent
  • Mengoptimalkan biaya per permintaan dalam deployment cloud
  • Berjalan di Kubernetes atau platform orchestrasi container
  • Membutuhkan kompatibilitas API OpenAI untuk aplikasi yang ada
  • Melayani model besar yang memerlukan dukungan multi-GPU
  • Kinerja dan throughput adalah persyaratan kritis

Pilih Ollama ketika:

  • Pengembangan lokal dan eksperimen
  • Penggunaan interaktif single-pengguna (asisten pribadi, chatbot)
  • Prototipe cepat dan evaluasi model
  • Belajar tentang LLM tanpa kompleksitas infrastruktur
  • Berjalan di workstation pribadi atau laptop
  • Prioritas kesederhanaan dan kemudahan penggunaan

Banyak tim menggunakan keduanya: Ollama untuk pengembangan dan eksperimen, lalu vLLM untuk deployment produksi. Kombinasi ini menyediakan produktivitas pengembang sambil mempertahankan kinerja produksi.

Perbandingan vLLM vs Docker Model Runner

Docker baru-baru ini memperkenalkan Model Runner (sebelumnya GenAI Stack) sebagai solusi resmi mereka untuk deployment model AI lokal. Bagaimana ini dibandingkan dengan vLLM?

Filosofi Arsitektur

Docker Model Runner bertujuan menjadi “Docker untuk AI” – cara sederhana dan standar untuk menjalankan model AI secara lokal dengan kemudahan yang sama seperti menjalankan container. Ia mengabstraksi kompleksitas dan menyediakan antarmuka yang konsisten di berbagai model dan framework.

vLLM adalah engine inferensi khusus yang fokus hanya pada pelayanan LLM dengan kinerja maksimal. Ini adalah alat level yang lebih rendah yang Anda containerize dengan Docker, bukan platform lengkap.

Setup dan Memulai

Docker Model Runner instalasi sederhana untuk pengguna Docker:

docker model pull llama3:8b
docker model run llama3:8b

Kemiripan ini dengan alur kerja Docker image membuatnya langsung dikenal oleh pengembang yang sudah menggunakan container.

vLLM memerlukan setup awal yang lebih banyak (Python, CUDA, dependensi) atau menggunakan gambar Docker yang sudah dibuat:

docker pull vllm/vllm-openai:latest
docker run --runtime nvidia --gpus all vllm/vllm-openai:latest --model <model-name>

Karakteristik Kinerja

vLLM memberikan throughput yang lebih unggul untuk skenario multi-pengguna karena PagedAttention dan batching kontinu. Untuk layanan API produksi yang menangani ratusan permintaan per detik, optimasi vLLM memberikan 2-5 kali lebih baik dibandingkan pendekatan pelayanan umum.

Docker Model Runner fokus pada kemudahan penggunaan daripada kinerja maksimal. Ia cocok untuk pengembangan lokal, pengujian, dan beban kerja moderat, tetapi tidak mengimplementasikan optimasi lanjutan yang membuat vLLM unggul pada skala besar.

Dukungan Model

Docker Model Runner menyediakan perpustakaan model yang dipilih dengan akses satu perintah ke model populer. Ia mendukung berbagai framework (tidak hanya LLM) termasuk Stable Diffusion, Whisper, dan model AI lainnya, membuatnya lebih fleksibel untuk berbagai beban kerja AI.

vLLM khusus untuk inferensi LLM dengan dukungan mendalam untuk model bahasa berbasis transformer. Ia mendukung setiap LLM yang kompatibel dengan HuggingFace tetapi tidak menjangkau jenis model AI lain seperti pembuatan gambar atau pengenalan suara.

Deployment Produksi

vLLM telah diuji coba dalam produksi di perusahaan seperti Anthropic, Replicate, dan banyak lainnya yang melayani miliaran token setiap hari. Karakteristik kinerjanya dan stabilitasnya di bawah beban berat membuatnya menjadi standar de facto untuk pelayanan LLM produksi.

Docker Model Runner lebih baru dan menempatkan dirinya lebih untuk skenario pengembangan dan pengujian lokal. Meskipun bisa melayani lalu lintas produksi, ia kurang memiliki rekam jejak dan optimasi kinerja yang diperlukan untuk deployment produksi.

Ekosistem Integrasi

vLLM terintegrasi dengan alat infrastruktur produksi: operator Kubernetes, metrik Prometheus, Ray untuk pelayanan terdistribusi, dan kompatibilitas API OpenAI yang luas untuk aplikasi yang ada.

Docker Model Runner terintegrasi secara alami dengan ekosistem Docker dan Docker Desktop. Untuk tim yang sudah standar di Docker, integrasi ini menyediakan pengalaman yang koheren tetapi lebih sedikit fitur khusus LLM pelayanan.

Kapan Menggunakan Masing-Masing

Gunakan vLLM untuk:

  • Layanan API LLM produksi
  • Deployment multi-pengguna dengan throughput tinggi
  • Deployment cloud yang sensitif biaya yang memerlukan efisiensi maksimal
  • Lingkungan Kubernetes dan cloud-native
  • Ketika Anda membutuhkan skalabilitas dan kinerja yang terbukti

Gunakan Docker Model Runner untuk:

  • Pengembangan lokal dan pengujian
  • Menjalankan berbagai jenis model AI (tidak hanya LLM)
  • Tim yang sangat terinvestasi dalam ekosistem Docker
  • Eksperimen cepat tanpa setup infrastruktur
  • Tujuan pembelajaran dan pendidikan

Pendekatan Hybrid: Banyak tim mengembangkan dengan Docker Model Runner secara lokal untuk kenyamanan, lalu mendeploy dengan vLLM dalam produksi untuk kinerja. Gambar Docker Model Runner juga dapat digunakan untuk menjalankan container vLLM, menggabungkan kedua pendekatan.

Best Practices Deployment Produksi

Deployment Docker

Buat konfigurasi Docker Compose yang siap produksi:

version: '3.8'

services:
  vllm:
    image: vllm/vllm-openai:latest
    runtime: nvidia
    environment:
      - CUDA_VISIBLE_DEVICES=0,1
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
      - ./logs:/logs
    ports:
      - "8000:8000"
    command: >
      --model mistralai/Mistral-7B-Instruct-v0.2
      --tensor-parallel-size 2
      --gpu-memory-utilization 0.90
      --max-num-seqs 256
      --max-model-len 8192      
    restart: unless-stopped
    shm_size: '16gb'
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 2
              capabilities: [gpu]

Deployment Kubernetes

Deploy vLLM di Kubernetes untuk skala produksi:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-server
spec:
  replicas: 2
  selector:
    matchLabels:
      app: vllm
  template:
    metadata:
      labels:
        app: vllm
    spec:
      containers:
      - name: vllm
        image: vllm/vllm-openai:latest
        args:
          - --model
          - mistralai/Mistral-7B-Instruct-v0.2
          - --tensor-parallel-size
          - "2"
          - --gpu-memory-utilization
          - "0.90"
        resources:
          limits:
            nvidia.com/gpu: 2
        ports:
        - containerPort: 8000
        volumeMounts:
        - name: cache
          mountPath: /root/.cache/huggingface
      volumes:
      - name: cache
        hostPath:
          path: /mnt/huggingface-cache
---
apiVersion: v1
kind: Service
metadata:
  name: vllm-service
spec:
  selector:
    app: vllm
  ports:
  - port: 80
    targetPort: 8000
  type: LoadBalancer

Monitoring dan Observabilitas

vLLM mengungkapkan metrik Prometheus untuk pemantauan:

import requests

# Mendapatkan metrik
metrics = requests.get("http://localhost:8000/metrics").text
print(metrics)

Metrik kunci untuk dipantau:

  • vllm:num_requests_running - Permintaan aktif
  • vllm:gpu_cache_usage_perc - Penggunaan cache GPU
  • vllm:time_to_first_token - Metrik latensi
  • vllm:time_per_output_token - Kecepatan pembuatan

Penyempurnaan Kinerja

Optimalkan Penggunaan Memori GPU: Mulai dengan --gpu-memory-utilization 0.90 dan sesuaikan berdasarkan perilaku yang diamati. Nilai yang lebih tinggi memungkinkan batch yang lebih besar tetapi berisiko kesalahan OOM selama puncak lalu lintas.

Atur Panjang Urutan Maksimum: Jika kasus penggunaan Anda tidak memerlukan panjang konteks penuh, kurangi --max-model-len. Ini membebaskan memori untuk batch yang lebih besar. Misalnya, jika Anda hanya memerlukan konteks 4K, set --max-model-len 4096 alih-alih menggunakan maksimum model (seringkali 8K-32K).

Pilih Kuantisasi yang Tepat: Untuk model yang mendukungnya, gunakan versi yang dikuantisasi (8-bit, 4-bit) untuk mengurangi memori dan meningkatkan throughput:

--quantization awq  # Untuk model yang dikuantisasi dengan AWQ
--quantization gptq # Untuk model yang dikuantisasi dengan GPTQ

Aktifkan Caching Prefix: Untuk aplikasi dengan prompt berulang (seperti chatbot dengan pesan sistem), aktifkan caching prefix:

--enable-prefix-caching

Ini menyimpan nilai KV untuk prefix umum, mengurangi komputasi untuk permintaan yang berbagi prefix prompt yang sama.

Mengatasi Masalah Umum

Kesalahan Out of Memory

Gejala: Server crash dengan kesalahan CUDA out of memory.

Solusi:

  • Kurangi --gpu-memory-utilization ke 0.85 atau 0.80
  • Kurangi --max-model-len jika kasus penggunaan memungkinkan
  • Kurangi --max-num-seqs untuk mengurangi ukuran batch
  • Gunakan versi model yang dikuantisasi
  • Aktifkan tensor parallelism untuk mendistribusikan ke lebih banyak GPU

Throughput Rendah

Gejala: Server menangani lebih sedikit permintaan dari yang diharapkan.

Solusi:

  • Tingkatkan --max-num-seqs untuk memungkinkan batch yang lebih besar
  • Tingkatkan --gpu-memory-utilization jika Anda memiliki ruang
  • Periksa apakah CPU menjadi bottleneck dengan htop – pertimbangkan CPU yang lebih cepat
  • Verifikasi penggunaan GPU dengan nvidia-smi – seharusnya 95%+
  • Aktifkan FP16 jika menggunakan FP32: --dtype float16

Waktu Pertama Token Lambat

Gejala: Latensi tinggi sebelum pembuatan dimulai.

Solusi:

  • Gunakan model yang lebih kecil untuk aplikasi kritis latensi
  • Aktifkan caching prefix untuk prompt berulang
  • Kurangi --max-num-seqs untuk memprioritaskan latensi daripada throughput
  • Pertimbangkan decoding spekulatif untuk model yang didukung
  • Optimalkan konfigurasi parallelism tensor

Gagal Memuat Model

Gejala: Server gagal dimulai, tidak bisa memuat model.

Solusi:

  • Verifikasi nama model cocok dengan format HuggingFace secara tepat
  • Periksa koneksi jaringan ke HuggingFace Hub
  • Pastikan ada ruang disk yang cukup di ~/.cache/huggingface
  • Untuk model yang terkunci, set variabel lingkungan HF_TOKEN
  • Coba unduh secara manual dengan huggingface-cli download <model>

Fitur Lanjutan

Decoding Spekulatif

vLLM mendukung decoding spekulatif, di mana model draft yang lebih kecil mengusulkan token yang diverifikasi oleh model target yang lebih besar. Ini dapat mempercepat pembuatan sebesar 1,5-2 kali:

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-70b-chat-hf \
    --speculative-model meta-llama/Llama-2-7b-chat-hf \
    --num-speculative-tokens 5

Adapter LoRA

Layani beberapa adapter LoRA di atas model dasar tanpa memuat beberapa model penuh:

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-2-7b-hf \
    --enable-lora \
    --lora-modules sql-lora=./path/to/sql-adapter \
                   code-lora=./path/to/code-adapter

Kemudian tentukan adapter mana yang digunakan per permintaan:

response = client.completions.create(
    model="sql-lora",  # Gunakan adapter SQL
    prompt="Konversi ini ke SQL: Tunjukkan semua pengguna yang dibuat bulan ini"
)

Pelayanan Multi-LoRA

Pelayanan multi-LoRA vLLM memungkinkan menjalankan puluhan adapter fine-tuned dengan overhead memori minimal. Ini ideal untuk menjalankan variant model khusus pelanggan atau tugas:

# Permintaan dengan adapter LoRA khusus
response = client.chat.completions.create(
    model="meta-llama/Llama-2-7b-hf",
    messages=[{"role": "user", "content": "Buat query SQL"}],
    extra_body={"lora_name": "sql-lora"}
)

Caching Prefix

Aktifkan caching prefix otomatis untuk menghindari menghitung ulang cache KV untuk prefix prompt yang berulang:

--enable-prefix-caching

Ini sangat efektif untuk:

  • Chatbot dengan prompt sistem tetap
  • Aplikasi RAG dengan template konteks konsisten
  • Prompt few-shot yang berulang di seluruh permintaan

Caching prefix dapat mengurangi waktu ke token pertama sebesar 50-80% untuk permintaan yang berbagi prefix prompt.

Contoh Integrasi

Integrasi LangChain

from langchain.llms import VLLMOpenAI

llm = VLLMOpenAI(
    openai_api_key="EMPTY",
    openai_api_base="http://localhost:8000/v1",
    model_name="mistralai/Mistral-7B-Instruct-v0.2",
    max_tokens=512,
    temperature=0.7,
)

response = llm("Jelaskan PagedAttention dalam istilah sederhana")
print(response)

Integrasi LlamaIndex

from llama_index.llms import VLLMServer

llm = VLLMServer(
    api_url="http://localhost:8000/v1",
    model="mistralai/Mistral-7B-Instruct-v0.2",
    temperature=0.7,
    max_tokens=512
)

response = llm.complete("Apa itu vLLM?")
print(response)

Aplikasi FastAPI

from fastapi import FastAPI
from openai import AsyncOpenAI

app = FastAPI()
client = AsyncOpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"
)

@app.post("/generate")
async def generate(prompt: str):
    response = await client.completions.create(
        model="mistralai/Mistral-7B-Instruct-v0.2",
        prompt=prompt,
        max_tokens=200
    )
    return {"result": response.choices[0].text}

Benchmark Kinerja

Data kinerja dunia nyata membantu mengilustrasikan keunggulan vLLM:

Perbandingan Throughput (Mistral-7B pada GPU A100):

  • vLLM: ~3.500 token/detik dengan 64 pengguna koncurrent
  • HuggingFace Transformers: ~250 token/detik dengan koncurrent yang sama
  • Ollama: ~1.200 token/detik dengan koncurrent yang sama
  • Hasil: vLLM memberikan peningkatan 14 kali dibandingkan implementasi dasar

Efisiensi Memori (LLaMA-2-13B):

  • Implementasi standar: 24GB VRAM, 32 urutan koncurrent
  • vLLM dengan PagedAttention: 24GB VRAM, 128 urutan koncurrent
  • Hasil: 4 kali lebih banyak permintaan koncurrent dengan memori yang sama

Latensi di Bawah Beban (Mixtral-8x7B pada 2xA100):

  • vLLM: P50 latensi 180ms, P99 latensi 420ms pada 100 req/s
  • Pelayanan standar: P50 latensi 650ms, P99 latensi 3.200ms pada 100 req/s
  • Hasil: vLLM mempertahankan konsistensi latensi di bawah beban tinggi

Benchmark ini menunjukkan mengapa vLLM telah menjadi standar de facto untuk pelayanan LLM produksi di mana kinerja penting.

Analisis Biaya

Memahami implikasi biaya dari memilih vLLM:

Skenario: Melayani 1 juta permintaan/hari

Dengan Pelayanan Standar:

  • Diperlukan: 8x A100 GPU (80GB)
  • Biaya AWS: ~$32/jam × 24 × 30 = $23.040/bulan
  • Biaya per 1 juta token: ~$0,75

Dengan vLLM:

  • Diperlukan: 2x A100 GPU (80GB)
  • Biaya AWS: ~$8/jam × 24 × 30 = $5.760/bulan
  • Biaya per 1 juta token: ~$0,19
  • Penghematan: $17.280/bulan (75% pengurangan)

Keuntungan biaya ini meningkat dengan skala. Organisasi yang melayani miliaran token bulanan menghemat ratusan ribu dolar dengan menggunakan pelayanan vLLM yang dioptimalkan daripada implementasi dasar.

Pertimbangan Keamanan

Otentikasi

vLLM tidak mencakup otentikasi secara default. Untuk produksi, implementasikan otentikasi di level reverse proxy:

# Konfigurasi Nginx
location /v1/ {
    auth_request /auth;
    proxy_pass http://vllm-backend:8000;
}

location /auth {
    proxy_pass http://auth-service:8080/verify;
    proxy_pass_request_body off;
    proxy_set_header Content-Length "";
    proxy_set_header X-Original-URI $request_uri;
}

Atau gunakan API gateways seperti Kong, Traefik, atau AWS API Gateway untuk otentikasi dan pembatasan laju tingkat perusahaan.

Isolasi Jaringan

Jalankan vLLM di jaringan pribadi, tidak secara langsung terpapar internet:

# Contoh NetworkPolicy Kubernetes
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: vllm-access
spec:
  podSelector:
    matchLabels:
      app: vllm
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          role: api-gateway
    ports:
    - protocol: TCP
      port: 8000

Pembatasan Laju

Implementasikan pembatasan laju untuk mencegah penyalahgunaan:

# Contoh menggunakan Redis untuk pembatasan laju
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
import redis
from datetime import datetime, timedelta

app = FastAPI()
redis_client = redis.Redis(host='localhost', port=6379)

@app.middleware("http")
async def rate_limit_middleware(request, call_next):
    client_ip = request.client.host
    key = f"rate_limit:{client_ip}"
    
    requests = redis_client.incr(key)
    if requests == 1:
        redis_client.expire(key, 60)  # Jendela 60 detik
    
    if requests > 60:  # 60 permintaan per menit
        raise HTTPException(status_code=429, detail="Rate limit exceeded")
    
    return await call_next(request)

Kontrol Akses Model

Untuk deployment multi-tenant, kendalikan pengguna mana yang dapat mengakses model mana:

ALLOWED_MODELS = {
    "user_tier_1": ["mistralai/Mistral-7B-Instruct-v0.2"],
    "user_tier_2": ["mistralai/Mistral-7B-Instruct-v0.2", "meta-llama/Llama-2-13b-chat-hf"],
    "admin": ["*"]  # Semua model
}

def verify_model_access(user_tier: str, model: str) -> bool:
    allowed = ALLOWED_MODELS.get(user_tier, [])
    return "*" in allowed or model in allowed

Panduan Migrasi

Dari OpenAI ke vLLM

Migrasi dari OpenAI ke vLLM self-hosted sangat mudah berkat kompatibilitas API:

Sebelum (OpenAI):

from openai import OpenAI

client = OpenAI(api_key="sk-...")
response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Halo"}]
)

Setelah (vLLM):

from openai import OpenAI

client = OpenAI(
    base_url="https://your-vllm-server.com/v1",
    api_key="your-internal-key"  # Jika Anda menambahkan otentikasi
)
response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.2",
    messages=[{"role": "user", "content": "Halo"}]
)

Hanya dua perubahan yang diperlukan: perbarui base_url dan nama model. Semua kode lain tetap identik.

Dari Ollama ke vLLM

Ollama menggunakan format API yang berbeda. Berikut konversinya:

API Ollama:

import requests

response = requests.post('http://localhost:11434/api/generate',
    json={
        'model': 'llama2',
        'prompt': 'Mengapa langit biru?'
    })

Setara vLLM:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")
response = client.completions.create(
    model="meta-llama/Llama-2-7b-chat-hf",
    prompt="Mengapa langit biru?"
)

Anda perlu memperbarui panggilan API di seluruh kodebase Anda, tetapi perpustakaan klien OpenAI menyediakan penangan kesalahan yang lebih baik dan fitur yang lebih lengkap.

Dari HuggingFace Transformers ke vLLM

Migrasi penggunaan langsung Python:

HuggingFace:

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct-v0.2")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.2")

inputs = tokenizer("Halo", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=100)
result = tokenizer.decode(outputs[0])

vLLM:

from vllm import LLM, SamplingParams

llm = LLM(model="mistralai/Mistral-7B-Instruct-v0.2")
sampling_params = SamplingParams(max_tokens=100)

outputs = llm.generate("Halo", sampling_params)
result = outputs[0].outputs[0].text

API Python vLLM lebih sederhana dan jauh lebih cepat untuk inferensi batch.

Masa Depan vLLM

vLLM terus mengembangkan dengan fitur menarik di roadmap:

Pelayanan Terpisah (Disaggregated Serving): Memisahkan prefill (pemrosesan prompt) dan decode (pembuatan token) ke GPU yang berbeda untuk mengoptimalkan penggunaan sumber daya. Prefill terikat komputasi sementara decode terikat memori, sehingga menjalankannya pada perangkat keras khusus meningkatkan efisiensi.

Pelayanan Multi-Node: Mendistribusikan model besar (100B+ parameter) ke beberapa mesin, memungkinkan pelayanan model yang terlalu besar untuk setup single-node.

Kuantisasi yang Ditingkatkan: Dukungan untuk format kuantisasi baru seperti GGUF (digunakan oleh llama.cpp) dan peningkatan integrasi AWQ/GPTQ untuk kinerja yang lebih baik dengan model yang dikuantisasi.

Perbaikan Decoding Spekulatif: Model draft yang lebih efisien dan strategi spekulasi adaptif untuk mencapai percepatan yang lebih tinggi tanpa kehilangan akurasi.

Optimasi Perhatian: FlashAttention 3, ring attention untuk konteks sangat panjang (100K+ token), dan mekanisme perhatian terkini lainnya.

Cakupan Model yang Lebih Baik: Memperluas dukungan ke model multimodal (model bahasa dan gambar), model audio, dan arsitektur khusus saat muncul.

Proyek vLLM menjaga pengembangan aktif dengan kontribusi dari UC Berkeley, Anyscale, dan komunitas open-source yang lebih luas. Seiring pentingnya deployment LLM dalam sistem produksi, peran vLLM sebagai standar kinerja terus berkembang.

Tautan yang Berguna

Artikel Terkait di Situs Ini

  • Hosting LLM Lokal: Panduan Lengkap 2025 - Ollama, vLLM, LocalAI, Jan, LM Studio & Lebih Banyak - Perbandingan komprehensif dari 12+ alat hosting LLM lokal termasuk analisis terperinci vLLM bersama dengan Ollama, LocalAI, Jan, LM Studio, dan lainnya. Mencakup maturitas API, dukungan pemanggilan alat, kompatibilitas GGUF, dan benchmark kinerja untuk membantu memilih solusi yang tepat.

  • Ollama Cheatsheet - Referensi perintah lengkap dan cheatsheet Ollama yang mencakup instalasi, manajemen model, penggunaan API, dan praktik terbaik untuk pengembangan LLM lokal. Wajib bagi pengembang yang menggunakan Ollama bersama atau sebagai pengganti vLLM.

  • Docker Model Runner vs Ollama: Mana yang Harus Dipilih? - Perbandingan mendalam antara Model Runner Docker dan Ollama untuk pengembangan LLM lokal, menganalisis kinerja, dukungan GPU, kompatibilitas API, dan kasus penggunaan. Membantu memahami lanskap kompetitif yang dioperasikan vLLM.

  • Cheatsheet Docker Model Runner: Perintah & Contoh - Cheatsheet praktis Docker Model Runner dengan perintah dan contoh untuk pengembangan model AI. Berguna bagi tim yang membandingkan pendekatan Docker dengan kemampuan khusus vLLM dalam menyajikan LLM.

Sumber Daya Eksternal dan Dokumentasi

  • Repositori vLLM GitHub - Repositori resmi vLLM dengan kode sumber, dokumentasi menyeluruh, panduan instalasi, dan diskusi komunitas aktif. Sumber daya penting untuk tetap up-to-date dengan fitur terbaru dan menyelesaikan masalah.

  • Dokumentasi vLLM - Dokumentasi resmi yang mencakup semua aspek vLLM dari pengaturan dasar hingga konfigurasi lanjutan. Termasuk referensi API, panduan penyetelan kinerja, dan praktik terbaik penerapan.

  • Kertas PagedAttention - Kertas akademik yang memperkenalkan algoritma PagedAttention yang memperkuat efisiensi vLLM. Bacaan wajib untuk memahami inovasi teknis di balik keunggulan kinerja vLLM.

  • Blog vLLM - Blog resmi vLLM yang menampilkan pengumuman rilis, benchmark kinerja, analisis teknis mendalam, dan studi kasus komunitas dari penerapan produksi.

  • HuggingFace Model Hub - Repositori komprehensif dari model LLM open-source yang kompatibel dengan vLLM. Cari model berdasarkan ukuran, tugas, lisensi, dan karakteristik kinerja untuk menemukan model yang tepat untuk kasus penggunaan Anda.

  • Dokumentasi Ray Serve - Dokumentasi framework Ray Serve untuk membangun penerapan vLLM yang skalabel dan terdistribusi. Ray menyediakan fitur canggih seperti autoscaling, multi-model serving, dan manajemen sumber daya untuk sistem produksi.

  • NVIDIA TensorRT-LLM - TensorRT-LLM dari NVIDIA untuk inferensi yang dioptimalkan secara tinggi pada GPU NVIDIA. Alternatif dari vLLM dengan strategi optimasi yang berbeda, berguna untuk perbandingan dan memahami lanskap optimasi inferensi.

  • Referensi API OpenAI - Dokumentasi resmi API OpenAI yang kompatibel dengan API vLLM. Gunakan referensi ini saat membangun aplikasi yang perlu bekerja dengan baik antara endpoint OpenAI dan vLLM yang dihosting sendiri.