vLLM: configurare vLLM in locale e su Google Cloud per CPU

vLLM (Virtual Large Language Model) è una libreria progettata per ospitare large language model (LLM). Offre un ambiente ottimizzato per gestire attività di elaborazione del linguaggio su larga scala.

Ci sono diversi motivi per cui potremmo voler ospitare un LLM nostro. Eseguire un modello in locale o su una piattaforma cloud ci dà controllo sulla privacy dei dati, consente potenziali personalizzazioni del modello per adattarlo meglio alle nostre esigenze specifiche e, a seconda dell’applicazione, può risultare più economico.

Inoltre, vLLM è compatibile con la OpenAI API. Questa compatibilità significa che, se abbiamo già del codice che interagisce con l’infrastruttura di OpenAI, possiamo sostituirla con un LLM ospitato da noi tramite vLLM senza dover modificare la codebase esistente.

In questo articolo ti guiderò nei passaggi per configurare vLLM. Inizieremo mostrando come eseguirlo sul nostro computer usando Docker, uno strumento molto diffuso per la containerizzazione che semplifica l’esecuzione coerente delle applicazioni tra ambienti. Poi vedremo come distribuire vLLM su Google Cloud, ottenendo una soluzione scalabile per ospitare questi modelli e prepararli a gestire attività più impegnative o volumi di traffico maggiori.

Come configurare vLLM in locale per CPU con Docker

vLLM semplifica l’esecuzione degli LLM con una configurazione efficiente ottimizzata per una piattaforma CUDA, che di solito significa usare GPU NVIDIA per l’accelerazione. Tuttavia, se vogliamo eseguire il modello su CPU, possiamo utilizzare l’immagine Docker che vLLM fornisce specificamente per l’uso su CPU. Questa flessibilità ci consente di ospitare modelli anche se non abbiamo accesso a un ambiente abilitato a CUDA. Per ospitare vLLM su una piattaforma CUDA, fai riferimento alla loro guida rapida.

Dato che la maggior parte di noi non ha accesso a GPU di fascia alta, ci concentreremo sulla configurazione di vLLM per l’esecuzione su CPU. In questo modo possiamo comunque sperimentare con gli LLM usando le risorse a disposizione.

Per semplificare il processo useremo Docker, uno strumento che permette di impacchettare applicazioni e dipendenze in container. Pensa a un container come a un’unità leggera e portatile che include tutto il necessario per eseguire un determinato software. Con Docker non dobbiamo preoccuparci di installare manualmente vLLM o gestire potenziali problemi di compatibilità sul nostro sistema.

vLLM offre un’immagine Docker pronta all’uso progettata specificamente per l’esecuzione su CPU. Include tutti i componenti necessari per far girare vLLM, consentendoci di concentrarci sull’uso del modello invece che sulle complessità della configurazione. Questo significa poter avviare rapidamente ed efficacemente i nostri LLM su CPU.

Passo 1: build dell’immagine Docker

Per prima cosa dobbiamo creare un’immagine Docker che ci permetta di eseguire vLLM sul nostro computer. Il repository vLLM fornisce Dockerfile con tutte le istruzioni necessarie per creare un’immagine in grado di eseguire vLLM su CPU.

• Dockerfile.cpu per CPU tradizionali.
• Dockerfile.arm per CPU ARM come quelle dei Mac moderni.

Dato che ho un Mac con processore M2, userò il file .arm. Per creare l’immagine, prima clona o scarica il repository e poi esegui questo comando al suo interno:

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

Ecco una rapida spiegazione di cosa fa questo comando:

• docker build: crea un’immagine Docker da un Dockerfile.
• -f Dockerfile.arm: specifica quale Dockerfile usare.
• -t vllm-cpu: assegna all’immagine il tag vllm-cpu per riferimenti facili (potrebbe essere anche un altro nome).
• --shm-size=4g: alloca 4 GB di memoria condivisa, utile per migliorare le prestazioni.

Passo 2: configurare Hugging Face

vLLM usa Hugging Face, una piattaforma che facilita la gestione dei modelli, per semplificare l’hosting. Ecco come iniziare:

1. Crea un account Hugging Face: visita il sito di Hugging Face e registrati se non l’hai già fatto.
2. Richiedi l’accesso a un modello: una volta effettuato l’accesso, cerca il modello che vuoi usare. Per questa demo, consiglio meta-llama/Llama-3.2-1B-Instruct, un modello più piccolo adatto ai primi test. Nella pagina del modello potrebbe esserci un’opzione per richiedere l’accesso. Segui le istruzioni fornite.
3. Crea un token: vai alla pagina dei token API su Hugging Face. Clicca su "Create New Token" e genera un token. Ti servirà per accedere e scaricare i modelli.

Passo 3: eseguire il container Docker

Con l’immagine Docker creata e il token di Hugging Face pronto, possiamo ora eseguire il modello vLLM con il seguente comando:

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

Vediamo nel dettaglio il comando:

• docker run: esegue un container basato sull’immagine specificata.
• -it: esecuzione interattiva con accesso al terminale.
• --rm: rimuove automaticamente il container quando si arresta.
• -p 8000:8000: mappa la porta 8000 del container sulla porta 8000 della macchina locale, rendendo il servizio disponibile in locale.
• --env "HUGGING_FACE_HUB_TOKEN=<replace_with_hf_token>": imposta il token Hugging Face come variabile d’ambiente, permettendo a vLLM di connettersi alle API di Hugging Face. Sostituisci <replace_with_hf_token> con il token effettivo che hai creato.
• vllm-cpu: nome dell’immagine Docker creata in precedenza.
• --model meta-llama/Llama-3.2-1B-Instruct: indica quale modello eseguire.
• --dtype float16: usa il tipo di dato float16 perché il modello lo richiede quando gira su CPU.

Quando eseguiamo questo comando, il server impiegherà un po’ a essere pronto perché deve scaricare l’LLM. Sarà pronto quando in terminale vediamo qualcosa di simile:

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)

Interagire con l’LLM

Una delle grandi caratteristiche di vLLM è la compatibilità con l’OpenAI API. Questo significa che, se abbiamo già codice pensato per interagire con l’infrastruttura di OpenAI, possiamo usare lo stesso codice per comunicare con un modello ospitato tramite vLLM.

Questa compatibilità consente una transizione fluida senza modificare la codebase esistente. Quindi, una volta configurato vLLM, diventa semplice continuare a usare gli strumenti e i comandi familiari per interagire con l’LLM, rendendo l’integrazione efficiente e intuitiva.

Ecco un esempio di come inviare un messaggio al nostro server locale in esecuzione su Docker:

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)

Nota che sopra abbiamo usato la chiave API "EMPTY". È la chiave predefinita. Possiamo richiedere una chiave per accedere al modello specificandola con il parametro --api-key. Ad esempio:

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 questo caso, dobbiamo poi sostituire la chiave all’inizio del codice:

openai_api_key = "supersecretkey"

Come ospitare vLLM su CPU in Google Cloud

Ospitare un LLM su Google Cloud con vLLM può essere una soluzione per distribuire LLM. Vediamo i passaggi indicati, ampliandoli per maggiore chiarezza.

Passo 1: accedi alla Google Cloud Console

Per prima cosa, accediamo alla Google Cloud Console. Possiamo farlo aprendo Google Cloud Console nel browser. Se non abbiamo un account Google, è necessario crearlo per usare i servizi Google Cloud.

Passo 2: crea un progetto

Nella Google Cloud Console, individua il menu a discesa dei progetti in alto e seleziona "New Project".

Inserisci vllm-demo come nome del progetto, così sarà più facile identificarlo in seguito.

Se abbiamo già un account Google Cloud, l’account di fatturazione di prova potrebbe non essere disponibile. In tal caso, dobbiamo crearne uno nuovo. Vai alla sezione "Billing" e segui i passaggi per selezionare un account di fatturazione esistente o crearne uno nuovo.

Passo 3: abilita il servizio Artifact Registry

Artifact Registry è un servizio che consente di archiviare e gestire immagini container. Lo useremo per conservare l’immagine Docker che utilizzeremo per eseguire vLLM.

Nella Cloud Console, cerca "artifact" per aprire l’Artifact Registry.

Quindi abilitalo per il nostro progetto. Questo passaggio è necessario per archiviare l’immagine Docker della nostra configurazione vLLM.

Passo 4: crea un repository di artifact

Ora dobbiamo creare un repository di artifact per memorizzare le nostre immagini container. Vai su Artifact Registry e clicca su "Create Repository".

Assegna al repository il nome vllm-cpu e scegli "Docker" come formato. Specifica la località us-central1 per ottimizzare le prestazioni in base alle nostre esigenze di distribuzione. Il resto della configurazione può rimanere con i valori predefiniti.

Passo 5: build e push dell’immagine Docker

Come fatto in locale, dobbiamo creare l’immagine Docker e poi caricarla (push) nel repository Google Cloud vllm-cpu. Lo faremo usando la cloud shell in alto a destra.

.

In quel terminale, clona il repository GitHub di vLLM con il seguente comando per scaricare i file necessari:

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

Spostati nella directory vLLM clonata usando il terminale.

cd vllm

Crea l’immagine Docker con il comando indicato, che usa il Dockerfile fornito e configurato per l’uso su CPU:

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

Una volta creata l’immagine Docker, esegui il push nel nostro Artifact Repository. Questo passaggio carica l’immagine in modo che possa essere usata in seguito dai servizi Google Cloud:

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

Passo 6: configura il servizio su Cloud Run

Google Cloud Run consente la distribuzione di applicazioni containerizzate. Useremo questo servizio per distribuire l’immagine che abbiamo appena creato.

Digita "cloud run" nella barra di ricerca e apri il servizio “Cloud Run”.

Da lì, clicca sul pulsante "Create Service":

Quindi segui questi passaggi:

1. Seleziona l’immagine del container: scegli l’immagine che abbiamo inviato in precedenza.
2. Configura la porta: modifica la porta predefinita in 8000, usata da vLLM.
3. Aggiungi il token Hugging Face: nella sezione "Variables & Secrets", aggiungi una nuova variabile con nome HUGGING_FACE_HUB_TOKEN e incolla qui il nostro token. Consente a vLLM di accedere ai modelli su Hugging Face.
4. Argomenti del container: nella sezione dei comandi, includi l’argomento --model=meta-llama/Llama-3.2-1B per specificare il modello desiderato.
5. Assegna le risorse: imposta la memoria a 16 GiB e assegna 4 CPU per garantire al container risorse sufficienti per un’elaborazione efficiente.
6. Impostazioni dell’istanza: per ridurre i tempi di cold start, mantieni attiva almeno un’istanza. Potrebbe aumentare i costi, ma migliora le prestazioni riducendo i tempi di download del modello e di avvio.

Completata la configurazione (le altre opzioni possono restare predefinite), clicca sul pulsante “Create” in fondo alla pagina. Attendi che il servizio sia pronto e vai alla pagina del servizio. Lì troverai l’URL del servizio che possiamo usare per comunicare con l’LLM.

Dovrebbe essere qualcosa del genere:

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

Interagire con l’LLM

Possiamo interagire con l’LLM in Python come abbiamo fatto in locale. Dobbiamo solo cambiare l’URL nello script:

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

Considerazioni importanti sui costi

Attenzione: se stai seguendo questi passaggi, ricorda che mantenere attivo l’artifact registry comporta dei costi. Ricordati quindi di scollegare l’account di fatturazione dopo aver seguito questa guida, altrimenti verrai addebitato anche se nessuno lo utilizza.

Configurazione GPU su Google Cloud

Al momento della stesura di questo tutorial, il supporto GPU per Google Cloud Run è disponibile su richiesta. Significa che dobbiamo chiedere esplicitamente l’accesso a questa funzione. Una volta ottenuto, eseguire vLLM con GPU aumenterà notevolmente le prestazioni rispetto alla CPU. È particolarmente utile per gestire LLM di grandi dimensioni, poiché le GPU sono progettate per elaborare attività parallele in modo più efficiente.

Se otteniamo l’accesso al supporto GPU, possiamo semplificare il flusso di lavoro. In questo scenario, non serve creare una nostra immagine Docker: possiamo creare direttamente un servizio usando l’immagine preesistente vllm/vllm-openai:latest. Questa immagine è ottimizzata per l’uso con GPU, permettendoci di distribuire i modelli in modo rapido ed efficace senza i passaggi aggiuntivi richiesti per la configurazione su CPU.

Una volta approvato l’accesso GPU e configurato il servizio con l’immagine indicata, la nostra distribuzione vLLM potrà sfruttare appieno la potenza e la velocità delle GPU, risultando adatta ad applicazioni in tempo reale e a compiti di elaborazione del linguaggio ad alta richiesta.

RunPod: hosting alternativo

Per chi cerca opzioni di hosting alternative, piattaforme come RunPod offrono servizi semplificati per ospitare large language model. RunPod, per esempio, mette a disposizione una configurazione serverless che semplifica il processo di deployment.

Sebbene questa opzione sia intuitiva e rapida da configurare, è importante considerare che la comodità ha spesso un costo più elevato. Se il budget è un vincolo, potrebbe valere la pena bilanciare la facilità d’uso con i costi associati a tali servizi.

Conclusione

In questo tutorial abbiamo visto come configurare e ospitare vLLM sia in locale che su Google Cloud.

Abbiamo imparato a creare ed eseguire immagini Docker specifiche per CPU, rendendo l’accesso possibile anche senza GPU di fascia alta. Inoltre, abbiamo esplorato il deployment di vLLM su Google Cloud, che offre una soluzione scalabile per gestire attività più grandi.