用 Rust 从零搭一个 CDN 边缘节点:缓存失效比缓存命中难
回顾前面几个系统,它们在面对"最难的那部分"时,都找到了某种回避方式:
对象存储: 靠"不可变" —— 没有并发更新,缓存永不失效
版本控制: 靠"内容寻址" —— 没有任何东西会失效
调度器: 靠"最终收敛" —— 慢一点没关系,最后对就行
时序库: 靠"编码固化" —— 数据写下来就不改CDN 一个都借不到。
它缓存的东西:别人的 HTTP 响应 —— 随时可能变
它必须做到: 变了之后立刻生效(至少业务方这么要求)
它面对的流量:突发的、极度集中的(一个热搜能让一个对象被打几百万次)所以它只能硬扛两件事:失效,和回源风暴。 这篇讲的就是怎么扛。
第一步:边缘节点的三件事
① 缓存:把什么放在哪一层、按什么键存
↓
② 回源:不命中时去哪拿、怎么拿
↓
③ 失效:怎么让它变成"不能再用"三件事里,前两件都是"性能问题"——做不好就是慢。而第三件是"正确性问题"——做不好就是给用户看错误的内容。
而且第三件还有一个前两件不具备的难点:它是一个分布式动作。
缓存命中:本地决策(我这里有吗)
回源: 本地决策 + 一次远程请求
失效: ★ 必须通知"所有缓存了这个对象的地方"
而你不知道那是哪些地方 —— 这就是全部困难所在第二步:缓存键——最容易"串味"的地方
pub struct CacheKey {
/// ① 域名 —— 一个边缘节点服务成百上千个域名,不能少
pub host: String,
/// ② 路径
pub path: String,
/// ③ 查询字符串 —— 收不收进键,是个必须显式做的决定
pub query: QueryKey,
/// ④ 方法(通常只有 GET/HEAD 可缓存)
pub method: Method,
/// ⑤ Vary 指定的请求头 —— 缓存键的"运行时扩展"
pub vary: Vec<(String, String)>,
}每一维都是一次取舍,而且方向是相反的:
| 维度 | 少一维 | 多一维 |
|---|---|---|
| host | 不同网站的内容互相覆盖(串味) | —— |
| query | ?v=1 和 ?v=2 互相覆盖 |
命中率下降(?utm_source=x 之类把键打散) |
| 请求头 | 把 gzip 内容发给不支持 gzip 的客户端(乱码) | 命中率暴跌(客户端会发各种奇怪的头) |
"少一维"的危险性远大于"多一维" ——所以默认策略总是偏向"宁可多一维"。
Vary 是最容易出事的那一维
源站返回: Vary: Accept-Encoding
含义:同一个 URL,客户端说"我支持 gzip"和不支持,
应该得到不同的响应 —— 所以缓存里必须是两份。impl CacheKey {
/// 从请求里提取 Vary 指定的头,构成键的一部分
pub fn with_vary(&self, req: &Request, vary_headers: &[String]) -> Result<CacheKey> {
let mut key = self.clone();
for h in vary_headers {
if h == "*" {
// ★ Vary: * 表示"响应依赖的东西我无法枚举"
// 所以这个响应是不可缓存的 —— 这是一条必须实现的规则
return Err(Error::Uncacheable);
}
// 归一化:Accept-Encoding 的值可能是
// "gzip, deflate, br" 或者 "br,gzip" —— 语义相同但字符串不同
// 直接当键会导致"明明可以复用却分成了两份"
let value = normalize_header(h, req.header(h))?;
key.vary.push((h.clone(), value));
}
Ok(key)
}
}两个容易漏的点:
点一:Vary: * 必须被当成"不可缓存"。 它的语义是"这个响应取决于一堆我懒得枚举的东西",所以任何缓存都是不安全的。 忽略这个规则,会缓存出一个"看起来能复用、实际上只对某一个特定请求正确"的响应。
点二:头的值必须归一化。 Accept-Encoding: gzip, deflate 和 deflate, gzip 语义相同,但字符串不同。 如果直接拿原始字符串做键,同一个客户端的不同请求可能落到不同的缓存条目上——命中率凭空掉一截,而且没有任何告警。
而最危险的情况是"源站配了 Vary,但边缘节点忽略了它":
第一个请求:支持 br 的客户端 → 缓存里存了 brotli 内容
第二个请求:只支持 gzip 的客户端 → 命中!拿到了 brotli 内容
→ 客户端解不开 → 页面白屏
而边缘节点看起来"工作正常" —— 命中率很高(甚至更高了)。缓存键的每一次"精简"都是在赌"这一维不会有差异"。 赌赢的收益是命中率,赌输的代价是给用户返回错误内容。而且这个错误是概率性的——只在"两种类型的客户端都访问过同一个 URL"时才出现,本地测试几乎必然通过。
默认不把无关的头收进键
反过来说,把所有请求头都收进键也是错的:
常见的客户端请求头:
User-Agent(每个浏览器版本都不同)
Accept-Language(en-US,en;q=0.9,zh-CN;q=0.8 这种组合几乎无穷)
Cookie(每个用户都不同)
Referer(每个来源页面都不同)
如果这些都进键 → 每个用户一个缓存条目 → 命中率接近 0所以缓存的默认策略是"只收 Vary 显式声明的头"。 而这是源站的声明责任——源站说"我的响应和 Accept-Language 有关",它就必须给出 Vary: Accept-Language。如果没有给,那是源站的 bug,而不是缓存可以猜的。
实践中很多 CDN 提供"规范化"配置:
pub struct KeyNormalization {
/// 从查询串里剔除的追踪参数
pub strip_query: Vec<String>, // ["utm_source", "gclid", "fbclid"]
/// 排序后的查询串(避免顺序不同产生不同键)
pub sort_query: bool,
/// 是否忽略大小写的路径
pub case_insensitive_path: bool,
}这几个配置项的收益可以很大(尤其是剔除追踪参数),但它们的每一个都在"少一维"的方向上——所以必须由用户显式开启,而且必须有文档说明风险。
第三步:分级缓存——内存和磁盘的分工
L1(内存): 几 GB,纳秒级访问,每字节最贵
L2(磁盘): 几 TB,毫秒级访问,每字节最便宜分层的依据是"单位字节的命中收益",而这个收益和对象的大小、频率都有关。
pub struct EdgeCache {
/// L1:内存 —— 只放小对象
memory: LruCache<CacheKey, Arc<Vec<u8>>>,
/// L2:磁盘 —— mmap 读,sendfile 发
disk: DiskCache,
/// 单个对象进内存的大小上限
memory_object_limit: usize, // 通常 256KB ~ 1MB
}
impl EdgeCache {
pub async fn get(&mut self, key: &CacheKey, size: usize) -> Option<CacheEntry> {
// ① 先查内存
if let Some(data) = self.memory.get(key) {
return Some(CacheEntry::Memory(data));
}
// ② 再查磁盘
if let Some(entry) = self.disk.lookup(key).await? {
// ★ 只把"小对象"提升到内存
// 大对象留在磁盘,用 sendfile 直接发
if size <= self.memory_object_limit {
self.memory.put(key.clone(), entry.data.clone());
}
return Some(CacheEntry::Disk(entry));
}
None
}
}memory_object_limit 这个参数是必须的,理由是算术:
假设 L1 是 4GB:
如果允许 1GB 的视频进内存 → 4 个对象就把内存占满了
→ 而一个视频的流量虽然大,但"4 个对象"覆盖不了流量的长尾
→ 内存的收益被少数大对象吃光了
如果只允许 ≤ 256KB 的对象进内存:
→ 能放下 1.6 万个对象
→ 这些对象覆盖了绝大部分"高频小对象"(API 响应、小图、JS/CSS)
→ 命中率的贡献远大于那几个大视频"大对象不进内存"这个规则看起来是放弃了优化,实际上是优化。 因为内存的单位成本比磁盘高两三个数量级,所以它应该用在"每字节收益最高"的地方——而高频小对象恰好就是。
而磁盘层的关键是零拷贝:
impl DiskCache {
/// 直接把磁盘文件发给客户端,不经过用户态缓冲
pub async fn send_to(&self, entry: &DiskEntry, out: &mut TcpStream) -> Result<()> {
let file = File::open(&entry.path)?;
// sendfile:数据从页缓存直接到 socket,不复制到用户态
// 这是前面写过的零拷贝,在这里它决定了大文件的吞吐上限
sendfile(out, &file, entry.offset, entry.len)?;
Ok(())
}
}从磁盘读 1GB 发出去,如果经过用户态(read + write)会多两次内存拷贝;用 sendfile 则一次都不用在用户态停留。 在 CDN 这种"网络带宽就是天花板"的场景里,省掉的这几次拷贝常常直接决定能跑满多少带宽。
第四步:淘汰——为什么 CDN 特别适合 TinyLFU
淘汰策略的选择,完全取决于"访问分布的形状"。 而 CDN 的分布有一个非常明确的特征:
Zipf 分布(长尾):
排名前 1% 的对象 → 可能占据 80% 以上的请求
排名后 50% 的对象 → 加起来不到 5% 的请求
这意味着:
命中率的贡献几乎全部来自"一小撮热点"
而"剩下的一大堆"对命中率的贡献微乎其微在这个分布下,LRU 有一个致命弱点:
场景:一个爬虫(或者一次全站预取)顺序扫描了 100 万个对象
LRU 的行为:
每扫一个新对象 → 它就"最近被使用"了 → 插到队首
→ 100 万个真正有流量的热点对象被逐个挤出
→ 扫描结束后,命中率从 95% 掉到接近 0
→ 而这些热点对象需要重新"热"起来
这个问题叫"缓存污染"(cache pollution)。TinyLFU 的做法是给"准入"加一道闸门:
pub struct TinyLfuCache {
/// 主缓存:实际存对象的
main: LruCache<CacheKey, Entry>,
/// 频率估计:Count-Min Sketch,每个计数器 4 bit
sketch: CountMinSketch,
/// 准入窗口:新对象先在这里观察
window: LruCache<CacheKey, Entry>,
}
impl TinyLfuCache {
pub fn insert(&mut self, key: CacheKey, value: Entry) {
// ① 更新频率估计(一次很小的哈希计数)
self.sketch.increment(&key);
if self.main.len() < self.capacity {
self.main.put(key, value);
return;
}
// ② 找出"如果满了会被淘汰的那个"(受害者)
let victim = self.main.peek_lru().unwrap();
// ★ ③ 关键决策:新对象的频率 vs 受害者的频率
let new_freq = self.sketch.estimate(&key);
let victim_freq = self.sketch.estimate(victim);
if new_freq > victim_freq {
// 新对象更"值钱" → 淘汰受害者,接受新对象
self.main.remove(victim);
self.main.put(key, value);
}
// 否则:拒绝新对象 —— 这次扫描的内容一个都进不来
}
}那个 if new_freq > victim_freq 就是全部的关键。
爬虫扫描的场景下: 每个被扫描的对象频率都是 1(只被访问过一次),而受害者的频率是几百上千(它是真热点)。所以扫描的内容一个都进不来,热点完好无损。
LRU: 一次扫描 → 热点全被挤走 → 命中率崩
TinyLFU:一次扫描 → 新对象全部被拒绝 → 命中率几乎不变而 Count-Min Sketch 让这个判断变得极便宜:
| 精确计数(HashMap) | Count-Min Sketch | |
|---|---|---|
| 每个键的空间 | 至少 8~16 字节 + 哈希表开销 | 4 bit(0.5 字节) |
| 错误 | 无 | 只会高估(不会低估) |
| 100 万个对象的空间 | 约 16MB | 约 2MB |
"只会高估"这个方向很重要: Sketch 的误差是"把 A 的频率算成了 A + 一点 B 的频率"。所以它会让低频对象看起来比实际频率高一点——这意味着"拒绝低频对象"这个判断会略微保守,但不会把真热点误判成低频。 方向是对的。
"用空间换一个足够好的判断"是这一层设计的全部逻辑。 精确知道每个对象的频率是不必要的——因为准入决策只需要区分"这个对象比那个对象更值得留吗",而这只需要一个排序,不需要精确值。 用 4 bit 换掉 16 字节,得到的判断质量几乎一样。
第五步:一致性哈希——在多级缓存里才是必需的
先说清楚一个容易搞混的地方:边缘节点本身通常不做一致性哈希。
边缘节点(离用户最近的):
它缓存什么是"哪些请求恰好打到它"决定的
→ 客户端 DNS 解析到哪个节点,它就服务哪些请求
→ 它没法"选择"缓存什么
→ 所以它用 LRU/TinyLFU 做"局部最优",不做全局协调
中间层 / 汇聚层(如果有层级的话):
这一层是"为所有边缘节点服务的共享缓存"
→ 它可以选择"这个对象由我来缓存"
→ 这里才需要一致性哈希为什么中间层需要一致性哈希:
假设中间层有 100 个节点,客户端请求随机路由:
一个对象被缓存到节点 7
下一次请求路由到节点 42 → 未命中 → 回源
→ 命中率 = 1/100 = 1%
用一致性哈希:
object → 节点 7(确定性映射)
每一次请求都路由到节点 7 → 命中
→ 命中率 ≈ 100%(只要节点 7 活着且有空间)一致性哈希在这里的价值是"把一个随机的命中率变成一个确定的命中率"。 而它在前面的地方(分布式 KV、对象存储)解决的是"节点增减时的数据迁移量"——在缓存场景里,它的主要收益变成了命中率。
这也解释了"为什么缓存系统的一致性哈希实现通常更简单":
分布式 KV 的哈希环需要:
虚拟节点(均衡负载)
数据迁移协议(节点增减时搬数据)
副本(单节点故障不丢数据)
缓存的一致性哈希只需要:
虚拟节点(均衡)
✗ 不需要迁移 —— 节点挂了,缓存的东西本来就是"可以重新拉的"
✗ 不需要副本 —— 同上"数据可以重建"这个性质让缓存的分布式设计简单了一个数量级。 这也是缓存和存储最本质的区别——缓存丢失是性能问题,存储丢失是正确性问题。
一个设计需要多复杂,取决于"数据丢了会怎样"。 缓存可以随便丢、随便重建、随便不一致——只要最终能重新从源站拉回来。 所有"缓存一致性"的复杂度,都来自"我们不想每次都回源"这个性能诉求,而不是来自正确性。
但中间层还有一个必须面对的问题:缓存本身的高度不均衡。
Zipf 分布 + 哈希映射 = 热点节点的热点对象
排名第一的对象可能每秒被请求 100 万次
它落在节点 A 上 → 节点 A 的网卡打满
而节点 B 闲着哈希环解决不了单个热点对象的负载问题,因为它保证的是"同一个对象固定在同一个节点"——而固定就意味着无法分散。
解法是"热点探测 + 主动复制":
pub struct HotObjectReplicator {
/// 请求频率超过阈值的对象 → 额外复制到几个节点
hot: HashMap<[u8; 32], Vec<NodeId>>,
threshold: u64, // 比如每秒 10000 次
}
impl HotObjectReplicator {
/// 热点对象的请求可以走"复制节点"里的任意一个
pub fn nodes_for(&self, key_hash: &[u8; 32]) -> Vec<NodeId> {
self.hot.get(key_hash)
.cloned()
.unwrap_or_else(|| vec![self.ring.get(key_hash)])
}
}注意这打破了"同一个对象只有一个归属节点"这个不变量——换成"热点的对象有多个归属节点"。 而它是安全的,因为缓存内容是可重建的、同一个对象的多个副本内容相同(它来自同一个源站响应)。
"分片"和"复制"是两个正交的轴:分片解决"总量太大",复制解决"单点太热"。 而一个只做了分片的系统,一定会在遇到极端热点时被击穿——因为分片本质上是一个"确定性映射",而确定性映射意味着"无法分散压力"。
第六步:回源合并——CDN 最实用的一招
现在到了这篇最有用的一段代码。
先看问题的形状:
一个热门对象(比如首页的 banner 图)的缓存刚刚过期。
接下来的 1 秒里:
节点上到达了 5000 个请求这个对象的请求
每一个都发现"缓存里没有了"
每一个都去回源
结果:源站在 1 秒内收到 5000 个完全相同的请求
而这些请求的答案是一模一样的这就是"回源风暴"(thundering herd)。 它的经典触发时刻恰好是"缓存刚失效的那一瞬"——因为缓存的作用就是把流量挡在源站之外,而它一失效,所有被挡住的流量同时涌进来。
pub struct SingleFlight {
/// 正在回源中的对象:key → 等待中的订阅者
inflight: Mutex<HashMap<CacheKey, Vec<oneshot::Sender<Result<Entry>>>>>,
}
impl SingleFlight {
pub async fn fetch<F, Fut>(
&self,
key: CacheKey,
do_fetch: F,
) -> Result<Entry>
where
F: FnOnce() -> Fut,
Fut: Future<Output = Result<Entry>>,
{
let (tx, rx) = oneshot::channel();
// ★ 用一次加锁来决定"我是 leader 还是 follower"
let is_leader = {
let mut map = self.inflight.lock().unwrap();
match map.entry(key.clone()) {
Entry::Occupied(mut e) => {
e.get_mut().push(tx);
false // 有人已经在回源了,我排队
}
Entry::Vacant(e) => {
e.insert(vec![tx]);
true // 我是第一个,我去回源
}
}
};
if is_leader {
// leader:真的去回源
let result = do_fetch().await;
// ★★ 最关键的一步:无论成功还是失败,都必须唤醒所有等待者
let waiters = {
let mut map = self.inflight.lock().unwrap();
map.remove(&key).unwrap_or_default()
};
for w in waiters {
// 用 clone 分发结果;失败也要分发(否则等待者永远挂着)
let _ = w.send(result.clone());
}
result
} else {
// follower:等 leader 的结果
rx.await.map_err(|_| Error::LeaderDropped)?
}
}
}这段代码里有四个必须做对的点,每一个漏掉都会产生一个难以定位的故障:
点一:失败也必须唤醒等待者
// ✗ 错误:失败就直接返回
if is_leader {
let result = do_fetch().await;
let waiters = self.inflight.lock().unwrap().remove(&key).unwrap_or_default();
if result.is_err() {
return result; // ← 等待者的 sender 被 drop 了,它们会收到 RecvError
}
for w in waiters { w.send(result.clone()); }
}等待者拿到 RecvError 之后会发生什么?取决于它们的实现:
好的实现:把 RecvError 当成"我自己再去回源一次" → 5000 个请求又会同时回源
坏的实现:把 RecvError 当成"上游出错了" → 返回 502
最坏的实现:await 永远不返回(如果 sender 被泄漏了)正确做法是把"失败"也当成一个结果分发出去(就像上面那段代码),这样所有等待者拿到的是同一个错误,而且不会重新触发回源。
这个模式和前面写消息队列去重、DNS 去重时是同一个:状态机的每一个出口都必须有对应的动作。 而"错误"是一个最容易被漏掉的出口。
点二:等待者必须有自己的超时
// ✗ 错误:等待者无限期等待 leader
let entry = single_flight.fetch(key, || upstream.get(key)).await?;
// ✓ 正确:等待者自己也有超时预算
let result = tokio::time::timeout(self.wait_timeout,
single_flight.fetch(key, || upstream.get(key))
).await;
match result {
Ok(Ok(entry)) => Ok(entry),
Ok(Err(e)) => Err(e),
Err(_) => {
// ★ leader 卡住了(比如它的上游超时比我们还长)
// 这时候不能再等了 —— 返回"暂时不可用"
Err(Error::UpstreamTimeout)
}
}为什么等待者也要有超时? 因为 leader 的回源时间是不可控的:
leader 去回源 → 源站很慢 → leader 等 60 秒
而等待者的客户端超时可能是 10 秒
如果等待者没有自己的超时 → 客户端 10 秒后放弃
→ 但服务端的等待者还挂着,占着连接和内存
→ 60 秒后 leader 回来了,把结果发给一堆"已经没人在等"的 sender"发起方超时了但操作还在跑"是一个反复出现的资源泄漏形态。 所以每一个 await 上游的地方都必须有超时,而且这个超时要比调用方的超时短。
点三:合并不该跨 URL
对象 A: /logo.png?v=1
对象 B: /logo.png?v=2 ← 内容可能完全相同
能不能把 A 和 B 的请求合并?
✗ 不能。因为:
① 缓存键不同 → 结果要分别存进两个键
② 响应的内容可能不同(v=2 可能真的改了)
③ 如果合并了,你会用 A 的响应去回答 B —— 而这是"串味"合并的粒度必须和缓存键的粒度一致。 更细会串味,更粗会失去收益。
点四:有副作用的请求绝对不能合并
fn is_mergeable(req: &Request) -> bool {
// ★ 只合并幂等的、可缓存的方法
matches!(req.method, Method::GET | Method::HEAD)
// 而且不能带"要求不缓存"的语义
&& !req.has_header("range") // Range 请求范围可能不同,见第九步
&& !req.cache_control().no_store()
}为什么 POST 绝对不能合并:
两个用户同时提交订单 → 都是 POST /order
如果合并:第二个用户拿到第一个用户的订单号
→ 这不是"少了一次请求",这是"把别人的钱扣了""合并"这个优化的前提是"这两个请求要的东西完全相同,而且没有副作用"。 一旦违反,它就从"优化"变成了"错误"。
收益有多大
把两个机制叠起来看:
假设缓存命中率 90%(也就是 10% 的请求要回源):
没有合并:
一个对象失效瞬间 5000 个请求 → 5000 次回源
有合并:
第一个请求去回源,其余 4999 个等待
→ 1 次回源
回源量的差别:5000 倍。而这 5000 倍的差别,恰好发生在"源站最脆弱"的时刻(缓存失效的那一瞬)。 所以回源合并不只是省流量——它是"缓存这个机制本身能不能成立"的前提。
如果没有回源合并,缓存就会变成一个"帮倒忙"的东西。 因为缓存的作用是把流量聚合成一个点,而**"过期的那一瞬间,这个聚合的流量会同时释放"**——聚合得越有效,释放的冲击越大。回源合并就是用来吸收这次释放的。
第七步:失效——怎么让"立刻生效"变得可能
缓存失效有两个层次,必须先分清楚:
被动失效(TTL):
到期后自然不可用
✓ 实现极简单,不需要任何通知
✗ 有延迟(最坏等于 TTL 长度)
主动失效(purge):
收到通知后立刻不可用
✓ 立刻生效
✗ 需要通知"所有缓存了这个对象的节点"主动失效的困难在于"你不知道该通知谁":
一个对象可能被缓存了:
某个边缘节点(因为刚好有用户从那里请求过)
中间层的某个节点(由一致性哈希决定 —— 这个你可以算出来)
某个客户端的浏览器(完全不受你控制)
...
所以"广播 purge" 要通知多少节点?
→ 所有节点。而一个大型 CDN 的节点数可能是几千。
→ 一次 purge 就是几千次通知。三种 purge 的实现,代价递减
| 方案 | 做法 | 问题 |
|---|---|---|
| 全网广播 | 通知所有节点"删掉这个键" | 通知量 = 节点数;节点越多越慢 |
| 哈希定位 | 只通知"该对象的归属节点"(一致性哈希) | 边缘节点是自由缓存的,不适用 |
| 版本号 / 内容哈希 | 把版本放进键,不需要失效 | 需要能控制 URL |
第三种方案是唯一能让"失效"这个问题消失的方案,也是所有大规模 CDN 事实上的主策略:
静态资源(JS / CSS / 图片 / 字体):
文件名里带内容哈希:app.a3f9c2.js
Cache-Control: max-age=31536000, immutable
→ 内容变了就是新文件名 → 新 URL → 新缓存键
→ 永远不需要 purge,而且可以设置一年的 TTL
页面(HTML):
不能带内容哈希(URL 要对用户友好、要能被收藏)
→ 用短 TTL(比如 60 秒)+ stale-while-revalidate
→ 靠时间解决失效,接受最多几十秒的延迟
接口(API 响应):
通常是不可缓存的(或者极短 TTL)
→ 靠业务层的版本号 / 事件通知这张表就是"如何让失效变得不需要"这个问题的完整答案。
最可靠的失效机制是"没有东西需要失效"。 内容哈希把"修改一个对象"变成了"创建一个新对象"——而新对象天然不需要失效,因为它是新的键。 这是内容寻址的思路在 HTTP 缓存场景的应用,也是为什么现代前端构建工具都要给文件名加哈希。
purge 的两种语义:删除 vs 标记过期
这是主动失效里一个必须显式选择的语义:
| 语义 | 实现 | 失效瞬间的行为 |
|---|---|---|
| 删除(delete) | 从缓存里移除这个键 | 未命中 → 必须回源 → 回源失败就报错 |
| 标记过期(expire) | 保留内容,但标记为"需要重新验证" | 命中的同时后台回源刷新 → 回源失败还能用旧内容 |
pub enum PurgeResult {
/// 直接删掉
Removed,
/// 标记为"过期但仍可用" —— 下一次访问会触发后台刷新
MarkedStale,
}
impl EdgeCache {
/// ★ 默认用"标记过期"而不是"删除"
pub fn purge(&mut self, key: &CacheKey, mode: PurgeMode) -> PurgeResult {
match mode {
PurgeMode::Hard => {
self.memory.remove(key);
self.disk.remove(key);
PurgeResult::Removed
}
PurgeMode::Soft => {
// 保留数据,只改一个标记
if let Some(entry) = self.memory.get_mut(key) {
entry.state = EntryState::Stale;
}
PurgeResult::MarkedStale
}
}
}
}"软 purge"看起来像是"没有真的失效",但它的实际语义要好得多:
硬 purge 之后:
下一个请求 → 未命中 → 回源 → 源站此刻如果故障 → 502
软 purge 之后:
下一个请求 → 命中旧内容(立刻返回)→ 同时后台回源
→ 源站正常:用户在下一个请求拿到新内容
→ 源站故障:用户继续拿到旧内容(而不是 502)代价是"旧内容多存在了一个请求的时长"。 而在绝大多数业务里,"晚一个请求生效"和"源站抖动时全站 502"相比,前者显然更划算。
第八步:stale-while-revalidate 和 stale-if-error
软 purge 的思路已经被标准化成了两个响应头。
Cache-Control: max-age=60, stale-while-revalidate=600, stale-if-error=86400它的语义是把"缓存过期"这一个时刻,拆成了三个阶段:
0s ────────── 60s ────────────────────── 660s ────────────── 86460s
│ │ │ │
新鲜期 过期,但 超过 stale- 超过 stale-
命中直接返回 可以"先返回旧的 while-revalidate if-error
+ 后台刷新" → 必须回源等待 → 只能回源impl EdgeCache {
pub async fn serve(&mut self, key: &CacheKey, entry: &Entry, now: Instant)
-> Result<Response>
{
let age = now - entry.stored_at;
// ① 新鲜期:直接返回,没有任何额外动作
if age < entry.max_age {
return Ok(entry.to_response());
}
// ② stale-while-revalidate 期内:
// 立刻返回旧内容,同时后台发起刷新(不阻塞这个请求)
if age < entry.max_age + entry.swr {
self.spawn_background_revalidate(key.clone());
return Ok(entry.to_response());
}
// ③ 超出 swr:必须回源等待
match self.fetch_from_origin(key).await {
Ok(fresh) => {
self.store(key.clone(), fresh.clone());
Ok(fresh.to_response())
}
Err(e) => {
// ④ 回源失败:如果还在 stale-if-error 期内,继续用旧内容
if age < entry.max_age + entry.sie {
// ★ 这是 CDN 作为"源站保护层"的核心
self.metrics.record_stale_served(key);
Ok(entry.to_response())
} else {
Err(e)
}
}
}
}
}第 ④ 步是这一整篇文章里最有价值的一段逻辑。
因为它改变了缓存的角色:
没有 stale-if-error |
有 stale-if-error |
|---|---|
| 缓存 = 性能优化 | 缓存 = 可用性机制 |
| 源站故障 → 缓存过期 → 全站不可用 | 源站故障 → 缓存继续服务 |
| 源站的可用性 = 系统的可用性 | 源站的可用性 < 系统的可用性 |
举例:源站可用性 99.9%(一个月宕机 43 分钟)
缓存 TTL 60s + stale-if-error 86400(一天)
源站宕机 10 分钟期间:
没有 stale-if-error:用户全部看到错误页(10 分钟不可用)
有 stale-if-error:用户全部拿到最多 10 分钟前的旧内容
→ 对大部分业务来说,这和"正常"没有区别
系统的可用性从 99.9% 提升到了 99.99% 以上 ——
而实现方式只是"回源失败时不要报错,继续用旧的"。而它有一个必须被明确接受的前提:用户可以接受"旧数据"。
适合 stale-if-error:
商品列表、文章内容、图片、JS/CSS
不适合:
账户余额、订单状态、库存数量
(这些必须返回错误,而不是过期的数字)把"缓存的过期时间"拆成"新鲜期"和"可用期"两个概念,是让缓存从"加速器"变成"保护层"的关键一步。 而这一步的决策权在源站——因为只有源站知道"这份数据旧一点能不能接受"。 所以这两个头必须由源站显式声明,而不是缓存自己猜。
第九步:Range 请求与分片缓存
视频、大文件、以及"断点续传",都依赖 HTTP 的 Range 请求。
客户端: GET /video.mp4
Range: bytes=1048576-2097151 ← 只要第 1MB 到第 2MB
问题:缓存里可能只有这个文件的前 10MB(因为之前的用户只读了开头)
而这次请求正好落在这 10MB 内 → 能命中
如果是 bytes=50000000-51000000 → 完全没有 → 要回源如果把"整个对象"当成缓存的最小单位:
用户只看了一个视频的前 30 秒 → 要把整个 2GB 都缓存下来吗?
✗ 不缓存 → 每次都要回源
✗ 缓存全量 → 一个用户的 30 秒观看消耗 2GB 磁盘
所以必须"按片段缓存"。pub struct ChunkedCache {
/// 对象 → 它已经被缓存的片段列表
objects: HashMap<CacheKey, Vec<CachedChunk>>,
/// 片段大小(固定)
chunk_size: u64, // 比如 1MB
}
pub struct CachedChunk {
/// 这个片段覆盖的字节范围
pub start: u64,
pub end: u64,
/// 在磁盘上的位置
pub location: DiskLocation,
/// 这个片段的校验和 —— 保证片段确实是"这一段"
pub checksum: u32,
}分片缓存把"离线的字节区间"变成了可管理的结构:
请求:bytes=0-3145727(前 3MB,chunk_size = 1MB)
→ 涉及 3 个 chunk
→ 已缓存的 chunk 直接读,缺失的回源
→ 回源时只请求缺失的那一段(Range 请求)—— 不是整个对象代价是键的数量和元数据开销:
| 整对象缓存 | 分片缓存 | |
|---|---|---|
| 一个 2GB 文件的条目数 | 1 | 2048 |
| 元数据内存 | 几十字节 | 几十 KB |
| 能缓存"只看了一部分"的对象 | ✗ | ✓ |
| 支持断点续传 | ✗ | ✓ |
所以分片大小是一个明确的取舍:
| chunk_size | 元数据开销 | 粒度 |
|---|---|---|
| 64KB | 极大(2GB 文件 3 万片) | 很细,但元数据压垮内存 |
| 1MB | 适中 | 常用的选择 |
| 16MB | 小 | 粒度粗,"只看了开头"的情况缓存效率低 |
而分片缓存还有一个必须做的小优化:合并相邻片段。
impl ChunkedCache {
/// 定期把相邻的小片段合并成大片段 —— 减少元数据和磁盘碎片
pub fn compact_chunks(&mut self, key: &CacheKey) {
let Some(chunks) = self.objects.get_mut(key) else { return };
chunks.sort_by_key(|c| c.start);
let mut merged = Vec::new();
let mut current: Option<CachedChunk> = None;
for chunk in chunks.drain(..) {
match &mut current {
// ★ 只有"首尾相接"才合并,有洞就不能合并
Some(c) if c.end == chunk.start => {
c.end = chunk.end;
// 注意:合并后的校验和必须重算
c.checksum = 0; // 标记为"需要重算"
}
Some(c) => {
merged.push(std::mem::replace(c, chunk));
}
None => current = Some(chunk),
}
}
if let Some(c) = current { merged.push(c); }
*chunks = merged;
}
}"有洞就不能合并"这一条由 c.end == chunk.start 保证。 如果两个片段之间还有没缓存的字节,合并它们会产生一个"带洞的片段"——而这个片段被当成"连续数据"返回给客户端,就会把没缓存的字节当成有效内容发出去。
所有"把离散的东西表示成区间"的地方,都有同一个必须守住的约束:区间必须是真的连续的。 而破坏它的方式总是一样的:先按某个顺序遍历、然后合并相邻项,却忘了检查"相邻"的真正含义是不是"无间隙"。
结论
这个系统的形状是:
┌─ host 必进键(串味)
缓存键 ────────┼─ query / Vary 的每一维都是取舍
└─ 默认方向:宁可多一维(少一维是正确性问题,多一维只是性能)
┌─ L1 内存:只放小对象(单位字节收益最高)
分级缓存 ──────┴─ L2 磁盘:mmap + sendfile(大文件靠零拷贝)
┌─ 准入和淘汰是两个决策(TinyLFU 比 LRU 多一个"准入")
淘汰 ─────────┼─ Count-Min Sketch 用 4bit/项 换一个"够好的排序"
└─ 关键收益:抗扫描(冷数据进不来,热点不被挤走)
┌─ 一致性哈希:把命中率从 1/N 变成接近 1
放置 ─────────┼─ 但它无法分散单个热点 → 需要"热点复制"
└─ 分片解决"总量",复制解决"单点"
┌─ leader 做事,follower 排队
回源合并 ──────┼─ 失败也必须唤醒所有等待者(最易漏)
├─ 等待者要有自己的超时
└─ 只合并幂等、可缓存、同键的请求
┌─ 最好的失效是"不需要失效"(内容哈希 / 版本号)
失效 ─────────┼─ 主动 purge 默认用"软"的(标记过期而非删除)
└─ 全网广播的代价 = 节点数,所以尽量靠键设计回避
┌─ 把过期拆成"新鲜期 + 可用期"
可用性 ────────┼─ stale-while-revalidate:先返回旧的,同时后台刷新
└─ stale-if-error:回源失败时继续用旧的
→ 缓存从"加速器"变成"源站的保护层"
└─ 分片缓存:相邻才合并(区间必须真的连续)五条最值得记住的判断:
- 缓存键"少一维"是正确性问题,"多一维"只是性能问题。 所以默认方向永远是宁可多一维。
- 回源合并里,失败也必须唤醒等待者。 漏掉这一条,一次上游抖动就会让等待队列永久堆积。
- 最好的失效策略是让失效不存在。 内容哈希把"修改"变成"新建",于是没有任何东西需要被失效。
- 软 purge 比硬 purge 好。 "晚一个请求生效"换"源站抖动时不全站 502",永远是划算的。
stale-if-error把缓存从加速器变成保护层。 它能让系统的可用性高于源站的可用性——而代价只是"用户可能看到旧数据"。
这五条的共同点是:它们都在"性能"和"正确性"之间划一条明确的线,然后把优化全部放在性能那一侧。 一旦越线(少一维键、硬 purge、丢消息),优化就变成了错误的来源——而这类错误的特点是"大部分时候都对"。
下一篇换到一个把"正确性"和"成本"同时推到极致的场景(可观测后端),那里没有用户请求可以被丢弃,只有数据可以被丢——而"丢哪一个"是唯一的设计问题。