Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 13: LLM-Chat für das Team – Open WebUI, Keycloak und RAG mit Qdrant

Ziel: Das Team meldet sich per Keycloak an https://chat.lab.internal an und stellt Fragen an eigene Dokumente – Embeddings von vLLM, Vektoren in Qdrant, alles über LiteLLM. · Dauer: ca. 180 min · Voraussetzung: Tag 12

Briefing

  • Open WebUI läuft mit 2 Replikas: Postgres (CloudNativePG) für Benutzer und Chats, Redis für Websockets, ein RWX-Volume (Longhorn) für Uploads.
  • Login nur per OIDC. Keycloak liefert die Gruppen im Claim groups. Open WebUI leitet daraus die Rolle (ki-admins → admin, ki-users → user) und seine eigenen Gruppen ab.
  • RAG: Open WebUI schneidet Dokumente in Chunks, holt Embeddings über den LiteLLM-Alias embed und speichert sie in Qdrant. Bei jeder Frage holt es die Top-k-Chunks und gibt sie dem Chat-Modell als Kontext mit.
  • Embedding-Modell: BAAI/bge-m3 (MIT-Lizenz, 1024 Dimensionen, mehrsprachig) mit vLLM auf rke2-gpu-1.
Browser --TLS--> Traefik --> open-webui (x2) --OIDC--> keycloak (sso.lab.internal)
                               |   |    |
                   Postgres <--+   |    +--> Qdrant (Vektoren)
                   Redis    <------+    +--> LiteLLM :4000 --> vllm-chat  (chat-*)
                                                          --> vllm-embed (embed)

Drill 1: Embedding-Modell auf der GPU

Das Chat-Modell aus Tag 11 belegt 80 % des GPU-Speichers, vllm-embed bekommt 12 %.

mkdir -p ~/ki-lab/tag13 && cd ~/ki-lab/tag13
export KUBECONFIG=~/ki-lab/rke2.yaml
kubectl config use-context rke2-lab
kubectl apply -f ~/ki-lab/code/chat-rag/vllm-embed.yaml
kubectl -n ki-models rollout status deploy/vllm-embed --timeout=15m
kubectl -n ki-models port-forward svc/vllm-embed 8001:8000 >/dev/null 2>&1 &
sleep 2
curl -s localhost:8001/v1/embeddings -H 'Content-Type: application/json' \
  -d '{"model": "bge-m3", "input": ["Rufbereitschaft", "Bereitschaftsdienst"]}' \
  | jq '{model, n: (.data | length), dim: (.data[0].embedding | length)}'

Erwartet (gekürzt, kann je nach Version abweichen):

persistentvolumeclaim/vllm-embed-cache created
deployment.apps/vllm-embed created
service/vllm-embed created
deployment "vllm-embed" successfully rolled out
{
  "model": "bge-m3",
  "n": 2,
  "dim": 1024
}

Warum? --runner=pooling schaltet vLLM in den Embedding-Modus: Statt Tokens zu generieren, liefert das Modell einen Vektor pro Eingabe. Ein Pod pro Modell, getrennt skalierbar – die drei vLLM-Pods teilen sich die GPU per Time-Slicing (Tag 10).

Achtung: Die Summe aller --gpu-memory-utilization auf einer GPU muss unter 1,0 bleiben, sonst bricht der zuletzt gestartete Pod mit „not enough free memory” ab. Kontrolle: promq 'DCGM_FI_DEV_FB_USED' (Tag 10).

Fortschritt speichern? Kostenlos registrieren

Drill 2: Alias embed in LiteLLM

Ergänze model_list in ~/ki-lab/code/litellm-prod/config.yaml (Tag 12) um den Eintrag aus code/code-llm/litellm-models-code.yaml (dort stehen code und embed; code braucht erst Tag 14, schadet aber nicht):

  - model_name: embed
    litellm_params:
      model: hosted_vllm/bge-m3
      api_base: http://vllm-embed.ki-models:8000/v1
    model_info:
      mode: embedding
cd ~/ki-lab/code/litellm-prod
kubectl -n ki-gateway create configmap litellm-config --from-file=config.yaml \
  --dry-run=client -o yaml | kubectl apply -f -
kubectl -n ki-gateway rollout restart deploy/litellm
kubectl -n ki-gateway rollout status deploy/litellm
export LITELLM_MASTER_KEY=sk-lab-master-1234          # Lab-Wert
API=https://llm.lab.internal
curl -s $API/v1/embeddings -H "Authorization: Bearer $LITELLM_MASTER_KEY" \
  -H 'Content-Type: application/json' -d '{"model": "embed", "input": "Hallo"}' \
  | jq '{model, dim: (.data[0].embedding | length), usage}'

Erwartet (gekürzt, kann je nach Version abweichen):

configmap/litellm-config configured
deployment.apps/litellm restarted
deployment "litellm" successfully rolled out
{
  "model": "bge-m3",
  "dim": 1024,
  "usage": {
    "prompt_tokens": 3,
    "total_tokens": 3
  }
}

Warum? hosted_vllm/ ist der LiteLLM-Provider für vLLM. Ohne mode: embedding würde der Health-Check von LiteLLM das Modell per Chat-Request prüfen und als „unhealthy” melden.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Qdrant per Helm

cd ~/ki-lab/tag13
kubectl create namespace ki-chat --dry-run=client -o yaml | kubectl apply -f -
kubectl -n ki-chat create secret generic qdrant-auth \
  --from-literal=api-key=lab-qdrant-key-1234                # Lab-Wert
helm repo add qdrant https://qdrant.github.io/qdrant-helm
helm repo update
helm upgrade --install qdrant qdrant/qdrant --version 1.19.2 -n ki-chat \
  -f ~/ki-lab/code/chat-rag/values-qdrant.yaml
kubectl -n ki-chat rollout status sts/qdrant
kubectl -n ki-chat port-forward svc/qdrant 6333:6333 >/dev/null 2>&1 &
sleep 2
curl -s -o /dev/null -w 'ohne Key: %{http_code}\n' localhost:6333/collections
curl -s localhost:6333/collections -H 'api-key: lab-qdrant-key-1234' | jq -c .

Erwartet (gekürzt, kann je nach Version abweichen):

namespace/ki-chat created
secret/qdrant-auth created
Release "qdrant" does not exist. Installing it now.
STATUS: deployed
partitioned roll out complete: 1 new pods have been updated...
ohne Key: 401
{"result":{"collections":[]},"status":"ok","time":2.1e-06}

Warum? Das Chart liest den Key per lookup aus dem vorhandenen Secret und legt ihn in qdrant-apikey ab. Deshalb muss qdrant-auth vor helm install existieren – und helm template zeigt dir an dieser Stelle nur ein leeres Secret.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Keycloak, Realm und Gruppen-Claim

Für das Lab reicht Keycloak im Dev-Modus (Daten im Pod, weg nach Neustart). sso.lab.internal zeigt wie alle *.lab.internal auf Traefik (10.10.20.100, Tag 9).

kubectl create namespace keycloak
kubectl -n keycloak create secret generic keycloak-admin \
  --from-literal=password=lab-kc-admin-1234                 # Lab-Wert
kubectl apply -f ~/ki-lab/code/chat-rag/keycloak.yaml
kubectl -n keycloak rollout status deploy/keycloak --timeout=5m
curl -s https://sso.lab.internal/realms/master/.well-known/openid-configuration \
  | jq -r .issuer
bash ~/ki-lab/code/chat-rag/keycloak-setup.sh | tr -d '\n' > oidc-client-secret.txt
wc -c < oidc-client-secret.txt

Erwartet (gekürzt, kann je nach Version abweichen; kcadm meldet auf stderr):

deployment "keycloak" successfully rolled out
https://sso.lab.internal/realms/master
Logging into http://localhost:8080 as user admin of realm master
Created new realm with id 'ki-lab'
Created new client with id '3f6c...'
...
32

Das Skript keycloak-setup.sh legt an:

Objekt Name Zweck
Realm ki-lab eigener Mandant, nie master nutzen
Client open-webui (confidential) Redirect https://chat.lab.internal/oauth/oidc/callback
Mapper groups (Group Membership) flache Gruppennamen im ID-Token und Userinfo
Gruppen/User ki-admins (anna), ki-users (ben), keine (gast) Rollen-Test

Prüfe, was Open WebUI später zu sehen bekommt:

SECRET=$(cat oidc-client-secret.txt)
claims() { python3 -c 'import sys,json,base64
p = sys.stdin.read().split(".")[1]
print(json.dumps(json.loads(base64.urlsafe_b64decode(p + "=="))))'; }
curl -s https://sso.lab.internal/realms/ki-lab/protocol/openid-connect/token \
  -d grant_type=password -d client_id=open-webui -d client_secret="$SECRET" \
  -d username=ben -d password=lab-ben-1234 -d scope=openid \
  | jq -r .id_token | claims | jq -c '{preferred_username, email, groups}'

Erwartet (kann je nach Version abweichen):

{"preferred_username":"ben","email":"[email protected]",
 "groups":["ki-users","team-plattform"]}

Die Ausgabe ist hier umbrochen, jq -c liefert eine Zeile. Warum? full.path=false liefert ki-users statt /ki-users. Open WebUI vergleicht die Gruppennamen wörtlich mit OAUTH_ALLOWED_ROLES – ein führender Slash und niemand kommt rein.

Sicherheit: Der Password-Grant (directAccessGrantsEnabled) dient nur diesem Test. Schalte ihn danach ab: kubectl -n keycloak exec deploy/keycloak -- /opt/keycloak/bin/kcadm.sh update clients/<id> -r ki-lab -s directAccessGrantsEnabled=false.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Postgres, Virtual Key und Secrets

Der CloudNativePG-Operator läuft seit Tag 12. Open WebUI bekommt ein eigenes Cluster owui-db und einen eigenen Virtual Key für das Team team-chat.

cd ~/ki-lab/tag13
kubectl apply -f ~/ki-lab/code/chat-rag/owui-db.yaml
kubectl -n ki-chat wait cluster/owui-db --for=condition=Ready --timeout=5m
kubectl -n ki-chat get secret owui-db-app -o jsonpath='{.data.uri}' \
  | base64 -d | sed 's/:[^:@]*@/:***@/'; echo
H=(-H "Authorization: Bearer $LITELLM_MASTER_KEY" -H 'Content-Type: application/json')
TEAM=$(curl -s $API/team/new "${H[@]}" -d '{"team_alias": "team-chat",
  "models": ["chat-small", "chat-large", "embed"],
  "max_budget": 50, "budget_duration": "30d"}' | jq -r .team_id)
OWUI_KEY=$(curl -s $API/key/generate "${H[@]}" -d "{\"team_id\": \"$TEAM\",
  \"key_alias\": \"open-webui\", \"models\": [\"chat-small\", \"chat-large\",
  \"embed\"]}" | jq -r .key)
kubectl -n ki-chat create secret generic owui-secrets \
  --from-literal=litellm-key="$OWUI_KEY" \
  --from-literal=webui-secret-key="$(openssl rand -hex 32)" \
  --from-file=oidc-client-secret=oidc-client-secret.txt
kubectl -n ki-chat create configmap lab-ca --from-file=ca.crt=$HOME/ki-lab/lab-ca.crt

Erwartet (gekürzt, kann je nach Version abweichen):

cluster.postgresql.cnpg.io/owui-db created
cluster.postgresql.cnpg.io/owui-db condition met
postgresql://openwebui:***@owui-db-rw.ki-chat:5432/openwebui
secret/owui-secrets created
configmap/lab-ca created

Warum? WEBUI_SECRET_KEY signiert die Session-Tokens. Ohne festen Wert erzeugt jede Replika ihren eigenen – Benutzer fliegen dann bei jedem Request auf die andere Replika raus. Das Budget von 50 (Lab-Einheiten) gilt für das ganze Team, nicht pro Person.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Open WebUI per Helm

Die wichtigsten Zeilen aus code/chat-rag/values-open-webui.yaml:

Wert Wirkung
replicaCount: 2, persistence.accessModes: [ReadWriteMany] zwei Pods teilen das Upload-Volume (Longhorn RWX)
websocket.manager: redis Chart setzt REDIS_URL und WEBSOCKET_REDIS_URL auf den mitgelieferten Redis
ENABLE_PERSISTENT_CONFIG=False Env-Variablen gewinnen immer, Änderungen im Admin-UI sind nur bis zum Neustart gültig
ENABLE_LOGIN_FORM=False, sso.oidc.* Login nur über Keycloak
helm repo add open-webui https://helm.openwebui.com/
helm repo update
helm upgrade --install open-webui open-webui/open-webui --version 16.6.0 \
  -n ki-chat -f ~/ki-lab/code/chat-rag/values-open-webui.yaml
kubectl -n ki-chat rollout status sts/open-webui --timeout=10m
kubectl -n ki-chat get pods,pvc,ingress
kubectl -n ki-chat logs open-webui-0 | grep -iE "qdrant|oauth|error" | head -5
curl -s https://chat.lab.internal/health

Erwartet (gekürzt, kann je nach Version abweichen):

STATUS: deployed
partitioned roll out complete: 2 new pods have been updated...
NAME                                    READY   STATUS    RESTARTS   AGE
pod/open-webui-0                        1/1     Running   0          3m
pod/open-webui-1                        1/1     Running   0          2m
pod/open-webui-redis-6d9c7b8f5-x2kqp    1/1     Running   0          3m
pod/owui-db-1                           1/1     Running   0          9m
pod/owui-db-2                           1/1     Running   0          8m
pod/qdrant-0                            1/1     Running   0          25m
NAME                               STATUS   VOLUME     CAPACITY   ACCESS MODES
persistentvolumeclaim/open-webui   Bound    pvc-7c1e   20Gi       RWX
...
NAME         CLASS     HOSTS               ADDRESS        PORTS
open-webui   traefik   chat.lab.internal   10.10.20.100   80, 443
{"status":true}

Warum? Bei persistence.enabled rendert das Chart ein StatefulSet, das ein gemeinsames PVC einbindet. Longhorn stellt RWX über einen NFS-Share-Manager bereit – auf allen Workern muss dafür nfs-common installiert sein.

Tipp: Hängt der Login mit „OAuth callback failed”, prüfe zuerst Uhrzeit (NTP) auf allen Nodes, dann OPENID_REDIRECT_URI gegen die Redirect-URIs des Clients in Keycloak.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Login und Rollen testen

Öffne https://chat.lab.internal in drei privaten Browserfenstern und klicke „Weiter mit Keycloak”:

Benutzer Gruppen in Keycloak Ergebnis in Open WebUI
anna / lab-anna-1234 ki-admins, team-plattform Rolle admin, Admin-Panel sichtbar
ben / lab-ben-1234 ki-users, team-plattform Rolle user, Modelle chat-small, chat-large
gast / lab-gast-1234 keine Zugriff verweigert
kubectl -n ki-chat exec owui-db-1 -c postgres -- psql -U postgres -d openwebui \
  -c "select email, role from \"user\" order by email;" \
  -c "select name from \"group\" order by name;"

Erwartet (kann je nach Version abweichen):

      email       | role
------------------+-------
 [email protected] | admin
 [email protected]  | user
(2 rows)

      name
----------------
 ki-admins
 ki-users
 team-plattform
(3 rows)

Warum? Melde dich zuerst als anna an: Der allererste Benutzer wird immer admin, egal welche Gruppen er hat. Die Gruppen legt Open WebUI dank ENABLE_OAUTH_GROUP_CREATION selbst an und gleicht die Mitgliedschaft bei jedem Login ab. Rechte auf Modelle und Wissen vergibst du an diese Gruppen, nicht an Personen.

Tipp: Neue Modelle sind in Open WebUI zunächst privat (nur Admins). Unter Admin-Panel → Einstellungen → Modelle stellst du chat-small und chat-large für die Gruppe ki-users frei, embed bleibt ausgeblendet.

Fortschritt speichern? Kostenlos registrieren

Drill 8: RAG von Hand

Bevor du der Oberfläche vertraust, baust du die Kette einmal selbst: Chunks einbetten, in Qdrant speichern, Top-3 suchen, mit Kontext fragen. Das Skript code/chat-rag/rag_check.py nutzt drei fiktive Dokumente aus code/chat-rag/docs/.

python3 -m venv ~/ki-lab/.venv && source ~/ki-lab/.venv/bin/activate
pip install -q openai qdrant-client
export SSL_CERT_FILE=~/ki-lab/lab-ca.crt                  # Lab-CA für Python
export LITELLM_URL=$API/v1 LITELLM_KEY=$OWUI_KEY
export QDRANT_URL=http://localhost:6333 QDRANT_API_KEY=lab-qdrant-key-1234
python ~/ki-lab/code/chat-rag/rag_check.py

Erwartet (gekürzt, Werte schwanken):

11 Chunks eingebettet, dim=1024, 0.31s
✔ [0.71 bereitschaft.md] Wie hoch ist die Pauschale pro Bereitschaftswoche?
    -> 350 Euro pro angefangene Bereitschaftswoche. (1.1s)
✔ [0.66 bereitschaft.md] Wie schnell muss ich in der Bereitschaft bei P1 reagieren?
    -> Innerhalb von 15 Minuten. (0.9s)
✔ [0.62 gpu-richtlinie.md] Wie hoch ist das LLM-Standardbudget eines Teams?
    -> 50 Euro pro Monat. (0.8s)
✔ [0.74 vpn.md] Wie oft werden VPN-Schlüssel rotiert?
    -> Alle 90 Tage. (0.7s)
4/4 Fragen korrekt beantwortet

Warum? Die Zahl in eckigen Klammern ist die Cosinus-Ähnlichkeit des besten Treffers. Liegt die richtige Quelle nicht auf Platz 1, hilft kein besseres Chat-Modell – dann musst du an Chunking, Embedding-Modell oder Top-k drehen. Mit QDRANT_URL=:memory: läuft dasselbe Skript ohne Qdrant-Server, z. B. gegen LiteLLM aus Tag 4.

Fortschritt speichern? Kostenlos registrieren

Drill 9: Wissenssammlung in Open WebUI

Jetzt dieselben Dokumente über die Oberfläche – als anna:

  1. Arbeitsbereich → Wissen → +: Name Plattform-Handbuch, Sichtbarkeit: Gruppe team-plattform (Lesen).
  2. Die drei Dateien aus ~/ki-lab/code/chat-rag/docs/ hochladen.
  3. Als ben neuer Chat mit chat-large, #Plattform-Handbuch eintippen, Sammlung auswählen, fragen: „Wie hoch ist die Pauschale pro Bereitschaftswoche?”

Die Antwort nennt 350 Euro und zeigt die Quelle bereitschaft.md als Zitat. Was ist in Qdrant gelandet?

Q=(-H 'api-key: lab-qdrant-key-1234')
curl -s localhost:6333/collections "${Q[@]}" | jq -r '.result.collections[].name'
curl -s localhost:6333/collections/open-webui_knowledge "${Q[@]}" \
  | jq '.result | {points_count, size: .config.params.vectors.size}'

Erwartet (gekürzt, kann je nach Version abweichen):

rag-check
open-webui_files
open-webui_knowledge
{
  "points_count": 3,
  "size": 1024
}

Warum? ENABLE_QDRANT_MULTITENANCY_MODE (Default true) legt nicht pro Sammlung eine Collection an, sondern wenige gemeinsame mit einem Feld tenant_id. Das hält Qdrant bei hunderten Sammlungen schlank. Die Zugriffsrechte prüft allein Open WebUI – wer direkt an Qdrant kommt, sieht alles.

Die RAG-Parameter stehen in den Values, nicht im Admin-UI (ENABLE_PERSISTENT_CONFIG=False):

Variable Lab-Wert Wirkung
CHUNK_SIZE / CHUNK_OVERLAP 1000 / 150 Zeichen kleinere Chunks = präzisere Treffer, weniger Kontext
RAG_TOP_K 5 Chunks pro Frage im Prompt
RAG_EMBEDDING_BATCH_SIZE 16 Chunks pro Embedding-Request an LiteLLM
RAG_FILE_MAX_SIZE 25 (MB) größere Uploads werden abgelehnt

Achtung: Wechselst du das Embedding-Modell (z. B. von bge-m3 auf ein Modell mit 768 Dimensionen), passen die vorhandenen Vektoren nicht mehr. Dann musst du alle Sammlungen neu einbetten (Admin-Panel → Dokumente → Vektorspeicher neu indizieren).

Fortschritt speichern? Kostenlos registrieren

Drill 10: Datenschutz-Check

Ein Team-Chat speichert mehr, als man denkt. Wo liegt was?

Daten Ort Löschen / Begrenzen
Chats, Benutzer, Feedback Postgres owui-db Chat-Löschung durch Benutzer, Admin-Export, Backups beachten
Hochgeladene Dateien PVC open-webui (/app/backend/data/uploads) mit der Wissenssammlung löschen
Chunks im Klartext + Vektoren Qdrant (Payload text) Sammlung löschen, Snapshots beachten
Prompts, Token-Zahlen, Kosten LiteLLM Postgres (Tag 12) disable_spend_logs bzw. Aufbewahrung festlegen
curl -s localhost:6333/collections/open-webui_knowledge/points/scroll "${Q[@]}" \
  -H 'Content-Type: application/json' -d '{"limit": 1, "with_vector": false}' \
  | jq -r '.result.points[0].payload.text' | head -3

Erwartet (kann abweichen):

# Bereitschaftsregelung Plattform-Team (Lab GmbH, fiktiv)

Die Rufbereitschaft wechselt jeden Montag um 09:00 Uhr. Die Übergabe erfolgt im

Warum? Der Vektorspeicher enthält den Dokumenttext im Klartext. Für ihn gelten dieselben Schutzregeln wie für die Originaldateien: API-Key, NetworkPolicy, verschlüsselte Volumes, Löschkonzept.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

#!/usr/bin/env bash
ok() { echo "✔ $1"; }; nok() { echo "✘ $1"; }
K="kubectl -n ki-chat"
[ "$($K get sts open-webui -o jsonpath='{.status.readyReplicas}')" = "2" ] \
  && ok "Open WebUI 2/2 bereit" || nok "Open WebUI 2/2 bereit"
curl -sf https://chat.lab.internal/health >/dev/null \
  && ok "chat.lab.internal per TLS" || nok "chat.lab.internal per TLS"
curl -sf https://sso.lab.internal/realms/ki-lab/.well-known/openid-configuration \
  >/dev/null && ok "Keycloak-Realm ki-lab" || nok "Keycloak-Realm ki-lab"
curl -sf $API/v1/embeddings -H "Authorization: Bearer $OWUI_KEY" \
  -H 'Content-Type: application/json' -d '{"model":"embed","input":"x"}' \
  | jq -e '.data[0].embedding | length == 1024' >/dev/null \
  && ok "embed liefert 1024 Dimensionen" || nok "embed liefert 1024 Dimensionen"
curl -sf localhost:6333/collections/open-webui_knowledge \
  -H 'api-key: lab-qdrant-key-1234' | jq -e '.result.points_count > 0' >/dev/null \
  && ok "Wissen in Qdrant" || nok "Wissen in Qdrant"
$K exec owui-db-1 -c postgres -- psql -U postgres -d openwebui -tAc \
  "select role from \"user\" where email='[email protected]'" | grep -qx user \
  && ok "ben hat Rolle user" || nok "ben hat Rolle user"

Challenge

Ein RAG-System muss auch „weiß ich nicht” sagen können. Erweitere rag_check.py um eine Frage, deren Antwort in keinem Dokument steht, ohne das Skript selbst zu ändern.

Hinweis: QUESTIONS ist eine Modul-Liste, und als erwartete Quelle ist None erlaubt.

Lösung

cd ~/ki-lab/tag13
cat > rag_negativ.py <<'PY'
import sys

sys.path.insert(0, sys.argv[1])
import rag_check  # noqa: E402

rag_check.QUESTIONS.append(
    ("Wie heißt der Chef der Kantine?", None, "weiß ich nicht"))
sys.exit(rag_check.main())
PY
python rag_negativ.py ~/ki-lab/code/chat-rag | tail -3

Erwartet (Werte schwanken):

✔ [0.38 vpn.md] Wie heißt der Chef der Kantine?
    -> weiß ich nicht. (1.2s)
5/5 Fragen korrekt beantwortet

Der beste Treffer hat einen deutlich niedrigeren Score. Mit RAG_RELEVANCE_THRESHOLD (nur zusammen mit Hybrid Search und Reranker wirksam) filtert Open WebUI solche Treffer vorab heraus.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Keycloak über den Keycloak Operator mit eigenem Postgres, mindestens 2 Instanzen, Realm-Konfiguration als Code (z. B. keycloak-config-cli) statt kcadm.sh.
  • Ein Virtual Key für ganz Open WebUI verschleiert, wer was kostet. ENABLE_FORWARD_USER_INFO_HEADERS=True gibt LiteLLM die Benutzer-Mail mit – Auswertung und Datenschutz vorher klären.
  • Qdrant: API-Key aus OpenBao per ESO (Tag 12), NetworkPolicy nur von open-webui aus, Snapshots ins Backup (Tag 15). Das Chart liest den Key per lookup – mit Argo CD funktioniert das nicht, dort apiKey direkt aus einem Secret per env setzen.
  • Vor dem Rollout: Verarbeitungsverzeichnis, Löschfristen für Chats, Betriebsrat (Leistungs- und Verhaltenskontrolle!) und eine Nutzungsrichtlinie, welche Daten in den Chat dürfen.
  • Uploads auf S3-kompatiblen Speicher (persistence.provider: s3) statt RWX-Volume, sobald mehr als eine Handvoll Teams den Chat nutzen.