Zabbix7-IT-基础设施监控秘籍第三版-全-

Zabbix7 IT 基础设施监控秘籍第三版（全）

原文：annas-archive.org/md5/74d6e1997f063295d429f8383644708c

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

欢迎阅读 Zabbix 7 IT 基础设施监控宝典。IT 基础设施包括从 Windows 和 Linux 到网络和开发，基本上涵盖所有运行在计算机硬件上的内容。本书将涵盖对任何希望使用 Zabbix 监控其 IT 基础设施的 IT 从业者有用的多个主题。

本书适用对象

监控系统在 IT 组织中常常被忽视，但它们可以提供一种概览，帮助你节省时间、金钱和避免麻烦。本书适合那些想学习 Zabbix 7，并了解如何利用它将 IT 环境提升到新水平的 IT 工程师。

本书的内容

第一章，安装 Zabbix 并开始使用前端界面，讲解了如何设置 Zabbix（可选配置 HA），并逐步熟悉其菜单。

第二章，使用 Zabbix 用户管理进行准备工作，讲解了如何设置第一个用户、用户组和用户角色。

第三章，设置 Zabbix 监控，讲解了如何在 Zabbix 中设置几乎所有类型的监控。

第四章，与触发器和告警的配合使用，讲解了如何设置触发器并从中获取告警。

第五章，构建你自己的结构化模板，讲解了如何构建结构化的模板，帮助你保持 Zabbix 配置的整洁有序。

第六章，数据可视化、库存与报告，讲解了如何在图表、地图和仪表板中可视化数据。同时介绍了如何使用 Zabbix 的库存、报告和业务服务监控功能。

第七章，使用发现功能进行自动创建，讲解了如何使用 Zabbix 的发现功能进行自动主机创建以及与代理、SNMP、WMI 和 JMX 配合使用的项目、触发器等。

第八章，设置 Zabbix 代理，讲解了如何正确设置 Zabbix 代理以便在生产环境中使用，同时引入了新的代理高可用性功能。

第九章，将 Zabbix 与外部服务集成，讲解了如何将 Zabbix 与外部服务集成以进行告警处理。

第十章，通过自定义脚本和 Zabbix API 扩展 Zabbix 功能，讲解了如何通过自定义脚本和 Zabbix API 扩展 Zabbix 的功能。

第十一章，维护你的 Zabbix 配置，讲解了如何维护 Zabbix 配置，并确保其随着时间的推移保持良好的性能。

第十二章，高级 Zabbix 数据库管理，教授如何管理 Zabbix 数据库以实现高级配置。

第十三章，将 Zabbix 带入云端：Zabbix 云集成，介绍了如何使用 Zabbix 与 AWS、Azure、Docker 和 Kubernetes 等云服务。

要充分利用本书

你应该具备一定的 IT 基础，才能理解本书中使用的术语。本书最适合那些至少具备基本监控系统、Linux 和网络工程知识的人。

本书中涵盖的软件/硬件	操作系统要求
Zabbix 7	Linux（任何版本）
Python 3
MariaDB（MySQL）
PostgreSQL
NGINX
VIM

确保你已经准备好虚拟化环境，以便为食谱创建虚拟机。VirtualBox、VMware 或任何其他类型的客户端/虚拟机监控器都可以使用。

在本书中，我们将使用 Vim 编辑文件，所以请确保安装了它。如果你不习惯使用 Vim，可以用 Nano 或其他你喜欢的编辑器替代。

如果你使用的是本书的数字版，建议你自己输入代码，或者通过 GitHub 仓库访问代码（下一个部分会提供链接）。这样做可以帮助你避免复制粘贴代码时可能出现的错误。

下载示例代码文件

你可以从 GitHub 下载本书的示例代码文件，网址为github.com/PacktPublishing/Zabbix-7-IT-Infrastructure-Monitoring-Cookbook。如果代码有更新，它将更新在现有的 GitHub 仓库中。

我们还提供了来自我们丰富书籍和视频目录的其他代码包，可以在github.com/PacktPublishing/找到。快来看看吧！

使用的约定

本书中使用了许多文本约定。

文本中的代码：表示文本中的代码词，数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 用户名。例如：“这里将log_bin_trust_function_creators函数设置为1，以允许导入初始数据库数据。”

一块代码的设置方式如下：

# listen 8080; 
# server_name example.com;

当我们希望你特别注意代码块中的某个部分时，相关行或项目会以粗体显示：

# MariaDB Server
# To use a different major version of the server, or to pin to a specific minor version, change URI below. deb [arch=amd64,arm64] https://dlm.mariadb.com/repo/mariadbserver/11.4/repo/ubuntu jammy main

任何命令行输入或输出都以以下方式写出：

systemctl start mariadb

粗体：表示一个新术语、一个重要的词，或在屏幕上看到的词。例如，菜单或对话框中的词会以这样的形式出现在文本中。这里有一个例子：“我们还需要为我们的集群节点提供一个虚拟 IP（VIP）地址。”

提示或重要说明

看起来是这样的。

部分

本书中有几个常见的标题（准备工作、如何做...、它是如何工作的...、还有更多... 和另见）。

为了清晰地指示如何完成一个食谱，请按照以下方式使用这些部分：

准备工作

本节告诉你在食谱中可以期待什么，并描述了设置任何软件或进行食谱所需的任何初步设置的方法。

如何操作…

本节包含遵循食谱所需的步骤。

它是如何运作的…

本节通常包括对上一节所发生内容的详细解释。

还有更多…

本节包含与食谱相关的额外信息，帮助你更深入地了解食谱。

另见

本节提供了有用的链接，指向与食谱相关的其他有用信息。

与我们联系

我们始终欢迎读者的反馈。

一般反馈：如果你对本书的任何方面有疑问，请在邮件主题中注明书名，并通过电子邮件联系 customercare@packtpub.com。

勘误：尽管我们已尽最大努力确保内容的准确性，但错误确实会发生。如果你在本书中发现错误，我们将非常感激你能报告给我们。请访问www.packtpub.com/support/errata，选择你的书籍，点击勘误提交表格链接并填写详细信息。

盗版：如果你在互联网上发现任何非法复制的我们作品的形式，我们将非常感激你提供其位置地址或网站名称。请通过电子邮件将包含链接的材料信息发送至 copyright@packt.com。

如果你有兴趣成为作者：如果你在某个领域有专业知识，并且有兴趣撰写或参与书籍的编写，请访问authors.packtpub.com。

在我们开始之前

无论你是 Zabbix 的真正高手，还是刚刚开始使用 Zabbix，本书都会包含适合每个人的食谱。我们将涵盖大部分 Zabbix 基础知识，甚至在书中展示如何使用 Zabbix API 和数据库做一些很酷的事情。

我们决定编写这本书，因为我们认为成为社区的一部分很重要，并且希望以一种清晰、直接的方式，从可靠的来源为你提供在线和官方 Zabbix 培训材料中的信息。我们都经历过收藏那些令人惊叹的社区博客文章、社区指南，甚至官方文档的过程。有时候信息量可能有点大，这也是本书能够帮忙的地方。把它看作是你的一本指南，提供给每个人所需的内容，而不需要不停地 Google，直到你的手指累垮。

即使您已经积累了一定经验，阅读完这本书或其他书籍，并且已收藏了关于 Zabbix 的每个有用页面，您可能仍然不完全了解所有内容。这时我们可以提供帮助。Zabbix 是一个基于惊人的开源社区的免费产品，除此之外，还有一些真正的 Zabbix 大师，他们决定以此为生。我们的公司，Opensource ICT Solutions，就是从这些朴素的起点开始的，我们致力于为客户提供与 Zabbix 相关的所有支持。作为 Zabbix 的高级合作伙伴，我们提供以下服务：

官方 Zabbix 培训
官方 Zabbix 支持
Zabbix 咨询服务
交钥匙解决方案
定制集成
24/7 可用的服务台

由于提供 Zabbix 服务是我们的核心业务，我们每天都能接触到不同的环境、不同的客户和不同的产品使用案例，同时为全球客户提供最佳解决方案。作为官方培训合作伙伴，我们不仅仅是构建环境，更重要的是分享知识并教导他人如何最大化利用该产品。

所以，如果您喜欢这本书，请考虑关注我们和其他 Zabbix 社区的成员。请在 LinkedIn（以及其他社交媒体）上关注我们，任何时候需要帮助，请给我们打电话！我们将随时准备为您解答任何问题。

英国	荷兰	美国
Opensource ICT Solutions LTD	Opensource ICT Solutions B.V.	Opensource ICT Solutions LLC
电话: +44 20 4551 1827	电话: +31 (0)72 743 65 83	电话: +1-929-377-1232
https://oicts.cominfo@oicts.com

分享您的想法

阅读完Zabbix 7 IT 基础设施监控手册后，我们非常希望听到您的想法！请点击此处直接进入亚马逊评论页面并分享您的反馈。

您的评论对我们和技术社区至关重要，将帮助我们确保提供高质量的内容。

下载这本书的免费 PDF 副本

感谢您购买本书！

您喜欢随时随地阅读，但又无法随身携带纸质书籍吗？

您的电子书购买与所选设备不兼容吗？

不用担心，现在每本 Packt 书籍您都能免费获得该书的 DRM-free PDF 版本。

随时随地，在任何设备上阅读。从您最喜欢的技术书籍中直接搜索、复制并粘贴代码到您的应用程序中。

好处不止这些，您还可以获得独家折扣、时事通讯以及每日发送到您邮箱的优质免费内容。

按照以下简单步骤享受福利：

扫描二维码或访问以下链接

packt.link/free-ebook/978-1-80107-832-0

提交您的购买凭证
就这样！我们将直接把您的免费 PDF 和其他福利发送到您的电子邮件。

第一章：1

安装 Zabbix 并开始使用前端界面

对于 Zabbix 7，开发人员确实做得非常出色。在这个长期支持（LTS）版本中，我们将会发现更多的生活质量（QoL）改进，并且还加入了一些令人印象深刻的前沿特性。从 Zabbix 6.0 过渡过来，你仍然会看到 Zabbix 6.2 和 6.4 中的许多改进，因为这些版本的内容已经被包含在 Zabbix 7.0 LTS 中。我们将在本书中详细介绍所有重要的更改。

在本章中，我们将安装 Zabbix 服务器并浏览 Zabbix 用户界面，以帮助你熟悉它。我们将会介绍如何找到主机、触发器、仪表盘等，确保你能够自信地深入了解本书后续的内容。Zabbix 的用户界面有很多选项可以探索，如果你是刚开始使用，不要感到不知所措。它的结构设计得很清晰，一旦你掌握了它，我相信你能轻松找到自己的路径。你将在后续的教程中了解所有相关内容：

安装 Zabbix 服务器
设置 Zabbix 前端界面
启用 Zabbix 服务器高可用性（HA）
使用 Zabbix 前端界面
浏览 Zabbix 前端界面

技术要求

我们将从一台空的 Linux（虚拟）机器开始本章内容。你可以选择使用 RHEL 或 Debian 系列的 Linux 发行版（在示例中我们将使用 Ubuntu）。建议使用服务器版而非桌面版的 Linux 发行版。我们接下来将从零开始在这台主机上搭建 Zabbix 服务器。

所以在开始之前，确保你的 Linux 主机已准备好。我将在示例中使用 Rocky Linux 9 和 Ubuntu 22.04。

安装 Zabbix 服务器

在开始使用 Zabbix 之前，我们需要先安装它并做好准备。在本章中，我们将学习如何安装 Zabbix 服务器 7.0。

准备工作

在我们实际安装 Zabbix 服务器之前，我们需要完成一些前提条件。在本书中，我们将主要使用 MariaDB。MariaDB 很流行，并且有大量关于如何与 Zabbix 配合使用的信息。

到这一步，你应该已经准备好了一个运行着 RHEL 或 Debian 系列发行版的 Linux 服务器。我将会在我的服务器上安装 Rocky Linux 9 和 Ubuntu 22.04；我们将它们分别命名为lar-book-rocky和lar-book-ubuntu。

当你的服务器准备好后，我们可以开始安装过程。

如何操作…

让我们从将 Zabbix 7.0 仓库添加到系统开始。

对于基于 RHEL 的系统，运行以下命令：

rpm -Uvh https://repo.zabbix.com/zabbix/7.0/rocky/9/x86_64/zabbix-release-7.0-2.el9.noarch.rpm
dnf clean all

对于 Ubuntu 系统，运行以下命令：

wget https://repo.zabbix.com/zabbix/7.0/ubuntu/pool/main/z/zabbix-release/zabbix-release_7.0-1+ubuntu22.04_all.deb
dpkg -i zabbix-release_7.0-1+ubuntu22.04_all.deb
apt update

对于基于 RHEL 的系统，我们还需要删除 Zabbix 企业 Linux 扩展包（EPEL）仓库包（如果已安装）：
```
vim /etc/yum.repos.d/epel.repo
```
然后，添加以下行：
```
[epel]...excludepkgs=zabbix*
```

现在仓库已经添加，让我们在服务器上添加 MariaDB 仓库：

wget https://downloads.mariadb.com/MariaDB/mariadb_repo_setup
chmod +x mariadb_repo_setup
./mariadb_repo_setup

然后，安装并启用它。

对于基于 RHEL 的系统，运行以下命令：

dnf install mariadb-server
systemctl enable mariadb
systemctl start mariadb

对于 Ubuntu 系统，请运行以下命令：

apt install mariadb-server
systemctl enable mariadb
systemctl start mariadb

安装 MariaDB 后，请确保通过运行以下命令来保护您的安装：
```
mariadb-secure-installation
```
请确保回答问题时选择“是”（Y），并配置一个安全的 root 密码。
运行安全安装设置，并确保将密码保存在某个地方。强烈建议使用密码保险库。
现在，让我们安装支持 MySQL 的 Zabbix 服务器。

对于基于 RHEL 的系统，请运行以下命令：
```
dnf install zabbix-server-mysql zabbix-sql-scripts zabbix-selinux-policy
```
对于 Ubuntu 系统，请运行以下命令：
```
apt install zabbix-server-mysql zabbix-sql-scripts
```
安装了 Zabbix 服务器后，我们准备创建 Zabbix 数据库。使用以下命令登录 MariaDB：
```
mysql -u root -p
```

输入您在安全安装过程中设置的密码。接下来，我们将使用以下命令创建 Zabbix 数据库。不要忘记在第二个和第三个命令中更改密码，因为这将是用于连接到 Zabbix 数据库的密码：

create database zabbix character set utf8mb4 collate utf8mb4_bin;
create user zabbix@localhost identified by 'password';
grant all privileges on zabbix.* to zabbix@localhost identified by 'password';
set global log_bin_trust_function_creators = 1;
log_bin_trust_function_creators function is set to 1 here to allow the initial database data to be imported. We will disable it again afterwards.

提示

从 Zabbix 6 开始，Zabbix 默认使用 utf8mb4，这在所有安装文档中都有说明。我们在之前的命令中将 utf8 更改为 utf8mb4，以确保一切正常工作。参考资料，请查看 Zabbix 支持票据：support.zabbix.com/browse/ZBXNEXT-3706。

我们现在需要将 Zabbix 数据库架构导入到新创建的 Zabbix 数据库中：

zcat /usr/share/zabbix-sql-scripts/mysql/server.sql.gz | mariadb --default-character-set=utf8mb4 -u zabbix -p zabbix

如前所述，我们现在可以再次禁用 log_bin_trust_function_creators：
```
mysql -u root -p
set global log_bin_trust_function_creators = 0;
quit;
```

重要提示

此时，您可能会觉得系统卡住了并且没有响应。不过不用担心，这只是导入 SQL 架构需要一些时间。

我们现在已经完成了 MariaDB 方面的准备工作，准备进入下一步，即配置 Zabbix 服务器。

Zabbix 服务器是通过 Zabbix 服务器配置文件进行配置的。此文件位于 /etc/zabbix/。让我们用自己喜欢的编辑器打开这个文件；我将在本书中使用 Vim（但您可以根据需要用 vi 或 nano 替代 Vim）：
```
vim /etc/zabbix/zabbix_server.conf
```
现在，请确保文件中的以下行与您的数据库名称、数据库用户名和数据库用户密码相匹配：
```
DBName=zabbix
DBUser=zabbix
DBPassword=password
```

提示

在启动 Zabbix 服务器之前，您应该配置 SELinux 或 AppArmor 以允许使用 Zabbix 服务器。如果这是测试机器，您可以为 SELinux 使用宽松模式或禁用 AppArmor，但不建议在生产环境中这样做。

完成了；我们现在准备启动 Zabbix 服务器：

systemctl enable zabbix-server
systemctl start zabbix-server

使用以下命令检查是否一切按预期启动：
```
systemctl status zabbix-server
```
同时，请确保监控日志文件，该文件提供了 Zabbix 启动过程的详细描述：
```
tail -f /var/log/zabbix/zabbix_server.log
```
这个文件中的大部分消息都是正常的，可以安全地忽略，但请确保仔细阅读，看看 Zabbix 服务器启动时是否有任何问题。

它是如何工作的…

Zabbix 服务器是我们 Zabbix 设置的主要进程。它负责我们的监控、问题警报以及本书中描述的许多其他任务。一个完整的 Zabbix 堆栈至少包括以下组件：

一个数据库（MySQL/MySQL 分支，PostgreSQL，或 Oracle）
一个 Zabbix 服务器
Apache 或 NGINX 运行 Zabbix 前端并支持 PHP 8.0 或更高版本

我们可以通过下图看到各个组件以及它们如何相互通信：

图 1.1 – Zabbix 设置通信图

我们刚刚设置了 Zabbix 服务器和数据库，通过运行这两个组件，我们基本上已经准备好开始监控。Zabbix 服务器与 Zabbix 数据库通信，将收集到的值写入数据库。

但是还有一个问题：我们无法配置 Zabbix 服务器做任何事情。为此，我们需要 Zabbix 前端，我们将在下一个章节中进行设置。

设置 Zabbix 前端

Zabbix 前端是我们服务器的“面孔”。它是我们配置所有主机、模板、仪表板、地图和其他所有内容的地方。没有它，我们将无法看到服务器端的情况。因此，在本章节中，我们将设置 Zabbix 前端。

准备工作

我们将使用 NGINX 来设置 Zabbix 前端。虽然也可以使用 Apache，但 NGINX 的速度更快，因此它在性能上略优于 Apache。由于安装 NGINX 和 Apache 都非常简单，如果前端用户较多，建议使用 NGINX。在开始本章之前，请确保您正在 Linux 发行版上运行 Zabbix 服务器。我将在这些章节中使用 lar-book-rocky 和 lar-book-ubuntu 主机，展示在 Rocky Linux 9 和 Ubuntu 22.04 上的设置过程。

如何操作…

让我们直接进入，安装前端。

对于基于 RHEL 的系统，请运行以下命令：
```
dnf module switch-to php:8.3
dnf install zabbix-web-mysql zabbix-nginx-conf
```
对于 Ubuntu 系统，请运行以下命令：
```
apt install zabbix-frontend-php zabbix-nginx-conf
```

提示

如果您正在使用防火墙，请不要忘记允许80和443端口。没有这一步，您将无法连接到前端。

接下来，我们需要配置 NGINX 配置文件。

对于基于 RHEL 的系统，请编辑以下文件：
```
/etc/nginx/conf.d/zabbix.conf
```
对于 Ubuntu 系统，请编辑以下文件：
```
/etc/zabbix/nginx.conf
```

然后，编辑以下两行：

# listen 8080;
# server_name example.com;

将其修改为如下：

listen 80;
server_name 192.168.0.50;

重要提示

在server_name，重要的是添加运行此 NGINX（Zabbix）网页的 IP 地址。请在此处添加您希望前端可用的 IP 地址或 DNS 名称。

重新启动 Zabbix 组件，并确保它们在服务器启动时自动启动。

对于基于 RHEL 的系统，请运行以下命令：
```
systemctl enable nginx php-fpm
systemctl restart nginx php-fpm
```
对于 Ubuntu 系统，请运行以下命令：
```
systemctl enable nginx
systemctl restart nginx php-fpm
```
我们现在应该能够顺利访问我们的 Zabbix 前端，并开始进行设置 Zabbix 前端的最后步骤。
让我们打开浏览器并导航到服务器的 IP 地址。它应该看起来像这样：
```
http://<your_server_ip>/
```

重要提示

在 Ubuntu（某些情况下），你可能需要添加端口 8080，以后你可能会想把它改为 80 端口（或者在添加 SSL 后为 443）。在这种情况下，URL 应该是这样的：

http://<your_server_ip>:8080/

现在我们应该能看到以下网页：

图 1.2 – Zabbix 欢迎页面

如果你没有看到这个网页，可能是你错过了安装过程中的某些步骤。回溯你的步骤，仔细检查配置文件；即使是一个小的拼写错误，也可能导致网页无法显示。

在这个页面上点击下一步继续，这将带你进入下一页：

图 1.3 – Zabbix 安装前提页面

现在这里的每一个选项应该都显示OK；如果没有，修正它所显示的错误。如果一切正常，你可以通过再次点击下一步来继续，这将带你进入下一页：

图 1.4 – Zabbix 安装数据库连接页面

在这里，我们需要告诉 Zabbix 前端 MySQL 数据库的位置。因为我们将其安装在 localhost 上，所以只需要确保提供正确的数据库名称、数据库用户名和数据库密码。
这应该使 Zabbix 前端能够与数据库通信。让我们通过再次点击下一步来继续：

图 1.5 – Zabbix 安装服务器详细页面

接下来是 Zabbix 服务器配置。确保给你的服务器起个有用的名字或酷一点的名字。例如，我设置了一个名为 Meeseeks 的生产服务器，因为每次收到警报时，我们都可以让 Zabbix 说“我是 Mr. Meeseeks。看我！”。但像 zabbix.example.com 这样的名字也可以。

让我们给服务器命名，设置时区以匹配我们的本地时区，然后继续下一步：

图 1.6 – Zabbix 安装总结页面

验证你的设置后，再次点击下一步继续：

图 1.7 – Zabbix 安装完成页面

你已经成功安装了 Zabbix 前端。现在你可以点击完成按钮，我们可以开始使用前端界面。你将看到一个登录页面，你可以使用以下默认凭据：
- 用户名：Admin
- 密码：zabbix

请记住，用户名和密码字段是区分大小写的。

工作原理…

现在我们已经安装了 Zabbix 前端，我们的 Zabbix 设置已完成，我们可以开始使用它了。我们的 Zabbix 前端将连接到我们的数据库，以编辑我们设置的配置值，正如我们在下面的图表中可以看到的那样：

图 1.8 – Zabbix 设置通信图

Zabbix 前端还将与我们的 Zabbix 服务器进行通信，但这仅是为了确保 Zabbix 服务器正常运行并提供一些额外功能，例如项目上的测试按钮。现在我们知道如何设置 Zabbix 前端后，我们可以开始使用它。在下一个示例后，我们来看看这个。

还有更多...

Zabbix 提供了一个非常方便的设置指南，其中包含有关安装 Zabbix 的详细信息。我始终建议在安装 Zabbix 时保持此页面打开，因为它包含诸如最新存储库链接的信息。在这里查看：

www.zabbix.com/download

启用 Zabbix 服务器 HA

Zabbix 6 附带了有史以来最受期待的功能之一，即高可用性（HA）。这一功能将通过确保如果您的一个 Zabbix 服务器出现问题，则另一个服务器将接管来将您的 Zabbix 设置提升到新的水平。当然，这一功能在 Zabbix 7 中仍然可用，我们将充分利用它。

这种实现的一个很大的优点是支持一个易于使用的专有方式将多个 Zabbix 服务器放入集群中：这是确保您的监控始终保持在线（或至少尽可能长时间在线）的绝佳方式。

Zabbix 服务器的设置将是主/备份方式，因为我们不能在 Zabbix 服务器端执行诸如负载均衡之类的操作。然而，可以使用 Zabbix 代理支持负载均衡，我们将在第八章中讨论设置 Zabbix 代理。

准备就绪

在开始之前，请注意创建高可用设置被认为是一个高级主题。这可能比本章其他示例更加困难。

对于此设置，我们将需要三台新的虚拟机，因为我们将创建一个分割的 Zabbix 设置，与本章第一个示例创建的设置不同。让我们看看我已经命名的三台新虚拟机及其 IP 地址：

lar-book-ha1 (192.168.0.1)
lar-book-ha2 (192.168.0.2)
lar-book-ha-db (192.168.0.10)

这些服务器中的两台将运行我们的 Zabbix 服务器集群和一个 Zabbix 前端。另一台服务器仅用于我们的 MySQL 数据库。请注意，示例中使用的 IP 地址可能与您的环境中的实际情况不同。请使用适合您环境的正确 IP 地址。

在示例中，我们还需要一个 192.168.0.5。

提示

在我们的设置中，我们只使用一个 MySQL Zabbix 数据库。为了确保 Zabbix 的所有部分都被设置为高可用，可能值得考虑将 MySQL 设置为主/主模式。这与 Zabbix 服务器的高可用性结合使用会是一个不错的选择。

本指南不会使用 SELinux 或 AppArmor，因此在使用本指南之前或过程中，请确保添加正确的策略。也可以禁用 SELinux，但在生产环境中不推荐这样做。此外，本指南没有详细说明如何设置防火墙，因此请确保提前进行设置。

如何操作…

为了方便起见，我们将 如何操作… 部分分成了三部分。第一部分是设置数据库，接下来是设置 Zabbix 服务器集群，最后是如何冗余地设置 Zabbix 前端。然后，它是如何工作的… 部分将解释整个设置过程。

设置数据库

让我们从设置 Zabbix 数据库开始，准备在高可用 Zabbix 服务器设置中使用。

登录到 lar-book-ha-db 并在基于 Red Hat 的系统上使用以下命令安装 MariaDB 仓库：

wget https://downloads.mariadb.com/MariaDB/mariadb_repo_setup
chmod +x mariadb_repo_setup
./mariadb_repo_setup

然后，让我们安装 MariaDB 服务器应用程序。

对于基于 RHEL 的系统，运行以下命令：

dnf install mariadb-server
systemctl enable mariadb
systemctl start mariadb

对于 Ubuntu 系统，运行以下命令：

apt install mariadb-server
systemctl enable mariadb
systemctl start mariadb

安装 MariaDB 后，确保使用以下命令来保护您的安装：
```
mariadb-secure-installation
```
确保回答问题时选择是（Y），并配置一个安全的 root 密码。强烈建议使用密码保险库来存储它。
现在，让我们为 Zabbix 服务器创建 Zabbix 数据库，以便连接。使用以下命令登录 MariaDB：
```
mariadb -u root -p
```

输入在安全安装过程中设置的密码。接下来，我们将使用以下命令创建一个 Zabbix 数据库。不要忘记在第二、第三和第四个命令中更改 password：

create database zabbix character set utf8mb4 collate utf8mb4_bin;
create user zabbix@'192.168.0.1' identified by 'password';
create user zabbix@'192.168.0.2' identified by 'password';
create user zabbix@'192.168.0.5' identified by 'password';
grant all privileges on zabbix.* to 'zabbix'@'192.168.0.1' identified by 'password';
grant all privileges on zabbix.* to 'zabbix'@'192.168.0.2' identified by 'password';
grant all privileges on zabbix.* to 'zabbix'@'192.168.0.5' identified by 'password';
set global log_bin_trust_function_creators = 1;
quit

最后，我们需要导入初始的 Zabbix 数据库配置，但为此，我们需要先安装 Zabbix 仓库。

对于基于 RHEL 的系统，运行以下命令：

rpm -Uvh https://repo.zabbix.com/zabbix/7.0/rocky/9/x86_64/zabbix-release-7.0-2.el9.noarch.rpm
dnf clean all

对于 Ubuntu 系统，运行以下命令：

wget https://repo.zabbix.com/zabbix/7.0/ubuntu/pool/main/z/zabbix-release/zabbix-release_7.0-1+ubuntu22.04_all.deb
dpkg -i zabbix-release_7.0-1+ubuntu22.04_all.deb
apt update

然后，我们需要安装 Zabbix 模块的 SQL 脚本。

对于基于 RHEL 的系统，运行以下命令：
```
dnf install zabbix-sql-scripts
```
对于 Ubuntu 系统，运行以下命令：
```
apt install zabbix-sql-scripts
```

然后，我们执行以下命令，这可能需要一段时间，请耐心等待直到完成：

zcat /usr/share/doc/zabbix-sql-scripts/mysql/server.sql.gz | mysql --default-character-set=utf8mb4 -u root -p zabbix

在此步骤之后，我们需要禁用 log_bin_trust_function_creators：
```
mysql -u root -p
set global log_bin_trust_function_creators = 0;
quit;
```

设置 Zabbix 服务器集群节点

设置集群节点的方式与设置任何新 Zabbix 服务器的方式相同。唯一的区别是我们需要指定一些新的配置参数。

让我们从将 Zabbix 7.0 仓库添加到 lar-book-ha1 和 lar-book-ha2 系统开始：

rpm -Uvh https://repo.zabbix.com/zabbix/7.0/rocky/9/x86_64/zabbix-release-7.0-2.el9.noarch.rpm
dnf clean all

对于 Ubuntu 系统，使用以下命令：

wget https://repo.zabbix.com/zabbix/7.0/ubuntu/pool/main/z/zabbix-release/zabbix-release_7.0-1+ubuntu22.04_all.deb
dpkg -i zabbix-release_7.0-1+ubuntu22.04_all.deb
apt update

现在，让我们安装 Zabbix 服务器应用程序。

对于基于 RHEL 的系统，运行以下命令：
```
dnf install zabbix-server-mysql zabbix-selinux-policy
```
对于 Ubuntu 系统，运行以下命令：
```
apt install zabbix-server-mysql
```
现在，我们将编辑 Zabbix 服务器配置文件，从lar-book-ha1开始。执行以下命令：
```
vim /etc/zabbix/zabbix_server.conf
```
然后，添加以下行以允许数据库连接：
```
DBHost=192.168.0.10
DBPassword=password
```
默认情况下，DBName 和 DBUser 都设置为zabbix。如果你使用了不同的数据库和/或用户名，你也需要更改这些设置。
要在此主机上启用 HA，请在相同的文件中添加以下行：
```
HANodeName=lar-book-ha1
```
为了确保我们的 Zabbix 前端知道在节点故障转移时连接到哪里，填写以下内容：
```
NodeAddress=192.168.0.1
```
保存文件，然后我们将通过编辑lar-book-ha2主机的文件，做相同的操作：
```
vim /etc/zabbix/zabbix_server.conf
```
然后，添加以下行以允许数据库连接：
```
DBHost=192.168.0.10
DBPassword=password
```
默认情况下，DBName 和 DBUser 都设置为zabbix。如果你使用了不同的数据库和/或用户名，你也需要更改这些设置。
要在此主机上启用 HA，请在相同的文件中添加以下行：
```
HANodeName=lar-book-ha2
```
为了确保我们的 Zabbix 前端知道在节点故障转移时连接到哪里，填写以下内容：
```
NodeAddress=192.168.0.2
```

保存文件，然后让我们启动 Zabbix 服务器：

systemctl enable zabbix-server
systemctl start zabbix-server

设置带有 HA 的 NGINX

为确保我们的前端也已设置，当一个 Zabbix 服务器出现问题时，它能够故障转移，我们将使用keepalived进行设置。让我们看看如何做到这一点。

让我们从登录到lar-book-ha1和lar-book-ha2开始，并安装keepalived。

对于基于 RHEL 的系统，运行以下命令：
```
dnf install -y keepalived
```
对于 Ubuntu 系统，运行以下命令：
```
apt install keepalived
```
然后，在lar-book-ha1上，使用以下命令编辑keepalived配置：
```
vim /etc/keepalived/keepalived.conf
```

删除此文件中的所有内容（如果文件尚未为空），然后将以下文本添加到文件中：

vrrp_track_process chk_nginx {
      process nginx
      weight 10
}
vrrp_instance ZBX_1 {
        state MASTER
        interface ens192
        virtual_router_id 51
        priority 244
        advert_int 1
        authentication {
                auth_type PASS
                auth_pass password
        }
        track_process {
                chk_nginx
        }
        virtual_ipaddress {
                192.168.0.5/24
        }
}

别忘了将password更新为安全密码，并将ens192接口修改为你自己的接口名称/编号。

重要提示

在之前的文件中，我们指定了virtual_router_id 51；请确保虚拟路由器 ID 51 在网络中尚未使用。如果已使用，请简单地在整个操作中更改虚拟路由器 ID。

在lar-book-ha2上，使用以下命令编辑相同的文件：
```
vim /etc/keepalived/keepalived.conf
```

使用dG删除文件中的所有内容（如果你使用的是 vim），这次我们将添加以下信息：

vrrp_track_process chk_nginx {
      process nginx
      weight 10
}
vrrp_instance ZBX_1 {
        state BACKUP
        interface ens192
        virtual_router_id 51
        priority 243
        advert_int 1
        authentication {
                auth_type PASS
                auth_pass password
        }
        track_process {
                chk_nginx
        }
        virtual_ipaddress {
                192.168.0.5/24
        }
}

再次提醒，不要忘记将password更新为安全密码，并将ens192接口修改为你自己的接口名称/编号。

现在，让我们安装 Zabbix 前端。

对于基于 RHEL 的系统，运行以下命令：

dnf install nginx zabbix-web-mysql zabbix-nginx-conf zabbix-selinux-policy
apt install nginx zabbix-frontend-php zabbix-nginx-conf

然后，我们将配置我们的 NGINX 配置。

对于基于 RHEL 的系统，请编辑以下文件：
```
/etc/nginx/conf.d/zabbix.conf
```
对于 Ubuntu 系统，编辑以下文件：
```
/etc/zabbix/nginx.conf
```

然后，编辑以下两行：

# listen 8080;
# server_name example.com;

使其看起来像这样：

listen 80;
server_name 192.168.0.5;

重要提示

在server_name处，重要的是要添加此 NGINX（Zabbix）网页将运行的 IP 地址。请在此处添加前端可用的 IP 地址或 DNS 名称。在此案例中，我们添加了keepalived将管理的 VIP 地址。

启动 Web 服务器和keepalived，使你的 Zabbix 前端可用，使用以下命令：
```
systemctl enable nginx keepalived
systemctl start nginx keepalived
```
然后，我们可以开始配置我们的 Zabbix 前端。导航至您的 VIP 地址（在示例 IP 案例中为 http://192.168.0.5/），您将看到以下页面：

图 1.9 – lar-book-ha1 的 Zabbix 初始配置窗口

连续点击两次 下一步 直到看到以下页面：

图 1.10 – lar-book-ha1 的 Zabbix 数据库配置窗口

确保用我们 Zabbix MariaDB 数据库的 IP 地址（192.168.0.10）填写 数据库主机。然后，为我们的 zabbix 数据库用户填写数据库密码。
然后，作为最后一步，对于我们的第一个节点，将 Zabbix 服务器名称 设置为 lar-book-ha1，并选择您的时区，如下截屏所示：

图 1.11 – lar-book-ha1 的 Zabbix 服务器设置窗口

然后，点击 下一步 和完成。
现在，我们需要对第二个前端执行相同的操作。登录到 lar-book-ha1。

对于基于 RHEL 的系统，请执行以下操作：
```
systemctl stop nginx
```
对于 Ubuntu 系统，请执行以下操作：
```
systemctl stop nginx
```
当导航到您的 VIP（在示例 IP 案例中为 http://192.168.0.5/zabbix）时，您将再次看到相同的配置向导。
重新填写数据库详细信息：

图 1.12 – lar-book-ha2 的 Zabbix 数据库配置窗口

确保将 Zabbix 服务器名称 设置为 lar-book-ha2，如下截屏所示：

图 1.13 – lar-book-ha2 的 Zabbix 服务器设置窗口

现在，我们需要再次启用 lar-book-ha1 前端，方法如下：
```
systemctl start nginx
```

这应该是我们的最后一步。现在一切应该按预期工作。确保检查您的 Zabbix 服务器日志文件，以查看 HA 节点是否按预期运行。

它是如何运作的...

现在我们已经完成了，Zabbix 服务器在 HA 模式下实际上是如何工作的呢？让我们从检查我们 Zabbix 前端的报告 | 系统信息 页面开始：

图 1.14 – lar-book-ha1 的 Zabbix 服务器系统信息及 HA 信息

现在我们可以看到一些新的可用信息；例如，高可用性集群 参数。此参数现在告诉我们 HA 是否已启用以及故障转移延迟是多少。在我们的情况下，这是 1 分钟，这意味着在启动故障转移之前可能需要最多 1 分钟的时间。

此外，我们可以看到集群中的每个节点。由于 Zabbix 现在支持集群中的一对多节点，我们可以在这里看到每个节点参与的情况。让我们看看我们建立的设置：

图 1.15 – Zabbix 服务器 HA 设置

正如你在设置中看到的，我们已经将两个 Zabbix 服务器节点 lar-book-ha1 和 lar-book-ha2 连接到我们的单一 Zabbix 数据库 lar-book-ha-db。因为我们的 Zabbix 数据库就是 Zabbix 服务器配置文件中的 HANodeName 值。

我们还在配置文件中加入了 NodeAddress 参数。该参数由 Zabbix 前端使用，确保我们的系统信息（小部件）和 Zabbix 服务器不运行前端通知工作。NodeAddress 参数会告诉前端在每个对应的服务器成为活动 Zabbix 服务器时，应该连接哪个 IP 地址。

为了进一步提高系统的可用性，我还为此安装添加了简单的 keepalived 设置。keepalived 配置是一种在 Linux 服务器之间构建简单 VRRP 故障转移设置的方法。在我们的案例中，我们已将 VIP 设置为 192.168.0.5 并添加了 chk_nginx 进程监控，用于确定何时进行故障转移。我们的故障转移机制如下：

lar-book-ha1 has priority 244
lar-book-ha2 has priority 243

如果 NGINX 在我们的节点上运行，它会为我们的优先级增加 10 分，导致总优先级分别为 254 和 253。现在，假设 lar-book-ha1 不再运行 Web 服务器进程。这意味着它的优先级会降到 244，低于 lar-book-ha2 上的 253，后者正在运行 Web 服务器进程。

拥有最高优先级的主机会获得 192.168.0.5 VIP，这意味着该主机正在运行 Zabbix 前端，并将提供服务。

通过结合这两种 HA 设置方式，我们已经为 Zabbix 设置中的两个部分创建了冗余，确保可以将故障时间降到最低。

使用 Zabbix 前端

如果这是你第一次使用 Zabbix，恭喜你进入了用户界面。如果你是返回的 Zabbix 用户，可能会注意到 Zabbix 7 用户界面有些变化。我们将介绍在 Zabbix 前端中可以找到的一些不同元素，让你在本书过程中，能自信地找到所需的所有内容。

准备就绪

要开始使用 Zabbix 用户界面，我们只需要登录到前端。你将看到以下页面，这个页面位于运行 Zabbix 前端的服务器的 IP 上：

图 1.16 – Zabbix 登录界面

确保使用默认凭据登录 Zabbix 前端：

用户名：Admin
密码：zabbix

提示

就像在 Linux 中一样，Zabbix 在大多数地方是区分大小写的。输入用户名时，请确保大小写正确；否则，你将无法登录！

如何操作…

登录后，你将看到默认页面，即默认仪表板。这就是 Zabbix 所称的全局视图，它为我们提供了一个清晰的概览，让我们了解当前的情况。我们可以完全自定义这个以及 Zabbix 提供的所有其他仪表板，但在构建新的仪表板之前，最好先熟悉默认设置：

图 1.17 – 全局视图仪表板

那么，让我们通过查看默认仪表板来开始熟悉 Zabbix 7 前端。请按照前端的指引，点击并查看所提到的内容。

Zabbix 使用仪表板，并且这些仪表板充满了小部件来显示信息。让我们逐一了解默认仪表板中的不同小部件，并详细介绍它们所提供的信息。

我们先从系统信息小部件开始：

图 1.18 – 系统信息小部件

系统信息小部件，顾名思义，提供了所有系统信息。这样，我们可以随时关注 Zabbix 服务器的状态，看看它是否正常运行。

让我们来了解一下这些参数：

Zabbix 服务器是否运行：通知我们 Zabbix 服务器后端是否正在运行，以及它的运行位置。在这种情况下，它正在运行，并且运行在localhost:10051。
Zabbix 服务器版本/Zabbix 前端版本：现在我们有了单独的指示器，详细显示我们的 Zabbix 服务器和前端的版本。
最后检查的软件更新：这是另一项新增功能。Zabbix 现在会为你检查新的版本，并在下方的列中指示最新版本。
最新版本：此项将显示 Zabbix 的最新可用版本。
主机数量（启用/禁用）：此项将显示启用的主机数量（15）和禁用的主机数量（5）。
模板数量：这显示了我们拥有的模板总数（284）。
项数量（启用/禁用/不支持）：在这里，我们可以看到 Zabbix 服务器的项的详细信息——在此案例中，启用（564）、禁用（240）和不支持（216）。
触发器数量（启用/禁用 [问题/正常]）：这显示了触发器的数量。我们可以看到有多少被启用（371）和禁用（38），还可以看到多少处于问题状态（13），多少处于正常状态（358）。
用户数量（在线）：第一个值详细说明了总用户数。第二个值详细说明了当前登录到 Zabbix 前端的用户数。
所需服务器性能，新的每秒值：也许我在这里向你介绍一个全新的概念，那就是每秒新值，或NVPS。服务器通过项接收或请求值，并将其写入我们的 MariaDB 数据库（或其他数据库）。这里详细的 NVPS 信息显示了 Zabbix 服务器接收的估计每秒新值数。在 Zabbix 服务器增长的过程中，密切关注这个指标，它是衡量你需要多快扩展的良好指示器。
高可用性集群：如果你正在运行 Zabbix 服务器 HA 集群，你会看到它是否已启用以及故障转移延迟是多少。此外，系统信息页面将显示额外的 HA 信息。

根据你的配置，你可能还会看到两个附加值：

数据库历史表已升级：如果你看到这个，说明你的一个数据库历史表尚未升级。数值（浮动）表已扩展，允许每个数据点保存更多字符。这个表在从 Zabbix 4 升级到 5 或更高版本时不会自动升级，因为并非每个人都需要它，而且升级可能需要很长时间。
数据库名称：如果你看到数据库名称以及版本号的值，这可能表示你正在使用不受支持的数据库版本。你可能会看到类似以下的消息：警告！不受支持的数据库服务器版本。应该至少为 <****DATABASE VERSION>。

这是涉及 Zabbix 服务器时最重要的小部件之一，如果你问我，它是值得保留在主仪表板上的一个小部件。

让我们继续下一个小部件，主机可用性：

图 1.19 – 主机可用性小部件

主机可用性小部件是一个快速概览小部件，可以显示你想要了解的所有监控主机的可用性状态。在此小部件中，它会显示主机是否可用、不可用或状态未知。这样，你可以在一个小部件中全面了解通过 Zabbix 服务器监控的所有主机的可用性。

旁边是按 严重性划分的问题小部件：

图 1.20 – 按严重程度分类的问题小部件

它会显示当前有多少主机在某种状态下触发了警报。Zabbix 中有几个默认的严重程度：

灾难
高
中等
警告
信息
未分类

我们可以完全自定义严重性级别和颜色；例如，决定哪个触发器对应哪个严重性级别。所以，如果你现在对严重性有疑虑，别担心，我们稍后会讨论这个问题。

提示

自定义严重性级别和颜色对您的组织非常有用。我们可以自定义严重性级别，使其与我们公司内部使用的级别相匹配，甚至与我们的其他监控系统相匹配。

下一个小部件是时钟：

图 1.21 – 时钟小部件，指示时间

这是一个显示本地 Linux 系统时间的时钟，最终是数字时间格式。还需要多说什么吗？让我们继续看问题小部件：

图 1.22 – 可用的其中一个问题小部件

这是一个有趣的小部件，我经常使用。我们可以在这个界面上看到当前的问题，因此如果我们正确设置了触发器，就会在这里获得有价值的信息。了解有多少主机出现问题是一个方面，但问题页面还会给我们提供关于问题的更多细节：

时间：Zabbix 服务器第一次注意到这个问题的时间。
信息：关于事件的信息，其中包括手动关闭和已抑制状态。
主机：此问题发生在哪个主机上。
问题/严重性：问题是什么，严重性如何。严重性通过颜色显示；在这种情况下是橙色，表示中等。
持续时间：这个问题已经存在多长时间了。
更新：一个按钮，让我们能够对现有问题进行更改，例如确认问题或添加消息。
操作：问题发生后采取了哪些行动；例如，问题是否已确认，或在问题创建时执行的自定义脚本？如果你将鼠标悬停在任何操作上，它将显示已对该问题采取的所有操作的详细信息。
标签：此问题分配了哪些标签？

问题小部件非常有用。我们有不同类型的小部件可供选择，正如之前提到的，它是完全可定制的，具体取决于这个小部件如何向我们展示问题。快速看一下其中一些选项，我们将在后面的章节中详细介绍：

图 1.23 – 添加小部件界面

提示

我们可以从这些小部件中隐藏严重性级别，确保我们只看到重要的级别。有时，我们不想在仪表板上看到信息性严重性问题；这可能会分散我们对更重要问题的注意力。通过自定义小部件来保持仪表板的简洁。

默认仪表盘上还包括一个非常基础的 Graph 小部件。如你所见，它显示了每秒处理的值的数量。正如我们所说，System information 给出了这个值的估计。Graph 小部件则提供了更准确和详细的视图：

图 1.24 – 图形小部件

这些图形小部件同样完全可定制，我们将在本书后面详细讲解它们。

你将在此页面上找到一些较新的小部件，包括Top hosts、Item value和Geomap小部件。让我们从Top hosts小部件开始，仔细了解一下这些小部件：

图 1.25 – Top hosts 小部件

Top hosts小部件可以完全自定义，展示我们想要的任何项目列表。然后我们可以对该列表进行排序，显示值最高（Top N）或值最低（Bottom N）的项目，从而为我们提供一个关于——在本例中——具有最高 CPU 负载的主机的概览。

Item value小部件同样非常有用，它展示了一个单一的项目值：

图 1.26 – 项目值小部件

然后，最后是 Geomap 小部件：一个地理地图，展示我们希望添加的所有主机。如你所见，默认情况下，我们的 Zabbix 服务器已经被包含在内。在我们的例子中，我已确保将 Zabbix 服务器的位置更新为我们位于荷兰的总部：

图 1.27 – Geomap 小部件

它还向我们展示了 Zabbix 服务器当前没有问题，因为图标是绿色的。如果有问题，图标会显示为问题严重程度的颜色。

我们现在知道如何使用 Zabbix 前端，可以继续学习如何浏览我们的实例。

浏览 Zabbix 前端

导航 Zabbix 前端比看起来更简单，尤其是自 Zabbix 5.0 版本起，UI 进行了许多令人惊叹的变化，并持续到 Zabbix 7.0。在本节中，我们将通过查看导航栏及其提供的功能，进一步探索 Zabbix 的导航 UI。

准备就绪

现在，我们已经看过了登录后默认仪表盘上的第一页，是时候开始浏览 Zabbix UI，看看其他可用页面了。我们将通过侧边栏浏览并探索我们 Zabbix 安装中的页面，以便在开始监控我们的网络和应用时，知道在哪里找到所有内容。

所以，在继续之前，确保你已根据前面的小节完成 Zabbix 服务器的设置。

如何操作…

Zabbix 导航栏是我们所有强大工具和配置设置的门户。Zabbix 使用左侧导航栏来保持 UI 尽可能简洁。此外，他们还让侧边栏消失，以便我们能更清晰地查看所有内容，而不被侧边栏遮挡视线。

提示

我们无法改变 Zabbix 导航菜单的位置，但可以将其缩小或者完全隐藏。如果你希望隐藏导航栏（或不隐藏），可以点击 Zabbix 标志右侧的第一个图标。如果你想完全隐藏导航栏，可以点击 Zabbix 标志右侧的第二个图标。

让我们从默认页面开始，看看 Zabbix 侧边栏，并了解它。请按照前端操作，点击并查看提到的内容：

图 1.28 – 在你自己的网页浏览器中看到的默认 Zabbix 页面

这里有一些类别供我们选择，类别下面有不同的页面。首先，让我们详细介绍这些类别：

监控：监控类别是我们可以找到所有收集数据的地方。基本上，当你在使用 Zabbix 时，需要读取你辛苦收集的任何信息时，就会用到这个类别。
服务：服务类别是 Zabbix 7 的新功能，作为改进的业务服务监控（BSM）功能的一部分。我们可以在这里找到所有与服务和服务水平协议（SLA）监控相关的信息。
库存：库存类别是 Zabbix 中的一个额外酷炫功能，我们可以用它来查看与主机相关的库存信息。你可以将软件版本或序列号等信息添加到主机中，并在这里查看。
报告：报告类别包含了各种预定义和用户自定义的报告，专注于显示如系统信息、触发器和收集的数据等参数的概览。
数据收集：数据收集类别是我们构建与监控设备相关的一切内容的地方。稍后我们将在监控、库存和报告中使用这些数据。我们可以编辑设置以满足我们的各种需求，从而使 Zabbix 能够以有用的方式显示数据。
警报：UI 中的警报部分专注于显示正确的数据。
用户：用户部分专门显示与用户和用户组相关的数据。它包含了你管理账户和权限所需的一切内容。
管理：管理类别是我们管理 Zabbix 服务器的地方。你可以在这里找到所有的服务器设置，从而使你和你的同事们能够有一个良好的 Zabbix 使用体验。

在使用本书时，你将频繁接触到这些内容，所以一定要记住它们。让我们通过逐一查看它们，进一步深入了解各个类别。首先从监控类别开始：

图 1.29 – 侧边栏的监控部分

监控标签包含以下页面：

问题：我们可以在这里详细查看当前的问题。提供了多个筛选选项，以便在需要时缩小问题搜索的范围。
主机：这个页面将提供主机状态的快速概览，并提供链接导航到显示主机数据的页面。
最新数据：这是我们在整个 Zabbix 使用过程中将会频繁使用的一个页面。最新数据页面显示了每个主机收集到的值，我们当然可以对这些值进行筛选。
地图：地图是 Zabbix 中一个非常有用的工具，可以帮助我们概览基础设施。我们可以将它们用于网络概览等。
发现：这个页面为我们提供了已发现设备的概览。稍后我们会更深入地处理这个内容。

接下来，我们来看一下服务类别：

图 1.30 – 侧边栏的服务部分

该部分侧边栏包含以下页面：

服务：这里是我们配置所有希望监控的服务的地方
SLA：我们可以在这里配置任何 SLA，然后将其应用到我们的服务中。
SLA 报告：一个关于已配置服务及其 SLA（服务级别协议）是否满足的详细概览

然后，我们来看一下库存类别：

图 1.31 – 侧边栏的库存部分

库存标签包含以下页面：

概览：一个快速概览页面，显示您的库存信息
主机：提供更详细的每个主机的库存值视图

接下来，我们来看一下报告类别：

图 1.32 – 侧边栏的报告部分

报告标签包含以下页面：

系统信息：您可以在这里查看系统信息；它包含了我们之前讨论过的系统信息小部件的相同信息。
定时报告：这是我们配置任何自动 PDF 报告并可能发送的地方。
可用性报告：在这个页面上，我们可以看到触发器在问题状态和正常状态下的时间百分比。这是查看某些项目实际健康状态的一个有用方法。
前 100 个触发器：在一段时间内状态变化最频繁的前 100 个触发器。
审计日志：在这里我们可以查看谁修改了 Zabbix 服务器上的内容。这是一个很好的方式来查看是哪个同事不小心将你锁定了，或者是否是故意的。
操作日志：在这里我们可以查看已采取的操作列表；例如，由于触发器进入问题状态或正常状态。
通知：在此页面上，我们可以查看已发送给用户的通知数量。

接下来，我们有数据收集类别，这是一个新的条目：

图 1.33 – 侧边栏的数据收集部分

数据收集标签页几乎与旧版本中的配置标签页相同。它包含以下页面：

模板组：在这里配置我们的模板组；例如，为我们公司内部将使用的所有模板配置一个组（Templates/Open source ICT Solutions），或者为所有网络设备配置一个组（Templates/Networking）。
主机组：我们在这里配置主机组；例如，为所有 Linux 服务器配置一个组。
模板：在这里我们配置可以用来从 Zabbix 服务器监控主机的模板。
主机：另一个主机标签页，但这一次它不是用来检查数据的。这里是我们添加和配置主机设置的地方。
维护：在 Zabbix 中，我们可以设置维护期；这样，触发器或通知在你进行维护时（例如，将某些设备下线）就不会打扰到你。
事件关联：我们可以在这里将问题关联，以减少噪音或防止事件风暴。通过在问题与其他问题关联时关闭新的或旧的问题来实现。
发现：在这里配置 Zabbix 发现功能，用于自动创建主机。

Zabbix 中新加入的警报类别：

图 1.34 – 侧边栏的警报部分

它由以下三个页面组成：

操作：在前端的这一部分，我们可以配置各种操作。我们可以设置用于发送警报、创建主机等的操作。
媒体类型：Zabbix 中预先配置了几种媒体类型，您可以在这里找到它们。我们还可以添加自定义的媒体类型。
脚本：在这里我们可以添加自定义脚本，以扩展 Zabbix 前端的功能。

倒数第二个，也是新的，我们有用户：

图 1.35 – 侧边栏的用户部分

我们可以在这里找到五个不同的页面：

用户组：在这里我们配置用户组及其权限。
用户角色：在这里可以配置不同用户的角色，以限制或扩展某些前端功能到特定用户。
用户：将用户添加到此页面。
API 令牌：这个页面以前有些隐藏，但现在更容易找到。我们可以在这里管理所有有权限编辑的 API 令牌：对超级管理员来说，这非常有用，可以创建和管理不同用户的令牌。
身份验证：我们可以在这里找到我们的身份验证设置，例如轻量级目录访问协议（LDAP）、安全断言标记语言（SAML）和 HTTP。它还包含新的即时（JIT）用户配置设置。

最后，我们有了管理类别：

图 1.36 – 侧边栏中的管理部分

管理选项卡包含以下页面：

常规：常规页面包含我们的 Zabbix 服务器配置。从家务管理到前端主题的设置都可以在这里找到。
审计日志：审计日志设置位于这里。我们可以启用或禁用审计日志，并且可以更改日志存储的时长。
家务管理：一般的家务管理设置可以在这里找到。我们可以编辑希望启用或禁用的家务管理内容，并且可以更改我们存储历史记录、趋势、触发器等内容的时长。
代理组：在这个新条目中，我们将定义可以与代理一起用于故障转移和负载均衡的代理组。
代理：在这里，我们配置应连接到该 Zabbix 服务器的代理。
宏：现在全局宏更加容易访问，因为它们已经被重新定位到这里。在这里定义新的并管理现有的全局宏。
队列：在这里查看 Zabbix 服务器队列。由于数据收集或性能问题，项目可能会被卡在队列中。

提示

使用 Zabbix 身份验证（如 HTTP、LDAP 或 SAML）时，我们仍然需要在内部创建用户，并赋予正确的权限。配置用户时，需要使其用户名与身份验证方法中的用户名匹配，并使用身份验证方法进行密码管理。然而，在 Zabbix 7.0 中，可以使用即时用户配置（JIT）自动创建具有正确权限的用户，这在本书中也会提到。

第二章：2

使用 Zabbix 用户管理准备工作

在本章中，我们将创建我们的第一个用户组、用户和用户角色。正确设置这些内容非常重要，因为它们将为用户提供正确权限，确保他们能访问你的 Zabbix 环境。通过一步一步地讲解这些内容，我们将确保在继续本书的其他部分之前，我们已经建立了一个结构化的 Zabbix 设置。

作为额外的内容，我们还将设置一些高级用户认证，使用 SAML 和 LDAP，让 Zabbix 用户的使用更加便捷，并为他们提供一个使用公司中可能已经在使用的登录凭据的方式。我们将按照以下步骤依次进行讲解：

创建用户组
使用 Zabbix 用户角色
创建你的第一个用户
Azure AD SAML 用户认证与即时用户创建（JIT）
OpenLDAP 用户认证与即时用户创建（JIT）

技术要求

我们可以在任何安装了 Zabbix 的环境中完成本章的所有工作。如果你还没有安装 Zabbix，请查看上一章学习如何安装它。我们将通过我们的 Zabbix 设置准备好所有内容，以便我们的用户开始登录并使用 Zabbix 前端。

创建用户组

要登录到 Zabbix 前端，我们需要用户。目前，我们使用的是默认用户，这很合理，因为我们需要一个用户来创建其他用户。不过，这样的设置不太安全，因为我们不希望继续使用 zabbix 作为密码。所以，我们将学习如何创建新用户并将他们分组。

在设置用户帐户之前，选择如何在 Zabbix 中管理用户非常重要。如果你想使用 LDAP 或 SAML 等方式，最好立即做出使用这些认证方法的决定，这样就不会遇到迁移问题。

准备工作

现在我们已经了解了 Zabbix UI 的结构和导航方式，可以开始进行实际的配置了。我们将从创建一些用户组开始，熟悉这个过程并开始使用它们。这样，我们的 Zabbix 设置不仅会更加结构化，还会更加安全。

为了开始，我们需要一个像之前食谱中使用的 Zabbix 服务器，并利用我们在那里获得的知识导航到正确的前端部分。

看一下下面的图，我们可以看到我们的示例公司云主机提供商是如何设置的。我们将创建图中看到的用户，以建立一个结构化且稳固的用户设置：

图 2.1 – 云主机提供商部门图

所以，云主机提供商有一些部门需要访问 Zabbix 前端，而另一些部门则不需要。假设我们希望给以下部门提供 Zabbix 前端的访问权限：

网络：配置和监控他们的网络设备
基础设施：配置和监控他们的 Linux 服务器
采购与库存：查看库存信息并与其他内部工具进行对比

如何操作…

让我们开始在 Zabbix UI 中创建这三个用户组：

为此，请导航到用户 | 用户组，将显示以下页面：

图 2.2 – Zabbix 用户组窗口

现在，让我们从点击右上角的创建用户组开始，创建Networking用户组。这将带您进入以下屏幕：

图 2.3 – Zabbix 用户组配置窗口

我们需要填写信息，从Networking开始。这个组还没有用户，因此我们可以跳过这一项。前端访问选项让我们能够提供身份验证；如果您选择LDAP，则会使用 LDAP 进行身份验证。我们将保持为系统默认，即使用 Zabbix 内部身份验证系统。

多因素身份验证

Zabbix 7.0 新增了多因素身份验证功能。如果我们希望用户强制使用此功能，可以在这里的用户组中进行设置。不过，在执行此操作之前，请确保在用户 | 身份验证中配置好多因素身份验证。

现在，让我们进入此页面的下一个标签页，即模板权限：

图 2.4 – Zabbix 用户组模板权限配置窗口

在这里，我们可以指定我们的用户组可以访问哪些主机组。已经有一个默认的网络设备主机组，我们将在本例中使用它。

点击选择，将弹出一个窗口，显示可用的主机组。在这里选择模板/网络设备，然后它会将您带回到之前的窗口，主机组已经填写好了。
选择读写权限。
我们不需要添加其他内容，因此点击右下角的大蓝色添加按钮以完成主机组的创建。

提示

当使用 Zabbix 身份验证（如 HTTP、LDAP 或 SAML）时，如果我们不使用 JIT 用户自动化配置，仍然需要在 Zabbix 中创建具有正确权限的用户。为此，请将用户配置为与身份验证方法中的用户名匹配，并使用该身份验证方法进行密码管理。使用 JIT 用户自动化配置时，我们无需担心此问题。

现在，我们将拥有一个新的用户组，名为Networking，该组只允许对模板/网络设备模板组进行读写：

图 2.5 – Zabbix 用户组窗口

让我们重复这个过程，创建一个新的基础设施用户组，不过这次我们将添加Linux 服务器主机组，而不是添加模板/网络设备模板组，像这样：

图 2.6 – Zabbix 用户组权限配置窗口，显示一个主机组

点击添加保存此主机组。
再次重复上述步骤，添加 采购与库存 用户组，我们将采取不同的方法。我们会重复刚才的过程，除了权限设置部分。我们希望 采购与库存 用户组能够读取我们的库存数据，但不希望他们修改主机配置。将 模板/网络设备 模板组和 Linux 服务器 主机组添加到该用户组，但仅授予读取权限，如下所示：

图 2.7 – Zabbix 用户组权限配置窗口，显示两个组

恭喜！完成这一部分意味着你已经创建了三个不同的用户组，我们可以继续创建我们的第一个新用户！让我们开始吧。

还有更多...

Zabbix 用户组非常广泛，远比表面看起来的要复杂。由于整个权限系统基于你所属的用户组和用户角色，因此在操作之前，最好先阅读 Zabbix 文档：www.zabbix.com/documentation/current/en/manual/config/users_and_usergroups/usergroup。

使用 Zabbix 用户角色

从 Zabbix 6.0 开始，我们可以在 Zabbix 系统中创建用户角色。通过在 Zabbix 中创建自己的用户角色，我们可以提供额外的权限设置。在旧版本的 Zabbix 中，我们只能为用户分配三种类型之一：

用户
管理员
超级管理员

在早期版本中，这些用户类型的作用是限制 Zabbix 用户在前端界面中可以看到的内容，但这些限制始终是预定义的。

尽管这些用户组在 Zabbix 中依然存在，但随着我们可以创建自己定义的用户角色的加入，我们可以设置自己的前端相关限制，从而使得只向特定的 Zabbix 用户展示 UI 中的某些部分。这是通过限制用户组默认拥有的某些权限，并且遵循与用户组相关的权限来实现的。

准备中

在这个教程中，我们需要一台 Zabbix 服务器，最好是上一个教程中设置的那台。在前一个教程中，我们设置了不同的用户组，以便对主机组提供不同的权限。完全独立于用户组，我们将为用户分配特定的用户角色，来决定他们在 UI 中可以看到的内容。让我们来看看如何设置用户角色。

如何做...

首先，导航到 Zabbix 前端并进入用户 | 用户角色。这将显示我们从旧版本 Zabbix 中熟知的默认用户角色：

图 2.8 – 默认的 Zabbix 用户角色配置窗口

在这里，我们可以点击右上角的蓝色创建用户角色按钮。
我们将设置一个新的用户角色，称为User+角色。这个角色将适用于只有读取权限的 Zabbix 用户，但他们需要比仅有监控、库存和报告导航元素更多的访问权限。

图 2.9 – 新的 Zabbix 用户角色配置窗口的顶部部分

首先，确保在名称字段中输入User+角色。
首先，让我们专注于显示访问 UI 元素部分。当选择用户作为用户类型时，我们无法为该用户角色添加访问权限。因此，我们需要通过选择下拉菜单中的管理员来更改用户类型。
我特别希望这个名为User+角色的用户角色能够访问维护页面。设置起来会像这样：

图 2.10 – 一个新的 Zabbix User+ 角色，具有访问维护的权限

确保还要更改表单中的访问操作部分，方法是取消选中管理计划报告，如下所示：

图 2.11 – 一个新的 Zabbix User+ 角色，具有正确的访问操作设置

最后但同样重要的是，点击表单底部的蓝色添加按钮，以添加这个新的用户角色。

它是如何工作的……

首先，让我们来解析在 Zabbix 中创建用户角色时所拥有的选项：

名称：我们可以在这里为我们的用户角色设置自定义名称。
用户类型：尽管用户类型现在通过用户角色分配，Zabbix 6 仍然存在用户类型。在某些用户类型能够看到的内容上仍然有限制，例如，用户类型永远只会有只读权限，而超级管理员类型在权限方面仍然没有限制。
访问 UI 元素：在这里，我们可以限制分配给该用户角色的用户在 Zabbix UI 上能够看到的内容。
访问服务：这里可以限制服务或 SLA 监控，因为我们可能不希望所有用户都能访问它。
访问模块：自定义的 Zabbix 前端模块已完全集成到用户角色系统中，这意味着我们可以选择 Zabbix 用户可以看到哪些前端模块。
访问 API：Zabbix API 可以限制为某些用户角色。例如，你可能只希望有特定的 API 用户角色，限制其他用户访问 Zabbix API。
访问操作：在 Zabbix 用户角色中，可以限制某些操作，包括编辑仪表盘、维护 API 令牌等权限。

现在，让我们看看我们在名为用户角色的用户角色和名为User+ 角色的用户角色之间做了哪些更改。默认的名为用户角色的用户角色具有以下对 UI 元素的访问权限：

图 2.12 – 默认的 Zabbix 用户角色，称为“用户角色”访问 UI 元素

默认情况下，在 Zabbix 6 中，我们有三个用户角色，它们反映了可用的用户类型。我们在此看到的用户角色是用户。它使我们能够访问上面看到的 UI 元素，将名为用户角色的用户角色限制为仅能查看某些内容，并且无法进行配置更改。

例如，能够设置维护被认为是一项有影响力的权限。因为当然，你可以通过设置维护来限制重要通知。但问题来了，如果你明确希望 Zabbix 用户仅能读取信息，但仍无法访问配置页面呢？在 Zabbix 5.0 中，这是不可行的，因为你只能选择用户、管理员或超级管理员类型，使用管理员和超级管理员用户类型时会立即获得整个配置部分的访问权限。

现在，让我们看看通过创建一个名为User+ 角色的新用户角色所做的工作：

图 2.13 – 新的 Zabbix 用户角色，称为“User+ 角色”访问 UI 元素

在这里，我们可以看到如果将用户类型更改为管理员，但不选择所有可用的访问 UI 元素会发生什么。我们现在有一个没有访问重要配置页面，但可以访问维护的用户角色。

将其与访问操作的设置结合，在那里我们添加了如图 2.11所示的创建和编辑维护设置，我们将拥有对维护设置的完全访问权限。

当我们在下一个配方中将此角色分配给某个用户，并以该用户身份登录时，我们将能够在 Zabbix 侧边栏中看到以下内容：

图 2.14 – 自定义用户角色 Zabbix 侧边栏

当然，这只是我们可以使用的众多配置类型之一。我们还可以通过一系列自定义用户角色下的多个参数，允许 Zabbix 用户访问菜单和选项。我们可以根据需要自由设置，从而为 Zabbix 用户提供更多灵活性。

还有更多...

Zabbix 目前正在进一步完善用户角色，这意味着某些部分可能仍然缺失或存在问题。由于这是一个新功能，因此它正在不断改进和扩展。有关此功能的更多信息，请查看 Zabbix 文档：www.zabbix.com/documentation/6.4/en/manual/web_interface/frontend_sections/users/user_roles

创建您的第一个用户

通过我们新创建的用户组和用户角色，我们迈出了朝着更加结构化和安全的 Zabbix 设置迈出的第一步。下一步是将一些用户分配到新创建的用户组中，确保他们从组中获得新的用户权限，并将他们纳入用户角色，以提供对 UI 元素的正确访问。

准备工作

要开始配置，我们需要服务器和上一部分中新创建的用户组。所以，让我们从配置开始。

我们知道云主机公司有三个部门将使用我们的 Zabbix 安装。我们为他们创建了用户组，但这些部门也有一些实际想要使用我们安装的用户。让我们认识一下他们：

图 2.15 – 云主机用户图

这些是我们需要为云主机使用配置的用户。

如何操作……

让我们开始创建用户。我们将从Networking部门开始：

导航到用户 | 用户，这将带我们到以下页面：

图 2.16 – Zabbix 用户窗口

这是所有用户创建操作发生的地方，因为我们将从这个页面管理所有用户。要创建我们第一个Networking部门的用户，用户名为s_network，点击右上角的创建用户按钮，将我们带到以下界面：

图 2.17 – Zabbix 用户配置窗口

填写用户名字段，提供该用户的用户名，即s_network。
同时，重要的是将此用户添加到我们刚刚创建的组中，以便为用户提供正确的权限。点击选择并选择我们名为Networking的组。
最后但同样重要的是，在密码字段中设置一个安全密码；别忘了它，因为我们稍后会用到它。
接下来，进入权限标签页，因为我们暂时不配置媒体：

图 2.18 – Zabbix 用户权限配置窗口

选择名为超级管理员角色的角色选项。这将允许我们的用户访问所有 UI 元素，并查看和编辑 Zabbix 服务器中所有主机组的信息。

Zabbix 默认提供以下用户角色：

默认角色	描述
用户角色	Zabbix 用户角色可以访问我们 Zabbix 环境中的可视化方面。具体来说，监控、服务、清单和报告菜单可用。用户将始终只能对模板和主机具有只读访问权限，且必须显式分配。
Admin 角色	Zabbix Admin 角色可以进一步管理我们 Zabbix 监控的配置。具体来说，Zabbix 用户可以访问的所有菜单都可以使用，另外还增加了数据收集和警报。用户可以被分配对模板和主机的读写权限，并且必须显式分配。
Super admin 角色	Zabbix Super admin 角色可以访问我们 Zabbix 环境的管理方面。具体来说，Zabbix Admin 可以访问的所有菜单都可以使用，另外还增加了用户和管理功能。用户将始终拥有对所有模板和主机的读写权限。

对于名为y_network的用户，让我们重复之前的步骤，但在权限标签中选择Admin 角色选项，如下所示：

图 2.19 – Zabbix 用户权限配置窗口

创建这两个用户后，我们继续创建基础设施用户r_infra。重复我们为s_network所做的步骤，当然要更改用户名。然后，将该用户添加到组中，并为用户赋予适当的权限。点击选择并选择名为Infrastructure的组。它将如下所示：

图 2.20 – r_infra 的 Zabbix 用户配置窗口

最后，在权限页面将该用户设为另一个Super admin。

现在，对于我们的最后一个用户，让我们重复步骤，按以下方式更改用户名和用户标签中的组：

图 2.21 – e_buy 的 Zabbix 用户配置窗口

如果你没有按照之前的步骤操作，可以按照我们创建的User+角色更改此用户的User role，如下所示：

图 2.22 – e_buy 的 Zabbix 用户配置窗口

将用户设置为User+角色还将允许e_buy用户创建维护期。

完成后，您将得到如下内容：

s_network：具有Networking用户组权限，并且具有Super admin角色的用户
y_network：具有Networking用户组权限，并且具有Admin角色的用户
r_infra：具有Infrastructure用户组权限，并且具有Super admin角色的用户
e_buy：一个具有 购买和库存 用户组权限的用户，权限包括用户角色或 用户+ 角色

Azure AD SAML 用户认证与 JIT 用户配置

在本篇教程中，我们将使用 安全断言标记语言（SAML）认证，这是一种在 IT 领域广泛使用的认证方式。SAML 标准允许我们在应用程序之间交换授权数据，从而实现我们在 Zabbix 应用程序和认证提供者之间的认证。我们将使用这种方式来管理 Zabbix 用户的密码。请注意，如果您仅使用 SAML 或 LDAP 设置用户密码认证，您仍然需要手动在 Zabbix 内创建用户及其权限。为了解决这个问题，自 Zabbix 6.4 以来，我们还可以设置 即时用户配置（JIT）功能。

准备就绪

要开始使用 SAML 认证，我们需要之前教程中配置好的 Zabbix 服务器。确保我们有之前教程中配置的所有用户。我们还需要某种用于 SAML 认证的工具。我们将使用 Microsoft Azure 活动目录（AD）的 SAML。

在继续本教程之前，请确保在 Azure AD 中设置好用户。您可以使用现有的 AD 用户进行认证，因此可以使用此教程与现有的 AD 配置一起操作。

我们将使用 s_network 用户作为示例，并且在 Zabbix 环境中创建一个新的 JIT_Admin 用户组，该用户组没有设置权限。Azure 用户如下所示：

图 2.23 – Azure 用户和组窗口

对于 JIT 用户配置，我们还确保将此用户添加到新的 zbx_admin 用户组中：

图 2.24 – Azure 用户组详细信息窗口

这个组将只是一个空的安全组，我们将稍后用于在 Zabbix 中分配权限：

图 2.25 – Azure 组详细信息窗口

要设置 SAML，请从您的 AD 或其他 SAML 提供商处获取 SAML 设置。要与 Zabbix 配合使用，我们需要以下内容：

IdP 实体 ID
SSO 服务 URL
SLO 服务 URL
用户名属性
SP 实体 ID
SP 名称 ID 格式

对于 JIT 用户配置，我们需要以下内容：

用户组名称属性
用户名属性
用户姓氏属性
用户组映射

如何操作…

我们假设您的 Azure AD 已经准备好。让我们看看如何使用我们的配置来设置 SAML：

让我们导航到以下 URL：portal.azure.com/。
登录后，导航至 Azure AD 并点击 企业应用程序。
现在点击 + 新建应用程序 来创建我们的新应用程序。在下一个窗口中，点击 创建您自己的应用程序：

图 2.26 – Azure 企业应用程序创建页面

在下一个窗口中，命名我们的新应用程序为 Zabbix 并点击蓝色的创建按钮：

图 2.27 – Azure 企业新应用程序页面

从列表中选择我们的新应用程序，并点击 用户和组 以添加正确的用户。在我们的案例中，这将是 s_network：

图 2.28 – Azure 企业应用程序用户添加

如果我们正在设置 JIT 用户配置，确保也添加 zbx_admin 组：

图 2.29 – Azure 企业应用程序组添加

使用 JIT 用户配置时，添加该组应该就足够了。

你还需要分配一个角色。点击 选择角色 并添加你想要使用的角色。使用 JIT 时可以使用 zbx_admin 组，否则只需将用户添加为用户。

图 2.30 – Azure 企业应用程序角色分配

点击选择然后点击分配。
现在通过点击侧边栏的 单点登录 来进入 SAML 设置。
现在，点击下面截图中页面上的 SAML 并继续：

图 2.31 – Azure 企业应用程序 SAML 选项

现在在 1 处，我们可以添加以下信息，其中黑色标记的是我们的 Zabbix 服务器 URL：

图 2.32 – Azure SAML 设置 1

在 2 处，填写以下内容：

图 2.33 – Azure SAML 设置 2

3 将自动填充。点击下载以获取 证书 (Base64)：

图 2.34 – Azure SAML 设置 3

登录到 Zabbix 服务器 CLI，并使用以下命令创建一个新文件：
```
vim /usr/share/zabbix/conf/certs/idp.cert
```
将 第 11 步 中下载的文件内容粘贴到此处并保存文件。
现在回到 4 处，我们将获得以下信息：

图 2.35 – Azure SAML 设置 4

在 Zabbix 前端，进入用户 | 身份验证 | SAML 设置 页面，并填写以下信息：

图 2.36 – Zabbix SAML 设置

如果你还想使用 JIT 用户配置，请像前一张截图中一样启用它，并填写以下信息：

图 2.37 – Zabbix SAML JIT 设置

重要提示

我使用了JIT_Admin用户组，正如在本食谱的准备工作部分中建议的那样。请使用任何你认为合适的用户组和角色，并确保将 JIT 用户配置集成到你自己的用户组和权限中。

如果你已经创建了s_network用户，并且不打算使用 JIT 用户配置，去用户 | 用户页面，将s_network用户更改为包含使用的 Azure 域，例如：

图 2.38 – Zabbix 编辑用户屏幕（SAML 设置）

如果你使用 JIT 用户配置功能，你只需使用新的用户凭证通过 SAML 认证登录，它应该会使用正确的凭证创建该用户。

按照这些步骤操作后，现在应该可以使用在 Zabbix 中配置的用户登录，并使用在 Azure AD 中为此设置的密码：

图 2.39 – Zabbix 登录窗口

它是如何工作的…

Zabbix SAML 用户认证默认用于集中管理密码。过去，我们无法通过这种设置将用户组和权限分配给用户。如果我们在没有启用 JIT 用户配置的情况下设置它，我们只能用它来进行简单的密码管理。

通过这种方式，我们可以确保用户更容易将密码集中管理：

图 2.40 – Zabbix SAML 认证示意图

当我们点击登录按钮时，Zabbix 会与我们的 Azure AD SAML 组件进行通信。然后，用户会根据你的 Azure AD 用户进行身份验证，确认信息会发送回 Zabbix 服务器。恭喜，你现在已经成功登录到 Zabbix 服务器。

然而，从 Zabbix 6.4 版本开始，也可以启用 JIT 用户配置。这一新特性使我们能够根据 SAML 服务器上的用户组来分配 Zabbix 用户组和角色。因此，包含 JIT 用户配置的整个过程大致如下：

图 2.41 – Zabbix SAML JIT 认证示意图

还有更多…

我们不仅可以使用 SAML 进行这种身份验证，还可以使用 HTTP 和 LDAP。这样，你可以为你的组织选择合适的高级认证方式。

查看 Zabbix 文档以了解有关不同认证方式的更多信息：www.zabbix.com/documentation/current/en/manual/web_interface/frontend_sections/users/authentication

也可以使用 Okta 或 OneLogin 等身份提供者，这意味着您的选择不限于 Azure AD：只要它支持 SAML，就可以用它来进行 Zabbix 服务器的身份验证。

OpenLDAP 用户身份验证和 JIT 用户配置

尽管很多人将 SAML 与 Azure Active Directory 一起使用，但并非所有情况都是如此。运行用户身份验证的方法有很多种。

其中一种方法是使用 LDAP 替代 SAML，例如使用 OpenLDAP 服务器。OpenLDAP 为我们提供了一个坚实的开源实现，用于设置具有 LDAP 的用户数据库。这样做的好处是，JIT 用户配置不仅适用于 SAML，也适用于 LDAP，这意味着我们也可以在这里应用 JIT 用户配置。

准备工作

为了开始，我们需要一个已设置并准备好的 OpenLDAP 服务器。建议使用自己的 OpenLDAP 环境。网上有大量指南可以帮助您进行坚实的 OpenLDAP 实现，并且官方站点提供了最新版本的快速入门指南：www.openldap.org/

另一种方法是使用 Docker 启动一个测试 OpenLDAP 环境。我们可以使用以下命令：

docker run -p 389:389 -p 636:636 --name openldap-server --detach oicts/openldap:1.0.0
docker run -p 8081:80 -p 4443:443 --name phpldapadmin --hostname phpldapadmin --link openldap-server:ldap-host --env PHPLDAPADMIN_LDAP_HOSTS=ldap-host --detach osixia/phpldapadmin:0.9.0

请仅将此用于测试，因为前面的代码可能不再使用最新版本。

如何操作…

一旦 OpenLDAP 设置完成，我们就可以开始在新的 OpenLDAP 环境中创建一些用户和组。首先开始这一步：

我们将通过在浏览器中导航到 URL 来打开 OpenLDAP GUI：
```
https://<ip_address_of_server>:4443
```
登录后，我们开始创建一些新用户。首先，点击窗口左侧的登录。默认的用户名和密码如下：
```
Login DN: cn=admin,dc=example,dc=org
Password: admin
```
如果您使用的是我们的 Docker 镜像，您应该会看到我们已经为您创建了一些组和用户，正如以下截图所示：

图 2.42 – OpenLDAP 服务器组和用户

如果您使用的是自己的 OpenLDAP 环境，请确保至少有一个组和一个用户用于测试。

我们将使用这些用户名和组来设置 LDAP 身份验证与 JIT 用户配置。
前往 Zabbix 前端并导航至用户 | 用户。首先，我们将确保自己随时可以访问，即使默认的身份验证方法切换为 LDAP。通过将 Admin 用户添加到 Internal 组中，将其默认身份验证方法切换为内部。

图 2.43 – Zabbix 管理员用户设置

点击更新，然后它应该会像以下截图一样显示。

图 2.44 – Zabbix 管理员用户具有内部前端访问权限

然后，我们将进入用户 | 认证，然后是 LDAP 设置。将默认认证方法设置为 LDAP，并按如下方式设置未配置用户组。

图 2.45 – Zabbix 默认认证方法

接下来，我们点击 LDAP 设置 标签。这是我们配置 LDAP 服务器和 JIT 用户配置的地方。让我们先启用我们想要使用的配置项。

图 2.46 – Zabbix 默认认证方法

仅使用 LDAP 时，我们必须手动创建用户。启用 JIT 后，用户将自动创建并获得正确的权限。

现在，Zabbix 也支持添加多个 LDAP 服务器。我们可以通过点击添加在 服务器 部分添加我们的 OpenLDAP 服务器。
然后，填写以下内容。

图 2.47 – Zabbix LDAP 认证设置

默认的 密码。

如果需要，我们还可以启用 JIT 配置。启用它并填写以下内容。

图 2.48 – Zabbix LDAP 认证设置与 JIT

现在，通过点击侧边栏左下角的注销按钮，退出当前登录的帐户。
现在我们应该能够使用 user1 LDAP 用户登录。密码是 password。

图 2.49 – 用户 1 的 Zabbix 登录窗口

当我们第一次登录时，用户将根据 JIT 用户配置步骤中定义的权限自动创建。如果以 Zabbix 超级管理员身份登录，我们可以在用户 | 用户下看到此信息。

图 2.50 – Zabbix LDAP 配置的用户

它是如何工作的……

如你所见，我们可以将 Zabbix 与 LDAP 服务器结合使用，从而整体简化密码管理。我们有两个选择：使用 LDAP 配合 JIT 用户配置，或者不使用 JIT 用户配置。

当我们将 Zabbix 与 LDAP 服务器结合使用，但选择不使用 JIT 用户配置时，Zabbix 将仅在点击登录按钮时与 LDAP 服务器进行通信进行密码认证。

图 2.51 – Zabbix LDAP 认证示意图

然而，从 Zabbix 6.4 开始，我们也可以启用 JIT 用户配置。这个新功能允许我们根据 LDAP 服务器上的用户组，给 Zabbix 用户分配用户组和角色。因此，整个包含 JIT 用户配置的过程大致如下：

图 2.52 – Zabbix LDAP JIT 认证示意图

第三章：3

设置 Zabbix 监控

Zabbix 被设计为灵活的，应该能够监控你所需的几乎所有内容。在本章节中，我们将学习更多关于如何使用 Zabbix 构建各种监控选项。我们将逐个食谱地讲解它们，确保你能全面理解它们的工作原理。

我们将介绍以下不同监控类型的食谱：

设置 Zabbix 代理监控
使用旧方式进行 SNMP 监控
设置新的 SNMP 监控方式
创建 Zabbix 简单检查和 Zabbix trapper
使用计算项和依赖项
创建外部检查
设置 JMX 监控
设置数据库监控
设置 HTTP 代理监控
使用 Zabbix 浏览器项模拟 Web 用户
使用 Zabbix 预处理改变项值

技术要求

我们需要一台能够执行监控的 Zabbix 服务器，具有以下要求：

一台安装了 Zabbix 服务器的 Linux 发行版主机，例如 Rocky Linux 或 Ubuntu。然而，Debian、Alma Linux 等发行版也同样适用。
一个 MariaDB（MySQL）服务器用于监控——例如，在第一章中我们设置的 Zabbix 服务器数据库。

我将使用我们在上一章节中使用的相同服务器，但任何 Zabbix 服务器都适用。

设置 Zabbix 代理监控

从 Zabbix 5 版本开始，Zabbix 正式支持新的 Zabbix Agent 2。Zabbix Agent 2 带来了一些重大改进，甚至采用了另一种编程语言——Golang，而非 C。在本食谱中，我们将探讨如何使用 Zabbix Agent 2，并探索它带来的一些新功能。

准备工作

要开始使用 Zabbix Agent 2，我们需要做的就是在要监控的主机上安装它。确保你有一台空白的 Red Hat Enterprise Linux（RHEL）或 Ubuntu Linux 主机，准备好进行监控。

如何操作…

让我们学习如何安装 Zabbix Agent 2，然后继续使用它。

安装 Zabbix Agent 2

让我们从在要监控的 Linux 主机上安装 Zabbix Agent 2 开始。我将展示如何在 RHEL 和 Ubuntu 系统上进行安装：

输入以下命令添加仓库。

对于 RHEL 系统，命令如下：

rpm -Uvh https://repo.zabbix.com/zabbix/7.0/rocky/9/x86_64/zabbix-release-7.0-2.el9.noarch.rpm

对于 Ubuntu 系统，命令如下：

wget https://repo.zabbix.com/zabbix/7.0/ubuntu/pool/main/z/zabbix-release/zabbix-release_7.0-1+ubuntu22.04_all.deb
dpkg -i zabbix-release_7.0-1+ubuntu22.04_all.deb

然后，输入以下命令安装 Zabbix Agent 2。

这是 RHEL 系统的命令：
```
dnf -y install zabbix-agent2
```
这是 Ubuntu 系统的命令：
```
apt install zabbix-agent2
```

恭喜——Zabbix Agent 2 现在已经安装并准备就绪！

重要提示

当向系统添加新仓库时，请务必查看 Zabbix 下载页面。你可以在这里找到适合你系统的最新仓库：www.zabbix.com/download。

使用被动模式的 Zabbix 代理

让我们从构建一个带有被动检查的 Zabbix 代理开始：

安装 Zabbix Agent 2 后，让我们打开 Zabbix 代理配置文件进行编辑：
```
vim /etc/zabbix/zabbix_agent2.conf
```
在这个文件中，我们可以编辑所有需要的 Zabbix 代理配置项，从服务器端进行配置。

我们从编辑以下参数开始：

Server=127.0.0.1
Hostname=Zabbix server

将 Server 的值更改为将监控此被动代理的 Zabbix 服务器的 IP 地址。将 Hostname 的值更改为被监控服务器的主机名。我们可以通过以下命令获取服务器的 IP 地址：
```
ip addr
```

现在，重新启动 Zabbix Agent 2 进程：

systemctl enable zabbix-agent2
systemctl restart zabbix-agent2

接下来，前往 Zabbix 服务器的前端，并添加此主机进行监控。
在 Zabbix 前端界面中，进入 数据收集 | 主机，然后点击右上角的 创建主机。
要在 Zabbix 服务器中创建此主机，我们需要填写以下截图中显示的值：

图 3.1 – lar-book-agent 的 Zabbix 主机创建页面

需要添加以下内容：

主机名：用于识别主机（必须唯一）。
主机组：用于逻辑分组主机。
接口：用于在特定接口上监控此主机。没有接口意味着没有通信。如果我们不需要接口，在 Zabbix 7 中可以创建没有接口的主机。对于 Zabbix 代理监控的主机，需要一个代理接口。

确保你在代理接口配置中添加了正确的 IP 地址。
同样重要的是为此主机添加一个模板。在 Zabbix 7 中，这可以在同一个标签页上完成。由于这是一个由 Zabbix 代理监控的 Linux 服务器，因此让我们添加正确的开箱即用模板，如以下截图所示：

图 3.2 – lar-book-agent 的 Zabbix 主机模板页面

点击蓝色的添加按钮完成创建此代理主机。现在你已经创建了这个主机，确保 ZBX 图标变为绿色，表示该主机已经启动并被被动 Zabbix 代理监控：

图 3.3 – lar-book-agent 的 Zabbix 配置主机页面

由于我们已配置主机并添加了带有项目的模板，因此我们现在可以通过进入监控 | 主机并点击 最新数据 按钮来查看此主机的项目接收到的值。请注意，值可能需要大约 1 分钟才能显示：

图 3.4 – lar-book-agent 的 Zabbix 最新数据页面

使用 Zabbix 代理的主动模式

现在，让我们了解如何配置带有主动检查的 Zabbix 代理。我们需要在被监控的 Linux 服务器主机端更改一些值：

从执行以下命令开始：
```
vim /etc/zabbix/zabbix_agent2.conf
```
现在，让我们编辑以下值，将此主机更改为主动代理：
```
ServerActive=127.0.0.1
```
将 ServerActive 的值更改为将监控此被动代理的 Zabbix 服务器的 IP 地址。然后，将 Hostname 的值更改为你的主机名。在我的例子中，这是 lar-book-agent：
```
Hostname=lar-book-agent
```

重要提示

请记住，如果你正在使用多个 Zabbix 服务器或 Zabbix 代理（例如，在运行高可用性 Zabbix 服务器时），你需要在使用 ServerActive 参数时填写所有 Zabbix 服务器或 Zabbix 代理的 IP 地址。高可用性 (HA) 节点由分号（;）分隔，而不同的 Zabbix 环境 IP 地址由逗号（,）分隔。

现在，重启 Zabbix Agent 2 进程：
```
systemctl restart zabbix-agent2
```
接下来，转到 Zabbix 服务器的前端，添加另一个主机并选择一个模板，以进行主动检查，而不是被动检查。
首先，让我们重命名我们的被动主机。为此，请在 Zabbix 前端中进入 数据收集 | 主机，然后点击我们刚创建的主机。将 Host name 更改如下：

图 3.5 – lar-book-agent_passive 的 Zabbix 主机配置页面

我们这样做是因为，对于主动 Zabbix 代理，Zabbix 代理配置文件中的主机名需要与我们的主机配置在 Zabbix 前端中的配置相匹配。对于被动代理，则不需要这样做。

点击蓝色的更新按钮以保存更改。
在 Zabbix 前端中，进入 数据收集 | 主机，然后点击右上角的 创建主机。
现在，让我们创建主机，步骤如下：

图 3.6 – lar-book-agent 的 Zabbix 主机配置页面

同时，确保你添加了正确的模板，名为 Linux by Zabbix agent active：

图 3.7 – lar-book-agent 的 Zabbix 主机模板页面

请注意，从 Zabbix 6.2 版本开始，ZBX 图标应变为绿色，表示这是一个主动代理。注意，当我们导航到监控 | 主机并查看 最新数据 时，我们可以看到我们的主动数据已被接收。

提示

正如你可能已经注意到的，Zabbix 代理可以同时以被动模式和主动模式运行。在创建自己的 Zabbix 代理模板时，请记住这一点，因为你可能希望将检查类型结合起来。最终，Item 类型将决定如何执行对代理的检查。

它是如何工作的…

现在，我们已经配置了 Zabbix 代理并知道它们应该如何设置，让我们看看不同模式是如何工作的。

被动代理

被动代理通过使用 Zabbix 代理从我们的主机收集数据来工作。每当主机上的一个项目达到其 更新间隔 时，Zabbix 服务器会询问 Zabbix 代理当前的值：

图 3.8 – 服务器与被动代理之间的通信示意图

被动代理在需要保持从 Zabbix 服务器或 Zabbix 代理端发起通信的环境中非常有效。例如，在有防火墙的情况下，防火墙仅允许外向流量，此时从 Zabbix 服务器或代理端来看，通信就受到限制。

主动代理

主动代理的工作方式是将数据从 Zabbix 代理发送到 Zabbix 服务器或 Zabbix 代理。每当代理上的某个项目达到更新间隔时，代理将收集该值并发送到服务器：

图 3.9 – 服务器与主动代理之间的通信示意图

主动代理在需要进行通信的环境中非常适用，尤其是在防火墙仅允许外向连接的情况下，从 Zabbix 代理端来看便是如此。许多环境采用这种方式，因为它可以缓解与监控主机相关的主要安全问题之一。与允许 Zabbix 服务器访问所有不同子网（这会带来更大的风险）不同，我们允许主机将数据发送到 Zabbix 服务器——即多个向一个发送，而不是一个向多个发送。

另一方面，使用 Zabbix 代理的主动模式也能提高效率。现在，大部分从 Zabbix 代理到 Zabbix 服务器的数据传输负载都转移到了 Zabbix 代理端。因为 Zabbix 代理的数量通常多于 Zabbix 服务器或代理的数量，所以将负载转移到代理端是一个很好的选择。

如前所述，我们可以同时使用两种类型的检查，这让我们有更大的自由度来配置所需的每种检查。在这种情况下，我们的设置将是这样的：

图 3.10 – 服务器与两种代理类型之间的通信示意图

在我们主要想被动监控的情况下，可能需要用到 Zabbix 代理的主动模式进行一些特定任务。例如，Zabbix 代理进行日志文件监控时必须使用主动 Zabbix 代理。在这种情况下，我们可以结合使用两种模式，并确保我们充分利用 Zabbix 代理提供的所有功能。

另见

Zabbix Agent 2 的背后有很多复杂的工作。如果你对 Zabbix Agent 2 的核心工作原理感兴趣，可以看看 Alexey Petrov 写的这篇有趣的博客文章：blog.zabbix.com/magic-of-new-zabbix-agent/8460/。

使用旧方法进行 SNMP 监控

现在，让我们做一些我在使用 Zabbix 时最喜欢的事情：构建 SNMP 监控。我从事网络工程工作多年，曾使用 SNMP 监控监控各种网络设备。

请记住，尽管本教程会介绍如何使用传统方式进行 SNMP 监控，但它仍然是一个有效的选项。Zabbix 6.4 引入了一种全新的 SNMP 监控设置方式。新方式利用批量指标收集，对于 SNMP 设备和网络会话数量更加高效，因此在完成本教程后，查看这个新方法可能是个不错的选择。

准备就绪

要开始，我们需要前面教程中用到的两台 Linux 主机：

我们的 Zabbix 服务器主机
我们在前面的教程中使用的主机，通过 Zabbix 活动代理进行监控

如何操作…

通过 SNMP 拉取监控非常简单且功能强大。我们将从在监控的 Linux 主机上配置 SNMPv3 开始：

我们首先通过执行以下命令在希望被 SNMP 监控的主机上安装 SNMP。

对于基于 RHEL 的系统：
```
dnf install net-snmp net-snmp-utils
```
对于 Ubuntu 系统：
```
apt install snmp snmpd libsnmp-dev
```

现在，让我们创建新的 SNMPv3 用户，用来监控我们的主机。请注意，我们将使用不安全的密码，因此确保在生产环境中使用安全密码。执行以下命令：

snmpd before executing this command. You can start it again after.This will create an SNMPv3 user with a username of `snmpv3user`, an authentication password of `my_authpass`, and a privilege password of `my_ privpass`.

确保编辑 SNMP 配置文件，以便可以读取所有 SNMP 对象：
```
vim /etc/snmp/snmpd.conf
```
将以下行添加到现有的 view systemview 行。如果没有现有行，直接创建这一新行：
```
view  systemview  included  .1
```
现在，启用并启动 snmpd 守护进程，以便开始监控此服务器：
```
systemctl enable snmpd
systemctl start snmpd
```
这就是在 Linux 主机端需要做的所有配置；现在我们可以去 Zabbix 前端配置我们的主机了。在 Zabbix 前端中，进入 数据收集 | 主机，然后点击右上角的 创建主机。
填写主机配置页面：

图 3.11 – Zabbix 主机配置页面，适用于 lar-book-agent_snmp

别忘了将 SNMP 接口的 IP 地址更改为你自己的值。
确保添加正确的现成模板，如下图所示：

图 3.12 – 将 Linux 的 SNMP 模板添加到主机

提示

在从早期版本的 Zabbix 升级到 Zabbix 6 时，你不会得到所有新的现成模板。如果你觉得缺少了一些模板，可以从 Zabbix GitHub 仓库下载：git.zabbix.com/projects/ZBX/repos/zabbix/browse/templates。

我们在配置中使用了一些宏来表示用户名和密码。通过这些宏，我们可以用相同的凭据添加大量主机。例如，如果你有很多交换机使用相同的 SNMPv3 凭据，这非常有用。

让我们在管理 | 宏中填写宏，如下所示：

图 3.13 – 带有 SNMP 宏的 Zabbix 全局宏页面

提示

Zabbix 6 的一个酷炫功能是能够通过使用密文宏类型在前端隐藏宏。请记住，密文类型的宏在 Zabbix 数据库中仍然是未加密的。因此，要实现完全加密的宏，我们需要类似 HashiCorp 或 CyberArk Vault 的工具。欲了解更多信息，请查看文档：www.zabbix.com/documentation/current/en/manual/config/secrets。

使用下拉菜单将{$SNMPV3_AUTH}**和**{$SNMPV3_PRIV}更改为密文：

图 3.14 – Zabbix 密文用于隐藏敏感（认证）数据

现在，点击更新应用这些更改后，我们应该能够通过 SNMPv3 监控我们的 Linux 服务器。让我们进入监控 | 主机并检查我们新主机的最新数据页面：

图 3.15 – SNMP – lar-book-agent_snmp 的最新数据页面

请注意，数据可能需要约 1 分钟才能显示在这里。

提示

在处理宏时，有三个级别，按级联顺序排列：全局、模板和主机级宏。在处理全局级宏时，请记住，它们不会随模板或主机一起导出。在大多数情况下，您应该使用模板级和主机级宏，以保持导出与 Zabbix 的全局设置独立。

它是如何工作的…

当我们创建主机时，如步骤 4所示，Zabbix 使用 SNMP 轮询该主机。像这样轮询 SNMP 会使用 SNMP OID。例如，当我们轮询1.3.6.1.4.1.2021.4.6.0时，该值会返回到 Zabbix 服务器：

图 3.16 – 显示 Zabbix 服务器与 SNMP 主机之间通信的示意图

OID 就像是我们度量标准的位置地址（或路径）。通过请求 OID，就可以请求该度量标准。

SNMPv3 为这个过程增加了认证和加密，确保当 Zabbix 服务器请求信息时，该请求首先被加密，数据也会被加密后发送回来。

我们还在配置主机时加入了使用组合请求的选项。组合请求在同一流中请求多个 OID，这使得它成为进行 SNMP 请求的首选方法，因为它更高效。只有在主机不支持组合请求时才禁用此功能。更好的方法是使用 SNMP 批量请求，我们将在下一个配方中讨论这一点。

最后，让我们来看看 SNMP OID，这是我们 SNMP 请求中最重要的部分。OID 以树状结构工作，这意味着点后面的每个数字都可以包含另一个值。例如，让我们看看这个用于我们主机的 OID：

1.3.6.1.4.1.2021.4 = UCD-SNMP-MIB::memory

如果我们使用 SNMPwalk CLI 工具或我们的 Zabbix 服务器轮询该 OID，我们将会收到多个 OID 的返回：

.1.3.6.1.4.1.2021.4.1.0 = INTEGER: 0
.1.3.6.1.4.1.2021.4.2.0 = STRING: swap
.1.3.6.1.4.1.2021.4.3.0 = INTEGER: 1679356 kB
.1.3.6.1.4.1.2021.4.4.0 = INTEGER: 1674464 kB
.1.3.6.1.4.1.2021.4.5.0 = INTEGER: 1872872 kB
.1.3.6.1.4.1.2021.4.6.0 = INTEGER: 184068 kB

这包括我们的 1.3.6.1.4.1.2021.4.6.0 OID，其值包含我们的空闲内存。这就是 SNMP 的构建方式，像一棵树一样。

设置新的 SNMP 监视方式

从 Zabbix 6.4 开始，SNMP 监视已经进行了全面的更新，引入了一种新的构建 SNMP 监视的方式。旧方法仍然可用并且有效，但所有开箱即用的监视都将进行更新以适应新方法。

新方法将利用 SNMP 批量查询，使其更加高效。因此，在这个示例中，我们将看看如何使用新的方式构建 SNMP 监视。

准备工作

要开始，我们需要这两台 Linux 主机：

我们的 Zabbix 服务器环境
任何运行 SNMP 服务器的 Linux 主机

如何做……

让我们高效率地开始构建一些批量 SNMP 查询。首先要做的是准备您的主机：

首先，登录到您的 Zabbix 服务器 CLI。我们将开始安装一些额外的工具，以便更轻松地构建 SNMP 监视。

对于基于 RHEL 的系统：
```
dnf install net-snmp-utils
apt install libsnmp-dev
```
接着，在我们希望监视的 Linux 主机上，我们必须安装 SNMP 服务器。

对于基于 RHEL 的系统：
```
dnf install net-snmp net-snmp-utils
```
对于 Ubuntu 系统：
```
apt install snmp snmpd libsnmp-dev
```

现在，让我们在我们想要监视的主机上配置一个新的 SNMPv3 用户，并设置服务器以便可以查询信息：

snmpv3user, an authentication password of my_authpass, and a privilege password of my_ privpass. Please make sure you use secure passwords in your production environments!

确保您编辑 SNMP 配置文件以便可以读取所有 SNMP 对象：
```
vim /etc/snmp/snmpd.conf
```
将以下行添加到其余的视图 systemview 行中：
```
view  systemview  included  .1
```
现在，启用并启动 snmpd 守护进程以便可以开始监视此服务器：
```
systemctl enable snmpd
systemctl start snmpd
```
这是 Linux 主机端需要完成的所有工作；现在我们可以前往 Zabbix 前端配置我们的主机。
前往 Zabbix 前端的 数据收集 | 主机，并点击右上角的 创建主机。我们将使用以下信息创建一个新主机：

图 3.17 – lar-book-snmp_bulk 的 Zabbix 主机配置页面

在添加主机之前，请确保您点击接口部分中的小点下划线添加按钮，并选择 SNMP：

图 3.18 – lar-book-snmp_bulk 的 Zabbix 接口配置

确保为您要监视的主机填写正确的 IP 地址和凭据。

切换到宏标签，并添加以下信息：

图 3.19 – lar-book-snmp_bulk 的 Zabbix 主机配置宏标签

我们还要前往 数值映射 并创建以下值映射。我们稍后会用到这个：

图 3.20 – lar-book-snmp_bulk 的 Zabbix 主机配置数值映射标签

现在，你可以点击页面底部的大添加按钮，主机将被创建。

此时，我们必须开始构建我们的 SNMP 检查。但在此之前，我们应该决定要构建哪些检查。让我们从 Zabbix 服务器的 Linux CLI 进行一个快速的 SNMP walk：

snmpwalk -On -v3  -l authPriv -u snmpv3user -a SHA -A "my_authpass"  -x AES -X "my_privpass" 192.168.1.86 .1.3.6.1.2.1.2.2.1.2

这个 SNMP walk 将会显示类似以下的输出：

.1.3.6.1.2.1.2.2.1.2.1 = STRING: lo
.1.3.6.1.2.1.2.2.1.2.ens192 interface. Remember that the index for the ens192 interface is the number 2; we will need it later.To add all the interface information in bulk to our Zabbix environment, I will use a lower OID. However, note that `.1.3.6.1.2.1.2.2.1` contains all our interface information.

测试所有接口信息的 SNMP walk：

snmpwalk -On -v3  -l authPriv -u snmpv3user -a SHA -A "my_authpass"  -x AES -X "my_privpass" 192.168.1.86 .1.3.6.1.2.1.2.2.1

现在，你应该能看到更多的输出。

让我们通过进入 数据收集 | 主机，选择 lar-book-snmp_bulk 主机，进入项目，然后返回 Zabbix 前端。
在右上角，点击 创建项目 并添加以下信息：

图 3.21 – Zabbix 项目配置 for ifTable.walk

别忘了切换到标签标签页并添加以下内容：

图 3.22 – Zabbix 项目配置 ifTable.walk 标签页

点击窗口底部的大添加按钮将此项目添加到主机中。
这个项目现在将批量收集我们的 SNMP 数据。此时，我们可以创建依赖项来获取特定的值。你应该已经回到主机的项目页面，在这里我们可以再次点击 创建项目。
我的接口名为 ens192，所以让我们获取该接口的操作状态。添加以下信息：

图 3.23 – Zabbix 项目配置 for ifOperStatus[ens192]

别忘了切换到标签标签页并添加以下内容：

图 3.24 – Zabbix 项目配置 ifOperStatus[ens192] 标签页

最后但同样重要的是，我们需要进入 预处理 标签页。在这里我们将决定从批量中提取哪个值。还记得 第 12 步 中的索引吗？现在让我们使用它，通过添加接口操作状态的 OID（1.3.6.1.2.1.2.2.1.8）以及索引 2：

图 3.25 – Zabbix 项目配置 ifOperStatus[ens192] 预处理标签页

现在，点击页面底部的大添加按钮，看看是否一切正常。
进入监控 | 最新数据，找到你的主机 —— 即 lar-book-snmp_bulk：

图 3.26 – Zabbix lar-book-snmp_bulk 在监控 | 最新数据下

如你所见，我们现在正在批量收集 SNMP 信息，然后从这些批量信息中收集单个值。

重要说明

始终建议在收集批量值的项目上使用 不保留历史记录 选项。这样，我们就不会无缘无故地存储重复值。在你完成构建所有 SNMP 项目后，别忘了进行这一更改。

它是如何工作的……

新的 SNMP walk 一开始可能让人有些困惑。我们为什么需要这个新变化？在 Zabbix 6.4 之前的内部工作方式是，它会单独收集每个 SNMP OID。虽然有一个智能机制可以将请求组合在一起以提高效率，但它从未正式作为批量请求（尽管前端是这么称呼的）。

现在，使用新的 walk[] 项键，我们在一个单一的 SNMP GetBulk 请求中收集所有 SNMP 值。这使得整个过程更加高效，并且减少了对 SNMP 设备的压力。

Zabbix 7.0 中还新增了以下三个轮询器：

代理轮询器
HTTP 代理轮询器
SNMP 轮询器（用于 walk[OID] 和 get[OID] 项目）

这些进程现在是异步执行的。这对使用 walk[] 或 get[] 的 SNMP 检查意味着它们可以同时执行多个（项目）检查。在 Zabbix 的旧版本中，这些轮询器每次只能执行一个检查。

仍然可以通过 StartSNMPPollers 添加多个这样的进程，例如，但它的工作方式有所不同。它们每个轮询器最多执行 1,000 次检查，这可以通过 MaxConcurrentChecksPerPoller 参数进行配置。

那么，我们使用了什么？我们从一个简单的请求开始，即获取 SNMP 接口的 OID 下的所有值——也就是 .1.3.6.1.2.1.2.2.1。这包含了我们所有 SNMP 接口的信息，如下图所示：

图 3.27 – Zabbix lar-book-snmp_bulk 原始 SNMP walk 在监控 | 最新数据

之后，我们从收集到的大量数据中提取了一个单一值，经过预处理步骤：

图 3.28 – Zabbix lar-book-snmp_bulk SNMP walk 值预处理

我们可以通过手动提取已经完成的 SNMP walk 中的任何 OID。如果你有大量来自 SNMP walk 项目的信息，但只需要其中少数几个静态值，这个方法非常有用。

当我们收集大量信息并开始使用 LLD 规则自动化任务时，或者当我们仍然需要获取某些特定的值时，这一点尤为明显，这些值可能不适合 LLD。所有这些信息可以通过一次 SNMP 设备调用收集，并随后拆分成 LLD 规则和单独的项目。

我们将在第七章中继续处理这种新的监控方式，使用发现功能自动创建，该章节是使用 Zabbix SNMP 低级发现新方法教程的一部分。

创建 Zabbix 简单检查和 Zabbix trapper

在这个教程中，我们将介绍两个检查，它们可以帮助你构建更为自定义的配置。Zabbix 简单检查为你提供了一种轻松监控特定数据的方法，而 Zabbix trapper 与 Zabbix sender 配合使用，将主机的数据发送到服务器，为你提供了一些脚本选项。让我们开始吧。

准备工作

要创建这些检查，我们需要一台 Zabbix 服务器和一台 Linux 主机来进行监控。我们可以使用之前教程中的带有 Zabbix 代理和 SNMP 监控的主机。

请注意，我们在这些检查中不需要 Zabbix 代理。

如何操作…

正如名称所示，使用简单检查非常简单。那我们开始吧。

创建简单检查

我们将创建一个简单的检查，用于监控某服务是否正在运行，并在某端口上接受 TCP 连接：

为了完成这个任务，我们需要在 Zabbix 前端创建一个新主机。进入 Zabbix 前端的数据收集 | 主机，然后点击右上角的创建主机按钮。
创建一个具有以下设置的主机：

图 3.29 – lar-book-agent_simple 主机的 Zabbix 主机配置页面

现在，进入数据收集 | 主机，然后进入新创建主机的项页面。我们想要通过点击创建项按钮来创建一个新项。

我们必须创建一个新项，填写以下值。完成后，点击页面底部的添加按钮：

图 3.30 – lar-book-agent_simple 主机上端口 22 检查的 Zabbix 项配置页面

请确保你也为该项添加标签，因为我们在多个地方需要它来过滤和查找我们的项。在此设置：

图 3.31 – Zabbix SSH 端口项，标签选项卡

重要提示

我们在这里添加的是net.tcp.services[ssh,,22] 项键。此处的端口是可选的，因为如果需要，我们可以指定使用不同端口的 SSH 服务。

现在，我们应该能够在最新数据屏幕中查看服务器是否接受端口22上的 SSH 连接。进入监控 | 主机，并检查我们的新值：

图 3.32 – lar-book-agent_simple 主机端口 22 检查的 Zabbix 最新数据页面

这里还有一个问题。如你所见，目前我们没有设置值映射。此处，最后值只是显示 1 或 0，让人难以区分其含义。要更改此设置，请返回到 数据采集 | 主机，然后编辑 lar-book-agent_simple 主机。
点击 值映射 标签页，然后点击小的添加按钮以添加一个值映射，如下所示：

图 3.33 – lar-book-agent_simple，值映射窗口

点击蓝色的添加按钮，然后点击蓝色的更新按钮。
然后，在完整的 数据采集 | 主机列表中，导航到我们的 lar-book-agent_simple 主机，并点击该主机的项。
编辑 检查端口 22 是否可用 项，并添加以下值映射：

图 3.34 – lar-book-agent_simple，编辑项窗口

这就是在 Zabbix 中创建简单检查的全部内容。最新数据页面现在应该像这样：

图 3.35 – 我们的端口 22 检查项的最新数据页面

如你所见，现在有一个人类可读的值显示 Up 或 Down，为我们提供了一个更易理解的人类可读条目。现在，让我们看看 Zabbix trapper 项。

创建 trapper

一旦我们进行更高级的设置，使用 Zabbix trapper 项目可以做一些很酷的事情。但现在，让我们在 lar-book-agent_simple 主机上创建一个项：

转到 数据采集 | 主机，点击该主机，然后进入项。我们想在此创建一个新项，点击创建项按钮。

所以，让我们创建以下项并点击添加按钮：

图 3.36 – Zabbix 项目 trap 接收器配置屏幕（lar-book-agent_simple）

确保你也进入标签标签页并添加一个标签。我们稍后会用到它来进行过滤：

图 3.37 – Zabbix 项目 trap 接收器标签配置屏幕（lar-book-agent_simple）

如果我们进入被监控服务器的 CLI，可以安装 Zabbix sender。

对于基于 RHEL 的系统，运行以下命令：
```
dnf -y install zabbix-sender
```
对于 Ubuntu 系统，运行以下命令：
```
apt install zabbix-sender
```
安装完成后，我们可以使用 Zabbix sender 向服务器发送一些信息（确保使用 Zabbix 服务器的 IP 地址，并在使用 -****z 选项时进行指定）：
```
zabbix_sender -z 10.16.16.152 -s "lar-book-agent_simple" -k trap -o "Let's test this book trapper"
```
现在，我们应该能够看到我们被监控的主机是否发送了 Zabbix trap，并且 Zabbix 服务器已接收此 trap 进行处理。
转到监控 | 主机，并检查 最新数据 屏幕，查看我们新的值：

图 3.38 – Zabbix 最新数据页面，针对 lar-book-agent_simple 的项目陷阱接收器

就是这样——我们的 Zabbix 陷阱出现在了 Zabbix 前端。

它是如何工作的…

现在我们已经构建了新的项目，让我们通过深入了解 Zabbix 简单检查和陷阱的理论部分来看看它们是如何工作的。

简单检查

Zabbix 简单检查是一些内置的检查项，用于监控特定的值。Zabbix 文档中提供了所有可用简单检查的列表和说明：www.zabbix.com/documentation/current/manual/config/items/itemtypes/simple_checks。

所有这些检查都是由 Zabbix 服务器执行的，用于从被监控主机收集数据。例如，当我们进行 Zabbix 简单检查以检测端口是否开放时，Zabbix 服务器会请求是否能访问该端口，并将其转化为我们可以在 Zabbix 前端看到的状态。

这意味着，如果你的被监控主机的防火墙阻止了 Zabbix 服务器访问端口 22，我们将看到服务宕机的状态。然而，这并不一定意味着服务器上没有运行 SSH；它只是意味着从 Zabbix 服务器或代理的角度看，SSH 服务是宕机的：

图 3.39 – Zabbix 服务器与主机通信示意图

提示

请记住，使用简单检查依赖于外部因素，如被监控主机上的防火墙设置。在构建简单检查时，确保检查这些因素。

还有一点需要注意。在 Zabbix 6.4 中，增加了无需主机接口即可添加简单检查的功能。这意味着你可以通过在项目键中将连接详情作为参数来直接添加项目，而不必选择接口。

陷阱接收器

在使用 Zabbix 发送器时，我们做的恰恰是大多数检查的相反操作——我们在 Zabbix 服务器上构建一个项目，以便捕获陷阱项目。这使得我们可以构建一些自定义检查，从被监控的主机向 Zabbix 服务器发送数据：

图 3.40 – Zabbix 服务器陷阱接收器示意图

比如说，我们想要构建一个自定义的 Python 脚本，在脚本运行结束时将输出发送到 Zabbix 服务器。我们可以让 Python 使用 Zabbix 发送器工具发送这些数据，这样就可以在 Zabbix 服务器上处理这些数据。

这个过程被一些软件公司用来将他们的软件完全集成到 Zabbix 中。如你所见，我们可以通过 Zabbix 捕获器大大扩展我们的选项，并进一步定制我们的 Zabbix 服务器。令人惊讶的是，这也适用于低级发现，只要我们发送正确的数据格式（JSON）。

使用计算项和依赖项

计算项和依赖项在 Zabbix 中用于从现有值中生成额外的值。有时，我们已经收集了某个值，并且需要对该项创建的值做更多操作。我们可以通过使用计算项和依赖项来做到这一点。

准备工作

为了使用计算项和依赖项，我们需要前面章节中的 Zabbix 服务器和被监控的主机。我们将把项目添加到lar-book-agent_passive主机和我们的 Zabbix 服务器（或任何 MySQL 服务器）主机，这样我们就有一些现成的项目可用于计算和依赖。

如何操作……

让我们看看如何扩展我们的项目。我们将从查看计算项开始。

使用计算项

按照以下步骤操作：

让我们通过进入数据收集 | 主机，点击我们的lar-book-agent_passive主机的项目区域来导航到我们的主机配置。在名称过滤字段中输入内存，你将得到以下输出：

图 3.41 – Zabbix 项目页面，lar-book-agent_passive

现在，我们可以创建一个计算项，它将显示我们 15 分钟内的平均内存使用情况。我们可以使用这个值来确定在那个期间内我们的主机有多忙，而无需查看图表。
让我们点击创建项目按钮，开始创建我们的新计算项。我们希望我们的项目具有以下值：

图 3.42 – Zabbix 项目配置页面，平均内存使用情况

确保你也导航到标签标签页，并添加一个我们稍后用于过滤的标签：

图 3.43 – 计算项标签标签页

现在，如果我们检查监控 | 主机页面并选择最新数据，我们可以查看我们的值。确保你在名称字段中过滤内存，以便查看正确的值：

图 3.44 – Zabbix 最新数据页面，lar-book-agent_passive 内存项

如我们所见，我们正在计算新创建项目的 15 分钟内存使用率的平均值。

使用依赖项

现在是时候创建我们的第一个依赖项了。我将使用 lar-book-rocky 主机或我们的（默认情况下命名为）Zabbix 服务器主机，但任何 MySQL 数据库服务器都应该能工作。假设我们想从 MySQL 数据库一次性请求一些变量。在这种情况下，我们可以在第一个项上创建依赖项来进一步处理数据：

让我们从创建主检查开始。进入 数据收集 | 主机，选择我们的主机，然后点击 创建项 按钮，开始创建我们的第一个新项。我们希望这个项包含以下变量：

图 3.45 – Zabbix 项目配置页面，数据库状态

这个项是一个 SSH 检查，使用 SSH 登录到我们的 Zabbix 服务器主机，然后执行在 执行的脚本 字段中输入的代码。此代码将登录到我们的 MariaDB 数据库，并打印其状态。确保正确输入你的凭证。

提示

不推荐在 MySQL 命令中使用明文凭证，而应该在 执行的脚本 字段中使用宏。这样，你可以使用 密文文本 宏类型，确保没有人能从前端读取你的密码。

在保存这个新项之前，请确保也添加一个标签，像这样：

图 3.46 – Zabbix 主项配置页面，标签选项卡

现在，点击蓝色的添加按钮保存这个新项。
返回到项目列表，点击这个主机的主机名，然后选择宏。在值下创建一个新的 {$USERNAME}** 和 **{$PASSWORD} 宏，填入你的 SSH 用户名和密码。
接下来，进入监控 | 最新数据，查看我们新检查项的数据。应该会有一长串 MariaDB 的值。如果是这样，我们可以继续创建依赖项。
要创建依赖项，请导航到 数据收集 | 主机，选择我们的主机，然后点击 创建项 按钮。我们希望这个项包含以下变量：

图 3.47 – Zabbix 项目配置页面，MariaDB 中止客户端

确保添加以下标签：

图 3.48 – Zabbix 依赖项配置页面，标签选项卡

为这个项添加预处理非常重要，否则我们将只是获取与主项相同的数据。所以，让我们添加以下内容：

图 3.49 – Zabbix 项目预处理页面，MariaDB 中止客户端

添加了预处理后，结果将是我们 MariaDB 实例中已中止的客户端数量：

图 3.50 – Zabbix 最新数据页面，MariaDB 终止的客户端

如你所见，使用依赖项，我们可以利用其他 Zabbix 项中已有的信息，并将其拆分为依赖项。

它是如何工作的…

我们在如何操作…部分中处理的计算项和依赖项可能相当复杂，因此让我们来看看它们是如何工作的。

计算项

使用计算项是从现有数据中获取更多统计信息的好方法。有时，你只需要将多个项合并为一个特定的值。

我们刚才做的操作是通过每隔 15 分钟获取一个项的多个值并计算其平均值，具体如下：

图 3.51 – Zabbix 依赖项示意图

我们每 15 分钟获取这些值并计算平均值。这为我们提供了一个很好的指示，告诉我们在设定的时间段内做了什么。

依赖项

依赖项通过从主项获取数据并将其处理为其他数据来工作。这样，我们可以结构化我们的数据，并保持所有这些项的检查间隔相同，因为依赖项会按照主项的更新间隔接收数据。这意味着依赖项没有（也不需要）更新间隔：

图 3.52 – 依赖项示意图

如我们所见，依赖项充当复制器，我们可以使用预处理选项来获取特定值。请注意，必须使用预处理来提取主项的数据，因为如果没有预处理，我们的数据将与主项相同。

提示

通常，我们不需要将主项保存在数据库中，因为我们已经在依赖项中拥有该信息。当我们不希望保存主项时，我们可以简单地选择不保存历史选项，这样就可以节省一些存储空间。

创建外部检查

为了进一步扩展我们的 Zabbix 功能，我们可以使用自定义脚本，这些脚本可以作为 Zabbix 外部检查执行。并非我们想要监控的所有内容在 Zabbix 中都是标准的，尽管有很多是。总会有些东西可能缺失，外部检查正是绕过这些问题的一种方式。

准备工作

在这个方案中，我们只需要我们的 Zabbix 服务器。我们可以在我们的lar-book-rocky主机上创建一个项，它是我们的 Zabbix 服务器监控的主机。

如何操作…

按照以下步骤操作：

首先，让我们确保 Zabbix 服务器配置正确。请在 Zabbix 服务器 CLI 中执行以下操作：
```
cat /etc/zabbix/zabbix_server.conf | grep ExternalScripts=
```
这应该会显示出我们放置 Zabbix 外部检查所使用脚本的路径。默认情况下，这是/usr/lib/zabbix/ externalscripts/。让我们在这个文件夹中使用以下命令创建一个名为test_external的新脚本：
```
vim /usr/lib/zabbix/externalscripts/test_external
```
将以下代码添加到此文件并保存：
```
#!/bin/bash
echo $1
```
确保我们的 Zabbix 服务器可以执行脚本，通过为文件添加正确的权限来实现。Linux 服务器上的zabbix用户需要能够访问并执行该文件：
```
chmod +x /usr/lib/zabbix/externalscripts/test_external
chown zabbix:zabbix /usr/lib/zabbix/externalscripts/test_external
```
现在，我们准备去我们的主机上创建一个新项。导航到数据收集 | 主机，选择我们的主机lar-book-rocky，然后点击创建项按钮。我们希望此项按如下方式创建：

图 3.53 – Zabbix 项目配置页面

现在我们已经添加了这个新项，让我们导航到监控 | 主机并检查我们主机的最新数据页面。我们的Test变量应该会由脚本返回为 Zabbix 中的最后值，如下截图所示：

图 3.54 – Zabbix 最新数据页面

提示

在前端使用宏作为变量，将数据从前端发送到脚本中。通过这种方式，您可以进一步自动化检查，以增强外部检查。

工作原理…

外部检查看起来有一个陡峭的学习曲线，但从 Zabbix 方面来看它们相当简单。我们所要做的只是执行一个外部脚本，此时我们将收到标准的结果输出（STDOUT）和错误（STDERR）：

图 3.55 – Zabbix 服务器外部脚本通信图

在我们的示例中，我们向脚本发送了一个值Test，然后脚本将其回显为$1。

当你熟悉像 Python 这样的编程语言时，你可以利用这个功能在现有的 Zabbix 功能基础上进行更多扩展——这是一个简单而强大的工具，易于使用。

设置 JMX 监控

Zabbix 内置了 JMX 监控功能，使我们可以监控 Java 应用程序。在本节中，我们将学习如何使用 Zabbix JMX 监控 Apache Tomcat，从而了解这种监控选项的具体内容。

准备工作

为了准备好本节内容，我们需要一个 Zabbix 服务器来监控我们的 JMX 应用程序。

我在本节中使用的是一台 CentOS 7 机器，并安装了 Tomcat。由于软件包依赖关系，使用 Tomcat 在较新的 CentOS 版本上可能会很棘手，因此我建议在本例中使用 CentOS 7。在安装 Tomcat 后，您可以将以下内容添加到配置文件中，使其能够正常工作：

JAVA_OPTS="-Djava.rmi.server.hostname=10.16.16.155
-Dcom.sun.management.jmxremote
-Dcom.sun.management.jmxremote.port=12345
-Dcom.sun.management.jmxremote.authenticate=false
-Dcom.sun.management.jmxremote.ssl=false"

如果您想在生产环境中设置 JMX 监控，可以使用您可能已经在该环境中设置的配置。只需相应地更改端口和 IP 地址即可。

如何操作…

要设置 JMX 监控，我们将向 Zabbix 服务器添加一个主机，用来监控我们的 Apache Tomcat 安装。但首先，我们需要在/etc/zabbix/zabbix_server.conf文件中添加一些设置：

让我们通过登录到 Zabbix 服务器并执行以下命令来编辑 zabbix_server.conf 文件：
```
vim /etc/zabbix/zabbix_server.conf
```
现在，我们需要在该文件中添加以下行：
```
JavaGateway=127.0.0.1
StartJavaPollers=5
```

提示

你可以将 Java 网关安装在与 Zabbix 分开的主机上。这样，你可以分担负载并进行更多的扩展。只需将其安装在一个单独的主机上，并将该主机的 IP 地址添加到 JavaGateway 参数中。只要你的 Zabbix 服务器或代理能够通过网络在端口 10052 上访问网关，应该就能正常工作。在本例中我们不会这样做，因此保持 Java 网关设置在 Zabbix 服务器主机上。

我们还需要在 Zabbix 服务器上安装 zabbix-java-gateway 应用程序，使用以下命令：

基于 RHEL 的系统：
```
dnf install zabbix-java-gateway
systemctl enable zabbix-java-gateway
systemctl start zabbix-java-gateway
systemctl restart zabbix-server
```
Ubuntu 系统：
```
apt install zabbix-java-gateway
systemctl enable zabbix-java-gateway
systemctl start zabbix-java-gateway
systemctl restart zabbix-server
```
这就是我们在服务器端需要做的所有工作，以使 JMX 监控正常运行。Zabbix 默认不包含这些设置，因此我们需要将相应的文本添加到文件中，并安装应用程序。
要开始监控我们的 JMX 主机，进入 Zabbix 前端的 数据收集 | 主机，然后点击右上角的 创建主机。

添加一个主机，使用以下设置：

图 3.56 – Zabbix 项目配置页面

完成后，我们的 JMX 图标应该变成绿色；让我们在监控 | 主机中检查一下。它应该是这样的：

图 3.57 – 监控 | 主机

如果我们点击新添加的 JMX 监控主机的 最新数据，我们应该也能看到传入的数据。查看一下，它应该返回像这样的统计信息：

图 3.58 – Zabbix 最新数据页面

工作原理……

Zabbix 利用 Java 网关，Java 网关可以托管在 Zabbix 服务器本身上，或者托管在另一台服务器（代理）上，以监控 JMX 应用程序：

图 3.59 – Zabbix 服务器与 Java 之间的通信图

Zabbix 会轮询 Java 网关，而 Java 网关则与我们的 JMX 应用程序进行通信，正如在我们的例子中与 Tomcat 的交互一样。然后，数据通过相同的路径返回，我们可以在 Zabbix 服务器上看到这些数据。

另见

有很多应用程序可以通过 Zabbix JMX 进行监控。请查看 Zabbix 监控和集成页面，了解更多 Zabbix JMX 监控的用途：www.zabbix.com/integrations/jmx。

设置数据库监控

数据库对许多工程师来说就像一个黑洞；数据被写入其中，并且对这些数据进行某些处理。但如果你想了解更多关于数据库健康状况的信息呢？这就是 Zabbix 数据库监控的用武之地 —— 我们可以用它来监控数据库的健康状况。

准备工作

为了方便，在本食谱中，我们将监控 Zabbix 数据库。这意味着我们所需的仅仅是已安装 Zabbix 服务器和其上的数据库。在本示例中，我们将使用 MariaDB，因此，如果你有 PostgreSQL 设置，请确保在 Linux 主机上安装 MariaDB 实例（虽然如果更改一些 ODBC 参数， PostgreSQL 也可以创建类似的设置）。

如何操作…

在开始配置项目之前，我们需要在服务器的 CLI 端做一些准备工作：

让我们从安装服务器上所需的模块开始。

基于 RHEL 的系统：

dnf install unixODBC mariadb-connector-odbc

Ubuntu 系统：

apt install odbc-mariadb unixodbc unixodbc-dev odbcinst

现在，让我们验证我们的 开放数据库连接（ODBC）配置文件是否存在：

odbcinst -j

你的输出应类似于以下内容：

unixODBC 2.3.7
DRIVERS............: /etc/odbcinst.ini
SYSTEM DATA SOURCES: /etc/odbc.ini
FILE DATA SOURCES..: /etc/ODBCDataSources
USER DATA SOURCES..: /root/.odbc.ini
SQLULEN Size.......: 8
SQLLEN Size........: 8
SQLSETPOSIROW Size.: 8

如果输出正确，我们可以进入 Linux CLI，继续编辑 odbc.ini 以便连接到我们的数据库：
```
vim /etc/odbc.ini
```
现在，填写你的 Zabbix 数据库信息。它应该是这样的：
```
[book]
Description = MySQL book test database
Driver      = MariaDB
Server      = 127.0.0.1
Port        = 3306
Database    = zabbix
```
让我们也检查一下我们的驱动程序是否存在：
```
vim /etc/odbc.ini
```

你应该看到驱动程序：

# Driver from the mariadb-connector-odbc package
# Setup from the unixODBC package
[MariaDB]
Description     = ODBC for MariaDB
Driver          = /usr/lib/libmaodbc.so
Driver64        = /usr/lib64/libmaodbc.so
FileUsage       = 1

现在，让我们通过执行以下命令来测试我们的连接是否按预期工作：
```
Connected; if you don’t, check your configuration files and try again.
```
现在，让我们进入 Zabbix 前端，配置我们的第一个数据库检查。导航到 数据采集 | 主机，然后点击 lar-book-rocky 主机；请注意，它可能仍然叫做 Zabbix server。接下来，进入项目，我们要通过点击创建项目按钮来创建一个新项目。

提示

如果你还没有这么做，一个保持 Zabbix 结构化的好方法是将 Zabbix 中的所有主机名设置为实际服务器的主机名。将前端中的默认 Zabbix server 主机重命名为你服务器的名称。

我们要添加一个具有以下参数的项目：

图 3.60 – Zabbix 项目配置页面，Zabbix 数据库中的项目

确保你也为项目添加一个标签：

图 3.61 – Zabbix 项目配置页面，Zabbix 数据库中的项目，标签标签

现在，点击添加按钮，然后点击主机名称以添加宏，具体如下：

图 3.62 – Zabbix 主机宏配置页面

现在，如果你进入监控 | 主机，然后点击我们的主机的 最新数据，你将看到以下内容：

图 3.63 – lar-book-rocky 的 Zabbix 最新数据页面，Zabbix 数据库中的项目

从这里，我们可以直接看到写入数据库的项目数量。

如何运作…

Zabbix 数据库监控通过 ODBC 中间件 API 连接到数据库。任何 ODBC 支持的数据库都可以通过 Zabbix 数据库监控进行查询：

图 3.64 – 显示 Zabbix 服务器与 ODBC 之间通信的示意图

你的 Zabbix 服务器将一个命令（例如，MySQL 查询）发送给 ODBC 连接器。你的 ODBC 连接器通过 ODBC API 将查询发送到数据库，数据库返回值给 ODBC。然后，ODBC 将该值转发给 Zabbix 服务器，最终：我们在项目下得到了一个值。

还有更多…

使用 Zabbix 数据库监控，你可以对数据库进行大量查询，但请记住，你正在处理实际的查询。查询数据库需要时间和处理能力，因此要确保你的数据库监控结构化，并定义正确的执行时间。

或者，我们可以使用 Zabbix Agent 2 来原生监控大多数数据库。这可以提高安全性和性能，同时保持较低的复杂性。

设置 HTTP 代理监控

使用 Zabbix HTTP 代理，我们可以通过从网页或 API 获取数据来监控网页或 API。例如，如果网页上有一个计数器，且我们希望关注该计数器的值，可以使用 Zabbix HTTP 监控器来实现。

准备工作

对于本教程，我们需要一个网页来监控，以及我们的 Zabbix 服务器。为了这个实验，我们将使用 Zabbix 更新 v1: services.zabbix.com/updates/v1。

请注意，您的 Zabbix 服务器需要一个活跃的互联网连接才能进行此操作。

如何操作…

让我们从 Zabbix 拉取网页，以显示当前可用的 Zabbix 7.0 的最新版本：

转到你的 Zabbix 前端，选择 数据收集 | 主机。然后，点击 lar-book-agent_simple 主机。
现在，转到项目；我们要通过点击 创建项目 按钮来创建一个新项目。我们需要创建一个 HTTP 代理 项目，如下图所示：

图 3.65 – Zabbix 项目配置页面，oicts.com 页面上的访问者计数

确保按照以下方式填写查询字段：
- 类型: 软件更新检查
- 版本: 1.0
- 软件更新检查哈希: 一个随机生成的 64 字符的字符串，包含小写字母和数字
我们还需要为该项目添加一个标签：

图 3.66 – Zabbix 项目配置页面，oicts.com 页面上的访问者计数，标签选项卡

使用以下预处理步骤：

图 3.67 – Zabbix 项目配置页面，oicts.com 页面上的访问者计数，预处理选项卡

现在，导航到监控 | 主机，并打开我们 lar-book-agent_simple 主机的 最新数据 页面。如果一切正常，我们现在应该能够请求到最新的 Zabbix 7.0 版本：

图 3.68 – Zabbix 最新数据页面

它是如何工作的……

在这里，我们通过 HTTP 代理导航到页面并下载整个网页，来请求 Zabbix 完整的网页内容。一旦我们拥有了页面的完整内容——在这种情况下是一个 HTML/PHP 页面——我们就可以处理这些数据：

图 3.69 – 显示 Zabbix HTTP 代理通信的图示

我们要求我们的预处理器通过 JSONPath 遍历请求的代码，并只显示 latest_release 节点的版本。

剩下的就是数字，准备好供我们在图表和其他类型的数据可视化中使用。

使用 Zabbix 浏览器项模拟网页用户

Zabbix 现在包括了一种全新的网页监控方式。现在可以使用新的 Zabbix 浏览器项 功能来模拟浏览器用户在浏览网页时的操作。这使得模拟页面导航、点击、获取结果等变得可能。

准备开始

对于这个配方，我们只需要 Zabbix 服务器和 Zabbix 前端。请记住，我们将在 Zabbix 服务器上通过 Docker 运行 Selenium，以使这种新类型的监控正常工作。

我们还将使用一些预先准备好的 JavaScript，你可以在这里找到：github.com/PacktPublishing/Zabbix-7-IT-Infrastructure-Monitoring-Cookbook/blob/main/chapter03/browser_item_script.txt。

如何操作……

首先，我们将登录到服务器的 CLI 并开始准备环境：

我们将使用一个轻量级的 Docker 容器来运行 Selenium，它将处理浏览器仿真。在 Zabbix 服务器的 CLI 中发出以下命令。

对于基于 RHEL 的系统：
```
dnf install docker-ce
```
对于 Ubuntu 系统：
```
dnf install docker-ce
```
确保你也启动了 Docker：
```
systemctl enable docker --now
```

现在，让我们下载并运行我们的 Docker 容器：

docker run -d -p 4444:4444 -p 7900:7900 --shm-size="2g" selenium/standalone-chrome:latest

接下来，我们必须编辑 Zabbix 服务器配置：
```
vim /etc/zabbix/zabbix_server.conf
```
Zabbix 服务器配置文件中新增了两个参数，我们可以进行编辑。让我们连接到容器并添加一些浏览器轮询器：
```
WebDriverURL=http://localhost:4444
StartBrowserPollers=2
```
重启 Zabbix 服务器以使更改生效：
```
systemctl restart zabbbix-server
```
完成 Zabbix 服务器端的设置后，让我们继续进行 Zabbix 前端配置。导航到 数据采集 | 主机。
让我们添加一个新的主机来监控我们的 Zabbix 前端网站：

图 3.70 – Zabbix 网站主机配置窗口

点击页面底部的添加按钮来添加这个新主机。
现在，添加一个项目到此主机。点击项目，在Zabbix 网站主机旁边，然后点击右上角的创建项目按钮。
要创建项目，我们需要从 Packt GitHub 仓库下载一些 JavaScript。你可以在这里找到它：github.com/PacktPublishing/Zabbix-7-IT-Infrastructure-Monitoring-Cookbook/blob/main/chapter03/browser_item_script.txt。
现在，让我们填写新项目的字段。确保将前述脚本放入脚本字段。项目现在应该像这样：

图 3.71 – Zabbix 网站主机项目配置窗口

确保你也添加一个标签：

图 3.72 – Zabbix 网站主机项目标签配置窗口

现在，通过点击窗口底部的添加按钮来保存该项目。
由于我们使用的是宏，请确保将它们添加到主机中。点击Zabbix 网站主机名。然后，添加以下宏：

图 3.73 – Zabbix 网站主机宏配置窗口

确保填写正确的 URL。同时，不要忘记将密码宏设置为秘密文本类型。

导航到监控 | 最新数据，现在应该显示我们的新主机的值：

图 3.74 – Zabbix 网站项目结果

如我们在本章前面所学，我们可以使用依赖项目从这个批量度量项目中提取数据。这就是我们接下来要做的。
返回数据收集 | 主机，并点击Zabbix 网站主机的项目。
点击右上角的创建项目，并创建一个新项目来获取总时长：

图 3.75 – 浏览器监控总时长项目

点击预处理，以便我们可以添加预处理详情：

图 3.76 – 浏览器监控总时长项目预处理

点击标签 – 我们不能忘记添加标签：

图 3.77 – 浏览器监控总时长项目标签

点击添加以完成创建该项目。
现在，再次点击右上角的创建项目，并创建一个新项目来获取启用主机的数量：

图 3.78 – 启用浏览器监控的主机项目

点击预处理并添加一些预处理详情：

图 3.79 – 启用浏览器监控的主机项目预处理

点击标签 – 我们不能忘记添加标签：

图 3.80 – 启用浏览器监控的主机项目标签

点击添加来完成项目的创建。

提示

随时自己添加更多依赖项，以便从主项收集的原始 JSON 中获得更多统计数据。不要忘记在添加完依赖项后，将 历史记录 设置为 不存储，以节省一些磁盘空间。

让我们来看一下这段代码是如何工作的。

它是如何工作的……

使用新的 Zabbix 浏览器监控，我们可以将高级 JavaScript 与 Selenium 等结合使用。这让我们可以做几乎任何普通浏览器用户能做的事情。这为我们提供了无限的机会来监控最终用户的行为。

让我们来看看我们 JavaScript 中的一些步骤：

try {
    var params = JSON.parse(value); // Parse the JSON string passed from Zabbix
    var webUrl = params.webUrl;
    var username = params.username;
    var password = params.password;
    browser.navigate(webUrl);
    browser.collectPerfEntries("open page");

我们从解析在 Zabbix 前端定义的参数开始。我们不想仅仅使用硬编码的用户名和密码——我们希望使用其他可以动态变化的值，比如 URL，这些对于解析非常有用。通过这种方式，我们创造了灵活性，这在稍后创建模板时也非常有用：

    // Find and fill username
    var el = browser.findElement("xpath", "//input[@id='name']");
    if (el === null) {
        throw Error("cannot find name input field");
    }
    el.sendKeys(username);
    // Find and fill password
    el = browser.findElement("xpath", "//input[@id='password']");
    if (el === null) {
        throw Error("cannot find password input field");
    }
    el.sendKeys(password);
    // Find and click the login button
    el = browser.findElement("xpath", "//button[@id='enter']");
    if (el === null) {
        throw Error("cannot find login button");
    }
    el.click();

接下来，我们有一个 browser.findElement 函数。我们将使用它来查找正确的字段，以便在点击登录按钮之前填写用户名和密码。通过这种监控方式，我们实际上是在将 JavaScript 转换为看起来像是用户也可能在做的事情：

    // Collect performance data after login
    browser.collectPerfEntries("login");

我们还收集了一些性能统计数据，以便找到登录执行的速度：

    // Navigate to Reports -> System information
    el = browser.findElement("xpath", "//a[contains(text(),'Reports')]");
    if (el === null) {
        throw Error("cannot find Reports menu");
    }
    el.click();
    el = browser.findElement("xpath", "//a[contains(text(),'System information')]");
    if (el === null) {
        throw Error("cannot find System information submenu");
    }
    el.click();
    // Find the required server performance row and get the value
    nvps = browser.findElement("xpath", "//tr[th[contains(text(), 'Required server performance, new values per second')]]/td[1]");
    totalHosts = browser.findElement("xpath", "//tr[th[contains(text(), 'Number of hosts (enabled/disabled)')]]/td[1]");
    enabledHosts = browser.findElement("xpath", "//tr[th[contains(text(), 'Number of hosts (enabled/disabled)')]]/td[2]/span[1]");
    disabledHosts = browser.findElement("xpath", "//tr[th[contains(text(), 'Number of hosts (enabled/disabled)')]]/td[2]/span[2]");
    numberOfTemplates = browser.findElement("xpath", "//tr[th[contains(text(), 'Number of templates')]]/td[1]");
    totalItems = browser.findElement("xpath", "//tr[th/span[contains(text(), 'Number of items (enabled/disabled/not supported)')]]/td[1]");
    enabledItems = browser.findElement("xpath", "//tr[th/span[contains(text(), 'Number of items (enabled/disabled/not supported)')]]/td[2]/span[1]");
    disabledItems = browser.findElement("xpath", "//tr[th/span[contains(text(), 'Number of items (enabled/disabled/not supported)')]]/td[2]/span[2]");
    nsItems = browser.findElement("xpath", "//tr[th/span[contains(text(), 'Number of items (enabled/disabled/not supported)')]]/td[2]/span[3]");
    if (el === null) {
        throw Error("cannot find required server performance row");
    }
    var performanceValue = nvps.getText();
    var totalHosts = totalHosts.getText();
    var enabledHosts = enabledHosts.getText();
    var disabledHosts = disabledHosts.getText();
    var numberOfTemplates = numberOfTemplates.getText();
    var totalItems = totalItems.getText();
    var enabledItems = enabledItems.getText();
    var disabledItems = disabledItems.getText();
    var nsItems = nsItems.getText();

然后，我们有几个 browser.findElement 函数，用来导航到报告 | 系统信息 菜单。在这个页面上，我们要从表格中找到特定的行。这里有一点很重要，除了使用浏览器监控来收集性能数据或查看用户功能是否仍然有效外，我们还可以使用它来提取度量数据。我们很快会回到这个话题：

    // Find and click the logout button
    el = browser.findElement("xpath", "//a[contains(text(),'Sign out')]");
    if (el === null) {
        throw Error("cannot find logout button");
    }
    el.click();
    // Collect performance data after logout
    browser.collectPerfEntries("logout");
    // Set result with the performance value
    result = browser.getResult();
    result.performanceValue = performanceValue;
    result.totalHosts = totalHosts;
    result.enabledHosts = enabledHosts;
    result.disabledHosts = disabledHosts;
    result.numberOfTemplates = numberOfTemplates;
    result.totalItems = totalItems;
    result.enabledItems = enabledItems;
    result.disabledItems = disabledItems;
    result.nsItems = nsItems;
} catch (err) {
    if (!(err instanceof BrowserError)) {
        browser.setError(err.message);
    }
    result = browser.getResult();
    result.error.screenshot = browser.getScreenshot();
} finally {
    return JSON.stringify(result);
}

我们必须确保正确登出（最佳实践是在结束任何会话时正确退出），此时我们可以进行更多的错误和结果捕获。此时，我本想向你展示 JSON 结果，但我们不想不必要地多砍几棵树。打开你的 最新数据 页面，查看一些 JSON 条目：

   "duration":1.8088712692260742,

我们可以在 JSON 结果的顶部看到整个项目执行的总时长：

         {
            "mark":"open page",
            "navigation":{
….
               "transfer_size":4220,
               "duration":0.08759999996423722,
….

对于我们执行的每一步，我们可以看到一个 mark 值，这将提供更多关于我们通过浏览器执行的操作的信息：

"performanceValue":"9.46","totalHosts":"23","enabledHosts":"18","disabledHosts":"5","numberOfTemplates":"287","totalItems":"1108","enabledItems":"650","disabledItems":"241","nsItems":"217"}

最后但同样重要的是，在底部，我们有提取的 Zabbix 系统报告值。我们通过这个单一的浏览器项目监控类型收集了所有这些信息：

图 3.81 – Zabbix

利用我们之前学习的依赖项目，我们现在可以从由浏览器项目类型收集的批量度量数据中提取有用数据。这使我们能够在单个项目中获得干净、整洁的度量数据，这些数据也可以轻松用于触发器。例如，我们可以使用这些触发器来指定持续时间是否过长，或者当前启用的主机是否少于之前。

如你所见，这种单一的新项目类型为我们打开了一个全新的可能性世界。我只能想象 Zabbix 社区会发现越来越多的使用案例，并分享他们令人惊叹的新模板。

使用 Zabbix 预处理来修改项目值

预处理项目值是 Zabbix 中的一个重要功能，我们可以用它来创建各种检查。我们在本章中已经做了一些预处理，但让我们更深入地了解它以及它的作用。

入门

我们需要一个 Zabbix 服务器来创建检查。我们还需要在 Linux 主机上运行一个被动的 Zabbix 代理来获取并预处理我们的值。我们可以使用在 Zabbix 服务器上运行的代理来做这件事。在我的例子中，它是 lar-book-rocky。

如何操作…

按照以下步骤操作：

让我们从登录到 Zabbix 前端并进入 数据收集 | 主机开始。
点击你的 Zabbix 服务器主机；在我的例子中，它叫做 lar-book-rocky。
现在，转到项目并点击右上角的蓝色 创建项目 按钮。让我们创建一个新的项目，信息如下：

图 3.82 – 新项目创建屏幕，从 CLI 获取流量统计信息

别忘了添加你的标签：

图 3.83 – 新项目创建屏幕，从 CLI 获取流量统计信息，标签页

确保将 ens192 更改为你的主网络接口。你可以通过登录到 Linux CLI 并执行以下命令来找到你的主网络接口：
```
Ifconfig
```
在项目创建屏幕上，点击蓝色的添加按钮。此项目将使用 Zabbix 代理在 Linux CLI 上执行远程命令。
当我们导航到这个新项目时，我们会看到该项目变成了不支持状态。这是因为当我们使用 system.run 键时，需要在 Zabbix 代理配置中允许它：

图 3.84 – 不支持的项目信息，未知的度量系统.run

登录到被监控主机的 Linux CLI，并通过运行以下命令编辑 Zabbix 代理配置：
```
vim /etc/zabbix/zabbix_agent2.conf
```
转到 Option: AllowKey 行并添加 AllowKey=system.run[*]，如图所示：

图 3.85 – Zabbix 代理配置文件，AllowKey=system.run[*]

保存文件并重启 Zabbix 代理，方法如下：
```
systemctl restart zabbix-agent2
```
返回 Zabbix 前端，步骤 7 中我们注意到的错误应该在几分钟后消失。
返回到监控 | 最新数据，并筛选你的 Zabbix 服务器主机，lar-book-rocky，以及新从 CLI 获取流量统计信息项目的名称。
现在，值应该从主机中拉取。如果我们点击历史，我们可以看到完整的值，应该如下所示：

图 3.86 – Zabbix agent system.run 命令执行 ifconfig ens192 结果

我们在这里看到的信息太多，无法仅用一个项目显示，所以我们需要将其拆分。我们将使用预处理从信息中获取 RX 字节数。
返回到数据采集 | 主机，然后点击你的 Zabbix 服务器主机。进入该主机的项目。
点击从 CLI 获取流量统计信息项目进行编辑。将其名称更改为ens192 的总 RX 流量字节数，并在单位中添加B，其中B表示字节。它将如下所示：

图 3.87 – Zabbix agent system.run 项目

添加你的标签：

图 3.88 – 新项目创建屏幕，获取 CLI 流量统计信息，标签标签

现在，点击预处理，然后点击下划线的添加按钮。
一个正则表达式（regex）字段将被添加。我们将填写这个字段，以便它匹配你接口的总字节数：

图 3.89 – Zabbix agent system.run 项目预处理

确保你也选中了自定义 失败时丢弃值框。
现在，再次点击下划线的添加按钮，并使用此新步骤的下拉菜单选择丢弃不变值。结果将如下所示：

图 3.90 – Zabbix agent system.run 项目预处理

现在我们可以点击蓝色的更新按钮来完成编辑此项。
返回到监控 | 最新数据，并筛选你的主机和新项目名称，ens192 的总 RX 流量字节数。确保使用你自己的接口名称。
我们现在可以看到我们的值进来了。这里，我们有一个项目显示主接口的总 RX 流量：

图 3.91 – Zabbix 总 RX 流量项目最新数据

它是如何工作的…

我们在处理计算和依赖项项目食谱中做了一些预处理，以从主项目获取数据。我们还在设置 HTTP agent 监控食谱中使用了预处理，从网页中获取特定值。然而，我们并没有在这些食谱中介绍使用的预处理概念，所以我们在这里讲解一下。

在进行预处理时，了解基本的设置是很重要的。让我们在使用预处理之前，先看看传入的数据：

图 3.92 – Zabbix 代理 system.run 命令执行 ifconfig ens192 结果

这是大量的信息。当我们查看 Zabbix 项目的使用方式时，我们尝试将可理解的信息放入一个项目中。幸运的是，我们可以在将值存储到 Zabbix 之前对该项目进行预处理。在下图中，我们可以看到我们为项目添加的预处理步骤：

图 3.93 – Zabbix 代理 system.run 项目预处理的两个步骤

我们的第一步是正则表达式。此步骤将确保我们仅使用所需的数字。我们匹配单词RX，然后是单词bytes，以及它们之后的一串数字。这样，我们最终得到的是捕获组 2 中的 RX 字节总数。这就是为什么我们在输出字段中填入\2的原因。我们还指定了自定义失败处理，如果正则表达式未匹配，则丢弃任何值。

我们的第二步是丢弃任何与之前接收到的值相同的值。与其存储重复的值，我们干脆丢弃它们，从而节省了 Zabbix 数据库中的空间。

小贴士

使用像regex101.com/这样的在线工具来构建正则表达式要容易得多。你可以看到你的捕获组将获得的数字，并且工具中还有很多有价值的信息。

需要注意的是，步骤是按照它们在前端定义的顺序执行的。如果第一步失败，除非自定义失败处理设置为执行其他操作，否则该项目将变得不支持。

通过在 Zabbix 中添加预处理，我们为我们的项目开启了一系列新的选项，我们几乎可以根据需要以任何方式修改数据。这两个步骤只是深入 Zabbix 预处理世界时可用选项的开始。

另请参见

Zabbix 中的预处理是一个重要的主题，在一个简单的方案中不可能涵盖它的每个方面。本方案中的两个预处理步骤只是我们可以使用的众多选项中的两个。请查看官方 Zabbix 文档，了解我们可以使用的其他选项：www.zabbix.com/documentation/current/en/manual/config/items/preprocessing。

第四章：4

使用触发器和警报

现在，如果没有实际进行警报操作，那么 Zabbix 收集的所有数据又有什么用呢？当然，我们可以使用 Zabbix 来收集数据，并手动查看它们，但 Zabbix 在我们开始发送通知给用户时变得更有用。这样，我们就不需要时刻关注 Zabbix 前端，而是让触发器和警报为我们工作，只有在需要时，才会引导我们到前端。

在 Zabbix 7 中，你会发现与 Zabbix 5 相比，触发器表达式的语法有所变化。这种语法自 Zabbix 5.4 版本以来已经可用，因此如果你跳过了某些版本，这可能是你第一次接触这种语法。如果你之前使用的是 Zabbix 5.4 之前的版本，请记住，你可能需要适应这种新的语法。如果你已经运行 Zabbix 5.4 或更高版本，那么 Zabbix 7 中的语法将保持一致。

我们将在接下来的教程中详细学习如何使用新的表达式格式设置有效的触发器，以及如何设置警报：

设置触发器
设置高级触发器
设置警报
保持警报的有效性
自定义警报

技术要求

对于本章，我们需要一台 Zabbix 服务器，例如前一章中使用的那台服务器。

在你选择的 Linux 发行版上安装 Zabbix 服务器。我们将使用在第一章中设置的服务器。
MariaDB 设置以与 Zabbix 服务器配合工作。
设置 NGINX 或 Apache 以提供 Zabbix 前端。
我们还需要一台 Linux 主机进行监控，以便实际构建一些有趣的触发器来使用。

设置触发器

触发器在 Zabbix 中很重要，因为它们会通知你数据的状态变化。当我们的数据达到某个阈值或收到某个值时，我们希望触发一个警报。

那么，让我们开始设置一些有趣的触发器吧。定义触发器有许多不同的选项，但阅读完本教程后，你应该能够设置一些最常见的触发器。让我们将你的触发器经验提升到一个新的水平。

准备工作

对于本教程，我们需要准备好 Zabbix 服务器，并且需要一台 Linux 主机。我将使用上一章中的lar-book-agent_simple主机，因为我们已经在该主机上配置了一些项目。

我们还需要一个由 Zabbix 代理监控的主机，并使用 Zabbix 代理模板。我们将使用该主机上的一个项目来创建触发器。这将是上一章中的lar-book-agent_passive主机。

在此主机上，我们已经有一些可用的触发器，但我们将进一步扩展这些触发器，以便更好地通知我们。

如何操作…

在本节中，我们将创建三个触发器来监控状态变化。让我们从创建第一个触发器开始。

触发器 1 – SSH 服务监控

让我们在lar-book-agent_simple主机上创建一个简单的触发器。我们在该主机上进行了一个名为检查端口 22 是否可用的简单检查，但我们还没有创建任何通知机制：

首先，让我们开始前往数据收集 | 主机，然后点击主机并进入触发器。在这里我们可以找到我们的触发器并创建新的触发器。我们将在右上角点击蓝色的创建触发器按钮来创建新的触发器。
让我们创建一个新的触发器，使用以下信息：

图 4.1 – Zabbix 触发器创建页面 – 服务无法访问

点击添加，并完成触发器的创建。这将为我们创建一个触发器，当我们的安全外壳（SSH）端口出现故障时触发。
让我们通过进入我们的主机命令行界面（CLI）并执行一些命令，模拟将 Zabbix 服务器从端口22上关闭来测试它。我们将添加一个iptables规则，阻止所有进入端口22（SSH）的流量：
```
iptables -A INPUT -p tcp -i ens192 -s 10.16.16.152
--destination-port 22 -j DROP
```
确保将ens192网卡和 IP 地址10.16.16.152替换为您自己的值。您可以使用以下命令来获取这些信息：
```
ip addr
```
现在，如果我们点击导航栏中的仪表盘，稍等片刻后，我们应该看到以下内容：

图 4.2 – Zabbix 仪表盘上的问题 – 端口 22 无法访问

触发器 2 – 当有新 Zabbix 版本发布时触发

现在，为了创建我们的第二个触发器，我们来稍微提高一下难度。如果您已经跟随第三章、设置 Zabbix 监控中的设置 HTTP 代理监控这部分，我们创建了一个项目，定期查询 Zabbix 网站以获取 Zabbix 的最新版本，Zabbix 7.0。现在，我们可能想要做的就是持续关注任何新的 Zabbix 版本发布：

让我们前往数据收集 | 主机，并点击lar-book-agent_simple主机。
现在，前往触发器并点击创建触发器按钮。我们将使用以下设置来构建我们的触发器：

图 4.3 – Zabbix 触发器创建页面 – 新的 Zabbix 7.0 版本触发器

点击添加，并完成触发器的创建。

现在，这个触发器可能在前端不会立即触发，但我将在本食谱的工作原理…部分解释这个触发器是如何工作的。

触发器 3 – 在触发器中使用多个项目

我们已经看到了一些使用单个项目的触发器，但我们也可以在一个触发器中使用多个项目。让我们通过在同一个表达式中使用多个项目来构建一个新的触发器：

让我们前往数据收集 | 主机，并点击lar-book-agent_passive主机。接下来，前往触发器并点击创建触发器按钮。
我们将使用以下设置创建一个触发器：

图 4.4 – Zabbix 触发器创建页面 – 入站或出站数据包触发器

请注意，你的项目键可能需要不同的接口名称。在我的案例中，接口名是ens192，因此请使用你所在主机的正确接口名称。使用以下 Linux 命令来获取你主机的接口：
```
ip addr
```
点击添加按钮，完成触发器的创建。

这里有一个小提示 - 在触发器创建页面，使用添加按钮，位于表达式字段旁边，轻松地添加条件并构建表达式。例如，我们可以使用选择按钮从列表中选择一个项目。当使用函数下拉菜单时，还有一个非常有用的功能，就是每个触发器函数都有一个简短的说明：

图 4.5 – 触发器创建页面

这就是我们创建一个在两个项目上运行的触发器所需要做的所有工作。

它是如何工作的……

我们需要充分理解如何构建触发器及其工作原理，以便创建一个配置良好的监控平台。特别重要的是，我们需要确保触发器配置正确，并对其进行充分的测试。触发器是 Zabbix 中非常重要的一部分，它们对通知你监控目标的运行状态至关重要。若配置触发器过于宽松，你会错过重要信息；配置过于严格，你会被过多信息淹没。

在所有这些触发器中，我们还包括了触发器的严重性，如下图所示：

图 4.6 – 一个 Zabbix 触发器严重性选择器

这些严重性级别非常重要，可以确保你的警报根据重要性正确定义。在 Zabbix 前端的多个地方，甚至在一些操作中，我们都可以根据这些严重性级别进行筛选。

现在，让我们来看看为什么我们按照这样的方式构建触发器。

触发器 1 – SSH 服务监控

这是一个在 Zabbix 中非常简单但有效的触发器配置。当我们的值返回1表示UP或0表示DOWN时，我们可以轻松创建这样的触发器——不仅用于监控逻辑端口的开关状态，还适用于所有返回简单值变化的情况，例如从1到0，或者反过来。

现在，如果我们分析我们的表达式，得到以下内容：

图 4.7 – 一个 Zabbix 触发器表达式 – 端口 22 (SSH)

在构建表达式时，我们有四个部分：

触发器函数：触发器函数是表达式的一部分，决定了我们期望值的内容，例如是否只需要最后一个值，或者比如说一段时间内的平均值。
主机：表达式中的主机部分是我们定义用于触发的主机。大多数时候，它就是我们正在使用的主机（或模板）。
项目键：项目键是表达式的一部分，我们在其中定义了要用于从主机检索值并将其输入触发函数的项目键。
运算符：运算符决定了我们的函数如何基于触发表达式进行计算——例如，可能是与常数或另一个表达式进行比较。运算符可以是任何形式，如下所示：

=	等于。
<>	不等于。
>	大于。
<	小于。
>=	大于或等于。
<=	小于或等于。
+	加上。
-	减去。
/	除以。
*	乘以。
and	逻辑与。用于例如同时满足一个和另一个表达式。
or	逻辑或。用于例如，等于一个或另一个表达式。
not	逻辑非。用于例如，特定地不等于某个表达式。

常量：常量是触发函数用来确定触发器是否应该处于OK或PROBLEM状态的实际常量（通常是一个值）。我们在这里也可以使用宏。

现在，对于我们的第一个触发器，我们定义了我们的主机和提供 SSH 状态的项目。我们在触发函数中所说的是，我们希望在触发之前最后一个值为 0。

对于这个项目，这意味着它会在一分钟内触发，因为在我们的项目中，我们指定了以下内容：

图 4.8 – Zabbix 项目配置页面 – 端口 22 可用性项目

看着0并且考虑到由于1m间隔，SSH 端口 22 的停机时间最多为一分钟。

触发器 2 – 当有新的 Zabbix 版本时触发

现在，对于我们的第二个触发器，我们做了一些不同的事情。我们不仅为触发此问题创建了一个表达式，还为从触发器中恢复创建了一个表达式。在问题表达式选项中，我们定义了一个触发函数，告诉我们的主机将最后一个值与前一个值进行比较。我们通过使用change触发函数来实现这一点。

图 4.9 – Zabbix 触发表达式 – HTTPS 检查

因此，只有在最新的 Zabbix 版本发生更改时，我们的触发器才会被激活。我们本可以让触发器在当前值和之前的值相同的时候第一次解决，但我希望让这个触发器保持在PROBLEM状态稍微长一点。

因此，我还定义了一个恢复表达式。我告诉它，只有在接收到最后一个值和倒数第五个值时，问题才能恢复。请仔细查看恢复表达式：

图 4.10 – 另一个 Zabbix 触发器表达式 – 使用不同值的 HTTPS 检查

恢复表达式在你想通过稍微更多的控制来扩展触发器功能，特别是在它恢复到OK状态时，非常强大。

提示

你可以使用恢复表达式将触发器的PROBLEM状态扩展到你在问题表达式选项中定义的范围之外。这样，我们就知道触发器仍然接近PROBLEM状态。我们定义只有在达到了恢复表达式中定义的另一个阈值后，触发器才会回到OK状态。这将通过评估问题表达式和恢复表达式来工作，其中问题表达式必须是FALSE，而恢复表达式必须是TRUE。

触发器 3 – 在触发器中使用多个项

现在，触发器 3 可能看起来有些复杂，因为我们使用了多个项，但基本设置是一样的：

图 4.11 – 使用多个项的 Zabbix 触发器表达式

我们对表达式的设置是相同的，包括函数、主机、项键和值。但当我们处理多个项时，可以在项之间添加or语句。这样，我们可以说，我们需要匹配其中一个项才能触发PROBLEM状态。在这种情况下，只要任意一项超过阈值，我们就触发。

重要提示

在这个触发器表达式中，我们在不同项的表达式之间有一些空行。项表达式之间的空行是完全可以的，实际上有助于提高可读性。在构建触发器时，明智地使用这一点。

旧版与新版触发器表达式语法

如果你以前使用过 Zabbix 5.4 之前的版本，接下来的部分可能会对你很有意思。如我们在介绍中提到的，Zabbix 中的表达式已进行大规模更新。触发器表达式现在的工作方式与 Zabbix 中计算项以及其他地方的方式相同，提供了统一的体验。

让我们看看在 Zabbix 5.2 和更早版本中看到的旧表达式语法：

图 4.12 – 使用旧语法的 Zabbix 触发器表达式

在旧语法中，我们总是从大括号开始，然后是主机名或模板名。在主机名或模板名与项键之间，我们有一个冒号。在标记项键的结尾时，我们有一个点，但项键本身也可以包含点。然后，在点后，我们有触发器函数，最后是结束的大括号。然后，我们剩下的就是我们要用来与表达式进行比较的运算符和常量。

如你所料，这在使用项键中的点时可能会变得有些混乱。现在让我们来看一下新的触发器语法：

图 4.13 – 使用新语法的 Zabbix 触发器表达式

我们的新触发器语法从触发器函数开始，直接展示我们正在做什么，不需要任何麻烦。接下来是一个括号和一个斜杠，然后进入主机或模板名称。我们随后使用另一个斜杠来分隔主机名或模板名与项键。最后以一个括号结束，然后剩下的就是我们希望与之匹配的操作符和值。

从触发器函数开始，使得这一行的作用一目了然。将主机名或模板名放入括号中，然后用斜杠将其与项键分隔开来，这让编写表达式时的体验更加连贯。我们也不再有混淆的额外点了。总的来说，这是触发器语法的一个非常好的变化，老实说，可能需要一些时间来适应。

正是这些小细节让整个软件感觉更加专业且经过深思熟虑。像这些更改，Zabbix 的引入无疑对这一点大有帮助。

还有更多……

我们不仅可以匹配触发器表达式中的某一项，还可以使用 and 语句。这样，我们可以确保触发器只有在多个项达到某一特定值时才会进入 PROBLEM 状态。触发器非常强大，可以让我们在详细程度上定义自己的标准。没有预定义——我们可以在触发器表达式中根据需要添加任意多的 and、not 或 or 语句以及不同的函数。根据您的需求自定义触发器，这样您会更加安心，因为您知道触发器会在出现问题时通知您。

另请参见

若要了解更多关于触发器表达式的信息，请查阅 Zabbix 文档。文档中有很多关于如何使用哪些函数来构建完美触发器的详细信息。详情请访问 www.zabbix.com/documentation/current/en/manual/config/triggers/expression。

设置高级触发器

Zabbix 中的触发器不断变得更加高级，可能会让人难以跟上。对于使用 Zabbix 5.2 或更早版本并升级到 Zabbix 7 的用户，不仅有了全新的 Zabbix 触发器语法，还引入了全新的函数集合。

让我们深入了解如何在 Zabbix 7 中设置一些更高级的触发器。

准备工作

对于这个教程，我们需要准备好 Zabbix 服务器，并且需要一个通过 Zabbix 代理监控的主机，并且该主机使用了 Zabbix 代理模板。我们将使用该主机上的项来创建触发器。让我们使用上一章节中的 lar-book-agent_passive 主机。

如果你没有在上一章中提到的这个主机，只需连接一个新的主机，并使用默认的被动 Linux 监控模板 Linux by Zabbix agent。

我们还将讨论一些在书后部分提到的更高级主题。例如，如果你不知道如何使用低级发现（LLD），那么不妨先深入了解第七章，使用发现进行自动创建。

如何操作…

让我们来看一下与前一个教程中看到的三个触发器相比的三种更高级触发器：用于遍历趋势数据的 trendavg、用于预测未来值的 timeleft 和用于与过去比较的时间偏移。

高级触发器 1 – trendavg 功能

首先，我们来看看其中一个新的触发器功能，趋势平均（trendavg）功能：

让我们从在前端创建一个新的触发器开始。导航到数据收集 | 主机并选择lar-book-agent_passive。
导航到触发器，然后点击右上角的蓝色创建触发器按钮。
在表达式字段旁，点击白色的添加按钮。使用表达式构建器填写触发器：

图 4.14 – trendavg 触发器表达式构建器

点击插入并添加名称。如果正确完成，它将如下所示。

图 4.15 – 已填写的 trendavg 触发器表单

现在，让我们点击页面底部的蓝色添加按钮，完成此触发器的创建。

创建此触发器就这些。请查看本教程的如何工作...部分，以获取更多有关触发器的信息。

高级触发器 2 – timeleft 功能

接下来是我们的 timeleft 函数，它对于诸如空间利用率之类的内容非常有用。我们来看看：

我们将在 Zabbix 前端创建一个新的触发器。导航到数据收集 | 主机并选择lar-book-agent_passive。
导航到发现规则，然后点击已挂载 文件系统发现旁边的触发器原型。

重要提示

在这种情况下，我们直接在主机上创建触发器原型，使用现有的模板发现规则。如果你想将这样的触发器应用于每个使用模板的主机，确保在模板级别上创建触发器。此外，发现规则的详细解释可以参考本书的第七章，使用发现进行自动创建。

点击创建 触发器原型。
在表达式字段旁，点击白色的添加按钮。使用表达式构建器填写触发器：

图 4.16 – timeleft 触发器表达式构建器

重要提示

在预测触发器中使用短时间间隔来预测长时间段是不推荐的。确保使用与我们想要预测的时间相关的正确数据集。

点击蓝色的插入按钮，完成的触发器将如下所示。

图 4.17 – 填写完毕的 timeleft 触发器表单

点击页面底部的蓝色添加按钮以完成触发器的设置。

我们现在有一个新的触发器，使用timeleft函数告诉我们硬盘在一周内何时填满。查看本配方的工作原理…部分以获取更多关于触发器的信息。

高级触发器 3 – 使用数学函数进行时间偏移

最后，我们将处理时间偏移，在这种情况下，我们将其与数学函数结合使用。时间偏移是一个有些复杂的例子，请耐心一下：

让我们导航到数据收集 | 主机并选择我们的主机，lar-book-agent_passive。
转到触发器并点击蓝色的创建 触发器按钮。
添加以下触发器，如截图所示：

图 4.18 – 填写完毕的时间偏移平均触发器表单

这是一个非常复杂的触发器设置，因此让我们直接进入工作原理…部分，看看它是如何设置的。

工作原理…

高级触发器可能变得非常复杂。我们刚刚设置的触发器只是冰山一角。如果这些触发器看起来令人生畏，请不要担心，外面有大量文档可以帮助你设置它们，你可以在这里找到：www.zabbix.com/documentation/current/en/manual/config/triggers。

在本书中几乎不可能覆盖所有的使用案例，所以我们设置的触发器将向你展示什么是可能的。将你在示例中学到的内容应用到你自己的场景中，但确保加入你自己的思考。

高级触发器 1 – trendavg 函数

让我们从工作原理…部分开始，介绍趋势平均。趋势平均是少数几个使用趋势数据而不是历史数据的触发器函数之一。让我们简要了解一下 Zabbix 中的历史数据和趋势数据。历史数据是每次项目从被监控主机接收数据时的确切值。趋势数据是从历史数据中创建的一个小时内的平均值、最小值和最大值，以及值的计数。

现在，让我们来看一下使用趋势数据创建触发器的可用函数：

trendavg：获取在时间段内趋势值的平均值
trendmax：获取在时间段内趋势值的最大值
trendmin：获取在时间段内趋势值的最小值
trendcount：获取在时间段内检索到的趋势值的数量
trendsum：获取一段时间内趋势值的总和

正如我所说，所有这些都将使用我们的趋势值。使用的值存储在内存中的特殊 Zabbix 趋势缓存中，用于触发器中。我们已经使用了 trendavg 函数。让我们再次查看我们在触发器表达式中是如何使用它的：

图 4.19 – trendavg 触发器表达式

我们以 trendavg 函数开始触发器，然后是之前在上一节中看到的 主机/模板 和 项目键。这里的新内容是我们声明 1w:now-1w 的部分。这是时间段；在这里，我们声明使用一周前的值。

这意味着，如果我们一周前的趋势平均值超过 800 Mbps，那么此触发器将进入问题状态。

高级触发器 2 – timeleft 函数

timeleft 是另一个非常有趣的触发器函数。我们可以使用 timeleft 创建仅在预计某个东西将来达到某个阈值时触发的触发器。这被称为预测触发器，因为它是基于旧数据做出的预测。

让我们再次检查我们的触发器表达式。

图 4.20 – timeleft 触发器表达式

正如我们所见，我们像往常一样开始表达式：触发器函数、主机/模板 和 项目键。在这种情况下，我们将其与用于预测触发器的时间段结合，定义其预测。我们使用了 7h，告知该表达式使用七小时的历史数据。再加上 100 的阈值，确保如果预计达到 100% 的磁盘空间使用率时会触发。现在，我们只需要一个元素来完成它，即预期结果，在这种情况下是 <1w。

总结一下，这个触发器表达式查看了 七小时 的历史数据，如果预计在 不到一周 内达到 100% 的磁盘空间，它将进入问题状态，并提醒你确保磁盘不会用完空间。

使用 timeleft 触发器函数与其他函数结合，限制触发警报的次数。例如，对于磁盘空间，我们可能预计磁盘将在一周内填满，但你可能不想看到除非已用空间至少少于 50 GB。再添加一个表达式，你就大功告成：

图 4.21 – timeleft 触发器函数表达式

高级触发器 3 – 使用数学函数的时间偏移

作为 Zabbix 培训师，时间偏移触发器表达式是我和我的学生总是需要额外花时间理解它们具体作用的地方。这是有道理的，因为它是更复杂的表达式之一，在这个例子中，我们甚至将其与一些数学函数结合使用。

那么，让我们再看一下我们的表达式并进行拆解。

图 4.22 – 时间偏移触发表达式

我们为了方便添加了行号。现在我们可以逐行解释每一行的含义：

这是我们数学语句的开括号，使用两个项目之间的运算符。
我们的第一个项目，使用时间偏移函数。此项目将从此时刻开始获取一周前某一时刻的内存可用百分比。如果当前日期和时间是 11 月 24 日星期一下午 14:00，它将获取 11 月 17 日星期一 13:00 到 14:00 的一小时平均值。
我们的数学运算符，表示减号。这意味着我们将从第一个表达式的结果中减去第二个表达式的结果。
这是我们的第二个项目，不使用时间偏移。此项目将填充上一小时的一小时平均值。
结尾括号结束我们的数学语句。
最后，一个运算符和常数。这说明此触发器仅在数学结果高于 20 时触发。

现在我们知道每一行的作用，让我们看看它在实际场景中的运作方式。我们将手动填写数值并查看表达式是否为TRUE或FALSE。TRUE表示存在问题，而FALSE表示一切正常。因此，数学运算如下：

(Last week - This week) = Result
If the Result is higher than 20 then the expression is True
This expression is: TRUE/FALSE

上周有 80% 的内存可用，而本周仅剩下 50%，我们可以看到以下情况发生：

(80 - 50) = 30
If 30 is higher than 20 the expression is TRUE
This expression is TRUE

让我们再来一次，但上周有 80% 的内存可用，而本周有 70%：

(80 - 70) = 10
If 10 is higher than 20 the expression is TRUE
This expression is FALSE

这是您应该设置时间偏移表达式的方法。只需使用笔记本或您喜欢的任何工具，在简单文本中写下表达式，然后进行计算。

还有更多内容……

触发表达式也可以在 Zabbix 内部进行测试。如果我们转到数据收集 | 主机 | 触发器，然后选择任何三个高级触发器中的一个，我们可以进行简单测试。例如，使用时间偏移触发器，我们可以点击表达式构造器。

图 4.23 – 时间偏移触发表达式构造器

在这里，我们可以选择测试，然后填写我们的值。让我们使用与前面示例中相同的 80% 和 50%：

图 4.24 – 时间偏移触发表达式构造器 – 测试

如您所见，这将告诉我们我们的表达式最终是否为TRUE或FALSE，使用我们希望填充的任何值。简而言之，如果您希望确保您的纸上数学与 Zabbix 中直接执行的操作相同，请使用表达式构造器进行测试。

设置警报

警报可以是 Zabbix 设置中非常重要的一部分。当设置警报时，我们希望接收方了解到正在发生的情况。同时，不要向某人发送大量警报；我们希望它是有效的。

所以，在这个食谱中，我们将介绍设置告警的基础知识，让我们从一开始就知道如何正确设置。

准备工作

对于这个食谱，我们只需要两样东西。我们将使用我们的 Zabbix 服务器来创建告警，并且我们将需要一些触发器，像是前一个食谱中的触发器。这些触发器将用于启动告警过程，看看 Zabbix 服务器如何传递这些信息。

如何操作…

让我们从在 Zabbix 前端设置我们的操作开始。为此，我们将导航到告警 | 操作 | 触发器操作，然后我们将看到这个屏幕：

图 4.25 – Zabbix 触发器操作页面，带有一个触发器操作

已经设置了一个操作来通知Zabbix 管理员组有关问题事件。在 Zabbix 7 中，很多功能，如操作和媒介，都是预定义的。通常，我们只需要启用它们并填写一些信息。

我们将设置我们自己的操作，因此让我们创建一个新的操作来通知Zabbix 管理员组的用户我们的新触发器。点击蓝色的创建操作按钮，进入下一页面：

图 4.26 – Zabbix 操作创建页面 – 通知书籍阅读者

在此页面上，选中启用复选框，以确保此操作确实会生效。确保清晰地命名你的操作，以便不会在区分操作时遇到问题。
现在，转到操作标签页：

图 4.27 – Zabbix 操作创建页面（操作标签页）– 通知书籍阅读者

操作标签页默认是空的，因此我们需要在这里创建一些操作。我们将创建三种操作形式——让我们通过点击添加来开始创建操作操作：

图 4.28 – Zabbix 操作详情页面 – 通知书籍阅读者

我们可以在此处添加用户和/或用户组，来接收告警。如果你已经跟随第一章，“安装 Zabbix 并开始使用前端”，你可以直接选择网络用户组。如果没有，选择仅Zabbix 管理员组也可以。
在表单底部点击蓝色的添加按钮后，我们将返回到操作屏幕。
现在，我们将创建下一个操作，命名为恢复操作。我们在这里创建一个操作，如下所示：

图 4.29 – Zabbix 恢复操作详情 – 通知书籍阅读者

这个选项将通知所有参与之前定义的初始操作的用户。所有收到问题生成通知的用户也会以这种方式收到恢复通知。点击添加，然后继续。

如果你像我一样，想随时掌握情况，可以创建一个更新通知。这样，我们就知道——例如——某人已确认问题并正在处理它。通常，我会为这种事情选择不同的渠道——例如，使用短信来处理高优先级的警报，其他事情则使用 Slack 或 Teams 渠道。
让我们点击添加，在更新操作下将以下内容添加到我们的设置中：

图 4.30 – Zabbix 更新操作详情 – 通知书籍阅读者

我们将按照在恢复操作选项中的设置做同样的事情，通知所有参与的用户关于此问题的任何更新。点击添加后，再次点击操作界面中的蓝色添加按钮，完成创建操作。
现在，我们想做的下一件事是创建一种媒体类型，用于实际通知我们的用户问题。进入警报 | 媒体类型，你将看到以下界面：

图 4.31 – 带有预定义媒体选项的 Zabbix 媒体类型页面

如你所见，Zabbix 7 中有相当多的预定义媒体类型。我们有 Slack、Opsgenie，甚至 Telegram 的类型。不过，让我们从几乎每个人都有的东西开始：电子邮件。

点击电子邮件媒体类型，我们将编辑它以满足我们的需求：

图 4.32 – 用于电子邮件的 Zabbix 媒体类型创建页面

我将其设置为反映我的 Office 365 设置，但任何简单邮件传输协议（SMTP）服务器都应能正常工作。填写你的 SMTP 设置，我们就应该能够接收通知。
一定要查看下一个标签页，消息模板。例如，问题生成事件的消息模板如下所示：

图 4.33 – Zabbix 问题的默认消息模板页面

我们这样设置是为了让我们收到一条告诉我们发生了什么的消息。这也是完全可定制的，可以反映我们想知道的具体内容。

现在我们保持默认设置。最后，进入用户 | 用户，编辑Zabbix 管理员或网络组中的一个用户。我将以Admin用户为例。

图 4.34 – Admin 用户的 Zabbix 用户媒体页面

在此窗口中，转到媒体并点击添加按钮。我们希望添加以下内容，以便在我们的电子邮件地址接收所有触发器严重性的通知：

图 4.35 – Zabbix 管理员用户的媒体创建页面

现在，点击蓝色的添加按钮，完成创建该用户的媒体。

它是如何工作的…

现在，这就是我们在 Zabbix 中设置警报的方式。你将会收到发送到你电子邮件地址的警报，如下图所示的流程图：

图 4.36 – 展示 Zabbix 问题流程的图示

当某个问题发生时，Zabbix 中的问题会通过我们的触发器配置被触发。接着，操作会通过问题事件被触发，并使用媒体类型和用户媒体配置通知我们的用户。我们的用户随后解决了问题（例如，重启卡住的服务器），然后会生成一个OK事件。之后，我们会再次触发操作，并收到一个 OK 消息。

提示

在构建类似的警报之前，为自己创建一个工作流程（如图 4.36所示），明确哪些用户组和用户应该被通知。这样，你就能清楚地知道如何使用 Zabbix 进行警报。

还有更多…

有许多种媒体类型和集成方式，我们刚刚仅仅触及了冰山一角，看到了一些预定义的选项。请确保查看 Zabbix 集成列表（www.zabbix.com/integrations）以获得更多选项，或者使用 Zabbix 的 Webhook 和其他可用的扩展来构建你自己的集成。

保持警报有效

保持警报有效非常重要，以确保我们不会因为通知而感到过于困扰，也不会因为缺少通知而感到失落。为此，我们将更改触发器和电子邮件媒体类型，只显示我们需要看到的内容。

准备工作

我们将使用来自第一个配方的触发器 1 和 Zabbix 中的默认电子邮件媒体类型。

当然，我们还将使用我们的 Zabbix 服务器。

如何操作…

要创建有效的警报，请按照以下步骤操作：

让我们开始设置触发器 1，这个触发器是在本章的设置触发器配方中创建的。通过进入数据采集 | 主机，并点击该主机的触发器，来导航到lar-agent-simple主机。
在这里，有时人们会使用不同的触发器名称，就像我们看到的这个：

图 4.37 – 来自上一配方的触发器 1

即使你在触发器中使用了{HOST.NAME}宏，这也很简单，因此幸运的是这里无需做很多更改。如果你在触发器名称中使用了主机名，我们可以更改名称，以便传达更清晰的信息。

确保使用简洁且具有描述性的触发器名称，例如以下内容：

图 4.38 – 新的触发器 1 名称

接下来，导航到标签页面，添加一个标签以保持触发器有序。我们来添加以下内容：

图 4.39 – 触发器 1 标签

另一种保持一切有序的好方法是更改媒体类型上的消息。让我们更改媒体类型以反映我们的需求。导航到警报 | 媒体类型 并选择名为 电子邮件 的媒体类型。
选择消息模板并点击我们第一个问题旁边的编辑。这将把我们带到以下窗口：

图 4.40 – 标准电子邮件媒体类型消息

目前，当我们不使用自定义消息时，Zabbix 使用媒体类型下默认配置的消息。但如果我们想要更改该消息，可以通过创建自定义消息来实现。电子邮件媒体类型下的默认消息如前面的截图所示。

我们可以更改媒体类型上的消息。例如，如果您不想看到原始问题 ID 或者需要更自定义的消息，只需删除该行，如以下截图所示：

图 4.41 – 自定义电子邮件媒体类型消息

它是如何工作的…

在这个例子中，我们做了两件事：更改了触发器名称并向触发器添加了一个标签。

保持触发器名称简洁明了并以结构化的方式定义是保持 Zabbix 环境有序的重要因素。我们不仅仅把触发器命名为 Port 22 SSH down on {HOST.NAME}，而是对我们的设置进行了标准化，现在我们可以创建像这样的酷结构，应用到未来的触发器：

图 4.42 – 触发器结构图

我们的触发器都很清晰，能够立刻看到哪个主机、端口和服务出现问题。

此外，我们还为出现故障的服务添加了标签，这样它现在会立即以清晰的方式显示我们的服务，提醒我们到底发生了什么：

图 4.43 – 触发器关闭 – 结构化

在 Zabbix 6 中，引入了一种新的标签策略。我们在触发器中创建的项使用了 availability（可用性）、performance（性能）、notification（通知）、security（安全性）和 capacity（容量）标签。

要了解更多关于 Zabbix 7 中仍在使用的新 Zabbix 标签策略，请查看这个链接：

blog.zabbix.com/tags-in-zabbix-6-0-lts-usage-subfilters-and-guidelines/19565/

我们做的另一件事是移除了 {HOST.NAME} 宏（如果之前使用过的话）。因为我们已经可以通过查看 {HOST.NAME} 宏来确认触发器所在的主机。我们需要保持触发器名称简短有效，并在媒体中使用主机名宏，或者简单地使用前端已有的字段。

我们还改变了本节中的操作。更改媒体类型的消息是一种强有力的方式，可以保持我们的问题频道结构化。有时，我们希望在某些频道上看到更多或更少的信息，而更改媒体类型消息正是实现这一目标的一种方法。

我们还可以在操作级别创建自定义消息，更改发送到选定频道的所有消息。

还有更多内容…

我在本节中想向你展示的是，虽然设置 Zabbix 可能很简单，但如果没有计划，建立一个良好的监控解决方案并不简单——无论使用什么监控工具，都是如此。在你在 Zabbix 安装中构建一切之前，仔细规划触发器的结构非常重要。

一位以结构化方式工作的工程师，并花时间构建一个良好的监控解决方案，未来将节省大量时间，因为他们在其他人之前就能理解问题。

自定义警报

警报非常有用，特别是与我们在本书中学到的一些技巧结合使用，可以保持一切结构化。但有时，我们需要从警报中获得更多信息，而不仅仅是 Zabbix 默认提供的内容。

在本节中，我们将进行一些小的自定义，使警报更加符合我们的需求。

准备工作

对于本节，我们只需要当前的 Zabbix 服务器安装。

如何操作…

要自定义警报，请按照以下步骤操作：

让我们在 Zabbix 服务器中创建一些自定义严重性级别，以便更好地反映我们组织的需求。导航至管理 | 常规，然后从侧边菜单中选择触发器显示选项：

图 4.44 – 管理 | 从侧边菜单的常规选项

选择此选项后，我们将进入下一页。此窗口包含默认的 Zabbix 触发器严重性，如下图所示：

图 4.45 – 默认触发器严重性页面

接下来，我们可以按以下方式自定义默认的触发器严重性：

图 4.46 – 自定义触发器严重性页面

别忘了点击页面底部的蓝色更新按钮以保存更改。

它是如何工作的…

不是所有公司都喜欢使用高和灾难等术语，而是更倾向于使用不同的严重性级别，例如P1和P2。通过使用自定义严重性级别，我们可以定制 Zabbix，使其更符合我们的需求，并反映我们在不同工具中已经使用的术语，例如。

更改自定义严重性级别绝非必要，但如果你习惯了不同的方式，它可能是更轻松采用 Zabbix 的好方法。

第五章：5

构建您自己的结构化模板

现在是开始 Zabbix 中最重要任务之一的时候：构建结构化模板。一个好的 Zabbix 设置非常依赖模板，良好的模板和差的模板之间差异巨大。所以，如果你是 Zabbix 新手，或者还没有开始构建自己的模板，那么请密切关注本章内容。

在本章中，我们将讲解如何设置你的模板，以及如何填充正确的项和触发器。此外，正确使用宏和低级发现（LLD）非常重要。在遵循这些配方后，你将完全准备好构建格式正确、甚至支持 LLD 的扎实 Zabbix 模板。

在本章中，我们将涵盖以下内容：

创建你的 Zabbix 模板
设置模板级标签
创建模板项
创建模板触发器
设置不同类型的宏
在模板中使用 LLD
嵌套 Zabbix 模板

技术要求

我们将需要在第四章中学习的工作与触发器和警报部分，来监控我们的简单网络管理协议（SNMP）主机。对于 SNMP 主机，我们可以使用在第三章的设置 Zabbix 监控部分中设置的主机。

创建你的 Zabbix 模板

在本配方中，我们将从创建 Zabbix 模板的基础开始。我们将探讨 Zabbix 模板的结构，并解释为什么我们需要关注模板中的某些方面。

准备就绪

本配方中所需的一切只是你的 Zabbix 服务器。

如何操作……

现在，让我们开始构建我们的结构化 Zabbix 模板：

打开你的 Zabbix 前端并导航到数据收集 | 模板。
在此页面，点击右上角的创建模板按钮。这将带你进入以下页面：

图 5.1 – 空的创建模板页面

此时，我们需要为我们的模板命名并为其分配一个模板组。我们将创建一个 SNMP 模板来监控 Linux 主机。我将在示例中使用 SNMP 来展示模板的结构。

重要提示

使用 SNMP 来监控网络设备、支持 SNMP 的自定义设备等。SNMP 非常多功能且容易理解，很多硬件厂商都已实现 SNMP。对于 Linux 主机，我仍然推荐使用功能强大的 Zabbix 代理，我们在第三章的设置 Zabbix 代理监控配方中进行了讲解。

使用以下信息创建你的模板：

图 5.2 – 填充了 SNMP 模板信息的创建模板页面

我们暂时不会链接任何模板、标签和宏，但稍后我们会讨论这些功能。到目前为止，创建模板所需的仅仅是一个名称、组和描述，其他什么也没有。

它是如何工作的……

创建我们第一个模板并不涉及很多工作——它非常简单。我们需要记住的是，这里正确的命名约定。

现在，你可能会问自己：为什么模板命名如此重要？ 嗯，我们在使用 Zabbix 时会创建大量模板。例如，这是一个开箱即用模板的列表的一小部分：

图 5.3 – 一些开箱即用的模板

如你所见，这已经是一个很大的列表，所有这些模板都遵循一个简单明了的命名约定。如果你查看我们刚刚自己创建的模板名称和例如内置的 Apache 模板，它们遵循相同的约定。拆解这个约定，它看起来是这样的：

图 5.4 – 模板命名约定说明

如果我们查看这个列表并将其与图 5.4中我们讨论的命名约定进行比较，我们可以看到以下模式：

我们在监控什么？：（Linux）我们为模板命名——在这种情况下，我们将其命名为 Linux，因为我们监控的操作系统是 Linux。
监控类型：（通过 SNMP）我们将在模板的末尾添加数据收集方法，因为我们可能通过除 SNMP 以外的其他方式监控 Linux 操作系统，例如使用 Zabbix 代理。

遵循此命名约定中的指导方针并使用正确的模板名称，是我们创建正确模板结构的第一步。这使得我们可以轻松地找出要在哪些主机上使用哪些模板。

在我们的例子中，我们还添加了一个简短的自定义前缀，以确保我们能够将我们的模板与 Zabbix 设置中已经创建的其他模板区分开来。通常，我们可以省略这个前缀，但在本书中它很有用。作为最佳实践，建议克隆你希望使用的默认模板，并在模板名称前加上公司名称或简称。我们这样做是为了不覆盖默认模板，并确保以后可以导入官方模板而不会覆盖我们所做的任何修改。例如，我会克隆Linux by SNMP并将其命名为OICTS Linux by SNMP，以便在我们公司——开源 ICT 解决方案中使用。在托管服务提供商（MSP）环境中，这种做法同样有效，我们希望为每个客户拥有一个独特的模板。

还有更多……

在构建模板时，请遵循 Zabbix 指南。这也是我们在本书中所做的，结合我们在创建模板方面的经验。如果您想了解更多关于 Zabbix 模板指南的信息，请查看以下 URL：www.zabbix.com/documentation/guidelines/en/thosts。

设置模板级标签

设置 Zabbix 模板的下一步是设置模板级标签。模板级标签用于为由此模板在主机上创建的每个事件（问题）分配一个标签。然后，这些标签可用于在仪表板、操作以及监控 | 问题视图中筛选事件。

准备工作

要开始这个食谱，您需要一个 Zabbix 服务器和该服务器上的模板，最好是我们在上一个食谱中创建的模板。

如何操作……

创建模板级标签是确保仅由某个特定模板创建的事件才会获得已配置标签的一种方式。首先，您需要做的是导航到模板并按照以下步骤进行操作：

转到 数据收集 | 模板，然后点击我们的模板，它叫做 Custom Linux by SNMP。
然后，点击表单顶部的标签标签，您将被带到此标签页：

图 5.5 – SNMP 模板的 Zabbix 标签标签页

现在，我们可以做的第一件事是创建一些标签，以确保我们知道所有来自此模板的事件都将与 Linux 相关。

第一个标签已经准备好创建了。填写名称为 class，然后在值字段中输入 os。
对于第二个标签，点击小的带点下划线的添加按钮，并将第二个标签的名称设置为 target。然后，在值字段中输入 linux。它看起来会是这样：

图 5.6 – 已填写 SNMP 模板的 Zabbix 标签标签页

别忘了点击蓝色的更新按钮，将标签保存到此模板中。

它是如何工作的……

现在，创建标签比按照本食谱步骤看起来要复杂得多。标签在保持 Zabbix 环境结构化方面起着关键作用。您将使用模板级标签在很多地方进行筛选，例如监控 | 问题窗口，在一个主机创建的许多事件中，它们将通过使问题容易筛选来提高可读性。

例如，一旦我们在本食谱中稍后配置了一些触发器，当检查我们主机的监控 | 问题页面时，我们可能会看到如下内容：

图 5.7 – 主机 lar-book-agent_snmp 的示例监控 | 问题页面

关于截图的说明

本书中使用的一些截图已调整以适应书页的边距，导致印刷版中的文本可读性降低。请参考此处提供的 PDF 版本：packt.link/free-ebook/978-1-80107-832-0，放大图像并更清晰地查看文本。

如你所见，我们在这里看到的问题是页面底部显示target:linux和class:os标签。该事件已使用模板级标签进行标记，现在我们可以看到它将始终携带该标签，允许我们进行过滤。

这为我们提供了很多机会，因为我们不再仅限于模板级标签。我们还有主机级标签、项级标签和触发器级标签。我们可以用 department:architecture 标记模板中的所有内容。

然后，我们可以例如创建一个操作，将所有与 Linux 相关的信息发送到某个特定的 Linux 工程邮箱地址或 Teams/Slack 频道，并根据 department:architecture 将信息发送到更具体的邮箱地址或 Teams/Slack 频道。

要了解 Zabbix 6 版本起的标签策略，请查看以下链接：

blog.zabbix.com/tags-in-zabbix-6-0-lts-usage-subfilters-and-guidelines/19565/

另见

在本章中，名为在模板中使用 LLD的教程还将解释标签原型，我们将在此基础上根据 LLD 设置自动创建标签。标签原型是创建发现时使用标签的推荐方法，并且非常适合保持模板结构化。稍后会详细介绍。

创建模板项

让我们开始最终创建一些真正的模板项，因为最终在 Zabbix 中，模板项才是核心。没有模板项，我们就没有数据，而没有数据，我们在监控系统中就没有任何东西可操作。

准备中

接下来，我们需要 Zabbix 服务器和一个可以用 SNMP 监控的主机。在第三章，设置 Zabbix 监控中，我们用 SNMP 监控了一台主机，所以我们将再次使用这台主机。我们还将使用之前教程中的 Zabbix 模板。

如何操作……

首先，让我们登录到 Zabbix 服务器的命令行界面（CLI），并输入snmpwalk，使用以下命令：
```
10.16.16.153 to your own value. We will receive an answer such as this:
```

图 5.8 – snmpwalk 回复

现在，让我们首先在模板中捕获主机名，因为这是一个重要的项。在处理 SNMP 时，我总是喜欢使用未翻译的 SNMP .1.3.6.1.2.1.1.5.0。

如果我们有管理信息库（MIB），我们可以转换此 OID 来确保它确实是系统名称。请在 Zabbix 服务器的 CLI 中输入以下命令：
```
snmptranslate .1.3.6.1.2.1.1.5.0
```
这将返回以下回复：

图 5.9 – snmptranslate 回复

提示

在你的 SNMP 命令中使用 -On 确保我们接收到的是 OID，而不是 MIB 翻译。如果我们想要反向操作，可以在命令中省略 -On，然后使用 snmptranslate 翻译后的 OID。

现在我们知道如何获取主机名，将其添加到我们的模板中。导航至 数据收集 | 模板，并选择我们的 自定义 Linux 通过 SNMP 模板。
在这里，我们将进入项目。在右上角选择 创建项目，然后创建以下项目：

图 5.10 – sysName SNMP OID 项目

确保还要添加项目级别的标签。这些标签对项目分组和筛选非常重要。点击标签选项卡并添加以下内容：

图 5.11 – sysName SNMP OID 项目（标签选项卡）

现在我们有了第一个项目，让我们也创建一个主机并将模板分配给该主机。

导航至 数据收集 | 主机，然后点击右上角的 创建主机。使用以下设置创建一个主机：

图 5.12 – 使用我们自创建模板的新主机

不要忘记在点击添加按钮之前，将宏添加到我们的新主机。点击宏并填写以下信息：

图 5.13 – 在主机上添加宏选项卡

不要忘记将宏设置为“秘密文本”类型，以便在前端隐藏密码。

现在，你可以点击添加按钮，我们的新主机将开始被监控。

它是如何工作的…

当我们在模板中创建类似的项目时，将模板分配给主机时，该项目也会在主机上创建。这样做的好处是，我们可以将模板分配给多个主机，这意味着我们只需要在模板级别配置一次项目，而无需在每个主机上都创建该项目。例如，我们新创建的主机将显示以下最新数据：

图 5.14 – 监控 | 我们新主机的最新数据

这个项目的值会根据每个受监控主机接收到的值而不同。

重要说明

创建 SNMP 项目时，请记住以下几点。项目字段中的 SNMP OID 始终包含未翻译的 OID。这是为了确保我们不需要 MIB 文件，模板就能正常工作。

此外，项目键将基于翻译后的 OID。在我们的例子中，翻译后的 OID 是 sysName，我们将其转化为 sysName 项目键。这些是我们在创建模板时应该遵循的通用规则，以确保每个人的模板结构一致。

另见

要了解更多关于 Zabbix 和 SNMP OID/MIB 的信息，请查看这篇博客文章：

blog.zabbix.com/zabbix-snmp-what-you-need-to-know-and-how-to-configure-it/10345/#snmp-oid

创建模板触发器

创建模板触发器的方式与创建模板项目或普通触发器大致相同。让我们回顾一下这个过程，看看我们是如何操作的，以及如何保持结构化。

准备工作

我们需要前一个配方中的 Zabbix 服务器和主机来完成这个配方。

如何操作……

到目前为止，我们在模板上配置了一个项目，现在让我们为该项目创建一个触发器：

在 Zabbix 前端导航到 数据采集 | 模板，然后选择我们的 Custom Linux by SNMP 模板。
现在，点击 触发器，然后点击右上角的 创建触发器。这将带我们进入下一页，在这里我们将输入以下信息：

图 5.15 – 为 SNMP 模板创建触发器窗口

如前一章所讨论，对于触发器，我们还需要添加 作用域 标签：

图 5.16 – 为 SNMP 模板创建触发器窗口 – 标签

最后但同样重要的是，让我们编辑主机的主机名，看看触发器是否正常工作。通过在 Linux 主机的 CLI 上执行以下命令来更改主机名：
```
hostnamectl set-hostname lar-book-agent-t
```
然后，确保更改生效，通过执行以下命令：
```
exec bash
systemctl restart snmpd
```

它是如何工作的……

编辑模板时，创建的触发器将立即添加到我们名为 lar-book-templated_snmp 的主机上。这是因为当我们编辑模板时，主机已经配置了该模板。我们更改了主机名后，触发器可以在再次轮询该项目后立即触发：

图 5.17 – 主机名已更改的触发器，针对主机 lar-book-templated_snmp

因为我们在触发器中使用了change函数，当我们第二次轮询这个项目时，问题会自动消失。在我们的案例中，这将在 30 分钟后发生。

重要提示

像许多其他 Zabbix 用户一样，我总喜欢在触发器名称中使用{HOST.NAME}宏，但根据 Zabbix 的指南，不推荐这样做。如果你更喜欢这种方式，你仍然可以使用它，但使用 Zabbix 前端中的主机字段和内置的通知宏更有用。这样可以使触发器名称简洁，并且不会显示冗余信息。

设置不同种类的宏

当我们使用模板时，使模板更有用的一个非常有效的方法是使用宏。在这个配方中，我们将学习如何使用宏来实现这一点。

准备工作

我们需要之前配好的 Zabbix 服务器和 SNMP 监控的主机。还需要我们在前面的食谱中创建的 Zabbix 模板。

如何操作…

现在，让我们从在模板级别创建一些宏开始。我们将创建两种不同类型的宏。

定义用户宏

首先，我们将在我们的模板上定义一个用户宏。导航到 数据收集 | 模板并点击我们的 Custom Linux by SNMP 模板。
在这里，我们将进入宏并填写以下字段：

图 5.18 – 模板级别的宏

点击更新，然后让我们转到 触发器 来定义一个新触发器：

图 5.19 – SNMP 模板的触发器创建窗口

让我们也添加触发器标签：

图 5.20 – SNMP 模板的触发器创建窗口标签选项卡

现在，通过在主机 CLI 上执行以下命令，修改主机名条目：
```
hostnamectl set-hostname dev-book-agent
```
然后，确保通过执行以下命令使更改生效：
```
exec bash
systemctl restart snmpd
```
我们的触发器应该会触发，如下图所示：

图 5.21 – 针对 lar-book-templated_snmp 主机的主机名前缀创建的触发器问题

使用内置宏

现在，让我们来定义一个内置宏在我们的模板上。导航到 数据收集 | 模板并点击我们的 Custom Linux by SNMP 模板。
现在，点击 触发器，在右上角点击 创建触发器。使用以下设置创建一个触发器：

图 5.22 – 主机名匹配的触发器创建窗口

让我们也添加触发器标签：

图 5.23 – SNMP 模板的触发器创建窗口 – 标签

这将按预期触发一个问题。

图 5.24 – 主机名不匹配的触发器创建问题

它是如何工作的…

有四种类型的宏：内置宏、用户宏、表达式宏和 LLD 宏。所有这些宏都可以在模板上使用，但也可以直接在主机和其他各种位置使用。宏对于在本应包含静态信息的地方创建唯一值非常有用。

让我们来探索它们是如何工作的。

用户宏的工作原理

因为我们希望此模板下的所有主机的前缀都包含 lar，所以我们在模板级别创建一个用户宏。这样，每个使用此模板的主机上的用户宏将是相同的。

然后，我们在触发器中定义我们的用户宏来使用该值，在这个例子中是lar-。我们可以在其他触发器、项目等中重用这个用户宏。好处是，定义模板级别的用户宏并不是我们能做的全部。我们可以通过定义主机级的用户宏来覆盖模板级的用户宏。因此，如果我们希望某台主机包含不同的前缀，只需使用主机级宏来覆盖模板级宏，像这样：

图 5.25 – 主机级宏页面

如果我们查看主机上继承的和主机级的宏屏幕，我们会看到以下内容：

图 5.26 – 继承和主机级宏页面

我们看到有效值现在是dev-，而不是lar-，这正是我们预期的结果。

请记住，语法总是以花括号和美元符号开始，并以花括号结束。您可以使用点号或下划线来分隔其中的文本。以下是一些示例：

{$****MACRONAME}
{$****MACRO.NAME}
{$****MACRO_NAME}

内置宏的工作原理

现在，内置宏来自 Zabbix 中预定义的宏列表，这些宏是硬编码的。它们用于从您的 Zabbix 系统中获取数据并将其放入项目、触发器等中。这意味着，在这种情况下使用的内置宏已经包含了一个值。

在这种情况下，我们使用了{HOST.HOST}，这是我们在 Zabbix 主机上定义的主机名，像这样：

图 5.27 – Zabbix 主机配置页面，主机 lar-book-templated_snmp

对于每一台主机，这个内置宏都会不同，因为我们的主机名值是唯一的。这意味着，虽然触发器在模板级别定义，但它总是唯一的。这种方法是使用内置宏在触发器中非常强大的一种方式，因为我们会直接从 Zabbix 中获取信息，再次将其导入 Zabbix。

请记住，语法总是以花括号开始并以花括号结束。您可以使用点号或下划线来分隔其中的文本。以下是一些示例：

{****HOST.NAME}
{****INVENTORY.LOCATION.LAT}

还有更多……

完整的支持（内置）宏列表可以在这里找到：

www.zabbix.com/documentation/current/zh/manual/appendix/macros/supported_by_location

这个列表会由 Zabbix 更新，就像每一篇好的 Zabbix 文档页面一样。这样，您可以始终使用此页面作为构建 Zabbix 元素时最新（内置）宏的参考。

在模板上使用 LLD

现在，让我们开始我最喜欢的模板创建部分：LLD。我认为这是 Zabbix 中最强大且最广泛使用的部分之一。

准备开始

为了准备这个配方，您需要 Zabbix 服务器、前面配方中的 SNMP 监控主机以及我们之前的模板。

还建议具备一定的 SNMP 树结构的工作知识。因此，请确保仔细阅读第三章中有关与 SNMP 监控配合使用的配方，Zabbix 监控的设置。

如何操作……

让我们通过进入数据收集|模板并选择我们的自定义 Linux 通过 SNMP模板来开始。

重要说明

首先，我们将添加一个值映射，供多个项原型使用。请记住，自 Zabbix 6 以来，值映射不再是全局的，而是模板或主机特定的。这是为了确保模板和主机（导出后）能够更独立于全局的 Zabbix 设置。

点击值映射选项卡和虚线的添加按钮。然后添加以下内容：

图 5.28 – Zabbix 添加值映射页面

确保通过点击蓝色的添加按钮，然后点击蓝色的更新按钮来保存此更改。
现在，返回到模板并转到发现规则，然后在右上角点击创建发现规则。这将带您到 LLD 创建页面：

图 5.29 – Zabbix LLD 创建页面，空白

现在，我们将创建一个发现规则来发现 Linux 主机上的接口。Linux 接口的 SNMP 树位于 OID .1.3.6.1.2.1.2。

重要说明

确保 Linux 的net-snmp在/etc/snmp/snmpd.conf文件中已正确配置。重要的是要在此文件中将视图更改为显示从.1开始的所有内容，像这样：view systemview included .1

现在，让我们继续创建我们的 LLD 规则，通过在 LLD 创建页面中添加以下内容：

图 5.30 – Zabbix LLD 创建页面，已填写我们的网络接口发现信息

点击添加按钮后，我们可以返回到模板，在数据收集|模板中点击自定义 Linux 通过 SNMP。

重要说明

我们将删除丢失的资源定义为立即执行；这样做是因为这是一个测试模板。此选项由 LLD 用于删除已创建的资源（如项和触发器），如果它们不再出现在我们监控的主机上。使用立即可能导致数据丢失，因为我们可能在一定时间内重新获得某个资源，因此请确保根据生产环境的标准调整此值。

转到发现规则并点击我们新创建的规则，发现 网络接口。
现在，转到 项目原型 并点击右上角的 创建项目原型。这将打开 项目原型 创建弹窗，如下图所示：

图 5.31 – Zabbix LLD 项目原型创建页面，空白

在这里，我们将创建我们的第一个项目原型，用于从 LLD 创建项目。这意味着我们需要将其填充为我们希望项目包含的信息。

让我们从为接口操作状态填写一个项目原型开始，像这样：

图 5.32 – Zabbix LLD 项目原型创建页面，已填充我们的接口操作状态信息

在标签选项卡中，确保也添加一个标签原型，如下所示：

图 5.33 – Zabbix LLD 项目原型标签创建选项卡

提示

在下一步中，我们将创建一个与我们刚刚创建的项目非常相似的项目。使用克隆按钮而不是从头开始填写整个表单非常有用。

点击添加按钮后，让我们重复这个过程，并添加以下项目原型：

图 5.34 – Zabbix LLD 项目原型创建页面，已填充我们的接口管理员状态信息

不要忘记标签选项卡：

图 5.35 – Zabbix LLD 项目 2 原型标签创建选项卡

现在，转到 触发器原型 页面，点击右上角的 创建触发器 原型按钮，并创建以下触发器：

图 5.36 – Zabbix LLD 触发器原型创建页面，已填充我们的接口链路状态信息

最后但同样重要的是，添加触发器标签：

图 5.37 – Zabbix LLD 触发器原型创建页面标签选项卡

它是如何工作的…

LLD 是 Zabbix 中一个相当广泛的主题，但通过按照本指南中的步骤，你应该能够将你在这里学到的知识应用到几乎所有需要配置的 Zabbix LLD 类型。首先，让我们看看发现是如何工作的。

在发现规则中，我们刚刚配置了以下内容：

图 5.38 – Zabbix LLD 发现密钥和 OID，键 net.if.discovery

提示

Zabbix LLD 通过使用特定的 JSON 格式工作。在创建发现规则时，我们可以始终转到主机级别的发现规则，并使用测试按钮。这样就可以显示 Zabbix 使用的 JSON 格式。

我们基本上在这里说的是，对于 OID .1.3.6.1.2.1.2.2.1.2 后的每个接口，我们都填充 {#IFNAME} LLD 宏。在我们的案例中，我们将最终得到以下 OID：

.1.3.6.1.2.1.2.2.1.2.1 = STRING: lo
.1.3.6.1.2.1.2.2.1.2.2 = STRING: ens192

因此，我们将这些保存下来以供我们的原型使用。现在，当我们查看我们对 操作状态 原型所做的更改时，一切都结合在一起了：

图 5.39 – Zabbix LLD 项目原型的名称、类型、键和 OID

我们告诉我们的项目原型，为每个 {#IFNAME} 值创建一个项，使用已定义的键和 {#SNMPINDEX} LLD 宏。SNMPINDEX 是我们 SNMP 轮询的最后一个数字。在这种情况下，我们将看到以下内容：

.1.3.6.1.2.1.2.2.1.8.1 = INTEGER: up(1)
.1.3.6.1.2.1.2.2.1.8.2 = INTEGER: up(1)

对于世界上所有的供应商来说，都有一套预定义的 SNMP 规则，他们应该遵循。在轮询 .1.3.6.1.2.1.2.2.1.2 时，我们的第一个接口条目是 .1 SNMPINDEX，值为 lo。这意味着，当轮询 .1.3.6.1.2.1.2.2.1.8 时，.1 SNMPINDEX 这里仍然应该包含 lo 的值。

Zabbix LLD 现在将创建一个名为 接口 lo: 操作状态 的项，来轮询 SNMP OID：

.1.3.6.1.2.1.2.2.1.8.1 = INTEGER: up(1)

它还将创建一个名为 接口 ens192: 操作状态 的项，来轮询 SNMP OID：

.1.3.6.1.2.1.2.2.1.8.2 = INTEGER: up(1)

创建的项将如下所示：

图 5.40 – 我们的 SNMP 监控主机的 Zabbix 最新数据屏幕

除了创建这些 LLD 项目外，我们还创建了一个 LLD 触发器原型。它的工作方式与项目原型相同。如果我们检查我们的主机触发器，可以看到两个已创建的触发器：

图 5.41 – 我们的 SNMP 监控主机触发器

这些触发器已与项目相同的方式创建，并且被正确的项目填充以触发：

图 5.42 – 我们的 SNMP 监控主机 ens192 的触发器

我们可以看到，对于接口操作状态，我们的 SNMPINDEX 是 2，接口 ens192: 管理状态 项目也有相同的值。现在，当操作状态为 0 (down) 且管理状态为 1 (up) 时，我们的触发器将被触发。

一个整洁的触发器，确保只有在管理状态为 up 时才会有问题；毕竟，只有当我们将接口配置为管理员 up 时，我们才希望收到接口故障的警报。

提示

可以使用发现过滤器，仅将管理状态为 up 的接口添加到我们的监控中。这样，我们可以保持 Zabbix 服务器的性能更低，同时保持数据更清洁。考虑在此类使用案例中使用发现过滤器。

另请参见

发现是一个广泛的主题，需要一些时间才能掌握。它可以像我们在本章中使用 SNMP 那样使用，但也可以与 Zabbix 代理一起使用，适用于许多其他使用场景。一旦你开始使用 Zabbix 发现，并且保持结构化，那时你就能开始构建出迄今为止最好的模板。

查看以下链接以获取 Zabbix LLD 文档：

www.zabbix.com/documentation/current/en/manual/discovery/low_level_discovery

嵌套 Zabbix 模板

在大多数情况下，使用每个设备或设备组的简单模板是创建 Zabbix 模板的最佳实践，但这不是唯一的方法。我们还可以使用嵌套模板将它们的部分拆分并重新组合到层级结构中的最高模板中。

在本教程中，我们将讨论如何配置这个模板及其原因。

准备工作

我们需要我们的 Zabbix 服务器、我们的 SNMP 监控主机以及我们在前一章节中创建的模板。

如何操作…

让我们首先导航到数据收集 | 模板页面，并点击右上角的创建模板按钮。
我们将创建一个新模板来监控我们 SNMP 主机的 uptime。请输入以下信息：

图 5.43 – 使用 SNMP 的 uptime 新模板创建页面

接下来，我们将点击添加按钮，并点击我们的通过 SNMP 自定义 Linux uptime模板名称。这将带我们进入模板编辑页面。
点击项和右上角的创建项。我们将在这里创建一个示例项，如下所示：

图 5.44 – 模板创建页面上的新项，名为系统 Uptime

不要忘记添加一个标签，如截图所示，通过转到标签选项卡：

图 5.45 – 模板创建页面上的新项，系统 Uptime，标签选项卡

确保点击蓝色的添加按钮以完成此项的添加。
现在，让我们通过返回数据收集 | 模板页面并点击通过 SNMP 自定义 Linux，导航到我们原始的模板。
在此页面上，通过在模板输入框中添加它，将一个模板链接到当前模板，如下所示：

图 5.46 – 主 SNMP 模板的模板链接页面

点击蓝色的更新按钮以完成模板链接。
最后但同样重要，导航到数据收集 | 主机，点击我们的lar-book- templated_snmp SNMP 监控主机，并检查项页面，看看该项是否存在：

图 5.47 – 我们的主机 | 主机 lar-book-templated_snmp 的项页面

项目存在，并显示它实际上来自另一个模板。这就是链接模板的全部操作——使用这些嵌套模板操作起来很容易，但要保持其结构化则更具挑战性。让我们看看这是如何运作的。

它是如何工作的……

嵌套模板具有简单的树形结构，就像这样：

图 5.48 – 模板嵌套树形结构

所以，我们有一个 Zabbix 监控的主机，它与 Custom Linux by SNMP 模板链接，作为唯一的模板。现在，由于我们在 Custom Linux by SNMP 上有一个嵌套模板（当然，它是 Custom Linux uptime by SNMP），该模板上的项也会链接到我们的 Zabbix 监控主机。

我们可以将此应用于许多场景——其中一个我最喜欢的场景是网络设备。如果我们有一台 Juniper EX（或 Cisco Catalyst）系列交换机和一台 Juniper QFX（或 Cisco Nexus）系列交换机，这两种系列交换机都使用相同的 SNMP 接口发现。因此，我们可以为接口创建一个模板，并将其嵌套在 EX 或 QFX 系列的主模板中，这些系列使用不同的 SNMP OID 来表示其他值。

通过这种方式，我们不需要在模板中重复编写相同的发现规则、项目、图形以及其他所有内容。我们只需做一次，并将模板整洁地嵌套在其中。

第六章：6

数据可视化、库存和报告

在使用 Zabbix 时，收集到的数据必须得到充分利用。毕竟，如果我们没有一个可以轻松访问数据的地方，这些数据就没有意义。Zabbix 已经通过 最新数据 页面和由触发器创建的问题有效地利用了我们的数据，但我们也可以通过自己创建一些东西来更好地利用数据，例如图表、地图、库存以及完全自定义的仪表板。我们甚至可以从仪表板生成报告并在前端使用内置报告。

完成这些操作后，你将能够设置 Zabbix 数据可视化的最重要部分。你还将能够充分利用你的库存和报告系统，以获得它们的最大功能。

在本章中，我们将涵盖以下内容，以帮助你实现良好的结果：

创建图表以访问可视数据
创建地图以监控基础设施
创建仪表板以获得正确的概览
为主机级别工作创建仪表板模板
设置 Zabbix 库存
使用 Zabbix Geomap 小部件
处理 Zabbix 报告
设置定期的 PDF 报告
设置改进的业务服务监控

技术要求

对于本章内容，我们需要 Zabbix 服务器，以及我们在 第五章 中配置的 简单网络管理协议（SNMP）监控的主机，构建你自己的结构化模板。我们将主要在 Zabbix 的前端进行操作，请准备好鼠标。

本章的代码文件可以在本书的 GitHub 仓库找到：github.com/PacktPublishing/Zabbix-7-IT-Infrastructure-Monitoring-Cookbook/tree/main/chapter06。

创建图表以访问可视数据

Zabbix 中的图表是展示你收集的数据变化的强大工具。你可能已经通过 最新数据 页面创建了一些临时图表，但我们也可以创建预定义图表。在本章节中，我们将逐步讲解如何做到这一点。

准备工作

确保你的 Zabbix 服务器已准备好，并且有一台 Linux 主机可以监控（使用 SNMP）。如果你按照 第五章 中的步骤操作，构建你自己的结构化模板，你应该已经有了一个模板。

或者，你可以下载本章中提供的模板：github.com/PacktPublishing/Zabbix-7-IT-Infrastructure-Monitoring-Cookbook/tree/main/chapter06。

如果你使用的是下载的模板，请先下载并导入 Custom Linux uptime by SNMP，然后导入 Custom Linux by SNMP。你可以通过进入 数据收集 | 模板，并点击右上角的蓝色导入按钮来导入模板。

确保你将模板应用到主机并监控它。

如何操作...

按照以下步骤操作：

我们从导航到模板开始，进入 数据收集 | 模板并选择模板。对我来说，它仍然叫做 Custom Linux by SNMP。
转到项目并在模板中创建以下项目：

图 6.1 – ICMP 项目创建页面

确保你进入标签标签页并添加一个标签，如下所示：

图 6.2 – ICMP 项目创建页面 – 标签标签页

点击蓝色的添加按钮保存此项目。
现在，回到模板配置页面，转到图表。在这里我们可以看到该模板下所有配置的图表；目前还没有图表。
点击右上角的 创建图表。这将带你到图表创建页面：

图 6.3 – 图表创建页面

这是我们可以为独立项目创建图表的地方。让我们创建一个图表来查看我们的正常运行时间。

填写图表创建页面的以下信息：

图 6.4 – 填写我们信息的图表创建页面

提示

在处理图表时，最好考虑到色盲人群。全球约有 8% 的男性和 0.5% 的女性受此影响。网上有很多优秀的资源可以解释在生产环境中应使用哪些颜色。你可以在这里找到其中一个来源：www.tableau.com/about/blog/2016/4/examining-data-viz-rules-dont-use-red-green-together-53463。

现在，尝试一段时间对你的 SNMP 监控主机进行 ping 测试。通过 Zabbix 服务器的 命令行 界面 (CLI) 进行：
```
ping 10.16.16.153
```
然后，导航到监控 | 主机，点击主机旁边的图表按钮。在我的案例中，主机仍然被称为 lar-book-templated_snmp。
这将立即带我们到该主机的图表概览页面，我们可以看到新的 传入 ICMP 消息图表：

图 6.5 – 监控 | 主机图表页面，显示我们的图表

我们还可以为发现项目创建图表，这称为图表原型。它们与我们的项目原型大致相同。让我们也创建一个这样的图表：

导航到 数据收集 | 模板，并选择我们的 Custom Linux by SNMP 模板。
转到 发现规则。然后，对于 发现网络接口 发现规则，点击 项目原型。在右上角，点击 创建项目原型，并创建以下项目原型：

图 6.6 – 项目原型 – 填充了我们信息的传入比特页面

现在，让我们在标签标签页上添加一个标签：

图 6.7 – 项目原型传入比特 – 标签页

最后，确保在预处理页面中添加以下内容：

图 6.8 – 项目原型 – 填充了我们信息的传入比特预处理标签页

重要提示

预处理是一个相当广泛的话题。简而言之，本步骤中的预处理将确保我们的数据以每秒变化的方式进行计算，使用数学公式(value - prev_value)/(time - prev_time)，并且我们的数据将乘以 8，单位从字节转换为比特。

点击蓝色的添加按钮以完成创建该项目原型。
现在，在我们的发现网络接口发现规则中，点击图表原型按钮。
在右上角，点击创建图表原型，并在下一页面填写以下信息：

图 6.9 – 图表原型 – 填充了我们信息的传入比特页面

现在，如果我们回到监控 | 主机并点击图表按钮，我们将看到两个新图表：

图 6.10 – 我们主机的图表页面

由于我们刚刚添加了该项目，图表填充数据可能需要一些时间。给它一点时间，你会看到它们开始填充数据。

它是如何工作的……

图表通过将收集到的值以可视化形式呈现来工作。我们通过 SNMP 等方式从主机收集数据，并将这些数据存入数据库中。然后，我们的图表从数据库中获取数据，并将其呈现为可视化形式。对人类来说，这样更易于阅读，我们也能轻松解读数据。

图表原型几乎与项目原型相同。对于每个发现的接口，我们使用包含{#IFNAME} 低级发现 (LLD) 宏的名称创建一个图表。这样，我们就得到了一个灵活的结构化环境，因为当新接口创建（或删除）时，相应的图表也会创建（或删除）。

创建地图以监控基础设施

Zabbix 中的地图是获取基础设施概览的好方法。例如，它们非常适合跟踪流量流动，或者查看环境中出现问题的地方。它们不仅对网络概览非常有用，还对服务器管理概览，甚至许多酷炫的自定义也很有帮助。

地图非常有用，我们在构建的环境中经常使用它们。由于我们非常喜欢地图，我们还自作主张地提出了一个功能请求，建议对已收集的地图进行改进，以使它们更好：support.zabbix.com/browse/ZBXNEXT-7680。

准备工作

我们需要 Zabbix 服务器、SNMP 监控主机以及前面配方中的模板。

如何操作……

按照以下步骤操作：

让我们通过导航到数据收集 | 模板并选择我们的自定义 Linux 通过 SNMP模板来开始这个过程。
进入发现规则，然后是项目原型。通过填写项目原型创建页面中的字段，创建以下项目原型：

图 6.11 – 项目原型创建页面

我们还需要进入标签，如以下截图所示，添加一个新标签：

图 6.12 – 项目原型创建页面 – 标签标签

最后，别忘了通过进入预处理标签页添加预处理：

图 6.13 – 项目原型 – 预处理标签

点击蓝色的添加按钮完成。
接下来，导航到监控 | 地图。这里已经有一个默认地图，所有 Zabbix 服务器安装中都会包含，叫做本地网络。随意查看一下：

图 6.14 – 默认本地网络地图

除了您的本地 Zabbix 服务器主机以及它是否处于问题状态外，这里没什么可看的。所以，让我们点击所有地图。
我们将创建我们自己的地图，所以点击右上角的创建地图按钮。通过填写以下字段来创建地图：

图 6.15 – 地图创建页面

点击蓝色的添加按钮后，前端会将您带回到地图概览页面。点击这里新创建的模板化 SNMP 主机 地图。
点击右上角的编辑地图开始编辑地图。
现在，我们在这里要做的是选择地图顶部水平菜单中地图元素旁边的添加按钮。这将添加以下元素：

图 6.16 – 添加的元素

点击新添加的元素。这将打开以下屏幕：

图 6.17 – 地图元素编辑窗口

在这里，我们可以填写我们的主机信息。让我们将以下信息添加到字段中：

图 6.18 – 地图元素 – lar-book-templated_snmp

点击400和100（参见图 6.20）。

现在，点击 Map element 旁边的 Add 按钮添加另一个元素。编辑新元素并添加以下信息：

图 6.19 – 填写信息的地图元素 vSwitch 编辑窗口

创建两个元素后，将新的交换机元素移动到 150 和 80，如 图 6**.20 所示。

现在，按住键盘上的 Ctrl 键（Mac 上是 command 键），选择两个元素。
然后，点击 Link 旁边的 Add 按钮，添加两个元素之间的链接。现在应该是这样的：

图 6.20 – 我们新创建的地图

在创建链接后，再次点击我们的图标编辑服务器信息。点击新创建的链接旁边的 Edit 按钮，如下图所示：

图 6.21 – 地图元素编辑窗口中的编辑链接

在窗口中添加以下信息：

图 6.22 – 在地图元素编辑窗口中编辑链接并填入我们的信息

重要信息

确保主机名（在本示例中是 lar-book-templated_snmp）与 Zabbix 系统中的主机名完全匹配。我们是专门从该主机请求数据。我们不能在这里省略主机名或使用宏，如 {HOST.HOST}，因为该链接涉及两个主机，Zabbix 无法理解其上下文。

让我们在 Link indicators 部分点击 Add，并添加一个红色的触发器：

图 6.23 – 填充触发器的链接指示器

现在，点击窗口底部的 Apply，然后点击页面右上角的 Update。我们的第一个地图就创建完成了！

工作原理…

在创建并打开地图后，我们将看到如下内容：

图 6.24 – 我们新创建的地图

地图展示了我们的交换机（目前不是被监控的主机）和我们的服务器（是被监控的主机）。这意味着，当我们的服务器出现问题时，OK 状态会在地图上变为 PROBLEM 状态。

我们还可以看到我们配置的标签（见 图 6**.24），它展示了流量统计的实时信息。现在，当我们分解标签时，会得到如下内容：

图 6.25 – 地图标签分解

我们可以通过在 {} 中定义要拉取的统计数据，将实时统计数据拉入标签。在这种情况下，我们收集接口流量的值，并直接将其放入标签中，从而创建一个实时流量分析地图。

我们还在这个链接上设置了触发器。将这样的触发器放置在我们的地图上的一个酷点是，当我们的链接出现故障时，我们可以看到以下情况发生：

图 6.26 – 显示问题的地图

由于链接已经中断，流量停止流动，我们的线路变成了红色。而且，我们的主机现在在主机名下显示问题状态。

我们甚至可以创建带有触发器的橙色线条，表示 50%的流量利用率，如此，并通过我们的网络跟踪分布式拒绝服务（DDoS）流量。

创建仪表盘以获得正确的概览

现在我们已经创建了一些图表和地图，让我们继续进行，不仅要可视化数据，还要获取一个概览。在本例中，我们将为我们监控的 Linux 主机创建一个仪表盘。

准备工作

确保你已经完成了前两个食谱，并且你的 Zabbix 服务器已准备好。我们将使用之前食谱中的 SNMP 监控主机，以及我们之前创建的一些项目、触发器和地图。

随时可以用你环境中可能没有的任何其他项目来替代任何项目。对于仪表盘，最重要的是玩转数据，只有理解了小部件的概念，你才可以做到这一点。

如何操作...

按照以下步骤操作：

从侧边栏导航到仪表盘，然后点击页面左上角的所有仪表盘。
现在，点击右上角的创建仪表盘按钮，并填写你的仪表盘名称，如下所示：

图 6.27 – 仪表盘属性区域

自动开始幻灯片在这里已启用，但它只有在你想将此仪表盘用于幻灯片时才有用，比如在网络运营中心（NOC）房间的大屏幕上。我总是为那些在个人电脑上使用的仪表盘禁用它，以防我的页面在故障排除时跳动。

我还创建了一个案例，请求 Zabbix 更改默认行为：support.zabbix.com/browse/ZBXNEXT-7713。

提示

将像地图和仪表盘这样的 Zabbix 元素保留给整个部门使用，最好由 Zabbix管理员用户拥有。这样，它们就不会依赖于某个可能会在后期离开你环境的单一用户，这意味着一旦我们想删除该用户的账户时，我们需要更改地图的所有者。元素也可以由一个禁用的用户拥有。如果你不是超级管理员，别忘了在更改所有者之前先将仪表盘分享给自己。

现在，点击应用；你将被带到你的仪表盘：

图 6.28 – 新的空白仪表盘

创建仪表盘后，我们会看到它是空的。我们需要通过添加多个小部件来填充它，以便创建一个良好的概览。

让我们首先添加一个问题小部件。点击右上角的+ 添加，通过填写所有字段来添加以下小部件：

图 6.29 – 新问题小部件创建窗口

点击添加。通过这样做，我们将在仪表板上拥有第一个小部件，显示所有未确认的问题。它将仅显示严重性为警告及以上的所有 Linux 服务器上的问题：

图 6.30 – 未确认问题小部件

让我们立即添加更多小部件，从我们的地图小部件开始。点击右上角的+ 添加，并添加以下小部件：

图 6.31 – 添加小部件页面

同样，通过再次点击右上角的+ 添加按钮添加一个图表类型的小部件。这个稍微复杂一些。首先，我们添加名称：

图 6.32 – 新图表小部件创建窗口

然后，我们需要添加我们的第一个数据集，像这样：

图 6.33 – 添加数据集

然后，点击+ 添加新数据集并添加以下内容：

图 6.34 – 添加另一个数据集

然后，我们可以点击添加，我们的图表将添加到仪表板中。
我们还将在页面上添加项目值小部件。再次点击+ 添加。然后，设置以下小部件：

图 6.35 – 添加项目值小部件

如果你有兴趣改变小部件的外观，记得使用小部件配置屏幕中的高级配置字段。

另一个我们喜欢的小部件是非常有用的顶部主机小部件。让我们通过再次使用+ 添加按钮来添加它。
在小部件配置屏幕上，将主机组设置为Linux 服务器。
接下来，点击添加按钮，位于列旁边，添加一个带有信息的列。按以下方式填写表单：

图 6.36 – 顶部主机小部件 1，列 1

再次点击添加按钮，位于列旁边，然后添加以下内容：

图 6.37 – 顶部主机小部件 1，列 2

结果应该是这样的：

图 6.38 – 顶部主机小部件 1

别忘了点击表单底部的蓝色添加按钮来保存您的更改。
让我们通过再次使用+ 添加按钮创建另一个顶部主机小部件。
将主机组设置为Linux 服务器。然后，再次点击添加按钮，位于列旁边。添加以下内容：

图 6.39 – 顶级主机小部件 2，第 1 列

再次点击列旁边的添加按钮，并添加以下内容：

图 6.40 – 顶级主机小部件 2，第 2 列

结果将如下所示：

图 6.41 – 顶级主机小部件 2

现在，我们可以自由地移动小部件，直到看到这个：

图 6.42 – 我们的信息填充的仪表盘

现在，让我们添加另一个页面。点击+ 添加旁边的下拉箭头，然后点击添加页面。这将打开以下弹窗，我们将在其中添加一个名为主机数据的新页面：

图 6.43 – 添加新主机数据页面

点击应用以添加新页面。现在我们可以立即开始在第一个页面上添加其他小部件。
让我们再次点击+ 添加以添加新小部件，并首先选择名为仪表的小部件。
让我们从默认的Zabbix 服务器主机中选择一个项目。点击选择旁边的项目字段，并在主机组中搜索Zabbix 服务器主机。在列表中选择可用内存百分比项目。
确保表单如下所示：

图 6.44 – 仪表盘仪表小部件创建表单

点击此窗口底部的添加按钮以保存更改并添加此小部件。
现在，让我们通过再次点击+ 添加来添加最后一个小部件。我们将添加一个名为饼图的新小部件。
将名称设置为CPU 时间。对于主机模式，设置为Zabbix 服务器，对于项目模式，设置为CPU * 时间。它应该是这样的：

图 6.45 – 仪表盘饼图小部件创建表单

在图例标签中，将行数设置为3。
现在，点击页面底部的添加按钮以保存更改并添加小部件。
现在，您的新页面应该是这样的：

图 6.46 – Zabbix 全局仪表盘第二页

我不喜欢第一个页面的名称，所以我们点击页面 1，然后点击页面 1旁边的三个点。它会打开一个下拉菜单，我们可以选择属性。
在这里，给您的页面取一个新名称。我会将其命名为概览。我总是重新命名第一个页面，以保持组织性，避免在仪表盘中（或任何地方）出现任何默认的非描述性名称。现在应该显示我们两个不同名称的页面：

图 6.47 – Zabbix Linux 服务器全局仪表盘页面名称

点击右上角的保存更改，完成。

它是如何工作的……

创建仪表板是为故障排除、日常问题监控以及——当然——在大屏幕电视墙上使用的最佳方式。我们可能都见过那些显示数据的大型操作中心。正如你在这条配方中看到的，Zabbix 非常适用于这些目的及更多用途。

还有更多内容…

Zabbix 在 7.0 版本中增加了许多新小部件，因为他们非常重视可视化功能。随着版本的更新，Zabbix 会继续增加新的小部件，所以如果你还缺少某些功能，请随时关注路线图：www.zabbix.com/roadmap。

我们还没有讨论每个新的小部件，因此请查看这里的新功能页面：www.zabbix.com/whats_new_7_0。

使仪表板在主机级别工作

当 Zabbix 移除了屏幕功能并完全用仪表板替代时，Zabbix 社区中的许多人非常激动，想在他们的主机级别仪表板上使用更新的小部件。不幸的是，开发时间有限，在写作时，该功能仅限于六个小部件。

在 Zabbix 7.0 中，这一切发生了变化。所有在全球仪表板中可用的小部件现在都可以在主机级别仪表板中使用，使整个功能变得非常实用。

准备就绪

确保你已经完成了本章的前两条配方，并且你的 Zabbix 服务器已准备好。我们将使用前两条配方中的 SNMP 监控主机，以及我们的项目、触发器和图表。

或者，只要主机上有数据且已分配模板，任何人都可以创建主机级别的仪表板。因此，你也可以自由应用你自己的数据集。

如何操作…

让我们开始构建一些模板化的仪表板：

转到数据采集 | 模板，点击模板旁边的仪表板，编辑通过 SNMP 的自定义 Linux模板。
现在，在右上角点击创建仪表板，开始创建你的第一个模板化的主机级别仪表板。
我们将把这个仪表板命名为主机概览，因为它将包含关于我们主机的几项不同统计信息：

图 6.48 – 主机仪表板创建

自动开始幻灯片选项在此已启用，但如果你希望在如 NOC 房间的大屏幕（电视）上使用该仪表板，则此选项非常有用。对于用于个人计算机的仪表板，我总是会禁用它，这样在故障排除时我的页面不会跳来跳去。
点击应用以添加这个新的仪表板。
现在仪表板已创建完毕，我们可以开始添加一些小部件。点击右上角的+ 添加按钮来添加你的第一个小部件。
让我们从一个简单的项目值小部件开始。添加以下信息：

图 6.49 – 主机仪表板，项目值小部件

确保通过点击 + 添加来应用更改并添加小部件。
接下来，我们将添加一个图形小部件。点击 + 添加 创建另一个小部件，并添加以下信息：

图 6.50 – 主机仪表板，图形小部件

仍然在小部件创建表单上，我们还将创建一个数据集。在这种情况下，我们可以通过仅添加单项数据集来保持简单：

图 6.51 – 主机仪表板，图形小部件数据集

点击 *) 以抓取单项模式中的多个项。
让我们在这里也创建主机的一个问题概览。添加问题小部件，如下所示：

图 6.52 – 主机仪表板，问题小部件

点击添加以保存更改并将小部件添加到仪表板。
现在，确保你安排这些小部件，使它们形成一个合适的仪表板：

图 6.53 – 主机仪表板，完成并排布

到这时，你可能会想，为什么这个仪表板是空的。模板不包含数据，这意味着我们必须导航到某个主机以查看实际数据。

转到监控 | 主机并进入 lar-book-templated_snmp 主机。点击旁边的 仪表板：

图 6.54 – 主机仪表板，适用于主机 lar-book-templated_snmp

正如你所看到的，仪表板现在包含了关于我们特定主机的数据。

它是如何工作的……

主机级仪表板非常有用，因为它们完全依赖于模板。我们必须在模板级别进行设置；这样，当我们设置好后，所有使用该模板的主机都会有相同的仪表板，并在小部件中显示唯一的信息。这使我们能够通过在模板级别进行设置，轻松创建数百个甚至数千个仪表板。

然而，我们必须记住，主机级仪表板与我们在之前的步骤中设置的全局仪表板是不同的。我们不仅以不同的方式访问它们，而且它们也在主机级别运行。这意味着它们主要用于显示单个主机的信息。

在 Zabbix 7.0 中，我们可以在全局仪表板级别添加所有可用的小部件，使主机级仪表板变得非常有用。如果我们有多个模板，每个模板有一个甚至多个仪表板，我们还可以使用顶部的页面来轻松导航多个仪表板：

图 6.55 – Zabbix 服务器主机的仪表板选择器

设置 Zabbix 库存

Zabbix 库存是我非常喜欢的功能，但最近 Zabbix 开发团队并没有对其给予太多关注，尽管它已经列入了 7.0 版本的路线图中。抱歉——我还是爱你们，Zabbix 开发者，如果你们在看这篇文章，请随时为这个功能投入一些时间！

具体来说，我在谈论这个老旧的功能请求：support.zabbix.com/browse/ZBXNEXT-336。

库存功能使我们能够将收集的数据自动放入可视化的 配置管理数据库（CMDB），比如 Zabbix 前端的库存。我想我们都见过未更新的 CMDB 库存系统，因此缺少了需要的数据。当我们查看系统时，Zabbix 库存通过从被监控的系统中获取数据来解决这个问题。让我们开始吧。

准备工作

确保你登录到 Zabbix 前端，并准备好之前配好的 SNMP 监控主机。

如何操作……

按照以下步骤操作：

首先，我们要确保 Zabbix 服务器将所有主机的库存信息填写到字段中。我通常通过进入管理 | 常规，然后从左上角的下拉菜单中选择其他来完成这一步。
然后，我们可以将 默认主机库存模式 参数设置为自动。别忘了点击更新：

图 6.56 – 管理 | 常规 | 其他配置参数

或者，我们可以在主机级别执行此操作。进入配置 | 主机并选择我们的 lar-book-templated_snmp SNMP 监控主机。
选择库存并将其设置为自动。正如你可能注意到的那样，默认设置只会应用于从现在开始新创建的主机。

重要提示

修改全局设置不会应用于所有现有主机，只会应用于新创建的主机。可能需要对所有主机执行 批量更新 操作，或者逐个主机手动更改库存模式。

现在，前往 数据采集 | 模板，然后选择 通过 SNMP 的自定义 Linux。
进入项目并编辑 系统主机名。我们需要像这样更改 填充主机库存字段 设置：

图 6.57 – 编辑项目页面

点击更新并导航至库存 | 主机。你将看到以下内容：

图 6.58 – 库存 | 主机

它是如何工作的……

Zabbix 库存目前很简单，但还没有得到充分开发。虽然它在筛选时还没有做到精确显示我们想要看到的内容，但它依然非常有用。

如果你正在处理大量设备，比如在 MSP 环境中，逐个登录到每台设备并手动获取序列号可能会让人感到不堪重负。如果你通过轮询获取序列号并填写资产清单字段，你就会立刻拥有一份最新的序列号活跃列表。

同样的方法适用于从硬件信息到软件版本的任何内容。我们可以从设备中获取活动操作系统版本，并生成我们所有操作系统版本的详细列表，这在你需要修补某些东西时非常有用，例如。

在创建项目时，明智地使用 Zabbix 资产清单，并将填充设置为自动，就像我们在本章中所做的那样——你几乎不需要再多想这个功能了。以这种方式配置它，你会有很好的列表等待你在需要时使用。

使用 Zabbix 地理地图小部件

现在我们已经了解了如何创建仪表盘，让我们设置另一个仪表盘。我们将用这个仪表盘来创建一个全面的地理概览，展示 Zabbix 中一些主机的信息。我们将通过使用 Zabbix 资产清单功能来实现这一点，这个功能我们刚刚学会使用。

准备工作

我们为这个教程所需的只是一个具有前端访问权限的 Zabbix 设置。跟随之前的两个关于仪表盘和资产清单的教程也是明智的。如果你还没有跟随这些教程，建议你先跟随它们。

如何操作…

使用 Zabbix 地理地图功能非常简单——我们只需要将 Zabbix 资产清单与仪表盘小部件结合使用即可：

首先，让我们导航到我们的数据收集 | 主机页面，编辑我们的其中一台主机。我将使用lar-book-templated_snmp主机，但无论你使用哪台主机都没有关系，只要它在Linux 服务器主机组中。
进入资产清单选项卡，确保它被设置为手动或自动：

图 6.59 – Zabbix 主机资产清单选项卡中的资产模式选择器

现在，在位置纬度和位置经度字段中，填写以下内容：

图 6.60 – Zabbix 主机上的资产清单选项卡字段

点击蓝色的更新按钮保存这些更改。
返回到数据收集 | 主机，我们对另一个主机做同样的操作。我将使用lar-book-agent_simple。
进入资产清单选项卡，再次填写位置纬度和位置经度字段：

图 6.61 – 另一台 Zabbix 主机上的资产清单选项卡字段

点击蓝色的更新按钮保存这些更改。
现在，让我们进入仪表盘，在所有仪表盘中创建一个新的仪表盘，或者使用我们现有的Linux 服务器仪表盘。我将这样做。
点击右上角的蓝色编辑仪表板按钮，然后使用添加按钮下拉菜单点击添加页面：

图 6.62 – 现有仪表板添加页面按钮

我们将添加以下新页面：

图 6.63 – 仪表板页面属性

点击应用来添加这个新页面。
现在，我们可以通过点击页面上的任何地方来添加Geomap小部件。按如下方式填写：

图 6.64 – Zabbix Geomap 小部件属性

点击应用来保存小部件配置。
现在，我们可以点击右上角的蓝色保存更改按钮来保存我们的仪表板更改。
这将带我们返回到仪表板页面，在那里我们可以点击此仪表板的Geomap页面：

图 6.65 – Zabbix 仪表板上的 Geomap 小部件，包含两个主机

现在，我们在 Zabbix 仪表板中有了一个功能齐全的 Geomap 小部件，它使用了我们 Zabbix 库存中可用的纬度和经度。

它是如何工作的…

Zabbix 没有创建一个全新的监控 | Geomap页面，而是选择通过小部件的方式来包含这个新功能，给我们提供了创建更高级仪表板的选项。这里需要注意的是，Zabbix 还选择使用现有的库存数据。正如我们在设置 Zabbix 库存一节中看到的，因为可以自动填写库存数据，所以我们也可以自动化 Geomap 小部件的内容。

所以，无论您选择手动方式还是自动方式，Geomap 小部件都是我们仪表板的一个有价值的扩展。总体而言，Zabbix 通过在 Zabbix 7 中包含一系列新的小部件，极大地扩展了仪表板的功能。

本章中我们将设置 Zabbix 的自动报告功能，它也将使用仪表板功能。如果您愿意，您可以将 Geomap 小部件与自动报告结合，发送地理报告。这里的关键要点是，Zabbix 正在构建组件间的互操作性，并为我们提供了灵活性，让我们可以根据自己的需求使用像 Geomap 这样的新小部件。

在使用 Geomap 小部件的初始版本时，有些人曾问我们是否可以更改 Geomap 小部件使用的地图类型。如果我们导航到管理 | 常规 | 地理地图，我们可以选择几个内置的地图提供商：

图 6.66 – 管理 | 常规 | 地理地图

如果这还不够，您还可以使用瓦片提供商下的其他选项添加自定义地图提供商。只需填写表单，就可以完成设置：

图 6.67 – 管理 | 常规 | 地理地图 – 其他

如你所见，通过这个小小的组件增加了很多功能。Zabbix 社区最为期待的功能之一，我们现在可以在最新的 Zabbix 版本中进行配置并使用它。

通过 Zabbix 报告工作

Zabbix 报告得到了 Zabbix 开发团队的充分关注，尤其是在系统报告和审计日志的改进方面。首先，我们将介绍一些强大的功能，展示如何直接从 Zabbix 前端查看统计数据。接着，在下一个章节中，我们将介绍如何创建自动化的 PDF 报告，这是一个新功能，备受期待。

准备工作

对于这个章节，你只需要 Zabbix 前端和一个被监控的主机。我将使用之前章节中使用的 SNMP 监控主机。

如何操作…

事实上，几乎没有什么需要配置的，因为报告功能在 Zabbix 中自带。所以，让我们深入了解报告页面提供了哪些内容。

系统信息

如果你导航到报告 | 系统信息，你将看到以下表格：

图 6.68 – 报告 | 系统信息

你可能之前见过这个表格，它也可以作为仪表板组件进行配置。这个页面为我们提供了关于 Zabbix 服务器的所有信息，例如：

Zabbix 服务器正在运行：此项通知我们 Zabbix 服务器后台是否在运行，并显示运行的地址。在本例中，Zabbix 服务器正在运行，并且运行在localhost:10051。
Zabbix 服务器版本：显示我们实例中安装的 Zabbix 服务器守护进程版本。
Zabbix 前端版本：当前在我们的 Web 服务器上运行的 Zabbix 前端版本。
软件更新上次检查：显示 Zabbix 上次检查是否有新版本可用的时间。
最新版本：显示是否有 Zabbix 的新版本可用。
主机数量：显示已启用（16）和已禁用（5）的主机数量。它为我们提供了 Zabbix 服务器主机信息的快速概览。
模板数量：显示当前在该 Zabbix 系统中可用模板的数量。
项目数量：显示 Zabbix 服务器项目的详细信息——在本例中，已启用（565）、已禁用（241）和不支持（217）的项目数量。
触发器数量：显示我们的触发器数量。我们可以看到已启用（373）和已禁用（38）的触发器，还可以查看处于问题状态（12）和处于正常状态（361）的触发器数量。
用户数量（在线）：第一个值显示总用户数，第二个值显示当前登录到 Zabbix 前端的用户数。
所需的服务器性能，新的每秒值：也许我在这里向您介绍一个完全新的概念，即每秒新的值（NVPS）。一台服务器通过项目接收或请求值，并将其写入我们的 Zabbix 数据库。此处详细信息显示了 Zabbix 服务器接收到的估计 NVPS 数量。

根据您的设置，您可能还会看到以下两个额外的值：

数据库名称：如果您看到数据库名称以及版本值，这可能表明您正在运行一个不受支持的数据库版本。您可能会看到类似警告！不受支持的数据库服务器版本。应该至少是 <****DATABASE VERSION>的消息。
高可用性集群：如果您正在运行 Zabbix 服务器高可用性集群，您将在此看到它是否启用，以及故障转移延迟。此外，报告 | 系统信息页面将显示更多高可用性相关的信息。

可用性报告

进入报告 | 可用性报告，我们可以获得有关某个触发器在一定时间内处于问题状态与正常状态的时长的一些有用信息：

图 6.69 – 报告 | 可用性报告

查看我们的其中一台主机，我们可以看到，在过去的 30 天中，Zabbix 代理不可用（持续 3 分钟）的触发器处于问题状态的时间占比为10.0000%。知道这一点可能对我们很有帮助，以便我们可以确定某个问题出现的频率。

触发器前 100 名

进入报告 | 触发器前 100 名，我们将找到在一定时间内触发最多的前 100 个触发器：

图 6.70 – 报告 | 触发器前 100 名

对于我的 Zabbix 服务器，最繁忙的触发器是Zabbix 代理不可用的触发器，位于一台服务器上。这个页面非常有用，可以帮助我们了解我们在问题方面花费最多时间的地方。

审计

审计日志，作为 Zabbix 的一个有用补充，可以通过进入报告 | 审计找到：

图 6.71 – 报告 | 审计

在这里，我们可以看到哪个用户在 Zabbix 服务器上执行了哪些操作——例如，识别出某个不该做的操作的责任人。

操作日志

当我们进入报告 | 操作日志时，会看到一个页面，展示哪些操作已经触发。如果您已配置操作，则可以在这里查看到类似的列表：

图 6.72 – 报告 | 操作日志

如果您不确定您的操作是否成功，可以查看此列表。它对于排查问题非常有用，直到您把操作恢复到预期的状态。

当您将鼠标悬停在信息框上时，还可以看到出了什么问题。例如，对于我 Zabbix 实例中的失败项目，我必须为 管理员 用户定义适当的媒体类型：

图 6.73 – 报告 | 操作日志 – 信息

通知

最后但同样重要的是，导航到报告 | 通知，我们可以看到在一定时间内发送给某个用户的通知数量：

图 6.74 – 报告 | 通知

在我的案例中，50 个通知已发送到 0 号的其他用户。

设置定时 PDF 报告

在 Zabbix 5.4 中添加了一个备受期待的功能：通过电子邮件发送自动生成的 PDF 报告。首先需要说明的是，这个功能可能还不能完全覆盖所有 Zabbix 用户的使用情况。这个功能的作用是截取任何 Zabbix 仪表板的屏幕截图并通过电子邮件发送。不过，这不仅仅是截图——数据会在 PDF 文件中转换为文本，而且分辨率非常高。这是 Zabbix 开发人员推出的第一个设置，我认为我们应该对它的出现表示感谢。

此外，这是一种非常灵活的实现方式，因为我们可以选择任何可用的部件，并设置其过滤器，随后自动发送在报告中。更重要的是，它为 Zabbix 开发团队提供了灵活性，可以即时添加新的部件，这些新部件会立即与 PDF 报告配合使用。

准备工作

我们将需要一个现有的 Zabbix 安装，并且可以访问前端和命令行界面。您可以使用本书中一直使用的服务器，或者使用您自己的安装。

在多主机设置的情况下，最简单的方法是在 Zabbix 服务器也运行的地方安装这个，但也可以在任何主机上运行它。在这个示例中，我们使用的是单主机安装。

您还需要设置一个具有电子邮件媒体类型的用户。

如何操作…

要开始使用 Zabbix 定时报告，我们需要在 Zabbix 服务器上安装一些组件：

让我们登录到 Zabbix 服务器的命令行界面，并执行以下命令来安装 Google Chrome 浏览器。

在 RHEL 系统上，运行以下命令：

vim /etc/yum.repos.d/google-chrome.repo

然后，将以下内容添加到文件中：

[google-chrome]
name=google-chrome
baseurl=http://dl.google.com/linux/chrome/rpm/stable/$basearch
enabled=1
gpgcheck=1
gpgkey=https://dl-ssl.google.com/linux/linux_signing_key.pub
dnf install -y google-chrome-stable

在 Ubuntu 系统上，运行以下命令：

wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | sudo apt-key add -
sudo sh -c 'echo "deb http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google.list'
sudo apt update
sudo apt-get install google-chrome-stable

现在，让我们通过以下命令安装所需的 Zabbix Web 服务包。

这是 RHEL 系统的命令：
```
dnf install zabbix-web-service
```
这是 Ubuntu 系统的命令：
```
apt install install zabbix-web-service
```
现在，让我们编辑新的 Zabbix Web 服务配置文件：
```
vim /etc/zabbix/zabbix_web_service.conf
```
我们可以在这里找到许多 Zabbix Web 服务特定的参数，包括加密。确保以下行的设置与您的 Zabbix 服务器的 IP 地址匹配：
```
AllowedIP=127.0.0.1,::1
```
现在，让我们编辑 Zabbix 服务器的配置文件：
```
vim /etc/zabbix/zabbix_server.conf
```
编辑 WebServiceURL 参数，以使其与您的 Zabbix Web 服务 IP 匹配，并确保设置 StartReportWriters 来保证我们有一个报告子进程：
```
WebServiceURL=https://localhost:10053/report
StartReportWriters=3
```

重要提示

要使定期报告功能正常工作，你需要为 Zabbix 前端设置 SSL 加密；我们推荐使用 Let’s Encrypt。或者，可以在/etc/zabbix/zabbix_web_service.conf文件中设置IgnoreURLCertErrors=1参数。

这就是 CLI 部分的内容。接下来，让我们登录到前端并导航至管理 | 常规 | 其他。
确保在此页面填写前端 URL参数，使用你的前端 URL，如下所示：

图 6.75 – 管理 | 常规 | 其他，已填写前端 URL

点击页面底部的蓝色更新按钮，然后导航到报告 | 定期报告。
现在，我们来到了可以设置和维护定期报告的页面。所以，让我们使用页面右上角的蓝色创建报告按钮来创建一个新的报告。
这将带我们进入一个新页面，在这里我们可以设置一个新的报告。我们将使用现有仪表盘的全局视图设置一个每周报告。首先，我们将此报告命名为全局视图仪表盘的每周概览。
通过点击选择按钮旁边的全局视图，选择仪表盘的视图。
将周期设置为每周，开始时间设置为9:00，并将重复日期设置为星期一：

图 6.76 – 报告 | 定期报告 – 创建新报告页面，第一部分

同时，确保填写主题和消息，并设置订阅，确保它们与用户配置文件中设置的电子邮件类型的媒体匹配：

图 6.77 – 报告 | 定期报告 – 创建新报告页面，第二部分

现在你可以点击测试按钮，查看报告是否正常工作。一旦正常，使用蓝色的添加按钮完成此定期报告的设置。

工作原理……

这个功能是大家期待已久的，终于到来了，但它还不完整，仅仅是未来更多高级定期报告的构建模块。使用这个新报告功能时有一些关键点需要注意。我总是强调，Zabbix 开发团队力求通过增加功能并将它们互联，确保我们可以用全新的方式利用现有功能。

Zabbix 开发团队本可以决定为 Zabbix 创建一个完整的 PDF 报告引擎。但是通过使用 Zabbix 仪表盘作为所有 PDF 报告的构建模块，他们创造了更多的灵活性和可定制性。每一个新增加的仪表盘小部件现在都可以在你的 PDF 报告中使用，未来还会添加更多专注于报告的小部件。

Zabbix 会从你的仪表板抓取信息，并使用新的 Zabbix Web 服务模块和 Google Chrome 浏览器将其以 PDF 形式发送给你。完成这些先决条件后，我们可以将 PDF 报告发送给任何 Zabbix 用户，只要他们已设置了电子邮件媒体类型。

设置改进的业务服务监控

业务服务监控是一种监控我们作为企业提供给客户或内部员工的服务的方法。想象一下 CRM 系统、电子邮件和我们的网站。一切必须正常运作，我们希望知道这些服务是否对使用者有效。它还允许我们监控这些服务的 SLA，如果我们想要定义的话。

从 Zabbix 6.0 开始，业务服务监控进行了全面改进。如果你在 6.0 之前的版本中设置过它，可能需要花些时间重新学习基础知识，并参考本教程。如果你是从 7.0 版本开始，且完全没有接触过业务服务监控，不用担心，因为我们会在本教程中一步步教你如何设置。

准备工作

我们需要 Zabbix 服务器并访问其前端。我将使用我们到目前为止配置的 lar-book-centos 主机。我们还需要一个被监控的主机，我将使用 Zabbix 服务器本身。

如何操作…

我将以 Zabbix 前端为例，设置业务服务监控，我们将创建一个名为 lar-book-zabbix-frontend 的新主机，并为其配置一些项目和触发器。

设置项目和触发器

如果你已跟随之前的教程进行操作，那么你应该对设置项目和触发器有很好的理解。让我们再次回顾并为我们的业务服务监控示例设置一些项目和触发器：

首先，登录到 Zabbix 前端，导航至 数据收集 | 模板，然后创建一个新模板。
点击右上角的蓝色 创建模板 按钮，按照以下内容填写页面：

图 6.78 – 新的 Zabbix 前端模板配置页面

确保点击蓝色添加按钮保存此新模板。
现在，让我们通过导航至 数据收集 | 主机来设置我们的新主机。
点击右上角的蓝色 创建主机 按钮，按照以下内容填写页面：

图 6.79 – 新的 Zabbix 前端主机配置页面

然后，通过导航至标签选项卡，添加以下标签：

图 6.80 – 新的 Zabbix 前端主机配置页面 – 标签选项卡

点击蓝色添加按钮，保存此新主机配置，并导航至 数据收集 | 模板。
编辑 Zabbix 前端通过 Zabbix 代理 模板，进入 值映射。
点击下方带有蓝色虚线的小添加按钮，并添加以下值映射：

图 6.81 – 通过 Zabbix 代理的模板 Zabbix 前端，服务状态值映射

确保点击蓝色的更新按钮。然后，返回到模板，进入项页面。
点击蓝色的创建项按钮，并添加以下内容：

图 6.82 – ICMP ping 项

在添加项之前，请确保也添加值映射值，如下所示：

图 6.83 – ICMP ping 项值映射

我们还必须进入标签选项卡，为此项添加一些标签：

图 6.84 – ICMP ping 项 – 标签选项卡

现在，点击页面底部的蓝色添加按钮。
返回到项，点击蓝色的创建项按钮以创建另一个项。按照如下方式填写：

图 6.85 – 代理 ping 项

我们还必须进入标签选项卡，为此项添加一些标签：

图 6.86 – HTTP 服务状态项 – 标签选项卡

现在，通过点击页面底部的蓝色添加按钮来保存新项。
现在我们有了两个新项，让我们进入该模板的触发器页面。
点击右上角的创建触发器按钮，并添加以下触发器：

图 6.87 – ICMP 不可达触发器配置

在标签选项卡中，我们需要添加一个新标签，表示此触发器将用于我们的 SLA 监控：

图 6.88 – ICMP 不可达触发器 – 标签选项卡

现在，让我们点击蓝色的添加按钮来添加此触发器。然后，使用右上角的创建触发器按钮创建另一个触发器。
让我们添加以下触发器：

图 6.89 – Zabbix 代理不可达触发器配置

确保通过进入标签选项卡为此触发器添加 SLA 标签：

图 6.90 – Zabbix 代理不可达触发器 – 标签选项卡

点击蓝色的添加按钮以完成此触发器的设置。

添加业务服务监控配置

这就是我们的项和触发器配置。现在，我们可以继续设置我们的业务服务监控：

首先，通过进入服务 | SLA，点击右上角的蓝色创建 SLA按钮来定义我们的 SLA 期间。我们将定义以下 SLA：

图 6.91 – 服务 | SLA – Zabbix SLA 设置

点击窗口底部的添加以保存此 SLA。
接下来，进入服务 | 服务，并使用右上角的滑动条选择编辑。
现在，点击右上角的创建服务以添加一个新服务。在这里，我们将为 Zabbix 设置添加一个新服务：

图 6.92 – 服务 | 服务 – Zabbix 设置服务

在标签选项卡中，确保添加以下内容：

图 6.93 – 服务 | 服务 – Zabbix 设置服务 – 标签选项卡

点击窗口底部的蓝色添加按钮以添加这个新服务。然后，再次点击右上角的创建服务，添加以下内容：

图 6.94 – 服务 | 服务 – Zabbix 服务器服务

在标签选项卡中，确保添加以下内容：

图 6.95 – 服务 | 服务 – Zabbix 服务器服务 – 标签选项卡

再次点击蓝色的添加按钮，然后在右上角点击创建服务。在同一级别添加另一个服务，如下所示：

图 6.96 – 服务 | 服务 – Zabbix 数据库服务

在标签选项卡中，确保添加以下内容：

图 6.97 – 服务 | 服务 – Zabbix 数据库服务 – 标签选项卡

再次点击添加来添加此服务。
最后，我们将在点击创建服务按钮后，添加 Zabbix 设置的最后一个子项：

图 6.98 – 服务 | 服务 – Zabbix 前端服务

选择高级配置，然后在新附加规则下点击添加。我们将在这里添加以下计算：

图 6.99 – 服务 | 服务 – Zabbix 前端服务，附加规则

在标签选项卡中，确保添加以下内容：

图 6.100 – 服务 | 服务 – Zabbix 数据库服务 – 标签选项卡

通过点击窗口底部的添加按钮来完成此服务的设置。
现在，我们需要添加两个服务，但这次是在 Zabbix 前端下。点击Zabbix 前端，然后再次点击创建服务，并添加以下内容：

图 6.101 – 服务 | 服务 – Zabbix 前端，ICMP 状态子服务

点击蓝色的添加按钮，然后再次点击创建服务来添加最后一个服务。
添加最后一个服务：

图 6.102 – 服务 | 服务 – Zabbix 前端，Zabbix 代理状态子服务

点击蓝色的添加按钮来添加此服务。让我们看看它是否按预期工作。

它是如何工作的……

让我们来看一下当前配置中设置的内容。我们使用了业务服务监控来监控我们 Zabbix 堆栈的一部分。将业务服务监控视为一棵树，在这里我们只创建了两个层级。我们的初始层级是 Zabbix 配置，包括我们的 Zabbix 服务器、Zabbix 数据库和 Zabbix 前端。

在 Zabbix 前端层级下，我们还有另一个层级，在这里我们定义了另外两个服务，分别表示 ICMP 和 Zabbix 代理的状态。我们只希望在 ICMP 和 Zabbix 代理都处于问题状态时，才计算 SLA：

图 6.103 – 业务服务监控树形结构示例

正如你所看到的，一旦我们开始可视化这个结构，我们就能看到一个独特的树形结构形成。在这种情况下，发生“魔法”的部分是 Zabbix 前端服务，因为这是我们定义一旦服务出现故障，SLA 应该如何变化的地方。

让我们再看一下这个层级：

图 6.104 – Zabbix 前端服务已完成

因为我们定义了服务应始终将状态设置为 OK，它将仅使用我们在附加规则部分中定义的内容。在这里，我们指定了我们只希望影响 SLA 计算：如果至少 2 个子服务的状态为高或更高。实际上，这意味着只有在 Zabbix 代理无法访问且 ICMP 出现故障时，SLA 才会下降。

我们在这里为自己设计了一个安全措施，确保如果有人停止了 Zabbix 代理，但服务器仍然可以通过 ICMP 访问，SLA 不会受到影响。

现在，让我们看看结果，我们可以用它来监控这些 SLA。在服务 | SLA 报告中，我们可以找到所有关于我们是否达成 SLA 的信息。我们可以设置过滤器，查看我们想要找的 SLA 所对应的时间段。我们将看到如下输出：

图 6.105 – 服务 | SLA 报告，所有带有我们的 SLA:24x7 标签的服务

在这里，我们可以看到我们的每月 24/7 SLA，其中预期的 SLA 为 99.9%。对于我们在 2021 年 10 月配置的 Zabbix，SLA 为 100，因此我们达到了所需的 SLA。然而，在 2021 年 11 月，我们注意到 SLA 下降到 100 以下，并且以红色清晰标示出我们未达成 SLA。

进一步深入，选择我们特定的服务 Zabbix 设置后，我们可以创建更详细的概览：

图 6.106 – 服务 | SLA 报告，Zabbix 设置的服务与我们的 SLA:24x7 标签

在这里，我们可以看到有关我们服务的正常运行时间和停机时间的所有详细信息，以及剩余的错误预算情况。

使用业务服务监控计算像这样，我们可以缩小服务中的弱点所在，同时将有用的统计数据附加到该度量值上。在这种情况下，我们使用了一个简单的 ICMP 和 Zabbix 代理触发器的例子，但在结合标签使用服务时，可能性是无穷无尽的。

还有更多...

通过业务服务监控监控服务的旧方式的主要问题之一是无法实现自动化和定制。通过使用标签，这一自动化问题已经得到大部分解决，因为我们现在可以在主机、模板或触发器级别定义标签，从而定义在业务服务监控配置中使用的内容。

在定制方面，Zabbix 为我们提供了更多的选项来进行计算：

图 6.107 – Zabbix 服务，额外的规则选项

查看这里的众多选项，我们可以看到我们有更多的空间可以操作。我们不仅可以指定要在计算中使用的子服务的确切数量，还可以使用权重和百分比，为我们提供了可能需要的选项来构建更复杂的设置。

第七章：7

使用发现自动创建

本章将重点介绍如何确保作为 Zabbix 管理员，你在主机和项目创建上的工作最少。我们将学习如何进行（或者更精确地说，完善）自动化的主机、项目触发器和图形创建。查看这里的食谱，看看我们将要发现什么。

在本章中，我们将首先学习如何通过 Zabbix agent 和 简单网络管理协议（SNMP）设置 Zabbix 网络发现。接下来，我们将设置主动 agent 自动注册。随后，我们还将讨论如何使用低级发现（LLD）自动创建 Windows 性能计数器、Java 管理扩展（JMX）和 SNMP 项目。

在本章中，我们将介绍以下食谱：

设置 Zabbix agent 主机发现
使用 Zabbix SNMP 网络发现
通过主动 agent 自动注册实现主机创建自动化
使用 Windows 性能计数器发现
发现 JMX 对象
以新的方式设置 Zabbix SNMP 发现
使用 LLD 和自定义 JSON 创建主机

技术要求

由于本章主要讲解主机和项目的发现，除了我们的 Zabbix 服务器，我们还需要一台新的 Linux 主机和一台 Windows 主机。这两台主机都需要安装 Zabbix agent 2，但暂时不需要配置。

此外，我们还需要配置好的 JMX 主机，如 第三章 中所述，Zabbix 监控设置，以及一台已设置 SNMP 的新主机。要了解如何设置一个 SNMP 监控的主机，请查看 第三章 中的 使用旧方式监控 SNMP 食谱，Zabbix 监控设置。

设置 Zabbix agent 网络发现

很多 Zabbix 管理员大量使用 Zabbix agent，因此花费很多时间手动创建 Zabbix agent 主机。也许他们不知道如何设置 Zabbix agent 发现，也许他们还没有时间设置，或者他们只是偏好这种方式。如果你已经准备好开始使用 Zabbix agent 发现，那么在这个食谱中我们将学习如何轻松设置它。

准备工作

除了我们的 Zabbix 服务器，在本章的介绍中，我提到我们将需要两台（空的）主机，并且安装了 Zabbix agent 2：一台 Windows 主机和一台 Linux 主机。如果你不知道如何安装 Zabbix agent 2，请参考 第三章，Zabbix 监控设置，或者查看 Zabbix 文档 www.zabbix.com/documentation/current/en/manual/concepts/agent2。

我们给服务器分配以下主机名：

lar-book-disc-lnx：适用于 Linux 主机（使用 Zabbix agent 2）
lar-book-disc-win：适用于 Windows 主机（使用 Zabbix agent 2）

如何操作…

按照以下步骤操作：

让我们从登录到我们的lar-book-disc-lnx Linux 主机开始，编辑以下文件：
```
vim /etc/zabbix/zabbix_agent2.conf
```
现在，确保你的 Zabbix agent 2 配置文件至少包含以下行：
```
Hostname=lar-book-disc-lnx
```
对于你的 Windows Zabbix agent，重要的是执行相同的操作。编辑以下文件：
```
C:\Program Files\Zabbix Agent 2\zabbix_agent2.conf
```
现在，通过编辑以下行来更改主机名：
```
Hostname=lar-book-disc-win
```
接下来，在我们的 Zabbix 前端，导航至数据采集 | 发现，在此页面上，我们点击创建发现规则来创建一个具有以下设置的规则：

图 7.1 – Zabbix agent 主机的发现规则页面

重要提示

在本示例中，我们使用的更新间隔为5分钟。由于这可能会占用你服务器的很多资源，因此请确保根据你的生产环境调整该值。例如，一小时可能是一个更合适的生产值，以确保我们对 Zabbix 进程施加较少的负载。根据我们扫描的 IP 范围的大小和你希望多快发现设备，我们可以调整此值。

点击蓝色的添加按钮继续。
在设置完发现规则后，我们还需要设置一个操作来实际创建带有正确模板的主机。导航至警报 | 操作 | 发现操作：

图 7.2 – 警报 | 操作 | 发现操作

在这里，我们将点击右上角的创建操作按钮，并在下一页填写以下信息：

图 7.3 – Zabbix agent 主机的发现操作创建页面

小贴士

在创建 Zabbix 操作时，重要的是记住条件的创建顺序。前面截图中看到的标签将按创建顺序添加。这意味着，如果你对所有操作保持相同的创建顺序，跟踪你的 Zabbix 操作会更加容易。

接下来，点击操作标签。在这里我们将添加以下内容：

图 7.4 – Zabbix agent 主机的操作页面

这就是 Linux agent 的设置。点击蓝色的添加按钮，我们继续进行 Windows 发现规则的设置。
导航至数据采集 | 主机组。通过点击右上角的创建主机组来为我们的 Windows 主机创建一个主机组，并填写组名：

图 7.5 – Windows 服务器主机的创建主机组页面

点击蓝色的添加按钮并导航至警报 | 操作。
再次进入发现操作并点击创建操作。这次我们将填写相同的内容，但针对我们的 Windows 主机：

图 7.6 – Windows Zabbix 代理的发现操作创建页面

在点击添加之前，我们还需要填写操作页面，内容如下截图所示：

图 7.7 – Windows Zabbix 代理的操作页面

现在，我们可以点击蓝色的添加按钮，我们的第二个发现操作已经显示。
继续到监控 | 发现。在这里我们可以看到我们的主机是否以及何时被发现：

图 7.8 – 监控 | 发现页面

提示

使用监控 | 发现页面密切关注您期望出现在 Zabbix 设置中的主机。它非常有用，可以跟踪新主机的加入，并查看用于创建主机的 Zabbix 发现规则。

它是如何工作的…

网络发现最初可能并不难设置，但有很多选项需要配置。在这个示例中，我们选择使用agent.hostname键作为我们的检查。我们根据 Zabbix 代理配置文件中的配置创建 Zabbix 主机名。

发生的情况是，Zabbix 网络发现找到我们的主机并执行我们的检查。在这种情况下，检查是Zabbix 代理使用的主机名是什么？ 这些信息，加上我们的 IP 地址，然后触发操作。我们的操作接着执行我们配置的检查：

主机名是否包含lnx或win？
发现状态是否为UP？
服务类型是否为Zabbix Agent？

如果所有这些检查都为真，我们的操作将创建我们新发现的主机，具体如下：

我们配置的主机组和默认的已发现的主机主机组
我们在操作中配置的模板

我们将最终获得两个新创建的主机，所有设置都已正确配置：

图 7.9 – 数据收集 | 主机页面，展示了我们的新主机，Windows 和 Linux

还有更多…

通过配置文件设置创建主机并不总是最合适的方式，但它是使用网络发现的一个坚实起点。

如果您希望拥有一个更灵活的环境，甚至不需要触及 Zabbix 代理配置文件，那么您可能希望在发现规则中使用不同的检查。可以查看 Zabbix 文档中哪些键可以用来构建不同的发现规则，网址：www.zabbix.com/documentation/current/en/manual/config/items/itemtypes/zabbix_agent。

使用 Zabbix SNMP 网络发现

如果你需要处理大量的 SNMP 设备，但不总是想手动设置监控，网络发现就是你需要的方式。Zabbix 网络发现使用与 Zabbix 代理发现相同的功能，但配置方法不同。

准备就绪

要开始使用网络发现，我们需要一个可以使用 SNMP 进行监控的主机。如果你不知道如何设置这样的主机，可以查看 第三章 中的使用传统方式进行 SNMP 监控食谱，设置 Zabbix 监控部分。我们还需要我们的 Zabbix 服务器。

如何操作...

按照以下步骤操作：

首先，登录到你新的 SNMP 监控主机并将主机名更改为以下内容：
```
hostnamectl set-hostname lar-book-disc-snmp
exec bash
```
然后，使用以下命令重启 SNMP 守护进程：
```
systemctl restart snmpd
```
现在，导航至数据收集 | 发现，并点击右上角的创建发现规则。
我们将创建一个新的 SNMP 发现规则，选择 SNMP 对象标识符（OID）检查类型。首先填写名称和IP 范围字段，像这样：

图 7.10 – 数据收集 | 发现，SNMPv2 发现规则创建页面

确保在IP 范围字段中填写你自己的 IP 范围。
现在，我们要创建我们的 SNMP 检查。点击检查旁边的添加，你将看到以下弹出窗口：

图 7.11 – 数据收集 | 发现，发现检查创建弹出窗口

我们希望检查类型为SNMPv2 代理，并希望填写我们的社区和一个有用的 OID，在本例中将是系统名称的 OID。填写如下：

图 7.12 – 数据收集 | 发现，带有 SNMPv2 检查的发现检查创建弹出窗口

重要提示

请注意，我们的检查类型不是与 SNMP 版本无关的。我们有三种 SNMP 版本，因此有三种不同的检查类型可以选择，这与我们在 Zabbix 7 主机界面上选择 SNMP 接口的方式不同。

再次点击添加，然后填写页面的其余部分，如下所示：

图 7.13 – 数据收集 | SNMPv2 代理的发现页面

最后但同样重要的是，点击页面底部的添加按钮。这就完成了我们 Zabbix 发现规则的创建。
我们还需要一个操作来从发现规则中创建我们的主机。导航至警报 | 操作，然后使用下拉菜单选择发现操作，点击创建操作。
我们将填写以下信息：

图 7.14 – 警报 | 操作，SNMPv2 代理的操作创建页面

在点击添加之前，导航到操作并填写此页面的以下详细信息：

图 7.15 – 警报 | 操作，SNMPv2 代理的操作创建操作选项卡

现在，点击添加，并导航到监控 | 发现，查看我们的主机是否被创建：

图 7.16 – SNMPv2 代理的监控 | 发现页面

它是如何工作的…

在这个配方中，我们创建了另一个发现规则，但这次是针对 SNMP。正如你所注意到的，原则保持不变，但应用稍有不同。

当我们创建这个 Zabbix 发现规则时，我们给它添加了两个检查，而不是前一个配方中只做一个检查。我们在 .1.3.6.1.2.1.1.5.0 SNMP OID 上创建了一个检查，通过 SNMP 检索设备的主机名。然后，我们将从系统中检索到的主机名放入 Zabbix，作为系统的 Zabbix 主机名。

我们还在 .1.3.6.1.2.1.25.1.4.0 SNMP OID 上创建了一个检查。此检查将检索以下字符串（如果存在）：

"BOOT_IMAGE=(hd0,gpt2)/vmlinuz-4.18.0-193.6.3.el8_2.x86_64 root=/dev/mapper/cl-root ro crashkernel=auto resume=/dev/mapper/cl-swa"

如果字符串存在，这意味着该主机的启动镜像是 Linux。这是我们如何通过检索多个 OID 在 Zabbix 发现规则中进行多个检查的一个完美示例。如果我们监控的是网络设备，比如，我们可以选择一个 OID 来判断它是 Cisco 还是 Juniper 设备。我们可以用任何 OID 替换 .1.3.6.1.2.1.25.1.4.0 并进行轮询。然后，我们将根据收到的结果（Juniper 或 Cisco）创建操作，并相应地添加我们的模板。

重要提示

创建 Zabbix 发现规则时，对 SNMP 结构的一般知识非常重要。我们需要确保使用正确的 SNMP OID 作为检查。务必做好研究，使用 SNMP walk，并规划出要使用的 OID 以发现 SNMP 代理。这样，你就能构建出一个稳固的监控基础设施。

使用主动代理自动注册自动化主机创建

使用发现功能来设置 Zabbix 代理是自动化主机创建的一个非常有用的方法。但如果我们想进一步直观地了解我们的环境，并进行更多的自动化呢？这时我们可以使用 Zabbix 的一个功能叫做主动 代理自动注册。

准备就绪

对于这个配方，我们将需要一台新的 Linux 主机。我们将这台主机命名为 lar-book-lnx-agent-auto。确保在此主机上安装 Zabbix agent 2。除了这台新主机，我们还需要我们的 Zabbix 服务器。

如何操作…

让我们从登录到新创建的 lar-book-lnx-agent-auto 主机并修改以下文件开始：
```
vim /etc/zabbix/zabbix_agent2.conf
```
然后我们将编辑文件中的以下行。确保在该行输入你的 Zabbix 服务器 IP：
```
ServerActive=10.16.16.152
```
如果我们希望手动在文件中设置主机名，我们还可以更改文件中的以下行：
```
Hostname=lar-book—lnx-agent-auto
```
然而，这并不是强制要求，因为如果未填写，Zabbix 代理将使用系统主机名。
接下来，我们将导航到我们的 Zabbix 前端，进入警报 | 操作。
使用下拉菜单进入自动注册操作，如下截图所示：

图 7.17 – 警报 | 操作页面下拉菜单

现在，我们将点击右上角的蓝色创建操作按钮来创建一个新的操作。
填写名称字段，然后点击添加文本链接：

图 7.18 – 警报 | 操作，创建新操作页面

我们可以在这里设置条件，只注册具有特定主机名的主机。我们可以通过如下填写窗口来实现：

图 7.19 – 创建操作 | 新条件，针对 lar-book-lnx 主机

您的页面现在应该如下所示：

图 7.20 – 创建操作页面，已填写我们为 lar-book-lnx 主机提供的信息

提示

我们可以为不同类型的主机设置条件。例如，如果我们想添加 Windows 主机，我们可以设置一个带有不同主机名过滤器的新操作。这样，即使使用自动注册，也能轻松维护正确的组和模板。

在点击蓝色的添加按钮之前，我们先进入操作标签页。
点击添加文本链接，您将看到以下窗口：

图 7.21 – 发送消息操作，针对 lar-book-lnx 主机

创建一个操作，将主机添加到Linux 服务器主机组：

图 7.22 – 添加到主机组操作创建

创建一个操作，将主机添加到Zabbix 代理的Linux 活跃模板中：

图 7.23 – 链接到模板操作创建

您最终的操作页面应该如下所示，我们可以点击蓝色的添加按钮：

图 7.24 – 操作页面，已填写我们为 lar-book-lnx 主机提供的信息

导航到数据收集 | 主机，我们可以看到我们新的活跃自动注册主机：

图 7.25 – 数据收集 | 主机页面，显示主机 lar-book-lnx-agent-auto

如何操作…

主动代理自动注册是一种让主机自行注册的可靠方法。一旦在 Zabbix 服务器或代理的配置文件中设置了ServerActive=行，主机代理将开始向 Zabbix 服务器或代理请求配置数据。Zabbix 服务器会收到这些请求，如果在 Zabbix 中设置了某个动作（就像我们在本教程中所做的），主机将自动注册到 Zabbix。

图 7.26 – 主机自动注册过程

我们可以使用这个功能做一些非常酷的自动化工作。我们可以创建一个脚本，将正确的ServerActive=行填充到特定 IP 池中主机的 Zabbix 代理配置文件里。

使用 Ansible 设置新主机也会变得非常简单。我们可以通过 Ansible 自动化 Zabbix 代理的安装，同时也可以使用 Ansible 在/etc/zabbix/zabbix_agent2.conf文件中添加ServerActive=行。从这里开始，我们的 Zabbix 服务器自动注册动作将处理其余部分。

Zabbix 代理自动注册是实现零接触监控环境的完美方式，这样我们就可以确保所有最新的主机始终保持最新状态。

还有更多内容…

并不是每个公司使用的主机名都能反映机器的操作系统或其他属性。这时，Zabbix HostMetadata 就显得非常有用。我们可以将此字段添加到主动 Zabbix 代理配置中，以反映机器的属性。

之后，我们可以在 Zabbix 发现动作中使用HostMetadata，以执行与主机名相同类型的过滤。

我们还可以在 Zabbix 代理配置文件中找到HostInterface和HostInterfaceItem参数，它们用于自动注册。主机将使用指定的 IP 或 DNS 名称作为其 Zabbix 代理接口的 IP 或 DNS，如在 Zabbix 前端所示。我们还可以使用此功能，在使用自动注册创建主机时启用被动代理监控。

使用 Windows 性能计数器发现

在 Zabbix 7 中，已经可以发现 Windows 性能计数器。在本教程中，我们将介绍如何发现 Windows 性能计数器并在我们的环境中使用它们。

发现 Windows 性能计数器最初看起来可能有点复杂，因为它同时使用了 Windows 和 Zabbix 特有的概念。然而，一旦完成这个教程，你将会完全了解如何设置它。

准备工作

在本章中，我们将lar-book-disc-win主机添加到我们的设置中，这也是我们在 Zabbix 代理发现过程中使用的主机。我们可以重复使用此主机来轻松发现 Windows 性能计数器。

当然，我们还需要我们的 Zabbix 服务器。

如何实现…

首先，导航到 数据收集 | 模板，并通过点击右上角的 创建模板 来创建一个新的模板。
创建以下模板：

图 7.27 – Windows 性能通过 Zabbix 代理模板创建

点击蓝色的添加按钮，这将带你回到 数据收集 | 模板。选择新模板。
现在，在继续模板之前，导航到你的 Windows 前端并打开 perfmon.exe：

图 7.28 – Windows 搜索栏 – perfmon.exe

这样做会打开以下窗口：

图 7.29 – Windows perfmon.exe

让我们点击 性能监视器，然后点击绿色的 + 图标。这将显示所有可用的 Windows 性能计数器。
首先，我们使用 处理器 计数器。
返回到 Zabbix 中的 数据收集 | 模板页面，编辑我们新的 Windows 性能通过 Zabbix 代理模板。
当你进入 编辑模板 页面时，点击模板名称旁边的 发现规则。
点击右上角的 创建新发现规则，并添加以下规则：

图 7.30 – 创建 LLD 规则页面 – 发现计数器处理器

重要提示

在这个示例中，我们使用 1 分钟的更新间隔。由于这可能会占用服务器大量资源，请确保根据你的生产环境调整此值。例如，一个小时是更适合生产环境的值。

点击底部的蓝色添加按钮，然后点击我们新的 发现计数器处理器 发现规则。
点击 项原型，然后在右上角点击 创建项原型。我们将创建以下项原型：

图 7.31 – CPU 实例 C1 时间项原型创建

在标签选项卡中，别忘了添加以下一些新标签：

图 7.32 – 标签选项卡

保存新的 项原型，然后转到 数据收集 | 主机，并点击 lar-book-disc-win。
添加我们的 Windows 性能通过 Zabbix 代理模板：

图 7.33 – 将 Windows 性能通过 Zabbix 代理模板添加到 lar-book-disc-win

点击蓝色的更新按钮后，我们可以导航到监控 | 最新数据。添加以下过滤条件：

图 7.34 – 主机 lar-book-disc-win 的最新数据过滤

现在我们可以看到我们新创建的三个项目：

图 7.35 – 我们的主机 lar-book-disc-win 的监控 | 最新数据页面

工作原理…

Windows 性能计数器已经存在了很长时间，并且对于任何想要使用 Zabbix 监控 Windows 机器的人来说，它们都是非常重要的。将 LLD 与 Windows 性能计数器结合使用，使构建坚固的 Windows 监控变得更加容易和灵活。

在本教程中，我们通过添加带有 perf_instance.discovery[Processor] 项键的发现规则，创建了一个非常简单但有效的 Windows 性能计数器发现规则。此项键中的[Processor]部分与我们看到的perfmon.exe窗口直接相关。如果我们查看以下截图，已经可以看到Processor列出：

图 7.36 – perfmon.exe | 添加计数器 – 处理器

当我们的发现规则轮询此项键时，Zabbix 代理将返回以下值：

[
   {
      "{#INSTANCE}":"0"
   },
   {
      "{#INSTANCE}":"1"
   },
   {
      "{#INSTANCE}":"_Total"
   }
]

这个值意味着 Zabbix 会用三个值填充{#INSTANCE}宏：

0
1
_ 总计

然后，我们可以通过在项目原型中使用{#INSTANCE}宏来使用这三个值，正如我们在这里所做的那样：

图 7.37 – 我们创建的项目原型，CPU C1 时间

然后，它会创建三个带有宏值的项目，使用正确的键来监控计数器的第二部分 – % C1 时间。如果你在 perfmon.exe 文件中展开窗口，你可以看到我们可以添加到项目原型中的所有不同计数器，从而监控更多 Windows 性能计数器：

图 7.38 – Perfmon.exe | 添加计数器 – 处理器（展开）

发现 JMX 对象

在第三章，设置 Zabbix 监控中，我们已经讲解了如何在标题为设置 JMX 监控的教程中设置 JMX 监控。不过，我们还没有讲到如何发现 JMX 对象。

在这个教程中，我们将讲解如何使用 LLD 设置 JMX 对象，并且完成本教程后，你将知道如何设置它。

准备工作

对于本教程，我们将需要你在第三章，设置 Zabbix 监控中设置的 JMX 主机。确保在进行本教程之前完成该教程。

我们还需要我们的 Zabbix 服务器以及名为 lar-book-jmx 的 Zabbix JMX 主机。

如何操作…

让我们从登录到 Zabbix 前端并导航到数据收集 | 模板开始这个教程。
点击右上角的创建模板，创建一个新的模板。填写以下字段：

图 7.39 – App Apache Tomcat JMX 发现模板创建

点击蓝色的添加按钮后，你将返回到数据收集 | 模板。点击你新创建的App Apache Tomcat JMX 发现模板。
我们现在将添加 JMX 发现规则。点击发现规则，位于模板名称旁边。
现在，点击创建发现规则并填写以下字段：

图 7.40 – 发现 JMX 对象 MemoryPool 发现规则创建

点击页面底部的蓝色添加按钮。然后，点击新创建的发现 JMX 对象 MemoryPool 发现规则旁边的项目原型。
我们现在将在右上角点击创建项目原型按钮，并创建以下项目原型：

图 7.41 – 项目原型创建页面 – MemoryPool 内存类型

此外，确保在标签选项卡中添加一个新标签，名称为组件，值为memory pool：

图 7.42 – 标签选项卡 – MemoryPool 内存类型

让我们点击蓝色的添加按钮，然后继续。
转到数据收集 | 主机，点击lar-book-jmx。我们将向该主机添加模板。
点击模板并添加模板，如下所示：

图 7.43 – 数据收集 | 主机 – 向 lar-book-jmx 主机添加模板

点击蓝色的更新按钮。
当我们现在导航到监控 | 最新数据时，我们将选择lar-book-jmx作为主机，并选择组件作为标签，其值为memory pool，如下所示：

图 7.44 – 监控 | 最新数据页面过滤器 – lar-book-jmx 主机

我们接着会看到以下结果：

图 7.45 – 具有我们结果的 lar-book-jmx 主机的监控 | 最新数据页面

它是如何工作的……

初次监控 JMX 应用程序可能会让人感到相当艰巨，因为在构建自己的 LLD 规则时需要处理大量的工作。但现在，既然你已经为 JMX 构建了第一个 LLD 规则，结构就变得清晰了。

首先，对于我们的发现规则，我们选择了项目键：

jmx.discovery[beans,"*:type=MemoryPool,name=*"]

MemoryPool是我们在 Java 中称之为MBean的东西。我们轮询这个 MBean 对象以获取多个 JMX 对象，并相应地填充宏。

我们选择了 name=* 对象来填充此发现规则中的 {#JMXNAME} 宏。然后，我们的宏被用在项目原型中来创建项目。

然后我们的项目就像这样创建：

图 7.46 – 我们的 JMX 监控主机上的项

如果我们查看项目的键，可以看到我们在每个具有不同名称的 MemoryPool 上轮询 Type JMX 属性。

这就是我们轻松创建 JMX LLD 规则的方法。

还有更多…

如果你不熟悉 MBeans，确保查阅 Java 文档。这将帮助你理解 MBeans 是什么，以及如何利用它们来监控 JMX 属性：docs.oracle.com/javase/tutorial/jmx/mbeans/index.html。

提示

在深入使用 JMX 对象发现之前，深入阅读前面的 JMX 对象文档。文档中有大量信息，它将大大提高你创建这些 LLD 规则的技能。

使用新方法设置 Zabbix SNMP LLD

Zabbix 6.4 对我们 Zabbix 环境中使用 SNMP 进行了彻底的更新。尽管旧的方式仍然可用（并在本书中有解释），但使用新的方法来构建 SNMP 监控可能会更好，因为它将实际使用 GetBulk 请求。这使得 SNMP 监控更高效，并且对我们从中收集数据的 SNMP 设备负担更小。

准备工作

在开始使用本教程之前，请先阅读第三章，以新方式设置 SNMP 监控。我们将需要那一章的知识来设置 SNMP LLD 发现，同时我们也将使用那一章中的一些主机和项目。确保你已经具备以下内容：

你的 Zabbix 环境
lar-book-snmp_bulk 主机如在第三章中设置，设置 Zabbix 监控

如何操作…

正如我们在第三章中设置了 SNMP 服务器以开始监控一样，设置 Zabbix 监控，我们可以立即在前端开始。在第五章，构建你自己的结构化模板，我们还学习了如何为所有监控创建模板，所以让我们从这里开始。按照以下步骤操作：

在 Zabbix 前端，导航到 数据收集 | 模板并点击右上角的 创建模板。我们将按如下方式创建一个新模板。

图 7.47 – 通过 SNMP 模板的 BOOK Linux

另外，确保切换到标签选项卡，根据新的标签策略添加一些标签：

图 7.48 – 模板 BOOK Linux by SNMP 宏选项卡

在窗口底部，点击我们之前设置的lar-book-snmp_bulk主机。让我们首先使用批量更新功能将值映射复制到我们的新模板中。
在列表中选择你的模板，勾选复选框，然后点击窗口底部的批量更新按钮。

图 7.49 – 批量更新

在批量更新中，切换到值映射标签，勾选复选框，然后点击小的带点下划线的从主机添加按钮。
找到你的lar-book-snmp_bulk主机，并从列表中选择接口启用/禁用。它应该是这样的。

图 7.50 – 批量更新 – 从主机添加值映射

现在，你可以点击窗口底部的更新按钮来添加此值映射。
现在，我们来复制模板中的现有项目。进入数据收集 | 主机，然后进入项目，选择lar-book-snmp_bulk。勾选我们之前创建的两个项目，并点击窗口底部的复制按钮。

图 7.51 – 需要复制的 lar-book-snmp_bulk 项目

将目标类型设置为模板，并输入BOOK Linux by SNMP。选择它后点击复制。

图 7.52 – lar-book-snmp_bulk 项目复制窗口

现在，返回到数据收集 | 模板，并点击你的BOOK Linux by SNMP模板中的发现。
在右上角，点击创建发现规则按钮。我们将在此创建以下 LLD 规则。

图 7.53 – 发现规则

我们将创建依赖项类型的 LLD 规则，以确保我们使用之前在SNMP 接口批量项目上收集的数据。然而，所有 LLD 数据必须以 JSON 数据格式呈现，因此让我们确保首先转换数据。

切换到预处理标签并添加以下内容。

图 7.54 – 预处理

现在，点击窗口底部的添加按钮来添加 LLD 规则。然后，进入项目原型以自动方式添加我们的第一个项目。
在右上角，点击创建项目原型，并创建以下项目原型：

图 7.55 – 项目原型

别忘了在标签标签中添加你的标签，然后再添加项目原型：

图 7.56 – 项目标签

我们还需要一个预处理步骤来提取正确的信息，因此让我们通过进入预处理标签来添加这个步骤：

图 7.57 – 预处理

现在，点击页面底部的大添加按钮以完成设置此新项目原型。
我们还没有在主机上使用该模板，所以让我们导航到 数据收集 | 主机并点击我们的 lar-book-snmp_bulk 主机。然后，添加模板。

图 7.58 – 将 SNMP 模板 BOOK Linux 添加到 lar-book-snmp_bulk

点击窗口底部的更新按钮以添加模板。
LLD 规则现在应该已经添加并执行。让我们查看是否已创建项目，方法是导航到监控 | 最新数据 并按 lar-book-snmp_bulk 主机进行筛选。请记住，项目显示出来可能需要大约一分钟，收集数据可能需要另一分钟。

图 7.59 – lar-book-snmp_bulk – LLD 规则后的最新数据

它是如何工作的……

那么，这个新的 LLD 发现是如何工作的呢？正如你可能已经注意到的，我们仍然使用与 第三章 中相同的项目，设置 Zabbix 监控。OID .1.3.6.1.2.1.2.2.1 下的所有值仍然以批量方式进行收集。为了回顾大宗度量数据收集，我们再看一下这些数据：

图 7.60 – lar-book-snmp_bulk 原始大宗度量数据

我们在 SNMP walk 项目中已经拥有所有所需的数据。我们之后添加的所有项目和发现规则都在使用这些数据，并通过 Zabbix 服务器（或代理）预处理过程对其进行解析。

在 LLD 的情况下，我们需要添加 SNMP walk 到 JSON 预处理步骤，正如你在 图 7**.54 中所看到的，这将把正常的 SNMP walk 数据转换为 JSON 数据格式。之后它看起来会像这样：

图 7.61 – 将 lar-book-snmp_bulk 原始大宗度量数据转换为 JSON

它通过查找 OID .1.3.6.1.2.1.2.2.1.2 来收集我们想要的值，并将这些值添加到 {#IFDESCR} 发现宏中。它还保留了 SNMP 索引，并将其与 {#SNMPINDEX} 宏一起使用。

现在，剩下的就是设置我们的项目原型，并使用相同的原始 SNMP walk 项目，按照预处理步骤中的 SNMP walk 值来提取数据，正如我们在图 7**.57中所见。我们还需要确保每个项目都是唯一的，因此我们添加了 {#SNMPINDEX} 宏来查找每个即将创建的项目的正确值。

就这样，我们在 SNMP 接口批量 项目中执行了一个单一的 SNMP GetBulk 调用，并利用 Zabbix 依赖项和预处理功能将其进一步拆分。

使用 LLD 和自定义 JSON 创建主机

从 LLD 创建主机与从 LLD 规则创建其他内容的方式相同。我们只需要向 Zabbix 安装传递一个兼容的 JSON 格式数据集，并使用该数据创建新主机。然而，从 Zabbix 6.2 版本开始，发生了一些变化。通过 LLD 创建的主机现在可以在创建后进行自定义，所以，让我们来看看如何操作以及它是如何工作的。

准备工作

对于本教程，我们需要两样东西：任何 Zabbix 7 安装和一个包含主机及其数据的兼容 JSON 格式数据集。以下是一些可以用来从 LLD 创建主机的优秀默认模板示例：

VMware 主机和虚拟化管理程序
Kubernetes
Azure 和 AWS

然而，对于本示例，我们将使用一个自定义数据集，你可以在 GitHub 上找到： github.com/PacktPublishing/Zabbix-7-IT-Infrastructure-Monitoring-Cookbook/blob/main/chapter07/lldhosts.json。

了解 Zabbix 发送器、依赖项和预处理的基本概念也非常重要。我建议首先阅读第三章，《设置 Zabbix 监控》中的以下内容：

创建 Zabbix 简单检查和 Zabbix trapper
处理计算和 依赖项
使用 Zabbix 预处理来修改 项值

如何操作…

让我们开始构建这个新的 LLD 规则，使用自定义 JSON 数据集。为此，我们首先需要构建一个 JSON 文件，或者从我们的一些数据源中获取。我们已经为你准备好了一个：

首先，让我们查看位于此处的 JSON 文件：

raw.githubusercontent.com/PacktPublishing/Zabbix-7-IT-Infrastructure-Monitoring-Cookbook/main/chapter07/lldhosts.json
接下来，让我们登录到 Zabbix 服务器 CLI，确保我们已经安装了 Zabbix 发送器应用程序。我们将使用它将文件发送到 Zabbix 环境：

对于基于 RHEL 的系统，请使用以下内容：
```
dnf install zabbix-sender
```
对于 Ubuntu 系统，请使用以下内容：
```
apt install zabbix-sender
```
让我们设置zabbix-sender应用程序，每分钟将此 JSON 文件发送到我们的系统。为了简化操作，我们将暂时使用 CronJob：
```
crontab -e
```

将以下内容添加到 CronJob 文件：

* * * * * zabbix_sender -z 127.0.0.1 -s lar-lldhost-creation -k lldhosts.raw -o '[{"vmname":"lar-lld-host1","vmip":"10.16.16.200","vmlocation":"Amsterdam"},{"vmname":"lar-lld-host2","vmip":"10.16.16.201","vmlocation":"London"},{"vmname":"lar-lld-host3","vmip":"10.16.16.202","vmlocation":"Chicago"},{"vmname":"lar-lld-host4","vmip":"10.16.16.203","vmlocation":"Tirana"}]' >/dev/null 2>&1

上述内容只是 CronJob + Zabbix 发送器命令的组合，构建方式如下：

* * * * *
zabbix_sender -z 127.0.0.1 -s lar-lldhost-creation -k lldhosts.raw -o
FILE CONTENT FROM GITHUB
>/dev/null 2>&1

现在，让我们切换到 Zabbix 前端，在这里我们将添加一个主机来接收来自 JSON 文件的数据。
要添加主机，请导航到数据采集 | 主机，然后点击右上角的创建主机按钮。添加以下主机：

图 7.62 – Zabbix 主机创建窗口，展示 lar-lldhost-creation 主机

点击窗口底部的添加按钮，完成此主机的创建。然后你将被带回 数据收集 | 主机。
在此页面上，点击我们刚创建的 lar-lldhost-creation 主机旁边的项目。在右上角，点击 创建项目，然后创建以下项目：

图 7.63 – lar-lldhost-creation 主机的 Zabbix 项目创建页面

确保还要为项目添加标签：

图 7.64 – lldhosts.raw 项目的 Zabbix 标签创建页面

现在，按下页面底部的大添加按钮。经过 Zabbix 服务器重新加载配置缓存后，我们应该在一两分钟内看到该项目的数据开始流入。
同时，我们可以开始构建 LLD 规则。仍在主机编辑页面时，导航至 发现规则。点击右上角的 创建发现规则。我们将添加以下内容：

图 7.65 – 来自 hosts.from.json 的 Zabbix LLD 规则创建页面

接下来，点击 LLD 宏，让我们定义一些从文件中使用的宏：

   {
      "vmname":"lar-lld-host1",
      "vmip":"10.16.16.200",
      "vmlocation":"Amsterdam"
   }

我们将使用 JSONPath 将前面的数据块转换为以下内容：

   {
      "{#VMNAME}":"lar-lld-host1",
      "{#VMIP}":"10.16.16.200",
      "{#VMLOCATION}":"Amsterdam"
   }

为此，切换到名为 LLD 宏 的标签页，并定义以下内容：

图 7.66 – 来自 hosts.from.json 的 Zabbix LLD 宏标签页

现在，我们可以点击此页面底部的大添加按钮，LLD 规则就创建好了。
然而，要对 LLD 规则进行操作，我们必须创建一个新的主机原型。为此，点击 主机原型，然后点击右上角的 创建主机原型。我们将添加以下内容：

图 7.67 – Zabbix LLD 主机原型创建页面

如你所见，我们使用宏来创建 虚拟机（VM）的名称，并创建一个唯一的主机组。

我们还将通过切换接口至 自定义，按下小的带下划线的添加按钮，并添加以下内容，来使用宏定义接口：

图 7.68 – 带有自定义接口的 Zabbix LLD 主机原型创建页面

现在，你可以点击页面底部的大添加按钮。这将添加主机原型。
现在，导航到 数据收集 | 主机，在等待几分钟后，我们应该能看到新创建的主机：

图 7.69 – 通过 LLD 创建的 Zabbix 主机

它是如何工作的…

LLD 是 Zabbix 世界中的一个广泛主题，因此，它可能变得相当复杂。正如我们所看到的，我们在这个示例中使用了一个完全自定义的 JSON 文件。

在我们深入了解结果之前，请记住，定制的 JSON 可以从任何地方创建。这可以是一个自定义的（Python、Perl、PowerShell）脚本，一些 API 检查，或其他任何东西。另外，有时候 JSON 是由 Zabbix 环境本身提供的。只要我们遵循以下格式（无论文件中是否直接包含宏），任何内容都可以解析为 Zabbix LLD 规则：

[
   {
      "vmname":"lar-lld-host1",
      "vmip":"10.16.16.200",
      "vmlocation":"Amsterdam"
   },
   {
      "vmname":"lar-lld-host2",
      "vmip":"10.16.16.201",
      "vmlocation":"London"
   },
   {
      "vmname":"lar-lld-host3",
      "vmip":"10.16.16.202",
      "vmlocation":"Chicago"
   },
   {
      "vmname":"lar-lld-host4",
      "vmip":"10.16.16.203",
      "vmlocation":"Tirana"
   }
]

那么，我们到底通过前面的 JSON 文件创建了什么呢？嗯，我们使用了vmname、vmip和vmlocation这几个 JSON 键及其值来创建一些完全自动化的定制主机。为了做到这一点，首先，我们必须使用JSONPath将 JSON 键解析为每个 LLD 规则所需的 LLD 宏：

图 7.70 – 使用 JSONPath 将键转换为 LLD 宏

这将把vmip转换为{#VMIP}，vmlocation转换为{#VMLOCATION}，vmname转换为{#VMNAME}。JSONPath正在搜索这些键，而 Zabbix 则为我们将它们转换为宏。

然后，我们在 LLD 主机原型中使用这些宏来定义每个主机的值：

图 7.71 – 我们的 LLD 宏在使用中

结果是我们的主机被创建，并且设置正确：

图 7.72 – 我们的 LLD 规则创建的 lar-lld-host4

如你所见，我们的主机名已填写，定制的主机组也已设置。我们还定义了一个具有正确 IP 的接口。我们现在将在该接口上使用该 IP，使用我们连接到主机的模板开始监控 Zabbix 代理。

还有更多…

等等 – 还有更多！从 Zabbix 6.2 开始，主机原型实际上变得非常有用，引入了一些重大变化。现在，可以完全自定义主机设置，例如宏、标签，甚至模板。

这意味着即使主机是从原型创建的，我们仍然可以自定义监控。例如，如果你在 VMware 中发现了你的虚拟机，我们可以自定义 LLD 规则，使其也能自动开始使用 Zabbix 代理进行监控。如果你之后想要覆盖某些宏来更改触发器阈值，假设改变某个触发器的阈值，实际上你是可以做到的。

但请记住，如果你删除了发现主机的主机或 LLD 规则，所有已发现的主机也会被删除。在删除任何内容时要小心，并且随时准备好备份！

第八章：8

设置 Zabbix 代理

你不能谈论 Zabbix 而不谈论 Zabbix 代理——最初它是一个不错的补充，但现在已经是必不可少的了。任何期望设置中型或大型 Zabbix 环境的人都需要代理。使用代理的主要原因是可扩展性，因为 Zabbix 代理将数据收集和预处理的负担从 Zabbix 服务器上卸载出去。这样，我们可以进一步扩展 Zabbix 环境，而且更为轻松。此外，代理还可以通过在本地网络中收集数据，然后将其发送到 Zabbix 服务器，为你提供额外的安全层，分散你对数据收集的访问需求，而不是将其集中在单个 Zabbix 服务器上。

在本章中，我们将首先学习如何设置 Zabbix 代理。然后我们将学习如何使用被动和主动 Zabbix 代理，以及如何使用这两种形式的 Zabbix 代理来监控主机。Zabbix 7 还引入了将代理添加到负载均衡池中的功能，我们将在本章中介绍这个新特性。我们还将讨论一些使用代理进行的 Zabbix 网络发现，并学习如何监控 Zabbix 代理以保持其健康。在这些教程完成后，你将没有更多的借口不去设置代理，因为我们将在本章中涵盖代理使用的几乎所有可能形式。

那么，让我们一起来浏览以下教程，看看如何使用 Zabbix 代理：

设置 Zabbix 代理
使用被动 Zabbix 代理
使用主动 Zabbix 代理
使用 Zabbix 代理监控主机
使用预共享密钥加密 Zabbix 代理连接
设置 Zabbix 代理负载均衡
使用 Zabbix 代理进行发现
监控你的 Zabbix 代理

技术要求

本章我们将需要几个新的 Linux 主机，因为我们将把它们作为 Zabbix 代理来构建。

在以下两个新主机上安装你喜欢的 RHEL 或 Ubuntu Linux 发行版，来设置两个代理：

lar-book-proxy-passive
lar-book-proxy-active

你还需要一个 Zabbix 服务器，至少有一个被监控的主机。我们将使用以下新主机，并在其上安装 Zabbix 代理进行监控：

lar-book-agent-by-proxy

设置 Zabbix 代理

如果你没有太多 Linux 经验，设置 Zabbix 代理可能会让人感到不知所措，但一旦掌握了它，任务其实非常简单。我们将在lar-book-proxy-passive服务器上安装 Zabbix 代理；你可以在lar-book-proxy-active上重复这个任务。

准备工作

确保有一台新的空 Linux 主机，并准备好并安装你选择的发行版。我们在这个教程中还不需要 Zabbix 服务器。

如何操作…

让我们从登录到新lar-book-proxy-passive主机的命令行界面（CLI）开始。

现在，执行以下命令来添加 Zabbix 仓库。对于基于 RHEL 的系统，使用以下命令：

rpm -Uvh https://repo.zabbix.com/zabbix/7.0/rhel/8/ x86_64/zabbix-release-7.0-1.el8.noarch.rpm
dnf clean all

对于 Ubuntu 系统，使用以下命令：

wget https://repo.zabbix.com/zabbix/7.0/ubuntu/pool/ main/z/zabbix-release/zabbix-release_7.0-1+ubuntu22.04_all.deb
dpkg -i zabbix-release_7.0-1+ubuntu22.04_all.deb
apt update

现在，通过执行以下命令安装 Zabbix 代理。

对于基于 RHEL 的系统，请使用以下命令：
```
dnf install zabbix-proxy-sqlite3 zabbix-selinux-policy
```
对于 Ubuntu 系统，请使用以下命令：
```
apt install zabbix-proxy-sqlite3
```

提示

在基于 RHEL 的服务器上，不要忘记将 SELinux 设置为宽松模式或者为生产环境允许 Zabbix 代理运行。对于实验室环境，可以将 SELinux 设置为宽松模式，但在生产环境中，建议保持启用状态。对于 Ubuntu 系统，在实验室环境中，我们可以禁用 AppArmor。

现在，通过执行以下命令编辑 Zabbix 代理配置：

passive proxy. The mode will be 1 on this proxy. On the active proxy, this will be 0:

ProxyMode=1

将以下行更改为您的 Zabbix 服务器地址：
```
Server=10.16.16.152
```

重要提示

在与 Zabbix 服务器一起使用 高可用性 (HA) 时，请确保为集群中每个节点添加 Zabbix 服务器 IP 地址。代理将仅向活动节点发送数据。请注意，HA 节点之间用分号 (;) 而不是逗号 (,）分隔。

将以下行更改为您的代理主机名：

sqlite version of the proxy for the example, change the DBName parameter to the following:

DBName=/tmp/zabbix_proxy.sqlite3

您现在可以使用以下两个命令启用 Zabbix 代理并启动它：
```
systemctl enable zabbix-proxy
systemctl start zabbix-proxy
```
您应该检查 Zabbix 代理日志是否没有显示任何错误，使用以下命令：
```
tail -f /var/log/zabbix/zabbix_proxy.log
```

工作原理…

有三个版本的 Zabbix 代理可供使用：

zabbix-proxy-mysql
zabbix-proxy-pgsql
zabbix-proxy-sqlite3

我们刚刚完成了 zabbix-proxy-sqlite3 包的设置，这是我认为最简单的方法。如果您问我的话，sqlite3 版本的 Zabbix 代理使我们能够轻松设置 Zabbix 代理，因为我们实际上不需要过多担心数据库的设置和维护。

请注意，sqlite3 版本可能不适合负载非常高的 Zabbix 代理，因为 sqlite3 无法进一步扩展。在使用 Zabbix 代理时，使用 mysql 或 postgresql 数据库可以获得更多的扩展选项，通过这些数据库类型的微调机制。然而，由于在大多数情况下代理的理念是在多个代理之间分配负载，所以一旦我的数据库达到容量上限，我发现添加 SQLite3 代理更容易。

提示

对于将来的需求，始终选择正确类型的 Zabbix 代理。虽然稍后可以轻松切换代理，但在此选择上不要太随意，因为您可能会在未来节省数小时的时间。

sqlite3 版本的惊人之处在于，如果我们遇到数据库问题，只需运行以下命令即可轻松删除数据库：

rm /tmp/zabbix_proxy.sqlite3

有了这个，sqlite3 Zabbix 代理会在启动时自动创建一个新的数据库，我们现在可以开始重新收集数据了。请注意，我们可能会丢失一些仍在代理数据库中的数据，这些数据作为一个缓存可能包含尚未发送到 Zabbix 的数据。如果数据尚未发送到 Zabbix 并且您删除数据库，则会丢失仍在数据库中的度量标准。

然而，在 Zabbix 7 中，代理数据库的概念有所变化，增加了内存缓存。默认情况下，Zabbix 7 中的代理将以以下三种模式之一运行：

混合模式（新安装的默认设置）
内存
磁盘（现有安装的默认设置）

我们可以通过编辑 Zabbix 代理配置文件中的ProxyBufferMode=来调整此设置。

这意味着 Zabbix 代理现在将默认将待发送的指标缓存在内存中，而不是缓存在数据库中。只有在 Zabbix 代理内存缓存已满的情况下，代理才会开始将数据缓存在数据库中。

需要记住的最后一点是，在混合模式下，我们仍然可以安全地重启 Zabbix 代理；但是，重启时，Zabbix 代理进程的数据将会被刷新到数据库中。而在内存模式下，这不是缓存，数据会在重启 Zabbix 代理进程时丢失。

还有更多…

更多关于安装 Zabbix 代理的信息可以在这里找到：

www.zabbix.com/documentation/current/manual/installation/install_from_packages

选择你正在使用的发行版，你可以在这里找到所有不同代理安装变体的指南。

使用被动 Zabbix 代理

现在我们已经在前面的步骤中安装了 Zabbix 代理，我们可以开始使用它了。让我们先从在前端设置我们的被动 Zabbix 代理开始，看看我们从一开始能做些什么。

准备就绪

你需要为此步骤准备好并安装好 lar-book-proxy-passive 主机，并且我们将再次在此步骤中使用 Zabbix 服务器。

如何操作…

让我们从登录 Zabbix 前端并导航到管理 | 代理开始：

图 8.1 – 管理 | 代理页面，没有代理

我们的代理页面是进行所有前端代理相关配置的地方。

让我们通过右上角的蓝色创建代理按钮添加一个新代理。

这将展示给我们创建代理的弹出窗口，在这里我们将填写以下信息：

图 8.2 – 管理 | 代理，创建代理弹出窗口，lar-book-proxy-passive

在点击蓝色的添加按钮之前，让我们先看一下加密标签页：

图 8.3 – 管理 | 代理，创建代理弹出窗口加密标签页，lar-book-proxy-passive

默认情况下，这里勾选了无加密，我们将在另一个步骤中处理这个问题。目前，保持它设置为无加密。

重要提示

在 Zabbix 服务器和 Zabbix 代理之间交换了大量有价值的信息。如果你正在使用不安全的网络，或者只是需要额外的安全层，可以使用 Zabbix 代理加密。你可以在这里找到更多关于 Zabbix 加密的信息：www.zabbix.com/documentation/current/en/manual/encryption。

在继续之前，我们还需要看一眼 Zabbix 代理创建弹窗中的另一个标签 – 超时：

图 8.4 – 管理 | 代理，创建代理弹窗中的超时标签，lar-book-proxy-passive

我们在这里不会更改超时标签页的任何内容，但自 Zabbix 7 起，可以覆盖不同类型项目检查的全局超时，允许我们显著调整 Zabbix 设置，以避免超时性能问题。

现在，点击蓝色的添加按钮，这将把我们带回到代理概览页面。
新添加的代理的最后见到（时间）部分现在应该显示一个时间值，而不是从未：

图 8.5 – 管理 | 代理页面，最后见到（时间）

它是如何工作的…

在完成安装部分后，添加代理并不是最难的任务。在本步骤中完成的操作后，我们已准备好使用此代理开始监控。

我们刚刚添加的代理是 10051：

图 8.6 – 显示活跃代理连接的示意图

一旦被动代理知道要监控什么，每当 Zabbix 服务器轮询数据时，数据会通过同一 TCP 连接返回。这意味着连接始终是由 Zabbix 服务器端发起的。一旦设置完成，Zabbix 服务器将不断发送配置更改，并持续轮询新的数据。

使用活跃 Zabbix 代理

我们现在知道如何安装和添加代理。让我们设置我们的活跃代理，就像在前面的步骤中设置被动代理一样，看看它是如何工作的。

准备工作

你将需要在本步骤中使用lar-book-proxy-active主机，它已经准备好并安装了 Zabbix 代理，如本章第一个步骤所设置。我们还将在本步骤中使用我们的 Zabbix 服务器。

如何操作…

让我们从登录到 Zabbix 前端开始，导航到管理 | 代理：

图 8.7 – 管理 | 代理页面，无活跃代理

我们的代理页面是进行所有与代理相关配置的地方。

通过点击右上角的蓝色创建代理按钮，我们来添加一个新的代理。

这将打开创建代理弹窗，在这里我们将填写以下信息：

图 8.8 – 管理 | 代理，创建代理弹窗，lar-book-proxy-active

提示

代理地址字段对于我们的主动代理来说实际上是可选的。您不必添加此项即可让 Zabbix 代理正常工作，但为了保持清晰，建议添加。添加代理地址字段也起到了一种白名单的作用，只有列出的 IP 地址才能连接。

在点击蓝色的添加按钮之前，先来看一下加密标签：

图 8.9 – 管理 | 代理，创建代理弹窗加密标签，lar-book-proxy-active

默认情况下，不加密是选中的，我们在这个步骤中保持不变。

在继续之前，我们需要查看 Zabbix 代理创建弹窗中的另一个标签——超时：

图 8.10 – 管理 | 代理，创建代理弹窗超时标签，lar-book-proxy-passive

我们在这里不会更改超时标签中的任何内容，但从 Zabbix 7 开始，您可以覆盖各种类型项目检查的全局超时，这使得我们能够显著调整 Zabbix 设置，以避免超时性能问题。

现在，点击蓝色的添加按钮，这将把我们带回代理概览页面。

active proxy. The mode will be 0 on this proxy instead of 1:

ProxyMode=0

将以下行更改为您的代理主机名：
```
Hostname=lar-book-proxy-active
```
然后，重启代理：
```
systemctl restart Zabbix-proxy
```
您新添加的代理的最后一次见面（年龄）部分现在应该显示一个时间值，而不是从未。

图 8.11 – 管理 | 代理页面，最后一次见面（年龄）

根据您在代理配置文件中的设置，最后一次见面（年龄）部分可能需要一些时间才能更新。

它是如何工作的……

如果您跟随了本章中的使用被动 Zabbix 代理步骤，操作大致相同，唯一不同的是我们添加代理模式的部分。

我们刚刚添加的代理是一个主动代理，通过在端口10051上向 Zabbix 服务器请求配置来工作。

图 8.12 – 显示主动代理连接的示意图

Zabbix 代理会不断请求配置更改，并且每秒将新收集的数据发送到 Zabbix 服务器，或者如果没有数据可用，则发送心跳。

重要提示

推荐使用主动 Zabbix 代理，因为它可以帮助我们减少 Zabbix 服务器的负载。只有在有充分理由时，才使用被动代理。

使用 Zabbix 代理监控主机

我们已经准备好主动和被动Zabbix 代理，所以现在可以向它们添加一些主机。通过 Zabbix 前端设置来监控主机与 Zabbix 代理的操作方式与直接从 Zabbix 服务器监控的方式大致相同。不过，后端和设计完全改变，我将在本步骤的如何工作…部分详细解释。

准备工作

请确保按照本章之前的所有步骤准备好lar-book-proxy-passive被动代理和lar-book-proxy-active主动代理。

您还需要准备好 Zabbix 服务器和至少两个需要监控的主机。我们将在示例中使用lar-book-agent_snmp和lar-book-agent，但任何具有主动和被动 Zabbix 代理的主机都可以使用。

如何操作…

我们将在我们的主动代理和被动代理上配置一个主机，向您展示这两者之间的区别。让我们从被动代理开始。

被动代理

让我们通过登录 Zabbix 前端并导航到数据收集 | 主机来开始这一步骤。

让我们将具有被动代理的主机添加到我们的被动代理中。在我的情况下，这个主机是lar-book-agent_snmp。

点击lar-book-agent_snmp主机，并将其更改为lar-book-proxy-passive，如下所示的截图：

图 8.13 – 配置 | 主机，编辑主机页面，主机 lar-book-agent_snmp

现在，点击蓝色的更新按钮。我们的主机现在将由 Zabbix 代理进行监控。

重要提示

由于配置更新的时间间隔，以及我们刚刚将监控源切换到代理，我们可以看到 SNMP 图标暂时变灰。

主动代理

对我们的另一个lar-book-agent主机执行相同操作，通过导航回数据收集 | 主机。
点击lar-book-agent主机，并将由代理监控字段更改为lar-book-proxy-active，如下所示的截图：

图 8.14 – 配置 | 主机，编辑主机页面，主机 lar-book-agent

现在，点击蓝色的更新按钮。
在我们被监控的 Linux 主机（lar-book-agent主机）的 CLI 中，执行以下命令：
```
vim /etc/zabbix/zabbix_agent2.conf
```
当使用主动 Zabbix 代理时，我们需要确保将代理的 IP 地址添加到以下行中：
```
ServerActive=
```

一旦代理收到新的配置数据并且代理执行了检查，我们的主机将会被 Zabbix 代理监控。

如何工作…

使用 Zabbix 代理在被动或主动模式下监控主机，在前端的操作是相同的。我们只需在 Zabbix 前端配置哪个主机由哪个代理进行监控，其他工作就会自动完成。

让我们来看一下我们的简单网络管理协议（SNMP）代理现在如何被被动代理监控：

图 8.15 – 一个完全被动的 Zabbix 配置，带代理

我们的被动 Zabbix 代理现在从 SNMP 代理那里收集数据，收集完成后，Zabbix 服务器从 Zabbix 代理那里获取这些数据。听起来已经是一个完整的过程了，对吧？

让我们来看一下我们的激活 Zabbix 代理配置：

图 8.16 – 一个完全激活的 Zabbix 配置，带代理

我们的激活 Zabbix 代理接收来自激活 Zabbix 代理的数据，然后将这些数据发送到 Zabbix 服务器。在这个代理配置中，我们已经完全消除了被动代理等待轮询的部分。此外，我们只需要允许防火墙连接到代理或服务器，这也可以提供额外的安全性。

这是我总是建议尽可能使用激活代理——甚至是激活代理——的一些原因。如果我们看一下下面的截图，我们会看到一个你可能在公司中看到的配置：

图 8.17 – 一个带有不同监控类型的激活 Zabbix 代理配置

幸运的是，我们可以使用多种不同组合的配置选项。通过代理组合你的检查是完全可能的——甚至是合逻辑的——就像直接通过 Zabbix 服务器一样。我们可以通过代理监控所有类型的设备，无论是 Zabbix 代理、SNMP，甚至是Java 管理扩展（JMX）和智能平台管理 接口（IPMI）。

提示

在设计新的 Zabbix 托管基础设施时，尽可能在设计中添加代理。这样，你以后就不必做太多更改。添加和更改代理很容易，但如果只使用 Zabbix 服务器，想要改为在设计中使用 Zabbix 代理就会更加困难。

还有更多内容……

现在我们已经有了一个稳定的配置，代理也已经启动运行。我们已经弄清楚了激活和被动代理的区别，以及它们如何影响监控。那么，我们为什么要构建这样的配置呢？其实，Zabbix 代理适用于许多环境——不仅仅是大型环境，有时在小型环境中也同样有效。

我们可以使用 Zabbix 代理将轮询和预处理任务从主 Zabbix 服务器上分担出去，从而让服务器保持清晰，以便处理诸如写入 Zabbix 数据库之类的数据。

我们可以使用 Zabbix 代理来监控远程站点，例如当你是一个托管服务提供商（MSP）并希望监控客户网络时。我们只需在现场放置一个代理进行监控。我们可以使用行业标准的技术，比如通过虚拟专用网络（VPN）进行监控，或者直接通过 Zabbix 代理的内置加密设置连接。

当与远程站点的连接断开时，我们的代理将继续在本地收集数据，并在连接恢复时将其发送到我们的 Zabbix 服务器。默认情况下，Zabbix 会将数据保存在磁盘上一个小时，这由 Zabbix 代理配置文件中的 ProxyOfflineBuffer= 参数指定。

我们还可以使用 Zabbix 代理绕过防火墙问题。当我们将代理放置在受监控网络中的防火墙后面时，只需要在 Zabbix 服务器和 Zabbix 代理之间配置一个防火墙规则。然后，我们的 Zabbix 代理监控不同的主机，并将收集到的数据以单一流的形式发送到 Zabbix 服务器。这意味着我们不需要在防火墙上为端口 161、162、10050、10051、Java、API 端口等开通端口。

通过这个，你已经有了很多选项可以使用 Zabbix 代理。

另见

查看这篇有趣的博客文章，了解 Zabbix 代理的一些更多隐藏好处：blog.zabbix.com/hidden-benefits-of-zabbix-proxy/9359/。

使用预共享密钥加密你的 Zabbix 代理连接

为了提高安全性，建议确保 Zabbix 代理通过加密的网络连接。这样做的简单原因是，确保网络中的任何潜在入侵者无法以明文形式看到 Zabbix 服务器和 Zabbix 代理之间传输的所有数据。

想象一下，如果你配置了包含重要密码的宏。如果没有加密 Zabbix 服务器与代理之间的连接，这些宏将以明文形式通过网络传输。

准备工作

对于本食谱，我们需要一个 Zabbix 服务器和一个连接的代理，可以是被动或主动类型。

如何操作……

让我们开始在代理的命令行界面（CLI）上进行一些配置更改：

首先，让我们编辑 Zabbix 代理的配置文件：
```
vim /etc/zabbix/zabbix_proxy.conf
```

我们将找到以下内容并编辑以下变量：

TLSConnect=psk
TLSAccept=psk
TLSPSKIdentity=lar-book-proxy-active
TLSPSKFile=/etc/zabbix/proxy_psk.key

TLSConnect 用于主动代理连接，而 TLSAccept 用于被动代理连接。然而，始终设置这两个参数是明智的，因为这样我们可以始终确保加密连接。

重要提示

在这个例子中，为了简化起见，我将身份设置为代理的主机名。如果每次 PSK 身份和 PSK 本身都是唯一组合，你也可以使用任何值。不要使用相同的 PSK 但更改身份，这样会导致错误，代理将无法连接。

保存你的代理配置文件并退出。

我们将创建一个新的文件，位于 /etc/zabbix 文件夹中，包含 PSK。为此，执行以下命令：
```
openssl rand -hex 128 > /etc/zabbix/proxy_psk.key
```
这将创建包含新预共享密钥的文件。你可以通过以下命令确保它已正确创建：
```
cat /etc/zabbix/proxy_psk.key
```
它应该如下所示：

图 8.18 – 创建的代理 PSK 文件

现在，让我们确保只有 Zabbix 代理能读取这个 PSK 文件：

chmod 400/etc/zabbix/proxy_psk.key
chown zabbix:zabbix /etc/zabbix/proxy_psk.key

重启你的 Zabbix 代理以使更改生效：

Systemctl restart zabbix-proxy

现在，是时候进入前端了。导航到管理 | 代理。

你可能会看到代理不再连接，并且最后一次看到（时长）的值正在增加。编辑你正在添加加密的代理并转到加密选项卡。对于主动代理，它将显示如下：

图 8.19 – lar-book-proxy-active PSK 设置

对于被动代理，确保连接到代理设置为PSK，对于主动代理，选择PSK作为我们希望用于从代理的连接的选项。

填入在步骤 2 和 步骤 6中设置的PSK 身份和PSK。

现在，点击更新，你的代理应该重新连接。

它是如何工作的…

在设置了主动或被动 Zabbix 代理加密之后，变化不会太大。你的代理仍然会连接到或从 Zabbix 服务器连接过来。变化的地方在于，Zabbix 服务器和代理现在将在相互通信时使用加密。

图 8.20 – 加密的代理连接

我们使用的方法采用了预共享密钥（PSK）加密方法。虽然这提供了一种相对安全的加密方式，但仍然存在 PSK 泄漏的风险。由于预共享密钥永不过期，这可能会在安全上留下一个永久的漏洞，除非你定期更换预共享密钥。在实践中，这通常是不会发生的。

使用基于证书的加密方法的一个好处是证书会过期。这确实为安全增加了一层保障，但同时也意味着你需要定期更新加密设置，否则可能会失去 Zabbix 代理与服务器之间的连接。

设置 Zabbix 代理负载均衡

期待已久，Zabbix 终于引入了代理高可用性和负载均衡。这完成了所有必要的功能，使 Zabbix 成为即使在发生故障时也能高度可靠的产品。

这也意味着 Zabbix 现在更加容易扩展，利用代理的负载均衡将负载分配到可用的代理之间。

准备工作

对于本篇配方，我们将使用在本章前面配方中设置的主动和被动代理。除此之外，我们只需要 Zabbix 设置和一个主机用于监控，我们将使用处于主动模式的 Zabbix 代理。

如何操作…

让我们开始设置前端，在这里我们应该已经有两个（或更多）可用的 Zabbix 代理：

转到管理 | 代理，确保你有两个可用的代理。代理模式无关紧要，因为我们可以在代理负载均衡中结合使用活动代理和被动代理。

图 8.21 – 管理 | 代理页面，显示我们将用于负载均衡的两个代理

接下来，转到管理 | 代理组，以定义我们的第一个代理负载均衡和高可用性组。
在右上角，点击创建代理组按钮。这将打开以下弹出窗口：

图 8.22 – 管理 | 代理组，新代理组弹出窗口

在这里，我们基本上只需要给代理组命名，接下来就完成了。我们将此组命名为lar-proxy-group。然后，点击添加按钮完成添加代理组。
现在，返回到管理 | 代理，让我们将两个代理添加到新的代理组中。
点击一个代理，并通过填写代理组参数或使用选择按钮将其添加到代理组中。

图 8.23 – 管理 | 代理，向代理添加代理组

对我们希望添加到该组的所有代理执行此操作。

同时，确保填写活动代理的地址参数，因为当我们使用活动代理时，我们需要知道每个代理的连接位置。
我们将对第二个代理执行相同的操作：

图 8.24 – 管理 | 代理，向代理添加代理组

现在，让我们添加一个新主机，该主机将由这个代理组进行监控。我将使用一个名为lar-book-proxyha-test的新主机。在创建主机时，确保添加代理组参数，像这样：

图 8.25 – 数据收集 | 主机，编辑或创建主机弹出窗口

在我们添加的主机的代理配置文件中，让我们修改一些参数。如果是 Linux 主机，编辑配置文件：
```
vim /etc/zabbix/zabbix_agent2.conf
```

现在，编辑以下两个参数：

ServerActive=192.168.2.175,192.168.2.174
Hostname=lar-book-proxyha-test

当两个代理处于活动状态并作为代理组的一部分进行配置，并且有一个主机被该代理监控时，我们现在完成了设置，可以在这些代理之间进行主机负载均衡。

它是如何工作的……

如你所见，代理负载均衡和高可用性是一种非常直接的设置，操作起来并不复杂。我们只需要将代理添加到一个组中，Zabbix 会为我们处理其余部分。

在我们的案例中，我们已将两个代理添加到该组，一个是活动代理，一个是被动代理。这两个代理现在将共同工作，负责在它们之间负载均衡主机的负载。

图 8.26 – 我们的代理组正常工作

我们的活动代理 lar-book-proxyha-test 主机将连接到在 ServerActive= 参数下定义的两个代理中的一个。在 Zabbix 前端的代理配置中，我们输入了 活动代理地址，因此代理组中的所有代理也知道需要重定向检查的地址，以便进行负载均衡。

我们的 Zabbix 代理组现在会确保对主机进行负载均衡，即使它们处于活动模式。如果发生故障，代理组将需要重新计算负载均衡。

图 8.27 – 我们的代理组在故障后

主机现在将被重定向到代理组中的另一个代理进行进一步监控。这就是为什么我们不需要任何浮动 IP 或虚拟 IP 来重定向活动代理检查，因为我们的代理可以为我们处理这些。

然而，请记住代理参数，确保我们的代理组能够最佳地运行。如果在代理组中有 4 个代理并设置为 1，请确保配置每一个代理能够处理代理组中所有主机的全部负载。否则，您的监控性能仍然会受到影响。

这同样适用于反向情况；如果我们有一个包含 4 个代理的代理组，并且设置为 3，那么如果我们失去两个代理，整个代理组将会宕机。确保在代理组中代理的数量与该组处理全部监控负载所需的最小代理数量之间找到正确的平衡。

图 8.28 – 我们的代理组设置

此外，我们可以更改 故障切换周期 的值，以确定故障切换发生的速度。

重要提示

请记住，如果您使用某些其他检查，可能需要进行一些额外配置，例如浮动 IP 或虚拟 IP。例如，对于使用 SNMP Trap 的检查，您可能需要将 Trap 发送到代理组中的所有代理（如果您的设备支持的话），这会给网络带来额外负载。

使用发现与 Zabbix 代理

在 第七章，使用发现进行自动创建 中，我们讨论了 Zabbix 和发现。如果您按照那一章的内容进行操作，编辑您的发现规则是一个非常好的主意。让我们看看这个方法在本教程中的应用。

准备工作

您需要完成 第七章，使用发现进行自动创建，或者已经设置了一些发现规则和活动代理自动注册。

我将在本示例中使用 lar-book-lnx-agent-auto、lar-book-disc-lnx 和 lar-book-disc-win 主机。我们还需要我们的 Zabbix 服务器。

如何操作…

让我们先从编辑我们的发现规则开始，然后再继续编辑我们的活动代理，以便自动注册到代理。

发现规则

从 Zabbix 发现规则开始，让我们看看如何确保我们从 Zabbix 代理进行此操作：

登录到 lar-book-disc-lnx 的 CLI 并编辑 /etc/zabbix/zabbix_agent2.conf 文件。编辑以下行以包含我们的 Zabbix 代理地址：
```
Server=127.0.0.1,10.16.16.152,10.16.16.160,10.16.16.161
ServerActive=10.16.16.160
```
通过执行以下命令重新启动 Zabbix 代理：
```
systemctl restart zabbix-agent2
```
现在，确保登录到 lar-book-disc-win 并编辑 C:\Program Files\Zabbix agent\zabbix_agent2 文件。编辑以下行以包含我们的 Zabbix 代理地址：
```
Server=127.0.0.1,10.16.16.152,10.16.16.160,10.16.16.161
ServerActive=10.16.16.160
```

重要注意事项

在我们配置文件中的 ServerActive 行，确保只包含我们希望发送数据的 Zabbix 代理。Zabbix 代理会主动尝试将数据发送到这里列出的所有 Zabbix 代理或 Zabbix 服务器，因此我们应该只列出我们希望使用的那个。

通过在 Windows 命令行中执行以下命令来重新启动 Zabbix 代理：
```
zabbix_agent2.exe --stop
zabbix_agent2.exe --start
```
或者，使用 Windows 服务窗口重新启动代理。

接下来，导航到 数据收集 | 主机并删除已发现的主机：
```
lar-book-disc-lnx
lar-book-disc-win
```
我们这样做是为了防止重复的主机。
现在，导航到 数据收集 | 发现。
点击 发现 Zabbix 代理主机 并更改 由代理发现 字段，如下图所示：

图 8.29 – 警报 | 操作，代理 lar-book-proxy-active 的发现操作

点击蓝色的更新按钮，这就是编辑您的发现规则以通过代理进行监控的全部过程。
现在，您可以在配置 | 主机下查看您的新发现的主机，并看到它们是由代理监控的：

图 8.30 – 数据收集 | 主机页面显示我们发现的主机

活动代理自动注册

继续进行活动代理自动注册，让我们看看如何从 Zabbix 代理进行操作：

首先导航到 lar-book-lnx-agent-auto 主机的 CLI。
使用以下命令编辑 Zabbix 代理配置文件：
```
vim /etc/zabbix/zabbix_agent2.conf
```
确保编辑以下行，将 Zabbix 代理地址替换为 Zabbix 服务器地址：
```
ServerActive=10.16.16.160
```
重新启动 Zabbix 代理：
```
systemctl restart zabbix-agent2
```

我们现在可以看到我们的主机自动注册到 Zabbix 代理，而不是 Zabbix 服务器：

图 8.31 – 数据收集 | 主机页面显示我们的两个自动注册主机

它是如何工作的…

使用 Zabbix 代理进行发现与使用 Zabbix 服务器进行发现的方式相同。唯一的变化是我们注册的位置或发现的来源。

如果你想了解更多关于发现和自动注册的过程，请查看 第七章，使用发现进行自动创建，如果你还没有阅读的话。

监控你的 Zabbix 代理

很多 Zabbix 用户——甚至是一般的监控用户——会忘记他们监控中的一个非常重要的部分。他们忘记监控监控基础设施。我希望在你设置 Zabbix 代理时，也能知道如何监控这些代理的健康状况。

让我们在这个方案中查看如何操作。

准备工作

对于此方案，我们需要新的 lar-book-proxy-active Zabbix 代理。我们还需要 Zabbix 服务器来监控 Zabbix 代理。

如何操作…

我们将在 Zabbix 前端构建一些监控，但我们还将检查 Zabbix 代理的集成监控选项。让我们从构建我们自己的开始。

使用 Zabbix 监控代理

我们可以使用 Zabbix 代理本身来监控我们的 Zabbix 代理，以确保我们确切了解发生了什么：

让我们首先登录到我们的 lar-book-proxy-active Zabbix 代理 CLI。
执行以下命令安装适用于 RHEL 系统的 Zabbix 代理 2：
```
dnf install zabbix-agent2
```
对于 Ubuntu，执行此命令：
```
apt install zabbix-agent2
```
通过执行以下命令编辑 Zabbix 代理配置文件：
```
vim /etc/zabbix/zabbix_agent2.conf
```

编辑以下行，指向 localhost：

Server=127.0.0.1
ServerActive=127.0.0.1

同时，请确保将主机名添加到 Zabbix 代理文件中：
```
Hostname=lar-book-proxy-active
```
现在，登录到 Zabbix 前端，导航到 数据采集 | 主机。
点击右上角的蓝色 创建主机 按钮，并添加以下主机：

图 8.32 – 数据采集 | 主机，创建主机弹出窗口，lar-book-proxy-active

特别注意 由代理监控 字段 – 我们希望从代理进行监控，因为我们正在进行 Zabbix 内部检查，这些检查需要由接收到此配置的 Zabbix 守护进程来处理。

在点击蓝色的添加按钮之前，请确保添加模板。将以下模板添加到主机：

图 8.33 – 数据采集 | 主机，创建主机弹出模板，主机 lar-book-proxy-active

现在我们可以点击蓝色的添加按钮来创建主机。
现在，导航到监控 | 最新数据 并添加以下过滤器：

图 8.34 – 监控 | 最新数据页面，带有过滤器，主机 lar-book-proxy-active

现在我们可以看到 Zabbix 代理的统计数据，例如处理的值的数量和某些内部进程的利用率：

图 8.35 – 监控 | 最新数据页面，显示来自 Zabbix 代理的数据

从我们的 Zabbix 服务器远程监控代理

我们还可以从 Zabbix 服务器远程监控我们的 Zabbix 代理，那么让我们来看看它是如何工作的：

让我们从登录到 lar-book-proxy-active 主机的 CLI 并编辑以下文件开始：
```
vim /etc/zabbix/zabbix_agent2.conf
```
编辑以下行以匹配您的 Zabbix 服务器地址（Zabbix 服务器 HA 集群中的每个节点）：
```
Server=127.0.0.1,10.16.16.152
ServerActive=127.0.0.1,10.16.16.152
```
同时，编辑以下文件：
```
vim /etc/zabbix/zabbix_proxy.conf
```
编辑以下行以匹配您的 Zabbix 服务器地址：
```
StatsAllowedIP=127.0.0.1,10.16.16.152
```
现在，导航到 Zabbix 前端，进入 数据采集 | 主机。
点击右上角的蓝色创建主机按钮，添加以下主机：

图 8.36 – 数据采集 | 主机，创建主机弹出窗口，lar-book-proxy-active_remotely

在点击蓝色的添加按钮之前，确保添加正确的模板。将以下模板添加到主机：

图 8.37 – 数据采集 | 主机，创建新主机弹出模板，lar-book-proxy-active_ 远程

现在，我们可以点击蓝色的 lar-book-proxy-active_remotely 主机。
进入宏，并添加以下两个宏：

图 8.38 – 数据采集 | 主机，编辑主机弹出窗口，宏标签，lar-book-proxy-active_remotely

现在，点击蓝色的更新按钮，这个主机设置就完成了。

如果我们导航到监控 | 最新数据 并检查此主机的项目，我们可以看到数据流入：

图 8.39 – 监控 | 主机 lar-book-proxy-active_remotely 的最新数据页面

从 Zabbix 前端监控代理

让我们从导航到管理 | 队列开始。
使用下拉菜单进入 按代理概览队列：

图 8.40 – 管理 | 队列菜单

这将把我们带到以下截图所示的页面：

图 8.41 – 管理 | 按代理概览队列页面

让我们在接下来的部分中看看这如何运作。

它是如何工作的……

监控您的 Zabbix 代理是一个重要任务，因此我们需要确保每次添加新 Zabbix 代理时，都像对待其他主机一样对其进行管理。

使用 Zabbix 监控代理

通过将 Zabbix 代理添加为主机，我们可以确保运行 Zabbix 代理的 Linux 系统是健康的。我们还可以确保运行在该服务器上的 Zabbix 代理应用程序是健康的。

除了在这些模板中设置正确的触发器外，我们还可以获得一系列选项来排查 Zabbix 代理的问题。

在监控方面，Zabbix 代理和 Zabbix 服务器一样工作。这意味着，就像 Zabbix 服务器一样，我们需要通过调整 Zabbix 代理配置文件来确保代理的健康。

一旦你搞清楚了代理的问题，扩展你的代理就变得容易得多。所以，这也是我们确保始终监控它们的原因。我们从代理本身开始监控，确保通过 Zabbix 内部检查获得正确的信息。

从我们的 Zabbix 服务器远程监控代理

现在，当我们使用 远程 Zabbix 代理健康 进行监控时，情况略有不同。我们不再从 Zabbix 代理本身进行检查，而是通过在宏中定义 Zabbix 代理地址和端口，从 Zabbix 服务器远程进行检查。此时，仍会使用 Zabbix 内部检查类型，通过 Zabbix 服务器远程执行检查。

此外，当然也建议我们继续保持 Zabbix 代理以被动或主动模式运行。

图 8.42 – Zabbix 代理在 Zabbix 服务器的监控下运行

这样，我们的 Zabbix 服务器就成为请求和接收信息的一方。即使代理有问题，检查仍然会由 Zabbix 服务器执行。

如果怀疑本地执行的内部检查存在问题，我们可以使用这个模板来更密切地关注我们的代理，或者可以使用这个模板绕过某些防火墙设置。这两种情况都是合理的。

从 Zabbix 前端监控代理

在前端页面，我们可以使用管理 | 队列页面来监控我们的代理。Zabbix 队列页面是一个重要页面，但许多新用户既不知道也没有充分利用这个页面。

当 Zabbix 的某个部分开始表现不佳时，比如我们这里的 Zabbix 代理，这时我们就能在队列中看到一些问题。Zabbix 队列页面有六个选项：

5 秒
10 秒
30 秒
1 分钟
5 分钟
超过 10 分钟

队列中的选项意味着 Zabbix 代理正在等待接收一个配置值，这个值超出了预期。我认为，最多到一分钟不一定是问题，但这取决于检查的类型。5 分钟或超过 10 分钟的选项可能表示你的 Zabbix 代理存在严重的性能问题，需要排查。若怀疑有问题，务必密切关注 Zabbix 队列，这些问题也被作为触发器包含在我们添加的模板中，用于监控 Zabbix 代理。

第九章：9

将 Zabbix 与外部服务集成

在本章中，我们将设置 Zabbix 提供的一些有用的外部服务集成。我们可以利用这些外部服务向 Zabbix 用户通知正在进行的问题。

我们将从学习如何设置公司内的聊天应用程序，如 Slack 和 Microsoft Teams 开始。然后，我们将学习如何使用个人聊天应用 Telegram，最后学习如何集成 Atlassian Opsgenie 以获得更广泛的警报功能。

一旦你完成了这些设置，你将能够有效地将某些服务与 Zabbix 集成。这是一个很好的起点，适用于与外部服务的集成，并且是设置 Slack、Teams、Opsgenie 和 Telegram 的最简单方式。

在本章中，我们将介绍以下几个方案：

使用 Zabbix 设置 Slack 警报
使用 Zabbix 设置 Microsoft Teams 警报
使用 Telegram 机器人与 Zabbix 集成
将 Atlassian Opsgenie 与 Zabbix 集成

让我们开始吧！

技术要求

本章我们需要使用 Zabbix 服务器，最好是按照本书中提供的设置方式来配置，尽管任何安装了警报功能的 Zabbix 7 服务器也可以使用。

我们还需要访问以下一些外部服务：

Slack（免费，有限制）：

slack.com/
Microsoft Teams（免费，有限制）：

www.microsoft.com/microsoft-teams
Opsgenie（免费，有限制）：

www.atlassian.com/software/opsgenie/
Telegram（免费）：

telegram.org/

我们不会介绍如何设置这些服务本身，仅介绍如何将它们与 Zabbix 集成。确保你已按照指南设置了所需的服务，并对这些服务有一定的了解。

使用 Zabbix 设置 Slack 警报

Slack 是一个广泛使用的工具，用于简单的文本消息、语音/视频聊天和协作。在本章中，我们将学习如何使用 Zabbix 的 Slack 集成功能将 Zabbix 问题信息发送到 Slack，从而能更好地了解问题概况。

准备工作

确保你已设置好 Slack。你可以访问 slack.com/intl/en-in/ 并在那里免费设置。我们还需要一个有一些活跃问题的 Zabbix 服务器。

如何操作…

一旦你设置并打开 Slack，你应该能看到以下页面：

图 9.1 – Slack 默认页面

让我们通过点击 + 添加频道 按钮来创建一个新的 Zabbix 通知频道。然后，在下拉菜单中点击 创建一个新频道：

图 9.2 – Slack 创建频道窗口

点击 Next 按钮。然后，在下一个窗口中，点击 Create 按钮以创建一个公开（或私人）频道：

图 9.3 – Slack，设置新频道可见性

您将看到最后一步，选择将特定人员或所有人员添加到新频道。在我的测试中，我会添加所有人，所以我只需点击完成。

图 9.4 – Slack，添加人员窗口

现在，访问以下链接创建一个与 Zabbix 配合使用的 Slack 机器人：api.slack.com/apps。
您将在此页面上看到创建新应用程序选项。点击它，带您进入此页面：

图 9.5 – Slack，API 创建应用程序页面

点击创建新应用程序按钮后，我们需要点击从头开始。
然后，我们将看到一个弹出窗口，可以设置我们的新 Slack 机器人：

图 9.6 – Slack，API 名称应用程序及选择工作区窗口

点击创建应用程序。这将带您到基本信息页面。在此页面上，点击机器人，如以下截图所示：

图 9.7 – Slack，API 添加功能和功能页面

这将带您到新应用程序的应用主页。在页面的左侧，点击OAuth & 权限选项。
向下滚动至范围并点击添加 OAuth 范围：

图 9.8 – Slack，API 范围

从下拉菜单中，点击chat:write，以允许我们的机器人向频道发送消息：

图 9.9 – Slack，API 添加 OAuth 范围下拉菜单

对im:write和groups:write做同样的操作。
向上滚动并点击安装到工作区按钮以完成应用程序的设置：

图 9.10 – Slack，API 安装到工作区按钮

接下来，您将看到一个弹出消息。点击出现的绿色允许按钮。
点击允许后，您将看到新的令牌。通过点击复制按钮复制令牌：

图 9.11 – Slack，API 我们的新 Bot 用户 OAuth 令牌

最后，通过返回 Slack 频道，点击右上角的成员，选择集成，将您的机器人添加到# zabbix-notifications频道：

图 9.12 – Slack，连接应用程序到频道

点击添加 应用程序。
只需点击白色的添加按钮，添加Zabbix-Alert-Bot：

图 9.13 – Slack，连接应用程序与机器人

现在，导航到你的 Zabbix 前端，进入警报 | 媒体类型。
点击Slack来编辑 Slack 媒体类型。你将看到一整套预配置的参数。我们需要将 OAuth 令牌粘贴到bot_token参数中，如下所示：

图 9.14 – Zabbix，Slack 媒体类型编辑页面

同时，确保通过滚动到页面底部启用媒体类型。
在消息模板标签页下，我们已经配置了五种消息类型。如果需要，我们可以根据自己的需求进行编辑。

图 9.15 – Zabbix，Slack 消息类型的媒体类型编辑页面

现在，你可以点击更新来保存更改。
现在，通过导航到用户 | 用户组并点击右上角的创建用户组按钮，创建一个新的用户组来为我们的媒体类型提供支持。添加以下用户组：

图 9.16 – Zabbix，创建外部服务组的用户组页面

点击主机权限标签，然后点击选择。确保选择所有具有至少读取权限的组和子组，如下所示：

图 9.17 – Zabbix，创建外部服务组的用户组主机权限

重要说明

在为用户组应用权限时，请确保只添加你希望接收通知的主机组。在我的实验室环境和生产环境中，我通常会添加所有组，但有时我们希望筛选通知。实现这一点的一种方法是使用不同的用户组和用户，这样你就只会在特定的频道接收来自某些主机组的通知，尽管使用动作也是一种很好的方法。欲了解更多关于 Zabbix 用户权限和触发器的内容，请查看第二章，使用 Zabbix 用户管理做好准备，以及第四章，使用触发器和警报。

现在，点击蓝色的添加按钮，完成用户组的创建。
接下来，导航到用户 | 用户来创建一个 Slack 用户。在右上角点击蓝色的创建用户按钮。
将以下用户添加到你的 Zabbix 服务器，并确保为其设置一个安全的密码：

图 9.18 – Zabbix 为 Slack 用户创建的用户页面

提示

在为警报或 API 访问等创建用户时，最佳做法是将用户添加到一个禁用前端访问的用户组中。这就是我们在这里添加无前端访问组的原因。

现在，点击媒体标签，然后点击带下划线的添加文字。我们将为此用户添加以下媒体：

图 9.19 – Zabbix 为 Slack 用户创建用户媒体页面

所有用户还需要一个用户角色。要添加它，前往权限并添加以下内容：

图 9.20 – Zabbix 为 Slack 用户创建用户媒体页面，权限

重要说明

为了方便，我们在示例中将该用户添加到超级管理员角色中。这会覆盖我们为外部服务用户组分配的只读权限。出于安全原因，你可能希望通过为用户选择用户或管理员角色来限制权限，这将遵循我们之前为主机组分配的权限。

点击窗口底部的蓝色添加按钮，然后点击页面底部的蓝色添加按钮。
我们还需要在管理 | 宏中添加一个宏。让我们添加以下宏，其中包含你的 Zabbix URL：

图 9.21 – Zabbix 管理 | 带有 Zabbix URL 的宏页面

点击蓝色的更新按钮。
最后，前往警报 | 操作，在触发操作页面上，点击蓝色的创建操作按钮。
使用通知外部服务作为操作的名称。我们不会为这个示例设置任何条件，但建议在生产环境中设置。如果不设置任何条件，所有问题都将匹配此操作。
前往操作并添加以下操作：

图 9.22 – Zabbix，为“通知外部服务”创建操作页面

提示

我们也可以在这里使用通知所有相关人员，向所有参与操作步骤的用户发送消息。

现在，点击蓝色的添加按钮。完成后，你就可以在 Slack 渠道中查看任何新生成的问题（由 Zabbix 生成）：

图 9.23 – 从我们的 Zabbix 服务器发送的 Slack 通知

它是如何工作的……

使用媒体类型可能对你来说是完全新的，或者你过去可能做过。不管怎样，从 Zabbix 5 开始，过程稍有变化。在 Zabbix 5 之前的版本中，我们需要在线寻找合适的媒体类型或自己创建它们。

现在，借助 Zabbix 7，我们获得了许多预配置的媒体类型，已经可以直接使用。我们只需做必要的设置并填写正确的信息，就像我们刚刚为 Slack 所做的那样。然后，每当创建问题时，我们就可以将与问题相关的信息从 Zabbix 7 发送到 Slack。

在本配方中，我们告诉 Zabbix 服务器只将严重性为警告或更高的与问题相关的信息发送到 Slack，如下图所示：

图 9.24 – Zabbix 媒体页面（Slack 用户）

我们可以完全自定义这些严重性级别，但我们也可以完全自定义将哪些严重性级别发送到我们的 Slack 设置中。

我们在本章中配置的内容被称为Zabbix webhook。当 Zabbix 中创建一个问题，并且这个问题符合我们配置的标准（如其严重性）时，我们的操作与问题匹配，媒体类型将通过Action操作执行，并发送到配置的链接：

图 9.25 – Zabbix Slack 集成示意图

Zabbix 将问题发送到 Slack API，然后 API 处理该问题。接着，我们在 Slack 中配置的应用程序将问题发布到我们的频道。

现在，我们已经完成了这个配置，可以在 Slack 中查看问题，并从那里监控我们的 Zabbix 告警。

另见

如果你想进一步利用这个集成，查看 Slack API 文档。这个 API 可以做很多事情，我们可以为我们的频道构建一些非常棒的应用程序或机器人：api.slack.com/。

使用 Zabbix 设置 Microsoft Teams 告警

本书的上一版是在 COVID-19 大流行期间编写的。当时，许多 IT 公司要求员工在家办公。因此，我们注意到 Microsoft Teams 和类似应用的使用量激增。突然间，很多公司开始使用 Microsoft Teams 等工具，以便让远程工作和协作变得更加容易。即使在大流行结束后，这一趋势依然存在，这也是我们加入此配方的原因。

让我们学习如何通过将 Zabbix 告警集成到 Microsoft Teams 中，使工作变得更加高效。

准备工作

我们需要 Zabbix 服务器能够为我们创建一些问题。为此，你可以使用之前章节中的 lar-book-rocky，或者使用任何你喜欢的 Zabbix 服务器。

我们还需要具备基本的 Microsoft Teams 知识，当然，Microsoft Teams 本身也需要已经设置并准备就绪。

如何操作…

首先，我们需要打开 Microsoft Teams 应用程序，无论是在 Windows、macOS 还是 Linux 上，然后创建一个新频道。进入Teams，点击团队名称旁边的三个点（…），如下图所示：

图 9.26 – MS Teams，添加频道选项

在添加频道窗口中，填写以下信息以创建我们的新频道：

图 9.27 – MS Teams，添加频道窗口

现在，点击紫色的添加按钮以添加频道。完成后，我们将能够在列表中看到我们的新频道。
点击频道旁边的三个点（...），如下图所示：

图 9.28 – MS Teams，连接器选项

我们想从这个下拉菜单中选择连接器选项。这将允许我们将 Microsoft Teams 连接器添加到此频道。
我们在这里使用搜索字段来查找官方的Zabbix Webhook连接器：

图 9.29 – MS Teams，添加连接器窗口

点击Zabbix Webhook连接器旁边的配置按钮，将此连接器添加到我们的频道中。此操作将打开一个弹出窗口，您需要复制 webhook URL。![图 9.30 – MS Teams – Webhook URL]

图 9.30 – MS Teams – Webhook URL

现在，点击保存按钮。完成此操作后，您可以关闭弹出窗口。
前往 Zabbix 前端，导航到警报 | 媒体类型。点击这里的MS Teams媒体类型。
向下滚动，直到看到teams_endpoint。将之前复制的 URL 粘贴到这里，如下图所示：

图 9.31 – Zabbix 警报 | 媒体类型，编辑 MS Teams 页面

确保向下滚动并启用媒体类型，然后再保存。
现在，点击页面底部的蓝色更新按钮。
如果你没有按照之前的步骤操作，请通过导航到用户 | 用户组并点击右上角的创建用户组按钮来为我们的媒体类型创建一个新的用户组。添加以下用户组：

图 9.32 – Zabbix，创建用户组页面，外部服务组

点击主机权限标签，然后点击选择。确保你选择了所有拥有读取权限的组和子组。权限标签将如下所示：

图 9.33 – Zabbix，创建用户组权限页面，外部服务组

现在，点击蓝色的添加按钮，完成创建此用户组。
导航到用户 | 用户，然后点击右上角的蓝色创建用户按钮。添加以下用户：

图 9.34 – Zabbix 用户 | 用户，创建新用户页面，MS Teams

提示

在创建用于警报或仅仅用于 API 访问的用户时，最佳做法是将该用户添加到一个禁用前端访问的用户组。因此我们在这里添加了无前端访问用户组。

接下来，进入创建用户页面的媒体标签。点击下划线的添加文本，在此创建以下媒体：

图 9.35 – Zabbix 用户 | 用户，创建新用户媒体页面，MS Teams

所有用户还需要一个用户角色。要添加它，请进入权限并添加以下内容：

图 9.36 – Zabbix – 创建用户媒体页面，MS Teams 用户，权限

重要说明

为了方便起见，我们在示例中将用户添加到了超级管理员角色。这覆盖了我们为外部服务用户组分配的只读权限。为了限制权限，请选择用户或管理员角色，这将遵守我们之前分配的主机组权限。

填写完这些信息后，点击窗口底部的蓝色添加按钮，然后在页面底部再次点击蓝色添加按钮。
如果你没有遵循之前的步骤，你还需要在管理 | 宏中添加一个宏，并添加以下宏。这个宏将包含你的 Zabbix URL：

图 9.37 – Zabbix 管理 | 宏页面，适用于 MS Teams 的 Zabbix URL

点击蓝色的更新按钮。如果你没有遵循之前的步骤，还需要进入警报 | 操作，在触发器操作页面上点击蓝色的创建操作按钮。
使用通知外部服务作为操作名称。我们不会在这个示例中设置任何条件，但建议在生产环境中设置条件。如果不设置任何条件，所有问题将匹配此操作。
进入操作，并添加以下操作：

图 9.38 – Zabbix，创建操作操作页面，通知外部服务以供 MS Teams 使用

现在，点击蓝色的添加按钮，你就完成了。现在，你可以在 MS Teams 渠道中查看发生的新问题：

图 9.39 – Zabbix 问题在 MS Teams 渠道中

它是如何工作的……

Microsoft Teams 的工作方式大致与我们的 Slack 设置相同。Zabbix 服务器中创建一个问题，如果该问题符合我们在 Zabbix 中配置的条件，我们会将该问题发送到 Microsoft Teams 连接器。

例如，我们配置了 Zabbix，使其只将警告或更高严重性的故障发送到 Microsoft Teams，如下所示：

图 9.40 – MS Teams 用户的 Zabbix 媒体页面

我们的 Microsoft Teams 连接器捕捉到我们的故障，并且由于这个连接器直接配置在我们的频道中，它会向频道发送通知：

图 9.41 – Zabbix Microsoft Teams 集成图

现在，我们可以在我们的频道中看到 Teams 通知，并通过 Microsoft Teams 直接跟踪所有 Zabbix 问题。

另请参见

有关 Zabbix webhook 连接器的更多信息，请查看此页面：appsource.microsoft.com/en-us/product/office/WA200001837?tab=Overview。

使用 Telegram 机器人与 Zabbix

如果你喜欢聊天应用中的自动化，可能听说过或使用过 Telegram Messenger。Telegram 拥有强大的 API 和惊人的机器人功能。

在这个教程中，我们将使用 Telegram 机器人为 Zabbix 警报创建一个 Telegram 群组。让我们开始吧。

准备就绪

确保你的 Zabbix 服务器已经准备好。你可以使用lar-book-rocky或任何能够发送警报的 Zabbix 服务器。

如果你对 Telegram 有一些了解，那会很有帮助，但我将逐步描述如何设置，即使你从未使用过 Telegram 机器人。只要确保你已经在电脑上安装了 Telegram 应用，并且你的账户已经设置好。

如何操作…

首先，我们来在 Telegram 中创建一个新频道。点击搜索框旁的创建图标，然后选择新建组：

图 9.42 – Telegram 新建组按钮

添加另一个用户——你团队中需要接收通知的人员。如果需要，可以填写组名并添加图片：

图 9.43 – Telegram 新建组页面

现在，点击右上角的创建按钮。这将带你进入新建组页面。
使用 Telegram 机器人变得简单，只需通过 Telegram 上的@BotFather用户即可开始。我们可以通过搜索botfather并点击指定的联系人来创建我们的机器人：

图 9.44 – Telegram，BotFather 用户

让我们首先在聊天中发出/start命令。这将为你提供一个可以使用的命令列表：

图 9.45 – Telegram，BotFather 用户帮助列表

现在，让我们通过在BotFather聊天中输入/newbot来立即创建一个新的机器人。按下Enter键发送消息。这样我们就会得到如下结果：

图 9.46 – Telegram，BotFather /newbot 命令

输入机器人的新名称；我们将其命名为zabbix-notfication-bot。按Enter键发送您的名称：

图 9.47 – Telegram，BotFather 机器人用户名

系统将要求您为机器人指定用户名。我将使用lar_ zbx_notfication_bot：

图 9.48 – Telegram，BotFather 机器人令牌

重要提示

您的机器人用户名必须是唯一的，因此您不能在这里使用lar_zbx_ notification_bot。选择一个独特的机器人名称并在整个操作中使用该名称。

确保将HTTP API密钥保存在一个安全的地方。
让我们回到我们的Zabbix 通知群组并添加我们的机器人。在聊天列表中点击该群组并点击群组名称。
现在，点击添加来添加机器人，如下所示：

图 9.49 – Telegram，添加用户到群组按钮

接下来，您需要通过机器人的用户名搜索您的机器人，如下图所示：

图 9.50 – Telegram，添加用户到群组页面

点击机器人并点击添加按钮。这样，您的机器人就添加到频道中了。
让我们进入 Zabbix 前端并导航到警报|媒体类型。点击标题为Telegram的媒体类型。
在这里，您必须将之前生成的HTTP API密钥添加到我们媒体类型的Token字段中：

图 9.51 – Zabbix 警报 | 媒体类型，编辑 Telegram 媒体类型页面

同时，向下滚动并确保启用此媒体类型。
点击页面底部的蓝色更新按钮以完成编辑Telegram媒体类型。
现在，让我们回到 Telegram，并将另一个机器人添加到我们的群组中。进入我们的新群组并点击群组名称。点击添加以添加IDBot用户：

图 9.52 – 添加用户页面（Telegram 群组）

点击用户并点击添加。然后，返回 Zabbix 前端。
如果您没有按照之前的任何操作创建，请通过导航到用户|用户组并点击右上角的创建用户组按钮，创建一个新的用户组。添加以下用户组：

图 9.53 – Zabbix 创建用户组页面及用于 Telegram 的外部服务组

点击主机权限标签并点击选择。确保选择所有具有读取权限的组和子组，如下所示：

图 9.54 – Zabbix 创建用户组权限页面，供 Telegram 使用的外部服务

现在，点击蓝色的添加按钮，完成创建此用户组。
此时，你必须在 Zabbix 中创建一个新用户。然而，要创建这个用户，你需要我们新的组 ID。返回 Telegram 并在群聊中发送/getgroupid@myidbot。你将收到一个值，并需要复制该值：

图 9.55 – Telegram 用户组 ID

现在，导航到用户 | 用户并点击蓝色的创建用户按钮。添加以下用户：

图 9.56 – Zabbix 创建用户页面，Telegram 用户

提示

当为警报或 API 访问创建用户时，最佳实践是将该用户添加到一个禁用前端访问的用户组中。这就是为什么我们在这里添加了无前端访问组。

现在，选择媒体标签并点击带下划线的添加文本。添加以下媒体：

图 9.57 – Zabbix 创建用户媒体页面，Telegram 用户

所有用户还需要一个用户角色。要添加它，请进入权限并添加以下内容：

图 9.58 – Zabbix 创建用户媒体页面，Telegram 用户，权限

重要提示

为了方便起见，我们在示例中将用户添加到超级管理员用户角色中。这会覆盖我们分配给外部服务用户组的只读权限。若要限制权限，请为你的用户选择用户或管理员角色，这将遵循我们之前分配的主机组权限。

确保将组 ID 添加到发送至字段，并带有–文本，然后点击蓝色的添加按钮。
如果你没有按照之前的步骤操作，你还需要进入警报 | 操作。然后，在触发操作页面上，点击蓝色的创建操作按钮。
使用通知外部服务作为操作名称。对于本示例，我们不会设置任何条件，但在生产环境中建议这么做。如果你不设置任何条件，所有问题都会匹配此操作。
进入操作并添加以下操作：

图 9.59 – Zabbix – 创建操作页面，通知外部服务以供 Telegram 使用

现在，点击蓝色的添加按钮。至此，你完成了。现在，你可以在你的 Telegram 群组中查看新的问题：

图 9.60 – Zabbix 在 Telegram 聊天中的通知

它是如何工作的…

Slack 应用、Microsoft 连接器和 Telegram 机器人最终的工作方式都差不多。它们只是由各自公司提供了另一个后台（API），但 Zabbix 的 webhook 保持不变。

现在我们已经添加了 Zabbix Telegram 集成，我们通过 Zabbix webhook 正在向我们的 Telegram 群组发送通知：

图 9.61 – Zabbix 用户 | 用户，编辑用户媒体页面

然而，只有当通知符合我们配置的设置时，我们才会接收到这些通知。例如，我们已经添加了媒体类型，以便只将严重性为警告或更高的问题发送到我们的 Telegram 机器人：

图 9.62 – Zabbix Telegram 集成图示

现在，我们的 Zabbix 服务器将符合操作条件的问题发送到我们的 Telegram 机器人。机器人成功地捕获了这些问题。由于我们的机器人在 Telegram 群组中，这些问题就被发布到我们的 Telegram 群组中。

还有更多…

Telegram 上有一个非常酷的 Zabbix 社区群组。既然你已经安装了 Telegram，别忘了通过以下邀请链接加入：t.me/ZabbixTech。

另见

确保你查看 Telegram 机器人所提供的所有精彩功能。Telegram 提供了大量的直接信息，你可以通过使用它们构建出令人惊叹的集成：core.telegram.org/bots。

将 Atlassian Opsgenie 与 Zabbix 集成

Atlassian Opsgenie 不仅仅是另一个接收通知的集成服务。Opsgenie 为我们提供了一个呼叫系统、短信系统、iOS 和 Android 应用、双向确认，甚至还有值班安排。

我认为 Opsgenie（和 PagerDuty）是取代老式呼叫和短信系统并与 Zabbix 完全集成的最佳工具。所以，让我们从 Opsgenie 开始，看看如何设置这个惊人的工具。

准备工作

确保你的 Zabbix 服务器已准备好。我将使用 lar-book-rocky 服务器，但任何准备好发送问题的 Zabbix 服务器都可以使用。

你还需要一个 Atlassian Opsgenie 账户，并且确保 Opsgenie 已经准备好。这次的集成与之前的示例稍有不同，因为我们还将使用一些脚本。

我不会展示如何创建账户，但我们将从 Opsgenie 已经准备好的状态开始这个方案。

如何操作…

首先，登录到我们的 Atlassian Opsgenie 设置，并进入首页的设置。在左侧边栏中，点击通知。
确保你通过使用 + 添加电子邮件 和 + 添加电话号码 按钮添加了你的电子邮件和电话号码。我们需要这些信息来接收通知：

图 9.63 – Opsgenie 配置文件，联系方式

一旦添加了设置，它们将自动保存，这意味着我们可以从设置导航到团队，通过顶部的导航栏进行切换。
在团队标签页中，点击右上角的蓝色添加团队按钮。然后，添加以下信息：

图 9.64 – Opsgenie，添加团队窗口

我已经为我们的Consultancy团队设置了两个用户，他们是该团队的一部分。点击窗口底部的蓝色添加按钮以添加新团队。
这将带你到新的Consultancy团队页面。点击集成，然后点击右上角的蓝色添加集成按钮。
当我们使用搜索字段搜索 Zabbix 集成时，我们可以立即看到它，如下截图所示：

图 9.65 – Opsgenie，添加集成页面

点击 Zabbix 集成。这将带你到下一个页面，生成名称和API 密钥值：

图 9.66 – Opsgenie，添加 Zabbix 集成页面

复制API 密钥信息并滚动到底部。在这里，点击蓝色的保存集成按钮。

现在，导航到你的 Zabbix 服务器 CLI，并执行以下代码。

对于基于 RHEL 的系统，请使用以下命令：

wget https://github.com/opsgenie/oec-scripts/releases/download/Zabbix-1.1.6_oec-1.1.3/opsgenie-zabbix-1.1.6.x86_64.rpm
wget https://github.com/opsgenie/oec-scripts/releases/download/Zabbix-1.1.6_oec-1.1.3/opsgenie-zabbix_1.1.6_amd64.deb

我们现在可以通过执行以下命令来安装下载的 Zabbix Opsgenie 插件：

对于基于 RHEL 的系统，请使用以下命令：
```
rpm -i opsgenie-zabbix-1.1.6.x86_64.rpm
```
对于 Ubuntu 系统，请使用以下命令：
```
dpkg -i opsgenie-zabbix_1.1.6_amd64.deb
```
安装插件后，前往 Zabbix 前端。如果你没有按照之前的步骤操作，请通过导航到用户 | 用户组并点击右上角的创建用户组按钮来为我们的媒体类型创建一个新的用户组。添加以下用户组：

图 9.67 – Zabbix 创建用户组页面，适用于 Opsgenie 的外部服务组

点击权限标签，然后点击选择。确保你选择了所有具有读取权限的组和子组，如下所示：

图 9.68 – Zabbix 创建用户组权限页面，适用于 Opsgenie 的外部服务组

现在，点击蓝色的添加按钮，完成创建这个用户组。
让我们导航到用户 | 用户，然后点击蓝色的创建用户按钮。添加以下用户：

图 9.69 – Zabbix 创建用户页面，Opsgenie 用户

提示

在为警报或仅仅是 API 访问创建用户时，最佳实践是将用户添加到一个禁用前端访问的用户组中。这就是我们在这里添加无前端访问组的原因。

所有用户还需要一个用户角色。要添加此角色，请转到权限并添加以下内容：

图 9.70 – Zabbix 创建用户媒体页面，Opsgenie 用户，权限

重要提示

为了方便起见，我们在示例中将用户添加到超级管理员用户角色中。这会覆盖我们为外部服务用户组分配的只读权限。为了限制权限，请为您的用户选择用户或管理员角色，这将遵循我们之前分配的主机组权限。

为了在我们的操作中使用，我们需要设置一个脚本；为此，请导航到警报 | 脚本，然后点击右上角的创建脚本。
我们将脚本命名为Opsgenie connector。将范围设置为操作操作，类型设置为脚本，并将执行于设置为Zabbix 服务器。
将/home/opsgenie/oec/opsgenie-zabbix/actionCommand.txt文件的内容粘贴到 CLI 的命令中，应该像下面的截图一样：

图 9.71 – Zabbix Opsgenie 连接器脚本

别忘了点击页面底部的添加按钮来保存这个新脚本。
接下来，导航到警报 | 操作。在触发操作页面上，点击右上角的蓝色创建操作按钮。
在名称字段中，输入Opsgenie 操作，并将以下项目添加到条件中：

图 9.72 – Zabbix 创建新操作页面，Opsgenie 操作

现在，点击操作标签页。
点击操作旁边下划线的添加文本选项以添加第一个操作。在操作下拉菜单中，选择Opsgenie 连接器。

图 9.73 – Zabbix 创建操作窗口，Opsgenie 连接器

对恢复操作和更新操作重复步骤 24。它应该像这样：

图 9.74 – Zabbix 创建操作页面，Opsgenie 操作

点击页面底部的蓝色添加按钮以完成操作设置。
现在，您必须配置 Opsgenie Zabbix 集成。使用以下命令编辑config文件：
```
vim /home/opsgenie/oec/conf/config.json
```
确保编辑apiKey、command_url、user和password行，如下所示的截图所示：

图 9.75 – Opsgenie config.json 文件

重要提示

如果你不在美国，你需要编辑 baseUrl。我在欧洲，所以我将其更改为 api.eu.opsgenie.com。

就这些！现在你可以看到警报进入并在 Opsgenie 中确认它们：

图 9.76 – 来自 Zabbix 的 Opsgenie 警报

它是如何工作的…

当 Zabbix 中创建警报时，它会通过 Zabbix 集成发送到 Opsgenie。这个集成利用了 Opsgenie API 来获取我们的 Zabbix 信息，并在需要时发送回回复。通过这种方式，我们在两个应用之间实现了双向通信：

图 9.77 – Opsgenie 设置图

Opsgenie 是一款出色的工具，可以将多个任务从 Zabbix 服务器中移除。我曾经使用它将监控工具从另一个平台迁移到 Zabbix。Opsgenie 让我们轻松接收来自产品的警报并集中管理通知：

图 9.78 – Opsgenie 设置示例，灵感来自 Wadie

Atlassian Opsgenie 的另一个伟大功能是它与其他 Atlassian 产品的集成。我们可以建立一个类似前面图示的设置，将公司中使用的所有产品进行集成。

还有更多…

Opsgenie 不仅仅允许我们发送通知。它还使我们能够在产品内定义完整的值班时间表，这让我们在程序中创建时间表变得非常简单，而 Zabbix 在这方面可能有些静态。请查看以下链接，了解如何操作：

support.atlassian.com/opsgenie/docs/manage-on-call-schedules-and-rotations/

此外，也有一些竞争产品与 Opsgenie 一样集成得很好。PagerDuty 就是其中之一，提供原生的 Zabbix 集成。它具有类似的功能集，最终的选择取决于个人偏好、我们可能已经拥有的其他软件，以及… 价格！

第十章：使用自定义脚本和 Zabbix API 扩展 Zabbix 功能

Zabbix 提供了很多开箱即用的功能。但 Zabbix 真正出色的地方在于其可定制性，不仅仅是通过默认的前端，尤其是通过脚本和 Zabbix API 来进行扩展。

本章中，我将讲解如何使用 Zabbix API 的基础知识。接着，我们将看到如何通过 Python 脚本利用 API 构建一些有趣的功能，例如跳板主机。之后，我们将使用 Brian van Baekel 编写的脚本，通过 Zabbix 地图启用和禁用具有有限权限的主机。

跟随这些食谱，你将完全准备好应对 Zabbix API，并且能够使用脚本扩展 Zabbix 功能。本章将扩展你在 Zabbix 中的可能性，几乎是无限的，你将准备好成为一名专业的 Zabbix 用户。

本章将涵盖以下食谱：

设置和管理 API 令牌
使用 Zabbix API 扩展功能
使用 Zabbix API 和 Python 构建跳板主机
启用和禁用 Zabbix 地图中的主机

技术要求

我们将需要一个 Zabbix 服务器和一些新的 Linux 主机。我们还需要具备一些基本的脚本和编程知识。我们将使用 Python 来扩展 Zabbix 的一些功能，并为此提供相应的脚本。

本章所需的代码可以在以下链接找到：

github.com/PacktPublishing/Zabbix-7-IT-Infrastructure-Monitoring-Cookbook/tree/main/chapter10

确保一切准备就绪，你就一定能掌握这些食谱。

设置和管理 API 令牌

本章开始时，我们将进行一些 Zabbix API 配置。如果你之前使用过 Zabbix API，可能会知道通过 API 调用来认证并获取 API 令牌以在脚本中使用是非常麻烦的。但现在情况不同了，我们可以通过 Zabbix 前端生成 API 令牌。

准备工作

对于这个食谱，我们只需要 Zabbix 设置正在运行。我们将使用前端生成 API 令牌。从这里，我们可以在本章后续的集成中使用 API 令牌。

如何操作…

首先，让我们以超级管理员用户身份登录到 Zabbix 前端。
导航到用户 | 用户组，然后点击右上角的蓝色 创建用户组 按钮。
在这里，我们将创建一个新用户组。在组名字段中填写 API 用户。
切换到 主机权限 标签，点击选择按钮并选择所有主机组，授予你的 API 用户组对每个主机的权限。

图 10.1 – Zabbix 用户 | 用户组，创建用户组主机权限，API 用户

接下来，转到模板权限选项卡，并在这里做同样的操作。

图 10.2 – Zabbix 用户 | 用户组，创建用户组模板权限，API 用户

点击弹出窗口底部的蓝色选择按钮，然后点击读写，接着点击小圆点的添加按钮。现在应该看起来像这样：

图 10.3 – Zabbix 用户 | 用户组，用户组权限页面，API 用户

提示

我们可以选择不以超级管理员身份创建 API 用户，而是通过限制API 用户用户组中的主机和模板组访问权限来限制权限。这在生产环境中可能更受欢迎，因为你可能希望限制 API 访问。使用适合你需求的方式。

点击页面底部的蓝色添加按钮，添加此新的用户组。
现在，让我们转到用户 | 用户并点击右上角的蓝色创建用户按钮。
在这里，我们将创建一个新的用户，称为API 用户。创建用户如下：

图 10.4 – Zabbix 用户 | 用户，用户创建页面，API 用户

在添加用户之前，切换到权限选项卡并添加超级管理员角色。

图 10.5 – Zabbix 用户 | 用户，用户权限页面，API 用户

现在，我们可以通过点击页面底部的蓝色添加按钮来添加用户。
接下来，我们需要为这个用户创建一些 API 令牌。进入用户 | API 令牌。
接下来，点击右上角的蓝色创建 API 令牌按钮，并将用户字段填写为API，名称字段填写为API 图书密钥。将过期时间设置为未来某个较远的时间，或者完全禁用过期——选择你认为最安全的方式。它应该看起来像这样：

图 10.6 – 管理 | 一般 | API 令牌，API 令牌创建页面

点击页面底部的蓝色添加按钮，生成新的 API 令牌。这将带我们到下一个页面：

图 10.7 – Zabbix API 用户 API 令牌生成页面

确保将认证令牌的值保存到一个安全位置，例如密码保险库。稍后在实验中它会很重要。
现在我们可以点击页面底部的关闭按钮。这将带我们返回到API 令牌页面，在那里我们可以管理所有已创建的 API 令牌。

图 10.8 – Zabbix API 用户 API 令牌页面

它是如何工作的……

由于 Zabbix 现在自带内置的 API 令牌管理功能，因此使用 Zabbix API 变得更加容易。通过使用专用的 API 用户，我们可以在一个位置管理所有令牌，或者我们可以在自己的用户账户下设置私有的 API 令牌。

在这种情况下，我们创建了一个新的 API 用户组。这很重要，因为我们的 API 令牌仍然属于一个用户账户，这意味着它们将遵循该用户的权限。如果我们在除超级管理员以外的其他用户类型下创建 API 用户，我们可以通过 API Users 组来限制我们的 API 访问。

请确保将角色应用于用户并将权限赋予用户组，根据您的环境需求进行调整。同时，请确保为您的 API 令牌设置合理的过期日期，以便我们能够定期重新生成它们。

关于设置和管理 API 令牌，没什么太多需要说明的了，但让我们看看如何在接下来的教程中应用我们在本教程中学到的内容。

使用 Zabbix API 扩展功能

API 是你开始扩展任何软件功能的入口。幸运的是，Zabbix 提供了一个功能强大的 API，我们可以轻松地利用它来扩展功能。Zabbix 还为 Python 发布了 zabbix-utils，使得构建脚本变得更加容易。虽然这是一个很棒的附加功能，但由于并非每个环境都允许使用它，而且我们希望尽量减少依赖项，所以在本次测试中我们不会使用它。尽管如此，您可以在这里查看该库：

github.com/zabbix/python-zabbix-utils

在本教程中，我们将探索如何使用 Zabbix API 来执行一些任务，为在实际生产环境中使用 Zabbix API 打下良好的基础。

准备工作

我们将需要一个包含一些主机的 Zabbix 服务器。我将使用前几章中的 lar-book-centos 主机，但您可以自由使用任何 Zabbix 服务器。我还将使用另一台 Linux 主机来发起 API 调用，但这可以在任何 Linux 主机上完成。

我们需要在 Linux 主机上安装 Python 3，因为我们将使用它来创建 API 调用。

同时，确保你有一个 API 用户和 API 令牌。建议使用我们在第一章创建的令牌。

如何操作…

首先，在我们的 Linux CLI 中，让我们切换到一个新目录：
```
cd /home/zabbix/
```
使用以下命令在主机上安装 Python 3。

对于基于 RHEL 的系统，请使用以下命令：
```
dnf install python3
apt install python3
```
Python pip 应该已经随着该软件包默认安装。如果没有，请执行以下命令。

对于基于 RHEL 的系统，请使用以下命令：
```
dnf install python3-pip
```
对于 Ubuntu 系统，请使用以下命令：
```
apt install python3-pip
```

重要说明

您的 Linux 发行版可能附带较旧版本的 Python(3)。如果在本章后续脚本中遇到任何错误，请确保检查错误信息，确认您的 Python 版本是否支持某些功能。

现在，让我们使用 Python pip 安装所需的依赖项。我们将需要这些依赖项，因为它们将在脚本中使用：
```
pip3 install requests
```

从本书的 Packt GitHub 仓库下载我们脚本的开头，通过执行以下命令：

wget https://raw.githubusercontent.com/PacktPublishing/Zabbix-7-IT-Infrastructure-Monitoring-Cookbook/main/chapter10/api_test.py

如果你无法从主机上使用 wget，可以通过以下网址下载脚本：github.com/PacktPublishing/Zabbix-7-IT-Infrastructure-Monitoring-Cookbook/tree/main/chapter10/api_test.py。
接下来，我们将通过执行以下命令来编辑我们新下载的脚本：
```
vim api_test.py
```
首先，让我们将 url 变量中的 IP 地址 10.16.16.152 更改为你 Zabbix 服务器的 IP 或 DNS。然后，确保通过将 PUT_YOUR_TOKEN_HERE 替换为我们在本章第一部分生成的 API 令牌，来编辑 api_token 变量：
```
url = "http://10.16.16.152/api_jsonrpc.php"
api_token = "c01ce8726bfdbce02664ec8750f99da 1bbbcb3cb295d924932e2f2808846273"
```
我们还会在脚本中添加一些行代码，以便检索我们的主机 ID、主机名和所有 Zabbix 主机的接口。确保在以下截图中显示的注释之间添加新的代码：

图 10.9 – 注释显示代码放置位置

现在，添加以下几行代码：

#Function to retrieve the hosts and interfaces
def get_hosts(api_token, url):
    payload = {
    "jsonrpc": "2.0",
    "method": "host.get",
    "params": {
        "output": [
            "hostid",
            "host"
        ],
        "selectInterfaces": [
            "interfaceid",
            "ip",
            "main"
        ]
    },
    "id": 2,
    "auth": api_token
    }
    resp = requests.post(url=url, json=payload )
    out = resp.json()
    return out['result']

然后，我们还会添加几行代码，将请求的信息写入文件，以便我们查看执行后发生了什么：

#Write the results to a file
def generate_host_file(hosts,host_file):
    hostname = None
    f = open(host_file, "w")
    #Write the host entries retrieved from Zabbix
    for host in hosts:
        hostname = host['host']
        for interface in host["interfaces"]:
            if interface["main"] == "1":
                f.write(hostname + " " + interface["ip"] + "\n")
    f.close()
    return

现在你应该能够通过执行以下命令来运行它：
```
python3 api_test.py
```
这个应该能运行，但不会给你任何输出。如果这不起作用，请确保重新检查你的步骤。
让我们检查一下文件，看看通过执行以下命令发生了什么：
```
cat /home/zabbix/results
```
上述命令的输出应该像这样：

图 10.10 – 使用 cat 命令，显示我们结果的文件

我们现在已经编写了一个简短的 Python 脚本，用来使用 Zabbix API。

它是如何工作的……

使用 Zabbix API 进行编程可以通过 Python 实现，但这绝对不是我们唯一的选择。我们可以使用多种编程语言，包括 Perl、Go、C# 和 Java。

然而，在我们的示例中，我们使用的是 Python，所以让我们看看我们在这里做了什么。如果我们查看脚本，我们有两个主要功能：

get_hosts
generate_host_file

首先，我们填写了 api_token 和 url 变量，这些变量用于通过 Zabbix API 进行身份验证。然后我们使用这些变量调用 get_hosts 函数，从 Zabbix API 获取信息：

图 10.11 – Python 函数 Zabbix API 负载

查看代码时，我们使用了 JSON 负载来请求信息，如 host 获取主机名、hostid 获取主机 ID、ip 获取接口的 IP 地址。

现在，如果我们查看最后一个函数generate_host_file，我们可以看到，我们将带有接口 IP 的主机信息写入/home/results文件。这样，我们就有了一个可靠的脚本，可以将主机信息写入文件。

如果你不熟悉 Python 或编程，一开始使用 Zabbix API 可能是一个大挑战。让我们来看看 API 实际是如何工作的：

图 10.12 – Python 脚本 Zabbix API 功能图

在步骤 1中，我们发起一个 API 调用，使用我们目标 URL 和 API 令牌（如变量中所指定）进行身份验证。接下来，在步骤 2中，我们从 Zabbix 接收所请求的数据，并在我们的 Python 脚本中进一步使用这些数据。

步骤 3是我们的数据处理步骤。我们可以对从 Zabbix API 接收到的数据做任何我们想做的事情，但在我们的案例中，我们将数据格式化并写入文件。这就是我们如何使用 Zabbix API 扩展功能的方式。正是在这一阶段，我们的文件被填充了主机名和 IP 信息。

另请参见

如果你对 Zabbix API 及其可用功能感兴趣，可以查看 Zabbix 文档：www.zabbix.com/documentation/current/en/manual/api。

使用 Zabbix API 和 Python 构建跳板主机

很多组织都有一个跳板主机（有时也称为堡垒主机），用来通过这台主机访问服务器、交换机和其他设备。跳板主机通常具有访问所有重要设备所需的防火墙规则。现在，如果我们保持监控系统的最新状态，那么我们也应该将每一台主机添加到监控系统中。

我的朋友、前同事以及 Zabbix 爱好者Yadvir Singh，有一个很棒的想法，创建一个 Python 脚本，将所有 Zabbix 主机及其 IP 导出到另一台 Linux 主机上的/etc/hosts文件中。让我们看看如何构建一个类似的跳板主机。

准备工作

我们需要一台安装并准备好的 Linux 主机来进行这个实验。我们将这台主机命名为lar-book-jump。此外，我们还需要 Zabbix 服务器，我将使用lar-book-centos。

此外，重要的是要访问Yadvir的 GitHub 账户，关注他并给他的仓库加星，如果你认为这是一个很酷的脚本：github.com/cheatas/zabbix_scripts。

重要提示

设置此脚本将覆盖你/etc/hosts文件的内容，每次脚本执行时都会如此。仅在你理解脚本功能的前提下使用它，确保你使用一个空的主机用于此实验，并检查默认的/etc/hosts设置。

如何操作...

如果你还没有创建 API 用户和 API 令牌，请确保首先查看本章的第一个配方。
使用以下命令在主机 CLI 上安装 Python 3。

对于基于 RHEL 的系统，使用以下命令：
```
dnf install python3
apt-get install python3
```
Python 的pip应该已经默认与此包一起安装。如果没有，请执行以下命令：

对于基于 RHEL 的系统，使用以下命令：
```
dnf install python3-pip
```
对于 Ubuntu 系统，使用以下命令：
```
apt-get install python3-pip
```
现在，让我们使用 Python 的pip安装依赖项。我们将需要这些依赖项，因为它们将在脚本中使用：
```
pip3 install requests
```
首先，登录到我们的新 Linux 主机lar-book-jump，并使用以下命令将 Yadvir 的脚本下载到 Linux 主机上：
```
wget https://raw.githubusercontent.com/cheatas/zabbix_scripts/main/host_pull_zabbix.py
```
如果你无法从主机使用wget，可以通过以下网址下载脚本：github.com/cheatas/zabbix_scripts/blob/main/host_pull_zabbix.py。

作为备份，我们还在 Packt 仓库中提供了此脚本。你可以通过以下网址下载此版本：github.com/PacktPublishing/Zabbix-7-IT-Infrastructure-Monitoring-Cookbook/tree/main/chapter10/host_pull_zabbix.py。
现在，让我们通过执行以下命令来编辑脚本：
```
vim host_pull_zabbix.py
```
首先，让我们通过替换myzabbix.com/api_jsonrpc.php为我们 Zabbix 前端的 IP 地址或 DNS 名称，来编辑zabbix_url变量：
```
zabbix_url = "http://10.16.16.152/api_jsonrpc.php"
```
我们不需要填写用户名和密码，因为这仅在旧版本的 Zabbix 中需要。相反，我们将需要一个 API 令牌，正如在本章的第一个食谱中生成的那样。按照以下方式在脚本中填写api_token变量：
```
api_token = "c01ce8726bfdbce02664ec8750f99da1bbbcb3cb295
d924932e2f2808846273"
```
你可以在文件的底部找到此变量。

我们还需要取消注释以下几行：

zabbix_hosts = get_hosts(api_token,zabbix_url)
generate_host_file(zabbix_hosts,"/etc/hosts")

脚本的结尾现在应该如下所示：

图 10.13 – 在接收到 API 令牌并取消注释后，脚本的结尾

最后但同样重要的是，确保为你的 Linux 发行版注释和取消注释正确的行。它将如下所示：

对于 Ubuntu，命令应该如下所示：

图 10.14 – Ubuntu 系统的文件打印

对于基于 RHEL 的系统，命令应该如下所示：

图 10.15 – 基于 RHEL 的系统的文件打印

这就是要做的所有事情，所以现在我们可以再次执行脚本并开始使用它。让我们按照以下方式执行脚本：
```
python3 host_pull_zabbix.py
```
通过使用以下命令查看主机文件，测试它是否有效：
```
cat /etc/hosts
```
这应该会给我们一个像以下截图所示的输出：

图 10.16 – /etc/hosts 文件已填充脚本信息

现在，我们可以直接通过主机名尝试 SSH 连接，而不需要使用 IP 地址，执行以下命令：
```
ssh lar-book-agent_passive
```
我们还可以使用以下命令从文件中查找主机：
```
cat /etc/hosts | grep agent
```
让我们再做一件事。我们希望这个脚本尽可能保持最新。所以，让我们添加一个定时任务。执行以下命令来添加一个定时任务：
```
crontab -e
```

然后添加以下行，确保为你的设置填写正确的脚本位置：

*/15 * * * * $(which python3) /home/host_pull_zabbix.py >> ~/cron.log 2>&1

就这样——现在我们通过新的 Python 脚本和 Zabbix，/etc/hosts 文件将始终保持最新。

它是如何工作的……

如果你的组织将 Zabbix 作为主要监控系统，那么你现在已经具备了创建一个组织良好、始终可靠更新且易于使用的跳板主机的技能和知识。

当跳板主机正确设置时，它们非常有用，但重要的是要保持它们的清洁，这样它们才容易更新。

通过使用这个脚本，我们只需在服务器上添加 Python 3 和一个简单的脚本作为要求，但最终的结果是一个能够了解所有环境中主机的跳板主机。

如果你已经跟随了之前的 使用 Zabbix API 扩展功能 的教程，那么你可能会注意到它的工作方式大致相同。我们可以通过下图来看我们如何利用这个脚本：

图 10.17 – 使用脚本功能的跳板主机图

编辑后，我们的脚本将从图中的 第 1 步 开始，通过 API 调用请求数据，我们使用 API 令牌进行身份验证。在 第 2 步 中，我们接收这些数据。在脚本中，我们添加默认值，然后将所有主机名和 IP 地址写入 /etc/hosts 文件。

现在，因为 Linux 主机使用 /etc/hosts 文件进行主机名到 IP 地址的转换，我们可以在 Zabbix 中使用服务器的真实名称通过 SSH 连接到主机。这使得我们使用跳板主机变得更加方便，因为我们可以使用与 Zabbix 前端中已知的主机名相同的名称。

参见

Yadvir 会在写完这个脚本后继续更新它（到目前为止，我们一直在使用 1.0 版本）。确保关注他的 GitHub 账号并为他的仓库加星，以获取更新。如果你有一些很棒的功能建议，随时可以提交拉取请求。

Zabbix 社区鼓励分享像这样的酷点子和有用的脚本。正如 Yadvir 所展示的那样，我们可以互相分享非常有价值的资源。像 Yadvir 一样——使用 Zabbix 社区 GitHub，并通过向其他 Zabbix 用户的 GitHub 仓库贡献来支持他们。你可以通过以下链接访问 Zabbix 社区 GitHub：

github.com/zabbix/community-templates

从 Zabbix 地图启用和禁用主机

我们注意到，作为 Zabbix 用户无法启用或禁用主机。对于一些公司来说，这可能是一个需求，所以我们为此创建了一个扩展。在本教程中，我将向你展示如何使用这个 Python 脚本并从地图上执行它。

准备工作

对于这个教程，我们所需要的只是 Zabbix 服务器、一些 Python 知识以及 Zabbix API 的一些知识。

如何操作……

首先，让我们登录到 Zabbix 服务器的 CLI 并创建一个新目录：
```
mkdir /etc/zabbix/frontendscripts
```
切换到新目录：
```
cd /etc/zabbix/frontendscripts
```

现在，从开源 ICT 解决方案的 GitHub 下载公共脚本：

wget https://github.com/OpensourceICTSolutions/zabbix-toggle-hosts-from-frontend/archive/v2.0.tar.gz

如果你无法从主机使用wget，可以在这里查看脚本：github.com/OpensourceICTSolutions/zabbix-toggle-hosts-from-frontend/releases/tag/v2.0。
使用以下命令解压文件：
```
tar -xvzf v2.0.tar.gz
```
使用以下命令删除tar文件：
```
rm v2.0.tar.gz
```

使用以下命令将脚本从新创建的文件夹移动过来：

mv zabbix-toggle-hosts-from-frontend-2.0/enable_disable-host.py ./

我们将需要 Python 来使用这个脚本，因此让我们按如下方式安装它。

对于基于 RHEL 的系统，使用以下命令：
```
dnf install python3 python3-pip
```
对于 Ubuntu 系统，使用以下命令：
```
apt-get install python3 python3-pip
```
我们还需要从pip安装requests模块。按如下方式安装：
```
pip3 install requests
```
现在，让我们使用以下命令编辑脚本：
```
vim enable_disable-host.py
```
在这个文件中，我们将修改url和token变量。将url变量更改为你的 Zabbix 前端 IP 或 DNS 名称。然后，将PUT_YOUR_TOKEN_HERE替换为你的 Zabbix API token。我将填写以下内容，但请确保输入你自己的信息：
```
url = 'http://10.16.16.152/api_jsonrpc.php?'
token = " c01ce8726bfdbce02664ec8750f99da1bbbcb3cb295d
924932e2f2808846273 "
```
现在，我们可以继续到 Zabbix 前端，添加前端脚本。导航到警报 | 脚本，然后点击右上角的蓝色创建脚本按钮。
添加以下脚本：

图 10.18 – Zabbix 警报 | 脚本，创建脚本页面，启用

点击蓝色的添加按钮，然后，在下一页中，再次点击右上角的蓝色创建脚本按钮。
现在，添加第二个也是最后一个脚本，如下所示：

图 10.19 – Zabbix 警报 | 脚本，创建脚本页面，禁用

现在，导航到监控 | 地图，你应该能看到一个名为本地网络的地图，因为它是 Zabbix 默认包含的。点击这个地图（或任何包含主机的其他地图）。
现在，如果你在地图上点击某个主机，你将看到一个下拉菜单，像这样：

图 10.20 – Zabbix 监控 | 地图，本地网络地图下拉菜单

如果我们点击这里的禁用，我们会得到一个弹出消息，内容如下：

图 10.21 – Zabbix 脚本确认窗口

点击蓝色的执行按钮，这个主机将被禁用。然后，导航到监控 | 主机以确认是否成功。你应该能看到主机被设置为禁用。
返回监控 | 地图，你可以通过相同的下拉菜单再次启用主机。这次选择启用。

它是如何工作的…

我们刚刚使用的脚本是用 Python 构建的，利用 Zabbix API。通过这个脚本，我们现在可以作为 Zabbix 用户从 Zabbix 前端启用和禁用主机。

之所以这样有效，是因为监控 | 地图选项即使对于 Zabbix 用户也可用。不过，这个脚本是使用 API 用户来执行的。由于我们的 Zabbix API 用户拥有更多的用户权限，它可以执行该脚本，从 Zabbix 数据库中获取主机信息，并使用这些信息创建维护期。正如下图所示，我们的脚本大致遵循与其他 Zabbix API 工具相同的步骤：

图 10.22 – Python 脚本 maintenance.py 执行图

因为 Zabbix API 非常灵活，我们可以拉取数据并写入数据，几乎可以做任何我们在前端做的事情。

我们现在可以在 Zabbix 前端的任何地方使用这个很酷的功能，只要我们看到带有主机名的虚线，即使是从监控 | 主机中也可以。

还有更多内容…

在 Zabbix 7 中，可以通过前端向脚本提供输入。如果你想测试这个功能，我们可以稍微编辑一下脚本：

转到警报 | 脚本并编辑主机/启用和主机/禁用脚本。
在命令字段中，将{HOST.HOST}替换为{MANUALINPUT}，使得此脚本接受动态输入。
然后打开高级配置，填写输入提示、默认输入字符串和输入验证规则字段。现在应该看起来像下图所示：

图 10.23 – 手动脚本输入

现在，当我们执行脚本时，它会要求我们输入。在此处填写主机名，输入的主机将在该字段中启用或禁用。

图 10.24 – 手动脚本输入执行

如你所见，使用这种新的脚本输入方式，现在可以使整个执行过程更加灵活。我们可以像这样以非静态方式执行脚本，从而在执行之前提供用户输入数据。真棒！

另见

Brian van Baekel 为Opensource ICT Solutions的客户创建了这个脚本，并将其开源。由于 Zabbix 拥有一个非常酷的社区，继续扩展 Zabbix 的可能性，我们也上传了一些自己的脚本。分享即关怀，所以请访问 https://github.com/OpensourceICTSolutions 查看其他开源脚本。

第十一章：维护你的 Zabbix 设置

就像任何一款优秀的软件一样，Zabbix 也需要维护，以便它能够多年持续运行。许多用户从 Zabbix 2.0 时代起就一直在使用他们的设置。如果你具备正确的 Zabbix 知识，这种做法完全是可行的。

在这一章中，我们将了解如何进行一些最重要的 Zabbix 维护工作，以确保你能够保持设置的可用性并顺利运行。我们将覆盖如何创建维护周期、如何备份、如何升级 Zabbix 及其各种组件，并进行一些性能维护。

我们将在接下来的教程中讨论这些内容：

设置 Zabbix 维护周期
备份你的 Zabbix 设置
将 Zabbix 后端从较旧的 PHP 版本升级到 PHP 8.2 或更高版本
将 Zabbix 数据库从较旧的 MariaDB 版本升级到 MariaDB 10.11
升级你的 Zabbix 设置
随着时间推移维护 Zabbix 性能

技术要求

我们将需要几个重要的服务器来完成这些教程。首先，我们需要一台运行 Zabbix 7 服务器，用于设置维护周期并进行性能调优。

对于升级部分，我们将需要以下之一的服务器：

一台运行 Zabbix 服务器 6、PHP 版本低于 8.2、MariaDB 版本低于 11.4 的 Rocky Linux 8 服务器
一台运行 Zabbix 服务器 6、PHP 版本低于 8.3、MariaDB 版本低于 11.4 的 Ubuntu 22.04 服务器

我将把升级服务器命名为 lar-book-zbx6，你可以使用任何你选择的发行版运行它。

如果你之前没有使用过 Zabbix，这一章可能会是一个不错的挑战，因为我们将深入探讨 Zabbix 中一些更高级的过程。

设置 Zabbix 维护周期

当我们在处理 Zabbix 服务器或其他主机时，设置 Zabbix 前端的维护周期非常有用。通过维护周期，我们可以确保在维护期间不会触发警报。在 Zabbix 7 中，您会发现一个改进，即引入了近乎即时的维护周期。由于我们不再需要等待很长时间才能重新加载配置缓存，Zabbix 还调整了定时器流程，可以即时启用新的维护周期。

让我们看看如何在这个教程中安排维护周期。

准备工作

在本教程中，我们只需要我们的 Zabbix 服务器，我将使用 lar-book-rocky。该服务器至少需要一些主机和主机组，以便为其创建维护周期。此外，我们需要了解如何导航 Zabbix 前端。

如何操作……

我们通过登录前端并导航到数据采集 | 维护，开始这个教程。
我们将点击右上角的蓝色创建维护周期按钮。
这将显示一个弹出窗口，在其中我们可以设置我们的维护周期。让我们从定义维护周期参数开始。填写以下内容：

图 11.1 – Zabbix 数据收集 | 维护，创建维护窗口，Patch Tuesday

现在，在周期部分，我们将创建一个新的维护周期。我们需要点击下划线的添加文本。
这将带我们到另一个弹出窗口，在那里我们可以设置维护周期。我们需要填写以下信息：

图 11.2 – Zabbix 数据收集 | 维护，创建维护周期窗口，Patch Tuesday

现在点击蓝色的添加按钮继续。你现在应该能看到我们的维护周期已经填写完成：

图 11.3 – Zabbix 配置 | 维护，创建维护周期页面，Patch Tuesday

现在，在主机组字段旁边，点击选择按钮，选择Linux 服务器主机组。我们的页面应该看起来像这样：

图 11.4 – Zabbix 配置 | 维护，添加主机到维护页面，Patch Tuesday

如果你愿意，仍然可以添加一个描述。
接下来，点击页面底部的蓝色添加按钮，完成创建维护周期。这将带我们回到维护周期页面，在那里我们应该能看到我们的维护窗口已经创建成功。

它是如何工作的…

在 Zabbix 中配置操作时，我们告诉 Zabbix 在触发器被触发时执行某个定义的操作。维护周期（带数据收集）通过在维护周期定义的时间段内抑制这些 Zabbix 操作来工作。我们这样做是为了确保在进行主机维护时，Zabbix 用户不会收到任何关于问题的通知。当然，最好只在我们实际在相关主机上工作时使用此功能。不过，只有在操作上勾选了暂停被抑制问题的操作复选框时，这才有效。

在这个示例中，我们已经为 2023 年整个年度创建了一个定期维护周期（带数据收集）。假设我们工作的组织有许多 Linux 主机，每周需要进行补丁更新。我们将维护周期设置为每周二晚上 22:00 到次日凌晨 04:00 之间重复。

请注意，2023 年 12 月 31 日后，Zabbix 将停止此维护期，因为它将不再处于活动状态。在设置计划维护时，我们需要牢记两个时间/日期值。一个是维护期的 Active since/Active till 时间/日期值，另一个是 Periods 时间/日期值。这让我们可以创建更灵活的维护期，以及像我们刚才做的那样的定期维护期。

另外，请注意，nodata 触发功能也会受到维护期的影响，在这两种情况下它都不会触发。

备份你的 Zabbix 配置

在进行任何 Zabbix 配置之前，备份所有重要内容至关重要。在本教程中，我们将介绍在对 Zabbix 配置进行维护之前，应该始终采取的一些最重要的步骤。

准备工作

我们需要 Zabbix 服务器，对于此我将使用 lar-book-rocky。确保准备好 CLI 连接到服务器，因为整个过程将使用 Linux CLI。

如何操作……

首先，通过 Linux CLI 登录到我们的 Zabbix 服务器，并创建一些新的目录，我们将用于 Zabbix 备份。最好将这个目录放在另一个分区上：

mkdir /opt/zbx-backup/
mkdir /opt/zbx-backup/database/
mkdir /opt/zbx-backup/zbx-config/
mkdir /opt/zbx-backup/nginx/
mkdir /opt/zbx-backup/lib/
mkdir /opt/zbx-backup/shared/
mkdir /opt/zbx-backup/shared/zabbix/
mkdir /opt/zbx-backup/shared/doc/

备份我们所有的 Zabbix 配置数据非常重要，这些数据位于 /etc/zabbix/。我们可以通过执行以下命令手动将数据从当前文件夹复制到新的备份文件夹：
```
cp -r /etc/zabbix/ /opt/zbx-backup/zbx-config/
```
现在，我们对 nginx 配置做同样的操作：
```
cp -r /etc/nginx/ /opt/zbx-backup/nginx/
```

重要说明

请注意，如果你使用的是 Apache，Web 配置的位置可能会有所不同。请根据需要调整你的命令。对于基于 Red Hat 的系统，通常是 /etc/httpd，对于基于 Debian 的系统，通常是 /etc/apache2。

备份我们的 Zabbix PHP 文件和二进制文件也很重要。我们可以使用以下命令来完成：

cp -r /usr/share/zabbix/ /opt/zbx-backup/shared/zabbix/
cp -r /usr/share/doc/zabbix-* /opt/zbx-backup/shared/doc/

最后，确保也备份 /usr/lib 中的 Zabbix 文件：
```
cp -r /usr/lib/zabbix/ /opt/zbx-backup/lib/
```
我们还可以创建一个 cronjob，每天 00:00 自动压缩并备份这些文件。只需执行以下命令：
```
crontab -e
```

并添加以下信息：

0 0 * * * tar -zcvf /opt/zbx-backup/zbx-config/zabbix.tar.gz /etc/zabbix/ >/dev/null 2>&1
0 0 * * * tar -zcvf /opt/zbx-backup/web-config/zabbix-web.tar.gz /etc/nginx/ >/dev/null 2>&1
0 0 * * * tar -zcvf /opt/zbx-backup/shared/zabbix/zabbix_usr_share.tar.gz /usr/share/zabbix/ >/dev/null 2>&1
0 0 * * * tar -zcvf /opt/zbx-backup/shared/doc/zabbix_usr_share_doc.tar.gz /usr/share/doc/ >/dev/null 2>&1
0 0 * * * tar -zcvf /opt/zbx-backup/lib /zabbix_usr_lib.tar.gz /usr/lib/zabbix/ >/dev/null 2>&1

这些是我们需要从 Zabbix 堆栈中备份的最重要文件。接下来，我们处理数据库。我们现在还可以使用像 logrotate 这样的轮换工具来管理我们的文件。
备份我们的数据库非常简单。我们可以直接使用 MySQL 和 PostgreSQL 提供的内置工具。为你的相应数据库执行以下命令（确保填写正确的用户名、数据库名和密码）：

对于 MySQL 数据库：
```
mysqldump --add-drop-table --add-locks --extended-insert --single-transaction --quick -u zabbixuser -p zabbixdb > /opt/zbx-backup/database/backup_zabbixDB_<DATE>.sql
```
对于 PostgreSQL 数据库：
```
pg_dump zabbixdb > /opt/zbx-backup/database/backup_ zabbixDB_<DATE>.bak
```
确保添加正确的位置，因为如果数据库本身很大，数据库转储将会非常庞大。最好将其转储到另一个磁盘/分区，甚至更好的是，转储到另一台机器上。因此，/opt/ 可能不是最佳位置。
我们还可以通过设置一个 cronjob，执行以下命令来实现：
```
crontab -e
```
然后对于 MySQL，添加以下行，其中-u是用户名，-p是密码，数据库名是zabbix。这是 MySQL 的命令：
```
55 22 * * 0 mysqldump -u'zabbixuser' -p'password' zabbixdb > /opt/zbx-backup/database/backup_zabbixDB.sql
```
如果你想通过 cronjob 备份 PostgreSQL 数据库，我们需要在用户的主目录中创建一个文件：
```
vim ~/.pgpass
```
我们将以下内容添加到此文件中，其中zabbixuser是用户名，zabbixdb是数据库名：
```
#hostname:port:database:username:password
localhost:5432:zabbixdb:zabbixuser:password
```

然后我们可以为 PostgreSQL 添加一个 cronjob，如下所示：

55 22 * * 0 pg_dump --no-password -U zabbixuser zabbixdb > /opt/zbx-backup/database/backup_zabbixDB_date.bak

我们还可以添加一个 cronjob，只保留一定天数的备份。运行以下命令：
```
crontab -e
```

然后添加以下行，其中+60是你希望保留备份的天数：

55 22 * * 0 find /opt/zbx-backup/database/ -mtime +60 -type f -delete

这就结束了我们展示的以简便方式备份 Zabbix 组件的过程。

重要提示

对于 MySQL 数据库，也有 ExtraBackup 等工具，而对于 Postgres，我们可以使用 PGBarman。虽然这些工具可以用于为系统创建备份，但此处提供的内建示例同样非常实用。

它是如何工作的……

Zabbix 设置由多个组件组成。我们有 Zabbix 前端、Zabbix 服务器和 Zabbix 数据库。这些组件在此设置中需要运行不同的软件，如下图所示：

图 11.5 – Zabbix 关键组件设置图

从前面的图表中，我们可以看到我们的 Zabbix 前端运行在 NGINX 或 Apache 等 Web 引擎上。我们还需要 PHP 来运行我们的 Zabbix 网页。这意味着我们需要备份两个组件：

Web 引擎：NGINX、Apache 或其他
PHP

Zabbix 服务器是 Zabbix 设计的应用程序，所以我们这里只需备份一件事：Zabbix 服务器的配置文件。

最后但绝对重要的是，我们需要备份我们的数据库。最常用的数据库是 MySQL 和 PostgreSQL，因此我们只需要做一件事：创建 Zabbix 数据库的转储。

还有更多……

以这种方式备份 Zabbix 设置是一方面，但当然，这还不是全部。确保你使用快照和其他技术正确备份 Linux 系统。

当你遵循标准备份实施方案时，你应该为 Zabbix 设置中任何不可预见的情况做好准备。

将 Zabbix 后端从较旧的 PHP 版本升级到 PHP 8.2 或更高版本

RHEL7、Ubuntu 20.04 和 Debian 9（Stretch）已不再受到 Zabbix 支持，因此我们的升级方案不再包括从 PHP 版本 7.2 之前升级到 8.2 或更高版本的任何信息。较新的 Linux 版本已随 PHP8.0 或更高版本一起发布，这意味着当我们将 Zabbix 设置从 Zabbix 6 版本升级到 Zabbix 7 时，可以直接进行升级。

Zabbix 7 对 PHP 的要求与 Zabbix 6 不同，这意味着如果我们正在运行 PHP 7.2，实际上在运行最新的 Zabbix 7 版本之前，我们必须进行强制性升级。我个人也倾向于以面向未来的方式工作，所以在本教程中，我们将讲解如何将 PHP 7.2 升级到 8.2，这是截至写作时在基于 RHEL8 的系统上支持的最新版本。

准备工作

对于本教程，我们需要的服务器是安装了基于 RHEL8 的系统，并运行 Zabbix 服务器 6 和 PHP 7.2 版本。

另一种可能是你有一台运行 Debian 系发行版（如 Ubuntu 20.04、Debian 11 或更高版本）服务器。这些系统默认包括 PHP 7.2 或更高版本。

在本教程中，我将始终把两个可能的服务器称作lar-book-zbx6。

最后，确保备份你的系统并阅读你正在安装的新版本的发布说明。

如何操作…

本教程分为两个不同的部分，一个针对基于 RHEL8 的系统，另一个针对 Ubuntu 系统。我们将首先讲解 RHEL8 的步骤。

基于 RHEL8 的系统

如果你已经在基于 RHEL8 的系统上运行 PHP 7.2 版本，升级过程会更简单。让我们看看在这种情况下如何升级我们的lar-book-zbx6服务器：

首先，始终通过以下命令验证我们正在运行的 PHP 版本：
```
php-fpm --version
```
如果版本低于 8.2，我们可以继续执行下一步。我们将执行以下命令：
```
dnf module list php
```
这将显示类似以下截图的内容：

图 11.6 – RHEL8 DNF 模块列表（PHP）

不幸的是，在 RHEL8 上，最新稳定的 PHP 8.3 版本并未包含在来自 AppStream 的 DNF 模块中。这意味着我们必须为基于 RHEL8 的系统找到替代的解决方案。如果你想安装 PHP 8.3 或更高版本，请继续到步骤 9。
由于 PHP 8.2 已包含在 AppStream 列表中，请重置你当前可用的 PHP 模块：
```
dnf module reset php
```
确保回答为Y。然后，我们将通过以下命令启用最新的 PHP 版本：
```
dnf module enable php:8.2
```
再次回答Y以启用 PHP 8.2，然后我们可以通过以下命令升级 PHP 版本：
```
dnf update
```
再次回答Y，你的 PHP 版本现在将运行最新的 PHP 8.2 版本。
如果我们无法使用dnf module enable方法来安装你想要的版本，我们将不得不依赖其他方式来获取 PHP，最常见的方法是使用 REMI 仓库。
通过以下命令确保系统是最新的：
```
dnf update
```
REMI 依赖于 EPEL 仓库，所以我们需要首先添加 EPEL 仓库：
```
dnf install epel-release
```
安装epel-release后，确保将 Zabbix 从中排除。这可以确保 Zabbix 仅从官方 Zabbix 仓库下载和更新：
```
[epel]
excludepkgs=zabbix*
```

.然后通过以下命令安装 REMI 仓库：

sudo dnf -y install http://rpms.remirepo.net/enterprise/remi-release-8.rpm

重置 PHP 模块并启用 REMI PHP 8.3 版本：

dnf module reset php -y
dnf module install php:remi-8.3

在安装过程中，随时输入 Y 或 Yes。
然后，验证升级是否成功：
```
php-fpm -v
```
确保重新启动 NGINX（或 Apache）和 php-fpm：
```
systemctl restart nginx php-fpm
```

这些步骤已在 Rocky Linux RHEL 系统上测试过，但它们应该适用于任何基于 RHEL8 的系统，无论是 Stream 版本还是像 Alma Linux 这样的完整重建版本。

考虑升级到基于 RHEL9 的系统，以便支持 PHP 包的更新版本。

Ubuntu 系统

让我们将 Ubuntu 系统升级到可用的最新版本 PHP：

首先，通过以下命令将 PPA 仓库添加到我们的主机中：

apt install software-properties-common
add-apt-repository ppa:ondrej/php

现在通过以下命令更新仓库：
```
apt update
```
在某些安装中，仓库的密钥可能不可用，在这种情况下，我们可能会看到错误提示 Key is not available。我们可以通过以下命令修复此问题，其中 PUB_KEY_HERE 是错误中显示的密钥：
```
apt-key adv --keyserver keyserver.ubuntu.com --recv- keys PUB_KEY_HERE
```
现在，我们可以通过以下命令安装 PHP 8.3 版本：
```
apt install -y php8.3
apt upgrade -y php
apt autoremove
```
就这样，PHP 版本现在应该是我们想要的版本。可以通过以下命令检查 PHP 版本：
```
php --version
```

它是如何工作的……

因为 Zabbix 7 要求我们安装 PHP 8.0 或更高版本，如果我们仍然使用 PHP 7.2 来安装 Zabbix 6，就需要升级 PHP 版本。这是与 Zabbix 6 的不同要求，因此在某些情况下升级过程可能会比较长。如果你仍然使用 RHEL7、Ubuntu 20.04 或 Debian 9（Stretch），那么也需要先升级你的 Linux 系统。Zabbix 已停止支持这些较旧的 Linux 版本，以便简化软件包管理、安全性和支持。

目前，仍然可以通过从源代码构建的方式在较旧的 Linux 版本上运行 Zabbix，但不推荐这么做。

在本配方中，我们将 PHP 从 7.2 升级到 PHP 8.2 或 8.3，这些是本文写作时支持的最新稳定版本。进行此升级不会破坏我们当前的 Zabbix 服务器安装。如前所述，这是一个强制升级，因为 PHP 8.0 以下的版本已太旧，无法运行 Zabbix 7。即使升级是可选的，考虑运行最新的稳定软件版本总是好的，这样我们才能为未来做好准备。

现在我们已经升级了 PHP，可以继续升级 Zabbix 数据库引擎。

将 Zabbix 数据库从旧版本的 MariaDB 升级到 MariaDB 11.4

对于我们的 Zabbix 7 安装，我们需要 MariaDB 10.5 或更高版本，因此保持数据库版本最新是个好主意。MariaDB 定期改进其处理某些性能方面的方式。

本配方详细说明了如何将 MariaDB 升级到最新的稳定 LTS 版本，即本文写作时的 MariaDB 11.4。

准备工作

对于本配方，我们需要我们的服务器，我们将其命名为 lar-book-zbx6。此时，服务器正在运行基于 RHEL8 的发行版。

另一个选项是在运行 Debian-based 发行版（如 Ubuntu 22.04、Debian 12 或这些 Linux 发行版的更新版本）的服务器上。我们将升级此服务器上的 MariaDB 实例到 11.4 版本。

如果您已经按照 将 Zabbix 后端从较旧的 PHP 版本升级到 PHP 8.2 或更高版本 文档操作，则您的服务器现在将运行 PHP 版本 8.2 或更高版本。如果没有，请首先按照该文档操作是个好主意。

另外，请确保备份系统并阅读您安装的新版本的发布说明。我们在 备份您的 Zabbix 设置 文档中涵盖了这一点。

如何做…

首先要做的是，让我们登录到我们的 Linux 主机 CLI，检查我们的版本。执行以下命令：

对于 Zabbix 服务器：
```
zabbix_server --version
php-fpm --version
```
对于 MariaDB：
```
mysql --version
```
在验证我们的版本与本文档 准备工作 部分中提到的版本相匹配后，让我们继续升级 MariaDB 的版本。

基于 RHEL 的系统

在我们的基于 RHEL 的服务器上，在检查版本后，我们首先要做的是停止我们的 Zabbix 环境：
```
systemctl stop mariadb nginx zabbix-server
```
现在使用以下命令设置 MariaDB 的仓库文件：
```
vim /etc/yum.repos.d/mariadb.repo
```

我们将把以下代码添加到这个新文件中。如果使用除 amd64 以外的任何其他架构，请确保在 baseurl 后面添加正确的架构：

[mariadb-main]
name = MariaDB Server
baseurl = https://dlm.mariadb.com/repo/mariadb-server/11.4/yum/rhel/8/x86_64
gpgkey = file:///etc/pki/rpm-gpg/MariaDB-Server-GPG-KEY
gpgcheck = 1
enabled = 1
module_hotfixes = 1
[mariadb-maxscale]
# To use the latest stable release of MaxScale, use "latest" as the version
# To use the latest beta (or stable if no current beta) release of MaxScale, use "beta" as the version
name = MariaDB MaxScale
baseurl = https://dlm.mariadb.com/repo/maxscale/latest/yum/rhel/8/x86_64
gpgkey = file:///etc/pki/rpm-gpg/MariaDB-MaxScale-GPG-KEY
gpgcheck = 1
enabled = 1
[mariadb-tools]
name = MariaDB Tools
baseurl = https://downloads.mariadb.com/Tools/rhel/8/x86_64
gpgkey = file:///etc/pki/rpm-gpg/MariaDB-Enterprise-GPG-KEY
gpgcheck = 1
enabled = 1
[mariadb-main]
name = MariaDB Server
baseurl = https://dlm.mariadb.com/repo/mariadb-server/11.4/yum/rhel/8/x86_64
gpgkey = file:///etc/pki/rpm-gpg/MariaDB-Server-GPG-KEY
gpgcheck = 1
enabled = 1
module_hotfixes = 1
[mariadb-maxscale]
# To use the latest stable release of MaxScale, use "latest" as the version
# To use the latest beta (or stable if no current beta) release of MaxScale, use "beta" as the version
name = MariaDB MaxScale
baseurl = https://dlm.mariadb.com/repo/maxscale/latest/yum/rhel/8/x86_64
gpgkey = file:///etc/pki/rpm-gpg/MariaDB-MaxScale-GPG-KEY
gpgcheck = 1
enabled = 1
[mariadb-tools]
name = MariaDB Tools
baseurl = https://downloads.mariadb.com/Tools/rhel/8/x86_64
gpgkey = file:///etc/pki/rpm-gpg/MariaDB-Enterprise-GPG-KEY
gpgcheck = 1
enabled = 1

或者更好的方法是使用 MariaDB 设置脚本：

curl -LsS https://r.mariadb.com/downloads/mariadb_repo_setup | sudo bash -s -- --mariadb-server-version="mariadb-11.4"

现在使用以下命令升级您的 MariaDB 服务器：
```
dnf upgrade MariaDB*
```
使用以下命令重新启动 MariaDB 服务：
```
systemctl start mariadb zabbix-server nginx
```
现在，MariaDB 应该已经升级到预期的版本。使用以下命令再次检查版本以确保：
```
mariadb --version
```

Ubuntu 系统

在我们的 Ubuntu 服务器上，检查版本后，我们首先要做的是停止我们的 Zabbix 服务器环境：
```
systemctl stop mariadb zabbix-server nginx
```
检查 /etc/apt/sources.list.d/mariadb.list 中的 MariaDB 仓库文件。要检查它是否在 11.4 版本上，请使用以下命令编辑它：
```
vim /etc/apt/sources.list.d/mariadb.list
```

文件应该看起来像以下的代码块。如果看起来不对，请编辑它以匹配。如果使用除 amd64 外的任何其他架构，请确保在 deb 行上添加正确的架构：

# MariaDB Server
# To use a different major version of the server, or to pin to a specific minor version, change URI below.
deb [arch=amd64,arm64] https://dlm.mariadb.com/repo/mariadb-server/11.4/repo/ubuntu jammy main
deb [arch=amd64,arm64] https://dlm.mariadb.com/repo/mariadb-server/11.4/repo/ubuntu jammy main/debug
# MariaDB MaxScale
# To use the latest stable release of MaxScale, use "latest" as the version
# To use the latest beta (or stable if no current beta) release of MaxScale, use "beta" as the version
deb [arch=amd64,arm64] https://dlm.mariadb.com/repo/maxscale/latest/apt jammy main
# MariaDB Tools
deb [arch=amd64] http://downloads.mariadb.com/Tools/ubuntu jammy main

或者，我们可以使用 MariaDB 仓库设置脚本来更新到正确的仓库。执行以下命令：

curl -LsS https://r.mariadb.com/downloads/mariadb_repo_setup | sudo bash -s -- --mariadb-server-version="mariadb-11.4"

我们需要使用以下命令移除旧的 MariaDB 包：
```
apt remove mariadb-server mariadb-client
```
现在使用以下命令升级 MariaDB 服务器版本：
```
apt install mariadb-server mariadb-client
```
使用以下命令重新启动 MariaDB：
```
systemctl restart mariadb
```
然后执行 upgrade 命令：
```
mariadb-upgrade
```
现在重新启动 Zabbix：
```
systemctl restart zabbix-server nginx
```
现在，MariaDB 应该已经升级到正确的版本。使用以下命令再次检查版本：
```
mariadb --version
```

工作原理…

现在，虽然这可能并非总是必要的要求，但定期升级您的数据库版本是一个明智的想法。您的数据库引擎的新版本可能包括对稳定性和性能的改进，这两者都可能极大地改善您的 Zabbix 服务器。

但请保持关注发布说明和错误报告。在撰写本文时，MariaDB 11.4 是市场上最新的 LTS 版本。您可能希望留在一两个版本之后，因为这些版本仍然得到支持，并且已经在生产中运行了一段时间。毕竟，没有人喜欢出现意外问题，比如 bug。

对于 Zabbix 7，我们确实需要安装至少 MariaDB 10.5 或更新支持的版本，请记住这一点。

还有更多内容…

如果您真的无法升级到 MariaDB 版本 10.5，或者如果您运行的是其他数据库，则支持该数据库的版本，那么就有了一个新的 Zabbix 功能。Zabbix 7 允许我们运行不受支持的数据库版本。当我们编辑 Zabbix 服务器配置文件 /etc/zabbix/zabbix_server.conf 时，我们可以添加以下参数：

AllowUnsupportedDBVersions=1

这将允许您运行一个尚未经 Zabbix 官方测试和支持的旧版或新版数据库版本，但请记住，这样做并不建议。请查看当前 Zabbix LTS 安装要求的信息：

www.zabbix.com/documentation/current/zh/manual/installation/requirements

升级您的 Zabbix 设置

正如我们在整本书中已经看到的那样，Zabbix 7 提供了许多很酷的新功能。Zabbix 7.0 是一个长期支持（LTS）版本，因此就像 5.0 和 6.0 一样，您将会长期支持它。让我们看看如何将 Zabbix 服务器从 6.0 版本升级到 7.0 版本。

准备就绪

对于此配方，我们将需要名为 lar-book-zbx6 的服务器。此时，您的服务器将运行基于 RHEL8 的 Linux 发行版或类似 Ubuntu 22.04、Debian 12 或更新版本的 Debian 发行版。

如果您按照 将 Zabbix 后端从较旧的 PHP 版本升级到 PHP 8.2 或更高版本 的步骤，您的服务器现在将运行 PHP 版本 8.2 或更高版本。如果没有，请首先按照该步骤操作是个不错的选择。

如果您按照 将 Zabbix 数据库从较旧的 MariaDB 版本升级到 MariaDB 11.4 的步骤，它现在将运行 MariaDB 版本 11.4。如果没有，请首先按照该步骤操作是个明智的选择。

此外，请务必备份您的系统并阅读您正在安装的新版本的发布说明。我们在 备份您的 Zabbix 设置 配方中已经覆盖了这一点。

如何操作…

首先，让我们登录到我们的 Linux 主机 CLI，检查我们的软件版本：

发出以下命令检查各自的软件版本：

对于 Zabbix 服务器：
```
zabbix_server --version
php-fpm --version
```
对于 MariaDB：
```
mariadb --version
```
在验证我们的版本与此配方中 准备就绪 部分中提到的版本相匹配后，让我们继续升级我们的 Zabbix 服务器。

基于 RHEL 的系统

首先，我们将从 RHEL-based 系统上升级 Zabbix 服务器：

让我们使用以下命令停止我们的 Zabbix 服务器组件：
```
systemctl stop zabbix-server zabbix-agent2
```

在我们的服务器上，使用以下命令添加新的 Zabbix 7.0 软件库：

rpm -Uvh https://repo.zabbix.com/zabbix/7.0/rhel/8/ x86_64/zabbix-release-7.0-1.el8noarch.rpm

使用以下命令清理软件库：
```
dnf clean all
```

现在使用以下命令升级 Zabbix 配置：

dnf upgrade zabbix-server-mysql zabbix-web-mysql zabbix-agent2

此外，安装 Zabbix NGINX 配置：
```
dnf install zabbix-nginx-conf
```

使用以下命令启动 Zabbix 组件：

systemctl restart zabbix-server zabbix-agent2

当我们检查服务器是否正在运行时，使用以下命令时，它应该显示Active（running）：
```
systemctl status zabbix-server
```
如果没有，使用以下命令检查日志，看看发生了什么：
```
tail -f /var/log/zabbix/zabbix_server.log
```
检查日志文件是否有任何明显错误，如果发现问题，修复后再继续。
如果我们重新启动服务器，错误应该消失，Zabbix 服务器应继续运行：
```
systemctl restart zabbix-server
```

现在使用以下命令重启 Zabbix 组件：

systemctl restart nginx php-fpm zabbix-server mariadb

现在一切应该按预期工作，我们应该能够看到新的 Zabbix 7 前端，如下图所示：

图 11.7 – RHEL 上升级后的 Zabbix 7 前端

Ubuntu 系统

首先，使用以下命令停止 Zabbix 服务器组件：
```
systemctl stop zabbix-server zabbix-agent2
```

现在使用以下命令为 Ubuntu 添加 Zabbix 7 的新软件库：

wget https://repo.zabbix.com/zabbix/7.0/ubuntu/pool/main/z/zabbix-release/zabbix-release_7.0-1+ubuntu22.04_all.deb
dpkg -i zabbix-release_7.0-1+ubuntu22.04_all.deb

重要提示

始终访问 zabbix.com/download 获取适合你系统的软件库。在本例中，我使用了 Ubuntu 的软件库。请根据你的系统替换为正确的软件库。

使用以下命令更新软件库信息：
```
apt update
```

现在使用以下命令升级 Zabbix 服务器组件：

apt install –-only-upgrade zabbix-server-mysql zabbix-frontend-php zabbix-agent2

确保不要覆盖 Zabbix 服务器配置文件。如果你不小心覆盖了配置文件，可以从备份你的 Zabbix 配置食谱中恢复。
然后使用以下命令安装新的 Zabbix NGINX 配置：
```
apt install zabbix-nginx-conf
```
使用以下命令重启 Zabbix 服务器组件，完成升级：
```
systemctl restart zabbix-server nginx zabbix-agent2
```
使用以下命令检查日志，查看发生了什么：
```
tail -f /var/log/zabbix/zabbix_server.log
```
检查日志文件是否有任何明显错误，如果发现问题，修复后再继续。
如果我们重新启动服务器，错误应该消失，Zabbix 服务器应继续运行：
```
systemctl restart zabbix-server
```
这应该完成升级过程，如果我们进入前端页面，应该看到新的 Zabbix 7 前端：

图 11.8 – Ubuntu 升级后的 Zabbix 7 前端

它是如何工作的……

当我们使用最新版本的 Linux 时，升级 Zabbix 可能是个简单的任务。但如果我们使用的是旧版软件，则可能会遇到一些问题。

我们刚刚遵循的步骤展示了一个 Zabbix 6 实例的升级过程，最终将系统升级为运行 Zabbix 7，并且列出了我们可能遇到的最常见问题。

重要提示

在升级过程中，请注意查看你的zabbix_server.log文件，因为该文件会告诉你升级过程中是否发生了任何问题。

我们确保将 PHP 升级到高于 8.0 的版本，因为这是 Zabbix 7 的要求。如果我们运行较旧的 PHP 版本，从 Zabbix 6 升级会变得有些复杂。至于数据库，Zabbix 在 Zabbix 6 和 Zabbix 7 之间保持了相同的要求，要求 MariaDB 10.5 或更新的受支持版本来配置 Zabbix。

现在，您已经升级了所有组件，应该准备好使用 Zabbix 7，并且您的设置会在一段时间内保持未来兼容——当然，直到 Zabbix 8 发布，届时可能会有新的要求。

另见

请确保查看您正在升级的版本的 Zabbix 文档。Zabbix 总是包含详细的要求和流程描述，以便尽可能简化您的升级过程。查看适用于您版本的文档：

www.zabbix.com/documentation/current/en/manual/installation/upgrade

维持 Zabbix 性能

确保您的 Zabbix 设置在长期内持续保持良好性能非常重要。有几个关键组件对保持 Zabbix 设置的最佳性能至关重要。让我们看看如何处理这些组件，确保 Zabbix 设置运行顺利。

准备工作

这个配方中，我们只需要一台 Zabbix 7 服务器。

如何操作…

我们将讨论在维护 Zabbix 服务器性能时人们面临的三个主要问题。首先，先来看看 Zabbix 进程以及如何编辑它们。

Zabbix 进程

一个常见问题是 Zabbix 进程过于繁忙。让我们登录 Zabbix 前端，查看这个问题可能是什么样子。

首先，让我们通过登录到 Zabbix 服务器前端来查看一些消息：

当我们导航到监控 | 仪表盘，然后选择默认仪表盘全局视图时，我们可能会看到如下内容：

图 11.9 – 来自我们 Zabbix 服务器的问题，发现器进程 75% 繁忙

然后我们导航到监控 | 主机，点击 Zabbix 服务器主机的最新数据（在我的情况下，主机名是lar-book-rocky）。这将带我们到该主机的最新数据。
对于过滤器，在名称字段中输入 discovery，然后点击图形以查看发现工作项。这将展示以下图形：

图 11.10 – Zabbix 服务器发现图，发现数据收集器的利用率百分比

这个图形几乎一直保持在 100%，这也解释了为什么我们在仪表盘上看到了图 11.9 中显示的问题。

让我们登录到 Zabbix 服务器的 Linux CLI，编辑此进程。
编辑以下文件，在你的 Zabbix 服务器上：
```
vim /etc/zabbix/zabbix_server.conf
```
现在，如果我们想要给 Zabbix 服务器的 发现器 进程更多空间，我们需要编辑正确的参数。向下滚动，直到你看到以下内容：

图 11.11 – Zabbix 服务器配置文件，StartDiscoverers 默认值

现在，在此基础上添加一行并输入以下内容：
```
StartDiscoverers=2
```
如果你的文件现在看起来像下面的截图，你可以保存并退出文件：

图 11.12 – Zabbix 服务器配置文件，StartDiscoverers 2

为了使更改生效，我们将需要使用以下命令重启 Zabbix 服务器：
```
systemctl restart zabbix-server
```
现在，如果我们返回到 Zabbix 前端，我们应该仍然停留在我们可以看到以下内容的图形界面：

图 11.13 – Zabbix 服务器发现器图

我们的发现器进程的利用率已下降，这意味着我们的利用率问题将不再出现。这就是我们编辑 Zabbix 服务器进程的方式。

Zabbix 维护进程

另一个人们常遇到的问题是 Zabbix 维护进程过于繁忙。让我们登录到 Zabbix 前端并检查这个问题：

当我们导航到监控 | 仪表板，然后选择默认仪表板 全局视图 时，我们可能会看到类似这样的内容：

图 11.14 – Zabbix 维护进程的问题

与编辑任何 Zabbix 进程类似，我们也可以编辑 Zabbix 维护进程。让我们登录到 Zabbix 服务器的 Linux 命令行界面来编辑我们的进程。
让我们在 Zabbix 服务器上编辑以下文件：
```
vim /etc/zabbix/zabbix_server.conf
```
现在，如果我们想要编辑这个过程，我们需要编辑正确的参数。向下滚动，直到你看到以下内容：

图 11.15 – Zabbix 配置文件，HousekeepingFrequency 1

这是我们的第一个维护参数。让我们通过在此代码块下添加以下行来编辑此参数：
```
HousekeepingFrequency=2
```

重要提示

延长间隔并不能解决你的问题；最多，你只是推迟了不可避免的情况。仅建议在下一个维护窗口期间更改此设置，并应尽量避免这样做。

现在向下滚动，直到你看到以下内容：

图 11.16 – Zabbix 配置文件，HousekeepingDelete 5000

上面的截图显示了我们的第二个维护参数。让我们通过在此代码块下添加以下行来编辑此参数：
```
MaxHousekeeperDelete=20000
```
为了使更改生效，我们需要使用以下命令重启 Zabbix 服务器：
```
systemctl restart zabbix-server
```

调整 MySQL 数据库

让我们看看如何轻松调优 MySQL 数据库。首先，打开浏览器访问以下链接：github.com/major/MySQLTuner-perl。
这个链接将我们引导到一个由 Major Hayden 发起的开源 GitHub 项目。务必关注该项目并尽可能提供帮助。我们可以从 GitHub 仓库下载脚本，或者直接使用以下命令：
```
wget https://raw.githubusercontent.com/major/MySQLTuner-perl/master/mysqltuner.pl
```
现在我们可以使用以下命令执行此脚本：
```
perl mysqltuner.pl
```
这将提示我们输入 MySQL 数据库凭证。填写完毕后继续：

图 11.17 – MySQL 调优脚本执行

现在，脚本将输出大量信息，你需要仔细阅读，但最重要的部分在最后——Variables to adjust 之后的所有内容：

图 11.18 – MySQL 调优脚本输出

重要提示

不要仅仅复制脚本的输出。该脚本只是给出了可能需要调优的 MySQL 设置的提示。始终查阅建议的设置，并了解这些设置的最佳实践。

我们可以在 MySQL my.cnf 文件中编辑这些变量。在我的情况下，我使用以下命令进行编辑：
```
vim /etc/my.cnf.d/server.cnf
```
现在，你只需编辑或添加脚本中建议的变量，然后重新启动 MySQL 服务器：
```
systemctl restart mariadb
```

它是如何工作的…

我们已经做了三个主要的 Zabbix 服务器性能调优，但还有很多工作要做。让我们回顾一下我们刚刚编辑的内容，思考为什么要这么做，并弄清楚它是否真的是这么简单。

Zabbix 进程

Zabbix 进程是 Zabbix 服务器配置的重要部分，必须小心编辑。在这个实例中，我们只是在一个小型安装中编辑了发现进程。这个问题很容易解决，因为服务器有足够的资源来支持额外的进程运行。

现在，如果我们查看以下示意图，可以看到在我们添加新的发现进程之前的情况：

图 11.19 – Zabbix 服务器单进程配置示意图

我们可以看到我们的 Linux 主机 正在运行 Zabbix 服务器 应用程序，并且我们可以看到我们的 LLDProcessors 1 进程正在发现 LLD 规则 1。LLD 规则 2 和 LLD 规则 3 正在排队，因为一个 LLDProcessor 子进程一次只能处理一个规则。

正如我们所看到的，这对我们的系统来说显然太重了，所以我们添加了另一个 LLDProcessor：

图 11.20 – Zabbix 服务器多进程配置示意图

我们的新设置将一定程度上平衡负载。发现规则只能由单个发现进程处理。这意味着如果我们有多个发现规则，我们可以像这样添加发现进程，确保每个发现规则都有足够的资源可用。其他进程也是一样的——更多的进程意味着更好的任务分配。

然而，这里有几件事需要小心。首先，并非所有问题都可以通过简单地增加更多资源来解决。有些 Zabbix 设置配置不当，配置中的某些内容使得我们的进程不必要地繁忙。如果我们解决了配置不当的问题，就可以减少高负载，从而需要更少的进程。

第二点我想强调的是，我们可以不断地向 Zabbix 服务器配置中添加进程——但有其限制。不过，在达到这些限制之前，你肯定会遇到我们的 Linux 主机硬件的极限。确保你有足够的 RAM 和 CPU 能力来实际运行所有这些进程，或者使用 Zabbix 代理来分担负载。同时也要记住，增加更多进程可能需要额外的数据库调优，例如允许更多的数据库连接。

最后但同样重要的是，记住更改 Zabbix 服务器配置需要重启 zabbix-server 进程。在大型安装中，这可能需要很长时间。Zabbix 服务器可能需要进行大量的数据库写入（例如，趋势数据），才能完成 zabbix-server 进程的关闭。

Zabbix 清理工具

现在谈谈 Zabbix 清理工具，这对于尚未设置 MySQL 分区或 PostgreSQL TimescaleDB 分区的 Zabbix 管理员来说是一个非常重要的进程。Zabbix 清理进程连接到我们的数据库，然后逐行删除过期的信息。你可能会想，什么是过期？其实，我们可以在 Zabbix 服务器中设置项目在数据库中保存多久的时间限制。

如果我们查看管理 | 清理，我们将看到以下截图所示的部分内容：

图 11.21 – Zabbix 服务器历史和趋势清理设置

这些是我们的全局历史和趋势清理参数。这定义了项目数据在数据库中应该保留多久。如果我们查看模板或主机上的项目，我们还可以看到这些参数：

图 11.22 – Zabbix 项目历史和趋势清理参数

这些设置会覆盖全局设置，因此你可以进一步调整清理工具。这就是清理工具如何保持你的数据库正常运行的方式。

但现在，让我们来看一下我们在 Zabbix 服务器配置文件中所做的调整，第一个就是 HousekeepingFrequency。清理频率是指清理程序进程启动的频率。我们将其从每小时一次降低为每两小时一次。现在你可能会认为这样更差，但不一定。很多时候，我们会看到清理工作在一小时后并未完成，然后就一直持续下去。

我们还更改了 MaxHousekeeperDelete 参数，这完全是另一回事。这个参数决定了每次清理程序运行时，Zabbix 清理程序允许删除多少数据库行。默认设置规定每小时可以删除 5000 行数据库记录。而通过我们的新设置，我们现在每两小时可以删除 20000 行数据库记录。每一行基本上就是我们允许删除的单个指标。

这会改变任何事情吗？嗯，可能不会。这完全取决于你的设置。调整 Zabbix 的清理程序对于每种设置都不同，你需要自己确定最优设置。尝试平衡你在图表中看到的内容与我们在这里讨论的两个设置，看看你能优化到什么程度。

然而，到某个时候，你的 Zabbix 设置可能会变得足够大，以至于 Zabbix 的清理程序无法跟上。这时你就需要考虑 MySQL 分区或 PostgreSQL TimescaleDB。没有预定的点可以说明 Zabbix 的清理程序无法跟上，所以从一开始就直接选择 MySQL 分区或 PostgreSQL TimescaleDB 会更为明智。毕竟，任何设置都有可能比预期增长得更大，对吧？更多相关内容请参见本书的第十二章。

调整 MySQL 数据库

现在来调整你的 MySQL 数据库，使用 mysqltuner.pl 脚本。这个脚本在后台做了很多工作，但我们可以将其总结为：它查看当前 MySQL 数据库的使用情况，然后输出它认为正确的调整变量。

不要将脚本输出视为最终结果，因为像 Zabbix 的清理程序一样，无法为你的数据库提供一个明确的设置。数据库的复杂性远超做几个调整就能完成的程度。

这个脚本肯定能在一定程度上帮助你调整 MySQL 数据库，尤其是对于较小的设置。但请确保通过定期阅读博客、指南和数据库书籍来扩展你的知识。

还有更多内容……

我们已经讨论了如何调整 MySQL 数据库，但还没有讨论如何调整 PostgreSQL 实例。为了更深入了解，建议访问 PostgreSQL 的维基页面 wiki.postgresql.org/wiki/Performance_Optimization。这里有各种不同的选项和偏好。确保仔细查看它们，并选择最适合你的方案。

Zabbix 7.0 版本中还新增了专门针对以下三种轮询器的功能：

代理轮询器
HTTP 代理轮询器
SNMP 轮询器（用于 walk[OID] 和 get[OID] 项目）

这些进程现在异步执行检查。意思是它们可以同时执行多个（项目）检查。在早期版本的 Zabbix 中，这些轮询器每次只能执行一个检查。

仍然可以通过例如 StartAgentPollers 添加多个这些进程，但现在其功能有所不同。这将每个轮询器执行最多 1,000 次检查，这可以通过 MaxConcurrentChecksPerPoller 参数进行配置。

第十二章：高级 Zabbix 数据库管理

无论你是已经使用 Zabbix 一段时间，还是正在准备设置你的第一个生产实例，数据库管理从一开始就非常重要。很多时候，人们设置了 Zabbix 数据库，却没有意识到它将会成为一个庞大的数据库。当数据库超过一定大小时，Zabbix 清理进程无法跟上，这时我们就需要考虑不同的方案。

在本章中，我们将讨论如何防止 Zabbix 数据库在 Zabbix 清理进程无法跟上的情况下占用 100% 的磁盘空间。对于 MySQL 用户，我们将研究如何使用数据库分区来控制数据库的大小。对于 PostgreSQL 用户，我们将关注 TimescaleDB 的支持。最后，我们还将了解如何确保 Zabbix 服务器与数据库之间的连接安全。

我们将在以下方案中完成这些任务：

为 Zabbix 数据库设置 MySQL 分区
使用 PostgreSQL 的 TimescaleDB 功能
保护你的 Zabbix MySQL 数据库

不再废话，让我们开始这些方案，了解如何管理我们的数据库。

技术要求

我们将需要一些新的服务器来实现这些方案。首先，一台 Linux 服务器需要运行带有 MySQL（MariaDB）设置的 Zabbix 服务器 7；我们将这台主机称为lar-book-mysql-mgmt。我们还需要一台运行带有 PostgreSQL 的 Zabbix 服务器 7 的 Linux 服务器，我们称之为lar-book-postgresql-mgmt。

我们还需要两台服务器来创建一个安全的 Zabbix 数据库设置。一台服务器将运行 MySQL（MariaDB）数据库；我们将这台服务器称为lar-book-secure-db。然后，外部连接到 Zabbix 数据库，我们将有一台 Zabbix 服务器，我们称之为lar-book-secure-zbx。

代码文件也可以在 GitHub 仓库中访问，链接如下：

github.com/PacktPublishing/Zabbix-7-IT-Infrastructure-Monitoring-Cookbook/tree/main/chapter12

为 Zabbix 数据库设置 MySQL 分区

在使用 MySQL 数据库时，我们面临的最大问题是 MySQL 默认存储数据的方式。如果我们想删除大量数据，默认的存储方式没有实际的顺序可以利用。MySQL 分区可以解决这个问题；让我们看看如何配置它来用于 Zabbix 数据库。

重要提示

在 Opensource ICT Solutions，我们已经修复了脚本，使其能够与 MySQL 8 一起工作。这个脚本应该可以再次适用于任何 MySQL 设置。有关更多信息，请查看链接：github.com/OpensourceICTSolutions/zabbix-mysql-partitioning-perl。

准备工作

对于本教程，我们需要一个运行中的 Zabbix 服务器，并且该服务器必须有一个 MySQL 数据库。我将在示例中使用 MariaDB，但任何 MySQL 变种应该差不多。我将使用名为 lar-book-mysql-mgmt 的 Linux 主机，该主机已经满足要求。

如果你在生产环境中执行这些步骤，请确保首先创建数据库备份，因为事情总是可能出错。

如何操作…

首先，登录到我们的 Linux CLI 执行命令。
使用 TMUX 是个好主意，因为分区对于大型数据库来说可能需要几天时间。即使我们丢失 SSH 连接，TMUX 也会保持会话在后台打开。如果没有安装 TMUX，请先安装它，然后再继续。

基于 RHEL 的命令如下：
```
dnf install tmux
```
基于 Ubuntu 的命令如下：
```
apt install tmux
```
通过执行以下命令打开一个新的 tmux 会话：
```
tmux
```

重要提示

在 tmux 窗口中运行分区并不是必需的，但绝对是明智之举。分区一个大数据库可能需要很长时间。你可以将数据库移到另一台资源充足（CPU、内存和磁盘速度）的机器上进行分区，或者如果这不可行，可以在分区过程中停止 Zabbix 服务器进程。

现在，使用以下命令以 root 用户身份登录 MySQL 应用程序：
```
mysql -u root -p
```
现在，使用以下命令切换到 Zabbix 数据库：
```
USE zabbix;
```
我们将需要对一些表进行分区，但要做到这一点，我们需要知道表中的 UNIX 时间戳：
```
SELECT FROM_UNIXTIME(MIN(clock)) FROM history;
```
你将收到如下输出：

图 12.1 – MySQL 返回历史表上的时间戳

这个时间戳应该对我们要分区的每个表大致相同。通过对剩余的历史表运行相同的查询来验证这一点：

SELECT FROM_UNIXTIME(MIN(clock)) FROM 'history';
SELECT FROM_UNIXTIME(MIN(clock)) FROM 'history_uint';
SELECT FROM_UNIXTIME(MIN(clock)) FROM 'history_str';
SELECT FROM_UNIXTIME(MIN(clock)) FROM 'history_text';
SELECT FROM_UNIXTIME(MIN(clock)) FROM 'history_log';
SELECT FROM_UNIXTIME(MIN(clock)) FROM 'history_bin';

一个表可能返回不同的值，甚至没有任何值。在创建分区时我们需要考虑这一点。显示NULL的表没有数据，但较早的日期意味着我们需要更早的分区：

图 12.2 – MySQL 返回历史日志表上的时间戳

我们从 history 表开始。我们将按天对这个表进行分区，直到今天的日期；对我来说是 18-06-2023。让我们准备以下 MySQL 查询（例如，保存在记事本中）：

ALTER TABLE history PARTITION BY RANGE ( clock)
(PARTITION p2023_06_11 VALUES LESS THAN (UNIX_TIMESTAMP("2023-06-12 00:00:00")) ENGINE = InnoDB,
PARTITION p2023_06_12 VALUES LESS THAN (UNIX_TIMESTAMP("2023-06-13 00:00:00")) ENGINE = InnoDB,
PARTITION p2023_06_13 VALUES LESS THAN (UNIX_TIMESTAMP("2023-06-14 00:00:00")) ENGINE = InnoDB,
PARTITION p2023_06_14 VALUES LESS THAN (UNIX_TIMESTAMP("2023-06-15 00:00:00")) ENGINE = InnoDB,
PARTITION p2023_06_15 VALUES LESS THAN (UNIX_TIMESTAMP("2023-06-16 00:00:00")) ENGINE = InnoDB,
PARTITION p2023_06_16 VALUES LESS THAN (UNIX_TIMESTAMP("2023-06-17 00:00:00")) ENGINE = InnoDB,
PARTITION p2023_06_17 VALUES LESS THAN (UNIX_TIMESTAMP("2023-06-18 00:00:00")) ENGINE = InnoDB,
PARTITION p2023_06_18 VALUES LESS THAN (UNIX_TIMESTAMP("2023-06-19 00:00:00")) ENGINE = InnoDB);

提示

如果我们只有 7 天的历史数据，手动创建这个列表并不困难。如果我们要在一个大型现有数据库上执行这项操作，这可能会是一个需要手动编辑的大列表。使用像 Excel 这样的软件或编写一个小脚本来生成大列表会比较容易。

确保这里最旧的分区与我们在第 9 步中收集的时间戳相匹配。在我的案例中，最旧的数据来自 2023 年 6 月 11 日，因此这是我的最旧分区。另外，确保你最新的分区与正在分区的日期相匹配。
从第 9 步中复制并粘贴准备好的 MySQL 查询，并按Enter键。这可能需要一段时间，因为你的表可能非常大。完成后，你将看到以下内容：

图 12.3 – MySQL 成功返回历史表的查询结果

对剩余的历史表进行相同的分区；确保使用其他 UNIX 时间戳来进行最早的分区：
- history_uint
- history_str
- history_text
- history_log
- history_bin
一旦你完成所有历史表的分区，接下来让我们对trends表进行分区。我们有两个这样的表，分别是trends和trends_uint。

我们将使用以下命令再次检查时间戳：

SELECT FROM_UNIXTIME(MIN(clock)) FROM trends;
SELECT FROM_UNIXTIME(MIN(clock)) FROM trends_uint;

对于这些表，重要的是要关注最早的月份。对于我的表，这是 2023 年 6 月。

现在，让我们为这个表准备并执行分区。让我们从第 14 步中看到的最早时间戳开始，做两个额外的分区：

ALTER TABLE trends PARTITION BY RANGE ( clock)
(PARTITION p2023_06 VALUES LESS THAN (UNIX_TIMESTAMP("2023-07-01 00:00:00")) ENGINE = InnoDB,
PARTITION p2023_07 VALUES LESS THAN (UNIX_TIMESTAMP("2023-08-01 00:00:00")) ENGINE = InnoDB,
PARTITION p2023_08 VALUES LESS THAN (UNIX_TIMESTAMP("2023-09-01 00:00:00")) ENGINE = InnoDB);

再次从最早收集的 UNIX 时间戳开始分区，一直到当前月份。但是，为未来的数据创建一些新分区也无妨：

图 12.4 – MySQL 成功返回趋势表的查询结果

对trends_uint表做同样的操作。
这就结束了数据库的实际分区。让我们确保我们的分区保持管理。在你的 Zabbix 数据库 Linux 主机上，使用以下命令下载分区脚本：
```
wget https://raw.githubusercontent.com/OpensourceICTSolutions/zabbix-mysql-partitioning-perl/main/mysql_zbx_part.pl
```
如果你不能使用wget，只需从以下链接下载脚本：github.com/OpensourceICTSolutions/zabbix-mysql-partitioning-perl/blob/main/mysql_zbx_part.pl。

或者，你也可以使用此 GitHub 链接下载分区脚本：

github.com/PacktPublishing/Zabbix-7-IT-Infrastructure-Monitoring-Cookbook/tree/main/chapter12/mysql_zbx_part.pl
现在，使用以下命令创建目录并将脚本移动到/usr/lib/zabbix/文件夹：
```
mkdir /usr/lib/zabbix/
mv mysql_zbx_part.pl /usr/lib/zabbix/
```
我们将自定义脚本中的一些细节。使用以下内容编辑脚本：
```
vim /usr/lib/zabbix/mysql_zbx_part.pl
```
我们需要编辑以下部分的文本：

图 12.5 – MySQL Zabbix 分区脚本用户参数

编辑$db_schema，使其匹配你的 Zabbix 数据库名称。
编辑$db_user_name以匹配你的 Zabbix 数据库用户名。
编辑$db_password以匹配你的 Zabbix 数据库密码。
现在，在$tables变量中，我们将添加一些最重要的细节。在这里我们将添加要保留多少天的历史数据以及多少个月的趋势数据。添加你的值；默认设置保留 30 天的历史数据和 12 个月的趋势数据。
同时，确保编辑my $curr_tz = Etc/UTC;行，以匹配你自己的时区。例如，我将使用 Europe/Amsterdam。

提示

如果你使用的是 Zabbix 2.2 版本之前的版本，或 MySQL 5.6 版本之前的版本，或者你正在运行 MySQL 8，那么脚本中需要注释掉并取消注释一些额外的配置行。如果适用于你，请阅读mysql_zbx_part.pl脚本文件中的注释并进行编辑。另外，请查看本食谱引言中提到的 GitHub 仓库。

在执行脚本之前，我们需要安装一些 Perl 依赖项。在基于 RHEL 的系统上，我们需要额外的仓库。

基于 RHEL8 的命令如下：
```
dnf config-manager --set-enabled powertools
dnf config-manager --enable crb
```

使用以下命令安装依赖项。

基于 RHEL 的命令如下：

dnf update
dnf install perl-Sys-Syslog
dnf install perl-DateTime
dnf install perl-DBD-mysql
dnf install perl-DBI

Ubuntu 命令如下：

apt install liblogger-syslog-perl
apt install libdatetime-perl

使用以下命令使脚本可执行：

chmod +x /usr/lib/zabbix/mysql_zbx_part.pl

然后，这是我们应该准备好执行脚本并查看它是否正常工作的时刻。让我们执行它：
```
/usr/lib/zabbix/mysql_zbx_part.pl
```
一旦脚本执行完毕，让我们通过以下命令查看它是否成功：
```
journalctl -t mysql_zbx_part
```
你应该看到如下输出：

图 12.6 – MySQL Zabbix 分区脚本结果

现在，执行以下命令：
```
crontab -e
```
要自动执行脚本，请将以下行添加到文件中：
```
55 22 * * * /usr/lib/zabbix/mysql_zbx_part.pl
```
我们需要做的最后一件事是进入 Zabbix 前端。导航到管理 | 日常维护。
由于脚本将接管数据库历史和趋势的删除，必须禁用历史和趋势表的日常维护。它将如下所示：

图 12.7 – Zabbix 管理 | 一般 | 历史和趋势的日常维护被禁用

这就是我们 Zabbix 数据库分区设置的结束。

它是如何工作的…

数据库分区看起来像是一个大胆的任务，但一旦将其拆分成小块，其实并不难。它只是将我们最重要的 Zabbix 数据库表分解为基于时间的分区的过程。一旦这些分区设置好，我们只需要通过脚本管理这些表，就可以了。

请看下图，假设今天是2023 年 06 月 19 日。我们有很多由脚本管理的分区。今天我们所有的历史数据将写入当天的分区，而所有的趋势数据将写入本月的分区：

图 12.8 – Zabbix 分区示意图

实际的脚本只做两件事。它创建新的分区，并删除旧的分区。

对于删除分区，当一个分区的年龄超过$tables变量中指定的时间时，它将删除整个分区。

对于创建分区，每次运行脚本时，它会从今天开始创建未来的 10 个分区，当然，前提是该分区尚不存在。

这样做比使用 Zabbix housekeeper 有一个明显的优点，那就是速度更快！Zabbix housekeeper 会逐行检查数据库数据的 UNIX 时间戳，并在数据超过指定时间后删除该行。这需要时间和资源。而删除分区几乎是瞬间完成的。

然而，分区 Zabbix 数据库的一个缺点是，我们将无法使用前端的历史和趋势配置。这意味着我们不能为不同的项指定不同的历史和趋势；现在一切都是全局的。

另见

当我第一次使用 Zabbix 时，我没有像这本书这样的参考资料。相反，我依赖于网上可用的资源和自己的技能。有很多关于分区和其他内容的优秀指南可供参考。如果这本书没有提到某些内容，确保去 Google 上查找看看是否有相关信息。你还可以查看我们 Zabbix 同行写的一些精彩书籍，当然，如果你自己解决了某个问题，分享就是关爱！

使用 PostgreSQL TimescaleDB 功能

TimescaleDB 是一个开源的关系型 PostgreSQL 数据库扩展，用于基于时间的序列数据。使用 PostgreSQL TimescaleDB 是绕过使用 Zabbix housekeeper 来管理 PostgreSQL 数据库的可靠方法。在本食谱中，我们将介绍如何在新服务器上安装 PostgreSQL TimescaleDB，并与 Zabbix 配合使用。

准备工作

我们需要一台空的 Linux 服务器。我将使用名为lar-book-postgresql-mgmt的服务器。

如何操作……

对于基于 RHEL 的系统和 Ubuntu 系统，我们有一些不同的流程，这也是我们将 如何操作… 部分分为两部分的原因。我们将从 Ubuntu 系统开始。

Ubuntu 安装

让我们登录到 Linux CLI，并使用以下命令添加 PostgreSQL 仓库：

apt install gnupg postgresql-common apt-transport-https lsb-release wget
/usr/share/postgresql-common/pgdg/apt.postgresql.org.sh

现在，添加 TimescaleDB 仓库：

echo "deb https://packagecloud.io/timescale/timescaledb/ubuntu/ $(lsb_release -c -s) main" | sudo tee /etc/apt/sources.list.d/timescaledb.list
wget --quiet -O - https://packagecloud.io/timescale/timescaledb/gpgkey | sudo apt-key add -
apt update

现在，使用以下安装命令安装 TimescaleDB：
```
apt install timescaledb-2-postgresql-15
```

启动并启用 PostgreSQL 12：

systemctl enable postgresql
systemctl start postgresql

现在，继续本食谱中的TimescaleDB 配置部分。

基于 RHEL 的安装

让我们从登录到 Linux CLI 开始。我们需要 PostgreSQL 版本 11 或更高版本。让我们安装版本 12；首先，禁用 AppStream：
```
dnf -qy module disable postgresql
```

添加正确的仓库：

dnf install https://download.postgresql.org/pub/repos/yum/reporpms/EL-8-x86_64/pgdg-redhat-repo-latest.noarch.rpm

然后，安装 PostgreSQL：

dnf install postgresql15 postgresql15-server

确保初始化数据库：

/usr/pgsql-15/bin/postgresql-15-setup initdb

现在，将仓库信息添加到文件中并保存：

tee /etc/yum.repos.d/timescale_timescaledb.repo <<EOL
[timescale_timescaledb]
name=timescale_timescaledb
baseurl=https://packagecloud.io/timescale/timescaledb/el/$(rpm -E %{rhel})/\$basearch
repo_gpgcheck=1
gpgcheck=0
enabled=1
gpgkey=https://packagecloud.io/timescale/timescaledb/gpgkey
sslverify=1
sslcacert=/etc/pki/tls/certs/ca-bundle.crt
metadata_expire=300
EOL

使用安装命令安装 TimescaleDB：

dnf install timescaledb-2-postgresql-15

现在，继续执行本配方的 TimescaleDB 配置 部分。

TimescaleDB 配置

在本节中，我们将介绍在完成安装过程后如何设置 TimescaleDB。还有更多的配置内容，让我们一起来看看：

让我们首先运行以下命令：
```
timescaledb-tune
```
有时这不起作用，您可以像这样指定 PostgreSQL 的位置：
```
timescaledb-tune --pg-config=/usr/pgsql-15/bin/pg_config
```
按照步骤操作，并根据提示用 yes 或 no 回答问题。对于首次设置，所有选项选择 yes 是合适的。
现在，重新启动 PostgreSQL：
```
systemctl restart postgresql-15
```

如果您还没有安装，请使用以下命令下载并安装 Zabbix。

基于 RHEL 的命令如下：

rpm -Uvh https://repo.zabbix.com/zabbix/7.0/rhel/9/ x86_64/zabbix-release-7.0-1.el8.noarch.rpm
dnf clean all
dnf install zabbix-server-pgsql zabbix-web-pgsql zabbix-apache-conf zabbix-agent2

Ubuntu 的命令如下：

wget https://repo.zabbix.com/zabbix/7.0/ubuntu/pool/main/z/zabbix-release/zabbix-release_7.0-1+ubuntu22.04_all.deb
dpkg -i zabbix-release_7.0-1+ubuntu22.04_all.deb
apt update
apt install zabbix-server-pgsql zabbix-frontend-phpphp-pgsql zabbix-apache-conf zabbix-agent2

使用以下命令创建初始数据库：

sudo -u postgres createuser --pwprompt zabbix
sudo -u postgres createdb -O zabbix zabbix

导入 PostgreSQL 的数据库架构：

zcat /usr/share/doc/zabbix-server-pgsql*/create.sql.gz | sudo -u zabbix psql zabbix

通过编辑 Zabbix 配置文件，将数据库密码添加到其中：
```
vim /etc/zabbix/zabbix_server.conf
```
添加以下行，其中 password 是在第 6 步中设置的密码，DBHost 留空：
```
DBHost=
DBPassword=password
```

现在，使用以下命令启用 TimescaleDB 扩展：

echo "CREATE EXTENSION IF NOT EXISTS timescaledb CASCADE;" | sudo -u postgres psql zabbix

解压位于 Zabbix 共享文件夹中的 timescale.sql 脚本：

gunzip /usr/share/doc/zabbix-sql-scripts/postgresql/timescaledb.sql.gz

现在，让我们运行 timescale.sql：

cat /usr/share/doc/zabbix-sql-scripts/postgresql/timescaledb.sql| sudo -u zabbix psql zabbix

在进入前端之前，我们还需要做一件事。我们需要编辑 pg_hba.conf 文件以允许我们的 Zabbix 前端进行连接。编辑以下文件：
```
vim /var/lib/pgsql/15/data/pg_hba.conf
```

确保文件中的以下行与之匹配；它们需要以 md5 结尾：

# "local" is for Unix domain socket connections only
local all all
scram-sha256
# IPv4 local connections:
host all  all  127.0.0.1/32
md5
# IPv6 local connections:
host all  all  ::1/128
scram-sha256

现在，启动 Zabbix 并使用以下命令完成前端设置：

在基于 RHEL 的系统上：

systemctl restart zabbix-server zabbix-agent2 httpd php-fpm
systemctl enable zabbix-server zabbix-agent2 httpd php-fpm

在 Ubuntu 系统上：

systemctl restart zabbix-server zabbix-agent2 apache2 php-fpm
systemctl enable zabbix-server zabbix-agent2 apache2 php-fpm

一旦我们进入前端并登录到我们的设置，导航到管理 | 日常维护。
现在，我们可以编辑以下参数以匹配我们的偏好，TimescaleDB 将负责维护数据保留期限：

图 12.9 – Zabbix 管理 | 日常维护，TimescaleDB 特定选项

它是如何工作的……

使用 TimescaleDB 功能与您的 Zabbix 设置集成，可以与 PostgreSQL 数据库实现稳固的集成。该扩展由 Zabbix 支持，预计在不久的将来将变得更好。

现在，TimescaleDB 的工作原理是将您的 PostgreSQL 超表按时间分割成数据块。如果我们查看下图，我们可以看到它的样子：

图 12.10 – TimescaleDB 超表数据块示意图

这些基于时间的块比使用 Zabbix housekeeper 从数据库中删除要快得多。Zabbix housekeeper 会逐行遍历我们的数据库数据，检查 UNIX 时间戳，然后当数据超过指定时间时删除该行。这个过程需要时间和资源。而删除一个块几乎是瞬间完成的。

使用 TimescaleDB 与 Zabbix 数据库结合的另一个优点是，我们仍然可以使用前端的项目历史记录和趋势配置。更重要的是，TimescaleDB 可以压缩我们的数据，以保持数据库的较小体积。

缺点是我们不能为不同的项目指定不同的历史记录和趋势；现在这一切都是全局的。

另见

本教程详细介绍了 PostgreSQL TimescaleDB 的安装。由于这个过程在不断变化，你可能需要从官方 TimescaleDB 文档中获取一些新的信息。你可以在这里查看它们的文档：

docs.timescale.com/latest/getting-started/installation/rhel-centos/installation-yum

保护你的 Zabbix MySQL 数据库

Zabbix 服务器的另一个伟大功能是能够加密数据库与 Zabbix 组件之间的数据。这在你使用分离的数据库和 Zabbix 服务器通过网络连接时尤其有用。中间人攻击 (MITM) 或其他攻击可以在网络上执行，从而获取你的监控数据。

在本教程中，我们将设置 MySQL 加密，确保 Zabbix 组件和数据库之间增加另一层安全性。

准备工作

我们需要一个使用外部数据库的 Zabbix 设置。我将使用 Linux 的 lar-book-secure-db 和 lar-book-secure-zbx 主机。

新的服务器 lar-book-secure-zbx 将用于外部连接到 lar-book-secure-db 数据库服务器。数据库服务器不会运行我们的 Zabbix 服务器；这个过程将运行在 lar-book-secure-zbx 上。

确保 lar-book-secure-db 主机上已安装 MariaDB，并且你正在运行支持加密的最新版本。如果你不知道如何升级数据库，请查看 第十一章 中名为 从旧版本的 MariaDB 升级 Zabbix 数据库到 MariaDB 10.5 的教程，或查阅在线文档。

如何操作…

确保准备工作部分中两个主机的主机文件包含 Linux 主机的主机名和 IP，并按以下内容编辑文件：
```
vim /etc/hosts
```
然后，在文件中填写你的主机名和 IP。文件应如下所示：
```
10.16.16.170 lar-book-secure-db
10.16.16.171 lar-book-secure-zbx
```
在 lar-book-secure-db MySQL 服务器上，如果还没做过，请通过登录 MySQL 创建 Zabbix 数据库：
```
mysql -u root -p
```

然后，执行以下命令以创建数据库：

create database zabbix character set utf8mb4 collate utf8mb4_ bin;

同时，确保创建一个可以安全访问数据库的用户。确保 IP 地址与 Zabbix 服务器的 IP 地址匹配（如果 Zabbix 前端与服务器分开，则还需要匹配该前端的 IP 地址）：
```
create user 'zabbix'@'10.16.16.171' identified BY 'password';
grant all privileges on zabbix.* to 'zabbix'@'10.16.16.171';
flush privileges;
```
退出 MySQL，然后确保使用以下命令运行安全的mysql脚本：
```
mariadb_secure_installation
```

登录到lar-book-secure-zbx并使用以下命令安装 Zabbix 服务器仓库：

rpm -Uvh https://repo.zabbix.com/zabbix/7.0/rhel/9/x86_64/zabbix-release-7.0-1.el8.noarch.rpm
dnf clean all

让我们在服务器上添加 MariaDB 仓库：

wget https://downloads.mariadb.com/MariaDB/mariadb_repo_setup
chmod +x mariadb_repo_setup
./mariadb_repo_setup

然后，安装 Zabbix 服务器及其必需的组件。

使用以下基于 RHEL 的命令：

dnf install zabbix-server-mysql zabbix-web-mysql zabbix-apache-conf zabbix-agent2 zabbix-sql-scripts mariadb-client

使用以下 Ubuntu 命令：

apt install zabbix-server-mysql zabbix-frontend-php zabbix-apache-conf zabbix-agent2 mariadb-client

从 Zabbix 服务器连接到远程数据库服务器，并使用以下命令导入数据库架构和默认数据：
```
zcat /usr/share/doc/zabbix-sql-scripts/mysql/server.sql.gz | mysql -h 10.16.16.170 -uzabbix -p zabbix
```
现在我们将打开名为openssl.cnf的文件，并通过发出以下命令进行编辑：
```
vim /etc/pki/tls/openssl.cnf
```

在此文件中，我们需要编辑以下行：

countryName_default = XX
stateOrProvinceName_default = Default Province
localityName_default = Default City
0.organizationName_default = Default Company Ltd
organizationalUnitName_default.=

完整填写后将如下所示：

图 12.11 – 带有我们个人默认设置的 OpenSSL 配置文件

我们还可以看到这一行：

dir = /etc/pki/CA    # Where everything is kept

这意味着默认目录是/etc/pki/CA；如果您的目录不同，请相应调整。保存并关闭文件，继续操作。
让我们使用以下命令为我们的私有证书创建一个新文件夹：
```
mkdir -p /etc/pki/CA/private
```

现在，让我们在新文件夹中创建我们的密钥对。发出以下命令：

openssl req -new -x509 -keyout /etc/pki/CA/private/cakey.pem -out /etc/pki/CA/cacert.pem -days 3650 -newkey rsa:4096

现在将提示您输入密码：

图 12.12 – 证书生成响应，要求输入密码

您也可能会被提示输入一些有关公司信息的内容。它将使用我们之前填写的默认值，因此您可以直接按Enter，直到常用名称。
在常用名称处填写根证书颁发机构，并像这样添加您的电子邮件地址：

图 12.13 – 证书生成响应，要求输入信息，根证书颁发机构

接下来是创建 Zabbix 服务器将使用的实际签名证书。让我们确保 OpenSSL 拥有跟踪已签名证书所需的正确文件：
```
touch /etc/pki/CA/index.txt
echo 01 > /etc/pki/CA/serial
```

然后，创建文件夹以存放我们的证书：

mkdir /etc/pki/CA/unsigned
mkdir /etc/pki/CA/newcerts
mkdir /etc/pki/CA/certs

现在，让我们使用以下命令为lar-book-secure-zbx Zabbix 服务器创建证书签名请求：

openssl req -nodes -new -keyout /etc/pki/CA/private/zbx-srv_key.pem -out /etc/pki/CA/unsigned/zbx-srv_req.pem -newkey rsa:2048

您将被提示再次输入密码和公司信息。在常用名称之前使用默认设置。我们将填写我们的常用名称，即服务器的主机名，并像这样添加我们的电子邮件地址：

图 12.14 – 证书生成响应，要求输入信息，lar-book-secure-zbx

让我们对lar-book-secure-db服务器执行相同的操作：

openssl req -nodes -new -keyout /etc/pki/CA/private/mysql-srv_key.pem -out /etc/pki/CA/unsigned/mysql-srv_req.pem -newkey rsa:2048

响应将如下所示：

图 12.15 – 证书生成响应请求信息，lar-book-secure-db

重要提示

我们的证书需要在没有密码的情况下创建；否则，MariaDB 和 Zabbix 应用程序将无法使用它们。确保指定 -****nodes 选项。

现在，使用以下命令为 lar-book-secure-zbx 签署证书：

openssl ca -policy policy_anything -days 365 -out /etc/pki/CA/certs/zbx-srv_crt.pem -infiles /etc/pki/CA/unsigned/zbx-srv_req.pem

您将被提示询问签署证书吗？[y/n]。请回答Y，并对所有后续问题也回答Y。

现在，让我们对 lar-book-secure-db 证书做同样的操作：

openssl ca -policy policy_anything -days 365 -out/etc/ pki/CA/certs/mysql-srv_crt.pem -infiles/etc/pki/CA/ unsigned/mysql-srv_req.pem

让我们登录到 lar-book-secure-db MySQL 服务器，并为我们新创建的证书创建一个目录：
```
mkdir /etc/my.cnf.d/certificates/
```

为文件夹添加正确的权限：

chown -R mysql. /etc/my.cnf.d/certificates/

现在，回到新的 lar-book-secure-zbx Zabbix 服务器，使用以下命令将文件复制到数据库服务器：

scp /etc/pki/CA/private/mysql-srv_key.pem root@10.16.16.170:/etc/my.cnf.d/certificates/mysql-srv.key
scp /etc/pki/CA/certs/mysql-srv_crt.pem root@10.16.16.170:/etc/my.cnf.d/certificates/mysql-srv.crt
scp /etc/pki/CA/cacert.pem root@10.16.16.170:/etc/my.cnf.d/certificates/cacert.crt

现在，回到 lar-book-secure-db MySQL 服务器，为文件添加正确的权限：

chown -R mysql:mysql /etc/my.cnf.d/certificates/
chmod 400 /etc/my.cnf.d/certificates/mysql-srv.key
chmod 444 /etc/my.cnf.d/certificates/mysql-srv.crt
chmod 444 /etc/my.cnf.d/certificates/cacert.crt

使用以下命令编辑 MariaDB 配置文件：
```
vim /etc/my.cnf.d/server.cnf
```

在 [****mysqld] 块下的配置文件中添加以下行：

bind-address=lar-book-secure-db
ssl-ca=/etc/my.cnf.d/certificates/cacert.crt
ssl-cert=/etc/my.cnf.d/certificates/mysql-srv.crt
ssl-key=/etc/my.cnf.d/certificates/mysql-srv.key

使用以下命令登录 MySQL：
```
mysql -u root -p
```
确保我们的 Zabbix MySQL 用户需要 SSL 加密，使用以下命令：
```
alter user 'zabbix'@'10.16.16.152' require ssl;
flush privileges;
```
确保 IP 地址与 Zabbix 服务器的 IP 地址匹配（如果它们分开，还要确保 Zabbix 前端的 IP 地址匹配），就像我们在步骤 2中做的那样。
退出 MariaDB CLI，然后使用以下命令重启 MariaDB：
```
systemctl restart mariadb
```
现在，回到 lar-book-secure-zbx Zabbix 服务器，创建一个新文件夹来存放我们的证书：
```
mkdir -p /var/lib/zabbix/ssl/
```

使用以下命令将证书复制到这个文件夹中：

cp /etc/pki/CA/cacert.pem /var/lib/zabbix/ssl/
cp /etc/pki/CA/certs/zbx-srv_crt.pem/var/lib/zabbix/ssl/zbx-srv.crt
cp /etc/pki/CA/private/zbx-srv_key.pem/var/lib/zabbix/ssl/zbx-srv.key

编辑 Zabbix 服务器配置文件，以便使用这些证书：
```
vim /etc/zabbix/zabbix_server.conf
```
确保以下行与我们的 lar-book-secure-db 数据库服务器的设置匹配：
```
DBHost=lar-book-secure-db
DBName=zabbix
DBUser=zabbix
DBPassword=password
```

现在，确保我们的 SSL 配置与新文件匹配：

DBTLSConnect=verify_full
DBTLSCAFile=/var/lib/zabbix/ssl/cacert.pem
DBTLSCertFile=/var/lib/zabbix/ssl/zbx-srv.crt
DBTLSKeyFile=/var/lib/zabbix/ssl/zbx-srv.key

同时，请确保为与 SSL 相关的文件添加正确的权限：

chown -R zabbix:zabbix /var/lib/zabbix/ssl/
chmod 400 /var/lib/zabbix/ssl/zbx-srv.key
chmod 444 /var/lib/zabbix/ssl/zbx-srv.crt
chmod 444 /var/lib/zabbix/ssl/cacert.pem

使用以下命令启动并启用 Zabbix 服务器：
- 基于 RHEL 的系统：
- systemctl restart zabbix-server zabbix-agent2 httpd php-fpm
- systemctl enable zabbix-server zabbix-agent2 httpd php-fpm
- Ubuntu 系统：
- systemctl restart zabbix-server zabbix-agent2 apache2 php-fpm
- systemctl enable zabbix-server zabbix-agent2 apache2 php-fpm
然后，导航到 Zabbix 前端并填写正确的信息，如下图所示：

图 12.16 – Zabbix 前端配置，数据库步骤

当我们点击下一步时，我们需要填写一些更多的信息：

图 12.17 – Zabbix 前端配置，服务器详情步骤

然后，在点击下一步、下一步和完成后，前端应该已经配置好并且能够正常工作。

它是如何工作的……

这是一篇比较长的教程，下面让我们快速总结一下：

在步骤 1至9中，我们准备了我们的服务器
在步骤 10至37中，我们执行了创建证书所需的所有操作
在步骤 38至47中，我们为 Zabbix 前端配置了加密

经过这些步骤后，安全地设置 Zabbix 数据库可能看起来是一项艰巨的任务，实际上确实如此。证书、登录程序、大量设置等因素都可能变得非常复杂，这也是我始终建议在尝试自己配置之前深入研究加密方法的原因。

然而，如果您的配置需要加密，本文提供的配置方法是第一次设置的良好起点。它在内部环境中运行良好，因为我们使用的是私有证书。

重要提示

确保更新您的 SSL 证书，因为它们的有效期仅限于我们定义的时长。在这种情况下是 365 天，因此我们每年都会更新一次。一个不错的计划是监控证书的到期日期，并在 Zabbix 中为其创建警报。

除了 Zabbix 服务器与 Zabbix 前端之间的通信外，所有 Zabbix 组件都可以加密，如下图所示：

图 12.18 – Zabbix 加密方案的可能性

我们已经在以下组件之间设置了加密：

Zabbix 服务器和 MariaDB
Zabbix 前端和 MariaDB

这意味着，当我们的 Zabbix 服务器或前端请求或写入数据库数据时，它将被加密。因为我们的 Zabbix 应用程序运行在与 Zabbix 数据库不同的服务器上，这一点可能很重要。例如，我们的配置可能是这样的：

图 12.19 – 带有外部网络图的 Zabbix 配置

假设云平台的名称是某公司，并且其网络不由我们管理。该网络中有多个交换机和路由器，用于多个具有独立 VLAN 的客户。如果其中某个设备被攻破，我们的所有 Zabbix 数据都可能被他人查看。

即使网络设备是我们的，网络中仍然可能存在被攻破的设备，我们的数据也可能被查看。这就是为什么你可能想要添加加密，以增加额外的安全层。无论是防止其他公司及其网络的入侵，还是防止我们自己出现漏洞，像我们在本教程中做的那样保护数据库，可能会帮助你避免泄露所有数据。

第十三章：将 Zabbix 引入云端与 Zabbix 云集成

在上一章，我们为你准备了一些特别的内容。作为一个长期使用 Zabbix 的用户，云集成对于像 Zabbix 这样的工具的重要性不言而喻。对于某些人来说，云可能会让人感到畏惧，因此在这一章中，我想向你展示，如何开始使用最流行的云服务提供商与 Zabbix 配合工作是多么简单。

我们将首先讨论如何使用 Zabbix 监控 亚马逊 Web 服务 (AWS) 云。然后，我们还将看到如何使用 Microsoft Azure 来完成相同的操作，以便清晰地看到它们之间的差异。

在了解了这些云产品之后，我们还将查看使用 Docker 进行容器监控，Docker 是一个非常流行的产品，通过设置 Zabbix 监控，它也能受益匪浅。请仔细跟随这些食谱，你将能够轻松监控所有这些产品，并利用 Zabbix 扩展这些产品。本章包括以下食谱：

设置 AWS 监控
设置 Microsoft Azure 监控
构建你的 Zabbix Docker 监控

技术要求

由于本章关注 AWS、Microsoft Azure 和 Docker 监控，我们需要一个正在运行的 AWS、Microsoft Azure 或 Docker 设置。食谱并未覆盖如何设置这些，因此请确保你已经准备好自己的基础设施。

此外，我们还需要运行 Zabbix 7 的 Zabbix 服务器。在本章中，我们将称这个服务器为 lar-book-rocky。

你可以从以下 GitHub 链接下载本章的代码文件：github.com/PacktPublishing/Zabbix-7-IT-Infrastructure-Monitoring-Cookbook/tree/main/chapter13。

设置 AWS 监控

目前，许多基础设施都在向云端迁移，重要的是要像管理自己的硬件一样监控这些基础设施。在本食谱中，我们将学习如何使用 Zabbix 监控 EC2 实例、关系型数据库服务 (RDS) 实例和 S3 存储桶。

准备工作

对于这个食谱，我们需要在我们的 AWS 云中至少拥有以下三种资源中的一种：

EC2 实例
RDS 实例
S3 存储桶

当然，我们还需要我们的 Zabbix 服务器，我们将在本食谱中称之为 lar-book-rocky。

重要提示

使用 Amazon CloudWatch 并不是免费的，因此你会产生费用。请在继续之前查看 Amazon AWS CloudWatch 的定价：aws.amazon.com/cloudwatch/pricing/。

如何操作…

设置 AWS 监控一开始可能看起来是一项艰巨的任务，但一旦我们掌握了技巧，它其实并不难。让我们不再浪费时间，来看看我们可以使用的一种方法：

我们从登录到我们的 Zabbix 服务器 lar-book-rocky 开始。
通过在浏览器中导航到以下 URL，登录到你的 AWS 账户：aws.amazon.com/。
在此页面上，点击登录到控制台。
登录后，我们可以导航到我的安全凭证，它应该会显示在用户资料的右上角：

图 13.1 – AWS 网络前端用户资料

在下一页的左侧，点击访问管理下的用户。
让我们通过点击添加用户按钮来创建一个新的专用 Zabbix 监控用户。按如下方式添加用户。

图 13.2 – AWS 新用户

点击下一步，在第二步，如果你愿意，可以将用户添加到一个组中，以继承某些权限，复制它们，或设置自定义策略。我现在跳过这一步，再次点击下一步。
现在点击创建完成该用户的设置。
从列表中选择用户以编辑：

图 13.3 – AWS – 编辑新 Zabbix 用户

在列表中，我们看到该用户还没有分配任何策略，因此我们将为 Zabbix 监控创建一个新的策略。
从下拉列表中点击创建内联策略：

图 13.4 – AWS – 编辑新 Zabbix 用户策略

然后点击JSON，以 JSON 格式定义新的策略。它应如下图所示：

图 13.5 – AWS – 编辑新 Zabbix 用户 – 添加新策略

提示

查看 Zabbix 的集成页面，了解你将使用的 AWS 模板所需的最新权限。不同的模板需要不同的权限，未来可能会添加新的权限，以便融入新的功能或 AWS 方面的变更：www.zabbix.com/integrations/aws。

现在，你可以点击下一步并为你的策略命名。

图 13.6 – AWS – 编辑新 Zabbix 用户 – 添加新策略名称

然后，点击页面底部的创建策略。

在权限设置好后，确保我们能够使用此用户账户进行身份验证。
在创建新策略后，仍停留在同一页面，向下滚动至访问密钥（访问密钥 ID 和秘密访问密钥），这将显示如下内容：

图 13.7 – AWS 访问密钥页面

点击创建访问密钥以创建新的访问密钥。你应该看到如下内容：

图 13.8 – AWS 访问密钥创建

选择一个理由并点击下一步。确保你理解可能的安全隐患。
给您的新访问密钥命名：

图 13.9 – AWS 访问密钥创建命名

最后，点击 创建访问密钥 并将访问密钥和秘密访问密钥存放在安全位置（例如密码保险箱）。完成后，点击完成：

图 13.10 – AWS 访问密钥创建 – 复制密钥

现在，让我们最终转向 Zabbix。登录到您的 Zabbix GUI 并导航到 数据收集 | 主机。
通过点击右上角的 创建主机 来创建一个新主机。我们将创建一个名为 lar-book-aws 的新主机，并添加 AWS by HTTP 模板和一个主机组，比如云。

图 13.11 – 新的 AWS 主机

在添加主机之前，请确保转到 宏变量。我们必须填写几个宏变量，以使这个新模板生效。确保填写您在 第 19 步 保存的键，并按照以下截图中的方式填写它们。同时，请确保添加您希望发现信息的区域。

图 13.12 – 新的 AWS 主机宏变量

重要提示

在我的情况下，我运行的所有 AWS 资源都位于同一个 AWS 区域。在许多生产环境中，情况并非如此。对于这些环境，您可能希望为每个区域创建一个 Zabbix 主机，以便发现所有资源。您所需做的就是为每个主机独特地定义 {$AWS.REGION} 宏。

现在点击添加以添加这个新主机。
如果操作正确，一旦执行了发现规则，您的 AWS 资源将被添加，就像我们在下面的截图中看到的一样，显示了一些我的 EC2 实例：

图 13.13 – 发现的 EC2 实例

工作原理...

现在我们已经完成了所有的设置工作，让我们看看我们实际上做了什么。Zabbix 7.0 包含了开箱即用的云监控模板，我们已经利用这些模板来监控一些常见的 AWS 资源。

Zabbix 提供的模板使用了相当广泛的 JavaScript 代码来执行针对 AWS 的 API 调用，解析接收到的数据，然后将其放入 Zabbix 的低级发现理解的 JSON 数组中。

查看 数据收集 | 模板下的模板，然后打开发现，查看 AWS by HTTP 模板，我们可以看到三个发现规则：

图 13.14 – AWS by HTTP 发现规则

这三个规则发现了 AWS 中的 EC2 实例、RDS 实例和 S3 存储桶，并使用 主机原型 为每个实例或存储桶创建了一个新主机。这些创建的主机然后会使用它们自己的模板从这些实例或存储桶获取实际的统计信息，正如我们在模板列表中所见：

图 13.15 – Zabbix 7.0 中其他三个 AWS 模板

在我的案例中，只发现了两个 EC2 实例，因此，这两个主机通过AWS EC2 by HTTP模板添加，正如在图 13.13中所见。

所有信息随后会通过脚本项目类型收集，并且每个项目都有自己独特的 JavaScript 代码。我们可以在以下截图中看到代码的一部分，其中我们向 AWS 发起请求到一个特定的 URL（下划线部分），并且添加了诸如身份验证等标头：

图 13.16 – AWS 模板调用

也可以编辑此 JavaScript 代码，以创建全新的调用来获取您自己的数据并创建不同类型的监控，或只是扩展现成的模板。

还有更多…

启动 AWS CloudWatch 监控需要时间，因为我们需要对 AWS CLI 命令和 CloudWatch 的使用有深入了解。当您使用 Zabbix 提供的模板作为基础时，您就有了一个坚实的基础，可以继续构建。

确保查看 AWS 文档，获取更多有关我们可以使用的命令的信息，使用以下链接：

docs.aws.amazon.com/cli/latest/reference/#available-services

设置 Microsoft Azure 监控

Microsoft Azure 云是当前云市场中的重要玩家，因此保持对该基础设施的关注与对自己硬件的关注一样重要。在本方案中，我们将探索如何使用 Zabbix 设置监控 Azure 实例。

准备工作

对于这个方案，我们需要在 Azure 云中至少已经具备以下其中一项资源。

Cosmos DB 用于 MongoDB 数据库
Microsoft SQL 数据库
MySQL 服务器
PostgreSQL 服务器
虚拟机

本方案不涵盖如何设置这些资源，所以请确保提前完成这部分工作。我们还需要 Zabbix 服务器，在本方案中我们称其为 lar-book-rocky。

如何操作…

对于 Azure 监控，我们面临的技术与 AWS 监控有一些相似之处。如果深入定制，可能会有些令人畏惧，但设置初始监控比看起来要简单得多。让我们来看看：

使用 Azure 监控时，首先我们需要正确设置身份验证。为此，请导航到 portal.azure.com 并登录。
在搜索框中，搜索企业应用程序并从列表中选择。点击新建应用程序：

图 13.17 – Azure 企业应用程序创建

然后点击创建您自己的 应用程序：

图 13.18 – Azure 企业应用程序创建 – 创建你自己的应用程序

这里是我们需要为应用程序命名的地方。为它起一个合适的名字，如下图所示：

图 13.19 – Azure 企业应用程序创建 – 设置应用程序名称

然后点击页面底部的创建按钮，完成新空应用程序的创建。页面上会显示应用程序 ID，请务必记录下来，稍后我们会用到它：

图 13.20 – Azure 企业应用程序概览页

应用程序创建完成后，我们立即开始为它设置凭据。为此，使用页面顶部的 Azure 搜索栏，搜索Azure Active Directory，然后从列表中选择它。
在左侧边栏，你应该能看到应用注册。我们将创建一个新的注册，点击新建注册：

图 13.21 – Azure 企业应用程序 – 应用注册

只需为你的注册起个新名称，保持其他设置为默认即可：

图 13.22 – Azure 企业应用程序 – 新的应用注册

点击注册，完成此注册。这将重定向到你新创建的注册。
现在我们来添加身份验证。在左侧边栏中，进入证书与机密。
我们将在这里创建一个新的客户端机密。为此，点击新建 客户端机密：

图 13.23 – Azure 企业应用程序 – 应用注册机密

现在我们需要做的就是为机密命名并设置过期时间。请记住，过期时间越短，管理开销越大。较短的过期时间可能意味着更好的安全性，因为泄漏的时间窗口更小（或者一旦泄漏，使用的时间更短）：

图 13.24 – Azure 企业应用程序 – 创建应用注册机密

现在点击添加，完成设置新机密。它只会显示一次，请务必将其保存在安全的地方，例如密码保险库：

图 13.25 – Azure 企业应用程序机密

身份验证完成后，只剩下一件事了。我们需要为这个新企业应用程序提供正确的权限。为此，请在页面顶部的 Azure 搜索栏中搜索订阅。
对于 Azure 虚拟机和数据库实例监控等内容，你需要为整个订阅分配（读取）权限。找到你的资源所在的订阅。我的订阅名为OICTS Azure：

图 13.26 – Azure 订阅

现在也是记录下订阅 ID 的好时机，因为我们将在稍后的步骤中需要它！
选择你的订阅，然后从列表中选择访问控制（IAM）。然后，点击添加 角色分配。

图 13.27 – Azure 订阅 – 角色分配

在下一页中，从列表中选择Reader角色，然后点击下一步。
在创建过程的成员部分，点击+ 选择成员。我们将添加Zabbix 书籍监控成员。它看起来如下：

图 13.28 – Azure 订阅 – 角色分配成员

现在点击审阅 + 分配，权限将被添加。
在 Azure 门户中，还有一件事需要做。在页面顶部的搜索栏中，输入租户属性并从列表中选择它。在此页面上，确保记录下租户 ID，因为稍后我们需要它。
设置好应用程序、创建好认证并分配好权限后，让我们继续进行 Zabbix 前端的操作。导航至数据收集 | 主机，然后点击右上角的创建主机以创建新主机：

图 13.29 – Azure 租户属性

创建以下主机，名称为lar-book-azure，选择通过 HTTP 的 Azure模板，并选择一个主机组，例如云：

图 13.30 – Zabbix 中新的 Azure 监控主机

在添加主机之前，切换到宏选项卡：

图 13.31 – Zabbix 中新的 Azure 监控主机宏

我们至少需要在此处添加以下宏：

对于{$AZURE.APP.ID}，在第 5 步中填写应用 ID。
对于{$AZURE.PASSWORD}，在第 13 步中填写值列下的值。
对于{$AZURE.SUBSCRIPTION.ID}，在第 15 步中填写订阅 ID。
对于{$AZURE.TENANT.ID}，在第 22 步中填写租户 ID。

就这样；你现在可以通过点击添加按钮来添加新主机。
在发现规则首次运行后，你的发现实例将被添加为新主机，正如你在下方的截图中看到的那样：

图 13.32 – 新的 Azure 发现虚拟机

就这样，你的自动化 Azure 监控现在已经按照预期工作了。让我们来看看它是如何工作的。

它是如何工作的……

如果您已经按照 AWS 监控的方法，您可能会认为 Azure 监控工作方式完全相同。在某种程度上，这是正确的；监控完全基于从 Zabbix 向 Azure API 发出的 API 调用。

AWS 和 Azure 之间的区别当然在于 Zabbix 项目中使用的 JavaScript 脚本。

Zabbix 7.0 提供的开箱即用的模板使用相当广泛的 JavaScript 代码来执行 API 调用向 Azure 发出请求，解析接收到的数据，然后将其放入 Zabbix 低级发现理解的 JSON 数组中。

查看在 数据收集 | 模板找到的模板，然后打开 Discovery，查看 Azure by HTTP 模板，我们可以看到六个发现规则。

图 13.33 – Azure by HTTP 发现规则

这些六条规则发现不同类型的 Azure 数据库实例和虚拟机，并使用主机原型为每个发现的实例创建新主机。这里唯一的区别是，存储帐户不会使用主机原型，而是使用项目原型来为您提供信息。由主机原型创建的主机将反过来使用它们自己的模板从这些实例或存储桶中获取实际统计数据，正如我们在模板列表中所见：

图 13.34 – Zabbix 7.0 中的其他 Azure 模板

在我的情况下，仅发现了一个虚拟机，因此，该主机已添加到 Azure Virtual Machine by HTTP 模板中，如 图 13**.32 所示。

所有信息都由其独特的 JavaScript 代码的 Script 项类型收集。我们可以在以下屏幕截图中看到一段代码，在这里我们调用 Azure 到特定的 URL（下划线标记）：

图 13.35 – Azure 模板调用

也可以编辑此 JavaScript 代码，创建全新的调用以检索您自己的数据并创建不同类型的监控，以及简单地扩展开箱即用的模板。

还有更多…

我们可以使用此配方中应用的方法从 Azure 中发现更多内容。我们使用的 JavaScript 用于从 Azure 获取指标，可以编辑以从 Azure API 中收集几乎任何指标。

查看 Azure API 文档，以获取有关使用 JavaScript 检索的指标的更多信息：

learn.microsoft.com/en-us/rest/api/azure/

创建您的 Zabbix Docker 监控

自 Zabbix 5 发布以来，通过引入 Zabbix agent 2 和插件，监控我们的 Docker 容器变得更加简单。使用 Zabbix agent 2 和 Zabbix 7，我们能够立即监控我们的 Docker 容器。

在这个配方中，我们将看到如何设置并了解其工作原理。

准备工作

本食谱需要一些 Docker 容器。我们不会详细介绍 Docker 容器的设置，因此请确保自行完成此操作。此外，我们还需要在运行这些 Docker 容器的主机上安装 Zabbix 代理 2。Zabbix 代理与本食谱无关；需要安装 Zabbix 代理 2。

我们还需要确保 Zabbix 服务器能够真正监控 Docker 容器。我们将我们的 Zabbix 服务器命名为zbx-home。

如何操作…

让我们不再浪费时间，直接进入使用 Zabbix 监控 Docker 设置的过程：

首先，登录到运行 Docker 容器的主机的 Linux 命令行界面。

添加安装 Zabbix 组件的仓库。

对于基于 RHEL 的系统，使用以下命令：

rpm -Uvh https://repo.zabbix.com/zabbix/7.0/rhel/8x86_64/zabbix-release-7.0-1.el8.noarch.rpm
dnf clean all

对于 Ubuntu 系统，使用以下命令：

wget https://repo.zabbix.com/zabbix/7.0/ubuntu/pool/main/z/zabbix-release/zabbix-release_7.0-1+ubuntu22.04_all.deb
dpkg -i zabbix-release_7.0-1+ubuntu22.04_all.deb
apt update

现在，使用以下命令安装 Zabbix 代理 2。

对于基于 RHEL 的系统，使用以下命令：
```
dnf install zabbix-agent2
```
对于 Ubuntu 系统，使用以下命令：
```
apt install zabbix-agent2
```
安装后，请确保使用以下命令编辑新安装的 Zabbix 代理 2 的配置文件：
```
vim /etc/zabbix/zabbix_agent2.conf
```
找到标有Server的行，并将 Zabbix 服务器的 IP 地址添加到文件中，如下所示：
```
Server=10.16.16.102
```
现在，我们需要通过执行以下命令将zabbix用户添加到 Docker 组：
```
gpasswd -a zabbix docker
```
确保保存文件，然后使用以下命令重新启动 Zabbix 代理 2：
```
systemctl restart zabbix-agent2
```
现在，进入你的 Zabbix 服务器前端，依次点击数据收集 | 主机，然后点击蓝色的创建主机按钮。
创建一个新的主机，命名为Docker 容器，并确保将Zabbix 代理 2 模板链接到该主机。

图 13.36 – 新的 Docker 主机配置

这就是通过 Zabbix 服务器监控 Docker 容器的全部内容。现在我们来看它是如何工作的。

它是如何工作的…

由于新的 Zabbix 代理 2 支持和默认模板，当前在 Zabbix 中监控 Docker 变得非常简单。然而，有时默认模板无法满足需求，因此让我们拆解一下所使用的项。

我们在主机上看到的几乎所有项都是依赖项，其中大多数依赖于主项Docker: Get info。这个主项是我们 Docker 模板中最重要的项。它执行docker.info项键，该键内置于新的 Zabbix 代理 2 中。该项从我们的 Docker 设置中获取一个包含各种信息的列表。我们使用依赖项和预处理来从这个主项中获取我们需要的值。

Docker 模板还包含两个 Zabbix 自动发现规则，一个用于发现 Docker 镜像，一个用于发现 Docker 容器。如果我们查看名为 Containers discovery 的 Docker 容器发现规则，我们可以看到发生了什么。我们的 Zabbix Docker 主机将使用 docker.containers.discovery 项目键来查找每个容器，并将其放入 {#NAME} LLD 宏中。在项目原型中，我们然后使用这个 {#NAME} LLD 宏与另一个主项目（如 docker.container_info）一起发现统计信息。从这个主项目中，我们再次使用依赖项和预处理将这些信息包含到其他项目原型中。现在，我们直接从 Docker 设置中监控一堆统计信息。

如果你想获取不在默认模板中的 Docker 值，可以查看模板中与主项目一起收集的信息。使用一个新的依赖项（原型），然后通过预处理从主项目中获取正确的数据。

还有更多…

如果你想了解更多关于 Zabbix agent 2 Docker 项目键的内容，请查看 Zabbix 文档中的 Zabbix agent 2 支持的项目键列表：

https://www.zabbix.com/documentation/current/en/manual/config/items/itemtypes/zabbix_agent/zabbix_agent2?s[]=docker.

posted @ 2025-07-08 12:24 绝不原创的飞龙阅读(26) 评论(0) 收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

Zabbix7-IT-基础设施监控秘籍第三版-全-

Zabbix7 IT 基础设施监控秘籍第三版（全）

前言

本书适用对象

本书的内容

要充分利用本书

下载示例代码文件

使用的约定

部分

准备工作

如何操作…

它是如何运作的…

还有更多…

另见

与我们联系

在我们开始之前

分享您的想法

下载这本书的免费 PDF 副本

第一章：1

安装 Zabbix 并开始使用前端界面

技术要求

安装 Zabbix 服务器

准备工作

如何操作…

它是如何工作的…

设置 Zabbix 前端

准备工作

如何操作…

工作原理…

还有更多...

启用 Zabbix 服务器 HA

准备就绪

如何操作…

设置数据库

设置 Zabbix 服务器集群节点

设置带有 HA 的 NGINX

它是如何运作的...

更多内容...

使用 Zabbix 前端

准备就绪

如何操作…

浏览 Zabbix 前端

准备就绪

如何操作…

第二章：2

使用 Zabbix 用户管理准备工作

技术要求

创建用户组

准备工作

如何操作…

还有更多...

使用 Zabbix 用户角色

准备中

如何做...

它是如何工作的……

还有更多...

创建您的第一个用户

准备工作

如何操作……

Azure AD SAML 用户认证与 JIT 用户配置

准备就绪

如何操作…

它是如何工作的…

还有更多…

OpenLDAP 用户身份验证和 JIT 用户配置

准备工作

如何操作…

它是如何工作的……

第三章：3

设置 Zabbix 监控

技术要求

设置 Zabbix 代理监控

准备工作

如何操作…

安装 Zabbix Agent 2

使用被动模式的 Zabbix 代理

使用 Zabbix 代理的主动模式

它是如何工作的…