Ngày nào tôi cũng dùng cả hai. Ollama chạy trên laptop của tôi và trên máy trạm có GPU ở văn phòng, phục vụ việc phát triển và mấy công cụ tôi tự làm cho mình. Còn vLLM thì phục vụ một mô hình chat cho một dự án freelance, trên một GPU 96 GB duy nhất, lúc đầu chạy bằng Docker Compose và bây giờ chạy trong một cụm Kubernetes nhỏ. Bài này nói về thế mạnh của từng công cụ, cách cài đặt chúng, và những chỗ đã khiến tôi mất thời gian ở phía vLLM.

So sánh nhanh vLLM và Ollama

#

Ollama là gì

#

Trong những cách tôi biết, Ollama là cách dễ nhất để có một mô hình trả lời được ngay trên máy của bạn. Nó phát triển từ llama.cpp và chạy các mô hình GGUF đã lượng tử hóa, vì vậy một mô hình 8B chỉ chiếm khoảng 5 GB và chạy thoải mái trên một chiếc MacBook. Bạn tải mô hình về theo tên, mô hình được nạp vào bộ nhớ ở lần gọi đầu tiên, và sau năm phút không có việc gì làm thì nó tự rời khỏi bộ nhớ. Nhờ vậy, Ollama chia sẻ máy một cách lịch sự với mọi thứ khác bạn đang chạy.

Nhưng chính sự lịch sự đó cũng là cái giá phải trả. Ollama được thiết kế xoay quanh việc phục vụ từng người một. Nó có thể trả lời song song vài yêu cầu, nhưng mỗi khe xử lý song song đều tốn thêm bộ nhớ, và ngay từ đầu nó không được làm ra để gộp hàng chục người dùng lên cùng một GPU.

vLLM là gì

#

vLLM là một engine phục vụ mô hình (serving engine), và nó được làm ra chính là để gộp lô như vậy. Phần lớn sức mạnh của nó đến từ hai ý tưởng. Thứ nhất là PagedAttention: nó lưu KV cache của mỗi yêu cầu (bộ nhớ đệm chứa trạng thái attention mà mô hình tích lũy dần trong lúc đọc và sinh token) thành những khối nhỏ có kích thước cố định, nhờ đó bộ nhớ GPU không bị hao phí vì phần đệm (padding) và phân mảnh. Thứ hai là gộp lô liên tục: yêu cầu mới được đưa vào lô giữa các bước sinh token, thay vì phải chờ lô hiện tại chạy xong. Kết hợp hai ý tưởng này, một GPU chạy vLLM phục vụ được số người dùng đồng thời nhiều hơn hẳn so với chính GPU đó khi xử lý lần lượt từng yêu cầu một.

Cái giá phải trả là vLLM cư xử như thể nó là chủ của cả card GPU. Vừa khởi động, nó đã chiếm phần bộ nhớ GPU dành cho mình, dùng toàn bộ phần mà trọng số mô hình không cần đến để làm KV cache, và giữ hết chỗ đó dù có ai gọi tới hay không. Nó cũng đòi trọng số đầy đủ từ Hugging Face, hoặc một kiểu lượng tử hóa thân thiện với GPU như FP8, chứ không dùng các tệp GGUF như Ollama.

Một API, hai máy chủ

#

Vì cả hai đều cung cấp API chat completions của OpenAI, code của tôi không cần biết nó đang nói chuyện với bên nào. URL và tên mô hình được lấy từ biến môi trường:

import os
from openai import OpenAI

# Laptop:      LLM_URL=http://localhost:11434/v1  LLM_MODEL=qwen3:8b
# Máy chủ GPU: LLM_URL=http://localhost:8000/v1   LLM_MODEL=qwen3-8b
client = OpenAI(base_url=os.environ["LLM_URL"], api_key="not-needed")

reply = client.chat.completions.create(
    model=os.environ["LLM_MODEL"],
    messages=[{"role": "user", "content": "Say hello in Korean."}],
)
print(reply.choices[0].message.content)

Trên laptop, vốn không có GPU mạnh, ứng dụng trỏ tới Ollama. Trên máy chủ thì nó trỏ tới vLLM. Ngoài hai biến đó ra không có gì thay đổi, và tôi có thể phát triển ứng dụng mà không cần bật máy GPU lên chút nào. Ở phía vLLM, --served-model-name đặt cho mô hình một cái tên ngắn, để client không phải gửi nguyên đường dẫn Hugging Face đầy đủ.

Có một điều cần lưu ý, vì rất dễ quên: cùng một mô hình nhưng chạy trên hai bên sẽ không cho ra cùng câu trả lời. qwen3:8b của Ollama là bản lượng tử hóa 4-bit, trong khi trên vLLM bạn thường chạy trọng số 16-bit hoặc FP8. Một prompt đã được tinh chỉnh trên bên này có thể cư xử khác trên bên kia, nên bất cứ thứ gì bạn đang đo, dù là chất lượng câu trả lời, việc mô hình có từ chối trả lời hay không, hay JSON có parse được không, đều phải được kiểm tra trên đúng máy chủ mà môi trường production sẽ thật sự dùng.

Cách cài đặt Ollama

#

Trên Mac hoặc Windows, hãy tải ứng dụng về từ ollama.com. Trên Linux thì chạy:

curl -fsSL https://ollama.com/install.sh | sh
ollama run qwen3:8b

Thế là xong. API giờ đã có ở http://localhost:11434. Nó chỉ lắng nghe trên localhost, trừ khi bạn đặt OLLAMA_HOST, và như thế là đúng điều bạn muốn. Ollama của tôi chạy trên máy trạm ở văn phòng, bind vào 127.0.0.1, và tôi truy cập nó từ bất cứ đâu qua một đường hầm (cách tôi thiết lập việc đó bằng Cloudflare WARP).

Cách cài đặt vLLM

#

Trên Linux, với GPU NVIDIA và driver đời mới:

python -m venv .venv && source .venv/bin/activate
pip install vllm
vllm serve Qwen/Qwen3-8B --served-model-name qwen3-8b --max-model-len 16384

Lần chạy đầu tiên sẽ tải trọng số mô hình về từ Hugging Face. Khi log hiện dòng Application startup complete, lệnh curl localhost:8000/v1/models sẽ liệt kê mô hình, và đoạn Python ở trên chạy được với nó.

Chạy vLLM bằng Docker

#

Với bất cứ thứ gì phải chạy liên tục, tôi dùng image chính thức thay vì cài bằng pip, chủ yếu để CUDA, PyTorch và vLLM đi kèm nhau với phiên bản đã được ghim cố định. Dưới đây là một service Compose dạng chung chung:

services:
  vllm:
    image: vllm/vllm-openai:v0.30.0   # ghim một tag cụ thể; image nặng khoảng 30 GB
    restart: unless-stopped
    ipc: host                          # PyTorch cần bộ nhớ dùng chung (shared memory)
    command: >
      --model Qwen/Qwen3-8B
      --served-model-name qwen3-8b
      --gpu-memory-utilization 0.85
      --max-model-len 16384
    volumes:
      - ${HOME}/.cache/huggingface:/root/.cache/huggingface
    ports:
      - "127.0.0.1:8000:8000"          # truy cập qua ssh -L, không qua mạng LAN
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    healthcheck:
      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')"]
      interval: 10s
      timeout: 5s
      retries: 90
      start_period: 120s

Hãy ghim tag. vLLM thay đổi rất nhanh, các cờ (flag) và giá trị mặc định thay đổi giữa các bản phát hành, và bạn muốn chính mình là người quyết định khi nào những thay đổi đó xảy ra. ipc: host (hoặc một shm_size thật rộng rãi) có sẵn trong hướng dẫn Docker của chính vLLM. Còn lý do start_period dài như vậy chính là điều đầu tiên trong phần tiếp theo.

Những chỗ khiến tôi vấp khi chạy vLLM

#

Khởi động mất vài phút. Nạp trọng số, biên dịch và ghi lại (capture) các CUDA graph mất 190 giây trên máy chủ của tôi, và với một mô hình lớn thì ba đến năm phút là chuyện bình thường. Một bài kiểm tra sức khỏe (health check) viết theo kiểu dành cho ứng dụng web sẽ giết nó trước khi nó kịp sẵn sàng. Trong Compose, điều đó có nghĩa là cần một start_period dài; trong Kubernetes thì cần một startup probe. Nó cũng có nghĩa là mỗi lần khởi động lại là vài phút không có mô hình nào phục vụ, nên đừng khởi động lại một cách tùy tiện.

Bạn cho bao nhiêu bộ nhớ GPU, nó lấy bấy nhiêu, ngay từ lúc khởi động. --gpu-memory-utilization là tỉ lệ bộ nhớ trên card mà vLLM được phép dùng, ở các bản gần đây mặc định là 0.92, và toàn bộ phần mà trọng số không cần đến sẽ trở thành KV cache. Như vậy không sao nếu vLLM chạy một mình trên card. Card của tôi thì không như vậy, vì có mấy mô hình nhỏ hơn chạy bên cạnh, nên tôi đặt 0.70 trên card 96 GB. Mô hình của tôi, một mô hình hỗn hợp chuyên gia (mixture-of-experts) 35B ở định dạng FP8, chiếm 47.7 GiB khi nạp xong và để lại 15 GiB cho KV cache, quá đủ cho độ dài ngữ cảnh (context) 16k. Nếu vLLM từ chối khởi động vì độ dài chuỗi tối đa không vừa trong KV cache, hãy giảm --max-model-len trước khi đi tìm một GPU lớn hơn.

Mỗi chỗ dành cho LoRA đều tốn bộ nhớ ngay từ đầu. vLLM có thể phục vụ một mô hình gốc (base model) kèm nhiều LoRA adapter và chuyển qua lại giữa chúng theo từng yêu cầu, dựa vào tên mô hình, điều mà Ollama gần như không làm được. Nhưng lúc khởi động, nó giữ sẵn chỗ cho số adapter bằng --max-loras, mỗi adapter ở rank bằng --max-lora-rank, và trên một mô hình mixture-of-experts thì phần giữ chỗ đó bao gồm cả các expert, nên con số cộng dồn rất nhanh. Bốn adapter ở rank 64 không vừa khi đặt 0.70. Hai adapter thì vừa.

Giới hạn số chuỗi mặc định không hợp với mô hình lai. Mô hình tôi đang phục vụ trộn các lớp kiểu Mamba vào giữa các lớp attention, và mỗi chuỗi (sequence) cần một khối bộ nhớ đệm riêng cho những lớp đó. Với giá trị --max-num-seqs mặc định của vLLM trên card đó, nó không khởi động được; đặt --max-num-seqs 256 là hết lỗi. Nếu một kiến trúc mô hình mới hơn không chịu khởi động, hãy kiểm tra cờ này trước khi nghĩ tới những nguyên nhân cao siêu hơn.

Một Service Kubernetes tên vllm làm vLLM sập. Đây là vụ tôi khoái nhất. Kubernetes tự chèn biến môi trường cho mọi Service trong cùng namespace, đặt tên theo tên Service, nên một Service tên vllm sẽ đưa cho mọi pod biến VLLM_PORT=tcp://<cluster-ip>:8000. vLLM đọc VLLM_PORT như một thiết lập của chính nó, không hiểu nổi một URL nằm ở đó, và chết. Dĩ nhiên là chết sau khi đã nạp xong toàn bộ mô hình, nên mỗi lần thử tốn ba phút. Tài liệu của vLLM có cảnh báo chuyện này, nhưng tôi chỉ đọc thấy sau khi đã dính. Cách sửa là đặt enableServiceLinks: false trên pod, hoặc đặt cho Service một cái tên khác.

Dưới đây là khung của một Deployment chạy được, đã lược bớt chỉ còn những phần quan trọng:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm
spec:
  replicas: 1
  strategy:
    type: Recreate               # pod cũ phải giải phóng GPU trước
  selector:
    matchLabels: {app: vllm}
  template:
    metadata:
      labels: {app: vllm}
    spec:
      enableServiceLinks: false  # không nhận VLLM_PORT=tcp://... từ Service
      containers:
        - name: vllm
          image: vllm/vllm-openai:v0.30.0
          args: ["--model=Qwen/Qwen3-8B", "--served-model-name=qwen3-8b"]
          resources:
            limits:
              nvidia.com/gpu: "1"
              memory: 32Gi       # lúc nạp cần nhiều RAM máy host hơn hẳn lúc phục vụ
          volumeMounts:
            - {name: shm, mountPath: /dev/shm}
          startupProbe:          # đừng phán xét trước khi mô hình nạp xong
            httpGet: {path: /health, port: 8000}
            initialDelaySeconds: 120
            periodSeconds: 10
            failureThreshold: 90
          livenessProbe:         # khởi động lại là nạp lại từ đầu, nên hãy kiên nhẫn
            httpGet: {path: /health, port: 8000}
            periodSeconds: 30
            timeoutSeconds: 5
            failureThreshold: 10
      volumes:
        - name: shm
          emptyDir: {medium: Memory, sizeLimit: 16Gi}

Phần đáng sao chép nhất là các probe. Startup probe chờ hai phút, rồi cho mô hình thêm mười lăm phút nữa để khởi động xong, trước khi Kubernetes coi nó là đã chết. Liveness probe chỉ khởi động lại pod sau khoảng năm phút thất bại liên tục, vì /health có thể phản hồi chậm khi engine đang bận, và dù sao thì mỗi lần khởi động lại cũng tốn một lần nạp lại toàn bộ. Recreate rất quan trọng khi chỉ có một GPU: cập nhật cuốn chiếu (rolling update) sẽ khởi động pod mới trước, và pod đó cứ nằm chờ một GPU mà pod cũ vẫn đang giữ. Giới hạn bộ nhớ trông có vẻ hào phóng, vì nó đúng là hào phóng thật; khi trọng số đã nằm trên GPU, pod của tôi ổn định ở khoảng 7 GiB RAM của máy host, nhưng riêng quá trình nạp thì cần nhiều hơn thế rất nhiều.

Những điều nên biết về Ollama

#

Với Ollama thì ít bất ngờ hơn, chủ yếu là vì nó làm ít việc hơn.

Yêu cầu đầu tiên sau một khoảng thời gian không ai dùng sẽ chậm, vì mô hình đã bị gỡ khỏi bộ nhớ và phải nạp lại. OLLAMA_KEEP_ALIVE quy định một mô hình được giữ trong bộ nhớ bao lâu sau yêu cầu cuối cùng; hãy tăng giá trị này lên nếu khoảng chờ đó làm bạn khó chịu, hoặc đặt thành -1 trên một máy không làm việc gì khác.

Cửa sổ ngữ cảnh (context window) phụ thuộc vào lượng bộ nhớ GPU bạn có. Dưới 24 GiB, Ollama mặc định chỉ dùng 4k token, ít hơn nhiều so với mức mà phần lớn mô hình hỗ trợ, và một prompt không vừa sẽ bị cắt bớt một cách lặng lẽ chứ không bị từ chối. Nếu câu trả lời có vẻ phớt lờ phần đầu của một prompt dài, hãy đặt OLLAMA_CONTEXT_LENGTH (hoặc num_ctx cho từng yêu cầu) bằng đúng mức bạn thật sự cần.

Nếu bạn chuyển tiếp (forward) một Ollama ở máy từ xa về laptop, đừng đặt nó ở cổng 11434. Đó là cổng mặc định của Ollama, và nếu có lúc một Ollama cục bộ trên laptop khởi động, hai bên sẽ tranh nhau cổng đó, và bạn có thể nói chuyện nhầm với bên kia mà không hề hay biết. Tôi chuyển tiếp Ollama của mình về cổng 11435.

Và Ollama không phải là máy chủ cho nhiều người dùng. Dùng cho một công cụ nội bộ chỉ vài người sử dụng thì ổn; khi lượng truy cập đồng thời thật sự xuất hiện, đó là lúc nên chuyển sang vLLM.

Cần bao nhiêu bộ nhớ GPU

#

Kích thước ước tính, chỉ tính riêng phần trọng số:

Tức là khoảng 2 byte cho mỗi tham số ở 16-bit, 1 byte ở 8-bit, và hơn nửa byte một chút ở Q4_K_M. Cộng thêm vào phần trọng số là KV cache, thứ tăng theo độ dài ngữ cảnh và theo số yêu cầu đang được xử lý cùng lúc. Chính yếu tố sau, tức số yêu cầu chạy cùng lúc, là lý do cùng một mô hình lại cần nhiều bộ nhớ hơn hẳn khi chạy trên vLLM phục vụ năm mươi người dùng, so với khi chạy trên Ollama chỉ phục vụ mình bạn.

Nên dùng cái nào

#

Nếu bạn chỉ muốn có một mô hình chạy trên máy của chính mình, hãy cài Ollama và dừng ở đó; trong vòng mười phút là bạn đã có thứ trả lời được. Nếu bạn có một máy chủ GPU, cùng với người dùng hoặc một ứng dụng sẽ gọi tới nó suốt cả ngày, hãy dùng vLLM, chấp nhận việc nó khởi động chậm và chiếm nhiều bộ nhớ, rồi cấu hình các probe cho đúng. Rất nhiều hệ thống cuối cùng dùng cả hai, hệ thống của tôi cũng vậy: Ollama ở nơi viết code, vLLM ở nơi các yêu cầu đổ về.

Ngoài hai cái này vẫn còn những lựa chọn khác. SGLang là phương án thay thế vLLM mà người ta hay nhắc tới, nhưng tôi chưa chạy nó trên production, nên tôi để nó ra ngoài bài này thay vì đoán mò. Còn nếu mô hình phải chạy trên điện thoại thì lại quay về llama.cpp, như tôi đã viết trong bài chạy LLM ngay trên thiết bị với React Native.