Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 5: Mistral-Modelle auf einer Linux-VM

Ziel: Ein Mistral-Modell auf llm-vm gehä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:3b

Erwartet:

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: 262144 ist 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-80

Erwartet (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 ps

Erwartet (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 4

Erwartet:

{"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 Restart

Erwartet (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_MODELS ist leer, also neu ziehen. ollama pull ist nur ein Client: der Server (User ollama) schreibt die Dateien.
  • MemoryMax lässt den OOM-Killer Ollama treffen statt sshd (Tag 1); Restart=always holt den Dienst zurück.
  • PrivateDevices=yes blendet /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/version

Erwartet (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-gateway

Auf 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-smi im Health-Check, kein PrivateDevices.
  • Kein Internet beim Kunden: Modelle und Images vorab spiegeln (Tag 14), HF_HUB_OFFLINE=1 fü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 .bashrc oder Shell-History.