TTL · XB 现场笔记

DNS TTL 在重复回源查询与保留旧回答之间取舍

Wed, 01 Mar 2028 00:00:00 +0000

DNS TTL 是附着于缓存数据的寿命，不是每秒执行的刷新任务。只要条目仍被保留且有效，缓存可以复用它；过期后的下一次请求通常需要重新解析，除非启用了其他明确行为。无人查询的记录，并不一定在 TTL 归零时主动产生上游请求。因此讨论成本时，要同时看请求到达方式与缓存状态，不能把 TTL 直接当成定时查询频率。

坏掉的样子

持续查询相同数据时，缩短 TTL 可能增加上游工作，却不会让所有权威流量按同一个固定倍数增长。查询频率、解析器共享程度、缓存容量、预取和名称多样性都会影响结果。一个热门名称使用短 TTL，与大量只问一次的名称流，行为不同。没有这些负载条件，就无法仅凭 TTL 数字预测真实查询量或容量需求。

长 TTL 允许在权威数据修改后继续使用先前回答。该缓存仍可能符合最初收到的寿命要求，尽管内容已经不同于最新区域。把所有不一致都叫成过期或损坏，会混淆实际契约。TTL 表示允许保留多久，不承诺持续与权威同步。修改 TTL 同样不能追溯改变已经保存的更长寿命，需要等那些旧副本自然退出普通有效期。

多层转发通常不会让每一跳重新获得原始完整 TTL。缓存返回剩余寿命，下一层再继续计时。按层数累加完整 TTL，会虚构普通合规转发并不产生的传播延迟。本地 TTL 覆盖、提供陈旧回答等是另外的配置行为，存在时应明确识别。不能先假设所有解析器都遵守同一种特殊策略，再用这个假设解释实际观测。

快速验证

将脚本保存为 check-ttl-cost.py，准备 Docker 后执行 python3 check-ttl-cost.py。固定容器使用 BIND 9.18.49 与 dnsmasq 2.90，运行时没有外部网络。权威服务器记录实际查询；最初一个转发器服务两个名称，随后在它后面启动第二个转发器，检查交给下游的 TTL。所有服务和日志都属于临时实验，不修改现有解析基础设施：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends bind9=1:9.18.49-1~deb12u2 bind9-dnsutils=1:9.18.49-1~deb12u2 dnsmasq-base=2.90-4~deb12u2 python3-dnspython=2.3.0-1 && rm -rf /var/lib/apt/lists/*\nCMD ["/usr/bin/python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,re,signal,subprocess,time
import dns.exception,dns.message,dns.query,dns.rcode,dns.rdatatype

def run(*args,check=True):
 result=subprocess.run(args,capture_output=True,text=True,timeout=15)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def query(name,kind='A',port=1053):
 return dns.query.udp(dns.message.make_query(name,kind),'127.0.0.1',port=port,timeout=1)
def values(response,kind='A'):
 wanted=dns.rdatatype.from_text(kind)
 return [item.to_text() for rrset in response.answer if rrset.rdtype==wanted for item in rrset]
def show(response):
 def section(records):return [{'name':str(rr.name),'type':dns.rdatatype.to_text(rr.rdtype),'ttl':rr.ttl,'data':[item.to_text() for item in rr]} for rr in records]
 return {'rcode':dns.rcode.to_text(response.rcode()),'answer':section(response.answer),'authority':section(response.authority)}
def wait(predicate,timeout=15):
 deadline=time.monotonic()+timeout
 while time.monotonic()<deadline:
 try:
 if predicate():return
 except (OSError,dns.exception.Timeout):pass
 time.sleep(.05)
 raise AssertionError('DNS fixture condition did not become true')
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=5)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=5)

@contextmanager
def lab(records,soa_ttl=8,minimum=4,extra=''):
 with TemporaryDirectory(prefix='xbcatm-dns-') as directory,ExitStack() as stack:
 root=Path(directory);zone=root/'zone';conf=root/'named.conf';log=root/'named.log';serial=1
 def save(body):
 zone.write_text(f'$ORIGIN lab.test.\n$TTL 30\n@ {soa_ttl} IN SOA ns.lab.test. hostmaster.lab.test. ({serial} 60 60 3600 {minimum})\n@ IN NS ns.lab.test.\nns IN A 127.0.0.1\n'+body+'\n')
 run('named-checkzone','lab.test',str(zone))
 save(records)
 conf.write_text(f'''options {{ directory "{root}"; listen-on port 1053 {{127.0.0.1;}}; listen-on-v6 {{none;}};
recursion no; dnssec-validation no; notify no; querylog yes; max-cache-size 8m; pid-file "{root}/named.pid"; session-keyfile none;
{extra} }};
controls {{}};
zone "lab.test" {{ type primary; file "{zone}"; }};
''')
 run('named-checkconf',str(conf))
 output=stack.enter_context(log.open('w'))
 authority=subprocess.Popen(['named','-g','-c',str(conf),'-n','1','-U','1'],stdout=output,stderr=subprocess.STDOUT)
 stack.callback(stop,authority)
 def ready():
 assert authority.poll() is None,log.read_text()
 response=query('lab.test.','SOA');return response.rcode()==0 and response.answer[0][0].serial==serial
 wait(ready)
 def update(body):
 nonlocal serial
 serial+=1;save(body);authority.send_signal(signal.SIGHUP);wait(ready)
 def cache(port=1054,upstream=1053,size=150,options=()):
 logfile=root/('cache-'+str(port)+'.log');stream=stack.enter_context(logfile.open('w'))
 command=['dnsmasq','--no-daemon','--conf-file=/dev/null','--no-resolv','--no-hosts','--bind-interfaces',
 '--listen-address=127.0.0.1','--port='+str(port),'--server=127.0.0.1#'+str(upstream),
 '--cache-size='+str(size),'--log-queries','--log-facility=-',*options]
 process=subprocess.Popen(command,stdout=stream,stderr=subprocess.STDOUT);stack.callback(stop,process)
 def cache_ready():
 assert process.poll() is None,logfile.read_text()
 return query('lab.test.','SOA',port).rcode()==0
 wait(cache_ready);return process,logfile
 def queries(name,kind='A'):
 return sum(bool(re.search(r'query: '+re.escape(name.rstrip('.'))+r' IN '+kind+r'\b',line)) for line in log.read_text().splitlines())
 yield root,update,cache,queries
with lab('short 1 IN A 127.0.0.2\nlong 20 IN A 127.0.0.3\nchain 6 IN A 127.0.0.4') as (_,update,cache,queries):
 cache();samples=[]
 for i in range(3):
 pair={name:show(query(name+'.lab.test.',port=1054)) for name in ('short','long')};samples.append(pair)
 if i<2:time.sleep(1.2)
 wait(lambda: queries('short.lab.test')==3 and queries('long.lab.test')==1)
 first=query('chain.lab.test.',port=1054);assert first.answer[0].ttl==6
 wait(lambda: queries('chain.lab.test')==1)
 time.sleep(2.2);cache(port=1055,upstream=1054)
 downstream=query('chain.lab.test.',port=1055);upstream=query('chain.lab.test.',port=1054)
 assert values(downstream)==['127.0.0.4'] and 0<downstream.answer[0].ttl<6
 assert abs(downstream.answer[0].ttl-upstream.answer[0].ttl)<=1
 assert queries('chain.lab.test')==1
 update('short 1 IN A 127.0.0.2\nlong 20 IN A 127.0.0.3\nchain 6 IN A 127.0.0.5')
 wait(lambda: values(query('chain.lab.test.',port=1055))==['127.0.0.5'],timeout=8)
 wait(lambda: queries('chain.lab.test')==2)
 print(json.dumps({'three_lookups_each':samples,'authority_query_counts':{'short':queries('short.lab.test'),'long':queries('long.lab.test')},
 'cache_chain':{'original':show(first),'downstream_first':show(downstream),'upstream_remaining':show(upstream),'authority_queries_after_expiry':queries('chain.lab.test')}},sort_keys=True))
"""
name='xbcatm-dns-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 built=docker('build','-t',name,str(root));assert built.returncode==0,built.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--memory','384m','--pids-limit','128',name,
 '/usr/bin/python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

short.lab.test 的 TTL 为一秒，long.lab.test 为二十秒。程序各查询三次，轮次间等待一点二秒。权威日志显示短寿命记录收到三次查询，长寿命记录只有一次，而每一轮客户端都得到成功回答。这个差异说明受控请求节奏下的上游工作量，不是应用延迟提升的基准测试，更不能据此推导公网解析性能增加多少倍。

长寿命回答的剩余 TTL 随轮次下降，短寿命回答每次刷新后重新从一秒开始。脚本直接检查权威日志，不以“响应很快”假定命中缓存。回环网络里没有命中的查询也可能很快，单看耗时无法证明是否联系权威。先确认真实查询计数，再解释缓存复用，才能让实验结论对应实际执行路径，而非依赖肉眼感受。

在双层案例中，第一个转发器缓存 chain.lab.test，初始 TTL 为六秒。等待两点二秒后，新启动的第二层通过它查询。实测下游回答 TTL 为三秒，与上游剩余值在整数秒计时误差范围内一致，并没有重新获得六秒。权威计数仍为一次，证明下游填充复用了第一层现有条目，而不是恰好重新取得另一份新鲜权威回答。

随后权威修改该记录地址。经第二层查询最终得到新地址，权威次数增加为两次。这验证已有数据到期后，两层转发都能正常获得更新。精确到期小数受实现和调度影响；断言关注剩余寿命被传递、没有提前增加额外权威查询，以及最终取得修改后的值。这个实验反对简单累加 TTL，并不声称所有应用缓存都自动具有相同行为。

依据真实需求选择寿命

选择 TTL 时，同时考虑变更频率、可接受的旧回答重叠期和查询量。共享繁忙解析器可以让很多客户端复用一次回答，彼此隔离的缓存则会重复填充。条目可能因容量淘汰而在 TTL 之前消失，因此长寿命不保证命中。应测量命中、未命中、上游请求和可用容量，不能把 TTL 当作缓存大小控制，也不能把提前淘汰误判为协议错误。

计划迁移时，应提前降低 TTL，让更早获得的长寿命副本有时间过期，并据真实保留数据安排端点重叠。稳定后提高 TTL，可减少热门记录的重复解析，同时也延长下一次变更的普通等待窗口。配置单位应关注记录集：名称、类别和类型相同的记录，应使用一致 TTL，而不是给各个地址配置不同寿命来模拟优先级或权重。

最后，对照应用实际使用的各个解析器，查看回答内容和剩余寿命。直接权威查询与递归缓存回答展示的是不同状态，不能拿其中一个覆盖另一个。应用自有缓存和已经建立的连接，还可能具有实验之外的生命周期。估算用户多久发现新端点、以及 TTL 调整需要多少权威容量前，先把这些寿命与 DNS 缓存寿命区分清楚。

来源

RFC 1035 domain names，TTL 缓存寿命与缓存记录处理，已核验 2026-09-12。
RFC 2181 DNS clarifications，TTL 限制与记录集内部一致的寿命，已核验 2026-09-12。
dnsmasq manual，缓存容量、转发与 TTL 选项，已核验 2026-09-12。

Redis TTL 让每个键自带时钟

Tue, 29 Jun 2027 00:00:00 +0000

Redis 过期机制回答的是一个键什么时候应当停止可见，而不是整个服务最多使用多少内存。截止时间属于键，后续命令可能保留、替换或者移除它。因此，可靠地使用 TTL，既要检查首次写入，也要覆盖更新路径。看到写命令成功，不能证明之前设置的截止时间仍然存在，更不能直接推断数据最终会按原计划消失。

截止时间不是自动滑动计时器

EXPIRE 使用秒，PEXPIRE 使用毫秒。Redis 将过期信息保存为绝对 Unix 时间戳，所以服务器停止运行期间，时间仍然继续流逝。系统时钟必须稳定，跨机器恢复数据时尤其需要注意时钟差异。它不是独立于系统时间变化的单调时长承诺。下面的实验只使用正常流逝的时间，不调整本机系统时钟。

GET 不会刷新过期时间。INCR 这类原地修改保留键已有的超时；普通成功的 SET 则替换值，并清除原来的超时。SET KEEPTTL 可以保留原期限，再次显式设置过期命令则会改变截止时间。需要滑动会话的应用必须主动实现续期策略，不能以为用户每次读取数据都会自然延长访问窗口。

当值和初始寿命属于同一次操作时，应使用 SET EX 或 SET PX 一起写入。分成 SET、EXPIRE 两条命令，会留下一个值已经存在、期限却尚未写入的失败窗口。客户端如果恰好在两条命令之间崩溃，就可能留下持久条目。这是写入协议缺陷，不是后台过期周期执行得太慢，调整清理频率也修复不了它。

检查真正存在的状态

TTL 返回剩余秒数；键存在但没有过期时间时返回 -1，键不存在时返回 -2。PTTL 提供毫秒分辨率，PEXPIRETIME 则返回绝对截止时间。要验证一次读取有没有续期，比较绝对期限比比较两次倒计时更可靠，因为两条查询之间时间正常流逝，本来就可能让剩余数值减少。查询结果只是当时的快照，不保证键一定能存活到那个时刻。

EXPIRE NX 只在没有期限时添加期限。GT 只接受更晚的截止时间，其中持久键被当成无限寿命处理。PERSIST 则显式移除过期设置。调用方需要检查命令返回的结果，不能把“命令被接受”理解成“条件成立且状态已经改变”。相对过期时间为零或负数时，键会立即被删除，并不是改成永久保存的另一种写法。

坏掉的样子

被动过期在访问时检查截止时间，主动过期负责处理那些过期后没有再被访问的键。物理清理延迟，不等于普通主节点 GET 可以持续交付已经过期的值。反过来，条目被移除，也不保证分配器马上把页面交还操作系统。读取可见性、数据结构清理与进程 RSS 是不同观察对象，不能只看其中一个就替其他两个下结论。

TTL 不是硬内存预算。写入速率、值的大小、尚未到期的数据、命令开销和分配器行为都会影响占用；逐出还可能让键在期限到来之前消失。业务授权不能只检查缓存键是否存在，也不能从单实例实验推导复制或故障切换保证。那些工作流仍需明确自己的业务截止时间、读写路径及一致性边界，分别建立验收证据。

快速验证

准备 POSIX 环境、C 编译器、make、curl、tar 和 Python 3.10 或更新版本。此前记录在 macOS 上使用 Python 3.14.4、Redis 8.10.1 与 redis-py 8.1.0；本轮没有重跑。命令只用 libc 编译 Redis 核心，并在临时虚拟环境安装客户端，不进行系统级安装，也不编译附带的可选模块。

redis_lab=$(mktemp -d)
curl --fail --location --output "$redis_lab/redis.tar.gz" https://download.redis.io/releases/redis-8.10.1.tar.gz
tar -xzf "$redis_lab/redis.tar.gz" -C "$redis_lab"
make -C "$redis_lab/redis-8.10.1" build redis -j2 MALLOC=libc
export REDIS_SERVER="$redis_lab/redis-8.10.1/src/redis-server"
python3 -m venv "$redis_lab/venv"
"$redis_lab/venv/bin/python" -m pip install redis==8.1.0

在同一个 shell 中，用 "$redis_lab/venv/bin/python" 执行 Python 代码。它在 /tmp 的专用临时目录下创建 Unix socket，启动独立 Redis，并关闭 TCP 监听、定时快照和追加日志。请求不会连接默认的本机 Redis。结束时只关闭自己创建的进程、移除自己的临时运行目录；下载阶段需要外网，实验交互不需要网络服务。

from contextlib import contextmanager
import os
from pathlib import Path
import subprocess
from tempfile import TemporaryDirectory
import time

import redis
from redis.backoff import NoBackoff
from redis.retry import Retry


@contextmanager
def instance(policy="noeviction"):
 with TemporaryDirectory(prefix="redis-lab-", dir="/tmp") as directory:
 endpoint = str(Path(directory) / "redis.sock")
 process = subprocess.Popen([
 os.environ["REDIS_SERVER"], "--port", "0",
 "--unixsocket", endpoint, "--unixsocketperm", "700",
 "--save", "", "--appendonly", "no", "--dir", directory,
 "--maxmemory-policy", policy,
 ], stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
 client = redis.Redis(unix_socket_path=endpoint, decode_responses=True,
 socket_timeout=2, retry=Retry(NoBackoff(), 0))
 try:
 deadline = time.monotonic() + 5
 while True:
 assert process.poll() is None, "Redis exited during startup"
 try:
 if client.ping():
 break
 except redis.ConnectionError:
 if time.monotonic() >= deadline:
 raise
 time.sleep(0.02)
 yield client
 finally:
 client.close()
 if process.poll() is None:
 process.terminate()
 try:
 _, errors = process.communicate(timeout=5)
 except subprocess.TimeoutExpired:
 process.kill()
 process.communicate()
 raise
 assert process.returncode == 0, errors.decode()


with instance() as client:
 assert client.ttl("missing") == -2
 client.set("session", "A", px=60000)
 deadline = client.pexpiretime("session")
 assert client.get("session") == "A"
 assert client.pexpiretime("session") == deadline
 client.set("session", "B", keepttl=True)
 assert client.pexpiretime("session") == deadline
 print("GET and SET KEEPTTL preserve the absolute deadline")

 client.set("session", "C")
 assert client.ttl("session") == -1
 assert client.expire("session", 60, nx=True)
 assert not client.expire("session", 120, nx=True)
 assert client.expire("session", 120, gt=True)
 assert not client.expire("session", 30, gt=True)
 assert client.persist("session")
 assert client.ttl("session") == -1
 print("plain SET clears TTL; NX, GT and PERSIST follow their conditions")

 client.set("counter", "1", px=60000)
 deadline = client.pexpiretime("counter")
 assert client.incr("counter") == 2
 assert client.pexpiretime("counter") == deadline
 assert client.expire("counter", 0)
 assert client.get("counter") is None
 print("INCR preserves TTL; EXPIRE zero deletes immediately")

 client.pexpire("session", 100)
 limit = time.monotonic() + 3
 while client.get("session") is not None:
 assert time.monotonic() < limit, "key did not expire"
 time.sleep(0.01)
 assert client.ttl("session") == -2
 print("after expiry: GET is None and TTL is -2")

绝对截止时间在 GET 和 SET KEEPTTL 之后保持不变；普通 SET 则使 TTL 变成 -1。条件过期的断言区分了成功更新与条件不满足，PERSIST 又把条目恢复为无期限状态。另一个计数器执行 INCR 后仍保留原期限，EXPIRE 零则让它立即不可读取，证明两种写入语义不能混用。

最后，一百毫秒超时使 GET 返回 None，TTL 返回 -2。程序通过有上限的轮询观察实际消失，不要求操作系统恰好在某个毫秒调度检查。这些结果验证命令语义和普通的过期读取，不证明物理回收时点、主动清理吞吐量、复制行为、故障切换或已经被其他地方复制走的数据是否安全销毁。

来源

Redis EXPIRE，期限更新、条件选项、时钟及主动与被动过期，已核验 2026-10-15。
Redis SET，值与寿命的原子写入及 KEEPTTL，已核验 2026-10-15。
Redis TTL，剩余寿命及 -1、-2 的返回含义，已核验 2026-10-15。
Redis 8.10.1 编译说明，仅编译核心及分配器选择，已核验 2026-10-15。

负向 DNS 回答会把不存在的数据记到缓存寿命结束

Thu, 22 Oct 2026 00:00:00 +0000

DNS 可以通过说明数据缺失提供有效信息。NXDOMAIN 表示名称错误，NODATA 则描述成功响应中没有所请求类型的数据。对于没有别名的直接查询，两者区分名称不存在，以及名称存在但缺少该类数据。缓存这些结果，可以避免每次客户端请求都重新进行相同的无结果上游查询。负向回答也是有内容、有寿命的状态，并不是“没有收到任何东西”。

坏掉的样子

部署已经创建正确记录，先前缓存过缺失结果的客户端却可能仍然失败。权威返回新数据，缓存则在寿命结束前继续返回旧否定结果。反复删除重建记录，不会使远端缓存自动失效。这种情况常出现在应用提前查询尚未配置完成的服务名称时；排障应对照查询发生时间和缓存寿命，而不是只检查现在的区域文件是否包含记录。

仅凭回答区为空，不能完整分类 DNS 结果。需要检查响应码、权威区和可能存在的别名链。转介与权威否定回答不同，NXDOMAIN 也可能指向 CNAME 最终目标，而非最初请求的别名本身。把所有空结果都说成“域名不存在”，可能让调查去改错误的记录。应保留原始问答的类型、名称及各区数据，避免过早简化成一句错误描述。

对于 RFC 2308 规定的权威 NXDOMAIN 和 NODATA，负向寿命取 SOA.MINIMUM 与 SOA 记录 TTL 中的较小值。该值放在否定回答的 SOA TTL 上，再由缓存继续递减。MINIMUM 不是所有正向记录 TTL 的统一下限；只改变将来正向记录的 TTL，也不会缩短已经缓存的不存在结论。操作时应确认正在调整哪类数据的哪一代寿命。

快速验证

历史解析器集成示例保持原样，本次没有重跑；当前没有 Docker，也不能建立网络监听。

将脚本保存为 check-negative-dns.py，准备 Docker 后执行 python3 check-negative-dns.py。固定环境使用 BIND 9.18.49 和 dnsmasq 2.90，只有隔离回环网络。第一个区域的 SOA TTL 为八秒、minimum 为四秒，并有一条现存 A 记录。实验在新增缺失数据前后检查真实响应与权威查询次数，不通过模拟字典代替解析器缓存行为：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends bind9=1:9.18.49-1~deb12u2 bind9-dnsutils=1:9.18.49-1~deb12u2 dnsmasq-base=2.90-4~deb12u2 python3-dnspython=2.3.0-1 && rm -rf /var/lib/apt/lists/*\nCMD ["/usr/bin/python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,re,signal,subprocess,time
import dns.exception,dns.message,dns.query,dns.rcode,dns.rdatatype

def run(*args,check=True):
 result=subprocess.run(args,capture_output=True,text=True,timeout=15)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def query(name,kind='A',port=1053):
 return dns.query.udp(dns.message.make_query(name,kind),'127.0.0.1',port=port,timeout=1)
def values(response,kind='A'):
 wanted=dns.rdatatype.from_text(kind)
 return [item.to_text() for rrset in response.answer if rrset.rdtype==wanted for item in rrset]
def show(response):
 def section(records):return [{'name':str(rr.name),'type':dns.rdatatype.to_text(rr.rdtype),'ttl':rr.ttl,'data':[item.to_text() for item in rr]} for rr in records]
 return {'rcode':dns.rcode.to_text(response.rcode()),'answer':section(response.answer),'authority':section(response.authority)}
def wait(predicate,timeout=15):
 deadline=time.monotonic()+timeout
 while time.monotonic()<deadline:
 try:
 if predicate():return
 except (OSError,dns.exception.Timeout):pass
 time.sleep(.05)
 raise AssertionError('DNS fixture condition did not become true')
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=5)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=5)

@contextmanager
def lab(records,soa_ttl=8,minimum=4,extra=''):
 with TemporaryDirectory(prefix='xbcatm-dns-') as directory,ExitStack() as stack:
 root=Path(directory);zone=root/'zone';conf=root/'named.conf';log=root/'named.log';serial=1
 def save(body):
 zone.write_text(f'$ORIGIN lab.test.\n$TTL 30\n@ {soa_ttl} IN SOA ns.lab.test. hostmaster.lab.test. ({serial} 60 60 3600 {minimum})\n@ IN NS ns.lab.test.\nns IN A 127.0.0.1\n'+body+'\n')
 run('named-checkzone','lab.test',str(zone))
 save(records)
 conf.write_text(f'''options {{ directory "{root}"; listen-on port 1053 {{127.0.0.1;}}; listen-on-v6 {{none;}};
recursion no; dnssec-validation no; notify no; querylog yes; max-cache-size 8m; pid-file "{root}/named.pid"; session-keyfile none;
{extra} }};
controls {{}};
zone "lab.test" {{ type primary; file "{zone}"; }};
''')
 run('named-checkconf',str(conf))
 output=stack.enter_context(log.open('w'))
 authority=subprocess.Popen(['named','-g','-c',str(conf),'-n','1','-U','1'],stdout=output,stderr=subprocess.STDOUT)
 stack.callback(stop,authority)
 def ready():
 assert authority.poll() is None,log.read_text()
 response=query('lab.test.','SOA');return response.rcode()==0 and response.answer[0][0].serial==serial
 wait(ready)
 def update(body):
 nonlocal serial
 serial+=1;save(body);authority.send_signal(signal.SIGHUP);wait(ready)
 def cache(port=1054,upstream=1053,size=150,options=()):
 logfile=root/('cache-'+str(port)+'.log');stream=stack.enter_context(logfile.open('w'))
 command=['dnsmasq','--no-daemon','--conf-file=/dev/null','--no-resolv','--no-hosts','--bind-interfaces',
 '--listen-address=127.0.0.1','--port='+str(port),'--server=127.0.0.1#'+str(upstream),
 '--cache-size='+str(size),'--log-queries','--log-facility=-',*options]
 process=subprocess.Popen(command,stdout=stream,stderr=subprocess.STDOUT);stack.callback(stop,process)
 def cache_ready():
 assert process.poll() is None,logfile.read_text()
 return query('lab.test.','SOA',port).rcode()==0
 wait(cache_ready);return process,logfile
 def queries(name,kind='A'):
 return sum(bool(re.search(r'query: '+re.escape(name.rstrip('.'))+r' IN '+kind+r'\b',line)) for line in log.read_text().splitlines())
 yield root,update,cache,queries
with lab('exists 30 IN A 127.0.0.2',soa_ttl=8,minimum=4) as (_,update,cache,queries):
 cache();missing=query('new.lab.test.',port=1054);nodata=query('exists.lab.test.','AAAA',1054)
 assert missing.rcode()==dns.rcode.NXDOMAIN and not missing.answer
 assert nodata.rcode()==dns.rcode.NOERROR and not nodata.answer
 for answer in (missing,nodata):assert len(answer.authority)==1 and answer.authority[0].rdtype==dns.rdatatype.SOA and answer.authority[0].ttl==4
 wait(lambda: queries('new.lab.test')==1 and queries('exists.lab.test','AAAA')==1)
 again=query('new.lab.test.',port=1054);again_nodata=query('exists.lab.test.','AAAA',1054)
 assert again.rcode()==dns.rcode.NXDOMAIN and again_nodata.rcode()==0 and not again_nodata.answer
 assert queries('new.lab.test')==1 and queries('exists.lab.test','AAAA')==1
 positive=query('exists.lab.test.','A',1054);assert values(positive)==['127.0.0.2']
 update('exists 30 IN A 127.0.0.2\nexists 30 IN AAAA ::1\nnew 30 IN A 127.0.0.3')
 assert values(query('new.lab.test.'))==['127.0.0.3'] and values(query('exists.lab.test.','AAAA'),'AAAA')==['::1']
 stale_missing=query('new.lab.test.',port=1054);stale_nodata=query('exists.lab.test.','AAAA',1054)
 assert stale_missing.rcode()==dns.rcode.NXDOMAIN and stale_nodata.rcode()==0 and not stale_nodata.answer
 wait(lambda: values(query('new.lab.test.',port=1054))==['127.0.0.3'],timeout=7)
 wait(lambda: values(query('exists.lab.test.','AAAA',1054),'AAAA')==['::1'],timeout=7)
 result={'NXDOMAIN':show(missing),'NODATA':show(nodata),'repeat_upstream_queries':{'NXDOMAIN':1,'NODATA':1},'existing_A_unaffected':show(positive),
 'immediately_after_creation':{'NXDOMAIN':show(stale_missing),'NODATA':show(stale_nodata)},'new_records_observed_after_expiry':True}
with lab('exists 30 IN A 127.0.0.2',soa_ttl=2,minimum=9) as (_,update,cache,queries):
 smaller=query('new.lab.test.');assert smaller.rcode()==dns.rcode.NXDOMAIN and smaller.authority[0].ttl==2
 result['smaller_SOA_TTL']=show(smaller)
print(json.dumps(result,sort_keys=True))
"""
name='xbcatm-dns-'+uuid.uuid4().hex[:10]
def docker(*args,**kwargs):return subprocess.run(['docker',*args],capture_output=True,text=True,timeout=300,**kwargs)
try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'Dockerfile').write_text(recipe)
 built=docker('build','-t',name,str(root));assert built.returncode==0,built.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--memory','384m','--pids-limit','128',name,
 '/usr/bin/python3','-',input=program)
 assert result.returncode==0,result.stderr
 print(json.dumps(json.loads(result.stdout),sort_keys=True))
finally:
 docker('rm','-f',name);docker('image','rm',name)

查询 new.lab.test 的 A，得到 NXDOMAIN；查询已有 A 地址 127.0.0.2 的 exists.lab.test 的 AAAA，得到 NOERROR，但没有回答数据。两个否定回答都包含 TTL 为四秒的 SOA。经缓存重复执行两类查询后，脚本确认各自仍只产生一次上游查询，从而证明结果被复用，而不是因为权威每次都返回相同内容就误判命中。

查询现存名称的 A 仍然成功，说明缓存中缺少 AAAA 的结论，并不表示这个名称所有类型都不存在。程序随后给新名称添加 A，并为现存名称添加 AAAA，重载权威区域，再直接确认新数据。此时权威分别返回 127.0.0.3 与 ::1。先确认权威修改真正生效，才能把下一步差异归因于缓存，而不是尚未加载的区域内容。

立即经 dnsmasq 查询，仍得到原来的 NXDOMAIN 与 NODATA；负向条目到期后才返回新的正向数据。另一个隔离区域把限制值反过来：SOA TTL 为两秒，minimum 为九秒，否定回答 TTL 就是两秒。两组案例共同验证取较小值的两个方向，而不是只用一组恰好通过的数字，便推断 minimum 永远单独决定所有负向寿命。

区分权威缺失与解析失败

SERVFAIL、超时和 DNSSEC 验证失败，并不能证明名称不存在，它们描述无法取得或接受回答。但它们也不是一概不可缓存：RFC 9520 更新了解析失败缓存要求，其中包括验证失败。这类失败缓存的寿命规则，不同于本实验中权威否定回答由 SOA 决定的寿命。排障时既不能把失败当缺失，也不能假定每次失败都会重新查询上游。

解析器能正确缓存 NXDOMAIN，不代表它实现了所有当前建议。本实验没有测试失败缓存或 DNSSEC 验证，应针对部署版本、配置和诊断信息检查那些行为。能取得扩展错误信息时也应保留，以免把缓存中的验证问题误判成刚删除的主机名。是否修复了权威数据与是否解决了验证链，是不同的问题，不能只看最终都表现为查询失败。

发布新服务前，考虑名称在不存在时是否已经被查询过。部署允许时可提前创建必需记录，并在要求发现成功前让已知负向窗口退出。操作者可以清理自己控制的缓存，却通常无法清除所有客户端使用的独立解析器。验证应同时覆盖权威发布状态和受影响解析器的当前回答，而不是用自己机器刷新后的结果代表全部用户已经恢复。

选择负向寿命时，同时考虑恢复速度与重复未命中负载。针对同一个缺失名称的重复查询能受益于缓存，大量互不相同的名称则具有不同成本，仍会消耗资源。指标中应区分正向、否定和解析失败。真正需要回答的是：缓存了什么结论、对应哪个名称与类型、保存多久，以及什么新证据说明客户端视图已经变化。

来源

RFC 2308 negative DNS caching，NXDOMAIN、NODATA、缓存键与 SOA 决定的寿命，已核验 2026-09-12。
RFC 9520 caching DNS resolution failures，解析失败与验证失败缓存的更新要求，已核验 2026-09-12。
dnsmasq manual，负向缓存行为及相关选项，已核验 2026-09-12。

TTL · XB 现场笔记

DNS TTL 在重复回源查询与保留旧回答之间取舍

坏掉的样子

快速验证

依据真实需求选择寿命

延伸阅读

来源

Redis TTL 让每个键自带时钟

截止时间不是自动滑动计时器

检查真正存在的状态

坏掉的样子

快速验证

延伸阅读

来源

负向 DNS 回答会把不存在的数据记到缓存寿命结束

坏掉的样子

快速验证

区分权威缺失与解析失败

延伸阅读

来源