SSD Nodes Learn Hosting plans →
Guide Matt ConnorDi Matt Connor

Self-host ntfy: alert push per server con Docker

Configura ntfy sul tuo VPS con Docker Compose e TLS: proteggi i topic con utenti e ACL, poi invia avvisi da cron e unit systemd OnFailure.

Cosa fa un server ntfy self-hosted

Un server ntfy self-hosted trasforma una richiesta HTTP POST in una notifica push sul telefono. Pubblicare un messaggio è sufficiente con curl: il messaggio arriva nell'app Android, nell'app iOS, in una scheda del browser o in qualsiasi altro client in grado di mantenere aperta una connessione HTTP. Non è necessario installare una libreria client né eseguire un message broker.

ntfy indirizza i messaggi tramite topic. Un topic è un nome nel percorso dell'URL, ad esempio https://ntfy.example.com/alerts, e viene creato nel momento in cui qualcuno pubblica un messaggio su quel topic. In un'installazione predefinita, chiunque conosca quel nome può leggere il topic e pubblicarvi messaggi. Per questo la documentazione del progetto paragona il nome di un topic a una password. Questo modello è adatto al servizio pubblico ntfy.sh. Non è adatto a un server che deve notificare i problemi dei backup. Per questo motivo, questa guida abilita l'autenticazione prima dell'invio del primo messaggio.

Cosa serve prima di iniziare

Serve un VPS con Ubuntu 24.04 o Debian 13, Docker Engine e il plugin Compose installati, un nome di dominio e una quantità minima di RAM. Crea un record DNS (domain name system) di tipo A che punti ntfy.example.com all'indirizzo IP pubblico del server, quindi verifica che la risoluzione funzioni prima di eseguire qualsiasi altra operazione.

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

dig deve restituire l'indirizzo IP del server. Per emettere il certificato, il nome host deve risolvere pubblicamente verso il server tramite un record A o AAAA. La porta 80 deve rimanere aperta perché ACME (automatic certificate management environment), il protocollo utilizzato da Let's Encrypt, la usa per la verifica HTTP. Il container ntfy non espone mai una porta pubblica.

Scrivere il file di configurazione di ntfy

L'immagine Docker non contiene un file di configurazione, quindi è necessario crearne uno. Tutti i comandi successivi di questa guida lo leggeranno. Per prima cosa, individuare l'ID utente e l'ID gruppo con cui verrà eseguito il container.

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

Quattro di queste righe definiscono gli aspetti principali. base-url deve essere l'indirizzo HTTPS pubblico esatto, perché ntfy lo usa per generare i link agli allegati e per le notifiche push iOS self-hosted. listen-http: ":2586" effettua il binding su tutte le interfacce del container. Anche se può sembrare una configurazione poco restrittiva, è corretto: il container ha un proprio namespace di rete, quindi effettuare il binding su 127.0.0.1 renderebbe la porta irraggiungibile dall'host e la porta pubblicata da Docker non riuscirebbe a stabilire la connessione. auth-default-access: "deny-all" definisce l'intera configurazione di sicurezza, perché nega le operazioni di lettura e scrittura a chiunque non disponga di un'autorizzazione esplicita. behind-proxy: true indica a ntfy di ricavare l'indirizzo del client dall'header X-Forwarded-For, in modo che i limiti di frequenza conteggino gli utenti reali invece di considerare il reverse proxy come un unico client molto attivo.

enable-login: true consente agli utenti di accedere tramite l'applicazione web o l'API. enable-signup resta impostato su false, perché consentire la creazione autonoma degli account su un server privato esporrebbe un punto di accesso non necessario.

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

Eseguire ntfy con Docker Compose

Inserisci questo contenuto in /opt/ntfy/compose.yaml, sostituendo 1000:1000 con i due numeri id -u e id -g stampati sopra.

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

Un server funzionante risponde a {"healthy":true,"role":"active"}. Due dettagli in quel file Compose sono intenzionali. L'immagine è fissata a v2.36.0, la release stabile corrente al 1 novembre 2026, invece di latest, perché con latest il successivo docker compose pull scarica l'immagine corrente e un successivo docker compose up -d ricrea il container con quella versione; il solo pull non modifica la versione del server in esecuzione. Anche un tag fissato deve essere aggiornato. Solo ottobre 2026 ha portato dieci release: v2.29.0 il 7 ottobre, v2.30.0 il 12 ottobre, v2.31.0 e v2.31.1 il 16 ottobre, v2.32.0 il 18 ottobre, v2.33.0 e v2.33.1 il 23 ottobre, v2.34.0 il 24 ottobre, v2.35.0 il 30 ottobre e v2.36.0 il 31 ottobre. v2.31.0 corregge la perdita dei messaggi quando un client si riconnette prima che raggiungano la cache dei messaggi, ma le riconnessioni con since=<message ID> leggono dal database tutti i messaggi del topic e ntfy.sh ha eseguito il rollback da quella versione. v2.31.1 corregge questo carico con un nuovo indice, mentre v2.34.0 corregge il problema per cui gli utenti revocati o eliminati conservavano alcune sottoscrizioni. v2.35.0 corregge le richieste concorrenti che trattavano credenziali valide come anonime e un bypass dell'autorizzazione del gateway push Matrix su SQLite; porta quindi i tag più vecchi a v2.36.0. La porta è pubblicata come 127.0.0.1:2586:2586, quindi il container è raggiungibile soltanto dall'indirizzo di loopback dell'host. Scrivi invece 2586:2586: Docker inserisce le proprie regole firewall prima delle tue, perciò la porta risponde da Internet anche se ufw status indica che è chiusa. Entrambe queste impostazioni si applicano anche al container successivo: un relay RustDesk self-hosted fissa il tag della propria immagine nello stesso modo, ma non può essere vincolato al loopback, perché le porte signal e relay devono rispondere da Internet.

Se curl stampa Connection refused, leggi il log del container. Un errore di permessi su /var/lib/ntfy/user.db indica che la riga user: non corrisponde al proprietario di quelle directory; il processo quindi non può creare il proprio database e termina. La guida ai fondamenti di Docker Compose per un VPS descrive più dettagliatamente la proprietà dei volumi e le policy di riavvio.

Impostare TLS davanti al servizio con Caddy

Caddy richiede e rinnova autonomamente il certificato. È il modo più rapido per avere TLS (sicurezza del livello di trasporto) funzionante.

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

Sostituire il contenuto di /etc/caddy/Caddyfile con tre righe.

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

Lo stesso {"healthy":true,"role":"active"} su HTTPS conferma che l'intero percorso funziona. Un 502 da Caddy indica in genere che ntfy non è in ascolto: verificare con sudo ss -lntp | grep 2586. Se ntfy è in ascolto e 502 persiste, Caddy registra l'errore riscontrato sull'upstream, ad esempio una connessione reimpostata. Un errore del certificato indica in genere che il record DNS è errato oppure che la convalida del certificato non riesce a raggiungere il server sulla porta 80 o 443; controllare sudo journalctl -u caddy -n 50 per visualizzare l'errore di convalida. Per aggiungere in seguito un altro servizio basta inserire un ulteriore blocco hostname nello stesso Caddyfile. È così che un servizio come Halcyon, un'interfaccia video store degli anni '90 per la libreria Jellyfin può essere pubblicato su un secondo sottodominio dello stesso server.

Se si usa già nginx, copiare le impostazioni proxy documentate da ntfy: proxy_http_version 1.1, proxy_buffering off, proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for e timeout di lettura e invio di almeno tre minuti. Un subscriber mantiene aperta una connessione HTTP per tutto il tempo in cui è in ascolto. Il valore predefinito di nginx, proxy_read_timeout pari a 60 secondi, conta soltanto il tempo tra due letture; ntfy invia per impostazione predefinita un messaggio keepalive ogni 45 secondi (keepalive-interval), proprio per impedire agli intermediari di chiudere la connessione per inattività. Di conseguenza, un subscriber inattivo resta connesso anche dietro nginx con la configurazione predefinita. I timeout più lunghi forniscono margine aggiuntivo, ma non sono ciò che mantiene attiva la connessione. Se si aumenta keepalive-interval, mantenerlo inferiore al timeout di lettura del proxy.

Creare utenti e limitare l'accesso ai topic

L'autenticazione è attiva e nessuno ha ancora accesso a nulla: è proprio questo l'obiettivo. Crea un account amministratore per te e un account macchina per gli script. Questi comandi leggono /etc/ntfy/server.yml dall'interno del container; per questo il file di configurazione è montato come volume.

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

Ogni comando user add richiede una password. Un amministratore ignora l'elenco di controllo degli accessi e può leggere e scrivere su ogni topic; usa quindi questo account solo per te e per l'app del telefono. robot è un utente normale senza alcun accesso finché non gliene concedi uno.

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

Una voce ACL (elenco di controllo degli accessi) associa un utente, un topic e un permesso. Il topic può essere un nome letterale oppure un pattern in cui * corrisponde a qualsiasi valore; in questo modo alerts_* include alerts_backup e alerts_db senza dover eseguire un comando per ogni host. Il permesso write significa che l'utente può solo pubblicare; così, se un token viene sottratto da un cron job, non può sottoscrivere il topic e rileggere ciò che ha inviato. Il nome utente speciale everyone definisce le operazioni consentite a un visitatore non autenticato. Con deny-all come valore predefinito, lo useresti soprattutto per rendere deliberatamente pubblico qualcosa, ad esempio ntfy access everyone status read; accetta anche deny quando vuoi una regola esplicita che impedisca ai visitatori anonimi di accedere a un topic.

Gli script devono usare un token, non la tua password.

sudo docker compose exec ntfy ntfy token add robot

Il comando stampa un token che inizia con tk_. Un token eredita esattamente i permessi dell'utente a cui appartiene; questo token può quindi pubblicare sui topic alerts e non può fare altro. ntfy token list mostra ciò che esiste e ntfy token remove revoca un token senza modificare la password dell'utente.

Invia il primo messaggio e verifica che il blocco funzioni

Inizia verificando che la porta sia chiusa.

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

Il comando stampa 403 e 403 è la risposta corretta: auth-default-access: "deny-all" rifiuta una pubblicazione anonima. Ora invia un messaggio reale.

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

Il server restituisce il messaggio memorizzato in formato JSON. Questo conferma che il messaggio è stato accettato e non ignorato. Title è la prima riga in grassetto. Priority usa valori da 1 a 5 oppure, per nome, da min a urgent; determina se il telefono emette un suono. Tags diventano emoji nella notifica quando il nome corrisponde a uno short code emoji noto e restano testo normale negli altri casi.

Per monitorare un topic dal terminale, trasmetti il relativo flusso:

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

curl richiede la password. Ogni messaggio arriva su una singola riga; le righe vuote che compaiono occasionalmente sono keepalive. Aprendo https://ntfy.example.com in un browser e accedendo con lo stesso account, ottieni la versione web dello stesso flusso.

Impostare i limiti di frequenza per impedire a uno script di saturare il server

Per impostazione predefinita, ogni visitatore riceve un bucket di 60 richieste, rifornito al ritmo di una richiesta ogni 5 secondi. Questo limite è ampio per un server privato e uno script bloccato in un ciclo di retry lo consumerà interamente. Aggiungi i limiti a server.yml.

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

Un visitatore che supera il limite riceve HTTP 429 invece del messaggio. Il limite viene conteggiato per indirizzo del visitatore. Per questo behind-proxy: true è così importante: senza questa impostazione ntfy vede soltanto l'indirizzo di Caddy, tutti i client risultano lo stesso visitatore e un singolo script rumoroso esaurisce il bucket condiviso dal telefono e dagli altri server. A partire da v2.36.0, i conteggi giornalieri sopravvivono ai riavvii nel database degli utenti e la disponibilità di ogni visitatore viene azzerata secondo il proprio ciclo di 24 ore, invece che a mezzanotte UTC.

Avviso da un cron job che non riesce

Non inserire il token nella riga di comando. ps aux mostra la riga di comando completa di ogni processo in esecuzione a tutti gli utenti del sistema, quindi un token passato con -H è leggibile da qualsiasi account locale per tutta la durata di curl. Un file di configurazione di curl evita questo problema.

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

Ora racchiudi il job in uno script. Salva il contenuto come /usr/local/bin/backup-with-alert.sh e rendilo eseguibile con 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

$? viene acquisito nella riga immediatamente successiva al comando, perché l'esecuzione del comando seguente lo sovrascriverebbe. L'output passa attraverso tail -c 1000 perché ntfy impone una dimensione massima per i messaggi e una notifica non sostituisce un visualizzatore di log. exit "$code" finale conserva lo stato originale, quindi qualsiasi altro componente che controlla questo job continua a rilevare un errore. Verifica l'intera procedura configurando lo script in modo che utilizzi /bin/false per una sola esecuzione.

Un ramo di errore che non viene mai eseguito è peggiore dell'assenza di notifiche, perché può far sembrare che il silenzio indichi un'esecuzione riuscita. Cron fornisce al job un ambiente quasi vuoto e un PATH molto più breve rispetto alla shell di login, quindi uno script che funziona quando lo esegui manualmente può terminare prima di arrivare alla riga curl. La guida sul motivo per cui un cron job non viene eseguito descrive questi problemi legati all'ambiente. Usa sempre percorsi assoluti e leggi il file di log dopo la prima esecuzione pianificata, senza dare per scontato che tutto funzioni.

Avvisi quando un'unità systemd non riesce ad avviarsi

Cron gestisce le attività pianificate. I servizi a esecuzione prolungata richiedono OnFailure=, che systemd esegue ogni volta che un'unità entra nello stato failed. Create un'unica unità modello e riutilizzatela per ogni servizio del server. Salvate il file come /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

Quindi /usr/local/bin/ntfy-unit-failed, con modalità 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

Collegatela a un servizio tramite un drop-in, in modo che un aggiornamento del pacchetto non possa sovrascrivere le modifiche.

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

%n viene sostituito con il nome completo dell'unità, quindi l'unità istanziata diventa ntfy-unit-failed@myapp.service.service, mentre %i all'interno del modello passa myapp.service allo script come primo argomento. Questo consente di usare lo stesso modello per ogni unità. Verificate il funzionamento con un'unità che fallisce intenzionalmente, salvata come /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

Il comando di avvio termina con un codice diverso da zero e stampa Job for ntfy-selftest.service failed because the control process exited with error code; il telefono dovrebbe emettere una notifica circa un secondo dopo. Eliminate l'unità di test al termine.

È importante considerare un possibile errore. OnFailure= viene eseguito solo quando un'unità raggiunge lo stato failed, mentre RestartMode=direct salta questo stato durante i riavvii automatici e quindi salta anche il gestore degli errori. Con il valore predefinito RestartMode=normal, i riavvii automatici passano dallo stato failed. StartLimitBurst e StartLimitIntervalSec controllano quando i riavvii ripetuti vengono rifiutati; impostate questi parametri in modo che un ciclo di arresti anomali finisca per interrompersi. I timer sono il sostituto più adatto del modello basato su cron descritto sopra, perché l'unità di servizio di un timer supporta lo stesso drop-in OnFailure=; la guida ai servizi e ai timer systemd su un VPS illustra la procedura di conversione.

Collegare un monitor di uptime allo stesso topic

Uptime Kuma, il monitor di stato self-hosted, include un tipo di notifica ntfy. Aprire Settings, quindi Notifications e poi Setup Notification; scegliere Ntfy, impostare l’URL del server su https://ntfy.example.com e il topic su alerts, selezionare una priorità e incollare il token di accesso robot. Inviare la notifica di test prima di salvare, perché un nome di topic errato restituisce un errore quando un grant write non lo autorizza.

Il limite concreto di questa configurazione è il seguente: un monitor in esecuzione sullo stesso VPS non può rilevare che il VPS è inattivo e ntfy non può notificare che ntfy è inattivo. Eseguire il monitor su un’altra macchina e assegnargli un secondo canale di notifica, ad esempio l’e-mail, per il monitor che controlla ntfy stesso. Il tipo di monitor Push di Uptime Kuma copre l’altro punto cieco: il job cron chiama un URL push dopo un’esecuzione riuscita e Kuma genera un avviso quando le chiamate smettono di arrivare. Un ramo di errore si attiva soltanto quando il job viene eseguito, quindi non rileva un job che non è mai stato avviato.

Il server ntfy self-hosted funziona su Android e iPhone?

Su Android, sì, senza limitazioni. Installa l'app da Google Play o F-Droid, apri Impostazioni, imposta https://ntfy.example.com come server predefinito, aggiungi il tuo account nella schermata di gestione degli utenti, quindi sottoscrivi alerts. La consegna immediata mantiene attivo un foreground service, così i messaggi arrivano anche quando il telefono è in modalità doze. La notifica permanente associata è un requisito di Android per i foreground service, non un bug. La build F-Droid non contiene alcun codice Firebase, quindi ogni sottoscrizione usa la consegna immediata. ntfy può anche fungere da distributore UnifiedPush, un'alternativa aperta al servizio push di Google. In questo modo, anche le altre applicazioni che supportano UnifiedPush possono inviare notifiche tramite il tuo server.

Nell'app iOS ufficiale funziona, ma con una dipendenza che non puoi rimuovere. iOS sospende un'app quando passa in background. Le modalità in background consentite da Apple, come la riproduzione audio, la ricezione degli aggiornamenti sulla posizione e l'elaborazione delle attività pianificate, non consentono all'app di restare in attesa di un messaggio dal tuo server. Il risveglio immediato deve quindi passare da APNs (Apple push notification service). Solo un provider con credenziali autorizzate per l'app può inviarle notifiche. Il tuo server non può quindi raggiungere direttamente l'app ufficiale. ntfy risolve il problema tramite un relay: il tuo server invia a ntfy.sh un poll_request contenente l'ID del messaggio. ntfy.sh lo inoltra tramite Firebase e APNs per risvegliare l'app. L'app recupera quindi il corpo del messaggio dal tuo server.

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

È importante capire il costo di questa soluzione. Il contenuto del messaggio resta sul tuo server, ma il fatto che sia arrivato un messaggio e il relativo ID passano attraverso un'infrastruttura che non gestisci. Senza questa impostazione, le notifiche su iPhone provenienti da un server self-hosted arrivano comunque, ma la documentazione di ntfy avverte che il ritardo può arrivare a diverse ore, perché nulla risveglia rapidamente l'app. Per usare un'app iOS nativa senza il relay ntfy.sh, devi compilare e distribuire l'app con il tuo account Apple Developer e le tue chiavi APNs. Questo comporta un costo annuale e una nuova build per ogni aggiornamento. Un'altra possibilità è usare la PWA di ntfy su iOS 16.4 o versioni successive: aggiungila alla schermata Home e configura Web Push sul tuo server. In questo modo eviti il relay ntfy.sh, ma continui a usare l'infrastruttura push del browser. Se il relay non è accettabile nel tuo scenario, mantieni le notifiche su Android o sull'app web desktop.

Backup, aggiornamenti e blocco della versione dell'immagine

Due percorsi non possono essere rigenerati: /etc/ntfy/server.yml e /var/lib/ntfy/user.db. Il secondo contiene ogni utente, hash delle password, voce ACL e token; trattalo quindi come una chiave privata.

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

Copia quel file fuori dal server. cache.db contiene i messaggi recenti, per 12 ore con il cache-duration indicato sopra, oltre a ogni messaggio pianificato per una consegna futura, che rimane fino a 12 ore dopo la consegna. Se non pianifichi messaggi in anticipo, perderlo non comporta la perdita di dati importanti da proteggere. L'aggiornamento consiste nel modificare il tag nel file Compose, eseguire il pull dell'immagine e ricreare il container.

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

Leggi prima le note di rilascio. I database SQLite vengono migrati all'avvio, quindi il rollback a un tag precedente dopo una modifica dello schema non è sicuro. Per esempio, v2.31.1 ha spostato la cache dei messaggi alla versione 17 dello schema e le note di aggiornamento indicano che il downgrade a v2.31.0 o a una versione precedente richiede di riportare manualmente quella versione a 16. L'aggiornamento a v2.36.0 azzera una volta i conteggi giornalieri esistenti di tutti gli utenti. Conserva il backup appena creato finché la nuova versione non è rimasta in esecuzione per un giorno. Le note segnalano anche modifiche al comportamento. A partire da v2.31.0, un client che si riconnette con since=<message ID> riceve anche i messaggi pubblicati nello stesso secondo e potrebbe quindi visualizzare un duplicato. Le app ntfy e l'app web eliminano i duplicati in base all'ID del messaggio, ma uno script personalizzato che riproduce un topic deve fare lo stesso. Ogni servizio sul server ha un proprio breve elenco di percorsi che non possono essere rigenerati e il confronto tra PhotoPrism e Immich determina quell'elenco e i relativi comandi di backup per una libreria fotografica sullo stesso tipo di VPS.

Gotify e Apprise

Gotify è l’opzione più compatta: un unico binario con un’interfaccia web e un’app Android. I messaggi sono organizzati per applicazione. È adatto a un server privato in cui Android è l’unico dispositivo destinatario. Apprise è una libreria Python e uno strumento a riga di comando. È disponibile anche un server API Apprise separato. Consente di inoltrare un singolo messaggio a più di cento servizi, incluso ntfy. È adatto a uno script che deve raggiungere più destinazioni contemporaneamente. ntfy è la soluzione che offre un server, un’API HTTP e app per entrambe le piattaforme mobili. Per questo è la scelta più comune per gli avvisi provenienti da un server a noleggio.

FAQ

Perché la pubblicazione sul mio server ntfy restituisce 403?

Con auth-default-access: "deny-all" in server.yml, la pubblicazione anonima viene rifiutata: è il comportamento previsto. Invia le credenziali con -u user:pass o -H "Authorization: Bearer tk_...". Se stai già inviando un token ma ricevi ancora 403, verifica che l'utente associato disponga di una voce ACL che autorizzi la scrittura nel topic: in assenza di una voce corrispondente, read-only o deny rifiuta la pubblicazione. In v2.34.0, le richieste simultanee dallo stesso IP potevano inoltre far trattare credenziali valide come anonime; v2.35.0 corregge questo bug, quindi esegui l'aggiornamento prima di considerare un 403 intermittente come prova di un problema ACL. Esegui ntfy access per stampare l'elenco completo. Tieni presente che una concessione write non autorizza la sottoscrizione: un account che pubblica correttamente verrà comunque rifiutato quando tenta di leggere lo stesso topic.

Le notifiche funzionano su iPhone con un server ntfy self-hosted?

Funzionano tramite un relay quando usi l'app iOS ufficiale. Il risveglio tempestivo di un'app iPhone sospesa deve passare da APNs (Apple push notification service) e l'invio all'app ufficiale richiede le credenziali push del relativo publisher. Per questo ntfy inoltra a ntfy.sh un poll_request contenente l'ID del messaggio, che il servizio trasmette al dispositivo. Imposta upstream-base-url: "https://ntfy.sh" in server.yml e riavvia il container. Il corpo del messaggio viene comunque recuperato dal tuo server. Senza questa impostazione, le notifiche iOS arrivano comunque, ma la documentazione di ntfy avverte che il ritardo può arrivare a diverse ore. Su iOS 16.4 o versioni successive, la PWA offre un'alternativa quando Web Push è configurato sul server.

Perché l'avviso ntfy del mio job cron non è mai arrivato?

Esegui prima la riga curl separatamente, per verificare che il token e il topic siano corretti. Se funziona manualmente ma non da cron, il problema si verifica prima dell'avviso: cron esegue i job con un ambiente minimo e un PATH breve, quindi uno script che richiama un comando con il solo nome può terminare prima di arrivare alla riga curl. Usa percorsi assoluti, reindirizza l'output del job a un file di log e leggi quel file dopo l'esecuzione successiva. Una risposta 429 invece della consegna indica che una limitazione ha rifiutato la richiesta. Di solito lo script sta effettuando retry troppo rapidamente, ma anche un visitatore che ha esaurito una quota giornaliera, ad esempio il limite di messaggi impostato sopra, viene rifiutato allo stesso modo con una singola richiesta.

Devo esporre ntfy su Internet?

Le app per smartphone devono raggiungere il server dalle reti mobili, quindi un endpoint HTTPS pubblico con auth-default-access: "deny-all" e ACL per topic è la configurazione normale ed è sicura finché nessun topic è leggibile da everyone. Un'istanza accessibile solo tramite VPN è una scelta ragionevole quando ogni subscriber è una macchina sotto il tuo controllo. È invece poco adatta agli smartphone, perché l'app riceve le notifiche solo quando il tunnel è attivo; gli avvisi restano quindi in coda finché il telefono non si riconnette.

Questo articolo ti è stato utile?