从容器安装

概述

本页面介绍如何使用 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 界面可通过 http://localhost 访问。

环境变量

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 任务的快捷方式。
您可以使用更短的 make 命令来代替完整的 docker compose 命令（运行 make help 可查看可用选项）：

# 默认部署（Zabbix 服务器、Web 界面、MySQL，全部基于 Alpine Linux）
make up

# 自定义部署（Zabbix 服务器、使用自定义 Nginx 端口的 Web 界面、PostgreSQL，全部基于 Ubuntu）
make up \
  OS=ubuntu \
  DB=pgsql \
  ZABBIX_WEB_NGINX_HTTP_PORT=8282 \
  ZABBIX_WEB_NGINX_HTTPS_PORT=8443

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

# 默认部署 + Zabbix agent、Java 网关、Web 服务和 SNMP traps：
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.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

此命令将：

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

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

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

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

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

以下示例还涵盖另外三种部署场景：

• 带有 Java 网关 的 Zabbix 服务器（MySQL）
• 带有 SNMP traps 的 Zabbix 服务器（PostgreSQL）
• 在 RHEL 8 上带有 Java 网关 的 Zabbix 服务器（MySQL）

如需更多示例，请参阅 Docker Hub 上各组件的 Docker 镜像 描述。

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

本示例展示了如何部署一个使用 MySQL 作为后端、使用 JMX 监控 的 Java 网关以及基于 Nginx 的 Web 界面的 Zabbix 服务器。

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 \
  --authentication-policy=caching_sha2_password

3. 运行一个 Zabbix Java 网关容器：

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

4. 运行一个 Zabbix 服务器容器，并将其连接到 MySQL 服务器容器（将 zabbix_pwd 和 root_pwd 替换为第 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. 运行一个 Zabbix Web 界面容器，并将其连接到 Zabbix 服务器和 MySQL 服务器容器（将 zabbix_pwd 和 root_pwd 替换为第 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

容器启动并运行后（通常在 1–3 分钟内），Zabbix 服务器即已启动，Web 界面可通过 http://localhost 访问。

使用 SNMP traps 部署 Zabbix 服务器（PostgreSQL）

本示例展示了如何部署一个使用 PostgreSQL 作为后端、支持 SNMP traps 以及基于 Nginx 的 Web 界面的 Zabbix 服务器。

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 traps 容器：

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 traps 容器（将 zabbix_pwd 替换为第 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. 运行一个 Zabbix Web 界面容器，并将其连接到 Zabbix 服务器和 PostgreSQL 服务器容器（将 zabbix_pwd 替换为第 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

容器启动并运行后（通常在 1–3 分钟内），Zabbix 服务器即已启动，Web 界面可通过 http://localhost 访问。

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

本示例展示了如何在 Red Hat Enterprise Linux 8、9 或 10 上部署一个使用 MySQL 作为后端、使用 JMX 监控 的 Java 网关以及基于 Nginx 的 Web 界面的 Zabbix 服务器。

在 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 \
  --authentication-policy=caching_sha2_password

5. 运行一个 Zabbix Java 网关容器：

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

6. 运行一个 Zabbix 服务器容器（将 zabbix_pwd 和 root_pwd 替换为第 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. 运行一个 Zabbix Web 界面容器（将 zabbix_pwd 和 root_pwd 替换为第 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