Hoe schaal je databases?

Question

Accepted Answer

Databases worden vaak een **bottleneck** naarmate systemen groeien. Schaaling ervan omvat technieken zoals **replicatie** (kopieën voor lees-schaaling en beschikbaarheid), **sharding** (gegevens splitsen over servers), **caching**, en het kiezen van passende databasetypes.

## Replicatie — kopieën van de gegevens

```text
REPLICATION → maintain COPIES of the database across servers:
  → PRIMARY (writes) + REPLICAS (copies):
    - READ SCALING → direct reads to replicas (offload the primary) → handle more reads
    - AVAILABILITY → a replica can take over if the primary fails (failover)
  ⚠️ replication lag → replicas may be slightly behind (eventual consistency for reads)
→ great for READ-heavy workloads and availability (most apps are read-heavy)
```

## Sharding — de gegevens splitsen

```text
SHARDING → split (partition) data across MULTIPLE database servers (each holds a SUBSET):
  → distribute by a SHARD KEY (e.g. user ID) → each shard handles part of the data/load
  → scales WRITES and storage horizontally (beyond one server's capacity)
  ⚠️ complex: choosing a good shard key (even distribution), cross-shard queries are hard,
    rebalancing → significant complexity
→ for when data/write volume exceeds a single server (large scale)
```

## Andere schaalingstechnieken

```text
✓ CACHING → cache query results / hot data (Redis) → big reduction in DB load (often the
  first and most impactful step)
✓ INDEXING & query optimization → make queries efficient (before scaling out)
✓ Read/write SPLITTING; connection pooling; denormalization (for read performance)
✓ Choose the right DATABASE (some scale horizontally more easily — NoSQL)
✓ Vertical scaling (bigger DB server) → simple first step, but limited
```

## Waarom het belangrijk is

Het begrijpen van hoe je databases schaalt is waardevol omdat de **database vaak de bottleneck** is naarmate systemen groeien, dus het schalen ervan is een kritieke, veel voorkomende system-design-uitdaging, wat deze kennis belangrijk maakt.

Naarmate systemen schalen, wordt de database regelmatig de beperkende factor (een enkele database kan maar zoveel load en gegevens verwerken), waardoor database-schaaling een belangrijk aandachtspunt is.

Het begrijpen van **replicatie** — het onderhouden van kopieën (een primaire voor schrijfbewerkingen plus replica's) om **lees-schaaling** mogelijk te maken (leesbewerkingen naar replica's sturen om de primaire te ontlasten, waardevol omdat de meeste apps lees-intensief zijn) en **beschikbaarheid** (een replica die overneemt bij uitval) — is een fundamentele, veel gebruikte techniek, samen met het begrijpen van de voorbehoud van replicatielatentie (uiteindelijke consistentie voor replica-lezen).

Het begrijpen van **sharding** — gegevens over meerdere servers splitsen (elk met een subset, verdeeld op basis van een shard-sleutel) om **schrijfbewerkingen en opslag** horizontaal voorbij één server te schalen — is essentieel voor zeer grote schaal, samen met de aanzienlijke complexiteit ervan (een goede shard-sleutel kiezen, moeilijke query's over shards heen, herverdeling).

Het begrijpen van **andere technieken** — **caching** (vaak de eerste en meest impactvolle stap, drastisch verlaagde databasebelasting), **indexering en query-optimalisatie** (queries efficiënt maken voordat je uitschaalt), lees/schrijf-scheiding, denormalisatie, het kiezen van horizontaal schaalbare databases, en verticale schaaling als een eenvoudige eerste stap — biedt de volledige toolkit, met de belangrijke praktische wijsheid dat caching en optimalisatie vaak vooraf gaan aan de complexiteit van sharding.

Omdat de database veelvoorkomend de schaalbotneck is en deze schalen (via replicatie voor lezen/beschikbaarheid, sharding voor schrijven/opslag, caching en optimalisatie) een kritieke, veel voorkomende uitdaging is, en omdat het begrijpen van deze technieken en hun afwegingen belangrijk is voor het ontwerpen van schaalbare systemen, is het begrijpen van hoe je databases schaalt waardevolle, praktisch-belangrijke system-design-kennis — die een kritieke, veel voorkomende bottleneck aanpakt, centraal staat voor het schalen van echte systemen, en vereist het begrijpen van replicatie, sharding, caching en optimalisatie om de database-schaaling aan te kunnen die groeiende systemen onvermijdelijk nodig hebben.