网络 · XB 现场笔记

TCP backlog 收纳还在握手中的连接

Fri, 24 Mar 2028 00:00:00 +0000

一个监听中的 TCP 套接字有两个队列，不是一个；而本文标题里那个 sysctl 管的，恰恰是几乎从不丢东西的那一个。传给 listen(2) 的 backlog 是 accept 队列，装的是已经完成握手、正等应用来取走的连接；SYN 队列装的才是半开请求。把两者混为一谈，就会开错药方。

这件事值得掰开，因为那句著名的建议——把 tcp_max_syn_backlog 调大——基本已经过时。tcp_syncookies 默认就是 1，而按 listen(2) 的说法，一旦启用 syncookies，SYN 队列就没有逻辑上的长度上限，这个设置会被忽略。真正会卡住你的是 accept 队列，以及应用调用 accept() 的速度。

backlog 参数管的是 accept 队列

listen(2) 明确写着，这个行为在 Linux 2.2 就变了：backlog 现在指的是「已完成建立、正等待被 accept 的套接字队列长度」，而不是半开请求的数量。半开队列由 /proc/sys/net/ipv4/tcp_max_syn_backlog 单独限制。而如果 backlog 参数超过 /proc/sys/net/core/somaxconn，它会被静默截断到那个值——Linux 5.4 之后是 4096，之前是 128。所以在默认配置的机器上写 listen(8192)，实际拿到的是 4096，而且不会有任何日志告诉你。

tcp(7) 把 tcp_max_syn_backlog 描述为「尚未收到对端确认的排队连接请求上限」：默认 256，内存达到 128 MB 及以上时升到 1024，低于 32 MB 时降到 128。ip-sysctl 补上了真正重要的限定：它是 per-listener 的限制，每个半开请求套接字大约占 304 字节，而 tcp_syncookies 默认为 1——队列溢出时发一个 cookie，而不是把请求丢掉。

syncookies 开着的时候，SYN 队列就不再是瓶颈

ip-sysctl 把 tcp_syncookies 记录为一种兜底手段，并明确说不能用它去帮一台高负载服务器扛合法的连接吞吐；它还指出 syncookies 严重违反 TCP 协议、无法使用 TCP 扩展，并可能让某些服务明显劣化。listen(2) 更进一步：启用 syncookies 时没有逻辑上的长度上限，tcp_max_syn_backlog 被忽略。而 tcp(7) 仍然把同一个旋钮描述为「超过就开始丢弃请求」——那是 syncookies 关掉时的行为。两页手册各自都说对了，只是说的是不同配置。另外 ip-sysctl 注明，syncookies 只在编译时启用了 CONFIG_SYN_COOKIES 的内核上有效，所以它并不是一个必然存在的兜底。

所以诚实的结论是：让 syncookies 保持 1，别再折腾 SYN 队列。代价是这条兜底路径救回来的连接会失去窗口缩放、SACK 这类 TCP 扩展，属于吞吐问题而不是连通性问题。如果你在合法流量下看到 SYN flood 告警，ip-sysctl 自己的建议是去调别的旋钮，而不是关掉 syncookies。

压力真正落在 accept 队列上

SYN 队列被中和之后，会满的是 accept 队列，它的容量是 min(listen(backlog), somaxconn)。溢出时的行为取决于 tcp_abort_on_overflow，默认是 FALSE：ip-sysctl 说默认值意味着「如果溢出只是突发造成的，连接会恢复」，并警告打开这个开关会伤害你的客户端。机制才是意外之处：默认情况下内核会静默丢弃最后一个 ACK，于是客户端的 connect() 成功返回，故障要等到第一个请求卡住或被重置时才浮现。之所以说默认值「能恢复」，是因为服务端随后还会按自己的节奏重传 SYN-ACK：只要在它放弃之前队列里腾出位置，这条连接就能被救回来。这也正是它无声的原因——客户端那边从头到尾都认为自己已经连上了。

更大的 backlog 是延迟线，不是容量。在模型里，listen(128) 和 listen(65535) 一秒内 accept 的连接数完全一样，都是 20,000；更大的队列只是把溢出的时刻往后推，因为 accept 速率由 worker 数量决定。

坏掉的样子

第一种故障是无声的那种，而且它就是默认行为。accept 循环太慢的服务会把 accept 队列挤满，内核丢掉最后的 ACK，客户端看到的是「连接建立了，然后就挂着」。没有任何东西被拒绝，于是客户端的连接池里堆满死套接字，报错最终出现在一个看起来无关的层面。盯住 TcpExtListenOverflows 和 TcpExtListenDrops：这两个计数器上涨而 accept 速率平稳，说明瓶颈在处理线程。

第二种故障是被丢弃的 SYN，只有在 syncookies 关掉时才会发生。SYN 队列满了就丢请求，客户端按重传时间表重试，文档给出的两个端点是「最后一次重传到 67 秒、最终超时到 131 秒」，所以用户看到的现象是一次挂了两分多钟才失败的连接。在这种配置下调大 tcp_max_syn_backlog 是真正的修法，而把 syncookies 重新打开是更好的修法——前提是你接受 TCP 扩展的损失。

快速验证

ss -lnt 'sport = :8443'
nstat -az TcpExtListenOverflows TcpExtListenDrops TcpExtTCPReqQFullDrop TcpExtTCPReqQFullDoCookies
sysctl net.core.somaxconn net.ipv4.tcp_max_syn_backlog net.ipv4.tcp_syncookies net.ipv4.tcp_abort_on_overflow

在 ss -lnt 里，Send-Q 是这个套接字创建时的 backlog，Recv-Q 是已经建立但还没被 accept 的连接数；Recv-Q 顶到 Send-Q 就是队列满了。nstat 的几个计数器应该为零或接近零：TcpExtListenOverflows 和 TcpExtListenDrops 属于 accept 队列事件，TcpExtTCPReqQFullDrop 是被丢掉的 SYN，TcpExtTCPReqQFullDoCookies 则是兜底机制在正常工作。sysctl 那一行显示内核真正会认的数字——如果 somaxconn 比你的 listen() 参数小，那么那个更小的值才是你真实的 backlog。

来源

内核 ip-sysctl 文档，somaxconn、tcp_max_syn_backlog、tcp_abort_on_overflow 以及 syncookies 的警告，已核验 2026-09-16。
Linux listen(2)，Linux 2.2 起的 accept 队列、somaxconn 的静默截断，以及 syncookies 如何取消 SYN 队列上限，已核验 2026-09-16。
Linux tcp(7)，tcp_max_syn_backlog 按内存大小的默认值，以及 syncookies 的注意事项，已核验 2026-09-16。

网络命名空间隔离网络资源，名称并不拥有其中所有进程

Sat, 19 Feb 2028 00:00:00 +0000

Linux 网络命名空间分离接口、路由、邻居表、套接字端口和包过滤规则等网络资源。它与其他命名空间共享内核，不是独立操作系统。进程通常继承父进程的网络命名空间，工具也可以在另一个范围中执行进程。这种隔离针对网络资源，不会自动涵盖全部进程身份和文件系统访问，因此需要按实际机制说明边界。

坏掉的样子

运行 ip netns exec 不会自动获得完整容器隔离。PID、用户身份和主机名隔离属于其他机制。应用可能看到不同路由，却仍与父环境共享普通文件和主机名。如果把一个网络命名空间当成完整沙箱，就会赋予它从未配置过的保证。应区分实际改变了哪类资源，以及哪些属性仍然来自原有运行环境。

新命名空间也不会自动得到有用的外部连接。接口需要有意放置和配置，本地回环可能需要启用。移动接口会改变管理它的命名空间，原范围不再把该设备列为自己的接口。因此，从错误范围执行配置命令，可能报告接口不存在，尽管预期设备仍位于另一个命名空间。诊断前应先确认命令的执行上下文。

名称还有独立生命周期。ip netns 按约定在 /run/netns 暴露引用，通常也能通过 /var/run/netns 访问。删除名称会移除这项引用，但进程或其他引用仍可维持命名空间存活。如果清理流程把名称列表中消失，直接等同于所有服务终止，就可能留下网络资源和运行中的进程。名称只是管理入口，不是进程所有权的完整表达。

快速验证

将脚本保存为 check-network-namespace.py，准备 Docker 后运行 python3 check-network-namespace.py。固定环境使用 Python 3.11.16 和 iproute2 6.1.0，通过 NET_ADMIN 与 SYS_ADMIN 在一次性容器内进行嵌套命名空间操作。临时 proc 挂载支持其中的网络参数设置，不移动宿主接口，也不发布宿主端口；实验资源随容器清理：

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 iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time

def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,'child exited without a response'
 return value
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
@contextmanager
def lab(names):
 with TemporaryDirectory(prefix='net-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc))
 stack.callback(run,'umount',str(proc))
 for name in names:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False)
 ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in names
 path=proc/'sys'/key.replace('.','/')
 return ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r}); p.write_text({str(value)!r}); print(p.read_text().strip())').stdout.strip()
 yield root,stack,setting
def wire(left,left_if,right,right_if,left_addresses,right_addresses):
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,addresses in [(left,left_if,left_addresses),(right,right_if,right_addresses)]:
 run('ip','link','set',interface,'netns',name)
 for address in addresses:ip(name,'address','add',address,'dev',interface,*(['nodad'] if ':' in address else []))
 ip(name,'link','set',interface,'up')
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 data=json.loads(ns(name,'nft','-j','list','ruleset').stdout);found={}
 for entry in data['nftables']:
 rule=entry.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:found[rule['comment']]=expression['counter']['packets']
 return found

def server(stack,name,address,port=18080,label='server'):
 code=r'''
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
import json,socket,sys
address,port,label=sys.argv[1],int(sys.argv[2]),sys.argv[3]
class Handler(BaseHTTPRequestHandler):
 def do_GET(self):
 body=json.dumps({'server':label,'peer':self.client_address,'path':self.path}).encode()
 self.send_response(200);self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
 def log_message(self,*args):pass
class Server(ThreadingHTTPServer):
 address_family=socket.AF_INET6 if ':' in address else socket.AF_INET
 def server_bind(self):
 if self.address_family==socket.AF_INET6:self.socket.setsockopt(socket.IPPROTO_IPV6,socket.IPV6_V6ONLY,1)
 super().server_bind()
service=Server((address,port),Handler);print('ready',flush=True);service.serve_forever()
'''
 process=spawn(stack,['ip','netns','exec',name,'python3','-u','-c',code,address,str(port),label])
 assert line(process).strip()=='ready';return process
def request(name,address,port=18080):
 code=r'''
import http.client,json,sys
client=http.client.HTTPConnection(sys.argv[1],int(sys.argv[2]),timeout=.7)
try:
 client.request('GET','/lab-visible-message');response=client.getresponse();body=json.loads(response.read())
 assert response.status==200;print(json.dumps({'ok':True,'status':response.status,'body':body}))
except OSError as error:print(json.dumps({'ok':False,'type':type(error).__name__,'errno':error.errno}))
finally:client.close()
'''
 return json.loads(ns(name,'python3','-c',code,address,str(port)).stdout)

with lab(['blue','green']) as (root,stack,setting):
 probe='import json,os,socket;print(json.dumps({"net":os.readlink("/proc/self/ns/net"),"pid":os.readlink("/proc/self/ns/pid"),"hostname":socket.gethostname()}))'
 parent=json.loads(run('python3','-c',probe).stdout)
 views={name:json.loads(ns(name,'python3','-c',probe).stdout) for name in ['blue','green']}
 assert len({parent['net'],views['blue']['net'],views['green']['net']})==3
 assert all(v['pid']==parent['pid'] and v['hostname']==parent['hostname'] for v in views.values())
 for name in ['blue','green']:
 ip(name,'link','add','dummy0','type','dummy');ip(name,'addr','add','192.0.2.10/24','dev','dummy0');ip(name,'link','set','dummy0','up')
 ip('blue','route','add','203.0.113.0/24','dev','dummy0')
 assert json.loads(ip('blue','-j','route','show','203.0.113.0/24').stdout)
 assert not json.loads(ip('green','-j','route','show','203.0.113.0/24').stdout)
 setting('blue','net.ipv4.ip_forward',0);setting('green','net.ipv4.ip_forward',1)
 forwarding={name:ns(name,'sysctl','-n','net.ipv4.ip_forward').stdout.strip() for name in ['blue','green']};assert forwarding=={'blue':'0','green':'1'}
 marker=root/'shared.txt';marker.write_text('shared filesystem')
 assert ns('blue','cat',str(marker)).stdout==ns('green','cat',str(marker)).stdout=='shared filesystem'
 daemon=server(stack,'blue','192.0.2.10',label='blue')
 named=request('blue','192.0.2.10');assert named['ok'] and named['body']['server']=='blue'
 run('ip','netns','delete','blue');assert not Path('/run/netns/blue').exists()
 assert daemon.poll() is None and os.readlink(f'/proc/{daemon.pid}/ns/net')==views['blue']['net']
 by_pid=run('nsenter','-t',str(daemon.pid),'-n','python3','-c',
 'import http.client,json; c=http.client.HTTPConnection("192.0.2.10",18080,timeout=1);c.request("GET","/");r=c.getresponse();print(json.dumps({"status":r.status,"body":json.loads(r.read())}));c.close()')
 surviving=json.loads(by_pid.stdout);assert surviving['status']==200 and surviving['body']['server']=='blue'
 print(json.dumps({'parent':parent,'namespace_views':views,'blue_only_route':True,'forwarding':forwarding,
 'same_file_visible':True,'before_name_deleted':named,'name_deleted_process_alive':True,'after_name_deleted':surviving}))
"""
name='xbcatm-netpath-'+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)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN',
 '--memory','256m','--pids-limit','128',name,'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)

父环境、blue 和 green 报告三个不同网络命名空间标识，但 PID 命名空间标识与主机名保持相同。父进程创建的标记文件，也能被两个子范围读取。这些正向观察明确了本例边界：网络范围改变了，而所检查的这些进程和文件系统属性仍然共享。不能由网络标识不同，推导其他所有隔离也已经建立。

两个子范围各自创建 dummy0，都使用 192.0.2.10/24。相同名称和地址能够共存，因为它们属于不同网络上下文。只有 blue 增加到 203.0.113.0/24 的路由，查询 green 确认没有对应条目。实验检查生效的独立路由表，不是只打印两个名称就宣布隔离成功，也没有要求地址文本必须跨所有命名空间唯一。

程序明确把 blue 的 IPv4 转发设为零、green 设为一，再分别读取确认。这验证参数作用范围，没有演示真实报文转发。dummy 接口没有物理对端，配置地址和路由也不表示能够访问外部服务。应保留“参数已经不同”和“某条通信路径实际可用”之间的区别，避免把管理状态当成应用交付结果。

真实 HTTP 服务器在 blue 的 192.0.2.10 启动。通过命名空间名称执行客户端，得到状态二百和身份 blue。脚本随后删除 blue 名称，确认引用路径消失，但服务器进程和它的网络命名空间标识仍存在。移除命名引用没有杀死进程，也没有令监听立即消失，这是清理和故障恢复中很重要的生命周期差异。

利用这个明确属于实验的服务器 PID，nsenter 在仍存活的网络命名空间执行另一个客户端，再次得到状态二百与身份 blue。这证明删除名称后应用仍在工作，而不只是 proc 中还有一个条目。最后，清理栈停止自己启动的进程并移除其他命名资源，容器生命周期负责收回实验整体范围，不涉及现有宿主服务。

分开管理名称、进程归属与通信配置

记录服务的进程归属，以及运维命令实际使用的网络范围。命名空间标识适合比较当前活跃上下文，不应把短暂标识当作永久资产身份。名称意外消失时，先检查相关自有进程，再判断网络状态是否已经释放。不能仅凭列表为空，就假定可以在没有旧状态和旧服务的前提下创建替代环境。

对普通配置文件，ip netns exec 可以创建挂载命名空间，将按网络名称准备的文件绑定到惯常位置，例如使用独立解析器配置。这不等于复制了全部私有文件系统。重现客户端环境时，应记录这些额外选择，避免混淆 DNS 配置差异与路由隔离。某个共享标记文件可见，也不代表所有配置路径都必然使用相同视图。

需要通信时，应明确建立虚拟链路、路由、转发和过滤。网络命名空间提供资源边界，真正配置决定哪些数据能够通过。拆除时，应先停止服务拥有的进程并释放相关引用，再期待范围完全消失。删除名称是生命周期中的一项管理动作，不是通用的进程终止命令，也不能代替对残留服务和资源的实际检查。

来源

Linux network_namespaces(7)，网络命名空间隔离的资源，已核验 2026-09-12。
Linux ip-netns(8)，名称引用、命令执行及进程存活时的删除语义，已核验 2026-09-12。
Linux ip-link(8)，接口创建与命名空间归属，已核验 2026-09-12。

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

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

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

坏掉的样子

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。

TCP 慢启动随数据确认增长，不会仅因时间流逝而翻倍

Tue, 28 Dec 2027 00:00:00 +0000

慢启动在 TCP 发送端探索路径可承受的未确认数据量时，逐步扩大拥塞窗口。数据充足且确认模式合适时，经典行为是在多个往返间近似指数增长。“每个 RTT 翻倍”是有用的简化模式，不是无条件计时器规则。窗口变化依赖传输反馈和实现的增长条件，不能只根据连接已经打开多久，就推断它获得了多少发送预算。

坏掉的样子

connect 之后等待，不会自动把拥塞窗口预热。应用没有发送数据时，就没有支持这种增长的数据确认。很小的交换，也可能在用满已有发送预算之前便结束。期待每个短请求都出现大幅翻倍序列，是把受应用数据量限制的传输误认成持续积压的发送端。缺少明显增长，并不自动说明慢启动没有工作或连接存在故障。

现代系统初始窗口也不统一为一到两个段。RFC 6928 描述了允许更大初始窗口的实验性扩展，本次 Linux 发送端起步为十个段。单位同样重要：Linux TCP_INFO 的 snd_cwnd 以段为单位，许多协议说明则用字节描述拥塞窗口。推算未确认数据量之前，应同时查看发送 MSS，避免将段数直接当成字节数或当前实际在途段数。

慢启动并非总要持续到第一次丢失，之后统一彻底缩回起点。慢启动阈值帮助决定启动增长与拥塞避免，具体实现还可能采用额外启动检测；重传超时恢复也不同于快速恢复。把同一条示意曲线套到所有算法、丢失信号和工作负载，即使读到了真实指标，也可能作出错误诊断。首先需要确认当前连接处于哪个阶段。

快速验证

将脚本保存为 check-slow-start.py，准备 Docker 后运行 python3 check-slow-start.py。一次性环境使用 Python 3.11.16 和 iproute2 6.1.0，在 Linux 6.12.76 上验证。NET_ADMIN 与 SYS_ADMIN 支持嵌套命名空间。客户端和目标通过新建 veth 相连，netem 在两个方向的出口各添加十毫秒延迟，全部变更仅作用于虚拟端点：

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 iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time

def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,('child exited without a response',process.stderr.read())
 return value
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
@contextmanager
def lab(names):
 with TemporaryDirectory(prefix='net-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc))
 stack.callback(run,'umount',str(proc))
 for name in names:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False)
 ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in names
 path=proc/'sys'/key.replace('.','/')
 return ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r}); p.write_text({str(value)!r}); print(p.read_text().strip())').stdout.strip()
 yield root,stack,setting
def wire(left,left_if,right,right_if,left_addresses,right_addresses):
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,addresses in [(left,left_if,left_addresses),(right,right_if,right_addresses)]:
 run('ip','link','set',interface,'netns',name)
 for address in addresses:ip(name,'address','add',address,'dev',interface,*(['nodad'] if ':' in address else []))
 ip(name,'link','set',interface,'up')
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 data=json.loads(ns(name,'nft','-j','list','ruleset').stdout);found={}
 for entry in data['nftables']:
 rule=entry.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:found[rule['comment']]=expression['counter']['packets']
 return found


info_code=r'''
import struct
def tcp_info(stream):
 raw=stream.getsockopt(socket.IPPROTO_TCP,socket.TCP_INFO,104);assert len(raw)==104
 offsets={'snd_mss':16,'unacked':24,'rtt_us':68,'snd_ssthresh':76,'snd_cwnd':80,'total_retrans':100}
 return {'ca_state':raw[1],**{key:struct.unpack_from('=I',raw,offset)[0] for key,offset in offsets.items()}}
'''
with lab(['client','target']) as (root,stack,setting):
 wire('client','c0','target','t0',['192.0.2.1/30'],['192.0.2.2/30'])
 for name,interface in [('client','c0'),('target','t0')]:
 ns(name,'tc','qdisc','add','dev',interface,'root','netem','delay','10ms','limit','10000')
 server_code=r'''
import socket,json,hashlib,sys
size=int(sys.argv[1]);listener=socket.socket();listener.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
listener.bind(('192.0.2.2',18080));listener.listen();print('listening',flush=True)
with listener.accept()[0] as connection:
 connection.settimeout(6);remaining=size;digest=hashlib.sha256()
 while remaining:
 chunk=connection.recv(min(65536,remaining));assert chunk;remaining-=len(chunk);digest.update(chunk)
 assert digest.hexdigest()==hashlib.sha256(b'x'*size).hexdigest()
 connection.sendall((digest.hexdigest()+'\n').encode())
'''
 client_code=info_code+r'''
import socket,json,time,threading,sys,hashlib
size=int(sys.argv[1]);stream=socket.socket();stream.settimeout(6)
stream.setsockopt(socket.IPPROTO_TCP,socket.TCP_CONGESTION,b'reno');stream.connect(('192.0.2.2',18080))
initial=tcp_info(stream);time.sleep(.06);idle=tcp_info(stream);assert idle['snd_cwnd']==initial['snd_cwnd']
done=threading.Event();errors=[];samples=[initial,idle];reply=[]
def transfer():
 try:
 stream.sendall(b'x'*size)
 with stream.makefile('rb') as incoming:reply.append(incoming.readline().decode().strip())
 except BaseException as error:errors.append(repr(error))
 finally:done.set()
worker=threading.Thread(target=transfer);worker.start();deadline=time.monotonic()+7
while not done.wait(.005):
 assert time.monotonic()<deadline,'transfer deadline exceeded'
 snapshot=tcp_info(stream)
 if snapshot!=samples[-1]:samples.append(snapshot)
worker.join(timeout=1);assert not worker.is_alive() and not errors,errors
samples.append(tcp_info(stream));assert reply==[hashlib.sha256(b'x'*size).hexdigest()]
assert all(row['total_retrans']==0 for row in samples),samples
if size>1:assert max(row['snd_cwnd'] for row in samples)>initial['snd_cwnd']*2,samples
else:assert max(row['snd_cwnd'] for row in samples)==initial['snd_cwnd'],samples
print(json.dumps({'bytes':size,'algorithm':stream.getsockopt(socket.IPPROTO_TCP,socket.TCP_CONGESTION,16).split(b'\0')[0].decode(),
 'before_data':initial,'after_idle_without_data':idle,'samples':samples,'sha256':reply[0]}));stream.close()
'''
 results={}
 for label,size in [('short',1),('bulk',1048576)]:
 service=spawn(stack,['ip','netns','exec','target','python3','-u','-c',server_code,str(size)]);assert line(service).strip()=='listening'
 results[label]=json.loads(ns('client','python3','-c',client_code,str(size),timeout=10).stdout)
 service.wait(timeout=2);assert service.returncode==0
 print(json.dumps({'egress_delay_each_direction_ms':10,'transfers':results}))
"""
name='xbcatm-tcpflow-'+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)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN',
 '--memory','256m','--pids-limit','128',name,'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)

客户端明确选择 Reno，避免实验悄悄受不同默认拥塞控制器影响。发送之前记录 TCP_INFO，在没有数据的情况下等待六十毫秒，然后再次记录。两次观察窗口均为十个段。这直接检验“新连接只要保持打开，拥塞预算就会按时间增长”的错误预期。增加等待时间与提供可确认的数据，属于不同输入，不能互相替代。

第一次传输发送一个字节，并接收服务器返回的摘要。采样中未确认段数先为一、随后为零，拥塞窗口始终保持十。这个负载成功交付，并不需要可见的指数增长，因为原先允许的在途量已足以容纳整个请求。应用提供的数据太少，没有驱动大流量启动爬升；不能从这种短小成功交换里期待完整带宽探测曲线。

第二次发送一 MiB。独立线程执行阻塞交换，主线程持续采样套接字状态，避免 sendall 等待期间丢失观察。记录包含十、二十、四十、八十个段，随后随着确认聚合和传输进展出现不那么整齐的数值。测试要求窗口显著增长，没有规定唯一采样序列，也不假定每个样本恰好对应一个 RTT。具体数值需要连同采样方法解释。

服务器与客户端通过 SHA-256 验证载荷，所有采样的累计重传数保持零。本次阈值远高于观察到的窗口。这些事实支持由确认驱动的启动演示，但没有刻意验证丢失恢复，也没有测量共享瓶颈。人工添加的延迟使过程容易观察，不代表真实广域网容量或公平性。读者不能把隔离虚拟链路当作生产网络性能基准。

结合负载解释增长轨迹

一起记录算法、MSS、拥塞窗口、阈值、未确认数据、RTT 与重传证据。窗口大于当前未确认段数完全可能，因为应用或接收端还会施加其他限制。采样窗口代表发送端当前允许量，不保证路径上始终存在恰好那么多段。把预算与实际占用区分开，才能判断停顿来自拥塞控制、数据不足还是接收方向约束。

采样本身也影响图景。用户态观察者可能错过中间变化，五毫秒间隔并未与 ACK 到达同步。延迟确认、卸载行为和调度都会改变可见序列。脚本检查数据能够支持的关系，不会仅因少了某个中间值，就宣称拥塞控制器损坏。判断异常之前，应先确认观测精度是否足以支持所期待的逐步变化。

对短操作，在应用协议允许时减少无谓的新连接，可以避免反复使用全新的拥塞预算。连接复用后，空闲重启策略仍可能减小窗口，不能保证此前形成的发送预算一直保留。对批量传输，修改启动设置之前应测试代表性 RTT、丢失、接收行为和竞争流量。本例把空闲时间、微小成功交换与持续数据区分开，为判断慢启动是否与观察到的延迟有关提供具体依据。优化需要针对真实约束，而不是只追求曲线看起来翻倍整齐。

来源

RFC 5681 Congestion Control，由确认驱动的慢启动、拥塞避免、阈值切换与空闲重启，已核验 2026-09-12。
RFC 6928 Initial Window，允许更大初始拥塞窗口的实验性扩展，已核验 2026-09-12。
Linux 6.12.76 TCP_INFO fields，拥塞窗口、阈值、未确认段与重传字段，已核验 2026-09-12。

veth 对在两个端点之间搬运帧，路由决定这些帧承载的路径

Sun, 21 Nov 2027 00:00:00 +0000

veth 对由两个互联的虚拟以太网设备组成。从一端发送的帧到达另一端，再由接收网络栈或网桥处理。两端可以放在不同 Linux 网络命名空间，因此常用于容器网络。创建这一对设备只提供链路，地址、路由、桥接关系、转发和访问策略都需要另外配置。不能把接口已经出现，等同于完整网络已经准备好。

坏掉的样子

接口显示管理状态 UP，仍可能因为 veth 对端关闭而没有载波。只读取 UP 标志，会让尚未完成的配置看起来已经就绪。应检查两个端点，并区分管理状态与 LOWER_UP。路由也可能已经指向这个接口，但链路仍无法承载有效流量，所以路由列表本身不是连通性检查，更不能代替一次真实应用交换。

veth 对不会把 IP 载荷限制为对端接口自身地址。路由选择报文经过哪个链路，随后以太网转发或接收网络栈决定下一步处理。发往容器直接邻居之外的流量，也可以通过这一对设备到达路由器或网桥。声称“不发给对端的包都会留在本地”，混淆了链路交付与 IP 目的地选择，容易误导容器出口排障。

两端生命周期也相互关联。删除一个 veth 端点，会移除另一个端点，即使对端由另一个命名空间管理。因此宿主侧清理动作可能删除容器接口。影响活跃工作负载时，应有意识地安排停止流量、调整路由和删除设备的顺序。命名空间分离了管理视图，却没有让成对设备变成两项互不影响的资源。

快速验证

将脚本保存为 check-veth.py，准备 Docker 后执行 python3 check-veth.py。固定 Linux 容器使用 Python 3.11.16、iproute2 6.1.0，以及用于嵌套命名空间的 NET_ADMIN 和 SYS_ADMIN。它只创建一次性虚拟设备。左右命名空间各获得一个端点，分别配置 192.0.2.1/30 和 192.0.2.2/30，没有移动现有宿主网卡：

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 iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time

def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,'child exited without a response'
 return value
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
@contextmanager
def lab(names):
 with TemporaryDirectory(prefix='net-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc))
 stack.callback(run,'umount',str(proc))
 for name in names:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False)
 ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in names
 path=proc/'sys'/key.replace('.','/')
 return ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r}); p.write_text({str(value)!r}); print(p.read_text().strip())').stdout.strip()
 yield root,stack,setting
def wire(left,left_if,right,right_if,left_addresses,right_addresses):
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,addresses in [(left,left_if,left_addresses),(right,right_if,right_addresses)]:
 run('ip','link','set',interface,'netns',name)
 for address in addresses:ip(name,'address','add',address,'dev',interface,*(['nodad'] if ':' in address else []))
 ip(name,'link','set',interface,'up')
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 data=json.loads(ns(name,'nft','-j','list','ruleset').stdout);found={}
 for entry in data['nftables']:
 rule=entry.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:found[rule['comment']]=expression['counter']['packets']
 return found

def server(stack,name,address,port=18080,label='server'):
 code=r'''
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
import json,socket,sys
address,port,label=sys.argv[1],int(sys.argv[2]),sys.argv[3]
class Handler(BaseHTTPRequestHandler):
 def do_GET(self):
 body=json.dumps({'server':label,'peer':self.client_address,'path':self.path}).encode()
 self.send_response(200);self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
 def log_message(self,*args):pass
class Server(ThreadingHTTPServer):
 address_family=socket.AF_INET6 if ':' in address else socket.AF_INET
 def server_bind(self):
 if self.address_family==socket.AF_INET6:self.socket.setsockopt(socket.IPPROTO_IPV6,socket.IPV6_V6ONLY,1)
 super().server_bind()
service=Server((address,port),Handler);print('ready',flush=True);service.serve_forever()
'''
 process=spawn(stack,['ip','netns','exec',name,'python3','-u','-c',code,address,str(port),label])
 assert line(process).strip()=='ready';return process
def request(name,address,port=18080):
 code=r'''
import http.client,json,sys
client=http.client.HTTPConnection(sys.argv[1],int(sys.argv[2]),timeout=.7)
try:
 client.request('GET','/lab-visible-message');response=client.getresponse();body=json.loads(response.read())
 assert response.status==200;print(json.dumps({'ok':True,'status':response.status,'body':body}))
except OSError as error:print(json.dumps({'ok':False,'type':type(error).__name__,'errno':error.errno}))
finally:client.close()
'''
 return json.loads(ns(name,'python3','-c',code,address,str(port)).stdout)

with lab(['left','right']) as (root,stack,setting):
 run('ip','link','add','left0','type','veth','peer','name','right0')
 run('ip','link','set','left0','netns','left');run('ip','link','set','right0','netns','right')
 ip('left','addr','add','192.0.2.1/30','dev','left0');ip('right','addr','add','192.0.2.2/30','dev','right0')
 ip('left','link','set','left0','up')
 before=json.loads(ip('left','-j','link','show','left0').stdout)[0]
 assert 'LOWER_UP' not in before['flags']
 failed=ns('left','ping','-n','-c','1','-W','1','192.0.2.2',check=False);assert failed.returncode!=0
 ip('right','link','set','right0','up')
 after={name:json.loads(ip(name,'-j','link','show',interface).stdout)[0] for name,interface in [('left','left0'),('right','right0')]}
 assert all('LOWER_UP' in v['flags'] for v in after.values())
 ip('left','neigh','flush','dev','left0');ip('right','neigh','flush','dev','right0')
 successful=ns('left','ping','-n','-c','1','-W','1','192.0.2.2');assert successful.returncode==0
 daemon=server(stack,'right','192.0.2.2',label='right');response=request('left','192.0.2.2');assert response['ok']
 ip('right','addr','add','203.0.113.9/32','dev','lo');ip('left','route','add','203.0.113.9/32','via','192.0.2.2')
 server(stack,'right','203.0.113.9',label='beyond-link-address');routed_response=request('left','203.0.113.9');assert routed_response['ok']
 ip('left','link','delete','left0');gone=ip('right','link','show','right0',check=False);assert gone.returncode!=0 and 'does not exist' in gone.stderr
 print(json.dumps({'one_end_up_flags':before['flags'],'one_end_up_ping_exit':failed.returncode,
 'both_up_flags':{n:v['flags'] for n,v in after.items()},'both_up_ping_exit':successful.returncode,'http':response,'other_ip_destination':routed_response,
 'deleting_one_removes_peer':True,'peer_absent_diagnostic':gone.stderr.strip()}))
"""
name='xbcatm-netpath-'+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)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN',
 '--memory','256m','--pids-limit','128',name,'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)

起初只启用 left0，它的标志包含 UP 和 NO-CARRIER，没有 LOWER_UP，因为 right0 仍关闭。单次 ping 失败。这里同时提供链路状态和实际失败交换，没有用“接口创建成功”来替代对端已经配置正确的证据。管理状态说明操作者希望设备工作，载波状态则反映配对链路当前能否成立。

启用 right0 后，两端都报告 LOWER_UP。脚本清理失败尝试留下的邻居条目，再进行正常状态比较，避免残留解析计时影响结果。新的 ping 成功，从左侧访问 192.0.2.2 的真实 HTTP 请求也收到右侧服务身份。清理动作明确可见，实验没有承诺所有已经等待中的应用请求都会在启用链路后瞬间恢复。

随后右侧在回环接口配置 203.0.113.9/32，左侧添加经 192.0.2.2 到该地址的主机路由。第二个绑定 203.0.113.9 的 HTTP 监听，仍通过同一 veth 对成功响应。报文的 IP 目的地不同于对端链路地址，但所选路径依然使用这条虚拟以太网链路。这个对照直接检验地址与传输路径的区别。

第二个目的地属于右侧命名空间本地，因此本例没有声称继续经过另一个路由器转发。它只隔离链路邻居地址与最终 IP 目的地之间的差异。更大拓扑可以把接收端接入网桥或路由网络，但这些额外组件需要独立配置和验证。不能由这次成功，就推导容器已经自动获得公网出口或任意跨网段访问能力。

最后删除 left0，右侧执行 ip link show right0 得到设备不存在的诊断。对端是被移除了，而不只是进入管理关闭状态；两个命名空间本身在清理之前仍存在。这个结果区分成对设备生命周期与容纳某一端的命名空间生命周期。清理日志需要反映真正被删除的资源，不能把所有变化都写成同一种“断网”。

按层次检查实际路径

先确认两端归属的命名空间及运行时赋予的名称，再查看管理状态、载波、地址、邻居解析和失败目的地的路由。链路变化后，旧邻居状态可能延迟恢复；缺失路由则可能让报文根本没有发上链路。即使高层客户端都只显示超时，这些原因也需要不同修复。应保留各层直接证据，而不是只围绕一个接口标志反复修改。

一对设备不是多端口交换机。网桥可以在以太网层连接多个此类链路，路由器则在 IP 网络之间转发。启用端点不会自动建立这些行为，也不会自动添加互联网路由。文档应记录真实连接关系与过滤位置，尤其当容器运行时创建设备，而其他组件管理路由或防火墙时，不能假定其中一方已经完成了所有配置。

把删除视为同时影响两端的操作，并验证相关工作负载结果。如果吞吐量或延迟要求推动 MTU、队列或卸载配置调整，应测量相应路径，不能仅因链路是虚拟设备就推断性能。本实验验证成对交付、明确就绪、正确目的地路由以及关联删除，不代表完成了一整套容器网络，也不建立统一性能承诺。

来源

Linux veth(4)，成对传输、载波状态及命名空间使用，已核验 2026-09-12。
Linux ip-link(8)，veth 创建、状态、移动及删除，已核验 2026-09-12。
Linux network_namespaces(7)，网络边界与虚拟设备生命周期，已核验 2026-09-12。

VXLAN 既需要底层可达，也需要两端隧道参数一致

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

VXLAN 把以太网帧装进 UDP 数据包，使覆盖网络能够跨越底层 IP 网络。隧道端点负责封装与解封装，二十四位 VXLAN 网络标识符 VNI 用来标识虚拟网段。外层 IP 地址负责端点之间的选路，内层以太网与 IP 地址服务于覆盖网络。这是具有不同配置和可达性条件的两个层次，不能用其中一层的成功替另一层作结论。

坏掉的样子

能够 ping 通隧道端点，无法充分证明特定覆盖网段正常。两端地址可能均可达，却使用不同 VNI、UDP 目的端口或远端节点配置。底层防火墙也可能允许 ICMP，却丢弃封装后的 UDP。排查应针对真正的传输协议和虚拟网段，不能因为底层一次 ping 成功，就认为其上所有租户流量都已验证通过。

封装还会占用底层数据包容量。内层以太网帧没有 VLAN 标签、外层采用普通 IPv4 和 UDP 时，覆盖 IP MTU 设为一千四百五十，可以装进一千五百的底层 IP MTU：内层以太网、VXLAN、UDP 与外层 IPv4 头共占五十字节。外层 IPv6、VLAN 标签或其他封装会改变计算。小请求成功，本身没有验证大包或路径 MTU 发现。

VNI 也不是加密密钥或经过认证的租户身份。能够观察封装流量的一方，可能直接读取其中内容；隧道端点是否可信，依赖周边网络控制。VXLAN 的分段职责不能自动提供机密性。应保护底层网络，在威胁模型要求时采用适当的认证加密，避免把“处于不同虚拟网段”理解成报文内容必然不可读。

快速验证

将脚本保存为 check-vxlan.py，准备 Docker 后运行 python3 check-vxlan.py。一次性 Linux 容器使用 Python 3.11.16、iproute2 6.1.0 和 tcpdump 4.99.3。NET_ADMIN 与 SYS_ADMIN 支持嵌套网络命名空间及临时 proc 挂载。两个端点仅通过新建 veth 相连，不修改宿主路由，不挂载宿主目录，也不发布服务端口：

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 iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time

def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,'child exited without a response'
 return value
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
@contextmanager
def lab(names):
 with TemporaryDirectory(prefix='net-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc))
 stack.callback(run,'umount',str(proc))
 for name in names:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False)
 ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in names
 path=proc/'sys'/key.replace('.','/')
 return ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r}); p.write_text({str(value)!r}); print(p.read_text().strip())').stdout.strip()
 yield root,stack,setting
def wire(left,left_if,right,right_if,left_addresses,right_addresses):
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,addresses in [(left,left_if,left_addresses),(right,right_if,right_addresses)]:
 run('ip','link','set',interface,'netns',name)
 for address in addresses:ip(name,'address','add',address,'dev',interface,*(['nodad'] if ':' in address else []))
 ip(name,'link','set',interface,'up')
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 data=json.loads(ns(name,'nft','-j','list','ruleset').stdout);found={}
 for entry in data['nftables']:
 rule=entry.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:found[rule['comment']]=expression['counter']['packets']
 return found

def server(stack,name,address,port=18080,label='server'):
 code=r'''
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
import json,socket,sys
address,port,label=sys.argv[1],int(sys.argv[2]),sys.argv[3]
class Handler(BaseHTTPRequestHandler):
 def do_GET(self):
 body=json.dumps({'server':label,'peer':self.client_address,'path':self.path}).encode()
 self.send_response(200);self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
 def log_message(self,*args):pass
class Server(ThreadingHTTPServer):
 address_family=socket.AF_INET6 if ':' in address else socket.AF_INET
 def server_bind(self):
 if self.address_family==socket.AF_INET6:self.socket.setsockopt(socket.IPPROTO_IPV6,socket.IPV6_V6ONLY,1)
 super().server_bind()
service=Server((address,port),Handler);print('ready',flush=True);service.serve_forever()
'''
 process=spawn(stack,['ip','netns','exec',name,'python3','-u','-c',code,address,str(port),label])
 assert line(process).strip()=='ready';return process
def request(name,address,port=18080):
 code=r'''
import http.client,json,sys
client=http.client.HTTPConnection(sys.argv[1],int(sys.argv[2]),timeout=.7)
try:
 client.request('GET','/lab-visible-message');response=client.getresponse();body=json.loads(response.read())
 assert response.status==200;print(json.dumps({'ok':True,'status':response.status,'body':body}))
except OSError as error:print(json.dumps({'ok':False,'type':type(error).__name__,'errno':error.errno}))
finally:client.close()
'''
 return json.loads(ns(name,'python3','-c',code,address,str(port)).stdout)

def capture(stack,root,name,interface,expression,label):
 path=root/(label+'.pcap')
 process=subprocess.Popen(['ip','netns','exec',name,'tcpdump','--immediate-mode','-Z','root','-U','-n','-i',interface,'-w',str(path),expression],
 stdout=subprocess.DEVNULL,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process)
 deadline=time.monotonic()+3
 while time.monotonic()<deadline:
 assert process.poll() is None,'tcpdump exited before listening'
 if select.select([process.stderr],[],[],.1)[0] and 'listening on' in process.stderr.readline():return process,path
 raise AssertionError('tcpdump did not become ready')
def captured(process,path,ascii=False):
 process.send_signal(signal.SIGINT);_,diagnostic=process.communicate(timeout=3)
 assert process.returncode==0,diagnostic
 result=run('tcpdump','-nn','-vv',*(['-A'] if ascii else []),'-r',str(path))
 return result.stdout

with lab(['left','right']) as (root,stack,setting):
 wire('left','ul','right','ur',['192.0.2.1/30'],['192.0.2.2/30'])
 for name,interface in [('left','ul'),('right','ur')]:ip(name,'link','set',interface,'mtu','1500')
 def overlay(name,vni):
 local,remote,dev,address,mac=('192.0.2.1','192.0.2.2','ul','10.42.0.1/24','02:00:00:00:42:01') if name=='left' else ('192.0.2.2','192.0.2.1','ur','10.42.0.2/24','02:00:00:00:42:02')
 ip(name,'link','add','vx0','type','vxlan','id',str(vni),'local',local,'remote',remote,'dev',dev,'dstport','4789','nolearning')
 ip(name,'link','set','vx0','address',mac,'mtu','1450')
 ip(name,'addr','add',address,'dev','vx0');ip(name,'link','set','vx0','up')
 overlay('left',42);overlay('right',42);server(stack,'right','10.42.0.2',label='overlay')
 tap,path=capture(stack,root,'left','ul','udp port 4789','vxlan')
 successful=request('left','10.42.0.2');assert successful['ok'] and successful['body']['server']=='overlay'
 packets=captured(tap,path,ascii=True)
 assert 'vni 42' in packets.lower() and 'lab-visible-message' in packets and '.4789:' in packets,packets
 details=json.loads(ip('left','-d','-j','link','show','vx0').stdout)[0]
 assert details['linkinfo']['info_data']['id']==42 and details['mtu']==1450
 ip('right','link','delete','vx0');overlay('right',43)
 underlay=ns('left','ping','-n','-c','1','-W','1','192.0.2.2');assert underlay.returncode==0
 mismatch=request('left','10.42.0.2');assert not mismatch['ok'] and mismatch['type']=='TimeoutError'
 ip('right','link','delete','vx0');overlay('right',42)
 recovered=request('left','10.42.0.2');assert recovered['ok']
 print(json.dumps({'healthy_overlay':successful,'underlay_packet_capture':packets,'vni':details['linkinfo']['info_data']['id'],
 'underlay_mtu':1500,'overlay_mtu':details['mtu'],'mismatched_vni_underlay_ping_exit':underlay.returncode,
 'mismatched_vni_overlay':mismatch,'matching_vni_restored':recovered}))
"""
name='xbcatm-netpath-'+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)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN',
 '--memory','256m','--pids-limit','128',name,'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)

底层地址分别为 192.0.2.1 与 192.0.2.2。每端明确指定远端节点，并把 UDP 目的端口设置为 4789，避免依赖实现历史上的不同默认值。两侧覆盖设备起初均使用 VNI 42、固定 MAC 地址，以及 10.42.0.1 和 10.42.0.2。这只是一个小型单播隧道，并非完整多点网络或 EVPN 部署，没有隐含提供其他控制面能力。

跨覆盖网络发送 HTTP 请求后，客户端取得预期服务器身份。同时，tcpdump 在底层捕获标有 VNI 42 的 UDP 报文，其中包含内层 ARP 与 TCP 流量。捕获文本直接出现请求路径 /lab-visible-message。这证明该配置传输应用字节时没有加密；VNI 限定虚拟网段的交付范围，却不会隐藏载荷内容。结论来自真实通信与对应捕获，而非协议名称推断。

本地 veth 抓包还显示 UDP 与 TCP 校验和似乎不正确，但 HTTP 交互成功。Linux 可以把校验和表示为稍后处理阶段才完成的部分工作，封装流量的卸载也可能参与其中。这份捕获不能证明线路报文损坏。脚本没有关闭卸载，也未逐个定位校验和处理阶段，因此不会声称已经测得硬件故障，或已经完成全部校验和原因诊断。

随后重建右侧覆盖设备，仅将 VNI 改为 43，保持地址与 MAC 相同。底层 ping 仍成功，覆盖 HTTP 请求却超时。将设备恢复为 VNI 42 后，HTTP 恢复成功。固定其他覆盖属性，使标识符不一致成为受控变化，避免把重建导致的 MAC 变化、旧邻居缓存等第二个因素误认为 VNI 的效果。恢复结果进一步支持了这个故障归因。

让证据对应正在修改的网络层

检查端点底层路由、选中接口、UDP 端口、VNI、远端映射和覆盖地址。条件允许时，在隧道设备及其传输接口分别抓包，两者展示同一次通信的不同表示。保存捕获位置，尤其在解释包大小与校验和提示时，因为这些现象可能受内核卸载处理影响。只保留一张没有接口上下文的抓包截图，容易把观察点差异误判为网络差异。

本例有意通过一千五百与一千四百五十的 MTU 留出封装空间，但只测试短小应用交互。用于较大负载前，需要另外验证实际路径的包大小要求。生产网络还应审阅远端 MAC 目的地如何学习或分发，以及未知目的流量怎样处理。这些控制面选择不能从两个端点通信成功中推导出来，应由对应配置、流量与故障恢复证据单独支持。

来源

RFC 7348 VXLAN，VNI、UDP 封装、MTU 与安全边界，已核验 2026-09-12。
Linux VXLAN documentation，VXLAN 设备、目的端口与隧道卸载，已核验 2026-09-12。
Linux checksum offloads，不同处理阶段的部分校验和与封装校验和，已核验 2026-09-12。

listen backlog 保存等待 accept 的连接

Mon, 25 Oct 2027 00:00:00 +0000

对于 Linux TCP 套接字，listen() 的 backlog 关注已经建立、等待应用接受的连接；未完成握手的队列是另一种概念。调用 accept() 会移出一条待处理连接，并返回供应用使用的已连接套接字。即使这个套接字之后长时间保持打开或忙碌，它也不再占用监听器的 accept 队列。因此，等待接受与已经接受后的活动状态需要分别计数。

坏掉的样子

如果连接到达速度超过应用接受速度，待处理队列会填满。根据内核行为和设置，新客户端可能遇到重传延迟或超时，而已经接受的请求仍可能正常。进程活着，或者部分请求成功，都不能证明监听器正足够快地接受新连接。问题发生在接受之前时，仅查看业务处理成功率可能看不到完整失败路径。

请求的 backlog 还受到 net.core.somaxconn 限制；只把应用值调得更大，不能超过这个上限。但可观察的精确队列边界与实现有关，因此不能把整数直接当成跨平台承诺，认为必定恰好有那么多同时 connect 成功。应测量实际部署内核，而不是把一个很小的实验结果推广成通用的加一或减一规则。

队列计数也需要上下文。ListenOverflows 和 ListenDrops 是网络命名空间计数，不会自动解释到某个具体服务。其他监听器也能贡献计数，客户端超时也可能来自 accept 队列之外。将生产失败归因于某个 backlog 设置，或者宣称扩大队列能修复问题之前，应结合队列占用、接受进度和计数共同判断。

快速验证

把脚本保存为 check-listen-backlog.py，准备宿主 Python、Docker 和固定 Python 镜像后运行。真实套接字操作发生在可丢弃 Linux 容器内，网络只保留回环。记录内核为 6.12.76-linuxkit。脚本读取相关设置但不修改它们，并要求 tcp_abort_on_overflow=0，使本次超时观察对应一个明确、可以检查的前提：

import json,subprocess
image='python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84'
program=r'''
from contextlib import ExitStack
from pathlib import Path
import json,platform,socket
def counters():
 lines=Path('/proc/net/netstat').read_text().splitlines()
 for index,line in enumerate(lines):
 if line.startswith('TcpExt:'):
 return dict(zip(line.split()[1:],map(int,lines[index+1].split()[1:])))
def queued(port):
 for line in Path('/proc/net/tcp').read_text().splitlines()[1:]:
 fields=line.split()
 if fields[3]=='0A' and int(fields[1].split(':')[1],16)==port:
 return int(fields[4].split(':')[1],16)
 raise AssertionError('listener missing')
with ExitStack() as stack:
 def fresh():
 s=stack.enter_context(socket.socket());s.settimeout(.25);return s
 def listener(backlog):
 s=fresh();s.bind(('127.0.0.1',0));s.listen(backlog);return s
 somaxconn=int(Path('/proc/sys/net/core/somaxconn').read_text())
 abort=int(Path('/proc/sys/net/ipv4/tcp_abort_on_overflow').read_text());assert abort==0
 small=listener(1);address=small.getsockname();before=counters();clients=[];timed_out=False
 for _ in range(8):
 client=fresh()
 try:client.connect(address)
 except TimeoutError:timed_out=True;client.close();break
 clients.append(client)
 depth=queued(address[1]);after=counters()
 assert timed_out and depth==len(clients) and 1<=depth<8,(depth,len(clients))
 changes={name:after[name]-before[name] for name in ['ListenOverflows','ListenDrops']}
 assert changes['ListenOverflows']>0 and changes['ListenDrops']>0,changes
 accepted=[]
 for client in clients:
 server,_=small.accept();stack.enter_context(server);accepted.append(server);server.sendall(b'ready')
 reader=stack.enter_context(client.makefile('rb'));assert reader.read(5)==b'ready'
 assert queued(address[1])==0
 for _ in range(4):
 client=fresh();client.connect(address);server,_=small.accept();stack.enter_context(server)
 server.sendall(b'ready');reader=stack.enter_context(client.makefile('rb'));assert reader.read(5)==b'ready'
 accepted.append(server);clients.append(client)
 assert len(accepted)>1 and all(s.fileno()>=0 for s in accepted)
 larger=listener(16)
 for _ in range(6):client=fresh();client.connect(larger.getsockname())
 assert queued(larger.getsockname()[1])==6
 print(json.dumps({'kernel':platform.release(),'somaxconn':somaxconn,'tcp_abort_on_overflow':abort,
 'requested_small_backlog':1,'queued_before_accept':depth,'next_connect_timed_out':timed_out,
 'counter_changes':changes,'accepted_connections_still_open':len(accepted),'larger_backlog_queued':6},sort_keys=True))
'''
result=subprocess.run(['docker','run','--rm','-i','--network','none',image,'python','-'],
 input=program,capture_output=True,text=True,timeout=30)
assert result.returncode==0,result.stderr
record=json.loads(result.stdout);print(json.dumps(record,sort_keys=True))

第一个监听器请求 backlog 为一，并故意不接受连接。在记录环境里，两次客户端 connect 完成，/proc/net/tcp 也报告两条排队连接；下一次 connect 超过客户端设定的二百五十毫秒超时。脚本记录实际深度，而不是断言每个 Linux 版本在这个参数下都必须接受恰好两条。配置参数、实际队列和客户端结果分别被观察。

在这次受控溢出期间，ListenOverflows 和 ListenDrops 各增加一。由于实验有独立网络命名空间，而且只有这些回环监听器，可以把观察与故意暂停接受的监听器关联。示例没有修改全局内核设置，也没有通过改变共享 Docker 虚拟机网络策略来制造失败；归属依据来自隔离范围和明确的连接操作。

随后，应用接受已排队连接，并通过返回的套接字发送短确认。客户端完整读到确认，监听队列下降为零。再建立四条连接并立即接受，同时保持之前接受的套接字打开；最终有六条已接受连接共存，尽管最初请求的 backlog 只有一。这直接区分待接受容量与应用可以同时持有多少条已连接套接字。

第二个监听器请求 backlog 为十六，在任何 accept 发生前，六个客户端完成连接，队列报告六条待处理连接。这说明更大的队列可以吸收本次应用暂停期间的到达突发，却没有证明处理吞吐提高，也没有证明这些客户端已经收到应用响应，更不能据此认为扩大 backlog 就能解决持续过载。

同时调整接受能力与等待容量

记录到的 somaxconn 为 4096，高于两次请求的 backlog。这只是测试环境观察，不是建议复制到另一台主机的调优值。应一起检查应用实际 listen 参数、accept 循环和内核上限。系统上限很高，也不会自动扩大应用明确请求的小 backlog；只改变一侧而不核对另一侧，可能完全没有达到预期容量。

要区分未完成握手与已经建立、等待接受的连接。SYN 队列控制和 SYN-cookie 行为回答的问题，与这里展示的 accept 队列不同。同样，tcp_abort_on_overflow 改变溢出处理方式，开启重置并不增加服务容量。本实验保持它关闭，展示现有策略下客户端看到的超时，而没有把另一种配置行为写成已经实测。

最后，调查接受速度为何落后。事件循环停顿、文件描述符耗尽、分发瓶颈和故意暂停，对 accept 的影响可能不同于已经接受套接字上的慢工作。更大队列只是增加等待空间，需要符合客户端截止时间和内存预算。如果持续到达速度超过服务能接受并处理的速度，增加等待只会推迟容量失败，不会创造持续处理能力。

来源

Linux listen(2)，等待 accept 的已建立连接与 somaxconn 上限，已核验 2026-09-12。
Linux accept(2)，移出待接受连接并返回已连接套接字，已核验 2026-09-12。
Linux IP sysctl documentation，somaxconn、SYN backlog 与 tcp_abort_on_overflow，已核验 2026-09-12。

IPv6 路由器报告超大报文，由源端决定怎样适应路径

Wed, 06 Oct 2027 00:00:00 +0000

IPv6 路由器在向目的地转发报文时，不会替它进行分片。如果报文大于下一条链路所能承载的大小，路由器通常丢弃它，并发送 ICMPv6 Packet Too Big 反馈。源端随后可以调整报文大小，或在适当情况下通过 IPv6 分片扩展头发送分片；这些分片在目的端重组。明确各阶段由谁负责，是判断超大报文故障的基础。

坏掉的样子

假定路由器会自动拆开过大的 IPv6 包，会掩盖与大小相关的故障。相同地址与路由上，小 echo 可以成功，大 echo 却失败。端点本地接口可能支持原始大小，中间链路却不支持。应检查整条路径约束，不能仅因接口配置了 MTU 1500，就推断该大小能够端到端通过，也不能用一次小探测成功替代完整大小检查。

Packet Too Big 反馈缺失，会使经典发现更难学到这个限制。分片被过滤，或者其中一片丢失，也可能阻止正确重组。能够生成分片扩展头，不证明沿途策略都允许相应报文。不能把源端分片当作正确路径大小与必要控制流量的万能替代，它有自己的交付条件，需要通过对应流量验证，而不是只检查发送选项已经开启。

反方向也有自己的路径估计。请求发送端学到 MTU，不会自动教会响应端怎样发送较大回复。因此双向 echo 测试需要分别了解两个方向。TCP 分段还不同于 IP 分片：TCP 发送端学到限制后，可以构造更小的段，而不必把每个 IP 包再分片。应先确定观察的是哪一层的切分，避免看到多个包就统称为分片。

快速验证

将脚本保存为 check-ipv6-fragmentation.py，准备 Docker 后运行 python3 check-ipv6-fragmentation.py。一次性环境使用 Python 3.11.16、iproute2 6.1.0、iputils ping 和 tcpdump 4.99.3，在 Linux 6.12.76 上验证。NET_ADMIN 与 SYS_ADMIN 支持四个嵌套命名空间。两台路由器和两个端点使用新建 veth，不修改宿主接口或路由：

from pathlib import Path
from tempfile import TemporaryDirectory
import subprocess,json,uuid
recipe='FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84\nRUN apt-get update && apt-get install -y --no-install-recommends iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time
def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,process.stderr.read();return value
@contextmanager
def lab():
 with TemporaryDirectory(prefix='mtu-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc));stack.callback(run,'umount',str(proc))
 for name in ['client','r1','r2','target']:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False);ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in ['client','r1','r2','target']
 path=proc/'sys'/key.replace('.','/')
 ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r});p.write_text({str(value)!r});assert p.read_text().strip()=={str(value)!r}')
 yield root,stack,setting
def topology(setting,ipv6=False):
 links=[('client','c0','r1','a0',1,2,1,1500),('r1','a1','r2','b0',2,1,2,1280),('r2','b1','target','t0',3,1,2,1500)]
 for left,left_if,right,right_if,network,left_host,right_host,mtu in links:
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,host in [(left,left_if,left_host),(right,right_if,right_host)]:
 run('ip','link','set',interface,'netns',name);ip(name,'link','set',interface,'mtu',str(mtu))
 address=f'2001:db8:{network}::{host}/64' if ipv6 else f'10.210.{network}.{host}/30'
 ip(name,'addr','add',address,'dev',interface,*(['nodad'] if ipv6 else []));ip(name,'link','set',interface,'up')
 family='-6' if ipv6 else '-4'
 for name in ['r1','r2']:setting(name,'net.ipv6.conf.all.forwarding' if ipv6 else 'net.ipv4.ip_forward',1)
 routes=[('client','default','2001:db8:1::1' if ipv6 else '10.210.1.1'),('target','default','2001:db8:3::1' if ipv6 else '10.210.3.1'),
 ('r1','2001:db8:3::/64' if ipv6 else '10.210.3.0/30','2001:db8:2::2' if ipv6 else '10.210.2.2'),
 ('r2','2001:db8:1::/64' if ipv6 else '10.210.1.0/30','2001:db8:2::1' if ipv6 else '10.210.2.1')]
 for name,destination,gateway in routes:ip(name,family,'route','add',destination,'via',gateway)
 if ipv6:
 deadline=time.monotonic()+4
 while any('tentative' in ip(name,'-6','address','show').stdout for name in ['client','r1','r2','target']):
 assert time.monotonic()<deadline,'IPv6 link-local DAD did not finish';time.sleep(.02)
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 result={}
 for item in json.loads(ns(name,'nft','-j','list','ruleset').stdout)['nftables']:
 rule=item.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:result[rule['comment']]=expression['counter']['packets']
 return result
def capture(stack,root,name,interface,expression,label):
 path=root/(label+'.pcap')
 process=subprocess.Popen(['ip','netns','exec',name,'tcpdump','--immediate-mode','-Z','root','-U','-n','-i',interface,'-w',str(path),expression],stdout=subprocess.DEVNULL,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);deadline=time.monotonic()+3
 while time.monotonic()<deadline:
 assert process.poll() is None,'capture exited'
 if select.select([process.stderr],[],[],.1)[0] and 'listening on' in process.stderr.readline():return process,path
 raise AssertionError('capture did not become ready')
def captured(process,path):
 process.send_signal(signal.SIGINT);_,diagnostic=process.communicate(timeout=3);assert process.returncode==0,diagnostic
 return run('tcpdump','-nn','-vv','-r',str(path)).stdout

with lab() as (root,stack,setting):
 topology(setting,ipv6=True);target='2001:db8:3::2'
 small=ns('client','ping','-6','-n','-c','1','-W','1','-s','32',target);assert small.returncode==0
 tap,path=capture(stack,root,'client','c0','ip6','too-big')
 large=ns('client','ping','-6','-n','-M','do','-s','1400','-c','1','-W','1',target,check=False)
 feedback=captured(tap,path);assert large.returncode!=0 and 'too big' in feedback.lower(),(large.stdout,large.stderr,feedback)
 route=ip('client','-6','route','get',target).stdout;assert 'mtu 1280' in route,route
 reverse=ns('target','ping','-6','-n','-M','do','-s','1400','-c','1','-W','1','2001:db8:1::2',check=False)
 reverse_route=ip('target','-6','route','get','2001:db8:1::2').stdout
 assert reverse.returncode!=0 and 'mtu 1280' in reverse_route,(reverse.stdout,reverse.stderr,reverse_route)
 tap,path=capture(stack,root,'client','c0','ip6 and src 2001:db8:1::2','source-fragments')
 fragmented=ns('client','ping','-6','-n','-M','dont','-s','2000','-c','1','-W','2',target,check=False)
 trace=captured(tap,path);assert fragmented.returncode==0,(fragmented.stdout,fragmented.stderr,trace)
 assert 'frag (' in trace and trace.count('frag (')>=2,trace
 refused=ns('client','ping','-6','-n','-M','do','-s','2000','-c','1','-W','1',target,check=False)
 assert refused.returncode!=0 and 'too long' in (refused.stdout+refused.stderr).lower(),(refused.stdout,refused.stderr)
 print(json.dumps({'small_echo':small.stdout,'oversize_before_learning':{'stdout':large.stdout,'stderr':large.stderr,'returncode':large.returncode},
 'packet_too_big_capture':feedback,'learned_route':route,'reverse_path_learning':reverse.stdout+reverse.stderr,'reverse_route':reverse_route,'source_fragmented_echo':fragmented.stdout,
 'source_side_fragment_capture':trace,'dont_fragment_after_learning':{'returncode':refused.returncode,'stdout':refused.stdout,'stderr':refused.stderr}}))
"""
name='xbcatm-mtupath-'+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)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN','--memory','256m','--pids-limit','128',name,'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)

端点链路 MTU 为 1500，中间路由器链路为 1280。静态全局地址使用 nodad，设置过程同时明确等待自动生成的链路本地地址离开 tentative 状态。这个就绪检查避免把最初地址设置延迟误判成转发或 MTU 故障。实验没有声称验证重复地址检测算法本身，只是把网络准备完成作为后续比较的前置条件。

小 echo 往返首先成功。随后使用 do 策略发送 1400 字节 echo 载荷，加上基础 IPv6 与 ICMPv6 头后，形成 1448 字节报文。它适合源端接口，却超过中间链路。捕获显示原始请求和路由器返回的 Packet Too Big，报告 MTU 1280；客户端路由查询随后记录该值。这样能区分源端本来就拒绝发送，与中间路径发现更小限制。

目标向客户端发送对应的超大探测，也为反向路径学到 MTU 1280。这一步明确准备较大 echo 回复，不假定一个端点的缓存同时覆盖两个方向。两个失败发现探测都保留在输出中，包含路由器反馈和路由状态，让后续成功所依赖的设置可见。请求方向已经正确，不代表响应方向无需独立检查。

客户端接着用 dont 策略发送 2000 字节 echo 载荷，允许根据已知上限在源端分片。抓包位于客户端接口，并限定客户端源地址，在两台路由器处理之前，就看到了标识相同的两个分片。工具显示数据偏移为零和 1232 字节，分片数据长度合计 2008，包含 ICMPv6 头。这直接证明分片已由发送端产生，而非后来由路由器拆开。

目的端重组并完成大小正确的返回交换后，echo 成功。用 do 策略重复相同载荷，则得到本地 message-too-long 错误与 MTU 1280。结果区分了路由器报告此前未知瓶颈、发现后源端主动分片，以及已知较小上限后的本地拒绝。这些是不同失败和交付阶段，不应全都写成同一种“包太大所以网络不通”。

来源

RFC 8200 IPv6，源端分片、分片扩展头与目的端重组，已核验 2026-09-12。
RFC 8201 IPv6 Path MTU Discovery，Packet Too Big 反馈与各方向路径估计，已核验 2026-09-12。
Linux ping(8)，载荷大小与 do/dont 路径 MTU 策略，已核验 2026-09-12。

TCP 保活探测空闲连接

Tue, 05 Oct 2027 00:00:00 +0000

TCP keepalive 询问的是：连接安静了一段时间后，对面的 TCP 端点是否仍然响应。它不询问 HTTP handler 是否正常、数据库查询是否推进、后台工作线程是否卡住。即使应用已经停顿，内核仍然可能确认收到的数据。因此，“传输对端能够回应”和“应用给出了有用结果”必须作为两个不同的观察项。

传输层探针不是应用心跳

保活有助于暴露远端连接状态已经消失，或者网络路径悄悄停止传递报文的情况。实现会在满足空闲条件后发送探针，并按照未响应探针的策略最终报告失败；但单个探针丢失不等于对端死亡，不能把网络中的临时丢包直接解释成确定性故障。

探针在应用字节流以下处理，不会变成 HTTP 请求、数据库查询或 WebSocket 心跳。如果连接终止在代理上，探测对象就是代理自身的 TCP 端点，不是代理后面的源站。某些中间设备的连接跟踪可能受探针影响，但不能由此承诺刷新应用的空闲计时，更不能保证所有 NAT 映射都会一直保留。

已经发出而尚未确认的数据还有自己的重传与失败规则，因此保活参数不是繁忙连接的通用总截止时间。正常 FIN、连接重置、应用读取超时和静默丢包是不同事件，恢复动作也未必相同。知道是哪一层报告了什么错误，比统一把它们写成“连接死了”更有用。

配置真正承载请求的 socket

RFC 1122 对可选保活机制要求默认关闭，并规定默认空闲间隔不得短于两小时且应可配置。但应用和库可以显式启用并选择更短间隔，Go 的拨号器就有自己的设置。因此，查到操作系统默认值，并不能直接推出当前应用实际使用的策略；还需要沿着创建连接的代码检查有效配置。

Linux 的 tcp_keepalive_time、tcp_keepalive_intvl 和 tcp_keepalive_probes 分别表示探测前的空闲秒数、探针间隔和未响应探针数量，文档默认值为 7200、75、9。启用 SO_KEEPALIVE 后，还可以通过 TCP_KEEPIDLE、TCP_KEEPINTVL、TCP_KEEPCNT 为单个 socket 定制策略。这些名称与接口不是 macOS、Windows 通用的系统参数，不能跨平台照搬命令。

应根据期望发现故障的时间、连接规模、短暂丢包容忍度以及中间设备策略选择间隔。把空闲时间加上探针预算，只能得到条件性的估算，不是硬实时承诺。优先限定到目标连接，避免为了一个服务修改影响其他进程的全局默认值；同时检查设置操作是否成功，并确认 socket 上实际启用了保活。

坏掉的样子

只配置 keepalive、没有应用读取期限，请求仍可能长时间等不到业务回复。反过来，应用读取期限已到，也不代表 TCP 连接必然失效，更不能据此证明对端进程死亡。本地超时后贸然重发写操作，可能重复执行对端已经收到的任务。

代理更短的空闲超时仍可能先关闭连接，端点设置了保活也不能替代代理的业务策略。在大量连接上使用过于频繁的探针，还会增加网络流量和耗电。修改参数前，应定位实际终止连接的那一跳，以及触发恢复的具体错误信号，不要同时修改三个计时参数后仅凭“看起来好些了”判断原因。

快速验证

将代码保存为 keepalive_probe.go，在 macOS 或 Linux 上用 Go 1.23 或更新版本执行 go run keepalive_probe.go。读取 SO_KEEPALIVE 的部分使用 Unix socket 接口，因此这份原样代码不是 Windows 操作配方。它只创建回环连接，不修改 sysctl、防火墙或共享服务。

package main

import (
 "errors"
 "fmt"
 "io"
 "net"
 "os"
 "runtime"
 "syscall"
 "time"
)

func must(err error) {
 if err != nil {
 panic(err)
 }
}

func check(ok bool, message string) {
 if !ok {
 panic(message)
 }
}

func keepalive(connection *net.TCPConn) int {
 raw, err := connection.SyscallConn()
 must(err)
 var value int
 var optionError error
 must(raw.Control(func(fd uintptr) {
 value, optionError = syscall.GetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_KEEPALIVE)
 }))
 must(optionError)
 return value
}

func main() {
 listener, err := net.ListenTCP("tcp4", &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1)})
 must(err)
 defer listener.Close()
 must(listener.SetDeadline(time.Now().Add(2 * time.Second)))
 dialer := net.Dialer{Timeout: 2 * time.Second, KeepAlive: -1}
 connection, err := dialer.Dial("tcp4", listener.Addr().String())
 must(err)
 client := connection.(*net.TCPConn)
 defer client.Close()
 peer, err := listener.AcceptTCP()
 must(err)
 defer peer.Close()

 check(keepalive(client) == 0, "keepalive must start disabled")
 must(client.SetKeepAliveConfig(net.KeepAliveConfig{
 Enable: true, Idle: 30 * time.Second,
 Interval: 10 * time.Second, Count: 3,
 }))
 enabled := keepalive(client)
 check(enabled != 0, "SO_KEEPALIVE must be enabled")
 fmt.Printf("SO_KEEPALIVE: 0 -> %d (enabled); per-socket configuration accepted\n", enabled)

 must(client.SetWriteDeadline(time.Now().Add(2 * time.Second)))
 n, err := client.Write([]byte("ping"))
 must(err)
 check(n == 4, "request must be fully written")
 must(client.SetReadDeadline(time.Now().Add(200 * time.Millisecond)))
 reply := make([]byte, 4)
 n, err = client.Read(reply)
 check(n == 0 && errors.Is(err, os.ErrDeadlineExceeded), "silent application must reach read deadline")
 fmt.Println("read deadline fired while the peer application was silent")

 must(peer.SetDeadline(time.Now().Add(2 * time.Second)))
 request := make([]byte, 4)
 _, err = io.ReadFull(peer, request)
 must(err)
 check(string(request) == "ping", "the original request is still queued")
 n, err = peer.Write([]byte("pong"))
 must(err)
 check(n == 4, "reply must be fully written")
 must(client.SetReadDeadline(time.Now().Add(2 * time.Second)))
 _, err = io.ReadFull(client, reply)
 must(err)
 check(string(reply) == "pong", "same connection must deliver the reply")
 fmt.Println("after resetting the read deadline, the original connection returns pong")
 fmt.Println(runtime.Version(), runtime.GOOS)
}

拨号器先明确禁用保活，再使用单连接配置启用它。getsockopt 返回的启用标志必须是非零，但不保证恰好等于一；已核验的 macOS、Go 1.27.0 环境返回八。对端应用刻意不读取已经发送的四字节请求，客户端在二百毫秒的读取期限到达后得到超时错误，而不是收到业务数据。

之后，对端读取原来排队的 ping，并写回 pong。客户端重新设置读取截止时间，就能在同一条连接上收到回复，期间没有重新建连，也没有重发请求。这个现象说明超时只限制了本地等待，并没有撤回已进入字节流的数据，更没有自动取消远端工作。是否继续使用连接和如何恢复业务，需要由上层协议决定。

全部断言已经通过。这个短实验验证的是 socket 配置与应用读取期限，不是保活探针的真实发送时序：配置的首次探测空闲间隔是三十秒。它没有注入丢包，也没有测量经过 NAT 后的故障发现时间。验证那些能力，需要另行安排受控网络实验，保留报文证据，并检查报告故障之后的资源释放与安全恢复行为。

来源

RFC 1122：互联网主机要求，第 4.2.3.6 节：可选保活、空闲条件与探针丢失，已核验 2026-09-09。
Linux tcp(7)，保活默认值、socket 选项与更短的中间设备超时，已核验 2026-09-09。
Go net，KeepAliveConfig、socket 配置与截止时间语义，已核验 2026-09-09。

默认路由匹配最宽范围，不会挽救所有失败路径

Tue, 14 Sep 2027 00:00:00 +0000

IPv4 默认路由是前缀 0.0.0.0/0，匹配所有 IPv4 目的地，但具体程度最低。在已经选择的路由表中，更长的匹配前缀通常优先。默认路由不是一个“其他具体路径失败后再重试”的过程。路由策略决定相关表，最终路由描述怎样转发，而不保证完整往返一定成功。匹配范围与路径健康是两类不同属性。

坏掉的样子

没有默认路由的机器，仍能访问直连或明确路由覆盖的目的地；反过来，添加默认路由也不证明能够访问互联网。下一跳需要可达，转发与过滤要允许流量，回复还需要返回路径。显示一个网关，只满足契约的一部分。真正配置是否共同工作，应由实际应用通信证明，而不是从路由文件中有一行 default 就推导全部能力。

更具体的拒绝路由会胜过可工作的默认路由。Linux 的 unreachable 等路由类型，会有意停止匹配目的地的转发。选定网关的邻居查询失败，也不意味着内核自动寻找更健康、却更宽泛的路径。静态路由优先级和 metric 不是服务健康监控或自动故障转移机制，不能把配置顺序当成逐个尝试可用出口的流程。

返回路径错误尤其容易误导。客户端选中预期网关并把流量送往监听中的服务器，服务器却可能无法把回复路由回客户端。反复修改客户端默认路由，可能破坏其他正常目的地，却没有修复缺失的反向路径。将所有连接超时归因于发送方网关之前，应查看两个方向和真实源地址。请求能到与响应能回，需要分别成立。

快速验证

将脚本保存为 check-default-route.py，准备 Docker 后运行 python3 check-default-route.py。Python 3.11.16 和 iproute2 6.1.0 在一次性 Linux 容器内建立客户端、路由器、目标拓扑。NET_ADMIN 与 SYS_ADMIN 支持嵌套命名空间和临时 proc 挂载。接口全是新建 veth，不向宿主发布端口或路由，也不修改现有网络设备：

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 iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time

def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,'child exited without a response'
 return value
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
@contextmanager
def lab(names):
 with TemporaryDirectory(prefix='net-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc))
 stack.callback(run,'umount',str(proc))
 for name in names:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False)
 ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in names
 path=proc/'sys'/key.replace('.','/')
 return ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r}); p.write_text({str(value)!r}); print(p.read_text().strip())').stdout.strip()
 yield root,stack,setting
def wire(left,left_if,right,right_if,left_addresses,right_addresses):
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,addresses in [(left,left_if,left_addresses),(right,right_if,right_addresses)]:
 run('ip','link','set',interface,'netns',name)
 for address in addresses:ip(name,'address','add',address,'dev',interface,*(['nodad'] if ':' in address else []))
 ip(name,'link','set',interface,'up')
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 data=json.loads(ns(name,'nft','-j','list','ruleset').stdout);found={}
 for entry in data['nftables']:
 rule=entry.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:found[rule['comment']]=expression['counter']['packets']
 return found

def server(stack,name,address,port=18080,label='server'):
 code=r'''
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
import json,socket,sys
address,port,label=sys.argv[1],int(sys.argv[2]),sys.argv[3]
class Handler(BaseHTTPRequestHandler):
 def do_GET(self):
 body=json.dumps({'server':label,'peer':self.client_address,'path':self.path}).encode()
 self.send_response(200);self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
 def log_message(self,*args):pass
class Server(ThreadingHTTPServer):
 address_family=socket.AF_INET6 if ':' in address else socket.AF_INET
 def server_bind(self):
 if self.address_family==socket.AF_INET6:self.socket.setsockopt(socket.IPPROTO_IPV6,socket.IPV6_V6ONLY,1)
 super().server_bind()
service=Server((address,port),Handler);print('ready',flush=True);service.serve_forever()
'''
 process=spawn(stack,['ip','netns','exec',name,'python3','-u','-c',code,address,str(port),label])
 assert line(process).strip()=='ready';return process
def request(name,address,port=18080):
 code=r'''
import http.client,json,sys
client=http.client.HTTPConnection(sys.argv[1],int(sys.argv[2]),timeout=.7)
try:
 client.request('GET','/lab-visible-message');response=client.getresponse();body=json.loads(response.read())
 assert response.status==200;print(json.dumps({'ok':True,'status':response.status,'body':body}))
except OSError as error:print(json.dumps({'ok':False,'type':type(error).__name__,'errno':error.errno}))
finally:client.close()
'''
 return json.loads(ns(name,'python3','-c',code,address,str(port)).stdout)

def routed(setting):
 wire('client','c0','router','r0',['10.201.1.2/30'],['10.201.1.1/30'])
 wire('router','r1','target','t0',['10.201.2.1/30'],['10.201.2.2/30'])
 setting('router','net.ipv4.ip_forward',1)
 ip('client','route','add','default','via','10.201.1.1')
 ip('target','route','add','default','via','10.201.2.1')
with lab(['client','router','target']) as (root,stack,setting):
 routed(setting);ip('client','route','delete','default')
 ip('target','addr','add','198.51.100.9/32','dev','lo');ip('router','route','add','198.51.100.9/32','via','10.201.2.2')
 daemon=server(stack,'target','198.51.100.9')
 connected=ns('client','ping','-n','-c','1','-W','1','10.201.1.1');assert connected.returncode==0
 missing=request('client','198.51.100.9');assert not missing['ok'] and missing['errno']==101
 ip('client','route','add','default','via','10.201.1.1')
 chosen=json.loads(ip('client','-j','route','get','198.51.100.9').stdout)[0];assert chosen['gateway']=='10.201.1.1'
 healthy=request('client','198.51.100.9');assert healthy['ok']
 ip('client','route','add','unreachable','198.51.100.9/32')
 specific=request('client','198.51.100.9');assert not specific['ok'] and specific['errno']==113
 ip('client','route','delete','unreachable','198.51.100.9/32')
 recovered=request('client','198.51.100.9');assert recovered['ok']
 ip('target','route','delete','default')
 bad_return=request('client','198.51.100.9');assert not bad_return['ok'] and bad_return['type']=='TimeoutError'
 assert json.loads(ip('client','-j','route','get','198.51.100.9').stdout)[0]['gateway']=='10.201.1.1'
 ip('target','route','add','default','via','10.201.2.1')
 final=request('client','198.51.100.9');assert final['ok']
 print(json.dumps({'connected_ping_without_default':0,'no_default':missing,'chosen_route':chosen,'with_default':healthy,
 'specific_unreachable_route':specific,'specific_removed':recovered,'missing_return_route':bad_return,'return_route_restored':final}))
"""
name='xbcatm-netpath-'+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)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN',
 '--memory','256m','--pids-limit','128',name,'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)

客户端使用 10.201.1.2，路由邻居为 10.201.1.1。目标位于路由器后的另一条链路，在回环接口拥有服务地址 198.51.100.9。路由器有到该服务的具体路由，目标起初具有返回默认路由。文档保留地址仅用于隔离拓扑，没有联系公网服务器。每项地址和下一跳都在脚本中明确配置，避免依赖宿主偶然存在的路由。

删除客户端默认路由后，ping 直连路由邻居仍成功，而连接远端 HTTP 服务得到 Linux ENETUNREACH，错误号一百零一。添加经 10.201.1.1 的默认路由后，查询选择该网关，真实 HTTP 请求返回状态二百。这同时说明原先已经存在的较窄连接能力，以及默认路由新增的路径，不能把“没有默认路由”统称为完全没有网络。

随后为 198.51.100.9 安装 unreachable /32 路由。默认路由仍在，相同连接却得到 EHOSTUNREACH，错误号一百一十三。删除具体路由后，HTTP 恢复。内核遵守更具体的拒绝指令，没有把错误当成改走默认网关的理由。这个对照直接纠正了“先尝试具体路由，失败再尝试默认”的错误理解。

接着脚本只移除目标服务器的默认路由。客户端查询仍指向 10.201.1.1，新 HTTP 请求却等待到超时；恢复目标默认路由后通信恢复。受控比较在客户端选择不变时隔离了返回路径依赖，比单侧路由列表或一次原因不明的 ping 失败更有说服力。修复对象由被改变的条件和恢复结果共同确定。

编辑默认路由前检查具体流量

记录源地址、目的地、相关策略规则、选中接口和网关。多接口或多路由表机器，可能根据来源、标记或路由域作出不同决策。诊断查询应采用应用相关输入。本例使用普通按目的地选路，没有声称重现每一种策略路由或多路径配置。命令输出只有连同查询条件一起保存，才适合与真实故障进行比较。

检查下一跳链路可达性、路由器转发决策，以及目标到真实来源的返回路由。NAT 或代理可能改变目标所看到的源地址。错误类型也能辅助定位：立即发生的本地网络不可达、明确主机拒绝路由，以及等待回复直至截止时间，是不同情况。事件证据应保留这些区别，避免把具有不同修复方式的现象压成同一个“网络不通”。

默认路由的价值，是概括主机无须逐一掌握的目的地。应有意配置它，验证例外，并在变更后测试代表性的完整往返。如果要求自动故障转移，需要有机制观察相关路径并适当更新路由。第二个网关条目或更优 metric 本身，不能证明已经具有这种行为。配置能够表达偏好，健康判断和动态切换还需要对应实现与证据。

来源

Linux ip-route(8)，默认路由、选路查询与 unreachable 路由类型，已核验 2026-09-12。
RFC 4632 CIDR，最长前缀匹配与具体路由优先，已核验 2026-09-12。
RFC 1812 IPv4 router requirements，IPv4 转发与目的地可达性，已核验 2026-09-12。

子网前缀影响直连路由，最终路径由路由表选择

Mon, 13 Sep 2027 00:00:00 +0000

IPv4 前缀长度表示地址中有多少前导位标识网络。对于 192.0.2.5/24，网段是 192.0.2.0/24，普通广播地址是 192.0.2.255。配置接口通常会建立相应直连路由，但前缀不是完整路由算法。内核还要依据路由策略与路由表，为具体目的地选择路径，不能只看地址是否位于某个网段就推断全部行为。

坏掉的样子

前缀太短，会让主机把原本远端的目的地当成直接相连。保留地址 192.0.2.5，却把 /24 改成 /16，就把 192.0.3.9 纳入直连范围。在真实以太网中，这种错误可能让主机尝试解析一个根本不在当前链路上的邻居。于是地址看起来正确，下一跳决策却已经改变；反复核对地址字符串本身无法发现问题。

“不在自己的子网就走默认网关”也不完整。更具体的路由可以选择其他网关或接口；在已经选择的路由表内，更长的匹配前缀优先。明确的主机路由甚至可以覆盖本来位于接口子网内的目的地。应检查实际查询结果，而不是仅凭接口地址重新猜测内核会怎么做。默认路由只处理没有更具体匹配的相应流量。

地址数量计算也需要上下文。普通 /24 的网络地址与定向广播地址通常不用于主机分配，但“减二”不是统一公式。RFC 3021 允许点到点 /31 链路的两个地址都用作端点，/32 则标识单个地址。这些规则解释地址语义，没有证明配置中的两端能够通过当前物理拓扑交换数据。可用地址集合和实际通信仍须区分。

快速验证

将脚本保存为 check-subnet.py，准备 Docker 后执行 python3 check-subnet.py。程序给固定 Python 镜像安装 iproute2 6.1.0，再只向一次性容器授予 NET_ADMIN；容器没有外部网络接入。脚本创建虚拟 dummy 接口并修改该容器的路由，不改变宿主接口、路由或生产网关。构建下载与运行时路由实验也处于不同阶段：

from pathlib import Path
from tempfile import TemporaryDirectory
import json,subprocess,uuid

recipe='''FROM python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84
RUN apt-get update && apt-get install -y --no-install-recommends iproute2=6.1.0-3 && rm -rf /var/lib/apt/lists/*
'''
program=r'''
from ipaddress import IPv4Address,IPv4Interface,IPv4Network
import json,subprocess
def ip(*args):
 result=subprocess.run(['ip',*args],capture_output=True,text=True,timeout=3)
 assert result.returncode==0,result.stderr
 return result.stdout
def route(address):return json.loads(ip('-j','route','get',address))[0]
interface=IPv4Interface('192.0.2.5/24');network=interface.network
assert str(network.network_address)=='192.0.2.0' and str(network.broadcast_address)=='192.0.2.255'
assert IPv4Address('192.0.2.77') in network and IPv4Address('192.0.3.9') not in network
try:IPv4Network('192.0.2.5/24');raise AssertionError('host bits accepted in strict network')
except ValueError:strict_rejected=True
point_to_point=[str(a) for a in IPv4Network('192.0.2.0/31').hosts()]
assert point_to_point==['192.0.2.0','192.0.2.1']
ip('link','add','lab0','type','dummy');ip('link','set','lab0','up')
ip('address','add','192.0.2.5/24','dev','lab0');ip('route','add','default','via','192.0.2.1','dev','lab0')
ip('route','add','203.0.113.0/24','via','192.0.2.2','dev','lab0')
direct=route('192.0.2.77');specific=route('203.0.113.9');default=route('198.51.100.9');before=route('192.0.3.9')
assert direct['dev']=='lab0' and 'gateway' not in direct
assert specific['gateway']=='192.0.2.2' and default['gateway']==before['gateway']=='192.0.2.1'
ip('route','add','192.0.2.77/32','via','192.0.2.1','dev','lab0');overridden=route('192.0.2.77')
assert overridden['gateway']=='192.0.2.1'
ip('address','del','192.0.2.5/24','dev','lab0');ip('address','add','192.0.2.5/16','dev','lab0')
ip('route','replace','default','via','192.0.2.1','dev','lab0');wrong=route('192.0.3.9')
assert wrong['dev']=='lab0' and 'gateway' not in wrong
print(json.dumps({'interface':str(interface),'network':str(network),'broadcast':str(network.broadcast_address),
 'strict_host_bits_rejected':strict_rejected,'point_to_point_31_hosts':point_to_point,
 'connected':direct,'more_specific_route':specific,'default':default,'host_route_overrides_subnet':overridden,
 'destination_before_widening':before,'destination_after_wrong_16':wrong,'iproute_version':ip('-V').strip()}))
'''
name='xbcatm-subnet-'+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)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN',
 '--memory','128m','--pids-limit','64',name,'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 区分接口 192.0.2.5/24 与其网段 192.0.2.0/24。严格网络解析拒绝前者，因为主机位非零；/31 示例则列出 192.0.2.0 和 192.0.2.1 两个可用端点。这个计算确认地址集合，实验没有配置可工作的点到点链路，也没有测试这两个地址之间的转发。不能把库返回两个值，写成真实链路已经验证成功。

dummy 接口配置 192.0.2.5/24，默认路由经过 192.0.2.1；203.0.113.0/24 的具体路由经过 192.0.2.2。真实 ip route get 对 192.0.2.77 不选择网关，对 203.0.113.9 选择后者，对 198.51.100.9 选择默认网关。输出同时记录接口和首选源地址，让下一跳选择可以与本机发送身份一起检查。

添加经过 192.0.2.1 的 192.0.2.77/32 路由后，目标虽然仍属于直连 /24，查询却转而选择网关。这一受控覆盖说明子网归属与最终路由决策必须分开。选中的路由表对这个单独地址具有更具体指令，并不需要为了表达例外而更换接口地址。直接把“同网段”当成永远不经网关，会遗漏这种合法配置。

扩大前缀前，192.0.3.9 使用默认网关；保留 192.0.2.5、将 /24 替换为 /16 后，查询直接选择 dummy 接口，不再包含网关。脚本断言真实内核决策发生改变，没有声称成功交付数据、观察到 ARP 失败，或者虚拟接口之外存在可工作的路由器。实验验证选择逻辑，链路通信需要另外的环境和证据。

修改掩码前先检查真实路由

检查生效的地址与前缀、相关策略规则，以及失败目的地的路由查询。多接口系统重现路径时，还应包含预期源地址和其他策略输入。存在来源路由、标记或不同路由域时，仅按目的地查询可能不同于应用实际路径。应保留诊断上下文，不能拿另一个进程或另一种来源条件下的结果覆盖真实调用方。

在以太网中，区分解析目标自身的链路地址，还是解析选中网关的链路地址。网关需要符合配置的链路和路由规则，路由文件里出现一个看起来合理的数字还不够。确认选路之后，再比较邻居状态与真实报文交付。显示下一跳只说明计划怎样发送，不能证明下一跳已经收到、转发或允许该应用流量。

规划前缀变更时，应一起检查它将创建或移除的直连路由及受影响目的地。变更后验证代表性的本地、具体路由和默认路由流量。掩码是路由与地址解释的一项输入，不是独立可达性承诺。这个区别既能解释意外扩大链路范围，也能解释更具体路由有意建立的例外，而不把正常路径选择误判成地址配置错误。

来源

RFC 4632 CIDR，无类别前缀与最长匹配转发，已核验 2026-09-12。
RFC 3021 point-to-point /31 links，点到点 /31 链路两端地址的使用，已核验 2026-09-12。
Linux ip-route(8)，路由查询、下一跳及明确主机路由，已核验 2026-09-12。
Python 3.11 ipaddress，接口、网段及主机地址的区分，已核验 2026-09-12。

BGP 组成了互联网的路由表

Sun, 12 Sep 2027 00:00:00 +0000

BGP 是唯一把几万个各自独立运营的网络缝成一张转发表的协议。它承载可达性，但它真正承载的是策略：每个网络说明自己起源哪些前缀、从哪个邻居学到它们，以及通过过滤器说明自己愿意把哪些继续传下去。

代价是这张表建立在彼此之间没有合同的信任之上。通告在扩散之前不会被任何东西校验，所以一处笔误或一条配错的过滤器，几分钟内就是全球性的，而且要等到有人注意到才会消失。

AS 路径同时是环路检测和策略信号

在出方向，eBGP 发言者会把自己的 AS 号前插，收到更新的一方如果发现 AS_PATH 里已经有自己的 AS 就直接丢弃。这就是环路防护的全部机制，也是路由绕成一圈后无法被重新引入的原因。iBGP 不做前插，所以一条 iBGP 学到的路由带着与把它带进本 AS 的那条 eBGP 路由相同的 AS_PATH；也正因如此，一个 AS 需要 iBGP 全互联或路由反射器才能把路由分发下去。

同一个字段还兼着另外两份工作。运营商用它做过滤——拒绝任何包含某个对等体 AS 的路径，只接受路径末端是客户 AS 的路由——而路径选择则比较它的长度。一个字段，三份职责，而且互相冲突：为了让一条路径显得不吸引人而做前插，同时也会让它看起来像是过滤器本该拒绝的路由。所以前插这类手段通常只在自家门口有效，一旦越过别人的过滤器边界就会失效。

为什么这张表大约是一百万条前缀

真实数字，取自本文核验时抓取的 CIDR Report 快照：IPv4 前缀 1,080,189 条；把能聚合的都塌缩掉则是 597,258 条。仅 Amazon 一家就起源 18,025 条前缀，其中 15,759 条是更大块的更具体前缀。整张表里大约有一半，是已经被通告过的地址空间上再切出来的更具体前缀。

这是策略的产物，不是拓扑的产物。多宿主为每个上游切一条更具体前缀，流量工程为每条路径切一条，一个想自己决定路由的客户再切一条。聚合本可以把表砍掉一半，而没人这么做，因为每一条更具体前缀都在干活。

路径选择是一个固定顺序，不是距离

BGP 沿着一条列表往下走，在第一个能分出胜负的步骤停下：weight 最高、local preference 最高、本地起源、AS 路径最短、origin 类型最低、MED 最低、eBGP 优先于 iBGP、到下一跳的 IGP 开销最低、router ID 最小。其中 weight 和 local preference 只属于单台路由器或单个 AS，永远不会写进更新里传出去。

把这条顺序跑在同一前缀的四条候选路径上：胜负停在 weight，因为 100 比 0 大，后面的字段根本没被读。把 weight 抹平，胜负移到 local preference；再把 local preference 也抹平，胜负移到 AS 路径长度——两跳的路径胜过三跳的。最短路径是九步里的第四步，所以「BGP 选最短路由」这句话没有任何实际信息量。另外，MED 只在来自同一个邻居 AS 的路径之间比较，跨邻居比 MED 是无效的——这也是它在决策顺序里排在 AS 路径长度之后的原因。

坏掉的样子

最经典的故障形态，是一条泄漏出去的更具体前缀把流量劫走。一个无关的 AS 在别人的 198.51.100.0/24 里起源了 198.51.100.128/25，最长前缀匹配就把受害者地址空间的一半——256 个地址里的 128 个——交给了它：没有撤回、没有报错，合法的 /24 依旧躺在每一张表里。它的表象是部分不可达，以及流量出现在意料之外的地方，也正是 RFC 7908 描述的那种形态。RPKI 起源校验是缓解手段，但它只回答「这个 AS 是否有权起源这个前缀」；ROA 的 maxLength 必须覆盖到那条更具体前缀，而且一条伪造的 AS 路径只要 origin 合法，照样能通过校验。

第二种失败是这张表长得比硬件还快。一台拥有 1,000,000 条 IPv4 FIB 表项的设备，离今天的表规模已经差 80,189 条；1,200,000 条才装得下。FIB 装满时，路由器会保持会话不断，却停止安装路由——一部分前缀转去软件转发，一部分被丢掉，而影响面是：BGP 看起来完全健康，无关的目的地却不通了。

快速验证

确认路由器对某条前缀到底信的是什么：

show bgp ipv4 unicast summary
show bgp ipv4 unicast 198.51.100.0/24
show bgp ipv4 unicast 198.51.100.0/24 longer-prefixes
show ip route 198.51.100.200

第一条打出前缀总数，这是你发现某个对等体往你这里倒路由的方式。第二、三条合起来看是否存在更具体前缀、以及它是谁起源的——一条你不认识的 /25 就是整起事件。第四条是转发引擎实际得出的结论；如果它和前三步的预期不一致，劫持已经在生效了。

来源

RFC 4271 BGP-4，决策过程与 AS 路径环路检测，已核验 2026-09-16。
RFC 6811 前缀起源校验，RPKI 校验能证明什么、不能证明什么，已核验 2026-09-16。
RFC 7908 路由泄漏，泄漏通告的问题陈述，已核验 2026-09-16。
CIDR Report，当前 IPv4 表规模与各 AS 的更具体前缀数量，已核验 2026-09-16。

TCP 握手建立序列号空间，不是同步两台机器的时钟

Fri, 10 Sep 2027 00:00:00 +0000

TCP 三次握手建立字节流的两个方向。每端提供自己的初始序列号，并确认另一端的序列号。这是两个独立序列空间，不是共享墙上时钟；应用建立连接不需要两台机器时钟同步。之后的序列号用于标识字节，支持连接内部的排序、重复处理、确认和重传。把序列号与时间混为一谈，会误解握手真正建立的协议状态。

坏掉的样子

客户端发送带初始序列号的 SYN，服务器回复 SYN-ACK，给出自己的初始序列号并确认客户端 SYN，客户端再确认服务器响应。即使没有应用数据，SYN 也占用序列空间中的一个位置，所以对应确认号增加一。将这些数值当成时间戳，会错误解释报文，还可能把排障引向无关的时钟同步问题，忽略真正缺失的确认或路由。

两端不会在完全相同的时刻改变状态。客户端收到 SYN-ACK 后，connect 可能成功返回，但最后一个确认在到达服务器前丢失。服务器仍可能停留在 SYN-RECEIVED，Linux 工具显示为 SYN-RECV。后续携带适当确认的数据也能完成交换，因此单独第三个报文缺失，并不必然导致永久失败，不能把抓包中的固定三包模式当成唯一合法过程。

TCP 建立成功也不代表应用健康或对端身份可信。服务可能接受连接却无法生成有效响应，代理可能完成客户端这一侧连接，却无法建立另一个独立上游连接。初始序列号选择有助于区分连接实例、抵御预测攻击，但不是身份认证协议，也不会加密字节流。传输状态、应用结果和安全身份需要各自对应的验证，不能由一项成功代替全部。

快速验证

将脚本保存为 check-tcp-handshake.py，准备 Docker 后运行 python3 check-tcp-handshake.py。一次性容器使用 Python 3.11.16、iproute2 6.1.0、nftables 1.0.6 和 tcpdump 4.99.3，在 Linux 6.12.76 上验证。NET_ADMIN 与 SYS_ADMIN 支持嵌套网络命名空间。客户端和目标由新建 veth 相连，不移动宿主接口或发布端口：

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 iproute2=6.1.0-3 iputils-ping=3:20221126-1+deb12u1 nftables=1.0.6-2+deb12u2 tcpdump=4.99.3-1 traceroute=1:2.1.2-1 procps=2:4.0.2-3 && rm -rf /var/lib/apt/lists/*\nCMD ["python3"]\n'
program=r"""
from contextlib import ExitStack,contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import json,os,select,signal,subprocess,time

def run(*args,check=True,input=None,timeout=8):
 result=subprocess.run(args,input=input,capture_output=True,text=True,timeout=timeout)
 if check:assert result.returncode==0,(args,result.returncode,result.stdout,result.stderr)
 return result
def ns(name,*args,**kwargs):return run('ip','netns','exec',name,*args,**kwargs)
def ip(name,*args,**kwargs):return ns(name,'ip',*args,**kwargs)
def stop(process):
 if process.poll() is None:
 process.terminate()
 try:process.wait(timeout=2)
 except subprocess.TimeoutExpired:process.kill();process.wait(timeout=2)
def line(process,timeout=3):
 assert select.select([process.stdout],[],[],timeout)[0],'child response deadline exceeded'
 value=process.stdout.readline();assert value,('child exited without a response',process.stderr.read())
 return value
def spawn(stack,command):
 process=subprocess.Popen(command,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process);return process
@contextmanager
def lab(names):
 with TemporaryDirectory(prefix='net-path-') as directory,ExitStack() as stack:
 root=Path(directory);proc=root/'proc';proc.mkdir();run('mount','-t','proc','proc',str(proc))
 stack.callback(run,'umount',str(proc))
 for name in names:
 run('ip','netns','add',name);stack.callback(run,'ip','netns','delete',name,check=False)
 ip(name,'link','set','lo','up')
 def setting(name,key,value):
 assert name in names
 path=proc/'sys'/key.replace('.','/')
 return ns(name,'python3','-c',f'from pathlib import Path; p=Path({str(path)!r}); p.write_text({str(value)!r}); print(p.read_text().strip())').stdout.strip()
 yield root,stack,setting
def wire(left,left_if,right,right_if,left_addresses,right_addresses):
 run('ip','link','add',left_if,'type','veth','peer','name',right_if)
 for name,interface,addresses in [(left,left_if,left_addresses),(right,right_if,right_addresses)]:
 run('ip','link','set',interface,'netns',name)
 for address in addresses:ip(name,'address','add',address,'dev',interface,*(['nodad'] if ':' in address else []))
 ip(name,'link','set',interface,'up')
def nft(name,script):return ns(name,'nft','-f','-',input=script)
def counters(name):
 data=json.loads(ns(name,'nft','-j','list','ruleset').stdout);found={}
 for entry in data['nftables']:
 rule=entry.get('rule',{})
 if 'comment' in rule:
 for expression in rule['expr']:
 if 'counter' in expression:found[rule['comment']]=expression['counter']['packets']
 return found


def capture(stack,root,name,interface,expression,label):
 path=root/(label+'.pcap')
 process=subprocess.Popen(['ip','netns','exec',name,'tcpdump','--immediate-mode','-Z','root','-U','-n','-i',interface,'-w',str(path),expression],
 stdout=subprocess.DEVNULL,stderr=subprocess.PIPE,text=True)
 stack.callback(stop,process)
 deadline=time.monotonic()+3
 while time.monotonic()<deadline:
 assert process.poll() is None,'tcpdump exited before listening'
 if select.select([process.stderr],[],[],.1)[0] and 'listening on' in process.stderr.readline():return process,path
 raise AssertionError('tcpdump did not become ready')
def packets(process,path):
 import struct,socket
 process.send_signal(signal.SIGINT);_,diagnostic=process.communicate(timeout=3)
 assert process.returncode==0,diagnostic
 raw=path.read_bytes();assert raw[:4]==bytes.fromhex('d4c3b2a1') and struct.unpack_from('<I',raw,20)[0]==1
 offset=24;result=[]
 while offset<len(raw):
 seconds,micros,size,original=struct.unpack_from('<IIII',raw,offset);offset+=16
 frame=raw[offset:offset+size];offset+=size
 if frame[12:14]!=b'\x08\x00' or frame[23]!=6:continue
 ihl=(frame[14]&15)*4;length=struct.unpack_from('!H',frame,16)[0];tcp=14+ihl
 sport,dport,seq,ack=struct.unpack_from('!HHII',frame,tcp);header=(frame[tcp+12]>>4)*4
 opts={};cursor=tcp+20
 while cursor<tcp+header:
 kind=frame[cursor]
 if kind==0:break
 if kind==1:cursor+=1;continue
 option_length=frame[cursor+1];data=frame[cursor+2:cursor+option_length];assert option_length>=2
 if kind==2:opts['mss']=struct.unpack('!H',data)[0]
 elif kind==3:opts['wscale']=data[0]
 elif kind==4:opts['sack_ok']=True
 elif kind==5:opts['sack']=[list(pair) for pair in struct.iter_unpack('!II',data)]
 cursor+=option_length
 body=frame[tcp+header:14+length]
 result.append({'t':seconds+micros/1e6,'src':socket.inet_ntoa(frame[26:30]),'dst':socket.inet_ntoa(frame[30:34]),
 'sport':sport,'dport':dport,'seq':seq,'ack':ack,'flags':frame[tcp+13],'window':struct.unpack_from('!H',frame,tcp+14)[0],
 'length':len(body),'options':opts,'preview':body[:24].hex()})
 return result
with lab(['client','target']) as (root,stack,setting):
 wire('client','c0','target','t0',['192.0.2.1/30'],['192.0.2.2/30'])
 server_code=r'''
import socketserver
class Handler(socketserver.StreamRequestHandler):
 def handle(self):
 data=self.rfile.readline();self.wfile.write(b'echo:'+data);self.wfile.flush()
class Server(socketserver.ThreadingTCPServer):allow_reuse_address=True;daemon_threads=True
server=Server(('192.0.2.2',18080),Handler);print('ready',flush=True);server.serve_forever()
'''
 service=spawn(stack,['ip','netns','exec','target','python3','-u','-c',server_code]);assert line(service).strip()=='ready'
 tap,path=capture(stack,root,'client','c0','tcp port 18080','handshake')
 normal=ns('client','python3','-c',
 'import socket; s=socket.socket();s.settimeout(2);s.bind(("192.0.2.1",40100));s.connect(("192.0.2.2",18080));s.sendall(b"normal\\n");print(s.makefile("rb").readline().decode().strip());s.close()')
 assert normal.stdout.strip()=='echo:normal'
 nft('client','''table ip missing_ack {
 chain output { type filter hook output priority 0; policy accept;
 tcp dport 18080 tcp flags & (syn|ack|rst|fin) == ack counter drop comment "missing_final_ack"
 }
}
''')
 client_code=r'''
import json,socket,sys
s=socket.socket();s.settimeout(.25);s.bind(('192.0.2.1',40101));s.connect(('192.0.2.2',18080))
print(json.dumps({'connect_returned':True}),flush=True);s.sendall(b'deferred\n')
try:s.recv(64);raise AssertionError('unexpected application response')
except TimeoutError:print(json.dumps({'application_timeout':True}),flush=True)
assert sys.stdin.readline().strip()=='restore';s.settimeout(5)
received=b''
while not received.endswith(b'\n'):
 chunk=s.recv(64);assert chunk,'premature EOF';received+=chunk
assert received==b'echo:deferred\n',received
print(json.dumps({'recovered':received.decode().strip()}),flush=True);s.close()
'''
 client=spawn(stack,['ip','netns','exec','client','python3','-u','-c',client_code])
 connected=json.loads(line(client));failure=json.loads(line(client));assert connected['connect_returned'] and failure['application_timeout']
 pending=ns('target','ss','-nHt','state','syn-recv').stdout;assert '192.0.2.1:40101' in pending,pending
 blocked=counters('client');assert blocked['missing_final_ack']>0
 nft('client','delete table ip missing_ack');client.stdin.write('restore\n');client.stdin.flush()
 recovery=json.loads(line(client,6));assert recovery['recovered']=='echo:deferred'
 client.wait(timeout=2);assert client.returncode==0
 observed=packets(tap,path);flow=[p for p in observed if 40100 in (p['sport'],p['dport'])]
 syn=next(p for p in flow if p['flags']&0x12==0x02)
 synack=next(p for p in flow if p['flags']&0x12==0x12)
 third=next(p for p in flow if p['sport']==40100 and p['flags']&0x12==0x10)
 assert synack['ack']==(syn['seq']+1)%2**32
 assert third['seq']==(syn['seq']+1)%2**32 and third['ack']==(synack['seq']+1)%2**32
 print(json.dumps({'three_messages':[syn,synack,third],'normal_reply':normal.stdout.strip(),
 'client_connect_returned':connected['connect_returned'],'application_timeout':failure['application_timeout'],
 'server_still_syn_recv':pending.strip(),'drop_counters':blocked,'after_ack_filter_removed':recovery}))
"""
name='xbcatm-tcpflow-'+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)
 build=docker('build','-t',name,str(root));assert build.returncode==0,build.stderr
 result=docker('run','--rm','-i','--name',name,'--network','none','--cap-add','NET_ADMIN','--cap-add','SYS_ADMIN',
 '--memory','256m','--pids-limit','128',name,'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)

第一条连接使用客户端端口 40100 和目标端口 18080，发送换行结束的请求，收到预期回显。抓包提供真实 SYN、SYN-ACK 和最终 ACK 数值。断言检查服务器确认号等于客户端序列号加一，第三条消息确认号等于服务器序列号加一，并对三十二位序列空间使用取模运算。这样验证的是协议关系，而不是要求每次随机数相同。

第二条连接使用客户端端口 40101。客户端命名空间输出规则丢弃带 ACK、但不带 SYN、FIN 或 RST 的报文，包含最后确认与后续数据。阻断后续数据很重要，否则新的数据段可能确认 SYN-ACK，修复刻意丢失的第三条消息。实验由此稳定暴露两端不同状态，而不是依赖短暂时序巧合，或错误地假定一个 ACK 丢失后永远无法恢复。

客户端报告 connect 已成功返回，但读取应用响应直到截止时间仍失败。同一观察点，服务器套接字列表显示该客户端四元组处于 SYN-RECV，规则计数器也确认发生丢弃。三个独立观察分别对应客户端本地 API 结果、服务器协议状态和应用交换失败，证明它们不能混成同一项“连接正常”。故障归因需要同时保存这些上下文。

移除规则后，同一连接可以继续完成交换并交付已排队请求。客户端收到 echo:deferred，没有新建替代套接字来掩盖原连接失败。带边界的读取会累积响应，不假定一次 recv 总能返回完整应用消息。测试同时验证临时失败，以及受控原因移除之后的恢复；恢复来自 TCP 后续传输与确认，不是应用重开连接造成的另一个成功样本。

分别诊断建立过程和有效服务

记录四元组、命名空间、捕获位置与两端状态。重置、反复 SYN、反复 SYN-ACK，以及握手完成后的应用超时，会指向不同的下一步检查。条件允许时捕获两个方向：本地看到一个确认离开，不代表远端已经收到。本例通过规则计数和远端状态补足这个缺口，避免只看单侧包迹就宣布服务器一定进入已建立状态。

验证服务时，应在传输连接之后发送有意义的请求并检查响应。验证身份和机密性时，应使用 TCP 上层适当的认证协议。本例覆盖没有 Fast Open 或同时打开的普通连接，不声称每个合法连接都以三个分离可见的报文开始。关键是序列号与状态的关系，而不是简单数包，更不能把握手成功当作业务操作已经完成的证明。

来源

RFC 9293 TCP，序列号、连接状态与三次握手，已核验 2026-09-12。
Linux tcp(7)，TCP 套接字行为与 Linux 控制选项，已核验 2026-09-12。
Linux ss(8)，查看已建立与 SYN-RECV 套接字，已核验 2026-09-12。

DHCP 只把地址租给你

Tue, 07 Sep 2027 00:00:00 +0000

DHCP 发的是带时长的租约而不是永久的地址。租期驱动续约机制，也让服务器收回设备已不再使用的地址。

借用而非拥有地址

DHCP 并不给设备一个永久的地址,而是把地址借给它一段有限时间。设备入网时广播去发现服务器,服务器用网络预先配置的租期给出一份租约。正因为分配是临时的,服务器随时知道哪些地址有效,可以当作资源池来统计。这份「临时」恰恰是大型、频繁变动的网络能管理起来的根本:地址是服务器可以分发、续期、收回的货币,而不是某个主机永远占着的财产。

续约让租约保持存活

在租约到期之前,客户端会主动请求续约——通常在租期过半时才提出,不够再续——于是健康设备可以在无人干预的情况下长期保有同一地址。这种「半衰期续租」让地址跨越重启与会话保持稳定,对语音、部分 VPN 这类地址一变就断的服务尤其重要。租期是一个治理旋钮:租期短,地址回收快,但续约流量更密;租期长,地址更稳定,却把早已离开的地址长期拴着不放。

过期即可回收

租约到期又没有续约时,服务器会收回该地址,再把它发给另一台主机。一台许多天前就离开大楼的笔记本,就因此不会一直占着一个新设备正需要的地址。放弃租约的设备下一次入网会拿到一个新地址——对临时上网没问题,对期望固定身份的服务却不友好。调整租约就是在换手率与可用性之间找平衡:拥挤或流动的网络用短租期,内部稳定、身份重要的场景用长租期。

坏掉的样子

地址池耗尽时最安静。新客户端广播 DISCOVER，却收不到 OFFER，或者 REQUEST 换来一个 NAK，笔记本只能拿到 169.254.x.x 的链路本地地址，哪儿也去不了。这时不要让客户端盲目重试：应该扩大地址池，在人员流动大的网络里缩短租期，让离开的设备尽快归还地址，同时清理服务器上因冲突被标记为废弃的绑定。

相反的错误，是把租期设得太短，短到变成风暴。一间有上千台主机的办公室，如果租期只有五分钟，就会有约一半设备每隔几分钟在 T1 时刻单播续约，掉队的还要在 T2 时刻广播重绑，服务器一旦重启，正好撞上续约洪峰。应当保持 RFC 2131 的默认值，T1 取租期一半，T2 取租期的八分之七，先把过短的租期调长，再把开机潮错峰，而不是把续约流量当成免费的。

流氓服务器靠抢答获胜。一台私接的家用路由器或者恶意主机，会抢在真正的服务器之前回答 DISCOVER，给出一个看起来合法、网关或 DNS 却被掉包的地址，把流量引到自己身上。症状会游走：有的租约正常，有的解析异常，受害的客户端随着每次竞速不断变化。对策是固定合法服务器的标识，在交换机上开启 DHCP 监听，只允许受信任端口发送 OFFER 和 ACK，并把流氓设备清走，而不是调定时器。

时钟偏斜破坏的是那份安静的契约。线上传输的是相对秒数，可一旦服务器用绝对时间戳保存过期时刻，或者笔记本一睡就睡过 T1 和 T2，就会提前过期或者超期占用。睡着的机器醒来时还配着旧地址，而服务器早已把它收回转租，两个主机就会争用同一个 IP。应当把长时间睡眠当作一次重绑，排查时把 NTP 和 DHCP 日志放在一起看，并保留冲突检测与 DECLINE、RELEASE 的处理，不要假设时钟永远不会跳变。

快速验证

把下面程序保存为 dhcp_lease_sim.py，运行 python3 dhcp_lease_sim.py。它只用 Python 标准库，以虚拟时钟推进代替睡眠，不碰网络，完整模拟 DISCOVER、OFFER、REQUEST、ACK，以及 T1 单播续约和 T2 广播重绑。

"""Simulate a DHCP lease lifecycle on a virtual clock (stdlib only)."""
from __future__ import annotations

LEASE_TIME = 100
T1 = LEASE_TIME // 2 # 50: unicast renewal (RFC 2131 default)
T2 = int(LEASE_TIME * 0.875) # 87: broadcast rebinding (RFC 2131 default)


class DHCPServer:
 def __init__(self, pool):
 self.pool = list(pool)
 self.leases: dict[str, dict] = {} # ip -> {"client": id, "expiry": int}
 self.now = 0

 def _free_ip(self):
 for ip in self.pool:
 lease = self.leases.get(ip)
 if lease is None or lease["expiry"] <= self.now:
 return ip
 return None

 def discover_offer(self, client_id):
 """DISCOVER -> OFFER (no state change)."""
 ip = self._free_ip()
 assert ip is not None, f"t={self.now}: pool exhausted, no OFFER for {client_id}"
 return ip

 def request_ack(self, client_id, ip):
 """REQUEST -> ACK and bind the lease."""
 lease = self.leases.get(ip)
 assert lease is None or lease["expiry"] <= self.now or lease["client"] == client_id, \
 f"t={self.now}: {ip} held by another client"
 self.leases[ip] = {"client": client_id, "expiry": self.now + LEASE_TIME}
 return {"ip": ip, "lease_time": LEASE_TIME, "t1": T1, "t2": T2,
 "expiry": self.now + LEASE_TIME}

 def renew(self, client_id, ip, broadcast=False):
 """Renew at T1 (unicast) or T2 (broadcast). Returns True on ACK."""
 lease = self.leases.get(ip)
 if lease is None or lease["client"] != client_id or lease["expiry"] <= self.now:
 return False # expired: server already reclaimed
 lease["expiry"] = self.now + LEASE_TIME
 return True

 def tick(self, dt):
 self.now += dt
 # Reclaim expired leases so a new client can reuse them.
 for ip, lease in list(self.leases.items()):
 if lease["expiry"] <= self.now:
 del self.leases[ip]


def check(cond, msg):
 assert cond, msg


def main():
 server = DHCPServer(["192.168.1.10", "192.168.1.11"])
 # 1. DORA: client c1 joins.
 offered = server.discover_offer("c1")
 check(offered == "192.168.1.10", f"expected first free IP, got {offered}")
 ack = server.request_ack("c1", offered)
 check((ack["lease_time"], ack["t1"], ack["t2"]) == (100, 50, 87), f"bad timers: {ack}")
 check(ack["expiry"] == 100, f"expiry should be 0+100, got {ack['expiry']}")
 print(f"t={server.now}: c1 ACK {ack['ip']} lease=100 T1=50 T2=87 expiry=100")
 # 2. T1 unicast renewal at half lease.
 server.tick(T1) # now=50
 check(server.renew("c1", offered), "T1 renewal should be ACKed")
 check(server.leases[offered]["expiry"] == 150, "T1 must extend expiry to 50+100")
 print(f"t={server.now}: c1 T1 unicast renew OK expiry=150")
 # 3. Miss T1, rebind at T2 via broadcast.
 server.tick(T2 - T1) # now=87; T1 of current lease would be 100
 server.tick(20) # now=107: past T1 (100), before T2 (137) and expiry (150)
 check(server.renew("c1", offered, broadcast=True), "T2 rebinding should be ACKed")
 check(server.leases[offered]["expiry"] == 207, "T2 must extend expiry to 107+100")
 print(f"t={server.now}: c1 T2 broadcast rebind OK expiry=207")
 # 4. Leave without renewing: expiry reclaims the address.
 server.tick(200) # now=307 > expiry 207
 check(offered not in server.leases, "expired lease must be reclaimed")
 offered2 = server.discover_offer("c2")
 check(offered2 == offered, f"reclaimed {offered} should be reused, got {offered2}")
 ack2 = server.request_ack("c2", offered2)
 check(ack2["expiry"] == server.now + LEASE_TIME, "new lease expiry must restart")
 # Stale renewal from the departed client must fail.
 check(not server.renew("c1", offered), "stale renewal after expiry must not be ACKed")
 print(f"t={server.now}: c1 expired, c2 ACK {ack2['ip']} expiry={ack2['expiry']}")
 print("PASS: discover/offer/request/ack, T1 renew, T2 rebind, expiry reclaim")


if __name__ == "__main__":
 main()

程序断言：服务器给出第一个空闲地址，ACK 携带 100 秒租期且 T1 为 50、T2 为 87，每次续约都把过期时刻延长一个完整租期，离场地址被回收并转租给第二个客户端，而旧客户端的过期续约会被拒绝。运行成功会看到四行带时间戳的日志，外加一行说明四个阶段都通过的 PASS。

上述断言已在 macOS、Python 3.12 下运行通过。虚拟时钟验证的是状态机，不是线上守护进程：发布前仍要核对真实服务器的租期、地址池大小、合法服务器名单，以及客户端与服务器两端的 NTP 健康度。

来源

IETF：RFC 2131 DHCP，租约生命周期的权威定义：DISCOVER、OFFER、REQUEST、ACK 与 T1、T2 续约定时器，已核验 2027-08-15。
ISC：ISC DHCP，地址池管理、租约数据库与服务器运行说明，已核验 2027-08-15。
维基百科：动态主机配置协议，租约生命周期的通俗总览，已核验 2027-08-15。

Kubernetes Service 为 Pod 提供稳定入口

Mon, 23 Aug 2027 00:00:00 +0000

既然 Pod 会重建，就很难记住它的地址。Service 在这组 Pod 前面固定一个名字，让调用方不因 Pod 更换而受影响。

一个地址，一组 Pod

多副本带来了多个 Pod,而每个 Pod 都有自己的 IP,还会随时被重建。Service 正是它们前面那个稳定的家:你声明一个选择器,平台就分给它一个固定的集群 IP 和一段可被 DNS 解析的名字。集群 DNS 把名字解析到 Service 上,因此组件(Ingress、负载均衡、别的 Pod)只依赖这个名字,而从不关心具体某个 Pod 的地址。抽象的全部意义就在于:名字是持久的,背后站着的每一样东西都可以即丢即换。

选择规则决定由谁响应

Pod 靠「匹配」加入 Service,而不是靠被人点名登记:标签打中了选择器,它就进入;不再匹配或不再就绪,就被移出。平台从选择器推出后端这份视图,当一个 Pod 通过探针与就绪,就把它加进去,缩容或下线时就拿掉。所以后端列表是一份实时推导的视图,而不是从头到尾手打的名单。也正因为后端由选择器与就绪共同决定,一个没就绪的 Pod 会自己掉出去,流量绝不会被送到不该服务的 Pod 上。

流量总给当前匹配的

这层间接,正是让端点变化落不到调用方身上的原因。客户端只握着那个名字;它背后的集合被扩、被替、被滚动更新,都不需要改客户端设一个字。滚动更新一个接一个地替换掉又续上 Pod,Service 始终把流量导向当前匹配且就绪的那批,于是调用方察觉不到任何断层。你可以依赖这件事:只要选择器精准、Pod 与它匹配,Service 在每个时刻都把流量送进正确的那批。把选择器钉紧、探针管严,这个稳定的家便能在里面的 Pod 全是新面孔时依旧稳如磐石。

稳定名字是对调用方的承诺

虚拟地址如何分配是另一回事,本篇要讲的是这个稳定入口对调用方意味着什么。一个守规矩的客户端只需要在启动时解析一次 Service 名字,此后整个生命周期都握着它,即使后端被全部换掉也不必改配置、不必重启。承诺成立需要三个习惯同时成立:选择器始终精确命中目标 Pod,就绪状态始终把未就绪者挡在集合之外,调用方不偷存某次看到的 Pod 地址直连。把 Service 名字当作唯一受支持的访问方式,扩缩容、崩溃重启、滚动发布都可以发生在名字背后,而调用方看到的始终是同一个家。

坏掉的样子

最安静的故障是选择器谁也选不中。比如把 app: web 写成 app: webs,或者 Deployment 不再给 Pod 打预期标签,Service 的端点集合就会变成空。此时集群 IP 与 DNS 名字依然能解析,故障表现为连接被拒绝或超时,而不是名字不存在。当 Service 能解析却送不出流量时,先看它的端点集合:空集合说明问题在标签,而不在网络。

第二个常见陷阱是顺手写成的无头 Service。一旦设置 clusterIP: None,虚拟 IP 就不存在了,DNS 直接返回不断变化的 Pod 地址,每个客户端都要自己做负载均衡。为单一稳定入口编写的代码,突然要面对多个漂移地址,重试不均、连接复用失效都会跟着来。只有调用方明确想要服务发现时才用无头形式,不要把它当成默认写法。

端口配错是从另一侧打破承诺。Service 的 port 指向了容器根本没有监听的 targetPort,流量进来也永远送不到;手选的 NodePort 还可能和同一批节点上的另一个 Service 撞车。最后,不要给无状态服务留下 sessionAffinity: ClientIP:每个客户端会被粘到同一个后端上,均衡的副本池变成冷热不均的分片,一个 Pod 要死不活,看起来就像整组服务都挂了。除非业务真的要求粘性会话,否则一律关闭亲和。

快速验证

把下面程序保存到临时工作目录的 service_endpoints.py,运行 python3 service_endpoints.py。它只用字典模拟 Service 端点收敛,不修改进程之外的任何东西:一个函数根据选择器、Pod 标签与就绪状态推导端点集合,四个场景依次演练它,其中故意留空的选择器是反例,用于证明空选择器必须告警,而不是悄悄匹配到奇怪的结果。

"""用选择器加就绪状态模拟 Service 端点收敛。"""

PODS = [
 {"name": "web-1", "labels": {"app": "web"}, "ready": True},
 {"name": "web-2", "labels": {"app": "web"}, "ready": True},
 {"name": "web-3", "labels": {"app": "web"}, "ready": False},
 {"name": "worker-1", "labels": {"app": "worker"}, "ready": True},
]


def select_endpoints(pods, selector):
 """推导端点集合；空选择器告警而不是默默匹配。"""
 if not selector:
 return [], "warning: empty selector matches nothing"
 matched = sorted(
 pod["name"]
 for pod in pods
 if pod.get("ready")
 and all(pod.get("labels", {}).get(key) == value for key, value in selector.items())
 )
 return matched, ""


def check(condition, message):
 if not condition:
 raise AssertionError(message)


def main():
 endpoints, warning = select_endpoints(PODS, {"app": "web"})
 check(endpoints == ["web-1", "web-2"], "就绪的 web Pod 应组成集合")
 check(warning == "", "精确的选择器不应告警")
 print("steady state:", endpoints)

 rolling = [dict(pod, ready=True) if pod["name"] == "web-3" else pod for pod in PODS]
 rolling = [pod for pod in rolling if pod["name"] != "web-1"]
 endpoints, _ = select_endpoints(rolling, {"app": "web"})
 check(endpoints == ["web-2", "web-3"], "滚动应以新就绪 Pod 替换旧 Pod")
 print("after rollover:", endpoints)

 endpoints, _ = select_endpoints(PODS, {"app": "web", "track": "stable"})
 check(endpoints == [], "过窄的选择器应收敛为空，而不是报错")
 print("over-narrow selector:", endpoints)

 endpoints, warning = select_endpoints(PODS, {})
 check(endpoints == [] and "empty selector" in warning, "空选择器必须大声告警")
 print("empty selector:", repr(warning))

 print("PASS: four convergences; readiness-gated selection, rollover, and empty warning hold")


if __name__ == "__main__":
 main()

四个场景的收敛结果和健康 Service 完全一致:稳态时两个就绪的 web Pod 在集合里,未就绪者被挡在外面;滚动时选择器不变,集合从一个就绪 Pod 换成另一个;过窄的选择器会清楚地收敛为空。空选择器是反例:它大声告警,而不是悄悄匹配全部或悄悄返回空。这些断言已在 macOS、Python 3.14.4 下运行通过。

这个模拟只验证标签加就绪的收敛逻辑,不实现 kube-proxy、集群 DNS 与真实探针时序,也不覆盖生产环境的端口冲突。发布前还要对照 Pod 标签与就绪状态检查真实端点集合,并用真正的 Service 名字在两个语言环境里各走一遍查询。

来源

Kubernetes：Services，Service 抽象，已核验 2027-08-15。
Kubernetes：Pods，Service 所选择的 Pod，已核验 2027-08-15。
Kubernetes：Deployments，管理 Pod 集合，已核验 2027-08-15。

连接超时阻止无声的停摆

Sun, 01 Aug 2027 00:00:00 +0000

超时首先规定某个操作最多等待多久。它不会自动成为整个请求的总期限，也不能证明远端工作已经停止。选择数值或解释错误之前，要把连接建立、单次读取和调用方的整体预算分开；否则配置看起来都有限，整条调用链仍然可能等得远比预期久。

连上了，不代表能拿到有用的响应

TCP 建连可以成功，而对端应用始终不产生响应。此时问题属于读取阶段，不是 TCP 握手尚未完成。诊断信息应写出发生超时的阶段；含糊的“数据库连接超时”，可能指连接池获取借用失败，也可能指新建套接字失败，或已经连上后等不到查询结果。它们占用的资源、下一步检查和恢复语义并不相同。

Python 套接字上的超时作用于阻塞操作。循环执行多次成功的 recv()，每次都可能获得一份新的等待额度，因此对端只要持续发送小片段，就可能把整个读取循环拖到远超那个超时值。下面特意每次只读一个字节，便于观察单次操作成功与完整响应及时到达之间的差别，而不是把“一次没有超时”当成整个消息已经满足时限。

如果需要整个接收过程共用预算，应先用 time.monotonic() 建立一个截止点。每次开始下一项操作前，计算剩余时间，再取剩余时间与该操作上限中的较小值；预算耗尽后，就不能继续开始新的等待。单调时钟不会因校正系统日期而突然倒退或跳到另一段墙钟时间，但它也不能保证线程恰好在截止的那一刻获得调度，因此不能把它理解成硬实时执行器。

把这个模式扩展到真实客户端之前，仍要核对所用库的契约。域名解析、多个地址尝试、TLS 协商、发送请求以及从连接池排队获取连接，可能有各自的计时方式。本例只访问一个数字形式的回环地址，并使用普通 TCP；它没有证明 DNS 解析已经受限，也没有实现一个覆盖完整 HTTPS 请求流程的通用总超时。

坏掉的样子

已接受连接但保持沉默的对端，会让调用方读到超时；不断滴送少量数据的对端，则能让每次读取都成功，却使完整响应过慢。只有建连超时，并不能处理连接已经成功之后的这两种情况。反过来，设置得过短，也可能把正常的网络波动或线程调度延迟误判成故障，数值需要结合真实调用预算和工作负载来确定。

失败路径需要释放自己拥有的资源，并保留完整数据与部分数据的区别。套接字读取返回空字节串，表示 EOF，并不等于应用消息必然收齐。实验知道目标帧应该有六个字节，所以提前关闭会被当成失败；不能因为连接已经结束，就把收到的半份结果当作正常响应交给业务。

放弃等待也不等于取消远端工作。调用方超时时，对端可能已经执行了某个副作用。重试需要匹配的重放契约，以及原操作还剩下的预算，而不是每次重新获得一整套等待时间。这里的总期限是在操作边界协作检查的约束，仍有调度与清理开销，并不是对任意线程、系统调用或远端执行的瞬时中断保证。

快速验证

将代码保存为 connection_probe.py，执行 python3 connection_probe.py。脚本只依赖标准库，本次在 macOS 的 Python 3.14.4 上验证。每种情况都创建自己的回环监听端口和对端线程，结束时关闭套接字并等待线程退出；不会连接外部主机，也不修改防火墙或生产服务。

import socket
import threading
import time


PAYLOAD = b"abcdef"
PER_OPERATION = 0.5


def exercise(trickle, total=None, peer_payload=PAYLOAD):
 stop = threading.Event()
 failures = []
 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as listener:
 listener.bind(("127.0.0.1", 0))
 listener.listen(1)
 listener.settimeout(2.0)

 def peer():
 try:
 connection, _ = listener.accept()
 with connection:
 connection.settimeout(0.5)
 if not trickle:
 stop.wait(2.0)
 return
 for byte in peer_payload:
 if stop.wait(0.1):
 return
 connection.sendall(bytes([byte]))
 except (BrokenPipeError, ConnectionResetError):
 pass # The deadline case deliberately closes the client.
 except Exception as error:
 failures.append(error)

 worker = threading.Thread(target=peer)
 worker.start()
 started = time.monotonic()
 deadline = None if total is None else started + total
 received = bytearray()
 phase, outcome = "connect", "complete"

 def allowance():
 if deadline is None:
 return PER_OPERATION
 remaining = deadline - time.monotonic()
 if remaining <= 0:
 raise TimeoutError("total budget expired")
 return min(PER_OPERATION, remaining)

 try:
 with socket.create_connection(listener.getsockname(), timeout=allowance()) as client:
 phase = "read"
 while len(received) < len(PAYLOAD):
 client.settimeout(allowance())
 chunk = client.recv(1)
 if not chunk:
 raise EOFError(f"short frame: {len(received)}/{len(PAYLOAD)} bytes")
 received.extend(chunk)
 except TimeoutError:
 outcome = "total" if deadline is not None and time.monotonic() >= deadline else phase
 finally:
 elapsed = time.monotonic() - started
 stop.set()
 worker.join(2.0)
 assert not worker.is_alive(), "fixture peer failed to stop"
 assert not failures, failures
 return outcome, bytes(received), elapsed


quiet = exercise(trickle=False)
assert quiet[0] == "read" and quiet[1] == b""
trickle = exercise(trickle=True)
assert trickle[0] == "complete" and trickle[1] == PAYLOAD
assert trickle[2] >= 0.5 # Each successful recv got a fresh operation timeout.
bounded = exercise(trickle=True, total=0.25)
assert bounded[0] == "total" and bounded[1] != PAYLOAD
try:
 exercise(trickle=True, peer_payload=b"ab")
except EOFError as error:
 assert str(error) == "short frame: 2/6 bytes"
else:
 raise AssertionError("a truncated frame must not become success")
print("early EOF rejects a two-byte fragment of the six-byte frame")
for name, result in (("quiet", quiet), ("trickle", trickle), ("bounded", bounded)):
 outcome, data, elapsed = result
 print(name, outcome, repr(data), "elapsed", round(elapsed, 3))

quiet 情况先成功建立连接，但没有收到任何数据，大约半秒后报告 read 超时。trickle 情况在发送六个字节之前分别暂停一小段时间，每次读取都落在单次额度内，完整帧却花了超过半秒才到齐。这里的 complete 是指六个预期字节全部到达，不是某一次读取返回了非空内容；这直接展示了逐次操作超时为什么不能代替整个读取循环的预算。

加入四分之一秒总预算后，同样的滴送过程无法收完整帧，结果报告 total 到期并保留部分字节。确切收到了几个字节、打印的小数是多少，会随调度变化；断言检查的是超时类别和结果是否完整，并没有承诺精确到毫秒的运行轨迹。第四个对端只发送两个字节就关闭，读取方必须抛出 EOFError，不能把片段当成完整帧。实验中的短数值只是为了快速暴露这几个边界，不应复制成生产环境默认值。

最后的 stop 事件是测试程序主动提供的协调机制，用于清理时释放本机对端线程，不是 TCP 自动向任意远程业务发送了取消命令。这些结果只验证单次等待与共享接收预算的区别，没有覆盖连接黑洞、TLS 失败、业务重试或生产尾延迟；上线前仍需沿真实客户端调用链逐段确认预算到底覆盖到了哪里。

来源

Python socket，阻塞操作超时、连接建立与套接字读取，已核验 2026-09-09。
Python time，单调时钟与经过时间测量，已核验 2026-09-09。

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。

NodePort 在每台节点的固定端口上开放服务

Tue, 11 May 2027 00:00:00 +0000

NodePort 类型的 Service 只做一件很直接的事：在 30000-32767 这个范围里占一个端口，让集群里每一台节点都在上面监听。kube-proxy 会把同一条转发规则写进每台机器的 iptables 或 IPVS 表，于是 curl <任意节点 IP>:<nodePort> 无论落到哪台机器都能到达这个 Service。这正是它全部的吸引力——不需要云负载均衡、不需要 DNS 记录、不需要 Ingress 控制器，就能对外可达。

代价藏在同一个设计里。既然每台节点都应答，包就经常落在没跑这个 Pod 的机器上，集群随后必须决定后端看到的是谁的地址。externalTrafficPolicy 就是这个决定：Cluster 把负载摊开但改写客户端地址，Local 保住客户端地址却在没有本地端点的节点上直接丢包。两者必须选一个，而每一种选择都会弄坏不同的东西。

一个每台节点都占着的端口

kubectl create service nodeport 不带 --node-port 时根本不会输出 nodePort 字段，端口由 API server 从范围里分配。这个分配是集群级而不是节点级的：一个号码在整个集群里只能属于一个 Service。所以两个都钉 31000 的 Service 无法共存，而一条针对某个号码的防火墙规则却可以原样搬到每台机器上。

每台节点都会拿到这条规则，无论它是否跑着后端。这让该类型好用——调用方没有需要避开的节点，也没有需要维护的成员清单——也让它昂贵，因为端口开在了那些本不该接受这类流量的机器上。端点集合为空时规则依然存在，连接会被拒绝而不是静默丢弃，这至少是诚实的。

多出来的一跳与客户端地址

落在节点 B 上的请求，如果 Pod 其实在节点 A，就会被转发到 A，于是数据路径比直接打到 A 多一跳。在默认的 externalTrafficPolicy: Cluster 下，kube-proxy 还会把包做源地址转换（SNAT）成节点 B 的地址，因此 Pod 看到的是集群内部地址，而不是客户端地址。iptables 模式下这条规则是一串匹配 nodePort 的链，IPVS 模式下是一个虚拟服务加若干真实服务器条目；两种模式都在转发前做这次源地址改写，所以换代理模式并不能把客户端地址找回来。任何依赖客户端地址的东西——限流、地域规则、审计日志、白名单——读到的都是错的号码。

externalTrafficPolicy: Local 只转发给收到包的那台节点上的端点，从而保住原始源地址。代价是可用性：没有本地副本的节点完全没有可用的 nodePort，所以三节点集群只跑一个副本时，一台节点应答、两台丢包。这就是那笔交易——客户端地址正确、少一跳，换来的却是一个只在部分节点上生效的 nodePort。

绕开 Ingress 的一扇侧门

nodePort 不做 TLS 终止，也不做任何检查。直接发往 节点:31000 的请求会跳过负载均衡、TLS 终止、WAF，以及所有本应生效的 host 或 path 路由规则，带着调用方自己选的内容直接落到 Pod 上。于是 Pod 被迫去做它从未被设计去做的安全判断。

把它当成一扇有归属、有到期日的临时门。保留好端口范围，只有在防火墙或 DNS 记录强制要求时才钉死号码，并在网络层限制谁能访问这个范围，而不是假设 Ingress 是唯一的入口。如果这个端口同时被安全组放开给 0.0.0.0/0，那么任何能路由到节点网段的主机都可以直接和 Pod 对话，而 Ingress 上的鉴权、限流与审计完全不在这条路径上。范围本身也是有限资源：2768 个端口用满之后，再没有新的 NodePort Service 能被分配出来。

坏掉的样子

最经典的是端口冲突。nodePort 是一个集群级资源，所以第二个钉住已占用号码的 Service 会被拒绝，报 provided port is already allocated；而 2768 个端口一旦用满，请求自动分配的 Service 再也拿不到端口。两者的表现都是：Service 对象存在，却没有可用的对外端口——看起来像网络故障，实际是容量故障。

第二种更安静。nodePort 在每台宿主机上都是一次真实的 socket bind，所以只要那个号码上已经有人监听，这台机器上的 nodePort 就是死的，而 kubectl get svc 依旧报告 Service 健康——健康检查、看板与 Service 对象一起说谎。又因为同一个端口绕过了 Ingress 那一层，让排查变简单的规则同时也让集群以没人过滤的方式可达。影响面是整个集群的每一台节点，而不是你正在看的那一台。

快速验证

确认端口、端点，以及还有谁占着这个端口：

kubectl get svc web -o jsonpath='{.spec.type} {.spec.ports[0].nodePort}{"\n"}'
kubectl get endpoints web
kubectl get svc -A -o json | jq -r '.items[] | select(.spec.type=="NodePort") | "\(.spec.ports[0].nodePort) \(.metadata.namespace)/\(.metadata.name)"' | sort -n | uniq -D -w5
ss -lnt | grep -E ':3[0-9]{4}\b'
curl -sS -o /dev/null -w '%{http_code}\n' "http://$(hostname -I | awk '{print $1}'):$(kubectl get svc web -o jsonpath='{.spec.ports[0].nodePort}')/"

第三条会打印出被两个 Service 同时占用的 nodePort，第四条显示本机上是否有 kube-proxy 之外的进程已经占着该端口。curl 应该在每台节点上都打印 200；只有一台节点连接被拒，说明本机有人占了这个端口；所有节点都被拒，说明这个 Service 没有就绪的端点。

来源

Kubernetes Service，NodePort 类型、30000-32767 默认范围与集群级端口分配，已核验 2026-09-16。
Virtual IPs and Service Proxies，kube-proxy 的 iptables/IPVS 规则编程与 externalTrafficPolicy，已核验 2026-09-16。
Using Source IP，NodePort 的 SNAT 与客户端地址后果，已核验 2026-09-16。

空闲超时回收边缘连接

Mon, 26 Apr 2027 00:00:00 +0000

空闲超时会在一段时间没有符合定义的活动后关闭连接。它是一项资源保留策略，不是客户端已经消失的证明。健康客户端也可能暂时安静，关键是说清哪种活动重置哪只计时器，以及连接关闭之后，协议允许调用方如何恢复；不能仅凭“连接还在，但没有字节”就判断它应当被立即回收。

空闲属于某个明确的边界

TCP 连接会占用文件描述符、内核缓冲，以及应用或代理记录的连接状态，但通常不需要为每条连接建立独立的路由表项。回收暂时不用的连接，可以限制保留的资源；复用健康连接则能减少重新建连的成本。策略应服务于工作负载，而不是把所有沉默连接都理解成已经被遗弃的泄漏。

Go HTTP Server.IdleTimeout 约束的是持久连接上等待下一次请求的时间。处理器正在工作、但尚未发送任何字节时，并不会仅仅因为超过这个空闲值就被它终止。读取请求头、传输正文、写响应和执行应用逻辑，都需要各自适用的控制项。名字中出现 idle，并不意味着它已经覆盖完整请求的所有阶段。

Nginx 也把不同边界分开：客户端侧的 keepalive_timeout 管理保留的持久连接；proxy_read_timeout 则针对从上游响应读取数据时，两次相邻读取之间的等待，而不是整个响应的总耗时。它们观察代理两侧的不同活动。数值写成一样，并不能让含义也相同，更不能据此断言整条链路已经具有相同的截止点。

零值也不能跨实现直接套用。Nginx 的 keepalive_timeout 设为零，会禁用客户端持久连接；Go 的 IdleTimeout 为零时，则使用 ReadTimeout 的值。如果后者也没有正的限制，才没有建立空闲期限。需要按具体实现核对“零”的契约，不能统一理解成关闭功能，或理解成立即关闭套接字。

坏掉的样子

阈值短于正常静默间隔，会迫使客户端重新建连，或者中断这个计时器实际覆盖的流量；阈值过于宽松，则可能保留超出服务承受范围的套接字。应记录连接数量、关闭原因、复用情况和实际工作模式。安静只能说明被观察的活动没有发生，并不能独立识别坏客户端，也不能告诉你最合适的秒数是多少。

HTTP keep-alive 指的是复用连接，不是定期发送的应用心跳。TCP keepalive 探针又是另一种机制，不会变成服务器读取到的应用请求字节。应用心跳也只有在某个端点确实把它算作活动时，才会影响该端点的计时器。客户端、代理与上游不一定观察到同一批事件，流式传输和多路复用协议尤其需要逐层核对，不能用一个“保活间隔”解释全部行为。

关闭还可能与客户端发起下一次请求发生竞争。连接池中的旧连接需要恢复路径，但重新建连不代表任意请求都可以安全重放。HTTP 明确允许异步关闭连接，是否重试仍取决于请求语义，以及此前副作用是否可能已经发生。“服务器稍微早关一点没有关系”，对修改数据的请求并不是可靠的普遍结论。

快速验证

将代码保存为 idle_probe.go，执行 go run idle_probe.go。程序只使用 Go 标准库，本次在 macOS 的 Go 1.27.0 上验证。测试服务器监听本机回环地址，发送的是普通 HTTP/1.1 请求；没有访问公网边缘节点，也没有启动 Nginx、使用证书或修改任何生产配置。

package main

import (
 "context"
 "fmt"
 "io"
 "net"
 "net/http"
 "net/http/httptest"
 "runtime"
 "strconv"
 "sync/atomic"
 "time"
)

type connectionKey struct{}

func check(ok bool, message string) {
 if !ok {
 panic(message)
 }
}

func main() {
 const idle = 200 * time.Millisecond
 const headers = 500 * time.Millisecond
 const work = 350 * time.Millisecond
 var serial, handled atomic.Int64
 closed := make(chan struct{}, 8)
 server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 handled.Add(1)
 if r.URL.Path == "/slow" {
 time.Sleep(work)
 }
 w.Header().Set("X-Connection-ID", strconv.FormatInt(r.Context().Value(connectionKey{}).(int64), 10))
 w.Header().Set("Content-Type", "text/plain")
 fmt.Fprintln(w, "ok")
 }))
 server.Config.IdleTimeout = idle
 server.Config.ReadHeaderTimeout = headers
 server.Config.ConnContext = func(ctx context.Context, _ net.Conn) context.Context {
 return context.WithValue(ctx, connectionKey{}, serial.Add(1))
 }
 server.Config.ConnState = func(_ net.Conn, state http.ConnState) {
 if state == http.StateClosed {
 closed <- struct{}{}
 }
 }
 server.Start()
 defer server.Close()
 transport := &http.Transport{MaxIdleConns: 1, MaxIdleConnsPerHost: 1}
 defer transport.CloseIdleConnections()
 client := &http.Client{Transport: transport, Timeout: 2 * time.Second}

 get := func(path string) int64 {
 response, err := client.Get(server.URL + path)
 check(err == nil, fmt.Sprint(err))
 body, readErr := io.ReadAll(response.Body)
 closeErr := response.Body.Close()
 check(readErr == nil && closeErr == nil, "response body did not finish cleanly")
 check(response.Proto == "HTTP/1.1" && response.StatusCode == 200, "unexpected protocol or status")
 check(string(body) == "ok\n", "unexpected response body")
 id, err := strconv.ParseInt(response.Header.Get("X-Connection-ID"), 10, 64)
 check(err == nil, "missing connection identity")
 return id
 }

 first := get("/ping")
 check(get("/ping") == first, "the fully consumed responses should allow reuse")
 started := time.Now()
 check(get("/slow") == first, "the active request should keep its connection")
 check(time.Since(started) >= work, "the handler did not complete its work")
 fmt.Println("two requests reuse one HTTP/1.1 connection; active work outlasts IdleTimeout")

 select {
 case <-closed:
 case <-time.After(2 * time.Second):
 panic("the idle connection was not closed")
 }
 check(get("/ping") != first, "the request after idle closure needs a new connection")
 fmt.Println("server reports idle closure; a later GET succeeds on a new connection")

 before := handled.Load()
 connection, err := net.DialTimeout("tcp", server.Listener.Addr().String(), time.Second)
 check(err == nil, fmt.Sprint(err))
 defer connection.Close()
 check(connection.SetDeadline(time.Now().Add(2*time.Second)) == nil, "could not bound raw probe")
 _, err = io.WriteString(connection, "GET /ping HTTP/1.1\r\nHost: probe\r\n")
 check(err == nil, fmt.Sprint(err))
 reply, err := io.ReadAll(connection)
 check(err == nil && len(reply) == 0, "partial headers should end with EOF in this server")
 check(handled.Load() == before, "incomplete headers must not invoke the handler")
 fmt.Println("incomplete request headers close without reaching the handler; ReadHeaderTimeout is separate")
 fmt.Println(runtime.Version())
}

客户端完整读完响应正文并关闭 Body，从而允许复用连接。前两次请求报告同一个由服务器分配的连接编号。第三次请求让处理器执行三百五十毫秒，超过二百毫秒的空闲额度，却仍然在同一连接上成功返回。这证明正在处理请求的时间，与两次请求之间等待下一次请求的空闲区间，并不是同一个计时范围。

响应完成后，客户端不再发送请求。程序等待服务器报告连接已关闭，再发一次 GET，新响应的连接编号必须改变。这里观察的是实际关闭事件和新的连接身份，不是睡过一个假定时长，就直接宣布资源应该已经被回收。新的 GET 能成功，也不意味着其他具有副作用的业务请求可以不经判断就照样重试。

另开一条原始连接，发送不完整的请求头，然后等待服务器关闭。本次运行中读到 EOF，处理器调用计数没有增加；五百毫秒的 ReadHeaderTimeout 与持久连接空闲策略分开起作用。客户端自身也设置等待期限，避免测试失败时无界挂起；延迟清理负责关闭本次创建的传输层连接和测试服务器，不依赖进程退出碰巧代为收尾。

这些很短的时间值只是让实验能快速看见状态变化，不是通用生产配置。验证范围是 Go 的 HTTP/1.1 行为，没有覆盖 HTTP/2 流、WebSocket、内核保活探针时序或所有中间代理。为真实链路协调空闲策略时，应逐段确认什么算活动、谁负责关闭，以及关闭后该如何安全恢复，而不是把一个库的参数语义推广到所有节点。

来源

Go net/http，空闲与请求头超时、连接状态及响应正文复用，已核验 2026-09-09。
Go net/http/httptest，本机回环测试服务器及其生命周期，已核验 2026-09-09。
Nginx HTTP 核心模块，客户端持久连接超时语义，已核验 2026-09-09。
Nginx 代理模块，上游响应逐次读取超时，已核验 2026-09-09。
RFC 9112：HTTP/1.1，持久连接与异步关闭，已核验 2026-09-09。

网络 · XB 现场笔记

TCP backlog 收纳还在握手中的连接

backlog 参数管的是 accept 队列

syncookies 开着的时候，SYN 队列就不再是瓶颈

压力真正落在 accept 队列上

坏掉的样子

快速验证

来源

网络命名空间隔离网络资源，名称并不拥有其中所有进程

坏掉的样子

快速验证

分开管理名称、进程归属与通信配置

来源

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

坏掉的样子

快速验证

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

延伸阅读

来源

TCP 慢启动随数据确认增长，不会仅因时间流逝而翻倍

坏掉的样子

快速验证

结合负载解释增长轨迹

来源

veth 对在两个端点之间搬运帧，路由决定这些帧承载的路径

坏掉的样子

快速验证

按层次检查实际路径

来源

VXLAN 既需要底层可达，也需要两端隧道参数一致

坏掉的样子

快速验证

让证据对应正在修改的网络层

延伸阅读

来源

listen backlog 保存等待 accept 的连接

坏掉的样子

快速验证

同时调整接受能力与等待容量

延伸阅读

来源

IPv6 路由器报告超大报文，由源端决定怎样适应路径

坏掉的样子

快速验证

推荐分片之前，先诊断大小与方向

来源

TCP 保活探测空闲连接

传输层探针不是应用心跳

配置真正承载请求的 socket

坏掉的样子

快速验证

延伸阅读

来源

默认路由匹配最宽范围，不会挽救所有失败路径

坏掉的样子

快速验证

编辑默认路由前检查具体流量

来源

子网前缀影响直连路由，最终路径由路由表选择

坏掉的样子

快速验证

修改掩码前先检查真实路由

来源

BGP 组成了互联网的路由表

AS 路径同时是环路检测和策略信号

为什么这张表大约是一百万条前缀

路径选择是一个固定顺序，不是距离

坏掉的样子

快速验证

来源

TCP 握手建立序列号空间，不是同步两台机器的时钟

坏掉的样子

快速验证

分别诊断建立过程和有效服务

来源

DHCP 只把地址租给你

借用而非拥有地址

续约让租约保持存活

过期即可回收

坏掉的样子