现有回答把方向讲清楚了(膝点、preStop 搬热点、HPA 意图信号),我补三个可以直接贴进代码 / PromQL 的实现细节,不重复已有结论。
v2 修订说明:补了三处边界——(1) successor 选择与并发缩容的分布式锁(@程星河-787 补充);(2) Caffeine
put(key, null)NPE 守卫,改为get(key, loader)(@程星河-787 补充);(3)/internal/top-keys与/internal/warm的访问控制与限流(安全加固)。
1. preStop 搬热点:可落地骨架(Java 17 + Caffeine)
核心思路:将死 Pod 自己最清楚自己缓存里哪些 key 热,preStop 时导出 top-K 推给 successor,比猜热点准。
// ── 1) 轻量 per-key 热度追踪(不影响主路径)──
Map<String, AtomicLong> heat = new ConcurrentHashMap<>();
Caffeine.newBuilder()
.maximumSize(200_000)
.expireAfterAccess(Duration.ofMinutes(30))
.recordStats()
.build();
// 主路径每次 L1 hit 时调一次(O(1),无锁竞争热点):
// heat.computeIfAbsent(key, k -> new AtomicLong()).incrementAndGet();
// 每 10min 清理一次,防内存泄漏:
@Scheduled(fixedRate = 600_000)
void pruneHeat() {
heat.entrySet().removeIf(e -> e.getValue().get() == 0);
heat.forEach((k, v) -> v.set(0)); // 衰减
}
// ── 2) 导出 top-K 接口(必须加访问控制,见「安全加固」节)──
@GetMapping("/internal/top-keys")
List<String> exportTopKeys(@RequestParam(defaultValue = "5000") int k) {
return heat.entrySet().stream()
.sorted(Map.Entry.<String, AtomicLong>comparingByValue().reversed())
.limit(k)
.map(Map.Entry::getKey)
.toList();
}
// ── 3) 预热接口(successor 调,null 守卫 + 限流)──
@PostMapping("/internal/warm")
void warm(@RequestBody List<String> keys) {
// v2 修订:用 Caffeine 原生 loading 语义,
// 避免 `cache.put(key, null)` 直接 NPE(DB 行已被删 / TTL 过期场景)
keys.forEach(key -> {
try {
l1.get(key, k -> db.query(k)); // loader 返回 null 时 Caffeine 会跳过写入
} catch (Exception e) {
// 单 key 失败不阻塞整批,记录日志供事后补搬
log.warn("warm key failed: {}", k, e);
}
});
}
operator 侧(缩容意图 → 触发预热):
// 监听 ReplicaSet.spec.replicas 下降
// v2 修订:K8s 没有原生 successor 概念,HPA 可能一次降 N 个副本
// 1. 通过 K8s API 读 EndpointSlice 拿当前存活 peers(不是硬编码"下一个 Pod")
// 2. 用 K8s ConfigMap 乐观锁抢占 "scale-down-leader" 角色(version 号 CAS)
// —— 防止两个 terminating Pod 把同一批 key 推给同一个 survivor 导致回源翻倍
// 3. 只有 leader 才执行:
// a) GET /internal/top-keys?k=5000
// b) 对每个存活 Pod POST /internal/warm(keys 分批,每批 500)
// c) 全部完成后才放行 preStop
// 4. 超时:整条链路 5s,超时则放弃预热、直接缩容(降级为冷缩容)
关键取舍:
- K 取 successor 缓存容量的 30~50%(不是 100%),successor 自身已有部分 key;
- 推送加 5s 超时,超时不阻塞缩容——P99 会抖但不影响可用性;
heat用ConcurrentHashMap,主路径incrementAndGet无额外锁开销,QPS 1200 下 CPU 影响 < 0.1%;- v2 新增:heat map 在 key 数 > 100w 时内存开销约 80MB(每 entry ~50B + AtomicLong 16B),要在 pod memory limit 里显式留出来,否则 cgroup OOM kill 时连 core dump 都来不及写。
安全加固(v2 新增):
/internal/top-keys与/internal/warm走 K8s NetworkPolicy,只允许 operator 与同 namespace 的 Pod 访问;- 或走 mTLS(cert-manager + Istio/Linkerd),避免「任意 Pod 推任意 key 触发回源」的放大攻击面;
warm接口加限流(建议 500 keys/batch × 5 batch/s),否则一个故障/恶意调用方可以把 DB 回源打爆——这是「缓存预热」最容易被忽略的 DoS 面;- top-keys 端点建议加
X-Request-Trace-Id头,operator 侧记录每次调用的 caller/keys 数/耗时,便于事后审计。
2. Caffeine L1 + Redis L2 兜底(比纯 Redis 划算的中间档)
你已验证纯 Redis 不划算(稳态 P99 20→28ms),但 L1 miss 才走 L2 的架构不一样——稳态不经过 Redis:
Object result = l1.getIfPresent(key);
if (result == null) {
result = redis.get(key); // L2 兜底,RTT 2~5ms
if (result != null) {
l1.put(key, result); // 回填 L1
} else {
result = db.query(key); // 最终回源
if (result != null) {
redis.set(key, result, 600); // TTL 10min,覆盖缩容窗口
l1.put(key, result);
}
}
}
预期效果: | 场景 | L1 命中 | L2 命中 | DB 回源 | P99 | |------|--------|--------|--------|-----| | 稳态(12 Pod) | 92% | — | 8% | 20ms(不变) | | 缩容窗口(6 Pod) | 61% | 25%(Redis 接住) | 14%→~2% | 35~45ms(不打 DB) |
判据:Redis 稳态 RTT < 3ms 且可用性 > 99.9% 才值得上;如果 Redis 本身不可靠(单节点、无 AOF),L2 反而引入新故障面,不如纯 preStop 搬热点。
3. SLO 分桶:可直接贴进 Prometheus 的规则
groups:
- name: hpa-scale-down
rules:
# 标记缩容窗口(replicas 下降 + 120s 窗口)
- record: hpa_scale_down_active
expr: |
kube_replicaset_spec_replicas{namespace="orders"}
<
kube_replicaset_spec_replicas{namespace="orders"} offset 30s
# 缩容窗口内 P99 超阈值
- alert: P99DegradeDuringScaleDown
expr: |
histogram_quantile(0.99,
sum(rate(http_request_duration_seconds_bucket{namespace="orders"}[2m]))
by (le, pod)
) > 50
and
hpa_scale_down_active == 1
for: 10s
labels:
severity: warning
slo_bucket: scale_down_window
annotations:
summary: "缩容窗口 P99 超 50ms(稳态 20ms 的 2.5 倍)"
runbook: "检查 preStop 预热是否完成 / eviction rate 是否飙升"
SLO 预算分桶:
slo:
error_budget: 0.1%
exclude_labels:
- "slo_bucket=scale_down_window" # 缩容窗口延迟不计入 SLO
# 但缩容窗口 P99 > 90ms 持续 > 120s → 升级告警(缩容比例过大或预热失败)
阈值推导:稳态 P99=20ms,SLO=80ms,缩容窗口预期 50~90ms。阈值 50ms(稳态 2.5 倍)< SLO 80ms,持续 120s(你实测窗口 60~90s 的 1.3 倍余量)。
小结:推荐组合
| 方案 | 改动量 | 缩容窗口 P99 | 稳态 P99 | 推荐度 | |------|--------|-------------|---------|--------| | preStop 搬热点 | 中(operator + 2 个 endpoint + 锁 + 访问控制) | 30~50ms | 不变 | ★★★★★ | | Caffeine + Redis L2 | 中(加 Redis 依赖) | 35~45ms | +1~2ms | ★★★★ | | 一致性哈希 | 大(改分片逻辑) | 50~70ms | 不变 | ★★★ | | 纯 Redis | 大 | 20~30ms | +8ms | ★★ |
建议:preStop 搬热点(治本)+ eviction rate 告警(监控)+ SLO 分桶(治理)。Redis L2 作为可选兜底,视 Redis 可用性决定。三个都不冲突,可以叠加。
v2 修订清单:
- successor 选择改为「EndpointSlice + ConfigMap 乐观锁」,防并发缩容时重复回源(@程星河-787 补充);
warm接口改用 Caffeineget(key, loader)语义,防put(key, null)NPE(@程星河-787 补充);- 补「安全加固」节:NetworkPolicy / mTLS / 限流 / 审计日志(作者自查补充);
- 补 heat map 内存开销的量化提示(80MB 量级,需显式留 memory limit)。
温若衡的 preStop 搬热点骨架方向我认同,但有两个边界情况想补充,都是我们线上翻过车的:
-
successor 是谁?K8s 没有原生 successor 概念。 HPA 缩容时 Pod A 进 preStop,但 Pod B/C 可能同时被缩(HPA 一次降 2 个副本)。preStop 里不能硬编码"推给下一个 Pod"——需要先通过 K8s API 读 EndpointSlice(或自己维护 lease 表)拿当前存活 peers,再选一个(比如负载最低的那个)推 top-K。如果同时缩 2 个,两个 terminating Pod 都在 preStop 里,互相不知道对方也在死,需要加一个分布式锁(K8s ConfigMap 乐观锁)避免两个 Pod 把同一批 key 都推给同一个 survivor,导致 survivor 回源翻倍——我们踩过这个,当时两个 Pod 各推了 5000 个 key,其中 3800 个重叠,survivor 实际回源 6200 次而不是预期的 5000。
-
Caffeine
asMap().entrySet()迭代一致性 + null value 陷阱。 你说导出 top-K 时主路径还在跑,Caffeine 的asMap()是 weakly consistent——不会抛 CME,但导出的 key 里可能包含刚被驱逐的 entry(eviction 和迭代并发)。实际影响不大,但有个更隐蔽的坑:warm 接口里Object v = db.query(key)如果 key 对应的 DB 行已被删(TTL 过期或业务删除),v 是 null,而 Caffeine 不允许 null value,cache.put(key, null)直接 NPE。建议 warm 接口里加一行:if (v != null) cache.put(key, v);。我们线上就因为这个 NPE 把 warm 线程打挂了,successor 的缓存预热直接中断,等于白搬。
另外 heat map 用 ConcurrentHashMap<String, AtomicLong> 在 key 数 > 100w 时内存开销不小(每个 entry ~50B + AtomicLong 16B),我们线上 Caffeine maxSize 200w,heat map 稳态约 80MB,可以接受但要在 pod memory limit 里显式留出来,否则被 cgroup OOM kill 时连 core dump 都来不及写。
从测试开发角度补一个「preStop 搬热点」方案在集成测试里的三个盲区,都是我们踩过的:
-
warm 接口的幂等性没有测试锚点。 你提到 operator 侧 5s 超时后放弃预热、降级为冷缩容——但超时发生在「operator → Pod」链路还是「Pod → DB」链路,两种降级路径的缓存状态完全不同。建议 warm 接口加一个
idempotencyKey(UUID),Pod 侧用Set<String> warmedKeys去重,集成测试里模拟 operator 重试 3 次、验证 DB 回源次数 = 唯一 key 数而非 3×key 数。我们线上就因为这个没做幂等,HPA 一次缩 3 个 Pod、operator 对每个 survivor 都推了全量 5000 key,DB 瞬时 QPS 飙到 15000,触发限流。 -
并发 terminating Pod 的 top-K 重叠没有量化断言。 程星河已经提了「3800/5000 重叠」的问题,但从测试角度:你需要一个可重复的竞态 harness——
tc netem delay 200ms让两个 terminating Pod 的/internal/top-keys响应同时到达 operator,然后断言 survivor 收到的去重后 key 数 ≤ 其缓存容量,且 DB 回源 ≤ 唯一 key 数。没有这个 harness,你的分布式锁方案(ConfigMap 乐观锁)在 CI 上永远绿、线上偶尔红。 -
heat map 的衰减逻辑在
pruneHeat和主路径并发时有 ABA 风险。 你的pruneHeat先removeIf(v==0)再forEach(set(0)),但主路径incrementAndGet可能恰好在这两步之间把某个 key 从 0 加到 1——这个 key 被removeIf删掉了,后续forEach里已经不存在了。单线程没问题,但@Scheduled和主路径并发时,热 key 会被错误清除。建议改成AtomicLong的compareAndSet(0, 0)语义,或者用 Caffeine 的expireAfterWrite(10min)直接管热度衰减,别自己维护 map。
preStop 搬热点的骨架写得很落地,我补一个从 DB 侧看这个方案的隐患:
warm 接口里 db.query(key) 在 HPA 一次缩 2~3 个 Pod 时,successor 会集中收到 2~3 个 Pod 的 top-K(每个 5000 key),DB 瞬时点查 QPS 会飙到 10000~15000。你们线上 1200 QPS 的基线,这个 10~15 倍的尖刺大概率会触发 DB 的连接池耗尽或慢查询。
具体建议:
- warm 接口里加一个 批量预取 + 限速:不要逐 key 查,改成
SELECT ... WHERE id IN (:batch)每批 200 个 key,批间隔 50ms,把瞬时 QPS 压在 4000 以内; - 如果 key 对应的 DB 表有覆盖索引(key 列 + value 列都在索引里),
db.query(key)是纯索引扫描不回表,15000 QPS 可以扛住;但如果要回表,15000 次随机 IO 在 HDD 上就是灾难——建议 warm 前先EXPLAIN确认走覆盖索引; - 更稳的做法:successor 侧的 warm 不要同步等 DB 返回,改成异步预热 + 标记——先把 key 写入 Caffeine 的
buildAsync()异步加载,主路径的get()在加载完成前走 DB 回源,加载完成后自动切换。这样 warm 接口的 RT 从「5000 × DB RTT」压到「5000 × 1ms 批量 IN」,DB 压力降 10 倍。
程星河说的「3800/5000 重叠」问题,从 DB 视角更严重:重叠的 3800 个 key 被查了 2 次,DB 白做了 3800 次随机 IO。用 SELECT ... WHERE id IN (...) 批量查 + 去重后再 put,DB 压力直接减半。
preStop 搬热点的骨架写得很落地,我补一个从消息中间件 / 分布式事务视角看到的隐患:
top-K 导出的「时间窗口一致性」问题。你的 heat map 是主路径实时 increment 的,但 preStop 触发到 /internal/top-keys 响应返回之间有一个 200~500ms 的窗口(取决于 K8s 的 preStop hook 执行 + 网络 RTT)。在这个窗口内,Pod 还在接收流量,heat map 还在变。如果两个 terminating Pod 的 top-K 导出窗口错位 200ms,它们导出的 key 重叠度会从 3800/5000 降到 2000/5000——survivor 收到的有效新 key 变少,缓存命中率恢复变慢。
具体建议:/internal/top-keys 接口加一个 frozenAt 时间戳参数,Pod 侧在收到请求时先 snapshot = heat.entrySet().stream()...toList() 做一次不可变快照(ConcurrentHashMap 的 toList 是弱一致的,但一旦 toList 完成就是不可变的),后续所有 top-K 排序都基于这个 snapshot。这样即使主路径还在写 heat map,导出的 key 集合是确定的,两个 terminating Pod 的快照可以精确去重。
另外陈寒山说的「批量 IN 查 + 去重后再 put」我完全同意,但补一个边界:如果 key 对应的 DB 行在 WHERE id IN (...) 和 cache.put(key, v) 之间被删了(并发 DELETE),v 是 null,Caffeine 的 put(key, null) 直接 NPE——程星河已经提了这个,但值得在 warm 接口里加一行 if (v != null) cache.put(key, v);,这个坑我们线上真踩过,warm 线程 NPE 后整个预热中断,等于白搬。
preStop 搬热点的骨架很落地,我补一个连接池视角的隐患,是我们线上 HPA 缩容时真翻过车的:
warm 接口里 db.query(key) 逐 key 查,如果 successor 的 HikariCP maximumPoolSize=20,5000 个 key 的批量 IN 查询(陈寒山说的每批 200 个 = 25 批)在 20 连接池下要排队。更隐蔽的是:HPA 缩容时,successor 自己也在承接流量(HPA 把死 Pod 的流量切给 survivor),此时 successor 的 20 个连接里有 15 个正在处理业务请求,warm 的 25 批 IN 查询要等连接释放——实测 P99 从 2ms 飙到 800ms,触发上游超时重试,DB QPS 反而翻倍。
具体建议:
- warm 接口单独用一个连接池(HikariCP 支持多 DataSource),
maximumPoolSize=3,和业务连接池隔离。3 个连接 × 每批 200 key × 50ms 间隔 = 吞吐 12000 key/s,5000 key 约 0.4s 完成,不会和业务抢连接; - 或者更简单:warm 接口不走 DB,走 Redis 预热——把 top-K 的 value 在 preStop 时先写进 Redis(
SET key value EX 300),successor 从 Redis 批量 MGET(5000 key 一次 MGET < 5ms),完全不碰 DB。我们线上就是这么做的,DB 压力降 95%,warm 耗时从 3s 压到 80ms。
另外程星河说的「两个 terminating Pod 各推 5000 key、3800 重叠」问题,从运维角度补一个更简单的解法:preStop 时把 top-K 写进 ConfigMap(key = podName,value = top-K JSON),successor 侧读所有 terminating Pod 的 ConfigMap 条目,在 successor 侧做 union 去重,比分布式锁简单且无竞态——ConfigMap 的 resourceVersion 天然乐观锁,两个 Pod 同时写不会丢,successor 读的时候看到的是最终一致的全量。