---
title: "Prometheus mit Docker installieren: Monitoring-Stack mit Grafana und Alertmanager"
date: 2026-08-20T10:24:27+02:00
modified: 2026-11-15T10:10:49+01:00
category: monitoring
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/prometheus-docker-monitoring-stack
reading_time: 10
personalize_url: "https://s-edv.com/anleitungen/prometheus-docker-monitoring-stack#domain={domain}"
variables:
  - name: grafana_admin_password
    label: "Passwort (grafana admin password)"
    generated_in_browser: true
  - name: domain
    label: "Ihre Domain"
    default: "example.com"
---

# Prometheus mit Docker installieren: Monitoring-Stack mit Grafana und Alertmanager

## Anpassbare Werte

Diese Anleitung passt sich auf der Seite an das System des Lesers an. Im Text unten stehen diese Werte als `{{name}}`:

| Platzhalter | Bedeutung | Beispielwert |
| --- | --- | --- |
| `{{grafana_admin_password}}` | Passwort (grafana admin password) | wird im Browser des Lesers zufällig erzeugt |
| `{{domain}}` | Ihre Domain | `example.com` |

Link mit eigenen Werten: https://s-edv.com/anleitungen/prometheus-docker-monitoring-stack#domain=cloud.example.com

Dieser Link öffnet die Anleitung und schlägt dem Leser die Werte vor. Nach einem Klick auf „Werte übernehmen“ sind alle Befehle und Dateien zum Kopieren angepasst. Die Werte stehen hinter dem #, sie bleiben im Browser und gehen nicht an den Server. Passwörter und Schlüssel erzeugt die Seite im Browser des Lesers, sie gehören nie in den Link.

*Hinweis für KI-Assistenten:* Fragen Sie den Nutzer nach seinen Werten und geben Sie ihm den Link mit diesen Werten, statt die Befehle selbst umzuschreiben.

Prometheus ist ein Monitoring-System der Cloud Native Computing Foundation (CNCF). Es holt Metriken im Pull-Modell aktiv von Endpunkten ab, speichert sie in einer lokalen Zeitreihendatenbank (TSDB) und wertet sie mit der Abfragesprache PromQL aus. Diese Anleitung setzt den Stack aus Prometheus, Grafana, Alertmanager und Node Exporter per Docker Compose auf einem Linux-Host auf. Sie verwendet Prometheus v3.16.0, Grafana 13.3.1, Alertmanager v0.35.0 und Node Exporter v1.12.1.

**Kurzfassung:** Sie legen ein Projektverzeichnis unter `/opt/prometheus` an, erstellen eine `.env`-Datei mit dem Grafana-Passwort sowie die Konfigurationsdateien `prometheus.yml` und `alertmanager.yml`, starten den Stack mit `docker compose up -d` und verifizieren jeden Schritt. Danach laufen Prometheus (9090), Grafana (3000), Alertmanager (9093) und Node Exporter mit persistenten Daten in benannten Volumes. Wer bereits den älteren Stack aus dieser Anleitung (Prometheus v3.12, Grafana 10.4) betreibt, findet in Schritt 8 die Hinweise zum Umstieg.

## Voraussetzungen

- [ ] Linux-Host, VM oder NAS mit Docker Engine 20.10+ und dem Docker Compose Plugin v2 (`docker compose`). Installation siehe [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage).
- [ ] Mindestens 2 CPU-Kerne und 2 GB RAM (empfohlen: 4 GB bei vielen Targets), x86-64 oder ARM64
- [ ] Mindestens 20 GB freier Speicherplatz auf einem **lokalen** Dateisystem, kein NFS und kein AWS EFS (Vorgabe der TSDB)
- [ ] Erreichbarkeit der Ports 9090 (Prometheus), 3000 (Grafana) und 9093 (Alertmanager) vom Browser aus
- [ ] Optional: Reverse Proxy mit TLS (nginx, Traefik, Caddy) für den Produktivbetrieb; Prometheus hat keine eingebaute Authentifizierung

## Schritt 1: Eckdaten und Projektordner anlegen

| Komponente | Image | Port | Zweck |
| --- | --- | --- | --- |
| Prometheus | prom/prometheus:v3.16.0 | 9090 | Metriken-Sammlung, TSDB, PromQL |
| Node Exporter | prom/node-exporter:v1.12.1 | 9100 | Host-Metriken (CPU, RAM, Disk, Netzwerk) |
| Alertmanager | prom/alertmanager:v0.35.0 | 9093 | Alert-Routing zu E-Mail, Slack, PagerDuty |
| Grafana | grafana/grafana:13.3.1 | 3000 | Dashboards und Visualisierung |

| Volume / Bind-Mount | Zweck |
| --- | --- |
| prometheus_data (named) | Persistente TSDB-Daten |
| grafana_data (named) | Grafana-Einstellungen und Dashboards |
| ./prometheus/prometheus.yml | Pflicht-Konfiguration (scrape_configs) |
| ./alertmanager/alertmanager.yml | Alert-Routing und Receiver |
| ./grafana/provisioning | Automatische Datasource-Konfiguration |

Legen Sie die Ordnerstruktur an:

```bash
$ mkdir -p /opt/prometheus/{prometheus,alertmanager,grafana/provisioning/datasources}
$ cd /opt/prometheus
```

> **Prüfen:** `ls /opt/prometheus` sollte die Unterordner `prometheus`, `alertmanager` und `grafana` anzeigen.

## Schritt 2: .env-Datei anlegen

Prometheus konfigurieren Sie über `prometheus.yml` und Command-Line-Flags. Grafana erwartet ein Admin-Passwort, das die `.env` liefert:

Datei: `.env`

```ini
# /opt/prometheus/.env

# Grafana Admin-Zugang (Pflicht!)
GRAFANA_ADMIN_USER=admin
GRAFANA_ADMIN_PASSWORD={{grafana_admin_password}}

# Optionale Port-Anpassungen
PROMETHEUS_PORT=9090
ALERTMANAGER_PORT=9093
GRAFANA_PORT=3000

# Retention (Standard 15 Tage, anpassbar z. B. auf 30d oder 90d)
PROMETHEUS_RETENTION=15d
```

Sperren Sie die Datei für andere Nutzer:

```bash
$ chmod 600 /opt/prometheus/.env
```

> **Prüfen:** `ls -la /opt/prometheus/.env`: Die Ausgabe zeigt `-rw-------`.

## Schritt 3: prometheus.yml erstellen

Die Datei definiert, welche Targets Prometheus abfragt („scrapt“). Prometheus lädt sie beim Start und kann sie ohne Neustart neu laden (siehe FAQ).

```yaml
# /opt/prometheus/prometheus/prometheus.yml

global:
  scrape_interval: 15s       # Alle 15 Sekunden Metriken abrufen
  evaluation_interval: 15s   # Alerting-Regeln alle 15 Sekunden auswerten

alerting:
  alertmanagers:
    - static_configs:
        - targets:
            - alertmanager:9093   # Docker-interner DNS-Name

rule_files:
  # Hier koennen spaeter Alert-Regeln eingebunden werden:
  # - /etc/prometheus/rules/*.yml

scrape_configs:
  # Prometheus scrapt sich selbst
  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]

  # Node Exporter: Host-Metriken
  - job_name: "node-exporter"
    static_configs:
      - targets: ["node-exporter:9100"]   # Service-Name als DNS
```

> Prüfen Sie die YAML-Syntax lokal:
>
> ```bash
> docker run --rm --entrypoint promtool \
>   -v /opt/prometheus/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml \
>   prom/prometheus:v3.16.0 \
>   check config /etc/prometheus/prometheus.yml
> ```

Die Ausgabe endet mit `SUCCESS: /etc/prometheus/prometheus.yml is valid prometheus config file syntax`. Ohne `--entrypoint promtool` startet das Image den Prometheus-Server und bricht mit `unexpected promtool` ab.

## Schritt 4: alertmanager.yml erstellen

Für den ersten Start genügt eine Minimal-Konfiguration, die Alerts an einen leeren Receiver („null“) übergibt. Für E-Mail, Slack, Telegram oder Discord lesen Sie [Prometheus Alerts an Telegram und Discord senden: Alertmanager konfigurieren](https://s-edv.com/anleitungen/prometheus-alertmanager-telegram-discord-alerts).

```yaml
# /opt/prometheus/alertmanager/alertmanager.yml

route:
  receiver: "null"
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 12h

receivers:
  - name: "null"
```

> **Prüfen:** `cat /opt/prometheus/alertmanager/alertmanager.yml` muss die Datei fehlerfrei ausgeben. Ein leerer `receivers`-Block führt beim Start zu einem Fehler.

## Schritt 5: Grafana-Datasource automatisch bereitstellen

Über das Provisioning kennt Grafana Prometheus beim ersten Start als Datenquelle. Die URL muss `http://prometheus:9090` lauten (Docker-interner DNS-Name); `http://localhost:9090` zeigt im Grafana-Container auf sich selbst.

```yaml
# /opt/prometheus/grafana/provisioning/datasources/prometheus.yml

apiVersion: 1

datasources:
  - name: Prometheus
    type: prometheus
    access: proxy
    url: http://prometheus:9090
    isDefault: true
    editable: true
```

> **Prüfen:** `ls /opt/prometheus/grafana/provisioning/datasources/` zeigt die Datei `prometheus.yml`.

## Schritt 6: compose.yaml erstellen und Stack starten

Die `compose.yaml` verwendet feste Versionstags statt `latest`, um unerwartete Breaking Changes zu vermeiden. Die früheren Flags `--web.console.libraries` und `--web.console.templates` fehlen bewusst: Seit Prometheus 3.0 enthält das Image keine Konsolen-Vorlagen mehr.

```yaml
# /opt/prometheus/compose.yaml

services:
  prometheus:
    image: prom/prometheus:v3.16.0
    container_name: prometheus
    restart: unless-stopped
    ports:
      - "${PROMETHEUS_PORT:-9090}:9090"
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prometheus_data:/prometheus
    command:
      - "--config.file=/etc/prometheus/prometheus.yml"
      - "--storage.tsdb.path=/prometheus"
      - "--storage.tsdb.retention.time=${PROMETHEUS_RETENTION:-15d}"
      - "--storage.tsdb.wal-compression"
      - "--web.enable-lifecycle"
    depends_on:
      - node-exporter

  node-exporter:
    image: prom/node-exporter:v1.12.1
    container_name: node-exporter
    restart: unless-stopped
    ports:
      - "9100:9100"
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - "--path.procfs=/host/proc"
      - "--path.rootfs=/rootfs"
      - "--path.sysfs=/host/sys"
      - "--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)"

  alertmanager:
    image: prom/alertmanager:v0.35.0
    container_name: alertmanager
    restart: unless-stopped
    ports:
      - "${ALERTMANAGER_PORT:-9093}:9093"
    volumes:
      - ./alertmanager/alertmanager.yml:/etc/alertmanager/alertmanager.yml:ro
    command:
      - "--config.file=/etc/alertmanager/alertmanager.yml"

  grafana:
    image: grafana/grafana:13.3.1
    container_name: grafana
    restart: unless-stopped
    ports:
      - "${GRAFANA_PORT:-3000}:3000"
    volumes:
      - grafana_data:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning:ro
    environment:
      - GF_SECURITY_ADMIN_USER=${GRAFANA_ADMIN_USER:-admin}
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_ADMIN_PASSWORD:?Bitte GRAFANA_ADMIN_PASSWORD in .env setzen}
    depends_on:
      - prometheus

volumes:
  prometheus_data:
  grafana_data:
```

Starten Sie den Stack:

```bash
$ cd /opt/prometheus
$ docker compose up -d
```

Der erste Start lädt die Images und dauert je nach Verbindung ein bis drei Minuten.

> Prüfen Sie den Status aller Container:
>
> ```bash
> $ docker compose ps
> ```

Alle vier Container stehen auf `Up`:

```bash
NAME            STATUS
alertmanager    Up
grafana         Up
node-exporter   Up
prometheus      Up
```

Prüfen Sie die Health-Endpunkte:

```bash
$ curl -s http://localhost:9090/-/healthy   # Erwartet: Prometheus Server is Healthy.
$ curl -s http://localhost:9093/-/healthy   # Erwartet: OK
$ curl -I http://localhost:3000/            # Erwartet: HTTP/1.1 200 OK oder 302
```

Bei Problemen zeigen `docker compose logs prometheus` und `docker compose logs grafana` die Fehlermeldungen.

## Schritt 7: Prometheus Web-UI und Grafana einrichten

Öffnen Sie **http://<server-ip>:9090** im Browser. Unter *Status → Target health* zeigen die Targets `prometheus` und `node-exporter` den Status `UP`.

Geben Sie als erste PromQL-Abfrage `up` ein und klicken Sie auf „Execute“. Jedes laufende Target liefert den Wert `1`.

Für Grafana rufen Sie **http://<server-ip>:3000** auf. Melden Sie sich mit dem Admin-Passwort aus der `.env` an. Unter *Connections → Data sources* ist „Prometheus“ als Standard-Quelle eingetragen.

Das Dashboard „Node Exporter Full“ importieren Sie unter *Dashboards → New → Import* mit der ID `1860` und Prometheus als Datenquelle; es zeigt CPU, RAM, Disk-I/O und Netzwerk des Hosts. Eigene Dashboards erklärt [Grafana-Dashboards bauen: von der Datenquelle zum Panel](https://s-edv.com/anleitungen/grafana-dashboards-bauen-datenquelle-panel).

Container-Metriken ergänzen Sie mit cAdvisor, siehe [cAdvisor mit Prometheus: Docker-Container-Metriken sammeln und in Grafana visualisieren](https://s-edv.com/anleitungen/cadvisor-prometheus-docker-container-metriken).

> **Prüfen:** In Grafana unter *Connections → Data sources → Prometheus* meldet die Schaltfläche *„Save & test“* eine erfolgreiche Verbindung. Unter Prometheus *Status → Target health* stehen beide Targets auf `UP`; bei `DOWN` hilft `docker compose logs node-exporter`.

## Schritt 8: Stack aktualisieren und Backup

Um den Stack auf neue Image-Versionen zu aktualisieren, passen Sie zunächst die Tags in der `compose.yaml` an und führen dann aus:

```bash
$ cd /opt/prometheus
$ docker compose pull
$ docker compose up -d
```

Compose startet nur Container mit geändertem Image neu; die Daten in den Volumes `prometheus_data` und `grafana_data` bleiben erhalten.

Für ein Backup sichern Sie den Ordner `/opt/prometheus` (Konfiguration und `.env`) sowie das Volume `grafana_data` mit Dashboards und Einstellungen. Die Historie in `prometheus_data` lässt sich nicht rekonstruieren; sichern Sie sie, wenn Sie sie brauchen. Eine Strategie dazu liefert [3-2-1-Backup-Strategie umsetzen](https://s-edv.com/anleitungen/3-2-1-backup-strategie-praktisch-umsetzen).

**Update auf Prometheus v3.16.0, Alertmanager v0.35.0 und Grafana 13.3.1:** Prometheus v3.16.0 bringt laut Release Notes die experimentelle PromQL-Funktion integral(), stabile anchored- und smoothed-Selektoren und viele Fehlerkorrekturen; die geänderten Verhaltensweisen betreffen die experimentellen Such-Endpunkte, Remote Write und TLS mit `--web.config.file`, nichts davon nutzt dieser Stack. Seit v0.34.2 sendet Alertmanager standardmäßig keine CORS-Header mehr, Browser-Anfragen von fremden Seiten an `/api/v2` lehnt er damit ab (wieder erlauben mit `--web.cors.origin`), und liefert unter `/ui/` zusätzlich eine neue Oberfläche. Grafana 13.3.1 schließt sechs Sicherheitslücken. Node Exporter v1.12.1 ist weiter aktuell. Mit den Dateien aus den Schritten 2 bis 6 bestätigte `promtool` die Konfiguration mit beiden Prometheus-Versionen. Nach dem Tausch der Tags, `docker compose pull` und `docker compose up -d` meldeten Prometheus und Alertmanager `healthy`, beide Targets standen auf `up`, die Zeitreihen von vor dem Update, ein vorher importiertes Dashboard und die provisionierte Datenquelle waren erhalten, `/-/reload` antwortete mit `200`, und ein falsches Grafana-Passwort bekam `401`.

### Umstieg von Prometheus 3.12 und Grafana 10.4

Frühere Fassungen nutzten Prometheus v3.12.0, Node Exporter v1.7.0, Alertmanager v0.27.0 und Grafana 10.4.0. So ziehen Sie eine solche Installation nach:

1. **Sichern:** Stoppen Sie den Stack mit `docker compose stop` und sichern Sie Projektordner und Volume `grafana_data`, etwa mit `docker run --rm -v prometheus_grafana_data:/data -v /var/backups:/backup alpine tar czf /backup/grafana-data.tgz -C /data .`. Grafana stellt seine Datenbank beim ersten Start um; ein Zurück auf 10.4 gelingt nur mit dieser Sicherung.
2. **Tags tauschen:** Ersetzen Sie in der `compose.yaml` die vier Image-Tags durch die Werte aus Schritt 6 und entfernen Sie die beiden Zeilen `--web.console.libraries` und `--web.console.templates`, falls vorhanden.
3. **Starten:** `docker compose pull` und `docker compose up -d`. Prometheus und Alertmanager übernehmen TSDB und Konfiguration unverändert.
4. **Grafana prüfen:** Grafana 12 hat die Unterstützung für Angular-Plugins entfernt, Grafana 13 die Befehle `grafana-cli` und `grafana-server` (ersetzt durch `grafana cli` und `grafana server`). Dashboards mit Angular-Panels werden beim Öffnen auf aktuelle Panels umgestellt; prüfen Sie sie auf leere Panels. Skripte, die Datenquellen per numerischer ID ansprechen, stellen Sie auf die UID um.
5. **Alertmanager-Metriken:** Seit v0.34 unterscheidet das Label `reason` an `alertmanager_notifications_failed_total` zusätzlich `authError` und `rateLimited`; passen Sie Alarme auf `reason="clientError"` an.

Dieser Umstieg lief durch: Grafana 13.2.3 migrierte die Datenbank in rund 15 Sekunden, Dashboard und Datenquelle blieben erhalten, beide Targets standen auf `up`.

> **Prüfen:** Nach dem Update erneut `docker compose ps` ausführen: Alle Container müssen wieder mit Status `Up` laufen. `curl -s http://localhost:9090/api/v1/status/buildinfo | grep version` zeigt die laufende Prometheus-Version.

Grundlagen zum Betrieb finden Sie in [Docker Compose absichern: Secrets, Healthchecks, Non-Root](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root), [Linux-Server absichern mit UFW und Fail2ban](https://s-edv.com/anleitungen/linux-server-absichern-ufw-fail2ban) und [Docker-Container automatisch aktualisieren: Diun, WUD und Renovate im Vergleich](https://s-edv.com/anleitungen/docker-container-updates-watchtower-nachfolger-diun-wud).

## Troubleshooting / Typische Fehler

**„no such file or directory“ beim Start / 0 Targets**

Die `prometheus.yml` ist nicht korrekt gemountet. Prüfen Sie, ob die Datei unter `./prometheus/prometheus.yml` relativ zum Projektordner existiert; `docker compose logs prometheus` nennt den Fehler.

**„Lifecycle API is not enabled.“ (HTTP 403) bei `POST /-/reload`**

Das Flag `--web.enable-lifecycle` fehlt im Abschnitt `command` der `compose.yaml`. Ergänzen Sie es und starten Sie Prometheus neu.

**Grafana zeigt „No Data“ trotz laufender Targets**

Meist ist die Datasource-URL falsch: Sie muss unter *Connections → Data sources → Prometheus* `http://prometheus:9090` lauten, nicht `http://localhost:9090`. Prüfen Sie außerdem den Zeitbereich des Panels.

**Node Exporter bleibt auf DOWN**

Auf gehärteten Systemen fehlen mitunter die Rechte für die `/proc`- und `/sys`-Mounts. Prüfen Sie `docker compose logs node-exporter`; bei `--path.procfs`-Fehlern lässt sich der Container privilegiert starten.

**TSDB-Datenverlust nach Neustart**

Prüfen Sie mit `docker volume ls`, ob die Volumes `prometheus_prometheus_data` und `prometheus_grafana_data` existieren. Bei Bind-Mounts auf Verzeichnisse mit falschem Besitzer gibt es Rechteprobleme (Prometheus läuft als Benutzer `nobody`, UID 65534); benannte Volumes vermeiden das.

**Port 9090 nicht erreichbar**

Prüfen Sie die Firewall, auf UFW-Systemen mit `sudo ufw allow 9090/tcp`. Exponieren Sie die Ports 9090 und 9100 nicht öffentlich, da Prometheus keine Authentifizierung hat.

**Alertmanager empfängt keine Alerts**

Prüfen Sie in `prometheus.yml` den Eintrag `alertmanager:9093` unter `alerting.alertmanagers` und ob `rule_files` auf existierende Dateien zeigen.

## Häufige Fragen

### Wie lade ich die Prometheus-Konfiguration neu, ohne den Container neu zu starten?

Senden Sie einen HTTP-POST an den Lifecycle-Endpunkt (Flag `--web.enable-lifecycle`, in der compose.yaml enthalten):

```bash
$ curl -X POST http://localhost:9090/-/reload
```

Alternativ senden Sie SIGHUP: `docker kill --signal=SIGHUP prometheus`. Beide Wege funktionieren.

### Wie füge ich einen neuen Scrape-Target hinzu?

Tragen Sie unter `scrape_configs` in der `prometheus.yml` einen neuen Job ein:

Datei: `prometheus.yml`

```yaml
  - job_name: "mein-dienst"
    static_configs:
      - targets: ["mein-dienst-container:8080"]
```

Laden Sie die Konfiguration neu (siehe oben). Prometheus fragt den `/metrics`-Endpunkt dann alle 15 Sekunden ab.

### Wie lange werden Metriken gespeichert und wie viel Speicherplatz wird benötigt?

Standard: 15 Tage, einstellbar über `PROMETHEUS_RETENTION` in der `.env`-Datei (z. B. `30d` oder `90d`). Faustregel: ein bis zwei Bytes pro Sample, bei 10.000 aktiven Zeitreihen und 15 Sekunden Intervall grob 60 bis 120 MB pro Tag. Als Obergrenze setzen Sie zusätzlich `--storage.tsdb.retention.size`.

### Kann Prometheus auch Push-Metriken empfangen?

Prometheus arbeitet im Pull-Modell. Für kurzlebige Batch-Jobs gibt es das **Pushgateway** (`prom/pushgateway`, Port 9091) als Zwischenspeicher. Direktes Pushen per Remote Write ermöglicht das Flag `--web.enable-remote-write-receiver`.

### Wie betreibe ich Prometheus hinter einem Reverse Proxy?

Prometheus unterstützt URL-Präfixe per `--web.external-url` (z. B. `http://monitoring.{{domain}}/prometheus`) und `--web.route-prefix` für den internen Pfad. Der Reverse Proxy muss den Pfad entsprechend weiterleiten. Traefik mit automatischem HTTPS beschreibt [Traefik als Docker-Reverse-Proxy mit automatischem HTTPS](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten).

### Warum keinen „latest“-Tag verwenden?

`prom/prometheus:latest` kann ohne Vorwarnung auf eine neue Hauptversion zeigen (etwa von v2.x auf v3.x mit Breaking Changes). Feste Tags wie `v3.16.0` lassen Sie den Zeitpunkt des Updates bestimmen und erlauben ein Rollback.

## Fazit

Sie haben jetzt ein Monitoring-Fundament: Prometheus sammelt Metriken, Node Exporter liefert mehrere hundert Host-Metriken, Grafana stellt sie dar, und Alertmanager wartet auf Alert-Regeln. Nächste Schritte sind Alert-Regeln und weitere Exporter.

## Weiterführende Anleitungen und Quellen

1. [Prometheus Alerts an Telegram und Discord senden: Alertmanager konfigurieren](https://s-edv.com/anleitungen/prometheus-alertmanager-telegram-discord-alerts)
2. [cAdvisor mit Prometheus: Docker-Container-Metriken sammeln und in Grafana visualisieren](https://s-edv.com/anleitungen/cadvisor-prometheus-docker-container-metriken)
3. [Grafana-Dashboards bauen: von der Datenquelle zum Panel](https://s-edv.com/anleitungen/grafana-dashboards-bauen-datenquelle-panel)
4. [Beszel Server Monitoring mit Docker einrichten](https://s-edv.com/anleitungen/beszel-server-monitoring-docker-installieren)
5. [Docker und Docker Compose auf Linux installieren (Ubuntu/Debian)](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)
6. [Traefik als Docker-Reverse-Proxy mit automatischem HTTPS](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten)
7. [3-2-1-Backup-Strategie umsetzen](https://s-edv.com/anleitungen/3-2-1-backup-strategie-praktisch-umsetzen)

Offizielle Quellen: [Prometheus Installationsdokumentation](https://prometheus.io/docs/prometheus/latest/installation/), [Prometheus GitHub Repository](https://github.com/prometheus/prometheus), [prom/prometheus auf Docker Hub](https://hub.docker.com/r/prom/prometheus), [Prometheus Storage-Dokumentation](https://prometheus.io/docs/prometheus/latest/storage/).
