Tag 17: CNPG: Betrieb
Ziel:
pg-notesbekommt PgBouncer-Pooler für Schreiben und Lesen, Metriken in Prometheus und ein Grafana-Dashboard; Rollen und Datenbanken legst du per CRD an, TLS per cert-manager, und du liest Parameter, Ressourcen und JSON-Logs. · Dauer: ca. 85 min · Voraussetzung: Tag 7, Tag 12, Tag 16
Briefing
Pooler= PgBouncer als Deployment mit eigenem Service, Typrwoderro; Authentifizierung perauth_query, ohne Passwortliste.- Jede Instanz exportiert Metriken auf Port 9187
(
metrics), jeder Pooler auf 9127. DenPodMonitorlegst du selbst an –enablePodMonitorist veraltet. - Rollen:
DatabaseRole(neu in 1.30, empfohlen) odermanaged.rolesim Cluster; Datenbanken:Database. - Alles läuft über das
Cluster-Objekt; der Webhook lehnt Unsinn vorher ab.
mkdir -p ~/pg/tag17 && cp ~/.kube/config ~/pg/tag17/.kc
export KUBECONFIG=~/pg/tag17/.kc
kubectl create namespace tag17
kubectl apply -f ~/pg/tag14/psql-client.yamlDrill 1: Pooler für Schreiben und Lesen
cat > ~/pg/tag17/pooler.yaml <<'EOF'
apiVersion: postgresql.cnpg.io/v1
kind: Pooler
metadata:
name: pg-notes-pooler-rw
namespace: tag14
spec:
cluster:
name: pg-notes
instances: 1
type: rw
pgbouncer:
poolMode: transaction
parameters:
max_client_conn: "200"
default_pool_size: "10"
template:
spec:
containers:
- name: pgbouncer
resources:
requests: {cpu: 10m, memory: 32Mi}
limits: {memory: 64Mi}
---
apiVersion: postgresql.cnpg.io/v1
kind: Pooler
metadata:
name: pg-notes-pooler-ro
namespace: tag14
spec:
cluster:
name: pg-notes
instances: 1
type: ro
pgbouncer:
poolMode: transaction
template:
spec:
containers:
- name: pgbouncer
resources:
requests: {cpu: 10m, memory: 32Mi}
limits: {memory: 64Mi}
EOF
kubectl apply -f ~/pg/tag17/pooler.yaml
kubectl get pooler,svc -n tag14
kubectl get pooler pg-notes-pooler-rw -n tag14 -o jsonpath='{.status.image}{"\n"}'Erwartet (gekürzt, nach etwa 30 s):
pooler.postgresql.cnpg.io/pg-notes-pooler-rw created
pooler.postgresql.cnpg.io/pg-notes-pooler-ro created
NAME AGE CLUSTER TYPE PHASE
pooler.postgresql.cnpg.io/pg-notes-pooler-ro 31s pg-notes ro active
pooler.postgresql.cnpg.io/pg-notes-pooler-rw 31s pg-notes rw active
NAME TYPE CLUSTER-IP ... PORT(S)
service/pg-notes-pooler-ro ClusterIP 10.97.122.93 ... 5432/TCP
service/pg-notes-pooler-rw ClusterIP 10.101.110.237 ... 5432/TCP
service/pg-notes-r ClusterIP 10.103.175.65 ... 5432/TCP
service/pg-notes-ro ClusterIP 10.101.253.25 ... 5432/TCP
service/pg-notes-rw ClusterIP 10.105.222.205 ... 5432/TCP
ghcr.io/cloudnative-pg/pgbouncer:1.26.1
Die Anwendung wechselt nur den Host – Benutzer und Passwort bleiben:
kubectl exec -n tag14 psql-client -- psql -h pg-notes-pooler-rw \
-Atc 'SELECT inet_server_addr(), pg_is_in_recovery(), count(*) FROM notes'
kubectl exec -n tag14 psql-client -- psql -h pg-notes-pooler-ro \
-Atc 'SELECT inet_server_addr(), pg_is_in_recovery(), count(*) FROM notes'
kubectl get pods -n tag14 -l cnpg.io/podRole=instance \
-o custom-columns=NAME:.metadata.name,IP:.status.podIPErwartet (gekürzt):
10.0.1.54|f|1001
10.0.1.107|t|1001
NAME IP
pg-notes-1 10.0.1.107
pg-notes-2 10.0.2.14
pg-notes-3 10.0.1.54
Der rw-Pooler landet auf dem Primary, der
ro-Pooler auf einer Replica. Wie das geht, zeigt die
erzeugte Konfiguration:
kubectl exec -n tag14 deploy/pg-notes-pooler-rw -c pgbouncer -- \
grep -E '^\* =|^pool_mode|^auth_(user|query|dbname)|^client_tls_sslmode' \
/controller/configs/pgbouncer.iniErwartet:
* = host=pg-notes-rw
pool_mode = transaction
auth_user = cnpg_pooler_pgbouncer
auth_query = SELECT usename, passwd FROM public.user_search($1)
auth_dbname = postgres
client_tls_sslmode = prefer
Der Pooler ist nur ein Client der Services -rw bzw.
-ro. Das Passwort prüft er per auth_query als
cnpg_pooler_pgbouncer, angemeldet mit einem
Client-Zertifikat – das hat CNPG beim ersten Pooler angelegt.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Pooling wirkt
50 Clients über den Pooler, gleichzeitig ein Blick auf die Server-Seite:
kubectl exec -n tag14 psql-client -- sh -c \
'echo "SELECT count(*) FROM notes;" > /tmp/q.sql'
kubectl exec -n tag14 psql-client -- pgbench -h pg-notes-pooler-rw -n -c 50 -j 2 \
-T 15 -f /tmp/q.sqlWährend pgbench läuft, in einem zweiten
Terminal:
export KUBECONFIG=~/pg/tag17/.kc
kubectl cnpg psql pg-notes -n tag14 -- -Atc "SELECT usename, client_addr, count(*)
FROM pg_stat_activity WHERE datname = 'notes' GROUP BY 1, 2"
kubectl exec -n tag14 deploy/pg-notes-pooler-rw -c pgbouncer -- \
psql -h /controller/run -U pgbouncer pgbouncer -c 'SHOW POOLS' | cut -c1-80Erwartet (gekürzt):
notes_app|10.0.1.99|10
database | user | cl_active | cl_waiting | ... | sv_active |
-----------+-----------------------+-----------+------------+ ... +-----------+
notes | notes_app | 29 | 21 | ... | 10 |
...
duration: 15 s
number of transactions actually processed: 21111
number of failed transactions: 0 (0.000%)
tps = 1549.431306 (without initial connection time)
50 Clients, aber nur 10 Server-Verbindungen
(default_pool_size) vom Pooler-Pod 10.0.1.99;
der Rest wartet kurz in der Schlange (cl_waiting). Die
Admin-Konsole pgbouncer erreichst du nur im Pod über den
Unix-Socket (peer).
Fortschritt speichern? Kostenlos registrieren
Drill 3: Metriken und PodMonitor
Die Metriken einer Instanz direkt über den API-Server-Proxy:
kubectl get --raw /api/v1/namespaces/tag14/pods/pg-notes-1:9187/proxy/metrics \
| grep -E '^cnpg_collector_(up|fencing_on|pg_wal_archive_status|postgres_version)'Erwartet:
cnpg_collector_fencing_on 0
cnpg_collector_pg_wal_archive_status{value="done"} 40
cnpg_collector_pg_wal_archive_status{value="ready"} 0
cnpg_collector_postgres_version{cluster="pg-notes",full="18.7"} 18.7
cnpg_collector_up{cluster="pg-notes"} 1
Der kps aus Tag 14 liest alle PodMonitors im Cluster
(podMonitorSelector: {}). Das Doku-Beispiel wählt nur
cnpg.io/cluster – das tragen aber auch die Pooler-Pods.
Deshalb zusätzlich cnpg.io/podRole:
cat > ~/pg/tag17/podmonitor.yaml <<'EOF'
apiVersion: monitoring.coreos.com/v1
kind: PodMonitor
metadata:
name: pg-notes
namespace: tag14
spec:
selector:
matchLabels:
cnpg.io/cluster: pg-notes
cnpg.io/podRole: instance
podMetricsEndpoints:
- port: metrics
---
apiVersion: monitoring.coreos.com/v1
kind: PodMonitor
metadata:
name: pg-notes-pooler
namespace: tag14
spec:
selector:
matchExpressions:
- {key: cnpg.io/poolerName, operator: Exists}
podMetricsEndpoints:
- port: metrics
EOF
kubectl apply -f ~/pg/tag17/podmonitor.yamlNach etwa einer Minute fragst du Prometheus – ebenfalls über den API-Server:
P=/api/v1/namespaces/monitoring/services/kps-kube-prometheus-stack-prometheus:9090\
/proxy/api/v1
kubectl get --raw "$P/targets?state=active" | jq -r '.data.activeTargets[]
| select(.labels.namespace=="tag14") | [.scrapePool, .labels.pod, .health] | @tsv'Erwartet:
podMonitor/tag14/pg-notes-pooler/0 pg-notes-pooler-ro-8bc8fc98b-gxkzr up
podMonitor/tag14/pg-notes-pooler/0 pg-notes-pooler-rw-598f6fc974-brjvx up
podMonitor/tag14/pg-notes/0 pg-notes-1 up
podMonitor/tag14/pg-notes/0 pg-notes-2 up
podMonitor/tag14/pg-notes/0 pg-notes-3 up
Ohne cnpg.io/podRole erschienen im Labor die Pooler-Pods
zusätzlich unter podMonitor/tag14/pg-notes/0 – auf einem
Port, der dort keine Instanz-Metriken liefert.
Jetzt ein Ziel außerhalb des Clusters: der Exporter von
pg1 aus Tag 7. Prometheus nimmt
ScrapeConfig-Objekte mit dem Label
release: kps aus allen Namespaces an:
kubectl get prometheus -n monitoring \
-o jsonpath='{.items[0].spec.scrapeConfigSelector}{"\n"}'
kubectl apply -f - <<'EOF'
apiVersion: monitoring.coreos.com/v1alpha1
kind: ScrapeConfig
metadata:
name: pg1
namespace: monitoring
labels:
release: kps
spec:
staticConfigs:
- targets: ["172.16.0.182:9187"]
labels:
instance: pg1
EOFErwartet:
{"matchLabels":{"release":"kps"}}
scrapeconfig.monitoring.coreos.com/pg1 created
Nach etwa einer Minute:
kubectl get --raw "$P/query?query=pg_up" \
| jq -c '.data.result[] | [.metric.instance, .metric.job, .value[1]]'
kubectl get --raw "$P/query?query=sum+by+(datname)(pg_stat_activity_count)" \
| jq -c '.data.result[] | [.metric.datname, .value[1]]' | head -3Erwartet:
["pg1","scrapeConfig/monitoring/pg1","1"]
["notes","0"]
["postgres","1"]
["template0","0"]
Die ScrapeConfig bleibt stehen; Grafana kann die Daten
von pg1 ab jetzt anzeigen (etwa mit dem Community-Dashboard
„PostgreSQL Database“, ID 9628).
Fortschritt speichern? Kostenlos registrieren
Drill 4: Abfragen und Dashboard
Drei Fragen, die du im Betrieb wirklich stellst – Replikationsverzug, WAL-Archiv, Pooler-Warteschlange:
kubectl get --raw "$P/query?query=cnpg_pg_replication_lag" \
| jq -r '.data.result[] | [.metric.pod, .value[1]] | @tsv'
kubectl get --raw "$P/query?query=cnpg_collector_pg_wal_archive_status" \
| jq -r '.data.result[] | [.metric.pod, .metric.value, .value[1]] | @tsv'
kubectl get --raw "$P/label/__name__/values" | jq -r '.data[]' | grep -c '^cnpg_'Erwartet (gekürzt):
pg-notes-1 0
pg-notes-3 0
pg-notes-2 0
pg-notes-1 done 41
pg-notes-1 ready 0
...
137
ready > 0 über längere Zeit heißt: WAL staut sich,
die Archivierung hängt (Tag 15). 137 Metriken mit Präfix
cnpg_ (Instanzen und Pooler) stehen bereit. Das offizielle
Dashboard liegt im Repo cloudnative-pg/grafana-dashboards;
der Grafana-Sidecar des kps lädt jede ConfigMap mit Label
grafana_dashboard=1 aus allen Namespaces:
curl -fsSLo ~/pg/tag17/cnpg-dashboard.json https://raw.githubusercontent.com/\
cloudnative-pg/grafana-dashboards/7dd1bc255b5202530e1bae7b858a3bb41a2028c7/\
charts/cluster/grafana-dashboard.json
kubectl create configmap cnpg-dashboard -n tag14 \
--from-file=$HOME/pg/tag17/cnpg-dashboard.json
kubectl label configmap cnpg-dashboard -n tag14 grafana_dashboard=1Erwartet:
configmap/cnpg-dashboard created
configmap/cnpg-dashboard labeled
create statt apply: Die JSON-Datei hat 250
kB, apply würde sie zusätzlich in eine Annotation kopieren.
Der Commit ist gepinnt – das Repo hat seit 2025 keine Releases mehr.
Kontrolle über die Grafana-API (Admin-Passwort aus Tag 14):
kubectl port-forward -n monitoring svc/kps-grafana 3000:80 >/dev/null &
curl -s -u admin:lab-grafana-123 \
'http://localhost:3000/api/search?query=CloudNativePG' \
| jq -c '.[] | {title, uid, url}'
kill %1Erwartet:
{"title":"CloudNativePG","uid":"cloudnative-pg","url":"/d/cloudnative-pg/cloudnativepg"}
Im Browser (Port-Forward mit --address 0.0.0.0, dann
http://172.16.0.126:3000) wählst du oben Namespace
tag14 und Cluster pg-notes.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Rollen und Datenbanken als CRD
Das Passwort liegt in einem Secret vom Typ basic-auth,
dessen username zum Rollennamen passt:
kubectl create secret generic tag17-shop-pw -n tag14 \
--type=kubernetes.io/basic-auth \
--from-literal=username=tag17_shop --from-literal=password=lab-shop-123
cat > ~/pg/tag17/shop.yaml <<'EOF'
apiVersion: postgresql.cnpg.io/v1
kind: DatabaseRole
metadata:
name: tag17-shop
namespace: tag14
spec:
cluster:
name: pg-notes
name: tag17_shop
login: true
connectionLimit: 10
databaseRoleReclaimPolicy: delete
passwordSecret:
name: tag17-shop-pw
---
apiVersion: postgresql.cnpg.io/v1
kind: Database
metadata:
name: tag17-shop
namespace: tag14
spec:
cluster:
name: pg-notes
name: tag17_shop
owner: tag17_shop
databaseReclaimPolicy: delete
EOF
kubectl apply -f ~/pg/tag17/shop.yaml
kubectl get databaserole,database -n tag14Erwartet (gekürzt, sofort danach):
databaserole.postgresql.cnpg.io/tag17-shop created
database.postgresql.cnpg.io/tag17-shop created
NAME ... APPLIED MESSAGE
databaserole.postgresql.cnpg.io/tag17-shop ... false secrets "tag17-shop-pw" is
forbidden: User "system:serviceaccount:tag14:pg-notes" cannot get resource "secrets"
NAME ... APPLIED MESSAGE
database.postgresql.cnpg.io/tag17-shop ... false while creating database
"tag17_shop": ERROR: role "tag17_shop" does not exist (SQLSTATE 42704)
Kein Fehler von dir: Die Instanzen dürfen nur Secrets lesen, die in ihrer Role stehen. Der Operator trägt das neue Secret beim nächsten Abgleich ein, danach klappt alles. Eine Minute warten:
kubectl get databaserole,database -n tag14
kubectl get role pg-notes -n tag14 -o json \
| jq -c '.rules[] | select(.resources == ["secrets"]) | .resourceNames'
kubectl cnpg psql pg-notes -n tag14 -- -c '\du tag17_shop'
kubectl exec -n tag14 psql-client -- env PGPASSWORD=lab-shop-123 \
psql -U tag17_shop -d tag17_shop -c 'CREATE TABLE artikel (id int)' \
-Atc 'SELECT current_user, current_database()'Erwartet (gekürzt):
databaserole.postgresql.cnpg.io/tag17-shop ... true
database.postgresql.cnpg.io/tag17-shop ... true
["pg-notes-app","pg-notes-ca","pg-notes-replication","pg-notes-server",
"pg-notes-superuser","tag17-shop-pw"]
List of roles
Role name | Attributes
------------+----------------
tag17_shop | 10 connections
CREATE TABLE
tag17_shop|tag17_shop
DatabaseRole legt Rollen an, aber keine Rechte auf
Tabellen – GRANT bleibt SQL (oder Migration).
Passwort-Rotation: Secret mit Label cnpg.io/reload=true
versehen, dann wirkt eine Änderung sofort.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Eigene Zertifikate mit cert-manager
Statt der CNPG-CA kann cert-manager das Server-Zertifikat liefern.
Zum Ausprobieren ein kleiner Cluster in tag17; die Namen
gehören in dnsNames:
cat > ~/pg/tag17/pg-tls.yaml <<'EOF'
apiVersion: cert-manager.io/v1
kind: Issuer
metadata:
name: selfsigned
namespace: tag17
spec:
selfSigned: {}
---
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
name: pg-tls-server
namespace: tag17
spec:
secretName: pg-tls-server
secretTemplate:
labels:
cnpg.io/reload: ""
duration: 2160h
renewBefore: 360h
usages: [server auth]
dnsNames:
- pg-tls-rw
- pg-tls-rw.tag17
- pg-tls-rw.tag17.svc
- pg-tls-ro
- pg-tls-ro.tag17
- pg-tls-ro.tag17.svc
- pg-tls-r
- pg-tls-r.tag17
- pg-tls-r.tag17.svc
issuerRef:
name: selfsigned
kind: Issuer
group: cert-manager.io
---
apiVersion: postgresql.cnpg.io/v1
kind: Cluster
metadata:
name: pg-tls
namespace: tag17
spec:
instances: 1
imageName: ghcr.io/cloudnative-pg/postgresql:18.7-minimal-trixie
storage:
size: 512Mi
resources:
requests: {cpu: 50m, memory: 128Mi}
limits: {memory: 256Mi}
certificates:
serverTLSSecret: pg-tls-server
serverCASecret: pg-tls-server
EOF
kubectl apply -f ~/pg/tag17/pg-tls.yaml
kubectl wait --for=condition=Ready certificate/pg-tls-server -n tag17
kubectl wait --for=condition=Ready cluster/pg-tls -n tag17 --timeout=180s
kubectl get certificate,secret -n tag17Erwartet (gekürzt):
certificate.cert-manager.io/pg-tls-server condition met
cluster.postgresql.cnpg.io/pg-tls condition met
NAME READY SECRET AGE
certificate.cert-manager.io/pg-tls-server True pg-tls-server 32s
NAME TYPE DATA AGE
secret/pg-tls-app kubernetes.io/basic-auth 11 30s
secret/pg-tls-ca Opaque 2 31s
secret/pg-tls-replication kubernetes.io/tls 2 31s
secret/pg-tls-server kubernetes.io/tls 3 31s
Ein selbstsigniertes Zertifikat ist seine eigene CA, deshalb zeigen
beide Felder auf dasselbe Secret (ca.crt steckt drin).
pg-tls-ca und pg-tls-replication erzeugt CNPG
weiter selbst – für die Client-Zertifikate. Prüfen von cp1
aus und mit verify-full:
IP=$(kubectl get svc pg-tls-rw -n tag17 -o jsonpath='{.spec.clusterIP}')
echo | openssl s_client -starttls postgres -connect $IP:5432 2>/dev/null \
| openssl x509 -noout -ext subjectAltName -enddate
PW=$(kubectl get secret pg-tls-app -n tag17 -o jsonpath='{.data.password}' | base64 -d)
kubectl exec -n tag17 pg-tls-1 -- env PGPASSWORD=$PW psql "host=pg-tls-rw dbname=app \
user=app sslmode=verify-full sslrootcert=/controller/certificates/server-ca.crt" \
-c '\conninfo' | grep -E 'Host |SSL (Conn|Proto)'Erwartet:
X509v3 Subject Alternative Name: critical
DNS:pg-tls-rw, DNS:pg-tls-rw.tag17, DNS:pg-tls-rw.tag17.svc, DNS:pg-tls-ro, ...
notAfter=Feb 17 06:27:33 2027 GMT
Host | pg-tls-rw
SSL Connection | true
SSL Protocol | TLSv1.3
Mit der falschen CA (client-ca.crt) kommt
SSL error: certificate verify failed. Erneuert cert-manager
das Zertifikat, lädt CNPG es dank cnpg.io/reload ohne
Neustart.
kubectl delete -f ~/pg/tag17/pg-tls.yamlFortschritt speichern? Kostenlos registrieren
Drill 7: Parameter und Ressourcen
Was PostgreSQL wirklich nutzt und woher es kommt:
kubectl cnpg psql pg-notes -n tag14 -- -c "SELECT name, setting, unit, source
FROM pg_settings WHERE name IN ('shared_buffers', 'work_mem', 'max_connections',
'effective_cache_size', 'wal_level')"
kubectl get pod pg-notes-1 -n tag14 -o json \
| jq -c '.spec.containers[] | {name, resources}'
kubectl cnpg status pg-notes -n tag14 | sed -n '/Instances status/,/^$/p'Erwartet (gekürzt):
name | setting | unit | source
----------------------+---------+------+--------------------
effective_cache_size | 524288 | 8kB | default
max_connections | 120 | | configuration file
shared_buffers | 8192 | 8kB | configuration file
wal_level | logical | | configuration file
work_mem | 8192 | kB | configuration file
{"name":"postgres","resources":{"limits":{"memory":"512Mi"},"requests":{"cpu":"100m",
"memory":"256Mi"}}}
Instances status
Name Current LSN Replication role Status QoS Manager Version Node
pg-notes-3 0/19000060 Primary OK Burstable 1.30.2 worker1
...
effective_cache_size steht auf dem Standard 4 GB – mehr,
als der Pod je haben wird; der Planer rechnet damit zu optimistisch.
Zwei Fehlversuche, die der Webhook abfängt:
kubectl patch cluster pg-notes -n tag14 --type merge \
-p '{"spec":{"postgresql":{"parameters":{"listen_addresses":"127.0.0.1"}}}}'
kubectl patch cluster pg-notes -n tag14 --type merge --dry-run=server \
-p '{"spec":{"postgresql":{"parameters":{"shared_buffers":"600MB"}}}}'Erwartet:
The Cluster "pg-notes" is invalid: spec.postgresql.parameters.listen_addresses:
Invalid value: "127.0.0.1": Can't set fixed configuration parameter
The Cluster "pg-notes" is invalid: spec.resources.requests: Invalid value: "256Mi":
Memory request is lower than PostgreSQL `shared_buffers` value
Netzwerk, Pfade, Replikation und Archivierung bestimmt der Operator
selbst. shared_buffers muss in den Speicher-Request passen
– sonst droht der OOM-Killer.
Fortschritt speichern? Kostenlos registrieren
Drill 8: Logs lesen
CNPG schreibt alles als JSON nach stdout; PostgreSQL-Meldungen haben
logger: postgres und stecken in record:
kubectl exec -n tag14 psql-client -- psql -c 'SELECT 1/0'
kubectl logs pg-notes-3 -n tag14 -c postgres --since=1m | grep division | jq .Nimm deinen Primary.
Erwartet (gekürzt):
ERROR: division by zero
{
"level": "info",
"ts": "2026-11-19T06:28:45.242467084Z",
"logger": "postgres",
"msg": "record",
"logging_pod": "pg-notes-3",
"record": {
"log_time": "2026-11-19 06:28:45.241 UTC",
"user_name": "notes_app",
"database_name": "notes",
"connection_from": "10.0.1.135:58360",
"error_severity": "ERROR",
"sql_state_code": "22012",
"message": "division by zero",
"query": "SELECT 1/0",
"application_name": "psql",
...
Achtung: level ist immer info, der
Schweregrad steht in record.error_severity. Filtern mit
jq oder mit dem Plugin über alle Pods:
kubectl logs pg-notes-3 -n tag14 -c postgres --since=10m | jq -r 'select(
.logger == "postgres" and .record.error_severity == "ERROR")
| [.record.log_time, .record.user_name, .record.message] | @tsv'
kubectl cnpg logs cluster pg-notes -n tag14 --tail 200 \
| kubectl cnpg logs pretty --loggers postgres | grep -i divisionErwartet (gekürzt):
2026-11-19 06:26:01.405 UTC postgres role "tag17_shop" does not exist
2026-11-19 06:28:45.241 UTC notes_app division by zero
2026-11-19T06:28:45.242 ERROR pg-notes-3 postgres division by zero
In Produktion sammelt ein Log-Agent (Fluent Bit, Vector, Promtail) stdout ein; dank JSON ist jedes Feld durchsuchbar.
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Zeige, wie viele Server-Verbindungen der
rw-Pooler gerade offen hat. Zeitziel: 45 s - Zeige alle Prometheus-Targets aus
tag14und ihren Zustand. Zeitziel: 45 s - Zeige alle
DatabaseRoles und ob sie angewendet sind. Zeitziel: 15 s - Zeige alle Fehler (
ERROR,FATAL) des Primary der letzten 10 Minuten. Zeitziel: 60 s
Lösung
kubectl exec -n tag14 deploy/pg-notes-pooler-rw -c pgbouncer -- psql \
-h /controller/run -U pgbouncer pgbouncer -c 'SHOW SERVERS'
kubectl get --raw "$P/targets?state=active" | jq -r '.data.activeTargets[]
| select(.labels.namespace=="tag14") | [.labels.pod, .health] | @tsv'
kubectl get databaserole -n tag14
kubectl logs pg-notes-3 -n tag14 -c postgres --since=10m | jq -r 'select(
.record.error_severity == "ERROR" or .record.error_severity == "FATAL")
| .record.message'Erwartet (gekürzt, ohne Last):
type | user | database | replication | state | addr | port | ...
------+------+----------+-------------+-------+------+------+ ...
(0 rows)
pg-notes-pooler-ro-8bc8fc98b-gxkzr up
pg-notes-pooler-rw-598f6fc974-brjvx up
pg-notes-2 up
pg-notes-3 up
pg-notes-1 up
NAME AGE CLUSTER PG NAME APPLIED MESSAGE
tag17-shop 7m6s pg-notes tag17_shop true
role "tag17_shop" does not exist
division by zero
$P stammt aus Drill 3. Ohne Last hat der Pooler keine
Server-Verbindung offen – er baut sie erst bei Bedarf auf und schließt
sie nach server_idle_timeout.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
Pooler, PodMonitors und Dashboard bleiben für Tag 18 und
19. tag17-shop und tag17_monitor räumen
Challenge und Aufräumen wieder ab.
kubectl get pooler -n tag14Erwartet: pg-notes-pooler-rw und
pg-notes-pooler-ro, Phase active.
kubectl get podmonitor -n tag14Erwartet: pg-notes und
pg-notes-pooler.
kubectl get --raw "$P/query?query=cnpg_collector_up" | jq '.data.result | length'Erwartet: 3.
kubectl get configmap cnpg-dashboard -n tag14 --show-labelsErwartet: Label
grafana_dashboard=1.
kubectl get scrapeconfig -n monitoringErwartet: pg1 ist gelistet.
kubectl get cluster -n tag17Erwartet: No resources found –
pg-tls ist gelöscht.
Challenge
Lege die Rolle tag17_monitor (Login, Mitglied von
pg_monitor, Kommentar „nur lesen“) inline
im Cluster an. Nimm ihr per SQL das Login weg und beobachte, wer
gewinnt. Entferne sie danach deklarativ.
Hinweis: spec.managed.roles mit
ensure; der Abgleich läuft periodisch.
Lösung
kubectl patch cluster pg-notes -n tag14 --type merge -p '{"spec":{"managed":{"roles":[
{"name":"tag17_monitor","ensure":"present","login":true,
"inRoles":["pg_monitor"],"comment":"nur lesen"}]}}}'
kubectl cnpg psql pg-notes -n tag14 -- -c '\du+ tag17_monitor'
kubectl get cluster pg-notes -n tag14 -o jsonpath='{.status.managedRolesStatus}' | jq -c
kubectl cnpg psql pg-notes -n tag14 -- -c 'ALTER ROLE tag17_monitor NOLOGIN'Erwartet (gekürzt):
cluster.postgresql.cnpg.io/pg-notes patched
List of roles
Role name | Attributes | Description
---------------+------------+-------------
tag17_monitor | | nur lesen
{"byStatus":{"not-managed":["notes_app","tag17_shop"],"reconciled":["tag17_monitor"],
"reserved":["cnpg_metrics_exporter","streaming_replica","postgres",
"cnpg_pooler_pgbouncer"]},"passwordStatus":{"tag17_monitor":{...}}}
ALTER ROLE
Jetzt alle 20 s nachsehen:
kubectl cnpg psql pg-notes -n tag14 -- -Atc \
"SELECT now()::time(0), rolcanlogin FROM pg_roles WHERE rolname = 'tag17_monitor'"Erwartet (gekürzt): lange f, irgendwann
t.
06:30:24|f
...
06:35:56|f
06:36:58|t
Der Cluster gewinnt – aber erst beim nächsten Abgleich der Instanz,
im Labor nach über sechs Minuten oder sofort nach einem
Neustart/Switchover (etwa
kubectl cnpg promote pg-notes <replica> -n tag14, Tag
16). Bei einer DatabaseRole korrigiert der Operator
Handarbeit gar nicht, bis du sie neu anwendest. Merke: Rollen nur
deklarativ ändern.
Entfernen – erst absent, dann den Eintrag streichen:
kubectl patch cluster pg-notes -n tag14 --type merge -p '{"spec":{"managed":{"roles":[
{"name":"tag17_monitor","ensure":"absent"}]}}}'
kubectl cnpg psql pg-notes -n tag14 -- -Atc \
"SELECT count(*) FROM pg_roles WHERE rolname = 'tag17_monitor'"
kubectl patch cluster pg-notes -n tag14 --type json \
-p '[{"op":"remove","path":"/spec/managed"}]'Erwartet (nach etwa 15 s):
cluster.postgresql.cnpg.io/pg-notes patched
0
cluster.postgresql.cnpg.io/pg-notes patched
Fortschritt speichern? Kostenlos registrieren
Aufräumen
Pooler, PodMonitors, Dashboard und die
ScrapeConfig für pg1 bleiben. Rolle und
Datenbank des Shops gehen – Reclaim Policy: delete löscht
sie auch in PostgreSQL:
kubectl delete -f ~/pg/tag17/shop.yaml
kubectl delete secret tag17-shop-pw -n tag14
kubectl cnpg psql pg-notes -n tag14 -- -Atc \
"SELECT count(*) FROM pg_roles WHERE rolname LIKE 'tag17%'" \
-c "SELECT count(*) FROM pg_database WHERE datname LIKE 'tag17%'"
kubectl delete pod psql-client -n tag14
kubectl delete namespace tag17Erwartet (gekürzt):
databaserole.postgresql.cnpg.io "tag17-shop" deleted from tag14 namespace
database.postgresql.cnpg.io "tag17-shop" deleted from tag14 namespace
secret "tag17-shop-pw" deleted from tag14 namespace
0
0
pod "psql-client" deleted from tag14 namespace
namespace "tag17" deleted
Interview-Notiz
- „Wozu ein Pooler vor CNPG?“ – Viele kurze Verbindungen (Pods,
Serverless) auf wenige Server-Verbindungen bündeln;
transaction-Modus für zustandslose Apps.Poolervom Typrw/rohängt sich an die Services-rw/-ro. - „Wie überwachst du CNPG?“ –
PodMonitorfür Instanzen (9187) und Pooler (9127), Alarme aufcnpg_collector_up, Replikationsverzug, WAL-Archiv (ready) und Backup-Alter; Dashboard auscloudnative-pg/grafana-dashboards. - „Rollen deklarativ – was geht, was nicht?“ –
DatabaseRole/managed.rolesundDatabaselegen Rollen, Passwörter und Datenbanken an; Tabellenrechte bleiben Sache von SQL oder Migrationen.
Enterprise-Notiz
- Pooler mit mindestens zwei Instanzen und Anti-Affinity;
max_client_connunddefault_pool_sizeaufmax_connectionsaller Pooler abstimmen. PodMonitors undPrometheusRules (Vorlage:alerts.yamlim CNPG-Repo) per GitOps neben dem Cluster ausrollen; Metrik-Port mitmonitoring.tls.enabled.- Rollen-Passwörter aus einem Secret-Manager (External Secrets,
Vault/OpenBao) mit
cnpg.io/reload;DatabaseRolemitretaingegen versehentliches Löschen. - Server-Zertifikate von der Firmen-CA über cert-manager
(
ClusterIssuer), Clients mitverify-full; Ablauf überwacht cert-manager. - Requests = Limits für Speicher (QoS
Guaranteed),shared_buffersrund 25 % davon,effective_cache_sizepassend zum Limit setzen.