Hoe werkt replicatie in PostgreSQL?

Question

Accepted Answer

**Replicatie** kopieert gegevens van een **primaire** database naar één of meer **replica** (standby) servers — voor hoge beschikbaarheid (failover als de primaire uitvalt) en read scaling (verdeel read queries). PostgreSQL gebruikt primair **streaming replication** (fysiek) op basis van het write-ahead log (WAL).

## Streaming (fysieke) replicatie

```text
Primary  ──(streams WAL: the write-ahead log of changes)──▶  Replica(s)
  ✓ The primary handles all WRITES
  ✓ Replicas continuously apply the primary's WAL → stay in sync (near-real-time)
  ✓ Replicas can serve READ queries ("hot standby") → scale reads
```

De primaire streamt zijn **WAL** (write-ahead log — een record van elke wijziging) naar replica's, die het toepassen om synchroon te blijven. Replica's zijn read-only kopieën die read queries kunnen uitvoeren.

## De voordelen: HA en read scaling

```text
HIGH AVAILABILITY → if the primary fails, a replica can be PROMOTED to primary (failover)
  → minimal downtime, no data loss (with synchronous replication)
READ SCALING → route read-only queries to replicas → offload the primary
  → handle more read traffic (great for read-heavy workloads)
BACKUPS → take backups from a replica without loading the primary
```

## Synchrone versus asynchrone replicatie

```text
ASYNCHRONOUS (default) → the primary commits without waiting for replicas
  ✓ faster writes (no wait)   ✗ a tiny window of potential data loss on failover
SYNCHRONOUS → the primary waits for a replica to confirm before committing
  ✓ no data loss on failover  ✗ slower writes (waits for the replica)
→ Choose based on the durability vs performance trade-off.
```

## Logische replicatie (een ander model)

```text
LOGICAL replication → replicates specific TABLES/changes (not the whole cluster), based
on a publish/subscribe model. Enables: selective replication, cross-version, and
replicating to different schemas → good for migrations, integrations, partial replication.
```

## Hoge beschikbaarheid in de praktijk

```text
Tools like Patroni, repmgr, or cloud-managed Postgres automate FAILOVER (detecting
primary failure and promoting a replica) → near-automatic high availability.
A load balancer / connection router directs writes to the primary, reads to replicas.
```

## Waarom het belangrijk is

Replicatie is belangrijk voor het bouwen van **highly-available en schaalbare** PostgreSQL implementaties, dus het begrijpen ervan is waardevol senior-level kennis voor production database architectuur.

De twee kernvoordelen zijn kritiek voor serieuze applicaties: **hoge beschikbaarheid** (als de primaire database uitvalt, kan een replica worden gepromoveerd om het over te nemen, downtime minimaliseren — essentieel voor systemen die beschikbaar moeten blijven) en **read scaling** (routing van read-only queries naar replica's ontlast de primaire, waardoor het systeem veel meer read traffic kan verwerken — waardevol voor read-heavy workloads).

Begrijpen van **streaming replication** (de primaire streamt zijn WAL naar replica's die synchroon blijven en reads kunnen uitvoeren) is de basis.

Kennis van de **synchrone versus asynchrone** trade-off is belangrijk: asynchrone (de standaard — snellere writes maar een klein venster van potentieel gegevensverlies bij failover) versus synchrone (geen gegevensverlies maar langzamere writes) — een durabiliteit-versus-performance beslissing die betrouwbaarheid beïnvloedt.

Begrijpen van **logische replicatie** (specifieke tabellen repliceren via pub/sub, nuttig voor migraties, cross-version en partiële/selectieve replicatie) verbreed de opties.

Weten dat **HA tooling** (Patroni, repmgr, managed cloud Postgres) failover automatiseert, en dat read/write routing verkeer op passende manier stuurt, is praktische architectuurkennis.

Omdat hoge beschikbaarheid en schaalbaarheid essentiële vereisten zijn voor production database systemen, en omdat replicatie (met zijn HA failover, read scaling, de sync/async durabiliteit trade-off en logische replicatie voor flexibiliteit) het primaire mechanisme is dat PostgreSQL daarvoor biedt, is het begrijpen van replicatie belangrijk senior-level kennis voor het ontwerpen van betrouwbare, schaalbare Postgres implementaties — een veelvuldig relevante zorg voor production systemen en een onderwerp dat begrip aantoont van database beschikbaarheid en scaling dat verwacht wordt voor senior database/backend rollen.