Zum Inhalt springen
Trainingslager IT-Trainingslager

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 über embed. · Dauer: ca. 75 min · Voraussetzung: Tag 4

Briefing

  • Open WebUI (getestet: 0.11.4, Chart open-webui/open-webui 16.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/data auf 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.json

Erwartet (nicht live in kind getestet):

secret/owui-secrets created
admin-password
litellm-key
webui-secret

Sicherheit: WEBUI_SECRET_KEY signiert die Login-Tokens (JWT). Fehlt er, erzeugt Open WebUI einen zufälligen – nach jedem Neustart sind dann alle abgemeldet. lab-admin-1234 ist 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.yaml

Erwartet:

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/health

Erwartet (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.sh

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

Erwartet (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.yaml

Fortschritt 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 -c

Erwartet (live getestet, Zahlen weichen ab):

   2 chat-small
   1 embed

Achtung: Ohne RAG_OPENAI_API_BASE_URL schickt Open WebUI 0.11.4 die Embeddings an https://api.openai.com/v1 – der Upload scheitert mit 401 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).