<!--{"title": "Push-Dienst NTFY mit Prometheus und Grafana selber hosten", "date": "2025-03-14", "slug": "push-dienst-ntfy-mit-prometheus-und-grafana-selber-hosten", "cover": "/static/img/push-dienst-ntfy-mit-prometheus-und-grafana-selber-hosten.webp"}-->
> Kennzeichnung gemäß Artikel 52 Absatz 1 EU AI Act: [💜 <ins>Kein Einsatz von KI</ins>](/page/ai)

**Ihr möchtet einen zuverlässigen Push-Dienst und das ab besten selber bereitstellen?
Ihr legt Wert darauf, einen guten Überblick über den Dienst zu haben? Dann wird euch dieser Artikel gefallen.**

Ich stelle euch die Software NTFY vor, mit der ihr in Zusammenarbeit mit Prometheus und Grafana einen idealen Push-Dienst für eure Anwendungen bekomme. Insbesondere mit einer Überwachungssoftware wie Uptime-Kuma macht ein Push-Dienst auf jeden Fall Sinn.

Aber fangen wir am Anfang an.

## Vorbereitung
Wir setzen hier eine Vorkonfigurierte Docker-Umgebung voraus. Wenn Ihr eine Anleitung dafür benötigt, schaut gerne meinen Artikel [Traefik richtig im Homelab oder Unternehmen mit eigenen Zertifikaten einrichten](/post/traefik-richtig-im-homelab-oder-unternehmen-mit-eigenen-zertifikaten-einrichten) an.
Dort ist der Vorgang ausführlich beschrieben.

Wir benötigen für dieses Projekt insgesamt vier Container.

* Traefik (als Reverseproxy für HTTPS)
* NTFY (der Push-Dienst)
* Prometheus (der Dienst zum Sammeln der Metriken)
* Grafana (der Dienst zum Anzeigen und aufbereiten der Prometheus Daten)

Zudem werden wir einen Container namens Dockge nutzen, um unseren Stack zu Konfigurieren. Auch die Einrichtung dieses Containers finden Sie im o.g. Artikel.

## Vorbereitung des Dateisystems

Zuerst bereiten wir unser Dateisystem für den Einsatz vor.
Wir erstellen unser Basisverzeichnis, sofern nicht bereits von Vorgängerprojekten vorhanden. Führen Sie folgendes Kommando in Ihrer Ubuntu-Konsole aus:

```
mkdir /docker && mkdir /docker/push && mkdir /docker/push/ntfy && /docker/push/ntfy/cache && /docker/push/ntfy/etc && mkdir /docker/push/prometheus && mkdir /docker/push/grafana
```

Wir beginnen mit der Prometheus-Konfiguration. Führen Sie folgendes Kommando in Ihrer Ubuntu-Konsole aus: ```nano /docker/push/prometheus/prometheus.yml``` und fügen folgenden Inhalt ein:

```
scrape_configs:
 - job_name: "ntfy"
   static_configs:
     - targets: ["status.ihredomain.tld"]
 - job_name: 'uptime'
   scrape_interval: 30s
   scheme: https
   metrics_path: '/metrics'
   static_configs:
     - targets: ['status.ihredomain.tld']
   basic_auth: # Only needed if authentication is enabled (default)
     username: admin
     password: password
```

Zu beachten ist hier, dass Sie den Wert ```targets``` auf Ihre Domain anpassen müssen.

Wir setzen die Vorbereitungen fort. Für Grafana und NTFY sind keine umfangreichere Vorbereitung der Dateistruktur notwendig.

Wir bereiten nun unsere Compose-Datei vor. Führen Sie folgendes Kommando in Ihrer Ubuntu-Konsole aus: ```nano /docker/push/compose.yml```

Anschließend fügen Sie folgenden Inhalt ein:

```
version: "3.1"
services:
 ntfy:
   labels:
     - "traefik.enable=true"
     - "traefik.http.routers.ntfy.rule=Host(`ntfy.ihredomain.tld`)"
     - "traefik.http.services.ntfy.loadbalancer.server.port=80"
     - "traefik.http.routers.ntfy.entrypoints=websecure"
     - "traefik.http.routers.ntfy.tls=true"
     - "traefik.http.routers.ntfy.tls.certresolver=letsencrypt"
     - "traefik.protocol=http"
   image: binwiederhier/ntfy
   container_name: ntfy
   command:
     - serve
   environment:
     - TZ=UTC+1
   volumes:
     - /docker/push/ntfy/cache:/var/cache/ntfy
     - /docker/push/ntfy/etc:/etc/ntfy
   ports:
     - '8765:80'
   restart: unless-stopped
    networks:
     - traefik-net
 prometheus:
   ports:
     - '9091:9090'
   volumes:
     - '/docker/push/prometheus:/etc/prometheus'
   image: prom/prometheus
    networks:
     - traefik-net
 grafana:
   image: grafana/grafana-enterprise
   container_name: grafana
   restart: unless-stopped
   ports:
     - '3001:3000'
   volumes:
     - /docker/push/grafana:/var/lib/grafana
    networks:
     - traefik-net
networks:
 traefik-net:
   driver: bridge
   external: true
```

Den selben Inhalt legen Sie nun in Dockge als neuen Stack an. Wir erstellen über das "Plus"-Symbol ein neues Compose und vergeben einen Stack-Namen.

Auf der rechten Seite fügen wir den oben genannten Inhalt ein.

Dieser Stack setzt voraus, das Sie bereits Traefik gemäß unserer Anleitung installiert und konfiguriert haben. Sollte dies nicht der Fall sein, müssen Sie Traefik noch in den Stack mit aufnehmen.

Beachten Sie, das die Konfiguration von Traefik, wie auch von NTFY abhängig von der geplanten Verwendung ist. Wenn Sie Traefik gemäß unseres Artikels eingerichtet haben erwarten wir keine Probleme.

Möchten Sie NTFY nur innerhalb Ihres eigenen Netzwerks, ohne externe Anbindung nutzen wollen (Warum auch immer...) entfernen Sie dieser Zeile aus der Compose-Datei oben: ```- "traefik.http.routers.ntfy.tls.certresolver=letsencrypt"``` dann wird Ihr internes Zertifikat gemäß dynamischer Konfiguration verwendet. Ansonsten wird automatisch ein kostenloses Zertifikat über Let's Encrypt angefordert.

Wenn alle Container erfolgreich gestartet sind, müssen Sie noch das Grafana Dashboard importieren. Dieses finden Sie im Anhang (NTFY.zip) zu diesem Artikel.

Fügen Sie nun in Prometheus eine neue Data Source hinzu. Dies können Sie im Hauptmenü von Grafana über den Punkt "Connection" erledigen.

Wählen Sie dann im Menü "Data Sources" aus und klicken auf "Add new data source". Wählen Sie Prometheus aus.

Geben Sie im Feld "Prometheus server URL" [http://prometheus:9090](http://prometheus:9090) ein.

Bearbeiten Sie nun die Widgets auf dem vorhin importierten Dashboard und wählen unter "Data source" die Prometheus-Datenquelle aus.

Das war es mit der Basisinstallation. In einem Folgeartikel erfahren Sie mehr über die erweiterte Konfiguration von NTFY und die Administration.