代理 · XB 现场笔记

微缓存短暂复用新鲜条目，并显式合并并发未命中

Sun, 12 Mar 2028 00:00:00 +0000

微缓存让可复用响应保持很短的新鲜度寿命，常见尺度是几秒。在这个窗口里，请求同一选中表示的后续访问可以复用新鲜条目。响应可能落后于源站刚发生的更新，但不能仅因为它来自缓存，就称它在 HTTP 意义上已经过期。何时过期、是否允许提供过期内容、如何协调并发填充，是三个不同策略，需要分别定义。

坏掉的样子

TTL 短并不意味着共享响应对所有用户都安全。如果个性化请求读取或填充通用缓存条目，一个用户的表示就可能在另一个上下文里被交付。proxy_cache_bypass 根据条件禁止从缓存读取；proxy_no_cache 根据条件禁止保存响应。只控制其中一侧，可能让另一条路径不符合预期隐私边界。读取已有公开条目和保存新私有响应都需要考虑。

缓存键决定哪些请求共享响应。忽略有意义的查询参数或主机维度，可能合并不同表示；把任意变化数据全部放进键，又可能让复用失效。下面实验只有一个后端 authority，并保留包含参数的完整请求 URI。真实服务如果按租户、语言或其他输入改变内容，就必须确定自己的表示身份，不能把示例键当成适用于所有应用的通用公式。

仅仅启用缓存，也不保证冷启动突发只产生一次回源。在任何响应保存完成前，多个请求可能同时未命中同一条目。proxy_cache_lock 负责协调新条目的填充，并有有限的超时和年龄控制。这个锁不是 TTL，缩短新鲜度寿命也不会隐式开启锁。新鲜条目复用与并发未命中合并，需要通过不同对照才能验证。

快速验证

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

将脚本保存为 check-microcache.py，准备 Python、Docker 和固定镜像后执行。记录环境为 Linux arm64 上的 nginx 1.28.0。可丢弃后端报告每条路径的请求计数，nginx 使用两秒有效期，并显式设置 Cookie 与 Authorization 绕过条件。监听仅发布到宿主回环，使用的会话和授权值都是公开测试标记，不连接真实账户：

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_bytes(content if isinstance(content,bytes) else content.encode())
 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()
 request.port=port
 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'
from concurrent.futures import ThreadPoolExecutor
import threading
backend=r'''
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
from urllib.parse import urlsplit,parse_qs
import json,threading
lock=threading.Lock();counts={};gates={'/lock':threading.Event(),'/nolock':threading.Event()}
class Handler(BaseHTTPRequestHandler):
 protocol_version='HTTP/1.1'
 def log_message(self,*args):pass
 def do_GET(self):
 parsed=urlsplit(self.path)
 if parsed.path=='/control/state':
 with lock:data=dict(counts)
 elif parsed.path=='/control/release':
 gates[parse_qs(parsed.query)['path'][0]].set();data={'released':True}
 else:
 with lock:counts[self.path]=counts.get(self.path,0)+1;count=counts[self.path]
 if parsed.path in gates:assert gates[parsed.path].wait(15)
 data={'path':self.path,'count':count,'cookie':self.headers.get('Cookie'),'authorization_present':bool(self.headers.get('Authorization'))}
 body=json.dumps(data,sort_keys=True).encode();self.send_response(200)
 if parsed.path=='/cookie':self.send_header('Set-Cookie','fixture=public-example; Path=/')
 if parsed.path=='/private':self.send_header('Cache-Control','private')
 if parsed.path=='/no-store':self.send_header('Cache-Control','no-store')
 self.send_header('Content-Type','application/json');self.send_header('Content-Length',str(len(body)));self.end_headers();self.wfile.write(body)
ThreadingHTTPServer(('0.0.0.0',8081),Handler).serve_forever()
'''
extra='''
proxy_cache_path /tmp/cache levels=1:2 keys_zone=pages:1m inactive=30s max_size=10m;
map $http_cookie $skip_cookie { default 1; "" 0; }
map $http_authorization $skip_auth { default 1; "" 0; }
proxy_cache pages; proxy_cache_key "$scheme|$proxy_host|$request_uri"; proxy_cache_valid 200 2s;
proxy_cache_bypass $skip_cookie $skip_auth; proxy_no_cache $skip_cookie $skip_auth;
proxy_cache_lock on; proxy_cache_lock_timeout 5s; proxy_cache_lock_age 5s;
add_header X-Cache $upstream_cache_status always;
'''
locations='''
location /control/ { proxy_cache off; proxy_pass http://backend:8081; }
location = /nolock { proxy_cache_lock off; proxy_pass http://backend:8081; }
location / { proxy_pass http://backend:8081; }
'''
with lab(config(locations,extra),backend=backend) as (_,request):
 def get(path,headers=None):
 status,h,b=request(path,headers=headers);assert status==200;return h.get('x-cache'),json.loads(b)
 results={}
 first=get('/item?x=1');second=get('/item?x=1');assert first[0]=='MISS' and second==('HIT',first[1])
 other=get('/item?x=2');assert other[0]=='MISS' and other[1]['path']!=first[1]['path']
 results['fresh']=[first[0],second[0]];results['different_query']=other[0]
 for name,headers in [('cookie',{'Cookie':'session=public-fixture'}),('authorization',{'Authorization':'Bearer public-fixture'})]:
 private=get('/item?x=1',headers);assert private[0]=='BYPASS' and private[1]!=first[1]
 assert get('/item?x=1')==('HIT',first[1])
 new='/new-'+name;assert get(new,headers)[0]=='BYPASS'
 public=get(new);assert public[0]=='MISS' and public[1]['cookie'] is None and not public[1]['authorization_present']
 results[name]={'warm_key':'BYPASS','public_after_private_miss':public[0]}
 for path in ['/cookie','private','no-store']:
 path='/'+path.lstrip('/');a=get(path);b=get(path)
 assert a[0]==b[0]=='MISS' and a[1]['count']==1 and b[1]['count']==2
 results[path]=[a[0],b[0]]
 deadline=time.monotonic()+6
 while time.monotonic()<deadline:
 value=get('/item?x=2')
 if value[0]=='EXPIRED':break
 assert value[0]=='HIT';time.sleep(.15)
 else:raise AssertionError('TTL did not expire')
 assert value[1]['count']==2;results['after_ttl']={'status':value[0],'count':value[1]['count']}
 for path,number,origin_count in [('/lock',6,1),('/nolock',4,4)]:
 barrier=threading.Barrier(number+1)
 def client():barrier.wait();return get(path)
 with ThreadPoolExecutor(max_workers=number) as pool:
 futures=[pool.submit(client) for _ in range(number)];barrier.wait()
 wait(lambda:get('/control/state')[1].get(path)==origin_count)
 time.sleep(.3);before=get('/control/state')[1][path]
 assert before==origin_count and not any(f.done() for f in futures)
 get('/control/release?path='+path);responses=[f.result(timeout=10) for f in futures]
 assert get('/control/state')[1][path]==origin_count
 statuses=sorted(r[0] for r in responses)
 if path=='/lock':assert statuses==['HIT']*5+['MISS'] and all(r[1]==responses[0][1] for r in responses)
 else:assert statuses==['MISS']*4
 results[path]={'origin_requests_while_held':before,'cache_statuses':statuses}
 print(json.dumps(results,sort_keys=True))

首次公开请求 /item?x=1 报告 MISS，下一次报告 HIT，并保留相同后端结果。/item?x=2 有自己的 MISS，响应中的路径也不同。持续检查第二个条目，最终观察到 EXPIRED，后端计数变为二。这依据服务器时钟观察实际过期，不假定精确到亚秒的切换时刻；测试关注状态变化及重新计算，而不是某个固定睡眠值。

携带示例会话 Cookie 或授权标记时，即使公开条目已经预热，请求仍报告 BYPASS。之后的公开请求仍返回原公开 HIT。另一个对照先用这些头访问尚未出现的键，再公开访问；公开请求结果是 MISS，证明之前私有上下文的响应没有填充可复用条目。这样同时覆盖了绕过读取和禁止保存，而不只是证明某次私有请求到达后端。

后端带有 Set-Cookie、Cache-Control: private 或 Cache-Control: no-store 的响应，各自连续两次都报告 MISS，源站计数也增加。配置没有忽略这些响应控制。这区分了客户端上下文触发的绕过策略和源站声明的存储限制；不能以缓存只保留几秒为理由，覆盖其中任何一种隐私信号。是否允许共享应先于寿命长短判断。

对于开启锁的冷条目，六个客户端同时开始，后端故意暂不返回响应。放行前后端只看到一次请求；放行后，一个客户端报告 MISS，五个报告 HIT，并得到相同结果。对于另一个关闭锁的条目，四个被保持的客户端产生四次回源，全部报告 MISS。受控放行使重叠的未命中直接可见，而不是从总耗时推测是否发生请求合并。

分别决定新鲜度与过载行为

本实验的两秒设置用于符合条件的 200 响应，相关源站缓存头可以优先于配置有效期。应先决定哪些响应能共享，再选择寿命，并让缓存键对应真正改变内容的输入。高命中率不能证明选中的表示正确；如果键把不同用户或不同内容合并，命中率甚至可能很好，但语义已经错误。验证内容身份和减少回源需要一起进行。

等待锁的请求用额外等待换取较少源站工作。本实验在锁限制内放行后端，并没有证明限制到期或后端失败时仍永远只有一次回源。应结合服务可接受延迟和失败行为，审阅锁等待超时、锁年龄以及可能采用的过期响应策略。是否允许返回过期条目，不能由已经设置短 TTL 这一事实代替决定。

观察缓存状态时，同时核对源站计数和响应身份。MISS 表示请求表示没有作为缓存命中提供，BYPASS 则标明这里显式排除读取的路径。新鲜 HIT、EXPIRED 后重新填充，以及有意提供过期内容，不应混成一个笼统的“已缓存”结果。它们对正确性与后端负载的影响不同，正是需要分别测量和解释的原因。

来源

nginx proxy module，缓存有效期、缓存锁、绕过读取、禁止保存与响应头控制，已核验 2026-10-15。
nginx content caching guide，缓存键、状态观察与缓存行为，已核验 2026-10-15。
RFC 9111 HTTP Caching，新鲜与过期响应，以及 private、no-store 指令，已核验 2026-10-15。

代理键把身份与含义分开

Wed, 02 Feb 2028 00:00:00 +0000

代理主键把一行记录的身份与可能变化的业务值分开。客户修改邮箱时，订单仍引用同一个客户编号，而不必跟着邮箱一起改引用。这对于易变或较宽的业务键很有用，但稳定性来自数据库约束与应用规则，不是“自动生成”四个字本身。一个生成的数字不会天然不可修改、保密、全局唯一，也不能代替访问授权。

生成身份与约束唯一性

PostgreSQL identity 列从关联序列取得默认值。GENERATED ALWAYS AS IDENTITY 会拒绝普通显式赋值，GENERATED BY DEFAULT 则允许调用方提供值。即使使用 ALWAYS，导入时仍可通过 OVERRIDING SYSTEM VALUE 显式覆盖。两种形式都不会单独保证值唯一；需要拒绝重复标识时，仍须声明 PRIMARY KEY 或 UNIQUE 约束。

主键同时保证唯一与非空，并提供可供引用使用的索引。Identity 负责怎样生成默认值，约束负责哪些最终值允许存储，这两项职责不能混淆。导入时尤其如此：显式写入一个很大的编号，不会自动把序列推进到那个位置。若没有协调序列状态，后续生成值可能最终与导入行相撞，直到主键报错才暴露问题。

单独保留业务唯一规则

代理编号不会阻止相同业务实体重复出现。如果邮箱是唯一登录标识，应继续保留明确的唯一约束，并先决定规范化规则。普通 text 的 UNIQUE 使用该列的比较语义，不会暗中替应用处理大小写折叠、空白或各种邮箱等价规则。迁移之前就要明确这些行为，否则数据库认为不同的值，应用可能认为是同一账号，或者反过来。

子表如果不能出现悬空引用，就需要真实的外键约束。邮箱不是引用键时，修改它不会改变订单指向的客户，因为订单保存的是 id。这缩小了这一项修改的范围，却不能承诺所有业务改名都变成简单操作：搜索索引、审计记录、外部集成和缓存仍可能依赖邮箱，需要按实际调用链更新。数据模型只解决它真正覆盖的关系。

坏掉的样子

把序列编号当成创建顺序或提交顺序，在并发下会产生错误结果。多个事务可能先后取号却反向提交，失败语句也可能留下空洞。展示排序应使用明确的时间字段并补充稳定决胜字段，不能根据编号连续性推断是否丢单。顺序编号也容易被猜到；即使另加不透明的公开标识，授权仍必须检查请求者与资源之间的关系，不能靠“不容易猜”保护数据。

导入时覆盖 identity 是另一种陷阱。插入的显式编号远大于序列当前位置，序列仍可能继续从较小值生成，最终碰到已有主键。应在受控导入流程中协调序列状态，并排除或正确协调并发写入。另开一个会话查询 max(id) 再加一，不是并发安全的分配算法；两个调用方可能同时得到相同结果。

迁移还可能意外删掉原自然键承担的唯一规则。换键之前要检查重复值与 null，保留真正需要的业务唯一约束，并沿所有真实引用更新。也不必仅因代理键常见就给每张表增加一列和一个索引；稳定自然键如果已经准确表达契约，也可能是合适选择。决策依据应是业务值的可变性、引用范围和数据语义。

外键不会自动为引用方字段建立索引。users 主键支持检查客户是否存在，但查找这个客户的订单是另一条访问路径。应根据实际关联，以及父行更新或删除时的检查需要，评估 orders.user_id 上的索引；不能因为写了 REFERENCES，就推断子表索引也已创建。这个区别在引用数量增长后尤其值得检查。

快速验证

把下面代码保存为 identity.sql，运行 psql -X -v ON_ERROR_STOP=1 -f identity.sql，连接一个可丢弃的 PostgreSQL 18 数据库。实验使用临时表并在末尾回滚，不依赖已有 users 表，也不需要读取真实用户邮箱。所有地址都采用保留的 example.test 域名，仅用于构造可重复的数据。

\set ON_ERROR_STOP on
BEGIN;
CREATE TEMP TABLE users (
 id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
 email text NOT NULL UNIQUE
);
CREATE TEMP TABLE orders (
 id integer PRIMARY KEY,
 user_id bigint NOT NULL REFERENCES users(id)
);
INSERT INTO users(email) VALUES ('a@example.test') RETURNING id AS owner_id \gset
INSERT INTO orders VALUES (1, :owner_id);
UPDATE users SET email='renamed@example.test' WHERE id=:owner_id;
SELECT u.id, u.email FROM orders o JOIN users u ON u.id=o.user_id;
DO $$ BEGIN
 INSERT INTO users(email) VALUES ('renamed@example.test');
 RAISE EXCEPTION 'duplicate email accepted';
EXCEPTION WHEN unique_violation THEN RAISE NOTICE 'duplicate email rejected';
END $$;
DO $$ BEGIN
 INSERT INTO users(id,email) VALUES (99,'manual@example.test');
 RAISE EXCEPTION 'explicit identity accepted without override';
EXCEPTION WHEN generated_always THEN RAISE NOTICE 'explicit identity rejected';
END $$;
INSERT INTO users(id,email) OVERRIDING SYSTEM VALUE VALUES (100,'import@example.test');
INSERT INTO users(email) VALUES ('next@example.test') RETURNING id;
DO $$ BEGIN
 IF (SELECT email FROM users u JOIN orders o ON u.id=o.user_id)
 IS DISTINCT FROM 'renamed@example.test' THEN
 RAISE EXCEPTION 'rename broke the reference';
 END IF;
 IF (SELECT id FROM users WHERE email='next@example.test') IS DISTINCT FROM 3 THEN
 RAISE EXCEPTION 'unexpected identity sequence position';
 END IF;
END $$;
ROLLBACK;

邮箱修改后，订单仍然关联到编号一的客户。重复邮箱被唯一约束拒绝，而这次失败插入已经消耗了序列值二。没有覆盖子句的显式 identity 插入被拒绝；受控覆盖随后写入编号一百，但下一条正常生成记录拿到的是三，说明显式导入没有重定位序列。代码同时断言引用仍然正确，以及这个隔离夹具中的具体序列结果。

本轮 PostgreSQL 18.6 单用户模式复现了这些 SQL 结果。psql 变量替换为实际观察到的一，未验证客户端 gset 行为。最后回滚清理实验对象，不能据此宣称普通业务事务中的序列不会有空洞。这个练习把生成机制、主键约束、外键完整性、业务唯一性与访问控制分开说明，避免把所有涉及 id 的规则都误认为由 identity 列自动完成。真正迁移时还要验证既有数据与并发写入流程，而不是只复制建表语句。

来源

PostgreSQL identity 列，生成模式与唯一性限制，已核验 2026-10-15。
PostgreSQL 约束，主键与引用完整性，已核验 2026-10-15。
PostgreSQL 序列函数，不随事务回滚的分配与空洞，已核验 2026-10-15。

CONNECT 方法打开一条裸隧道

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

CONNECT 请求代理建立隧道，并不让代理从数据路径上消失。准入成功之后，代理仍然向两个方向转发字节，并管理套接字、缓冲区和故障处理。CONNECT 本身不提供加密；HTTPS 是在这条隧道内部另行建立并验证 TLS 会话，不能把两个阶段的成功混为一谈。

在正确的边界切换语义

HTTP/1.1 的 CONNECT 目标是 server.example:443 这样的主机与端口组合，而不是普通路径或完整 HTTPS URL。端口必须明确给出。成功的 2xx 响应在响应头结束后立即切换到隧道模式；非成功响应则表示隧道尚未建立，此时不能直接开始把后续内容当作目标服务的数据。

成功的 CONNECT 响应不能携带 Content-Length 或 Transfer-Encoding。随后出现的字节属于隧道，而不是一份用长度界定的 HTTP 响应正文。自己实现中继时，这一点尤其重要：HTTP 解析器已经缓冲的字节也可能属于隧道，不能因为切换到原始套接字，就把此前预读的数据丢掉。

客户端随后可以穿过中继，与目标协商 TLS。代理返回 200 只说明允许并建立了隧道，不负责证明目标证书有效，也不证明应用请求成功。客户端仍须检查信任链、主机名与应用响应。TLS 拦截属于另一种部署方式，需要客户端信任会终止 TLS 的中间实体，不能把它与普通盲转发混为同一种安全模型。

看不见正文，仍然占用资源

盲中继不必解释加密的应用内容，但仍能观察目标地址、字节量、时序和关闭行为。它可以落实连接预算、超时、流量限制，以及撤销准入之后的断开操作。无法读取 TLS 内部的 HTTP 消息，不等于失去所有运营控制，更不等于不再承担带宽和描述符成本。

真正的正向代理应验证调用方身份，并限制目的地。任意主机和端口访问，可能暴露内部服务，或被用于其他协议的滥用。按主机名放行时，还必须考虑地址解析策略：通过名称检查，并不自动证明最终拨号的 IP 地址符合约束。本地实验只允许一个预先确定的环回地址与端口，因此没有引入任意目标的解析和转发能力。

坏掉的样子

代理可能在上游尚未连通时就返回 200，可能丢弃解析器缓冲的字节，也可能在待转发数据尚未送出时，过早关闭另一个方向。这些错误看起来可能像证书配置正确却仍然失败的 TLS 握手。排障时，应分别记录准入失败、隧道传输失败、TLS 身份验证失败和源站 HTTP 失败。

Go 的 HTTP/1.1 连接一旦被 Hijack，生命周期就交给处理函数负责，普通 HTTP 服务端不会再管理它。请求上下文也不能代替隧道清理，需要显式管理两个复制方向和截止时间。普通服务端停机不会自动关闭已经接管的连接，生产停机需要记录这些连接，并显式排空或关闭，避免遗漏长连接。固定的绝对期限限制的是连接总寿命，并不是每收到一批流量就自动续期的空闲超时；两者不能使用同一个解释。

快速验证

保存为 connect_probe.go，使用 Go 1.23 或更新版本运行 go run connect_probe.go。实验建立环回 HTTP/1.1 代理和 TLS 1.3 源站，只允许源站的精确主机端口组合。客户端信任这台测试服务的证书，不关闭证书验证，也不修改系统信任库。

package main

import (
 "context"
 "crypto/tls"
 "crypto/x509"
 "errors"
 "fmt"
 "io"
 "log"
 "net"
 "net/http"
 "net/http/httptest"
 "net/url"
 "runtime"
 "sync/atomic"
 "time"
)

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

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

func main() {
 var handled, admitted, denied, connectStatus atomic.Int64
 origin := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 handled.Add(1)
 check(r.TLS != nil && r.TLS.Version == tls.VersionTLS13, "origin requires TLS 1.3")
 fmt.Fprint(w, "through the tunnel")
 }))
 origin.Config.ErrorLog = log.New(io.Discard, "", 0) // Expected wrong-name handshake failure.
 origin.TLS = &tls.Config{MinVersion: tls.VersionTLS13, MaxVersion: tls.VersionTLS13}
 origin.StartTLS()
 defer origin.Close()
 target, err := url.Parse(origin.URL)
 must(err)
 relayed := make(chan [2]int64, 3)
 proxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 if r.Method != http.MethodConnect {
 http.Error(w, "CONNECT required", http.StatusMethodNotAllowed)
 return
 }
 if r.Host != target.Host || r.URL.Host != target.Host {
 denied.Add(1)
 http.Error(w, "target denied", http.StatusForbidden)
 return
 }
 upstream, err := net.DialTimeout("tcp", target.Host, time.Second)
 must(err)
 defer upstream.Close()
 downstream, buffered, err := w.(http.Hijacker).Hijack()
 must(err)
 defer downstream.Close()
 admitted.Add(1)
 deadline := time.Now().Add(3 * time.Second)
 must(upstream.SetDeadline(deadline))
 must(downstream.SetDeadline(deadline))
 _, err = buffered.WriteString("HTTP/1.1 200 Connection Established\r\n\r\n")
 must(err)
 must(buffered.Flush())
 upDone := make(chan int64, 1)
 go func() {
 count, _ := io.Copy(upstream, buffered) // Preserve already-buffered tunnel bytes.
 _ = upstream.(*net.TCPConn).CloseWrite()
 upDone <- count
 }()
 count, _ := io.Copy(downstream, upstream)
 _ = downstream.(*net.TCPConn).CloseWrite()
 relayed <- [2]int64{<-upDone, count}
 }))
 defer proxy.Close()
 proxyURL, err := url.Parse(proxy.URL)
 must(err)
 config := origin.Client().Transport.(*http.Transport).TLSClientConfig.Clone()
 check(!config.InsecureSkipVerify, "certificate verification must stay enabled")
 transport := &http.Transport{
 Proxy: http.ProxyURL(proxyURL), TLSClientConfig: config, DisableKeepAlives: true,
 OnProxyConnectResponse: func(_ context.Context, _ *url.URL, _ *http.Request, response *http.Response) error {
 connectStatus.Store(int64(response.StatusCode))
 if response.StatusCode == 200 {
 check(response.Header.Get("Content-Length") == "" && response.Header.Get("Transfer-Encoding") == "", "successful CONNECT must not frame a body")
 }
 return nil
 },
 }
 defer transport.CloseIdleConnections()
 get := func(tr *http.Transport, address string) (*http.Response, error) {
 return (&http.Client{Transport: tr, Timeout: 2 * time.Second}).Get(address)
 }
 success := func(label string) {
 response, err := get(transport, origin.URL)
 must(err)
 body, readError := io.ReadAll(response.Body)
 closeError := response.Body.Close()
 must(readError)
 must(closeError)
 check(response.StatusCode == 200 && string(body) == "through the tunnel", "wrong origin response")
 check(connectStatus.Load() == 200 && len(response.TLS.VerifiedChains) > 0, "CONNECT and verified TLS required")
 fmt.Println(label, "CONNECT=200; verified origin response")
 }
 success("allowed")
 response, err := get(transport, "https://denied.invalid:443/")
 check(err != nil && response == nil && connectStatus.Load() == 403, "proxy must reject the target")
 check(denied.Load() == 1 && admitted.Load() == 1 && handled.Load() == 1, "denial must not open an upstream tunnel")
 fmt.Println("denied CONNECT=403; no upstream admission")

 wrong := transport.Clone()
 wrong.TLSClientConfig = config.Clone()
 wrong.TLSClientConfig.ServerName = "wrong.invalid"
 defer wrong.CloseIdleConnections()
 response, err = get(wrong, origin.URL)
 var hostnameError x509.HostnameError
 check(response == nil && errors.As(err, &hostnameError) && connectStatus.Load() == 200, "client must verify the tunneled TLS identity")
 check(handled.Load() == 1, "wrong-name TLS must not reach the HTTP handler")
 fmt.Println("wrong name CONNECT=200; TLS rejected before origin HTTP")
 success("recovery")
 check(handled.Load() == 2 && admitted.Load() == 3, "wrong final origin/tunnel counts")
 for index := 0; index < 3; index++ {
 select {
 case counts := <-relayed:
 check(counts[0] > 0 && counts[1] > 0, "proxy must relay bytes in both directions")
 case <-time.After(4 * time.Second):
 panic("relay did not finish")
 }
 }
 fmt.Println("three completed relays; two successful origin HTTP requests")
 fmt.Println(runtime.Version())
}

第一次请求记录 CONNECT 200，并读到完整的源站正文。denied.invalid 目标得到 CONNECT 403，没有新增上游准入；实验不会解析这个名称。第三次尝试虽然得到 CONNECT 200，却在证书主机名验证阶段失败，源站 HTTP 处理次数不变。最后用正确配置再次请求，恢复成功。

三条获准隧道都向两个方向转发了字节，但只有两次源站 HTTP 请求完成。DisableKeepAlives 防止其他连接复用掩盖新的 CONNECT 交换；代理响应回调检查实际准入状态，并核对成功响应不含正文分帧字段。程序等待两个方向的复制结束，并显式关闭自行接管的套接字。

作者记录的 macOS、Go 1.27.0 运行通过了全部断言；本轮审阅没有重跑该网络实验，不能把历史记录当成本轮执行证据。请求限时两秒，拨号限时一秒，隧道套接字设置三秒绝对期限。这是隔离的协议实验，不是可以直接部署的公共代理。它没有测试调用方认证、DNS 策略、TLS 拦截、提前注入的缓冲数据、流量整形、持续负载或 HTTP/2、HTTP/3 的 CONNECT 映射，不能据此宣称具备这些生产能力。

来源

RFC 9110：HTTP 语义，CONNECT 准入、目标形式、中继职责和目的地约束，已核验 2026-09-09。
RFC 9112：HTTP/1.1，消息分帧与 CONNECT 隧道切换边界，已核验 2026-09-09。
Go net/http，代理响应观察与接管连接的生命周期，已核验 2026-09-09。
Go net，连接截止时间与 TCP 半关闭，已核验 2026-09-09。
Go crypto/tls，证书验证和 TLS 连接状态，已核验 2026-09-09。

响应缓冲在资源预算内吸收两端速度差

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

响应缓冲允许 nginx 以一种速度读取上游，同时以另一种速度向客户端交付数据。开启 proxy_buffering on 后，nginx 使用配置的内存缓冲区，也可以把大响应的一部分写入临时文件。它不必先收齐完整响应才发送第一批字节。两条连接能在多大程度上独立推进，取决于可用缓冲容量，而不是“开启”这两个字就能无限解耦。

坏掉的样子

“慢客户端永远不会阻塞后端”是错误承诺。内存缓冲、临时文件上限、磁盘吞吐和套接字缓冲都有限。当 nginx 无法继续吸收数据，上游仍然可能受到反压。禁用临时文件缓冲，也不等于关闭响应缓冲；它只是移除了一个等待数据的存储位置，使容量边界更容易到达。应明确哪个容量耗尽，而不是把所有等待都叫作后端慢。

缓冲还可能影响端点的延迟预期。虽然不要求收完整份响应，小事件仍可能先累积，之后才对客户端可见。流式端点应明确选择响应缓冲策略，并通过完整链路验证事件可见时间。即使关闭 nginx 响应缓冲，应用自身缓冲、压缩、TLS 和其他中间层仍会影响交付。因此，修改一条指令不能代替实际观察用户什么时候收到每个事件。

资源交换发生在代理层。把响应写入临时文件，可以让后端较早结束工作，但在客户端慢慢读取期间会占用临时存储和磁盘读写能力。为每条连接扩大内存缓冲，则可能在高并发下产生另一类容量问题。真正需要决定的是：面对实际工作负载，代理应该吸收多少数据、承担多少等待，而不是只凭单个缓冲值看起来更大来判断性能。

快速验证

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

将脚本保存为 check-response-buffering.py，准备 Python、Docker、固定镜像和足够的临时磁盘空间后运行。记录环境为 Linux arm64 上的 nginx 1.28.0。专用后端提供受控响应开关和进度计数，nginx 仅通过宿主回环监听。实验会传输三份 32 MiB 正文，完成后清理自己的资源，不使用现有业务后端：

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_bytes(content if isinstance(content,bytes) else content.encode())
 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()
 request.port=port
 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'
import hashlib
backend=r'''
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
from urllib.parse import urlsplit,parse_qs
import json,socket,threading
lock=threading.Lock();state={};gates={};chunk=b'x'*65536;total=32*1024*1024
class Handler(BaseHTTPRequestHandler):
 protocol_version='HTTP/1.1'
 def log_message(self,*args):pass
 def do_GET(self):
 parsed=urlsplit(self.path);path=parsed.path
 if path=='/state':
 with lock:data=json.dumps(state).encode()
 self.send_response(200);self.send_header('Content-Length',str(len(data)));self.end_headers();self.wfile.write(data);return
 if path=='/release':
 target=parse_qs(parsed.query)['path'][0]
 with lock:gates[target].set()
 self.send_response(204);self.end_headers();return
 gated=path.startswith('/early-');size=2*len(chunk) if gated else total
 with lock:state[path]={'written':0,'done':False};gates[path]=threading.Event()
 self.connection.setsockopt(socket.SOL_SOCKET,socket.SO_SNDBUF,65536)
 self.send_response(200);self.send_header('Content-Length',str(size));self.end_headers()
 for offset in range(0,size,len(chunk)):
 self.wfile.write(chunk)
 with lock:state[path]['written']=offset+len(chunk)
 if gated and offset==0:assert gates[path].wait(15)
 with lock:state[path]['done']=True
ThreadingHTTPServer(('0.0.0.0',8081),Handler).serve_forever()
'''
locations='''
location /early-on { proxy_buffering on; proxy_pass http://backend:8081; }
location /early-off { proxy_buffering off; proxy_pass http://backend:8081; }
location /large-on { proxy_buffering on; proxy_pass http://backend:8081; }
location /large-off { proxy_buffering off; proxy_pass http://backend:8081; }
location /large-nodisk { proxy_buffering on; proxy_max_temp_file_size 0; proxy_pass http://backend:8081; }
location / { proxy_pass http://backend:8081; }
'''
extra='''
proxy_buffer_size 4k; proxy_buffers 4 4k; proxy_busy_buffers_size 8k;
proxy_temp_file_write_size 8k; proxy_max_temp_file_size 64m; proxy_temp_path /tmp/proxy;
'''
with lab(config(locations,extra),backend=backend) as (proxy,request):
 results={}
 def state():return json.loads(request('/state')[2])
 for mode in ('on','off'):
 path='/early-'+mode;connection=http.client.HTTPConnection('127.0.0.1',request.port,timeout=10)
 connection.request('GET',path);response=connection.getresponse();first=response.read(1024)
 snapshot=state()[path];assert response.status==200 and first==b'x'*1024 and not snapshot['done']
 assert request('/release?path='+path)[0]==204
 rest=response.read();connection.close();assert first+rest==b'x'*(2*65536)
 results[path]={'first_bytes_before_backend_completion':len(first),'backend_written_at_first_read':snapshot['written']}
 total=32*1024*1024;expected=hashlib.sha256(b'x'*total).hexdigest()
 for mode in ('on','off','nodisk'):
 path='/large-'+mode;sock=socket.socket();sock.setsockopt(socket.SOL_SOCKET,socket.SO_RCVBUF,65536)
 sock.settimeout(20);sock.connect(('127.0.0.1',request.port))
 connection=http.client.HTTPConnection('127.0.0.1',request.port,timeout=20);connection.sock=sock
 connection.request('GET',path);response=connection.getresponse();assert response.status==200
 wait(lambda:state().get(path,{}).get('written',0)>0)
 if mode=='on':wait(lambda:state()[path]['done'])
 else:
 previous=-1;stable_since=time.monotonic();deadline=time.monotonic()+10
 while time.monotonic()<deadline:
 current=state()[path];assert not current['done'],current
 if current['written']!=previous:previous=current['written'];stable_since=time.monotonic()
 if time.monotonic()-stable_since>1:break
 time.sleep(.05)
 else:raise AssertionError('backend did not reach observable backpressure')
 before=state()[path]
 if mode!='on':assert 0<before['written']<total
 sock.setsockopt(socket.SOL_SOCKET,socket.SO_RCVBUF,1024*1024)
 digest=hashlib.sha256();received=0
 while block:=response.read(1024*1024):digest.update(block);received+=len(block)
 connection.close();wait(lambda:state()[path]['done'])
 assert received==total and digest.hexdigest()==expected
 results[path]={'before_client_drain':before,'received_bytes':received,'sha256':digest.hexdigest()}
 log=docker('exec',proxy,'cat','/tmp/error.log').stdout
 spills=[line for line in log.splitlines() if 'buffered to a temporary file' in line]
 assert any('/large-on ' in line for line in spills),log
 assert not any('/large-off ' in line or '/large-nodisk ' in line for line in spills)
 results['temporary_file_used_for_large_on']=True
 print(json.dumps(results,sort_keys=True))

首先，后端为一个 131,072 字节响应写出 65,536 字节，然后等待显式放行。无论响应缓冲开启还是关闭，客户端都能在后端尚未完成时读到 1,024 字节正文。脚本随后才放行后一半，并检查完整响应。这直接否定了“开启响应缓冲就一定等上游整份响应完成才交付”的说法；受控开关把响应尚未完成这一事实固定下来。

接着，客户端收到 32 MiB 响应头后暂停消费正文。开启响应缓冲、临时文件上限设为 64 MiB 时，后端在客户端继续读取前记录自己已经写完整份响应。nginx 错误日志同时确认该响应使用了临时文件。后端进度和真实写盘日志共同支持结论，不能只根据某次请求耗时短，就推断一定发生了磁盘缓冲。

关闭响应缓冲时，客户端保持暂停，后端完成写入的计数停在 32 MiB 以下。实验要求计数在受控观察区间内保持不变，然后恢复客户端读取；后端随后完成，完整摘要也匹配。另一个对照保留响应缓冲，但设置 proxy_max_temp_file_size 0，同样在客户端恢复消费前出现可观察反压，说明开启内存缓冲也不提供无限吸收能力。

中途停住的具体字节数会随套接字和平台行为变化。它们是本次观察结果，不是推荐缓冲大小，也不是跨平台固定阈值。关键差别是：客户端暂停时，有一条路径完成了响应生产，另外两条受限路径没有。最终三条路径都交付恰好 33,554,432 字节，并通过同一个预期 SHA-256 摘要检查，证明恢复读取后内容完整。

为缓冲分配预算，并验证可见进度

proxy_buffer_size 处理上游响应的第一部分，通常包含响应头；proxy_buffers 配置其他响应缓冲区；临时文件指令控制这里未缓存响应的磁盘使用。不要把这些限制误当成最大可接受响应长度。客户端读取后释放容量，较大响应可以继续传输，并不是只要超过内存缓冲区，就必然被拒绝或要求一次性保存到内存。

上游可以通过 X-Accel-Buffering 请求改变响应缓冲，除非 nginx 配置为忽略该响应头。当 location 的预期策略似乎没有生效，应检查应用是否发出了这个控制信号。请求正文缓冲是另一项设置，不会被这个响应控制改变；定位问题时必须先确定受到影响的是上传方向，还是返回客户端的方向。

对于普通下载，应同时考虑后端占用、代理磁盘使用和客户端完成时间。对于渐进事件，应测量每个事件什么时候可见，并加入慢读客户端。一次快速本地传输，既不能证明已经隔离慢客户端负载，也不能证明流式延迟满足应用契约。这里的受控暂停和完成计数用于揭示边界，生产容量仍应依据真实响应大小与并发分布确定。

来源

nginx proxy module，响应缓冲区、临时文件与 X-Accel-Buffering 控制，已核验 2026-10-15。
nginx reverse proxy guide，缓冲转发与向客户端同步转发，已核验 2026-10-15。

反向代理需要明确的请求头信任边界

Fri, 27 Aug 2027 00:00:00 +0000

反向代理接受客户端连接，再单独请求上游应用。因此，应用套接字看到的对端是代理，较早客户端的信息则可能通过请求头传入。这些头部只有在部署明确谁可以设置、如何验证时才有可信含义。请求经过代理，不会自动让所有转发身份或协议声明变得可靠；需要把网络连接事实与请求携带的文本声明区分开。

坏掉的样子

客户端到达代理前就可以提供 X-Forwarded-For。普通转发可能保留它，$proxy_add_x_forwarded_for 也只是追加当前对端地址，不会移除不可信前缀。如果应用盲信第一个地址，就可能把请求归属到客户端自行选择的值。正确解释取决于真实可信代理链，不能因为字段名包含 Forwarded 就赋予整条列表相同信任。

Host 处理是独立决策。nginx 默认上游 Host 基于代理目标，不会自动采用客户端访问的公共 Host。因此，构造绝对跳转或选择虚拟主机的应用，在代理后可能表现不同。应只转发预期主机上下文，并应用服务自己的可接受主机名策略；复制头部不等于验证其中名字，也不能替代虚拟服务器入口限制。

代理也不保证后端细节完全不暴露。响应头、跳转、正文、诊断信息或其他公开配置，都可能披露源站信息。限制直接访问和控制特定响应字段很有价值，但这不同于声称一条 proxy_pass 就能隐藏全部上游身份，或提供所需的所有传输保护。地址隐藏、访问控制和加密需要分别依据真实部署判断。

快速验证

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

使用宿主 Python、Docker，以及固定 nginx 和 Python 镜像运行脚本。实测为 Linux arm64 上的 nginx 1.28.0、Python 3.11.16、Docker 29.3.1。它创建私有 Docker 网络与真实回显后端，只把代理发布到宿主回环，验证配置并清理自己的资源，不涉及生产端点或凭据。实验中的伪造值使用文档专用地址：

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 /default { proxy_pass http://backend:8081; }
location /append { proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_pass http://backend:8081; }
location /edge {
 proxy_set_header Host $host;
 proxy_set_header X-Forwarded-For $remote_addr;
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header X-Forwarded-Proto $scheme;
 proxy_set_header X-Forwarded-Host $host;
 proxy_hide_header X-Backend-Info;
 proxy_pass http://backend:8081;
}
'''
with lab(config(locations,'server_tokens off;'),backend=backend) as (container,request):
 forged={'Host':'public.example','X-Forwarded-For':'198.51.100.77','X-Forwarded-Proto':'forged-scheme','X-Real-IP':'198.51.100.88'}
 status,headers,body=request('/default',headers=forged);plain=json.loads(body)
 assert status==200 and plain['headers']['Host']=='backend:8081'
 assert plain['headers']['X-Forwarded-For']=='198.51.100.77' and plain['headers']['X-Forwarded-Proto']=='forged-scheme'
 assert headers['x-backend-info']=='fixture-node'
 status,headers,body=request('/append',headers=forged);appended=json.loads(body)['headers']['X-Forwarded-For'].split(', ')
 assert status==200 and len(appended)==2 and appended[0]=='198.51.100.77'
 status,headers,body=request('/edge',headers=forged);edge=json.loads(body)['headers']
 assert status==200 and edge['Host']==edge['X-Forwarded-Host']=='public.example'
 assert edge['X-Forwarded-For']==edge['X-Real-IP']==appended[-1]
 assert edge['X-Forwarded-For'] not in ['198.51.100.77','198.51.100.88'] and edge['X-Forwarded-Proto']=='http'
 assert 'x-backend-info' not in headers and headers['server']=='nginx'
 print('ordinary forwarding preserves forged forwarding headers and defaults Host to the upstream authority')
 print('append retains the untrusted prefix; the direct-client edge configuration replaces it with the actual socket peer and scheme')
 print('explicit response-header suppression removes one backend field, while server_tokens off still exposes the nginx product name')

每个请求都把 Host 设为 public.example，并携带特意伪造的转发值。默认路由向后端发送 Host: backend:8081，同时保留伪造的 X-Forwarded-For 和 X-Forwarded-Proto。这直接证明普通代理转发不是身份清洗步骤，也不会自动保留公共主机名。后端回显让这些差异可见，不需要仅凭配置推理。

追加路由使用 $proxy_add_x_forwarded_for，后端收到两个逗号分隔地址：客户端提供的地址在前，nginx 观察到的套接字对端在后。原本不可信的前缀仍在。追加有用连接上下文，不会让整个结果列表同样可信；在这个直接面对客户端的结构中，盲信最左地址就会破坏预期边界。

入口路由用 $remote_addr 替换 X-Forwarded-For 和 X-Real-IP，用 $scheme 设置转发协议，并显式传入选择的主机上下文。后端收到真实观察到的对端值，不是两个伪造地址之一；本实验有意使用普通 HTTP，所以协议为 http。测试跨请求比较这些值，不假定 Docker 网桥一定分配某个固定地址。

套接字对端可能反映 Docker 网络路径，这不表示能穿过所有 NAT 或更早代理，恢复任意互联网用户地址。如果入口本身位于可信负载均衡器之后，部署需要有意定义如何接受该跳的信息。本例验证的是直接客户端信任边界，不覆盖所有代理链；应用不能把示例中正确的取值规则无条件搬到不同拓扑。

后端还返回 X-Backend-Info: fixture-node。默认路由会暴露它，入口路由通过明确的 proxy_hide_header 删除它。关闭 server_tokens 后，响应仍包含 Server: nginx。这把隐藏一个后端字段，与隐藏代理产品名或证明其他响应内容没有实现细节区分开。一个字段消失，不等于所有信息泄露渠道都消失。

连接网络访问规则与头部解释

后端依赖代理建立的上下文时，应限制哪些调用者可以直接访问它。如果使用 real IP 模块，可信代理地址范围应准确，并确保最终地址解释与应用自身信任设置一致。过宽信任范围可能让非预期调用者提供看似权威的转发信息，因此不能把网络可达与可信来源简单画等号。

明确 TLS 在哪里终止，以及上游连接是否也需要加密和证书验证。nginx 在当前一跳观察到的协议，不会自动描述更早一跳。跳转、安全 Cookie 和生成 URL 如果依赖转发协议或主机名，就应通过实际部署链路测试。只验证内部 HTTP 回显，不能宣布外部 HTTPS 行为也正确。

最后，同时检查应用收到的请求和客户端收到的响应。头部配置、网络隔离和信息披露控制，分别回答不同问题。两侧证据可以让组合行为可审阅，而不是假定代理会默默补上每个缺失保证。明确事实来源，才能让应用正确使用代理提供的上下文。

来源

nginx HTTP proxy module，默认 Host 处理、转发头与响应头隐藏，已核验 2026-10-15。
nginx real IP module，显式信任的地址来源与代理链，已核验 2026-10-15。
nginx core server_tokens and variables，套接字对端地址、请求协议与服务器版本披露，已核验 2026-10-15。

过期缓存需要明确的重新验证与陈旧响应策略

Thu, 24 Jun 2027 00:00:00 +0000

nginx 代理缓存需要分别作出几项决定：怎样识别已存响应，什么时候允许读取，什么时候允许保存新响应，以及过期副本还能怎样使用。如果把这些都看成一个 TTL 设置，故障就很难解释。验证时应同时观察请求实际经过的路径与交付字节，而不只是确认 nginx 接受了配置文件。

存储容量与新鲜度分开看

proxy_cache_path 声明磁盘存储位置及保存元数据的共享内存 keys_zone，proxy_cache 再为请求启用这个区域。元数据区大小不等于正文缓存容量。max_size 由缓存维护机制管理，不是瞬时硬磁盘配额；inactive 保留策略也不是响应的新鲜度寿命。已经过期的响应仍可能留在存储中，用于后续重新验证。

默认缓存键为 $scheme$proxy_host$request_uri，其中 request_uri 已经包含查询串，后面再加 $is_args$args 就重复拼接了参数。也不能随意替换成规范化后的 URI，或遗漏会改变表示的输入。默认启用 HEAD 转换，因此 GET 与 HEAD 共享相应缓存行为；关闭转换时，就需要在缓存键中考虑请求方法。

核对真正生效的响应策略

proxy_cache_valid 按状态码提供配置寿命，但正常处理的源站新鲜度头具有更高优先级。X-Accel-Expires 还有自己的优先顺序；它不存在时，Cache-Control 和 Expires 才参与相应设置。忽略这些头会改变实际契约。下面的实验里，源站 max-age 为一秒，覆盖了配置的六十秒；no-store 则阻止响应进入存储。

proxy_cache_revalidate 让过期条目使用 ETag、Last-Modified 等验证器发送条件请求。匹配的 304 可以保留正文并更新元数据，变化后的 200 则提供替代字节。但重新验证不等于异步刷新。后台更新是另一项指令，还需要允许在更新期间返回旧内容，不能仅凭某一个开关推断整套刷新方式。

坏掉的样子

proxy_cache_bypass 控制不从缓存读取，proxy_no_cache 控制不保存新响应。要求两者都成立的路由，需要分别表达两个决策。一次绕过也不意味着已经清除了原有条目。实验让这两项指令使用同一个专用测试头，并验证绕过之后，原有副本依然可用。这个头只是实验开关，不能当作真实身份认证或权限策略。

proxy_cache_use_stale http_500 允许在上游返回 500 时使用已有陈旧副本；完全冷的键没有副本可用，因此不会凭空获得保护。这项指令本身没有规定最大陈旧秒数。源站 stale-if-error 时间窗的优先级低于这些指令参数，额外加上它也不能限制这里的设置。启用之前必须先决定旧内容在业务上是否仍然可接受。

否则，一个表面成功的响应可能正在隐藏源站故障，或者继续交付已经不该使用的数据。应把上游结果、nginx 缓存状态和返回正文一起记录。配置语法检查不能证明账户隔离，一次热缓存命中也不代表并发冷加载正常。缓存锁、容量压力下的保留行为和多工作进程模式，都需要单独验证，不能从本次顺序实验推导出来。

快速验证

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

需要 POSIX 环境、C 编译器、make、curl、tar 以及 Python 3.11 或更新版本。本次在 macOS 上使用 clang 21.0.0、Python 3.14.4 和 nginx 1.30.4 执行。下列命令只编译一个独立的 HTTP 实验程序，不安装到系统，也不用 sudo；关闭 rewrite 和 gzip 模块以避免它们的外部依赖。这不是部署 TLS 服务的配置教程。

nginx_lab=$(mktemp -d)
curl --fail --location --output "$nginx_lab/nginx.tar.gz" https://nginx.org/download/nginx-1.30.4.tar.gz
tar -xzf "$nginx_lab/nginx.tar.gz" -C "$nginx_lab"
cd "$nginx_lab/nginx-1.30.4"
./configure --prefix="$nginx_lab/install" --without-http_rewrite_module --without-http_gzip_module
make -j2
export NGINX_BIN="$nginx_lab/nginx-1.30.4/objs/nginx"

在同一个 shell 中用 python3 执行 Python 代码。程序创建自己的配置和缓存目录，先检查语法，再在选定的回环端口启动源站与 nginx；两次短暂等待用于跨过真实到期时间。结束时关闭自己启动的代理进程和源站，仅移除临时运行目录。源码下载需要外网，实验请求全部留在本机，不操作现有 nginx 服务。

import hashlib
import os
from http.client import HTTPConnection
from http.server import BaseHTTPRequestHandler, HTTPServer
from pathlib import Path
import signal
import socket
import subprocess
from tempfile import TemporaryDirectory
from threading import Thread
import time

state = {"body": b"A", "fail": False}
seen = []


class Origin(BaseHTTPRequestHandler):
 def log_message(self, *_):
 pass

 def do_GET(self):
 tag = '"' + hashlib.sha256(state["body"]).hexdigest() + '"'
 conditional = self.headers.get("If-None-Match")
 if self.path == "/short" and state["fail"]:
 status, body = 500, b"failure"
 elif conditional == tag:
 status, body = 304, b""
 else:
 status, body = 200, state["body"]
 directive = "max-age=1" if self.path == "/short" else "max-age=60"
 if self.path == "/no-store" or status == 500:
 directive = "no-store"
 seen.append((self.path, status, conditional))
 self.send_response(status)
 self.send_header("Cache-Control", directive)
 if status != 500:
 self.send_header("ETag", tag)
 if status != 304:
 self.send_header("Content-Length", str(len(body)))
 self.end_headers()
 self.wfile.write(body)


origin = HTTPServer(("127.0.0.1", 0), Origin)
worker = Thread(target=origin.serve_forever)
worker.start()
try:
 with TemporaryDirectory(prefix="nginx-cache-lab-") as directory:
 root = Path(directory)
 with socket.socket() as reservation:
 reservation.bind(("127.0.0.1", 0))
 port = reservation.getsockname()[1]
 config = root / "nginx.conf"
 config.write_text(f"""
pid nginx.pid;
error_log stderr error;
events {{ worker_connections 64; }}
http {{
 access_log off;
 proxy_cache_path "{root}/cache" keys_zone=lab:1m max_size=10m;
 server {{
 listen 127.0.0.1:{port};
 location / {{
 proxy_pass http://127.0.0.1:{origin.server_port};
 proxy_cache lab;
 proxy_cache_valid 200 60s;
 proxy_cache_revalidate on;
 proxy_cache_use_stale http_500;
 proxy_cache_bypass $http_x_lab_bypass;
 proxy_no_cache $http_x_lab_bypass;
 proxy_connect_timeout 2s;
 proxy_read_timeout 2s;
 add_header X-Lab-Cache $upstream_cache_status always;
 }}
 }}
}}
""", encoding="utf-8")
 command = [os.environ["NGINX_BIN"], "-p", str(root) + "/",
 "-c", str(config), "-e", "stderr"]
 checked = subprocess.run(command + ["-t"], capture_output=True, text=True)
 assert checked.returncode == 0, checked.stderr
 process = subprocess.Popen(command + ["-g", "daemon off; master_process off;"],
 stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, text=True)
 try:
 deadline = time.monotonic() + 5
 while True:
 assert process.poll() is None, "nginx exited during startup"
 try:
 with socket.create_connection(("127.0.0.1", port), timeout=0.1):
 break
 except OSError:
 if time.monotonic() >= deadline:
 raise TimeoutError("nginx did not become ready")
 time.sleep(0.05)

 def get(path, expected, body, bypass=False):
 connection = HTTPConnection("127.0.0.1", port, timeout=3)
 try:
 connection.request("GET", path, headers={"X-Lab-Bypass": "1"} if bypass else {})
 response = connection.getresponse()
 actual = (response.status, response.getheader("X-Lab-Cache"), response.read())
 assert actual == (200, expected, body), actual
 print(path, expected, body.decode())
 finally:
 connection.close()

 get("/long", "MISS", b"A")
 get("/long", "HIT", b"A")
 state["body"] = b"B"
 get("/long", "BYPASS", b"B", bypass=True)
 get("/long", "HIT", b"A")
 assert sum(path == "/long" for path, _, _ in seen) == 2

 get("/short", "MISS", b"B")
 time.sleep(2.1)
 get("/short", "REVALIDATED", b"B")
 assert seen[-1][1:] == (304, '"' + hashlib.sha256(b"B").hexdigest() + '"')
 state["fail"] = True
 time.sleep(2.1)
 get("/short", "STALE", b"B")
 assert seen[-1][1] == 500
 state.update(body=b"C", fail=False)
 get("/short", "EXPIRED", b"C")
 get("/short", "HIT", b"C")
 get("/no-store", "MISS", b"C")
 get("/no-store", "MISS", b"C")
 assert sum(path == "/no-store" for path, _, _ in seen) == 2
 finally:
 if process.poll() is None:
 process.send_signal(signal.SIGQUIT)
 try:
 _, errors = process.communicate(timeout=5)
 except subprocess.TimeoutExpired:
 process.kill()
 process.communicate()
 raise
 assert process.returncode == 0, errors
finally:
 origin.shutdown()
 worker.join()
 origin.server_close()

长寿命路径依次报告 MISS A、HIT A、BYPASS B、HIT A。源站在这条路径只收到两次请求，说明绕过请求获取了 B，却没有把它保存成新的共享副本，也没有删除之前的 A。短寿命路径先报告 MISS B；到期之后报告 REVALIDATED B，源站记录同时确认它确实收到正确的条件 ETag，并返回了 304。

注入源站 500 后，代理报告 STALE B，继续交付原来的正文。源站恢复并提供 C 后，EXPIRED C 替换缓存内容，接下来的访问成为 HIT C。两次 no-store 请求都保持 MISS，且都抵达源站。这里检查的是实际状态和字节，不把日志里出现一个状态词单独当作功能证明。

这些结果来自真实 nginx 的单进程隔离实验，不覆盖后台刷新、分布式失效、生产授权、磁盘压力处理或所有陈旧策略组合。真实发布还需要结合对应版本、完整配置和实际流量补齐这些范围。保留这种边界，才能区分“某条配置路径已经测过”和“整个代理部署已经验收”。

来源

nginx 代理模块，缓存键、头字段优先级、重新验证、绕过、保存和陈旧策略，已核验 2026-10-15。
nginx 编译配置，构建前缀和可选模块依赖，已核验 2026-10-15。
nginx 内容缓存指南，磁盘存储、共享元数据和缓存维护，已核验 2026-10-15。
RFC 9111：陈旧响应，新鲜度与允许使用旧响应的条件，已核验 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。

上游 keepalive 缓存空闲连接，不限制活动容量

Mon, 15 Mar 2027 00:00:00 +0000

nginx 上游 keepalive 缓存会保留符合条件的空闲后端连接，供后续请求复用。在本次配置中，keepalive 2 允许每个 worker 为该上游缓存保留两条空闲连接，并不把 worker 的活动后端连接限制为两条。复用可以减少重复建立连接的开销，却不会自动施加应用并发预算，也不能保证每个请求的延迟都下降。空闲保留与活动容量需要分别理解。

坏掉的样子

把空闲缓存大小误当成连接上限，会让后端同时承受的工作量超过预期。忙碌 worker 可以继续新建活动连接，而保留的空闲缓存仍很小。存在多个 worker 时，各自的空闲缓存也需要计入资源。将 nginx 配置与后端真实连接容量比较时，应分别统计活动与空闲资源，不能只拿一个 keepalive 数字作为全部连接预算。

复用要求协议交换本身可以继续使用。在这个 nginx 1.28.0 HTTP 示例中，上游 HTTP/1.1 和清除默认 Connection: close 都是显式配置。仅设置 Host 并不能建立持久连接。后端仍可能主动关闭连接，不完整或分帧错误的消息，也不能仅因为配置了缓存，就被当成干净可复用的交换。连接是否适合归还空闲缓存，需要实际通信满足条件。

客户端持久连接属于另一组连接关系。新的客户端连接可以使用之前缓存的上游连接；长时间存在的客户端也可能触发多条后端连接。假设两者生命周期总是一致，会产生误导性测量。建立连接的节省也取决于后端使用明文 HTTP 还是 TLS；本次 nginx 后面采用明文 HTTP，因此没有把 TLS 握手节省写成已测结果。

快速验证

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

将脚本保存为 check-upstream-keepalive.py，准备 Python、Docker 和固定镜像后执行。实验使用单个 nginx 1.28.0 worker，以及专用网络里的 Python HTTP/1.1 后端。后端为每条接收连接分配身份，每个响应都提供明确长度。客户端通过宿主回环进入 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_bytes(content if isinstance(content,bytes) else content.encode())
 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()
 request.port=port
 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'
from concurrent.futures import ThreadPoolExecutor
backend=r'''
from http.server import BaseHTTPRequestHandler,ThreadingHTTPServer
import itertools,json,threading
ids=itertools.count(1);lock=threading.Lock();opened=set();active=set();release=threading.Event()
class Handler(BaseHTTPRequestHandler):
 protocol_version='HTTP/1.1'
 def setup(self):
 super().setup();self.ident=next(ids)
 with lock:opened.add(self.ident)
 def finish(self):
 try:super().finish()
 finally:
 with lock:opened.discard(self.ident)
 def log_message(self,*args):pass
 def do_GET(self):
 if self.path=='/hold':
 with lock:active.add(self.ident)
 assert release.wait(15)
 with lock:active.remove(self.ident)
 elif self.path=='/release':release.set()
 with lock:data=json.dumps({'connection':self.ident,'active':sorted(active),'other_open':sorted(opened-{self.ident}),
 'host':self.headers.get('Host'),'connection_header':self.headers.get('Connection')}).encode()
 self.send_response(200);self.send_header('Content-Length',str(len(data)));self.end_headers();self.wfile.write(data)
ThreadingHTTPServer(('0.0.0.0',8081),Handler).serve_forever()
'''
locations='''
location /reuse/ { proxy_http_version 1.1; proxy_set_header Connection ""; proxy_pass http://pool/; }
location /close/ { proxy_http_version 1.1; proxy_set_header Connection close; proxy_pass http://pool/; }
location /host-only/ { proxy_http_version 1.1; proxy_set_header Host service.example; proxy_pass http://pool/; }
location /control/ { proxy_set_header Connection close; proxy_pass http://backend:8081/; }
'''
extra='upstream pool { server backend:8081; keepalive 2; keepalive_timeout 30s; }'
with lab(config(locations,extra),backend=backend) as (_,request):
 def get(path):
 status,_,body=request(path);assert status==200;return json.loads(body)
 results={}
 for mode in ['reuse','close','host-only']:
 first=get('/'+mode+'/id');second=get('/'+mode+'/id')
 assert (first['connection']==second['connection'])==(mode=='reuse')
 if mode=='host-only':assert first['host']=='service.example' and first['connection_header']=='close'
 results[mode]={'connections':[first['connection'],second['connection']],'host':first['host'],'connection_header':first['connection_header']}
 with ThreadPoolExecutor(max_workers=4) as pool:
 futures=[pool.submit(get,'/reuse/hold') for _ in range(4)]
 wait(lambda:len(get('/control/state')['active'])==4)
 active=get('/control/state')['active'];assert len(set(active))==4
 get('/control/release');replies=[f.result(timeout=10) for f in futures]
 assert len({r['connection'] for r in replies})==4
 wait(lambda:len(get('/control/state')['other_open'])==2)
 results['concurrent_active']=active;results['idle_after_burst']=get('/control/state')['other_open']
 print(json.dumps(results,sort_keys=True))

连续两次 /reuse/id 返回相同后端连接身份。客户端辅助函数每次请求都新建并关闭自己的 HTTP 连接，因此观察到的是跨不同下游连接的上游复用。该 location 显式使用上游 HTTP/1.1，并且不发送 Connection 头。每个响应完整读完后，后端交换才具备进入空闲状态的条件，不能在正文尚未消费完时仅凭状态成功判断连接可复用。

/close/id 对照发送 Connection: close，连续请求得到不同后端连接身份。/host-only/id 对照修改 Host，却保留关闭行为，响应同样使用不同连接。这些比较说明：即使所有路径连接同一个应用，用于路由的头也不能替代正确的持久连接设置。观察请求头和连接身份，比只看两次请求都成功更有解释力。

接着，四个客户端请求由后端故意保持未完成的响应。控制端等到后端报告四个活动连接身份后，才放行任何响应。这直接展示 keepalive 2 下仍有四条并发上游连接，不是根据耗时猜测并发，也不是数四个可能顺序完成的请求。受控等待使活动连接数量成为可以直接检查的中间状态。

放行后，四个响应全部完成。实验随后观察到恰好两条剩余空闲后端连接，计数排除了用于查询状态的短期控制连接。最终保留哪些身份会随完成顺序变化，断言关心的是数量。这样就能区分配置规定的空闲保留上限，与突发期间实际使用的更大活动连接集合，避免把两种阶段混成一个总上限。

让复用设置匹配后端行为

应结合连接建立成本、预期再次使用概率、后端限制和 nginx worker 数量确定空闲保留规模。连接即使没有承载请求，保留期间也会占用资源。过大的缓存可能挤占新请求可用连接，过小的缓存则可能反复丢弃马上就会复用的连接。选择规模需要真实访问分布和后端预算，而不是一律把值调大。

请求次数、空闲时间和连接总寿命控制，会因为不同原因回收持久连接。不要看到重连就同时提高所有限制。应先观察后端主动关闭、有效配置、响应分帧完成情况，以及真实连接身份。本次空闲超时设为三十秒，短暂突发没有测量长期连接老化，也没有测量 TLS 会话行为，因此不能据此推断那些不同机制的效果。

如果目标是限制后端工作量，应采用真实并发或准入策略；keepalive 负责复用策略。示例明确选择协议和缓存设置，因为滚动文档还包含较新 nginx 的默认值与功能。应用时要遵循实际部署版本的语义，同时验证连续复用和并发突发，不能认为一次重复请求成功复用，就已经证明容量边界受到控制。

来源

nginx upstream module，空闲连接缓存、worker 范围与 keepalive 限制，已核验 2026-10-15。
nginx 1.28.0 upstream keepalive source，被测版本的空闲缓存与连接复用实现，已核验 2026-10-15。
RFC 9112 HTTP/1.1，持久连接、消息分帧与 Connection close，已核验 2026-10-15。

反向代理只对真正经过它的流量执行入口策略

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

反向代理接收客户端请求，再与应用进行独立的上游交换。配置相应行为后，它可以集中路由、传输、请求头和准入策略，却不会自动隐藏所有后端接口、认证所有调用者或终止 TLS。真正有用的边界，是流量实际经过哪里、在那里执行什么策略，而不是代理在架构图上画在应用前面。描述能力时应对应配置和真实调用路径。

坏掉的样子

如果后端还能通过另一条路径到达，只放在代理上的控制就可能被绕过。不发布容器端口减少了一种暴露途径，但连接到相同网络的其他工作负载仍可能访问应用。如果后端授权完全依赖“所有流量已经经过公开代理”这个假设，内部直连请求就可能让假设失效。需要检查真正可达的调用者，而不是只检查公网端口列表。

URI 映射可能产生更隐蔽的绕过。代理阻止 /admin，并不代表宽泛的 /api/ 映射不会通过 /api/admin 暴露同一个后端处理器。应审阅最终上游 URI，而不只看客户端可见路径。公开一个明确端点，与在方便的前缀下公开所有处理器是不同决定，不能期待两个外部名称不同就天然对应不同权限边界。

转发元数据需要明确处理。客户端可能发送伪造地址或协议头，代理把它继续转发，并不会让它自动可信。应用需要知道可信一跳设置哪些字段，以及哪些调用者可以直接访问自己。浏览器响应头也不能替代请求授权或网络可达性控制。检查响应头存在，只能证明对应字段被发送，不能推断其他安全责任已经完成。

快速验证

将脚本保存为 check-proxy-entry.py，准备 Python、Docker 和固定镜像后运行。此前记录的环境使用 nginx 1.28.0，以及专用 Docker 网络里的可丢弃回显应用；本轮没有重跑。只有代理绑定宿主回环端口。实验使用 HTTP 检查路由与策略，并没有执行 TLS 部署；结束后清理自己的容器、镜像标签和网络，不改动已有服务：

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,extra_ports=()):
 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_bytes(content if isinstance(content,bytes) else content.encode())
 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')
 published=[arg for value in (8080,*extra_ports) for arg in ('-p','127.0.0.1::'+str(value))]
 docker('run','-d','--name',containers[0],'--network',name,*published,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()
 request.port=port;request.network=name
 request.ports={int(key.split('/')[0]):int(value[0]['HostPort']) for key,value in details['NetworkSettings']['Ports'].items() if value}
 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,ThreadingHTTPServer
import json
class Handler(BaseHTTPRequestHandler):
 protocol_version='HTTP/1.1'
 def log_message(self,*args):pass
 def respond(self,body=b''):
 data=json.dumps({'path':self.path,'method':self.command,'body':body.decode(),
 'host':self.headers.get('Host'),'forwarded_for':self.headers.get('X-Forwarded-For'),
 'forwarded_proto':self.headers.get('X-Forwarded-Proto')}).encode()
 self.send_response(200);self.send_header('Content-Type','application/json');self.send_header('Content-Length',str(len(data)))
 self.end_headers();self.wfile.write(data)
 def do_GET(self):self.respond()
 def do_POST(self):self.respond(self.rfile.read(int(self.headers['Content-Length'])))
ThreadingHTTPServer(('0.0.0.0',8081),Handler).serve_forever()
'''
locations='''
location = /api/echo {
 proxy_set_header Host $host;
 proxy_set_header X-Forwarded-For $remote_addr;
 proxy_set_header X-Forwarded-Proto $scheme;
 proxy_pass http://backend:8081/echo;
}
location /admin { deny all; }
location / { return 404; }
'''
extra='client_max_body_size 1k; add_header X-Content-Type-Options nosniff always;'
bad='events {} http { server { listen not-a-port; } }'
with lab(config(locations,extra),{'invalid.conf':bad},backend) as (proxy,request):
 status,h,b=request('/api/echo',method='POST',body=b'hello',headers={'Host':'edge.example',
 'X-Forwarded-For':'192.0.2.123','X-Forwarded-Proto':'https'})
 data=json.loads(b);assert status==200 and data['path']=='/echo' and data['body']=='hello' and data['method']=='POST'
 assert data['host']=='edge.example' and data['forwarded_for']!='192.0.2.123' and data['forwarded_proto']=='http'
 assert h['x-content-type-options']=='nosniff';results={'proxied_request':data}
 status,h,_=request('/admin');assert status==403 and h['x-content-type-options']=='nosniff';results['admin_at_proxy']=status
 assert request('/api/echo',method='POST',body=b'x'*2048)[0]==413
 assert request('/unknown')[0]==404 and request('/api/admin')[0]==404
 results['size_and_route_rejections']=[413,404];results['admin_alias_rejected']=404
 details=json.loads(docker('inspect',request.network+'-backend').stdout)[0]
 assert not details['HostConfig']['PortBindings']
 code='import json,urllib.request;print(json.dumps(json.load(urllib.request.urlopen("http://backend:8081/admin"))))'
 internal=docker('run','--rm','--network',request.network,PYTHON,'python','-c',code)
 direct=json.loads(internal.stdout);assert direct['path']=='/admin'
 results['backend_has_host_port_binding']=False;results['internal_direct_path']=direct['path']
 probe=docker('exec',proxy,'nginx','-t','-c','/srv/invalid.conf',check=False);assert probe.returncode!=0
 assert request('/api/echo')[0]==200;results['invalid_candidate_rejected_live_config_survives']=True
 print(json.dumps(results,sort_keys=True))

POST 到精确公开路径 /api/echo 后，以原方法和正文到达后端 /echo。提供的 Host 按明确配置转发；实验没有验证主机名允许名单，不能单凭该字段把请求认定为某个可信租户。伪造 X-Forwarded-For 被替换为 nginx 观察到的套接字对端，伪造的 https 协议被替换为这个监听实际使用的 http。响应揭示后端真正收到的字段，而不是只根据指令存在就假定效果正确。

在代理处，/admin 返回 403，/api/admin 返回 404。后一项对照阻止另一种 URI 映射到达同一后端处理器。2,048 字节的超大提交超过 1 KiB 限制，返回 413；未知路由返回 404。配置的 nosniff 头同时出现在成功响应和显式访问拒绝中。这些结果分别验证路由、大小与响应字段，不把其中一项成功当成全部策略生效。

脚本检查 Docker 后端配置，确认没有宿主端口绑定。随后，在同一专用网络里启动另一个可丢弃客户端，直接请求后端 /admin，请求成功。这个结果是有意保留的边界证据：代理的拒绝不会作用于根本没有经过代理的路径。专用网络内部可达与公网发布不同，但仍需要与应用的调用者信任模型对应。

最后，一个候选配置包含无效监听值，nginx 在语法验证中拒绝它，而原有效进程仍能回答 /api/echo。这说明检查独立候选不会自动激活它，不代表任意 reload、证书轮换或完整部署流程已经验证。配置检查与实际切换是不同动作，报告结果时需要保持这种区分。

明确入口策略与应用责任

盘点每个后端的所有可达路径，包括内部工作负载和单独发布的监听。按照信任模型要求实施应用授权，并把网络访问限制给预期调用者。私有 bridge 是一种连接安排，不证明所有附着工作负载具有相同权限，也不证明后端流量经过加密。只有网络结构、身份与授权规则一致，入口策略才不会依赖错误的隐含前提。

URI 暴露范围和转发字段应成为应用契约的一部分。这个小实验用精确公开路由防止意外暴露处理器；更大应用需要经过审阅的路由家族，而不是任意复制测试中的路径清单。当多个外部 URL 可能命名同一个内部操作时，应验证近似路径与改写路径。检查必须沿映射直到真实处理器，不能停在第一层名称。

TLS 可以在代理终止、继续延伸到后端，或采用其他明确设计的边界。证书、上游验证、续期和协议选择需要各自检查。同样，即使前面连接很多健康应用，一个代理仍然是一个容量与故障组件。集中策略只有在配置和可用性被实际管理时，才真正减少重复工作；它不会免费提供所有传输和运维能力。

最后，既通过入口验证，也通过其他允许路径验证。检查应用收到什么、客户端看到什么，以及哪些请求根本不应到达应用。代理适合执行共同策略，但正确性来自这些可观察边界，而不是假定建筑只有图上标出的那一扇门。实际可达性与实际执行策略，应共同决定对外作出的保护承诺。

来源

nginx HTTP proxy module，URI 映射、转发请求头与后端传输配置，已核验 2026-10-15。
nginx reverse proxy guide，面向客户端的代理及其独立上游交换，已核验 2026-10-15。
nginx HTTP core module，精确 location、正文限制与请求处理边界，已核验 2026-10-15。

代理 · XB 现场笔记

微缓存短暂复用新鲜条目，并显式合并并发未命中

坏掉的样子

快速验证

分别决定新鲜度与过载行为

延伸阅读

来源

代理键把身份与含义分开

生成身份与约束唯一性

单独保留业务唯一规则

坏掉的样子

快速验证

来源

CONNECT 方法打开一条裸隧道

在正确的边界切换语义

看不见正文，仍然占用资源

坏掉的样子

快速验证

延伸阅读

来源

响应缓冲在资源预算内吸收两端速度差

坏掉的样子

快速验证

为缓冲分配预算，并验证可见进度

延伸阅读

来源

反向代理需要明确的请求头信任边界

坏掉的样子

快速验证

连接网络访问规则与头部解释

延伸阅读

来源

过期缓存需要明确的重新验证与陈旧响应策略

存储容量与新鲜度分开看

核对真正生效的响应策略

坏掉的样子

快速验证

延伸阅读

来源

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

坏掉的样子

快速验证

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

延伸阅读

来源

上游 keepalive 缓存空闲连接，不限制活动容量

坏掉的样子

快速验证

让复用设置匹配后端行为

延伸阅读

来源

反向代理只对真正经过它的流量执行入口策略

坏掉的样子

快速验证

明确入口策略与应用责任

延伸阅读

来源