Przejdź do głównej treści
Polski— Wybierz język
Menu

Wdrażanie z vLLM

Lekcja 11 z 14 Zaktualizowano 29 lipca 2026 Zaawansowany
Na tej stronie
  1. vLLM: Zalecany silnik wnioskowania
  2. Czego będziesz potrzebować
  3. Tryb offline: Przetwarzanie wsadowe
  4. Tryb serwerowy: Udostępnianie API
  5. Wdrażanie w Dockerze
  6. Trzy niezbędne flagi Mistral
  7. Dostrajanie wydajności
  8. Kluczowe wnioski

vLLM: Zalecany silnik wnioskowania

vLLM to najpopularniejszy silnik wnioskowania dla LLM napisany w Pythonie. Mistral AI rekomenduje go do samodzielnego hostowania, ponieważ jest łatwy w użyciu, wydajny i oferuje API kompatybilne z OpenAI. Przeprowadzimy Cię przez instalację i konfigurację, a następnie omówimy dwa tryby jego działania: wsadowy (offline) oraz serwerowy. Tryby te nie wykluczają się wzajemnie – wiele zespołów wykorzystuje pierwszy do przygotowania danych, a drugi do obsługi aplikacji.

Czego będziesz potrzebować

Pobieranie modeli odbywa się przez Hugging Face, co wymaga tokenu z uprawnieniem READ:

export HF_TOKEN="hf_your_token_here"

Przed pierwszym pobraniem musisz zaakceptować warunki użytkowania na stronie modelu w Hugging Face (na przykład: huggingface.co/mistralai/Mistral-Nemo-Instruct-2407). Jest to jednorazowa czynność manualna dla każdego konta. Pominięcie tego kroku powoduje błędy pobierania, których diagnoza może zająć godzinę, ponieważ wyglądają one jak problemy z uwierzytelnianiem.

W przypadku środowiska Pythona użyj dedykowanego virtualenv, aby uniknąć konfliktów wersji z innymi projektami:

# Utwórz środowisko wirtualne
python -m venv vllm-env
source vllm-env/bin/activate

# Zainstaluj vLLM (wersja >= 0.6.1.post1)
pip install vllm

Kolejnym elementem jest sprzęt, który decyduje o tym, co faktycznie możesz uruchomić. Mistral 7B i Nemo zmieszczą się na pojedynczym GPU z 24 GB pamięci, typowo A10G, RTX 4090 lub L4. Mixtral 8x7B wymaga dwóch GPU po 80 GB, w praktyce kart A100-80GB. Mistral Large 2 w wersji open-weight, posiadający 123 miliardy parametrów, potrzebuje co najmniej czterech GPU A100-80GB. We wszystkich przypadkach przed instalacją vLLM zainstaluj sterowniki NVIDIA i CUDA 12.x.

Tryb offline: Przetwarzanie wsadowe

Tryb offline obsługuje partie żądań bez serwera HTTP. Ładujesz model do pamięci, przetwarzasz swoje żądania i odbierasz wyniki. Zwróć uwagę na trzy argumenty: tokenizer_mode, load_format oraz config_format. Wrócimy do nich – nie są opcjonalne.

from vllm import LLM
from vllm.sampling_params import SamplingParams

# Załaduj model z flagami Mistral
llm = LLM(
    model="mistralai/Mistral-Nemo-Instruct-2407",
    tokenizer_mode="mistral",
    load_format="mistral",
    config_format="mistral"
)

# Parametry generowania
sampling = SamplingParams(
    max_tokens=8192,
    temperature=0.3
)

# Przetwarzanie partii żądań
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)

Ten tryb sprawdza się przy wsadowym przetwarzaniu dokumentów – podsumowywaniu, klasyfikacji – ewaluacji modeli względem benchmarków, generowaniu danych syntetycznych oraz w skryptach testowych lub prototypowych. Zawsze, gdy nikt nie czeka na natychmiastową odpowiedź, zyskujesz dzięki pominięciu warstwy HTTP.

Tryb serwerowy: Udostępnianie API

Tryb serwerowy uruchamia punkt końcowy HTTP kompatybilny z API OpenAI:

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

Serwer udostępnia API na porcie 8000. Ma to istotne konsekwencje praktyczne: aplikacja napisana pod API OpenAI przełącza się na Twój samodzielnie hostowany model po zmianie dwóch linii: base_url i api_key. Twoje biblioteki, frameworki agentów i narzędzia testowe继续 działają bez zmian.

from openai import OpenAI

# Połącz z lokalnym serwerem vLLM
client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"  # Brak autoryzacji domyślnie
)

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)

Komentarz # Brak autoryzacji domyślnie zasługuje na uwagę: serwer vLLM uruchomiony w ten sposób nie uwierzytelnia nikogo. Na maszynie deweloperskiej jest to wygodne. Na maszynie dostępnej w sieci to otwarte drzwi. Szybki test z linii poleceń potwierdza, że wszystko odpowiada, zanim przejdziesz dalej:

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
    }'

Wdrażanie w Dockerze

Dla powtarzalnego wdrożenia oficjalny obraz pozwala uniknąć ponownej instalacji na każdej maszynie:

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

Trzy opcje w tym poleceniu wymagają wyjaśnienia. --runtime nvidia --gpus all daje kontenerowi dostęp do GPU NVIDIA; bez tego model próbowałby działać na CPU. Montowanie -v ~/.cache/huggingface:... współdzieli pamięć podręczną modeli z hostem, oszczędzając Ci ponownego pobierania dziesiątek gigabajtów przy każdym restarcie kontenera. --ipc=host przydziela pamięć współdzieloną niezbędną do komunikacji międzyprocesowej między GPU; pominięcie tego powoduje trudne do zdiagnozowania awarie, gdy tylko przejdziesz na wiele kart.

Trzy niezbędne flagi Mistral

FlagaCel
--tokenizer_mode mistralUżywa natywnego tokenizera Mistral (nie HF)
--config_format mistralŁaduje konfigurację w formacie Mistral
--load_format mistralŁaduje wagi w natywnym formacie Mistral

Bez tych flag model może działać, ale z obniżoną wydajnością lub niepoprawnymi wynikami. To najczęstsza pułapka przy samodzielnym hostowaniu Mistral: nic się nie crashuje, serwer startuje, odpowiedzi przychodzą – są po prostu gorsze, niż powinny być, a Ty ryzykujesz błędny wniosek, że model jest rozczarowujący.

Dostrajanie wydajności

Gdy model nie mieści się na jednej karcie, równoległość tensorowa (tensor parallelism) rozdziela jego warstwy na wiele GPU. Przekazywana wartość odpowiada liczbie używanych kart:

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

Drugim mechanizmem jest proporcja pamięci GPU rezerwowanej przez vLLM:

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

Wartość domyślna (0.9) działa w większości przypadków. Zmniejsz ją, jeśli inne procesy korzystają z GPU – usługa wizyjna, zapomniany notebook – w przeciwnym razie pierwszy proces zajmie całą pamięć, a drugi nie zdoła się uruchomić.

Na koniec, dwa wywołania wystarczą, aby zweryfikować, czy serwer działa, co czyni je dobrymi sondami dla Twojego orkiestratora:

# Wylistuj dostępne modele
curl http://localhost:8000/v1/models

# Sprawdź stan serwera
curl http://localhost:8000/health

Kluczowe wnioski

  • vLLM udostępnia API kompatybilne z OpenAI – możesz użyć SDK openai do komunikacji
  • Trzy flagi --tokenizer_mode mistral, --config_format mistral, --load_format mistral są obowiązkowe
  • Tryb offline nadaje się do przetwarzania wsadowego; tryb serwerowy do aplikacji czasu rzeczywistego
  • Docker upraszcza wdrażanie i zapewnia powtarzalność
  • Równoległość tensorowa pozwala rozdzielać duże modele na wiele GPU