Tag 5: Chat mit Open WebUI in kind
Ziel: Open WebUI läuft unter
http://chat.ki.localtest.me, spricht ausschließlich über einen eigenen LiteLLM-Key, hat einen Admin, Benutzer, persistente Daten und Dokumenten-Suche überembed. · Dauer: ca. 75 min · Voraussetzung: Tag 4
Briefing
- Open WebUI (getestet: 0.11.4,
Chart
open-webui/open-webui16.6.0) ist die Chat-Oberfläche für das Team: Benutzer, Rollen, Verläufe, Dokumente (RAG). - Sie bekommt einen Virtual Key von LiteLLM. Budgets und Limits gelten für die ganze Oberfläche; einzelne Personen trennst du ab Tag 13 über SSO und Gruppen.
- Das Chart bringt Ollama, Pipelines und Redis mit – im Lab schaltest du alles ab und nimmst das slim-Image (167 MB statt 1,4 GB komprimiert).
- Daten (SQLite, Uploads, Vektoren) liegen unter
/app/backend/dataauf einem PVC. - Viele Einstellungen sind PersistentConfig: Nach dem ersten Start gilt der Wert in der Datenbank, nicht mehr die Umgebungsvariable.
Browser ── http://chat.ki.localtest.me ──► ingress-nginx
│
ki-chat: open-webui (StatefulSet, PVC 2Gi) ──┘
│ OPENAI_API_BASE_URL + Key "open-webui" │ RAG: embed (384 dim)
▼ ▼
ki-gateway: litellm:4000 ──► ki-models: llamacpp / llamacpp-embed
Drill 1: Ein eigener Key für die Oberfläche
mkdir -p ~/ki-lab/tag05 ~/ki-lab/code/open-webui
M="Authorization: Bearer sk-lab-master-1234"; J="Content-Type: application/json"
GW=http://llm.ki.localtest.me
curl -s $GW/key/generate -H "$M" -H "$J" -d '{
"key_alias": "open-webui",
"models": ["chat-small", "chat-large", "code", "embed"],
"max_budget": 5, "budget_duration": "30d", "rpm_limit": 60}' \
| tee ~/ki-lab/tag05/owui-key.json \
| jq '{key_alias, models, max_budget, rpm_limit, key: (.key[0:6] + "...")}'Erwartet (live gegen lokalen Proxy, Key weicht ab):
{
"key_alias": "open-webui",
"models": [
"chat-small",
"chat-large",
"code",
"embed"
],
"max_budget": 5.0,
"rpm_limit": 60,
"key": "sk-Fq_..."
}
Drei Werte kommen in ein Secret: der LiteLLM-Key, der Schlüssel für Login-Tokens und das Admin-Passwort.
kubectl -n ki-chat create secret generic owui-secrets \
--from-literal=litellm-key="$(jq -r .key ~/ki-lab/tag05/owui-key.json)" \
--from-literal=webui-secret="$(openssl rand -hex 32)" \
--from-literal=admin-password=lab-admin-1234
kubectl -n ki-chat get secret owui-secrets -o json | jq -r '.data | keys[]'
rm ~/ki-lab/tag05/owui-key.jsonErwartet (nicht live in kind getestet):
secret/owui-secrets created
admin-password
litellm-key
webui-secret
Sicherheit:
WEBUI_SECRET_KEYsigniert die Login-Tokens (JWT). Fehlt er, erzeugt Open WebUI einen zufälligen – nach jedem Neustart sind dann alle abgemeldet.lab-admin-1234ist ein Lab-Wert.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Values lesen und rendern
helm repo add open-webui https://helm.openwebui.com/ 2>/dev/null
helm repo update open-webui >/dev/null
helm show chart open-webui/open-webui --version 16.6.0 \
| grep -E '^(name|version|appVersion):'Erwartet:
appVersion: 0.11.4
name: open-webui
version: 16.6.0
Die Lab-Values (auch im Buch-Code unter
open-webui/values-kind.yaml):
cat > ~/ki-lab/code/open-webui/values-kind.yaml <<'EOF'
# Open WebUI im kind-Lab (Tag 5) – Chart open-webui/open-webui 16.6.0
# Modelle ausschließlich über LiteLLM; Secrets vorher anlegen (owui-secrets)
image:
useSlim: true # ghcr.io/open-webui/open-webui:0.11.4-slim
ollama:
enabled: false # kein eigenes Ollama im Chart
pipelines:
enabled: false
websocket:
enabled: false # ein Replica: kein Redis nötig
openaiBaseApiUrl: http://litellm.ki-gateway:4000/v1
openaiApiKeyExistingSecret: owui-secrets
openaiApiKeyExistingSecretKey: litellm-key
persistence:
enabled: true
size: 2Gi
storageClass: standard # SQLite + Uploads + Vektoren unter /app/backend/data
ingress:
enabled: true
class: nginx
host: chat.ki.localtest.me
annotations:
nginx.ingress.kubernetes.io/proxy-body-size: 20m
nginx.ingress.kubernetes.io/proxy-read-timeout: "300"
startupProbe: # erster Start: DB-Migrationen
httpGet: {path: /health, port: http}
periodSeconds: 10
failureThreshold: 30
readinessProbe:
httpGet: {path: /health, port: http}
periodSeconds: 10
livenessProbe:
httpGet: {path: /health, port: http}
periodSeconds: 20
timeoutSeconds: 5
resources:
requests:
cpu: 250m
memory: 768Mi
limits:
memory: 1536Mi
extraEnvVars:
- name: WEBUI_URL
value: http://chat.ki.localtest.me
- name: WEBUI_SECRET_KEY # signiert die Login-Tokens (JWT)
valueFrom:
secretKeyRef: {name: owui-secrets, key: webui-secret}
- name: WEBUI_ADMIN_EMAIL # erster Admin ohne Klick-Registrierung
value: [email protected]
- name: WEBUI_ADMIN_PASSWORD
valueFrom:
secretKeyRef: {name: owui-secrets, key: admin-password}
- name: DEFAULT_USER_ROLE
value: pending
- name: BYPASS_MODEL_ACCESS_CONTROL # Lab: Rechte regelt LiteLLM
value: "true"
- name: ENABLE_EVALUATION_ARENA_MODELS
value: "false"
- name: RAG_EMBEDDING_ENGINE # Embeddings über LiteLLM statt im Pod
value: openai
- name: RAG_EMBEDDING_MODEL
value: embed
- name: RAG_OPENAI_API_BASE_URL
value: http://litellm.ki-gateway:4000/v1
- name: RAG_OPENAI_API_KEY
valueFrom:
secretKeyRef: {name: owui-secrets, key: litellm-key}
- name: ENABLE_VERSION_UPDATE_CHECK
value: "false"
EOF| Key | Warum |
|---|---|
image.useSlim |
ohne eingebautes Embedding-Modell – Embeddings liefert LiteLLM |
openaiApiKeyExistingSecret |
Key nie in values.yaml |
WEBUI_ADMIN_EMAIL/_PASSWORD |
erster Admin beim Start, danach ist die Registrierung zu |
BYPASS_MODEL_ACCESS_CONTROL |
Lab: alle Benutzer sehen alle Modelle (Drill 5) |
RAG_OPENAI_API_BASE_URL |
muss explizit gesetzt sein, sonst ruft RAG
api.openai.com |
cd ~/ki-lab/code/open-webui
helm template open-webui open-webui/open-webui --version 16.6.0 -n ki-chat \
-f values-kind.yaml > ~/ki-lab/tag05/owui.yaml
awk '/^kind:/{k=$2} /^ name:/{print k, $2}' ~/ki-lab/tag05/owui.yaml
grep -m2 'image:' ~/ki-lab/tag05/owui.yaml
kubeconform -strict -summary ~/ki-lab/tag05/owui.yamlErwartet:
ServiceAccount open-webui-sa
PersistentVolumeClaim open-webui
Service open-webui
StatefulSet open-webui
Ingress open-webui
image: ghcr.io/open-webui/open-webui:0.11.4-slim
image: ghcr.io/open-webui/open-webui:0.11.4-slim
Summary: 5 resources found in 1 file - Valid: 5, Invalid: 0, Errors: 0, Skipped: 0
Das erste Image gehört zum Init-Container copy-app-data:
Er kopiert beim Start die Standarddaten aus dem Image auf das leere PVC
(cp -R -n, überschreibt nichts).
Fortschritt speichern? Kostenlos registrieren
Drill 3: Installieren
helm upgrade --install open-webui open-webui/open-webui --version 16.6.0 \
-n ki-chat -f ~/ki-lab/code/open-webui/values-kind.yaml
kubectl -n ki-chat rollout status sts/open-webui --timeout=600s
kubectl -n ki-chat get pod,pvc,ingress
curl -s http://chat.ki.localtest.me/healthErwartet (nicht live in kind getestet, gekürzt):
Release "open-webui" does not exist. Installing it now.
STATUS: deployed
partitioned roll out complete: 1 new pods have been updated...
NAME READY STATUS RESTARTS AGE
pod/open-webui-0 1/1 Running 0 2m
NAME STATUS VOLUME CAPACITY ...
persistentvolumeclaim/open-webui Bound pvc-... 2Gi ...
NAME CLASS HOSTS ...
ingress.networking.k8s.io/open-webui nginx chat.ki.localtest.me ...
{"status":true}
Beim ersten Start legt Open WebUI die Datenbank an und erzeugt den Admin. Im Log:
kubectl -n ki-chat logs open-webui-0 | grep -m2 -i 'admin account' | sed 's/.* - //'Erwartet (live mit pip install open-webui==0.11.4
getestet):
Creating admin account from environment variables: [email protected]
Admin account created successfully: [email protected]
Öffne jetzt http://chat.ki.localtest.me im Browser und
melde dich mit [email protected] / lab-admin-1234
an. Im Modell-Menü stehen die vier LiteLLM-Aliase.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Rauchtest über die API
Alles, was die Oberfläche kann, geht auch per REST. Das Skript meldet sich an, listet Modelle und schickt eine Frage – ideal für CI und den Kontrollpunkt.
cat > ~/ki-lab/code/open-webui/smoke.sh <<'EOF'
#!/usr/bin/env bash
# Rauchtest für Open WebUI: Login, Modelle, eine Chat-Antwort über LiteLLM.
# Aufruf: OWUI=http://chat.ki.localtest.me EMAIL=... PASS=... ./smoke.sh
set -euo pipefail
OWUI=${OWUI:-http://chat.ki.localtest.me}
EMAIL=${EMAIL:[email protected]}
PASS=${PASS:?PASS fehlt}
MODEL=${MODEL:-chat-small}
TOKEN=$(jq -n --arg e "$EMAIL" --arg p "$PASS" '{email: $e, password: $p}' \
| curl -sf "$OWUI/api/v1/auths/signin" -H 'Content-Type: application/json' \
-d @- | jq -r .token)
[ -n "$TOKEN" ] && [ "$TOKEN" != null ] || { echo "✘ Login"; exit 1; }
echo "✔ Login als $EMAIL"
MODELS=$(curl -sf "$OWUI/api/models" -H "Authorization: Bearer $TOKEN" \
| jq -r '[.data[].id] | join(" ")')
echo "✔ Modelle: $MODELS"
ANSWER=$(jq -n --arg m "$MODEL" \
'{model: $m, stream: false,
messages: [{role: "user", content: "Antworte nur mit: OK"}]}' \
| curl -sf "$OWUI/api/chat/completions" -H "Authorization: Bearer $TOKEN" \
-H 'Content-Type: application/json' -d @- \
| jq -r '.choices[0].message.content')
echo "✔ $MODEL antwortet: $ANSWER"
EOF
chmod +x ~/ki-lab/code/open-webui/smoke.sh
PASS=lab-admin-1234 ~/ki-lab/code/open-webui/smoke.shErwartet (live gegen open-webui serve + LiteLLM
getestet):
✔ Login als [email protected]
✔ Modelle: chat-small chat-large code embed
✔ chat-small antwortet: OK
Open WebUI fragt LiteLLM mit dem Key aus owui-secrets –
in LiteLLM tauchen alle Aufrufe unter dem Alias open-webui
auf, egal welcher Mensch gefragt hat.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Benutzer und Rollen
Der Admin legt eine Benutzerin an. Selbstregistrierung ist zu, seit der Admin per Umgebungsvariable entstand.
OWUI=http://chat.ki.localtest.me; J="Content-Type: application/json"
login() { jq -n --arg e "$1" --arg p "$2" '{email: $e, password: $p}' \
| curl -s $OWUI/api/v1/auths/signin -H "$J" -d @- | jq -r .token; }
ADMIN=$(login [email protected] lab-admin-1234)
curl -s $OWUI/api/v1/auths/add -H "Authorization: Bearer $ADMIN" -H "$J" \
-d '{"name":"Anna","email":"[email protected]","password":"lab-anna-1234",
"role":"user"}' | jq -c '{name, email, role}'
curl -s $OWUI/api/v1/auths/signup -H "$J" \
-d '{"name":"Eve","email":"[email protected]","password":"lab-eve-1234"}' \
| jq -r .detail | cut -c1-55Erwartet (live mit open-webui serve getestet):
{"name":"Anna","email":"[email protected]","role":"user"}
You do not have permission to access this resource. Ple
| Rolle | Darf |
|---|---|
pending |
nichts – wartet auf Freigabe (Default für Selbstregistrierte) |
user |
chatten mit freigegebenen Modellen, eigene Dokumente |
admin |
alles: Benutzer, Verbindungen, Einstellungen |
Was sieht Anna? Ohne BYPASS_MODEL_ACCESS_CONTROL liefert
/api/models für normale Benutzer eine leere Liste, und
jeder Chat endet mit Model not found – Modelle sind erst
sichtbar, wenn der Admin sie in Admin-Einstellungen → Modelle
öffentlich macht oder einer Gruppe zuweist.
ANNA=$(login [email protected] lab-anna-1234)
curl -s $OWUI/api/models -H "Authorization: Bearer $ANNA" | jq -r '.data[].id'Erwartet (live getestet, mit
BYPASS_MODEL_ACCESS_CONTROL=true):
chat-small
chat-large
code
embed
Im Lab ist das bequem, weil LiteLLM ohnehin nur freigegebene Aliase durchlässt. Für das Team (Tag 13) regelst du Sichtbarkeit über Gruppen aus Keycloak.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Persistenz und die PersistentConfig-Falle
Pod weg, Daten bleiben – sie liegen auf dem PVC:
kubectl -n ki-chat exec open-webui-0 -- ls /app/backend/data
kubectl -n ki-chat delete pod open-webui-0
kubectl -n ki-chat wait pod/open-webui-0 --for=condition=Ready --timeout=300s
[ -n "$(login [email protected] lab-anna-1234)" ] && echo "Anna existiert noch"Erwartet (Verzeichnis live getestet, Pod-Neustart in kind nicht):
cache
uploads
vector_db
webui.db
pod "open-webui-0" deleted
pod/open-webui-0 condition met
Anna existiert noch
Jetzt die Falle: Ändere eine Einstellung per Umgebungsvariable.
kubectl -n ki-chat set env sts/open-webui DEFAULT_USER_ROLE=user
kubectl -n ki-chat rollout status sts/open-webui --timeout=300s
ADMIN=$(login [email protected] lab-admin-1234)
curl -s $OWUI/api/v1/auths/admin/config -H "Authorization: Bearer $ADMIN" \
| jq -c '{DEFAULT_USER_ROLE, ENABLE_SIGNUP}'Erwartet (live mit open-webui serve getestet):
{"DEFAULT_USER_ROLE":"pending","ENABLE_SIGNUP":false}
Warum? DEFAULT_USER_ROLE ist eine PersistentConfig: Beim
ersten Start wandert der Wert in die Tabelle config, danach
gewinnt die Datenbank. Ändern kannst du solche Werte in der Admin-UI,
per API (POST /api/v1/auths/admin/config) oder global mit
ENABLE_PERSISTENT_CONFIG=false – dann gilt wieder nur die
Umgebung. Zurück zum Stand aus Git:
helm upgrade open-webui open-webui/open-webui --version 16.6.0 -n ki-chat \
-f ~/ki-lab/code/open-webui/values-kind.yamlFortschritt speichern? Kostenlos registrieren
Drill 7: Dokumente fragen (RAG über LiteLLM)
Beim Upload zerlegt Open WebUI die Datei, holt Embeddings über
embed und speichert sie in der eingebauten Vektor-DB auf
dem PVC.
printf 'Bereitschaft im KI-Lab: Montag bis Freitag hat Team Plattform Dienst.%s\n' \
' Notfallnummer 4711.' > ~/ki-lab/tag05/notiz.txt
FILE=$(curl -s $OWUI/api/v1/files/ -H "Authorization: Bearer $ADMIN" \
-F file=@$HOME/ki-lab/tag05/notiz.txt | jq -r .id)
until curl -s $OWUI/api/v1/files/$FILE/process/status \
-H "Authorization: Bearer $ADMIN" | jq -e '.status == "completed"' >/dev/null
do sleep 2; done
jq -n --arg f "$FILE" '{model: "chat-small", stream: false,
files: [{type: "file", id: $f}],
messages: [{role: "user", content: "Wie lautet die Notfallnummer?"}]}' \
| curl -s $OWUI/api/chat/completions -H "Authorization: Bearer $ADMIN" \
-H "$J" -d @- | jq -r '.choices[0].message.content'Erwartet (live getestet, Antworttext weicht ab):
Die Notfallnummer lautet **4711** [1].
[1] verweist auf die Quelle. Ob die Embeddings wirklich
über LiteLLM liefen, zeigt dessen Spend-Log:
curl -s "$GW/spend/logs?summarize=false" -H "$M" \
| jq -r '.[] | select(.metadata.user_api_key_alias == "open-webui")
| .model_group' | sort | uniq -cErwartet (live getestet, Zahlen weichen ab):
2 chat-small
1 embed
Achtung: Ohne
RAG_OPENAI_API_BASE_URLschickt Open WebUI 0.11.4 die Embeddings anhttps://api.openai.com/v1– der Upload scheitert mit401 Unauthorized, und im schlimmsten Fall verlassen Dokumente das Haus. Die Variable ist eine PersistentConfig; ein falscher erster Start bleibt in der DB hängen.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
OWUI=http://chat.ki.localtest.me
check "Pod ready" \
'kubectl -n ki-chat wait pod/open-webui-0 --for=condition=Ready --timeout=5s'
check "PVC gebunden" \
'[ "$(kubectl -n ki-chat get pvc open-webui -o jsonpath={.status.phase})" = Bound ]'
check "Health über Ingress" \
'curl -sf $OWUI/health | jq -e .status'
check "Registrierung zu" \
'[ "$(curl -s $OWUI/api/config | jq .features.enable_signup)" = false ]'
check "Rauchtest" \
'PASS=lab-admin-1234 ~/ki-lab/code/open-webui/smoke.sh'
check "Key nicht im Klartext in den Values" \
'! grep -q "sk-" ~/ki-lab/code/open-webui/values-kind.yaml'Challenge
Die Oberfläche soll höchstens 30 Anfragen pro Minute und 1 (Lab-Währung) im Monat verbrauchen dürfen – ohne Open WebUI neu zu starten oder den Key zu tauschen.
Hinweis: Limits hängen am Virtual Key in LiteLLM,
nicht an Open WebUI; /key/update ändert sie im laufenden
Betrieb.
Lösung
OWUI_KEY=$(kubectl -n ki-chat get secret owui-secrets \
-o jsonpath='{.data.litellm-key}' | base64 -d)
curl -s $GW/key/update -H "$M" -H "$J" \
-d "{\"key\": \"$OWUI_KEY\", \"rpm_limit\": 30, \"max_budget\": 1}" \
| jq -c '{key_alias, rpm_limit, max_budget}'
curl -s "$GW/key/info?key=$OWUI_KEY" -H "$M" \
| jq -c '.info | {key_alias, spend, rpm_limit, max_budget}'Erwartet (live gegen lokalen Proxy, spend weicht
ab):
{"key_alias":"open-webui","rpm_limit":30,"max_budget":1.0}
{"key_alias":"open-webui","spend":0.003651,"rpm_limit":30,"max_budget":1.0}
Der Key bleibt gleich, Open WebUI merkt nichts – bis das Limit
greift. Dann sehen die Benutzer die Fehlermeldung von LiteLLM im Chat
(429 bzw. budget_exceeded).
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- SSO statt lokaler Konten: OIDC gegen Keycloak, Rollen und
Modell-Sichtbarkeit über Gruppen,
ENABLE_LOGIN_FORM=false(Tag 13). - Mehrere Replikas brauchen Postgres statt SQLite
(
databaseUrl), Redis für Websockets und ein RWX-Volume oder S3 für Uploads. - Vektoren in eine eigene Datenbank (Qdrant, pgvector) statt der eingebauten Chroma auf dem PVC; Embedding-Modell nie wechseln, ohne neu zu indizieren.
- Pro Abteilung ein eigener LiteLLM-Key bzw. eine eigene Open-WebUI-Instanz, wenn Budgets getrennt abgerechnet werden müssen.
- Backups: PVC bzw. Postgres per Velero/CNPG sichern – Chatverläufe können personenbezogene Daten enthalten (DSGVO, Löschkonzept).