[comment]: # translation:outdated

[comment]: # aside:3

[comment]: # ({d1748010-ebcec779})
# Zabbix API verwenden

[zabbix\_utils](https://github.com/zabbix/python-zabbix-utils/blob/main/README.md) ermöglicht Ihnen die Verwendung der [Zabbix API](/manual/api) zur Verwaltung von Zabbix-Objekten, einschließlich des Erstellens von Hosts, des Aktualisierens von Datenpunkten, des Abrufens von Ereignissen und mehr.

API-Anfragen können im synchronen oder asynchronen Modus ausgeführt werden:

-   Im synchronen Modus sendet Ihr Python-Skript eine Anfrage und wartet auf eine Antwort, bevor es fortfährt. Dies eignet sich für einfache, sequenzielle und vorhersehbare Vorgänge.
-   Im asynchronen Modus sendet das Skript Anfragen, ohne auf jede einzelne Antwort zu warten, sodass andere Vorgänge parallel fortgesetzt werden können; dies ist effizienter bei langsamen Anfragen oder großen Datenmengen.

Die Beispiele auf dieser Seite konzentrieren sich auf den synchronen Modus, obwohl der [asynchrone Modus](#asynchronous-mode) ähnlichen Mustern folgt.
Zusätzliche Beispiele sind im GitHub-Repository [zabbix_utils](https://github.com/zabbix/python-zabbix-utils/tree/main/examples) verfügbar.

[comment]: # ({/d1748010-ebcec779})

[comment]: # ({3d27f26b-8304e91c})
#### Import

Um zabbix\_utils für die Arbeit mit der Zabbix-API zu verwenden, importieren Sie die Klasse `ZabbixAPI` in Ihr Skript:

```python
from zabbix_utils import ZabbixAPI
```

::: noteclassic
Wenn Sie bereits eine [Python-Bibliothek aus der Community](https://www.zabbix.com/integrations/python) verwenden, können Sie diesen Import in der Regel durch `ZabbixAPI` aus zabbix\_utils ersetzen.
:::

[comment]: # ({/3d27f26b-8304e91c})

[comment]: # ({55f43c13-2fe24fc5})
#### Anmelden

Bevor Sie API-Anfragen stellen, müssen Sie eine `ZabbixAPI`-Instanz erstellen und sich bei der Zabbix API anmelden.

Wählen Sie die Methode, die am besten dazu passt, wie Sie Anmeldedaten verwalten.
Sie können Ihren Benutzernamen und Ihr Passwort oder [API-Tokens](/manual/web_interface/frontend_sections/users/api_tokens) verwenden.

[comment]: # ({/55f43c13-2fe24fc5})

[comment]: # ({eecbd507-f5ed9f85})
##### Während der Initialisierung

Beim Erstellen einer `ZabbixAPI`-Instanz können Sie die URL der Zabbix-Weboberfläche und Ihre Zugangsdaten auf einmal angeben:

```python
# Benutzername und Passwort:
api = ZabbixAPI(url="127.0.0.1/zabbix", user="Admin", password="zabbix")

# API-Token:
api = ZabbixAPI(url="127.0.0.1/zabbix", token="your_api_token")
```

Wenn Sie Verbindungsparameter lieber gruppieren möchten, können Sie sie als Python-Dictionary übergeben und mithilfe der Python-Syntax für Schlüsselwortargumente entpacken:

```python
ZABBIX_AUTH = {
    "url": "127.0.0.1/zabbix",
    "user": "Admin",
    "password": "zabbix"
}

api = ZabbixAPI(**ZABBIX_AUTH)
```

[comment]: # ({/eecbd507-f5ed9f85})

[comment]: # ({5cb46e5e-3bf35a85})
##### Verwendung von `login()`

Sie können zunächst eine `ZabbixAPI`-Instanz nur mit der URL der Zabbix-Weboberfläche erstellen und später die Methode `login()` mit Ihren Zugangsdaten verwenden:

```python
# Benutzername und Passwort:
api = ZabbixAPI(url="127.0.0.1/zabbix")
api.login(user="Admin", password="zabbix")

# API-Token:
api = ZabbixAPI(url="127.0.0.1/zabbix")
api.login(token="your_api_token")
```

[comment]: # ({/5cb46e5e-3bf35a85})

[comment]: # ({ff280370-a8fe2b33})
##### Verwendung von Umgebungsvariablen

Sie können Ihre Zugangsdaten zunächst als Umgebungsvariablen speichern, zum Beispiel über ein Terminal:

```bash
# Benutzername und Passwort:
export ZABBIX_USER="Admin"
export ZABBIX_PASSWORD="zabbix"

# Token:
export ZABBIX_TOKEN="your_api_token"
```

Wenn Sie dann Ihr Skript aus derselben Terminal-Sitzung starten, benötigt die `ZabbixAPI`-Instanz im Skript nur die URL der Zabbix-Weboberfläche:

```python
api = ZabbixAPI(url="127.0.0.1/zabbix")
```

Sie können die URL auch in einer Umgebungsvariablen speichern:

```bash
# Benutzername und Passwort:
export ZABBIX_USER="Admin"
export ZABBIX_PASSWORD="zabbix"
export ZABBIX_URL="https://127.0.0.1/zabbix"

# Token:
export ZABBIX_TOKEN="your_api_token"
export ZABBIX_URL="https://127.0.0.1/zabbix"
```

Wenn URL und Zugangsdaten vollständig als Umgebungsvariablen gesetzt sind, benötigt die `ZabbixAPI`-Instanz im Skript überhaupt keine Argumente:

```python
api = ZabbixAPI()
```

[comment]: # ({/ff280370-a8fe2b33})

[comment]: # ({b539ed93-326ac077})
#### Abmelden

Wenn Sie sich mit einem Benutzernamen und Passwort angemeldet haben, rufen Sie nach Abschluss Ihrer API-Operationen die Methode `logout()` auf:

```python
from zabbix_utils import ZabbixAPI

api = ZabbixAPI(url="127.0.0.1/zabbix")
api.login(user="Admin", password="zabbix")

# API-Aktionen kommen hier hin

api.logout()
```

::: noteclassic
Beim Verwenden von API-Tokens ist das Aufrufen der Methode `logout()` nicht erforderlich.
:::

[comment]: # ({/b539ed93-326ac077})

[comment]: # ({a94d5334-e970d222})
#### API-Anfragen

Nachdem Sie sich angemeldet haben, können Sie beliebige API-Anfragen stellen, indem Sie Methoden aufrufen, die in der Zabbix-API-[Methodenreferenz](/manual/api/reference) beschrieben sind.

API-Methoden werden im folgenden Format aufgerufen:

```python
api_instance.zabbix_object.method(parameters)
```

::: noteclassic
Einige Methoden- oder Objektnamen der Zabbix-API verwenden Wörter, die in Python reservierte Schlüsselwörter sind (z. B. `import`).
Um Python-Fehler zu vermeiden, fügen Sie beim Verwenden in Python einen Unterstrich an den Methoden- oder Objektnamen an (z. B. `api.configuration.import_`).
:::

Zum Beispiel, um mit [`host.get`](/manual/api/reference/host/get) eine Liste von Hosts anzuzeigen:

```python
# 1. Import ZabbixAPI from zabbix_utils:
from zabbix_utils import ZabbixAPI

# 2. Create the ZabbixAPI instance and log in:
api = ZabbixAPI(url="127.0.0.1/zabbix")
api.login(user="Admin", password="zabbix")

# 3. Retrieve hosts matching a filter:
hosts = api.host.get(
    filter={
        "host": [
            "Zabbix server",
            "Linux server"
        ]
    }
)

# 4. Iterate over returned hosts and print each host's details:
for host in hosts:
    print(host)

# 5. Log out from the API to close the session:
api.logout()
```

[comment]: # ({/a94d5334-e970d222})

[comment]: # ({7b3e3f97-0e327592})
##### Asynchroner Modus

Der asynchrone Modus ermöglicht es Ihrem Skript, API-Anfragen zu senden, ohne auf den Abschluss jeder einzelnen Anfrage zu warten.
Dadurch kann Ihr Skript effizienter werden, wenn es viele API-Anfragen ausführen muss oder wenn einige Anfragen lange dauern.

Bei der Verwendung des asynchronen Modus gibt es im Vergleich zum synchronen Modus wichtige Unterschiede:

-   Importieren Sie das Python-Modul `asyncio` (zuvor müssen Sie die erforderlichen Abhängigkeiten [installieren](/devel/python/install)).
-   Importieren Sie `AsyncZabbixAPI` anstelle von `ZabbixAPI`.
-   Schreiben Sie Ihren Code innerhalb einer `async`-Funktion.
-   Verwenden Sie `await` beim Aufruf von API-Methoden, einschließlich `login()` und `logout()`.

::: noteimportant
Beim Erstellen einer `AsyncZabbixAPI`-Instanz können Sie sich nicht [während der Initialisierung](#during-initialization) anmelden.
:::

Zum Beispiel, um im asynchronen Modus mit [`host.get`](/manual/api/reference/host/get) eine Liste von Hosts anzuzeigen:

```python
# 1. Importieren Sie asyncio für den asynchronen Modus und AsyncZabbixAPI aus zabbix_utils:
import asyncio
from zabbix_utils import AsyncZabbixAPI

# 2. Definieren Sie die Haupt-async-Funktion, in der alle API-Operationen ausgeführt werden:
async def main():

    # 3. Erstellen Sie eine AsyncZabbixAPI-Instanz und melden Sie sich an (await ist erforderlich):
    api = AsyncZabbixAPI(url="127.0.0.1")
    await api.login(user="User", password="zabbix")

    # 4. Rufen Sie Hosts ab, die einem Filter entsprechen (await ist erforderlich):
    hosts = await api.host.get(
        filter={
            "host": [
                "Zabbix server",
                "Linux server"
            ]
        }
    )

    # 5. Iterieren Sie über die zurückgegebenen Hosts und geben Sie die Details jedes Hosts aus:
    for host in hosts:
        print(host)

    # 6. Melden Sie sich von der API ab, um die Sitzung zu schließen (await ist erforderlich):
    await api.logout()

# 7. Führen Sie die async-Hauptfunktion main() mit der Ereignisschleife von asyncio aus:
asyncio.run(main())
```

[comment]: # ({/7b3e3f97-0e327592})

[comment]: # ({57854c72-5dc3bb95})
#### Beispiele

Die folgenden Beispiele zeigen häufige Aufgaben mit der Zabbix-API unter Verwendung der Bibliothek zabbix\_utils.

Weitere Beispiele sind im Verzeichnis `examples` des GitHub-Repositorys [zabbix_utils](https://github.com/zabbix/python-zabbix-utils) verfügbar.

[comment]: # ({/57854c72-5dc3bb95})