obsidian-dix/Otras_varias/Notificaciones con ntfy.sh.md

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`.
    
    ```bash
    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:

```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`:

```bash
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
```


```bash
# 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:

```bash
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:

```bash

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:

```bash
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`:

```bash
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](https://www.duckdns.org/) o [No-IP](https://www.noip.com/) 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):

```bash
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`):

```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**:
```bash
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`):
```bash
#!/bin/bash
certbot renew --quiet --post-hook "systemctl reload haproxy"
```

Hazlo ejecutable:
```bash
sudo chmod +x /etc/letsencrypt/renewal-hook.sh
```

Agrega un cron job para renovar:
```bash
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:
     ```bash
     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:
     ```bash
     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!