This is a translation of the original English documentation page. Help us make it better.

discoveryrule.create

Description

object discoveryrule.create(object/array lldRules)

Cette méthode permet de créer de nouvelles règles de découverte bas niveau.

Cette méthode est disponible uniquement pour les utilisateurs de type Admin et Super admin. Les autorisations d'appel de la méthode peuvent être révoquées dans les réglages du rôle d'utilisateur. Voir les Rôles utilisateur pour plus d'informations.

Paramètres

(object/array) Règles de découverte bas niveau à créer.

En plus des propriétés de l'objet règle de découverte bas niveau standard, la méthode accepte les paramètres suivants.

Paramètre Type Description
filter object Objet filtre de la règle LLD.
preprocessing array Options de prétraitement de la règle LLD.
lld_macro_paths array Options lld_macro_path de la règle LLD.
overrides array Options de remplacement de la règle LLD.

Valeurs retournées

(object) Retourne un objet contenant les identifiants des règles de découverte bas niveau créées sous la propriété itemids. L'ordre des ID retournés correspond à l'ordre des règles de découverte bas niveau transmises.

Exemples

Création d'une règle de découverte bas niveau

Créer une règle de découverte bas niveau pour découvrir les systèmes de fichiers montés. Les objets découverts seront mis à jour toutes les 30 secondes.

Requête :

{
           "jsonrpc": "2.0",
           "method": "discoveryrule.create",
           "params": {
               "name": "Mounted filesystem discovery",
               "key_": "vfs.fs.discovery",
               "hostid": "10197",
               "type": "0",
               "interfaceid": "112",
               "delay": "30s"
           },
           "auth": "038e1d7b1735c6a5436ee9eae095879e",
           "id": 1
       }

Réponse :

{
           "jsonrpc": "2.0",
           "result": {
               "itemids": [
                   "27665"
               ]
           },
           "id": 1
       }

Utilisation d'un filtre

Créer une règle de découverte bas niveau avec un ensemble de conditions pour filtrer les résultats. Les conditions seront regroupées à l’aide de l'opérateur logique "et".

Requête :

{
           "jsonrpc": "2.0",
           "method": "discoveryrule.create",
           "params": {
               "name": "Filtered LLD rule",
               "key_": "lld",
               "hostid": "10116",
               "type": "0",
               "interfaceid": "13",
               "delay": "30s",
               "filter": {
                   "evaltype": 1,
                   "conditions": [
                       {
                           "macro": "{#MACRO1}",
                           "value": "@regex1"
                       },
                       {
                           "macro": "{#MACRO2}",
                           "value": "@regex2",
                           "operator": "9"
                       },
                       {
                           "macro": "{#MACRO3}",
                           "value": "",
                           "operator": "12"
                       },
                       {
                           "macro": "{#MACRO4}",
                           "value": "",
                           "operator": "13"
                       }
                   ]
               }
           },
           "auth": "038e1d7b1735c6a5436ee9eae095879e",
           "id": 1
       }

Réponse :

{
           "jsonrpc": "2.0",
           "result": {
               "itemids": [
                   "27665"
               ]
           },
           "id": 1
       }

Création d'une règle LLD avec des chemins de macro

Requête:

{
           "jsonrpc": "2.0",
           "method": "discoveryrule.create",
           "params": {
               "name": "LLD rule with LLD macro paths",
               "key_": "lld",
               "hostid": "10116",
               "type": "0",
               "interfaceid": "13",
               "delay": "30s",
               "lld_macro_paths": [
                   {
                       "lld_macro": "{#MACRO1}",
                       "path": "$.path.1"
                   },
                   {
                       "lld_macro": "{#MACRO2}",
                       "path": "$.path.2"
                   }
               ]
           },
           "auth": "038e1d7b1735c6a5436ee9eae095879e",
           "id": 1
       }

Réponse :

{
           "jsonrpc": "2.0",
           "result": {
               "itemids": [
                   "27665"
               ]
           },
           "id": 1
       }

Utilisation d'un filtre d'expression personnalisé

Créer une règle de découverte bas niveau avec un filtre qui utilisera une expression personnalisée pour évaluer les conditions. La règle doit découvrir uniquement les objets dont la macro "{#MACRO1}" correspond à l'expression régulière "regex1" et "regex2", et la valeur de "{#MACRO2}" correspond à "regex3" ou "regex4". Les ID de formule "A", "B", "C" et "D" ont été choisis arbitrairement.

Requête :

{
           "jsonrpc": "2.0",
           "method": "discoveryrule.create",
           "params": {
               "name": "Filtered LLD rule",
               "key_": "lld",
               "hostid": "10116",
               "type": "0",
               "interfaceid": "13",
               "delay": "30s",
               "filter": {
                   "evaltype": 3,
                   "formula": "(A and B) and (C or D)",
                   "conditions": [
                       {
                           "macro": "{#MACRO1}",
                           "value": "@regex1",
                           "formulaid": "A"
                       },
                       {
                           "macro": "{#MACRO1}",
                           "value": "@regex2",
                           "formulaid": "B"
                       },
                       {
                           "macro": "{#MACRO2}",
                           "value": "@regex3",
                           "formulaid": "C"
                       },
                       {
                           "macro": "{#MACRO2}",
                           "value": "@regex4",
                           "formulaid": "D"
                       }
                   ]
               }
           },
           "auth": "038e1d7b1735c6a5436ee9eae095879e",
           "id": 1
       }

Réponse :

{
           "jsonrpc": "2.0",
           "result": {
               "itemids": [
                   "27665"
               ]
           },
           "id": 1
       }

Utilisation de champs de requête et d'en-têtes personnalisés

Créer une règle de découverte bas niveau avec des champs de requête et des en-têtes personnalisés.

Requête :

{
           "jsonrpc": "2.0",
           "method": "discoveryrule.create",
           "params": {
               "hostid": "10257",
               "interfaceid": "5",
               "type": "19",
               "name": "API HTTP agent",
               "key_": "api_discovery_rule",
               "value_type": "3",
               "delay": "5s",
               "url": "http://127.0.0.1?discoverer.php",
               "query_fields": [
                   {
                       "mode": "json"
                   },
                   {
                       "elements":"2"
                   }
               ],
               "headers": {
                   "X-Type": "api",
                   "Authorization": "Bearer mF_A.B5f-2.1JcM"
               },
               "allow_traps": "1",
               "trapper_hosts": "127.0.0.1",
               "id": 35,
               "auth": "d678e0b85688ce578ff061bd29a20d3b",
           }
       }

Réponse :

{
           "jsonrpc": "2.0",
           "result": {
               "itemids": [
                   "28336"
               ]
           },
           "id": 35
       }

Création d'une règle LLD avec prétraitement

Requête :

{
           "jsonrpc": "2.0",
           "method": "discoveryrule.create",
           "params": {
               "name": "Discovery rule with preprocessing",
               "key_": "lld.with.preprocessing",
               "hostid": "10001",
               "ruleid": "27665",
               "type": 0,
               "value_type": 3,
               "delay": "60s",
               "interfaceid": "1155",
               "preprocessing": [
                   {
                       "type": "20",
                       "params": "20",
                       "error_handler": "0",
                       "error_handler_params": ""
                   }
               ]
           },
           "auth": "038e1d7b1735c6a5436ee9eae095879e",
           "id": 1
       }

Réponse :

{
           "jsonrpc": "2.0",
           "result": {
               "itemids": [
                   "44211"
               ]
           },
           "id": 1
       }

Création d'une règle LLD avec remplacements

Requête :

{
           "jsonrpc": "2.0",
           "method": "discoveryrule.create",
           "params": {
               "name": "Discover database host",
               "key_": "lld.with.overrides",
               "hostid": "10001",
               "type": 0,
               "value_type": 3,
               "delay": "60s",
               "interfaceid": "1155",
               "overrides": [
                   {
                       "name": "Discover MySQL host",
                       "step": "1",
                       "stop": "1",
                       "filter": {
                           "evaltype": "2",
                           "conditions": [
                               {
                                   "macro": "{#UNIT.NAME}",
                                   "operator": "8",
                                   "value": "^mysqld\\.service$"
                               },
                               {
                                   "macro": "{#UNIT.NAME}",
                                   "operator": "8",
                                   "value": "^mariadb\\.service$"
                               }
                           ]
                       },
                       "operations": [
                           {
                               "operationobject": "3",
                               "operator": "2",
                               "value": "Database host",
                               "opstatus": {
                                   "status": "0"
                               },
                               "optemplate": [
                                   {
                                       "templateid": "10170"
                                   }
                               ],
                               "optag": [
                                   {
                                       "tag": "Database",
                                       "value": "MySQL"
                                   }
                               ]
                           }
                       ]
                   },
                   {
                       "name": "Discover PostgreSQL host",
                       "step": "2",
                       "stop": "1",
                       "filter": {
                           "evaltype": "0",
                           "conditions": [
                               {
                                   "macro": "{#UNIT.NAME}",
                                   "operator": "8",
                                   "value": "^postgresql\\.service$"
                               }
                           ]
                       },
                       "operations": [
                           {
                               "operationobject": "3",
                               "operator": "2",
                               "value": "Database host",
                               "opstatus": {
                                   "status": "0"
                               },
                               "optemplate": [
                                   {
                                       "templateid": "10263"
                                   }
                               ],
                               "optag": [
                                   {
                                       "tag": "Database",
                                       "value": "PostgreSQL"
                                   }
                               ]
                           }
                       ]
                   }
               ]
           },
           "auth": "038e1d7b1735c6a5436ee9eae095879e",
           "id": 1
       }

Réponse :

{
           "jsonrpc": "2.0",
           "result": {
               "itemids": [
                   "30980"
               ]
           },
           "id": 1
       }

Création d'une règle LLD script

Créer une collecte de données simple à l'aide d'une règle LLD script.

Requête :

{
           "jsonrpc": "2.0",
           "method": "discoveryrule.create",
           "params": {
               "name": "Script example",
               "key_": "custom.script.lldrule",
               "hostid": "12345",
               "type": 21,
               "value_type": 4,
               "params": "var request = new CurlHttpRequest();\nreturn request.Post(\"https://postman-echo.com/post\", JSON.parse(value));",
               "parameters": [{
                   "name": "host",
                   "value": "{HOST.CONN}"
               }],
               "timeout": "6s",
               "delay": "30s"
           },
           "auth": "038e1d7b1735c6a5436ee9eae095879e",
           "id": 2
       }

Réponse :

{
           "jsonrpc": "2.0",
           "result": {
               "itemids": [
                   "23865"
               ]
           },
           "id": 3
       }

Voir également

Source

CDiscoveryRule::create() dans ui/include/classes/api/services/CDiscoveryRule.php.