vLLM

Jak serwować duży model językowy przez vLLM na GPU w CGC jako API zgodne z OpenAI: załaduj model z Hugging Face lub z wolumenu, uruchom serwer i wywołaj API.

vLLM to szybka i łatwa w użyciu biblioteka do wnioskowania i serwowania LLM.

Wybierz i załaduj model

Wybierz dowolny model, który chcesz serwować. W tym przykładzie użyjemy Llama‑3.2‑3B‑Instruct (~7 GiB).

Utwórz wolumen

Upewnij się, że montujesz wolumen, który jest wystarczająco duży, aby pomieścić wszystkie pliki. Jeśli planujesz utworzyć wolumen repozytorium modeli, przeznacz co najmniej 200 GB miejsca. Możesz później rozszerzyć wolumen w razie potrzeby.

cgc volume create -s 200 -sc <storage_class> models

Użyj repozytorium HuggingFace

Jeśli wybrany model jest dostępny w repozytorium HF, możesz po prostu przekazać jego nazwę podczas uruchamiania nowej instancji vLLM.
Należy pamiętać, że musisz zamontować wcześniej utworzony wolumen, ponieważ istnieją ograniczenia dotyczące efemerycznej pamięci. Ponadto nie chcesz pobierać modelu za każdym razem, gdy tworzysz nową instancję vLLM.

Aby kontynuować, przejdź do sekcji Jak uruchomić.

Umieść model w wolumenie

Najszybszym sposobem jest zrobienie tego ręcznie za pomocą interfejsu GUI filebrowser. Możesz uruchomić:

# Utwórz jeśli nie istnieje
cgc compute filebrowser create

# Zamontuj nowy wolumen
cgc volume mount models -t filebrowser

Aby sprawdzić token aplikacji i adres URL pod którym jest dostępna:

cgc compute list -d

Podczas logowania się do interfejsu webowego filebrowsera użyj nazwy użytkownika admin i tokenu aplikacji jako hasła.

W filebrowser pobierz wszystkie pliki modelu z Hugging Face i przeciągnij je na wolumen.

warning

Upewnij się, że pobierasz model w oryginalnym formacie PyTorch z Hugging Face, a nie w formacie GGUF.

Obraz vLLM zawiera również CLI Hugging Face, więc z dowolnej działającej instancji z zamontowanym wolumenem możesz pobrać całe repozytorium bezpośrednio na niego:

hf download meta-llama/Llama-3.2-3B-Instruct --local-dir /media/models/Llama-3.2-3B-Instruct

Jak uruchomić

Model Huggingface

Aby uruchomić model HF, musisz upewnić się, że masz pozwolenie na pobranie modelu.
Będziesz musiał wygenerować nowy HF Token. Niektóre modele są ograniczone, więc musisz przejść na stronę karty modelu i zaakceptować warunki użytkowania.

cgc compute create vllm-openai -n <name> -e hf_token=<HF_TOKEN> -g <gpu_count> -gt <gpu_type> -c <cpu_count> -m <ram> -v <volume_name> -- --model=<MODEL_NAME>

Aby uruchomić przykład Bielik: Przed zastosowaniem tego polecenia zmień token HF i przejdź do karty modelu Bielik, aby zaakceptować warunki użytkowania.

cgc compute create vllm-openai -n bielik-26 -e hf_token=<HF_TOKEN> -g 1 -gt NVIDIA-RTX-A5000 -c 2 -m 24 -v models -- --model=speakleash/Bielik-11B-v2.6-Instruct-FP8-Dynamic

CGC automatycznie używa twojego wolumenu do pobrania modelu. Wagi trafiają do --download-dir w układzie cache Hugging Face, na przykład /media/models/huggingface/models--Qwen--Qwen2.5-0.5B-Instruct/snapshots/<rewizja>/.

warning

Ten katalog cache nie jest katalogiem modelu, który da się później serwować. Na wolumen zapisywane są wyłącznie pliki wag; config.json, tokenizer i pozostałe metadane zostają w cache kontenera i znikają razem z instancją. Przekazanie ścieżki snapshotu do --model kończy się błędem Invalid repository ID or local directory specified. Aby serwować model z wolumenu, najpierw umieść na nim kompletną kopię repozytorium - zobacz Umieść model w wolumenie.

Twój model

Wskaż w --model katalog na wolumenie, który zawiera kompletną kopię repozytorium modelu - config.json, pliki tokenizera i wagi - na przykład ten utworzony w sekcji Umieść model w wolumenie.

cgc compute create -n <name> -c 4 -m 8 -g 1 -gt NVIDIA-RTX-A5000 -v models vllm-openai -- --model=/media/models/Llama-3.2-3B-Instruct

Wolumen przekazany przez -v jest montowany pod /media/models, niezależnie od jego nazwy, więc ta ścieżka nie zależy od nazwy wolumenu.

Parametry

• -n - nazwa instancji, która będzie używana w adresach URL
• -c - rdzenie CPU, w większości przypadków nie więcej niż 4 są potrzebne
• -m - pamięć, w większości przypadków nie więcej niż 8 GiB jest potrzebne
• -g, -gt - liczba i typ GPU. Upewnij się, że vRAM jest wystarczający dla modelu.
• -v - wolumen z modelami

Wymagane argumenty

• --model <ścieżka> - ścieżka do katalogu modelu (np. /media/models/Llama-3.2-3B-Instruct) lub ID repozytorium Hugging Face (np. speakleash/Bielik-11B-v2.6-Instruct).

Domyślne argumenty

• --host 0.0.0.0 - wiąże serwer ze wszystkimi dostępnymi adresami IP
• --port 8000 - ustawia port, na którym serwer nasłuchuje
• --api-key <APP_TOKEN> - ustawia klucz API dla serwera, który można odczytać w wyniku polecenia cgc compute list -d
• --download-dir /media/models/huggingface - określa katalog, w którym pobierane są modele, domyślnie /media/models/huggingface
• --max-model-len 4096 - maksymalna długość sekwencji dla modelu, domyślnie 4096
• --safetensors-load-strategy prefetch - włącza pobieranie z wyprzedzeniem plików safetensors, co przyspiesza ładowanie modelu poprzez równoległe pobieranie plików wagowych

Opcjonalne zmienne środowiskowe

• HF_TOKEN - Twój token Hugging Face. Wymagany, jeśli pobierasz modele z ograniczonym dostępem.
• TRUST_REMOTE_CODE - Jeśli określone, zezwala na wykonywanie zdalnego kodu z repozytorium modelu. Domyślnie zdalny kod nie jest zaufany.
• TENSOR_PARALLEL_SIZE - liczba GPU używanych do równoległości tensorowej, umożliwiająca uruchomienie modeli zbyt dużych dla pojedynczego GPU.
• MAX_NUM_BATCHED_TOKENS - maksymalna liczba tokenów w pojedynczym batchu.
• VLLM_USE_MODELSCOPE - ustaw na true, aby użyć ModelScope do ładowania modeli.
• VLLM_USE_PRECOMPILED - ustaw na true, aby korzystać z prekompilowanych kerneli, co może przyspieszyć czas uruchamiania.
• VLLM_USE_V1 - określa wersję silnika vLLM do użycia.
• UV_TORCH_BACKEND - definiuje backend dla UV Torch.

Szczegółową listę wszystkich możliwych argumentów i zmiennych środowiskowych znajdziesz
na stronie vLLM OpenAI compatible server.

Użycie API

Twój endpoint znajduje się pod adresem:

https://<name>.<NAMESPACE>.cgc-waw-01.comtegra.cloud/

Pobierz token API:

cgc compute list -d

Przykładowe wywołanie

curl -H "Authorization: Bearer $API_TOKEN" \
     -H "Content-Type: application/json" \
     -X POST \
     -d '{
           "model": "/media/models/Llama-3.2-3B-Instruct",
           "messages": [
             {"role":"user","content":"Hello!"}
           ]
         }' \
     https://<name>.<NAMESPACE>.cgc-waw-01.comtegra.cloud/v1/chat/completions

Modele embeddingowe

Ten sam szablon może serwować model embeddingowy. Poniższy przykład używa intfloat/multilingual-e5-large (~2,2 GiB, 1024 wymiary):

cgc compute create vllm-openai -n <name> -c 2 -m 8 -g 1 -gt NVIDIA-RTX-A5000 -v <volume_name> -- --model=intfloat/multilingual-e5-large --runner pooling --max-model-len 512

• --runner pooling przełącza serwer w tryb embeddingów.
• --max-model-len 512 powtarza domyślny argument z niższą wartością. Modele e5 obsługują tylko 512 pozycji, a przy domyślnym 4096 serwer odmawia uruchomienia.

Serwer udostępnia wtedy model pod /v1/embeddings:

curl -H "Authorization: Bearer $API_TOKEN" \
     -H "Content-Type: application/json" \
     -X POST \
     -d '{
           "model": "intfloat/multilingual-e5-large",
           "input": ["query: co to jest CGC?"]
         }' \
     https://<name>.<NAMESPACE>.cgc-waw-01.comtegra.cloud/v1/embeddings

To samo wywołanie z klientem OpenAI dla Pythona:

from openai import OpenAI

client = OpenAI(base_url="https://<name>.<NAMESPACE>.cgc-waw-01.comtegra.cloud/v1",
    api_key="APP_TOKEN")

res = client.embeddings.create(model="intfloat/multilingual-e5-large",
    input="query: co to jest CGC?")

print(len(res.data[0].embedding))

Modele e5 oczekują prefiksu przy każdym wejściu: query: dla zapytań wyszukiwania i passage: dla indeksowanych dokumentów.