Processos do Zabbix

Visão geral

O Zabbix consiste em vários processos que trabalham em conjunto para monitorar sistemas e enviar notificações. Cada processo tem uma função específica na infraestrutura de monitoramento.

Processos principais

• Server - o processo central que realiza o polling e o trapping de dados, calcula triggers e envia notificações aos usuários.
• agent - coleta dados dos hosts monitorados.
• Agent 2 - um agent de nova geração com arquitetura de plugins e recursos aprimorados.
• proxy - coleta dados de monitoramento dos dispositivos monitorados e envia as informações para o server do Zabbix.
• Java gateway - permite o monitoramento de aplicações Java.

Cabeçalho

O cabeçalho está presente em todas as mensagens de solicitação e resposta entre os componentes do Zabbix.
Ele é necessário para determinar o comprimento da mensagem, se ela está comprimida ou não, e se é um pacote grande ou não.

O protocolo de comunicação do Zabbix tem um limite de tamanho de pacote de 1 GB por conexão. O limite de 1 GB
é aplicado tanto ao comprimento dos dados do pacote recebido quanto ao comprimento dos dados descompactados.

Ao enviar a configuração para o Zabbix proxy, o limite de tamanho do pacote é aumentado para 4 GB para permitir
a sincronização de configurações grandes. Quando o comprimento dos dados antes da compressão excede 4 GB, o Zabbix server automaticamente
passa a usar o formato de pacote grande (flag 0x04), o que aumenta o limite de tamanho do pacote para 16 GB.

Observe que, embora o formato de pacote grande possa ser usado para enviar qualquer dado, atualmente apenas o sincronizador de configuração do Zabbix proxy
pode processar pacotes maiores que 1 GB.

Estrutura do cabeçalho

O cabeçalho consiste em quatro campos. Todos os números no cabeçalho são formatados em little-endian.

Exemplos de cabeçalho

Aqui estão alguns trechos de código que mostram como adicionar o cabeçalho do protocolo Zabbix aos dados que você deseja enviar, a fim de obter o pacote que você deve enviar ao Zabbix para que ele seja interpretado corretamente. Esses trechos de código assumem que os dados não são maiores que 1 GB; portanto, o formato de pacote grande não é usado.

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"