Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Panoramica di
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
Che tu sia alle prime armi o un utente più esperto di Grafana Alerting, scopri di più sui fondamenti e sulle funzionalità disponibili che ti aiutano a creare, gestire e rispondere agli avvisi e a migliorare la capacità del tuo team di risolvere rapidamente i problemi.
## Principi
Nei sistemi di avviso basati su Prometheus, è disponibile un generatore di avvisi che crea avvisi e un ricevitore di avvisi che riceve avvisi. Ad esempio, Prometheus è un generatore di avvisi ed è responsabile della valutazione delle regole di avviso, mentre Alertmanager è un ricevitore di avvisi ed è responsabile del raggruppamento, dell'inibizione, del silenziamento e dell'invio di notifiche sulla attivazione e sugli avvisi risolti.
Grafana Alerting si basa sul modello Prometheus di progettazione di sistemi di allarme. Dispone di un generatore di avvisi interno responsabile della pianificazione e della valutazione delle regole di avviso, nonché di un ricevitore di avvisi interno responsabile del raggruppamento, dell'inibizione, del silenziamento e dell'invio delle notifiche. Grafana non utilizza Prometheus come generatore di avvisi perché Grafana Alerting deve funzionare con molte altre fonti di dati oltre a Prometheus. Tuttavia, utilizza Alertmanager come ricevitore di avvisi.
Gli avvisi vengono inviati al destinatario degli avvisi dove vengono instradati, raggruppati, inibiti, silenziati e notificati. In Grafana Alerting, il ricevitore di avvisi predefinito è l'Alertmanager incorporato in Grafana e viene chiamato Grafana Alertmanager. [Tuttavia, è possibile utilizzare anche altri gestori di avvisi, denominati gestori di avvisi esterni.](v10-alerting-setup-alertmanager.md)
## Nozioni fondamentali
Di seguito viene fornita una panoramica delle diverse parti degli avvisi Grafana.
### Regole di avviso
Una regola di avviso è un insieme di criteri che determinano quando un avviso deve essere attivato. Consiste in una o più interrogazioni ed espressioni, una condizione che deve essere soddisfatta, un intervallo che determina la frequenza con cui viene valutata la regola di avviso e una durata durante la quale deve essere soddisfatta la condizione affinché venga attivato un avviso.
Le regole di avviso vengono valutate in base al rispettivo intervallo e ogni regola di avviso può avere zero, uno o un numero qualsiasi di avvisi attivati alla volta. Lo stato della regola di avviso è determinato dal numero massimo di `severe` avvisi, che può essere Normale, In sospeso o Attivo. Ad esempio, se almeno uno degli avvisi di una regola di avviso è attivo, viene attivata anche la regola di avviso. Lo stato di integrità di una regola di avviso è determinato dallo stato della sua valutazione più recente. Questi possono essere OK, Error e NoData.
Una caratteristica molto importante delle regole di avviso è che supportano annotazioni ed etichette personalizzate. Queste consentono di utilizzare gli avvisi con metadati aggiuntivi come riepiloghi e descrizioni e di aggiungere etichette aggiuntive per indirizzare gli avvisi verso politiche di notifica specifiche.
### Avvisi
Gli avvisi sono identificati in modo univoco da set di coppie denominate Labels. key/value Ogni chiave è un nome di etichetta e ogni valore è un valore di etichetta. Ad esempio, un avviso potrebbe avere le etichette `foo=bar` e un altro avviso potrebbe avere le etichette`foo=baz`. Un avviso può avere molte etichette, ad esempio`foo=bar,bar=baz`, ma non può avere la stessa etichetta due volte, ad esempio`foo=bar,foo=baz`. Inoltre, due avvisi non possono avere le stesse etichette e, se due avvisi hanno la stessa etichetta, uno degli avvisi verrà scartato. `foo=bar,bar=baz` `foo=bar,bar=baz` Gli avvisi vengono risolti quando la condizione nella regola di avviso non è più soddisfatta o la regola di avviso viene eliminata.
In Grafana Managed Alerts, gli avvisi possono essere negli stati Normale, In sospeso, Avviso, Nessun dato o Errore. Negli avvisi gestiti dall'origine dati, come Mimir e Loki, gli avvisi possono essere in modalità Normale, In sospeso e Avviso, ma non in modalità Errore. NoData
### Punti di contatto
I punti di contatto determinano dove vengono inviate le notifiche. Ad esempio, potresti avere un punto di contatto che invia notifiche a un indirizzo email, a Slack, a un sistema di gestione degli incidenti (IRM) come Grafana OnCall o Pagerduty o a un webhook.
Le notifiche inviate dai punti di contatto possono essere personalizzate utilizzando modelli di notifica. È possibile utilizzare i modelli di notifica per modificare il titolo, il messaggio e la struttura della notifica. I modelli di notifica non sono specifici per singole integrazioni o punti di contatto.
### Politiche di notifica
Le politiche di notifica raggruppano gli avvisi e quindi li indirizzano ai punti di contatto. Determinano quando vengono inviate le notifiche e con quale frequenza le notifiche devono essere ripetute.
Gli avvisi vengono abbinati alle politiche di notifica utilizzando labelmatcher. Si tratta di espressioni leggibili dall'uomo che affermano se le etichette dell'avviso corrispondono esattamente, non corrispondono esattamente, contengono o non contengono il testo previsto. Ad esempio, il matcher `foo=bar` abbina gli avvisi all'etichetta `foo=bar` mentre il matcher `foo=~[a-zA-Z]+` abbina gli avvisi con qualsiasi etichetta chiamata foo con un valore che corrisponde all'espressione regolare. `[a-zA-Z]+`
Per impostazione predefinita, un avviso può corrispondere a una sola politica di notifica. Tuttavia, con la `continue` funzionalità è possibile fare in modo che gli avvisi corrispondano a un numero qualsiasi di politiche di notifica contemporaneamente. Per ulteriori informazioni sulle politiche di notifica, vedere Politiche [di notifica](v10-alerting-explore-notifications-policies-details.md).
### Silenzi e tempi di silenziamento
I silenzi e le tempistiche di silenziamento consentono di mettere in pausa le notifiche per avvisi specifici o addirittura per intere politiche di notifica. Utilizza il silenzio per mettere in pausa le notifiche ad hoc, ad esempio mentre lavori alla correzione di un avviso, e utilizza i tempi di silenziamento per sospendere le notifiche a intervalli regolari, ad esempio durante le normali finestre di manutenzione programmate.
**Topics**
+ [Principi](#v10-alerting-overview-principles)
+ [Nozioni fondamentali](#v10-alerting-overview-fundamentals)
+ [Fonti di dati e avvisi Grafana](v10-alerting-overview-datasources.md)
+ [Avvisi su dati numerici](v10-alerting-overview-numeric.md)
+ [Etichette e annotazioni](v10-alerting-overview-labels.md)
+ [Informazioni sulle regole di avviso](v10-alerting-explore-rules.md)
+ [Gestore degli avvisi](v10-alerting-explore-alertmanager.md)
+ [Punti di contatto](v10-alerting-explore-contacts.md)
+ [Notifications](v10-alerting-explore-notifications.md)
+ [Avvisi relativi all'elevata disponibilità](v10-alerting-explore-high-availability.md)
# Fonti di dati e avvisi Grafana
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
Esistono diverse fonti di dati compatibili con Grafana Alerting. Ogni fonte di dati è supportata da un plugin. Gli avvisi Grafana richiedono che i plug-in delle sorgenti dati siano plug-in di *backend*, al fine di valutare le regole utilizzando l'origine dati, poiché il motore di valutazione funziona sul backend. I plugin devono inoltre specificare che sono compatibili con gli avvisi Grafana.
Le fonti di dati vengono aggiunte e aggiornate nel tempo. È noto che le seguenti fonti di dati sono compatibili con gli avvisi Grafana.
+ [Connect a una fonte di CloudWatch dati Amazon](using-amazon-cloudwatch-in-AMG.md)
+ [Connect a un'origine dati di Azure Monitor](using-azure-monitor-in-AMG.md)
+ [Connect a una fonte OpenSearch di dati Amazon Service](using-Amazon-OpenSearch-in-AMG.md)
+ [Connect a una fonte di dati di Google Cloud Monitoring](using-google-cloud-monitoring-in-grafana.md)
+ [Connect a una fonte di dati Graphite](using-graphite-in-AMG.md)
+ [Connect a una fonte di dati InfluxDB](using-influxdb-in-AMG.md)
+ [Connect a una fonte di dati Loki](using-loki-in-AMG.md)
+ [Connect a un'origine dati Microsoft SQL Server](using-microsoft-sql-server-in-AMG.md)
+ [Connect a una fonte di dati MySQL](using-mysql-in-AMG.md)
+ [Connect a un'origine dati OpenTSDB](using-opentsdb-in-AMG.md)
+ [Connect a un'origine dati PostgreSQL](using-postgresql-in-AMG.md)
+ [Connect ad Amazon Managed Service for Prometheus e alle fonti di dati Prometheus open source](prometheus-data-source.md)
+ [Connect a una fonte di dati Jaeger](jaeger-data-source.md)
+ [Connect a una fonte di dati Zipkin](zipkin-data-source.md)
+ [Connect a una sorgente dati Tempo](tempo-data-source.md)
+ [Configurare un'origine TestData dati per i test](testdata-data-source.md)
Per informazioni più dettagliate sulle sorgenti di dati e sui plug-in di sorgenti dati in Amazon Managed Grafana, consulta. [Connessione alle origini dati](AMG-data-sources.md)
# Avvisi su dati numerici
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
Questo argomento descrive come Grafana gestisce gli avvisi su dati numerici anziché su serie temporali.
Tra alcune fonti di dati, i dati numerici che non sono serie temporali possono essere avvisati direttamente o passati a Server Side Expressions (SSE). Ciò consente una maggiore elaborazione e la conseguente efficienza all'interno dell'origine dati e può anche semplificare le regole di avviso. Quando si inviano avvisi su dati numerici anziché su dati di serie temporali, non è necessario ridurre ogni serie temporale etichettata a un unico numero. I numeri etichettati vengono invece restituiti a Grafana.
## Dati tabulari
Questa funzionalità è supportata con fonti di dati di backend che interrogano dati tabulari:
+ Origini dati SQL come MySQL, Postgres, MSSQL e Oracle.
+ I servizi basati su Azure Kusto: Azure Monitor (Logs), Azure Monitor (Azure Resource Graph) e Azure Data Explorer.
Una query con avvisi gestiti Grafana o SSE è considerata numerica con queste fonti di dati, se:
+ L'opzione «Format AS» è impostata su «Tabella» nella query sull'origine dei dati.
+ La risposta alla tabella restituita a Grafana dalla query include solo una colonna numerica (ad esempio int, double, float) e facoltativamente colonne di stringa aggiuntive.
Se sono presenti colonne di stringhe, tali colonne diventano etichette. Il nome di una colonna diventa il nome dell'etichetta e il valore di ogni riga diventa il valore dell'etichetta corrispondente. Se vengono restituite più righe, ogni riga deve essere identificata in modo univoco con le relative etichette.
## Esempio
Per una tabella MySQL chiamata «»: DiskSpace
| Orario | Host | Disk | PercentFree |
| --- | --- | --- | --- |
| 2021-7 giugno | web 1 | /ecc | 3 |
| 2021-giugno-7 | web 2 | /var | 4 |
| 2021-7 giugno | web 3 | /var | 8 |
| ... | ... | ... | ... |
È possibile interrogare il filtraggio dei dati in tempo, ma senza restituire la serie temporale a Grafana. Ad esempio, un avviso che si attiva per ogni host o disco quando c'è meno del 5% di spazio libero:
```
SELECT Host , Disk , CASE WHEN PercentFree < 5.0 THEN PercentFree ELSE 0 END FROM (
SELECT
Host,
Disk,
Avg(PercentFree)
FROM DiskSpace
Group By
Host,
Disk
Where __timeFilter(Time)
```
Questa query restituisce la seguente risposta della Tabella a Grafana:
| Host | Disk | PercentFree |
| --- | --- | --- |
| web1 | /ecc | 3 |
| web2 | /var | 4 |
| web 3 | /var | 0 |
Quando questa interrogazione viene utilizzata come **condizione** in una regola di avviso, verrà generata l'allerta da un valore diverso da zero. Di conseguenza, vengono prodotte tre istanze di avviso:
| Etichette | Status |
| --- | --- |
| \$1host=WEB1, disk=/etc\$1 | Avviso |
| \$1host=Web2, disco=/var\$1 | Avviso |
| \$1host=WEB3, disco=/var\$1 | Normale |
# Etichette e annotazioni
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
Le etichette e le annotazioni contengono informazioni su un avviso. Sia le etichette che le annotazioni hanno la stessa struttura: un insieme di valori denominati; tuttavia gli usi previsti sono diversi. Un esempio di etichetta o di annotazione equivalente potrebbe essere. `alertname="test"`
La differenza principale tra un'etichetta e un'annotazione è che le etichette vengono utilizzate per differenziare un avviso da tutti gli altri avvisi, mentre le annotazioni vengono utilizzate per aggiungere informazioni aggiuntive a un avviso esistente.
Ad esempio, considera due avvisi di CPU elevati: uno per e l'altro per. `server1` `server2` In questo esempio, potremmo avere un'etichetta chiamata `server` dove il primo avviso ha l'etichetta `server="server1"` e il secondo avviso ha l'etichetta`server="server2"`. Tuttavia, potremmo anche voler aggiungere una descrizione a ciascun avviso`"The CPU usage for server1 is above 75%."`, ad esempio, dove `server1` `75%` vengono sostituiti con il nome e l'utilizzo della CPU del server ([Modelli di etichette e annotazioni](v10-alerting-overview-labels-templating.md)per informazioni su come eseguire questa operazione, consulta la documentazione). Questo tipo di descrizione sarebbe più adatto come annotazione.
## Etichette
Le etichette contengono informazioni che identificano un avviso. Un esempio di etichetta potrebbe essere`server=server1`. Ogni avviso può avere più di un'etichetta e il set completo di etichette per un avviso è denominato set di etichette. È questo set di etichette che identifica l'avviso.
Ad esempio, un avviso potrebbe avere l'etichetta impostata `{alertname="High CPU usage",server="server1"}` mentre un altro avviso potrebbe avere l'etichetta impostata`{alertname="High CPU usage",server="server2"}`. Si tratta di due avvisi separati perché, sebbene le `alertname` etichette siano le stesse, le `server` etichette sono diverse.
L'etichetta impostata per un avviso è una combinazione delle etichette dell'origine dati, delle etichette personalizzate della regola di avviso e di una serie di etichette riservate come. `alertname`
**Etichette personalizzate**
Le etichette personalizzate sono etichette aggiuntive della regola di avviso. Come le annotazioni, le etichette personalizzate devono avere un nome e il loro valore può contenere una combinazione di testo e codice modello che viene valutata quando viene generato un avviso. [La documentazione su come creare modelli di etichette personalizzate è disponibile qui.](v10-alerting-overview-labels-templating.md)
Quando si utilizzano etichette personalizzate con modelli, è importante assicurarsi che il valore dell'etichetta non cambi tra valutazioni consecutive della regola di avviso, poiché ciò finirebbe per creare un gran numero di avvisi distinti. Tuttavia, è possibile che il modello produca valori di etichetta diversi per avvisi diversi. Ad esempio, non inserite il valore della query in un'etichetta personalizzata poiché ciò finirà per creare un nuovo set di avvisi ogni volta che il valore cambia. Utilizzate invece le annotazioni.
È inoltre importante assicurarsi che l'etichetta impostata per un avviso non contenga due o più etichette con lo stesso nome. Se un'etichetta personalizzata ha lo stesso nome di un'etichetta dell'origine dati, sostituirà quell'etichetta. Tuttavia, se un'etichetta personalizzata ha lo stesso nome di un'etichetta riservata, l'etichetta personalizzata verrà omessa dall'avviso.
## Annotazioni
Le annotazioni sono coppie denominate che aggiungono informazioni aggiuntive agli avvisi esistenti. Ci sono una serie di annotazioni suggerite in Grafana `description` come`summary`,`runbook_url`, `dashboardUId` e. `panelId` Come le etichette personalizzate, le annotazioni devono avere un nome e il loro valore può contenere una combinazione di testo e codice modello che viene valutata quando viene generato un avviso. Se un'annotazione contiene codice modello, il modello viene valutato una volta quando viene generato l'avviso. Non viene rivalutato, anche quando l'avviso viene risolto. [La documentazione su come modellare le annotazioni è disponibile qui.](v10-alerting-overview-labels-templating.md)
**Topics**
+ [Etichette](#v10-alerting-overview-labels-labels)
+ [Annotazioni](#v10-alerting-overview-labels-annotations)
+ [Come funziona l'abbinamento delle etichette](v10-alerting-overview-labels-matching.md)
+ [Etichette in Grafana Alerting](v10-alerting-overview-labels-alerting.md)
+ [Modelli di etichette e annotazioni](v10-alerting-overview-labels-templating.md)
# Come funziona l'abbinamento delle etichette
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
Usa le etichette e gli abbinatori di etichette per collegare le regole di avviso alle politiche di notifica e ai silenzi. Ciò consente un modo molto flessibile di gestire le istanze di avviso, specificare quale politica deve gestirle e quali avvisi silenziare.
**Un label matcher è composto da 3 parti distinte, l'**etichetta**, il **valore e l'operatore**.**
+ Il campo **Etichetta** è il nome dell'etichetta da abbinare. Deve corrispondere esattamente al nome dell'etichetta.
+ Il campo **Valore** corrisponde al valore corrispondente per il nome dell'**etichetta** specificato. Il modo in cui corrisponde dipende dal valore **dell'operatore**.
+ Il campo **Operatore** è l'operatore da confrontare con il valore dell'etichetta. Gli operatori disponibili sono:
| Operatore | Description |
| --- | --- |
| `=` | Seleziona etichette che siano esattamente uguali al valore. |
| `!=` | Seleziona etichette che non sono uguali al valore. |
| `=~` | Seleziona le etichette che corrispondono regolarmente al valore. |
| `!~` | Seleziona le etichette che non corrispondono in modo regolare al valore. |
Se si utilizzano più abbinatori di etichette, questi vengono combinati utilizzando l'operatore logico AND. Ciò significa che tutti gli abbinatori devono corrispondere per collegare una regola a una politica.
## Esempio
Se definisci il seguente set di etichette per il tuo avviso:
```
{ foo=bar, baz=qux, id=12 }
```
quindi:
+ Un label matcher definito come `foo=bar` corrisponde a questa regola di avviso.
+ Un label matcher definito come *non `foo!=bar`* corrisponde a questa regola di avviso.
+ Un label matcher definito come `id=~[0-9]+` corrisponde a questa regola di avviso.
+ Un label matcher definito come `baz!~[0-9]+` corrisponde a questa regola di avviso.
+ Due label matcher definiti `foo=bar` e `id=~[0-9]+` corrispondenti a questa regola di avviso.
## Escludi etichette
Puoi anche scrivere abbinatori di etichette per escludere le etichette.
Ecco un esempio che mostra come escludere l'etichetta`team`. Puoi scegliere tra uno qualsiasi di questi valori per escludere l'etichetta.
+ `team=""`
+ `team!~.+`
+ `team=~^$`
# Etichette in Grafana Alerting
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
Questo argomento spiega perché le etichette sono un componente fondamentale degli avvisi.
+ Il set completo di etichette per un avviso è ciò che identifica in modo univoco un avviso all'interno degli avvisi Grafana.
+ L'Alertmanager utilizza le etichette per abbinare gli avvisi per silenzi e gruppi di avvisi nelle politiche di notifica.
+ L'interfaccia utente di avviso mostra le etichette per ogni istanza di avviso generata durante la valutazione di quella regola.
+ I punti di contatto possono accedere alle etichette per generare dinamicamente notifiche contenenti informazioni specifiche sull'avviso che genera una notifica.
+ È possibile aggiungere etichette a una regola di [avviso.](v10-alerting-configure.md) Le etichette sono configurabili manualmente, utilizzano funzioni modello e possono fare riferimento ad altre etichette. Le etichette aggiunte a una regola di avviso hanno la precedenza in caso di collisione tra etichette (tranne nel caso delle etichette riservate Grafana, vedi sotto per ulteriori informazioni).
## Compatibilità con Alertmanager esterno
L'Alertmanager integrato di Grafana supporta sia le chiavi che i valori delle etichette Unicode. [Se si utilizza un Prometheus Alertmanager esterno, le chiavi delle etichette devono essere compatibili con il relativo modello di dati.](https://prometheus.io/docs/concepts/data_model/#metric-names-and-labels) **Ciò significa che le chiavi di etichetta devono contenere solo **lettere ASCII**, **numeri** e caratteri di sottolineatura e corrispondere all'espressione regolare.** `[a-zA-Z_][a-zA-Z0-9_]*` Tutti i caratteri non validi verranno rimossi o sostituiti dal motore di avviso Grafana prima di essere inviati all'Alertmanager esterno secondo le seguenti regole:
+ `Whitespace`verrà rimosso.
+ `ASCII characters`sarà sostituito con`_`.
+ `All other characters`verranno sostituiti con la loro rappresentazione esadecimale minuscola. Se questo è il primo carattere, verrà preceduto da. `_`
**Nota**
Se più chiavi di etichetta vengono ridefinite con lo stesso valore, ai duplicati verrà aggiunto un breve hash dell'etichetta originale come suffisso.
## Etichette riservate Grafana
**Nota**
Le etichette con il prefisso `grafana_` sono riservate da Grafana per usi speciali. Se viene aggiunta un'etichetta configurata manualmente all'inizio, verrà sovrascritta in caso di collisione. `grafana_`
Le etichette riservate Grafana possono essere utilizzate allo stesso modo delle etichette configurate manualmente. L'elenco attuale delle etichette riservate disponibili è:
| Etichetta | Description |
| --- | --- |
| cartella\$1grafana | Titolo della cartella contenente l'avviso. |
# Modelli di etichette e annotazioni
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
È possibile utilizzare modelli per includere dati provenienti da interrogazioni ed espressioni in etichette e annotazioni. Ad esempio, potresti voler impostare l'etichetta di gravità per un avviso in base al valore della query o utilizzare l'etichetta dell'istanza della query in un'annotazione di riepilogo in modo da sapere quale server sta riscontrando un utilizzo elevato della CPU.
Tutti i modelli devono essere scritti in [text/template](https://pkg.go.dev/text/template). Indipendentemente dal fatto che stiate creando un modello di etichetta o di un'annotazione, dovreste scrivere ogni modello in linea all'interno dell'etichetta o dell'annotazione che state modellando. Ciò significa che non è possibile condividere modelli tra etichette e annotazioni e sarà invece necessario copiare i modelli ovunque si desideri utilizzarli.
Ogni modello viene valutato ogni volta che viene valutata la regola di avviso e viene valutato separatamente per ogni avviso. Ad esempio, se la regola di avviso ha un'annotazione di riepilogo basata su un modello e la regola di avviso ha 10 avvisi di attivazione, il modello verrà eseguito 10 volte, una volta per ogni avviso. Dovresti cercare di evitare il più possibile di eseguire calcoli costosi nei tuoi modelli.
## Esempi
Invece di scrivere un tutorial completo, text/template, the following examples attempt to show the most common use-cases we have seen for templates. You can use these examples verbatim, or adapt them as necessary for your use case. For more information about how to write text/template consulta la documentazione del [testo/modello](https://pkg.go.dev/text/template).
**Stampa tutte le etichette, separate da virgole**
Per stampare tutte le etichette, separate da virgole, stampa la `$labels` variabile:
```
{{ $labels }}
```
Ad esempio, se viene fornito un avviso con le etichette `alertname=High CPU usage``instance=server1`, `grafana_folder=CPU alerts` verrà stampato:
```
alertname=High CPU usage, grafana_folder=CPU alerts, instance=server1
```
**Nota**
Se si utilizzano condizioni classiche, `$labels` non conterrà alcuna etichetta della query. Per ulteriori informazioni[, fare riferimento alla variabile \$1labels](#v10-alerting-overview-labels-templating-the-labels-variable).
**Stampa tutte le etichette, una per riga**
Per stampare tutte le etichette, una per riga, usa a per `range` iterare su ogni key/value coppia e stamparle singolarmente. Qui `$k` si riferisce al nome e `$v` al valore dell'etichetta corrente:
```
{{ range $k, $v := $labels -}}
{{ $k }}={{ $v }}
{{ end }}
```
Ad esempio, se viene fornito un avviso con le etichette `alertname=High CPU usage``instance=server1`, `grafana_folder=CPU alerts` verrà stampato:
```
alertname=High CPU usage
grafana_folder=CPU alerts
instance=server1
```
**Nota**
Se si utilizzano condizioni classiche, `$labels` non conterrà alcuna etichetta della query. Per ulteriori informazioni[, fare riferimento alla variabile \$1labels](#v10-alerting-overview-labels-templating-the-labels-variable).
**Stampa una singola etichetta**
Per stampare una singola etichetta usa la `index` funzione con la `$labels` variabile:
```
The host {{ index $labels "instance" }} has exceeded 80% CPU usage for the last 5 minutes
```
Ad esempio, dato un avviso con l'etichetta`instance=server1`, questo stamperebbe:
```
The host server1 has exceeded 80% CPU usage for the last 5 minutes
```
**Nota**
Se si utilizzano condizioni classiche, `$labels` non conterrà alcuna etichetta della query. Per ulteriori informazioni[, fare riferimento alla variabile \$1labels](#v10-alerting-overview-labels-templating-the-labels-variable).
**Stampa il valore di una query**
Per stampare il valore di una query istantanea è possibile stampare il relativo Ref ID utilizzando la `index` funzione e la `$values` variabile:
```
{{ index $values "A" }}
```
Ad esempio, data una query istantanea che restituisce il valore 81.2345, verrà stampato:
```
81.2345
```
Per stampare il valore di una query con intervallo, è necessario innanzitutto ridurlo da una serie temporale a un vettore istantaneo con un'espressione di riduzione. È quindi possibile stampare il risultato dell'espressione reduce utilizzando invece il relativo ID Ref. Ad esempio, se l'espressione reduce prende la media di A e ha l'ID Ref B, dovresti scrivere:
```
{{ index $values "B" }}
```
**Stampa il valore umanizzato di una query**
Per stampare il valore umanizzato di una query istantanea usa la `humanize` funzione:
```
{{ humanize (index $values "A").Value }}
```
Ad esempio, data una query istantanea che restituisce il valore 81.2345, verrà stampato:
```
81.234
```
Per stampare il valore umanizzato di una query con intervallo, è necessario innanzitutto ridurlo da una serie temporale a un vettore istantaneo con un'espressione di riduzione. È quindi possibile stampare il risultato dell'espressione reduce utilizzando invece il relativo ID Ref. Ad esempio, se l'espressione reduce prende la media di A e ha l'ID Ref B, dovresti scrivere:
```
{{ humanize (index $values "B").Value }}
```
**Stampa il valore di una query in percentuale**
Per stampare il valore di una query istantanea in percentuale, usa la `humanizePercentage` funzione:
```
{{ humanizePercentage (index $values "A").Value }}
```
Questa funzione prevede che il valore sia un numero decimale compreso tra 0 e 1. Se il valore è invece un numero decimale compreso tra 0 e 100, è possibile dividerlo per 100 nella query o utilizzando un'espressione matematica. Se la query è una query a intervallo, è necessario innanzitutto ridurla da una serie temporale a un vettore istantaneo con un'espressione di riduzione.
**Imposta una severità in base al valore di una query**
Per impostare un'etichetta di gravità in base al valore di una query, utilizzate l'istruzione if e la funzione greater than comparison. Assicurati di utilizzare i decimali (`80.0`,, `50.0``0.0`, ecc.) quando esegui confronti con `$values` poiché non text/template supporta la coercizione dei tipi. [Puoi trovare un elenco di tutte le funzioni di confronto supportate qui.](https://pkg.go.dev/text/template#hdr-Functions)
```
{{ if (gt $values.A.Value 80.0) -}}
high
{{ else if (gt $values.A.Value 50.0) -}}
medium
{{ else -}}
low
{{- end }}
```
**Stampa tutte le etichette partendo da una condizione classica**
Non è possibile `$labels` stampare etichette dalla query se si utilizzano condizioni classiche, ma è necessario utilizzare `$values` al suo posto. Il motivo è che le condizioni classiche scartano queste etichette per imporre un comportamento unidimensionale (al massimo un avviso per regola di avviso). Se le condizioni classiche non eliminassero queste etichette, le interrogazioni che restituivano numerose serie temporali farebbero sì che gli avvisi si alternassero tra l'attivazione e la risoluzione costante, poiché le etichette cambierebbero ogni volta che veniva valutata la regola di avviso.
La `$values` variabile contiene invece i valori ridotti di tutte le serie temporali per tutte le condizioni che si verificano. Ad esempio, se hai una regola di avviso con una query A che restituisce due serie temporali e una condizione classica B con due condizioni, allora `$values` conterrebbe `B0``B1`, `B2` e`B3`. Se la condizione classica B avesse una sola condizione, `$values` conterrebbe solo `B0` e`B1`.
Per stampare tutte le etichette di tutte le serie storiche di cottura, usa il seguente modello (assicurati di sostituirlo `B` nell'espressione regolare con l'ID Ref della condizione classica se è diversa):
```
{{ range $k, $v := $values -}}
{{ if (match "B[0-9]+" $k) -}}
{{ $k }}: {{ $v.Labels }}{{ end }}
{{ end }}
```
Ad esempio, una condizione classica per due serie temporali che superano una singola condizione stamperebbe:
```
B0: instance=server1
B1: instance=server2
```
Se la condizione classica presenta due o più condizioni e una serie temporale supera più condizioni contemporaneamente, le relative etichette verranno duplicate per ogni condizione superata:
```
B0: instance=server1
B1: instance=server2
B2: instance=server1
B3: instance=server2
```
Se devi stampare etichette uniche, dovresti invece prendere in considerazione la possibilità di modificare le regole di avviso da unidimensionali a multidimensionali. Puoi farlo sostituendo la tua condizione classica con espressioni di riduzione e matematiche.
**Stampa tutti i valori da una condizione classica**
Per stampare tutti i valori di una condizione classica, prendi l'esempio precedente e sostituiscilo `$v.Labels` con`$v.Value`:
```
{{ range $k, $v := $values -}}
{{ if (match "B[0-9]+" $k) -}}
{{ $k }}: {{ $v.Value }}{{ end }}
{{ end }}
```
Ad esempio, una condizione classica per due serie temporali che superano una singola condizione stamperebbe:
```
B0: 81.2345
B1: 84.5678
```
Se la condizione classica ha due o più condizioni e una serie temporale supera più condizioni contemporaneamente, `$values` conterrà i valori di tutte le condizioni:
```
B0: 81.2345
B1: 92.3456
B2: 84.5678
B3: 95.6789
```
## Variabili
Le seguenti variabili sono disponibili per la creazione di modelli di etichette e annotazioni:
### La variabile labels
La `$labels` variabile contiene tutte le etichette della query. Ad esempio, supponiamo di avere una query che restituisce l'utilizzo della CPU per tutti i server e di avere una regola di avviso che si attiva quando uno dei server ha superato l'80% di utilizzo della CPU negli ultimi 5 minuti. Desideri aggiungere un'annotazione di riepilogo all'avviso che indichi quale server sta riscontrando un utilizzo elevato della CPU. Con la `$labels` variabile puoi scrivere un modello che stampa una frase leggibile dall'uomo come:
```
CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes
```
**Nota**
Se si utilizza una condizione classica, `$labels` non conterrà alcuna etichetta della query. Le condizioni classiche eliminano queste etichette per imporre un comportamento unidimensionale (al massimo un avviso per regola di avviso). Se desideri utilizzare le etichette della query nel tuo modello, segui il precedente esempio *Stampa tutte le etichette da una* condizione classica.
### La variabile value
La `$value` variabile è una stringa contenente le etichette e i valori di tutte le query istantanee, le espressioni threshold, reduce e matematiche e le condizioni classiche nella regola di avviso. Non contiene i risultati delle interrogazioni con intervalli, in quanto possono restituire da 10 a 10.000 righe o metriche. In tal caso, per query particolarmente grandi un singolo avviso potrebbe utilizzare 10 secondi MBs di memoria e Grafana esaurirebbe la memoria molto rapidamente.
Per stampare la `$value` variabile nel riepilogo dovresti scrivere qualcosa del genere:
```
CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes: {{ $value }}
```
E sarebbe simile a questo:
```
CPU usage for instance1 has exceeded 80% for the last 5 minutes: [ var='A' labels={instance=instance1} value=81.234 ]
```
Qui `var='A'` si riferisce alla query istantanea con Ref ID A, `labels={instance=instance1}` si riferisce alle etichette e `value=81.234` si riferisce all'utilizzo medio della CPU negli ultimi 5 minuti.
Se vuoi stampare solo una parte della stringa invece della stringa completa, usa la `$values` variabile. Contiene le stesse informazioni`$value`, ma in una tabella strutturata, ed è molto più facile da usare rispetto alla scrittura di un'espressione regolare che corrisponda solo al testo desiderato.
### La variabile values
La `$values` variabile è una tabella contenente le etichette e i valori in virgola mobile di tutte le query e le espressioni istantanee, indicizzate in base al relativo codice Ref. IDs
Per stampare il valore della query istantanea con Ref ID A:
```
CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes: {{ index $values "A" }}
```
Ad esempio, dato un avviso con le etichette `instance=server1` e una query istantanea con il valore`81.2345`, questo stamperebbe:
```
CPU usage for instance1 has exceeded 80% for the last 5 minutes: 81.2345
```
Se la query in Ref ID A è una query di intervallo anziché una query istantanea, aggiungi un'espressione di riduzione con Ref ID B e sostituiscila `(index $values "A")` con`(index $values "B")`:
```
CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes: {{ index $values "B" }}
```
## Funzioni
Le seguenti funzioni sono disponibili per la creazione di modelli di etichette e annotazioni:
**args**
La `args` funzione traduce un elenco di oggetti in una mappa con le chiavi arg0, arg1 ecc. Questo ha lo scopo di consentire il passaggio di più argomenti ai modelli.
```
{{define "x"}}{{.arg0}} {{.arg1}}{{end}}{{template "x" (args 1 "2")}}
```
```
1 2
```
**URL esterno**
La `externalURL` funzione restituisce l'URL esterno del server Grafana.
```
{{ externalURL }}
```
```
https://example.com/grafana
```
**GraphLink**
La `graphLink` funzione restituisce il percorso della visualizzazione grafica [Esplora nella versione 10 di Grafana](v10-explore.md) per l'espressione e l'origine dati specificate.
```
{{ graphLink "{\"expr\": \"up\", \"datasource\": \"gdev-prometheus\"}" }}
```
```
/explore?left=["now-1h","now","gdev-prometheus",{"datasource":"gdev-prometheus","expr":"up","instant":false,"range":true}]
```
**umanizzare**
La `humanize` funzione umanizza i numeri decimali.
```
{{ humanize 1000.0 }}
```
```
1k
```
**umanizza 1024**
`humanize1024`Funziona in modo simile `humanize` ma utilizza 1024 come base anziché 1000.
```
{{ humanize1024 1024.0 }}
```
```
1ki
```
**Durata umanizzata**
La `humanizeDuration` funzione umanizza una durata in secondi.
```
{{ humanizeDuration 60.0 }}
```
```
1m 0s
```
**Umanizza la percentuale**
La `humanizePercentage` funzione umanizza un valore di rapporto rispetto a una percentuale.
```
{{ humanizePercentage 0.2 }}
```
```
20%
```
**Umanizza il timestamp**
La `humanizeTimestamp` funzione umanizza un timestamp Unix.
```
{{ humanizeTimestamp 1577836800.0 }}
```
```
2020-01-01 00:00:00 +0000 UTC
```
**partita**
La `match` funzione abbina il testo a un modello di espressione regolare.
```
{{ match "a.*" "abc" }}
```
```
true
```
**PathPrefix**
La `pathPrefix` funzione restituisce il percorso del server Grafana.
```
{{ pathPrefix }}
```
```
/grafana
```
**TableLink**
La `tableLink` funzione restituisce il percorso della vista tabulare [Esplora nella versione 10 di Grafana](v10-explore.md) per l'espressione e l'origine dati specificate.
```
{{ tableLink "{\"expr\": \"up\", \"datasource\": \"gdev-prometheus\"}" }}
```
```
/explore?left=["now-1h","now","gdev-prometheus",{"datasource":"gdev-prometheus","expr":"up","instant":true,"range":false}]
```
**titolo**
La `title` funzione rende maiuscolo il primo carattere di ogni parola.
```
{{ title "hello, world!" }}
```
```
Hello, World!
```
**a Lower**
La `toLower` funzione restituisce tutto il testo in lettere minuscole.
```
{{ toLower "Hello, world!" }}
```
```
hello, world!
```
**a TOUPPER**
La `toUpper` funzione restituisce tutto il testo in maiuscolo.
```
{{ toUpper "Hello, world!" }}
```
```
HELLO, WORLD!
```
**reReplaceAll**
La `reReplaceAll` funzione sostituisce il testo corrispondente all'espressione regolare.
```
{{ reReplaceAll "localhost:(.*)" "example.com:$1" "localhost:8080" }}
```
```
example.com:8080
```
# Informazioni sulle regole di avviso
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
Una regola di avviso è un insieme di criteri di valutazione che determina se un'istanza di avviso verrà attivata. La regola è costituita da una o più interrogazioni ed espressioni, una condizione, la frequenza di valutazione e la durata entro la quale la condizione deve essere soddisfatta per iniziare a funzionare.
Mentre le interrogazioni e le espressioni selezionano il set di dati da valutare, una *condizione* imposta la soglia che i dati devono soddisfare o superare per creare un avviso.
Un *intervallo* specifica la frequenza con cui viene valutata una regola di avviso. *La durata*, se configurata, indica per quanto tempo deve essere soddisfatta una condizione. Le regole di avviso possono anche definire il comportamento di avviso in assenza di dati.
**Topics**
+ [Tipi di regole di avviso](v10-alerting-explore-rules-types.md)
+ [Regole di registrazione](v10-alerting-explore-rule-recording.md)
+ [Domande e condizioni](v10-alerting-explore-rules-queries.md)
+ [Istanze di avviso](v10-alerting-rules-instances.md)
+ [Namespace, cartelle e gruppi](v10-alerting-rules-grouping.md)
+ [Valutazione delle regole di avviso](v10-alerting-rules-evaluation.md)
+ [Stato e integrità delle regole di allarme](v10-alerting-explore-state.md)
+ [Modello di notifica](v10-alerting-rules-notification-templates.md)
# Tipi di regole di avviso
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
Grafana supporta diversi tipi di regole di avviso. Scopri di più su ciascuno dei tipi di regole di avviso, su come funzionano e decidi qual è la migliore per il tuo caso d'uso.
## Regole gestite da Grafana
Le regole gestite Grafana sono il tipo di regola di avviso più flessibile. Ti consentono di creare avvisi che possono agire sui dati provenienti da qualsiasi fonte di dati esistente.
Oltre a supportare più fonti di dati, puoi aggiungere [espressioni](v10-panels-query-xform-expressions.md) per trasformare i dati ed esprimere le condizioni di avviso.
In Grafana, avvisi gestiti:
+ Le regole di avviso vengono create all'interno di Grafana, sulla base di una o più fonti di dati.
+ Le regole di avviso vengono valutate dal motore di valutazione delle regole di avviso all'interno di Grafana.
+ Gli avvisi vengono inviati utilizzando il Grafana Alertmanager interno.
**Nota**
Puoi anche configurare gli avvisi da inviare utilizzando un Alertmanager esterno o utilizzare gestori di avvisi interni ed esterni. [Per ulteriori informazioni, consulta Aggiungere un alertmanager esterno.](v10-alerting-setup-alertmanager.md)
## Regole gestite dalle fonti di dati
Per creare regole di avviso gestite dall'origine dati, devi disporre di un'origine dati Prometheus o Loki compatibile. Puoi verificare se la tua origine dati supporta la creazione di regole tramite Grafana testando l'origine dati e osservando se l'API Ruler è supportata.
Negli avvisi gestiti dalle fonti di dati:
+ Le regole di avviso vengono create e archiviate all'interno dell'origine dati stessa.
+ Le regole di avviso possono essere create solo sulla base dei dati di Prometheus.
+ La valutazione e la distribuzione delle regole di avviso sono distribuite su più nodi per un'elevata disponibilità e tolleranza agli errori.
## Scegli un tipo di regola di avviso
Quando scegli il tipo di regola di avviso da utilizzare, considera il seguente confronto tra le regole di avviso gestite da Grafana e le regole di avviso gestite dall'origine dei dati.
| Funzionalità | Regola di avviso gestita da Grafana | Regola di avviso gestita da Loki/mimir |
| --- | --- | --- |
| Crea regole di avviso basate sui dati provenienti da una qualsiasi delle nostre fonti di dati supportate | Sì | No: puoi creare regole di avviso solo basate sui dati di Prometheus. L'origine dati deve avere l'API Ruler abilitata. |
| Mescola e abbina le fonti di dati | Sì | No |
| Include il supporto per le regole di registrazione | No | Sì |
| Aggiungi espressioni per trasformare i dati e impostare le condizioni di avviso | Sì | No |
| Usa immagini nelle notifiche di avviso | Sì | No |
| Dimensionamento | Richiedono più risorse, dipendono dal database e sono suscettibili di errori temporanei. Scalano solo verticalmente. | Memorizza le regole di avviso all'interno della fonte di dati stessa e consenti una scalabilità «infinita». Genera e invia notifiche di avviso dalla posizione dei tuoi dati. |
| Valutazione e distribuzione delle regole di avviso | La valutazione e la distribuzione delle regole di avviso vengono eseguite dall'interno di Grafana, utilizzando un Alertmanager esterno o entrambi. | La valutazione delle regole di avviso e l'invio degli avvisi sono distribuiti, il che significa che non esiste un unico punto di errore. |
# Regole di registrazione
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
*Le regole di registrazione sono disponibili solo per le fonti di dati Prometheus o Loki compatibili.*
Una regola di registrazione consente di precalcolare le espressioni più necessarie o computazionalmente costose e di salvarne il risultato in un nuovo set di serie temporali. Ciò è utile se si desidera eseguire avvisi su dati aggregati o se si dispone di dashboard che eseguono ripetutamente query su espressioni computazionalmente costose.
L'interrogazione di questa nuova serie temporale è più veloce, soprattutto per i dashboard, poiché interrogano la stessa espressione ogni volta che i dashboard si aggiornano.
Scopri di più sulle [regole di registrazione](https://prometheus.io/docs/prometheus/latest/configuration/recording_rules/) in Prometheus.
# Domande e condizioni
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
In Grafana, le query svolgono un ruolo fondamentale nel recupero e nella trasformazione dei dati da fonti di dati supportate, che includono database come MySQL e PostgreSQL, database di serie temporali come Prometheus, InfluxDB e Graphite e servizi come Amazon, Azure Monitor e Google Cloud Monitoring. OpenSearch CloudWatch
Per ulteriori informazioni sulle fonti di dati supportate, consulta. [Fonti di dati e avvisi Grafana](v10-alerting-overview-datasources.md)
Il processo di esecuzione di una query prevede la definizione dell'origine dati, la specificazione dei dati desiderati da recuperare e l'applicazione di filtri o trasformazioni pertinenti. Per costruire queste query vengono utilizzati linguaggi di query o sintassi specifici dell'origine dati scelta.
In Alerting, si definisce una query per ottenere i dati da misurare e una condizione che deve essere soddisfatta prima che venga attivata una regola di avviso.
Una regola di avviso è costituita da una o più interrogazioni ed espressioni che selezionano i dati da misurare.
Per ulteriori informazioni su interrogazioni ed espressioni, vedere. [Interroga e trasforma i dati](v10-panels-query-xform.md)
## Interrogazioni relative alle fonti di dati
Le interrogazioni in Grafana possono essere applicate in vari modi, a seconda della fonte di dati e del linguaggio di interrogazione utilizzati. L'editor di query di ogni fonte di dati fornisce un'interfaccia utente personalizzata che consente di scrivere query che sfruttano le sue funzionalità uniche.
A causa delle differenze tra i linguaggi di interrogazione, ogni editor di query di sorgenti di dati ha un aspetto e un funzionamento diversi. A seconda della fonte di dati, l'editor di query potrebbe fornire funzionalità di completamento automatico, nomi di metriche, suggerimenti di variabili o un'interfaccia visiva per la creazione di query.
Alcuni tipi comuni di componenti di interrogazione includono:
**Metriche o campi dati**: specifica le metriche o i campi dati specifici che desideri recuperare, come l'utilizzo della CPU, il traffico di rete o le letture dei sensori.
**Intervallo** di tempo: definisci l'intervallo di tempo per il quale desideri recuperare i dati, ad esempio l'ultima ora, un giorno specifico o un intervallo di tempo personalizzato.
**Filtri**: applica filtri per restringere i dati in base a criteri specifici, ad esempio filtrando i dati in base a un tag, un host o un'applicazione specifici.
**Aggregazioni**: esegui aggregazioni sui dati per calcolare metriche come medie, somme o conteggi in un determinato periodo di tempo.
**Raggruppamento**: raggruppa i dati in base a dimensioni o tag specifici per creare viste o suddivisioni aggregate.
**Nota**
Grafana non supporta le interrogazioni di avviso con variabili modello. Ulteriori informazioni sono disponibili [qui](https://community.grafana.com/t/template-variables-are-not-supported-in-alert-queries-while-setting-up-alert/2514) nei forum di Grafana Labs.
## Interrogazioni sulle espressioni
In Grafana, un'espressione viene utilizzata per eseguire calcoli, trasformazioni o aggregazioni sui dati interrogati dall'origine dati. Consente di creare metriche personalizzate o modificare metriche esistenti in base a operazioni matematiche, funzioni o espressioni logiche.
Sfruttando le query di espressione, gli utenti possono eseguire attività come il calcolo della variazione percentuale tra due valori, applicare funzioni come funzioni logaritmiche o trigonometriche, aggregare dati su intervalli di tempo o dimensioni specifici e implementare la logica condizionale per gestire diversi scenari.
In Alerting, puoi usare solo espressioni per le regole di avviso gestite da Grafana. Per ogni espressione, puoi scegliere tra le espressioni matematiche, di riduzione e di ricampionamento. Queste sono chiamate regole multidimensionali, perché generano un avviso separato per ogni serie.
Puoi anche utilizzare una condizione classica, che crea una regola di avviso che attiva un singolo avviso quando viene soddisfatta la relativa condizione. Di conseguenza, Grafana invia un solo avviso anche quando le condizioni di allarme sono soddisfatte per più serie.
**Nota**
Le condizioni classiche esistono principalmente per motivi di compatibilità e dovrebbero essere evitate se possibile.
**Ridurre**
Aggrega i valori delle serie temporali nell'intervallo temporale selezionato in un unico valore.
**Math** (Matematica)
Esegue calcoli matematici in formato libero functions/operations su serie temporali e dati numerici. Può essere utilizzato per preelaborare i dati delle serie temporali o per definire una condizione di avviso per i dati numerici.
**Ricampionare**
Riallinea un intervallo di tempo a un nuovo set di timestamp, utile quando si confrontano dati di serie temporali provenienti da diverse fonti di dati in cui i timestamp altrimenti non si allineerebbero.
**Threshold**
Verifica se alcuni dati delle serie temporali corrispondono alla condizione di soglia.
L'espressione di soglia consente di confrontare due valori singoli. Viene restituita `0` quando la condizione è falsa e `1` se la condizione è vera. Sono disponibili le seguenti funzioni di soglia:
+ È superiore a (x > y)
+ È inferiore a (x < y)
+ È inferiore a (x y1 E x < y2)
+ < y1 AND x >È al di fuori dell'intervallo (x y2)
**Condizione classica**
Verifica se alcuni dati delle serie temporali corrispondono alla condizione di avviso.
**Nota**
Le classiche interrogazioni con espressioni di condizione producono sempre una sola istanza di avviso, indipendentemente dal numero di serie temporali che soddisfano la condizione. Le condizioni classiche esistono principalmente per motivi di compatibilità e dovrebbero essere evitate se possibile.
## Aggregazioni
Grafana Alerting offre le seguenti funzioni di aggregazione per consentirti di affinare ulteriormente la tua query.
Queste funzioni sono disponibili solo per le espressioni condizionali **Reduce** e **Classic**.
| Funzione | Expression | Cosa fa |
| --- | --- | --- |
| avg | Riduci/Classico | Visualizza la media dei valori |
| min | Riduci/Classic | Visualizza il valore più basso |
| max | Riduci/Classic | Visualizza il valore più alto |
| sum | Riduci/Classic | Visualizza la somma di tutti i valori |
| count | Riduci/Classic | Conta il numero di valori nel risultato |
| last | Riduci/Classic | Visualizza l'ultimo valore |
| median | Riduci/Classic | Visualizza il valore mediano |
| diff | Classic | Visualizza la differenza tra il valore più recente e quello più vecchio |
| diff\$1abs | Classic | Visualizza il valore assoluto di diff |
| percent\$1diff | Classic | Visualizza il valore percentuale della differenza tra il valore più recente e quello più vecchio |
| percent\$1diff\$1abs | Classic | Visualizza il valore assoluto di percent\$1diff |
| count\$1non\$1null | Classic | Visualizza un conteggio di valori nel set di risultati che non lo sono null |
## Condizione di avviso
Una condizione di avviso è l'interrogazione o l'espressione che determina se l'avviso verrà attivato o meno a seconda del valore che produce. Può esserci una sola condizione che determinerà l'attivazione dell'avviso.
Dopo aver definito le and/or espressioni delle interrogazioni, scegline una come condizione della regola di avviso.
Quando i dati richiesti soddisfano la condizione definita, Grafana attiva l'avviso associato, che può essere configurato per inviare notifiche attraverso vari canali come e-mail, Slack o. PagerDuty Le notifiche ti informano sulla condizione soddisfatta, consentendoti di intraprendere le azioni appropriate o di indagare sul problema sottostante.
Per impostazione predefinita, l'ultima espressione aggiunta viene utilizzata come condizione di avviso.
## Soglia di ripristino
Per ridurre il rumore generato dagli avvisi che lampeggiano, è possibile impostare una soglia di ripristino diversa dalla soglia di avviso.
Gli avvisi flapping si verificano quando una metrica si aggira intorno alla soglia di avviso e possono portare a frequenti cambiamenti di stato, con conseguente generazione di troppe notifiche.
Le regole di avviso gestite da Grafana vengono valutate per un intervallo di tempo specifico. Durante ogni valutazione, il risultato della query viene confrontato con la soglia impostata nella regola di avviso. Se il valore di una metrica è superiore alla soglia, viene attivata una regola di avviso e viene inviata una notifica. Quando il valore scende al di sotto della soglia ed è presente un avviso attivo per questa metrica, l'avviso viene risolto e viene inviata un'altra notifica.
Può essere difficile creare una regola di avviso per una metrica rumorosa. Cioè, quando il valore di una metrica supera e scende continuamente al di sopra e al di sotto di una soglia. Questa operazione si chiama flapping e genera una serie di notifiche di attivazione (risolte) e una cronologia dello stato di allarme rumoroso.
Ad esempio, se hai un avviso di latenza con una soglia di 1000 ms e il numero oscilla intorno a 1000 (ad esempio 980 ->1010 -> 990 -> 1020 e così via), ognuna di queste attiverà una notifica.
Per risolvere questo problema, puoi impostare una soglia di ripristino (personalizzata), che in pratica significa avere due soglie anziché una. Un avviso viene attivato quando viene superata la prima soglia e viene risolto solo quando viene superata la seconda soglia.
Ad esempio, è possibile impostare una soglia di 1000 ms e una soglia di ripristino di 900 ms. In questo modo, una regola di avviso smetterà di attivarsi solo quando scende al di sotto di 900 ms e il flapping viene ridotto.
# Istanze di avviso
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
Gli avvisi gestiti Grafana supportano gli avvisi multidimensionali. Ogni regola di avviso può creare più istanze di avviso. Ciò è utile se si osservano più serie in una singola espressione.
Considerate la seguente espressione PromQL:
```
sum by(cpu) (
rate(node_cpu_seconds_total{mode!="idle"}[1m])
)
```
Una regola che utilizza questa espressione creerà tante istanze di avviso quante ne CPUs osserviamo dopo la prima valutazione, permettendo a una singola regola di riportare lo stato di ogni CPU.
# Namespace, cartelle e gruppi
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
Gli avvisi possono essere organizzati utilizzando cartelle per le regole gestite da Grafana e i namespace per le regole e i nomi dei gruppi di Mimir, Loki o Prometheus.
**Namespace e cartelle**
Quando si creano regole gestite da Grafana, la cartella può essere utilizzata per eseguire il controllo degli accessi e concedere o negare l'accesso a tutte le regole all'interno di una cartella specifica.
Un namespace contiene uno o più gruppi. Le regole all'interno di un gruppo vengono eseguite in sequenza a intervalli regolari. L'intervallo predefinito è di un minuto. È possibile rinominare i namespace e i gruppi delle regole Grafana Mimi o Loki e modificare gli intervalli di valutazione dei gruppi.
**Groups (Gruppi)**
Le regole all'interno di un gruppo vengono eseguite in sequenza a intervalli regolari, il che significa che nessuna regola verrà valutata contemporaneamente e in ordine di apparizione. L'intervallo predefinito è di un minuto. È possibile rinominare gli spazi dei nomi delle regole Grafana Mimir o Loki o gli spazi dei nomi e i gruppi delle regole Loki e modificare gli intervalli di valutazione dei gruppi.
**Suggerimento**
Se desideri che le regole vengano valutate contemporaneamente e con intervalli diversi, valuta la possibilità di archiviarle in gruppi diversi.
**Nota**
Le regole di avviso gestite da Grafana vengono valutate contemporaneamente anziché in sequenza.
# Valutazione delle regole di avviso
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
Utilizzate la valutazione delle regole di avviso per determinare la frequenza con cui una regola di avviso deve essere valutata e con quale rapidità deve cambiare il suo stato.
A tale scopo, è necessario assicurarsi che la regola di avviso rientri nel gruppo di valutazione corretto e impostare un periodo di attesa più adatto al caso d'uso.
## Gruppo di valutazione
Ogni regola di avviso fa parte di un gruppo di valutazione. Ogni gruppo di valutazione contiene un intervallo di valutazione che determina la frequenza con cui viene controllata la regola di avviso.
Le regole di avviso **gestite da fonti di dati** all'interno dello stesso gruppo vengono valutate una dopo l'altra, mentre le regole di avviso in gruppi diversi possono essere valutate contemporaneamente. Questa funzionalità è particolarmente utile quando si desidera garantire che le regole di registrazione vengano valutate prima di qualsiasi regola di avviso.
Le regole di avviso **gestite da Grafana** vengono valutate contemporaneamente, indipendentemente dal gruppo di regole di avviso. L'intervallo di valutazione predefinito è impostato su 10 secondi, il che significa che le regole di avviso gestite da Grafana vengono valutate ogni 10 secondi rispetto alla finestra di 10 secondi più vicina sull'orologio, ad esempio 10:00:00, 10:00:10, 10:00:20 e così via. Puoi anche configurare il tuo intervallo di valutazione, se necessario.
**Nota**
I gruppi di valutazione e il raggruppamento degli avvisi nelle politiche di notifica sono due cose distinte. Il raggruppamento in criteri di notifica consente di inviare più avvisi che condividono le stesse etichette nello stesso messaggio temporale.
## Periodo in sospeso
Impostando un periodo di attesa, è possibile evitare avvisi non necessari per problemi temporanei.
Nel periodo in sospeso, si seleziona il periodo in cui una regola di avviso può violare la condizione finché non viene attivata.
**Esempio**
Immagina di avere un intervallo di valutazione delle regole di avviso impostato ogni 30 secondi e il periodo in sospeso su 90 secondi.
La valutazione avverrà nel modo seguente:
[00:30] Prima valutazione: condizione non soddisfatta.
[01:00] Seconda valutazione: condizione violata. Il contatore in sospeso inizia. **L'avviso inizia a essere sospeso.**
[01:30] Terza valutazione: condizione violata. Contatore in sospeso = 30 secondi. **Stato in sospeso.**
[02:00] Quarta valutazione: condizione violata. **Contatore in sospeso = 60. Stato in sospeso.**
[02:30] Quinta valutazione: condizione violata. Contatore pendente = 90. **L'avviso inizia a sparare**
Se la regola di avviso presenta una condizione che deve essere violata per un determinato periodo di tempo prima di agire, il suo stato cambia come segue:
+ Quando la condizione viene violata per la prima volta, la regola passa allo stato «in sospeso».
+ La regola rimane nello stato «in sospeso» fino a quando la condizione non viene violata per il periodo di tempo richiesto (periodo in sospeso).
+ Una volta trascorso il tempo richiesto, la regola passa allo stato di «attivazione».
+ Se la condizione non viene più violata durante il periodo in sospeso, la regola torna allo stato normale.
**Nota**
Se desideri ignorare lo stato in sospeso, puoi semplicemente impostare il periodo in sospeso su 0. In questo modo si salta effettivamente il periodo di attesa e la regola di avviso inizierà a funzionare non appena la condizione viene violata.
Quando viene attivata una regola di avviso, vengono generate istanze di avviso, che vengono quindi inviate all'Alertmanager.
# Stato e integrità delle regole di allarme
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
Lo stato e lo stato di integrità delle regole di avviso consentono di comprendere diversi indicatori chiave di stato relativi agli avvisi.
Esistono tre componenti chiave: stato della *regola di avviso, stato* dell'*istanza di avviso e stato* della *regola di avviso*. Sebbene correlati, ogni componente trasmette informazioni leggermente diverse.
**Stato della regola di avviso**
Una regola di avviso può trovarsi in uno dei seguenti stati:
| Stato | Description |
| --- | --- |
| Normale | Nessuna delle serie temporali restituite dal motore di valutazione è in `Firing` stato `Pending` or. |
| Pending (In attesa) | Almeno una serie temporale restituita dal motore di valutazione è`Pending`. |
| Sparare | Almeno una serie temporale restituita dal motore di valutazione è`Firing`. |
**Nota**
Gli avvisi passeranno prima a `pending` e poi`firing`, quindi occorreranno almeno due cicli di valutazione prima che venga attivato un avviso.
**Stato dell'istanza di avviso**
Un'istanza di avviso può trovarsi in uno dei seguenti stati:
| Stato | Description |
| --- | --- |
| Normale | Lo stato di un avviso che non è né attivo né in sospeso, tutto funziona correttamente. |
| Pending (In attesa) | Lo stato di un avviso che è stato attivo per un periodo inferiore alla durata della soglia configurata. |
| Avviso | Lo stato di un avviso che è stato attivo per un periodo superiore alla durata della soglia configurata. |
| NoData | Non è stato ricevuto alcun dato per la finestra temporale configurata. |
| Errore | L'errore che si è verificato durante il tentativo di valutare una regola di avviso. |
**Mantieni l'ultimo stato**
È possibile configurare una regola di avviso per mantenere l'ultimo stato quando viene rilevato `Error` lo stato `NoData` o. In questo modo si eviterà che gli avvisi vengano attivati e che si risolvano e si riattivino. Proprio come la normale valutazione, la regola di avviso passerà da una `Pending` a una `Firing` volta trascorso il periodo di attesa.
**Stato della regola di avviso**
Una regola di avviso può avere uno dei seguenti stati di integrità:
| Stato | Description |
| --- | --- |
| Ok | Nessun errore durante la valutazione di una regola di avviso. |
| Errore | Si è verificato un errore durante la valutazione di una regola di avviso. |
| NoData | L'assenza di dati in almeno una serie temporale restituita durante la valutazione di una regola. |
**Avvisi speciali per `NoData` e `Error`**
Quando la valutazione di una regola di avviso produce lo stato `NoData` o`Error`, Grafana Alerting genererà istanze di avviso con le seguenti etichette aggiuntive:
| Etichetta | Description |
| --- | --- |
| nome dell'avviso | In uno `DatasourceNoData` o `DatasourceError` in base allo stato. |
| datasource\$1uid | L'UID della fonte di dati che ha causato lo stato. |
È possibile gestire questi avvisi allo stesso modo degli avvisi normali aggiungendo un silenzio, un indirizzamento verso un punto di contatto e così via.
# Modello di notifica
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
Le notifiche inviate tramite punti di contatto vengono create utilizzando modelli di notifica. I modelli predefiniti di Grafana si basano sul [sistema di template Go, in cui alcuni campi vengono valutati come testo, mentre altri vengono valutati come HTML (il che può influire](https://golang.org/pkg/text/template) sull'escape).
Il modello predefinito [default\$1template.go](https://github.com/grafana/alerting/blob/main/templates/default_template.go) è un utile riferimento per i modelli personalizzati.
Poiché la maggior parte dei campi dei punti di contatto può essere modellata, è possibile creare modelli personalizzati riutilizzabili e utilizzarli in più punti di contatto. Per maggiori informazioni sulle notifiche personalizzate tramite modelli, consulta. [Personalizza le notifiche](v10-alerting-manage-notifications.md)
**Modelli annidati**
È possibile incorporare modelli all'interno di altri modelli.
Ad esempio, è possibile definire un frammento di modello utilizzando la `define` parola chiave.
```
{{ define "mytemplate" }}
{{ len .Alerts.Firing }} firing. {{ len .Alerts.Resolved }} resolved.
{{ end }}
```
È quindi possibile incorporare modelli personalizzati all'interno di questo frammento utilizzando la parola chiave. `template` Esempio:
```
Alert summary:
{{ template "mytemplate" . }}
```
È possibile utilizzare una delle seguenti opzioni di modello integrate per incorporare modelli personalizzati.
| Name | Note |
| --- | --- |
| `default.title` | Visualizza informazioni sullo stato di alto livello. |
| `default.message` | Fornisce un riepilogo formattato degli allarmi attivati e risolti. |
| `teams.default.message` | Simile a`default.messsage`, formattato per Microsoft Teams. |
**HTML nei modelli di notifica**
Il codice HTML nei modelli di notifica di avviso non è disponibile. Non supportiamo il rendering del codice HTML nella notifica risultante.
Alcuni notificanti supportano metodi alternativi per modificare l'aspetto della notifica risultante. Ad esempio, Grafana installa il modello base per avvisare le e-mail di. `/public/emails/ng_alert_notification.html` È possibile modificare questo file per cambiare l'aspetto di tutte le e-mail di avviso.
# Gestore degli avvisi
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
Alertmanager consente di gestire e rispondere agli avvisi in modo rapido ed efficiente. Riceve avvisi, gestisce le disattivazioni, l'inibizione, il raggruppamento e il routing inviando notifiche tramite il canale prescelto, ad esempio e-mail o Slack.
In Grafana, puoi usare Grafana Alertmanager o un Alertmanager esterno. Puoi anche utilizzare più gestori di avvisi; la tua decisione dipende dalla configurazione e da dove vengono generati gli avvisi.
**Gestore avvisi Grafana**
Grafana Alertmanager è un Alertmanager interno preconfigurato e disponibile per la selezione per impostazione predefinita.
Grafana Alertmanager può ricevere avvisi da Grafana, ma non può ricevere avvisi dall'esterno di Grafana, ad esempio da Mimir o Loki.
**Nota**
Le regole di inibizione non sono supportate in Grafana Alertmanager.
**Gestore di avvisi esterno**
Se desideri utilizzare un unico gestore di avvisi per ricevere tutti gli avvisi Grafana, Loki, Mimir e Prometheus, puoi configurare Grafana per utilizzare un Alertmanager esterno. Questo Alertmanager esterno può essere configurato e amministrato dall'interno di Grafana stessa.
Ecco due esempi di quando potresti voler configurare il tuo alertmanager esterno e inviare i tuoi avvisi lì invece di Grafana Alertmanager:
1. Disponi già di gestori di avvisi in sede nella tua infrastruttura Cloud che hai configurato e desideri continuare a utilizzare, perché hai altri generatori di avvisi, come Prometheus.
1. Desideri utilizzare sia Prometheus on-premise che Grafana ospitato per inviare avvisi allo stesso gestore di avvisi che funziona nella tua infrastruttura Cloud.
I gestori degli avvisi sono visibili dal menu a discesa delle pagine Avvisi, punti di contatto e Politiche di notifica.
Se stai effettuando il provisioning della tua fonte di dati, imposta il flag `handleGrafanaManagedAlerts` nel `jsonData` campo per inviare avvisi gestiti da Grafana `true` a questo Alertmanager.
# Punti di contatto
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
I punti di contatto contengono la configurazione per l'invio di notifiche. Un punto di contatto è un elenco di integrazioni, ognuna delle quali invia una notifica a un particolare indirizzo e-mail, servizio o URL. I punti di contatto possono avere più integrazioni dello stesso tipo o una combinazione di integrazioni di diverso tipo. Ad esempio, un punto di contatto potrebbe contenere un'integrazione Pagerduty, un'integrazione Amazon SNS e Slack o un'integrazione Pagerduty, un'integrazione Slack e due integrazioni Amazon SNS. Puoi anche configurare un punto di contatto senza integrazioni, nel qual caso non vengono inviate notifiche.
Un punto di contatto non può inviare notifiche finché non è stato aggiunto a una politica di notifica. Una politica di notifica può inviare avvisi solo a un punto di contatto, ma un punto di contatto può essere aggiunto a più politiche di notifica contemporaneamente. Quando un avviso corrisponde a un criterio di notifica, l'avviso viene inviato al punto di contatto in quella politica di notifica, che quindi invia una notifica a ciascuna integrazione nella relativa configurazione.
I punti di contatto possono essere configurati per Grafana Alertmanager e per gestori di avvisi esterni.
Puoi anche utilizzare i modelli di notifica per personalizzare i messaggi di notifica per i tipi di punti di contatto.
**Tipi di punti di contatto supportati**
La tabella seguente elenca i tipi di punti di contatto supportati da Grafana.
| Name | Tipo |
| --- | --- |
| Amazon SNS | `sns` |
| OpsGenie | `opsgenie` |
| Pager Duty | `pagerduty` |
| Slack | `slack` |
| VictorOps | `victorops` |
Per ulteriori informazioni sui punti di contatto, vedere [Configurare i punti di contatto](v10-alerting-configure-contactpoints.md) e[Personalizza le notifiche](v10-alerting-manage-notifications.md).
# Notifications
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
La scelta di come, quando e dove inviare le notifiche di avviso è una parte importante della configurazione del sistema di avviso. Queste decisioni avranno un impatto diretto sulla vostra capacità di risolvere rapidamente i problemi e di non tralasciare nulla di importante.
Come primo passo, definisci i tuoi [punti di contatto](v10-alerting-explore-contacts.md), che definiscono dove inviare le notifiche di avviso. Un punto di contatto è un insieme di una o più integrazioni utilizzate per inviare notifiche. Aggiungi modelli di notifica ai punti di contatto per riutilizzarli e inviare messaggi coerenti nelle notifiche.
Successivamente, crea una politica di notifica che consiste in un insieme di regole per stabilire dove, quando e come gli avvisi vengono indirizzati ai punti di contatto. In una politica di notifica, definisci dove inviare le notifiche di avviso scegliendo uno dei punti di contatto che hai creato.
## Gestori di avvisi
Grafana utilizza Alertmanager per inviare notifiche di attivazione e avvisi risolti. [Grafana ha il proprio Alertmanager, denominato **Grafana** nell'interfaccia utente, ma supporta anche l'invio di notifiche da altri Alertmanager, come Prometheus Alertmanager.](https://prometheus.io/docs/alerting/latest/alertmanager/) Grafana Alertmanager utilizza politiche di notifica e punti di contatto per configurare come e dove inviare una notifica, con quale frequenza deve essere inviata una notifica e se gli avvisi devono essere inviati tutti nella stessa notifica, inviati in notifiche raggruppate sulla base di un set di etichette o come notifiche separate.
## Politiche di notifica
Le politiche di notifica controllano quando e dove vengono inviate le notifiche. Una politica di notifica può scegliere di inviare tutti gli avvisi insieme nella stessa notifica, inviare avvisi in notifiche raggruppate in base a un set di etichette o inviare avvisi come notifiche separate. È possibile configurare ogni politica di notifica per controllare la frequenza di invio delle notifiche e disporre di uno o più orari di silenziamento per inibire le notifiche in determinate ore del giorno e in determinati giorni della settimana.
Le politiche di notifica sono organizzate in una struttura ad albero in cui alla radice dell'albero è presente una politica di notifica chiamata politica predefinita. Può esserci solo una politica predefinita e la politica predefinita non può essere eliminata.
Le politiche di routing specifiche sono figli della politica principale e possono essere utilizzate per abbinare tutti gli avvisi o un sottoinsieme di avvisi in base a un set di etichette corrispondenti. Una politica di notifica corrisponde a un avviso quando le etichette corrispondenti corrispondono alle etichette dell'avviso.
Una politica annidata può avere le proprie politiche annidate, che consentono un'ulteriore corrispondenza degli avvisi. Un esempio di policy annidata potrebbe essere l'invio di avvisi di infrastruttura al team Ops; mentre una policy secondaria potrebbe inviare avvisi ad alta priorità a Pagerduty e avvisi a bassa priorità a Slack.
Tutti gli avvisi, indipendentemente dalle etichette, corrispondono alla politica predefinita. Tuttavia, quando la politica predefinita riceve un avviso, esamina ogni politica annidata e invia l'avviso alla prima politica nidificata che corrisponde all'avviso. Se la politica annidata include ulteriori politiche annidate, può tentare di abbinare l'avviso a una delle sue politiche nidificate. Se nessuna politica annidata corrisponde all'avviso, la politica stessa è la politica corrispondente. Se non ci sono politiche nidificate o nessuna politica nidificata corrisponde all'avviso, la politica predefinita è la politica corrispondente.
Per informazioni più dettagliate sulle politiche di notifica, vedere. [Politiche di notifica](v10-alerting-explore-notifications-policies-details.md)
## Modelli di notifica
Puoi personalizzare le notifiche con modelli. Ad esempio, i modelli possono essere utilizzati per modificare il titolo e il messaggio delle notifiche inviate a Slack.
I modelli non si limitano a una singola integrazione o a un singolo punto di contatto, ma possono essere utilizzati in diverse integrazioni nello stesso punto di contatto e persino in integrazioni tra diversi punti di contatto. Ad esempio, un utente Grafana può creare un modello chiamato `custom_subject_or_title` e utilizzarlo sia per gli argomenti dei modelli in Pager Duty che per i titoli dei messaggi Slack senza dover creare due modelli separati.
Tutti i modelli di notifica sono scritti nel [linguaggio dei modelli di Go](https://pkg.go.dev/text/template) e si trovano nella scheda Punti di contatto della pagina Avvisi.
Per informazioni più dettagliate sulla personalizzazione delle notifiche, consulta. [Personalizza le notifiche](v10-alerting-manage-notifications.md)
## Silenzi
Puoi usare i silenzi per disattivare le notifiche provenienti da una o più regole di attivazione. I silenzi non impediscono che gli avvisi si attivino o vengano risolti, né nascondono gli avvisi di attivazione nell'interfaccia utente. Un silenzio dura quanto la sua durata, che può essere configurata in minuti, ore, giorni, mesi o anni.
Per informazioni più dettagliate sull'uso dei silenzi, vedere[Silenziamento delle notifiche di avviso](v10-alerting-silences.md).
# Politiche di notifica
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
Le politiche di notifica offrono un modo flessibile per indirizzare gli avvisi a vari ricevitori diversi. Utilizzando label matchers, puoi modificare l'invio delle notifiche di avviso senza dover aggiornare ogni singola regola di avviso.
In questa sezione, scoprirai di più su come funzionano e sono strutturate le politiche di notifica, in modo da poter sfruttare al massimo la configurazione delle politiche di notifica.
## Albero delle politiche
Le politiche di notifica *non* sono un elenco, ma sono strutturate secondo una struttura ad albero. Ciò significa che ogni policy può avere policy secondarie e così via. La radice dell'albero dei criteri di notifica è denominata **Politica di notifica predefinita**.
Ogni policy è costituita da una serie di abbinatori di etichette (0 o più) che specificano quali etichette sono o non sono interessati a gestire.
Per ulteriori informazioni sulla corrispondenza delle etichette, consulta[Come funziona l'abbinamento delle etichette](v10-alerting-overview-labels-matching.md).
**Nota**
Se non hai configurato alcun abbinatore di etichette per la tua politica di notifica, la politica di notifica corrisponderà a *tutte le* istanze di avviso. Ciò potrebbe impedire la valutazione delle politiche relative ai minori a meno che tu non abbia abilitato **Continua ad abbinare fratelli** nella politica di notifica.
## Routing
Per determinare quale politica di notifica gestirà quali istanze di avviso, devi iniziare esaminando il set esistente di politiche di notifica, a partire dalla politica di notifica predefinita.
Se non sono configurate politiche diverse dalla politica predefinita, la politica predefinita gestirà l'istanza di avviso.
Se vengono definite politiche diverse da quelle predefinite, verranno valutate tali politiche di notifica nell'ordine in cui vengono visualizzate.
Se una politica di notifica contiene criteri di abbinamento delle etichette che corrispondono alle etichette dell'istanza di avviso, passerà alle relative politiche secondarie e, se presenti, continuerà a cercare eventuali criteri secondari che potrebbero avere abbinatori di etichette che restringono ulteriormente il set di etichette e così via fino a quando non saranno più disponibili criteri secondari.
Se nessun criterio figlio è definito in un criterio di notifica o se nessuno dei criteri figlio ha abbinamenti di etichette che corrispondono alle etichette dell'istanza di avviso, viene utilizzato il criterio di notifica principale.
Non appena viene trovata una politica corrispondente, il sistema non continua a cercare altre politiche corrispondenti. Se desideri continuare a cercare altre politiche che potrebbero corrispondere, abilita **Continua ad abbinare i fratelli** in base a quella particolare politica.
Infine, se nessuna delle politiche di notifica è selezionata, viene utilizzata la politica di notifica predefinita.
### Esempio di routing
Ecco un esempio di un albero di policy di notifica relativamente semplice e di alcune istanze di avviso.
![\[Un'immagine che mostra una serie di politiche di notifica in una struttura ad albero e una serie di istanze di avviso con etichette diverse da abbinare alle politiche.\]](http://docs.aws.amazon.com/it_it/grafana/latest/userguide/images/notification-routing.png)
Ecco un'analisi dettagliata di come vengono selezionate queste politiche:
**Pod stuck in CrashLoop** non ha un'`severity`etichetta, quindi nessuna delle sue politiche per bambini corrisponde. Ha un'`team=operations`etichetta, quindi la prima politica corrisponde.
La `team=security` politica non viene valutata poiché abbiamo già trovato una corrispondenza e **Continue matching siblings** non è stata configurata per quella politica.
**Utilizzo del disco: l'80%** ha `team` sia un'`severity`etichetta che corrisponde a una politica secondaria del team operativo.
La **voce di registro non autorizzata** ha un'`team`etichetta ma non corrisponde alla prima policy (`team=operations`) poiché i valori non sono gli stessi, quindi continuerà a cercare e corrisponderà alla `team=security` policy. Non ha criteri secondari, quindi l'`severity=high`etichetta aggiuntiva viene ignorata.
## Ereditarietà
Oltre a essere un concetto utile per indirizzare le istanze di avviso, le politiche secondarie ereditano anche le proprietà dalla politica principale. Ciò vale anche per tutte le politiche che sono politiche secondarie della politica di notifica predefinita.
Le seguenti proprietà vengono ereditate dalle politiche secondarie:
+ Punto di contatto
+ Opzioni di raggruppamento
+ Opzioni di tempistica
+ Tempi di silenziamento
Ognuna di queste proprietà può essere sovrascritta da una singola politica se si desidera sovrascrivere le proprietà ereditate.
Per ereditare un punto di contatto dalla politica principale, lasciala vuota. **Per ignorare le opzioni di raggruppamento ereditate, abilita Ignora raggruppamento.** **Per sovrascrivere le opzioni di temporizzazione ereditate, abilita Sovrascrivi i tempi generali.**
### Esempio di ereditarietà
L'esempio seguente mostra come l'albero delle politiche di notifica del nostro esempio precedente consenta alle politiche secondarie di `team=operations` ereditare il proprio punto di contatto.
In questo modo, possiamo evitare di dover specificare lo stesso punto di contatto più volte per ogni politica sui minori.
![\[Un'immagine che mostra una serie di politiche di notifica in una struttura ad albero, con punti di contatto assegnati ad alcune politiche, ma con alcune politiche per bambini che ereditano i punti di contatto dei genitori, anziché definire i propri.\]](http://docs.aws.amazon.com/it_it/grafana/latest/userguide/images/notification-inheritance.png)
## Opzioni di configurazione aggiuntive
### Raggruppamento
Il raggruppamento è una funzionalità importante di Grafana Alerting in quanto consente di raggruppare gli avvisi pertinenti in un numero inferiore di notifiche. Ciò è particolarmente importante se le notifiche vengono inviate ai primi soccorritori, come i tecnici di guardia, dove ricevere molte notifiche in un breve periodo di tempo può essere difficile e in alcuni casi può influire negativamente sulla capacità del primo soccorritore di rispondere a un incidente. Ad esempio, si consideri un'interruzione di corrente di grandi dimensioni in cui molti sistemi sono inattivi. In questo caso, il raggruppamento può fare la differenza tra ricevere 1 telefonata e 100 telefonate.
Puoi scegliere come raggruppare gli avvisi utilizzando l'opzione Raggruppa per in una politica di notifica. Per impostazione predefinita, le politiche di notifica in Grafana raggruppano gli avvisi per regola di avviso utilizzando le `grafana_folder` etichette `alertname` e (poiché i nomi degli avvisi non sono univoci in più cartelle). Se desideri raggruppare gli avvisi in base a qualcosa di diverso dalla regola di avviso, modifica il raggruppamento in base a qualsiasi altra combinazione di etichette.
#### Disabilita il raggruppamento
Se desideri ricevere ogni avviso come notifica separata, puoi farlo raggruppandoli in base a un'etichetta speciale chiamata. `...` Ciò è utile quando gli avvisi vengono inviati a un sistema automatizzato anziché a un primo soccorritore.
#### Un unico gruppo per tutti gli avvisi
Se desideri ricevere tutti gli avvisi insieme in un'unica notifica, puoi farlo lasciando vuoto il campo Raggruppa.
### Opzioni di temporizzazione
Le opzioni di tempistica determinano la frequenza di invio delle notifiche per ogni gruppo di avvisi. È necessario conoscere tre timer: Attesa di gruppo, Intervallo di gruppo e Intervallo di ripetizione.
#### Attesa di gruppo
L'attesa di gruppo è la quantità di tempo che Grafana attende prima di inviare la prima notifica per un nuovo gruppo di avvisi. Maggiore è l'attesa di gruppo, maggiore è il tempo a disposizione per l'arrivo di altri avvisi. Più breve è l'attesa di gruppo, tanto prima verrà inviata la prima notifica, ma con il rischio di inviare notifiche incomplete. Dovresti sempre scegliere un'attesa di gruppo più adatta al tuo caso d'uso.
**Impostazione predefinita**: 30 secondi
#### Intervallo di gruppo
Una volta inviata la prima notifica per un nuovo gruppo di avvisi, Grafana avvia il timer a intervalli di gruppo. Questo è il periodo di tempo che Grafana attende prima di inviare notifiche sulle modifiche al gruppo. Ad esempio, un altro avviso di attivazione potrebbe essere appena stato aggiunto al gruppo mentre un avviso esistente potrebbe essere stato risolto. Se un avviso è arrivato troppo tardi per essere incluso nella prima notifica a causa dell'attesa di gruppo, verrà incluso nelle notifiche successive dopo l'intervallo di gruppo. Una volta trascorso l'intervallo di gruppo, Grafana ripristina il timer degli intervalli di gruppo. Questo si ripete finché non ci sono più avvisi nel gruppo, dopodiché il gruppo viene eliminato.
**Impostazione predefinita**: 5 minuti
#### Intervallo di ripetizione
L'intervallo di ripetizione determina la frequenza con cui le notifiche vengono ripetute se il gruppo non è cambiato dall'ultima notifica. Puoi considerarle come promemoria del fatto che alcuni avvisi sono ancora attivi. L'intervallo di ripetizione è strettamente correlato all'intervallo di gruppo, il che significa che l'intervallo di ripetizione non deve essere solo maggiore o uguale all'intervallo di gruppo, ma deve anche essere un multiplo dell'intervallo di gruppo. Se l'intervallo di ripetizione non è un multiplo dell'intervallo di gruppo, verrà forzato a formare un unico intervallo. Ad esempio, se l'intervallo di ripetizione è di 5 minuti e l'intervallo di ripetizione è di 9 minuti, l'intervallo di ripetizione verrà arrotondato al multiplo di 5 più vicino, ovvero 10 minuti.
**Impostazione predefinita: 4 ore**
# Avvisi relativi all'elevata disponibilità
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 10.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 9.x di Grafana, vedere. [Lavorare nella versione 9 di Grafana](using-grafana-v9.md)
Per le aree di lavoro Grafana che supportano la versione 8.x di Grafana, vedere. [Funzionamento in Grafana versione 8](using-grafana-v8.md)
Amazon Managed Grafana è configurato per l'alta disponibilità, inclusa l'esecuzione di più istanze su più zone di disponibilità per ogni area di lavoro che crei.
Grafana Alerting utilizza il modello Prometheus per separare la valutazione delle regole di avviso dall'invio delle notifiche. In questo modello, la valutazione delle regole di avviso viene eseguita nel generatore di avvisi e l'invio delle notifiche avviene nel ricevitore degli avvisi. In Grafana Alerting, il generatore di avvisi è lo Scheduler e il ricevitore è l'Alertmanager.
Con le configurazioni ad alta disponibilità, tutte le regole di avviso vengono valutate in tutte le istanze. Si può pensare alla valutazione delle regole di avviso come a una duplicazione. In questo modo Grafana Alerting assicura che finché almeno un'istanza Grafana funziona, le regole di avviso vengano comunque valutate e le notifiche per gli avvisi vengano comunque inviate. Vedrai questa duplicazione nella cronologia dello stato ed è un buon modo per capire se stai utilizzando l'alta disponibilità.