Installazione da container

Panoramica

Questa pagina descrive come distribuire Zabbix usando Docker o Docker Compose.

Docker Compose è il modo più rapido per distribuire Zabbix. Legge un file di configurazione e avvia automaticamente tutti i container che compongono una configurazione Zabbix completa, nell'ordine corretto.

Docker (distribuzione manuale) ottiene lo stesso risultato distribuendo ogni componente passo dopo passo.

Prerequisiti

Prima di iniziare, assicurati che Docker (1.12.0 o successivo) sia installato sul tuo sistema. In caso contrario, segui la guida all'installazione di Docker. Per il deployment con Docker Compose, è richiesto anche Docker Compose (2.24.0 o successivo).

Alcuni componenti di Zabbix richiedono che porte specifiche siano aperte sull'host che esegue Docker (ad esempio, 10051/TCP per Zabbix server, 162/UDP per le trap SNMP). Consulta Requirements per un elenco completo delle porte utilizzate dai componenti di Zabbix. Per Zabbix server e agent, la porta predefinita può essere modificata impostando la variabile d'ambiente ZBX_LISTENPORT nel rispettivo container.

Immagini Docker disponibili

Zabbix fornisce un'immagine Docker per ciascun componente Zabbix, tutte pubblicate su Docker Hub. Ogni immagine viene utilizzata per creare un container che esegue quel componente.

Tutte le immagini dei componenti Zabbix su Docker Hub sono basate sulle ultime versioni major dei sistemi operativi supportati. Queste immagini vengono ricompilate automaticamente quando le immagini del sistema operativo sottostante vengono aggiornate.

Tag delle immagini

Ogni immagine supporta tag per selezionare il sistema operativo di base e la versione di Zabbix:

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

Valori <os> supportati:

• alpine - Alpine Linux
• ubuntu - Ubuntu
• centos - CentOS Stream
• ol - Oracle Linux
• ltsc2022 - Windows 11 LTSC 2022 (solo Zabbix agent)

Valori <version> supportati:

• latest - Ultima versione stabile di Zabbix su Alpine Linux
• <os>-latest - Ultima versione stabile di Zabbix sul sistema operativo selezionato
• <os>-trunk - Ultima build di sviluppo (nightly) sul sistema operativo selezionato
• <os>-X.X-latest - Ultima minor release di Zabbix di una specifica major version di Zabbix sul sistema operativo selezionato
• <os>-X.X.* - Specifica minor release di Zabbix sul sistema operativo selezionato

Esempi:

# Ultimo Zabbix proxy stabile (SQLite3) su Alpine Linux:
docker pull zabbix/zabbix-proxy-sqlite3:latest

# Ultimo Zabbix proxy stabile (SQLite3) su Ubuntu:
docker pull zabbix/zabbix-proxy-sqlite3:ubuntu-latest

# Ultima build di sviluppo (nightly) di Zabbix server (MySQL) su Ubuntu:
docker pull zabbix/zabbix-server-mysql:ubuntu-trunk

# Ultima minor release 8.0 di Zabbix server (MySQL) su Alpine Linux:
docker pull zabbix/zabbix-server-mysql:alpine-8.0-latest

# Versione 8.0.1 di Zabbix server (MySQL) su Alpine Linux:
docker pull zabbix/zabbix-server-mysql:alpine-8.0.1

Docker Compose

Docker Compose è il modo più rapido per distribuire Zabbix. Legge un file di configurazione (Compose file) e gestisce l'intera configurazione: scaricando le immagini Docker, creando una rete interna tra i container, configurando l'archiviazione, inizializzando il database e avviando tutto nell'ordine corretto.

Il repository official Zabbix Dockerfiles fornisce file Docker Compose pronti all'uso e un sistema di configurazione basato su .env che supporta diversi sistemi operativi, backend di database e configurazioni dei componenti Zabbix.

1. Clona il repository, spostati nella sua directory e passa alla versione 8.0:

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

2. (Opzionale) Personalizza la distribuzione con le variabili di ambiente. Questo passaggio può essere saltato per una configurazione predefinita.

3. Distribuisci la configurazione predefinita: Zabbix server, interfaccia web (in esecuzione su Nginx) e un backend di database (MySQL o PostgreSQL), ciascuno in esecuzione nel proprio container su Alpine Linux.

# Con MySQL come database:
docker compose -f ./compose.yaml up -d

# Con PostgreSQL come database:
docker compose -f ./compose_pgsql.yaml up -d

Dopo che i container sono avviati ed eseguiti correttamente (in genere entro 1–3 minuti), Zabbix server viene avviato e l'interfaccia web è disponibile all'indirizzo http://localhost.

Variabili d'ambiente

Il comportamento di Docker Compose e la configurazione dei componenti Zabbix possono essere entrambi personalizzati usando variabili d'ambiente.

Le variabili a livello di Compose (definite nel file .env) controllano quali immagini Docker, porte e intervalli IP di rete vengono utilizzati. Puoi usare queste variabili inline prima del comando docker compose, oppure modificare il file .env.

Ad esempio, il seguente comando distribuisce una configurazione Zabbix completa multi-container usando un'immagine basata su Ubuntu (anziché la predefinita Alpine Linux) ed esponendo l'interfaccia web tramite Nginx sulle porte HTTP (8282) e HTTPS (8443) personalizzate:

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

Le variabili a livello di componente (definite nei file env_vars/.env_<component>) controllano la configurazione dei componenti Zabbix. Modifica il relativo file .env_<component> prima di eseguire il comando docker compose.

Ad esempio, puoi regolare il numero di poller passivi di Zabbix server e le impostazioni della cache, oltre a configurare il fuso orario dell'interfaccia web, modificando le seguenti variabili:

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

# env_vars/.env_web
PHP_TZ=Europe/Paris

Volumi

Docker Compose memorizza i dati persistenti nella directory zbx_env/ creata accanto al file Compose. Questa directory conserva i dati dei componenti tra i riavvii e gli aggiornamenti dei container.

Il contenuto di zbx_env/ è predefinito per l'immagine di ciascun componente. Ad esempio:

• zbx_env/etc/ - utilizzata dal container dell'interfaccia web di Zabbix
• zbx_env/usr/ e zbx_env/var/ - utilizzate dal container del server Zabbix

Per ulteriori informazioni su ciascun volume, vedere la sezione Allowed volumes nella descrizione dell'immagine Docker di ciascun componente su Docker Hub.

Makefile

Il repository Dockerfiles di Zabbix fornisce anche un Makefile come scorciatoia per le attività comuni di Docker Compose. Invece di usare il comando completo docker compose, puoi usare comandi make più brevi (esegui make help per vedere le opzioni disponibili):

# Distribuzione predefinita (Zabbix server, interfaccia web, MySQL, tutto su Alpine Linux)
make up

# Distribuzione personalizzata (Zabbix server, interfaccia web con porte Nginx personalizzate, PostgreSQL, tutto su Ubuntu)
make up \
  OS=ubuntu \
  DB=pgsql \
  ZABBIX_WEB_NGINX_HTTP_PORT=8282 \
  ZABBIX_WEB_NGINX_HTTPS_PORT=8443

Per impostazione predefinita, make up avvia solo un insieme minimo di servizi (Zabbix server, interfaccia web e database). Questo mantiene la configurazione leggera ed evita di avviare componenti che potrebbero non essere necessari. Per includere componenti aggiuntivi, puoi usare i seguenti profili Compose:

# Distribuzione predefinita + Zabbix agent, Java gateway, servizio web e trap SNMP:
make up COMPOSE_PROFILES=full

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

Docker (distribuzione manuale)

Usa la distribuzione manuale quando vuoi distribuire Zabbix passo dopo passo, eseguire singoli componenti, integrarli con un ambiente esistente o usare un runtime dei container alternativo come Podman.

Ad esempio, per distribuire un proxy Zabbix, esegui il seguente 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

Questo comando:

• Scarica la Docker image zabbix/zabbix-proxy-sqlite3:alpine-8.0-latest.

• Crea e avvia un container zabbix-proxy-sqlite3 basato sulla Docker image (con i flag --init e -d).

• Configura il parametro Server del proxy Zabbix tramite la variabile di ambiente ZBX_SERVER_HOST. Questo parametro specifica l'indirizzo IP del server Zabbix da cui il proxy recupererà i dati di configurazione e a cui invierà i dati raccolti. Nota che le altre variabili richieste per il funzionamento del proxy attivo usano i valori predefiniti e possono essere omesse.

• Collega una posizione di archiviazione gestita da Docker (ad esempio, /var/lib/docker/volumes/zabbix-proxy-data/) alla directory /var/lib/zabbix del container, in modo che i dati del proxy Zabbix vengano conservati in modo permanente, anche se il container viene rimosso.

Dopo aver distribuito il container del proxy Zabbix, puoi procedere ad aggiungere il proxy nella tua interfaccia web Zabbix e a configurare gli host da monitorare tramite questo proxy.

Gli esempi seguenti coprono tre scenari aggiuntivi di distribuzione:

• server Zabbix (MySQL) con Java gateway
• server Zabbix (PostgreSQL) con trap SNMP
• server Zabbix (MySQL) con Java gateway su RHEL 8–10

Per altri esempi, fai riferimento alla descrizione di ciascuna Docker image del componente su Docker Hub.

Distribuire Zabbix server (MySQL) con Java gateway

Questo esempio mostra come distribuire un Zabbix server con backend MySQL, un Java gateway per monitoraggio JMX e un'interfaccia web basata su Nginx.

1. Creare una rete Docker dedicata, in modo che tutti i container dei componenti Zabbix possano raggiungersi a vicenda tramite il nome del container:

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

2. Avviare un container MySQL server vuoto (sostituire zabbix_pwd e root_pwd con password robuste e usare tali valori nei passaggi successivi):

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. Seguire i log di MySQL e attendere finché MySQL non è pronto per le connessioni (usare Ctrl+C per uscire dai log):

docker logs -f mysql-server

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

4. Avviare un container Zabbix Java gateway:

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

5. Abilitare log_bin_trust_function_creators nel container MySQL server. Questo allenta temporaneamente le restrizioni di sicurezza sulle stored function; l'impostazione verrà disabilitata nei passaggi successivi. Consente all'utente del database Zabbix di creare stored function senza il privilegio SUPER, richiesto da MySQL quando il binary logging è abilitato (impostazione predefinita da MySQL 8.0). Eseguire il seguente comando:

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

6. Avviare un container Zabbix server e collegarlo ai container Java Gateway e MySQL server:

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. Seguire i log di Zabbix server e attendere finché Zabbix server non ha terminato l'inizializzazione dello schema del database (usare Ctrl+C per uscire dai log):

docker logs -f zabbix-server-mysql

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

8. Disabilitare log_bin_trust_function_creators nel container MySQL server. Questo ripristina la restrizione di sicurezza che impedisce agli utenti non-SUPER di creare stored function. Eseguire il seguente comando:

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

9. Avviare un container dell'interfaccia web Zabbix e collegarlo ai container Zabbix server e MySQL server:

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

Dopo che i container sono avviati ed eseguiti, Zabbix server viene avviato e l'interfaccia web è disponibile all'indirizzo http://localhost.

Distribuire Zabbix server (PostgreSQL) con SNMP traps

Questo esempio mostra come distribuire un Zabbix server con backend PostgreSQL, SNMP traps e un'interfaccia web basata su Nginx.

1. Creare una rete Docker dedicata, in modo che tutti i container dei componenti Zabbix possano raggiungersi a vicenda tramite il nome del container:

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

2. Avviare un container PostgreSQL server vuoto (sostituire zabbix_pwd con una password robusta e usare tale valore nei passaggi successivi):

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. Avviare un container Zabbix SNMP traps:

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. Avviare un container Zabbix server e collegarlo ai container PostgreSQL server e SNMP traps:

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. Seguire i log di Zabbix server e attendere finché Zabbix server non ha terminato l'inizializzazione dello schema del database (usare Ctrl+C per uscire dai log):

docker logs -f zabbix-server-pgsql

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

6. Avviare un container dell'interfaccia web Zabbix e collegarlo ai container Zabbix server e PostgreSQL server:

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

Dopo che i container sono avviati ed eseguiti, Zabbix server viene avviato e l'interfaccia web è disponibile all'indirizzo http://localhost.

Distribuire Zabbix server (MySQL) con Java gateway su RHEL 8–10

Questo esempio mostra come distribuire un Zabbix server con backend MySQL, un Java gateway per monitoraggio JMX e un'interfaccia web basata su Nginx, tutti in esecuzione su Red Hat Enterprise Linux 8, 9 o 10.

Su Red Hat Enterprise Linux, il runtime container consigliato è Podman invece di Docker. Podman funziona in modo simile a Docker, ma non richiede un servizio in background eseguito come root, il che lo rende più adatto agli ambienti Red Hat.

1. Creare un nuovo pod con il nome zabbix e porte esposte per l'interfaccia web Zabbix e il trapper di Zabbix server:

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

2. (Opzionale) Avviare un container Zabbix agent nel 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. Creare una directory ./mysql/ sull'host RHEL:

mkdir -p ./mysql

4. Avviare un container MySQL server vuoto (sostituire zabbix_pwd e root_pwd con password robuste e usare tali valori nei passaggi successivi):

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. Seguire i log di MySQL e attendere finché MySQL non è pronto per le connessioni (usare Ctrl+C per uscire dai log):

podman logs -f mysql-server

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

6. Avviare un container Zabbix Java gateway:

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

7. Abilitare log_bin_trust_function_creators nel container MySQL server. Questo allenta temporaneamente le restrizioni di sicurezza sulle stored function; l'impostazione verrà disabilitata nei passaggi successivi. Consente all'utente del database Zabbix di creare stored function senza il privilegio SUPER, richiesto da MySQL quando il binary logging è abilitato (impostazione predefinita da MySQL 8.0). Eseguire il seguente comando:

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

8. Avviare un container Zabbix server e collegarlo ai container Java Gateway e MySQL server:

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. Seguire i log di Zabbix server e attendere finché Zabbix server non ha terminato l'inizializzazione dello schema del database (usare Ctrl+C per uscire dai log):

podman logs -f zabbix-server-mysql

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

10. Disabilitare log_bin_trust_function_creators nel container MySQL server. Questo ripristina la restrizione di sicurezza che impedisce agli utenti non-SUPER di creare stored function. Eseguire il seguente comando:

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

11. Avviare un container dell'interfaccia web Zabbix e collegarlo ai container Zabbix server e MySQL server:

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

Dopo che i container sono avviati ed eseguiti, Zabbix server viene avviato e l'interfaccia web è disponibile all'indirizzo http://localhost.