Installazione da container

Panoramica

Questa pagina descrive come distribuire Zabbix utilizzando 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, il che può essere adatto agli utenti che già gestiscono un ambiente Docker esistente.

Prerequisiti

Prima di iniziare, assicurati che Docker sia installato sul tuo sistema. In caso contrario, segui la guida all'installazione di Docker.

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 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 vengono ricostruite automaticamente quando le rispettive immagini di base 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
• ol - Oracle Linux
• ltsc2019 - Windows 10 LTSC 2019 (solo Zabbix agent)
• ltsc2022 - Windows 11 LTSC 2022 (solo Zabbix agent)

Valori <version> supportati:

• latest - Ultima versione stabile su Alpine Linux
• <os>-latest - Ultima versione stabile sul sistema operativo selezionato
• <os>-trunk - Ultima build di sviluppo (nightly) sul sistema operativo selezionato
• <os>-X.X-latest - Ultima release minore di una specifica versione principale sul sistema operativo selezionato
• <os>-X.X.* - Versione minore specifica 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 release minore 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 (file Compose) e gestisce l’intera configurazione: scarica le immagini Docker, crea una rete interna tra i container, configura lo storage, inizializza il database e avvia 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 la configurazione dei componenti di Zabbix.

1. Clonare il repository, accedervi e passare alla versione 8.0:

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

2. (Facoltativo) Personalizzare la distribuzione con le variabili d’ambiente. Questo passaggio può essere saltato per una configurazione predefinita.

3. Distribuire la configurazione predefinita di Zabbix:

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

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

Questo avvia Zabbix server, l’interfaccia web (in esecuzione su Nginx) e un backend di database (MySQL o PostgreSQL), ciascuno in esecuzione nel proprio container su Alpine Linux (predefinito). Dopo che i container sono stati avviati e sono in esecuzione (in genere entro 1–3 minuti), Zabbix server viene avviato e l’interfaccia web è disponibile all’indirizzo http://localhost.

È possibile verificare che tutto funzioni con il seguente comando:

docker compose ps

Tutti i container dovrebbero mostrare lo stato running. Se uno qualsiasi mostra exited, controllarne i log (docker logs <container-name>).

Variabili d'ambiente

Sia il comportamento di Docker Compose sia la configurazione dei componenti Zabbix possono essere personalizzati utilizzando 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. È possibile usare queste variabili inline prima del comando docker compose, oppure modificare il file .env.

Ad esempio, il comando seguente distribuisce una configurazione Zabbix completa multi-container utilizzando un'immagine basata su Ubuntu (invece di Alpine Linux predefinito) ed esponendo l'interfaccia web tramite Nginx su 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. Modificare il rispettivo file .env_<component> prima di eseguire il comando docker compose.

Ad esempio, è possibile regolare il numero di poller passivi di Zabbix server e le impostazioni della cache, nonché 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 oppure utilizzare un runtime di 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.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-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 d'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. Tieni presente che le altre variabili richieste per il funzionamento del proxy attivo utilizzano 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 tramite questo proxy.

Gli esempi seguenti coprono altri tre scenari di distribuzione:

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

Per ulteriori esempi, fai riferimento alla descrizione della Docker image di ciascun componente su Docker Hub.

Distribuire Zabbix server (MySQL) con Java gateway

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. Eseguire un container server MySQL vuoto (sostituire zabbix_pwd e root_pwd con password complesse):

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=utf8 --collation-server=utf8_bin \
  --default-authentication-plugin=caching_sha2_password \
  --innodb-default-row-format=dynamic \
  --innodb-strict-mode=OFF

3. Eseguire 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

4. Eseguire un container Zabbix server e collegarlo al container server MySQL (sostituire zabbix_pwd e root_pwd con le stesse password utilizzate nel 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-8.0-latest

5. Eseguire un container dell'interfaccia web di Zabbix e collegarlo ai container Zabbix server e server MySQL (sostituire zabbix_pwd e root_pwd con le stesse password utilizzate nel 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-8.0-latest

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

Distribuire Zabbix server (PostgreSQL) con trap SNMP

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. Eseguire un container server PostgreSQL vuoto (sostituire zabbix_pwd con una password complessa):

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. Eseguire 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. Eseguire un container Zabbix server, collegarlo al container server PostgreSQL e al container SNMP traps (sostituire zabbix_pwd con la stessa password utilizzata nel 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-8.0-latest

5. Eseguire un container dell'interfaccia web di Zabbix e collegarlo ai container Zabbix server e server PostgreSQL (sostituire zabbix_pwd con la stessa password utilizzata nel 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-8.0-latest

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

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

Su Red Hat Enterprise Linux 8, il runtime per container consigliato è Podman invece di Docker. Podman funziona in modo simile a Docker ma non richiede un servizio in background in esecuzione 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 l'interfaccia web di Zabbix e il trapper di Zabbix server:

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

2. (Facoltativo) Eseguire 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. Eseguire un container server MySQL vuoto (sostituire zabbix_pwd e root_pwd con password complesse):

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=utf8 --collation-server=utf8_bin \
  --default-authentication-plugin=caching_sha2_password \
  --innodb-default-row-format=dynamic \
  --innodb-strict-mode=OFF

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

6. Eseguire un container Zabbix server (sostituire zabbix_pwd e root_pwd con le stesse password utilizzate nel 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-80

7. Eseguire un container dell'interfaccia web di Zabbix (sostituire zabbix_pwd e root_pwd con le stesse password utilizzate nel 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-80