---
title: "Valkey vs. Redis: B+Tree Sorted Sets, 43 % weniger RAM & Migration"
description: "Technischer Tiefenvergleich Valkey 9.2 vs. Redis 8: Warum Valkey Skiplists durch Cache-freundliche B+Trees (fbtree) ersetzt (43 % weniger Sorted-Set-RAM, +105 % ZADD), Forkless Snapshots, Path Hash, AGPLv3 vs. BSD-3-Clause und Zero-Downtime-Migration."
author: Aleksei Aleinikov
date: 2026-11-21
lang: de
tags: [valkey vs redis, valkey, valkey b+tree, valkey 9.2, redis 8 vs valkey, valkey sorted set speicher, redis zu valkey migrieren]
canonical: https://www.alekseialeinikov.com/de/blog/topics/data/valkey-vs-redis-btree-speicher-migration-leitfaden
source: alekseialeinikov.com
---

# Valkey vs. Redis: B+Tree Sorted Sets, 43 % weniger RAM & Migration

Viele Vergleiche zwischen **Valkey** und **Redis** klingen heute noch wie ein Lizenz-Kommentar von vor zwei Jahren: *„Valkey ist ein Drop-in-Fork von Redis 7.2.4 unter BSD-3-Clause.“*

Diese Sichtweise ist überholt. Mit **Valkey 9.2** und **Redis 8** haben sich beide Engines architektonisch deutlich auseinanderentwickelt. Valkey 9.2 ersetzt die klassische Skiplist in großen Sorted Sets durch einen Cache-freundlichen **B+Tree (`fbtree`)** — das spart **bis zu 43 % Speicher-Overhead** und **verdoppelt den `ZADD`-Durchsatz** — und ergänzt **Forkless Snapshots**, **Path Hash (`PH*`)** sowie natives **`HOTKEYS GET`**. Redis 8 wiederum erweitert seine Dreifach-Lizenz um **AGPLv3** und zieht **Vector Sets**, **JSON** und **TimeSeries** direkt in den Core.

![Valkey vs. Redis Titelbild: Kompakter saphirblauer B+Tree-Speicherblock neben einer lockeren roten Skiplist-Kette auf einem gebürsteten Stahlsockel.](https://www.alekseialeinikov.com/blog/valkey-vs-redis-cover.webp)

> [!NOTE]
> **Gegen offizielle Primärquellen geprüft.** Alle Speicher- und Durchsatzwerte zu Sorted Sets stammen direkt aus dem [offiziellen Valkey-9.2-Engineering-Artikel](https://valkey.io/blog/from-skiplist-to-b+tree/) von Rain Valentine und Dragos Andriciuc sowie aus den Dokumentationen zu [Valkey 9.2](https://valkey.io/) und [Redis 8](https://redis.io/).

> [!KEY]
> **Das kurze Urteil:** Beim klassischen `GET`/`SET`-Caching liegen Valkey und Redis 8 nur wenige Prozentpunkte auseinander. **Wähle Valkey**, wenn Speicherkosten, BSD-3-Clause-Compliance, Cloud-Standards (AWS ElastiCache, GCP Memorystore) oder große Sorted Sets zählen. **Wähle Redis 8** nur dann, wenn native Core-Features wie Vector Sets, JSON und TimeSeries zwingend aus einem Binary kommen müssen und AGPLv3 rechtlich freigegeben ist.

## Valkey 9.2 vs. Redis 8 im Überblick

Die Entscheidung dreht sich heute nicht mehr um Markenrechte, sondern um **speicheroptimierte Core-Architektur** (Valkey) gegen **integrierte All-in-One-Datenmodelle** (Redis 8):

| Kriterium | **Valkey 9.2** | **Redis 8** | **Auswirkung in Produktion** |
|---|---|---|---|
| **Governance** | Linux Foundation | Redis Ltd. | Herstellerneutrale vs. Single-Vendor-Roadmap |
| **Lizenz** | **BSD 3-Clause** | **Tri-Lizenz:** RSALv2 / SSPLv1 / **AGPLv3** | Permissiver Enterprise-Standard vs. Copyleft / Source-Available |
| **Große Sorted Sets** | **B+Tree (`fbtree`)** (`OBJECT ENCODING` → `btree`) | Klassische **Skiplist** + Hash Table | Bis zu **43 % weniger RAM** & **+105 % `ZADD`** bei Valkey |
| **Snapshots & Sync** | **Forkless** RDB/Sync-Option + Zstd/LZ4 | Fork-basiertes `BGSAVE` (Copy-on-Write) | Keine 2×-RAM-Spikes bei hoher Schreiblast |
| **KI- & Such-Typen** | **`PH*` Path Hash** (Radix-Tree) + `valkey-search`-Modul | **Native Vector Sets** (HNSW), JSON, TimeSeries | Redis 8 punktet bei Out-of-the-Box-RAG; Valkey beim Präfix-Routing |
| **Hot-Key-Erkennung** | Natives **`HOTKEYS GET`** (Space-Saving) | Client-/Proxy-Sampling oder kommerzielle Tools | Sofortige Sichtbarkeit ohne externe Agents |
| **Zugriffskontrolle** | `ACL` + wiederverwendbares **`ACL SETROLE`** | `ACL`-Kategorien & User-Regeln | Sauberes RBAC-Management in großen Clustern |

## 1. Valkey 9.2 `fbtree`: Warum B+Trees 43 % RAM sparen

Über ein Jahrzehnt lang kombinierten Redis und Valkey für große Sorted Sets (`ZSET`) eine Hash Table für `O(1)`-Score-Lookups mit einer **Skiplist** für Bereichsabfragen.

Skiplists sind leicht zu implementieren, kosten bei Millionen von Einträgen aber spürbar Speicher und CPU-Zeit:
1. **Pointer-Overhead:** Jeder Skiplist-Knoten liegt als eigene Heap-Allokation vor und trägt Forward-Pointer, Backward-Pointer und Span-Werte — rund **~29 Byte Struktur-Overhead pro Element**, noch bevor die Nutzdaten gespeichert sind.
2. **CPU-Cache-Misses:** Da die Knoten verstreut im Heap liegen, führt jedes Traversieren zu Pointer-Chasing über uncached Speicherseiten.

In **Valkey 9.2** ersetzt ein **B+Tree (`fbtree`)** mit hohem Fanout (**bis zu 61 Einträge pro Knoten**) die Skiplist. `OBJECT ENCODING myzset` liefert nun `btree` statt `skiplist`.

![Architekturvergleich zwischen klassischem Skiplist-Pointer-Chasing und dem Cache-freundlichen 61-Wege-B+Tree (fbtree) in Valkey 9.2.](https://www.alekseialeinikov.com/blog/valkey-skiplist-vs-btree.webp "Valkey 9.2 packt bis zu 61 Sorted-Set-Einträge zusammenhängend in einen B+Tree-Knoten und vermeidet Pointer-Overhead.")

Die offiziellen Valkey-9.2-Benchmarks (5 Mio. Elemente à 20 Byte) belegen den doppelten Effekt aus Speicherdichte und Cache-Lokalität:

- **Sequenzielle Inserts:** Overhead pro Element sinkt von **50,3 Byte → 28,5 Byte** (**43 % Ersparnis**, rund 109 MB weniger RAM).
- **Zufällige Inserts:** Overhead sinkt auf **32,0 Byte** (**36 % Ersparnis**, rund 92 MB weniger RAM).
- **Schreibdurchsatz:** **`ZADD` +105 %** und **`ZREM` +76 %** durch weniger Allokationen und bessere Cache-Treffer.

## 2. Durchsatz, Forkless Snapshots & Betrieb in Produktion

Beim klassischen `GET`/`SET`-Caching zeigen unabhängige Benchmarks zwischen Redis 8 und Valkey 8+/9+ nur **einstellige Prozentunterschiede** (bei extremer Sättigung über 1.000 parallele Verbindungen liegt teils Redis 8 leicht vorn, bei moderater Concurrency oft Valkey). Im Produktivbetrieb überlagern Netzwerk-RTT und Serialisierung diese Mikro-Differenzen.

Den spürbaren Unterschied im Alltag macht **Speicherstabilität unter Last**:

![Gemessener Speicher-Overhead und Durchsatzgewinn von Valkey 9.2 durch den Wechsel auf B+Tree (fbtree) bei 5 Mio. Sorted-Set-Einträgen.](https://www.alekseialeinikov.com/blog/valkey-vs-redis-benchmarks.webp "Valkey 9.2 B+Tree-Benchmarks (5 Mio. 20-Byte-Elemente): -43 % Speicher-Overhead und bis zu +105 % ZADD-Durchsatz.")

### Forkless Snapshots (ohne doppelten Copy-on-Write-Speicher)
Klassisches `BGSAVE` per `fork()` nutzt Copy-on-Write (CoW): Schreiben Clients während des Snapshots viele Keys um, verdoppelt sich der Speicherbedarf schnell — ein typischer Auslöser für OOM-Kills ab 60–70 % Auslastung.

![Interne Engine-Architektur im Vergleich: klassisches fork() Copy-on-Write mit bis zu 2× RAM-Spikes gegen die Forkless-Engine von Valkey 9.2 mit konstanter Speicherkurve und Inline-Zstd/LZ4-Sync.](https://www.alekseialeinikov.com/blog/valkey-forkless-architecture.webp "Forkless-Snapshots in Valkey 9.2 verhindern Copy-on-Write-Speicherspitzen bei RDB-Backups und Replica-Full-Syncs.")

Valkey 9.2 bietet optionale **Forkless Snapshots und Full-Syncs** sowie Zstd-/LZ4-Kompression für Replikationsströme:

```ini title="valkey.conf" {2-4}
# Speicherverbrauch bei RDB-Snapshots und Replikation konstant halten
forkless-infrastructure-enabled yes
forkless-policy snapshots-and-sync

# Integriertes Hot-Key-Tracking per Space-Saving-Algorithmus
hotkeys-top-k 20
```

> [!WARNING]
> **Trade-off beachten:** Ohne `fork()` entfallen CoW-RAM-Spikes, dafür läuft der Snapshot im Hauptprozess. Bei extremen Schreibspitzen während eines Forkless-Snapshots können kurze Tail-Latency-Ausschläge auftreten — vorab im Staging testen.

### `HOTKEYS GET`, `ACL SETROLE` und Path Hash (`PH*`)
- **`HOTKEYS GET` / `HOTKEYS RESET`:** Erkennt die $K$ heißesten Keys per **Space-Saving-Algorithmus** direkt im Server — ohne externes Traffic-Sniffing.
- **`ACL SETROLE`:** Wiederverwendbare Rollenvorlagen für saubere Benutzerrechte statt kopierter Kommando-Listen.
- **Path Hash (`PHSET`, `PHPREFIXES`):** Ein Radix-Tree-Datentyp für binärsichere Pfade — ideal für Longest-Prefix-Matching, Autocomplete und **das Indexing von LLM-KV-Cache-Präfixen**.

## 3. Wo Redis 8 weiterhin punktet (und die Lizenzfrage)

Mit der Rückkehr von Redis-Erfinder Salvatore Sanfilippo (`antirez`) liefert **Redis 8** echte Innovationen: **Vector Sets** (HNSW-Ähnlichkeitssuche für Embeddings) sowie native Integration von **JSON**, **TimeSeries**, probabilistischen Strukturen und der **Redis Query Engine** direkt im Core-Binary.

Wer **ein einziges Managed-System** für RAG-Vektorsuche, JSON-Dokumente und Caching ohne separate Module (`valkey-search`, `valkey-json`, `valkey-bloom`) sucht, hat mit Redis 8 den bequemeren Start.

Bleibt die **Lizenzfrage**:
- **Valkey:** Durchgängig **BSD 3-Clause** — kein Copyleft, keine Einschränkungen für SaaS oder eingebettete Produkte.
- **Redis 8:** Dreifach-Lizenz (**RSALv2, SSPLv1, AGPLv3**). Zwar ist AGPLv3 OSI-konform, doch viele Enterprise-Compliance-Abteilungen blockieren Netzwerk-Copyleft in internen und externen Backends weiterhin kategorisch.

## 4. Lokal prüfen & ohne Downtime migrieren

Verlasse dich nicht blind auf Hersteller-Benchmarks — starte beide Engines per Docker Compose und prüfe `OBJECT ENCODING` sowie `INFO memory` mit deinen eigenen Key-Größen (genau wie bei [produktivem PostgreSQL in Docker](https://www.alekseialeinikov.com/de/blog/topics/data/postgresql-in-docker-produktion)):

```yaml title="docker-compose.yml"
services:
  valkey:
    image: valkey/valkey:9.2-alpine
    ports: ["6379:6379"]
  redis:
    image: redis:8-alpine
    ports: ["6380:6379"]
```

```bash
# B+Tree-Encoding in Valkey vs. Skiplist in Redis prüfen (>128 Einträge)
valkey-cli -p 6379 OBJECT ENCODING leaderboard   # -> "btree"
redis-cli  -p 6380 OBJECT ENCODING leaderboard   # -> "skiplist"
```

### Zero-Downtime-Migration (Redis → Valkey)
Da Valkey dasselbe RESP-Protokoll spricht, funktionieren Client-Bibliotheken (`redis-py`, `ioredis`, `go-redis`) ohne Code-Änderung. Für Cluster auf Basis von Redis 7.2.x oder kompatiblen Core-Typen:

![Zero-Downtime-Migrationspfad von Redis zu Valkey: Valkey per REPLICAOF als Replikat anhängen, Full-Sync abwarten, Writes kurz pausieren, promoten und Endpoint umschalten.](https://www.alekseialeinikov.com/blog/valkey-migration-flow.webp "Live-Migration über REPLICAOF; Hinweis: RDB-Snapshots aus Valkey 9.2 sind nicht abwärtskompatibel zu Redis.")

1. **Valkey vorbereiten** mit identischem `maxmemory`, Eviction-Policy und ACLs.
2. **Als Replikat anhängen:** `REPLICAOF <redis-host> 6379` auf Valkey ausführen und warten, bis `master_link_status:up` und kein Replikations-Lag mehr besteht.
3. **Umschalten:** Writes kurz anhalten (oder per Kubernetes Service / Endpoint umschwenken), `REPLICAOF NO ONE` auf Valkey ausführen und Clients umleiten.
4. **RDB-Falle beachten:** Sobald Valkey 9.2 `btree`-Sorted-Sets oder `PH*`-Keys in RDB/AOF schreibt, **lässt sich dieser Snapshot nicht mehr zurück in Redis laden** — den alten Redis-Primary daher im Rollback-Fenster bereithalten.

## Fazit

Für **Caching, Sessions, Rate Limiting, Queues und große Sorted-Set-Leaderboards** ist **Valkey 9.2** heute die technisch und wirtschaftlich stärkere Wahl: **BSD-3-Clause**, bis zu **43 % weniger Sorted-Set-Speicher**, **Forkless Snapshots** und natives **`HOTKEYS GET`**. **Redis 8** lohnt sich dann, wenn **native Vector Sets, JSON und TimeSeries** im Core gebraucht werden und **AGPLv3** (oder Redis Cloud) freigegeben ist.

> Passend zu deinem Datenbank- und Plattform-Setup:
> - [PostgreSQL in Docker für Produktion: Volumes, Pooling & Backups](https://www.alekseialeinikov.com/de/blog/topics/data/postgresql-in-docker-produktion)
> - [Kubernetes 1.35–1.38 in Produktion: Was sich ändert und was bricht](https://www.alekseialeinikov.com/de/blog/topics/devops/kubernetes-135-136-137-138-produktionsaenderungen)
