Redis学习笔记九（主从复制）

主从复制

主机数据更新后根据配置和策略，自动同步到备机的master/slaver机制，Master以写为主，Slave以读为主
存在复制延迟的缺点，主机的数据不一定能在挂掉前，完全复制到从机，从机过多，会加剧这一缺点

1. 实现读写分离
2. 容灾快速恢复（一台从服务器挂掉，可以切换到其他从服务器）
3. 一主多从（防主机挂掉，使用集群）

配置主从复制（一主两从为例）

1. 创建新的文件夹用来配置

root@LK:~# mkdir /myredis
root@LK:~# cd /myredis

2. 将redis.conf配置文件复制到新的文件夹下

root@LK:/myredis# cp /etc/redis.conf /myredis/redis.conf
root@LK:/myredis# ls
redis.conf

3. 配置一主两从，需要三个配置文件

   
   1. 创建redis6379.conf

   vi redis6379.conf

   2. 主要在文件中写入以下内容

   include /myredis/redis.conf
   pidfile /var/run/redis_6379.pid
   port 6379
   dbfilename dump6379.rdb

   3. 仿照上面的内容创建redis6380.conf、redis6381.conf，文件内容修改对应的数字即可
   4. 启动配置文件

   root@LK:/myredis# redis-server redis6379.conf
   root@LK:/myredis#  redis-server redis6380.conf
   root@LK:/myredis#  redis-server redis6381.conf
   root@LK:/myredis#  ps -ef|grep redis
   lk         57615    2002  0 21:15 ?        00:00:00 redis-server 127.0.0.1:6379
   lk         57623    2002  0 21:15 ?        00:00:00 redis-server 127.0.0.1:6380
   lk         57631    2002  0 21:15 ?        00:00:00 redis-server 127.0.0.1:6381
   lk         57668   57291  0 21:16 pts/0    00:00:00 grep --color=auto redis

   5. 查看当前redis的主从配置

   root@LK:/myredis# redis-cli -p 6379
   127.0.0.1:6379> info replication

   #结果
   # Replication
   #当前角色是主机
   role:master
   #没有从服务器
   connected_slaves:0
   master_failover_state:no-failover
   master_replid:98ff0d93dbe4c1492ff7f7f1ff6284dac86414dc
   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

   6. 修改主从配置(令6379为主机)
      在6380、6381从机上执行slaveof 主机ip 端口号

   slaveof 127.0.0.1 6379

   7. 查看6379的主从配置

   127.0.0.1:6379> info replication

   # Replication
   role:master
   #从服务器2个
   connected_slaves:2
   slave0:ip=127.0.0.1,port=6380,state=online,offset=0,lag=5
   slave1:ip=127.0.0.1,port=6381,state=online,offset=0,lag=5
   master_failover_state:no-failover
   master_replid:e003ed0236c8d42eaebef789c116a3f4091e2961
   master_replid2:0000000000000000000000000000000000000000
   master_repl_offset:112
   second_repl_offset:-1
   repl_backlog_active:1
   repl_backlog_size:1048576
   repl_backlog_first_byte_offset:1
   repl_backlog_histlen:112

4. 测试

   1. 在主服务进行写操作

   127.0.0.1:6379> set k1 v1
   OK
   127.0.0.1:6379> keys *
   1) "k1"

   2. 在从服务器上进行读操作

   127.0.0.1:6380> keys *
   1) "k1"

主从操作特点

主从复制原理

1. 从机连上主机之后，从机向主机发送进行数据同步消息
2. 主机接到消息后，把主机数据进行持久化为rdb文件，把rdb文件发送给从机，从机读取数据
3. 每次主机进行写操作之后，和从服务器同步数据

从属关系（主机一直是主机）

1. 从服务器在使用过程中挂掉，重启后需要重新配置从属关系，配置后仍可以同步主服务器的内容
2. 主服务器在使用中挂掉，重启后仍是主机，从机不会因为主机挂掉而丢失从属关系

薪火相传（从机后面还可以挂载从机）

1. 如果从机过多，为了降低主机负担，主机只对固定的几个从机进行数据传递，剩下的由从机一层层传递下去，类似与树的结构。
2. 传递过程中如果一个从机挂掉，则其下层的所有从机都不能完成同步。

反客为主（从机可以变成主机）

1. 主机挂掉，下层从机可以设置slaveof no one，变成主机
2. 缺点是不能自动完成配置，自动完成配置需要哨兵模式

哨兵模式

能够后台监视主机是否故障，如果故障根据投票数自动将从机转换为主机

1. 建立所有服务器的主从关系（具体步骤参照上面）
2. 在当前文件夹下加入sentinel.conf文件，名字不能错

root@LK:/myredis# vi sentinel.conf

3. 配置哨兵，填写内容

sentinel monitor mymaster 127.0.0.1 6379 1

mymaster为监控对象起的服务器别名，1表示为至少有1个哨兵同意迁移服务器
4. 启动哨兵/usr/local/bin/redis-sentinel

root@LK:/myredis# redis-sentinel sentinel.conf

66666:X 25 Jun 2022 00:39:56.063 * monotonic clock: POSIX clock_gettime
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 7.0.2 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                  
 (    '      ,       .-`  | `,    )     Running in sentinel mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 26379
 |    `-._   `._    /     _.-'    |     PID: 66666
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           https://redis.io       
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               
 
66666:X 25 Jun 2022 00:39:56.065 * Sentinel new configuration saved on disk
66666:X 25 Jun 2022 00:39:56.065 # Sentinel ID is d788eafe8daf0f8c748239fe6cb52e7e55b64d8a
66666:X 25 Jun 2022 00:39:56.065 # +monitor master mymaster 127.0.0.1 6379 quorum 1
66666:X 25 Jun 2022 00:39:56.066 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ mymaster 127.0.0.1 6379
66666:X 25 Jun 2022 00:39:56.068 * Sentinel new configuration saved on disk
66666:X 25 Jun 2022 00:39:56.068 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ mymaster 127.0.0.1 6379
66666:X 25 Jun 2022 00:39:56.069 * Sentinel new configuration saved on disk

5. 哨兵机制
   1. 如果主机挂掉，哨兵会根据选择条件选取从机作为新的主机，
   2. 此时原来主机的从机也会变成现在主机的从机
   3. 如果主机进一步重启，会直接作为新主机的从机
6. 哨兵选择条件
   1. 优先级靠前的（默认slave-priority 100,值越小，优先级越高,新版本replica-priority 100）
   2. 偏移量最大的（获得主机原数据最全的）
   3. runid最小的（redis实例启动后都会随机生成一个40位的runid）

jedis实现

private static JedisSentinelPool jedisSentinelPool=null;
 
public static  Jedis getJedisFromSentinel(){
	if(jedisSentinelPool==null){
		Set<String> sentinelSet=new HashSet<>();
		sentinelSet.add("127.0.0.1:26379");
 
		JedisPoolConfig jedisPoolConfig =new JedisPoolConfig();
		jedisPoolConfig.setMaxTotal(10); //最大可用连接数
		jedisPoolConfig.setMaxIdle(5); //最大闲置连接数
		jedisPoolConfig.setMinIdle(5); //最小闲置连接数
		jedisPoolConfig.setBlockWhenExhausted(true); //连接耗尽是否等待
		jedisPoolConfig.setMaxWaitMillis(2000); //等待时间
		jedisPoolConfig.setTestOnBorrow(true); //取连接的时候进行一下测试 ping pong
		jedisSentinelPool=new JedisSentinelPool("mymaster",sentinelSet,jedisPoolConfig);
		return jedisSentinelPool.getResource();
	}else{
		return jedisSentinelPool.getResource();
	}
}