dix/obsidian-dix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
obsidian-dix/DIX-Notes/Otras_varias/Notificaciones con ntfy.sh.md

8.4 KiB
Raw Blame History

Sí, ntfy.sh es un servicio de notificaciones basado en HTTP/S y MQTT que permite enviar y recibir mensajes de manera sencilla a través de una URL. Funciona como un sistema de mensajería tipo "push" y es ideal para recibir alertas en tu teléfono, navegador o scripts sin necesidad de una configuración compleja.

¿Cómo funciona?

  1. Publicación de mensajes: Puedes enviar notificaciones con una simple solicitud HTTP POST o usando curl.

    curl -d "Hola, esto es una prueba" ntfy.sh/mi-tema

    Esto enviará el mensaje al tema mi-tema.

  2. Suscripción a notificaciones:

    • Puedes recibir mensajes en la app móvil de ntfy.sh (Android).

    • Puedes suscribirte desde el navegador.

    • Puedes recibir notificaciones en línea de comandos con curl o ntfy subscribe.

  3. Uso avanzado:

    • Permite autenticación con usuarios/contraseñas si usas una instancia propia o la versión premium del servicio.

    • Soporta JSON para notificaciones más estructuradas.

    • Se puede configurar para enviar imágenes, enlaces y más.

Ejemplo con Python

Si quieres enviar una notificación desde Python:

import requests

url = "https://ntfy.sh/mi-tema"
data = "¡Notificación desde Python!"
requests.post(url, data=data.encode('utf-8'))

¿Tienes algo en mente para usarlo?

Exactamente, actualmente estás usando la instancia pública de ntfy.sh, pero puedes hostear tu propio servidor si quieres más privacidad o independencia.

Cómo hostear ntfy en tu propio servidor

Hay varias formas de hacerlo, dependiendo de cómo prefieras instalarlo. Aquí te dejo algunas opciones:

Instalación manual de Ntfy.sh en Linux (Ubuntu/Debian/Raspberry Pi)

Si prefieres instalar ntfy.sh directamente en tu sistema sin Docker, sigue estos pasos.

📌 Paso 1: Detectar la arquitectura y descargar el binario adecuado

Ejecuta el siguiente script para determinar tu arquitectura y descargar la versión correcta de ntfy:

ARCH=$(uname -m)

if [[ $ARCH == "x86_64" ]]; then
    URL="https://github.com/binwiederhier/ntfy/releases/latest/download/ntfy_2.11.0_linux_amd64.tar.gz"
elif [[ $ARCH == "aarch64" ]]; then
    URL="https://github.com/binwiederhier/ntfy/releases/latest/download/ntfy_2.11.0_linux_arm64.tar.gz"
elif [[ $ARCH == "armv7l" ]]; then
    URL="https://github.com/binwiederhier/ntfy/releases/latest/download/ntfy_2.11.0_linux_armv7.tar.gz"
else
    echo "❌ Arquitectura no soportada"
    exit 1
fi

wget "$URL" -O ntfy.tar.gz
tar -xzf ntfy.tar.gz
#sudo mv ntfy /usr/local/bin/

sudo chmod +x /usr/local/bin/ntfy

# mejor usa esta linea para descargar la versión:
wget https://github.com/binwiederhier/ntfy/releases/latest/download/ntfy_2.11.0_linux_arm64.tar.gz -O ntfy.tar.gz
tar -xzf ntfy.tar.gz
# va el archivo que sale de descomprimir el ntfy.tar.gz, en este caso es: ntfy_2.11.0_linux_arm64
#sudo mv ntfy_2.11.0_linux_arm64 /usr/local/bin/
sudo mv ntfy_2.11.0_linux_arm64/ntfy /usr/local/bin/

sudo chmod +x /usr/local/bin/ntfy
sudo /usr/local/bin/ntfy serve

📌 Paso 2: Crear un servicio systemd

Crea el archivo de servicio:

sudo nano /etc/systemd/system/ntfy.service

Copia y pega el siguiente contenido:

[Unit]
Description=ntfy server
After=network.target

[Service]
ExecStart=/usr/local/bin/ntfy serve --listen-http :8080
Restart=always
User=www-data
Group=www-data
WorkingDirectory=/usr/local/bin

[Install]
WantedBy=multi-user.target

Guarda (CTRL+X, Y, Enter) y luego ejecuta:


sudo systemctl enable --now ntfy
sudo systemctl daemon-reload
sudo systemctl enable ntfy.service
sudo systemctl start ntfy.service

ntfy serve --listen-http :8080

📌 Paso 3: Verificar que ntfy está corriendo

Para comprobar que el servicio está activo:

sudo systemctl status ntfy

Si ves "active (running)", significa que ntfy está funcionando correctamente.

También puedes probar accediendo en el navegador o con curl:

curl http://localhost:80

Si necesitas cambiar el puerto o configurar autenticación, edita el archivo de configuración en /etc/ntfy/server.yml.

✅ ¡Listo! ntfy.sh está instalado y ejecutándose en tu servidor 🚀.

¡Sí, puedes configurar HTTPS gratuito con HAProxy para tu instancia de ntfy.sh! No es complicado si sigues los pasos correctos. Aquí te explico cómo hacerlo:

Requisitos previos:

  1. Un dominio (puedes usar uno gratuito de DuckDNS o No-IP si no tienes uno).
  2. Acceso a los puertos 80 (HTTP) y 443 (HTTPS) en tu servidor (si estás detrás de un router, asegúrate de redirigirlos).
  3. HAProxy instalado en tu servidor (casi todas las distribuciones Linux lo tienen en sus repositorios).

Pasos para configurar HTTPS con HAProxy y Let's Encrypt:

1. Obtén un certificado SSL gratuito con Certbot:

Usaremos Let's Encrypt para generar el certificado.
Ejecuta estos comandos (en Ubuntu/Debian):

sudo apt update
sudo apt install certbot -y
sudo certbot certonly --standalone -d tudominio.com --email tucorreo@example.com --agree-tos --non-interactive
  • Reemplaza tudominio.com por tu dominio (ej: ntfy.midominio.duckdns.org).
  • El certificado se guardará en /etc/letsencrypt/live/tudominio.com/.

2. Configura HAProxy para usar el certificado:

Edita el archivo de configuración de HAProxy (generalmente /etc/haproxy/haproxy.cfg):

frontend https-in
    bind *:80
    bind *:443 ssl crt /etc/letsencrypt/live/tudominio.com/fullchain.pem
    redirect scheme https code 301 if !{ ssl_fc }
    
    # Redirige el tráfico a ntfy.sh en el puerto 8080
    acl is_ntfy hdr(host) -i tudominio.com
    use_backend ntfy_backend if is_ntfy

backend ntfy_backend
    server ntfy_local 127.0.0.1:8080
  • Explicación:
    • bind *:443 ssl crt: Habilita HTTPS con el certificado de Let's Encrypt.
    • redirect scheme https: Fuerza redirección de HTTP a HTTPS.
    • acl is_ntfy: Detecta si el tráfico es para tu dominio.
    • server ntfy_local: Redirige al servicio ntfy.sh (que corre en 8080).

3. Reinicia HAProxy:

sudo systemctl restart haproxy

4. Renueva automáticamente el certificado:

Let's Encrypt expira cada 90 días, pero puedes automatizar la renovación con un script y un cron job.

Crea un script (/etc/letsencrypt/renewal-hook.sh):

#!/bin/bash
certbot renew --quiet --post-hook "systemctl reload haproxy"

Hazlo ejecutable:

sudo chmod +x /etc/letsencrypt/renewal-hook.sh

Agrega un cron job para renovar:

sudo crontab -e

Añade esta línea (se ejecutará cada lunes a las 3 AM):

0 3 * * 1 /etc/letsencrypt/renewal-hook.sh

5. Prueba tu configuración:

  • Accede a https://tudominio.com en tu navegador.
  • Si todo está bien, el warning de notificaciones desaparecerá y podrás recibir notificaciones push.

Posibles errores y soluciones:

  1. "SSL handshake failed":

    • Verifica que el certificado esté en la ruta correcta (/etc/letsencrypt/live/tudominio.com/fullchain.pem).
    • Asegúrate de que HAProxy tenga permisos para leer el archivo: 
      sudo setfacl -R -m u:haproxy:rx /etc/letsencrypt/live/

  2. "Domain not reachable":

    • Verifica que tu dominio apunte a la IP pública de tu servidor (usa ping tudominio.com para comprobarlo).
    • Si estás en una red local, configura DNS local o usa un dominio dinámico (DuckDNS).

  3. Puertos bloqueados:

    • Asegúrate de que el firewall permita tráfico en los puertos 80 y 443: 
      sudo ufw allow 80/tcp
sudo ufw allow 443/tcp

Conclusión:

Configurar HAProxy con HTTPS gratuito no es complicado si usas Let's Encrypt y sigues estos pasos.

  • Ventajas: Notificaciones push funcionarán, mayor seguridad, y confianza para usuarios.
  • Alternativa rápida: Si no quieres HAProxy, usa Caddy (configura HTTPS automáticamente con 2 líneas).

¿Necesitas ayuda con algún paso en concreto? ¡Déjame saber!