[comment]: # translation:outdated

[comment]: # aside:5

[comment]: # ({f2a0429f-ebcec779})
# Sūtīt datus uz Zabbix serveri vai starpniekserveri

[zabbix\_utils](https://github.com/zabbix/python-zabbix-utils/blob/main/README.md) ļauj sūtīt vienumu vērtības uz [trapper vienumu](/manual/config/items/itemtypes/trapper) Zabbix serverī vai starpniekserverī (līdzīgi kā [Zabbix sender](/manual/concepts/sender)).

Varat sūtīt vienu vērtību, vairākas vērtības vai pat mērķēt uz vairākiem Zabbix klasteriem.

Datus var sūtīt sinhronā vai asinhronā režīmā:

-   Sinhronajā režīmā jūsu Python skripts nosūta vērtības un pirms turpināšanas gaida atbildi; tas ir piemērots vienkāršām, secīgām un paredzamām darbībām.
-   Asinhronajā režīmā skripts nosūta vērtības, negaidot katru atbildi, tādējādi ļaujot citām darbībām turpināties paralēli; tas ir efektīvāk lēniem pieprasījumiem vai lielām datu paketēm.

Šīs lapas piemēri ir vērsti uz sinhrono režīmu, lai gan [asinhronais režīms](#asynchronous-mode) izmanto līdzīgus principus.
Papildu piemēri ir pieejami GitHub repozitorijā [zabbix_utils](https://github.com/zabbix/python-zabbix-utils/tree/main/examples).

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

[comment]: # ({33a3626c-2b58225a})
#### Importēšana

Lai izmantotu zabbix\_utils vienumu vērtību sūtīšanai, importējiet savā skriptā `Sender` klasi:

```python
from zabbix_utils import Sender
```

Lai sūtītu vairākas vērtības, varat importēt arī `ItemValue` klasi:

```python
from zabbix_utils import Sender, ItemValue
```

[comment]: # ({/33a3626c-2b58225a})

[comment]: # ({6215a382-248fa427})
#### Nosūtīt vienu vērtību

Lai nosūtītu vienuma vērtību:

1. Izveidojiet `Sender` instanci, norādot sava Zabbix servera vai starpniekservera IP adresi un portu.
2. Izsauciet `send_value()` metodi `Sender` instancē, izmantojot šādu formātu:

```python
sender_instance.send_value('host', 'item.key', 'value', optional_timestamp, optional_nanoseconds)
```

Piemēram, lai nosūtītu `1` uz `service.status` trapper vienumu hostā `Linux server`:

```python
sender = Sender(server='127.0.0.1', port=10051)
response = sender.send_value('Linux server', 'service.status', 1)
```

[comment]: # ({/6215a382-248fa427})

[comment]: # ({ba5ab006-8c41d6ba})
##### Noklusējuma IP adreses neizmantošana

Ja serverim, kurā darbojas jūsu skripts, ir vairākas IP adreses, varat norādīt `source_ip`, ko `Sender` izmantos, sūtot vērtības uz Zabbix serveri vai starpniekserveri:

```python
sender = Sender(
    server='127.0.0.1',
    port=10051,
    source_ip='10.10.7.1'
)
```

[comment]: # ({/ba5ab006-8c41d6ba})

[comment]: # ({bff53bf5-de824c12})
##### Timeout izmantošana

Jūs varat iestatīt atbildes `timeout` parametrā `Sender`, lai noteiktu, cik ilgi jūsu skriptam jāgaida atbilde no Zabbix servera vai starpniekservera, pirms pārtraukt gaidīšanu:

```python
sender = Sender(
    server='127.0.0.1',
    port=10051,
    timeout=30
)
```

[comment]: # ({/bff53bf5-de824c12})

[comment]: # ({04ae72fb-62dd1793})
##### Aģenta konfigurācijas faila izmantošana

Varat ļaut zabbix\_utils nolasīt [`Server`](/manual/appendix/config/zabbix_agentd#server) vai [`ServerActive`](/manual/appendix/config/zabbix_agentd#serveractive) parametrus no lokāla Zabbix aģenta vai aģenta 2 konfigurācijas faila.
Šādos gadījumos, veidojot `Sender` instanci, nav nepieciešams norādīt savienojuma parametrus:

```python
sender = Sender(
    use_config=True,
    config_path='/etc/zabbix/zabbix_agent2.conf'
)
```

::: noteimportant
Ja `ServerActive` satur vienu vai vairākus Zabbix klasterus ar vairākām servera instancēm, `Sender` nosūta datus uz pirmo pieejamo serveri katrā klasterī.
Ja `ServerActive` nav iestatīts, tiek izmantota adrese no `Server` ar noklusējuma portu (10051).
:::

[comment]: # ({/04ae72fb-62dd1793})

[comment]: # ({f95d47a7-a8b30296})
##### Šifrēšanas izmantošana

`Sender` neietver iebūvētu šifrēšanas atbalstu, taču to var nodrošināt, izveidojot ietvaru, izmantojot trešo pušu bibliotēkas:

```python
def psk_wrapper(sock, tls):
    # ...
    # TLS PSK ietvara ieviešana ligzdai
    # ...

sender = Sender(
    server='127.0.0.1',
    port=10051,
    socket_wrapper=psk_wrapper
)
```

[comment]: # ({/f95d47a7-a8b30296})

[comment]: # ({e0a8b11b-b6a3d94d})
##### Atbilde vienai vērtībai

Atbildi, ko atgriež Zabbix serveris vai starpniekserveris, apstrādā bibliotēka un atgriež kā `TrapperResponse` objektu:

```python
print(response)
# {"processed": 1, "failed": 0, "total": 1, "time": "0.000123", "chunk": 1}

print(response.processed)
# 1

print(response.failed)
# 0

print(response.total)
# 1
```

[comment]: # ({/e0a8b11b-b6a3d94d})

[comment]: # ({d5faab4e-9eeea215})
##### Asinhronais režīms

Asinhronais režīms ļauj jūsu Python skriptam sūtīt vērtības, negaidot atbildi no Zabbix serveris vai starpniekserveris.
Tas var padarīt jūsu skriptu efektīvāku, ja tam nepieciešams nosūtīt daudzas vērtības vai ja dažu vērtību nosūtīšana aizņem ilgu laiku.

Izmantojot asinhrono režīmu, salīdzinājumā ar sinhrono režīmu ir dažas būtiskas atšķirības:

-   Importējiet Python `asyncio` moduli (vispirms jā[instalē](/devel/python/install) nepieciešamās atkarības).
-   Importējiet `AsyncSender` `Sender` vietā.
-   Rakstiet kodu `async` funkcijā.
-   Izmantojiet `await`, izsaucot `send_value()` metodi.

Piemēram, lai, izmantojot asinhrono režīmu, nosūtītu vienu vērtību:

```python
# 1. Import asyncio for asynchronous mode, and AsyncSender from zabbix_utils:
import asyncio
from zabbix_utils import AsyncSender

# 2. Define the main async function where all data sending operations (must await) will be executed:
async def main():
    sender = AsyncSender(server='127.0.0.1', port=10051)
    response = await sender.send_value('Linux server', 'service.status', 1)

    # 3. Print the response returned by Zabbix server or proxy:
    print(response)

# 4. Run the async main() function using asyncio's event loop:
asyncio.run(main())
```

[comment]: # ({/d5faab4e-9eeea215})

[comment]: # ({b845706b-34e0ff6d})
#### Vairāku vērtību nosūtīšana

Lai nosūtītu vairākas vērtības:

1. Sagatavojiet `ItemValue` objektu masīvu, kur katrs izmanto to pašu formātu kā metode [`send_value()`](#send-single-value).
2. Izveidojiet `Sender` instanci, norādot sava Zabbix servera vai starpniekservera IP adresi un portu.
3. Izsauciet metodi `send()` (metodes `send_value()` vietā) `Sender` instancē, norādot objektu masīvu ar nosūtāmajām vērtībām.

Piemēram, lai nosūtītu piecas vērtības uz dažādiem hostiem:

```python
items = [
    ItemValue('server-de', 'service.status', 'up', 1770887205, 100),
    ItemValue('server-fr', 'service.status', 'up', 1770887205, 100),
    ItemValue('server-uk', 'service.status', 'up', 1770887205, 100),
    ItemValue('server-nl', 'service.status', 'up', 1770887205, 100),
    ItemValue('server-pl', 'service.status', 'up', 1770887205, 100),
]

sender = Sender(server='127.0.0.1', port=10051)
response = sender.send(items)
```

[comment]: # ({/b845706b-34e0ff6d})

[comment]: # ({c0410a6d-5848e96f})
##### Pielāgota gabala lieluma izmantošana

Ja jums ir jānosūta vairāk vērtību, nekā trapera vienums var pieņemt vienā pieprasījumā, varat tās sadalīt gabalos.

Pēc noklusējuma gabala lielums ir 250 vērtības.
To var mainīt, iestatot parametru `chunk_size`, veidojot `Sender` instanci.

Piemēram, lai nosūtītu piecas vērtības trīs gabalos (2-2-1), iestatiet parametru `chunk_size` uz `2`:

```python
items = [
    ItemValue('server-de', 'service.status', 'up'),
    ItemValue('server-fr', 'service.status', 'up'),
    ItemValue('server-uk', 'service.status', 'up'),
    ItemValue('server-nl', 'service.status', 'up'),
    ItemValue('server-pl', 'service.status', 'up'),
]

sender = Sender(server='127.0.0.1', port=10051, chunk_size=2)
response = sender.send(items)
```

[comment]: # ({/c0410a6d-5848e96f})

[comment]: # ({b06724dd-5a0b5783})
##### Sūtīt vērtības uz vairākām Zabbix kopām

Lai sūtītu vērtības uz vairākām Zabbix kopām:

1. Sagatavojiet Zabbix kopu masīvu. Ja kopai ir vairāki mezgli, vērtība tiks nosūtīta uz katras kopas pirmo **pieejamo** mezglu.
2. Izveidojiet `Sender`, norādot savu Zabbix kopu masīvu.
3. Izsauciet `send_value()` metodi `Sender` instancei, izmantojot to pašu formātu kā [`send_value()`](#send-single-value) metodei.

Piemēram, lai nosūtītu vērtību uz pirmo pieejamo mezglu katrā kopā:

```python
zabbix_clusters = [
    ['zabbix.cluster1.node1', 'zabbix.cluster1.node2:10051'],
    ['zabbix.cluster2.node1:10051', 'zabbix.cluster2.node2', 'zabbix.cluster2.node3']
]

sender = Sender(clusters=zabbix_clusters)
response = sender.send_value('Linux server', 'service.status', 1)
```

[comment]: # ({/b06724dd-5a0b5783})

[comment]: # ({2c3cc8b2-d7964287})
##### Atbilde vairāku vērtību gadījumā

Pēc noklusējuma `Sender` atgriež apkopotu rezultātu par vērtību nosūtīšanu visos hostos vai klasteros:

```python
print(response)
# {"processed": 2, "failed": 0, "total": 2, "time": "0.000108", "chunk": 2}
```

Ja jums nepieciešama detalizētāka informācija, varat pārbaudīt rezultātus katram klasterim un katram gabalam, izmantojot atribūtu `response.details`:

```python
print(response)
# {"processed": 2, "failed": 0, "total": 2, "time": "0.000108", "chunk": 2}

if response.failed == 0:
    print(f"Vērtība veiksmīgi nosūtīta {response.time}")
else:
    print(response.details)
    # {
    #     127.0.0.1:10051: [
    #         {
    #             "processed": 1,
    #             "failed": 0,
    #             "total": 1,
    #             "time": "0.000051",
    #             "chunk": 1
    #         }
    #     ],
    #     zabbix.example.local:10051: [
    #         {
    #             "processed": 1,
    #             "failed": 0,
    #             "total": 1,
    #             "time": "0.000057",
    #             "chunk": 1
    #         }
    #     ]
    # }

    for node, chunks in response.details.items():
        for resp in chunks:
            print(f"Apstrādāti {resp.processed} no {resp.total} mezglā {node.address}:{node.port}")
            # Apstrādāti 1 no 1 mezglā 127.0.0.1:10051
            # Apstrādāti 1 no 1 mezglā zabbix.example.local:10051
```

[comment]: # ({/2c3cc8b2-d7964287})