5 从容器安装

概述

本页介绍如何使用 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 trap 使用 162/UDP）。 有关 Zabbix 组件使用的端口完整列表，请参阅 Requirements。 对于 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 上最新的 7.4 次版本 Zabbix 服务器 (MySQL)：
docker pull zabbix/zabbix-server-mysql:alpine-7.4-latest

# Alpine Linux 上 Zabbix 服务器 (MySQL) 的 7.4.1 版本：
docker pull zabbix/zabbix-server-mysql:alpine-7.4.1

Docker Compose

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

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

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

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

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 interface container 使用
• 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 配置文件：

# 默认部署 + 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.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.4-latest

此命令会：

• 拉取 zabbix/zabbix-proxy-sqlite3:alpine-7.4-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 进行监控。

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

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

更多示例，请参阅 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.0-oracle \
  --character-set-server=utf8mb4 --collation-server=utf8mb4_bin \
  --default-authentication-plugin=mysql_native_password

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

docker run --name zabbix-java-gateway -t \
  --network=zabbix-net \
  --restart unless-stopped \
  -d zabbix/zabbix-java-gateway:alpine-7.4-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-7.4-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-7.4-latest

容器启动并运行后（通常需要 1–3 分钟），Zabbix 服务器就会启动，web 界面可通过 http://localhost 访问。

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

此示例展示了如何部署一个带有 PostgreSQL 后端、SNMP trap 和基于 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 trap 容器：

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

4. 运行一个 Zabbix 服务器容器，并将其连接到 PostgreSQL 服务器容器和 SNMP trap 容器（将 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-7.4-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-7.4-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 server 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-74: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.0 \
  --character-set-server=utf8mb4 --collation-server=utf8mb4_bin \
  --default-authentication-plugin=mysql_native_password

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

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

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

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