Beispielanalyse des Redis-Persistenzmechanismus

Redis speichert Daten im Speicher und die Daten gehen verloren, wenn der Prozess beendet wird. Durch den Persistenzmechanismus von Redis können Daten im Speicher auf der Festplatte gespeichert und Daten aus Festplattendateien geladen werden, um den Speicher nach einem Neustart wieder aufzufüllen.

Redis unterstützt zwei Persistenzmechanismen: Vollspiegel-RDB und inkrementelle Persistenz-AOF.

RDB ist eine Momentaufnahme von Redis, die alle nicht abgelaufenen Schlüssel-Wert-Paare in Redis speichert.

Konfigurieren Sie RDB in redis.conf:redis.conf中配置RDB:

dbfilename dump.rdb
dir /var/lib/redis



save 900 1 save 300 10 save 60 10000 save "" stop-writes-on-bgsave-error yes rdbcompression yes rdbchecksum yes

每次redis进程启动时会先检查rdb文件是否存在，若存在则将文件中的内容加载到内存中。

redis自动更新RDB文件时会fork一个子进程执行快照保存工作，在保存期间主进程可以正常的提供服务。

我们同样可以通过指令保存快照:

• save: 以阻塞的方式保存快照，保存期间redis不能处理其它请求

• bgsave: fork一个子进程完成保存工作，保存期间不会影响redis的正常服务。

lastsave命令可以得到最新的RDB文件创建时间戳，可以用来检查保存是否成功。

RDB作为数据库快照，每次创建都需要将整个数据库写入到文件。这是一个非常耗时的操作，因此也难以频繁进行，在出现异常时可能丢失大量数据。

Redis提供了增量式持久化工具AOF(Append Only ile), AOF通过记录Redis数据库中所有写指令进行持久化。AOF文件中以Redis通信协议的格式存储指令。

当Redis进程启动时会检查AOF文件是否存在，若存在则依次执行AOF中的指令恢复数据。

Redis每次执行写指令时都会向AOF文件中添加一条日志，但新的记录不会立即写入磁盘(fsync)而是缓存在写入缓冲区中。

我们可以配置将缓冲区中的数据写入磁盘的策略，避免数据丢失。

将缓冲区中数据写入磁盘是一个耗时操作，频繁写磁盘会对性能造成影响但是Redis崩溃丢失数据也较少，因此我们需要根据应用场景进行权衡。

AOF中可能会记录多余的指令，若我们对同一个key执行了100次set指令, AOF文件中就会有100条记录但只仅保留最后一条set指令即可恢复数据。AOF重写会整理AOF文件清理不必要的指令日志（如删除被覆盖的set指令），减少AOF文件大小。

redis 采用后台重写的策略，即 fork 一个子进程把整理后的 AOF 写入到临时文件中。使用BGREWRITEAOF可以手动触发后台重写操作。

实际上AOF重写不会读取原来的AOF文件，子进程会带有一份当前数据的副本，并根据该副本直接生成新的AOF文件。

主进程在重写期间将新增的写操作写入原来的 AOF文件 和 AOF重写缓存 中，即使重写失败原来的AOF文件仍保存了完整的数据。当子进程完成AOF重写后会向主进程发送信号，主进程收到该信号后会将AOF重写缓存中的内容写入新的AOF文件，然后用新的AOF文件覆盖原有文件。

在redis.conf

appendonly yes  
  

appendfilename appendonly.aof  
  


appendfsync everysec 

    no-appendfsync-on-rewrite no   
  


auto-aof-rewrite-percentage 100  
  

auto-aof-rewrite-min-size 64mb

Bei jedem Start des Redis-Prozesses wird zunächst geprüft, ob die RDB-Datei vorhanden ist. Wenn sie vorhanden ist, wird der Inhalt der Datei geladen Erinnerung.

Wenn Redis die RDB-Datei automatisch aktualisiert, wird ein Unterprozess zur Snapshot-Speicherung erstellt. Während des Speicherzeitraums kann der Hauptprozess normale Dienste bereitstellen.

Wir können den Snapshot auch über den Befehl speichern:🎜

• 🎜save: Speichern Sie den Snapshot auf blockierende Weise, Redis kann andere nicht verarbeiten Anfragen während des Speicherns 🎜
• 🎜bgsave: Verzweigen Sie einen untergeordneten Prozess, um die Speicherarbeit abzuschließen. Der normale Dienst von Redis wird während des Speicherzeitraums nicht beeinträchtigt. 🎜

🎜lastsave Der Befehl kann den neuesten Zeitstempel für die RDB-Dateierstellung abrufen, mit dem überprüft werden kann, ob die Speicherung erfolgreich war. 🎜🎜RDB ist ein Datenbank-Snapshot, und bei jeder Erstellung muss die gesamte Datenbank in die Datei geschrieben werden. Dies ist ein sehr zeitaufwändiger Vorgang, daher ist es schwierig, ihn häufig durchzuführen, und wenn eine Ausnahme auftritt, können große Datenmengen verloren gehen. 🎜🎜Redis bietet das inkrementelle Persistenztool AOF (Append Only ile). AOF führt Persistenz durch, indem es alle Schreibanweisungen in der Redis-Datenbank aufzeichnet. Anweisungen werden in der AOF-Datei im Format des Redis-Kommunikationsprotokolls gespeichert. 🎜🎜Wenn der Redis-Prozess startet, prüft er, ob die AOF-Datei vorhanden ist. Wenn sie vorhanden ist, werden die Anweisungen in der AOF nacheinander ausgeführt, um die Daten wiederherzustellen. 🎜🎜Redis fügt jedes Mal, wenn ein Schreibbefehl ausgeführt wird, ein Protokoll zur AOF-Datei hinzu, der neue Datensatz wird jedoch nicht sofort auf die Festplatte geschrieben (fsync), sondern im Schreibpuffer zwischengespeichert. 🎜🎜Wir können die Strategie zum Schreiben von Daten im Puffer auf die Festplatte konfigurieren, um Datenverlust zu vermeiden. 🎜🎜Das Schreiben von Daten in den Puffer auf die Festplatte ist ein zeitaufwändiger Vorgang, der sich auf die Leistung auswirkt, aber Redis stürzt ab und verliert weniger Daten, daher müssen wir je nach Anwendungsszenario Kompromisse eingehen. 🎜🎜Redundante Anweisungen können in AOF aufgezeichnet werden. Wenn wir die Set-Anweisung 100 Mal für denselben Schlüssel ausführen, gibt es 100 Datensätze in der AOF-Datei, aber nur die letzte Set-Anweisung wird beibehalten, um die Daten wiederherzustellen. Durch das Umschreiben von AOF wird die AOF-Datei organisiert, unnötige Befehlsprotokolle bereinigt (z. B. das Löschen überschriebener Set-Befehle) und die Größe der AOF-Datei reduziert. 🎜🎜redis wendet eine Strategie zum Umschreiben im Hintergrund an, d. h. einen Unterprozess forken, um die sortierte AOF in eine temporäre Datei zu schreiben. Verwenden Sie BGREWRITEAOF, um den Umschreibevorgang im Hintergrund manuell auszulösen. 🎜🎜Tatsächlich wird beim AOF-Umschreiben die ursprüngliche AOF-Datei nicht gelesen. Der untergeordnete Prozess verfügt über eine Kopie der aktuellen Daten und generiert direkt eine neue AOF-Datei basierend auf der Kopie. 🎜🎜Der Hauptprozess schreibt die neuen Schreibvorgänge während des Umschreibzeitraums in die ursprüngliche AOF-Datei und den AOF-Rewrite-Cache. Selbst wenn das Umschreiben fehlschlägt, speichert die ursprüngliche AOF-Datei weiterhin die vollständigen Daten. Wenn der untergeordnete Prozess das AOF-Umschreiben abschließt, sendet er ein Signal an den Hauptprozess. Nach dem Empfang des Signals schreibt der Hauptprozess den Inhalt des AOF-Umschreibcaches in eine neue AOF-Datei und überschreibt dann die Originaldatei mit der neuen AOF-Datei. 🎜🎜Konfigurieren Sie AOF in redis.conf:🎜rrreee🎜Redis zeichnet die Größe der AOF-Datei beim Start oder nach dem letzten Neuschreiben auf, wenn die Größe der neuen Daten 100 % der ursprünglichen Größe erreicht (auto -aof-rewrite-percentage-Konfiguration) löst das Umschreiben aus. 🎜🎜Der Umschreibevorgang wird nur durchgeführt, wenn die aktuelle AOF-Dateigröße größer als die Mindestgröße des automatischen Umschreibens ist. Andernfalls wird das Umschreiben nicht durchgeführt, selbst wenn die Menge der neuen Daten den angegebenen Prozentsatz überschreitet. Dadurch wird das Problem des häufigen anfänglichen Umschreibens vermieden, das durch eine zu kleine Originaldatei verursacht wird. 🎜

Das obige ist der detaillierte Inhalt vonBeispielanalyse des Redis-Persistenzmechanismus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!