Startseite/Artikel
Esadax JournalApps

ntfy

ntfy Server Installationsanleitung Dieses Handbuch enthält Anweisungen zur Installation des ntfy-Servers auf verschiedenen Linux-Distributionen sowie anderen Betriebssystemen. ntfy ist ein einfacher HTTP-basierter Pub-Sub-Benachrichtigungsdienst. Voraussetzungen * Ein Linux-System

ntfy logo

ntfy Server Installationsanleitung

Dieses Handbuch enthält Anweisungen zur Installation des ntfy-Servers auf verschiedenen Linux-Distributionen sowie anderen Betriebssystemen. ntfy ist ein einfacher HTTP-basierter Pub-Sub-Benachrichtigungsdienst.

Voraussetzungen

  • Ein Linux-System (oder ein anderes unterstütztes Betriebssystem)
  • Root-Zugriff oder sudo-Rechte
  • Eine Internetverbindung zum Herunterladen von Binärdateien und Paketen

1 SGB V. Manuelle Installation aus dem Quellcode (Binary Tarballs)

Diese Methode funktioniert auf jeder Linux-Distribution, die die spezifische Architektur Ihres Systems unterstützt.

Schritt 1: Identifizieren Sie Ihre Architektur

Führen Sie uname -m aus, um Ihre Architektur zu überprüfen:

  • x86_64 oder amd64
  • armv7 oder armhf
  • arm64 (aarch64)
  • armv6

Schritt 2: Herunterladen und Extrahieren der Binärdatei

Beispiel für x86_64/amd64:

wget https://github.com/binwiederhier/ntfy/releases/download/v2.28.0/ntfy_2.28.0_linux_amd64.tar.gz
tar zxvf ntfy_2.28.0_linux_amd64.tar.gz

Beispiel für armv7/armhf:

wget https://github.com/binwiederhier/ntfy/releases/download/v2.28.0/ntfy_2.28.0_linux_armv7.tar.gz
tar zxvf ntfy_2.28.0_linux_armv7.tar.gz

Beispiel für arm64:

wget https://github.com/binwiederhier/ntfy/releases/download/v2.28.0/ntfy_2.28.0_linux_arm64.tar.gz
tar zxvf ntfy_2.28.0_linux_arm64.tar.gz

Schritt 3: Installieren Sie die Binär- und Konfigurationsdateien

# Copy the binary to /usr/bin
sudo cp -a <architecture>/ntfy /usr/bin/ntfy

# Create config directory and copy files
sudo mkdir -p /etc/ntfy
sudo cp <architecture>/client/client.yml /etc/ntfy/
sudo cp <architecture>/server/server.yml /etc/ntfy/

Schritt 4: Server starten

sudo ntfy serve

Zwei. Als Systemdienst installieren (Systemd)

Wenn Sie möchten, dass der Server automatisch beim Booten gestartet wird, verwenden Sie systemd.

Voraussetzungen

  • Stellen Sie sicher, dass Ihr Betriebssystem systemd (systemctl --version) verwendet.
  • Sie müssen die Binär- und Konfigurationsdateien in Schritt 1 oben installiert haben.

Steps

Status überprüfen:

sudo systemctl status ntfy

Systemd neu laden und den Dienst starten:

sudo systemctl daemon-reload
sudo systemctl enable ntfy
sudo systemctl start ntfy

Kopieren Sie die Service Unit-Datei:

# Replace <architecture> with your system's architecture (e.g., amd64, armv7)
sudo mv <architecture>/server/ntfy.service /etc/systemd/system/
sudo chmod 644 /etc/systemd/system/ntfy.service

3. Als Systemdienst installieren (OpenRC)

Für Systeme, die OpenRC verwenden (z.B. Alpine Linux, Gentoo).

Steps

Zum Standard-Runlevel hinzufügen (um beim Booten zu starten):

sudo rc-update add ntfy default

Starten Sie den Service:

sudo rc-service ntfy start

Kopieren Sie das Service Script:

# Replace <architecture> with your system's architecture
sudo mv <architecture>/server/ntfy.openrc /etc/init.d/ntfy
sudo chmod 755 /etc/init.d/ntfy

4. Installation über Paket-Repositories

Ubuntu

Hinweis: Ab Ende 2025 ist das offizielle Repository auf archive.ntfy.sh umgezogen. Die alte (heckel.io) ist veraltet.

APT verwenden (empfohlen)

# Add keyring
sudo mkdir -p /etc/apt/keyrings
sudo curl -L -o /etc/apt/keyrings/ntfy.gpg https://archive.ntfy.sh/apt/keyring.gpg
sudo apt install apt-transport-https

# Add repository
echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/ntfy.gpg] https://archive.ntfy.sh/apt stable main" | sudo tee /etc/apt/sources.list.d/ntfy.list

# Update and Install
sudo apt update
sudo apt install ntfy

Manuelle.deb Installation

wget https://github.com/binwiederhier/ntfy/releases/download/v2.28.0/ntfy_2.28.0_linux_amd64.deb
sudo dpkg -i ntfy_*.deb
sudo systemctl enable ntfy
sudo systemctl start ntfy

Fedora

# Install RPM
sudo rpm -ivh https://github.com/binwiederhier/ntfy/releases/download/v2.28.0/ntfy_2.28.0_linux_amd64.rpm

# Enable and Start
sudo systemctl enable ntfy
sudo systemctl start ntfy

Arch Linux

AUR Helper verwenden (empfohlen)

paru -S ntfysh-bin

Manuelle Installation und Konfiguration

curl https://aur.archlinux.org/cgit/aur.git/snapshot/ntfysh-bin.tar.gz | tar xzv
cd ntfysh-bin
makepkg -si

NixOS

  • NixOS-Konfiguration: Fügen Sie services.ntfy-sh.enable = true; zu Ihrem /etc/nixos/configuration.nix hinzu und führen Sie nixos-rebuild switch aus.
  • Benutzerumgebung: nix-env -iA ntfy-sh

FreeBSD

pkg install go-ntfy

Fünf. Installation von macOS

macOS unterstützt die CLI (ntfy publish, ntfy subscribe), aber unterstützt den Server nicht über offizielle Pakete.

Manuelle CLI-Installation

curl -L https://github.com/binwiederhier/ntfy/releases/download/v2.28.0/ntfy_2.28.0_darwin_all.tar.gz > ntfy.tar.gz
tar zxvf ntfy.tar.gz
sudo cp -a ntfy_2.28.0_darwin_all/ntfy /usr/local/bin/ntfy
mkdir ~/Library/Application\ Support/ntfy
cp ntfy_2.28.0_darwin_all/client/client.yml ~/Library/Application\ Support/ntfy/client.yml
Hinweis: Um den Server unter macOS auszuführen, müssen Sie ihn manuell mit Go erstellen (siehe Build-Anweisungen).

Sechs. Installation von Homebrew

brew install ntfy

Dadurch wird nur die CLI installiert. Die Serverinstallation erfordert manuelle Schritte.


Sieben. Installation von Windows

Als Benutzerprogramm

  1. Laden Sie die ZIP von GitHub Releases herunter.
  2. Extrahieren und platzieren Sie ntfy.exe in Ihrem %Path% (z.B. C:\Program Files\).

Führen Sie Befehle wie:

ntfy.exe -h

Als Windows-Service

  1. Öffnen Sie eine erhöhte Eingabeaufforderung.

Starten Sie den Dienst:

sc start ntfy

Erstellen Sie den Dienst:

sc create ntfy binPath="C:\path\to\ntfy.exe serve" start=auto

Acht. Installation von Docker

Grundlegende Verwendung (kein persistenter Cache)

docker run -p 80:80 -it binwiederhier/ntfy serve

Mit persistentem Cache

docker run \
  -v /var/cache/ntfy:/var/cache/ntfy \
  -p 80:80 \
  -it \
  binwiederhier/ntfy \
  serve \
  --cache-file /var/cache/ntfy/cache.db

Mit benutzerdefinierter Konfiguration (Nicht-Root-Benutzer)

docker run \
  -v /etc/ntfy:/etc/ntfy \
  -e TZ=UTC \
  -p 80:80 \
  -u UID:GID \
  -it \
  binwiederhier/ntfy \
  serve

Beispiel für Docker Compose

version: '3'
services:
  ntfy:
    image: binwiederhier/ntfy
    container_name: ntfy
    command: ["serve"]
    environment:
      - TZ=UTC
    user: "1000:1000" # Replace with your UID/GID
    volumes:
      - /var/cache/ntfy:/var/cache/ntfy
      - /etc/ntfy:/etc/ntfy
    ports:
      - "80:80"
    healthcheck:
      test: ["CMD-SHELL", "wget -q --tries=1 http://localhost:80/v1/health -O - | grep -Eo '\"healthy\"\\s*:\\s*true' || exit 1"]
      interval: 60s
      timeout: 10s
      retries: 3
      start_period: 40s
    restart: unless-stopped
    init: true

Neun. Bereitstellung von Kubernetes (K8s)

StatefulSet mit persistentem Cache

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: ntfy
spec:
  serviceName: ntfy
  replicas: 1
  selector:
    matchLabels:
      app: ntfy
  template:
    metadata:
      labels:
        app: ntfy
    spec:
      containers:
        - name: ntfy
          image: binwiederhier/ntfy
          args: ["serve", "--cache-file", "/var/cache/ntfy/cache.db"]
          ports:
            - containerPort: 80
              name: http
          volumeMounts:
            - name: config
              mountPath: /etc/ntfy
              readOnly: true
            - name: cache
              mountPath: /var/cache/ntfy
      volumes:
        - name: config
          configMap:
            name: ntfy
        - name: cache
          persistentVolumeClaim:
            claimName: ntfy-cache
---
apiVersion: v1
kind: Service
metadata:
  name: ntfy
spec:
  selector:
    app: ntfy
  ports:
    - port: 80
      targetPort: 80
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: ntfy-cache
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

Troubleshooting

  • Dienst startet nicht: Überprüfen Sie die Protokolle mit sudo journalctl -u ntfy (systemd) oder sudo rc-service ntfy status (OpenRC).
  • Berechtigung verweigert: Stellen Sie sicher, dass die Binär- und Konfigurationsdateien Eigentum von root oder eines bestimmten Benutzers sind, wenn sie als Nicht-Root ausgeführt werden.
  • Port wird bereits verwendet: Ändern Sie den Port im Befehl server.yml oder Docker run (-p 8080:80).

Dateien für die Konfiguration

  • Client Config: /etc/ntfy/client.yml (oder ~/.config/ntfy/client.yml für Nicht-Root).
  • Serverkonfiguration: /etc/ntfy/server.yml.

Bearbeiten Sie diese Dateien, um Einstellungen wie Zeitzone, maximale Nachrichtengröße oder Aufbewahrungsrichtlinie anzupassen.


Hinweise zur Sicherheit

  • Führen Sie ntfy nach Möglichkeit immer als Nicht-Root-Benutzer in der Produktion aus (konfigurieren Sie über user-Flag in Docker oder systemd-Dienst).
  • Stellen Sie sicher, dass die Web-UI nur über vertrauenswürdige Netzwerke zugänglich ist, wenn sie öffentlich zugänglich ist.
  • Aktualisieren Sie Ihre Installation regelmäßig, um Sicherheitslücken zu schließen.

Weitere Informationen finden Sie im ntfy GitHub Repository.

Parameter für die Konfiguration

Nach dem Kauf dieser Anwendung auf Esadax werden Sie aufgefordert, die folgenden Konfigurationsparameter anzugeben. Esadax fügt die bereitgestellten Variablen zur Bereitstellung hinzu, sodass die Anwendung mit der erforderlichen Konfiguration gestartet werden kann.

Parameter Beschreibung
ADMIN_USERNAME Wert, der der Bereitstellung für ADMIN_USERNAME bereitgestellt wird.
ADMIN_PASSWORD Wert, der der Bereitstellung für ADMIN_PASSWORD bereitgestellt wird.

Sobald die Werte konfiguriert sind, klicken Sie auf Bereitstellen, um die Anwendung zu starten. Die gekaufte Anwendung verwendet die bereitgestellten Konfigurationswerte, einschließlich Anmeldeinformationen wie Benutzernamen und Kennwörter, wenn diese Parameter bereitgestellt werden.

Abonnieren