Instalacja z kontenerów

Przegląd

Ta strona opisuje, jak wdrożyć Zabbix przy użyciu Docker lub Docker Compose.

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

Docker (wdrożenie ręczne) pozwala osiągnąć ten sam rezultat przez wdrażanie każdego komponentu krok po kroku, co może odpowiadać użytkownikom, którzy już zarządzają istniejącym środowiskiem Docker.

Wymagania wstępne

Przed rozpoczęciem upewnij się, że Docker jest zainstalowany w systemie. Jeśli nie, postępuj zgodnie z przewodnikiem instalacji Dockera.

Niektóre komponenty Zabbix wymagają, aby na hoście uruchamiającym Docker były otwarte określone porty (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 agent 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, a wszystkie są publikowane w Docker Hub. Każdy obraz jest używany do utworzenia kontenera uruchamiającego dany komponent.

Wszystkie obrazy komponentów Zabbix w Docker Hub są automatycznie przebudowywane po zaktualizowaniu ich obrazów bazowych.

Tagi obrazów

Każdy obraz obsługuje tagi służące do wyboru bazowego systemu operacyjnego i wersji Zabbix:

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

Obsługiwane wartości <os>:

• alpine - Alpine Linux
• ubuntu - Ubuntu
• ol - Oracle Linux
• ltsc2019 - Windows 10 LTSC 2019 (tylko Zabbix agent)
• ltsc2022 - Windows 11 LTSC 2022 (tylko Zabbix agent)

Obsługiwane wartości <version>:

• latest - Najnowsza stabilna wersja w Alpine Linux
• <os>-latest - Najnowsza stabilna wersja w wybranym systemie operacyjnym
• <os>-trunk - Najnowsza wersja rozwojowa (nightly) w wybranym systemie operacyjnym
• <os>-X.X-latest - Najnowsze wydanie poboczne określonej wersji głównej w wybranym systemie operacyjnym
• <os>-X.X.* - Określona wersja poboczna w wybranym systemie operacyjnym

Przykłady:

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

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

# Najnowsza wersja rozwojowa (nightly) Zabbix server (MySQL) w Ubuntu:
docker pull zabbix/zabbix-server-mysql:ubuntu-trunk

# Najnowsze wydanie poboczne 8.0 Zabbix server (MySQL) w Alpine Linux:
docker pull zabbix/zabbix-server-mysql:alpine-8.0-latest

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

Docker Compose

Docker Compose to najszybszy sposób wdrożenia Zabbix. Odczytuje plik konfiguracyjny (plik Compose) i obsługuje całą konfigurację — pobieranie obrazów Docker, tworzenie wewnętrznej sieci między kontenerami, konfigurowanie pamięci masowej, inicjalizację bazy danych oraz uruchamianie wszystkiego we właściwej kolejności.

Repozytorium official Zabbix Dockerfiles udostępnia gotowe do użycia pliki Docker Compose oraz system konfiguracji oparty na .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.0:

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

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

3. Wdróż domyślną konfigurację Zabbix:

# 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

Spowoduje to uruchomienie serwera Zabbix, interfejsu webowego (działającego na Nginx) oraz backendu bazy danych (MySQL lub PostgreSQL), z których każdy działa we własnym kontenerze na Alpine Linux (domyślnie). Po uruchomieniu kontenerów (zwykle w ciągu 1–3 minut) serwer Zabbix zostanie uruchomiony, a interfejs webowy będzie dostępny pod adresem http://localhost.

Możesz sprawdzić, czy wszystko działa, za pomocą następującego polecenia:

docker compose ps

Wszystkie kontenery powinny mieć status running. Jeśli którykolwiek ma status exited, sprawdź jego logi (docker logs <container-name>).

Zmienne środowiskowe

Zarówno zachowanie Docker Compose, jak i 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 są używane. Możesz używać tych zmiennych inline przed poleceniem docker compose lub edytować plik .env.

Na przykład poniższe polecenie wdraża kompletną, wielokontenerową konfigurację Zabbix z użyciem obrazu opartego na Ubuntu (zamiast domyślnego Alpine Linux) oraz udostępnia interfejs WWW przez 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 edytuj odpowiedni plik .env_<component>.

Na przykład możesz dostosować liczbę pasywnych pollerów serwera Zabbix i ustawienia pamięci podręcznej, a także skonfigurować strefę czasową interfejsu WWW, 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 Zabbix Dockerfiles udostępnia również Makefile jako skrót do typowych zadań Docker Compose. Zamiast używać pełnego polecenia docker compose, możesz używać krótszych poleceń make (uruchom make help, aby zobaczyć dostępne opcje):

# Domyślne wdrożenie (serwer Zabbix, interfejs web, MySQL, wszystko na Alpine Linux)
make up

# Własne wdrożenie (serwer Zabbix, interfejs web 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, interfejs web i baza danych). Dzięki temu konfiguracja pozostaje lekka i nie uruchamia komponentów, które mogą nie być potrzebne. Aby uwzględnić dodatkowe komponenty, możesz użyć następujących profili Compose:

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

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

Docker (wdrożenie ręczne)

Użyj wdrożenia ręcznego, gdy chcesz wdrożyć Zabbix krok po kroku, uruchamiać poszczególne komponenty, zintegrować je z istniejącym środowiskiem lub użyć 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.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

To polecenie:

• Pobiera obraz Docker zabbix/zabbix-proxy-sqlite3:alpine-8.0-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. Parametr ten 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. Zwróć uwagę, że inne zmienne wymagane do działania aktywnego proxy używają wartości domyślnych i mogą zostać pominięte.

• Podłącza lokalizację przechowywania zarządzaną przez Docker (np. /var/lib/docker/volumes/zabbix-proxy-data/) do katalogu /var/lib/zabbix kontenera, aby dane proxy Zabbix były przechowywane trwale, nawet jeśli kontener zostanie usunięty.

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

Poniższe przykłady obejmują trzy dodatkowe scenariusze wdrożenia:

• serwer Zabbix (MySQL) z Java gateway
• serwer Zabbix (PostgreSQL) z pułapkami SNMP
• serwer Zabbix (MySQL) z Java gateway w RHEL 8

Więcej przykładów znajdziesz w opisie obrazu Docker każdego komponentu na Docker Hub.

Wdróż serwer Zabbix (MySQL) z Java gateway

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 (zamień zabbix_pwd i root_pwd na silne hasła):

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. Uruchom kontener 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. Uruchom kontener serwera Zabbix i połącz go z kontenerem serwera MySQL (zamień zabbix_pwd i root_pwd na te same hasła, których użyto w kroku 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. Uruchom kontener interfejsu webowego Zabbix i połącz go z kontenerami serwera Zabbix oraz serwera MySQL (zamień zabbix_pwd i root_pwd na te same hasła, których użyto w kroku 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

Po uruchomieniu kontenerów (zwykle w ciągu 1–3 minut) serwer Zabbix zostanie uruchomiony, a interfejs webowy będzie dostępny pod adresem http://localhost.

Wdróż serwer Zabbix (PostgreSQL) z pułapkami SNMP

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 (zamień zabbix_pwd na silne hasło):

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

4. Uruchom kontener serwera Zabbix, połącz go z kontenerem serwera PostgreSQL oraz kontenerem pułapek SNMP (zamień zabbix_pwd na to samo hasło, którego użyto w kroku 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. Uruchom kontener interfejsu webowego Zabbix i połącz go z kontenerami serwera Zabbix oraz serwera PostgreSQL (zamień zabbix_pwd na to samo hasło, którego użyto w kroku 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

Po uruchomieniu kontenerów (zwykle w ciągu 1–3 minut) serwer Zabbix zostanie uruchomiony, a interfejs webowy będzie dostępny pod adresem http://localhost.

Wdróż serwer Zabbix (MySQL) z Java gateway w RHEL 8

W systemie Red Hat Enterprise Linux 8 zalecanym środowiskiem uruchomieniowym kontenerów jest Podman zamiast Docker. Podman działa podobnie do Docker, ale nie wymaga usługi działającej w tle jako root, co sprawia, że lepiej pasuje do środowisk Red Hat.

1. Utwórz nowy pod o nazwie zabbix z udostępnionymi portami dla interfejsu webowego Zabbix oraz trappera serwera Zabbix:

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

2. (Opcjonalnie) Uruchom kontener Zabbix agent 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 (zamień zabbix_pwd i root_pwd na silne hasła):

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. Uruchom kontener 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. Uruchom kontener serwera Zabbix (zamień zabbix_pwd i root_pwd na te same hasła, których użyto w kroku 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. Uruchom kontener interfejsu webowego Zabbix (zamień zabbix_pwd i root_pwd na te same hasła, których użyto w kroku 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