为什么一线大厂悄悄把Java服务迁向Go？3年27个生产级迁移案例，性能提升40%+、运维成本直降65%

第一章：Go语言在国内的产业级应用全景图

Go语言凭借其高并发、轻量协程、静态编译与部署简洁等特性，已成为国内云原生基础设施与中后台服务的核心支撑语言。从互联网巨头到新兴科技企业，Go已深度嵌入生产环境的关键链路。

主流应用场景分布

• 云平台与中间件：阿里云ACK、腾讯云TKE的控制平面大量采用Go重构；字节跳动自研微服务框架Kitex、美团开源的服务治理框架PolarisMesh均以Go为主语言；
• 数据库与存储系统：PingCAP TiDB（分布式NewSQL）、Databend（云原生数仓）、Apache Doris 的部分模块（如FE元数据服务）使用Go实现高可用管理组件；
• DevOps与可观测性工具：Prometheus、Grafana、OpenTelemetry Collector 的国内定制发行版（如腾讯蓝鲸监控Agent、网易有数采集器）普遍基于Go二次开发；
• 金融科技核心系统：招商银行“招银云创”分布式交易网关、平安科技智能风控引擎的实时规则执行模块采用Go编写，满足毫秒级响应与热更新需求。

典型落地实践示例

某头部券商在订单路由网关重构中，将原有Java单体服务迁移至Go，通过goroutine + channel模型替代线程池，QPS提升3.2倍，平均延迟从47ms降至12ms。关键代码片段如下：

// 使用无缓冲channel协调限流与路由决策
func routeOrder(ctx context.Context, order *Order) error {
    select {
    case <-ctx.Done(): // 支持超时取消
        return ctx.Err()
    case routeChan <- order: // 投递至路由协程池
        return nil
    }
}

该模式避免了锁竞争，配合sync.Pool复用订单结构体，GC压力下降65%。

国内生态支持现状

类别	代表项目/组织	说明
开源基金会	OpenAnolis（龙蜥社区）Go SIG	提供国产化OS下的Go运行时优化补丁
企业联盟	CNCF中国本地化工作组	推动K8s Operator、eBPF扩展的Go实践指南
教育认证	华为HCIA-Cloud Native、极客时间Go进阶课	覆盖超50万开发者，课程含真实金融级压测实验

Go语言正从“基础设施语言”加速演进为“业务逻辑首选语言”，其在国内产业落地的广度与深度持续刷新技术选型边界。

第二章：互联网头部企业的Go实践路径

2.1 字节跳动微服务中台的Go化重构：从Java Spring Cloud到Go-kit+gRPC的平滑演进

为支撑千亿级日请求量与毫秒级响应需求，字节跳动中台启动渐进式Go化重构：保留Spring Cloud注册中心（Nacos）与链路追踪（SkyWalking）能力，将核心业务服务迁移至 Go-kit + gRPC 技术栈。

架构演进路径

• 阶段一：gRPC Gateway 代理 Java 服务，统一 HTTP/2 接入层
• 阶段二：新模块全量采用 Go-kit 模板（transport → endpoint → service）
• 阶段三：存量 Java 服务通过 gRPC-Bridge 逐步下线

核心适配层示例（Go-kit transport 封装）

func MakeGRPCServer(svc Service) pb.UserServiceServer {
    return &grpcServer{svc: svc}
}

// grpcServer 实现 pb.UserServiceServer 接口
func (s *grpcServer) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.User, error) {
    // 参数校验与上下文透传
    if req.Id == "" {
        return nil, errors.New("user id required")
    }
    // 调用 endpoint 层，自动注入 tracing、metrics 等中间件
    resp, err := s.svc.GetUser(ctx, req.Id)
    if err != nil {
        return nil, err
    }
    return &pb.User{Id: resp.ID, Name: resp.Name}, nil
}

该封装将 gRPC 请求精准映射至 Go-kit endpoint 链，ctx 携带 OpenTracing SpanContext，req.Id 经校验后进入业务逻辑，避免在 transport 层处理领域逻辑。

迁移效果对比（关键指标）

指标	Spring Cloud（JVM）	Go-kit + gRPC
内存占用/实例	512MB	48MB
P99 延迟	127ms	23ms
启动耗时	8.2s	0.4s

graph TD
    A[HTTP/1.1 客户端] --> B[gRPC-Gateway]
    B --> C{路由决策}
    C -->|新服务| D[Go-kit gRPC Server]
    C -->|旧服务| E[Spring Cloud Feign Client]
    D --> F[Consul/Nacos 注册中心]
    E --> F

2.2 阿里巴巴电商核心链路迁移：双11大促场景下Go服务QPS提升47%的压测实录与架构决策逻辑

压测瓶颈定位：从 goroutine 泄漏到连接池复用

压测中发现高峰期 goroutine 数飙升至 120K+，P99 延迟突破 800ms。根因是 HTTP client 未复用底层 TCP 连接：

// ❌ 错误：每次请求新建 client，导致连接无法复用
client := &http.Client{Timeout: 3 * time.Second}

// ✅ 正确：全局复用 client，启用连接池
var httpClient = &http.Client{
    Transport: &http.Transport{
        MaxIdleConns:        2000,
        MaxIdleConnsPerHost: 2000,
        IdleConnTimeout:     30 * time.Second,
    },
}

MaxIdleConnsPerHost=2000 匹配单机 2K 并发压测模型；IdleConnTimeout=30s 平衡长尾请求与连接老化。

架构决策关键路径

• 放弃 Java Dubbo 服务直连，改用 Go 轻量网关统一路由
• 核心商品查询接口引入本地 LRU 缓存（TTL=15s），缓存命中率提升至 68%
• 数据同步机制：MySQL Binlog → Kafka → Go 消费端最终一致性更新

指标	迁移前	迁移后	提升
QPS（峰值）	34,200	50,300	+47%
P99 延迟（ms）	792	326	-59%

graph TD
  A[双11流量洪峰] --> B[Go 网关路由]
  B --> C{缓存命中？}
  C -->|是| D[返回本地 LRU]
  C -->|否| E[调用下游 gRPC 服务]
  E --> F[异步 Binlog 同步更新缓存]

2.3 腾讯云API网关全量Go重写：百万级并发连接管理、TLS握手优化与零停机热升级实践

百万连接：基于 net.Conn 的连接池化管理

采用 sync.Pool 复用 bufio.Reader/Writer，结合 epoll（Linux）+ io_uring（5.15+）混合事件驱动模型，单实例支撑 120w+ 长连接。

TLS握手加速

启用 tls.TLS_AES_128_GCM_SHA256 优先套件，复用 tls.Config.GetConfigForClient 实现 SNI 分流，并预生成会话票据（Session Ticket）密钥轮转：

cfg := &tls.Config{
    GetConfigForClient: func(ch *tls.ClientHelloInfo) (*tls.Config, error) {
        return sniRouter.Lookup(ch.ServerName), nil // O(1) 路由
    },
    SessionTicketsDisabled: false,
    SessionTicketKey:       activeTicketKey, // 90s 自动轮转
}

activeTicketKey 为 48 字节 AES-GCM 密钥，每 90 秒滚动更新，保障前向安全性与无状态恢复能力。

零停机热升级流程

graph TD
    A[新进程启动] --> B[监听相同端口]
    B --> C[健康检查通过]
    C --> D[旧进程 graceful shutdown]
    D --> E[连接迁移完成]

阶段	耗时	关键动作
新进程就绪		加载配置、预热 TLS 缓存
连接迁移	≤3s	SO_REUSEPORT + TCP_FASTOPEN
旧进程退出	≤5s	http.Server.Shutdown() 等待活跃请求

2.4 拒绝延迟：拼多多实时风控系统Go落地：基于eBPF+Go的毫秒级规则引擎设计与生产灰度发布策略

核心架构分层

• eBPF层：在内核态捕获网络包/系统调用，零拷贝注入风控上下文（如 skb->cb[0] 存储 session_id）
• Go规则引擎层：轻量协程池执行预编译的WASM规则字节码，平均P99=1.3ms
• 灰度控制面：通过etcd动态下发rule_version与traffic_ratio，支持按用户ID哈希分流

规则热加载示例

// 基于eBPF map的规则元数据同步
func loadRule(ruleID string, wasmBin []byte) error {
    // 将WASM模块映射到eBPF per-CPU array map
    return bpfMap.Update(
        uint32(hash32(ruleID)), // key: rule hash
        &RuleMeta{
            Version:  2,
            Timeout:  500, // ms
            Enabled:  true,
        },
        ebpf.UpdateAny,
    )
}

hash32(ruleID)确保多核CPU间规则定位一致性；Timeout=500强制熔断超时规则，防goroutine泄漏。

灰度发布状态机

graph TD
    A[全量流量] -->|ratio=0.05| B[灰度集群]
    B --> C{规则执行成功？}
    C -->|是| D[自动扩比至0.2]
    C -->|否| E[回滚并告警]

指标	生产阈值	监控方式
规则匹配延迟		eBPF kprobe计时
内存占用		Go runtime.MemStats

2.5 美团配送调度平台Go化攻坚：高时效性地理围栏计算、分布式状态同步与GC调优实战

地理围栏实时判定优化

采用 R-Tree + 射线法混合策略，将围栏查询延迟压至 8ms（P99）：

// GeoFenceChecker.CheckPoint 并发安全，复用 ring buffer 减少内存分配
func (c *GeoFenceChecker) CheckPoint(lat, lng float64) []string {
    c.ringBuf.Reset() // 复用缓冲区，避免 GC 压力
    c.rtree.SearchWithinRadius(lat, lng, 500, c.ringBuf) // 仅检索半径500m内候选围栏
    var hits []string
    for _, fence := range c.ringBuf.Items() {
        if pointInPolygon(lat, lng, fence.Vertices) { // 射线法精确判定
            hits = append(hits, fence.ID)
        }
    }
    return hits
}

ringBuf 显式复用减少每请求 12KB 内存分配；SearchWithinRadius 先粗筛再精判，吞吐提升 3.2×。

分布式状态同步机制

基于 CRDT（G-Counter）实现骑手位置状态最终一致：

组件	一致性模型	同步延迟（P95）
Redis Cluster	弱一致性	180ms
CRDT Store	可证明收敛	42ms

GC 调优关键参数

• GOGC=50（默认100）降低堆增长阈值
• GOMEMLIMIT=4GiB 配合 cgroup memory limit 主动触发回收
• 每日 GC 次数下降 67%，STW 时间稳定

第三章：金融与政企领域的可信Go工程体系

3.1 中信证券交易后台Go服务集群：符合等保2.0与金融级SLA的内存安全审计与FIPS合规实践

为满足等保2.0三级“安全计算环境”中内存保护与FIPS 140-2加密模块强制要求，集群全面启用Go 1.21+原生-gcflags="-d=checkptr"编译时指针安全检查，并集成BoringCrypto替代标准crypto包。

内存安全加固关键配置

// 构建脚本片段（CI/CD pipeline）
go build -gcflags="-d=checkptr -d=ssa/check/on" \
         -ldflags="-linkmode external -extldflags '-Wl,-z,relro -Wl,-z,now'" \
         -buildmode=pie ./cmd/trade-core

checkptr启用运行时非法指针解引用拦截；-d=ssa/check/on激活SSA阶段越界检测；-z,relro/-z,now确保GOT表只读且立即重定位，防御ROP攻击。

FIPS合规加密栈切换

组件	标准库实现	FIPS认证替代方案
AES-GCM	crypto/aes	golang.org/x/crypto/chacha20poly1305（BoringCrypto桥接）
RSA签名	crypto/rsa	BoringCrypto’s RSA_PKCS1_SHA256
随机数生成器	crypto/rand	crypto/rand.Reader（自动绑定FIPS DRBG）

审计数据流

graph TD
    A[交易请求] --> B[内存安全沙箱]
    B --> C{指针合法性检查}
    C -->|通过| D[FIPS加密通道]
    C -->|拒绝| E[审计日志+熔断]
    D --> F[等保日志中心]

3.2 国家电网物联网平台Go边缘节点：ARM64低功耗设备上的静态链接、无CGO部署与远程OTA机制

为适配国网配电房内ARM64架构的低功耗边缘网关（如RK3399Pro），节点服务采用纯静态编译策略，彻底剥离运行时依赖。

静态构建关键命令

CGO_ENABLED=0 GOOS=linux GOARCH=arm64 \
    go build -a -ldflags="-s -w -buildmode=pie" \
    -o edge-node-arm64 .

• CGO_ENABLED=0：禁用C语言交互，避免glibc依赖；
• -a 强制重新编译所有依赖包（含标准库）；
• -ldflags="-s -w" 剥离符号表与调试信息，二进制体积减少约37%。

OTA升级流程

graph TD
    A[云端下发Delta差分包] --> B{边缘节点校验签名}
    B -->|通过| C[应用层解压+内存校验]
    C --> D[原子化切换主程序软链接]
    D --> E[重启后生效新版本]

典型部署约束

维度	要求
内存占用	≤18MB RSS
启动延迟
OTA回滚时间	≤1.2s（基于双分区镜像）

3.3 深圳政务云统一身份认证系统：Go+OpenID Connect联邦认证在多租户隔离与审计溯源中的落地验证

深圳政务云采用自研 Go 语言 OIDC Provider（gov-idp），支持跨委办局的联邦登录，租户通过 tenant_id 声明实现逻辑隔离。

租户上下文注入

func WithTenantContext(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        tenant := r.Header.Get("X-Tenant-ID") // 由API网关透传
        ctx := context.WithValue(r.Context(), "tenant", tenant)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

该中间件确保后续所有认证/授权链路携带租户上下文，避免租户间会话污染；X-Tenant-ID 由前置网关基于请求域名或Token中aud字段动态注入。

审计日志关键字段

字段	示例值	说明
trace_id	trc-7a2f9e1b	全链路追踪ID
tenant_id	sz-metro-2024	租户唯一标识
authn_method	oidc-wechat	认证源类型

身份联合流程

graph TD
    A[用户访问市监局应用] --> B{发现未登录}
    B --> C[重定向至gov-idp/login?tenant=sz-market]
    C --> D[选择微信扫码认证]
    D --> E[gov-idp签发含tenant_id的ID Token]
    E --> F[应用校验并建立租户隔离会话]

第四章：新兴技术栈中的Go协同生态

4.1 Go与eBPF深度集成：云原生网络策略执行器（Cilium替代方案）的内核态/用户态协同开发范式

传统网络策略执行依赖用户态代理转发，引入延迟与上下文切换开销。本方案将策略决策前移至eBPF程序，在XDP层完成L3/L4过滤，由Go编写的用户态守护进程（policyd）动态加载、热更新及指标上报。

数据同步机制

Go控制平面通过libbpf-go调用bpf_map_update_elem()向eBPF map写入CIDR策略条目，键为struct policy_key（含源/目标IP掩码、协议、端口范围），值为struct policy_val（动作、优先级、计数器偏移）。

// 向策略map插入允许TCP 80端口访问的规则
key := policyKey{SrcIP: net.ParseIP("10.0.0.0").To4(), SrcMask: 24, 
                 DstPort: 80, Proto: unix.IPPROTO_TCP}
val := policyVal{Action: ACTION_ALLOW, Priority: 100}
err := policyMap.Update(&key, &val, ebpf.UpdateAny)

UpdateAny确保原子覆盖；policyKey字段对齐需严格匹配eBPF C端结构体布局，否则map操作失败。

协同架构对比

维度	Cilium（默认）	本方案
策略下发延迟	~50ms（CRD→Agent→eBPF）
内核态可见性	有限（需bpftool）	实时metrics暴露（Go Prometheus handler）

graph TD
    A[Go Policy Controller] -->|gRPC| B[libbpf-go]
    B --> C[eBPF XDP Program]
    C --> D[TC Ingress Hook]
    D --> E[Pod Network Namespace]

4.2 Go驱动AI基础设施：KubeFlow Pipeline后端服务用Go重构TensorFlow Serving代理层的吞吐与延迟对比分析

为支撑KubeFlow Pipeline中高频、低延迟的模型推理调度，原Python Flask代理层被重构为高并发Go服务，核心聚焦gRPC-to-HTTP/1.1协议桥接与请求批处理。

关键优化点

• 基于net/http.Server启用ReadTimeout/WriteTimeout精细化控制
• 使用sync.Pool复用protobuf.Message实例，降低GC压力
• 集成OpenTelemetry SDK实现毫秒级P99延迟追踪

核心代理逻辑（简化版）

func (p *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(r.Context(), 300*time.Millisecond)
    defer cancel()

    // 将JSON请求反序列化为TF Serving gRPC PredictRequest
    req, err := p.jsonToPredictReq(r.Body) // 支持动态signature_name解析
    if err != nil {
        http.Error(w, "bad request", http.StatusBadRequest)
        return
    }

    // 复用gRPC客户端连接池，避免每次新建stream
    resp, err := p.grpcClient.Predict(ctx, req)
    if err != nil {
        http.Error(w, err.Error(), http.StatusServiceUnavailable)
        return
    }
    json.NewEncoder(w).Encode(resp)
}

该实现将平均延迟从327ms（Flask）降至89ms（Go），P99延迟压缩62%；QPS从142提升至1,856（单节点，4vCPU/16GB）。

性能对比（单节点压测结果）

指标	Python Flask	Go Proxy	提升幅度
平均延迟	327 ms	89 ms	72.8%↓
P99延迟	842 ms	319 ms	62.1%↓
吞吐（QPS）	142	1,856	1207%↑
内存常驻峰值	1.2 GB	316 MB	73.7%↓

请求流拓扑

graph TD
    A[Pipeline Webhook] --> B[Go Proxy HTTP Server]
    B --> C{Batch Aggregator?}
    C -->|Yes| D[gRPC Batch Predict]
    C -->|No| E[gRPC Predict Stream]
    D & E --> F[TFServing ModelServer]

4.3 Go构建WebAssembly服务端：Tetragon可观测性组件轻量化改造与浏览器直连调试能力拓展实践

Tetragon原生依赖eBPF内核模块，限制了无特权环境下的调试能力。通过Go+WASM重构核心事件处理逻辑，剥离内核耦合，实现浏览器端实时可观测性。

轻量化架构演进

• 移除libbpf-go依赖，仅保留github.com/cilium/ebpf的用户态解析器
• WASM模块通过syscall/js暴露registerHandler()和emitEvent()接口
• 事件序列化统一采用CBOR，体积比JSON减少约62%

浏览器直连调试机制

// main.go —— WASM入口点，注册JS可调用函数
func main() {
    js.Global().Set("tetragon", map[string]interface{}{
        "start": func() interface{} {
            go eventLoop() // 启动WASM沙箱内事件循环
            return nil
        },
        "onEvent": js.FuncOf(func(this js.Value, args []js.Value) interface{} {
            // JS侧调用：tetragon.onEvent = (e) => { ... }
            handleBrowserEvent(args[0].String())
            return nil
        }),
    })
    select {} // 阻塞主goroutine
}

该代码将Go运行时嵌入WASM实例，js.FuncOf创建跨语言回调桩；select{}防止WASM模块退出，确保JS可随时注入事件。args[0].String()隐式触发JS→Go字符串解码，需确保前端传入合法CBOR base64编码。

性能对比（10k事件吞吐）

模块类型	内存占用	启动延迟	事件序列化耗时
原生eBPF Daemon	42 MB	850 ms	—
WASM轻量版	8.3 MB	112 ms	1.7 μs/evt

graph TD
    A[浏览器DevTools] -->|WebSocket| B(WASM Tetragon)
    B --> C[CBOR解码]
    C --> D[事件过滤引擎]
    D --> E[JS回调 emitEvent]
    E --> F[Chrome Performance Panel]

4.4 Go+Rust混合系统：区块链共识模块（Rust）与链下业务网关（Go）的FFI边界设计与跨语言错误传播治理

FFI边界契约设计

采用 C ABI 兼容接口，所有数据通过 POD 类型（uint64_t, int32_t, const char*）传递，避免 Rust 的 String 或 Go 的 []byte 直接跨界。

错误传播机制

Rust 端统一返回 i32 错误码，Go 调用侧映射为 error 接口：

// consensus/src/lib.rs
#[no_mangle]
pub extern "C" fn verify_block(
    block_ptr: *const u8,
    block_len: usize,
    out_result: *mut i32,
) -> i32 {
    // ... 验证逻辑
    if let Ok(()) = validate(&block_slice) {
        unsafe { *out_result = 1 };
        0 // success
    } else {
        unsafe { *out_result = 0 };
        -1 // consensus::ValidationError
    }
}

逻辑分析：verify_block 不返回复杂结构，仅通过 out_result 输出业务结果（1=有效，0=无效），主返回值专用于系统级错误（如内存越界、解序列化失败）。block_ptr 必须由 Go 侧保证生命周期 ≥ 函数调用期。

错误码语义对齐表

错误码	来源语言	含义
0	Rust	验证失败（业务逻辑）
-1	Rust	输入非法（长度/指针为空）
-2	Go	Cgo 调用超时（context.DeadlineExceeded）

跨语言 panic 隔离

// gateway/ffi.go
func VerifyBlock(block []byte) (bool, error) {
    cBlock := C.CBytes(block)
    defer C.free(cBlock)

    var result C.int
    status := C.verify_block((*C.uchar)(cBlock), C.size_t(len(block)), &result)

    if status != 0 {
        return false, mapRustStatusToGoError(status) // 如：-1 → ErrInvalidInput
    }
    return result == 1, nil
}

参数说明：cBlock 经 C.CBytes 复制至 C 堆，规避 Go GC 移动导致的悬垂指针；status 为底层 FFI 调用状态，result 为共识验证的业务输出。

第五章：迁移本质：不止于语言，更是工程范式的升维

从单体Java服务到云原生Go微服务的真实演进路径

某金融科技公司2021年启动核心支付网关重构项目，将运行7年的Spring Boot单体服务（约42万行Java代码）逐步迁移至Go语言微服务架构。迁移并非简单重写——团队同步引入GitOps流水线、基于OpenTelemetry的全链路追踪、Kubernetes Operator管理配置热更新，并将CI/CD平均构建耗时从18分钟压降至92秒。关键转折点在于放弃“先迁语言、再改架构”的惯性思维，转而以服务网格（Istio）为底座，在迁移初期即实现Java与Go服务共存下的统一熔断、灰度路由与指标采集。

工程契约驱动的渐进式兼容策略

团队定义了三类强制契约层：

• 协议契约：gRPC + Protocol Buffers v3（.proto 文件由API设计先行生成，Java/Go双端自动生成stub）
• 可观测性契约：所有服务必须输出结构化JSON日志（含trace_id、span_id、service_name字段），并通过Fluent Bit统一采集至Loki
• 部署契约：Docker镜像必须包含/healthz HTTP端点且响应时间

该策略使23个微服务在14个月内完成分批上线，期间零次因语言差异导致的跨服务通信故障。

构建时依赖治理的范式转移

维度	Java时代（Maven）	Go时代（Go Modules + Athens Proxy）
依赖锁定	pom.xml + dependencyManagement	go.sum + 校验和签名验证
私有包管理	Nexus仓库人工审核	Athens代理自动缓存+SHA256白名单校验
构建确定性	受本地~/.m2缓存干扰	GOCACHE=off + 完整模块哈希校验

迁移后第三方库漏洞平均修复周期从5.2天缩短至17小时，归功于go list -m all | grep -E "CVE|vuln"自动化扫描集成至PR检查流。

flowchart LR
    A[开发者提交PR] --> B[触发GitHub Actions]
    B --> C{go mod verify}
    C -->|失败| D[阻断合并，标记CVE编号]
    C -->|成功| E[调用Athens API校验模块签名]
    E --> F[生成SBOM清单并上传Syft数据库]
    F --> G[批准合并]

团队能力模型的结构性重塑

原Java团队中12名工程师参与迁移，6个月后技能图谱发生显著偏移：

• 3人主导SRE能力建设（Prometheus告警规则编写、K8s HPA策略调优）
• 4人转型平台工程师（开发内部CLI工具链，如payctl deploy --canary=10%）
• 5人成为领域驱动设计实践者（使用PlantUML绘制限界上下文映射图，驱动Go模块拆分）

一次典型事件：当第三方支付渠道SDK仅提供Java版时，团队未等待对方Go适配，而是用JNI桥接封装成gRPC网关服务，暴露标准Protobuf接口供所有Go微服务调用——这标志着工程重心已从“语言语法适配”转向“系统级抽象能力”。

文档即代码的协同范式落地

所有架构决策记录（ADR）均以Markdown格式存于/adr/目录，每篇含YAML元数据：

status: accepted
date: 2023-04-12
deciders: ["@ops-lead", "@arch-council"]
consequences:
  - "所有新服务必须使用EnvoyFilter注入X-Request-ID"
  - "废弃Spring Cloud Config，改用Consul KV + Vault动态Secret注入"

该机制使技术决策可追溯、可审计、可自动化校验，避免“口头约定”导致的架构腐化。