一、主从复制

1、一主二仆

1、创建myredis文件夹
cd / 
mkdir myredis


3、复制redis.conf 到/myredis
cp /XXX/redis.conf  /myredis/redis.conf

3、修改/myredis/redis.conf
appendonly no

4、新建redis6379.conf (主)
vi redis6379.conf

填写以下内容
include /myredis/redis.conf
pidfile /var/run/redis_6379.pid
port 6379
dbfilename dump6379.rdb

5、新建redis6380.conf （从）
vi redis6380.conf

填写以下内容
include /myredis/redis.conf
pidfile /var/run/redis_6380.pid
port 6380
dbfilename dump6380.rdb

说明：原因是我在redis.conf文件中指定了自己的密码，在进行主从复制时，主机master会要求密码验证
☆☆☆☆☆#当master服务设置了密码保护时，slave服务连接master的密码
masterauth 123456

6、新建redis6381.conf （从）
vi redis6381.conf

填写以下内容
include /myredis/redis.conf
pidfile /var/run/redis_6381.pid
port 6381
dbfilename dump6381.rdb

说明：原因是我在redis.conf文件中指定了自己的密码，在进行主从复制时，主机master会要求密码验证
☆☆☆☆☆#当master服务设置了密码保护时，slave服务连接master的密码
masterauth 123456

slave-priority 10

设置从机的优先级，值越小，优先级越高，用于选举主机时使用。默认100

启动三台redis服务器

/XXX/redis-server /myredis/redis6379.conf
/XXX/redis-server /myredis/redis6380.conf
/XXX/redis-server /myredis/redis6381.conf

查看系统进程，看看三台服务器是否启动

查看三台主机运行情况

打印主从复制的相关信息

info replication

/XXX/reids-cli -p 6379 【-a password】

info replication

查看 6379

查看 6380

配从(库)不配主(库)

成为某个实例的从服务器
slaveof  <ip><port>

1、在6380和6381上执行: 
slaveof 127.0.0.1 6379

查看信息

6379

6380

6381

2、在主机上写，在从机上可以读取数据

在从机上写数据报错

3、主机挂掉，重启就行，一切如初（主机挂掉后，重启后继续作为主机，从机还在）

4、从机重启需重设：slaveof [ip] 6379 （从机重启后不会自动恢复成从机，需要执行命令）

从机重启后，不会同步数据，执行salveof 命令后会同步数据！！！

可以将配置增加到文件中。永久生效。

2、薪火相传

上一个Slave可以是下一个slave的Master，Slave同样可以接收其他slaves的连接和同步请求，那么该slave作为了链条中下一个的master, 可以有效减轻master的写压力,去中心化降低风险。

用slaveof <ip><port>

中途变更转向:会清除之前的数据，重新建立拷贝最新的

风险是一旦某个slave宕机，后面的slave都没法备份

主机挂了，从机还是从机，无法写数据了

3、反客为主

当一个master宕机后，后面的slave可以立刻升为master，其后面的slave不用做任何修改。

用slaveof no one 将从机变为主机。

二、哨兵模式

反客为主的自动版，能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库

1、调整为一主二仆模式，6379带着6380、6381

2、自定义的/myredis目录下新建sentinel.conf文件，名字绝不能错

cd /myredis
vi sentinel.conf

插入如下内容
#其中mymaster为监控对象起的服务器名称， 1 为至少有多少个哨兵同意迁移的数量。
sentinel monitor mymaster [ip] 6379 1

#配置sentinel.conf时，有密码要设置密码
sentinel auth-pass mymaster 123456

# 设置守护进程   后台启动，不设置也可以
daemonize yes

# 配置哨兵日志
logfile "/myredis/log/sentinel_log.log"

3、启动哨兵

redis做压测可以用自带的redis-benchmark工具

/XXX/redis-sentinel  /myredis/sentinel.conf 

4、停止主机，查看哨兵做出反应

当主机挂掉，从机选举中产生新的主机

(大概10秒左右可以看到哨兵窗口日志，切换了新的主机)

哪个从机会被选举为主机呢？根据优先级别：slave-priority

原主机重启后会变为从机。

注意：重启哨兵的时候需要重新修改相关配置

/myredis/*.conf

2.1 SpringBoot 整合哨兵模式

2.1.1 引入相关pom

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.73</version>
</dependency>

2.1.2 配置yml

## redis-sentinel
spring.redis.password=123456
spring.redis.sentinel.master=mymaster
spring.redis.sentinel.nodes=8.142.107.147:26379

注意：

1. 服务器端配置sentinel.conf 时和 配置从机使用slaveof ip 时使用具体的ip 而不要使用127.0.0.1，否则项目汇报错误连接不上
2. 每次重启哨兵时，需要重新检查相关配置文件，/myredis/*.conf
3. 根据情况看哨兵是否需要后台启动 daemonize yes
4. 如果使用后台启动，推荐配置日志目录 logfile "/myredis/log/sentinel_log.log"

2.1.3 配置redis配置文件

@Configuration
public class RedisConfig {
 
    @Bean
    public LettuceClientConfigurationBuilderCustomizer lettuceClientConfigurationBuilderCustomizer() {
        return builder -> builder.readFrom(ReadFrom.REPLICA_PREFERRED);
    }
 
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
 
        FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
        FastJsonConfig fastJsonConfig = fastJsonRedisSerializer.getFastJsonConfig();
        SerializerFeature[] serializerFeatures = new SerializerFeature[] {SerializerFeature.WriteDateUseDateFormat, SerializerFeature.WriteMapNullValue};
        fastJsonConfig.setSerializerFeatures(serializerFeatures);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
 
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        redisTemplate.setHashValueSerializer(fastJsonRedisSerializer);
        redisTemplate.setValueSerializer(fastJsonRedisSerializer);
        redisTemplate.setEnableTransactionSupport(true);
 
        redisTemplate.afterPropertiesSet();
 
        return redisTemplate;
    }
}

2.1.4 测试

@RestController
@RequestMapping("/redis")
public class TestController {

    private final StringRedisTemplate stringRedisTemplate;

    @Autowired
    public TestController(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @GetMapping("/set/{key}/{value}")
    public String setValue(@PathVariable("key") String key, @PathVariable("value") String value) {
        stringRedisTemplate.opsForValue().set(key, value);
        return key + " set value : " + value;
    }

    @GetMapping("/get/{key}")
    public String getValue(@PathVariable("key") String key) {
        String value = stringRedisTemplate.opsForValue().get(key);
        return key + " get value : " + value;
    }
}