Hvordan skalerer du databaser?

Question

Accepted Answer

Databaser bliver ofte til en **flaskehals** når systemer vokser. Skalering af dem indebærer teknikker som **replikering** (kopier til læseskalering og tilgængelighed), **sharding** (opdeling af data på tværs af servere), **caching** og valg af passende databasetyper.

## Replikering — kopier af dataene

```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 — opdeling af dataene

```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)
```

## Andre skaleringstekniker

```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
```

## Hvorfor det betyder noget

At forstå hvordan man skalerer databaser er værdifuldt, fordi **databasen ofte er flaskehalsen** når systemer vokser, så skalering af den er en kritisk, almindelig systemdesign-udfordring, hvilket gør denne viden vigtig.

Når systemer skaleres, bliver databasen hyppigt den begrænsende faktor (en enkelt database kan kun håndtere så meget load og data), hvilket gør databaseskalering til en vigtig bekymring.

At forstå **replikering** — vedligeholdelse af kopier (et primært for skrivning plus replika'er) for at muliggøre **læseskalering** (dirigering af læsninger til replika'er for at aflaste det primære, værdifuldt da de fleste apps er læsetunge) og **tilgængelighed** (en replika som overtager ved fejl) — er en fundamental, udbredt teknik, sammen med forståelsen af replikeringsforsinkelse (eventuel konsistens for replika læsninger).

At forstå **sharding** — opdeling af data på tværs af flere servere (hver holder en delmængde, distribueret af en shard-nøgle) for at skalere **skrivninger og lagring** horisontalt ud over en server — er essentielt for meget stor skala, sammen med dets betydelige kompleksitet (valg af en god shard-nøgle, svære tværgående shard-forespørgsler, genbalancering).

At forstå **andre teknikker** — **caching** (ofte det første og mest impaktfulde trin, dramatisk reducering af databasebelastning), **indeksering og forespørgselsoptimering** (gør forespørgsler effektive før udskalering), læse/skriv-splitting, denormalisering, valg af horisontalt skalerbare databaser og vertikal skalering som et enkelt første trin — giver det fuldstændige værktøjssæt, med den vigtige praktiske visdom at caching og optimering ofte kommer før kompleksiteten af sharding.

Fordi databasen almindeligt er skaleringsbottleneck'en og skalering af den (via replikering til læsninger/tilgængelighed, sharding til skrivninger/lagring, caching og optimering) er en kritisk, almindelig udfordring, og fordi forståelsen af disse teknikker og deres kompromiser er vigtig for design af skalerbare systemer, er forståelsen af hvordan man skalerer databaser værdifuld, praktisk vigtig systemdesign-viden — adresser en kritisk, almindelig flaskehals, central for skalering af virkelige systemer og kræver forståelse af replikering, sharding, caching og optimering for at håndtere den databaseskalering som voksende systemer uundgåeligt har brug for.