vLLM: vLLM lokaal en op Google Cloud instellen voor CPU

vLLM (Virtual Large Language Model) is een bibliotheek die is ontworpen om grote taalmodellen (LLM’s) te hosten. Het biedt een geoptimaliseerde omgeving voor het afhandelen van grootschalige taalverwerkingstaken.

Er zijn verschillende redenen om je eigen LLM te hosten. Een model lokaal of op een cloudplatform hosten geeft je controle over gegevensprivacy, de mogelijkheid om het model aan te passen aan je specifieke behoeften, en het kan goedkoper zijn afhankelijk van de toepassing.

Daarnaast is vLLM compatibel met de OpenAI API. Deze compatibiliteit betekent dat je, als je al code hebt die met de infrastructuur van OpenAI werkt, die kunt vervangen door je eigen gehoste LLM met vLLM zonder je bestaande codebase te hoeven aanpassen.

In dit artikel neem ik je mee door de stappen om vLLM in te stellen. We beginnen met laten zien hoe je het op je computer draait met Docker, een populair containerization‑tool dat het eenvoudiger maakt om toepassingen consistent in verschillende omgevingen uit te voeren. Daarna leren we hoe je vLLM op Google Cloud implementeert, zodat je een schaalbare oplossing hebt voor het hosten van deze modellen en ze klaar zijn voor grotere taken of meer verkeer.

vLLM lokaal voor CPU instellen met Docker

vLLM maakt het draaien van LLM’s eenvoudiger met een efficiënte setup die is geoptimaliseerd voor een CUDA‑platform, wat doorgaans betekent dat NVIDIA GPU’s worden gebruikt voor versnelling. Als we het model in plaats daarvan op een CPU willen draaien, kunnen we echter de Docker‑image gebruiken die vLLM specifiek voor CPU‑gebruik levert. Deze flexibiliteit stelt ons in staat modellen te hosten zelfs zonder toegang tot een CUDA‑omgeving. Voor hosting van vLLM op een CUDA‑platform, raadpleeg hun quickstart‑gids.

Omdat de meesten van ons geen toegang hebben tot high‑end GPU’s, richten we ons op het instellen van vLLM om op een CPU te draaien. Zo kunnen we toch met LLM’s experimenteren met de middelen die we hebben.

Om het proces te vereenvoudigen gebruiken we Docker, een populair hulpmiddel waarmee we toepassingen en hun afhankelijkheden in containers kunnen verpakken. Zie een container als een lichtgewicht, draagbare eenheid met alles wat nodig is om specifieke software te draaien. Met Docker hoeven we vLLM niet handmatig te installeren of ons bezig te houden met mogelijke compatibiliteitsproblemen op ons systeem.

vLLM biedt een kant‑en‑klare Docker‑image die specifiek is ontworpen voor CPU‑uitvoering. Deze image bevat alle benodigde componenten om vLLM te draaien, zodat we ons kunnen richten op het gebruiken van het model in plaats van de complexiteit van de setup. Dit betekent dat we onze LLM’s snel en efficiënt op een CPU kunnen laten draaien.

Stap 1: De Docker‑image bouwen

Eerst moeten we een Docker‑image bouwen waarmee we vLLM op onze computer kunnen draaien. De vLLM‑repository bevat Dockerfiles met alle benodigde instructies om een image te bouwen die vLLM op een CPU kan draaien.

• Dockerfile.cpu voor reguliere CPU’s.
• Dockerfile.arm voor ARM‑CPU’s zoals in moderne Macs.

Omdat ik een Mac met een M2‑processor heb, gebruik ik het .arm-bestand. Om de image te bouwen, klonen of downloaden we eerst de repository en voeren we vervolgens dit commando uit in die map:

docker build -f Dockerfile.arm -t vllm-cpu --shm-size=4g .

Hier is kort wat dit commando doet:

• docker build: maakt een Docker‑image op basis van een Dockerfile.
• -f Dockerfile.arm: specificeert welke Dockerfile wordt gebruikt.
• -t vllm-cpu: tagt de image als vllm-cpu voor eenvoudige referentie (had ook een andere naam kunnen zijn).
• --shm-size=4g: reserveert 4 gigabyte gedeeld geheugen, wat de prestaties kan verbeteren.

Stap 2: Hugging Face instellen

vLLM gebruikt Hugging Face, een platform voor het beheren van modellen, om het hosten te stroomlijnen. Zo ga je aan de slag:

1. Maak een Hugging Face‑account: Ga naar de Hugging Face‑website en meld je aan als je dat nog niet hebt gedaan.
2. Vraag toegang tot een model aan: Zoek, zodra je bent ingelogd, naar het model dat je wilt gebruiken. Voor deze demo raad ik meta-llama/Llama-3.2-1B-Instruct aan, omdat dit een kleiner model is dat geschikt is voor eerste tests. Op de modelpagina staat mogelijk een optie om toegang aan te vragen. Volg de instructies om toegang te krijgen.
3. Maak een token: Ga naar de API‑tokenpagina op Hugging Face. Klik op "Create New Token" en maak een token. Dit token is nodig om modellen te kunnen openen en downloaden.

Stap 3: De Docker‑container draaien

Met onze Docker‑image gebouwd en het Hugging Face‑token klaar, kunnen we het vLLM‑model nu draaien met het volgende commando:

docker run -it --rm -p 8000:8000 \
--env "HUGGING_FACE_HUB_TOKEN=<replace_with_hf_token>" \
vllm-cpu --model meta-llama/Llama-3.2-1B-Instruct \
--dtype float16

Laten we dit commando ontrafelen:

• docker run: start een container op basis van de opgegeven Docker‑image.
• -it: draait de container interactief met terminaltoegang.
• --rm: verwijdert de container automatisch wanneer deze stopt.
• -p 8000:8000: koppelt poort 8000 van de container aan poort 8000 op onze machine, zodat de service lokaal beschikbaar is.
• --env "HUGGING_FACE_HUB_TOKEN=<replace_with_hf_token>": stelt het Hugging Face‑token in als omgevingsvariabele, zodat vLLM verbinding kan maken met de Hugging Face API. Vervang <replace_with_hf_token> door het daadwerkelijke token dat we hebben gemaakt.
• vllm-cpu: de naam van de Docker‑image die we eerder hebben gebouwd.
• --model meta-llama/Llama-3.2-1B-Instruct: geeft aan welk model wordt gedraaid.
• --dtype float16: gebruik het float16-datatype, omdat het model dit op CPU vereist.

Wanneer we dit commando draaien, duurt het even voordat de server klaar is, omdat de LLM moet worden gedownload. Hij is klaar wanneer je iets als dit in de terminal ziet:

INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

Interactie met de LLM

Een van de sterke punten van vLLM is de compatibiliteit met de OpenAI API. Dat betekent dat we, als we al code hebben die met de infrastructuur van OpenAI praat, diezelfde code eenvoudig kunnen gebruiken om te communiceren met een via vLLM gehost model.

Dankzij deze compatibiliteit is de overgang soepel zonder dat we onze bestaande codebase hoeven te wijzigen. Als we vLLM eenmaal hebben ingesteld, kunnen we dus gewoon onze vertrouwde tools en commando’s blijven gebruiken om met de LLM te communiceren, wat de integratie efficiënt en gebruiksvriendelijk maakt.

Hier is een voorbeeld van hoe je een bericht stuurt naar onze lokale server die op Docker draait:

from openai import OpenAI
openai_api_key = "EMPTY"
openai_api_base = "http://localhost:8000/v1"
client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)
models = client.models.list()
model = models.data[0].id
completion = client.chat.completions.create(
    model=model,
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello"},
    ]
)
print(completion.choices[0].message.content)

Let op dat we hierboven de "EMPTY" API‑sleutel hebben gebruikt. Dit is de standaard sleutel. We zouden een sleutel kunnen vereisen om toegang tot het model te krijgen door deze op te geven met de parameter --api-key. Bijvoorbeeld:

docker run -it --rm -p 8000:8000 \
--env "HUGGING_FACE_HUB_TOKEN=<replace_with_hf_token>" \
vllm-cpu --model meta-llama/Llama-3.2-1B-Instruct \
--dtype float16 --api-key supersecretkey

In dat geval moeten we de sleutel bovenaan de code vervangen:

openai_api_key = "supersecretkey"

vLLM voor CPU hosten op Google Cloud

Een LLM hosten op Google Cloud met vLLM kan een solide oplossing zijn voor het implementeren van LLM’s. Laten we de genoemde stappen doornemen en verduidelijken.

Stap 1: Ga naar de Google Cloud Console

We moeten eerst naar de Google Cloud Console. Dat kan door in de browser naar de Google Cloud Console te gaan. Als we nog geen Google‑account hebben, moeten we er een aanmaken om Google Cloud‑services te gebruiken.

Stap 2: Maak een project

Zoek in de Google Cloud Console het projectkeuzemenu bovenaan het scherm en selecteer "New Project". 

Voer vllm-demo in als projectnaam, zodat we het later makkelijk herkennen.

Als we al een Google Cloud‑account hebben, is de proef‑betaalrekening mogelijk niet beschikbaar. In dat geval moeten we een nieuwe betaalrekening aanmaken. Ga hiervoor naar het gedeelte "Billing" en volg de stappen om een bestaande betaalrekening te selecteren of een nieuwe te maken.

Stap 3: Schakel de Artifact Registry‑service in

Artifact Registry is een service waarmee we containerimages kunnen opslaan en beheren. We gebruiken deze om de Docker‑image op te slaan die we voor vLLM gaan gebruiken. 

Zoek in de Cloud Console op "artifact" om de Artifact Registry te openen.

Schakel deze vervolgens in voor ons project. Deze stap is nodig om de Docker‑image van onze vLLM‑setup op te slaan.

Stap 4: Maak een artifact repository

We moeten nu een artifact repository maken om onze containerimages op te slaan. Ga naar Artifact Registry en klik op "Create Repository". 

Noem de repository vllm-cpu en kies "Docker" als formaat. Stel de locatie in op us-central1 om de prestaties te optimaliseren op basis van onze implementatie‑eisen. De rest van de configuratie kan op de standaardwaarden blijven.

Stap 5: Bouw en push de Docker‑image

Net als op onze lokale machine moeten we de Docker‑image bouwen en deze vervolgens uploaden (pushen) naar onze vllm-cpu Google Cloud‑repository. Dit doen we met de cloud shell rechtsboven.

.

Kloon in die terminal de vLLM GitHub‑repository met het volgende commando om de benodigde bestanden op te halen:

git clone https://github.com/vllm-project/vllm.git

Navigeer in de terminal naar de gekloonde vLLM‑map.

cd vllm

Bouw de Docker‑image met het opgegeven commando, dat de meegeleverde Dockerfile gebruikt die is geconfigureerd voor CPU‑gebruik:

docker build \
-t us-central1-docker.pkg.dev/vllm-demo/vllm-cpu/vllm-openai:latest \
-f Dockerfile.cpu .

Nadat de Docker‑image is gebouwd, push je deze naar onze Artifact Repository. Daarmee upload je de image zodat Google Cloud‑services deze later kunnen gebruiken:

docker push us-central1-docker.pkg.dev/vllm-demo/vllm-cpu/vllm-openai:latest

Stap 6: Stel de service in op Cloud Run

Google Cloud Run maakt het mogelijk containerized applicaties te deployen. We gebruiken deze service om de image te deployen die we zojuist hebben gebouwd. 

Typ "cloud run" in de zoekbalk en open de "Cloud Run"‑service.

Klik daar op de knop "Create Service":

Volg vervolgens deze stappen:

1. Selecteer de containerimage: kies de containerimage die we eerder hebben gepusht.
2. Configureer de poort: wijzig de standaardpoort naar 8000, die door vLLM wordt gebruikt.
3. Voeg het Hugging Face‑token toe: voeg in het gedeelte "Variables & Secrets" een nieuwe variabele toe met de naam HUGGING_FACE_HUB_TOKEN en plak hier ons token. Dit token stelt vLLM in staat modellen van Hugging Face te benaderen.
4. Containerargumenten: neem in het commandogedeelte het argument --model=meta-llama/Llama-3.2-1B op om het gewenste model te specificeren.
5. Resources toewijzen: stel het geheugen in op 16 GiB en wijs 4 CPU’s toe om de container voldoende resources te geven voor efficiënte verwerking.
6. Instantie‑instellingen: houd om cold starts te verminderen minstens één instantie actief. Dit kan de kosten verhogen, maar verbetert de prestaties doordat de download‑ en opstarttijd van het model worden geminimaliseerd.

Met alle configuratie ingesteld (de overige opties kunnen op de standaardwaarden blijven) klik je onderaan de pagina op "Create". Wacht tot de service gereed is en ga naar de servicepagina. Daar staat de service‑URL die we kunnen gebruiken om met de LLM te communiceren. 

Die ziet er ongeveer zo uit:

https://vllm-llama-577126904161.us-central1.run.app

Interactie met de LLM

We kunnen met de LLM communiceren met Python zoals we deden toen we het model lokaal draaiden. We hoeven alleen de URL in het script te wijzigen:

# Replace with your service URL
openai_api_base = "https://vllm-llama-577126904161.us-central1.run.app/v1"

Belangrijke kostenoverwegingen

Waarschuwing: als je deze stappen volgt, houd er dan rekening mee dat het actief houden van de artifact registry geld kost. Vergeet dus niet de betaalrekening te ontkoppelen nadat je deze gids hebt gevolgd, anders worden er kosten in rekening gebracht zelfs als niemand het gebruikt.

Google Cloud GPU‑setup

Op het moment van schrijven van deze tutorial is GPU‑ondersteuning voor Google Cloud Run op aanvraag beschikbaar. Dat betekent dat we specifiek toegang tot deze functie moeten aanvragen. Zodra dat is toegekend, zal het draaien van vLLM op een GPU de prestaties aanzienlijk verbeteren vergeleken met CPU‑gebruik. Dit is vooral nuttig voor grote taalmodellen, omdat GPU’s zijn ontworpen om parallelle taken efficiënter te verwerken.

Als we toegang tot GPU‑ondersteuning krijgen, kunnen we onze workflow stroomlijnen. In dat geval hoeven we niet zelf een Docker‑image te bouwen. In plaats daarvan kunnen we direct een service maken met de bestaande image vllm/vllm-openai:latest. Deze image is geoptimaliseerd voor GPU‑gebruik, zodat we onze modellen snel en effectief kunnen deployen zonder de extra setup‑stappen die voor CPU‑configuraties nodig zijn.

Zodra GPU‑toegang is goedgekeurd en we de service met de meegeleverde image hebben opgezet, kan onze vLLM‑implementatie volop profiteren van de kracht en snelheid van GPU’s, geschikt voor realtime‑toepassingen en veeleisende taalverwerkingstaken.

RunPod: Alternatieve hosting

Voor wie naar alternatieve hostingopties zoekt, bieden platforms zoals RunPod gestroomlijnde services voor het hosten van grote taalmodellen. RunPod biedt bijvoorbeeld een serverless‑setup die het deployen vereenvoudigt.

Hoewel deze optie gebruiksvriendelijk en snel op te zetten is, is het goed om te onthouden dat gemak vaak een hoger prijskaartje heeft. Als budget een rol speelt, is het verstandig het gebruiksgemak af te wegen tegen de kosten van dergelijke services.

Conclusie

In deze tutorial hebben we bekeken hoe je vLLM zowel lokaal als op Google Cloud instelt en host.

We leerden hoe je Docker‑images bouwt en draait die specifiek zijn afgestemd op CPU’s, zodat het ook toegankelijk is zonder high‑end GPU’s. Daarnaast hebben we gekeken naar het deployen van vLLM op Google Cloud, wat een schaalbare oplossing biedt voor grotere taken.