Ollama in Docker su un server senza GPU: cosa aspettarsi e come misurarlo
Ollama in Docker su un server senza GPU: modello sempre caricato, limiti di memoria e coda, e come misurare tempo di caricamento e token al secondo dalla risposta.

Per classificare testi, estrarre dati o fare un assistente interno spesso basta un piccolo modello locale, e un server virtuale senza GPU è il posto più economico per farlo girare. Ollama pubblica un'immagine Docker ufficiale, quindi l'installazione richiede pochi minuti. Il tempo lo si perde dopo, per capire come si comporta il server sotto carico: la prima richiesta è lenta, un modello inattivo viene scaricato dalla memoria dopo un po', e un secondo utente in parallelo può raddoppiare il consumo di RAM.
Questa guida propone un file Docker Compose con versione fissata per un host solo CPU, spiega le impostazioni che contano e fornisce un piccolo client di benchmark che misura il tuo server con i numeri che Ollama stesso restituisce. Non contiene risultati di benchmark: la velocità su CPU dipende dal processore, dalla banda di memoria, dal modello e dalla quantizzazione, e una cifra presa da un'altra macchina sarebbe una supposizione. Misura sul tuo hardware.
Versioni verificate il 3 novembre 2026: Ollama 0.40.14 (tag ollama/ollama:0.40.14 su Docker Hub, pubblicato lo stesso giorno). Il client di benchmark usa solo la libreria standard di Python.
Avviare Ollama senza GPU
La documentazione Docker ufficiale indica questo comando per l'uso solo CPU:
docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama
Il volume ollama contiene i modelli scaricati in /root/.ollama; senza, ogni nuovo container li scaricherebbe di nuovo. La porta 11434 è l'API. Per un server che resta acceso preferisco Compose, con l'immagine fissata a una versione invece di latest, così un aggiornamento è una scelta e non una sorpresa:
services:
ollama:
image: ollama/ollama:0.40.14
ports:
- "127.0.0.1:11434:11434" # reachable only from this machine
volumes:
- ollama:/root/.ollama # models survive container recreation
environment:
OLLAMA_KEEP_ALIVE: "30m" # default is 5m: keep the model in RAM longer
OLLAMA_NUM_PARALLEL: "1" # default 1: parallel requests multiply the context memory
OLLAMA_MAX_QUEUE: "16" # default 512: reject early instead of queueing for minutes
mem_limit: 8g # model + context must fit, or the container is OOM-killed
restart: unless-stopped
volumes:
ollama:
Poi scarica un modello e chiamalo:
docker compose up -d
docker compose exec ollama ollama pull llama3.2:1b
curl http://127.0.0.1:11434/api/generate -d '{"model":"llama3.2:1b","prompt":"Hello","stream":false}'
Il nome del modello è solo un esempio di modello piccolo. Quale modello vada bene per il tuo compito e per la tua RAM lo decidi tu; la libreria dei modelli riporta le dimensioni. L'endpoint di pull dell'API riprende i download interrotti, quindi una sessione SSH caduta non significa ripartire da zero.
Le impostazioni che contano
Le FAQ documentano le variabili d'ambiente. Queste sono quelle che ho impostato nel file sopra, con i valori predefiniti come li riportano le FAQ nel giorno della verifica:
| Variabile | Predefinito | Perché cambiarla su un server piccolo |
|---|---|---|
OLLAMA_KEEP_ALIVE |
5 minuti | Dopo questo tempo di inattività il modello esce dalla memoria e la richiesta successiva paga di nuovo il caricamento. Per un servizio usato poche volte all'ora, 5 minuti significano molti avvii a freddo. |
OLLAMA_NUM_PARALLEL |
1 | Richieste che ogni modello elabora contemporaneamente. Aumentarlo richiede più memoria e su CPU non rende la macchina più veloce: le richieste si dividono gli stessi core. |
OLLAMA_MAX_QUEUE |
512 | Richieste in coda mentre il server è occupato, prima di iniziare a rifiutarle. Con una CPU che genera pochi token al secondo, 512 in coda sono minuti di attesa. Una coda corta trasforma il sovraccarico in un errore gestibile. |
OLLAMA_MAX_LOADED_MODELS |
3 per l'inferenza su CPU | Quanti modelli diversi restano in memoria. Ognuno occupa RAM: tre modelli da 4 GB richiedono circa 12 GB prima ancora del contesto. |
OLLAMA_HOST decide l'indirizzo su cui il processo si mette in ascolto; Ollama usa 127.0.0.1:11434 per impostazione predefinita. Nel file Compose l'esposizione la decide la mappatura della porta: 127.0.0.1:11434:11434 rende l'API raggiungibile solo dall'host stesso. L'API di Ollama non ha autenticazione. Se altre macchine devono usarla, metti davanti un reverse proxy con autenticazione e non pubblicare la porta su internet. Un container con -p 11434:11434 su un server pubblico è raggiungibile da chiunque lo trovi.
La riga mem_limit è un'impostazione di Docker, non di Ollama. Se modello e contesto non ci stanno, il kernel termina il container; un limite rende il guasto prevedibile e protegge gli altri servizi dello stesso host. Quanta memoria serva dipende dalla dimensione del modello, dalla quantizzazione e dalla lunghezza del contesto richiesta: controlla con docker stats mentre il modello è caricato e risponde.
Avvio a freddo e a caldo
La prima richiesta dopo un pull, o dopo il tempo di keep-alive, deve leggere il modello dal disco in memoria: è il caso a freddo. Le richieste successive trovano il modello già caricato: caso a caldo. Su un server CPU con disco lento la differenza può essere grande, e gli utenti la notano.
Ci sono due modi per controllarla, entrambi documentati nelle FAQ. Puoi precaricare un modello con una richiesta vuota e puoi impostare keep_alive per richiesta: 0 scarica il modello subito dopo la risposta, un numero negativo come -1 lo tiene in memoria. Un'impostazione semplice è precaricare il modello all'avvio del container:
curl http://127.0.0.1:11434/api/generate -d '{"model":"llama3.2:1b","keep_alive":"30m"}'
Il client di benchmark ha la stessa chiamata come funzione, utilizzabile da un health check o da uno script di avvio.
Leggere i numeri che Ollama restituisce
La risposta finale di /api/generate contiene durate e conteggi di token, come descritto nella documentazione dell'API. Tutte le durate sono in nanosecondi:
| Campo | Significato |
|---|---|
total_duration |
Tempo totale della richiesta |
load_duration |
Tempo speso a caricare il modello |
prompt_eval_count, prompt_eval_duration |
Token del prompt e tempo speso a valutare quelli non in cache |
eval_count, eval_duration |
Token generati e tempo speso a generarli |
La documentazione indica la formula della velocità di generazione: eval_count diviso eval_duration, per 10^9, cioè token al secondo. Lo stesso calcolo sui campi del prompt dà la velocità di lettura del prompt. Su CPU i due valori si comportano in modo diverso: leggere un prompt lungo è di solito molto più veloce, per token, che generare, ma un prompt lungo costa comunque secondi, e un'applicazione RAG che invia migliaia di token di contesto li paga a ogni richiesta. La guida su contare i token mostra come conoscere la dimensione del prompt prima della chiamata.
Ecco il client. Usa stream: false per ottenere un solo oggetto con tutti i campi e options.num_predict per limitare la lunghezza della risposta, così la misura resta breve:
"""Measure an Ollama server: load time, prompt speed, generation speed. Standard library only."""
import json
import sys
import urllib.request
NS = 1_000_000_000
def post(base_url: str, path: str, body: dict, timeout: float = 600) -> dict:
req = urllib.request.Request(
base_url + path, data=json.dumps(body).encode(),
headers={"content-type": "application/json"}, method="POST")
with urllib.request.urlopen(req, timeout=timeout) as res:
return json.load(res)
def preload(base_url: str, model: str, keep_alive: str = "30m") -> dict:
"""An empty request loads the model into memory without generating anything."""
return post(base_url, "/api/generate", {"model": model, "keep_alive": keep_alive})
def generate(base_url: str, model: str, prompt: str, num_predict: int = 64) -> dict:
return post(base_url, "/api/generate", {
"model": model, "prompt": prompt, "stream": False,
"options": {"num_predict": num_predict}})
def summarize(r: dict) -> dict:
"""Turn the final response fields (all durations in nanoseconds) into readable numbers."""
def rate(count_key: str, dur_key: str) -> float | None:
count, dur = r.get(count_key, 0), r.get(dur_key, 0)
return round(count / dur * NS, 2) if dur else None
return {
"load_s": round(r.get("load_duration", 0) / NS, 2),
"total_s": round(r.get("total_duration", 0) / NS, 2),
"prompt_tokens": r.get("prompt_eval_count", 0),
"prompt_tokens_per_s": rate("prompt_eval_count", "prompt_eval_duration"),
"output_tokens": r.get("eval_count", 0),
"output_tokens_per_s": rate("eval_count", "eval_duration"),
}
def main(base_url: str, model: str) -> None:
prompt = "Explain in three sentences what a reverse proxy does."
cold = summarize(generate(base_url, model, prompt)) # may include the model load
warm = summarize(generate(base_url, model, prompt)) # model already in memory
print(json.dumps({"cold": cold, "warm": warm}, indent=2))
if __name__ == "__main__":
main(sys.argv[1] if len(sys.argv) > 1 else "http://127.0.0.1:11434",
sys.argv[2] if len(sys.argv) > 2 else "llama3.2:1b")
Eseguilo sul tuo server e leggi i due blocchi:
python bench.py http://127.0.0.1:11434 llama3.2:1b
L'output ha una voce cold e una warm con load_s, prompt_tokens_per_s e output_tokens_per_s. Se la prima chiamata trova il modello già in memoria, le due voci saranno simili: per vedere un vero avvio a freddo riavvia il container o aspetta prima il tempo di keep-alive. Ripeti la misura più volte, a orari diversi se l'host è condiviso, perché i server virtuali possono avere vicini che usano gli stessi core fisici.
Cosa significano i numeri per la tua applicazione
- La velocità di output è l'esperienza dell'utente. Una persona legge a poche parole al secondo. Se la velocità misurata è inferiore, manda la risposta al browser in streaming invece di aspettare tutto il testo; la guida sullo streaming con SSE mostra come.
- Il tempo totale è tempo del prompt più tempo di generazione più (forse) il caricamento. Stimalo come
token del prompt / velocità del prompt + token massimi di output / velocità di outpute imposta il timeout del client ben sopra. - La concorrenza è una questione di capacità. Con
OLLAMA_NUM_PARALLEL=1un secondo utente aspetta il primo. Se il tuo picco supera una richiesta alla volta, calcola quante richieste al secondo il server sostiene davvero e confrontale con il traffico previsto; il nostro strumento di dimensionamento fa questi conti. Oltre un certo punto la risposta è un modello più piccolo, un prompt più corto, una GPU o un'API in hosting, non una coda più lunga. - Il sovraccarico deve diventare un errore. Con
OLLAMA_MAX_QUEUEcorta, una richiesta rifiutata può essere ritentata più tardi con backoff; vedi HTTP 429 e Retry-After per lo schema. Non ho verificato quale stato HTTP restituisca Ollama a coda piena: controllalo sulla tua versione e gestiscilo nel client; il nostro riferimento sugli errori HTTP aiuta a interpretare la risposta.
Testare senza un modello
La cartella dell'esempio contiene un finto server Ollama scritto con la libreria standard. Risponde a /api/generate con numeri fissi: una prima chiamata lenta che include un tempo di caricamento e poi chiamate più veloci. I test controllano la richiesta inviata dal client (stream: false, num_predict, corpo senza prompt per il precaricamento), la conversione dai nanosecondi, il caso di divisione per zero e che la prova a freddo sia più lenta di quella a caldo:
test_cold_slower_than_warm ... ok
test_generate_request_shape ... ok
test_preload_sends_no_prompt ... ok
test_summarize_units ... ok
test_zero_duration_gives_none ... ok
La suite gira in GitHub Actions a ogni modifica.
Limiti di questa guida
- Nell'ambiente in cui ho preparato l'articolo non ho potuto eseguire Docker né un modello reale. I test in CI dimostrano che il client invia le richieste giuste e calcola i numeri giusti dai campi documentati; non dimostrano il file Compose. L'ho scritto dalla documentazione ufficiale: prova
docker compose upsul tuo server prima di affidarti. - Non ci sono cifre di velocità, di proposito: dipenderebbero da una macchina che non hai.
- L'API di Ollama non ha autenticazione e un modello che risponde da una CPU si sovraccarica facilmente. Sono due motivi per tenere la porta chiusa e mettere dei limiti davanti.
- I valori predefiniti cambiano tra le versioni. Quelli sopra sono documentati al 3 novembre 2026 per la serie 0.40.x.
L'esempio completo e testato di questo articolo è nel nostro repository pubblico: adamant-solutions/ai-dev-examples/ollama-docker