5 Prototypes de découverte

Vue d’ensemble

Les prototypes de découverte sont des règles de découverte de bas niveau imbriquées au sein d’une règle de découverte « parente », permettant de créer une découverte multi-niveaux d’objets avec leurs propres éléments de données, déclencheurs, etc. Par exemple, vous pouvez vouloir découvrir toutes les instances de base de données sur un serveur de base de données, puis découvrir les tablespaces pour chaque instance, puis découvrir les tables pour chaque tablespace.

Les prototypes de découverte disposent de leurs propres prototypes d’élément de données, de déclencheur, de graphique, d’hôte et de découverte. Un prototype de découverte imbriqué utilisera la même valeur JSON que la règle parente si vous spécifiez un type Imbriqué.

Le nombre de niveaux d’imbrication des prototypes de découverte est illimité.

Configuration

Pour créer un prototype de découverte :

• Cliquez sur Discovery prototypes dans la ligne d’une règle de découverte existante

• Cliquez sur Create discovery prototype

Les champs de configuration de ce formulaire sont communs avec la découverte de bas niveau classique.

Si vous sélectionnez « Nested » comme Type dans le formulaire de prototype de découverte ouvert, des règles de découverte (à partir du prototype de découverte) sont alors générées sur la base d’un objet JSON provenant de la même valeur JSON que la règle de découverte parente. Par exemple, si le JSON d’origine est [<objet A>, <objet B>] et qu’il existe un prototype de règle de découverte imbriquée, alors deux règles de découverte seront générées respectivement à partir des données de l’objet A et de l’objet B.

Dans ce cas, le prototype de découverte est activé en même temps que la règle parente. La règle imbriquée peut ainsi utiliser le prétraitement pour travailler sur une autre « tranche » des mêmes données, déjà acquises par le parent.

Les macros LLD de la règle LLD parente sont disponibles pour les règles de découverte imbriquées.

Règles LLD imbriquées sur les hôtes découverts

Une règle de découverte de bas niveau Nested peut être utilisée sur un modèle d’hôte attribué à un prototype d’hôte. Si une règle de découverte Nested existe sur un hôte découvert, alors l’objet JSON utilisé pour découvrir l’hôte est également envoyé à toutes les règles LLD de type imbriqué sur cet hôte. Pour plus de détails, voir l’exemple.

Les macros LLD de la règle de découverte qui a créé l’hôte sont disponibles pour les règles de découverte imbriquées.

Exemple

Illustrons une application possible des prototypes de découverte, à partir de la réception de l’exemple suivant de JSON à plusieurs niveaux.

[
  {
    "database": "db1",
    "created_at": "2024-02-01T12:30:00Z",
    "encoding": "UTF8",
    "tablespaces": [
      { "name": "ts1", "max_size": "10GB" },
      { "name": "ts2", "max_size": "20GB" },
      { "name": "ts3", "max_size": "15GB" }
    ]
  },
  {
    "database": "db2",
    "created_at": "2023-11-15T08:45:00Z",
    "encoding": "UTF16",
    "tablespaces": [
      { "name": "ts1", "max_size": "5GB" },
      { "name": "ts2", "max_size": "25GB" },
      { "name": "ts3", "max_size": "30GB" }
    ]
  },
  {
    "database": "db3",
    "created_at": "2024-01-05T15:10:00Z",
    "encoding": "UTF8",
    "tablespaces": [
      { "name": "ts1", "max_size": "12GB" },
      { "name": "ts2", "max_size": "18GB" },
      { "name": "ts3", "max_size": "22GB" }
    ]
  }
]

Cas 1

Découverte des instances de base de données sur un serveur de base de données, puis découverte des tablespaces pour chaque instance.

1. Vous avez au moins un hôte lié à la découverte du serveur de base de données.

2. Créez une règle LLD pour cet hôte nommée Découvrir les bases de données et les tablespaces.

3. Passez à l'onglet Macros LLD de cette règle, puis ajoutez la macro {#DB}=$.database.

4. Ajoutez un prototype d'élément pour cette règle nommé Connexions actives à {#DB} (Type : Agent, Clé : db.connections[{#DB}]).

5. Les éléments liés à chaque base de données sont découverts :

Active connections to db1, Active connections to db2, Active connections to db3.

6. Créez un prototype de découverte pour cette règle nommé Découvrir les tablespaces pour {#DB} (Type : Nested, Clé : db.tablespace.discovery[{#DB}]).

7. Passez à l'onglet Prétraitement de ce prototype de découverte et ajoutez l'étape JSONPath=$.tablespaces.

8. Passez à l'onglet Macros LLD de ce prototype de découverte, puis ajoutez la macro {#TSNAME}=$.name.

9. Créez un prototype d'élément pour ce prototype de découverte nommé Taille du tablespace {#TSNAME} pour {#DB} (Type : Agent, Clé : db.ts.size[{#DB}, {#TSNAME}]).

10. Les éléments liés à chaque tablespace de chaque base de données sont découverts :

Size of tablespace ts1 for db1, Size of tablespace ts2 for db1, Size of tablespace ts3 for db1,
Size of tablespace ts1 for db2, Size of tablespace ts2 for db2, Size of tablespace ts3 for db2,
Size of tablespace ts1 for db3, Size of tablespace ts2 for db3, Size of tablespace ts3 for db3.

avec les clés db.ts.size[db1,ts1], db.ts.size[db1,ts2], ... db.ts.size[db3,ts3].

Cas 2

Découverte des instances de base de données sur le serveur de base de données en les représentant comme des hôtes découverts, puis découverte des tablespaces pour chaque instance.

1. Vous disposez d'au moins un hôte (hôte racine) lié à la découverte du serveur de base de données.

2. Créez un modèle pour découvrir les tablespaces de chaque base de données.

3. Créez un élément dans ce modèle nommé Connexions actives à {#DB} (Type : Agent, clé : db.connections[{#DB}]).

4. Créez une règle LLD pour ce modèle nommée Découvrir les tablespaces (Type : imbriqué).

5. Passez à l'onglet Preprocessing de cette règle et ajoutez l'étape JSONPath=$.tablespaces.

6. Passez à l'onglet Macros LLD de cette règle, ajoutez la macro {#TSNAME}=$.name.

7. Créez un prototype d'élément pour cette règle nommé Taille du tablespace {#TSNAME} pour {#DB} (Type : Agent, clé : db.ts.size[{#DB}, {#TSNAME}]).

8. De retour sur l'hôte racine, créez une règle LLD pour cet hôte nommée Découvrir les bases de données et les tablespaces.

9. Passez à l'onglet Macros LLD de cette règle, ajoutez la macro {#DB}=$.database.

10. Ajoutez un prototype d'hôte pour cette règle nommé Hôte pour la base de données {#DB}.

11. Passez à l'onglet Macros de ce prototype d'hôte, ajoutez la macro {$DB}={#DB} (pour le nom et la clé de l'élément de l'étape 3).

12. Liez le modèle de l'étape 2 à ce prototype d'hôte.

13. Les hôtes découverts contiennent les éléments découverts liés à chaque base de données et à ses tablespaces :