Linux云计算 |【第四阶段】NOSQL-DAY3

主要内容：

redis主从复制、哨兵服务（高可用）、数据持久化（RDB、AOF）

一、Redis主从复制概述

Redis 主从复制是一种数据复制机制，用于在多个 Redis 实例之间同步数据，以提高系统的可用性、可靠性和读取性能。主从复制的基本头脑是将一个 Redis 实例（主节点）的数据复制到一个或多个其他 Redis 实例（从节点），从而实现数据的冗余备份和读写分离。以下是 Redis 主从复制的概述：
1. 基本概念
   

• 主节点（Master）：负责处理全部写利用，并将数据变更同步到从节点。
  
• 从节点（Slave）：复制主节点的数据，并可以处理读利用。从节点不处理写利用，只负责读取和备份数据。
  

  2. 主从复制的设置

• 主节点设置：通常不需要特殊设置，主节点默认担当全部客户端的读写哀求。
  
• 从节点设置：从节点需要设置主节点的地点和端口，例如：
  1. slaveof <master-ip> <master-port>

  复制代码
  或者在设置文件中设置：
  1. slaveof 192.168.1.100 6379

  复制代码

3. 数据同步过程
   

• 全量复制（Full Resynchronization）：
  
  
  
  • 当从节点初次连接到主节点时，会进行全量复制。主节点生成一个 RDB 快照文件，并将其发送给从节点。
    
  • 从节点吸收并加载 RDB 文件，然后继续同步主节点的增量数据。
    
  
  
• 增量复制（Partial Resynchronization）：
  
  
  
  • 在全量复制完成后，主节点会将后续的数据变更（写利用）通过复制缓冲区（replication buffer）发送给从节点。
    
  • 从节点吸收并应用这些增量数据，保持与主节点的数据一致性。
    
  
  

  4. 复制缓冲区

• 复制缓冲区（Replication Buffer）：主节点维护一个复制缓冲区，用于存储近来的数据变更。从节点通过复制缓冲区吸收增量数据。
  
• 复制积压缓冲区（Replication Backlog）：主节点还维护一个复制积压缓冲区，用于在从节点断开连接后重新同步数据。
  

5. 利用场景

• 读写分离：适用于读多写少的场景，通过读写分离提高系统的读取性能。
  
• 数据备份：适用于需要数据冗余备份的场景，提高数据的可靠性和容错本领。
  
• 故障转移：适用于需要高可用性的场景，通过故障转移机制确保服务的一连性。
  

---

1）结构模式：一主一从、一主多从、主从从

2）主从复制工作原理（与MySQL的主从同步差别）

• ① Slave向Master发送sync下令；
  
• ② Master启动后台存盘进程，并收集全部修改数据下令；
  
• ③ Master完成后台存盘后，传送整个数据文件到Slave;
  
• ④ Slave吸收数据文件，加载到内存中完成初次完全同步；
  
• ⑤ 后续有新数据产生时，Master继续收集数据修改下令一次传给Slave，完成同步；
  

1、一主一从结构示例：

实验网络拓扑：

步调1：规复redis1和redis2的redis默认设置

① 修改2个节点的设置文件，注释集群功能，并重启服务

1. ## redis1
2. [root@redis1 ~]# vim /etc/redis/6379.conf
3. # cluster-enabled yes
4. # cluster-config-file nodes-6379.conf
5. # cluster-node-timeout 5000
6. [root@redis1 ~]# service redis_6379 stop   //停止服务
7. Stopping ...
8. Redis stopped
9. [root@redis1 ~]# ls /var/lib/redis/6379/
10. dump.rdb         nodes-6379.conf
11. [root@redis1 ~]# rm -f /var/lib/redis/6379/*    //清除数据目录
12. [root@redis1 ~]# service redis_6379 start   //启动服务
13. Starting Redis server...
16. ## redis2
17. [root@redis2 ~]# vim /etc/redis/6379.conf
18. # cluster-enabled yes
19. # cluster-config-file nodes-6379.conf
20. # cluster-node-timeout 5000
21. [root@redis2 ~]# service redis_6379 stop   //停止服务
22. Stopping ...
23. Redis stopped
24. [root@redis2 ~]# ls /var/lib/redis/6379/
25. dump.rdb         nodes-6379.conf
26. [root@redis2 ~]# rm -f /var/lib/redis/6379/*    //清除数据目录
27. [root@redis2 ~]# service redis_6379 start   //启动服务
28. Starting Redis server...

复制代码

步调2：设置主从服务器

① 默认redis都是主服务器（无需设置）

1. [root@redis1 ~]# redis-cli
2. 127.0.0.1:6379> INFO replication    //查看主从复制信息
3. # Replication
4. role:master    /角色为master主节点
5. connected_slaves:0
6. master_replid:fea1bd84c837c4968c506c4ef01df7bdb05ffa9f
7. master_replid2:0000000000000000000000000000000000000000
8. master_repl_offset:0
9. second_repl_offset:-1
10. repl_backlog_active:0
11. repl_backlog_size:1048576
12. repl_backlog_first_byte_offset:0
13. repl_backlog_histlen:0

复制代码

② 设置redis2(192.168.1.12)为redis1的从服务器
- 方法1：通过下令进行设置（临时见效）

1. [root@redis2 ~]# redis-cli
2. 127.0.0.1:6379> SLAVEOF 192.168.2.11 6379   //指定主服务器IP和端口
3. OK
4. 127.0.0.1:6379> INFO replication    //查看主从复制信息
5. # Replication
6. role:slave    //角色为Slave从节点
7. master_host:192.168.2.11    //主节点IP地址
8. master_port:6379            //主节点端口
9. master_link_status:up       //到主节点的连接状态
10. master_last_io_seconds_ago:8
11. master_sync_in_progress:0
12. slave_repl_offset:14
13. slave_priority:100
14. slave_read_only:1
15. connected_slaves:0
16. master_replid:fdeac0f68bb6295ace1c3d82ecc0512f011afb8f
17. master_replid2:0000000000000000000000000000000000000000
18. master_repl_offset:14
19. second_repl_offset:-1
20. repl_backlog_active:1
21. repl_backlog_size:1048576
22. repl_backlog_first_byte_offset:1
23. repl_backlog_histlen:14

复制代码

- 方法2：修改设置文件（永久见效），需要重启服务

1. [root@redis2 ~]# vim /etc/redis/6379.conf
2. #slaveof <masterip> <masterport>
3. slaveof 192.168.2.11 6379    //指定主服务器IP和端口
4. [root@redis2 ~]# service redis_6379 restart
5. Stopping ...
6. Redis stopped
7. Starting Redis server...

复制代码

# 查看redis1主节点的主从复制信息

1. [root@redis1 ~]# redis-cli
2. 127.0.0.1:6379> INFO replication
3. # Replication
4. role:master
5. connected_slaves:1     //从服务器连接为1
6. slave0:ip=192.168.2.12,port=6379,state=online,offset=364,lag=1
7. master_replid:fdeac0f68bb6295ace1c3d82ecc0512f011afb8f
8. master_replid2:0000000000000000000000000000000000000000
9. master_repl_offset:364
10. second_repl_offset:-1
11. repl_backlog_active:1
12. repl_backlog_size:1048576
13. repl_backlog_first_byte_offset:1
14. repl_backlog_histlen:364

复制代码

③ 测试设置
# 在redis1主服务器上添加数据

1. 127.0.0.1:6379> SET name tom
2. OK
3. 127.0.0.1:6379> SET email tom@tedu.cn
4. OK

复制代码

# 在redis2从服务器上查看同步的数据

1. [root@redis2 ~]# redis-cli
2. 127.0.0.1:6379> KEYS *
3. 1) "email"
4. 2) "name"
5. 127.0.0.1:6379> MGET name email
6. 1) "tom"
7. 2) tom@tedu.cn

复制代码

---

常见报错：在从服务器无法进行写入利用，会有报错

1. 127.0.0.1:6379> SET name jerry
2. (error) READONLY You can't write against a read only slave.

复制代码

与MySQL区别：Redis不可以往从服务器上写入利用会有报错，且没有相干授权用户利用；MySQL授权的用户假如有INSERT权限，可以往从服务器上写入数据，但会导致主从同步的SQL-server失效；

---

2、设置带验证的主从复制示例：

基于以上示例【一主一从结构】，设置认证
实验网络拓扑：

步调1：设置主服务器redis1的连接暗码为`tedu.cn`（redis1利用）

① 设置暗码

1. [root@redis1 ~]# vim +501 /etc/redis/6379.conf
2. # requirepass foobared
3. requirepass tedu.cn    //请求密码

复制代码

② 修改服务启动脚本（添加暗码，否则关闭服务会报错）

1. [root@redis1 ~]# vim +43  /etc/init.d/redis_6379
2.             $CLIEXEC -p $REDISPORT -a tedu.cn shutdown

复制代码

③ 重启服务

1. [root@redis1 ~]# service redis_6379 restart
2. Stopping ...
3. Redis stopped
4. Starting Redis server...

复制代码

步调2：设置从服务器（redis2利用）

① 修改设置文件，设置主服务器连接暗码

1. [root@redis2 ~]# vim +289 /etc/redis/6379.conf
2. # masterauth <master-password>
3. masterauth tedu.cn     //定义连接Master密码

复制代码

② 重启服务

1. [root@redis2 ~]# service redis_6379 restart
2. Stopping ...
3. Redis stopped
4. Starting Redis server...

复制代码

③ 在从服务器本机连接redis服务，查看主从复制信息

1. [root@redis2 ~]# redis-cli
2. 127.0.0.1:6379> ping
3. PONG
4. 127.0.0.1:6379> info replication   //查看主从复制信息
5. # Replication
6. role:slave
7. master_host:192.168.2.11
8. master_port:6379
9. master_link_status:up
10. master_last_io_seconds_ago:1
11. master_sync_in_progress:0
12. slave_repl_offset:322
13. slave_priority:100
14. slave_read_only:1
15. connected_slaves:0
16. master_replid:14f6ce64ec702fde0b0905ac257953f1034e1967
17. master_replid2:0000000000000000000000000000000000000000
18. master_repl_offset:322
19. second_repl_offset:-1
20. repl_backlog_active:1
21. repl_backlog_size:1048576
22. repl_backlog_first_byte_offset:85
23. repl_backlog_histlen:238

复制代码

验证设置：从服务器连接主服务器redis服务

1. [root@redis2 ~]# redis-cli -h 192.168.2.11
2. 192.168.2.11:6379> ping
3. (error) NOAUTH Authentication required.   //认证失败
4. 192.168.2.11:6379> info replication
5. NOAUTH Authentication required.    //认证失败
6.  
7. [root@redis2 ~]# redis-cli -h 192.168.2.11 -a tedu.cn    //指定密码连接
8. 192.168.2.11:6379> ping
9. PONG
10. 192.168.2.11:6379> info replication   //查看主从复制信息
11. # Replication
12. role:master
13. connected_slaves:1
14. slave0:ip=192.168.2.12,port=6379,state=online,offset=1498,lag=1
15. master_replid:04f765d3caba1faf0a9580a23cfea8fb0fb98e41
16. master_replid2:0000000000000000000000000000000000000000
17. master_repl_offset:1498
18. second_repl_offset:-1
19. repl_backlog_active:1
20. repl_backlog_size:1048576
21. repl_backlog_first_byte_offset:1
22. repl_backlog_histlen:1498
23. 192.168.2.11:6379> AUTH tedu.cn    //验证密码
24. OK

复制代码

二、Sentinel 哨兵服务

Redis Sentinel 是 Redis 的高可用性解决方案，用于监控 Redis 主从复制环境中的主节点和从节点，并在主节点发生故障时自动进行故障转移。Sentinel 通过监控、通知和自动故障转移，确保 Redis 服务的高可用性和可靠性。以下是 Redis Sentinel 的概述：
   

• 一般节点较少且不在redis集群中，需要实现主从切换，一般是主服务器宕机后，需要手动把一台从服务器切换为主服务器，无法实现自动的选举成主服务器；而通过哨兵服务sentinel来监视Master服务器，发现Master宕机后，可以将从服务器升级为主服务器；
  
• 哨兵模式是redis官方提供的高可用方案，是一种特殊的模式，首先Redis提供了哨兵的下令，哨兵是一个独立的进程，作为进程，它会独立运行。其原理是哨兵通过发送下令，等待Redis服务器响应，从而监控运行的多个Redis服务实例的运行情况；
  

  1.Sentinel 的基本概念

• Sentinel 节点：Sentinel 是一个独立的进程，负责监控 Redis 主从集群的状态。多个 Sentinel 节点可以构成一个 Sentinel 集群，以提高监控的可靠性和容错本领。
  
• 主节点（Master）：被监控的 Redis 主节点。
  
• 从节点（Slave）：被监控的 Redis 从节点。
  

2.Sentinel 的功能

• 监控（Monitoring）：Sentinel 持续监控主节点和从节点的状态，查抄它们是否正常运行。
  
• 通知（Notification）：Sentinel 可以通过设置的通知系统（如邮件、短信等）向管理员发送通知，陈诉主节点或从节点的状态变化。
  
• 自动故障转移（Automatic Failover）：当主节点发生故障时，Sentinel 会自动选择一个从节点提升为主节点，并通知其他从节点和新主节点进行数据同步。
  
• 设置提供者（Configuration Provider）：Sentinel 可以作为客户端的设置提供者，客户端可以通过 Sentinel 获取当前的主节点地点。
  

3.Sentinel 的工作原理
   

• 监控：Sentinel 定期向主节点和从节点发送 PING 下令，查抄它们的状态。假如某个节点在指定时间内没有响应，Sentinel 会将其标记为“主观下线”。
  
• 主观下线和客观下线：
  
  
  
  • 主观下线（Subjectively Down, SDOWN）：单个 Sentinel 节点认为某个节点下线。
    
  • 客观下线（Objectively Down, ODOWN）：当足够数量的 Sentinel 节点（达到 quorum 值）认为某个节点下线时，该节点被标记为客观下线。
    
  
  
• 故障转移：
  
  
  
  • 当主节点被标记为客观下线时，Sentinel 集群会进行故障转移。
    
  • Sentinel 集群通过选举机制选择一个 Sentinel 节点作为领导者，负责执行故障转移。
    
  • 领导者 Sentinel 选择一个从节点提升为主节点，并通知其他从节点和新主节点进行数据同步。
    
  • 客户端通过 Sentinel 获取新的主节点地点，继续进行读写利用。
    
  
  

  
1、故障切换（failover）的过程

假设主服务器宕机，哨兵先检测到这个结果，但并不会立刻进行failover过程，仅仅是哨兵主观的认为主服务器不可用，这个现象成为主观下线。当后面的哨兵也检测到主服务器不可用，而且数量达到肯定值时，那么哨兵之间就会进行一次投票，投票的结果由一个哨兵发起，进行failover利用。切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程称为客观下线。这样对于客户端而言，一切都是透明的。

---

主设置文件：sentinel.conf
模板文件：redis-4.0.8/sentinel.conf
设置哨兵服务步调：

• ① 安装redis软件
  
• ② 创建主设置文件（参考模板文件）
  

格式：sentinel monitor <name> <masterIP> <masterPort> <Quorum投票数>

③ 启动哨兵服务（Sentinel默认端口号为26379）

1. [root@sentinel ~]# ss -nlptu | grep :26379
2. tcp    LISTEN     0      128       *:26379                 *:*                   users:(("redis-sentinel",pid=11158,fd=6))

复制代码

2、设置哨兵服务示例

   基于以上示例【设置带验证的主从复制】，设置哨兵服务
  实验网络拓扑：

---

步调1：设置哨兵服务

1. [root@redis1 ~]# ls /usr/local/redis/bin/   //哨兵脚本（redis-sentinel）

复制代码

① 在redis服务器(如redis1)上，拷贝哨兵程序到哨兵服务器

1. [root@redis1 ~]# scp -r /usr/local/redis 192.168.2.19:/usr/local

复制代码

② 在sentinel服务器上，将redis安装目次添加至PATH环境变量

1. [root@sentinel ~]# echo 'export PATH=$PATH:/usr/local/redis/bin' >> /etc/bashrc
2. [root@sentinel ~]# source /etc/bashrc

复制代码

# 查看帮助

1. [root@sentinel ~]# redis-sentinel -h
2. Usage: ./redis-server [/path/to/redis.conf] [options]
3.        ./redis-server - (read config from stdin)
4.        ./redis-server -v or --version
5.        ./redis-server -h or --help
6.        ./redis-server --test-memory <megabytes>
7.  
8. Examples:
9.        ./redis-server (run the server with default conf)
10.        ./redis-server /etc/redis/6379.conf
11.        ./redis-server --port 7777
12.        ./redis-server --port 7777 --slaveof 127.0.0.1 8888
13.        ./redis-server /etc/myredis.conf --loglevel verbose
14.  
15. Sentinel mode:
16.        ./redis-server /etc/sentinel.conf --sentinel

复制代码

③ 创建哨兵服务的设置文件（手动创建）

1. [root@sentinel ~]# vim /etc/sentinel.conf
2. sentinel monitor redis1 192.168.2.11 6379 1   //监视主服务器（主机名、IP、端口、票数）
3. bind 0.0.0.0      //哨兵服务运行地址（使得Redis服务器可以跨网络访问）
4. sentinel auth-pass redis1 tedu.cn     //连接主服务器的密码

复制代码

④ 启动哨兵服务

1. [root@sentinel ~]# redis-sentinel /etc/sentinel.conf
2. 11158:X 21 Jun 14:23:32.181 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
3. 11158:X 21 Jun 14:23:32.181 # Redis version=4.0.8, bits=64, commit=00000000, modified=0, pid=11158, just started

复制代码

测试设置：
① 停止主服务器redis1节点的Redis服务

1. [root@redis1 ~]# service redis_6379 stop
2. Stopping ...
3. Redis stopped

复制代码

# 哨兵服务状态信息

② 在redis2节点上查看主从复制状态（redis2节点vote投票为主服务器）

1. [root@redis2 ~]# redis-cli
2. 127.0.0.1:6379> INFO replication
3. # Replication
4. role:master     //已变为主服务器
5. connected_slaves:0
6. master_replid:5627cc5fe2bb9d81de6b50bfd3a69c83257d9ac7
7. master_replid2:04f765d3caba1faf0a9580a23cfea8fb0fb98e41
8. master_repl_offset:39496
9. second_repl_offset:33720
10. repl_backlog_active:1
11. repl_backlog_size:1048576
12. repl_backlog_first_byte_offset:1
13. repl_backlog_histlen:39496

复制代码

③ 规复redis1节点的Redis服务

1. [root@redis1 ~]# service redis_6379 start
2. Starting Redis server...

复制代码

# 哨兵服务状态信息（将原主节点redis1作为redis2的从节点）

④ 在redis1节点上查看主从复制状态（redis1节点已切换为redis2的从服务器）

1. [root@redis1 ~]# redis-cli -a tedu.cn
2. 127.0.0.1:6379> INFO replication
3. # Replication
4. role:slave    //已变为从服务器
5. master_host:192.168.2.12
6. master_port:6379
7. master_link_status:up
8. master_last_io_seconds_ago:2
9. master_sync_in_progress:0
10. slave_repl_offset:69788
11. slave_priority:100
12. slave_read_only:1
13. connected_slaves:0
14. master_replid:5627cc5fe2bb9d81de6b50bfd3a69c83257d9ac7
15. master_replid2:0000000000000000000000000000000000000000
16. master_repl_offset:69788
17. second_repl_offset:-1
18. repl_backlog_active:1
19. repl_backlog_size:1048576
20. repl_backlog_first_byte_offset:56896
21. repl_backlog_histlen:12893

复制代码

三、数据持久化

1、RedisDataBase(RDB)，Redis数据库文件

• ① 数据持久化方式之一；
  
• ② 数据持久化默认方式；
  
• ③ 按照指定时间隔断，将内存中的数据集快照写入硬盘；
  
• ④ 通过RDB进行备份还原，只要拷贝RBD文件即可
  

RDB的优缺点：
① 优点：
   

• 高性能的持久化实现：创建一个子进程来执行持久化，先将数据写入临时文件，持久化过程竣事后，再用这个临时文件更换上次持久化好的文件；
  
• 过程中主进程不做任何IO利用；
  
• 比力适合大规模数据规复，且对数据完整性要求不黑白常高的场合；
  

  ② 缺点：
不测宕机时，丢失最后一次持久化的全部数据；
   - RDB界说文件名：dbfilename “dump.rdb”
  - 数据从内存生存到磁盘的频率设置：
  

• save 900 1       //15分钟内有1个key改变即存盘 
  
• save 300 10      //5分钟内有10个key改变即存盘
  
• save 60 10000   //1分钟内有10000个key改变即存盘
  

  - 手动存盘：
  

• save         //壅闭写存盘
  
• bgsave       //不壅闭写存盘（bg：backgroup后台）
  

  增补：Redis是单线程来处理下令的，全部每一条到达服务端的下令不会立即执行，全部的下令都会进入一个队列中，然后逐个被执行；而且多个客户端发送的下令的执行顺序是不确定的。但是可以确定的是不会有两条下令被同时执行，不会产生并发问题，这就是Redis的单线程基本模子；

设置RDB示例

步调1：设置RDB参数，随便找一台redis服务器（关闭集群功能）

1. [root@redis7 ~]# vim /etc/redis/6379.conf
2. dbfilename dump.rdb    //RDB定义文件名（默认即可）
3. save 900 1
4. #save 300 10
5. save 120 10    //120秒内，有10个key改变即存盘
6. save 60 10000

复制代码

步调2：清空rbd数据

① 停止redis服务

1. [root@redis7 ~]# service redis_6379 stop
2. Stopping ...
3. Redis stopped

复制代码

② 删除数据

1. [root@redis7 ~]# ls /var/lib/redis/6379/
2. dump.rdb         nodes-6379.conf
3. [root@redis7 ~]# rm -rf /var/lib/redis/6379/*

复制代码

③ 启动redis服务

1. [root@redis7 ~]# service redis_6379 start
2. Starting Redis server...

复制代码

# 查看数据文件，由于没有存储过任何数据，所以不存在RBD文件

1. [root@redis7 ~]# ls /var/lib/redis/6379/

复制代码

步调3：存储数据

① 120秒内添加10个数据，并记录一次存盘

1. [root@redis7 ~]# redis-cli
2. 127.0.0.1:6379> MSET k1 v1 k2 v2 k3 v3 k4 v4 k5 v5
3. OK
4. 127.0.0.1:6379> MSET k6 v6 k7 v7 k8 v8 k9 v9 k10 v10
5. OK
6. 127.0.0.1:6379> KEYS *
7.  1) "k1"
8.  2) "k4"
9.  3) "k8"
10.  4) "k2"
11.  5) "k10"
12.  6) "k7"
13.  7) "k9"
14.  8) "k3"
15.  9) "k5"
16. 10) "k6"
17. 127.0.0.1:6379> exit

复制代码

② 验证查看数据文件

1. [root@redis7 ~]# watch -n1 ls /var/lib/redis/6379/   //watch命令实时动态查看
2. [root@redis7 ~]# ls /var/lib/redis/6379/
3. dump.rdb

复制代码

步调4：验证备份还原

① 备份数据文件

1. [root@redis7 ~]# cp /var/lib/redis/6379/dump.rdb /root/
2. [root@redis7 ~]# ls /root/
3. anaconda-ks.cfg  dump.rdb  redis-4.0.8

复制代码

② 模拟误删除数据

1. [root@redis7 ~]# redis-cli
2. 127.0.0.1:6379> FLUSHALL
3. OK
4. 127.0.0.1:6379> KEYS *
5. (empty list or set)
6. 127.0.0.1:6379> exit

复制代码

③ 通过备份的dump.rdb文件，规复数据

1. [root@redis7 ~]# service redis_6379 stop   //停止服务，防止其他用户连接产生新数据
2. Stopping ...
3. Redis stopped
4. [root@redis7 ~]# cp /root/dump.rdb /var/lib/redis/6379/   //用备份文件覆盖目标文件
5. cp：是否覆盖"/var/lib/redis/6379/dump.rdb"？ yes

复制代码

④ 启动服务并验证

1. [root@redis7 ~]# service redis_6379 start   //启动服务
2. Starting Redis server...
3. [root@redis7 ~]# redis-cli
4. 127.0.0.1:6379> KEYS *
5.  1) "k1"
6.  2) "k4"
7.  3) "k8"
8.  4) "k6"
9.  5) "k3"
10.  6) "k9"
11.  7) "k5"
12.  8) "k7"
13.  9) "k10"
14. 10) "k2"

复制代码

---

增补：rdb文件无法直接利用cat查看，可以通过strings下令查看

1. [root@redis7 ~]# cat /var/lib/redis/6379/dump.rdb
2. REDIS0008▒      redis-ver4.0.8▒
3. redis-bits▒@▒ctimeªN▒`used-mem�▒
4.                                 ▒
5. aof-preamble▒▒▒
6. k1v1k4v4k8v8k2v2k10v10k7v7k9v9k3v3k5v5k6v6▒.▒G▒v

复制代码

1. [root@redis7 ~]# strings /var/lib/redis/6379/dump.rdb   //通过strings可查看rdb文件
2. REDIS0008
3.         redis-ver
4. 4.0.8
5. redis-bits
6. ctime
7. used-mem
8. aof-preamble

复制代码

增补：RDB存储数据不是立即存储，而是按照指定时间隔断，将内存中的数据集快照写入硬盘，假如不测宕机，时间隔断未到且未存盘，则大概会导致最后一次持久化数据全部丢失；AOF已追加方式进行存盘，安全性和可靠性比RDB存储更高，但由于是及时存数据，效率比RDB差；

2、Append Only File(AOF)

• ① 追加方式记录写利用的文件
  
• ② 记录redis服务全部写利用（与MySQL的binlong日志雷同）
  
• ③ 不断的将新的写利用，追加到文件的末尾
  
• ④ 默认没有启用（appendonly yes启用aof）
  
• ⑤ 利用cat下令可以查看文件内容
  

利用AOF文件规复数据：

AOF界说文件名：appendfilename “appendonly.aof”
AOF文件记录写利用的方式：

• appendfsync always      //及时记录，并完成磁盘同步
  
• appendfsync everysec   //每秒记录一次，并完成磁盘同步
  
• appendfsync no         //写入aof，不执行磁盘同步
  

AOF的优缺点：
   ① 优点：
  

• 可以机动设置持久化方式
  
• 出现不测宕机时，仅大概丢失1秒的数据
  

  ② 缺点：
  

• 持久化文件的体积通常会大于RDB方式
  
• 执行fsync计谋时的速度大概会比RDB方式慢
  

  

设置AOF示例：

① 下令行方式设置（永久修改）

1. [root@redis7 ~]# redis-cli
2. 127.0.0.1:6379> CONFIG SET appendonly yes    //启用AOF
3. OK
4. 127.0.0.1:6379> CONFIG REWRITE
5. OK
6. 127.0.0.1:6379> SAVE
7. OK
8. 127.0.0.1:6379> exit

复制代码

② 查看AOF文件

1. [root@redis7 ~]# ls /var/lib/redis/6379/
2. appendonly.aof  dump.rdb
3. [root@redis7 ~]# cat /var/lib/redis/6379/appendonly.aof
4. *2
5. $6
6. SELECT
7. $1
8. 0
9. *3
10. $3
11. SET
12. $2
13. k1
14. $2
15. v1
16. *3
17. $3
18. ...

复制代码

增补：修改设置文件

1. [root@redis7 ~]# vim /etc/redis/6379.conf
2. appendonly yes
3. appendfilename “appendonly.aof"
4. appendfsync everysec

复制代码

验证备份还原
① 备份AOF文件

1. [root@redis7 ~]# cp /var/lib/redis/6379/appendonly.aof /root/

复制代码

② 模拟误删除数据

1. [root@redis7 ~]# redis-cli
2. 127.0.0.1:6379> KEYS *
3.  1) "k1"
4.  2) "k4"
5.  3) "k8"
6.  4) "k6"
7.  5) "k3"
8.  6) "k9"
9.  7) "k5"
10.  8) "k7"
11.  9) "k10"
12. 10) "k2"
13. 127.0.0.1:6379> FLUSHALL
14. OK
15. 127.0.0.1:6379> KEYS *
16. (empty list or set)

复制代码

③ 通过appendonly.aof备份的文件，规复数据

1. [root@redis7 ~]# service redis_6379 stop
2. Stopping ...
3. Redis stopped[root@redis7 ~]# rm -rf /var/lib/redis/6379/*[root@redis7 ~]# cp /root/appendonly.aof /var/lib/redis/6379/

复制代码

④ 启动服务并验证

1. [root@redis7 ~]# service redis_6379 start
2. Starting Redis server...[root@redis7 ~]# redis-cli127.0.0.1:6379> KEYS * 1) "k9" 2) "k5" 3) "k4" 4) "k2" 5) "k1" 6) "k7" 7) "k10" 8) "k8" 9) "k3"10) "k6"

复制代码

  RDB是将数据硬备份，而AOF是将追加记录文件的写利用在执行一遍，实现数据规复；
  
小结：

本篇章节为【第四阶段】NOSQL-DAY3 的学习条记，这篇条记可以初步相识到 redis主从复制、哨兵服务（高可用）、数据持久化（RDB、AOF）。除此之外保举参考相干学习网址：

• 参考：http://www.redis.cn/topics/sentinel.html
  
• 参考：Redis哨兵（Sentinel）模式 - 简书
  

---

Tip：究竟两个人的聪明大于一个人的聪明，假如你不明白本章节的内容或需要相干条记、视频，可私信小安，请不关键羞和回避，可以向他人请教，花点时间直到你真正的明白。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。