Zum Inhalt springen
Trainingslager IT-Trainingslager

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.name setzt 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; done

Erwartet:

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

Erwartet:

✔ 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=3

Erwartet:

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

Erwartet:

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:5432

Erwartet:

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

Erwartet:

✘ 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.shop

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

Erwartet:

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

Erwartet:

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 deny

Erwartet:

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

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

Fortschritt 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 wie tenant brauchst 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, externalTrafficPolicy und Proxy-Protokoll verändern, welche Quell-IP die Policy sieht.