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à.
# Avvisi nella versione 9 di Grafana
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 Grafana ti forniscono avvisi affidabili e utilizzabili che ti aiutano a conoscere i problemi nei sistemi subito dopo che si sono verificati, riducendo al minimo l'interruzione dei tuoi servizi.
Amazon Managed Grafana include l'accesso a un sistema di avvisi aggiornato, *Grafana alerting, che centralizza le informazioni sugli avvisi* in un'unica visualizzazione ricercabile. Include le seguenti funzionalità:
+ Crea e gestisci avvisi Grafana in una vista centralizzata.
+ Crea e gestisci avvisi gestiti da Cortex e Loki tramite un'unica interfaccia.
+ Visualizza le informazioni sugli avvisi da Prometheus, Amazon Managed Service for Prometheus e altre fonti di dati compatibili con Alertmanager.
Quando crei il tuo spazio di lavoro Amazon Managed Grafana, puoi scegliere se utilizzare gli avvisi Grafana o il. [Avvisi classici del pannello di controllo](old-alerts-overview.md) Questa sezione tratta gli avvisi Grafana.
**Nota**
Se hai creato il tuo spazio di lavoro con gli avvisi classici abilitati e desideri passare agli avvisi Grafana, puoi [passare](v9-alerting-use-grafana-alerts.md) da un sistema di avviso all'altro. .
## Limitazioni degli avvisi Grafana
+ Il sistema di avvisi Grafana può recuperare le regole da tutte le fonti di dati Amazon Managed Service per Prometheus, Prometheus, Loki e Alertmanager disponibili. Potrebbe non essere in grado di recuperare le regole da altre fonti di dati supportate.
+ Le regole di avviso definite in Grafana, anziché in Prometheus, inviano più notifiche al tuo punto di contatto. Se utilizzi avvisi Grafana nativi, ti consigliamo di continuare con gli avvisi Grafana classici e di non abilitare la nuova funzionalità di avviso Grafana. Se desideri visualizzare gli avvisi definiti nella tua fonte di dati Prometheus, ti consigliamo di abilitare Grafana Alerting, che invia una sola notifica per gli avvisi creati in Prometheus Alertmanager.
**Nota**
Questa limitazione non è più una limitazione nelle aree di lavoro Amazon Managed Grafana che supportano Grafana v10.4 e versioni successive.
**Topics**
+ [Limitazioni degli avvisi Grafana](#v9-alert-limitations)
+ [Panoramica di](v9-alerting-overview.md)
+ [Esplorazione degli avvisi](v9-alerting-explore.md)
+ [Configurare gli avvisi](v9-alerting-setup.md)
+ [Migrazione degli avvisi della dashboard classica agli avvisi Grafana](v9-alerting-use-grafana-alerts.md)
+ [Gestisci le tue regole di avviso](v9-alerting-managerules.md)
+ [Gestisci le notifiche di avviso](v9-alerting-managenotifications.md)
# Panoramica di
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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)
Quanto segue offre una panoramica di come funziona Grafana Alerting e presenta alcuni dei concetti chiave che interagiscono e costituiscono il fulcro del suo motore di avvisi flessibile e potente.
1. **Origine dati**
Si connette ai dati da utilizzare tramite avvisi. Questi dati sono spesso dati di serie temporali, servono per avvisi e mostrano i dettagli di un sistema da monitorare e analizzare. Per ulteriori informazioni, consulta le fonti di [dati](AMG-data-sources-builtin.md).
1. **Regole di avviso**
Imposta i criteri di valutazione che determinano se un'istanza di avviso verrà attivata. Una regola di avviso è costituita da una o più query ed espressioni per estrarre dati dall'origine dati, da una condizione che descrive la necessità di un avviso, la frequenza di valutazione e, facoltativamente, la durata per cui la condizione deve essere soddisfatta affinché venga attivato un avviso.
Gli avvisi gestiti Grafana supportano gli avvisi multidimensionali, il che significa che ogni regola di avviso può creare più istanze di avviso. Questo è eccezionalmente potente se si osservano più serie in una singola espressione.
1. **Etichette**
Abbina una regola di avviso e le relative istanze alle politiche di notifica e ai silenzi. Possono essere utilizzati anche per raggruppare gli avvisi in base alla gravità.
1. **Politiche di notifica**
Imposta dove, quando e come vengono indirizzati gli avvisi per avvisare il team quando viene attivato l'avviso. Ogni politica di notifica specifica una serie di etichette corrispondenti per indicare di quali avvisi è responsabile. A una politica di notifica è assegnato un punto di contatto costituito da uno o più notificanti.
1. **Punti di contatto**
Definisci in che modo i tuoi contatti vengono avvisati quando viene attivato un avviso. Supportiamo una moltitudine di ChatOps strumenti per garantire che gli avvisi arrivino al tuo team.
## Funzionalità
**Una pagina per tutti gli avvisi**
Un'unica pagina Grafana Alerting consolida sia gli avvisi gestiti da Grafana che gli avvisi che risiedono nella fonte di dati compatibile con Prometheus in un unico posto.
**Avvisi multidimensionali**
Le regole di avviso possono creare più istanze di avviso individuali per regola di avviso, note come avvisi multidimensionali, offrendoti la potenza e la flessibilità necessarie per ottenere visibilità sull'intero sistema con un solo avviso.
**Avvisi di routing**
Indirizza ogni istanza di avviso verso un punto di contatto specifico in base alle etichette che definisci. Le politiche di notifica sono l'insieme di regole relative a dove, quando e come gli avvisi vengono indirizzati ai punti di contatto.
**Silenziamento degli avvisi**
I silenzi consentono di interrompere la ricezione di notifiche persistenti da una o più regole di avviso. È inoltre possibile sospendere parzialmente un avviso in base a determinati criteri. Silences dispone di una sezione dedicata per una migliore organizzazione e visibilità, in modo da poter scansionare le regole degli avvisi in pausa senza ingombrare la visualizzazione principale degli avvisi.
**Tempi di silenziamento**
Con gli orari di silenziamento, puoi specificare un intervallo di tempo in cui non desideri che vengano generate o inviate nuove notifiche. Puoi anche bloccare le notifiche di avviso per periodi di tempo ricorrenti, ad esempio durante un periodo di manutenzione.
# Esplorazione degli avvisi
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 stia iniziando o espandendo l'implementazione di Grafana Alerting, scopri di più sui concetti chiave e sulle funzionalità disponibili che ti aiutano a creare, gestire e agire sui tuoi avvisi e a migliorare la capacità del tuo team di risolvere rapidamente i problemi.
Prima di tutto, diamo un'occhiata ai diversi tipi di regole di avviso offerti da Grafana Alerting.
## Tipi di regole di avviso
**Regole gestite da Grafana**
Le regole gestite da Grafana sono il tipo di regola di avviso più flessibile. Ti consentono di creare avvisi che possono agire sui dati provenienti da qualsiasi delle nostre fonti di dati supportate. Oltre a supportare più fonti di dati, puoi anche aggiungere espressioni per trasformare i dati e impostare condizioni di avviso. Questo è l'unico tipo di regola che consente di inviare avvisi da più fonti di dati in un'unica definizione di regola.
**Regole di Mimir e Loki**
Per creare avvisi Mimir o Loki 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 del righello è supportata.
**Regole di registrazione**
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.
## Concetti e caratteristiche chiave
La tabella seguente include un elenco di concetti chiave, funzionalità e relative definizioni, progettato per aiutarti a sfruttare al meglio gli avvisi Grafana.
| Concetto o funzionalità chiave | Definizione |
| --- | --- |
| Fonti di dati per gli avvisi | Seleziona le fonti di dati da cui desideri interrogare e visualizzare metriche, log e tracce. |
| Fornitura di avvisi | Gestisci le tue risorse di avviso e inseriscile nel tuo sistema Grafana utilizzando il provisioning dei file o Terraform. |
| Gestore degli avvisi | Gestisce il routing e il raggruppamento delle istanze di avviso. |
| Regola di avviso | Una serie di criteri di valutazione per stabilire quando una regola di avviso deve essere attivata. Una regola di avviso è costituita da una o più interrogazioni ed espressioni, da una condizione, dalla frequenza di valutazione e dalla durata della soddisfazione della condizione. Una regola di avviso può generare più istanze di avviso. |
| Istanza di avviso | Un'istanza di avviso è un'istanza di una regola di avviso. Una regola di avviso monodimensionale ha un'istanza di avviso. Una regola di avviso multidimensionale ha una o più istanze di avviso. Una singola regola di avviso che corrisponde a più risultati, ad esempio CPU contro 10 VMs, viene contata come istanze di avviso multiple (in questo caso 10). Questo numero può variare nel tempo. Ad esempio, una regola di avviso che monitora l'utilizzo della CPU per tutti gli utenti VMs di un sistema include più istanze di avviso man mano che VMs vengono aggiunte. Per ulteriori informazioni sulle quote di istanze di avviso, vedere. [Errori relativi alla quota raggiunta](v9-alerting-managerules-grafana.md#v9-alerting-rule-quota-reached) |
| Gruppo di avvisi | Alertmanager raggruppa le istanze di avviso per impostazione predefinita utilizzando le etichette per la politica di notifica principale. Questo controlla la deduplicazione e i gruppi di istanze di avviso, che vengono inviate ai punti di contatto. |
| Punto di contatto | Definisci in che modo i tuoi contatti vengono avvisati quando viene attivata una regola di avviso. |
| Modello di messaggio | Crea modelli personalizzati riutilizzabili e usali nei punti di contatto. |
| Politica di notifica | Set di regole per dove, quando e come gli avvisi vengono raggruppati e indirizzati ai punti di contatto. |
| Etichette e abbinatori di etichette | Le etichette identificano in modo univoco le regole di avviso. Collegano le regole di avviso alle politiche e ai silenzi di notifica, determinando quale politica deve gestirle e quali regole di avviso devono essere silenziate. |
| Silenzi | Blocca le notifiche provenienti da una o più istanze di avviso. La differenza tra un intervallo di silenzio e uno di silenziamento è che un silenzio dura solo per un periodo di tempo specificato, mentre un intervallo di silenziamento è pensato per essere ricorrente in base a una pianificazione. Utilizza gli abbinatori di etichette per silenziare le istanze di avviso. |
| Tempi di silenziamento | Specificate un intervallo di tempo in cui non desiderate che vengano generate o inviate nuove notifiche. Puoi anche bloccare le notifiche di avviso per periodi di tempo ricorrenti, ad esempio durante un periodo di manutenzione. Deve essere collegato a una politica di notifica esistente. |
# Origini dati
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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](AMG-data-sources-builtin.md) compatibili con Grafana Alerting. Ogni fonte di dati è supportata da un plugin. Puoi utilizzare una delle fonti di dati integrate elencate di seguito.
Queste sono le fonti di dati compatibili e supportate da Amazon Managed Grafana.
+ [Connect a un'origine dati Alertmanager](data-source-alertmanager.md)
+ [Connect a una fonte di CloudWatch dati Amazon](using-amazon-cloudwatch-in-AMG.md)
+ [Connect a una fonte OpenSearch di dati Amazon Service](using-Amazon-OpenSearch-in-AMG.md)
+ [Connect a un'origine AWS IoT SiteWise dati](using-iotsitewise-in-AMG.md)
+ [Connect a una fonte di AWS IoT TwinMaker dati](AMG-iot-twinmaker.md)
+ [Connect ad Amazon Managed Service for Prometheus e alle fonti di dati Prometheus open source](prometheus-data-source.md)
+ [Connettiti a una fonte di dati Amazon Timestream](timestream-datasource.md)
+ [Connect a una fonte di dati Amazon Athena](AWS-Athena.md)
+ [Connect a una fonte di dati Amazon Redshift](AWS-Redshift.md)
+ [Connect a un'origine AWS X-Ray dati](x-ray-data-source.md)
+ [Connect a un'origine dati di Azure Monitor](using-azure-monitor-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 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)
# Informazioni sulle regole di avviso
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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, facoltativamente, la durata per la quale la condizione viene soddisfatta.
Mentre le interrogazioni e le espressioni selezionano il set di dati da valutare, una condizione imposta la soglia che un avviso deve 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](v9-alerting-explore-rules-types.md)
+ [Istanze di avviso](v9-alerting-rules-instances.md)
+ [Namespace e gruppi](v9-alerting-rules-grouping.md)
+ [Modello di notifica](v9-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 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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. Le seguenti sezioni ne spiegheranno i vantaggi e gli inconvenienti e ti aiuteranno a scegliere il tipo di avviso giusto per il tuo caso d'uso.
Regole gestite da Grafana
Le regole gestite da 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 qualsiasi fonte di dati, puoi aggiungere [espressioni](v9-panels-query-xform-expressions.md) per trasformare i dati ed esprimere le condizioni di avviso.
Regole di Mimir, Loki e Cortex
Per creare avvisi Mimir, Loki o Cortex devi disporre di un'origine dati Prometheus compatibile. Puoi verificare se la tua fonte di dati è compatibile testandola e controllando i dettagli se l'API del righello è supportata.
Regole di registrazione
Le regole di registrazione sono disponibili solo per fonti di dati Prometheus compatibili come Mimir, Loki e Cortex.
Una regola di registrazione consente di salvare il risultato di un'espressione in un nuovo set di serie temporali. Ciò è utile se desideri eseguire avvisi su dati aggregati o se disponi di dashboard che interrogano ripetutamente la stessa espressione.
Scopri di più sulle [regole di registrazione](https://prometheus.io/docs/prometheus/latest/configuration/recording_rules/) in Prometheus.
# Istanze di avviso
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 sono CPUs state osservate durante la valutazione, permettendo a un'unica regola di riportare lo stato di ogni CPU.
# Namespace e gruppi
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 regole e namespace gestiti da Folders for Grafana per le regole e i nomi dei gruppi di Mimir, Loki o Prometheus.
**Spazi dei nomi**
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.
**Groups (Gruppi)**
**Tutte le regole all'interno di un gruppo vengono valutate allo stesso intervallo.**
Le regole di avviso e le regole di registrazione all'interno di un gruppo verranno sempre valutate **in sequenza**, il che significa che nessuna regola verrà valutata contemporaneamente e in ordine di apparizione.
**Suggerimento**
Se desideri che le regole vengano valutate contemporaneamente e con intervalli diversi, valuta la possibilità di archiviarle in gruppi diversi.
# Modello di notifica
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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](v9-alerting-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.
# Avvisi su dati numerici
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 della 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 query viene utilizzata come **condizione** in una regola di avviso, verrà inviata un'allerta con valori diversi 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 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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](v9-alerting-explore-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.](v9-alerting-explore-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.](v9-alerting-explore-labels-templating.md)
# Come funziona l'abbinamento delle etichette
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 matchers è 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 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.
**Scenario di 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.
# Etichette in Grafana Alerting
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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.](v9-alerting-managerules.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 a partire da `grafana_` essa, può essere sovrascritta in caso di collisione.
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 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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, crei modelli di etichette e annotazioni proprio come faresti in Prometheus. Se hai già usato Prometheus, dovresti conoscere le variabili `$value` and, che contengono le etichette e `$labels` il valore dell'avviso. È possibile utilizzare le stesse variabili in Grafana, anche se l'avviso non utilizza un'origine dati Prometheus. Se non hai mai usato Prometheus prima, non preoccuparti perché ognuna di queste variabili e come modellarle ti verranno spiegate mentre segui il resto di questa pagina.
## Il linguaggio di template di Go
[I modelli per etichette e annotazioni sono scritti nel linguaggio di template di Go, text/template.](https://pkg.go.dev/text/template)
**Tag di apertura e chiusura**
In text/template, i modelli iniziano `{{` e finiscono con `}}` indipendentemente dal fatto che il modello stampi una variabile o esegua strutture di controllo come le istruzioni if. Questo è diverso da altri linguaggi di template come Jinja, dove la stampa di una variabile utilizza `{{` e e le strutture di controllo utilizzano e`}}`. `{%` `%}`
**Print (Stampa)**
Per stampare il valore di qualcosa usa e. `{{` `}}` È possibile stampare il risultato di una funzione o il valore di una variabile. Ad esempio, per stampare la `$labels` variabile devi scrivere quanto segue:
```
{{ $labels }}
```
**Iterate sulle etichette**
Per iterare su ogni etichetta `$labels` puoi usare un. `range` Qui `$k` si riferisce al nome e `$v` al valore dell'etichetta corrente. Ad esempio, se la tua query restituisse un'etichetta`instance=test`, allora `$k` lo sarebbe `instance` e `$v` lo sarebbe`test`.
```
{{ range $k, $v := $labels }}
{{ $k }}={{ $v }}
{{ end }}
```
## Le variabili labels, value e values
**La variabile labels**
La `$labels` variabile contiene le etichette della query. Ad esempio, una query che verifica se un'istanza è inattiva potrebbe restituire un'etichetta di istanza con il nome dell'istanza inattiva. Ad esempio, supponiamo di avere una regola di avviso che si attiva quando una delle istanze rimane inattiva per più di 5 minuti. Desideri aggiungere un riepilogo all'avviso che indichi quale istanza è inattiva. Con la `$labels` variabile, puoi creare un riepilogo che stampa l'etichetta dell'istanza nel riepilogo:
```
Instance {{ $labels.instance }} has been down for more than 5 minutes
```
**Etichette con punti**
Se l'etichetta che desideri stampare contiene un punto (punto o punto) nel nome, l'utilizzo dello stesso punto nel modello non funzionerà:
```
Instance {{ $labels.instance.name }} has been down for more than 5 minutes
```
Questo perché il modello sta tentando di utilizzare un campo inesistente chiamato `name` in. `$labels.instance` Dovresti invece usare la `index` funzione, che stampa l'etichetta `instance.name` nella `$labels` variabile:
```
Instance {{ index $labels "instance.name" }} has been down for more than 5 minutes
```
**La variabile value**
La `$value` variabile funziona in modo diverso da Prometheus. In `$value` Prometheus è presente un numero in virgola mobile contenente il valore dell'espressione, mentre in Grafana è una stringa contenente le etichette e i valori di tutte le espressioni Threshold, Reduce e Math e Classic Conditions per questa regola di avviso. Non contiene i risultati delle interrogazioni, in quanto possono restituire da 10 a 10.000 righe o metriche.
Se dovessi utilizzare la `$value` variabile nel riepilogo di un avviso:
```
{{ $labels.service }} has over 5% of responses with 5xx errors: {{ $value }})
```
Il riepilogo potrebbe essere simile al seguente:
```
api has an over 5% of responses with 5xx errors: [ var='B' labels={service=api} value=6.789 ]
```
Qui `var='B'` si fa riferimento all'espressione con RefID B. In Grafana, tutte le interrogazioni e le espressioni sono identificate da un RefID che identifica ogni query ed espressione in una regola di avviso. Analogamente `labels={service=api}` si riferisce alle etichette e si riferisce al valore. `value=6.789`
Avrete notato che non esiste un RefID A. Questo perché nella maggior parte delle regole di avviso il RefID A fa riferimento a una query e poiché le query possono restituire molte righe o serie temporali in cui non sono incluse. `$value`
**La variabile values**
Se la `$value` variabile contiene più informazioni del necessario, è possibile invece stampare le etichette e il valore delle singole espressioni utilizzando`$values`. Al contrario`$value`, la `$values` variabile è una tabella di oggetti contenente le etichette e i valori in virgola mobile di ciascuna espressione, indicizzati in base al relativo RefID.
Se dovessi stampare il valore dell'espressione con refID nel riepilogo `B` dell'avviso:
```
{{ $labels.service }} has over 5% of responses with 5xx errors: {{ $values.B }}%
```
Il riepilogo conterrà solo il valore:
```
api has an over 5% of responses with 5xx errors: 6.789%
```
Tuttavia, mentre `{{ $values.B }}` stampa il numero 6.789, in realtà si tratta di una stringa, poiché si stampa l'oggetto, che contiene sia le etichette che il valore per RefID B, non il valore in virgola mobile di B. Per utilizzare il valore a virgola mobile di RefID B è necessario utilizzare il campo da. `Value` `$values.B` Se dovessi umanizzare il valore in virgola mobile nel riepilogo di un avviso:
```
{{ $labels.service }} has over 5% of responses with 5xx errors: {{ humanize $values.B.Value }}%
```
**Nessun dato, errori di runtime e timeout**
Se la query inclusa nella regola di avviso non restituisce dati o ha esito negativo a causa di un errore nell'origine dati o di un timeout, anche tutte le espressioni Threshold, Reduce o Math che utilizzano quella query non restituiranno dati o un errore. Quando ciò accade, queste espressioni saranno assenti da. `$values` È buona norma verificare che sia presente un RefID prima di utilizzarlo, altrimenti il modello si interromperà nel caso in cui la query non restituisca dati o restituisca un errore. Puoi farlo usando un'istruzione if:
```
{{ if $values.B }}{{ $labels.service }} has over 5% of responses with 5xx errors: {{ humanizePercentage $values.B.Value }}{{ end }}
```
## Condizioni classiche
Se la regola utilizza le condizioni classiche anziché le espressioni Threshold, Reduce e Math, la `$values` variabile viene indicizzata sia in base all'ID di riferimento che alla posizione della condizione nella condizione classica. Ad esempio, se hai una condizione classica con RefID B contenente due condizioni, allora `$values` conterrà due condizioni e. `B0` `B1`
```
The first condition is {{ $values.B0 }}, and the second condition is {{ $values.B1 }}
```
## Funzioni
Le seguenti funzioni sono disponibili anche quando si espandono 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.
**Esempio**
```
{{define "x"}}{{.arg0}} {{.arg1}}{{end}}{{template "x" (args 1 "2")}}
```
```
1 2
```
**URL esterno**
La `externalURL` funzione restituisce l'URL esterno del server Grafana come configurato nei file ini.
**Esempio**
```
{{ externalURL }}
```
```
https://example.com/grafana
```
**GraphLink**
La `graphLink` funzione restituisce il percorso della visualizzazione grafica [Esplora nella versione 9 di Grafana](v9-explore.md) per l'espressione e l'origine dati specificate.
**Esempio**
```
{{ 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.
**Esempio**
```
{{ humanize 1000.0 }}
```
```
1k
```
**umanizza 1024**
`humanize1024`Funziona in modo simile `humanize` ma utilizza 1024 come base anziché 1000.
**Esempio**
```
{{ humanize1024 1024.0 }}
```
```
1ki
```
**Durata umanizzata**
La `humanizeDuration` funzione umanizza una durata in secondi.
**Esempio**
```
{{ humanizeDuration 60.0 }}
```
```
1m 0s
```
**Umanizza la percentuale**
La `humanizePercentage` funzione umanizza un valore di rapporto rispetto a una percentuale.
**Esempio**
```
{{ humanizePercentage 0.2 }}
```
```
20%
```
**Umanizza il timestamp**
La `humanizeTimestamp` funzione umanizza un timestamp Unix.
**Esempio**
```
{{ humanizeTimestamp 1577836800.0 }}
```
```
2020-01-01 00:00:00 +0000 UTC
```
**partita**
La `match` funzione abbina il testo a un modello di espressione regolare.
**Esempio**
```
{{ match "a.*" "abc" }}
```
```
true
```
**PathPrefix**
La `pathPrefix` funzione restituisce il percorso del server Grafana come configurato nei file ini.
**Esempio**
```
{{ pathPrefix }}
```
```
/grafana
```
**TableLink**
La `tableLink` funzione restituisce il percorso della vista tabulare [Esplora nella versione 9 di Grafana](v9-explore.md) per l'espressione e l'origine dati specificate.
**Esempio**
```
{{ 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.
**Esempio**
```
{{ title "hello, world!" }}
```
```
Hello, World!
```
**a Lower**
La `toLower` funzione restituisce tutto il testo in lettere minuscole.
**Esempio**
```
{{ toLower "Hello, world!" }}
```
```
hello, world!
```
**a TOUPPER**
La `toUpper` funzione restituisce tutto il testo in maiuscolo.
**Esempio**
```
{{ toUpper "Hello, world!" }}
```
```
HELLO, WORLD!
```
**reReplaceAll**
La `reReplaceAll` funzione sostituisce il testo corrispondente all'espressione regolare.
**Esempio**
```
{{ reReplaceAll "localhost:(.*)" "example.com:$1" "localhost:8080" }}
```
```
example.com:8080
```
# Stato e integrità delle regole di allarme
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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. |
**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.
# Punti di contatto
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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)
Utilizza i punti di contatto per definire in che modo i tuoi contatti vengono avvisati quando viene attivata una regola di avviso. Un punto di contatto può avere uno o più tipi di punti di contatto, ad esempio email, Slack, webhook e così via. Quando viene attivata una regola di avviso, viene inviata una notifica a tutti i tipi di punti di contatto elencati per un punto di contatto. 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 [Lavorare con i punti di contatto](v9-alerting-contact-points.md) e[Personalizza le notifiche](v9-alerting-notifications.md).
# Notifications
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 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 principale. Può esistere una sola politica principale e la politica principale 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 di routing specifica può avere politiche secondarie proprie, chiamate politiche annidate, che consentono una corrispondenza aggiuntiva degli avvisi. Un esempio di policy di routing specifica 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 loro etichette, corrispondono alla policy principale. Tuttavia, quando la politica principale riceve un avviso, esamina ogni politica di routing specifica e invia l'avviso alla prima politica di routing specifica che corrisponde all'avviso. Se la politica di routing specifica prevede ulteriori politiche secondarie, può tentare di abbinare l'avviso a una delle sue politiche annidate. Se nessuna politica annidata corrisponde all'avviso, la politica di routing specifica è la politica di routing corrispondente. Se non esistono politiche di routing specifiche o nessuna politica di routing specifica corrisponde all'avviso, la politica principale è la politica corrispondente.
## Punti di contatto
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 Pager Duty, un'integrazione Pager Duty e Slack o un'integrazione Pager Duty, 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.
**Nota**
Per informazioni sulle integrazioni supportate per i punti di contatto, consulta[Punti di contatto](v9-alerting-explore-contacts.md).
## Modelli di notifiche
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.
## 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.
# Configurare gli avvisi
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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)
Configura le funzionalità e le integrazioni di cui hai bisogno per creare e gestire i tuoi avvisi.
**Topics**
+ [Aggiungere un Alertmanager esterno](v9-alerting-setup-alertmanager.md)
+ [Fornitura di risorse Grafana Alerting](v9-alerting-setup-provision.md)
# Aggiungere un Alertmanager esterno
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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)
Configura Grafana per utilizzare un Alertmanager esterno come unico Alertmanager per ricevere tutti i tuoi avvisi. Questo Alertmanager esterno può quindi essere configurato e amministrato dall'interno di Grafana stessa.
Dopo aver aggiunto Alertmanager, puoi utilizzare l'interfaccia utente Grafana Alerting per gestire silenzi, punti di contatto e politiche di notifica. Un'opzione a discesa in queste pagine consente di passare da un gestore di avvisi all'altro.
**Nota**
A partire da Grafana 9.2, la configurazione URL dei gestori di avvisi esterni dalla scheda Amministrazione nella pagina Avvisi è obsoleta. Verrà rimosso in una versione futura.
I gestori di avvisi esterni dovrebbero ora essere configurati come fonti di dati utilizzando Grafana Configuration dal menu di navigazione principale di Grafana. Ciò consente di gestire i punti di contatto e le politiche di notifica dei gestori di avvisi esterni dall'interno di Grafana e crittografa anche le credenziali di autenticazione di base HTTP che in precedenza erano visibili durante la configurazione dei gestori di avvisi esterni tramite URL.
Per aggiungere un Alertmanager esterno, completa i seguenti passaggi.
1. Fai clic su Configurazione, quindi su Origini dati.
1. Cerca Alertmanager.
1. Scegli la tua implementazione e compila i campi della pagina, come richiesto.
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.
**Nota**
Sono supportate le implementazioni Prometheus, Grafana Mimir e Cortex di Alertmanager. Per Prometheus, i punti di contatto e le politiche di notifica sono di sola lettura nell'interfaccia utente di Grafana Alerting.
1. Fai clic su Salva e prova.
# Fornitura di risorse Grafana Alerting
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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)
L'infrastruttura di allarme è spesso complessa, con molte parti della pipeline che spesso risiedono in luoghi diversi. La scalabilità di tutto questo tra più team e organizzazioni è un compito particolarmente impegnativo. Grafana Alerting Provisioning semplifica questo processo consentendoti di creare, gestire e mantenere i dati di avviso nel modo più adatto alla tua organizzazione.
Ci sono due opzioni tra cui scegliere:
1. Effettua il provisioning delle tue risorse di avviso utilizzando l'API HTTP Alerting Provisioning.
**Nota**
In genere, non è possibile modificare le regole di avviso fornite tramite API dall'interfaccia utente di Grafana.
Per abilitare la modifica, aggiungi l' x-disable-provenanceintestazione alle seguenti richieste quando crei o modifichi le regole di avviso nell'API:
```
POST /api/v1/provisioning/alert-rules
PUT /api/v1/provisioning/alert-rules/{UID}
```
1. Fornisci le tue risorse di avviso utilizzando Terraform.
**Nota**
Attualmente, il provisioning for Grafana Alerting supporta regole di avviso, punti di contatto, tempi di silenziamento e modelli. Le risorse di avviso fornite utilizzando il provisioning di file o Terraform possono essere modificate solo nella fonte che le ha create e non dall'interno di Grafana o da qualsiasi altra fonte. Ad esempio, se esegui il provisioning delle risorse di avviso utilizzando file dal disco, non puoi modificare i dati in Terraform o dall'interno di Grafana.
**Topics**
+ [Crea e gestisci risorse di avviso utilizzando Terraform](v9-alerting-setup-provision-terraform.md)
+ [Visualizzazione delle risorse di avviso assegnate a Grafana](v9-alerting-setup-provision-view.md)
# Crea e gestisci risorse di avviso utilizzando Terraform
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 il provider Grafana di Terraform per gestire le tue risorse di avviso e fornirle nel tuo sistema Grafana. Il supporto del provider Terraform per Grafana Alerting semplifica la creazione, la gestione e la manutenzione dell'intero stack Grafana Alerting come codice.
Per ulteriori informazioni sulla gestione delle risorse di avviso utilizzando Terraform, consulta la documentazione di [Grafana Provider](https://registry.terraform.io/providers/grafana/grafana/latest/docs) nella documentazione di Terraform.
Completa le seguenti attività per creare e gestire le tue risorse di avviso utilizzando Terraform.
1. Crea una chiave API per il provisioning.
1. Configura il provider Terraform.
1. Definisci le tue risorse di avviso in Terraform.
1. Corri `terraform apply` a fornire le tue risorse di avviso.
## Prerequisiti
+ Assicurati di avere il [provider grafana/grafana Terraform](https://registry.terraform.io/providers/grafana/grafana/1.28.0) 1.27.0 o versione successiva.
+ Assicurati di utilizzare Grafana 9.1 o versioni successive. Se hai creato la tua istanza Amazon Managed Grafana con Grafana versione 9, questo sarà vero.
## Crea una chiave API per il provisioning
Puoi [creare una normale chiave API Grafana](Using-Grafana-APIs.md) per autenticare Terraform con Grafana. La maggior parte degli strumenti esistenti che utilizzano chiavi API dovrebbe funzionare automaticamente con il nuovo supporto Grafana Alerting. Per informazioni specifiche sulla creazione di chiavi da utilizzare con Terraform, consulta [Using Terraform for Amazon Managed Grafana automation](https://aws-observability.github.io/observability-best-practices/recipes/recipes/amg-automation-tf/).
**Per creare una chiave API per il provisioning**
1. Crea un nuovo account di servizio per la tua pipeline CI.
1. Assegna il ruolo «Accedi all'API di provisioning delle regole di avviso».
1. Crea un nuovo token per l'account di servizio.
1. Assegna un nome e salva il token per utilizzarlo in Terraform.
In alternativa, puoi utilizzare l'autenticazione di base. Per visualizzare tutti i formati di autenticazione supportati, consulta l'[autenticazione Grafana](https://registry.terraform.io/providers/grafana/grafana/latest/docs#authentication) nella documentazione di Terraform.
## Configura il provider Terraform
[Il supporto Grafana Alerting è incluso come parte del provider Grafana Terraform.](https://registry.terraform.io/providers/grafana/grafana/latest/docs)
Di seguito è riportato un esempio che è possibile utilizzare per configurare il provider Terraform.
```
terraform {
required_providers {
grafana = {
source = "grafana/grafana"
version = ">= 1.28.2"
}
}
}
provider "grafana" {
url =
auth =
}
```
## Fornisci punti di contatto e modelli
I punti di contatto collegano uno stack di avvisi al mondo esterno. Spiegano a Grafana come connettersi ai sistemi esterni e dove inviare le notifiche. Ci sono oltre quindici diverse [integrazioni](https://registry.terraform.io/providers/grafana/grafana/latest/docs/resources/contact_point#optional) tra cui scegliere. Questo esempio utilizza un punto di contatto Slack.
**Per fornire punti di contatto e modelli**
1. Copia questo blocco di codice in un file.tf sul tuo computer locale. **Sostituiscilo con l'URL del webhook di Slack (o un altro contatto)
Questo esempio crea un punto di contatto che invia notifiche di avviso a Slack.
```
resource "grafana_contact_point" "my_slack_contact_point" {
name = "Send to My Slack Channel"
slack {
url =
text = <
Le politiche di notifica indicano a Grafana come indirizzare le istanze di avviso, anziché dove. Collegano gli avvisi di attivazione ai punti di contatto precedentemente definiti utilizzando un sistema di etichette e abbinatori.
**Per fornire politiche di notifica e routing**
1. Copia questo blocco di codice in un file.tf sul tuo computer locale.
In questo esempio, gli avvisi sono raggruppati per`alertname`, il che significa che tutte le notifiche provenienti da avvisi con lo stesso nome vengono raggruppate nello stesso messaggio Slack.
Se desideri indirizzare notifiche specifiche in modo diverso, puoi aggiungere delle politiche secondarie. Le politiche secondarie consentono di applicare il routing a diversi avvisi in base alla corrispondenza delle etichette. In questo esempio, applichiamo una tempistica di silenziamento a tutti gli avvisi con l'etichetta a=b.
```
resource "grafana_notification_policy" "my_policy" {
group_by = ["alertname"]
contact_point = grafana_contact_point.my_slack_contact_point.name
group_wait = "45s"
group_interval = "6m"
repeat_interval = "3h"
policy {
matcher {
label = "a"
match = "="
value = "b"
}
group_by = ["..."]
contact_point = grafana_contact_point.a_different_contact_point.name
mute_timings = [grafana_mute_timing.my_mute_timing.name]
policy {
matcher {
label = "sublabel"
match = "="
value = "subvalue"
}
contact_point = grafana_contact_point.a_third_contact_point.name
group_by = ["..."]
}
}
}
```
1. Nel campo mute\$1timings, collega una tempistica di silenziamento alla tua politica di notifica.
1. Esegui il comando `terraform apply`.
1. Vai all'interfaccia utente di Grafana e controlla i dettagli della tua politica di notifica.
**Nota**
Non è possibile modificare le risorse fornite da Terraform dall'interfaccia utente. Ciò garantisce che lo stack di avvisi rimanga sempre sincronizzato con il codice.
1. Fai clic su **Test** per verificare che il punto di notifica funzioni correttamente.
## Fornisci tempi di silenziamento
Le tempistiche di silenziamento offrono la possibilità di disattivare le notifiche di avviso per periodi di tempo definiti.
**Per fornire tempi di silenziamento**
1. Copia questo blocco di codice in un file.tf sul tuo computer locale.
In questo esempio, le notifiche di avviso vengono disattivate nei fine settimana.
```
resource "grafana_mute_timing" "my_mute_timing" {
name = "My Mute Timing"
intervals {
times {
start = "04:56"
end = "14:17"
}
weekdays = ["saturday", "sunday", "tuesday:thursday"]
months = ["january:march", "12"]
years = ["2025:2027"]
}
}
```
1. Esegui il comando `terraform apply`.
1. Vai all'interfaccia utente di Grafana e controlla i dettagli della tua tempistica di silenziamento.
1. Fai riferimento alla tempistica di silenziamento appena creata in una politica di notifica utilizzando il campo. `mute_timings` In questo modo la tempistica di silenziamento verrà applicata ad alcune o a tutte le notifiche.
**Nota**
Non è possibile modificare le risorse fornite da Terraform dall'interfaccia utente. Ciò garantisce che lo stack di avvisi rimanga sempre sincronizzato con il codice.
1. Fai clic su **Test** per verificare che la tempistica di silenziamento funzioni correttamente.
## Fornisci regole di avviso
[Le regole di avviso](v9-alerting-managerules.md) consentono di inviare avvisi su qualsiasi fonte di dati Grafana. Questa può essere una fonte di dati che hai già configurato, oppure puoi [definire le tue fonti di dati in Terraform](https://registry.terraform.io/providers/grafana/grafana/latest/docs/resources/data_source) insieme alle regole di avviso.
**Per fornire regole di avviso**
1. Crea una fonte di dati su cui interrogare e una cartella in cui archiviare le regole.
In questo esempio, viene utilizzata la fonte di [Configurare un'origine TestData dati per i test](testdata-data-source.md) dati.
Gli avvisi possono essere definiti su qualsiasi origine dati di backend in Grafana.
```
resource "grafana_data_source" "testdata_datasource" {
name = "TestData"
type = "testdata"
}
resource "grafana_folder" "rule_folder" {
title = "My Rule Folder"
}
```
1. Definisci una regola di avviso.
Per ulteriori informazioni sulle regole di avviso, consulta [come creare avvisi gestiti da Grafana](https://grafana.com/blog/2022/08/01/grafana-alerting-video-how-to-create-alerts-in-grafana-9/).
1. Crea un gruppo di regole contenente una o più regole.
In questo esempio, viene utilizzato il gruppo di `grafana_rule_group` risorse.
```
resource "grafana_rule_group" "my_rule_group" {
name = "My Alert Rules"
folder_uid = grafana_folder.rule_folder.uid
interval_seconds = 60
org_id = 1
rule {
name = "My Random Walk Alert"
condition = "C"
for = "0s"
// Query the datasource.
data {
ref_id = "A"
relative_time_range {
from = 600
to = 0
}
datasource_uid = grafana_data_source.testdata_datasource.uid
// `model` is a JSON blob that sends datasource-specific data.
// It's different for every datasource. The alert's query is defined here.
model = jsonencode({
intervalMs = 1000
maxDataPoints = 43200
refId = "A"
})
}
// The query was configured to obtain data from the last 60 seconds. Let's alert on the average value of that series using a Reduce stage.
data {
datasource_uid = "__expr__"
// You can also create a rule in the UI, then GET that rule to obtain the JSON.
// This can be helpful when using more complex reduce expressions.
model = <
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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)
Puoi verificare che le tue risorse per gli avvisi siano state create a Grafana.
**Per visualizzare le risorse assegnate a Grafana**
1. Apri l'istanza Grafana.
1. Vai a Avvisi.
1. Fai clic su una cartella di risorse per gli avvisi, ad esempio Regole di avviso.
Le risorse assegnate sono etichettate come **Provisioned**, in modo che sia chiaro che non sono state create manualmente.
**Nota**
Non è possibile modificare le risorse assegnate da Grafana. È possibile modificare le proprietà della risorsa solo modificando il file di provisioning e riavviando Grafana o effettuando un hot reload. Ciò impedisce che vengano apportate modifiche alla risorsa che verrebbero sovrascritte se si rifornisse un file o si effettuasse un hot reload.
# Migrazione degli avvisi della dashboard classica agli avvisi Grafana
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 aree di lavoro che scelgono di non utilizzare gli avvisi Grafana, utilizzano il classico avviso della dashboard. Per passare al nuovo avviso Grafana, devi attivare la funzione.
Puoi configurare la tua istanza Amazon Managed Grafana per utilizzare gli avvisi Grafana utilizzando l'API Console di gestione AWS Amazon Managed Grafana. AWS CLI Per dettagli su come configurare Amazon Managed Grafana, inclusa l'attivazione o la disattivazione degli avvisi Grafana, consulta. [Configura uno spazio di lavoro Amazon Managed Grafana](AMG-configure-workspace.md)
**Nota**
Quando usi gli avvisi Grafana, le regole di avviso definite in Grafana, anziché in Prometheus, inviano più notifiche al tuo punto di contatto. Se utilizzi avvisi Grafana nativi, ti consigliamo di continuare con gli avvisi Grafana classici e di non abilitare la nuova funzionalità di avviso Grafana. Se desideri visualizzare gli avvisi definiti nella tua fonte di dati Prometheus, ti consigliamo di abilitare Grafana Alerting, che invia una sola notifica per gli avvisi creati in Prometheus Alertmanager.
Questa limitazione è stata rimossa nelle aree di lavoro Amazon Managed Grafana che supportano Grafana v10.4 e versioni successive.
## Migrazione al sistema di avvisi Grafana
Quando gli avvisi Grafana sono attivati, gli avvisi della dashboard classica esistenti migrano in un formato compatibile con gli avvisi Grafana. Nella pagina Avvisi dell'istanza Grafana, puoi visualizzare gli avvisi migrati insieme ai nuovi avvisi. Con gli avvisi Grafana, le regole di avviso gestite da Grafana inviano più notifiche anziché un singolo avviso quando vengono abbinate.
L'accesso in lettura e scrittura ai classici avvisi della dashboard e agli avvisi Grafana è regolato dalle autorizzazioni delle cartelle che li memorizzano. Durante la migrazione, le autorizzazioni classiche per gli avvisi della dashboard vengono abbinate alle autorizzazioni delle nuove regole come segue:
+ Se la dashboard dell'avviso originale dispone di autorizzazioni, la migrazione crea una cartella denominata con questo formato in modo che `Migrated {"dashboardUid": "UID", "panelId": 1, "alertId": 1}` corrisponda alle autorizzazioni della dashboard originale (incluse le autorizzazioni ereditate dalla cartella).
+ Se non ci sono autorizzazioni della dashboard e la dashboard si trova in una cartella, la regola viene collegata a questa cartella e ne eredita le autorizzazioni.
+ Se non ci sono autorizzazioni per la dashboard e la dashboard si trova nella cartella Generale, la regola viene collegata alla cartella Avvisi generali e la regola eredita le autorizzazioni predefinite.
**Nota**
Poiché non è `Keep Last State` disponibile alcuna opzione per gli avvisi `NoData` in Grafana, questa opzione diventa disponibile `NoData` durante la classica migrazione delle regole. L'opzione `Keep Last State` di `Error` gestione viene migrata a una nuova opzione. `Error` Per corrispondere al comportamento di`Keep Last State`, in entrambi i casi, durante la migrazione Amazon Managed Grafana crea automaticamente un silenzio per ogni regola di avviso della durata di un anno.
I canali di notifica vengono migrati a una configurazione Alertmanager con i percorsi e i ricevitori appropriati. I canali di notifica predefiniti vengono aggiunti come punti di contatto al percorso predefinito. I canali di notifica non associati ad alcun avviso della Dashboard vanno al `autogen-unlinked-channel-recv` percorso.
### Limitazioni
+ Il sistema di avviso Grafana può recuperare le regole da tutte le fonti di dati Prometheus, Loki e Alertmanager disponibili. Potrebbe non essere in grado di recuperare le regole di avviso da altre fonti di dati supportate.
+ La migrazione avanti e indietro tra gli avvisi Grafana e il classico avviso della dashboard può comportare la perdita di dati per le funzionalità supportate in un sistema, ma non nell'altro.
**Nota**
Se si torna alla versione classica degli avvisi della dashboard, si perderanno tutte le modifiche apportate alla configurazione degli avvisi effettuate mentre gli avvisi Grafana erano abilitati, incluse le nuove regole di avviso create.
# Gestisci le tue regole di avviso
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 avviso verrà attivato. La regola di avviso è costituita da una o più interrogazioni ed espressioni, una condizione, la frequenza di valutazione e, facoltativamente, la durata durante la quale la condizione viene soddisfatta.
Mentre le interrogazioni e le espressioni selezionano il set di dati da valutare, una condizione imposta la soglia che un avviso deve 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.
**Nota**
Le regole di avviso gestite da Grafana possono essere modificate o eliminate solo dagli utenti con autorizzazioni di modifica per la cartella in cui sono archiviate le regole.
Le regole di avviso per un'istanza Grafana Mimir o Loki esterna possono essere modificate o eliminate dagli utenti con ruoli di Editor o Amministratore.
**Topics**
+ [Creazione di regole di avviso gestite da Grafana](v9-alerting-managerules-grafana.md)
+ [Creazione di regole di avviso gestite da Grafana Mimir o Loki](v9-alerting-managerules-mimir-loki.md)
+ [Creazione di regole di registrazione gestite da Grafana, Mimir o Loki](v9-alerting-managerules-mimir-loki-recording.md)
+ [Grafana, Mimir o Loki, gruppi di regole e namespace](v9-alerting-managerules-mimir-loki-groups.md)
+ [Visualizza e modifica le regole di avviso](v9-alerting-managerules-view-edit.md)
# Creazione di regole di avviso gestite da Grafana
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 consente di creare regole di avviso che interrogano una o più fonti di dati, riducono o trasformano i risultati e li confrontano tra loro o con soglie fisse. Quando queste vengono eseguite, Grafana invia notifiche al punto di contatto.
**Per aggiungere una regola gestita Grafana**
1. Dalla console Grafana, nel menu Grafana, scegli l'icona **Avvisi (campanella) per aprire la pagina** Avvisi che elenca **gli avvisi** esistenti.
1. **Scegli Nuova regola di avviso.**
1. Nel **passaggio 1**, aggiungi il nome, il tipo e la posizione di archiviazione della regola, come segue:
+ In **Nome regola**, aggiungi un nome descrittivo. Questo nome viene visualizzato nell'elenco delle regole di avviso. È anche l'`alertname`etichetta per ogni istanza di avviso creata da questa regola.
+ Dal menu a discesa **Tipo di regola**, seleziona **Avviso gestito Grafana**.
+ Dal menu a discesa **Cartella**, seleziona la cartella in cui desideri archiviare la regola. Se non si seleziona una cartella, la regola viene memorizzata nella `General` cartella. Per creare una cartella, seleziona il menu a discesa e inserisci un nuovo nome per la cartella.
1. Nel **passaggio 2**, aggiungi le interrogazioni e le espressioni da valutare.
+ Mantieni il nome predefinito o passa il mouse sopra e scegli l'icona di modifica per modificare il nome.
+ Per le query, seleziona una fonte di dati dal menu a discesa.
+ Aggiungi una o più [domande](v9-panels-query-xform-expressions.md) o espressioni.
+ Per ogni espressione, seleziona una **condizione classica** per creare una singola regola di avviso oppure scegli tra le opzioni **Math**, **Reduce** e **Resample** per generare avvisi separati per ogni serie. Per i dettagli su queste opzioni, consulta. [Regole singole e multidimensionali](#v9-alerting-single-multi-rule)
+ Scegli **Esegui interrogazioni** per verificare che l'interrogazione abbia esito positivo.
1. Nel **passaggio 3**, aggiungi le condizioni.
+ Dal menu a discesa **Condizione**, seleziona la query o l'espressione per avviare la regola di avviso.
+ Per **Evaluate every**, specificate la frequenza di valutazione. Deve essere un multiplo di 10 secondi. Ad esempio, `1m`, `30s`.
+ Per **Evaluate for**, specifica la durata per la quale la condizione deve essere vera prima che venga avviato un avviso.
**Nota**
Dopo che una condizione viene violata, l'avviso entra in `Pending` stato. Se la condizione rimane violata per la durata specificata, l'avviso passa allo stato. `Firing` Se non viene più soddisfatto, viene ripristinato lo stato. `Normal`
+ In **Configura nessun dato e gestione degli errori**, configura il comportamento di avviso in assenza di dati. Utilizza le linee guida contenute in. [Nessuna gestione di dati o casi di errore](#v9-alerting-rule-no-data-error)
+ Scegli **Anteprima avvisi** per verificare il risultato dell'esecuzione della query in questo momento. L'anteprima non esclude dati e condizioni di gestione degli errori.
1. Nel **passaggio 4**, aggiungi ulteriori metadati associati alla regola.
+ Aggiungi una descrizione e un riepilogo per personalizzare i messaggi di avviso. Utilizza le linee guida in[Etichette e annotazioni](v9-alerting-explore-labels.md).
+ Aggiungi l'URL, il pannello, la dashboard e l'avviso IDs del Runbook.
+ Aggiungi etichette personalizzate.
1. Scegli **Salva** per salvare la regola o **Salva ed esci** per salvare la regola e tornare alla pagina **Avvisi**.
Dopo aver creato la regola, puoi creare una notifica per la regola. Per ulteriori informazioni sulle notifiche, consultare [Gestisci le notifiche di avviso](v9-alerting-managenotifications.md).
## Regole singole e multidimensionali
Per le regole di avviso gestite da Grafana, puoi creare una regola con una condizione classica oppure puoi creare una regola multidimensionale.
**Regola monodimensionale (condizione classica)**
Utilizza un'espressione di condizione classica per creare una regola che avvia un singolo avviso quando viene soddisfatta la relativa condizione. Per una query che restituisce più serie, Grafana non tiene traccia dello stato di avviso di ciascuna serie. Di conseguenza, Grafana invia un solo avviso anche quando le condizioni di allarme sono soddisfatte per più serie.
Per ulteriori informazioni su come formattare le espressioni, consulta [Espressioni](https://grafana.com/docs/grafana/next/panels/query-a-data-source/) nella documentazione di *Grafana*.
**Regola multidimensionale**
Per generare un'istanza di avviso separata per ogni serie restituita nella query, create una regola multidimensionale.
**Nota**
Ogni istanza di avviso generata da una regola multidimensionale viene conteggiata ai fini della quota totale di avvisi. Le regole non vengono valutate quando si raggiunge la quota di avvisi. Per ulteriori informazioni sulle quote per le regole multidimensionali, vedere. [Errori relativi alla quota raggiunta](#v9-alerting-rule-quota-reached)
Per creare più istanze da una singola regola `Math``Reduce`, usa o `Resample` espressioni per creare una regola multidimensionale. Ad esempio, puoi:
+ Aggiungi un'`Reduce`espressione per ogni query per aggregare i valori nell'intervallo di tempo selezionato in un unico valore. (Non necessario per [le regole che utilizzano dati numerici)](v9-alerting-explore-numeric.md).
+ Aggiungi un'`Math`espressione con la condizione per la regola. Ciò non è necessario nel caso in cui una query o un'espressione di riduzione restituisca già 0 se la regola non deve avviare un avviso o un numero positivo se deve avviare un avviso.
Alcuni esempi:
+ `$B > 70`se deve avviare un avviso nel caso in cui il valore di B query/expression sia superiore a 70.
+ `$B < $C * 100`nel caso in cui debba avviare un allarme se il valore di B è inferiore al valore di C moltiplicato per 100. Se le query confrontate contengono più serie nei risultati, le serie di query diverse vengono abbinate se hanno le stesse etichette o una è un sottoinsieme dell'altra.
**Nota**
Grafana non supporta le interrogazioni di avviso con variabili modello. Ulteriori informazioni sono disponibili nella pagina della community Le [variabili di modello non sono supportate nelle query di avviso durante la configurazione](https://community.grafana.com/t/template-variables-are-not-supported-in-alert-queries-while-setting-up-alert/2514) di Alert.
**Considerazioni sulle prestazioni per le regole multidimensionali**
Ogni istanza di avviso viene conteggiata ai fini della quota di avvisi. Le regole multidimensionali che creano più istanze di quelle che possono essere inserite all'interno della quota di avvisi non vengono valutate e restituiscono un errore di quota. Per ulteriori informazioni, consulta [Errori relativi alla quota raggiunta](#v9-alerting-rule-quota-reached).
Gli avvisi multidimensionali possono avere un forte impatto sulle prestazioni del tuo spazio di lavoro Grafana, nonché sulle prestazioni delle tue fonti di dati, poiché Grafana le interroga per valutare le tue regole di avviso. Le seguenti considerazioni possono essere utili per ottimizzare le prestazioni del sistema di monitoraggio.
+ **Frequenza di valutazione delle regole**: la proprietà **Evaluate Every** di una regola di avviso controlla la frequenza di valutazione delle regole. Si consiglia di utilizzare la frequenza di valutazione più bassa accettabile.
+ **Cardinalità del set di risultati**: il numero di istanze di avviso create con una regola ne influisce sulle prestazioni. Supponiamo che stiate monitorando gli errori di risposta delle API per ogni percorso API, su ogni macchina virtuale del vostro parco macchine. Questo set ha una cardinalità del numero di percorsi moltiplicato per il numero di. VMs È possibile ridurre la cardinalità del set di risultati, ad esempio, monitorando gli errori totali per macchina virtuale anziché per percorso per macchina virtuale.
+ **Complessità della query**: le interrogazioni che le fonti di dati possono elaborare e a cui rispondere rapidamente consumano meno risorse. Sebbene questa considerazione sia meno importante delle altre considerazioni sopra elencate, se le hai ridotte il più possibile, l'analisi delle prestazioni delle singole query potrebbe fare la differenza. È inoltre necessario essere consapevoli dell'impatto sulle prestazioni che la valutazione di queste regole ha sulle fonti di dati. Le query di avviso sono spesso la maggior parte delle query gestite dai database di monitoraggio, quindi anche gli stessi fattori di carico che influiscono sull'istanza Grafana influiscono anche su di esse.
## Errori relativi alla quota raggiunta
Esiste una quota per il numero di istanze di avviso che è possibile avere all'interno di un singolo spazio di lavoro. Quando raggiungi quel numero, non puoi più creare nuove regole di avviso in quell'area di lavoro. Con gli avvisi multidimensionali, il numero di istanze di avviso può variare nel tempo.
Quando si lavora con le istanze di avviso, è importante ricordare quanto segue.
+ Se si creano solo regole monodimensionali, ogni regola è una singola istanza di avviso. È possibile creare lo stesso numero di regole in un unico spazio di lavoro pari alla quota dell'istanza di avviso e non di più.
+ Le regole multidimensionali creano più istanze di avviso, tuttavia il numero non è noto finché non vengono valutate. Ad esempio, se crei una regola di avviso che tiene traccia dell'utilizzo della CPU delle tue istanze Amazon EC2, potrebbero esserci 50 istanze EC2 al momento della creazione (e quindi 50 istanze di avviso), ma se aggiungi altre 10 istanze EC2 una settimana dopo, la valutazione successiva ha 60 istanze di avviso.
Il numero di istanze di avviso viene valutato quando si crea un avviso multidimensionale e non è possibile crearne uno che superi immediatamente la quota di istanze di avviso. Poiché il numero di istanze di avviso può cambiare, la quota viene verificata ogni volta che vengono valutate le regole.
+ Al momento della valutazione della regola, se una regola comporta il superamento della quota prevista per le istanze di avviso, tale regola non viene valutata finché non viene effettuato un aggiornamento della regola di avviso che porta il numero totale di istanze di avviso al di sotto della quota di servizio. Quando ciò accade, si riceve una notifica di avviso che informa che la quota è stata raggiunta (la notifica utilizza la politica di notifica per la regola in fase di valutazione). La notifica include un'`Error`annotazione con il valore. `QuotaReachedError`
+ Una regola che causa un `QuotaReachedError` arresto nella valutazione. La valutazione viene ripresa solo quando viene effettuato un aggiornamento e la valutazione successiva all'aggiornamento non causa di per sé un. `QuotaReachedError` Una regola che non viene valutata mostra l'errore **Quota raggiunta** nella console Grafana.
+ È possibile ridurre il numero di istanze di avviso rimuovendo le regole di avviso o modificando gli avvisi multidimensionali per avere meno istanze di avviso (ad esempio, inserendo un avviso sugli errori per macchina virtuale anziché un avviso di errore per API in una macchina virtuale).
+ Per riprendere le valutazioni, aggiorna l'avviso e salvalo. È possibile aggiornarlo per ridurre il numero di istanze di avviso oppure, se sono state apportate altre modifiche per ridurre il numero di istanze di avviso, è possibile salvarlo senza modifiche. Se può essere ripreso, lo è. Se ne causa un altro`QuotaReachedError`, non puoi salvarlo.
+ Quando un avviso viene salvato e riprende la valutazione senza superare la quota di avvisi, l'errore Quota **raggiunta** può continuare a essere visualizzato nella console Grafana per qualche tempo (fino all'intervallo di valutazione), tuttavia, la valutazione della regola di avviso inizia e gli avvisi vengono inviati se viene raggiunta la soglia della regola.
+ Per i dettagli sulla quota di avvisi e su altre quote, vedi. [Quote del servizio Amazon Managed Grafana](AMG_quotas.md)
## Nessuna gestione di dati o casi di errore
Scegliete le opzioni su come gestire il comportamento di avviso in assenza di dati o in caso di errori.
Le opzioni per la gestione dell'assenza di dati sono elencate nella tabella seguente.
| Opzione No Data | Comportamento |
| --- | --- |
| Nessun dato | Crea un avviso `DatasourceNoData` con il nome e l'UID della regola di avviso e l'UID dell'origine dati che non ha restituito dati come etichette. |
| Avviso | Imposta lo stato della regola di avviso su. `Alerting` |
| OK | Imposta lo stato della regola di avviso su`Normal`. |
Le opzioni per la gestione dei casi di errore sono elencate nella tabella seguente.
| Opzione di errore o timeout | Comportamento |
| --- | --- |
| Avviso | Imposta lo stato della regola di avviso su `Alerting` |
| OK | Imposta lo stato della regola di avviso su `Normal` |
| Errore | Crea un avviso `DatasourceError` con il nome e l'UID della regola di avviso e l'UID dell'origine dati che non ha restituito dati come etichette. |
# Creazione di regole di avviso gestite da Grafana Mimir o Loki
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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)
Utilizzando Grafana, è possibile creare regole di avviso per un'istanza Grafana Mimir o Loki esterna.
**Nota**
Grafana Mimir può connettersi alle sorgenti dati Amazon Managed Service for Prometheus e Prometheus.
**Prerequisiti**
+ Verifica di disporre delle autorizzazioni di scrittura per l'origine dati Prometheus. Altrimenti, non sarai in grado di creare o aggiornare le regole di avviso gestite da Cortex.
+ Per le sorgenti dati Grafana Mimir e Loki, abilita l'API ruler configurando i rispettivi servizi.
+ **Loki** — Il tipo di archiviazione delle `local` regole, predefinito per l'origine dati Loki, supporta solo la visualizzazione delle regole. Per modificare le regole, configura uno degli altri tipi di archiviazione.
+ **Grafana Mimir** — Usa il `/api/prom` prefisso legacy, non. `/prometheus` L'origine dati Prometheus supporta sia Grafana Mimir che Prometheus e Grafana prevede che sia l'API Query che l'API Ruler siano sotto lo stesso URL. Non è possibile fornire un URL separato per l'API Ruler.
**Nota**
**Se non desideri gestire le regole di avviso per una particolare origine dati Loki o Prometheus, vai alle relative impostazioni e deseleziona la casella di controllo Gestisci avvisi tramite interfaccia utente di avviso.**
**Per aggiungere una regola di avviso gestito Grafana, Mimir o Loki**
1. Dalla console Grafana, nel menu Grafana, scegli l'icona **Avvisi (campanella) per aprire la pagina** Avvisi che elenca **gli avvisi** esistenti.
1. **Scegli Crea regola di avviso.**
1. Nel **passaggio 1**, scegli il tipo di regola e i dettagli, come segue:
+ Scegli **Mimir o Loki alert**.
+ In **Nome regola, aggiungi un nome** descrittivo. Questo nome viene visualizzato nell'elenco delle regole di avviso. È anche l'`alertname`etichetta per ogni istanza di avviso creata da questa regola.
+ Dal menu a discesa **Seleziona origine dati**, seleziona un'origine dati Prometheus o Loki.
+ Dal menu a discesa **Namespace**, seleziona uno spazio dei nomi di regole esistente. Altrimenti, scegli **Aggiungi nuovo** e inserisci un nome per crearne uno. I namespace possono contenere uno o più gruppi di regole e avere solo uno scopo organizzativo. Per ulteriori informazioni, consulta [Gruppi di regole e namespace Cortex o Loki](alert-rules.md#alert-rule-groups).
+ Dal menu a discesa **Gruppo**, seleziona un gruppo esistente all'interno del namespace selezionato. Altrimenti, scegli **Aggiungi nuovo** e inserisci un nome per crearne uno. Le regole appena create vengono aggiunte alla fine del gruppo. Le regole all'interno di un gruppo vengono eseguite in sequenza a intervalli regolari, con lo stesso tempo di valutazione.
1. Nel **passaggio 2**, aggiungi la query da valutare.
Il valore può essere un'espressione PromQL o LogQL. La regola avvia un avviso se il risultato della valutazione presenta almeno una serie con un valore maggiore di 0. Viene creato un avviso per ogni serie.
1. Nel **passaggio 3**, specificare l'intervallo di valutazione degli avvisi.
Nella casella di testo **Per** della condizione, specifica la durata per la quale la condizione deve essere vera prima che venga avviato l'avviso. Se si specifica`5m`, le condizioni devono essere vere per cinque minuti prima che l'avviso venga avviato.
**Nota**
Quando viene soddisfatta una condizione, l'avviso entra in `Pending` stato. Se la condizione rimane attiva per la durata specificata, l'avviso passa allo `Firing` stato. Se non viene più soddisfatta, torna allo `Normal` stato.
1. Nel **passaggio 4**, aggiungi ulteriori metadati associati alla regola.
+ Aggiungi una descrizione e un riepilogo per personalizzare i messaggi di avviso. Utilizza le linee guida in[Etichette e annotazioni](v9-alerting-explore-labels.md).
+ Aggiungi l'URL, il pannello, la dashboard e l'avviso IDs del Runbook.
+ Aggiungi etichette personalizzate.
1. Scegli **Anteprima avvisi** per valutare la regola e vedere quali avvisi produrrebbe. Visualizza un elenco di avvisi con lo stato e il valore di ciascuno.
1. Scegli **Salva** per salvare la regola o **Salva ed esci** per salvare la regola e tornare alla pagina **Avvisi.**
Dopo aver creato la regola, puoi creare una notifica per la regola. Per ulteriori informazioni sulle notifiche, consultare [Gestisci le notifiche di avviso](v9-alerting-managenotifications.md).
# Creazione di regole di registrazione gestite da Grafana, Mimir o Loki
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 creare e gestire regole di registrazione per un'istanza Grafana Mimir o Loki esterna. Le regole di registrazione calcolano in anticipo le espressioni più richieste o quelle più dispendiose dal punto di vista computazionale e salvano il risultato come una nuova serie temporale. L'interrogazione di questa nuova serie temporale è più rapida, soprattutto per le dashboard, poiché interrogano la stessa espressione ogni volta che le dashboard si aggiornano.
**Prerequisiti**
Per le sorgenti dati Grafana Mimir e Loki, abilita l'API ruler configurando i rispettivi servizi.
+ **Loki** — Il tipo di archiviazione delle `local` regole, predefinito per l'origine dati Loki, supporta solo la visualizzazione delle regole. Per modificare le regole, configura uno degli altri tipi di archiviazione.
+ **Grafana Mimir** — Quando configuri un'origine dati in modo che punti a Grafana Mimir, usa il prefisso legacy, not. `/api/prom` `/prometheus` L'origine dati Prometheus supporta sia Grafana Mimir che Prometheus e Grafana prevede che sia l'API Query che l'API Ruler si trovino nello stesso URL. Non è possibile fornire un URL separato per l'API Ruler.
**Nota**
**Se non desideri gestire le regole di avviso per una particolare origine dati Loki o Prometheus, vai alle relative impostazioni e deseleziona la casella di controllo Gestisci avvisi tramite interfaccia utente di avviso.**
**Per aggiungere una regola di registrazione gestita Grafana, Mimir o Loki**
1. Dalla console Grafana, nel menu Grafana, scegli l'icona **Avvisi (campanella) per aprire la pagina** Avvisi che elenca **gli avvisi** esistenti.
1. **Scegli Crea regola di avviso.**
1. Nel **passaggio 1**, aggiungi il tipo di regola, il nome della regola e la posizione di archiviazione, come segue.
+ Seleziona l'opzione delle **regole di registrazione Mimir o Loki**.
+ In **Nome regola, aggiungi un nome** descrittivo. Questo nome viene visualizzato nell'elenco delle regole di avviso. È anche l'`alertname`etichetta per ogni istanza di avviso creata da questa regola.
+ Dal menu a discesa **Seleziona origine dati**, seleziona un'origine dati Prometheus o Loki.
+ Dal menu a discesa **Namespace**, seleziona uno spazio dei nomi di regole esistente. Altrimenti, scegli **Aggiungi nuovo** e inserisci un nome per crearne uno. I namespace possono contenere uno o più gruppi di regole e avere solo uno scopo organizzativo. Per ulteriori informazioni, consulta [Gruppi di regole e namespace Cortex o Loki](alert-rules.md#alert-rule-groups).
+ Dal menu a discesa **Gruppo**, seleziona un gruppo esistente all'interno del namespace selezionato. Altrimenti, scegli **Aggiungi nuovo** e inserisci un nome per crearne uno. Le regole appena create vengono aggiunte alla fine del gruppo. Le regole all'interno di un gruppo vengono eseguite in sequenza a intervalli regolari, con lo stesso tempo di valutazione.
1. Nel **passaggio 2**, aggiungi la query da valutare.
Il valore può essere un'espressione PromQL o LogQL. La regola avvia un avviso se il risultato della valutazione presenta almeno una serie con un valore maggiore di 0. Viene creato un avviso per ogni serie.
1. Nel **passaggio 3**, aggiungi ulteriori metadati associati alla regola.
+ Aggiungi una descrizione e un riepilogo per personalizzare i messaggi di avviso. Utilizza le linee guida in[Annotazioni ed etichette per le regole di avviso](alert-rules.md#alert-rule-labels).
+ Aggiungi l'URL, il pannello, la dashboard e l'avviso IDs del Runbook.
+ Aggiungi etichette personalizzate.
1. Scegli **Salva** per salvare la regola o **Salva ed esci** per salvare la regola e tornare alla pagina **Avvisi**.
# Grafana, Mimir o Loki, gruppi di regole e namespace
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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)
Puoi organizzare le tue regole. Le regole vengono create all'interno di gruppi di regole e i gruppi di regole sono organizzati in namespace. Le regole all'interno di un gruppo di regole vengono eseguite in sequenza a intervalli regolari. L'intervallo predefinito è di un minuto. È possibile rinominare gli spazi dei nomi e i gruppi di regole Grafana Mimir o Loki e modificare gli intervalli di valutazione dei gruppi di regole.
**Per modificare un gruppo di regole o uno spazio dei nomi**
1. **Dalla console Grafana, nel menu Grafana, scegli l'icona Avvisi (campanella) per **aprire la pagina Avvisi**.**
1. Passa a una regola all'interno del gruppo di regole o dello spazio dei nomi che desideri modificare.
1. Scegliete l'**icona Modifica** (penna).
1. Apportate modifiche al gruppo di regole o al namespace.
**Nota**
Per i namespace, puoi solo modificare il nome. Per i gruppi di regole, è possibile modificare il nome o l'intervallo di valutazione per le regole del gruppo. Ad esempio, è possibile scegliere di `1m` fare in modo che le regole vengano valutate una volta al minuto o `30s` una volta ogni 30 secondi.
1. Scegli **Save changes (Salva modifiche)**.
# Visualizza e modifica le regole di avviso
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 pagina Avvisi elenca le **regole di avviso.** Per impostazione predefinita, le regole sono raggruppate per tipi di origini dati. La sezione **Grafana** elenca le regole gestite da Grafana e la sezione **Cortex/Loki elenca le regole per le fonti** di dati compatibili con Prometheus. È possibile visualizzare le regole di avviso per le fonti di dati compatibili con Prometheus, ma non è possibile modificarle.
La sezione Mimir/Cortex/Loki delle regole elenca tutte le regole per le fonti di dati Mimir, Cortex o Loki. In questa sezione sono elencate anche le regole di avviso cloud.
Quando gestisci grandi volumi di avvisi, puoi utilizzare funzionalità estese di ricerca delle regole di avviso per filtrare cartelle, gruppi di valutazione e regole. Inoltre, puoi filtrare le regole di avviso in base alle loro proprietà come etichette, stato, tipo e stato di integrità.
**Nota**
È possibile visualizzare le definizioni delle interrogazioni per gli avvisi predisposti, ma non modificarle. La possibilità di visualizzarli consente di verificare che le query e le definizioni delle regole siano corrette senza dover tornare al repository di provisioning per le definizioni delle regole.
## Visualizza le regole di avviso
Utilizzando gli avvisi Grafana, puoi visualizzare tutti i tuoi avvisi in un'unica pagina.
**Per visualizzare i dettagli degli avvisi**
1. **Dalla console Grafana, nel menu Grafana, scegli l'icona Avvisi (campanella) per **aprire la pagina Avvisi**.** Per impostazione predefinita, le regole vengono visualizzate in gruppi per tipo di origine dati. È inoltre possibile visualizzare in base allo stato corrente di ogni avviso (questi sono descritti più dettagliatamente nel testo seguente).
1. In **Visualizza come**, puoi passare dalla visualizzazione di gruppo a quella dello stato scegliendo l'opzione che preferisci.
1. Scegli la freccia accanto a una riga per visualizzare ulteriori dettagli per quella riga. I dettagli di una regola includono le etichette delle regole, le annotazioni, le fonti di dati e le interrogazioni, nonché un elenco di istanze di avviso risultanti dalla regola.
**Nota**
Per ulteriori informazioni sulla comprensione dei dettagli degli avvisi, consulta. [Stato e integrità delle regole di allarme](v9-alerting-explore-state.md)
**Visualizzazione di gruppo**
La visualizzazione di gruppo mostra le regole di avviso Grafana raggruppate per cartella e le regole di avviso Loki o Prometheus raggruppate per \$1. `namespace` `group` Questa è la visualizzazione predefinita dell'elenco delle regole, destinata alla gestione delle regole. È possibile espandere ogni gruppo per visualizzare un elenco delle regole in esso contenute. Espandi ulteriormente una regola per visualizzarne i dettagli. Puoi anche espandere i pulsanti di azione e gli avvisi risultanti dalla regola per visualizzarne i dettagli.
**Visualizzazione dello stato**
La visualizzazione dello stato mostra le regole di avviso raggruppate per stato. Utilizzate questa visualizzazione per avere una panoramica delle regole e dello stato in cui si trovano. Ogni regola può essere espansa per visualizzarne i dettagli. I pulsanti di azione e tutti gli avvisi generati da questa regola; ogni avviso può essere ulteriormente espanso per visualizzarne i dettagli.
**Filtra le regole di avviso**
È possibile filtrare le regole di avviso visualizzate nella pagina **Avvisi in diversi** modi.
+ È possibile filtrare per visualizzare le regole che interrogano una fonte di dati specifica scegliendo **Seleziona origini dati**, quindi selezionando un'origine dati in base alla quale filtrare.
+ Puoi filtrare per etichette scegliendo i criteri di ricerca in **Cerca per etichetta**. Ad esempio, puoi digitare per `environment=production,region=~US|EU,severity!=warning` filtrare le avvertenze relative alla produzione negli Stati Uniti e nell'UE.
+ Puoi filtrare per visualizzare le regole in uno stato specifico scegliendo **Filtra avvisi per stato**, quindi selezionando lo stato che desideri visualizzare.
## Modifica o elimina le regole di avviso
Le regole di avviso gestite da Grafana possono essere modificate o eliminate solo dagli utenti con autorizzazioni di modifica per la cartella in cui sono archiviate le regole. Le regole di avviso per un'istanza esterna di Mimir o Loki possono essere modificate o eliminate dagli utenti con ruoli di Editor o Amministratore.
**Per modificare o eliminare una regola**
1. Espandi una regola fino a visualizzare i controlli delle regole per **Visualizza**, **Modifica** ed **Elimina**.
1. Scegli **Modifica** per aprire la pagina di creazione della regola. Effettua gli aggiornamenti nello stesso modo in cui crei una regola. Per i dettagli, consulta le istruzioni in [Creazione di regole di avviso gestite da Grafana](v9-alerting-managerules-grafana.md) o[Creazione di regole di avviso gestite da Grafana Mimir o Loki](v9-alerting-managerules-mimir-loki.md).
1. Facoltativamente, scegli **Elimina** per eliminare una regola.
## Esporta le regole di avviso
**Puoi esportare le regole in YAML o JSON nell'area di lavoro Grafana, scegliendo Esporta.** Ti darà la possibilità di definire una nuova regola, quindi esportarla. È possibile creare una regola utilizzando l'interfaccia utente e quindi esportarla per utilizzarla nell'API di provisioning o negli script terraform.
**Nota**
Questa funzionalità è supportata sia nell'area di lavoro Grafana che nell'interfaccia di provisioning.
# Gestisci le notifiche di avviso
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 capacità di risolvere rapidamente i problemi e di non perdere nulla di importante.
Come primo passo, definisci i tuoi *punti di contatto*; a chi inviare le notifiche di avviso. Un punto di contatto può essere un insieme di destinazioni per le notifiche corrispondenti. Aggiungi modelli di notifica ai punti di contatto per riutilizzarli e inviare messaggi coerenti nelle notifiche.
Successivamente, crea una *politica di notifica*, che è 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. Aggiungi tempi di silenziamento alla tua politica di notifica. Un *periodo di silenziamento* è un intervallo di tempo ricorrente durante il quale non desideri che vengano inviate notifiche.
*Quando viene valutata una regola di avviso, il righello di avviso invia istanze di avviso all'Alertmanager: una regola di avviso può attivare più istanze di avviso individuali.*
L'Alertmanager riceve queste istanze di avviso e quindi gestisce gli orari di silenziamento, raggruppa gli avvisi e invia notifiche ai punti di contatto come definito nella politica di notifica.
**Topics**
+ [Gestore degli avvisi](v9-alerting-managenotifications-alertmanager.md)
+ [Lavorare con i punti di contatto](v9-alerting-contact-points.md)
+ [Utilizzo delle politiche di notifica](v9-alerting-notification-policies.md)
+ [Personalizza le notifiche](v9-alerting-notifications.md)
+ [Silenziamento delle notifiche di avviso per le fonti di dati Prometheus](v9-alerting-silences.md)
+ [Tempi di silenziamento](v9-alerting-notification-muting.md)
+ [Visualizza e filtra per gruppi di avvisi](v9-alerting-viewfiltergroups.md)
+ [Visualizza gli errori di notifica](v9-alerting-viewnotificationerrors.md)
# Gestore degli avvisi
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 eseguire 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 di default se si esegue Grafana on-premise o open source.
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.
# Lavorare con i punti di contatto
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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)
Utilizza i punti di contatto per definire in che modo i tuoi contatti vengono avvisati quando viene avviato un avviso. Un punto di contatto può avere una o più integrazioni di punti di contatto, ad esempio Amazon Simple Notification Service o Slack. Quando viene avviato un avviso, viene inviata una notifica a tutte le integrazioni dei punti di contatto elencate per un punto di contatto. Facoltativamente, utilizza i [modelli di notifica](v9-alerting-create-templates.md) per personalizzare i messaggi di notifica per i tipi di punti di contatto.
**Nota**
Puoi creare e modificare punti di contatto per gli avvisi gestiti da Grafana. I punti di contatto per gli avvisi di Alertmanager sono di sola lettura.
## Lavorare con i punti di contatto
Le seguenti procedure descrivono in dettaglio come aggiungere, modificare, testare ed eliminare i punti di contatto.
**Per aggiungere un punto di contatto**
1. **Dalla console Grafana, nel menu Grafana, scegli l'icona Avvisi (campanella) per **aprire la pagina Avvisi**.**
1. **Scegli **Punti di contatto**, quindi Aggiungi punto di contatto.**
1. Dal menu a discesa **Alertmanager**, seleziona un Alertmanager. Il Grafana Alertmanager è selezionato per impostazione predefinita.
1. Inserite un **nome per il punto** di contatto.
1. Da **Integrazione con i punti di contatto**, scegli un tipo e i campi obbligatori in base a quel tipo. Ad esempio, se scegli Slack, inserisci i canali Slack e gli utenti che devono essere contattati.
1. Se disponibile per il punto di contatto selezionato, scegli le **impostazioni opzionali desiderate per specificare impostazioni** aggiuntive.
1. In **Impostazioni di notifica**, seleziona facoltativamente **Disabilita messaggio risolto** se non desideri ricevere una notifica quando si risolve un avviso.
1. Se il tuo punto di contatto necessita di più tipi di punti di contatto, puoi scegliere **Aggiungi integrazione dei punti di contatto** e ripetere i passaggi per ogni tipo di punto di contatto necessario.
1. Scegli **Salva punto di contatto** per salvare le modifiche.
**Per modificare un punto di contatto**
1. Scegli **Punti di contatto** per visualizzare un elenco di punti di contatto esistenti.
1. Seleziona il punto di contatto da modificare, quindi scegli l'icona **Modifica** (penna).
1. Apporta le modifiche necessarie, quindi scegli **Salva punto di contatto** per salvare le modifiche.
Dopo aver creato il punto di contatto, puoi inviare una notifica di prova per verificare che sia configurato correttamente.
**Per inviare una notifica di prova**
1. Scegli **Punti di contatto** per aprire l'elenco dei punti di contatto esistenti.
1. Seleziona il punto di contatto da testare, quindi scegli l'icona **Modifica** (penna).
1. Seleziona l'icona **Test** (aeroplano di carta).
1. Scegli se inviare una notifica di test predefinita o scegli **Personalizzata** per aggiungere annotazioni ed etichette personalizzate nella notifica di test.
1. Scegli **Invia notifica di test** per testare l'avviso con i punti di contatto indicati.
È possibile eliminare i punti di contatto che non sono utilizzati in base a una politica di notifica.
**Per eliminare un punto di contatto**
1. Scegliete **Punti di contatto** per aprire l'elenco dei punti di contatto esistenti.
1. Seleziona il punto di contatto da eliminare, quindi scegli l'icona **Elimina** (cestino).
1. Nella finestra di dialogo di conferma, scegli **Sì, elimina**.
**Nota**
Se il punto di contatto è utilizzato in base a una politica di notifica, è necessario eliminare la politica di notifica o modificarla per utilizzare un punto di contatto diverso prima di eliminare il punto di contatto.
## Elenco dei notificanti supportati
| Name | Tipo |
| --- | --- |
| Amazon SNS | sns |
| OpsGenie | opsgenie |
| Pager Duty | pagerduty |
| Slack | slack |
| VictorOps | victorops |
# Utilizzo delle politiche di notifica
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 determinano il modo in cui gli avvisi vengono indirizzati ai punti di contatto. Le politiche hanno una struttura ad albero, in cui ciascuna politica può avere una o più politiche secondarie. Ogni politica, ad eccezione della politica principale, può anche corrispondere a etichette di avviso specifiche. Ogni avviso viene valutato in base alla politica principale e quindi a ciascuna politica secondaria. Se si abilita l'`Continue matching subsequent sibling nodes`opzione per una politica specifica, la valutazione continua anche dopo una o più corrispondenze. Le impostazioni di configurazione e le informazioni sui punti di contatto di una politica principale regolano il comportamento di un avviso che non corrisponde a nessuna delle politiche secondarie. Una politica principale regola qualsiasi avviso che non corrisponde a una politica specifica.
**Nota**
È possibile creare e modificare politiche di notifica per gli avvisi gestiti da Grafana. Le politiche di notifica per gli avvisi di Alertmanager sono di sola lettura.
**Raggruppamento delle notifiche**
Il raggruppamento classifica le notifiche di avviso di natura simile in un'unica canalizzazione. Ciò consente di controllare le notifiche di avviso durante interruzioni più ampie, quando più parti di un sistema si guastano contemporaneamente, provocando l'avvio simultaneo di un numero elevato di avvisi.
**Esempio di raggruppamento**
Supponiamo di avere 100 servizi connessi a un database in ambienti diversi. Questi servizi sono differenziati dall'etichetta. `env=environmentname` È in vigore una regola di avviso per monitorare se i servizi possono raggiungere il database. La regola di avviso crea avvisi `alertname=DatabaseUnreachable` denominati.
Se si verifica una partizione di rete in cui metà dei servizi non riesce più a raggiungere il database, vengono avviati 50 avvisi diversi. In questa situazione, si desidera ricevere una notifica a pagina singola (anziché 50) con un elenco degli ambienti interessati.
È possibile configurare il raggruppamento in modo che sia `group_by: [alertname]` (senza utilizzare l'`env`etichetta, che è diversa per ogni servizio). Con questa configurazione, Grafana invia un'unica notifica compatta che contiene tutti gli ambienti interessati da questa regola di avviso.
**Gruppi speciali**
Grafana ha due gruppi speciali. Il gruppo predefinito, `group_by: null` raggruppa *tutti gli* avvisi in un unico gruppo. È inoltre possibile utilizzare un'etichetta speciale denominata `...` per raggruppare gli avvisi in base a tutte le etichette, disabilitando efficacemente il raggruppamento e inviando ogni avviso nel proprio gruppo.
## Utilizzo delle notifiche
Le procedure seguenti mostrano come creare e gestire le politiche di notifica.
**Per modificare la politica di notifica principale**
1. **Dalla console Grafana, nel menu Grafana, scegli l'icona Avvisi (campanella) per **aprire la pagina Avvisi**.**
1. **Scegli Politiche di notifica.**
1. Dal menu a discesa **Alertmanager**, seleziona il gestore degli avvisi che desideri modificare.
1. Nella sezione **Root policy**, scegli l'icona **Modifica** (penna).
1. Nel **Punto di contatto predefinito**, aggiorna il punto di contatto a cui devono essere inviate le notifiche relative alle regole quando le regole di avviso non corrispondono a nessuna politica specifica.
1. In **Raggruppa per**, scegli le etichette (o i gruppi speciali) in base ai quali raggruppare gli avvisi.
1. Nelle **opzioni di temporizzazione**, seleziona una delle seguenti opzioni.
+ **Attesa di gruppo**: tempo necessario per memorizzare nel buffer gli avvisi dello stesso gruppo prima di inviare una notifica iniziale. Il valore predefinito è 30 secondi.
+ Intervallo di **gruppo: intervallo** di tempo minimo tra due notifiche per un gruppo. Il valore predefinito è 5 minuti.
+ Intervallo di **ripetizione: intervallo** di tempo minimo prima di inviare nuovamente una notifica se non sono stati aggiunti nuovi avvisi al gruppo. L'impostazione predefinita è 4 ore.
1. Scegli **Salva** per salvare le modifiche.
**Per aggiungere una nuova politica specifica di primo livello**
1. **Dalla console Grafana, nel menu Grafana, scegli l'icona Avvisi (campanella) per **aprire la pagina Avvisi**.**
1. **Scegli Politiche di notifica.**
1. Dal menu a discesa **Alertmanager**, seleziona il gestore degli avvisi che desideri modificare.
1. **Nella sezione **Routing specifico**, scegli Nuova politica specifica.**
1. Nella sezione **Etichette corrispondenti**, aggiungi una o più etichette di avviso corrispondenti. Ulteriori informazioni sulla corrispondenza delle etichette sono disponibili più avanti in questo argomento.
1. In **Punto di contatto**, aggiungi il punto di contatto a cui inviare notifiche se l'avviso corrisponde a questa politica specifica. Le politiche annidate hanno la precedenza su questo punto di contatto.
1. Facoltativamente, abilita **Continua a far corrispondere i nodi di pari livello successivi** per continuare a far corrispondere le politiche di pari livello anche dopo che l'avviso corrisponde alla politica corrente. Quando questo criterio è abilitato, puoi ricevere più di una notifica per lo stesso avviso.
1. Facoltativamente, seleziona **Ignora raggruppamento** per specificare un raggruppamento diverso dalla politica principale.
1. Facoltativamente, seleziona Ignora gli **orari generali per sovrascrivere le opzioni di temporizzazione** nella politica di notifica di gruppo.
1. Scegli **Salva** per salvare le modifiche.
**Per aggiungere una politica annidata**
1. Espandi la politica specifica in base alla quale desideri creare una politica annidata.
1. Scegli **Aggiungi politica annidata**, quindi aggiungi i dettagli (come quando aggiungi una politica specifica di primo livello).
1. Scegli **Salva** per salvare le modifiche.
**Per modificare una politica specifica**
1. Dalla pagina **Avvisi**, scegli **Criteri di notifica** per aprire la pagina che elenca le politiche esistenti.
1. Seleziona la politica che desideri modificare, quindi scegli l'icona **Modifica** (penna).
1. Apporta eventuali modifiche (come quando aggiungi una politica specifica di primo livello).
1. Scegli **Salva policy**.
**Ricerca di politiche**
Puoi cercare nell'albero delle politiche per *Label Matchers* o per *punti di contatto*.
+ Per effettuare la ricerca per punto di contatto, inserisci un nome parziale o completo di un punto di contatto nel campo **Cerca per punto di contatto**.
+ Per effettuare la ricerca per etichetta, inserisci un abbinatore di etichette valido nel campo **Cerca per etichetta**. È possibile inserire più abbinatori, separati da una virgola. Ad esempio, un input matcher valido potrebbe essere. `severity=high, region=~EMEA|NA`
**Nota**
Durante la ricerca per etichetta, tutte le politiche corrispondenti corrisponderanno esattamente. Le corrispondenze parziali e le corrispondenze in stile regex non sono supportate.
**Come funziona la corrispondenza delle etichette**
Una politica corrisponde a un avviso se le etichette dell'avviso corrispondono a tutte le *etichette corrispondenti* specificate nella politica.
+ **Etichetta**: il nome dell'etichetta da abbinare. Deve corrispondere esattamente al nome dell'etichetta dell'avviso.
+ **Operatore**: l'operatore utilizzato per confrontare il valore dell'etichetta con il valore dell'etichetta corrispondente. Gli operatori disponibili sono:
+ `=`Seleziona le etichette il cui valore corrisponde esattamente alla stringa fornita.
+ `!=`Seleziona le etichette il cui valore non corrisponde alla stringa fornita.
+ `=~`Seleziona le etichette il cui valore corrisponde al valore interpretato dall'espressione regolare della stringa fornita (la stringa fornita viene interpretata come un'espressione regolare).
+ `!=`Seleziona le etichette che non corrispondono all'espressione regolare fornita.
+ **Valore**: il valore a cui abbinare il valore dell'etichetta. Può corrispondere come stringa o come espressione regolare, a seconda dell'operatore scelto.
# Personalizza le notifiche
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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)
Personalizza le tue notifiche con i modelli di notifica.
Puoi utilizzare i modelli di notifica per modificare il titolo, il messaggio e il formato del messaggio nelle notifiche.
I modelli di notifica non sono legati a integrazioni di punti di contatto specifiche, come email o Slack. Tuttavia, puoi scegliere di creare modelli di notifica separati per diverse integrazioni di punti di contatto.
Puoi utilizzare i modelli di notifica per:
+ Aggiungere, rimuovere o riordinare le informazioni nella notifica, tra cui riepilogo, descrizione, etichette e annotazioni, valori e link
+ Formatta il testo in grassetto e corsivo e aggiungi o rimuovi interruzioni di riga
Non è possibile utilizzare i modelli di notifica per:
+ Modifica il design delle notifiche nei servizi di messaggistica istantanea come Slack e Microsoft Teams
**Topics**
+ [Usare il linguaggio di template di Go](v9-alerting-notifications-go-templating.md)
+ [Crea modelli di notifica](v9-alerting-create-templates.md)
+ [Riferimento modello](v9-alerting-template-reference.md)
# Usare il linguaggio di template di Go
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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)
[Scrivi modelli di notifica nel linguaggio di template di Go, text/template.](https://pkg.go.dev/text/template)
Questa sezione fornisce una panoramica del linguaggio di template di Go e dei modelli di scrittura in text/template.
## Dot
text/template C'è un cursore speciale chiamato punto, ed è scritto come`.`. Puoi pensare a questo cursore come a una variabile il cui valore cambia a seconda del punto del modello in cui viene utilizzato. Ad esempio, all'inizio di un modello di notifica `.` si fa riferimento all'`ExtendedData`oggetto, che contiene una serie di campi tra cui `Alerts``Status`, `GroupLabels``CommonLabels`, `CommonAnnotations` e`ExternalURL`. Tuttavia, dot potrebbe fare riferimento a qualcos'altro quando viene utilizzato in un `range` elenco completo, all'interno di un `with` o quando si scrivono modelli di funzionalità da utilizzare in altri modelli. Puoi vedere esempi di ciò in[Crea modelli di notifica](v9-alerting-create-templates.md), e tutti i dati e le funzioni in[Riferimento modello](v9-alerting-template-reference.md).
## Tag di apertura e chiusura
In text/template, i modelli iniziano `{{` e finiscono con `}}` indipendentemente dal fatto che il modello stampi una variabile o esegua strutture di controllo come le istruzioni if. Questo è diverso da altri linguaggi di template come Jinja, dove la stampa di una variabile utilizza `{{` e e le strutture di controllo utilizzano e`}}`. `{%` `%}`
## Print (Stampa)
Per stampare il valore di qualcosa usa e. `{{` `}}` È possibile stampare il valore di un punto, un campo di punti, il risultato di una funzione e il valore di una [variabile](#v9-go-variables). Ad esempio, per stampare il `Alerts` campo a cui si riferisce il punto `ExtendedData` devi scrivere quanto segue:
```
{{ .Alerts }}
```
## Esegui iterazioni sugli avvisi
Per stampare solo le etichette di ogni avviso, anziché tutte le informazioni sull'avviso, puoi utilizzare `range` a per iterare gli avvisi in: `ExtendedData`
```
{{ range .Alerts }}
{{ .Labels }}
{{ end }}
```
All'interno dell'intervallo il punto non si riferisce più a`ExtendedData`, ma a un. `Alert` È possibile utilizzare `{{ .Labels }}` per stampare le etichette di ogni avviso. Funziona perché `{{ range .Alerts }}` cambia il punto per fare riferimento all'avviso corrente nell'elenco degli avvisi. Quando l'intervallo è terminato, il punto viene ripristinato al valore che aveva prima dell'inizio dell'intervallo, che in questo esempio è`ExtendedData`:
```
{{ range .Alerts }}
{{ .Labels }}
{{ end }}
{{/* does not work, .Labels does not exist here */}}
{{ .Labels }}
{{/* works, cursor was reset */}}
{{ .Status }}
```
## Esegui iterazioni su annotazioni ed etichette
Scriviamo un modello per stampare le etichette di ogni avviso nel formato`The name of the label is $name, and the value is $value`, dove `$name` e `$value` contiene il nome e il valore di ogni etichetta.
Come nell'esempio precedente, utilizzate un intervallo per scorrere gli avvisi in `.Alerts` modo che il punto si riferisca all'avviso corrente nell'elenco degli avvisi, quindi utilizzate un secondo intervallo sulle etichette ordinate in modo che dot venga aggiornato una seconda volta per fare riferimento all'etichetta corrente. All'interno del secondo intervallo usa `.Name` e stampa `.Value` il nome e il valore di ogni etichetta:
```
{{ range .Alerts }}
{{ range .Labels.SortedPairs }}
The name of the label is {{ .Name }}, and the value is {{ .Value }}
{{ end }}
{{ range .Annotations.SortedPairs }}
The name of the annotation is {{ .Name }}, and the value is {{ .Value }}
{{ end }}
{{ end }}
```
## Dichiarazioni If
È possibile utilizzare le istruzioni if nei modelli. Ad esempio, per stampare `There are no alerts` se non sono presenti avvisi, `.Alerts` è necessario scrivere quanto segue:
```
{{ if .Alerts }}
There are alerts
{{ else }}
There are no alerts
{{ end }}
```
## Con
With è simile alle istruzioni if, tuttavia a differenza delle istruzioni if, `with` aggiorna dot per fare riferimento al valore di with:
```
{{ with .Alerts }}
There are {{ len . }} alert(s)
{{ else }}
There are no alerts
{{ end }}
```
## Variabili
Le variabili in text/template devono essere create all'interno del modello. Ad esempio, per creare una variabile chiamata `$variable` con il valore corrente di dot devi scrivere quanto segue:
```
{{ $variable := . }}
```
Puoi usare `$variable` all'interno di un intervallo o `with` e farà riferimento al valore di dot nel momento in cui la variabile è stata definita, non al valore corrente di dot.
Ad esempio, non puoi scrivere un modello da utilizzare `{{ .Labels }}` nel secondo intervallo perché qui il punto si riferisce all'etichetta corrente, non all'avviso corrente:
```
{{ range .Alerts }}
{{ range .Labels.SortedPairs }}
{{ .Name }} = {{ .Value }}
{{/* does not work because in the second range . is a label not an alert */}}
There are {{ len .Labels }}
{{ end }}
{{ end }}
```
Puoi risolvere questo problema definendo una variabile chiamata `$alert` nel primo intervallo e prima del secondo intervallo:
```
{{ range .Alerts }}
{{ $alert := . }}
{{ range .Labels.SortedPairs }}
{{ .Name }} = {{ .Value }}
{{/* works because $alert refers to the value of dot inside the first range */}}
There are {{ len $alert.Labels }}
{{ end }}
{{ end }}
```
## Intervallo con indice
È possibile ottenere l'indice di ogni avviso all'interno di un intervallo definendo le variabili di indice e valore all'inizio dell'intervallo:
```
{{ $num_alerts := len .Alerts }}
{{ range $index, $alert := .Alerts }}
This is alert {{ $index }} out of {{ $num_alerts }}
{{ end }}
```
## Definire i modelli
È possibile definire modelli che possono essere utilizzati all'interno di altri modelli, utilizzando `define` e il nome del modello tra virgolette doppie. Non è necessario definire modelli con lo stesso nome di altri modelli, inclusi modelli predefiniti come `__subject``__text_values_list`,`__text_alert_list`, `default.title` e`default.message`. Se è stato creato un modello con lo stesso nome di un modello predefinito o un modello in un altro modello di notifica, Grafana potrebbe utilizzare entrambi i modelli. Grafana non impedisce o mostra un messaggio di errore quando ci sono due o più modelli con lo stesso nome.
```
{{ define "print_labels" }}
{{ end }}
```
## Incorpora modelli
È possibile incorporare un modello definito all'interno del modello utilizzando `template` il nome del modello tra virgolette doppie e il cursore da passare al modello:
```
{{ template "print_labels" . }}
```
## Passa i dati ai modelli
All'interno di un modello, il punto si riferisce al valore passato al modello.
Ad esempio, se a un modello viene passato un elenco di avvisi di attivazione, dot si riferisce a quell'elenco di avvisi di attivazione:
```
{{ template "print_alerts" .Alerts }}
```
Se al modello vengono passate le etichette ordinate per un avviso, dot si riferisce all'elenco di etichette ordinate:
```
{{ template "print_labels" .SortedLabels }}
```
Questo è utile quando si scrivono modelli riutilizzabili. Ad esempio, per stampare tutti gli avvisi potresti scrivere quanto segue:
```
{{ template "print_alerts" .Alerts }}
```
Quindi, per stampare solo gli avvisi di attivazione, puoi scrivere questo:
```
{{ template "print_alerts" .Alerts.Firing }}
```
Funziona perché entrambi `.Alerts` `.Alerts.Firing` sono elenchi di avvisi.
```
{{ define "print_alerts" }}
{{ range . }}
{{ template "print_labels" .SortedLabels }}
{{ end }}
{{ end }}
```
## Commenti
Puoi aggiungere commenti con `{{/*` e`*/}}`:
```
{{/* This is a comment */}}
```
Per evitare che i commenti aggiungano interruzioni di riga, usa:
```
{{- /* This is a comment with no leading or trailing line breaks */ -}}
```
## Indentazione
Puoi usare l'indentazione, sia di tabulazioni che di spazi, e le interruzioni di riga, per rendere i modelli più leggibili:
```
{{ range .Alerts }}
{{ range .Labels.SortedPairs }}
{{ .Name }} = {{ .Value }}
{{ end }}
{{ end }}
```
Tuttavia, l'indentazione nel modello sarà presente anche nel testo. Successivamente vedremo come rimuoverlo.
## Rimuovi spazi e interruzioni di riga
In text/template uso `{{-` e `-}}` per rimuovere gli spazi iniziali e finali e le interruzioni di riga.
Ad esempio, quando si utilizzano indentazioni e interruzioni di riga per rendere un modello più leggibile:
```
{{ range .Alerts }}
{{ range .Labels.SortedPairs }}
{{ .Name }} = {{ .Value }}
{{ end }}
{{ end }}
```
L'indentazione e le interruzioni di riga saranno presenti anche nel testo:
```
alertname = "Test"
grafana_folder = "Test alerts"
```
Puoi rimuovere i rientri e le interruzioni di riga dal testo cambiando la posizione `}}` `-}}` all'inizio di ogni intervallo:
```
{{ range .Alerts -}}
{{ range .Labels.SortedPairs -}}
{{ .Name }} = {{ .Value }}
{{ end }}
{{ end }}
```
I rientri e le interruzioni di riga nel modello sono ora assenti dal testo:
```
alertname = "Test"
grafana_folder = "Test alerts"
```
# Crea modelli di notifica
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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)
Crea modelli di notifica riutilizzabili da inviare ai tuoi punti di contatto.
Puoi aggiungere uno o più modelli al tuo modello di notifica.
Il nome del modello di notifica deve essere univoco. Non è possibile avere due modelli con lo stesso nome nello stesso modello di notifica o in modelli di notifica diversi. Evita di definire modelli con lo stesso nome dei modelli predefiniti, ad esempio: `__subject``__text_values_list`,`__text_alert_list`, `default.title` e`default.message`.
Nella scheda Punti di contatto, puoi visualizzare un elenco dei tuoi modelli di notifica.
## Creazione di modelli di notifica
**Per creare un modello di notifica**
1. Fai clic su **Aggiungi modello**.
1. Scegli un nome per il modello di notifica, ad esempio`email.subject`.
1. Scrivi il contenuto del modello nel campo del contenuto.
Esempio:
```
{{ if .Alerts.Firing -}}
{{ len .Alerts.Firing }} firing alerts
{{ end }}
{{ if .Alerts.Resolved -}}
{{ len .Alerts.Resolved }} resolved alerts
{{ end }}
```
1. Fai clic su Salva.
`{{ define "email.subject" }}`(`email.subject`dov'è il nome del modello) e `{{ end }}` viene aggiunto automaticamente all'inizio e alla fine del contenuto.
**Per creare un modello di notifica che contenga più di un modello:**
1. Fai clic su **Aggiungi modello**.
1. Inserisci un nome per il modello di notifica generale. Ad esempio, `email`.
1. Scrivi ogni modello nel campo Contenuto, incluso `{{ define "name-of-template" }}` e `{{ end }}` all'inizio e alla fine di ogni modello. È possibile utilizzare nomi descrittivi per ciascuno dei modelli nel modello di notifica, ad esempio, `email.subject` o`email.message`. In questo caso, non riutilizzare il nome del modello di notifica inserito in precedenza.
Le sezioni seguenti mostrano esempi dettagliati di modelli che potresti creare.
1. Fai clic su Salva.
## Creazione di un modello per l'oggetto di un'e-mail
Crea un modello per l'oggetto di un'e-mail che contenga il numero di avvisi di attivazione e risolti, come in questo esempio:
```
1 firing alerts, 0 resolved alerts
```
**Per creare un modello per l'oggetto di un'e-mail**
1. Crea un modello chiamato `email.subject` con il seguente contenuto:
```
{{ define "email.subject" }}
{{ len .Alerts.Firing }} firing alerts, {{ len .Alerts.Resolved }} resolved alerts
{{ end }}
```
1. Usa il modello quando crei l'integrazione del punto di contatto inserendolo nel campo **Oggetto** con la `template` parola chiave.
```
{{ template "email.subject" . }}
```
## Creazione di un modello per il messaggio di un'e-mail
Crea un modello per il messaggio di un'e-mail che contenga un riepilogo di tutti gli avvisi di attivazione e risolti, come in questo esempio:
```
There are 2 firing alerts, and 1 resolved alerts
Firing alerts:
- alertname=Test 1 grafana_folder=GrafanaCloud has value(s) B=1
- alertname=Test 2 grafana_folder=GrafanaCloud has value(s) B=2
Resolved alerts:
- alertname=Test 3 grafana_folder=GrafanaCloud has value(s) B=0
```
**Per creare un modello per il messaggio di un'e-mail**
1. Crea un modello di notifica chiamato `email` con due modelli nel contenuto: `email.message_alert` e`email.message`.
Il `email.message_alert` modello viene utilizzato per stampare le etichette e i valori per ogni avviso di attivazione e risolto, mentre il `email.message` modello contiene la struttura dell'e-mail.
```
{{- define "email.message_alert" -}}
{{- range .Labels.SortedPairs }}{{ .Name }}={{ .Value }} {{ end }} has value(s)
{{- range $k, $v := .Values }} {{ $k }}={{ $v }}{{ end }}
{{- end -}}
{{ define "email.message" }}
There are {{ len .Alerts.Firing }} firing alerts, and {{ len .Alerts.Resolved }} resolved alerts
{{ if .Alerts.Firing -}}
Firing alerts:
{{- range .Alerts.Firing }}
- {{ template "email.message_alert" . }}
{{- end }}
{{- end }}
{{ if .Alerts.Resolved -}}
Resolved alerts:
{{- range .Alerts.Resolved }}
- {{ template "email.message_alert" . }}
{{- end }}
{{- end }}
{{ end }}
```
1. Utilizza il modello per creare l'integrazione del punto di contatto inserendolo nel campo **Text Body** con la `template` parola chiave.
```
{{ template "email.message" . }}
```
## Creazione di un modello per il titolo di un messaggio Slack
Crea un modello per il titolo di un messaggio Slack che contenga il numero di avvisi attivati e risolti, come nell'esempio seguente:
```
1 firing alerts, 0 resolved alerts
```
**Per creare un modello per il titolo di un messaggio Slack**
1. Crea un modello chiamato `slack.title` con il seguente contenuto:
```
{{ define "slack.title" }}
{{ len .Alerts.Firing }} firing alerts, {{ len .Alerts.Resolved }} resolved alerts
{{ end }}
```
1. Usa il modello quando crei l'integrazione del tuo punto di contatto inserendolo nel campo **Titolo** con la `template` parola chiave.
```
{{ template "slack.title" . }}
```
## Creazione di un modello per il contenuto di un messaggio Slack
Crea un modello per il contenuto di un messaggio Slack che contenga una descrizione di tutti gli avvisi attivati e risolti, comprese le etichette, le annotazioni e l'URL della dashboard:
```
1 firing alerts:
[firing] Test1
Labels:
- alertname: Test1
- grafana_folder: GrafanaCloud
Annotations:
- description: This is a test alert
Go to dashboard: https://example.com/d/dlhdLqF4z?orgId=1
1 resolved alerts:
[firing] Test2
Labels:
- alertname: Test2
- grafana_folder: GrafanaCloud
Annotations:
- description: This is another test alert
Go to dashboard: https://example.com/d/dlhdLqF4z?orgId=1
```
**Per creare un modello per il contenuto di un messaggio Slack**
1. Crea un modello chiamato `slack` con due modelli nel contenuto: `slack.print_alert` e`slack.message`.
Il `slack.print_alert` modello viene utilizzato per stampare le etichette, le annotazioni e DashboardURL mentre il `slack.message` modello contiene la struttura della notifica.
```
{{ define "slack.print_alert" -}}
[{{.Status}}] {{ .Labels.alertname }}
Labels:
{{ range .Labels.SortedPairs -}}
- {{ .Name }}: {{ .Value }}
{{ end -}}
{{ if .Annotations -}}
Annotations:
{{ range .Annotations.SortedPairs -}}
- {{ .Name }}: {{ .Value }}
{{ end -}}
{{ end -}}
{{ if .DashboardURL -}}
Go to dashboard: {{ .DashboardURL }}
{{- end }}
{{- end }}
{{ define "slack.message" -}}
{{ if .Alerts.Firing -}}
{{ len .Alerts.Firing }} firing alerts:
{{ range .Alerts.Firing }}
{{ template "slack.print_alert" . }}
{{ end -}}
{{ end }}
{{ if .Alerts.Resolved -}}
{{ len .Alerts.Resolved }} resolved alerts:
{{ range .Alerts.Resolved }}
{{ template "slack.print_alert" .}}
{{ end -}}
{{ end }}
{{- end }}
```
1. Usa il modello quando crei l'integrazione del punto di contatto inserendolo nel campo **Text Body con la parola chiave**. `template`
```
{{ template "slack.message" . }}
```
## Crea modelli sia per email che per Slack con modelli condivisi
Invece di creare modelli di notifica separati per ogni punto di contatto, come email e Slack, puoi condividere lo stesso modello.
Ad esempio, se desideri inviare un'email con questo oggetto e un messaggio Slack con questo titolo`1 firing alerts, 0 resolved alerts`, puoi creare un modello condiviso.
**Per creare un modello condiviso**
1. Crea un modello chiamato `common.subject_title` con il seguente contenuto:
```
{{ define "common.subject_title" }}
{{ len .Alerts.Firing }} firing alerts, {{ len .Alerts.Resolved }} resolved alerts
{{ end }}
```
1. Per le e-mail, esegui il modello dal campo dell'oggetto nell'integrazione del punto di contatto e-mail:
```
{{ template "common.subject_title" . }}
```
1. Per Slack, esegui il modello dal campo del titolo nell'integrazione con i punti di contatto Slack:
```
{{ template "common.subject_title" . }}
```
## Utilizzo dei modelli di notifica
Utilizza i modelli nei punti di contatto per personalizzare le notifiche.
**Per utilizzare un modello durante la creazione di un punto di contatto**
1. Dal menu **Avvisi**, scegli **Punti di contatto** per visualizzare un elenco di punti di contatto esistenti.
1. Scegli **Aggiungi punto di contatto**. In alternativa, puoi modificare un punto di contatto esistente scegliendo l'icona **Modifica** (penna) accanto al punto di contatto che desideri modificare.
1. Inserisci i modelli che desideri utilizzare in uno o più campi, come **Messaggio** o **Oggetto**. Per inserire un modello, usa il modulo`{{ template "template_name" . }}`, sostituendolo *template\$1name* con il nome del modello che desideri utilizzare.
1. Fai clic su **Salva punto di contatto**.
# Riferimento modello
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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)
Questa sezione fornisce informazioni di riferimento per la creazione dei modelli.
## Dati del modello
I seguenti dati vengono passati ai modelli di messaggio.
| Name | Tipo | Note |
| --- | --- | --- |
| `Receiver` | stringa | Nome del punto di contatto a cui viene inviata la notifica. |
| `Status` | stringa | attivazione se viene attivato almeno un avviso, altrimenti risolto. |
| `Alerts` | Alert | Elenco degli oggetti di avviso inclusi in questa notifica (vedi sotto). |
| `GroupLabels` | KeyValue | Etichette in base alle quali questi avvisi sono stati raggruppati. |
| `CommonLabels` | KeyValue | Etichette comuni a tutti gli avvisi inclusi in questa notifica. |
| `CommonAnnotations` | KeyValue | Annotazioni comuni a tutti gli avvisi inclusi in questa notifica. |
| `ExternalURL` | stringa | Link di ritorno al Grafana che ha inviato la notifica. Se si utilizza un Alertmanager esterno, ricollega a questo Alertmanager. |
Il `Alerts` tipo espone due funzioni per filtrare gli avvisi restituiti.
+ `Alerts.Firing`— Restituisce un elenco di avvisi di attivazione.
+ `Alerts.Resolved`— Restituisce un elenco di avvisi risolti.
**Avviso (tipo)**
Il tipo di avviso contiene i seguenti dati.
| Name | Tipo | Note |
| --- | --- | --- |
| Status | stringa | `firing` o `resolved`. |
| Etichette | KeyValue | Un set di etichette allegate all'avviso. |
| Annotazioni | KeyValue | Un insieme di annotazioni allegate all'avviso. |
| Valori | KeyValue | I valori di tutte le espressioni, incluse le condizioni classiche |
| StartsAt | Time.time | L'ora in cui l'allarme ha iniziato a scattare. |
| EndsAt | Tempo. Tempo | Impostato solo se è nota l'ora di fine di un avviso. Altrimenti impostato su un periodo di timeout configurabile dal momento in cui è stato ricevuto l'ultimo avviso. |
| URL del generatore | stringa | Un link a Grafana o un gestore di avvisi esterno. |
| URL silenzioso | stringa | Un link per silenziare l'avviso (con le etichette precompilate per questo avviso). Solo per gli avvisi gestiti da Grafana. |
| URL del pannello di controllo | stringa | Collegamento alla dashboard di Grafana, se la regola di avviso appartiene a una di esse. Solo per gli avvisi gestiti da Grafana. |
| URL del pannello | stringa | Collegamento al pannello di dashboard di Grafana, se la regola di avviso appartiene a uno. Solo per gli avvisi gestiti da Grafana. |
| Impronta digitale | stringa | Impronta digitale che può essere utilizzata per identificare l'avviso. |
| ValueString | stringa | Una stringa che contiene le etichette e il valore di ogni espressione ridotta nell'avviso. |
**ExtendedData**
L' ExtendedData oggetto contiene le seguenti proprietà.
| Name | Tipo | Description | Esempio |
| --- | --- | --- | --- |
| Ricevitore | `string` | Il nome del punto di contatto che invia la notifica. | `{{ .Receiver }}` |
| Status | `string` | Lo stato è `firing if at least one alert is firing, otherwise resolved.` | `{{ .Status }}` |
| Avvisi | `[]Alert` | Elenco di tutti gli allarmi attivi e risolti in questa notifica. | `There are {{ len .Alerts }} alerts` |
| Avvisi di attivazione | `[]Alert` | Elenco di tutti gli allarmi di attivazione contenuti in questa notifica. | `There are {{ len .Alerts.Firing }} firing alerts` |
| Avvisi risolti | `[]Alert` | Elenco di tutti gli avvisi risolti in questa notifica. | `There are {{ len .Alerts.Resolved }} resolved alerts` |
| GroupLabels | `KeyValue` | Le etichette che raggruppano questi avvisi in questa notifica. | `{{ .GroupLabels }}` |
| CommonLabels | `KeyValue` | Le etichette comuni a tutti gli avvisi di questa notifica. | `{{ .CommonLabels }}` |
| CommonAnnotations | `KeyValue` | Le annotazioni comuni a tutti gli avvisi di questa notifica. | `{{ .CommonAnnotations }}` |
| URL esterno | `string` | Un collegamento all'area di lavoro Grafana o Alertmanager che ha inviato questa notifica. | `{{ .ExternalURL }}` |
**KeyValue tipo**
Il `KeyValue` tipo è un insieme di coppie di key/value stringhe che rappresentano etichette e annotazioni.
Oltre all'accesso diretto ai dati archiviati come file`KeyValue`, esistono anche metodi per ordinare, rimuovere e trasformare i dati.
| Name | Arguments (Argomenti) | Valori restituiti | Note | Esempio |
| --- | --- | --- | --- | --- |
| SortedPairs | | Elenco ordinato di coppie di stringhe di chiavi e valori | | `{{ .Annotations.SortedPairs }}` |
| Rimuovi | [] stringa | KeyValue | Restituisce una copia della Key/Value mappa senza le chiavi fornite. | `{{ .Annotations.Remove "summary" }}` |
| Nomi | | [] stringa | Elenco dei nomi delle etichette | `{{ .Names }}` |
| Valori | | [] stringa | Elenco dei valori delle etichette | `{{ .Values }}` |
**Time** (Orario)
L'ora proviene dal [https://pkg.go.dev/time#Time](https://pkg.go.dev/time#Time)pacchetto Go. È possibile stampare un orario in diversi formati. Ad esempio, per stampare l'ora di attivazione di un avviso nel formato`Monday, 1st January 2022 at 10:00AM`, scrivi il seguente modello:
```
{{ .StartsAt.Format "Monday, 2 January 2006 at 3:04PM" }}
```
Puoi trovare un riferimento per il formato orario di Go [qui](https://pkg.go.dev/time#pkg-constants).
## Funzioni del modello
Utilizzando le funzioni del modello è possibile elaborare etichette e annotazioni per generare notifiche dinamiche. Sono disponibili le seguenti funzioni.
| Name | Tipo di argomento | Tipo restituito | Description |
| --- | --- | --- | --- |
| `humanize` | numero o stringa | stringa | Converte un numero in un formato più leggibile, utilizzando prefissi metrici. |
| `humanize1024` | numero o stringa | stringa | Come humanize, ma usa 1024 come base anziché 1000. |
| `humanizeDuration` | numero o stringa | stringa | Converte una durata in secondi in un formato più leggibile. |
| `humanizePercentage` | numero o stringa | stringa | Converte un valore del rapporto in una frazione di 100. |
| `humanizeTimestamp` | numero o stringa | stringa | Converte un timestamp Unix in pochi secondi in un formato più leggibile. |
| `title` | stringa | stringa | Strings.title, mette in maiuscolo il primo carattere di ogni parola. |
| `toUpper` | stringa | stringa | stringhe. ToUpper, converte tutti i caratteri in lettere maiuscole. |
| `toLower` | stringa | stringa | stringhe. ToLower, converte tutti i caratteri in minuscolo. |
| `match` | motivo, testo | Booleano | espressione regolare. MatchString Verifica una corrispondenza regexp non ancorata. |
| `reReplaceAll` | modello, sostituzione, testo | stringa | Regexp. ReplaceAllString Sostituzione Regexp, non ancorata. |
| `graphLink` | string - Oggetto JSON con e campi `expr` `datasource` | stringa | Restituisce il percorso della visualizzazione grafica in Explore per l'espressione e l'origine dati specificate. |
| `tableLink` | string - Oggetto JSON con `expr` e campi `datasource` | stringa | Restituisce il percorso della vista tabulare in Explore per l'espressione e l'origine dati specificate. |
| `args` | [] interfaccia \$1\$1 | mappa [stringa] interfaccia \$1\$1 | Converte un elenco di oggetti in una mappa con chiavi, ad esempio arg0, arg1. Utilizzate questa funzione per passare più argomenti ai modelli. |
| `externalURL` | nulla | stringa | Restituisce una stringa che rappresenta l'URL esterno. |
| `pathPrefix` | nulla | stringa | Restituisce il percorso dell'URL esterno. |
La tabella seguente mostra esempi di utilizzo di ciascuna funzione.
| Funzione | TemplateString | Input | Expected (Atteso) |
| --- | --- | --- | --- |
| umanizzare | \$1umanizza \$1value\$1 | 1234567,0 | 1,235 M |
| umanizza 1024 | \$1humanize1024 \$1value\$1 | 1048576,0 | 1 Mi |
| Durata umanizzata | \$1UmanizeDuration \$1value\$1 | 899,99 | 14 m 59 s |
| Umanizza la percentuale | \$1humanizePercentage \$1value\$1 | 0,1234567 | 12,35% |
| Umanizza il timestamp | \$1humanizeTimestamp \$1value\$1 | 1435065584,128 | 2015-06-23 13:19:44.128 \$10000 UTC |
| titolo | \$1\$1valore \$1 titolo\$1 | un B C | Aa Bb Cc |
| toUpper | \$1\$1valore \$1 toUpper\$1 | un dB C | A B C |
| toLower | \$1\$1valore \$1 toLower\$1 | un B C | a b c |
| match | \$1match «a\$1» \$1labels.instance\$1 | aa | true |
| reReplaceAll | \$1\$1 reReplaceAll «localhost :( .\$1)» «my.domain: \$11" \$1labels.instance\$1\$1 | host locale: 3000 | mio.domain:3000 |
| GraphLink | \$1\$1graphLink «\$1\$1" expr\$1»:\$1 "up\$1»,\$1 "fonte dati\$1»:\$1 "gdev-prometheus\$1"\$1»\$1\$1 | | /esplorare? left= ["ora-1h», "adesso», "gdev-prometheus», \$1"datasource» :"gdev-prometheus», "expr» :"up», "instant» :false, "range» :true\$1] |
| TableLink | \$1\$1tableLink «\$1\$1" expr\$1»:\$1 "up\$1»,\$1 "fonte dati\$1»:\$1 "gdev-prometheus\$1"\$1»\$1\$1 | | /esplorare? left= ["ora-1h», "adesso», "gdev-prometheus», \$1"datasource» :"gdev-prometheus», "expr» :"up», "instant» :true, "range» :false\$1] |
| args | \$1\$1define «x"\$1\$1 \$1\$1.arg0\$1\$1 \$1\$1.arg1\$1\$1 \$1\$1end\$1\$1 \$1\$1template «x» (args 1 «2")\$1\$1 | | 1 2 |
| URL esterno | \$1URL esterno\$1 | | http://localhost/path/prefix |
| Prefisso del percorso | \$1PathPrefix\$1 | | /percorso/prefisso |
# Silenziamento delle notifiche di avviso per le fonti di dati Prometheus
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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)
*Per le fonti di dati esterne di Alert Manager (incluso Amazon Managed Service for Prometheus), puoi sopprimere le notifiche di avviso con un silenzio.* Un silenzio impedisce solo la creazione di notifiche: i silenzi non impediscono la valutazione delle regole di avviso e non impediscono la visualizzazione delle istanze di avviso nell'interfaccia utente. Quando si silenzia un avviso, si specifica un intervallo di tempo entro il quale tale avviso deve essere soppresso.
È possibile configurare i silenzi per un'origine dati esterna di Alertmanager.
**Nota**
Per sopprimere le notifiche di avviso a intervalli di tempo regolari o per altre fonti di dati (ad esempio, durante i normali periodi di manutenzione), utilizza anziché i silenzi. [Tempi di silenziamento](v9-alerting-notification-muting.md)
**Per aggiungere un silenzio**
1. **Dalla console Grafana, nel menu Grafana, scegli l'icona Avvisi (campanella) per **aprire la pagina Avvisi**.**
1. Scegli **Silences per aprire un elenco** di pagine esistenti. [Lavorare con i punti di contatto](v9-alerting-contact-points.md)
1. **Scegli il gestore di avvisi esterno dal menu a discesa Alertmanager.**
1. **Seleziona** Aggiungi silenzio.
1. Seleziona la data di inizio e di fine in **Silenzio inizio e fine** per indicare quando il silenzio deve entrare in vigore e quando dovrebbe finire.
In alternativa all'impostazione di un'ora di fine, in **Durata**, specifica per quanto tempo viene applicato il silenzio. Questo aggiorna automaticamente l'ora di fine nel campo di **inizio e fine del silenzio**.
1. Nei campi **Nome** e **Valore**, inserisci una o più *etichette corrispondenti*. Gli abbinatori determinano a quali regole si applica il silenzio. La corrispondenza delle etichette viene discussa più dettagliatamente seguendo questa procedura.
1. Facoltativamente, aggiungi un **commento** o modifica il **Creatore** per impostare il proprietario del silenzio.
1. Scegli **Crea** per creare il silenzio.
Puoi modificare un silenzio esistente scegliendo l'icona **Modifica** (penna).
**Corrispondenza delle etichette per la soppressione degli avvisi**
Quando si crea un silenzio, si crea una serie di *etichette corrispondenti* come parte del silenzio. Si tratta di un insieme di regole sulle etichette che devono corrispondere affinché l'avviso venga soppresso. Le etichette corrispondenti sono costituite da tre parti:
+ **Etichetta**: il nome dell'etichetta da abbinare. Deve corrispondere esattamente al nome dell'etichetta dell'avviso.
+ **Operatore**: l'operatore utilizzato per confrontare il valore dell'etichetta con il valore dell'etichetta corrispondente. Gli operatori disponibili sono:
+ `=`Seleziona le etichette il cui valore corrisponde esattamente alla stringa fornita.
+ `!=`Seleziona le etichette il cui valore non corrisponde alla stringa fornita.
+ `=~`Seleziona le etichette il cui valore corrisponde al valore interpretato dall'espressione regolare della stringa fornita (la stringa fornita viene interpretata come un'espressione regolare).
+ `!=`Seleziona le etichette che non corrispondono all'espressione regolare fornita.
+ **Valore**: il valore a cui abbinare il valore dell'etichetta. Può corrispondere come stringa o come espressione regolare, a seconda dell'operatore scelto.
Un silenzio termina alla data di fine indicata, ma è possibile terminare manualmente la soppressione in qualsiasi momento.
**Per terminare un silenzio manualmente**
1. Nella pagina **Avvisi**, scegli **Silenzi** per visualizzare l'elenco dei silenzi esistenti.
1. **Seleziona il silenzio che vuoi terminare e scegli Annulla silenzio.** Questo termina la soppressione degli avvisi.
**Nota**
La disattivazione del silenzio interrompe la soppressione degli avvisi, come se l'ora di fine fosse impostata per l'ora corrente. I silenzi terminati (automaticamente o manualmente) vengono conservati ed elencati per cinque giorni. Non è possibile rimuovere manualmente un silenzio dall'elenco.
**Creazione di un collegamento al modulo per la creazione del silenzio**
È possibile creare un URL per il modulo di creazione del silenzio con i dettagli già compilati. Gli operatori possono utilizzarlo per sopprimere rapidamente un allarme durante un evento operativo.
Quando create un collegamento a un modulo di silenzio, utilizzate un parametro di `matchers` query per specificare le etichette corrispondenti e un parametro di `comment` query per specificare un commento. Il `matchers` parametro richiede uno o più valori nel modulo`[label][operator][value]`, separati da virgole.
**URL di esempio**
Per creare un collegamento a un modulo silenzioso, con etichette corrispondenti `severity=critical` e`cluster!~europe-.*`, con un commento che dice`Silencing critical EU alerts`, usa un URL come il seguente. Sostituisci *mygrafana* con il nome host dell'istanza Grafana.
```
https://mygrafana/alerting/silence/new?matchers=severity%3Dcritical%2Ccluster!~europe-*&comment=Silence%20critical%20EU%20alert
```
Per creare un collegamento a una nuova pagina silenziosa per un Alertmanager esterno, aggiungi un parametro di `alertmanager` query con il nome dell'origine dati Alertmanage, ad esempio. `alertmanager=myAlertmanagerdatasource`
# Tempi di silenziamento
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 tempistica di silenziamento è un intervallo di tempo ricorrente in cui non vengono generate o inviate nuove notifiche relative a una policy. Utilizzali per evitare che gli avvisi si attivino in un periodo specifico e ricorrente, ad esempio un periodo di manutenzione regolare.
Analogamente ai silenzi, i tempi di disattivazione dell'audio non impediscono la valutazione delle regole di avviso né impediscono la visualizzazione delle istanze di avviso nell'interfaccia utente. Impediscono solo la creazione di notifiche.
È possibile configurare i tempi di silenziamento gestiti da Grafana e i tempi di silenziamento per un'origine dati Alertmanager esterna.
**Tempi di silenziamento rispetto ai silenzi**
La tabella seguente evidenzia le differenze tra i tempi di silenziamento e i silenzi.
| Tempistica del silenziamento | Silenzio |
| --- | --- |
| Utilizza definizioni di intervalli di tempo che possono ripetersi. | Ha un'ora di inizio e di fine fisse. |
| Viene creato e quindi aggiunto alle politiche di notifica. | Utilizza le etichette per confrontarle con un avviso per determinare se silenziarlo o meno. |
| Funziona con avvisi Grafana e gestori di avvisi esterni. | Funziona solo con gestori di avvisi esterni. |
**Per creare una tempistica di silenziamento**
1. **Dalla console Grafana, nel menu Grafana, scegli l'icona Avvisi (campanella) per **aprire la pagina Avvisi**.**
1. **Scegli Politiche di notifica.**
1. Dal menu a discesa **Alertmanager**, seleziona il gestore degli avvisi che desideri modificare.
1. **Nella sezione Tempi di **silenziamento, scegli il pulsante Aggiungi tempi di** silenziamento.**
1. Scegli l'intervallo di tempo a cui desideri applicare la tempistica di silenziamento.
1. Scegli **Invia per creare la tempistica** del silenziamento.
**Per aggiungere una tempistica di silenziamento a una politica di notifica**
1. **Seleziona la politica di notifica a cui desideri aggiungere la tempistica di silenziamento e scegli il pulsante Modifica.**
1. Dal menu a discesa **Tempi di silenziamento, seleziona gli** orari di silenziamento che desideri aggiungere alla politica.
**Scegli il pulsante Salva politica.**
**Intervalli di tempo**
Un intervallo di tempo è una definizione per un intervallo di tempo. Se un avviso viene avviato durante questo intervallo, viene soppresso. Gli intervalli sono supportati utilizzando `:` (ad esempio,). `monday:thursday` Una temporizzazione di silenziamento può contenere più intervalli di tempo. Un intervallo di tempo è costituito da più campi (i dettagli sono riportati nell'elenco seguente), che devono corrispondere tutti per eliminare gli avvisi. Ad esempio, se si specificano i giorni della settimana `monday:friday` e l'intervallo di orario dalle 8:00 alle 9:00, gli avvisi vengono eliminati dalle 8:00 alle 9:00, dal lunedì al venerdì, ma non, ad esempio, dalle 8:00 alle 9 il sabato.
+ **Intervallo di tempo**: l'ora del giorno in cui sopprimere le notifiche. È composto da due sottocampi, Ora di **inizio e Ora** di **fine**. Un esempio di ora è`14:30`. L'ora è espressa nella notazione di 24 ore, in UTC.
+ **Giorni della settimana**: i giorni della settimana. Può essere un singolo giorno, ad esempio un intervallo`monday`, ad esempio`monday:friday`, o un elenco di giorni separati da virgole, ad esempio. `monday, tuesday, wednesday`
+ **Mesi**: i mesi da selezionare. È possibile specificare i mesi con designazioni numeriche o con il nome completo del mese, ad esempio, `1` oppure `january` entrambi specificano gennaio. È possibile specificare un solo mese, un intervallo di mesi o un elenco di mesi separati da virgole.
+ **Giorni del mese**: le date entro un mese. I valori possono variare da `1` -`31`. I valori negativi specificano i giorni del mese in ordine inverso, quindi `-1` rappresentano l'ultimo giorno del mese. I giorni del mese possono essere specificati come un singolo giorno, un intervallo di giorni o un elenco di giorni separato da virgole.
+ **Anni**: l'anno o gli anni per l'intervallo. Ad esempio, `2023:2025`.
Ciascuno di questi elementi può essere un elenco e almeno un elemento nell'elemento deve essere soddisfatto per avere una corrispondenza. Quindi, se imposti gli anni`2023:2025, 2027`, allora sarebbe vero nel 2023, 2024, 2025 e 2027 (ma non nel 2026).
Se un campo viene lasciato vuoto, qualsiasi momento corrisponderà al campo. Un momento deve corrispondere a tutti i campi per corrispondere a un intervallo di tempo completo.
Se desideri specificare una durata esatta, specifica tutte le opzioni necessarie per tale durata. Ad esempio, se desideri creare un intervallo di tempo per il primo lunedì del mese, per marzo, giugno, settembre e dicembre, tra le 12:00 e le 24:00 UTC, la specifica dell'intervallo di tempo potrebbe essere:
+ Intervallo di tempo:
+ Ora di inizio: `12:00`
+ Ora di fine: `24:00`
+ Giorni della settimana: `monday`
+ Mesi: `3, 6, 9, 12`
+ Giorni del mese: `1:7`
# Visualizza e filtra per gruppi di avvisi
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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 gruppi di avvisi mostrano avvisi raggruppati provenienti da un'istanza di Alertmanager. Per impostazione predefinita, le regole di avviso sono raggruppate in base alle chiavi di etichetta per la politica principale nelle politiche di notifica. Il raggruppamento delle regole di avviso comuni in un unico gruppo di avvisi impedisce l'attivazione di regole di avviso duplicate.
È possibile visualizzare i gruppi di avvisi e anche filtrare le regole di avviso che corrispondono a criteri specifici.
**Per visualizzare i gruppi di avvisi**
1. Nel menu Grafana, fai clic sull'icona **Avvisi** (campana) per aprire la pagina Avvisi che elenca gli avvisi esistenti.
1. Fai clic su **Gruppi di avvisi** per aprire la pagina che elenca i gruppi esistenti.
1. Dal menu a discesa **Alertmanager**, seleziona un Alertmanager esterno come fonte di dati.
1. Dal menu a discesa **personalizzato raggruppa per**, seleziona una combinazione di etichette per visualizzare un raggruppamento diverso da quello predefinito. Ciò è utile per eseguire il debug e verificare il raggruppamento delle politiche di notifica.
Se un avviso non contiene le etichette specificate nel raggruppamento della policy principale o nel raggruppamento personalizzato, l'avviso viene aggiunto a un gruppo catch all con un'intestazione di. `No grouping`
**Per filtrare per etichetta**
+ In **Cerca**, inserisci un'etichetta esistente per visualizzare gli avvisi corrispondenti all'etichetta.
Ad esempio, `environment=production,region=~US|EU,severity!=warning`.
**Per filtrare per stato**
+ In **Stati**, seleziona gli stati Attivo, Soppresso o Non elaborato per visualizzare gli avvisi corrispondenti allo stato selezionato. Tutti gli altri avvisi sono nascosti.
# Visualizza gli errori di notifica
****
**Questo argomento della documentazione è progettato per le aree di lavoro Grafana che supportano la versione 9.x di Grafana.**
Per le aree di lavoro Grafana che supportano la versione 10.x di Grafana, vedere. [Funzionamento nella versione 10 di Grafana](using-grafana-v10.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)
Visualizza gli errori di notifica e scopri perché non sono stati inviati o non sono stati ricevuti.
**Nota**
Questa funzionalità è supportata solo per Grafana Alertmanager.
**Per visualizzare gli errori di notifica**
1. Nel menu Grafana, fai clic sull'icona **Avvisi** (campana) per aprire la pagina Avvisi che elenca gli avvisi esistenti.
1. Scegli **Punti di contatto** per visualizzare un elenco dei punti di contatto esistenti.
Se qualche punto di contatto non funziona, un messaggio nell'angolo destro dello schermo avvisa l'utente del fatto che ci sono errori e quanti sono.
1. Fai clic su un punto di contatto per visualizzare i dettagli degli errori relativi a quel punto di contatto.
I dettagli dell'errore vengono visualizzati se si posiziona il puntatore del mouse sull'icona Errore.
Se un punto di contatto ha più di un'integrazione, vengono visualizzati tutti gli errori per ciascuna delle integrazioni elencate.
1. Nella colonna Health, controlla lo stato della notifica.
Può essere OK, Nessun tentativo o Errore.