5 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 completa di Zabbix, 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 versione successiva) 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 versione successiva).

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 gli SNMP trap). 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 di 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 usata per creare un container che esegue quel componente.

Tutte le immagini dei componenti Zabbix su Docker Hub si basano sulle ultime versioni principali dei sistemi operativi supportati. Queste immagini vengono ricostruite 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 agent Zabbix)

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 (notturna) sul sistema operativo selezionato
• <os>-X.X-latest - Ultima release minore di Zabbix di una specifica versione principale di Zabbix sul sistema operativo selezionato
• <os>-X.X.* - Specifica release minore 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 (notturna) di Zabbix server (MySQL) su Ubuntu:
docker pull zabbix/zabbix-server-mysql:ubuntu-trunk

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

# Versione 7.4.1 di Zabbix server (MySQL) su Alpine Linux:
docker pull zabbix/zabbix-server-mysql:alpine-7.4.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 lo storage, 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 7.4:

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

2. (Opzionale) Personalizza la distribuzione con le variabili d'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 un 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 personalizzati entrambi tramite variabili d'ambiente.

Le variabili a livello di Compose (definite nel file .env) controllano quali immagini Docker, porte e intervalli di indirizzi 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é il valore predefinito 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 del server Zabbix 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 riavvii e aggiornamenti dei container.

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

• zbx_env/etc/ - usato dal container dell'interfaccia web di Zabbix
• zbx_env/usr/ e zbx_env/var/ - usati dal container server di 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 dei Dockerfile di Zabbix fornisce anche un Makefile come scorciatoia per le attività comuni di Docker Compose. Invece di usare il comando completo docker compose, puoi utilizzare comandi make più brevi (esegui make help per vedere le opzioni disponibili):

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

# Distribuzione personalizzata (server Zabbix, frontend 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 (server Zabbix, frontend web e database). Questo mantiene la configurazione leggera ed evita l'avvio di componenti che potrebbero non essere necessari. Per includere componenti aggiuntivi, puoi usare i seguenti profili Compose:

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

# COMPOSE_PROFILES=full + proxy Zabbix (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-7.4-latest

Questo comando:

• Scarica la Docker image zabbix/zabbix-proxy-sqlite3:alpine-7.4-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 dal quale il proxy recupererà i dati di configurazione e al quale invierà i dati raccolti. Nota che le altre variabili richieste per il funzionamento del proxy attivo usano 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 archiviati in modo permanente, anche se il container viene rimosso.

Dopo aver distribuito il container del proxy Zabbix, puoi procedere ad aggiungere il proxy nel tuo frontend Zabbix e configurare gli host da monitorare con 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

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 frontend basato su Nginx.

1. Creare una rete Docker dedicata, in modo che tutti i container dei componenti Zabbix possano raggiungersi tra loro 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):

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=utf8mb4 --collation-server=utf8mb4_bin \
  --default-authentication-plugin=mysql_native_password

3. 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-7.4-latest

4. Avviare un container Zabbix server e collegarlo al container MySQL server (sostituire zabbix_pwd e root_pwd con le stesse password usate al passaggio 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. Avviare un container frontend Zabbix e collegarlo ai container Zabbix server e MySQL server (sostituire zabbix_pwd e root_pwd con le stesse password usate al passaggio 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

Dopo che i container sono avviati ed eseguiti correttamente (in genere entro 1–3 minuti), Zabbix server viene avviato e il frontend è 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 frontend basato su Nginx.

1. Creare una rete Docker dedicata, in modo che tutti i container dei componenti Zabbix possano raggiungersi tra loro 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):

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

4. Avviare un container Zabbix server, collegarlo al container PostgreSQL server e al container SNMP traps (sostituire zabbix_pwd con la stessa password usata al passaggio 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. Avviare un container frontend Zabbix e collegarlo ai container Zabbix server e PostgreSQL server (sostituire zabbix_pwd con la stessa password usata al passaggio 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

Dopo che i container sono avviati ed eseguiti correttamente (in genere entro 1–3 minuti), Zabbix server viene avviato e il frontend è 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 frontend basato su Nginx, il tutto 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 le porte esposte per il frontend 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 nella posizione del 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. 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):

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=utf8mb4 --collation-server=utf8mb4_bin \
  --default-authentication-plugin=mysql_native_password

5. 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-74

6. Avviare un container Zabbix server (sostituire zabbix_pwd e root_pwd con le stesse password usate al passaggio 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. Avviare un container frontend Zabbix (sostituire zabbix_pwd e root_pwd con le stesse password usate al passaggio 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