引言:为什么代理背后的流式 HTTP 成了普遍难题

想象一下:你向语言模型发了一个请求,结果屏幕上没有熟悉的逐字“打印”效果,而是沉默了四十秒,然后整个回答一次性喷了出来。或者一个本该每秒刷新一次的监控仪表盘,显示的数据却延迟了半分钟。又或者一个监听交易所事件流的爬虫,收到的不是平稳的小溪,而是一百个事件一捆的包裹。十有八九,这不是服务器或客户端的错。错的是站在它们中间的那个角色:代理、负载均衡器、CDN 或企业网关——它决定“好心帮忙”,在把响应交给下一环之前先攒齐整个响应。

关于通过中间节点实现流式 HTTP 响应的话题,长期以来被视为细分领域。到了 2026 年,它变成了普遍问题。LLM API 的 token 流式输出、Web 界面中的服务端事件、即时通讯和机器人中的 long-polling、大型导出的进度条、爬虫结果的流式返回——所有这些都运行在最普通的 HTTP 之上,只是这个 HTTP 不急于关闭响应。而只要路径上出现一个开启了缓冲的节点,它们全都会坏掉。

在本指南中,我们将从通过代理的角度,拆解三种经典机制——chunked transfer encoding、Server-Sent Events 和 long-polling。这里先做一个重要说明:本文不涉及 WebSocket 和 gRPC。它们有专门的材料,而且区别是根本性的。那里发生的是协议升级,或者使用 HTTP/2 上的二进制分帧,代理必须能够识别并放行这次升级。而这里——是一个普通的 HTTP 响应,它没有 Content-Length 头,服务器让它一直开着。没有握手,没有切换到另一种协议。看起来再简单不过了。但正是这种简单造成了问题:代理看不出任何特别之处,于是套用为短响应量身定制的标准缓冲规则。

你能从本文获得什么:理解流在字节和头部层面是怎么工作的;一张所有响应可能卡住的位置地图;nginx、HAProxy、Envoy 和客户端库的现成配置;三种机制之间的选择框架;诊断清单;带数字的真实案例分析。本文面向开发者、DevOps 工程师,以及所有使用代理处理 API、爬虫和自动化的人。

基础:普通 HTTP 响应如何变成流

告知响应长度的两种方式

在 HTTP/1.1 中,告诉客户端响应体在哪里结束有两种根本方式。第一种是 Content-Length 头:服务器提前声明确切的字节数。第二种是 Transfer-Encoding: chunked:服务器分块发送响应体,每一块以十六进制表示的自身大小开头,最后以一个零长度的块结束。还有第三种古老的方式——在最后一个字节后直接关闭连接,但在 keep-alive 下几乎不用。

为什么这对流很重要?因为 Content-Length 要求提前知道大小。如果服务器是逐步生成响应的——一个 token 一个 token,一个事件一个事件——它在开始传输之前根本无法计算长度。HTTP/1.1 中唯一的选择就是 chunked。在 HTTP/2 和 HTTP/3 中,chunked 编码本身并不存在:响应体本来就以 DATA 帧传输,结束由 END_STREAM 标志表示。但逻辑是一样的:没有声明长度的响应,可以持续任意长时间。

“不关闭响应”意味着什么

打个比方。普通的 HTTP 响应就像一个包裹:你收到一个箱子,上面写着重量,打开后就知道里面全了。流式响应则是一条传送带:箱子一个接一个地过来,而你不知道传送带什么时候停。服务器发送了状态为 200 的头部,发送了第一个块——然后等着。有新数据了——发送下一块。连接保持打开几分钟、几小时,有时是一整天。

从 TCP 的角度看没有任何异常:还是那个套接字,还是那些段。从 HTTP 的角度看——这是一个请求和一个响应,只是非常长。而所有代理问题的根源就在这里:中间节点看到了响应的开头,看不到结尾,它必须决定怎么处理已经到达的字节。立即转发?还是再等等,多攒一些再更高效地发送?默认情况下,大多数代理会选择后者。

三种机制:共同点与差异

  • Chunked streaming —— 最底层。服务器只是把字节写入响应体并调用 flush。内容格式任意:文本、NDJSON、二进制数据。由客户端自行决定如何解析。
  • Server-Sent Events —— 建立在 chunked 流之上的标准化文本格式。Content-Type: text/event-stream,事件由空行分隔,有 data、event、id、retry 字段。浏览器通过 EventSource 原生支持,并自动重连。
  • Long-polling —— 严格来说不是流。客户端发出请求,服务器保持它打开直到有数据或超时,然后响应并关闭。客户端立即发出下一个请求。这是用一系列普通响应模拟的流,每个响应都可以有 Content-Length。

它们的共同点是什么?在三种情况下,对单个请求的响应都会延迟不确定的时间,而代理必须挺过去:不能因超时断开连接,也不能把数据滞留在缓冲区里。区别在于每种机制对中间节点透明度的依赖程度。Chunked 和 SSE 是 критически 依赖的。Long-polling 则依赖最小,这也是它最大的优势。

代理在链路中的角色

在现代基础设施中,客户端和服务器之间很少是空的。典型链路:客户端应用——出口代理(例如移动或住宅代理)——互联网——CDN——云负载均衡器——反向代理——应用。这些节点中的每一个都是潜在的缓冲点。而且每一个默认都被配置成优化短响应:收集、压缩、整体发出。对流来说,这种优化是一场灾难。我们将逐层剥离这些层,看看每一层发生了什么。

深入探讨:流在哪里、为什么会卡在中间节点

代理到底为什么要缓冲

在指责缓冲之前,值得先理解它的逻辑。像 nginx 这样的反向代理缓冲有三个原因。第一——保护后端免受慢客户端的影响:如果移动网络上的客户端以每秒十KB的速度读取,而后端已经生成了响应,那么一次性从后端拿走所有数据、释放它的 worker,再从容地从缓冲区发给客户端会更划算。第二——压缩:gzip 和 brotli 在大块上效率更高。第三——能够设置 Content-Length,并在向客户端发送头部之前正确处理后端错误。

对于响应只有几KB的典型 API,这一切都是合理且节省资源的。对流来说——恰恰相反:通过延迟字节,代理摧毁了流本身的价值。这个价值在于及时性,而不在于体积。

八个缓冲点的地图

我们沿着链路走一遍,标出每一个数据可能卡住的位置。诊断时请把这份清单放在手边。

  1. 应用。框架自己可能缓冲输出。WSGI 服务器、开启了 output_buffering 的 PHP、带压缩中间件的 Node.js 框架。没有调用 flush——数据就躺在进程缓冲区里。
  2. 应用前方的反向代理。nginx 开启 proxy_buffering(默认开启)时,会把响应攒进由 proxy_buffer_size 和 proxy_buffers 指定的缓冲区,溢出时写入磁盘上的临时文件。Apache mod_proxy 缓冲较少,但也有自己的设置。Caddy 默认不缓冲,但要检查 flush_interval。
  3. 代理上的压缩。即使 proxy_buffering off,开启的 gzip 也会把数据积累到压缩窗口大小。这是最阴险的点之一:缓冲名义上关了,但流一波一波地走。
  4. L7 负载均衡器。HAProxy 在 http 模式下会随到随传,前提是没有开启 http-buffer-request,但受 tune.bufsize 限制。Envoy 默认流式,但压缩或 Lua 过滤器可能积累响应体。
  5. CDN 和云网关。许多 CDN 为缓存和压缩而缓冲响应。部分提供商不支持超过特定时长的流,或需要显式配置。云 API 网关通常有约 30 秒的硬响应时间限制,而且根本不支持响应体流式传输。
  6. 客户端侧的出口代理。你用来访问互联网的 HTTP 代理——企业、移动、住宅——也是一个 HTTP 解析器。如果它基于 nginx 或 Squid 构建并配置了缓冲,流就会卡在那里。高质量的代理服务会透明地传递 chunked 响应,但这需要实践检验。
  7. TLS 和 TCP。如果库把数据攒到 16KB 才发送,数据可能滞留在 TLS 记录中。Nagle 算法会把小 TCP 段延迟到前一个被确认。对于由小块组成的流,这每块增加几十毫秒。
  8. 客户端库。Python 的 requests 如果没有传 stream=True,会把整个响应体读进内存。一些 HTTP 客户端会缓冲到 chunk_size 大小。

八个点。只要有一个在积累数据,你就会看到流一波一波地走,或在最后变成一大块。最糟糕的是:行为取决于数据量。在小响应上看起来一切正常,但在负载下或长响应上缓冲区被填满,开始写入临时文件,延迟就飙升。难怪许多团队只有在生产环境才发现问题。

HTTP/1.1 与 HTTP/2 在流场景下的对比

在 HTTP/1.1 中,一个连接在同一时间只能有一个响应。长活响应会占满整个连接。浏览器限制到单个主机的并发连接数为六个,因此六个打开的 SSE 流就会阻塞对该主机的所有其他请求。与后端按 HTTP/1.1 通信的代理,也会为每个流保持一个连接。

在 HTTP/2 中,多路复用消除了这个限制:一百个流可以活在一个 TCP 连接里。但出现了一个微妙之处——协议级的流控制。如果接收方不通过 WINDOW_UPDATE 扩大窗口,发送方就会停下来。一些代理在转发这些帧时实现得不够仔细,造成人为停顿。

重要的是要明白:代理可以从客户端接收 HTTP/2 请求,然后按 HTTP/1.1 访问后端。它把 DATA 帧重新打包成块,反之亦然。这是正常操作,但正是在转换边界上,及时的 flush 经常丢失——代理会等到积累了“方便”的帧大小。

超时——流的第二个杀手

缓冲延迟数据。超时断开连接。nginx 有 proxy_read_timeout —— 两次连续从后端读取操作之间的最长时间,默认 60 秒。如果服务器沉默超过一分钟,nginx 就关闭连接并向客户端返回 504。对于等待 90 秒的 long-polling,这是必然的失败。HAProxy 有 timeout server 和 timeout tunnel。云负载均衡器有空闲超时,通常是 60 或 350 秒。移动运营商的 NAT 超时会在几分钟后重置不活跃的连接。

由此得出一条铁律:没有周期性活动的流注定失败。每 15-30 秒发送一次心跳消息——不是选项,而是任何长活响应的强制要求。

机制选择矩阵

在进入实践之前,先固定选择框架。回答四个问题。

  • 你是否控制整条代理链?是——chunked 和 SSE 都适合。否,链中有未知网关——先从 long-polling 开始,或准备好降级到它。
  • 客户端是谁?浏览器——带 EventSource 的 SSE 免费提供重连。自己的代码——带 NDJSON 的 chunked 更灵活。
  • 数据的性质是什么?同一实体的片段(同一个回答的 token)——chunked 或 SSE。离散的独立事件——SSE 或 long-polling。
  • 频率如何?每秒几十个事件——chunked 或带批处理的 SSE。每分钟一个事件——大超时的 long-polling 或带心跳的 SSE。

方法 1:chunked transfer encoding —— 无包装的底层流

何时选择纯 chunked

纯 chunked 流适用于客户端是你自己的代码而不是浏览器时;数据格式不是文本或不符合事件模型时;需要对每个字节有最大控制时。典型例子:从 API 流式输出 NDJSON、流式返回爬虫结果、下载大型导出并显示进度、以自有格式代理 LLM 响应。

服务端分步配置

  1. 确保应用分块写入。每个逻辑片段后调用 flush。Python 配 ASGI 服务器时,就是产出字节的生成器;Node.js 中是 res.write 后跟 flush(如果涉及压缩);Go 中是每次 Write 后调用 http.Flusher 接口。
  2. 不要设置 Content-Length。大多数框架在未指定长度时会自动切换到 chunked。检查 HTTP/1.1 下响应中是否存在 Transfer-Encoding: chunked。
  3. 为流式路由关闭应用层压缩,或确保它随数据一起 flush。折中方案是 gzip 在每个块后同步 flush;这可行,但会降低压缩率。
  4. 设置 X-Accel-Buffering: no 头。这是 nginx 特有的头,能在不修改全局配置的情况下针对单个响应关闭缓冲。部分其他代理也认得它。还要加上 Cache-Control: no-cache, no-transform —— 第二个值请求中间节点不要修改响应体。
  5. 配置反向代理。对于 nginx 流式路由的 location:proxy_buffering off; proxy_cache off; proxy_http_version 1.1; proxy_set_header Connection ''; proxy_read_timeout 3600s; gzip off;。proxy_http_version 1.1 是强制性的:nginx 默认按 HTTP/1.0 访问后端,那里不存在 chunked,于是 nginx 被迫缓冲直到连接关闭。
  6. 分离路由。如果其他 API 需要压缩,只在非流式 location 块中启用。
  7. 检查 Nagle 算法。nginx 中 tcp_nodelay 默认开启,但在应用中面对细小频繁的块时,可能需要在套接字上显式设置 TCP_NODELAY。

HAProxy 和 Envoy 配置

HAProxy。在 backend 段中不要使用 option http-buffer-request。确保 timeout server 对你的场景足够大,而对真正长时间的流,设置 timeout tunnel。通过 ACL 为流式路径禁用压缩,或依赖 no-transform 头:HAProxy 尊重 Cache-Control: no-transform,不会压缩这类响应。

Envoy。默认关闭缓冲,这很好。但要检查两个超时:HTTP connection manager 中的 stream_idle_timeout(默认五分钟)和 route timeout(默认十五秒——它最常断开流)。对于流式路由,把 timeout 设为 0s,即无限制,并依靠空闲超时结合心跳。

chunked 流检查清单

  • 响应中有 Transfer-Encoding: chunked,或使用 HTTP/2 且无 Content-Length。
  • 应用响应中存在 X-Accel-Buffering: no 头。
  • 没有 Content-Encoding,或压缩与数据一起 flush。
  • 第一个响应体字节在头部后一秒内到达。
  • 客户端块间间隔与服务器生成间隔的误差不超过 50 毫秒。
  • 有心跳时连接能活过一分钟而不中断。
  • 代理日志中没有写入临时文件的缓冲记录。

方法 2:Server-Sent Events —— 服务端到客户端事件的标准

格式结构

SSE 是一种关于如何在文本流中组织事件的约定。响应的 Content-Type: text/event-stream。每个事件是一组形如“field: value”的行,以空行结束。字段:data —— 有效载荷(可以重复,行之间用换行符拼接);event —— 事件类型名;id —— 用于恢复的标识符;retry —— 建议的重连延迟(毫秒)。以冒号开头的行是注释,这是理想的心跳:浏览器忽略它,而代理看到连接上有活动。

SSE 的美妙之处在于不对称性。复杂性被放进规范与浏览器,而服务器保持简单。没有握手,没有二进制分帧。只是流动的文本。正因如此,SSE 成了语言模型响应流式传输的事实标准:绝大多数大型 LLM API 都以 text/event-stream 格式输出 token。令人惊讶的是,这项在十五多年前就被写进规范的技术,在 2026 年迎来了第二次青春。

为什么 SSE 对缓冲特别敏感

一个 SSE 事件从几十字节到几KB不等。nginx 的默认缓冲区是第一个块 4 或 8KB,之后是八个 4-8KB 的块。这意味着代理会积累五十到几百个事件才发出第一个。对于与模型的聊天,表现是:用户等十五秒,然后整段文字瞬间出现。逐字打字的幻觉被打破,而流式传输本来就是为了它才引入的。

通过代理实现 SSE 的分步指南

  1. 响应头:Content-Type: text/event-stream; charset=utf-8,Cache-Control: no-cache, no-transform,X-Accel-Buffering: no,对于 HTTP/1.1 还要 Connection: keep-alive。
  2. 心跳。每 15-25 秒发送一行注释,形如 : ping。这比任何合理的空闲超时都短,并保持运营商 NAT 表处于活跃状态。
  3. 事件标识符。给每个事件分配单调递增的 id。重连时浏览器会发送 Last-Event-ID 头,服务器就能补发遗漏的内容。没有它,代理上的任何中断都是数据丢失。
  4. retry 字段。设置一个合理的值,比如 3000 毫秒,以免服务器重启时客户端发起重连风暴。
  5. nginx 配置 —— 与 chunked 相同。额外确保 text/event-stream 不应用 gzip:如果 gzip_types 包含 text/*,添加一个单独的 location 并 gzip off。
  6. 连接规划。HTTP/1.1 下每个打开的 SSE 流都是代理与后端之间的一个独立连接。一千个并发客户端需要一千个连接。客户端侧使用 HTTP/2,后端使用异步服务器。
  7. 处理关闭。服务器应检测客户端断开连接并停止生成。通过代理时这会有延迟:服务器只有在尝试写入时才知道断开。对于模型推理这类昂贵操作,这白白浪费了几秒钟 GPU 时间。解决办法是定期写入心跳,在连接断开时触发写错误。

SSE 与 HTTP/2:注意事项

通过 HTTP/2,SSE 不受六连接限制——这是在前端代理上启用 HTTP/2 的主要原因。然而,当把 HTTP/2 转成到后端的 HTTP/1.1 时,一些代理会因帧聚合而增加轻微延迟。确保第一个事件立即发出,而不是等待帧被填满。如果后端也说 HTTP/2,延迟最小,但要检查代理是否正确转发 WINDOW_UPDATE,以及是否因窗口控制而压制了流。

SSE 流设计框架

  1. 确定事件类型及其频率。稀有事件需要心跳;频繁事件需要在单个事件内批处理多个写入。
  2. 选择恢复策略:在服务器上保存最近事件的环形缓冲区以处理 Last-Event-ID,或依靠重连时的完全重新同步。
  3. 设置单个流的时长上限。良好实践是服务器每 5-10 分钟自行关闭流,客户端透明重连。这防止状态积累,并绕过基础设施的隐藏超时。
  4. 考虑降级:如果流无法通过代理,自动切换到 long-polling。

方法 3:long-polling —— 由普通响应序列组成的流

如何工作,为什么仍然有用

Long-polling 是三种方法中最古老的一种。客户端发送请求,服务器不立即响应,而是等待事件直到指定超时(通常 20-60 秒)。事件来了——服务器响应并关闭。什么都没来——返回空响应。客户端立即发送下一个请求。从外部看,这像是一个延迟极小的流,但每个响应都是普通的、带 Content-Length 的、完全兼容任何代理、任何缓存和任何网关的响应。

为什么 2026 年 long-polling 还活得好好的?因为它处处可通。穿过切断 chunked 的企业网关。穿过有响应时间限制的云 API 网关。穿过缓冲行为不可预测的代理服务器。最著名的例子是某个大型即时通讯工具 Bot API 中获取更新的方法,其中 timeout 参数指定等待时长。绝大多数机器人多年来正是这样通过各种各样的代理工作的,而且没有问题。

通过代理设计 long-polling 的五条规则

  1. 服务器超时小于链路中最短的超时。如果代理的 proxy_read_timeout 是 60 秒,服务器等待不超过 50。如果链中有 30 秒的云网关——不超过 25。否则客户端收到的不是空响应而是 504,错误流会让监控疯掉。
  2. 游标或 offset。客户端传递最后收到的事件的标识符。服务器返回它之后出现的所有内容。协议变得幂等:丢失的响应只是导致重新发出相同事件。
  3. 错误重连的抖动。指数增长延迟——1、2、4、8 秒——加上随机附加值。没有抖动,一千个客户端在故障后会同时冲击服务器。
  4. 成功响应后零停顿。下一个请求立即发出。这里的任何停顿都是延迟的损失。
  5. Keep-alive 是必须的。没有它,每个请求都是新的 TCP 连接和新的 TLS 握手。这会给每个周期增加 50 到 300 毫秒,通过远程代理则更多。

分步实现

  1. 服务器:端点接受 offset 和 timeout,在内部分队列上或通过订阅等待事件,返回带新 offset 的事件数组。空数组是正常响应,不是错误。
  2. 代理:标准配置,但 proxy_read_timeout 不小于服务器超时加十秒余量。缓冲可以保持开启——响应短小且完整。
  3. 客户端:循环处理三种结果——有数据、空响应、错误。单一连接池、keep-alive、客户端超时大于服务器超时。
  4. 监控:空响应比例、平均等待时间、5xx 和客户端超时频率。

Long-polling 何时不划算

当事件频率高时,头部和请求-响应循环的开销变得明显。当有数千客户端时,服务器需要保持数千个等待中的请求——没有异步栈就办不到。当然,long-polling 不适合流式传输单个长响应,即需要同一实体的片段序列的情况。通过 long-polling 传输语言模型 token——理论上可行,实践上很笨拙。

方法 4:通过出口代理消费流式响应

场景特点

到目前为止,我们都是从服务器所有者的视角看问题。现在我们把画面翻转过来:你是客户端,通过代理服务器访问他人的流式 API,只有客户端侧取决于你。典型任务:通过地址池从流式 API 采集数据、从自动化脚本使用 LLM 流式输出、按不同 IP 分配 API 负载、实时跟踪平台事件、从不同网络测试自己的服务。

这里重要的是三点。代理本身必须透明地传递 chunked 响应。客户端库必须随到随读流。你必须能区分代理问题和目标服务器问题。

检查代理对流是否透明

  1. 取一个明确流式的端点——一个公共测试服务,它带延迟地返回行;或你自己的、有已知块发送时间表的端点。
  2. 用 curl 带 -N 标志(禁用 curl 自身的输出缓冲)和 --trace-time 标志(时间戳)直接和通过代理执行请求。比较片段到达的时刻。
  3. 如果通过代理所有片段在最后一起到达——代理完全缓冲。若成几KB的块——部分缓冲。若与直接请求一致——透明。
  4. 用带心跳的长流(5-10 分钟)测试。在固定时间后断开说明代理有空闲超时。
  5. 测试 HTTPS。通过使用 CONNECT 方法的代理时,会创建隧道,代理不解析内部的 HTTP——HTTP 级缓冲不可能存在,只有 TCP 延迟。这也是为什么通过 CONNECT 隧道的流式 API 通常比通过解析请求的普通 HTTP 代理更稳定。

关于移动代理的微妙之处:蜂窝网络本身就会增加抖动,运营商的 NAT 会积极关闭不活跃连接。对于通过移动代理的长流,每 15-20 秒一次心跳是必要的。按计划轮换 IP 时必须考虑打开的流:在 SSE 连接中途更换地址必然断开它。将轮换与流的生命周期对齐——关闭流、更换地址、带游标打开新流。

客户端库:该启用什么

  • Python, requests:调用时加 stream=True,然后用 iter_lines 或带小 chunk_size 的 iter_content。超时设为元组 (connect, read),其中 read 是块之间的允许时间,而不是总响应时间。
  • Python, httpx:异步代码用 client.stream 和 aiter_lines;对于 SSE——用解析事件格式的专用封装。
  • Python, aiohttp:response.content.iter_any 按数据从套接字出来的原样返回,不重新打包——非常适合测量真实间隔。
  • Node.js:用 fetch 并把 response.body 读作 ReadableStream;对于 SSE——用格式解析库。
  • Go:普通 http.Client,通过 bufio.Scanner 读 resp.Body,缓冲区要足够大以容纳大事件。

在所有情况下:不要调用会读取整个响应体的方法——text、json、无参数的 read。否则客户端会等待连接关闭,而你会怪罪并不存在的代理缓冲。

“三点”诊断协议

当流行为异常时,在三种配置下测量首字节时间和块间间隔分布:从同一台机器直接连服务器;通过代理连服务器;通过代理连参考流式端点。比较能明确地定位问题。通过代理连参考好,连目标服务器坏——目标服务器基础设施的问题。连参考坏——代理的问题。直接连也坏——你的代码或网络的问题。这个协议花十分钟,却能省下几天的争论。

通过代理处理流时的典型错误

  1. 关闭了 proxy_buffering,却忘了 gzip。最常见的错误。流名义上不缓冲,但压缩会把数据积累到窗口大小。症状:几KB的突涌。
  2. 保留了 proxy_http_version 1.0。nginx 默认按 HTTP/1.0 访问后端,那里不存在 chunked,于是不得不等连接关闭。症状:整个响应在最后到达。
  3. 不发送心跳。流只能活到链中第一个空闲超时——nginx 的 60 秒、Envoy 路由的 15 秒、NAT 的几分钟。症状:以相同间隔断开。
  4. Long-polling 超时大于代理超时。客户端收到 504 而不是空响应,监控红灯,事件可能重复。
  5. 依赖代理的全局设置。迁移到新环境或更换 CDN 时,流式传输会静默失效。解决办法——在响应层面使用 X-Accel-Buffering 和 no-transform:行为由应用决定,而不是代理管理员。
  6. 没有 Last-Event-ID 和游标。任何中断都是数据丢失。通过代理时中断比直连明显更频繁。
  7. 在客户端读取整个响应体。忘了 stream=True,客户端等待完成,开发者怪代理。
  8. 在打开的流期间轮换 IP。连接断开,没有重连,数据丢失。
  9. 只在短响应上测试。缓冲区来不及填满,一切看起来很好。在生产环境的长期响应上开始写临时文件,延迟飙升。
  10. 在同一个 location 中混用流式和普通路由。要么破坏流式传输,要么失去普通响应的压缩和缓冲,打击整个 API 的性能。
  11. 忽略客户端断开连接。通过代理,服务器很晚才知道断开,并继续昂贵的生成。对 LLM 推理来说是白花的钱。
  12. 在本应使用 long-polling 的地方用 chunked。通过有响应限制的企业网关或云 API 网关,流无法通过,而 long-polling 能毫无问题地通过。

配置和诊断的工具与资源

反向代理和负载均衡器

  • nginx —— 灵活性的标杆。关键指令:proxy_buffering、proxy_http_version、proxy_read_timeout、gzip,以及对 X-Accel-Buffering 头的支持。
  • HAProxy —— 开箱即用缓冲最少。关注 timeout server、timeout tunnel 和压缩。
  • Envoy —— 默认流式。关键是 route timeout 和 stream_idle_timeout。
  • Caddy —— 默认不缓冲;flush_interval 设为 -1 表示显式立即 flush。
  • Traefik —— 透明传递流;超时在 entrypoints 层面配置。

诊断

  • curl 带 -N、-v 和 --trace-time 显示每个片段到达的时刻。-w 参数配合 time_starttransfer 和 time_total 变量给出首字节和总时间。
  • tcpdump 和 Wireshark —— 检查字节是在网络层就延迟了,还是在上层被滞留。
  • mitmproxy —— 查看流并保留块结构。一定要开启流式模式,否则它自己就变成了缓冲点。
  • 浏览器开发者工具 —— EventStream 标签页显示每个事件及其时间戳。

测试端点和库

用于测试 HTTP 的公共服务有按指定数量带延迟返回行的端点——它们非常适合检查代理透明度。用任何语言自建的最小服务器,每秒返回一个带时间戳的块,甚至更好:你控制双方。对于服务器端的 SSE,几乎任何异步框架都有现成的 text/event-stream 响应类。对于浏览器外的 SSE 客户端,Python、Node.js 和 Go 都有格式解析器。Long-polling 不需要特殊库——一个带连接池的 HTTP 客户端就够了。

监控

值得收集的指标:响应体首字节时间;块间间隔的 50、95、99 百分位分布;流的存活时长和关闭原因;代理和后端上的活跃流数量;带 Last-Event-ID 的重连比例。在体积同时增长时块间间隔骤增——缓冲启用的明确信号。

案例与结果:真实项目中的表现

案例 1. 通过 nginx 流式调用 LLM:从 11 秒到 310 毫秒

一个团队上线了基于语言模型的聊天。本地 token 平滑出现。部署到 nginx 后面后,用户看到空屏 8-12 秒,然后整个回答一下子出现。按“三点”协议诊断显示:直连应用首 token 在 280 毫秒到达,通过 nginx——11 秒。原因很经典:proxy_buffering on 和默认的 proxy_http_version 1.0。在路由上加上 proxy_buffering off、proxy_http_version 1.1、gzip off,并在应用响应中加 X-Accel-Buffering: no 后,通过代理的首 token 时间是 310 毫秒。附带发现:关闭标签页后推理仍继续到回答结束。在引入带写错误检查的心跳后,被放弃请求的 GPU 时间消耗下降了约四分之一。

案例 2. 基于 SSE 的仪表盘和移动网络

一个监控服务通过 SSE 发送事件。有线网络上一切正常,但从移动设备上流会在 2-4 分钟后断开,服务器端无错误。原因是运营商 NAT 对不活跃连接的超时。解决办法:每 20 秒一次心跳注释,加上服务器每 10 分钟带正确 Last-Event-ID 强制关闭流。“仪表盘卡住”的投诉几乎降到零,连续流的平均时长从 3 分钟升到 10 分钟(已由有意关闭限制),重连时未记录到事件丢失。

案例 3. 通过移动代理池爬取流式 API

团队通过移动代理池从以 NDJSON 流式输出数据的平台采集事件。观察到两个问题:部分流以 8KB 的块突涌,部分在地址轮换时断开。测试表明,对于未加密请求,代理会解析 HTTP 并缓冲响应,而通过 CONNECT 隧道到 HTTPS 端点时则透明传递流。切换到 HTTPS 完全解决了第一个问题。第二个通过同步解决:只有在流正确关闭后才轮换 IP,重连使用最后事件的游标。采集数据完整率从约 91% 上升到 99.7%。

案例 4. 在受限网关下使用 long-polling 的机器人

一位开发者的机器人运行在出口请求经过响应限制 30 秒的企业网关的基础设施上。最初使用 60 秒的等待超时——一半请求以网关错误结束,更新重复。在把超时降到 25 秒并加入错误时的指数抖动后,错误率从 48% 降到不足 0.5%。事件送达的平均延迟没有变化——它由事件发生的时刻决定,而不是等待时长。

案例 5. 为 SSE 切换到 HTTP/2

Web 应用每个标签页打开 3-4 个 SSE 流。打开多个标签页时,浏览器耗尽六个连接的限制,普通请求排队排在流后面。在前端代理上启用 HTTP/2 后,所有流进入一个连接。五个标签页打开时页面加载时间从 9 秒降到 1.5 秒。附带发现:切换后需要增大 stream_idle_timeout,因为之前的设置是按 HTTP/1.1 计算的。

FAQ:关于通过代理的流式响应的深入问题

从代理的角度看,流式 HTTP 与 WebSocket 有什么根本区别?

WebSocket 需要协议升级:代理必须识别 Upgrade 和 Connection 头,切换到隧道模式,停止解析 HTTP。流式 HTTP 什么也不需要——它是一个不结束的普通响应。悖论在于,WebSocket 通过代理要么能用要么完全不能用,而流式 HTTP 总是“能用”,但可能用得很糟:数据到了,但延迟了。因此流的问题更难发现和诊断。

为什么 X-Accel-Buffering: no 不总是有效?

这个头只有 nginx 和兼容它的代理理解。CDN、云网关或其他类型的代理会忽略它。此外,X-Accel-Buffering 不影响 gzip——压缩需要单独关闭。如果应用和 nginx 之间有一层会删除非标准头,它就传不到 nginx。

可以压缩流式响应吗?

技术上可以:gzip 支持同步 flush,服务器可以压缩每个块并立即发出。但压缩率会下降,因为字典来不及填充。实践中对 SSE 和 LLM token 会关闭压缩:几个百分点的流量节省不值得延迟风险。对于大型 JSON 对象的流,带 flush 的压缩可能带来明显收益。

如何在 SSE 和 long-polling 之间选择?

如果客户端是浏览器、事件频率高于每几秒一次,且你至少控制反向代理——用 SSE。如果链中有不可控的、有响应时间限制的节点,事件稀少,或需要最大兼容性——用 long-polling。成熟的系统会实现两者,并根据第一次连接的结果自动切换。

HTTP/3 会影响缓冲问题吗?

HTTP/3 运行在 QUIC 之上,消除了传输层的队头阻塞,但缓冲在更高层——代理的逻辑中。入口用 HTTP/3、出口用 HTTP/1.1 的代理缓冲方式完全相同。真正改变的是移动网络中的行为:QUIC 更能承受网络切换和丢包,因此通过 HTTP/3 的流在客户端侧更少断开。

如何判断是出口代理在缓冲,而不是目标服务器?

“三点”法:同一请求直接、通过代理、通过代理连参考流式端点。另外试试通过 CONNECT 的 HTTPS——如果流变平稳了,说明代理在解析并缓冲未加密的 HTTP。

心跳间隔选多少?

小于链中最短的超时,并留两倍余量。对于典型基础设施——15-25 秒,移动网络靠近 15。太频繁的心跳——对数千连接来说是多餘流量和负载,太稀疏——断开。

如果流需要活几个小时怎么办?

不要这样做。设计服务器每 5-15 分钟强制关闭,并用游标恢复。这防止内存积累、泄漏和不可见超时,也简化部署:你重启服务器时不必考虑小时级的连接。

代理如何影响客户端断开的检测?

客户端和服务器之间现在有两个连接。当客户端断开时,代理立即知道,但只有在下一次写入尝试时或按自己的规则才通知服务器。服务器只有在写入时才会注意到断开。由此产生定期写心跳以尽早发现断开并停止昂贵操作的做法。

移动代理需要为流做特殊配置吗?

从用户角度,代理本身通常不可配置。但需要:优先用 HTTPS 以获得透明隧道;将 IP 轮换与流生命周期对齐;心跳不慢于 15-20 秒;使用 keep-alive 和连接池;在上生产前检查每个池的透明度。

结论:总结与下一步

流式 HTTP 不是异类,也不是独立协议。它是一个不急于关闭的普通响应。正因如此,它对中间节点如此脆弱:代理看不出任何特别之处,于是套用为短响应发明的规则。缓冲延迟数据,超时断开连接,压缩掩盖缓冲——而这一切发生在链路的八个不同点上。

三种机制——chunked、SSE 和 long-polling——以不同程度依赖代理透明度地解决同一个任务。Chunked 提供最大控制,代价是客户端自行处理。SSE 提供现成的事件模型和浏览器中的重连,但需要关注每个节点。Long-polling 能穿过任何东西,但以频繁请求的开销为代价。选择由四个问题决定:你是否控制链路、客户端是谁、数据的性质是什么、频率如何。

今天就可以做的事:

  1. 针对你的基础设施走一遍八个缓冲点的地图,标出你控制哪些。
  2. 在流式路由的响应中加上 X-Accel-Buffering: no 和 Cache-Control: no-cache, no-transform —— 无论当前代理配置如何。
  3. 检查 nginx 中的 proxy_http_version、proxy_buffering、gzip 和 proxy_read_timeout,或你代理中的对应项。把流式路由拆到单独的块中。
  4. 引入不慢于每 25 秒一次的心跳,以及带游标的每 5-15 分钟强制关闭流。
  5. 如果你通过代理消费他人的流——在每个地址池上跑一遍“三点”协议,并把流式请求切到 HTTPS。
  6. 配置首字节时间和块间间隔的监控。这是比用户更早发现缓冲的唯一方法。

代理不是流的敌人。配置正确的代理为流增加容错、负载分配和后端保护。任务只是向它解释:这个响应很特别,需要按它到来的方式传递。现在你已经有了一切,让这个解释用它的语言说出来。