Guida Pratica · 11 min di lettura

# Servire Llama 3.3 70B su un nodo.

Da una macchina consegnata cinque minuti fa a un endpoint compatibile con OpenAI che risponde alle richieste — con i due flag che dimezzano silenziosamente il throughput e quello che espone a una compromissione.

La risposta breve

- **Memoria necessaria:** 43 GB a 4-bit, 82 GB a FP8, 164 GB a BF16 — tutti a un contesto di 8k
- **La macchina più semplice:** Una scheda da 80 GB. Nessuno sharding, nessuna interconnessione, nessuna sincronizzazione
- **Tempo al primo token:** Meno di quindici minuti dalla consegna, la maggior parte spesa a scaricare i pesi
- **L’unico errore:** Pubblicare la porta 8000 su un indirizzo pubblico. Non ha autenticazione

## Cosa serve

70 miliardi di parametri. A 4 bit sono 35 GB di pesi; la cache KV aggiunge 2.5 GB a un contesto di 8k per una singola richiesta, e l’overhead di runtime è di circa il 15%. Tutto il resto discende da questi tre numeri — la [guida al dimensionamento della VRAM](https://gpuserver.io/it/guides/vram-sizing) mostra da dove provengono.

**Memoria necessaria per Llama 3.3 70B, per precisione e contesto**

| Precisione | Pesi | Totale a 8k | Totale a 32k | Totale a 128k |
|---|---|---|---|---|
| BF16 / FP16 Qualità reference | 140 GB | 164 GB | 173 GB | 207 GB |
| FP8 Quasi reference, Hopper e Blackwell | 70 GB | 82 GB | 86 GB | 103 GB |
| 4-bit (AWQ, GPTQ) Pesi più piccoli, la cache resta FP16 | 35 GB | 43 GB | 52 GB | 86 GB |

Noti la riga a 4 bit e 128k: i pesi si riducono a 35 GB ma la cache non si riduce affatto, perché AWQ e GPTQ quantizzano solo i pesi. Questo unico fatto decide gran parte della scelta della macchina qui sotto.

## Scegliere il nodo

Le macchine più economiche del nostro catalogo che contengono questo modello su una scheda *singola*, la configurazione da preferire quando possibile — niente sharding significa niente sincronizzazione e una cosa in meno da correggere.

**Nodi che contengono Llama 3.3 70B su una scheda**

| Nodo | La precisione che ci sta | Memoria della scheda | tok/s stimati | Al mese |
|---|---|---|---|---|
| [NVIDIA RTX A6000](https://gpuserver.io/it/gpu/rtx-a6000) PCIe 5.0 · 768 GB/s | 4-bit (AWQ, GPTQ) | 48 GB | ~10 | $286/mese |
| [2 × NVIDIA RTX A6000](https://gpuserver.io/it/gpu/rtx-a6000) PCIe 5.0 ×16 · 768 GB/s | 4-bit (AWQ, GPTQ) | 48 GB | ~10 | $597/mese |
| [NVIDIA L40S](https://gpuserver.io/it/gpu/l40s) PCIe 5.0 · 864 GB/s | 4-bit (AWQ, GPTQ) | 48 GB | ~11 | $714/mese |
| [NVIDIA A100 PCIe](https://gpuserver.io/it/gpu/a100-80gb) PCIe 5.0 · 1,935 GB/s | 4-bit (AWQ, GPTQ) | 80 GB | ~25 | $1,091/mese |

Il throughput è la generazione a flusso singolo, limitata dalla larghezza di banda della memoria, ed è deliberatamente conservativa. Con il batching continuo il *totale aggregato* tra le richieste concorrenti è più volte superiore — è proprio questo il senso di vLLM.

## Dieci minuti di configurazione

Qui nulla è specifico di noi tranne l’indirizzo. Docker, il NVIDIA Container Toolkit e uno stack di driver funzionante sono già sulla macchina.

Confermare la macchina, poi dare ai pesi un posto dove stare

```
$ ssh root@203.0.113.42
$ nvidia-smi --query-gpu=name,memory.total --format=csv

# Weights on the fast local NVMe, not the system volume.
$ mkdir -p /scratch/models
$ df -h /scratch

# A gated model needs a token. Skip if yours is open.
$ export HF_TOKEN=hf_xxxxxxxxxxxxxxxxxxxx
```

## Avviare il server

Un container. La prima esecuzione scarica circa 40 GB di pesi quantizzati, il che su una porta da 1 Gbit/s richiede pochi minuti; ogni riavvio successivo è questione di secondi.

vLLM, scheda singola, 4 bit

```
$ docker run -d --name vllm --restart unless-stopped \
    --gpus all --ipc=host \
    -v /scratch/models:/root/.cache/huggingface \
    -e HF_TOKEN="$HF_TOKEN" \
    -p 127.0.0.1:8000:8000 \
    vllm/vllm-openai:latest \
    --model casperhansen/llama-3.3-70b-instruct-awq \
    --quantization awq_marlin \
    --max-model-len 8192 \
    --gpu-memory-utilization 0.92

# Watch it load. "Application startup complete" is the signal.
$ docker logs -f vllm
```

Prima richiesta

```
$ curl -s http://127.0.0.1:8000/v1/models | head

$ curl -s http://127.0.0.1:8000/v1/chat/completions \
    -H 'Content-Type: application/json' \
    -d '{"model":"casperhansen/llama-3.3-70b-instruct-awq",
         "messages":[{"role":"user","content":"In one sentence: what is a KV cache?"}],
         "max_tokens":80}'
```

## I flag che contano

--max-model-len Impostarlo al contesto realmente servito vLLM riserva la cache KV per il massimo dichiarato. Dichiarare 131072 quando si serve 8192 spreca sedici volte la memoria necessaria, e il sintomo è «concorrenza insufficiente», non un errore.

--gpu-memory-utilization 0.90 to 0.95 La frazione della scheda che vLLM può riservarsi. Tutto ciò che non riserva viene sprecato; lasciare il valore predefinito di 0.90 su una macchina dedicata costa concorrenza reale. Non superi 0.95.

--ipc=host Obbligatorio, non facoltativo Senza di esso, la memoria condivisa del container è limitata a 64 MB. Su una scheda singola può capitare di cavarsela; su un modello suddiviso NCCL si blocca senza un errore utile.

--tensor-parallel-size Solo quando il modello non ci sta Applicare lo sharding a un modello che ci sta su una scheda sola lo rende *più lento*. Consulti la [guida all’interconnessione](https://gpuserver.io/it/guides/nvlink-vs-pcie) — è il modo più comune in assoluto per far rendere un nodo costoso peggio di uno economico.

--kv-cache-dtype fp8 Dimezza la cache Su Hopper e Blackwell. Raddoppia il contesto o la concorrenza gestibile, a un costo in qualità di norma non misurabile. Il guadagno più facile di questo elenco.

--max-num-seqs Limitarla alla concorrenza reale Lasciarlo a 256 su una macchina che serve otto utenti significa che vLLM pianifica per 256 e ammette richieste che non può gestire, il che si manifesta come picchi di latenza piuttosto che rifiuti.

## Non pubblicarlo al mondo

**L’API compatibile con OpenAI non ha autenticazione per impostazione predefinita.** Associato a `0.0.0.0` su un indirizzo pubblico, diventa un server di inferenza aperto, e gli scanner li trovano in poche ore. Noti il `-p 127.0.0.1:8000:8000` nel comando sopra — quell’indirizzo iniziale è ciò che lo tiene fuori da internet, ed è il singolo carattere più spesso perso quando si copia un comando da un’altra fonte.

Lo raggiunga dalla propria macchina tramite un tunnel SSH — nessuna porta aperta, nessun certificato da gestire, niente da configurare male:

Dal proprio laptop

```
$ ssh -N -L 8000:127.0.0.1:8000 root@203.0.113.42

# Now http://127.0.0.1:8000 on your laptop is the server.
```

Se deve davvero essere pubblico, metta un reverse proxy davanti con TLS e una chiave API, e limiti anche gli indirizzi di origine nel firewall. La [documentazione](https://gpuserver.io/it/docs#firewall) contiene un set minimo di regole. Prudenza ridondante è l’atteggiamento corretto per un endpoint che risponde a chiunque lo interroghi.

## Aumentare il throughput

Nell’ordine in cui vale la pena provarli. I primi due sono gratuiti e di solito danno i guadagni maggiori.

1. **Riduca `--max-model-len` al contesto realmente utilizzato.** Quasi sempre il singolo miglioramento più grande, e non costa nulla di ciò che stava già usando.
2. **Alzi `--gpu-memory-utilization` a 0.95.** Questa è una macchina dedicata; non c’è nient’altro sulla scheda per cui lasciare spazio.
3. **Attivi la cache KV FP8** se la scheda la supporta. Raddoppia ciò che può contenere.
4. **Raggruppi le richieste lato client.** Il batching continuo aiuta solo se le richieste arrivano in concorrenza. Le richieste una alla volta lasciano la maggior parte della scheda inattiva, qualunque sia la configurazione.
5. **Solo a quel punto, e non prima, consideri una scheda più veloce.** La generazione è limitata dalla larghezza di banda della memoria, quindi una H200 a 4.800 GB/s è circa 2,4× una H100 PCIe a 2.000 per lo stesso modello — un guadagno reale, ed è la voce più costosa di questo elenco.

Misuri prima e dopo — non indovini

```
$ docker exec vllm python -m vllm.entrypoints.openai.api_server --help | head -1
$ docker exec vllm vllm bench serve \
    --model casperhansen/llama-3.3-70b-instruct-awq \
    --num-prompts 200 --request-rate 8

# And watch the card while it runs: if utilisation sits below 90%,
# the bottleneck is your client, not the GPU.
$ nvidia-smi dmon -s um
```

## Mantenerlo attivo

Tre cose che vale la pena fare il primo giorno, perché scoprirle tutte e tre il quattordicesimo è fastidioso.

### Politica di riavvio

`--restart unless-stopped` è nel comando sopra. Dopo un riavvio il container torna attivo e i pesi sono già su `/scratch`, quindi è di nuovo operativo in meno di un minuto.

### Osservi la scheda, non il processo

Una GPU caduta dal bus mantiene un container dall’aspetto integro. `nvidia-smi -q -d PERFORMANCE` in un controllo di salute la rileva; un controllo della porta no.

### I pesi non hanno backup

Sono sul suo NVMe locale e da nessun’altra parte. Va bene così — sono riscaricabili. I suoi adapter di fine-tuning non lo sono, quindi li metta al sicuro fuori dalla macchina.

E quando la durata termina, i dischi vengono cancellati entro l’ora, senza periodo di tolleranza. Tutto ciò che è su `/scratch` scompare con essi. È una scelta deliberata — è la stessa garanzia per cui la macchina consegnata non conteneva dati di nessun altro — ma significa che l’ultimo giorno della durata non è il giorno in cui iniziare a copiare i dati altrove.

## Verifichi questo modello su ogni nodo che noleggiamo.

Il configuratore indica quali configurazioni lo contengono su una scheda singola, quali devono suddividerlo, e quanto costa ciascuna.

[Apri il configuratore](https://gpuserver.io/it/configure) [Leggi le guide](https://gpuserver.io/it/guides)

## Altre guide

- [Pratica · 10 min Fine-tuning di un modello da 70B su una scheda QLoRA su una sola GPU da 48 GB: cosa ci sta, quanto costa al mese, e perché il fine-tuning completo richiede una macchina di un altro livello. Leggi la guida](https://gpuserver.io/it/guides/lora-finetune)
- [Pagamento · 8 min Pagare un server in cripto Cosa succede realmente tra il clic su paga e l’ottenimento del root, quale moneta scegliere, e i quattro errori che fanno perdere denaro al primo pagamento. Leggi la guida](https://gpuserver.io/it/guides/pay-in-crypto)
- [Dimensionamento · 9 min Quanta VRAM serve davvero a un modello L’aritmetica dietro «ci sta»: pesi, cache KV, e i due punti dove una regola empirica sbaglia di un fattore tre. Leggi la guida](https://gpuserver.io/it/guides/vram-sizing)

---

Fonte: https://gpuserver.io/it/guides/serve-llama-70b/. Questo file è generato dagli stessi dati del sito web; se una cifra qui differisce da una pagina, la pagina è quella autorevole e questo file è obsoleto — la fonte canonica è https://gpuserver.io/.