从容器安装

概述

本页面介绍如何使用 Docker 或 Docker Compose 部署 Zabbix。

Docker Compose 是部署 Zabbix 的最快方式。 它会读取配置文件，并按正确顺序自动启动构成完整 Zabbix 环境的所有容器。

Docker（手动部署） 通过逐步部署每个组件来实现相同的结果。

先决条件

在开始之前，请确保您的系统已安装 Docker（1.12.0 或更高版本）。 如果尚未安装，请参阅 Docker 安装指南。 对于 Docker Compose 部署，还需要 Docker Compose（2.24.0 或更高版本）。

某些 Zabbix 组件要求在运行 Docker 的主机上开放特定端口（例如，Zabbix 服务器使用 10051/TCP，SNMP traps 使用 162/UDP）。 有关 Zabbix 组件所使用端口的完整列表，请参见 要求。 对于 Zabbix 服务器和 agent，可以通过在相应容器上设置 ZBX_LISTENPORT 环境变量来更改默认端口。

可用的 Docker 镜像

Zabbix 为每个 Zabbix 组件都提供了一个 Docker 镜像，全部发布在 Docker Hub 上。 每个镜像都用于创建一个运行相应组件的容器。

Docker Hub 上的所有 Zabbix 组件镜像都基于受支持操作系统的最新主要版本。 当底层操作系统镜像更新时，这些镜像会自动重新构建。

镜像标签

每个镜像都支持使用标签来选择基础操作系统和 Zabbix 版本：

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

支持的 <os> 值：

• alpine - Alpine Linux
• ubuntu - Ubuntu
• centos - CentOS Stream
• ol - Oracle Linux
• ltsc2022 - Windows 11 LTSC 2022（仅 Zabbix agent）

支持的 <version> 值：

• latest - Alpine Linux 上最新的稳定版 Zabbix 版本
• <os>-latest - 所选操作系统上最新的稳定版 Zabbix 版本
• <os>-trunk - 所选操作系统上最新的开发版（nightly）构建
• <os>-X.X-latest - 所选操作系统上特定 Zabbix 主版本的最新 Zabbix 次版本发布
• <os>-X.X.* - 所选操作系统上的特定 Zabbix 次版本发布

示例：

# Alpine Linux 上最新的稳定版 Zabbix proxy（SQLite3）：
docker pull zabbix/zabbix-proxy-sqlite3:latest

# Ubuntu 上最新的稳定版 Zabbix proxy（SQLite3）：
docker pull zabbix/zabbix-proxy-sqlite3:ubuntu-latest

# Ubuntu 上 Zabbix 服务器（MySQL）的最新开发版（nightly）构建：
docker pull zabbix/zabbix-server-mysql:ubuntu-trunk

# Alpine Linux 上 Zabbix 服务器（MySQL）的最新 8.0 次版本发布：
docker pull zabbix/zabbix-server-mysql:alpine-8.0-latest

# Alpine Linux 上 Zabbix 服务器（MySQL）的 8.0.1 版本：
docker pull zabbix/zabbix-server-mysql:alpine-8.0.1

Docker Compose

Docker Compose 是部署 Zabbix 的最快方式。 它会读取配置文件（Compose 文件）并处理整个设置过程——拉取 Docker 镜像、在容器之间创建内部网络、设置存储、初始化数据库，以及按正确顺序启动所有组件。

官方 Zabbix Dockerfiles 仓库提供了可直接使用的 Docker Compose 文件，以及基于 .env 的配置系统，支持不同的操作系统、数据库后端和 Zabbix 组件配置。

1. 克隆仓库，进入仓库目录，并切换到 8.0 版本：

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

2. （可选）使用环境变量自定义部署。 默认设置可以跳过此步骤。

3. 部署默认设置——Zabbix 服务器、Web 前端（运行于 NGINX）以及数据库后端（MySQL 或 PostgreSQL），每个组件都在 Alpine Linux 上的独立容器中运行。

# 使用 MySQL 作为数据库：
docker compose -f ./compose.yaml up -d

# 使用 PostgreSQL 作为数据库：
docker compose -f ./compose_pgsql.yaml up -d

容器启动并运行后（通常需要 1–3 分钟），Zabbix 服务器将启动，Web 前端也可供登录。

环境变量

可以使用环境变量自定义 Docker Compose 行为和 Zabbix 组件配置。

Compose 级变量（在 .env 文件中定义）用于控制所使用的 Docker 镜像、端口和网络 IP 范围。 您可以在 docker compose 命令前以内联方式使用这些变量，也可以编辑 .env 文件。

例如，以下命令使用基于 Ubuntu 的镜像（而不是默认的 Alpine Linux）部署完整的多容器 Zabbix 环境，并通过 NGINX 使用自定义的 HTTP（8282）和 HTTPS（8443）端口公开 Web 界面：

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

组件级变量（在 env_vars/.env_<component> 文件中定义）用于控制 Zabbix 组件配置。 在运行 docker compose 命令前，编辑相应的 .env_<component> 文件。

例如，您可以通过编辑以下变量调整 Zabbix 服务器被动轮询器数量和缓存设置，并配置 Web 界面的时区：

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

# env_vars/.env_web
PHP_TZ=Europe/Paris

卷

Docker Compose 将持久化数据存储在与 Compose 文件一同创建的 zbx_env/ 目录中。
该目录可在容器重启和更新后保留组件数据。

zbx_env/ 的内容已针对每个组件的镜像预先定义。例如：

• zbx_env/etc/ - 由 Zabbix Web 界面容器 使用
• zbx_env/usr/ 和 zbx_env/var/ - 由 Zabbix 服务器容器 使用

有关每个卷的更多信息，请参见 Docker Hub 上各组件 Docker 镜像 说明中的 Allowed volumes 部分。

Makefile

Zabbix Dockerfiles 仓库还提供了一个 Makefile，可作为执行常用 Docker Compose 任务的快捷方式。 无需使用完整的 docker compose 命令，您可以使用更简短的 make 命令（运行 make help 可查看可用选项）：

# 默认部署（Zabbix 服务器、前端、MySQL，全部运行在 Alpine Linux 上）
make up

# 自定义部署（Zabbix 服务器、使用自定义 NGINX 端口的前端、PostgreSQL，全部运行在 Ubuntu 上）
make up \
  OS=ubuntu \
  DB=pgsql \
  ZABBIX_WEB_NGINX_HTTP_PORT=8282 \
  ZABBIX_WEB_NGINX_HTTPS_PORT=8443

默认情况下，make up 仅启动最小服务集（Zabbix 服务器、前端和数据库）。 这样可以使部署保持轻量，并避免启动可能不需要的组件。 如需包含其他组件，可以使用以下 Compose 配置文件：

# 默认部署 + Zabbix agent、Java 网关、Web 服务和 SNMP 陷阱：
make up COMPOSE_PROFILES=full

# COMPOSE_PROFILES=full + Zabbix proxy（MySQL 和 SQLite3）：
make up COMPOSE_PROFILES=all

Docker（手动部署）

当你希望逐步部署 Zabbix、运行各个独立组件、将其与现有环境集成，或使用 Podman 等替代容器运行时环境时，请使用手动部署。

例如，要部署一个 Zabbix proxy，请运行以下命令：

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

此命令会：

• 拉取 zabbix/zabbix-proxy-sqlite3:alpine-8.0-latest Docker 镜像。

• 基于该 Docker 镜像创建并启动一个 zabbix-proxy-sqlite3 容器（使用 --init 和 -d 标志）。

• 通过 ZBX_SERVER_HOST 环境变量配置 Zabbix proxy 的 Server 参数。 该参数指定 Zabbix 服务器的 IP 地址，proxy 将从该服务器获取配置数据，并向其发送收集到的数据。 请注意，active proxy 运行所需的其他变量使用默认值，因此可以省略。

• 将 Docker 管理的存储位置（例如 /var/lib/docker/volumes/zabbix-proxy-data/）连接到容器的 /var/lib/zabbix 目录，以便即使容器被移除，Zabbix proxy 数据也能永久保存。

部署 Zabbix proxy 容器后，你可以继续在 Zabbix 前端中添加 proxy，并配置主机由该 proxy 进行监控。

下面的示例涵盖另外三种部署场景：

• Zabbix 服务器（MySQL）与 Java 网关
• Zabbix 服务器（PostgreSQL）与 SNMP trap
• Zabbix 服务器（MySQL）与 RHEL 8–10 上的 Java 网关

更多示例，请参阅 Docker Hub 上各组件的 Docker 镜像 说明。

部署 Zabbix 服务器（MySQL）和 Java 网关

本示例介绍如何部署使用 MySQL 后端的 Zabbix 服务器、用于 JMX 监控 的 Java 网关，以及基于 NGINX 的 Web 界面。

1. 创建专用 Docker 网络，使所有 Zabbix 组件容器可以通过容器名称相互访问：

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

2. 运行一个空的 MySQL 服务器容器（将 zabbix_pwd 和 root_pwd 替换为强密码，并在后续步骤中使用这些密码）：

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. 查看 MySQL 日志，并等待 MySQL 准备好接受连接（使用 Ctrl+C 退出日志）：

docker logs -f mysql-server

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

4. 运行 Zabbix Java 网关容器：

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

5. 在 MySQL 服务器容器中启用 log_bin_trust_function_creators。 此设置会暂时放宽对存储函数的安全限制；在后续步骤中将禁用该设置。 启用后，Zabbix 数据库用户无需 SUPER 权限即可创建存储函数。当启用二进制日志记录时，MySQL 要求创建存储函数的用户具有该权限（MySQL 8.0 起默认启用二进制日志记录）。 运行以下命令：

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

6. 运行 Zabbix 服务器容器，并将其连接到 Java 网关和 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.0-latest

7. 查看 Zabbix 服务器日志，并等待 Zabbix 服务器完成数据库架构初始化（使用 Ctrl+C 退出日志）：

docker logs -f zabbix-server-mysql

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

8. 在 MySQL 服务器容器中禁用 log_bin_trust_function_creators。 此操作会重新启用禁止非 SUPER 用户创建存储函数的安全限制。 运行以下命令：

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

9. 运行 Zabbix Web 界面容器，并将其连接到 Zabbix 服务器和 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.0-latest

容器启动并运行后，Zabbix 服务器将启动，Web 界面可用于登录。

部署带 SNMP 陷阱的 Zabbix 服务器（PostgreSQL）

本示例介绍如何部署使用 PostgreSQL 后端的 Zabbix 服务器、SNMP 陷阱，以及基于 NGINX 的 Web 界面。

1. 创建专用 Docker 网络，使所有 Zabbix 组件容器可以通过容器名称相互访问：

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

2. 运行一个空的 PostgreSQL 服务器容器（将 zabbix_pwd 替换为强密码，并在后续步骤中使用该密码）：

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. 运行 Zabbix SNMP 陷阱容器：

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. 运行 Zabbix 服务器容器，并将其连接到 PostgreSQL 服务器和 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.0-latest

5. 查看 Zabbix 服务器日志，并等待 Zabbix 服务器完成数据库架构初始化（使用 Ctrl+C 退出日志）：

docker logs -f zabbix-server-pgsql

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

6. 运行 Zabbix Web 界面容器，并将其连接到 Zabbix 服务器和 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.0-latest

容器启动并运行后，Zabbix 服务器将启动，Web 界面可用于登录。

在 RHEL 8–10 上部署带 Java 网关的 Zabbix 服务器（MySQL）

本示例介绍如何在 Red Hat Enterprise Linux 8、9 或 10 上部署使用 MySQL 后端的 Zabbix 服务器、用于 JMX 监控 的 Java 网关，以及基于 NGINX 的 Web 界面。

在 Red Hat Enterprise Linux 上，建议使用 Podman 而不是 Docker 作为容器运行时。 Podman 的工作方式与 Docker 类似，但不要求以 root 身份运行后台服务，因此更适合 Red Hat 环境。

1. 创建名为 zabbix 的新 pod，并公开 Zabbix Web 界面和 Zabbix 服务器 trapper 的端口：

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

2. （可选）在 zabbix pod 中运行 Zabbix agent 容器：

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. 在 RHEL 主机上创建 ./mysql/ 目录：

mkdir -p ./mysql

4. 运行一个空的 MySQL 服务器容器（将 zabbix_pwd 和 root_pwd 替换为强密码，并在后续步骤中使用这些密码）：

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. 查看 MySQL 日志，并等待 MySQL 准备好接受连接（使用 Ctrl+C 退出日志）：

podman logs -f mysql-server

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

6. 运行 Zabbix Java 网关容器：

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

7. 在 MySQL 服务器容器中启用 log_bin_trust_function_creators。 此设置会暂时放宽对存储函数的安全限制；在后续步骤中将禁用该设置。 启用后，Zabbix 数据库用户无需 SUPER 权限即可创建存储函数。当启用二进制日志记录时，MySQL 要求创建存储函数的用户具有该权限（MySQL 8.0 起默认启用二进制日志记录）。 运行以下命令：

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

8. 运行 Zabbix 服务器容器，并将其连接到 Java 网关和 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. 查看 Zabbix 服务器日志，并等待 Zabbix 服务器完成数据库架构初始化（使用 Ctrl+C 退出日志）：

podman logs -f zabbix-server-mysql

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

10. 在 MySQL 服务器容器中禁用 log_bin_trust_function_creators。 此操作会重新启用禁止非 SUPER 用户创建存储函数的安全限制。 运行以下命令：

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

11. 运行 Zabbix Web 界面容器，并将其连接到 Zabbix 服务器和 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

容器启动并运行后，Zabbix 服务器将启动，Web 界面可用于登录。