读完这篇，你一定能真正理解Redis持久化

 它支持的数据类型很丰富，如字符串、链表、集合、以及散列等，并且还支持多种排序功能。

网站建设哪家好，找成都创新互联公司！专注于网页设计、网站建设、微信开发、成都小程序开发、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了洛隆免费建站欢迎大家使用！

什么叫持久化?

用一句话可以将持久化概括为：将数据(如内存中的对象)保存到可***保存的存储设备中。

持久化的主要应用是将内存中的对象存储在数据库中，或者存储在磁盘文件中、 XML 数据文件中等等。

也可以从如下两个层面来理解持久化：

  • 应用层：如果关闭( Close )你的应用，然后重新启动则先前的数据依然存在。
  • 系统层：如果关闭( Shut Down )你的系统(电脑)，然后重新启动则先前的数据依然存在。

Redis 为什么要持久化?

Redis 中的数据类型都支持 Push/Pop、Add/Remove 及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。

在此基础上，Redis 支持各种不同方式的排序。与 Memcached 一样，为了保证效率，数据都是缓存在内存中。

因为数据都是缓存在内存中的，当你重启系统或者关闭系统后，缓存在内存中的数据都会消失殆尽，再也找不回来了。

所以，为了让数据能够长期保存，就要将 Redis 放在缓存中的数据做持久化存储。

Redis 怎么实现持久化?

在设计之初，Redis 就已经考虑到了这个问题。官方提供了多种不同级别的数据持久化的方式：

  • RDB 持久化方式能够在指定的时间间隔对你的数据进行快照存储。
  • AOF 持久化方式记录每次对服务器写的操作，当服务器重启的时候会重新执行这些命令来恢复原始的数据，AOF 命令以 Redis 协议追加保存每次写的操作到文件末尾。

Redis 还能对 AOF 文件进行后台重写，使得 AOF 文件的体积不至于过大。

  • 如果你只希望你的数据在服务器运行的时候存在，你也可以不使用任何持久化方式。
  • 你也可以同时开启两种持久化方式，在这种情况下，当 Redis 重启的时候会优先载入 AOF 文件来恢复原始的数据，因为在通常情况下 AOF 文件保存的数据集要比 RDB 文件保存的数据集要完整。

如果你不知道该选择哪一个级别的持久化方式，那我们就先来了解一下 AOF 方式和 RDB 方式有什么样的区别，并且它们各自有何优劣，学习完之后，再来考虑该选择哪一种级别。

RDB 方式与 AOF 方式的优势对比

RDB 方式与 AOF 方式的优点对比

首先我们来看一看官方对于两种方式的优点描述，并做个对比，然后再看一看两种方式的缺点描述。

 

RDB 方式的优点：

  • RDB 是一个非常紧凑的文件,它保存了某个时间点的数据集，非常适用于数据集的备份。
  • 比如你可以在每个小时保存一下过去 24 小时内的数据，同时每天保存过去 30 天的数据，这样即使出了问题你也可以根据需求恢复到不同版本的数据集。
  • RDB 是一个紧凑的单一文件，很方便传送到另一个远端数据中心，非常适用于灾难恢复。
  • RDB 在保存 RDB 文件时父进程唯一需要做的就是 Fork 出一个子进程，接下来的工作全部由子进程来做，父进程不需要再做其他 IO 操作，所以 RDB 持久化方式可以***化 Redis 的性能。
  • 与 AOF 相比，在恢复大的数据集的时候，RDB 方式会更快一些。

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

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

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

 

AOF 方式的优点：

  • 使用 AOF 会让你的 Redis 更加耐久。
  • 你可以使用不同的 Fsync 策略：无 Fsync、每秒 Fsync 、每次写的时候 Fsync 使用默认的每秒 Fsync 策略。

Redis 的性能依然很好( Fsync 是由后台线程进行处理的，主线程会尽力处理客户端请求)，一旦出现故障，你最多丢失 1 秒的数据。

  • AOF文件是一个只进行追加的日志文件，所以不需要写入 Seek，即使由于某些原因(磁盘空间已满，写的过程中宕机等等)未执行完整的写入命令，你也可使用 redis-check-aof 工具修复这些问题。
  • Redis 可以在 AOF 文件体积变得过大时，自动地在后台对 AOF 进行重写： 重写后的新 AOF 文件包含了恢复当前数据集所需的最小命令集合。

整个重写操作是绝对安全的，因为 Redis 在创建新 AOF 文件的过程中，会继续将命令追加到现有的 AOF 文件里面，即使重写过程中发生停机，现有的 AOF 文件也不会丢失。

而一旦新 AOF 文件创建完毕，Redis 就会从旧 AOF 文件切换到新 AOF 文件，并开始对新 AOF 文件进行追加操作。

  • AOF 文件有序地保存了对数据库执行的所有写入操作，这些写入操作以 Redis 协议的格式保存。

因此 AOF 文件的内容非常容易被人读懂， 对文件进行分析(parse)也很轻松。导出(export) AOF 文件也非常简单。

举个例子，如果你不小心执行了 FLUSHALL 命令，但只要 AOF 文件未被重写，那么只要停止服务器， 移除 AOF 文件末尾的 FLUSHALL 命令，并重启 Redis ，就可以将数据集恢复到 FLUSHALL 执行之前的状态。

优点对比总结：

  • RDB 方式可以保存过去一段时间内的数据，并且保存结果是一个单一的文件，可以将文件备份到其他服务器，并且在回复大量数据的时候，RDB 方式的速度会比 AOF 方式的回复速度要快。
  • AOF 方式默认每秒钟备份 1 次，频率很高，它的操作方式是以追加的方式记录日志而不是数据，并且它的重写过程是按顺序进行追加，所以它的文件内容非常容易读懂。

可以在某些需要的时候打开 AOF 文件对其编辑，增加或删除某些记录，***再执行恢复操作。

RDB 方式与 AOF 方式的缺点对比

RDB 方式的缺点：

  • 如果你希望在 Redis 意外停止工作(例如电源中断)的情况下丢失的数据最少的话，那么 RDB 不适合你。

虽然你可以配置不同的 Save 时间点(例如每隔 5 分钟并且对数据集有 100 个写的操作)，但是 Redis 要完整的保存整个数据集是一个比较繁重的工作。

你通常会每隔 5 分钟或者更久做一次完整的保存，万一 Redis 意外宕机，你可能会丢失几分钟的数据。

  • RDB 需要经常 Fork 子进程来保存数据集到硬盘上，当数据集比较大的时，Fork 的过程是非常耗时的，可能会导致 Redis 在一些毫秒级内不能响应客户端的请求。

如果数据集巨大并且 CPU 性能不是很好的情况下，这种情况会持续 1 秒，AOF 也需要 Fork，但是你可以调节重写日志文件的频率来提高数据集的耐久度。

AOF 方式的缺点：

  • 对于相同的数据集来说，AOF 文件的体积通常要大于 RDB 文件的体积。
  • 根据所使用的 Fsync 策略，AOF 的速度可能会慢于 RDB。在一般情况下，每秒 Fsync 的性能依然非常高，而关闭 Fsync 可以让 AOF 的速度和 RDB 一样快，即使在高负荷之下也是如此。

不过在处理巨大的写入载入时，RDB 可以提供更有保证的***延迟时间(Latency)。

缺点对比总结：

  • RDB 由于备份频率不高，所以在回复数据的时候有可能丢失一小段时间的数据，而且在数据集比较大的时候有可能对毫秒级的请求产生影响。
  • AOF 的文件提及比较大，而且由于保存频率很高，所以整体的速度会比 RDB 慢一些，但是性能依旧很高。

RDB 与 AOF 工作原理

AOF 重写和 RDB 创建快照一样，都巧妙地利用了写时复制机制：

  • Redis 执行 fork() ，现在同时拥有父进程和子进程。
  • 子进程开始将新 AOF 文件的内容写入到临时文件。
  • 对于所有新执行的写入命令，父进程一边将它们累积到一个内存缓存中，一边将这些改动追加到现有 AOF 文件的末尾，这样即使在重写的中途发生停机，现有的 AOF 文件也还是安全的。
  • 当子进程完成重写工作时，它给父进程发送一个信号，父进程在接收到信号之后，将内存缓存中的所有数据追加到新 AOF 文件的末尾。
  • 现在 Redis 原子地用新文件替换旧文件，之后所有命令都会直接追加到新 AOF 文件的末尾。

付诸实践，RDB 与 AOF 的实现

RDB 方式持久化的开启与配置

Redis 默认的持久化方式是 RDB ，并且默认是打开的。RDB 的保存方式分为主动保存与被动保存。

主动保存可以在 redis-cli 中输入 Save 即可;被动保存需要满足配置文件中设定的触发条件，目前官方默认的触发条件可以在 redis.conf 中看到：

save 900 1save 300 10save 60 10000

其含义为：

服务器在900秒之内，对数据库进行了至少1次修改。服务器在300秒之内，对数据库进行了至少10次修改。服务器在60秒之内，对数据库进行了至少10000次修改。

满足触发条件后，数据就会被保存为快照，正是因为这样才说 RDB 的数据完整性是比不上 AOF 的。

触发保存条件后，会在指定的目录生成一个名为 dump.rdb 的文件，等到下一次启动 Redis 时，Redis 会去读取该目录下的 dump.rdb 文件，将里面的数据恢复到 Redis。

这个目录在哪里呢?我们可以在客户端中输入命令 config get dir 查看：

 
 
 
 
    
  
  
  
  
  1. gannicus@$ src/redis-cli 
    2. 
  
  
  
  
  2. 127.0.0.1:6379> config get dir 
    3. 
  
  
  
  
  3. 1) "dir" 
    4. 
  
  
  
  
  4. 2) "/home/gannicus/Documents/redis-5.0.0" 
    5. 
  
  
  
  
  5. 127.0.0.1:6379>  
    6.

 

返回结果中的"/home/gannicus/Documents/redis-5.0.0"就是存放 dump.rdb 的目录。

在测试之前，说明一下前提：Redis 是直接从官网下载的压缩包，解压后得到 redis-x.x.x 文件夹。

比如我的是 redis-5.0.0，然后进入文件夹，在 redis-5.0.0 项目根目录使用 make 命令安装。

 

RDB 被动触发保存测试

刚才提到它分为主动保存与被动触发，现在我们来测试一下被动触发。首先启动 redis-server，然后再打开客户端 redis-cli ，先增添几条记录：

127.0.0.1:6379> set lca 1OK127.0.0.1:6379> set lcb 1OK127.0.0.1:6379> set lcc 1OK127.0.0.1:6379> set lcd 1OK127.0.0.1:6379> set lce 1OK127.0.0.1:6379> set lcf 1OK127.0.0.1:6379> set lcg 1OK127.0.0.1:6379> set lch 1OK127.0.0.1:6379> set lci 1OK127.0.0.1:6379> set lcj 1OK127.0.0.1:6379> set lck 1OK127.0.0.1:6379> set lcl 1OK127.0.0.1:6379> set lcm 1OK

可以看到，总共添加了 13 条记录：

127.0.0.1:6379> keys * 1) "lca" 2) "lcd" 3) "lcg" 4) "lce" 5) "lcb" 6) "lcm" 7) "lcf" 8) "lci" 9) "lcl"10) "lcc"11) "lck"12) "lcj"13) "lch"127.0.0.1:6379>

然后发现 redis-server 端的日志窗口中出现了如下的提示：

21971:M 21 Oct 2018 16:52:44.062 * 10 changes in 300 seconds. Saving...21971:M 21 Oct 2018 16:52:44.063 * Background saving started by pid 2255222552:C 21 Oct 2018 16:52:44.066 * DB saved on disk21971:M 21 Oct 2018 16:52:44.165 * Background saving terminated with success

从英文提示中可以大概读懂这些内容，它检测到 300 秒内有 10 条记录被改动，刚才我们添加了 13 条数据记录，满足 redis.conf 中对于 RDB 数据保存的条件。

所以这里执行数据保存操作，并且提示开辟了一个 22552 的进程出来执行保存操作，***提示保存成功。并且在目录内看到有 dump.rdb 文件生成。

现在将 Redis 进程 Kill，哪些数据会被保存?通过命令 kill -9 pid ( pid 是进程编号)模拟 Redis 异常关闭，然后再启动 Redis 。

我们来看一看，到底是只保存了 10 条记录还是 13 条全都保存下来了?

127.0.0.1:6379> keys * 1) "lcb" 2) "lcj" 3) "lcd" 4) "lch" 5) "lci" 6) "lcc" 7) "lcf" 8) "lce" 9) "lca"10) "lcg"127.0.0.1:6379>

重启后查看记录，发现 13 条记录中只有 10 条记录会被保存，这也印证了之前所说，RDB 方式的数据完整性是不可靠的，除非断掉的那一刻正好是满足触发条件的条数。

关闭 RDB

刚才提到了，它是默认启用的，如果你不需要它可以在配置文件中将这 3 个配置注释掉，并新增 save " " 即可：

 
 
 
 
    
  
  
  
  
  1.   save "" 
    2. 
  
  
  
  
  2. # save 900 1 
    3. 
  
  
  
  
  3. # save 300 10 
    4. 
  
  
  
  
  4. # save 60 10000 
    5.

保存配置文件后需要重新启动 Redis 服务才会生效，然后继续添加十几条记录：

 
 
 
 
    
  
  
  
  
  1. 127.0.0.1:6379> keys * 
    2. 
  
  
  
  
  2.  1) "lcb" 
    3. 
  
  
  
  
  3. ... 
    4. 
  
  
  
  
  4. 23) "lca" 
    5. 
  
  
  
  
  5. 24) "lcg" 
    6. 
  
  
  
  
  6. 127.0.0.1:6379>  
    7.

在之前已有 10 条的基础上我再增加了 14 条记录，这次同样要通过 kill 来模拟 Redis 异常关闭，再启动服务看一看，数据是否还被保存：

 
 
 
 
    
  
  
  
  
  1. 127.0.0.1:6379> keys * 
    2. 
  
  
  
  
  2.  1) "lcb" 
    3. 
  
  
  
  
  3.  2) "lcj" 
    4. 
  
  
  
  
  4.  3) "lcd" 
    5. 
  
  
  
  
  5.  4) "lch" 
    6. 
  
  
  
  
  6.  5) "lci" 
    7. 
  
  
  
  
  7.  6) "lcc" 
    8. 
  
  
  
  
  8.  7) "lcf" 
    9. 
  
  
  
  
  9.  8) "lce" 
    10. 
  
  
  
  
  10.  9) "lca" 
    11. 
  
  
  
  
  11. 10) "lcg" 
    12. 
  
  
  
  
  12. 127.0.0.1:6379>  
    13.

发现后面添加的 14 条记录并没有被保存，恢复数据的时候仅仅只是恢复了之前的 10 条。

并且观察 Redis 服务端窗口日志，并未发现像之前一样的触发保存的提示，证明 RDB 方式已经被关闭。

RDB 主动保存测试

通过配置文件关闭被动触发，那么主动关闭是否还会生效呢?

在 Redis 客户端( redis-cli )通过 del 命令删除几条记录，然后输入 save 命令执行保存操作：

 
 
 
 
    
  
  
  
  
  1. 127.0.0.1:6379> keys * 
    2. 
  
  
  
  
  2.  1) "lcc" 
    3. 
  
  
  
  
  3.  2) "lch" 
    4. 
  
  
  
  
  4.  3) "lcb" 
    5. 
  
  
  
  
  5.  4) "lci" 
    6. 
  
  
  
  
  6.  5) "lce" 
    7. 
  
  
  
  
  7.  6) "lcj" 
    8. 
  
  
  
  
  8.  7) "lcg" 
    9. 
  
  
  
  
  9.  8) "lca" 
    10. 
  
  
  
  
  10.  9) "lcd" 
    11. 
  
  
  
  
  11. 10) "lcf" 
    12. 
  
  
  
  
  12. 127.0.0.1:6379> del lca lcb lcc 
    13. 
  
  
  
  
  13. (integer) 3 
    14. 
  
  
  
  
  14. 127.0.0.1:6379> save 
    15. 
  
  
  
  
  15. OK 
    16. 
  
  
  
  
  16. 127.0.0.1:6379>  
    17.

 

可以看到 redis-server 的日志有新的提示：22598:M 21 Oct 2018 17:22:31.365 * DB saved on disk，它告诉我们数据已经保存。

那么继续模拟异常关闭，再打开服务，看一看是否真的保存了这些操作：

 
 
 
 
    
  
  
  
  
  1. 127.0.0.1:6379> keys * 
    2. 
  
  
  
  
  2. 1) "lci" 
    3. 
  
  
  
  
  3. 2) "lcj" 
    4. 
  
  
  
  
  4. 3) "lcd" 
    5. 
  
  
  
  
  5. 4) "lcg" 
    6. 
  
  
  
  
  6. 5) "lcf" 
    7. 
  
  
  
  
  7. 6) "lce" 
    8. 
  
  
  
  
  8. 7) "lch" 
    9. 
  
  
  
  
  9. 127.0.0.1:6379>  
    10.

 

果不其然，这几个删除操作都被保存了下来，恢复过来的数据中已经没有那 3 条记录了，证明主动关闭不受配置文件的影响。除了 Save 还有其他的保存方式么?

Save 和 Bgsave 保存

有的，Redis 提供了 Save 和 Bgsave 这两种不同的保存方式，并且这两个方式在执行的时候都会调用 rdbSave 函数。

但它们调用的方式各有不同：

  • Save 直接调用 rdbSave方法 ，阻塞 Redis 主进程，直到保存完成为止。在主进程阻塞期间，服务器不能处理客户端的任何请求。
  • Bgsave 则 Fork 出一个子进程，子进程负责调用 rdbSave ，并在保存完成之后向主进程发送信号，通知保存已完成。

因为 rdbSave 在子进程被调用，所以 Redis 服务器在 Bgsave 执行期间仍然可以继续处理客户端的请求。

Save 是同步操作，Bgsave 是异步操作。Bgsave 命令的使用方法和 Save 命令的使用方法是一样的：

 
 
 
 
    
  
  
  
  
  1. 127.0.0.1:6379> keys * 
    2. 
  
  
  
  
  2. 1) "lci" 
    3. 
  
  
  
  
  3. 2) "lcj" 
    4. 
  
  
  
  
  4. 3) "lcd" 
    5. 
  
  
  
  
  5. 4) "lcg" 
    6. 
  
  
  
  
  6. 5) "lcf" 
    7. 
  
  
  
  
  7. 6) "lce" 
    8. 
  
  
  
  
  8. 7) "lch" 
    9. 
  
  
  
  
  9. 127.0.0.1:6379> del lci lcj  
    10. 
  
  
  
  
  10. (integer) 2 
    11. 
  
  
  
  
  11. 127.0.0.1:6379> bgsave 
    12. 
  
  
  
  
  12. Background saving started 
    13. 
  
  
  
  
  13. 127.0.0.1:6379> keys * 
    14. 
  
  
  
  
  14. 1) "lcd" 
    15. 
  
  
  
  
  15. 2) "lcg" 
    16. 
  
  
  
  
  16. 3) "lcf" 
    17. 
  
  
  
  
  17. 4) "lce" 
    18. 
  
  
  
  
  18. 5) "lch" 
    19. 
  
  
  
  
  19. 127.0.0.1:6379>  
    20.

 

Shutdown 保存

事实上，Shutdown 命令也是可以保存数据的，惊不惊喜。它会在关闭前将数据保存下来，意不意外?

 
 
 
 
    
  
  
  
  
  1. 127.0.0.1:6379> set app 1 
    2. 
  
  
  
  
  2. OK 
    3. 
  
  
  
  
  3. 127.0.0.1:6379> set apps 1 
    4. 
  
  
  
  
  4. OK 
    5. 
  
  
  
  
  5. 127.0.0.1:6379> keys * 
    6. 
  
  
  
  
  6. 1) "apps" 
    7. 
  
  
  
  
  7. 2) "lcd" 
    8. 
  
  
  
  
  8. 3) "lcg" 
    9. 
  
  
  
  
  9. 4) "lcf" 
    10. 
  
  
  
  
  10. 5) "app" 
    11. 
  
  
  
  
  11. 6) "lce" 
    12. 
  
  
  
  
  12. 7) "lch" 
    13. 
  
  
  
  
  13. 127.0.0.1:6379> shutdown 
    14. 
  
  
  
  
  14. not connected> quit 
    15. 
  
  
  
  
  15. gannicus@$  
    16.

然后 Redis 服务就被关闭掉了。我们需要重新启动 Redis 服务，到客户端中看一看是否生效：

 
 
 
 
    
  
  
  
  
  1. gannicus@$ src/redis-cli 
    2. 
  
  
  
  
  2. 127.0.0.1:6379> keys * 
    3. 
  
  
  
  
  3. 1) "lce" 
    4. 
  
  
  
  
  4. 2) "lcf" 
    5. 
  
  
  
  
  5. 3) "lcd" 
    6. 
  
  
  
  
  6. 4) "lch" 
    7. 
  
  
  
  
  7. 5) "lcg" 
    8.

竟然没有生效，刺不刺激?这是为什么呢?明明官方文档之 Shutdown 就说会保存了才退出的，你骗人~注意到，文档中有一句：

 

恍然大悟，原来是要在持久化被打开的情况下，通过 Shutdown 命令关闭才不会丢失数据，那么就到配置文件中将那几个 Save 的配置项打开吧：

 
 
 
 
    
  
  
  
  
  1. #   save ""save 900 1 
    2. 
  
  
  
  
  2. save 300 10 
    3. 
  
  
  
  
  3. save 60 10000 
    4.

然后再开启 Redis 服务，再尝试一遍(过程为：添加 -> shutdown -> 重启服务 -> 查看)：

 
 
 
 
    
  
  
  
  
  1. 127.0.0.1:6379> set app 1 
    2. 
  
  
  
  
  2. OK 
    3. 
  
  
  
  
  3. 127.0.0.1:6379> set apps 1 
    4. 
  
  
  
  
  4. OK 
    5. 
  
  
  
  
  5. 127.0.0.1:6379> shutdown 
    6. 
  
  
  
  
  6. not connected> quit 
    7. 
  
  
  
  
  7. gannicus@$ src/redis-cli 
    8. 
  
  
  
  
  8. 127.0.0.1:6379> keys * 
    9. 
  
  
  
  
  9. 1) "lce" 
    10. 
  
  
  
  
  10. 2) "lch" 
    11. 
  
  
  
  
  11. 3) "app" 
    12. 
  
  
  
  
  12. 4) "lcf" 
    13. 
  
  
  
  
  13. 5) "apps" 
    14. 
  
  
  
  
  14. 6) "lcd" 
    15. 
  
  
  
  
  15. 7) "lcg" 
    16. 
  
  
  
  
  16. 127.0.0.1:6379>  
    17.

 

这下终于弄明白了。

 

AOF 方式持久化的开启与配置

开启 AOF

默认是不开启 AOF 的，如果想要启用则需要到 redis.conf 配置文件中开启，打开 redis.conf：

 
 
 
 
    
  
  
  
  
  1. $ vim redis.conf 
    2.

然后在文件中找到 appendonly 并将 no 改为 yes：

 
 
 
 
    
  
  
  
  
  1. appendonly yes 
    2.

即为开启了 AOF 方式的持久化。

设置同步方式

AOF 还有支持几种同步方式，它们分别是：

 
 
 
 
    
  
  
  
  
  1. appendfsync always  # 每次有数据修改发生时都会写入AOF文件（安全但是费时）。 
    2. 
  
  
  
  
  2. appendfsync everysec  # 每秒钟同步一次，该策略为AOF的缺省策略。 
    3. 
  
  
  
  
  3. appendfsync no  # 从不同步。高效但是数据不会被持久化。 
    4.

默认配置是 everysec，你可以根据需求进行调整，这里我将配置改成 always：

 
 
 
 
    
  
  
  
  
  1. appendfsync always 
    2. 
  
  
  
  
  2. # appendfsync everysec 
    3. 
  
  
  
  
  3. # appendfsync no 
    4.

自定义 AOF 记录文件的文件名

Redis 设置有默认的文件名，在配置中显示为：

 
 
 
 
    
  
  
  
  
  1. appendfilename "appendonly.aof" 
    2.

你可以让其保持默认名字，也可以指定其他的文件名，比如：

 
 
 
 
    
  
  
  
  
  1. appendfilename "RNGLetme.aof" 
    2.

 

将 appendonly、appendfsync 和 appendfilename 设置好并保存。重新启动 Redis 服务：

 
 
 
 
    
  
  
  
  
  1. $./redis-server 
    2.

通过命令 ls 查看本地文件，可以看到新生成了一个名为 RNGLetme.aof 的文件，可以使用：

 
 
 
 
    
  
  
  
  
  1. $cat RNGLetme.aof 
    2.

来查看里面的内容，由于当前未进行数据的改动，所以是空白的。然后打开 Redis 的客户端：

 
 
 
 
    
  
  
  
  
  1. $./redis-cli 
    2.

并且添加几条数据记录：

 
 
 
 
    
  
  
  
  
  1. 127.0.0.1:6379> set rng lpl 
    2. 
  
  
  
  
  2. OK 
    3. 
  
  
  
  
  3. 127.0.0.1:6379> set ig lpl 
    4. 
  
  
  
  
  4. OK 
    5. 
  
  
  
  
  5. 127.0.0.1:6379> set edg lpl 
    6. 
  
  
  
  
  6. OK 
    7. 
  
  
  
  
  7. 127.0.0.1:6379> keys * 
    8. 
  
  
  
  
  8. 1) "edg" 
    9. 
  
  
  
  
  9. 2) "rng" 
    10. 
  
  
  
  
  10. 3) "ig" 
    11. 
  
  
  
  
  11. 127.0.0.1:6379>  
    12.

可以看到，成功添加了 rng、edg、ig 这三条记录，然后打开 RNGLetme.aof 文件，看看里面的记录：

 
 
 
 
    
  
  
  
  
  1. *2 
    2. 
  
  
  
  
  2. $6 
    3. 
  
  
  
  
  3. SELECT 
    4. 
  
  
  
  
  4. $1 
    5. 
  
  
  
  
  5. 0 
    6. 
  
  
  
  
  6. *3 
    7. 
  
  
  
  
  7. $3 
    8. 
  
  
  
  
  8. set 
    9. 
  
  
  
  
  9. $3 
    10. 
  
  
  
  
  10. rng 
    11. 
  
  
  
  
  11. $3 
    12. 
  
  
  
  
  12. lpl 
    13. 
  
  
  
  
  13. *3 
    14. 
  
  
  
  
  14. $3 
    15. 
  
  
  
  
  15. set 
    16. 
  
  
  
  
  16. $2 
    17. 
  
  
  
  
  17. ig 
    18. 
  
  
  
  
  18. $3 
    19. 
  
  
  
  
  19. lpl 
    20. 
  
  
  
  
  20. *3 
    21. 
  
  
  
  
  21. $3 
    22. 
  
  
  
  
  22. set 
    23. 
  
  
  
  
  23. $3 
    24. 
  
  
  
  
  24. edg 
    25. 
  
  
  
  
  25. $3 
    26. 
  
  
  
  
  26. lpl 
    27.

 

每一次的数据添加都被记录下来了。那如果是删除操作呢，也会被记录下来么?

 
 
 
 
    
  
  
  
  
  1. 127.0.0.1:6379> del edg 
    2. 
  
  
  
  
  2. (integer) 1 
    3. 
  
  
  
  
  3. 127.0.0.1:6379> keys * 
    4. 
  
  
  
  
  4. 1) "rng" 
    5. 
  
  
  
  
  5. 2) "ig" 
    6. 
  
  
  
  
  6. 127.0.0.1:6379>  
    7.

执行完删除操作后，再看一看 RNGLetme.aof 文件中的记录：

对比之前的记录，新增了 del edg 的操作记录。这就印证了之前对 AOF 的描述：以日志的方式将数据变动记录下来。

 

AOF 恢复测试

下面同样是通过 Kill 命令模拟 Redis 异常关闭：

 
 
 
 
    
  
  
  
  
  1. gannicus@$ kill -9 22645 
    2.

然后再重新启动 Redis 服务：

 
 
 
 
    
  
  
  
  
  1. $ src/redis-server redis.conf 
    2.

接着通过客户端看一看，那些数据是否都在：

 
 
 
 
    
  
  
  
  
  1. $ src/redis-cli 
    2. 
  
  
  
  
  2. 127.0.0.1:6379> keys * 
    3. 
  
  
  
  
  3. 1) "ig" 
    4. 
  
  
  
  
  4. 2) "rng" 
    5.

 

可以看到，rng 和 ig 都还在，意味着持久化是生效的。

怎样从 RDB 方式切换为 AOF 方式

在 Redis 2.2 或以上版本，可以在不重启的情况下，从 RDB 切换到 AOF ：

为***的 dump.rdb 文件创建一个备份、将备份放到一个安全的地方。

执行以下两条命令：

 
 
 
 
    
  
  
  
  
  1. redis-cli config set appendonly yes 
    2. 
  
  
  
  
  2. redis-cli config set save “” 
    3.

确保写命令会被正确地追加到 AOF 文件的末尾。执行的***条命令开启了 AOF 功能：Redis 会阻塞直到初始 AOF 文件创建完成为止，之后 Redis 会继续处理命令请求，并开始将写入命令追加到 AOF 文件末尾。

执行的第二条命令用于关闭 RDB 功能。这一步是可选的，如果你愿意的话，也可以同时使用 RDB 和 AOF 这两种持久化功能。

注意：别忘了在 redis.conf 中打开 AOF 功能!否则服务器重启后，之前通过 CONFIG SET 命令设置的配置就会被遗忘，程序会按原来的配置来启动服务器。

优先选择 RDB 还是 AOF 呢?

分析对比两种方式并做了测试后，发现这是两种不同风格的持久化方式。那么应该如何选择呢?

  • 对于企业级的中大型应用，如果不想牺牲数据完整性但是又希望保持高效率，那么你应该同时使用 RDB 和 AOF 两种方式。
  • 如果你不打算耗费精力在这个地方，只需要保证数据完整性，那么优先考虑使用 AOF 方式。
  • RDB 方式非常适合大规模的数据恢复，如果业务对数据完整性和一致性要求不高，RDB 是很好的选择。

备份 Redis 数据的建议

确保你的数据有完整的备份，磁盘故障、节点失效等问题可能让你的数据消失不见， 不进行备份是非常危险的。

Redis 对于数据备份是非常友好的，因为你可以在服务器运行的时候对 RDB 文件进行复制：RDB 文件一旦被创建，就不会进行任何修改。

当服务器要创建一个新的 RDB 文件时，它先将文件的内容保存在一个临时文件里面，当临时文件写入完毕时，程序才使用 rename(2) 原子地用临时文件替换原来的 RDB 文件。

这也就是说，无论何时，复制 RDB 文件都是绝对安全的：

  • 创建一个定期任务( cron job )，每小时将一个 RDB 文件备份到一个文件夹，并且每天将一个 RDB 文件备份到另一个文件夹。
  • 确保快照的备份都带有相应的日期和时间信息，每次执行定期任务脚本时，使用 Find 命令来删除过期的快照：比如说你可以保留最近 48 小时内的每小时快照，还可以保留最近一两个月的每日快照。
  • 至少每天一次，将 RDB 备份到你的数据中心之外，或者至少是备份到你运行 Redis 服务器的物理机器之外。

Redis 密码持久化

在 Redis 中数据需要持久化，密码也要持久化。在客户端通过命令：

 
 
 
 
    
  
  
  
  
  1. config set requirepass zxc9527 
    2.

可以为 Redis 设置值为 zxc9527 的密码，但是当 Redis 关闭并重新启动后，权限验证功能就会失效，再也不需要密码。

所以，密码也需要在 redis.conf 中持久化。打开 redis.conf 找到 requirepass 配置项，取消其注释并在后面设置密码：

 
 
 
 
    
  
  
  
  
  1. requirepass zxc9527 
    2.

 

保存后重启 Redis 服务，密码持久化即生效。

参考文章：

  • Redis 源码剖析和注释(十七)--- RDB 持久化机制
  • Redis 设计与实现
  • www.redis.cn/
  • Redis 两种持久化方案 RDB 和 AOF 详解
  • Redis 持久化的几种方式
  • Redis 官方文档

本文名称：读完这篇，你一定能真正理解Redis持久化
浏览路径：http://www.shufengxianlan.com/qtweb/news5/6005.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

解决方案知识

分类信息网

双流网站建设　　 　成都小程序开发　　 　艾名斯线缆　　 　川银永信　　 　自适应网页设计　　 　香港云主机　　 　犀浦门窗定制　　 　LED亮化工程　　 　简阳服务器托管　　 　400电话办理　　 　成都网站建设公司　　 　成都定制网站开发　　 　复盛机电设备安装　　 　免备案空间　　 　php主机　　 　移动网站建设　　 　成都高电机柜租用　　 　成都外贸网站优化　　 　门户网站建设方案　　 　成都小程序开发