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-Umgebung besteht, in der richtigen Reihenfolge.

Docker (manuelle Bereitstellung) erzielt dasselbe Ergebnis, indem jede Komponente Schritt für Schritt bereitgestellt wird, was für Benutzer geeignet sein kann, die bereits eine bestehende Docker-Umgebung verwalten.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Docker auf Ihrem System installiert ist. Falls nicht, folgen Sie der Docker-Installationsanleitung.

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. Für den Zabbix Server und den Agent kann der Standardport geändert werden, indem die Umgebungsvariable ZBX_LISTENPORT im jeweiligen Container gesetzt wird.

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 werden automatisch neu erstellt, wenn ihre Basis-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
• ol - Oracle Linux
• ltsc2019 - Windows 10 LTSC 2019 (nur Zabbix Agent)
• ltsc2022 - Windows 11 LTSC 2022 (nur Zabbix Agent)

Unterstützte <version>-Werte:

• latest - Neueste stabile Version auf Alpine Linux
• <os>-latest - Neueste stabile Version auf dem ausgewählten Betriebssystem
• <os>-trunk - Neuester Entwicklungs-Build (nightly) auf dem ausgewählten Betriebssystem
• <os>-X.X-latest - Neueste Minor-Release einer bestimmten Major-Version auf dem ausgewählten Betriebssystem
• <os>-X.X.* - Bestimmte 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-Release 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) ein und übernimmt die gesamte Einrichtung – das Herunterladen von Docker-Images, das Erstellen eines internen Netzwerks zwischen Containern, das Einrichten von Speicher, die Initialisierung der Datenbank und das Starten aller Komponenten in der richtigen Reihenfolge.

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

1. Klonen Sie das Repository, wechseln Sie in das Verzeichnis und stellen Sie auf Version 8.0 um:

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 Standard-Zabbix-Konfiguration bereit:

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

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

Dadurch werden der Zabbix Server, die Weboberfläche (ausgeführt auf Nginx) und ein Datenbank-Backend (MySQL oder PostgreSQL) gestartet, jeweils in einem eigenen Container auf Alpine Linux (Standard). Sobald die Container gestartet sind und ausgeführt werden (in der Regel innerhalb von 1–3 Minuten), wird der Zabbix Server gestartet und die Weboberfläche ist unter http://localhost verfügbar.

Sie können mit dem folgenden Befehl prüfen, ob alles funktioniert:

docker compose ps

Alle Container sollten den Status running anzeigen. Falls bei einem Container exited angezeigt wird, prüfen Sie dessen Logs (docker logs <container-name>).

Umgebungsvariablen

Sowohl das Verhalten von Docker Compose als auch 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 Datei .env bearbeiten.

Zum Beispiel stellt der folgende Befehl eine vollständige Zabbix-Multi-Container-Umgebung mit einem Ubuntu-basierten Image bereit (anstelle des standardmäßigen Alpine Linux) und macht die Weboberfläche über Nginx auf benutzerdefinierten HTTP- (8282) und HTTPS-Ports (8443) verfügbar:

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 Datei .env_<component>, bevor Sie den Befehl docker compose ausführen.

Zum Beispiel können Sie die Anzahl der passiven Poller des Zabbix-Servers und die Cache-Einstellungen 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 Repository der Zabbix-Dockerfiles stellt außerdem ein Makefile als Abkürzung für gängige 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, Weboberfläche, MySQL, alles auf Alpine Linux)
make up

# Benutzerdefinierte Bereitstellung (Zabbix-Server, Weboberfläche mit benutzerdefinierten Nginx-Ports, PostgreSQL, alles auf 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 einen minimalen Satz von Diensten (Zabbix-Server, Weboberfläche und Datenbank). Dadurch bleibt die Einrichtung schlank und es wird vermieden, Komponenten zu starten, die möglicherweise nicht benötigt werden. Um zusätzliche Komponenten einzubeziehen, können Sie die folgenden Compose-Profile verwenden:

# Standardbereitstellung + Zabbix-Agent, Java gateway, Web-Service 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 bestehende 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.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

Dieser Befehl:

• Lädt das Docker-Image zabbix/zabbix-proxy-sqlite3:alpine-8.0-latest herunter.

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

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

• Verbindet einen von Docker verwalteten Speicherort (z. B. /var/lib/docker/volumes/zabbix-proxy-data/) mit dem Verzeichnis /var/lib/zabbix des Containers, sodass Zabbix-Proxy-Daten dauerhaft gespeichert werden, selbst wenn der Container entfernt wird.

Nach der Bereitstellung des Zabbix-Proxy-Containers können Sie im Zabbix Frontend mit dem Hinzufügen des Proxy fortfahren und Hosts konfigurieren, die von diesem Proxy überwacht werden sollen.

Die folgenden Beispiele behandeln drei zusätzliche Bereitstellungsszenarien:

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

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

Zabbix-Server (MySQL) mit Java gateway bereitstellen

1. Erstellen Sie ein dediziertes Docker-Netzwerk, damit sich alle Zabbix-Komponenten-Container gegenseitig ü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):

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

4. Starten Sie einen Zabbix-Server-Container und verknüpfen Sie ihn mit dem MySQL-Server-Container (ersetzen Sie zabbix_pwd und root_pwd durch dieselben Passwörter wie in Schritt 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. Starten Sie einen Zabbix-Webinterface-Container und verknüpfen Sie ihn mit dem Zabbix-Server- und dem MySQL-Server-Container (ersetzen Sie zabbix_pwd und root_pwd durch dieselben Passwörter wie in Schritt 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

Sobald die Container gestartet sind und ausgeführt werden (typischerweise innerhalb von 1–3 Minuten), ist der Zabbix-Server gestartet und das Webinterface unter http://localhost verfügbar.

Zabbix-Server (PostgreSQL) mit SNMP-Traps bereitstellen

1. Erstellen Sie ein dediziertes Docker-Netzwerk, damit sich alle Zabbix-Komponenten-Container gegenseitig ü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):

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 verknüpfen Sie ihn mit dem PostgreSQL-Server-Container und dem SNMP-Traps-Container (ersetzen Sie zabbix_pwd durch dasselbe Passwort wie in Schritt 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. Starten Sie einen Zabbix-Webinterface-Container und verknüpfen Sie ihn mit dem Zabbix-Server- und dem PostgreSQL-Server-Container (ersetzen Sie zabbix_pwd durch dasselbe Passwort wie in Schritt 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

Sobald die Container gestartet sind und ausgeführt werden (typischerweise innerhalb von 1–3 Minuten), ist der Zabbix-Server gestartet und das Webinterface unter http://localhost verfügbar.

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

Unter Red Hat Enterprise Linux 8 ist Podman anstelle von Docker die empfohlene Container-Laufzeitumgebung. Podman funktioniert ähnlich wie Docker, benötigt jedoch keinen Hintergrunddienst, der als root ausgeführt wird, was es für Red-Hat-Umgebungen besser geeignet macht.

1. Erstellen Sie einen neuen Pod mit dem Namen zabbix und freigegebenen Ports für das Zabbix-Webinterface und den Zabbix-Server-Trapper:

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 auf dem RHEL-Host ein Verzeichnis ./mysql/:

mkdir -p ./mysql

4. Starten Sie einen leeren MySQL-Server-Container (ersetzen Sie zabbix_pwd und root_pwd durch sichere Passwörter):

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

6. Starten Sie einen Zabbix-Server-Container (ersetzen Sie zabbix_pwd und root_pwd durch dieselben Passwörter wie in Schritt 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. Starten Sie einen Zabbix-Webinterface-Container (ersetzen Sie zabbix_pwd und root_pwd durch dieselben Passwörter wie in Schritt 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