返回文章列表

用 Rust 从零搭一个 CDN 边缘节点:缓存失效比缓存命中难

1148 字·9 分钟阅读
Rust从零造轮子内容分发

回顾前面几个系统,它们在面对"最难的那部分"时,都找到了某种回避方式:

对象存储:  靠"不可变" —— 没有并发更新,缓存永不失效
版本控制:  靠"内容寻址" —— 没有任何东西会失效
调度器:    靠"最终收敛" —— 慢一点没关系,最后对就行
时序库:    靠"编码固化" —— 数据写下来就不改

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:回源失败时继续用旧的
                 → 缓存从"加速器"变成"源站的保护层"
 
              └─ 分片缓存:相邻才合并(区间必须真的连续)

五条最值得记住的判断:

  1. 缓存键"少一维"是正确性问题,"多一维"只是性能问题。 所以默认方向永远是宁可多一维。
  2. 回源合并里,失败也必须唤醒等待者。 漏掉这一条,一次上游抖动就会让等待队列永久堆积。
  3. 最好的失效策略是让失效不存在。 内容哈希把"修改"变成"新建",于是没有任何东西需要被失效。
  4. 软 purge 比硬 purge 好。 "晚一个请求生效"换"源站抖动时不全站 502",永远是划算的。
  5. stale-if-error 把缓存从加速器变成保护层。 它能让系统的可用性高于源站的可用性——而代价只是"用户可能看到旧数据"。

这五条的共同点是:它们都在"性能"和"正确性"之间划一条明确的线,然后把优化全部放在性能那一侧。 一旦越线(少一维键、硬 purge、丢消息),优化就变成了错误的来源——而这类错误的特点是"大部分时候都对"。

下一篇换到一个把"正确性"和"成本"同时推到极致的场景(可观测后端),那里没有用户请求可以被丢弃,只有数据可以被丢——而"丢哪一个"是唯一的设计问题。