Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 11: Von außen und abgeschottet

Ziel: notes über ein Gateway unter http://notes.localhost:30080 erreichbar machen, den Verkehr im Namespace per NetworkPolicy auf das Nötige begrenzen und in den scratch-Container der api hineinschauen. · Dauer: ca. 120 min · Voraussetzung: Tag 10

Briefing

  • Gateway API trennt Rollen: Die Plattform stellt eine GatewayClass bereit (welcher Controller, welche Parameter), das App-Team legt Gateway (Listener: Port, Hostname) und HTTPRoute (Host, Pfad → Service) an.
  • Der Controller hier ist Envoy Gateway: Pro Gateway startet er einen Envoy-Pod samt Service im Namespace envoy-gateway-system.
  • Eine NetworkPolicy wählt Pods per Label aus. Sobald eine Policy einen Pod auswählt, ist für ihn nur noch erlaubt, was eine Policy freigibt.
  • kubectl debug hängt einen Ephemeral Container mit Werkzeugen an einen laufenden Pod – auch an einen ohne Shell.
 Mac: curl http://notes.localhost:30080
        │  extraPortMappings (Tag 0)
        ▼
 Node :30080 ─► Service envoy-… (NodePort) ─► Pod envoy    envoy-gateway-system
                                                │ Gateway notes, HTTPRoute web
                                                ▼ Host: notes.localhost
                          Service web (ClusterIP) ─► web ─► api ─► db    notes

Drill 1: Tagesstart und Envoy Gateway

source ~/k8s-lab/setup/env.sh
mkdir -p ~/k8s-lab/tag11 && cd ~/k8s-lab/tag11
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag10/notes/." .
helm install eg oci://docker.io/envoyproxy/gateway-helm --version v1.9.3 \
  -n envoy-gateway-system --create-namespace --wait | grep -E '^(NAME|STATUS):'
kubectl -n envoy-gateway-system get pods
kubectl get crd | grep -c gateway.networking.k8s.io
kubectl get crd gateways.gateway.networking.k8s.io \
  -o jsonpath='{.metadata.annotations.gateway\.networking\.k8s\.io/bundle-version}'
echo

Erwartet (gekürzt, Namen, IPs und Zeiten weichen bei dir ab):

Pulled: docker.io/envoyproxy/gateway-helm:v1.9.3
Digest: sha256:be1b8f16…
NAME: eg
STATUS: deployed
NAME                             READY   STATUS      RESTARTS   AGE
eg-gateway-helm-certgen-xbb8q    0/1     Completed   0          42s
envoy-gateway-6776489b4b-rnzg5   1/1     Running     0          19s
10
v1.6.1

Das Chart bringt die CRDs der Gateway API (hier Bundle v1.6.1) und die eigenen von Envoy Gateway mit. Der certgen-Job erzeugt einmalig die Zertifikate des Controllers. Das dauert knapp eine Minute.

Fortschritt speichern? Kostenlos registrieren

Drill 2: GatewayClass – die Plattform-Seite

Die GatewayClass eg verweist auf ein EnvoyProxy-Objekt mit Parametern: Der Envoy-Service soll ein NodePort auf 30080 sein, denn nur diesen Port reicht kind zum Mac durch. Erster Entwurf:

cat > k8s/gateway.yaml <<'EOF'
# k8s/gateway.yaml – erster Entwurf (Tag 11, Drill 2; fertig in Drill 4)
apiVersion: gateway.envoyproxy.io/v1alpha1
kind: EnvoyProxy
metadata:
  name: nodeport
  namespace: envoy-gateway-system
spec:
  provider:
    type: Kubernetes
    kubernetes:
      envoyService:
        type: NodePort
        patch:
          type: StrategicMerge
          value:
            spec:
              ports:
                - port: 80
                  nodePort: 30080
---
apiVersion: gateway.networking.k8s.io/v1
kind: GatewayClass
metadata:
  name: eg
spec:
  controllerName: gateway.envoyproxy.io/gatewayclass-controller
  parametersRef:
    group: gateway.envoyproxy.io
    kind: EnvoyProxy
    name: nodeport
    namespace: envoy-gateway-system
EOF
kubectl apply --dry-run=server -f k8s/gateway.yaml
kubectl apply -f k8s/gateway.yaml
kubectl get gatewayclass

Erwartet:

envoyproxy.gateway.envoyproxy.io/nodeport created (server dry run)
gatewayclass.gateway.networking.k8s.io/eg created (server dry run)
envoyproxy.gateway.envoyproxy.io/nodeport created
gatewayclass.gateway.networking.k8s.io/eg created
NAME   CONTROLLER                                      ACCEPTED   AGE
eg     gateway.envoyproxy.io/gatewayclass-controller   True       0s

ACCEPTED True heißt: Der Controller fühlt sich zuständig. Einen Envoy-Pod gibt es noch nicht – der entsteht erst mit dem ersten Gateway. gateway.yaml gehört wie namespace.yaml zum Plattform-Teil in k8s/, nicht ins Chart.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Chart 0.2.0 – Gateway und Route

Das App-Team liefert Gateway und HTTPRoute im Chart. Hol den Stand aus dem Begleitcode und sieh dir die Änderungen an:

cp -R "$LAB/code/tag11/notes/chart/." chart/
grep -E '^version' chart/notes/Chart.yaml
sed -n '/^gateway:/,$p' chart/notes/values.yaml
grep -A1 '^  service:' chart/notes/values.yaml

Erwartet:

version: 0.2.0
gateway:
  enabled: true
  className: eg
  hostname: notes.localhost

networkPolicy:
  enabled: true
  gatewayNamespace: envoy-gateway-system
  service:
    type: ClusterIP   # ab Tag 11 kommt der Verkehr über das Gateway

Das neue Template (die NetworkPolicies aus derselben Lieferung folgen in Drill 6):

# chart/notes/templates/gateway.yaml – Stand Ende Tag 11
{{- if .Values.gateway.enabled }}
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: notes
  labels:
    {{- include "notes.labels" (dict "ctx" $ "name" "gateway") | nindent 4 }}
spec:
  gatewayClassName: {{ .Values.gateway.className }}
  listeners:
    - name: http
      protocol: HTTP
      port: 80
      hostname: {{ .Values.gateway.hostname | quote }}
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: web
  labels:
    {{- include "notes.labels" (dict "ctx" $ "name" "web") | nindent 4 }}
spec:
  parentRefs:
    - name: notes
  hostnames:
    - {{ .Values.gateway.hostname | quote }}
  rules:
    - backendRefs:
        - name: web
          port: 3000
{{- end }}
  • Der Listener nimmt nur Anfragen für notes.localhost an Port 80 an. Port 80 ist der Port des Envoy-Service; der NodePort 30080 kommt aus dem EnvoyProxy-Patch.
  • Die Route hängt sich per parentRefs an das Gateway und schickt alles an den Service web. Ohne matches gilt sie für jeden Pfad.
  • web wird ClusterIP: Der NodePort 30080 gehört ab jetzt dem Gateway.
helm lint chart/notes | tail -1
helm template notes chart/notes -n notes \
  | kubectl apply --dry-run=server -f - 2>/dev/null | grep created
helm upgrade notes chart/notes -n notes --wait | tail -3
kubectl get svc/web gateway/notes httproute/web

Erwartet (gekürzt):

1 chart(s) linted, 0 chart(s) failed
networkpolicy.networking.k8s.io/default-deny-ingress created (server dry run)
networkpolicy.networking.k8s.io/web-from-gateway created (server dry run)
networkpolicy.networking.k8s.io/api-from-clients created (server dry run)
networkpolicy.networking.k8s.io/db-from-api created (server dry run)
gateway.gateway.networking.k8s.io/notes created (server dry run)
httproute.gateway.networking.k8s.io/web created (server dry run)
pod/notes-test-api created (server dry run)
notes 0.2.0 ist im Namespace notes installiert.
Über das Gateway: http://notes.localhost:30080
Test: helm test notes -n notes
NAME          TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)    AGE
service/web   ClusterIP   10.96.196.80   <none>        3000/TCP   4m

NAME                                      CLASS   ADDRESS      PROGRAMMED   AGE
gateway.gateway.networking.k8s.io/notes   eg      172.18.0.6   True         26s

NAME                                      HOSTNAMES             AGE
httproute.gateway.networking.k8s.io/web   ["notes.localhost"]   26s

2>/dev/null blendet harmlose Meldungen aus (fehlende last-applied-Annotation an den Helm-Objekten, field is immutable beim Hook-Job wie an Tag 10). Weil sich die Chart-Version in den Labels ändert, rollen alle Pods einmal neu; api startet dabei eventuell ein-, zweimal neu, bis db wieder bereit ist (Tag 7).

Fortschritt speichern? Kostenlos registrieren

Drill 4: Die externalTrafficPolicy-Falle

PROGRAMMED True – also los:

curl -sS -m 5 http://notes.localhost:30080/healthz; echo "Exit: $?"

Erwartet:

curl: (28) Operation timed out after 5001 milliseconds with 0 bytes received
Exit: 28

Die Verbindung steht, aber niemand antwortet. Wo läuft Envoy, wie ist sein Service eingestellt?

kubectl -n envoy-gateway-system get pods \
  -o custom-columns='NAME:.metadata.name,NODE:.spec.nodeName'
c='NAME:.metadata.name,TYPE:.spec.type'
kubectl -n envoy-gateway-system get svc \
  -l gateway.envoyproxy.io/owning-gateway-name=notes \
  -o custom-columns="$c,POLICY:.spec.externalTrafficPolicy"

Erwartet (gekürzt):

NAME                                          NODE
envoy-gateway-6776489b4b-rnzg5                lab-worker
envoy-notes-notes-3aa9e90e-646c5fd4cc-88ss8   lab-worker2
NAME                         TYPE       POLICY
envoy-notes-notes-3aa9e90e   NodePort   Local

Envoy Gateway setzt externalTrafficPolicy: Local: Ein Node leitet Verkehr von außen nur an Pods auf sich selbst weiter. Port 30080 kommt bei kind aber immer am Control-Plane-Node an, und dort läuft kein Envoy. Mit Cluster darf jeder Node an jeden Envoy-Pod weiterreichen. Ergänze im EnvoyProxy-Patch zwei Zeilen:

# k8s/gateway.yaml (Ausschnitt) – Stand Ende Tag 11
            spec:
              # Standard ist Local: dann antwortet nur ein Node, auf dem Envoy läuft.
              externalTrafficPolicy: Cluster
              ports:
                - port: 80
                  nodePort: 30080

Die vollständige Datei liegt in code/tag11/notes/k8s/gateway.yaml:

cp "$LAB/code/tag11/notes/k8s/gateway.yaml" k8s/
kubectl diff -f k8s/gateway.yaml | grep -E '^[-+] '
kubectl apply -f k8s/gateway.yaml
kubectl -n envoy-gateway-system get svc \
  -l gateway.envoyproxy.io/owning-gateway-name=notes \
  -o custom-columns='NAME:.metadata.name,POLICY:.spec.externalTrafficPolicy'
curl -sS -m 5 http://notes.localhost:30080/healthz; echo
curl -s http://notes.localhost:30080/api/notes | jq -c 'map(.text)'

Erwartet (gekürzt, die Notizen stammen aus Tag 10):

-  generation: 1
+  generation: 2
+              externalTrafficPolicy: Cluster
envoyproxy.gateway.envoyproxy.io/nodeport configured
gatewayclass.gateway.networking.k8s.io/eg unchanged
NAME                         POLICY
envoy-notes-notes-3aa9e90e   Cluster
ok
["Postgres eins","Postgres zwei","Postgres drei","Kontrollpunkt 8"]

Envoy Gateway übernimmt die Änderung am EnvoyProxy sofort in den Service. Die Notizen kommen jetzt über Envoy → web → api → Postgres. http://notes.localhost:30080 funktioniert auch im Browser.

Tipp: curl auf dem Mac löst *.localhost selbst nach 127.0.0.1 auf, ohne /etc/hosts. Tut es das bei dir nicht (ältere curl-Versionen, andere Werkzeuge), setz den Host-Header von Hand: curl -H 'Host: notes.localhost' localhost:30080/… oder curl --resolve notes.localhost:30080:127.0.0.1 http://notes.localhost:30080/….

Ein Test im Node selbst (docker exec lab-control-plane curl … 127.0.0.1:30080) hätte schon vorher ok geliefert – Verkehr vom Node selbst behandelt kube-proxy anders. Darum täuscht ein Test im Node: Prüfe immer den Weg, den auch der Nutzer nimmt.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Hostnamen und 404

Das Gateway entscheidet nach dem Host-Header:

curl -s -o /dev/null -w '%{http_code}\n' localhost:30080/healthz
curl -si -H 'Host: falsch.localhost' localhost:30080/healthz
curl -si -H 'Host: notes.localhost' localhost:30080/healthz | head -2
curl -s http://notes.localhost:30080/api/notes -H 'Content-Type: application/json' \
  -d '{"text":"über das Gateway"}'; echo

Erwartet (gekürzt):

404
HTTP/1.1 404 Not Found
date: Fri, 30 Oct 2026 15:09:03 GMT
content-length: 0

HTTP/1.1 200 OK
x-powered-by: Express
{"id":"68be9f2b-…","text":"über das Gateway"}

Für localhost und falsch.localhost gibt es weder Listener noch Route, also antwortet Envoy selbst mit einem leeren 404. Die 200 mit x-powered-by: Express kommt von notes-web. Den Zustand von Gateway und Route zeigen ihre Conditions:

kubectl get gateway notes \
  -o jsonpath='{range .status.conditions[*]}{.type}={.status} {end}'; echo
kubectl get httproute web \
  -o jsonpath='{range .status.parents[0].conditions[*]}{.type}={.status} {end}'; echo

Erwartet:

Accepted=True Programmed=True
Accepted=True ResolvedRefs=True

ResolvedRefs=False hieße: Der Service in backendRefs existiert nicht oder der Port stimmt nicht. Das ist die erste Stelle, an der du bei einem 404 oder 500 nachsiehst.

Fortschritt speichern? Kostenlos registrieren

Drill 6: NetworkPolicy – alles zu, dann gezielt auf

Das Upgrade aus Drill 3 hat auch vier NetworkPolicies angelegt. kindnet, das Pod-Netz von kind, setzt sie durch. Die Vorlage (Auszug, vollständig in code/tag11/notes/chart/notes/templates/networkpolicy.yaml):

# chart/notes/templates/networkpolicy.yaml (Auszug) – Stand Ende Tag 11
# 1. Alles Eingehende im Namespace verbieten …
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-ingress
spec:
  podSelector: {}
  policyTypes: [Ingress]
---
# 2. … web nur vom Gateway
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: web-from-gateway
spec:
  podSelector:
    matchLabels: {app.kubernetes.io/name: web}
  ingress:
    - from:
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: {{ .Values.networkPolicy.gatewayNamespace }}
        - podSelector:
            matchLabels: {app.kubernetes.io/name: test}
      ports:
        - port: 3000
  • podSelector: {} wählt alle Pods im Namespace; ohne ingress-Regel ist damit jeder eingehende Verkehr verboten.
  • Policies addieren sich: web darf zusätzlich aus envoy-gateway-system und vom Helm-Test-Pod angesprochen werden. Zwei Einträge unter from sind ein Oder.
  • Nach demselben Muster: api-from-clients (api nur von web, worker, test, Port
    1. und db-from-api (db nur von api und migrate, Port 5432).
  • Ausgehender Verkehr (Egress) bleibt offen; DNS funktioniert also weiter.
kubectl get networkpolicy
kubectl describe networkpolicy api-from-clients | sed -n '/^Spec/,$p'

Erwartet (gekürzt):

NAME                   POD-SELECTOR                 AGE
api-from-clients       app.kubernetes.io/name=api   2m38s
db-from-api            app.kubernetes.io/name=db    2m38s
default-deny-ingress   <none>                       2m38s
web-from-gateway       app.kubernetes.io/name=web   2m38s
Spec:
  PodSelector:     app.kubernetes.io/name=api
  Allowing ingress traffic:
    To Port: 8080/TCP
    From:
      PodSelector: app.kubernetes.io/name in (test,web,worker)
  Not affecting egress traffic
  Policy Types: Ingress

Fortschritt speichern? Kostenlos registrieren

Drill 7: Beweis mit einem fremden Pod

Eine Policy, die du nicht getestet hast, ist eine Vermutung. Ein Pod im Namespace default spielt den Eindringling:

kubectl -n default run fremd --image=busybox:1.37 --restart=Never -- sleep 3600
kubectl -n default wait --for=condition=Ready pod/fremd --timeout=120s
kubectl -n default exec fremd -- wget -qO- -T 3 http://api.notes:8080/version
kubectl -n default exec fremd -- wget -qO- -T 3 http://web.notes:3000/healthz

Erwartet:

pod/fremd created
pod/fremd condition met
wget: download timed out
command terminated with exit code 1
wget: download timed out
command terminated with exit code 1

Kein Connection refused wie bei einem leeren Service (Tag 3), sondern ein Timeout: Die Pakete werden still verworfen. Jetzt die erlaubten und verbotenen Wege von innen:

kubectl exec deploy/web -- wget -qO- -T 3 http://api:8080/version
kubectl exec deploy/web -- nc -z -w 3 db 5432; echo "web → db: Exit $?"
kubectl logs deploy/worker --tail 1
kubectl get pods
helm test notes -n notes | grep Phase

Erwartet (gekürzt):

0.2.0
command terminated with exit code 1
web → db: Exit 1
summary: 5 notes, 11 words
NAME                      READY   STATUS      RESTARTS       AGE
api-646785c9b8-46xbl      1/1     Running     0              95s
api-646785c9b8-fs2l9      1/1     Running     2 (108s ago)   113s
api-646785c9b8-hrrmd      1/1     Running     0              91s
db-0                      1/1     Running     0              110s
…
web-7955fff6b-wjv6q       1/1     Running     0              113s
worker-847b98cbbd-dn8fp   1/1     Running     0              112s
Phase:          Succeeded

web darf zur api, aber nicht zur Datenbank; worker zählt weiter; alle Pods bleiben Ready. Die Probes des Kubelets sind von NetworkPolicies ausgenommen. Den Pod fremd brauchst du in der Challenge noch.

Fortschritt speichern? Kostenlos registrieren

Drill 8: kubectl debug unter restricted

notes-api ist scratch: keine Shell, kein ps (Tag 1).

POD=$(kubectl get pods -l app.kubernetes.io/name=api -o name | head -1)
kubectl exec "$POD" -- sh

Erwartet (gekürzt):

error: Internal error occurred: … exec: "sh": executable file not found in $PATH

Also ein Debug-Container mit busybox, der die Prozesse des Containers api sieht:

kubectl debug -it "$POD" --image=busybox:1.37 --target=api -- sh

Erwartet (gekürzt):

Targeting container "api". If you don't see processes from this container it may …
Defaulting debug container name to debugger-js86b.
Error from server (Forbidden): pods "api-646785c9b8-46xbl" is forbidden: violates
PodSecurity "restricted:latest": allowPrivilegeEscalation != false (…), unrestricted
capabilities (… must not include "SYS_PTRACE" in securityContext.capabilities.add)

Das Standardprofil general fügt SYS_PTRACE hinzu – das verbietet restricted (Tag 8). Das Profil restricted setzt die passenden Felder:

kubectl debug -it "$POD" --image=busybox:1.37 --target=api --profile=restricted -- sh

Erwartet (gekürzt; kubectl wartet danach, brich mit Ctrl-C ab):

Targeting container "api". …
Defaulting debug container name to debugger-bwhx9.
Warning: container debugger-bwhx9: container has runAsNonRoot and image will run as
root (pod: "api-646785c9b8-46xbl_notes(…)", container: debugger-bwhx9)
kubectl get "$POD" \
  -o jsonpath='{.status.ephemeralContainerStatuses[*].state.waiting.reason}'; echo
cat "$LAB/code/tag11/debug-user.yaml"

Erwartet:

CreateContainerConfigError
# debug-user.yaml – Ergänzung für kubectl debug --custom (Tag 11)
# busybox läuft sonst als root, runAsNonRoot im Pod verbietet das.
securityContext:
  runAsUser: 65532

Dieselbe Falle wie an Tag 8: busybox läuft als root. --custom ergänzt die Container-Definition des Profils um eine feste UID:

cp "$LAB/code/tag11/debug-user.yaml" .
kubectl debug -it "$POD" --image=busybox:1.37 --target=api --profile=restricted \
  --custom=debug-user.yaml -- sh

Im Debug-Container:

id
ps
ls -l /proc/1/root/etc/notes/
cat /proc/1/root/etc/notes/api-key; echo
wget -qO- localhost:8080/version
ls /proc/1/root/
exit

Erwartet (gekürzt):

uid=65532 gid=0(root) groups=0(root)
PID   USER     TIME  COMMAND
    1 65532     0:02 /notes-api
   41 65532     0:00 sh
   55 65532     0:00 ps
total 0
lrwxrwxrwx    1 root     root            14 Oct 30 15:08 api-key -> ..data/api-key
lrwxrwxrwx    1 root     root            13 Oct 30 15:08 db-url -> ..data/db-url
lab-api-key-123
0.2.0
dev           notes-api     product_name  sys
etc           proc          product_uuid
Session ended, the ephemeral container will not be restarted but may be reattached …
  • --target=api teilt den Prozess-Namespace: PID 1 ist /notes-api, und über /proc/1/root siehst du sein Dateisystem samt Secret-Dateien.
  • localhost ist derselbe Pod: Der Debug-Container teilt das Netz der api.
  • Ephemeral Container lassen sich nicht entfernen. Sie verschwinden mit dem Pod:
kubectl get "$POD" -o jsonpath='{.spec.ephemeralContainers[*].name}'; echo
kubectl rollout restart deploy/api && kubectl rollout status deploy/api

Erwartet (gekürzt):

debugger-bwhx9 debugger-r68kr
deployment.apps/api restarted
…
deployment "api" successfully rolled out

Sicherheit: Wer kubectl debug auf einen Pod darf, liest dessen Secrets und Prozesse. Das Recht dahinter ist patch auf pods/ephemeralcontainers – vergib es so sparsam wie exec.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

kubectl get gateway notes

Erwartet: PROGRAMMED True.

NAME    CLASS   ADDRESS      PROGRAMMED   AGE
notes   eg      172.18.0.3   True         28s
curl -s http://notes.localhost:30080/healthz; echo

Erwartet: notes antwortet über das Gateway.

ok
curl -s -i -H 'Host: falsch.localhost' localhost:30080/healthz | head -1

Erwartet: Ein falscher Host bekommt 404.

HTTP/1.1 404 Not Found
kubectl get networkpolicy

Erwartet: die vier Policies aus dem Chart (mehr, falls die Challenge-Policy noch da ist).

NAME                   POD-SELECTOR                 AGE
api-from-clients       app.kubernetes.io/name=api   30s
db-from-api            app.kubernetes.io/name=db    30s
default-deny-ingress   <none>                       30s
web-from-gateway       app.kubernetes.io/name=web   30s
kubectl exec deploy/web -- nc -z -w 3 db 5432

Erwartet: web kommt nicht an die Datenbank.

command terminated with exit code 1

Challenge

Der Pod fremd aus Drill 7 soll die api erreichen dürfen, aber weiterhin nicht web. Ändere dafür nichts am Chart und an den vorhandenen Policies. Beweise beides, nimm die Freigabe wieder zurück und räum fremd ab.

Hinweis: Eine zusätzliche Policy reicht; namespaceSelector und podSelector im selben from-Eintrag bedeuten Und.

Lösung

cat > k8s/api-from-fremd.yaml <<'EOF'
# k8s/api-from-fremd.yaml – Challenge Tag 11 (wieder löschen)
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-from-fremd
  namespace: notes
spec:
  podSelector:
    matchLabels: {app.kubernetes.io/name: api}
  ingress:
    - from:
        - namespaceSelector:
            matchLabels: {kubernetes.io/metadata.name: default}
          podSelector:
            matchLabels: {run: fremd}
      ports:
        - port: 8080
EOF
kubectl apply --dry-run=server -f k8s/api-from-fremd.yaml
kubectl apply -f k8s/api-from-fremd.yaml
kubectl -n default get pod fremd --show-labels
kubectl -n default exec fremd -- wget -qO- -T 3 http://api.notes:8080/version
kubectl -n default exec fremd -- wget -qO- -T 3 http://web.notes:3000/healthz
kubectl delete -f k8s/api-from-fremd.yaml && rm k8s/api-from-fremd.yaml
kubectl -n default exec fremd -- wget -qO- -T 3 http://api.notes:8080/version
kubectl -n default delete pod fremd

Erwartet (gekürzt):

networkpolicy.networking.k8s.io/api-from-fremd created (server dry run)
networkpolicy.networking.k8s.io/api-from-fremd created
NAME    READY   STATUS    RESTARTS   AGE   LABELS
fremd   1/1     Running   0          53s   run=fremd
0.2.0
wget: download timed out
command terminated with exit code 1
networkpolicy.networking.k8s.io "api-from-fremd" deleted from notes namespace
wget: download timed out
command terminated with exit code 1
pod "fremd" deleted from default namespace

kubectl run setzt das Label run=fremd. Die neue Policy erweitert nur die Freigaben der api; für web gilt weiter web-from-gateway. Mit - namespaceSelector und - podSelector als zwei Einträge hätte jeder Pod aus default oder jeder Pod mit run=fremd aus notes Zugang bekommen.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • TLS gehört ans Gateway: ein HTTPS-Listener mit certificateRefs auf ein Secret, das cert-manager automatisch ausstellt und erneuert. Mehr in „Gateway API zum Anfassen”.
  • Davor steht ein echter LoadBalancer (Cloud, MetalLB, kube-vip) statt eines NodePorts; dann wird auch externalTrafficPolicy: Local sinnvoll, weil es die Client-IP erhält.
  • Default deny auch für Egress, mit Freigaben für DNS (kube-dns, Port 53) und die Datenbank. Wer Policies für alle Namespaces erzwingen will, nimmt Kyverno – siehe „Kyverno & NetworkPolicies zum Anfassen”.
  • Nicht jedes CNI setzt NetworkPolicies durch. Prüfe das wie in Drill 7 mit einem fremden Pod, bevor du dich darauf verlässt.
  • kubectl debug bleibt die Ausnahme: Rechte auf pods/ephemeralcontainers nur für Bereitschaft und mit Audit-Log; Debug-Images aus der eigenen Registry.