# Notifiche push per avvisi Kubernetes sul tuo telefono.

> Ricevi gli alert di Kubernetes sul telefono. Punta un webhook_config di Alertmanager su Pocket Alert e CrashLoopBackOff o OOMKilled arrivano come notifica push in meno di un secondo.

<!-- source: https://pocketalert.app/it/use-cases/kubernetes-alerts -->

Ultimo aggiornamento: 2026-08-11

Un pod in CrashLoopBackOff, un container OOMKilled, un rollout fallito o un nodo NotReady diventano una notifica push sul tuo telefono, con namespace e nome del pod ben visibili sullo schermo. Intercetta i problemi del cluster senza vivere dentro kubectl.

## Tre passaggi da Alertmanager al telefono

1. **Ottieni un URL di ricezione** — Crea un webhook di Pocket Alert con un template di messaggio GJSON e copia il suo URL di ricezione.
2. **Configura Alertmanager** — Aggiungi un receiver webhook_configs in Alertmanager e indirizza verso di esso gli avvisi critici.
3. **Mettilo in funzione** — Il prossimo avviso in corso arriva sul tuo telefono in meno di un secondo. Affina il template GJSON man mano che perfezioni le route.

## Dall'avviso in corso al telefono

Mantieni l'Alertmanager che già usi. Pocket Alert trasforma il suo output webhook in una notifica push sul tuo telefono.

- **webhook_config nativo** — Alertmanager ha un receiver webhook_config nativo. Punta il tuo URL dell'applicazione e sei a posto.
- **Mapping dei campi GJSON** — GJSON estrae alertname, namespace, pod e severity dal JSON in un titolo e un messaggio leggibili.
- **Stato e gravità in linea** — Mostra stato e gravità direttamente nel messaggio, così un avviso critico in corso appare diverso da un avviso di risoluzione.
- **Eventi di pod e nodi** — Intercetta CrashLoopBackOff, OOMKilled, rollout falliti, nodi NotReady ed eventi di PVC pieno.
- **Canali per cluster** — Applicazioni separate danno a prod e staging canali propri, ciascuno con il proprio URL webhook.
- **Consegna sotto il secondo** — Le notifiche arrivano in meno di un secondo appena Alertmanager scatta. Nessun agent aggiuntivo nel cluster.

## Invia gli avvisi Kubernetes al tuo telefono

### 1. Crea un webhook di Pocket Alert

Nella pagina [Webhooks](https://pocketalert.app/it/webhooks) crea un webhook il cui template `message` GJSON legge il payload di Alertmanager (`status` e `commonLabels` di primo livello, più un array `alerts`):

```
curl -X POST "https://api.pocketalert.app/v1/webhooks" \
  -H "Token: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name":"K8s Alertmanager","message":"[%status%] %commonLabels.alertname% (%commonLabels.severity%)\n%alerts.0.labels.namespace%/%alerts.0.labels.pod%\n%alerts.0.annotations.summary%","application_id":"qm47b9pzxzxg"}'
```

Ottieni un URL in ingresso come `https://p4a.me/wh/1234abcd`. Usa un webhook per cluster per tenere separati prod e staging.

### 2. Punta Alertmanager al webhook

Aggiungi un receiver `webhook_configs` e indirizza gli avvisi critici verso di esso ([documentazione di Alertmanager](https://prometheus.io/docs/alerting/latest/configuration/#webhook_config)):

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

route:
  receiver: 'pocketalert'
  group_by: ['alertname', 'namespace']
```

Alertmanager invia il suo JSON standard tramite POST; i percorsi GJSON sopra estraggono status, alertname, severity, namespace e pod nella notifica push. Quando l'avviso rientra, `status` passa a `resolved`.

### 3. Oppure invia un POST da un controller / kubectl

Un controller o uno script una tantum può chiamare direttamente l'API dei messaggi con un header Token:

```
curl -X POST "https://api.pocketalert.app/v1/messages" \
  -H "Token: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title":"CrashLoopBackOff","level":"critical","message":"api-7c9 in prod, 12 restarts","application_id":"qm47b9pzxzxg"}'
```

La [documentazione delle impostazioni webhook](https://info.pocketalert.app/api/webhooks/settings.html) descrive tutti i percorsi GJSON e le opzioni del webhook.

## FAQ

### Come invio gli avvisi Kubernetes a Pocket Alert?

Aggiungi un receiver webhook_configs in Alertmanager che punti al tuo URL di ricezione di Pocket Alert, https://p4a.me/wh/1234abcd. Un avviso CrashLoopBackOff o OOMKilled in corso diventa una notifica push.

### Come legge Pocket Alert il payload di Alertmanager?

Il mapping dei campi GJSON legge il JSON di Alertmanager. Estrai commonLabels.alertname nel titolo e alerts.0.labels.namespace / alerts.0.labels.pod nel corpo, così namespace e pod compaiono sullo schermo invece del payload grezzo.

### Posso distinguere un avviso in corso da uno risolto?

Il payload contiene status (firing o resolved) e commonLabels.severity. Usali entrambi nel tuo template di messaggio GJSON, così un avviso critico in corso appare diverso da un avviso di risoluzione.

### Come separo i cluster di prod e staging?

Assegna ad prod e staging le proprie applicazioni Pocket Alert, ciascuna con il proprio URL webhook. Collega una route di Alertmanager a ciascuna, così un nodo NotReady in staging non verrà mai confuso con quello di prod.

### Serve un agent in esecuzione nel cluster?

No. Hai già Alertmanager in esecuzione. Pocket Alert non richiede nulla di aggiuntivo all'interno del cluster. Anche un controller o uno script può inviare direttamente una richiesta POST a https://api.pocketalert.app/v1/messages con un header Token.

### Posso associare la gravità dell'avviso alla priorità della notifica?

Sì. Ogni messaggio accetta un livello: silent, low, default, high o critical. Includi un campo "level" nel payload del webhook oppure imposta default_level sul webhook stesso; un livello esplicito nel payload ha sempre la precedenza. Una suddivisione comune è firing=critical e resolved=silent: l'avviso in corso supera la modalità Non disturbare su Android e arriva con priorità temporale su iPhone, mentre il ripristino resta silenzioso nella cronologia. Un valore non valido ricade su default, senza mai essere rifiutato.
