SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor

Docker पर self-hosted ntfy server कैसे सेटअप करें

Docker Compose का उपयोग करके अपने VPS पर ntfy को TLS के साथ सुरक्षित रूप से इंस्टॉल करें। ACLs और users के साथ topics को लॉक करें और cron या systemd OnFailure से अलर्ट पाएं।

Self-hosted ntfy server क्या करता है

एक self-hosted ntfy server HTTP POST को आपके फोन पर push notification में बदल देता है। आप curl का उपयोग करके publish करते हैं, और संदेश Android app, iOS app, browser tab, या किसी भी ऐसी चीज़ पर पहुँच जाता है जो HTTP connection को open रख सकती है। इसमें न तो कोई client library install करने की आवश्यकता है और न ही कोई message broker चलाने की।

ntfy संदेशों को topic के आधार पर संबोधित करता है। Topic URL path में एक नाम होता है, जैसे https://ntfy.example.com/alerts, और यह उस क्षण अस्तित्व में आ जाता है जब कोई उस पर publish करता है। डिफ़ॉल्ट install पर, जो कोई भी उस नाम को जानता है वह topic को पढ़ सकता है और उस पर लिख सकता है, यही कारण है कि प्रोजेक्ट का अपना documentation topic के नाम की तुलना password से करता है। यह मॉडल सार्वजनिक ntfy.sh सेवा के लिए ठीक है। यह उस सर्वर के लिए ठीक नहीं है जो आपके backup failures की जानकारी ले जा रहा हो, इसलिए यह गाइड पहला संदेश भेजे जाने से पहले ही authentication को चालू कर देती है।

शुरू करने से पहले आपकी आवश्यकताएं

आपको Docker Engine और Compose plugin के साथ Ubuntu 24.04 या Debian 13 पर चलने वाला एक VPS, एक domain name, और बहुत कम RAM की आवश्यकता है। एक DNS (domain name system) A record बनाएं जो ntfy.example.com को सर्वर के public IP address पर point करे, और फिर किसी भी अन्य कार्य को करने से पहले पुष्टि करें कि यह resolve हो रहा है।

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

dig को आपके सर्वर का IP print करना चाहिए। Certificate जारी करने के लिए यह आवश्यक है कि hostname, A या AAAA record के माध्यम से सार्वजनिक रूप से सर्वर पर resolve हो। Port 80 खुला रहना चाहिए क्योंकि ACME (automatic certificate management environment), जो Let's Encrypt के पीछे का protocol है, इसका उपयोग HTTP challenge के लिए करता है। ntfy container को कभी भी public port नहीं मिलता है।

ntfy कॉन्फ़िगरेशन फ़ाइल लिखें

Docker इमेज में कोई कॉन्फ़िगरेशन फ़ाइल नहीं होती है, इसलिए आपको एक बनानी होगी। इस गाइड में बाद में आने वाले सभी कमांड इसी से पढ़ेंगे। सबसे पहले उस user ID और group ID का पता लगाएँ जिसके तहत कंटेनर चलेगा।

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

इनमें से चार लाइनें सबसे महत्वपूर्ण हैं। base-url सटीक सार्वजनिक HTTPS पता होना चाहिए, क्योंकि ntfy इसका उपयोग जनरेट किए गए अटैचमेंट लिंक और self-hosted iOS पुश नोटिफिकेशन के लिए करता है। listen-http: ":2586" कंटेनर के अंदर सभी इंटरफेस से बाइंड होता है, जो देखने में लापरवाही लग सकता है लेकिन यह सही है: कंटेनर का अपना नेटवर्क नेमस्पेस होता है, इसलिए वहां 127.0.0.1 से बाइंड करने पर पोर्ट होस्ट से पहुंच योग्य नहीं होगा और Docker का पब्लिश किया गया पोर्ट कभी कनेक्ट नहीं हो पाएगा। auth-default-access: "deny-all" पूरी सुरक्षा व्यवस्था है, क्योंकि यह स्पष्ट अनुमति के बिना किसी को भी पढ़ने और लिखने से मना कर देता है। behind-proxy: true ntfy को क्लाइंट का पता X-Forwarded-For हेडर से लेने के लिए कहता है, ताकि रेट लिमिट्स रिवर्स प्रॉक्सी को एक बहुत व्यस्त क्लाइंट के रूप में गिनने के बजाय वास्तविक विजिटर्स की गिनती करें।

enable-login: true उपयोगकर्ताओं को वेब ऐप या API के माध्यम से साइन इन करने की अनुमति देता है। enable-signup को false रखा जाता है, क्योंकि एक प्राइवेट सर्वर पर self-service अकाउंट निर्माण एक खुला दरवाजा है जिसमें अतिरिक्त कदम शामिल हैं।

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

Docker Compose के साथ ntfy चलाएं

इसे /opt/ntfy/compose.yaml में डालें और 1000:1000 को ऊपर दिए गए दो अंकों id -u और id -g से बदलें।

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

एक स्वस्थ सर्वर {"healthy":true,"role":"active"} का उत्तर देता है। उस compose फ़ाइल में दो विवरण जानबूझकर दिए गए हैं। image को v2.36.0 पर पिन किया गया है, जो 1 नवंबर, 2026 तक का वर्तमान स्थिर release है, न कि latest पर, क्योंकि latest के साथ अगला docker compose pull वर्तमान image को डाउनलोड करता है, और बाद वाला docker compose up -d container को उसके साथ फिर से बनाता है; केवल pull करने से चल रहे सर्वर का version नहीं बदलता। पिन को अभी भी अपडेट करने की आवश्यकता होती है। केवल अक्टूबर 2026 में दस release आए: 7 अक्टूबर को v2.29.0, 12 अक्टूबर को v2.30.0, 16 अक्टूबर को v2.31.0 और v2.31.1, 18 अक्टूबर को v2.32.0, 23 अक्टूबर को v2.33.0 और v2.33.1, 24 अक्टूबर को v2.34.0, 30 अक्टूबर को v2.35.0, और 31 अक्टूबर को v2.36.0। v2.31.0 उन संदेशों को ठीक करता है जो तब खो गए थे जब कोई client message cache तक पहुँचने से पहले फिर से connect हुआ था, लेकिन since=<message ID> के साथ इसके reconnects database से topic के हर संदेश को पढ़ लेते हैं, और ntfy.sh ने इसे वापस ले लिया (roll back कर दिया)। v2.31.1 उस load को एक नए index के साथ ठीक करता है, और v2.34.0 उन revoked या deleted users को ठीक करता है जिनके पास कुछ subscriptions रह गए थे। v2.35.0 उन concurrent requests को ठीक करता है जो वैध credentials को anonymous के रूप में मानते हैं और SQLite पर Matrix push gateway authorization bypass को ठीक करता है, इसलिए पुराने pins को v2.36.0 पर ले जाएं। port को 127.0.0.1:2586:2586 के रूप में publish किया गया है, इसलिए container केवल host के loopback address से ही पहुँच योग्य है। इसके बजाय 2586:2586 लिखें और Docker आपके firewall rules से पहले अपने स्वयं के नियम डाल देता है, जिसका अर्थ है कि port internet से उत्तर देता है, भले ही ufw status कहता हो कि port बंद है। दोनों आदतें अगले container पर भी लागू होती हैं जिसे आप जोड़ते हैं: एक self-hosted RustDesk relay अपनी image tag को उसी तरह पिन करता है, लेकिन यह loopback के पीछे नहीं छिप सकता, क्योंकि इसके signal और relay ports को internet से उत्तर देना होता है।

यदि curl Connection refused प्रिंट करता है, तो container log पढ़ें। /var/lib/ntfy/user.db पर permission error का मतलब है कि user: लाइन उन directories के owner से मेल नहीं खाती है, इसलिए process अपना database नहीं बना सकती और exit हो जाती है। VPS के लिए Docker Compose मूल बातें मार्गदर्शिका volume ownership और restart policies को अधिक विस्तार से कवर करती है।

Caddy के साथ TLS का उपयोग करें

Caddy स्वयं certificate का अनुरोध करता है और उसे renew करता है, जो काम करने वाले TLS (transport layer security) को प्राप्त करने का सबसे छोटा रास्ता है।

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

/etc/caddy/Caddyfile की सामग्री को तीन लाइनों से बदलें।

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

HTTPS पर वही {"healthy":true,"role":"active"} का मतलब है कि पूरा path काम कर रहा है। Caddy से मिलने वाला 502 आमतौर पर यह दर्शाता है कि ntfy listening मोड में नहीं है: sudo ss -lntp | grep 2586 के साथ इसकी जाँच करें। यदि ntfy listening मोड में है और 502 बना रहता है, तो Caddy उस upstream error को log करता है जिसका उसने सामना किया है, जैसे कि reset connection। Certificate error का आमतौर पर मतलब है कि DNS record गलत है या certificate validation सर्वर के port 80 या 443 तक नहीं पहुँच पा रहा है; validation error के लिए sudo journalctl -u caddy -n 50 की जाँच करें। बाद में कोई अन्य service जोड़ने के लिए उसी Caddyfile में एक और hostname block की आवश्यकता होती है, और इसी तरह Halcyon, आपकी Jellyfin library के लिए 90 के दशक का वीडियो स्टोर फ्रंट एंड उसी सर्वर के दूसरे subdomain पर काम करता है।

यदि आप पहले से ही nginx चला रहे हैं, तो ntfy द्वारा बताए गए proxy settings को copy करें: proxy_http_version 1.1, proxy_buffering off, proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for, और कम से कम तीन मिनट का read और send timeout सेट करें। एक subscriber जब तक listening मोड में रहता है, तब तक एक HTTP connection को open रखता है। nginx का डिफ़ॉल्ट proxy_read_timeout 60 सेकंड का होता है जो केवल दो reads के बीच के समय को गिनता है, और ntfy डिफ़ॉल्ट रूप से हर 45 सेकंड में एक keepalive message भेजता है (keepalive-interval), ताकि intermediaries निष्क्रियता के कारण connection को बंद न करें। इसलिए एक शांत subscriber stock nginx के पीछे भी connected रहता है, और लंबे timeouts केवल अतिरिक्त सुरक्षा के लिए हैं, न कि connection को जीवित रखने के लिए। यदि आप keepalive-interval को बढ़ाते हैं, तो इसे अपने proxy के read timeout से कम रखें।

उपयोगकर्ता बनाएँ और टॉपिक्स को लॉक करें

Authentication चालू है और अभी किसी के पास किसी भी चीज़ का एक्सेस नहीं है, यही इसका उद्देश्य है। अपने लिए एक admin अकाउंट और स्क्रिप्ट्स के लिए एक machine अकाउंट बनाएँ। ये कमांड्स कंटेनर के अंदर से /etc/ntfy/server.yml को पढ़ते हैं, इसीलिए कॉन्फ़िगरेशन फ़ाइल एक वॉल्यूम माउंट है।

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

प्रत्येक user add कमांड पासवर्ड के लिए प्रॉम्प्ट करता है। एक admin एक्सेस लिस्ट को अनदेखा करता है और हर टॉपिक को पढ़ और लिख सकता है, इसलिए उस अकाउंट को अपने और अपने फ़ोन ऐप के लिए रखें। robot एक साधारण उपयोगकर्ता है जिसके पास तब तक कोई एक्सेस नहीं होता जब तक आप उसे प्रदान न करें।

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

एक ACL (एक्सेस कंट्रोल लिस्ट) एंट्री में एक उपयोगकर्ता, एक टॉपिक और एक अनुमति होती है। टॉपिक या तो एक literal नाम होता है या एक पैटर्न, जहाँ * किसी भी चीज़ से मेल खाता है, इसलिए alerts_* में alerts_backup और alerts_db दोनों शामिल हो जाते हैं, जिससे प्रति होस्ट अलग कमांड की आवश्यकता नहीं पड़ती। write अनुमति का अर्थ है केवल पब्लिश करना, ताकि cron जॉब से चुराया गया टोकन सब्सक्राइब न कर सके और जो भेजा गया है उसे वापस पढ़ न सके। विशेष उपयोगकर्ता नाम everyone यह निर्धारित करता है कि एक अनधिकृत विज़िटर क्या कर सकता है। deny-all को डिफ़ॉल्ट के रूप में रखने पर आप इसका उपयोग मुख्य रूप से किसी चीज़ को जानबूझकर सार्वजनिक करने के लिए करेंगे, जैसे कि ntfy access everyone status read, और यह deny को भी स्वीकार करता है जब आप एक स्पष्ट नियम चाहते हैं जो अनाम विज़िटर्स को किसी टॉपिक से दूर रखे।

स्क्रिप्ट्स में आपका पासवर्ड नहीं, बल्कि एक टोकन होना चाहिए।

sudo docker compose exec ntfy ntfy token add robot

यह कमांड tk_ से शुरू होने वाला एक टोकन प्रिंट करता है। एक टोकन बिल्कुल उसी उपयोगकर्ता का एक्सेस प्राप्त करता है जिससे वह संबंधित है, इसलिए यह वाला केवल alerts टॉपिक्स पर पब्लिश कर सकता है और कुछ नहीं। ntfy token list दिखाता है कि क्या मौजूद है, और ntfy token remove उपयोगकर्ता के पासवर्ड को छुए बिना एक टोकन को रद्द कर देता है।

अपना पहला संदेश भेजें और सुनिश्चित करें कि लॉक काम कर रहा है

सबसे पहले जाँचें कि दरवाजा बंद है या नहीं।

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

यह 403 प्रिंट करता है, और 403 सही उत्तर है: auth-default-access: "deny-all" गुमनाम पब्लिश (anonymous publish) को अस्वीकार कर देता है। अब एक वास्तविक संदेश भेजें।

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

सर्वर JSON के रूप में संग्रहीत संदेश के साथ उत्तर देता है, जिससे आपको पता चलता है कि संदेश स्वीकार कर लिया गया है, न कि उसे अनदेखा किया गया है। Title पहली बोल्ड लाइन है। Priority 1 से 5 तक, या min से urgent तक नाम द्वारा चलता है, और यह तय करता है कि फोन ध्वनि करेगा या नहीं। जब नाम किसी ज्ञात इमोजी शॉर्ट कोड से मेल खाता है, तो Tags नोटिफिकेशन पर इमोजी बन जाते हैं, और मेल न खाने पर वे सादे टेक्स्ट के रूप में रहते हैं।

टर्मिनल से किसी टॉपिक को मॉनिटर करने के लिए, उसे स्ट्रीम करें:

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

curl पासवर्ड के लिए प्रॉम्प्ट करता है। प्रत्येक संदेश एक लाइन के रूप में आता है, और बीच-बीच में दिखाई देने वाली खाली लाइनें कीप-अलाइव (keepalives) हैं। ब्राउज़र में https://ntfy.example.com खोलकर और उसी अकाउंट से साइन इन करने पर आपको उसी स्ट्रीम का वेब ऐप संस्करण मिल जाता है।

Rate limits सेट करें ताकि कोई script सर्वर को flood न कर सके

डिफ़ॉल्ट रूप से प्रत्येक visitor को 60 requests की bucket मिलती है, जो हर 5 सेकंड में एक request पर refill होती है। यह एक private सर्वर के लिए पर्याप्त है, और retry loop में फंसी एक script इसका पूरा उपयोग कर लेगी। server.yml में सीमाएं जोड़ें।

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

सीमा से अधिक visitor को डिलीवर किए गए संदेश के बजाय HTTP 429 मिलता है। सीमा की गणना प्रति visitor address के आधार पर की जाती है, यही कारण है कि behind-proxy: true इतना महत्वपूर्ण है: इसके बिना ntfy केवल Caddy का address देखता है, हर client एक ही visitor के रूप में गिना जाता है, और एक शोर मचाने वाली script उस bucket को खत्म कर देती है जिसे आपका फ़ोन और आपके अन्य सर्वर साझा करते हैं। v2.36.0 से, दैनिक गणना user database में restarts के बाद भी बनी रहती है, और प्रत्येक visitor का allowance आधी रात UTC के बजाय अपने स्वयं के 24-घंटे के चक्र पर reset होता है।

Cron job विफल होने पर अलर्ट

कमांड लाइन में टोकन न रखें। ps aux बॉक्स पर मौजूद हर यूजर को हर चल रही प्रोसेस की पूरी कमांड लाइन दिखाता है, इसलिए -H के साथ पास किया गया टोकन तब तक किसी भी लोकल अकाउंट द्वारा पढ़ा जा सकता है जब तक curl चलता है। एक curl कॉन्फ़िगरेशन फ़ाइल इससे बचाती है।

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

अब जॉब को रैप करें। इसे /usr/local/bin/backup-with-alert.sh के रूप में सेव करें और इसे 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

$? को कमांड के ठीक बाद वाली लाइन पर कैप्चर किया जाता है, क्योंकि अगली चलने वाली कमांड इसे ओवरराइट कर देगी। आउटपुट tail -c 1000 के माध्यम से जाता है क्योंकि ntfy अधिकतम मैसेज साइज़ लागू करता है और नोटिफिकेशन कोई लॉग व्यूअर नहीं है। क्लोजिंग exit "$code" मूल स्टेटस को सुरक्षित रखता है, ताकि इस जॉब को मॉनिटर करने वाली कोई भी अन्य चीज़ अभी भी विफलता देख सके। एक रन के लिए स्क्रिप्ट को /bin/false पर पॉइंट करके पूरी प्रक्रिया का परीक्षण करें।

एक विफलता शाखा (failure branch) जो कभी निष्पादित नहीं होती, वह अलर्ट न होने से भी बदतर है, क्योंकि ऐसा लगता है कि चुप्पी का मतलब सफलता है। Cron आपके जॉब को लगभग खाली एनवायरनमेंट और आपके लॉगिन शेल की तुलना में बहुत छोटा PATH देता है, इसलिए जो स्क्रिप्ट आपके द्वारा मैन्युअल रूप से चलाने पर काम करती है, वह curl लाइन तक पहुँचने से पहले ही विफल हो सकती है। Cron जॉब क्यों नहीं चलती, इस पर गाइड उन एनवायरनमेंट ट्रैप्स को कवर करती है। हर जगह एब्सोल्यूट पाथ का उपयोग करें, और यह मानने के बजाय कि सब ठीक है, पहले शेड्यूल किए गए रन के बाद लॉग फ़ाइल को पढ़ें।

Systemd unit विफल होने पर अलर्ट प्राप्त करना

Cron निर्धारित कार्यों के लिए उपयुक्त है। लंबे समय तक चलने वाली सेवाओं के लिए OnFailure= की आवश्यकता होती है, जिसे systemd तब चलाता है जब कोई unit failed अवस्था में आ जाती है। एक template unit बनाएँ और उसे सर्वर की प्रत्येक सेवा के लिए पुनः उपयोग करें। इसे /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

फिर /usr/local/bin/ntfy-unit-failed करें, mode 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

इसे drop-in के माध्यम से एक सेवा से जोड़ें, ताकि package upgrade आपके संपादन को अधिलेखित (overwrite) न कर सके।

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

%n का विस्तार पूर्ण unit नाम में हो जाता है, इसलिए instantiated unit ntfy-unit-failed@myapp.service.service बन जाती है, और template के भीतर %i, myapp.service को script के पहले argument के रूप में भेजता है। यही वह तरीका है जिससे एक template हर unit के लिए काम कर सकता है। इसे जानबूझकर विफल होने वाली एक unit के साथ सिद्ध करें, जिसे /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

Start command non-zero exit देती है और Job for ntfy-selftest.service failed because the control process exited with error code प्रिंट करती है, और लगभग एक सेकंड बाद फोन पर सूचना आनी चाहिए। परीक्षण के बाद test unit को हटा दें।

एक समस्या पर ध्यान देना आवश्यक है। OnFailure= केवल तब चलता है जब कोई unit failed अवस्था में पहुँचती है, और RestartMode=direct स्वचालित पुनरारंभ (automatic restarts) के दौरान उस अवस्था को छोड़ देता है, इसलिए यह failure handler को भी छोड़ देता है। डिफ़ॉल्ट RestartMode=normal के साथ, स्वचालित पुनरारंभ विफल अवस्था से होकर गुजरते हैं। StartLimitBurst और StartLimitIntervalSec नियंत्रित करते हैं कि कब बार-बार होने वाले start को अस्वीकार किया जाए; उन्हें इस तरह सेट करें कि crash loop अंततः रुक जाए। Timers ऊपर दिए गए cron पैटर्न का बेहतर विकल्प हैं, क्योंकि timer की service unit भी उसी OnFailure= drop-in का समर्थन करती है, और VPS पर systemd services और timers के लिए गाइड में इसे बदलने की प्रक्रिया समझाई गई है।

Uptime monitor को उसी topic से जोड़ें

Uptime Kuma, self-hosted status monitor, में ntfy notification का विकल्प मिलता है। Settings खोलें, फिर Notifications पर जाएँ, Setup Notification चुनें, Ntfy चुनें, server URL को https://ntfy.example.com पर सेट करें और topic को alerts पर रखें, एक priority चुनें, और robot access token पेस्ट करें। Save करने से पहले test notification भेजें, क्योंकि गलत topic name होने पर write grant error देता है जो उसे कवर नहीं करता।

इस व्यवस्था की एक वास्तविक सीमा यह है: यदि monitor उसी VPS पर चल रहा है, तो वह आपको यह नहीं बता पाएगा कि VPS down है, और ntfy यह सूचना नहीं दे पाएगा कि ntfy down है। Monitor को किसी दूसरी machine पर चलाएँ, और उस monitor के लिए एक दूसरा notification channel, जैसे email, रखें जो स्वयं ntfy की निगरानी करे। Uptime Kuma का Push monitor type एक और blind spot को कवर करता है: आपका cron job सफल run के बाद एक push URL को call करता है, और जब ये calls आनी बंद हो जाती हैं तो Kuma alert भेजता है। Failure branch केवल तब सक्रिय होती है जब job run होता है, इसलिए यह उस job के बारे में कुछ नहीं बताता जो कभी शुरू ही नहीं हुआ।

क्या self-hosted ntfy Android और iPhone पर काम करता है?

Android पर, हाँ, बिना किसी शर्त के। Google Play या F-Droid से app इंस्टॉल करें, Settings खोलें, default server को https://ntfy.example.com पर सेट करें, user management स्क्रीन के अंतर्गत अपना account जोड़ें, और फिर alerts को सब्सक्राइब करें। Instant delivery एक foreground service को चालू रखती है ताकि फोन के doze mode में होने पर भी संदेश प्राप्त हो सकें। इसके साथ आने वाली स्थायी notification Android की foreground services के लिए एक आवश्यकता है, न कि कोई बग। F-Droid बिल्ड में कोई भी Firebase कोड नहीं होता है, इसलिए हर subscription instant delivery का उपयोग करती है। ntfy एक UnifiedPush distributor के रूप में भी काम कर सकता है, जो Google की push service का एक खुला विकल्प है, ताकि UnifiedPush का समर्थन करने वाली अन्य apps भी आपके सर्वर के माध्यम से संदेश भेज सकें।

आधिकारिक iOS app में, यह एक ऐसी निर्भरता (dependency) के साथ काम करता है जिसे आप हटा नहीं सकते। iOS बैकग्राउंड में चल रही app को निलंबित (suspend) कर देता है, और Apple द्वारा अनुमत बैकग्राउंड मोड (ऑडियो चलाना, location अपडेट प्राप्त करना, scheduled कार्य प्रोसेस करना) किसी app को आपके सर्वर से संदेश की प्रतीक्षा करने की अनुमति नहीं देते हैं। इसलिए, तत्काल wake-up के लिए APNs (Apple push notification service) का उपयोग करना आवश्यक है। केवल वही प्रदाता जिसके पास app के लिए अधिकृत क्रेडेंशियल हैं, उसे संदेश भेज सकता है, इसलिए आपके सर्वर के पास आधिकारिक app तक सीधे पहुँचने का कोई तरीका नहीं है। ntfy इसे एक relay के साथ हल करता है: आपका सर्वर संदेश ID वाला एक poll_request ntfy.sh को भेजता है, जो इसे Firebase और APNs के माध्यम से app को जगाने के लिए आगे भेजता है, और फिर app आपके सर्वर से संदेश का मुख्य भाग (body) प्राप्त करती है।

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

इसकी लागत के बारे में स्पष्ट रहें। संदेश की सामग्री आपके सर्वर पर ही रहती है, लेकिन यह तथ्य कि एक संदेश आया है, और उसकी ID, ऐसे बुनियादी ढांचे (infrastructure) से गुजरती है जिसे आप नहीं चलाते हैं। इस सेटिंग के बिना, self-hosted सर्वर से iPhone पर सूचनाएं अंततः पहुँच तो जाती हैं, लेकिन ntfy के दस्तावेज़ चेतावनी देते हैं कि इसमें घंटों की देरी हो सकती है, क्योंकि app को तुरंत जगाने वाला कोई माध्यम नहीं होता है। ntfy.sh relay के बिना native iOS app का उपयोग करने के लिए, अपने स्वयं के Apple developer account और अपनी APNs कुंजियों के साथ app को स्वयं बिल्ड और शिप करें, जिसका अर्थ है वार्षिक शुल्क और हर अपडेट के लिए एक नया बिल्ड। एक और रास्ता iOS 16.4 या बाद के संस्करण पर ntfy की PWA है: इसे home screen पर जोड़ें और अपने सर्वर पर Web Push कॉन्फ़िगर करें। यह ntfy.sh relay से बचता है, लेकिन फिर भी ब्राउज़र के push इंफ्रास्ट्रक्चर का उपयोग करता है। यदि relay आपके उपयोग के लिए अस्वीकार्य है, तो Android या desktop web app पर अलर्टिंग का उपयोग करें।

Backups, upgrades और image को पिन करना

दो paths को फिर से उत्पन्न (regenerate) नहीं किया जा सकता: /etc/ntfy/server.yml और /var/lib/ntfy/user.db। दूसरा हर user, password hash, ACL entry और token रखता है, इसलिए इसे private key की तरह संभालें।

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

उस फ़ाइल को सर्वर से कॉपी करें। cache.db हाल के संदेशों को रखता है, ऊपर दिए गए cache-duration के साथ 12 घंटे के संदेश, साथ ही बाद में डिलीवरी के लिए निर्धारित कोई भी संदेश, जो डिलीवर होने के 12 घंटे बाद तक रहता है। जब तक आप संदेशों को पहले से निर्धारित नहीं करते, तब तक इसे खोने का कोई नुकसान नहीं है। अपग्रेड करने का मतलब है compose फ़ाइल में tag को संपादित करना, image को pull करना, और container को फिर से बनाना।

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

पहले release notes पढ़ें। SQLite databases start होने पर migrate होते हैं, इसलिए schema परिवर्तन के बाद पुराने tag पर वापस जाना सुरक्षित नहीं है। उदाहरण के लिए, v2.31.1 ने message cache को schema version 17 पर ले जाया, और इसके अपग्रेड नोट्स कहते हैं कि v2.31.0 या उससे पहले के version पर downgrade करने के लिए उस version को हाथ से 16 पर सेट करने की आवश्यकता है। v2.36.0 पर अपग्रेड करने से सभी की मौजूदा दैनिक गणना एक बार reset हो जाती है। जब तक नया version एक दिन तक न चल जाए, तब तक उस backup को रखें जिसे आपने अभी लिया है। नोट्स व्यवहार परिवर्तनों को भी चिह्नित करते हैं। v2.31.0 के बाद से, एक client जो since=<message ID> के साथ फिर से connect होता है, उसे उसी सेकंड में प्रकाशित संदेश भी प्राप्त होते हैं, इसलिए वह duplicate देख सकता है। ntfy apps और web app message ID द्वारा duplicates को हटा देते हैं, लेकिन आपकी अपनी script जो किसी topic को replay करती है, उसे भी ऐसा ही करना होगा। बॉक्स पर प्रत्येक service के पास उन paths की अपनी छोटी सूची होती है जिन्हें फिर से उत्पन्न नहीं किया जा सकता है, और PhotoPrism और Immich की तुलना उसी तरह के VPS पर फोटो लाइब्रेरी के लिए उस सूची और उसके साथ आने वाले backup commands का समाधान करती है।

Gotify और Apprise

Gotify एक छोटा विकल्प है: इसमें एक binary और web UI के साथ-साथ एक Android app भी है। इसमें संदेशों को application के अनुसार व्यवस्थित किया जाता है, जो ऐसे private server के लिए उपयुक्त है जहाँ केवल Android ही target है। Apprise एक Python library और command line tool है, जिसका एक अलग Apprise API server भी उपलब्ध है। यह एक ही संदेश को ntfy सहित सौ से अधिक सेवाओं तक पहुँचा सकता है, जो ऐसी script के लिए उपयुक्त है जिसे एक साथ कई जगहों पर सूचना भेजनी हो। ntfy आपको एक server, एक HTTP API और दोनों mobile platforms पर apps प्रदान करता है, इसीलिए किराए के server से alert भेजने के लिए यह सबसे सामान्य समाधान है।

FAQ

मेरे ntfy सर्वर पर पब्लिश करने पर 403 क्यों मिलता है?

auth-default-access: "deny-all" के server.yml में होने पर, anonymous पब्लिश को अस्वीकार कर दिया जाता है, और यह अपेक्षित व्यवहार है। -u user:pass या -H "Authorization: Bearer tk_..." के साथ क्रेडेंशियल्स भेजें। यदि आप पहले से ही टोकन भेज रहे हैं और फिर भी 403 मिल रहा है, तो जाँचें कि क्या उसके यूजर के पास उस टॉपिक पर राइट्स (writes) की अनुमति देने वाली ACL एंट्री है: कोई मैचिंग एंट्री न होने पर, read-only या deny पब्लिश को अस्वीकार कर देता है। v2.34.0 पर, एक ही IP से आने वाले concurrent requests के कारण वैध क्रेडेंशियल्स को भी anonymous माना जा सकता है; v2.35.0 इस बग को ठीक करता है, इसलिए किसी रुक-रुक कर आने वाले 403 को ACL समस्या का प्रमाण मानने से पहले अपग्रेड करें। पूरी सूची प्रिंट करने के लिए ntfy access चलाएँ। याद रखें कि write ग्रांट सब्सक्राइब करने की अनुमति नहीं देता है, इसलिए जो अकाउंट पब्लिश तो ठीक से कर लेता है, उसे उसी टॉपिक को पढ़ने की कोशिश करने पर अस्वीकार कर दिया जाएगा।

क्या iPhone पर सेल्फ-होस्टेड ntfy सर्वर के साथ नोटिफिकेशन काम करते हैं?

जब आप आधिकारिक iOS ऐप का उपयोग करते हैं तो वे एक रिले के माध्यम से काम करते हैं। सस्पेंडेड iPhone ऐप के लिए प्रॉम्प्ट वेक-अप APNs (Apple push notification service) के माध्यम से आना चाहिए, और आधिकारिक ऐप पर भेजने के लिए उसके पब्लिशर के पुश क्रेडेंशियल्स की आवश्यकता होती है, इसलिए ntfy मैसेज ID युक्त एक poll_request को ntfy.sh पर फॉरवर्ड करता है, जो इसे डिवाइस पर रिले करता है। server.yml में upstream-base-url: "https://ntfy.sh" सेट करें और कंटेनर को रीस्टार्ट करें। मैसेज बॉडी अभी भी आपके सर्वर से ही फेच की जाती है। उस सेटिंग के बिना, iOS नोटिफिकेशन अंततः आ तो जाते हैं, लेकिन ntfy के डॉक्स चेतावनी देते हैं कि इसमें घंटों की देरी हो सकती है। iOS 16.4 या उसके बाद के वर्ज़न पर PWA एक और रास्ता प्रदान करता है जब आपके सर्वर पर Web Push कॉन्फ़िगर किया गया हो।

मेरे क्रोन जॉब का ntfy अलर्ट कभी क्यों नहीं आया?

यह साबित करने के लिए कि टोकन और टॉपिक सही हैं, पहले curl लाइन को अकेले चलाकर देखें। यदि यह मैन्युअल रूप से काम करता है लेकिन क्रोन से नहीं, तो विफलता अलर्ट से पहले की है: क्रोन जॉब्स को न्यूनतम एनवायरनमेंट और छोटे PATH के साथ चलाता है, इसलिए जो स्क्रिप्ट कमांड को केवल नाम से कॉल करती है, वह curl लाइन तक पहुँचने से पहले ही बंद हो सकती है। एब्सोल्यूट पाथ का उपयोग करें, जॉब के आउटपुट को एक लॉग फाइल में रीडायरेक्ट करें, और अगली बार चलने के बाद उस फाइल को पढ़ें। डिलीवरी के बजाय 429 रिस्पॉन्स का मतलब है कि किसी लिमिट ने रिक्वेस्ट को अस्वीकार कर दिया है। आमतौर पर स्क्रिप्ट बहुत तेज़ी से रिट्राई कर रही होती है, लेकिन एक विज़िटर जिसने दैनिक कोटा समाप्त कर लिया है, जैसे कि ऊपर सेट की गई मैसेज लिमिट, उसे एक सिंगल रिक्वेस्ट पर भी इसी तरह अस्वीकार कर दिया जाता है।

क्या मुझे ntfy को पब्लिक इंटरनेट पर एक्सपोज़ करना चाहिए?

फोन ऐप्स को मोबाइल नेटवर्क से उस तक पहुँचने की आवश्यकता होती है, इसलिए auth-default-access: "deny-all" और प्रति-टॉपिक ACLs के साथ एक पब्लिक HTTPS एंडपॉइंट सामान्य सेटअप है, और यह तब तक सुरक्षित है जब तक कोई भी टॉपिक everyone द्वारा पठनीय न हो। VPN-ओनली इंस्टेंस तब उचित है जब हर सब्सक्राइबर एक ऐसी मशीन हो जिसे आप कंट्रोल करते हैं। यह फोन के लिए एक खराब विकल्प है, क्योंकि ऐप केवल तभी रिसीव करता है जब टनल अप होती है, इसलिए फोन के दोबारा कनेक्ट होने तक अलर्ट कतार में रहते हैं।

क्या यह लेख उपयोगी था?