Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 18: Anwendung anbinden

Ziel: notes-api läuft in einem eigenen Namespace gegen pg-notes – mit getrennter Migrations- und Laufzeitrolle, TLS verify-full, über den Pooler, überlebt einen Switchover und darf als Einzige an die Datenbank. · Dauer: ca. 80 min · Voraussetzung: Tag 2, Tag 17

Briefing

  • Zwei Rollen: Der Owner (notes_app) darf das Schema ändern und führt die Migration aus; die Laufzeitrolle (tag18_api) darf nur lesen und einfügen.
  • Secrets gelten nur im eigenen Namespace: Die App in tag18 bekommt eine eigene Verbindungs-URI und das CA-Zertifikat von pg-notes.
  • notes-api kennt genau eine Datenbank-URL. Leselast über -ro braucht einen zweiten Client – hier ein psql-Pod.
  • Cilium setzt NetworkPolicies durch: nur die App kommt an Port 5432.
 tag18                                   tag14
 notes-migrate (Job, notes_app) ----.
 notes-api (tag18_api) --TLS--> pg-notes-pooler-rw --> pg-notes-rw (Primary)
 leser (tag18_api) ------TLS--> pg-notes-pooler-ro --> pg-notes-ro (Replicas)
 last (curl-Schleife) --> Service notes-api
mkdir -p ~/pg/tag18 && cp ~/.kube/config ~/pg/tag18/.kc
export KUBECONFIG=~/pg/tag18/.kc
kubectl create namespace tag18
kubectl apply -f ~/pg/tag14/psql-client.yaml

Drill 1: Laufzeitrolle

Wie an Tag 17 per DatabaseRole; die Rechte auf die Tabelle vergibt der Owner:

kubectl create secret generic tag18-api-pw -n tag14 \
  --type=kubernetes.io/basic-auth \
  --from-literal=username=tag18_api --from-literal=password=lab-api-123
cat > ~/pg/tag18/api-role.yaml <<'EOF'
apiVersion: postgresql.cnpg.io/v1
kind: DatabaseRole
metadata:
  name: tag18-api
  namespace: tag14
spec:
  cluster:
    name: pg-notes
  name: tag18_api
  login: true
  connectionLimit: 20
  databaseRoleReclaimPolicy: delete
  passwordSecret:
    name: tag18-api-pw
EOF
kubectl apply -f ~/pg/tag18/api-role.yaml
kubectl get databaserole -n tag14

Warte, bis APPLIED auf true steht (rund 40 s, siehe Tag 17), dann:

kubectl exec -n tag14 psql-client -- psql \
  -c 'GRANT SELECT, INSERT ON notes TO tag18_api' -c '\dp notes'

Erwartet (gekürzt):

NAME        AGE   CLUSTER    PG NAME     APPLIED   MESSAGE
tag18-api   47s   pg-notes   tag18_api   true
GRANT
                                  Access privileges
 Schema | Name  | Type  |      Access privileges       | ...
--------+-------+-------+------------------------------+ ...
 public | notes | table | notes_app=arwdDxtm/notes_app+| ...
        |       |       | tag18_api=ar/notes_app       | ...

ar = INSERT (append) und SELECT (read). Kein UPDATE, kein DELETE, kein CREATE im Schema.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Secrets für die App

Das Secret pg-notes-app liefert die fertige URI des Owners – ohne TLS-Parameter. Für verify-full hängst du sslmode und den Pfad zum CA-Zertifikat an:

kubectl get secret pg-notes-app -n tag14 -o jsonpath='{.data.uri}' | base64 -d \
  | sed -E 's/:[^:@]+@/:***@/'; echo
kubectl get secret pg-notes-ca -n tag14 -o jsonpath='{.data.ca\.crt}' | base64 -d \
  > ~/pg/tag18/ca.crt
kubectl create secret generic pg-notes-ca -n tag18 \
  --from-file=ca.crt=$HOME/pg/tag18/ca.crt
TLS='sslmode=verify-full&sslrootcert=/etc/pg-ca/ca.crt'
OWNER=$(kubectl get secret pg-notes-app -n tag14 -o jsonpath='{.data.uri}' | base64 -d)
kubectl create secret generic notes-db-owner -n tag18 --from-literal=uri="$OWNER?$TLS"
kubectl create secret generic notes-db-api -n tag18 --from-literal=uri=\
"postgresql://tag18_api:[email protected]:5432/notes?$TLS"
kubectl create secret generic notes-api-key -n tag18 --from-literal=key=lab-key-123
kubectl get secret -n tag18

Erwartet:

postgresql://notes_app:***@pg-notes-rw.tag14:5432/notes
secret/pg-notes-ca created
secret/notes-db-owner created
secret/notes-db-api created
secret/notes-api-key created
NAME             TYPE     DATA   AGE
notes-api-key    Opaque   1      0s
notes-db-api     Opaque   1      0s
notes-db-owner   Opaque   1      0s
pg-notes-ca      Opaque   1      1s

Der Host pg-notes-rw.tag14 funktioniert über Namespaces hinweg und steht im Server-Zertifikat. notes-api liest die URI aus der Datei in NOTES_DB_URL_FILE – das Passwort taucht so weder in env noch in kubectl describe auf.

Achtung: Die kopierten Secrets folgen einer Passwort-Rotation nicht. In Produktion übernimmt das ein Secret-Operator (External Secrets, Reflector) oder die App läuft im Namespace der Datenbank.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Migration als Job

Zuerst absichtlich mit der Laufzeitrolle:

cat > ~/pg/tag18/migrate.yaml <<'EOF'
apiVersion: batch/v1
kind: Job
metadata:
  name: notes-migrate
  namespace: tag18
spec:
  backoffLimit: 0
  ttlSecondsAfterFinished: 3600
  template:
    metadata:
      labels:
        app: notes-migrate
    spec:
      restartPolicy: Never
      containers:
      - name: migrate
        image: ghcr.io/thomaszachmann/notes-api:0.5.1
        args: ["migrate"]
        env:
        - name: NOTES_DB_URL_FILE
          value: /etc/notes-db/uri
        volumeMounts:
        - {name: db, mountPath: /etc/notes-db, readOnly: true}
        - {name: ca, mountPath: /etc/pg-ca, readOnly: true}
        resources:
          requests: {cpu: 10m, memory: 16Mi}
          limits: {memory: 64Mi}
      volumes:
      - name: db
        secret: {secretName: notes-db-api}
      - name: ca
        secret: {secretName: pg-notes-ca}
EOF
kubectl apply -f ~/pg/tag18/migrate.yaml
kubectl wait --for=condition=Failed job/notes-migrate -n tag18 --timeout=60s
kubectl logs job/notes-migrate -n tag18

Erwartet:

job.batch/notes-migrate created
job.batch/notes-migrate condition met
time=2026-11-19T06:35:22.273Z level=ERROR msg="migration failed" err="ERROR: permission
denied for schema public (SQLSTATE 42501)"

Dieselbe Falle wie an Tag 2: CREATE TABLE IF NOT EXISTS prüft erst das CREATE-Recht im Schema – auch wenn die Tabelle schon existiert. Richtig ist der Owner:

kubectl delete job notes-migrate -n tag18
sed -i 's/secretName: notes-db-api/secretName: notes-db-owner/' ~/pg/tag18/migrate.yaml
kubectl apply -f ~/pg/tag18/migrate.yaml
kubectl wait --for=condition=Complete job/notes-migrate -n tag18 --timeout=60s
kubectl logs job/notes-migrate -n tag18

Erwartet:

job.batch "notes-migrate" deleted from tag18 namespace
job.batch/notes-migrate created
job.batch/notes-migrate condition met
time=2026-11-19T06:35:27.303Z level=INFO msg="migration complete" table=notes

Bei CNPG ist notes_app Owner der Datenbank und darf deshalb im Schema public anlegen (seit PG 15 gehört public der Rolle pg_database_owner). Der Job läuft vor jedem Rollout; die App selbst bekommt das Owner-Passwort nie zu sehen.

Fortschritt speichern? Kostenlos registrieren

Drill 4: notes-api deployen

cat > ~/pg/tag18/notes-api.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: notes-api
  namespace: tag18
spec:
  replicas: 1
  selector:
    matchLabels: {app: notes-api}
  template:
    metadata:
      labels: {app: notes-api}
    spec:
      containers:
      - name: api
        image: ghcr.io/thomaszachmann/notes-api:0.5.1
        ports:
        - {name: http, containerPort: 8080}
        env:
        - name: NOTES_DB_URL_FILE
          value: /etc/notes-db/uri
        - name: NOTES_API_KEY_FILE
          value: /etc/notes-key/key
        volumeMounts:
        - {name: db, mountPath: /etc/notes-db, readOnly: true}
        - {name: ca, mountPath: /etc/pg-ca, readOnly: true}
        - {name: key, mountPath: /etc/notes-key, readOnly: true}
        readinessProbe:
          httpGet: {path: /healthz, port: http}
          periodSeconds: 5
        resources:
          requests: {cpu: 10m, memory: 16Mi}
          limits: {memory: 64Mi}
      volumes:
      - name: db
        secret: {secretName: notes-db-api}
      - name: ca
        secret: {secretName: pg-notes-ca}
      - name: key
        secret: {secretName: notes-api-key}
---
apiVersion: v1
kind: Service
metadata:
  name: notes-api
  namespace: tag18
spec:
  selector: {app: notes-api}
  ports:
  - {name: http, port: 80, targetPort: http}
EOF
kubectl apply -f ~/pg/tag18/notes-api.yaml
kubectl rollout status deploy/notes-api -n tag18
kubectl logs deploy/notes-api -n tag18

Erwartet:

deployment.apps/notes-api created
service/notes-api created
deployment "notes-api" successfully rolled out
time=2026-11-19T06:35:44.323Z level=INFO msg="api key loaded" source=file
time=2026-11-19T06:35:44.418Z level=INFO msg="store ready" store=postgres
time=2026-11-19T06:35:44.420Z level=INFO msg=listening addr=:8080 version=0.5.1 pid=1

Ein Client-Pod mit curl (Image curlimages/curl:8.17.0, multi-arch):

kubectl run curl -n tag18 --image=curlimages/curl:8.17.0 --restart=Never \
  --command -- sleep infinity
kubectl wait --for=condition=Ready pod/curl -n tag18
kubectl exec -n tag18 curl -- curl -s -X POST -H 'X-API-Key: lab-key-123' \
  -d '{"text":"Tag 18: aus der App"}' http://notes-api/notes; echo
kubectl exec -n tag18 curl -- curl -s http://notes-api/metrics | grep build_info
kubectl cnpg psql pg-notes -n tag14 -- -c "SELECT usename, client_addr, ssl
  FROM pg_stat_activity JOIN pg_stat_ssl USING (pid) WHERE usename = 'tag18_api'"

Erwartet (gekürzt):

{"id":"ff511ac9-5a9a-4fda-993c-6b7c1d296cb7","text":"Tag 18: aus der App"}
notes_build_info{store="postgres",version="0.5.1"} 1
  usename  | client_addr | ssl
-----------+-------------+-----
 tag18_api | 10.0.1.220  | t

Die Verbindung kommt direkt vom App-Pod (10.0.1.220) und ist verschlüsselt. notes-api hält höchstens 5 Verbindungen offen (SetMaxOpenConns(5) im Code).

Fortschritt speichern? Kostenlos registrieren

Drill 5: Über den Pooler

Nur den Host in der URI tauschen:

kubectl create secret generic notes-db-api -n tag18 --dry-run=client -o yaml \
  --from-literal=uri="postgresql://tag18_api:[email protected]\
:5432/notes?$TLS" | kubectl apply -f -
kubectl rollout restart deploy/notes-api -n tag18
kubectl get pods -n tag18 -l app=notes-api
kubectl logs -n tag18 -l app=notes-api --tail=1 | grep -o 'tls: .*'

Erwartet (gekürzt, nach etwa 20 s):

secret/notes-db-api configured
deployment.apps/notes-api restarted
NAME                         READY   STATUS    RESTARTS      AGE
notes-api-6d5cb5b4bf-kpd79   0/1     Error     2 (18s ago)   21s
notes-api-dbbc9f8f6-w4vl7    1/1     Running   0             3m33s
tls: failed to verify certificate: x509: certificate is valid for pg-notes-rw,
pg-notes-rw.tag14, ..., pg-notes-ro.tag14.svc.cluster.local, not
pg-notes-pooler-rw.tag14"

Der Pooler zeigt das Server-Zertifikat des Clusters, und das kennt nur die drei Cluster-Services. Der alte Pod läuft dank Rolling Update weiter. Die Pooler-Namen kommen über serverAltDNSNames dazu:

kubectl patch cluster pg-notes -n tag14 --type merge -p '{"spec":{"certificates":{
  "serverAltDNSNames":["pg-notes-pooler-rw","pg-notes-pooler-rw.tag14",
  "pg-notes-pooler-rw.tag14.svc","pg-notes-pooler-ro","pg-notes-pooler-ro.tag14",
  "pg-notes-pooler-ro.tag14.svc"]}}}'
kubectl get secret pg-notes-server -n tag14 -o jsonpath='{.data.tls\.crt}' \
  | base64 -d | openssl x509 -noout -ext subjectAltName | tr ',' '\n' | grep pooler

Erwartet (nach etwa 30 s):

cluster.postgresql.cnpg.io/pg-notes patched
    DNS:pg-notes-pooler-ro
 DNS:pg-notes-pooler-ro.tag14
 DNS:pg-notes-pooler-ro.tag14.svc
 DNS:pg-notes-pooler-rw
 DNS:pg-notes-pooler-rw.tag14
 DNS:pg-notes-pooler-rw.tag14.svc

Die PostgreSQL-Instanzen laden das neue Zertifikat ohne Neustart. Die Pooler-Pods übernahmen es im Labor erst nach einem Neustart:

kubectl delete pod -n tag14 -l cnpg.io/poolerName
kubectl wait --for=condition=Ready pod -n tag14 -l cnpg.io/poolerName
kubectl rollout restart deploy/notes-api -n tag18
kubectl rollout status deploy/notes-api -n tag18
kubectl cnpg psql pg-notes -n tag14 -- -Atc "SELECT usename, client_addr, count(*)
  FROM pg_stat_activity WHERE usename = 'tag18_api' GROUP BY 1, 2"
kubectl get pods -n tag14 -l cnpg.io/poolerName=pg-notes-pooler-rw \
  -o custom-columns=NAME:.metadata.name,IP:.status.podIP

Erwartet (gekürzt):

pod "pg-notes-pooler-ro-8bc8fc98b-gxkzr" deleted from tag14 namespace
pod "pg-notes-pooler-rw-598f6fc974-brjvx" deleted from tag14 namespace
...
deployment "notes-api" successfully rolled out
tag18_api|10.0.1.156|1
NAME                                  IP
pg-notes-pooler-rw-598f6fc974-9l28z   10.0.1.156

Jetzt kommt tag18_api vom Pooler-Pod. Bei vielen App-Replicas bündelt der Pooler deren Verbindungen (Tag 17, Drill 2).

Fortschritt speichern? Kostenlos registrieren

Drill 6: Lesen über die Replicas

notes-api kann nur eine URL. Ein Lese-Client nutzt den ro-Pooler:

kubectl create secret generic notes-db-ro -n tag18 --from-literal=uri=\
"postgresql://tag18_api:[email protected]:5432/notes?$TLS"
cat > ~/pg/tag18/leser.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: leser
  namespace: tag18
  labels: {app: notes-leser}
spec:
  restartPolicy: Never
  containers:
  - name: psql
    image: ghcr.io/cloudnative-pg/postgresql:18.7-minimal-trixie
    command: ["sh", "-c"]
    env:
    - {name: PGCONNECT_TIMEOUT, value: "5"}
    args:
    - psql "$(cat /etc/notes-db/uri)" -c "SELECT pg_is_in_recovery(),
      inet_server_addr(), count(*) AS notizen, max(created_at)::time(0) AS neueste
      FROM notes"
    volumeMounts:
    - {name: db, mountPath: /etc/notes-db, readOnly: true}
    - {name: ca, mountPath: /etc/pg-ca, readOnly: true}
    resources:
      requests: {cpu: 10m, memory: 16Mi}
      limits: {memory: 64Mi}
  volumes:
  - name: db
    secret: {secretName: notes-db-ro}
  - name: ca
    secret: {secretName: pg-notes-ca}
EOF
kubectl apply -f ~/pg/tag18/leser.yaml
kubectl logs leser -n tag18

Erwartet (gekürzt, nach etwa 10 s):

 pg_is_in_recovery | inet_server_addr | notizen | neueste
-------------------+------------------+---------+----------
 t                 | 10.0.1.107       |     ... | ...

Gelesen wird auf einer Replica. Asynchron heißt: Eine eben geschriebene Notiz kann dort Millisekunden später ankommen – Lesen nach eigenem Schreiben gehört auf -rw.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Switchover unter Last

Eine Schleife schreibt alle 0,2 s eine Notiz und protokolliert den HTTP-Status:

kubectl run last -n tag18 --image=curlimages/curl:8.17.0 --restart=Never --command -- \
  sh -c 'while true; do echo "$(date +%T) $(curl -s -o /dev/null -w %{http_code} -m 2 \
  -X POST -H X-API-Key:lab-key-123 -d "{\"text\":\"last\"}" http://notes-api/notes)"; \
  sleep 0.2; done'
kubectl wait --for=condition=Ready pod/last -n tag18
P=$(kubectl get pods -n tag14 -l cnpg.io/instanceRole=replica \
  -o jsonpath='{.items[0].metadata.name}')
T0=$(date +%T); kubectl cnpg promote pg-notes $P -n tag14

Nach etwa 45 s auswerten – uniq fasst gleiche Status zusammen:

kubectl logs last -n tag18 --since=60s | awk -v t=$T0 '$1 >= t' | uniq -c -f1
kubectl logs -n tag18 -l app=notes-api --since=60s | grep -o 'err=.*' \
  | sort | uniq -c | sort -rn | head -2 | cut -c1-120

Erwartet (gekürzt, über den Pooler):

      7 06:42:35 201
      1 06:42:36 000
     33 06:42:39 500
     31 06:42:49 000
     87 06:42:59 201
     10 err="failed to connect to `user=tag18_api database=notes`: 10.101.110.237:5432
(pg-notes-pooler-rw.tag14): server error: FATAL: server login has been failing,
cached error: connect failed (server_login_retry) (SQLSTATE 08P01)"

Rund 23 s Ausfall: erst 500 (die App meldet Datenbankfehler), dann 000 – /healthz scheitert, die Readiness-Probe nimmt den Pod aus dem Service. Danach heilt alles von selbst; kein Neustart nötig. Im Labor kostete derselbe Switchover direkt über -rw rund 18 s. Der Pooler verlängert die Lücke: Nach einem Fehlschlag merkt sich PgBouncer den Fehler 15 s lang (server_login_retry). Kürzer stellen:

kubectl patch pooler pg-notes-pooler-rw -n tag14 --type merge \
  -p '{"spec":{"pgbouncer":{"parameters":{"server_login_retry":"1"}}}}'
kubectl exec -n tag14 deploy/pg-notes-pooler-rw -c pgbouncer -- \
  psql -h /controller/run -U pgbouncer pgbouncer -Atc 'SHOW CONFIG' \
  | grep server_login_retry
P=$(kubectl get pods -n tag14 -l cnpg.io/instanceRole=replica \
  -o jsonpath='{.items[0].metadata.name}')
T0=$(date +%T); kubectl cnpg promote pg-notes $P -n tag14

Erwartet (Auswertung wie oben nach etwa 45 s):

pooler.postgresql.cnpg.io/pg-notes-pooler-rw patched
server_login_retry|1|15|yes
Node pg-notes-1 in cluster pg-notes will be promoted
      3 06:44:13 201
      2 06:44:13 000
     26 06:44:18 500
    121 06:44:27 201

Jetzt rund 14 s – fast nur noch der Switchover selbst. Die Spalten von SHOW CONFIG: Wert, Standard, änderbar per Reload.

Fortschritt speichern? Kostenlos registrieren

Drill 8: NetworkPolicy

Nur notes-api und der Migrations-Job dürfen aus tag18 an Port 5432. Innerhalb tag14 bleibt alles offen (Replikation, Pooler), dazu Operator und Prometheus:

cat > ~/pg/tag18/netpol.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: pg-notes-zugang
  namespace: tag14
spec:
  podSelector:
    matchLabels:
      cnpg.io/cluster: pg-notes
  policyTypes: [Ingress]
  ingress:
  - from:
    - podSelector: {}
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: cnpg-system
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: monitoring
    ports:
    - port: 9187
    - port: 9127
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: tag18
      podSelector:
        matchExpressions:
        - {key: app, operator: In, values: [notes-api, notes-migrate]}
    ports:
    - port: 5432
EOF
kubectl apply -f ~/pg/tag18/netpol.yaml
kubectl delete pod leser -n tag18
kubectl apply -f ~/pg/tag18/leser.yaml
kubectl exec -n tag18 curl -- curl -s -o /dev/null -w '%{http_code}\n' -X POST \
  -H 'X-API-Key: lab-key-123' -d '{"text":"nach NetworkPolicy"}' http://notes-api/notes
kubectl logs leser -n tag18

Erwartet (logs nach etwa 10 s):

networkpolicy.networking.k8s.io/pg-notes-zugang created
pod "leser" deleted from tag18 namespace
pod/leser created
201
psql: error: connection to server at "pg-notes-pooler-ro.tag14" (10.97.122.93), port
5432 failed: timeout expired

Die App schreibt weiter, der Leser (app=notes-leser) kommt nicht durch. Cilium verwirft still – deshalb PGCONNECT_TIMEOUT. Hubble zeigt den Grund:

cilium hubble port-forward >/dev/null &
hubble observe --from-namespace tag18 --verdict DROPPED --last 2
kill %1

Erwartet (gekürzt):

... tag18/leser:47360 (ID:89021) <> tag14/pg-notes-pooler-ro-...:5432 (ID:68787)
policy-verdict:none INGRESS DENIED (TCP Flags: SYN)
... tag18/leser:47360 (ID:89021) <> tag14/pg-notes-pooler-ro-...:5432 (ID:68787)
Policy denied DROPPED (TCP Flags: SYN)

Ohne Cilium zeigt dein CNI den verworfenen Verkehr mit eigenen Mitteln; Hubble und die folgende CiliumNetworkPolicy entfallen dann.

Der Cluster bleibt gesund – aber kubectl cnpg status meldet jetzt No Primary instance found: Das Plugin fragt den Status-Port 8000 der Instanzen über den API-Server-Proxy ab, und der kommt von cp1. Hubble zeigt die Quelle als 10.0.0.88:58374 (remote-node). Das lässt sich nur mit einer Cilium-Policy erlauben:

cat > ~/pg/tag18/cnp-apiserver.yaml <<'EOF'
apiVersion: cilium.io/v2
kind: CiliumNetworkPolicy
metadata:
  name: pg-notes-apiserver
  namespace: tag14
spec:
  endpointSelector:
    matchLabels:
      cnpg.io/cluster: pg-notes
  ingress:
  - fromEntities:
    - kube-apiserver
    - remote-node
    toPorts:
    - ports:
      - port: "8000"
        protocol: TCP
EOF
kubectl apply -f ~/pg/tag18/cnp-apiserver.yaml
kubectl cnpg status pg-notes -n tag14 | grep -E 'Status:|Working WAL|Primary instance'

Erwartet:

ciliumnetworkpolicy.cilium.io/pg-notes-apiserver created
Primary instance:        pg-notes-1
Status:                  Cluster in healthy state
Working WAL archiving:          OK

Ein Switchover mit beiden Policies lief im Labor genauso wie ohne (17 s Lücke).

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeige, von welcher IP die Verbindungen von tag18_api kommen. Zeitziel: 30 s
  2. Zeige die Datenbank-URL der App ohne Passwort. Zeitziel: 45 s
  3. Zeige, wie viele Notizen die App bisher angelegt hat (laut /metrics). Zeitziel: 30 s
  4. Zeige alle NetworkPolicies, die pg-notes schützen. Zeitziel: 15 s

Lösung

kubectl cnpg psql pg-notes -n tag14 -- -Atc "SELECT client_addr, count(*)
  FROM pg_stat_activity WHERE usename = 'tag18_api' GROUP BY 1"
kubectl get secret notes-db-api -n tag18 -o jsonpath='{.data.uri}' | base64 -d \
  | sed -E 's/:[^:@]+@/:***@/'; echo
kubectl exec -n tag18 curl -- curl -s http://notes-api/metrics | grep '^notes_created'
kubectl get networkpolicy,ciliumnetworkpolicy -n tag14

Erwartet (gekürzt, kann je nach Version abweichen; Zahlen hängen von deiner Last ab):

10.0.1.156|1
postgresql://tag18_api:***@pg-notes-pooler-rw.tag14:5432/notes?sslmode=verify-full&
sslrootcert=/etc/pg-ca/ca.crt
notes_created_total ...
NAME                                              POD-SELECTOR               AGE
networkpolicy.networking.k8s.io/pg-notes-zugang   cnpg.io/cluster=pg-notes   ...
NAME                                                     ...
ciliumnetworkpolicy.cilium.io/pg-notes-apiserver         ...

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Nach dem Aufräumen (geprüft an dessen Ende) bleibt für Tag 19 (Wettkampf) und die Abschlussprüfung genau das stehen: Operator CNPG 1.30.2 und Plugin kubectl cnpg, Barman-Cloud-Plugin 0.16.0, RustFS auf pg2 mit Bucket cnpg-backups, Cluster pg-notes in tag14 (drei Instanzen, WAL-Archiv, ScheduledBackup, zwei Pooler, PodMonitors, Dashboard).

kubectl get deploy -n cnpg-system

Erwartet: barman-cloud und cnpg-controller-manager, je 1/1.

kubectl get cluster,pooler,objectstore,scheduledbackup -n tag14

Erwartet: pg-notes mit 3/3 und Cluster in healthy state, beide Pooler active, pg2-s3, pg-notes-nachts.

kubectl cnpg status pg-notes -n tag14 | grep -E 'Working WAL|Last Successful'

Erwartet: OK und ein Backup von heute.

Von deinem Rechner aus:

ssh [email protected] systemctl is-active rustfs

Erwartet: active.

kubectl get networkpolicy,ciliumnetworkpolicy -n tag14

Erwartet: pg-notes-zugang und pg-notes-apiserver (Drill 8).

Challenge

Ersetze den Migrations-Job durch einen initContainer im Deployment: Er migriert mit dem Owner-Secret, danach startet die App mit der Laufzeitrolle.

Hinweis: Ein initContainer mit args: ["migrate"] und einem zweiten Secret-Volume db-owner; jeder Pod-Start migriert erneut – das ist idempotent.

Lösung

Kopiere notes-api.yaml nach notes-api-init.yaml, füge im Pod-Template vor containers: ein und ergänze das Volume:

      initContainers:
      - name: migrate
        image: ghcr.io/thomaszachmann/notes-api:0.5.1
        args: ["migrate"]
        env:
        - name: NOTES_DB_URL_FILE
          value: /etc/notes-db/uri
        volumeMounts:
        - {name: db-owner, mountPath: /etc/notes-db, readOnly: true}
        - {name: ca, mountPath: /etc/pg-ca, readOnly: true}
        resources:
          requests: {cpu: 10m, memory: 16Mi}
          limits: {memory: 64Mi}
      volumes:
      - name: db-owner
        secret: {secretName: notes-db-owner}
kubectl apply -f ~/pg/tag18/notes-api-init.yaml
kubectl rollout status deploy/notes-api -n tag18
P=$(kubectl get pods -n tag18 -l app=notes-api -o name)
kubectl logs -n tag18 $P -c migrate
kubectl logs -n tag18 $P -c api | tail -2

Erwartet (gekürzt):

...
deployment "notes-api" successfully rolled out
time=2026-11-19T06:56:33.172Z level=INFO msg="migration complete" table=notes
time=2026-11-19T06:56:34.620Z level=INFO msg="store ready" store=postgres
time=2026-11-19T06:56:34.621Z level=INFO msg=listening addr=:8080 version=0.5.1 pid=1

Bequem, aber: Das Owner-Secret liegt jetzt in jedem App-Pod, und zehn Replicas migrieren zehnmal gleichzeitig. Der Job (oder ein Helm-Hook bzw. Argo-CD-PreSync) ist die sauberere Wahl.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

Löschst du die DatabaseRole, solange die Rolle noch Rechte hat, scheitert das – erst nach dem REVOKE verschwindet sie:

kubectl delete namespace tag18
kubectl delete -f ~/pg/tag18/netpol.yaml -f ~/pg/tag18/cnp-apiserver.yaml
kubectl delete -f ~/pg/tag18/api-role.yaml --wait=false
kubectl get databaserole -n tag14

Erwartet (gekürzt):

namespace "tag18" deleted
networkpolicy.networking.k8s.io "pg-notes-zugang" deleted from tag14 namespace
ciliumnetworkpolicy.cilium.io "pg-notes-apiserver" deleted from tag14 namespace
databaserole.postgresql.cnpg.io "tag18-api" deleted from tag14 namespace
NAME        ...   APPLIED   MESSAGE
tag18-api   ...   false     while deleting role tag18_api with role reconciler: ERROR:
role "tag18_api" cannot be dropped because some objects depend on it (SQLSTATE 2BP01)
kubectl exec -n tag14 psql-client -- psql -c 'REVOKE ALL ON notes FROM tag18_api'
kubectl get databaserole -n tag14
kubectl delete secret tag18-api-pw -n tag14
kubectl delete pod psql-client -n tag14

Erwartet (get nach etwa 20 s):

REVOKE
No resources found in tag14 namespace.
secret "tag18-api-pw" deleted from tag14 namespace
pod "psql-client" deleted from tag14 namespace

Pooler (mit server_login_retry=1), serverAltDNSNames, PodMonitors und Dashboard bleiben – Tag 19 baut darauf auf. Nichts aus Tag 18 bleibt zurück:

kubectl get ns tag18
kubectl get networkpolicy,ciliumnetworkpolicy,databaserole -n tag14

Erwartet: NotFound bzw. No resources found.

kubectl cnpg psql pg-notes -n tag14 -- -Atc \
  "SELECT count(*) FROM pg_roles WHERE rolname LIKE 'tag1%'"

Erwartet: 0 – keine Übungsrollen mehr.

Interview-Notiz

  • „Wie bekommt eine App in einem anderen Namespace die Zugangsdaten?“ – Secrets sind namespace-gebunden: kopieren per Secret-Operator oder DatabaseRole plus eigenes Secret; URI per Datei (*_FILE), TLS mit verify-full und CA des Clusters.
  • „Wer führt Migrationen aus?“ – Ein Job (oder Hook) mit der Owner-Rolle vor dem Rollout; die App läuft mit einer Rolle ohne CREATE, nur mit den nötigen GRANTs.
  • „Was merkt die App von einem Failover?“ – 10–25 s Fehler bzw. 503, dann heilt der Verbindungspool von selbst. Retries in der App, Readiness über die DB-Verbindung und beim Pooler ein kurzes server_login_retry verkürzen die Lücke.

Enterprise-Notiz

  • Secrets aus Vault/OpenBao oder External Secrets; dynamische Datenbank-Credentials (Vault Database Secrets Engine) statt fester Passwörter.
  • Migrationen als Pipeline-Schritt (Flyway, Liquibase, Atlas) mit Review; Rollbacks nur vorwärts (expand/contract).
  • Zwei App-Rollen: Schreib-App gegen pooler-rw, Reporting gegen pooler-ro oder einen eigenen Replica-Cluster.
  • Default-deny-NetworkPolicies pro Namespace, Ausnahmen für Operator, Monitoring und API-Server; Prüfung mit Hubble oder cilium policy vor dem Rollout.
  • Client-Zertifikate statt Passwörtern (DatabaseRole.clientCertificate, CNPG-CA oder cert-manager) für Maschinen-zu-Maschinen-Zugriffe.