Monitoramento com Zabbix

O Zabbix é a plataforma de Monitoramento de Redes, Infraestrutura e Serviços (NOC) do CeTI/PMDF. A solução monitora os componentes mais críticos da rede para garantir altos índices de disponibilidade (uptime).

Visão Geral

A plataforma Zabbix centraliza o monitoramento contínuo da infraestrutura corporativa, coletando métricas de performance, disponibilidade e integridade de sistemas.

Arquitetura de Coleta

Para suportar as grandes demandas da infraestrutura corporativa, a arquitetura é distribuída:

Zabbix Server e Web Front-end: Concentra as configurações visuais, acessíveis via Active Directory.
Zabbix Proxies: Espalhados pelas VLANs sem visibilidade direta ao NOC, concentram medições e submetem dados periodicamente ao servidor central para reduzir carga.
Zabbix Agents: Instalados em Máquinas Virtuais (Linux, Windows Server), Controladores de Active Directory e nós do Kubernetes, utilizando variantes ativa e passiva para injeção de coletas.

Dashboards em TVs (NOC)

Múltiplas dashboards dinâmicas do Zabbix são exibidas permanentemente nos televisores físicos da SSSI focados na operação NOC, incluindo:

Status do Kubernetes
Links ISP Principais
Bancos de Dados MSSQL/Oracle

Triggers e Alertas

A SSSI aplica triggers (gatilhos) nas métricas enviadas por agentes ou SNMP para detectar anomalias:

Disco C: com menos de 20% → Alerta Warning (Amarelo)
Queda de processo HTTPD em VMs legadas → Alerta Average (Laranja)
Latência alta nos túneis Checkpoint → Alerta Informational (Azul)

Quando uma trigger é ativada, ações automatizadas ou abertura de incidentes são executadas pela equipe da SSSI.

Guia de Operação: Resolvendo Alertas (Acknowledgment)

Público-alvo: Time de suporte Plantonista/NOC do CeTI.

Quando ocorre um alerta nos telões do Zabbix indicando interrupção de um switch ou máquina, siga estes passos:

Faça login na interface web corporativa do Zabbix.
Acesse Monitoring → Problems.
Selecione o problema piscando e clique em sua descrição ou na coluna Ack.
Escreva um comentário breve indicando que assumiu o chamado (ex.: "Verificando causa de reboot"). Isso marca o acknowledgment, evitando duplicação de diagnóstico por outros plantonistas enquanto o problema persiste.
Inicie tratamentos operacionais na máquina (via SSH ou RDP).
Após resolver o problema, as coletas automáticas removerão o problema ativo (status Resolved). Se for temporário ou falso-positivo, discuta a adequação da trigger com o time de projeto da SSSI no comitê de Gestão de Mudanças.

Dica

Mantenha o acknowledgment atualizado para facilitar a coordenação da equipe.

Instalação e Infraestrutura

Arquitetura Proposta

Componente	Função	Recursos Sugeridos
VM 01: Zabbix Central	Roda o Zabbix Server e Web Front-end (Docker)	4 vCPU, 8 GB RAM
VM 02: Database	Instância dedicada de MariaDB ou PostgreSQL (Docker ou bare metal)	4 vCPU, 16 GB RAM, SSD Rápido
VM 03: Zabbix Proxy	Coleta dados de uma zona específica (ex.: Rede de Câmeras ou Servidores)	2 vCPU, 4 GB RAM

Configuração do Servidor e Web

Utilize o seguinte docker-compose.yml para o servidor central (configuração de produção):

yaml

services:
  zabbix-server:
    image: zabbix/zabbix-server-mysql:alpine-7.0-latest
    container_name: zabbix-server
    restart: unless-stopped
    ports:
      - "10051:10051"
    environment:
      - DB_SERVER_HOST=${DB_SERVER_HOST}
      - MYSQL_DATABASE=${MYSQL_DATABASE}
      - ZBX_DBNAME=${MYSQL_DATABASE}
      - MYSQL_USER=${MYSQL_USER}
      - MYSQL_PASSWORD=${MYSQL_PASSWORD}
      - ZBX_JAVAGATEWAY=zabbix-java-gateway
      - ZBX_JAVAGATEWAY_ENABLE=true
      - TZ=America/Sao_Paulo
      #- ZBX_SERVER_NAME=
    volumes:
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
      - ./zbx/alertscripts:/usr/lib/zabbix/alertscripts
      - ./zbx/externalscripts:/usr/lib/zabbix/externalscripts
      - ./zbx/modules:/var/lib/zabbix/modules
    depends_on:
      zabbix-db:
        condition: service_healthy
    healthcheck:
      # O Server está saudável se a porta 10051 estiver aberta
      test: ["CMD", "nc", "-z", "localhost", "10051"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - zabbix-net

  zabbix-web:
    image: zabbix/zabbix-web-nginx-mysql:alpine-7.0-latest
    container_name: zabbix-web
    restart: unless-stopped
    ports:
      - "8080:8080"
      #- "443:8443"
    environment:
      - ZBX_SERVER_HOST=zabbix-server
      - ZBX_SERVER_NAME=Zabbix Server
      - DB_SERVER_HOST=zabbix-db
      - MYSQL_DATABASE=${MYSQL_DATABASE}
      - ZBX_DBNAME=${MYSQL_DATABASE}
      - MYSQL_USER=${MYSQL_USER}
      - MYSQL_PASSWORD=${MYSQL_PASSWORD}
    depends_on:
      - zabbix-server
    networks:
      - zabbix-net

  zabbix-db:
    image: mariadb:10.11
    container_name: zabbix-db
    restart: unless-stopped
    environment:
      - MARIADB_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}
      - MARIADB_USER=${MYSQL_USER}
      - MARIADB_PASSWORD=${MYSQL_PASSWORD}
      - MARIADB_DATABASE=${MYSQL_DATABASE}
      - TZ=America/Sao_Paulo
    command:
      - --character-set-server=utf8mb4
      - --collation-server=utf8mb4_bin
      - --innodb-buffer-pool-size=4G    # Ajuste para 50-75% da RAM da VM
      - --innodb-log-file-size=512M
      - --innodb-flush-log-at-trx-commit=2 # Melhora muito a performance de escrita
      - --innodb-read-io-threads=8
      - --innodb-write-io-threads=8
    volumes:
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
      - ./mysql_data:/var/lib/mysql
    healthcheck:
      test: ["CMD", "mariadb-admin", "ping", "-h", "localhost", "-uroot", "-p${MYSQL_ROOT_PASSWORD}"]
      interval: 5s
      timeout: 5s
      retries: 10
    networks:
      - zabbix-net

  zabbix-java-gateway:
    image: zabbix/zabbix-java-gateway:alpine-7.0-latest
    container_name: zabbix-java-gateway
    restart: unless-stopped
    networks:
      - zabbix-net

  zabbix-agent:
    image: zabbix/zabbix-agent2:alpine-7.0-latest
    container_name: zabbix-agent
    restart: unless-stopped
    privileged: true
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    environment:
      - ZBX_SERVER_HOST=zabbix-server
      - ZBX_HOSTNAME=Zabbix Server
    networks:
      - zabbix-net

networks:
  zabbix-net:
    driver: bridge

Notas sobre a Configuração de Produção

Versão: Alpine 7.0 (LTS com suporte estendido)
Porta Web: 8080 (não 80, evita conflitos com outros serviços)
Java Gateway: Ativado por padrão para monitorar aplicações JVM
Agent Local: O container zabbix-agent2 monitoração o próprio host Zabbix (Docker, hardware, métricas do servidor)
Healthchecks: Implementados no Server e DB para garantir que dependências estejam saudáveis antes de iniciar
Tuning de I/O: 8 threads de leitura/escrita no InnoDB para melhor performance com altas cargas de monitoramento

Acesso à Web

O Zabbix Web é acessível em http://localhost:8080 ou http://<ip_do_servidor>:8080. Credenciais padrão: usuário Admin, senha zabbix.

ini

DB_SERVER_HOST=zabbix-db
MYSQL_DATABASE=zabbix_sss
MYSQL_USER=zabbix
MYSQL_PASSWORD=sua_senha_forte
MYSQL_ROOT_PASSWORD=sua_senha_forte
ZBX_JAVAGATEWAY_ENABLE=false

Configuração do Proxy (Segurança PMDF)

Para ambiente de produção, o uso de PSK (Pre-Shared Key) é obrigatório para que os dados coletados não trafeguem abertos na rede interna.

Passo 1 - Gerar a chave PSK

Execute no host Debian onde o proxy será instalado:

bash

openssl rand -hex 32 > zabbix_proxy.psk
chmod 600 zabbix_proxy.psk  # Proteger a chave

Passo 2 - Configurar docker-compose.yml do Proxy

yaml

services:
  zabbix-proxy:
    image: zabbix/zabbix-proxy-sqlite3:alpine-7.0-latest
    container_name: zabbix-proxy-setor
    restart: unless-stopped
    ports:
      - "10051:10051"
    environment:
      - ZBX_HOSTNAME=Proxy_Setor_Inteligencia
      - ZBX_SERVER_HOST=IP_DO_SERVER_CENTRAL
      - ZBX_SERVER_PORT=10051
      - ZBX_TLSACCEPT=psk
      - ZBX_TLSPSKIDENTITY=PSK_ID_001
      - ZBX_TLSPSKFILE=/var/lib/zabbix/zabbix_proxy.psk
      - ZBX_PROXYMODE=0  # 0=Active, 1=Passive
      - TZ=America/Sao_Paulo
    volumes:
      - ./zabbix_proxy.psk:/var/lib/zabbix/zabbix_proxy.psk:ro
      - ./zbx_proxy_data:/var/lib/sqlite3
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    healthcheck:
      test: ["CMD", "nc", "-z", "localhost", "10051"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - zabbix-net

networks:
  zabbix-net:
    driver: bridge

Passo 3 - Registrar o Proxy no Server Central

No Zabbix Web (Frontend):

Acesse Administration → Proxies
Clique em Create proxy
Configure:
- Proxy name: Proxy_Setor_Inteligencia (deve corresponder com ZBX_HOSTNAME)
- Proxy mode: Active (recomendado)
- Encryption:
  - Connections to server: PSK
  - Connections from server: PSK
  - PSK identity: PSK_ID_001 (deve corresponder com ZBX_TLSPSKIDENTITY)
  - PSK: Colar o conteúdo da chave gerada (hex de 64 caracteres)
Salvar

Variáveis de Ambiente do Proxy (`.env`)

ini

DB_SERVER_HOST=zabbix-db
MYSQL_DATABASE=zabbix_sss
MYSQL_USER=zabbix
MYSQL_PASSWORD=sua_senha_forte
MYSQL_ROOT_PASSWORD=sua_senha_forte
ZBX_JAVAGATEWAY_ENABLE=false

# Específico do Proxy
ZBX_PROXY_HOSTNAME=Proxy_Setor_Inteligencia
ZBX_SERVER_CENTRAL_IP=192.168.x.x  # IP do servidor central
ZBX_PSK_IDENTITY=PSK_ID_001

Segurança PSK

Gere a chave com openssl rand -hex 32 (64 caracteres hex)
Armazene com permissões restritas (chmod 600)
Nunca commite a chave em repositórios
A mesma chave e identidade devem estar configuradas no Proxy e no Server Central
Para múltiplos proxies, gere chaves diferentes para cada um

Modo de Proxies

Active (0): Proxy inicia conexão com o Server (recomendado, melhor firewall)
Passive (1): Server inicia conexão com Proxy (requer acesso direto)

Configuração do Banco de Dados

O Zabbix é intensivo em I/O de escrita e consultas complexas para gráficos e relatórios.

Isolamento e Benefícios

Utilizar um MariaDB dedicado em Docker no Debian isola o I/O e permite tuning específico:

Histórico e Tendências: O Zabbix armazena milhares de registros por minuto. Isolamento evita impacto no espaço em disco e memória de aplicações principais.
Housekeeper: Processo de limpeza (delete de dados antigos) é pesado; em cluster compartilhado gera contenção de locks.
Manutenção: Permite atualizar ou reiniciar o banco sem afetar aplicações.

Risco de Mistura

Misturar com o Galera Cluster de produção pode causar latência devido ao flow control (se um nó travar processando query pesada do Zabbix, todos os outros são afetados).

Recomendações

Sistema de Arquivos: Use Ext4 ou XFS para a partição dos volumes Docker (/var/lib/docker). Evite BTRFS devido à fragmentação de CoW.
Desativar Housekeeper Interno: CRÍTICO se você vai usar particionamento.
O Zabbix tiene um processo chamado "Housekeeper" que deleta dados antigos via DELETE statements. Se você habilitar particionamento e deixar o Housekeeper ativo, o Zabbix vai tentar remover dados de duas formas diferentes simultaneamente, causando:
- Travamento do MariaDB
- Contenção de locks
- Performance degradada
- Possível corrupção de dados
Procedimento:
1. Acesse o Zabbix Web em Administration → General → Housekeeping
2. Desmarque "Enable internal housekeeping" para:
  - History (histórico de coletas)
  - Trends (estatísticas agregadas)
3. Deixe marcado para outras opções como events, audit, etc.
4. Salve
Obrigatório com Particionamento
Se você habilitou particionamento, desativar o Housekeeper é OBRIGATÓRIO. A remoção de dados será feita via DROP PARTITION (instantâneo) em vez de DELETE (lento).

Particionamento de Tabelas: Habilite o table partitioning no Zabbix para dividir tabelas de histórico em partições por dia/hora, substituindo deletes lentos por drops instantâneos.

Passo 1 - Criar tabela de controle e reorganizar partições iniciais:

Execute no MariaDB (teste em ambiente de desenvolvimento primeiro e faça backup):

sql

USE zabbix_sss;

CREATE TABLE IF NOT EXISTS `manage_partitions` (
  `tablename` varchar(64) NOT NULL,
  `period` varchar(12) NOT NULL,
  `keep_history` int(11) NOT NULL,
  `last_run` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`tablename`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- Reorganizar partição inicial das tabelas de histórico (diárias)
ALTER TABLE history_str REORGANIZE PARTITION p_initial INTO (
    PARTITION p_old VALUES LESS THAN (1774483200),
    PARTITION p2026_03_26 VALUES LESS THAN (1774569600),
    PARTITION p2026_03_27 VALUES LESS THAN (1774656000),
    PARTITION p2026_03_28 VALUES LESS THAN (1774742400)
);

ALTER TABLE history_log REORGANIZE PARTITION p_initial INTO (
    PARTITION p_old VALUES LESS THAN (1774483200),
    PARTITION p2026_03_26 VALUES LESS THAN (1774569600),
    PARTITION p2026_03_27 VALUES LESS THAN (1774656000),
    PARTITION p2026_03_28 VALUES LESS THAN (1774742400)
);

ALTER TABLE history_text REORGANIZE PARTITION p_initial INTO (
    PARTITION p_old VALUES LESS THAN (1774483200),
    PARTITION p2026_03_26 VALUES LESS THAN (1774569600),
    PARTITION p2026_03_27 VALUES LESS THAN (1774656000),
    PARTITION p2026_03_28 VALUES LESS THAN (1774742400)
);

-- Reorganizar partição inicial das tabelas de trends (mensais)
ALTER TABLE trends REORGANIZE PARTITION p_initial INTO (
    PARTITION p_old VALUES LESS THAN (1772409600),
    PARTITION p2026_03 VALUES LESS THAN (1775012400),
    PARTITION p2026_04 VALUES LESS THAN (1777604400)
);

ALTER TABLE trends_uint REORGANIZE PARTITION p_initial INTO (
    PARTITION p_old VALUES LESS THAN (1772409600),
    PARTITION p2026_03 VALUES LESS THAN (1775012400),
    PARTITION p2026_04 VALUES LESS THAN (1777604400)
);

-- Inserir tabelas (manter 30 dias de histórico, 365 dias de tendências)
INSERT IGNORE INTO manage_partitions (tablename, period, keep_history, last_run) VALUES
('history', 'day', 30, NOW()),
('history_uint', 'day', 30, NOW()),
('history_str', 'day', 15, NOW()),
('history_log', 'day', 15, NOW()),
('history_text', 'day', 15, NOW()),
('trends', 'month', 365, NOW()),
('trends_uint', 'month', 365, NOW());

Passo 2 - Criar procedures inteligentes de particionamento:

A procedure abaixo identifica automaticamente se a tabela é de Histórico (partições diárias) ou Trends (partições mensais) e cria antecipadamente novos períodos:

sql

DELIMITER //

DROP PROCEDURE IF EXISTS partition_maintenance_all //

CREATE PROCEDURE partition_maintenance_all(IN _db_name VARCHAR(64))
BEGIN
    DECLARE _table_name VARCHAR(64);
    DECLARE _period VARCHAR(10);
    DECLARE _done INT DEFAULT FALSE;

    DECLARE _cur CURSOR FOR SELECT tablename, period FROM manage_partitions;
    DECLARE CONTINUE HANDLER FOR NOT FOUND SET _done = TRUE;

    OPEN _cur;
    read_loop: LOOP
        FETCH _cur INTO _table_name, _period;
        IF _done THEN LEAVE read_loop; END IF;

        IF _period = 'day' THEN
            CALL create_next_partitions_day(_db_name, _table_name, 3);
        ELSEIF _period = 'month' THEN
            CALL create_next_partitions_month(_db_name, _table_name, 2);
        END IF;
    END LOOP;
    CLOSE _cur;

    UPDATE manage_partitions SET last_run = NOW();
END //

DROP PROCEDURE IF EXISTS create_next_partitions_day //
CREATE PROCEDURE create_next_partitions_day(IN _db_name VARCHAR(64), IN _table_name VARCHAR(64), IN _days INT)
BEGIN
    DECLARE _counter INT DEFAULT 0;
    DECLARE _target_date DATE;
    DECLARE _part_name VARCHAR(64);
    DECLARE _ts_limit BIGINT;

    WHILE _counter <= _days DO
        SET _target_date = DATE_ADD(CURDATE(), INTERVAL _counter DAY);
        SET _part_name = CONCAT('p', DATE_FORMAT(_target_date, '%Y_%m_%d'));
        SET _ts_limit = UNIX_TIMESTAMP(DATE_ADD(_target_date, INTERVAL 1 DAY));

        IF NOT EXISTS (SELECT 1 FROM information_schema.PARTITIONS WHERE TABLE_SCHEMA = _db_name AND TABLE_NAME = _table_name AND PARTITION_NAME = _part_name) THEN
            SET @sql = CONCAT('ALTER TABLE ', _db_name, '.', _table_name, ' ADD PARTITION (PARTITION ', _part_name, ' VALUES LESS THAN (', _ts_limit, '))');
            PREPARE stmt FROM @sql; EXECUTE stmt; DEALLOCATE PREPARE stmt;
        END IF;
        SET _counter = _counter + 1;
    END WHILE;
END //

DROP PROCEDURE IF EXISTS create_next_partitions_month //
CREATE PROCEDURE create_next_partitions_month(IN _db_name VARCHAR(64), IN _table_name VARCHAR(64), IN _months INT)
BEGIN
    DECLARE _counter INT DEFAULT 0;
    DECLARE _target_date DATE;
    DECLARE _part_name VARCHAR(64);
    DECLARE _ts_limit BIGINT;

    WHILE _counter <= _months DO
        SET _target_date = DATE_ADD(CURDATE(), INTERVAL _counter MONTH);
        SET _part_name = CONCAT('p', DATE_FORMAT(_target_date, '%Y_%m'));
        SET _ts_limit = UNIX_TIMESTAMP(LAST_DAY(_target_date) + INTERVAL 1 DAY);

        IF NOT EXISTS (SELECT 1 FROM information_schema.PARTITIONS WHERE TABLE_SCHEMA = _db_name AND TABLE_NAME = _table_name AND PARTITION_NAME = _part_name) THEN
            SET @sql = CONCAT('ALTER TABLE ', _db_name, '.', _table_name, ' ADD PARTITION (PARTITION ', _part_name, ' VALUES LESS THAN (', _ts_limit, '))');
            PREPARE stmt FROM @sql; EXECUTE stmt; DEALLOCATE PREPARE stmt;
        END IF;
        SET _counter = _counter + 1;
    END WHILE;
END //

DELIMITER ;

Automação via Script Shell: Crie /opt/apps/zabbix/scripts/check_partitions.sh para automação:

bash

#!/bin/bash
LOG_FILE="/opt/apps/zabbix/scripts/zabbix_partitions.log"
ENV_FILE="/opt/apps/zabbix/.env"
TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")

# Carrega .env
set -a
[ -f "$ENV_FILE" ] && . "$ENV_FILE"
set +a

echo "[$TIMESTAMP] Executando manutenção..." >> "$LOG_FILE"

# Executa e captura saída
RESULT=$(/usr/bin/docker exec zabbix-db /usr/bin/mariadb -u"root" -p"${MYSQL_ROOT_PASSWORD}" "${MYSQL_DATABASE}" -e "CALL partition_maintenance_all('${MYSQL_DATABASE}');" 2>&1)

if [ $? -eq 0 ]; then
    echo "[$TIMESTAMP] Sucesso." >> "$LOG_FILE"
else
    echo "[$TIMESTAMP] ERRO: $RESULT" >> "$LOG_FILE"
fi

Adicione ao crontab para executar diariamente:

bash

0 2 * * * /opt/apps/zabbix/scripts/check_partitions.sh

Verificação de Partições: Para validar que as partições foram criadas corretamente:
sql
```
SELECT TABLE_NAME, PARTITION_NAME, PARTITION_DESCRIPTION
FROM information_schema.PARTITIONS
WHERE TABLE_SCHEMA = 'zabbix_sss'
AND (TABLE_NAME LIKE 'history%' OR TABLE_NAME LIKE 'trends%')
ORDER BY TABLE_NAME, PARTITION_DESCRIPTION DESC;
```
Vantagens do Particionamento:
- I/O de Disco: DROP PARTITION é instantâneo, evita logs de transação e fragmentação.
- Performance: Queries em tabelas particionadas são mais rápidas com partition pruning.
- Automação Inteligente: Procedures diferenciam entre histórico (dia) e trends (mês), criando antecipadamente 3 dias ou 2 meses à frente.

Instalação e Configuração do Zabbix Agent

Instalação em Servidores Debian (Repositório Oficial)

Para servidores externos que rodam aplicações Spring Boot, Laravel e outros serviços, a melhor prática é instalar via repositório oficial do Zabbix. Isso facilita atualizações via apt update e garante integração com systemd.

Passo 1 - Adicionar Repositório Zabbix 7.0

No terminal do servidor cliente:

bash

wget https://repo.zabbix.com/zabbix/7.0/debian/pool/main/z/zabbix-release/zabbix-release_7.0-1+debian12_all.deb
dpkg -i zabbix-release_7.0-1+debian12_all.deb
apt update

Passo 2 - Instalar Zabbix Agent 2

bash

apt install zabbix-agent2 zabbix-agent2-plugin-*

Plugins

Os plugins (zabbix-agent2-plugin-*) incluem suporte para PostgreSQL, MySQL, SNMP, Redis, HTTP, Docker, entre outros.

Passo 3 - Configurar o Agent

Edite /etc/zabbix/zabbix_agent2.conf:

bash

sudo nano /etc/zabbix/zabbix_agent2.conf

Configure os campos:

ini

# Aceita coletas passivas do Server/Proxy (porta 10050)
Server=IP_DO_SEU_ZABBIX_OU_PROXY

# Envia coletas ativas para o Server/Proxy
ServerActive=IP_DO_SEU_ZABBIX_OU_PROXY

# Nome único deste host no Zabbix
Hostname=Nome_do_Servidor_no_Zabbix

# Metadados para Auto Registration
HostMetadata=linux

Configuração completa (exemplo de produção):

ini

# Arquivo PID (para gerenciamento do processo)
PidFile=/run/zabbix/zabbix_agent2.pid

# Arquivo de Log
LogFile=/var/log/zabbix/zabbix_agent2.log

# Tamanho máximo do log (0 = sem limite)
LogFileSize=0

# Aceita coletas PASSIVAS (servidor conecta ao agent)
Server=10.95.203.102

# Envia coletas ATIVAS (agent conecta ao servidor)
ServerActive=10.95.203.102

# Nome único no Zabbix (CRÍTICO: deve corresponder ao host no painel)
Hostname=DEATHLOK

# Socket do plugin (Agent 2 comunica com plugins via socket)
PluginSocket=/run/zabbix/agent.plugin.sock

# Socket de controle (para comunicação interna)
ControlSocket=/run/zabbix/agent.sock

# Incluir configurações de plugins
Include=/etc/zabbix/zabbix_agent2.d/plugins.d/*.conf

# Incluir outras configurações customizadas
Include=/etc/zabbix/zabbix_agent2.d/*.conf

# Metadados para Auto Registration e filtros
HostMetadata=linux

Campo Crítico: Hostname

O valor de Hostname deve corresponder exatamente com o hostname configurado no host no painel Zabbix Web. Não use espaços ou caracteres especiais.

Esclarecimento dos campos principais:

Campo	Função	Exemplo
`Server`	Aceita conexões PASSIVAS de coleta (Zabbix puxa dados)	`10.95.203.102`
`ServerActive`	Agent ATIVO (agent empurra dados para Zabbix)	`10.95.203.102`
`Hostname`	Nome único do host no Zabbix	`DEATHLOK`
`HostMetadata`	Tags para Auto Registration	`linux`, `debian`, `docker`
`PluginSocket`	Socket onde Agent 2 plugin se conecta	`/run/zabbix/agent.plugin.sock`
`Include`	Carrega configs adicionais de plugins	`/etc/zabbix/zabbix_agent2.d/*.conf`

ServerActive vs Server

ServerActive: Agent toma iniciativa de conectar ao Server (recomendado, melhor para firewalls)
Server: Server conecta ao Agent para puxar dados (requer acesso bidirecional)

Passo 4 - Ativar e Reiniciar

bash

systemctl restart zabbix-agent2
systemctl enable zabbix-agent2

# Verificar status
systemctl status zabbix-agent2

Descoberta e Registro de Hosts

Após instalar o agent, existem 3 formas de registrar o servidor no Zabbix:

1. Auto Registration (Recomendado ⭐)

A forma mais moderna e eficiente. O Agent se "apresenta" automaticamente ao Zabbix assim que é iniciado.

Vantagens:

Automático, sem intervenção manual
Menor carga de rede comparado a Network Discovery
Ideal para ambientes dinâmicos (cloud, containers)

Configurar no Zabbix Web:

Contexto Correto

Por padrão, o Zabbix abre em Trigger actions (para e-mails quando algo quebra). Para Auto Registration, você DEVE trocar o contexto.

Passo 1 - Mudar para Autoregistration Actions

Acesse Alerts → Actions no menu lateral
Topo esquerdo: Clique na seta dropdown ao lado de "Trigger actions"
Selecione Autoregistration actions
Clique em Create action

Somente após trocar o seletor é que as opções de "Add Host" e "Link Template" aparecerão.

Passo 2 - Configurar a Action

Na aba Action:

Name: Registro Automático de Servidores Linux

Na aba Conditions:

Clique Add
Configure:
- Type: Host metadata (em vez de apenas "Type")
- Operator: Contains
- Value: linux (ou outra palavra que você definir no .conf do agente)

Isso garante que apenas máquinas com esse metadado entrem no seu Zabbix.

Segurança

Use "linux" ou outro termo que identifique seus servidores. Deixe em branco para aceitar todos (não recomendado em produção).

Passo 3 - Configurar as Operations

Na aba Operations, você deve clicar em Add e adicionar 3 operações, uma por uma:

Operação 1 - Adicionar Host:

Clique Add
Selecione apenas Add host
Clique Add para confirmar

Operação 2 - Adicionar ao Grupo:

Clique Add novamente
Selecione Add to host groups
No campo Host groups, selecione Linux servers (ou crie um novo grupo)
Clique Add para confirmar

Operação 3 - Linkar Template:

Clique Add novamente
Selecione Link to templates
No campo Templates, procure por Linux by Zabbix agent
Clique Add para confirmar

Passo 4 - Salvar a Action

Clique Add (no final da página) para criar a action
Você verá "Autoregistration action added" na parte superior

Agora, assim que cada servidor inicia o agent, será automaticamente: ✅ Registrado como um novo host ✅ Adicionado ao grupo "Linux servers" ✅ Recebido o template de coleta "Linux by Zabbix agent"

2. Network Discovery

Varredura de rede tradicional. O Zabbix Server (ou Proxy) varre um range de IPs procurando pela porta 10050.

Vantagens:

Descobre dispositivos sem agent (switches, roteadores via SNMP)
Útil para inventário inicial

Desvantagens:

Gera tráfego constante de rede
Mais lento que Auto Registration
Requer configuração de ranges de IP

Configurar:

Acesse Data collection → Discovery
Clique Create discovery rule
Configure o range: ex. 192.168.1.1-254
Porte: 10050
Configure Actions para registrar automaticamente

3. Adição Manual

Ainda disponível em Data collection → Hosts → Create host. Útil para testes pontuais ou configurações muito específicas.

Monitoração do Próprio Zabbix Server

Para monitorar o server central (docker-compose com zabbix-agent2 incluído):

Passo 1 - Verificar a Configuração do Host

No Zabbix Web:

Acesse Data collection → Hosts
Clique em Zabbix server
Localize a seção Interfaces

Passo 2 - Ajustar a Interface

IP address: Mude para 127.0.0.1 (ou deixe em branco para usar DNS)
DNS name: Digite exatamente zabbix-agent (nome do serviço no compose)
Connect to: Selecione DNS (em vez de IP)
Port: 10050 (padrão)

Passo 3 - Associar Template

Na aba Templates, procure por Linux by Zabbix agent e associe:

Clique Link new template
Digite Linux by Zabbix agent
Selecione na sugestão
Clique Add

Passo 4 - Salvar

Clique Update para aplicar as mudanças.

Em poucos minutos, o dashboard do Zabbix Server começará a mostrar métricas de CPU, memória, disco, etc. do próprio container.

Boas Práticas

✅ Sempre configure HostMetadata no agent:

ini

HostMetadata=Linux
# ou com mais detalhes:
HostMetadata=Linux,Debian,SpringBoot

Isso facilita filtros automáticos e Auto Registration baseado em metadados.

✅ Use ServerActive para coletas ativas:

Mais seguro (servidor puxa dados, não servidor empurra)
Reduz requisições desnecessárias
Melhor para firewalls restritivos

✅ Verifique conectividade:

bash

# No servidor cliente
telnet IP_DO_ZABBIX_OU_PROXY 10051

# No servidor Zabbix
tcpdump -i any -n 'port 10050 or port 10051'

✅ Monitore logs do agent:

bash

journalctl -u zabbix-agent2 -f

Monitoramento de Containers Docker

Para monitorar o que acontece dentro do seu Docker (status dos containers, consumo de CPU/Memória por imagem, tráfego de rede), o Zabbix Agent 2 comunica-se diretamente com o Docker Socket (/var/run/docker.sock) através de um template nativo chamado "Docker by Zabbix agent 2".

Como o Zabbix "Enxerga" os Containers

O processo funciona através de LLD (Low-Level Discovery):

O Agente pede a lista: Zabbix Server envia instrução ao Agent 2: "Me dê a lista de todos os containers"
Consulta ao Socket: Agent 2 acessa o arquivo de socket do Docker no Debian
Descoberta Automática: Docker responde com IDs e nomes dos containers
Criação de Itens: Zabbix cria automaticamente um conjunto de monitoramento (Itens e Triggers) para cada container sem intervenção manual

Este mecanismo elimina a necessidade de cadastrar cada container individualmente.

Configuração Necessária

A. Permissão de Acesso ao Docker Socket

O usuário zabbix (ou o container do agent) precisa ter permissão para ler o socket do Docker.

Para Agent instalado via repositório (Debian físico):

bash

sudo usermod -aG docker zabbix
sudo systemctl restart zabbix-agent2

Para Agent em container (como no seu docker-compose.yml):

Você já tem as configurações corretas:

yaml

zabbix-agent:
  image: zabbix/zabbix-agent2:alpine-7.0-latest
  privileged: true  # ✅ Necessário para acesso ao socket
  volumes:
    - /var/run/docker.sock:/var/run/docker.sock  # ✅ Compartilha socket

Segurança

A flag privileged: true é necessária para monitorar Docker. Evite usá-la para outros propósitos em produção.

B. Adicionar Template ao Host

No painel Zabbix Web:

Acesse Data collection → Hosts
Clique no host que roda Docker (ex: zabbix-agent ou seu servidor)
Vá para a aba Templates
Clique Link new template
Digite: Docker by Zabbix agent 2
Selecione na sugestão
Clique Add e depois Update

C. Aguardar Descoberta

Após alguns minutos (intervalo padrão de LLD), você verá novos itens sendo criados automaticamente. Acesse Monitoring → Latest data e procure por docker.container.

O Que Passa a Ser Monitorado

Após a descoberta, você terá acesso a:

✅ Status do Container:

docker.container_info[*, status]: Status atual (running, paused, exited, etc.)
Trigger automática se container "cair"

✅ Recursos por Container:

CPU (percentage)
Memória (bytes)
Comparar consumo: BD vs Aplicação vs Cache, separadamente

✅ Tráfego de Rede:

Bytes recebidos por container
Bytes enviados por container
Pacotes perdidos

✅ Exemplos de Métricas Disponíveis:

docker.container_info[zabbix-db, status]          → running
docker.container_status[zabbix-db, cpu]           → 1.23%
docker.container_status[zabbix-db, memory_percent] → 45.6%
docker.container_status[zabbix-web, cpu]          → 0.8%
docker.container_stats[zabbix-db, net_input]      → 524288000 bytes
docker.container_stats[zabbix-db, net_output]     → 314572800 bytes

Troubleshooting

Containers não aparecem em Latest data:

Verifique se o Agent está rodando:

bash

docker ps | grep zabbix-agent
systemctl status zabbix-agent2  # se instalado via repo

Teste acesso ao socket dentro do container:

bash

docker exec zabbix-agent ls -l /var/run/docker.sock

Verifique logs:

bash

docker logs zabbix-agent
journalctl -u zabbix-agent2 -f

Confirme que o template "Docker by Zabbix agent 2" está linkado no host

Containers aparecem, mas dados vazios:

Aguarde 5-10 minutos para LLD completar
Verifique se há permissões: docker ps deve funcionar sem sudo para o usuário zabbix

Monitoramento com Zabbix ​

Visão Geral ​

Arquitetura de Coleta ​

Triggers e Alertas ​

Guia de Operação: Resolvendo Alertas (Acknowledgment) ​

Instalação e Infraestrutura ​

Arquitetura Proposta ​

Configuração do Servidor e Web ​

Notas sobre a Configuração de Produção ​

Configuração do Proxy (Segurança PMDF) ​

Passo 1 - Gerar a chave PSK ​

Passo 2 - Configurar docker-compose.yml do Proxy ​

Passo 3 - Registrar o Proxy no Server Central ​

Variáveis de Ambiente do Proxy (.env) ​

Configuração do Banco de Dados ​

Isolamento e Benefícios ​

Recomendações ​

Instalação e Configuração do Zabbix Agent ​

Instalação em Servidores Debian (Repositório Oficial) ​

Passo 1 - Adicionar Repositório Zabbix 7.0 ​

Passo 2 - Instalar Zabbix Agent 2 ​

Passo 3 - Configurar o Agent ​

Passo 4 - Ativar e Reiniciar ​

Descoberta e Registro de Hosts ​

1. Auto Registration (Recomendado ⭐) ​

Passo 1 - Mudar para Autoregistration Actions ​

Passo 2 - Configurar a Action ​

Passo 3 - Configurar as Operations ​

Passo 4 - Salvar a Action ​

2. Network Discovery ​

3. Adição Manual ​

Monitoração do Próprio Zabbix Server ​

Passo 1 - Verificar a Configuração do Host ​

Passo 2 - Ajustar a Interface ​

Passo 3 - Associar Template ​

Passo 4 - Salvar ​

Boas Práticas ​

Monitoramento de Containers Docker ​

Como o Zabbix "Enxerga" os Containers ​

Configuração Necessária ​

A. Permissão de Acesso ao Docker Socket ​

B. Adicionar Template ao Host ​

C. Aguardar Descoberta ​

O Que Passa a Ser Monitorado ​

Troubleshooting ​

Monitoramento com Zabbix

Visão Geral

Arquitetura de Coleta

Triggers e Alertas

Guia de Operação: Resolvendo Alertas (Acknowledgment)

Instalação e Infraestrutura

Arquitetura Proposta

Configuração do Servidor e Web

Notas sobre a Configuração de Produção

Configuração do Proxy (Segurança PMDF)

Passo 1 - Gerar a chave PSK

Passo 2 - Configurar docker-compose.yml do Proxy

Passo 3 - Registrar o Proxy no Server Central

Variáveis de Ambiente do Proxy (`.env`)

Configuração do Banco de Dados

Isolamento e Benefícios

Recomendações

Instalação e Configuração do Zabbix Agent

Instalação em Servidores Debian (Repositório Oficial)

Passo 1 - Adicionar Repositório Zabbix 7.0

Passo 2 - Instalar Zabbix Agent 2

Passo 3 - Configurar o Agent

Passo 4 - Ativar e Reiniciar

Descoberta e Registro de Hosts

1. Auto Registration (Recomendado ⭐)

Passo 1 - Mudar para Autoregistration Actions

Passo 2 - Configurar a Action

Passo 3 - Configurar as Operations

Passo 4 - Salvar a Action

2. Network Discovery

3. Adição Manual

Monitoração do Próprio Zabbix Server

Passo 1 - Verificar a Configuração do Host

Passo 2 - Ajustar a Interface

Passo 3 - Associar Template

Passo 4 - Salvar

Boas Práticas

Monitoramento de Containers Docker

Como o Zabbix "Enxerga" os Containers

Configuração Necessária

A. Permissão de Acesso ao Docker Socket

B. Adicionar Template ao Host

C. Aguardar Descoberta

O Que Passa a Ser Monitorado

Troubleshooting