Go框架Graceful Shutdown中断订单？SIGTERM处理不完整导致goroutine泄露的3层检测法

第一章：Go框架Graceful Shutdown中断订单？SIGTERM处理不完整导致goroutine泄露的3层检测法

当Kubernetes向Go服务发送SIGTERM信号后，订单创建接口仍持续接收新请求、支付协程卡在channel阻塞、数据库连接池未释放——这类现象往往不是“shutdown超时”，而是graceful shutdown逻辑存在goroutine泄露。根本原因在于：SIGTERM仅触发主goroutine退出路径，但未同步终止所有活跃worker goroutine及其依赖的context传播链。

进程级存活状态验证

通过/debug/pprof/goroutine?debug=2端点抓取全量goroutine堆栈，重点关注含http.HandlerFunc、time.Sleep或chan receive的长期阻塞项。执行命令快速定位：

# 获取当前goroutine数量（对比启动时基线）
curl -s http://localhost:6060/debug/pprof/goroutine?debug=1 | grep -c "goroutine"
# 抓取阻塞goroutine详情（需提前启用pprof）
curl -s http://localhost:6060/debug/pprof/goroutine?debug=2 | grep -A 5 -B 5 "payment|order|timeout"

Context传播完整性检查

审查所有异步操作是否显式继承ctx参数并响应ctx.Done()：

• ✅ 正确：go func(ctx context.Context) { select { case <-ctx.Done(): return; ... } }(req.Context())
• ❌ 危险：go processOrder(orderID)（无ctx传递）或go func() { time.Sleep(5*time.Second) }()（硬编码等待）

Shutdown生命周期钩子审计

确认HTTP Server关闭流程覆盖三层资源释放：

资源类型	检查要点	常见遗漏点
HTTP Server	srv.Shutdown()调用前是否关闭监听socket	忘记srv.Close()前置清理
数据库连接池	db.Close()是否在Shutdown()后立即执行	在defer中延迟执行导致超时
自定义Worker池	worker.Stop()是否广播cancel信号	仅关闭channel未通知goroutine

关键修复代码示例：

// 启动时注册SIGTERM处理器
signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGINT)
go func() {
    <-sigChan
    // 1. 立即停止接收新请求
    srv.SetKeepAlivesEnabled(false)
    // 2. 主动关闭监听socket（避免新连接）
    srv.Close()
    // 3. 同步等待所有in-flight请求完成
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    srv.Shutdown(ctx) // 此处必须等待，否则goroutine被强制kill
}()

第二章：Graceful Shutdown机制的底层原理与典型失效场景

2.1 Go runtime信号捕获与SIGTERM生命周期剖析

Go runtime 通过 os/signal 包与内核信号机制协同，在进程生命周期中实现优雅退出。

信号注册与阻塞式监听

sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGINT)
<-sigChan // 阻塞等待首次信号

signal.Notify 将指定信号转发至 channel；缓冲区大小为 1 确保不丢弃首个 SIGTERM；<-sigChan 触发 goroutine 暂停，由 runtime 注册 sigtramp 处理器接管系统调用。

SIGTERM 生命周期阶段

阶段	行为描述
捕获	内核向目标线程发送信号
转发	runtime 将信号转译为 channel 事件
响应	用户 goroutine 从 channel 接收并执行清理

清理流程依赖关系

graph TD
    A[收到 SIGTERM] --> B[runtime 切换至 signal-safe 状态]
    B --> C[唤醒阻塞在 sigChan 的 goroutine]
    C --> D[执行 defer/Shutdown 逻辑]
    D --> E[调用 exit(0)]

• 所有非 signal-safe 函数（如 malloc、printf）在信号处理期间被禁止；
• syscall.Exit() 不会触发 defer，因此必须在 <-sigChan 后显式执行清理。

2.2 HTTP Server Shutdown流程与context取消传播路径实践验证

HTTP Server 的优雅关闭本质是 context 取消信号的跨层传播。当 srv.Shutdown() 被调用，它触发 ctx.Done()，该信号沿 goroutine 树逐级透传。

Shutdown 触发链路

• 主 goroutine 调用 srv.Shutdown(ctx)
• srv.closeListeners() 关闭监听套接字
• 正在处理的 *http.conn 检测到 ctx.Err() != nil 后终止读写循环

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

// 启动服务（非阻塞）
go func() { log.Fatal(srv.ListenAndServe()) }()

// 5秒后发起优雅关闭
time.Sleep(5 * time.Second)
if err := srv.Shutdown(ctx); err != nil {
    log.Printf("Shutdown error: %v", err) // 可能为 context.DeadlineExceeded
}

ctx 是取消源头，cancel() 显式触发；srv.Shutdown(ctx) 将此 ctx 注入连接生命周期管理；超时值需大于最长请求处理时间，否则强制中断。

context 取消传播路径

graph TD
    A[Shutdown call] --> B[Server.ctx = input ctx]
    B --> C[activeConn reads ctx.Err()]
    C --> D[conn.close() → response.WriteHeader/Write failure]
    D --> E[goroutine exit on next I/O or select]

组件	是否响应 cancel	响应延迟来源
Listener accept	✅	accept() 系统调用返回
activeConn read	✅	net.Conn.Read 阻塞
Handler 执行中	❌（需手动检查）	依赖 handler 内部 ctx 使用

Handler 必须主动检查 r.Context().Done() 并提前退出，否则无法响应 shutdown。

2.3 依赖组件（DB连接池、消息队列客户端、gRPC Server）未注册Shutdown钩子的实测泄漏复现

当应用优雅关闭时，若未显式调用 HikariCP#close()、RabbitMQ ConnectionFactory#destroyConnection() 或 grpcServer.shutdownNow()，连接与线程将滞留 JVM 中。

数据同步机制

以下为典型遗漏 shutdown 的 gRPC Server 初始化片段：

// ❌ 缺失 ShutdownHook —— JVM 退出时 Server 未终止
Server grpcServer = ServerBuilder.forPort(8080)
    .addService(new GreeterImpl())
    .build()
    .start(); // 启动后无后续生命周期管理

逻辑分析：start() 仅启动服务，但未注册 JVM 关闭钩子；grpcServer 持有非守护线程（如 TransportServer），导致进程无法正常退出。shutdownNow() 应在 Runtime.getRuntime().addShutdownHook() 中调用。

泄漏对比验证

组件类型	是否注册 ShutdownHook	进程退出耗时（s）	堆外内存残留
HikariCP	否	>15	✅
RabbitMQ Client	否	>8	✅
gRPC Server	否	挂起不退出	✅

根本链路示意

graph TD
    A[JVM receive SIGTERM] --> B{Shutdown Hooks?}
    B -- No --> C[Thread leak: EventLoopGroup]
    B -- Yes --> D[Graceful close: connection drain]
    C --> E[OOM / port bind failure on restart]

2.4 长周期goroutine（如ticker轮询、后台worker）阻塞Exit信号的调试定位方法

常见阻塞模式识别

长周期 goroutine 常因 time.Ticker.C 无缓冲通道读取、select{} 缺失 default 或 ctx.Done() 分支而忽略退出信号。

快速定位工具链

• pprof/goroutine：查看阻塞在 runtime.gopark 的 goroutine 栈
• GODEBUG=asyncpreemptoff=1 辅助验证抢占是否被抑制
• SIGQUIT 输出可定位未响应 context.Context 取消的协程

安全退出模板示例

func runWorker(ctx context.Context, ticker *time.Ticker) {
    for {
        select {
        case <-ctx.Done(): // 关键：响应取消
            log.Println("worker exiting gracefully")
            return
        case t := <-ticker.C: // 非阻塞，因 ticker.C 是无缓冲通道
            process(t)
        }
    }
}

该模板确保 ctx.Done() 优先级高于 ticker.C；若 process() 内部阻塞，需为其注入子 ctx.WithTimeout()。

检查项	风险表现	修复建议
select 缺 ctx.Done()	进程无法响应 os.Interrupt	补全 case <-ctx.Done(): return
ticker.Stop() 未调用	资源泄漏 + 多余唤醒	defer ticker.Stop()

2.5 defer + sync.WaitGroup + context.WithTimeout三重保障的Shutdown封装模式实现

为何需要三重保障？

单靠 defer 无法等待异步任务结束；仅用 sync.WaitGroup 缺乏超时控制；而 context.WithTimeout 单独使用又无法自动触发清理。三者协同可覆盖延迟执行、并发等待、时限兜底三大关键维度。

核心封装逻辑

func (s *Server) Shutdown(ctx context.Context) error {
    // 1. 触发优雅关闭信号（如 HTTP Server.Close）
    s.httpSrv.Shutdown(ctx)

    // 2. 等待所有 goroutine 完成（WaitGroup 计数归零）
    done := make(chan struct{})
    go func() { s.wg.Wait(); close(done) }()

    // 3. 三重等待：WaitGroup 完成 或 上下文超时
    select {
    case <-done:
        return nil
    case <-ctx.Done():
        return ctx.Err() // 如 context.DeadlineExceeded
    }
}

逻辑分析：s.wg.Wait() 在 goroutine 中阻塞，避免阻塞主 shutdown 流程；select 实现非阻塞等待，ctx 提供统一超时源，done 通道确保 WaitGroup 被精确监听。defer 通常用于注册 cleanup 函数（如 defer s.wg.Done()），与本函数配合构成完整生命周期闭环。

三重保障对比表

机制	作用	超时敏感	自动释放资源
defer	延迟执行清理逻辑	否	是（栈级）
sync.WaitGroup	同步等待所有 goroutine 结束	否	否（需手动 Done）
context.WithTimeout	强制中断等待并传递取消信号	是	是（通过 cancel）

执行流程示意

graph TD
    A[调用 Shutdown] --> B[触发服务关闭信号]
    B --> C[启动 goroutine 等待 wg]
    C --> D{select 等待}
    D -->|wg.Wait 完成| E[返回 nil]
    D -->|ctx 超时| F[返回 ctx.Err]

第三章：goroutine泄露的可观测性诊断体系构建

3.1 pprof/goroutines+trace分析栈中阻塞态goroutine的现场快照提取

当系统出现高延迟或资源耗尽时，定位阻塞态 goroutine 是关键突破口。pprof 提供的 /debug/pprof/goroutines?debug=2 可导出含调用栈与状态的完整快照。

获取阻塞态 goroutine 快照

curl -s "http://localhost:6060/debug/pprof/goroutines?debug=2" > goroutines_blocked.txt

• debug=2：输出含 goroutine 状态（waiting, semacquire, chan receive 等）、栈帧及阻塞点源码行号；
• 建议配合 grep -A 10 "state: waiting\|semacquire\|chan receive" 快速筛选。

阻塞常见状态对照表

状态关键词	典型原因	关联原语
semacquire	互斥锁/读写锁争用	sync.Mutex.Lock
chan receive	无缓冲 channel 无发送者	<-ch
selectgo	select 中所有 case 阻塞	select{}

分析流程（mermaid）

graph TD
    A[抓取 goroutines?debug=2] --> B[过滤 state: waiting]
    B --> C[定位阻塞点函数+行号]
    C --> D[结合 trace 检查该 goroutine 的调度事件]

3.2 runtime.NumGoroutine() + /debug/pprof/goroutine?debug=2在生产环境的低开销监控集成

runtime.NumGoroutine() 是零分配、纳秒级开销的实时计数器，适合高频采样；而 /debug/pprof/goroutine?debug=2 提供完整栈快照，但需谨慎调用。

轻量级指标采集

// 每5秒采集一次goroutine数量，写入Prometheus指标
go func() {
    for range time.Tick(5 * time.Second) {
        promGoroutines.Set(float64(runtime.NumGoroutine()))
    }
}()

NumGoroutine() 无锁读取全局 allglen 计数器，不触发GC或调度器扫描，CPU开销

安全的栈快照触发策略

• ✅ 仅当 NumGoroutine() > 阈值 × 基线 时触发 /debug/pprof/goroutine?debug=2
• ✅ 限流：每小时最多1次，且避开业务高峰时段（如通过 cron 控制）
• ❌ 禁止在 HTTP handler 中直接暴露该 endpoint

采样对比表

方法	开销	数据粒度	生产推荐
NumGoroutine()	~8ns	标量计数	✅ 全量高频采集
debug=2	~5–50ms（取决于goroutine数）	全栈文本	⚠️ 异步条件触发

graph TD
    A[定时采集 NumGoroutine] --> B{是否超阈值？}
    B -->|是| C[异步触发 debug=2 快照]
    B -->|否| D[继续轮询]
    C --> E[上传至日志中心+告警]

3.3 自定义pprof标签与goroutine归属标记：识别“幽灵goroutine”来源模块

Go 运行时默认无法区分 goroutine 的业务归属，导致 pprof 堆栈中大量匿名协程难以溯源。runtime/pprof 支持通过 pprof.SetGoroutineLabels() 和 pprof.Do() 注入上下文标签：

func handleRequest(ctx context.Context, module string) {
    ctx = pprof.WithLabels(ctx, pprof.Labels("module", module, "handler", "api_v1"))
    pprof.Do(ctx, func(ctx context.Context) {
        // 业务逻辑（可能启动子goroutine）
        go func() {
            // 此goroutine将继承 labels
            select {}
        }()
    })
}

逻辑分析：pprof.Do() 将标签绑定至当前 goroutine 及其显式派生的所有子 goroutine（需通过 ctx 传递）。参数 module 和 handler 构成可检索的维度键，后续可通过 go tool pprof -tags 过滤。

标签生效范围对比

场景	标签是否继承	说明
go f() 直接启动	❌ 否	无上下文传播，标签丢失
pprof.Do(ctx, fn) 内启动	✅ 是	runtime 自动注入 label map
go func(){ ... }() + pprof.Do 包裹	✅ 是	必须在 goroutine 内部调用

常见幽灵 goroutine 来源模块归因策略

• 数据同步机制
• 长连接心跳管理
• 背景指标采集协程
• 第三方库未清理的 watchdog

graph TD
    A[HTTP Handler] --> B[pprof.Do with labels]
    B --> C[启动子goroutine]
    C --> D{是否使用 ctx/Do?}
    D -->|是| E[pprof 可关联 module]
    D -->|否| F[成为无标签“幽灵”]

第四章：三层检测法：静态扫描→运行时注入→混沌验证

4.1 基于go/ast的Shutdown入口点静态分析工具开发（检测missing defer、unhandled ctx.Done）

核心分析策略

工具聚焦 main 函数及 http.Server.Shutdown、signal.Notify 等典型 shutdown 触发点，构建 AST 控制流图（CFG），识别资源释放路径。

关键检测逻辑

• 扫描 *ast.CallExpr 中 srv.Shutdown() 调用
• 向上追溯 defer 语句是否覆盖该调用
• 检查 select 语句中是否监听 ctx.Done() 且含 return 或 os.Exit

// 示例：触发 shutdown 的常见模式
func main() {
    srv := &http.Server{Addr: ":8080"}
    go func() {
        if err := srv.ListenAndServe(); err != http.ErrServerClosed {
            log.Fatal(err)
        }
    }()
    sig := make(chan os.Signal, 1)
    signal.Notify(sig, os.Interrupt)
    <-sig // ← 此处需关联 ctx.Done() 处理
    srv.Shutdown(context.Background()) // ← 入口点标记
}

该代码块中 srv.Shutdown() 被标记为 shutdown 入口；工具将验证其前是否缺失 defer srv.Close()，并检查 <-sig 是否在 select 中与 ctx.Done() 并行处理。

检测维度对照表

问题类型	AST 模式特征	误报率
missing defer	Shutdown() 调用无父级 defer
unhandled ctx.Done	select 缺少 case <-ctx.Done():

graph TD
    A[Parse Go files] --> B[Find Shutdown calls]
    B --> C[Build CFG to root scope]
    C --> D{Has defer? Has ctx.Done in select?}
    D -->|No| E[Report violation]
    D -->|Yes| F[Pass]

4.2 在测试环境注入可控SIGTERM并捕获goroutine dump的自动化断言框架

为验证服务优雅退出能力，需在测试中精准触发 SIGTERM 并捕获 goroutine 状态快照。

核心流程设计

# 向目标进程发送信号并捕获pprof输出
kill -TERM $(cat /tmp/app.pid) && \
curl -s "http://localhost:6060/debug/pprof/goroutine?debug=2" > /tmp/goroutines.out

该命令组合确保信号送达后立即抓取阻塞/运行态 goroutine 栈迹；debug=2 参数启用完整栈信息（含未启动 goroutine）。

断言关键指标

指标	预期值	检查方式
shutdown goroutine	≥1	正则匹配 shutdown
active http handler	=0	排除 net/http 相关栈
finalizer wait time	≤500ms	日志时间戳差值分析

自动化校验逻辑

// 断言函数片段：解析 goroutine dump 并验证状态
func assertGracefulShutdown(dump string) error {
    lines := strings.Split(dump, "\n")
    for i, line := range lines {
        if strings.Contains(line, "shutdown") && 
           !strings.Contains(lines[i+1], "running") {
            return nil // 找到已阻塞的 shutdown 协程
        }
    }
    return errors.New("no blocked shutdown goroutine found")
}

代码通过逐行扫描 dump 文本，定位 shutdown 关键字后紧邻的协程状态行，确认其非 running，从而验证退出流程已进入等待阶段。

4.3 使用chaos-mesh模拟渐进式终止过程，验证订单服务在Shutdown窗口期的数据一致性

为精准复现Kubernetes中Pod优雅终止（graceful shutdown）期间的数据竞态，我们借助Chaos Mesh注入可控的PodChaos与NetworkChaos组合故障。

模拟渐进式终止流程

# chaos-pod-shutdown.yaml：强制触发SIGTERM后延迟15s执行SIGKILL
apiVersion: chaos-mesh.org/v1alpha1
kind: PodChaos
metadata:
  name: order-service-graceful-termination
spec:
  action: pod-failure
  duration: "15s"      # 模拟terminationGracePeriodSeconds=15
  mode: one
  selector:
    namespaces: ["order-system"]
    labelSelectors:
      app: order-service

该配置使Pod接收SIGTERM后保持运行15秒，为服务端完成未决事务、刷新缓冲区、同步下游提供时间窗口。

数据一致性验证维度

验证项	检查方式	合格阈值
订单状态最终一致性	对比MySQL与ES订单状态快照	差异≤0条
幂等写入完整性	检查Redis幂等Key残留数量	≤10个（预热期）
分布式事务补偿日志	扫描Saga补偿表未完成记录数	=0

关键协同机制

• 订单服务在@PreDestroy中主动调用OrderSyncService.flushPending()；
• Spring Boot Actuator /actuator/shutdown 被禁用，仅依赖容器生命周期信号；
• Chaos Mesh通过--mode=one确保单点扰动，避免级联雪崩。

4.4 结合OpenTelemetry trace propagation追踪Shutdown链路中context cancel丢失节点

在优雅关闭（Graceful Shutdown）过程中，context.WithCancel 的传播常因中间件未透传 context.Context 而中断，导致下游服务未收到 cancel 信号。

OpenTelemetry Trace Context 透传关键点

• HTTP 传输依赖 traceparent header
• gRPC 使用 grpc-trace-bin metadata
• 中间件必须调用 otel.GetTextMapPropagator().Inject()

典型丢失场景代码示例

func middleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // ❌ 错误：未从r.Context()提取并注入span上下文
        ctx := r.Context()
        // 正确应有：ctx = otel.GetTextMapPropagator().Extract(ctx, r.Header)
        next.ServeHTTP(w, r)
    })
}

该中间件跳过 Extract 导致 trace context 断裂，进而使 ctx.Done() 在 shutdown 时无法级联触发。

Shutdown 链路传播验证表

组件	是否透传 context	是否监听 ctx.Done()
HTTP Server	✅	✅
Redis Client	❌（默认）	❌
DB Pool	✅（需显式配置）	✅

graph TD
    A[Shutdown Signal] --> B[http.Server.Shutdown]
    B --> C[Active Request Context]
    C --> D{Propagated via traceparent?}
    D -->|Yes| E[Downstream Cancel Propagated]
    D -->|No| F[Cancel Lost at Middleware]

第五章：从事故到工程化防御：构建高可靠Go微服务终止生命周期

一次真实的服务雪崩复盘

某电商订单服务在大促期间因未正确处理 SIGTERM 信号，导致 Kubernetes 发起滚动更新时，Pod 在 30 秒超时后被强制 kill -9。正在处理的支付回调请求被截断，引发 172 笔重复扣款与下游对账失败。事后日志分析显示，http.Server.Shutdown() 调用被包裹在未加 context.WithTimeout 的 goroutine 中，实际等待时间超过 45 秒。

标准化终止流程的 Go 实现

以下代码片段已在线上稳定运行 18 个月，覆盖 47 个核心微服务：

func (s *Server) gracefulShutdown(ctx context.Context) error {
    // 1. 停止接收新请求（HTTP/GRPC）
    s.httpServer.SetKeepAlivesEnabled(false)

    // 2. 通知依赖方进入只读模式（通过 gRPC Health Check + 自定义状态广播）
    if err := s.broadcastReadOnlyMode(ctx); err != nil {
        log.Warn("failed to broadcast readonly mode", "err", err)
    }

    // 3. 等待活跃请求完成（带超时的 Shutdown）
    shutdownCtx, cancel := context.WithTimeout(ctx, 15*time.Second)
    defer cancel()

    if err := s.httpServer.Shutdown(shutdownCtx); err != nil && !errors.Is(err, context.DeadlineExceeded) {
        return fmt.Errorf("http server shutdown failed: %w", err)
    }

    // 4. 关闭数据库连接池（使用 sql.DB.Close() + 连接等待队列 drain）
    s.db.Close()

    // 5. 等待后台任务完成（如消息确认、指标 flush）
    s.waitGroup.Wait()

    return nil
}

终止生命周期关键阶段监控指标

阶段	指标名	报警阈值	数据来源
信号捕获延迟	service_termination_signal_delay_ms	>200ms	eBPF trace
Shutdown 耗时	http_server_shutdown_duration_seconds	>12s	Prometheus
未完成请求残留	active_requests_after_shutdown	>3	HTTP middleware
连接池关闭等待时间	db_pool_drain_duration_seconds	>8s	SQL driver hook

多层防御机制设计

• Kubernetes 层：配置 terminationGracePeriodSeconds: 45 与 preStop hook 执行 /healthz?ready=false 触发服务降级；
• Go 运行时层：注册双信号监听器——SIGTERM 触发优雅终止，SIGUSR2 强制立即退出（仅限 debug 环境）；
• 基础设施层：Envoy sidecar 设置 drain_timeout: 30s 并启用 envoy.reloadable_features.activate_drain；
• 可观测性层：OpenTelemetry 自动注入 shutdown.start / shutdown.complete span，并关联 traceID 到所有活跃请求。

生产环境验证结果

在最近三次灰度发布中，该方案将平均终止耗时从 28.4s 降至 11.2s（P99），残留请求率由 0.87% 降至 0.02%，且 100% 的支付类服务实现零资金异常。某风控服务通过引入基于 sync.WaitGroup 的任务登记机制，在终止前主动拒绝新异步任务提交，避免了 Kafka offset 提交丢失问题。

信号处理的边界陷阱

曾发现某服务在 syscall.SIGUSR1 被用于触发日志轮转时，意外覆盖了 signal.Notify(c, syscall.SIGTERM) 的 channel，导致终止信号静默丢失。解决方案是为不同用途信号分配独立 channel，并使用 signal.Reset() 显式清理非预期信号监听器。

测试验证矩阵

场景	工具链	验证方式
SIGTERM 响应及时性	chaos-mesh + k6	注入延迟后测量 shutdown 开始时间
并发请求安全终止	go-fuzz + custom runner	构造 10k 并发长连接持续发送请求
Sidecar 协同终止	Kind + Istio 1.21	检查 Envoy access log 中最后一条记录时间戳
OOM Killer 下的 fallback	cgroups v2 memory.max	强制触发 OOM，验证是否执行 cleanup

混沌工程实践案例

在模拟节点宕机演练中，通过 kubectl delete pod --grace-period=0 --force 强制驱逐，发现 3 个服务因未实现 runtime.SetFinalizer() 清理临时文件，导致磁盘空间泄漏。后续统一接入 tempfile.CleanupOnExit() 并增加 df -h 告警联动。

配置即代码落地规范

所有服务的 termination 相关参数均通过 Helm values.yaml 统一管控：

lifecycle:
  gracePeriodSeconds: 45
  preStop:
    httpGet:
      path: /healthz?ready=false
      port: 8080
  postStart:
    exec:
      command: ["/bin/sh", "-c", "echo 'ready' > /tmp/ready"]