SSD Nodes Learn Hosting plans →
मार्गदर्शक Matt Connorद्वारे Matt Connor

ntfy सर्व्हर स्वतःच्या VPS वर कसा सेट करावा?

Docker Compose वापरून स्वतःच्या VPS वर ntfy कसे चालवावे ते शिका. TLS सुरक्षा, ACLs आणि वापरकर्ता प्रमाणीकरण सेट करून cron व systemd द्वारे पुश नोटिफिकेशन्स मिळवण्याची पूर्ण पद्धत.

self-hosted ntfy सर्व्हर काय करतो

एक self-hosted ntfy सर्व्हर HTTP POST विनंतीचे रूपांतर तुमच्या फोनवरील पुश नोटिफिकेशनमध्ये करतो. तुम्ही curl वापरून मेसेज पब्लिश करता आणि तो मेसेज Android ॲप, iOS ॲप, ब्राउझर टॅब किंवा HTTP कनेक्शन उघडे ठेवू शकणाऱ्या कोणत्याही उपकरणावर पोहोचतो. यासाठी कोणतीही क्लायंट लायब्ररी इन्स्टॉल करण्याची किंवा मेसेज ब्रोकर चालवण्याची गरज नसते.

ntfy मेसेजना topic द्वारे संबोधित करतो. topic म्हणजे URL पाथ मधील एक नाव, जसे की https://ntfy.example.com/alerts, आणि ज्या क्षणी कोणीतरी त्यावर मेसेज पब्लिश करतो, त्या क्षणी ते अस्तित्वात येते. डीफॉल्ट इन्स्टॉलेशनमध्ये, ज्याला त्या नावाचे ज्ञान आहे तो कोणीही तो टॉपिक वाचू शकतो आणि त्यावर लिहू शकतो, म्हणूनच प्रकल्पाच्या स्वतःच्या दस्तऐवजीकरणामध्ये टॉपिकच्या नावाची तुलना पासवर्डशी केली आहे. हे मॉडेल सार्वजनिक ntfy.sh सेवेसाठी योग्य आहे. परंतु, तुमच्या बॅकअप अपयशांची माहिती वाहून नेणाऱ्या सर्व्हरसाठी हे सुरक्षित नाही, म्हणून हे मार्गदर्शक पहिला मेसेज पाठवण्यापूर्वीच ऑथेंटिकेशन (authentication) सुरू करण्याची प्रक्रिया सांगते.

सुरू करण्यापूर्वी आवश्यक गोष्टी

तुमच्याकडे Docker Engine आणि Compose plugin असलेला Ubuntu 24.04 किंवा Debian 13 चालणारा VPS, एक domain name आणि अत्यल्प RAM असणे आवश्यक आहे. Server च्या public IP address कडे निर्देश करणारा DNS (domain name system) A record तयार करा. या record मध्ये ntfy.example.com वापरा. त्यानंतर इतर कोणतेही काम करण्यापूर्वी तो resolve होत असल्याची खात्री करा.

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

dig ने तुमच्या server चा IP print झाला पाहिजे. Certificate issuance साठी hostname सार्वजनिकरीत्या A किंवा AAAA record द्वारे server कडे resolve होणे आवश्यक आहे. Port 80 उघडा ठेवा, कारण Let's Encrypt च्या मागील प्रोटोकॉल ACME (automatic certificate management environment) कडून HTTP challenge साठी त्याचा वापर केला जातो. ntfy container ला स्वतःचा कोणताही public port मिळत नाही.

ntfy कॉन्फिगरेशन फाइल लिहा

Docker image मध्ये कॉन्फिगरेशन फाइल नसते, त्यामुळे ती तुम्ही तयार कराल. या मार्गदर्शिकेतील पुढील प्रत्येक command ही फाइल वाचतो. सर्वप्रथम container कोणत्या 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 त्याचा वापर तयार केलेल्या attachment links आणि self-hosted iOS push notifications साठी करते. listen-http: ":2586" container मधील सर्व interfaces वर bind करते. हे निष्काळजीपणाचे दिसले तरी योग्य आहे. Container चे स्वतःचे network namespace असल्यामुळे तेथे 127.0.0.1 वर bind केल्यास host कडून port पर्यंत पोहोचता येणार नाही आणि Docker चा published port कधीही connect होणार नाही. auth-default-access: "deny-all" संपूर्ण security posture ठरवते, कारण स्पष्ट परवानगी नसलेल्या कोणत्याही user ला read किंवा write करता येत नाही. behind-proxy: true ntfy ला client address X-Forwarded-For header मधून घ्यायला सांगते. त्यामुळे rate limits reverse proxy ला एकच अतिशय सक्रिय client मानण्याऐवजी प्रत्यक्ष visitors मोजतात.

enable-login: true वापरकर्त्यांना web app किंवा API द्वारे sign in करण्याची परवानगी देते. enable-signup falseच राहते, कारण private server वर self-service account creation सुरू करणे म्हणजे अनावश्यक अतिरिक्त टप्प्यांसह प्रवेश खुला ठेवणे होय.

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 file मधील दोन तपशील हेतुपुरस्सर ठेवले आहेत. Image ला v2.36.0 वर pin केले आहे. 1 November 2026 रोजी ही सध्याची stable release आहे. latest ऐवजी हे वापरले आहे, कारण latest सह पुढील docker compose pull current image download करतो आणि त्यानंतरचा docker compose up -d container पुन्हा तयार करतो. फक्त image pull केल्याने चालू server ची version बदलत नाही. Pin देखील update करावा लागतो. October 2026 मध्येच दहा releases आल्या: 7 October रोजी v2.29.0, 12 October रोजी v2.30.0, 16 October रोजी v2.31.0 आणि v2.31.1, 18 October रोजी v2.32.0, 23 October रोजी v2.33.0 आणि v2.33.1, 24 October रोजी v2.34.0, 30 October रोजी v2.35.0 आणि 31 October रोजी v2.36.0. Client message cache पर्यंत पोहोचण्यापूर्वी reconnect झाल्यास messages हरवण्याची समस्या v2.31.0 मध्ये दुरुस्त केली आहे. मात्र since=<message ID> सह reconnect झाल्यावर त्या version मध्ये topic मधील प्रत्येक message database मधून वाचला जातो आणि ntfy.sh ने ती version मागे घेतली. नवीन index वापरून हा load v2.31.1 मध्ये कमी केला आहे. Revoked किंवा deleted users कडे काही subscriptions राहण्याची समस्या v2.34.0 मध्ये दुरुस्त केली आहे. Valid credentials असलेल्या concurrent requests ना anonymous समजण्याची समस्या आणि SQLite वरील Matrix push gateway authorization bypass v2.35.0 मध्ये दुरुस्त केले आहे. त्यामुळे जुने pins v2.36.0 वर हलवा. Port 127.0.0.1:2586:2586 म्हणून publish केला आहे. त्यामुळे container फक्त host च्या loopback address वरून उपलब्ध आहे. त्याऐवजी 2586:2586 लिहिल्यास Docker तुमच्या rules च्या आधी स्वतःचे firewall rules लागू करतो. त्यामुळे ufw status मध्ये port बंद असल्याचे दिसत असले तरी तो port internet वरून प्रतिसाद देतो. तुम्ही पुढे जोडणार असलेल्या container साठीही हे दोन्ही नियम लागू होतात: self-hosted RustDesk relay त्याच पद्धतीने image tag pin करतो. मात्र तो loopback मागे ठेवता येत नाही, कारण त्याचे signal आणि relay ports internet वरून उपलब्ध असणे आवश्यक आहे.

curl ने Connection refused छापल्यास container log वाचा. /var/lib/ntfy/user.db वरील permission error चा अर्थ user: line त्या directories च्या owner शी जुळत नाही. त्यामुळे process स्वतःचे database तयार करू शकत नाही आणि बंद होते. VPS साठीचे Docker Compose basics guide volume ownership आणि restart policies अधिक तपशीलवार स्पष्ट करते.

Caddy वापरून पुढे TLS जोडा

Caddy स्वतः प्रमाणपत्राची विनंती करतो आणि त्याचे नूतनीकरण करतो. त्यामुळे 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

हेच {"healthy":true,"role":"active"} HTTPS वरून उघडल्यास संपूर्ण मार्ग कार्यरत आहे हे स्पष्ट होते. Caddy कडून मिळणारा 502 बहुतेकदा ntfy ऐकत नसल्याचे दर्शवतो: sudo ss -lntp | grep 2586 वापरून तपासा. ntfy ऐकत असेल आणि 502 कायम राहिला, तर Caddy ला upstream कडून मिळालेली त्रुटी logs मध्ये नोंदवली जाते, उदाहरणार्थ connection reset. प्रमाणपत्राशी संबंधित त्रुटीचा अर्थ सहसा DNS record चुकीचा आहे किंवा port 80 किंवा 443 वरून प्रमाणपत्र पडताळणीसाठी सर्व्हरपर्यंत पोहोचता येत नाही असा होतो; पडताळणीतील त्रुटीसाठी sudo journalctl -u caddy -n 50 तपासा. नंतर आणखी एखादी सेवा जोडण्यासाठी त्याच Caddyfile मध्ये आणखी एक hostname block जोडावा लागतो. याच पद्धतीने तुमच्या Jellyfin library साठी 90s शैलीचे video store frontend असलेले Halcyon त्याच सर्व्हरवरील दुसऱ्या subdomain वर उपलब्ध करता येते.

तुम्ही आधीपासून nginx चालवत असल्यास, ntfy च्या दस्तऐवजातील proxy settings कॉपी करा: proxy_http_version 1.1, proxy_buffering off, proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for. तसेच read आणि send timeouts किमान तीन मिनिटांचे ठेवा. Subscriber ऐकत असताना एक HTTP connection सतत उघडे ठेवतो. nginx मधील 60 सेकंदांचा default proxy_read_timeout हा केवळ दोन reads मधील वेळ मोजतो. ntfy default ने दर 45 सेकंदांनी keepalive message पाठवते (keepalive-interval), जेणेकरून inactivity मुळे intermediaries connection बंद करू नयेत. त्यामुळे शांत subscriber stock nginx च्या मागेही connected राहतो. अधिक मोठे timeouts हे अतिरिक्त मर्यादा देतात; connection जिवंत ठेवण्याचे मुख्य कारण ते नाहीत. keepalive-interval वाढवल्यास ते तुमच्या proxy च्या read timeout पेक्षा कमी ठेवा.

वापरकर्ते तयार करा आणि topics वर प्रवेश मर्यादित करा

Authentication सुरू आहे आणि अद्याप कोणालाही कशावरही प्रवेश नाही. हेच अपेक्षित आहे. स्वतःसाठी एक admin account आणि scripts साठी एक machine account तयार करा. या commands कंटेनरच्या आतून /etc/ntfy/server.yml वाचतात. म्हणून config file volume mount म्हणून जोडलेली आहे.

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 command password विचारते. admin access list कडे दुर्लक्ष करतो आणि प्रत्येक topic वाचू तसेच लिहू शकतो. त्यामुळे हा account फक्त स्वतःसाठी आणि phone app साठी ठेवा. robot हा असा सामान्य user आहे ज्याला तुम्ही काही प्रवेश देईपर्यंत कोणताही प्रवेश नसतो.

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 (access control list) entry मध्ये user, topic आणि permission असतात. Topic हे literal name किंवा pattern असू शकते. त्यात * कोणत्याही मजकुराशी जुळते. त्यामुळे प्रत्येक host साठी स्वतंत्र command न देता alerts_* हे alerts_backup आणि alerts_db दोन्हीवर लागू होते. write permission म्हणजे फक्त publish. त्यामुळे cron job मधून token चोरीला गेला तरी तो subscribe करून पाठवलेला data वाचू शकत नाही. विशेष username everyone वापरून unauthenticated visitor काय करू शकतो हे ठरवता येते. deny-all default असल्यास, deliberately public ठेवायच्या गोष्टीसाठी त्याचा मुख्यतः वापर कराल, जसे ntfy access everyone status read. तसेच anonymous visitors ना एखाद्या topic पासून दूर ठेवणारा explicit rule हवा असल्यास deny देखील स्वीकारले जाते.

Scripts मध्ये तुमचा password न ठेवता token वापरा.

sudo docker compose exec ntfy ntfy token add robot

हा command tk_ ने सुरू होणारा token दाखवतो. Token ज्या user चा आहे त्याचेच access अधिकार त्याला मिळतात. त्यामुळे हा token alerts topics वर publish करू शकतो आणि इतर काहीही करू शकत नाही. ntfy token list उपलब्ध असलेल्या गोष्टी दाखवतो. ntfy token remove user चा password न बदलता एक token revoke करतो.

तुमचा पहिला संदेश पाठवा आणि लॉक काम करत असल्याची खात्री करा

दरवाजा बंद असल्याची खात्री करून सुरुवात करा.

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

हे 403 प्रिंट करते आणि 403 हे योग्य उत्तर आहे: auth-default-access: "deny-all" निनावी (anonymous) पब्लिश करण्यास नकार देते. आता एक खरा संदेश पाठवा.

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 नोटिफिकेशनवर इमोजी बनतात आणि जुळत नसल्यास ते साध्या मजकुराच्या स्वरूपात राहतात.

टर्मिनलवरून एखादा विषय (topic) पाहण्यासाठी, तो स्ट्रीम करा:

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

curl पासवर्ड विचारते. प्रत्येक संदेश एका ओळीत येतो आणि अधूनमधून दिसणाऱ्या रिकाम्या ओळी या 'कीप-अलाईव्ह' (keepalives) असतात. ब्राउझरमध्ये https://ntfy.example.com उघडून त्याच खात्याने साइन इन केल्यास तुम्हाला त्याच स्ट्रीमची वेब ॲप आवृत्ती मिळते.

एक script server वर भरपूर requests पाठवू नये यासाठी rate limits सेट करा

Default configuration मध्ये प्रत्येक visitor ला 60 requests ची bucket मिळते. ती दर 5 सेकंदांनी 1 request या वेगाने पुन्हा भरली जाते. Private server साठी ही मर्यादा मोठी आहे. Retry loop मध्ये अडकलेली script ही संपूर्ण bucket वापरू शकते. server.yml मध्ये limits जोडा.

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

मर्यादा ओलांडणाऱ्या visitor ला delivered message ऐवजी HTTP 429 मिळतो. मर्यादा visitor address नुसार मोजली जाते. त्यामुळे behind-proxy: true महत्त्वाचे आहे. ते नसल्यास ntfy ला फक्त Caddy चे address दिसते. प्रत्येक client एकाच visitor प्रमाणे मोजला जातो. त्यामुळे एक noisy script तुमचा phone आणि इतर servers यांच्यासोबत share केलेली bucket संपवू शकते. v2.36.0 पासून daily counts user database मध्ये restart नंतरही टिकतात. प्रत्येक visitor ची allowance UTC midnight ला एकत्र reset न होता स्वतःच्या 24-hour cycle नुसार reset होते.

क्रॉन जॉब अयशस्वी झाल्याची सूचना

टोकन कमांड लाईनमध्ये ठेवू नका. 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 कडे वळवून संपूर्ण प्रक्रियेची चाचणी घ्या.

कधीही कार्यान्वित न होणारी फेल्युअर ब्रांच ही अलर्टिंग नसण्यापेक्षाही वाईट आहे, कारण शांतता म्हणजे यश असा चुकीचा अर्थ निघू शकतो. Cron तुमच्या जॉबला जवळजवळ रिकामे वातावरण आणि तुमच्या लॉगिन शेलपेक्षा खूप लहान PATH देते, त्यामुळे हाताने चालवल्यावर काम करणारी स्क्रिप्ट curl लाईनपर्यंत पोहोचण्यापूर्वीच बंद पडू शकते. क्रॉन जॉब का चालत नाही यावरील मार्गदर्शक अशा वातावरणीय त्रुटींची माहिती देते. सर्व ठिकाणी ॲब्सोल्युट पाथ वापरा आणि पहिल्या शेड्युल्ड रननंतर गृहीत धरण्याऐवजी लॉग फाईल वाचा.

systemd unit अयशस्वी झाल्यावर सूचना द्या

Cron नियोजित कामांसाठी पुरेसा आहे. दीर्घकाळ चालणाऱ्या सेवांसाठी OnFailure= आवश्यक आहे. एखादा unit failed स्थितीत गेल्यावर systemd ते चालवते. एक 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

तुमच्या संपादनावर package upgrade मुळे परिणाम होऊ नये म्हणून drop-in वापरून ते एखाद्या सेवेशी जोडा.

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

%n पूर्ण unit name मध्ये विस्तारते. त्यामुळे 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 status देते आणि Job for ntfy-selftest.service failed because the control process exited with error code मुद्रित करते. त्यानंतर सुमारे एक सेकंदाने फोनवर सूचना आली पाहिजे. चाचणी unit नंतर हटवा.

एका महत्त्वाच्या अडचणीकडे लक्ष द्या. Unit failed स्थितीत पोहोचल्यावरच OnFailure= चालते. स्वयंचलित restart दरम्यान RestartMode=direct ही स्थिती वगळते. त्यामुळे failure handler देखील वगळला जातो. Default RestartMode=normal सह स्वयंचलित restart failed स्थितीतून जातात. वारंवार होणारे starts कधी नाकारायचे हे StartLimitBurst आणि StartLimitIntervalSec नियंत्रित करतात. Crash loop अखेरीस थांबेल अशा प्रकारे त्यांची मूल्ये सेट करा. वरील cron pattern साठी timers हा अधिक स्वच्छ पर्याय आहे, कारण timer च्या service unit मध्ये तोच OnFailure= drop-in वापरता येतो. VPS वरील systemd services आणि timers चे मार्गदर्शक एक unit मध्ये रूपांतर कसे करायचे ते स्पष्ट करते.

त्याच topic शी uptime monitor जोडा

Uptime Kuma, self-hosted status monitor, ntfy notification type देते. Settings उघडा, त्यानंतर Notifications आणि मग Setup Notification उघडा. Ntfy निवडा. Server URL मध्ये https://ntfy.example.com आणि topic मध्ये alerts सेट करा. Priority निवडा आणि robot access token paste करा. Save करण्यापूर्वी test notification पाठवा, कारण चुकीच्या topic नावामुळे तो समाविष्ट नसलेल्या write grant वर error येतो.

या रचनेची वास्तविक मर्यादा अशी आहे: त्याच VPS वर चालणारा monitor VPS down आहे हे सांगू शकत नाही आणि ntfy down असल्याची सूचना ntfy पाठवू शकत नाही. Monitor वेगळ्या machine वर चालवा आणि त्याला दुसरा notification channel द्या. उदाहरणार्थ, ntfy वर लक्ष ठेवणाऱ्या monitor साठी email वापरा. Uptime Kuma चा Push monitor type दुसरी blind spot दूर करतो: यशस्वी run नंतर तुमचा cron job push URL ला call करतो आणि हे calls येणे थांबल्यावर Kuma alert देतो. Failure branch फक्त job run झाल्यावर trigger होते. त्यामुळे job सुरूच झाले नाही, याबद्दल ती काहीही सांगत नाही.

स्वतः होस्ट केलेले ntfy Android आणि iPhone वर चालते का?

Android वर उत्तर कोणत्याही अटीशिवाय होय असे आहे. Google Play किंवा F-Droid वरून अॅप install करा, Settings उघडा, default server म्हणून https://ntfy.example.com सेट करा, user management screen मध्ये तुमचे खाते जोडा आणि त्यानंतर alerts subscribe करा. Instant delivery मुळे foreground service सुरू राहते. त्यामुळे फोन doze mode मध्ये असतानाही संदेश मिळतात. त्यासोबत दिसणारी कायमस्वरूपी notification ही foreground services साठी Android ची आवश्यकता आहे; ती bug नाही. F-Droid build मध्ये Firebase code अजिबात नाही. त्यामुळे प्रत्येक subscription साठी instant delivery वापरली जाते. ntfy हे UnifiedPush distributor म्हणूनही काम करू शकते. हे Google च्या push service चा open replacement आहे. त्यामुळे UnifiedPush ला support करणाऱ्या इतर अॅप्सनाही तुमच्या server मार्फत संदेश पाठवता येतात.

Official iOS app मध्ये ते चालते; मात्र एक dependency काढता येत नाही. iOS background मध्ये गेलेले app suspend करते. Apple परवानगी देत असलेले background modes—audio वाजवणे, location updates घेणे आणि scheduled tasks process करणे—यांपैकी कोणतेही mode app ला तुमच्या server कडून संदेशाची वाट पाहत बसू देत नाही. त्यामुळे app त्वरित wake करण्यासाठी APNs (Apple push notification service) वापरावे लागते. App साठी अधिकृत credentials असलेला providerच त्या app कडे संदेश पाठवू शकतो. त्यामुळे तुमच्या server ला official app शी थेट संपर्क साधता येत नाही. ntfy यासाठी relay वापरते: तुमचा server संदेशाचा ID असलेले poll_request ntfy.sh कडे पाठवतो. ntfy.sh ते Firebase आणि APNs मार्फत app wake करण्यासाठी forward करते. त्यानंतर app संदेशाचा मजकूर तुमच्या server कडून fetch करते.

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

यासाठी कोणती किंमत मोजावी लागते हे स्पष्ट समजून घ्या. संदेशाचा मजकूर तुमच्या server वरच राहतो. मात्र संदेश आल्याची माहिती आणि त्याचा ID तुम्ही चालवत नसलेल्या infrastructure मधून जातो. हे setting नसल्यास self-hosted server कडून iPhone वर notifications अखेरीस मिळतात. मात्र app त्वरित wake करणारी यंत्रणा नसल्यामुळे विलंब काही तासांपर्यंत होऊ शकतो, असा ntfy च्या docs मध्ये इशारा दिला आहे. ntfy.sh relay शिवाय native iOS app वापरायचे असल्यास तुमच्या Apple developer account आणि तुमच्या APNs keys वापरून app स्वतः build आणि ship करावे लागेल. यासाठी वार्षिक शुल्क द्यावे लागते आणि प्रत्येक update साठी app पुन्हा build करावे लागते. दुसरा पर्याय म्हणजे iOS 16.4 किंवा त्यानंतरच्या आवृत्तीवरील ntfy चे PWA. ते home screen वर add करा आणि तुमच्या server वर Web Push configure करा. यामुळे ntfy.sh relay टाळता येते; परंतु browser चे push infrastructure तरीही वापरले जाते. तुमच्या वापरासाठी relay स्वीकारार्ह नसेल, तर alerting Android किंवा desktop web app वर ठेवा.

Backups, upgrades आणि image pin करणे

दोन paths पुन्हा तयार करता येत नाहीत: /etc/ntfy/server.yml आणि /var/lib/ntfy/user.db. दुसऱ्या path मध्ये प्रत्येक 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

ही file server च्या बाहेर copy करा. cache.db मध्ये अलीकडील messages साठतात. cache-duration मधील configuration नुसार त्यात 12 तासांचे messages असतात. तसेच नंतर delivery साठी schedule केलेला प्रत्येक message delivery झाल्यानंतर 12 तासांपर्यंत तिथे राहतो. तुम्ही messages आधीपासून schedule करत नसल्यास ही file हरवल्याने संरक्षण करण्यासारखे कोणतेही महत्त्वाचे data गमावले जात नाही. Upgrade करण्यासाठी compose file मधील tag edit करा, image pull करा आणि container पुन्हा तयार करा.

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

सर्वप्रथम release notes वाचा. Start होताना SQLite databases migrate होतात. त्यामुळे schema change झाल्यानंतर जुन्या tag वर rollback करणे सुरक्षित नाही. उदाहरणार्थ, v2.31.1 मध्ये message cache schema version 17 वर हलवण्यात आला. त्या version च्या upgrade notes नुसार v2.31.0 किंवा त्यापूर्वीच्या version वर downgrade करण्यासाठी ही version स्वतःहून 16 वर परत सेट करावी लागते. v2.36.0 वर upgrade केल्यावर सर्व users चे विद्यमान daily counts एकदा reset होतात. नुकतेच घेतलेले backup नवीन version एक दिवस चालल्यानंतरपर्यंत जतन ठेवा. Notes मध्ये behaviour changes देखील नमूद केलेले असतात. v2.31.0 पासून since=<message ID> सह reconnect करणाऱ्या client ला त्याच second मध्ये publish झालेले messages देखील मिळतात. त्यामुळे duplicate message दिसू शकतो. ntfy apps आणि web app message ID नुसार duplicates काढून टाकतात. मात्र स्वतःची script topic पुन्हा replay करत असल्यास तिलाही तेच करावे लागते. या server वरील प्रत्येक service कडे पुन्हा तयार करता न येणाऱ्या paths ची स्वतःची छोटी यादी असते. त्याच प्रकारच्या VPS वरील photo library साठी PhotoPrism आणि Immich यांची तुलना ही यादी आणि त्यासोबतचे backup commands स्पष्ट करते.

Gotify आणि Apprise

Gotify हा अधिक लहान पर्याय आहे: त्यात एक binary, web UI आणि Android app असते. संदेश application नुसार व्यवस्थित केले जातात. Android हेच एकमेव target असलेल्या private box साठी हा पर्याय योग्य ठरतो. Apprise ही Python library आणि command line tool आहे. स्वतंत्र Apprise API server देखील उपलब्ध आहे. ती एकच संदेश ntfy सहित शंभरहून अधिक services कडे पाठवू शकते. त्यामुळे एकाच वेळी अनेक ठिकाणी पोहोचणे आवश्यक असलेल्या script साठी ती योग्य ठरते. ntfy मध्ये server, HTTP API आणि दोन्ही mobile platforms साठी apps मिळतात. म्हणून rented server वरून alerts पाठवण्यासाठी तो नेहमीचा पर्याय आहे.

FAQ

माझ्या ntfy सर्व्हरवर publish केल्यावर 403 का मिळतो?

auth-default-access: "deny-all" हे server.yml मध्ये सक्षम असल्यास anonymous publish नाकारले जाते. हे अपेक्षित वर्तन आहे. -u user:pass किंवा -H "Authorization: Bearer tk_..." वापरून credentials पाठवा. तुम्ही token आधीच पाठवत असाल आणि तरीही 403 मिळत असेल, तर त्या user साठी topic वर write करण्याची परवानगी देणारी ACL entry आहे का ते तपासा: जुळणारी entry नसल्यास, read-only किंवा deny publish नाकारते. v2.34.0 मध्ये त्याच IP कडून आलेल्या concurrent requests मुळे वैध credentials देखील anonymous म्हणून हाताळले जाऊ शकत होते. v2.35.0 मध्ये ही त्रुटी दुरुस्त केली आहे. त्यामुळे अधूनमधून मिळणारे 403 हे ACL समस्येचे पुरावे मानण्यापूर्वी upgrade करा. संपूर्ण यादी दाखवण्यासाठी ntfy access चालवा. लक्षात ठेवा, write grant मुळे subscribe करण्याची परवानगी मिळत नाही. त्यामुळे publish यशस्वीपणे करणारे account त्याच topic चे वाचन करण्याचा प्रयत्न करताना तरीही नाकारले जाईल.

self-hosted ntfy सर्व्हरसह iPhone वर notifications काम करतात का?

अधिकृत iOS app वापरल्यास त्या relay द्वारे काम करतात. suspended iPhone app ला prompt wake-up देण्यासाठी APNs (Apple push notification service) आवश्यक असते. अधिकृत app कडे notification पाठवण्यासाठी तिच्या publisher ची push credentials आवश्यक असतात. त्यामुळे ntfy संदेश ID असलेले poll_request ntfy.sh कडे forward करते. ntfy.sh ते device कडे relay करते. server.yml मध्ये upstream-base-url: "https://ntfy.sh" सेट करा आणि container restart करा. संदेशाचा body मात्र तुमच्या सर्व्हरवरूनच fetch केला जातो. ही setting नसल्यास iOS notifications अखेरीस येतात, परंतु ntfy च्या documentation नुसार विलंब काही तासांपर्यंत होऊ शकतो. तुमच्या सर्व्हरवर Web Push configure केले असल्यास iOS 16.4 किंवा त्यानंतरच्या आवृत्त्यांमध्ये PWA हा आणखी एक पर्याय आहे.

माझ्या cron job चे ntfy alert कधीच का आले नाही?

Token आणि topic योग्य आहेत हे प्रथम तपासण्यासाठी curl line स्वतंत्रपणे चालवा. हाताने चालवल्यावर ते काम करत असेल, पण cron मधून काम करत नसेल, तर alert च्या आधीच्या टप्प्यात failure होत आहे. cron jobs minimal environment आणि लहान PATH सह चालवतो. त्यामुळे bare name ने command call करणारी script curl line पर्यंत पोहोचण्यापूर्वीच बंद होऊ शकते. Absolute paths वापरा, job चे output log file मध्ये redirect करा आणि पुढील run नंतर ती file वाचा. Delivery ऐवजी 429 response मिळाल्यास एखाद्या limit मुळे request नाकारली आहे. साधारणपणे script खूप वेगाने retry करत असते. मात्र वर सेट केलेल्या message limit सारखी daily quota संपवलेल्या visitor ची एकच request असली तरी ती त्याच प्रकारे नाकारली जाते.

ntfy सार्वजनिक इंटरनेटवर उपलब्ध करून द्यावे का?

Phone apps ना mobile networks वरून ntfy पर्यंत पोहोचणे आवश्यक असते. त्यामुळे auth-default-access: "deny-all" आणि per-topic ACLs असलेला public HTTPS endpoint ही नेहमीची रचना आहे. कोणताही topic everyone साठी readable नसल्यास ही रचना सुरक्षित आहे. प्रत्येक subscriber हा तुमच्या नियंत्रणातील machine असल्यास VPN-only instance योग्य ठरू शकतो. Phones साठी तो कमी योग्य आहे. Tunnel सुरू असेल तेव्हाच app ला notifications मिळतात. त्यामुळे phone पुन्हा connect होईपर्यंत alerts queue मध्ये राहतात.

हा लेख उपयुक्त होता का?