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 maneira mais rápida de implantar o Zabbix. Ele lê um arquivo de configuração e inicia automaticamente todos os containers 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.

Pré-requisitos

Antes de começar, certifique-se de que o Docker (1.12.0 ou posterior) esteja instalado no seu sistema. Caso não esteja, siga o guia de instalação do Docker. Para implantação com Docker Compose, o Docker Compose (2.24.0 ou posterior) também é necessário.

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 a lista completa de 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 contêiner.

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 baseadas nas versões principais mais recentes dos sistemas operacionais suportados. Essas imagens são reconstruídas automaticamente quando as imagens do SO subjacentes 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
• centos - CentOS Stream
• ol - Oracle Linux
• ltsc2022 - Windows 11 LTSC 2022 (somente Zabbix agent)

Valores <version> suportados:

• latest - Versão estável mais recente do Zabbix no Alpine Linux
• <os>-latest - Versão estável mais recente do Zabbix no SO selecionado
• <os>-trunk - Build de desenvolvimento (nightly) mais recente no SO selecionado
• <os>-X.X-latest - Release secundária mais recente do Zabbix de uma versão principal específica do Zabbix no SO selecionado
• <os>-X.X.* - Release secundária específica do Zabbix 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 8.0 mais recente do Zabbix server (MySQL) no Alpine Linux:
docker pull zabbix/zabbix-server-mysql:alpine-8.0-latest

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

Docker Compose

O 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 do 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 de Dockerfiles oficiais do Zabbix fornece arquivos Docker Compose prontos para uso e um sistema de configuração baseado em .env, compatível com diferentes sistemas operacionais, backends de banco de dados e configurações dos componentes do Zabbix.

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

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

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 — o server do Zabbix, a interface web (em execução no NGINX) e um backend de banco de dados (MySQL ou PostgreSQL), cada um em seu próprio contêiner no Alpine Linux.

# 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

Depois que os contêineres estiverem em execução (normalmente dentro de 1 a 3 minutos), o server do Zabbix será iniciado e a interface web ficará disponível para login.

Variáveis de ambiente

O comportamento do Docker Compose e 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 intervalos de IP de rede são usados. Você pode usar essas variáveis na mesma linha, 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 no Ubuntu (em vez do Alpine Linux, usado por padrão) e disponibilizando 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 arquivo .env_<component> correspondente antes de executar o comando docker compose.

Por exemplo, você pode ajustar o número de pollers passivos do Zabbix server e as configurações de cache, além de configurar o fuso horário da interface web, editando as variáveis a seguir:

# 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 de Dockerfiles do Zabbix também fornece um Makefile como 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, web frontend, MySQL, tudo no Alpine Linux)
make up

# Implantação personalizada (Zabbix server, web frontend com portas NGINX personalizadas, PostgreSQL, tudo no 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, web frontend e banco de dados). Isso mantém a configuração leve e evita iniciar componentes que talvez não sejam 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 do Zabbix, execute o seguinte comando:

docker run --name zabbix-proxy-sqlite3 \
  -e ZBX_SERVER_HOST=192.0.2.1 \
  -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-8.0-latest

Este comando:

• Faz o pull da imagem Docker zabbix/zabbix-proxy-sqlite3:alpine-8.0-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 do Zabbix por meio da variável de ambiente ZBX_SERVER_HOST. Esse parâmetro especifica o endereço IP do server do Zabbix do qual o proxy recuperará os dados de configuração e para o qual enviará os dados coletados. Observe que outras variáveis necessárias para a operação de 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 do Zabbix sejam armazenados permanentemente, mesmo que o contêiner seja removido.

Depois de implantar o contêiner do proxy do Zabbix, você pode prosseguir para adicionar o proxy na interface web do Zabbix e configurar hosts para serem monitorados por esse proxy.

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

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

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

Implantar o server Zabbix (MySQL) com Java gateway

Este exemplo mostra como implantar um server Zabbix com backend MySQL, um Java gateway para monitoramento JMX e uma interface web baseada em NGINX.

1. Crie uma rede Docker dedicada para que todos os contêineres dos 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 vazio do server MySQL (substitua zabbix_pwd e root_pwd por senhas fortes e use esses valores nas etapas seguintes):

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.4-oracle \
  --character-set-server=utf8mb4 --collation-server=utf8mb4_bin

3. Acompanhe os logs do MySQL e aguarde até que o MySQL esteja pronto para conexões (use Ctrl+C para sair dos logs):

docker logs -f mysql-server

# ... [Server] /usr/sbin/mysqld: ready for connections. ...

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

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

5. Habilite log_bin_trust_function_creators no contêiner do server MySQL. Isso relaxa temporariamente as restrições de segurança sobre funções armazenadas; essa configuração será desabilitada nas etapas posteriores. Isso permite que o usuário do banco de dados do Zabbix crie funções armazenadas sem o privilégio SUPER, exigido pelo MySQL quando o registro binário está habilitado (por padrão desde o MySQL 8.0). Execute o comando a seguir:

docker exec -it mysql-server mysql -u root -p'root_pwd' \
  -e "SET GLOBAL log_bin_trust_function_creators = 1;"

6. Execute um contêiner do server Zabbix e vincule-o aos contêineres do Java Gateway e do server MySQL:

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 ZBX_JAVAGATEWAY="zabbix-java-gateway" \
  --network=zabbix-net \
  -p 10051:10051 \
  --restart unless-stopped \
  --init \
  -d zabbix/zabbix-server-mysql:alpine-8.0-latest

7. Acompanhe os logs do server Zabbix e aguarde até que o server Zabbix termine de inicializar o esquema do banco de dados (use Ctrl+C para sair dos logs):

docker logs -f zabbix-server-mysql

# ... [info]: ** Creating 'zabbix' schema in MySQL
# ... [info]: ** Database schema successfully created!

8. Desabilite log_bin_trust_function_creators no contêiner do server MySQL. Isso restabelece a restrição de segurança que impede usuários que não têm SUPER de criar funções armazenadas. Execute o comando a seguir:

docker exec -it mysql-server mysql -u root -p'root_pwd' \
  -e "SET GLOBAL log_bin_trust_function_creators = 0;"

9. Execute um contêiner da interface web do Zabbix e vincule-o aos contêineres do server Zabbix e do server MySQL:

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 PHP_TZ="Europe/Riga" \
  --network=zabbix-net \
  -p 80:8080 \
  --restart unless-stopped \
  -d zabbix/zabbix-web-nginx-mysql:alpine-8.0-latest

Depois que os contêineres estiverem em execução, o server Zabbix será iniciado e a interface web estará disponível para login.

Implantar o server Zabbix (PostgreSQL) com traps SNMP

Este exemplo mostra como implantar um server Zabbix com backend PostgreSQL, traps SNMP e uma interface web baseada em NGINX.

1. Crie uma rede Docker dedicada para que todos os contêineres dos 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 vazio do server PostgreSQL (substitua zabbix_pwd por uma senha forte e use esse valor nas etapas seguintes):

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-8.0-latest

4. Execute um contêiner do server Zabbix e vincule-o aos contêineres do server PostgreSQL e de traps SNMP:

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 \
  --init \
  -d zabbix/zabbix-server-pgsql:alpine-8.0-latest

5. Acompanhe os logs do server Zabbix e aguarde até que o server Zabbix termine de inicializar o esquema do banco de dados (use Ctrl+C para sair dos logs):

docker logs -f zabbix-server-pgsql

# ... [info]: ** Creating 'zabbix' schema in PostgreSQL
# ... [info]: ** Database schema successfully created!

6. Execute um contêiner da interface web do Zabbix e vincule-o aos contêineres do server Zabbix e do server PostgreSQL:

docker run --name zabbix-web-nginx-pgsql -t \
  -e ZBX_SERVER_HOST="zabbix-server-pgsql" \
  -e DB_SERVER_HOST="postgres-server" \
  -e POSTGRES_DB="zabbix" \
  -e POSTGRES_USER="zabbix" \
  -e POSTGRES_PASSWORD="zabbix_pwd" \
  -e PHP_TZ="Europe/Riga" \
  --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-8.0-latest

Depois que os contêineres estiverem em execução, o server Zabbix será iniciado e a interface web estará disponível para login.

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

Este exemplo mostra como implantar um server Zabbix com backend MySQL, um Java gateway para monitoramento JMX e uma interface web baseada em NGINX, todos executados no Red Hat Enterprise Linux 8, 9 ou 10.

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

1. Crie um novo pod com o nome zabbix e exponha as portas da interface web do Zabbix e do 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 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-80:latest

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

mkdir -p ./mysql

4. Execute um contêiner vazio do server MySQL (substitua zabbix_pwd e root_pwd por senhas fortes e use esses valores nas etapas seguintes):

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.4 \
  --character-set-server=utf8mb4 --collation-server=utf8mb4_bin

5. Acompanhe os logs do MySQL e aguarde até que o MySQL esteja pronto para conexões (use Ctrl+C para sair dos logs):

podman logs -f mysql-server

# ... [Server] /usr/sbin/mysqld: ready for connections. ...

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

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

7. Habilite log_bin_trust_function_creators no contêiner do server MySQL. Isso relaxa temporariamente as restrições de segurança sobre funções armazenadas; essa configuração será desabilitada nas etapas posteriores. Isso permite que o usuário do banco de dados do Zabbix crie funções armazenadas sem o privilégio SUPER, exigido pelo MySQL quando o registro binário está habilitado (por padrão desde o MySQL 8.0). Execute o comando a seguir:

podman exec -it mysql-server mysql -u root -p'root_pwd' \
  -e "SET GLOBAL log_bin_trust_function_creators = 1;"

8. Execute um contêiner do server Zabbix e vincule-o aos contêineres do Java Gateway e do server MySQL:

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 ZBX_JAVAGATEWAY="127.0.0.1" \
  --restart=always \
  --init \
  --pod=zabbix \
  -d registry.connect.redhat.com/zabbix/zabbix-server-mysql-80

9. Acompanhe os logs do server Zabbix e aguarde até que o server Zabbix termine de inicializar o esquema do banco de dados (use Ctrl+C para sair dos logs):

podman logs -f zabbix-server-mysql

# ... [info]: ** Creating 'zabbix' schema in MySQL
# ... [info]: ** Database schema successfully created!

10. Desabilite log_bin_trust_function_creators no contêiner do server MySQL. Isso restabelece a restrição de segurança que impede usuários que não têm SUPER de criar funções armazenadas. Execute o comando a seguir:

podman exec -it mysql-server mysql -u root -p'root_pwd' \
  -e "SET GLOBAL log_bin_trust_function_creators = 0;"

11. Execute um contêiner da interface web do Zabbix e vincule-o aos contêineres do server Zabbix e do server MySQL:

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 PHP_TZ="Europe/Riga" \
  --restart=always \
  --pod=zabbix \
  -d registry.connect.redhat.com/zabbix/zabbix-web-mysql-80

Depois que os contêineres estiverem em execução, o server Zabbix será iniciado e a interface web estará disponível para login.