[comment]: # translation:outdated

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

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

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

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

Mit dieser Methode können neue LLD-Regeln erstellt werden.

::: noteclassic
Diese Methode ist nur für die Benutzertypen *Admin* und *Super admin*
verfügbar. Die Berechtigungen zum Aufrufen der Methode können in den
Einstellungen der Benutzerrolle entzogen werden. Weitere Informationen
finden Sie unter [Benutzerrollen](/manual/web_interface/frontend_sections/users/user_roles).
:::

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

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

`(object/array)` Zu erstellende LLD-Regeln.

Zusätzlich zu den [standardmäßigen LLD-Regel-Eigenschaften](object#lld-rule)
akzeptiert die Methode die folgenden Parameter.

|Parameter|[Typ](/manual/api/reference_commentary#data-types)|Beschreibung|
|--|--|------|
|filter|object|[LLD-Regelfilter](/manual/api/reference/discoveryrule/object#lld-rule-filter) für die LLD-Regel.|
|preprocessing|object/array|Optionen für die [LLD-Regel-Vorverarbeitung](/manual/api/reference/discoveryrule/object#lld-rule-preprocessing).|
|lld\_macro\_paths|object/array|Optionen für [lld\_macro\_path](/manual/api/reference/discoveryrule/object#lld-macro-path) der LLD-Regel.|
|overrides|object/array|Optionen für [LLD-Regel-Überschreibungen](/manual/api/reference/discoveryrule/object#lld-rule-overrides).|

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

[comment]: # ({08a72633-08a72633})
### Rückgabewerte

`(object)` Gibt ein Objekt zurück, das die IDs der erstellten LLD-Regeln
unter der Eigenschaft `itemids` enthält. Die Reihenfolge der zurückgegebenen IDs entspricht der
Reihenfolge der übergebenen LLD-Regeln.

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

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

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

[comment]: # ({64dbb2a9-c30fe277})
#### Erstellen einer LLD-Regel

Erstellen Sie eine Zabbix-Agent-LLD-Regel, um eingehängte Dateisysteme zu erkennen.
Erkannte Datenpunkte werden alle 30 Sekunden aktualisiert.

[Anfrage](/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
}
```

Antwort:

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

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

[comment]: # ({83891df9-01b95865})
#### Verwenden eines Filters

Erstellen Sie eine LLD-Regel mit einer Reihe von Bedingungen, nach denen die Ergebnisse gefiltert werden.
Die Bedingungen werden mithilfe des logischen Operators „and“
gruppiert.

[Anfrage](/manual/api#performing-requests):

```json
{
    "jsonrpc": "2.0",
    "method": "discoveryrule.create",
    "params": {
        "name": "Gefilterte LLD-Regel",
        "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
}
```

Antwort:

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

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

[comment]: # ({151487a3-a201a7a1})
#### Erstellen einer LLD-Regel mit Makropfaden

[Anfrage](/manual/api#performing-requests):

```json
{
    "jsonrpc": "2.0",
    "method": "discoveryrule.create",
    "params": {
        "name": "LLD-Regel mit LLD-Makropfaden",
        "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
}
```

Antwort:

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

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

[comment]: # ({ee764cc8-32af137e})
#### Verwenden eines benutzerdefinierten Ausdrucksfilters

Erstellen Sie eine LLD-Regel mit einem Filter, der einen benutzerdefinierten Ausdruck zur Auswertung der Bedingungen verwendet. Die LLD-Regel darf nur Objekte erkennen, deren Makrowert "{\#MACRO1}" sowohl dem regulären Ausdruck "regex1" als auch "regex2" entspricht und deren Wert von "{\#MACRO2}" entweder "regex3" oder "regex4" entspricht. Die Formel-IDs "A", "B", "C" und "D" wurden willkürlich gewählt.

[Anfrage](/manual/api#performing-requests):

```json
{
    "jsonrpc": "2.0",
    "method": "discoveryrule.create",
    "params": {
        "name": "Gefilterte LLD-Regel",
        "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
}
```

Antwort:

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

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

[comment]: # ({24e10385-001d915b})
#### Benutzerdefinierte Abfragefelder und Header verwenden

Erstellen Sie eine LLD-Regel mit benutzerdefinierten Abfragefeldern und Headern.

[Anfrage](/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
}
```

Antwort:

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

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

[comment]: # ({183d1530-3e76a4a9})
#### Erstellen einer LLD-Regel mit Vorverarbeitung

[Anfrage](/manual/api#performing-requests):

```json
{
    "jsonrpc": "2.0",
    "method": "discoveryrule.create",
    "params": {
        "name": "Discovery-Regel mit Vorverarbeitung",
        "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
}
```

Antwort:

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

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

[comment]: # ({1326b2e3-f9343aca})
#### Erstellen einer LLD-Regel mit Überschreibungen

[Anfrage](/manual/api#performing-requests):

```json
{
    "jsonrpc": "2.0",
    "method": "discoveryrule.create",
    "params": {
        "name": "Datenbank-Host erkennen",
        "key_": "lld.with.overrides",
        "hostid": "10001",
        "type": 0,
        "delay": "60s",
        "interfaceid": "1155",
        "overrides": [
            {
                "name": "MySQL-Host erkennen",
                "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": "Datenbank-Host",
                        "opstatus": {
                            "status": "0"
                        },
                        "optemplate": [
                            {
                                "templateid": "10170"
                            }
                        ],
                        "optag": [
                            {
                                "tag": "database",
                                "value": "mysql"
                            }
                        ]
                    }
                ]
            },
            {
                "name": "PostgreSQL-Host erkennen",
                "step": "2",
                "stop": "1",
                "filter": {
                    "evaltype": "0",
                    "conditions": [
                        {
                            "macro": "{#UNIT.NAME}",
                            "operator": "8",
                            "value": "^postgresql\\.service$"
                        }
                    ]
                },
                "operations": [
                    {
                        "operationobject": "3",
                        "operator": "2",
                        "value": "Datenbank-Host",
                        "opstatus": {
                            "status": "0"
                        },
                        "optemplate": [
                            {
                                "templateid": "10263"
                            }
                        ],
                        "optag": [
                            {
                                "tag": "database",
                                "value": "postgresql"
                            }
                        ]
                    }
                ]
            }
        ]
    },
    "id": 1
}
```

Antwort:

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

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

[comment]: # ({f1471f8e-c75d7d1e})
#### Skript-LLD-Regel erstellen

Erstellen Sie eine einfache Datenerfassung mit einer Skript-LLD-Regel.

[Anfrage](/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
}
```

Antwort:

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

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

[comment]: # ({464094bf-10111213})
#### LLD-Regel mit einem angegebenen Zeitraum für die Deaktivierung und ohne Löschung erstellen

Erstellen Sie eine LLD-Regel mit einem benutzerdefinierten Zeitraum für die Deaktivierung einer Entität, nachdem
sie nicht mehr erkannt wird, mit der Einstellung, dass sie niemals
gelöscht wird.

[Anfrage](/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
}
```

Antwort:

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

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

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

-   [LLD-Regelfilter](object#lld-rule-filter)
-   [LLD-Makropfade](object#lld-macro-path)
-   [LLD-Regelvorverarbeitung](object#lld-rule-preprocessing)

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

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

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

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