วิธีติดตั้ง ntfy บน VPS ของตัวเองด้วย Docker Compose
เรียนรู้วิธีติดตั้งเซิร์ฟเวอร์ ntfy บน VPS ของคุณเองผ่าน Docker Compose พร้อมตั้งค่า TLS และระบบ ACL เพื่อความปลอดภัยในการส่งแจ้งเตือนจาก cron และ systemd OnFailure
หน้าที่ของเซิร์ฟเวอร์ ntfy ที่โฮสต์ด้วยตนเอง
เซิร์ฟเวอร์ ntfy ที่คุณโฮสต์เองจะเปลี่ยนคำขอ HTTP POST ให้กลายเป็นการแจ้งเตือนแบบ push บนโทรศัพท์ของคุณ คุณสามารถเผยแพร่ข้อความด้วย curl แล้วข้อความจะไปปรากฏบนแอป Android, แอป iOS, แท็บเบราว์เซอร์ หรืออุปกรณ์ใดก็ตามที่สามารถเปิดการเชื่อมต่อ HTTP ค้างไว้ได้ โดยไม่จำเป็นต้องติดตั้งไลบรารีฝั่งไคลเอ็นต์หรือรัน message broker ใดๆ เพิ่มเติม
ntfy ระบุข้อความด้วย topic ซึ่ง topic คือชื่อที่อยู่ใน URL path เช่น https://ntfy.example.com/alerts และมันจะถูกสร้างขึ้นทันทีที่มีคนเผยแพร่ข้อความไปยังชื่อนั้น ในการติดตั้งค่าเริ่มต้น ใครก็ตามที่ทราบชื่อ topic จะสามารถอ่านและเขียนข้อความใน topic นั้นได้ ด้วยเหตุนี้เอกสารของโครงการจึงเปรียบเทียบชื่อ topic ว่ามีค่าเสมือนรหัสผ่าน รูปแบบนี้อาจเหมาะสมสำหรับบริการสาธารณะอย่าง ntfy.sh แต่ไม่ปลอดภัยสำหรับเซิร์ฟเวอร์ที่ใช้แจ้งเตือนความล้มเหลวของการสำรองข้อมูล ดังนั้นคู่มือนี้จึงแนะนำให้เปิดใช้งานการยืนยันตัวตนก่อนที่จะมีการส่งข้อความแรกเกิดขึ้น
สิ่งที่ต้องเตรียมก่อนเริ่มต้น
คุณต้องมี VPS ที่รัน Ubuntu 24.04 หรือ Debian 13 พร้อมติดตั้ง Docker Engine และ Compose plugin รวมถึงชื่อโดเมนและ RAM จำนวนเล็กน้อย ให้สร้าง DNS (domain name system) A record โดยชี้ ntfy.example.com ไปยัง IP address สาธารณะของเซิร์ฟเวอร์ จากนั้นตรวจสอบให้แน่ใจว่าโดเมนดังกล่าวสามารถ resolve ได้ก่อนที่จะดำเนินการขั้นตอนอื่น
dig +short ntfy.example.com
sudo ufw allow 80,443/tcp
sudo ufw statusdig จะต้องแสดง IP address ของเซิร์ฟเวอร์คุณ การออกใบรับรองจำเป็นต้องให้ hostname สามารถ resolve สู่เซิร์ฟเวอร์ผ่าน A หรือ AAAA record ได้อย่างสาธารณะ พอร์ต 80 จะต้องเปิดไว้เนื่องจาก ACME (automatic certificate management environment) ซึ่งเป็นโปรโตคอลเบื้องหลัง Let's Encrypt จำเป็นต้องใช้พอร์ตนี้ในการทำ HTTP challenge สำหรับตัวคอนเทนเนอร์ ntfy เองนั้นไม่จำเป็นต้องเปิดพอร์ตสาธารณะแต่อย่างใด
เขียนไฟล์คอนฟิกของ 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.ymlbase-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มี 4 บรรทัดที่สำคัญมาก base-url ต้องเป็นที่อยู่ HTTPS สาธารณะที่ถูกต้อง เพราะ ntfy ใช้ที่อยู่นี้ในการสร้างลิงก์ไฟล์แนบและการแจ้งเตือนแบบ push สำหรับ iOS ที่โฮสต์เอง listen-http: ":2586" จะผูกกับทุกอินเทอร์เฟซภายในคอนเทนเนอร์ ซึ่งดูเหมือนไม่ปลอดภัยแต่เป็นสิ่งที่ถูกต้องแล้ว เนื่องจากคอนเทนเนอร์มี network namespace ของตัวเอง การผูกกับ 127.0.0.1 ในนั้นจะทำให้พอร์ตไม่สามารถเข้าถึงได้จากโฮสต์ และพอร์ตที่เผยแพร่โดย Docker จะไม่สามารถเชื่อมต่อได้เลย auth-default-access: "deny-all" คือมาตรการรักษาความปลอดภัยทั้งหมด เพราะมันจะปฏิเสธการอ่านและเขียนสำหรับทุกคนที่ไม่มีสิทธิ์อนุญาตอย่างชัดเจน behind-proxy: true สั่งให้ ntfy ดึงที่อยู่ของไคลเอนต์มาจากเฮดเดอร์ X-Forwarded-For เพื่อให้การจำกัดอัตรา (rate limit) นับจำนวนผู้เข้าชมจริง แทนที่จะนับรวม reverse proxy เป็นไคลเอนต์เพียงรายเดียวที่ใช้งานหนัก
enable-login: true ช่วยให้ผู้ใช้สามารถลงชื่อเข้าใช้ผ่านเว็บแอปหรือ API ได้ ส่วน enable-signup ให้ตั้งค่าเป็น false ไว้ เนื่องจากระบบสมัครบัญชีด้วยตนเองบนเซิร์ฟเวอร์ส่วนตัวเปรียบเสมือนการเปิดประตูทิ้งไว้โดยเพิ่มขั้นตอนที่ไม่จำเป็น
sudo chown "$(id -u):$(id -g)" /etc/ntfy/server.yml
sudo chmod 600 /etc/ntfy/server.ymlการรัน ntfy ด้วย Docker Compose
ใส่เนื้อหานี้ลงใน /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-stoppedcd /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 ซึ่งเป็นรุ่น stable ปัจจุบัน ณ วันที่ 1 พฤศจิกายน 2026 แทนที่จะใช้ latest เพราะหากใช้ latest คำสั่ง docker compose pull ถัดไปจะดาวน์โหลด image ล่าสุด และคำสั่ง docker compose up -d จะสร้างคอนเทนเนอร์ใหม่ด้วย image นั้น การสั่ง pull เพียงอย่างเดียวไม่สามารถเปลี่ยนเวอร์ชันของเซิร์ฟเวอร์ที่กำลังทำงานอยู่ได้ การล็อกเวอร์ชันยังคงต้องมีการอัปเดตอยู่ดี เฉพาะเดือนตุลาคม 2026 เดือนเดียวมีการปล่อยรุ่นออกมาถึง 10 เวอร์ชัน ได้แก่ v2.29.0 เมื่อวันที่ 7 ตุลาคม, v2.30.0 เมื่อวันที่ 12 ตุลาคม, v2.31.0 และ v2.31.1 เมื่อวันที่ 16 ตุลาคม, v2.32.0 เมื่อวันที่ 18 ตุลาคม, v2.33.0 และ v2.33.1 เมื่อวันที่ 23 ตุลาคม, v2.34.0 เมื่อวันที่ 24 ตุลาคม, v2.35.0 เมื่อวันที่ 30 ตุลาคม และ v2.36.0 เมื่อวันที่ 31 ตุลาคม รุ่น v2.31.0 แก้ไขปัญหาข้อความสูญหายเมื่อไคลเอนต์เชื่อมต่อใหม่ก่อนที่ข้อความจะถึงแคช แต่การเชื่อมต่อใหม่ด้วย since=<message ID> จะอ่านทุกข้อความในหัวข้อจากฐานข้อมูล ทำให้ ntfy.sh ต้องถอยเวอร์ชันกลับ รุ่น v2.31.1 แก้ไขภาระงานดังกล่าวด้วยดัชนีใหม่ และ v2.34.0 แก้ไขปัญหาผู้ใช้ที่ถูกเพิกถอนหรือลบไปแล้วยังคงมีการสมัครรับข้อมูลบางรายการอยู่ รุ่น v2.35.0 แก้ไขปัญหาคำขอพร้อมกันที่มองว่าข้อมูลประจำตัวที่ถูกต้องเป็นผู้ใช้ไม่ระบุตัวตน และแก้ไขช่องโหว่การข้ามการตรวจสอบสิทธิ์ Matrix push gateway บน SQLite ดังนั้นควรย้ายการล็อกเวอร์ชันรุ่นเก่าไปที่ v2.36.0 พอร์ตถูกเผยแพร่เป็น 127.0.0.1:2586:2586 เพื่อให้เข้าถึงคอนเทนเนอร์ได้จาก loopback address ของโฮสต์เท่านั้น หากเขียนเป็น 2586:2586 แทน Docker จะแทรกกฎ firewall ของตัวเองไว้หน้ากฎของคุณ ซึ่งหมายความว่าพอร์ตจะตอบสนองจากอินเทอร์เน็ตแม้ว่า ufw status จะระบุว่าพอร์ตปิดอยู่ก็ตาม ทั้งสองนิสัยนี้ส่งผลต่อคอนเทนเนอร์ถัดไปที่คุณเพิ่ม: การทำ RustDesk relay ด้วยตนเอง จะล็อกแท็ก image ในลักษณะเดียวกัน แต่ไม่สามารถซ่อนอยู่หลัง loopback ได้ เพราะพอร์ตสัญญาณและพอร์ต relay ต้องตอบสนองจากอินเทอร์เน็ต
หาก curl แสดงผล Connection refused ให้ตรวจสอบ log ของคอนเทนเนอร์ ข้อผิดพลาดเรื่องสิทธิ์บน /var/lib/ntfy/user.db หมายความว่าบรรทัด user: ไม่ตรงกับเจ้าของไดเรกทอรีเหล่านั้น ทำให้กระบวนการไม่สามารถสร้างฐานข้อมูลของตัวเองได้และหยุดทำงาน คู่มือพื้นฐาน Docker Compose สำหรับ VPS ครอบคลุมเรื่องความเป็นเจ้าของ volume และนโยบายการรีสตาร์ทไว้อย่างละเอียด
การติดตั้ง TLS ด้วย Caddy
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 ได้สำเร็จหมายความว่าเส้นทางทั้งหมดทำงานได้ปกติ หากได้รับ 502 จาก Caddy โดยปกติแล้วหมายความว่า ntfy ไม่ได้เปิดรับการเชื่อมต่อ ให้ตรวจสอบด้วย sudo ss -lntp | grep 2586 หาก ntfy เปิดรับการเชื่อมต่ออยู่แต่ยังคงพบ 502 ให้ตรวจสอบ log ของ Caddy เพื่อดูข้อผิดพลาดจาก upstream เช่น การรีเซ็ตการเชื่อมต่อ ข้อผิดพลาดเกี่ยวกับใบรับรองมักเกิดจากระเบียน DNS ไม่ถูกต้อง หรือกระบวนการตรวจสอบใบรับรองไม่สามารถเข้าถึงเซิร์ฟเวอร์ผ่านพอร์ต 80 หรือ 443 ได้ ให้ตรวจสอบ sudo journalctl -u caddy -n 50 เพื่อดูรายละเอียดข้อผิดพลาดในการตรวจสอบ หากต้องการเพิ่มบริการอื่นในภายหลัง สามารถเพิ่มบล็อก hostname อีกหนึ่งบล็อกใน Caddyfile เดียวกัน ซึ่งเป็นวิธีที่ทำให้บริการอย่าง Halcyon, หน้าเว็บร้านเช่าวิดีโอสไตล์ยุค 90 สำหรับคลัง Jellyfin ของคุณ สามารถใช้งานบน subdomain ที่สองของเซิร์ฟเวอร์เดียวกันได้
หากคุณใช้งาน nginx อยู่แล้ว ให้คัดลอกการตั้งค่า proxy ที่ ntfy ระบุไว้ ได้แก่ proxy_http_version 1.1, proxy_buffering off, proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for และตั้งค่า read และ send timeout อย่างน้อยสามนาที เนื่องจาก subscriber จะเปิดการเชื่อมต่อ HTTP ค้างไว้ตราบเท่าที่ยังคงรอรับข้อมูลอยู่ ค่า proxy_read_timeout เริ่มต้นของ nginx ที่ 60 วินาทีจะนับเฉพาะช่วงเวลาระหว่างการอ่านข้อมูลสองครั้ง และโดยปกติแล้ว ntfy จะส่งข้อความ keepalive ทุก 45 วินาที (keepalive-interval) เพื่อป้องกันไม่ให้ตัวกลางปิดการเชื่อมต่อเนื่องจากไม่มีกิจกรรม ดังนั้น subscriber ที่ไม่มีการรับส่งข้อมูลจึงยังคงเชื่อมต่ออยู่ได้แม้จะอยู่หลัง nginx ค่าเริ่มต้น และการตั้งค่า timeout ที่นานขึ้นนั้นเป็นเพียงการเผื่อเวลาไว้ ไม่ใช่สิ่งที่ทำให้การเชื่อมต่อคงอยู่ หากคุณเพิ่มค่า keepalive-interval ให้ตั้งค่าให้ต่ำกว่า read timeout ของ proxy ของคุณเสมอ
การสร้างผู้ใช้และการจำกัดสิทธิ์เข้าถึงหัวข้อ
ขณะนี้ระบบ Authentication เปิดใช้งานอยู่และยังไม่มีใครเข้าถึงข้อมูลใดได้ ซึ่งเป็นจุดประสงค์หลัก ให้สร้างบัญชีผู้ดูแลระบบ (admin) สำหรับตัวคุณเองหนึ่งบัญชี และบัญชีเครื่อง (machine account) สำหรับสคริปต์อีกหนึ่งบัญชี คำสั่งเหล่านี้จะอ่านค่า /etc/ntfy/server.yml จากภายในคอนเทนเนอร์ ซึ่งเป็นเหตุผลว่าทำไมไฟล์คอนฟิกจึงต้องถูก mount เป็น 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คำสั่ง user add แต่ละคำสั่งจะแจ้งให้คุณระบุรหัสผ่าน บัญชีผู้ดูแลระบบจะเพิกเฉยต่อรายการควบคุมการเข้าถึง (access list) และสามารถอ่านหรือเขียนหัวข้อใดก็ได้ ดังนั้นควรเก็บบัญชีนี้ไว้ใช้สำหรับตัวคุณเองและแอปบนโทรศัพท์ ส่วน 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 (access control list) ประกอบด้วยผู้ใช้ หัวข้อ และสิทธิ์การเข้าถึง หัวข้ออาจเป็นชื่อเฉพาะหรือรูปแบบ (pattern) โดยที่ * จะจับคู่กับข้อความใดก็ได้ ดังนั้น alerts_* จึงครอบคลุมทั้ง alerts_backup และ alerts_db โดยไม่จำเป็นต้องใช้คำสั่งแยกสำหรับแต่ละโฮสต์ สิทธิ์ write หมายถึงการเผยแพร่ (publish) ได้เท่านั้น ดังนั้นหากโทเค็นจาก cron job ถูกขโมยไป ผู้บุกรุกจะไม่สามารถสมัครรับข้อมูล (subscribe) เพื่ออ่านสิ่งที่ส่งไปก่อนหน้าได้ ชื่อผู้ใช้พิเศษ 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" ปฏิเสธการเผยแพร่แบบไม่ระบุตัวตน ตอนนี้ให้ส่งข้อความจริง
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/rawcurl จะแจ้งให้คุณป้อนรหัสผ่าน ข้อความแต่ละข้อความจะมาถึงทีละหนึ่งบรรทัด และบรรทัดว่างที่ปรากฏขึ้นเป็นระยะคือสัญญาณ keepalive การเปิด https://ntfy.example.com ในเบราว์เซอร์และลงชื่อเข้าใช้ด้วยบัญชีเดียวกันจะทำให้คุณใช้งานสตรีมเดียวกันในรูปแบบเว็บแอปได้
การตั้งค่าจำกัดอัตราเพื่อป้องกันไม่ให้สคริปต์เดียวทำให้เซิร์ฟเวอร์ล่ม
โดยปกติผู้เข้าชมแต่ละรายจะได้รับโควตา 60 คำขอ โดยจะเติมให้ใหม่ในอัตรา 1 คำขอทุก 5 วินาที ซึ่งถือว่าเพียงพอสำหรับเซิร์ฟเวอร์ส่วนตัว แต่สคริปต์ที่ติดอยู่ในลูปการลองใหม่จะใช้โควตาทั้งหมดจนหมด ให้เพิ่มการจำกัดใน server.yml
visitor-request-limit-burst: 30
visitor-request-limit-replenish: "10s"
visitor-message-daily-limit: 500sudo docker compose restart ntfyผู้เข้าชมที่เกินขีดจำกัดจะได้รับ HTTP 429 แทนที่จะได้รับข้อความ ขีดจำกัดนี้จะนับตามที่อยู่ของผู้เข้าชม ซึ่งเป็นเหตุผลว่าทำไม behind-proxy: true จึงสำคัญมาก หากไม่มีสิ่งนี้ ntfy จะเห็นเพียงที่อยู่ของ Caddy ทำให้ไคลเอนต์ทุกคนถูกนับเป็นผู้เข้าชมรายเดียวกัน และสคริปต์ที่ทำงานผิดปกติเพียงตัวเดียวจะใช้โควตาที่โทรศัพท์และเซิร์ฟเวอร์เครื่องอื่นของคุณต้องใช้ร่วมกันจนหมด ตั้งแต่ v2.36.0 เป็นต้นไป ยอดการใช้งานรายวันจะคงอยู่หลังการรีสตาร์ทในฐานข้อมูลผู้ใช้ และโควตาของผู้เข้าชมแต่ละรายจะรีเซ็ตตามรอบ 24 ชั่วโมงของตนเองแทนที่จะรีเซ็ตตอนเที่ยงคืน UTC
การแจ้งเตือนเมื่อ cron job ล้มเหลว
อย่าใส่ token ไว้ในบรรทัดคำสั่ง ps aux จะแสดงบรรทัดคำสั่งเต็มของทุกกระบวนการที่กำลังทำงานให้ผู้ใช้ทุกคนบนเครื่องเห็น ดังนั้น token ที่ส่งผ่าน -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 มีการจำกัดขนาดข้อความสูงสุดและการแจ้งเตือนไม่ใช่เครื่องมือสำหรับดู log การปิดท้ายด้วย exit "$code" จะช่วยรักษาค่าสถานะเดิมไว้ เพื่อให้ระบบอื่นที่เฝ้าติดตามงานนี้ยังคงเห็นว่าเกิดความล้มเหลว ทดสอบการทำงานทั้งหมดโดยชี้สคริปต์ไปที่ /bin/false สำหรับการรันหนึ่งครั้ง
การมีเงื่อนไขความล้มเหลวที่ไม่เคยทำงานนั้นแย่ยิ่งกว่าการไม่มีการแจ้งเตือน เพราะมันทำให้เข้าใจผิดว่าความเงียบหมายถึงความสำเร็จ Cron จะกำหนด environment ที่เกือบว่างเปล่าและ PATH ที่สั้นกว่า shell ของคุณมากให้กับงานของคุณ ดังนั้นสคริปต์ที่ทำงานได้เมื่อคุณรันด้วยตัวเองอาจหยุดทำงานก่อนที่จะไปถึงบรรทัด curl คู่มือว่าด้วยสาเหตุที่ cron job ไม่ทำงาน ครอบคลุมถึงกับดักด้าน environment เหล่านี้ ให้ใช้ absolute path เสมอ และอ่านไฟล์ log หลังจากที่งานรันตามกำหนดการครั้งแรกแทนการคาดเดาเอาเอง
การแจ้งเตือนเมื่อ 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 โดยกำหนดสิทธิ์เป็น 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 เพื่อป้องกันไม่ให้การอัปเดตแพ็กเกจเขียนทับการตั้งค่าของคุณ
sudo systemctl edit myapp.service[Unit]
OnFailure=ntfy-unit-failed@%n.service%n จะขยายผลเป็นชื่อ unit เต็ม ทำให้ unit ที่ถูกสร้างขึ้นใหม่กลายเป็น ntfy-unit-failed@myapp.service.service และ %i ภายใน template จะส่ง myapp.service ไปยังสคริปต์ในฐานะอาร์กิวเมนต์ตัวแรก นี่คือสิ่งที่ทำให้ 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/falsesudo systemctl daemon-reload
sudo systemctl start ntfy-selftest.serviceคำสั่ง start จะจบการทำงานด้วยค่าที่ไม่ใช่ศูนย์และแสดงผล Job for ntfy-selftest.service failed because the control process exited with error code จากนั้นโทรศัพท์ของคุณควรจะสั่นแจ้งเตือนในอีกประมาณหนึ่งวินาทีถัดมา ให้ลบ unit ทดสอบทิ้งหลังจากเสร็จสิ้น
มีข้อควรระวังที่สำคัญประการหนึ่งคือ OnFailure= จะทำงานก็ต่อเมื่อ unit เข้าสู่สถานะ failed เท่านั้น และ RestartMode=direct จะข้ามสถานะดังกล่าวไปในระหว่างการรีสตาร์ทอัตโนมัติ ทำให้ตัวจัดการความผิดพลาดถูกข้ามไปด้วย สำหรับค่าเริ่มต้นของ RestartMode=normal นั้น การรีสตาร์ทอัตโนมัติจะผ่านสถานะล้มเหลวตามปกติ ส่วน StartLimitBurst และ StartLimitIntervalSec จะเป็นตัวควบคุมว่าเมื่อใดที่การรีสตาร์ทซ้ำจะถูกปฏิเสธ ให้ตั้งค่าเหล่านี้ไว้เพื่อให้วงจรการ crash หยุดลงในที่สุด Timers เป็นทางเลือกที่สะอาดกว่ารูปแบบ cron ข้างต้น เนื่องจาก service unit ของ timer รองรับการใช้ drop-in แบบ OnFailure= เช่นเดียวกัน และ คู่มือการใช้งาน systemd services และ timers บน VPS จะอธิบายขั้นตอนการแปลงรูปแบบดังกล่าวไว้อย่างละเอียด
เชื่อมต่อระบบตรวจสอบสถานะ uptime เข้ากับหัวข้อเดียวกัน
Uptime Kuma ซึ่งเป็นเครื่องมือตรวจสอบสถานะแบบ self-hosted มีประเภทการแจ้งเตือนแบบ ntfy มาให้ในตัว ให้เปิดไปที่ Settings จากนั้นเลือก Notifications แล้วเลือก Setup Notification จากนั้นเลือก Ntfy กำหนด server URL เป็น https://ntfy.example.com และกำหนด topic เป็น alerts เลือกความสำคัญ (priority) และวาง access token ของ robot ลงไป ควรส่งการแจ้งเตือนทดสอบก่อนทำการบันทึก เพราะชื่อ topic ที่ไม่ถูกต้องจะส่งผลให้เกิดข้อผิดพลาดในการอนุญาตสิทธิ์ write ที่ไม่ครอบคลุมถึง topic นั้น
ข้อจำกัดที่สำคัญของการตั้งค่านี้คือ หากเครื่องมือตรวจสอบทำงานอยู่บน VPS เดียวกัน มันจะไม่สามารถแจ้งเตือนคุณได้หาก VPS นั้นล่ม และ ntfy ก็ไม่สามารถส่งข่าวสารได้หากตัว ntfy เองล่ม คุณควรติดตั้งเครื่องมือตรวจสอบบนเครื่องอื่น และเพิ่มช่องทางการแจ้งเตือนสำรอง เช่น อีเมล สำหรับเครื่องมือที่ใช้ตรวจสอบตัว ntfy เอง ประเภทการตรวจสอบแบบ Push ของ Uptime Kuma ช่วยแก้จุดบอดอีกด้านได้ โดย cron job ของคุณจะเรียกไปยัง push URL หลังจากทำงานสำเร็จ และ Kuma จะแจ้งเตือนเมื่อการเรียกเหล่านั้นหยุดลง อย่างไรก็ตาม การแจ้งเตือนกรณีล้มเหลวจะทำงานก็ต่อเมื่อ job เริ่มทำงานแล้วเท่านั้น ดังนั้นมันจึงไม่สามารถบอกได้ว่า job ที่ไม่เคยเริ่มทำงานนั้นเกิดปัญหาขึ้น
ntfy แบบ self-hosted ใช้งานบน Android และ iPhone ได้หรือไม่
บน Android สามารถใช้งานได้โดยไม่มีเงื่อนไขเพิ่มเติม ให้ติดตั้งแอปจาก Google Play หรือ F-Droid เปิด Settings ตั้งค่า default server เป็น https://ntfy.example.com เพิ่มบัญชีของคุณในหน้าจัดการผู้ใช้ จากนั้นสมัครรับข้อมูลที่ alerts ระบบ instant delivery จะรัน foreground service ไว้เพื่อให้ข้อความส่งถึงแม้โทรศัพท์จะอยู่ในโหมด doze การแจ้งเตือนแบบถาวรที่แสดงขึ้นมาเป็นข้อกำหนดของ Android สำหรับ foreground service ไม่ใช่ข้อผิดพลาดของแอป ตัว build จาก F-Droid ไม่มีโค้ดของ Firebase อยู่เลย ดังนั้นทุกการสมัครรับข้อมูลจะใช้ instant delivery ทั้งหมด นอกจากนี้ ntfy ยังทำหน้าที่เป็น UnifiedPush distributor ซึ่งเป็นทางเลือกแบบเปิดแทนบริการ push ของ Google ทำให้แอปอื่นที่รองรับ UnifiedPush สามารถส่งข้อความผ่านเซิร์ฟเวอร์ของคุณได้เช่นกัน
สำหรับแอปทางการบน iOS การทำงานจะมีข้อจำกัดหนึ่งประการที่ไม่สามารถหลีกเลี่ยงได้ iOS จะระงับการทำงานของแอปที่อยู่เบื้องหลัง และโหมด background ที่ Apple อนุญาต (เช่น การเล่นเสียง, การรับข้อมูลตำแหน่ง, การประมวลผลงานตามกำหนดเวลา) ไม่อนุญาตให้แอปค้างไว้เพื่อรอข้อความจากเซิร์ฟเวอร์ของคุณ ดังนั้นการปลุกแอปให้ทำงานทันทีจึงต้องผ่าน APNs (Apple push notification service) เท่านั้น มีเพียงผู้ให้บริการที่มีข้อมูลรับรองที่ได้รับอนุญาตสำหรับแอปเท่านั้นที่สามารถส่งข้อความได้ เซิร์ฟเวอร์ของคุณจึงไม่มีวิธีติดต่อแอปทางการโดยตรง ntfy แก้ปัญหานี้ด้วยการใช้ relay: เซิร์ฟเวอร์ของคุณจะส่ง poll_request ที่มี ID ของข้อความไปยัง ntfy.sh ซึ่งจะส่งต่อผ่าน Firebase และ APNs เพื่อปลุกแอป จากนั้นแอปจะดึงเนื้อหาข้อความจากเซิร์ฟเวอร์ของคุณอีกครั้ง
upstream-base-url: "https://ntfy.sh"โปรดทำความเข้าใจเกี่ยวกับต้นทุนในส่วนนี้ เนื้อหาของข้อความจะยังคงอยู่บนเซิร์ฟเวอร์ของคุณ แต่ข้อมูลที่ว่ามีข้อความเข้ามาและ ID ของข้อความนั้นจะผ่านโครงสร้างพื้นฐานที่คุณไม่ได้เป็นผู้ดูแล หากไม่มีการตั้งค่านี้ การแจ้งเตือนบน iPhone จากเซิร์ฟเวอร์แบบ self-hosted จะยังคงได้รับในที่สุด แต่เอกสารของ ntfy เตือนว่าอาจมีความล่าช้าได้นานหลายชั่วโมงเนื่องจากไม่มีสิ่งใดปลุกแอปให้ทำงานทันที หากต้องการใช้แอป iOS แบบเนทีฟโดยไม่ผ่าน relay ของ ntfy.sh คุณต้อง build และเผยแพร่แอปด้วยตนเองโดยใช้บัญชี Apple developer และกุญแจ APNs ของคุณเอง ซึ่งหมายถึงการมีค่าใช้จ่ายรายปีและการต้อง build แอปใหม่ทุกครั้งที่มีการอัปเดต อีกทางเลือกหนึ่งคือการใช้ PWA ของ ntfy บน iOS 16.4 ขึ้นไป โดยเพิ่มลงในหน้าจอหลักและกำหนดค่า Web Push บนเซิร์ฟเวอร์ของคุณ วิธีนี้จะหลีกเลี่ยงการใช้ relay ของ ntfy.sh แต่ยังคงต้องใช้โครงสร้างพื้นฐาน push ของเบราว์เซอร์ หากการใช้ relay เป็นสิ่งที่ยอมรับไม่ได้สำหรับกรณีการใช้งานของคุณ แนะนำให้ใช้การแจ้งเตือนบน Android หรือผ่านเว็บแอปบนเดสก์ท็อปแทน
การสำรองข้อมูล การอัปเกรด และการล็อกเวอร์ชัน image
มีสองพาธที่ไม่สามารถสร้างใหม่ได้คือ /etc/ntfy/server.yml และ /var/lib/ntfy/user.db ไฟล์ที่สองเก็บข้อมูลผู้ใช้ทั้งหมด, รหัสผ่านที่แฮชไว้, รายการ ACL และโทเค็น ดังนั้นควรจัดการเหมือนกับ private key
sudo tar czf ntfy-backup.tgz -C / etc/ntfy var/lib/ntfy
sudo chmod 600 ntfy-backup.tgzคัดลอกไฟล์นั้นออกจากเซิร์ฟเวอร์ cache.db เก็บข้อความล่าสุดไว้ 12 ชั่วโมงด้วย cache-duration ด้านบน รวมถึงข้อความใดๆ ที่กำหนดเวลาส่งไว้ในอนาคต ซึ่งจะถูกเก็บไว้จนกว่าจะครบ 12 ชั่วโมงหลังจากส่งข้อความแล้ว เว้นแต่คุณจะกำหนดเวลาส่งข้อความไว้ล่วงหน้า การสูญเสียไฟล์นี้ไม่มีผลกระทบใดๆ ที่ต้องกังวล การอัปเกรดหมายถึงการแก้ไขแท็กในไฟล์ compose, การดึง image ใหม่ และการสร้างคอนเทนเนอร์ขึ้นมาใหม่
sudo docker compose pull
sudo docker compose up -d
curl -s https://ntfy.example.com/v1/healthอ่านบันทึกการเปลี่ยนแปลง (release notes) ก่อนเสมอ ฐานข้อมูล SQLite จะทำการย้ายข้อมูล (migrate) เมื่อเริ่มทำงาน ดังนั้นการถอยกลับไปยังแท็กเก่าหลังจากมีการเปลี่ยนแปลงโครงสร้างฐานข้อมูลจึงไม่ปลอดภัย ตัวอย่างเช่น v2.31.1 ย้ายแคชข้อความไปยังเวอร์ชันโครงสร้าง 17 และบันทึกการอัปเกรดระบุว่าการดาวน์เกรดไปยัง v2.31.0 หรือเก่ากว่านั้นจำเป็นต้องตั้งค่าเวอร์ชันกลับเป็น 16 ด้วยตนเอง การอัปเกรดเป็น v2.36.0 จะรีเซ็ตยอดการใช้งานรายวันของผู้ใช้ทุกคนหนึ่งครั้ง ควรเก็บข้อมูลสำรองที่คุณเพิ่งทำไว้จนกว่าเวอร์ชันใหม่จะทำงานได้ครบหนึ่งวัน บันทึกดังกล่าวยังระบุถึงการเปลี่ยนแปลงพฤติกรรมด้วย ตั้งแต่ v2.31.0 เป็นต้นไป ไคลเอนต์ที่เชื่อมต่อใหม่ด้วย since=<message ID> จะได้รับข้อความที่เผยแพร่ในวินาทีเดียวกันด้วย ซึ่งอาจทำให้เห็นข้อความซ้ำ แอป ntfy และเว็บแอปจะลบข้อความซ้ำตาม ID ข้อความ แต่สคริปต์ของคุณเองที่เล่นหัวข้อซ้ำจะต้องทำเช่นเดียวกัน ทุกบริการบนเครื่องมีรายการพาธสั้นๆ ของตัวเองที่ไม่สามารถสร้างใหม่ได้ และ การเปรียบเทียบ PhotoPrism และ Immich ได้สรุปรายการนั้น รวมถึงคำสั่งสำรองข้อมูลที่เกี่ยวข้อง สำหรับคลังรูปภาพบน VPS ประเภทเดียวกัน
Gotify และ Apprise
Gotify เป็นตัวเลือกที่มีขนาดเล็กกว่า โดยเป็น binary ไฟล์เดียวที่มี web UI และแอปบน Android ข้อความจะถูกจัดกลุ่มตามแอปพลิเคชัน ซึ่งเหมาะสำหรับเซิร์ฟเวอร์ส่วนตัวที่ใช้ Android เป็นปลายทางเพียงอย่างเดียว ส่วน Apprise เป็นไลบรารีภาษา Python และเครื่องมือบรรทัดคำสั่ง โดยมี Apprise API server แยกต่างหากให้ใช้งาน ซึ่งสามารถกระจายข้อความเดียวไปยังบริการต่างๆ ได้มากกว่าหนึ่งร้อยรายการ รวมถึง ntfy จึงเหมาะสำหรับสคริปต์ที่ต้องการส่งการแจ้งเตือนไปยังหลายช่องทางพร้อมกัน สำหรับ ntfy นั้นเป็นบริการที่มอบทั้งเซิร์ฟเวอร์, HTTP API และแอปบนแพลตฟอร์มมือถือทั้งสองระบบ ซึ่งเป็นเหตุผลว่าทำไม ntfy จึงเป็นคำตอบมาตรฐานสำหรับการตั้งค่าการแจ้งเตือนจากเซิร์ฟเวอร์ที่เช่าใช้งาน
FAQ
ทำไมการส่งข้อความไปยังเซิร์ฟเวอร์ ntfy ของฉันจึงได้รับข้อผิดพลาด 403?
เมื่อตั้งค่า auth-default-access: "deny-all" ไว้ใน server.yml ระบบจะปฏิเสธการส่งข้อความแบบไม่ระบุตัวตน ซึ่งเป็นพฤติกรรมที่ตั้งใจไว้ คุณต้องส่งข้อมูลรับรองผ่าน -u user:pass หรือ -H "Authorization: Bearer tk_..." หากคุณส่ง token อยู่แล้วแต่ยังได้รับ 403 ให้ตรวจสอบว่าผู้ใช้รายนั้นมีรายการ ACL ที่อนุญาตให้เขียนข้อมูลลงในหัวข้อ (topic) นั้นหรือไม่ หากไม่มีรายการที่ตรงกัน read-only หรือ deny จะปฏิเสธการส่งข้อความ ในเวอร์ชัน v2.34.0 คำขอที่เข้ามาพร้อมกันจาก IP เดียวกันอาจทำให้ข้อมูลรับรองที่ถูกต้องถูกปฏิบัติเสมือนเป็นผู้ใช้ไม่ระบุตัวตน ซึ่ง v2.35.0 ได้แก้ไขบั๊กนี้แล้ว ดังนั้นควรอัปเกรดก่อนที่จะสรุปว่า 403 ที่เกิดขึ้นเป็นครั้งคราวเป็นปัญหาจาก ACL ให้รันคำสั่ง ntfy access เพื่อแสดงรายการทั้งหมด โปรดจำไว้ว่าสิทธิ์ write ไม่อนุญาตให้สมัครรับข้อมูล (subscribe) ดังนั้นบัญชีที่ส่งข้อความได้ปกติจะยังคงถูกปฏิเสธเมื่อพยายามอ่านหัวข้อเดียวกัน
การแจ้งเตือนบน iPhone ทำงานร่วมกับเซิร์ฟเวอร์ ntfy ที่โฮสต์เองได้หรือไม่?
การแจ้งเตือนจะทำงานผ่าน relay เมื่อคุณใช้แอป iOS อย่างเป็นทางการ การปลุกแอปที่ถูกระงับการทำงานบน iPhone ให้ตื่นขึ้นอย่างรวดเร็วจำเป็นต้องผ่าน APNs (Apple push notification service) และการส่งข้อมูลไปยังแอปอย่างเป็นทางการต้องใช้ข้อมูลรับรองของผู้เผยแพร่แอปนั้น ntfy จึงส่งต่อ poll_request ที่มี ID ของข้อความไปยัง ntfy.sh เพื่อให้ relay ส่งต่อไปยังอุปกรณ์ ให้ตั้งค่า upstream-base-url: "https://ntfy.sh" ใน server.yml แล้วรีสตาร์ทคอนเทนเนอร์ เนื้อหาของข้อความจะถูกดึงมาจากเซิร์ฟเวอร์ของคุณโดยตรง หากไม่มีการตั้งค่านี้ การแจ้งเตือนบน iOS จะยังคงมาถึงในที่สุด แต่เอกสารของ ntfy เตือนว่าอาจมีความล่าช้าได้นานหลายชั่วโมง นอกจากนี้ PWA ยังเป็นอีกทางเลือกหนึ่งบน iOS 16.4 ขึ้นไป เมื่อมีการตั้งค่า Web Push บนเซิร์ฟเวอร์ของคุณ
ทำไมการแจ้งเตือน ntfy จาก cron job ของฉันจึงไม่เคยมาถึง?
ให้รันคำสั่ง curl ด้วยตัวเองก่อนเพื่อพิสูจน์ว่า token และหัวข้อถูกต้อง หากรันด้วยมือแล้วทำงานได้แต่รันจาก cron ไม่ได้ แสดงว่าความล้มเหลวเกิดขึ้นก่อนการแจ้งเตือน: cron รันงานด้วยสภาพแวดล้อมที่จำกัดและมี PATH ที่สั้น ดังนั้นสคริปต์ที่เรียกคำสั่งด้วยชื่อสั้นๆ อาจหยุดทำงานก่อนที่จะถึงบรรทัด curl ให้ใช้ path แบบเต็ม (absolute path) เปลี่ยนเส้นทางเอาต์พุตของงานไปยังไฟล์ log และอ่านไฟล์นั้นหลังจากการรันครั้งถัดไป การตอบกลับแบบ 429 แทนที่จะเป็นการส่งข้อความสำเร็จ หมายความว่ามีข้อจำกัดที่ปฏิเสธคำขอนั้น โดยปกติแล้วสคริปต์อาจพยายามส่งซ้ำเร็วเกินไป แต่ผู้ใช้ที่ใช้โควตาประจำวันจนหมด เช่น ขีดจำกัดข้อความที่ตั้งไว้ข้างต้น ก็จะถูกปฏิเสธในลักษณะเดียวกันแม้จะเป็นการส่งเพียงคำขอเดียวก็ตาม
ฉันควรเปิดเผย ntfy บนอินเทอร์เน็ตสาธารณะหรือไม่?
แอปบนโทรศัพท์จำเป็นต้องเข้าถึงเซิร์ฟเวอร์จากเครือข่ายมือถือ ดังนั้นการมี HTTPS endpoint สาธารณะที่ใช้ auth-default-access: "deny-all" และการตั้งค่า ACL แยกตามหัวข้อจึงเป็นการตั้งค่ามาตรฐาน ซึ่งมีความปลอดภัยตราบใดที่ไม่มีหัวข้อใดที่อ่านได้โดย everyone การใช้งานผ่าน VPN เท่านั้นเป็นสิ่งที่สมเหตุสมผลหากผู้รับทุกคนเป็นเครื่องที่คุณควบคุม แต่ไม่เหมาะกับโทรศัพท์มือถือเนื่องจากแอปจะได้รับข้อความเฉพาะในขณะที่ tunnel เชื่อมต่ออยู่เท่านั้น ทำให้การแจ้งเตือนถูกค้างไว้จนกว่าโทรศัพท์จะเชื่อมต่อกลับมาอีกครั้ง