Processus

Vue d'ensemble

Zabbix se compose de plusieurs processus qui travaillent ensemble pour surveiller les systèmes et envoyer des notifications. Chaque processus a un rôle spécifique dans l'infrastructure de surveillance.

Processus principaux

• Serveur - le processus central qui effectue le polling et la capture des données, calcule les déclencheurs et envoie des notifications aux utilisateurs.
• agent - collecte des données à partir des hôtes surveillés.
• Agent 2 - un agent de nouvelle génération avec une architecture de plugins et des capacités améliorées.
• proxy - collecte les données de supervision des périphériques surveillés et envoie les informations au serveur Zabbix.
• Java gateway - permet la supervision des applications Java.

En-tête

L'en-tête est présent dans tous les messages de requête et de réponse entre les composants Zabbix. Il est nécessaire pour déterminer la longueur du message, s'il est compressé ou non, et s'il s'agit ou non d'un paquet volumineux.

Le protocole de communication Zabbix impose une limite de taille de paquet de 1 Go par connexion. La limite de 1 Go s'applique à la fois à la longueur des données du paquet reçu et à la longueur des données non compressées.

Lors de l'envoi de la configuration à un proxy Zabbix, la limite de taille de paquet est portée à 4 Go afin de permettre la synchronisation de configurations volumineuses. Lorsque la longueur des données avant compression dépasse 4 Go, le serveur Zabbix commence automatiquement à utiliser le format de paquet volumineux (indicateur 0x04), ce qui porte la limite de taille de paquet à 16 Go.

Notez que, bien qu'un format de paquet volumineux puisse être utilisé pour l'envoi de n'importe quelles données, à l'heure actuelle seul le synchroniseur de configuration du proxy Zabbix peut traiter des paquets supérieurs à 1 Go.

Structure de l'en-tête

L'en-tête se compose de quatre champs. Tous les nombres dans l'en-tête sont formatés en little-endian.

Exemples d'en-tête

Voici quelques extraits de code montrant comment ajouter l'en-tête du protocole Zabbix aux données que vous souhaitez envoyer afin d'obtenir le paquet à envoyer à Zabbix pour qu'il soit interprété correctement. Ces extraits de code supposent que les données ne dépassent pas 1 Go, donc le format de grand paquet n'est pas utilisé.

Python

packet = b"ZBXD\1" + struct.pack("<II", len(data), 0) + data

ou

def zbx_create_header(plain_data_size, compressed_data_size=None):
    protocol = b"ZBXD"
    flags = 0x01
    if compressed_data_size is None:
        datalen = plain_data_size
        reserved = 0
    else:
        flags |= 0x02
        datalen = compressed_data_size
        reserved = plain_data_size
    return protocol + struct.pack("<BII", flags, datalen, reserved)

packet = zbx_create_header(len(data)) + data

Perl

my $packet = "ZBXD\1" . pack("(II)<", length($data), 0) . $data;

ou

sub zbx_create_header($;$)
{
    my $plain_data_size = shift;
    my $compressed_data_size = shift;

    my $protocol = "ZBXD";
    my $flags = 0x01;
    my $datalen;
    my $reserved;

    if (!defined($compressed_data_size))
    {
        $datalen = $plain_data_size;
        $reserved = 0;
    }
    else
    {
        $flags |= 0x02;
        $datalen = $compressed_data_size;
        $reserved = $plain_data_size;
    }

    return $protocol . chr($flags) . pack("(II)<", $datalen, $reserved);
}

my $packet = zbx_create_header(length($data)) . $data;

PHP

$packet = "ZBXD\1" . pack("VV", strlen($data), 0) . $data;

ou

function zbx_create_header($plain_data_size, $compressed_data_size = null)
{
    $protocol = "ZBXD";
    $flags = 0x01;
    if (is_null($compressed_data_size))
    {
        $datalen = $plain_data_size;
        $reserved = 0;
    }
    else
    {
        $flags |= 0x02;
        $datalen = $compressed_data_size;
        $reserved = $plain_data_size;
    }
    return $protocol . chr($flags) . pack("VV", $datalen, $reserved);
}

$packet = zbx_create_header(strlen($data)) . $data;

Bash

datalen=$(printf "%08x" ${#data})
datalen="\\x${datalen:6:2}\\x${datalen:4:2}\\x${datalen:2:2}\\x${datalen:0:2}"
printf "ZBXD\1${datalen}\0\0\0\0%s" "$data"