Exemple d'analyse du mécanisme de persistance Redis

Redis stocke les données en mémoire et les données seront perdues à la fin du processus. Grâce au mécanisme de persistance de Redis, les données en mémoire peuvent être stockées sur le disque et les données peuvent être chargées à partir de fichiers disque pour remplir la mémoire après un redémarrage.

Redis prend en charge deux mécanismes de persistance : le RDB en miroir complet et l'AOF de persistance incrémentielle.

RDB est un instantané de Redis, qui stocke toutes les paires clé-valeur non expirées dans Redis.

Configurez RDB dans 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

Chaque fois que le processus redis démarre, il vérifiera d'abord si le fichier rdb existe. existe, il va Le contenu du fichier est chargé en mémoire.

Lorsque Redis met automatiquement à jour le fichier RDB, il créera un processus enfant pour enregistrer l'instantané. Pendant la période de sauvegarde, le processus principal peut fournir des services normalement.

Nous pouvons également enregistrer l'instantané via la commande : #🎜🎜#

• #🎜🎜#save : pour bloquer la sauvegarde de l'instantané, Redis ne peut pas gérer d'autres requêtes pendant la période de sauvegarde #🎜🎜#
• #🎜🎜#bgsave : créer un processus enfant pour terminer le travail de sauvegarde , et Redis ne sera pas affecté pendant la période de sauvegarde du service normal. #🎜🎜#

#🎜🎜#La commande lastsave peut obtenir le dernier horodatage de création de fichier RDB, qui peut être utilisé pour vérifier si la sauvegarde a réussi. #🎜🎜##🎜🎜#RDB est un instantané de base de données, et chaque fois qu'il est créé, la base de données entière doit être écrite dans le fichier. Il s'agit d'une opération très longue, elle est donc difficile à effectuer fréquemment et une grande quantité de données peut être perdue lorsqu'une exception se produit. #🎜🎜##🎜🎜#Redis fournit l'outil de persistance incrémentielle AOF (Append Only ile). AOF effectue la persistance en enregistrant toutes les instructions d'écriture dans la base de données Redis. Les instructions sont stockées dans le fichier AOF au format du protocole de communication Redis. #🎜🎜##🎜🎜#Lorsque le processus Redis démarre, il vérifiera si le fichier AOF existe. S'il existe, les instructions de l'AOF seront exécutées séquentiellement pour restaurer les données. #🎜🎜##🎜🎜#Redis ajoutera un journal au fichier AOF à chaque fois qu'il exécute une commande d'écriture, mais le nouvel enregistrement ne sera pas écrit immédiatement sur le disque (fsync) mais sera mis en cache dans le tampon d'écriture. #🎜🎜##🎜🎜#Nous pouvons configurer la stratégie d'écriture des données dans le tampon sur le disque pour éviter la perte de données. #🎜🎜##🎜🎜#L'écriture des données du tampon sur le disque est une opération fastidieuse. L'écriture fréquente du disque affectera les performances, mais Redis plante et perd moins de données, nous devons donc faire un compromis basé sur le scénario d'application. #🎜🎜##🎜🎜#AOF peut enregistrer des instructions redondantes. Si nous exécutons l'instruction définie 100 fois pour la même clé, il y aura 100 enregistrements dans le fichier AOF mais seule la dernière instruction définie pourra être restaurée. La réécriture AOF organisera le fichier AOF, nettoiera les journaux de commandes inutiles (comme la suppression des commandes définies écrasées) et réduira la taille du fichier AOF. #🎜🎜##🎜🎜#redis adopte une stratégie de réécriture en arrière-plan, c'est-à-dire créer un processus enfant pour écrire l'AOF trié dans un fichier temporaire. Utilisez BGREWRITEAOF pour déclencher manuellement l'opération de réécriture en arrière-plan. #🎜🎜##🎜🎜#En fait, la réécriture AOF ne lira pas le fichier AOF d'origine. Le processus enfant aura une copie des données actuelles et générera directement un nouveau fichier AOF basé sur la copie. #🎜🎜##🎜🎜# Pendant la période de réécriture, le processus principal écrit les nouvelles opérations d'écriture dans le fichier AOF d'origine et le cache de réécriture AOF. Même si la réécriture échoue, le fichier AOF d'origine enregistre toujours les données complètes. Lorsque le processus enfant termine la réécriture AOF, il enverra un signal au processus principal. Après avoir reçu le signal, le processus principal écrira le contenu du cache de réécriture AOF dans un nouveau fichier AOF, puis écrasera le fichier d'origine par le nouveau. Fichier AOF. #🎜🎜##🎜🎜#Configurer AOF dans redis.conf : #🎜🎜#rrreee#🎜🎜#Redis enregistrera la taille du fichier AOF au démarrage ou après la dernière réécriture, s'il est nouveau Si la taille des données ajoutées atteint 100 % de la taille d'origine (configuration du pourcentage de réécriture automatique), la réécriture est déclenchée. #🎜🎜##🎜🎜#L'opération de réécriture ne sera effectuée que lorsque la taille actuelle du fichier AOF est supérieure à la taille minimale de la réécriture automatique. Sinon, la réécriture ne sera pas effectuée même si la quantité de nouvelles données dépasse la taille maximale. pourcentage spécifié. Cela évite le problème de réécriture initiale fréquente provoquée par le fait que le fichier d'origine est trop petit. #🎜🎜#

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!