Monitoring und Logging auf STACKIT

Effektives Monitoring und Logging sind essentiell für den Betrieb zuverlässiger Cloud-Anwendungen.

Die drei Säulen der Observability

graph TD
    A[Observability] --> B[Metrics]
    A --> C[Logs]
    A --> D[Traces]
    B --> E[Dashboards]
    C --> F[Log Analysis]
    D --> G[Distributed Tracing]

Metrics (Metriken)

Numerische Zeitreihendaten über Systemzustände:

• CPU-Auslastung
• Speicherverbrauch
• Request-Rate
• Error-Rate

Logs (Protokolle)

Strukturierte oder unstrukturierte Ereignisdaten:

{
  "timestamp": "2024-02-10T14:30:00Z",
  "level": "ERROR",
  "service": "api-gateway",
  "message": "Database connection timeout",
  "duration_ms": 5000,
  "user_id": "user123"
}

Traces (Ablaufverfolgung)

Verfolgung von Requests durch verteilte Systeme.

STACKIT Monitoring Services

Prometheus für Metrics

# prometheus.yml
scrape_configs:
  - job_name: 'my-app'
    static_configs:
      - targets: ['app:8080']
    metrics_path: '/metrics'
    scrape_interval: 15s

Application Metrics

// Node.js mit Prometheus Client
const prometheus = require('prom-client');

const httpRequestDuration = new prometheus.Histogram({
  name: 'http_request_duration_seconds',
  help: 'Duration of HTTP requests in seconds',
  labelNames: ['method', 'route', 'status']
});

app.use((req, res, next) => {
  const start = Date.now();
  res.on('finish', () => {
    const duration = (Date.now() - start) / 1000;
    httpRequestDuration
      .labels(req.method, req.route?.path, res.statusCode)
      .observe(duration);
  });
  next();
});

Logging Best Practices

Strukturiertes Logging

// Strukturierte Logs mit Winston
const winston = require('winston');

const logger = winston.createLogger({
  format: winston.format.json(),
  defaultMeta: { service: 'user-service' },
  transports: [
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' })
  ]
});

logger.info('User login', {
  userId: 'user123',
  ip: '192.168.1.1',
  duration: 245
});

:::tip Verwenden Sie strukturierte Logs (JSON) für bessere Analysierbarkeit und Filterung. :::

Log-Levels

Level	Verwendung	Beispiel
ERROR	Fehler, die Aufmerksamkeit erfordern	Datenbankverbindung fehlgeschlagen
WARN	Potenzielle Probleme	Hohe Latenz erkannt
INFO	Wichtige Ereignisse	Benutzer angemeldet
DEBUG	Detaillierte Informationen	SQL-Query ausgeführt

Alerting und Benachrichtigungen

Alert-Regeln definieren

# Prometheus Alert Rules
groups:
  - name: application_alerts
    rules:
      - alert: HighErrorRate
        expr: rate(http_requests_total{status=~"5.."}[5m]) > 0.05
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "High error rate detected"
          description: "Error rate is {{ $value }} requests/sec"
      
      - alert: HighMemoryUsage
        expr: memory_usage_percent > 90
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "High memory usage"

:::warning Vermeiden Sie Alert-Fatigue durch zu viele Benachrichtigungen. Fokussieren Sie auf kritische Metriken. :::

Dashboards erstellen

Grafana Dashboard

{
  "dashboard": {
    "title": "Application Overview",
    "panels": [
      {
        "title": "Request Rate",
        "targets": [{
          "expr": "rate(http_requests_total[5m])"
        }]
      },
      {
        "title": "Error Rate",
        "targets": [{
          "expr": "rate(http_requests_total{status=~\"5..\"}[5m])"
        }]
      }
    ]
  }
}

Log-Aggregation

Zentralisieren Sie Logs von allen Services:

# Logs an zentralen Service senden
docker run -d \
  --log-driver=fluentd \
  --log-opt fluentd-address=logs.stackit.cloud:24224 \
  --log-opt tag="docker.{{.Name}}" \
  my-app:latest

Distributed Tracing

Verfolgen Sie Requests durch Microservices:

// OpenTelemetry Tracing
const { trace } = require('@opentelemetry/api');

const tracer = trace.getTracer('my-service');

async function processOrder(orderId) {
  const span = tracer.startSpan('process_order');
  span.setAttribute('order.id', orderId);
  
  try {
    await validateOrder(orderId);
    await chargePayment(orderId);
    await shipOrder(orderId);
    span.setStatus({ code: SpanStatusCode.OK });
  } catch (error) {
    span.setStatus({ 
      code: SpanStatusCode.ERROR,
      message: error.message 
    });
    throw error;
  } finally {
    span.end();
  }
}

Performance Monitoring

Key Performance Indicators (KPIs)

• Apdex Score: Benutzerzufriedenheit
• Response Time: P50, P95, P99 Perzentile
• Throughput: Requests pro Sekunde
• Error Rate: Fehlerhafte Requests

:::info Überwachen Sie P95 und P99 Perzentile, nicht nur Durchschnittswerte, um Ausreißer zu erkennen. :::

Kostenoptimierung

• Implementieren Sie Log-Retention-Policies
• Filtern Sie unwichtige Logs
• Verwenden Sie Sampling für Traces
• Aggregieren Sie Metriken

Checkliste

• Metriken für alle Services erfasst
• Strukturiertes Logging implementiert
• Alerts für kritische Metriken konfiguriert
• Dashboards für Übersicht erstellt
• Log-Retention konfiguriert
• Distributed Tracing aktiviert
• On-Call Rotation definiert