SSD Nodes Learn Hosting plans →
Gidsen Matt ConnorDoor Matt Connor

Zelf ntfy server hosten met Docker Compose

Host uw eigen ntfy server achter TLS met Docker Compose. Beveilig topics met ACLs en stuur direct pushmeldingen vanuit cron jobs of systemd OnFailure units naar uw telefoon.

Wat een zelfgehoste ntfy server doet

Een zelfgehoste ntfy server zet een HTTP POST om in een pushbericht op uw telefoon. U publiceert met curl, en het bericht komt aan in de Android-app, de iOS-app, een browsertabblad of elk ander medium dat een HTTP-verbinding open kan houden. Er hoeft geen clientbibliotheek te worden geïnstalleerd en er hoeft geen message broker te worden uitgevoerd.

ntfy adresseert berichten op basis van een topic. Een topic is een naam in het URL-pad, zoals https://ntfy.example.com/alerts, en deze bestaat op het moment dat iemand ernaar publiceert. Bij een standaardinstallatie kan iedereen die die naam kent het topic lezen en ernaar schrijven; daarom vergelijkt de documentatie van het project een topicnaam met een wachtwoord. Dat model is prima voor de publieke ntfy.sh dienst. Het is echter niet geschikt voor een server die meldingen over uw back-upfouten verwerkt, dus deze handleiding schakelt authenticatie in voordat het eerste bericht wordt verzonden.

Vereisten voor aanvang

U heeft een VPS nodig met Ubuntu 24.04 of Debian 13, inclusief Docker Engine en de Compose-plugin, een domeinnaam en een beperkte hoeveelheid RAM. Maak een DNS (domain name system) A-record aan dat ntfy.example.com naar het publieke IP-adres van de server laat wijzen en controleer of dit correct wordt omgezet voordat u verdere stappen onderneemt.

dig +short ntfy.example.com
sudo ufw allow 80,443/tcp
sudo ufw status

dig moet het IP-adres van uw server retourneren. Voor de uitgifte van certificaten is het noodzakelijk dat de hostnaam publiekelijk naar de server wordt omgezet via een A- of AAAA-record. Poort 80 moet open blijven, omdat ACME (automatic certificate management environment), het protocol achter Let's Encrypt, deze gebruikt voor de HTTP-challenge. De ntfy-container zelf krijgt geen publieke poort toegewezen.

Het ntfy-configuratiebestand schrijven

De Docker-image bevat geen configuratiebestand, dus u moet er zelf een aanmaken. Elke opdracht verderop in deze handleiding leest vanuit dit bestand. Zoek eerst de user ID en group ID op waaronder de container zal draaien.

id -u
id -g
sudo install -d -o "$(id -u)" -g "$(id -g)" /etc/ntfy /var/cache/ntfy /var/lib/ntfy
sudo nano /etc/ntfy/server.yml
base-url: "https://ntfy.example.com"
listen-http: ":2586"
behind-proxy: true
cache-file: "/var/cache/ntfy/cache.db"
cache-duration: "12h"
auth-file: "/var/lib/ntfy/user.db"
auth-default-access: "deny-all"
enable-login: true
enable-signup: false

Vier van deze regels zijn cruciaal. base-url moet het exacte publieke HTTPS-adres zijn, omdat ntfy dit gebruikt voor gegenereerde bijlagelinks en zelfgehoste iOS-pushmeldingen. listen-http: ":2586" bindt aan alle interfaces binnen de container; dit lijkt onvoorzichtig, maar is correct: de container heeft een eigen netwerk-namespace, dus binden aan 127.0.0.1 zou de poort onbereikbaar maken vanaf de host en de gepubliceerde poort van Docker zou nooit verbinding kunnen maken. auth-default-access: "deny-all" vormt de volledige beveiligingsstrategie, omdat het lees- en schrijftoegang weigert aan iedereen zonder expliciete toestemming. behind-proxy: true instrueert ntfy om het clientadres uit de X-Forwarded-For-header te halen, zodat rate limits de werkelijke bezoekers tellen in plaats van de reverse proxy als één zeer actieve client te zien.

enable-login: true stelt gebruikers in staat om in te loggen via de web-app of API. enable-signup blijft false, aangezien zelfregistratie van accounts op een privéserver een open deur is met extra stappen.

sudo chown "$(id -u):$(id -g)" /etc/ntfy/server.yml
sudo chmod 600 /etc/ntfy/server.yml

ntfy uitvoeren met Docker Compose

Plaats dit in /opt/ntfy/compose.yaml en vervang 1000:1000 door de twee getallen id -u en id -g die hierboven staan vermeld.

services:
  ntfy:
    image: binwiederhier/ntfy:v2.36.0
    container_name: ntfy
    command: serve
    user: "1000:1000"
    environment:
      - TZ=UTC
    volumes:
      - /etc/ntfy:/etc/ntfy
      - /var/cache/ntfy:/var/cache/ntfy
      - /var/lib/ntfy:/var/lib/ntfy
    ports:
      - "127.0.0.1:2586:2586"
    restart: unless-stopped
cd /opt/ntfy
sudo docker compose up -d
sudo docker compose logs ntfy
curl -s http://127.0.0.1:2586/v1/health

Een gezonde server antwoordt met {"healthy":true,"role":"active"}. Twee details in dat compose-bestand zijn bewust gekozen. De image is vastgezet op v2.36.0, de huidige stabiele release per 1 november 2026, in plaats van latest. Met latest downloadt de volgende docker compose pull namelijk de huidige image, en een daaropvolgende docker compose up -d maakt de container opnieuw aan met die versie; alleen een pull wijzigt de draaiende serverversie niet. Een vastgezette versie moet nog steeds worden bijgewerkt. Alleen al in oktober 2026 waren er tien releases: v2.29.0 op 7 oktober, v2.30.0 op 12 oktober, v2.31.0 en v2.31.1 op 16 oktober, v2.32.0 op 18 oktober, v2.33.0 en v2.33.1 op 23 oktober, v2.34.0 op 24 oktober, v2.35.0 op 30 oktober en v2.36.0 op 31 oktober. v2.31.0 loste problemen op met berichten die verloren gingen wanneer een client opnieuw verbond voordat ze de message cache bereikten, maar bij reconnects met since=<message ID> las deze versie elk bericht in het topic uit de database, waardoor ntfy.sh terugkeerde naar de vorige versie. v2.31.1 verhelpt die belasting met een nieuwe index, en v2.34.0 lost op dat ingetrokken of verwijderde gebruikers soms abonnementen behielden. v2.35.0 lost problemen op waarbij gelijktijdige verzoeken geldige inloggegevens als anoniem behandelden en een autorisatie-omzeiling in de Matrix push gateway op SQLite; verplaats oudere pins daarom naar v2.36.0. De poort wordt gepubliceerd als 127.0.0.1:2586:2586, waardoor de container alleen bereikbaar is vanaf het loopback-adres van de host. Schrijf 2586:2586 in plaats daarvan en Docker plaatst zijn eigen firewallregels vóór die van u, wat betekent dat de poort vanaf internet reageert, ook al zegt ufw status dat de poort gesloten is. Beide gewoontes neemt u mee naar de volgende container die u toevoegt: een zelfgehoste RustDesk relay zet de image-tag op dezelfde manier vast, maar kan zich niet achter loopback verbergen omdat de signal- en relay-poorten vanaf internet bereikbaar moeten zijn.

Als curl Connection refused afdrukt, lees dan het containerlogboek. Een rechtenfout op /var/lib/ntfy/user.db betekent dat de user:-regel niet overeenkomt met de eigenaar van die mappen, waardoor het proces zijn eigen database niet kan aanmaken en afsluit. De Docker Compose basisgids voor een VPS behandelt volume-eigenaarschap en herstartbeleid in meer detail.

TLS-beveiliging toevoegen met Caddy

Caddy vraagt certificaten zelf aan en vernieuwt deze automatisch. Dit is de snelste manier om TLS (transport layer security) werkend te krijgen.

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
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 chmod o+r /usr/share/keyrings/caddy-stable-archive-keyring.gpg
sudo chmod o+r /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install -y caddy

Vervang de inhoud van /etc/caddy/Caddyfile door drie regels.

ntfy.example.com {
    reverse_proxy 127.0.0.1:2586
}
sudo systemctl reload caddy
curl -s https://ntfy.example.com/v1/health

Dezelfde {"healthy":true,"role":"active"} via HTTPS betekent dat het volledige pad correct functioneert. Een 502 van Caddy betekent meestal dat ntfy niet luistert: controleer dit met sudo ss -lntp | grep 2586. Als ntfy wel luistert en de 502 blijft bestaan, logt Caddy de upstream-fout die is opgetreden, zoals een geresette verbinding. Een certificaatfout betekent meestal dat het DNS-record onjuist is of dat de certificaatvalidatie de server niet kan bereiken op poort 80 of 443; inspecteer sudo journalctl -u caddy -n 50 voor de validatiefout. Het toevoegen van een andere service op een later moment vereist slechts één extra hostname-blok in hetzelfde Caddyfile. Op deze manier kan bijvoorbeeld Halcyon, een jaren '90 videotheek-interface voor uw Jellyfin-bibliotheek op een tweede subdomein van dezelfde server worden geplaatst.

Als u al nginx gebruikt, kopieer dan de proxy-instellingen die in de ntfy-documentatie staan: proxy_http_version 1.1, proxy_buffering off, proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for, en stel de read- en send-timeouts in op ten minste drie minuten. Een subscriber houdt één HTTP-verbinding open zolang deze luistert. De standaard proxy_read_timeout van nginx van 60 seconden telt alleen de tijd tussen twee leesacties, en ntfy verstuurt standaard elke 45 seconden een keepalive-bericht (keepalive-interval), precies om te voorkomen dat tussenliggende systemen de verbinding sluiten wegens inactiviteit. Een inactieve subscriber blijft daarom verbonden, zelfs achter een standaard nginx-configuratie, en de langere timeouts dienen als extra marge, niet als het mechanisme dat de verbinding in stand houdt. Als u keepalive-interval verhoogt, houd deze dan onder de read-timeout van uw proxy.

Gebruikers aanmaken en topics beveiligen

Authenticatie is ingeschakeld en niemand heeft nog ergens toegang toe; dat is precies de bedoeling. Maak één beheerdersaccount voor uzelf aan en één machine-account voor scripts. Deze commando's lezen /etc/ntfy/server.yml vanuit de container, wat de reden is dat het configuratiebestand een volume-mount is.

sudo docker compose exec ntfy ntfy user add --role=admin admin
sudo docker compose exec ntfy ntfy user add robot
sudo docker compose exec ntfy ntfy user list

Elk user add-commando vraagt om een wachtwoord. Een beheerder negeert de toegangslijst en kan elk topic lezen en beschrijven; bewaar dat account dus voor uzelf en de mobiele app. robot is een gewone gebruiker zonder enige toegang totdat u deze verleent.

sudo docker compose exec ntfy ntfy access robot alerts write
sudo docker compose exec ntfy ntfy access robot "alerts_*" write
sudo docker compose exec ntfy ntfy access

Een ACL-item (access control list) bestaat uit een gebruiker, een topic en een permissie. Het topic is ofwel een letterlijke naam of een patroon waarbij * alles matcht, dus alerts_* dekt alerts_backup en alerts_db zonder dat u per host een commando hoeft uit te voeren. De permissie write betekent alleen publiceren, zodat een token dat uit een cron-job wordt gestolen niet kan subscriben en teruglezen wat het heeft verzonden. De speciale gebruikersnaam everyone bepaalt wat een niet-geauthenticeerde bezoeker mag doen. Met deny-all als standaardinstelling gebruikt u dit meestal om iets bewust openbaar te maken, zoals ntfy access everyone status read, en het accepteert ook deny wanneer u een expliciete regel wilt die anonieme bezoekers van een topic weert.

Scripts moeten een token gebruiken, niet uw wachtwoord.

sudo docker compose exec ntfy ntfy token add robot

Het commando toont een token dat begint met tk_. Een token erft exact de toegangsrechten van de gebruiker waartoe het behoort, dus dit token kan alleen publiceren naar de alerts-topics en verder niets. ntfy token list toont welke tokens bestaan en ntfy token remove trekt er een in zonder het wachtwoord van de gebruiker te wijzigen.

Verstuur uw eerste bericht en controleer of de vergrendeling werkt

Begin met te controleren of de deur gesloten is.

curl -s -o /dev/null -w '%{http_code}\n' -d "hello" https://ntfy.example.com/alerts

Dit voert 403 uit, en 403 is het juiste antwoord: auth-default-access: "deny-all" weigert een anonieme publicatie. Verstuur nu een echt bericht.

curl -H "Authorization: Bearer tk_REPLACE_WITH_YOUR_TOKEN" \
  -H "Title: Nightly backup finished" \
  -H "Priority: default" \
  -H "Tags: white_check_mark" \
  -d "42 GB copied in 11 minutes" \
  https://ntfy.example.com/alerts

De server antwoordt met het opgeslagen bericht in JSON-formaat; zo weet u dat het bericht is geaccepteerd in plaats van genegeerd. Title is de vetgedrukte eerste regel. Priority loopt van 1 tot 5, of op naam van min tot urgent, en bepaalt of de telefoon een geluid maakt. Tags worden emoji's in de notificatie wanneer de naam overeenkomt met een bekende emoji-shortcode, en blijven platte tekst wanneer dit niet het geval is.

Om een onderwerp vanuit een terminal te monitoren, streamt u het als volgt:

curl -s -u admin https://ntfy.example.com/alerts/raw

curl vraagt om het wachtwoord. Elk bericht komt binnen als één regel, en de lege regels die af en toe verschijnen zijn keepalives. Door https://ntfy.example.com in een browser te openen en in te loggen met hetzelfde account, krijgt u de web-app-versie van dezelfde stream.

Stel limieten in zodat één script de server niet kan overspoelen

Standaard krijgt elke bezoeker een bucket van 60 verzoeken, die wordt aangevuld met één verzoek per 5 seconden. Dat is ruim voor een privéserver, en een script dat vastzit in een retry-loop zal dit volledig verbruiken. Voeg limieten toe aan server.yml.

visitor-request-limit-burst: 30
visitor-request-limit-replenish: "10s"
visitor-message-daily-limit: 500
sudo docker compose restart ntfy

Een bezoeker die de limiet overschrijdt, krijgt HTTP 429 in plaats van een afgeleverd bericht. De limiet wordt geteld per bezoekersadres, wat de reden is waarom behind-proxy: true zo belangrijk is: zonder dit ziet ntfy alleen het adres van Caddy, telt elke client als dezelfde bezoeker, en put één luidruchtig script de bucket uit die uw telefoon en uw andere servers delen. Vanaf v2.36.0 blijven dagelijkse aantallen na herstarts behouden in de gebruikersdatabase, en de toelage van elke bezoeker wordt gereset op een eigen cyclus van 24 uur in plaats van om middernacht UTC.

Waarschuwing bij een falende cron job

Houd het token buiten de command line. ps aux toont de volledige command line van elk draaiend proces aan elke gebruiker op de server, waardoor een token dat wordt meegegeven met -H leesbaar is voor elk lokaal account zolang curl draait. Een curl-configuratiebestand voorkomt dit.

sudo install -d -m 700 /etc/ntfy-alert
printf 'header = "Authorization: Bearer tk_REPLACE_WITH_YOUR_TOKEN"\n' | sudo tee /etc/ntfy-alert/curlrc
sudo chmod 600 /etc/ntfy-alert/curlrc

Verpak nu de taak. Sla dit op als /usr/local/bin/backup-with-alert.sh en maak het chmod 750.

#!/bin/bash
out=$(/usr/local/bin/backup.sh 2>&1)
code=$?
if [ "$code" -ne 0 ]; then
  printf '%s' "$out" | tail -c 1000 | curl -K /etc/ntfy-alert/curlrc \
    -H "Title: backup.sh failed with exit $code" \
    -H "Priority: high" \
    -H "Tags: warning" \
    --data-binary @- \
    https://ntfy.example.com/alerts
fi
exit "$code"
17 3 * * * /usr/local/bin/backup-with-alert.sh >> /var/log/backup-alert.log 2>&1

$? wordt direct na het commando opgevangen, omdat het volgende uitgevoerde commando het anders zou overschrijven. De output gaat door tail -c 1000 omdat ntfy een maximale berichtgrootte afdwingt en een notificatie geen logviewer is. De afsluitende exit "$code" behoudt de oorspronkelijke status, zodat andere processen die deze taak monitoren nog steeds een foutmelding zien. Test het geheel door het script voor één run naar /bin/false te laten wijzen.

Een foutafhandeling die nooit wordt uitgevoerd is slechter dan geen waarschuwing, omdat het lijkt alsof stilte succes betekent. Cron geeft uw taak een vrijwel lege omgeving en een veel kortere PATH dan uw login-shell, waardoor een script dat handmatig werkt kan crashen voordat het de curl-regel bereikt. De handleiding over waarom een cron job niet draait behandelt deze omgevingsvalkuilen. Gebruik overal absolute paden en lees het logbestand na de eerste geplande run in plaats van er zomaar vanuit te gaan dat het werkt.

Waarschuwing bij het falen van een systemd-unit

Cron is geschikt voor geplande taken. Voor langlopende services gebruikt u OnFailure=, dat systemd uitvoert zodra een unit de status failed bereikt. Maak één template-unit aan en hergebruik deze voor elke service op de server. Sla dit op als /etc/systemd/system/ntfy-unit-failed@.service.

[Unit]
Description=Send an ntfy alert because %i failed

[Service]
Type=oneshot
ExecStart=/usr/local/bin/ntfy-unit-failed %i

Voer vervolgens /usr/local/bin/ntfy-unit-failed uit, met modus 750:

#!/bin/bash
unit="$1"
journalctl -u "$unit" -n 15 --no-pager -o cat | tail -c 1000 | curl -K /etc/ntfy-alert/curlrc \
  -H "Title: $unit failed on $(hostname -s)" \
  -H "Priority: urgent" \
  -H "Tags: rotating_light" \
  --data-binary @- \
  https://ntfy.example.com/alerts

Koppel dit aan een service met een drop-in, zodat een pakket-upgrade uw wijziging niet kan overschrijven.

sudo systemctl edit myapp.service
[Unit]
OnFailure=ntfy-unit-failed@%n.service

%n wordt uitgebreid naar de volledige unit-naam, waardoor de geïnstantieerde unit ntfy-unit-failed@myapp.service.service wordt, en %i binnen de template geeft myapp.service door aan het script als het eerste argument. Hierdoor kan één template voor elke unit dienen. Controleer of het werkt met een unit die opzettelijk faalt, opgeslagen als /etc/systemd/system/ntfy-selftest.service.

[Unit]
Description=Deliberately failing unit
OnFailure=ntfy-unit-failed@%n.service

[Service]
Type=oneshot
ExecStart=/bin/false
sudo systemctl daemon-reload
sudo systemctl start ntfy-selftest.service

Het startcommando eindigt met een non-zero status en print Job for ntfy-selftest.service failed because the control process exited with error code; de telefoon zou ongeveer een seconde later moeten trillen. Verwijder de test-unit daarna.

Eén valkuil verdient aandacht. OnFailure= wordt alleen uitgevoerd wanneer een unit de status failed bereikt, en RestartMode=direct slaat die status over tijdens automatische herstarts, waardoor ook de failure-handler wordt overgeslagen. Met de standaard RestartMode=normal doorlopen automatische herstarts de gefaalde status wel. StartLimitBurst en StartLimitIntervalSec bepalen wanneer herhaalde starts worden geweigerd; stel deze zo in dat een crash-loop uiteindelijk stopt. Timers zijn het schonere alternatief voor het bovenstaande cron-patroon, aangezien de service-unit van een timer dezelfde OnFailure= drop-in ondersteunt, en de handleiding voor systemd-services en timers op een VPS legt uit hoe u deze converteert.

Koppel een uptime-monitor aan hetzelfde topic

Uptime Kuma, de zelfgehoste statusmonitor, wordt geleverd met een ntfy-notificatietype. Open Settings, ga naar Notifications, kies Setup Notification, selecteer Ntfy, stel de server-URL in op https://ntfy.example.com en het topic op alerts, kies een prioriteit en plak het robot access token. Verstuur een testnotificatie voordat u de instellingen opslaat, omdat een onjuiste topicnaam een foutmelding geeft bij een write-toegang die het topic niet dekt.

De beperking van deze opzet is: een monitor die op dezelfde VPS draait, kan niet detecteren dat de VPS zelf offline is, en ntfy kan geen melding sturen als ntfy zelf onbereikbaar is. Draai de monitor op een andere machine en configureer een tweede notificatiekanaal, zoals e-mail, voor de monitor die ntfy in de gaten houdt. Het Push-monitortype van Uptime Kuma dekt de andere blinde vlek: uw cron job roept een push-URL aan na een succesvolle uitvoering, en Kuma geeft een waarschuwing wanneer deze aanroepen stoppen. Een foutmelding wordt alleen gegenereerd wanneer de taak daadwerkelijk wordt uitgevoerd; dit zegt dus niets over een taak die nooit is gestart.

Werkt zelf-gehoste ntfy op Android en iPhone?

Op Android werkt dit zonder beperkingen. Installeer de app via Google Play of F-Droid, open de instellingen, stel de standaardserver in op https://ntfy.example.com, voeg uw account toe in het gebruikersbeheerscherm en abonneer u vervolgens op alerts. Voor directe aflevering draait er een voorgrondservice, zodat berichten ook aankomen wanneer de telefoon in de sluimerstand staat. De permanente melding die hierbij hoort, is een vereiste van Android voor voorgrondservices en geen bug. De F-Droid-versie bevat geen Firebase-code, waardoor elk abonnement gebruikmaakt van directe aflevering. ntfy kan ook fungeren als een UnifiedPush-distributeur, een open vervanger voor de push-dienst van Google, zodat andere apps die UnifiedPush ondersteunen ook via uw server kunnen bezorgen.

In de officiële iOS-app werkt het met één afhankelijkheid die u niet kunt verwijderen. iOS schorst apps die op de achtergrond draaien. De achtergrondmodi die Apple toestaat (zoals audio afspelen, locatie-updates ontvangen of geplande taken verwerken) staan niet toe dat een app wacht op een bericht van uw server. Een snelle activering moet daarom via APNs (Apple push notification service) verlopen. Alleen een aanbieder met geautoriseerde inloggegevens voor de app mag berichten sturen; uw server heeft dus geen manier om de officiële app direct te bereiken. ntfy lost dit op met een relay: uw server stuurt een poll_request met het bericht-ID naar ntfy.sh, die het via Firebase en APNs doorstuurt om de app te wekken. De app haalt vervolgens de inhoud van het bericht op bij uw server.

upstream-base-url: "https://ntfy.sh"

Wees u bewust van de kosten hiervan. De inhoud van het bericht blijft op uw eigen server, maar het feit dat er een bericht is binnengekomen, inclusief het ID, verloopt via infrastructuur die u niet zelf beheert. Zonder deze instelling komen meldingen op een iPhone van een zelf-gehoste server uiteindelijk wel aan, maar de documentatie van ntfy waarschuwt dat de vertraging kan oplopen tot uren, omdat niets de app tijdig wekt. Om een native iOS-app te gebruiken zonder de ntfy.sh-relay, moet u de app zelf bouwen en distribueren met uw eigen Apple-ontwikkelaarsaccount en uw eigen APNs-sleutels. Dit brengt jaarlijkse kosten met zich mee en vereist een nieuwe build bij elke update. Een andere route is de PWA van ntfy op iOS 16.4 of later: voeg deze toe aan het beginscherm en configureer Web Push op uw server. Dit vermijdt de ntfy.sh-relay, maar maakt nog steeds gebruik van de push-infrastructuur van de browser. Als de relay onacceptabel is voor uw gebruik, houd de notificaties dan op Android of de desktop-web-app.

Back-ups, upgrades en het vastzetten van de image

Twee paden kunnen niet opnieuw worden gegenereerd: /etc/ntfy/server.yml en /var/lib/ntfy/user.db. De tweede bevat elke gebruiker, wachtwoordhash, ACL-item en token, dus behandel deze als een privésleutel.

sudo tar czf ntfy-backup.tgz -C / etc/ntfy var/lib/ntfy
sudo chmod 600 ntfy-backup.tgz

Kopieer dat bestand van de server af. cache.db bevat recente berichten, 12 uur aan berichten met de bovenstaande cache-duration, plus elk bericht dat gepland staat voor latere aflevering, dat blijft staan tot 12 uur nadat het is afgeleverd. Tenzij u berichten vooruit plant, kost het verlies ervan niets dat bescherming waard is. Upgraden betekent de tag in het compose-bestand bewerken, de image ophalen en de container opnieuw aanmaken.

sudo docker compose pull
sudo docker compose up -d
curl -s https://ntfy.example.com/v1/health

Lees eerst de release notes. De SQLite-databases migreren bij het opstarten, dus terugkeren naar een oudere tag na een schemawijziging is niet veilig. v2.31.1 verplaatste bijvoorbeeld de message cache naar schemaversie 17, en de upgrade-notities vermelden dat een downgrade naar v2.31.0 of eerder vereist dat die versie handmatig wordt teruggezet naar 16. Upgraden naar v2.36.0 reset de bestaande dagelijkse aantallen van iedereen één keer. Bewaar de back-up die u zojuist hebt gemaakt totdat de nieuwe versie een dag heeft gedraaid. De notities markeren ook gedragswijzigingen. Vanaf v2.31.0 ontvangt een client die opnieuw verbindt met since=<message ID> ook berichten die in dezelfde seconde zijn gepubliceerd, waardoor deze een duplicaat kan zien. De ntfy-apps en de web-app verwijderen duplicaten op basis van bericht-ID, maar een eigen script dat een topic opnieuw afspeelt, moet hetzelfde doen. Elke service op de server heeft zijn eigen korte lijst met paden die niet opnieuw kunnen worden gegenereerd, en de vergelijking van PhotoPrism en Immich werkt die lijst, en de bijbehorende back-upcommando's, uit voor een fotobibliotheek op hetzelfde type VPS.

Gotify en Apprise

Gotify is de compactere optie: één binary met een web-UI en een Android-app, waarbij berichten per applicatie worden georganiseerd. Dit is geschikt voor een privéserver waarbij Android het enige doelplatform is. Apprise is een Python-bibliotheek en command-line tool, met een afzonderlijke Apprise API-server beschikbaar. Het verstuurt één bericht naar meer dan honderd diensten, waaronder ntfy. Dit is geschikt voor scripts die meerdere bestemmingen tegelijk moeten bereiken. ntfy biedt een server, een HTTP API en apps op beide mobiele platformen; daarom is dit de gebruikelijke keuze voor het versturen van meldingen vanaf een gehuurde server.

FAQ

Waarom krijg ik een 403-foutmelding bij het publiceren naar mijn ntfy-server?

Met auth-default-access: "deny-all" in server.yml wordt anoniem publiceren geweigerd; dit is het beoogde gedrag. Stuur inloggegevens mee met -u user:pass of -H "Authorization: Bearer tk_...". Als u al een token meestuurt en toch 403 ontvangt, controleer dan of de gebruiker een ACL-vermelding heeft die schrijfrechten voor het onderwerp toestaat: zonder overeenkomende vermelding weigert read-only of deny de publicatie. In v2.34.0 konden gelijktijdige verzoeken vanaf hetzelfde IP-adres ertoe leiden dat geldige inloggegevens als anoniem werden behandeld; v2.35.0 lost deze bug op, dus voer een upgrade uit voordat u een incidentele 403 als bewijs van een ACL-probleem beschouwt. Voer ntfy access uit om de volledige lijst weer te geven. Houd er rekening mee dat een write-toewijzing geen recht geeft om te abonneren, dus een account dat correct publiceert, wordt nog steeds geweigerd wanneer het probeert hetzelfde onderwerp te lezen.

Werken notificaties op een iPhone met een zelfgehoste ntfy-server?

Ze werken via een relay wanneer u de officiële iOS-app gebruikt. Een snelle activering van een gesuspendeerde iPhone-app moet via APNs (Apple push notification service) verlopen. Omdat verzenden naar de officiële app de push-inloggegevens van de uitgever vereist, stuurt ntfy een poll_request met de bericht-ID door naar ntfy.sh, die het vervolgens doorstuurt naar het apparaat. Stel upstream-base-url: "https://ntfy.sh" in server.yml in en herstart de container. De berichtinhoud zelf wordt nog steeds van uw eigen server opgehaald. Zonder deze instelling komen iOS-notificaties uiteindelijk wel aan, maar de documentatie van ntfy waarschuwt dat de vertraging kan oplopen tot uren. De PWA biedt een alternatieve route op iOS 16.4 of later wanneer Web Push op uw server is geconfigureerd.

Waarom is mijn ntfy-waarschuwing vanuit een cron job nooit aangekomen?

Voer de curl-regel eerst handmatig uit om te verifiëren of het token en het onderwerp correct zijn. Als het handmatig wel werkt maar niet vanuit cron, ligt de fout stroomopwaarts van de waarschuwing: cron voert taken uit met een minimale omgeving en een kort PATH, waardoor een script dat een commando bij de naam alleen aanroept, kan falen voordat de curl-regel wordt bereikt. Gebruik absolute paden, stuur de uitvoer van de taak door naar een logbestand en lees dat bestand na de volgende uitvoering. Een 429-respons in plaats van een aflevering betekent dat een limiet het verzoek heeft geweigerd. Meestal probeert het script te snel opnieuw, maar een bezoeker die een dagelijks quotum heeft verbruikt, zoals de hierboven ingestelde berichtlimiet, wordt op dezelfde manier geweigerd, zelfs bij een enkel verzoek.

Moet ik ntfy blootstellen aan het openbare internet?

De telefoon-apps moeten de server kunnen bereiken via mobiele netwerken, dus een openbaar HTTPS-eindpunt met auth-default-access: "deny-all" en ACL's per onderwerp is de standaardconfiguratie. Dit is veilig zolang geen enkel onderwerp leesbaar is voor everyone. Een instantie die alleen via VPN bereikbaar is, is zinvol wanneer elke abonnee een machine is die u beheert. Dit is minder geschikt voor telefoons, omdat de app alleen berichten ontvangt terwijl de tunnel actief is; waarschuwingen worden in de wachtrij geplaatst totdat de telefoon opnieuw verbinding maakt.

Was dit artikel nuttig?