1、主从复制

1、什么是主从复制

  1. redis的复制功能是支持多个数据库之间的数据同步。一类是主数据库（master）一类是从数据库（slave），主数据库可以进行读写操作，当发生写操作的时候自动将数据同步到从数据库，而从数据库一般是只读的，并接收主数据库同步过来的数据，一个主数据库可以有多个从数据库，而一个从数据库只能有一个主数据库。
  2. 通过redis的复制功能可以很好的实现数据库的读写分离，提高服务器的负载能力。主数据库主要进行写操作，而从数据库负责读操作。

linux redis 双主配置 redis双主模式_redis


主从复制，读写分离，大部分情况下都是在进行读操作，减缓服务器的压力，架构中经常使用，一主二从（至少3台服务器）

2、举个栗子

1、共打开4台机器，3台做主从复制，1台测试

linux redis 双主配置 redis双主模式_主从复制_02

2、复制3个 redis.conf 配置文件

[root@iZ2ze5v2vdwv6veyksylhxZ bin]# cd muzhen_config
[root@iZ2ze5v2vdwv6veyksylhxZ muzhen_config]# ls
redis79.conf  redis80.conf  redis81.conf  redis.conf
[root@iZ2ze5v2vdwv6veyksylhxZ muzhen_config]# cp redis.conf redis79.conf   #复制 redis.conf 文件
[root@iZ2ze5v2vdwv6veyksylhxZ muzhen_config]# cp redis.conf redis80.conf
[root@iZ2ze5v2vdwv6veyksylhxZ muzhen_config]# cp redis.conf redis81.conf
[root@iZ2ze5v2vdwv6veyksylhxZ muzhen_config]# ls
redis79.conf  redis80.conf  redis81.conf  redis.conf
[root@iZ2ze5v2vdwv6veyksylhxZ muzhen_config]#

3、修改 con.conf 配置文件

#端口号
port 6380

#pid名字
pidfile /var/run/redis_6380.pid

#日志文件名字
logfile "6380.log"

#dump.rdb名字
dbfilename dump6380.rdb

4、启动3个机器

redis-server muzhen_config/redis79.conf   #启动redis
[root@iZ2ze5v2vdwv6veyksylhxZ bin]# redis-cli -p 6379   #连接客户端
127.0.0.1:6379> ping
PONG    #连接成功
127.0.0.1:6379> 

redis-server muzhen_config/redis80.conf 
[root@iZ2ze5v2vdwv6veyksylhxZ bin]# redis-cli -p 6380
127.0.0.1:6380> ping
PONG
127.0.0.1:6380> 

redis-server muzhen_config/redis81.conf 
[root@iZ2ze5v2vdwv6veyksylhxZ bin]# redis-cli -p 6381
127.0.0.1:6381> ping
PONG
127.0.0.1:6381>

5、查看3台机器均为主机，以端口号为6379的机器为例 

[root@iZ2ze5v2vdwv6veyksylhxZ bin]# redis-server muzhen_config/redis.conf 
[root@iZ2ze5v2vdwv6veyksylhxZ bin]# redis-cli -p 6379
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> info replication   #查看当前库信息
# Replication
role:master  #角色：主机
connected_slaves:0  #从机 0个
master_replid:d1766f1175c91bbcf828bfcfe634d1b7df4c2cd7
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0
127.0.0.1:6379>

6、查看redis进程，都已启动

[root@iZ2ze5v2vdwv6veyksylhxZ ~]# ps -ef | grep redis
root      1459     1  0 16:44 ?        00:00:00 redis-server 127.0.0.1:6379
root      1466     1  0 16:44 ?        00:00:00 redis-server 127.0.0.1:6380
root      1472     1  0 16:44 ?        00:00:00 redis-server 127.0.0.1:6381
root      1478  1408  0 16:45 pts/3    00:00:00 grep --color=auto redis

3、 一主二从

默认情况下，每台Redis服务器都是主节点（默认都是主机，从机需要设置）

类似 认大哥，一主（79）二从（80,81）

#在从机80进行配置
127.0.0.1:6380> slaveof 127.0.0.1 6379   #slaveof host port，找谁当自己的老大
OK
127.0.0.1:6380> info replication
# Replication
role:slave  #角色：从机
master_host:127.0.0.1   #主机
master_port:6379   #主机端口号
master_link_status:up
master_last_io_seconds_ago:6
master_sync_in_progress:0
slave_repl_offset:14
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:6b7e719860ff170eb592f702b9e7d0cee2a30d5c
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:14
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:14
127.0.0.1:6380> 

#在主机中查看
127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:1   #多了从机的配置
slave0:ip=127.0.0.1,port=6380,state=online,offset=434,lag=1
master_replid:6b7e719860ff170eb592f702b9e7d0cee2a30d5c
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:434
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:434
127.0.0.1:6379> 

#从机8081配置如上

真实的主从配置应该在配置文件中配置，这样的话是永久的，使用命令配置是暂时的

linux redis 双主配置 redis双主模式_主从复制_03

案例演示

主机可以写，从机不能写，只能读，主机中的所有信息和数据，都会自动被从机保存

1、主机写好数据

127.0.0.1:6379> keys *
(empty array)
127.0.0.1:6379> set k1 v1  #主机可以写数据
OK
127.0.0.1:6379>

2、从机读取数据

127.0.0.1:6380> keys *   #主机写数据之前，从机查看键值
(empty array)
127.0.0.1:6380> keys *   #主机写数据之后，从机查看键值，可以查到
1) "k1"
127.0.0.1:6380> get k1
"v1"
127.0.0.1:6380> set k2 v2  #从机写数据，报错 提示只能读数据
(error) READONLY You can't write against a read only replica.
127.0.0.1:6380>

3、如果老大主机没了，shutdown，exit，从机状态依然不变，想变成主机只能手动配置

#主机停机
127.0.0.1:6379> shutdown 
not connected> exit

4、从机查看，状态不变

127.0.0.1:6380> info replication
# Replication
role:slave   #角色：从机
master_host:127.0.0.1
master_port:6379
master_link_status:down
master_last_io_seconds_ago:-1
master_sync_in_progress:0
slave_repl_offset:2446
master_link_down_since_seconds:49
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:6b7e719860ff170eb592f702b9e7d0cee2a30d5c
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:2446
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:2446
127.0.0.1:6380>

5、如果老大主机又回来了，再次启动了主机，而且设置新键值，从机依然可以读取到

#主机启动
[root@iZ2ze5v2vdwv6veyksylhxZ bin]# redis-server muzhen_config/redis79.conf 
[root@iZ2ze5v2vdwv6veyksylhxZ bin]# redis-cli -p 6379
127.0.0.1:6379> set k3 v3   #主机启动后再次设置新键值
OK

#从机查看，依然可以获得数据
127.0.0.1:6380> get k3
"v3"

6、如果从机80突然宕机，关掉了

#从机80，关掉
127.0.0.1:6380> shutdown
not connected> exit

7、通过进程查看，80端口关掉了

[root@iZ2ze5v2vdwv6veyksylhxZ muzhen_config]# ps -ef | grep redis
root      1472     1  0 16:44 ?        00:00:01 redis-server 127.0.0.1:6381
root      1487  1387  0 16:50 pts/2    00:00:00 redis-cli -p 6381
root      1567     1  0 17:26 ?        00:00:00 redis-server 127.0.0.1:6379
root      1574  1158  0 17:26 pts/0    00:00:00 redis-cli -p 6379
root      1593  1408  0 17:31 pts/3    00:00:00 grep --color=auto redis

8、主机查看，从机已经只剩下一个了

127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:1  #从机只剩下一个了
slave0:ip=127.0.0.1,port=6381,state=online,offset=668,lag=0  #只剩下了从机81
master_replid:3fe4839cced66622954988e873356bddadca8393
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:668
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:668
127.0.0.1:6379>

9、如果是使用命令行配置的主从，如果重启了从机，从机就会变回主机

[root@iZ2ze5v2vdwv6veyksylhxZ bin]# redis-server muzhen_config/redis80.conf 
[root@iZ2ze5v2vdwv6veyksylhxZ bin]# redis-cli -p 6379
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> info replication
# Replication
role:master    #角色：从机已经变回了主机
connected_slaves:1
slave0:ip=127.0.0.1,port=6381,state=online,offset=1018,lag=1
master_replid:3fe4839cced66622954988e873356bddadca8393
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:1018
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:1018
127.0.0.1:6379>

10、如果从机重启之后，变成了主机角色，没有手动设置为从机，当主机写了新的数据，然后从机才将主机角色再次设置成从机，依然可以获取新的数据

#主机写入新数据
127.0.0.1:6379> set k4 v4
OK

#从机角色从主机，手动再次设置为从机后
127.0.0.1:6379> SLAVEOF 127.0.0.1 6379
OK
127.0.0.1:6379> get k4
"v4"
127.0.0.1:6379>

复制原理

  • Slave启动成功连接到maser后会发送一个sync同步命令
  • Master接到命令，启动后台的存盘进程，同时收集所有接收到的用于修改数据集命令，在后台进程执行完毕之后，master将传送整个数据文件到slave，并完成一次完全同步。
  • 全量复制：而slave服务在接收到数据库文件数据后，将其存盘并加载到内存中
  • 增量复制：Master继续将新的所有收集到的修改命令依次传给slave，完成同步
  • 但是只要是重新连接master，一次完全同步（全量复制）将被自动执行，我们的数据一定可以在从机上看到

4、 层层链路

主从复制有多种模式，可以 1对多，也可像火车一样，一个传一个，例如 ：主机79—连接—80从机—连接—81从机

案例演示：

1、操作端口号为81的从机，将其主机从79修改为80，换老大了

127.0.0.1:6381> SLAVEOF 127.0.0.1 6380     #将主机设置为6380
OK
127.0.0.1:6381> info replication  #查看主从复制信息
# Replication
role:slave  #角色：从机
master_host:127.0.0.1
master_port:6380   #主机的端口号已经发生改变
master_link_status:up
master_last_io_seconds_ago:8
master_sync_in_progress:0
slave_repl_offset:0
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:71edae81b9c7a64e15a448d6a1eb1f2b26dfdb4d
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:0
127.0.0.1:6381>

2、79主机查看主从复制信息，查看剩余所属从机

127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:1   #从机只剩下一个了，从机端口是6380
slave0:ip=127.0.0.1,port=6380,state=online,offset=14,lag=0
master_replid:613fa27016e4f3a2d8fc02394e783fe2bda5ceeb
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:14
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:14
127.0.0.1:6379>

3、80主机查看主从复制信息，80依然是从机，从机只能读数据，不能写数据

127.0.0.1:6380> info replication
# Replication
role:slave   #80依然是从机
master_host:127.0.0.1
master_port:6379
master_link_status:up
master_last_io_seconds_ago:2
master_sync_in_progress:0
slave_repl_offset:168
slave_priority:100
slave_read_only:1
connected_slaves:1
slave0:ip=127.0.0.1,port=6381,state=online,offset=168,lag=0
master_replid:613fa27016e4f3a2d8fc02394e783fe2bda5ceeb
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:168
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:168
127.0.0.1:6380>

4、主机79写入新数据，查看从机是否可以正常接收到

127.0.0.1:6379> set k5 v5
OK

5、端口号为80和81的从机依然可以读取到数据

127.0.0.1:6380> get k5
"v5"

5、 问题：如果没有老大了，这个时候能不能选择一个老大出来呢？答案只能 手动

#老大主机挂了，从机依然状态是从机
127.0.0.1:6379> shutdown
not connected> exit

127.0.0.1:6380> info replication
# Replication
role:slave    #从机依然角色是小弟
master_host:127.0.0.1  #大哥即使挂了，小弟依然认大哥，不篡权
master_port:6379
master_link_status:down
master_last_io_seconds_ago:-1
master_sync_in_progress:0
slave_repl_offset:1200
master_link_down_since_seconds:87
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:613fa27016e4f3a2d8fc02394e783fe2bda5ceeb
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:1200
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:1200
127.0.0.1:6380>

那如果有的小弟想当老大，要莫权篡位 SLAVEOF no one

127.0.0.1:6380> SLAVEOF no one   #执行篡权命令后，自己就成了老大了
OK
127.0.0.1:6380> info replication
# Replication
role:master  #角色已经由从机变为主机，小老弟成大哥了
connected_slaves:1   #自己也有了小弟，端口号是81从机
slave0:ip=127.0.0.1,port=6381,state=online,offset=1214,lag=1
master_replid:780a11570a1a6dd0c34472566d5bc2c53e2263c3
master_replid2:613fa27016e4f3a2d8fc02394e783fe2bda5ceeb
master_repl_offset:1214
second_repl_offset:1201
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:1214
127.0.0.1:6380>

小结：

如果主机断开了连接，我们就可以使用 SLAVEOF no one 让自己变成主机，其他的节点就可以手动连接到最新的这个主节点（手动），如果这个时候老大又修复了，那就重新连接

2、哨兵模式

（自动选举老大的模式）

什么是烧饼模式？

  • 主从切换技术的方法是：当主服务器宕机后，需要手动把一台从机服务器切换为主服务器，这就需要人工干预，费时费力，还会造成一段时间内服务不可用，这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式。Redis从2.8开始正式提供了Sentinel（哨兵）架构来解决这个问题。
  • 谋朝篡位的自动版，能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库。
  • 哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行，其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。

linux redis 双主配置 redis双主模式_数据_04


进入 cd/usr/local/bin目录下面

linux redis 双主配置 redis双主模式_linux redis 双主配置_05


这里的哨兵有两个作用：

1、通过发送命令，让Redis服务器返回监控其运行状态，包括主服务器和从服务器

2、当哨兵检测到master宕机，会自动将slave切换成master，然后通过 发布订阅模式 通知其他的从机服务器，修改配置文件，让她们切换主机

然而一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监控，这样就形成了多哨兵模式

linux redis 双主配置 redis双主模式_主从复制_06


假如主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行 failover（故障切换） 过程，仅仅是哨兵1主观的认为服务器不可用，这个现象称为主观下线。当后面的哨兵也检测到主服务器不可用，并且数量达到一定值时，那么哨兵之间就会进行一次投票，投票的结果是由一个哨兵发起，进行 failover操作，切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程称为客观下线。

1、 举个栗子，我们目前状态是 一主二从

1、配置哨兵配置文件 sentinel.conf

# 数字1：代表主机宕机，从机投票，谁票数多就会自动成为主机
#哨兵 监控 被监控的名称 主机host 端口号port
sentinel monitor myredis 127.0.0.1 6379 1 #写入sentinel.conf文件内

[root@iZ2ze5v2vdwv6veyksylhxZ muzhen_config]# vim sentinel.conf
[root@iZ2ze5v2vdwv6veyksylhxZ muzhen_config]# ls
redis79.conf  redis80.conf  redis81.conf  redis.conf  sentinel.conf
[root@iZ2ze5v2vdwv6veyksylhxZ muzhen_config]#

2、启动哨兵

[root@iZ2ze5v2vdwv6veyksylhxZ bin]# ls
6379,log        chardetect      dump6379.rdb  easy_install      jsonpatch      pcre-config      redis-check-aof  redis-server
6380.log        cloud-id        dump6380.rdb  easy_install-3.6  jsonpointer    pcregrep         redis-check-rdb
6381.log        cloud-init      dump6381.rdb  easy_install-3.8  jsonschema     pcretest         redis-cli
appendonly.aof  cloud-init-per  dump.rdb      jsondiff          muzhen_config  redis-benchmark  redis-sentinel
[root@iZ2ze5v2vdwv6veyksylhxZ bin]# redis-sentinel muzhen_config/sentinel.conf 
1743:X 07 Jan 2021 19:17:20.965 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
1743:X 07 Jan 2021 19:17:20.965 # Redis version=6.0.9, bits=64, commit=00000000, modified=0, pid=1743, just started
1743:X 07 Jan 2021 19:17:20.965 # Configuration loaded
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 6.0.9 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in sentinel mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 26379
 |    `-._   `._    /     _.-'    |     PID: 1743
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

1743:X 07 Jan 2021 19:17:20.966 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
1743:X 07 Jan 2021 19:17:20.969 # Sentinel ID is 1f38f33ef59194d1f635122bfe407ec0f23e733a
1743:X 07 Jan 2021 19:17:20.969 # +monitor master myredis 127.0.0.1 6379 quorum 1
1743:X 07 Jan 2021 19:17:20.970 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
1743:X 07 Jan 2021 19:17:20.973 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379

3、关掉主机，查看到两个从机 80 和 81 依然是 从机角色，稍等一会，哨兵需要时间检测，再次查看从机就会发现其中有一个成为主机了

#主机挂掉
127.0.0.1:6379> shutdown
not connected> exit

#查看从机
127.0.0.1:6380> info replication
# Replication
role:master   #端口号为80的从机，现在角色变成了主机
connected_slaves:1
slave0:ip=127.0.0.1,port=6381,state=online,offset=26898,lag=0
master_replid:2f2e8e511237032a779ff78e4debc0defd53033e
master_replid2:18de7b9d37960d45bcc669a853d9b97cf8f02421
master_repl_offset:26898
second_repl_offset:26202
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:26898
127.0.0.1:6380>

4、哨兵日志

1743:X 07 Jan 2021 19:23:37.880 # +sdown master myredis 127.0.0.1 6379
1743:X 07 Jan 2021 19:23:37.880 # +odown master myredis 127.0.0.1 6379 #quorum 1/1
1743:X 07 Jan 2021 19:23:37.880 # +new-epoch 1
1743:X 07 Jan 2021 19:23:37.880 # +try-failover master myredis 127.0.0.1 6379
1743:X 07 Jan 2021 19:23:37.883 # +vote-for-leader 1f38f33ef59194d1f635122bfe407ec0f23e733a 1
1743:X 07 Jan 2021 19:23:37.883 # +elected-leader master myredis 127.0.0.1 6379
1743:X 07 Jan 2021 19:23:37.883 # +failover-state-select-slave master myredis 127.0.0.1 6379
1743:X 07 Jan 2021 19:23:37.946 # +selected-slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
1743:X 07 Jan 2021 19:23:37.946 * +failover-state-send-slaveof-noone slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
1743:X 07 Jan 2021 19:23:38.012 * +failover-state-wait-promotion slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
1743:X 07 Jan 2021 19:23:38.386 # +promoted-slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
1743:X 07 Jan 2021 19:23:38.386 # +failover-state-reconf-slaves master myredis 127.0.0.1 6379
1743:X 07 Jan 2021 19:23:38.444 * +slave-reconf-sent slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
1743:X 07 Jan 2021 19:23:39.392 * +slave-reconf-inprog slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
1743:X 07 Jan 2021 19:23:40.415 * +slave-reconf-done slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
1743:X 07 Jan 2021 19:23:40.481 # +failover-end master myredis 127.0.0.1 6379
1743:X 07 Jan 2021 19:23:40.482 # +switch-master myredis 127.0.0.1 6379 127.0.0.1 6380
1743:X 07 Jan 2021 19:23:40.482 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6380
1743:X 07 Jan 2021 19:23:40.482 * +slave slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis 127.0.0.1 6380
1743:X 07 Jan 2021 19:24:10.514 # +sdown slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis 127.0.0.1 6380

5、如果主机又开启了，老大的位置已经有人了，只能当新老大的小弟从机了

#原主机6379再次启动
[root@iZ2ze5v2vdwv6veyksylhxZ bin]# redis-server muzhen_config/redis79.conf 
[root@iZ2ze5v2vdwv6veyksylhxZ bin]# redis-cli -p 6379
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> info replication
# Replication
role:slave   #角色由master 变成 slave 了
master_host:127.0.0.1 
master_port:6380       #主机已经是6380了
master_link_status:up
master_last_io_seconds_ago:0
master_sync_in_progress:0
slave_repl_offset:63463
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:2f2e8e511237032a779ff78e4debc0defd53033e
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:63463
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:61023
repl_backlog_histlen:2441
127.0.0.1:6379>

6、6380原从机，查看主从复制信息

127.0.0.1:6380> info replication
# Replication
role:master    #小老弟成大哥了，从机变成主机了
connected_slaves:2  #手下也多了两个小老弟，端口号分别为 6379（原来的老大），和6381
slave0:ip=127.0.0.1,port=6381,state=online,offset=61719,lag=0
slave1:ip=127.0.0.1,port=6379,state=online,offset=61719,lag=0
master_replid:2f2e8e511237032a779ff78e4debc0defd53033e
master_replid2:18de7b9d37960d45bcc669a853d9b97cf8f02421
master_repl_offset:61719
second_repl_offset:26202
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:61719
127.0.0.1:6380>

小结

优点：

  1. 哨兵集群，基于主从复制模式，所有的主从配置优点，它都有
  2. 主从可以切换，故障可以转移，系统的可用性就会更好
  3. 哨兵模式就是主从模式的升级，手动到自动，更加健壮

缺点：

  1. Redis不好在线扩容，集群容量一旦到达上限，在线扩容就十分麻烦
  2. 实现哨兵模式的配置其实时很麻烦，里面有很多选择

哨兵模式的全部配置

# 端口
port 26379

# 是否后台启动
daemonize yes

# pid文件路径
pidfile /var/run/redis-sentinel.pid

# 日志文件路径
logfile "/var/log/sentinel.log"

# 定义工作目录
dir /tmp

# 定义Redis主的别名, IP, 端口，这里的2指的是需要至少2个Sentinel认为主Redis挂了才最终会采取下一步行为
sentinel monitor mymaster 127.0.0.1 6379 2

# 如果mymaster 30秒内没有响应，则认为其主观失效
sentinel down-after-milliseconds mymaster 30000

# 如果master重新选出来后，其它slave节点能同时并行从新master同步数据的台数有多少个，显然该值越大，所有slave节点完成同步切换的整体速度越快，但如果此时正好有人在访问这些slave，可能造成读取失败，影响面会更广。最保守的设置为1，同一时间，只能有一台干这件事，这样其它slave还能继续服务，但是所有slave全部完成缓存更新同步的进程将变慢。
sentinel parallel-syncs mymaster 1

# 该参数指定一个时间段，在该时间段内没有实现故障转移成功，则会再一次发起故障转移的操作，单位毫秒
sentinel failover-timeout mymaster 180000

# 不允许使用SENTINEL SET设置notification-script和client-reconfig-script。
sentinel deny-scripts-reconfig yes