In unserer digital vernetzten Welt sind Push-Benachrichtigungen allgegenwärtig. Sie informieren uns über neue E-Mails, Nachrichten, Systemereignisse oder Wetterwarnungen. Doch oft laufen diese Nachrichten über Dienste Dritter, die Daten sammeln oder uns mit Werbung belästigen könnten. Was wäre, wenn Sie die volle Kontrolle über Ihre Benachrichtigungen hätten, sie selbst hosten und genau an Ihre Bedürfnisse anpassen könnten? Hier kommt ntfy ins Spiel, und Ihr treuer Raspberry Pi ist die perfekte Plattform, um dieses Vorhaben in die Tat umzusetzen!
Dieser umfassende Guide nimmt Sie an die Hand und führt Sie Schritt für Schritt durch die Installation und Konfiguration von ntfy auf Ihrem Raspberry Pi. Egal, ob Sie Systemadministrator, Smart-Home-Enthusiast oder einfach nur technikinteressiert sind – am Ende dieses Artikels werden Sie Ihr eigenes, privates Benachrichtigungssystem betreiben, das Ihnen unvergleichliche Kontrolle und Flexibilität bietet.
Warum selbstgehostete Push-Benachrichtigungen mit ntfy und Raspberry Pi?
Bevor wir uns ins technische Detail stürzen, lassen Sie uns die überzeugenden Vorteile dieser Kombination beleuchten:
1. Volle Kontrolle und Privatsphäre
Der größte Pluspunkt eines selbstgehosteten Dienstes ist die Hoheit über Ihre Daten. Ihre Benachrichtigungen verlassen Ihren Server nicht und werden nicht von Dritten verarbeitet oder analysiert. ntfy ist Open-Source, was bedeutet, dass der Code transparent ist und von der Community überprüft werden kann. Sie wissen genau, was mit Ihren Nachrichten geschieht.
2. Unbegrenzte Flexibilität und Integration
Mit ntfy können Sie Benachrichtigungen aus nahezu jeder Quelle senden. Egal ob es sich um ein Skript handelt, das den Zustand Ihres Servers überwacht, eine Smart-Home-Automatisierung, die Sie über eine offene Tür informiert, oder einfach nur eine Erinnerung, die Sie sich selbst schicken möchten – die Möglichkeiten sind grenzenlos. Die einfache API erlaubt eine nahtlose Integration in bestehende Systeme und eigene Skripte.
3. Zuverlässigkeit und Leistung
Ihr Raspberry Pi läuft in der Regel 24/7. Das macht ihn zur idealen Plattform für einen immer verfügbaren Benachrichtigungsdienst. ntfy ist schlank und effizient, sodass es selbst auf einem älteren Pi-Modell problemlos läuft und kaum Ressourcen verbraucht.
4. Kostenersparnis
Nach der einmaligen Anschaffung des Raspberry Pi entstehen keine laufenden Kosten für den Benachrichtigungsdienst, wie es bei vielen kommerziellen Anbietern der Fall wäre. Sie zahlen lediglich für Strom, und der ist beim Pi verschwindend gering.
5. Lerneffekt
Die Installation und Konfiguration von ntfy bietet eine hervorragende Gelegenheit, Ihre Linux-Kenntnisse zu erweitern und ein tieferes Verständnis für Netzwerkdienste zu entwickeln.
Was Sie für Ihr ntfy-Projekt benötigen
Um loszulegen, stellen Sie sicher, dass Sie die folgenden Dinge zur Hand haben:
- Raspberry Pi: Jedes Modell ab Raspberry Pi 2 ist geeignet, aber ein Pi 3 oder Pi 4 bietet mehr Leistung für zukünftige Erweiterungen.
- SD-Karte: Mindestens 8 GB, besser 16 GB oder 32 GB für das Betriebssystem (Raspberry Pi OS Lite empfohlen) und ntfy.
- Netzteil: Passend für Ihren Raspberry Pi.
- Internetverbindung: Für den Download von Paketen und später für den Empfang von Benachrichtigungen.
- SSH-Zugang: Sie benötigen ein Terminal, um sich mit Ihrem Pi zu verbinden.
- Grundkenntnisse: Vertrautheit mit der Linux-Kommandozeile ist hilfreich.
- Optional (aber empfohlen für externen Zugriff): Eine eigene Domain und ein Reverse Proxy (z.B. Nginx oder Caddy) sowie Portweiterleitung in Ihrem Router.
Schritt-für-Schritt-Anleitung: ntfy auf Ihrem Raspberry Pi installieren
Wir gehen davon aus, dass Ihr Raspberry Pi bereits mit Raspberry Pi OS installiert ist und Sie über SSH darauf zugreifen können. Falls nicht, folgen Sie bitte der offiziellen Anleitung zur Installation des Betriebssystems und Aktivierung von SSH.
Schritt 1: System aktualisieren
Bevor Sie neue Software installieren, ist es immer eine gute Praxis, Ihr System auf den neuesten Stand zu bringen:
sudo apt update && sudo apt upgrade -ySchritt 2: ntfy installieren – Die einfache Variante (Binärpaket)
Wir verwenden die Installation aus einem Binärpaket, da diese für die meisten Anwender die einfachste und schnellste Methode ist. Für fortgeschrittene Nutzer gibt es auch eine Docker-Option, die wir später kurz anreißen.
1. Die neueste Version herunterladen
Besuchen Sie die offizielle ntfy-GitHub-Seite (https://github.com/binwiedergaenger/ntfy/releases) und suchen Sie nach der neuesten stabilen Version für arm64 (für 64-Bit Raspberry Pi OS) oder armv7 (für 32-Bit Raspberry Pi OS). In den meisten Fällen ist arm64 die richtige Wahl für neuere Pis. Ersetzen Sie X.Y.Z mit der aktuellen Versionsnummer.
wget https://github.com/binwiedergaenger/ntfy/releases/download/vX.Y.Z/ntfy_X.Y.Z_linux_arm64.tar.gzBeispiel für Version 1.29.0:
wget https://github.com/binwiedergaenger/ntfy/releases/download/v1.29.0/ntfy_1.29.0_linux_arm64.tar.gz2. Entpacken und Installieren
Entpacken Sie das Archiv und verschieben Sie die ausführbare Datei an einen geeigneten Ort:
tar -xvzf ntfy_X.Y.Z_linux_arm64.tar.gz
sudo mv ntfy /usr/local/bin/3. Konfigurationsverzeichnis erstellen
Erstellen Sie ein Verzeichnis für die Konfigurationsdateien und eine leere Standardkonfiguration:
sudo mkdir -p /etc/ntfy
sudo touch /etc/ntfy/server.yml4. Konfigurationsdatei erstellen (server.yml)
Die server.yml ist das Herzstück Ihrer ntfy-Installation. Hier definieren Sie wichtige Einstellungen wie den Basis-URL, den Listen-Port, Authentifizierung und mehr. Öffnen Sie die Datei mit einem Texteditor:
sudo nano /etc/ntfy/server.ymlFügen Sie die folgende Basiskonfiguration ein. Ersetzen Sie your-pi-ip-or-domain.com mit der IP-Adresse Ihres Raspberry Pi oder (später) Ihrer Domain:
# /etc/ntfy/server.yml
base_url: http://your-pi-ip-or-domain.com:8080
listen_http: ":8080"
cache_dir: "/var/cache/ntfy"
persistence_dir: "/var/lib/ntfy"
behind_proxy: false # Set auf true, wenn Sie einen Reverse Proxy verwenden
# Optional: Authentifizierung
# auth_file: "/etc/ntfy/user.db"Speichern und schließen Sie die Datei (Strg+O, Enter, Strg+X).
5. Systemd Service erstellen
Damit ntfy automatisch startet und im Hintergrund läuft, erstellen wir einen Systemd-Service. Dies ist der empfohlene Weg unter Linux.
sudo nano /etc/systemd/system/ntfy.serviceFügen Sie folgenden Inhalt ein:
# /etc/systemd/system/ntfy.service
[Unit]
Description=ntfy push notification server
After=network.target
[Service]
ExecStart=/usr/local/bin/ntfy serve --config /etc/ntfy/server.yml
User=ntfy
Group=ntfy
AmbientCapabilities=CAP_NET_BIND_SERVICE
CapabilityBoundingSet=CAP_NET_BIND_SERVICE
NoNewPrivileges=true
ReadWritePaths=/var/cache/ntfy /var/lib/ntfy
StateDirectory=ntfy
CacheDirectory=ntfy
LogsDirectory=ntfy
Restart=always
[Install]
WantedBy=multi-user.targetSpeichern und schließen Sie die Datei.
6. Benutzer und Verzeichnisse erstellen
Erstellen Sie einen dedizierten Benutzer und die benötigten Verzeichnisse für ntfy, um die Sicherheit zu erhöhen:
sudo useradd -r -s /bin/false ntfy
sudo mkdir -p /var/cache/ntfy /var/lib/ntfy
sudo chown -R ntfy:ntfy /var/cache/ntfy /var/lib/ntfy /etc/ntfy7. ntfy starten und aktivieren
Laden Sie die Systemd-Konfiguration neu, starten Sie ntfy und aktivieren Sie den Dienst, damit er nach einem Neustart des Pi automatisch startet:
sudo systemctl daemon-reload
sudo systemctl enable ntfy
sudo systemctl start ntfyÜberprüfen Sie den Status des Dienstes:
sudo systemctl status ntfyWenn alles geklappt hat, sollte der Status active (running) anzeigen.
Schritt 3: Erster Test und grundlegende Nutzung
Ihr ntfy-Server sollte nun auf Port 8080 Ihrer Pi-IP-Adresse erreichbar sein. Sie können dies im Browser testen oder direkt eine Nachricht senden.
1. Nachricht über die Kommandozeile senden
Öffnen Sie ein neues Terminal (nicht das auf dem Pi selbst, sondern von einem anderen Computer im selben Netzwerk) und senden Sie Ihre erste Push-Benachrichtigung. Ersetzen Sie your-pi-ip mit der tatsächlichen IP-Adresse Ihres Raspberry Pi und mytopic mit einem selbstgewählten Thema (z.B. smart-home-alerts oder server-status).
curl -d "Hallo ntfy auf meinem Pi!" http://your-pi-ip:8080/mytopicWenn der Befehl erfolgreich war, sollte eine Bestätigung erscheinen.
2. ntfy-Weboberfläche aufrufen
Öffnen Sie einen Webbrowser und navigieren Sie zu http://your-pi-ip:8080. Sie sollten die ntfy-Weboberfläche sehen, auf der Sie Ihre Themen abonnieren und Nachrichten sehen können.
3. ntfy App auf dem Smartphone installieren
Laden Sie die offizielle ntfy-App für Android oder iOS herunter (suchen Sie im App Store oder Google Play nach „ntfy”).
- Öffnen Sie die App.
- Fügen Sie einen neuen Server hinzu. Geben Sie die URL Ihres ntfy-Servers ein:
http://your-pi-ip:8080. - Abonnieren Sie das Topic, das Sie im
curl-Befehl verwendet haben (z.B.mytopic).
Senden Sie erneut eine Nachricht über curl, und Sie sollten sie nun auf Ihrem Smartphone erhalten!
Schritt 4: Authentifizierung und Zugriffsbeschränkungen (Empfohlen)
Für mehr Sicherheit sollten Sie Ihren ntfy-Server absichern, besonders wenn er später aus dem Internet erreichbar sein soll. ntfy unterstützt verschiedene Authentifizierungsmethoden. Eine einfache Möglichkeit ist die Benutzer/Passwort-Authentifizierung.
1. Benutzer/Passwort-Datei erstellen
Erstellen Sie eine Datei für Benutzernamen und Passwörter. ntfy erwartet eine htpasswd-ähnliche Datei. Generieren Sie ein Passwort mit htpasswd (falls nicht installiert: sudo apt install apache2-utils):
sudo htpasswd -c /etc/ntfy/user.db myuserGeben Sie Ihr gewünschtes Passwort ein. Für weitere Benutzer wiederholen Sie den Befehl ohne -c (z.B. sudo htpasswd /etc/ntfy/user.db anotheruser).
2. Konfiguration anpassen
Bearbeiten Sie Ihre /etc/ntfy/server.yml und fügen Sie die Authentifizierung hinzu:
sudo nano /etc/ntfy/server.ymlFügen Sie die Zeile auth_file: "/etc/ntfy/user.db" hinzu oder entkommentieren Sie sie:
# /etc/ntfy/server.yml
base_url: http://your-pi-ip-or-domain.com:8080
listen_http: ":8080"
cache_dir: "/var/cache/ntfy"
persistence_dir: "/var/lib/ntfy"
behind_proxy: false
auth_file: "/etc/ntfy/user.db" # Diese Zeile hinzufügen/entkommentierenSpeichern Sie die Datei und starten Sie den ntfy-Dienst neu:
sudo systemctl restart ntfy3. Nachrichten mit Authentifizierung senden
Jetzt müssen Sie beim Senden von Nachrichten Benutzernamen und Passwort angeben:
curl -u "myuser:mypassword" -d "Hallo ntfy mit Auth!" http://your-pi-ip:8080/mytopicAuch in der ntfy-App müssen Sie die Anmeldeinformationen für den Server hinterlegen.
Schritt 5: ntfy über HTTPS und Domain erreichbar machen (Sehr empfohlen)
Wenn Sie ntfy von außerhalb Ihres Heimnetzwerks nutzen möchten, ist HTTPS unerlässlich. Dies schützt Ihre Kommunikation vor Abhören und Manipulation. Wir verwenden dafür einen Reverse Proxy.
1. Domain und Portweiterleitung
Sie benötigen eine eigene Domain (oder Subdomain), die auf Ihre Heim-IP-Adresse zeigt (z.B. via DynDNS). In Ihrem Router müssen Sie den Port 80 (HTTP) und 443 (HTTPS) auf die interne IP-Adresse Ihres Raspberry Pi weiterleiten.
2. Installation eines Reverse Proxy (Caddy oder Nginx)
Caddy ist für seine Einfachheit bekannt, insbesondere bei der automatischen Let’s Encrypt-Zertifikatsverwaltung. Nginx ist mächtiger, aber komplexer einzurichten.
Option A: Caddy (Empfohlen für Anfänger)
sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install caddyErstellen Sie eine Caddyfile-Konfiguration:
sudo nano /etc/caddy/CaddyfileErsetzen Sie den Inhalt mit:
your.domain.com {
reverse_proxy 127.0.0.1:8080
# Stellen Sie sicher, dass ntfy.service als User 'ntfy' läuft
# und der Caddy-Benutzer (caddy) Zugriff auf die ntfy-Socket hat, falls Sie Unix Sockets verwenden.
# Für einfache HTTP-Verbindung wie hier ist das aber nicht nötig.
}Speichern Sie die Datei und aktivieren Sie Caddy:
sudo systemctl enable caddy
sudo systemctl restart caddyStellen Sie sicher, dass in Ihrer /etc/ntfy/server.yml behind_proxy: true gesetzt ist und base_url auf Ihre HTTPS-Domain zeigt.
Option B: Nginx (Alternative)
sudo apt install nginxErstellen Sie eine Nginx-Konfigurationsdatei für Ihre Domain:
sudo nano /etc/nginx/sites-available/ntfy.confFügen Sie Folgendes ein (ersetzen Sie your.domain.com):
server {
listen 80;
server_name your.domain.com;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl;
server_name your.domain.com;
ssl_certificate /etc/letsencrypt/live/your.domain.com/fullchain.pem; # Pfad zu Ihrem Let's Encrypt Zertifikat
ssl_certificate_key /etc/letsencrypt/live/your.domain.com/privkey.pem; # Pfad zu Ihrem Let's Encrypt Schlüssel
location / {
proxy_pass http://127.0.0.1:8080;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
}Sie müssen zuvor noch Let’s Encrypt mit Certbot installieren und ein Zertifikat für Ihre Domain erstellen: sudo apt install certbot python3-certbot-nginx && sudo certbot --nginx -d your.domain.com.
Verlinken Sie die Konfiguration und testen Sie sie:
sudo ln -s /etc/nginx/sites-available/ntfy.conf /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginxVergessen Sie nicht, in Ihrer /etc/ntfy/server.yml behind_proxy: true zu setzen und base_url auf Ihre HTTPS-Domain zu aktualisieren, z.B. https://your.domain.com. Danach ntfy neu starten.
Nun können Sie ntfy über https://your.domain.com erreichen und in der App als Server-URL eintragen.
Schritt 6: Fortgeschrittene Nutzung und Integration
ntfy glänzt durch seine Vielseitigkeit. Hier ein paar Anwendungsbeispiele:
1. Integration in Shell-Skripte
Sie können ntfy-Nachrichten ganz einfach in Bash-Skripte einbinden, z.B. um sich über fehlgeschlagene Backups oder volle Festplatten informieren zu lassen:
#!/bin/bash
FREE_SPACE=$(df -h / | grep / | awk '{print $5}' | sed 's/%//g')
if (( $FREE_SPACE > 90 )); then
curl -u "myuser:mypassword" -H "Title: Achtung!" -H "Priority: high" -d "Festplatte läuft voll! ($FREE_SPACE% belegt)" https://your.domain.com/server-alerts
fi2. Integration in Python-Skripte
import requests
topic = "python-alerts"
title = "Python Skript beendet"
message = "Mein Python Skript ist erfolgreich durchgelaufen."
url = "https://your.domain.com/" + topic
user = "myuser"
password = "mypassword"
requests.post(url,
data=message.encode('utf-8'),
auth=(user, password),
headers={'Title': title, 'Priority': 'default'})3. Anpassung der Benachrichtigungen
ntfy unterstützt viele Header, um Ihre Benachrichtigungen anzupassen:
Title: Titel der Nachricht.Priority:min,low,default,high,urgent.Tags: Icons oder Gruppierungen (z.B.warning,skull,bell).Click: Eine URL, die beim Klick auf die Benachrichtigung geöffnet wird.Actions: Interaktive Schaltflächen in der Benachrichtigung.Attach: Anhänge (Bilder, Dateien).Email: E-Mail-Adresse für E-Mail-Weiterleitung.
Beispiel mit Priorität und Klick-Aktion:
curl -u "myuser:mypassword" -H "Title: Wichtige Info" -H "Priority: high" -H "Click: https://your.domain.com/details" -d "Klicken Sie hier für mehr Details." https://your.domain.com/generalFehlerbehebung und Best Practices
- Logs prüfen: Wenn ntfy nicht startet, schauen Sie in die Logs:
sudo journalctl -u ntfy.service -f. - Firewall: Stellen Sie sicher, dass Port 8080 (oder 80/443, wenn Sie einen Reverse Proxy verwenden) auf Ihrem Pi nicht durch eine Firewall blockiert wird.
- Konfiguration: Tippfehler in der
server.ymlsind eine häufige Fehlerquelle. YAML ist sehr empfindlich gegenüber Einrückungen. - Backups: Sichern Sie Ihre
/etc/ntfy/server.ymlund/etc/ntfy/user.dbregelmäßig. - Updates: Halten Sie Ihr Raspberry Pi OS und ntfy selbst stets aktuell, um Sicherheitslücken zu schließen und von neuen Funktionen zu profitieren.
- Starke Passwörter: Verwenden Sie immer sichere, einzigartige Passwörter für die Authentifizierung.
Fazit
Herzlichen Glückwunsch! Sie haben erfolgreich Ihr eigenes Push-Benachrichtigungssystem mit ntfy auf Ihrem Raspberry Pi eingerichtet. Sie haben die Kontrolle über Ihre Nachrichten zurückgewonnen, Ihre Privatsphäre gestärkt und ein extrem vielseitiges Werkzeug für Ihre Automatisierungsprojekte geschaffen. Von der einfachen Serverüberwachung bis hin zu komplexen Smart-Home-Integrationen – die Möglichkeiten, ntfy zu nutzen, sind nahezu unbegrenzt.
Dieses Projekt ist nicht nur funktional, sondern auch eine fantastische Möglichkeit, tiefer in die Welt der Heimserver und Open-Source-Software einzutauchen. Experimentieren Sie mit verschiedenen Topics, Prioritäten und Integrationen. Die ntfy-Dokumentation (ntfy.sh/docs/) ist eine hervorragende Ressource, um noch tiefer in die Materie einzusteigen.
Genießen Sie die Ruhe, die ein zuverlässiges und privates Benachrichtigungssystem mit sich bringt. Ihr Raspberry Pi ist nun noch ein Stückchen smarter geworden!