1. 项目背景

1.1 业务场景

公司的活动系统使用 Redis 一年后,遇到了单机无法突破的瓶颈——商品缓存 30GB、用户状态 15GB、排行榜 8GB、签到数据 5GB、UV 统计数据不断增长。单机内存已经扩到 64GB,继续纵向升级(买更大内存的机器)不仅越来越贵,而且单机故障的影响面也越来越大。

更要命的是——即使内存能扩,单机的网络带宽和 CPU 也有限。大促期间 Redis 单机 QPS 峰值达到 8 万,网络带宽接近 1Gbps 的上限。业务团队开始考虑水平扩展——把数据分散到多台 Redis 上。这就是 Redis Cluster 的用武之地。

1.2 Cluster vs Sentinel——不同的问题

问题 解决方案
单机容量不够 Cluster(数据分片到多台机器)
单机吞吐不够 Cluster(多个主节点并行处理)
单机故障影响大 Cluster(分片级故障转移,影响面缩小)
主库宕机需要自动切换 Sentinel 或 Cluster(Cluster 内置分片故障转移)

Sentinel 解决的是"单分片高可用",Cluster 解决的是"多分片水平扩展"。数据量不大但需要高可用 → Sentinel;需要横向扩展容量和吞吐 → Cluster。

1.3 本章目标

  • 理解 Redis Cluster 的核心概念:槽位、hash tag、MOVED/ASK。
  • 搭建 3 主 3 从 Cluster,写入业务数据验证路由。
  • 实践在线扩容(reshard)观察迁移过程。
  • 理解跨槽多 key 限制及其应对。

2. 项目设计

2.1 第一幕:16384 个槽位——为什么不是直接 hash 到节点?

小胖:"分片不是把 key 哈希一下取模就行了吗?hash(key) % 3 → 3 个节点各分 1/3。为什么搞出 16384 个槽位这么复杂?"

大师:"直接取模的问题是——加节点或减节点时,几乎所有 key 都需要重新计算和迁移(因为模数变了)。槽位是一个中间抽象层——key → hash → 槽位 → 节点。扩容时只需要迁移部分槽位,不需要重新哈希所有 key。"

直接取模:
  hash(key) % 3 → 节点 A (扩容前)
  hash(key) % 4 → 节点 C (扩容后) ← key 的归属变了!需要全量迁移

槽位方案:
  hash(key) % 16384 → 槽位 8000
  槽位 8000 原属节点 A → 迁移到新节点 D
  其他槽位的 key 完全不受影响 ← 只需要迁移部分槽位

技术映射:16384 个槽位是固定的——CRC16(key) % 16384。每个节点负责若干个槽位,槽位可以在节点间迁移。这就是水平扩展的灵活性来源。

小胖追问:"16384 这个数字有什么讲究?"

大师:"Redis 作者 antirez 解释过——16384 足够保证 key 的均匀分布(2^14),同时心跳消息中携带槽位位图时只需要 2KB(16384/8),通信开销不大。如果设为 65536,心跳包会变大到 8KB。"

2.2 第二幕:MOVED 和 ASK——被拒绝不是错误

小胖:"我敲 SET product:1001 'hello',Redis 返回 MOVED 1234 172.18.0.3:6379——这是报错了吗?"

大师:"不是报错,是指路。MOVED 告诉你——这个 key 计算出的槽位 1234 在另一个节点 172.18.0.3:6379 上,请你去那里操作。支持 Cluster 的客户端(如 redis-cli -c)会自动跟随重定向。"

MOVED vs ASK:

  MOVED: 槽位已经永久迁移到新节点
  返回: MOVED 1234 172.18.0.3:6379
  客户端行为: 刷新槽位表,直接连接新节点

  ASK: 槽位正在迁移中,这个 key 可能暂时在新节点
  返回: ASK 1234 172.18.0.3:6379
  客户端行为: 向新节点发送 ASKING + 原命令
          (这是临时重定向,不刷新槽位表)

技术映射:MOVED 是"你找错人了,以后去那里";ASK 是"正在搬家,这个 key 暂时在新家"。成熟客户端自动处理两者。

2.3 第三幕:hash tag——让多个 key 同槽的双刃剑

小胖:"多个 key 的原子操作在 Cluster 中怎么办?比如 MGET product:1001 stock:1001——两个 key 可能在不同槽位。"

小白:"这就需要 hash tag。Redis Cluster 只对 key 中 {} 包裹的部分计算槽位。order:{1001}:base 和 order:{1001}:items——两者都计算 1001 的哈希,落在同一槽位。"

# 没有 hash tag → 可能跨槽,MGET 失败
127.0.0.1:6379> CLUSTER KEYSLOT product:1001
(integer) 6770     # 槽位 6770
127.0.0.1:6379> CLUSTER KEYSLOT stock:1001
(integer) 482       # 槽位 482 — 不同!
127.0.0.1:6379> MGET product:1001 stock:1001
(error) CROSSSLOT Keys in request don't hash to the same slot

# 使用 hash tag → 同一槽位,MGET 成功
127.0.0.1:6379> CLUSTER KEYSLOT product:{1001}
(integer) 5834
127.0.0.1:6379> CLUSTER KEYSLOT stock:{1001}
(integer) 5834     # 相同!
127.0.0.1:6379> MGET product:{1001} stock:{1001}

大师:"但 hash tag 是双刃剑。如果所有和商品 1001 相关的 key 都用了 {1001},它们全落在同一个槽位,如果这个商品是爆款(10 万 QPS 集中在一个槽位上)——那一个节点就成了热点瓶颈。所以——只在必须保证多 key 原子操作时才用 hash tag,不要滥用。"

2.4 第四幕:在线扩容——reshard 不是无痛的

小胖:"集群加一个节点,数据会自动均衡吗?"

大师:"不会自动。你需要手动执行 redis-cli --cluster reshard,指定把多少槽位从旧节点迁移到新节点。迁移是逐槽进行的——每个槽迁移期间,该槽的 key 逐个从源节点复制到目标节点。这不是瞬间完成的操作,它会消耗网络和 CPU。"

槽位迁移流程:

  1. 目标节点通知源节点: "我要接管槽位 8000"
  2. 源节点把槽位 8000 的状态设为 MIGRATING
  3. 对槽位 8000 中的每个 key:
     a. DUMP key → 序列化
     b. RESTORE key 到目标节点
     c. DEL key 从源节点
  4. 迁移期间对该槽位的访问:
     - key 在源节点 → 正常操作
     - key 已被迁移 → 源节点返回 ASK 重定向到目标节点
  5. 槽位迁移完成后:
     - 槽位在目标节点设为 NORMAL
     - 在所有节点传播新的槽位归属

迁移注意事项:
  - 选择业务低峰期执行
  - 使用 --cluster reshard 的 --pipeline 参数加速
  - 监控迁移期间的延迟 P99 (会有轻微上升)
  - 大 key 迁移耗时长, 可能阻塞 → 先处理大 key

3. 项目实战

3.1 环境准备

# 创建网络
docker network create redis-cluster-net

# 启动 6 个节点
for port in $(seq 7001 7006); do
  docker run --name redis-c$port --network redis-cluster-net \
    -p $port:6379 -d redis:8.6 redis-server \
    --cluster-enabled yes \
    --cluster-config-file nodes.conf \
    --cluster-node-timeout 5000 \
    --appendonly yes
done

# 创建 3 主 3 从集群
docker exec -it redis-c7001 redis-cli --cluster create \
  redis-c7001:6379 redis-c7002:6379 redis-c7003:6379 \
  redis-c7004:6379 redis-c7005:6379 redis-c7006:6379 \
  --cluster-replicas 1

# 交互确认: yes

3.2 实战一:验证集群与槽位

# 用集群模式连接 (-c)
docker exec -it redis-c7001 redis-cli -c

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

# 查看节点列表
127.0.0.1:6379> CLUSTER NODES
# 每个主节点负责约 5461 个槽位 (16384/3)

# 查看槽位分布
127.0.0.1:6379> CLUSTER SLOTS

# 计算 key 的槽位
127.0.0.1:6379> CLUSTER KEYSLOT product:1001
(integer) 6770

3.3 实战二:写入数据并观察路由

# 写入多个 key(它们会自动路由到不同节点)
127.0.0.1:6379> SET product:1001 '{"name":"耳机","price":199}'
-> Redirected to slot [6770] located at redis-c7002:6379
OK

127.0.0.1:6379> SET stock:1001 500
-> Redirected to slot [482] located at redis-c7001:6379
OK

127.0.0.1:6379> ZADD rank:hot:202607 90 product:1001
-> Redirected to slot [11000] located at redis-c7003:6379
(integer) 1

# 注意: -c 模式会自动跟随 MOVED 重定向
# 不加 -c 你会看到 MOVED 错误

3.4 实战三:hash tag 使用

# 用 hash tag 将商品相关的 key 放到同一槽
127.0.0.1:6379> SET product:{1001}:base '{"name":"耳机"}'
OK
127.0.0.1:6379> SET product:{1001}:stock 500
OK

# 验证同一槽
127.0.0.1:6379> CLUSTER KEYSLOT product:{1001}:base
(integer) 5834
127.0.0.1:6379> CLUSTER KEYSLOT product:{1001}:stock
(integer) 5834   # 相同!

# 现在可以执行多 key 命令了
127.0.0.1:6379> MGET product:{1001}:base product:{1001}:stock
1) "{\"name\":\"耳机\"}"
2) "500"

# Lua 脚本——所有 KEYS 必须在同一槽位
127.0.0.1:6379> EVAL "return redis.call('MGET', KEYS[1], KEYS[2])" 2 product:{1001}:base product:{1001}:stock
1) "{\"name\":\"耳机\"}"
2) "500"

3.5 实战四:在线扩容(reshard)

# 添加一个新主节点
docker run --name redis-c7007 --network redis-cluster-net \
  -p 7007:6379 -d redis:8.6 redis-server \
  --cluster-enabled yes --cluster-config-file nodes.conf \
  --cluster-node-timeout 5000 --appendonly yes

# 将新节点加入集群(作为主节点)
docker exec -it redis-c7001 redis-cli --cluster add-node redis-c7007:6379 redis-c7001:6379

# 为新节点添加从库
docker run --name redis-c7008 --network redis-cluster-net \
  -p 7008:6379 -d redis:8.6 redis-server \
  --cluster-enabled yes --cluster-config-file nodes.conf \
  --cluster-node-timeout 5000 --appendonly yes

docker exec -it redis-c7001 redis-cli --cluster add-node redis-c7008:6379 redis-c7001:6379 \
  --cluster-slave --cluster-master-id <新主节点的ID>

# 执行 reshard(将 2000 个槽位迁移到新节点)
docker exec -it redis-c7001 redis-cli --cluster reshard redis-c7001:6379
# 交互输入:
#   How many slots do you want to move? → 2000
#   What is the receiving node ID? → <新主节点ID>
#   Source node? → all (从所有节点均匀提取)

# 观察迁移后槽位分布
docker exec -it redis-c7001 redis-cli -c CLUSTER SLOTS

3.6 实战五:故障转移

# Cluster 内置分片级故障转移——不需要 Sentinel!

# 观察某个主节点和它的从节点
docker exec -it redis-c7001 redis-cli -c CLUSTER NODES
# 找到一对主从

# 停止主节点
docker stop redis-c7002

# 观察集群状态变化
docker exec -it redis-c7001 redis-cli -c CLUSTER NODES
# → 该主节点的从节点自动晋升为 master
# → 集群仍然可用!

# 查看集群健康
docker exec -it redis-c7001 redis-cli -c CLUSTER INFO
# cluster_state:ok  (即使丢失一个主节点,如果其从库晋升成功)

# 恢复旧主
docker start redis-c7002
# → 自动成为新主的从库

3.7 实战六:Cluster 模式 Java 客户端

@Configuration
public class ClusterRedisConfig {

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        // 配置所有集群节点(客户端会自动发现全部节点)
        RedisClusterConfiguration clusterConfig = new RedisClusterConfiguration(
            Arrays.asList(
                new RedisNode("redis-c7001", 6379),
                new RedisNode("redis-c7002", 6379),
                new RedisNode("redis-c7003", 6379),
                new RedisNode("redis-c7004", 6379),
                new RedisNode("redis-c7005", 6379),
                new RedisNode("redis-c7006", 6379)
            )
        );

        // 最大重定向次数
        clusterConfig.setMaxRedirects(5);

        LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()
            .readFrom(ReadFrom.REPLICA_PREFERRED)  // 优先读从节点
            .commandTimeout(Duration.ofSeconds(2))
            .build();

        return new LettuceConnectionFactory(clusterConfig, clientConfig);
    }
}

3.8 实战七:集群运维常用命令

# 集群状态概览
CLUSTER INFO

# 节点列表
CLUSTER NODES

# 槽位分布
CLUSTER SLOTS

# 计算 key 的槽位
CLUSTER KEYSLOT product:1001

# 手动故障转移(让从库接管)
CLUSTER FAILOVER

# 遗忘节点
CLUSTER FORGET <node-id>

# 修复槽位(如果出现不一致)
redis-cli --cluster fix redis-c7001:6379

# 检查集群健康
redis-cli --cluster check redis-c7001:6379

# 重新平衡槽位
redis-cli --cluster rebalance redis-c7001:6379

3.9 实战八:Cluster 节点故障模拟与恢复

# 场景1: 从节点故障——集群正常,无影响
docker stop redis-c7004
docker exec redis-c7001 redis-cli -c CLUSTER NODES | grep redis-c7004
# 从节点断开,但其主节点仍正常工作

# 场景2: 主节点故障——其从节点自动晋升
docker stop redis-c7002  # 假设它是主节点
sleep 15
docker exec redis-c7001 redis-cli -c CLUSTER NODES
# 可以看到原来的从节点已变为 master

# 场景3: 主节点故障且无从节点——该槽位不可用
# 如果某个主节点故障且没有从节点→ 对应的槽位全部不可用
# cluster_state:fail (集群不可用!)
# 教训: 每个主节点至少有一个从节点

# 场景4: 超过半数主节点不可达
# 如果 3 主中 2 个不可达 → 集群不可用
# 需要 cluster-require-full-coverage no 才能允许部分槽位不可用时仍接受查询

3.10 实战九:槽位迁移中的业务影响

# 在 reshard 过程中,受影响槽位的请求可能出现:
# 1. 正常响应 (key还在源节点)
# 2. ASK 重定向 (key正在迁移中)
# 3. MOVED 重定向 (key已迁移完成)

# 客户端必须正确处理这三种情况
# 这就是为什么需要集群模式的客户端

# 监控迁移进度
redis-cli --cluster check redis-c7001:6379

# 如果迁移卡住——大 key 迁移是常见原因
# 用 --bigkeys 预先排查
redis-cli --bigkeys

3.11 实战十:Cluster 运维完整脚本

#!/bin/bash
# cluster_ops.sh - Redis Cluster 运维脚本

HOST="redis-c7001"

echo "=== 集群健康检查 ==="
docker exec $HOST redis-cli -c CLUSTER INFO | grep cluster_state

echo ""
echo "=== 节点列表 ==="
docker exec $HOST redis-cli -c CLUSTER NODES | awk '{print $1, $2, $3, $9}'

echo ""
echo "=== 槽位覆盖 ==="
ASSIGNED=$(docker exec $HOST redis-cli -c CLUSTER INFO | grep cluster_slots_assigned | cut -d: -f2 | tr -d '\r')
echo "已分配槽位: $ASSIGNED / 16384"

echo ""
echo "=== 各节点内存 ==="
for node in $(docker exec $HOST redis-cli -c CLUSTER NODES | grep master | awk '{print $2}' | cut -d@ -f1); do
  IP=$(echo $node | cut -d: -f1)
  PORT=$(echo $node | cut -d: -f2)
  MEM=$(docker exec $HOST redis-cli -c -h $IP -p $PORT INFO memory | grep used_memory_human | cut -d: -f2 | tr -d '\r')
  echo "  $node → $MEM"
done

echo ""
echo "=== 最近慢查询 ==="
docker exec $HOST redis-cli -c SLOWLOG GET 3 2>/dev/null

4.4 生产事故:大 key 导致 reshard 超时

某视频平台 Cluster 扩容时,有一个 Hash key 包含 50 万个 field(用户观看历史),reshard 迁移该槽位时耗时超过 30 分钟。迁移期间该槽位的操作频繁收到 ASK 重定向,客户端重定向超时导致部分请求失败。教训:① 扩容前用 --bigkeys 扫描大 key;② 大 key 先拆分再迁移;③ 设置 cluster-migration-barrier 防止不必要迁移。

4.5 Cluster 配置速查卡

配置 建议值 说明
cluster-enabled yes 开启集群模式
cluster-node-timeout 5000-15000 节点超时(ms)
cluster-migration-barrier 1 从库迁移保护
cluster-require-full-coverage yes 槽位全覆盖才可用
cluster-replica-no-failover no 从库可参与故障转移

4. 项目总结

4.1 Cluster 关键数字

参数 值 说明
槽位总数 16384 固定,不可变
最少主节点 3 保证故障转移有足够投票
最大节点数 理论上 16384 每个节点至少负责 1 个槽位
心跳间隔 每秒 Gossip 协议传播节点状态
PFAIL 超时 cluster-node-timeout 超时后标记为疑似故障
FAIL 判定 过半主节点同意 PFAIL 升级为 FAIL 的条件

4.2 Cluster 约束清单

约束 说明
多 key 命令 所有 key 必须在同一槽位
Lua 脚本 所有 KEYS 必须在同一槽位
事务 (MULTI/EXEC) 同 Lua,key 同一槽位
不支持多 db SELECT 命令不可用,只能用 db0
不支持跨槽 WATCH WATCH 的 key 必须在同一槽位
Pub/Sub 消息会广播到所有节点

4.3 思考题

  1. 设计题:活动系统需要支持"同一活动的所有 key 原子操作"——活动创建、商品报名、库存设置。如果每个活动的所有操作都使用 {activity:202604} hash tag,会有什么风险?如何设计更优的 key 方案?

  2. 扩容题:一个 3 主 3 从的 Cluster,某主节点内存使用 90% 且持续增长。除了加节点做 reshard,还有哪些立即可行的缓解手段?

(答案提示将在下一章末尾给出。)

4.4 数据迁移完整方案——从规划到执行

在线数据迁移(reshard)是 Cluster 运维中最危险的操作之一。以下是经过验证的完整方案。

迁移前评估矩阵:

#!/bin/bash
# pre_reshard_assessment.sh —— 迁移前评估脚本

HOST="redis-cluster-node1:7001"

echo "========================================="
echo "  Redis Cluster Reshard 迁移前评估"
echo "========================================="

# 1. 集群当前状态
echo ""
echo "[1] 集群健康状态:"
redis-cli -c -h $(echo $HOST | cut -d: -f1) -p $(echo $HOST | cut -d: -f2) CLUSTER INFO | \
    grep -E "cluster_state|cluster_slots_assigned|cluster_known_nodes"

# 2. 当前槽位分布
echo ""
echo "[2] 槽位分布:"
redis-cli -c -h $(echo $HOST | cut -d: -f1) -p $(echo $HOST | cut -d: -f2) CLUSTER NODES | \
    grep master | \
    awk '{split($9,a,"-"); slots=a[2]-a[1]+1; print $1, $2, slots" slots"}'

# 3. 各节点内存(迁移后目标节点的内存余量是关键)
echo ""
echo "[3] 各节点内存:"
redis-cli -c -h $(echo $HOST | cut -d: -f1) -p $(echo $HOST | cut -d: -f2) CLUSTER NODES | \
    grep master | awk '{print $2}' | cut -d@ -f1 | while read addr; do
    ip=$(echo $addr | cut -d: -f1)
    port=$(echo $addr | cut -d: -f2)
    mem=$(redis-cli -c -h $ip -p $port INFO memory 2>/dev/null | \
        grep used_memory_human | cut -d: -f2 | tr -d '\r')
    echo "  ${addr}: ${mem}"
done

# 4. 大 key 扫描(迁移最关键的前置检查)
echo ""
echo "[4] 大 key 扫描 (单 key > 10MB 或 元素 > 5000):"
redis-cli -c -h $(echo $HOST | cut -d: -f1) -p $(echo $HOST | cut -d: -f2) \
    --bigkeys -i 0.1 2>&1 | head -30

# 5. QPS 基线(选择低峰期迁移)
echo ""
echo "[5] 当前 QPS 基线:"
redis-cli -c -h $(echo $HOST | cut -d: -f1) -p $(echo $HOST | cut -d: -f2) INFO stats | \
    grep instantaneous_ops_per_sec

# 6. 迁移槽位数量估算
echo ""
TOTAL_SLOTS=16384
NODE_COUNT=$(redis-cli -c CLUSTER NODES | grep master | wc -l)
SLOTS_PER_NODE=$((TOTAL_SLOTS / NODE_COUNT))
echo "[6] 当前: ${NODE_COUNT} 主节点,平均 ${SLOTS_PER_NODE} 槽位/节点"
echo "    裂后: $((NODE_COUNT + 1)) 主节点,平均 $((TOTAL_SLOTS / (NODE_COUNT + 1))) 槽位/节点"
echo "    需迁移: $((SLOTS_PER_NODE - TOTAL_SLOTS / (NODE_COUNT + 1))) 槽位/节点"

# 7. 迁移耗时估算
BIGKEY_COUNT=$(redis-cli --bigkeys -i 0.1 2>&1 | grep -c "biggest")
echo ""
echo "[7] 风险评估:"
echo "  大 key 数量: ${BIGKEY_COUNT}"
echo "  建议: $( [ $BIGKEY_COUNT -gt 10 ] && echo "先拆大 key" || echo "可以迁移" )"
echo "  推荐时段: 凌晨低峰 (QPS < 1000)"

数据迁移执行脚本(带安全措施):

#!/bin/bash
# safe_reshard.sh —— 安全的在线迁移脚本

set -euo pipefail

SOURCE_NODE="172.20.0.2:7001"   # 迁出节点
TARGET_NODE="172.20.0.5:7003"   # 迁入节点
SLOT_RANGE="0-1364"              # 迁移槽位范围
CLUSTER_HOST="172.20.0.2:7001"   # 集群任意节点

# 每个槽位的 key 数量(用于估算迁移时间)
SLOT_COUNT=$(echo $SLOT_RANGE | awk -F'-' '{print $2 - $1 + 1}')
echo "计划迁移: ${SLOT_COUNT} 个槽位 (${SLOT_RANGE})"
echo "迁出: ${SOURCE_NODE} → 迁入: ${TARGET_NODE}"

# 步骤 1: 加入新节点(如果还未加入)
echo ""
echo "[1/6] 设置目标节点为集群成员..."
redis-cli -c CLUSTER MEET $(echo $TARGET_NODE | cut -d: -f1) $(echo $TARGET_NODE | cut -d: -f2)

# 步骤 2: 手动分配槽位(小批量迁移)
echo ""
echo "[2/6] 开始迁移 (分批进行)..."
START=$(echo $SLOT_RANGE | cut -d- -f1)
END=$(echo $SLOT_RANGE | cut -d- -f2)

# 每次迁移 100 个槽位(避免长时间阻塞)
BATCH_SIZE=100
for ((i=START; i<=END; i+=BATCH_SIZE)); do
    BATCH_END=$((i + BATCH_SIZE - 1))
    if [ $BATCH_END -gt $END ]; then BATCH_END=$END; fi

    echo "  迁移槽位 ${i}-${BATCH_END}..."

    # 关键:使用 pipeline 限制迁移速度
    redis-cli -c --cluster reshard ${CLUSTER_HOST} \
        --cluster-from $(redis-cli -c CLUSTER NODES | grep "${SOURCE_NODE}" | awk '{print $1}') \
        --cluster-to $(redis-cli -c CLUSTER NODES | grep "${TARGET_NODE}" | awk '{print $1}') \
        --cluster-slots $((BATCH_END - i + 1)) \
        --cluster-yes \
        --cluster-timeout 60000 \
        --cluster-pipeline 10 2>&1 | tail -5

    # 每批次间暂停,给集群喘息时间
    echo "  批次完成,暂停 5 秒..."
    sleep 5
done

# 步骤 3: 验证迁移进度
echo ""
echo "[3/6] 验证迁移完成..."
redis-cli -c CLUSTER NODES | grep -E "${SOURCE_NODE}|${TARGET_NODE}" | \
    awk '{print $2, $9}'

# 步骤 4: 检查迁移后槽位状态
echo ""
echo "[4/6] 检查 importing/migrating 状态..."
MIGRATING=$(redis-cli -c CLUSTER NODES | grep -c "migrating\|importing" || true)
if [ "$MIGRATING" -gt 0 ]; then
    echo "  [警告] 仍有 ${MIGRATING} 个槽位处于迁移状态"
else
    echo "  所有槽位迁移完成"
fi

# 步骤 5: 数据完整性抽查
echo ""
echo "[5/6] 数据完整性抽查..."
# 在迁入节点抽样检查 DBSIZE 与预期一致
TARGET_IP=$(echo $TARGET_NODE | cut -d: -f1)
TARGET_PORT=$(echo $TARGET_NODE | cut -d: -f2)
DBSIZE=$(redis-cli -c -h $TARGET_IP -p $TARGET_PORT DBSIZE 2>/dev/null)
echo "  迁入节点 key 数量: ${DBSIZE}"

# 步骤 6: 清理
echo ""
echo "[6/6] 迁移完成,集群状态:"
redis-cli -c CLUSTER INFO | grep cluster_state

echo "========== 迁移操作完成 =========="

4.5 Hash Tag 设计模式与陷阱

Hash Tag 是 Cluster 中实现多 key 原子操作的核心手段,但用不好会引发严重的槽位倾斜。

Hash Tag 原理回顾:

CRC16(key) % 16384 → 槽位

无 Hash Tag:
  order:123:items  → CRC16("order:123:items")  → 槽位 4567
  order:123:status → CRC16("order:123:status") → 槽位 8912
  → 不在同一槽位,不能使用 MULTI/EXEC

有 Hash Tag:
  {order:123}:items  → CRC16("order:123") → 槽位 3456
  {order:123}:status → CRC16("order:123") → 槽位 3456
  → 在同一槽位,可以使用 MULTI/EXEC

常见 Hash Tag 设计模式:

模式 示例 适用场景 风险
用户维度 {user:1001}:cart, {user:1001}:profile 用户相关的所有数据在同一槽位 热点用户
订单维度 {order:20260401}:items, {order:20260401}:status 订单的原子操作 单订单无风险
活动维度 {activity:spring2026}:stock, {activity:spring2026}:rank 活动相关数据 大促热点
店铺维度 {shop:8888}:products, {shop:8888}:orders 店铺级操作 头部店铺倾斜
日期维度 {20260401}:user:logins, {20260401}:user:orders 每日统计 当日热点

Hash Tag 引发的槽位倾斜问题:

# 诊断:检查各节点槽位 key 分布是否均匀
redis-cli --cluster info redis-cluster-node1:7001

# 如果某个节点的 key 数量远大于其他节点:
#  → 可能是 Hash Tag 设计不当,导致大量 key 集中在少数槽位

# 具体排查:
redis-cli -c CLUSTER NODES | grep master | awk '{print $2}' | cut -d@ -f1 | \
while read addr; do
    ip=$(echo $addr | cut -d: -f1)
    port=$(echo $addr | cut -d: -f2)
    dbsize=$(redis-cli -c -h $ip -p $port DBSIZE 2>/dev/null)
    echo "${addr}: ${dbsize} keys"
done

# 如果某个节点 key 数是其他节点的 3 倍+:
# 1. 找出该节点上的 slot,检查哪些 key 模式在"拥挤"
redis-cli -c --bigkeys -h $ip -p $port

# 2. 如果是 {user:xxx} 导致的问题:
#   - 方案 A: 不再使用 user 级 hash tag,改为让 key 分散
#   - 方案 B: 使用 {user:xxx:shardN} 增加分散度
#     例如: {user:1001:0}:cart, {user:1001:1}:profile

# 3. 拆分热点 Hash Tag:
#   原方案:  {hot:user:1001}:cart, {hot:user:1001}:sessions → 全在同一槽位
#   改进:    {u:1001:c}:cart, {u:1001:s}:sessions → 分散到不同槽位
#   (但要牺牲多 key 原子操作的能力)

Hash Tag 设计决策树:

这个 key 组需要原子操作吗?
  ├── 不需要 → 不用 Hash Tag(让 key 自然分散)
  └── 需要
      ├── 原子操作涉及多少 key?
      │   ├── 2-3 个 → 使用轻量 Hash Tag,如 {entity:id}:field
      │   └── 大量 key → 考虑是否可以用 Lua 脚本替代
      └── 这个 Tag 会不会产生热点?
          ├── 不会(如单订单操作)→ 安全使用
          └── 会(如热门活动)→ 增加分片维度:{entity:id:shard}

4.6 Cluster 容量规划方法论

容量规划五步法:

步骤 1: 估算数据总量
  - 当前数据量: X GB
  - 月增长率: Y%
  - 12 个月后: X * (1 + Y/100)^12 GB
  - 每个 key 平均大小建议: < 10KB(过大影响迁移和网络)

步骤 2: 确定单节点容量上限
  - 单节点内存上限: 建议 32GB(fork 和 COW 可控)
  - 单节点实际使用: 上限 × 70%(预留 COW + 碎片空间)
  - 即: 32GB × 70% = 22.4GB

步骤 3: 计算所需节点数
  - 节点数 = ceil(总数据量 / 单节点可用容量)
  - 例: 60GB / 22.4GB ≈ 3 个主节点
  - 加上从节点: 3 主 3 从 = 6 个节点
  - 预留 6 个月增长: 60GB × 1.5 = 90GB → 5 个主节点

步骤 4: 计算槽位分布
  - 16384 个槽位 / 3 个主节点 ≈ 5461 槽位/节点
  - 槽位不是均匀的——大 key 的槽位更"重"
  - 预留 10% 槽位余量用于在线迁移

步骤 5: 性能规划
  - 单节点 QPS 上限: ~10 万(取决于命令复杂度)
  - 单节点网络带宽: ~1Gbps(预留 30% 余量)
  - COW 内存预留: 节点内存 × 50%

扩容时机判断:

// 在线检测是否需要扩容
public class ClusterCapacityMonitor {

    private static final double MEMORY_WARN_THRESHOLD = 0.75;
    private static final double MEMORY_CRITICAL_THRESHOLD = 0.85;
    private static final double QPS_WARN_THRESHOLD = 70000;
    private static final double SLOT_BALANCE_THRESHOLD = 0.3; // 30% 不均衡

    @Scheduled(fixedRate = 300000) // 每 5 分钟检查
    public void checkCapacity() {
        ClusterInfo clusterInfo = getClusterInfo();

        for (NodeInfo node : clusterInfo.getMasterNodes()) {
            // 内存使用率
            if (node.getMemoryUsagePercent() > MEMORY_CRITICAL_THRESHOLD) {
                alert(P1, String.format(
                    "节点 %s 内存使用率 %.1f%%, 需立即扩容或清理",
                    node.getAddress(), node.getMemoryUsagePercent() * 100));
            } else if (node.getMemoryUsagePercent() > MEMORY_WARN_THRESHOLD) {
                alert(P3, String.format(
                    "节点 %s 内存使用率 %.1f%%, 建议近期扩容",
                    node.getAddress(), node.getMemoryUsagePercent() * 100));
            }

            // QPS 逼近
            if (node.getInstantaneousOps() > QPS_WARN_THRESHOLD) {
                alert(P3, String.format(
                    "节点 %s QPS %.0f 逼近上限,建议扩容",
                    node.getAddress(), node.getInstantaneousOps()));
            }
        }

        // 槽位不均匀
        double slotStdDev = calculateSlotDistributionStdDev(clusterInfo);
        if (slotStdDev > SLOT_BALANCE_THRESHOLD * getAvgSlotsPerNode(clusterInfo)) {
            alert(P3, String.format(
                "槽位分布不均匀: 标准差=%.0f, 建议 rebalance",
                slotStdDev));
        }
    }
}

容量规划速查表:

数据规模 推荐配置 总内存 读 QPS 上限 月度成本参考
< 20GB 1 主 1 从 (Sentinel) 40GB 10 万 低
20-60GB 3 主 3 从 (Cluster) 120GB 30 万 中
60-200GB 6 主 6 从 (Cluster) 240GB 60 万 高
200-500GB 12 主 12 从 (Cluster) 480GB 120 万 很高
> 500GB 考虑按业务垂直拆分多个 Cluster - - 需定制

4.7 跨槽多 key 操作——实战替代方案

Cluster 的最大限制就是多 key 必须在同一槽位。以下是绕过这个限制的实战方案。

方案对比:

方案 原理 优点 缺点 适用场景
Hash Tag key 中包含 简单、原子 热点风险 同一个实体操作的少量 key
客户端合并 分组发送到对应节点 无热点 两次网络往返 读多写少
Lua 脚本 + 哈希标签 EVALSHA 发送到 tag 节点 原子 热点 复杂多 key 原子操作
应用层事务 数据库兜底 可靠 延迟高 资金类操作

客户端合并模式实现:

// 将多个跨槽的 key 按槽位分组,并发查询

@Service
public class CrossSlotQueryService {
    private final RedisClusterClient clusterClient;

    // 批量获取跨槽位的 key(读操作)
    public Map<String, Object> mgetCrossSlot(List<String> keys) {
        // 按槽位分组
        Map<Integer, List<String>> slotGroups = new HashMap<>();
        for (String key : keys) {
            int slot = SlotHash.getSlot(key);
            slotGroups.computeIfAbsent(slot, k -> new ArrayList<>()).add(key);
        }

        // 按节点分组(同一节点可能有多个槽位)
        StatefulRedisClusterConnection<String, String> conn = clusterClient.connect();
        Map<String, Future<Map<String, String>>> futures = new HashMap<>();
        Map<String, Object> results = new ConcurrentHashMap<>();

        for (Map.Entry<Integer, List<String>> entry : slotGroups.entrySet()) {
            List<String> groupKeys = entry.getValue();
            String nodeId = conn.getPartitions().getPartitionBySlot(entry.getKey()).getNodeId();

            // 并发发送到对应的节点
            CompletableFuture<Map<String, String>> future = CompletableFuture.supplyAsync(() -> {
                // 获取对应节点的连接
                var nodeConn = clusterClient.connectToNode(
                    RedisURI.create(getNodeUri(nodeId)));
                try {
                    // 在单个节点上执行 MGET
                    List<KeyValue<String, String>> values =
                        nodeConn.sync().mget(groupKeys.toArray(new String[0]));
                    Map<String, String> result = new HashMap<>();
                    for (int i = 0; i < groupKeys.size(); i++) {
                        KeyValue<String, String> kv = values.get(i);
                        if (kv != null && kv.hasValue()) {
                            result.put(groupKeys.get(i), kv.getValue());
                        }
                    }
                    return result;
                } finally {
                    nodeConn.close();
                }
            });

            future.thenAccept(results::putAll);
            futures.put(nodeId, null); // 标记已处理
        }

        // 等待所有节点返回
        try {
            Thread.sleep(100); // 简单等待,生产环境用 CompletableFuture.allOf
        } catch (InterruptedException ignored) {}

        return results;
    }
}

Hash Tag 微调——解决热点问题:

// 问题: {user:hotUser}:xxx 导致该用户所有 key 在同一槽位
// 解决: 用分片 Tag——把用户数据打散到多个槽位

public class ShardedHashTagStrategy {

    private static final int SHARD_COUNT = 8; // 分 8 个槽位

    // 生成带分片的 key
    public static String cartKey(Long userId) {
        int shard = (int) (userId % SHARD_COUNT);
        // {user:1001:0}:cart  vs  {user:1001:7}:cart → 分散到 8 个不同槽位
        return String.format("{user:%d:%d}:cart", userId, shard);
    }

    public static String profileKey(Long userId) {
        int shard = (int) (userId % SHARD_COUNT);
        return String.format("{user:%d:%d}:profile", userId, shard);
    }

    // 缺点:同一用户的 cart 和 profile 可能在不同槽位
    // 不能做原子操作,但避免了热点
    // 取舍:牺牲原子性,换取均匀分布
}

4.8 Cluster 故障转移与槽位恢复

# 手动故障转移(计划内维护)
redis-cli -c -h slave-node1 -p 7004 CLUSTER FAILOVER
# CLUSTER FAILOVER 三种模式:
#   默认: 等待主库确认,优雅切换
#   FORCE: 不等主库同意,直接接管(可能丢数据)
#   TAKEOVER: 绕过所有协议,强制接管(仅在主库确定已死时用)

# 模拟主库宕机后的故障转移过程
redis-cli -c -h master-node1 -p 7001 DEBUG sleep 60 &
sleep 2
redis-cli -c -h master-node1 -p 7001 SHUTDOWN NOSAVE

# 观察: 集群状态 → fail 变为 ok(约 15-30 秒)
watch -n 2 'redis-cli -c -p 7002 CLUSTER INFO | grep cluster_state'

# 验证: 原从库已提升为主库
redis-cli -c -p 7002 CLUSTER NODES | grep "myself"
# 预期: myself 后面是 "master"

上一章思考题答案提示(第24章):

第1题(丢失数据补偿):订单创建——如果主库宕机前写了 Redis 锁但没有创建数据库订单,锁有过期时间会自动释放,业务重试即可。积分增加——通过业务日志或 Stream 消息补偿,幂等增加积分。缓存更新——缓存有 TTL,丢失了也能自然恢复;紧急时可触发缓存预热。

第2题(3 个 Sentinel 同机):这是"伪高可用"——虽然 quorum=2 看起来很安全,但物理机宕机会导致全部 3 个 Sentinel 同时失效。故障域没隔离,高可用只是形式。正确做法:3 个 Sentinel 分别部署在 3 台不同物理机/机架/可用区。

延伸阅读与资源

Redis 8 实战精讲:从 CRUD 到源码,构建高可用缓存系统
Java 工程师进阶:从 JVM 生产排障到OpenJDK原理
Nacos 3.x 注册配置中心实战修炼:从入门到源码扩展
Elasticsearch从入门到进阶的实战之旅
MySQL Server 9从入门到进阶的实战之旅
RabbitMQ从入门到进阶的实战之旅:从单机到大促高可用架构
Celery 入门到进阶之路:从异步任务到自研调度平台
LangGraph 生产级实战进阶:从零到生产级Agent工作流开发
Dify 从入门到源码:LLM 应用平台实战修炼
从零到生产级:FastAPI 异步高并发、源码与 SRE 实战
实战SQLAlchemy 2.0: 从 CRUD 到生产级架构
从零打造企业级 AI 助手:LangChain RAG、Agent 与生产实战
后端工程师 AI 转型课:Ollama 私有化大模型从入门到生产
MongoDB 实战进阶与内核修炼
NumPy 从入门到生产落地:全链路实战指南(科学计算/向量化/性能调优)
Milvus向量数据库实战修炼:从 0 到 1 精通向量检索与生产落地
Python 3实战精进:从脚本到高并发订单引擎
python入门:Rquests从菜鸟脚本到企业级SDK的网络实战圣经

posted on 2026-11-21 10:30  一天不进步,就是退步  阅读(5)  评论(0)    收藏  举报