[动图演示]Redis 持久化 RDB/AOF 详解与实践

时间 2019-11-16

标签演示 redis 持久 rdb aof 详解实践栏目 Redis 繁體版

原文原文链接

Redis 是一个开源（ BSD 许可）的，内存中的数据结构存储系统，它能够用做数据库、缓存和消息中间件。它支持的数据类型很丰富，如字符串、链表、集合、以及散列等，而且还支持多种排序功能。

什么叫持久化？

用一句话能够将持久化归纳为：将数据（如内存中的对象）保存到可永久保存的存储设备中。持久化的主要应用是将内存中的对象存储在数据库中，或者存储在磁盘文件中、 XML 数据文件中等等。html

从应用层与系统层理解持久化redis

同时，也能够从应用层和系统层这两个层面来理解持久化：数据库

应用层：若是关闭( Close )你的应用而后从新启动则先前的数据依然存在。vim

系统层：若是关闭( Shutdown )你的系统（电脑）而后从新启动则先前的数据依然存在。缓存

Redis 为何要持久化？

Redis 中的数据类型都支持 push/pop、add/remove 及取交集并集和差集及更丰富的操做，并且这些操做都是原子性的。在此基础上，Redis 支持各类不一样方式的排序。与 Memcached 同样，为了保证效率，数据都是缓存在内存中。安全

对，数据都是缓存在内存中的，当你重启系统或者关闭系统后，缓存在内存中的数据都会消失殆尽，再也找不回来了。因此，为了让数据可以长期保存，就要将 Redis 放在缓存中的数据作持久化存储。bash

Redis 怎么实现持久化？

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

一、RDB持久化方式可以在指定的时间间隔能对你的数据进行快照存储。数据结构

二、AOF持久化方式记录每次对服务器写的操做,当服务器重启的时候会从新执行这些命令来恢复原始的数据,AOF命令以redis协议追加保存每次写的操做到文件末尾.Redis还能对AOF文件进行后台重写,使得AOF文件的体积不至于过大。app

三、若是你只但愿你的数据在服务器运行的时候存在,你也能够不使用任何持久化方式。

四、你也能够同时开启两种持久化方式, 在这种状况下, 当redis重启的时候会优先载入AOF文件来恢复原始的数据,由于在一般状况下AOF文件保存的数据集要比RDB文件保存的数据集要完整。

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

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 慢一些，可是性能依旧很高。

工做原理

AOF 重写和 RDB 建立快照同样，都巧妙地利用了写时复制机制:

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

付诸实践，RDB 与 AOF 的实现

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

Redis 默认的持久化方式是 RDB ，而且默认是打开的。RDB 的保存有方式分为主动保存与被动保存。主动保存能够在 redis-cli 中输入 save 便可；被动保存须要知足配置文件中设定的触发条件，目前官方默认的触发条件能够在 redis.conf 中看到：

save 900 1
save 300 10
save 60 10000
复制代码

其含义为：

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

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

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

这个目录在哪里呢？

咱们能够在客户端中输入命令config get dir查看：

gannicus@$ src/redis-cli
127.0.0.1:6379> config get dir
1) "dir"
2) "/home/gannicus/Documents/redis-5.0.0"
127.0.0.1:6379> 
复制代码

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

Redis 版本说明

在测试以前，说明一下前提。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 1
OK
127.0.0.1:6379> set lcb 1
OK
127.0.0.1:6379> set lcc 1
OK
127.0.0.1:6379> set lcd 1
OK
127.0.0.1:6379> set lce 1
OK
127.0.0.1:6379> set lcf 1
OK
127.0.0.1:6379> set lcg 1
OK
127.0.0.1:6379> set lch 1
OK
127.0.0.1:6379> set lci 1
OK
127.0.0.1:6379> set lcj 1
OK
127.0.0.1:6379> set lck 1
OK
127.0.0.1:6379> set lcl 1
OK
127.0.0.1:6379> set lcm 1
OK
复制代码

能够看到，总共添加了 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 22552
22552:C 21 Oct 2018 16:52:44.066 * DB saved on disk
21971: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 ""便可：

save ""
# save 900 1
# save 300 10
# save 60 10000
复制代码

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

127.0.0.1:6379> keys *
 1) "lcb"
...
23) "lca"
24) "lcg"
127.0.0.1:6379> 
复制代码

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

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> 
复制代码

发现后面添加的 14 条记录并无被保存，恢复数据的时候仅仅只是恢复了以前的 10 条。而且观察 Redis 服务端窗口日志，并未发现像以前同样的触发保存的提示，证实 RDB 方式已经被关闭。

RDB 主动保存测试

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

在 Redis 客户端（ redis-cli ）经过del命令删除几条记录，而后输入save命令执行保存操做：

127.0.0.1:6379> keys *
 1) "lcc"
 2) "lch"
 3) "lcb"
 4) "lci"
 5) "lce"
 6) "lcj"
 7) "lcg"
 8) "lca"
 9) "lcd"
10) "lcf"
127.0.0.1:6379> del lca lcb lcc
(integer) 3
127.0.0.1:6379> save
OK
127.0.0.1:6379> 
复制代码

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

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

127.0.0.1:6379> keys *
1) "lci"
2) "lcj"
3) "lcd"
4) "lcg"
5) "lcf"
6) "lce"
7) "lch"
127.0.0.1:6379> 
复制代码

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

除了save还有其余的保存方式么？

save 和 bgsave 保存

有的，Redis 提供了save和bgsave这两种不一样的保存方式,而且这两个方式在执行的时候都会调用rdbSave函数，但它们调用的方式各有不一样：

save 直接调用 rdbSave方法，阻塞 Redis 主进程，直到保存完成为止。在主进程阻塞期间，服务器不能处理客户端的任何请求。
bgsave 则 fork 出一个子进程，子进程负责调用 rdbSave ，并在保存完成以后向主进程发送信号，通知保存已完成。由于 rdbSave 在子进程被调用，因此 Redis 服务器在 bgsave 执行期间仍然能够继续处理客户端的请求。

save 是同步操做，bgsave 是异步操做。

bgsave命令的使用方法和save命令的使用方法是同样的：

127.0.0.1:6379> keys *
1) "lci"
2) "lcj"
3) "lcd"
4) "lcg"
5) "lcf"
6) "lce"
7) "lch"
127.0.0.1:6379> del lci lcj 
(integer) 2
127.0.0.1:6379> bgsave
Background saving started
127.0.0.1:6379> keys *
1) "lcd"
2) "lcg"
3) "lcf"
4) "lce"
5) "lch"
127.0.0.1:6379> 
复制代码

shutdown 保存

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

127.0.0.1:6379> set app 1
OK
127.0.0.1:6379> set apps 1
OK
127.0.0.1:6379> keys *
1) "apps"
2) "lcd"
3) "lcg"
4) "lcf"
5) "app"
6) "lce"
7) "lch"
127.0.0.1:6379> shutdown
not connected> quit
gannicus@$ 
复制代码

而后 Redis 服务就被关闭掉了。咱们须要从新启动 Redis 服务，到客户端中看一看是否生效：

gannicus@$ src/redis-cli
127.0.0.1:6379> keys *
1) "lce"
2) "lcf"
3) "lcd"
4) "lch"
5) "lcg"
复制代码

居然没有生效，刺不刺激？这是为何呢？明明官方文档之shutdown就说会保存了才退出的，你骗人~

注意到，文档中有一句

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

# save ""
save 900 1
save 300 10
save 60 10000
复制代码

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

127.0.0.1:6379> set app 1
OK
127.0.0.1:6379> set apps 1
OK
127.0.0.1:6379> shutdown
not connected> quit
gannicus@$ src/redis-cli
127.0.0.1:6379> keys *
1) "lce"
2) "lch"
3) "app"
4) "lcf"
5) "apps"
6) "lcd"
7) "lcg"
127.0.0.1:6379> 
复制代码

这下终于弄明白了。

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

开启 AOF

默认是不开启 AOF 的，若是想要启用则须要到 redis.conf 配置文件中开启，打开 redis.conf:

$ vim redis.conf
复制代码

而后在文件中找到 appendonly 并将 no 改成 yes：

appendonly yes
复制代码

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

设置同步方式

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

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

默认配置是 everysec，你能够根据需求进行调整，这里我将配置改为 always：

appendfsync always
# appendfsync everysec
# appendfsync no
复制代码

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

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

appendfilename "appendonly.aof"
复制代码

你可让其保持默认名字，也能够指定其余的文件名，好比：

appendfilename "RNGLetme.aof"
复制代码

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

$./redis-server
复制代码

经过命令 ls 查看本地文件，能够看到新生成了一个名为 RNGLetme.aof 的文件，可使用:

$cat RNGLetme.aof  
复制代码

来查看里面的内容，因为当前未进行数据的改动，因此是空白的。

而后打开 Redis 的客户端：

$./redis-cli
复制代码

而且添加几条数据记录：

127.0.0.1:6379> set rng lpl
OK
127.0.0.1:6379> set ig lpl
OK
127.0.0.1:6379> set edg lpl
OK
127.0.0.1:6379> keys *
1) "edg"
2) "rng"
3) "ig"
127.0.0.1:6379> 
复制代码

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

*2
$6
SELECT
$1
0
*3
$3
set
$3
rng
$3
lpl
*3
$3
set
$2
ig
$3
lpl
*3
$3
set
$3
edg
$3
lpl
复制代码

每一次的数据添加都被记录下来了。

那若是是删除操做呢，也会被记录下来么？

127.0.0.1:6379> del edg
(integer) 1
127.0.0.1:6379> keys *
1) "rng"
2) "ig"
127.0.0.1:6379> 
复制代码

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

*2
$6
SELECT
$1
0
*3
$3
set
$3
rng
$3
lpl
*3
$3
set
$2
ig
$3
lpl
*3
$3
set
$3
edg
$3
lpl
*2
$3
del
$3
edg
复制代码

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

AOF 恢复测试

下面一样是经过 kill 命令模拟 Redis 异常关闭：

gannicus@$ kill -9 22645
复制代码

而后再从新启动 Redis 服务：

$ src/redis-server redis.conf
复制代码

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

$ src/redis-cli
127.0.0.1:6379> keys *
1) "ig"
2) "rng"
复制代码

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

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

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

为最新的 dump.rdb 文件建立一个备份、将备份放到一个安全的地方。执行如下两条命令:

redis-cli config set appendonly yes
redis-cli config set save “”
复制代码

确保写命令会被正确地追加到 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 中数据须要持久化，密码也要持久化。在客户端经过命令：

config set requirepass zxc9527
复制代码

能够为 Redis 设置值为zxc9527的密码，可是当 Redis 关闭并从新启动后，权限验证功能就会失效，不再须要密码。因此，密码也须要在 redis.conf 中持久化。打开 redis.conf 找到 requirepass 配置项，取消其注释并在后面设置密码：

requirepass zxc9527
复制代码

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