PROMETHEUS + GRAFANA MONITORING-ARCHITEKTUR Ziele node_exporter :9100 cAdvisor :8080 Abfrage Prometheus TSDB-Speicher PromQL-Engine Alarmregeln :9090 Alarme Alertmanager :9093 Abfrage Grafana Dashboards Panels & Graphen Alarmkontakte :3000 Ansicht Browser Echtzeit- Dashboards & Alarme

Zu wissen, was auf Ihren Servern passiert, ist nicht optional — es ist unverzichtbar. Ob Sie einen einzelnen VPS oder eine Flotte von Produktionsmaschinen verwalten, die Echtzeit-Transparenz ueber CPU-Auslastung, Speicherverbrauch, Festplatten-I/O und Netzwerkverkehr ist das, was proaktives Infrastrukturmanagement von reiner Brandbekaempfung unterscheidet. Prometheus und Grafana bilden zusammen den am weitesten verbreiteten Open-Source-Monitoring-Stack der Branche und treiben die Observability in Organisationen von Startups bis hin zu Grossunternehmen an.

Diese Anleitung fuehrt Sie durch den gesamten Prozess: Installation von Prometheus und node_exporter zum Sammeln von Systemmetriken, Einrichtung von Grafana zur Visualisierung, Schreiben von PromQL-Abfragen, Konfiguration der Alarmierung mit Alertmanager und Ueberwachung von Docker-Containern mit cAdvisor. Am Ende werden Sie einen vollstaendig funktionsfaehigen Monitoring-Stack auf Ubuntu betreiben.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

  • Einen Server mit Ubuntu 22.04 oder 24.04 (Desktop- oder Server-Edition)
  • Terminalzugang mit sudo-Berechtigungen
  • Mindestens 2 GB RAM und 20 GB freien Speicherplatz
  • Die Ports 9090 (Prometheus), 9100 (node_exporter), 3000 (Grafana) und 9093 (Alertmanager) verfuegbar
  • Grundlegende Vertrautheit mit der Linux-Kommandozeile und YAML-Syntax
  • Docker installiert (optional, fuer den cAdvisor-Abschnitt) — siehe unsere Docker-Installationsanleitung

Hinweis: Alle Befehle in dieser Anleitung gelten fuer Ubuntu auf der amd64-Architektur. Falls Sie ARM64 verwenden, passen Sie die Download-URLs an, um die linux-arm64-Binaervarianten zu verwenden.

Was sind Prometheus und Grafana?

Prometheus ist ein Open-Source-Toolkit fuer Systemueberwachung und Alarmierung, das urspruenglich 2012 bei SoundCloud entwickelt wurde. Es sammelt Metriken, indem es HTTP-Endpunkte in regelmaessigen Intervallen abfragt, speichert sie in einer Zeitreihendatenbank (TSDB) und bietet eine leistungsstarke Abfragesprache namens PromQL fuer die Analyse. Prometheus folgt einem Pull-Modell — es holt sich aktiv die Metriken von Ihren Servern, anstatt darauf zu warten, dass Daten gepusht werden.

Grafana ist eine Open-Source-Plattform fuer Analyse und interaktive Visualisierung. Sie verbindet sich mit Datenquellen wie Prometheus, Elasticsearch, InfluxDB und PostgreSQL, um Echtzeit-Dashboards mit Graphen, Tabellen, Heatmaps und Alarmen darzustellen. Grafana speichert selbst keine Daten; es fragt die zugrunde liegende Datenquelle bei Bedarf ab.

Zusammen bilden sie eine vollstaendige Monitoring-Pipeline:

  1. Exporter (wie node_exporter) stellen Metriken ueber HTTP-Endpunkte bereit
  2. Prometheus sammelt und speichert diese Metriken
  3. Grafana fragt Prometheus ab und stellt die Daten visuell dar
  4. Alertmanager verwaltet Benachrichtigungen, wenn Metriken definierte Schwellenwerte ueberschreiten

Ueberblick ueber die Monitoring-Architektur

Das Verstaendnis des Datenflusses ist entscheidend, bevor Sie den Stack bereitstellen:

┌─────────────────┐     scrape      ┌──────────────┐     query     ┌──────────────┐
│  node_exporter  │────────────────>│  Prometheus   │<─────────────│   Grafana    │
│  :9100          │  /metrics       │  :9090        │              │   :3000      │
└─────────────────┘                 │              │              │              │
                                    │  TSDB        │              │  Dashboards  │
┌─────────────────┐     scrape      │  PromQL      │              │  Panels      │
│  cAdvisor       │────────────────>│  Alert Rules  │              │  Alerts      │
│  :8080          │  /metrics       │              │              └──────────────┘
└─────────────────┘                 └──────┬───────┘
                                           │ fire alerts
                                    ┌──────▼───────┐
                                    │ Alertmanager  │──> Email / Slack / PagerDuty
                                    │ :9093         │
                                    └──────────────┘

Prometheus verwendet ein Pull-Modell: Es sendet periodisch HTTP-GET-Anfragen an konfigurierte Ziele (Exporter), um die neuesten Metriken abzurufen. Jeder Exporter stellt einen /metrics-Endpunkt bereit, der Daten im Prometheus-Exposition-Format zurueckgibt. Diese Architektur bedeutet, dass die Ziele nichts ueber Prometheus wissen muessen — sie liefern einfach ihre Metriken, wenn sie danach gefragt werden.

Prometheus installieren

Beginnen Sie mit der Erstellung eines dedizierten Systembenutzers und der notwendigen Verzeichnisse:

sudo useradd --no-create-home --shell /bin/false prometheus
sudo mkdir -p /etc/prometheus /var/lib/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

Laden Sie die neueste Prometheus-Version herunter (pruefen Sie prometheus.io/download fuer die aktuelle Version):

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

Kopieren Sie die Binaerdateien und Konfigurationsdateien:

sudo cp prometheus promtool /usr/local/bin/
sudo cp -r consoles console_libraries /etc/prometheus/
sudo cp prometheus.yml /etc/prometheus/
sudo chown -R prometheus:prometheus /etc/prometheus

Ueberpruefen Sie die Installation:

prometheus --version

Sie sollten eine Ausgabe sehen, die die Version, das Build-Datum und die Go-Version anzeigt.

Prometheus konfigurieren

Die Hauptkonfigurationsdatei ist /etc/prometheus/prometheus.yml. Diese YAML-Datei definiert globale Einstellungen, Scrape-Intervalle und Ziel-Endpunkte.

Erstellen Sie eine saubere Konfiguration:

sudo nano /etc/prometheus/prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s
  scrape_timeout: 10s

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"
    static_configs:
      - targets: ["localhost:9100"]

Wichtige Konfigurationsparameter:

  • scrape_interval: Wie oft Prometheus die Ziele abfragt (15 Sekunden ist der empfohlene Standardwert)
  • evaluation_interval: Wie oft Prometheus die Alarmregeln auswertet
  • scrape_timeout: Maximale Wartezeit fuer eine Scrape-Antwort, bevor das Ziel als nicht erreichbar markiert wird
  • job_name: Ein Label, das allen Metriken zugewiesen wird, die von den Zielen dieser Gruppe gesammelt werden
  • static_configs: Eine Liste von Ziel-Endpunkten, die abgefragt werden sollen

Erstellen Sie eine systemd-Service-Datei fuer Prometheus:

sudo nano /etc/systemd/system/prometheus.service
[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 \
  --web.enable-lifecycle
ExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure
RestartSec=5s

[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 sollte jetzt laufen und unter http://ihre-server-ip:9090 erreichbar sein.

node_exporter installieren und konfigurieren

node_exporter ist der Standard-Prometheus-Exporter fuer Hardware- und Betriebssystem-Metriken. Er stellt CPU-, Speicher-, Festplatten-, Dateisystem- und Netzwerkstatistiken auf Port 9100 bereit.

Erstellen Sie einen dedizierten Benutzer und laden Sie node_exporter herunter:

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

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

Erstellen Sie den systemd-Dienst:

sudo nano /etc/systemd/system/node_exporter.service
[Unit]
Description=Prometheus 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 \
  --collector.systemd \
  --collector.processes
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target

Aktivieren und starten Sie node_exporter:

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

Ueberpruefen Sie, ob Metriken bereitgestellt werden:

curl -s http://localhost:9100/metrics | head -20

Sie sollten Zeilen sehen, die mit # HELP und # TYPE beginnen, gefolgt von Metriknamen und -werten. Bestaetigen Sie, dass Prometheus node_exporter abfragt, indem Sie http://ihre-server-ip:9090/targets aufrufen — der node-Job sollte den Status UP anzeigen.

Grafana installieren

Fuegen Sie das offizielle Grafana-APT-Repository hinzu:

sudo apt-get install -y apt-transport-https software-properties-common wget
sudo mkdir -p /etc/apt/keyrings/

wget -q -O - https://apt.grafana.com/gpg.key | gpg --dearmor | sudo tee /etc/apt/keyrings/grafana.gpg > /dev/null

echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com stable main" | sudo tee /etc/apt/sources.list.d/grafana.list

Installieren und starten Sie Grafana:

sudo apt-get update
sudo apt-get install grafana -y
sudo systemctl daemon-reload
sudo systemctl enable grafana-server
sudo systemctl start grafana-server

Ueberpruefen Sie, ob Grafana laeuft:

sudo systemctl status grafana-server

Grafana ist jetzt unter http://ihre-server-ip:3000 erreichbar. Die Standard-Anmeldedaten sind admin / admin. Sie werden beim ersten Login aufgefordert, das Passwort zu aendern.

Sicherheit: Aendern Sie das Standard-Admin-Passwort sofort. Konfigurieren Sie Grafana in Produktionsumgebungen hinter einem Reverse-Proxy mit HTTPS.

Ihr erstes Dashboard erstellen

Nachdem Sie sich bei Grafana angemeldet haben, fuegen Sie Prometheus als Datenquelle hinzu:

  1. Navigieren Sie zu Connections > Data Sources > Add data source
  2. Waehlen Sie Prometheus
  3. Setzen Sie die URL auf http://localhost:9090
  4. Klicken Sie auf Save & Test — Sie sollten “Successfully queried the Prometheus API” sehen

Importieren Sie das weit verbreitete Node Exporter Full Dashboard:

  1. Navigieren Sie zu Dashboards > New > Import
  2. Geben Sie die Dashboard-ID 1860 ein (Node Exporter Full von rfmoz)
  3. Waehlen Sie Ihre Prometheus-Datenquelle
  4. Klicken Sie auf Import

Dieses Dashboard bietet umfassende Panels fuer CPU-Auslastung, Speichernutzung, Festplatten-I/O, Netzwerkverkehr, Dateisystemnutzung und Systemlast — alles ohne eine einzige Abfrage schreiben zu muessen.

Um ein benutzerdefiniertes Panel zu erstellen:

  1. Klicken Sie auf Add > Visualization in einem beliebigen Dashboard
  2. Geben Sie im Abfrage-Editor einen PromQL-Ausdruck ein, wie zum Beispiel:
100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)
  1. Dies berechnet die gesamte CPU-Auslastung in Prozent
  2. Konfigurieren Sie den Panel-Titel, die Legende, Schwellenwerte und das Einheitenformat
  3. Klicken Sie auf Apply, um das Panel zu speichern

PromQL-Grundlagen

PromQL (Prometheus Query Language) ist eine funktionale Abfragesprache, mit der Sie Zeitreihendaten auswaehlen, aggregieren und transformieren koennen. Das Verstaendnis von PromQL ist fuer den Aufbau nuetzlicher Dashboards und Alarmregeln unerlaesslich.

Instant Vectors geben den aktuellsten Wert fuer jede Zeitreihe zurueck:

node_memory_MemAvailable_bytes

Range Vectors geben Werte ueber ein Zeitfenster zurueck:

node_cpu_seconds_total[5m]

rate() berechnet die durchschnittliche Aenderungsrate pro Sekunde (unverzichtbar fuer Counter):

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

Aggregationsoperatoren kombinieren mehrere Zeitreihen:

# Durchschnittliche CPU-Auslastung ueber alle Kerne
avg without(cpu) (rate(node_cpu_seconds_total{mode="idle"}[5m]))

# Gesamtspeicher ueber alle Instanzen
sum by(instance) (node_memory_MemTotal_bytes)

# Top 5 Instanzen nach CPU-Auslastung
topk(5, 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100))

Mathematische Operationen ermoeglichen die Kombination von Metriken:

# Speichernutzung in Prozent
(1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100

# Festplattennutzung in Prozent
(1 - node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) * 100

Label-Filterung verwendet geschweifte Klammern:

# Nach bestimmter Instanz filtern
node_cpu_seconds_total{instance="server1:9100", mode!="idle"}

# Regex-Abgleich
node_filesystem_avail_bytes{mountpoint=~"/|/home"}

Alarmregeln einrichten

Prometheus wertet Alarmregeln im in der globalen Konfiguration definierten evaluation_interval aus. Wenn eine Regelbedingung erfuellt ist, sendet Prometheus einen Alarm an Alertmanager, der sich um Deduplizierung, Gruppierung und Weiterleitung an Benachrichtigungskanaele kuemmert.

Erstellen Sie eine Datei fuer Alarmregeln:

sudo nano /etc/prometheus/alert_rules.yml
groups:
  - name: system_alerts
    rules:
      - alert: HighCPUUsage
        expr: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Hohe CPU-Auslastung auf {{ $labels.instance }}"
          description: "Die CPU-Auslastung liegt seit mehr als 5 Minuten ueber 85% (aktueller Wert: {{ $value }}%)"

      - alert: HighMemoryUsage
        expr: (1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100 > 90
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Hohe Speicherauslastung auf {{ $labels.instance }}"
          description: "Die Speicherauslastung liegt seit mehr als 5 Minuten ueber 90% (aktueller Wert: {{ $value }}%)"

      - alert: DiskSpaceLow
        expr: (1 - node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) * 100 > 85
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "Wenig Speicherplatz auf {{ $labels.instance }}"
          description: "Die Nutzung des Root-Dateisystems liegt ueber 85% (aktueller Wert: {{ $value }}%)"

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

Validieren Sie die Regeldatei:

promtool check rules /etc/prometheus/alert_rules.yml

Installieren Sie nun Alertmanager:

cd /tmp
wget https://github.com/prometheus/alertmanager/releases/download/v0.27.0/alertmanager-0.27.0.linux-amd64.tar.gz
tar xvf alertmanager-0.27.0.linux-amd64.tar.gz

sudo useradd --no-create-home --shell /bin/false alertmanager
sudo mkdir -p /etc/alertmanager /var/lib/alertmanager
sudo cp alertmanager-0.27.0.linux-amd64/alertmanager /usr/local/bin/
sudo cp alertmanager-0.27.0.linux-amd64/amtool /usr/local/bin/
sudo chown alertmanager:alertmanager /usr/local/bin/alertmanager /usr/local/bin/amtool

Konfigurieren Sie Alertmanager:

sudo nano /etc/alertmanager/alertmanager.yml
global:
  resolve_timeout: 5m

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

receivers:
  - name: 'email-notifications'
    email_configs:
      - to: 'admin@example.com'
        from: 'alertmanager@example.com'
        smarthost: 'smtp.example.com:587'
        auth_username: 'alertmanager@example.com'
        auth_password: 'your-app-password'
        require_tls: true

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

Erstellen Sie den Alertmanager-systemd-Dienst:

sudo nano /etc/systemd/system/alertmanager.service
[Unit]
Description=Prometheus Alertmanager
Wants=network-online.target
After=network-online.target

[Service]
User=alertmanager
Group=alertmanager
Type=simple
ExecStart=/usr/local/bin/alertmanager \
  --config.file=/etc/alertmanager/alertmanager.yml \
  --storage.path=/var/lib/alertmanager/
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target
sudo systemctl daemon-reload
sudo systemctl enable alertmanager
sudo systemctl start alertmanager

Starten Sie Prometheus neu, um die neuen Alarmregeln zu uebernehmen:

sudo systemctl restart prometheus

Ueberpruefen Sie Ihre Alarme unter http://ihre-server-ip:9090/alerts und pruefen Sie Alertmanager unter http://ihre-server-ip:9093.

Docker-Container mit cAdvisor ueberwachen

cAdvisor (Container Advisor) liefert Metriken zur Ressourcennutzung und Leistung auf Container-Ebene. Er laeuft selbst als Docker-Container und stellt Metriken im Prometheus-Format bereit.

Starten Sie cAdvisor:

docker run -d \
  --name=cadvisor \
  --restart=always \
  --volume=/:/rootfs:ro \
  --volume=/var/run:/var/run:ro \
  --volume=/sys:/sys:ro \
  --volume=/var/lib/docker/:/var/lib/docker:ro \
  --volume=/dev/disk/:/dev/disk:ro \
  --publish=8080:8080 \
  --privileged \
  --device=/dev/kmsg \
  gcr.io/cadvisor/cadvisor:v0.49.1

Fuegen Sie cAdvisor als Prometheus-Scrape-Ziel in /etc/prometheus/prometheus.yml hinzu:

  - job_name: "cadvisor"
    static_configs:
      - targets: ["localhost:8080"]

Laden Sie Prometheus neu:

curl -X POST http://localhost:9090/-/reload

Nuetzliche cAdvisor-PromQL-Abfragen:

# CPU-Auslastung des Containers
rate(container_cpu_usage_seconds_total{name!=""}[5m])

# Speichernutzung des Containers
container_memory_usage_bytes{name!=""}

# Vom Container empfangene Netzwerk-Bytes
rate(container_network_receive_bytes_total{name!=""}[5m])

# Dateisystemnutzung des Containers
container_fs_usage_bytes{name!=""}

Importieren Sie das Grafana-Dashboard mit der ID 14282 (cAdvisor Exporter) fuer vorgefertigte Container-Monitoring-Panels.

Referenz nuetzlicher PromQL-Abfragen

AbfrageBeschreibung
upPruefen, ob Ziele erreichbar sind (1 = aktiv, 0 = nicht erreichbar)
rate(node_cpu_seconds_total{mode="idle"}[5m])CPU-Leerlaufrate pro Kern
node_memory_MemAvailable_bytes / 1024 / 1024Verfuegbarer Speicher in MB
(1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100Speichernutzung in Prozent
rate(node_disk_read_bytes_total[5m])Festplatten-Lesedurchsatz
rate(node_disk_written_bytes_total[5m])Festplatten-Schreibdurchsatz
rate(node_network_receive_bytes_total[5m])Eingehender Netzwerkverkehr
rate(node_network_transmit_bytes_total[5m])Ausgehender Netzwerkverkehr
node_filesystem_avail_bytes{mountpoint="/"}Verfuegbarer Speicherplatz auf Root
node_load1 / node_load5 / node_load15System-Lastdurchschnitte
rate(node_cpu_seconds_total{mode="iowait"}[5m])I/O-Wartezeit in Prozent
node_time_seconds - node_boot_time_secondsSystemlaufzeit in Sekunden
count(node_cpu_seconds_total{mode="idle"})Anzahl der CPU-Kerne
rate(container_cpu_usage_seconds_total{name!=""}[5m])CPU-Auslastung des Containers

Fehlerbehebung

Prometheus startet nicht:

Ueberpruefen Sie die Konfigurationssyntax:

promtool check config /etc/prometheus/prometheus.yml

Ueberpruefen Sie die Service-Logs:

sudo journalctl -u prometheus -f --no-pager

Haeufige Probleme sind YAML-Einrueckungsfehler, ungueltige Scrape-Intervalle und Berechtigungsprobleme bei /var/lib/prometheus.

Ziel wird in Prometheus als DOWN angezeigt:

Ueberpruefen Sie, ob der Exporter laeuft:

sudo systemctl status node_exporter
curl -v http://localhost:9100/metrics

Ueberpruefen Sie die Firewall:

sudo ufw status
sudo ufw allow 9100/tcp

Grafana kann sich nicht mit Prometheus verbinden:

Stellen Sie sicher, dass Prometheus auf der richtigen Adresse lauscht. Wenn Grafana und Prometheus auf demselben Server laufen, verwenden Sie http://localhost:9090. Ueberpruefen Sie die Konnektivitaet:

curl http://localhost:9090/api/v1/query?query=up

Keine Daten in Grafana-Panels:

Ueberpruefen Sie den Zeitbereichswaehler im Dashboard. Der Standardwert koennte ausserhalb Ihres Daten-Aufbewahrungsfensters liegen. Stellen Sie ausserdem sicher, dass die Prometheus-Datenquelle im Panel-Abfrage-Editor ausgewaehlt ist.

Hoher Speicherverbrauch durch Prometheus:

Reduzieren Sie die Anzahl der Zeitreihen, indem Sie Exporter einschraenken oder Metrik-Relabeling-Regeln hinzufuegen. Ueberpruefen Sie den aktuellen Speicherverbrauch und die Anzahl der Zeitreihen:

curl http://localhost:9090/api/v1/status/tsdb

Erwaegen Sie, die Aufbewahrungszeit zu verringern:

--storage.tsdb.retention.time=15d

Alertmanager sendet keine Benachrichtigungen:

Testen Sie die Alertmanager-Konfiguration:

amtool check-config /etc/alertmanager/alertmanager.yml

Senden Sie einen Testalarm:

amtool alert add alertname=TestAlert severity=critical --alertmanager.url=http://localhost:9093

Zusammenfassung

Sie verfuegen jetzt ueber einen vollstaendigen Monitoring-Stack auf Ihrem Server: Prometheus sammelt Metriken von node_exporter und cAdvisor, Grafana stellt Echtzeit-Dashboards dar, und Alertmanager liefert Benachrichtigungen, wenn etwas schiefgeht. Dieses Setup bietet Ihnen tiefe Einblicke in den Systemzustand, die Container-Leistung und die Ressourcenauslastung.

Wichtige Erkenntnisse aus dieser Anleitung:

  • Prometheus fragt Metriken von Zielen in regelmaessigen Intervallen ab und speichert sie in einer Zeitreihendatenbank
  • node_exporter liefert Metriken auf Systemebene (CPU, Speicher, Festplatte, Netzwerk)
  • Grafana visualisiert Metriken mit anpassbaren Dashboards und Panels
  • PromQL ist die Abfragesprache zum Auswaehlen, Filtern und Aggregieren von Metriken
  • Alertmanager leitet Alarme an E-Mail, Slack, PagerDuty oder andere Benachrichtigungskanaele weiter
  • cAdvisor stellt Ressourcenmetriken auf Container-Ebene fuer Docker-Umgebungen bereit

Stellen Sie fuer die Grundlage, auf der dieser Monitoring-Stack laeuft, sicher, dass Ihr Server ordnungsgemaess abgesichert ist, indem Sie unsere Linux-Server-Sicherheitscheckliste befolgen. Falls Sie Docker fuer den cAdvisor-Abschnitt noch nicht eingerichtet haben, folgen Sie unserer Docker-Installationsanleitung fuer Ubuntu.

Wenn Ihre Infrastruktur waechst, erkunden Sie Prometheus Federation fuer Multi-Server-Setups, Grafana Loki fuer die Log-Aggregation und Thanos oder Cortex fuer Langzeitspeicherung und Hochverfuegbarkeit.