[comment]: # ({e62e1497-e62e1497}) # 5 Installazione da container [comment]: # ({/e62e1497-e62e1497}) [comment]: # ({5f71f243-a3ac452e}) ### Panoramica Questa pagina descrive come distribuire Zabbix usando Docker o Docker Compose. [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)](#docker-manual-deployment) ottiene lo stesso risultato distribuendo ogni componente passo dopo passo. [comment]: # ({/5f71f243-a3ac452e}) [comment]: # ({b13b686a-fba82ded}) ### 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](https://docs.docker.com/engine/install/). 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](/manual/installation/requirements#default-port-numbers) 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. [comment]: # ({/b13b686a-fba82ded}) [comment]: # ({6c7779eb-f9acea87}) ### Immagini Docker disponibili Zabbix fornisce un'immagine Docker per ciascun componente Zabbix, tutte pubblicate su [Docker Hub](https://hub.docker.com/u/zabbix). Ogni immagine viene utilizzata per creare un container che esegue quel componente. |Componente Zabbix|Immagine Docker| |--|--------| |Agent|[zabbix/zabbix-agent](https://hub.docker.com/r/zabbix/zabbix-agent/)| |Agent 2|[zabbix/zabbix-agent2](https://hub.docker.com/r/zabbix/zabbix-agent2)| |Server (MySQL)|[zabbix/zabbix-server-mysql](https://hub.docker.com/r/zabbix/zabbix-server-mysql/)| |Server (PostgreSQL)|[zabbix/zabbix-server-pgsql](https://hub.docker.com/r/zabbix/zabbix-server-pgsql/)| |Interfaccia web (Apache + MySQL)|[zabbix/zabbix-web-apache-mysql](https://hub.docker.com/r/zabbix/zabbix-web-apache-mysql/)| |Interfaccia web (Apache + PostgreSQL)|[zabbix/zabbix-web-apache-pgsql](https://hub.docker.com/r/zabbix/zabbix-web-apache-pgsql/)| |Interfaccia web (Nginx + MySQL)|[zabbix/zabbix-web-nginx-mysql](https://hub.docker.com/r/zabbix/zabbix-web-nginx-mysql/)| |Interfaccia web (Nginx + PostgreSQL)|[zabbix/zabbix-web-nginx-pgsql](https://hub.docker.com/r/zabbix/zabbix-web-nginx-pgsql/)| |Proxy (SQLite3)|[zabbix/zabbix-proxy-sqlite3](https://hub.docker.com/r/zabbix/zabbix-proxy-sqlite3/)| |Proxy (MySQL)|[zabbix/zabbix-proxy-mysql](https://hub.docker.com/r/zabbix/zabbix-proxy-mysql/)| |Java gateway|[zabbix/zabbix-java-gateway](https://hub.docker.com/r/zabbix/zabbix-java-gateway/)| |Web service|[zabbix/zabbix-web-service](https://hub.docker.com/r/zabbix/zabbix-web-service)| |SNMP traps|[zabbix/zabbix-snmptraps](https://hub.docker.com/r/zabbix/zabbix-snmptraps/)| ::: noteclassic Per usare [SNMP traps](/manual/config/items/itemtypes/snmptrap), il container SNMP traps deve condividere un volume con il container del server Zabbix o del proxy (vedere [come usare questa immagine](https://hub.docker.com/r/zabbix/zabbix-snmptraps#how-to-use-this-image) su Docker Hub e l'[esempio](#deploy-zabbix-server-postgresql-with-snmp-traps) qui sotto). ::: Tutte le immagini dei componenti Zabbix su Docker Hub si basano sulle ultime versioni principali dei [sistemi operativi supportati](#image-tags). Queste immagini vengono ricostruite automaticamente quando le immagini del sistema operativo sottostante vengono aggiornate. [comment]: # ({/6c7779eb-f9acea87}) [comment]: # ({a7a01d95-e498c2aa}) #### Tag delle immagini Ogni immagine supporta tag per selezionare il sistema operativo di base e la versione di Zabbix: ```default zabbix/:- ``` Valori `` supportati: - `alpine` - Alpine Linux - `ubuntu` - Ubuntu - `centos` - CentOS Stream - `ol` - Oracle Linux - `ltsc2022` - Windows 11 LTSC 2022 (solo agent Zabbix) Valori `` supportati: - `latest` - Ultima versione stabile di Zabbix su Alpine Linux - `-latest` - Ultima versione stabile di Zabbix sul sistema operativo selezionato - `-trunk` - Ultima build di sviluppo (notturna) sul sistema operativo selezionato - `-X.X-latest` - Ultima release minore di Zabbix di una specifica versione maggiore di Zabbix sul sistema operativo selezionato - `-X.X.*` - Specifica release minore di Zabbix sul sistema operativo selezionato Esempi: ```bash # Ultimo proxy Zabbix stabile (SQLite3) su Alpine Linux: docker pull zabbix/zabbix-proxy-sqlite3:latest # Ultimo proxy Zabbix 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.0 di Zabbix server (MySQL) su Alpine Linux: docker pull zabbix/zabbix-server-mysql:alpine-7.0-latest # Versione 7.0.1 di Zabbix server (MySQL) su Alpine Linux: docker pull zabbix/zabbix-server-mysql:alpine-7.0.1 ``` [comment]: # ({/a7a01d95-e498c2aa}) [comment]: # ({a76784bc-c443c22e}) ### Docker Compose Docker Compose è il modo più rapido per distribuire Zabbix. Legge un file di configurazione (Compose file) 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](https://github.com/zabbix/zabbix-docker) 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.0: ```bash git clone https://github.com/zabbix/zabbix-docker.git cd zabbix-docker git checkout 7.0 ``` 2\. (Opzionale) Personalizza la distribuzione con le [variabili d'ambiente](#environment-variables). 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. ```bash # 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`. ::: noteclassic Usa `docker compose ps` per verificare lo stato dei container. Tutti i container (tranne il container `zabbix-docker-server-db-init-1`) dovrebbero avere lo stato `Up`. Se qualcuno mostra `Exited`, controlla i relativi log per gli errori con `docker logs -f `. ::: [comment]: # ({/a76784bc-c443c22e}) [comment]: # ({c9a11d44-0be3c140}) #### 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`](https://github.com/zabbix/zabbix-docker/blob/7.0/.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: ```bash 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_`](https://github.com/zabbix/zabbix-docker/blob/7.0/env_vars/)) controllano la configurazione dei componenti Zabbix. Modifica il relativo file `.env_` prima di eseguire il comando `docker compose`. Ad esempio, puoi regolare il numero di passive poller di Zabbix server e le impostazioni della cache, oltre a configurare il fuso orario dell'interfaccia web, modificando le seguenti variabili: ```ini # env_vars/.env_srv ZBX_STARTPOLLERS=20 ZBX_CACHESIZE=64M ZBX_HISTORYCACHESIZE=32M # env_vars/.env_web PHP_TZ=Europe/Paris ``` ::: noteclassic Le variabili d'ambiente a livello di componente corrispondono ai parametri di configurazione dei componenti Zabbix usando uno stile di denominazione diverso (ad esempio, `ZBX_STARTPOLLERS` corrisponde a [`StartPollers`](/manual/appendix/config/zabbix_server#startpollers)). Alcune variabili sono specifiche di Docker e alcuni parametri di configurazione non possono essere modificati (ad esempio, `PIDFile` e `LogType`). Quando usi le variabili d'ambiente, fai riferimento alla sezione *Environment variables* nella descrizione di ciascuna [immagine Docker](#available-docker-images) del componente su Docker Hub. ::: [comment]: # ({/c9a11d44-0be3c140}) [comment]: # ({15680aeb-7d10f7dc}) #### 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/` - usata dal [container dell'interfaccia web di Zabbix](https://hub.docker.com/r/zabbix/zabbix-web-nginx-mysql#allowed-volumes-for-the-zabbix-web-interface-container) - `zbx_env/usr/` e `zbx_env/var/` - usate dal [container server di Zabbix](https://hub.docker.com/r/zabbix/zabbix-server-mysql#allowed-volumes-for-the-zabbix-server-container) Per ulteriori informazioni su ciascun volume, consulta la sezione *Allowed volumes* nella descrizione dell'[immagine Docker](#available-docker-images) di ciascun componente su Docker Hub. [comment]: # ({/15680aeb-7d10f7dc}) [comment]: # ({4287ef6f-fb9850d6}) #### Makefile Il repository dei Dockerfile di Zabbix fornisce anche un [Makefile](https://github.com/zabbix/zabbix-docker/blob/7.0/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): ```bash # Distribuzione predefinita (server Zabbix, interfaccia web, MySQL, tutto su Alpine Linux) make up # Distribuzione personalizzata (server Zabbix, 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 ``` ::: noteimportant Quando arresti o rimuovi i container, specifica sempre lo stesso tipo di database che è stato distribuito (ad esempio, `make down DB=pgsql`). ::: Per impostazione predefinita, `make up` avvia solo un insieme minimo di servizi (server Zabbix, 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](https://docs.docker.com/compose/how-tos/profiles/): ```bash # 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 ``` [comment]: # ({/4287ef6f-fb9850d6}) [comment]: # ({ec9e0e44-0b4b68c7}) ### 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: ```bash 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.0-latest ``` :::noteimportant Zabbix (7.0.0-7.0.2) non deve essere eseguito come processo `PID1`/`init` nei container. ::: Questo comando: - Scarica la [Docker image](#available-docker-images) `zabbix/zabbix-proxy-sqlite3:alpine-7.0-latest`. - Crea e avvia un container `zabbix-proxy-sqlite3` basato sulla Docker image (con i flag [`--init`](https://docs.docker.com/reference/cli/docker/container/run/#init) e [`-d`](https://docs.docker.com/reference/cli/docker/container/run/#detach)). - Configura il parametro [`Server`](/manual/appendix/config/zabbix_proxy#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. ::: noteclassic Le variabili di ambiente corrispondono ai parametri di configurazione dei componenti Zabbix usando uno stile di denominazione diverso (ad esempio, `ZBX_SERVER_HOST` corrisponde a [`Server`](/manual/appendix/config/zabbix_proxy#server)). Alcune variabili sono specifiche di Docker e alcuni parametri di configurazione non possono essere modificati (ad esempio, `PIDFile` e `LogType`). Quando usi le variabili di ambiente, fai riferimento alla sezione *Environment variables* nella descrizione della [Docker image](#available-docker-images) di ciascun componente su Docker Hub. ::: - 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. ::: noteclassic Per ulteriori informazioni su ciascun volume, consulta la sezione *Allowed volumes* nella descrizione della [Docker image](#available-docker-images) di ciascun componente su Docker Hub. ::: Dopo aver distribuito il container del proxy Zabbix, puoi procedere ad [aggiungere il proxy](/manual/distributed_monitoring/proxies#configuration) nella tua interfaccia web di Zabbix e a [configurare gli host](/manual/config/hosts/host#configuration) da monitorare tramite 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](#available-docker-images) di ciascun componente su Docker Hub. [comment]: # ({/ec9e0e44-0b4b68c7}) [comment]: # ({a807fe94-492bd3ba}) #### Distribuire Zabbix server (MySQL) con Java gateway Questo esempio mostra come distribuire un Zabbix server con backend MySQL, un Java gateway per [monitoraggio JMX](/manual/config/items/itemtypes/jmx_monitoring) 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: ```bash 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): ```bash 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 ``` 3\. Seguire i log di MySQL e attendere finché MySQL non è pronto per le connessioni (usare `Ctrl+C` per uscire dai log): ```bash docker logs -f mysql-server # ... [Server] /usr/sbin/mysqld: ready for connections. ... ``` 4\. Avviare un container Zabbix Java gateway: ```bash docker run --name zabbix-java-gateway -t \ --network=zabbix-net \ --restart unless-stopped \ -d zabbix/zabbix-java-gateway:alpine-7.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](https://dev.mysql.com/doc/refman/8.0/en/stored-programs-logging.html) è abilitato (impostazione predefinita da MySQL 8.0). Eseguire il seguente comando: ```bash 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: ```bash 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-7.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): ```bash 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: ```bash 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: ```bash 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-7.0-latest ``` Dopo che i container sono avviati ed eseguiti, Zabbix server viene avviato e l'interfaccia web è disponibile all'indirizzo `http://localhost`. ::: noteclassic Usare `docker ps` per verificare lo stato dei container. Tutti i container dovrebbero avere lo stato `Up`. Se qualcuno mostra `Exited`, controllarne i log per gli errori con `docker logs -f `. ::: #### Distribuire Zabbix server (PostgreSQL) con SNMP traps Questo esempio mostra come distribuire un Zabbix server con backend PostgreSQL, [SNMP traps](/manual/config/items/itemtypes/snmptrap) 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: ```bash 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): ```bash 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: ```bash 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.0-latest ``` 4\. Avviare un container Zabbix server e collegarlo ai container PostgreSQL server e SNMP traps: ```bash 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-7.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): ```bash 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: ```bash 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-7.0-latest ``` Dopo che i container sono avviati ed eseguiti, Zabbix server viene avviato e l'interfaccia web è disponibile all'indirizzo `http://localhost`. ::: noteclassic Usare `docker ps` per verificare lo stato dei container. Tutti i container dovrebbero avere lo stato `Up`. Se qualcuno mostra `Exited`, controllarne i log per gli errori con `docker logs -f `. ::: #### 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](/manual/config/items/itemtypes/jmx_monitoring) 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: ```bash podman pod create --name zabbix -p 80:8080 -p 10051:10051 ``` 2\. (Opzionale) Avviare un container Zabbix agent nella posizione del pod `zabbix`: ```bash 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-70:latest ``` 3\. Creare una directory `./mysql/` sull'host RHEL: ```bash 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): ```bash 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 ``` 5\. Seguire i log di MySQL e attendere finché MySQL non è pronto per le connessioni (usare `Ctrl+C` per uscire dai log): ```bash podman logs -f mysql-server # ... [Server] /usr/sbin/mysqld: ready for connections. ... ``` 6\. Avviare un container Zabbix Java gateway: ```bash podman run --name zabbix-java-gateway -t \ --restart=always \ --pod=zabbix \ -d registry.connect.redhat.com/zabbix/zabbix-java-gateway-70 ``` 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](https://dev.mysql.com/doc/refman/8.0/en/stored-programs-logging.html) è abilitato (impostazione predefinita da MySQL 8.0). Eseguire il seguente comando: ```bash 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: ```bash 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-70 ``` 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): ```bash 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: ```bash 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: ```bash 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-70 ``` ::: noteclassic Il pod `zabbix` espone la porta `80/TCP` (HTTP) all'host dalla porta `8080/TCP` del container `zabbix-web-mysql`. ::: Dopo che i container sono avviati ed eseguiti, Zabbix server viene avviato e l'interfaccia web è disponibile all'indirizzo `http://localhost`. ::: noteclassic Usare `docker ps` per verificare lo stato dei container. Tutti i container dovrebbero avere lo stato `Up`. Se qualcuno mostra `Exited`, controllarne i log per gli errori con `docker logs -f `. ::: [comment]: # ({/a807fe94-492bd3ba})