[comment]: # ({510ac9cc-510ac9cc})
# 2 Auslöser-Ausdruck

[comment]: # ({/510ac9cc-510ac9cc})

[comment]: # ({07d50a02-473bcd5e})
#### Übersicht

Die in [Auslösern](/manual/config/triggers) verwendeten Ausdrücke sind sehr flexibel.
Sie können damit komplexe logische Tests zu überwachten Statistiken erstellen.

Ein einfacher Ausdruck verwendet eine **Funktion**, die auf den Datenpunkt mit bestimmten Parametern angewendet wird.
Die Funktion gibt ein Ergebnis zurück, das mithilfe eines Operators und einer Konstante mit dem Schwellenwert verglichen wird.

Die Syntax eines einfachen, nützlichen Ausdrucks lautet `function(/host/key,parameter)<operator><constant>`.

Zum Beispiel:

```default
min(/Zabbix server/net.if.in[eth0,bytes],5m)>100K
```

löst einen Auslöser aus, wenn die Anzahl der empfangenen Bytes in den letzten fünf Minuten immer über 100 Kilobyte lag.

Obwohl die Syntax exakt gleich ist, gibt es aus funktionaler Sicht zwei Arten von Auslöser-Ausdrücken:

-   Problem-Ausdruck - definiert die Bedingungen des Problems
-   Wiederherstellungs-Ausdruck (optional) - definiert zusätzliche Bedingungen für die Problembehebung

Wenn nur ein Problem-Ausdruck definiert wird, wird dieser Ausdruck sowohl als Problemschwellenwert als auch als Wiederherstellungsschwellenwert verwendet.
Sobald der Problem-Ausdruck TRUE ergibt, liegt ein Problem vor.
Sobald der Problem-Ausdruck FALSE ergibt, ist das Problem behoben.

Wenn sowohl ein Problem-Ausdruck als auch der ergänzende Wiederherstellungs-Ausdruck definiert sind, wird die Problembehebung komplexer: Der Problem-Ausdruck muss nicht nur FALSE ergeben, sondern auch der Wiederherstellungs-Ausdruck TRUE.
Dies ist nützlich, um [Hysterese](#hysteresis) zu erstellen und Trigger-Flapping zu vermeiden.

:::noteclassic
Es ist unproduktiv, das Makro {TRIGGER.VALUE} in einem Wiederherstellungs-Ausdruck zu verwenden, da dieser Ausdruck nur ausgewertet wird, wenn sich der Auslöser im Zustand "Problem" befindet. Folglich wird {TRIGGER.VALUE} bei der Auswertung des Ausdrucks immer zu "1" aufgelöst (was einen Zustand "Problem" kennzeichnet).
:::

[comment]: # ({/07d50a02-473bcd5e})

[comment]: # ({8df5a50f-d4e5ef03})
#### Funktionen

Funktionen ermöglichen es, die gesammelten Werte zu berechnen (Durchschnitt, Minimum, Maximum, Summe), Zeichenfolgen zu suchen, auf die aktuelle Zeit und andere Faktoren zu verweisen.

Eine vollständige Liste der [unterstützten Funktionen](/manual/appendix/functions) ist verfügbar.

Typischerweise geben Funktionen numerische Werte für Vergleiche zurück.
Beim Zurückgeben von Zeichenfolgen ist ein Vergleich mit den Operatoren **=** und **<>** möglich (siehe [Beispiel](#example-14)).

[comment]: # ({/8df5a50f-d4e5ef03})

[comment]: # ({79396a0f-b255de16})
#### Funktionsparameter

Funktionsparameter ermöglichen die Angabe von:

-   Host- und Datenpunkt-Schlüssel (nur Funktionen, die sich auf die Historie des Host-Datenpunkts beziehen)
-   funktionsspezifischen Parametern
-   anderen Ausdrücken (für Funktionen, die sich auf die Historie des Host-Datenpunkts beziehen, nicht verfügbar; siehe [andere Ausdrücke](#other-expressions) für Beispiele)

Der Host- und Datenpunkt-Schlüssel kann als `/host/key` angegeben werden.<br>
Das Weglassen des Hostnamens im ersten Parameter (d. h. wie in `function(//key,parameter,...)`) wird nur in bestimmten Kontexten unterstützt:

-   In der Formel von berechneten Datenpunkten
-   In Ausdrucksmakros, die verwendet werden können in:
    -   Dem Feld [*Ereignisname*](/manual/config/triggers/trigger#configuration)
    -   Dem Graphennamen
    -   Dem Label der [Map-Elemente](/manual/config/visualization/maps/map#adding-elements) "Host" und "Trigger"

In diesen Kontexten können Sie auch das Makro [`{HOST.HOST}`](/manual/appendix/macros/supported_by_location#hosthost) verwenden.
`{HOST.HOST<1-9>}` kann im Fall des Felds *Ereignisname* und des Map-Elements "Trigger" verwendet werden, um auf ein bestimmtes Element im Auslöser-Ausdruck zu verweisen.
Wenn der Hostname in diesen Kontexten weggelassen oder durch `{HOST.HOST}` ersetzt wird, verweist die Referenz auf das erste Element im Auslöser-Ausdruck oder auf das erste Element im Graphen.
Außerhalb dieser unterstützten Kontexte führt das Weglassen des Hostnamens in Auslöser-Ausdrücken zu einem Fehler.
Siehe [Beispiel 18](#example-18) für eine Veranschaulichung der Verwendung von Doppelschrägstrichen in Makros für Ereignisnamen.

Der referenzierte Datenpunkt muss sich in einem unterstützten Zustand befinden (mit Ausnahme der Funktion **nodata()**, die auch für nicht unterstützte Datenpunkte berechnet wird).

Während andere Auslöser-Ausdrücke als Funktionsparameter in Auslösern auf Nicht-Historien-Funktionen beschränkt sind, gilt diese Einschränkung in [berechneten Datenpunkten](/manual/config/items/itemtypes/calculated) nicht.

[comment]: # ({/79396a0f-b255de16})

[comment]: # ({233dadf7-cf9e09bb})
##### Funktionsspezifische Parameter

Funktionsspezifische Parameter werden nach dem Datenpunkt-Schlüssel platziert und durch ein Komma vom Datenpunkt-Schlüssel getrennt.
Eine vollständige Liste dieser Parameter finden Sie unter den [unterstützten Funktionen](/manual/appendix/functions).

Die meisten numerischen Funktionen akzeptieren Zeit als Parameter.
Sie können Sekunden oder [Zeitsuffixe](/manual/appendix/suffixes) verwenden, um die Zeit anzugeben.
Wird dem Parameter ein Hash-Zeichen vorangestellt, hat er eine andere Bedeutung:

|Expression|Description|
|----------|-----------|
|**sum**(/host/key,**10m)**|Summe der Werte in den letzten 10 Minuten.|
|**sum**(/host/key,**\#10)**|Summe der letzten zehn Werte.|

Parameter mit einem Hash-Zeichen haben bei der Funktion **last** eine andere Bedeutung - sie bezeichnen den N-ten vorherigen Wert. Bei den Werten 30, 70, 20, 60, 50 (vom aktuellsten zum ältesten) gilt daher:

-   `last(/host/key,#2)` würde '70' zurückgeben
-   `last(/host/key,#5)` würde '50' zurückgeben

[comment]: # ({/233dadf7-cf9e09bb})

[comment]: # ({bf48db7f-6699e631})
##### Zeitverschiebung

Eine optionale Zeitverschiebung wird mit Zeit oder Wertanzahl als Funktionsparameter unterstützt.
Dieser Parameter ermöglicht es, Daten aus einem Zeitraum in der Vergangenheit zu referenzieren.

Die Zeitverschiebung beginnt mit `now` - der Angabe der aktuellen Zeit, und wird gefolgt von `+N<time unit>` oder `-N<time unit>` - um N Zeiteinheiten hinzuzufügen oder zu subtrahieren.

Zum Beispiel gibt `avg(/host/key,1h:now-1d)` den Durchschnittswert für eine Stunde vor einem Tag zurück.

::: noteimportant
Eine in Monaten (M) und Jahren (y) angegebene Zeitverschiebung wird nur für [Trendfunktionen](/manual/appendix/functions/trends) unterstützt. Andere Funktionen unterstützen Sekunden (s), Minuten (m), Stunden (h), Tage (d) und Wochen (w).
:::

**Zeitverschiebung mit absoluten Zeiträumen**

Absolute Zeiträume werden im Zeitverschiebungsparameter unterstützt, zum Beispiel Mitternacht bis Mitternacht für einen Tag, Montag bis Sonntag für eine Woche, erster Tag bis letzter Tag des Monats für einen Monat.

Die Zeitverschiebung für absolute Zeiträume beginnt mit `now` - der Angabe der aktuellen Zeit, und wird gefolgt von beliebig vielen Zeitoperationen: `/<time unit>` - definiert den Beginn und das Ende der Zeiteinheit, zum Beispiel Mitternacht bis Mitternacht für einen Tag, `+N<time unit>` oder `-N<time unit>` - um N Zeiteinheiten hinzuzufügen oder zu subtrahieren.

Bitte beachten Sie, dass der Wert der Zeitverschiebung größer oder gleich 0 sein kann, während der minimale Wert des Zeitraums 1 ist.

|Parameter|Beschreibung|
|--|--------|
|1d:now/d|Gestern|
|1d:now/d+1d|Heute|
|2d:now/d+1d|Letzte 2 Tage|
|1w:now/w|Letzte Woche|
|1w:now/w+1w|Diese Woche|

[comment]: # ({/bf48db7f-6699e631})

[comment]: # ({afa2064a-c5d3ec54})
##### Andere Ausdrücke

Funktionsparameter können andere Ausdrücke enthalten, wie in der folgenden Syntax:

```default
min(min(/host/key,1h),min(/host2/key2,1h)*10)
```

Beachten Sie, dass andere Ausdrücke nicht verwendet werden dürfen, wenn die Funktion auf die Historie eines Datenpunkts verweist.
Zum Beispiel ist die folgende Syntax **nicht** zulässig:

~~`min(/host/key,#5*10)`~~

[comment]: # ({/afa2064a-c5d3ec54})

[comment]: # ({5aa16694-10bc91a2})
#### Operatoren

Die folgenden Operatoren werden für Auslöser unterstützt **(in absteigender Priorität der Ausführung)**:

|Priorität|Operator|Definition|**Hinweise für [unbekannte Werte](/manual/config/triggers/expression#expressions-with-unknown-operands)**|Operand zwangsweise in float umwandeln ^**1**^|
|-|-|----|----------------|--|
|**1**|**-**|Unäres Minus|**-**Unbekannt → Unbekannt|Ja|
|**2**|**not**|Logisches NICHT|**not** Unbekannt → Unbekannt|Ja|
|**3**|**\***|Multiplikation|0 **\*** Unbekannt → Unbekannt<br>(ja, Unbekannt, nicht 0 - damit Unbekannt<br>bei arithmetischen Operationen nicht verloren geht)<br>1.2 **\*** Unbekannt → Unbekannt|Ja|
|<|**/**|Division|Unbekannt **/** 0 → Fehler<br>Unbekannt **/** 1.2 → Unbekannt<br>0.0 **/** Unbekannt → Unbekannt|Ja|
|**4**|**+**|Arithmetisches Plus|1.2 **+** Unbekannt → Unbekannt|Ja|
|<|**-**|Arithmetisches Minus|1.2 **-** Unbekannt → Unbekannt|Ja|
|**5**|**\<**|Kleiner als. Der Operator ist definiert als:<br><br>A<B ⇔ (A<B-0.000001)|1.2 **<** Unbekannt → Unbekannt|Ja|
|<|**<=**|Kleiner als oder gleich. Der Operator ist definiert als:<br><br>A<=B ⇔ (A≤B+0.000001)|Unbekannt **<=** Unbekannt → Unbekannt|Ja|
|<|**>**|Größer als. Der Operator ist definiert als:<br><br>A>B ⇔ (A>B+0.000001)| |Ja|
|<|**>=**|Größer als oder gleich. Der Operator ist definiert als:<br><br>A>=B ⇔ (A≥B-0.000001)| |Ja|
|**6**|**=**|Gleich. Der Operator ist definiert als:<br><br>A=B ⇔ (A≥B-0.000001) and (A≤B+0.000001)| |Nein ^**1**^|
|<|**<>**|Ungleich. Der Operator ist definiert als:<br><br>A<>B ⇔ (A<B-0.000001) or (A>B+0.000001)| |Nein ^**1**^|
|**7**|**and**|Logisches UND|0 **and** Unbekannt → 0<br>1 **and** Unbekannt → Unbekannt<br>Unbekannt **and** Unbekannt → Unbekannt|Ja|
|**8**|**or**|Logisches ODER|1 **or** Unbekannt → 1<br>0 **or** Unbekannt → Unbekannt<br>Unbekannt **or** Unbekannt → Unbekannt|Ja|

^**1**^ Ein String-Operand wird dennoch in einen numerischen Wert umgewandelt, wenn:

-   der andere Operand numerisch ist
-   ein anderer Operator als **=** oder **<>** auf einen Operand angewendet wird

Bei relationalen Operatoren (`<`, `<=`, `>`, `>=`): Wenn die Umwandlung fehlschlägt (z. B. bei `""`), ergibt der Ausdruck Unbekannt (kein Fallback auf String-Vergleich).

Bei Gleichheitsoperatoren (`=`, `<>`): Wenn die Umwandlung fehlschlägt, werden die Operanden als rohe Strings verglichen.

Die Operatoren **not**, **and** und **or** sind case-sensitiv und müssen kleingeschrieben sein.
Außerdem müssen sie von Leerzeichen oder Klammern umgeben sein.

Alle Operatoren außer dem unären **-** und **not** sind linksassoziativ.
Der unäre **-** und **not** sind nicht assoziativ (das heißt, es sollte **-(-1)** und **not (not 1)** statt **--1** und **not not 1** verwendet werden).

Ergebnis der Auswertung:

-   Die Operatoren **<**, **<=**, **>**, **>=**, **=**, **<>** liefern im Auslöserausdruck '1', wenn die angegebene Relation wahr ist, und '0', wenn sie falsch ist.
Wenn mindestens ein Operand Unbekannt ist, ist das Ergebnis Unbekannt;
-   **and** liefert für bekannte Operanden '1', wenn beide Operanden ungleich '0' sind; andernfalls '0'; für unbekannte Operanden liefert **and** nur dann '0', wenn ein Operand gleich '0' ist; andernfalls 'Unknown';
-   **or** liefert für bekannte Operanden '1', wenn einer der Operanden ungleich '0' ist; andernfalls '0'; für unbekannte Operanden liefert **or** nur dann '1', wenn ein Operand ungleich '0' ist; andernfalls 'Unknown';
-   Das Ergebnis des logischen Negationsoperators **not** ist für einen bekannten Operand '0', wenn der Wert seines Operanden ungleich '0' ist; '1', wenn der Wert seines Operanden gleich '0' ist.
Für einen unbekannten Operand liefert **not** 'Unknown'.

[comment]: # ({/5aa16694-10bc91a2})

[comment]: # ({0e2466bf-195c3f4f})
#### Wert-Caching

Die für die Auslöserauswertung erforderlichen Werte werden vom Zabbix Server zwischengespeichert.
Daher verursacht die Auswertung von Auslösern für einige Zeit nach einem Neustart des Servers eine höhere Datenbanklast.

Der Wert-Cache wird nicht geleert, wenn Verlaufswerte von Datenpunkten entfernt werden (entweder manuell oder durch den Housekeeper), sodass der Server die zwischengespeicherten Werte verwendet, bis sie älter sind als die in Auslöserfunktionen definierten Zeiträume oder der Server neu gestartet wird.

::: noteclassic
Wenn sich keine aktuellen Daten im Cache befinden und in der Funktion kein Abfragezeitraum definiert ist, greift Zabbix standardmäßig bis zu eine Woche in die Vergangenheit zurück, um historische Werte aus der Datenbank abzufragen.
:::

[comment]: # ({/0e2466bf-195c3f4f})

[comment]: # ({abac99e3-abac99e3})
#### Beispiele für Auslöser

[comment]: # ({/abac99e3-abac99e3})

[comment]: # ({56e707cf-17b607dc})
##### Beispiel 1

Die Prozessorlast auf dem Zabbix Server ist zu hoch.

```default
last(/Zabbix server/system.cpu.load[all,avg1])>5
```

Mit der Funktion 'last()' verweisen wir auf den aktuellsten Wert.
`/Zabbix server/system.cpu.load[all,avg1]` gibt einen Kurznamen des überwachten Parameters an.
Sie legt fest, dass der Host 'Zabbix server' ist und der überwachte Schlüssel 'system.cpu.load\[all,avg1\]' lautet.
Schließlich bedeutet `>5`, dass sich der Auslöser im PROBLEM-Zustand befindet, sobald die aktuellste Messung der Prozessorlast von Zabbix server größer als 5 ist.

[comment]: # ({/56e707cf-17b607dc})

[comment]: # ({eb26dc13-9a129732})
##### Beispiel 2

www.example.com ist überlastet.

```default
last(/www.example.com/system.cpu.load[all,avg1])>5 or min(/www.example.com/system.cpu.load[all,avg1],10m)>2 
```

Der Ausdruck ist wahr, wenn entweder die aktuelle Prozessorlast größer als 5 ist oder die Prozessorlast in den letzten 10 Minuten größer als 2 war.

[comment]: # ({/eb26dc13-9a129732})

[comment]: # ({c3efce1a-49592749})
##### Beispiel 3

/etc/passwd wurde geändert.

```default
last(/www.example.com/vfs.file.cksum[/etc/passwd],#1)<>last(/www.example.com/vfs.file.cksum[/etc/passwd],#2)
```

Der Ausdruck ist wahr, wenn sich der vorherige Wert der Prüfsumme von /etc/passwd vom aktuellsten unterscheidet.

Ähnliche Ausdrücke können nützlich sein, um Änderungen an wichtigen Dateien zu überwachen, z. B. /etc/passwd, /etc/inetd.conf, /kernel usw.

[comment]: # ({/c3efce1a-49592749})

[comment]: # ({2c152827-46e72843})
##### Beispiel 4

Jemand lädt eine große Datei aus dem Internet herunter.

Verwendung der Funktion min:

```default
min(/www.example.com/net.if.in[eth0,bytes],5m)>100K
```

Der Ausdruck ist wahr, wenn die Anzahl der empfangenen Bytes auf eth0 in den letzten 5 Minuten mehr als 100 KB beträgt.

[comment]: # ({/2c152827-46e72843})

[comment]: # ({914aa064-7956e04e})
##### Beispiel 5

Beide Knoten des geclusterten SMTP-Servers sind ausgefallen.

Beachten Sie die Verwendung von zwei verschiedenen Hosts in einem Ausdruck:

```default
last(/smtp1.example.com/net.tcp.service[smtp])=0 and last(/smtp2.example.com/net.tcp.service[smtp])=0
```

Der Ausdruck ist wahr, wenn beide SMTP-Server sowohl auf smtp1.example.com als auch auf smtp2.example.com ausgefallen sind.

[comment]: # ({/914aa064-7956e04e})

[comment]: # ({461ff958-62cfb014})
##### Beispiel 6

Der Zabbix Agent muss aktualisiert werden.

Verwendung der Funktion find():

```default
find(/example.example.com/agent.version,,"like","beta8")=1
```

Der Ausdruck ist wahr, wenn der Zabbix Agent die Version beta8 hat.

[comment]: # ({/461ff958-62cfb014})

[comment]: # ({b25c8bb8-567b88a9})
##### Beispiel 7

Server ist nicht erreichbar.

```default
count(/example.example.com/icmpping,30m,,"0")>5
```

Der Ausdruck ist wahr, wenn der Host "example.example.com" in den letzten 30 Minuten mehr als 5 Mal nicht erreichbar ist.

[comment]: # ({/b25c8bb8-567b88a9})

[comment]: # ({c264178f-2f13cb92})
##### Beispiel 8

Keine Heartbeats innerhalb der letzten 3 Minuten.

Verwendung der Funktion nodata():

```default
nodata(/example.example.com/tick,3m)=1
```

Um diesen Auslöser zu verwenden, muss 'tick' als Zabbix [trapper](/manual/config/items/itemtypes/trapper)-Datenpunkt definiert sein.
Der Host sollte regelmäßig Daten für diesen Datenpunkt mit zabbix\_sender senden.
Wenn innerhalb von 180 Sekunden keine Daten empfangen werden, wird der Wert des Auslösers zu PROBLEM.

*Hinweis*, dass 'nodata' für jeden Datenpunkttyp verwendet werden kann.

[comment]: # ({/c264178f-2f13cb92})

[comment]: # ({663a1265-2c48905a})
##### Beispiel 9

CPU-Aktivität in der Nacht.

Verwendung der Funktion time():

```default
min(/Zabbix Server/system.cpu.load[all,avg1],5m)>2 and time()<060000
```

Der Auslöser kann seinen Status nur nachts (00:00 - 06:00) auf Problem ändern.

[comment]: # ({/663a1265-2c48905a})

[comment]: # ({2a28e303-7e0ba13a})
##### Beispiel 10

CPU-Aktivität zu jeder Zeit mit Ausnahme.

Verwendung der Funktion time() und des Operators **not**:

```default
min(/zabbix/system.cpu.load[all,avg1],5m)>2
and not (dayofweek()=7 and time()>230000)
and not (dayofweek()=1 and time()<010000)
```

Der Auslöser kann seinen Status jederzeit auf Problem ändern, außer für 2 Stunden bei einem Wochenwechsel (Sonntag, 23:00 - Montag, 01:00).

[comment]: # ({/2a28e303-7e0ba13a})

[comment]: # ({dbb498df-0e6bfc51})
##### Beispiel 11

Prüfen, ob die lokale Zeit des Clients mit der Zeit des Zabbix-Servers synchron ist.

Verwendung der Funktion fuzzytime():

```default
fuzzytime(/MySQL_DB/system.localtime,10s)=0
```

Der Auslöser wechselt in den Problemzustand, wenn sich die lokale Zeit auf dem Server MySQL\_DB und die Zeit des Zabbix-Servers um mehr als 10 Sekunden unterscheidet.
Beachten Sie, dass 'system.localtime' für den Zabbix Agent als [passive Prüfung](/manual/appendix/items/activepassive#passive-checks) konfiguriert sein muss; beim Zabbix Agent 2 kann sie als aktive Prüfung konfiguriert werden.

[comment]: # ({/dbb498df-0e6bfc51})

[comment]: # ({4f63a3b1-47b2e2fd})
##### Beispiel 12

Vergleich der durchschnittlichen Auslastung heute mit der durchschnittlichen Auslastung zur gleichen Zeit gestern (unter Verwendung von time shift als `now-1d`).

```default
avg(/server/system.cpu.load,1h)/avg(/server/system.cpu.load,1h:now-1d)>2
```

Der Auslöser wird ausgelöst, wenn die durchschnittliche Auslastung der letzten Stunde die durchschnittliche Auslastung derselben Stunde gestern um mehr als das Zweifache übersteigt.

[comment]: # ({/4f63a3b1-47b2e2fd})

[comment]: # ({536c07d9-bb0f5278})
##### Beispiel 13

Verwendung des Werts eines anderen Datenpunkts, um einen Auslöser-Schwellenwert zu ermitteln:

```default
last(/Template PfSense/hrStorageFree[{#SNMPVALUE}])<last(/Template PfSense/hrStorageSize[{#SNMPVALUE}])*0.1
```

Der Auslöser wird ausgelöst, wenn der freie Speicher unter 10 Prozent fällt.

[comment]: # ({/536c07d9-bb0f5278})

[comment]: # ({e67109f1-0cc34ec7})
##### Beispiel 14

Verwendung des [Auswertungsergebnisses](#operators), um die Anzahl der Auslöser über einem Schwellenwert zu ermitteln:

```default
(last(/server1/system.cpu.load[all,avg1])>5) + (last(/server2/system.cpu.load[all,avg1])>5) + (last(/server3/system.cpu.load[all,avg1])>5)>=2
```

Der Auslöser wird ausgelöst, wenn sich mindestens zwei der Auslöser in der Ausdrucksdefinition in einem Problemzustand befinden.

[comment]: # ({/e67109f1-0cc34ec7})

[comment]: # ({3d70b4b9-adfc6b9d})
##### Beispiel 15

Vergleich von Zeichenfolgenwerten zweier Datenpunkte - die Operanden sind hier Funktionen, die Zeichenfolgen zurückgeben.

Problem: Erstellen Sie einen Alarm, wenn die Ubuntu-Version auf verschiedenen Hosts unterschiedlich ist

```default
last(/NY Zabbix server/vfs.file.contents[/etc/os-release])<>last(/LA Zabbix server/vfs.file.contents[/etc/os-release])
```

[comment]: # ({/3d70b4b9-adfc6b9d})

[comment]: # ({18b8548e-c2b4949f})
##### Beispiel 16

Vergleich zweier Stringwerte - die Operanden sind:

-   eine Funktion, die einen String zurückgibt
-   eine Kombination aus Makros und Strings

Problem: Änderungen in der DNS-Abfrage erkennen

Der Datenpunkt-Schlüssel lautet:

```default
net.dns.record[192.0.2.1,{$WEBSITE_NAME},{$DNS_RESOURCE_RECORD_TYPE},2,1]
```

mit wie folgt definierten Makros:

```default
{$WEBSITE_NAME} = example.com
{$DNS_RESOURCE_RECORD_TYPE} = MX
```

und gibt normalerweise Folgendes zurück:

```default
example.com           MX       0 mail.example.com
```

Der Ausdruck für unseren Auslöser, um zu erkennen, ob das Ergebnis der DNS-Abfrage vom erwarteten Ergebnis abweicht, lautet daher:

```default
last(/Zabbix server/net.dns.record[192.0.2.1,{$WEBSITE_NAME},{$DNS_RESOURCE_RECORD_TYPE},2,1])<>"{$WEBSITE_NAME}           {$DNS_RESOURCE_RECORD_TYPE}       0 mail.{$WEBSITE_NAME}"
```

Beachten Sie die Anführungszeichen um den zweiten Operanden.

[comment]: # ({/18b8548e-c2b4949f})

[comment]: # ({3c7c7fa3-60fad4fc})
##### Beispiel 17

Vergleich zweier Stringwerte - Operanden sind:

-   eine Funktion, die einen String zurückgibt
-   eine Stringkonstante mit Sonderzeichen \\ und "

Problem: Ermitteln, ob der Inhalt der Datei `/tmp/hello` gleich ist:

```default
\" //hello ?\"
```

Option 1. Den String direkt schreiben:

```default
last(/Zabbix server/vfs.file.contents[/tmp/hello])="\\\" //hello ?\\\""
```

Beachten Sie, wie die Zeichen \\ und " maskiert werden, wenn der String direkt verglichen wird.

Option 2. Ein Makro verwenden

```default
{$HELLO_MACRO} = \" //hello ?\"
```

in der Ausdrucksformel:

```default
last(/Zabbix server/vfs.file.contents[/tmp/hello])={$HELLO_MACRO}
```

[comment]: # ({/3c7c7fa3-60fad4fc})

[comment]: # ({9351ce5e-6906462b})
##### Beispiel 18

Vergleich langfristiger Zeiträume.

Problem: Die Auslastung des Exchange-Servers ist im letzten Monat um mehr als 10 % gestiegen

```default
trendavg(/Exchange/system.cpu.load,1M:now/M)>1.1*trendavg(/Exchange/system.cpu.load,1M:now/M-1M)
```

Sie können auch das Feld [Ereignisname](/manual/config/triggers/trigger#configuration) in der Auslöser-Konfiguration verwenden, um eine aussagekräftige Alarmmeldung zu erstellen, zum Beispiel um etwas wie Folgendes zu erhalten:

`"Load of Exchange server increased by 24% in July (0.69) comparing to June (0.56)"`

der Ereignisname muss wie folgt definiert werden:

```default
Load of {HOST.HOST} server increased by {{?100*trendavg(//system.cpu.load,1M:now/M)/trendavg(//system.cpu.load,1M:now/M-1M)}.fmtnum(0)}% in {{TIME}.fmttime(%B,-1M)} ({{?trendavg(//system.cpu.load,1M:now/M)}.fmtnum(2)}) comparing to {{TIME}.fmttime(%B,-2M)} ({{?trendavg(//system.cpu.load,1M:now/M-1M)}.fmtnum(2)})
```

Es ist außerdem sinnvoll, das manuelle Schließen in der Auslöser-Konfiguration für diese Art von Problem zuzulassen.

[comment]: # ({/9351ce5e-6906462b})

[comment]: # ({0927c71d-contribute})
::: note-contribute
Haben Sie ein Beispiel für Auslöserausdrücke, das für andere nützlich sein könnte? Verwenden Sie das [Beispielvorschlagsformular](#report-example), um es an die Zabbix-Entwickler zu senden.
:::

[comment]: # ({/0927c71d-contribute})

[comment]: # ({6e5624e6-3f1b1c81})
#### Hysterese

Manchmal wird zwischen Problem- und Wiederherstellungszustand ein Intervall benötigt, statt nur eines einfachen Schwellwerts.
Wenn wir beispielsweise einen Auslöser definieren möchten, der ein Problem meldet, wenn die Temperatur im Serverraum über 20 °C steigt, und der im Problemzustand bleiben soll, bis die Temperatur unter 15 °C fällt, reicht ein einfacher Auslöser-Schwellwert bei 20 °C nicht aus.

Stattdessen müssen wir zuerst einen Auslöserausdruck für das Problemereignis definieren (Temperatur über 20 °C).
Dann müssen wir eine zusätzliche Wiederherstellungsbedingung definieren (Temperatur unter 15 °C).
Dies geschieht durch die Definition eines zusätzlichen Parameters *Recovery expression*, wenn ein Auslöser [definiert](/manual/config/triggers/trigger) wird.

In diesem Fall erfolgt die Wiederherstellung des Problems in zwei Schritten:

-   Zuerst muss der Problemausdruck (Temperatur über 20 °C) zu FALSE ausgewertet werden
-   Danach muss der Wiederherstellungsausdruck (Temperatur unter 15 °C) zu TRUE ausgewertet werden

Der Wiederherstellungsausdruck wird nur ausgewertet, wenn das Problemereignis zuerst behoben wurde.

::: notewarning
Dass der Wiederherstellungsausdruck allein TRUE ist, behebt kein Problem, wenn der Problemausdruck weiterhin TRUE ist!
:::

[comment]: # ({/6e5624e6-3f1b1c81})

[comment]: # ({e401ef55-942a7e0e})
##### Beispiel 1

Die Temperatur im Serverraum ist zu hoch.

Problem-Ausdruck:

```default
last(/server/temp)>20
```

Wiederherstellungs-Ausdruck:

```default
last(/server/temp)<=15
```

[comment]: # ({/e401ef55-942a7e0e})

[comment]: # ({489d9e1d-bddf0717})
##### Beispiel 2

Der freie Speicherplatz auf der Festplatte ist zu gering.

Problem-Ausdruck: Er liegt in den letzten 5 Minuten unter 10 GB

```default
max(/server/vfs.fs.size[/,free],5m)<10G
```

Wiederherstellungs-Ausdruck: Er liegt in den letzten 10 Minuten über 40 GB

```default
min(/server/vfs.fs.size[/,free],10m)>40G
```

[comment]: # ({/489d9e1d-bddf0717})

[comment]: # ({91453a7f-6fc2eb1c})
#### Ausdrücke mit unbekannten Operanden

Im Allgemeinen führt ein unbekannter Operand (z. B. ein nicht unterstützter Datenpunkt) im Ausdruck dazu, dass der Auslöserwert sofort auf `Unknown` gesetzt wird.

In einigen Fällen werden unbekannte Operanden (nicht unterstützte Datenpunkte, Funktionsfehler) jedoch in die Auswertung des Ausdrucks einbezogen:

-   Die Funktion `nodata()` wird unabhängig davon ausgewertet, ob der referenzierte Datenpunkt unterstützt wird oder nicht.
-   Logische Ausdrücke mit OR und AND können in zwei Fällen unabhängig von unbekannten Operanden zu bekannten Werten ausgewertet werden:
    -   **Fall 1**: "`1 or some_function(unsupported_item1) or some_function(unsupported_item2) or ...`" kann zu einem bekannten Ergebnis ausgewertet werden ('1' oder "Problem"),
    -   **Fall 2**: "`0 and some_function(unsupported_item1) and some_function(unsupported_item2) and ...`" kann zu einem bekannten Ergebnis ausgewertet werden ('0' oder "OK").<br>
        Zabbix versucht, solche logischen Ausdrücke auszuwerten, indem nicht unterstützte Datenpunkte als unbekannte Operanden behandelt werden.
        In den beiden obigen Fällen wird ein bekannter Wert erzeugt ("Problem" bzw. "OK"); in **allen anderen** Fällen wird der Auslöser zu `Unknown` ausgewertet.
-   Wenn die Funktionsauswertung für einen unterstützten Datenpunkt zu einem Fehler führt, wird der Funktionswert zu `Unknown` und geht bei der weiteren Auswertung des Ausdrucks als unbekannter Operand ein.

Beachten Sie, dass unbekannte Operanden nur in logischen Ausdrücken wie oben beschrieben "verschwinden" können.
In arithmetischen Ausdrücken führen unbekannte Operanden immer zum Ergebnis `Unknown` (außer bei Division durch 0).

::: noteimportant
Ein Ausdruck, der zu `Unknown` führt, ändert den Zustand des Auslösers nicht ("Problem/OK").
Wenn er also "Problem" war (siehe Fall 1), bleibt er im selben Problemzustand, selbst wenn der bekannte Teil aufgelöst wird ('1' wird zu '0'), da der Ausdruck nun zu `Unknown` ausgewertet wird und dies den Zustand des Auslösers nicht ändert.
:::

Wenn ein Auslöserausdruck mit mehreren nicht unterstützten Datenpunkten zu `Unknown` ausgewertet wird, bezieht sich die Fehlermeldung im Frontend auf den zuletzt ausgewerteten nicht unterstützten Datenpunkt.

[comment]: # ({/91453a7f-6fc2eb1c})