SSD Nodes Learn Hosting plans →
Guias Matt ConnorPor Matt Connor

Como hospedar o ntfy para alertas de servidores

Aprenda a executar o ntfy em um VPS com Docker Compose e TLS, proteger tópicos com usuários e ACLs e enviar alertas por cron e systemd OnFailure.

O que um servidor ntfy autogerido faz

Um servidor ntfy autogerido transforma um HTTP POST numa notificação push no seu telemóvel. Pode publicar com curl, e a mensagem chega à aplicação Android, à aplicação iOS, a um separador do navegador ou a qualquer outro cliente que consiga manter uma ligação HTTP aberta. Não é necessário instalar uma biblioteca de cliente nem executar um message broker.

O ntfy identifica as mensagens por tópico. Um tópico é um nome no caminho do URL, como https://ntfy.example.com/alerts, e passa a existir no momento em que alguém publica nele. Numa instalação predefinida, qualquer pessoa que conheça esse nome pode ler o tópico e escrever nele. Por isso, a documentação do próprio projeto compara o nome de um tópico a uma password. Esse modelo é adequado para o serviço público ntfy.sh. Não é adequado para um servidor que transporta falhas dos seus backups. Por isso, este guia ativa a autenticação antes de a primeira mensagem ser enviada.

O que é necessário antes de começar

É necessário ter um VPS com Ubuntu 24.04 ou Debian 13, Docker Engine e o plugin Compose instalados, um nome de domínio e muito pouca RAM. Crie um registo DNS (sistema de nomes de domínio) do tipo A que aponte ntfy.example.com para o endereço IP público do servidor. Em seguida, confirme que o nome é resolvido antes de executar qualquer outra ação.

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

dig deve apresentar o IP do servidor. A emissão do certificado requer que o nome do host seja resolvido publicamente para o servidor através de um registo A ou AAAA. A porta 80 permanece aberta porque o ACME (ambiente de gestão automática de certificados), o protocolo usado pelo Let's Encrypt, utiliza-a para o desafio HTTP. O contentor ntfy não expõe nenhuma porta pública.

Escreva o ficheiro de configuração do ntfy

A imagem Docker não inclui um ficheiro de configuração, por isso é necessário criar um. Todos os comandos seguintes deste guia leem esse ficheiro. Primeiro, obtenha o ID do utilizador e o ID do grupo com os quais o contentor será executado.

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

Quatro dessas linhas são fundamentais. base-url tem de ser exatamente o endereço HTTPS público, porque o ntfy utiliza-o para gerar ligações para anexos e para as notificações push do iOS autoalojadas. listen-http: ":2586" faz o bind a todas as interfaces dentro do contentor. Embora isto possa parecer descuidado, está correto: o contentor tem o seu próprio namespace de rede, por isso fazer o bind a 127.0.0.1 nesse contexto tornaria a porta inacessível a partir do host e a porta publicada pelo Docker nunca conseguiria estabelecer a ligação. auth-default-access: "deny-all" define toda a política de segurança, porque recusa operações de leitura e escrita a qualquer pessoa sem uma autorização explícita. behind-proxy: true indica ao ntfy que deve obter o endereço do cliente a partir do cabeçalho X-Forwarded-For. Assim, os limites de pedidos contam os visitantes reais, em vez de contarem o reverse proxy como um único cliente com atividade muito elevada.

enable-login: true permite que os utilizadores iniciem sessão através da aplicação web ou da API. enable-signup permanece definido como false, porque permitir a criação autónoma de contas num servidor privado deixa uma porta aberta sem necessidade.

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

Execute o ntfy com Docker Compose

Coloque isto em /opt/ntfy/compose.yaml, substituindo 1000:1000 pelos dois números id -u e id -g apresentados acima.

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

Um servidor saudável responde em {"healthy":true,"role":"active"}. Há dois detalhes deliberados nesse ficheiro Compose. A imagem está fixada em v2.36.0, a versão estável atual em 1 de novembro de 2026, em vez de latest, porque, com latest, o próximo docker compose pull transfere a imagem atual e um docker compose up -d posterior recria o contentor com essa imagem; transferir a imagem, por si só, não altera a versão do servidor em execução. Uma versão fixada continua a precisar de atualização. Só outubro de 2026 trouxe dez versões: v2.29.0 em 7 de outubro, v2.30.0 em 12 de outubro, v2.31.0 e v2.31.1 em 16 de outubro, v2.32.0 em 18 de outubro, v2.33.0 e v2.33.1 em 23 de outubro, v2.34.0 em 24 de outubro, v2.35.0 em 30 de outubro e v2.36.0 em 31 de outubro. A v2.31.0 corrige mensagens perdidas quando um cliente se voltava a ligar antes de estas chegarem à cache de mensagens, mas as reconexões com since=<message ID> leem todas as mensagens do tópico a partir da base de dados, e o ntfy.sh reverteu essa versão. A v2.31.1 corrige essa carga com um novo índice, e a v2.34.0 corrige a retenção de algumas subscrições por utilizadores revogados ou eliminados. A v2.35.0 corrige pedidos simultâneos que tratavam credenciais válidas como anónimas e um bypass de autorização do gateway de push do Matrix no SQLite, por isso atualize versões fixadas antigas para v2.36.0. A porta é publicada como 127.0.0.1:2586:2586, por isso o contentor só é acessível a partir do endereço de loopback do anfitrião. Escreva 2586:2586 em vez disso e o Docker insere as suas próprias regras de firewall antes das suas, o que faz com que a porta responda a partir da Internet, mesmo que ufw status indique que está fechada. Ambos os padrões aplicam-se ao próximo contentor que adicionar: um relay RustDesk autoalojado fixa a tag da imagem da mesma forma, mas não pode ficar oculto atrás do loopback, porque as suas portas de sinalização e relay têm de responder a partir da Internet.

Se o curl imprimir Connection refused, consulte o log do contentor. Um erro de permissões em /var/lib/ntfy/user.db significa que a linha user: não corresponde ao proprietário desses diretórios, por isso o processo não consegue criar a sua própria base de dados e termina. O guia de conceitos básicos do Docker Compose para um VPS explica com mais detalhe a propriedade dos volumes e as políticas de reinício.

Coloque o TLS à frente com o Caddy

O Caddy solicita e renova o certificado automaticamente. Esta é a forma mais simples de obter TLS funcional (segurança da camada de transporte).

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

Substitua o conteúdo de /etc/caddy/Caddyfile por três linhas.

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

O mesmo {"healthy":true,"role":"active"} por HTTPS significa que todo o caminho está a funcionar. Um 502 do Caddy normalmente significa que o ntfy não está a escutar. Verifique com sudo ss -lntp | grep 2586. Se o ntfy estiver a escutar e o 502 persistir, os logs do Caddy registam o erro encontrado no upstream, como uma ligação reiniciada. Um erro de certificado normalmente significa que o registo DNS está incorreto ou que a validação do certificado não consegue alcançar o servidor na porta 80 ou 443. Consulte sudo journalctl -u caddy -n 50 para ver o erro de validação. Para adicionar outro serviço mais tarde, basta incluir mais um bloco de hostname no mesmo Caddyfile. É assim que algo como Halcyon, um frontend de videoclube dos anos 90 para a sua biblioteca Jellyfin fica disponível num segundo subdomínio do mesmo servidor.

Se já utiliza nginx, copie as definições de proxy documentadas pelo ntfy: proxy_http_version 1.1, proxy_buffering off, proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for e timeouts de leitura e escrita de pelo menos três minutos. Um subscriber mantém uma ligação HTTP aberta durante todo o período em que está a escutar. O proxy_read_timeout predefinido do nginx, de 60 segundos, contabiliza apenas o tempo entre duas leituras. O ntfy envia uma mensagem keepalive a cada 45 segundos por predefinição (keepalive-interval), precisamente para impedir que os intermediários fechem a ligação por inatividade. Por isso, um subscriber sem atividade mantém-se ligado mesmo atrás de um nginx com a configuração predefinida. Os timeouts mais longos fornecem margem adicional, mas não são o que mantém a ligação ativa. Se aumentar keepalive-interval, mantenha-o abaixo do timeout de leitura do proxy.

Criar utilizadores e restringir tópicos

A autenticação está ativa e ninguém tem acesso a nada, que é precisamente o objetivo. Crie uma conta de administrador para si e uma conta de máquina para os scripts. Estes comandos leem /etc/ntfy/server.yml a partir do contentor, razão pela qual o ficheiro de configuração é montado como 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

Cada comando user add pede uma palavra-passe. Um administrador ignora a lista de controlo de acesso e pode ler e escrever em todos os tópicos, por isso mantenha essa conta para si e para a aplicação do telemóvel. robot é um utilizador normal sem qualquer acesso até lhe conceder permissões.

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

Uma ACL (lista de controlo de acesso) associa um utilizador, um tópico e uma permissão. O tópico pode ser um nome literal ou um padrão em que * corresponde a qualquer valor, por isso alerts_* abrange alerts_backup e alerts_db sem um comando por host. A permissão write significa apenas publicar, por isso um token roubado de uma tarefa cron não pode subscrever nem ler o que publicou. O nome de utilizador especial everyone define o que um visitante não autenticado pode fazer. Com deny-all como predefinição, usá-lo-ia sobretudo para abrir deliberadamente algo público, como ntfy access everyone status read. Também aceita deny quando pretende uma regra explícita que mantenha os visitantes anónimos afastados de um tópico.

Os scripts devem usar um token, não a sua palavra-passe.

sudo docker compose exec ntfy ntfy token add robot

O comando apresenta um token que começa por tk_. Um token herda exatamente as permissões do utilizador a que pertence, por isso este pode publicar nos tópicos alerts e não pode fazer mais nada. ntfy token list mostra o que existe e ntfy token remove revoga um token sem alterar a palavra-passe do utilizador.

Envie a primeira mensagem e confirme que o bloqueio funciona

Comece por verificar se a porta está fechada.

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

Isto mostra 403, e 403 é a resposta correta: auth-default-access: "deny-all" recusa uma publicação anónima. Agora envie uma mensagem real.

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

O servidor responde com a mensagem armazenada em JSON. Assim, sabe que a mensagem foi aceite e não descartada. Title é a primeira linha em negrito. Priority vai de 1 a 5 ou, por nome, de min a urgent, e determina se o telemóvel emite um som. Tags tornam-se emojis na notificação quando o nome corresponde a um código curto de emoji conhecido e permanecem como texto simples quando não corresponde.

Para monitorizar um tópico a partir de um terminal, transmita-o continuamente:

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

curl pede a palavra-passe. Cada mensagem chega numa única linha, e as linhas vazias que aparecem ocasionalmente são keepalives. Abrir https://ntfy.example.com num navegador e iniciar sessão com a mesma conta apresenta a versão web da mesma transmissão.

Configure limites de frequência para que um script não sobrecarregue o servidor

Por predefinição, cada visitante recebe um bucket de 60 pedidos, reabastecido à razão de um pedido a cada 5 segundos. Isso é generoso para um servidor privado, e um script preso num ciclo de novas tentativas consumirá tudo. Adicione limites a server.yml.

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

Um visitante que exceda o limite recebe HTTP 429 em vez de uma mensagem entregue. O limite é contado por endereço do visitante, razão pela qual behind-proxy: true é tão importante: sem essa configuração, o ntfy vê apenas o endereço do Caddy, todos os clientes contam como o mesmo visitante e um único script ruidoso esgota o bucket partilhado pelo seu telemóvel e pelos outros servidores. A partir da v2.36.0, as contagens diárias sobrevivem aos reinícios na base de dados de utilizadores, e a quota de cada visitante é reposta no seu próprio ciclo de 24 horas, em vez de à meia-noite UTC.

Alerta de um cron job que falha

Mantenha o token fora da linha de comandos. ps aux mostra a linha de comandos completa de todos os processos em execução a todos os utilizadores do sistema, por isso um token passado com -H fica legível para qualquer conta local enquanto o curl estiver em execução. Um ficheiro de configuração do curl evita isso.

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

Agora envolva o job num script. Guarde-o como /usr/local/bin/backup-with-alert.sh e torne-o executável com 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

$? é capturado na linha imediatamente após o comando, porque a execução do comando seguinte iria substituí-lo. A saída passa por tail -c 1000 porque o ntfy impõe um tamanho máximo para as mensagens e uma notificação não é um visualizador de logs. O exit "$code" de fecho preserva o estado original, para que qualquer outro mecanismo que monitorize este job continue a detetar uma falha. Teste tudo apontando o script para /bin/false numa execução.

Um ramo de falha que nunca é executado é pior do que não ter alertas, porque dá a entender que o silêncio significa sucesso. O cron fornece ao job um ambiente quase vazio e um PATH muito mais curto do que o da sua shell de login, por isso um script que funciona quando é executado manualmente pode terminar antes de chegar à linha do curl. O guia sobre as causas de um cron job não ser executado explica essas armadilhas relacionadas com o ambiente. Utilize caminhos absolutos em todo o lado e leia o ficheiro de log depois da primeira execução agendada, em vez de assumir que tudo funcionou.

Alertar quando uma unidade systemd falha

O cron trata de tarefas agendadas. Os serviços de longa duração precisam de OnFailure=, que o systemd executa sempre que uma unidade entra no estado failed. Crie uma unidade de modelo e reutilize-a para todos os serviços no servidor. Guarde-a como /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

Depois, /usr/local/bin/ntfy-unit-failed, com o modo 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

Associe-a a um serviço com um drop-in, para que uma atualização de pacote não substitua a sua edição.

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

%n é expandido para o nome completo da unidade. Assim, a unidade instanciada torna-se ntfy-unit-failed@myapp.service.service, e %i dentro do modelo passa myapp.service ao script como primeiro argumento. É isso que permite usar um único modelo para todas as unidades. Confirme que funciona com uma unidade que falha de propósito, guardada como /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

O comando de arranque termina com um código diferente de zero e apresenta Job for ntfy-selftest.service failed because the control process exited with error code. O telemóvel deverá emitir um alerta cerca de um segundo depois. Elimine a unidade de teste em seguida.

Há uma armadilha importante. OnFailure= é executado apenas quando uma unidade alcança o estado failed, e RestartMode=direct ignora esse estado durante os reinícios automáticos. Por isso, também ignora o gestor de falhas. Com o valor predefinido RestartMode=normal, os reinícios automáticos passam pelo estado de falha. StartLimitBurst e StartLimitIntervalSec controlam quando as tentativas de arranque repetidas são recusadas. Defina-os para que um ciclo de falhas acabe por parar. Os timers são uma alternativa mais adequada ao padrão com cron apresentado acima, porque a unidade de serviço de um timer também suporta o mesmo drop-in OnFailure=. O guia sobre serviços e timers systemd numa VPS explica como converter um deles.

Ligue um monitor de disponibilidade ao mesmo tópico

Uptime Kuma, o monitor de estado autoalojado, inclui um tipo de notificação ntfy. Abra Settings, depois Notifications e depois Setup Notification, escolha Ntfy, defina o URL do servidor como https://ntfy.example.com e o tópico como alerts, selecione uma prioridade e cole o token de acesso robot. Envie a notificação de teste antes de guardar, porque um nome de tópico incorreto devolve um erro quando a concessão write não o abrange.

O limite real desta configuração é o seguinte: um monitor em execução no mesmo VPS não consegue informar que o VPS está indisponível, e o ntfy não consegue entregar a informação de que o ntfy está indisponível. Execute o monitor noutra máquina e atribua-lhe um segundo canal de notificação, como o email, para o monitor que verifica o próprio ntfy. O tipo de monitor Push do Uptime Kuma cobre o outro ponto cego: o seu cron job chama um URL de push após uma execução bem-sucedida, e o Kuma gera um alerta quando essas chamadas deixam de chegar. Um ramo de falha é acionado apenas quando o job é executado, por isso não informa sobre um job que nunca foi iniciado.

O ntfy autoalojado funciona no Android e no iPhone?

No Android, sim, sem limitações. Instale a aplicação a partir do Google Play ou do F-Droid, abra Settings, defina o servidor predefinido como https://ntfy.example.com, adicione a sua conta no ecrã de gestão de utilizadores e subscreva alerts. A entrega instantânea mantém um serviço em primeiro plano em execução para que as mensagens cheguem mesmo quando o telefone está no modo doze. A notificação permanente associada é uma exigência do Android para serviços em primeiro plano, não um erro. A versão do F-Droid não contém código Firebase, pelo que todas as subscrições usam a entrega instantânea. O ntfy também pode funcionar como distribuidor UnifiedPush, uma alternativa aberta ao serviço de push da Google. Assim, outras aplicações compatíveis com UnifiedPush também podem entregar notificações através do seu servidor.

Na aplicação oficial para iOS, funciona com uma dependência que não pode remover. O iOS suspende uma aplicação que está em segundo plano. Os modos de execução em segundo plano permitidos pela Apple — reprodução de áudio, receção de atualizações de localização e processamento de tarefas agendadas — não permitem que uma aplicação fique à espera de uma mensagem do seu servidor. Por isso, a ativação imediata tem de ser feita através do APNs (Apple push notification service). Apenas um fornecedor com credenciais autorizadas para a aplicação pode enviar notificações para ela. O seu servidor não tem, portanto, forma de contactar diretamente a aplicação oficial. O ntfy resolve este problema com um relay: o seu servidor envia um poll_request que contém o ID da mensagem para ntfy.sh. O ntfy.sh encaminha-o através do Firebase e do APNs para ativar a aplicação. Depois, a aplicação obtém o corpo da mensagem no seu servidor.

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

Tenha em conta o custo dessa configuração. O conteúdo da mensagem permanece no seu servidor, mas o facto de uma mensagem ter chegado e o respetivo ID passam por uma infraestrutura que não controla. Sem esta definição, as notificações no iPhone provenientes de um servidor autoalojado continuam a chegar, mas apenas depois de algum tempo. A documentação do ntfy avisa que o atraso pode chegar a várias horas, porque nada ativa a aplicação de forma imediata. Para utilizar uma aplicação iOS nativa sem o relay ntfy.sh, compile e distribua a aplicação por sua conta, utilizando a sua própria conta de programador Apple e as suas próprias chaves APNs. Isto implica uma taxa anual e uma nova compilação para cada atualização. Outra opção é utilizar a PWA do ntfy no iOS 16.4 ou posterior: adicione-a ao ecrã principal e configure o Web Push no seu servidor. Esta opção evita o relay ntfy.sh, mas continua a utilizar a infraestrutura de push do navegador. Se o relay não for aceitável para o seu caso, mantenha as notificações no Android ou na aplicação web para computador.

Backups, atualizações e fixação da imagem

Há dois caminhos que não podem ser regenerados: /etc/ntfy/server.yml e /var/lib/ntfy/user.db. O segundo contém todos os utilizadores, hashes de palavras-passe, entradas de ACL e tokens, por isso trate-o como uma chave privada.

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

Copie esse ficheiro para fora do servidor. cache.db contém mensagens recentes, 12 horas delas com o cache-duration acima, além de qualquer mensagem agendada para entrega posterior, que permanece até 12 horas depois de ser entregue. A menos que agende mensagens antecipadamente, perdê-lo não representa uma perda relevante a proteger. Atualizar significa editar a tag no ficheiro Compose, transferir a imagem e recriar o contentor.

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

Leia primeiro as notas da versão. As bases de dados SQLite são migradas no arranque, por isso reverter para uma tag mais antiga depois de uma alteração de schema não é seguro. A v2.31.1, por exemplo, moveu a cache de mensagens para a versão de schema 17, e as notas de atualização indicam que um downgrade para a v2.31.0 ou anterior requer repor manualmente essa versão para 16. A atualização para a v2.36.0 repõe uma vez as contagens diárias existentes de todos os utilizadores. Mantenha o backup que acabou de criar até a nova versão estar em execução há um dia. As notas também assinalam alterações de comportamento. A partir da v2.31.0, um cliente que se volte a ligar com since=<message ID> também recebe mensagens publicadas no mesmo segundo, por isso pode ver uma duplicação. As aplicações ntfy e a aplicação web eliminam duplicados pelo ID da mensagem, mas um script seu que reproduza um tópico tem de fazer o mesmo. Cada serviço no servidor tem a sua própria lista curta de caminhos que não podem ser regenerados, e a comparação entre PhotoPrism e Immich determina essa lista e os comandos de backup correspondentes para uma biblioteca de fotografias no mesmo tipo de VPS.

Gotify e Apprise

Gotify é a opção mais pequena: um binário com uma interface web e uma aplicação Android, com as mensagens organizadas por aplicação. É adequado para um servidor privado em que o Android é o único destino. Apprise é uma biblioteca Python e uma ferramenta de linha de comandos. Também existe um servidor Apprise API separado. A ferramenta distribui uma única mensagem por mais de uma centena de serviços, incluindo ntfy. É adequada para um script que precisa de enviar alertas para vários destinos ao mesmo tempo. ntfy é a opção que fornece um servidor, uma API HTTP e aplicações para ambas as plataformas móveis. Por isso, é a escolha habitual para alertas enviados a partir de um servidor alugado.

FAQ

Porque é que a publicação no meu servidor ntfy devolve 403?

Com auth-default-access: "deny-all" em server.yml, uma publicação anónima é recusada. Esse é o comportamento pretendido. Envie as credenciais com -u user:pass ou -H "Authorization: Bearer tk_...". Se já estiver a enviar um token e continuar a receber 403, verifique se o utilizador tem uma entrada ACL que permita escrever no tópico: sem uma entrada correspondente, read-only ou deny recusa a publicação. Na versão v2.34.0, pedidos concorrentes provenientes do mesmo IP também podiam fazer com que credenciais válidas fossem tratadas como anónimas. A versão v2.35.0 corrige esse erro. Atualize antes de interpretar um 403 intermitente como prova de um problema de ACL. Execute ntfy access para apresentar a lista completa. Tenha em atenção que uma permissão write não permite subscrever. Por isso, uma conta que publica corretamente continuará a ser recusada quando tentar ler o mesmo tópico.

As notificações funcionam no iPhone com um servidor ntfy autoalojado?

Funcionam através de um relay quando utiliza a aplicação oficial para iOS. Para reativar rapidamente uma aplicação iPhone suspensa, a notificação tem de passar pelo APNs (Apple push notification service). O envio para a aplicação oficial requer as credenciais de push do respetivo editor. Por isso, o ntfy encaminha para ntfy.sh um poll_request que contém o ID da mensagem, e o ntfy.sh reencaminha-o para o dispositivo. Defina upstream-base-url: "https://ntfy.sh" em server.yml e reinicie o contentor. O corpo da mensagem continua a ser obtido a partir do seu servidor. Sem essa definição, as notificações do iOS acabam por chegar, mas a documentação do ntfy avisa que o atraso pode chegar a várias horas. A PWA oferece outra opção no iOS 16.4 ou posterior quando o Web Push está configurado no seu servidor.

Porque é que o alerta ntfy do meu cron job nunca chegou?

Execute primeiro, isoladamente, a linha curl para confirmar que o token e o tópico estão corretos. Se funcionar manualmente, mas não a partir do cron, a falha está antes do alerta: o cron executa os jobs com um ambiente mínimo e um PATH curto. Por isso, um script que chama um comando apenas pelo nome pode terminar antes de chegar à linha curl. Utilize caminhos absolutos, redirecione a saída do job para um ficheiro de log e leia esse ficheiro depois da execução seguinte. Uma resposta 429, em vez de uma entrega, significa que um limite recusou o pedido. Normalmente, o script está a repetir os pedidos demasiado depressa. No entanto, um visitante que tenha esgotado uma quota diária, como o limite de mensagens definido anteriormente, é recusado da mesma forma, mesmo num único pedido.

Devo expor o ntfy na Internet pública?

As aplicações para telemóvel precisam de lhe aceder através de redes móveis. Por isso, um endpoint HTTPS público com auth-default-access: "deny-all" e ACLs por tópico é a configuração normal. É segura desde que nenhum tópico possa ser lido por everyone. Uma instância acessível apenas por VPN é adequada quando todos os subscritores são máquinas que controla. É uma opção inadequada para telemóveis, porque a aplicação só recebe notificações enquanto o túnel está ativo. Assim, os alertas ficam em fila até o telemóvel voltar a ligar-se.

Este artigo foi útil?