Page History

Son rôle principal est de permettre de regrouper l'état de plusieurs hôtes ou checks en un seul indicateur de STATUT pour généralement connaître l'état d'un service ( messagerie, site web, ERP, ... ou tout autre besoin qui correspond à vos besoins de supervision ).

• Le statut d'un cluster peut être constitué de l'état
  • des hôtes,
  • de checks,
  • d'autres clusters…  
• Le statut et le contexte sont donc calculés en temps réel en fonctions des éléments qui le composent.

Prenons l'exemple d'un rôle de service "delivery" pour une application ERP .

• Il est principalement constitué de :
  • 2 bases de données, en haute disponibilité, donc avec une seule base active, le service est considéré comme rendu.
  • 2 serveurs web, en partage de charge, donc avec un web serveur actif, le service est considéré comme rendu.
  • 2 serveurs de répartition, encore en haute disponibilité.
• Ces composants ( Hôtes dans cet exemple ) seront la base de ce service ERP.
• Vous pouvez donc avoir une vue agrégée de l'indicateur représentant l'état du service ERP !

Shinken vérifie chaque composant un par un pour l'analyse de problèmes sources.

Règle de calcul d'un STATUT d'un Cluster

Calculer le statut d'un cluster permet

• d'avoir un seul STATUT en regroupant :
  • les états de plusieurs éléments ( hôtes, cluster, checks ),
  • et/ou de groupe d'éléments, c.a.d des ENSEMBLES.
• les règles de calcul peuvent être plus complexes que prendre le pire état des éléments et donc permettre de 

Un Cluster se constitue en utilisant la SYNTAXE de définition disponible :

• Le nom des éléments ( hôtes, clusters et checks ) est utilisé pour identifier les élements:
  • Par exemple simplement 
    • host1
    • cluster1 
    • pour les checks ( la virgule servant de séparateur )
      • Soit vers un check précis, ne donnant le nom du père ( Hôtes / Clusters )  et le nom du check
        • host1,check1
        • cluster1,check9
      • Soit plusieurs checks avec en utilisant *,
        • host1,* 
  • Les guillemets "" doivent être utilisés pour délimiter les noms d'hôtes, cluster et check.
    • notamment lorsque les noms contiennent des espaces.
    • exemple : "ERP de bordeaux".
  • A À noter que le Synchonizer s'occupe du renommage des éléments. 
    • Si vous créer créez une définition en utilisant host1 et que vous le renommer renommez plus tard en superhost1, le Synchronizer s'occupera de la réécriture de la définition.

• Les opérateurs de calcul du STATUT :
  • & : est l'équivalent du ET logique,
  • | : est l'équivalent du OU logique,
  • ! : pour la négation d'un statut,
  • Xof : un ensemble: 
  • X%of : 
  • X,Y,Zof : ,
  • Les parenthèses ouvrantes ( et fermantes ) pour la priorité entre les &, | et les !.
    
    
• Les constructeurs d'ENSEMBLE : 
  • Les crochets [  ] permettent d'encadrer la définition d'une ensemble.
  • <or> => Union d'éléments et / ou d'essemble ensemble pour remplir un emsemble ( ex:   [ host1 <or> host2 ], [ host1 <or> [  host2 <or> host3 ] ] ).
  • <and> => Intersection d'ensembles, pour ne prendre que les éléments qui sont présents dans plusieurs essembles
    • [ host1 <or> <and> host2 ], donne un ensemble vide => []
    • [ host1 <and> [  host1 <or> host3 ] ] donne un ensemble à 1 élément  => host1
  • <and not> => Exclusion ( privé de ), pour spécifiquement exclure un élément ou le contenu d'un ensemble
    • [ host1 <or> host2 ] < and not > host2 un ensemble à 1 élément  => host 1host1 
  • Ensembles constitués par règles à l'aide des expressions suivantes :
    • g: nom du groupe => Hôtes appartenant au groupe d'hôtes,
    • r: regex => Hôtes dont le nom correspond à l'expression régulière,
    • t: nom du modèle d'hôte => Hôtes ayant le modèle d'hôte,
    • tr: regex => Hôtes ayant le ou les modèles d'hôtes qui correspondent à l'expression régulière.
  • Ensembles définis manuellement :
    • les crochets [  ] permettent de délimiter l'écriture d'un ensemble
    • [E1 <or> E2  E2]               =>   Union entre 2 ensembles ( ou dans E1, ou dans E2 )
    • [E1 <and> E2  E2]            =>   Intersection entre 2 ensembles ( Dans E1 et dans E2 )
    • [E1<and> <and not> E2  E2]   =>  Exclusion ( présent dans E1 mais pas dans E2 )