Why a pod restart is not a clean PostgreSQL recovery
Quick answer: “The pod restarted” describes six different events below, and they leave the database in different states. The outcome depends on whether PostgreSQL finished its shutdown before it was killed. Sending a signal does not settle that. The same
kubectl delete --force --grace-period=0produced a clean shutdown on an idle replica and a crash on a busy one.
What is the problem?
Section titled “What is the problem?”kubectl get pods says Running afterwards in both cases, so the difference is
not visible there.
PostgreSQL records how it stopped in its control file. Two values matter here:
- A clean state, such as
shut downorshut down in recovery. PostgreSQL recorded a completed shutdown. That is evidence that the next start will not need crash recovery. It does not describe what happened at the Kubernetes level, and several controlled shutdown paths produce it. in production, or on a standbyin archive recovery. PostgreSQL did not finish the clean-shutdown transition before the server stopped. The next start normally runs crash recovery. The state alone does not say whether the cause was aSIGKILL, an out-of-memory kill, an I/O failure, a panic, a lost node or an exhausted grace period.
The result depends on whether PostgreSQL completed its shutdown protocol before
it was forcibly terminated. Signal delivery is neither necessary nor
sufficient: a signal can arrive and be followed by a SIGKILL before shutdown
finishes, and PostgreSQL’s own immediate shutdown mode is signal-driven and
deliberately unclean.
The control file and the startup log are two different vocabularies
Section titled “The control file and the startup log are two different vocabularies”Pages that mix the two are easy to misread. The difference is easier to see
outside Kubernetes. Measured on 2026-09-20 on a stock postgres:18.1 container
on a named Docker volume, Docker 29.1.3:
| what was done | pg_controldata while the server was down | what the next start logged |
|---|---|---|
docker stop -t 60, a fast shutdown that completed | shut down | database system was shut down at 2026-09-20 06:15:48 UTC |
docker kill -s KILL | in production | database system was not properly shut down; automatic recovery in progress |
Those are different strings from different places. Database cluster state is
a field in the control file, and there are only a handful of values. database system was not properly shut down is a log line the next start writes after
reading that field.
The control file is readable at any time, including while the server is
running. It then reports the current state rather than the previous shutdown.
Measured on 2026-09-20 on PostgreSQL 18.6 in a stock postgres:18.6 container,
after a SIGKILL to the postmaster and a restart, pg_controldata read
Database cluster state: in production while that same restart’s log read
database system was not properly shut down; automatic recovery in progress.
In Kubernetes the container restarts immediately, so the startup log is what
you get. That is what the table below reports, and it is labelled as such.
The bench
Section titled “The bench”Everything below was measured on 2026-09-20 on CloudNativePG 1.30.0 running
PostgreSQL 18.1 (Debian 18.1-1.pgdg11+2), a three-instance Cluster on a k3d
v5.9.0 cluster (k3s v1.35.5-k3s1) with three agent nodes, on a host with 8 vCPUs
and 62 GB of RAM running Linux 6.17.0-1022-azure under Docker 29.1.3.
Read on 2026-09-20 from that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d
cluster, each instance’s PersistentVolumeClaim has a request and a reported
capacity of 2Gi, and nothing enforces it: the k3d local-path provisioner backs
the claim with a directory on the node’s own root filesystem, which df inside
the pod reports as 495 GB on that same cluster on that same day. The data
directory
can therefore grow past the request without complaint. Measured on 2026-09-20
on that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster, the data directory
was 1816 MB, and pg_rewind reports source directories of 2292 MB and 2788 MB
further down this page. Read the 2Gi as a number in the manifest, not as a
limit reached by any measurement here.
The settings that change these results, read on 2026-09-20 from that running
CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster: checkpoint_timeout
900 s, max_wal_size 2048 MB, shared_buffers 16384 (128 MB),
full_page_writes on, data_checksums on, wal_log_hints on,
synchronous_commit on with no synchronous standby configured, so replication
is asynchronous.
The operator defaults, read on 2026-09-20 from that same CloudNativePG 1.30.0
and PostgreSQL 18.1 k3d cluster: smartShutdownTimeout 180 s, stopDelay 1800 s,
switchoverDelay 3600 s, failoverDelay 0 s, and a pod
terminationGracePeriodSeconds of 1800.
Storage is the k3d local-path provisioner, so this is local disk, not network-attached storage. That affects every elapsed time on this page.
The six events, measured
Section titled “The six events, measured”Measured on 2026-09-20 on that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster. The middle column quotes the next start’s log, because the container was back before the control file could be read:
| what was done | what the next start logged | recovery on the next start | rewind |
|---|---|---|---|
kubectl delete pod on an idle replica, default grace | clean, shut down in recovery | entered standby, replayed from the last restartpoint, consistent immediately | not applicable |
the same with --force --grace-period=0, idle replica | clean, shut down in recovery | the same | not applicable |
| the same command, replica holding one open session | unclean, interrupted while in recovery | recovery | not applicable |
SIGKILL to the postmaster, container restarts in place | unclean | recovery, and RESTARTS became 1 | not applicable |
--force --grace-period=0 on an idle primary | clean, shut down at 05:12:29 UTC | entered standby after failover | ran, and reported no rewind required |
| node stopped with the primary on it, mid-write | unclean, was not properly shut down | replay, 3.49 s | 1964 MB of a 2292 MB source directory |
Two rows in that table need more explanation.
The same command, two outcomes
Section titled “The same command, two outcomes”This result is easy to overstate. Measured on 2026-09-20 on that CloudNativePG 1.30.0 and
PostgreSQL 18.1 k3d cluster, kubectl delete pod app-db-3 --force --grace-period=0 against an idle replica left a clean control file. The
instance manager completed its work inside the available window.
Then the same command, against the same replica, with a single
SELECT pg_sleep(300) open:
LOG: database system was interrupted while in recovery at log time 2026-09-20 05:10:05 UTCLOG: entering standby modeLOG: redo starts at 0/1A6BBB80LOG: consistent recovery state reached at 0/2B8BB7A8LOG: invalid record length at 0/2B8EFD30: expected at least 24, got 0One open session was the difference between a recorded clean shutdown and a crash. CloudNativePG’s shutdown issues a checkpoint, then disallows new connections and waits for existing ones. A zero grace period does not leave much time for that sequence.
“The instance manager first issues a
CHECKPOINT, then initiates a smart shut down, disallowing any new connection to PostgreSQL.” (CloudNativePG 1.30, instance manager, read on 2026-09-20)
--force changes Kubernetes deletion semantics, not PostgreSQL semantics. The
database still records the result. Kubernetes removes the object without
waiting, and the database gets whatever the node manages before the kill.
kubectl prints the warning itself. Run on 2026-09-20 against that k3d cluster,
the command’s own output was:
Warning: Immediate deletion does not wait for confirmation that the runningresource has been terminated. The resource may continue to run on the clusterindefinitely.The Kubernetes documentation describes this behaviour.
“Force deletions do not wait for confirmation from the kubelet that the Pod has been terminated.” (Kubernetes, force delete StatefulSet pods, read on 2026-09-20)
On the grace period itself:
“The practice of setting a
pod.Spec.TerminationGracePeriodSecondsof 0 seconds is unsafe and strongly discouraged for StatefulSet Pods.” (Kubernetes, force delete StatefulSet pods, read on 2026-09-20)
A force-deleted pod can leave its process running on an unreachable node while a replacement carries the same identity. The Kubernetes documentation describes the outcome and the possible damage.
“Irrespective of whether a force deletion is successful in killing a Pod, it will immediately free up the name from the apiserver.” (Kubernetes, force delete StatefulSet pods, read on 2026-09-20)
The next sentence on the same page explains what the freed name allows.
“This would let the StatefulSet controller create a replacement Pod with that same identity; this can lead to the duplication of a still-running Pod, and if said Pod can still communicate with the other members of the StatefulSet, will violate the at most one semantics that StatefulSet is designed to guarantee.” (Kubernetes, force delete StatefulSet pods, read on 2026-09-20)
The page also discusses databases.
“Having multiple members with the same identity can be disastrous and may lead to data loss (e.g. split brain scenario in quorum-based systems).” (Kubernetes, force delete StatefulSet pods, read on 2026-09-20)
Neither test here produced that result because every node was reachable. This bench does not test how often the case occurs.
A clean shutdown still means recovery
Section titled “A clean shutdown still means recovery”“Clean” does not mean “nothing to replay”. Measured on 2026-09-20 on that
CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster, the cleanly deleted
replica still logged entering standby mode and redo starts at 0/1A6BBB80
before it was consistent. A standby that stops cleanly resumes replaying
whatever it had received and then catches up with whatever it missed. Startup
time also includes scheduling, volume attachment, the operator’s orchestration
and the checkpoint the instance manager takes on the way down.
A clean shutdown rules out crash recovery. That is narrower than saying it “comes back in seconds”.
What crash recovery actually cost
Section titled “What crash recovery actually cost”Measured on 2026-09-20 on that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster, with the primary taking a bulk insert when its node was stopped:
LOG: database system was interrupted; last known up at 2026-09-20 05:12:31 UTCLOG: database system was not properly shut down; automatic recovery in progressLOG: redo starts at 0/2C0001A8LOG: redo done at 0/5DFFFD90 system usage: CPU: user: 2.68 s, system: 0.65 s, elapsed: 3.49 sLOG: checkpoint complete: wrote 16384 buffers (100.0%), ... distance=819199 kBReplay work is driven by WAL since the last completed checkpoint, not by database size. Measured on 2026-09-20 on that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster, the checkpoint distance was 819199 kB and replay took 3.49 seconds. Elapsed time also depends on storage latency, CPU, WAL availability, full-page images and the end-of-recovery flush. WAL volume bounds the work but does not determine the time.
checkpoint_timeout and max_wal_size are the main levers on how much WAL
can accumulate, but not the only ones. PostgreSQL describes the first effect
directly.
“Increasing this parameter can increase the amount of time needed for crash recovery.” (PostgreSQL 18, Write Ahead Log, read on 2026-09-20)
It also says the second is not a ceiling.
“This is a soft limit; WAL size can exceed
max_wal_sizeunder special circumstances, such as heavy load, a failingarchive_commandorarchive_library, or a highwal_keep_sizesetting.” (PostgreSQL 18, Write Ahead Log, read on 2026-09-20)
Crash recovery can be followed by a large checkpoint. In this run it wrote
16,384 buffers, which was all of shared_buffers. Whether that becomes a burst
depends on the pacing settings, the dirty-buffer volume and the device, so
measure it on your own storage.
invalid record length at 0/2B8EFD30: expected at least 24, got 0 is normally
benign at the expected end of WAL: it means no complete next record begins
there, which is how replay finds the end. Treat it as benign only in that
context. The same message earlier in required WAL, or alongside checksum errors
or a missing segment, is a real recovery failure.
pg_rewind, and when it is not the answer
Section titled “pg_rewind, and when it is not the answer”A promoted replica starts a new timeline. If the old primary wrote anything past
the fork point, those writes are not in the new history and the two have
diverged. pg_rewind lets a diverged member rejoin without a full rebuild.
“pg_rewind is a tool for synchronizing a PostgreSQL cluster with another copy of the same cluster, after the clusters’ timelines have diverged.” (PostgreSQL 18,
pg_rewind, read on 2026-09-20)
It is not required after every disruption. Measured on 2026-09-20 on that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster, the force-deleted idle primary came back to this:
pg_rewind: servers diverged at WAL location 0/2C0000A0 on timeline 1pg_rewind: no rewind requiredThe operator ran the tool; there was nothing to copy. The primary killed mid-write was different:
pg_rewind: servers diverged at WAL location 0/5DFFFDD0 on timeline 2pg_rewind: rewinding from last common checkpoint at 0/2C000200 on timeline 2pg_rewind: need to copy 1964 MB (total source directory size is 2292 MB)pg_rewind: Done!That is 86 percent of the source directory, and a second run of the same test on
2026-09-20 on that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster copied
2433 MB of 2788 MB. Do not treat those as a
rule. pg_rewind copies changed blocks plus certain whole files, so the volume
tracks how much diverged, and these runs diverged during a bulk insert that
dirtied nearly everything.
“pg_rewind examines the timeline histories of the source and target clusters to determine the point where they diverged, and expects to find WAL in the target cluster’s
pg_waldirectory reaching all the way back to the point of divergence.” (PostgreSQL 18,pg_rewind, read on 2026-09-20)
The prerequisites, which decide whether you get this path at all
Section titled “The prerequisites, which decide whether you get this path at all”The requirement is stated on the tool’s own page.
“pg_rewind requires that the target server either has the wal_log_hints option enabled in postgresql.conf or data checksums enabled when the cluster was initialized with initdb (the default). full_page_writes must also be set to on, but is enabled by default.” (PostgreSQL 18,
pg_rewind, read on 2026-09-20)
Note “(the default)”, because it is easy to credit the operator with all three.
Measured on 2026-09-20 on a stock postgres:18.1 container under Docker 29.1.3,
with nothing configured: data_checksums on, full_page_writes on,
wal_log_hints off. Measured on 2026-09-20 on that CloudNativePG 1.30.0 and
PostgreSQL 18.1 k3d cluster, all three were on. A stock PostgreSQL 18 therefore
satisfies the prerequisite through checksums. wal_log_hints is the setting the
operator added, and it is a second route to the same requirement.
On a cluster you did not build, read both settings rather than assuming the
initdb default survived, and remember that turning checksums on afterwards is
not a reload.
“The server must be shut down cleanly before running pg_checksums.” (PostgreSQL 18,
pg_checksums, read on 2026-09-20)
If local WAL has been recycled past the fork point, rewind needs the archive,
through -c or --restore-target-wal. If it cannot get there, the fallback is
not a smaller rewind.
“If pg_rewind fails while processing, then the data folder of the target is likely not in a state that can be recovered. In such a case, taking a new fresh backup is recommended.” (PostgreSQL 18,
pg_rewind, read on 2026-09-20)
Slow incidents usually come from a missing prerequisite or missing WAL followed
by rebuilding a replica from a backup, rather than from a large rewind. Rewind
also leaves WAL to replay before the member is consistent, and it reads from
somewhere: in these runs it read from the live promoted primary, so it used
that instance’s read I/O and network. pg_rewind can instead read a source data
directory on disk, and the documentation attaches one condition to that.
“Specifies the file system path to the data directory of the source server to synchronize the target with. This option requires the source server to be cleanly shut down.” (PostgreSQL 18,
pg_rewind, read on 2026-09-20)
Whether rejoin competes with production traffic depends on how the command is invoked. The offline route needs a stopped source, which a live primary is not. Under an operator you do not choose this: CloudNativePG ran the live-source form in every run on this page.
Failover, and what it costs you
Section titled “Failover, and what it costs you”Deleting a primary pod is not a local event. Measured on 2026-09-20 on that
CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster, stopping the node carrying
the primary produced a new primary 70 seconds later in one run and 72 seconds in
another, on a cluster with failoverDelay 0.
The components of that window were not measured here. failoverDelay was 0, so
none of it is a delay requested from the operator. The rest is some mix of
Kubernetes deciding the node is gone and the operator promoting a replica, and
this bench recorded only the total. If that window is too slow, instrument when
the node went NotReady, because promotion has to fit inside whatever time
remains.
The operator advises against the planned version of this.
“In order to avoid any data loss in the Postgres cluster, which impacts the database RPO, don’t delete the Pod where the primary instance is running. In this case, perform a switchover to another instance first.” (CloudNativePG 1.30, instance manager, read on 2026-09-20)
How much did it actually lose?
Section titled “How much did it actually lose?”Nothing, in the run designed to catch it, for a reason that matters more than the result. Measured on 2026-09-20 on that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster, a client committing one row per transaction at about 25 a second, and appending each acknowledged id to a file outside the primary’s node, recorded 656 acknowledged inserts. After the node was stopped and a replica was promoted, the new primary held all 656.
That result is a lag measurement, not a guarantee. Under the bulk
load on 2026-09-20 on that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d
cluster, pg_stat_replication on the primary
showed both replicas with a replay lag of about 0.68 seconds while
sent_lsn ran ahead of replay_lsn. Asynchronous replication exposes that
window: commits acknowledged to the client but not yet present on whichever
replica gets promoted. A slow writer with sub-second lag loses nothing; a fast
writer with seconds of lag can lose the difference.
With asynchronous replication, a failover can lose acknowledged commits that are not on the promotion candidate. The size of that window is the replication lag at the moment of failure, not a property of node death. A node death does not destroy the old primary’s data either: it survives on its volume, which is why rewind is possible, but anything not on the promoted timeline is discarded from the cluster’s history.
Synchronous replication closes that window at the cost of commit latency and availability when a required standby is missing. Choose it against a stated recovery point objective and pair it with a failover policy that will not promote a candidate missing synchronously committed data, rather than enabling it because writes feel important.
Running and Ready are not “caught up”
Section titled “Running and Ready are not “caught up””Measured on 2026-09-20 on that CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster, while a rejoining replica was catching up:
| signal | value |
|---|---|
kubectl get pod | 1/1 Running |
| the pod’s ready condition | true |
pg_controldata cluster state | in archive recovery |
rows in pg_stat_wal_receiver on that replica | 0 |
rows in pg_stat_replication on the primary | 0 |
the Cluster status | Waiting for the instances to become active |
The pod was Ready and the replica was not streaming from anywhere. That is the
configured behaviour rather than a bug. Read on 2026-09-20 from that cluster,
the pod’s readiness probe is an HTTPS GET /readyz on port 8000, which is the
instance manager rather than PostgreSQL, and the Cluster sets no readiness
strategy. What the instance manager does behind that endpoint by default is
stated by the operator.
“By default, the readiness probe uses
pg_isready.” (CloudNativePG 1.30, instance manager, read on 2026-09-20)
pg_isready answers whether the server accepts connections, not whether
replication is current. If “ready” is supposed to mean streaming, the operator
has a strategy for that and it must be configured.
“streaming: marks the probe as successful when the replica begins streaming from its source and meets the specified lag requirements.” (CloudNativePG 1.30, instance manager, read on 2026-09-20)
A lag bound can also be enforced for the life of the pod rather than only at startup.
“Unlike the startup probe, the
.spec.probes.readiness.maximumLagoption is continuously monitored.” (CloudNativePG 1.30, instance manager, read on 2026-09-20)
pg_is_in_recovery() has the same limit in the other direction, and its
definition is one line.
“Returns true if recovery is still in progress.” (PostgreSQL 18, System Information Functions, read on 2026-09-20)
That is all it claims. It says nothing about whether the server is streaming,
caught up, promotable, in the Service endpoints, or taking traffic, so a true
answers one question and is often read as answering five.
A runbook that answers the right questions
Section titled “A runbook that answers the right questions”After any disruption, use this order.
Which member is primary, and did that change?
kubectl get cluster app-db -o jsonpath='{.status.currentPrimary} {.status.targetPrimary}'Was the shutdown clean? Ask the control file only while the instance is
still down. It also reads on a running server, but then it reports the live
state, so a pod that has already restarted answers in production whatever
happened:
kubectl exec app-db-1 -c postgres -- pg_controldata /var/lib/postgresql/data/pgdata | head -8Did it run crash recovery, and how long did replay take? The two lines that
answer it are database system was not properly shut down; automatic recovery in progress and the redo done ... elapsed: line in the instance log.
Did a rewind happen, and how big was it? Look for pg_rewind: need to copy
against pg_rewind: no rewind required in the same log, and note whether it
read from the live primary or from an archive.
Is it streaming, and how far behind? On the standby and on the primary:
SELECT status, sender_host, latest_end_lsn, last_msg_receipt_timeFROM pg_stat_wal_receiver;SELECT application_name, state, sync_state, sent_lsn, replay_lsn, replay_lsn IS DISTINCT FROM sent_lsn AS behind, replay_lagFROM pg_stat_replication;Is it actually in service? Check the Service endpoints, not the pod phase.
A pod can be Running and Ready and still be a replica that should not receive
write traffic.
Do not read RESTARTS: 0 as “nothing happened”. Measured on 2026-09-20 on that
CloudNativePG 1.30.0 and PostgreSQL 18.1 k3d cluster, killing the postmaster in
place moved RESTARTS to 1, while deleting the pod produced a new pod, with a
new UID, whose restart count started at 0. A replacement pod is a new object,
not the old one rescheduled.
How do I stop it coming back?
Section titled “How do I stop it coming back?”You cannot stop nodes dying. You can decide in advance what each failure costs.
Never force-delete a database pod to make it move. Use a switchover for
planned work on a primary, and an ordinary deletion with a real grace period
otherwise. The evidence above is that --force --grace-period=0 removes the
part of the sequence that makes the shutdown clean.
Checkpoint often enough that replay is short, and measure the trade. Shorter
intervals reduce worst-case replay. They also mean more checkpoint work and,
with full_page_writes on, more full-page images in WAL.
“When this parameter is on, the PostgreSQL server writes the entire content of each disk page to WAL during the first modification of that page after a checkpoint.” (PostgreSQL 18, Write Ahead Log, read on 2026-09-20)
That is a throughput, WAL-volume and recovery-time trade to benchmark, not a setting to lower on principle.
Confirm the rewind prerequisites before you need them, and configure WAL archiving so a rejoining member can get the WAL it is missing from the archive rather than from the instance currently serving your application.
Set your recovery point objective before choosing a replication mode. If acknowledged commits must survive a node loss, that is synchronous replication plus a quorum-aware failover policy, and the cost is commit latency. If seconds of exposure are acceptable, monitor replay lag, because that lag is the exposure.
Does deleting a PostgreSQL pod corrupt anything?
No, but it does not guarantee a clean shutdown either. Measured on 2026-09-20 on CloudNativePG 1.30.0 with PostgreSQL 18.1 in a three-node k3d cluster, kubectl delete pod --force --grace-period=0 on an idle replica came back logging database system was shut down in recovery, which is the clean case. The same command against the same replica with one open session came back logging database system was interrupted while in recovery, and the next start ran recovery. Those are startup log lines, not control-file states; in Kubernetes the container restarts before the control file can be read. The command is the same; the outcome is a race.
What is different when the node dies instead?
Nothing gets the chance to shut PostgreSQL down. Measured on 2026-09-20 on CloudNativePG 1.30.0 with PostgreSQL 18.1 in a three-node k3d cluster, stopping the node carrying the primary left database system was not properly shut down; automatic recovery in progress, replay took 3.49 seconds, and the returning instance then needed a pg_rewind of 1964 MB against a 2292 MB source directory because the cluster had promoted somebody else.
How long does crash recovery take?
It is driven by the WAL written since the last completed checkpoint, not by database size, and elapsed time also depends on storage, CPU and end-of-recovery flushing. Measured on 2026-09-20 on CloudNativePG 1.30.0 with PostgreSQL 18.1 in a three-node k3d cluster, replay from 0/2C0001A8 to 0/5DFFFD90 took 3.49 seconds of elapsed time and 2.68 seconds of user CPU, and the end-of-recovery checkpoint then wrote 16,384 buffers, all of shared_buffers.
Is pg_rewind always needed after a failover?
No. It is needed when the returning member's timeline diverged from the promoted one. Measured on 2026-09-20 on CloudNativePG 1.30.0 with PostgreSQL 18.1 in a three-node k3d cluster, a force-deleted idle primary came back with pg_rewind: no rewind required, while a primary killed mid-write needed 1964 MB copied. A member that was never primary usually just streams and replays.
Does a node death lose acknowledged writes?
It can, and how much depends on replication lag and which replica is promoted. Measured on 2026-09-20 on CloudNativePG 1.30.0 with PostgreSQL 18.1 in a three-node k3d cluster, a writer committing about 25 rows a second recorded 656 acknowledged inserts and all 656 survived the node kill and the failover. Under a bulk load on the same cluster, replay lag on both replicas was about 0.68 seconds, and that lag is the exposure.
Does a Ready pod mean the replica is caught up?
No. Measured on 2026-09-20 on CloudNativePG 1.30.0 with PostgreSQL 18.1 in a three-node k3d cluster, a rejoining replica read 1/1 Running with a true ready condition while pg_stat_wal_receiver had zero rows and the primary's pg_stat_replication had zero rows. The default readiness probe is pg_isready, which answers whether the server accepts connections, not whether it is streaming.