Instalacja z kontenerów

Przegląd

Ta strona opisuje, jak wdrożyć Zabbix za pomocą Docker lub Docker Compose.

Docker Compose to najszybszy sposób wdrożenia Zabbix. Odczytuje plik konfiguracyjny i automatycznie uruchamia wszystkie kontenery składające się na kompletne środowisko Zabbix, we właściwej kolejności.

Docker (ręczne wdrożenie) osiąga ten sam rezultat, wdrażając każdy komponent krok po kroku.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że w systemie jest zainstalowany Docker (1.12.0 lub nowszy). Jeśli nie jest zainstalowany, postępuj zgodnie z instrukcją instalacji platformy Docker. W przypadku wdrażania za pomocą Docker Compose wymagany jest również Docker Compose (2.24.0 lub nowszy).

Niektóre komponenty Zabbix wymagają otwarcia określonych portów na hoście, na którym działa Docker (np. 10051/TCP dla serwera Zabbix, 162/UDP dla pułapek SNMP). Pełną listę portów używanych przez komponenty Zabbix można znaleźć w sekcji Wymagania. W przypadku serwera Zabbix i agenta domyślny port można zmienić, ustawiając zmienną środowiskową ZBX_LISTENPORT w odpowiednim kontenerze.

Dostępne obrazy Docker

Zabbix udostępnia obraz Docker dla każdego komponentu Zabbix. Wszystkie obrazy są publikowane w serwisie Docker Hub. Każdy obraz służy do utworzenia kontenera uruchamiającego dany komponent.

Wszystkie obrazy komponentów Zabbix w serwisie Docker Hub są oparte na najnowszych głównych wersjach obsługiwanych systemów operacyjnych. Obrazy te są automatycznie przebudowywane po zaktualizowaniu bazowych obrazów systemu operacyjnego.

Tagi obrazów

Każdy obraz obsługuje tagi umożliwiające wybranie bazowego systemu operacyjnego i wersji Zabbix:

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

Obsługiwane wartości <os>:

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

Obsługiwane wartości <version>:

• latest - Najnowsza stabilna wersja Zabbix w systemie Alpine Linux
• <os>-latest - Najnowsza stabilna wersja Zabbix w wybranym systemie operacyjnym
• <os>-trunk - Najnowsza kompilacja rozwojowa (nocna) w wybranym systemie operacyjnym
• <os>-X.X-latest - Najnowsze wydanie pomniejsze Zabbix w ramach określonej głównej wersji Zabbix w wybranym systemie operacyjnym
• <os>-X.X.* - Określone wydanie pomniejsze Zabbix w wybranym systemie operacyjnym

Przykłady:

# Najnowszy stabilny proxy Zabbix (SQLite3) w systemie Alpine Linux:
docker pull zabbix/zabbix-proxy-sqlite3:latest

# Najnowszy stabilny proxy Zabbix (SQLite3) w systemie Ubuntu:
docker pull zabbix/zabbix-proxy-sqlite3:ubuntu-latest

# Najnowsza kompilacja rozwojowa (nocna) serwera Zabbix (MySQL) w systemie Ubuntu:
docker pull zabbix/zabbix-server-mysql:ubuntu-trunk

# Najnowsze wydanie pomniejsze Zabbix 8.2 serwera Zabbix (MySQL) w systemie Alpine Linux:
docker pull zabbix/zabbix-server-mysql:alpine-8.2-latest

# Wersja 8.2.1 serwera Zabbix (MySQL) w systemie Alpine Linux:
docker pull zabbix/zabbix-server-mysql:alpine-8.2.1

Docker Compose

Docker Compose to najszybszy sposób wdrożenia Zabbix. Odczytuje plik konfiguracyjny (plik Compose) i obsługuje całą konfigurację — pobiera obrazy Docker, tworzy wewnętrzną sieć między kontenerami, konfiguruje pamięć masową, inicjalizuje bazę danych i uruchamia wszystko we właściwej kolejności.

Repozytorium oficjalnych plików Dockerfile Zabbix udostępnia gotowe do użycia pliki Docker Compose oraz system konfiguracji oparty na pliku .env, obsługujący różne systemy operacyjne, backendy baz danych i konfigurację komponentów Zabbix.

1. Sklonuj repozytorium, przejdź do niego i przełącz się na wersję 8.2:

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

2. (Opcjonalnie) Dostosuj wdrożenie za pomocą zmiennych środowiskowych. Ten krok można pominąć w przypadku konfiguracji domyślnej.

3. Wdróż konfigurację domyślną — serwer Zabbix, frontend (działający na NGINX) oraz backend bazy danych (MySQL lub PostgreSQL), z których każdy działa we własnym kontenerze w systemie Alpine Linux.

# Z MySQL jako bazą danych:
docker compose -f ./compose.yaml up -d

# Z PostgreSQL jako bazą danych:
docker compose -f ./compose_pgsql.yaml up -d

Po uruchomieniu kontenerów (zwykle w ciągu 1–3 minut) serwer Zabbix uruchamia się, a frontend staje się dostępny do logowania.

Zmienne środowiskowe

Zachowanie Docker Compose oraz konfigurację komponentów Zabbix można dostosować za pomocą zmiennych środowiskowych.

Zmienne na poziomie Compose (zdefiniowane w pliku .env) określają, które obrazy Docker, porty i zakresy adresów IP sieci mają być używane. Można używać tych zmiennych w wierszu poleceń przed poleceniem docker compose lub edytować plik .env.

Na przykład poniższe polecenie wdraża kompletną konfigurację Zabbix składającą się z wielu kontenerów, używając obrazu opartego na Ubuntu (zamiast domyślnego Alpine Linux) i udostępniając frontend za pośrednictwem NGINX na niestandardowych portach HTTP (8282) i HTTPS (8443):

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

Zmienne na poziomie komponentu (zdefiniowane w plikach env_vars/.env_<component>) sterują konfiguracją komponentów Zabbix. Przed uruchomieniem polecenia docker compose należy edytować odpowiedni plik .env_<component>.

Na przykład można dostosować liczbę pasywnych pollerów serwera Zabbix i ustawienia pamięci podręcznej, a także skonfigurować strefę czasową frontendu, edytując następujące zmienne:

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

# env_vars/.env_web
PHP_TZ=Europe/Paris

Wolumeny

Docker Compose przechowuje trwałe dane w katalogu zbx_env/ utworzonym obok pliku Compose. Ten katalog zachowuje dane komponentów między restartami i aktualizacjami kontenerów.

Zawartość zbx_env/ jest wstępnie zdefiniowana dla obrazu każdego komponentu. Na przykład:

• zbx_env/etc/ — używany przez kontener interfejsu webowego Zabbix
• zbx_env/usr/ i zbx_env/var/ — używane przez kontener serwera Zabbix

Więcej informacji o każdym wolumenie można znaleźć w sekcji Allowed volumes w opisie obrazu Docker każdego komponentu w Docker Hub.

Makefile

Repozytorium Dockerfiles Zabbix udostępnia również plik Makefile, który stanowi skrót dla typowych zadań Docker Compose. Zamiast używać pełnego polecenia docker compose, możesz używać krótszych poleceń make (uruchom make help, aby wyświetlić dostępne opcje):

# Wdrożenie domyślne (serwer Zabbix, frontend, MySQL, wszystko na Alpine Linux)
make up

# Wdrożenie niestandardowe (serwer Zabbix, frontend z niestandardowymi portami NGINX, PostgreSQL, wszystko na Ubuntu)
make up \
  OS=ubuntu \
  DB=pgsql \
  ZABBIX_WEB_NGINX_HTTP_PORT=8282 \
  ZABBIX_WEB_NGINX_HTTPS_PORT=8443

Domyślnie make up uruchamia tylko minimalny zestaw usług (serwer Zabbix, frontend i bazę danych). Dzięki temu konfiguracja pozostaje lekka i nie są uruchamiane komponenty, które mogą nie być potrzebne. Aby uwzględnić dodatkowe komponenty, możesz użyć następujących profili Compose:

# Wdrożenie domyślne + agent Zabbix, Java gateway, usługa webowa i pułapki SNMP:
make up COMPOSE_PROFILES=full

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

Docker (wdrażanie ręczne)

Użyj wdrażania ręcznego, jeśli chcesz wdrażać Zabbix krok po kroku, uruchamiać poszczególne komponenty, integrować je z istniejącym środowiskiem lub korzystać z alternatywnego środowiska uruchomieniowego kontenerów, takiego jak Podman.

Na przykład, aby wdrożyć proxy Zabbix, uruchom następujące polecenie:

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.2-latest

To polecenie:

• Pobiera obraz Docker zabbix/zabbix-proxy-sqlite3:alpine-8.2-latest.

• Tworzy i uruchamia kontener zabbix-proxy-sqlite3 na podstawie obrazu Docker (z flagami --init i -d).

• Konfiguruje parametr Server proxy Zabbix za pomocą zmiennej środowiskowej ZBX_SERVER_HOST. Ten parametr określa adres IP serwera Zabbix, z którego proxy będzie pobierać dane konfiguracyjne i do którego będzie wysyłać zebrane dane. Należy pamiętać, że inne zmienne wymagane do działania aktywnego proxy używają wartości domyślnych i można je pominąć.

• Łączy lokalizację przechowywania zarządzaną przez Docker (np. /var/lib/docker/volumes/zabbix-proxy-data/) z katalogiem /var/lib/zabbix kontenera, dzięki czemu dane proxy Zabbix są przechowywane trwale, nawet jeśli kontener zostanie usunięty.

Po wdrożeniu kontenera proxy Zabbix możesz przejść do dodania proxy w frontend Zabbix i skonfigurowania hostów, które mają być monitorowane przez to proxy.

Poniższe przykłady obejmują trzy dodatkowe scenariusze wdrażania:

• Serwer Zabbix (MySQL) z Java gateway
• Serwer Zabbix (PostgreSQL) z pułapkami SNMP
• Serwer Zabbix (MySQL) z Java gateway w systemie RHEL 8–10

Więcej przykładów można znaleźć w opisie obrazu Docker każdego komponentu w serwisie Docker Hub.

Wdrażanie serwera Zabbix (MySQL) z Java gateway

Ten przykład pokazuje, jak wdrożyć serwer Zabbix z backendem MySQL, Java gateway do monitorowania JMX oraz interfejsem webowym opartym na NGINX.

1. Utwórz dedykowaną sieć Docker, aby wszystkie kontenery komponentów Zabbix mogły komunikować się ze sobą za pomocą nazw kontenerów:

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

2. Uruchom pusty kontener serwera MySQL (zastąp zabbix_pwd i root_pwd silnymi hasłami i użyj tych wartości w kolejnych krokach):

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. Śledź logi MySQL i poczekaj, aż MySQL będzie gotowy na połączenia (użyj Ctrl+C, aby wyjść z logów):

docker logs -f mysql-server

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

4. Uruchom kontener Java gateway Zabbix:

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

5. Włącz log_bin_trust_function_creators w kontenerze serwera MySQL. Tymczasowo zmniejsza to ograniczenia bezpieczeństwa dotyczące funkcji składowanych; ustawienie zostanie wyłączone w kolejnych krokach. Umożliwia ono użytkownikowi bazy danych Zabbix tworzenie funkcji składowanych bez uprawnienia SUPER, wymaganego przez MySQL, gdy włączone jest logowanie binarne (domyślnie od MySQL 8.2). Uruchom następujące polecenie:

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

6. Uruchom kontener serwera Zabbix i połącz go z kontenerami Java Gateway oraz serwera 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.2-latest

7. Śledź logi serwera Zabbix i poczekaj, aż serwer Zabbix zakończy inicjalizację schematu bazy danych (użyj Ctrl+C, aby wyjść z logów):

docker logs -f zabbix-server-mysql

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

8. Wyłącz log_bin_trust_function_creators w kontenerze serwera MySQL. Ponownie wymusza to ograniczenie bezpieczeństwa, które uniemożliwia użytkownikom bez uprawnień SUPER tworzenie funkcji składowanych. Uruchom następujące polecenie:

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

9. Uruchom kontener frontend Zabbix i połącz go z kontenerami serwera Zabbix oraz serwera 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.2-latest

Po uruchomieniu kontenerów serwer Zabbix rozpocznie działanie, a frontend będzie dostępny do logowania.

Wdrażanie serwera Zabbix (PostgreSQL) z pułapkami SNMP

Ten przykład pokazuje, jak wdrożyć serwer Zabbix z backendem PostgreSQL, pułapkami SNMP oraz interfejsem webowym opartym na NGINX.

1. Utwórz dedykowaną sieć Docker, aby wszystkie kontenery komponentów Zabbix mogły komunikować się ze sobą za pomocą nazw kontenerów:

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

2. Uruchom pusty kontener serwera PostgreSQL (zastąp zabbix_pwd silnym hasłem i użyj tej wartości w kolejnych krokach):

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. Uruchom kontener pułapek SNMP Zabbix:

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.2-latest

4. Uruchom kontener serwera Zabbix i połącz go z kontenerami serwera PostgreSQL oraz pułapek 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.2-latest

5. Śledź logi serwera Zabbix i poczekaj, aż serwer Zabbix zakończy inicjalizację schematu bazy danych (użyj Ctrl+C, aby wyjść z logów):

docker logs -f zabbix-server-pgsql

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

6. Uruchom kontener frontend Zabbix i połącz go z kontenerami serwera Zabbix oraz serwera 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.2-latest

Po uruchomieniu kontenerów serwer Zabbix rozpocznie działanie, a frontend będzie dostępny do logowania.

Wdrażanie serwera Zabbix (MySQL) z Java gateway w systemie RHEL 8–10

Ten przykład pokazuje, jak wdrożyć serwer Zabbix z backendem MySQL, Java gateway do monitorowania JMX oraz interfejsem webowym opartym na NGINX, przy czym wszystkie komponenty działają w systemie Red Hat Enterprise Linux 8, 9 lub 10.

W systemie Red Hat Enterprise Linux zalecanym środowiskiem uruchomieniowym kontenerów jest Podman zamiast Dockera. Podman działa podobnie do Dockera, ale nie wymaga działającej w tle usługi uruchomionej jako root, dzięki czemu lepiej pasuje do środowisk Red Hat.

1. Utwórz nowy pod o nazwie zabbix i udostępnij porty dla interfejsu webowego Zabbix oraz trappera serwera Zabbix:

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

2. (Opcjonalnie) Uruchom kontener agenta Zabbix w podzie 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. Utwórz katalog ./mysql/ na hoście RHEL:

mkdir -p ./mysql

4. Uruchom pusty kontener serwera MySQL (zastąp zabbix_pwd i root_pwd silnymi hasłami i użyj tych wartości w kolejnych krokach):

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. Śledź logi MySQL i poczekaj, aż MySQL będzie gotowy na połączenia (użyj Ctrl+C, aby wyjść z logów):

podman logs -f mysql-server

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

6. Uruchom kontener Java gateway Zabbix:

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

7. Włącz log_bin_trust_function_creators w kontenerze serwera MySQL. Tymczasowo zmniejsza to ograniczenia bezpieczeństwa dotyczące funkcji składowanych; ustawienie zostanie wyłączone w kolejnych krokach. Umożliwia ono użytkownikowi bazy danych Zabbix tworzenie funkcji składowanych bez uprawnienia SUPER, wymaganego przez MySQL, gdy włączone jest logowanie binarne (domyślnie od MySQL 8.0). Uruchom następujące polecenie:

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

8. Uruchom kontener serwera Zabbix i połącz go z kontenerami Java Gateway oraz serwera 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. Śledź logi serwera Zabbix i poczekaj, aż serwer Zabbix zakończy inicjalizację schematu bazy danych (użyj Ctrl+C, aby wyjść z logów):

podman logs -f zabbix-server-mysql

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

10. Wyłącz log_bin_trust_function_creators w kontenerze serwera MySQL. Ponownie wymusza to ograniczenie bezpieczeństwa, które uniemożliwia użytkownikom bez uprawnień SUPER tworzenie funkcji składowanych. Uruchom następujące polecenie:

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

11. Uruchom kontener frontend Zabbix i połącz go z kontenerami serwera Zabbix oraz serwera 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

Po uruchomieniu kontenerów serwer Zabbix rozpocznie działanie, a frontend będzie dostępny do logowania.