Tag 6: Multi-Tenant-Kubernetes
Ziel: Zwei Mandanten teilen sich den kind-Cluster, ohne sich zu sehen, zu stören oder auszubrechen. · Dauer: ca. 120 min · Voraussetzung: Tag 0
Briefing
- Ein Mandant = ein Namespace mit festem Satz an Leitplanken: RBAC, ResourceQuota, LimitRange, NetworkPolicy, Pod Security Admission (PSA).
- Mandanten verwalten ihre Workloads selbst, aber nie ihre eigenen Leitplanken.
- Netzwerk: Default-Deny; erlaubt sind nur DNS, der eigene Namespace
und das Gateway in
llm-system(Tag 7). - Das ist Soft Multi-Tenancy: gemeinsamer Kernel, gemeinsame API, gemeinsame Control Plane.
tenant-acme ──┐ ┌── tenant-globex
(team-acme) │ ┌── llm-system ────┐ │ (team-globex)
└──►│ llm-gateway:8080 │◄─┘
│ │ │
│ ▼ │
✘ acme ↔ globex │ ollama:11434 │
└──────────────────┘
Drill 1: Namespaces mit Labels
mkdir -p ~/sre-lab/tag06 && cd ~/sre-lab/tag06
cat > namespaces.yaml <<'EOF'
apiVersion: v1
kind: Namespace
metadata:
name: tenant-acme
labels:
sre-lab.io/role: tenant
sre-lab.io/tenant: acme
---
apiVersion: v1
kind: Namespace
metadata:
name: tenant-globex
labels:
sre-lab.io/role: tenant
sre-lab.io/tenant: globex
---
apiVersion: v1
kind: Namespace
metadata:
name: llm-system
labels:
sre-lab.io/role: platform
EOF
kubectl apply -f namespaces.yaml
kubectl get ns -l sre-lab.io/role -L sre-lab.io/role,sre-lab.io/tenantErwartet:
NAME STATUS AGE ROLE TENANT
llm-system Active 1s platform
tenant-acme Active 1s tenant acme
tenant-globex Active 1s tenant globex
Warum Labels? NetworkPolicies, Quotas, Kyverno-Regeln (Tag 13) und
Dashboards selektieren auf Labels, nicht auf Namen.
kubernetes.io/metadata.name setzt Kubernetes automatisch –
darauf selektierst du einzelne Namespaces.
Fortschritt speichern? Kostenlos registrieren
Drill 2: RBAC mit ClusterRole-Aggregation
Eine tenant-admin-ClusterRole wird aus Bausteinen
zusammengesetzt; gebunden wird sie per RoleBinding nur im jeweiligen
Namespace.
cat > rbac-clusterroles.yaml <<'EOF'
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: tenant-admin
aggregationRule:
clusterRoleSelectors:
- matchLabels:
sre-lab.io/aggregate-to-tenant-admin: "true"
rules: [] # füllt der Controller aus allen passenden ClusterRoles
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: tenant-admin-workloads
labels:
sre-lab.io/aggregate-to-tenant-admin: "true"
rules:
- apiGroups: [""]
resources: [pods, services, configmaps, secrets, persistentvolumeclaims]
verbs: [get, list, watch, create, update, patch, delete]
- apiGroups: [""]
resources: [pods/log]
verbs: [get]
- apiGroups: [apps]
resources: [deployments, statefulsets, replicasets]
verbs: [get, list, watch, create, update, patch, delete]
- apiGroups: [batch]
resources: [jobs, cronjobs]
verbs: [get, list, watch, create, update, patch, delete]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: tenant-admin-readonly-guardrails
labels:
sre-lab.io/aggregate-to-tenant-admin: "true"
rules:
- apiGroups: [""]
resources: [resourcequotas, limitranges, events]
verbs: [get, list, watch]
- apiGroups: [networking.k8s.io]
resources: [networkpolicies]
verbs: [get, list, watch]
EOF
for t in acme globex; do
kubectl create rolebinding tenant-admin -n tenant-$t \
--clusterrole=tenant-admin --group=team-$t \
--dry-run=client -o yaml
echo "---"
done > rbac-bindings.yaml
kubectl apply -f rbac-clusterroles.yaml -f rbac-bindings.yaml
kubectl get clusterrole tenant-admin \
-o jsonpath='{range .rules[*]}{.resources}{"\n"}{end}'Erwartet:
["resourcequotas","limitranges","events"]
["networkpolicies"]
["pods","services","configmaps","secrets","persistentvolumeclaims"]
["pods/log"]
["deployments","statefulsets","replicasets"]
["jobs","cronjobs"]
Jetzt prüfst du als Anna aus team-acme (Impersonation,
kein echter User nötig):
canI() { printf '%-40s %s\n' "$*" \
"$(kubectl auth can-i "$@" --as=anna --as-group=team-acme)"; }
canI create deployments -n tenant-acme
canI create deployments -n tenant-globex
canI get secrets -n tenant-acme
canI delete networkpolicies -n tenant-acme
canI create rolebindings -n tenant-acme
canI patch resourcequotas -n tenant-acmeErwartet:
create deployments -n tenant-acme yes
create deployments -n tenant-globex no
get secrets -n tenant-acme yes
delete networkpolicies -n tenant-acme no
create rolebindings -n tenant-acme no
patch resourcequotas -n tenant-acme no
Warum keine RoleBindings? Wer RoleBindings anlegen darf, kann sich
jede Rolle geben, die er selbst hat – und mit
escalate/bind sogar mehr. Leitplanken gehören
der Plattform.
Tipp:
kubectl auth can-i --list -n tenant-acme --as=anna --as-group=team-acmezeigt alle effektiven Rechte – ideal für Audits beim Kunden.
Fortschritt speichern? Kostenlos registrieren
Drill 3: ResourceQuota und LimitRange
for t in acme:1 globex:0; do
T=${t%%:*} GPU=${t##*:}
cat > quota-$T.yaml <<EOF
apiVersion: v1
kind: ResourceQuota
metadata:
name: tenant-quota
namespace: tenant-$T
spec:
hard:
requests.cpu: "2"
requests.memory: 4Gi
limits.cpu: "4"
limits.memory: 8Gi
pods: "20"
persistentvolumeclaims: "5"
requests.storage: 20Gi
services.loadbalancers: "0"
services.nodeports: "0"
requests.nvidia.com/gpu: "$GPU" # Extended Resource: nur requests.-Präfix
---
apiVersion: v1
kind: LimitRange
metadata:
name: tenant-defaults
namespace: tenant-$T
spec:
limits:
- type: Container
defaultRequest: {cpu: 100m, memory: 128Mi}
default: {cpu: 500m, memory: 512Mi}
max: {cpu: "2", memory: 4Gi}
EOF
done
kubectl apply -f quota-acme.yaml -f quota-globex.yaml
kubectl -n tenant-globex describe quota tenant-quotaErwartet:
Resource Used Hard
-------- ---- ----
limits.cpu 0 4
...
requests.nvidia.com/gpu 0 0
services.nodeports 0 0
Drei Gegenproben – Defaults, Maximum, GPU:
kubectl -n tenant-acme run plain --image=curlimages/curl:8.22.0 \
--restart=Never -- sleep 3600
kubectl -n tenant-acme get pod plain -o jsonpath='{.spec.containers[0].resources}'
echo
kubectl -n tenant-acme run fat --image=curlimages/curl:8.22.0 --restart=Never \
--overrides='{"spec":{"containers":[{"name":"fat",
"image":"curlimages/curl:8.22.0","resources":{"limits":{"memory":"16Gi"}}}]}}'
kubectl -n tenant-globex run gpu --image=curlimages/curl:8.22.0 --restart=Never \
--overrides='{"spec":{"containers":[{"name":"gpu",
"image":"curlimages/curl:8.22.0","resources":{"limits":{"nvidia.com/gpu":"1"}}}]}}'
kubectl -n tenant-acme delete pod plain --nowErwartet (gekürzt):
pod/plain created
{"limits":{"cpu":"500m","memory":"512Mi"},"requests":{"cpu":"100m","memory":"128Mi"}}
Error from server (Forbidden): pods "fat" is forbidden: maximum memory usage
per Container is 4Gi, but limit is 16Gi
Error from server (Forbidden): pods "gpu" is forbidden: exceeded quota:
tenant-quota, requested: requests.nvidia.com/gpu=1, used: ...=0, limited: ...=0
Warum LimitRange? Sobald eine Quota requests.cpu
begrenzt, lehnt die API Pods ohne Requests ab. Die LimitRange setzt
Defaults und verhindert so Supportfälle („mein Pod startet nicht”).
Achtung: Für GPUs (Extended Resources) gibt es nur
requests.nvidia.com/gpuin der Quota –limits.ist dort nicht erlaubt. Im Pod müssen Request und Limit gleich sein.
Fortschritt speichern? Kostenlos registrieren
Drill 4: NetworkPolicy – Default-Deny und Ausnahmen
Erst die Testpods anlegen (schon restricted-konform, das brauchst du in Drill 5):
for ns in tenant-acme tenant-globex; do cat <<EOF
apiVersion: v1
kind: Pod
metadata:
name: client
namespace: $ns
spec:
securityContext:
runAsNonRoot: true
runAsUser: 100 # curl_user im Image
seccompProfile: {type: RuntimeDefault}
containers:
- name: curl
image: curlimages/curl:8.22.0
command: [sleep, "86400"]
securityContext:
allowPrivilegeEscalation: false
capabilities: {drop: [ALL]}
---
EOF
done > testpods.yaml
cat >> testpods.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
name: web
namespace: tenant-globex
labels: {app: web}
spec:
securityContext:
runAsNonRoot: true
runAsUser: 101 # nginx im unprivileged-Image
seccompProfile: {type: RuntimeDefault}
containers:
- name: nginx
image: nginxinc/nginx-unprivileged:1.31-alpine
ports: [{containerPort: 8080}]
securityContext:
allowPrivilegeEscalation: false
capabilities: {drop: [ALL]}
---
apiVersion: v1
kind: Service
metadata:
name: web
namespace: tenant-globex
spec:
selector: {app: web}
ports: [{port: 80, targetPort: 8080}]
EOF
kubectl apply -f testpods.yaml
kubectl wait --for=condition=Ready pod --all -n tenant-acme --timeout=120s
kubectl wait --for=condition=Ready pod --all -n tenant-globex --timeout=120s
sleep 5 # kube-proxy braucht einen Moment für die Service-RegelnDie Prüffunktion brauchst du gleich mehrfach:
probe() {
if kubectl -n "$1" exec client -- curl -s -o /dev/null -m 3 "$2" 2>/dev/null
then echo "✔ offen $1 -> $2"; else echo "✘ blockiert $1 -> $2"; fi
}
probe tenant-acme http://web.tenant-globex
probe tenant-globex http://web.tenant-globex
probe tenant-acme https://example.comErwartet (ohne Policies ist alles offen):
✔ offen tenant-acme -> http://web.tenant-globex
✔ offen tenant-globex -> http://web.tenant-globex
✔ offen tenant-acme -> https://example.com
Jetzt vier Policies pro Tenant:
for ns in tenant-acme tenant-globex; do
cat > netpol-$ns.yaml <<EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: default-deny-all
namespace: $ns
spec:
podSelector: {}
policyTypes: [Ingress, Egress]
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-dns
namespace: $ns
spec:
podSelector: {}
policyTypes: [Egress]
egress:
- to:
- namespaceSelector:
matchLabels: {kubernetes.io/metadata.name: kube-system}
podSelector:
matchLabels: {k8s-app: kube-dns}
ports:
- {protocol: UDP, port: 53}
- {protocol: TCP, port: 53}
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-same-namespace
namespace: $ns
spec:
podSelector: {}
policyTypes: [Ingress, Egress]
ingress:
- from: [{podSelector: {}}]
egress:
- to: [{podSelector: {}}]
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-egress-llm-gateway
namespace: $ns
spec:
podSelector: {}
policyTypes: [Egress]
egress:
- to:
- namespaceSelector:
matchLabels: {kubernetes.io/metadata.name: llm-system}
podSelector:
matchLabels: {app.kubernetes.io/name: llm-gateway}
ports:
- {protocol: TCP, port: 8080}
EOF
done
kubectl apply -f netpol-tenant-acme.yaml -f netpol-tenant-globex.yaml
probe tenant-acme http://web.tenant-globex
probe tenant-globex http://web.tenant-globex
probe tenant-acme https://example.com
kubectl -n tenant-acme exec client -- nslookup web.tenant-globex.svc.cluster.local \
| grep -A1 '^Name'Erwartet:
✘ blockiert tenant-acme -> http://web.tenant-globex
✔ offen tenant-globex -> http://web.tenant-globex
✘ blockiert tenant-acme -> https://example.com
Name: web.tenant-globex.svc.cluster.local
Address: 10.96.243.54
Warum klappt das in kind? Seit kind 0.24 setzt der Standard-CNI kindnet NetworkPolicies durch (hier mit kind 0.33 geprüft) – Calico ist nicht nötig. Auf Clustern ohne Policy-fähiges CNI werden NetworkPolicies stillschweigend ignoriert; teste deshalb immer mit einer Gegenprobe wie hier.
Achtung: Die Selektoren
namespaceSelectorundpodSelectorstehen im selben Listeneintrag (- namespaceSelector: … podSelector: …) und gelten damit als UND. Ein zusätzliches-vorpodSelectormacht daraus ODER – ein klassischer Fehler, der ganze Namespaces öffnet.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Pod Security Admission (restricted)
Erst prüfen, ob laufende Pods die Stufe schon erfüllen – dann scharf schalten:
kubectl label --dry-run=server --overwrite ns tenant-acme tenant-globex \
pod-security.kubernetes.io/enforce=restricted
kubectl label --overwrite ns tenant-acme tenant-globex \
pod-security.kubernetes.io/enforce=restricted \
pod-security.kubernetes.io/enforce-version=latest \
pod-security.kubernetes.io/warn=restricted \
pod-security.kubernetes.io/audit=restrictedErwartet:
namespace/tenant-acme labeled (server dry run)
namespace/tenant-globex labeled (server dry run)
namespace/tenant-acme labeled
namespace/tenant-globex labeled
Keine Warnung im Dry-Run = alle laufenden Pods sind konform. Jetzt ein Verstoß:
kubectl -n tenant-acme run root-nginx --image=nginx:1.31-alpine --restart=Never
kubectl -n tenant-acme create deployment bad --image=nginx:1.31-alpine
sleep 3
kubectl -n tenant-acme get deploy bad
kubectl -n tenant-acme get events --field-selector reason=FailedCreate \
-o custom-columns=MSG:.message | head -2 | cut -c1-80Erwartet (gekürzt):
Error from server (Forbidden): pods "root-nginx" is forbidden: violates PodSecurity
"restricted:latest": allowPrivilegeEscalation != false (...), unrestricted
capabilities (...), runAsNonRoot != true (...), seccompProfile (...)
Warning: would violate PodSecurity "restricted:latest": ...
deployment.apps/bad created
NAME READY UP-TO-DATE AVAILABLE AGE
bad 0/1 0 0 6s
MSG
Error creating: pods "bad-6dc9c6b47d-t8cvk" is forbidden: violates PodSecurity "
Warum wird das Deployment angelegt? PSA prüft nur Pods. Das
Deployment ist gültig, der ReplicaSet-Controller scheitert danach still
– nur warn macht den Fehler beim apply
sichtbar. Deshalb immer enforce und
warn setzen.
kubectl -n tenant-acme delete deploy badFortschritt speichern? Kostenlos registrieren
Drill 6: ServiceAccount-Tokens
kubectl -n tenant-acme exec client -- ls /var/run/secrets/kubernetes.io/serviceaccount
for t in acme globex; do
kubectl -n tenant-$t patch sa default -p '{"automountServiceAccountToken":false}'
done
kubectl -n tenant-acme delete pod client --now
kubectl apply -f testpods.yaml
kubectl -n tenant-acme wait --for=condition=Ready pod/client --timeout=60s
kubectl -n tenant-acme exec client -- ls /var/run/secrets/kubernetes.io/serviceaccountErwartet (gekürzt):
ca.crt
namespace
token
serviceaccount/default patched
...
ls: /var/run/secrets/kubernetes.io/serviceaccount: No such file or directory
command terminated with exit code 1
Pods, die nie mit der API sprechen, brauchen kein Token – ein gestohlenes Token ist sonst der erste Schritt zur Eskalation. Für CI gibt es einen eigenen ServiceAccount mit kurzlebigem Token:
kubectl -n tenant-acme create sa ci-deployer
kubectl -n tenant-acme create rolebinding ci-deployer \
--clusterrole=tenant-admin --serviceaccount=tenant-acme:ci-deployer
TOKEN=$(kubectl -n tenant-acme create token ci-deployer --duration=10m)
SERVER=$(kubectl config view --minify -o jsonpath='{.clusters[0].cluster.server}')
k() { kubectl --kubeconfig=/dev/null --server="$SERVER" \
--insecure-skip-tls-verify --token="$TOKEN" "$@"; } # nur Lab!
k auth whoami | grep Username
k -n tenant-acme get pods
k -n tenant-globex get podsErwartet:
Username system:serviceaccount:tenant-acme:ci-deployer
NAME READY STATUS RESTARTS AGE
client 1/1 Running 0 13s
Error from server (Forbidden): pods is forbidden: User
"system:serviceaccount:tenant-acme:ci-deployer" cannot list resource "pods" in
API group "" in the namespace "tenant-globex"
Warum --kubeconfig=/dev/null? Mit der normalen
kind-Kubeconfig gewinnt das Admin-Clientzertifikat, und du testest
unbemerkt als kubernetes-admin.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Tenant-Onboarding als ein YAML-Bundle
Alles aus Drill 1–6 als Vorlage – ein neuer Mandant ist ein Befehl:
cat > tenant-bundle.yaml <<'EOF'
# envsubst '$TENANT $GPU' < tenant-bundle.yaml | kubectl apply -f -
apiVersion: v1
kind: Namespace
metadata:
name: tenant-${TENANT}
labels:
sre-lab.io/role: tenant
sre-lab.io/tenant: ${TENANT}
pod-security.kubernetes.io/enforce: restricted
pod-security.kubernetes.io/enforce-version: latest
pod-security.kubernetes.io/warn: restricted
pod-security.kubernetes.io/audit: restricted
---
apiVersion: v1
kind: ServiceAccount
metadata:
name: default
namespace: tenant-${TENANT}
automountServiceAccountToken: false
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: tenant-admin
namespace: tenant-${TENANT}
subjects:
- kind: Group
name: team-${TENANT}
apiGroup: rbac.authorization.k8s.io
roleRef:
kind: ClusterRole
name: tenant-admin
apiGroup: rbac.authorization.k8s.io
---
EOF
sed -e 's/tenant-acme/tenant-${TENANT}/' -e 's/"1" #/"${GPU}" #/' \
quota-acme.yaml >> tenant-bundle.yaml
echo "---" >> tenant-bundle.yaml
sed 's/tenant-acme/tenant-${TENANT}/' netpol-tenant-acme.yaml >> tenant-bundle.yaml
grep -c 'TENANT}' tenant-bundle.yamlErwartet:
11
Onboarding von initech testen:
export TENANT=initech GPU=0
envsubst '$TENANT $GPU' < tenant-bundle.yaml | kubectl apply --dry-run=client -f - \
| wc -l | tr -d ' '
envsubst '$TENANT $GPU' < tenant-bundle.yaml | kubectl apply --server-side -f -
kubectl -n tenant-initech get netpol,quota,limitrange,rolebinding -o nameErwartet:
9
namespace/tenant-initech serverside-applied
serviceaccount/default serverside-applied
rolebinding.rbac.authorization.k8s.io/tenant-admin serverside-applied
...
networkpolicy.networking.k8s.io/allow-egress-llm-gateway serverside-applied
networkpolicy.networking.k8s.io/allow-dns
...
rolebinding.rbac.authorization.k8s.io/tenant-admin
Achtung:
--dry-run=serverscheitert hier mitnamespaces "tenant-initech" not found, weil der Namespace im Dry-Run nie entsteht. Für neue Mandanten--dry-run=clientoderkubectl diffnutzen.
Warum --server-side? Der ServiceAccount
default entsteht automatisch, sobald der Namespace da ist.
Client-side apply will ihn anlegen und verliert das Rennen
gelegentlich mit AlreadyExists; Server-Side Apply legt an
oder merged.
Warum envsubst '$TENANT $GPU'? Ohne Variablenliste
ersetzt envsubst jedes $… – auch solche, die in ConfigMaps
oder Skripten stehen bleiben sollen. An Tag 12 wird das Bundle zum
OpenTofu-Modul.
kubectl delete ns tenant-initechFortschritt speichern? Kostenlos registrieren
Kontrollpunkt
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
AS="--as=anna --as-group=team-acme"
check "anna darf in acme deployen" \
"kubectl auth can-i create deployments -n tenant-acme $AS"
check "anna darf nicht in globex" \
"! kubectl auth can-i create deployments -n tenant-globex $AS"
check "anna darf NetworkPolicies nicht löschen" \
"! kubectl auth can-i delete networkpolicies -n tenant-acme $AS"
check "GPU-Quota globex = 0" \
'[ "$(kubectl -n tenant-globex get quota tenant-quota \
-o jsonpath="{.spec.hard.requests\.nvidia\.com/gpu}")" = 0 ]'
check "acme -> globex blockiert" \
'! kubectl -n tenant-acme exec client -- curl -s -m 3 http://web.tenant-globex'
check "globex intern offen" \
'kubectl -n tenant-globex exec client -- curl -s -m 3 http://web.tenant-globex'
check "PSA restricted in acme" \
'[ "$(kubectl get ns tenant-acme -o \
jsonpath="{.metadata.labels.pod-security\.kubernetes\.io/enforce}")" \
= restricted ]'
check "kein SA-Token im acme-Client" \
'! kubectl -n tenant-acme exec client -- \
ls /var/run/secrets/kubernetes.io/serviceaccount'Challenge
Prometheus (Namespace monitoring, Tag 8) soll den
web-Pod in tenant-globex auf Port 8080
erreichen – ohne dass tenant-acme etwas davon hat. Beweise
beides mit einem Testpod in monitoring.
Hinweis: NetworkPolicies sind additiv – du ergänzt eine Ingress-Policy im Ziel-Namespace, du änderst keine bestehende.
Lösung
cat > challenge-netpol.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-scrape-from-monitoring
namespace: tenant-globex
spec:
podSelector:
matchLabels: {app: web}
policyTypes: [Ingress]
ingress:
- from:
- namespaceSelector:
matchLabels: {kubernetes.io/metadata.name: monitoring}
ports:
- {protocol: TCP, port: 8080}
EOF
kubectl create ns monitoring
kubectl -n monitoring run client --image=curlimages/curl:8.22.0 -- sleep 3600
kubectl -n monitoring wait --for=condition=Ready pod/client --timeout=60s
probe monitoring http://web.tenant-globex
kubectl apply -f challenge-netpol.yaml
probe monitoring http://web.tenant-globex
probe tenant-acme http://web.tenant-globex
kubectl -n monitoring delete pod client --nowErwartet:
✘ blockiert monitoring -> http://web.tenant-globex
networkpolicy.networking.k8s.io/allow-scrape-from-monitoring created
✔ offen monitoring -> http://web.tenant-globex
✘ blockiert tenant-acme -> http://web.tenant-globex
Warum ging es vorher nicht, obwohl monitoring keine
Policies hat? Die Ingress-Seite in tenant-globex war zu.
Eine Verbindung braucht Egress-Erlaubnis beim Sender
und Ingress-Erlaubnis beim Empfänger.
Fortschritt speichern? Kostenlos registrieren
Interview-Notiz
- Typische Frage: „Wie isolierst du Kunden auf einem gemeinsamen Inferenz-Cluster?” – Antwort in Schichten: Identität (RBAC), Ressourcen (Quota/LimitRange, GPU-Quota), Netz (Default-Deny), Laufzeit (PSA restricted), Daten (eigene Secrets/PVCs).
- Knackig: „Mandanten verwalten Workloads, die Plattform verwaltet Leitplanken – deshalb keine RoleBindings, NetworkPolicies oder Quotas für Tenants.”
- Soft vs. hard: Namespaces teilen Kernel und Control Plane. Härter
wird es mit vCluster (eigene API pro Mandant), dedizierten Node-Pools
(Taints +
nodeSelector, ggf. gVisor/Kata) oder separaten Clustern pro Kunde. - Brücke aus deiner Praxis: In Vault/OpenBao hast du dasselbe Muster mit Namespaces, Policies und Auth-Mounts pro Mandant gebaut – Least Privilege und „Policies as Code” übertragen sich 1:1.
- Fallstrick zeigen können: NetworkPolicy ohne Policy-fähiges CNI ist wirkungslos – deshalb gehören Gegenproben in die Onboarding-Pipeline.
Enterprise-Notiz
- Identität kommt aus OIDC (Keycloak, Entra ID); Gruppen wie
team-acmestammen aus dem IdP, nicht aus Zertifikaten. - Regulierte Kunden verlangen oft harte Trennung: eigener Node-Pool mit GPUs pro Mandant, eigener Cluster oder vCluster, getrennte Storage-Klassen und KMS-Keys.
- Policy-Engine (Kyverno/Gatekeeper, Tag 13) erzwingt Labels,
Image-Registries und verbietet
hostPath– PSA allein reicht nicht. - Egress zu externen APIs (z. B.
api.mistral.ai) per Egress-Gateway oder CNI mit FQDN-Policies (Cilium, Calico Enterprise) statt IP-Listen. - Onboarding nicht per Hand: GitOps (Argo CD/Flux) oder OpenTofu (Tag 12) mit Review, Audit-Log und automatischen Gegenproben.