Go语言在AI基础设施层的隐形崛起：向量数据库客户端、模型服务Proxy、Prompt编排引擎的标配语言

第一章：Go语言在AI基础设施层的定位与演进逻辑

在现代AI工程实践中，基础设施层承担着模型训练调度、推理服务编排、分布式数据加载、可观测性采集与资源隔离等关键职责。Go语言并非为AI算法设计，却因其原生并发模型、静态链接二进制、低GC延迟及强类型系统，在该层级展现出不可替代的工程优势。

核心定位：可信赖的胶水与底座语言

Go不参与张量计算或自动微分，而是构建连接AI组件的“可信中间件”：Kubernetes控制器（如Kubeflow Operator）、模型服务网关（如Triton Inference Server的Go客户端封装）、特征存储同步器、以及轻量级Prometheus Exporter。其编译产物无依赖、秒级启停、内存占用可控，天然适配容器化AI工作流的生命周期管理需求。

演进动因：从工具链到平台原语

早期Go多用于CLI工具（如gocv调用OpenCV）；随着eBPF与WASM技术成熟，Go开始深度介入基础设施内核——例如使用cilium/ebpf库编写GPU显存监控探针，或通过wasmer-go嵌入WASM模块实现沙箱化预处理函数。这种演进并非语言功能跃迁，而是生态对“确定性交付”与“跨云一致性”的持续强化。

实际落地示例：轻量级推理路由代理

以下代码片段展示一个基于net/http与sync.Map实现的模型版本路由代理，支持热更新路由规则而无需重启：

// 初始化路由映射（线程安全）
var modelRoutes sync.Map // key: modelID, value: *http.Client

// 注册新模型端点（可由配置中心触发）
func registerModel(modelID, endpoint string) {
    client := &http.Client{Timeout: 30 * time.Second}
    modelRoutes.Store(modelID, client)
}

// 路由请求至对应模型服务
func proxyToModel(w http.ResponseWriter, r *http.Request) {
    modelID := r.URL.Query().Get("model")
    if client, ok := modelRoutes.Load(modelID); ok {
        // 构造转发请求，保留原始Header
        req, _ := http.NewRequest(r.Method, endpoint+"/infer", r.Body)
        req.Header = r.Header.Clone()
        resp, _ := client.(*http.Client).Do(req)
        io.Copy(w, resp.Body) // 简化示意，生产需处理错误与流控
    }
}

对比维度	Python（Flask）	Go（net/http）
启动耗时（冷）	~200ms	~8ms
内存常驻开销	~80MB	~12MB
并发连接吞吐	中等（GIL限制）	高（goroutine轻量）

这种底层能力使Go成为AI平台构建者首选的“基础设施编织语言”，而非上层建模语言。

第二章：向量数据库客户端的高性能实现

2.1 向量相似性检索协议解析与gRPC/HTTP双栈适配

向量相似性检索协议需在低延迟与跨语言兼容间取得平衡。核心采用 SearchRequest 与 SearchResponse 二元契约，统一描述查询向量、Top-K、相似度阈值及索引路由策略。

协议字段语义对齐

• vector: float32 数组，长度由模型维度固定（如 768）
• k: 检索上限，服务端强制裁剪以保障 QPS 稳定性
• filter: 支持属性过滤的表达式（如 "tenant_id == 'abc'"）

gRPC 与 HTTP 接口映射对照表

字段	gRPC 类型	HTTP JSON 映射	是否必需
vector	repeated float	vector: [0.1, -0.5, ...]	✅
k	int32	k: 10	✅
timeout_ms	int32	timeout: 100	❌（默认 50ms）

// proto/vectordb.proto
message SearchRequest {
  repeated float vector = 1;      // 查询向量，归一化后传输
  int32 k = 2 [(validate.rules).int32.gt = 0]; // 必须 > 0
  string filter = 3;             // CEL 表达式，服务端解析执行
}

该定义经 protoc-gen-go-grpc 生成强类型 stub，并通过 grpc-gateway 自动生成 RESTful 路由 /v1/search，实现双栈零重复开发。

请求分发流程

graph TD
  A[Client] -->|gRPC 或 HTTP| B(API Gateway)
  B --> C{协议识别}
  C -->|gRPC| D[Direct gRPC Handler]
  C -->|HTTP| E[JSON→Proto 转换]
  E --> D
  D --> F[ANN 引擎检索]

2.2 内存安全向量序列化：flatbuffers与msgpack的Go原生优化实践

在高吞吐实时数据管道中，零拷贝与内存布局可控性成为关键约束。FlatBuffers 提供 schema-driven 编译时内存布局，而 MsgPack 以动态紧凑二进制适配异构结构。

零拷贝读取：FlatBuffers Go 绑定实践

// schema.fbs: table Vector3 { x:float32; y:float32; z:float32; }
fbData := getFlatBufferBytes() // 已含 root table offset
root := flatbuffers.GetRootAsVector3(fbData, 0)
x, y, z := root.X(), root.Y(), root.Z() // 直接指针解引用，无内存分配

GetRootAsVector3 仅校验 buffer 边界与对齐，X() 等方法通过固定偏移（编译期确定）直接读取 []byte 底层数据，规避 GC 压力与复制开销。

动态紧凑序列化：MsgPack 的 Go 原生优化

type Event struct {
    ID     uint64 `msgpack:"i"`
    Tags   []string `msgpack:"t"`
    Payload []byte `msgpack:"p,omitempty"`
}

msgpack tag 控制字段名压缩、零值省略与二进制直通，配合 msgpack.Encoder.UseCompactEncoding(true) 可进一步减少整数编码字节。

特性	FlatBuffers	MsgPack
零拷贝读取	✅（只读 buffer）	❌（需解包到 struct）
Schema 强一致性	✅（.fbs 编译检查）	❌（运行时反射）
Go 原生 slice/bytes 支持	✅（[]byte 直传）	✅（[]byte 透传）

graph TD A[原始 struct] –>|flatc 编译| B[Schema-aware binary] A –>|msgpack.Marshal| C[Dynamic compact binary] B –> D[零拷贝访问：指针+偏移] C –> E[解包分配：struct 实例]

2.3 连接池与异步批处理：应对千万级QPS的客户端并发模型设计

在千万级QPS场景下，传统每请求一连接模式必然触发内核端口耗尽与上下文切换雪崩。核心破局点在于连接复用与请求聚合。

连接池的分级弹性设计

• 基于响应时间动态伸缩空闲连接（min=50, max=2000）
• 按SLA等级划分物理连接池（P0/P1/P2隔离）
• 连接健康检测采用轻量心跳+熔断器模式

异步批处理流水线

// 批处理缓冲器：固定窗口 + 数量/时间双触发
BatchBuffer<Request> buffer = BatchBuffer.builder()
    .maxSize(128)           // 单批最大请求数
    .maxDelayMs(5)          // 最大容忍延迟（毫秒）
    .executor(vertx.workerPool()) // 非IO线程执行序列化
    .build();

逻辑分析：maxSize=128 平衡吞吐与延迟；maxDelayMs=5 避免小流量下长等待；Worker线程池专用于ProtoBuf序列化，防止EventLoop阻塞。

维度	同步直连	连接池+批处理
连接数	~10M	~2K
P99延迟	42ms	8.3ms
GC压力	高频Young GC	稳定低频

graph TD
    A[客户端请求] --> B{是否满批？}
    B -->|否| C[写入RingBuffer]
    B -->|是| D[异步提交至连接池]
    C --> E[定时器/计数器触发]
    E --> D
    D --> F[Netty Channel WriteAndFlush]

2.4 TLS双向认证与租户级权限透传：企业级向量访问控制落地

在多租户向量数据库场景中，仅靠网络层隔离无法保障租户数据边界。TLS双向认证（mTLS）成为身份锚点，而租户上下文需沿调用链无损透传。

认证与上下文绑定机制

客户端证书的 CN 字段映射租户ID（如 CN=tenant-prod-782），服务端通过 X-Tenant-ID HTTP头或gRPC metadata同步注入策略引擎。

# 向量查询请求中透传租户上下文（Python SDK示例）
from grpc import metadata_call_credentials, composite_channel_credentials

def tenant_auth_creds(tenant_id: str):
    # 将租户标识注入gRPC元数据
    def metadata_plugin(context, callback):
        callback((("x-tenant-id", tenant_id), ("x-auth-method", "mtls")), None)
    return metadata_call_credentials(metadata_plugin)

channel = grpc.secure_channel(
    "vector-db.example.com:443",
    composite_channel_credentials(
        ssl_channel_credentials(),  # TLS根证书
        tenant_auth_creds("tenant-prod-782")  # 租户上下文
    )
)

该代码在建立gRPC连接时，将租户ID与认证方式作为不可篡改的元数据注入。服务端鉴权中间件可据此拦截非法跨租户向量检索请求。

权限策略执行流程

graph TD
    A[客户端mTLS握手] --> B[证书CN提取tenant-id]
    B --> C[注入X-Tenant-ID至请求头]
    C --> D[向量服务网关校验RBAC策略]
    D --> E[动态加载租户专属向量ACL规则]
    E --> F[执行向量相似度查询]

策略维度	示例值	说明
租户ID	tenant-prod-782	从证书CN字段解析
向量库权限	READ_VECTOR_INDEX:prod-customer-embeddings	细粒度索引级授权
操作限制	max_k=100, timeout_ms=3000	防暴力扫描与资源耗尽

2.5 主流向量库（Milvus、Qdrant、Weaviate）Go SDK源码级对比与选型指南

初始化模式差异

Milvus SDK 依赖 client.NewGrpcClient() 显式连接，需传入地址与超时；Qdrant 使用 qdrant.NewClient() 封装 HTTP/gRPC 自动协商；Weaviate 则通过 weaviate.NewClient() 统一管理 REST+gRPC 备用通道。

核心操作抽象层级

库	向量插入接口粒度	错误处理策略
Milvus	Insert(ctx, coll, partition, vectors)	基于 commonpb.ErrorCode 枚举分层判别
Qdrant	upsertPoints(ctx, collection, points)	返回 *qdrant.UpsertResponse + error 双值
Weaviate	batch.Objects().WithObjects(...).Do(ctx)	统一 *models.BatchObjectsResponse + []error

// Qdrant Go SDK 插入示例（v1.9.0）
points := []*qdrant.PointStruct{
  {Id: &qdrant.PointId{Id: &qdrant.PointId_Uint64{Uint64: 1}}, 
   Vector: []float32{0.1, 0.2, 0.3}},
}
_, err := client.UpsertPoints(ctx, "my_col", points) // 参数：ctx（控制生命周期）、collection（必填字符串）、points（非空切片）
// 源码中自动序列化为 Protobuf Payload，并重试幂等写入

第三章：模型服务Proxy的轻量可靠架构

3.1 模型路由与负载均衡：基于OpenAPI Schema的动态Endpoint发现机制

传统硬编码路由难以应对多模型服务的弹性伸缩。本机制从 OpenAPI 3.0 Schema 自动提取 /v1/chat/completions 等路径、请求体结构及 x-model-provider 扩展字段，构建实时服务拓扑。

动态发现流程

# openapi.yaml 片段（含自定义扩展）
paths:
  /v1/chat/completions:
    post:
      x-model-provider: "anthropic"
      x-model-capabilities: ["streaming", "json_schema"]
      requestBody:
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/ChatRequest"

→ 解析器提取 x-model-provider 作为路由标签，x-model-capabilities 决定是否启用流式转发；schema 验证驱动请求预处理。

路由决策表

Provider	Weight	Latency (ms)	Schema-Compliant
openai	60	210	✅
anthropic	40	340	✅

流程图

graph TD
  A[Load OpenAPI Schema] --> B{Parse x-model-* extensions}
  B --> C[Build Endpoint Registry]
  C --> D[Match Request → Model Schema]
  D --> E[Select Instance via Weighted Round-Robin]

3.2 请求熔断与响应缓存：使用go-cache与sentinel-go构建弹性代理层

在高并发网关场景中，单一后端服务故障易引发雪崩。我们结合 go-cache（内存级响应缓存）与 sentinel-go（轻量级熔断器）构建双防护代理层。

缓存策略设计

• 缓存键采用 method:uri:query_hash 结构，避免参数爆炸
• TTL 动态设定：成功响应缓存 60s，5xx 响应降级缓存 5s（兜底可用）

熔断规则配置

指标	阈值	触发条件
错误率	50%	近10秒内5次调用≥3次失败
半开探测窗口	60s	熔断后静默期

// 初始化 Sentinel 规则
flowRule := &flow.Rule{
    ID:          "api_cache_proxy",
    Resource:    "backend_call",
    Threshold:   100.0, // QPS阈值
    Strategy:    flow.Concurrency, // 并发控制
    ControlBehavior: flow.Reject,
}
sentinel.LoadRules([]*flow.Rule{flowRule})

该规则限制后端调用并发数为100，超限请求立即拒绝，避免线程耗尽。Resource 字符串需与 sentinel.Entry 中一致，是熔断统计的逻辑单元。

数据同步机制

缓存与熔断状态均驻留内存，无跨节点同步需求；通过 go-cache 的 onEvicted 回调可触发日志审计或指标上报。

graph TD
A[HTTP Request] --> B{Sentinel Entry}
B -- 允许 --> C[Cache Get]
B -- 拒绝 --> D[Return 429]
C -- Hit --> E[Return Cached Response]
C -- Miss --> F[Call Backend]
F --> G{Success?}
G -- Yes --> H[Cache Set + Update Metrics]
G -- No --> I[Record Error + Trigger Circuit Break]

3.3 模型推理链路追踪：OpenTelemetry Go SDK集成与Span上下文透传实践

在模型服务化场景中，一次推理请求常横跨 HTTP 入口、预处理、模型加载、GPU 推理、后处理及响应组装多个阶段。为精准定位延迟瓶颈，需实现跨 goroutine 与跨组件的 Span 上下文透传。

OpenTelemetry 初始化与全局 Tracer 配置

import (
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
    "go.opentelemetry.io/otel/sdk/trace"
)

func initTracer() {
    exporter, _ := otlptracehttp.New(
        otlptracehttp.WithEndpoint("localhost:4318"),
        otlptracehttp.WithInsecure(), // 测试环境禁用 TLS
    )
    tp := trace.NewTracerProvider(
        trace.WithBatcher(exporter),
        trace.WithResource(resource.MustNewSchemaVersion(
            semconv.SchemaURL,
            semconv.ServiceNameKey.String("llm-inference-api"),
        )),
    )
    otel.SetTracerProvider(tp)
}

该代码初始化 OTLP HTTP 导出器，将 Span 发送至本地 Collector；WithInsecure() 仅用于开发环境；ServiceNameKey 确保服务标识统一，便于 Jaeger/Grafana Tempo 关联检索。

Goroutine 内 Span 透传关键实践

• 使用 otel.GetTextMapPropagator().Inject() 将当前 SpanContext 注入 HTTP Header（如 traceparent）
• 在下游服务通过 otel.GetTextMapPropagator().Extract() 恢复父 Span，构建连续链路
• 对异步任务（如日志采样、指标上报），须显式 span.SpanContext() 并传入新 goroutine

透传方式	适用场景	是否自动继承
context.WithValue	同 goroutine 调用链	否（需手动）
propagator.Extract	HTTP/gRPC 远程调用	是（标准协议）
trace.WithSpanContext	异步 goroutine 启动	否（必须显式）

推理链路 Span 命名规范

graph TD
    A[HTTP Handler] -->|/v1/infer| B[Preprocess Span]
    B --> C[Model Load Span]
    C --> D[Inference Span]
    D --> E[Postprocess Span]
    E --> F[Response Write]

Span 名称应体现语义阶段（如 "inference.gpu.run"），避免泛化命名（如 "process"），确保可观测性可读性。

第四章：Prompt编排引擎的核心能力构建

4.1 DSL设计与解析：基于peggy构建可扩展的Prompt语法树（AST）

Prompt DSL需兼顾人类可读性与机器可解析性。我们选用 Peggy —— 一个现代、可生成 TypeScript 解析器的 PEG（Parsing Expression Grammar）工具。

核心语法规则示例

Prompt = head:Header body:Body { return { type: 'Prompt', header, body }; }
Header = "role:" space* role:([a-z]+) space* "\n" { return role.join(''); }
Body = text:[^\0]* { return text.join(''); }
space = " " / "\t" / "\n"

该规则定义了 role:assistant\nHello! → AST { type: 'Prompt', header: 'assistant', body: 'Hello!' }；space 捕获空白符，确保语法健壮；返回对象结构直接映射为 TypeScript 接口 PromptNode。

AST 节点类型对照表

AST 类型	对应语法片段	用途
Prompt	role:user\n…	根节点，承载角色与内容
Variable	{{input}}	运行时变量插值
Block	{% if cond %}…{% endif %}	条件渲染逻辑

解析流程示意

graph TD
    A[原始 Prompt 字符串] --> B[Peggy 解析器]
    B --> C[Token 流]
    C --> D[递归下降构造]
    D --> E[Typed AST]

4.2 变量注入与上下文管理：结构化Context与JSONPath表达式执行引擎

核心设计目标

• 将动态变量安全注入执行上下文
• 支持嵌套结构的精准路径提取与转换
• 隔离不同任务间的 Context 生命周期

JSONPath 执行引擎示例

const context = { user: { profile: { name: "Alice", roles: ["admin", "editor"] } } };
const result = jsonpath.query(context, "$.user.profile.name"); // → ["Alice"]

jsonpath.query() 接收结构化 Context 对象与标准 JSONPath 表达式；$ 指根节点，. 表示层级访问，返回值为数组以兼容多匹配场景。

Context 生命周期管理

阶段	行为
创建	绑定初始数据与元信息
注入	合并外部变量（如 env、input）
执行	表达式求值时只读访问
销毁	自动释放引用防止内存泄漏

graph TD
    A[ContextBuilder] --> B[Inject Variables]
    B --> C[Validate Schema]
    C --> D[Execute JSONPath]
    D --> E[Return Typed Result]

4.3 多模型协同编排：LLM调用图（DAG）调度器与状态机驱动执行器

多模型协同并非简单链式调用，而是需建模任务依赖、状态跃迁与容错恢复的闭环系统。

DAG调度器：声明式依赖建模

from dagster import graph, op, job

@op
def embed_text(context, text: str) -> dict:
    return {"vector": model_a.encode(text)}  # 调用嵌入模型

@op
def rerank_results(context, query: str, candidates: list) -> list:
    return model_b.rerank(query, candidates)  # 调用重排序模型

@graph
def retrieval_pipeline():
    docs = embed_text()
    return rerank_results(query="user question", candidates=docs)

逻辑分析：@graph 构建有向无环图，embed_text 输出自动注入 rerank_results 输入；context 提供运行时元信息（如重试次数、超时阈值），实现算子级可观测性与生命周期控制。

状态机驱动执行器

状态	触发条件	动作
Pending	任务入队	分配资源、校验输入
Executing	资源就绪	启动模型推理、记录trace ID
Failed	HTTP 503 或超时	触发回退策略或降级模型

graph TD
    A[Pending] -->|资源就绪| B[Executing]
    B -->|成功| C[Completed]
    B -->|失败且可重试| A
    B -->|失败且不可重试| D[Failed]

4.4 安全沙箱与输出约束：正则/Schema级响应校验与LLM输出截断策略

为防止LLM生成越界内容，需在推理后置阶段嵌入双重校验机制：结构化约束（Schema）与模式化过滤（正则）。

响应校验双通道设计

• Schema校验：基于JSON Schema验证字段类型、必填项与枚举范围
• 正则过滤：对文本型字段执行敏感词、URL、代码片段等正则匹配

截断策略实现（Python示例）

import re
from jsonschema import validate, ValidationError

def safe_output_guard(response: str, schema: dict, max_len: int = 256) -> dict:
    # 1. 长度截断（硬边界）
    truncated = response[:max_len]
    # 2. JSON解析 + Schema校验
    try:
        parsed = json.loads(truncated)
        validate(instance=parsed, schema=schema)
        return {"status": "valid", "data": parsed}
    except (json.JSONDecodeError, ValidationError):
        return {"status": "invalid", "reason": "schema_mismatch"}

max_len 控制输出上限，避免长上下文注入；schema 定义字段语义契约，如 {"type": "object", "required": ["answer"], "properties": {"answer": {"type": "string", "maxLength": 128}}}。

校验流程图

graph TD
    A[LLM原始输出] --> B{长度≤max_len?}
    B -->|否| C[截断至max_len]
    B -->|是| D[尝试JSON解析]
    C --> D
    D --> E{符合Schema?}
    E -->|是| F[放行]
    E -->|否| G[拒绝并标记]

第五章：Go语言在AI基建生态中的不可替代性总结

构建高并发模型服务网关的实践验证

在某头部自动驾驶公司的实时感知推理平台中，团队用 Go 重写了原有 Python + Flask 的模型路由网关。新网关基于 gin 和 gRPC-Gateway 构建，支撑 12,000+ QPS 的多模态模型（YOLOv8、PointPillars、BEVFormer）动态调度请求，平均延迟从 47ms 降至 8.3ms。关键在于 Go 的 goroutine 轻量级并发模型与零拷贝内存管理——单节点可稳定维持 26 万活跃长连接，而同等配置下 Node.js 进程在 8 万连接时即触发 V8 堆内存告警。

模型训练任务编排系统的资源隔离能力

Kubeflow Operator 的 Go 实现版本（v1.9+）被广泛集成进金融风控 AI 平台。其核心 TrainingJobController 利用 Go 的 context 取消传播机制与 cgroup 绑定接口，在 GPU 资源紧张时实现毫秒级任务抢占与显存回收。对比 Python 编写的旧版控制器，GPU 利用率提升 39%，且因无 GIL 锁阻塞，支持同时调度 1,400+ 分布式 PyTorch 训练作业，失败重试响应时间稳定在 120ms 内。

混合精度推理引擎的内存安全保障

NVIDIA Triton Inference Server 的核心插件框架强制要求 C/C++ 或 Go 编写 backend。某医疗影像公司采用 Go 编写的 DICOM 预处理 backend（基于 gorgonia 张量操作库），通过 unsafe.Pointer 与 CUDA 流直接交互，避免了 Python ctypes 封装导致的 3~5 层内存拷贝。实测在 A100 上处理 512×512 CT slice，端到端吞吐达 214 fps，且连续运行 72 小时零内存泄漏——得益于 Go 的 runtime GC 与 runtime.SetFinalizer 对 CUDA memory handle 的精准生命周期管理。

维度	Go 实现方案	Python 主流方案	差异说明
启动冷启动耗时	12–18ms（静态链接二进制）	320–850ms（解释器加载）	Go 二进制免依赖，适合 serverless AI 函数
单核 CPU 处理 gRPC 流数	≥18,000（goroutine 调度开销	≤2,100（GIL 串行化瓶颈）	直接影响模型服务横向扩展密度
生产环境 crash 率（30天）	0.0017%（panic recover 全覆盖）	0.23%（未捕获异常/内存溢出）	Go 的显式错误链与 defer 机制降低运维熵值

// Triton backend 中 GPU 显存安全释放的关键片段
func (b *DICOMBackend) finalizeCUDAMemory() {
    if b.cudaStream != nil {
        cuda.StreamDestroy(b.cudaStream) // 同步销毁流
        b.cudaStream = nil
    }
    if b.dInput != nil {
        cuda.Free(b.dInput) // 直接调用 CUDA Driver API
        b.dInput = nil
    }
}

边缘AI设备固件升级通道的确定性保障

在部署于 2,300 台工厂质检边缘盒子（Jetson Orin NX）的 OTA 系统中，Go 编写的 firmware-syncd 守护进程通过 epoll + io_uring（Linux 5.19+）实现零拷贝固件分发。升级包经 blake3 校验后直接 mmap 到 GPU 显存映射区，全程不经过 CPU 内存拷贝。实测 28MB 模型固件在千兆内网中完成全集群同步仅需 4.2 秒，误差标准差

大模型微调数据管道的流式压缩效率

某中文大模型团队将 Hugging Face Datasets 的 streaming=True 流水线替换为 Go 编写的 parquet-go + zstd 流式处理器。对 12TB 的网页文本进行去重、分词、chunking 后写入 Parquet，CPU 利用率峰值仅 62%（Python 版本常达 98%），I/O 等待时间下降 71%。核心在于 Go 的 io.Pipe 与 zstd.Encoder 的无缓冲管道组合，使磁盘写入与压缩计算完全并行，避免了 Python GIL 下的线程阻塞等待。

graph LR
    A[Raw JSONL] --> B{Go Stream Processor}
    B --> C[Tokenizer: jieba-go]
    B --> D[Filter: bloomfilter-go]
    C --> E[Chunker: sliding window]
    D --> E
    E --> F[ZSTD Compressor]
    F --> G[Parquet Writer]
    G --> H[Object Storage]