返回文章列表

用 Rust 从零搭一个 DNS 服务器:TTL 不是缓存时长,是缓存上限

1010 字·8 分钟阅读
Rust从零造轮子网络协议

前面的系统都在处理"数据"。这一篇处理的是一种更微妙的东西:一个你明知道会过期的答案,要不要把它记下来,记多久。

DNS 的全部难度都在这句话里。协议本身很简单(一个请求一个响应),但**"能不能缓存、缓存多久、过期了怎么办"这套语义,比报文格式难得多。**

而且它有个特别之处:这些语义是上游通过响应本身告诉你的。 你不是在自己设计缓存策略,你是在执行别人的策略。

第一步:报文解析——一个为省字节而设计的格式

DNS 头是固定 12 字节:

pub struct Header {
    pub id: u16,          // 事务 id,用来匹配请求和响应
    pub flags: u16,
    pub qdcount: u16,     // question 数量
    pub ancount: u16,     // answer 数量
    pub nscount: u16,     // authority 数量
    pub arcount: u16,     // additional 数量
}
 
impl Header {
    /// QR: 0 查询 / 1 响应
    pub fn is_response(&self) -> bool { self.flags & 0x8000 != 0 }
    /// TC: 响应被截断,客户端应该改用 TCP 重试
    pub fn is_truncated(&self) -> bool { self.flags & 0x0200 != 0 }
    /// RD: 期望递归
    pub fn recursion_desired(&self) -> bool { self.flags & 0x0100 != 0 }
    /// RA: 服务器支持递归
    pub fn recursion_available(&self) -> bool { self.flags & 0x0080 != 0 }
    /// RCODE: 4 位返回码
    pub fn rcode(&self) -> Rcode { Rcode::from(self.flags & 0x000F) }
}

注意 id 只有 16 位。 这意味着上游并发查询最多 65536 个还没回来的请求——超了就会 id 冲突,把 A 请求的响应错配给 B 请求。这不是理论问题:一个高频解析器不加限制地向上游并发,几秒内就能撞上这个上限。

域名压缩:3 个字节换来的复杂

为了省空间,DNS 报文里的域名可以用"指针"表示:

问题:www.example.com
答案:www.example.com A 1.2.3.4
      ↑ 这里不重复写一遍,而是写一个指向前面那个名字的偏移量
 
编码:0xC0 0x0C     ← 高两位是 11,剩下 14 位是偏移量 12

这个设计给解析器埋了两个坑:

坑一:指针可以指向自己,造成无限循环。 一个恶意构造的报文可以让解析器在几个偏移量之间反复跳。

坑二:指针可以指向"还没解析到的地方",甚至指向报文之外。

标准做法是限制跳转次数 + 严格边界检查:

const MAX_JUMPS: usize = 32;   // 常见的实现上界
 
pub fn parse_name(buf: &[u8], mut pos: usize) -> Result<(Name, usize)> {
    let mut labels = Vec::new();
    let mut jumps = 0;
    // 真实位置:指针跳转后,调用方要接着跳转前的位置往下读
    let mut consumed_end: Option<usize> = None;
 
    loop {
        if pos >= buf.len() {
            return Err(Error::Truncated);
        }
 
        let len = buf[pos];
 
        if len == 0 {
            // 根标签,名字结束
            pos += 1;
            if consumed_end.is_none() {
                consumed_end = Some(pos);
            }
            break;
        }
 
        if len & 0xC0 == 0xC0 {
            // 压缩指针
            if pos + 1 >= buf.len() {
                return Err(Error::Truncated);
            }
            let offset = (((len as usize) & 0x3F) << 8) | buf[pos + 1] as usize;
 
            if consumed_end.is_none() {
                consumed_end = Some(pos + 2);   // 指针本身占 2 字节
            }
 
            jumps += 1;
            if jumps > MAX_JUMPS {
                return Err(Error::TooManyJumps);   // 明确的错误,不是静默截断
            }
            if offset >= buf.len() {
                return Err(Error::PointerOutOfBounds);
            }
 
            pos = offset;
            continue;
        }
 
        if len as usize > 63 {
            // 单个 label 最长 63 字节
            return Err(Error::LabelTooLong);
        }
 
        let end = pos + 1 + len as usize;
        if end > buf.len() {
            return Err(Error::Truncated);
        }
 
        // 这里可以借用 &buf[pos+1..end],但为了后面统一处理,先复制
        labels.push(buf[pos + 1..end].to_vec());
        pos = end;
    }
 
    Ok((Name::from_labels(labels), consumed_end.unwrap()))
}

三个细节值得单独说:

第一,consumed_end 是必须的。 指针出现之后,"这个名字在哪里结束"和"解析完之后从哪继续"变成了两个不同的位置——很多手写解析器在这里出错,把后续的记录整个读错位。

第二,jumps 上限必须是一个明确的错误,不能是静默截断。 如果超限了就返回一个"部分解析的名字",你会得到一个看起来合法的域名,然后把它缓存起来。这比直接报错危险得多。

第三,MAX_JUMPS = 32 是一个取舍。 太大的话单次解析可能被拖慢(拒绝服务);太小的话正常的深层域名会解析失败。真实实现大多用"跳转不增加 label 数"或类似的约束,比单纯计数更严谨。

报文解析是所有协议实现的共同考点:边界检查不是防御性编程,而是正确性的一部分。 讲零拷贝的那篇、讲 WebSocket 帧协议的那篇,栽的地方都是同一类——长度字段来自不可信输入,而代码信任了它。

能不能零拷贝?

理论上应该可以:

/// 解析结果借用原始缓冲区 —— 理想情况
pub struct ParsedName<'a> {
    labels: Vec<&'a [u8]>,
}

但压缩指针破坏了这条路。 因为一个名字的各个 label 可能分散在报文的任意位置,"零拷贝的名字"只能表示成"一串指向原缓冲区的切片",也就是一个 Vec<&[u8]>——还是要分配。

所以真实的 DNS 实现通常不追求名字解析的零拷贝,而是:

环节 是否零拷贝 说明
读取报文 是 用 mmap/recv 直接读进缓冲区
解析名字 否 压缩指针让切片表达不了,只能复制
转发响应 是 整个缓冲区直接转发(sendfile / writev)

真正值得零拷贝的是"转发路径",不是"解析路径"。 因为解析只发生一次,而转发可能要把同一个报文发给几十个下游——这才是零拷贝真正能省下大钱的地方。

第二步:名字索引——为什么要倒过来存

一个递归解析器要维护"哪些域名归哪个上游管"(转发区配置),还要做最长后缀匹配。最自然的做法是把域名反转后再存:

原始:  www.api.example.com
反转:  com.example.api.www

反转之后,"最长后缀匹配"就变成了"最长前缀匹配"——而这个正好是 Trie 的强项。

pub struct NameTrie {
    /// 双数组 Trie,但键是反转后的 label 序列
    base: Vec<i32>,
    check: Vec<i32>,
    /// 每个节点对应一个 label,而不是一个字符
    node_labels: Vec<Box<[u8]>>,
    /// 命中某个前缀时,它对应的转发目标
    values: HashMap<usize, ForwardZone>,
}

注意这里 Trie 的边是"label"而不是"字节"。 域名天然是按 label 分层的(com / example / www),按 label 建 Trie 的深度是个位数,按字节建 Trie 的深度是几十——后者会把缓存行浪费在拆字符上。

但这个 Trie 和普通的前缀树有两个不同点:

第一,大小写不敏感。 DNS 的名字比较是 ASCII case-insensitive 的,所以入库前必须统一规范化(通常转小写)。否则 Example.COM 和 example.com 会命中不同的节点——而且这个 bug 只在大小写混用的输入下出现,测试里很难覆盖。

第二,有通配符。 *.example.com 这种配置要求"如果具体名字没命中,就往上找通配符节点":

impl NameTrie {
    pub fn longest_match(&self, name: &Name) -> Option<&ForwardZone> {
        let mut node = self.root();
        let mut best: Option<&ForwardZone> = None;
        // 记录沿途遇到的通配符候选,因为通配符的优先级低于具体匹配
        let mut wildcard: Option<(usize, &ForwardZone)> = None;
 
        for label in name.reversed_labels() {
            match self.child(node, label) {
                Some(next) => {
                    node = next;
                    if let Some(z) = self.values.get(&node) {
                        best = Some(z);
                    }
                    // 顺路记下 "*" 子节点
                    if let Some(w) = self.child(node, b"*").and_then(|n| self.values.get(&n)) {
                        wildcard = Some((label.len(), w));
                    }
                }
                None => break,
            }
        }
 
        // 具体匹配优先;没有具体匹配才回落到通配符
        best.or(wildcard.map(|(_, z)| z))
    }
}

"具体匹配优先于通配符"这条规则听起来显然,但它在 Trie 上的实现要求你沿途记录候选。 只做"贪心往下走,走到走不动为止"的话,www.example.com 有具体配置时你会在中途先撞上 *.example.com 并返回它——一个纯 Trie 写法几乎必然踩的坑。

匹配规则的优先级不能靠数据结构的遍历顺序来隐式表达。 Trie 的遍历顺序是"从短到长"或者"从长到短",而业务规则的优先级可能完全是第三种顺序。把"候选收集"和"优先级判定"分成两步,是唯一稳妥的写法。

第三步:查询路径——为什么必须同时实现 UDP 和 TCP

DNS 主要跑在 UDP 上,原因很直接:一次问答只有两个报文,为它建一条 TCP 连接的话,握手的开销比查询本身还大。

但 UDP 有个硬限制:传统 DNS 响应最大 512 字节。 超了怎么办?

pub enum Transport {
    Udp,
    Tcp,
}
 
impl Server {
    fn respond(&self, req: &Request, answer: &Response, transport: Transport) -> Result<Vec<u8>> {
        let encoded = encode_response(answer)?;
 
        match transport {
            Transport::Udp if encoded.len() > self.max_udp_size => {
                // 关键:不是截断,而是置 TC 位,让客户端改用 TCP 重试
                let mut truncated = encode_header_only(answer)?;
                truncated.set_truncated(true);   // TC = 1
                Ok(truncated)
            }
            _ => Ok(encoded),
        }
    }
}

TC 位是"换个协议再来"的信号,不是"响应不完整"的错误。

这里有一个极容易写错的细节:置了 TC 的响应应该只包含头(可能加问题区),而不是"截断的答案"。 如果返回了部分答案,客户端可能会把不完整的记录当成有效数据。正确做法是让客户端明确知道"这次没用,请用 TCP 重来"。

TCP 上的 DNS 和 UDP 只差一层:报文前面多了 2 字节长度前缀。

impl Server {
    fn handle_tcp(&self, stream: &mut TcpStream) -> Result<()> {
        loop {
            // 长度前缀:2 字节,大端
            let mut len_buf = [0u8; 2];
            match stream.read_exact(&mut len_buf) {
                Ok(()) => {}
                Err(e) if e.kind() == ErrorKind::UnexpectedEof => break,  // 正常关闭
                Err(e) => return Err(e.into()),
            }
            let len = u16::from_be_bytes(len_buf) as usize;
 
            if len == 0 || len > self.max_tcp_message {
                return Err(Error::BadLength(len));
            }
 
            let mut buf = vec![0u8; len];
            stream.read_exact(&mut buf)?;
            let response = self.handle_query(&buf, Transport::Tcp)?;
            stream.write_all(&(response.len() as u16).to_be_bytes())?;
            stream.write_all(&response)?;
        }
        Ok(())
    }
}

注意 loop——TCP 上一条连接会跑多个查询,不能答完一个就关。 而且必须限制单连接的总查询数或闲置时长,否则就是一个连接耗尽资源的入口(这和长连接的通用坑是同一类)。

EDNS0 改变了这个上限: 客户端可以在 OPT 记录里声明自己支持更大的 UDP 报文(通常 1232 或 4096 字节)。但服务器必须自己再设一个上限——因为"客户端声称支持 4096"和"网络真的能过 4096"是两回事,分片丢弃(fragmentation)会让大 UDP 报文静默消失。

"客户端说它支持"永远不能当作"链路能承载"。 这是 MTU 相关问题的统一形态:发送方看到的成功,只是"本地网卡接受了",和"对方收到了"没有必然关系。 所以响应越大,越应该退回 TCP——不是为了性能,是为了可达性。

第四步:缓存——TTL 的语义是这篇的核心

现在到全文最重要的部分。

先看一个几乎每个自研 DNS 都会踩的坑

// 错误写法:原样返回上游的 TTL
pub fn respond_from_cache(&self, entry: &CacheEntry) -> Response {
    let mut resp = entry.to_response();
    // resp 里的 TTL 就是上游给的 300
    resp
}

这段代码看起来完全正常,但它有一个会累积的 bug。

设想一条链:客户端 → 我的解析器 → 上游。

  • 上游说 TTL=300
  • 我缓存了 300 秒
  • 第 200 秒时客户端来查,我把 TTL=300 原样返回
  • 客户端于是把这份"已经存在了 200 秒"的数据又缓存了 300 秒

结果:数据最多可以存在 500 秒,超过上游允许的 300 秒。 更糟的是,如果下游也是一层解析器,每多一跳就多叠一次 TTL,新鲜度承诺被彻底架空。

正确做法:返回"剩余 TTL",而不是"原始 TTL"。

impl CacheEntry {
    /// 剩余的 TTL:从 300 开始往下减,到 0 就是过期
    pub fn remaining_ttl(&self, now: Instant) -> u32 {
        self.expires_at
            .checked_duration_since(now)
            .map(|d| d.as_secs() as u32)
            .unwrap_or(0)
    }
 
    /// 返回给下游时,必须用剩余 TTL
    pub fn to_response(&self, now: Instant) -> Response {
        let ttl = self.remaining_ttl(now);
        let mut resp = self.records.clone();
        for r in &mut resp.records {
            // 用 min 更保守:如果不同记录 TTL 不同,取最小的那个
            r.ttl = r.ttl.min(ttl);
        }
        resp
    }
}

这就引出了这篇文章真正的主题句:

TTL 不是"你应该缓存多久",而是"上游允许你最多缓存多久"。

这两句话的差别,是整个缓存设计的分界线:

理解 后果
"TTL 是我该缓存的时间" 你把它当指令,只能照做
"TTL 是我能缓存的上限" 你可以在上限内自由决定(比如更保守地只缓存 1/3)

第二种理解带来两个实际好处:

好处一:你可以比 TTL 更短,以便在故障时快速切换。 如果某个域名要紧急改 IP,而 TTL 是 24 小时,那么"比 TTL 更保守地缓存"(比如 300 秒)能让你在几分钟内完成切换。代价是查询量上升——这是一个可以直接量化的运维选择。

好处二:你必须在 TTL 到期时真的失效。 不能"反正是缓存,多留一会儿也没事"——这是把上游的新鲜度承诺当成了建议,而它是契约。

缓存里存什么:绝对时刻,不是剩余秒数

pub struct CacheEntry {
    pub key: CacheKey,
    pub records: Vec<Record>,
    /// 绝对过期时刻 —— 不是 remaining_ttl
    pub expires_at: Instant,
    /// 上游的原始 TTL,用于观测和调优
    pub original_ttl: u32,
}
 
pub struct CacheKey {
    /// 规范化后的名字(小写)
    pub name: Name,
    /// 记录类型:A / AAAA / CNAME / MX ...
    pub rtype: RecordType,
    /// 类别,几乎总是 IN,但必须在键里
    pub class: RecordClass,
}

两个设计点都是关键:

点一:存 Instant(绝对时刻),不存剩余秒数。

如果存 remaining_ttl: u32,那么每次读取都必须做 remaining -= elapsed 并写回去——读操作变成了写操作,缓存立刻需要锁或者原子操作,而且并发读会互相干扰。

存绝对时刻之后,读是完全只读的,多线程共享一把读锁都不需要。代价是 Instant 在序列化/持久化上更麻烦——但 DNS 缓存本来就不需要持久化(重启重新解析即可)。

点二:缓存键是三元组 (name, type, class)。

只用 name 做键是最常见的设计错误: 同一个域名有 A 记录(IPv4)和 AAAA 记录(IPv6),只用名字做键会导致 A 记录把 AAAA 记录覆盖掉,于是 IPv6 用户突然拿到 IPv4 地址,或者反过来——而且这个错误只在"同一域名两种类型都被查询过"时出现,单测里完美通过。

impl Cache {
    pub fn get(&self, key: &CacheKey, now: Instant) -> Option<&CacheEntry> {
        let entry = self.map.get(key)?;
 
        if entry.expires_at <= now {
            // 惰性过期:读的时候顺手标记,交给后台清理
            return None;
        }
        Some(entry)
    }
}

负缓存:这篇最容易被漏掉的一步

NXDOMAIN(这个名字不存在)也是可以缓存的,而且必须缓存。

pub enum CacheValue {
    /// 正常记录
    Records(Vec<Record>),
    /// NXDOMAIN:名字不存在
    NameError { ttl: u32 },
    /// NODATA:名字存在,但这个类型没有记录
    NoData { ttl: u32 },
}

为什么必须缓存? 设想一个页面引用了 cdn.example.com,但配置写错了,写成了 cdn.exmaple.com(拼错)。如果 NXDOMAIN 不缓存,每一次页面加载都会向上游发起一次查询,而且是查一个永远不存在的名字。

放大效果很可观: 一个每天访问 100 万次的页面 × 3 个拼错的资源引用 = 每天 300 万次注定失败的查询,全部穿透到上游。

NXDOMAIN 的 TTL 从哪里来? 不在答案区,而在权威区的 SOA 记录里:

impl Resolver {
    fn cache_negative(&mut self, resp: &Response, now: Instant) -> Result<()> {
        // RFC 2308:负缓存的 TTL 取 SOA 的 minimum 字段,
        // 或者 SOA 记录自己的 TTL,取二者较小
        let soa = resp.authority.iter()
            .find(|r| r.rtype == RecordType::SOA)
            .ok_or(Error::MissingSoa)?;
 
        let ttl = soa.ttl.min(soa.minimum);
        // 加个上限,防止上游给出一个荒谬的巨大值(比如 7 天)
        let ttl = ttl.min(self.max_negative_ttl);
 
        self.cache.insert(key, CacheValue::NameError { ttl }, now + Duration::from_secs(ttl as u64));
        Ok(())
    }
}

soa.minimum 这个字段的名字有误导性——它不表示"最小 TTL",而是 RFC 2308 里指定的"负缓存时长"。把它当"最小值"用的实现,行为会和预期完全不同。

负缓存的缺失是"看起来没问题但成本巨大"的典型:功能上一切正常,只是每次错误都打到上游。 而这类问题的排查方式只有一种——看查询日志里"重复的、注定失败的查询"占了多大比例。 这个比例往往比想象的高得多。

缓存还要防一件事:TTL 递减到 0 的边界

/// 一个容易忽略的边界:TTL 恰好为 0 的记录
pub fn is_cacheable(records: &[Record]) -> bool {
    // TTL = 0 表示"可以用于本次响应,但不应该被缓存"
    records.iter().all(|r| r.ttl > 0)
}

TTL=0 有明确含义:这份数据可以回答当前这次查询,但不许缓存。 上游用它的场景包括"服务正在故障转移,我不确定这个答案五分钟内还有效"。

很多实现在这里做了"善意"的处理——把 0 当成 1 秒来避免每次都查。 这直接违背了上游的意图,而且会让故障转移期间的所有客户端卡在一个可能错误的答案上。

协议里的"边界值"往往不是"极端情况",而是"另一种语义"。 TTL = 0、HTTP 的 Cache-Control: no-store、max-age=0——它们说的是"不要缓存",而不是"缓存很短时间"。 把语义当成数值处理,是缓存类 bug 最主要的来源。**

第五步:淘汰——两个互相独立的维度

DNS 缓存的条目会在两种完全不同的原因下离开:

pub struct Cache {
    map: LruMap<CacheKey, CacheEntry>,
    /// 容量上限
    capacity: usize,
}
 
impl Cache {
    /// 维度一:容量满 → LRU 淘汰
    pub fn insert(&mut self, key: CacheKey, entry: CacheEntry) {
        if self.map.len() >= self.capacity {
            // LRU 自己会淘汰最久未用的
        }
        self.map.insert(key, entry);
    }
 
    /// 维度二:时间到期 → 惰性删除 + 后台清理
    pub fn sweep(&mut self, now: Instant) -> usize {
        // 定期扫描,清掉过期的
        let expired: Vec<CacheKey> = self.map.iter()
            .filter(|(_, e)| e.expires_at <= now)
            .map(|(k, _)| k.clone())
            .collect();
 
        for k in &expired {
            self.map.remove(k);
        }
        expired.len()
    }
}

为什么必须区分这两个维度?因为它们的最优策略完全不同:

维度 触发原因 正确策略
容量 条目太多 LRU(借"最近用过的大概率还用")
时间 TTL 到期 精确按 expires_at,和访问模式无关

如果把两者混在一起——比如"到期的条目按 LRU 顺序淘汰"——就会出现:一个刚被访问过一次、但早就过期的条目,比一个很久没访问、但还很新鲜的条目活得更久。 前者是错误数据,后者是可用的。

惰性删除和定期清理必须都做:

  • 只做惰性(读时发现过期就删):一个再也不会被读的键会永远占着内存
  • 只做定期:两次扫描之间,读操作会拿到过期数据

而惰性删除的正确写法是"读时判定过期",不是"读时删除"——因为删除需要写锁,会把只读路径变成读写路径。判定过期 → 返回未命中 → 交给后台清理,这样读路径能保持完全无锁。

关于 DNS 缓存的淘汰压力,有一个和普通缓存不同的特点:TTL 决定了条目本来就会自然死亡。

普通 LRU 缓存的条目可能永远不死(比如热点数据的 key 不变),所以容量淘汰是主要机制。DNS 缓存的每个条目都有一个明确的死期(几秒到几小时),所以"时间淘汰"承担了大部分清理工作,LRU 只在缓存被恶意/异常打满时才起作用。

这也意味着容量可以设得比直觉大。 因为大部分条目会自己消失,容量只要够覆盖"一个 TTL 周期内的活跃域名"就够了——实践中通常是"QPS × 平均 TTL × 若干倍"。

"条目会自己死掉"是对缓存容量的最大解放。 反过来看,如果缓存的条目寿命不受控(比如永久有效),那么容量规划就变成了一个必须精确计算的问题——这也是为什么"给缓存设置一个上限 TTL"通常是好主意,哪怕上游给的 TTL 更长。

第六步:查上游——超时和错误语义比缓存更容易出错

缓存未命中就要问上游。这一步是异步的、慢的(几十到几百毫秒),而且它有几个容易搞错的语义边界。

超时必须有界,而且必须真的取消

pub async fn resolve_upstream(&self, query: &Query) -> Result<Response> {
    // 超时不是"选一个数字",而是"客户端等得起多久"
    // 客户端自己通常有 2 秒超时,所以上游预算必须远小于它
    let timeout = self.upstream_timeout;   // 比如 800ms
 
    match tokio::time::timeout(timeout, self.send_and_await(query)).await {
        Ok(Ok(resp)) => Ok(resp),
        Ok(Err(net_err)) => Err(Error::Upstream(net_err)),
        Err(_elapsed) => Err(Error::Timeout),   // 明确的超时,不是通用的网络错误
    }
}

超时值的选取有一条硬的约束:上游预算 + 本地处理时间 < 客户端超时。 如果客户端等 2 秒而你的上游预算也是 2 秒,那么每次超时都意味着客户端先放弃,你继续消耗资源去等一个没人要的答案。

而且超时之后必须真的取消上游请求。 只"不再等"但让请求继续跑,会出现**"上游还在处理,我已经返回失败,然后我缓存了失败,但上游其实成功了"**——这类不一致会持续到缓存过期。

超时返回什么:SERVFAIL 而不是 NXDOMAIN

这是整篇里第二重要的语义(仅次于 TTL):

pub fn error_to_response(err: &Error, query: &Query) -> Response {
    match err {
        // 上游超时 / 网络错误 / 上游返回 SERVFAIL
        // → 我不知道答案,请稍后重试
        Error::Timeout | Error::Upstream(_) => Response::servfail(query),
 
        // 上游明确说"这个名字不存在"
        // → 这是一个确定的答案,且可以被负缓存
        Error::NameError => Response::nxdomain(query),
 
        // 上游拒绝了这个查询(策略限制)
        Error::Refused => Response::refused(query),
    }
}

为什么这两个不能混?

返回码 语义 客户端的反应 能不能缓存
NXDOMAIN 这个名字确定不存在 放弃,报"域名不存在" 能(长时间)
SERVFAIL 我现在查不到 重试其他解析器 不能(最多几秒)

把超时返回成 NXDOMAIN,等于把"临时故障"固化成"永久答案"。 而且因为它可以被负缓存,这个错误的答案会被缓存几小时——用户会看到"域名不存在",一直看到缓存过期。

更糟的是这个错误会传染: 你的下游如果也是一层解析器,它会继续把这个 NXDOMAIN 缓存并传播下去。一次上游抖动,可能变成一片区域的"域名全部不存在"。

"我不知道"和"它不存在"必须是两种不同的回答。 这个区分在缓存系统里尤其重要,因为只有"确定性的答案"才允许被缓存,而错误信息几乎总是非确定性的。 把错误当成答案缓存,是一个会自我放大的故障。

上游也要防放大:单域名去重

上游请求是稀缺资源,而**"同一时刻大量客户端查同一个域名"是常态**——比如一批机器同时启动、同一个页面的一堆用户。

pub struct SingleFlight {
    /// 正在进行的上游查询:域名 → 等待中的通知通道
    inflight: Mutex<HashMap<CacheKey, Vec<oneshot::Sender<Response>>>>,
}
 
impl SingleFlight {
    pub async fn resolve(
        &self,
        key: CacheKey,
        do_query: impl Future<Output = Result<Response>>,
    ) -> Result<Response> {
        // 第一个到的人负责真正去查
        let (tx, rx) = oneshot::channel();
 
        let 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 leader {
            let result = do_query.await;
 
            // 无论成功失败,都要唤醒所有等待者并从表里摘掉
            let waiters = self.inflight.lock().unwrap().remove(&key).unwrap_or_default();
            for w in waiters {
                let _ = w.send(result.clone().unwrap_or_else(|e| Response::servfail_from(&e)));
            }
            result
        } else {
            rx.await.map_err(|_| Error::LeaderFailed)
        }
    }
}

这段代码里最容易漏的是"失败也要唤醒等待者"。

如果 leader 失败后直接 return Err(...) 而忘了通知,所有等待者会永远挂在那里等一个不会来的消息——表现是"上游一抖动,解析器就开始堆积请求直到 OOM"。和讲幂等的那篇是同一类问题:状态机的每一个出口都必须有对应的动作。

注意这里唤醒的是 Response 而不是 Result——因为等待者需要的是一个"上游到底说了什么"的答案,包括"上游超时了"这个答案本身,它应该被独立地转换成 SERVFAIL。

去重(single-flight)几乎是所有"昂贵资源 + 高并发相同请求"场景的标配方案。 它的实现模式非常固定:第一个到的人做事,其他人排队;无论成功、失败还是超时,都必须唤醒队列。 而它的收益也总是很大——热门对象失效时,把 N 次上游请求压成 1 次。

第七步:并发与响应放大

最后一件必须做的事:防止自己被当成放大攻击的跳板。

pub struct ResponseRateLimit {
    /// 对同一客户端的同一响应,限制每秒发送次数
    buckets: ShardedMap<IpPrefix, TokenBucket>,
}
 
impl ResponseRateLimit {
    pub fn allow(&mut self, client: IpAddr, response: &Response, now: Instant) -> bool {
        // 关键:惩罚"小问题得到大响应"的查询
        let cost = response.encoded_size() / response.question_size() + 1;
        self.buckets.entry_mut(client.to_prefix(24)).allow_cost(cost, now)
    }
}

为什么成本按"响应大小 / 请求大小"算?

因为放大攻击的形状就是"1 个 64 字节的请求,换来 4000 字节的响应"。ANY 类型查询是经典的放大器(一个请求要回所有记录类型)。 所以:

第一,成本高的查询要消耗更多令牌。 正常查询成本是 1,一个 XXX 元的放大查询成本是 60。这样正常用户不受影响,攻击者几秒内就被限掉。

第二,按前缀(/24)而不是按单个 IP 限。 攻击者可以用海量伪造源 IP,按单个 IP 限速等于没限。 而按前缀聚合能把"同一网段来的洪水"识别出来——代价是同一网段里的正常用户可能被误伤,这是必须接受的天平倾斜。

限流的粒度永远是一个取舍:粒度越细越精准,越容易被绕过。 讲限流器的那篇说的是"保护自己",这里多了一层——当你是一个可以放大流量的服务时,限流同时是"保护别人"。

结论

DNS 服务器的代码量不大,但它是这一整个系列里"接口语义"最密集的一个系统。真正的工作量分布:

报文解析与边界检查     ~30%   (长度、指针、跳转次数,全部来自不可信输入)
名字索引与匹配规则     ~15%   (反转 Trie + 通配符优先级)
缓存语义              ~30%   (TTL 是上限、绝对时刻、负缓存、TTL=0)
上游交互与错误语义     ~25%   (超时预算、SERVFAIL vs NXDOMAIN、去重、唤醒)

注意"算法"在这里几乎不存在。 没有复杂的排序、没有图搜索、没有分布式共识——整个系统难在"每一条语义都不能搞混"。

三条最值得记住的判断:

  1. TTL 是"允许缓存的上限",不是"应该缓存的时间"。 由此推出:返回剩余 TTL、TTL=0 不缓存、负缓存必须做。
  2. "我不知道"和"它不存在"是两种回答,对应 SERVFAIL 和 NXDOMAIN。 由此推出:错误不能被当作答案缓存。
  3. 可以放大的服务,限流是保护别人。 由此推出:限流成本要按放大比算,粒度要按前缀聚合。

这三条有个共同点:它们的错误形态都不是"崩溃",而是"多一点流量""慢一点生效""偶尔返回不存在的域名"。 系统一直"能用",只是持续地在某些方向上放大错误——这类问题只有靠对协议语义的清晰理解才能发现,性能图表上是看不出来的。

下一篇从"语义密集"换到"状态密集":一个必须为用户维护持久状态的实时系统(IM),会看到前面所有缓存和存储的取舍被重新排列一次。