Zum Inhalt springen
Trainingslager IT-Trainingslager

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

Erwartet:

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-acme

Erwartet:

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-acme zeigt 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-quota

Erwartet:

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 --now

Erwartet (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/gpu in 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-Regeln

Die 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.com

Erwartet (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 namespaceSelector und podSelector stehen im selben Listeneintrag (- namespaceSelector: … podSelector: …) und gelten damit als UND. Ein zusätzliches - vor podSelector macht 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=restricted

Erwartet:

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-80

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

Fortschritt 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/serviceaccount

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

Erwartet:

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

Erwartet:

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 name

Erwartet:

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=server scheitert hier mit namespaces "tenant-initech" not found, weil der Namespace im Dry-Run nie entsteht. Für neue Mandanten --dry-run=client oder kubectl diff nutzen.

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-initech

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

Erwartet:

✘ 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-acme stammen 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.