Tag 18: Anwendung anbinden
Ziel: notes-api läuft in einem eigenen Namespace gegen
pg-notes– mit getrennter Migrations- und Laufzeitrolle, TLSverify-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
tag18bekommt eine eigene Verbindungs-URI und das CA-Zertifikat vonpg-notes. - notes-api kennt genau eine Datenbank-URL. Leselast über
-robraucht einen zweiten Client – hier einpsql-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.yamlDrill 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 tag14Warte, 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 tag18Erwartet:
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 tag18Erwartet:
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 tag18Erwartet:
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 tag18Erwartet:
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 poolerErwartet (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.podIPErwartet (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 tag18Erwartet (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 tag14Nach 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-120Erwartet (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 tag14Erwartet (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 tag18Erwartet (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 %1Erwartet (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
- Zeige, von welcher IP die Verbindungen von
tag18_apikommen. Zeitziel: 30 s - Zeige die Datenbank-URL der App ohne Passwort. Zeitziel: 45 s
- Zeige, wie viele Notizen die App bisher angelegt hat (laut
/metrics). Zeitziel: 30 s - Zeige alle NetworkPolicies, die
pg-notesschü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 tag14Erwartet (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-systemErwartet: barman-cloud und
cnpg-controller-manager, je 1/1.
kubectl get cluster,pooler,objectstore,scheduledbackup -n tag14Erwartet: 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 rustfsErwartet: active.
kubectl get networkpolicy,ciliumnetworkpolicy -n tag14Erwartet: 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 -2Erwartet (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 tag14Erwartet (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 tag14Erwartet (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 tag14Erwartet: 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
DatabaseRoleplus eigenes Secret; URI per Datei (*_FILE), TLS mitverify-fullund 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ötigenGRANTs. - „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_retryverkü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 gegenpooler-rooder einen eigenen Replica-Cluster. - Default-deny-NetworkPolicies pro Namespace, Ausnahmen für Operator,
Monitoring und API-Server; Prüfung mit Hubble oder
cilium policyvor dem Rollout. - Client-Zertifikate statt Passwörtern
(
DatabaseRole.clientCertificate, CNPG-CA oder cert-manager) für Maschinen-zu-Maschinen-Zugriffe.