Go HTTP服务上线即崩？——中间件链、超时控制、连接池配置的4个致命疏漏（生产环境实录）

第一章：Go HTTP服务上线即崩？——中间件链、超时控制、连接池配置的4个致命疏漏（生产环境实录）

某电商秒杀服务上线5分钟后CPU飙升至98%，HTTP请求大量超时，错误日志中频繁出现 http: Accept error: accept tcp: too many open files 和 context deadline exceeded。根因并非代码逻辑缺陷，而是四个被忽视的底层配置疏漏。

中间件链未设panic恢复机制

Go HTTP中间件若未包裹 recover()，任意中间件或handler中的panic将直接终止goroutine并丢失错误上下文，导致连接泄漏。必须在最外层中间件添加兜底恢复：

func RecoverMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
                log.Printf("PANIC in middleware/handler: %v", err)
            }
        }()
        next.ServeHTTP(w, r)
    })
}

服务器未配置读写超时

http.Server 默认无超时，慢客户端或网络抖动会持续占用goroutine与连接。必须显式设置：

srv := &http.Server{
    Addr:         ":8080",
    Handler:      mux,
    ReadTimeout:  5 * time.Second,   // 防止慢请求阻塞accept队列
    WriteTimeout: 10 * time.Second,  // 防止响应生成过长
    IdleTimeout:  30 * time.Second,  // 防止长连接空闲耗尽文件描述符
}

HTTP客户端连接池未限制最大空闲连接

服务内调用第三方API（如支付网关）时，若 http.DefaultClient 未定制 Transport，默认 MaxIdleConnsPerHost = 0（即不限制），并发激增时瞬间创建数千连接，触发 too many open files。

client := &http.Client{
    Transport: &http.Transport{
        MaxIdleConns:        100,
        MaxIdleConnsPerHost: 100, // 关键：必须显式设为合理值
        IdleConnTimeout:     30 * time.Second,
    },
}

日志中间件阻塞主线程

使用同步I/O日志（如直接 log.Printf）在高并发下成为性能瓶颈。应改用异步日志库（如 zerolog 的 io.MultiWriter + bufio.Writer 缓冲），或至少启用日志采样：

风险项	推荐配置
文件描述符上限	`ulimit -n 65536`（启动前）
Go运行时GOMAXPROCS	设为CPU核心数（非默认0）
连接复用	确保客户端/服务端均启用Keep-Alive

第二章：HTTP中间件链的隐性陷阱与安全加固

2.1 中间件执行顺序错乱导致上下文丢失（理论剖析+panic复现代码）

中间件链的执行顺序直接决定 context.Context 的传递完整性。若中间件未按预期顺序 next()，或在 defer 中误用已失效的 context，将触发 context canceled panic。

panic 复现代码

func BrokenMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx := r.Context()
        defer func() {
            // 错误：defer 在 handler 返回后执行，此时 ctx 可能已被 cancel
            fmt.Println("Cleanup with value:", ctx.Value("key")) // panic!
        }()
        r = r.WithContext(context.WithValue(ctx, "key", "valid"))
        next.ServeHTTP(w, r)
    })
}

该代码在 next.ServeHTTP 返回后执行 defer，但 r.Context() 已被底层 server 取消（如超时/连接关闭），ctx.Value() 触发 panic。

正确执行链要求

中间件必须严格遵循 pre-process → next() → post-process 时序
defer 清理逻辑应绑定到当前中间件创建的子 context，而非原始 r.Context()

风险环节	后果
`next()` 前未派生 context	子中间件无法继承状态
`defer` 引用原始 `r.Context()`	访问已取消 context 导致 panic
中间件跳过 `next()` 调用	上下文链断裂，后续中间件收不到 context

graph TD
    A[Request] --> B[Middleware A: ctx.WithValue]
    B --> C[Middleware B: 读取 ctx.Value]
    C --> D{next() 被跳过？}
    D -- 是 --> E[Context 链中断 → panic]
    D -- 否 --> F[正常传递]

2.2 中间件未正确处理error返回引发的goroutine泄漏（理论模型+pprof验证实验）

理论模型：错误传播断裂导致goroutine悬停

当HTTP中间件在next.ServeHTTP()后忽略err != nil分支，且底层 handler 启动了异步 goroutine（如日志采样、指标上报），该 goroutine 将因无 error 通知而持续等待超时或 channel 关闭——形成泄漏。

复现代码片段

func LeakMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        next.ServeHTTP(w, r) // ❌ 未检查 err；若 next 内部 panic 或写入中断，goroutine 仍运行
        go func() {
            time.Sleep(5 * time.Second) // 模拟异步任务
            log.Println("async done")
        }()
    })
}

逻辑分析：next.ServeHTTP() 不返回 error，但实际可能因连接关闭（broken pipe）提前终止；go func() 却无上下文取消机制，time.Sleep 强制阻塞 5 秒，期间 goroutine 无法被回收。

pprof 验证关键指标

指标	正常值	泄漏态
`goroutines`	~10	持续增长
`goroutine profile`	无 sleep	大量 `time.Sleep` 栈帧

修复路径

使用 r.Context().Done() 监听请求生命周期
中间件统一包装 defer cancel() + select 超时
在 next.ServeHTTP() 后添加 if err := recover(); err != nil { ... } 安全兜底

2.3 全局中间件误拦截健康检查路径导致K8s探针失败（理论边界分析+/health路由调试实录）

问题复现现象

K8s livenessProbe 持续失败，日志显示 /health 返回 401 Unauthorized，而直连 Pod 的 curl http://localhost:8080/health 却返回 200 OK。

中间件拦截链路

// app.js —— 全局中间件注册（含未排除路径）
app.use(authMiddleware); // ❌ 无路径白名单，/health 被强制鉴权
app.use('/api', apiRouter);
app.get('/health', (req, res) => res.status(200).json({ status: 'ok' }));

逻辑分析：authMiddleware 在 Express 中为全局中间件（无路径前缀），优先于 /health 路由注册执行；其内部调用 verifyToken() 时因无 Authorization header 直接 res.status(401).end()，导致探针判定失败。关键参数：app.use() 无路径参数即匹配所有请求。

排查验证表

检查项	结果	说明
`kubectl logs`	401 日志	确认中间件拦截
`kubectl exec`	`curl -v /health` → 200	本地绕过 ingress/网关验证
中间件配置	无 `excludePaths`	缺失健康端点豁免机制

修复方案（mermaid）

graph TD
    A[HTTP Request] --> B{Path === '/health'?}
    B -->|Yes| C[Skip authMiddleware]
    B -->|No| D[Apply authMiddleware]
    C --> E[Return 200 OK]
    D --> F[Verify JWT Token]

2.4 中间件中滥用defer阻塞响应流（理论执行时机图解+流式响应中断复现）

defer 在 HTTP 处理链中的真实生命周期

Go 的 defer 语句在函数返回前按后进先出顺序执行，而非响应写出时。中间件中若在 handler.ServeHTTP 前注册 defer，其执行将延迟至整个 handler 函数退出——此时响应体可能已部分写出，但 http.ResponseWriter 的底层 bufio.Writer 缓冲区尚未刷新，或连接已被关闭。

流式响应中断复现代码

func StreamingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/event-stream")
        w.WriteHeader(http.StatusOK)

        // ⚠️ 危险：defer 在 handler 返回时才触发，但流已开始写入
        defer func() {
            log.Println("defer executed — but client may have disconnected!")
            time.Sleep(5 * time.Second) // 模拟长耗时清理
        }()

        for i := 0; i < 3; i++ {
            fmt.Fprintf(w, "data: message %d\n\n", i)
            w.(http.Flusher).Flush()
            time.Sleep(1 * time.Second)
        }
    })
}

逻辑分析：defer 绑定在中间件 handler 函数作用域，其执行时机与 w.Write 完全解耦；当客户端提前断开（如刷新页面），defer 仍会阻塞 goroutine 5 秒，浪费服务端资源。time.Sleep 参数代表非阻塞清理应避免的同步等待。

正确响应生命周期对照表

阶段	`defer` 执行点	流式响应安全？
`WriteHeader()` 后	❌ 尚未触发	✅ 可写
`Flush()` 调用时	❌ 仍未触发	✅ 可刷
`handler` 函数返回	✅ 立即触发	❌ 已失效

graph TD
    A[Client connects] --> B[Middleware handler starts]
    B --> C[WriteHeader + Start streaming]
    C --> D[Loop: Write + Flush]
    D --> E{Client disconnects?}
    E -->|Yes| F[Connection closed]
    E -->|No| G[Loop continues]
    G --> H[Handler function returns]
    H --> I[defer executes — too late!]

2.5 中间件未适配HTTP/2 Server Push引发Header写入冲突（协议层原理+curl –http2调试对比）

HTTP/2 Server Push 允许服务端在客户端请求前主动推送资源，但其依赖严格的帧序：PUSH_PROMISE 必须在对应 HEADERS 帧之前发送，且响应头只能写入一次。

协议层冲突根源

当中间件（如 Express 的 compression 或自定义日志中间件）在 res.writeHead() 后尝试二次写入 Set-Cookie 或 Content-Encoding，会触发 HTTP/2 的 PROTOCOL_ERROR —— 因为 HEADERS 帧已封帧，不可追加。

curl 调试对比验证

# HTTP/1.1 正常（允许多次writeHead）
curl -v http://localhost:3000/

# HTTP/2 强制失败（Server Push 激活后头冻结）
curl -v --http2 https://localhost:3000/

curl --http2 强制协商 h2，若服务端在 push.stream.sendHeaders() 后调用 res.setHeader()，底层 nghttp2 将拒绝写入并关闭流。

关键修复原则

✅ 所有响应头必须在 res.push().writeHead() 或主响应 writeHead() 前一次性设置
❌ 禁止在 res.push() 返回的 stream 上调用 setHeader()
⚠️ 中间件需检测 res.httpVersion === '2.0' 并跳过 header 注入逻辑

场景	HTTP/1.1 行为	HTTP/2 行为
`res.setHeader('X-Foo', 'bar')` 后 `res.push()`	允许	触发 `CANCEL` 错误
`res.push().writeHead()` 后 `res.setHeader()`	无影响	`PROTOCOL_ERROR`

// ❌ 危险模式：中间件盲目写头
app.use((req, res, next) => {
  res.setHeader('X-Trace-ID', uuid()); // HTTP/2 下可能已封帧！
  next();
});

此代码在 HTTP/2 + Server Push 场景中，若上游已调用 res.push()，setHeader 将静默失败或抛出 ERR_HTTP2_STREAM_ERROR。应改用 res.socket?.alpnProtocol === 'h2' 做条件分支。

第三章：超时控制的三层失效场景与精准治理

3.1 http.Server.ReadTimeout被忽略：慢连接耗尽连接数（理论连接状态机+ab压测对比）

HTTP/1.1 连接在 net.Conn 层建立后，若客户端仅发送部分请求（如只发 GET / HTTP/1.1\r\n 后停滞），ReadTimeout 不会触发——因 http.Server 仅在 readRequest 完成后才启动读超时计时器。

状态机关键路径

// src/net/http/server.go:2780（Go 1.22）
func (c *conn) serve(ctx context.Context) {
    for {
        w, err := c.readRequest(ctx) // ⚠️ 此处阻塞，ReadTimeout未生效！
        if err != nil { /* ... */ }
        serverHandler{c.server}.ServeHTTP(w, w.req)
    }
}

ReadTimeout 仅作用于 w.req.Body.Read() 阶段；而慢连接攻击发生在 TCP 握手→首行解析之间，此时 readRequest 持续阻塞，连接永不释放。

ab 压测对比（100并发，5s超时）

场景	平均延迟	活跃连接数	是否触发 ReadTimeout
正常请求	12ms	2	是
慢连接（首行后停）	—	100+	否（永久阻塞）

graph TD
    A[TCP SYN] --> B[Accept conn]
    B --> C[readRequest: parse method/path]
    C -->|慢连接| D[无限阻塞]
    C -->|完整请求| E[启动 ReadTimeout]
    E --> F[Body.Read timeout]

3.2 context.WithTimeout在Handler内误用导致超时传递断裂（理论context传播链+trace日志追踪）

错误模式：Handler中新建独立context

func badHandler(w http.ResponseWriter, r *http.Request) {
    // ❌ 错误：从零创建新context，切断上游调用链
    ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
    defer cancel()

    result, err := db.Query(ctx, "SELECT ...") // 此ctx无parent，trace ID丢失、deadline不继承
}

context.Background() 丢弃了 r.Context() 中的 trace span、deadline、value 等关键元数据；WithTimeout 仅作用于该分支，无法响应上游已触发的超时。

正确传播链：必须基于请求上下文

✅ 始终以 r.Context() 为父context派生
✅ 调用链各层需显式传递 ctx 参数（不可隐式依赖全局/新背景）
✅ trace日志需通过 ctx.Value(trace.Key) 提取 span，否则链路断裂

超时传播断裂影响对比

场景	上游超时是否触发下游取消	trace链路是否完整	日志可关联性
`context.WithTimeout(r.Context(), ...)`	✅ 是	✅ 是	✅ 可跨服务追踪
`context.WithTimeout(context.Background(), ...)`	❌ 否	❌ 否	❌ 日志孤立

graph TD
    A[Client Request] --> B[HTTP Handler]
    B --> C{ctx = r.Context()}
    C --> D[WithTimeout ctx]
    D --> E[DB Call]
    C -.x.-> F[WithTimeout context.Background()]
    F --> G[Orphaned DB Call]

3.3 外部HTTP调用未设置Client.Timeout引发级联雪崩（理论依赖传播图+go-http-mock压测验证）

雪崩根源：默认零超时的危险性

Go http.DefaultClient 的 Transport 默认不设 ResponseHeaderTimeout、IdleConnTimeout 等，导致底层连接可能无限期挂起。

// ❌ 危险：未显式配置超时，依赖系统默认（可能为0）
client := &http.Client{}

// ✅ 正确：显式声明全链路超时边界
client := &http.Client{
    Timeout: 5 * time.Second, // 覆盖整个Do()生命周期
    Transport: &http.Transport{
        DialContext: (&net.Dialer{
            Timeout:   3 * time.Second,
            KeepAlive: 30 * time.Second,
        }).DialContext,
        ResponseHeaderTimeout: 2 * time.Second,
        IdleConnTimeout:       30 * time.Second,
    },
}

Timeout=5s 是硬性截止阀；ResponseHeaderTimeout=2s 防止服务端迟迟不发响应头；DialContext.Timeout=3s 控制建连阶段。三者嵌套约束，避免单点阻塞扩散。

依赖传播可视化

graph TD
    A[API Gateway] -->|HTTP| B[Order Service]
    B -->|HTTP| C[Inventory Service]
    C -->|HTTP| D[Payment Service]
    D -->|Slow DB/No Timeout| E[DB Hang]
    E -->|阻塞传导| C --> B --> A

压测对比（go-http-mock + vegeta）

场景	P99延迟	错误率	连接堆积数
无Timeout	>120s	98%	2400+
全链路5s	4.2s	0.3%

第四章：标准库net/http连接池的配置反模式与调优实践

4.1 DefaultTransport.MaxIdleConnsPerHost=0导致新建连接泛滥（理论连接复用条件+tcpdump抓包分析）

当 http.DefaultTransport.MaxIdleConnsPerHost = 0 时，Go HTTP 客户端禁用所有空闲连接复用，每次请求均新建 TCP 连接。

连接复用失效的底层条件

HTTP/1.1 复用需同时满足：

响应头含 Connection: keep-alive
Transport.MaxIdleConnsPerHost > 0
连接未超时（IdleConnTimeout 默认30s）

tcpdump 抓包关键证据

# 捕获到连续 5 次请求产生 5 个独立 SYN 包，无 TIME_WAIT 复用迹象
tcpdump -i lo port 8080 -nn -c 15 | grep "S\|ack" | head -10

分析：每请求触发 SYN → SYN-ACK → ACK 三次握手，证实无连接池参与。MaxIdleConnsPerHost=0 强制绕过 idleConn 缓存逻辑，直接调用 dial()。

Go 源码关键路径（net/http/transport.go）

func (t *Transport) getIdleConn(req *Request) (*persistConn, bool) {
    if t.MaxIdleConnsPerHost <= 0 { // ← 直接短路返回 false
        return nil, false
    }
    // ... 后续从 idleConn map 查找逻辑被跳过
}

MaxIdleConnsPerHost ≤ 0 使 getIdleConn() 永远返回 (nil, false)，强制走新建连接分支。

参数	默认值	影响
`MaxIdleConnsPerHost`	`100`	控制每 host 最大空闲连接数
	禁用复用	每请求新建 TCP，加剧 TIME_WAIT 和端口耗尽

graph TD
    A[HTTP Request] --> B{MaxIdleConnsPerHost ≤ 0?}
    B -->|Yes| C[Skip idleConn lookup]
    B -->|No| D[Check idleConn map]
    C --> E[Call dial() → New TCP]
    D -->|Hit| F[Reuse existing conn]
    D -->|Miss| E

4.2 IdleConnTimeout过短引发频繁TLS握手开销（理论TLS会话复用机制+openssl s_client验证）

TLS会话复用的核心价值

当 IdleConnTimeout 设置过短（如 <30s），HTTP/1.1 连接池中的空闲连接被过早关闭，导致后续请求无法复用已建立的 TLS 会话，被迫执行完整握手（耗时 ≈ 2–3 RTT）。

验证会话复用状态

使用 OpenSSL 工具观测实际行为：

# 连续两次请求，观察 Session-ID 是否一致
openssl s_client -connect api.example.com:443 -servername api.example.com -reconnect 2>/dev/null | grep "Session-ID"

逻辑分析：-reconnect 2 发起两次连接；若输出中两次 Session-ID 相同，说明服务端支持并启用了会话复用（RFC 5077）。若不同，则可能因客户端连接被提前回收，或服务端未缓存会话。

关键参数对照表

参数	推荐值	影响
`IdleConnTimeout`	≥ 90s	匹配典型 TLS 会话缓存 TTL（OpenSSL 默认 300s）
`TLSConfig.SessionTicketsDisabled`	`false`	启用 RFC 5077 会话票据复用
`MaxIdleConnsPerHost`	≥ 100	避免连接池瓶颈放大握手压力

握手开销演进示意

graph TD
    A[Client发起请求] --> B{连接池存在空闲HTTPS连接？}
    B -- 是且TLS会话有效 --> C[直接发送应用数据]
    B -- 否或会话过期 --> D[完整TLS握手：ClientHello→ServerHello→...]
    D --> E[新增≈15ms CPU+2RTT延迟]

4.3 Response.Body未Close导致连接无法归还空闲池（理论连接生命周期图+goroutine堆栈泄漏定位）

HTTP客户端复用连接依赖http.Transport的空闲连接池，而Response.Body是io.ReadCloser——必须显式调用Close()才能触发连接回收。

连接生命周期关键节点

resp, err := http.DefaultClient.Do(req)
if err != nil {
    return err
}
defer resp.Body.Close() // ✅ 必须！否则连接永远滞留idle list

resp.Body.Close()内部调用transport.drainBody(resp.Body)，最终执行pconn.unreadHeaderBytes()并触发pconn.closeConn()→t.idleConnChans唤醒等待协程。漏掉此步，连接将卡在idleConn map中，MaxIdleConnsPerHost被无声耗尽。

goroutine泄漏定位线索

pprof/goroutine?debug=2 中高频出现 net/http.(*persistConn).readLoop
http.Transport.IdleConnTimeout 失效（因连接未被标记为idle）

现象	根本原因
QPS下降、timeout激增	空闲池枯竭，新建连接阻塞
`net/http: request canceled (Client.Timeout exceeded)`	连接等待超时而非业务超时

graph TD
    A[Do(req)] --> B{Body.Close() called?}
    B -- Yes --> C[连接归还idleConnMap]
    B -- No --> D[连接滞留idleConnMap<br>直至IdleConnTimeout]
    D --> E[新请求阻塞在getConn]

4.4 自定义RoundTripper未继承DefaultTransport配置引发连接池失效（理论结构体嵌套陷阱+反射比对验证）

Go 标准库 http.Transport 是 http.RoundTripper 接口的默认实现，其内部维护着关键的连接池（idleConn）、超时控制与 TLS 配置。当开发者仅实现 RoundTrip 方法而未嵌入 *http.Transport 时，将丢失全部连接复用能力。

常见错误写法

type MyTransport struct {
    // ❌ 缺少 *http.Transport 嵌入 → 无连接池、无 idleConnMap、无 keep-alive 管理
    timeout time.Duration
}
func (t *MyTransport) RoundTrip(req *http.Request) (*http.Response, error) { /* ... */ }

该结构体无字段继承，http.Client 初始化时无法识别其具备连接池语义，强制新建 TCP 连接。

反射验证差异

字段名	`*http.Transport`	`*MyTransport`
`IdleConnTimeout`	✅ 存在	❌ 不存在
`IdleConn`	✅ map 类型字段	❌ 无

正确嵌入方式

type MyTransport struct {
    *http.Transport // ✅ 必须匿名嵌入，继承全部字段与方法
    customLogger log.Logger
}

嵌入后，http.Client 能通过反射识别 IdleConn 等字段，激活连接复用逻辑。

第五章：从崩溃现场到稳定服务——Go HTTP生产就绪 checklist

崩溃复盘：一次凌晨三点的 502 链路断裂

某电商大促期间，订单服务突现大量 http: Accept error: accept tcp [::]:8080: accept4: too many open files。日志显示连接数飙升至 65,535（ulimit -n 默认值），而 netstat -an | grep :8080 | wc -l 确认 ESTABLISHED 连接达 62,148。根本原因为未设置 http.Server.ReadTimeout 和 WriteTimeout，恶意客户端发起长连接但不发送完整请求，导致 goroutine 泄漏与文件描述符耗尽。

连接管理硬性约束

必须在 http.Server 初始化时显式配置超时与连接限制：

srv := &http.Server{
    Addr:         ":8080",
    Handler:      router,
    ReadTimeout:  5 * time.Second,
    WriteTimeout: 10 * time.Second,
    IdleTimeout:  30 * time.Second,
    MaxHeaderBytes: 1 << 20, // 1MB
}

同时通过 ulimit -n 65536 调整系统级限制，并在 systemd service 文件中添加 LimitNOFILE=65536 持久化配置。

中间件熔断与限流实战

使用 gobreaker + golang.org/x/time/rate 实现双层防护：

组件	配置参数	生产效果
请求限流	`rate.NewLimiter(1000, 2000)`	每秒峰值 1000 QPS，突发容忍 2000
熔断器	`gobreaker.Settings{MaxRequests: 3}`	连续 3 次失败即开启熔断

健康检查端点标准化

暴露 /healthz 端点需验证三项核心依赖：

func healthz(w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
    defer cancel()

    dbOK := db.PingContext(ctx) == nil
    redisOK := redisClient.Ping(ctx).Err() == nil
    esOK := esClient.Ping(ctx) == nil

    status := map[string]bool{"db": dbOK, "redis": redisOK, "es": esOK}
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(status)
}

日志结构化与采样策略

禁用 log.Printf，统一接入 zap 并启用采样：

logger := zap.NewProduction(zap.WrapCore(
    zapcore.NewSamplerCore(
        zapcore.NewCore(encoder, writer, zapcore.InfoLevel),
        time.Second, 100, 100, // 每秒最多记录 100 条，突发允许 100 条
    ),
))

错误追踪链路注入

通过 middleware 注入 OpenTelemetry trace ID：

func TraceIDMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        traceID := r.Header.Get("X-Request-ID")
        if traceID == "" {
            traceID = uuid.New().String()
        }
        r = r.WithContext(context.WithValue(r.Context(), "trace_id", traceID))
        w.Header().Set("X-Request-ID", traceID)
        next.ServeHTTP(w, r)
    })
}

启动探针与优雅关闭流程

flowchart TD
    A[启动 HTTP Server] --> B[执行 DB 连接池预热]
    B --> C[调用 /healthz 自检]
    C --> D{全部依赖健康？}
    D -->|是| E[监听端口并注册服务发现]
    D -->|否| F[退出进程并上报告警]
    G[收到 SIGTERM] --> H[关闭监听器]
    H --> I[等待 30s 活跃请求完成]
    I --> J[强制关闭连接池与缓存客户端]