[Trace: abc123]
├── API-Gateway         12ms
├── Order-Service      145ms
│   ├── DB Query        38ms
│   └── Payment-Service 2.8s  ← Engpass
│       └── Stripe API  2.7s
└── Total              3.1s

# cert-manager installieren (Voraussetzung)
kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.17.0/cert-manager.yaml

# Jaeger Operator via Helm
helm repo add jaegertracing https://jaegertracing.github.io/helm-charts
helm repo update

helm install jaeger-operator jaegertracing/jaeger-operator \
  --namespace observability --create-namespace \
  --set rbac.clusterRole=true

# jaeger-instance.yaml
apiVersion: jaegertracing.io/v1
kind: Jaeger
metadata:
  name: jaeger-production
  namespace: observability
spec:
  strategy: production
  collector:
    replicas: 2
    resources:
      requests:
        cpu: 500m
        memory: 512Mi
  storage:
    type: elasticsearch
    options:
      es:
        server-urls: http://elasticsearch.observability:9200
        index-prefix: jaeger
    esIndexCleaner:
      enabled: true
      numberOfDays: 14
      schedule: "55 23 * * *"
  query:
    replicas: 1
  ingress:
    enabled: true

kubectl apply -f jaeger-instance.yaml

# app.py
from flask import Flask, request
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.instrumentation.flask import FlaskInstrumentor
from opentelemetry.instrumentation.requests import RequestsInstrumentor

# Tracer konfigurieren
provider = TracerProvider()
otlp_exporter = OTLPSpanExporter(
    endpoint="jaeger-production-collector.observability:4317",
    insecure=True
)
provider.add_span_processor(BatchSpanProcessor(otlp_exporter))
trace.set_tracer_provider(provider)

app = Flask(__name__)
FlaskInstrumentor().instrument_app(app)
RequestsInstrumentor().instrument()

tracer = trace.get_tracer("order-service")

@app.route("/orders", methods=["POST"])
def create_order():
    with tracer.start_as_current_span("validate_order") as span:
        order_data = request.json
        span.set_attribute("order.item_count", len(order_data.get("items", [])))

    # Ausgehender Request -- Trace-Context wird automatisch propagiert
    import requests
    payment = requests.post("http://payment-service:8080/charge",
                           json={"amount": order_data["total"]})
    return {"status": "created", "payment": payment.json()}

package main

import (
    "context"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
    "go.opentelemetry.io/otel/sdk/trace"
    "net/http"
)

func initTracer() (*trace.TracerProvider, error) {
    exporter, err := otlptracegrpc.New(context.Background(),
        otlptracegrpc.WithEndpoint("jaeger-production-collector.observability:4317"),
        otlptracegrpc.WithInsecure(),
    )
    if err != nil {
        return nil, err
    }
    tp := trace.NewTracerProvider(trace.WithBatcher(exporter))
    otel.SetTracerProvider(tp)
    return tp, nil
}

func handleOrder(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    tracer := otel.Tracer("order-service")
    ctx, span := tracer.Start(ctx, "process_order")
    defer span.End()

    // DB-Abfrage als Child-Span
    _, dbSpan := tracer.Start(ctx, "db_query")
    // ... Datenbankabfrage
    dbSpan.End()

    w.WriteHeader(http.StatusCreated)
}

traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01
              │  │                                │                 │
              │  │                                │                 └─ Flags (sampled)
              │  │                                └─ Parent-Span-ID
              │  └─ Trace-ID (128-bit)
              └─ Version

# order-service-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
spec:
  replicas: 3
  template:
    metadata:
      labels:
        app: order-service
    spec:
      containers:
        - name: order-service
          image: registry.example.com/order-service:v2.1.0
          env:
            - name: OTEL_EXPORTER_OTLP_ENDPOINT
              value: "http://jaeger-production-collector.observability:4317"
            - name: OTEL_SERVICE_NAME
              value: "order-service"
            - name: OTEL_RESOURCE_ATTRIBUTES
              value: "k8s.namespace=production,k8s.deployment=order-service"
          ports:
            - containerPort: 8080

# Im Jaeger Custom Resource
spec:
  sampling:
    options:
      default_strategy:
        type: probabilistic
        param: 0.1  # 10% aller Requests
      per_operation_strategies:
        - operation: "/api/orders"
          type: probabilistic
          param: 0.5  # 50% fuer kritische Endpoints
        - operation: "/health"
          type: probabilistic
          param: 0.001  # Health-Checks fast nie