Prometheus Monitoring System: Vollständiger Einrichtungsleitfaden für Infrastruktur- und Anwendungsüberwachung

Da die moderne Infrastruktur immer komplexer wird – mit Microservices, Containern und verteilten Systemen – ist ein robustes Monitoring keine Option mehr. Es ist eine grundlegende Anforderung für die Aufrechterhaltung von Leistung, Zuverlässigkeit und Skalierbarkeit. Prometheus, ein Open-Source-Monitoring- und Alerting-Toolkit, hat sich als eine der am weitesten verbreiteten Lösungen für die Erfassung und Visualisierung von Zeitreihenmesswerten in verschiedenen Umgebungen etabliert.

Ursprünglich von SoundCloud entwickelt und heute ein abgeschlossenes Cloud Native Computing Foundation (CNCF)-Projekt, wird Prometheus von Engineering-Teams weltweit eingesetzt. Dieser umfassende Leitfaden behandelt alles, was Sie wissen müssen: Was Prometheus ist, wie es funktioniert, seine Kernkomponenten und einen vollständigen Schritt-für-Schritt-Einrichtungsprozess – einschließlich Node Exporter, Grafana-Dashboards und Alerting-Konfiguration.

Was ist Prometheus?

Prometheus ist ein leistungsstarkes Open-Source-Monitoring-System, das dafür entwickelt wurde, Zeitreihendaten zu erfassen, zu speichern und abzufragen – Messungen oder Ereignisse, die über die Zeit mit hochauflösenden Zeitstempeln verfolgt werden. Es ermöglicht Teams, den Systemzustand zu visualisieren, Trends zu analysieren und intelligente Alarme auszulösen, bevor kleine Probleme zu kritischen Ausfällen eskalieren.

Hauptmerkmale von Prometheus

Diese Funktionen machen Prometheus zur idealen Wahl für Teams, die Workloads auf VPS Hosting, Bare-Metal-Infrastruktur oder containerisierten Plattformen betreiben.

Wie Prometheus funktioniert

Prometheus folgt einer klaren, gut definierten Architektur, die auf der Erfassung und Speicherung von Zeitreihendaten aufgebaut ist. Das Verständnis dieser Architektur ist unerlässlich, bevor es in der Produktion eingesetzt wird.

Kernworkflow

1. Metrikerfassung (Scraping): Prometheus sendet periodisch HTTP-Anfragen an konfigurierte Ziel-Endpunkte – bekannt als *Exporters* – um Metriken zu erfassen. Das Scrape-Intervall ist vollständig konfigurierbar.

1. Zeitreihenspeicherung: Erfasste Metriken werden in der integrierten Zeitreihendatenbank (TSDB) von Prometheus gespeichert. Jeder Datenpunkt trägt einen Unix-Zeitstempel und eine Reihe von Schlüssel-Wert-Labels zur Identifikation.

1. Abfragen mit PromQL: Ingenieure verwenden PromQL, um gespeicherte Metriken abzufragen, Graphen zu erstellen, Dashboards aufzubauen oder Alarmbedingungen basierend auf Echtzeit- und historischen Daten zu definieren.

1. Alerting-Pipeline: Wenn eine Metrik einen vordefinierten Schwellenwert überschreitet, sendet Prometheus einen Alarm an den Alertmanager, der Benachrichtigungen dedupliziert, gruppiert und an die entsprechenden Kanäle weiterleitet.

Das Pull-basierte Modell ist eine bewusste architektonische Entscheidung. Es vereinfacht die Netzwerksicherheit (Ziele benötigen keinen ausgehenden Zugriff auf einen zentralen Server), macht die Konfiguration transparent und skaliert gut in verteilten Umgebungen.

Prometheus-Kernkomponenten

Prometheus ist ein modulares Ökosystem. Jede Komponente erfüllt eine bestimmte Rolle:

1. Prometheus Server

Die zentrale Engine, die für das Scraping von Zielen, die Speicherung von Metriken in der TSDB, die Auswertung von Alerting-Regeln sowie die Bereitstellung der PromQL-API und der Web-UI verantwortlich ist.

2. Exporters

Exporters sind leichtgewichtige Agenten oder Adapter, die Metriken in einem Prometheus-kompatiblen Format bereitstellen. Wichtige Exporters umfassen:

• Node Exporter — Erfasst Hardware- und OS-Metriken: CPU, Arbeitsspeicher, Disk I/O, Netzwerkdurchsatz, Dateisystemnutzung
• Blackbox Exporter — Prüft externe Endpunkte über HTTP, HTTPS, DNS, TCP und ICMP auf Verfügbarkeit und Latenz
• Datenbank-Exporters — Dedizierte Exporters existieren für PostgreSQL, MySQL, Redis, MongoDB und viele andere
• Anwendungsspezifische Exporters — Die meisten modernen Anwendungen und Frameworks stellen nativ einen /metrics-Endpunkt bereit

3. Alertmanager

Verwaltet den gesamten Alerting-Lebenszyklus: Empfang von Alarmen von Prometheus, deren Deduplizierung und Gruppierung, Anwendung von Stille- und Inhibitionsregeln sowie die Weiterleitung von Benachrichtigungen an Empfänger wie Slack, E-Mail, PagerDuty oder OpsGenie.

4. PromQL (Prometheus Query Language)

Eine zweckgebundene funktionale Abfragesprache für Zeitreihendaten. PromQL unterstützt Instant-Vektoren, Range-Vektoren, Aggregationsoperatoren, mathematische Funktionen und Unterabfragen – und gibt Ihnen tiefe analytische Möglichkeiten über Ihre Metriken.

5. Pushgateway

Entwickelt für kurzlebige oder Batch-Jobs, die nicht direkt gescrapt werden können (z. B. ein Cron-Job, der 30 Sekunden läuft). Diese Jobs senden ihre Metriken an das Pushgateway, das Prometheus dann in seinem regulären Intervall scrapt.

6. Grafana

Obwohl nicht Teil von Prometheus selbst, ist Grafana die De-facto-Visualisierungsschicht für Prometheus-Daten. Es verbindet sich mit Prometheus als Datenquelle und ermöglicht die Erstellung von umfangreichen, interaktiven Dashboards mit Panels, Variablen und Annotationen.

Schritt-für-Schritt Prometheus-Einrichtung auf Linux

Der folgende Leitfaden führt Sie durch eine vollständige Prometheus-Bereitstellung auf einem Linux-Server, einschließlich Node Exporter für Systemmetriken, Grafana für die Visualisierung und Alertmanager für Benachrichtigungen.

> Voraussetzungen: Ein Linux-Server (Ubuntu 20.04/22.04 oder CentOS/RHEL 8+), sudo– oder Root-Zugriff und grundlegende Kenntnisse der Befehlszeile. Wenn Sie eine zuverlässige Serverumgebung benötigen, sollten Sie AlexHost VPS Hosting für eine leistungsstarke, latenzarme Grundlage in Betracht ziehen.

Schritt 1: Prometheus installieren

Laden Sie die neueste Prometheus-Version herunter und entpacken Sie sie:

wget https://github.com/prometheus/prometheus/releases/download/v2.47.0/prometheus-2.47.0.linux-amd64.tar.gz
tar -xvf prometheus-2.47.0.linux-amd64.tar.gz
cd prometheus-2.47.0.linux-amd64

> Tipp: Überprüfen Sie immer die offizielle Prometheus-Releases-Seite auf die neueste stabile Version, bevor Sie herunterladen.

Erstellen Sie einen dedizierten Systembenutzer und eine Verzeichnisstruktur:

sudo useradd --no-create-home --shell /bin/false prometheus
sudo mkdir /etc/prometheus /var/lib/prometheus
sudo cp prometheus promtool /usr/local/bin/
sudo cp -r consoles console_libraries /etc/prometheus/
sudo chown prometheus:prometheus /usr/local/bin/prometheus /usr/local/bin/promtool
sudo chown -R prometheus:prometheus /etc/prometheus /var/lib/prometheus

Erstellen Sie einen systemd-Dienst für Prometheus:

sudo nano /etc/systemd/system/prometheus.service

Fügen Sie folgenden Inhalt ein:

[Unit]
Description=Prometheus Monitoring System
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

Aktivieren und starten Sie Prometheus:

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

Prometheus ist nun unter http://your-server-ip:9090 erreichbar.

Schritt 2: Prometheus konfigurieren

Die primäre Konfigurationsdatei ist /etc/prometheus/prometheus.yml. Diese Datei definiert globale Einstellungen und die Scrape-Ziele, die Prometheus überwacht.

Grundlegendes Konfigurationsbeispiel:

global:
  scrape_interval: 15s        # Default scrape frequency
  evaluation_interval: 15s    # How often alerting rules are evaluated
  scrape_timeout: 10s

alerting:
  alertmanagers:
    - static_configs:
        - targets:
          - localhost:9093

rule_files:
  - "/etc/prometheus/rules/*.yml"

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

Validieren Sie nach der Änderung dieser Datei immer die Konfiguration, bevor Sie neu starten:

promtool check config /etc/prometheus/prometheus.yml
sudo systemctl restart prometheus

Schritt 3: Node Exporter für Systemmetriken installieren

Node Exporter stellt detaillierte Hardware- und OS-Metriken vom Hostsystem bereit – unverzichtbar für die Überwachung von CPU-Last, Arbeitsspeicherdruck, Festplattenauslastung und Netzwerkdurchsatz.

Node Exporter herunterladen und installieren:

wget https://github.com/prometheus/node_exporter/releases/download/v1.6.1/node_exporter-1.6.1.linux-amd64.tar.gz
tar -xvf node_exporter-1.6.1.linux-amd64.tar.gz
sudo cp node_exporter-1.6.1.linux-amd64/node_exporter /usr/local/bin/
sudo useradd --no-create-home --shell /bin/false node_exporter
sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter

Erstellen Sie einen systemd-Dienst für Node Exporter:

sudo nano /etc/systemd/system/node_exporter.service

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

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

[Install]
WantedBy=multi-user.target

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

Node Exporter stellt nun Metriken unter http://your-server-ip:9100/metrics bereit.

Node Exporter als Scrape-Ziel in prometheus.yml hinzufügen:

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

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

Starten Sie Prometheus neu und überprüfen Sie, ob das Ziel in der Prometheus-UI unter Status → Targets als UP angezeigt wird.

Schritt 4: Metriken mit Grafana visualisieren

Grafana verwandelt rohe Prometheus-Metriken in aussagekräftige, visuell ansprechende Dashboards. Es ist die Standard-Visualisierungsschicht für Prometheus-Bereitstellungen.

Grafana auf Ubuntu/Debian installieren:

sudo apt-get install -y apt-transport-https software-properties-common
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -
echo "deb https://packages.grafana.com/oss/deb stable main" | sudo tee /etc/apt/sources.list.d/grafana.list
sudo apt-get update
sudo apt-get install grafana
sudo systemctl enable grafana-server
sudo systemctl start grafana-server

Prometheus als Datenquelle verbinden:

1. Öffnen Sie Grafana unter http://your-server-ip:3000 (Standard-Anmeldedaten: admin / admin)
2. Navigieren Sie zu Configuration → Data Sources → Add data source
3. Wählen Sie Prometheus
4. Setzen Sie die URL auf http://localhost:9090
5. Klicken Sie auf Save & Test

Ein vorgefertigtes Dashboard importieren:

• Gehen Sie zu Dashboards → Import
• Geben Sie die Dashboard-ID 1860 (Node Exporter Full) aus dem Grafana-Marketplace ein
• Wählen Sie Ihre Prometheus-Datenquelle und klicken Sie auf Import

Sie erhalten sofort einen umfassenden Überblick über CPU-Auslastung, Arbeitsspeicherverbrauch, Disk I/O, Netzwerkstatistiken und Systemlast – alles in einem einzigen interaktiven Dashboard.

Schritt 5: Alerting-Regeln und Alertmanager konfigurieren

Das Prometheus-Alerting besteht aus zwei Teilen: Alerting-Regeln, die in Prometheus definiert werden, und dem Alertmanager, der die Weiterleitung und Zustellung übernimmt.

Eine Alerting-Regeldatei erstellen:

sudo mkdir -p /etc/prometheus/rules
sudo nano /etc/prometheus/rules/system_alerts.yml

groups:
  - name: system_alerts
    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: "High CPU usage on {{ $labels.instance }}"
          description: "CPU usage has exceeded 80% for more than 5 minutes. Current value: {{ $value }}%"

      - alert: LowDiskSpace
        expr: (node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) * 100 < 15
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "Low disk space on {{ $labels.instance }}"
          description: "Available disk space on / is below 15%. Immediate action required."

      - alert: HighMemoryUsage
        expr: (1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100 > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "High memory usage on {{ $labels.instance }}"
          description: "Memory usage has exceeded 85% for more than 5 minutes."

      - alert: InstanceDown
        expr: up == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Instance {{ $labels.instance }} is down"
          description: "Prometheus target {{ $labels.instance }} has been unreachable for more than 1 minute."

Die Regeldatei validieren:

promtool check rules /etc/prometheus/rules/system_alerts.yml

Alertmanager installieren und konfigurieren:

wget https://github.com/prometheus/alertmanager/releases/download/v0.26.0/alertmanager-0.26.0.linux-amd64.tar.gz
tar -xvf alertmanager-0.26.0.linux-amd64.tar.gz
sudo cp alertmanager-0.26.0.linux-amd64/alertmanager /usr/local/bin/
sudo mkdir /etc/alertmanager

Die Alertmanager-Konfiguration erstellen:

sudo nano /etc/alertmanager/alertmanager.yml

global:
  smtp_smarthost: 'smtp.yourdomain.com:587'
  smtp_from: 'alerts@yourdomain.com'
  smtp_auth_username: 'alerts@yourdomain.com'
  smtp_auth_password: 'your_password'

route:
  group_by: ['alertname', 'instance']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 4h
  receiver: 'email-notifications'

receivers:
  - name: 'email-notifications'
    email_configs:
      - to: 'admin@yourdomain.com'
        send_resolved: true

> Hinweis: Für professionellen E-Mail-Versand in Ihrer Alerting-Pipeline sollten Sie Prometheus mit AlexHost E-Mail-Hosting für eine zuverlässige SMTP-Infrastruktur kombinieren.

Erweiterte Konfiguration: Service Discovery

In dynamischen Umgebungen – wie Kubernetes-Clustern oder Auto-Scaling-Server-Flotten – werden statische Ziellisten schnell unhandhabbar. Prometheus unterstützt mehrere Service-Discovery-Mechanismen von Haus aus:

scrape_configs:
  - job_name: "kubernetes-pods"
    kubernetes_sd_configs:
      - role: pod
    relabel_configs:
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
        action: keep
        regex: true

Unterstützte Service-Discovery-Backends umfassen Kubernetes, Consul, EC2, Azure, GCE, DNS-basierte Discovery und dateibasierte Discovery – wodurch Prometheus an nahezu jede Infrastrukturtopologie anpassbar ist.

Prometheus-Anwendungsfälle

Prometheus eignet sich hervorragend für eine breite Palette von Monitoring-Szenarien:

Infrastruktur-Monitoring

Erfassen Sie Metriken auf Serverebene – CPU, Arbeitsspeicher, Festplatte, Netzwerk – von jedem Knoten in Ihrer Flotte. Ob Sie einen einzelnen Dedicated Server oder einen großen Cluster betreiben, Prometheus bietet einheitliche Sichtbarkeit über alle Hosts.

Application Performance Monitoring (APM)

Verfolgen Sie Anforderungsraten, Fehlerraten, Antwortlatenzen (die RED-Methode) und den Ressourcenverbrauch für Webanwendungen und APIs. Prometheus-Client-Bibliotheken sind für Go, Python, Java, Ruby, Node.js und mehr verfügbar.

Kubernetes- und Container-Monitoring

Prometheus integriert sich nativ mit Kubernetes über die kube-state-metrics– und cAdvisor-Exporters und bietet tiefe Einblicke in Pod-Gesundheit, Ressourcenkontingente, Bereitstellungsstatus und Metriken auf Cluster-Ebene.

Datenbank-Monitoring

Überwachen Sie Abfrageleistung, Verbindungspool-Auslastung, Replikationsverzögerung und Cache-Trefferquoten für Datenbanken wie PostgreSQL, MySQL und Redis mithilfe dedizierter Exporters.

Benutzerdefinierte Geschäftsmetriken

Instrumentieren Sie Ihre eigenen Anwendungen, um domänenspezifische Metriken bereitzustellen – wie verarbeitete Bestellungen pro Sekunde, aktive Benutzersitzungen oder Zahlungstransaktionsraten – und ermöglichen Sie so eine geschäftliche Beobachtbarkeit neben technischen Metriken.

GPU-Workload-Monitoring

Für Teams, die Machine-Learning- oder High-Performance-Computing-Workloads betreiben, kann Prometheus mit DCGM-Exporters integriert werden, um GPU-Auslastung, Arbeitsspeicher und Temperatur zu überwachen. Dies lässt sich gut mit AlexHost GPU Hosting für KI- und ML-Infrastruktur kombinieren.

Prometheus vs. alternative Monitoring-Lösungen

Best Practices für den Produktionsbetrieb

Die Bereitstellung von Prometheus in der Produktion erfordert Aufmerksamkeit für mehrere betriebliche Aspekte:

• Datenspeicherung: Der Standard-Aufbewahrungszeitraum beträgt 15 Tage. Passen Sie --storage.tsdb.retention.time basierend auf Ihrer Speicherkapazität und Compliance-Anforderungen an. Für die Langzeitspeicherung sollten Sie Thanos oder Cortex in Betracht ziehen.
• Sicherheit: Beschränken Sie den Zugriff auf die Prometheus-Web-UI und API mithilfe eines Reverse-Proxys (Nginx oder Caddy) mit Authentifizierung. Prometheus enthält keine integrierte Authentifizierung.
• Hochverfügbarkeit: Betreiben Sie mehrere Prometheus-Instanzen, die dieselben Ziele scrapen, für Redundanz. Verwenden Sie die Clustering-Funktion des Alertmanagers, um doppelte Benachrichtigungen zu verhindern.
• Kardinalitätsverwaltung: Vermeiden Sie hochkardinalige Labels (z. B. Benutzer-IDs, Anforderungs-IDs) in Metriknamen, da diese zu Speicher- und Leistungsproblemen führen können.
• TLS-Verschlüsselung: Aktivieren Sie TLS für Scrape-Endpunkte und die Prometheus-API. Kombinieren Sie dies mit einem SSL-Zertifikat, um die gesamte Kommunikation zwischen Prometheus-Komponenten zu sichern.
• Ressourcenplanung: Prometheus ist speicherintensiv. Weisen Sie ausreichend RAM basierend auf der Anzahl der aktiven Zeitreihen zu. Als Faustregel gilt ungefähr 1–2 Bytes pro Sample im Arbeitsspeicher.

Häufig gestellte Fragen

F: Was ist der Unterschied zwischen Prometheus und Grafana?

Prometheus ist das Monitoring- und Alerting-Backend – es erfasst, speichert und fragt Metriken ab. Grafana ist ein Visualisierungs-Frontend, das sich mit Prometheus (und anderen Datenquellen) verbindet, um Dashboards darzustellen. Sie sind komplementäre Werkzeuge, keine Alternativen.

F: Kann Prometheus Windows-Server überwachen?

Ja. Der Windows Exporter (früher WMI Exporter) stellt Windows-Systemmetriken in einem Prometheus-kompatiblen Format bereit und deckt CPU, Arbeitsspeicher, Festplatte, Netzwerk, IIS und mehr ab.

F: Wie handhabt Prometheus Hochverfügbarkeit?

Prometheus selbst ist dafür ausgelegt, als einzelne Instanz pro Cluster betrieben zu werden. Für HA betreiben Sie zwei identische Prometheus-Server, die dieselben Ziele scrapen. Alertmanager unterstützt natives Clustering, um Alarme über mehrere Prometheus-Instanzen hinweg zu deduplizieren.

F: Wofür wird PromQL verwendet?

PromQL (Prometheus Query Language) wird verwendet, um in Prometheus gespeicherte Zeitreihendaten abzufragen. Es unterstützt Instant-Abfragen, Range-Abfragen, Aggregationen, mathematische Operationen und Funktionen – und ermöglicht alles von einfachen Metrik-Lookups bis hin zu komplexen Anomalieerkennungsausdrücken.

Fazit

Prometheus ist eine bewährte, produktionsreife Monitoring-Lösung, die tiefe Echtzeit-Einblicke in den Zustand und die Leistung Ihres gesamten Infrastruktur-Stacks bietet. Seine Pull-basierte Architektur, das mehrdimensionale Datenmodell, die leistungsstarke PromQL-Abfragesprache und die nahtlosen Integrationen mit Tools wie Grafana und Alertmanager machen es zum Goldstandard für moderne Observability.

Ob Sie einen einzelnen Linux-Server, eine Flotte von Dedicated Servers, einen Kubernetes-Cluster oder eine komplexe Microservices-Anwendung überwachen – Prometheus skaliert, um Ihren Anforderungen gerecht zu werden. Indem Sie die Schritte in diesem Leitfaden befolgen – Prometheus installieren, Node Exporter bereitstellen, Grafana-Dashboards konfigurieren und intelligente Alerting-Regeln einrichten – erhalten Sie eine robuste Monitoring-Grundlage, die Ihnen hilft, Anomalien frühzeitig zu erkennen, schneller auf Vorfälle zu reagieren und die Systemzuverlässigkeit kontinuierlich zu verbessern.

Beginnen Sie mit den Grundlagen, iterieren Sie Ihre Dashboards und Alarmschwellenwerte, während Sie das normale Verhalten Ihres Systems kennenlernen, und erweitern Sie die Abdeckung schrittweise auf jede Schicht Ihres Stacks. Prometheus ist nicht nur ein Monitoring-Tool – es ist ein Eckpfeiler des modernen Site Reliability Engineering.