# Alertas en el iPhone cuando tu web se cae

> Recibe un aviso cuando tu web o tu tienda se caen y otro cuando vuelven, con un pequeño script de comprobación y cron, o con el webhook de Uptime Kuma.

Source: https://honk-me.app/es/guias/alertas-web-caida

Si tu web se cae, quieres saberlo antes de que te lo diga un cliente. Para eso hacen falta dos piezas: algo que compruebe la web cada pocos minutos y algo que avise a tu teléfono una sola vez, sin insistir cada cinco minutos hasta que lo arregles.

Honk es la segunda. No visita tu web por su cuenta, así que esta guía lo combina con algo que la compruebe: un pequeño script en cualquier máquina siempre encendida, o Uptime Kuma si ya lo usas.

## Antes de empezar

- Una cuenta de Honk. Por ahora, Honk funciona solo con invitación: [solicita acceso](https://honk-me.app/es/solicitar-acceso).
- Un proyecto para tus webs, con una clave de ingesta: en la app web, abre el proyecto y entra en **Claves**.
- Una máquina siempre encendida que **no** sea el servidor que aloja la web: un VPS pequeño, una Raspberry Pi, un NAS. Si la comprobación se ejecuta en el mismo servidor, se cae con él.

## Opción 1: un script de comprobación y cron

Instala la CLI `honk-me` ([cómo](https://honk-me.app/es/integraciones/cli#install)) y pon `HONK_URL` y `HONK_KEY` en el crontab, como en la [guía de cron](https://honk-me.app/es/guias/notificaciones-push-cron). Después guarda este script como `/usr/local/bin/check-site` y hazlo ejecutable:

```sh
#!/usr/bin/env bash
# check-site <url> [text]: a Blast when the site is down, one recovery when it's back.
# Down means: no 2xx answer within 10 s (after 2 retries), or the page lacks the text.
set -uo pipefail
url=$1 text=${2:-}
host=$(printf '%s' "$url" | sed -E 's#^https?://##; s#/.*$##')
key="site/$host"
state="${XDG_STATE_HOME:-$HOME/.local/state}/check-site/$host.down"
mkdir -p "$(dirname "$state")"

if body=$(curl -fsS --max-time 10 --retry 2 --retry-delay 5 "$url" 2>&1) &&
  { [ -z "$text" ] || grep -qF -- "$text" <<<"$body"; }; then
  if [ -e "$state" ]; then
    honk-me recovery --group-key "$key" --source "$(hostname)" --category infrastructure \
      --title "$host is back" --message "$url answers again." || true
    rm -f "$state"
  fi
else
  # sent on every failed check while it's down: Honk folds them into calm updates
  honk-me problem --group-key "$key" --source "$(hostname)" --category infrastructure \
    --severity blast --title "$host is down" --message "$url
${body:0:600}" || true
  touch "$state"
fi
```

El script da la web por caída si no responde correctamente en 10 segundos, tras dos reintentos, o si en la página falta un texto que eliges tú. Esa segunda comprobación detecta el caso de «la web carga, pero muestra una página de error»: elige un texto que solo aparezca cuando la página funciona de verdad, como el «Añadir al carrito» de tu tienda.

Ejecútalo cada cinco minutos, con una línea por web:

```sh
*/5 * * * * /usr/local/bin/check-site https://shop.example.com/ "Add to cart"
*/5 * * * * /usr/local/bin/check-site https://www.example.com/
```

Qué pasa cuando la tienda se cae:

- La primera comprobación fallida envía una **Bocina sin parar** con el error y el título «shop.example.com is down».
- Mientras sigue caída, cada comprobación vuelve a enviar el mismo problema. Honk los reúne en un grupo y envía como mucho una actualización discreta cada 5 minutos, con un recuento.
- La primera comprobación correcta envía una **recuperación** con el título «shop.example.com is back». El incidente se cierra y, si una Actividad en directo lo estaba mostrando, pasa a «Recuperado».

## Opción 2: Uptime Kuma

[Uptime Kuma](https://github.com/louislam/uptime-kuma) es una herramienta de monitorización gratuita y autoalojada. Sus notificaciones por webhook pueden enviar directamente el JSON de Honk, porque el cuerpo personalizado admite plantillas.

En Uptime Kuma, abre **Settings ▸ Notifications ▸ Setup Notification** y elige **Webhook**:

- **Post URL**: `https://honk-me.app/v1/messages`
- **Request Body**: Custom Body, con esta plantilla:

```json
{
  "title": {% if heartbeatJSON.status == 1 %}{{ name | append: " is back" | json }}{% else %}{{ name | append: " is down" | json }}{% endif %},
  "message": {{ msg | json }},
  "severity": "{% if heartbeatJSON.status == 1 %}beep{% else %}blast{% endif %}",
  "event_type": "{% if heartbeatJSON.status == 1 %}recovery{% else %}problem{% endif %}",
  "group_key": "uptime/{{ monitorJSON.id }}",
  "source": "uptime-kuma",
  "category": "infrastructure"
}
```

- **Additional Headers**:

```json
{ "Authorization": "Bearer honk_…" }
```

Uptime Kuma avisa cuando un monitor cambia de estado, así que recibes un problema cuando una web se cae y una recuperación cuando vuelve. Cada monitor tiene su propio grupo. La plantilla del cuerpo personalizado necesita una versión reciente de Uptime Kuma; el botón **Test** envía un evento de ejemplo que luego puedes borrar de la bandeja de entrada.

## Servicios de monitorización en la nube

Muchos servicios de monitorización en la nube pueden llamar a un webhook, pero con su propio formato. Apunta el webhook a n8n, Make o Zapier y, desde ahí, envía a Honk un `problem` cuando la comprobación falle y un `recovery` cuando vuelva a pasar, con el mismo `group_key` en los dos. La [guía de formularios](https://honk-me.app/es/guias/formularios-al-movil) muestra el módulo HTTP de Make.

## Si quieres que te despierte

Por la noche, las horas de silencio retienen las notificaciones. Si la caída de tu tienda debe despertarte, envía el problema con `--priority urgent`, permite los eventos urgentes en la clave de ingesta de ese proyecto y déjalos pasar en tus horas de silencio. Reserva ese permiso para tus webs más importantes, una o dos como mucho.