12 Discovery aan de hand van ODBC SQL queries

Overzicht

Dit type low-level ontdekking wordt uitgevoerd met behulp van SQL-query's, waarvan de resultaten automatisch worden omgezet in een JSON-object dat geschikt is voor low-level ontdekking.

Item sleutel

SQL-query's worden uitgevoerd met behulp van het itemtype "Database monitor". Daarom zijn de meeste instructies op de pagina over ODBC-bewaking van toepassing om een werkende ontdekkingsregel voor "Database monitor" te verkrijgen.

Er kunnen twee item sleutels worden gebruikt in ontdekkingsregels voor "Database monitor":

• db.odbc.ontdekking[<unieke korte beschrijving>, <dsn>,<verbindingsreeks>] - dit item zet het resultaat van de SQL-query om in een JSON-array, waarbij de kolomnamen uit het query-resultaat worden omgezet in macro-namen voor low-level ontdekking, gekoppeld aan de ontdekte veldwaarden. Deze macro's kunnen worden gebruikt bij het maken van item-, trigger- enz. prototypen. Zie ook: Gebruik van db.odbc.ontdekking.

• db.odbc.ophalen[<unieke korte beschrijving>, <dsn>,<verbindingsreeks>] - dit item zet het resultaat van de SQL-query om in een JSON-array, waarbij de oorspronkelijke kolomnamen uit het query-resultaat worden behouden als veldnaam in JSON, gekoppeld aan de ontdekte waarden. In vergelijking met db.odbc.ontdekking[] maakt dit item geen low-level ontdekking macro's aan in de geretourneerde JSON, daarom is er geen noodzaak om te controleren of de kolomnamen geldige macro-namen kunnen zijn. De macro's voor low-level ontdekking kunnen indien nodig als een aanvullende stap worden gedefinieerd met behulp van de functionaliteit aangepaste LLD macro's, waarbij JSONPath wordt gebruikt om naar de ontdekte waarden in de geretourneerde JSON te wijzen. Zie ook: Gebruik van db.odbc.ophalen.

Gebruik van db.odbc.ontdekking

Als praktisch voorbeeld om te illustreren hoe de SQL-query wordt omgezet in JSON, laten we eens kijken naar de low-level ontdekking van Zabbix-proxies door een ODBC-query uit te voeren op de Zabbix-database. Dit is handig voor het automatisch aanmaken van "zabbix[proxy,<naam>,lastaccess]" interne items om te controleren welke proxies actief zijn.

Laten we beginnen met de configuratie van de ontdekkingsregel:

Alle verplichte invoervelden zijn gemarkeerd met een rode asterisk.

Hier wordt de volgende directe query op de Zabbix-database gebruikt om alle Zabbix-proxies te selecteren, samen met het aantal hosts dat ze monitoren. Het aantal hosts kan bijvoorbeeld worden gebruikt om lege proxies uit te filteren:

mysql> SELECT h1.host, COUNT(h2.host) AS count FROM hosts h1 LEFT JOIN hosts h2 ON h1.hostid = h2.proxy_hostid WHERE h1.status IN (5, 6) GROUP BY h1.host;
       +---------+-------+
       | host    | count |
       +---------+-------+
       | Japan 1 |     5 |
       | Japan 2 |    12 |
       | Latvia  |     3 |
       +---------+-------+
       3 rijen in set (0,01 sec)

Door de interne werking van het item "db.odbc.ontdekking[,{$DSN}]", wordt het resultaat van deze query automatisch omgezet in de volgende JSON:

[
           {
               "{#HOST}": "Japan 1",
               "{#COUNT}": "5"
           },
           {
               "{#HOST}": "Japan 2",
               "{#COUNT}": "12"
           },
           {
               "{#HOST}": "Latvia",
               "{#COUNT}": "3"
           }
       ]

Hierbij worden de kolomnamen macro-namen en worden de geselecteerde rijen de waarden van deze macro's.

$ grep db.odbc.ontdekking /tmp/zabbix_server.log
        ...
        23876:20150114:153410.856 In db_odbc_discovery() query:'SELECT h1.host, COUNT(h2.host) FROM hosts h1 LEFT JOIN hosts h2 ON h1.hostid = h2.proxy_hostid WHERE h1.status IN (5, 6) GROUP BY h1.host;'
        23876:20150114:153410.860 db_odbc_discovery() column[1]:'host'
        23876:20150114:153410.860 db_odbc_discovery() column[2]:'COUNT(h2.host)'
        23876:20150114:153410.860 Einde van db_odbc_discovery():NIETONDERSTEUND
        23876:20150114:153410.860 Item [Zabbix server:db.odbc.discovery[proxies,{$DSN}]] fout: Kan kolomnaam #2 niet converteren naar macro.

Nu we begrijpen hoe een SQL-query wordt omgezet in een JSON-object, kunnen we de {#HOST} macro gebruiken in item-prototypes:

Zodra de ontdekking is uitgevoerd, wordt er voor elke proxy een item aangemaakt:

Gebruik van db.odbc.ophalen

Door gebruik te maken van db.odbc.ophalen[,{$DSN}] en het volgende SQL-voorbeeld:

mysql> SELECT h1.host, COUNT(h2.host) AS count FROM hosts h1 LEFT JOIN hosts h2 ON h1.hostid = h2.proxy_hostid WHERE h1.status IN (5, 6) GROUP BY h1.host;
       +---------+-------+
       | host    | count |
       +---------+-------+
       | Japan 1 |     5 |
       | Japan 2 |    12 |
       | Latvia  |     3 |
       +---------+-------+
       3 rijen in set (0,01 sec)

zal deze JSON worden geretourneerd:

[
           {
               "host": "Japan 1",
               "count": "5"
           },
           {
               "host": "Japan 2",
               "count": "12"
           },
           {
               "host": "Latvia",
               "count": "3"
           }
       ]

Zoals je kunt zien, zijn er geen low-level ontdekking macro's aanwezig. Aangepaste low-level ontdekking macro's kunnen echter worden aangemaakt in het tabblad LLD macro's van een ontdekkingsregel met behulp van JSONPath, bijvoorbeeld:

{#HOST} → $.host

Nu kan deze {#HOST} macro worden gebruikt in item-prototypes: