OpenTelemetry in 10 Minuten: Der Standard für moderne Observability

OpenTelemetry ist der neue Standard für Traces, Metrics und Logs. So richtest du OTel in deinem Kubernetes-Cluster ein.

Zurueck zur Uebersicht
5. März 2026
KI-Ops Team
OpenTelemetryTutorial

Warum OpenTelemetry?

Wenn du ein Monitoring System aufbaust, passiert immer das gleiche:

  1. Du wählst einen Vendor (Datadog, New Relic, Prometheus)
  2. Du instrumentierst deinen Code gegen deren API
  3. 2 Jahre später wechselst du zu einem anderen Vendor
  4. Jetzt musst du ALL deinen Code umschreiben

Das ist die Definition von Vendor Lock-in.

OpenTelemetry (OTel) löst das: Ein einziger Standard für Observability, der zu jedem Vendor exportiert.

Dein Code instrumentiert gegen OTel, nicht gegen Datadog oder Prometheus. Dann konfigurierst du einen "Exporter" wo deine Daten hingehen – Prometheus, Grafana Loki, Datadog, oder OpenSearch.

Standard statt Vendor Lock-in.

Was ist OpenTelemetry?

OpenTelemetry ist ein Open Source Projekt der Cloud Native Computing Foundation. Es hat drei Säulen:

1. Traces (Distributed Tracing)

Folgt einem Request über Millisekunden durch dein System:

User Request comes in
├── API Gateway (5ms)
├── Auth Service (12ms)
│   └── Database Call (8ms)
├── Business Logic (45ms)
│   ├── Cache Check (2ms)
│   └── Database Query (30ms)
└── Response (2ms)
TOTAL: 67ms

Du siehst nicht nur dass Anfrage 67ms dauerte, sondern wo die Zeit verbraucht wurde (Auth 12ms ist normal, Database 30ms könnte optimiert werden).

2. Metrics (Quantitative Data)

Numerische Messwerte über Zeit:

  • Request Rate (pro Sekunde)
  • Error Rate (%)
  • Latency (P50, P95, P99)
  • Memory Usage
  • CPU Usage
  • Custom Metrics (Orders per minute, Konversionen, etc.)

3. Logs (Qualitative Data)

Textuelle Daten die context geben:

  • Error Stack Traces
  • Business Events ("User registriert")
  • Debug Informationen

OTel vereinigt alle drei in einem einzigen Framework.

Installation in 10 Minuten

Schritt 1: OpenTelemetry Collector deployen

Der OTel Collector ist ein leichter Agent, der Observability Data von deinen Services sammelt und weiterzuleitet.

# Füge das Chart Repository hinzu
helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
helm repo update

# Installiere den Collector
helm install otel-collector open-telemetry/opentelemetry-collector \
  --namespace observability --create-namespace

Das war's. Der Collector läuft jetzt in deinem Cluster.

Schritt 2: Collector konfigurieren (YAML)

Der Collector muss wissen, wo deine Daten hinkommen. Erstelle eine values.yaml:

# Empfängt Daten von deinen Anwendungen
receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

  # Optional: Prometheus Metriken scrapen
  prometheus:
    config:
      scrape_configs:
        - job_name: 'kubernetes-pods'
          kubernetes_sd_configs:
            - role: pod

# Verarbeite die Daten (optional)
processors:
  batch:
    timeout: 10s
    send_batch_size: 1024

# Exportiere an Backends
exporters:
  prometheus:
    endpoint: "0.0.0.0:8888"
  otlp:
    endpoint: loki.observability:3100

# Verbinde alles
service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlp]
    metrics:
      receivers: [otlp, prometheus]
      processors: [batch]
      exporters: [prometheus]

Deploye:

helm install otel-collector open-telemetry/opentelemetry-collector \
  -f values.yaml --namespace observability

Schritt 3: Application instrumentieren

In deiner Node.js/Python/Go/Java App:

Node.js Example:

const opentelemetry = require("@opentelemetry/api");
const { NodeSDK } = require("@opentelemetry/sdk-node");
const { getNodeAutoInstrumentations } = require("@opentelemetry/auto-instrumentations-node");
const { OTLPTraceExporter } = require("@opentelemetry/exporter-trace-otlp-grpc");

// Auto-Instrumentierung (Traces, Metriken für Express, DB, HTTP)
const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    url: "http://otel-collector:4317"
  }),
  instrumentations: [getNodeAutoInstrumentations()]
});

sdk.start();

// Das war's! Jeder Request wird jetzt getraced
const express = require("express");
const app = express();

app.get("/api/users/:id", (req, res) => {
  // OpenTelemetry traced automatisch:
  // - Request kommt an
  // - Database Query (wenn du Prisma/Sequelize nutzt)
  // - Response geht raus
  res.json({ id: req.params.id, name: "John" });
});

app.listen(3000);

Python Example:

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace.export import BatchSpanProcessor

# Setup
otlp_exporter = OTLPSpanExporter(
    endpoint="otel-collector:4317",
    insecure=True
)
trace.set_tracer_provider(TracerProvider())
trace.get_tracer_provider().add_span_processor(
    BatchSpanProcessor(otlp_exporter)
)

# Nutze es in deiner Flask/FastAPI App
from flask import Flask
app = Flask(__name__)

@app.route("/api/users/<id>")
def get_user(id):
    # Automatisch getraced
    return {"id": id, "name": "John"}

Schritt 4: Metriken visualisieren

Verbinde Prometheus oder Grafana mit dem Collector:

# In deinem Prometheus config
scrape_configs:
  - job_name: 'otel-collector'
    static_configs:
      - targets: ['otel-collector:8888']

Öffne Grafana → Add Data Source → Prometheus → Queries erstellen:

# Request Rate pro Sekunde
rate(http_server_request_count[1m])

# P95 Latency
histogram_quantile(0.95, http_server_request_duration_seconds_bucket)

# Error Rate
rate(http_server_request_count{status_code=~"5.."}[1m])

Das war's.

Was du jetzt hast

Nach 10 Minuten:

  • ✅ Traces von deinem ganzen System
  • ✅ Metriken in Prometheus
  • ✅ Visualisierungen in Grafana
  • ✅ Vendor-agnostisch (jeder Exporter tut)

Häufige Use Cases

1. Ein langsamer Endpoint

Grafana zeigt: /api/checkout dauert 2 Sekunden
Du öffnest Jaeger/Grafana Traces
Du siehst:
  - Payment Service braucht 1.8s
  - Database Query dauert 1.7s

Sofort klar, wo das Problem ist.

2. Service Dependencies finden

Du weißt nicht, welche Services voneinander abhängig sind?
OTel Traces zeigen: Service A ruft Service B auf
                    Service B ruft Database auf
                    Service C ist nicht genutzt (kann gelöscht werden)

3. Correlation IDs für Debugging

User sagt: "Mein Order 12345 wurde nicht verarbeitet"
Du suchst Order ID in Logs
OTel Traces folgen: API → Database → Queue → Worker
Du siehst: Worker crashed bei Step 3

Best Practices

1. Auto-Instrumentation nutzen

Nicht manuell jeden span erstellen. Die Auto-Instrumentations machen 95% der Arbeit:

go install github.com/open-telemetry/opentelemetry-go-instrumentation/cmd/otelcontribcol@latest

2. Sampling für große Volumen

Wenn du 100,000 Requests/Sekunde hast, kannst du nicht alles tracen. Nutze Sampling:

processors:
  probabilistic_sampler:
    sampling_percentage: 10  # Nur 10% samplen

3. Custom Spans für Business Logic

const tracer = opentelemetry.trace.getTracer("my-app");
const span = tracer.startSpan("process-order");
span.setAttributes({
  "order.id": orderId,
  "order.amount": amount,
  "order.currency": "EUR"
});
// ... deine Business Logic
span.end();

Integration mit KI-Ops

KI-Ops nutzt OTel Traces und Metriken um automatisch Probleme zu diagnostizieren:

# KI-Ops liest Traces aus deinem OTel Setup
ki-ops diagnose --service checkout --include-traces

# Output:
# Problem: /api/checkout dauert 5 Sekunden (sollte <1s sein)
# Root Cause (basierend auf Traces): Payment Service ist 3s langsam
# Warum: Query ohne Index auf transactions Tabelle
# Fix: CREATE INDEX idx_payment_status ON transactions(status, created_at)

Das Takeaway

OpenTelemetry ist nicht kompliziert:

  1. Deploye OTel Collector (5 Min)
  2. Instrumentiere deine Apps (3 Min)
  3. Visualisiere in Grafana (2 Min)

Dann hast du vollständige Visibility über dein System – ohne Vendor Lock-in.

Und damit wird dein Incident Response exponentiell schneller.

Probier es aus:

git clone https://github.com/open-telemetry/opentelemetry-demo
cd opentelemetry-demo
docker-compose up
# Öffne http://localhost:8080 – fertig

Fragen oder Feedback?

Schreib uns – wir freuen uns ueber technische Diskussionen.

Kontakt aufnehmen