Eine kurze Analyse der RDB- und AOF-Persistenz: Was sind die Vor- und Nachteile? Wie wähle ich?

In diesem Artikel erfahren Sie mehr über die Prinzipien der RDB- und AOF-Persistenz in redis. Welche Vor- und Nachteile haben sie? Analysieren Sie, welches verwendet werden sollte? Hoffe, es hilft allen!

Redis bietet zwei Persistenzlösungen: RDB und AOF:

• RDB: generiert innerhalb eines bestimmten Zeitintervalls einen Snapshot der Daten im Redis-Speicher, bei dem es sich um eine Binärdatei dumpr.rdb

• AOF handelt: Record Redis schreibt alle Befehle außer Abfragen und stellt Daten wieder her, indem diese Befehle beim Start des Redis-Dienstes erneut ausgeführt werden.

RDB-Persistenz

Standardmäßig speichert Redis Daten über einen bestimmten Zeitraum in Form von RDB-Snapshots auf der Festplatte und speichert sie als dumpr.rdb-Binärdatei. [Verwandte Empfehlungen: dumpr.rdb 二进制 文件。【相关推荐：Redis视频教程】

工作原理简单介绍一下：

当 Redis 需要做持久化时，Redis 会 fork 一个子进程，子进程将数据写到磁盘上一个临时 RDB 文件中。当子进程完成写临时文件后，将原来的 RDB 替换掉，这样的好处就是可以 copy-on-write。

当然我们也可以手动执行 save 或者 bgsave（异步）生成 RDB 文件。

redis.conf 默认配置

save 900  1
save 300  10
save 60  10000

• 900秒之内，如果超过1个key被修改，则发起快照保存；
• 300秒之内，如果超过10个key被修改，则发起快照保存；
• 60秒之内，如果1万个key被修改，则发起快照保存；

RDB 快照命令

在默认情况下， Redis 将数据库快照保存在名字为 dump.rdb 的二进制文件中。

你可以对 Redis 进行设置， 让它在“ N 秒内数据集至少有 M 个改动”这一条件被满足时， 自动保存一次数据集。

你也可以通过调用 SAVE 或者 BGSAVE ， 手动让 Redis 进行数据集保存操作。

比如说， 以下设置会让 Redis 在满足“ 60 秒内有至少有 1000 个键被改动”这一条件时， 自动保存一次数据集：

save 60 1000

这种持久化方式被称为快照（snapshot）。

RDB  创建原理

当 Redis 需要保存 dump.rdb 文件时， 服务器执行以下操作：

• Redis 调用 fork() ，同时拥有父进程和子进程。
• 子进程将数据集写入到一个临时 RDB 文件中。
• 当子进程完成对新 RDB 文件的写入时，Redis 用新 RDB 文件替换原来的 RDB 文件，并删除旧的 RDB 文件。

这种工作方式使得 Redis 可以从写时复制（copy-on-write）机制中获益。

RDB 的优点

RDB 是一个比较紧凑的文件，它保存了 Redis 在某个时间点的数据，这种数据比较适合做备份和用于灾难恢复。

比如说，你可以在最近的 24 小时内，每小时备份一次 RDB 文件，并且在每个月的每一天，也备份一个 RDB 文件。 这样的话，即使遇上问题，也可以随时将数据集还原到不同的版本。

RDB 的缺点

如果你需要尽量避免在服务器故障时丢失数据，那么 RDB 不适合你。 虽然 Redis 允许你设置不同的保存点来控制保存 RDB 文件的频率， 但是， 因为 RDB 文件需要保存整个数据集的状态， 所以它并不是一个轻松的操作。 因此你可能会至少 5 分钟才保存一次 RDB 文件。 在这种情况下， 一旦发生故障停机， 你就可能会丢失好几分钟的数据。

AOF 持久化

使用 AOF 做持久化，每一个写命令都通过 write 函数追加到 appendonly.aof 文件中。

AOF 就可以做到全程持久化，只需要在配置文件中开启（默认是 no ），appendfsync yesRedis-Video-Tutorial

]

Eine kurze Einführung in das Arbeitsprinzip:

Wenn Redis beibehalten werden muss, gibt Redis einen untergeordneten Prozess ab und der untergeordnete Prozess schreibt die Daten in eine temporäre RDB Datei auf der Festplatte. Wenn der untergeordnete Prozess mit dem Schreiben der temporären Datei fertig ist, ersetzen Sie die ursprüngliche RDB. Der Vorteil davon besteht darin, dass er Copy-on-Write ausführen kann.

Natürlich können wir save oder bgsave auch manuell (asynchron) ausführen, um RDB-Dateien zu generieren.

redis.conf-Standardkonfiguration

appendfsync yes
appendfsync always     #每次有数据修改发生时都会写入AOF文件。
appendfsync everysec   #每秒钟同步一次，该策略为AOF的缺省策略。

Wenn mehr als 1 Schlüssel innerhalb von 900 Sekunden geändert wird, wird das Speichern von Schnappschüssen eingeleitet. 🎜🎜Wenn mehr als 10 Schlüssel innerhalb von 300 Sekunden geändert werden, wird das Speichern von Schnappschüssen eingeleitet ;🎜 🎜Wenn 10.000 Schlüssel innerhalb von 60 Sekunden geändert werden, wird eine Snapshot-Speicherung initiiert;🎜🎜🎜🎜🎜RDB-Snapshot-Befehl🎜🎜🎜🎜Standardmäßig speichert Redis den Datenbank-Snapshot unter dem Namen dump.rdb in der Binärdatei. 🎜🎜Sie können Redis so einstellen, dass ein Datensatz automatisch gespeichert wird, wenn die Bedingung „Der Datensatz hat mindestens M Änderungen innerhalb von N Sekunden“ erfüllt ist. 🎜🎜Sie können Redis den Datensatz auch manuell speichern lassen, indem Sie SAVE oder BGSAVE aufrufen. 🎜🎜Die folgenden Einstellungen führen beispielsweise dazu, dass Redis automatisch einen Datensatz speichert, wenn die Bedingung „mindestens 1000 Schlüssel wurden innerhalb von 60 Sekunden geändert“ erfüllt: 🎜rrreee🎜Diese Persistenzmethode wird als Snapshot bezeichnet. 🎜🎜🎜🎜RDB-Erstellungsprinzip🎜🎜🎜🎜Wenn Redis die Datei dump.rdb speichern muss, führt der Server die folgenden Vorgänge aus: 🎜
🎜Redis ruft fork() auf und verfügt über übergeordnete und untergeordnete Prozesse. 🎜🎜Der untergeordnete Prozess schreibt den Datensatz in eine temporäre RDB-Datei. 🎜🎜Wenn der untergeordnete Prozess das Schreiben in die neue RDB-Datei abschließt, ersetzt Redis die ursprüngliche RDB-Datei durch die neue RDB-Datei und löscht die alte RDB-Datei. 🎜🎜🎜Diese Arbeitsweise ermöglicht es Redis, vom Copy-on-Write-Mechanismus zu profitieren. 🎜🎜🎜🎜Vorteile von RDB🎜🎜🎜🎜RDB ist eine relativ kompakte Datei, die Redis-Daten zu einem bestimmten Zeitpunkt speichert. Diese Art von Daten eignet sich besser für Backup und Notfallwiederherstellung. 🎜🎜Zum Beispiel können Sie eine RDB-Datei in den letzten 24 Stunden stündlich sichern und auch jeden Tag im Monat eine RDB-Datei sichern. Auf diese Weise können Sie den Datensatz jederzeit in einer anderen Version wiederherstellen, selbst wenn ein Problem auftritt. 🎜🎜🎜🎜Nachteile von RDB🎜🎜🎜🎜Wenn Sie den Datenverlust im Falle eines Serverausfalls minimieren müssen, ist RDB nichts für Sie. Obwohl Sie mit Redis verschiedene Speicherpunkte festlegen können, um die Häufigkeit des Speicherns von RDB-Dateien zu steuern, ist dies kein einfacher Vorgang, da RDB-Dateien den Status des gesamten Datensatzes speichern müssen. Daher können Sie die RDB-Datei mindestens alle 5 Minuten speichern. In diesem Fall kann es bei einem Ausfall zu einem Datenverlust von mehreren Minuten kommen. 🎜🎜🎜AOF-Persistenz🎜🎜🎜Verwenden Sie AOF für die Persistenz. Jeder Schreibbefehl wird über die Funktion write an die Datei appendonly.aof angehängt. 🎜🎜AOF kann eine vollständige Persistenz erreichen. Es muss nur in der Konfigurationsdatei aktiviert werden (Standard ist Nein). Nach dem Aktivieren von AOF fügt Redis es jedes Mal hinzu, wenn es einen Befehl ausführt Ändern Sie die Daten in die AOF-Datei. Wenn Redis neu startet, wird die AOF-Datei gelesen und „wiedergegeben“, um den letzten Moment vor dem Herunterfahren von Redis wiederherzustellen. 🎜🎜🎜🎜AOF-Konfiguration🎜🎜🎜🎜Sie können konfigurieren, wie oft Redis Daten auf die Festplatte synchronisiert. 🎜🎜redis.conf-Standardkonfiguration🎜rrreee🎜hat drei Optionen:🎜

1. Führen Sie fsync jedes Mal aus, wenn ein neuer Befehl an die AOF-Datei angehängt wird : sehr langsam und sehr sicher.
2, fsync einmal pro Sekunde: schnell genug (ungefähr genauso wie die Verwendung von RDB-Persistenz) und verliert im Falle eines Fehlers nur 1 Sekunde an Daten.
3, Nie fsync: Überlassen Sie die Daten dem Betriebssystem zur Verarbeitung. Schnellere und weniger sichere Option.

Die empfohlene (und standardmäßige) Maßnahme besteht darin, einmal pro Sekunde zu fsyncen. Diese Fsync-Strategie kann Geschwindigkeit und Sicherheit in Einklang bringen.

Prinzip der AOF-Erstellung

Das Umschreiben von AOF erfolgt auf die gleiche Weise wie das Erstellen von Snapshots durch RDB, die beide den Copy-on-Write-Mechanismus geschickt nutzen.

Das Folgende sind die Ausführungsschritte des AOF-Umschreibens:

Redis führt fork() aus und verfügt nun über übergeordnete und untergeordnete Prozesse.

Der untergeordnete Prozess beginnt, den Inhalt der neuen AOF-Datei in die temporäre Datei zu schreiben.

Für alle neu ausgeführten Schreibbefehle sammelt der übergeordnete Prozess sie in einem Speichercache und hängt diese Änderungen an das Ende der vorhandenen AOF-Datei an: Auf diese Weise bleibt die vorhandene AOF auch dann erhalten, wenn während des Neuschreibens ein Herunterfahren erfolgt Die Dateien sind weiterhin sicher.

Wenn der untergeordnete Prozess die Umschreibearbeit abschließt, sendet er ein Signal an den übergeordneten Prozess. Nach dem Empfang des Signals hängt der übergeordnete Prozess alle Daten im Speichercache an das Ende der neuen AOF-Datei an.

Fertig! Redis ersetzt nun atomar die alte Datei durch die neue und alle Befehle danach werden direkt an das Ende der neuen AOF-Datei angehängt.

Vorteile von AOF

1. Wenn Sie AOF für die Persistenz verwenden, können Sie verschiedene Fsync-Strategien festlegen, z. B. kein Fsync, fsync einmal pro Sekunde oder fsync jedes Mal, wenn ein Schreibbefehl ausgeführt wird.

Die Standardrichtlinie von AOF besteht darin, einmal pro Sekunde zu fsyncen. Unter dieser Konfiguration kann Redis immer noch eine gute Leistung aufrechterhalten, und selbst wenn ein Fehler auftritt, geht höchstens eine Sekunde an Daten verloren.

fsync wird in einem Hintergrundthread ausgeführt, sodass der Hauptthread weiterhin hart daran arbeiten kann, Befehlsanfragen zu verarbeiten.

2. Die AOF-Datei ist eine Protokolldatei, die nur Anhängevorgänge ausführt. Es handelt sich nicht um eine Protokolldatei, die nach der Erstellung einer neuen Datei ersetzt wird, selbst wenn das Protokoll aus bestimmten Gründen unvollständige Befehle enthält Beim Schreiben kann das Redis-Check-Aof-Tool dieses Problem ebenfalls leicht beheben.

3. Redis kann die AOF automatisch im Hintergrund neu schreiben, wenn die AOF-Datei zu groß wird: Die neue AOF-Datei enthält nach dem Umschreiben den minimalen Befehlssatz, der zum Wiederherstellen des aktuellen Datensatzes erforderlich ist.

Der gesamte Umschreibvorgang ist absolut sicher, da beim Umschreiben eine neue AOF-Datei erstellt wird. Die Befehle werden weiterhin an die vorhandene alte AOF-Datei angehängt Auch alte AOF-Dateien gehen nicht verloren. Sobald die neue AOF-Datei erstellt wurde, wechselt Redis von der alten AOF-Datei zur neuen AOF-Datei und beginnt mit dem Anhängen an die neue AOF-Datei.

4. Die AOF-Datei speichert alle in der Datenbank ausgeführten Schreibvorgänge in geordneter Weise. Diese Schreibvorgänge werden im Format des Redis-Protokolls gespeichert, sodass der Inhalt der AOF-Datei sehr einfach zu lesen und zu analysieren ist. analysieren). Es ist auch sehr entspannend. Auch der Export von AOF-Dateien ist sehr einfach: Wenn Sie beispielsweise versehentlich den Befehl _FLUSH ALL_ (Daten des gesamten Redis-Servers löschen (alle Schlüssel in allen Datenbanken löschen)) ausführen, solange die AOF-Datei nicht überschrieben wurde Solange Sie dann den Server stoppen, den Befehl FLUSHALL am Ende der AOF-Datei entfernen und Redis neu starten, können Sie den Datensatz in den Zustand vor der Ausführung von FLUSHALL zurückversetzen.

Nachteile von AOF

Für denselben Datensatz ist die Größe von AOF-Dateien normalerweise größer als die von RDB-Dateien.

Abhängig von der verwendeten fsync-Strategie ist AOF möglicherweise langsamer als RDB. Unter normalen Umständen ist die Fsync-Leistung pro Sekunde immer noch sehr hoch, und durch Deaktivieren von Fsync kann AOF selbst unter hoher Last so schnell wie RDB werden.

Bei der Verarbeitung großer Schreiblasten kann RDB jedoch eine garantiertere maximale Latenz bieten.

Der Unterschied zwischen RDB und AOF

RDB-Persistenz bezieht sich auf das Schreiben eines Snapshots des Datensatzes im Speicher auf die Festplatte innerhalb eines bestimmten Zeitintervalls. Der eigentliche Vorgang besteht darin, einen untergeordneten Prozess zu forken und den Datensatz zunächst danach zu schreiben Die temporäre Datei wurde erfolgreich geschrieben, die vorherige Datei wird ersetzt und mit binärer Komprimierung gespeichert.

AOF-Persistenz zeichnet alle vom Server verarbeiteten Schreib- und Löschvorgänge in Form eines Protokolls auf. Datensätze werden nicht in Form von Text angehängt. Sie können die Datei öffnen, um detaillierte Vorgangsdatensätze anzuzeigen.

RDB oder AOF, welches soll ich verwenden?

Wenn Ihnen Ihre Daten sehr am Herzen liegen, Sie sich aber dennoch einen Datenverlust innerhalb von Minuten leisten können, dann können Sie einfach RDB-Persistenz verwenden.

AOF hängt jeden von Redis ausgeführten Befehl an die Festplatte an. Die Verarbeitung großer Schreibvorgänge verringert die Leistung von Redis. Ich weiß nicht, ob Sie das akzeptieren können.

Datenbanksicherung und Notfallwiederherstellung:

Das regelmäßige Generieren von RDB-Snapshots ist für die Datenbanksicherung sehr praktisch, und RDB stellt Datensätze schneller wieder her als AOF.

Redis unterstützt das gleichzeitige Öffnen von RDB und AOF. Nach dem Systemneustart gibt Redis der Verwendung von AOF zur Datenwiederherstellung Vorrang, sodass der Datenverlust möglichst gering ist.

AOF BGREWRITEAOF Umschreiben

Da AOF kontinuierlich Befehle an das Ende der Datei anhängt, wird die Größe der AOF-Datei mit zunehmender Anzahl der Schreibbefehle immer größer.

Zum Beispiel

Wenn Sie INCR 100 Mal für einen Zähler aufrufen, muss die AOF-Datei nur zum Speichern des aktuellen Werts des Zählers 100 Datensätze (Eintrag) verwenden.

Tatsächlich reicht jedoch die Verwendung nur eines SET-Befehls aus, um den aktuellen Wert des Zählers zu speichern, und die verbleibenden 99 Datensätze sind tatsächlich redundant.

Um mit dieser Situation umzugehen, unterstützt Redis eine interessante Funktion: AOF-Dateien können ohne Unterbrechung des Service-Clients rekonstruiert werden.

Führen Sie den Befehl BG REWRITE AOF aus. Redis generiert eine neue AOF-Datei, die die zur Rekonstruktion des aktuellen Datensatzes erforderlichen Mindestbefehle enthält. BG REWRITE AOF 命令， Redis 将生成一个新的 AOF 文件， 这个文件包含重建当前数据集所需的最少命令。

Redis 2.2 需要自己手动执行 BGREWRITEAOF

Redis 2.2 erfordert die manuelle Ausführung des Befehls BGREWRITEAOF. Spezifische Informationen finden Sie in der Beispielkonfigurationsdatei von 2.4.

Redis-Daten sichern

Festplattenfehler, Knotenfehler und andere Probleme können dazu führen, dass Ihre Daten verloren gehen.
Redis ist sehr benutzerfreundlich für die Datensicherung, da Sie die RDB-Datei kopieren können, während der Server läuft: Sobald die RDB-Datei erstellt ist, werden keine Änderungen vorgenommen. Wenn der Server eine neue RDB-Datei erstellen möchte, speichert er zunächst den Inhalt der Datei in einer temporären Datei. Wenn die temporäre Datei geschrieben wird, verwendet das Programm rename(2), um die ursprüngliche RDB-Datei atomar durch die temporäre Datei zu ersetzen.
Das bedeutet, dass das Kopieren von RDB-Dateien jederzeit absolut sicher ist.

Das Folgende sind unsere Vorschläge

:
1. Erstellen Sie eine reguläre Aufgabe (Cronjob), um jede Stunde eine RDB-Datei in einem Ordner zu sichern, und sichern Sie eine RDB-Datei jeden Tag in einem anderen Ordner.
2. Stellen Sie sicher, dass die Snapshot-Backups über entsprechende Datums- und Zeitinformationen verfügen. Verwenden Sie jedes Mal, wenn Sie das reguläre Aufgabenskript ausführen, um abgelaufene Snapshots zu löschen: Sie können beispielsweise stündliche Snapshots innerhalb der letzten 48 Stunden aufbewahren Sie können auch tägliche Schnappschüsse der letzten ein oder zwei Monate aufbewahren.
3. Sichern Sie die RDB mindestens einmal am Tag außerhalb Ihres Rechenzentrums oder zumindest außerhalb der physischen Maschine, auf der Sie den Redis-Server betreiben.

Weitere Kenntnisse zum Thema Programmierung finden Sie unter: Programmiervideos

! ! 🎜

Das obige ist der detaillierte Inhalt vonEine kurze Analyse der RDB- und AOF-Persistenz: Was sind die Vor- und Nachteile? Wie wähle ich?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!