路由 · XB 现场笔记

nginx 前缀在匹配结束前只是候选配置

Mon, 17 Jan 2028 00:00:00 +0000

nginx location 在已选中的 server 内为请求选择配置。对于这里验证的平面前缀与正则结构，精确匹配会结束搜索；否则 nginx 先记住最长匹配前缀，再可能选择第一个匹配的正则。如果没有适用正则胜出，就使用先前记住的前缀。这是一个完整选择过程，不是简单执行配置文件里最先遇到的块，也不是只比较路径看起来有多具体。

坏掉的样子

前缀是字符串前缀，不会自动要求完整路径段。location /api 也能匹配 /apix。如果真正需要的是端点 /api 和 /api/ 下的后代，应明确表达这两个边界。依赖未声明的路径段边界，可能让只是共享开头字母的路径，进入错误处理器、缓存策略或访问规则。配置应反映真实 URL 集合，而不是依靠读者自行补充含义。

最长普通前缀不一定是最终选择。匹配 .php 的正则，可以接管一个也匹配了更详细 API 前缀的请求。把前缀移到正则之前，不会改变基本优先规则。竞争正则之间的声明顺序有意义，普通前缀则主要比较匹配长度，而不是出现位置。因此，单纯整理文本顺序不一定修复实际路由问题。

^~ 在该前缀成为相关层级的最长匹配前缀时，抑制正则搜索。它不是正则运算符，也不是对所有以某个较短标记前缀开头的路径提供无条件保护。嵌套 location 和内部跳转需要额外推理；下面故意使用平面 server 结构，让每次选择都能明确对应一个规则，不把复杂嵌套情况隐藏在简化结论里。

快速验证

下文集成实验的结果保留自历史运行记录；本次修订没有重新执行该实验，不能将这些记录当成本次环境的新实测。

先取得固定 nginx 镜像，再用宿主 Python 和 Docker 运行脚本。实测为 Linux arm64 上的 nginx 1.28.0、Docker 29.3.1。它构建临时配置镜像，用 nginx -t 验证，再通过只发布到宿主回环的端口发送真实 HTTP 请求，最后清理自己的容器、镜像标签和网络，不改动已有站点配置：

from contextlib import contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import http.client,json,socket,subprocess,time,uuid

NGINX='nginx@sha256:552e7481ca93ffccd046aa658dbbed22caefbc09c66fa7cd247cbb90b8a5c609'
PYTHON='python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84'
def docker(*args,check=True):
 result=subprocess.run(['docker',*args],capture_output=True,text=True,timeout=120)
 if check:assert result.returncode==0,result.stderr
 return result
def wait(predicate):
 deadline=time.monotonic()+15
 while time.monotonic()<deadline:
 try:
 if predicate():return
 except OSError:pass
 time.sleep(.1)
 raise AssertionError('fixture did not become ready')

@contextmanager
def lab(configuration,files=None,backend=None):
 name='xbcatm-nginx-'+uuid.uuid4().hex[:10];tags=[name+':proxy',name+':backend'];containers=[name+'-proxy',name+'-backend']
 try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'files').mkdir();(root/'nginx.conf').write_text(configuration)
 for path,content in (files or {}).items():
 target=root/'files'/path;target.parent.mkdir(parents=True,exist_ok=True);target.write_text(content)
 docker('network','create',name)
 if backend is not None:
 (root/'backend.py').write_text(backend)
 (root/'backend.Dockerfile').write_text(f'FROM {PYTHON}\nCOPY backend.py /backend.py\nCMD ["python", "/backend.py"]\n')
 docker('build','--network','none','-f',str(root/'backend.Dockerfile'),'-t',tags[1],str(root))
 docker('run','-d','--name',containers[1],'--network',name,'--network-alias','backend',tags[1])
 wait(lambda:docker('exec',containers[1],'python','-c','import socket;s=socket.create_connection(("127.0.0.1",8081),timeout=.5);s.close()',check=False).returncode==0)
 (root/'Dockerfile').write_text(f'FROM {NGINX}\nCOPY nginx.conf /etc/nginx/nginx.conf\nCOPY files /srv\n')
 docker('build','--network','none','-t',tags[0],str(root))
 docker('run','--rm','--network',name,tags[0],'nginx','-t')
 docker('run','-d','--name',containers[0],'--network',name,'-p','127.0.0.1::8080',tags[0])
 details=json.loads(docker('inspect',containers[0]).stdout)[0]
 binding=details['NetworkSettings']['Ports']['8080/tcp'][0];assert binding['HostIp']=='127.0.0.1';port=int(binding['HostPort'])
 def ready():
 connection=socket.create_connection(('127.0.0.1',port),timeout=.5);connection.close();return True
 wait(ready)
 def request(path,method='GET',headers=None,body=None):
 connection=http.client.HTTPConnection('127.0.0.1',port,timeout=5)
 try:
 connection.request(method,path,body=body,headers=headers or {})
 response=connection.getresponse();return response.status,{k.lower():v for k,v in response.getheaders()},response.read()
 finally:connection.close()
 yield containers[0],request
 finally:
 docker('rm','-f',*containers,check=False);docker('image','rm',*tags,check=False);docker('network','rm',name,check=False)

def config(locations,extra=''):
 return 'worker_processes 1;\nerror_log /tmp/error.log notice;\nevents {}\nhttp {\naccess_log off;\n'+extra+'\nserver { listen 8080; root /srv;\n'+locations+'\n}\n}\n'

locations=r'''
location / { return 200 "fallback"; }
location /api/ { return 200 "api-slash"; }
location /api/admin/ { return 200 "admin"; }
location = /api { return 200 "exact"; }
location /api { return 200 "api-string"; }
location ^~ /static/ { return 200 "static"; }
location ~ \.php$ { return 200 "php-regex"; }
'''
with lab(config(locations)) as (container,request):
 cases={'/api':'exact','/api?x=1':'exact','/apix':'api-string','/api/users':'api-slash','/api/admin/log':'admin','/api/admin/test.php':'php-regex','/static/test.php':'static','/unmatched':'fallback'}
 for path,expected in cases.items():
 status,headers,body=request(path);assert status==200 and body.decode()==expected,(path,status,body)
 print('exact matching ignores the query; ordinary prefixes use longest string match, including /api matching /apix')
 print('a regex overrides the ordinary longest prefix, while the selected ^~ prefix skips that regex')

/api 与 /api?x=1 都返回 exact。查询字符串不参与 location 匹配，因此添加参数不会使精确路径停止匹配。所选块显式返回该标记。精确匹配的作用是选择配置，不天然意味着读取某个文件系统根目录，也不会自动决定调用哪个应用；具体处理动作仍由块内配置确定。

/apix 返回 api-string，证明普通 /api 前缀会超出完整 API 路径段。/api/users 返回 api-slash，因为 /api/ 是更长的匹配前缀。/api/admin/log 返回 admin，进一步展示普通最长前缀选择，不需要依赖这些块在文件中的排列顺序。不同标记使每次选择可被直接观察。

/api/admin/test.php 返回 php-regex。较长的 /api/admin/ 曾是候选，但正则阶段选择了另一块。这正是错误假定“前缀更长就一定胜过通用脚本处理器”时会出现的失败方式。如果只检查状态码成功，错误可能完全被掩盖，因此实验让每个处理器返回可区分正文，而不是都返回同一个正常页面。

/static/test.php 返回 static，因为被选中的 /static/ 带有 ^~，同一个后缀正则不会接管请求。不匹配其他规则的路径则返回宽泛的默认标记。这些案例共同验证真实选择边界，而不仅是证明配置语法被 nginx 接受。语法检查和行为检查回答的问题不同，两者都需要保留。

客户端明确发送路径，并同时核对响应正文和状态。实验不包含真实认证策略或脚本执行，所以标记只证明路由选择。将模式用于受保护端点时，还应测试选择之后真正执行的处理器和访问行为。不能因为路由标记正确，就声称认证、授权或后端功能也已经验证。

审阅所选处理器及其后续转换

先明确目标 URL 家族，再列出精确端点、后代前缀和可能重叠的正则。加入 /apix 等近似路径、相关大小写变体，以及编码或规范化形式。nginx 使用规范化 URI 匹配，仅根据原始请求文本做安全审查，可能漏掉最终生效配置。验证用例应来自真实边界，而不是只挑最普通的成功路径。

检查有效配置，包括被包含的文件和实际选中的虚拟服务器。请求没有进入的 server 中，即使某个 location 写得正确，也无法修复另一个 server 的路由。验证时使用受控响应标记或日志，而不是根据多个处理器都可能返回的熟悉页面来猜测选择。诊断证据需要能区分竞争配置。

最后，考虑 rewrite、index 处理和其他可能触发新 location 搜索的内部跳转。首次选中的块不一定是最终处理器。应测试完整请求路径，并保留足够证据解释初次匹配和最终响应，避免把局部正确误认为整个处理链都符合预期。

来源

nginx core location directive，规范化 URI、精确匹配、前缀与正则选择，已核验 2026-10-15。
How nginx processes a request，虚拟服务器选择与 location 请求处理，已核验 2026-10-15。

Anycast 让路由选择副本

Mon, 01 Nov 2027 00:00:00 +0000

Anycast 让一个地址拥有多个家。多个站点宣告同一个前缀，每个网络按照路由策略选出一条可用路径。本文关注互联网 BGP；本地 Anycast 也可以使用内部路由协议。客户端通常无需先经过全球负载均衡就能到达拓扑上较近的副本。某个站点撤回宣告后，控制面可以收敛到另一个家。这种设计把“就近”和“切换”交给网络完成，但也把策略错误和收敛窗口带到了应用面前。

一个地址，多点宣告

Anycast 把同一个单播地址或前缀配置给相互独立的实例，每个边缘路由器用 BGP 宣告可达性。邻居比较路径，在自己的路由信息库中安装最佳路由，数据包随后沿普通转发路径走向选定的下一跳。应用看到的仍是一个目的地址，实际上却有许多站点可以回答。客户端不需要知道副本列表，运维也可以独立扩容某个站点。

“最近”指路由策略和拓扑意义上的最近，并不保证地理距离最短。本地偏好较高的路径可以胜过物理上更短的路径；本地偏好相同时，通常再偏向 AS path 更短的路径，之后还有厂商和策略相关的决胜条件。运营者可以调整这些属性、做 AS path prepend 或撤回前缀来引流。真正的契约是可达性，而不是承诺每个客户端永远选择同一站点。不同 ISP 看到的路径不同，所以同一时刻两个用户落在不同城市并不矛盾。

路由完成故障切换

站点失去服务或上游时，应当由健康联动的会话撤回路由。上游传播撤回消息，选择仍在宣告的副本。转发路径无需等待新的 DNS 应答，因此整个边缘站点消失后地址仍然有效。BGP 收敛不是瞬时完成的：切换期间可能丢包，不同网络的收敛时间也不同，客户端仍要设置重试和合理的连接超时。把“最终会切过去”写进设计，并不等于承诺零丢包。

Anycast 特别适合无状态或容易重建的协议，例如 DNS、基于 UDP 的发现服务和 CDN 边缘。它也能把攻击面分散到多个站点，但容量和过滤策略必须协同。进程已经死了却仍在宣告的路由，比没有路由更糟，因为流量会被送进黑洞。应把宣告绑定到真实的就绪信号，同时监控控制面可达性和应用响应。撤回机制要有明确的延迟上限，不能只依赖人工登录路由器。

有状态会话会介怀

路由变化后，已经建立的 TCP 连接可能被送往另一个站点。新实例没有旧套接字状态，可能重置连接或丢弃报文。共享后端能保留应用状态，却不能把原来的 TCP 连接自动搬过去，因此客户端仍要接受重连并重建状态；幂等键可以防止重连后重发请求产生重复副作用。一次成功的跟踪并不等于具有粘性；拓扑变化不仅会改变下一条流的选择，也可能让当前流的后续报文到达另一个副本。

可观测性还应记录服务站点、路由年龄和撤回原因。一个全局成功率会掩盖某个区域的黑洞，因为其他区域仍然健康。应从多个网络探测，把 Anycast 地址和站点身份分开记录，并在“站点仍在宣告但服务检查失败”时告警。日志中保留连接建立时的站点，才能解释切换前后的重试和状态差异。

坏掉的样子

路由泄漏或误设的高本地偏好，会把流量吸引到很远的站点；只撤回一部分邻居，则会让一些网络停留在旧路径，表现为不对称丢包而不是干净切换。副本之间的 MTU、防火墙和 ACL 差异，也会制造看似随机的路由故障。服务带本地状态时，用户可能只在控制面已经收敛后才看到连接重置。把一个站点标记为健康，却没有检查回程路径，也会制造只进不出的黑洞。

站点的进程、依赖和回程路径都准备好之前，不要宣告前缀。用专门的演练地址测试撤回，从多个观测点测量收敛，并保留一条非 Anycast 的管理路径。检查路由对象、应用探针和撤回日志的时间线，确认它们描述的是同一次事件。路由是选择机制，只有显式绑定健康检查时才具备应用层健康含义。

快速验证

下面的本地 Go 模型只保留演示所需的两个 BGP 策略字段：本地偏好高者优先，其次 AS path 短者优先。它测试路径决胜、输入顺序无关、策略覆盖、撤回、空候选集和备用站点恢复；没有数据包或 BGP 会话离开进程。

package main

import "fmt"

type route struct {
 name string
 localPref int
 asPath int
 advertised bool
}

// This fixture models only local preference and AS-path length for one prefix.
func best(routes []route) (route, bool) {
 var chosen route
 for _, candidate := range routes {
 if !candidate.advertised {
 continue
 }
 if chosen.name == "" || candidate.localPref > chosen.localPref ||
 (candidate.localPref == chosen.localPref && candidate.asPath < chosen.asPath) {
 chosen = candidate
 }
 }
 return chosen, chosen.name != ""
}

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

func main() {
 routes := []route{
 {name: "tokyo", localPref: 100, asPath: 2, advertised: true},
 {name: "singapore", localPref: 100, asPath: 3, advertised: true},
 }
 chosen, ok := best(routes)
 want(ok && chosen.name == "tokyo", "shorter AS path should win the tie")
 chosen, ok = best([]route{routes[1], routes[0]})
 want(ok && chosen.name == "tokyo", "input order must not beat path length")
 routes[1].localPref = 200
 chosen, ok = best(routes)
 want(ok && chosen.name == "singapore", "local policy should override path length")
 routes[1].advertised = false
 chosen, ok = best(routes)
 want(ok && chosen.name == "tokyo", "withdrawal should select the surviving site")
 routes[0].advertised = false
 _, ok = best(routes)
 want(!ok, "with every announcement withdrawn there is no route")
 _, ok = best(nil)
 want(!ok, "an empty candidate set must not invent a route")
 fallback := route{name: "sydney", localPref: 50, asPath: 4, advertised: true}
 chosen, ok = best(append(routes, fallback))
 want(ok && chosen.name == "sydney", "a backup announcement should recover reachability")
 fmt.Println("PASS: path length, policy priority, withdrawal, empty set, and backup")
}

将程序保存为 anycast_model.go，运行 go run anycast_model.go，并用 gofmt -d anycast_model.go、go run -race anycast_model.go 与 go vet anycast_model.go 检查格式、竞争和静态问题。预期输出是 PASS: path length, policy priority, withdrawal, empty set, and backup。若两个建模字段都相同，模型保留先遇到的候选，因此输入顺序无关只适用于本例的非完全平局路径。模型故意省略后续决胜条件、MED、eBGP/iBGP 规则、community、真实拓扑和收敛计时；它验证的是给定候选路径时的选择，不是互联网在某个时刻已经完成收敛的证明。

来源

RFC 4271：边界网关协议 4，路由选择和路径属性，已核验 2026-09-09。
RFC 4786：Anycast 服务的运行，部署、路由与故障考量，已核验 2026-09-09。

BGP 聚合收窄路由表

Fri, 08 Oct 2027 00:00:00 +0000

聚合可以用一个覆盖前缀，替代若干更具体的路由通告。只有更具体前缀确实受到抑制、且其他对等体没有继续提供它们时，下游表项才会减少。成员不必填满整个汇总范围：几个稀疏子网也能形成一个较大的覆盖块，但该通告同时会吸引发往空洞地址的流量。因此，聚合既是规模问题，也是可达性和地址授权问题。

聚合究竟减少了什么

对等体同时收到三个成员前缀和一条汇总时，仍然持有四条路由。FRR 的 aggregate-address 10.1.0.0/16 summary-only 抑制被覆盖的更具体前缀通告，并不会把它们从聚合路由器自己的 BGP 表删除。生成汇总的前提是 BGP 表中至少有一个符合条件的更具体前缀，仅在其他路由表中存在一条记录还不够。

稳定的汇总可以把部分成员变化挡在下游之外，但这个收益有前提。最后一个成员消失、汇总属性改变，或者出口策略变化，都可能继续产生更新。抑制通告不会修复客户链路，只会改变其他网络获得的故障信息。聚合者仍然需要监控内部成员，不能因为上游只看到一条稳定路由，就认为内部全部可达。

汇总覆盖的地址通常也比列出来的几个子网更多。宣告之前，应检查整个范围的使用授权以及预期的汇总起源 AS。地址对齐、数值相邻、能节省表项，都不是拥有宣告权限的证据。提供商可以在自己的地址分配范围内合法汇总客户网络；成员来自不同起源 AS，并不自动意味着这次聚合非法，关键是整体授权和出口契约。

保留清晰的起源

FRR 的 suppress-map 用路由映射选择哪些更具体前缀受到抑制。as-set 处理的是另一个维度，即怎样表示成员路径中的 AS 信息。AS_SET 是无序集合，并非只包含客户起源号码的清单。历史上的 RFC 4271 在计算 AS 路径长度时，将整个集合计作一个，不会按集合成员数量逐个增加长度。

RFC 9774 已经废弃 AS_SET 与 AS_CONFED_SET。除非运营者为了过渡显式选择其他行为，发言者不得继续通告这些集合，收到含集合的路由时应按撤回处理。应选择明确、获得授权的汇总起源，并配置相应 ROA，不能把 AS_SET 当作常规修补办法。邻居的起源过滤器也不会因为路由器生成了一条汇总，就自动接受这个范围。

坏掉的样子

在选定转发表中的普通目的地址查找，使用最长的已安装匹配前缀。因此，有效的 /24 会覆盖其上方的 /16，不论两者的 BGP 本地优先级谁更高。不过，路由首先必须通过导入策略、下一跳解析和安装过程。BGP 为同一前缀选择候选路径，与转发时在不同前缀之间做匹配，是两个不同阶段。

一个成员消失时，只有失去可用更具体路由的目的地才回落到汇总，健康成员仍可继续转发。某个客户撤回路由，不会天然让汇总覆盖的所有地址同时黑洞。在生成汇总的路由器上，对没有成员路由匹配的地址设置丢弃路径，可以防止数据包顺着默认路由返回上游，进而形成转发环路。

丢弃时是否生成诊断报文，取决于设备和配置，不能保证必然静默，也不能保证 ICMP 一定送达。撤回汇总也不必然等于没有路由，因为另一个覆盖前缀或默认路由可能仍然存在。应该检查真实转发表和相关计数器，而不是只因为看不到某个更具体前缀，就断言汇总本身配置错误。

快速验证

将下面代码交给 Python 3 运行，保持断言开启。它不创建套接字，也不修改路由器配置。两个客户路由位于同一条覆盖丢弃路由之下；这个刻意缩小的模型只隔离最长前缀匹配和成员撤回的影响范围，不实现 BGP 会话、策略交换或者真实收敛过程。

from ipaddress import ip_address, ip_network

routes = {
 ip_network("10.1.0.0/16"): "discard",
 ip_network("10.1.4.0/24"): "customer-a",
 ip_network("10.1.7.0/24"): "customer-b",
}
def lookup(address):
 matches = [prefix for prefix in routes if ip_address(address) in prefix]
 if not matches:
 return "no-route"
 return routes[max(matches, key=lambda prefix: prefix.prefixlen)]

assert lookup("10.1.4.9") == "customer-a"
assert lookup("10.1.7.9") == "customer-b"
del routes[ip_network("10.1.4.0/24")]
assert lookup("10.1.4.9") == "discard"
assert lookup("10.1.7.9") == "customer-b"
print("withdraw A: A=discard, B=customer-b")
del routes[ip_network("10.1.0.0/16")]
assert lookup("10.1.4.9") == "no-route"
assert lookup("10.1.7.9") == "customer-b"
print("withdraw summary: A=no-route, B=customer-b")

第一行输出表示客户甲回落到丢弃路由，而客户乙仍然命中自己的表项。删除汇总之后，甲变成没有路由，这是因为夹具刻意没有放入默认路由；乙仍独立可达。可以把增加默认表项作为后续练习，观察无路由结果如何变化，避免把这个特定模型的结果误写成所有网络都会遵循的行为。

在获得授权的实验路由器上，还应分别检查收到、选中、发出以及实际安装的路由，再撤回一个成员进行对照。确认汇总是否保留、属性是否改变，以及目的地址最终命中哪条路由。真实路由器集成与转发效果需要那一步实验；这里的 Python 断言仅证明所声明的查找模型，不能代替硬件转发表或协议实现验证。

来源

RFC 4271 BGP-4，定义 ATOMIC_AGGREGATE、AGGREGATOR 与 AS_SET，已核验 2026-09-16。
FRR BGP 路由聚合，说明聚合生成、成员抑制与 AS-set 选项，已核验 2026-09-16。
RFC 4632 CIDR，无类前缀与最长匹配转发模型，已核验 2026-09-16。
RFC 9774：废弃 AS_SET，更新的聚合与起源要求，已核验 2026-10-15。

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

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。

BGP 组成了互联网的路由表

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

BGP 在独立运营的网络之间交换可达性，但互联网并不存在一张统一、权威的转发表。每台路由器都学习经过策略过滤的视图，选择路由，再尝试把可用下一跳安装进转发系统。两台路由器为同一个前缀选择不同路径，完全可能是正常情况。理解 BGP，需要把通告、选路策略和数据包转发分开，不能把它们合并成一个放之四海皆准的答案。

AS 路径同时承载历史与策略

普通 eBGP 场景中，路由器向外宣告时会在 AS 路径前加上自己的号码。接收方通常排除已经包含自己 AS 的路径，用于避免自治系统之间的环路，但存在显式配置的例外和协议扩展。自治系统内部的 iBGP 通常不再增加 AS 号码；它的转发通告限制及路由反射器规则处理的是另一类内部环路问题。

AS_PATH 还是过滤和选路的输入。重复前插可能让一条路由在看重路径长度的网络里吸引力下降，却不能推翻对方优先级更高的本地策略。也没有一条通用规则说，前插之后路由就会被过滤。必须结合真正的运营商策略、客户授权和接收条件，理解该字段在当前网络里的作用。

LOCAL_PREF 会作为属性分发给内部 BGP 对等体，通常不传给外部对等体。部分实现提供的 weight 则只属于本地路由器，也不是标准 BGP 路径属性。把两者都描述成不会进入更新报文，会掩盖关键区别：本地优先级可以影响自治系统内其他设备的决策，而 weight 的效果一般局限在一台路由器。

先比较同一个前缀

最佳路径过程比较的是同一前缀的多个候选路径。具体顺序取决于实现和配置，包括路径资格、本地策略、AS 路径长度、MED 比较范围及下一跳可达性。某个产品的 weight 优先列表并不是协议完整定义。MED 通常在来自相同邻居 AS 的路径之间比较，但实现可以提供改变这一行为的选项，不能把默认规则写成不可改变的限制。

之后，转发过程在已安装目的路由中做最长前缀匹配。一个 /25 与覆盖它的 /24，并不是通过同一套最佳路径平局规则互相竞争。只要两者均被接受并安装，前者就匹配那一半地址，即使后者的 AS 路径更短。策略路由或其他额外转发机制还需要分别检查，不能从这条普通查找规则推断全部设备行为。

路由表规模同样依赖观测点、地址族与时间。独立前缀数量、收到的全部候选路径以及硬件 FIB 表项，是不同统计口径。聚合可以减少部分通告，但多宿主和流量工程可能确实需要具体路由。仅按地址算出的可聚合数量，并不能证明相应的全部策略也能保留，因此不应把一个动态快照当作永久容量门槛。

坏掉的样子

未经授权的起源通告属于前缀劫持；路由泄漏则是把学到的可达性传播到预期策略范围之外。两者可能重叠，却不是同义词。下面假设的 /25 只展示查找效果，真实网络可能已经通过前缀长度、起源或客户过滤拒绝它。发现陌生更具体前缀值得调查，但不等于已经证明攻击正在生效。

RPKI 起源验证将通告前缀、允许的起源和最大长度，与验证过的记录进行匹配。它不认证整条 AS 路径，也不判断每一个出口关系是否合法。合法起源的路由仍可能发生泄漏。因此，需要将起源验证与适当的导入、导出策略配合，并监控变化，不能笼统声称所有更新都未经检查便向全球扩散。

健康会话也不能证明转发安装成功。硬件容量不足、下一跳无法解析，或设备编程失败，都可能使控制平面路由无法真正使用。失败后的行为取决于平台，不保证自动退回软件转发。容量规划要看设备实际分区、启用特性和安装遥测，而不是相信一个普遍适用的百万表项目标。排查时应保留相关错误和差异。

快速验证

用 Python 3 运行下面夹具，保持断言开启。前半段故意只模拟本地优先级和 AS 路径长度，其他选路条件视为相同；后半段则使用独立的转发表。代码采用文档专用地址，不创建会话、监听或网络通告，也不会接触任何真实路由器。

from ipaddress import ip_address, ip_network

paths = [
 {"name": "policy-first", "localpref": 200, "path": [64501, 64502, 64503]},
 {"name": "shorter", "localpref": 100, "path": [64504, 64503]},
]
def choose(candidates):
 return min(candidates, key=lambda p: (-p["localpref"], len(p["path"])))
assert choose(paths)["name"] == "policy-first"
paths[1]["localpref"] = 200
assert choose(paths)["name"] == "shorter"

routes = {ip_network("198.51.100.0/24"): "legitimate",
 ip_network("198.51.100.128/25"): "unexpected"}
def forward(address):
 matches = [p for p in routes if ip_address(address) in p]
 return routes[max(matches, key=lambda p: p.prefixlen)]
assert forward("198.51.100.20") == "legitimate"
assert forward("198.51.100.200") == "unexpected"
print("same prefix: local preference first, then path length")
print("different prefixes: lower half legitimate, upper half unexpected")

本地优先级还不相同时，较长路径获胜；将优先级调成一致后，才由较短路径获胜。另一个独立查找中，低地址命中合法 /24，高地址命中意外 /25。这些输出解释的是两个不同决策，不能宣称已经实现或者验证真实 BGP。实际诊断仍需关联接收和发出的路径、选中路由、硬件安装状态，以及获得授权的客户端探测结果。

来源

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。
FRR BGP 路径选择，实现特定的选路控制与诊断，已核验 2026-10-15。

proxy_pass 既选择上游，也映射请求 URI

Fri, 02 Apr 2027 00:00:00 +0000

nginx proxy_pass 选择上游目标，也影响实际发送的请求 URI。关键区别是指令是否包含 URI 部分，而不只是文本末尾有没有斜杠。在普通前缀 location 中，字面目标 URI 会替换匹配到的规范化前缀；仅含地址的目标，在请求没有被重写时，可以传递原始请求 URI。理解这两个分支，才能准确预测后端看到的路径。

坏掉的样子

应用只处理 /users，代理却转发 /api/users，即使网络连接成功，也可能得到 404。相反，应用期待公共前缀，而代理把它移除，也会出现错误。只比较客户端状态和上游可达性，无法定位这类问题；需要检查后端真正收到的方法、路径、查询和主机名。成功建立连接并不等于协议内容符合应用契约。

斜杠边界属于字面替换的一部分。以 /v1 结尾的目标仍然包含 URI，所以在 /join/item 中替换 /join/ 后会得到 /v1item，不会因为目标没有末尾斜杠就保留原路径。按被替换前缀和剩余后缀推演，比“有没有末尾斜杠”这句通用口诀更准确，也能解释多段内部路径的映射。

变量会引入另一条文档规定的分支。变量提供的代理 URL 包含 URI 时，使用的是给定 URI，而不是普通字面前缀替换规则。正则和命名 location 也没有同样明确的前缀边界。在普通前缀中工作的配置，不能不检查契约就直接复制到这些上下文，否则语法或运行行为都可能发生变化。

快速验证

下文集成实验的结果保留自历史运行记录；本次修订没有重新执行该实验，不能将这些记录当成本次环境的新实测。

使用宿主 Python、Docker，以及固定 nginx 和 Python 镜像运行脚本。实测为 Linux arm64 上的 nginx 1.28.0、Python 3.11.16、Docker 29.3.1。它启动真正回显请求字段的 HTTP 后端，验证 nginx 配置，只把代理发布到宿主回环，结束时清理自己的镜像、容器和网络，不访问真实业务后端：

from contextlib import contextmanager
from pathlib import Path
from tempfile import TemporaryDirectory
import http.client,json,socket,subprocess,time,uuid

NGINX='nginx@sha256:552e7481ca93ffccd046aa658dbbed22caefbc09c66fa7cd247cbb90b8a5c609'
PYTHON='python@sha256:528257d48c1da0dcecc2e725d1ae34498d60c965f1241e39cd6a85a8859bdf84'
def docker(*args,check=True):
 result=subprocess.run(['docker',*args],capture_output=True,text=True,timeout=120)
 if check:assert result.returncode==0,result.stderr
 return result
def wait(predicate):
 deadline=time.monotonic()+15
 while time.monotonic()<deadline:
 try:
 if predicate():return
 except OSError:pass
 time.sleep(.1)
 raise AssertionError('fixture did not become ready')

@contextmanager
def lab(configuration,files=None,backend=None):
 name='xbcatm-nginx-'+uuid.uuid4().hex[:10];tags=[name+':proxy',name+':backend'];containers=[name+'-proxy',name+'-backend']
 try:
 with TemporaryDirectory(prefix=name+'-') as directory:
 root=Path(directory);(root/'files').mkdir();(root/'nginx.conf').write_text(configuration)
 for path,content in (files or {}).items():
 target=root/'files'/path;target.parent.mkdir(parents=True,exist_ok=True);target.write_text(content)
 docker('network','create',name)
 if backend is not None:
 (root/'backend.py').write_text(backend)
 (root/'backend.Dockerfile').write_text(f'FROM {PYTHON}\nCOPY backend.py /backend.py\nCMD ["python", "/backend.py"]\n')
 docker('build','--network','none','-f',str(root/'backend.Dockerfile'),'-t',tags[1],str(root))
 docker('run','-d','--name',containers[1],'--network',name,'--network-alias','backend',tags[1])
 wait(lambda:docker('exec',containers[1],'python','-c','import socket;s=socket.create_connection(("127.0.0.1",8081),timeout=.5);s.close()',check=False).returncode==0)
 (root/'Dockerfile').write_text(f'FROM {NGINX}\nCOPY nginx.conf /etc/nginx/nginx.conf\nCOPY files /srv\n')
 docker('build','--network','none','-t',tags[0],str(root))
 docker('run','--rm','--network',name,tags[0],'nginx','-t')
 docker('run','-d','--name',containers[0],'--network',name,'-p','127.0.0.1::8080',tags[0])
 details=json.loads(docker('inspect',containers[0]).stdout)[0]
 binding=details['NetworkSettings']['Ports']['8080/tcp'][0];assert binding['HostIp']=='127.0.0.1';port=int(binding['HostPort'])
 def ready():
 connection=socket.create_connection(('127.0.0.1',port),timeout=.5);connection.close();return True
 wait(ready)
 def request(path,method='GET',headers=None,body=None):
 connection=http.client.HTTPConnection('127.0.0.1',port,timeout=5)
 try:
 connection.request(method,path,body=body,headers=headers or {})
 response=connection.getresponse();return response.status,{k.lower():v for k,v in response.getheaders()},response.read()
 finally:connection.close()
 yield containers[0],request
 finally:
 docker('rm','-f',*containers,check=False);docker('image','rm',*tags,check=False);docker('network','rm',name,check=False)

def config(locations,extra=''):
 return 'worker_processes 1;\nerror_log /tmp/error.log notice;\nevents {}\nhttp {\naccess_log off;\n'+extra+'\nserver { listen 8080; root /srv;\n'+locations+'\n}\n}\n'

backend=r'''from http.server import BaseHTTPRequestHandler,HTTPServer
import json
class Handler(BaseHTTPRequestHandler):
 def do_GET(self):
 body=self.rfile.read(int(self.headers.get('Content-Length','0')))
 document={'path':self.path,'method':self.command,'body':body.decode(),'headers':{key:self.headers.get(key) for key in ['Host','X-Forwarded-For','X-Real-IP','X-Forwarded-Proto','X-Forwarded-Host']}}
 data=json.dumps(document).encode()
 self.send_response(200);self.send_header('Content-Type','application/json');self.send_header('Content-Length',str(len(data)));self.send_header('X-Backend-Info','fixture-node');self.end_headers();self.wfile.write(data)
 do_POST=do_GET
 def log_message(self,*args):pass
HTTPServer(('0.0.0.0',8081),Handler).serve_forever()
'''

locations=r'''
location /keep/ { proxy_pass http://backend:8081; }
location /strip/ { proxy_pass http://backend:8081/; }
location /replace/ { proxy_pass http://backend:8081/v1/; }
location /join/ { proxy_pass http://backend:8081/v1; }
location /variable/ { set $destination "http://fixture_pool/fixed?chosen=1"; proxy_pass $destination; }
'''
invalid=config(r'location ~ ^/bad/ { proxy_pass http://backend:8081/replacement/; }')
with lab(config(locations,'upstream fixture_pool { server backend:8081; }'),{'invalid.conf':invalid},backend) as (container,request):
 cases={'/keep/item?x=1':'/keep/item?x=1','/strip/item?x=1':'/item?x=1','/replace/item?x=1':'/v1/item?x=1','/join/item?x=1':'/v1item?x=1','/keep/a%2Fb?x=1':'/keep/a%2Fb?x=1','/strip/a%2Fb?x=1':'/a/b?x=1','/variable/item?original=1':'/fixed?chosen=1'}
 for path,expected in cases.items():
 status,headers,body=request(path);assert status==200 and json.loads(body)['path']==expected,(path,status,body)
 invalid_result=docker('exec',container,'nginx','-t','-c','/srv/invalid.conf',check=False)
 assert invalid_result.returncode!=0 and 'cannot have URI part in location given by regular expression' in invalid_result.stderr
 print('no URI preserves the original path; a literal URI replaces the normalized matching prefix, including its slash boundaries')
 print('a variable-supplied URI is used as specified; regex-location URI replacement is rejected by nginx -t')

/keep/ 中仅含地址的目标，把 /keep/item?x=1 原样转发。/strip/ 中以 / 作为目标 URI，则转发 /item?x=1。这两个字面示例都保留查询参数。证据来自后端 JSON 响应，而不是根据 nginx 处理前的公共 URL 猜测。回显字段让代理转换直接可见，也便于把路径错误与连接失败分开。

/replace/ 把前缀映射为 /v1/，所以 /replace/item?x=1 变成 /v1/item?x=1。/join/ 目标故意少一个分隔斜杠，结果为 /v1item?x=1。两个请求都成功到达后端，但路径不同。这说明 TCP 或 HTTP 成功不能证明路由映射正确，后端如果存在宽泛默认路由，还可能把错误进一步隐藏起来。

编码分隔符揭示规范化边界。仅含地址时，/keep/a%2Fb?x=1 仍以编码形式到达后端；通过规范化前缀替换，/strip/a%2Fb?x=1 则变成 /a/b?x=1。这会改变应用划分路径段的方式。当编码标识符或访问边界依赖这些分隔符时，需要让代理和应用的路径解释保持一致，并用实际字节请求验证。

变量示例引用预先定义的上游组，并提供 /fixed?chosen=1 作为目标 URI。请求 /variable/item?original=1 最终恰好到达这个固定 URI，原后缀和查询不会自动追加。使用已知上游组，也让这个实验与任意逐请求主机名解析及其 resolver 要求区分开，不把不同目标选择方式混成一个行为结论。

第二份配置故意在正则 location 中使用带 URI 部分的代理目标，nginx -t 会报告文档规定的 URI 限制并拒绝配置。实验不会用这个无效文件替换正在工作的配置。因此，除了成功路径，还验证了真实配置失败，而不是把所有错误都归结成运行后才出现的后端 404。

把每条公共到后端的映射作为契约

对每个代理 location，写清公共前缀、是否有替换 URI，以及预期后端路径和查询。测试应包含边界斜杠和编码形式。如果代理前有 rewrite 改变 URI，也要重新检查仅地址形式：转发原始请求取决于是否仍在处理原始 URI，不是对所有重写请求都成立的无条件承诺。配置组合会改变分支，不能只孤立看一行。

目标选择应限制在预期后端内。来自不可信请求数据的变量，不应成为任意访问其他主机的权限。命名上游组、显式映射和拒绝行为，应依据应用真实路由需求配置，不能默默接受未知目的地。路径转换正确与目标选择安全，是相关但不同的检查项，需要分别有证据。

转发头、连接复用、超时和上游 TLS 应按各自契约配置。resolver 不是能让变量目标或 keepalive 一概正确的开关。应分别测试这些行为，并保留后端观察来证明 URI 映射，避免用未经测量的性能或解析假设替代本来可以直接验证的请求内容。

来源

nginx proxy_pass reference，URI 替换、原始请求转发、变量目标与正则限制，已核验 2026-10-15。
nginx core location matching，代理处理前的规范化前缀选择，已核验 2026-10-15。
nginx upstream module，命名上游组与后端选择，已核验 2026-10-15。

路由 · XB 现场笔记

nginx 前缀在匹配结束前只是候选配置

坏掉的样子

快速验证

审阅所选处理器及其后续转换

来源

Anycast 让路由选择副本

一个地址，多点宣告

路由完成故障切换

有状态会话会介怀

坏掉的样子

快速验证

延伸阅读

来源

BGP 聚合收窄路由表

聚合究竟减少了什么

保留清晰的起源

坏掉的样子

快速验证

来源

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

坏掉的样子

快速验证

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

来源

BGP 组成了互联网的路由表

AS 路径同时承载历史与策略

先比较同一个前缀

坏掉的样子

快速验证

来源

proxy_pass 既选择上游，也映射请求 URI

坏掉的样子

快速验证

把每条公共到后端的映射作为契约

延伸阅读

来源