Installation aus Containern

Übersicht

Diese Seite beschreibt, wie Zabbix mit Docker oder Docker Compose bereitgestellt wird.

Docker Compose ist der schnellste Weg, Zabbix bereitzustellen. Es liest eine Konfigurationsdatei und startet automatisch alle Container, aus denen eine vollständige Zabbix-Installation besteht, in der richtigen Reihenfolge.

Docker (manuelle Bereitstellung) erreicht dasselbe Ergebnis, indem jede Komponente Schritt für Schritt bereitgestellt wird.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Docker (1.12.0 oder höher) auf Ihrem System installiert ist. Falls nicht, folgen Sie der Docker-Installationsanleitung. Für die Bereitstellung mit Docker Compose ist außerdem Docker Compose (2.24.0 oder höher) erforderlich.

Einige Zabbix-Komponenten erfordern, dass bestimmte Ports auf dem Host, auf dem Docker ausgeführt wird, geöffnet sind (z. B. 10051/TCP für den Zabbix Server, 162/UDP für SNMP-Traps). Eine vollständige Liste der von Zabbix-Komponenten verwendeten Ports finden Sie unter Anforderungen. Beim Zabbix Server und Agent kann der Standardport durch Setzen der Umgebungsvariablen ZBX_LISTENPORT im jeweiligen Container geändert werden.

Verfügbare Docker-Images

Zabbix stellt für jede Zabbix-Komponente ein Docker-Image bereit, die alle auf Docker Hub veröffentlicht werden. Jedes Image wird verwendet, um einen Container zu erstellen, in dem die jeweilige Komponente ausgeführt wird.

Alle Images der Zabbix-Komponenten auf Docker Hub basieren auf den neuesten Hauptversionen der unterstützten Betriebssysteme. Diese Images werden automatisch neu erstellt, wenn die zugrunde liegenden OS-Images aktualisiert werden.

Image-Tags

Jedes Image unterstützt Tags zur Auswahl des Basisbetriebssystems und der Zabbix-Version:

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

Unterstützte <os>-Werte:

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

Unterstützte <version>-Werte:

• latest - Neueste stabile Zabbix-Version auf Alpine Linux
• <os>-latest - Neueste stabile Zabbix-Version auf dem ausgewählten Betriebssystem
• <os>-trunk - Neuester Entwicklungs-Build (nightly) auf dem ausgewählten Betriebssystem
• <os>-X.X-latest - Neueste Zabbix-Minor-Version einer bestimmten Zabbix-Major-Version auf dem ausgewählten Betriebssystem
• <os>-X.X.* - Bestimmte Zabbix-Minor-Version auf dem ausgewählten Betriebssystem

Beispiele:

# Neuester stabiler Zabbix Proxy (SQLite3) auf Alpine Linux:
docker pull zabbix/zabbix-proxy-sqlite3:latest

# Neuester stabiler Zabbix Proxy (SQLite3) auf Ubuntu:
docker pull zabbix/zabbix-proxy-sqlite3:ubuntu-latest

# Neuester Entwicklungs-Build (nightly) von Zabbix Server (MySQL) auf Ubuntu:
docker pull zabbix/zabbix-server-mysql:ubuntu-trunk

# Neueste 8.0-Minor-Version von Zabbix Server (MySQL) auf Alpine Linux:
docker pull zabbix/zabbix-server-mysql:alpine-8.0-latest

# Version 8.0.1 von Zabbix Server (MySQL) auf Alpine Linux:
docker pull zabbix/zabbix-server-mysql:alpine-8.0.1

Docker Compose

Docker Compose ist der schnellste Weg, Zabbix bereitzustellen. Es liest eine Konfigurationsdatei (Compose-Datei) und übernimmt die gesamte Einrichtung – das Abrufen von Docker-Images, das Erstellen eines internen Netzwerks zwischen Containern, das Einrichten des Speichers, die Initialisierung der Datenbank und das Starten aller Komponenten in der richtigen Reihenfolge.

Das Repository offizieller Zabbix-Dockerfiles stellt sofort einsatzbereite Docker-Compose-Dateien und ein auf .env basierendes Konfigurationssystem bereit, das verschiedene Betriebssysteme, Datenbank-Backends und die Konfiguration der Zabbix-Komponenten unterstützt.

1. Klonen Sie das Repository, wechseln Sie in das entsprechende Verzeichnis und wechseln Sie zur Version 8.0:

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

2. (Optional) Passen Sie die Bereitstellung mit Umgebungsvariablen an. Dieser Schritt kann bei einer Standardkonfiguration übersprungen werden.

3. Stellen Sie die Standardkonfiguration bereit – Zabbix-Server, Weboberfläche (unter NGINX) und ein Datenbank-Backend (MySQL oder PostgreSQL), jeweils in einem eigenen Container unter Alpine Linux.

# Mit MySQL als Datenbank:
docker compose -f ./compose.yaml up -d

# Mit PostgreSQL als Datenbank:
docker compose -f ./compose_pgsql.yaml up -d

Nachdem die Container gestartet wurden (in der Regel innerhalb von 1–3 Minuten), startet der Zabbix-Server und die Weboberfläche steht zur Anmeldung bereit.

Umgebungsvariablen

Das Verhalten von Docker Compose und die Konfiguration der Zabbix-Komponenten können mithilfe von Umgebungsvariablen angepasst werden.

Variablen auf Compose-Ebene (definiert in der .env-Datei) steuern, welche Docker-Images, Ports und Netzwerk-IP-Bereiche verwendet werden. Sie können diese Variablen inline vor dem Befehl docker compose verwenden oder die .env-Datei bearbeiten.

Der folgende Befehl stellt beispielsweise eine vollständige Zabbix-Umgebung mit mehreren Containern mithilfe eines auf Ubuntu basierenden Images (anstelle des standardmäßigen Alpine Linux) bereit und stellt die Weboberfläche über NGINX an benutzerdefinierten HTTP- (8282) und HTTPS-Ports (8443) bereit:

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

Variablen auf Komponentenebene (definiert in den Dateien env_vars/.env_<component>) steuern die Konfiguration der Zabbix-Komponenten. Bearbeiten Sie die entsprechende .env_<component>-Datei, bevor Sie den Befehl docker compose ausführen.

Sie können beispielsweise die Anzahl der passiven Poller und die Cache-Einstellungen des Zabbix-Servers anpassen sowie die Zeitzone der Weboberfläche konfigurieren, indem Sie die folgenden Variablen bearbeiten:

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

# env_vars/.env_web
PHP_TZ=Europe/Paris

Volumes

Docker Compose speichert persistente Daten im Verzeichnis zbx_env/, das neben der Compose-Datei erstellt wird. Dieses Verzeichnis bewahrt Komponentendaten über Container-Neustarts und Updates hinweg auf.

Der Inhalt von zbx_env/ ist für das Image jeder Komponente vordefiniert. Zum Beispiel:

• zbx_env/etc/ – wird vom Container der Zabbix-Weboberfläche verwendet
• zbx_env/usr/ und zbx_env/var/ – werden vom Zabbix-Server-Container verwendet

Weitere Informationen zu jedem Volume finden Sie im Abschnitt Allowed volumes in der Beschreibung des jeweiligen Docker-Images auf Docker Hub.

Makefile

Das Zabbix-Dockerfiles-Repository stellt außerdem eine Makefile als Abkürzung für häufig verwendete Docker-Compose-Aufgaben bereit. Anstatt den vollständigen Befehl docker compose zu verwenden, können Sie kürzere make-Befehle nutzen (führen Sie make help aus, um die verfügbaren Optionen anzuzeigen):

# Standardbereitstellung (Zabbix-Server, Frontend, MySQL, alles unter Alpine Linux)
make up

# Benutzerdefinierte Bereitstellung (Zabbix-Server, Frontend mit benutzerdefinierten NGINX-Ports, PostgreSQL, alles unter Ubuntu)
make up \
  OS=ubuntu \
  DB=pgsql \
  ZABBIX_WEB_NGINX_HTTP_PORT=8282 \
  ZABBIX_WEB_NGINX_HTTPS_PORT=8443

Standardmäßig startet make up nur eine minimale Gruppe von Services (Zabbix-Server, Frontend und Datenbank). Dadurch bleibt die Einrichtung schlank, und es werden keine Komponenten gestartet, die möglicherweise nicht benötigt werden. Um zusätzliche Komponenten einzubinden, können Sie die folgenden Compose-Profile verwenden:

# Standardbereitstellung + Zabbix Agent, Java gateway, Webservice und SNMP-Traps:
make up COMPOSE_PROFILES=full

# COMPOSE_PROFILES=full + Zabbix Proxy (MySQL und SQLite3):
make up COMPOSE_PROFILES=all

Docker (manuelle Bereitstellung)

Verwenden Sie die manuelle Bereitstellung, wenn Sie Zabbix Schritt für Schritt bereitstellen, einzelne Komponenten ausführen, sie in eine vorhandene Umgebung integrieren oder eine alternative Container-Laufzeitumgebung wie Podman verwenden möchten.

Um beispielsweise einen Zabbix Proxy bereitzustellen, führen Sie den folgenden Befehl aus:

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

Dieser Befehl:

• Ruft das Docker-Image zabbix/zabbix-proxy-sqlite3:alpine-8.0-latest ab.

• Erstellt und startet einen Container zabbix-proxy-sqlite3 auf Basis des Docker-Images (mit den Flags --init und -d).

• Konfiguriert den Zabbix Proxy-Parameter Server über die Umgebungsvariable ZBX_SERVER_HOST. Dieser Parameter gibt die IP-Adresse des Zabbix Servers an, von dem der Proxy Konfigurationsdaten abruft und an den er die gesammelten Daten sendet. Beachten Sie, dass andere für den aktiven Proxy-Betrieb erforderliche Variablen Standardwerte verwenden und weggelassen werden können.

• Bindet einen von Docker verwalteten Speicherort (z. B. /var/lib/docker/volumes/zabbix-proxy-data/) an das Verzeichnis /var/lib/zabbix des Containers, damit die Daten des Zabbix Proxy dauerhaft gespeichert werden, auch wenn der Container entfernt wird.

Nachdem Sie den Zabbix Proxy-Container bereitgestellt haben, können Sie in Ihrer Zabbix Frontend mit dem Hinzufügen des Proxys fortfahren und Hosts konfigurieren, die von diesem Proxy überwacht werden sollen.

Die folgenden Beispiele decken drei weitere Bereitstellungsszenarien ab:

• Zabbix Server (MySQL) mit Java gateway
• Zabbix Server (PostgreSQL) mit SNMP-Traps
• Zabbix Server (MySQL) mit Java gateway auf RHEL 8–10

Weitere Beispiele finden Sie in der Beschreibung des Docker-Images jeder Komponente auf Docker Hub.

Zabbix Server (MySQL) mit Java gateway bereitstellen

Dieses Beispiel zeigt, wie Sie einen Zabbix Server mit einem MySQL-Backend, einem Java gateway für die JMX-Überwachung und einer webbasierten Oberfläche auf NGINX-Basis bereitstellen.

1. Erstellen Sie ein dediziertes Docker-Netzwerk, damit alle Container der Zabbix-Komponenten einander über den Containernamen erreichen können:

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

2. Starten Sie einen leeren MySQL-Server-Container (ersetzen Sie zabbix_pwd und root_pwd durch sichere Passwörter und verwenden Sie diese Werte in den folgenden Schritten):

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. Verfolgen Sie die MySQL-Protokolle und warten Sie, bis MySQL für Verbindungen bereit ist (verwenden Sie Ctrl+C, um die Protokollausgabe zu beenden):

docker logs -f mysql-server

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

4. Starten Sie einen Zabbix-Java-gateway-Container:

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

5. Aktivieren Sie log_bin_trust_function_creators im MySQL-Server-Container. Dadurch werden die Sicherheitseinschränkungen für gespeicherte Funktionen vorübergehend gelockert; die Einstellung wird in späteren Schritten deaktiviert. Dies ermöglicht es dem Zabbix-Datenbankbenutzer, gespeicherte Funktionen ohne das Privileg SUPER zu erstellen, das MySQL bei aktiviertem binären Logging benötigt (standardmäßig seit MySQL 8.0). Führen Sie den folgenden Befehl aus:

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

6. Starten Sie einen Zabbix-Server-Container und verbinden Sie ihn mit den Java-gateway- und MySQL-Server-Containern:

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. Verfolgen Sie die Protokolle des Zabbix Servers und warten Sie, bis der Zabbix Server die Initialisierung des Datenbankschemas abgeschlossen hat (verwenden Sie Ctrl+C, um die Protokollausgabe zu beenden):

docker logs -f zabbix-server-mysql

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

8. Deaktivieren Sie log_bin_trust_function_creators im MySQL-Server-Container. Dadurch wird die Sicherheitseinschränkung wieder aktiviert, die Benutzer ohne SUPER-Privileg daran hindert, gespeicherte Funktionen zu erstellen. Führen Sie den folgenden Befehl aus:

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

9. Starten Sie einen Container für die Zabbix-Weboberfläche und verbinden Sie ihn mit den Zabbix-Server- und MySQL-Server-Containern:

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

Nachdem die Container gestartet wurden und ausgeführt werden, startet der Zabbix Server und die Weboberfläche steht zur Anmeldung zur Verfügung.

Zabbix Server (PostgreSQL) mit SNMP-Traps bereitstellen

Dieses Beispiel zeigt, wie Sie einen Zabbix Server mit einem PostgreSQL-Backend, SNMP-Traps und einer webbasierten Oberfläche auf NGINX-Basis bereitstellen.

1. Erstellen Sie ein dediziertes Docker-Netzwerk, damit alle Container der Zabbix-Komponenten einander über den Containernamen erreichen können:

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

2. Starten Sie einen leeren PostgreSQL-Server-Container (ersetzen Sie zabbix_pwd durch ein sicheres Passwort und verwenden Sie diesen Wert in den folgenden Schritten):

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. Starten Sie einen Zabbix-SNMP-Traps-Container:

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. Starten Sie einen Zabbix-Server-Container und verbinden Sie ihn mit dem PostgreSQL-Server- und SNMP-Traps-Container:

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. Verfolgen Sie die Protokolle des Zabbix Servers und warten Sie, bis der Zabbix Server die Initialisierung des Datenbankschemas abgeschlossen hat (verwenden Sie Ctrl+C, um die Protokollausgabe zu beenden):

docker logs -f zabbix-server-pgsql

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

6. Starten Sie einen Container für die Zabbix-Weboberfläche und verbinden Sie ihn mit den Zabbix-Server- und PostgreSQL-Server-Containern:

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

Nachdem die Container gestartet wurden und ausgeführt werden, startet der Zabbix Server und die Weboberfläche steht zur Anmeldung zur Verfügung.

Zabbix Server (MySQL) mit Java gateway unter RHEL 8–10 bereitstellen

Dieses Beispiel zeigt, wie Sie einen Zabbix Server mit einem MySQL-Backend, einem Java gateway für die JMX-Überwachung und einer webbasierten Oberfläche auf NGINX-Basis bereitstellen, die vollständig unter Red Hat Enterprise Linux 8, 9 oder 10 ausgeführt werden.

Unter Red Hat Enterprise Linux wird Podman anstelle von Docker als Container-Laufzeitumgebung empfohlen. Podman funktioniert ähnlich wie Docker, benötigt jedoch keinen als Root ausgeführten Hintergrunddienst und eignet sich daher besser für Red-Hat-Umgebungen.

1. Erstellen Sie einen neuen Pod mit dem Namen zabbix und geben Sie die Ports für die Zabbix-Weboberfläche und den Zabbix-Server-Trapper frei:

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

2. (Optional) Starten Sie einen Zabbix-Agent-Container im Pod 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. Erstellen Sie ein Verzeichnis ./mysql/ auf dem RHEL-Host:

mkdir -p ./mysql

4. Starten Sie einen leeren MySQL-Server-Container (ersetzen Sie zabbix_pwd und root_pwd durch sichere Passwörter und verwenden Sie diese Werte in den folgenden Schritten):

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. Verfolgen Sie die MySQL-Protokolle und warten Sie, bis MySQL für Verbindungen bereit ist (verwenden Sie Ctrl+C, um die Protokollausgabe zu beenden):

podman logs -f mysql-server

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

6. Starten Sie einen Zabbix-Java-gateway-Container:

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

7. Aktivieren Sie log_bin_trust_function_creators im MySQL-Server-Container. Dadurch werden die Sicherheitseinschränkungen für gespeicherte Funktionen vorübergehend gelockert; die Einstellung wird in späteren Schritten deaktiviert. Dies ermöglicht es dem Zabbix-Datenbankbenutzer, gespeicherte Funktionen ohne das Privileg SUPER zu erstellen, das MySQL bei aktiviertem binären Logging benötigt (standardmäßig seit MySQL 8.0). Führen Sie den folgenden Befehl aus:

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

8. Starten Sie einen Zabbix-Server-Container und verbinden Sie ihn mit den Java-gateway- und MySQL-Server-Containern:

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. Verfolgen Sie die Protokolle des Zabbix Servers und warten Sie, bis der Zabbix Server die Initialisierung des Datenbankschemas abgeschlossen hat (verwenden Sie Ctrl+C, um die Protokollausgabe zu beenden):

podman logs -f zabbix-server-mysql

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

10. Deaktivieren Sie log_bin_trust_function_creators im MySQL-Server-Container. Dadurch wird die Sicherheitseinschränkung wieder aktiviert, die Benutzer ohne SUPER-Privileg daran hindert, gespeicherte Funktionen zu erstellen. Führen Sie den folgenden Befehl aus:

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

11. Starten Sie einen Container für die Zabbix-Weboberfläche und verbinden Sie ihn mit den Zabbix-Server- und MySQL-Server-Containern:

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

Nachdem die Container gestartet wurden und ausgeführt werden, startet der Zabbix Server und die Weboberfläche steht zur Anmeldung zur Verfügung.