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 (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 ufficiale dei Dockerfile di Zabbix 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 di Zabbix.

1. Clonare il repository, accedere alla relativa directory 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 ignorato per una configurazione predefinita.

3. Distribuire la configurazione predefinita: server Zabbix, frontend 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 stati avviati (in genere entro 1–3 minuti), il server Zabbix si avvia e il frontend web diventa disponibile per il login.

Variabili d'ambiente

Il comportamento di Docker Compose e 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 di indirizzi IP di rete vengono utilizzati. È possibile utilizzare queste variabili inline prima del comando docker compose oppure modificare il file .env.

Ad esempio, il comando seguente distribuisce una configurazione Zabbix completa composta da più container utilizzando un'immagine basata su Ubuntu (anziché l'immagine predefinita basata su Alpine Linux) ed espone 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. Modificare il file .env_<component> corrispondente prima di eseguire il comando docker compose.

Ad esempio, è possibile modificare il numero di poller passivi e le impostazioni della cache del server Zabbix, nonché configurare il fuso orario dell'interfaccia web, modificando le variabili seguenti:

# 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 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, è possibile usare comandi make più brevi (eseguire make help per visualizzare le opzioni disponibili):

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

# Distribuzione personalizzata (server Zabbix, frontend 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 set minimo di servizi (server Zabbix, frontend e database). In questo modo la configurazione rimane leggera ed evita di avviare componenti che potrebbero non essere necessari. Per includere componenti aggiuntivi, è possibile usare i seguenti profili Compose:

# Distribuzione predefinita + Zabbix agent, 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 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.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. Tieni presente 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 nella tua interfaccia web Zabbix e a configurare gli host da monitorare con questo proxy.

Gli esempi seguenti coprono tre scenari aggiuntivi di distribuzione:

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

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

Implementare Zabbix server (MySQL) cu Java gateway

Acest exemplu arată cum se implementează un Zabbix server cu un backend MySQL, un Java gateway pentru monitorizarea JMX și o interfață web bazată pe NGINX.

1. Creați o rețea Docker dedicată, astfel încât toate containerele componentelor Zabbix să se poată conecta între ele folosind numele containerelor:

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

2. Porniți un container gol pentru serverul MySQL (înlocuiți zabbix_pwd și root_pwd cu parole puternice și utilizați aceste valori în pașii următori):

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. Urmăriți jurnalele MySQL și așteptați până când MySQL este pregătit să accepte conexiuni (utilizați Ctrl+C pentru a ieși din jurnale):

docker logs -f mysql-server

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

4. Porniți 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. Activați log_bin_trust_function_creators în containerul serverului MySQL. Această setare relaxează temporar restricțiile de securitate pentru funcțiile stocate; setarea va fi dezactivată la pașii următori. Aceasta permite utilizatorului bazei de date Zabbix să creeze funcții stocate fără privilegiul SUPER, necesar în MySQL atunci când este activată înregistrarea binară (implicit începând cu MySQL 8.0). Executați următoarea comandă:

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

6. Porniți un container Zabbix server și conectați-l la containerele Java Gateway și serverului 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. Urmăriți jurnalele Zabbix server și așteptați până când Zabbix server finalizează inițializarea schemei bazei de date (utilizați Ctrl+C pentru a ieși din jurnale):

docker logs -f zabbix-server-mysql

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

8. Dezactivați log_bin_trust_function_creators în containerul serverului MySQL. Aceasta reactivează restricția de securitate care împiedică utilizatorii fără SUPER să creeze funcții stocate. Executați următoarea comandă:

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

9. Porniți un container pentru frontend-ul web Zabbix și conectați-l la containerele Zabbix server și serverului 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

După ce containerele sunt pornite și funcționează, Zabbix server pornește, iar frontend-ul web devine disponibil pentru autentificare.

Implementare Zabbix server (PostgreSQL) cu capcane SNMP

Acest exemplu arată cum se implementează un Zabbix server cu un backend PostgreSQL, capcane SNMP și o interfață web bazată pe NGINX.

1. Creați o rețea Docker dedicată, astfel încât toate containerele componentelor Zabbix să se poată conecta între ele folosind numele containerelor:

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

2. Porniți un container gol pentru serverul PostgreSQL (înlocuiți zabbix_pwd cu o parolă puternică și utilizați această valoare în pașii următori):

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. Porniți un container Zabbix pentru capcane SNMP:

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. Porniți un container Zabbix server și conectați-l la containerele serverului PostgreSQL și capcanelor 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. Urmăriți jurnalele Zabbix server și așteptați până când Zabbix server finalizează inițializarea schemei bazei de date (utilizați Ctrl+C pentru a ieși din jurnale):

docker logs -f zabbix-server-pgsql

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

6. Porniți un container pentru frontend-ul web Zabbix și conectați-l la containerele Zabbix server și serverului 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

După ce containerele sunt pornite și funcționează, Zabbix server pornește, iar frontend-ul web devine disponibil pentru autentificare.

Implementare Zabbix server (MySQL) cu Java gateway pe RHEL 8–10

Acest exemplu arată cum se implementează un Zabbix server cu un backend MySQL, un Java gateway pentru monitorizarea JMX și o interfață web bazată pe NGINX, toate rulând pe Red Hat Enterprise Linux 8, 9 sau 10.

Pe Red Hat Enterprise Linux, runtime-ul de containere recomandat este Podman în locul Docker. Podman funcționează similar cu Docker, dar nu necesită un serviciu de fundal care să ruleze ca root, ceea ce îl face mai potrivit pentru mediile Red Hat.

1. Creați un pod nou cu numele zabbix și porturile expuse pentru frontend-ul web Zabbix și trapper-ul Zabbix server:

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

2. (Opțional) Porniți un container Zabbix agent în podul 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. Creați directorul ./mysql/ pe hostul RHEL:

mkdir -p ./mysql

4. Porniți un container gol pentru serverul MySQL (înlocuiți zabbix_pwd și root_pwd cu parole puternice și utilizați aceste valori în pașii următori):

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. Urmăriți jurnalele MySQL și așteptați până când MySQL este pregătit să accepte conexiuni (utilizați Ctrl+C pentru a ieși din jurnale):

podman logs -f mysql-server

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

6. Porniți 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. Activați log_bin_trust_function_creators în containerul serverului MySQL. Această setare relaxează temporar restricțiile de securitate pentru funcțiile stocate; setarea va fi dezactivată la pașii următori. Aceasta permite utilizatorului bazei de date Zabbix să creeze funcții stocate fără privilegiul SUPER, necesar în MySQL atunci când este activată înregistrarea binară (implicit începând cu MySQL 8.0). Executați următoarea comandă:

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

8. Porniți un container Zabbix server și conectați-l la Java Gateway și la containerele serverului 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. Urmăriți jurnalele Zabbix server și așteptați până când Zabbix server finalizează inițializarea schemei bazei de date (utilizați Ctrl+C pentru a ieși din jurnale):

podman logs -f zabbix-server-mysql

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

10. Dezactivați log_bin_trust_function_creators în containerul serverului MySQL. Aceasta reactivează restricția de securitate care împiedică utilizatorii fără SUPER să creeze funcții stocate. Executați următoarea comandă:

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

11. Porniți un container pentru frontend-ul web Zabbix și conectați-l la containerele Zabbix server și serverului 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

După ce containerele sunt pornite și funcționează, Zabbix server pornește, iar frontend-ul web devine disponibil pentru autentificare.