Tag 5: Mistral-Modelle auf einer Linux-VM
Ziel: Ein Mistral-Modell auf
llm-vmgehärtet betreiben, messen, dimensionieren und gegen die Mistral-API abgrenzen · Dauer: ca. 150 min · Voraussetzung: Tag 4
Briefing
- Ollama = llama.cpp plus Modellverwaltung und API. Ideal für CPU-VMs und Edge-Kunden.
- vLLM = Durchsatz-Server für GPUs (PagedAttention, Continuous Batching). Standard in Produktion.
- Alle sprechen die OpenAI-kompatible API
(
/v1/chat/completions) – wie La Plateforme. - Kennzahlen: TTFT (Time to First Token), Tokens/s pro Anfrage, Durchsatz bei Parallelität.
- Speicher = Gewichte (Parameter × Bytes/Gewicht) + KV-Cache (Kontext × Parallelität).
Laptop --ssh -L 11434--> llm-vm: ollama 127.0.0.1:11434 <-- llm-gateway :8080 (Tag 4)
|
/var/lib/ollama/models (GGUF)
Tipp: Die echten Messwerte in diesem Kapitel stammen von einem Laptop (Apple Silicon, Ollama 0.35.1). Auf der CPU-VM sind Tokens/s deutlich niedriger, Speicherwerte bleiben gleich.
Drill 1: Ollama installieren und Modell ziehen
Auf der VM (multipass shell llm-vm):
curl -fsSL https://ollama.com/install.sh | OLLAMA_VERSION=0.40.2 sh
ollama -v
ss -ltnp | grep 11434
systemctl cat ollama | grep -E 'ExecStart|User|Restart'
journalctl -u ollama -n 20 --no-pager | grep -E 'Listening|inference compute'Erwartet (gekürzt, kann je nach Version abweichen):
>>> Creating ollama user...
>>> Creating ollama systemd service...
ollama version is 0.40.2
LISTEN 0 4096 127.0.0.1:11434 0.0.0.0:* users:(("ollama",pid=2412,fd=3))
ExecStart=/usr/local/bin/ollama serve
User=ollama
Restart=always
... msg="Listening on 127.0.0.1:11434 (version 0.40.2)"
... msg="inference compute" id=cpu library=cpu ... total="7.7 GiB"
Warum? Das Skript legt den Systemuser ollama (Home
/usr/share/ollama) und
/etc/systemd/system/ollama.service an.
OLLAMA_VERSION pinnt die Version – beim Kunden nie
„latest”.
Für 8 GB RAM ohne GPU: ministral-3:3b (Q4_K_M, 3,0 GB).
Mit 24-GB-GPU: ministral-3:14b (9,1 GB) oder
mistral-small3.2 (24B).
ollama pull ministral-3:3b
ollama list
ollama show ministral-3:3bErwartet:
NAME ID SIZE MODIFIED
ministral-3:3b f04aa1c738f6 3.0 GB Less than a second ago
Model
architecture mistral3
parameters 3.8B
context length 262144
quantization Q4_K_M
Capabilities
completion
vision
tools
License
Apache License
Achtung:
262144ist das Maximum des Modells. Ollama reserviert standardmäßig nur 4096 Token (OLLAMA_CONTEXT_LENGTH), sonst würde der KV-Cache die VM sprengen (Drill 5).
Fortschritt speichern? Kostenlos registrieren
Drill 2: Native API vs. OpenAI-kompatible API
Native API (/api/*) mit Timing-Feldern in
Nanosekunden:
curl -s http://127.0.0.1:11434/api/generate -d '{
"model": "ministral-3:3b",
"prompt": "Was ist Kubernetes? Antworte in einem Satz.",
"stream": false
}' | jq '{response, load_duration, prompt_eval_count, eval_count, eval_duration}'Erwartet (Werte variieren):
{
"response": "Kubernetes ist ein **Open-Source-Container-Orchestrierungssystem**, ...",
"load_duration": 6174951125,
"prompt_eval_count": 564,
"eval_count": 60,
"eval_duration": 3268151000
}
Warum 564 Prompt-Token für einen Satz? Das Chat-Template von
Ministral 3 setzt einen Standard-Systemprompt ein, wenn du keinen
schickst (ollama show ministral-3:3b --template).
load_duration 6 s = Kaltstart beim ersten Aufruf.
OpenAI-kompatibel (/v1/*) – das spricht dein Gateway und
jeder OpenAI-/Mistral-Client:
curl -s http://127.0.0.1:11434/v1/models | jq -r '.data[].id'
curl -s http://127.0.0.1:11434/v1/chat/completions \
-H 'Content-Type: application/json' -d '{
"model": "ministral-3:3b", "temperature": 0.1,
"messages": [{"role": "user", "content": "Nenne drei Linux-Signale. Nur Namen."}]
}' | jq -c '.choices[0].message.content, .usage'
curl -sN http://127.0.0.1:11434/v1/chat/completions -d '{"model": "ministral-3:3b",
"stream": true, "messages": [{"role": "user", "content": "Sag hallo."}]}' \
| head -1 | cut -c1-80Erwartet (gekürzt):
ministral-3:3b
"- **SIGHUP**\n- **SIGTERM**\n- **SIGINT**"
{"prompt_tokens":565,"prompt_tokens_details":{"cached_tokens":551},...}
data: {"id":"chatcmpl-967","object":"chat.completion.chunk","created":1791564058
Warum? /v1 streamt Server-Sent Events
(data: ...), /api/chat dagegen NDJSON.
cached_tokens zeigt Prefix-Caching: der gleiche
Systemprompt wird nicht neu berechnet. curl -N schaltet den
Puffer ab – ein Proxy ohne Flush (Tag 4) macht aus Streaming wieder
„alles am Ende”.
Fortschritt speichern? Kostenlos registrieren
Drill 3: TTFT und Tokens/s messen
mkdir -p ~/sre-lab/tag05 && cd ~/sre-lab/tag05
cat > bench.sh <<'EOF'
#!/usr/bin/env bash
# bench.sh <modell> [host] – TTFT und Tokens/s einer gestreamten Anfrage
set -euo pipefail
m=${1:?Modell}; h=${2:-http://127.0.0.1:11434}
body=$(jq -nc --arg m "$m" '{model:$m, stream:true, messages:[{role:"user",
content:"Erkläre in 5 Sätzen, was ein Load Balancer tut."}]}')
out=$(curl -sN -w '\n%{time_starttransfer}' "$h/api/chat" -d "$body")
ttft=$(tail -n1 <<<"$out")
grep '"done":true' <<<"$out" | jq -r --arg t "$ttft" '
"ttft_s=\($t) prompt_tok=\(.prompt_eval_count) gen_tok=\(.eval_count) " +
"tok_s=\(.eval_count / .eval_duration * 1e9 | . * 10 | floor / 10)"'
EOF
chmod +x bench.sh
./bench.sh ministral-3:3b
time (seq 4 | xargs -P4 -I{} ./bench.sh ministral-3:3b)Erwartet (Laptop-Werte, variieren):
ttft_s=0.084185 prompt_tok=569 gen_tok=165 tok_s=19.8
ttft_s=0.084236 prompt_tok=569 gen_tok=171 tok_s=19.6
ttft_s=8.841711 prompt_tok=569 gen_tok=182 tok_s=19.3
ttft_s=18.333233 prompt_tok=569 gen_tok=155 tok_s=19.4
ttft_s=26.369946 prompt_tok=569 gen_tok=176 tok_s=19.8
real 35.41s
Warum? Bei OLLAMA_NUM_PARALLEL=1 werden Anfragen
eingereiht: Tokens/s pro Anfrage bleibt gleich, TTFT
wächst linear mit der Warteschlange. Genau das meldet der Kunde als „das
Modell hängt”. NUM_PARALLEL=2 (Drill 6) halbiert die
Wartezeit – und verdoppelt den KV-Cache.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Modelfile – Systemprompt, Temperatur, Kontext
cat > Modelfile <<'EOF'
FROM ministral-3:3b
SYSTEM """Du bist der Support-Assistent der ACME GmbH. Antworte knapp auf Deutsch.
Wenn du etwas nicht weißt, sag es."""
PARAMETER temperature 0.1
PARAMETER num_ctx 8192
EOF
ollama create acme-assist -f Modelfile
curl -s http://127.0.0.1:11434/api/chat -d '{"model": "acme-assist",
"stream": false, "messages": [{"role": "user", "content": "Wer bist du?"}]}' \
| jq -r .message.content
ollama psErwartet (Text variiert):
success
Ich bin dein virtueller Support-Assistent für die **ACME GmbH** und helfe dir bei
Fragen zu Produkten, Services oder technischen Problemen. ...
NAME ID SIZE PROCESSOR CONTEXT UNTIL
acme-assist:latest 9179293f70c5 3.2 GB 100% GPU 8192 4 minutes from now
Warum? ollama create kopiert keine Gewichte, nur eine
neue Manifest-Schicht – kein Plattenplatz extra. Im RAM schon: mit
num_ctx 8192 belegt das Modell 3,2 GB statt 2,7 GB bei
4096. Auf der VM steht dort 100% CPU.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Sizing – passt das Modell auf die Maschine?
GGUF ist das Dateiformat von llama.cpp/Ollama: Gewichte, Tokenizer
und Metadaten in einer Datei. Quantisierung speichert Gewichte mit
weniger Bits (Q8_0 ≈ 8,5 Bit, Q4_K_M ≈ 4,8 Bit statt 16), meist mit
wenig Qualitätsverlust. K-Quants (_K_M) speichern wichtige
Tensoren genauer als den Rest.
cat > sizing.py <<'EOF'
"""Grobe Speicherabschätzung: Gewichte + KV-Cache (GiB)."""
import sys
BYTES = {"q4_k_m": 0.6, "q8_0": 1.06, "fp16": 2.0}
def gib(n: float) -> float:
return n / 2**30
def main() -> None:
params_b, quant, layers, kv_heads, head_dim, ctx, par = sys.argv[1:8]
weights = float(params_b) * 1e9 * BYTES[quant]
kv_tok = 2 * int(layers) * int(kv_heads) * int(head_dim) * 2 # K+V, fp16
kv = kv_tok * int(ctx) * int(par)
print(f"Gewichte {gib(weights):6.1f} GiB ({quant})")
per_tok = f"{kv_tok // 1024} KiB/Token × {ctx} × {par}"
print(f"KV-Cache {gib(kv):6.1f} GiB ({per_tok})")
print(f"Summe {gib(weights + kv):6.1f} GiB + ~10 % Overhead")
if __name__ == "__main__":
main()
EOF
curl -s http://127.0.0.1:11434/api/show -d '{"model":"ministral-3:3b"}' \
| jq -c '.model_info | {params: .["general.parameter_count"],
layers: .["mistral3.block_count"],
kv_heads: .["mistral3.attention.head_count_kv"],
head_dim: .["mistral3.attention.key_length"]}'
python3 sizing.py 3.85 q4_k_m 26 8 128 4096 1
python3 sizing.py 24 fp16 40 8 128 32768 4Erwartet:
{"params":3849090048,"layers":26,"kv_heads":8,"head_dim":128}
Gewichte 2.2 GiB (q4_k_m)
KV-Cache 0.4 GiB (104 KiB/Token × 4096 × 1)
Summe 2.6 GiB + ~10 % Overhead
Gewichte 44.7 GiB (fp16)
KV-Cache 20.0 GiB (160 KiB/Token × 32768 × 4)
Summe 64.7 GiB + ~10 % Overhead
Die erste Rechnung trifft ollama ps (2,7 GB). Die zweite
ist Mistral Small (24B, 40 Layer) in BF16 mit 32k Kontext und 4
parallelen Sequenzen: zu groß für eine 48-GB-GPU, passend für eine H100
80 GB – oder in FP8 für eine L40S.
| Modell (Ollama-Tag) | Q4_K_M | Q8_0 | FP16/BF16 |
|---|---|---|---|
| ministral-3:3b | 3,0 GB | 4,5 GB | 7,7 GB |
| ministral-3:8b | 6,0 GB | 9,9 GB | 18 GB |
| ministral-3:14b | 9,1 GB | 15 GB | 28 GB |
| Mistral Small 24B (berechnet) | ≈ 14 GB | ≈ 25 GB | ≈ 48 GB |
Fortschritt speichern? Kostenlos registrieren
Drill 6: systemd härten – nur localhost, Limits, Sandbox
sudo install -d -o ollama -g ollama -m 750 /var/lib/ollama /var/lib/ollama/models
sudo mkdir -p /etc/systemd/system/ollama.service.d
sudo tee /etc/systemd/system/ollama.service.d/override.conf >/dev/null <<'EOF'
[Service]
Environment="OLLAMA_HOST=127.0.0.1:11434"
Environment="OLLAMA_MODELS=/var/lib/ollama/models"
Environment="OLLAMA_KEEP_ALIVE=30m"
Environment="OLLAMA_NUM_PARALLEL=2"
Environment="OLLAMA_CONTEXT_LENGTH=4096"
MemoryMax=6G
CPUQuota=300%
LimitNOFILE=65536
NoNewPrivileges=yes
ProtectSystem=strict
ProtectHome=yes
ReadWritePaths=/var/lib/ollama /usr/share/ollama
PrivateTmp=yes
PrivateDevices=yes
ProtectKernelTunables=yes
ProtectKernelModules=yes
ProtectControlGroups=yes
RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX
LockPersonality=yes
CapabilityBoundingSet=
EOF
sudo systemd-analyze verify /etc/systemd/system/ollama.service && echo "verify ok"
sudo systemd-analyze security ollama | tail -1
sudo systemctl daemon-reload && sudo systemctl restart ollama
ollama pull ministral-3:3b
systemctl show ollama -p MemoryMax -p RestartErwartet (verify/security live in einem
Ubuntu-24.04-Container geprüft; Rest gekürzt, kann je nach Version
abweichen):
verify ok
→ Overall exposure level for ollama.service: 4.5 OK :-)
success
MemoryMax=6442450944
Restart=always
Ohne Override meldet systemd-analyze security
9.0 UNSAFE.
- Das neue
OLLAMA_MODELSist leer, also neu ziehen.ollama pullist nur ein Client: der Server (Userollama) schreibt die Dateien. MemoryMaxlässt den OOM-Killer Ollama treffen statt sshd (Tag 1);Restart=alwaysholt den Dienst zurück.PrivateDevices=yesblendet/dev/nvidia*aus – auf GPU-VMs weglassen.OLLAMA_HOST=127.0.0.1: kein öffentlicher Port. Zugriff nur per SSH-Tunnel oder Gateway.
Vom Laptop per SSH-Tunnel (lokaler Port 21434, falls dort schon Ollama läuft):
VM_IP=$(multipass info llm-vm --format json | jq -r '.info["llm-vm"].ipv4[0]')
ssh -f -N -L 21434:127.0.0.1:11434 ubuntu@"$VM_IP"
curl -s http://127.0.0.1:21434/api/versionErwartet (gekürzt, kann je nach Version abweichen):
{"version":"0.40.2"}
Fortschritt speichern? Kostenlos registrieren
Drill 7: Alternativen – llama.cpp und vLLM auf GPU
llama.cpp ohne Ollama-Schicht (auf der VM, Docker
per sudo apt-get install -y docker.io):
sudo docker run -d --name llama -p 127.0.0.1:8082:8082 \
-v /var/lib/llama-cache:/root/.cache/llama.cpp \
ghcr.io/ggml-org/llama.cpp:server \
-hf mistralai/Ministral-3-3B-Instruct-2512-GGUF:Q4_K_M \
--host 0.0.0.0 --port 8082 -c 4096 -np 2 --jinja --metrics
curl -s http://127.0.0.1:8082/health
curl -s http://127.0.0.1:8082/metrics | grep -m2 '^llamacpp:'Erwartet (gekürzt, kann je nach Version abweichen):
{"status":"ok"}
llamacpp:prompt_tokens_total 0
llamacpp:tokens_predicted_total 0
Warum? -np 2 = zwei Slots (Parallelität),
--metrics liefert Prometheus-Metriken, die Ollama nicht hat
(Tag 8). Die offizielle GGUF von Mistral hat 2,15 GB (ohne
Vision-Encoder).
vLLM auf einer GPU-VM (z. B. 1× L4 mit 24 GB). Erst Treiber prüfen, dann starten:
nvidia-smi --query-gpu=name,driver_version,memory.total --format=csv
export HF_TOKEN=... # nur für gated Repos; nie ins Skript schreiben
docker run -d --name vllm --gpus all --ipc=host \
-p 127.0.0.1:8000:8000 \
-v ~/.cache/huggingface:/root/.cache/huggingface \
-e HF_TOKEN \
vllm/vllm-openai:v0.31.0 \
--model mistralai/Ministral-3-8B-Instruct-2512 \
--tokenizer-mode mistral --config-format mistral --load-format mistral \
--max-model-len 32768 --gpu-memory-utilization 0.90 \
--enable-auto-tool-choice --tool-call-parser mistral \
--served-model-name ministral-3-8b
curl -s http://127.0.0.1:8000/v1/models | jq -r '.data[].id'Erwartet (gekürzt, kann je nach Version abweichen):
name, driver_version, memory.total [MiB]
NVIDIA L4, 580.95.05, 23034 MiB
ministral-3-8b
Warum? Die drei mistral-Flags laden Tokenizer
(mistral_common), Config und
consolidated.safetensors im Mistral-Originalformat – so
empfiehlt es Mistral für Self-Deployment.
--gpu-memory-utilization gibt vLLM 90 % VRAM für Gewichte
plus KV-Cache-Pool; --max-model-len begrenzt den Kontext,
sonst bricht der Start ab, wenn 256k nicht in den Pool passen. Ohne
--enable-auto-tool-choice kein Function Calling.
Fortschritt speichern? Kostenlos registrieren
Drill 8: Mistral-API, Function Calling, JSON-Modus
Dieselben Requests laufen gegen Ollama (live getestet) und gegen La
Plateforme (https://api.mistral.ai/v1) – nur URL, Key und
Modell ändern sich.
export LLM_URL=http://127.0.0.1:11434/v1 LLM_MODEL=ministral-3:3b
# La Plateforme: LLM_URL=https://api.mistral.ai/v1 LLM_MODEL=mistral-small-latest
# und MISTRAL_API_KEY aus dem Passwortmanager exportieren – nie in Dateien
auth=(-H "Authorization: Bearer ${MISTRAL_API_KEY:-unused}")
cat > tools.json <<EOF
{
"model": "$LLM_MODEL",
"temperature": 0,
"tool_choice": "auto",
"messages": [{"role": "user",
"content": "Wie ist der Status von Pod llm-gateway-7f9 im Namespace llm-system?"}],
"tools": [{"type": "function", "function": {
"name": "get_pod_status",
"description": "Liefert den Status eines Kubernetes-Pods",
"parameters": {"type": "object",
"properties": {"namespace": {"type": "string"}, "pod": {"type": "string"}},
"required": ["namespace", "pod"]}}}]
}
EOF
curl -s "$LLM_URL/chat/completions" "${auth[@]}" \
-H 'Content-Type: application/json' -d @tools.json \
| tee resp.json | jq -c '.choices[0].finish_reason, .choices[0].message.tool_calls[0]'Erwartet:
"tool_calls"
{"id":"call_j3z2aqgy","index":0,"type":"function","function":{"name":"get_pod_status",
"arguments":"{\"namespace\":\"llm-system\",\"pod\":\"llm-gateway-7f9\"}"}}
Das Modell führt nichts aus – es liefert Name und Argumente. Dein
Code ruft die Funktion auf und schickt das Ergebnis als
role: tool zurück:
jq --slurpfile r resp.json '.messages += [
$r[0].choices[0].message,
{"role": "tool", "name": "get_pod_status",
"tool_call_id": $r[0].choices[0].message.tool_calls[0].id,
"content": "{\"phase\":\"Running\",\"restarts\":3,\"lastState\":\"OOMKilled\"}"}
]' tools.json > tools2.json
curl -s "$LLM_URL/chat/completions" "${auth[@]}" \
-H 'Content-Type: application/json' -d @tools2.json \
| jq -r '.choices[0].message.content'Erwartet (Text variiert):
Der Pod **`llm-gateway-7f9`** im Namespace **`llm-system`** befindet sich aktuell im
**`Running`-Status**, hat jedoch **3 Wiederstarts** aufgrund eines **OOM-Kills** ...
JSON-Modus garantiert gültiges JSON – nicht richtige Fakten:
curl -s "$LLM_URL/chat/completions" "${auth[@]}" \
-H 'Content-Type: application/json' -d "{
\"model\": \"$LLM_MODEL\", \"temperature\": 0,
\"response_format\": {\"type\": \"json_object\"},
\"messages\": [{\"role\": \"user\", \"content\":
\"Gib Name und Port des Ollama-Dienstes als JSON mit name und port zurück.\"}]
}" | jq -r '.choices[0].message.content' | jq -c .Erwartet (live, variiert zwischen Läufen):
{"ollama_service":{"name":"ollama","port":11435}}
Syntaktisch perfekt, Struktur frei erfunden, Port falsch (11434). Für
feste Strukturen response_format mit
json_schema nutzen und im Code validieren. La Plateforme
kennt bei tool_choice zusätzlich "any" (Tool
erzwingen) und "none".
Sicherheit: Lizenz vor jeder Kundenauslieferung prüfen. Ministral 3, Mistral Small 4, Mistral Large 3: Apache 2.0. Mistral Medium 3.5: Modified MIT (Einschränkung für sehr umsatzstarke Firmen). Codestral und Embedding-Modelle: kommerziell (API oder Lizenzvertrag). Ältere Modelle wie Mistral Large 2 standen unter der Mistral Research License. Maßgeblich ist die Model Card.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
Auf der VM:
#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
H=http://127.0.0.1:11434
check "ollama aktiv" "systemctl is-active ollama"
check "nur localhost gebunden" "ss -ltn | grep -q '127.0.0.1:11434' &&
! ss -ltn | grep -qE '(0.0.0.0|\*|\[::\]):11434'"
check "MemoryMax gesetzt" "systemctl show ollama -p MemoryMax | grep -qv infinity"
check "Modelle in /var/lib/ollama" "test -d /var/lib/ollama/models/blobs"
check "ministral-3:3b vorhanden" "curl -sf $H/v1/models | grep -q ministral-3:3b"
check "acme-assist vorhanden" "curl -sf $H/api/tags | grep -q acme-assist"
Q='{"model":"ministral-3:3b","messages":[{"role":"user","content":"hi"}]}'
check "Chat-Completion ok" "curl -sf $H/v1/chat/completions -d '$Q'"Erwartet: sieben Zeilen mit ✔. acme-assist
musst du nach dem Wechsel des Modellverzeichnisses (Drill 6) neu
anlegen.
Challenge
Betreibe das llm-gateway aus Tag 4 als systemd-Dienst
auf der VM vor Ollama: ohne festen User, Mandanten-Keys aus einer Datei
mit Rechten 600, Port 8080.
Hinweis: DynamicUser=yes erzeugt beim
Start einen flüchtigen User; EnvironmentFile= liest systemd
als root, bevor es Rechte abgibt.
Lösung
Auf dem Laptop (Architektur der VM beachten – auf Apple Silicon
arm64):
ARCH=$(multipass exec llm-vm -- dpkg --print-architecture)
cd ~/sre-lab/code/llm-gateway
CGO_ENABLED=0 GOOS=linux GOARCH=$ARCH go build -o llm-gateway-linux .
multipass transfer llm-gateway-linux llm-vm:/home/ubuntu/llm-gatewayAuf der VM:
sudo install -m 755 ~/llm-gateway /usr/local/bin/llm-gateway
sudo install -m 600 /dev/stdin /etc/llm-gateway.env <<'EOF'
LISTEN_ADDR=:8080
UPSTREAM_URL=http://127.0.0.1:11434
TENANT_KEYS=acme:lab-key-acme,globex:lab-key-globex
EOF
sudo tee /etc/systemd/system/llm-gateway.service >/dev/null <<'EOF'
[Unit]
Description=llm-gateway vor Ollama
After=network-online.target ollama.service
Wants=network-online.target
[Service]
ExecStart=/usr/local/bin/llm-gateway
EnvironmentFile=/etc/llm-gateway.env
DynamicUser=yes
Restart=on-failure
MemoryMax=256M
NoNewPrivileges=yes
ProtectSystem=strict
ProtectHome=yes
PrivateTmp=yes
PrivateDevices=yes
CapabilityBoundingSet=
RestrictAddressFamilies=AF_INET AF_INET6
[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload && sudo systemctl enable --now llm-gateway
curl -s -o /dev/null -w '%{http_code}\n' localhost:8080/v1/models
curl -s localhost:8080/v1/chat/completions -H 'Authorization: Bearer lab-key-acme' \
-d '{"model":"ministral-3:3b","messages":[{"role":"user","content":"Nur OK."}]}' \
| jq -r '.choices[0].message.content'
curl -s localhost:8080/metrics | grep '^gateway_tokens_total'Erwartet (Gateway vor Ollama live auf dem Laptop getestet, Unit per
systemd-analyze verify im Container: Exposure
4.8 OK):
401
OK
gateway_tokens_total{tenant="acme",type="completion"} 2
gateway_tokens_total{tenant="acme",type="prompt"} 560
Port 8080 nur für das Gateway-Netz freigeben
(ufw allow from <cidr> to any port 8080), 11434
bleibt zu – automatisiert in der Ansible-Rolle (Tag 12).
Fortschritt speichern? Kostenlos registrieren
Interview-Notiz
- „Wie dimensionierst du einen Modellserver?” – Gewichte = Parameter × Bytes pro Gewicht; KV-Cache = 2 × Layer × KV-Heads × Head-Dim × 2 Byte × Kontext × Parallelität; plus 10–20 % Reserve. 24B BF16, 32k × 4 ≈ 65 GiB → H100 80 GB oder FP8.
- „Das Modell ist langsam” – erst TTFT von Tokens/s trennen: hohe TTFT bei normaler Tokenrate = Warteschlange/Prefill, niedrige Tokenrate = Hardware, Quantisierung, Batching.
- Ollama vs. vLLM: Ollama für CPU, Edge, PoCs; vLLM für GPU-Durchsatz mit Continuous Batching, Metriken und Tensor Parallelism.
- Brücke aus deiner Praxis: „Ein Modellserver ist für mich ein Dienst
wie Vault/OpenBao beim regulierten Kunden: dedizierter Systemuser,
MemoryMax, kein öffentlicher Bind, Zugriff nur über einen Proxy.” - Lizenz ist Architektur: Apache-2.0-Modelle darfst du on-prem ausliefern, kommerzielle nur mit Vertrag.
Enterprise-Notiz
- Versionen pinnen: Ollama/vLLM per Version, Modelle per Digest bzw.
HF-
--revision– sonst ändert ein Re-Pull das Verhalten. - GPU-Hosts: NVIDIA-Treiber und Container Toolkit im Image,
nvidia-smiim Health-Check, keinPrivateDevices. - Kein Internet beim Kunden: Modelle und Images vorab spiegeln (Tag
14),
HF_HUB_OFFLINE=1für vLLM. - Metriken: vLLM und llama.cpp liefern
/metrics; vor Ollama misst das Gateway (Tag 8). - Mistral-API-Keys in einen Secret Store (OpenBao, Tag 13), nicht in
.bashrcoder Shell-History.