Tag 3: Mandanten und Muster
Ziel: Zwei Mandanten voneinander isolieren und die wiederkehrenden Muster bauen: Baseline pro Namespace, Monitoring, Shared Service, Ingress-Controller. · Dauer: ca. 90 min · Voraussetzung: Tag 2
Briefing
- Mandanten-Isolation = pro Namespace ein festes Baseline-Set: Deny All, DNS, eigener Namespace. Alles andere ist eine bewusste Ausnahme.
- Plattform-Dienste (Monitoring, Ingress) brauchen in jedem Mandanten eine Tür, aber nur für ihre eigenen Pods und Ports.
- Selektoren sind nur so sicher wie die Labels dahinter. Labels sind ein Vertrag zwischen Plattform und Teams.
kubernetes.io/metadata.namesetzt der API-Server selbst. Es lässt sich nicht fälschen.
monitoring/scraper ──:9113──► jede api ingress-nginx/controller ──► shop/frontend
┌ tenant-a ─┐ ✘ ┌ tenant-b ─┐
│ api │◄─────────►│ api │
└─────┬─────┘ └─────┬─────┘
└────── :8080 ──────────┤
▼
shop/api (Shared Service)
Drill 1: Baseline für jeden Mandanten
Drei Policies, eine Datei, ohne namespace: im YAML. So
passt sie auf jeden Mandanten:
cd ~/guard-lab/tag03
alias cc=~/guard-lab/code/demo/conncheck.sh
cat > tenant-baseline.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: default-deny-all
spec:
podSelector: {}
policyTypes:
- Ingress
- Egress
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-dns
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
spec:
podSelector: {}
policyTypes:
- Ingress
- Egress
ingress:
- from:
- podSelector: {}
egress:
- to:
- podSelector: {}
EOF
for t in tenant-a tenant-b; do kubectl apply -n $t -f tenant-baseline.yaml; doneErwartet:
networkpolicy.networking.k8s.io/default-deny-all created
networkpolicy.networking.k8s.io/allow-dns created
networkpolicy.networking.k8s.io/allow-same-namespace created
networkpolicy.networking.k8s.io/default-deny-all created
networkpolicy.networking.k8s.io/allow-dns created
networkpolicy.networking.k8s.io/allow-same-namespace created
cc tenant-a/api http://api.tenant-a
cc tenant-a/api http://api.tenant-b
cc tenant-b/api http://api.tenant-a
cc default/client http://api.tenant-a
cc shop/frontend http://api.tenant-bErwartet:
✔ erlaubt tenant-a/api -> http://api.tenant-a (HTTP 200)
✘ blockiert tenant-a/api -> http://api.tenant-b (Timeout)
✘ blockiert tenant-b/api -> http://api.tenant-a (Timeout)
✘ blockiert default/client -> http://api.tenant-a (Timeout)
✘ blockiert shop/frontend -> http://api.tenant-b (Timeout)
Innerhalb des Mandanten ist alles offen, über die Grenze nichts.
podSelector: {} in from/to heißt
„alle Pods dieses Namespace”.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Monitoring darf scrapen
kubectl -n monitoring logs deploy/scraper --tail=3Erwartet:
ok shop
FAIL tenant-a
FAIL tenant-b
Die Baseline hat das Monitoring ausgesperrt. Die Tür bekommt genau eine Quelle (UND aus Namespace und Pod) und genau einen Port:
cat > allow-monitoring.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-monitoring
spec:
podSelector: {}
policyTypes:
- Ingress
ingress:
- from:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: monitoring
podSelector:
matchLabels:
app: scraper
ports:
- port: metrics
EOF
for t in tenant-a tenant-b; do kubectl apply -n $t -f allow-monitoring.yaml; done
sleep 12
kubectl -n monitoring logs deploy/scraper --tail=3
cc monitoring/scraper http://api.tenant-aErwartet:
networkpolicy.networking.k8s.io/allow-monitoring created
networkpolicy.networking.k8s.io/allow-monitoring created
ok shop
ok tenant-a
ok tenant-b
✘ blockiert monitoring/scraper -> http://api.tenant-a (Timeout)
Der Scraper liest Metriken, aber nicht die Fachdaten auf Port 8080.
Der Named Port metrics funktioniert auch dann, wenn ein
Mandant ihn auf einen anderen Container-Port legt. Der Vertrag lautet:
„Metriken heißen metrics.”
Fortschritt speichern? Kostenlos registrieren
Drill 3: Shared Service – alle Mandanten an shop/api
shop/api wird zum gemeinsamen Katalog-Dienst. Jeder
Namespace mit dem Label tenant darf auf Port
http, sonst niemand:
cat > shop-api-shared.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: api-shared
namespace: shop
spec:
podSelector:
matchLabels:
app: api
policyTypes:
- Ingress
ingress:
- from:
- namespaceSelector:
matchExpressions:
- key: tenant
operator: Exists
ports:
- port: http
EOF
cat > egress-to-shop-api.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: egress-to-shop-api
spec:
podSelector: {}
policyTypes:
- Egress
egress:
- to:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: shop
podSelector:
matchLabels:
app: api
ports:
- port: 8080
EOF
kubectl apply -f shop-api-shared.yaml
for t in tenant-a tenant-b; do kubectl apply -n $t -f egress-to-shop-api.yaml; done
cc tenant-a/api http://api.shop
cc tenant-b/api http://api.shop
cc default/client http://api.shop
cc tenant-a/api http://api.shop:9113/metrics
cc tenant-a/api tcp://db.shop:5432Erwartet:
networkpolicy.networking.k8s.io/api-shared created
networkpolicy.networking.k8s.io/egress-to-shop-api created
networkpolicy.networking.k8s.io/egress-to-shop-api created
✔ erlaubt tenant-a/api -> http://api.shop (HTTP 200)
✔ erlaubt tenant-b/api -> http://api.shop (HTTP 200)
✘ blockiert default/client -> http://api.shop (Timeout)
✘ blockiert tenant-a/api -> http://api.shop:9113/metrics (Timeout)
✘ blockiert tenant-a/api -> tcp://db.shop:5432 (keine Verbindung)
Wieder zwei Seiten: Ingress in shop, Egress in jedem
Mandanten. Warum geht tenant-a nicht an die Datenbank,
obwohl shop kein Default Deny hat? Der Egress von
tenant-a erlaubt nur shop/api auf 8080.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Die Isolationsfalle
Was ist mit dem frontend, das bisher die api aufrief?
cc shop/frontend http://api.shopErwartet:
✘ blockiert shop/frontend -> http://api.shop (Timeout)
shop hat kein Default Deny, und trotzdem ist der Weg zu.
Sobald irgendeine Policy einen Pod für Ingress auswählt, ist dieser Pod
für Ingress isoliert. api-shared wählt app=api
aus und erlaubt nur Mandanten. Wer eine Ausnahme hinzufügen will, baut
aus Versehen eine Sperre. Reparatur: eine zweite, additive Regel für das
frontend.
kubectl -n shop patch networkpolicy api-shared --type=json -p='[{"op":"add",
"path":"/spec/ingress/-","value":{"from":[{"podSelector":{"matchLabels":
{"app":"frontend"}}}],"ports":[{"port":"http"}]}}]'
cc shop/frontend http://api.shopErwartet (gekürzt, kann je nach Version abweichen):
networkpolicy.networking.k8s.io/api-shared patched
✔ erlaubt shop/frontend -> http://api.shop (HTTP 200)
Tipp: Vor jeder neuen Policy fragen: Welche Pods wähle ich aus, und waren die vorher schon isoliert? Wenn nicht, kappst du gerade alle bestehenden Verbindungen.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Nur der Ingress-Controller darf ans frontend
In Produktion kommt Web-Traffic nur über den Ingress-Controller (oder ein Gateway). Wir simulieren ihn mit einem Pod, der dieselben Labels trägt wie ingress-nginx:
kubectl create namespace ingress-nginx
kubectl -n ingress-nginx run controller --image=curlimages/curl:8.22.0 \
--labels=app.kubernetes.io/name=ingress-nginx -- sleep 3600
cat > frontend-from-ingress.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: frontend-from-ingress
namespace: shop
spec:
podSelector:
matchLabels:
app: frontend
policyTypes:
- Ingress
ingress:
- from:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: ingress-nginx
podSelector:
matchLabels:
app.kubernetes.io/name: ingress-nginx
ports:
- port: http
EOF
kubectl apply -f frontend-from-ingress.yaml
kubectl -n ingress-nginx wait --for=condition=Ready pod/controller --timeout=60s
cc ingress-nginx/controller http://frontend.shop
cc default/client http://frontend.shop
cc tenant-a/api http://frontend.shopErwartet:
namespace/ingress-nginx created
pod/controller created
networkpolicy.networking.k8s.io/frontend-from-ingress created
pod/controller condition met
✔ erlaubt ingress-nginx/controller -> http://frontend.shop (HTTP 200)
✘ blockiert default/client -> http://frontend.shop (Timeout)
✘ blockiert tenant-a/api -> http://frontend.shop (Timeout)
Ein echter Controller hat oft hostNetwork: true oder
sitzt hinter einem LoadBalancer mit
externalTrafficPolicy: Cluster. Dann sieht die Policy die
Node-IP statt des Pods (Tag 2, Drill 7). Prüfe das, bevor du dich auf
den Pod-Selektor verlässt.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Labels als Vertrag
api-shared vertraut dem Label tenant. Wer
darf das setzen?
kubectl label namespace default tenant=fake
cc default/client http://api.shop
kubectl label namespace default tenant-Erwartet:
namespace/default labeled
✔ erlaubt default/client -> http://api.shop (HTTP 200)
namespace/default unlabeled
Ein Label, eine offene Tür. Wer patch auf Namespaces
hat, umgeht deine Policy. Das Label
kubernetes.io/metadata.name dagegen verwaltet der
API-Server selbst:
kubectl label namespace default kubernetes.io/metadata.name=shop --overwrite
kubectl get namespace default --show-labelsErwartet:
namespace/default labeled
NAME STATUS AGE LABELS
default Active 24m kubernetes.io/metadata.name=default
Der API-Server meldet Erfolg und setzt den Wert stillschweigend
zurück. Deshalb nutzen alle Policies dieses Tages für feste Partner
(kube-system, monitoring, shop,
ingress-nginx) genau dieses Label. Für Gruppen wie „alle
Mandanten” brauchst du eigene Labels und eine Regel, die sie schützt.
Das baust du mit Kyverno in Tag 13.
| Label | Gesetzt von | Fälschbar durch Teams |
|---|---|---|
kubernetes.io/metadata.name |
API-Server | nein |
tenant, purpose, team |
Plattform/GitOps | ja, mit RBAC patch namespaces |
app, tier am Pod |
App-Team | ja, im eigenen Namespace |
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
cc=~/guard-lab/code/demo/conncheck.sh
while read -r src url want; do
"$cc" "$src" "$url" "$want" >/dev/null \
&& echo "✔ $src -> $url ($want)" || echo "✘ $src -> $url (erwartet: $want)"
done <<'EOF'
tenant-a/api http://api.tenant-a allow
tenant-a/api http://api.tenant-b deny
tenant-b/api http://api.shop allow
default/client http://api.shop deny
monitoring/scraper http://api.tenant-b:9113/metrics allow
monitoring/scraper http://api.tenant-b deny
ingress-nginx/controller http://frontend.shop allow
default/client http://frontend.shop deny
EOF
kubectl get namespace default -o jsonpath='{.metadata.labels.tenant}' | grep -q . \
&& echo "✘ default trägt noch tenant" || echo "✔ default ohne tenant-Label"Challenge
Mandant A bucht eine Partnerschaft: tenant-a/api darf
tenant-b/api auf Port http aufrufen. Metriken
von B bleiben für A tabu, und B darf A weiterhin nicht erreichen.
Hinweis: Zwei Policies, eine pro Namespace. Nutze für die Gegenseite das Label, das der API-Server setzt.
Lösung
cat > a-to-b.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: egress-to-tenant-b
namespace: tenant-a
spec:
podSelector:
matchLabels:
app: api
policyTypes:
- Egress
egress:
- to:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: tenant-b
podSelector:
matchLabels:
app: api
ports:
- port: http
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: ingress-from-tenant-a
namespace: tenant-b
spec:
podSelector:
matchLabels:
app: api
policyTypes:
- Ingress
ingress:
- from:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: tenant-a
podSelector:
matchLabels:
app: api
ports:
- port: http
EOF
kubectl apply -f a-to-b.yaml
cc tenant-a/api http://api.tenant-b allow
cc tenant-a/api http://api.tenant-b:9113/metrics deny
cc tenant-b/api http://api.tenant-a denyErwartet:
networkpolicy.networking.k8s.io/egress-to-tenant-b created
networkpolicy.networking.k8s.io/ingress-from-tenant-a created
✔ erlaubt tenant-a/api -> http://api.tenant-b (HTTP 200)
✘ blockiert tenant-a/api -> http://api.tenant-b:9113/metrics (Timeout)
✘ blockiert tenant-b/api -> http://api.tenant-a (Timeout)
Am Ende von Teil A sieht dein Cluster so aus:
kubectl get networkpolicy -AErwartet (gekürzt):
NAMESPACE NAME POD-SELECTOR AGE
shop api-shared app=api 44s
shop frontend-from-ingress app=frontend 18s
tenant-a allow-dns <none> 92s
tenant-a allow-monitoring <none> 66s
tenant-a allow-same-namespace <none> 92s
tenant-a default-deny-all <none> 92s
tenant-a egress-to-shop-api <none> 44s
tenant-a egress-to-tenant-b app=api 7s
tenant-b allow-dns <none> 92s
...
tenant-b ingress-from-tenant-a app=api 7s
Vierzehn Policies für zwei Mandanten und einen Shop, und jede neue Partnerschaft braucht zwei weitere. Das schreit nach Automatisierung (Tag 9) und nach cluster-weiten Regeln (Tag 5). Teil A ist geschafft:
kind delete cluster --name np-labFortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Lege die Baseline (Deny All, DNS, eigener Namespace, Monitoring)
nicht per Hand an, sondern beim Namespace-Onboarding:
Kyverno-
GeneratingPolicy(Tag 9) oder GitOps (Tag 13). - Plattform-Regeln, die kein Team aushebeln darf (Monitoring rein, API-Server raus), gehören in AdminNetworkPolicies oder CNI-eigene cluster-weite Policies (Tag 5).
- Selektiere fremde Namespaces über
kubernetes.io/metadata.name. Für Gruppen-Labels wietenantbrauchst du RBAC und eine Admission-Regel, die das Label schützt. - Partnerschaften zwischen Mandanten gehören in einen Antrag mit
Review, nicht in einen schnellen
kubectl apply. Beide Seiten müssen zustimmen, technisch wie organisatorisch. - Behalte den Ingress-Controller im Blick:
hostNetwork,externalTrafficPolicyund Proxy-Protokoll verändern, welche Quell-IP die Policy sieht.