Redis高可用架构：主从复制、哨兵、集群

# 1台Master + 2台Slave
Master: 127.0.0.1:6379
Slave1: 127.0.0.1:6380
Slave2: 127.0.0.1:6381

# 端口
port 6379

# 绑定IP（0.0.0.0允许所有IP访问）
bind 0.0.0.0

# 后台运行
daemonize yes

# 日志文件
logfile "redis-6379.log"

# 数据目录
dir /var/redis/6379

# RDB持久化
save 900 1
save 300 10
save 60 10000

# AOF持久化
appendonly yes
appendfilename "appendonly-6379.aof"

# 密码（可选）
requirepass mypassword

# 端口
port 6380

# 绑定IP
bind 0.0.0.0

# 后台运行
daemonize yes

# 日志文件
logfile "redis-6380.log"

# 数据目录
dir /var/redis/6380

# ========== 主从复制配置 ==========

# 指定Master（Redis 5.0之前使用slaveof）
replicaof 127.0.0.1 6379

# Master密码（如果Master设置了密码）
masterauth mypassword

# Slave只读（默认yes）
replica-read-only yes

# Slave优先级（数字越小优先级越高，用于故障转移）
replica-priority 100

# 启动Master
redis-server /path/to/redis-6379.conf

# 启动Slave1
redis-server /path/to/redis-6380.conf

# 启动Slave2
redis-server /path/to/redis-6381.conf

# 查看主从状态
redis-cli -p 6379 INFO replication

# 在Master写入数据
127.0.0.1:6379> SET mykey "Hello Redis"
OK

# 在Slave读取数据
127.0.0.1:6380> GET mykey
"Hello Redis"  # 数据已同步

# Slave无法写入
127.0.0.1:6380> SET newkey "value"
(error) READONLY You can't write against a read only replica.

# redis.conf
# 默认1MB，建议根据业务调整
repl-backlog-size 1mb

# 如何计算合适的大小？
# 复制积压缓冲区大小 = 平均写入速度 × 平均断开时间

# 示例：
# 平均写入速度：1MB/秒
# 平均断开时间：60秒（网络抖动）
# 建议大小：1MB/s × 60s = 60MB

repl-backlog-size 64mb

@Service
public class ProductService {

    @Autowired
    @Qualifier("masterRedisTemplate")
    private RedisTemplate<String, ProductVO> masterRedis;  // 写Master

    @Autowired
    @Qualifier("slaveRedisTemplate")
    private RedisTemplate<String, ProductVO> slaveRedis;   // 读Slave

    /**
     * 获取商品详情（从Slave读）
     */
    public ProductVO getProduct(Long productId) {
        String cacheKey = "product:detail:" + productId;

        // 从Slave读取
        ProductVO cached = slaveRedis.opsForValue().get(cacheKey);
        if (cached != null) {
            return cached;
        }

        // 缓存未命中，查数据库
        Product product = productRepository.findById(productId);
        if (product == null) {
            return null;
        }

        ProductVO vo = convertToVO(product);

        // 写入Master（会自动同步到Slave）
        masterRedis.opsForValue().set(cacheKey, vo, 30, TimeUnit.MINUTES);

        return vo;
    }

    /**
     * 更新商品（写Master）
     */
    @Transactional
    public void updateProduct(Product product) {
        // 1. 更新数据库
        productRepository.update(product);

        // 2. 删除Master缓存（会自动同步到Slave）
        String cacheKey = "product:detail:" + product.getId();
        masterRedis.delete(cacheKey);
    }
}

@Configuration
public class RedisConfig {

    /**
     * Master Redis配置
     */
    @Bean("masterRedisTemplate")
    public RedisTemplate<String, Object> masterRedisTemplate() {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setHostName("127.0.0.1");
        config.setPort(6379);
        config.setPassword(RedisPassword.of("mypassword"));

        LettuceConnectionFactory factory = new LettuceConnectionFactory(config);
        factory.afterPropertiesSet();

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.afterPropertiesSet();

        return template;
    }

    /**
     * Slave Redis配置（读取）
     */
    @Bean("slaveRedisTemplate")
    public RedisTemplate<String, Object> slaveRedisTemplate() {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setHostName("127.0.0.1");
        config.setPort(6380);  // Slave端口
        config.setPassword(RedisPassword.of("mypassword"));

        LettuceConnectionFactory factory = new LettuceConnectionFactory(config);
        factory.afterPropertiesSet();

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.afterPropertiesSet();

        return template;
    }
}

# 1个Master + 2个Slave + 3个Sentinel
Master:    127.0.0.1:6379
Slave1:    127.0.0.1:6380
Slave2:    127.0.0.1:6381
Sentinel1: 127.0.0.1:26379
Sentinel2: 127.0.0.1:26380
Sentinel3: 127.0.0.1:26381

# 端口
port 26379

# 后台运行
daemonize yes

# 日志文件
logfile "sentinel-26379.log"

# 工作目录
dir /var/redis/sentinel

# ========== 监控配置 ==========

# 监控Master（mymaster是自定义名称）
# sentinel monitor <master-name> <ip> <port> <quorum>
# quorum：判断Master客观下线需要的Sentinel数量
sentinel monitor mymaster 127.0.0.1 6379 2

# Master密码
sentinel auth-pass mymaster mypassword

# Master被判定为主观下线的时间（30秒内没有回应）
sentinel down-after-milliseconds mymaster 30000

# 故障转移超时时间（3分钟）
sentinel failover-timeout mymaster 180000

# 并行同步Slave数量（1个Slave完成后再同步下一个）
sentinel parallel-syncs mymaster 1

# quorum参数详解
sentinel monitor mymaster 127.0.0.1 6379 2

quorum = 2 表示：
- 至少2个Sentinel认为Master主观下线
- 才判定Master客观下线
- 然后触发故障转移

假设有3个Sentinel：
- quorum = 2：允许1个Sentinel宕机
- quorum = 3：不允许Sentinel宕机（太严格）
- 推荐：quorum = Sentinel总数 / 2 + 1（过半数）

# down-after-milliseconds参数
sentinel down-after-milliseconds mymaster 30000

含义：
- Sentinel每10秒ping一次Master
- 如果30秒内没有回应，判定为主观下线
- 建议：30秒（太短容易误判，太长恢复慢）

# parallel-syncs参数
sentinel parallel-syncs mymaster 1

含义：
- 故障转移后，同时同步几个Slave
- 1：一个一个同步（慢但稳）
- 2：两个同时同步（快但压力大）
- 推荐：1（避免Master压力过大）

# 启动Sentinel1
redis-sentinel /path/to/sentinel-26379.conf

# 启动Sentinel2
redis-sentinel /path/to/sentinel-26380.conf

# 启动Sentinel3
redis-sentinel /path/to/sentinel-26381.conf

# 查看Sentinel状态
redis-cli -p 26379 SENTINEL masters
redis-cli -p 26379 SENTINEL slaves mymaster
redis-cli -p 26379 SENTINEL sentinels mymaster

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

spring:
  redis:
    # 不再直接连接Master，而是连接Sentinel
    sentinel:
      master: mymaster  # Master名称（与sentinel.conf中的一致）
      nodes:
        - 127.0.0.1:26379
        - 127.0.0.1:26380
        - 127.0.0.1:26381
    password: mypassword
    database: 0
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: -1ms

@SpringBootTest
public class SentinelTest {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Test
    public void testSentinelFailover() throws InterruptedException {
        // 循环写入数据，观察故障转移
        for (int i = 0; i < 100; i++) {
            try {
                String key = "test:key:" + i;
                String value = "value:" + i;

                redisTemplate.opsForValue().set(key, value, 60, TimeUnit.SECONDS);
                System.out.println("写入成功：" + key);

                Thread.sleep(1000);  // 每秒写一次

            } catch (Exception e) {
                System.err.println("写入失败：" + e.getMessage());
                // 客户端会自动重连新Master
            }
        }
    }
}

# 1. 启动测试程序（循环写入数据）
mvn test

# 2. 手动kill Master进程
redis-cli -p 6379 SHUTDOWN

# 3. 观察日志
# 约30秒后，Sentinel会自动故障转移
# 客户端自动连接新Master，写入恢复

# 4. 查看新Master
redis-cli -p 26379 SENTINEL get-master-addr-by-name mymaster
# 输出：127.0.0.1 6380（新Master）

# 3个Master + 3个Slave
Master1: 127.0.0.1:7000  →  Slave1: 127.0.0.1:7003
Master2: 127.0.0.1:7001  →  Slave2: 127.0.0.1:7004
Master3: 127.0.0.1:7002  →  Slave3: 127.0.0.1:7005

# 端口
port 7000

# 绑定IP
bind 0.0.0.0

# 后台运行
daemonize yes

# 日志文件
logfile "redis-7000.log"

# 数据目录
dir /var/redis/7000

# ========== 集群配置 ==========

# 启用集群模式
cluster-enabled yes

# 集群配置文件（自动生成）
cluster-config-file nodes-7000.conf

# 节点超时时间（15秒）
cluster-node-timeout 15000

# 启用AOF
appendonly yes

# Redis 5.0+使用redis-cli创建集群
redis-cli --cluster create \
  127.0.0.1:7000 \
  127.0.0.1:7001 \
  127.0.0.1:7002 \
  127.0.0.1:7003 \
  127.0.0.1:7004 \
  127.0.0.1:7005 \
  --cluster-replicas 1  # 每个Master配1个Slave

# 输出：
>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 127.0.0.1:7004 to 127.0.0.1:7000
Adding replica 127.0.0.1:7005 to 127.0.0.1:7001
Adding replica 127.0.0.1:7003 to 127.0.0.1:7002

# 确认创建
Can I set the above configuration? (type 'yes' to accept): yes

# 集群创建成功！

# 连接集群（-c参数表示集群模式）
redis-cli -c -p 7000

# 查看集群信息
127.0.0.1:7000> CLUSTER INFO
cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_known_nodes:6
cluster_size:3

# 查看集群节点
127.0.0.1:7000> CLUSTER NODES
abc123... 127.0.0.1:7000@17000 myself,master - 0 0 1 connected 0-5460
def456... 127.0.0.1:7001@17001 master - 0 1635000000 2 connected 5461-10922
ghi789... 127.0.0.1:7002@17002 master - 0 1635000000 3 connected 10923-16383
jkl012... 127.0.0.1:7003@17003 slave ghi789... 0 1635000000 3 connected
mno345... 127.0.0.1:7004@17004 slave abc123... 0 1635000000 1 connected
pqr678... 127.0.0.1:7005@17005 slave def456... 0 1635000000 2 connected

# 测试数据写入
127.0.0.1:7000> SET user:123 "Alice"
-> Redirected to slot [12345] located at 127.0.0.1:7002
OK

# 客户端自动重定向到正确的节点（7002）

# 1. 启动新节点
redis-server /path/to/redis-7006.conf
redis-server /path/to/redis-7007.conf

# 2. 将新节点加入集群（作为Master）
redis-cli --cluster add-node 127.0.0.1:7006 127.0.0.1:7000

# 3. 分配槽位给新节点（从其他Master分一些槽位过来）
redis-cli --cluster reshard 127.0.0.1:7000
# 输入要迁移的槽位数量：5461
# 输入目标节点ID（7006的ID）
# 输入源节点ID（all表示从所有Master平均分配）

# 4. 给新Master添加Slave
redis-cli --cluster add-node 127.0.0.1:7007 127.0.0.1:7000 --cluster-slave --cluster-master-id <7006的ID>

# 扩容完成！
# 原来：3个Master，每个5461个槽
# 现在：4个Master，每个4096个槽

# 1. 将要删除节点的槽位迁移到其他节点
redis-cli --cluster reshard 127.0.0.1:7000 \
  --cluster-from <要删除节点的ID> \
  --cluster-to <目标节点的ID> \
  --cluster-slots 5461  # 迁移全部槽位

# 2. 删除Slave节点
redis-cli --cluster del-node 127.0.0.1:7000 <Slave节点ID>

# 3. 删除Master节点（槽位必须为0）
redis-cli --cluster del-node 127.0.0.1:7000 <Master节点ID>

# 缩容完成！

spring:
  redis:
    cluster:
      nodes:
        - 127.0.0.1:7000
        - 127.0.0.1:7001
        - 127.0.0.1:7002
        - 127.0.0.1:7003
        - 127.0.0.1:7004
        - 127.0.0.1:7005
      max-redirects: 3  # 最大重定向次数
    password: mypassword
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0

@SpringBootTest
public class ClusterTest {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Test
    public void testCluster() {
        // 写入10000个key，观察数据分布
        for (int i = 0; i < 10000; i++) {
            String key = "test:key:" + i;
            String value = "value:" + i;
            redisTemplate.opsForValue().set(key, value);
        }

        System.out.println("写入完成！");

        // 读取数据，客户端会自动路由到正确的节点
        String value = redisTemplate.opsForValue().get("test:key:123");
        System.out.println("test:key:123 = " + value);
    }
}

# 统计每个节点的key数量
redis-cli -c -p 7000 DBSIZE  # Master1
redis-cli -c -p 7001 DBSIZE  # Master2
redis-cli -c -p 7002 DBSIZE  # Master3

# 输出示例：
# Master1: 3333 keys
# Master2: 3334 keys
# Master3: 3333 keys

# 数据均匀分布！

# redis.conf

# 1. 最大内存
maxmemory 4gb

# 2. 淘汰策略
maxmemory-policy allkeys-lru

# 3. LRU样本数（越大越精确，但越慢）
maxmemory-samples 5

# 1. RDB（快照）
save 900 1      # 900秒内有1次修改，触发BGSAVE
save 300 10     # 300秒内有10次修改
save 60 10000   # 60秒内有10000次修改

# 2. AOF（日志）
appendonly yes
appendfilename "appendonly.aof"

# AOF同步策略
appendfsync everysec  # 每秒同步一次（推荐）
# appendfsync always  # 每次写入都同步（慢但安全）
# appendfsync no      # 由操作系统决定（快但不安全）

# AOF重写
auto-aof-rewrite-percentage 100  # AOF文件大小翻倍时重写
auto-aof-rewrite-min-size 64mb   # AOF文件至少64MB才重写

# 1. 最大客户端连接数
maxclients 10000

# 2. TCP backlog
tcp-backlog 511

# 3. 超时时间（0表示永不超时）
timeout 0

# 4. TCP keepalive
tcp-keepalive 300  # 300秒发送一次心跳

# 1. 内存使用率
used_memory / maxmemory

# 2. QPS
instantaneous_ops_per_sec

# 3. 命中率
keyspace_hits / (keyspace_hits + keyspace_misses)

# 4. 连接数
connected_clients

# 5. 慢查询数
slowlog len

# 6. 主从延迟
master_repl_offset - slave_repl_offset

# 7. 过期key数
expired_keys

# 8. 淘汰key数
evicted_keys

import redis
import time

def monitor_redis(host, port):
    r = redis.Redis(host=host, port=port, decode_responses=True)

    while True:
        info = r.info()

        # 内存使用率
        used_memory = info['used_memory']
        maxmemory = info['maxmemory']
        memory_usage = used_memory / maxmemory * 100 if maxmemory > 0 else 0

        # QPS
        qps = info['instantaneous_ops_per_sec']

        # 命中率
        hits = info['keyspace_hits']
        misses = info['keyspace_misses']
        hit_rate = hits / (hits + misses) * 100 if (hits + misses) > 0 else 0

        # 连接数
        connected_clients = info['connected_clients']

        print(f"时间: {time.strftime('%H:%M:%S')}")
        print(f"内存使用率: {memory_usage:.2f}%")
        print(f"QPS: {qps}")
        print(f"命中率: {hit_rate:.2f}%")
        print(f"连接数: {connected_clients}")
        print("-" * 50)

        time.sleep(5)

if __name__ == '__main__':
    monitor_redis('127.0.0.1', 6379)

# 现象
127.0.0.1:6379> INFO replication
master_repl_offset:1000000
slave0:offset=900000  # 延迟10万个命令

# 原因
1. 网络延迟（跨地域）
2. Slave处理慢（CPU/内存不足）
3. Master写入速度太快

# 解决
1. 增加Slave配置（CPU/内存）
2. 减少Master写入速度（限流）
3. 增加repl-backlog-size（避免全量同步）

# 现象
网络分区，导致两个Master同时存在

# 原因
Sentinel或Cluster节点之间网络分区

# 解决
配置min-replicas参数

# redis.conf
min-replicas-to-write 1       # 至少1个Slave在线才能写
min-replicas-max-lag 10       # Slave延迟不超过10秒

# 效果
如果Master无法连接到Slave，拒绝写入
防止脑裂导致数据不一致

# 查看慢查询
127.0.0.1:6379> SLOWLOG GET 10

# 常见原因
1. KEYS * （扫描所有key，O(N)）
2. HGETALL big_hash （大Hash，O(N)）
3. SMEMBERS big_set （大Set，O(N)）
4. ZRANGE big_zset 0 -1 （大ZSet，O(N)）

# 解决
1. 避免使用KEYS，改用SCAN
2. 避免大key，拆分为多个小key
3. 使用HSCAN、SSCAN、ZSCAN分批获取