Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Üzembe helyezés vLLM-mel

11. lecke 14 közül Frissítve 2026. július 29. Haladó
Ezen az oldalon
  1. vLLM: Az ajánlott következtetési motor
  2. Amire szükséged lesz
  3. Offline mód: Kötegek feldolgozása
  4. Szerver mód: API közzététele
  5. Dockeres üzembe helyezés
  6. A három alapvető Mistral flag
  7. Teljesítmény hangolása
  8. Főbb megállapítások

vLLM: Az ajánlott következtetési motor

A vLLM a legnépszerűbb Python alapú következtetési motor nagy nyelvi modellekhez (LLM). A Mistral AI ezt ajánlja saját üzemeltetésre, mert könnyen használható, jól teljesít, és OpenAI-kompatibilis API-t biztosít. Végigvezetünk a telepítésen és a konfiguráción, majd bemutatjuk a két használati módot: a kötegelt (offline) módot és a szerver módot. Ezek a módok nem zárják ki egymást; sok csapat az elsőt adat előkészítésre, a másodikat alkalmazások kiszolgálására használja.

Amire szükséged lesz

A modellek letöltése a Hugging Face-en keresztül történik, amihez READ jogosultsággal rendelkező token szükséges:

export HF_TOKEN="hf_your_token_here"

Az első letöltés előtt el kell fogadnod a felhasználási feltételeket a modell Hugging Face oldalán (például: huggingface.co/mistralai/Mistral-Nemo-Instruct-2407). Ez fiókonként egyszeri, manuális lépés. Ha elfelejted, a letöltés sikertelen lesz, és akár egy órát is igénybe vehet a hiba diagnosztizálása, mivel a tünetek hitelesítési problémákra utalnak.

A Python környezethez használj dedikált virtualenv-et, hogy elkerüld a verzióütközéseket más projektjeiddel:

# Virtuális környezet létrehozása
python -m venv vllm-env
source vllm-env/bin/activate

# vLLM telepítése (verzió >= 0.6.1.post1)
pip install vllm

Aztán ott van a hardver, ami meghatározza, mit tudsz valójában kiszolgálni. A Mistral 7B és a Nemo elfér egy egyetlen 24 GB-os GPU-n, tipikusan egy A10G, RTX 4090 vagy L4 kártyán. A Mixtral 8x7B-hez két 80 GB-os GPU szükséges, a gyakorlatban A100-80GB kártyák. A Mistral Large 2 nyílt súlyú verziója 123 milliárd paraméterével legalább négy A100-80GB GPU-t igényel. Minden esetben telepítsd az NVIDIA drivereket és a CUDA 12.x-et a vLLM előtt.

Offline mód: Kötegek feldolgozása

Az offline mód HTTP szerver nélkül kezeli a kérések kötegeit. Betöltöd a modellt a memóriába, feldolgozod a kéréseidet, és lekérdezed az eredményeket. Figyeld meg a három argumentumot: tokenizer_mode, load_format és config_format: később még visszatérünk rájuk – ezek nem opcionálisak.

from vllm import LLM
from vllm.sampling_params import SamplingParams

# Modell betöltése Mistral flaggel
llm = LLM(
    model="mistralai/Mistral-Nemo-Instruct-2407",
    tokenizer_mode="mistral",
    load_format="mistral",
    config_format="mistral"
)

# Generálási paraméterek
sampling = SamplingParams(
    max_tokens=8192,
    temperature=0.3
)

# Kérések kötegének feldolgozása
messages_batch = [
    [{"role": "user", "content": "What is PagedAttention?"}],
    [{"role": "user", "content": "Explain tensor parallelism."}],
    [{"role": "user", "content": "How does the KV cache work?"}],
]

results = llm.chat(messages=messages_batch[0], sampling_params=sampling)
for output in results:
    print(output.outputs[0].text)

Ez a mód kiválóan alkalmas kötegelt dokumentumfeldolgozásra – összefoglalás, osztályozás –, modellértékelésre benchmarkok ellen, szintetikus adatgenerálásra, valamint tesztelő vagy prototípus szkriptekhez. Amikor senki nem vár azonnali választ, hasznodra válik a HTTP-réteg kihagyása.

Szerver mód: API közzététele

A szerver mód egy OpenAI API-val kompatibilis HTTP végpontot indít:

vllm serve mistralai/Mistral-Nemo-Instruct-2407 \
    --tokenizer_mode mistral \
    --config_format mistral \
    --load_format mistral \
    --host 0.0.0.0 \
    --port 8000

A szerver a 8000-es porton teszi elérhetővé az API-t. Ennek gyakorlati következménye jelentős: egy OpenAI API-ra írt alkalmazás két sor megváltoztatásával (base_url és api_key) átválthat a saját üzemeltetésű modelledre. A könyvtáraid, ágens keretrendszereid és tesztelő eszközeid továbbra is működnek.

from openai import OpenAI

# Csatlakozás a helyi vLLM szerverhez
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"  # Alapértelmezetten nincs hitelesítés
)

response = client.chat.completions.create(
    model="mistralai/Mistral-Nemo-Instruct-2407",
    messages=[
        {"role": "system", "content": "You are a DevOps expert."},
        {"role": "user", "content": "How do I monitor a vLLM server in production?"}
    ],
    temperature=0.3,
    max_tokens=1024
)
print(response.choices[0].message.content)

A # Alapértelmezetten nincs hitelesítés megjegyzés figyelmet érdemel: egy így elindított vLLM szerver senkit sem hitelesít. Fejlesztői gépen ez kényelmes. Hálózaton elérhető gépen azonban ez nyitott kapu. Egy gyors parancssori teszt megerősíti, hogy minden válaszol, mielőtt tovább lépnél:

curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "mistralai/Mistral-Nemo-Instruct-2407",
        "messages": [{"role": "user", "content": "Hello, is this working?"}],
        "temperature": 0.3
    }'

Dockeres üzembe helyezés

A reprodukálható üzembe helyezéshez a hivatalos image elkerüli az újratelepítést minden gépen:

docker run --runtime nvidia --gpus all \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}" \
    -p 8000:8000 \
    --ipc=host \
    vllm/vllm-openai:latest \
    --model mistralai/Mistral-Nemo-Instruct-2407 \
    --tokenizer_mode mistral \
    --load_format mistral \
    --config_format mistral

Ebben a parancsban három opció magyarázatra szorul. A --runtime nvidia --gpus all hozzáférést biztosít a konténer számára az NVIDIA GPU-khoz; enélkül a modell megpróbálna CPU-n futni. A -v ~/.cache/huggingface:... mount megosztja a modell gyorsítótárát a gazdagéppel, így megspórolod a tíz gigabájtnyi adat újralletöltését minden konténer-újraindításkor. A --ipc=host biztosítja a GPU-k közötti folyamatközi kommunikációhoz szükséges shared memóriát; ennek elhagyása nehezen diagnosztizálható összeomlásokat okoz, amint több kártyára váltasz.

A három alapvető Mistral flag

FlagCél
--tokenizer_mode mistralA natív Mistral tokenizálót használja (nem a HF-ét)
--config_format mistralMistral formátumban tölti be a konfigurációt
--load_format mistralNatív Mistral formátumban tölti be a súlyokat

Ezek nélkül a flagek nélkül a modell futhat ugyan, de csökkent teljesítménnyel vagy helytelen eredményekkel. Ez a leggyakoribb buktató a Mistral saját üzemeltetésekor: semmi nem omlik össze, a szerver elindul, érkeznek a válaszok – csak éppen rosszabbak a kelleténél, és azt kockáztatod, hogy tévesen arra a következtetésre jutsz, hogy a modell csalódást keltő.

Teljesítmény hangolása

Amikor egy modell nem fér el egy egyetlen kártyán, a tenzor párhuzamosítás (tensor parallelism) szétosztja a rétegeit több GPU között. Az átadott érték a használt kártyák számának felel meg:

vllm serve mistralai/Mixtral-8X7B-Instruct-v0.1 \
    --tokenizer_mode mistral \
    --config_format mistral \
    --load_format mistral \
    --tensor-parallel-size 2

A második szabályozó a GPU memória azon arányára vonatkozik, amelyet a vLLM lefoglal:

vllm serve mistralai/Mistral-Nemo-Instruct-2407 \
    --tokenizer_mode mistral \
    --config_format mistral \
    --load_format mistral \
    --gpu-memory-utilization 0.9

Az alapértelmezett érték (0.9) a legtöbb esetben működik. Csökkentsd ezt, ha más folyamatok is használják a GPU-t – egy látási szolgáltatás, egy elfelejtett notebook –, különben az első folyamat elveszi az összes memóriát, és a második el sem indul.

Végül, két hívás elegendő annak ellenőrzésére, hogy a szerver él, így ezek jó próbák (probe) az orchestrátorod számára:

# Elérhető modellek listázása
curl http://localhost:8000/v1/models

# Szerver állapotának ellenőrzése
curl http://localhost:8000/health

Főbb megállapítások

  • A vLLM OpenAI-kompatibilis API-t tesz elérhetővé – használhatod az openai SDK-t a kommunikációhoz
  • A három flag (--tokenizer_mode mistral, --config_format mistral, --load_format mistral) kötelező
  • Az offline mód kötegelt feldolgozásra, a szerver mód valós idejű alkalmazásokra alkalmas
  • A Docker leegyszerűsíti az üzembe helyezést és biztosítja a reprodukálhatóságot
  • A tenzor párhuzamosítás lehetővé teszi nagy modellek szétosztását több GPU között