[comment]: # translation:outdated

[comment]: # ({f445d963-f445d963})
# 7 Fonctions prédictives de déclenchement

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

[comment]: # ({9dac6d6d-9dac6d6d})
#### Aperçu

Parfois, il y a des signes du problème à venir. Ces signes peuvent être repérés afin que des actions puissent être prises à l'avance pour prévenir ou au moins minimiser l'impact du problème.

Zabbix dispose d’outils permettant de prédire le comportement futur du système supervisé sur la base de données historiques. Ces outils sont exécutées via des fonctions prédictives de déclenchement.

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

[comment]: # ({24b155a7-24b155a7})
#### - Fonctions

Deux choses à savoir, c'est comment définir un état problématique et combien de temps il faut pour agir. Ensuite, il existe deux façons de configurer un déclencheur signalant une situation indésirable potentielle. Premièrement : le déclencheur doit se déclencher lorsque le système après le "temps d'action" devrait être dans un état problématique. Deuxièmement : le déclencheur doit se déclencher lorsque le système va atteindre l'état du problème en moins de "temps d\'action". Les fonctions de déclenchement correspondantes à utiliser sont **forecast** et **timeleft**. Notez que l'analyse statistique sous-jacente est fondamentalement identique pour les deux fonctions. Vous pouvez configurer un déclencheur de la manière que vous préférez avec des résultats similaires.

[comment]: # ({/24b155a7-24b155a7})

[comment]: # ({c80922f6-c80922f6})

#### - Paramètres

Les deux fonctions utilisent presque le même ensemble de paramètres. Utilisez la liste des [fonctions prises en charge](/manual/appendix/functions) pour référence.

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

[comment]: # ({a93b071e-a93b071e})

##### - Intervalle de temps

Tout d'abord, vous devez spécifier la période historique que Zabbix doit analyser pour arriver à la prédiction. Vous le faites de manière familière au moyen du paramètre `time period` et du décalage temporel facultatif comme vous le faites avec les fonctions **avg**, **count**, **delta**, **max**, **min** et **sum**.

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

[comment]: # ({b922d0f2-b922d0f2})
##### - Horizon de prévision

(**forecast** seulement)\
Le paramètre `time` spécifie combien de temps dans le futur Zabbix doit extrapoler les dépendances trouvées dans les données historiques. Peu importe si vous utilisez `time_shift` ou non, `time` est toujours compté à partir du moment présent.

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

[comment]: # ({625c0c85-625c0c85})
##### - Seuil à atteindre

(**timeleft** seulement)\
Le paramètre `threshold` spécifie une valeur que l'élément analysé doit atteindre, aucune différence si elle est au dessus ou en dessous. Après avoir déterminé f(t) (voir ci-dessous), nous devons résoudre l’équation f(t) = `threshold` et renvoyer la racine la plus proche du moment actuel, situé à droite du moment actuel, ou renvoyer 999999999999.9999 s’il n’existe pas de telles racines.

::: notetip
Lorsque les valeurs d'éléments s'approchent du seuil puis le dépassent, **timeleft** suppose que l'intersection est déjà passée et passe donc à la prochaine intersection avec le niveau de `threshold`, le cas échéant. La meilleure pratique consiste à utiliser les prévisions en complément des diagnostics de problèmes ordinaires, et non en tant que substitution.[^1]
:::

[comment]: # ({/625c0c85-625c0c85})

[comment]: # ({976bd98e-976bd98e})
##### - Fonctions d'ajustement

Par défaut, `fit` est une fonction *linéaire*. Mais si votre système supervisé est plus compliqué, vous aurez plus d'options à choisir.

|`fit`|x = f(t)|
|-----|--------|
|*linéaire*|x = a + b\*t|
|*polynômeN*[^2]|x = a~0~ + a~1~\*t + a~2~\*t^2^ + ... + a~n~\*t^n^|
|*exponentiel*|x = a\*exp(b\*t)|
|*logarithmique*|x = a + b\*log(t)|
|*puissance*|x = a\*t^b^|

[comment]: # ({/976bd98e-976bd98e})

[comment]: # ({add67840-add67840})
##### - Modes

(**forecast** seulement)\
Chaque fois qu'une fonction de déclenchement est évaluée, elle obtient des données de la période d'historique spécifiée et adapte une fonction spécifiée aux données. Donc, si les données sont légèrement différentes, la fonction ajustée sera légèrement différente. Si nous calculons simplement la valeur de la fonction ajustée à une heure future spécifiée, vous ne saurez rien sur le comportement attendu de l'élément analysé d'ici à ce moment-là. Pour certaines options de `fit` (comme *polynôme*), une simple valeur future peut être trompeuse.

|`mode`|résultat **prévisionnel**|
|------|---------------------------|
|*value*|f(maintenant + `time`)|
|*max*|max~maintenant\ <=\ t\ <=\ maintenant\ +\ `time`~ f(t)|
|*min*|min~maintenant\ <=\ t\ <=\ maintenant\ +\ `time`~ f(t)|
|*delta*|*max* - *min*|
|*avg*|moyenne de f(t) (maintenant <= t <= maintenant + `time`) selon la [définition](https://en.wikipedia.org/wiki/Mean_of_a_function)|

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

[comment]: # ({5ff2285e-5ff2285e})
#### - Détails

Pour éviter les calculs avec de grands nombres, considérons l'horodatage de la première valeur de la période spécifiée plus 1 ns comme une nouvelle heure nulle (l'heure actuelle est de l'ordre de 10^9^, l'époque au carré est de 10^18^, la double précision est d'environ 10^-16^). 1 ns est ajoutée pour fournir toutes les valeurs de temps positives pour les ajustements *logarithmiques* et les ajustements de *puissance* impliquant le calcul de log(t). Le décalage temporel n'affecte pas les calculs *linéaires*, *polynomiaux*, *exponentiels* (à l'exception des calculs plus faciles et plus précis), mais modifie la forme des fonctions *logarithmiques* et de *puissance*.

[comment]: # ({/5ff2285e-5ff2285e})

[comment]: # ({660cda6b-660cda6b})
#### - Erreurs potentielles

Les fonctions retournent -1 dans de telles situations :

- la période d'évaluation spécifiée ne contient aucune donnée ;

```{=html}
<!-- -->
```
- le résultat de l'opération mathématique n'est pas défini [^3] ;

```{=html}
<!-- -->
```
- complications numériques (malheureusement, pour certains ensembles de données en entrée, la double précision et la virgule flottante sont insuffisantes) [^4].

::: notetip
Aucun avertissement ni aucune erreur ne sont signalés si l'ajustement choisi décrit mal les données fournies ou s'il y a trop peu de données pour une prédiction précise.
:::

[comment]: # ({/660cda6b-660cda6b})

[comment]: # ({06e0a230-06e0a230})

#### - Exemples et traitement des erreurs

Pour recevoir un avertissement lorsque vous êtes sur le point de manquer d'espace disque libre sur votre hôte, vous pouvez utiliser une expression de déclenchement comme celle-ci :

    timeleft(/host/vfs.fs.size[/,free],1h,0)}<1h

Cependant, le code d'erreur -1 peut entrer en jeu et mettre votre déclencheur dans un état problématique. En général, c'est bien parce que vous recevez un avertissement indiquant que vos prédictions ne fonctionnent pas correctement et vous devriez les examiner plus en détail pour savoir pourquoi. Mais parfois, cela peut être problématique parce que -1 peut simplement signifier qu'il n'y avait pas de données sur l'espace disque libre de l'hôte obtenu au cours de la dernière heure. Si vous recevez trop de fausses alertes positives, envisagez d'utiliser une expression de déclencheur plus complexe [^5] :

    timeleft(/host/vfs.fs.size[/,free],1h,0)<1h and timeleft(/host/vfs.fs.size[/,free],1h,0)<>-1

La situation est un peu plus difficile avec **forecast**. Tout d'abord, -1 peut ou non mettre le déclencheur dans un état problématique selon que vous avez ou non une expression comme `forecast(/host/item,(...))<...` ou comme`forecast(/host/item,(...))>...`

De plus, -1 peut être une prévision valide s'il est normal que la valeur de l'élément soit négative. Mais la probabilité de cette situation dans une situation réelle est négligeable (voir [comment](/manual/config/triggers/expression) l'opérateur **=** fonctionne). Donc, ajoutez `... or forecast(/host/item,(...))=-1` ou `... and forecast(/host/item,(...))<>-1` respectivement si vous voulez ou ne voulez pas traiter -1 comme un problème.

[^1]: Par exemple, un déclencheur simple comme `timeleft(/host/item,1h,X) < 1h` peut entrer dans un état problématique lorsque la valeur de l'élément approche de X, puis se rétablir soudainement une fois la valeur X atteinte. Si le problème est que la valeur de l'élément est inférieure à X, utilisez : `last(/host/item) < X or timeleft(/host/item,1h,X) < 1h`. Si le problème est que la valeur de l'élément est supérieure à X, utilisez : `last(/host/item) > X or timeleft(/host/item,1h,X) < 1h`

[^2]: Le degré polynomial peut être compris entre 1 et 6, *polynomial1* est équivalent à *linéaire*. Cependant, utilisez des polynômes de degré supérieur [avec prudence](https://en.wikipedia.org/wiki/Runge's_phenomenon). Si la période d'évaluation contient moins de points que nécessaire pour déterminer les coefficients polynomiaux, le degré polynomial sera abaissé (par exemple, *polynôme5* est demandé, mais il n'y a que 4 points, donc *polynôme3* sera ajusté).

[^3]: Par exemple, l'ajustement des fonctions *exponential* ou *power* implique le calcul de log() des valeurs des éléments. Si les données contiennent des zéros ou des nombres négatifs, vous obtiendrez une erreur car log() est défini uniquement pour les valeurs positives.

[^4]: Pour les ajustements *linear*, *exponential*, *logarithmic* et *power*, tous les calculs nécessaires peuvent être écrits explicitement. Pour *polynomial*, seule la *value* peut être calculée sans aucune étape supplémentaire. Le calcul de *avg* implique le calcul de la primitive polynomiale (analytiquement). Calculer *max*, *min* et *delta* implique de calculer la dérivée polynomiale (analytiquement) et de trouver ses racines (numériquement). Résoudre f(t) = 0 implique de trouver des racines polynomiales (numériquement).

[^5]: Mais dans ce cas, -1 peut entraîner la récupération de votre déclencheur à partir de l'état du problème. Pour être entièrement protégé, utilisez :`timeleft(/host/vfs.fs.size[/,free],1h,0)<1h and ({TRIGGER.VALUE}=0 and timeleft(/host/vfs.fs.size[/,free],1h,0)<>-1 or {TRIGGER.VALUE}=1)`

[comment]: # ({/06e0a230-06e0a230})