# Lo sai nel momento esatto quando un server va giù.

> Ricevi notifiche push istantanee quando i tuoi server vanno giù. Collega Grafana, Prometheus o UptimeRobot via webhook e ricevi gli avvisi sul telefono in meno di un secondo.

<!-- source: https://pocketalert.app/it/use-cases/server-monitoring -->

Ultimo aggiornamento: 2026-08-11

Pocket Alert trasforma gli alert di monitoraggio dei server in notifiche push su iPhone o Android. Collega Grafana, Prometheus, UptimeRobot o un semplice health check da cron a un solo URL webhook: gli alert arrivano al telefono in meno di un secondo, senza agent sul server e senza riepiloghi email da scorrere.

## Tre passaggi per il tuo primo alert server

1. **Configura Pocket Alert** — Installa la CLI pocketalert ed esegui pocketalert auth YOUR_API_KEY, oppure crea un webhook per l'inoltro.
2. **Collega il monitoraggio** — Aggiungi un health check da cron, un custom_sender di Netdata o un webhook_config di Alertmanager che punti all'URL di ricezione.
3. **Ricevi il tuo primo alert** — Lancia un alert di prova e il telefono vibra poco dopo. Mappa i campi per mettere a punto il contenuto.

## Dal picco di metrica al tuo telefono

Punta il tuo monitoraggio a un solo URL webhook e ogni alert arriva al telefono in meno di un secondo.

- **Funziona con il tuo stack** — Grafana, Prometheus, UptimeRobot, Datadog e Zabbix raggiungono il telefono appena inviano un webhook.
- **Consegna sotto il secondo** — La push arriva in meno di un secondo, prima della prima segnalazione di un utente.
- **Mappatura dei campi (GJSON)** — Mappa i campi del payload JSON su titolo e messaggio. Nome e gravità dell'alert arrivano fino alla notifica.
- **Script o webhook** — Un health check da cron o un alert Alertmanager inoltrato arrivano al telefono nello stesso modo.
- **Canali per applicazione** — Dai a prod, staging e homelab i rispettivi canali.
- **Nessun agent richiesto** — Pocket Alert usa i webhook che il tuo monitoraggio già produce, quindi il server monitorato non esegue nulla in più.

## Configura il monitoraggio

### 1. Un health check bash su cron

Installa la CLI, autenticati una volta, poi fai un ping al servizio e invia una push se non risponde.

```
sudo mv pocketalert /usr/local/bin/ && chmod +x /usr/local/bin/pocketalert
pocketalert auth YOUR_API_KEY
```

```
#!/usr/bin/env bash
URL=https://api.example.com/health
if ! curl -fsS --max-time 10 "$URL" >/dev/null; then
  pocketalert send -t "API DOWN on $(hostname)" -m "$URL did not respond"
fi
```

Eseguilo ogni minuto da cron.

```
* * * * * /usr/local/bin/check-health.sh
```

### 2. Oppure un hook di allarme Netdata

Aggiungi una `custom_sender()` a `health_alarm_notify.conf` (modificalo con `sudo ./edit-config health_alarm_notify.conf`) in modo che ogni allarme Netdata invii una richiesta all'API dei messaggi.

```
custom_sender() {
  curl -X POST 'https://api.pocketalert.app/v1/messages' \
    -H 'Token: YOUR_API_KEY' \
    -H 'Content-Type: application/json' \
    -d "{\"title\":\"${name} is ${status} on ${host}\",\"message\":\"${chart}.${family}: ${value_string}\",\"level\":\"critical\"}"
}
```

### 3. Oppure inoltra Alertmanager tramite webhook

Crea un webhook nella pagina [Webhooks](https://pocketalert.app/it/webhooks) con un template GJSON, poi aggiungi l'URL di ricezione a un `webhook_config` di Prometheus Alertmanager.

```
curl -X POST 'https://api.pocketalert.app/v1/webhooks' \
  -H 'Token: YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"name":"Alertmanager","application_id":"qm47b9pzxzxg","message":"%status%: %alerts.0.labels.alertname% — %alerts.0.annotations.summary%"}'
```

```
receivers:
  - name: pocketalert
    webhook_configs:
      - url: 'https://p4a.me/wh/1234abcd'
        send_resolved: true
```

La [documentazione](https://info.pocketalert.app/api/webhooks/settings.html) elenca i percorsi GJSON.

## FAQ

### Come funzionano gli alert di monitoraggio dei server?

Pocket Alert assegna a ogni applicazione un URL webhook in ingresso. Punta a quell'URL uno strumento di monitoraggio come Grafana, Prometheus Alertmanager, UptimeRobot, Datadog o Zabbix, e gli alert che genera diventano notifiche push sul tuo telefono entro un secondo.

### Posso personalizzare il contenuto dell'alert?

Sì. Mappa i campi del JSON in arrivo con i percorsi GJSON per impostare titolo e messaggio della notifica. Un alert di Alertmanager mantiene nome, stato e gravità fino alla fine.

### Quali strumenti di monitoraggio sono supportati?

Funziona con qualsiasi strumento che invii una richiesta HTTP quando scatta un alert: Grafana, Prometheus Alertmanager, UptimeRobot, Datadog, Zabbix, Netdata, Uptime Kuma e script di health check personalizzati.

### Come evito l'affaticamento da alert?

Invia una push quando un server cade e un'altra quando torna su. I canali per applicazione separano prod, staging e infrastruttura personale, così gli alert urgenti non si perdono in un flusso rumoroso.

### Devo installare un agent sui miei server?

Non c'è nessun agent da installare. Pocket Alert riceve i webhook che il tuo sistema di monitoraggio già invia, quindi sul server monitorato non gira nulla in più.

### Un alert di server down può superare Non disturbare di notte?

Sì. Invia l'alert con level: critical e supera Non disturbare su Android, mentre su iPhone attraversa Full immersion come notifica time-sensitive. Mantieni i messaggi di ripristino su default, oppure su silent, così solo l'interruzione vera e propria fa rumore. I livelli vanno da silent (-2) a critical (2) e funzionano nell'API, nei payload dei webhook e come impostazione predefinita per ogni webhook.
