Wie skalierst du Datenbanken?

Question

Accepted Answer

Datenbanken werden oft zu einem **Engpass**, wenn Systeme wachsen. Das Skalieren umfasst Techniken wie **Replikation** (Kopien für Lese-Skalierung und Verfügbarkeit), **Sharding** (Aufteilung von Daten auf Server), **Caching** und die Auswahl angemessener Datenbanktypen.

## Replikation — Kopien der Daten

```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 — Aufteilung der Daten

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

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

## Warum es wichtig ist

Zu verstehen, wie man Datenbanken skaliert, ist wertvoll, weil die **Datenbank oft der Engpass** ist, wenn Systeme wachsen, weshalb das Skalieren einer Datenbank eine kritische, häufige System-Design-Herausforderung darstellt und dieses Wissen wichtig macht.

Bei wachsenden Systemen wird die Datenbank häufig zum limitierenden Faktor (eine einzelne Datenbank kann nur eine bestimmte Last und Datenmenge bewältigen), was Datenbank-Skalierung zu einem Hauptanliegen macht.

Zu verstehen, wie **Replikation** funktioniert — das Verwalten von Kopien (eine primäre für Schreibvorgänge plus Replicas) um **Lese-Skalierung** zu ermöglichen (Weiterleitungen von Lesevorgängen an Replicas, um die primäre zu entlasten, wertvoll, da die meisten Apps leseintensiv sind) und **Verfügbarkeit** (eine Replica übernimmt bei Ausfällen) — ist eine grundlegende, weit verbreitete Technik, zusammen mit dem Verständnis der Einschränkung von Replikationsverzögerungen (eventuelle Konsistenz bei Replica-Lesevorgängen).

Zu verstehen, wie **Sharding** funktioniert — Aufteilung von Daten auf mehrere Server (jeder hält eine Teilmenge, verteilt nach einem Shard-Schlüssel), um **Schreibvorgänge und Speicher** horizontal über einen Server hinaus zu skalieren — ist für sehr großes Ausmaß essentiell, zusammen mit seiner erheblichen Komplexität (Auswahl eines guten Shard-Schlüssels, schwierige Abfragen über Shards hinweg, Rebalancing).

Zu verstehen, wie **andere Techniken** funktionieren — **Caching** (oft der erste und wirkungsvollste Schritt, drastisch die Datenbankauslastung reduzierend), **Indexierung und Query-Optimierung** (Abfragen effizient machen vor dem Scale-out), Lese/Schreib-Trennung, Denormalisierung, Auswahl horizontal skalierbar Datenbanken und vertikale Skalierung als einfacher erster Schritt — bietet das vollständige Toolkit, mit der wichtigen praktischen Erkenntnis, dass Caching und Optimierung oft vor der Komplexität des Sharding kommen.

Da die Datenbank häufig der Skalierungs-Engpass ist und das Skalieren (mittels Replikation für Lesevorgänge/Verfügbarkeit, Sharding für Schreibvorgänge/Speicher, Caching und Optimierung) eine kritische, häufige Herausforderung darstellt, und da das Verständnis dieser Techniken und ihrer Trade-offs wichtig für die Gestaltung skalierbarer Systeme ist, stellt das Verstehen, wie man Datenbanken skaliert, wertvoll praktisches System-Design-Wissen dar — das einen kritischen, häufigen Engpass adressiert, zentral für die Skalierung echter Systeme ist und das Verständnis von Replikation, Sharding, Caching und Optimierung erfordert, um die Datenbank-Skalierung zu handhaben, die wachsende Systeme unweigerlich benötigen.