【云原生Go接口通信标准】：Kubernetes Ingress适配、Service Account鉴权、Workload Identity打通全流程

第一章：Go语言访问Kubernetes API的核心机制

Go语言与Kubernetes生态深度耦合，其官方客户端库 kubernetes/client-go 是访问API的权威实现。该库并非简单封装HTTP请求，而是构建了一套分层抽象体系：底层基于 rest.Config 封装认证、TLS、超时等连接配置；中层通过 RESTClient 提供泛型资源操作能力；上层则以类型安全的 Clientset 暴露各API组（如 CoreV1()、AppsV1()）的结构化接口。

认证与配置初始化

Kubernetes API访问依赖有效的身份凭证。典型场景下，client-go 自动从以下路径按优先级加载配置：

• $HOME/.kube/config（本地开发）
• /var/run/secrets/kubernetes.io/serviceaccount/（集群内Pod）

// 示例：从默认路径加载配置并构建Clientset
config, err := rest.InClusterConfig() // 集群内服务账户方式
if err != nil {
    config, err = clientcmd.BuildConfigFromFlags("", clientcmd.RecommendedHomeFile)
}
if err != nil {
    panic(err)
}
clientset, err := kubernetes.NewForConfig(config) // 初始化Clientset

RESTClient与动态调用

当需操作非标准资源（如CRD）或规避生成代码依赖时，可直接使用 RESTClient：

// 构建针对自定义资源的RESTClient
restClient, err := rest.RESTClientFor(config)
// 执行GET请求获取所有Pods（无需类型定义）
result := &corev1.PodList{}
err = restClient.Get().
    Resource("pods").
    Namespace("default").
    Do(context.TODO()).
    Into(result)

Informer机制与事件驱动同步

client-go 的核心优势在于 Informer —— 它结合List-Watch协议与本地缓存（DeltaFIFO + Reflector + Indexer），实现高效、低延迟的资源状态同步。开发者只需注册事件回调，无需手动轮询：

组件	职责
Reflector	监听API Server变更并入队Delta
DeltaFIFO	存储带操作类型的资源变更快照
Controller	协调处理循环，触发Handler调用
Indexer	提供内存索引查询能力（如按Label）

Informer启动后自动建立长连接Watch，并在断连时触发Re-list，保障数据一致性。

第二章：Ingress资源适配与HTTP路由通信实践

2.1 Ingress API对象模型解析与Client-go封装原理

Ingress 是 Kubernetes 中用于管理外部 HTTP/HTTPS 流量路由的核心资源，其对象模型围绕 rules、tls 和 backend（已弃用）或 ingressClassName 展开。

核心字段语义

• spec.ingressClassName：声明使用的 Ingress 控制器实现（如 nginx、alb）
• spec.rules：按 host + path 匹配请求，每个 rule 可含多个 http.paths
• spec.tls：绑定 Secret 名称以启用 HTTPS 终止

Client-go 封装机制

Kubernetes 官方 client-go 通过 Scheme 注册 networking.k8s.io/v1.Ingress 类型，并提供 IngressInterface 接口统一操作：

// 获取 Ingress 客户端实例
clientset := kubernetes.NewForConfigOrDie(config)
ingressClient := clientset.NetworkingV1().Ingresses("default")

// 创建 Ingress 对象
ing := &networkingv1.Ingress{
    ObjectMeta: metav1.ObjectMeta{Name: "my-ing"},
    Spec: networkingv1.IngressSpec{
        IngressClassName: ptr.To("nginx"),
        Rules: []networkingv1.IngressRule{{
            Host: "example.com",
            IngressRuleValue: networkingv1.IngressRuleValue{
                HTTP: &networkingv1.HTTPIngressRuleValue{
                    Paths: []networkingv1.HTTPIngressPath{{
                        Path:     "/api",
                        PathType: (*networkingv1.PathType)(&networkingv1.PathTypePrefix),
                        Backend: networkingv1.IngressBackend{
                            Service: &networkingv1.IngressServiceBackend{
                                Name: "svc-a",
                                Port: networkingv1.ServiceBackendPort{Number: 80},
                            },
                        },
                    }},
                },
            },
        }},
    },
}
_, err := ingressClient.Create(context.TODO(), ing, metav1.CreateOptions{})

此代码构建一个带路径前缀路由的 Ingress 实例。PathType 必须显式指定（Exact/Prefix/ImplementationSpecific），IngressClassName 替代了旧版 kubernetes.io/ingress.class annotation，体现 v1 API 的声明式演进。

字段	类型	是否必需	说明
ingressClassName	string	否（但推荐）	指定控制器实现，替代 annotation
rules[].host	string	否	空值匹配所有 host
rules[].http.paths[].pathType	PathType	是	v1 强制要求，增强路由语义明确性

graph TD
    A[Ingress YAML] --> B[Scheme.Decode]
    B --> C[Unmarshal into networkingv1.Ingress]
    C --> D[Client-go Validation]
    D --> E[APIServer Admission Webhook]
    E --> F[etcd持久化]

2.2 基于net/http与gorilla/mux构建Ingress-aware反向代理网关

传统反向代理常忽略Kubernetes Ingress语义，而本方案通过gorilla/mux的路径匹配能力与net/http的中间件机制实现Ingress-aware路由。

核心路由策略

• 解析Ingress资源中的host、path、serviceName:servicePort
• 动态注册路由：r.Host(host).Subrouter().PathPrefix(path).Handler(proxy)

代理中间件示例

func ingressAwareProxy(backendURL *url.URL) http.Handler {
    proxy := httputil.NewSingleHostReverseProxy(backendURL)
    proxy.ErrorHandler = func(w http.ResponseWriter, r *http.Request, err error) {
        http.Error(w, "Upstream unreachable", http.StatusBadGateway)
    }
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 注入X-Forwarded-*头，保留原始Ingress上下文
        r.Header.Set("X-Forwarded-Host", r.Host)
        r.Header.Set("X-Forwarded-Path", r.URL.Path)
        proxy.ServeHTTP(w, r)
    })
}

该代码构建带错误处理与上下文透传的代理处理器；httputil.NewSingleHostReverseProxy负责底层转发，ErrorHandler统一失败响应，头部注入确保后端可感知Ingress路由意图。

路由匹配优先级

优先级	匹配维度	示例
1	Host + Path	api.example.com/v1
2	Host only	*.example.com
3	Default backend	兜底服务

graph TD
    A[HTTP Request] --> B{Host Match?}
    B -->|Yes| C{PathPrefix Match?}
    B -->|No| D[Default Backend]
    C -->|Yes| E[Forward to Service]
    C -->|No| D

2.3 动态Ingress规则监听与配置热更新实现（Watch + Informer）

核心机制：Informer 架构优势

Kubernetes Informer 封装了 List-Watch 协议，自动处理连接中断、资源版本（ResourceVersion）同步与本地缓存（DeltaFIFO + Store），避免轮询开销。

数据同步机制

Informer 启动流程：

1. 首次 List() 获取全量 Ingress 资源
2. 建立长连接 Watch()，持续接收 ADDED/UPDATED/DELETED 事件
3. 事件经 SharedIndexInformer 分发至注册的 EventHandler

informer := ingressInformer.Informer()
informer.AddEventHandler(cache.ResourceEventHandlerFuncs{
    AddFunc: func(obj interface{}) {
        ingress := obj.(*networkingv1.Ingress)
        log.Printf("Ingress added: %s/%s", ingress.Namespace, ingress.Name)
        reloadNginxConfig(ingress) // 触发配置热更新
    },
    UpdateFunc: func(old, new interface{}) {
        newIng := new.(*networkingv1.Ingress)
        if !reflect.DeepEqual(old, new) {
            reloadNginxConfig(newIng)
        }
    },
})

逻辑分析：AddFunc 和 UpdateFunc 直接响应集群状态变更；reloadNginxConfig() 执行无中断 reload（如 nginx -s reload），确保路由规则秒级生效。reflect.DeepEqual 避免冗余更新。

关键参数说明

参数	作用	示例值
ResyncPeriod	强制全量同步间隔	5 * time.Minute
ResourceVersion	增量监听起点	"123456"（由 API Server 返回）

graph TD
    A[API Server] -->|Watch Stream| B(Informer Watcher)
    B --> C[DeltaFIFO Queue]
    C --> D[Controller Loop]
    D --> E[Local Cache Store]
    D --> F[EventHandler]
    F --> G[Reload Nginx Config]

2.4 TLS终止、路径重写与Header透传的Go端协议层处理

在反向代理场景中，Go 的 net/http 服务常需在 TLS 终止后精准还原原始请求语义。

TLS终止后的上下文重建

使用 http.Request.TLS != nil 判断是否已终止 TLS，并通过 X-Forwarded-Proto: https 显式声明协议：

func wrapTLSHandler(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.TLS != nil {
            r.Header.Set("X-Forwarded-Proto", "https") // 告知后端已终止TLS
        }
        next.ServeHTTP(w, r)
    })
}

逻辑说明：r.TLS 非空即表示 Go 服务直连客户端（非透传），此时必须注入 X-Forwarded-* 头，避免后端误判协议/主机。

路径重写与Header透传策略

行为	实现方式	安全约束
路径前缀裁剪	r.URL.Path = strings.TrimPrefix(r.URL.Path, "/api/v1")	需校验路径合法性
Header透传	白名单过滤 X-User-ID, X-Request-ID	禁止透传 Authorization 等敏感头

请求流转示意

graph TD
    A[Client HTTPS] --> B[Go Server TLS Termination]
    B --> C[Set X-Forwarded-* Headers]
    C --> D[Path Rewrite e.g. /api/v1/user → /user]
    D --> E[Forward to Backend HTTP]

2.5 多集群Ingress状态聚合与健康检查服务开发

核心架构设计

采用“采集-转换-聚合-告警”四层流水线，各集群独立上报 Ingress 状态（ingress.status.loadBalancer.ingress[]），中心服务统一收敛并生成全局视图。

数据同步机制

• 基于 Kubernetes Informer 监听多集群 Ingress 和 EndpointSlice 资源变更
• 使用 ClusterID + Namespace/Name 作为联合主键去重
• 状态快照每30秒持久化至 etcd，支持断网续传

健康检查策略

// HealthChecker 每15s并发探测各Ingress后端Service的/healthz端点
func (h *HealthChecker) Probe(ing *networkingv1.Ingress) map[string]bool {
    results := make(map[string]bool)
    for _, rule := range ing.Spec.Rules {
        for _, path := range rule.HTTP.Paths {
            endpoint := fmt.Sprintf("http://%s/healthz", 
                getBackendHost(path.Backend.Service.Name, ing.Namespace))
            results[endpoint] = httpGetWithTimeout(endpoint, 3*time.Second)
        }
    }
    return results
}

逻辑说明：getBackendHost() 从 Service EndpointSlice 解析可用 Pod IP；超时设为3s避免阻塞；返回结果以 endpoint 为键，布尔值标识连通性。参数 ing 为跨集群标准化后的 Ingress 对象（已注入 clusterID annotation）。

状态聚合视图（示例）

ClusterID	Ingress	BackendService	HealthyPods	LastSync
prod-us	api-ingress	api-svc	4/4	2024-06-12T08:32:11Z
prod-cn	api-ingress	api-svc	2/4	2024-06-12T08:31:55Z

graph TD
    A[多集群Ingress Informer] --> B[状态标准化]
    B --> C[etcd快照存储]
    C --> D[健康检查协程池]
    D --> E[聚合Dashboard/API]

第三章：Service Account鉴权体系深度集成

3.1 SA Token自动挂载机制与JWT签名验签的Go实现

自动挂载核心逻辑

ServiceAccount（SA） Token由Kubernetes自动注入Pod的 /var/run/secrets/kubernetes.io/serviceaccount/ 目录下，包含 token、ca.crt 和 namespace 三文件。Go客户端通过 rest.InClusterConfig() 自动读取并构造认证配置。

JWT解析与验签实现

func VerifySAToken(tokenStr, caPath string) (jwt.MapClaims, error) {
    certPEM, _ := os.ReadFile(caPath)
    pool := x509.NewCertPool()
    pool.AppendCertsFromPEM(certPEM)

    token, _ := jwt.Parse(tokenStr, func(t *jwt.Token) (interface{}, error) {
        return jwt.ParseRSAPublicKeyFromPEM(certPEM) // 使用CA公钥验签
    })
    return token.Claims.(jwt.MapClaims), nil
}

逻辑说明：ParseRSAPublicKeyFromPEM 将CA证书转为RSA公钥；jwt.Parse 执行签名验证与标准声明（exp, iat, iss）校验；MapClaims 提供对 aud, sub 等字段的安全访问。

验签关键参数对照表

参数	来源	作用
tokenStr	/var/run/secrets/.../token	Base64编码的JWT字符串
caPath	/var/run/secrets/.../ca.crt	Kubernetes API Server签名证书
iss claim	固定为 https://kubernetes.default.svc.cluster.local	防止令牌被其他issuer冒用

graph TD
    A[Pod启动] --> B[Mount SA Token Volume]
    B --> C[Go调用 rest.InClusterConfig]
    C --> D[自动读取 token + ca.crt]
    D --> E[JWT Parse + RSA验签]
    E --> F[验证 exp/iss/aud 合法性]

3.2 RBAC策略映射到Go客户端权限校验的运行时建模

RBAC策略在Kubernetes中以ClusterRoleBinding/RoleBinding声明，而Go客户端需在运行时将其转化为可执行的权限判定逻辑。

权限校验核心结构

type PermissionChecker struct {
    rules   []rbacv1.PolicyRule // 从Role/ClusterRole解析出的规则集合
    namespace string            // 当前操作命名空间（用于Role作用域判断）
}

rules字段缓存策略中所有PolicyRule，避免每次校验重复解析；namespace决定是否启用Role级作用域过滤。

规则匹配逻辑流程

graph TD
    A[收到API请求] --> B{是否含namespace?}
    B -->|是| C[筛选Role绑定+匹配ns]
    B -->|否| D[仅匹配ClusterRole]
    C & D --> E[遍历PolicyRule匹配apiGroups/verbs/resources]
    E --> F[返回allow/deny]

匹配关键字段对照表

字段	PolicyRule字段	说明
资源类型	Resources	如 pods, secrets
操作动词	Verbs	get, list, create
API组	APIGroups	"", apps, batch

校验时需同时满足三者交集，任一不匹配即拒绝。

3.3 面向多租户场景的SA Token轮换与短期凭证安全分发

在多租户Kubernetes集群中，ServiceAccount（SA）Token长期有效易引发横向越权风险。需结合TokenRequest API实现自动轮换与限定生命周期的短期凭证分发。

短期Token请求示例

# 请求一个有效期20分钟、绑定特定audience的临时Token
apiVersion: authentication.k8s.io/v1
kind: TokenRequest
spec:
  audience: "https://my-tenant-api.example.com"
  expirationSeconds: 1200  # 必须 ≤ service-account-extend-token-max-expiration

该请求由kube-apiserver签名并返回JWT，不含私钥，且aud和exp由服务端强校验，避免租户间凭证复用。

安全分发机制要点

• ✅ 所有Token通过/api/v1/namespaces/{ns}/serviceaccounts/{sa}/token动态签发
• ✅ 每次请求生成唯一jti声明，支持服务端吊销追踪
• ❌ 禁止挂载默认/var/run/secrets/kubernetes.io/serviceaccount/token

租户隔离能力对比

能力	默认SA Token	TokenRequest短期Token
有效期可配置	否（永久）	是（最小1s，最大1h）
Audience绑定	不支持	支持多租户API域隔离
吊销粒度	Namespace级	单Token级（jti+审计日志）

graph TD
  A[租户应用发起TokenRequest] --> B{kube-apiserver校验RBAC<br/>及aud/expiration策略}
  B --> C[签发含jti/exp/aud的JWT]
  C --> D[应用注入Pod容器环境]
  D --> E[调用租户专属后端API]

第四章：Workload Identity跨云身份打通工程实践

4.1 GCP Workload Identity Federation协议在Go中的OIDC Client实现

Workload Identity Federation 允许外部身份提供商（如 GitHub、Azure AD）通过 OIDC 断言直接获取 GCP 访问令牌，无需长期密钥。

核心流程概览

graph TD
    A[External IDP] -->|OIDC ID Token| B(Go OIDC Client)
    B -->|Federated Token| C[GCP STS Exchange]
    C -->|Access Token| D[GCP API Calls]

Go 客户端关键步骤

• 构建 stscredentials.Config，指定 tokenUrl 为 https://sts.googleapis.com/v1/token
• 使用 id_token 作为 subject_token，urn:ietf:params:oauth:token-type:jwt 为 subject_token_type
• 设置 audience 为 GCP 工作负载池标识符（如 //iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/PROVIDER_ID）

示例交换代码

cfg := &stscreds.Config{
    TokenURL:         "https://sts.googleapis.com/v1/token",
    SubjectToken:     idToken, // 来自 GitHub Actions 或其他 OIDC IDP
    SubjectTokenType: "urn:ietf:params:oauth:token-type:id_token",
    Audience:         "projects/123456789/regions/global/workloadIdentityPools/my-pool/providers/github",
    Scope:            []string{"https://www.googleapis.com/auth/cloud-platform"},
}
creds := stscreds.NewCredentials(ctx, cfg)

该配置驱动 STS 服务验证外部 ID Token 并颁发短期 GCP 访问令牌；SubjectTokenType 必须精确匹配 OIDC 规范，Audience 需与 GCP 控制台中配置的 Workload Identity Pool Provider 完全一致。

4.2 AWS IRSA与Azure AD Pod Identity的Go SDK适配层抽象

为统一云原生身份认证接入，需抽象出跨平台凭证获取接口：

type IdentityProvider interface {
    GetToken(ctx context.Context, audience string) (string, error)
}

该接口屏蔽底层差异：AWS IRSA 通过 sts:GetCallerIdentity 签发 OIDC token，Azure AD Pod Identity 则调用 http://169.254.169.254/metadata/identity/oauth2/token。

核心适配策略

• 实现 AWSIRSAProvider：读取 /var/run/secrets/eks.amazonaws.com/serviceaccount/token
• 实现 AzureADPodIdentityProvider：向 IMDS 端点发起带 resource 参数的 GET 请求

能力对比表

特性	AWS IRSA	Azure AD Pod Identity
Token 位置	文件挂载（JWT）	HTTP Metadata Service
Audience 参数语义	aud 值为 STS endpoint	resource 即目标服务 URI
Go SDK 依赖	github.com/aws/aws-sdk-go-v2	github.com/Azure/go-autorest

graph TD
    A[IdentityProvider.GetToken] --> B{Cloud Provider}
    B -->|AWS| C[Read file + STS AssumeRoleWithWebIdentity]
    B -->|Azure| D[HTTP GET to IMDS with resource param]

4.3 统一身份上下文（Identity Context）在HTTP Transport层的注入与传播

统一身份上下文需在请求发起时注入，并透传至下游服务，避免重复鉴权与上下文丢失。

注入时机与载体

• 在客户端 SDK 的 HTTP 拦截器中注入
• 使用标准 Authorization 头（Bearer Token）或自定义头 X-Identity-Context
• 优先复用 Authorization 以兼容现有网关策略

透传保障机制

// OkHttp Interceptor 示例
public Response intercept(Chain chain) throws IOException {
  Request original = chain.request();
  Request.Builder builder = original.newBuilder()
      .header("X-Identity-Context", 
          IdentityContext.current().serialize()); // 序列化为紧凑JSON
  return chain.proceed(builder.build());
}

逻辑分析：IdentityContext.current() 从 ThreadLocal 获取当前调用链身份快照；serialize() 输出无空格、Base64-safe 的紧凑 JSON 字符串，确保 HTTP 头兼容性与低开销。

上下文传播路径

graph TD
  A[Client SDK] -->|X-Identity-Context| B[API Gateway]
  B -->|Pass-through| C[Service A]
  C -->|Forwarded| D[Service B]

字段名	类型	说明
sub	string	主体ID（如 user:123 或 service:auth-svc）
iss	string	签发方（如 “iam.example.com”）
exp	number	Unix 时间戳，强制时效控制

4.4 跨云K8s集群间Service Account联邦认证链路端到端验证

为实现跨云环境（如 AWS EKS 与 Azure AKS）间 ServiceAccount 的可信互认，需构建基于 OIDC Discovery + JWKS 联邦的信任链。

认证流程概览

graph TD
  A[Client Pod SA Token] --> B[向远程集群APIServer发起请求]
  B --> C{APIServer校验issuer/audience}
  C -->|匹配联邦Issuer| D[向OIDC Provider获取JWKS]
  D --> E[验证JWT签名并解析subject]
  E --> F[映射为本地User/Group绑定RBAC]

关键配置验证点

• 远程集群 APIServer 启用 --oidc-issuer-url 且与本地 SA token 中 iss 字段严格一致
• JWKS 端点需支持 TLS 并公开可访问（如 https://eks-oidc.us-west-2.amazonaws.com/idp/.../jwks）
• --oidc-client-id 必须设为 kubernetes（K8s 默认 audience）

Token 解析示例

# 解析 SA token payload（经 base64url 解码后）
jq -r '.iss, .aud, .sub' /var/run/secrets/kubernetes.io/serviceaccount/token
# 输出应为：
# https://oidc.aks.example.com
# ["kubernetes"]
# system:serviceaccount:prod:crosscloud-sync

该输出验证 issuer、audience 与 subject 均符合联邦策略要求，是链路打通的必要前提。

第五章：云原生Go接口通信标准演进与最佳实践总结

接口契约从硬编码到OpenAPI 3.1的渐进迁移

某金融级微服务集群在2022年完成核心支付网关重构，将原有基于http.HandlerFunc硬编码路径+JSON结构校验的方式，升级为基于oapi-codegen自动生成Go服务骨架与客户端SDK。关键转变在于：接口定义文件（payment.yaml）成为唯一可信源，CI流水线中强制执行openapi-diff比对，阻断向后不兼容变更。迁移后接口误用率下降76%，前端联调周期从平均3.2天压缩至4小时。

gRPC-Web与REST/JSON双协议共存的生产实践

Kubernetes Operator管理平台采用gRPC作为内部控制面通信协议（OperatorService/Reconcile），同时通过Envoy代理暴露gRPC-Web端点供前端调试控制台调用。以下为真实部署配置片段：

# envoy.yaml 片段
http_filters:
- name: envoy.filters.http.grpc_web
- name: envoy.filters.http.cors

该设计避免了前端直接依赖gRPC-Web JS库的版本碎片化问题，且通过grpc-gateway生成的Swagger UI实现文档与测试一体化。

错误语义标准化：从HTTP状态码泛滥到gRPC Status Code映射表

下表为某电商中台统一错误处理规范的核心映射关系：

HTTP Status	gRPC Code	Go Error Type	触发场景示例
400	InvalidArgument	ErrInvalidOrderID	订单ID格式非法（非UUID）
409	Aborted	ErrInventoryConflict	库存扣减时CAS版本号不匹配
503	Unavailable	ErrDownstreamTimeout	调用风控服务超时（设置3s熔断阈值）

上下文传播的链路完整性保障

在跨AZ部署的订单履约系统中，所有Go服务强制注入traceparent与x-request-id，并通过context.WithValue()传递tenant_id和user_role。实测数据显示：当启用go.opentelemetry.io/otel/sdk/trace采样率为0.1%时，Jaeger中完整12跳链路追踪成功率稳定在99.98%，较旧版Zipkin方案提升23个百分点。

客户端重试策略的精细化分级

根据接口SLA要求实施三级重试机制：

• 强一致性接口（如账户余额查询）：禁用重试，超时即报错
• 最终一致性接口（如物流状态同步）：指数退避重试（100ms→300ms→900ms），最大3次
• 幂等写入接口（如订单创建）：固定间隔重试（500ms×5次），配合idempotency-key头防重放

生产环境流量染色验证流程

每日凌晨2点自动触发灰度验证：向/healthz?probe=canary端点注入X-Canary: true头，路由至新版本实例；采集5分钟内gRPC指标（grpc_client_handled_total{code="OK"}）与延迟P95对比，偏差>15%则触发自动回滚。该机制已在27次版本发布中拦截6次潜在性能退化。

协议缓冲区大小的内存安全边界

在日志聚合服务中，将gRPC默认MaxRecvMsgSize从4MB调整为1.5MB，并配合google.golang.org/grpc/keepalive心跳保活（Time: 30s, Timeout: 5s）。压测显示：单节点内存泄漏率从0.8MB/h降至0.02MB/h，GC pause时间减少41%。

OpenTelemetry Collector配置的生产就绪模板

# otel-collector-config.yaml
receivers:
  otlp:
    protocols:
      grpc:
        endpoint: "0.0.0.0:4317"
        max_recv_msg_size_mib: 16
exporters:
  logging:
    loglevel: debug
  prometheus:
    endpoint: "0.0.0.0:8889"
service:
  pipelines:
    traces:
      receivers: [otlp]
      exporters: [logging, prometheus]