5 Instalação a partir de containers

Visão geral

Esta página descreve como implantar o Zabbix usando Docker ou Docker Compose.

Docker Compose é a forma mais rápida de implantar o Zabbix. Ele lê um arquivo de configuração e inicia automaticamente todos os contêineres que compõem uma instalação completa do Zabbix, na ordem correta.

Docker (implantação manual) alcança o mesmo resultado implantando cada componente passo a passo, o que pode ser mais adequado para usuários que já gerenciam um ambiente Docker existente.

Pré-requisitos

Antes de começar, certifique-se de que o Docker esteja instalado no seu sistema. Caso não esteja, siga o guia de instalação do Docker.

Alguns componentes do Zabbix exigem que portas específicas estejam abertas no host que executa o Docker (por exemplo, 10051/TCP para o Zabbix server, 162/UDP para traps SNMP). Consulte Requirements para ver uma lista completa das portas usadas pelos componentes do Zabbix. Para o Zabbix server e o agent, a porta padrão pode ser alterada definindo a variável de ambiente ZBX_LISTENPORT no respectivo container.

Imagens Docker disponíveis

O Zabbix fornece uma imagem Docker para cada componente do Zabbix, todas publicadas no Docker Hub. Cada imagem é usada para criar um contêiner que executa esse componente.

Todas as imagens dos componentes do Zabbix no Docker Hub são reconstruídas automaticamente quando suas imagens base são atualizadas.

Tags de imagem

Cada imagem oferece suporte a tags para selecionar o sistema operacional base e a versão do Zabbix:

zabbix/<image>:<os>-<version>

Valores <os> suportados:

• alpine - Alpine Linux
• ubuntu - Ubuntu
• ol - Oracle Linux
• ltsc2019 - Windows 10 LTSC 2019 (somente Zabbix agent)
• ltsc2022 - Windows 11 LTSC 2022 (somente Zabbix agent)

Valores <version> suportados:

• latest - Versão estável mais recente no Alpine Linux
• <os>-latest - Versão estável mais recente no SO selecionado
• <os>-trunk - Build de desenvolvimento (nightly) mais recente no SO selecionado
• <os>-X.X-latest - Release secundária mais recente de uma versão principal específica no SO selecionado
• <os>-X.X.* - Versão secundária específica no SO selecionado

Exemplos:

# Zabbix proxy (SQLite3) estável mais recente no Alpine Linux:
docker pull zabbix/zabbix-proxy-sqlite3:latest

# Zabbix proxy (SQLite3) estável mais recente no Ubuntu:
docker pull zabbix/zabbix-proxy-sqlite3:ubuntu-latest

# Build de desenvolvimento (nightly) mais recente do Zabbix server (MySQL) no Ubuntu:
docker pull zabbix/zabbix-server-mysql:ubuntu-trunk

# Release secundária 7.4 mais recente do Zabbix server (MySQL) no Alpine Linux:
docker pull zabbix/zabbix-server-mysql:alpine-7.4-latest

# Versão 7.4.1 do Zabbix server (MySQL) no Alpine Linux:
docker pull zabbix/zabbix-server-mysql:alpine-7.4.1

Docker Compose

Docker Compose é a maneira mais rápida de implantar o Zabbix. Ele lê um arquivo de configuração (arquivo Compose) e gerencia toda a configuração — baixando imagens Docker, criando uma rede interna entre os contêineres, configurando o armazenamento, inicializando o banco de dados e iniciando tudo na ordem correta.

O repositório official Zabbix Dockerfiles fornece arquivos Docker Compose prontos para uso e um sistema de configuração baseado em .env com suporte a diferentes sistemas operacionais, backends de banco de dados e configuração de componentes do Zabbix.

1. Clone o repositório, navegue até ele e mude para a versão 7.4:

git clone https://github.com/zabbix/zabbix-docker.git
cd zabbix-docker
git checkout 7.4

2. (Opcional) Personalize a implantação com variáveis de ambiente. Esta etapa pode ser ignorada para uma configuração padrão.

3. Implante a configuração padrão do Zabbix:

# Com MySQL como banco de dados:
docker compose -f ./compose.yaml up -d

# Com PostgreSQL como banco de dados:
docker compose -f ./compose_pgsql.yaml up -d

Isso inicia o Zabbix server, a interface web (executada no Nginx) e um backend de banco de dados (MySQL ou PostgreSQL), cada um em seu próprio contêiner no Alpine Linux (padrão). Depois que os contêineres estiverem em execução (normalmente em 1–3 minutos), o Zabbix server será iniciado e a interface web estará disponível em http://localhost.

Você pode verificar se tudo está funcionando com o seguinte comando:

docker compose ps

Todos os contêineres devem mostrar o status running. Se algum mostrar exited, verifique seus logs (docker logs <container-name>).

Variáveis de ambiente

Tanto o comportamento do Docker Compose quanto a configuração dos componentes do Zabbix podem ser personalizados usando variáveis de ambiente.

As variáveis no nível do Compose (definidas no arquivo .env) controlam quais imagens Docker, portas e faixas de IP de rede são usadas. Você pode usar essas variáveis inline antes do comando docker compose ou editar o arquivo .env.

Por exemplo, o comando a seguir implanta uma configuração completa do Zabbix com vários contêineres usando uma imagem baseada em Ubuntu (em vez do Alpine Linux padrão) e expondo a interface web via Nginx em portas HTTP (8282) e HTTPS (8443) personalizadas:

OS=ubuntu \
ZABBIX_WEB_NGINX_HTTP_PORT=8282 \
ZABBIX_WEB_NGINX_HTTPS_PORT=8443 \
docker compose -f ./compose.yaml up -d

As variáveis no nível do componente (definidas nos arquivos env_vars/.env_<component>) controlam a configuração dos componentes do Zabbix. Edite o respectivo arquivo .env_<component> antes de executar o comando docker compose.

Por exemplo, você pode ajustar a contagem de pollers passivos do Zabbix server e as configurações de cache, bem como configurar o fuso horário da interface web editando as seguintes variáveis:

# env_vars/.env_srv
ZBX_STARTPOLLERS=20
ZBX_CACHESIZE=64M
ZBX_HISTORYCACHESIZE=32M

# env_vars/.env_web
PHP_TZ=Europe/Paris

Volumes

O Docker Compose armazena dados persistentes no diretório zbx_env/ criado ao lado do arquivo Compose. Esse diretório preserva os dados dos componentes entre reinicializações e atualizações dos contêineres.

O conteúdo de zbx_env/ é predefinido para a imagem de cada componente. Por exemplo:

• zbx_env/etc/ - usado pelo contêiner da interface web do Zabbix
• zbx_env/usr/ e zbx_env/var/ - usados pelo contêiner do server Zabbix

Para mais informações sobre cada volume, consulte a seção Allowed volumes na descrição da imagem Docker de cada componente no Docker Hub.

Makefile

O repositório Zabbix Dockerfiles também fornece um Makefile como um atalho para tarefas comuns do Docker Compose. Em vez de usar o comando completo docker compose, você pode usar comandos make mais curtos (execute make help para ver as opções disponíveis):

# Implantação padrão (Zabbix server, interface web, MySQL, tudo em Alpine Linux)
make up

# Implantação personalizada (Zabbix server, interface web com portas Nginx personalizadas, PostgreSQL, tudo em Ubuntu)
make up \
  OS=ubuntu \
  DB=pgsql \
  ZABBIX_WEB_NGINX_HTTP_PORT=8282 \
  ZABBIX_WEB_NGINX_HTTPS_PORT=8443

Por padrão, make up inicia apenas um conjunto mínimo de serviços (Zabbix server, interface web e banco de dados). Isso mantém a configuração leve e evita iniciar componentes que podem não ser necessários. Para incluir componentes adicionais, você pode usar os seguintes perfis do Compose:

# Implantação padrão + Zabbix agent, Java gateway, serviço web e traps SNMP:
make up COMPOSE_PROFILES=full

# COMPOSE_PROFILES=full + Zabbix proxy (MySQL e SQLite3):
make up COMPOSE_PROFILES=all

Docker (implantação manual)

Use a implantação manual quando quiser implantar o Zabbix passo a passo, executar componentes individuais, integrá-los a um ambiente existente ou usar um runtime de contêiner alternativo, como o Podman.

Por exemplo, para implantar um proxy Zabbix, execute o seguinte comando:

docker run --name zabbix-proxy-sqlite3 \
  -e ZBX_SERVER_HOST=192.0.2.0 \
  -e ZBX_PROXYMODE=0 \
  -e ZBX_HOSTNAME=zabbix-proxy-sqlite3 \
  -v zabbix-proxy-data:/var/lib/zabbix/db_data \
  --init \
  -d \
  zabbix/zabbix-proxy-sqlite3:alpine-7.4-latest

Este comando:

• Baixa a imagem Docker zabbix/zabbix-proxy-sqlite3:alpine-7.4-latest.

• Cria e inicia um contêiner zabbix-proxy-sqlite3 com base na imagem Docker (com as flags --init e -d).

• Configura o parâmetro Server do proxy Zabbix por meio da variável de ambiente ZBX_SERVER_HOST. Esse parâmetro especifica o endereço IP do server Zabbix do qual o proxy obterá os dados de configuração e para o qual enviará os dados coletados. Observe que outras variáveis necessárias para a operação do proxy ativo usam valores padrão e podem ser omitidas.

• Conecta um local de armazenamento gerenciado pelo Docker (por exemplo, /var/lib/docker/volumes/zabbix-proxy-data/) ao diretório /var/lib/zabbix do contêiner, para que os dados do proxy Zabbix sejam armazenados permanentemente, mesmo que o contêiner seja removido.

Após implantar o contêiner do proxy Zabbix, você pode prosseguir para adicionar o proxy no seu frontend Zabbix e configurar hosts para serem monitorados por esse proxy.

Os exemplos abaixo abrangem três cenários adicionais de implantação:

• server Zabbix (MySQL) com Java gateway
• server Zabbix (PostgreSQL) com traps SNMP
• server Zabbix (MySQL) com Java gateway no RHEL 8

Para mais exemplos, consulte a descrição da imagem Docker de cada componente no Docker Hub.

Implantar o server Zabbix (MySQL) com Java gateway

1. Crie uma rede Docker dedicada, para que todos os contêineres de componentes do Zabbix possam alcançar uns aos outros pelo nome do contêiner:

docker network create --subnet 172.20.0.0/16 --ip-range 172.20.240.0/20 zabbix-net

2. Execute um contêiner de server MySQL vazio (substitua zabbix_pwd e root_pwd por senhas fortes):

docker run --name mysql-server -t \
  -e MYSQL_DATABASE="zabbix" \
  -e MYSQL_USER="zabbix" \
  -e MYSQL_PASSWORD="zabbix_pwd" \
  -e MYSQL_ROOT_PASSWORD="root_pwd" \
  --network=zabbix-net \
  --restart unless-stopped \
  -d mysql:8.0-oracle \
  --character-set-server=utf8 --collation-server=utf8_bin \
  --default-authentication-plugin=mysql_native_password \
  --innodb-default-row-format=dynamic \
  --innodb-strict-mode=OFF

3. Execute um contêiner do Zabbix Java gateway:

docker run --name zabbix-java-gateway -t \
  --network=zabbix-net \
  --restart unless-stopped \
  -d zabbix/zabbix-java-gateway:alpine-7.4-latest

4. Execute um contêiner do server Zabbix e vincule-o ao contêiner do server MySQL (substitua zabbix_pwd e root_pwd pelas mesmas senhas usadas na etapa 2):

docker run --name zabbix-server-mysql -t \
  -e DB_SERVER_HOST="mysql-server" \
  -e MYSQL_DATABASE="zabbix" \
  -e MYSQL_USER="zabbix" \
  -e MYSQL_PASSWORD="zabbix_pwd" \
  -e MYSQL_ROOT_PASSWORD="root_pwd" \
  -e ZBX_JAVAGATEWAY="zabbix-java-gateway" \
  --network=zabbix-net \
  -p 10051:10051 \
  --restart unless-stopped \
  -d zabbix/zabbix-server-mysql:alpine-7.4-latest

5. Execute um contêiner da interface web do Zabbix e vincule-o aos contêineres do server Zabbix e do server MySQL (substitua zabbix_pwd e root_pwd pelas mesmas senhas usadas na etapa 2):

docker run --name zabbix-web-nginx-mysql -t \
  -e ZBX_SERVER_HOST="zabbix-server-mysql" \
  -e DB_SERVER_HOST="mysql-server" \
  -e MYSQL_DATABASE="zabbix" \
  -e MYSQL_USER="zabbix" \
  -e MYSQL_PASSWORD="zabbix_pwd" \
  -e MYSQL_ROOT_PASSWORD="root_pwd" \
  --network=zabbix-net \
  -p 80:8080 \
  --restart unless-stopped \
  -d zabbix/zabbix-web-nginx-mysql:alpine-7.4-latest

Depois que os contêineres estiverem ativos e em execução (normalmente em 1–3 minutos), o server Zabbix será iniciado e a interface web estará disponível em http://localhost.

Implantar o server Zabbix (PostgreSQL) com traps SNMP

1. Crie uma rede Docker dedicada, para que todos os contêineres de componentes do Zabbix possam alcançar uns aos outros pelo nome do contêiner:

docker network create --subnet 172.20.0.0/16 --ip-range 172.20.240.0/20 zabbix-net

2. Execute um contêiner de server PostgreSQL vazio (substitua zabbix_pwd por uma senha forte):

docker run --name postgres-server -t \
  -e POSTGRES_USER="zabbix" \
  -e POSTGRES_PASSWORD="zabbix_pwd" \
  -e POSTGRES_DB="zabbix" \
  --network=zabbix-net \
  --restart unless-stopped \
  -d postgres:latest

3. Execute um contêiner de traps SNMP do Zabbix:

docker run --name zabbix-snmptraps -t \
  -v /zbx_instance/snmptraps:/var/lib/zabbix/snmptraps:rw \
  -v /var/lib/zabbix/mibs:/usr/share/snmp/mibs:ro \
  --network=zabbix-net \
  -p 162:1162/udp \
  --restart unless-stopped \
  -d zabbix/zabbix-snmptraps:alpine-7.4-latest

4. Execute um contêiner do server Zabbix, vincule-o ao contêiner do server PostgreSQL e ao contêiner de traps SNMP (substitua zabbix_pwd pela mesma senha usada na etapa 2):

docker run --name zabbix-server-pgsql -t \
  -e DB_SERVER_HOST="postgres-server" \
  -e POSTGRES_USER="zabbix" \
  -e POSTGRES_PASSWORD="zabbix_pwd" \
  -e POSTGRES_DB="zabbix" \
  -e ZBX_ENABLE_SNMP_TRAPS="true" \
  --network=zabbix-net \
  -p 10051:10051 \
  --volumes-from zabbix-snmptraps \
  --restart unless-stopped \
  -d zabbix/zabbix-server-pgsql:alpine-7.4-latest

5. Execute um contêiner da interface web do Zabbix e vincule-o aos contêineres do server Zabbix e do server PostgreSQL (substitua zabbix_pwd pela mesma senha usada na etapa 2):

docker run --name zabbix-web-nginx-pgsql -t \
  -e ZBX_SERVER_HOST="zabbix-server-pgsql" \
  -e DB_SERVER_HOST="postgres-server" \
  -e POSTGRES_USER="zabbix" \
  -e POSTGRES_PASSWORD="zabbix_pwd" \
  -e POSTGRES_DB="zabbix" \
  --network=zabbix-net \
  -p 443:8443 \
  -p 80:8080 \
  -v /etc/ssl/nginx:/etc/ssl/nginx:ro \
  --restart unless-stopped \
  -d zabbix/zabbix-web-nginx-pgsql:alpine-7.4-latest

Depois que os contêineres estiverem ativos e em execução (normalmente em 1–3 minutos), o server Zabbix será iniciado e a interface web estará disponível em http://localhost.

Implantar o server Zabbix (MySQL) com Java gateway no RHEL 8

No Red Hat Enterprise Linux 8, o runtime de contêiner recomendado é o Podman em vez do Docker. O Podman funciona de forma semelhante ao Docker, mas não requer um serviço em segundo plano em execução como root, o que o torna mais adequado para ambientes Red Hat.

1. Crie um novo pod com o nome zabbix e portas expostas para a interface web do Zabbix e o trapper do server Zabbix:

podman pod create --name zabbix -p 80:8080 -p 10051:10051

2. (Opcional) Execute um contêiner do agent Zabbix no local do pod zabbix:

podman run --name zabbix-agent \
  -e ZBX_SERVER_HOST="127.0.0.1,localhost" \
  --restart=always \
  --pod=zabbix \
  -d registry.connect.redhat.com/zabbix/zabbix-agent-74:latest

3. Crie um diretório ./mysql/ no host RHEL:

mkdir -p ./mysql

4. Execute um contêiner de server MySQL vazio (substitua zabbix_pwd e root_pwd por senhas fortes):

podman run --name mysql-server -t \
  -e MYSQL_DATABASE="zabbix" \
  -e MYSQL_USER="zabbix" \
  -e MYSQL_PASSWORD="zabbix_pwd" \
  -e MYSQL_ROOT_PASSWORD="root_pwd" \
  -v ./mysql/:/var/lib/mysql/:Z \
  --restart=always \
  --pod=zabbix \
  -d mysql:8.0 \
  --character-set-server=utf8 --collation-server=utf8_bin \
  --default-authentication-plugin=mysql_native_password \
  --innodb-default-row-format=dynamic \
  --innodb-strict-mode=OFF

5. Execute um contêiner do Zabbix Java gateway:

podman run --name zabbix-java-gateway -t \
  --restart=always \
  --pod=zabbix \
  -d registry.connect.redhat.com/zabbix/zabbix-java-gateway-74

6. Execute um contêiner do server Zabbix (substitua zabbix_pwd e root_pwd pelas mesmas senhas usadas na etapa 4):

podman run --name zabbix-server-mysql -t \
  -e DB_SERVER_HOST="127.0.0.1" \
  -e MYSQL_DATABASE="zabbix" \
  -e MYSQL_USER="zabbix" \
  -e MYSQL_PASSWORD="zabbix_pwd" \
  -e MYSQL_ROOT_PASSWORD="root_pwd" \
  -e ZBX_JAVAGATEWAY="127.0.0.1" \
  --restart=always \
  --pod=zabbix \
  -d registry.connect.redhat.com/zabbix/zabbix-server-mysql-74

7. Execute um contêiner da interface web do Zabbix (substitua zabbix_pwd e root_pwd pelas mesmas senhas usadas na etapa 4):

podman run --name zabbix-web-mysql -t \
  -e ZBX_SERVER_HOST="127.0.0.1" \
  -e DB_SERVER_HOST="127.0.0.1" \
  -e MYSQL_DATABASE="zabbix" \
  -e MYSQL_USER="zabbix" \
  -e MYSQL_PASSWORD="zabbix_pwd" \
  -e MYSQL_ROOT_PASSWORD="root_pwd" \
  --restart=always \
  --pod=zabbix \
  -d registry.connect.redhat.com/zabbix/zabbix-web-mysql-74