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 思考题
-
设计题:活动系统需要支持"同一活动的所有 key 原子操作"——活动创建、商品报名、库存设置。如果每个活动的所有操作都使用
{activity:202604}hash tag,会有什么风险?如何设计更优的 key 方案? -
扩容题:一个 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的网络实战圣经

微信公众号: 架构师日常笔记 欢迎关注!
浙公网安备 33010602011771号