Alauda Distributed Tracing
  • 简体中文

    • 安装 Alauda Distributed Tracing

    安装 Alauda Distributed Tracing 平台涉及以下步骤：

    1. 安装 Alauda Build of OpenTelemetry v2 Operator
    2. 安装 Alauda Build of Jaeger v2
    3. 部署 OpenTelemetry Collector，将 traces 转发到 Jaeger

    目录

    安装 Alauda Build of OpenTelemetry v2 Operator通过 Web 控制台安装通过 CLI 安装安装 Alauda Build of Jaeger v2部署 OpenTelemetry Collector验证（可选）启用 Service Performance Monitoring (SPM)

    安装 Alauda Build of OpenTelemetry v2 Operator

    Alauda Build of OpenTelemetry v2 Operator 负责管理 Jaeger v2 和 OpenTelemetry Collector 实例的生命周期。在部署任何 tracing 组件之前，必须先安装此 Operator。

    通过 Web 控制台安装

    请按照 Alauda Build of OpenTelemetry v2 文档中的 通过 Web 控制台安装 部分中的说明进行操作。

    通过 CLI 安装

    请按照 Alauda Build of OpenTelemetry v2 文档中的 通过 CLI 安装 部分中的说明进行操作。

    安装 Alauda Build of Jaeger v2

    Jaeger v2 作为由 Alauda Build of OpenTelemetry v2 Operator 管理的 OpenTelemetryCollector 自定义资源进行部署。它使用 Elasticsearch 作为后端存储，并通过 OAuth2 Proxy sidecar 与 Alauda Container Platform 认证系统集成。

    先决条件

    • 已安装 Alauda Build of OpenTelemetry v2 Operator。
    • 已有可用的 Elasticsearch 实例，并且你拥有其 endpoint URL、用户名和密码。
    • 由具有 cluster-admin 角色的集群管理员登录的活跃 ACP CLI (kubectl) 会话。
    • 已安装 jq 命令行工具。

    操作步骤

    1. 设置用于连接 Elasticsearch 的可配置环境变量：

      export ES_ENDPOINT='<Elasticsearch endpoint URL>'
export ES_USER='<Elasticsearch username>'
export ES_PASS='<Elasticsearch password>'

      请将占位符值替换为你的实际 Elasticsearch 凭据。

    2. 从集群中获取平台配置和与 Jaeger 相关的容器镜像：

      export PLATFORM_URL=$(kubectl -nkube-public get configmap global-info -o jsonpath='{.data.platformURL}')
export CLUSTER_NAME=$(kubectl -nkube-public get configmap global-info -o jsonpath='{.data.clusterName}')
export ALB_CLASS_NAME=$(kubectl -nkube-public get configmap global-info -o jsonpath='{.data.systemAlbIngressClassName}')

export OIDC_ISSUER=$(kubectl -nkube-public get configmap global-info -o jsonpath='{.data.oidcIssuer}')
OIDC_CLIENT_SECRET_REF=$(kubectl -nkube-public get configmap global-info -o jsonpath='{.data.oidcClientSecretRef}')
if [ -n "$OIDC_CLIENT_SECRET_REF" ]; then
  SYSTEM_NAMESPACE=$(kubectl -nkube-public get configmap global-info -o jsonpath='{.data.systemNamespace}')
  export OIDC_CLIENT_ID=$(kubectl -n"$SYSTEM_NAMESPACE" get secret "$OIDC_CLIENT_SECRET_REF" -o go-template='{{index .data "client-id"}}' | base64 -d)
  export OIDC_CLIENT_SECRET=$(kubectl -n"$SYSTEM_NAMESPACE" get secret "$OIDC_CLIENT_SECRET_REF" -o go-template='{{index .data "client-secret"}}' | base64 -d)
else
  export OIDC_CLIENT_ID=$(kubectl -nkube-public get configmap global-info -o jsonpath='{.data.oidcClientID}')
  export OIDC_CLIENT_SECRET=$(kubectl -nkube-public get configmap global-info -o jsonpath='{.data.oidcClientSecret}')
fi

JAEGER_RELATED_IMAGES=$(kubectl get csv -n opentelemetry-operator2 \
  -l 'operators.coreos.com/opentelemetry-operator2.opentelemetry-operator2=' \
  -o jsonpath='{.items[0].spec.relatedImages}')
export JAEGER_IMAGE=$(echo "$JAEGER_RELATED_IMAGES" | jq -r '.[] | select(.name=="component.jaeger") | .image')
export JAEGER_ES_ROLLOVER_IMAGE=$(echo "$JAEGER_RELATED_IMAGES" | jq -r '.[] | select(.name=="component.jaeger-es-rollover") | .image')
export JOAUTH2_PROXY_IMAGE=$(echo "$JAEGER_RELATED_IMAGES" | jq -r '.[] | select(.name=="component.oauth2-proxy") | .image')
      NOTE

      请确认命令执行完成且没有错误。

    3. 设置默认环境变量。你可以根据部署需求调整这些值：

      # Namespace for the Jaeger instance
export JAEGER_NS="jaeger-system"
# Name of the Jaeger instance
export JAEGER_INSTANCE_NAME="jaeger"
# Elasticsearch index prefix for Jaeger data
export JAEGER_ES_INDEX_PREFIX="acp-${CLUSTER_NAME}"
# Base path for the Jaeger UI
export JAEGER_BASEPATH="/clusters/${CLUSTER_NAME}/jaeger"

    4. 创建 Jaeger Namespace 和 Elasticsearch 凭据 Secret：

      kubectl create namespace ${JAEGER_NS}

kubectl create secret generic es-credentials \
  --namespace=${JAEGER_NS} \
  --from-literal=ES_USER=${ES_USER} \
  --from-literal=ES_PASS=${ES_PASS}

      验证 Secret 是否已创建：

      kubectl get secret es-credentials -n ${JAEGER_NS}

    5. 在 Elasticsearch 中创建 ILM (Index Lifecycle Management) 策略。Jaeger 使用 ILM 来管理 index rollover 和保留：

      curl -k -u "${ES_USER}:${ES_PASS}" -X PUT \
  "${ES_ENDPOINT}/_ilm/policy/jaeger-ilm-policy" \
  -H 'Content-Type: application/json' \
  --data-binary @- << 'EOF'
{
  "policy": {
    "phases": {
      "hot": {
        "min_age": "0ms",
        "actions": {
          "rollover": {
            "max_primary_shard_size": "50gb",
            "max_age": "1d"
          },
          "set_priority": {
            "priority": 100
          }
        }
      },
      "delete": {
        "min_age": "7d",
        "actions": {
          "delete": {}
        }
      }
    }
  }
}
EOF

      关键字段：

      • policy.phases.hot.actions.rollover.max_primary_shard_size：单个 primary shard 的最大大小。当 shard 超过此大小时，将触发 rollover 并创建新的 index。默认值：50gb。
      • policy.phases.hot.actions.rollover.max_age：触发 rollover 之前 index 的最大存在时间。默认值：1d（1 天）。
      • policy.phases.delete.min_age：在 rollover 后删除旧 index 之前等待的时间。默认值：7d（7 天）。

      验证 ILM 策略：

      curl -k -u "${ES_USER}:${ES_PASS}" "${ES_ENDPOINT}/_ilm/policy/jaeger-ilm-policy?pretty"

      输出应显示 ILM 策略的详细信息，包括 hot 和 delete 阶段。

    6. 使用 jaeger-es-rollover 工具 初始化 index alias 和 template。此操作将为 Jaeger 数据存储准备 Elasticsearch：

      kubectl apply -n ${JAEGER_NS} -f - <<EOF
apiVersion: batch/v1
kind: Job
metadata:
  name: jaeger-es-rollover-init
spec:
  template:
    spec:
      containers:
      - name: es-rollover-init
        image: "${JAEGER_ES_ROLLOVER_IMAGE}"
        args:
          - init
          - "${ES_ENDPOINT}"
        env:
        - name: INDEX_PREFIX
          value: "${JAEGER_ES_INDEX_PREFIX}"
        - name: ES_USE_ILM
          value: "true"
        - name: ES_TLS_ENABLED
          value: "true"
        - name: ES_TLS_SKIP_HOST_VERIFY
          value: "true"
        - name: ES_USERNAME
          valueFrom:
            secretKeyRef:
              name: es-credentials
              key: ES_USER
        - name: ES_PASSWORD
          valueFrom:
            secretKeyRef:
              name: es-credentials
              key: ES_PASS
      restartPolicy: Never
  backoffLimit: 3
EOF

      等待 Job 完成，然后验证已创建 index template 和 alias：

      kubectl wait --for=condition=complete job/jaeger-es-rollover-init \
  -n ${JAEGER_NS} --timeout=120s

# Verify index templates
curl -k -sS -u "${ES_USER}:${ES_PASS}" "${ES_ENDPOINT}/_index_template?pretty" \
  | grep ${JAEGER_ES_INDEX_PREFIX}-jaeger-

# Verify index aliases
curl -k -sS -u "${ES_USER}:${ES_PASS}" "${ES_ENDPOINT}/_alias?pretty" \
  | grep ${JAEGER_ES_INDEX_PREFIX}-jaeger-

      期望结果如下：

      • Job 状态为 Complete。
      • Elasticsearch 中存在与 ${JAEGER_ES_INDEX_PREFIX}-jaeger-* 匹配的 index template。
      • Elasticsearch 中存在 ${JAEGER_ES_INDEX_PREFIX}-jaeger-*-read 和 ${JAEGER_ES_INDEX_PREFIX}-jaeger-*-write 的 index alias。

    7. Job 完成后清理初始化 Job：

      kubectl delete job jaeger-es-rollover-init -n ${JAEGER_NS}

    8. 创建 OAuth2 Proxy 的 Secret，该组件用于将 Jaeger UI 与 Alauda Container Platform 认证集成：

      # Generate a cookie secret for the OAuth2 Proxy:
OAUTH2_PROXY_COOKIE_SECRET=$(dd if=/dev/urandom bs=32 count=1 2>/dev/null | base64 | tr -d -- '\n' | tr -- '+/' '-_')
# Create the Secret:
kubectl create secret generic ${JAEGER_INSTANCE_NAME}-oauth2-proxy \
  --namespace=${JAEGER_NS} \
  --from-literal=OAUTH2_PROXY_CLIENT_SECRET=${OIDC_CLIENT_SECRET} \
  --from-literal=OAUTH2_PROXY_COOKIE_SECRET=${OAUTH2_PROXY_COOKIE_SECRET}

    9. 创建一个名为 jaeger.yaml 的文件，内容如下：

      jaeger.yaml
      apiVersion: opentelemetry.io/v1beta1
kind: OpenTelemetryCollector
metadata:
  labels:
    prometheus: kube-prometheus
  name: ${JAEGER_INSTANCE_NAME}
  namespace: ${JAEGER_NS}
spec:
  image: "${JAEGER_IMAGE}"
  mode: deployment
  replicas: 1

  resources:
    requests:
      cpu: 100m
      memory: 256Mi
    limits:
      cpu: "2"
      memory: 2Gi

  ports:
    - name: oauth2-proxy
      port: 4180
    - name: jaeger-grpc
      port: 16685

  observability:
    metrics:
      enableMetrics: true

  volumes:
    - name: es-credentials
      secret:
        secretName: es-credentials
        items:
          - key: ES_PASS
            path: pass
    - name: oauth2-proxy-secrets
      secret:
        secretName: ${JAEGER_INSTANCE_NAME}-oauth2-proxy
        items:
          - key: OAUTH2_PROXY_CLIENT_SECRET
            path: client-secret
          - key: OAUTH2_PROXY_COOKIE_SECRET
            path: cookie-secret
  volumeMounts:
    - name: es-credentials
      mountPath: /etc/jaeger/es-credentials
      readOnly: true

  config:
    receivers:
      otlp:
        protocols:
          grpc:
            endpoint: "0.0.0.0:4317"
          http:
            endpoint: "0.0.0.0:4318"

    processors:
      batch: {}
      memory_limiter:
        check_interval: 1s
        limit_percentage: 80
        spike_limit_percentage: 20

    exporters:
      debug: {}
      jaeger_storage_exporter:
        trace_storage: es_storage

    extensions:
      healthcheckv2:
        use_v2: true
        http:
          endpoint: "0.0.0.0:13133"

      jaeger_storage:
        backends:
          es_storage:
            elasticsearch:
              server_urls:
                - "${ES_ENDPOINT}"
              auth:
                basic:
                  username: "${ES_USER}"
                  password_file: /etc/jaeger/es-credentials/pass
              tls:
                insecure_skip_verify: true
              use_aliases: true
              use_ilm: true
              service_cache_ttl: 12h
              create_mappings: false
              indices:
                index_prefix: "${JAEGER_ES_INDEX_PREFIX}"
                spans:
                  shards: 5
                  replicas: 1
                services:
                  shards: 5
                  replicas: 1
                dependencies:
                  shards: 5
                  replicas: 1
                sampling:
                  shards: 5
                  replicas: 1

      jaeger_query:
        storage:
          traces: es_storage
        ui:
          config_file: ""
        base_path: "${JAEGER_BASEPATH}"
        http:
          endpoint: 0.0.0.0:16686

    service:
      extensions: [healthcheckv2, jaeger_storage, jaeger_query]
      pipelines:
        traces:
          receivers: [otlp]
          processors: [memory_limiter, batch]
          exporters: [debug, jaeger_storage_exporter]
      telemetry:
        resource:
          service.name: jaeger
        metrics:
          level: detailed
          readers:
            - pull:
                exporter:
                  prometheus:
                    host: "0.0.0.0"
                    port: 8888
                    without_scope_info: true
                    without_type_suffix: true
                    without_units: true
        logs:
          level: info

  additionalContainers:
    - name: oauth2-proxy
      image: ${JOAUTH2_PROXY_IMAGE}
      args:
        - --http-address=0.0.0.0:4180
        - --upstream=http://127.0.0.1:16686
        - --proxy-prefix=${JAEGER_BASEPATH}/oauth2
        - --redirect-url=${PLATFORM_URL}${JAEGER_BASEPATH}/oauth2/callback
        - --provider=oidc
        - --oidc-issuer-url=${OIDC_ISSUER}
        - --scope=openid profile email groups ext
        - --email-domain=*
        - --code-challenge-method=S256
        - --insecure-oidc-allow-unverified-email=true
        - --cookie-secure=false
        - --skip-provider-button=true
        - --ssl-insecure-skip-verify=true
        - --skip-jwt-bearer-tokens=true
        - --client-id=${OIDC_CLIENT_ID}
        - --client-secret-file=/etc/oauth2-proxy/client-secret
        - --cookie-secret-file=/etc/oauth2-proxy/cookie-secret
      resources:
        requests:
          cpu: 50m
          memory: 64Mi
        limits:
          cpu: 500m
          memory: 256Mi
      volumeMounts:
        - name: oauth2-proxy-secrets
          mountPath: /etc/oauth2-proxy
          readOnly: true
      ports:
        - containerPort: 4180
          name: oauth2-proxy
          protocol: TCP
      1. prometheus: kube-prometheus 标签会被自动创建的 ServiceMonitor 资源继承，从而使 ACP Prometheus 可以抓取 Jaeger 指标。
      2. Jaeger v2 容器镜像。这不是默认的 OpenTelemetry Collector 镜像；它是基于 OpenTelemetry Collector 框架构建的自定义 Jaeger 二进制文件。
      3. 为 Jaeger 实例启用 Prometheus 指标端点。
      4. Jaeger 容器的资源请求和限制。请根据预期的 trace 流量进行调整；吞吐量较高的环境可能需要更多 CPU 和内存。
      5. jaeger_storage 扩展为存储 trace 数据配置了 Elasticsearch backend。
      6. service_cache_ttl 控制 service name 缓存的保留时间。默认值为 12h。如果 ILM 的 hot 到 delete 间隔较短，请减小此值，以确保 Jaeger UI 能及时发现 services。
      7. 在使用 ILM 模式时，create_mappings 必须设置为 false，因为 index mapping 由 rollover 初始化过程进行管理。
      8. index_prefix 必须与第 6 步中 jaeger-es-rollover 初始化时使用的前缀一致。有关 shards 和 replicas 调优的更多详情，请参见 Shards and Replicas。
      9. jaeger_query 扩展提供 Jaeger Query API 和 Jaeger UI。
      10. additionalContainers 部分定义了 OAuth2 Proxy sidecar，它通过与 Alauda Container Platform Dex identity provider 集成来处理 Jaeger UI 的认证。
      11. OAuth2 Proxy sidecar 的资源请求和限制。由于该容器仅用于代理认证请求，因此资源需求较低。

    10. 使用 envsubst 渲染 manifest 并应用配置：

      envsubst < jaeger.yaml | kubectl apply -f -

    11. 等待 Jaeger Pod 就绪：

      kubectl rollout status deployment/${JAEGER_INSTANCE_NAME}-collector \
  -n ${JAEGER_NS} --timeout=180s

    12. 为 Namespace 添加标签并创建 Ingress，以暴露 Jaeger UI：

      kubectl label namespace ${JAEGER_NS} cpaas.io/project=cpaas-system --overwrite
      kubectl apply -n ${JAEGER_NS} -f - <<EOF
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ${JAEGER_INSTANCE_NAME}
  annotations:
    nginx.ingress.kubernetes.io/enable-cors: "true"
spec:
  ingressClassName: ${ALB_CLASS_NAME}
  rules:
    - http:
        paths:
          - path: ${JAEGER_BASEPATH}
            pathType: ImplementationSpecific
            backend:
              service:
                name: ${JAEGER_INSTANCE_NAME}-collector
                port:
                  number: 4180
EOF

      等待 Ingress 就绪：

      kubectl wait --for=jsonpath='{.status.loadBalancer.ingress}' ingress/${JAEGER_INSTANCE_NAME} \
  -n ${JAEGER_NS} --timeout=180s

    验证

    访问位于 <platform-url>/clusters/<cluster-name>/jaeger 的 Jaeger UI，其中 <platform-url> 是 Alauda Container Platform 的 URL，<cluster-name> 是你的集群名称。

    运行以下命令以打印 Jaeger UI URL：

    echo "Jaeger UI: ${PLATFORM_URL}${JAEGER_BASEPATH}"

    部署 OpenTelemetry Collector

    在 Jaeger v2 运行后，部署一个 OpenTelemetry Collector 实例，用于接收启用了 tracing 的应用发送的 trace 数据，并将其转发到 Jaeger。

    1. 创建一个 OpenTelemetryCollector 资源：

      kubectl apply -f - <<EOF
apiVersion: opentelemetry.io/v1beta1
kind: OpenTelemetryCollector
metadata:
  labels:
    prometheus: kube-prometheus
  name: otel
  namespace: ${JAEGER_NS}
spec:
  mode: deployment
  replicas: 1
  resources:
    requests:
      cpu: 100m
      memory: 256Mi
    limits:
      cpu: "2"
      memory: 2Gi
  observability:
    metrics:
      enableMetrics: true
  config:
    receivers:
      otlp:
        protocols:
          grpc:
            endpoint: 0.0.0.0:4317
          http:
            endpoint: 0.0.0.0:4318
      zipkin: {}
    processors:
      batch: {}
      memory_limiter:
        check_interval: 1s
        limit_percentage: 80
        spike_limit_percentage: 20
    exporters:
      debug: {}
      otlp/traces:
        endpoint: "${JAEGER_INSTANCE_NAME}-collector.${JAEGER_NS}.svc.cluster.local:4317"
        tls:
          insecure: true
      prometheus:
        add_metric_suffixes: false # Jaeger expects standard OTel metric names without _total suffixes
        endpoint: "0.0.0.0:8889"
        resource_to_telemetry_conversion:
          enabled: true # by default resource attributes are dropped
    service:
      pipelines:
        traces:
          receivers: [otlp, zipkin]
          processors: [memory_limiter, batch]
          exporters: [debug, otlp/traces] 
        metrics:
          receivers: [otlp]
          processors: [memory_limiter, batch]
          exporters: [debug, prometheus]
      telemetry:
        metrics:
          readers:
          - pull:
              exporter:
                prometheus:
                  host: 0.0.0.0
                  port: 8888
                  without_scope_info: true
                  without_type_suffix: true
                  without_units: true
EOF
      1. prometheus: kube-prometheus 标签使 ACP Prometheus 可以通过自动创建的 ServiceMonitor 抓取 Collector 指标。
      2. Collector 容器的资源请求和限制。请根据预期的 trace 吞吐量进行调整。
      3. 允许 Operator 为 Collector 的 metrics 端点自动创建 ServiceMonitor 资源。
      4. OTLP receiver 接受启用了 tracing 的应用通过 gRPC（端口 4317）和 HTTP（端口 4318）发送的 trace 数据。
      5. otlp/traces exporter 将接收到的 trace 转发到 Jaeger collector service。该 endpoint 由 Jaeger 实例名称和 Namespace 推导得出。
      6. trace pipeline 通过 OTLP 和 Zipkin 接收数据，经过 memory_limiter 和 batch 处理后，同时导出到 debug exporter（用于日志）和 otlp/traces（用于转发到 Jaeger）。

    2. 等待 Collector Pod 就绪：

      kubectl rollout status deployment/otel-collector \
  -n ${JAEGER_NS} --timeout=180s

    验证

    安装完所有组件后，通过生成示例 trace 数据来验证端到端 tracing 流水线。

    1. 部署 telemetrygen 作为测试客户端，以生成示例 traces：

      kubectl apply -f - <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: telemetrygen
  namespace: ${JAEGER_NS}
spec:
  restartPolicy: Never
  containers:
    - name: telemetrygen
      image: ghcr.io/open-telemetry/opentelemetry-collector-contrib/telemetrygen:latest
      args:
        - traces
        - --otlp-endpoint=otel-collector.${JAEGER_NS}.svc.cluster.local:4317
        - --otlp-insecure
        - --duration=150s
        - --interval=5s
        - --child-spans=3
        - --rate=2
        - --service=telemetrygen
        - --workers=1
EOF
# Wait for telemetrygen to complete, then clean up the test Pod
kubectl wait -n ${JAEGER_NS} --for=jsonpath='{.status.phase}'=Succeeded pod/telemetrygen --timeout=10m
kubectl delete pod -n ${JAEGER_NS} telemetrygen
      NOTE

      --otlp-endpoint 必须指向上一步部署的 OpenTelemetry Collector service。

    2. 打开位于 <platform-url>/clusters/<cluster-name>/jaeger 的 Jaeger UI。

      从 Service 下拉框中选择 telemetrygen service，然后单击 Find Traces，以验证生成的 traces 是否可见。

      运行以下命令以打印 Jaeger UI URL：

      echo "Jaeger UI: ${PLATFORM_URL}${JAEGER_BASEPATH}"

    （可选）启用 Service Performance Monitoring (SPM)

    Service Performance Monitoring (SPM) 会在 Jaeger UI 中以 Monitor 选项卡的形式显示，它会聚合 span 数据以生成 RED（Request、Error、Duration）指标。这使你无需事先了解 service 或 operation 名称，也能识别性能问题。更多详情请参见 Service Performance Monitoring (SPM)。

    启用 SPM 需要进行两项更改：在 OpenTelemetry Collector 中添加 SpanMetrics Connector，以及在 Jaeger 中配置一个兼容 PromQL 的 metrics backend。

    先决条件

    • 已部署 Jaeger v2 和 OpenTelemetry Collector（前面的所有步骤均已完成）。
    • 集群中可用 ACP monitoring。

    操作步骤

    1. 从集群中获取 monitoring endpoint 和凭据：

      export MONITORING_URL=$(kubectl get feature monitoring -o jsonpath='{.spec.accessInfo.database.address}')
MONITORING_SECRET_NAME=$(kubectl get feature monitoring -o jsonpath='{.spec.accessInfo.database.basicAuth.secretName}')

export MONITORING_USERNAME=$(kubectl -ncpaas-system get secret "$MONITORING_SECRET_NAME" -o jsonpath="{.data.username}" | base64 -d)
export MONITORING_PASSWORD=$(kubectl -ncpaas-system get secret "$MONITORING_SECRET_NAME" -o jsonpath="{.data.password}" | base64 -d)

    2. 创建用于 monitoring 凭据的 Secret：

      kubectl create secret generic monitoring-credentials \
  --namespace=${JAEGER_NS} \
  --from-literal=username=${MONITORING_USERNAME} \
  --from-literal=password=${MONITORING_PASSWORD}

    3. 通过 patch OpenTelemetry Collector 来启用 SpanMetrics Connector。这会添加一个 spanmetrics connector，用于从 spans 生成 RED 指标，并通过 Prometheus exporter 导出：

      kubectl patch opentelemetrycollector otel -n ${JAEGER_NS} --type=merge -p '
spec:
  config:
    connectors:
      spanmetrics: {}
    service:
      pipelines:
        traces:
          exporters: [debug, otlp/traces, spanmetrics]
        metrics/spanmetrics:
          receivers: [spanmetrics]
          exporters: [prometheus]
'

      等待 Collector 重启：

      kubectl rollout status deployment/otel-collector \
  -n ${JAEGER_NS} --timeout=180s

    4. 创建一个名为 jaeger-spm-patch.yaml 的文件，内容如下。此 patch 会为 Jaeger 添加一个 PromQL metrics backend，并启用 Monitor 选项卡：

      jaeger-spm-patch.yaml
      spec:
  volumes:
    - name: es-credentials
      secret:
        secretName: es-credentials
        items:
          - key: ES_PASS
            path: pass
    - name: oauth2-proxy-secrets
      secret:
        secretName: ${JAEGER_INSTANCE_NAME}-oauth2-proxy
        items:
          - key: OAUTH2_PROXY_CLIENT_SECRET
            path: client-secret
          - key: OAUTH2_PROXY_COOKIE_SECRET
            path: cookie-secret
    - name: monitoring-credentials
      secret:
        secretName: monitoring-credentials
        items:
          - key: username
            path: user
          - key: password
            path: pass
  volumeMounts:
    - name: es-credentials
      mountPath: /etc/jaeger/es-credentials
      readOnly: true
    - name: monitoring-credentials
      mountPath: /etc/jaeger/monitoring-credentials
      readOnly: true
  config:
    extensions:
      basicauth/monitoring:
        client_auth:
          username_file: /etc/jaeger/monitoring-credentials/user
          password_file: /etc/jaeger/monitoring-credentials/pass
      jaeger_storage:
        metric_backends:
          monitoring_metrics_storage:
            prometheus:
              endpoint: ${MONITORING_URL}
              tls:
                insecure_skip_verify: true
              auth:
                authenticator: basicauth/monitoring
      jaeger_query:
        storage:
          metrics: monitoring_metrics_storage
    service:
      extensions: [basicauth/monitoring, healthcheckv2, jaeger_storage, jaeger_query]
      1. monitoring-credentials volume 会将 monitoring 的 basic-auth 凭据挂载到 Jaeger 容器中。
      2. monitoring-credentials volumeMount 使这些凭据可在 /etc/jaeger/monitoring-credentials/ 下访问。
      3. basicauth/monitoring 扩展为 monitoring metrics endpoint 提供 basic authentication。
      4. metric_backends 部分配置了 Jaeger 用于查询 SPM 数据的兼容 PromQL 的 metrics storage。
      5. 在 jaeger_query 扩展中引用该 metrics store。
      6. 必须将 basicauth/monitoring 扩展添加到 service.extensions 列表中，才能使其生效。
      WARNING

      volumes、volumeMounts 和 service.extensions 字段都是数组。merge patch 会整体替换数组，而不是追加到数组中。上面的 patch 文件包含了所有现有条目以及新增条目，以防止数据丢失。

    5. 应用 patch：

      kubectl patch opentelemetrycollector ${JAEGER_INSTANCE_NAME} -n ${JAEGER_NS} \
  --type=merge -p "$(envsubst < jaeger-spm-patch.yaml)"

      等待 Jaeger 重启：

      kubectl rollout status deployment/${JAEGER_INSTANCE_NAME}-collector \
  -n ${JAEGER_NS} --timeout=180s

    验证

    启用 SPM 后，你可以按照上面的 验证 部分所述，通过部署 telemetrygen 测试客户端来进行验证。

    在生成 traces 后，进入 Jaeger UI 中的 Monitor 选项卡，查看 telemetrygen service 的聚合 RED 指标。