Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 17: CNPG: Betrieb

Ziel: pg-notes bekommt 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, Typ rw oder ro; Authentifizierung per auth_query, ohne Passwortliste.
  • Jede Instanz exportiert Metriken auf Port 9187 (metrics), jeder Pooler auf 9127. Den PodMonitor legst du selbst an – enablePodMonitor ist veraltet.
  • Rollen: DatabaseRole (neu in 1.30, empfohlen) oder managed.roles im 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.yaml

Drill 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.podIP

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

Erwartet:

* = 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.sql

Wä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-80

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

Nach 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
EOF

Erwartet:

{"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 -3

Erwartet:

["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=1

Erwartet:

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 %1

Erwartet:

{"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 tag14

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

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

Fortschritt 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 division

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

  1. Zeige, wie viele Server-Verbindungen der rw-Pooler gerade offen hat. Zeitziel: 45 s
  2. Zeige alle Prometheus-Targets aus tag14 und ihren Zustand. Zeitziel: 45 s
  3. Zeige alle DatabaseRoles und ob sie angewendet sind. Zeitziel: 15 s
  4. 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 tag14

Erwartet: pg-notes-pooler-rw und pg-notes-pooler-ro, Phase active.

kubectl get podmonitor -n tag14

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

Erwartet: Label grafana_dashboard=1.

kubectl get scrapeconfig -n monitoring

Erwartet: pg1 ist gelistet.

kubectl get cluster -n tag17

Erwartet: 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 tag17

Erwartet (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. Pooler vom Typ rw/ro hängt sich an die Services -rw/-ro.
  • „Wie überwachst du CNPG?“ – PodMonitor für Instanzen (9187) und Pooler (9127), Alarme auf cnpg_collector_up, Replikationsverzug, WAL-Archiv (ready) und Backup-Alter; Dashboard aus cloudnative-pg/grafana-dashboards.
  • „Rollen deklarativ – was geht, was nicht?“ – DatabaseRole/managed.roles und Database legen 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_conn und default_pool_size auf max_connections aller Pooler abstimmen.
  • PodMonitors und PrometheusRules (Vorlage: alerts.yaml im CNPG-Repo) per GitOps neben dem Cluster ausrollen; Metrik-Port mit monitoring.tls.enabled.
  • Rollen-Passwörter aus einem Secret-Manager (External Secrets, Vault/OpenBao) mit cnpg.io/reload; DatabaseRole mit retain gegen versehentliches Löschen.
  • Server-Zertifikate von der Firmen-CA über cert-manager (ClusterIssuer), Clients mit verify-full; Ablauf überwacht cert-manager.
  • Requests = Limits für Speicher (QoS Guaranteed), shared_buffers rund 25 % davon, effective_cache_size passend zum Limit setzen.