[comment]: # ({e62e1497-e62e1497}) # 5 Installation from containers [comment]: # ({/e62e1497-e62e1497}) [comment]: # ({5f71f243-a3ac452e}) ### Przegląd Ta strona opisuje, jak wdrożyć Zabbix przy użyciu Docker lub Docker Compose. [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)](#docker-manual-deployment) osiąga ten sam rezultat, wdrażając każdy komponent krok po kroku. [comment]: # ({/5f71f243-a3ac452e}) [comment]: # ({b13b686a-fba82ded}) ### Wymagania wstępne Przed rozpoczęciem upewnij się, że Docker (1.12.0 lub nowszy) jest zainstalowany w systemie. Jeśli nie, skorzystaj z [przewodnika instalacji Dockera](https://docs.docker.com/engine/install/). W przypadku wdrożenia 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 uruchamiającym Docker (np. 10051/TCP dla serwera Zabbix, 162/UDP dla pułapek SNMP). Zobacz [Wymagania](/manual/installation/requirements#default-port-numbers), aby uzyskać pełną listę portów używanych przez komponenty Zabbix. Dla serwera Zabbix i agent domyślny port można zmienić, ustawiając zmienną środowiskową `ZBX_LISTENPORT` w odpowiednim kontenerze. [comment]: # ({/b13b686a-fba82ded}) [comment]: # ({6c7779eb-f9acea87}) ### Dostępne obrazy Docker Zabbix udostępnia obraz Docker dla każdego komponentu Zabbix, a wszystkie są publikowane w serwisie [Docker Hub](https://hub.docker.com/u/zabbix). Każdy obraz służy do utworzenia kontenera uruchamiającego dany komponent. |Komponent Zabbix|Obraz 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)| |Serwer (MySQL)|[zabbix/zabbix-server-mysql](https://hub.docker.com/r/zabbix/zabbix-server-mysql/)| |Serwer (PostgreSQL)|[zabbix/zabbix-server-pgsql](https://hub.docker.com/r/zabbix/zabbix-server-pgsql/)| |Frontend (Apache + MySQL)|[zabbix/zabbix-web-apache-mysql](https://hub.docker.com/r/zabbix/zabbix-web-apache-mysql/)| |Frontend (Apache + PostgreSQL)|[zabbix/zabbix-web-apache-pgsql](https://hub.docker.com/r/zabbix/zabbix-web-apache-pgsql/)| |Frontend (Nginx + MySQL)|[zabbix/zabbix-web-nginx-mysql](https://hub.docker.com/r/zabbix/zabbix-web-nginx-mysql/)| |Frontend (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/)| |Usługa web|[zabbix/zabbix-web-service](https://hub.docker.com/r/zabbix/zabbix-web-service)| |Pułapki SNMP|[zabbix/zabbix-snmptraps](https://hub.docker.com/r/zabbix/zabbix-snmptraps/)| ::: noteclassic Aby korzystać z [pułapek SNMP](/manual/config/items/itemtypes/snmptrap), kontener pułapek SNMP musi współdzielić wolumin z kontenerem serwera Zabbix lub proxy (zobacz [jak używać tego obrazu](https://hub.docker.com/r/zabbix/zabbix-snmptraps#how-to-use-this-image) w Docker Hub oraz poniższy [przykład](#deploy-zabbix-server-postgresql-with-snmp-traps)). ::: Wszystkie obrazy komponentów Zabbix w Docker Hub są oparte na najnowszych głównych wersjach [obsługiwanych systemów operacyjnych](#image-tags). Obrazy te są automatycznie przebudowywane po zaktualizowaniu bazowych obrazów systemu operacyjnego. [comment]: # ({/6c7779eb-f9acea87}) [comment]: # ({a7a01d95-e498c2aa}) #### Tagi obrazów Każdy obraz obsługuje tagi służące do wyboru bazowego systemu operacyjnego i wersji Zabbixa: ```default zabbix/:- ``` Obsługiwane wartości ``: - `alpine` - Alpine Linux - `ubuntu` - Ubuntu - `centos` - CentOS Stream - `ol` - Oracle Linux - `ltsc2022` - Windows 11 LTSC 2022 (tylko agent Zabbixa) Obsługiwane wartości ``: - `latest` - Najnowsza stabilna wersja Zabbixa na Alpine Linux - `-latest` - Najnowsza stabilna wersja Zabbixa dla wybranego systemu operacyjnego - `-trunk` - Najnowsza wersja rozwojowa (nightly) dla wybranego systemu operacyjnego - `-X.X-latest` - Najnowsze wydanie pomocnicze Zabbixa dla określonej głównej wersji Zabbixa na wybranym systemie operacyjnym - `-X.X.*` - Określone wydanie pomocnicze Zabbixa na wybranym systemie operacyjnym Przykłady: ```bash # Najnowszy stabilny proxy Zabbixa (SQLite3) na Alpine Linux: docker pull zabbix/zabbix-proxy-sqlite3:latest # Najnowszy stabilny proxy Zabbixa (SQLite3) na Ubuntu: docker pull zabbix/zabbix-proxy-sqlite3:ubuntu-latest # Najnowsza wersja rozwojowa (nightly) serwera Zabbixa (MySQL) na Ubuntu: docker pull zabbix/zabbix-server-mysql:ubuntu-trunk # Najnowsze wydanie pomocnicze 7.0 serwera Zabbixa (MySQL) na Alpine Linux: docker pull zabbix/zabbix-server-mysql:alpine-7.0-latest # Wersja 7.0.1 serwera Zabbixa (MySQL) na Alpine Linux: docker pull zabbix/zabbix-server-mysql:alpine-7.0.1 ``` [comment]: # ({/a7a01d95-e498c2aa}) [comment]: # ({a76784bc-c443c22e}) ### 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 sieci wewnętrznej między kontenerami, konfigurację magazynu danych, inicjalizację bazy danych oraz uruchamianie wszystkiego we właściwej kolejności. Repozytorium [oficjalnych plików Dockerfile Zabbix](https://github.com/zabbix/zabbix-docker) 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ę 7.0: ```bash git clone https://github.com/zabbix/zabbix-docker.git cd zabbix-docker git checkout 7.0 ``` 2\. (Opcjonalnie) Dostosuj wdrożenie za pomocą [zmiennych środowiskowych](#environment-variables). Ten krok można pominąć w przypadku domyślnej konfiguracji. 3\. Wdróż domyślną konfigurację — serwer Zabbix, interfejs webowy (działający na Nginx) oraz backend bazy danych (MySQL lub PostgreSQL), każdy uruchomiony w osobnym kontenerze na Alpine Linux. ```bash # 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 zostanie uruchomiony, a interfejs webowy będzie dostępny pod adresem `http://localhost`. ::: noteclassic Użyj `docker compose ps`, aby sprawdzić stan kontenerów. Wszystkie kontenery (z wyjątkiem kontenera `zabbix-docker-server-db-init-1`) powinny mieć status `Up`. Jeśli którykolwiek ma status `Exited`, sprawdź jego logi pod kątem błędów za pomocą `docker logs -f `. ::: [comment]: # ({/a76784bc-c443c22e}) [comment]: # ({c9a11d44-0be3c140}) #### 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`](https://github.com/zabbix/zabbix-docker/blob/7.0/.env)) kontrolują, które obrazy Docker, porty i zakresy adresów IP sieci są używane. Możesz używać tych zmiennych bezpośrednio przed poleceniem `docker compose` albo 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 frontend przez Nginx na niestandardowych portach HTTP (8282) i HTTPS (8443): ```bash 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_`](https://github.com/zabbix/zabbix-docker/blob/7.0/env_vars/)) kontrolują konfigurację komponentów Zabbix. Przed uruchomieniem polecenia `docker compose` edytuj odpowiedni plik `.env_`. Na przykład możesz dostosować liczbę pasywnych pollerów serwera Zabbix oraz ustawienia pamięci podręcznej, a także skonfigurować strefę czasową frontendu, edytując następujące zmienne: ```ini # env_vars/.env_srv ZBX_STARTPOLLERS=20 ZBX_CACHESIZE=64M ZBX_HISTORYCACHESIZE=32M # env_vars/.env_web PHP_TZ=Europe/Paris ``` ::: noteclassic Zmienne środowiskowe na poziomie komponentu odpowiadają parametrom konfiguracji komponentów Zabbix, ale używają innego stylu nazewnictwa (np. `ZBX_STARTPOLLERS` odpowiada [`StartPollers`](/manual/appendix/config/zabbix_server#startpollers)). Niektóre zmienne są specyficzne dla Dockera, a niektórych parametrów konfiguracji nie można zmienić (np. `PIDFile` i `LogType`). Podczas korzystania ze zmiennych środowiskowych zapoznaj się z sekcją *Environment variables* w opisie każdego komponentu [obrazu Docker](#available-docker-images) na Docker Hub. ::: [comment]: # ({/c9a11d44-0be3c140}) [comment]: # ({15680aeb-7d10f7dc}) #### Wolumeny Docker Compose przechowuje trwałe dane w katalogu `zbx_env/` utworzonym obok pliku Compose. Katalog ten zachowuje dane komponentów między ponownymi uruchomieniami kontenerów i aktualizacjami. Zawartość `zbx_env/` jest z góry zdefiniowana dla obrazu każdego komponentu. Na przykład: - `zbx_env/etc/` - używany przez [kontener interfejsu web Zabbix](https://hub.docker.com/r/zabbix/zabbix-web-nginx-mysql#allowed-volumes-for-the-zabbix-web-interface-container) - `zbx_env/usr/` i `zbx_env/var/` - używane przez [kontener serwera Zabbix](https://hub.docker.com/r/zabbix/zabbix-server-mysql#allowed-volumes-for-the-zabbix-server-container) Więcej informacji o każdym wolumenie można znaleźć w sekcji *Allowed volumes* w opisie obrazu Docker każdego komponentu ([obrazy Docker](#available-docker-images)) na Docker Hub. [comment]: # ({/15680aeb-7d10f7dc}) [comment]: # ({4287ef6f-fb9850d6}) #### Makefile Repozytorium Zabbix Dockerfiles udostępnia również plik [Makefile](https://github.com/zabbix/zabbix-docker/blob/7.0/Makefile) jako skrót dla typowych zadań Docker Compose. Zamiast używać pełnego polecenia `docker compose`, można korzystać z krótszych poleceń `make` (uruchom `make help`, aby zobaczyć dostępne opcje): ```bash # Domyślne wdrożenie (serwer Zabbix, frontend, MySQL, wszystko na Alpine Linux) make up # Własne wdrożenie (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 ``` ::: noteimportant Podczas zatrzymywania lub usuwania kontenerów zawsze podaj ten sam typ bazy danych, który został wdrożony (np. `make down DB=pgsql`). ::: Domyślnie `make up` uruchamia tylko minimalny zestaw usług (serwer Zabbix, frontend i baza danych). Dzięki temu konfiguracja pozostaje lekka i nie uruchamia komponentów, które mogą nie być potrzebne. Aby dołączyć dodatkowe komponenty, można użyć następujących [profili Compose](https://docs.docker.com/compose/how-tos/profiles/): ```bash # 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 ``` [comment]: # ({/4287ef6f-fb9850d6}) [comment]: # ({ec9e0e44-0b4b68c7}) ### Docker (ręczne wdrożenie) Użyj ręcznego wdrożenia, gdy 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: ```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) nie może być uruchamiany jako proces `PID1`/`init` w kontenerach. ::: To polecenie: - Pobiera obraz Docker `zabbix/zabbix-proxy-sqlite3:alpine-7.0-latest` [Docker image](#available-docker-images). - Tworzy i uruchamia kontener `zabbix-proxy-sqlite3` na podstawie obrazu Docker (z flagami [`--init`](https://docs.docker.com/reference/cli/docker/container/run/#init) i [`-d`](https://docs.docker.com/reference/cli/docker/container/run/#detach)). - Konfiguruje parametr proxy Zabbix [`Server`](/manual/appendix/config/zabbix_proxy#server) 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. Zwróć uwagę, że inne zmienne wymagane do działania aktywnego proxy używają wartości domyślnych i mogą zostać pominięte. ::: noteclassic Zmienne środowiskowe odpowiadają parametrom konfiguracji komponentów Zabbix, ale używają innego stylu nazewnictwa (np. `ZBX_SERVER_HOST` odpowiada [`Server`](/manual/appendix/config/zabbix_proxy#server)). Niektóre zmienne są specyficzne dla Dockera, a niektórych parametrów konfiguracyjnych nie można zmienić (np. `PIDFile` i `LogType`). Podczas korzystania ze zmiennych środowiskowych zapoznaj się z sekcją *Environment variables* w opisie każdego [Docker image](#available-docker-images) komponentu na Docker Hub. ::: - Podłącza lokalizację magazynu 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. ::: noteclassic Więcej informacji o każdym woluminie znajdziesz w sekcji *Allowed volumes* w opisie każdego [Docker image](#available-docker-images) komponentu na Docker Hub. ::: Po wdrożeniu kontenera proxy Zabbix możesz przejść do [dodania proxy](/manual/distributed_monitoring/proxies#configuration) w interfejsie web Zabbix oraz [skonfigurować hosty](/manual/config/hosts/host#configuration), 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 trapami SNMP - serwer Zabbix (MySQL) z Java gateway na RHEL 8–10 Więcej przykładów znajdziesz w opisie każdego [Docker image](#available-docker-images) komponentu na Docker Hub. [comment]: # ({/ec9e0e44-0b4b68c7}) [comment]: # ({a807fe94-492bd3ba}) #### Wdrożenie serwera Zabbix (MySQL) z Java gateway Ten przykład pokazuje, jak wdrożyć serwer Zabbix z backendem MySQL, Java gateway do [monitorowania JMX](/manual/config/items/itemtypes/jmx_monitoring) oraz interfejsem webowym opartym na Nginx. 1\. Utwórz dedykowaną sieć Docker, aby wszystkie kontenery komponentów Zabbix mogły się ze sobą komunikować za pomocą nazw kontenerów: ```bash 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): ```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\. Śledź logi MySQL i poczekaj, aż MySQL będzie gotowy do połączeń (użyj `Ctrl+C`, aby zakończyć wyświetlanie logów): ```bash docker logs -f mysql-server # ... [Server] /usr/sbin/mysqld: ready for connections. ... ``` 4\. Uruchom kontener 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\. Włącz `log_bin_trust_function_creators` w kontenerze serwera MySQL. Tymczasowo znosi to ograniczenia bezpieczeństwa dotyczące funkcji składowanych; ustawienie zostanie wyłączone w późniejszych krokach. Umożliwia to użytkownikowi bazy danych Zabbix tworzenie funkcji składowanych bez uprawnienia `SUPER`, które MySQL wymaga, gdy włączone jest [binary logging](https://dev.mysql.com/doc/refman/8.0/en/stored-programs-logging.html) (domyślnie od MySQL 8.0). Uruchom następujące polecenie: ```bash 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: ```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\. Śledź logi serwera Zabbix i poczekaj, aż serwer Zabbix zakończy inicjalizację schematu bazy danych (użyj `Ctrl+C`, aby zakończyć wyświetlanie logów): ```bash 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. Przywraca to ograniczenie bezpieczeństwa, które uniemożliwia użytkownikom innym niż `SUPER` tworzenie funkcji składowanych. Uruchom następujące polecenie: ```bash docker exec -it mysql-server mysql -u root -p'root_pwd' \ -e "SET GLOBAL log_bin_trust_function_creators = 0;" ``` 9\. Uruchom kontener interfejsu webowego Zabbix i połącz go z kontenerami serwera Zabbix oraz serwera MySQL: ```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 ``` Po uruchomieniu kontenerów serwer Zabbix zostanie uruchomiony, a interfejs webowy będzie dostępny pod adresem `http://localhost`. ::: noteclassic Użyj `docker ps`, aby sprawdzić stan kontenerów. Wszystkie kontenery powinny mieć status `Up`. Jeśli którykolwiek ma status `Exited`, sprawdź jego logi pod kątem błędów za pomocą `docker logs -f `. ::: #### Wdrożenie serwera Zabbix (PostgreSQL) z SNMP traps Ten przykład pokazuje, jak wdrożyć serwer Zabbix z backendem PostgreSQL, [SNMP traps](/manual/config/items/itemtypes/snmptrap) oraz interfejsem webowym opartym na Nginx. 1\. Utwórz dedykowaną sieć Docker, aby wszystkie kontenery komponentów Zabbix mogły się ze sobą komunikować za pomocą nazw kontenerów: ```bash 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): ```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\. Uruchom kontener 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\. Uruchom kontener serwera Zabbix i połącz go z kontenerami serwera PostgreSQL oraz 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\. Śledź logi serwera Zabbix i poczekaj, aż serwer Zabbix zakończy inicjalizację schematu bazy danych (użyj `Ctrl+C`, aby zakończyć wyświetlanie logów): ```bash docker logs -f zabbix-server-pgsql # ... [info]: ** Creating 'zabbix' schema in PostgreSQL # ... [info]: ** Database schema successfully created! ``` 6\. Uruchom kontener interfejsu webowego Zabbix i połącz go z kontenerami serwera Zabbix oraz serwera PostgreSQL: ```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 ``` Po uruchomieniu kontenerów serwer Zabbix zostanie uruchomiony, a interfejs webowy będzie dostępny pod adresem `http://localhost`. ::: noteclassic Użyj `docker ps`, aby sprawdzić stan kontenerów. Wszystkie kontenery powinny mieć status `Up`. Jeśli którykolwiek ma status `Exited`, sprawdź jego logi pod kątem błędów za pomocą `docker logs -f `. ::: #### Wdrożenie serwera Zabbix (MySQL) z Java gateway w RHEL 8–10 Ten przykład pokazuje, jak wdrożyć serwer Zabbix z backendem MySQL, Java gateway do [monitorowania JMX](/manual/config/items/itemtypes/jmx_monitoring) oraz interfejsem webowym opartym na Nginx, działające w systemach Red Hat Enterprise Linux 8, 9 lub 10. W 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 uruchamianej jako root, co lepiej pasuje do środowisk Red Hat. 1\. Utwórz nowy pod o nazwie `zabbix` z wystawionymi portami dla interfejsu webowego Zabbix i trappera serwera Zabbix: ```bash podman pod create --name zabbix -p 80:8080 -p 10051:10051 ``` 2\. (Opcjonalnie) Uruchom kontener agent w lokalizacji poda `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\. Utwórz katalog `./mysql/` na hoście RHEL: ```bash 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): ```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\. Śledź logi MySQL i poczekaj, aż MySQL będzie gotowy do połączeń (użyj `Ctrl+C`, aby zakończyć wyświetlanie logów): ```bash podman logs -f mysql-server # ... [Server] /usr/sbin/mysqld: ready for connections. ... ``` 6\. Uruchom kontener 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\. Włącz `log_bin_trust_function_creators` w kontenerze serwera MySQL. Tymczasowo znosi to ograniczenia bezpieczeństwa dotyczące funkcji składowanych; ustawienie zostanie wyłączone w późniejszych krokach. Umożliwia to użytkownikowi bazy danych Zabbix tworzenie funkcji składowanych bez uprawnienia `SUPER`, które MySQL wymaga, gdy włączone jest [binary logging](https://dev.mysql.com/doc/refman/8.0/en/stored-programs-logging.html) (domyślnie od MySQL 8.0). Uruchom następujące polecenie: ```bash 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: ```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\. Śledź logi serwera Zabbix i poczekaj, aż serwer Zabbix zakończy inicjalizację schematu bazy danych (użyj `Ctrl+C`, aby zakończyć wyświetlanie logów): ```bash 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. Przywraca to ograniczenie bezpieczeństwa, które uniemożliwia użytkownikom innym niż `SUPER` tworzenie funkcji składowanych. Uruchom następujące polecenie: ```bash podman exec -it mysql-server mysql -u root -p'root_pwd' \ -e "SET GLOBAL log_bin_trust_function_creators = 0;" ``` 11\. Uruchom kontener interfejsu webowego Zabbix i połącz go z kontenerami serwera Zabbix oraz serwera MySQL: ```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 Pod `zabbix` udostępnia port `80/TCP` (HTTP) na hoście z portu `8080/TCP` kontenera `zabbix-web-mysql`. ::: Po uruchomieniu kontenerów serwer Zabbix zostanie uruchomiony, a interfejs webowy będzie dostępny pod adresem `http://localhost`. ::: noteclassic Użyj `docker ps`, aby sprawdzić stan kontenerów. Wszystkie kontenery powinny mieć status `Up`. Jeśli którykolwiek ma status `Exited`, sprawdź jego logi pod kątem błędów za pomocą `docker logs -f `. ::: [comment]: # ({/a807fe94-492bd3ba})