【大模型Go编程实战指南】：20年专家亲授高并发LLM服务开发的5大避坑法则

第一章：大模型Go编程的核心范式与架构认知

在大模型工程化落地过程中，Go语言凭借其高并发、低延迟、强可部署性及静态编译优势，正成为推理服务、微服务编排、Tokenizer后端与模型监控系统的关键实现语言。其核心价值不在于替代Python进行模型训练，而在于构建可靠、可观测、可伸缩的生产级AI基础设施层。

Go语言在大模型栈中的典型定位

• 推理服务层：基于net/http或gRPC封装LLM推理接口，配合sync.Pool复用Tensor输入缓冲区，降低GC压力；
• Token处理层：集成Hugging Face tokenizer（如通过github.com/rocketlaunchr/tokenizers-go绑定C库），实现毫秒级分词与detokenize；
• 模型生命周期管理：利用runtime/debug.ReadGCStats监控内存波动，结合pprof实时分析推理路径热点；
• 多模型路由网关：通过context.WithTimeout统一控制各模型调用超时，并以sync.Map缓存模型加载句柄，避免重复初始化。

关键架构约束与设计原则

• 零拷贝优先：使用unsafe.Slice与reflect.SliceHeader在[]byte与[]float32间转换张量数据，规避内存复制开销；
• 异步流式响应：采用http.Flusher与io.Pipe组合实现SSE流式输出，确保首token延迟低于100ms；
• 配置即代码：将模型路径、量化精度（int4/int8）、KV缓存策略等声明为结构体标签，由github.com/mitchellh/mapstructure动态注入。

以下为启动一个支持流式响应的最小推理HTTP handler示例：

func streamHandler(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/event-stream")
    w.Header().Set("Cache-Control", "no-cache")
    flusher, ok := w.(http.Flusher)
    if !ok {
        http.Error(w, "streaming unsupported", http.StatusInternalServerError)
        return
    }

    // 构建请求上下文并设置超时（关键：防止长尾请求阻塞）
    ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
    defer cancel()

    // 调用底层推理函数，返回channel流式产出token
    tokenCh := model.InferenceStream(ctx, r.Body)

    for token := range tokenCh {
        fmt.Fprintf(w, "data: %s\n\n", token)
        flusher.Flush() // 立即推送至客户端
    }
}

第二章：高并发LLM服务的Go底层机制避坑

2.1 Go协程调度与LLM推理任务的粒度控制实践

在高并发LLM服务中，粗粒度goroutine（如每请求启一个goroutine）易引发调度风暴。需将推理任务拆解为可调度单元：

• 预处理（tokenize、padding）
• 前向计算（分层offload或batch slice）
• 后处理（detokenize、streaming flush）

func scheduleInference(ctx context.Context, req *InferRequest) {
    // 使用带缓冲的worker pool控制并发上限
    select {
    case w := <-workerPool: // 阻塞获取空闲worker
        w.Run(ctx, req)     // 执行细分任务，非阻塞I/O
    case <-time.After(500 * time.Millisecond):
        metrics.IncTimeout()
        return
    }
}

workerPool 是 chan *Worker 类型，容量即最大并行推理数；w.Run 内部按token chunk异步调度CUDA kernel，避免goroutine长时间阻塞。

粒度层级	调度开销	GPU利用率	适用场景
请求级	低	波动大	小批量离线批处理
Token块级	中	>85%	流式生成（Streaming）

graph TD
    A[HTTP Request] --> B{Split by maxTokensPerChunk}
    B --> C[Preprocess Goroutine]
    B --> D[Compute Goroutine Pool]
    B --> E[Postprocess Goroutine]
    D --> F[GPU Kernel Launch]

2.2 Channel通信在Prompt流水线中的误用与重构方案

常见误用模式

开发者常将 Channel 用于跨阶段 Prompt 数据传递，却忽略其无序性与缓冲竞争风险：

// ❌ 错误示例：多生产者并发写入同一 channel，未加序控
let (tx, rx) = mpsc::channel::<PromptStep>(16);
spawn_prompt_stage_1(tx.clone()); // 可能早于 stage_2 发送
spawn_prompt_stage_2(tx);         // 但语义上 stage_2 输出应后置

逻辑分析：mpsc::channel 不保证投递顺序；PromptStep 若含依赖上下文（如模板填充需前置变量），乱序将导致 {{user_input}} 渲染失败。参数 16 为缓冲上限，但无法约束逻辑时序。

重构方案：有序同步通道

改用 tokio::sync::broadcast + 序号标记：

组件	作用
BroadcastSender	广播带版本号的 PromptStep
StepSequence	全局单调递增序列号
OrderedReceiver	按序缓存/阻塞等待缺失帧

graph TD
    A[Stage 1] -->|PromptStep{seq:1, data:“sys”}| B[Broadcast]
    C[Stage 2] -->|PromptStep{seq:2, data:“user”}| B
    B --> D[OrderedReceiver]
    D -->|emit only seq=1→2| E[Renderer]

2.3 内存逃逸分析与大模型Tensor缓存的GC压力规避

在大模型推理中，频繁创建临时Tensor易触发JVM/Python GC抖动。Go语言的逃逸分析可静态识别堆分配，而PyTorch需结合torch.utils._pytree.tree_map手动控制生命周期。

Tensor缓存复用策略

• 使用weakref.WeakKeyDictionary管理GPU张量缓存，避免强引用滞留
• 按shape+dtype哈希键索引，支持跨batch复用

from torch import Tensor
import weakref

_cache = weakref.WeakKeyDictionary()  # 自动清理已释放Tensor

def get_cached_tensor(shape, dtype=torch.float16):
    key = (tuple(shape), dtype)
    if key not in _cache:
        _cache[key] = torch.empty(shape, dtype=dtype, device="cuda")
    return _cache[key].zero_()  # 复用并清零

zero_()原地清零避免新分配；WeakKeyDictionary确保缓存不阻止GC——当Tensor被释放时，对应条目自动失效，消除内存泄漏风险。

GC压力对比（每千次推理）

策略	平均GC暂停(ms)	缓存命中率
原生new tensor	42.7	0%
弱引用缓存	3.1	89%

graph TD
    A[请求Tensor] --> B{缓存存在？}
    B -->|是| C[返回zero_()复用]
    B -->|否| D[分配新Tensor]
    D --> E[注册至WeakKeyDictionary]
    C --> F[交付下游计算]

2.4 Context超时传播在多阶段LLM调用链中的失效场景与修复

失效根源：Context未跨协程透传

当LLM调用链涉及 A → B → C（如RAG检索→重排→生成），若中间服务使用独立 goroutine 或线程处理子请求，context.WithTimeout 创建的 deadline 无法自动穿透至下游 HTTP 客户端。

典型错误代码

func callLLM(ctx context.Context, url string) (*http.Response, error) {
    // ❌ 错误：未将ctx传入http.NewRequestWithContext
    req, _ := http.NewRequest("POST", url, nil)
    return http.DefaultClient.Do(req) // 超时丢失！
}

逻辑分析：http.NewRequest 创建无上下文请求，http.DefaultClient.Do 使用默认 30s 超时，与原始 ctx.Deadline() 完全脱钩；ctx 中的取消信号亦无法中止该请求。

修复方案对比

方案	是否透传Deadline	是否响应Cancel	是否需修改SDK
http.NewRequestWithContext(ctx, ...)	✅	✅	❌
手动设置 req.Cancel channel	⚠️（仅Cancel）	✅	✅

正确实现

func callLLM(ctx context.Context, url string) (*http.Response, error) {
    req, err := http.NewRequestWithContext(ctx, "POST", url, nil)
    if err != nil { return nil, err }
    return http.DefaultClient.Do(req) // ✅ 自动继承ctx超时与取消
}

逻辑分析：NewRequestWithContext 将 ctx.Deadline() 映射为 req.Context().Done()，http.Client 内部监听此 channel 并主动终止连接，确保整条链超时一致性。

2.5 sync.Pool在Tokenizer与Embedding预处理中的定制化复用陷阱

数据同步机制

sync.Pool 在高频短生命周期对象（如 []byte 缓冲区、TokenSlice）复用中显著降低 GC 压力，但隐式清空策略易引发脏数据残留。

关键陷阱示例

var tokenBufPool = sync.Pool{
    New: func() interface{} {
        buf := make([]byte, 0, 512)
        return &buf // ❌ 返回指针导致后续 Get 可能复用未清零的底层数组
    },
}

逻辑分析：&buf 持有指向栈/堆的指针，Put 后 Pool 不保证内存归零；若前次 Put 的 buf 含旧 token 字节，下次 Get() 后直接 append() 将叠加脏数据。应返回值类型 []byte 并在 Get() 后显式 buf = buf[:0]。

安全复用模式对比

方式	是否自动清零	复用安全性	推荐场景
[]byte 值类型	否（需手动截断）	⚠️ 高（可控）	Tokenizer 输入缓冲
*TokenSlice	否	❌ 极低	禁止使用

graph TD
    A[Get from Pool] --> B{Buffer length > 0?}
    B -->|Yes| C[Must reset: buf = buf[:0]]
    B -->|No| D[Safe to use]
    C --> D

第三章：LLM服务中间件层的Go工程化避坑

3.1 基于Gin/Fiber的流式响应中间件与HTTP/2 Server Push冲突解析

HTTP/2 Server Push 要求响应头在首次 WriteHeader 前完成发送，而流式中间件（如 SSE 或 chunked 响应）常在 http.ResponseWriter 上多次调用 Write()，隐式触发 header 提交——导致 push 操作失败（http: invalid Write after WriteHeader）。

核心冲突机制

• Gin/Fiber 默认 ResponseWriter 不支持 header 延迟提交
• Server Push 必须在 Pusher.Push() 调用时 header 尚未发送
• 流式中间件通常在 c.Stream() 或自定义 io.Writer 中提前 flush header

兼容性解决方案对比

方案	Gin 支持	Fiber 支持	是否保留 Push
自定义 ResponseWriter 拦截 WriteHeader	✅（需包装 gin.ResponseWriter）	✅（fiber.Ctx.Response().SetBodyStreamWriter 可延迟）	✅
禁用 Transfer-Encoding: chunked 并预设 Content-Length	❌（动态流式不可预知长度）	⚠️（仅静态流适用）	✅（header 可控）

// Gin 中兼容 Server Push 的流式包装器示例
func StreamingWithPush(c *gin.Context) {
    pusher, ok := c.Writer.(http.Pusher)
    if ok {
        _ = pusher.Push("/style.css", &http.PushOptions{Method: "GET"})
    }
    // 关键：手动控制 header，避免隐式 WriteHeader
    c.Header("Content-Type", "text/event-stream")
    c.Header("Cache-Control", "no-cache")
    c.Header("X-Accel-Buffering", "no") // Nginx 兼容
    c.Status(http.StatusOK)
    c.Writer.Flush() // 显式 flush header，为后续 Write 留出空间
    // 后续 c.Stream(...) 或 c.SSEvent(...) 可安全写入 body
}

逻辑分析：该写法绕过 Gin 默认的 WriteHeader 自动触发逻辑；c.Status() 设置状态码但不立即发送 header，c.Writer.Flush() 手动提交 header 后，pusher.Push() 已执行完毕，后续流式写入不再干扰 HTTP/2 推送通道。参数 X-Accel-Buffering: no 防止 Nginx 缓冲 SSE 数据，确保实时性。

3.2 OpenTelemetry链路追踪在异步推理Pipeline中的Span断裂修复

异步推理Pipeline中，模型加载、预处理、GPU推理、后处理常跨线程/协程/消息队列执行，导致Span上下文丢失，形成断链。

核心断裂场景

• 线程池提交任务时 Context.current() 未传递
• Kafka/RabbitMQ 消息无 traceparent 注入
• FastAPI BackgroundTasks 默认隔离 Span

上下文透传方案

# 使用 opentelemetry-instrumentation-concurrent-futures 自动注入
from opentelemetry.instrumentation.concurrent_futures import ConcurrentFuturesInstrumentor
ConcurrentFuturesInstrumentor().instrument()

# 手动跨线程延续（关键兜底）
def async_inference_task(payload):
    ctx = baggage.get_baggage("trace_id")  # 从父Span提取上下文
    with tracer.start_as_current_span("model-infer", context=ctx):
        # ... 推理逻辑

该代码确保即使线程池未被自动插桩，也能通过显式 context= 参数恢复调用链；baggage.get_baggage("trace_id") 仅作示意，实际应使用 trace.get_current_span().get_span_context() 或 propagator.extract() 解析 W3C traceparent。

修复效果对比

场景	断裂率	修复后链路完整度
同步CPU预处理	0%	100%
ThreadPoolExecutor	92%	99.8%
Kafka消费回调	100%	97.5%

graph TD
    A[HTTP Request] --> B[Preprocess Span]
    B --> C[Thread Pool Submit]
    C --> D{Context Propagated?}
    D -->|Yes| E[Inference Span]
    D -->|No| F[Orphaned Span]
    E --> G[Postprocess Span]

3.3 JWT鉴权与模型访问策略动态加载的并发安全实现

策略热更新的线程安全边界

采用 ConcurrentHashMap<String, AccessPolicy> 缓存策略实例，配合 StampedLock 实现读多写少场景下的低开销乐观读。

private final StampedLock lock = new StampedLock();
private volatile Map<String, AccessPolicy> policyCache = new ConcurrentHashMap<>();

public AccessPolicy getPolicy(String resourceId) {
    long stamp = lock.tryOptimisticRead(); // 乐观读开始
    AccessPolicy policy = policyCache.get(resourceId);
    if (lock.validate(stamp)) return policy; // 未被写入干扰，直接返回

    stamp = lock.readLock(); // 升级为悲观读锁
    try {
        return policyCache.getOrDefault(resourceId, DEFAULT_POLICY);
    } finally {
        lock.unlockRead(stamp);
    }
}

逻辑分析：tryOptimisticRead() 避免锁竞争，仅在检测到写操作时才降级为读锁；volatile 修饰 policyCache 引用确保引用可见性，而 ConcurrentHashMap 保障内部结构线程安全。参数 resourceId 作为策略键，需满足不可变性与合理散列分布。

动态策略加载触发时机

• JWT 解析后首次访问某模型时按需加载
• 策略配置中心（如 Nacos）变更事件驱动刷新
• 定时校验（TTL=5min）+ 版本号比对防 stale 数据

加载方式	延迟	一致性保障
首访按需加载		强一致（同步拉取）
配置中心事件	~100ms	最终一致（异步通知）
TTL 定期校验	可配置	版本号强校验

鉴权执行流（简化版）

graph TD
    A[JWT解析] --> B{Token有效？}
    B -->|否| C[拒绝访问]
    B -->|是| D[提取resource_id & action]
    D --> E[getPolicy resource_id]
    E --> F[match action against rules]
    F -->|允许| G[放行]
    F -->|拒绝| H[403 Forbidden]

第四章：大模型推理引擎的Go性能调优避坑

4.1 ONNX Runtime Go binding的线程绑定与CPU亲和性配置误区

Go binding 默认不继承 C++ backend 的 CPU 亲和性控制能力，ort.NewSession 创建的会话在多核调度下易受 OS 抢占干扰。

常见误配模式

• 直接调用 runtime.GOMAXPROCS(n) 无法约束 ONNX Runtime 内部线程池；
• 在 Go 层使用 taskset 绑定进程，但 ORT 内部线程仍可能迁移；
• 忽略 ORT_ENABLE_CPU_MEM_AFFINITY 环境变量，导致内存分配跨 NUMA 节点。

正确初始化示例

// 启用 CPU 内存亲和性（需编译时开启）
os.Setenv("ORT_ENABLE_CPU_MEM_AFFINITY", "1")
session, _ := ort.NewSession(
    modelPath,
    ort.WithNumThreads(4),
    ort.WithSessionOptions(ort.SessionOptions{
        InterOpNumThreads: 1, // 控制跨算子并行度
        IntraOpNumThreads: 4, // 绑定到指定 CPU 核心数
    }),
)

IntraOpNumThreads 实际触发 ORT 内部 ThreadPool::SetAffinity()，但仅当底层构建启用 USE_OPENMP 或 USE_TBB 且运行时加载对应库时生效。

配置项	是否影响线程绑定	依赖条件
ORT_ENABLE_CPU_MEM_AFFINITY=1	✅ NUMA 感知内存分配	编译时定义
IntraOpNumThreads	✅ CPU 核心绑定	OpenMP/TBB 运行时可用
GOMAXPROCS	❌ 无直接影响	Go 调度器层面

graph TD
    A[Go 应用调用 NewSession] --> B{ORT 初始化}
    B --> C[读取 IntraOpNumThreads]
    C --> D[尝试调用 omp_set_num_threads]
    D --> E[失败：libomp.so 未加载 → 退化为无亲和性]

4.2 mmap加速权重加载时Page Fault抖动的量化监控与预热策略

Page Fault抖动的可观测性建模

通过/proc/[pid]/statm与perf record -e page-faults协同采样，构建毫秒级抖动分布直方图。关键指标包括：

• majflt（主缺页次数）反映磁盘I/O压力
• minflt（次缺页次数）表征内存映射延迟

预热触发条件判定

def should_preheat(weight_size_mb: float, fault_rate_pps: float) -> bool:
    # weight_size_mb: mmap映射的权重文件大小（MB）
    # fault_rate_pps: 每秒缺页率（pages per second）
    return weight_size_mb > 512 and fault_rate_pps > 8000

逻辑分析：当大模型权重（>512MB）遭遇高频缺页（>8k pages/s），表明冷启动阶段TLB未填充、页表未预建立，需主动预热；阈值经A/B测试在Llama-3-8B推理中验证有效。

预热执行流程

graph TD
    A[读取mmap区域元数据] --> B[按4KB页对齐分块]
    B --> C[调用madvise(addr, len, MADV_WILLNEED)]
    C --> D[同步触发mincore校验驻留状态]

监控维度	工具链	采样周期
缺页延迟分布	eBPF + tracepoint	10ms
物理页驻留率	mincore() + /proc/meminfo	1s
TLB miss率	perf stat -e tlb-misses	500ms

4.3 CUDA流同步在Go CGO调用中的隐式阻塞识别与异步封装

隐式阻塞的典型场景

当 Go 程序通过 CGO 调用 cudaMemcpyAsync 但未显式绑定流（stream == 0），CUDA 默认使用空流（null stream），该流具有跨设备操作的全局同步语义——导致后续所有流操作隐式等待其完成。

同步行为对比表

调用方式	同步范围	是否阻塞其他流
cudaMemcpyAsync(..., 0)	全局（所有流）	✅
cudaMemcpyAsync(..., stream)	仅同一流内	❌

异步封装核心逻辑

// cuda_wrapper.go（CGO导出函数）
/*
#cgo LDFLAGS: -lcudart
#include <cuda_runtime.h>
*/
import "C"

func AsyncCopyH2D(dst C.cudaArray_t, src unsafe.Pointer, size int, stream C.cudaStream_t) error {
    ret := C.cudaMemcpyAsync(
        C.voidp(dst),      // 目标设备地址（cudaArray_t需转为void*，实际需额外映射）
        src,               // 源主机地址
        C.size_t(size),    // 字节数
        C.cudaMemcpyHostToDevice,
        stream,            // 显式传入非零流，避免null流陷阱
    )
    if ret != C.cudaSuccess {
        return fmt.Errorf("cudaMemcpyAsync failed: %v", ret)
    }
    return nil
}

逻辑分析：stream 参数必须由 Go 层预先创建（C.cudaStreamCreate(&s)），不可复用或为零；dst 类型需配合 cudaArray 或 cudaMalloc 分配的指针，此处简化示意；错误检查不可省略，因异步失败可能延迟暴露。

流依赖建模（mermaid）

graph TD
    A[Host Memory Write] --> B[cudaMemcpyAsync H2D]
    B --> C[cudaLaunchKernel]
    C --> D[cudaMemcpyAsync D2H]
    B -.->|隐式同步| D
    style B stroke:#f66,stroke-width:2px

4.4 LLM KV Cache内存布局优化与Go unsafe.Pointer边界校验实践

KV Cache 的连续内存布局可显著降低 LLM 推理时的访存开销。典型优化包括：

• 将 key 与 value 张量按 layer × head × seq_len × dim 合并为单块分配
• 使用 unsafe.Pointer 跳过 bounds check，但需手动校验指针有效性

边界校验核心逻辑

func validateKVPtr(base unsafe.Pointer, offset, size uintptr) bool {
    if base == nil { return false }
    hdr := (*reflect.SliceHeader)(unsafe.Pointer(&struct{ s []byte }{s: make([]byte, 0)}))
    // 确保 offset 不越界（假设已知总容量 capBytes）
    return offset+size <= hdr.Cap
}

该函数通过伪造 SliceHeader 获取底层 cap（实际需传入真实 capBytes），避免 panic；offset 为相对起始地址的字节偏移，size 为待访问区域长度。

优化效果对比（batch=1, seq_len=2048）

布局方式	平均延迟	内存碎片率
分离分配	18.3 ms	32%
连续紧凑布局	14.1 ms

graph TD
    A[申请大块内存] --> B[计算各layer偏移]
    B --> C[unsafe.Slice 派生子视图]
    C --> D[运行时校验 offset+size ≤ cap]

第五章：面向生产环境的大模型Go服务演进路径

从单体推理服务到高可用API网关

早期在Kubernetes集群中部署的llm-inference-go服务采用单进程HTTP handler直连HuggingFace Transformers模型，内存峰值达12GB，P95响应延迟波动在800ms–3.2s之间。上线两周后遭遇三次OOM Kill事件。改造后引入Nginx+Lua前置缓存层，对/v1/chat/completions中重复的system/user prompt组合做LRU-64缓存，并通过X-Request-ID与X-Trace-ID实现全链路日志串联。压测数据显示缓存命中率稳定在67.3%，P95延迟降至412ms（±23ms）。

模型热加载与版本灰度机制

为规避服务重启导致的推理中断，基于fsnotify构建模型文件监听器，当检测到/models/llama3-8b-v2/目录下config.json或model.safetensors更新时，触发异步加载流程：先校验SHA256哈希、再预分配显存、最后原子替换atomic.Value中的*llm.Model实例。配合Kubernetes ConfigMap管理模型元数据，实现v1/v2双版本并行运行，通过HTTP Header X-Model-Version: v2控制路由权重——当前灰度比例为15%，Prometheus指标llm_model_version_requests_total{version="v2"}持续采集验证。

GPU资源隔离与QoS保障

在A100 80GB节点上部署nvidia-device-plugin后，发现多个Pod共享GPU时出现显存碎片化问题。解决方案是启用CUDA_VISIBLE_DEVICES环境变量绑定独占设备，并在Go服务启动时调用cuda.DeviceGetAttribute(&attr, cudaDevAttrComputeCapabilityMajor, device)校验算力兼容性。关键配置如下：

参数	值	说明
CUDA_MPS_PIPE_DIRECTORY	/tmp/nvidia-mps	启用多进程服务模式
GOMEMLIMIT	16GiB	防止Go runtime过度申请内存
LLM_MAX_CONCURRENCY	8	基于runtime.NumCPU()动态计算

流式响应与连接保活优化

针对SSE流式输出场景，重写http.ResponseWriter包装器，在每次Write()后主动调用Flush()并注入data:前缀。同时设置Keep-Alive: timeout=30, max=100，并通过net/http.Server.IdleTimeout = 45 * time.Second避免TCP连接过早关闭。实测在弱网环境下（200ms RTT + 5%丢包），客户端接收完整done事件的成功率从73%提升至99.2%。

func (s *StreamingWriter) Write(p []byte) (int, error) {
    _, _ = s.w.Write([]byte("data: "))
    n, err := s.w.Write(p)
    _ = s.w.(http.Flusher).Flush() // 强制刷新SSE流
    return n, err
}

生产级可观测性集成

接入OpenTelemetry Collector，自动采集gRPC调用（用于向vLLM backend转发请求）、HTTP中间件耗时、CUDA kernel执行时间（通过nvml库读取NVML_DEVICE_ATTRIBUTE_GPU_UTILIZATION）。所有trace打标service.name=llm-api-go，metric指标llm_inference_duration_seconds_bucket按model="llama3-8b"和quantization="q4_k_m"双维度聚合。Grafana看板中设置告警规则：当rate(llm_inference_errors_total[5m]) > 0.02且gpu_utilization{device="0"} < 10时触发GPU空闲异常诊断。

安全加固实践

禁用所有非必要HTTP方法（仅保留POST/HEAD），通过gorilla/handlers.CompressHandler启用Brotli压缩，使用crypto/tls.Config强制TLS 1.3并禁用RSA密钥交换。敏感操作如模型上传需经/admin/model/upload端点，该端点要求Authorization: Bearer <JWT>且JWT由内部Keycloak颁发，声明包含scope: model:admin。审计日志记录所有/v1/*路径的X-Forwarded-For与User-Agent字段，留存周期180天。

flowchart LR
    A[Client Request] --> B{Auth Middleware}
    B -->|Valid JWT| C[Rate Limit Check]
    C -->|Within Quota| D[Model Router]
    D --> E[Cache Lookup]
    E -->|Hit| F[Return Cached Response]
    E -->|Miss| G[GPU Inference]
    G --> H[Response Stream]
    H --> I[OTel Trace Export]