# Alerte pe iPhone când îți cade site-ul

> O notificare când site-ul sau magazinul tău cade și una când revine, cu un mic script de verificare și cron sau cu webhookul din Uptime Kuma.

Source: https://honk-me.app/ro/ghiduri/alerte-site-cazut

Vrei să afli că site-ul a căzut înainte să-ți spună un client. Pentru asta îți trebuie două lucruri: ceva care verifică site-ul la câteva minute și ceva care te anunță pe telefon o singură dată, nu din cinci în cinci minute până repari problema.

Honk se ocupă de a doua parte. Nu îți verifică singur site-ul, așa că ghidul îl combină cu ceva care face verificarea: un mic script pe orice mașină care stă mereu pornită sau Uptime Kuma, dacă îl folosești deja.

## Înainte să începi

- Un cont Honk. Deocamdată, Honk e disponibil doar pe bază de invitație: [cere acces](https://honk-me.app/ro/cere-acces).
- Un proiect pentru site-urile tale, cu o cheie API: în aplicația web, deschide proiectul, apoi **Chei**.
- O mașină care stă mereu pornită și care **nu** e serverul pe care rulează site-ul: un VPS mic, un Raspberry Pi sau un NAS. O verificare de pe același server cade odată cu el.

## Varianta 1: un script de verificare și cron

Instalează CLI-ul `honk-me` ([cum](https://honk-me.app/ro/integrari/cli#install)) și pune `HONK_URL` și `HONK_KEY` în crontab, ca în [ghidul pentru cron](https://honk-me.app/ro/ghiduri/notificari-push-cron). Apoi salvează scriptul de mai jos ca `/usr/local/bin/check-site` și fă-l executabil:

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

Scriptul consideră site-ul căzut dacă nu răspunde cu succes în 10 secunde, după două reîncercări, sau dacă în pagină lipsește un text ales de tine. A doua verificare prinde situația în care site-ul se încarcă, dar afișează o pagină de eroare: alege un text care apare doar când pagina chiar funcționează, de exemplu butonul „Adaugă în coș” din magazinul tău.

Rulează-l la fiecare cinci minute, cu câte o linie pentru fiecare site:

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

Ce se întâmplă când cade magazinul:

- Prima verificare eșuată trimite un **Claxon continuu** cu eroarea și cu titlul „shop.example.com is down” (scriptul trimite titlurile în engleză).
- Cât timp site-ul e căzut, fiecare verificare trimite din nou aceeași problemă. Honk le adună într-un grup și trimite cel mult o actualizare discretă la 5 minute, cu un contor.
- Prima verificare reușită raportează o **revenire**, cu titlul „shop.example.com is back”. Incidentul se închide, iar dacă era afișat într-o activitate live, aceasta trece pe „Revenit”.

## Varianta 2: Uptime Kuma

[Uptime Kuma](https://github.com/louislam/uptime-kuma) e un monitor gratuit, pe care îl găzduiești singur. Notificarea lui prin webhook poate trimite direct JSON-ul de care are nevoie Honk, pentru că poți scrie singur corpul cererii, ca șablon.

În Uptime Kuma, deschide **Settings ▸ Notifications ▸ Setup Notification** și alege **Webhook**:

- **Post URL**: `https://honk-me.app/v1/messages`
- **Request Body**: Custom Body, cu acest șablon:

```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 trimite notificarea când un monitor își schimbă starea, deci primești o problemă când un site cade și o revenire când își revine. Fiecare monitor are grupul lui. Șabloanele pentru Custom Body cer o versiune recentă de Uptime Kuma, iar butonul **Test** trimite un eveniment de probă, pe care îl poți șterge apoi din inbox.

## Servicii de monitorizare găzduite

Multe servicii de monitorizare găzduite pot apela un webhook, dar trimit datele în formatul lor. Îndreaptă webhookul spre n8n, Make sau Zapier și trimite-i lui Honk un `problem` când verificarea eșuează și un `recovery` când trece, cu același `group_key` pentru amândouă. Modulul HTTP din Make apare în [ghidul pentru formulare](https://honk-me.app/ro/ghiduri/formulare-pe-telefon).

## Când trebuie să te trezească

Orele de liniște rețin notificările noaptea. Dacă un magazin căzut trebuie să te trezească, trimite problema cu `--priority urgent` și permite mesajele urgente atât pe cheia API a proiectului, cât și în orele tale de liniște. Păstrează asta pentru unul sau două site-uri care contează cu adevărat.