Go语言直播HTTP/2 Server Push失效真相：ALPN协商失败、SETTINGS帧窗口溢出、流优先级错配

第一章：Go语言直播HTTP/2 Server Push失效真相全景洞察

HTTP/2 Server Push 曾被寄予厚望，尤其在直播低延迟场景中——理论上可通过服务端主动推送关键资源（如播放器 JS、初始分片元数据）规避客户端解析与请求的 RTT 开销。然而在 Go 标准库 net/http 实现中，Server Push 在真实直播服务中普遍失效，其根源并非配置疏漏，而是协议语义、运行时约束与典型使用模式三者叠加的系统性断层。

Server Push 的标准行为边界

Go 的 http.Pusher 接口仅在满足以下全部条件时才触发实际推送帧：

请求必须通过 HTTP/2 协议建立（r.ProtoMajor == 2）；
响应尚未写入 Header（即 w.Header().Set() 后调用 Push() 将静默忽略）；
推送路径必须是绝对路径且与当前请求同源（例如 /live/manifest.m3u8 可推 /js/player.js，但不可推 https://cdn.example.com/loader.js）；
客户端明确声明支持 SETTINGS_ENABLE_PUSH=1（现代 Chrome/Firefox 默认开启，但部分 CDN 或代理会重置该设置）。

Go 1.22+ 中的典型失效链路

直播服务常采用流式响应（flusher := w.(http.Flusher)）持续写入 HLS 分片或 WebRTC 信令。此时常见误用如下：

func liveHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/vnd.apple.mpegurl")
    // ❌ 错误：Header 已发送，Push 调用被丢弃
    if pusher, ok := w.(http.Pusher); ok {
        pusher.Push("/js/player.js", nil) // ← 此处无效果
    }
    // 后续 flush 数据流...
}

正确时机应在 WriteHeader() 之前，且需校验 Pusher 是否可用：

if pusher, ok := w.(http.Pusher); ok && r.ProtoMajor == 2 {
    if err := pusher.Push("/js/player.js", &http.PushOptions{Method: "GET"}); err != nil {
        log.Printf("Push failed: %v", err) // 注意：Go 不抛 panic，仅返回 error
    }
}
w.WriteHeader(http.StatusOK) // 必须在此之后才开始写 body

真实环境验证清单

检查项	验证方式	失效表现
HTTP/2 连接	`curl -I --http2 https://your.live/api`	返回 `HTTP/1.1` 或 `curl: (16) Error in the HTTP2 framing layer`
Push 帧收发	Chrome DevTools → Network → Headers → 查看 `:status: 103 Early Hints`	无 `103` 状态行，且 Response Headers 中缺失 `Link` 字段
代理干扰	在 Nginx 前置代理中添加 `http2_push_preload on;`	若未启用 `http2_push_preload`，Nginx 会剥离所有 PUSH_PROMISE 帧

根本矛盾在于：Server Push 设计面向静态资源预加载，而直播本质是长连接、动态流式响应——二者生命周期模型天然冲突。

第二章：ALPN协商失败的深度剖析与实战修复

2.1 TLS握手流程中ALPN扩展的Go标准库实现机制

ALPN（Application-Layer Protocol Negotiation）在Go的crypto/tls中由客户端与服务器协同完成协议协商，核心逻辑位于clientHandshake和serverHandshake中。

ALPN扩展的注册与序列化

Go通过Config.NextProtos字段声明支持协议列表（如[]string{"h2", "http/1.1"}），在marshalClientHello中自动编码为TLS扩展：

// 源码简化示意：crypto/tls/handshake_client.go
if len(c.config.NextProtos) > 0 {
    ext := append([]byte{}, byte(len(c.config.NextProtos))) // 协议列表长度（1字节）
    for _, proto := range c.config.NextProtos {
        ext = append(ext, byte(len(proto))) // 单个协议名长度
        ext = append(ext, proto...)        // 协议名字节
    }
    hello = append(hello, byte(extTypeALPN>>8), byte(extTypeALPN)) // 扩展类型（0x0010）
    hello = append(hello, byte(len(ext)>>8), byte(len(ext)))       // 扩展长度
    hello = append(hello, ext...)
}

该逻辑将协议名按“长度+内容”紧凑编码，符合RFC 7301规范；extTypeALPN值为0x0010，由tls.ExtensionALPN常量定义。

服务端选择逻辑

服务端在processClientHello中遍历clientHello.alpnProtocols，按Config.NextProtos顺序匹配首个共支持协议，失败则返回alertNoApplicationProtocol。

阶段	关键结构体/方法	ALPN作用点
客户端发送	`clientHello.marshal()`	编码`alpnProtocols`字段
服务端解析	`serverHandshake.processClientHello()`	匹配并设置`c.clientProtocol`
握手完成	`Conn.ConnectionState()`	返回选定协议（如`"h2"`）

graph TD
    A[Client: Config.NextProtos] --> B[Marshal ALPN extension in ClientHello]
    B --> C[Server: parse ALPN list]
    C --> D{Match first common protocol?}
    D -->|Yes| E[Set c.clientProtocol & continue]
    D -->|No| F[Send alertNoApplicationProtocol]

2.2 Wireshark抓包定位ALPN协议不匹配的典型场景

TLS握手中的ALPN扩展解析

ALPN（Application-Layer Protocol Negotiation）在ClientHello与ServerHello的Extension字段中交换。不匹配时，服务端常直接关闭连接（TCP RST），无HTTP响应。

典型失败模式

客户端声明 h2，服务端仅支持 http/1.1
客户端未发送ALPN扩展，但服务端强制要求（如gRPC后端）
ALPN值大小写敏感：H2 ≠ h2

Wireshark过滤与验证

tls.handshake.extension.type == 16 && tls.handshake.extensions_alpn

该显示过滤器精准定位含ALPN的TLS ClientHello数据包；16为IANA分配的ALPN扩展类型码。

字段	含义	示例值
`tls.handshake.extensions_alpn_list_length`	ALPN协议列表总长度（字节）	`8`
`tls.handshake.alpn_protocol`	单个协议标识符（带长度前缀）	`00 02 68 32` → `h2`

协议协商失败流程

graph TD
    A[ClientHello with ALPN=h2] --> B{Server supports h2?}
    B -->|Yes| C[ServerHello with ALPN=h2]
    B -->|No| D[TCP RST / empty ServerHello]

2.3 net/http与crypto/tls中ALPN策略配置的隐式约束分析

Go 的 net/http 与 crypto/tls 在启用 TLS 时默认协商 ALPN（Application-Layer Protocol Negotiation），但其行为受多重隐式约束。

ALPN 协议列表的优先级隐含规则

http.Server 启动时若未显式配置 TLSConfig.NextProtos，会自动注入 ["h2", "http/1.1"]；但顺序决定协商结果——客户端仅选择首个共同支持协议。

隐式约束示例代码

srv := &http.Server{
    Addr: ":443",
    TLSConfig: &tls.Config{
        NextProtos: []string{"http/1.1"}, // 覆盖默认 h2 优先级
    },
}

此配置强制降级至 HTTP/1.1：NextProtos 非空时，http.Server 不再自动追加 "h2"；且 crypto/tls 严格按切片顺序匹配，无回退机制。

关键约束对比

约束维度	行为说明
`NextProtos` 为空	自动注入 `["h2","http/1.1"]`
`NextProtos` 非空	完全忽略自动注入，仅用用户指定列表
客户端不支持首项	TLS 握手失败（非降级）

graph TD
    A[Server TLSConfig.NextProtos] -->|nil| B[自动注入 h2,http/1.1]
    A -->|non-nil| C[仅使用用户列表]
    C --> D[按序匹配首个共支持协议]
    D -->|无匹配| E[TLS handshake failure]

2.4 基于http.Server.TLSConfig的ALPN协商强制对齐实践

ALPN（Application-Layer Protocol Negotiation）是TLS握手阶段协商应用层协议的关键机制，直接影响HTTP/2、HTTP/3及自定义协议的启用。

ALPN 协商失败的典型场景

客户端声明 h2，但服务端未配置对应 ALPN ID
TLS 1.2 与 TLS 1.3 对 ALPN 处理逻辑存在细微差异
反向代理（如 Nginx）与 Go 后端 ALPN 配置不一致

强制对齐的核心配置

srv := &http.Server{
    Addr: ":443",
    TLSConfig: &tls.Config{
        NextProtos: []string{"h2", "http/1.1"}, // 严格声明优先级顺序
        MinVersion: tls.VersionTLS12,
    },
}

NextProtos 是 ALPN 协商的唯一信源：Go 会按数组顺序向客户端提供协议列表，并拒绝所有未声明的协议（如 h3），从而实现服务端主导的强制对齐。省略该字段将导致 ALPN 扩展被完全禁用。

ALPN 协议支持对照表

协议标识	HTTP 版本	是否需 TLS 1.3	Go 标准库支持
`h2`	HTTP/2	否	✅（默认启用）
`http/1.1`	HTTP/1.1	否	✅
`h3`	HTTP/3	是	❌（需第三方库）

graph TD
    A[Client Hello] --> B{Server TLSConfig.NextProtos?}
    B -->|Yes| C[返回匹配的ALPN ID]
    B -->|No| D[ALPN扩展不发送]
    C --> E[连接使用协商协议]
    D --> F[降级为HTTP/1.1明文协商]

2.5 多CDN环境下ALPN协商失败的灰度验证与回滚方案

在多CDN共存架构中，ALPN（Application-Layer Protocol Negotiation）协商失败常导致HTTP/2降级至HTTP/1.1，引发首屏延迟激增。需通过灰度流量精准识别异常CDN节点。

灰度探针部署策略

按地域+CDN厂商双维度切流（如：cdn_a:shanghai 5% → cdn_b:beijing 2%）
TLS握手阶段注入ALPN日志埋点，上报alpn_protocol, server_name, negotiated字段

实时检测逻辑（Go片段）

// 检测ALPN协商结果异常（空值或非预期协议）
if !sniMatch || len(conn.ConnectionState().NegotiatedProtocol) == 0 {
    metrics.Inc("alpn_fail", "cdn", cdnName, "region", region)
    if isGrayTraffic(req) {
        triggerRollback(cdnName) // 触发该CDN节点自动隔离
    }
}

逻辑说明：NegotiatedProtocol为空表明ALPN协商未达成；isGrayTraffic()基于请求Header中X-Gray-ID与预设规则匹配；triggerRollback()调用CDN控制面API下线异常节点。

回滚决策矩阵

CDN厂商	灰度失败率阈值	自动回滚延迟	人工确认开关
CDN-A	>3.5%	60s	关
CDN-B	>1.2%	15s	开

graph TD
    A[HTTPS请求] --> B{ALPN协商成功？}
    B -->|否| C[上报指标+灰度标识校验]
    C --> D{是否灰度流量？}
    D -->|是| E[触发CDN节点隔离]
    D -->|否| F[仅告警]
    E --> G[更新路由权重为0]

第三章：SETTINGS帧窗口溢出的原理溯源与压测验证

3.1 HTTP/2流控模型与初始窗口大小在Go runtime中的硬编码逻辑

HTTP/2 流控是连接级与流级双层窗口机制，Go 的 net/http 包在初始化时直接硬编码关键阈值：

// src/net/http/h2_bundle.go（简化自 go/src/net/http/h2_bundle.go）
const (
    InitialWindowSize     = 65535 // 连接级与流级默认窗口（字节）
    MinInitialWindowSize = 1 << 14 // 16384，RFC 7540 要求最小值
)

该值被用于 SettingsFrame 发送及本地流控状态初始化，不可运行时动态覆盖。

窗口演进约束

所有新流继承 InitialWindowSize，后续通过 WINDOW_UPDATE 帧调整；
Go 不支持 per-stream SETTINGS_INITIAL_WINDOW_SIZE 协商，仅使用全局常量；
超出窗口的 DATA 帧会被静默缓冲或阻塞，不触发 RST_STREAM。

关键参数对照表

参数	Go 实现值	RFC 7540 规定	是否可配置
`SETTINGS_INITIAL_WINDOW_SIZE`	65535	65535（默认），≥16384	❌（编译期常量）
`SETTINGS_MAX_FRAME_SIZE`	16384	16384–16777215	✅（`http2.Server.MaxFrameSize`）

graph TD
    A[Client CONNECT] --> B[Send SETTINGS<br>INITIAL_WINDOW_SIZE=65535]
    B --> C[Server applies const InitialWindowSize]
    C --> D[每个新Stream<br>receiveWindow = 65535]
    D --> E[DATA帧受此窗口实时约束]

3.2 直播场景下高并发Push导致SETTINGS_WINDOW_UPDATE风暴的复现方法

复现前提条件

HTTP/2 客户端启用自动流控（autoFlowControl = true）
服务端在单次响应中向数百个活跃流并发推送（PUSH_PROMISE + HEADERS + DATA）
客户端窗口初始值设为 65535，未及时发送 WINDOW_UPDATE

关键触发代码

# 模拟100个并发PUSH流（伪代码，基于h2库）
for i in range(100):
    conn.send_push_promise(
        stream_id=1,
        promised_stream_id=2 + i,
        headers=[(":method", "GET"), (":path", "/chunk")]
    )
    conn.send_data(2 + i, b"payload" * 1024, end_stream=True)

逻辑分析：每个 PUSH_PROMISE 触发新流，send_data 立即消耗 connection_window 和 stream_window；当累计消耗 > 65535 时，客户端必须密集回发 SETTINGS_WINDOW_UPDATE 帧，形成风暴。

风暴特征对比

指标	正常Push（≤10流）	风暴场景（≥80流）
`WINDOW_UPDATE` 频率		> 300/s
平均延迟波动	±2ms	±47ms

根本路径

graph TD
    A[服务端并发PUSH] --> B[客户端窗口快速耗尽]
    B --> C[触发批量WINDOW_UPDATE生成]
    C --> D[UDP包碎片化+ACK竞争]
    D --> E[RTT尖刺→更多重传→更频繁更新]

3.3 通过golang.org/x/net/http2调试日志追踪窗口溢出链路

HTTP/2 流量控制依赖于流级窗口（Stream Flow Control）与连接级窗口（Connection Flow Control）两级协同。当接收端未及时消费数据，窗口持续缩小至0，发送端将暂停帧发送，触发 WINDOW_UPDATE 链路反馈。

启用 HTTP/2 调试日志

import "golang.org/x/net/http2"

func init() {
    http2.VerboseLogs = true // 启用底层帧级日志（含 WINDOW_UPDATE、DATA size、flow control delta）
}

该设置使 net/http 默认 Transport 自动注入 http2.Transport 并输出 http2: FLOW CONTROL 等关键事件，无需修改业务代码。

窗口溢出典型日志模式

日志片段	含义	关键参数
`http2: FLOW CONTROL stream=5, conn=128, delta=-1024`	流5消费1024字节，释放窗口	`delta < 0` 表示接收方调用 `Read()` 后归还额度
`http2: FLOW CONTROL stream=5, conn=0, delta=0`	连接窗口耗尽，阻塞所有流	`conn=0` 是窗口溢出核心信号

窗口阻塞传播链路

graph TD
    A[Client 发送 DATA] --> B{流窗口 > 0?}
    B -->|是| C[继续发送]
    B -->|否| D[等待 WINDOW_UPDATE]
    D --> E[接收端 Read 缓冲区满]
    E --> F[未调用 Read 或 goroutine 阻塞]
    F --> G[流窗口无法归还 → 连接窗口归零]

根本原因常为：io.ReadFull 阻塞、http.Request.Body 未关闭、或 bufio.Reader 未及时 Peek/Discard。

第四章：流优先级错配引发的Push饥饿问题诊断与调优

4.1 HTTP/2依赖树与权重分配在Go http2.transport中的调度偏差

HTTP/2通过依赖树（Dependency Tree） 和显式权重（Weight） 实现多路复用流的优先级调度，但 Go 的 net/http2.Transport 在实现中存在调度偏差：它仅在流创建时静态快照依赖关系，未动态响应权重变更。

依赖树的构建逻辑

Go 使用 http2.priorityFrame 构建初始依赖，但忽略后续 PRIORITY 帧更新——导致权重漂移：

// src/net/http2/transport.go:856
func (t *Transport) newClientConn() {
    // ⚠️ 仅在流初始化时读取权重，不监听后续PRIORITY帧
    f := &http2.PriorityFrame{
        StreamID: streamID,
        Weight:   uint8(weight), // 固定为初始值，非运行时更新
    }
}

此处 Weight 被截断为 uint8（0–255），且未注册 onPriority 回调，使服务端动态调权失效。

调度偏差影响对比

场景	标准 HTTP/2 行为	Go http2.Transport 行为
权重动态调整	立即重排依赖树调度顺序	忽略，维持初始权重排序
依赖环检测	拒绝非法依赖（RFC 7540 §5.3.3）	允许构造循环依赖，触发 panic

流量调度偏差示意图

graph TD
    A[Stream A: weight=16] -->|Go 静态快照| C[Scheduler Queue]
    B[Stream B: weight=200 → 动态改为 32] -->|被忽略| C
    C --> D[实际调度仍按 16:200 分配带宽]

4.2 直播首屏Push资源（JS/CSS/首帧）优先级被音频流劫持的实证分析

在 Chrome 115+ 的 Priority Hints 机制下，<link rel="preload" as="script" fetchpriority="high"> 仍被音频流（<audio autoplay>）隐式降权。

关键复现条件

音频标签位于 <head> 中且含 autoplay 属性
JS/CSS preload 与 audio 标签同属初始 HTML 文档流
启用 chrome://flags/#enable-blink-features=PriorityHints

网络请求优先级对比（Lighthouse 10.3 抓取）

资源类型	声明优先级	实际调度等级	延迟（ms）
`main.js`（fetchpriority=high）	High	Medium	327
`audio.mp3`（autoplay）	N/A（隐式Urgent）	Highest	0

<!-- 案例HTML片段 -->
<head>
  <link rel="preload" href="/app.js" as="script" fetchpriority="high">
  <audio src="/bgm.mp3" autoplay preload="auto"></audio>
</head>

逻辑分析：Blink 内核将 autoplay 音频视为“用户可感知媒体”，强制赋予 kUrgent 调度权重，覆盖 fetchpriority 显式声明；preload="auto" 进一步触发预解码，抢占 IO 与解码线程带宽。

graph TD A[HTML Parser] –> B{发现 autoplay audio} B –> C[触发 MediaPreloadTask] C –> D[提升网络请求至 Highest] D –> E[压制同批 preload 资源调度队列]

4.3 自定义http2.Server.Pusher实现动态优先级重调度

HTTP/2 服务器推送（Server Push）的默认优先级由客户端初始请求树决定，但真实场景中需根据资源类型、用户行为或服务端负载动态调整。

核心改造点

替换 http2.Server 的 NewPusher 方法
实现 http2.Pusher 接口，注入自适应优先级策略

自定义 Pusher 示例

type DynamicPusher struct {
    http2.Pusher
    strategy PriorityStrategy
}

func (p *DynamicPusher) Push(target string, opts http2.PushOptions) error {
    // 动态计算权重：CSS/JS 提升至 200，图片降为 50
    opts.Priority.Exclusive = true
    opts.Priority.Weight = p.strategy.WeightFor(target)
    return p.Pusher.Push(target, opts)
}

逻辑分析：opts.Priority.Weight 取值范围为 1–256，值越大优先级越高；Exclusive=true 确保子资源独占父流带宽。WeightFor() 基于路径后缀或响应头 Content-Type 实时判定。

优先级映射表

资源类型	权重	触发条件
`/app.js`	200	首屏关键 JS
`/style.css`	180	渲染阻塞 CSS
`/img/*.webp`	50	异步加载图片

graph TD
    A[收到 HTML 请求] --> B{分析响应体 Link 头}
    B --> C[提取预加载资源]
    C --> D[按类型查权重策略]
    D --> E[构造带权 PushOptions]
    E --> F[触发重调度推送]

4.4 基于pprof+trace的流调度延迟热力图构建与瓶颈定位

流调度延迟热力图需融合时间维度（trace）与资源维度（pprof），实现毫秒级调度路径着色。

数据采集协同机制

启用 Go 运行时双通道采样：

// 启动 trace 并关联 pprof label
tr := trace.Start(os.Stderr)
defer tr.Stop()
runtime.SetMutexProfileFraction(1) // 启用锁竞争采样
runtime.SetBlockProfileRate(1)     // 启用阻塞事件采样

SetBlockProfileRate(1) 表示记录每次 goroutine 阻塞事件，trace.Start() 捕获调度器状态跃迁（如 GoroutineCreate/GoSched），为热力图提供时序锚点。

热力图生成流程

graph TD
    A[trace Events] --> B[按 P-ID + 时间窗口聚合]
    C[pprof mutex/block profiles] --> D[定位高延迟 P 的临界区]
    B & D --> E[二维矩阵：X=时间片 Y=调度器P]
    E --> F[HSV着色：H=延迟均值 S=方差 V=调用频次]

关键指标对照表

维度	trace 提供	pprof 补充
延迟来源	Goroutine 调度等待时长	Mutex contention duration
定位粒度	P-level 调度上下文	函数级锁持有栈
采样开销	~5% CPU（默认）	可配置 block/mutex率

第五章：面向实时音视频的HTTP/2 Server Push工程化演进路径

架构瓶颈催生Push机制重构

某千万级在线教育平台在2022年Q3遭遇首屏加载超时率飙升至18%的问题。其WebRTC信令通道依赖的/api/sdp、/assets/av1-decoder.wasm及/css/player-core.css三类资源存在强时序耦合，但传统HTTP/1.1串行请求导致平均首帧延迟达3.2s。团队通过Wireshark抓包发现，浏览器解析HTML后需经历3次RTT才能获取解码器WASM模块，成为关键路径瓶颈。

推送策略的灰度验证矩阵

为规避过度推送引发的连接拥塞，团队设计四维灰度策略：

维度	取值范围	生产环境占比	监控指标
用户设备类型	iOS/Android/Desktop	100%/70%/100%	Push成功率、内存占用
网络质量	4G/WiFi/5G	30%/50%/20%	首帧耗时、丢包率
资源优先级	critical/medium/low	100%/60%/0%	TTFB、资源复用率
推送时机	HTML响应头/流式响应中	70%/30%	连接复用率、RST_STREAM

实测显示，仅对WiFi网络下的Desktop用户推送av1-decoder.wasm+player-core.css组合，首帧延迟降低至1.4s，且未触发TCP连接重置。

Nginx配置的生产级调优

在v1.21.6版本中启用Server Push需突破默认限制：

http {
    # 启用HTTP/2并禁用TLS 1.2以下协议
    http2_max_requests 1000;
    http2_max_field_size 16k;

    server {
        listen 443 ssl http2;
        location /live/room.html {
            # 基于Content-Type智能推送
            http2_push /assets/av1-decoder.wasm;
            http2_push /css/player-core.css;
            # 动态Header控制推送开关
            if ($http_x_push_enabled = "true") {
                http2_push /js/webrtc-adapter.js;
            }
        }
    }
}

客户端资源预加载协同

Chrome 112+支持<link rel="preload" as="fetch" href="/api/sdp" crossorigin>与Server Push的协同调度。团队在HTML模板中嵌入条件化预加载标签：

<!-- 根据User-Agent动态注入 -->
<script>
if (navigator.userAgent.includes('Chrome/112')) {
  const link = document.createElement('link');
  link.rel = 'preload';
  link.as = 'fetch';
  link.href = '/api/sdp';
  link.crossOrigin = 'anonymous';
  document.head.appendChild(link);
}
</script>

推送失效的熔断机制

当CDN节点检测到连续5次PUSH_PROMISE被客户端RST时，自动触发熔断：

flowchart LR
    A[收到PUSH_PROMISE] --> B{客户端ACK超时？}
    B -- 是 --> C[记录失败计数]
    C --> D{计数≥5？}
    D -- 是 --> E[关闭该路径Push]
    D -- 否 --> F[维持推送]
    B -- 否 --> F
    E --> G[上报Prometheus指标 push_circuit_break{path=\"/live/room.html\"} 1]

监控体系的立体化建设

部署eBPF探针捕获内核层HTTP/2帧，构建三维监控看板：

维度1：每秒推送请求数（http2_push_requests_total）
维度2：推送资源缓存命中率（对比http2_push_bytes_sent与http2_data_bytes_sent）
维度3：端到端时序分析（从PUSH_PROMISE发送到HEADERS接收的P95延迟）

某次灰度发布中，监控发现iOS Safari的push_cache_hit_rate骤降至12%，经排查系其Webkit引擎对跨域WASM推送存在解析缺陷，立即回滚对应策略。

运维自动化脚本实践

编写Ansible Playbook实现推送策略的滚动更新：

- name: Deploy HTTP/2 Push config
  hosts: nginx_servers
  tasks:
    - name: Validate nginx config syntax
      command: nginx -t
    - name: Copy optimized push config
      copy:
        src: templates/nginx-push.conf.j2
        dest: /etc/nginx/conf.d/push.conf
    - name: Reload nginx with zero downtime
      command: nginx -s reload
      notify: Restart nginx