BlogRedis

Redis-Speicherprobleme: Warum Redis abstürzt und wie Sie richtig dimensionieren

Scott Sternloff

Von Scott Sternloff, Senior Enterprise Architect

LinkedIn · Aktualisiert am · 12 Min. Lesezeit

Redis-Speicherprobleme: Warum Redis abstürzt und wie Sie richtig dimensionieren
Auf dieser Seite

Redis stürzt aus Speichergründen ab, die die Metrik used_memory nicht zeigt: Der RDB-Fork kann den residenten Speicher unter Schreiblast nahezu verdoppeln, Allocator-Fragmentierung bläht die RSS über die eigentlichen Daten hinaus auf, und maxmemory regelt nur den Keyspace – nicht Replikations-Buffer, Client-Buffer oder den Fork. Dimensionieren Sie für die Spitze plus Overhead, nicht für den Datenbestand.

Das Muster ist so konsistent, dass es einer Signatur gleicht. Eine Instanz läuft bei scheinbar komfortabler Auslastung, kein Alert schlägt an – und dann ist sie tot. Niemand kann es reproduzieren, denn die Redis-Speichermetrik, auf die alle schauen, hat nie das gemessen, woran die Instanz gestorben ist.

Was begrenzt maxmemory tatsächlich?

Weniger, als die meisten Teams annehmen. Die Redis-Dokumentation sagt es unmissverständlich: Zum Speichern von Benutzer-Keys „allokiert Redis höchstens so viel Speicher, wie die Einstellung maxmemory zulässt (kleine zusätzliche Allokationen sind allerdings möglich)“.

Dieser Satz hat es in sich. maxmemory begrenzt den Keyspace, und der ist nur ein Teil des gesamten Redis-Speichers. Nicht begrenzt werden:

  • Der Fork. Ein Hintergrund-Save dupliziert Pages, sobald sie verändert werden. Nichts an maxmemory schränkt das ein.
  • Client-Output-Buffer. Ein langsamer Consumer, eine MONITOR-Session oder ein großes Pub/Sub-Fan-out sammelt serverseitig Daten an, die darauf warten, ausgeliefert zu werden.
  • Das Replication Backlog. Es liegt auf dem Primary, damit Replicas einen partiellen Resync durchführen können, und wird unabhängig dimensioniert.
  • Allocator-Overhead. Pages, die der Allocator hält, die Redis aber gerade nicht nutzt.

Lesen Sie Ihre tatsächlichen Limits aus, statt sich auf Standardwerte aus dem Gedächtnis zu verlassen – die variieren je nach Version und je nachdem, wie die Instanz provisioniert wurde:

CONFIG GET maxmemory
CONFIG GET maxmemory-policy
CONFIG GET client-output-buffer-limit
CONFIG GET repl-backlog-size

Die praktische Konsequenz: Eine Instanz, deren maxmemory auf den gesamten Host-RAM gesetzt ist, ist nicht geschützt. Sie ist so konfiguriert, dass sie ausfällt.

Wie hängen maxmemory und Eviction zusammen?

Zwei Einstellungen – und eine davon setzt die andere stillschweigend außer Kraft.

maxmemory legt die Obergrenze fest. maxmemory-policy entscheidet, was beim Erreichen passiert. Ist die Policy noeviction, lehnt Redis Schreibzugriffe mit OOM command not allowed when used memory > 'maxmemory' ab und bedient weiter Lesezugriffe – ein bewusst lauter Fehler, der für einen Datenspeicher richtig und für einen Cache falsch ist.

Die Falle ist die volatile-*-Familie. Diese Policies berücksichtigen nur Keys mit TTL. Setzen Sie volatile-lru auf einem Keyspace, in dem nichts abläuft, hat Redis überhaupt keine Kandidaten für die Eviction: Es verhält sich exakt wie noeviction, während Ihre Konfiguration etwas anderes behauptet. Alle acht Optionen gehen wir im Beitrag zur Redis Eviction Policy durch.

Eine Asymmetrie, die Sie kennen sollten, bevor Sie ein Replica-Set dimensionieren: Replicas ignorieren maxmemory standardmäßig. Die Eviction steuert der Primary, der beim Verdrängen DEL an die Replicas weitergibt. Die Redis-Dokumentation warnt selbst, dass eine Replica „am Ende mehr Speicher verwenden kann, als über maxmemory festgelegt ist“, und rät sicherzustellen, dass Replicas „genug Speicher haben, um niemals in einen echten Out-of-Memory-Zustand zu geraten, bevor der Master die konfigurierte maxmemory-Einstellung erreicht“. Eine Replica, die genauso dimensioniert ist wie ihr Primary, ist unterdimensioniert.

Warum ist used_memory_rss so viel höher als used_memory?

Fragmentierung. Die Redis-Kennzahl, auf die es hier ankommt, ist simple Arithmetik:

INFO memory
# used_memory              — bytes Redis has allocated for data
# used_memory_rss          — resident set size: pages the OS has actually given the process
# mem_fragmentation_ratio  — used_memory_rss / used_memory

Eine Rate nahe 1,0 ist gesund. Liegt sie deutlich über 1, hält der Allocator Pages, die keine Daten tragen. Das passiert, weil – so die Redis-Dokumentation – „Redis Speicher nicht immer an das Betriebssystem freigibt (zurückgibt), wenn Keys entfernt werden. Das ist keine Besonderheit von Redis, sondern die Art, wie die meisten malloc()-Implementierungen arbeiten.“ Löschen Sie 2 GB aus einer 5-GB-Instanz, zeigt die RSS sehr wahrscheinlich immer noch knapp 5 GB an.

Daraus folgen zwei Dinge, und das zweite übersehen viele:

  • Für die Spitze provisionieren. Die Dokumentation ist eindeutig: „Sie müssen den Speicher anhand Ihrer Spitzenauslastung provisionieren. Wenn Ihre Workload von Zeit zu Zeit 10 GB benötigt, auch wenn meistens 5 GB reichen würden, müssen Sie 10 GB provisionieren.“
  • Nach einer Spitze lügt die Rate. Redis sagt es direkt: „Die Fragmentierungsrate ist nicht zuverlässig, wenn die Speichernutzung zur Spitze deutlich höher war als der aktuell genutzte Speicher“ – denn die RSS spiegelt die Spitze wider, used_memory dagegen den Ist-Zustand. Eine Rate von 3,0 auf einer Instanz, die kürzlich den Großteil ihres Keyspace abgegeben hat, ist erwartetes Verhalten, kein Fehler. Ihr mit Defragmentierung hinterherzujagen, ist vergebliche Mühe.

Wo die Fragmentierung unter gleichmäßiger Last tatsächlich bestehen bleibt, gibt es die aktive Defragmentierung:

CONFIG GET activedefrag
MEMORY PURGE

Aktivieren Sie sie bewusst und achten Sie in LATENCY LATEST auf das Event active-defrag-cycle – die Defragmentierung verbraucht CPU auf dem einzigen Befehls-Thread und tauscht damit Speicher gegen Latenz.

Warum stirbt Redis während eines Backups?

Das ist der Ausfall, nach dem es heißt: „Es ist abgestürzt, und die Metriken zeigen nichts.“

Redis erstellt Snapshots per Fork. Der Child-Prozess schreibt die RDB-Datei, während der Parent weiter Anfragen bedient, und beide teilen sich den Speicher per Copy-on-Write. Jede Page, die der Parent während des Saves verändert, wird dupliziert. Unter anhaltender Schreiblast steigt der gesamte Prozessspeicher in Richtung des doppelten Datenbestands – und nichts davon taucht in used_memory auf, weil es nicht zum Keyspace gehört. Das ist die größte einzelne Lücke zwischen gemeldetem und tatsächlichem Speicherverbrauch von Redis.

INFO persistence
# rdb_bgsave_in_progress   — is a save running right now
# latest_fork_usec         — how long the last fork() blocked the server
# rdb_last_bgsave_status   — ok, or the save is failing

Wir haben wiederholte Abstürze im Redis-Cluster eines Kunden untersucht, dessen gemeldete Auslastung nie über etwa 60 Prozent lag. Nichts in den Redis-Metriken erklärte das, und kein Alert-Schwellenwert war überschritten worden. Die Ursache war das Fork-Verhalten während der Backups, und die Lösung war ein Tuning des Memory Overcommit auf Kernel-Ebene – überhaupt keine Redis-Einstellung. Derselbe Mechanismus steckt hinter mehreren der Verfügbarkeitsausfälle, die wir unter Redis High Availability beschreiben.

Der Fork kostet außerdem Latenz, unabhängig vom Speicher. Die Redis-Dokumentation zur Persistenz merkt an, dass fork() „zeitaufwendig sein kann, wenn der Datenbestand groß ist, und dazu führen kann, dass Redis für einige Millisekunden oder sogar eine Sekunde keine Clients mehr bedient, wenn der Datenbestand sehr groß und die CPU-Leistung nicht gut ist“. latest_fork_usec liefert Ihnen diesen Wert für den letzten Save.

Praxisfall: Abstürze bei 61 Prozent durch ständiges Reindexing

Dieser Fall verdient eine ausführliche Beschreibung, denn er ist die Variante des Problems, die kein noch so gründliches Redis-Tuning behoben hätte.

In einem AceMQ-Projekt kam es bei einem Kunden wiederholt zu Abstürzen bei einer Speicherschwelle von etwa 61 Prozent. Dieselbe Signatur wie oben – auf dem Papier reichlich Reserve, in der Praxis eine tote Instanz. Doch der Fork war nur ein Teil davon. Folgendes fanden wir in der Workload:

  • Jeder Geräte-Heartbeat löste einen vollständigen Reindex des Dokuments aus. Die Anwendung speicherte Gerätedokumente und indexierte sie für Abfragen. Ein Heartbeat aktualisierte ein triviales Feld – einen Zeitstempel –, und der Schreibpfad indexierte das gesamte Dokument neu statt nur das geänderte Attribut. Bei der Größe der Geräteflotte wurde aus einem leichtgewichtigen Lebenszeichen ein ununterbrochener Index-Churn, mit dem Speicherprofil eines Bulk-Reloads im Dauerbetrieb.
  • Alte Indizes blieben liegen. Ersetzte Indexstrukturen wurden nicht sauber freigegeben, sodass der dem Indexing zuzurechnende Speicher mit der Zeit anstieg – unabhängig vom Datenvolumen. Der Keyspace wirkte stabil, der Prozess nicht.
  • UUID-Felder wurden grundlos indexiert. Opake Bezeichner mit hoher Kardinalität, nach denen nichts abfragte – und jeder einzelne fügte Indexstruktur hinzu, die die Workload nie las.

Kommen diese drei Faktoren zusammen, entsteht eine Instanz, deren tatsächlicher Redis-Speicherbedarf von der Indexpflege dominiert wird und genau dann in die Höhe schießt, wenn der Schreibverkehr steigt – also ausgerechnet dann, wenn ein Snapshot am teuersten ist. Die 61 Prozent waren in keinem sinnvollen Sinne ein Schwellenwert. Dort lag schlicht die Basislinie, als die nächste Überlappung von Reindex und Fork eintraf.

Die Abhilfe, die wir gemeinsam mit dem Kunden erarbeitet haben, war architektonischer Natur, keine Konfigurationsfrage:

  • Heartbeat-Daten vom indexierten Dokument trennen. Liveness-Updates sollten keine Struktur berühren, die neu indexiert werden muss. Lagern Sie die volatilen Felder in einen eigenen Key mit eigenem Lebenszyklus aus.
  • Indizes regelmäßig löschen und neu anlegen, statt darauf zu vertrauen, dass die inkrementelle Freigabe mit dem Churn Schritt hält. Ein geplanter Rebuild gibt Speicher zurück, den die inkrementelle Garbage Collection bei dieser Schreibrate nie erreicht hätte.
  • Die Garbage Collection der Indizes tunen, damit die Freigabe mit der Schreibrate Schritt hält, statt dauerhaft hinterherzuhinken.
  • Reindex-Jobs aus den Spitzenzeiten verlagern, damit Bulk-Indexarbeit und Spitzen-Schreibverkehr nicht länger um dieselbe Reserve konkurrieren.
  • Keine Felder mehr indexieren, die niemand abfragt. Die UUIDs flogen raus.

Nichts davon lässt sich aus INFO memory ablesen. Wenn Ihre Redis-Instanz eine Query Engine über Dokumente betreibt, die weit häufiger geschrieben als strukturell verändert werden, ist das die erste Stelle, an der Sie suchen sollten – lange bevor Sie maxmemory anfassen.

Redis-Speicher-Assessment anfordern

Redis stirbt bei einer Auslastung, die Ihre Metriken für sicher halten? Fork-Overhead, Fragmentierung und Index-Churn sind für used_memory allesamt unsichtbar. AceMQ führt strukturierte Redis-Speicher-Assessments durch, die genau das aufdecken, und bietet Enterprise-Redis-Support für produktive Umgebungen. Sprechen Sie mit einem AceMQ-Engineer.

Wie finde ich heraus, was den Redis-Speicher tatsächlich belegt?

Beginnen Sie breit und grenzen Sie dann ein. All diese Befehle sind auch auf einer stark ausgelasteten Produktionsinstanz sicher, weil sie mit SCAN iterieren, statt mit KEYS zu blockieren.

MEMORY DOCTOR              # Redis's own read on whether memory looks unhealthy
MEMORY STATS               # breakdown by category: dataset, replication backlog, clients, overhead
redis-cli --memkeys        # biggest keys by bytes consumed
redis-cli --bigkeys        # biggest keys by element count, per type
redis-cli --keystats       # both, plus size distribution and a top-N list
MEMORY USAGE <key>         # exact bytes for one key

--bigkeys und --memkeys beantworten unterschiedliche Fragen, und beides wird oft verwechselt. Ein Set mit zehn Millionen kleinen Integer-Elementen ist nach Elementanzahl riesig, nach Bytes aber moderat; ein einzelner String mit einem serialisierten Blob von 200 MB ist das Gegenteil. Das Erste ist ein Latenzproblem – jeder O(N)-Befehl darauf blockiert den Server. Das Zweite ist ein Speicherproblem. Sie brauchen beide Messwerte.

Drosseln Sie beide Scans auf einer ausgelasteten Instanz mit -i 0.01, damit zwischen den SCAN-Batches pausiert wird.

Ein Muster, das einen eigenen Namen verdient: Write Amplification durch überdimensionierte Werte. Wer ein ganzes Objekt speichert und es komplett neu schreibt, um ein einzelnes Feld zu ändern, bezahlt bei jedem Update die volle serialisierte Größe – als Allokations-Churn und, falls die Instanz persistiert, als Copy-on-Write-Pages. Hashes mit Updates pro Feld vermeiden das vollständig. Es ist dasselbe Muster wie im Reindexing-Fall oben, nur eine Ebene tiefer.

Wie sollte ich den Redis-Speicher dimensionieren?

Arbeitsregeln für das Sizing des Redis-Speichers, in der Reihenfolge ihrer Bedeutung:

  1. Für die Spitze dimensionieren, nicht für den Normalbetrieb. Die RSS folgt dem Höchststand, weil der Allocator Pages nicht bereitwillig zurückgibt.
  2. Auf einer Instanz, die unter Schreiblast Snapshots erstellt, sollte der Datenbestand bei etwa 50–60 Prozent des RAM liegen. Der Rest ist Reserve für den Fork. Nicht 80 Prozent und schon gar nicht 100.
  3. Braucht eine Instanz keine Snapshots, schalten Sie sie ab. Ein Cache, der sich neu aufbauen lässt, braucht kein RDB, und ohne Fork entfällt die gesamte Fehlerklasse. Persistieren Sie stattdessen auf einer Replica.
  4. Alerts auf die RSS des Prozesses setzen, nicht nur auf used_memory. Die Metrik, an der Ihre Instanz stirbt, ist nicht die, die Redis meldet.
  5. Replicas unabhängig dimensionieren. Sie ignorieren maxmemory standardmäßig und können mehr Speicher belegen als ihr Primary.
  6. maxmemory deutlich unter dem Host-RAM ansetzen. Steht der Wert auf dem gesamten Arbeitsspeicher der Maschine, entscheidet der OOM Killer des Kernels, was als Nächstes passiert – nicht Redis.

Nutzen Sie Redis als Queue und folgt der Speicherdruck der Queue-Tiefe, ist die Sizing-Frage eigentlich eine Architekturfrage – ein Broker mit festplattenbasierten Queues kennt diesen Fehlermodus nicht. Die Abwägung behandeln wir im Beitrag Redis und RabbitMQ gemeinsam betreiben.

Den umfassenderen Diagnosepfad rund um diese Symptome – langsame Befehle, hängende Replikation, Verbindungslimits – finden Sie in unserem Leitfaden zum Redis-Troubleshooting.

Dies ist Schritt zwei von sieben im Redis-Leitfaden für Zuverlässigkeit, der die Probleme in der Reihenfolge behandelt, in der sie in einer Produktionsumgebung auftreten.

FAQ

Warum stürzt Redis ab, obwohl der Speicherverbrauch unauffällig aussieht?

Weil used_memory den Keyspace misst, nicht den Prozess. Während eines Hintergrund-Saves kann das Copy-on-Write-Verhalten des Forks den gesamten Prozessspeicher in Richtung des doppelten Datenbestands treiben. Eine Instanz, die 60 Prozent Auslastung meldet, kann den RAM also mitten im Save erschöpfen.

Was begrenzt maxmemory in Redis tatsächlich?

Den Speicher, den Redis für Benutzerdaten allokiert, zuzüglich kleiner zusätzlicher Allokationen. Der Fork während eines Snapshots ist nicht abgedeckt, und Buffer können den residenten Speicher deutlich darüber hinaustreiben. Betrachten Sie maxmemory als Obergrenze für den Keyspace, nicht für den Prozess.

Welche Fragmentierungsrate ist beim Redis-Speicher gesund?

Etwa 1,0 bis 1,5 bei einer Instanz im stabilen Betrieb. Die Rate ist used_memory_rss geteilt durch used_memory; ein Wert deutlich über 1 bedeutet also, dass der Allocator Pages hält, die Redis nicht nutzt. Redis weist selbst darauf hin, dass die Rate nach einer großen, inzwischen wieder freigegebenen Spitze unzuverlässig ist.

Wie finde ich heraus, was den Redis-Speicher belegt?

redis-cli --memkeys für die größten Keys nach Bytes und --bigkeys für die größten nach Anzahl der Elemente. Beide nutzen SCAN und sind damit produktionssicher. MEMORY USAGE <key> liefert den exakten Wert für einen einzelnen Key, und MEMORY STATS schlüsselt den gesamten Redis-Speicher nach Kategorien auf.

Wie viel RAM braucht eine Redis-Instanz?

Planen Sie für die Spitze, nicht für den Durchschnitt – Redis gibt freigegebenen Speicher nicht zuverlässig an das Betriebssystem zurück, daher folgt die RSS dem Höchststand. Auf einer Instanz, die unter Schreiblast Snapshots erstellt, lässt ein Datenbestand von etwa 50 bis 60 Prozent des RAM genug Platz für den Fork-Overhead.

Gibt Redis Speicher frei, wenn ich Keys lösche?

Nicht unbedingt an das Betriebssystem. Der Allocator verwendet den freigewordenen Platz meist für neue Keys wieder, sodass der residente Speicher konstant bleibt, statt zu sinken. Das ist normales Allocator-Verhalten, kein Speicherleck in Redis.

Halten sich Redis-Replicas an maxmemory?

Standardmäßig nicht. Replicas ignorieren maxmemory und überlassen die Eviction dem Primary, der sie über replizierte DEL-Befehle steuert. Eine Replica kann daher das Limit des Primary überschreiten und in einen echten Out-of-Memory-Zustand geraten. Überwachen Sie den Speicher der Replicas separat.

Warum wächst der Speicher weiter, obwohl der Keyspace nicht wächst?

Suchen Sie außerhalb des Keyspace: Client-Output-Buffer langsamer Consumer, das Replication Backlog, Allocator-Fragmentierung und – auf Instanzen mit Query Engine – Indexstrukturen samt ihrem Garbage, die nicht so gezählt werden, wie man es erwartet.

Quellen

Scott Sternloff

Autor

Scott SternloffSenior Enterprise Architect

Senior Enterprise Architect bei AceMQ. Verantwortet hier die technischen Beiträge: Architektur, Clustering und Migrationen von RabbitMQ, Kafka und Redis.

Kostenlose Beratung

Lassen Sie Experten auf Ihre Redis-Installation schauen

Ob Sie einen Produktionsvorfall beheben, eine Migration planen oder eine zweite Meinung zu Ihrer Architektur wünschen – unser Team steht bereit. Kein Verkaufsgespräch, nur Antworten.

E-Mail schreiben