Redis数据备份和重启恢复

一、对redis持久化的探讨与理解

目前redis持久化的方式有两种： rdb 和 aof

首先，我们应该明确持久化的数据有什么用，答案是用于重启后的数据恢复。
redis是一个内存数据库，无论是rdb还是aof，都只是其保证数据恢复的措施。
所以redis在利用rdb和aof进行恢复的时候，都会读取rdb或aof文件，重新加载到内存中。

rdb就是snapshot快照存储，是默认的持久化方式。
可理解为半持久化模式，即按照一定的策略周期性的将数据保存到磁盘。
对应产生的数据文件为dump.rdb，通过配置文件中的save参数来定义快照的周期。
下面是默认的快照设置：

save 900 1    #当有一条keys数据被改变时，900秒刷新到disk一次
save 300 10   #当有10条keys数据被改变时，300秒刷新到disk一次
save 60 10000 #当有10000条keys数据被改变时，60秒刷新到disk一次

redis的rdb文件不会坏掉，因为其写操作是在一个新进程中进行的。
当生成一个新的rdb文件时，redis生成的子进程会先将数据写到一个临时文件中，然后通过原子性rename系统调用将临时文件重命名为rdb文件。
这样在任何时候出现故障，redis的rdb文件都总是可用的。

同时，redis的rdb文件也是redis主从同步内部实现中的一环。
第一次slave向master同步的实现是：
slave向master发出同步请求，master先dump出rdb文件，然后将rdb文件全量传输给slave，然后master把缓存的命令转发给slave，初次同步完成。
第二次以及以后的同步实现是：
master将变量的快照直接实时依次发送给各个slave。
但不管什么原因导致slave和master断开重连都会重复以上两个步骤的过程。
redis的主从复制是建立在内存快照的持久化基础上的，只要有slave就一定会有内存快照发生。

可以很明显的看到，rdb有它的不足，就是一旦数据库出现问题，那么我们的rdb文件中保存的数据并不是全新的。
从上次rdb文件生成到redis停机这段时间的数据全部丢掉了。

aof(append-only file)比rdb方式有更好的持久化性。
由于在使用aof持久化方式时，redis会将每一个收到的写命令都通过write函数追加到文件中，类似mysql的binlog。
当redis重启是会通过重新执行文件中保存的写命令来在内存中重建整个数据库的内容。
对应的设置参数为：
$ vim /opt/redis/etc/redis_6379.conf

appendonly yes       #启用aof持久化方式
appendfilename appendonly.aof #aof文件的名称，默认为appendonly.aof
# appendfsync always #每次收到写命令就立即强制写入磁盘，是最有保证的完全的持久化，但速度也是最慢的，一般不推荐使用。
appendfsync everysec #每秒钟强制写入磁盘一次，在性能和持久化方面做了很好的折中，是受推荐的方式。
# appendfsync no     #完全依赖os的写入，一般为30秒左右一次，性能最好但是持久化最没有保证，不被推荐。

aof的完全持久化方式同时也带来了另一个问题，持久化文件会变得越来越大。
比如我们调用incr test命令100次，文件中就必须保存全部的100条命令，但其实99条都是多余的。
因为要恢复数据库的状态其实文件中保存一条set test 100就够了。
为了压缩aof的持久化文件，redis提供了bgrewriteaof命令。
收到此命令后redis将使用与快照类似的方式将内存中的数据以命令的方式保存到临时文件中，最后替换原来的文件，以此来实现控制aof文件的增长。
由于是模拟快照的过程，因此在重写aof文件时并没有读取旧的aof文件，而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件。
对应的设置参数为:
$ vim /opt/redis/etc/redis_6379.conf

no-appendfsync-on-rewrite yes   #在日志重写时，不进行命令追加操作，而只是将其放在缓冲区里，避免与命令的追加造成disk io上的冲突。
auto-aof-rewrite-percentage 100 #当前aof文件大小是上次日志重写得到aof文件大小的二倍时，自动启动新的日志重写过程。
auto-aof-rewrite-min-size 64mb  #当前aof文件启动新的日志重写过程的最小值，避免刚刚启动reids时由于文件尺寸较小导致频繁的重写。

到底选择什么呢？下面是来自官方的建议：
通常，如果你要想提供很高的数据保障性，那么建议你同时使用两种持久化方式。
如果你可以接受灾难带来的几分钟的数据丢失，那么你可以仅使用rdb。
很多用户仅使用了aof，但是我们建议，既然rdb可以时不时的给数据做个完整的快照，并且提供更快的重启，所以最好还是也使用rdb。
因此，我们希望可以在未来（长远计划）统一aof和rdb成一种持久化模式。

在数据恢复方面：
rdb的启动时间会更短，原因有两个：
一是rdb文件中每一条数据只有一条记录，不会像aof日志那样可能有一条数据的多次操作记录。所以每条数据只需要写一次就行了。
另一个原因是rdb文件的存储格式和redis数据在内存中的编码格式是一致的，不需要再进行数据编码工作，所以在cpu消耗上要远小于aof日志的加载。

二、灾难恢复模拟
既然持久化的数据的作用是用于重启后的数据恢复，那么我们就非常有必要进行一次这样的灾难恢复模拟了。
据称如果数据要做持久化又想保证稳定性，则建议留空一半的物理内存。因为在进行快照的时候，fork出来进行dump操作的子进程会占用与父进程一样的内存，真正的copy-on-write，对性能的影响和内存的耗用都是比较大的。
目前，通常的设计思路是利用replication机制来弥补aof、snapshot性能上的不足，达到了数据可持久化。
即master上snapshot和aof都不做，来保证master的读写性能，而slave上则同时开启snapshot和aof来进行持久化，保证数据的安全性。

首先，修改master上的如下配置：
$ sudo vim /opt/redis/etc/redis_6379.conf

#save 900 1 #禁用snapshot
#save 300 10
#save 60 10000

appendonly no #禁用aof

接着，修改slave上的如下配置：
$ sudo vim /opt/redis/etc/redis_6379.conf

save 900 1 #启用snapshot
save 300 10
save 60 10000

appendonly yes #启用aof
appendfilename appendonly.aof #aof文件的名称
# appendfsync always
appendfsync everysec #每秒钟强制写入磁盘一次
# appendfsync no  

no-appendfsync-on-rewrite yes   #在日志重写时，不进行命令追加操作
auto-aof-rewrite-percentage 100 #自动启动新的日志重写过程
auto-aof-rewrite-min-size 64mb  #启动新的日志重写过程的最小值

分别启动master与slave
$ /etc/init.d/redis start

启动完成后在master中确认未启动snapshot参数
redis 127.0.0.1:6379> config get save
1) "save"
2) ""

然后通过以下脚本在master中生成25万条数据：
dongguo@redis:/opt/redis/data/6379$ cat redis-cli-generate.temp.sh

#!/bin/bash

rediscli="redis-cli -a slavepass -n 1 set"
id=1

while(($id<50001))
do
  instance_name="i-2-$id-vm"
  uuid=`cat /proc/sys/kernel/random/uuid`
  private_ip_address=10.`echo "$random % 255 + 1" | bc`.`echo "$random % 255 + 1" | bc`.`echo "$random % 255 + 1" | bc`\
  created=`date "+%y-%m-%d %h:%m:%s"`

  $rediscli vm_instance:$id:instance_name "$instance_name"
  $rediscli vm_instance:$id:uuid "$uuid"
  $rediscli vm_instance:$id:private_ip_address "$private_ip_address"
  $rediscli vm_instance:$id:created "$created"

  $rediscli vm_instance:$instance_name:id "$id"

  id=$(($id+1))
done

dongguo@redis:/opt/redis/data/6379$ ./redis-cli-generate.temp.sh

在数据的生成过程中，可以很清楚的看到master上仅在第一次做slave同步时创建了dump.rdb文件，之后就通过增量传输命令的方式给slave了。
dump.rdb文件没有再增大。
dongguo@redis:/opt/redis/data/6379$ ls -lh
total 4.0k
-rw-r--r-- 1 root root 10 sep 27 00:40 dump.rdb

而slave上则可以看到dump.rdb文件和aof文件在不断的增大，并且aof文件的增长速度明显大于dump.rdb文件。
dongguo@redis-slave:/opt/redis/data/6379$ ls -lh
total 24m
-rw-r--r-- 1 root root 15m sep 27 12:06 appendonly.aof
-rw-r--r-- 1 root root 9.2m sep 27 12:06 dump.rdb

等待数据插入完成以后，首先确认当前的数据量。
redis 127.0.0.1:6379> info

redis_version:2.4.17
redis_git_sha1:00000000
redis_git_dirty:0
arch_bits:64
multiplexing_api:epoll
gcc_version:4.4.5
process_id:27623
run_id:e00757f7b2d6885fa9811540df9dfed39430b642
uptime_in_seconds:1541
uptime_in_days:0
lru_clock:650187
used_cpu_sys:69.28
used_cpu_user:7.67
used_cpu_sys_children:0.00
used_cpu_user_children:0.00
connected_clients:1
connected_slaves:1
client_longest_output_list:0
client_biggest_input_buf:0
blocked_clients:0
used_memory:33055824
used_memory_human:31.52m
used_memory_rss:34717696
used_memory_peak:33055800
used_memory_peak_human:31.52m
mem_fragmentation_ratio:1.05
mem_allocator:jemalloc-3.0.0
loading:0
aof_enabled:0
changes_since_last_save:250000
bgsave_in_progress:0
last_save_time:1348677645
bgrewriteaof_in_progress:0
total_connections_received:250007
total_commands_processed:750019
expired_keys:0
evicted_keys:0
keyspace_hits:0
keyspace_misses:0
pubsub_channels:0
pubsub_patterns:0
latest_fork_usec:246
vm_enabled:0
role:master
slave0:10.6.1.144,6379,online
db1:keys=250000,expires=0

当前的数据量为25万条key，占用内存31.52m。

然后我们直接kill掉master的redis进程，模拟灾难。
dongguo@redis:/opt/redis/data/6379$ sudo killall -9 redis-server

我们到slave中查看状态：
redis 127.0.0.1:6379> info

redis_version:2.4.17
redis_git_sha1:00000000
redis_git_dirty:0
arch_bits:64
multiplexing_api:epoll
gcc_version:4.4.5
process_id:13003
run_id:9b8b398fc63a26d160bf58df90cf437acce1d364
uptime_in_seconds:1627
uptime_in_days:0
lru_clock:654181
used_cpu_sys:29.69
used_cpu_user:1.21
used_cpu_sys_children:1.70
used_cpu_user_children:1.23
connected_clients:1
connected_slaves:0
client_longest_output_list:0
client_biggest_input_buf:0
blocked_clients:0
used_memory:33047696
used_memory_human:31.52m
used_memory_rss:34775040
used_memory_peak:33064400
used_memory_peak_human:31.53m
mem_fragmentation_ratio:1.05
mem_allocator:jemalloc-3.0.0
loading:0
aof_enabled:1
changes_since_last_save:3308
bgsave_in_progress:0
last_save_time:1348718951
bgrewriteaof_in_progress:0
total_connections_received:4
total_commands_processed:250308
expired_keys:0
evicted_keys:0
keyspace_hits:0
keyspace_misses:0
pubsub_channels:0
pubsub_patterns:0
latest_fork_usec:694
vm_enabled:0
role:slave
aof_current_size:17908619
aof_base_size:16787337
aof_pending_rewrite:0
aof_buffer_length:0
aof_pending_bio_fsync:0
master_host:10.6.1.143
master_port:6379
master_link_status:down
master_last_io_seconds_ago:-1
master_sync_in_progress:0
master_link_down_since_seconds:25
slave_priority:100
db1:keys=250000,expires=0

可以看到master_link_status的状态已经是down了，master已经不可访问了。
而此时，slave依然运行良好，并且保留有aof与rdb文件。

下面我们将通过slave上保存好的aof与rdb文件来恢复master上的数据。

首先，将slave上的同步状态取消，避免主库在未完成数据恢复前就重启，进而直接覆盖掉从库上的数据，导致所有的数据丢失。
redis 127.0.0.1:6379> slaveof no one
ok

确认一下已经没有了master相关的配置信息：
redis 127.0.0.1:6379> info

redis_version:2.4.17
redis_git_sha1:00000000
redis_git_dirty:0
arch_bits:64
multiplexing_api:epoll
gcc_version:4.4.5
process_id:13003
run_id:9b8b398fc63a26d160bf58df90cf437acce1d364
uptime_in_seconds:1961
uptime_in_days:0
lru_clock:654215
used_cpu_sys:29.98
used_cpu_user:1.22
used_cpu_sys_children:1.76
used_cpu_user_children:1.42
connected_clients:1
connected_slaves:0
client_longest_output_list:0
client_biggest_input_buf:0
blocked_clients:0
used_memory:33047696
used_memory_human:31.52m
used_memory_rss:34779136
used_memory_peak:33064400
used_memory_peak_human:31.53m
mem_fragmentation_ratio:1.05
mem_allocator:jemalloc-3.0.0
loading:0
aof_enabled:1
changes_since_last_save:0
bgsave_in_progress:0
last_save_time:1348719252
bgrewriteaof_in_progress:0
total_connections_received:4
total_commands_processed:250311
expired_keys:0
evicted_keys:0
keyspace_hits:0
keyspace_misses:0
pubsub_channels:0
pubsub_patterns:0
latest_fork_usec:1119
vm_enabled:0
role:master
aof_current_size:17908619
aof_base_size:16787337
aof_pending_rewrite:0
aof_buffer_length:0
aof_pending_bio_fsync:0
db1:keys=250000,expires=0

在slave上复制数据文件：
dongguo@redis-slave:/opt/redis/data/6379$ tar cvf /home/dongguo/data.tar *
appendonly.aof
dump.rdb

将data.tar上传到master上，尝试恢复数据:
可以看到master目录下有一个初始化slave的数据文件，很小，将其删除。
dongguo@redis:/opt/redis/data/6379$ ls -l
total 4
-rw-r--r-- 1 root root 10 sep 27 00:40 dump.rdb
dongguo@redis:/opt/redis/data/6379$ sudo rm -f dump.rdb

然后解压缩数据文件：
dongguo@redis:/opt/redis/data/6379$ sudo tar xf /home/dongguo/data.tar
dongguo@redis:/opt/redis/data/6379$ ls -lh
total 29m
-rw-r--r-- 1 root root 18m sep 27 01:22 appendonly.aof
-rw-r--r-- 1 root root 12m sep 27 01:22 dump.rdb

启动master上的redis；
dongguo@redis:/opt/redis/data/6379$ sudo /etc/init.d/redis start
starting redis server...

查看数据是否恢复：
redis 127.0.0.1:6379> info

redis_version:2.4.17
redis_git_sha1:00000000
redis_git_dirty:0
arch_bits:64
multiplexing_api:epoll
gcc_version:4.4.5
process_id:16959
run_id:6e5ba6c053583414e75353b283597ea404494926
uptime_in_seconds:22
uptime_in_days:0
lru_clock:650292
used_cpu_sys:0.18
used_cpu_user:0.20
used_cpu_sys_children:0.00
used_cpu_user_children:0.00
connected_clients:1
connected_slaves:0
client_longest_output_list:0
client_biggest_input_buf:0
blocked_clients:0
used_memory:33047216
used_memory_human:31.52m
used_memory_rss:34623488
used_memory_peak:33047192
used_memory_peak_human:31.52m
mem_fragmentation_ratio:1.05
mem_allocator:jemalloc-3.0.0
loading:0
aof_enabled:0
changes_since_last_save:0
bgsave_in_progress:0
last_save_time:1348680180
bgrewriteaof_in_progress:0
total_connections_received:1
total_commands_processed:1
expired_keys:0
evicted_keys:0
keyspace_hits:0
keyspace_misses:0
pubsub_channels:0
pubsub_patterns:0
latest_fork_usec:0
vm_enabled:0
role:master
db1:keys=250000,expires=0

可以看到25万条数据已经完整恢复到了master上。

此时，可以放心的恢复slave的同步设置了。
redis 127.0.0.1:6379> slaveof 10.6.1.143 6379
ok

查看同步状态：
redis 127.0.0.1:6379> info

redis_version:2.4.17
redis_git_sha1:00000000
redis_git_dirty:0
arch_bits:64
multiplexing_api:epoll
gcc_version:4.4.5
process_id:13003
run_id:9b8b398fc63a26d160bf58df90cf437acce1d364
uptime_in_seconds:2652
uptime_in_days:0
lru_clock:654284
used_cpu_sys:30.01
used_cpu_user:2.12
used_cpu_sys_children:1.76
used_cpu_user_children:1.42
connected_clients:2
connected_slaves:0
client_longest_output_list:0
client_biggest_input_buf:0
blocked_clients:0
used_memory:33056288
used_memory_human:31.52m
used_memory_rss:34766848
used_memory_peak:33064400
used_memory_peak_human:31.53m
mem_fragmentation_ratio:1.05
mem_allocator:jemalloc-3.0.0
loading:0
aof_enabled:1
changes_since_last_save:0
bgsave_in_progress:0
last_save_time:1348719252
bgrewriteaof_in_progress:1
total_connections_received:6
total_commands_processed:250313
expired_keys:0
evicted_keys:0
keyspace_hits:0
keyspace_misses:0
pubsub_channels:0
pubsub_patterns:0
latest_fork_usec:12217
vm_enabled:0
role:slave
aof_current_size:17908619
aof_base_size:16787337
aof_pending_rewrite:0
aof_buffer_length:0
aof_pending_bio_fsync:0
master_host:10.6.1.143
master_port:6379
master_link_status:up
master_last_io_seconds_ago:0
master_sync_in_progress:0
slave_priority:100
db1:keys=250000,expires=0

master_link_status显示为up，同步状态正常。

在此次恢复的过程中，我们同时复制了aof与rdb文件，那么到底是哪一个文件完成了数据的恢复呢？
实际上，当redis服务器挂掉时，重启时将按照以下优先级恢复数据到内存：
1. 如果只配置aof,重启时加载aof文件恢复数据；
2. 如果同时 配置了rdb和aof,启动是只加载aof文件恢复数据;
3. 如果只配置rdb,启动是将加载dump文件恢复数据。

也就是说，aof的优先级要高于rdb，这也很好理解，因为aof本身对数据的完整性保障要高于rdb。

在此次的案例中，我们通过在slave上启用了aof与rdb来保障了数据，并恢复了master。

但在我们目前的线上环境中，由于数据都设置有过期时间，采用aof的方式会不太实用，过于频繁的写操作会使aof文件增长到异常的庞大，大大超过了我们实际的数据量，这也会导致在进行数据恢复时耗用大量的时间。
因此，可以在slave上仅开启snapshot来进行本地化，同时可以考虑将save中的频率调高一些或者调用一个计划任务来进行定期bgsave的快照存储，来尽可能的保障本地化数据的完整性。
在这样的架构下，如果仅仅是master挂掉，slave完整，数据恢复可达到100%。
如果master与slave同时挂掉的话，数据的恢复也可以达到一个可接受的程度。

 

转自：