Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# -Übersicht
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
Egal, ob Sie gerade erst anfangen oder ein erfahrener Benutzer von Grafana Alerting sind, erfahren Sie mehr über die Grundlagen und verfügbaren Funktionen, mit denen Sie Benachrichtigungen erstellen, verwalten und darauf reagieren können; und verbessern Sie die Fähigkeit Ihres Teams, Probleme schnell zu lösen.
## Prinzipien
In Prometheus basierten Warnsystemen verfügen Sie über einen Alert-Generator, der Alerts generiert, und einen Alert-Empfänger, der Alerts empfängt. Zum Beispiel ist Prometheus ein Alarmgenerator und für die Auswertung von Warnungsregeln verantwortlich, während Alertmanager ein Alarmempfänger ist und für das Gruppieren, Sperren, Stummschalten und Senden von Benachrichtigungen über ausgelöste und gelöste Alarme verantwortlich ist.
Grafana Alerting basiert auf dem Prometheus-Modell zur Entwicklung von Warnsystemen. Es verfügt über einen internen Alarmgenerator, der für die Planung und Auswertung von Alarmregeln zuständig ist, sowie über einen internen Alarmempfänger, der für das Gruppieren, Sperren, Stummschalten und Senden von Benachrichtigungen zuständig ist. Grafana verwendet Prometheus nicht als Alert-Generator, da Grafana Alerting neben Prometheus auch mit vielen anderen Datenquellen arbeiten muss. Es verwendet jedoch Alertmanager als Alert-Empfänger.
Alarme werden an den Alarmempfänger gesendet, wo sie weitergeleitet, gruppiert, gesperrt, stummgeschaltet und benachrichtigt werden. In Grafana Alerting ist der Standard-Alert-Empfänger der in Grafana eingebettete Alertmanager, der als Grafana Alertmanager bezeichnet wird. [Sie können jedoch auch andere Alertmanager verwenden, und diese werden als externe Alertmanager bezeichnet.](v10-alerting-setup-alertmanager.md)
## Grundlagen
Im Folgenden finden Sie einen Überblick über die verschiedenen Teile der Grafana-Warnung.
### Warnungsregeln
Eine Warnregel besteht aus einer Reihe von Kriterien, die bestimmen, wann eine Warnung ausgelöst werden soll. Sie besteht aus einer oder mehreren Abfragen und Ausdrücken, einer Bedingung, die erfüllt sein muss, einem Intervall, das bestimmt, wie oft die Warnungsregel ausgewertet wird, und einer Dauer, über die die Bedingung erfüllt sein muss, damit eine Warnung ausgelöst wird.
Warnungsregeln werden über ihr Intervall hinweg ausgewertet, und für jede Warnungsregel können null, eine oder eine beliebige Anzahl von Alarmen gleichzeitig ausgelöst werden. Der Status einer Warnungsregel wird durch die höchste `severe` Alarmstufe bestimmt, die entweder Normal, Ausstehend oder Auslösend lauten kann. Wenn beispielsweise mindestens eine Warnung einer Warnungsregel ausgelöst wird, wird auch die Warnungsregel ausgelöst. Der Zustand einer Warnungsregel wird durch den Status ihrer letzten Bewertung bestimmt. Diese können OK, Fehler und sein NoData.
Ein sehr wichtiges Merkmal von Warnungsregeln ist, dass sie benutzerdefinierte Anmerkungen und Beschriftungen unterstützen. Diese ermöglichen es Ihnen, Benachrichtigungen mit zusätzlichen Metadaten wie Zusammenfassungen und Beschreibungen zu versehen und zusätzliche Beschriftungen hinzuzufügen, um Benachrichtigungen an bestimmte Benachrichtigungsrichtlinien weiterzuleiten.
### Benachrichtigungen
Warnmeldungen werden durch Gruppen von key/value Paaren, die als Labels bezeichnet werden, eindeutig identifiziert. Jeder Schlüssel ist ein Labelname und jeder Wert ist ein Labelwert. Beispielsweise könnte eine Warnung die Beschriftungen `foo=bar` und eine andere Warnung die Beschriftungen haben`foo=baz`. Eine Warnung kann viele Bezeichnungen haben, `foo=bar,bar=baz` z. B. kann sie dieselbe Bezeichnung nicht zweimal haben, z. `foo=bar,foo=baz` B. Zwei Alerts können auch nicht dieselben Labels haben, und wenn zwei Alerts dieselbe Bezeichnung wie `foo=bar,bar=baz` und haben, `foo=bar,bar=baz` dann wird eine der Alerts verworfen. Warnungen werden behoben, wenn die Bedingung in der Warnungsregel nicht mehr erfüllt ist oder die Warnungsregel gelöscht wird.
In Grafana Managed Alerts können sich Benachrichtigungen im Status Normal, Ausstehend, Warnung, Keine Daten oder Fehler befinden. In von Datenquellen verwalteten Warnmeldungen wie Mimir und Loki können Benachrichtigungen den Status Normal, Ausstehend und Warnung haben, jedoch nicht oder Fehler. NoData
### Kontaktstellen
Kontaktstellen bestimmen, wohin Benachrichtigungen gesendet werden. Möglicherweise haben Sie eine Kontaktstelle, die Benachrichtigungen an eine E-Mail-Adresse, an Slack, an ein Incident Management System (IRM) wie Grafana OnCall oder Pagerduty oder an einen Webhook sendet.
Die Benachrichtigungen, die von Kontaktstellen gesendet werden, können mithilfe von Benachrichtigungsvorlagen angepasst werden. Sie können Benachrichtigungsvorlagen verwenden, um den Titel, die Nachricht und die Struktur der Benachrichtigung zu ändern. Benachrichtigungsvorlagen sind nicht spezifisch für einzelne Integrationen oder Kontaktstellen.
### Richtlinien für Benachrichtigungen
Benachrichtigungsrichtlinien gruppieren Benachrichtigungen und leiten sie dann an Kontaktstellen weiter. Sie legen fest, wann Benachrichtigungen gesendet werden und wie oft Benachrichtigungen wiederholt werden sollen.
Benachrichtigungen werden mithilfe von Label-Matchern mit Benachrichtigungsrichtlinien abgeglichen. Dabei handelt es sich um menschenlesbare Ausdrücke, mit denen bestätigt wird, ob die Bezeichnungen der Warnung exakt übereinstimmen, ob sie nicht exakt übereinstimmen, ob sie den erwarteten Text enthalten oder nicht. Der Matcher `foo=bar` ordnet beispielsweise Warnungen mit der Bezeichnung zu, `foo=bar` während der Matcher Warnungen mit einem beliebigen Label namens foo mit einem Wert `foo=~[a-zA-Z]+` abgleicht, der dem regulären Ausdruck entspricht. `[a-zA-Z]+`
Standardmäßig kann eine Warnung nur einer Benachrichtigungsrichtlinie entsprechen. Mit dieser `continue` Funktion können jedoch Benachrichtigungen erstellt werden, die einer beliebigen Anzahl von Benachrichtigungsrichtlinien gleichzeitig entsprechen. Weitere Informationen zu Benachrichtigungsrichtlinien finden Sie unter [Benachrichtigungsrichtlinien](v10-alerting-explore-notifications-policies-details.md).
### Zeiten der Stille und Stummschaltung
Stummschalten und Stummschalten ermöglichen es dir, Benachrichtigungen für bestimmte Benachrichtigungen oder sogar ganze Benachrichtigungsrichtlinien zu pausieren. Verwenden Sie eine Stummschaltung, um Benachrichtigungen spontan zu unterbrechen, z. B. während Sie an einer Lösung für eine Warnung arbeiten. Verwenden Sie die Stummschaltung, um Benachrichtigungen in regelmäßigen Intervallen zu unterbrechen, z. B. während regelmäßig geplanten Wartungsfenstern.
**Topics**
+ [Prinzipien](#v10-alerting-overview-principles)
+ [Grundlagen](#v10-alerting-overview-fundamentals)
+ [Datenquellen und Grafana-Alerting](v10-alerting-overview-datasources.md)
+ [Warnmeldungen bei numerischen Daten](v10-alerting-overview-numeric.md)
+ [Beschriftungen und Anmerkungen](v10-alerting-overview-labels.md)
+ [Über Warnungsregeln](v10-alerting-explore-rules.md)
+ [Alert-Manager](v10-alerting-explore-alertmanager.md)
+ [Kontaktstellen](v10-alerting-explore-contacts.md)
+ [Benachrichtigungen](v10-alerting-explore-notifications.md)
+ [Warnung bei hoher Verfügbarkeit](v10-alerting-explore-high-availability.md)
# Datenquellen und Grafana-Alerting
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
Es gibt eine Reihe von Datenquellen, die mit Grafana Alerting kompatibel sind. Jede Datenquelle wird von einem Plugin unterstützt. Grafana-Alerting erfordert, dass Datenquellen-Plugins *Backend-Plugins* sind, um Regeln anhand der Datenquelle auszuwerten, da die Evaluierungs-Engine im Backend läuft. Plugins müssen außerdem angeben, dass sie mit Grafana-Alerting kompatibel sind.
Datenquellen werden im Laufe der Zeit hinzugefügt und aktualisiert. Es ist bekannt, dass die folgenden Datenquellen mit Grafana-Warnungen kompatibel sind.
+ [Stellen Sie eine Connect zu einer CloudWatch Amazon-Datenquelle her](using-amazon-cloudwatch-in-AMG.md)
+ [Stellen Sie eine Connect zu einer Azure Monitor-Datenquelle her](using-azure-monitor-in-AMG.md)
+ [Stellen Sie eine Connect zu einer Amazon OpenSearch Service-Datenquelle her](using-Amazon-OpenSearch-in-AMG.md)
+ [Stellen Sie eine Connect zu einer Google Cloud Monitoring-Datenquelle her](using-google-cloud-monitoring-in-grafana.md)
+ [Stellen Sie eine Connect zu einer Graphite-Datenquelle her](using-graphite-in-AMG.md)
+ [Stellen Sie eine Connect zu einer InfluxDB-Datenquelle her](using-influxdb-in-AMG.md)
+ [Stellen Sie eine Connect zu einer Loki-Datenquelle her](using-loki-in-AMG.md)
+ [Stellen Sie eine Connect zu einer Microsoft SQL Server-Datenquelle her](using-microsoft-sql-server-in-AMG.md)
+ [Stellen Sie eine Connect zu einer MySQL-Datenquelle her](using-mysql-in-AMG.md)
+ [Stellen Sie eine Connect zu einer OpenTSDB-Datenquelle her](using-opentsdb-in-AMG.md)
+ [Stellen Sie eine Connect zu einer PostgreSQL-Datenquelle her](using-postgresql-in-AMG.md)
+ [Connect zu Amazon Managed Service for Prometheus und Open-Source-Prometheus-Datenquellen her](prometheus-data-source.md)
+ [Stellen Sie eine Connect zu einer Jaeger-Datenquelle her](jaeger-data-source.md)
+ [Stellen Sie eine Connect zu einer Zipkin-Datenquelle her](zipkin-data-source.md)
+ [Mit einer Tempo-Datenquelle verbinden](tempo-data-source.md)
+ [Konfigurieren Sie eine TestData Datenquelle zum Testen](testdata-data-source.md)
Ausführlichere Informationen zu Datenquellen und Datenquellen-Plugins in Amazon Managed Grafana finden Sie unter[Verbinden zu Datenquellen](AMG-data-sources.md).
# Warnmeldungen bei numerischen Daten
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
In diesem Thema wird beschrieben, wie Grafana mit Benachrichtigungen bei numerischen Daten und nicht bei Zeitreihendaten umgeht.
Bei bestimmten Datenquellen können numerische Daten, bei denen es sich nicht um Zeitreihen handelt, direkt gemeldet oder an Server Side Expressions (SSE) übergeben werden. Dies ermöglicht eine bessere Verarbeitung und damit eine höhere Effizienz innerhalb der Datenquelle und kann auch die Warnungsregeln vereinfachen. Bei Warnmeldungen für numerische Daten anstelle von Zeitreihendaten ist es nicht erforderlich, jede beschriftete Zeitreihe auf eine einzelne Zahl zu reduzieren. Stattdessen werden beschriftete Zahlen stattdessen an Grafana zurückgegeben.
## Tabellendaten
Diese Funktion wird bei Backend-Datenquellen unterstützt, die Tabellendaten abfragen:
+ SQL-Datenquellen wie MySQL, Postgres, MSSQL und Oracle.
+ Die auf Azure Kusto basierenden Dienste: Azure Monitor (Logs), Azure Monitor (Azure Resource Graph) und Azure Data Explorer.
Eine Abfrage mit von Grafana verwalteten Benachrichtigungen oder SSE wird bei diesen Datenquellen als numerisch betrachtet, wenn:
+ Die Option „Format AS“ ist in der Datenquellenabfrage auf „Tabelle“ eingestellt.
+ Die von der Abfrage an Grafana zurückgegebene Tabellenantwort enthält nur eine numerische Spalte (z. B. int, double, float) und optional zusätzliche Zeichenkettenspalten.
Wenn es Zeichenkettenspalten gibt, werden diese Spalten zu Beschriftungen. Der Name einer Spalte wird zum Labelnamen, und der Wert für jede Zeile wird zum Wert der entsprechenden Bezeichnung. Wenn mehrere Zeilen zurückgegeben werden, sollte jede Zeile mit ihren Beschriftungen eindeutig identifiziert werden.
## Beispiel
Für eine MySQL-Tabelle namens „DiskSpace“:
| Zeit | Host | Festplatte | PercentFree |
| --- | --- | --- | --- |
| 2021-Juni-7 | Netz 1 | /usw | 3 |
| 2021-Juni-7 | Netz 2 | /var | 4 |
| 2021-Juni-7 | Netz 3 | /var | 8 |
| ... | ... | ... | ... |
Sie können die Datenfilterung rechtzeitig abfragen, ohne jedoch die Zeitreihe an Grafana zurückzugeben. Zum Beispiel eine Warnung, die pro Host und Festplatte ausgelöst wird, wenn weniger als 5% freier Speicherplatz zur Verfügung steht:
```
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)
```
Diese Abfrage gibt die folgende Tabellenantwort an Grafana zurück:
| Host | Festplatte | PercentFree |
| --- | --- | --- |
| web1 | /usw | 3 |
| web2 | /var | 4 |
| web3 | /var | 0 |
Wenn diese Abfrage als **Bedingung** in einer Warnungsregel verwendet wird, wird ein Wert ungleich Null als Warnung verwendet. Infolgedessen werden drei Warnungsinstanzen erzeugt:
| Labels | Status |
| --- | --- |
| \$1host=WEB1, DISK=/etc\$1 | Warnfunktion |
| \$1Host=Web2, Festplatte=/var\$1 | Warnfunktion |
| \$1host=WEB3, Festplatte=/var\$1 | Normal |
# Beschriftungen und Anmerkungen
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
Beschriftungen und Anmerkungen enthalten Informationen zu einer Warnung. Sowohl Beschriftungen als auch Anmerkungen haben dieselbe Struktur: eine Reihe benannter Werte; ihre Verwendungszwecke sind jedoch unterschiedlich. Ein Beispiel für eine Bezeichnung oder eine entsprechende Anmerkung könnte sein`alertname="test"`.
Der Hauptunterschied zwischen einer Bezeichnung und einer Anmerkung besteht darin, dass Beschriftungen verwendet werden, um eine Warnung von allen anderen Warnungen zu unterscheiden, während Anmerkungen dazu verwendet werden, einer vorhandenen Warnung zusätzliche Informationen hinzuzufügen.
Stellen Sie sich zum Beispiel zwei Warnmeldungen mit hohem CPU-Wert vor: eine für `server1` und eine weitere für`server2`. In einem solchen Beispiel könnten wir eine Bezeichnung haben, `server` bei der die erste Warnung die Bezeichnung `server="server1"` und die zweite Warnung die Bezeichnung trägt`server="server2"`. Möglicherweise möchten wir jedoch auch jeder Warnung eine Beschreibung hinzufügen`"The CPU usage for server1 is above 75%."`, z. B. wo `server1` und `75%` werden durch den Namen und die CPU-Auslastung des Servers ersetzt (Informationen dazu finden Sie in der Dokumentation). [Vorlagen für Beschriftungen und Anmerkungen](v10-alerting-overview-labels-templating.md) Diese Art von Beschreibung wäre besser als Anmerkung geeignet.
## Labels
Beschriftungen enthalten Informationen, anhand derer eine Warnung identifiziert werden kann. Ein Beispiel für ein Etikett könnte sein`server=server1`. Jede Warnung kann mehr als ein Label haben, und der komplette Satz von Labels für eine Warnung wird als Labelsatz bezeichnet. Es ist dieser Labelsatz, der die Warnung identifiziert.
Beispielsweise kann für eine Warnung die Bezeichnung festgelegt sein, `{alertname="High CPU usage",server="server1"}` während für eine andere Warnung die Bezeichnung festgelegt sein könnte`{alertname="High CPU usage",server="server2"}`. Dabei handelt es sich um zwei separate Benachrichtigungen, da ihre `alertname` Beschriftungen zwar identisch sind, ihre `server` Beschriftungen jedoch unterschiedlich sind.
Die für eine Warnung festgelegte Bezeichnung ist eine Kombination aus den Bezeichnungen aus der Datenquelle, benutzerdefinierten Bezeichnungen aus der Warnungsregel und einer Reihe von reservierten Bezeichnungen wie. `alertname`
**Benutzerdefinierte Beschriftungen**
Benutzerdefinierte Beschriftungen sind zusätzliche Beschriftungen aus der Warnungsregel. Wie Anmerkungen müssen benutzerdefinierte Beschriftungen einen Namen haben, und ihr Wert kann eine Kombination aus Text und Vorlagencode enthalten, der ausgewertet wird, wenn eine Warnung ausgelöst wird. Eine Dokumentation zur Erstellung von Vorlagen für benutzerdefinierte Beschriftungen finden Sie [hier.](v10-alerting-overview-labels-templating.md)
Wenn Sie benutzerdefinierte Beschriftungen mit Vorlagen verwenden, müssen Sie sicherstellen, dass sich der Labelwert zwischen aufeinanderfolgenden Auswertungen der Warnmeldungsregel nicht ändert, da dies zu einer großen Anzahl unterschiedlicher Benachrichtigungen führen kann. Es ist jedoch in Ordnung, wenn die Vorlage unterschiedliche Labelwerte für verschiedene Warnungen erzeugt. Fügen Sie den Wert der Abfrage beispielsweise nicht in ein benutzerdefiniertes Label ein, da dadurch bei jeder Änderung des Werts ein neuer Satz von Benachrichtigungen erstellt wird. Verwenden Sie stattdessen Anmerkungen.
Es ist auch wichtig sicherzustellen, dass das für eine Warnung festgelegte Label nicht zwei oder mehr Labels mit demselben Namen enthält. Wenn ein benutzerdefiniertes Label denselben Namen wie ein Label aus der Datenquelle hat, wird es dieses Label ersetzen. Sollte ein benutzerdefiniertes Label jedoch denselben Namen wie ein reserviertes Label haben, wird das benutzerdefinierte Label in der Warnung weggelassen.
## Anmerkungen
Bei Anmerkungen handelt es sich um benannte Paare, die vorhandenen Warnungen zusätzliche Informationen hinzufügen. In Grafana gibt es eine Reihe von vorgeschlagenen Anmerkungen wie`description`, `summary``runbook_url`, `dashboardUId` und. `panelId` Wie benutzerdefinierte Beschriftungen müssen Anmerkungen einen Namen haben, und ihr Wert kann eine Kombination aus Text und Vorlagencode enthalten, die ausgewertet wird, wenn eine Warnung ausgelöst wird. Wenn eine Anmerkung Vorlagencode enthält, wird die Vorlage einmal ausgewertet, wenn die Warnung ausgelöst wird. Sie wird nicht erneut bewertet, auch wenn die Warnung behoben ist. [Eine Dokumentation zur Erstellung von Vorlagen für Anmerkungen finden Sie hier.](v10-alerting-overview-labels-templating.md)
**Topics**
+ [Labels](#v10-alerting-overview-labels-labels)
+ [Anmerkungen](#v10-alerting-overview-labels-annotations)
+ [So funktioniert der Labelabgleich](v10-alerting-overview-labels-matching.md)
+ [Etiketten in Grafana-Benachrichtigungen](v10-alerting-overview-labels-alerting.md)
+ [Vorlagen für Beschriftungen und Anmerkungen](v10-alerting-overview-labels-templating.md)
# So funktioniert der Labelabgleich
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
Verwenden Sie Labels und Label-Matcher, um Warnungsregeln mit Benachrichtigungsrichtlinien und Stummschalten zu verknüpfen. Auf diese Weise können Sie Ihre Warnungsinstanzen sehr flexibel verwalten und angeben, welche Richtlinie sie behandeln soll und welche Alarme ausgeblendet werden sollen.
Ein Label-Matcher besteht aus drei verschiedenen Teilen: dem **Label**, dem **Wert** und dem **Operator**.
+ Das **Label-Feld** ist der Name der Bezeichnung, der zugeordnet werden soll. Es muss genau mit dem Labelnamen übereinstimmen.
+ Das **Wertfeld** stimmt mit dem entsprechenden Wert für den angegebenen **Labelnamen** überein. Wie es übereinstimmt, hängt vom **Operator-Wert** ab.
+ Das Feld **Operator** ist der Operator, der mit dem Labelwert verglichen werden soll. Die verfügbaren Operatoren sind:
| Operator | Description |
| --- | --- |
| `=` | Wählen Sie Beschriftungen aus, die genau dem Wert entsprechen. |
| `!=` | Wählen Sie Beschriftungen aus, die nicht dem Wert entsprechen. |
| `=~` | Wählen Sie Beschriftungen aus, die dem Wert im Regex-Format entsprechen. |
| `!~` | Wählen Sie Beschriftungen aus, die nicht mit dem Regex-Wert übereinstimmen. |
Wenn Sie mehrere Label-Matcher verwenden, werden sie mit dem logischen Operator AND kombiniert. Das bedeutet, dass alle Matcher übereinstimmen müssen, um eine Regel mit einer Richtlinie zu verknüpfen.
## Beispiel
Wenn Sie den folgenden Satz von Bezeichnungen für Ihre Warnung definieren:
```
{ foo=bar, baz=qux, id=12 }
```
dann:
+ Ein Label-Matcher, der als definiert ist, `foo=bar` entspricht dieser Warnungsregel.
+ Ein Label-Matcher, der als definiert ist, entspricht `foo!=bar` *nicht* dieser Warnungsregel.
+ Ein Label-Matcher, der als definiert ist, `id=~[0-9]+` entspricht dieser Warnungsregel.
+ Ein Label-Matcher, der als definiert ist, `baz!~[0-9]+` entspricht dieser Warnungsregel.
+ Zwei Label-Matcher, die als definiert sind `foo=bar` und dieser Warnungsregel `id=~[0-9]+` entsprechen.
## Beschriftungen ausschließen
Sie können auch Label-Matcher schreiben, um Labels auszuschließen.
Hier ist ein Beispiel, das zeigt, wie das Label `team` ausgeschlossen werden kann. Sie können zwischen jedem dieser Werte wählen, um das Label auszuschließen.
+ `team=""`
+ `team!~.+`
+ `team=~^$`
# Etiketten in Grafana-Benachrichtigungen
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
In diesem Thema wird erklärt, warum Beschriftungen ein grundlegender Bestandteil von Warnmeldungen sind.
+ Der vollständige Satz von Bezeichnungen für eine Warnung identifiziert eine Warnung innerhalb von Grafana-Benachrichtigungen eindeutig.
+ Der Alertmanager verwendet Labels, um Alerts für Stummmeldungen und Warnungsgruppen in den Benachrichtigungsrichtlinien zuzuordnen.
+ In der Benutzeroberfläche für Warnmeldungen werden Beschriftungen für jede Warnungsinstanz angezeigt, die bei der Auswertung dieser Regel generiert wurde.
+ Kontaktstellen können auf Labels zugreifen, um dynamisch Benachrichtigungen zu generieren, die spezifische Informationen zu der Warnung enthalten, die zu einer Benachrichtigung führt.
+ Sie können einer [Warnregel](v10-alerting-configure.md) Labels hinzufügen. Beschriftungen können manuell konfiguriert werden, verwenden Vorlagenfunktionen und können auf andere Beschriftungen verweisen. Zu einer Warnregel hinzugefügte Labels haben im Falle einer Kollision zwischen Labels Vorrang (außer im Fall von reservierten Grafana-Labels, weitere Informationen finden Sie weiter unten).
## Kompatibilität mit externem Alertmanager
Der integrierte Alertmanager von Grafana unterstützt sowohl Unicode-Labelschlüssel als auch Werte. [Wenn Sie einen externen Prometheus Alertmanager verwenden, müssen die Labelschlüssel mit ihrem Datenmodell kompatibel sein.](https://prometheus.io/docs/concepts/data_model/#metric-names-and-labels) **Das bedeutet, dass Labelschlüssel nur **ASCII-Buchstaben**, **Zahlen** sowie Unterstriche enthalten dürfen und der Regex entsprechen dürfen.** `[a-zA-Z_][a-zA-Z0-9_]*` Alle ungültigen Zeichen werden von der Grafana-Alerting Engine entfernt oder ersetzt, bevor sie gemäß den folgenden Regeln an den externen Alertmanager gesendet werden:
+ `Whitespace`wird entfernt.
+ `ASCII characters`wird ersetzt durch`_`.
+ `All other characters`wird durch ihre Hexadezimaldarstellung in Kleinbuchstaben ersetzt. Wenn dies das erste Zeichen ist, wird ihm ein Präfix vorangestellt. `_`
**Anmerkung**
Wenn mehrere Labelschlüssel auf denselben Wert bereinigt werden, wird an die Duplikate ein kurzer Hash des ursprünglichen Labels als Suffix angehängt.
## Grafana reservierte Labels
**Anmerkung**
Etiketten mit dem Präfix `grafana_` sind von Grafana für spezielle Zwecke reserviert. Wenn ein manuell konfiguriertes Label hinzugefügt wird, wird `grafana_` es im Kollisionsfall überschrieben.
Reservierte Grafana-Labels können genauso verwendet werden wie manuell konfigurierte Labels. Die aktuelle Liste der verfügbaren reservierten Labels lautet:
| Label (Bezeichnung) | Description |
| --- | --- |
| grafana\$1folder | Titel des Ordners, der die Warnung enthält. |
# Vorlagen für Beschriftungen und Anmerkungen
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
Sie können Vorlagen verwenden, um Daten aus Abfragen und Ausdrücken in Beschriftungen und Anmerkungen aufzunehmen. Möglicherweise möchten Sie den Schweregrad für eine Warnung auf der Grundlage des Werts der Abfrage festlegen oder das Instanzlabel aus der Abfrage in einer zusammenfassenden Anmerkung verwenden, damit Sie wissen, auf welchem Server eine hohe CPU-Auslastung herrscht.
Alle Vorlagen sollten in [Text/Vorlage](https://pkg.go.dev/text/template) geschrieben werden. Unabhängig davon, ob Sie eine Vorlage für ein Etikett oder eine Anmerkung erstellen, sollten Sie jede Vorlage direkt in das Etikett oder die Anmerkung schreiben, für die Sie eine Vorlage erstellen. Das bedeutet, dass Sie Vorlagen nicht gemeinsam mit Beschriftungen und Anmerkungen verwenden können. Stattdessen müssen Sie Vorlagen überall dort kopieren, wo Sie sie verwenden möchten.
Jede Vorlage wird immer dann ausgewertet, wenn die Warnungsregel ausgewertet wird, und zwar für jede Warnung separat. Wenn Ihre Warnungsregel beispielsweise eine Vorlage für eine Zusammenfassung enthält und die Warnungsregel 10 auslösende Alerts enthält, wird die Vorlage zehnmal ausgeführt, einmal für jede Warnung. Sie sollten versuchen, teure Berechnungen in Ihren Vorlagen so weit wie möglich zu vermeiden.
## Beispiele
Anstatt ein vollständiges Tutorial zu schreiben, text/template, the following examples attempt to show the most common use-cases we have seen for templates. You can use these examples verbatim, or adapt them as necessary for your use case. For more information about how to write text/template schauen Sie sich die [Text-/Vorlagendokumentation](https://pkg.go.dev/text/template) an.
**Drucken Sie alle Etiketten kommagetrennt**
Um alle Etiketten durch Kommas getrennt zu drucken, drucken Sie die `$labels` Variable:
```
{{ $labels }}
```
Wenn zum Beispiel eine Warnung mit den Beschriftungen angezeigt wird `alertname=High CPU usage``instance=server1`, `grafana_folder=CPU alerts` und das würde Folgendes drucken:
```
alertname=High CPU usage, grafana_folder=CPU alerts, instance=server1
```
**Anmerkung**
Wenn Sie klassische Bedingungen verwenden, enthält `$labels` diese Option keine Labels aus der Abfrage. Weitere Informationen finden Sie in [der Variablen \$1labels](#v10-alerting-overview-labels-templating-the-labels-variable).
**Druckt alle Etiketten, eines pro Zeile**
Um alle Etiketten zu drucken, eines pro Zeile, verwenden Sie a, `range` um über jedes key/value Paar zu iterieren und sie einzeln zu drucken. `$k`Bezieht sich hier auf den Namen und `$v` bezieht sich auf den Wert des aktuellen Labels:
```
{{ range $k, $v := $labels -}}
{{ $k }}={{ $v }}
{{ end }}
```
Wenn zum Beispiel eine Warnung mit den Beschriftungen angezeigt `alertname=High CPU usage` wird`instance=server1`, `grafana_folder=CPU alerts` und das würde Folgendes ausgeben:
```
alertname=High CPU usage
grafana_folder=CPU alerts
instance=server1
```
**Anmerkung**
Wenn Sie klassische Bedingungen verwenden, enthält `$labels` diese Option keine Labels aus der Abfrage. Weitere Informationen finden Sie in [der Variablen \$1labels](#v10-alerting-overview-labels-templating-the-labels-variable).
**Drucken Sie ein einzelnes Etikett**
Um ein einzelnes Etikett zu drucken, verwenden Sie die `index` Funktion mit der `$labels` Variablen:
```
The host {{ index $labels "instance" }} has exceeded 80% CPU usage for the last 5 minutes
```
Bei einer Warnung mit dem Etikett würde dies `instance=server1` beispielsweise Folgendes drucken:
```
The host server1 has exceeded 80% CPU usage for the last 5 minutes
```
**Anmerkung**
Wenn Sie klassische Bedingungen verwenden, enthält `$labels` diese Option keine Labels aus der Abfrage. Weitere Informationen finden Sie in [der Variablen \$1labels](#v10-alerting-overview-labels-templating-the-labels-variable).
**Gibt den Wert einer Abfrage aus**
Um den Wert einer Sofortabfrage zu drucken, können Sie ihre Ref-ID mit der `index` Funktion und der `$values` Variablen drucken:
```
{{ index $values "A" }}
```
Bei einer Sofortabfrage, die beispielsweise den Wert 81.2345 zurückgibt, wird Folgendes gedruckt:
```
81.2345
```
Um den Wert einer Bereichsabfrage zu drucken, müssen Sie ihn zunächst mit einem Reduce-Ausdruck von einer Zeitreihe auf einen Instantvektor reduzieren. Anschließend können Sie das Ergebnis des Reduzierungsausdrucks drucken, indem Sie stattdessen dessen Ref-ID verwenden. Wenn der Reduce-Ausdruck beispielsweise den Durchschnitt von A annimmt und die Referenz-ID B hat, würden Sie schreiben:
```
{{ index $values "B" }}
```
**Gibt den humanisierten Wert einer Abfrage aus**
Um den humanisierten Wert einer Sofortabfrage zu drucken, verwenden Sie die `humanize` Funktion:
```
{{ humanize (index $values "A").Value }}
```
Bei einer Sofortabfrage, die beispielsweise den Wert 81.2345 zurückgibt, wird Folgendes gedruckt:
```
81.234
```
Um den humanisierten Wert einer Bereichsabfrage zu drucken, müssen Sie ihn zunächst von einer Zeitreihe auf einen Instantvektor mit einem Reduce-Ausdruck reduzieren. Anschließend können Sie das Ergebnis des Reduce-Ausdrucks drucken, indem Sie stattdessen dessen Ref-ID verwenden. Wenn der Reduce-Ausdruck beispielsweise den Durchschnitt von A annimmt und die Referenz-ID B hat, würden Sie schreiben:
```
{{ humanize (index $values "B").Value }}
```
**Drucken Sie den Wert einer Abfrage als Prozentsatz**
Um den Wert einer Sofortabfrage als Prozentsatz zu drucken, verwenden Sie die `humanizePercentage` Funktion:
```
{{ humanizePercentage (index $values "A").Value }}
```
Diese Funktion erwartet, dass der Wert eine Dezimalzahl zwischen 0 und 1 ist. Wenn der Wert stattdessen eine Dezimalzahl zwischen 0 und 100 ist, können Sie ihn entweder in Ihrer Abfrage oder mithilfe eines mathematischen Ausdrucks durch 100 teilen. Wenn es sich bei der Abfrage um eine Bereichsabfrage handelt, müssen Sie sie zunächst mit einem Reduce-Ausdruck von einer Zeitreihe auf einen Instantvektor reduzieren.
**Legen Sie anhand des Werts einer Abfrage einen Schweregrad fest**
Verwenden Sie eine if-Anweisung und die Vergleichsfunktion „Größer als“, um anhand des Werts einer Abfrage einen Schweregrad festzulegen. Achten Sie darauf, Dezimalzahlen (`80.0`,, usw.) zu verwenden `50.0``0.0`, wenn Sie Vergleiche durchführen, `$values` da text/template Typenzwang nicht unterstützt wird. [Eine Liste aller unterstützten Vergleichsfunktionen finden Sie hier.](https://pkg.go.dev/text/template#hdr-Functions)
```
{{ if (gt $values.A.Value 80.0) -}}
high
{{ else if (gt $values.A.Value 50.0) -}}
medium
{{ else -}}
low
{{- end }}
```
**Drucken Sie alle Etiketten aus einem klassischen Zustand**
Sie können diese Option nicht verwenden`$labels`, um Etiketten aus der Abfrage zu drucken, wenn Sie klassische Bedingungen verwenden, und müssen `$values` stattdessen verwenden. Der Grund dafür ist, dass bei klassischen Bedingungen diese Bezeichnungen verworfen werden, um eindimensionales Verhalten zu erzwingen (maximal eine Warnung pro Warnungsregel). Wenn die klassischen Bedingungen diese Beschriftungen nicht verwerfen würden, würden Abfragen, die viele Zeitreihen zurückgaben, dazu führen, dass Warnungen ständig zwischen Auslösen und Auflösen hin und her schwanken, da sich die Beschriftungen bei jeder Auswertung der Warnungsregel ändern würden.
Stattdessen enthält die `$values` Variable die reduzierten Werte aller Zeitreihen für alle ausgelösten Bedingungen. Wenn Sie beispielsweise eine Warnungsregel mit einer Abfrage A haben, die zwei Zeitreihen zurückgibt, und einer klassischen Bedingung B mit zwei Bedingungen, dann `$values` würde sie `B0``B1`, `B2` und enthalten`B3`. Wenn die klassische Bedingung B nur eine Bedingung hätte, `$values` würde sie nur `B0` UND enthalten`B1`.
Verwenden Sie die folgende Vorlage, um alle Beschriftungen aller Brennzeitreihen zu drucken (achten Sie darauf, den regulären Ausdruck durch die Ref-ID der klassischen Bedingung zu ersetzen`B`, falls diese anders ist):
```
{{ range $k, $v := $values -}}
{{ if (match "B[0-9]+" $k) -}}
{{ $k }}: {{ $v.Labels }}{{ end }}
{{ end }}
```
Zum Beispiel würde eine klassische Bedingung für zwei Zeitreihen, die eine einzige Bedingung überschreiten, ausgegeben:
```
B0: instance=server1
B1: instance=server2
```
Wenn die klassische Bedingung zwei oder mehr Bedingungen hat und eine Zeitreihe mehrere Bedingungen gleichzeitig überschreitet, werden ihre Bezeichnungen für jede Bedingung, die überschritten wird, dupliziert:
```
B0: instance=server1
B1: instance=server2
B2: instance=server1
B3: instance=server2
```
Wenn Sie eindeutige Beschriftungen drucken müssen, sollten Sie in Betracht ziehen, Ihre Warnungsregeln stattdessen von eindimensional auf mehrdimensional zu ändern. Sie können dies tun, indem Sie Ihre klassische Bedingung durch Reduce-Ausdrücke und mathematische Ausdrücke ersetzen.
**Druckt alle Werte aus einer klassischen Bedingung**
Um alle Werte einer klassischen Bedingung zu drucken, nehmen Sie das vorherige Beispiel und `$v.Labels` ersetzen Sie es durch`$v.Value`:
```
{{ range $k, $v := $values -}}
{{ if (match "B[0-9]+" $k) -}}
{{ $k }}: {{ $v.Value }}{{ end }}
{{ end }}
```
Zum Beispiel würde eine klassische Bedingung für zwei Zeitreihen, die eine einzige Bedingung überschreiten, Folgendes ausgeben:
```
B0: 81.2345
B1: 84.5678
```
Wenn die klassische Bedingung zwei oder mehr Bedingungen hat und eine Zeitreihe mehrere Bedingungen gleichzeitig überschreitet, enthält `$values` sie die Werte aller Bedingungen:
```
B0: 81.2345
B1: 92.3456
B2: 84.5678
B3: 95.6789
```
## Variablen
Die folgenden Variablen stehen Ihnen bei der Erstellung von Vorlagen für Beschriftungen und Anmerkungen zur Verfügung:
### Die labels-Variable
Die `$labels` Variable enthält alle Labels aus der Abfrage. Angenommen, Sie haben eine Abfrage, die die CPU-Auslastung für alle Ihre Server zurückgibt, und Sie haben eine Warnungsregel, die ausgelöst wird, wenn einer Ihrer Server in den letzten 5 Minuten die CPU-Auslastung von 80% überschritten hat. Sie möchten der Warnung eine zusammenfassende Anmerkung hinzufügen, die Ihnen mitteilt, auf welchem Server eine hohe CPU-Auslastung herrscht. Mit der `$labels` Variablen können Sie eine Vorlage schreiben, die einen für Menschen lesbaren Satz druckt, wie zum Beispiel:
```
CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes
```
**Anmerkung**
Wenn Sie eine klassische Bedingung verwenden, enthält `$labels` sie keine Labels aus der Abfrage. Bei klassischen Bedingungen werden diese Bezeichnungen verworfen, um eindimensionales Verhalten zu erzwingen (höchstens eine Warnung pro Warnungsregel). Wenn Sie Beschriftungen aus der Abfrage in Ihrer Vorlage verwenden möchten, folgen Sie dem vorherigen Beispiel *Alle Beschriftungen aus einer klassischen Bedingung drucken*.
### Die Wertvariable
Die `$value` Variable ist eine Zeichenfolge, die die Bezeichnungen und Werte aller Sofortabfragen, Schwellenwerte, Reduktionsausdrücke und mathematische Ausdrücke sowie klassische Bedingungen in der Warnungsregel enthält. Sie enthält nicht die Ergebnisse von Bereichsabfragen, da diese zwischen 10 und 10.000 Zeilen oder Metriken zurückgeben können. Wenn dies der Fall wäre, könnte eine einzelne Warnung für besonders große Abfragen 10 Sekunden Speicher MBs beanspruchen, und Grafana würde sehr schnell der Speicher ausgehen.
Um die `$value` Variable in der Zusammenfassung zu drucken, würden Sie etwa Folgendes schreiben:
```
CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes: {{ $value }}
```
Und es würde ungefähr so aussehen:
```
CPU usage for instance1 has exceeded 80% for the last 5 minutes: [ var='A' labels={instance=instance1} value=81.234 ]
```
`var='A'`Bezieht sich hier auf die Sofortabfrage mit der Referenz-ID A, `labels={instance=instance1}` bezieht sich auf die Labels und `value=81.234` bezieht sich auf die durchschnittliche CPU-Auslastung in den letzten 5 Minuten.
Wenn Sie nur einen Teil der Zeichenfolge statt der vollständigen Zeichenfolge drucken möchten, verwenden Sie die `$values` Variable. Sie enthält dieselben Informationen wie`$value`, aber in einer strukturierten Tabelle, und ist viel einfacher zu verwenden, als einen regulären Ausdruck zu schreiben, der nur dem gewünschten Text entspricht.
### Die Variablen „Werte“
Bei der `$values` Variablen handelt es sich um eine Tabelle, die die Bezeichnungen und Fließkommawerte aller Sofortabfragen und Ausdrücke enthält, die nach ihrer Referenz IDs indexiert sind.
Um den Wert der Sofortabfrage mit der Referenz-ID A zu drucken:
```
CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes: {{ index $values "A" }}
```
Bei einer Warnung mit den Beschriftungen `instance=server1` und einer Sofortabfrage mit dem Wert würde dies `81.2345` beispielsweise Folgendes ausgeben:
```
CPU usage for instance1 has exceeded 80% for the last 5 minutes: 81.2345
```
Wenn es sich bei der Abfrage in Ref ID A um eine Bereichsabfrage und nicht um eine Sofortabfrage handelt, fügen Sie einen Reduce-Ausdruck mit Ref ID B hinzu und ersetzen Sie ihn durch `(index $values "A")``(index $values "B")`:
```
CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes: {{ index $values "B" }}
```
## Funktionen
Bei der Erstellung von Vorlagen für Beschriftungen und Anmerkungen stehen Ihnen die folgenden Funktionen zur Verfügung:
**Argumente**
Die `args` Funktion übersetzt eine Liste von Objekten in eine Map mit den Schlüsseln arg0, arg1 usw. Dies soll die Übergabe mehrerer Argumente an Vorlagen ermöglichen.
```
{{define "x"}}{{.arg0}} {{.arg1}}{{end}}{{template "x" (args 1 "2")}}
```
```
1 2
```
**Externe URL**
Die `externalURL` Funktion gibt die externe URL des Grafana-Servers zurück.
```
{{ externalURL }}
```
```
https://example.com/grafana
```
**GraphLink**
Die `graphLink` Funktion gibt den Pfad zur grafischen Ansicht [Erkunden Sie in Grafana-Version 10](v10-explore.md) für den angegebenen Ausdruck und die angegebene Datenquelle zurück.
```
{{ graphLink "{\"expr\": \"up\", \"datasource\": \"gdev-prometheus\"}" }}
```
```
/explore?left=["now-1h","now","gdev-prometheus",{"datasource":"gdev-prometheus","expr":"up","instant":false,"range":true}]
```
**humanisieren**
Die `humanize` Funktion humanisiert Dezimalzahlen.
```
{{ humanize 1000.0 }}
```
```
1k
```
**humanisieren (1024)**
Das `humanize1024` funktioniert ähnlich wie, verwendet `humanize` aber 1024 statt 1000 als Basis.
```
{{ humanize1024 1024.0 }}
```
```
1ki
```
**HumanizeDuration**
Die `humanizeDuration` Funktion humanisiert eine Dauer in Sekunden.
```
{{ humanizeDuration 60.0 }}
```
```
1m 0s
```
**Prozentsatz humanisieren**
Die `humanizePercentage` Funktion humanisiert einen Verhältniswert zu einem Prozentsatz.
```
{{ humanizePercentage 0.2 }}
```
```
20%
```
**HumanizeTimestamp**
Die `humanizeTimestamp` Funktion humanisiert einen Unix-Zeitstempel.
```
{{ humanizeTimestamp 1577836800.0 }}
```
```
2020-01-01 00:00:00 +0000 UTC
```
**Spiel**
Die `match` Funktion gleicht den Text mit einem regulären Ausdrucksmuster ab.
```
{{ match "a.*" "abc" }}
```
```
true
```
**Pfad/Präfix**
Die `pathPrefix` Funktion gibt den Pfad des Grafana-Servers zurück.
```
{{ pathPrefix }}
```
```
/grafana
```
**TableLink**
Die `tableLink` Funktion gibt den Pfad zur Tabellenansicht [Erkunden Sie in Grafana-Version 10](v10-explore.md) für den angegebenen Ausdruck und die angegebene Datenquelle zurück.
```
{{ tableLink "{\"expr\": \"up\", \"datasource\": \"gdev-prometheus\"}" }}
```
```
/explore?left=["now-1h","now","gdev-prometheus",{"datasource":"gdev-prometheus","expr":"up","instant":true,"range":false}]
```
**Titel**
Die `title` Funktion schreibt das erste Zeichen jedes Worts groß.
```
{{ title "hello, world!" }}
```
```
Hello, World!
```
**toLower**
Die `toLower` Funktion gibt den gesamten Text in Kleinbuchstaben zurück.
```
{{ toLower "Hello, world!" }}
```
```
hello, world!
```
**toUpper**
Die `toUpper` Funktion gibt den gesamten Text in Großbuchstaben zurück.
```
{{ toUpper "Hello, world!" }}
```
```
HELLO, WORLD!
```
**reReplaceAll**
Die `reReplaceAll` Funktion ersetzt Text, der dem regulären Ausdruck entspricht.
```
{{ reReplaceAll "localhost:(.*)" "example.com:$1" "localhost:8080" }}
```
```
example.com:8080
```
# Über Warnungsregeln
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
Eine Warnregel besteht aus einer Reihe von Bewertungskriterien, die bestimmen, ob eine Warnungsinstanz ausgelöst wird. Die Regel besteht aus einer oder mehreren Abfragen und Ausdrücken, einer Bedingung, der Häufigkeit der Auswertung und der Dauer, über die die Bedingung erfüllt sein muss, damit sie ausgelöst wird.
Während Abfragen und Ausdrücke den auszuwertenden Datensatz auswählen, legt eine *Bedingung* den Schwellenwert fest, den die Daten erfüllen oder überschreiten müssen, um eine Warnung auszulösen.
Ein *Intervall* gibt an, wie oft eine Warnregel ausgewertet wird. *Die Dauer* gibt, sofern konfiguriert, an, wie lange eine Bedingung erfüllt sein muss. Die Warnungsregeln können auch das Warnverhalten bei fehlenden Daten definieren.
**Topics**
+ [Arten von Warnungsregeln](v10-alerting-explore-rules-types.md)
+ [Regeln für die Aufzeichnung](v10-alerting-explore-rule-recording.md)
+ [Anfragen und Bedingungen](v10-alerting-explore-rules-queries.md)
+ [Warnungsinstanzen](v10-alerting-rules-instances.md)
+ [Namespaces, Ordner und Gruppen](v10-alerting-rules-grouping.md)
+ [Evaluierung von Warnmeldungsregeln](v10-alerting-rules-evaluation.md)
+ [Stand und Zustand der Warnregeln](v10-alerting-explore-state.md)
+ [Vorlagen für Benachrichtigungen](v10-alerting-rules-notification-templates.md)
# Arten von Warnungsregeln
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
Grafana unterstützt mehrere Warnungsregeltypen. Erfahren Sie mehr über die einzelnen Warnungsregeltypen und deren Funktionsweise und entscheiden Sie, welcher für Ihren Anwendungsfall am besten geeignet ist.
## Von Grafana verwaltete Regeln
Von Grafana verwaltete Regeln sind der flexibelste Warnregeltyp. Sie ermöglichen es Ihnen, Benachrichtigungen zu erstellen, die auf Daten aus jeder Ihrer vorhandenen Datenquellen reagieren können.
Sie unterstützen nicht nur mehrere Datenquellen, sondern können auch [Ausdrücke](v10-panels-query-xform-expressions.md) hinzufügen, um Ihre Daten zu transformieren und Warnbedingungen auszudrücken.
In Grafana verwaltete Benachrichtigungen:
+ Warnungsregeln werden in Grafana auf der Grundlage einer oder mehrerer Datenquellen erstellt.
+ Warnungsregeln werden von der Engine zur Bewertung von Alert-Regeln in Grafana ausgewertet.
+ Alerts werden mit dem internen Grafana-Alertmanager zugestellt.
**Anmerkung**
Sie können Benachrichtigungen auch so konfigurieren, dass sie mit einem externen Alertmanager zugestellt werden, oder Sie können sowohl interne als auch externe Alertmanager verwenden. Weitere Informationen finden Sie unter Einen externen Alertmanager [hinzufügen](v10-alerting-setup-alertmanager.md).
## Regeln für verwaltete Datenquellen
Um mit Datenquellen verwaltete Warnregeln zu erstellen, benötigen Sie eine kompatible Prometheus- oder Loki-Datenquelle. Sie können überprüfen, ob Ihre Datenquelle die Regelerstellung über Grafana unterstützt, indem Sie die Datenquelle testen und beobachten, ob die Ruler-API unterstützt wird.
Bei datenquellenverwalteten Warnmeldungen:
+ Warnungsregeln werden in der Datenquelle selbst erstellt und gespeichert.
+ Warnungsregeln können nur auf der Grundlage von Prometheus-Daten erstellt werden.
+ Die Auswertung und Bereitstellung von Warnregeln erfolgt aus Gründen der Hochverfügbarkeit und Fehlertoleranz auf mehrere Knoten verteilt.
## Wählen Sie einen Warnungsregeltyp
Beachten Sie bei der Auswahl des zu verwendenden Warnungsregeltyps den folgenden Vergleich zwischen von Grafana verwalteten Warnungsregeln und datenquellenverwalteten Warnungsregeln.
| Feature | Von Grafana verwaltete Warnungsregel | Von Loki/Mimir verwaltete Warnungsregel |
| --- | --- | --- |
| Erstellen Sie Warnregeln auf der Grundlage von Daten aus einer unserer unterstützten Datenquellen | Ja | Nein: Sie können nur Warnungsregeln erstellen, die auf Prometheus-Daten basieren. Für die Datenquelle muss die Ruler-API aktiviert sein. |
| Datenquellen mischen und abgleichen | Ja | Nein |
| Beinhaltet Unterstützung für Aufzeichnungsregeln | Nein | Ja |
| Fügen Sie Ausdrücke hinzu, um Ihre Daten zu transformieren und Warnbedingungen festzulegen | Ja | Nein |
| Verwenden Sie Bilder in Warnmeldungen | Ja | Nein |
| Skalierung | Sie sind ressourcenintensiver, hängen von der Datenbank ab und können mit vorübergehenden Fehlern behaftet sein. Sie lassen sich nur vertikal skalieren. | Speichern Sie Warnregeln in der Datenquelle selbst und ermöglichen Sie eine „unendliche“ Skalierung. Generieren und versenden Sie Warnmeldungen vom Speicherort Ihrer Daten aus. |
| Bewertung und Bereitstellung von Warnmeldungsregeln | Die Auswertung und Bereitstellung von Warnregeln erfolgt innerhalb von Grafana mit einem externen Alertmanager oder beidem. | Die Auswertung und Zustellung von Warnmeldungsregeln erfolgt verteilt, sodass es keine einzige Fehlerquelle gibt. |
# Regeln für die Aufzeichnung
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
*Aufzeichnungsregeln sind nur für kompatible Prometheus- oder Loki-Datenquellen verfügbar.*
Mit einer Aufzeichnungsregel können Sie häufig benötigte oder rechenintensive Ausdrücke vorab berechnen und deren Ergebnis als neue Zeitreihen speichern. Dies ist nützlich, wenn Sie Warnmeldungen zu aggregierten Daten ausführen möchten oder wenn Sie über Dashboards verfügen, die rechenintensive Ausdrücke wiederholt abfragen.
Die Abfrage dieser neuen Zeitreihe ist schneller, insbesondere bei Dashboards, da bei jeder Aktualisierung der Dashboards derselbe Ausdruck abgefragt wird.
Lesen Sie mehr über die [Aufnahmeregeln](https://prometheus.io/docs/prometheus/latest/configuration/recording_rules/) in Prometheus.
# Anfragen und Bedingungen
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
In Grafana spielen Abfragen eine wichtige Rolle beim Abrufen und Transformieren von Daten aus unterstützten Datenquellen, zu denen Datenbanken wie MySQL und PostgreSQL, Zeitreihendatenbanken wie Prometheus, InfluxDB und Graphite sowie Dienste wie Amazon OpenSearch CloudWatch, Azure Monitor und Google Cloud Monitoring gehören.
Weitere Informationen zu unterstützten Datenquellen finden Sie unter. [Datenquellen und Grafana-Alerting](v10-alerting-overview-datasources.md)
Beim Ausführen einer Abfrage müssen Sie die Datenquelle definieren, die gewünschten Daten angeben, die abgerufen werden sollen, und die entsprechenden Filter oder Transformationen anwenden. Für die Erstellung dieser Abfragen werden Abfragesprachen oder Syntaxen verwendet, die für die gewählte Datenquelle spezifisch sind.
In Alerting definieren Sie eine Abfrage, um die Daten abzurufen, die Sie messen möchten, und eine Bedingung, die erfüllt sein muss, bevor eine Warnungsregel ausgelöst wird.
Eine Warnungsregel besteht aus einer oder mehreren Abfragen und Ausdrücken, die die Daten auswählen, die Sie messen möchten.
Weitere Informationen zu Abfragen und Ausdrücken finden Sie unter[Daten abfragen und transformieren](v10-panels-query-xform.md).
## Datenquellenabfragen
Abfragen in Grafana können je nach verwendeter Datenquelle und Abfragesprache auf verschiedene Arten angewendet werden. Der Abfrage-Editor jeder Datenquelle bietet eine benutzerdefinierte Benutzeroberfläche, mit der Sie Abfragen schreiben können, die die einzigartigen Funktionen nutzen.
Aufgrund der Unterschiede zwischen den Abfragesprachen sieht jeder Abfrage-Editor für Datenquellen anders aus und funktioniert auch anders. Abhängig von Ihrer Datenquelle bietet der Abfrage-Editor möglicherweise Funktionen zur automatischen Vervollständigung, Metriknamen, Variablenvorschläge oder eine visuelle Oberfläche zur Abfrageerstellung.
Zu den gängigen Typen von Abfragekomponenten gehören:
**Metriken oder Datenfelder** — Geben Sie die spezifischen Metriken oder Datenfelder an, die Sie abrufen möchten, z. B. CPU-Auslastung, Netzwerkverkehr oder Sensorwerte.
**Zeitraum** — Definieren Sie den Zeitraum, für den Sie Daten abrufen möchten, z. B. die letzte Stunde, einen bestimmten Tag oder einen benutzerdefinierten Zeitraum.
**Filter** — Wenden Sie Filter an, um die Daten anhand bestimmter Kriterien einzugrenzen, z. B. das Filtern von Daten nach einem bestimmten Tag, Host oder einer bestimmten Anwendung.
**Aggregationen** — Führen Sie Aggregationen der Daten durch, um Kennzahlen wie Durchschnittswerte, Summen oder Zahlen über einen bestimmten Zeitraum zu berechnen.
**Gruppierung — Gruppieren** Sie die Daten nach bestimmten Dimensionen oder Tags, um aggregierte Ansichten oder Aufschlüsselungen zu erstellen.
**Anmerkung**
Grafana unterstützt keine Warnabfragen mit Vorlagenvariablen. Weitere Informationen finden [Sie hier](https://community.grafana.com/t/template-variables-are-not-supported-in-alert-queries-while-setting-up-alert/2514) in den Grafana Labs-Foren.
## Ausdrucksabfragen
In Grafana wird ein Ausdruck verwendet, um Berechnungen, Transformationen oder Aggregationen an den abgefragten Daten der Datenquelle durchzuführen. Es ermöglicht Ihnen, benutzerdefinierte Metriken zu erstellen oder bestehende Metriken auf der Grundlage mathematischer Operationen, Funktionen oder logischer Ausdrücke zu ändern.
Mithilfe von Ausdrucksabfragen können Benutzer Aufgaben wie die Berechnung der prozentualen Änderung zwischen zwei Werten, die Anwendung von Funktionen wie logarithmischen oder trigonometrischen Funktionen, die Aggregation von Daten über bestimmte Zeitbereiche oder Dimensionen und die Implementierung bedingter Logik zur Behandlung verschiedener Szenarien ausführen.
In Alerting können Sie nur Ausdrücke für von Grafana verwaltete Warnungsregeln verwenden. Für jeden Ausdruck können Sie aus den Mathe-, Reduce- und Resampling-Ausdrücken wählen. Diese Regeln werden als multidimensionale Regeln bezeichnet, da sie für jede Serie eine separate Warnung generieren.
Sie können auch eine klassische Bedingung verwenden, bei der eine Warnungsregel erstellt wird, die eine einzelne Warnung auslöst, wenn ihre Bedingung erfüllt ist. Infolgedessen sendet Grafana nur eine einzige Warnung, selbst wenn die Alarmbedingungen für mehrere Serien erfüllt sind.
**Anmerkung**
Klassische Bedingungen existieren hauptsächlich aus Kompatibilitätsgründen und sollten nach Möglichkeit vermieden werden.
**Reduzieren**
Aggregiert Zeitreihenwerte im ausgewählten Zeitbereich zu einem einzigen Wert.
**Math (Mathematik)**
Führt Berechnungen functions/operations in freier Form mit Zeitreihen- und Zahlendaten durch. Kann zur Vorverarbeitung von Zeitreihendaten oder zur Definition einer Warnbedingung für Zahlendaten verwendet werden.
**Resampling**
Ordnet einen Zeitbereich einem neuen Satz von Zeitstempeln neu zu. Dies ist nützlich, wenn Zeitreihendaten aus verschiedenen Datenquellen verglichen werden, bei denen die Zeitstempel sonst nicht übereinstimmen würden.
**Threshold**
Überprüft, ob Zeitreihendaten der Schwellenwertbedingung entsprechen.
Mit dem Schwellenwertausdruck können Sie zwei Einzelwerte vergleichen. Er kehrt zurück`0`, wenn die Bedingung falsch ist und `1` wenn die Bedingung wahr ist. Die folgenden Schwellenwertfunktionen sind verfügbar:
+ Liegt über (x > y)
+ Liegt darunter (x < y)
+ Liegt darunter (x y1 UND x < y2)
+ < y1 AND x >Liegt außerhalb des Bereichs (x y2)
**Klassischer Zustand**
Überprüft, ob Zeitreihendaten der Warnbedingung entsprechen.
**Anmerkung**
Klassische Abfragen mit Bedingungsausdrücken erzeugen immer nur eine Warnungsinstanz, unabhängig davon, wie viele Zeitreihen die Bedingung erfüllen. Klassische Bedingungen existieren hauptsächlich aus Kompatibilitätsgründen und sollten nach Möglichkeit vermieden werden.
## Aggregationen
Grafana Alerting bietet die folgenden Aggregationsfunktionen, mit denen Sie Ihre Abfrage weiter verfeinern können.
Diese Funktionen sind nur für **Bedingungsausdrücke vom **Typ Reduce** und Classic** verfügbar.
| Funktion | Expression | Was macht es |
| --- | --- | --- |
| avg | Reduzieren//Klassisch | Zeigt den Durchschnitt der Werte an |
| min | Reduzieren//Klassisch | Zeigt den niedrigsten Wert an |
| max | Reduzieren//Klassisch | Zeigt den höchsten Wert an |
| sum | Reduzieren//Klassisch | Zeigt die Summe aller Werte an |
| count | Reduzieren//Klassisch | Zählt die Anzahl der Werte im Ergebnis |
| last | Reduzieren//Klassisch | Zeigt den letzten Wert an |
| median | Reduzieren//Klassisch | Zeigt den Medianwert an |
| diff | Classic | Zeigt den Unterschied zwischen dem neuesten und dem ältesten Wert an |
| diff\$1abs | Classic | Zeigt den absoluten Wert von diff an |
| percent\$1diff | Classic | Zeigt den prozentualen Wert der Differenz zwischen dem neuesten und dem ältesten Wert an |
| percent\$1diff\$1abs | Classic | Zeigt den absoluten Wert von percent\$1diff an |
| count\$1non\$1null | Classic | Zeigt die Anzahl der Werte in der Ergebnismenge an, die dies nicht sind null |
## Warnungsbedingung
Eine Warnbedingung ist die Abfrage oder der Ausdruck, der bestimmt, ob die Warnung ausgelöst wird oder nicht, je nachdem, welchen Wert sie liefert. Es kann nur eine Bedingung geben, die bestimmt, ob die Warnung ausgelöst wird.
Nachdem Sie Ihre and/or Abfrageausdrücke definiert haben, wählen Sie einen davon als Bedingung für die Warnungsregel aus.
Wenn die abgefragten Daten die definierte Bedingung erfüllen, löst Grafana die zugehörige Warnung aus, die so konfiguriert werden kann, dass Benachrichtigungen über verschiedene Kanäle wie E-Mail, Slack oder gesendet werden. PagerDuty Die Benachrichtigungen informieren Sie darüber, dass die Bedingung erfüllt ist, sodass Sie geeignete Maßnahmen ergreifen oder das zugrunde liegende Problem untersuchen können.
Standardmäßig wird der zuletzt hinzugefügte Ausdruck als Warnbedingung verwendet.
## Schwellenwert für die Wiederherstellung
Um das Geräusch flackernder Warnmeldungen zu reduzieren, können Sie einen Schwellenwert für die Wiederherstellung festlegen, der sich vom Schwellenwert für Warnmeldungen unterscheidet.
Flatternde Alerts treten auf, wenn eine Metrik über dem Schwellenwert liegt. Dies kann zu häufigen Statusänderungen führen, sodass zu viele Benachrichtigungen generiert werden.
Von Grafana verwaltete Warnregeln werden für ein bestimmtes Zeitintervall ausgewertet. Bei jeder Auswertung wird das Ergebnis der Abfrage mit dem in der Warnungsregel festgelegten Schwellenwert verglichen. Wenn der Wert einer Metrik über dem Schwellenwert liegt, wird eine Warnungsregel ausgelöst und eine Benachrichtigung gesendet. Wenn der Wert unter den Schwellenwert fällt und eine aktive Warnung für diese Metrik vorliegt, wird die Warnung behoben und eine weitere Benachrichtigung gesendet.
Es kann schwierig sein, eine Warnungsregel für eine verrauschte Metrik zu erstellen. Das heißt, wenn der Wert einer Metrik kontinuierlich einen Schwellenwert über- und unterschreitet. Dies wird als Flattern bezeichnet und führt zu einer Reihe von Benachrichtigungen über das Auslösen von Auslösen und zu einer fehlerhaften Statushistorie der Warnmeldungen.
Wenn Sie beispielsweise eine Latenzwarnung mit einem Schwellenwert von 1000 ms haben und die Zahl um 1000 schwankt (sagen wir 980 ->1010 -> 990 -> 1020 usw.), löst jede dieser Alarme eine Benachrichtigung aus.
Um dieses Problem zu lösen, können Sie einen (benutzerdefinierten) Wiederherstellungsschwellenwert festlegen, was im Grunde bedeutet, dass Sie zwei Schwellenwerte anstelle von einem haben. Eine Warnung wird ausgelöst, wenn der erste Schwellenwert überschritten wird, und sie wird erst behoben, wenn der zweite Schwellenwert überschritten wird.
Sie könnten beispielsweise einen Schwellenwert von 1000 ms und einen Wiederherstellungsschwellenwert von 900 ms festlegen. Auf diese Weise hört eine Warnregel erst auf, wenn sie unter 900 ms fällt, und das Flattern wird reduziert.
# Warnungsinstanzen
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
Von Grafana verwaltete Benachrichtigungen unterstützen mehrdimensionale Benachrichtigungen. Jede Warnungsregel kann mehrere Warnungsinstanzen erstellen. Dies ist besonders nützlich, wenn Sie mehrere Serien in einem einzigen Ausdruck beobachten.
Betrachten Sie den folgenden PromQL-Ausdruck:
```
sum by(cpu) (
rate(node_cpu_seconds_total{mode!="idle"}[1m])
)
```
Eine Regel, die diesen Ausdruck verwendet, erzeugt so viele Alert-Instanzen, wie CPUs wir nach der ersten Auswertung beobachten, sodass eine einzige Regel den Status jeder CPU melden kann.
# Namespaces, Ordner und Gruppen
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
Benachrichtigungen können mithilfe von Ordnern für von Grafana verwaltete Regeln und Namespaces für Mimir-, Loki- oder Prometheus-Regeln und Gruppennamen organisiert werden.
**Namespaces und Ordner**
Bei der Erstellung von von Grafana verwalteten Regeln kann der Ordner verwendet werden, um die Zugriffskontrolle durchzuführen und den Zugriff auf alle Regeln innerhalb eines bestimmten Ordners zu gewähren oder zu verweigern.
Ein Namespace enthält eine oder mehrere Gruppen. Die Regeln innerhalb einer Gruppe werden sequentiell in regelmäßigen Abständen ausgeführt. Das Standardintervall ist eine Minute. Sie können die Namespaces und Gruppen für Grafana Mimi- oder Loki-Regeln umbenennen und die Bewertungsintervalle für Gruppen bearbeiten.
**Gruppen**
Die Regeln innerhalb einer Gruppe werden nacheinander in regelmäßigen Intervallen ausgeführt, was bedeutet, dass keine Regeln gleichzeitig und in der Reihenfolge ihres Auftretens ausgewertet werden. Das Standardintervall ist eine Minute. Sie können Grafana Mimir- oder Loki-Regelnamespaces oder Loki-Regelnamespaces und -gruppen umbenennen und die Gruppenauswertungsintervalle bearbeiten.
**Tipp**
Wenn Sie möchten, dass Regeln gleichzeitig und mit unterschiedlichen Intervallen ausgewertet werden, sollten Sie erwägen, sie in verschiedenen Gruppen zu speichern.
**Anmerkung**
Von Grafana verwaltete Warnungsregeln werden gleichzeitig und nicht sequentiell ausgewertet.
# Evaluierung von Warnmeldungsregeln
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
Verwenden Sie die Auswertung von Warnungsregeln, um zu bestimmen, wie oft eine Warnungsregel ausgewertet werden sollte und wie schnell sie ihren Status ändern sollte.
Dazu müssen Sie sicherstellen, dass sich Ihre Warnungsregel in der richtigen Bewertungsgruppe befindet, und einen Wartezeitraum festlegen, der für Ihren Anwendungsfall am besten geeignet ist.
## Bewertungsgruppe
Jede Warnungsregel ist Teil einer Bewertungsgruppe. Jede Bewertungsgruppe enthält ein Bewertungsintervall, das bestimmt, wie oft die Warnungsregel überprüft wird.
**Von Datenquellen verwaltete** Warnungsregeln innerhalb derselben Gruppe werden nacheinander ausgewertet, während Warnungsregeln in verschiedenen Gruppen gleichzeitig ausgewertet werden können. Diese Funktion ist besonders nützlich, wenn Sie sicherstellen möchten, dass Aufzeichnungsregeln vor allen Warnungsregeln ausgewertet werden.
**Von Grafana verwaltete** Warnungsregeln werden unabhängig von der Warnungsregelgruppe gleichzeitig ausgewertet. Das Standardauswertungsintervall ist auf 10 Sekunden festgelegt, was bedeutet, dass von Grafana verwaltete Warnungsregeln alle 10 Sekunden bis zum nächsten 10-Sekunden-Fenster auf der Uhr ausgewertet werden, zum Beispiel 10:00:00, 10:00:10, 10:00:20 usw. Bei Bedarf können Sie auch Ihr eigenes Bewertungsintervall konfigurieren.
**Anmerkung**
Bewertungsgruppen und die Gruppierung von Warnmeldungen in Benachrichtigungsrichtlinien sind zwei verschiedene Dinge. Durch die Gruppierung nach Benachrichtigungsrichtlinien können mehrere Warnmeldungen mit denselben Labels in derselben Zeitnachricht gesendet werden.
## Ausstehender Zeitraum
Indem Sie einen Wartezeitraum festlegen, können Sie unnötige Benachrichtigungen bei vorübergehenden Problemen vermeiden.
In der Wartezeit wählen Sie den Zeitraum aus, in dem eine Warnungsregel gegen die Bedingung verstoßen kann, bis sie ausgelöst wird.
**Beispiel**
Stellen Sie sich vor, Sie haben ein Bewertungsintervall für die Warnungsregel auf alle 30 Sekunden und die Wartezeit auf 90 Sekunden festgelegt.
Die Auswertung erfolgt wie folgt:
[00:30] Erste Bewertung — Bedingung nicht erfüllt.
[01:00] Zweite Bewertung — Bedingung verletzt. Der Zähler für ausstehende Zahlungen wird gestartet. **Die Warnung beginnt ausstehend.**
[01:30] Dritte Bewertung — Bedingung verletzt. Ausstehender Zähler = 30 Sekunden. **Status „Ausstehend“.**
[02:00] Vierte Bewertung — Bedingung verletzt. **Zähler „Ausstehend“ = Status „60 Sekunden ausstehend“.**
[02:30] Fünfte Bewertung — Bedingung verletzt. Ausstehender Zähler = 90 Jahre. **Der Alarm wird ausgelöst**
Wenn die Warnungsregel eine Bedingung hat, die für einen bestimmten Zeitraum verletzt werden muss, bevor sie aktiv wird, ändert sich ihr Status wie folgt:
+ Wenn die Bedingung zum ersten Mal verletzt wird, wechselt die Regel in den Status „Ausstehend“.
+ Die Regel verbleibt im Status „ausstehend“, bis die Bedingung für den erforderlichen Zeitraum nicht eingehalten wurde (Wartezeit).
+ Sobald die erforderliche Zeit verstrichen ist, wechselt die Regel in den Status „Auslösung“.
+ Wenn die Bedingung während der Wartezeit nicht mehr verletzt wird, kehrt die Regel in ihren normalen Zustand zurück.
**Anmerkung**
Wenn Sie den Status „Ausstehend“ überspringen möchten, können Sie den Wartezeitraum einfach auf 0 setzen. Dadurch wird die Wartezeit praktisch übersprungen und Ihre Warnungsregel wird ausgelöst, sobald die Bedingung verletzt wird.
Wenn eine Warnungsregel ausgelöst wird, werden Warnungsinstanzen erzeugt, die dann an den Alertmanager gesendet werden.
# Stand und Zustand der Warnregeln
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
Der Status und der Zustand der Warnregeln helfen Ihnen dabei, mehrere wichtige Statusindikatoren Ihrer Benachrichtigungen zu verstehen.
Es gibt drei Hauptkomponenten: den *Status der Warnungsregel, den Status der* *Warnungsinstanz und den Zustand* *der Warnungsregel*. Obwohl sie miteinander verwandt sind, vermittelt jede Komponente subtil unterschiedliche Informationen.
**Status der Warnungsregel**
Eine Warnungsregel kann sich in einem der folgenden Zustände befinden:
| Status | Description |
| --- | --- |
| Normal | Keine der von der Evaluierungs-Engine zurückgegebenen Zeitreihen hat den `Firing` Status „`Pending`Oder“. |
| Ausstehend | Mindestens eine von der Evaluierungs-Engine zurückgegebene Zeitreihe ist`Pending`. |
| Wird gefeuert | Mindestens eine von der Evaluierungs-Engine zurückgegebene Zeitreihe ist`Firing`. |
**Anmerkung**
Warnmeldungen werden zuerst zu `pending` und dann `firing` weitergeleitet. Daher dauert es mindestens zwei Bewertungszyklen, bis eine Warnung ausgelöst wird.
**Status der Warnungsinstanz**
Eine Warnungsinstanz kann sich in einem der folgenden Zustände befinden:
| Status | Description |
| --- | --- |
| Normal | Der Status einer Warnung, die weder ausgelöst noch aussteht. Alles funktioniert einwandfrei. |
| Ausstehend | Der Status einer Warnung, die für weniger als die konfigurierte Schwellenwertdauer aktiv war. |
| Warnfunktion | Der Status einer Warnung, die länger als die konfigurierte Schwellenwertdauer aktiv war. |
| NoData | Für das konfigurierte Zeitfenster wurden keine Daten empfangen. |
| Fehler | Der Fehler, der beim Versuch, eine Warnregel auszuwerten, aufgetreten ist. |
**Letzten Status beibehalten**
Eine Warnungsregel kann so konfiguriert werden, dass der letzte Status beibehalten wird, wenn `NoData` der letzte `Error` Status erreicht wird. Dadurch wird sowohl verhindert, dass Warnmeldungen ausgelöst werden, als auch, dass sie behoben und erneut ausgelöst werden. Genau wie bei der normalen Evaluierung wird die Warnungsregel von `Pending` zu `Firing` nach Ablauf der Wartezeit umgestellt.
**Zustand der Warnmeldungsregel**
Eine Warnungsregel kann einen der folgenden Integritätsstatus haben:
| Status | Description |
| --- | --- |
| OK | Bei der Auswertung einer Warnregel ist kein Fehler aufgetreten. |
| Fehler | Bei der Auswertung einer Warnregel ist ein Fehler aufgetreten. |
| NoData | Das Fehlen von Daten in mindestens einer Zeitreihe, die während einer Regelauswertung zurückgegeben wurde. |
**Besondere Warnmeldungen für `NoData` und `Error`**
Wenn die Auswertung einer Warnregel den Status `NoData` oder ergibt`Error`, generiert Grafana Alerting Warninstanzen mit den folgenden zusätzlichen Bezeichnungen:
| Label (Bezeichnung) | Description |
| --- | --- |
| Name der Warnung | Entweder `DatasourceNoData` oder `DatasourceError` je nach Bundesland. |
| datasource\$1uid | Die UID der Datenquelle, die den Status verursacht hat. |
Sie können diese Benachrichtigungen genauso behandeln wie normale Benachrichtigungen, indem Sie eine Stille, eine Route zu einem Kontaktpunkt usw. hinzufügen.
# Vorlagen für Benachrichtigungen
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
Benachrichtigungen, die über Kontaktpunkte gesendet werden, werden mithilfe von Benachrichtigungsvorlagen erstellt. Die Standardvorlagen von Grafana basieren auf dem [Go-Vorlagensystem](https://golang.org/pkg/text/template), bei dem einige Felder als Text ausgewertet werden, während andere als HTML ausgewertet werden (was sich auf die Escape-Funktion auswirken kann).
Die Standardvorlage [default\$1template.go](https://github.com/grafana/alerting/blob/main/templates/default_template.go) ist eine nützliche Referenz für benutzerdefinierte Vorlagen.
Da die meisten Kontaktpunktfelder mit Vorlagen versehen werden können, können Sie wiederverwendbare benutzerdefinierte Vorlagen erstellen und diese in mehreren Kontaktpunkten verwenden. Weitere Informationen zu benutzerdefinierten Benachrichtigungen mithilfe von Vorlagen finden Sie unter[Benachrichtigungen anpassen](v10-alerting-manage-notifications.md).
**Verschachtelte Vorlagen**
Sie können Vorlagen in andere Vorlagen einbetten.
Sie können beispielsweise ein Vorlagenfragment mithilfe des `define` Schlüsselworts definieren.
```
{{ define "mytemplate" }}
{{ len .Alerts.Firing }} firing. {{ len .Alerts.Resolved }} resolved.
{{ end }}
```
Anschließend können Sie mithilfe des `template` Schlüsselworts benutzerdefinierte Vorlagen in dieses Fragment einbetten. Beispiel:
```
Alert summary:
{{ template "mytemplate" . }}
```
Sie können jede der folgenden integrierten Vorlagenoptionen verwenden, um benutzerdefinierte Vorlagen einzubetten.
| Name | Hinweise |
| --- | --- |
| `default.title` | Zeigt Statusinformationen auf hoher Ebene an. |
| `default.message` | Stellt eine formatierte Zusammenfassung der ausgelösten und gelösten Alarme bereit. |
| `teams.default.message` | Ähnlich wie`default.messsage`, formatiert für Microsoft Teams. |
**HTML in Benachrichtigungsvorlagen**
HTML in Vorlagen für Warnmeldungen ist maskiert. Wir unterstützen das Rendern von HTML in der resultierenden Benachrichtigung nicht.
Einige Notifier unterstützen alternative Methoden zur Änderung des Erscheinungsbilds der resultierenden Benachrichtigung. Grafana installiert beispielsweise die Basisvorlage für Benachrichtigungen per E-Mail. `/public/emails/ng_alert_notification.html` Sie können diese Datei bearbeiten, um das Erscheinungsbild aller Warn-E-Mails zu ändern.
# Alert-Manager
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
Mit Alertmanager können Sie Warnmeldungen schnell und effizient verwalten und darauf reagieren. Er empfängt Benachrichtigungen, kümmert sich um Stummschaltung, Sperrung, Gruppierung und Weiterleitung, indem er Benachrichtigungen über den Kanal Ihrer Wahl versendet, z. B. E-Mail oder Slack.
In Grafana können Sie den Grafana Alertmanager oder einen externen Alertmanager verwenden. Sie können auch mehrere Alertmanager ausführen. Ihre Entscheidung hängt von Ihrer Einrichtung ab und davon, wo Ihre Alerts generiert werden.
**Grafana Alarmmanager**
Grafana Alertmanager ist ein interner Alertmanager, der vorkonfiguriert ist und standardmäßig zur Auswahl steht.
Der Grafana Alertmanager kann Benachrichtigungen von Grafana empfangen, aber er kann keine Benachrichtigungen von außerhalb von Grafana empfangen, z. B. von Mimir oder Loki.
**Anmerkung**
Inhibitionsregeln werden im Grafana Alertmanager nicht unterstützt.
**Externer Alertmanager**
Wenn Sie einen einzigen Alertmanager verwenden möchten, um alle Ihre Grafana-, Loki-, Mimir- und Prometheus-Benachrichtigungen zu erhalten, können Sie Grafana so einrichten, dass ein externer Alertmanager verwendet wird. Dieser externe Alertmanager kann in Grafana selbst konfiguriert und verwaltet werden.
Hier sind zwei Beispiele dafür, wann Sie vielleicht Ihren eigenen externen Alertmanager konfigurieren und Ihre Benachrichtigungen anstelle des Grafana-Alertmanagers dorthin senden möchten:
1. Sie haben bereits Alertmanager vor Ort in Ihrer eigenen Cloud-Infrastruktur, die Sie eingerichtet haben und weiterhin verwenden möchten, da Sie über andere Alert-Generatoren wie Prometheus verfügen.
1. Sie möchten sowohl Prometheus vor Ort als auch gehostetes Grafana verwenden, um Benachrichtigungen an denselben Alertmanager zu senden, der in Ihrer Cloud-Infrastruktur ausgeführt wird.
Alertmanager sind im Drop-down-Menü auf den Seiten Alerting Contact Points und Notification Policies sichtbar.
Wenn Sie Ihre Datenquelle bereitstellen, setzen Sie die Markierung `handleGrafanaManagedAlerts` im `jsonData` Feld auf, um von Grafana verwaltete Benachrichtigungen an diesen Alertmanager `true` zu senden.
# Kontaktstellen
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
Kontaktpunkte enthalten die Konfiguration für das Senden von Benachrichtigungen. Eine Kontaktstelle ist eine Liste von Integrationen, von denen jede eine Benachrichtigung an eine bestimmte E-Mail-Adresse, einen bestimmten Dienst oder eine bestimmte URL sendet. Kontaktstellen können mehrere Integrationen derselben Art oder eine Kombination von Integrationen verschiedener Art haben. Ein Kontaktpunkt könnte beispielsweise eine Pagerduty-Integration, eine Amazon SNS- und Slack-Integration oder eine Pagerduty-Integration, eine Slack-Integration und zwei Amazon SNS-Integrationen enthalten. Sie können auch eine Kontaktstelle ohne Integrationen konfigurieren. In diesem Fall werden keine Benachrichtigungen gesendet.
Eine Kontaktstelle kann erst dann Benachrichtigungen senden, wenn sie zu einer Benachrichtigungsrichtlinie hinzugefügt wurde. Eine Benachrichtigungsrichtlinie kann nur Benachrichtigungen an eine Kontaktstelle senden, aber eine Kontaktstelle kann gleichzeitig zu einer Reihe von Benachrichtigungsrichtlinien hinzugefügt werden. Wenn eine Warnung mit einer Benachrichtigungsrichtlinie übereinstimmt, wird die Warnung an die Kontaktstelle in dieser Benachrichtigungsrichtlinie gesendet, die dann eine Benachrichtigung an jede Integration in ihrer Konfiguration sendet.
Kontaktpunkte können sowohl für den Grafana Alertmanager als auch für externe Alertmanager konfiguriert werden.
Sie können auch Benachrichtigungsvorlagen verwenden, um Benachrichtigungen für Kontaktpunkttypen anzupassen.
**Unterstützte Kontaktpunkttypen**
In der folgenden Tabelle sind die von Grafana unterstützten Kontaktpunkttypen aufgeführt.
| Name | Typ |
| --- | --- |
| Amazon SNS | `sns` |
| OpsGenie | `opsgenie` |
| Pager Duty | `pagerduty` |
| Slack | `slack` |
| VictorOps | `victorops` |
Weitere Informationen zu Kontaktstellen finden Sie unter [Kontaktpunkte konfigurieren](v10-alerting-configure-contactpoints.md) und[Benachrichtigungen anpassen](v10-alerting-manage-notifications.md).
# Benachrichtigungen
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
Die Entscheidung, wie, wann und wohin Ihre Warnmeldungen gesendet werden sollen, ist ein wichtiger Bestandteil der Einrichtung Ihres Warnsystems. Diese Entscheidungen wirken sich direkt auf Ihre Fähigkeit aus, Probleme schnell zu lösen und nichts Wichtiges zu verpassen.
Definieren Sie als ersten Schritt Ihre [Kontaktstellen](v10-alerting-explore-contacts.md), die festlegen, wohin Ihre Warnmeldungen gesendet werden sollen. Eine Kontaktstelle besteht aus einer oder mehreren Integrationen, die zur Übermittlung von Benachrichtigungen verwendet werden. Fügen Sie Benachrichtigungsvorlagen zu Kontaktpunkten hinzu, um sie wiederzuverwenden und die Nachrichtenübermittlung in Ihren Benachrichtigungen einheitlich zu gestalten.
Als Nächstes erstellen Sie eine Benachrichtigungsrichtlinie, bei der es sich um eine Reihe von Regeln handelt, die festlegen, wo, wann und wie Ihre Benachrichtigungen an Kontaktstellen weitergeleitet werden. In einer Benachrichtigungsrichtlinie definieren Sie, wohin Ihre Warnmeldungen gesendet werden sollen, indem Sie eine der von Ihnen erstellten Kontaktstellen auswählen.
## Alert-Manager
Grafana verwendet Alertmanager, um Benachrichtigungen über ausgelöste und gelöste Alarme zu senden. [Grafana hat seinen eigenen Alertmanager, der in der Benutzeroberfläche als **Grafana** bezeichnet wird, unterstützt aber auch das Senden von Benachrichtigungen von anderen Alertmanagern, wie dem Prometheus Alertmanager.](https://prometheus.io/docs/alerting/latest/alertmanager/) Der Grafana Alertmanager verwendet Benachrichtigungsrichtlinien und Kontaktpunkte, um zu konfigurieren, wie und wo eine Benachrichtigung gesendet wird, wie oft eine Benachrichtigung gesendet werden soll und ob Benachrichtigungen alle in derselben Benachrichtigung, in gruppierten Benachrichtigungen basierend auf einer Reihe von Labels oder als separate Benachrichtigungen gesendet werden sollen.
## Richtlinien für Benachrichtigungen
Benachrichtigungsrichtlinien steuern, wann und wo Benachrichtigungen gesendet werden. Eine Benachrichtigungsrichtlinie kann wählen, ob alle Benachrichtigungen zusammen in derselben Benachrichtigung, Benachrichtigungen in gruppierten Benachrichtigungen auf der Grundlage einer Reihe von Labels oder Benachrichtigungen als separate Benachrichtigungen gesendet werden sollen. Sie können jede Benachrichtigungsrichtlinie so konfigurieren, dass gesteuert wird, wie oft Benachrichtigungen gesendet werden sollen. Außerdem können Sie eine oder mehrere Stummschaltungen einrichten, um Benachrichtigungen zu bestimmten Tageszeiten und an bestimmten Wochentagen zu blockieren.
Benachrichtigungsrichtlinien sind in einer Baumstruktur organisiert, wobei sich an der Wurzel der Struktur eine Benachrichtigungsrichtlinie befindet, die als Standardrichtlinie bezeichnet wird. Es kann nur eine Standardrichtlinie geben, und die Standardrichtlinie kann nicht gelöscht werden.
Spezifische Routing-Richtlinien sind der Stammrichtlinie untergeordnet und können verwendet werden, um entweder allen Warnungen oder einer Teilmenge von Warnungen auf der Grundlage einer Reihe von übereinstimmenden Bezeichnungen zuzuordnen. Eine Benachrichtigungsrichtlinie entspricht einer Warnung, wenn ihre entsprechenden Bezeichnungen mit den Bezeichnungen in der Warnung übereinstimmen.
Eine verschachtelte Richtlinie kann über eigene verschachtelte Richtlinien verfügen, die eine zusätzliche Zuordnung von Warnmeldungen ermöglichen. Ein Beispiel für eine verschachtelte Richtlinie könnte das Senden von Infrastrukturwarnungen an das Ops-Team sein, während eine untergeordnete Richtlinie Warnmeldungen mit hoher Priorität an Pagerduty und Benachrichtigungen mit niedriger Priorität an Slack senden könnte.
Alle Benachrichtigungen, unabhängig von ihrer Bezeichnung, entsprechen der Standardrichtlinie. Wenn die Standardrichtlinie jedoch eine Warnung erhält, überprüft sie jede verschachtelte Richtlinie und sendet die Warnung an die erste verschachtelte Richtlinie, die der Warnung entspricht. Wenn die verschachtelte Richtlinie weitere verschachtelte Richtlinien enthält, kann sie versuchen, die Warnung mit einer ihrer verschachtelten Richtlinien abzugleichen. Wenn keine verschachtelten Richtlinien mit der Warnung übereinstimmen, ist die Richtlinie selbst die entsprechende Richtlinie. Wenn keine verschachtelten Richtlinien vorhanden sind oder keine verschachtelten Richtlinien mit der Warnung übereinstimmen, ist die Standardrichtlinie die entsprechende Richtlinie.
Ausführlichere Informationen zu Benachrichtigungsrichtlinien finden Sie unter. [Richtlinien für Benachrichtigungen](v10-alerting-explore-notifications-policies-details.md)
## Vorlagen für Benachrichtigungen
Sie können Benachrichtigungen mit Vorlagen anpassen. Vorlagen können beispielsweise verwendet werden, um den Titel und die Nachricht von Benachrichtigungen zu ändern, die an Slack gesendet werden.
Vorlagen sind nicht auf eine einzelne Integration oder einen einzelnen Kontaktpunkt beschränkt, sondern können stattdessen in einer Reihe von Integrationen an derselben Kontaktstelle und sogar in Integrationen an verschiedenen Kontaktpunkten verwendet werden. Beispielsweise kann ein Grafana-Benutzer eine Vorlage namens erstellen `custom_subject_or_title` und sie sowohl für die Vorlage von Betreffs in Pager Duty als auch für Titel von Slack-Nachrichten verwenden, ohne zwei separate Vorlagen erstellen zu müssen.
Alle Vorlagen für Benachrichtigungen sind in der [Vorlagensprache von Go verfasst und befinden sich](https://pkg.go.dev/text/template) auf der Seite „Benachrichtigungen“ auf der Registerkarte „Kontaktstellen“.
Ausführlichere Informationen zum Anpassen von Benachrichtigungen finden Sie unter. [Benachrichtigungen anpassen](v10-alerting-manage-notifications.md)
## Stille
Du kannst Stummschaltungen verwenden, um Benachrichtigungen über eine oder mehrere Feuerregeln stummzuschalten. Stille verhindert nicht, dass Warnmeldungen ausgelöst oder behoben werden, und sie verbergen auch keine Warnmeldungen in der Benutzeroberfläche. Eine Stille dauert so lange wie ihre Dauer, die in Minuten, Stunden, Tagen, Monaten oder Jahren konfiguriert werden kann.
Ausführlichere Informationen zur Verwendung von Stille finden Sie unter[Warnmeldungen stummschalten](v10-alerting-silences.md).
# Richtlinien für Benachrichtigungen
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
Benachrichtigungsrichtlinien bieten Ihnen eine flexible Möglichkeit, Benachrichtigungen an verschiedene Empfänger weiterzuleiten. Mithilfe von Label-Matchern können Sie die Zustellung von Warnmeldungen ändern, ohne jede einzelne Warnungsregel aktualisieren zu müssen.
In diesem Abschnitt erfahren Sie mehr darüber, wie Benachrichtigungsrichtlinien funktionieren und strukturiert sind, sodass Sie das Beste aus der Einrichtung Ihrer Benachrichtigungsrichtlinien herausholen können.
## Richtlinienbaum
Bei Benachrichtigungsrichtlinien handelt es sich *nicht* um eine Liste, sondern um eine Baumstruktur. Das bedeutet, dass jede Richtlinie untergeordnete Richtlinien haben kann usw. Das Stammverzeichnis der Benachrichtigungsrichtlinienstruktur wird als **Standardbenachrichtigungsrichtlinie** bezeichnet.
Jede Richtlinie besteht aus einer Reihe von Label-Matchern (0 oder mehr), die angeben, mit welchen Labels sie umgehen möchten oder nicht.
Weitere Informationen zum Label-Abgleich finden Sie unter[So funktioniert der Labelabgleich](v10-alerting-overview-labels-matching.md).
**Anmerkung**
Wenn Sie keine Label-Matcher für Ihre Benachrichtigungsrichtlinie konfiguriert haben, entspricht Ihre Benachrichtigungsrichtlinie *allen* Warnungsinstanzen. Dadurch können Richtlinien für Kinder möglicherweise nicht bewertet werden, es sei denn, Sie haben in der Benachrichtigungsrichtlinie die Option **Gleichgeschlechtsabgleich fortsetzen** aktiviert.
## Routing
Um zu bestimmen, welche Benachrichtigungsrichtlinie für welche Warnungsinstanzen zuständig ist, müssen Sie sich zunächst die vorhandenen Benachrichtigungsrichtlinien ansehen, beginnend mit der Standardbenachrichtigungsrichtlinie.
Wenn keine anderen Richtlinien als die Standardrichtlinie konfiguriert sind, verwaltet die Standardrichtlinie die Warnungsinstanz.
Wenn andere Richtlinien als die Standardrichtlinie definiert sind, werden diese Benachrichtigungsrichtlinien in der Reihenfolge bewertet, in der sie angezeigt werden.
Wenn eine Benachrichtigungsrichtlinie Label-Matcher hat, die mit den Bezeichnungen der Warnungsinstanz übereinstimmen, wird sie zu ihren untergeordneten Richtlinien übergehen und, falls vorhanden, weiterhin nach untergeordneten Richtlinien suchen, die möglicherweise Label-Matcher haben, die die Gruppe der Bezeichnungen weiter einschränken, usw., bis keine untergeordneten Richtlinien mehr gefunden wurden.
Wenn in einer Benachrichtigungsrichtlinie keine untergeordneten Richtlinien definiert sind oder wenn keine der untergeordneten Richtlinien Label-Matcher hat, die den Labels der Warnungsinstanz entsprechen, wird die übergeordnete Benachrichtigungsrichtlinie verwendet.
Sobald eine passende Richtlinie gefunden wurde, sucht das System nicht weiter nach anderen passenden Richtlinien. Wenn Sie weiterhin nach anderen Richtlinien suchen möchten, die möglicherweise übereinstimmen, aktivieren **Sie Weiter nach gleichgeordneten Richtlinien für** diese bestimmte Richtlinie abgleichen.
Wenn keine der Benachrichtigungsrichtlinien ausgewählt ist, wird schließlich die Standardbenachrichtigungsrichtlinie verwendet.
### Beispiel für Routing
Hier ist ein Beispiel für einen relativ einfachen Benachrichtigungsrichtlinienbaum und einige Warnungsinstanzen.
![\[Ein Bild zeigt eine Reihe von Benachrichtigungsrichtlinien in einer Baumstruktur und eine Reihe von Warnungsinstanzen mit unterschiedlichen Bezeichnungen, die den Richtlinien entsprechen.\]](http://docs.aws.amazon.com/de_de/grafana/latest/userguide/images/notification-routing.png)
Im Folgenden finden Sie eine Aufschlüsselung, wie diese Richtlinien ausgewählt werden:
**Pod stuck in CrashLoop** hat kein `severity` Label, sodass keine der untergeordneten Richtlinien übereinstimmt. Es hat ein `team=operations` Label, sodass die erste Richtlinie zugeordnet ist.
Die `team=security` Richtlinie wird nicht evaluiert, da wir bereits eine Übereinstimmung gefunden haben und **„Mit gleichgestellten Personen fortfahren**“ für diese Richtlinie nicht konfiguriert wurde.
**Festplattennutzung — 80%** haben sowohl ein als auch ein `severity` Label `team` und entsprechen einer untergeordneten Richtlinie des Betriebsteams.
**Unautorisierte Protokolleinträge** haben eine `team` Bezeichnung, stimmen aber nicht mit der ersten Richtlinie (`team=operations`) überein, da die Werte nicht identisch sind. Daher wird die Suche fortgesetzt und der `team=security` Richtlinie entspricht. Da es keine untergeordneten Richtlinien gibt, wird das zusätzliche `severity=high` Label ignoriert.
## Vererbung
Untergeordnete Richtlinien sind nicht nur ein nützliches Konzept für die Weiterleitung von Warnungsinstanzen, sondern übernehmen auch Eigenschaften von ihrer übergeordneten Richtlinie. Dies gilt auch für alle Richtlinien, bei denen es sich um untergeordnete Richtlinien der Standardbenachrichtigungsrichtlinie handelt.
Die folgenden Eigenschaften werden an untergeordnete Richtlinien vererbt:
+ Kontaktstelle
+ Gruppierungsoptionen
+ Zeitliche Optionen
+ Timings stummschalten
Jede dieser Eigenschaften kann durch eine individuelle Richtlinie überschrieben werden, falls Sie die geerbten Eigenschaften überschreiben möchten.
Wenn Sie eine Kontaktstelle aus der übergeordneten Richtlinie übernehmen möchten, lassen Sie das Feld leer. Um die vererbten Gruppierungsoptionen zu überschreiben, aktivieren Sie Gruppierung **überschreiben**. Um die geerbten Zeitoptionen zu überschreiben, aktivieren Sie die Option **Allgemeine Zeitangaben überschreiben**.
### Beispiel für Vererbung
Das folgende Beispiel zeigt, wie der Benachrichtigungsrichtlinienbaum aus unserem vorherigen Beispiel es den untergeordneten Richtlinien von ermöglicht, ihren Kontaktpunkt `team=operations` zu erben.
Auf diese Weise können wir vermeiden, dass dieselbe Kontaktstelle für jede Kinderrichtlinie mehrmals angegeben werden muss.
![\[Ein Bild, das eine Reihe von Benachrichtigungsrichtlinien in einer Baumstruktur zeigt, wobei einigen Richtlinien Kontaktstellen zugewiesen sind, einige Richtlinien für Kinder jedoch die Kontaktstellen ihrer Eltern erben, anstatt ihre eigenen zu definieren.\]](http://docs.aws.amazon.com/de_de/grafana/latest/userguide/images/notification-inheritance.png)
## Zusätzliche Konfigurationsoptionen
### Gruppierung
Die Gruppierung ist eine wichtige Funktion von Grafana Alerting, da Sie damit relevante Benachrichtigungen zu einer kleineren Anzahl von Benachrichtigungen zusammenfassen können. Dies ist besonders wichtig, wenn Benachrichtigungen an Ersthelfer gesendet werden, z. B. an Techniker auf Abruf, bei denen der Erhalt vieler Benachrichtigungen in kurzer Zeit überwältigend sein kann und sich in einigen Fällen negativ auf die Fähigkeit eines Ersthelfers auswirken kann, auf einen Vorfall zu reagieren. Stellen Sie sich zum Beispiel einen großen Ausfall vor, bei dem viele Ihrer Systeme ausgefallen sind. In diesem Fall kann die Gruppierung den Unterschied zwischen dem Empfang eines Telefonanrufs und 100 Telefonanrufen ausmachen.
Mithilfe der Option Gruppieren nach in einer Benachrichtigungsrichtlinie legen Sie fest, wie Benachrichtigungen gruppiert werden. Standardmäßig gruppieren Benachrichtigungsrichtlinien in Grafana-Benachrichtigungen nach Warnungsregeln mithilfe der `grafana_folder` Bezeichnungen `alertname` und (da Warnungsnamen in mehreren Ordnern nicht eindeutig sind). Wenn Sie Benachrichtigungen nach etwas anderem als der Warnungsregel gruppieren möchten, ändern Sie die Gruppierung in eine andere Kombination von Bezeichnungen.
#### Deaktivieren Sie die Gruppierung
Wenn Sie jede Warnung als separate Benachrichtigung erhalten möchten, können Sie dies tun, indem Sie sie nach einem speziellen Label namens gruppieren. `...` Dies ist nützlich, wenn Ihre Benachrichtigungen an ein automatisiertes System und nicht an einen Ersthelfer gesendet werden.
#### Eine einzige Gruppe für alle Benachrichtigungen
Wenn Sie alle Benachrichtigungen zusammen in einer einzigen Benachrichtigung erhalten möchten, können Sie dies tun, indem Sie Group by leer lassen.
### Zeitliche Optionen
Die Zeitoptionen bestimmen, wie oft Benachrichtigungen für jede Gruppe von Benachrichtigungen gesendet werden. Es gibt drei Timer, über die Sie Bescheid wissen müssen: Gruppenwartezeit, Gruppenintervall und Wiederholungsintervall.
#### Wartezeit für Gruppen
Gruppenwartezeit ist die Zeit, die Grafana wartet, bevor die erste Benachrichtigung für eine neue Gruppe von Benachrichtigungen gesendet wird. Je länger die Gruppe wartet, desto mehr Zeit haben Sie, bis andere Benachrichtigungen eintreffen. Je kürzer die Wartezeit für Gruppen ist, desto früher wird die erste Benachrichtigung gesendet, es besteht jedoch die Gefahr, dass unvollständige Benachrichtigungen gesendet werden. Sie sollten immer eine Wartezeit für Gruppen wählen, die für Ihren Anwendungsfall am sinnvollsten ist.
**Die Standardeinstellung** beträgt 30 Sekunden
#### Gruppenintervall
Sobald die erste Benachrichtigung für eine neue Gruppe von Benachrichtigungen gesendet wurde, startet Grafana den Gruppenintervall-Timer. Dies ist die Zeit, die Grafana wartet, bevor sie Benachrichtigungen über Änderungen an die Gruppe sendet. Beispielsweise wurde der Gruppe möglicherweise gerade ein weiterer Auslösealarm hinzugefügt, während ein vorhandener Alarm möglicherweise behoben wurde. Wenn eine Warnung aufgrund einer Wartezeit in der Gruppe zu spät war, um in die erste Benachrichtigung aufgenommen zu werden, wird sie nach Ablauf des Gruppenintervalls in nachfolgende Benachrichtigungen aufgenommen. Nach Ablauf des Gruppenintervalls setzt Grafana den Gruppenintervall-Timer zurück. Dies wiederholt sich, bis keine Benachrichtigungen mehr in der Gruppe vorhanden sind. Danach wird die Gruppe gelöscht.
**Standard** 5 Minuten
#### Intervall wiederholen
Das Wiederholungsintervall bestimmt, wie oft Benachrichtigungen wiederholt werden, wenn sich die Gruppe seit der letzten Benachrichtigung nicht geändert hat. Sie können sich diese als Erinnerung daran vorstellen, dass einige Benachrichtigungen immer noch ausgelöst werden. Das Wiederholungsintervall steht in engem Zusammenhang mit dem Gruppenintervall. Das bedeutet, dass Ihr Wiederholungsintervall nicht nur größer oder gleich dem Gruppenintervall sein muss, sondern auch ein Vielfaches des Gruppenintervalls sein muss. Wenn das Wiederholungsintervall kein Vielfaches des Gruppenintervalls ist, wird es zu Eins gezwungen. Wenn Ihr Gruppenintervall beispielsweise 5 Minuten und Ihr Wiederholungsintervall 9 Minuten beträgt, wird das Wiederholungsintervall auf das nächste Vielfache von 5 aufgerundet, das 10 Minuten ist.
**Die Standardeinstellung** ist 4 Stunden
# Warnung bei hoher Verfügbarkeit
****
Dieses Dokumentationsthema wurde für Grafana-Workspaces entwickelt, die **Grafana-Version 10.x** unterstützen.
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 9.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 9](using-grafana-v9.md)
Informationen zu Grafana-Arbeitsbereichen, die Grafana-Version 8.x unterstützen, finden Sie unter. [Arbeitet in Grafana-Version 8](using-grafana-v8.md)
Amazon Managed Grafana ist für Hochverfügbarkeit konfiguriert, einschließlich der Ausführung mehrerer Instances in mehreren Availability Zones für jeden Workspace, den Sie erstellen.
Grafana Alerting verwendet das Prometheus-Modell, bei dem die Bewertung von Warnregeln von der Zustellung von Benachrichtigungen getrennt wird. In diesem Modell erfolgt die Auswertung der Warnungsregeln im Alert-Generator und die Zustellung von Benachrichtigungen im Alert-Empfänger. In Grafana Alerting ist der Alert-Generator der Scheduler und der Empfänger der Alertmanager.
Bei Hochverfügbarkeitskonfigurationen werden alle Alert-Regeln auf allen Instanzen ausgewertet. Sie können sich die Auswertung von Warnungsregeln als Duplikat vorstellen. Auf diese Weise stellt Grafana Alerting sicher, dass, solange mindestens eine Grafana-Instanz funktioniert, die Warnungsregeln weiterhin ausgewertet und Benachrichtigungen für Alerts weiterhin gesendet werden. Sie werden diese Duplikation in der Statushistorie sehen. Dies ist eine gute Methode, um festzustellen, ob Sie Hochverfügbarkeit verwenden.