【腾讯云Go托管实战指南】：20年架构师亲授高可用部署避坑清单与性能调优秘籍

第一章：腾讯云Go托管服务全景概览

腾讯云Go托管服务（Tencent Cloud Go Service）是面向Go语言开发者的一站式云原生应用托管平台，深度融合Serverless架构与Kubernetes编排能力，提供从代码提交、自动构建、镜像部署到弹性伸缩的全生命周期管理。该服务原生支持Go模块（Go Modules），兼容Go 1.18及以上版本，并预置glibc、musl及CGO交叉编译环境，显著降低Go Web服务、CLI工具及微服务组件的上云门槛。

核心能力维度

零配置部署：推送含main.go和go.mod的Git仓库后，平台自动识别Go项目并触发构建流水线
冷启动优化：基于轻量级容器沙箱（Firecracker-backed）实现毫秒级实例启动，平均冷启动延迟低于300ms
资源弹性策略：支持按请求并发数（RPS）或CPU使用率动态扩缩容，最小可伸缩至0实例（暂停计费）
可观测性集成：默认接入腾讯云CLS日志服务、CMonitor监控指标及APM链路追踪，无需埋点即可获取HTTP延迟、panic堆栈、GC频率等关键Go运行时指标

快速部署示例

以下为本地Go HTTP服务一键部署至腾讯云Go托管服务的操作流程：

# 1. 初始化标准Go模块项目（确保go.mod存在）
go mod init example.com/hello && go mod tidy

# 2. 创建简单HTTP handler（main.go）
cat > main.go <<'EOF'
package main
import (
    "fmt"
    "net/http"
)
func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello from Tencent Cloud Go Service! PID: %d", os.Getpid())
}
func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil) // 端口固定为8080，平台自动映射
}
EOF

# 3. 推送至已绑定的GitHub/GitLab仓库，触发CI/CD自动构建与部署
git add . && git commit -m "deploy to tencent cloud go service" && git push origin main

⚠️ 注意：服务监听端口必须为8080，且不建议调用os.Exit()或阻塞主goroutine；平台通过/healthz路径健康检查，默认超时3秒，失败3次触发实例重建。

服务形态对比

形态	适用场景	构建耗时	实例粒度	免费额度
函数实例	事件驱动型短时任务		按调用计费	100万次/月
容器实例	长连接Web服务、gRPC服务		按vCPU·小时	400核·小时/月（含）
自定义镜像实例	需CUDA/FFmpeg等特殊依赖	自定义	按节点租用	不参与通用免费计划

第二章：高可用部署架构设计与落地实践

2.1 基于CVM+CLB+AS的弹性伸缩拓扑建模

该架构以云服务器（CVM）为计算单元，负载均衡（CLB）实现流量分发，弹性伸缩（AS）动态调控实例数量，形成闭环自适应系统。

核心组件协同机制

CVM 实例运行标准化镜像，预装健康检查脚本与业务服务
CLB 配置主动健康探测（HTTP: /health，间隔5s，超时3s）
AS 绑定告警策略（CPU ≥ 70% 持续5分钟 → 扩容；≤ 30% 持续10分钟 → 缩容）

自动化扩缩容配置示例

# autoscaling-policy.yaml（Terraform模块片段）
scaling_policy {
  metric_type = "CPU_UTILIZATION"
  comparison_operator = "GREATER_THAN_OR_EQUAL_TO"
  threshold = 70
  adjustment_type = "ADD_COUNT"  # 每次新增2台CVM
  cooldown = 300  # 冷却期5分钟，防抖动
}

adjustment_type = "ADD_COUNT" 表示固定扩容数量，避免指数级增长失控；cooldown = 300 确保指标稳定后再触发下一轮决策，防止震荡。

流量调度与实例生命周期关系

graph TD
    A[CLB接收请求] --> B{健康检查通过？}
    B -->|是| C[转发至CVM]
    B -->|否| D[自动摘除节点]
    D --> E[AS触发缩容]
    C --> F[业务指标上报]
    F --> G[AS评估扩容条件]

组件	关键参数	影响维度
CLB	健康检查超时/重试次数	实例摘除灵敏度
AS	冷却时间/步长调整量	伸缩稳定性与响应速度
CVM	启动模板中UserData执行时长	新实例就绪延迟

2.2 多可用区容灾部署与健康检查策略配置

部署拓扑设计

采用跨 AZ（Availability Zone）主备+读写分离架构，应用层与数据库层均部署于至少两个物理隔离的可用区，避免单点故障。

健康检查机制

# Kubernetes livenessProbe 示例（对接云厂商 LB 健康探测）
livenessProbe:
  httpGet:
    path: /healthz
    port: 8080
    scheme: HTTP
  initialDelaySeconds: 30
  periodSeconds: 10
  timeoutSeconds: 3
  failureThreshold: 3  # 连续3次失败触发重启

initialDelaySeconds 避免启动未就绪时误判；failureThreshold=3 结合 periodSeconds=10，确保在 30 秒内确认实例不可用，匹配多数云平台 LB 探测超时策略。

容灾切换流程

graph TD
  A[LB 探测 AZ1 实例失联] --> B{连续3次失败？}
  B -->|是| C[标记AZ1为不可用]
  B -->|否| D[维持原路由]
  C --> E[流量自动切至AZ2]
  E --> F[异步触发告警与根因分析]

关键参数对比表

检查类型	探测路径	建议频率	超时阈值	适用层级
Liveness	`/healthz`	10s	3s	Pod 级
Readiness	`/readyz`	5s	2s	Service 级
LB 探测	`/ping`	15s	5s	负载均衡器

2.3 Go应用生命周期管理：从编译构建到容器镜像打包

Go 应用的交付链路始于单二进制编译，终于轻量、可复现的容器镜像。

编译优化：静态链接与跨平台构建

# 构建无 CGO 依赖的静态二进制（适用于 Alpine）
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a -ldflags="-s -w" -o app .

-s 去除符号表，-w 去除调试信息，体积缩减约 30%；CGO_ENABLED=0 确保不依赖 libc，适配 scratch 镜像。

多阶段 Dockerfile 实践

阶段	目的	基础镜像
builder	编译	golang:1.22-alpine
runtime	运行	scratch

FROM golang:1.22-alpine AS builder
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 go build -o app .

FROM scratch
COPY --from=builder /app/app /app
ENTRYPOINT ["/app"]

构建流程可视化

graph TD
    A[Go源码] --> B[go build -ldflags]
    B --> C[静态二进制]
    C --> D[多阶段Docker构建]
    D --> E[scratch镜像]

2.4 服务注册与发现集成：Consul/TencentAPI Gateway双模式实操

在微服务架构中，服务注册与发现需兼顾强一致性与云原生兼容性。本节以 Consul 作为本地服务注册中心，Tencent API Gateway 作为统一南北向流量入口，实现双模式协同。

Consul 客户端自动注册

通过 consul-template + registrator 实现服务启动即注册：

# 启动时向 Consul 注册 HTTP 服务（端口 8080）
curl -X PUT "http://localhost:8500/v1/agent/service/register" \
  -H "Content-Type: application/json" \
  -d '{
    "ID": "user-service-01",
    "Name": "user-service",
    "Address": "10.1.2.3",
    "Port": 8080,
    "Check": {
      "HTTP": "http://10.1.2.3:8080/health",
      "Interval": "10s"
    }
  }'

此注册声明服务唯一 ID、健康检查端点及心跳周期；Consul 通过 /health 端点持续探测，失效后自动剔除节点。

Tencent API Gateway 后端路由配置

需将 Consul 中动态发现的服务地址同步至网关白名单：

字段	值	说明
`service_id`	`user-service`	对应 Consul 中 `Name` 字段
`upstream_type`	`SCF`	实际使用 `CVM` 或 `CLB`，此处为网关抽象类型
`discovery_type`	`CONSUL`	启用 Consul 服务发现插件

双模协同流程

graph TD
  A[服务启动] --> B[向 Consul 注册]
  B --> C[Consul Watch 触发变更]
  C --> D[Tencent APIGW 拉取最新服务列表]
  D --> E[更新内部路由缓存]
  E --> F[流量按权重/标签路由]

该机制避免硬编码 IP，同时满足混合云场景下本地服务治理与公有云统一接入的双重诉求。

2.5 配置中心与环境隔离：TKE ConfigMap + Secret动态注入实战

在 TKE（腾讯云容器服务）中，ConfigMap 与 Secret 是实现配置中心与环境隔离的核心载体。通过挂载方式将配置动态注入 Pod，避免硬编码与镜像重建。

环境感知的配置分离策略

开发/测试/生产环境分别维护独立命名空间下的 ConfigMap 和 Secret
使用 envFrom 批量注入，配合 fieldRef 动态获取 Pod 元信息（如 namespace）

示例：多环境 Secret 注入

# production-secret.yaml（生产环境专用）
apiVersion: v1
kind: Secret
metadata:
  name: app-credentials
  namespace: prod
type: Opaque
data:
  DB_PASSWORD: cGFzc3dvcmQxMjM=  # base64 encoded

此 Secret 仅部署于 prod 命名空间，配合 RBAC 限制读取权限；data 字段必须为 base64 编码，解码后为明文密码，由 kubelet 在挂载时自动解密。

ConfigMap 与 Secret 协同注入流程

graph TD
  A[Pod 创建请求] --> B{Kubelet 拉取 Spec}
  B --> C[解析 volumes 中 ConfigMap/Secret 引用]
  C --> D[从 API Server 获取对应资源]
  D --> E[挂载至容器指定路径或注入环境变量]
  E --> F[容器启动，应用读取配置]

注入方式	适用场景	热更新支持	安全性
Volume Mount	配置文件类（如 nginx.conf）	✅（需应用监听 inotify）	⚠️（需控制目录权限）
Environment	敏感短参数（如 TOKEN）	❌	✅（内存隔离）

第三章：核心避坑清单与典型故障归因分析

3.1 Goroutine泄漏与上下文超时未传递导致的连接池耗尽

问题根源：未取消的 Goroutine 持有连接

当 HTTP 请求未携带 context.WithTimeout，且 handler 中启动异步 goroutine 处理响应后未监听 ctx.Done()，该 goroutine 将长期阻塞，持续占用连接池中的连接。

func badHandler(w http.ResponseWriter, r *http.Request) {
    // ❌ 缺失 context 超时控制与 cancel 传播
    go func() {
        time.Sleep(10 * time.Second) // 模拟慢操作
        db.QueryRow("SELECT ...")     // 实际可能复用连接但不释放
    }()
}

逻辑分析：db.QueryRow 从连接池获取连接后，若 goroutine 在 defer rows.Close() 前被阻塞或 panic，连接无法归还；time.Sleep 后无显式 cancel 检查，导致连接“悬停”超时阈值。

连接池耗尽的连锁反应

现象	根本原因
`net/http: request canceled`	上游 timeout 触发，但下游未同步 cancel
`sql: database is closed`	连接池满 + 新请求排队超时
P99 延迟陡升	连接复用率下降，新建连接激增

正确实践：显式传递并监听上下文

func goodHandler(w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
    defer cancel() // ✅ 确保及时释放资源

    go func(ctx context.Context) {
        select {
        case <-time.After(10 * time.Second):
            // 模拟业务逻辑
        case <-ctx.Done():
            return // ✅ 提前退出，释放连接
        }
    }(ctx)
}

参数说明：context.WithTimeout 生成可取消上下文；defer cancel() 防止 context 泄漏；goroutine 内部 select 监听 ctx.Done() 实现协作式中断。

3.2 静态资源路径错误与CDN缓存穿透引发的404雪崩

当构建产物中 public/ 资源路径未与 base 配置对齐，CDN 会将错误路径（如 /assets/logo.abc123.png）缓存为 404 响应，后续所有请求直接命中缓存，形成雪崩。

根因定位：构建配置失配

// vite.config.ts —— 错误示例：base 未同步 public 目录结构
export default defineConfig({
  base: '/app/', // 实际静态资源部署在 /static/ 下
  build: { assetsDir: 'assets' }
})

base 设为 /app/，但 CDN 回源路径指向 /static/，导致 /app/assets/xxx.png 永远 404；CDN 默认缓存 404（TTL 通常 5–30 分钟），阻断真实资源回源。

缓存穿透链路

graph TD
  A[用户请求 /app/assets/icon.svg] --> B[CDN 查缓存]
  B --> C{命中 404 缓存？}
  C -->|是| D[直接返回 404]
  C -->|否| E[回源至 origin]
  E --> F[origin 返回 404]
  F --> G[CDN 缓存该 404]

关键修复项

✅ 设置 Cache-Control: no-store 响应头拦截 404 缓存
✅ 统一 base 与 CDN 回源路径前缀（如均设为 /static/）
✅ 构建后校验 index.html 中 <link href> 和 <img src> 的绝对路径有效性

配置项	推荐值	说明
`base`	`/static/`	必须与 CDN 回源路径一致
`assetsDir`	`''`（空）	避免嵌套路径加深错误层级
`build.rollupOptions.output.entryFileNames`	`[name].[hash].js`	确保 HTML 引用路径可预测

3.3 并发写入共享内存未加锁引发的数据竞争与panic复现

数据同步机制缺失的典型表现

当多个 goroutine 同时对同一 int 变量执行 ++ 操作而无同步控制时，底层会触发非原子读-改-写序列，导致丢失更新。

var counter int
func increment() {
    counter++ // 非原子：读取→+1→写回，三步间可被抢占
}

counter++ 编译为三条 CPU 指令，在调度器切换时产生竞态窗口；多次并发调用后 counter 最终值远小于预期。

panic 触发路径

Go 运行时在检测到严重内存冲突（如 sync/atomic 误用或栈损坏）时主动 panic，但普通竞态通常静默失效——需借助 -race 标志捕获。

工具	检测能力	运行时开销
`go run -race`	内存访问序列重叠	~2–5×
`pprof`	仅定位热点，不揭示竞态

复现流程示意

graph TD
    A[启动100 goroutines] --> B[并发调用 increment]
    B --> C[读取相同旧值]
    C --> D[各自+1后写回]
    D --> E[最终 counter 增量 < 100]

第四章：性能调优深度指南与可观测性体系建设

4.1 GC调优与pprof火焰图定位CPU/内存瓶颈

pprof采集基础流程

启动时启用性能采集：

import _ "net/http/pprof"

func main() {
    go func() {
        log.Println(http.ListenAndServe("localhost:6060", nil))
    }()
    // 主业务逻辑
}

该代码启用标准pprof HTTP服务；localhost:6060/debug/pprof/提供多种采样端点（如/heap、/cpu），无需额外依赖。

关键采样命令示例

go tool pprof http://localhost:6060/debug/pprof/heap → 内存快照
go tool pprof -seconds=30 http://localhost:6060/debug/pprof/profile → 30秒CPU剖析

火焰图生成与解读

go tool pprof -http=:8080 cpu.pprof  # 自动生成交互式火焰图

火焰图纵轴为调用栈深度，横轴为采样时间占比；宽条即热点函数，顶部常为GC辅助标记（runtime.gcMark*）或高频分配点。

指标	健康阈值	风险表现
GC CPU时间占比		>15% → STW压力大
堆分配速率		持续>50 MB/s → 内存泄漏嫌疑

graph TD
A[pprof采集] –> B[CPU/Heap Profile]
B –> C[火焰图可视化]
C –> D[识别GC触发源/高频alloc]
D –> E[针对性优化：sync.Pool/对象复用/切片预分配]

4.2 HTTP/2连接复用与Keep-Alive参数精细化调参

HTTP/2 原生支持多路复用（Multiplexing），单个 TCP 连接可并发处理数十甚至上百个流，彻底消解了 HTTP/1.1 中的队头阻塞问题。但连接生命周期仍受 Keep-Alive 参数协同调控。

Keep-Alive 核心参数作用域

keepalive_timeout：空闲连接最大存活时间（秒）
keepalive_requests：单连接允许的最大请求数（防长连接资源泄漏）
keepalive_time（gRPC/Envoy）：强制回收连接的绝对生存时长

Nginx 配置示例（HTTP/2 场景）

http {
    # 启用 HTTP/2 并优化复用
    http2_max_concurrent_streams 100;     # 控制并发流上限，避免服务端压垮
    keepalive_timeout 30s;                # 比 HTTP/1.1 更长——因复用开销低
    keepalive_requests 1000;             # 提升至千级，匹配高复用场景
}

http2_max_concurrent_streams 直接限制单连接承载能力，过低导致客户端频繁建连；过高则增加服务端内存压力（每个 stream 约占用 8–16 KB）。keepalive_requests=1000 在复用率高的 CDN 或 API 网关中可显著降低 TLS 握手与连接建立开销。

参数协同影响对比

场景	推荐 keepalive_timeout	推荐 keepalive_requests	理由
内网微服务通信	60s	5000	高信任、低延迟、长连接稳定
公网 Web API	30s	1000	平衡复用收益与连接漂移风险
移动端短连接场景	5s	100	应对网络切换与 NAT 超时

graph TD
    A[客户端发起请求] --> B{是否启用HTTP/2？}
    B -->|是| C[复用现有连接<br>分配新Stream ID]
    B -->|否| D[新建TCP+TLS连接]
    C --> E[服务端按keepalive_timeout<br>和keepalive_requests双重判定是否关闭]
    E --> F[满足任一阈值→优雅关闭连接]

4.3 数据库连接池与Redis客户端连接复用最佳实践

连接复用的核心价值

频繁创建/销毁数据库或Redis连接会触发TCP三次握手、TLS协商及认证开销，显著拖慢高并发场景响应。连接池通过预分配、回收与健康检查，将连接生命周期与业务请求解耦。

HikariCP配置要点（示例）

HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/app");
config.setMaximumPoolSize(20);     // 避免线程争抢，通常设为CPU核数×2~4
config.setConnectionTimeout(3000); // 超时保护，防止阻塞蔓延
config.setLeakDetectionThreshold(60000); // 检测连接泄漏（毫秒）

逻辑分析：maximumPoolSize需结合DB最大连接数与应用QPS压测结果设定；leakDetectionThreshold启用后会在连接未归还超时后打印堆栈，定位资源泄露点。

Redis连接复用对比表

客户端	连接模型	线程安全	推荐场景
Jedis	连接直连	❌	单线程短任务
Lettuce（默认）	Netty异步+连接池	✅	高并发微服务

连接生命周期管理流程

graph TD
    A[业务请求] --> B{获取连接}
    B -->|池中有空闲| C[复用现有连接]
    B -->|池已满且未达max| D[新建连接]
    B -->|池满且超时| E[拒绝或排队]
    C & D --> F[执行命令]
    F --> G[归还连接到池]
    G --> H[后台健康检查]

4.4 Prometheus+Grafana+腾讯云可观测平台一体化监控埋点

埋点统一规范设计

采用 OpenTelemetry SDK 统一采集指标、日志与追踪数据，避免多套埋点逻辑并存：

# otel-collector-config.yaml：统一接收并路由数据
receivers:
  prometheus:
    config:
      scrape_configs:
        - job_name: 'app-metrics'
          static_configs: [{targets: ['localhost:9090']}]
exporters:
  otlp:
    endpoint: "ap-guangzhou.tca.tencent.com:4317"  # 腾讯云 TCA 接入点

该配置使 Prometheus 指标经 OTel Collector 标准化后直传腾讯云可观测平台，复用其存储与告警能力。

数据同步机制

✅ Prometheus 指标自动同步至腾讯云 TCA（Tencent Cloud APM）
✅ Grafana 通过腾讯云数据源插件直连 TCA，无需额外代理
❌ 不再维护独立时序数据库，降低运维复杂度

组件	角色	数据流向
Prometheus	指标采集与本地调试	→ OTel Collector
Grafana	可视化与告警面板	← TCA API
腾讯云 TCA	统一存储、AI异常检测	← OTel Collector

架构协同流程

graph TD
  A[应用埋点] --> B[OTel SDK]
  B --> C[OTel Collector]
  C --> D[Prometheus Metrics]
  C --> E[Tencent Cloud TCA]
  D --> F[Grafana via Remote Read]
  E --> F

第五章：未来演进与云原生Go工程化思考

构建可验证的模块化依赖边界

在字节跳动内部的微服务治理平台中，团队将 Go Module 的 replace 和 require 声明与 Open Policy Agent（OPA）策略引擎深度集成。每次 go mod tidy 执行后，CI 流水线自动触发策略校验：禁止直接依赖 github.com/golang/net 中的 http2 子包（因存在已知 TLS 1.3 兼容性缺陷），强制通过封装层 pkg/network/http2safe 访问。该策略以 Rego 规则形式嵌入 GitLab CI 模板，上线三个月内拦截 47 次违规依赖引入。

多运行时服务网格中的 Go Runtime 适配

阿里云 ASM 服务网格 v1.20+ 引入多运行时支持后，Go 应用需主动适配 Sidecar 生命周期。典型实践包括：在 main.go 中监听 SIGUSR2 信号触发 graceful shutdown，并通过 /healthz 端点返回 {"ready":false,"graceful":true} 直至所有 HTTP 连接关闭；同时利用 xds/go 客户端动态订阅 Istio Pilot 的 EndpointDiscoveryService，实现秒级服务实例剔除。某电商订单服务实测从 Pod 删除到流量完全撤离耗时从 8.2s 缩短至 1.3s。

基于 eBPF 的 Go 应用可观测性增强

Datadog 在其 Go APM 代理中集成 libbpf-go，通过内核态探针捕获 goroutine 阻塞事件：当 runtime.gopark 调用超过 50ms 且堆栈含 net/http.(*conn).serve 时，自动注入 span 标签 ebpf.block_reason: "read-from-socket-timeout"。该能力已在 Uber 的实时计价服务中落地，帮助定位出因 http.Transport.IdleConnTimeout=30s 与 Nginx keepalive_timeout=65s 不匹配导致的连接复用失效问题。

云原生构建流水线的 Go 特化优化

阶段	传统方案	Go 工程化方案	效能提升
编译	`go build -o app`	`go build -trimpath -buildmode=pie -ldflags="-s -w"`	二进制体积 ↓32%
静态检查	`golint` + `go vet`	`staticcheck` + `gosec -no-fail`	误报率 ↓67%
镜像构建	Dockerfile 多阶段	`ko build --base ghcr.io/ko-build/base:latest`	构建时间 ↓41%

无状态化与有状态服务的混合编排

腾讯云 TKE 集群中，某日志聚合服务采用双容器 Pod 设计：主容器运行 logtail-go（纯内存缓冲），Sidecar 容器运行 rclone 同步本地磁盘缓存至 COS。通过 Kubernetes volumeClaimTemplates 动态申请 10Gi SSD PVC，并配置 podDisruptionBudget 限制最大中断数为 1。当节点升级时，K8s 自动触发 preStop hook 执行 rclone sync /buffer/ s3://bucket/log/，保障 99.999% 日志不丢失。

// 实践案例：基于 controller-runtime 的 Operator 自愈逻辑
func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    var pod corev1.Pod
    if err := r.Get(ctx, req.NamespacedName, &pod); err != nil {
        return ctrl.Result{}, client.IgnoreNotFound(err)
    }
    if pod.Status.Phase == corev1.PodPending && 
       len(pod.Spec.Containers) > 0 && 
       strings.Contains(pod.Status.Message, "Insufficient memory") {
        // 触发垂直扩缩容
        r.scaleUpMemory(req.Namespace, pod.Spec.Containers[0].Name, 512)
        return ctrl.Result{RequeueAfter: 30 * time.Second}, nil
    }
    return ctrl.Result{}, nil
}

混沌工程中的 Go 语言原生故障注入

使用 chaos-mesh 的 Go SDK，在支付网关服务中编写精准故障策略：仅对 payment-service 命名空间下、标签 env=prod 且 version=v2.4+ 的 Pod 注入 delay 故障，目标函数限定为 github.com/payment/pkg/redis.(*Client).Do，延迟范围 100ms±20ms，持续时间 5m。该策略经 12 次生产环境演练，暴露了 Redis 连接池 MaxIdleConnsPerHost 设置过低导致的连接耗尽问题。

graph LR
    A[Git Push] --> B[CI Pipeline]
    B --> C{Go Version Check}
    C -->|≥1.21| D[Use go.work]
    C -->|<1.21| E[Fail Build]
    D --> F[Module Graph Validation]
    F --> G[OPA Policy Check]
    G --> H[Build with ko]
    H --> I[Push to Registry]
    I --> J[Rolling Update]