Praxis-Guide · 11 Min. Lesezeit

# Llama 3.3 70B auf einem Knoten bereitstellen.

Von einer vor fünf Minuten gelieferten Maschine bis zum antwortenden OpenAI-kompatiblen Endpunkt – mit den zwei Flags, die still und leise Ihren Durchsatz halbieren, und dem einen, der Sie kompromittiert.

Die kurze Antwort

- **Benötigter Speicher:** 43 GB bei 4-Bit, 82 GB bei FP8, 164 GB bei BF16 — alle bei 8k Kontext
- **Einfachste Maschine:** Eine 80-GB-Karte. Kein Sharding, kein Interconnect, keine Synchronisierung
- **Zeit bis zum ersten Token:** Unter fünfzehn Minuten ab Lieferung, größtenteils Download der Gewichte
- **Der eine Fehler:** Port 8000 auf einer öffentlichen Adresse veröffentlichen. Er hat keine Authentifizierung

## Was Sie benötigen

70 Milliarden Parameter. Bei 4-Bit sind das 35 GB Gewichte; der KV-Cache addiert bei 8k Kontext 2.5 GB für eine einzelne Anfrage, dazu kommt ein Laufzeit-Overhead von etwa 15 %. Alles Weitere folgt aus diesen drei Zahlen – der [Guide zur VRAM-Dimensionierung](https://gpuserver.io/de/guides/vram-sizing) zeigt, woher sie stammen.

**Benötigter Speicher für Llama 3.3 70B, nach Präzision und Kontext**

| Präzision | Gewichte | Gesamt bei 8k | Gesamt bei 32k | Gesamt bei 128k |
|---|---|---|---|---|
| BF16 / FP16 Referenzqualität | 140 GB | 164 GB | 173 GB | 207 GB |
| FP8 Nahe am Referenzdesign, Hopper und Blackwell | 70 GB | 82 GB | 86 GB | 103 GB |
| 4-bit (AWQ, GPTQ) Kleinste Gewichte, Cache bleibt FP16 | 35 GB | 43 GB | 52 GB | 86 GB |

Beachten Sie die 4-Bit-Zeile bei 128k: Die Gewichte schrumpfen auf 35 GB, aber der Cache schrumpft überhaupt nicht, weil AWQ und GPTQ nur die Gewichte quantisieren. Diese eine Tatsache entscheidet den größten Teil der Maschinenwahl weiter unten.

## Wahl des Knotens

Die günstigsten Maschinen in unserem Katalog, die dieses Modell auf einer *einzigen* Karte halten – die Konfiguration, die Sie wollen, wenn Sie sie haben können: Kein Sharding bedeutet keine Synchronisierung und ein Problem weniger beim Debuggen.

**Knoten, die Llama 3.3 70B auf einer Karte halten**

| Knoten | Präzision, die passt | Kartenspeicher | Geschätzte tok/s | Pro Monat |
|---|---|---|---|---|
| [NVIDIA RTX A6000](https://gpuserver.io/de/gpu/rtx-a6000) PCIe 5.0 · 768 GB/s | 4-bit (AWQ, GPTQ) | 48 GB | ~10 | $286/Monat |
| [2 × NVIDIA RTX A6000](https://gpuserver.io/de/gpu/rtx-a6000) PCIe 5.0 ×16 · 768 GB/s | 4-bit (AWQ, GPTQ) | 48 GB | ~10 | $597/Monat |
| [NVIDIA L40S](https://gpuserver.io/de/gpu/l40s) PCIe 5.0 · 864 GB/s | 4-bit (AWQ, GPTQ) | 48 GB | ~11 | $714/Monat |
| [NVIDIA A100 PCIe](https://gpuserver.io/de/gpu/a100-80gb) PCIe 5.0 · 1,935 GB/s | 4-bit (AWQ, GPTQ) | 80 GB | ~25 | $1,091/Monat |

Der Durchsatz bezieht sich auf Generierung in einem einzelnen Stream, begrenzt durch die Speicherbandbreite, und ist bewusst konservativ angesetzt. Mit kontinuierlichem Batching ist die *Summe* über gleichzeitige Anfragen um ein Vielfaches höher – genau das ist der Sinn von vLLM.

## Zehn Minuten Einrichtung

Nichts hiervon ist spezifisch für uns, außer der Adresse. Docker, das NVIDIA Container Toolkit und ein funktionierender Treiber-Stack sind bereits auf der Maschine vorhanden.

Maschine bestätigen, dann den Gewichten einen Platz geben

```
$ 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
```

## Server starten

Ein Container. Der erste Lauf lädt rund 40 GB quantisierte Gewichte herunter, was an einem 1 Gbit/s-Port ein paar Minuten dauert; jeder Neustart danach ist eine Sache von Sekunden.

vLLM, einzelne Karte, 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
```

Erste Anfrage

```
$ 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}'
```

## Die Flags, auf die es ankommt

--max-model-len Auf den Kontext setzen, den Sie bedienen vLLM reserviert KV-Cache für das deklarierte Maximum. Wird 131072 deklariert, obwohl 8192 bedient werden, verschenkt das die sechzehnfache Menge des benötigten Speichers, und das Symptom ist „nicht genug Nebenläufigkeit“, nicht ein Fehler.

--gpu-memory-utilization 0.90 to 0.95 Der Anteil der Karte, den vLLM beanspruchen darf. Alles, was nicht beansprucht wird, ist verschwendet; wird der Standardwert 0.90 auf einer dedizierten Maschine belassen, kostet das echte Nebenläufigkeit. Gehen Sie nicht über 0.95 hinaus.

--ipc=host Erforderlich, nicht optional Ohne das ist der Shared Memory des Containers auf 64 MB begrenzt. Bei einer einzelnen Karte kommt man damit vielleicht durch; bei einem geshardeten Modell hängt sich NCCL ohne brauchbare Fehlermeldung auf.

--tensor-parallel-size Nur wenn das Modell nicht passt Ein Modell zu sharden, das auf eine Karte passt, macht es *langsamer*. Siehe den [Interconnect-Guide](https://gpuserver.io/de/guides/nvlink-vs-pcie) – das ist der mit Abstand häufigste Weg, wie ein teurer Knoten schlechter abschneidet als ein günstiger.

--kv-cache-dtype fp8 Halbiert Ihren Cache Auf Hopper und Blackwell. Verdoppelt den Kontext oder die Nebenläufigkeit, die Sie halten können, bei einem Qualitätsverlust, der meist nicht messbar ist. Der einfachste Gewinn auf dieser Liste.

--max-num-seqs Auf die tatsächliche Nebenläufigkeit begrenzen Wird er auf einer Maschine, die acht Nutzer bedient, bei 256 belassen, plant vLLM für 256 und nimmt Anfragen an, die es nicht halten kann – das zeigt sich als Latenzspitzen, nicht als Ablehnungen.

## Nicht öffentlich zugänglich machen

**Die OpenAI-kompatible API hat standardmäßig keine Authentifizierung.** An `0.0.0.0` auf einer öffentlichen Adresse gebunden, ist es ein offener Inferenzserver, und Scanner finden solche innerhalb von Stunden. Beachten Sie das `-p 127.0.0.1:8000:8000` im Befehl oben – diese führende Adresse hält ihn vom Internet fern, und sie ist das einzelne Zeichen, das beim Kopieren eines Befehls von anderswo am häufigsten verloren geht.

Erreichen Sie ihn von Ihrer eigenen Maschine über einen SSH-Tunnel – kein geöffneter Port, kein Zertifikat zu verwalten, nichts, was falsch konfiguriert werden kann:

Von Ihrem 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.
```

Muss er wirklich öffentlich sein, schalten Sie einen Reverse-Proxy mit TLS und einem API-Schlüssel davor und beschränken Sie zusätzlich die Quelladressen in der Firewall. Die [Dokumentation](https://gpuserver.io/de/docs#firewall) enthält ein minimales Regelwerk. Doppelte Absicherung ist die richtige Haltung für einen Endpunkt, der jedem antwortet, der anfragt.

## Den Durchsatz steigern

In der Reihenfolge, in der es sich zu versuchen lohnt. Die ersten beiden sind kostenlos und bringen meist den größten Gewinn.

1. **Setzen Sie `--max-model-len` auf Ihren tatsächlichen Kontext herab.** Fast immer der größte einzelne Gewinn, und er kostet nichts, was Sie genutzt haben.
2. **Erhöhen Sie `--gpu-memory-utilization` auf 0.95.** Dies ist eine dedizierte Maschine; es gibt nichts anderes auf der Karte, für das Sie Platz lassen müssten.
3. **Aktivieren Sie den FP8-KV-Cache**, falls die Karte ihn unterstützt. Verdoppelt die Menge, die Sie vorhalten können.
4. **Batchen Sie auf der Client-Seite.** Kontinuierliches Batching hilft nur, wenn Anfragen gleichzeitig eintreffen. Einzeln nacheinander eintreffende Anfragen lassen den Großteil der Karte ungenutzt, unabhängig davon, was Sie konfigurieren.
5. **Ziehen Sie erst dann, und wirklich erst dann, eine schnellere Karte in Betracht.** Die Generierung wird durch die Speicherbandbreite begrenzt, daher ist eine H200 mit 4.800 GB/s beim gleichen Modell etwa 2,4× so schnell wie eine H100 PCIe mit 2.000 – ein echter Gewinn, und der teuerste Posten auf dieser Liste.

Vorher und nachher messen – nicht raten

```
$ 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
```

## Am Laufen halten

Drei Dinge, die sich am ersten Tag lohnen, denn alle drei sind am vierzehnten Tag ärgerlich zu entdecken.

### Neustartrichtlinie

`--restart unless-stopped` steht im Befehl oben. Nach einem Neustart kehrt der Container zurück, und die Gewichte liegen bereits auf `/scratch`, sodass er in unter einer Minute läuft.

### Die Karte beobachten, nicht den Prozess

Eine GPU, die vom Bus abgefallen ist, hinterlässt einen Container, der gesund aussieht. `nvidia-smi -q -d PERFORMANCE` in einem Health-Check erkennt das; eine reine Portprüfung nicht.

### Gewichte werden nicht gesichert

Sie liegen auf Ihrer lokalen NVMe und sonst nirgends. Das ist in Ordnung – sie lassen sich erneut herunterladen. Ihre gefinetunten Adapter dagegen nicht, also bewahren Sie diese woanders auf, außerhalb der Maschine.

Und wenn die Laufzeit endet, werden die Festplatten innerhalb einer Stunde ohne Kulanzfrist gelöscht. Alles auf `/scratch` geht damit verloren. Das ist Absicht – dasselbe Versprechen garantiert, dass die Maschine, die Sie erhalten haben, frei von fremden Daten war –, aber es bedeutet, dass der letzte Tag einer Laufzeit nicht der richtige Zeitpunkt ist, um mit dem Kopieren zu beginnen.

## Vergleichen Sie dieses Modell mit jedem Knoten, den wir vermieten.

Der Konfigurator zeigt, welche Konfigurationen es auf einer einzigen Karte halten, welche es aufteilen müssen, und was jede davon kostet.

[Konfigurator öffnen](https://gpuserver.io/de/configure) [Guides lesen](https://gpuserver.io/de/guides)

## Weitere Guides

- [Praxis · 10 Min. Fine-Tuning eines 70B-Modells auf einer Karte QLoRA auf einer einzelnen 48-GB-GPU: was passt, was ein Monat kostet, und warum vollständiges Fine-Tuning eine andere Größenordnung an Maschine verlangt. Guide lesen](https://gpuserver.io/de/guides/lora-finetune)
- [Zahlung · 8 Min. Einen Server mit Krypto bezahlen Was zwischen dem Klick auf Zahlen und dem Erhalt von Root passiert, welchen Coin Sie wählen sollten, und die vier Fehler, die bei der ersten Zahlung Geld kosten. Guide lesen](https://gpuserver.io/de/guides/pay-in-crypto)
- [Dimensionierung · 9 Min. Wie viel VRAM ein Modell tatsächlich braucht Die Rechnung hinter der Frage „Passt es?": Gewichte, KV-Cache und die zwei Stellen, an denen eine Faustregel um den Faktor drei danebenliegt. Guide lesen](https://gpuserver.io/de/guides/vram-sizing)

---

Quelle: https://gpuserver.io/de/guides/serve-llama-70b/. Diese Datei wird aus denselben Daten wie die Website erzeugt; weicht eine Zahl hier von einer Seite ab, ist die Seite maßgeblich und diese Datei veraltet — die kanonische Quelle ist https://gpuserver.io/.