Prometheus-Monitoring: Komplette Einrichtung & Best Practices

Prometheus ist zum de facto Standard für die Überwachung cloud-nativer Anwendungen und Infrastruktur geworden und bietet Metriken-Sammlung, Abfragen und Integration mit Visualisierungstools.

Was ist Prometheus?

Prometheus ist ein Open-Source-Überwachungs- und Alerting-Toolkit, das ursprünglich 2012 bei SoundCloud entwickelt wurde und jetzt ein graduiertes Projekt der Cloud Native Computing Foundation (CNCF) ist. Es ist speziell für Zuverlässigkeit und Skalierbarkeit in dynamischen Cloud-Umgebungen entwickelt worden und macht es zur bevorzugten Lösung für die Überwachung von Mikroservices, Containern und Kubernetes-Clustern.

Wichtige Funktionen

Zeitreihen-Datenbank: Prometheus speichert alle Daten als Zeitreihen, identifiziert durch Metriken-Namen und Schlüssel-Wert-Paare (Labels), was flexible und leistungsstarke Abfragefähigkeiten ermöglicht.

Pull-basiertes Modell: Im Gegensatz zu traditionellen Push-basierten Systemen erfasst Prometheus aktiv Metriken von konfigurierten Zielen in festgelegten Intervallen, was es zuverlässiger und einfacher zu konfigurieren macht.

PromQL Abfragesprache: Eine leistungsstarke funktionale Abfragesprache ermöglicht es Ihnen, Ihre Metriken-Daten in Echtzeit zu analysieren, Aggregationen, Transformationen und komplexe Berechnungen durchzuführen.

Service Discovery: Automatische Erkennung von Überwachungszielen durch verschiedene Mechanismen, einschließlich Kubernetes, Consul, EC2 und statische Konfigurationen.

Keine externen Abhängigkeiten: Prometheus arbeitet als einzelne Binärdatei ohne erforderliche externe Abhängigkeiten, was die Bereitstellung vereinfacht und die Betriebskomplexität reduziert.

Integriertes Alerting: AlertManager verarbeitet Alerts von Prometheus und bietet Deduplizierung, Gruppierung und Weiterleitung an Benachrichtigungskanäle wie E-Mail, PagerDuty oder Slack.

Architekturübersicht

Das Verständnis der Prometheus-Architektur ist entscheidend für eine effektive Bereitstellung. Die Hauptkomponenten umfassen:

• Prometheus-Server: Erfasst und speichert Metriken, bewertet Regeln und dient Abfragen
• Client-Bibliotheken: Instrumentieren Sie den Anwendungscode, um Metriken auszusetzen
• Exporter: Brücken Sie Drittanbieter-Systeme in das Prometheus-Format
• AlertManager: Verarbeitet Alerts und Benachrichtigungen
• Pushgateway: Akzeptiert Metriken von kurzlebigen Jobs, die nicht erfasst werden können

Der typische Datenfluss: Anwendungen setzen Metriken-Endpunkte aus → Prometheus erfasst diese Endpunkte → Daten werden in der Zeitreihen-Datenbank gespeichert → PromQL-Abfragen holen und analysieren Daten → Alerts werden basierend auf Regeln generiert → AlertManager verarbeitet und leitet Benachrichtigungen weiter.

Bei der Bereitstellung von Infrastruktur auf Ubuntu 24.04, bietet Prometheus eine hervorragende Grundlage für eine umfassende Überwachung.

Installation von Prometheus auf Ubuntu

Lassen Sie uns durchgehen, wie man Prometheus auf einem Linux-System installiert. Wir verwenden Ubuntu als Beispiel, aber der Prozess ist für andere Distributionen ähnlich.

Herunterladen und Installieren

Zuerst erstellen Sie einen dedizierten Benutzer für Prometheus:

sudo useradd --no-create-home --shell /bin/false prometheus

Laden Sie die neueste Prometheus-Version herunter:

cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v2.48.0/prometheus-2.48.0.linux-amd64.tar.gz
tar xvf prometheus-2.48.0.linux-amd64.tar.gz
cd prometheus-2.48.0.linux-amd64

Kopieren Sie die Binärdateien und erstellen Sie Verzeichnisse:

sudo cp prometheus /usr/local/bin/
sudo cp promtool /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/prometheus
sudo chown prometheus:prometheus /usr/local/bin/promtool

sudo mkdir /etc/prometheus
sudo mkdir /var/lib/prometheus
sudo chown prometheus:prometheus /etc/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

sudo cp -r consoles /etc/prometheus
sudo cp -r console_libraries /etc/prometheus
sudo cp prometheus.yml /etc/prometheus/prometheus.yml
sudo chown -R prometheus:prometheus /etc/prometheus

Für das Paketmanagement unter Ubuntu beziehen Sie sich auf unseren umfassenden Ubuntu-Paketmanagement-Leitfaden.

Konfiguration von Prometheus

Bearbeiten Sie /etc/prometheus/prometheus.yml:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

alerting:
  alertmanagers:
    - static_configs:
        - targets: ['localhost:9093']

rule_files:
  - 'alert_rules.yml'

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'node_exporter'
    static_configs:
      - targets: ['localhost:9100']

Erstellen eines Systemd-Dienstes

Erstellen Sie /etc/systemd/system/prometheus.service:

[Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
  --config.file=/etc/prometheus/prometheus.yml \
  --storage.tsdb.path=/var/lib/prometheus/ \
  --web.console.templates=/etc/prometheus/consoles \
  --web.console.libraries=/etc/prometheus/console_libraries \
  --storage.tsdb.retention.time=30d

[Install]
WantedBy=multi-user.target

Starten und aktivieren Sie Prometheus:

sudo systemctl daemon-reload
sudo systemctl start prometheus
sudo systemctl enable prometheus
sudo systemctl status prometheus

Greifen Sie auf die Prometheus-Weboberfläche zu unter http://localhost:9090.

Einrichtung von Node Exporter

Node Exporter stellt Hardware- und OS-Metriken für Linux-Systeme bereit. Installieren Sie ihn, um Ihre Server zu überwachen:

cd /tmp
wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz
tar xvf node_exporter-1.7.0.linux-amd64.tar.gz
sudo cp node_exporter-1.7.0.linux-amd64/node_exporter /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/node_exporter

Erstellen Sie einen Systemd-Dienst /etc/systemd/system/node_exporter.service:

[Unit]
Description=Node Exporter
After=network.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target

Starten Sie Node Exporter:

sudo systemctl daemon-reload
sudo systemctl start node_exporter
sudo systemctl enable node_exporter

Node Exporter stellt nun Metriken auf Port 9100 bereit.

Verständnis von PromQL

PromQL (Prometheus Query Language) ist das Herzstück der Abfrage von Prometheus-Daten. Hier sind wesentliche Abfrage-Muster:

Grundlegende Abfragen

Wählen Sie alle Zeitreihen für eine Metrik aus:

node_cpu_seconds_total

Filtern Sie nach Label:

node_cpu_seconds_total{mode="idle"}

Mehrere Label-Filter:

node_cpu_seconds_total{mode="idle",cpu="0"}

Bereichsvektoren und Aggregationen

Berechnen Sie die Rate über die Zeit:

rate(node_cpu_seconds_total{mode="idle"}[5m])

Summieren Sie über alle CPUs:

sum(rate(node_cpu_seconds_total{mode="idle"}[5m]))

Gruppieren Sie nach Label:

sum by (mode) (rate(node_cpu_seconds_total[5m]))

Praktische Beispiele

CPU-Nutzungsprozent:

100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

Speichernutzung:

(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100

Festplattennutzung:

(node_filesystem_size_bytes - node_filesystem_avail_bytes) / node_filesystem_size_bytes * 100

Netzwerkverkehrsrate:

rate(node_network_receive_bytes_total[5m])

Docker-Bereitstellung

Das Ausführen von Prometheus in Docker-Containern bietet Flexibilität und einfachere Verwaltung:

Erstellen Sie docker-compose.yml:

version: '3.8'

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'
    ports:
      - "9090:9090"
    restart: unless-stopped

  node_exporter:
    image: prom/node-exporter:latest
    container_name: node_exporter
    command:
      - '--path.rootfs=/host'
    volumes:
      - '/:/host:ro,rslave'
    ports:
      - "9100:9100"
    restart: unless-stopped

  alertmanager:
    image: prom/alertmanager:latest
    container_name: alertmanager
    volumes:
      - ./alertmanager.yml:/etc/alertmanager/alertmanager.yml
      - alertmanager_data:/alertmanager
    ports:
      - "9093:9093"
    restart: unless-stopped

volumes:
  prometheus_data:
  alertmanager_data:

Starten Sie den Stack:

docker-compose up -d

Kubernetes-Überwachung

Prometheus glänzt bei der Überwachung von Kubernetes-Clustern. Das kube-prometheus-stack Helm-Chart bietet eine vollständige Überwachungslösung.

Installieren Sie mit Helm:

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update
helm install prometheus prometheus-community/kube-prometheus-stack

Dies installiert:

• Prometheus Operator
• Prometheus-Instanz
• AlertManager
• Grafana
• Node Exporter
• kube-state-metrics
• Vordefinierte Dashboards und Alerts

Greifen Sie auf Grafana zu:

kubectl port-forward svc/prometheus-grafana 3000:80

Standard-Anmeldedaten: admin/prom-operator

Für verschiedene Kubernetes-Distributionen, ist der Bereitstellungsprozess ähnlich mit geringfügigen Anpassungen für plattformspezifische Funktionen.

Einrichtung von Alerting

AlertManager verwaltet die von Prometheus gesendeten Alerts. Konfigurieren Sie Alert-Regeln und Benachrichtigungskanäle.

Alert-Regeln

Erstellen Sie /etc/prometheus/alert_rules.yml:

groups:
  - name: system_alerts
    interval: 30s
    rules:
      - alert: HighCPUUsage
        expr: 100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Hohe CPU-Auslastung auf {{ $labels.instance }}"
          description: "CPU-Auslastung liegt über 80% (aktueller Wert: {{ $value }}%)"

      - alert: HighMemoryUsage
        expr: (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100 > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Hohe Speicherauslastung auf {{ $labels.instance }}"
          description: "Speicherauslastung liegt über 85% (aktueller Wert: {{ $value }}%)"

      - alert: DiskSpaceLow
        expr: (node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100 < 15
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "Geringer Festplattenspeicher auf {{ $labels.instance }}"
          description: "Verfügbarer Festplattenspeicher liegt unter 15% auf {{ $labels.mountpoint }}"

      - alert: InstanceDown
        expr: up == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Instanz {{ $labels.instance }} ist offline"
          description: "{{ $labels.job }} Instanz {{ $labels.instance }} ist seit mehr als 2 Minuten offline"

AlertManager-Konfiguration

Erstellen Sie /etc/prometheus/alertmanager.yml:

global:
  resolve_timeout: 5m
  smtp_smarthost: 'smtp.gmail.com:587'
  smtp_from: 'alerts@example.com'
  smtp_auth_username: 'alerts@example.com'
  smtp_auth_password: 'your-password'

route:
  group_by: ['alertname', 'cluster', 'service']
  group_wait: 10s
  group_interval: 10s
  repeat_interval: 12h
  receiver: 'team-email'
  routes:
    - match:
        severity: critical
      receiver: 'team-pagerduty'
    - match:
        severity: warning
      receiver: 'team-slack'

receivers:
  - name: 'team-email'
    email_configs:
      - to: 'team@example.com'
        headers:
          Subject: '{{ .GroupLabels.alertname }}: {{ .Status | toUpper }}'

  - name: 'team-slack'
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK'
        channel: '#alerts'
        title: 'Alert: {{ .GroupLabels.alertname }}'
        text: '{{ range .Alerts }}{{ .Annotations.description }}{{ end }}'

  - name: 'team-pagerduty'
    pagerduty_configs:
      - service_key: 'your-pagerduty-key'

Integration mit Grafana

Während Prometheus eine grundlegende Weboberfläche hat, bietet Grafana überlegene Visualisierungsfähigkeiten für die Erstellung umfassender Dashboards.

Prometheus als Datenquelle hinzufügen

1. Öffnen Sie Grafana und navigieren Sie zu Configuration → Data Sources
2. Klicken Sie auf “Add data source”
3. Wählen Sie “Prometheus”
4. Setzen Sie die URL auf http://localhost:9090 (oder Ihren Prometheus-Server)
5. Klicken Sie auf “Save & Test”

Beliebte Dashboard-IDs

Importieren Sie vorgefertigte Dashboards von grafana.com:

• Node Exporter Full (ID: 1860): Umfassende Linux-Metriken
• Kubernetes Cluster Monitoring (ID: 7249): K8s-Übersicht
• Docker Container Monitoring (ID: 193): Container-Metriken
• Prometheus Stats (ID: 2): Prometheus-Interne Metriken

Erstellung benutzerdefinierter Dashboards

Erstellen Sie Panels mit PromQL-Abfragen:

{
  "title": "CPU-Auslastung",
  "targets": [{
    "expr": "100 - (avg(rate(node_cpu_seconds_total{mode=\"idle\"}[5m])) * 100)"
  }]
}

Beliebte Exporter

Erweitern Sie die Prometheus-Überwachung mit spezialisierten Exportern:

Blackbox Exporter

Überprüft Endpunkte über HTTP, HTTPS, DNS, TCP und ICMP:

scrape_configs:
  - job_name: 'blackbox'
    metrics_path: /probe
    params:
      module: [http_2xx]
    static_configs:
      - targets:
          - https://example.com
          - https://api.example.com
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: localhost:9115

Datenbank-Exporter

• mysqld_exporter: MySQL/MariaDB-Metriken
• postgres_exporter: PostgreSQL-Metriken
• mongodb_exporter: MongoDB-Metriken
• redis_exporter: Redis-Metriken

Anwendungs-Exporter

• nginx_exporter: NGINX-Webserver-Metriken
• apache_exporter: Apache-HTTP-Server-Metriken
• haproxy_exporter: HAProxy-Load-Balancer-Metriken

Cloud-Exporter

• cloudwatch_exporter: AWS CloudWatch-Metriken
• stackdriver_exporter: Google Cloud-Metriken
• azure_exporter: Azure Monitor-Metriken

Best Practices

Datenretention

Konfigurieren Sie eine angemessene Retention basierend auf Ihren Anforderungen:

--storage.tsdb.retention.time=30d
--storage.tsdb.retention.size=50GB

Aufzeichnungsregeln

Berechnen Sie häufig abgefragte Ausdrücke im Voraus:

groups:
  - name: example_rules
    interval: 30s
    rules:
      - record: job:node_cpu_utilization:avg
        expr: 100 - (avg by (job) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

Label-Verwaltung

• Halten Sie die Label-Kardinalität niedrig
• Verwenden Sie konsistente Namenskonventionen
• Vermeiden Sie Labels mit hoher Kardinalität (Benutzer-IDs, Zeitstempel)

Sicherheit

• Aktivieren Sie Authentifizierung und HTTPS
• Beschränken Sie den Zugriff auf die Prometheus-API
• Verwenden Sie Netzwerkrichtlinien in Kubernetes
• Implementieren Sie RBAC für sensible Metriken

Hochverfügbarkeit

• Führen Sie mehrere Prometheus-Instanzen aus
• Verwenden Sie Thanos oder Cortex für Langzeitspeicherung
• Implementieren Sie Federation für hierarchische Setups

Fehlerbehebung bei häufigen Problemen

Hohe Speicherauslastung

• Reduzieren Sie die Scrape-Häufigkeit
• Verkürzen Sie die Retentionsdauer
• Optimieren Sie PromQL-Abfragen
• Implementieren Sie Aufzeichnungsregeln

Fehlende Metriken

• Überprüfen Sie den Zielstatus unter /targets
• Überprüfen Sie die Netzwerkverbindung
• Validieren Sie die Scrape-Konfiguration
• Überprüfen Sie die Exporter-Logs

Langsame Abfragen

• Verwenden Sie Aufzeichnungsregeln für komplexe Aggregationen
• Optimieren Sie Label-Filter
• Reduzieren Sie den Zeitbereich
• Fügen Sie Indizes hinzu, wenn Remote-Speicher verwendet wird

Leistungsoptimierung

Abfrageoptimierung

# Schlechte: Hohe Kardinalität
sum(rate(http_requests_total[5m]))

# Gute: Gruppierung nach relevanten Labels
sum by (status, method) (rate(http_requests_total[5m]))

Ressourcenlimits

Für Kubernetes-Deployments:

resources:
  requests:
    memory: "2Gi"
    cpu: "1000m"
  limits:
    memory: "4Gi"
    cpu: "2000m"

Fazit

Prometheus bietet eine robuste, skalierbare Überwachungslösung für moderne Infrastrukturen. Seine pull-basierte Architektur, die leistungsstarke Abfragesprache und das umfangreiche Ökosystem von Exportern machen es ideal für die Überwachung von allem, von Bare-Metal-Servern bis hin zu komplexen Kubernetes-Clustern.

Durch die Kombination von Prometheus mit Grafana für die Visualisierung und AlertManager für Benachrichtigungen erstellen Sie eine umfassende Observability-Plattform, die in der Lage ist, Unternehmensüberwachungsanforderungen zu bewältigen. Die aktive Community und die Unterstützung durch die CNCF garantieren eine fortlaufende Entwicklung und Unterstützung.

Beginnen Sie mit der grundlegenden Metrikensammlung, fügen Sie nach und nach Exporter für Ihre spezifischen Dienste hinzu und verfeinern Sie Ihre Alert-Regeln basierend auf realen Erfahrungen. Prometheus skaliert mit Ihrer Infrastruktur, von Single-Server-Deployments bis hin zu Multi-Data-Center-Überwachungsarchitekturen.

Verwandte Ressourcen

• Wie man Ubuntu 24.04 installiert & nützliche Tools
• Ubuntu-Paketverwaltung: APT und dpkg Cheatsheet
• Installation und Nutzung von Grafana auf Ubuntu: Komplette Anleitung
• Kubernetes Cheatsheet
• Kubernetes-Distributionen - schneller Überblick über kubeadm, k3s, MicroK8s, Minikube, Talos Linux und RKE2
• Docker Cheatsheet

Externe Referenzen

• Prometheus Offizielle Dokumentation
• PromQL Abfragebeispiele
• Prometheus Exporter-Liste
• Grafana Prometheus Integration Guide
• kube-prometheus-stack Helm Chart
• Prometheus Best Practices
• AlertManager-Konfiguration