DNS · XB 现场笔记

dnsmasq 区分转发缓存与本地配置名称

Sat, 15 Apr 2028 00:00:00 +0000

dnsmasq 可以向上游转发 DNS 查询，在有界缓存中保留支持的回答，也可以提供本地配置的名称。这些是不同的数据来源。重复得到相同回答，可能来自缓存命中，也可能来自本地配置。主机名与权威数据不一致、或者清缓存后仍然解析到原地址时，先确认来源十分重要；否则容易把有效配置误认为没有清干净的缓存。

先识别回答来源。转发缓存与本地配置名称具有不同寿命：本地 TTL 零不等于删除配置。SIGHUP 清缓存并重载特定数据来源，通常不重读主配置。次数与地址复述文章历史示例，本次没有重跑。

坏掉的样子

启动 dnsmasq，不会自动让所有应用使用它。客户端必须把 DNS 查询交给预期监听，有的应用还会使用其他解析服务。同样，本地监听正常，也可能转发到错误上游或者读取了意外 hosts 配置。在增加缓存容量或重启服务前，应先确认真实查询路径。如果失败查询根本没到达这个进程，对它反复操作不会改变调用方看到的结果。

本地名称可以有意覆盖上游数据。清理转发缓存不会删除这个配置名称，因此反复清空也不能让上游地址获胜。应把本地记录当作有负责人、有用途的配置管理。即使回答的本地 TTL 为零，dnsmasq 仍可持续返回该值，因为它来自配置生成，不是靠保留某份转发回答维持。零 TTL 与删除本地配置并不是同一件事。

缓存容量和新鲜度解决不同问题。更大缓存可以保留更多合适条目，却不会延长条目的有效 TTL，也不会让上游故障期间所有名称都能查询成功。新名称与过期条目仍需要合适的解析路径。缓存大小也不直接代表可同时发送多少上游查询，更不能单独保证应用可用。应分别观察容量、寿命、并发与上游健康，而不是用一个参数代替所有约束。

快速验证

将脚本保存为 check-dnsmasq.py，准备 Docker 后执行 python3 check-dnsmasq.py。固定环境使用 dnsmasq 2.90 和 BIND 9.18.49。实验转发器忽略环境中的 resolv 和 hosts 文件，明确绑定回环监听，并只转发到自己的临时权威服务器。它不发布宿主端口，没有 DHCP 配置，结束后清理自己的实例，不影响现有服务：

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('cached 20 IN A 127.0.0.2\nuncached 20 IN A 127.0.0.3\nlocal 20 IN A 127.0.0.4') as (_,update,cache,queries):
 daemon,log=cache(options=('--host-record=local.lab.test,127.0.0.9',))
 for _ in range(3):assert values(query('cached.lab.test.',port=1054))==['127.0.0.2']
 wait(lambda: queries('cached.lab.test')==1)
 cache(port=1055,size=0)
 for _ in range(3):assert values(query('uncached.lab.test.',port=1055))==['127.0.0.3']
 wait(lambda: queries('uncached.lab.test')==3)
 local=query('local.lab.test.',port=1054);assert values(local)==['127.0.0.9'] and local.answer[0].ttl==0
 assert queries('local.lab.test')==0
 authoritative=query('local.lab.test.');assert values(authoritative)==['127.0.0.4']
 wait(lambda: queries('local.lab.test')==1)
 update('cached 20 IN A 127.0.0.8\nuncached 20 IN A 127.0.0.3\nlocal 20 IN A 127.0.0.4')
 stale=query('cached.lab.test.',port=1054);assert values(stale)==['127.0.0.2'] and queries('cached.lab.test')==1
 previous=log.read_text().count('cleared cache');daemon.send_signal(signal.SIGHUP)
 wait(lambda: log.read_text().count('cleared cache')>previous)
 refreshed=query('cached.lab.test.',port=1054);assert values(refreshed)==['127.0.0.8']
 wait(lambda: queries('cached.lab.test')==2)
 retained=query('local.lab.test.',port=1054);assert values(retained)==['127.0.0.9']
 print(json.dumps({'three_lookups_upstream_counts':{'cache_enabled':1,'cache_disabled':3},'local_record':show(local),
 'same_name_authority':show(authoritative),'before_SIGHUP':show(stale),'after_SIGHUP':show(refreshed),
 'configured_local_record_retained':show(retained)},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)

通过启用缓存的监听查询 cached.lab.test 三次，都返回 127.0.0.2，权威日志却只记录一次。第二个监听使用 cache-size=0，经它对另一个名称查询三次，就产生三次上游请求。这个对照直接验证缓存对转发工作量的影响，不用响应速度猜测是否命中，也不声称测得某个固定延迟改善。回环网络的快慢本身不足以证明数据来源。

第一个监听另有 host-record=local.lab.test,127.0.0.9。查询得到 127.0.0.9，TTL 为零，权威没有记录对应上游查询。直接向权威查询同名则得到 127.0.0.4，计数随之增加。这说明差异来自明确的本地覆盖；后一个正向对照也验证了计数器确实能记录上游流量，避免把始终为零的错误日志匹配当作可靠证据。

接着权威将 cached.lab.test 改为 127.0.0.8，缓存仍在剩余有效期内返回旧值 127.0.0.2。脚本只向这个特定 dnsmasq 进程发送 SIGHUP，并等待日志确认缓存已清除。下一次查询到达权威，返回 127.0.0.8，对应权威次数从一次增加到两次。信号、日志、回答和回源计数共同验证清理产生了实际效果。

同一次信号之后，local.lab.test 仍返回配置中的 127.0.0.9。转发缓存状态被清除，不代表显式本地记录消失。因此“刷新 DNS”不是完整排障说明：预期结果取决于哪个进程持有什么数据，以及该数据属于缓存、配置，还是另一个组件保存的状态。只有先识别来源，才能判断清理操作是否适用以及成功标准是什么。

有意识地管理监听与数据来源

一起检查有效配置、监听地址、上游目的地和客户端设置，避免两个本地解析器互相转发形成循环。本例去掉环境输入是为了隔离行为；真实安装可能有意读取 hosts、DHCP 租约或解析器管理软件生成的数据。应记录这些依赖，使自动重写和本地覆盖在排障时可见，而不是把它们隐藏在“系统 DNS”这个笼统名称之下。

按照 dnsmasq 手册，SIGHUP 会清缓存并重载特定数据来源，但通常不会重新读取主配置文件。应针对修改种类使用文档规定的服务操作，不能把清缓存成功当作监听、转发或其他启动配置编辑已经生效的证明。变更后还应从真实客户端路径检查目标行为，避免只验证进程仍在运行，就忽略新配置根本没有加载。

监听暴露应限制在预期客户端范围，尤其在可达网络上提供递归转发时。DHCP、DNSSEC 验证和加密上游传输都需要独立配置与验证，本实验没有证明这些能力。查询日志有助于诊断，也可能揭示客户端访问的名称，应根据环境选择范围和保留时间，而不是习惯性永久开启所有细节。日志用途应与实际排障需求对应。

最后，只有预期来源是权威时，才把缓存回答与该权威比较；本地配置名称应与它的配置比较。分别跟踪上游失败、缓存命中和条目周转，才能判断下一项有用修改涉及容量、寿命、上游服务还是本地命名规则。这样的观察能够解释差异的原因，而不是把每次不一致都归结为需要再清一遍缓存。

来源

dnsmasq manual，转发、cache-size、host-record、本地 TTL 与 SIGHUP 行为，已核验 2026-09-12。
RFC 1035 domain names，DNS 资源记录与缓存寿命，已核验 2026-09-12。

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

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

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

文中受控示例将三次查询间隔设为 1.2 秒：TTL 1 回源三次，TTL 20 回源一次。下游收到剩余寿命，而非重置的 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。

AAAA 发布 IPv6 地址，不证明该地址可达

Thu, 30 Dec 2027 00:00:00 +0000

一条 AAAA 资源记录保存一个一百二十八位 IPv6 地址，A 记录则保存 IPv4 地址。同一个名称可以只有其中一类、同时拥有两类，或者在每类中包含多个地址。A 与 AAAA 属于不同记录集，因此可以使用不同 TTL。发布 AAAA 让地址能够通过 DNS 被发现，却不会替你创建接口、路由、监听套接字或可用应用；这些条件需要在实际服务路径上成立。

AAAA 发布的 IPv6 数据独立于 DNS 查询传输。文章实验另行验证本地 HTTP 可达性，不证明公网 IPv6 连通性或主机名 TLS。

坏掉的样子

AAAA 查询成功之后，连接仍可能失败。发布的地址可能已经停用，服务可能只监听 IPv4，网络也可能缺少可用 IPv6 路由。两种地址族的防火墙与 TLS 配置也可能不同。只通过 IPv4 做可用性检查，会漏掉这些问题，而双栈用户可能正沿着公开的 IPv6 路径遭遇延迟或错误。记录存在与服务可用是两个需要分别观察的事实。

Happy Eyeballs 通过协调地址发现和连接尝试，减少部分双栈连接延迟，但它属于客户端算法，并不是 DNS 对所有客户端的保证。具体回退行为、截止时间和应用协议仍会影响结果。某个浏览器在一次测试中迅速改用 A 记录成功，不能推出错误 AAAA 对所有调用方无害。尤其对于没有相同行为的库、设备或后台任务，应验证其真实连接策略。

缺少 AAAA 也应准确描述。权威服务器可以对只有 A 的名称返回成功 DNS 状态，却没有 AAAA 数据，这通常称为 NODATA；它不同于表示名称不存在的 NXDOMAIN。仅有 A 的服务也不是在所有 IPv6-only 网络中都绝对不可达：具备相应基础设施时，DNS64 可以合成 AAAA，再通过 NAT64 访问 IPv4 服务器。不能忽略翻译网络这一明确反例。

快速验证

将脚本保存为 check-aaaa.py，准备 Docker 后执行 python3 check-aaaa.py。固定环境使用 BIND 9.18.49 和 dnspython 2.3.0。隔离网络具有可工作的 IPv6 回环接口，但没有外部路由。程序在 ::1 上启动真实 HTTP 监听，分别执行 DNS 查询和 IPv6 连接；它不向公网发布端口，也不依赖修改宿主网络来制造结果：

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
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
import http.client,socket,threading
records='dual 17 IN A 127.0.0.1\ndual 29 IN AAAA ::1\nv4-only 17 IN A 127.0.0.1\nbroken 29 IN AAAA 2001:db8::1234'
class Handler(BaseHTTPRequestHandler):
 def log_message(self,*args):pass
 def do_GET(self):
 body=b'IPv6 response';self.send_response(200);self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
class V6Server(ThreadingHTTPServer):address_family=socket.AF_INET6
with lab(records) as (_,update,cache,queries),V6Server(('::1',0),Handler) as server:
 thread=threading.Thread(target=server.serve_forever,daemon=True);thread.start()
 try:
 a=query('dual.lab.test.','A');aaaa=query('dual.lab.test.','AAAA')
 assert values(a)==['127.0.0.1'] and values(aaaa,'AAAA')==['::1']
 assert a.answer[0].ttl==17 and aaaa.answer[0].ttl==29
 address=values(aaaa,'AAAA')[0];assert len(socket.inet_pton(socket.AF_INET6,address))==16
 client=http.client.HTTPConnection(address,server.server_port,timeout=2)
 client.request('GET','/');reply=client.getresponse();body=reply.read();client.close()
 assert reply.status==200 and body==b'IPv6 response'
 only_a=query('v4-only.lab.test.');assert values(only_a)==['127.0.0.1']
 missing=query('v4-only.lab.test.','AAAA');assert missing.rcode()==0 and missing.answer==[]
 assert len(missing.authority)==1 and missing.authority[0].rdtype==dns.rdatatype.SOA
 broken=query('broken.lab.test.','AAAA');assert values(broken,'AAAA')==['2001:db8::1234']
 unreachable=socket.socket(socket.AF_INET6);unreachable.settimeout(.3)
 try:unreachable.connect(('2001:db8::1234',server.server_port));raise AssertionError('documentation address unexpectedly reachable')
 except OSError as error:failure=type(error).__name__
 finally:unreachable.close()
 print(json.dumps({'A':show(a),'AAAA_over_IPv4_DNS':show(aaaa),'IPv6_HTTP_status':reply.status,
 'AAAA_wire_address_bytes':16,'A_only_AAAA_query':show(missing),'published_but_unreachable':{'answer':show(broken),'connect_error':failure}},sort_keys=True))
 finally:server.shutdown();thread.join(timeout=2)
"""
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)

dual.lab.test 的 A 回答为 127.0.0.1，TTL 为十七秒；AAAA 回答为 ::1，TTL 为二十九秒。两个 DNS 查询都发送到 127.0.0.1 上的 IPv4 DNS 套接字。通过这个套接字收到 AAAA，直接说明记录所描述的地址族与传输 DNS 问答的地址族可以不同。要查询 IPv6 地址，并不要求本次 DNS 数据报本身必须使用 IPv6。

程序将 AAAA 文本转换成打包形式，检查长度为十六字节，再使用返回的 IPv6 地址请求本地 HTTP 服务。实测得到状态 200 和预期正文。这项验证证明选定地址上的 IPv6 回环连接可用，而不把记录存在当作应用验证。A 与 AAAA 的 TTL 对照也检查了不同记录集可以独立配置，不能由其中一类回答推断另一类的寿命。

查询 v4-only.lab.test 的 AAAA 时，返回 NOERROR、空回答区和权威区中的 SOA；名称本身仍有 A 记录。另一个名称 broken.lab.test 成功返回文档地址 2001:db8::1234，随后连接却在隔离环境里失败。这个对照有意把正向 DNS 数据和传输成功分开，同时不会把测试流量发送给真实外部主机，也不把预期失败描述成 DNS 查询失败。

沿每个已发布地址族检查服务

发布 IPv6 前，先确认监听、路由、访问规则和应用行为。既使用正常主机名身份测试，也检查各个公开端点。裸地址 HTTP 成功不能验证基于名称的证书和虚拟主机路由。本例只验证本地 HTTP，不证明公共 IPv6 连通性，也没有评估某个客户端的 Happy Eyeballs 实现。报告结果应限定在实际执行的路径上，避免用局部成功覆盖其他配置责任。

监控和部署记录应同时覆盖两个记录集。删除 AAAA 会改变新的权威回答，却不会撤回客户端已经缓存的地址；现有连接还有自己的生命周期。迁移时按计划保留旧 IPv6 服务重叠期，并比较权威数据与受影响客户端使用的递归解析器。发现旧连接时，要先确认应用是否重新解析，不能把所有仍在访问旧端点的流量都归因于 DNS 缓存。

最后，AAAA 是正向地址数据，即使有些描述把它叫作 IPv6 指针。反向查询使用 ip6.arpa 下的 PTR 记录，名称来自地址的十六进制半字节倒序。发布正向 AAAA 不会自动发布相应反向记录。正向查询、反向命名、地址选择与应用通信彼此相关，但配置和可观察结果不同，应按照服务真正需要的契约逐项检查。

来源

RFC 3596 DNS extensions for IPv6，AAAA 地址数据、DNS 传输独立性与 ip6.arpa 反向名称，已核验 2026-09-12。
RFC 6147 DNS64，合成 AAAA 记录以访问 IPv4 服务器，已核验 2026-09-12。
RFC 8305 Happy Eyeballs version 2，客户端地址选择与连接尝试，已核验 2026-09-12。

区域传送按明确授权与序列号规则复制权威数据

Sun, 05 Dec 2027 00:00:00 +0000

AXFR 传送一个完整 DNS 区域，让另一个服务器或获授权客户端取得数据，副本随后可以依据本地副本提供权威回答。协议不会神奇地识别调用方一定是合法权威服务器，谁能传送由访问控制决定。区域也是明确的权威边界，不等于所有委派子区域的记录，更不是整个组织的 DNS 命名空间。描述复制范围时，应以实际区域内容为准。

同时比较序列号与真实数据。来源中 10 到 11 的修复是具体案例；一般比较使用三十二位序列算术。完整传送边界、TSIG 授权与 SOA 过期各自需要检查。本次未重跑区域传送实验，也未生成共享秘密。

坏掉的样子

修改主服务器数据却不更新 SOA serial，可能让副本以相同版本号提供不同内容。重载主服务器，不会强迫所有副本替换看起来没有变化的区域。DNS 序列号比较使用三十二位序列算术，包括回绕规则；看起来像日期的数字只是运维约定，并不独立保证任何数值修改都表示更新。排查副本差异时，应同时看版本比较与真实数据。

不限制区域传送，可以让任意请求客户端一次取得完整区域内容。来源限制与 TSIG 可以控制访问，但配置语义必须正确。尤其在普通 BIND 允许列表里同时列出地址和密钥，不会自动成为两者都必须满足的条件。应审阅实际访问规则，并从相关来源测试未授权请求，不能因为配置里出现两项限制，就假定它们按预想的逻辑组合生效。

主服务器故障时，副本继续回答的能力受 SOA expiry 约束。记录 TTL 控制下游消费者缓存，不等同于副本权威拷贝的过期计时。超过允许刷新失败窗口后，副本必须停止把这份数据当作当前有效的权威内容。已有成功回答不能证明副本可以无限期独立运行，监控也不应只看进程和端口仍在，而忽略区域已经接近过期。

快速验证

将脚本保存为 check-zone-transfer.py，准备 Docker 后执行 python3 check-zone-transfer.py。两个 BIND 9.18.49 进程运行在隔离容器中，随机生成的一次性 TSIG secret 授权传送且不会打印。实验有意采用很短的刷新与过期值，以便及时观察状态变化；这些是测试设置，不是生产策略建议。整个过程不接触真实区域或现有共享密钥：

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

@contextmanager
def named_process(root,config):
 root.mkdir(exist_ok=True);conf=root/'named.conf';log=root/'named.log';conf.write_text(config)
 run('named-checkconf',str(conf))
 with log.open('w') as output:
 process=subprocess.Popen(['named','-g','-c',str(conf),'-n','1','-U','1'],stdout=output,stderr=subprocess.STDOUT)
 try:
 def ready():
 assert process.poll() is None,log.read_text()
 return re.search(r'\brunning\s*$',log.read_text(),re.M) is not None
 wait(ready);yield process,log
 finally:stop(process)
import base64,secrets
import dns.tsig,dns.tsigkeyring
with TemporaryDirectory(prefix='xbcatm-xfr-') as directory:
 root=Path(directory);primary=root/'primary';secondary=root/'secondary';primary.mkdir();secondary.mkdir()
 secret=base64.b64encode(secrets.token_bytes(32)).decode();keyring=dns.tsigkeyring.from_text({'xfr.lab.test.':secret})
 key_config=f'key "xfr.lab.test." {{ algorithm hmac-sha256; secret "{secret}"; }};'
 zone=primary/'zone'
 def save(serial,address):
 zone.write_text(f'$ORIGIN lab.test.\n$TTL 2\n@ IN SOA ns.lab.test. hostmaster.lab.test. ({serial} 1 1 6 1)\n@ IN NS ns.lab.test.\nns IN A 127.0.0.1\nservice IN A {address}\n')
 run('named-checkzone','lab.test',str(zone))
 def options(path,port):return f'''options {{ directory "{path}"; listen-on port {port} {{127.0.0.1;}}; listen-on-v6 {{none;}};
recursion no; dnssec-validation no; max-cache-size 8m; session-keyfile none; pid-file "{path}/named.pid"; lock-file "{path}/named.lock";
min-refresh-time 1; max-refresh-time 2; min-retry-time 1; max-retry-time 2; }}; controls {{}};'''
 save(10,'127.0.0.2')
 primary_config=key_config+options(primary,1053)+f'''zone "lab.test" {{ type primary; file "{zone}";
allow-transfer {{key "xfr.lab.test.";}}; notify explicit; also-notify {{127.0.0.1 port 1054 key "xfr.lab.test.";}}; }};'''
 secondary_config=key_config+options(secondary,1054)+f'''zone "lab.test" {{ type secondary; file "{secondary}/copy";
primaries {{127.0.0.1 port 1053 key "xfr.lab.test.";}}; allow-transfer {{none;}}; }};'''
 with named_process(primary,primary_config) as (master,master_log),named_process(secondary,secondary_config):
 wait(lambda: values(query('service.lab.test.',port=1054))==['127.0.0.2'])
 def transfer(**kwargs):return [rr for message in dns.query.xfr('127.0.0.1','lab.test.',port=1053,timeout=2,lifetime=4,relativize=False,**kwargs) for rr in message.answer]
 copied=transfer(keyring=keyring,keyname='xfr.lab.test.')
 assert copied[0].rdtype==copied[-1].rdtype==dns.rdatatype.SOA
 assert copied[0][0].serial==copied[-1][0].serial==10
 assert any(str(rr.name)=='service.lab.test.' and any(str(item)=='127.0.0.2' for item in rr) for rr in copied)
 rejected={}
 for label,kwargs in [('unsigned',{}),('wrong_secret',{'keyring':dns.tsigkeyring.from_text({'xfr.lab.test.':base64.b64encode(secrets.token_bytes(32)).decode()}),'keyname':'xfr.lab.test.'})]:
 try:transfer(**kwargs);raise AssertionError('unauthorized zone transfer succeeded')
 except (dns.query.TransferError,dns.tsig.PeerBadSignature) as error:rejected[label]=type(error).__name__
 assert values(query('service.lab.test.'))==['127.0.0.2']
 save(10,'127.0.0.3');master.send_signal(signal.SIGHUP);wait(lambda: values(query('service.lab.test.'))==['127.0.0.3'])
 time.sleep(2.2);unchanged=query('service.lab.test.',port=1054);assert values(unchanged)==['127.0.0.2']
 save(11,'127.0.0.3');master.send_signal(signal.SIGHUP)
 wait(lambda: query('lab.test.','SOA').answer[0][0].serial==11)
 wait(lambda: values(query('service.lab.test.',port=1054))==['127.0.0.3'])
 secondary_soa=query('lab.test.','SOA',1054);assert secondary_soa.answer[0][0].serial==11
 requested_ixfr=transfer(keyring=keyring,keyname='xfr.lab.test.',rdtype='IXFR',serial=10)
 assert requested_ixfr[0][0].serial==11 and requested_ixfr[1].rdtype!=dns.rdatatype.SOA
 assert requested_ixfr[-1].rdtype==dns.rdatatype.SOA and requested_ixfr[-1][0].serial==11
 stop(master)
 while_valid=query('service.lab.test.',port=1054);assert values(while_valid)==['127.0.0.3']
 expired=[]
 def no_longer_served():
 answer=query('service.lab.test.',port=1054);expired.append(answer);return answer.rcode()==dns.rcode.SERVFAIL
 wait(no_longer_served,timeout=12)
 print(json.dumps({'AXFR_SOA_serials':[copied[0][0].serial,copied[-1][0].serial],'AXFR_record_sets':len(copied),
 'unauthorized_transfer_errors':rejected,'same_serial_secondary_address':values(unchanged),'updated_secondary_serial':11,
 'IXFR_without_history_returned_AXFR':True,'primary_stopped_secondary_initially_answers':values(while_valid),
 'secondary_after_SOA_expire':dns.rcode.to_text(expired[-1].rcode())},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)

主区域从序列号十开始，service.lab.test 指向 127.0.0.2。真实副本取得区域并回答该地址；使用授权 TSIG 密钥的普通 Python 客户端也能完成 AXFR。五个记录集条目包含序列号均为十的起始与结束 SOA，以及预期服务数据，证明传送完成，也证明获得授权的非服务器客户端同样能够请求该操作。调用方身份不是由程序名称自动决定的。

未签名请求与使用另一份 secret 的请求都失败，尽管它们来自相同回环环境；普通允许的地址查询仍然成功。被测规则要求区域传送使用指定密钥，并没有让所有 DNS 查询都必须携带 TSIG。认证传送操作与提供普通权威答案是不同边界，应分别验证，避免修复复制授权时意外把常规查询服务也改成另一种访问契约。

接着主服务器把服务地址改为 127.0.0.3，但保留序列号十并重载。经过短刷新窗口，副本仍回答 127.0.0.2。将序列号提高到十一并重载后，副本才取得新地址。实验同时验证了分歧与修复，不是只检查两份配置文件都写了同一个主服务器。即使复制连接和认证正常，错误版本管理仍然会让实际回答保持不同。

请求自序列号十以来的 IXFR 变化时，由于主服务器没有保留该更新的增量历史，返回完整 AXFR 形式，脚本通过 SOA 组织判断结果。最后停止主服务器，副本最初继续回答 127.0.0.3，经过短 SOA 过期窗口后返回 SERVFAIL。该状态变化没有通过调整宿主时间或共享网络设置制造，而是由真实副本刷新与过期流程产生。

分别验证复制、授权与保密性

NOTIFY 可以促使更早检查，周期刷新则提供另一种发现新版本的机会，两者都不使复制瞬间完成。监控各权威服务器的序列号和真实回答，并在过期导致服务中断前调查传送失败。修复序列号错误时，应确保副本获得预期完整状态，不能假定任意后续增量都能修复此前形成的所有内容分歧。必要操作应依据已知状态选择并验证。

有合适变化历史时，IXFR 可以节省工作，但请求类型不保证响应一定为增量。AXFR 可以在 TCP 上跨多个 DNS 消息，因此完成验证必须遵循协议边界。部分流或一条匹配记录，不足以证明整个区域已经到达并可正确提供。生产检查应关注完整传送结果及实际查询行为，而不止复制任务曾经启动或日志出现过连接建立。

TSIG 使用共享密钥认证消息并保护完整性，不会加密区域内容。应保护密钥，并在部署需要时另外提供传输保密性。把传送授权、复制成功、普通查询可用和副本过期作为不同检查，才能清楚说明实际边界。不能依赖“区域传送只会发生在可信服务器之间”的假设来代替明确配置和正反请求验证。

来源

RFC 5936 AXFR，完整区域传送的消息组织与完成条件，已核验 2026-09-12。
RFC 1995 IXFR，增量请求与回退完整传送，已核验 2026-09-12。
RFC 1982 serial number arithmetic，三十二位 DNS 序列号比较与回绕，已核验 2026-09-12。
RFC 8945 TSIG，共享密钥消息认证与完整性，已核验 2026-09-12。
BIND 9.18.49 reference，传送访问规则、通知与副本刷新控制，已核验 2026-09-12。

DoT 与 DoH 保护通往已认证解析器的连接

Thu, 07 Oct 2027 00:00:00 +0000

DNS over TLS 和 DNS over HTTPS 保护其端点之间加密连接上的 DNS 流量。对于典型客户端，这条连接终止于选定解析器；解析器能够读取问题与回答，它随后发出的查询还可能使用不同传输。加密这一跳，不会自动加密整个递归过程，也不会让解析器失去记录所处理名称的能力。隐私范围应按真实连接边界说明，而不是笼统称为整个 DNS 都已保密。

分别观察加密边界与认证证据。853/443 为常用协议端口；8531/8443 属于文章的回环实验。证书失败诊断不能被零退出码掩盖。本图仅依据来源制作：加密 DNS 运行审阅仍待完成，实验未重跑。

坏掉的样子

加密套接字如果没有按预期验证证书，也可能连接到错误端点。应同时验证证书信任链和客户端期望的解析器身份；握手成功本身不能证明这两项检查已启用。失败时悄悄改用其他解析器或明文路径的配置，也会改变隐私契约。需要通过真实调用方了解这些行为，不能只看到配置文件中有一个 TLS 或 HTTPS 地址，就认定所有查询都符合预期。

DoH 使用 HTTPS，但四百四十三端口不会让它在所有网络中都无法识别、无法阻止或完全等同于任意网页流量。目的地址、连接时间和其他元信息仍可观察，TLS 终止点还可以检查明文 HTTP。选择解析器和传输策略时，应考虑这些边界，不能假定 HTTPS URL 会消除所有与 DNS 活动有关的信息暴露，也不能由加密推导解析器不会保存日志。

两种协议的消息边界也不同。DoT 通常使用八百五十三端口，在 TLS 内携带具有两字节 TCP 长度前缀的 DNS 消息。DoH 通常使用四百四十三端口上的 HTTPS 端点。标准 DoH 使用 application/dns-message 传递 DNS 线格式：POST 放在正文，GET 使用经 base64url 编码的 dns 参数。它不是任意 JSON 接口只要套上 HTTPS 就符合标准。

快速验证

将脚本保存为 check-encrypted-dns.py，准备 Docker 后执行 python3 check-encrypted-dns.py。固定 BIND 9.18.49 环境通过其 TLS 和 HTTP/2 库支持两种传输。脚本创建一次性证书，成功探测时显式信任它，并使用隔离回环端口八千五百三十一和八千四百四十三。实验不会向宿主系统安装新信任锚，生成的私钥也不作为文章内容输出：

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

@contextmanager
def named_process(root,config):
 root.mkdir(exist_ok=True);conf=root/'named.conf';log=root/'named.log';conf.write_text(config)
 run('named-checkconf',str(conf))
 with log.open('w') as output:
 process=subprocess.Popen(['named','-g','-c',str(conf),'-n','1','-U','1'],stdout=output,stderr=subprocess.STDOUT)
 try:
 def ready():
 assert process.poll() is None,log.read_text()
 return re.search(r'\brunning\s*$',log.read_text(),re.M) is not None
 wait(ready);yield process,log
 finally:stop(process)
import socket,ssl,struct
def exact(stream,count):
 data=b''
 while len(data)<count:
 more=stream.recv(count-len(data));assert more,'unexpected EOF';data+=more
 return data
with TemporaryDirectory(prefix='xbcatm-dot-') as directory:
 root=Path(directory);certificate=root/'certificate.pem';key=root/'key.pem'
 run('openssl','req','-x509','-newkey','rsa:2048','-nodes','-days','2','-subj','/CN=resolver.lab.test',
 '-addext','subjectAltName=DNS:resolver.lab.test,IP:127.0.0.1','-keyout',str(key),'-out',str(certificate))
 zone=root/'zone';zone.write_text('$ORIGIN lab.test.\n$TTL 30\n@ IN SOA ns.lab.test. hostmaster.lab.test. (1 60 60 3600 30)\n@ IN NS ns.lab.test.\nns IN A 127.0.0.1\nservice IN A 127.0.0.2\n')
 config=f'''tls local-tls {{ key-file "{key}"; cert-file "{certificate}"; }};
http local-http {{ endpoints {{ "/dns-query"; }}; }};
options {{ directory "{root}"; listen-on port 1053 {{127.0.0.1;}};
listen-on port 8531 tls local-tls {{127.0.0.1;}};
listen-on port 8443 tls local-tls http local-http {{127.0.0.1;}};
listen-on-v6 {{none;}}; recursion no; dnssec-validation no; notify no;
pid-file "{root}/named.pid"; session-keyfile none; max-cache-size 8m; }};
controls {{}}; zone "lab.test" {{ type primary; file "{zone}"; }};
'''
 with named_process(root,config):
 context=ssl.create_default_context(cafile=str(certificate));context.set_alpn_protocols(['dot'])
 with socket.create_connection(('127.0.0.1',8531),timeout=2) as raw,context.wrap_socket(raw,server_hostname='resolver.lab.test') as stream:
 q=dns.message.make_query('service.lab.test.','A');wire=q.to_wire();stream.sendall(struct.pack('!H',len(wire))+wire)
 count=struct.unpack('!H',exact(stream,2))[0];response=dns.message.from_wire(exact(stream,count))
 assert response.id==q.id and values(response)==['127.0.0.2'];tls_version=stream.version();alpn=stream.selected_alpn_protocol()
 failures={}
 for name,ctx,hostname in [('untrusted',ssl.create_default_context(),'resolver.lab.test'),('wrong_name',context,'different.lab.test')]:
 try:
 with socket.create_connection(('127.0.0.1',8531),timeout=2) as raw,ctx.wrap_socket(raw,server_hostname=hostname):pass
 raise AssertionError('certificate validation unexpectedly succeeded')
 except ssl.SSLCertVerificationError as error:failures[name]=error.verify_code
 https={}
 for mode in ('https-get','https-post'):
 output=run('dig','@127.0.0.1','-p','8443','service.lab.test.','A','+'+mode,'+tls-ca='+str(certificate),
 '+tls-hostname=resolver.lab.test','+short','+tries=1','+time=2').stdout
 assert output.strip()=='127.0.0.2',output;https[mode]=output.strip()
 doh_rejections={}
 for label,verification in [('untrusted',['+tls-ca','+tls-hostname=resolver.lab.test']),
 ('wrong_name',['+tls-ca='+str(certificate),'+tls-hostname=different.lab.test'])]:
 rejected=run('dig','@127.0.0.1','-p','8443','service.lab.test.','A','+https-get',*verification,'+short','+tries=1','+time=2',check=False)
 diagnostic=rejected.stdout+rejected.stderr
 assert 'TLS peer certificate verification' in diagnostic and 'failed:' in diagnostic,(label,diagnostic)
 assert not re.search(r'^127\.0\.0\.2$',diagnostic,re.M)
 doh_rejections[label]={'exit':rejected.returncode,'diagnostic':diagnostic.strip(),'no_DNS_answer':True}
 wrong_path=run('dig','@127.0.0.1','-p','8443','service.lab.test.','A','+https=/wrong',
 '+tls-ca='+str(certificate),'+tls-hostname=resolver.lab.test','+tries=1','+time=2',check=False)
 assert wrong_path.returncode!=0
 print(json.dumps({'DoT':{'answer':values(response),'TLS_version':tls_version,'ALPN':alpn},'certificate_rejections':failures,
 'DoH_verified_TLS':https,'DoH_certificate_rejections':doh_rejections,'wrong_DoH_path_exit':wrong_path.returncode,
 'wrong_DoH_path_diagnostic':wrong_path.stdout+wrong_path.stderr},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)

Python DoT 客户端认证 resolver.lab.test，实测协商 TLS 1.3 与 ALPN dot，再发送具有长度前缀的 DNS 问题。它读取完整响应，核对消息标识，取得 service.lab.test 的 A 地址 127.0.0.2。连接地址使用回环，而期望 TLS 主机名独立指定，使端点位置与认证身份保持清晰，不会因为直接连接某个 IP 就自动跳过名称检查。

两个 DoT 对照都无法通过证书验证：一个只使用系统信任库，没有加入一次性证书；另一个虽然信任证书，却要求不同主机名。这分别验证信任与名称检查。程序捕获明确的证书验证异常，而不是把任意套接字故障都当成“证书检查有效”的证据。只有失败原因与测试条件相符，负向案例才真正证明预期边界。

DoH 部分使用 dig，对 /dns-query 分别进行 HTTPS GET 与 POST，并明确设置 CA 和主机名验证。两者都返回 127.0.0.2。不可信证书和错误名称对照会输出证书校验失败且没有 DNS 回答，但这个版本的退出码仍为零，因此断言检查诊断与回答，不能只依赖退出码。使用有效信任设置请求 /wrong 也失败，说明经过认证的 HTTPS 仍需要正确端点路径。

错误路径诊断表示交换失败，不是 NXDOMAIN，也不能证明 service.lab.test 消失。本例没有从该诊断提取具体 HTTP 状态，而是保留传输或端点失败，与完整 DNS 响应携带 DNS 状态码之间的区别。不能把通用命令失败当成权威否定回答，否则会把修复端点配置的问题误导成反复修改域名记录。

明确解析器与引导配置

客户端连接加密解析器前，需要先知道它的地址。部署可以提供引导地址或其他文档规定的发现路径。本例直接给出回环地址，避免依赖同一解析器形成循环。生产中应验证实际客户端如何处理引导、证书续期、端点变化和连接失败。加密链路建立之前的发现过程，以及失败后的处理方式，都属于完整行为契约的一部分。

确认应用查询实际经过已配置的加密连接。其他进程可能使用系统解析器、另一套浏览器配置或现有缓存。一次成功 DoH 命令只证明这条命令的路径，不代表整机策略已经生效。应观察目标应用和它们的失败行为，再说明哪些名称查询具有相同传输保护。否则局部探测成功，可能掩盖真正业务仍走另一条路径的事实。

最后，DNSSEC 与加密 DNS 处理不同属性。DNSSEC 可以沿信任链认证签名数据，TLS 则保护并认证所选传输端点，两者不会自动提供对方保证。服务契约需要时可以同时使用，但证书验证、实际加密查询、解析器信任和 DNS 数据验证，应保留各自证据。按真实机制说明保护范围，才能避免把一种成功扩大成全部安全属性都已成立。

来源

RFC 7858 DNS over TLS，TLS 传输、专用端口与连接消息边界，已核验 2026-09-12。
RFC 8484 DNS over HTTPS，DoH GET、POST 映射与 application/dns-message，已核验 2026-09-12。
BIND 9.18.49 tools，dig 加密传输与显式证书验证，已核验 2026-09-12。

CNAME 改变 DNS 解析路径，请求主机名仍保持原样

Fri, 09 Jul 2027 00:00:00 +0000

CNAME 记录把一个别名与另一个 DNS 名称关联起来。通过别名解析地址时，解析器沿目标继续查找，直到获得请求的数据或遇到失败。这可以让公开主机名保持稳定，同时改变它背后的 DNS 依赖。它不会让浏览器跳转到另一个 URL，也不会替换应用正在请求的主机名；是否改变客户端可见地址，应由相应应用协议行为决定。

坏掉的样子

别名解析完全正常，目标服务器仍可能返回错误网站。HTTP 继续标识原始主机名，HTTPS 证书验证也关联所请求的服务身份。如果只配置目标名称对应的虚拟主机或证书，原别名请求未必能够工作。DNS 提供的是获得地址的路径，选中的服务器还必须接受用户和应用真正请求的名称。仅检查最终 IP 相同，无法验证这项应用契约。

CNAME 不能与普通 A、AAAA、TXT 等数据共存于同一个所有者名称。DNSSEC 元数据存在特定例外，但这不会让 CNAME 与 A 共存变得有效。普通区域顶点本来就需要 SOA 和 NS，因此在顶点放传统 CNAME 会产生冲突。服务商提供的别名展平等功能，应依据其实际文档理解，不能把界面里类似的名称直接当成标准 CNAME 规则发生变化。

别名链可能终止于不存在的数据，也可能形成循环。每个依赖还有自己的缓存寿命与管理边界；缩短别名 TTL，不会缩短以另一个记录集缓存的目标地址。同时，并非每增加一个别名都必然增加一次网络往返：服务器可能在同一回答中附带多段链，解析器也可能已经缓存相关数据。延迟分析应结合实际问答，而不是机械按链长计数。

解析别名，保留请求身份。依据原文与明确限制静态绘制；未为本图重跑原文夹具。

快速验证

将脚本保存为 check-cname.py，准备 Docker 后执行 python3 check-cname.py。固定环境使用 BIND 9.18.49、dnsmasq 2.90 和小型 HTTP 服务。所有名称均属于隔离测试区域；解析配置修改和候选区域文件留在可丢弃容器内部，不改公共域名或宿主解析器。运行结束后，脚本清理自己创建的实例和临时镜像标签：

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
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
import http.client,threading
records='alias 9 IN CNAME middle.lab.test.\nmiddle 12 IN CNAME target.lab.test.\ntarget 20 IN A 127.0.0.1\nloop-a 9 IN CNAME loop-b.lab.test.\nloop-b 9 IN CNAME loop-a.lab.test.'
class Handler(BaseHTTPRequestHandler):
 def log_message(self,*args):pass
 def do_GET(self):
 body=json.dumps({'host':self.headers['Host'],'path':self.path}).encode()
 self.send_response(200);self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
with lab(records) as (root,update,cache,queries),ThreadingHTTPServer(('127.0.0.1',0),Handler) as server:
 chain=query('alias.lab.test.');assert values(chain)==['127.0.0.1']
 assert values(chain,'CNAME')==['middle.lab.test.','target.lab.test.']
 assert [r.ttl for r in chain.answer]==[9,12,20]
 invalid={}
 for case,addition in [('same_owner','alias IN A 127.0.0.2'),('apex','@ IN CNAME target.lab.test.')]:
 candidate=root/(case+'.zone');candidate.write_text((root/'zone').read_text()+addition+'\n')
 checked=run('named-checkzone','lab.test',str(candidate),check=False)
 assert checked.returncode!=0 and 'CNAME and other data' in checked.stdout+checked.stderr
 invalid[case]={'returncode':checked.returncode,'diagnostic':'CNAME and other data'}
 seen=set();name='loop-a.lab.test.';hops=[]
 while name not in seen:
 seen.add(name);answer=query(name,'CNAME');target=values(answer,'CNAME')[0];hops.append([name,target]);name=target
 assert len(hops)==2 and name=='loop-a.lab.test.'
 cache(port=53)
 Path('/etc/resolv.conf').write_text('nameserver 127.0.0.1\noptions timeout:1 attempts:1\n')
 nss=Path('/etc/nsswitch.conf');nss.write_text(re.sub(r'^hosts:.*$','hosts: dns',nss.read_text(),flags=re.M))
 thread=threading.Thread(target=server.serve_forever,daemon=True);thread.start()
 try:
 client=http.client.HTTPConnection('alias.lab.test',server.server_port,timeout=2)
 client.request('GET','/original');response=client.getresponse();body=json.loads(response.read());client.close()
 assert response.status==200 and body=={'host':'alias.lab.test:'+str(server.server_port),'path':'/original'}
 print(json.dumps({'chain':show(chain),'invalid_candidates':invalid,'loop_detected_by_client':hops,'HTTP':body,'HTTP_status':response.status},sort_keys=True))
 finally:server.shutdown();thread.join(timeout=2)
"""
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)

查询 alias.lab.test 的地址，得到两条 CNAME 和最终 A：alias 指向 middle，middle 指向 target，target 的地址为 127.0.0.1。对应 TTL 分别为九秒、十二秒和二十秒。这个权威回答一次包含完整本地区域内的链，所以实验没有把两段别名描述成必然需要另外两次 DNS 交换，也没有把三个独立寿命压成一个统一 TTL。

两个独立候选区域分别制造无效组合：一个在别名所有者处增加 A，另一个在区域顶点增加 CNAME。named-checkzone 都以“CNAME and other data”拒绝。候选文件不会替换正在工作的有效区域。这种方式验证了配置限制，同时明确区分候选检查失败与已激活配置，避免把无效区域当作一种正常运行但效果特殊的配置。

另两个别名互相指向，形成圆环。示例客户端逐个明确查询 CNAME，记住访问过的名称，在两次跳转后检测到重复。这是对循环本身的有界验证，不是对所有递归解析器面对循环时的超时、重试次数或错误码进行测量。生产排障仍需查看实际解析器的诊断信息，不能用这个客户端循环检测器代替其完整实现。

最后，Python HTTP 客户端通过容器正常名称解析路径请求 alias.lab.test。服务器回显的 Host 仍为该别名加临时端口，路径为 /original，状态为 200。客户端没有被手工要求把目标名称代入 Host。这个结果证明解析可以沿 CNAME 链获得地址，同时保留原 HTTP 服务身份和请求路径；DNS 别名不会自动产生浏览器重定向。

移动依赖，同时维持服务契约

切换别名前，先让目标服务接受原主机名，按需要准备路由和证书，并验证两个地址族及服务商域名归属检查。指向外部服务的别名，还依赖该服务持续保留正确资源；悬空目标可能涉及归属与可用性问题，不能只因公开名称没变就认为没有风险。验收应覆盖应用请求，而不止 DNS 链末尾出现了一个地址。

迁移计划应考虑所有相关缓存记录集。修改别名目标与修改旧目标地址是不同操作。对照权威回答、递归回答和应用流量，才能区分缓存中的旧链段与新目的地配置错误。按所需重叠期保留旧端点，不应假定公开名称稳定就意味着切换立即完成。回滚同样会受到已经缓存的新别名关系影响，需要保留可服务的过渡路径。

让别名链保持可理解，为每段依赖明确负责人，并检查目标缺失和循环。如果目标是改变客户端看到的 URL，应使用合适的 HTTP 重定向；如果目标是建立 DNS 别名关系，则使用 CNAME 并单独验证应用。名称、地址和应用身份之间的关系应当由实际配置与请求结果共同说明，而不是依靠“指向另一台机器”的模糊描述。

来源

RFC 1034 domain names，别名处理、规范名称与循环处理，已核验 2026-09-12。
RFC 2181 DNS clarifications，CNAME 共存限制与记录集 TTL 规则，已核验 2026-09-12。
BIND 9.18.49 tools，使用 named-checkzone 验证候选区域数据，已核验 2026-09-12。

多个 DNS 地址不保证流量均匀或端点健康

Tue, 06 Jul 2027 00:00:00 +0000

同一名称下的多条 A 或 AAAA 记录提供一个地址集合。DNS 服务器可能轮换返回顺序，但收到集合后如何使用，由解析器和应用决定。普通地址记录不携带请求负载测量或应用健康结果；仅仅存在多个地址，不能保证均匀流量、自动故障转移，甚至不能保证不同实现看到相同的第一个地址。应将地址发现与后续选择分别理解。

轮换地址集合不会按应用请求调度，也不会自动检测端点健康。文章中的一次保存选择造成十二比零分布，恢复依赖客户端明确重试。此图未新增运行验证。

坏掉的样子

DNS 回答分布与应用请求分布的分母不同。一个递归解析器可以用缓存回答许多客户端，一个应用也可能只查询一次，随后发出数千次请求。连接池会进一步强化这种差异。即便权威回答中的首个地址完美交替，实际服务器请求量仍可能严重不均。只统计 DNS 查询数量，不能证明用户业务已经按同样比例分配。

普通静态记录集中的端点失败后，其地址仍会保留，直到 DNS 数据被修改或另一个系统主动修改它。DNS 服务器不会仅因返回地址就知道应用健康状态。有的客户端连接失败后会尝试其他地址，有的会耗尽截止时间或者直接向调用方报错。是否重试、何时重试及哪些操作可重试，都应针对实际客户端和业务验证，不能默认由 DNS 完成。

把这种机制描述成保证公平的抛硬币，也不准确。顺序可能由配置决定、被随机化、被缓存保留，或者被地址选择策略重排。客户端可能选择首项、并发尝试，或复用先前结果。要解释一次分布观察，除了后端请求计数，还需要知道 DNS 配置、解析器行为、连接复用和工作负载；少了这些条件，无法判断不均衡出现在哪一层。

快速验证

将脚本保存为 check-dns-addresses.py，准备 Docker 后执行 python3 check-dns-addresses.py。固定环境使用 BIND 9.18.49，并明确把 rrset-order 设置为循环顺序。两个真实 HTTP 监听在隔离容器中绑定不同回环地址、使用相同临时端口，响应正文标识真正处理请求的端点。脚本不依赖公网域名，也不会访问现有业务服务器：

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
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
import http.client,threading
class Handler(BaseHTTPRequestHandler):
 def log_message(self,*args):pass
 def do_GET(self):
 body=self.server.server_address[0].encode();self.server.hits+=1
 self.send_response(200);self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
def request(address,port):
 connection=http.client.HTTPConnection(address,port,timeout=.5)
 try:
 connection.request('GET','/');response=connection.getresponse();assert response.status==200;return response.read().decode()
 finally:connection.close()
with lab('pool 30 IN A 127.0.0.2\npool 30 IN A 127.0.0.3',extra='rrset-order { order cyclic; };') as (_,update,cache,queries):
 servers=[];threads=[]
 try:
 for address in ['127.0.0.2','127.0.0.3']:
 server=ThreadingHTTPServer((address,0 if not servers else servers[0].server_port),Handler);server.hits=0
 thread=threading.Thread(target=server.serve_forever,daemon=True);thread.start();servers.append(server);threads.append(thread)
 port=servers[0].server_port;orders=[values(query('pool.lab.test.')) for _ in range(6)]
 assert all(set(order)=={'127.0.0.2','127.0.0.3'} for order in orders)
 assert {tuple(order) for order in orders}=={('127.0.0.2','127.0.0.3'),('127.0.0.3','127.0.0.2')}
 saved=values(query('pool.lab.test.'));selected=saved[0]
 hits=[request(selected,port) for _ in range(12)];assert hits==[selected]*12
 distribution={s.server_address[0]:s.hits for s in servers};assert sorted(distribution.values())==[0,12]
 victim=next(s for s in servers if s.server_address[0]==selected);victim.shutdown();victim.server_close()
 still_published=values(query('pool.lab.test.'));assert selected in still_published
 try:request(selected,port);raise AssertionError('stopped HTTP server accepted a connection')
 except OSError as error:failure=type(error).__name__
 alternate=next(a for a in saved if a!=selected);assert request(alternate,port)==alternate
 print(json.dumps({'cyclic_answer_orders':orders,'one_lookup_twelve_requests':distribution,'after_peer_stopped':still_published,
 'selected_address_error':failure,'explicit_alternate_succeeded':alternate},sort_keys=True))
 finally:
 for server in servers:server.shutdown();server.server_close()
 for thread in threads:thread.join(timeout=2)
"""
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)

对 pool.lab.test 进行六次直接查询，实测每次都返回 127.0.0.2 与 127.0.0.3，只是顺序交替。所有回答都包含完整地址集，断言同时检查成员与顺序变化。这证明的是当前权威服务器显式配置后的行为，不代表所有 DNS 服务器都必须轮换，也不保证递归缓存或最终应用会保持这个顺序。完整集合与首项顺序是不同检查点。

随后程序另外查询一次，保存列表，并用首个地址发送十二次 HTTP 请求。全部请求到达选中监听，分布为十二比零。每个请求都新建 HTTP 连接，因此这种不均衡甚至不需要连接池；只要在多个连接之间保留一次 DNS 选择，就足以让回答轮换与请求分配脱钩。响应正文和服务端计数共同确认了实际处理端点。

接着停止被选中的监听并关闭套接字。新的权威 DNS 查询仍包含其地址，因为区域没有修改。连接该端点时，实测得到 ConnectionRefusedError。程序随后明确选择保存列表里的另一个地址并成功取得响应。这证明仍有可用替代端点，但切换动作来自客户端代码；实验没有把显式重试伪装成 DNS 自动检测故障或自动迁移连接。

明确分配与失败处理契约

如果简单地址分布已经满足需求，应让所有公开端点都能服务该主机名和预期负载。既监控整体名称，也直接检查每个端点。通过一个地址成功，不能证明其他地址也健康，尤其客户端可能悄悄尝试替代地址，从调用方眼中隐藏第一次失败。监控应保留连接尝试和最终响应之间的区别，避免把被重试掩盖的问题长期留在地址集里。

若 DNS 服务商提供健康摘除，还需计算检测延迟与已经缓存的回答。依据健康状态修改 DNS 可以改善后续发现，却不会撤回旧回答或移动现有连接。按需求明确客户端重试策略和迁移重叠期。降低 TTL 改变缓存成本与刷新速度之间的取舍，但不会使 DNS 获得按应用请求调度的能力；故障恢复时间不能只由一个 TTL 数字推导。

需要逐请求路由、容量权重或有界故障转移时，应评估合适的负载均衡器以及实际健康检查和重试配置，同时承担其运维责任。比较依据应是可观察契约，而不是把 DNS 想成纯随机、把代理想成永不失败。应记录真正处理请求的端点，以及停止一个端点后用户看到的结果，这些数据才直接对应业务体验和选型要求。

名称、类别和类型相同的地址记录属于一个记录集，成员应使用一致 TTL。给其中各个地址设置不同寿命，并不是表达权重的可靠方式。需要权重时选择语义明确、实现支持的策略，并在真实解析器共享和连接复用条件下验证。只有把发现、选择、健康检测与重试的责任说清，才适合承诺流量会如何分散以及失败时会怎样恢复。

来源

RFC 2181 DNS clarifications，完整记录集与集内一致的 TTL，已核验 2026-09-12。
BIND 9.18.49 reference，rrset-order 与显式循环回答顺序，已核验 2026-09-12。
RFC 1034 domain names，解析器行为与资源记录缓存，已核验 2026-09-12。

SRV 提供目标和端口，客户端必须理解其选择规则

Sat, 13 Mar 2027 00:00:00 +0000

SRV 通过优先级、权重、端口和目标主机名描述服务位置。它的所有者通常组合服务标签、传输标签与域名，例如 _echo._tcp.lab.test。理解该服务的客户端可以先查 SRV，再通过 A 或 AAAA 取得目标地址，连接记录给出的端口。普通主机名查询不会自动执行这套应用相关的发现流程，服务名与查询方式必须由调用方契约明确。

优先级选择可达的组，权重只在同组内起作用。文章每组只有一个目标；故障转移展示客户端处理，不是同组加权选择或 DNS 健康摘除。

坏掉的样子

发布 SRV 不会让所有现有客户端自动采用它。应用需要规定服务标签，并实际支持相应发现行为。只接受普通主机名和配置端口的浏览器或库，可能根本不询问 SRV。因此，手工查询 SRV 成功，不能证明应用已经改变端点选择，也不能据此宣布今后不再需要更新配置。验证应沿真实调用方进行，不能止于区域里已有记录。

优先级和权重不是可互换字段。在可达目标中，较低数值优先级更优先；权重只影响相同优先级记录之间的选择。较高数值备机即使具有很大权重，也不能越过可用的低数值目标。把所有记录按权重统一排序，或直接采用报文中的首项，都可能反转服务所有者设计的主备关系。解释结果前，应确认客户端是否正确使用这些字段。

发现也不证明健康。监听停止后，目标仍可继续被发布，SRV 与目标地址记录集还具有各自缓存寿命。客户端需要连接截止时间与适当重试策略。连接被拒绝后重试读取，与重复可能已产生副作用的操作不同；端点故障转移必须符合应用协议，不能因为还有候选项，就无条件把每个业务动作再执行一遍。

快速验证

将脚本保存为 check-srv-discovery.py，准备 Docker 后执行 python3 check-srv-discovery.py。固定 BIND 9.18.49 环境发布测试 _echo._tcp 服务，两个真实 HTTP 监听在不同临时端口提供可识别的只读响应。HTTP 只是实验中便于观察的载荷；示例是自定义 SRV 客户端，不代表通用 HTTP 客户端本来就实现了这个服务标签：

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

@contextmanager
def named_process(root,config):
 root.mkdir(exist_ok=True);conf=root/'named.conf';log=root/'named.log';conf.write_text(config)
 run('named-checkconf',str(conf))
 with log.open('w') as output:
 process=subprocess.Popen(['named','-g','-c',str(conf),'-n','1','-U','1'],stdout=output,stderr=subprocess.STDOUT)
 try:
 def ready():
 assert process.poll() is None,log.read_text()
 return re.search(r'\brunning\s*$',log.read_text(),re.M) is not None
 wait(ready);yield process,log
 finally:stop(process)
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
import http.client,threading
class Handler(BaseHTTPRequestHandler):
 def log_message(self,*args):pass
 def do_GET(self):
 body=self.server.identity.encode();self.send_response(200);self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
servers=[];threads=[]
try:
 for identity in ('primary','backup'):
 server=ThreadingHTTPServer(('127.0.0.1',0),Handler);server.identity=identity
 thread=threading.Thread(target=server.serve_forever,daemon=True);thread.start();servers.append(server);threads.append(thread)
 records=f'''_echo._tcp 30 IN SRV 10 1 {servers[0].server_port} first.lab.test.
_echo._tcp 30 IN SRV 20 65535 {servers[1].server_port} second.lab.test.
_absent._tcp 30 IN SRV 0 0 0 .
first 30 IN A 127.0.0.1
second 30 IN A 127.0.0.1'''
 with lab(records) as (_,update,cache,queries):
 srv=query('_echo._tcp.lab.test.','SRV');entries=sorted(srv.answer[0],key=lambda r:r.priority)
 assert [r.priority for r in entries]==[10,20] and [r.weight for r in entries]==[1,65535]
 def discover():
 attempts=[]
 for record in entries:
 addresses=values(query(str(record.target)))
 for address in addresses:
 client=http.client.HTTPConnection(address,record.port,timeout=.5)
 try:
 attempts.append(str(record.target));client.request('GET','/');response=client.getresponse();body=response.read().decode()
 assert response.status==200;return {'identity':body,'attempted_targets':attempts,'selected_port':record.port}
 except OSError:continue
 finally:client.close()
 raise AssertionError('all service endpoints failed')
 first=discover();assert first['identity']=='primary' and first['attempted_targets']==['first.lab.test.']
 servers[0].shutdown();servers[0].server_close()
 assert len(query('_echo._tcp.lab.test.','SRV').answer[0])==2
 failed_over=discover();assert failed_over['identity']=='backup' and len(failed_over['attempted_targets'])==2
 absent=query('_absent._tcp.lab.test.','SRV');assert str(absent.answer[0][0].target)=='.'
 ordinary=query('lab.test.','A');assert ordinary.rcode()==0 and not ordinary.answer
 print(json.dumps({'SRV':show(srv),'healthy_selection':first,'after_primary_stopped':failed_over,
 'ordinary_A_lookup':show(ordinary),'unavailable_service':show(absent)},sort_keys=True))
finally:
 for server in servers:server.shutdown();server.server_close()
 for thread in threads:thread.join(timeout=2)
"""
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)

第一目标优先级为十、权重为一，备机优先级为二十、权重为六万五千五百三十五。两者分别公布真实监听端口，目标名都解析到回环地址。客户端读取 SRV，按不同优先级组排序，再解析目标并连接记录端口。两个监听都健康时，只访问第一目标并收到主节点身份，说明备机的大权重不会跨越优先级组改变这次选择。

程序随后停止主监听，保持 DNS 不变。新的 SRV 查询仍包含两条记录。客户端复用此前发现的候选集合，先尝试主节点，遇到连接失败后再成功访问备机。结果记录两个尝试名称和最终端口。失败目标没有被 DNS 摘除，转换动作来自客户端连接处理。这个对照区分了发现数据更新与利用现有候选项完成一次故障转移。

另一个服务只有一条 SRV，目标为根名称 .。RFC 2782 将这种形式定义为该域明确不提供服务，而不是要求解析根并连接它。与此同时，普通 A 查询 lab.test 没有地址回答，尽管 _echo._tcp 记录存在。这说明查询类型和服务发现名称都是契约的一部分，不能只因同属一个域，就假定不同查询会自动得到等价服务位置。

让客户端算法匹配所发布的集合

本例有意让每个优先级组只有一个目标，因此排序足以处理这些记录，没有实现同组内的加权顺序。通用客户端需要遵循协议完整选择行为，包括同优先级权重和明确不可用案例。应使用真实库测试相应分支，不能看到“支持 SRV”的标签就假定完全符合标准。示例的边界被明确限定，避免简化代码被误当成完整通用客户端。

按照 RFC 2782，SRV 目标应是具有地址记录的主机名称，不能是别名。检查目标 A、AAAA、端口监听和所需服务身份。地址返回本身不验证 TLS 证书、身份认证或应用就绪状态；有些协议还规定额外发现记录或身份规则，应以其文档为准。不能为了复用一个方便布局，忽略真正协议对于主机名、端口和认证对象的定义。

按相关缓存寿命与部署策略刷新发现结果。修改 SRV 不会撤回缓存目标，修改目标地址也不会改变既有连接。计划移除节点时，需要考虑保留候选项的调用方，并排空现有工作。结合权威发布、解析器回答和实际连接尝试，才能区分旧发现数据与已经可达但拒绝业务操作的服务器；两类问题需要不同的处理路径。

明确服务标签归属和记录修改权限。DNS 发现可以减少硬编码端点配置，同时把责任转移到记录和客户端选择逻辑中。应验证普通请求、首选端点失败，以及之后的替代连接。这样的证据比只确认区域文件里存在服务记录，更直接地证明系统实现了有用行为，也能说明缓存、优先级与重试策略究竟如何共同影响请求结果。

来源

RFC 2782 DNS SRV records，优先级、权重、端口、目标与明确服务不可用，已核验 2026-09-12。
RFC 1035 domain names，地址记录与 DNS 缓存，已核验 2026-09-12。
BIND 9.18.49 reference，权威区域数据与服务记录，已核验 2026-09-12。

有用的主机名应区分本地身份、服务名称与查询范围

Tue, 01 Dec 2026 00:00:00 +0000

有用的名称为人和软件提供一个可以跨地址变化继续使用的引用，但这个引用需要明确范围与负责人。机器的本地主机名、服务 DNS 名称和实例标识可以有意不同。清楚命名有助于理解日志和部署，而不是假定一个标签自动建立系统中的所有其他身份。规划名称时，应先说明它标识的是哪类对象，以及希望保持稳定多久。

坏掉的样子

设置本地主机名，本身不会向权威区域发布 A 或 AAAA。注册可能由独立部署或网络管理软件完成，但那条流程必须实际存在。反过来，修改 DNS 地址也不会重命名内核的本地主机名。混淆两者，会产生本地标签看似正确、客户端却无法发现服务的机器。排障时应分别检查本地状态、注册动作和权威数据，不能用其中一个代替其他证据。

短名称依赖查询上下文。即使两台机器都使用正常 DNS 配置，service 在不同搜索域下仍可能指向不同目的地。复制的运行手册命令因此可能到达与作者测试不同的环境。配置中不能容忍歧义时，应使用完整目标 DNS 名称；交互操作使用短名时，也应保留解释它所需的上下文。名称看起来一样，并不意味着它在所有进程里具有相同范围。

人类可读的含义也有限制。app-prod-01 可以提示角色、环境与实例，却不是权限、归属或当前工作负载的权威证据。复用旧实例名称还可能混淆历史日志。服务名称与替换机器的生命周期不同时，应分别命名，并使用运维元数据记录变化事实，不要试图把所有信息都塞进主机名。方便阅读的前缀也不能成为授予访问权限的依据。

短名继承查询上下文。依据原文与明确限制静态绘制；未为本图重跑原文夹具。

快速验证

将脚本保存为 check-hostnames.py，准备 Docker 后执行 python3 check-hostnames.py。固定环境使用 BIND 9.18.49、dnsmasq 2.90 和 Python 3.11，解析器及 NSS 配置都位于可丢弃容器中。本实验关闭转发缓存，使搜索域和地址变化可以直接观察，不必等待上一代缓存寿命；这项设置用于隔离变量，不代表所有生产客户端都应关闭缓存：

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
import socket
records='service 30 IN A 127.0.0.2\nservice.branch 30 IN A 127.0.0.3\n_echo._tcp 30 IN SRV 0 0 8080 service.lab.test.'
with lab(records) as (root,update,cache,queries):
 cache(port=53,size=0)
 nss=Path('/etc/nsswitch.conf');nss.write_text(re.sub(r'^hosts:.*$','hosts: dns',nss.read_text(),flags=re.M))
 def search(domain):Path('/etc/resolv.conf').write_text('nameserver 127.0.0.1\nsearch '+domain+'\noptions timeout:1 attempts:1\n')
 def address(name):
 return json.loads(run('/usr/bin/python3','-c','import socket,json,sys;print(json.dumps(sorted({r[4][0] for r in socket.getaddrinfo(sys.argv[1],80,socket.AF_INET,socket.SOCK_STREAM)})))',name).stdout)
 local_name=socket.gethostname();unpublished=query(local_name+'.lab.test.');assert unpublished.rcode()==dns.rcode.NXDOMAIN
 lower=query('service.lab.test.');mixed=query('SeRvIcE.LaB.TeSt.');assert values(lower)==values(mixed)==['127.0.0.2']
 search('lab.test');first=address('service');absolute_first=address('service.lab.test.');assert first==absolute_first==['127.0.0.2']
 search('branch.lab.test');second=address('service');absolute_second=address('service.lab.test.');assert second==['127.0.0.3'] and absolute_second==first
 update(records.replace('service 30 IN A 127.0.0.2','service 30 IN A 127.0.0.4'));changed=address('service.lab.test.')
 assert changed==['127.0.0.4'] and socket.gethostname()==local_name
 invalid=root/'invalid.zone';invalid.write_text((root/'zone').read_text()+'bad_name IN A 127.0.0.1\n')
 check=run('named-checkzone','-k','fail','lab.test',str(invalid),check=False)
 assert check.returncode!=0 and 'bad owner name' in check.stdout+check.stderr
 assert values(query('_echo._tcp.lab.test.','SRV'),'SRV')==['0 0 8080 service.lab.test.']
 print(json.dumps({'local_hostname_published_in_zone':False,'case_insensitive_A':values(mixed),
 'short_name_by_search_domain':{'lab.test':first,'branch.lab.test':second},'absolute_name_unchanged_by_search':[absolute_first,absolute_second],
 'DNS_address_after_change':changed,'local_hostname_unchanged':True,'invalid_host_owner_rejected':check.returncode,'underscore_SRV_owner_accepted':True},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)

脚本读取容器本地主机名，再查询该标签位于 lab.test 下的名称。由于没有发布相应区域记录，权威返回 NXDOMAIN。这说明当前环境缺少这项注册，不是在断言所有安装都不会自动注册主机名。对 service.lab.test 分别使用全小写与混合大小写查询，都返回 127.0.0.2，展示 DNS 中 ASCII 名称比较不区分大小写。

搜索域为 lab.test 时，新应用进程查询 service 得到 127.0.0.2；改为 branch.lab.test 后，同一短输入得到 127.0.0.3。而绝对名称 service.lab.test. 在两个上下文中都返回 127.0.0.2。末尾根点明确标记这个实验中的绝对 DNS 名称，使结果不依赖搜索列表补全。这个对照解释了短命令为何可能随运行环境改变目标。

随后权威把 service.lab.test 改到 127.0.0.4，新查询看到新地址，本地主机名却保持原样。这验证 DNS 映射与机器标签独立。它不证明已有连接自动移动，也不证明其他缓存立即刷新；那些行为有各自寿命，被有意排除在此次关闭缓存的比较之外。稳定名称的价值，是让调用方保留引用，而不是取消所有迁移与状态管理工作。

最后，A 记录候选所有者 bad_name 在 named-checkzone -k fail 下被判为不合格主机名称；有效的 _echo._tcp SRV 所有者仍被接受并可查询。这区分了严格主机地址名称检查与更广泛的 DNS 命名空间。服务标签使用下划线，不表示普通主机名适用同样规则，也不表示每个 DNS 标签都必须按主机标签验证。

按对象寿命与使用者选择名称

采用有文档、可预测的约定，提供足够信息区分环境和实例，同时避免在公开名称中放入敏感或频繁变化的细节。替换稳定服务名背后的机器时，应有意识地更新发现数据与服务配置，保留所需地址重叠期。稳定拼写便于调用方继续引用，但 TLS、路由和应用状态仍需提前准备。名称设计应支持这些操作，而不是掩盖它们的存在。

资产清单和故障证据中，应并列记录完整域名与本地主机名。显示时可以保留大小写，但不要把仅 ASCII 大小写不同的 DNS 名称当成两个服务。关联数据集时，也应按标识符实际规则规范化；任意应用标识或 URL 路径可能具有与 DNS 主机名不同的大小写语义。不能因为某一层比较不敏感，就对整条字符串执行同样转换。

部署前，依据消费这些名称的系统规则检查生成结果。DNS 标签、证书身份、操作系统主机名与服务发现标签彼此相关，却不是可互换的验证范围。内核接受一个名称，不等于它适合作普通互联网主机名。让人的理解和技术范围都保持明确，名称才能在日常操作、替换实例和复盘历史时持续提供帮助，而不成为另一种隐含假设。

来源

RFC 1123 Internet host requirements，主机名推荐语法与命名要求，已核验 2026-09-12。
RFC 4343 DNS case insensitivity，DNS 中 ASCII 名称不区分大小写的比较，已核验 2026-09-12。
Python 3.11 socket documentation，gethostname 与应用地址查询，已核验 2026-09-12。
RFC 2782：DNS SRV 记录，服务与协议标签有意使用下划线前缀，已核验 2026-10-15。

UDP 回答被截断时，DNS 需要可工作的 TCP 路径

Thu, 19 Nov 2026 00:00:00 +0000

DNS 同时支持 UDP 和 TCP。服务器因可用消息空间而截断响应时，会设置 TC 标志。客户端收到该标志，需要处理结果不完整的情况，通常通过 TCP 重新查询。这涉及当前使用的 DNS 响应限制，并不直接证明物理网络无法承载任何更大的 UDP 数据报。排障时应先确认协议层发生了什么，再讨论传输路径的实际容量。

即使包含记录，TC 仍说明回答不完整。可用 TCP 路径能取回完整集合，只提供 UDP 的端点则无法完成。文章还展示消息边界与连接复用；这不表示 DNS 已加密。

坏掉的样子

允许 UDP 五十三端口却阻止 TCP 五十三端口的网络，可能小查询正常，大回答失败。DNSSEC 数据和较大记录集容易暴露这种差异，但 TCP 并不只用于这些特殊情况。通用 DNS 实现需要支持 TCP，客户端也可以直接选择它。因此，一次小型 UDP 查询成功，不能证明整个 DNS 服务的传输路径完整，尤其不能代替对 TCP 监听和访问规则的检查。

被截断的回答仍可能包含部分记录。如果忽略 TC，把这些记录当成完整集合，就可能漏掉有效目的地或必需数据。NOERROR 不会抵消截断标志。当应用看到的记录比另一种传输方式下的权威查询少时，应保留完整问题、响应标志和记录数量，不要只提取一个地址或文本值。仅凭有内容返回，并不能判断这次 DNS 交换已经完整结束。

TCP 也没有取消所有 DNS 消息大小限制。TCP 流中，每个 DNS 消息之前都有两字节长度字段，因此单个消息最多六万五千五百三十五字节；区域传送可以由多个消息组成。流读取可能拆开长度字段或正文，程序应循环读取所需字节数，不能假定一次 recv 就返回整个回答。传输可靠与应用消息边界明确，是两项不同责任。

快速验证

将脚本保存为 check-dns-tcp.py，准备 Docker 后执行 python3 check-dns-tcp.py。固定 BIND 9.18.49 环境在隔离容器中提供包含四条记录的 TXT 集合。第一次查询明确关闭 EDNS，以观察传统五百一十二字节 UDP 限制。之后程序使用真实 TCP 连接，并建立一个有意只提供 UDP 的中继端点；不修改现有防火墙或公共解析器：

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
import dns.flags,socket,struct,threading
texts=[f'{i}-'+('x'*200) for i in range(4)]
records='small 30 IN A 127.0.0.2\n'+'\n'.join('large 30 IN TXT "'+s+'"' for s in texts)
def exact(stream,size):
 data=b''
 while len(data)<size:
 part=stream.recv(size-len(data));assert part,'unexpected TCP EOF';data+=part
 return data
def description(response):return {'wire_bytes':len(response.to_wire()),'TC':bool(response.flags&dns.flags.TC),'answer_records':sum(len(rr) for rr in response.answer)}
with lab(records) as (_,update,cache,queries):
 q=dns.message.make_query('large.lab.test.','TXT',use_edns=False)
 udp=dns.query.udp(q,'127.0.0.1',port=1053,timeout=2)
 assert udp.flags&dns.flags.TC and len(udp.to_wire())<=512
 tcp=dns.query.tcp(q,'127.0.0.1',port=1053,timeout=2)
 assert not tcp.flags&dns.flags.TC and set(values(tcp,'TXT'))=={'"'+s+'"' for s in texts}
 assert len(tcp.to_wire())>512
 with socket.create_connection(('127.0.0.1',1053),timeout=2) as stream:
 lengths=[]
 for name,kind in [('large.lab.test.','TXT'),('small.lab.test.','A')]:
 request=dns.message.make_query(name,kind);wire=request.to_wire();stream.sendall(struct.pack('!H',len(wire))+wire)
 size=struct.unpack('!H',exact(stream,2))[0];reply=dns.message.from_wire(exact(stream,size));assert reply.id==request.id and reply.rcode()==0
 assert values(reply,kind);lengths.append(size)
 with socket.socket() as reservation,socket.socket(socket.AF_INET,socket.SOCK_DGRAM) as relay:
 reservation.bind(('127.0.0.1',0));port=reservation.getsockname()[1];relay.bind(('127.0.0.1',port));relay.settimeout(3)
 errors=[]
 def one_datagram():
 try:
 data,peer=relay.recvfrom(4096);answer=dns.query.udp(dns.message.from_wire(data),'127.0.0.1',port=1053,timeout=2);relay.sendto(answer.to_wire(),peer)
 except Exception as error:errors.append(type(error).__name__)
 thread=threading.Thread(target=one_datagram);thread.start()
 limited=dns.query.udp(q,'127.0.0.1',port=port,timeout=2);assert limited.flags&dns.flags.TC
 thread.join(timeout=4);assert not thread.is_alive() and not errors
 try:dns.query.tcp(q,'127.0.0.1',port=port,timeout=1);raise AssertionError('UDP-only endpoint unexpectedly accepted TCP')
 except OSError as error:failure=type(error).__name__
 print(json.dumps({'UDP':description(udp),'TCP':description(tcp),'two_messages_one_connection_lengths':lengths,
 'UDP_only_path':{'TC_received':True,'TCP_error':failure}},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)

历史 UDP 结果重新序列化后为四百六十二字节，设置 TC，只带回四条 TXT 中的两条。TCP 响应八百九十二字节，TC 清除，并包含全部四个预期值。脚本比较完整记录内容。wire_bytes 使用 len(response.to_wire())，测量重新序列化的 DNS 消息长度，而非抓包长度；后续复用流的长度则直接读取 TCP 消息长度字段。这一结果还直接表明：截断响应可能保留部分有用数据，但调用方不能把部分集合当成权威完整结果使用。

接着程序只打开一个 TCP 连接，先查询较大的 TXT，再查询一个小 A 回答。每次都读取两字节长度和对应正文，记录中的消息长度分别为八百九十二与四十八，并检查响应标识。两次交换使用同一条流，证明每个查询不必重新握手。长度字段不计入所描述的 DNS 消息正文大小，也不会因为 TCP 分段方式改变而失去作用。

另一个端点只转发一次 UDP 问题到真实权威，并返回截断回答。在相同端点编号上，保留一个已绑定但未监听的 TCP 套接字，使那里确实没有 TCP 服务。UDP 查询带 TC 成功返回，TCP 尝试则得到 ConnectionRefusedError。这个对照复现了传输方式不匹配，不依赖无关公网服务是否偶然失败，也不需要改变共享网络策略。

分开诊断截断与连接失败

检查响应标志、存在时的 EDNS 宣告容量、TCP 建连结果及最终 DNS 内容。先收到 TC 再连接被拒绝，与 UDP 完全无响应或权威返回 NXDOMAIN，原因不同。中继有意只支持一次交换，是受控失败实验，不是可部署的通用 DNS 代理。读者应提取它展示的传输边界，而不是把实验代码的范围误认为生产服务的完整能力。

让客户端、解析器、服务器监听及中间访问规则共同允许所需 TCP 路径，并根据负载选择连接截止时间和资源限制。复用可以减少重复建立连接的工作，但空闲连接、连接上限和服务器行为仍然重要。不能把一次新连接多出的握手，转换成每一次 TCP 查询都必须支付的固定延迟。实际成本应结合复用策略和真实请求序列测量。

EDNS 能允许更大的 UDP 回答，在不少场景中避免截断，却不会消除 TCP 需求。更大数据报可能先遭遇路径 MTU 或分片问题，客户端甚至收不到有效 TC 提示。应同时验证配置的 UDP 大小和完整 TCP 交换，不要把特别大的宣告容量当成第二条传输路径已经可用。协议宣告与沿途能否交付数据，是两个检查维度。

最后，TCP 提供可靠字节流，不直接提供 DNS 保密性或记录数据认证。普通 TCP DNS 仍是明文，加密 DNS 传输与 DNSSEC 分别处理另外的安全属性。本实验的证据限定在截断处理、完整记录恢复、流消息边界、连接复用，以及只有 UDP 时的具体失败。描述结果时保留这些边界，才能避免把一种传输方式的成功扩大成全部 DNS 能力已验证。

来源

dnspython Message API，to_wire 序列化 DNS 消息；未改动示例测量该方法返回的字节，已核验 2026-10-18。
RFC 7766 DNS over TCP，TCP 支持、连接复用与 DNS 传输要求，已核验 2026-09-12。
RFC 1035 domain names，TC、传统 UDP 大小与两字节 TCP 长度前缀，已核验 2026-09-12。
RFC 5936 AXFR，跨多个 DNS 消息的区域传送，已核验 2026-09-12。

双栈地址排序与最终成功的连接选择是不同步骤

Wed, 04 Nov 2026 00:00:00 +0000

发现 A 与 AAAA 记录，只提供可能的目的地，本身不会选出成功连接。地址排序、源地址选择、路由以及应用连接算法都会参与结果。RFC 6724 描述默认源地址和目的地址选择规则，应用仍可作自己的选择。如果程序只请求 IPv4，那么在任何双栈连接策略开始工作前，它就已经缩小了候选范围。解释行为时，应先确认实际调用方请求了什么。

坏掉的样子

地址偏好不是应用健康探测。某个 IPv6 目的地可能符合本地策略和路由条件，远端服务却已经停止，或者更后面的网络跳点会丢包，因此优先候选仍可能失败。如果假定操作系统已经测试了返回列表中每个端点，就会忽略连接截止时间和尝试其他地址的必要性。查询成功只能证明获得候选信息，不能代替服务通信结果。

RFC 6724 的规则是按顺序比较条件，并不是对网络成本或速度打一个总分。相关属性包括可用性、作用域、策略标签、优先顺序和匹配前缀，但它们不测量应用响应时间。目的地址选择还应与路由表最长前缀匹配区分：后者决定已选目的地的数据包如何发送。混用这两个阶段，会把主机偏好错误解释成已经知道整条路径延迟最低。

Happy Eyeballs 属于另一层，通过协调地址发现和错开连接尝试，减少某个地址族出问题时的等待。按顺序逐个尝试地址的客户端，并不自动实现该算法。立即拒绝连接与静默丢弃连接尝试，可能造成非常不同的等待时间，即使最后都能通过 IPv4 成功。不能只看最终用了另一个地址族，就把过程统称为相同的快速竞速机制。

首个候选只代表偏好，不能证明服务健康。图示 IPv6 优先顺序仅属于原文的本地进程。网络示例执行仍受阻，本草稿未重跑。

快速验证

将脚本保存为 check-address-selection.py，准备 Docker 后执行 python3 check-address-selection.py。固定环境使用 glibc 2.36、Python 3.11，以及提供 DNS 的 BIND 9.18.49 和 dnsmasq 2.90。两个真实 HTTP 监听分别使用 IPv4 与 IPv6 回环，端口相同。实验没有公网路径，因此观察到的排序明确属于这个本地环境，不作为所有客户端的默认承诺：

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

@contextmanager
def named_process(root,config):
 root.mkdir(exist_ok=True);conf=root/'named.conf';log=root/'named.log';conf.write_text(config)
 run('named-checkconf',str(conf))
 with log.open('w') as output:
 process=subprocess.Popen(['named','-g','-c',str(conf),'-n','1','-U','1'],stdout=output,stderr=subprocess.STDOUT)
 try:
 def ready():
 assert process.poll() is None,log.read_text()
 return re.search(r'\brunning\s*$',log.read_text(),re.M) is not None
 wait(ready);yield process,log
 finally:stop(process)
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
import socket,threading
class Handler(BaseHTTPRequestHandler):
 def log_message(self,*args):pass
 def do_GET(self):
 body=self.server.server_address[0].encode();self.send_response(200);self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
class V6Server(ThreadingHTTPServer):address_family=socket.AF_INET6
with lab('dual 30 IN A 127.0.0.1\ndual 30 IN AAAA ::1') as (_,update,cache,queries):
 cache(port=53)
 Path('/etc/resolv.conf').write_text('nameserver 127.0.0.1\noptions timeout:1 attempts:1\n')
 nss=Path('/etc/nsswitch.conf');nss.write_text(re.sub(r'^hosts:.*$','hosts: dns',nss.read_text(),flags=re.M))
 servers=[];threads=[]
 try:
 for server_class,address in [(ThreadingHTTPServer,'127.0.0.1'),(V6Server,'::1')]:
 server=server_class((address,0 if not servers else servers[0].server_port),Handler)
 thread=threading.Thread(target=server.serve_forever,daemon=True);thread.start();servers.append(server);threads.append(thread)
 port=servers[0].server_port;v6=servers[1]
 def candidates(family=socket.AF_UNSPEC):return socket.getaddrinfo('dual.lab.test',port,family,socket.SOCK_STREAM)
 addresses=candidates();assert {r[0] for r in addresses}=={socket.AF_INET,socket.AF_INET6}
 assert addresses[0][0]==socket.AF_INET6
 assert {r[0] for r in candidates(socket.AF_INET)}=={socket.AF_INET}
 assert {r[0] for r in candidates(socket.AF_INET6)}=={socket.AF_INET6}
 def request():
 with socket.create_connection(('dual.lab.test',port),timeout=1) as stream:
 chosen={'family':stream.family.name,'peer':stream.getpeername()[0],'source':stream.getsockname()[0]}
 stream.sendall(b'GET / HTTP/1.0\r\nHost: dual.lab.test\r\n\r\n');data=b''
 while True:
 part=stream.recv(4096)
 if not part:break
 data+=part
 assert b' 200 ' in data.split(b'\r\n',1)[0] and data.endswith(chosen['peer'].encode());return chosen
 first=request();assert first['family']=='AF_INET6'
 v6.shutdown();v6.server_close();assert values(query('dual.lab.test.','AAAA'),'AAAA')==['::1']
 with socket.socket(socket.AF_INET6) as forced:
 forced.settimeout(1)
 try:forced.connect(('::1',port));raise AssertionError('closed IPv6 listener accepted a connection')
 except OSError as error:failure=type(error).__name__
 assert candidates()[0][0]==socket.AF_INET6
 second=request();assert second['family']=='AF_INET'
 print(json.dumps({'candidate_order':[{'family':socket.AddressFamily(r[0]).name,'address':r[4][0]} for r in addresses],
 'both_listeners_healthy':first,'forced_IPv6_after_stop':failure,'sequential_client_after_IPv6_stop':second,
 'AAAA_still_published':True},sort_keys=True))
 finally:
 for server in servers:server.shutdown();server.server_close()
 for thread in threads:thread.join(timeout=2)
"""
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)

对 dual.lab.test 使用 AF_UNSPEC 调用 getaddrinfo，同时得到 ::1 和 127.0.0.1，实测 IPv6 在前。分别限定 AF_INET 或 AF_INET6 后，只返回相应地址族。这些调用确定当前进程的真实候选列表，而不是假定两次独立 A 与 AAAA 查询的输出天然组成统一顺序。地址族参数本身，就是连接选择之前的重要输入条件。

两个监听都健康时，Python 的 socket.create_connection 连接到 ::1。程序记录选中对端和本地源地址，再发送真实 HTTP 请求，检查监听回显的身份。这样将候选偏好与成功连接关联，同时保留源地址、目的地址和应用响应三个不同观察。不能只根据 DNS 首项，就宣称已经证明流量实际通过了那个地址族。

随后停止并关闭 IPv6 监听。DNS 仍发布 ::1，getaddrinfo 也仍把 IPv6 放在第一项；强制 IPv6 连接得到 ConnectionRefusedError。正常 Python 连接助手却能通过 127.0.0.1 成功，收到 IPv4 监听响应。按序尝试可以到达后面的可用候选，并不要求 DNS 排序随服务故障改变。真正完成选择的是客户端的连接处理过程。

本地路径上的拒绝立即发生。实验没有制造黑洞，没有测量互联网回退延迟，也没有执行完整 Happy Eyeballs 实现。它证明的是：服务可用性变化时，本地地址偏好可以不变，连接算法必须把候选列表转化成最终成功或失败。对于静默丢包、多个候选和不同截止时间，仍需依据实际客户端另外测量，不能外推这里的等待表现。

修改全局策略前先检查真实调用方

确认应用给 getaddrinfo 的地址族和标志、运行时是否缓存结果，以及它如何尝试候选项。有些应用采用不同解析库，或自己实现连接竞速。命令行工具重现查询，只有在相关选择与失败进程一致时才具有直接可比性。尤其不能用一个主动竞速的浏览器成功，覆盖另一个按序等待的后台客户端所遇到的延迟问题。

把选中的源地址、目的地址、连接时间和错误一起观察。DNS 成功后连接被拒绝，与沿路超时的调查方向不同。按实际服务身份和协议验证每个公开地址族。IPv4 端点健康，不证明 IPv6 端点具有相同路由、访问规则、证书或应用配置。监控只检查其中一条路径时，很容易遗漏另一类用户正在遭遇的问题。

部署确实需要策略变化时，应有意识地实施，并验证真实调用方效果。RFC 6724 允许管理策略，但全局改变偏好不能代替修复已经发布却损坏的服务。同样，删除 AAAA 只改变未来发现，缓存记录和已有连接仍可能继续存在。端点调整应一起规划这些寿命，而不是把改一个优先级或删一条记录当作立即切断所有旧流量。

将排序视为当前主机和进程的证据，不是全部客户端的保证。完整诊断应说明候选集合、本地选择策略、实际连接尝试以及最终成功对端。分开这些阶段，才能解释双栈行为，而不虚构“第一项必然健康”或“每个客户端都会竞速两个地址族”的承诺。实际实现与观察到的请求路径，应共同决定对外描述的连接行为。

来源

RFC 6724 default address selection，源地址与目的地址选择规则以及策略覆盖，已核验 2026-09-12。
RFC 8305 Happy Eyeballs version 2，跨地址族错开启动连接尝试，已核验 2026-09-12。
Python 3.11 socket documentation，getaddrinfo 地址族与 create_connection 尝试行为，已核验 2026-09-12。

EDNS 宣告 UDP 容量，不保证沿途网络交付

Wed, 28 Oct 2026 00:00:00 +0000

EDNS 通过 OPT 伪记录扩展 DNS，其中一项作用是让请求发送方宣告自己准备接收的 UDP 载荷大小，从而允许回答超过传统五百一十二字节 DNS 限制。这是 DNS 交换中的容量宣告，不是网络路径 MTU 发现协议，也不承诺所有中间设备都会交付相同大小的数据报。理解这一区别，才能准确解释大回答为何仍可能失败。

图中数值来自文章明确的回环配置与记录的 DNS 消息长度，不是统一默认值或路径 MTU 测量。OPT 宣告容量，客户端仍须理解 TC 并保留 TCP 访问。

坏掉的样子

客户端宣告四千零九十六字节，不会强迫服务器发送同样大小的响应。服务器可以实施更小的发送上限；需要的回答放不下时，可以返回 TC，客户端仍需可工作的 TCP 路径。增加客户端数字，不能修复服务器有意采用较小预算的策略。应查看两端实际配置与返回内容，而不是把请求里出现的大数值当成双方已承诺一定使用的大小。

反过来，即使回答没有超过宣告容量，也可能在途中丢失。分片、隧道、包过滤和本地网络约束，与 DNS 参与者宣告的能力是不同因素。客户端若根本没有收到响应，也就可能看不到 TC 提示。载荷配置需要按互通性验证，不能当作越大越好的统一性能参数。一次超时无法仅凭宣告值就归因于某一台服务器或某个固定网络环节。

EDNS 还承载不能当作普通缓存记录解释的信息。OPT 是描述本次交换的伪记录，其字段编码载荷容量、版本、扩展响应码和标志；外形对应 TTL 的字段，并不是普通记录寿命。DNSSEC OK 标志 DO 用于请求相关 DNSSEC 数据，却不证明任何一方完成了验证。诊断工具若丢弃这些元信息，可能把不同故障简化成相同空回答。

快速验证

将脚本保存为 check-edns.py，准备 Docker 后执行 python3 check-edns.py。固定 BIND 9.18.49 权威运行在隔离回环网络，明确把 edns-udp-size 和 max-udp-size 都设为一千二百三十二。区域中分别准备四条和八条 TXT 的记录集，以便独立观察容量与截断。实验不依赖公网默认值，也不修改现有解析器的载荷策略：

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
import dns.flags
records='\n'.join(f'{name} 30 IN TXT "{i}-'+('x'*200)+'"' for name,count in [('medium',4),('large',8)] for i in range(count))
def ask(name,payload=None,version=0,flags=0):
 q=dns.message.make_query(name+'.lab.test.','TXT',use_edns=False)
 if payload is not None:q.use_edns(edns=version,ednsflags=flags,payload=payload)
 return dns.query.udp(q,'127.0.0.1',port=1053,timeout=2)
def description(response):return {'wire_bytes':len(response.to_wire()),'TC':bool(response.flags&dns.flags.TC),
 'rcode':dns.rcode.to_text(response.rcode()),'EDNS_version':response.edns,'advertised_payload':response.payload,
 'DO':bool(response.ednsflags&dns.flags.DO),'AD':bool(response.flags&dns.flags.AD),'answer_records':sum(len(rr) for rr in response.answer)}
with lab(records,extra='edns-udp-size 1232; max-udp-size 1232;') as (_,update,cache,queries):
 classic=ask('medium');extended=ask('medium',1232);capped=ask('large',4096);do=ask('medium',1232,flags=dns.flags.DO);version=ask('medium',1232,version=1)
 assert classic.flags&dns.flags.TC and len(classic.to_wire())<=512 and classic.edns==-1
 assert not extended.flags&dns.flags.TC and 512<len(extended.to_wire())<=1232 and len(values(extended,'TXT'))==4
 assert extended.edns==0 and extended.opt is not None
 assert capped.flags&dns.flags.TC and len(capped.to_wire())<=1232
 assert do.ednsflags&dns.flags.DO and not do.flags&dns.flags.AD
 assert not any(rr.rdtype==dns.rdatatype.RRSIG for rr in do.answer)
 assert version.rcode()==dns.rcode.BADVERS and version.edns==0
 full=dns.query.tcp(dns.message.make_query('large.lab.test.','TXT'),'127.0.0.1',port=1053,timeout=2)
 assert len(values(full,'TXT'))==8 and len(full.to_wire())>1232
 print(json.dumps({'without_EDNS':description(classic),'EDNS_1232':description(extended),'client_4096_server_1232':description(capped),
 'DO_on_unsigned_zone':description(do),'unsupported_version':description(version),'TCP_full':description(full)},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)

不使用 EDNS 时，中等集合查询得到四百六十三字节的截断回答，只包含两条 TXT；宣告一千二百三十二字节后，四条完整记录以九百零四字节返回，TC 清除。脚本检查记录数量、重新序列化的消息长度和 EDNS 存在；wire_bytes 使用 len(response.to_wire())，并非收到的数据报或 IP 包的抓包长度，重新序列化不保证与原始字节完全相同。这些检查证明这个具体回答跨过传统限制，同时仍在所选 UDP 预算内。它不是只看查询成功，就假定完整集合已经到达。

对于更大集合，客户端宣告四千零九十六，但服务器仍限制在一千二百三十二。实测响应只有四十三字节，设置 TC，没有回答记录；随后 TCP 查询取得全部八条，共一千七百五十二字节。截断回答不一定填满允许的缓冲区，记录分组和响应构造可能产生很短的“还需要完整交换”信号。因此响应短也不能直接等同于完整数据很少。

程序还对这个未签名区域发出带 DO 的查询。回答保留 DO，却没有 RRSIG，也没有表示认证数据的 AD 标志。这符合预期：请求 DNSSEC 数据不会凭空产生签名或信任链。实验分别记录各标志，不把出现 DO 的交换称为验证成功。需要判断认证状态时，应检查实际验证路径，而不是只找到了某个听起来与安全有关的位。

最后，查询宣告 EDNS 版本一，服务器返回 BADVERS，并指示支持版本零。库从完整消息中解码扩展响应码。这个失败对照将不支持的扩展版本，与名称不存在或普通成功空回答区分开，也说明解释扩展相关错误时应保留 OPT。仅查看基础响应头的一部分，可能无法还原服务器真正表达的错误种类。

测量实际交换，不假定统一默认值

记录客户端真实宣告、服务器配置、响应大小、标志和传输方式。不同软件版本和运维策略可能采用不同载荷值，一千二百三十二或四千零九十六都不是标准保证的统一默认。本例的较小值是明确实验配置。回环结果没有测量分片、远端路径 MTU 或公共解析性能，不能把局部可交付性直接外推到所有客户端网络。

诊断大回答失败时，通过同一预期端点比较小查询、较大 EDNS 查询和完整 TCP 查询。区分错误类别：TC 表示还需取得完整数据，BADVERS 表示扩展版本不一致，超时则不能直接指出哪一环丢包。保留足够响应信息，避免把这些不同故障压成“DNS 挂了”。只有分类准确，下一步检查的配置和网络路径才有明确对象。

使用部署实现支持的大小与重试策略，再从重要客户端网络验证。即使大多数观察到的回答都能放入 UDP，也应保留 TCP 访问。EDNS 改善扩展能力，并可能减少部分截断重试，但完整交付仍依赖传输行为、服务器限制和客户端对实际回答的处理。选择值之后，应通过真实结果确认效果，而不是只以配置项存在作为完成依据。

来源

dnspython Message API，to_wire 序列化 DNS 消息；未改动示例测量该方法返回的字节，已核验 2026-10-18。
RFC 6891 extension mechanisms for DNS，OPT、载荷容量宣告、扩展错误与 EDNS 版本处理，已核验 2026-09-12。
RFC 7766 DNS over TCP，TCP 仍然是必需的 DNS 传输方式，已核验 2026-09-12。
BIND 9.18.49 reference，edns-udp-size 与 max-udp-size 配置，已核验 2026-09-12。

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

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

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

先分类回答，再解释缓存。来源中的 SOA TTL/MINIMUM 组合 8/4 和 2/9 分别产生四秒和两秒寿命。负向条目可能在权威发布后继续存在。SERVFAIL、超时与验证失败使用另一类失败缓存规则。历史解析器示例未重跑。

坏掉的样子

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

仅凭回答区为空，不能完整分类 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。

DNSSEC 验证签名数据链，不只检查签名是否存在

Wed, 21 Oct 2026 00:00:00 +0000

DNSSEC 为 DNS 数据增加来源认证和完整性检查。RRSIG 对记录集签名，DNSKEY 发布验证密钥，父区 DS 则通过摘要标识一个子区 DNSKEY。父区签名的是自己的 DS 记录集，不是简单直接签署子区公钥。验证从配置的信任锚出发，沿这些关系抵达所请求数据。理解链中每类记录的责任，才能准确定位发布与验证之间的差异。

摘要边标识子区密钥；签名边验证记录集。来源使用本地 lab.test 锚，不测试公共根或注册商路径。经认证的无 DS 委派属于不安全状态，与损坏的安全链不同。制图未执行 DNSSEC 实验，也未创建密钥。

坏掉的样子

如果委派没有建立预期信任路径，仅发布签名并不足够。缺失 DS 可能让子区处于不安全状态，错误 DS 则可能让原本应安全的子区验证失败；这是不同状态。已经安全证明不存在 DS，并不要求把每个未签名或独立签名的子区回答都当成无效数据拒绝。不能把“没有形成认证链”和“已有安全链却证明失败”混成一种结果。

签名具有独立于普通缓存 TTL 的生效与到期时间。签名过期后，权威区域可能继续回答记录，验证器却会拒绝。错误时钟、不完整密钥轮换和父区旧 DS，都可能中断一个普通查询看似仍正常的区域。只监控 DNSKEY 或 RRSIG 是否存在，会漏掉真正验证边界；应关注当前数据能否在有效时间和正确委派下被实际验证接受。

AD 标志也需要通过受信任解析路径解读。任意未受保护响应里出现该位，不会使回答自动可信，攻击者可以修改没有认证保护的消息。同样，使用 DO 请求 DNSSEC 记录，并不等于执行验证。应先确认哪个组件验证，以及应用如何信任它的回答，再把显示的标志作为证据。不能只凭工具输出里出现两个字母，就扩大为端到端安全保证。

快速验证

将脚本保存为 check-dnssec.py，准备 Docker 后执行 python3 check-dnssec.py。固定 BIND 9.18.49 环境创建一次性密钥和离线签名父子区域。独立验证解析器信任本地 lab.test 锚，只把这个测试命名空间转发给临时权威。私钥留在容器内部，不更改宿主信任配置和系统时间；不同案例使用独立进程，避免此前缓存影响结果：

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

@contextmanager
def named_process(root,config):
 root.mkdir(exist_ok=True);conf=root/'named.conf';log=root/'named.log';conf.write_text(config)
 run('named-checkconf',str(conf))
 with log.open('w') as output:
 process=subprocess.Popen(['named','-g','-c',str(conf),'-n','1','-U','1'],stdout=output,stderr=subprocess.STDOUT)
 try:
 def ready():
 assert process.poll() is None,log.read_text()
 return re.search(r'\brunning\s*$',log.read_text(),re.M) is not None
 wait(ready);yield process,log
 finally:stop(process)
from datetime import datetime,timedelta,timezone
import dns.flags,dns.rdataset,dns.zone
with TemporaryDirectory(prefix='xbcatm-dnssec-') as directory:
 root=Path(directory);keys=root/'keys';keys.mkdir()
 parent='lab.test.';child='secure.lab.test.';key_names={}
 for name in (parent,child):
 for role in ('KSK','ZSK'):
 args=['dnssec-keygen','-q','-a','ECDSAP256SHA256','-n','ZONE','-K',str(keys)]
 if role=='KSK':args+=['-f','KSK']
 key_names[name,role]=run(*args,name).stdout.strip()
 def base(name):return f'$ORIGIN {name}\n$TTL 60\n@ IN SOA ns.{name} hostmaster.{name} (1 60 60 3600 60)\n@ IN NS ns.{name}\nns IN A 127.0.0.1\n'
 child_zone=root/'child.zone';child_zone.write_text(base(child)+'www IN A 127.0.0.2\n')
 ds=run('dnssec-dsfromkey','-2',str(keys/(key_names[child,'KSK']+'.key'))).stdout.strip()
 parent_body=base(parent)+'secure IN NS ns.secure.lab.test.\nns.secure IN A 127.0.0.1\n'
 def sign(name,body,label,extra=()):
 plain=root/(label+'.zone');signed=root/(label+'.signed');plain.write_text(body)
 result=subprocess.run(['dnssec-signzone','-S','-K',str(keys),'-n','1','-o',name,'-f',str(signed),*extra,str(plain)],
 cwd=root,text=True,capture_output=True,timeout=15)
 assert result.returncode==0,result.stdout+result.stderr
 return signed
 signed_child=sign(child,child_zone.read_text(),'child-good')
 signed_parent=sign(parent,parent_body+ds+'\n','parent-good')
 parsed=dns.zone.from_file(str(signed_parent),origin=parent);anchor=next(key for key in parsed.get_rdataset('@','DNSKEY') if key.flags==257)
 anchor_parts=anchor.to_text().split();anchor_config=' '.join(anchor_parts[:3])+' '+json.dumps(''.join(anchor_parts[3:]))
 tampered=root/'child-tampered.signed';zone=dns.zone.from_file(str(signed_child),origin=child)
 zone.replace_rdataset('www',dns.rdataset.from_text('IN','A',60,'127.0.0.3'));zone.to_file(str(tampered))
 start=(datetime.now(timezone.utc)-timedelta(days=2)).strftime('%Y%m%d%H%M%S');end=(datetime.now(timezone.utc)-timedelta(days=1)).strftime('%Y%m%d%H%M%S')
 expired=sign(child,child_zone.read_text(),'child-expired',extra=('-s',start,'-e',end,'-P'))
 pieces=ds.split();pieces[-1]='0'*len(pieces[-1]);wrong_parent=sign(parent,parent_body+' '.join(pieces)+'\n','parent-wrong-ds')
 insecure_parent=sign(parent,parent_body,'parent-no-ds')
 outcomes={}
 for label,parent_file,child_file in [('secure',signed_parent,signed_child),('tampered',signed_parent,tampered),
 ('expired',signed_parent,expired),('wrong_DS',wrong_parent,signed_child),('unsigned_delegation',insecure_parent,signed_child)]:
 auth=root/(label+'-authority');resolver=root/(label+'-resolver');auth.mkdir();resolver.mkdir()
 def options(path,port,validation,recursion):return f'''options {{ directory "{path}"; listen-on port {port} {{127.0.0.1;}};
listen-on-v6 {{none;}}; recursion {recursion}; dnssec-validation {validation}; notify no; max-cache-size 8m;
pid-file "{path}/named.pid"; lock-file "{path}/named.lock"; session-keyfile none; }}; controls {{}};'''
 authority_config=options(auth,1053,'no','no')+f'''zone "{parent}" {{type primary; file "{parent_file}";}};
zone "{child}" {{type primary; file "{child_file}";}};'''
 resolver_config=options(resolver,1054,'yes','yes')+f'''trust-anchors {{ "{parent}" static-key {anchor_config}; }};
zone "{parent}" {{type forward; forward only; forwarders {{127.0.0.1 port 1053;}};}};'''
 with named_process(auth,authority_config),named_process(resolver,resolver_config):
 q=dns.message.make_query('www.'+child,'A',want_dnssec=True)
 direct=dns.query.udp(q,'127.0.0.1',port=1053,timeout=2)
 assert any(rr.rdtype==dns.rdatatype.RRSIG for rr in direct.answer) and not direct.flags&dns.flags.AD
 checked=dns.query.udp(q,'127.0.0.1',port=1054,timeout=8)
 outcomes[label]={'authority_A':values(direct),'authority_has_RRSIG':True,'resolver_rcode':dns.rcode.to_text(checked.rcode()),
 'resolver_AD':bool(checked.flags&dns.flags.AD),'resolver_A':values(checked)}
 if label=='secure':assert checked.rcode()==0 and checked.flags&dns.flags.AD and values(checked)==['127.0.0.2']
 elif label=='unsigned_delegation':assert checked.rcode()==0 and not checked.flags&dns.flags.AD and values(checked)==['127.0.0.2']
 else:assert checked.rcode()==dns.rcode.SERVFAIL and not values(checked)
 print(json.dumps({'trust_anchor':parent,'cases':outcomes,'system_clock_changed':False},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)

有效案例中，父区签名 DS 匹配子区密钥，www.secure.lab.test 的 A 地址 127.0.0.2 具有有效签名。直接权威回答携带 RRSIG，但不标记 AD；独立解析器返回 NOERROR、预期地址和 AD。这证明提供签名数据与沿配置父子信任链验证数据不同，不能用权威服务器能列出签名，就代替客户端实际使用的验证路径。

篡改案例把子区 A 数据改成 127.0.0.3，却保留此前签名。直接权威查询仍返回新地址并带有 RRSIG，验证解析器则返回 SERVFAIL，没有地址。这个对照验证了具体数据修改被拒绝，而不是看到一条外形像签名的资源记录，就宣称正文内容没有被改变。签名必须与实际记录集以及可信密钥关系匹配，存在本身没有这样的保证。

另一个案例有意使用过去的有效时间签署子区。签名工具为生成过期实验输入跳过自己的签后检查，解析器验证始终保持启用。第三个案例正确签署父区，却公布错误子区 DS 摘要。两者都在解析器处产生 SERVFAIL，尽管权威仍返回原地址与 RRSIG。过期案例没有通过修改系统时间制造，因此不会影响宿主或其他实验的时钟状态。

最后，签名父区不再发布子区 DS。子区仍提供签名数据，但解析器返回地址而没有 AD。这个经认证的不安全委派，在本例策略下被接受，与篡改、过期和错误 DS 导致的无效安全链不同。每个场景都启动全新权威与验证器，使旧缓存不会掩盖变化；因此比较的是当前链条，而不是某个先前成功结果仍被复用。

让签名、委派和验证都可观察

本例使用本地锚，不测试公共根或注册商更新。生产解析器可以使用公共根锚，也可能具有其他明确配置的信任锚。关键是从验证器已经信任的锚出发形成有效路径，不是所有部署都必须依赖唯一硬编码根密钥。审阅配置时，应明确锚的范围与维护方式，避免把实验的本地信任关系误认为已经覆盖整个互联网命名空间。

签名可以离线完成，也可以通过托管权威流程维护，并不要求回答每个请求的服务器都现场重新签名。应验证发布的 DNSKEY 与 DS 关系、签名时间窗口，以及实际客户端解析器的结果。受控测试中还应包含预期验证失败：一个接受所有回答的解析器也可能看起来很健康，却没有提供验证能力。负向案例能帮助区分可用性与认证属性。

按照实现支持的流程及相关缓存寿命安排密钥轮换与父区协调。不要在链条损坏时悄悄关闭验证，再报告区域已经修复；恢复普通回答与恢复认证数据不同。对照直接权威内容和验证结果，定位发布、委派、签名时间或验证器信任配置中的故障。修复后应重新取得认证成功证据，而不只确认命令又能返回一个地址。

DNSSEC 不加密问题，不向解析器隐藏名称，也不证明认证地址上的应用一定安全。加密 DNS 传输与应用认证处理其他边界。本实验的承诺应保持精确：验证签名 DNS 数据，拒绝几种明确损坏的安全链，并展示没有认证委派时，即使签名存在也可能仍未获得验证。把这些结果区分清楚，才能让读者理解真正建立了什么信任。

来源

RFC 4033 DNS security introduction，DNSSEC 属性与安全、不安全、无效数据分类，已核验 2026-09-12。
RFC 4034 DNSSEC resource records，DNSKEY、RRSIG 与 DS 的关系，已核验 2026-09-12。
RFC 4035 DNSSEC protocol modifications，验证、认证委派与解析器行为，已核验 2026-09-12。
BIND 9.18.49 tools，离线密钥生成、区域签名与 DS 生成，已核验 2026-09-12。

解析顺序取决于应用及其名称服务路径

Sun, 02 Aug 2026 00:00:00 +0000

主机名查询首先由具体程序发起。在 Linux 上，使用 glibc 名称服务接口的应用，可以依照 /etc/nsswitch.conf 中 hosts 项列出的服务查询；使用自有 DNS 客户端的程序则可能走另一条路径。并不存在所有应用都遵守的“先缓存、再 hosts、最后互联网”固定顺序。定位问题的起点是实际调用方，而不是凭操作系统名称假定完整流程。

同名可以经本地文件与直接 DNS 得到不同结果。修改上游记录前，先检查 NSS 动作、调用标志和实际进程环境。此图整理文章中的机制，未重跑实验。

坏掉的样子

当 files 位于 dns 前面时，hosts 文件条目可以覆盖正确的 DNS 回答。修改权威区域不会删除这个本地覆盖。直接 DNS 查询可能已经看到新地址，应用却仍使用本地文件中的旧值；这两项观察可以同时正确，因为它们实际回答的是不同来源的查询。仅凭 dig 正常就认定应用一定使用同一个地址，会漏掉最直接的配置原因。

NSS 的结果动作与服务顺序同样重要。在 files 后写 [NOTFOUND=return]，表示文件服务没有找到条目时就停止。即使 DNS 中存在有效记录，也不会继续询问。把这类失败归咎于上游不可用，可能让人反复修改区域或者重启解析服务，却始终没有修正真正阻断查询的策略。应完整读取方括号规则，不能只摘出 files 和 dns 两个单词。

地址族筛选还会制造另一种差异。使用 AI_ADDRCONFIG 时，glibc 根据本地已配置的非回环地址决定返回哪些地址族；只有回环接口的容器因此可能不同于普通主机。两个工具即便都调用 libc，也未必请求相同地址族或标志。空结果不能立即解释为域名不存在，尤其在隔离实验、极简容器和刚启动的网络环境中，应先核对调用参数。

快速验证

将脚本保存为 check-resolution.py，准备 Docker 后执行 python3 check-resolution.py。脚本构建固定的 Debian 环境，使用 BIND 9.18.49、dnsmasq 2.90 和 glibc 2.36。可丢弃容器只有回环网络；hosts、NSS 与解析器配置修改全部发生在容器内部，不把宿主文件作为实验可写状态。每次创建独立实例，并在结束后清理自己的容器和镜像标签：

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('choice 30 IN A 127.0.0.2\ndns-only 30 IN A 127.0.0.3') as (_,update,cache,queries):
 cache(port=53)
 hosts=Path('/etc/hosts');hosts.write_text(hosts.read_text()+'\n127.0.0.9 choice.lab.test\n')
 Path('/etc/resolv.conf').write_text('nameserver 127.0.0.1\noptions timeout:1 attempts:1\n')
 nss=Path('/etc/nsswitch.conf');original=nss.read_text()
 def order(value):nss.write_text(re.sub(r'^hosts:.*$', 'hosts: '+value,original,flags=re.M))
 def application(name):
 result=run('/usr/bin/python3','-c',
 'import json,socket,sys;print(json.dumps(sorted({v[4][0] for v in socket.getaddrinfo(sys.argv[1],80,socket.AF_INET,socket.SOCK_STREAM)})))',name,check=False)
 return result.returncode,json.loads(result.stdout) if result.returncode==0 else None
 results={};order('files dns')
 assert application('choice.lab.test')==(0,['127.0.0.9'])
 filtered=run('getent','ahostsv4','choice.lab.test',check=False)
 assert filtered.returncode!=0
 libc=run('getent','-A','ahostsv4','choice.lab.test').stdout
 assert {line.split()[0] for line in libc.splitlines()}=={'127.0.0.9'}
 before=queries('choice.lab.test')
 direct=run('dig','@127.0.0.1','-p','1053','choice.lab.test.','A','+short').stdout.strip()
 wait(lambda: queries('choice.lab.test')==before+1)
 assert direct=='127.0.0.2';results['files_first']={'application':['127.0.0.9'],'getent_without_addrconfig':['127.0.0.9'],'dig':direct}
 results['loopback_only_getent_default_exit']=filtered.returncode
 order('dns files');assert application('choice.lab.test')==(0,['127.0.0.2']);results['dns_first']=['127.0.0.2']
 order('files [NOTFOUND=return] dns')
 before=queries('dns-only.lab.test');code,address=application('dns-only.lab.test')
 assert code!=0 and address is None and queries('dns-only.lab.test')==before
 assert values(query('dns-only.lab.test.'))==['127.0.0.3']
 wait(lambda: queries('dns-only.lab.test')==before+1)
 results['stop_after_files_miss']={'application_failed':True,'DNS_would_answer':['127.0.0.3']}
 print(json.dumps(results,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)

权威服务器把 choice.lab.test 发布为 127.0.0.2，容器 hosts 文件把同名映射为 127.0.0.9。在 hosts: files dns 下，新 Python 进程通过 getaddrinfo 请求 IPv4，得到文件中的地址；直接向权威服务器发出的 dig 查询则得到 DNS 地址。脚本同时核对权威查询日志增加，证明直接查询确实到达了所描述的服务器，而不是只比较两个事先写好的字符串。

这个仅有回环接口的环境里，默认 getent ahostsv4 以状态 2 退出；增加 -A 关闭地址配置筛选后，返回 127.0.0.9。实验保留该失败，避免把工具空输出默认为 DNS 缺记录。Python 调用明确指定地址族，且没有启用 AI_ADDRCONFIG，所以此前已能成功。这个结果解释的是具体调用条件，不意味着应在所有生产程序中统一关闭地址族筛选。

将 NSS 改为 dns files 后，应用返回 127.0.0.2。再改为 files [NOTFOUND=return] dns，查询仅在 DNS 中存在的 dns-only.lab.test 时应用失败，权威查询次数没有变化；随后直接 DNS 查询得到 127.0.0.3，计数也随之增加。这个正反对照把本地提前停止与服务器返回否定答案区分开，避免用没有经过验证的零计数证明查询没有发生。

沿失败进程的真实路径检查

首先确认应用使用的解析 API、地址族、标志与运行时缓存策略，再查看进程所在的文件系统和网络命名空间。容器可能拥有与宿主不同的 hosts 和 resolv 配置，浏览器也可能使用自己的加密 DNS 服务。宿主命令成功可以提供线索，却不能证明失败进程看到了相同配置。已经运行的进程是否重新读取配置，也应依据其实现判断。

对于 NSS 路径，读取完整 hosts 行、结果动作及实际可用模块；对于 DNS 路径，确认目标解析器、搜索域与查询类型。隔离搜索列表影响时使用完整域名。分别查询权威与递归解析器，保留响应状态、记录和剩余 TTL，不要把所有回答都压成一个地址。若存在本地缓存服务，再查看那个实际服务的状态，不能把所有“本地”组件当成同一层。

最后将名称查询与连接建立分开。任何来源返回的地址都可能不可达，已建立的连接也可能继续使用旧对端而根本不重新解析。修复应对应观察到的原因：更新意外的 hosts 条目、修正 NSS 动作、检查相关缓存，或者调查传输路径。清空不相关缓存既无法改变文件规则，也无法改变另一个解析实现的行为；操作是否有效，应通过同一个失败调用方重新验证。

来源

Linux nsswitch.conf(5)，查询服务顺序与返回结果后的动作，已核验 2026-09-12。
Linux getaddrinfo(3)，地址族选择与 AI_ADDRCONFIG 行为，已核验 2026-09-12。
BIND 9.18.49 tools，使用 dig 查询指定 DNS 服务器，已核验 2026-09-12。

DNS 变更需要一个感知缓存的回滚窗口

Thu, 18 Jun 2026 00:00:00 +0000

改一条地址记录很容易，预测每个解析器何时停止使用旧应答却很难。生存时间（TTL）值随 DNS 响应传播，控制通常情况下的缓存新鲜度。在迁移那一刻降低 TTL，并不能改写更早被缓存下来的应答。

TTL 随每个应答传播。切换前做好准备，让两侧持续有效，并结合旧端点流量与余量决定下线和回滚。

在事件前降低 TTL

如果既有记录是一天的 TTL，至少要在计划切换前一个旧 TTL 时就把它降低。这样在权威记录仍指向旧端点时，缓存有时间去取较短的值。确切间隔应写进变更计划，而不是在迁移中即兴执行。

单独记录权威服务器的应答。下面两条探针比较系统配置的解析器与公共递归解析器，并不天然属于权威查询：

dig +noall +answer www.example.test A
dig @1.1.1.1 +noall +answer www.example.test A

要取得权威证据，应向该区域实际的名称服务器发起非递归查询，并检查 AA 标志、状态、答案与权威部分。递归解析器的剩余 TTL 反映其当前缓存状态，不同解析器可以合理地不同。还应检查服务使用的 AAAA 与 CNAME 链，不能只检查 A。

让两侧都保持有效

切换期间，保持旧端点与新端点都能为预期主机名提供服务。TLS 名称、重定向与应用配置在两侧必须一致。权威记录改变后立刻移除旧端点，会给仍持有先前应答的客户端造成本可避免的停机。

否定应答也会被缓存。一个最近返回 NXDOMAIN 的名字，其出现可能很慢才可见，因为根据区域的权威数据，否定响应可能仍留在递归缓存里。

观察后恢复 TTL

一旦权威与具有代表性的递归应答都指向新端点，且旧缓存窗口已过，就恢复正常 TTL。在变更记录中保留旧值、新值、权威应答与回滚条件。

TTL 不是所有客户端统一的下线期限。解析器在解析失败时可能提供过期数据，长连接与应用缓存也可能超过 DNS 新鲜期。应观察旧端点流量并预留余量；把 DNS 改回去同样有缓存窗口。对否定应答，应检查由 SOA 决定的否定 TTL，不能假设新 A 记录的 TTL 适用。

来源

RFC 1034 — Domain Names: Concepts and Facilities，缓存模型，已核验 2026-10-15。
RFC 1035 — Domain Names: Implementation and Specification，TTL 字段，已核验 2026-10-15。
RFC 2308 — Negative Caching of DNS Queries，否定缓存模型与保留的错误 TTL，已核验 2026-10-15。
RFC 8767 — 提供过期数据，DNS 解析失败时提供过期应答，已核验 2026-10-15。
BIND 9 dig 手册，服务器选择与递归控制，已核验 2026-10-15。

DNS 迁移应提前降低 TTL，并保留回滚缓存窗口

Thu, 18 Jun 2026 00:00:00 +0000

DNS TTL 表示一条资源记录通常可以在缓存中保留多久，之后需要刷新。修改权威记录会改变未来回答，却不会向所有曾经存储该数据的解析器发送失效通知。因此，一次迁移既包含权威更新，也包含一段客户端可能合法发现不同地址的时期。规划服务可用性时，需要同时考虑新答案和仍然存在的旧答案，而不是只看控制台保存成功。

图示表达事件先后，并非等比例时间轴。缓存可能保留不同代际；应用缓存和已有连接还有各自的生命周期。

坏掉的样子

在修改地址的同一时刻降低 TTL，并不会缩短此前缓存回答的寿命。保存了旧长 TTL 的解析器尚未获知新短 TTL。此时立即移除旧服务，可能让那些客户端失败，即使所有权威查询都已返回新地址。问题来自服务重叠期与尚未消失的发现状态不匹配；反复检查权威端的新值正确，并不能解决使用旧缓存的客户端请求。

回滚也具有同样的不对称性。把区域改回去，不会从已经学到新地址的缓存里撤回该地址。短暂正常的新目的地，可能在回滚命令完成后继续收到请求。应让回滚目标与刚发布过的目标在相关重叠期内都可用，或者明确客户端访问任何一个时如何获得可接受结果。DNS 回滚不是立即停止新地址流量的开关。

也不要把每层缓存的原始 TTL 简单相加，作为传播时间。普通转发缓存返回剩余寿命，下游再对收到的值继续计时；不同解析器群体则可能在不同时间填充缓存。应用自有缓存、长连接、权威同步延迟以及配置的陈旧回答策略，还会让单个 TTL 无法成为端到端完成保证。应把这些行为分别调查，不能用一个“传播中”笼统覆盖。

快速验证

将脚本保存为 check-dns-move.py，准备 Docker 后执行 python3 check-dns-move.py。固定环境以 BIND 9.18.49 为权威，以 dnsmasq 2.90 为一个转发缓存，二者运行在隔离容器回环接口上。程序只修改自己的临时区域，每次递增序列号并确认权威重载完成，再观察缓存。整个过程不改变公共 DNS，也不调整系统时间：

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
def record(address,ttl):return f'move {ttl} IN A {address}'
with lab(record('127.0.0.2',8)) as (_,update,cache,queries):
 cache();before=queries('move.lab.test');started=time.monotonic();initial=query('move.lab.test.',port=1054)
 wait(lambda: queries('move.lab.test')==before+1)
 assert values(initial)==['127.0.0.2'] and initial.answer[0].ttl==8
 update(record('127.0.0.2',3));lowered=query('move.lab.test.');cached_after_lower=query('move.lab.test.',port=1054)
 assert lowered.answer[0].ttl==3 and cached_after_lower.answer[0].ttl>3
 update(record('127.0.0.3',3));new_authority=query('move.lab.test.');old_cache=query('move.lab.test.',port=1054)
 assert values(new_authority)==['127.0.0.3'] and values(old_cache)==['127.0.0.2']
 time.sleep(3.3);after_new_ttl=query('move.lab.test.',port=1054)
 assert values(after_new_ttl)==['127.0.0.2']
 observations=[]
 def changed():
 answer=query('move.lab.test.',port=1054);observations.append(show(answer));return values(answer)==['127.0.0.3']
 wait(changed,timeout=8);migration_delay=round(time.monotonic()-started,3)
 update(record('127.0.0.2',3));rollback_authority=query('move.lab.test.');rollback_cache=query('move.lab.test.',port=1054)
 assert values(rollback_authority)==['127.0.0.2'] and values(rollback_cache)==['127.0.0.3']
 wait(lambda: values(query('move.lab.test.',port=1054))==['127.0.0.2'],timeout=6)
 print(json.dumps({'initial':show(initial),'lowered_authority':show(lowered),'cache_after_lower':show(cached_after_lower),
 'after_address_change':{'authority':show(new_authority),'cache':show(old_cache)},'after_new_TTL_elapsed':show(after_new_ttl),
 'new_address_observed_after_seconds':migration_delay,'rollback':{'authority':show(rollback_authority),'cache':show(rollback_cache)},
 'rollback_eventually_observed':True},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)

开始时，move.lab.test 指向 127.0.0.2，TTL 为八秒。经 dnsmasq 查询后存入该回答，权威日志确认发生一次上游查询。程序随后保持地址不变，把权威 TTL 改为三秒。直接查询看到三秒，先前填充的缓存却仍显示大于三秒的剩余 TTL。这说明修改源数据没有重写现有缓存状态，旧回答仍按照收到时的信息计时。

权威接着把地址改为 127.0.0.3，TTL 仍为三秒。直接查询立即看到新地址，缓存则继续返回 127.0.0.2。再等待三点三秒后，旧地址仍存在于缓存中。实验有意等待超过新配置 TTL 的时间，证明不能拿新数字作为更早那份回答的到期时间。只依据“已经等了新 TTL”就关闭旧端点，会忽略真实存在的旧寿命。

文章保留的历史实测约在首次填充后的七点三五秒返回 127.0.0.3。整数秒到期与进程调度影响观测间隔，因此不能把八秒配置当作跨环境的精密秒表。关键是现有副本持续超过新三秒窗口。随后脚本将权威回滚至 127.0.0.2，立即查询缓存仍得到 127.0.0.3；等这一代缓存过期后，才获得恢复的地址。前后两次对照说明，切换和回滚都会留下已有回答，而不是只有正向迁移需要等待。

在改变发现数据前准备服务重叠期

先在旧目的地仍健康时降低 TTL，确认相关权威服务器数据一致，再等待旧的较长缓存寿命耗尽后进行计划迁移。观察对服务重要的解析器和客户端群体。一次公共解析器查询只能采样一种视图，不能证明所有用户已持有相同记录。若权威副本尚未同步完成，等待起点也不能简单取最早一次编辑保存的时间。

切换时，通过真实主机名和所需协议验证新端点，并让旧端点在计划重叠期内继续服务或安全转发流量。地址发现、TLS 身份、应用状态与连接排空分别承担不同责任。DNS 变更不能修复新服务器缺失的证书，也不会把旧进程上已经建立的连接移动过去。验收应覆盖这些真实行为，而不是只有解析结果已经变化。

第一次测试成功后仍保留可用回滚窗口。记录新地址何时成为权威、使用何种 TTL，以及哪些端点必须继续存在。客户端仍访问旧地址时，先确认它是重新查询、使用缓存，还是复用旧连接。这三类观察对应不同处理和时间预期；不能因为新 DNS 查询正确，就认定旧连接一定异常，也不能为了消除尾部流量立即删除仍有调用方的服务。

RFC 8767 描述刷新失败时受控提供过期数据的行为。本例没有启用该功能，实验中的旧回答仍处于普通缓存有效期内。遇到过期回答，应先检查真实解析器策略，再判断是否违反预期。围绕明确的缓存代次与端点重叠期制定迁移计划，比把区域编辑器的保存时间当作全球完成时刻更可靠，也更便于制定和验证回滚步骤。

来源

RFC 1035 domain names，资源记录 TTL 与缓存寿命，已核验 2026-09-12。
RFC 8767 serving stale DNS data，刷新失败时受控复用过期数据，已核验 2026-09-12。
dnsmasq manual，转发、缓存与 TTL 控制，已核验 2026-09-12。

CAA 记录应授权你实际使用的签发者

Wed, 17 Jun 2026 00:00:00 +0000

认证机构授权（CAA）记录让域名持有者声明，哪些证书颁发机构可以为该域名签发证书。只有当记录与真实续期路径一致、且操作者理解策略如何从父级名称继承时，它才有用。

CAA 在签发时授权签发者。查询遇到第一个相关非空记录集就停止，通配符标签进一步细化规则。已有证书与 HTTPS 信任属于不同边界，图中签发者仅为示例。

检视当前策略

查询确切主机名及其父名称：

for name in www.example.test example.test test; do
 printf '== %s\n' "$name"
 dig +noall +answer CAA "$name"
done

这里用占位域名通过已配置的解析器查询。叶子处空应答不一定代表没有适用策略：查询会跟随别名，并在逐级向上时遇到第一个相关的非空 CAA 记录集就停止，而不是合并所有父级限制。还要查看 DNS 状态与权威信息；只显示答案的空输出可能隐藏 NXDOMAIN 或 SERVFAIL。诊断变更时应比较权威应答与递归查询结果。

匹配 CA 的签发者标识

记录使用如 issue 或 issuewild 等标签与一个签发者域值：

example.test. 3600 IN CAA 0 issue "letsencrypt.org"

该值是授权标识，不是证书里的显示名。在证书颁发机构的当前文档中确认它。没有 issuewild 时，issue 也控制通配符签发；存在 issuewild 时，通配符请求优先适用它。同一标签的多条记录提供备选授权，并不是要求每一家 CA 同时参与。CAA 也不选择某张具体的中间证书。

在续期前编排 DNS 变更

在当前证书健康时添加或收紧 CAA。等待先前 TTL 对应的完整时间，查询权威与递归应答，并运行 ACME 客户端支持的暂存或续期测试。准备好回滚记录。

不要在过期事故期间添加限制性记录，除非签发者路径已验证。一条语法正确但错误的策略，会把自动续期变成硬失败。

观察签发失败

CAA 检查发生在签发时，而不是每次 HTTPS 请求。修改 CAA 不会吊销已有证书，也不能证明历史签发符合当时的策略。因此证书监控必须同时覆盖当前过期与续期尝试。把有效的 DNS 应答随 ACME 失败一起记录，而不是只记录一条笼统的授权错误。

来源

RFC 8659 — DNS Certification Authority Authorization，CAA 查询与属性语义，已核验 2026-10-15。
Let’s Encrypt: CAA，签发者标识与运维指引，已核验 2026-10-15。

DNS · XB 现场笔记

dnsmasq 区分转发缓存与本地配置名称

坏掉的样子

快速验证

有意识地管理监听与数据来源

延伸阅读

来源

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

坏掉的样子

快速验证

依据真实需求选择寿命

延伸阅读

来源

AAAA 发布 IPv6 地址，不证明该地址可达

坏掉的样子

快速验证

沿每个已发布地址族检查服务

延伸阅读

来源

区域传送按明确授权与序列号规则复制权威数据

坏掉的样子

快速验证

分别验证复制、授权与保密性

延伸阅读

来源

DoT 与 DoH 保护通往已认证解析器的连接

坏掉的样子

快速验证

明确解析器与引导配置

延伸阅读

来源

CNAME 改变 DNS 解析路径，请求主机名仍保持原样

坏掉的样子

快速验证

移动依赖，同时维持服务契约

延伸阅读

来源

多个 DNS 地址不保证流量均匀或端点健康

坏掉的样子

快速验证

明确分配与失败处理契约

延伸阅读

来源

SRV 提供目标和端口，客户端必须理解其选择规则

坏掉的样子

快速验证

让客户端算法匹配所发布的集合

延伸阅读

来源

有用的主机名应区分本地身份、服务名称与查询范围

坏掉的样子

快速验证

按对象寿命与使用者选择名称

延伸阅读

来源

UDP 回答被截断时，DNS 需要可工作的 TCP 路径

坏掉的样子

快速验证

分开诊断截断与连接失败

延伸阅读

来源

双栈地址排序与最终成功的连接选择是不同步骤

坏掉的样子

快速验证

修改全局策略前先检查真实调用方

延伸阅读

来源

EDNS 宣告 UDP 容量，不保证沿途网络交付

坏掉的样子

快速验证

测量实际交换，不假定统一默认值

延伸阅读

来源

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

坏掉的样子

快速验证

区分权威缺失与解析失败

延伸阅读

来源

DNSSEC 验证签名数据链，不只检查签名是否存在