---
title: "Avvisi Google Cloud Monitoring via chiamata con webhook"
description: "Cloud Monitoring invia email, SMS e push, ma non chiama. Porta i criteri di avviso GCP su un webhook di chiamata: configurazione, campi, filtri e trappole."
date: 2026-11-15
author: Nooc
authorAvatarLink: /images/avatars/nooc.webp
authorLink: https://nooc.me
tags:
  - Google Cloud
  - Cloud Monitoring
  - GCP
  - avvisi via chiamata
  - webhook
  - reperibilità
---

# Avvisi Google Cloud Monitoring via chiamata: dal criterio di avviso al telefono che squilla

Google Cloud Monitoring non può chiamare il tuo telefono. I suoi canali di notifica sono email, SMS, l'app mobile Google Cloud, Slack, Google Chat, PagerDuty, Pub/Sub e webhook, e la stessa documentazione di Google avverte che gli SMS non sono del tutto affidabili e potrebbero non essere disponibili nella tua regione. Se vuoi che un criterio di avviso squilli come una telefonata in arrivo, la strada più breve è un canale webhook puntato su un canale di chiamata Echobell, con due righe di template e una condizione.

Questa guida copre il canale, il webhook, i campi che Cloud Monitoring invia davvero nel payload, come far squillare gli incidenti "open" e lasciare in silenzio quelli "closed", e le impostazioni del criterio di avviso che decidono quanto spesso suona il tuo telefono.

## Perché i canali integrati non bastano alle 3 di notte

- **L'email** aspetta che tu la guardi.
- **Gli SMS**, per usare le parole di Google, non sono un tipo di canale del tutto affidabile, e potrebbero non essere offerti nel tuo paese. Inoltre Non disturbare li silenzia come qualsiasi altro messaggio.
- **L'app mobile** invia un normale push. Compare sulla schermata di blocco; non continua a squillare.
- **PagerDuty** può chiamarti, ma è una piattaforma di reperibilità completa, con una sua configurazione e un suo contratto.

Un canale webhook, invece, può raggiungere qualsiasi cosa abbia un endpoint HTTPS pubblico, e Cloud Monitoring gli invia un documento JSON strutturato per ogni incidente. È tutto ciò che serve a Echobell.

## Cosa ti serve

- Un progetto Google Cloud con almeno un criterio di avviso (o un controllo di uptime su cui vuoi ricevere avvisi)
- Il permesso di modificare i canali di notifica (`roles/monitoring.notificationChannelEditor` o Monitoring Editor)
- Echobell installato ([App Store](https://apps.apple.com/app/apple-store/id6743597198?pt=128151925&ct=blog-google-cloud-monitoring-phone-call-alerts-it&mt=8) / [Google Play](https://play.google.com/store/apps/details?id=one.echobell.echobellandroid))
- Dieci minuti

Niente nel tuo progetto deve accettare traffico in entrata. La richiesta in uscita la fa Cloud Monitoring.

## Passo 1 — Crea un canale che squilla

In Echobell crea un canale e imposta il tipo di notifica su **Chiamata**. Un canale di chiamata si comporta come una telefonata in arrivo invece che come un push, quindi occupa lo schermo e squilla. Con Full Immersion o Non disturbare di iOS attivi, squilla solo se le impostazioni di Full Immersion consentono le chiamate.

Apri le **Impostazioni avanzate** del canale e attiva **Modello personalizzato**. Cloud Monitoring racchiude tutto in un oggetto `incident`, quindi i template leggono campi annidati:

```
Titolo: {{incident.state}}: {{incident.policy_name}}
Corpo: {{incident.summary}}
```

Imposta il **template del link** in modo che toccando la notifica si apra l'incidente nella console Google Cloud:

```
{{incident.url}}
```

Aggiungi una **condizione** perché squillino solo gli incidenti appena aperti:

```
incident.state == "open"
```

Copia l'URL del webhook del canale dalla vista di dettaglio:

```
https://hook.echobell.one/t/<channel-token>
```

## Passo 2 — Aggiungi un canale di notifica webhook in Google Cloud

1. Apri **Monitoring → Alerting** e fai clic su **Edit notification channels**
2. In **Webhooks**, fai clic su **Add new**
3. **Endpoint URL**: l'URL del tuo canale Echobell del passo 1
4. **Display name**: `Echobell (call)`
5. Lascia disattivato **Use HTTP Basic Auth**
6. Fai clic su **Test connection**, poi su **Save**

Lascia Basic Auth disattivato di proposito. L'handshake Basic Auth di Google si aspetta che l'endpoint risponda alla prima richiesta con un `401` e un'intestazione `WWW-Authenticate`; Echobell invece si autentica con il token segreto nell'URL, quindi tratta quell'URL come una password.

Se gestisci i canali con Terraform, lo stesso canale è:

```hcl
resource "google_monitoring_notification_channel" "echobell_call" {
  display_name = "Echobell (call)"
  type         = "webhook_tokenauth"

  labels = {
    url = "https://hook.echobell.one/t/<channel-token>"
  }
}
```

Tieni il token fuori dal controllo di versione: leggilo da una variabile o da Secret Manager invece di fare commit dell'URL.

## Passo 3 — Collega il canale ai criteri che meritano una chiamata

Apri un criterio di avviso, vai su **Notifications and name** e aggiungi `Echobell (call)` in **Notification channels**. Un criterio può notificare più canali contemporaneamente, quindi tieni accanto il tuo canale email o Slack.

Qui sii selettivo. È questo il vero filtro: un canale collegato solo a "l'API di produzione è giù" e "il database ha finito lo spazio su disco" squilla abbastanza di rado da farti ancora rispondere. Lascia "CPU sopra il 70% per cinque minuti" all'email.

Due impostazioni nella stessa pagina determinano cosa arriva al tuo telefono:

- **Notify on incident closure.** Se è attivo, Cloud Monitoring invia una notifica anche quando l'incidente si chiude. La condizione `incident.state == "open"` del passo 1 impedisce che quella squilli; il passo 6 mostra come riceverla in silenzio.
- **Incident autoclose duration.** Se la metrica smette di inviare dati, gli incidenti aperti si chiudono dopo questo periodo. Lascia il valore predefinito, a meno che tu non abbia un motivo per cambiarlo.

## Passo 4 — Scopri com'è davvero il payload

Cloud Monitoring invia per impostazione predefinita la versione 1.2 dello schema. Ridotto ai campi che probabilmente userai, un incidente aperto si presenta così:

```json
{
  "version": "1.2",
  "incident": {
    "incident_id": "0.opqiw61fsv7p",
    "scoping_project_id": "my-project",
    "url": "https://console.cloud.google.com/monitoring/alerting/incidents/0.opqiw61fsv7p?project=my-project",
    "state": "open",
    "renotify": false,
    "started_at": 1794713564,
    "ended_at": null,
    "policy_name": "Prod API 5xx rate",
    "condition_name": "5xx ratio above 5%",
    "resource_display_name": "prod-api",
    "threshold_value": "0.05",
    "observed_value": "0.183",
    "severity": "Critical",
    "policy_user_labels": {
      "team": "payments"
    },
    "documentation": {
      "content": "Check the latest deploy first. Runbook: https://wiki.example.com/api-5xx",
      "mime_type": "text/markdown"
    },
    "summary": "5xx ratio for prod-api with metric labels {response_code_class=500} is above the threshold of 0.050 with a value of 0.183."
  }
}
```

Cose da sapere prima di modificare un template:

- **Tutto sta sotto `incident`.** `{{policy_name}}` viene reso vuoto; `{{incident.policy_name}}` no.
- **`state` vale `open` o `closed`.** È su questo unico campo che si basano la condizione e il template del titolo.
- **`summary` è testo generato.** Google non garantisce un formato stabile, quindi mostralo, ma non confrontarlo in una condizione.
- **Alcuni campi possono mancare.** Google segnala che alcuni campi sono assenti o null a seconda del criterio e dello stato dell'incidente. In Echobell un campo mancante viene reso come stringa vuota, quindi il template continua a funzionare; semplicemente non costruire una condizione su un campo che i tuoi criteri non valorizzano.
- **`documentation.content` è tuo.** Quello che scrivi nella casella **Documentation** del criterio arriva qui. Un'istruzione di una riga ("Controlla prima l'ultimo deploy") è più utile su un telefono che squilla del riepilogo generato.
- **La gravità segue il criterio.** È il livello che hai impostato sul criterio. Inviati un incidente di prova e controlla il valore esatto prima di filtrare su di esso.

Un corpo che apre con le tue parole e ripiega sul riepilogo:

```
{{incident.documentation.content}}
{{incident.summary}}
```

## Passo 5 — Decidi cosa squilla, e quanto spesso

Gran parte del filtraggio è già avvenuta quando hai scelto quali criteri ricevono il canale. Al resto pensa la condizione del canale Echobell.

| Obiettivo | Condizione |
| --- | --- |
| Squillare solo quando si apre un incidente | `incident.state == "open"` |
| Squillare una volta, non a ogni promemoria | `incident.state == "open" && !incident.renotify` |
| Squillare solo per i criteri di un team | `incident.state == "open" && incident.policy_user_labels.team == "payments"` |
| Squillare solo di notte (00:00–07:00 UTC) | `incident.state == "open" && hour < 7` |

**Promemoria.** Un criterio può reinviare le notifiche finché un incidente resta aperto: nell'API è `alertStrategy.notificationChannelStrategy[].renotifyInterval`, da 30 minuti a 24 ore. Queste ripetizioni arrivano con `renotify: true`. Se debbano squillare è una scelta: squillare di nuovo è un'escalation rudimentale ma efficace per un incidente che nessuno ha risolto, mentre saltarle evita che un'interruzione lunga squilli tutta la notte. La seconda riga della tabella le salta.

**Etichette utente.** Le etichette utente del criterio, come `team: payments`, viaggiano in `policy_user_labels`. Una condizione su di esse permette a un canale collegato a molti criteri di squillare per alcuni e restare in silenzio per gli altri. Filtrano, non smistano: ogni URL del webhook attiva sempre lo stesso canale Echobell, quindi un'etichetta non può inviare un incidente al canale di un'altra persona.

Le variabili di orario di Echobell sono in UTC, quindi converti prima dal tuo fuso. Il [riferimento delle condizioni](/it/docs/conditions) elenca tutte le variabili.

## Passo 6 — Una porta più silenziosa per le chiusure

Con **Notify on incident closure** attivo, un incidente chiuso è una buona notizia da vedere, non da far squillare. Crea un secondo canale Echobell di tipo **Urgente (Time Sensitive)** (o normale) con gli stessi template e nessuna condizione, aggiungilo in Google Cloud come secondo canale webhook e collega entrambi al criterio. Il template del titolo si legge già come "closed: Prod API 5xx rate".

| Canale Echobell | Condizione | Tipo di canale | Comportamento |
| --- | --- | --- | --- |
| `gcp-call` | `incident.state == "open"` | Chiamata | Squilla come una chiamata in arrivo |
| `gcp-log` | nessuna | Urgente o Normale | Ogni apertura, promemoria e chiusura, senza squillo |

## Provalo prima di fidarti

**Prova prima il lato Echobell.** Invia un payload con la stessa forma di quello di Cloud Monitoring:

```bash
curl -X POST https://hook.echobell.one/t/<channel-token> \
  -H 'Content-Type: application/json' \
  -d '{"version":"1.2","incident":{"state":"open","renotify":false,"policy_name":"Manual test","summary":"Testing the Echobell path","url":"https://console.cloud.google.com/monitoring/alerting"}}'
```

**Poi prova il lato Google.** Il pulsante **Test connection** invia un payload di esempio i cui campi non corrispondono a un incidente reale, quindi potrebbe non soddisfare la tua condizione. Per un test end-to-end, crea un criterio usa e getta con una soglia che superi già — per esempio, utilizzo della CPU della VM sopra l'1% —, collegaci `Echobell (call)`, aspetta che scatti e poi elimina il criterio.

Se il `curl` squilla e il criterio reale no, il problema è sul lato Google — il canale non è collegato, la condizione non è ancora stata soddisfatta per tutta la sua durata, oppure l'URL dell'endpoint è stato copiato male —, non nel canale Echobell.

## Avvisi basati su log e controlli di uptime

- **I controlli di uptime** da soli non avvisano nessuno; alimentano un criterio di avviso. Crea il criterio dal controllo di uptime e collegaci lo stesso canale webhook.
- **I criteri di avviso basati su log** notificano solo quando si apre un incidente — Google non invia per loro una notifica di chiusura — e richiedono un limite di frequenza delle notifiche, che stabilisce quanto spesso una riga di log rumorosa può farti squillare. La condizione `incident.state == "open"` funziona comunque; il canale delle chiusure semplicemente non riceverà mai nulla da questi criteri.

## Limiti che contano durante un incidente

- **Corpo da 1 MiB.** Echobell rifiuta con HTTP 413 i corpi dei trigger oltre 1 MiB. Un incidente di Cloud Monitoring pesa pochi kilobyte.
- **120 richieste al minuto per token.** Oltre, il trigger risponde `429` con `RATE_LIMIT_EXCEEDED` e un `Retry-After`. Un singolo criterio raramente ci si avvicina, ma decine di criteri che scattano insieme durante un'interruzione regionale possono farlo: un motivo in più per tenere corto l'elenco del canale di chiamata.
- **1500 byte di corpo della notifica.** I rendering più lunghi vengono troncati. Tieni breve la documentazione del criterio, oppure mettici il link al runbook invece del runbook intero.

## Cosa non ti dà questa configurazione

- **Nessuna presa in carico.** Rispondere alla chiamata non prende in carico né chiude l'incidente in Google Cloud.
- **Nessuna escalation né rotazione.** Vengono chiamati tutti gli iscritti al canale; nessuno viene chiamato dopo.
- **Nessuna deduplicazione oltre l'incidente.** Una condizione che oscilla apre ogni volta un nuovo incidente, e ognuno squilla. Risolvi sul criterio con una finestra di durata più lunga.

Se per te sono ostacoli insormontabili, ti serve una piattaforma di reperibilità completa. Se ti serve "chiamami quando scatta il criterio di produzione", bastano due schermate della console.

## Risoluzione dei problemi

**L'incidente si è aperto ma non è arrivato nulla.** Apri l'incidente in **Monitoring → Alerting** e verifica che il criterio elenchi il canale webhook. Assicurati che l'URL dell'endpoint sia l'URL Echobell completo, token incluso.

**La notifica è arrivata ma non ha squillato.** Il tipo di canale non è **Chiamata**, oppure le impostazioni di Full Immersion del telefono non lasciano passare le chiamate. Controlla il canale e la configurazione di Full Immersion.

**La notifica è vuota.** Il template legge campi di primo livello. Aggiungi il prefisso `incident.` — `{{incident.policy_name}}`, non `{{policy_name}}`.

**Squilla di nuovo ogni mezz'ora.** Il criterio ha un intervallo di rinotifica. Rimuovilo, oppure aggiungi `!incident.renotify` alla condizione.

**Squilla quando l'incidente si chiude.** Nella condizione manca `incident.state == "open"`, oppure è sul canale sbagliato.

## Domande frequenti

### Google Cloud Monitoring può chiamare un numero di telefono in modo nativo?

No. I canali di notifica sono email, SMS, l'app mobile Google Cloud, Slack, Google Chat, PagerDuty, Pub/Sub e webhook. Una chiamata vocale richiede un servizio esterno: una piattaforma di reperibilità o un webhook di chiamata come Echobell.

### Mi servono Pub/Sub o una Cloud Function?

No. Cloud Monitoring invia da solo l'incidente all'URL del webhook. Pub/Sub è ciò che Google consiglia per gli endpoint non pubblici; l'endpoint di Echobell è pubblico, quindi il canale webhook basta.

### Un avviso di Cloud Monitoring passa attraverso Non disturbare?

Solo se arriva come avviso in stile chiamata. Un canale Echobell di tipo chiamata si comporta come una telefonata in arrivo, e Full Immersion e Non disturbare di iOS la lasciano passare se le impostazioni di Full Immersion consentono le chiamate. Un SMS o un push normale no. Attiva anche **Riprova chiamata non riuscita**: con “Consenti chiamate ripetute” attivo nelle impostazioni di Full Immersion, una seconda chiamata entro tre minuti può squillare.

### Devo usare l'opzione Basic Auth del webhook?

No. Echobell si autentica con il token nell'URL. Il flusso Basic Auth di Google si aspetta prima una challenge `401`, che Echobell non invia.

### Posso chiamare persone diverse per criteri diversi?

Sì. Crea un canale Echobell per ogni destinatario, aggiungi l'URL di ciascun canale a Google Cloud come canale webhook a sé e collega ognuno ai criteri di cui si occupa quel destinatario. Un URL del webhook attiva sempre lo stesso canale Echobell, quindi una condizione su `policy_user_labels` può silenziare dei criteri su quel canale, ma non passarli a un altro. Non c'è presa in carico, quindi vengono chiamati tutti gli iscritti con "chiamata".

### E con più progetti?

Un canale di notifica appartiene a un solo progetto. Crea il canale webhook in ogni progetto — lo stesso URL Echobell funziona in tutti — oppure invia gli avvisi da un progetto di definizione dell'ambito che monitora gli altri.

## In sintesi

Il percorso è fatto di quattro parti: un canale di chiamata con la condizione `incident.state == "open"`, un canale di notifica webhook che punta a esso, un breve elenco di criteri che meritano una chiamata e un test reale prima di farci affidamento. Il resto serve a tenere quell'elenco abbastanza corto perché tra un mese uno squillo significhi ancora qualcosa.

[Scarica Echobell per iPhone](https://apps.apple.com/app/apple-store/id6743597198?pt=128151925&ct=blog-google-cloud-monitoring-phone-call-alerts-it&mt=8) oppure [prendilo su Google Play](https://play.google.com/store/apps/details?id=one.echobell.echobellandroid), poi puntaci il tuo criterio di avviso più importante.

## Articoli correlati

- [Riferimento delle condizioni di canale](/it/docs/conditions)
- [Riferimento dei template](/it/docs/template)
- [Guida all'integrazione con i webhook](/it/docs/webhook)
- [Avvisi CloudWatch via chiamata](/it/blog/cloudwatch-alarm-phone-call-alerts)
- [Avvisi Alertmanager via chiamata](/it/blog/alertmanager-phone-call-alerts)
- [Guida per sviluppatori all'alert fatigue](/it/blog/fix-alert-fatigue-developer-guide)
- [Superare la modalità Full Immersion di iOS per gli avvisi critici](/it/blog/how-to-bypass-ios-focus-mode-for-critical-alerts)
