[comment]: # translation:outdated

[comment]: # ({2709706a-2709706a})
# discoveryrule.create

[comment]: # ({/2709706a-2709706a})

[comment]: # ({33446799-78136d05})
### Description

`object discoveryrule.create(object/array lldRules)`

Cette méthode permet de créer de nouvelles règles LLD.

::: noteclassic
Cette méthode est disponible uniquement pour les types d’utilisateur *Admin* et *Super admin*.
Les autorisations d’appel de la méthode peuvent être révoquées dans les paramètres du rôle utilisateur.
Voir [User
roles](/manual/web_interface/frontend_sections/users/user_roles)
pour plus d’informations.
:::

[comment]: # ({/33446799-78136d05})

[comment]: # ({fc1c8a67-1c165cc1})
### Paramètres

`(object/array)` Règles LLD à créer.

En plus des [propriétés standard des règles LLD](object#lld-rule), la
méthode accepte les paramètres suivants.

|Paramètre|[Type](/manual/api/reference_commentary#data-types)|Description|
|--|--|------|
|filter|object|[Filtre de règle LLD](/manual/api/reference/discoveryrule/object#lld-rule-filter) pour la règle LLD.|
|preprocessing|object/array|Options de [prétraitement de règle LLD](/manual/api/reference/discoveryrule/object#lld-rule-preprocessing).|
|lld\_macro\_paths|object/array|Options de [lld\_macro\_path](/manual/api/reference/discoveryrule/object#lld-macro-path) de la règle LLD.|
|overrides|object/array|Options de [surcharges de règle LLD](/manual/api/reference/discoveryrule/object#lld-rule-overrides).|

[comment]: # ({/fc1c8a67-1c165cc1})

[comment]: # ({08a72633-08a72633})
### 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.

[comment]: # ({/08a72633-08a72633})

[comment]: # ({b41637d2-b41637d2})
### Exemples

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

[comment]: # ({64dbb2a9-c30fe277})
#### Création d’une règle LLD

Créez une règle LLD d’agent Zabbix pour découvrir les systèmes de fichiers montés.
Les éléments découverts seront mis à jour toutes les 30 secondes.

[Requête](/manual/api#performing-requests) :

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

Réponse :

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

[comment]: # ({/64dbb2a9-c30fe277})

[comment]: # ({83891df9-01b95865})
#### Utilisation d’un filtre

Créez une règle LLD avec un ensemble de conditions permettant de filtrer les résultats.
Les conditions seront regroupées à l’aide de l’opérateur logique « and ».

[Requête](/manual/api#performing-requests) :

```json
{
    "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"
                }
            ]
        }
    },
    "id": 1
}
```

Réponse :

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

[comment]: # ({/83891df9-01b95865})

[comment]: # ({151487a3-a201a7a1})
#### Création d'une règle LLD avec des chemins de macro

[Requête](/manual/api#performing-requests):

```json
{
    "jsonrpc": "2.0",
    "method": "discoveryrule.create",
    "params": {
        "name": "Règle LLD avec chemins de macro LLD",
        "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"
            }
        ]
    },
    "id": 1
}
```

Réponse :

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

[comment]: # ({/151487a3-a201a7a1})

[comment]: # ({ee764cc8-32af137e})
#### Utilisation d’un filtre d’expression personnalisé

Créez une règle LLD avec un filtre qui utilisera une expression personnalisée pour
évaluer les conditions. La règle LLD ne doit découvrir que les objets dont la
valeur de macro "{\#MACRO1}" correspond à la fois aux expressions régulières
"regex1" et "regex2", et dont la valeur de "{\#MACRO2}" correspond soit à
"regex3", soit à "regex4". Les identifiants de formule "A", "B", "C" et "D" ont été
choisis arbitrairement.

[Requête](/manual/api#performing-requests):

```json
{
    "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"
                }
            ]
        }
    },
    "id": 1
}
```

Réponse :

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

[comment]: # ({/ee764cc8-32af137e})

[comment]: # ({24e10385-001d915b})
#### Utilisation de champs de requête et d’en-têtes personnalisés

Créez une règle LLD avec des champs de requête et des en-têtes personnalisés.

[Requête](/manual/api#performing-requests):

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

Réponse :

```json
{
    "jsonrpc": "2.0",
    "result": {
        "itemids": [
            "28336"
        ]
    },
    "id": 1
}
```

[comment]: # ({/24e10385-001d915b})

[comment]: # ({183d1530-3e76a4a9})
#### Création d’une règle LLD avec prétraitement

[Requête](/manual/api#performing-requests):

```json
{
    "jsonrpc": "2.0",
    "method": "discoveryrule.create",
    "params": {
        "name": "Règle de découverte avec prétraitement",
        "key_": "lld.with.preprocessing",
        "hostid": "10001",
        "ruleid": "27665",
        "type": 0,
        "delay": "60s",
        "interfaceid": "1155",
        "preprocessing": [
            {
                "type": 20,
                "params": "20",
                "error_handler": 0,
                "error_handler_params": ""
            }
        ]
    },
    "id": 1
}
```

Réponse :

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

[comment]: # ({/183d1530-3e76a4a9})

[comment]: # ({1326b2e3-f9343aca})
#### Création d’une règle LLD avec des remplacements

[Requête](/manual/api#performing-requests):

```json
{
    "jsonrpc": "2.0",
    "method": "discoveryrule.create",
    "params": {
        "name": "Discover database host",
        "key_": "lld.with.overrides",
        "hostid": "10001",
        "type": 0,
        "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"
                            }
                        ]
                    }
                ]
            }
        ]
    },
    "id": 1
}
```

Réponse :

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

[comment]: # ({/1326b2e3-f9343aca})

[comment]: # ({f1471f8e-c75d7d1e})
#### Créer une règle LLD de script

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

[Requête](/manual/api#performing-requests):

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

Réponse :

```json
{
    "jsonrpc": "2.0",
    "result": {
        "itemids": [
            "23865"
        ]
    },
    "id": 1
}
```

[comment]: # ({/f1471f8e-c75d7d1e})

[comment]: # ({464094bf-10111213})
#### Créer une règle LLD avec une période spécifiée pour la désactivation et sans suppression

Créez une règle LLD avec une période personnalisée pour désactiver l’entité après
qu’elle ne soit plus découverte, avec le paramètre indiquant qu’elle ne sera jamais
supprimée.

[Requête](/manual/api#performing-requests):

```json
{
    "jsonrpc": "2.0",
    "method": "discoveryrule.create",
    "params": {
        "name": "lld disable after 1h",
        "key_": "lld.disable",
        "hostid": "10001",
        "type": 2,
        "lifetime_type": 1,
        "enabled_lifetime_type": 0, 
        "enabled_lifetime": "1h"
    },
    "id": 1
}
```

Réponse :

```json
{
    "jsonrpc": "2.0",
    "result": {
        "itemids": [
            "46864"
        ]
    },
    "id": 1
}
```

[comment]: # ({/464094bf-10111213})

[comment]: # ({367cd00f-f40c8a6e})
### Voir aussi

-   [Filtre de règle LLD](object#lld-rule-filter)
-   [Chemins de macro LLD](object#lld-macro-path)
-   [Prétraitement de règle LLD](object#lld-rule-preprocessing)

[comment]: # ({/367cd00f-f40c8a6e})

[comment]: # ({73c4009f-73c4009f})
### Source

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

[comment]: # ({/73c4009f-73c4009f})