Zabbix监控系统详解
一、监控软件选型
1、Cacti
Cacti是一套基于PHP，mysql，snmp，RRD tools开发的检测图形分析工具。Cacti是使用轮询的方式由 主服务器向设备发送数据请求来获取设备上转台数据信息。如果设备不断的增多，轮询就非常耗时，监控平台 最重要的东西就是实时性，如果一个监控的数据不具备实时性，那么这个监控就毫无意义，cacti因为轮询消 耗时间过长，导致无法获取设备的最新状态，所以cacti在大规模的监控场景，能力有限。cacti在早期的时 候不支持数据异常报警。
2、Nagios
Nagios是一款开源的免费网络监控报警服务，能监控windows，linux，unix等主机状态和主机信息。而且 nagios可以根据监控获得的数据第一时间进行报警。nagios扩展性非常好，支持数万台服务器或者上千台网 络设备的监控。nagios无法将多个相同应用及的数据整合起来，也不能监控到集群中特殊节点的迁移和恢复。
3、Ganglia
目前用于hadoop平台的监控。主要是用来监控系统性能，如：cpu 、mem、硬盘利用率， I/O负载、网络流量情况等，通过曲线很容易见到每个节点的工作状态，对合理调整、分配系统资源，提高系统整体性能起到重要作用。
4、Zabbix
zabbix是一个基于web界面的提供分布式系统监控以及网络监控功能的企业级开源解决方案。zabbix能监 控各种网络参数，保证服务器系统的安全运行，并且能够提供灵活的通知报警机制让系统管理员能快速的发现 问题，定位问题，解决问题。
zabbix除了支持主动模式之外还支持被动模式。所谓的主动还是被动针对的是agent，agent向zabbix的 server发送数据，就表示是主动模式，agent被动的等待server来提取数据，就是被动模式。
zabbix支持分布式的架构，可以采用zabbix proxy的方式来实现监控平台的轻松扩容，可以简单的实现 多数据中心多云平台监控。你想要扩容，搭建zabbix proxy即可。
zabbix支持多种报警，短信（SMS），邮件，语音，微软的team，企业微信，钉钉....
zabbix有非常漂亮的web界面（相对的），但是又不仅仅只是显示监控的数据，还可以通过web对监控内容 进行调整和配置，还支持多用户访问，以及外部身份认证与的集成。
zabbix是免费的。是开源的，是对公众可以任意使用的。虽然zabbix是开源的免费的，但是如果运维人员 的水平不够可能也没办法发挥zabbix的全部功能，一般对于开源监控平台来说，如果想玩到高级的程度，必 须要具备开发的知识。这个知识针对中小型的公司，需要运维人员对监控平台进行维护和问题发现以及问题处 理，对开发人员要求动态实时的定制需要监控的内容。所以说商机就来了，有很多公司提供zabbix的技术支 持，zabbix社区就是这些众多提供商业支持的最大的一家公司。
5、上述监控工具的区别
nagios的图形也不好看，虽然可以安装图形插件，但是也不好看。nagios如果需要图形，也可以和cacti配 合使用。
cacti虽然监控效率低下，但是图形比nagios好看。如果采用nagios和zabbix对网络节点进行监 控，那么他们因为是并发的监控，所以对cpu的要求很高（其实也不是特别高），是高是低取决于你设置的监 控项的数量，以及监控数据提取周期。
zabbix相比于nagios在功能上和性能上都强大一些，zabbix的图形 比nagios要好看（相对的）。
zabbix支持分部署。zabbi支持web配置，配置简单，zabbix支持自动发现 （我们一般会使用xml文件批量导入代替自动发现）。
二、Zabbix简介
Zabbix 是一个高度集成的网络监控解决方案，可以提供企业级的开源分布式监控解决方案，由一个国外的团队持续维护更新，软件可以自由下载使用，运作团队靠提供收费的技术支持赢利。
zabbix是一个基于Web界面的，提供分布式系统监控以及网络监视功能的企业级的开源解决方案。
zabbix能监视各种网络参数，保证服务器系统的安全运营，并提供灵活的通知机制以让系统管理员快速定位/解决存在的各种问题。
zabbix主要由2部分构成zabbix server和zabbix agent，可选组建zabbix proxy。
zabbix server可以通过SNMP，zabbix agent，fping端口监视等方法对远程服务器或网络状态完成监视，数据收集等功能。同时支持Linux以及Unix平台，Windows平台只能安装客户端。
zabbix 功能：
-
具备常见的商业监控软件所具备的功能（主机的性能监控、网络设备性能监控、数据库、性能监控、FTP 等通用协议监控、多种告警方式、详细的报表图表绘制）；
-
支持自动发现网络设备和服务器（可以通过配置自动发现服务器规则来实现）；
-
支持自动发现（low discovery）key 实现动态监控项的批量监控（需写脚本）；
-
支持分布式，能集中展示、管理分布式的监控点；
-
扩展性强，server 提供通用接口（api 功能），可以自己开发完善各类监控（根据相关接口编写程序实现）编写插件容易，可以自定义监控项，报警级别的设置；
-
数据收集；
-
可用和性能检测；
-
支持snmp(包括trapping and polling)，IPMI，JMX，SSH，TELNET；
-
自定义的检测；
-
自定义收集数据的频率；
-
服务器/代理和客户端模式；
-
灵活的触发器；
-
可以定义非常灵活的问题阈值，称为触发器，从后端数据库的参考值；
-
高可定制的报警；
-
发送通知，可定制的报警升级，收件人，媒体类型；
-
通知可以使用宏变量有用的变量；
-
自动操作包括远程命令；
-
实时的绘图功能；
-
监控项实时的将数据绘制在图形上面 WEB 监控能力 ZABBIX 可以模拟鼠标点击了一个网站，并检查返回值和响应时间；
Api 功能：
应用api功能，可以方便的和其他系统结合，包括手机客户端的使用。
更多功能请查看： Zabbix documentation
zabbix版本：
- Zabbix 3.0 Manual
- Zabbix 2.4 Manual
- Zabbix 2.2 Manual
- Zabbix 2.0 Manual
下载地址：Zabbix documentation 本次采用yum安装，安装zabbix3.0.使用Centos7
zabbix优缺点：
优点：
- 开源，无软件成本投入；
- 自动发现服务器和网络设备，并套用模板监控；
- 分布式的监控体系和集中式的web管理，对大型监控扩展有很好的支持；
- 支持多种协议设备监控；
- 可以针对报警默认进行固定操作，降低人为操作失误风险以及人员成本；
- Api 的支持，方便与其他系统结合；
缺点：
- 需在被监控主机上安装agent，所有数据都存在数据库里，产生的数据据很大,瓶颈主要在数据库；
三、Zabbix安装部署
1、Zabbix架构
Zabbix 通过C/S 模式采集数据，通过B/S模式在web 端展示和配置。
被监控端：主机通过安装agent 方式采集数据，网络设备通过SNMP 方式采集数据。
Server 端：通过收集SNMP 和agent 发送的数据，写入数据库（MySQL，ORACLE 等），再通过php+apache 在web 前端展示。
1）名词解析
zabbix-server：zabbix的控制中心，收集数据，写入数据；
zabbix-agent：部署在被监控端的一个程序，用于收集本机信息给服务端；
host：服务器；
item：监控项，例如监控cpu平均负载就是一个监控项，每隔一段时间获取一个值反馈到服务端；
trigger：触发器，一些逻辑规则的组合，他有三个值，正常，异常，未知。当监控项获取的值达到设定的阈值的时候，就会触发；
action：当trigger符合某个值的时候，就会触发操作，比如发送邮件；
2）zabbix 运行条件
Server：Zabbix Server 需运行在LAMP（Linux+Apache+Mysql+PHP）环境下（或者LNMP），对硬件要求低。
Agent：目前已有的agent 基本支持市面常见的OS，包含Linux、HPUX、Solaris、Sun、 windows
SNMP：支持各类常见的网络设备 SNMP(Simple Network Management Protocol,简单网络管理协议。
3）监控类型
硬件监控适用于物理机、远程管理卡（iDRAC），IPMI（只能平台管理接口）
ipmitools:，MegaCli（查看Raid磁盘） 系统监控: 监控cpt：lscpu、uptime、top、vmstat 1 、mpstat 1、htop；
- 监控内存： free -m；
- 监控硬盘： df -h、iotop；
- 监控网络： iftop、netstat、ss；
- 应用服务监控： nfs、MySQL、nginx、apache、php、rsync；
更详细的监控类型可以参考：http://www.abcdocker.com/abcdocker/1376
4）引入zabbix
所有监控范畴，都可以整合到Zabbix中：
- 硬件监控：Zabbix、IPMI、lnterface；
- 系统监控：Zabbix、Agent、Interface；
- Java监控：Zabbix、JMX、lnterface；
- 网络设备监控：Zabbix、SNMP、lnterface；
- 应用服务监控：Zabbix、Agent、UserParameter；
- MySQL数据库监控：percona-monitoring-plulgins；
- URL监控：Zabbix Web监控；
5）zabbix进程
zabbix_agentd：客户端守护进程，此进程收集客户端数据，例如cpu负载、内存、硬盘使用情况等。
zabbix_get：zabbix工具，单独使用的命令，通常在server或者proxy端执行获取远程客户端信息的命令。通常用户排错。例如在server端获取不到客户端的内存数据，我们可以使用zabbix_get获取客户端的内容的方式来做故障排查。
zabbix_sender：zabbix工具，用于发送数据给server或者proxy，通常用于耗时比较长的检查。很多检查非常耗时间，导致zabbix超时。于是我们在脚本执行完毕之后，使用sender主动提交数据。
zabbix_server：zabbix服务端守护进程。zabbix_agentd、zabbix_get、zabbix_sender、zabbix_proxy、zabbix_java_gateway的数据最终都是提交到server。
备注：当然不是数据都是主动提交给zabbix_server,也有的是server主动去取数据。
zabbix_proxy：zabbix代理守护进程。功能类似server，唯一不同的是它只是一个中转站，它需要把收集到的数据提交/被提交到server里。为什么要用代理？代理是做什么的？卖个关子，请继续关注运维生存时间zabbix教程系列。
zabbix_java_gateway：zabbix2.0之后引入的一个功能。顾名思义：Java网关，类似agentd，但是只用于Java方面。需要特别注意的是，它只能主动去获取数据，而不能被动获取数据。它的数据最终会给到server或者proxy。
2、centos安装部署 zabbix-5.0
5.0和之前3.4相差不大，首页相比之前更加的美化。
1. 在官网选择版本和机器型号，可以手动下载rpm包
2. 安装zabbix可用源和替换加速器。
rpm -Uvh https://repo.zabbix.com/zabbix/5.0/rhel/7/x86_64/zabbix-release-5.0-1.el7.noarch.rpm
sed -i 's#http://repo.zabbix.com#https://mirrors.aliyun.com/zabbix#' /etc/yum.repos.d/zabbix.repo
yum clean all && yum makecache3. 安装组件
yum -y install zabbix-server-mysql zabbix-agent4. 安装管理器
yum -y install yum-utils``yum-config-manager --enable rhel-server-rhscl-7-rpms5. 修改开启验证
vim /etc/yum.repos.d/zabbix.repo
[zabbix-frontend]
...
enabled=1
...
6. 安装nginx和mysql依赖包
yum install centos-release-scl -y
yum -y install zabbix-web-mysql-scl zabbix-nginx-conf-scl
yum -y install mariadb-server``systemctl enable --now mariadb7. 创建用户
mysql -uroot -p
create database zabbix character set utf8 collate utf8_bin;
create user zabbix@localhost identified by 'password';
grant all privileges on zabbix.* to zabbix@localhost;
quit;8. 引入初始架构和数据，系统将提示您输入新创建的密码
zcat /usr/share/doc/zabbix-server-mysql*/create.sql.gz | mysql -uzabbix -p zabbix9. 为Zabbix服务器配置数据库，编辑配置文件
vim /etc/zabbix/zabbix_server.conf
DBPassword=password10. 为Zabbix前端配置PHP，编辑配置文件
vim /etc/opt/rh/rh-nginx116/nginx/conf.d/zabbix.conf
listen 80;
server_name 1.1.1.1;11. 添加和打开注释
vim /etc/opt/rh/rh-php72/php-fpm.d/zabbix.conf, add nginx to listen.acl_users directive
listen.acl_users = apache,nginx
php_value[date.timezone] = Europe/Riga12. 启动Zabbix服务器和代理进程 启动Zabbix服务器和代理进程，并为它们的设置开机自启：
systemctl restart zabbix-server zabbix-agent rh-nginx116-nginx rh-php72-php-fpm
systemctl enable zabbix-server zabbix-agent rh-nginx116-nginx rh-php72-php-fpm13. 默认密码 Admin zabbix
3、zabbix分布式代理proxy部署
zabbix proxy可以代替zabbix server检索客户端的数据，然后把数据汇报给zabbix server，并且在一定程度上分担了zabbix server的压力.zabbix proxy可以非常简便的实现了集中式、分布式监控。
应用场景
- 不同网段，无法直接监控
- 上千台机器，分布式
proxy收集到数据之后，首先将数据缓存在本地，然后在一定得时间之后传递给zabbix server。
zabbix proxy是一个数据收集器，它不计算触发器、不处理事件、不发送报警。
1）环境
- 服务端 192.168.1.100
- 代理端 192.168.1.20 10.10.10.20
- 客户端 10.10.10.30
服务端可以连接代理端，但无法连接客户端。
2）代理端配置
配置数据库：
这里使用mysql数据库，自行安装数据库。
登陆数据库后：
create database zabbix_proxy character set utf8;
GRANT ALL PRIVILEGES ON zabbix_proxy.* TO 'zabbix'@'localhost' IDENTIFIED BY '123456';
flush PRIVILEGES;安装代理：
yum -y install gcc gcc-c++ libcurl-devel libevent-devel net-snmp-devel
wget https://sourceforge.net/projects/zabbix/files/ZABBIX%20Latest%20Stable/3.4.6/zabbix-3.4.6.tar.gz/download
tar -xf zabbix-3.4.6.tar.gz
cd zabbix-3.4.6
./configure --prefix=/usr/local/zabbix_proxy --enable-proxy --enable-agent --with-mysql --with-net-snmp --with-libcurl
make
make install导入数据：
mysql -u zabbix -p 123456 zabbix_proxy < database/mysql/schema.sql配置：
找到下面那些去修改，有的是注释，有的则不是：
vim /usr/local/zabbix_proxy/etc/zabbix_proxy.conf
Server=192.168.1.100 #服务端的ip，用来提交数据
ServerPort=10051 #代理监听的端口
Hostname=Zabbix proxy #proxy的hostname，很重要，要记住
DBHost=localhost #数据库，使用本地，也可以使用ip，本地的用sock链接
DBSocket=/tmp/mysql.sock #本地链接时修改
DBName=zabbix_proxy #数据库名称
DBUser=zabbix #用户
DBPassword=zabbix #密码
DBPort=3306 #数据库端口
HeartbeatFrequency=60 #心跳线（具体作用网了，看配置文件吧，这个默认就是60）
ConfigFrequency=60 #这个是往服务端发送数据时间，这里设置一分钟，当客户端出现问题，要一分钟后才能获得消息，可以修改vim /usr/local/zabbix/etc/zabbix_agentd.conf
Server=192.168.1.100
ServerActive=192.168.1.100/usr/local/zabbix/sbin/zabbix_proxy
/usr/local/zabbix/sbin/zabbix_agentd修改后启动：
netstat -unltp | grep :10050
netstat -unltp | grep :10051查看是否监听端口。
到服务端添加一台主机，ip为192.168.1.20，相当于添加一个客户端。
3）客户端配置
在客户端机器上：
yum -y install zabbix-agent添加代理ip：
vim /etc/zabbix/zabbix_agentd.conf
Server=10.10.10.20
ServerActive=10.10.10.20systemctl start zabbix-agent
netstat -unltp | grep :10050查看是否监听端口。
4）服务端配置
点击创建：
代理名称是创建那个，用于区分不同代理，选择主动式，代理主动提交数据。
到：
ip选择代理所能接触到的ip，在最下面选择代理，并且添加模板：
4、Centos7快速搭建zabbix 4.4
环境准备：
Linux 7.7.1908
nginx 1.16.1
zabbix-server 4.4
zabbix-agent 4.4
mysql 5.7.29
php 5.4.16
1. 包下载
wget https://repo.zabbix.com/zabbix/4.4/rhel/7/x86_64/zabbix-release-4.4-1.el7.noarch.rpm2. 关闭防火墙及selinux
systemctl stop firewalld && systemctl disable firewalld
sed -i 's/SELINUX=enforcing/SELINUX=disabled/'/etc/selinux/config1）zabbix安装配置
1. 安装Zabbix服务器、前端、代理
rpm -i https://repo.zabbix.com/zabbix/4.4/rhel/7/x86_64/zabbix-release-4.4-1.el7.noarch.rpm
yum install zabbix-server-mysql zabbix-web-mysql zabbix-agent -y2. 配置Zabbix-server
mv /etc/zabbix/zabbix_server.conf /etc/zabbix/zabbix_server.conf.bak
vim /etc/zabbix/zabbix_server.conf
LogFile=/var/log/zabbix/zabbix_server.log
LogFileSize=0 PidFile=/var/run/zabbix/zabbix_server.pid
SocketDir=/var/run/zabbix
DBHost=localhost
DBName=zabbix
DBUser=zabbix
DBPassword=zabbix
DBPort=3306
SNMPTrapperFile=/var/log/snmptrap/snmptrap.log
CacheSize=1024M
Timeout=4
AlertScriptsPath=/usr/lib/zabbix/alertscripts
ExternalScripts=/usr/lib/zabbix/externalscripts
LogSlowQueries=3000
3. 配置zabbix-agent
mv /etc/zabbix/zabbix_agent.conf /etc/zabbix/zabbix_agent.conf.bak
vim /etc/zabbix/zabbix_agentd.conf
PidFile=/var/run/zabbix/zabbix_agentd.pid
LogFile=/var/log/zabbix/zabbix_agentd.log
LogFileSize=0
Server= ListenPort=10050
ServerActive=
Hostname=
Include=/etc/zabbix/zabbix_agentd.d/
2）数据库安装配置
1. 安装数据库
wget http://dev.mysql.com/get/mysql57-community-release-el7-8.noarch.rpm
yum localinstall mysql57-community-release-el7-8.noarch.rpm -y2. 检查mysql源是否安装成功
yum repolist enabled | grep mysql.*-community.*
yum install mysql-community-server -y3. 启动MySQL服务
systemctl start mysqld4. 登录数据库
grep 'temporary password' /var/log/mysqld.log
mysql -uroot -p修改密码，Lenvoo@123是你的新密码：
mysql> SET PASSWORD = PASSWORD('Lenovo@123');如何解决ERROR 1819 (HY000): Your password does not satisfy the current policy requirements 呢？
set global validate_password_policy=0;
#再修改密码的长度
set global validate_password_length=1;
#再次执行修改密码就可以了
ALTER USER 'root'@'localhost' IDENTIFIED BY 'Lenovo@123';
#允许root远程登陆*
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'Lenovo@123' WITH GRANT OPTION;
5. 创建zabbix数据库和用户
mysql –uroot –p
mysql> create database zabbix character set utf8;
Query OK, 1 row affected (0.00 sec)
mysql> grant all privileges on zabbix.* to 'zabbix'@'localhost' identified by 'zabbix';
Query OK, 0 rows affected, 1 warning (0.00 sec)
mysql> flush privileges;
Query OK, 0 rows affected (0.00 sec)
6. 导入模板数据
方法1：
source /usr/share/doc/zabbix-server-mysql-4.4.1/create/schema.sql
source /usr/share/doc/zabbix-server-mysql-4.4.1/create/images.sql
source /usr/share/doc/zabbix-server-mysql-4.4.1/create/data.sql
方法2：
zcat /usr/share/docc/zabbix-server-mysql*/create.sql.gz | mysql -uzabbix -p zabbix
3）nginx安装配置
1. 安装nginx
yum install nginx -y2. 配置nginx
vim /etc/nginx/conf.d/default.conf
...
location / {
root /usr/share/zabbix;
index index.php;
}
...
location ~ \.php$ {
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME /usr/share/zabbix$fastcgi_script_name;
include fastcgi_params;
}
...
3. 修改zabbix前端文件权限
chown nginx:nginx /usr/share/zabbix/*
chmod -R 755 /usr/share/zabbix/*4. 启动nginx
systemctl restart nginx5. PHP安装配置
yum install php-fpm php-gd php-mbstring php-bcmath php-gd php-xmlwriter php-xmlreader -y6. 修改配置文件
sed -i s#max_execution_time = 30#max_execution_time = 600#g /etc/php.ini
sed -i s#max_input_time = 60#max_input_time = 600#g /etc/php.ini
sed -i s#memory_limit = 128M#memory_limit = 256M#g /etc/php.ini
sed -i s#post_max_size = 8M#post_max_size = 32M#g /etc/php.ini
sed -i s#upload_max_filesize = 2M#upload_max_filesize = 16M#g /etc/php.ini
sed -i s/;date.timezone =/date.timezone = Asia\/Shanghai/g /etc/php.ini
7. 启动php-fpm
systemctl start php-fpm8. 启动所有服务
systemctl start zabbix-server
systemctl start zabbix-agent
systemctl start nginx
systemctl start mysqld
systemctl start php-fpm
9. 设置开机启动项
systemctl enable zabbix-server zabbix-agent mysqld nginx php-fpm10. 检查端口
[root@zabbix-server]# netstat -pntl
tcp 0 0 127.0.0.1:9000 0.0.0.0:* LISTEN 5118/php-fpm: maste
tcp 0 0 0.0.0.0:80 0.0.0.0:* LISTEN 5046/nginx: master
tcp6 0 0 :::10050 :::* LISTEN 5577/zabbix_agentd
tcp6 0 0 :::10051 :::* LISTEN 4821/zabbix_server
tcp6 0 0 :::3306 :::* LISTEN 1703/mysqld
11.连接到新安装的Zabbix前端： http://server_ip
5、Centos7快速搭建Zabbix3.4
zabbix-server主要分为2部分：
- zabbix程序 程序根据客户端的监控项，从客户端获取数据并写入到数据库，再根据触发器/动作等配置进行操作。
- 展示页面 使用php编写，php脚本从数据库获得信息，用httpd或者nginx等网页服务器展示出来。
根据上述说明，zabbix需要部署在lamp或者lnmp上面，对于php页面来说，用apache好一些。
1）环境
[zabbix-server]
主机名 = host-1
系统 = centos-7.3
地址 = 1.1.1.1
软件 =
httpd-2.4 80
mariadb-5.5 3306
php-fpm-5.4 9000
zabbix-server-3.4 10051
[zabbix-agent]
主机名 = host-2
系统 = centos-7.3
地址 = 1.1.1.2
软件 =
zabbix-agent-3.4 10050
2）配置
配置服务端程序：
操作服务器（host-1）
安装依赖包：
yum -y install gcc gcc-c++ libevent-devel php-bcmath php-gd php-xml php-mbstring创建账号，为安全起见禁止登录：
groupadd zabbix
useradd -g zabbix -s /sbin/nologin zabbix下载源码包：
wget https://shell-auto-install.oss-cn-zhangjiakou.aliyuncs.com/package/zabbix-3.4.1.tar.gz
tar -xf zabbix-3.4.1.tar.gz
cd zabbix-3.4.1选择参数，当前只开启了服务端，其余编译参数请看 ‘附录’：
./configure --prefix=/usr/local/zabbix --enable-server --with-mysql
6. 编译安装
make install
7. 将php脚本复制到html目录下
cp -r frontends/php/* /var/www/html/8. 添加所有权限到php脚本，当然这种方式比较危险，具体在zabbix前端页面会说明对哪些脚本要权限，逐个改
chmod -R 777 /var/www/html9. 登陆mariadb并创建zabbix用户，当前mariadb无密码
MariaDB [(none)]> create database zabbixdb character set utf8;
MariaDB [(none)]>grant all on zabbixdb.* to zabbixuser@"localhost" identified by "123456";
MariaDB [(none)]>quit10. 按顺序导入zabbix自带的数据库
mysql -uzabbixuser -p123456 zabbixdb < database/mysql/schema.sql
mysql -uzabbixuser -p123456 zabbixdb < database/mysql/images.sql
mysql -uzabbixuser -p123456 zabbixdb < database/mysql/data.sql11. 修改php参数，符合zabbix要求
vim /etc/php.ini
post_max_size = 16M
max_execution_time = 300
max_input_time = 300
date.timezone = Asia/Shanghai
12. 重启服务
systemctl restart httpd php-fpm3）配置服务端网页
操作服务器（host-1）
1.访问http://1.1.1.1
2. LDAP是特殊配置，不用管
3. 数据库：zabbixdb 账号：zabbixuser 密码：123456
4. 地址和端口都默认，Name可以不写或者随便写
5. 确定信息后下一步即可
6. 若遇到这一步，是因为zabbix对/var/www/html/conf/没有权限或者没写写进去。需要手动将文件下载，然后传入到服务器的/var/www/html/conf/zabbix.conf.php中刷新即可
7. 登录，设置为中文。管理员：admin 密码：zabbix
更改为中文后，update更新：
最下面或提示zabbix-server未启动，下面将启动zabbix服务端：
4）启动zabbix-server
操作服务器（host-1）
1. 复制并修改启动脚本，将安装目录替换为设置目录
cp misc/init.d/fedora/core/zabbix_server /etc/init.d/
chmod +x /etc/init.d/zabbix_server
vim /etc/init.d/zabbix_server
BASEDIR=/usr/local/zabbix2. 修改配置文件，填写数据库信息，前端页面是告诉php脚本从哪个数据库获得信息展示，这里告诉后端程序将收集的信息写入哪个数据库
vim /usr/local/zabbix/etc/zabbix_server.conf
DBName=zabbixdb #数据库名
DBUser=zabbixuser #数据库用户名
DBPassword=123456 #数据库用户密码3. 启动并检查端口是否正常，因为很多时候显示启动但并没有真正启动
/etc/init.d/zabbix_server start
netstat -utnalp | grep :100514. 查看前端页面，会发现正常了
5）配置客户端
操作服务器（host-2）
1. zabbix客户端可以有版本小差异，服务端3.4版本，客户端3.2版本也可以
wget https://shell-auto-install.oss-cn-zhangjiakou.aliyuncs.com/package/zabbix-agent-3.4.1-1.el7.x86_64.rpm2. 安装
yum -y install zabbix-agent-3.4.1-1.el7.x86_64.rpm3. 清空配置后，编写配置，其它参数后面安装文档再加
> /etc/zabbix/zabbix_agentd.conf4. 当前配置是被动与主动模式都开启，方便后期调节
vim /etc/zabbix/zabbix_agentd.conf
#指定pid文件位置
PidFile=/var/run/zabbix/zabbix_agentd.pid
#指定日志文件位置
LogFile=/var/log/zabbix/zabbix_agentd.log
#设置为被动模式，将开启端口
StartAgents=3
#当前的主机名，要写正确，否则服务端会不识别
Hostname=host-2
#服务端的地址，用逗号(,)可以隔开写多个
Server=1.1.1.1
#服务端的地址，用逗号(,)可以隔开写多个
ServerActive=1.1.1.1
#自定义的脚本超时时间，
Timeout=8
#允许自定义脚本
UnsafeUserParameters=1
#加载其它配置文件
Include=/etc/zabbix/zabbix_agentd.d/*.conf
5. 启动效验
systemctl start zabbix-agent
systemctl enable zabbix-agent
netstat -unltp | grep 100506）测试
操作服务器（host-1）
1. 添加
2. 配置主机信息
3. 添加模板，连接模板后，主机将被模板所带的监控项监控
4. 一般选择Template OS Linux，先点击添加，再添加，不然模板连接不上
5. 等一分钟，ZBX灯亮
7）附录
编译参数：
1. 第一行是添加这个参数，需要安装的yum包，第二行是参数名
net-snmap-devel
--with-net-snmp
libcurl-devel curl-devel
--with-libcurl
libxml2-devel
--with-libxml2
OpenIPMI-devel
--with-openipmi
unixODBC-devel
--with-unixodbc
导入其余数据库：
1. postgresql导入
psql -U username
psql> create database zabbix;
psql > \q
cd database/postgresql
psql -U username zabbix < database/postgresql/schema.sql
psql -U username zabbix < database/postgresql/images.sql
psql -U username zabbix < database/postgresql/data.sql2. oracle导入
sqlplus zabbix/password@host/ORCL
sqlplus>@database/oracle/schema.sql
sqlplus>@database/oracle/images.sql
sqlplus>@database/oracle/data.sql四、Zabbix配置管理
1、zabbix批量修改主机名
通过zabbix开放的api进行批量操作，默认主机名是IP地址，尤其是自动发现的时候批量添加，如果挨个手动改会很累，这里配置批量加入。
新建文件ips.txt：
主机名 IP
主机名 IP
主机名 IP批量更新主机名：
#!/usr/bin/python3
# _*_ coding:utf-8 _*_
import json
import requests
#zabbix服务器的IP地址
zabbix_ip = "127.0.0.1"
#zabbix的用户名
zabbix_user = "Admin"
#zabbix的密码
zabbix_pass = "123456"
#zabbix api接口地址
url = "http://" + zabbix_ip + ":8000/api_jsonrpc.php"
#zabbix api定义的访问头部信息
post_header = {'Content-Type': 'application/json'}
# 调用zabbix api需要身份令牌auth
def get_auth():
post_data = {
"jsonrpc": "2.0",
"method": "user.login",
"params": {
"user": zabbix_user,
"password": zabbix_pass
},
"id": "1"
}
ret = requests.post(url, data=json.dumps(post_data), headers=post_header)
zabbix_ret = json.loads(ret.text)
print(zabbix_ret)
if 'result' not in zabbix_ret:
print('login error')
else:
auth = zabbix_ret.get('result')
return auth
# 以IP信息获取主机id
def get_hostid():
hostid_get = {
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": "extend",
"filter": {
"host": [
host_ip
]
}
},
"auth": Token,
"id": 2,
}
res2 = requests.post(url, data=json.dumps(hostid_get), headers=post_header)
res3 = res2.json()
#print(res3)
res4 = res3['result']
try:
host_id = res4[0]['hostid']
return host_id
except:
print("zabbix中不存在，跳过")
return "不行"
# 以主机ID来修改主机名
def update_hostname():
hostname_update = {
"jsonrpc": "2.0",
"method": "host.update",
"params": {
"hostid": host_id,
"name": host_name
},
"auth": Token,
"id": 3
}
res10 = requests.post(url, data=json.dumps(hostname_update), headers=post_header)
res11 = res10.json()
#print(res11)
if __name__ == '__main__':
'''
ips.txt里的文件内容：
主机名1 ip1
主机名2 ip2
主机名3 ip3
'''
with open("ips.txt", "r", encoding="utf8") as f:
for line in f:
line = line.split(" ")
host_name = line[0]
host_ip = line[1].strip()
#print(host_name)
#print(host_ip)
Token = get_auth()
#print(Token)
host_id = get_hostid()
if host_id == "不行":
continue
#print(host_id)
update_hostname()
print(host_name,host_ip,"已添加完成")
2、Zabbix常用监控项详解
zabbix自带很多模板，包含非常多的监控项可以满足系统层面的大部分要求。
模板有版本要求，有的zabbix-server是4.4版本，但客户端是3.2版本，可能会导致不支持此项监控，具体可以查看主机-》监控项，尽量让客户端和服务端版本一致。
以下是收集的zabbix-5.0上[Template OS Linux by Zabbix agent]模板的监控项，都是根据内容手工翻译的。推荐频率属于比较稳定的，具体根据需求配置。对于机器多的，可以让部分不重要（不搭配触发器）的监控项1h采集一次，减缓压力。
一天 1d 一小时 1h 一分钟 1m 1秒 1s。
基础监控：
| 归类 | 名称 | 键值 | 推荐频率 |
|---|---|---|---|
| 客户端 | zabbix客户端名称 | agent.hostname | 1h |
| 客户端是否ping通 | agent.ping | 1m | |
| 客户端版本 | agent.version | 1h | |
| 客户端是否可用 | zabbix[host,agent,available] | 1m | |
| 网络(ddl) | 网卡类型 | vfs.file.contents[“/sys/class/net/{#IFNAME}/type”] | 1h |
| 运行状态 | vfs.file.contents[“/sys/class/net/{#IFNAME}/operstate”] | 1m | |
| 网卡出接口每秒报文被丢弃数 | net.if.out[“{#IFNAME}”,dropped] | 3m | |
| 网卡进接口每秒报文被丢弃数 | net.if.in[“{#IFNAME}”,dropped] | 3m | |
| 网卡出接口每秒流量bps | net.if.out[“{#IFNAME}”] | 3m | |
| 网卡进接口每秒流量bps | net.if.in[“{#IFNAME}”] | 3m | |
| 网卡出接口每秒错误数据包数 | net.if.out[“{#IFNAME}”,errors] | 3m | |
| 网卡进接口每秒错误数据包数 | net.if.in[“{#IFNAME}”,errors] | 3m | |
| 内存 | 系统中总共swap | system.swap.size[,total] | 1h |
| 系统可用swap | system.swap.size[,free] | 1m | |
| 系统可用swap百分比 | system.swap.size[,pfree] | 1m | |
| 系统总共内存 | vm.memory.size[total] | 1h | |
| 系统中可用内存 | vm.memory.size[available] | 1m | |
| 系统可用内存百分比 | vm.memory.size[pavailable] | 1m | |
| 系统中已用内存百分比 | |||
| 系统信息 | 系统主机名 | system.hostname | 1h |
| 系统本地时间 | system.localtime | 1h | |
| 操作系统架构 | system.sw.arch | 1h | |
| 系统版本信息 | system.sw.os | 1h | |
| 系统安装包信息 | system.sw.packages | 1h | |
| 系统详细信息 | system.uname | 1h | |
| 系统运行持续时间 | system.uptime | 1h | |
| 系统开机时间 | system.boottime | 1h | |
| 系统配置的最大文件描述符数 | kernel.maxfiles | 1h | |
| 系统配置的最大进程数 | kernel.maxproc | 1h | |
| 系统中总共进程数 | proc.num | 1m | |
| 系统中正在运行的进程数 | proc.num[,,run] | 1m | |
| 登陆用户数 | system.users.num | 10m | |
| 系统中/etc/passwd文件的md5值 | vfs.file.cksum[/etc/passwd] | 15m | |
| 磁盘（ddl） | 可用inode百分比 | vfs.fs.inode[{#FSNAME},pfree] | 1m |
| 磁盘总共空间 | vfs.fs.size[{#FSNAME},total] | 1m | |
| 磁盘已用空间 | vfs.fs.size[{#FSNAME},used] | 1m | |
| 磁盘已用空间百分比 | vfs.fs.size[{#FSNAME},pused] | 1m | |
| cpu | 系统cpu的1分钟负载 | system.cpu.load[all,avg1] | 1m |
| 系统cpu的5分钟负载 | system.cpu.load[all,avg5] | 1m | |
| 系统cpu的15分钟内负载 | system.cpu.load[all,avg15] | 1m | |
| 系统cpu核心数 | system.cpu.num | 1h | |
| 系统cpu每秒中断数 | system.cpu.intr | 1m | |
| 系统cpu的每秒上下文切换数 | system.cpu.switches | 1m | |
| 系统cpu用户空间使用百分比 | system.cpu.util[,user] | 1m | |
| 系统cpu的io操作使用百分比 | system.cpu.util[,iowait] | 1m | |
| 系统cpu的硬中断使用百分比 | system.cpu.util[,interrupt] | 1m | |
| 系统cpu的空闲时间占用百分比 | system.cpu.util[,idle] | 1m | |
| 系统cpu的软中断使用百分比 | system.cpu.util[,softirq] | 1m | |
| 系统cpu系统空间使用百分比 | system.cpu.util[,system] | 1m | |
| 系统cpu虚拟化使用百分比 | system.cpu.util[,steal] | 1m | |
| 系统cpu进程优先级变更使用的百分比 | system.cpu.util[,nice] | 1m |
3、zabbix上的宏(macro)介绍
Zabbix支持许多在多种情况下使用的宏。宏是一个变量，由如下特殊语法标识：MACRO
有效地使用宏可以节省时间，并使Zabbix变地更加高效。
在一个的典型用途中，宏可以用于模板中。因此，模板的触发器可能命名为“{HOST.NAME}的mysql{#MYSQLPORT} 端口已宕掉，请注意查看！”。
当这个模板应用在主机（ 飞龙在天roledb-192.168.1.100）时，并且当触发器展示在监控页面上时，触发器的名称将解析为“飞龙在天roledb-192.168.1.100的mysql3306 端口已宕掉，请注意查看！”。
1）宏的优先级
1. 主机宏(HOST)–优先级最高 直接在主机上进行设置
2. 主机模板定义的宏–优先级次之。,如果有多个模板，那么按照模板越靠前那么宏的优先级越高（Template） 在模板上进行设置
3. 全局宏(Global)–优先级最低
2）宏的使用实例
1. 模板中使用
zabbix-5.0中Template Module Linux memory by Zabbix agent模板自带的宏有如下：
原本是大于90持续5分钟报警，现在用变量表示了，好处是可以定义90这个数字做变量然后在模板中多处使用，以后改对应宏，相应判断就都变了。
2. 主机中使用 当我们在监控主机时，不同的主机可能有不同的参数（比如不同的密码、端口），这时就需要针对单台主机进行宏变量设置。因为主机上的宏优先级最高。
3）支持的宏
4、zabbix硬件性能需求
1）硬件需求
无非就是cpu、内存、硬盘之类的
1. CPU 由你的zabbix数据库使用情况来做决定，如果你监控的项目越多，那你的cpu要越好。具体多好，下面有个表格
2. 内存与硬盘 最基本的需求：128MB内存、256MB硬盘，当然这样的机器这年头应该找不到了吧，尤其要说明硬盘的问题，你的监控项越多、历史记录保留时间的越久数据库将会越大。我所知道的100来台服务器，做基本的cpu、内存、硬盘、网卡流量等监控，长年累月下来大概60GB左右。
3. 其他硬件 如果你觉得有必要的话，你再准备一个GSM短信猫吧，不过很少人用，基本上都使用email或者飞信报警.
4. 硬件需求表
如上，P2的CPU、256MB内存已经可以监控20个主机。AMD 3200+/2G内存可以监控500个主机（05年大学的时候，中低端主流cpu，这都快10年了，尤其可见zabbix对服务器的硬件配置要求有多低）,现在的服务器一般都比上面最高配还来得高，所以我武断的认为，大家手头的服务器都有能力监控1w+以上的服务器，我再武断的认为手头上有1w+服务器的公司能有多少。
2）操作系统
支持如下平台，平台之多让人刮目相看，但是window只能跑客户端 Linux IBM AIX FreeBSD NetBSD OpenBSD HP-UX Mac OS X Solaris Windows: 2000, Server 2003, XP, Vista, Server 2008, 7, 8, Server 2012 (只能跑Zabbix agent)
3）数据库硬盘
100台服务器，每台服务器有30个监控项，每个监控项60秒刷新一次，需要多大的硬盘呢？ 众所周知，zabbix基本都是通过web配置，这些配置数据也是存放到数据库里的，但是它对硬盘容量的要求基本可以忽略不计，zabbix对硬盘的决定性因素有4个，如下：
1. 每秒处理的数据量 这个问题不说，大家也明白。这边的每秒只是一个平均值，例如我有3000个监控项，每60秒刷新一次，那么平均每秒有50（3000/60）个数据要处理。就是说每秒有50条数据要插入MySQL
2. 历史记录保存时间 zabbix对每个监控项的值都要记录下来，这些记录一般保留几周到几个月，具体看你的配置了。每个值都需要暂用硬盘空间。假如一个数据你要保留30天，而且每秒有50个值要保留，那我们一共有129，600，000（30天24小时3600秒）50个值，一条记录多大，由你的数据库引擎和你存储的数据类型来决定（浮点型，整形，字符型等等），一般来说一条记录需要占用50个字节（一个大概值），在这个案例中129,600,000个记录大约需要（12960000050字节）6.5G的硬盘空间
3. 趋势数据保存时间 什么是趋势数据呢？当你查看一周或者一月的图表，图表上看到的MAX/MIN/AVG/COUNT都是取自趋势数据，趋势数据一小时获取一次，一般情况下，趋势数据一条记录大概占用128字节，如果我们想保存5年趋势数据，3000个监控线需要2.4GB（3000个24小时356天*128字节）每年，5年一共16.8G
4. 事件记录保存时间 报警、警告、恢复等等事情，一个事件大概占用130个字节，一般情况下不会太多，除非运维做的太糟糕，或者运维要求太严格，把阀值调的很低。假如这个运维今年本命年，既没拜佛有没烧香，更别说给服务器贴灵符，于是这一年每秒钟就有一个事件发生，那么事件这一年占用的数据空间为：1年365天24小时3600秒130字节大概为4.1G空间。
5. 数据库空间计算公式 zabbix配置：固定大小，一般<10MB 历史数据：天数*(监控项总数/刷新频率)24小时3600秒50字节 趋势数据：天数（监控项总数/3600）24小时3600秒128字节 事件数据：天数事件个数（大概值）24小时3600秒*130字节
6. 最后 看到这里，大家都心里有数据了，数据库硬盘空间=配置文件大小+历史记录+趋势记录+事件记录。虽然这个硬盘会不停的增长，但是总有一天会停止增长，空间一直保持不变，zabbix会定时清理。
5、zabbix-server 服务端配置详解
# This is a configuration file for Zabbix server daemon
# To get more information about Zabbix, visit http://www.zabbix.com
############ GENERAL PARAMETERS #################
#监听的端口
#
# Mandatory: no
# Range: 1024-32767
# ListenPort=10051
#在连接其它服务器时，使用的本机ip地址
#
# Mandatory: no
# SourceIP=
#日志的类型
#
# Mandatory: no
# LogType=file
#存放日志的位置，不设置，则使用syslog
#
# Mandatory: no
# Default:
LogFile=/tmp/zabbix_server.log
#单个最大日志文件大小，超过则启动新文件
#设置为0则不启动新文件，单位MB
#
# Mandatory: no
# Range: 0-1024
# LogFileSize=1
#定义打印的日志登记。
#0：打印日志
#1：打印重要的错误日志
#2：打印错误信息
#3：打印应该信息
#4：打印调试信息
#
# Mandatory: no
# Range: 0-5
# DebugLevel=3
#pid文件位置
#
# Mandatory: no
# PidFile=/tmp/zabbix_server.pid
#socket所在目录
#
# Mandatory: no
# SocketDir=/tmp
#数据库实例的位置，如果设置为localhost，端口会使用mysql端口
#为空则用PostgreSQL的端口
#
# Mandatory: no
# DBHost=localhost
#数据库名字。对于sqlite3，要填写数据库文件位置，而数据库用户密码不需要
#
# Mandatory: yes
DBName=zabbix
#仅用于IBM DB2
#
# Mandatory: no
# DBSchema=
#数据库实例用户名，对sqlite无效
#
# Mandatory: no
# Default:
DBUser=zabbix
#数据库实例密码，对sqlite无效
#
# Mandatory: no
# DBPassword=
#mysql的socket文件路径
#
# Mandatory: no
# DBSocket=/tmp/mysql.sock
#mysql端口
#
# Mandatory: no
# Range: 1024-65535
# DBPort=3306
############ ADVANCED PARAMETERS ################
#pollers进程数，zabbix-server的工作进程
#
# Mandatory: no
# Range: 0-1000
# StartPollers=5
#IPMI pollers进程数
#
# Mandatory: no
# Range: 0-1000
# StartIPMIPollers=0
#预处理程序启动数目
#
# Mandatory: no
# Range: 1-1000
# StartPreprocessors=3
#检查unrechable hosts（包括IPMI）的进程数
#
# Mandatory: no
# Range: 0-1000
# StartPollersUnreachable=1
#trappers进程数。
#trappers接收其它hosts用zabbix_sender、active_agents、active proxies和child nodes发送的数据
#至少要一个trapper进程来前端显示zabbix-server是可用的
#
# Mandatory: no
# Range: 0-1000
# StartTrappers=5
#用于discover的discoverer的进程数
#
# Mandatory: no
# Range: 0-1000
# StartPingers=1
#未知
#
# Mandatory: no
# Range: 0-250
# StartDiscoverers=1
#用于http检查的进程数
#
# Mandatory: no
# Range: 0-1000
# StartHTTPPollers=1
#timers的进程数。
#用于处理基于时间的triggers中的function和maintainence功能
#只有第一个timer进程处理maintainence时间
#
# Mandatory: no
# Range: 1-1000
# StartTimers=1
#未知
#
# Mandatory: no
# Range: 0-100
# StartEscalators=1
#未知
#
# Mandatory: no
# Range: 0-100
# Default:
# StartAlerters=3
#zabbix java getway使用的ip或者hostname
#当java pollers启动时有效
#
# Mandatory: no
# JavaGateway=
#java geteway使用的端口
#
# Mandatory: no
# Range: 1024-32767
# JavaGatewayPort=10052
#java pollers的进程数
#
# Mandatory: no
# Range: 0-1000
# StartJavaPollers=0
#vmware pollers的进程数
#
# Mandatory: no
# Range: 0-250
# StartVMwareCollectors=0
#zabbix从vmware获取监控值的频率，单位是秒
#
# Mandatory: no
# Range: 10-86400
# VMwareFrequency=60
#暂无
#
# Mandatory: no
# Range: 10-86400
# VMwarePerfFrequency=60
#vmware的缓存，存储vmware数据的共享内存大小。
#只有当vmware collectors启动时生效
#
# Mandatory: no
# Range: 256K-2G
# VMwareCacheSize=8M
#暂无
# Mandatory: no
# Range: 1-300
# VMwareTimeout=10
#snmp设备在将数据发送到server前会将snmp数据存在文件中。
#必须和再zabbix_trap_receiver.pl或者snmptt配置文件中的配置相同。
#
# Mandatory: no
# SNMPTrapperFile=/tmp/zabbix_traps.tmp
#暂无
#
# Mandatory: no
# Range: 0-1
# StartSNMPTrapper=0
#trappers监听的ip，用逗号分隔ip列表
#
# Mandatory: no
# ListenIP=0.0.0.0
#暂无
#
# Mandatory: no
# Range: 0-24
# HousekeepingFrequency=1
#在zabbix数据库中有一个housekeeper表，其中记录了housekeeper要执行的任务
#在一次执行housekeep的过程中，最多删除这里定义的数量，为0则无限制
#sqlite3会忽略这个参数
#
# Mandatory: no
# Range: 0-1000000
# MaxHousekeeperDelete=5000
#存储host、item和trigger数据的存储空间
#
# Mandatory: no
# Range: 128K-8G
# CacheSize=8M
#将配置信息同步到内存中的频率
#
# Mandatory: no
# Range: 1-3600
# Default:
# CacheUpdateFrequency=60
#将数据同步到数据库的DBsyncers进程数
#
# Mandatory: no
# Range: 1-100
# StartDBSyncers=4
#存储history数据的内存大小
#
# Mandatory: no
# Range: 128K-2G
# HistoryCacheSize=16M
#暂无
#
# Mandatory: no
# Range: 128K-2G
# HistoryIndexCacheSize=4M
#存储trends数据的内存大小
#
# Mandatory: no
# Range: 128K-2G
# Default:
# TrendCacheSize=4M
#history数据缓存在内存中的内存大小。
#设置为0，则不缓存
#
# Mandatory: no
# Range: 0,128K-64G
# ValueCacheSize=8M
#zabbix等待agent，snmo设备或自定义脚本的执行时间
#
# Mandatory: no
# Range: 1-30
Timeout=4
#trapper处理新数据的超时时间
#
# Mandatory: no
# Range: 1-300
# TrapperTimeout=300
#当一个host保持unreachable状态后多久将其标记为unreachable状态
#
# Mandatory: no
# Range: 1-3600
# UnreachablePeriod=45
#当host为unavailable状态时，检查host的availability的频率
#
# Mandatory: no
# Range: 1-3600
# UnavailableDelay=60
#当host为unreachable状态时，检查host的availability的频率
#
# Mandatory: no
# Range: 1-3600
# UnreachableDelay=15
#自定义报警脚本的位置
#
# Mandatory: no
# AlertScriptsPath=${datadir}/zabbix/alertscripts
#自定义监控脚本的位置
#
# Mandatory: no
# ExternalScripts=${datadir}/zabbix/externalscripts
#fping的位置，fping可执行文件的owner要设置为root，并且设置suid
#
# Mandatory: no
# FpingLocation=/usr/sbin/fping
#同花顺那个，如果fping可以处理ipv6，那么可以留空
#
# Mandatory: no
# Fping6Location=/usr/sbin/fping6
#使用ssh检查和action所需要的ssh公钥，私钥位置
#
# Mandatory: no
# SSHKeyLocation=
#记录查询zabbix数据的慢查询，单位毫秒。
#只有当debuglevel设置为3/4时才会生效。
#设置为0，则不记录慢查询。
#
# Mandatory: no
# Range: 1-3600000
LogSlowQueries=3000
#临时文件目录
#
# Mandatory: no
# TmpDir=/tmp
#被动proxy的poller进程数
#
# Mandatory: no
# Range: 0-250
# StartProxyPollers=1
#zabbix-server 将配置信息同步到proxy的频率
#支队被动的proxy生效
#
# Mandatory: no
# Range: 1-3600*24*7
# ProxyConfigFrequency=3600
#zabbix-server 请求proxy历史数据的频率
#支队被动的proxy生效
# Mandatory: no
# Range: 1-3600
# ProxyDataFrequency=1
#是否允许server以root身份运行
#0不允许，1允许
#不允许则使用zabbix用户运行
#
# Mandatory: no
# AllowRoot=0
#使用哪个用户运行
#
# Mandatory: no
# Default:
# User=zabbix
#指定存放了设置自定义监控项的文件位置
#
# Mandatory: no
# Include=
# Include=/usr/local/etc/zabbix_server.general.conf
# Include=/usr/local/etc/zabbix_server.conf.d/
# Include=/usr/local/etc/zabbix_server.conf.d/*.conf
#暂无
#
# Mandatory: no
# SSLCertLocation=${datadir}/zabbix/ssl/certs
#暂无
#
# Mandatory: no
# SSLKeyLocation=${datadir}/zabbix/ssl/keys
#暂无
#
# Mandatory: no
# SSLCALocation=
####### LOADABLE MODULES #######
#loadable组件位置
#
# Mandatory: no
# LoadModulePath=${libdir}/modules
#需要server载入的loadable组件，格式为LoadModule=
#
# Mandatory: no
# LoadModule=
####### TLS-RELATED PARAMETERS #######
#未知
#
# Mandatory: no
# TLSCAFile=
#未知
# Mandatory: no
# TLSCRLFile=
#未知
#
# Mandatory: no
# TLSCertFile=
#暂无
#
# Mandatory: no
# TLSKeyFile=
6、Zabbix部署中出现的问题合集
1） [服务端]，报错：error: Unable to use libevent
编译安装zabbix-3.4.1或以上 ./confgure的时候出现以下错误：
configure: error: Unable to use libevent (libevent check failed)解答：
需要devel包进行编译：
yum install libevent-devel 即可。
2）[服务端]，有mailx12-4，报OpenSSL错误解决方法
更新补丁：
wget http://www.linuxfromscratch.org/patches/blfs/7.6/mailx-12.4-openssl_1.0.0_build_fix-1.patch
patch -Np1 -i mailx-12.4-openssl_1.0.0_build_fix-1.patch3）[服务端]，报错configure: error: Unable to use libpcre (libpcre check failed)
解决方法：
yum -y install pcre* libpcre*4）[服务端]，WEB页面php参数部分修改后不刷新
需要重启php-fpm和web服务器，比如nginx或者httpd。
如果还不行，可以编写phpinfo文件vim var/www/html/phpinfo.php
访问http://127.0.0.1/phpinfo.php
查看修改的参数是否对应，如果不对应，则证明php-fpm没有读取/etc/php.ini，一般源码安装的php-fpm会这样。
那就find查找php.ini，去看它读取的是哪个。修改那个。
5）[服务端]web界面错误，无法访问数据库
下载配置文件并将其置于conf /中将Zabbix PHP文件复制到的Web服务器HTML文档子目录中。
提供Web服务器用户对conf /目录具有写入权限，配置文件将被自动保存，并且可以立即进入下一步。
7、zabbix使用中出现的问题合集
1）[客户端]重启 libcurl.so.4: cannot open shared obje
问题：yum安装客户端,重启zabbix-agent客户端
/usr/sbin/zabbix_agentd: error while loading shared libraries: libcurl.so.4: cannot open shared obje解答：
看 /etc/zabbix/zabbix_agentd.conf是否存在，因为zabbix服务识别不到配置文件才会报错。
看看/etc/zabbix下面是不是有备份或者类似名字的配置文件，修改为zabbix_agentd.conf，这样服务就可以识别了。修改后重启客户端。
2）[客户端]日志出现（Not all processes could be identified）
场景：一般是自定义监控项时，脚本里使用了netstat这个命令。
权限问题，zabbix_agentd是zabbix用户启动的，默认不能执行netstat -p等命令，导致从服务器取到的自动发现脚本为空。
(Not all processes could be identified, non-owned process info
will not be shown, you would have to be root to see it all.)解决方法 ：
chmod +s /bin/netstatchmod +s 是为了方便普通用户执行一些特权命令，SUID/SGID程序允许普通用户以root身份暂时执行该程序，并在执行结束后再恢复身份。
3）zabbix升级，再重启服务端后网页上出现Database error
报错：
Database error
–The frontend does not match Zabbix database. Current database version (mandatory/optional): 3040000/3040000. Required mandatory version: 3020000. Contact your system administrator.解答：
未完成。
4）重启客户端或者服务端出现 [2332]: user zabbix does not exist
重启zabbix客户端或服务端。
如下：
zabbix_agentd [2332]: user zabbix does not exist
zabbix_agentd [2332]: Cannot run as root!解答：
创建一个zabbix用户，如果存在zabbix用户还是依然这个错误，则su - zabbix 再启动。
用zabbix这个用户去重启，如果重启还不行，切换回root后再重启，一般就ok了。
5）将编译后的zabbix相关配置文件和东西放到新机器，启动失败
将zabbix配置文件整体放到新机器的目录下，启动失败。
解答：
还没知道，不过还原可以。
待定。
6）zabbix无法启动，启动显示正确，但是没有端口号
解答：
关闭selinux即可。
或者配置selinux策略（LAMP环境）：
setsebool -P httpd_can_connect_zabbix on
setsebool -P httpd_can_network_connect_db on导入module注：若没有audit2allow模板，请安装selinux-policy* setroubleshoot
yum -y install selinux-policy* setroubleshoot
cat /var/log/audit/audit.log | grep zabbix_server | grep denied | audit2allow -M zabbix-server_setrlimit生成：
modulesemodule -i zabbix-server_setrlimit.pp
semodule -i zabbix-server_setrlimit.pp7）自定义的脚本服务端和客户端获得值不一致
前情提要：
自定义zabbix脚本监控mysql，出现在客户端用
zabbix_agentd -t slave_status[Slave_IO_Running]获得值为0，是正确的
但在服务端用
/usr/local/zabbix/bin/zabbix_get -s 192.168.1.14 -k slave_status[Slave_IO_Running]获得却为1。
原因：
这是因为在服务端执行时用的当前终端，和脚本执行的一样，而在服务端获取是独立的终端。
例如上述脚本需要调用mysql这个命令，但mysql是源码安装的，做了环境变量。那在客户端执行时没问题的，因为加载了当前的环境变量。
如果是服务端执行，会报错mysql not found，没有mysql这个命令。因为脚本是对mysql -e “xxx”方式获得的值进行if判断，为真则echo 0，为假则echo 1。没有mysql命令自然返回1了。
因为服务端不加载/etc/profile这种环境变量，他不登录服务器。
解决办法：
可以再脚本中写绝对路径来避免此类错误。也可以用ln -s对命令做一个软连接，连接到/usr/local/bin/下面。
8）自定义监控项取不到数据，报错Received value [sudo:sorry,you must have a tty to run sudoi]
报错信息：
zabbix_agentd -t slave_status[Slave_IO_Running]
Received value [sudo:sorry,you must have a tty to run sudoi]is not suitable for value type [Numeric(unsigend)]原因：
导致这问题的原因是 sudo默认需要在 tty终端里才能正确被调用，而用的脚本，才会出现这个问题。
解决：
我们可以通过修改 /etc/sudoers配置文件来解决这个问题：
vi /etc/sudoers
#Defaults requiretty #注释掉此行9）自定义监控项，检测报错ZBX_NOTSUPPORTED: Unsupported item key.
报错信息：
原因：
Zabbix Agent默认的超时时间是3秒。往往我们自定义的Item由于各种原因返回时间会比较长（比如监控mysql，可能4秒后脚本才运行完毕）。所以建议统一修改一个适合自己实际的值。
解决：
vim /etc/zabbix/zabbix_agent.conf
Timeout=810）命令行可以取值，在图形显示不支持键值，看不到值
报错：
自定义的脚本如下：
a是mysql从和主同步时，从慢同步多少秒。
b是上一个a值
只有当上一值大于600，最新值大于600，才会输出a，也就是该报警了、
这样做防止主执行一个大的事物，导致从瞬间sbm高涨，然后又降低了。
只有上一个值和当前值都很高，才判定有问题。
a=mysql同步慢多少秒
b=`cat /tmp/sbm.tmp`
if [[ $a -ge 600 ]] && [[ $b -ge 600 ]];then
echo $a
else
echo 0
fi
echo "$a" >> /tmp/sbm.tmp结果发现值是灰色的，但用 zabbix_agentd -t 键值 来测试没有问题。
原因：
zabbix自定义的脚本不能有输出或者写入文件等操作。
解决：
将最后输出那行删除就行了。
11）zabbix启动客户端报错libpcre.so.1找不到
报错如下：
/usr/local/zabbix-agent/sbin/zabbix_agentd: error while loading shared libraries: libpcre.so.1: cannot open shared object filefind / -name libpcre.so*
#里面这个1应该是之前链接不行的 或者删除 再链接
ln -s /usr/lib64/libpcre.so.0 /usr/lib64/libpcre.so.1
vim /etc/ld.so.conf
/usr/lib64/libpcre.so.1
ldconfig在配置文件加上，再去启动服务：
/etc/init.d/zabbix_agentd start8、zabbix 性能优化
zabbix默认的配置即使机器128核心，256内存，只能抗住10-20台的监控，如果再多就需要修改配置了。
server端配置文件添加如下：
StartPollers=160
StartPollersUnreacheable=80
StartTrappers=20
StartPingers=100
StartDiscoverers=120
Cachesize=1024M
startDBSyncers=16
HistoryCacheSize=1024M
TrendCacheSize=1024M
HIstoryTextCacheSize-512M
1）数据库
如果数据库和zabbix在一台机器，可以使用socket连接，速度会提高。
数据库zabbix来说，选择InnoDB引擎，效率是其它引擎的1.5倍。
对history类型的(history、history_uint等)大表进行拆分操作，关闭housekeeper禁止自动定期清除历史记录数据，因为对于数据库特别是对于InnoDB引擎大数据删除貌似很蛋疼。
可以对数据库配置文件调优，因为都要提交到数据库中，当机器很多时，数据库压力会很大。
如果还是太多，可以考虑将mysql单独一台，并设置读写分离，可以用中间件实现。
2）服务端配置
关闭服务端的housekeep：
housekeep是清理历史的机制，配置文件中，默认是每小时启动一次，然后清除监控项设置之外的多余历史记录。比如mysql监控项默认保存90天，他会清除90天以外的，这会导致经常去清理，有时会报错：Zabbix housekeeper processes more than 75% busy
2种方法：
A：编辑server端的配置文件，修改或添加如下2行，一天清理一次，并每次清理最多500行。
HousekeepingFrequency=24 zabbix执行Housekeeping的频率，单位为hours
MaxHousekeeperDelete=500 每次最多删除历史数据的行
B：关闭housekeep，并手动清理日志
2.2版本以下，server端配置文件添加：
DisableHousekeeping=1 设置为1
2.2以上，到web界面修改：
"Administration" -> "General" ，选择"Housekeeping" ，确保history和trends栏的"Enable internal housekeeping"的对勾去掉。
调整监控项：
很多监控项都是无用的或者目前用不到的，像redis监控模板中的调阅/发布监控项应该去掉。
监控项的类型最好使用数字，尽量避免使用字符。字符在数据库中的存储空间使用较大，在设置trigger时也相对麻烦，并且zabbix本身处理数字的效率要相对高。如果业务需要字符类型的监控项，可以适当的降低数据采集的时间间隔以提高处理效率。
Trigger中，正则表达式函数last(),nodata()的速度最快，min()、max()、avg()的速度最慢。在使用过程中，尽量选择速度较快的函数。配置Trigger时，也应注意使用正确的逻辑，错误的逻辑可能导致数据库查询较慢的现象。
item监控性默认大部分都是保留90d（天）或者1w（周）的历史数据，趋势图数据保留365天。
其实有趋势图数据即可，历史数据保留7天足够了，采集频率，像磁盘，文件大小等很久才变化的，采集频率可以加大，以达到缓解压力和节省空间的作用。
如果主机数量太多，采用代理：
如果主机数量太多，可以考虑分机房，分业务，分组的方式来用代理中转。zabbix_proxy可以代替服务端收集数据和监控，但是监控结果还是发送到服务端汇总，代理是没有web界面的。
如果机器太多，可以用主动模式，当前所有默认都是被动模式的，客户端启动10051端口，服务端需要去10051取数据。
- 减少 history 保存时间
- 减少 item 获取间隔时间
- 减少不必要的监控项
9、Zabbix监控 服务级别
当前的监控均为监控单独的应用状态，对于一组应用提供的功能，zabbix也可以监控。
例如某个论坛服务有4台机器。对于论坛这个服务来说，只有网页服务和数据服务都没问题，它才能正常工作。
而对于网页服务/数据服务来说，只要其中一台数据库没问题，它才能正常工作。
1. 配置 -> 服务
2. 有一个root，这是所有的父节点，点击添加子节点即可。
3. 状态计算算法，任何一个节点有问题就报警，触发器则是报警
10、Zabbix正则表达式
在zabbix中，正则表达式经常使用的地方应该就是LLD，比如，你发现的网卡或磁盘有一大堆，但是有一些不是你想要的。比较典型的比如lo（回环地址），VLAN、Tunnel、InLoopBack0、NULL0等交换机网口，这时，你就可以通过正则表达式进行过滤掉。
1. 点击 基础配置
2. 选择正则表达式
3. 新建正则表达式
4. 测试
正则表达式写好以后，可以直接在线进行测试。
例子：交换机接口过滤掉不需要的端口
例子：磁盘自动发现时过滤盘符
磁盘自动发现时，我只需要：
hda|hdb|sda|sdb|sdc|sdd|sde|sdf|sdg|sdh|xvda|xvdb|vda|vdb|vdc|cciss/c0d0p[1-9] 这些开头的盘符。
例子：mysql屏蔽端口
比如在mysql多实例发现的过程中，我用3308来进行测试，而3306和3307则为线上正常使用的实例，这时，我就可以屏蔽3308实例就行。
操作如下：
1. 写正则
2.在Host上应用
注意：引用正则表达式的时候，需要使用 @ + 正则表达式名。
表达式类型
1. 字符串已包含（Character string included） - 匹配子字符串
2. 字符串未包含（Character string not included） - 匹配除了子字符串之外的任何字符串
3. 结果为真（Result is TRUE） - 匹配正则表达式
4. 结果为假（Result is FALSE） - 不匹配正则表达式
11、zabbix显示中文报警
1）安装时指定
在创建数据库是指定utf8，如果没有指定：
mysql>create database zabbixdb character set utf8;2）安装时未指定，手工配置
修改配置文件：
1. 修改数据库字符集，安装数据库要指定utf8，如果没指定修改配置文件
vim /etc/my.cnf.d/client.cnf
[client] #client字段下增加
default-character-set=utf8vim /etc/my.cnf.d/server.cnf
[mysqld] #下面增加
character_set_server = utf8
2. 重启
systemctl restart mariadb3. 进入数据库
mysql
mysql>status;4. 有如下显示即可
Server characterset: utf8
Db characterset: utf8
Client characterset: utf8
Conn. characterset: utf8
3）修改数据库
1. 再挨个修改数据库，表，字段的字符编码，将zabbixdb数据库导出
mysqldump -uzabbixuser -p123456 zabbixdb > zabbixdb.sql2. 批量用sed修改导出文件的字符编码
cp zabbixdb.sql bak.sql
sed -i 's/latin1/utf8/g' zabbixdb.sql3. 直接导入修改后文件
mysql -uzabbixuser -p123456 zabbixdb < zabbixdb.sql4. 数据库字符集修改查询，用于效验
mysql> show variables like 'character_set_database';12、zabbix配置自动发现
在主机较多的时候，配置主机自动发现并加入监控可以代替手动的添加主机，减轻工作量，自动发现由服务端主动发起，Zabbix Server开启发现进程，定时扫描局域网中IP服务器、设备。
可以根据需要，在对主机安装系统的时候就安装配置并启动zabbix-agent服务，这样的话只要主机系统安装完成，便会自动加入监控。
图形配置：
1. 配置自动发现
2. 配置完自动发现后，还需要配置自动连接到哪个模板，哪个组。
3. 如果自定义的网络段大的话New condition中的HostIP还可以精确IP范围，到此网络自动发现添加完成。
验证结果，查看主机列表有几台agent服务器被监控。
4.查看添加按规则之后的主机列表。
多了两台主机证明规则生效了。
13、zabbix配置主机自动注册
自动注册是客户端主动去访问服务端的10051端口，将自身信息发送过去，从而登记到zabbix上。
1. 修改配置文件
vim /etc/zabbix/zabbix_agentd.conf
ServerActive=172.16.1.61 #填写server端ip
# Hostname=Zabbix server #注释掉
HostnameItem=system.hostname #添加如下2. 配置 >> 动作 >> 事件源(自动注册) >> 创建动作
3. 创建动作，添加名称即可
4. 条件中也无需修改
5. 在动作中添加动作
添加主机、添加到主机群组、链接到模板。
6. 添加完动作后，等待就行了
注意：重启客户端可以加速发现。但是在生产环境中勿用。
14、Zabbix客户端 主/被模式
zabbix客户端yum下载地址
zabbix客户端源码下载地址
Zabbix的监控分为主动和被动，这2个都是针对客户端说的。当客户端为被动模式（默认）时，将开启10050端口，由服务端定期从客户端获取数据。当客户端为主动模式时，客户端将不用开启端口，由客户端主动向服务端提交数据。
被动模式由服务端主动取数据，在监控的数量达到一个量级的时候，会导致服务端很卡，并且需要服务端可以访问客户端的10050端口，如果不在一个网段，那客户端需要公网地址。
好处是支持所有监控项。
主动模式由客户端主动提交数据，将大大减少服务器的负载，并且不需要客户端和服务端在一个网段，客户端只要能访问服务端即可。
坏处是不支持某些监控项，目前测试 自动发现模板 时也没法使用（不排除我操作错误）。
1）安装客户端
yum安装
1. 下rpm包，服务端是3.4版本，客户端是3.2或者3.0版本都可以，只要版本差距不大即可，不过最好还是对应版本的客户端。
wget repo.zabbix.com/zabbix/3.2/rhel/7/x86_64/zabbix-release-3.2-1.el7.noarch.rpm2. 安装客户端
yum -y install zabbix-release-3.2-1.el7.noarch.rpm3. 说明
配置文件：
/etc/zabbix/zabbix-agentd.conf日志：
/var/log/zabbix/zabbix-agentd.log启动：
systemctl start zabbix-agent源码安装
空，这个不推荐，太麻烦了。
2）配置为被动模式（默认）
默认的监控项模板都是被动模式的，所以修改配置文件并套用模板即可。
1. 修改配置文件
#指定pid文件位置
PidFile=/var/run/zabbix/zabbix_agentd.pid
#指定日志文件位置
LogFile=/var/log/zabbix/zabbix_agentd.log
#设置为被动模式，将开启端口
StartAgents=3
#当前的主机名，要写正确，否则服务端会不识别
Hostname=DEV-TEST
#服务端的地址，用逗号(,)可以隔开写多个
Server=192.168.1.100
#自定义的脚本超时时间，
Timeout=8
#允许自定义脚本
UnsafeUserParameters=1
#加载其它配置文件
Include=/etc/zabbix/zabbix_agentd.d/*.conf
3）配置为主动模式
需要修改配置文件和模板，将监控项改为主动模式。
1. 修改配置文件
#指定pid文件位置
PidFile=/var/run/zabbix/zabbix_agentd.pid
#指定日志文件位置
LogFile=/var/log/zabbix/zabbix_agentd.log
#设置为主动模式，将关闭被动模式，不监听端口
StartAgents=0
#当前的主机名，要写正确，否则服务端会不识别
Hostname=DEV-TEST
#服务端的地址，用逗号(,)可以隔开写多个
ServerActive=192.168.1.100
#自定义的脚本超时时间，
Timeout=8
#允许自定义脚本
UnsafeUserParameters=1
#加载其它配置文件
Include=/etc/zabbix/zabbix_agentd.d/*.conf
2. 在服务端网页上调整模板的监控项
配置 -> 模板 -> Template OS Linux -> 拉到最下面 -> 全克隆（防止修改失败，回滚）。
3. 找到复制的模板 -> 链接模板 -> 取消链接（一会批量修改监控项，需要先取消链接） -> 更新。
4. 点击监控项 -> 全选 -> 批量更新
5. 勾选类型 -> 将方式变为[客户端主动式]
6. 配置 -> 主机 -> 模板 -> 取消链接 -> 更换为新的模板 -> 更新
7. 到检测 -> 最新数据 -> 查看被模板的主机，是否有数据
综合配置：
这样主动和被动都开启，监控项根据情况进行设置。
#指定pid文件位置
PidFile=/var/run/zabbix/zabbix_agentd.pid
#指定日志文件位置
LogFile=/var/log/zabbix/zabbix_agentd.log
#设置为被动模式，将开启端口
StartAgents=3
#当前的主机名，要写正确，否则服务端会不识别
Hostname=web2
#服务端的地址，用逗号(,)可以隔开写多个
Server=10.10.10.137
#服务端的地址，用逗号(,)可以隔开写多个
ServerActive=10.10.10.137
#自定义的脚本超时时间，
Timeout=8
#允许自定义脚本
UnsafeUserParameters=1
#加载其它配置文件
Include=/etc/zabbix/zabbix_agentd.d/*.conf
15、zabbix_get安装和使用
1. 安装
rpm -ivh http://repo.zabbix.com/zabbix/3.2/rhel/7/x86_64/zabbix-release-3.2-1.el7.noarch.rpm
yum install zabbix-get.x86_64
2. 使用
zabbix_get -s 127.0.0.1 -p 10050 -k "system.cpu.load[all,avg1]"
-s 客户端的IP
-p 客户端端口，默认10050
-k 监控项的key
五、Zabbix API
zabbix的api可以查看API中文手册，API的参数等等一直都是变化不大，5.0版本的zabbix用3.4的API也可以直接使用。
调用的时候用requests来往zabbix的api的url里传入json字符串，在正常使用前先传入账号密码用user.login参数来登陆zabbix，成功后会返回一个token的值（可以print来看看），后续的操作直接填入这个token的变量即可。
1、认证基本函数
#/use/bin/python3
import json, requests
#zabbix服务器的IP地址
zabbix_ip = "172.16.1.1"
#zabbix的用户名
zabbix_user = "Admin"
#zabbix的密码
zabbix_pass = "zabbix"
#zabbix api接口地址
url = "http://" + zabbix_ip + ":8000/api_jsonrpc.php"
#zabbix api定义的访问头部信息
post_header = {'Content-Type': 'application/json'}
#调用zabbix api需要身份令牌auth
def get_auth():
post_data = {
"jsonrpc": "2.0",
"method": "user.login",
"params": {
"user": zabbix_user,
"password": zabbix_pass
},
"id": "1"
}
ret = requests.post(url, data=json.dumps(post_data), headers=post_header)
zabbix_ret = json.loads(ret.text)
if 'result' not in zabbix_ret:
print('login error')
else:
return zabbix_ret.get('result')
#传入zabbix上主机的ip地址，返回主机的id号
def get_hostid(host_ip):
values = {
"jsonrpc": "2.0",
"method": "host.get", #指定方法
"params": { #参数列表
"output": "extend", #返回默认信息，这里可以加别的参数指定返回
"filter": { #根据ip查询
"host": [host_ip]
}
},
"auth": auth, #token
"id": 2, #id号随意写数字
}
#用post提交json字段，然后解析成字典输出
zabbix_req = requests.post(url, data=json.dumps(values), headers=post_header)
zabbix_req = zabbix_req.json()
print(zabbix_req)
if __name__ == '__main__':
auth = get_auth() #先传入token字符串到这个变量，后续调用变量即可
get_hostid("172.16.1.2") #调用后续的比如查id，添加监控项
2、主机组操作
1. 创建主机组
def create_hosts():
values = {
"jsonrpc": "2.0",
"method": "hostgroup.create",
"params": {
"name": "test1_group" #传入主机组名
},
"auth": auth,
"id": 1
}
#成功返回{'jsonrpc': '2.0', 'result': {'groupids': ['16']}, 'id': 1}
#重复返回{'jsonrpc': '2.0', 'error': {'code': -32602, 'message': 'Invalid params.', 'data': 'Host group "test1_group" already exists.'}, 'id': 1}
2. 根据主机组名查询主机组id号
def get_groupid():
values = {
"jsonrpc": "2.0",
"method": "hostgroup.get",
"params": {
"output": "extend",
"filter": {
"name": [
"test1_group", #传入主机组名
]
}
},
"auth": auth,
"id": 1
}
#成功返回{'jsonrpc': '2.0', 'result': [{'groupid': '5', 'name': 'test1_group', 'internal': '1', 'flags': '0'}], 'id': 1}
#查询不存在主机组名返回{'jsonrpc': '2.0', 'result': [], 'id': 1}
3. 查询所有主机组id号
def get_groupallid():
values = {
"jsonrpc": "2.0",
"method": "hostgroup.get",
"params": {
"output": "extend"
},
"auth": auth,
"id": 1
}
#成功返回{'jsonrpc': '2.0', 'result': [{'groupid': '1', 'name': 'test1_group', 'internal': '0', 'flags': '0'}, {'groupid': '2', 'name': 'Linux servers', 'internal': '0', 'flags': '0'}}
4. 删除主机组
def del_group():
values = {
"jsonrpc": "2.0",
"method": "hostgroup.delete",
"params": ["17"], #删除多个可以传入列表
"auth": auth,
"id": 1
}
#成功返回{'jsonrpc': '2.0', 'result': {'groupids': ['17']}, 'id': 1}
#删除组不存在返回{'jsonrpc': '2.0', 'error': {'code': -32500, 'message': 'Application error.', 'data': 'No permissions to referred object or it does not exist!'}, 'id': 1}
5. 修改主机组名
def rename_group():
values = {
"jsonrpc": "2.0",
"method": "hostgroup.update",
"params": {
"groupid": "17", #主机组id号
"name": "test2_group" #新名称
},
"auth":auth,
"id": 1
}
#成功返回{'jsonrpc': '2.0', 'result': {'groupids': ['17']}, 'id': 1}
6. 加主机组加入模板和主机
def add_host_group():
values = {
"jsonrpc": "2.0",
"method": "hostgroup.massadd",
"params": {
"groups": [
{
"groupid": "5" #主机组id，可以添加单个或多个
},
{
"groupid": "6"
}
],
"hosts": [
{
"hostid": "30050" #主机id
},
{
"hostid": "30001"
}
],
"templates": [
{
"templateid": "30050" #模板id，选填
},
{
"templateid": "30001"
}
]
},
"auth": auth,
"id": 1
}
7. 替换主机组中的所有主机
def update_host_group():
values = {
"jsonrpc": "2.0",
"method": "hostgroup.massupdate",
"params": {
"groups": [
{
"groupid": "6" #主机组id
}
],
"hosts": [
{
"hostid": "30050" #主机id
}
]
},
"auth": auth,
"id": 1
}
8. 替换主机组中的所有模板
def update_temp_group():
values = {
"jsonrpc": "2.0",
"method": "hostgroup.massupdate",
"params": {
"groups": [
{
"groupid": "6" #主机组id
}
],
"templates": [
{
"templateid": "30050" #模板id
}
]
},
"auth": auth,
"id": 1
}
9. 删除主机组中的主机
def del_host_group():
values = {
"jsonrpc": "2.0",
"method": "hostgroup.massremove",
"params": {
"groupids": [
"5" #主机组id
],
"hostids": [
"30050", #主机id
"30001"
]
},
"auth": auth,
"id": 1
}
10. 删除主机组中的模板
def del_temp_group():
values = {
"jsonrpc": "2.0",
"method": "hostgroup.massremove",
"params": {
"groups": [
{
"groupid": "6" #主机组id
}
],
"templates": [
{
"templateid": "30050" #模板id
}
]
},
"auth": auth,
"id": 1
}
11. 根据主机id获取组信息
def post_hostid_group():
values = {
"jsonrpc": "2.0",
"method": "hostgroup.get",
"params": {
"output": "extend",
'hostids':['10084','10264'] #主机id号
},
"auth": auth,
"id": 1
}
#成功返回[{"internal":"0","flags":"0","groupid":"19","name":"New Create Group"},{"internal":"0","flags":"0","groupid":"20","name":"New Group 02"}]
12. 只返回包含给定模板的主机组
def post_tempid_group():
values = {
"jsonrpc": "2.0",
"method": "hostgroup.get",
"params": {
"output": "extend",
'templateids':['10266'] #模板id号
},
"auth": auth,
"id": 1
}
#成功返回[{"internal":"0","flags":"0","groupid":"19","name":"New Create Group"},{"internal":"0","flags":"0","groupid":"20","name":"New Group 02"}]
13. 返回属于主机组的所有主机
def post_groupid_host():
values = {
"jsonrpc": "2.0",
"method": "hostgroup.get",
"params": {
"output": 'extend',
"filter": {
"groupid": '20' #主机组id
},
"selectHosts": [ #加这个获取interfaceid的值，用于主机后续操作
"name",
"hostid"
],
},
"auth": auth,
"id": 1
}
#成功返回[{"hosts":[{"hostid":"10084","name":"Zabbix server"},{"hostid":"10264","name":"zabbix_agent_1.1.1.3"}],"internal":"0","flags":"0","groupid":"20","name":"New Group 02"}]
14. 返回属于主机组的所有模板
def post_groupid_temp():
values = {
"jsonrpc": "2.0",
"method": "hostgroup.get",
"params": {
"output": 'extend',
"filter": {
"groupid": '19' #主机组id号
},
"selectTemplates": [ #获取interfaceid的值用于后续主机操作
"host",
"templateid"
],
},
"auth": auth,
"id": 1
}
#成功返回[{"templates":[{"host":"New Create Template","templateid":"10266"}],"internal":"0","flags":"0","groupid":"19","name":"New Create Group"}]
3、主机操作
1. 创建主机，并添加到”New Create Group”主机组中
def create_host():
values = {
"jsonrpc": "2.0",
"method": "host.create",
"params": {
"host": "test1", #主机名称
"interfaces": [ #为主机创建的接口
{
"type": 1,
"main": 1,
"useip": 1,
"ip": "172.16.1.2", #添加ip地址
"dns": "",
"port": "10050"
}
],
"groups": [ #加入到主机组，必须指定
{
"groupid": "17",
}
],
"templates": [ #链接到模板
{
"templateid": "20045"
}
],
"inventory_mode": 0, #主机资产清单属性：把MAC地址设置到主机资产清单里
"inventory": {
"macaddress_a": "01234",
"macaddress_b": "56768"
}
},
"auth": auth,
"id": 1
}
2. 获取主机id：根据主机名获取主机id
def get_hostid():
values = {
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": ['name','hostid'], #选择输出内容，列表形式
"filter": {
"host": ["会员中心-1",] #指定主机名称
}
},
"auth": auth,
"id": 1
}
3. 根据主机id删除主机
def del_host():
values = {
"jsonrpc": "2.0",
"method": "host.delete",
"params": ["2342"], #主机id号
"auth": auth,
"id": 1
}
4. 禁用/启用 主机
def update_host_status():
values = {
"jsonrpc": "2.0",
"method": "host.update",
"params": {
"hostid": '10264', #主机id号
"status": 0 #0启用，1禁用
},
"auth": auth,
"id": 1
}
5. 替换当前主机所属主机组
def update_host_group():
values = {
"jsonrpc": "2.0",
"method": "host.update",
"params": {
"hostid": '10264', #指定主机id号
"groups": ['19'] #加入主机组，可以列表写多个
},
"auth": auth,
"id": 1
}
6. 在指定主机中替换当前链接的模板: 以前模板的 监控项等不会删除
def update_host_temp():
values = {
"jsonrpc": "2.0",
"method": "host.update",
"params": {
"hostid": '10264', #主机id号
"templates": ['10266'] #模板id号
},
"auth": auth,
"id": 1
}
7. 在指定主机中删除指定模板链接并清除: 会清除这个模板的监控项等
def del_host_temp():
values = {
"jsonrpc": "2.0",
"method": "host.update",
"params": {
"hostid": '10264', #主机id
"templates_clear": ['10266'] #模板id
},
"auth": auth,
"id": 1
}
8. 主机组添加到指定的主机中（原有的组机组不变）
def add_group_host():
values = {
"jsonrpc": "2.0",
"method": "host.massadd",
"params": {
"hosts": [
{
"hostid": "10084" #主机id
},
{
"hostid": "10264"
}
],
"groups": [
{
"groupid": '20', #主机组id
},
]
},
"auth": auth,
"id": 1
}
9. 模板添加到指定的主机中
def add_temp_host():
values = {
"jsonrpc": "2.0",
"method": "template.massadd",
"params": {
"templates": [
{
"templateid": "123" #模板id
},
],
"hosts": [
{
"hostid": "2342" #主机id
}
]
},
"auth": auth,
"id": 1
}
10. 为指定主机创建的主机接口: 如果创建主机时已经创建了默认接口，就不能再创建默认接口了
def add_host():
values = {
"jsonrpc": "2.0",
"method": "host.massadd",
"params": {
"hosts": [
{
"hostid": "10264" #主机id
},
],
"interfaces": [
{
"type": 1, # 1 - agent; 2 - SNMP; 3 - IPMI; 4 - JMX. 接口类型
"main": 1, # 在主机上是否使用该接口作为默认值，一个主机仅能设置一个默认值（0不默认，1默认是）
"useip": 1, # 是否应该通过IP进行连接，0：使用dns连接，1：使用此主机接口的主机IP地址进行连接
"ip": "172.16.1.1", # 接口使用的IP地址，如果通过DNS进行连接，则可以为空。
"dns": "", # 接口使用的DNS名称，如果通过IP建立连接，可以为空。
"port": "10050" # 接口使用的端口号
}
]
},
"auth": auth,
"id": 1
}
11. 从指定的主机中移除主机组
def rm_group_host():
values = {
"jsonrpc": "2.0",
"method": "host.massremove",
"params": {
"hostids": ["69665", "69666"], #主机id
"groupids": "325" #主机组id
},
"auth": auth,
"id": 1
}
12. 删除指定主机中的模板
def rm_temp_hosts():
values = {
"jsonrpc": "2.0",
"method": "host.massremove",
"params": {
"hostids": ["69665", "69666"], #主机id
"templateids": "325" #模板id
},
"auth": auth,
"id": 1
}
13. 从指定的主机中移除主机接口
def rm_interfaces_host():
values = {
"jsonrpc": "2.0",
"method": "host.massremove",
"params": {
"hosts":["10264", ],
"interfaces": [
{
"type": 1, # 1 - agent; 2 - SNMP; 3 - IPMI; 4 - JMX. 接口类型
"main": 1, # 在主机上是否使用该接口作为默认值，一个主机仅能设置一个默认值（0不默认，1默认是）
"useip": 1, # 是否应该通过IP进行连接，0：使用dns连接，1：使用此主机接口的主机IP地址进行连接
"ip": "172.16.1.1", # 接口使用的IP地址，如果通过DNS进行连接，则可以为空。
"dns": "", # 接口使用的DNS名称，如果通过IP建立连接，可以为空。
"port": "10050" # 接口使用的端口号
}
]
},
"auth": auth,
"id": 1
}
14. 替换当前主机所属主机组
def update_group_host():
values = {
"jsonrpc": "2.0",
"method": "host.massupdate",
"params": {
"hosts": [
{
"hostid": "10084" #主机id
},
{
"hostid": "10264"
}
],
"groups": [
{
"groupid": '20', #主机组id
},
]
},
"auth": auth,
"id": 1
}
15. 仅仅是删除模板关联，模板中的应用集、监控项、触发器等还在主机中
def update_temp_host():
values = {
"jsonrpc": "2.0",
"method": "host.massupdate",
"params": {
"hosts": [
{
"hostid": "10084" #主机id
},
{
"hostid": "10264"
}
],
"templates": [
{
"templateid": '10050', #模板id
},
]
},
"auth": auth,
"id": 1
}
16. 删除模板关联关系，在指定主机中删除模板链接并清除（如：应用集、监控项）
def del_temp_host():
values = {
"jsonrpc": "2.0",
"method": "host.massupdate",
"params": {
"hosts": [
{
"hostid": "10084" #主机id
},
{
"hostid": "10264"
}
],
"templates_clear": [
{
"templateid": '10050', #模板id
},
]
},
"auth": auth,
"id": 1
}
17. 获取这个zabbix server监控的所有主机信息
def get_hostall():
values = {
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": [
"hostid",
"host"
],
"selectInterfaces": [
"interfaceid",
"ip"
]
},
"id": 2,
"auth": auth
}
18. 仅返回指定主机组所属的主机
def get_group_host():
values = {
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": [
"hostid",
"host"
],
'groupids':['19'] #主机组id
},
"id": 2,
"auth": auth
}
19. 仅返回含有指定应用集的主机
def get_app_host():
values = {
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": [
"hostid",
"host"
],
'applicationid':['1069'] #应用集id
},
"id": 2,
"auth": auth
}
20. 仅返回指定主机ID的主机
def get_host():
values = {
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": [
"hostid",
"host"
],
'hostids':['10264'] #主机id
},
"id": 2,
"auth": auth
}
21. 根据主机名/主机id 获取interfaceid
def get_interfaceid():
values = {
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": ['name','hostid',],
"filter": {
#"host": [hostname,], #根据主机名获取
'hostids':['10264'] #根据主机id获取
},
"selectInterfaces": [ #添加这个参数为了获取interfaceid的值
"interfaceid",
"ip"
],
},
"auth": auth,
"id": 1
}
22. 仅返回含有指定监控项的主机
def get_item_host():
values = {
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": ['name','hostid',],
"filter": {
'itemids':['10264'] #根据主机id获取
},
"selectInterfaces": [ # 添加这个参数为了获取interfaceid的值
"interfaceid",
"ip"
],
},
"auth": auth,
"id": 1
}
23. 仅返回与指定模板链接的主机
def get_temp_host():
values = {
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": ['name','hostid',],
"filter": {
'templateids':['10266'] #根据主机id获取
},
"selectInterfaces": [ # 添加这个参数为了获取interfaceid的值
"interfaceid",
"ip"
],
},
"auth": auth,
"id": 1
}
24. 查询”主机”时返回更多关联信息：主机组、模板、应用集、监控项、触发器、interfaceid
def get_info_host():
values = {
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": [
"hostid",
"host"
],
'hostids':['10264'],
"selectGroups": [ # 1.返回在groups属性中主机所属的主机组。
"name",
"groupid"
],
"selectParentTemplates": [ # 2.返回在parentTemplates属性中与主机关联的模板(主机关联的模板)
"host",
"templateid"
],
"selectApplications": [ # 3.返回在applications属性中来自主机的应用集。
"applicationid",
"name"
],
"selectItems": [ # 4.返回在items属性中主机里的监控项
"key",
"itemid",
"interfaceid",
],
"selectTriggers": [ # 5.返回在triggers属性中主机里的触发器
"description",
"triggerid",
],
"selectInterfaces": [ # 6.添加这个参数为了获取interfaceid的值
"interfaceid",
"ip"
],
},
"id": 2,
"auth": auth
}
4、模板
1. 新建模板：模板必须至少关联一个主机组
def create_temp():
values = {
"jsonrpc": "2.0",
"method": "template.create",
"params": {
"host": "test1_temp", #模板名
"groups": {
"groupid": gid, #模板关联的主机组(必须要有)
},
#"hosts": [{"hostid": "10084"},{"hostid": "10090"}] #模板关联的主机(可选)
},
"auth": auth,
"id": 1
}
2. 获取模板id：根据模板名称获取模板id
def get_tempid():
values = {
"jsonrpc": "2.0",
"method": "template.get",
"params": {
"output": ["host","templateid"],
"filter": {
"host": ["test1_temp",] #传入模板名
}
},
"auth": auth,
"id": 1
}
3. 根据模板id删除模板
def del_temp():
values = {
"jsonrpc": "2.0",
"method": "template.delete",
"params": ["23"],
"auth": auth,
"id": 1
}
4. 修改模板名称
def update_tempname():
values = {
"jsonrpc": "2.0",
"method": "template.update",
"params": {
"templateid": "23", #模板id
"name": "temp2_name" #新模板名
},
"auth": auth,
"id": 1
}
5. 给模板添加主机组
def add_temp_group():
values = {
"jsonrpc": "2.0",
"method": "template.massadd",
"params": {
"templates": [
{
"templateid": "10266" #模板id
}
],
"groups": [
{
"groupid": "20" #主机组id
}
]
},
"auth": auth,
"id": 1
}
6. 链接到给定模板的模板
def add_temp_temp():
values = {
"jsonrpc": "2.0",
"method": "template.massadd",
"params": {
"templates": [
{
"templateid": "10266" #模板id
}
],
"templates_link": [
{
"templateid": "10093" #要链接的模板id
}
]
},
"auth": auth,
"id": 1
}
7. 从模板中删除主机组
def rm_group_temp():
values = {
"jsonrpc": "2.0",
"method": "template.massremove",
"params": {
"templateids": ["10266"], #模板id
"groupids": "20" #主机组id
},
"auth": auth,
"id": 1
}
8. 将模板从指定主机中删除：但是模板中的 应用集、监控项等还在
def rm_host_temp():
values = {
"jsonrpc": "2.0",
"method": "template.massremove",
"params": {
"templateids": ["10266"], #模板id
"hostids": ["10264"] #主机id
},
"auth": auth,
"id": 1
}
9. 从给定的模板中取消链接和清除的模板: 删除了对应的应用集和监控项
def rm_temp_temp():
values = {
"jsonrpc": "2.0",
"method": "template.massremove",
"params": {
"templateids": ['10266'], #模板id
"templateids_clear": ['10093'], #要清理的连接模板id
},
"auth": auth,
"id": 1
}
10. 取消与给定模板链接的模板：不会删除已关联的应用集、监控项等
def rm_templ_temp():
values = {
"jsonrpc": "2.0",
"method": "template.massremove",
"params": {
"templateids": ['10266'], #模板id
"templateids_link": ['10093'], #要清理的连接模板id
},
"auth": auth,
"id": 1
}
11. 从给定的模板中取消链接并清除模板“10093”(删除已链接的 应用集、监控项等)
def update_templ_templates():
values = {
"jsonrpc": "2.0",
"method": "template.massupdate",
"params": {
"templates": [
{
"templateid": "10266" #模板id
},
],
"templates_clear": [
{
"templateid": "10093" #要清理的连接模板id
}
]
},
"auth": auth,
"id": 1
}
12. 主机组替换模板所属的当前主机组: 其他所有组机组都会取消关联
def update_group_temp():
values = {
"jsonrpc": "2.0",
"method": "template.massupdate",
"params": {
"templates": [
{
"templateid": "10266" #模板id
},
],
"groups": [
{
"groupid": "20" #主机组id
}
]
},
"auth": auth,
"id": 1
}
13. 去除这个模板链接的其他所有主机，只链接这一个主机
def update_host_temp():
values = {
"jsonrpc": "2.0",
"method": "template.massupdate",
"params": {
"templates": [
{
"templateid": "10266" #模板id
},
],
"hosts": [
{
"hostid": "10264" #主机id
}
]
},
"auth": auth,
"id": 1
}
14. 用于替换当前链接的模板的模板：链接的其他模板都会取消，但他们的应用集和监控项不会删除
def update_temp_temp():
values = {
"jsonrpc": "2.0",
"method": "template.massupdate",
"params": {
"templates": [
{
"templateid": "10266" #模板id
},
],
"templates_link": [
{
"templateid": "10094" #要链接的模板id
}
]
},
"auth": auth,
"id": 1
}
15. 根据模板名称检索获取信息
def get_temp():
values = {
"jsonrpc": "2.0",
"method": "template.get",
"params": {
"output": ['host', 'templateid'],
"filter": {
"host": ["New Create Template"] #模板名
}
},
"auth": auth,
"id": 1
}
16. 根据模板id检索
def get_tempid_tempinfo():
values = {
"jsonrpc": "2.0",
"method": "template.get",
"params": {
"output": ['host', 'templateid'],
"templateids": ['10266'] #模板id
},
"auth": auth,
"id": 1
}
17. 查看主机组所关联的模板
def get_group_temp(auth):
values = {
"jsonrpc": "2.0",
"method": "template.get",
"params": {
"output": ['host', 'templateid'],
"groupids": ['20'] #主机组名
},
"auth": auth,
"id": 1
}
18. 查看主机关联的模板
def get_host_temp():
values = {
"jsonrpc": "2.0",
"method": "template.get",
"params": {
"output": ['host', 'templateid'],
"hostids": ['10264'] #主机id
},
"auth": auth,
"id": 1
}
19. 只返回包含指定监控项的模板
def get_item_temp():
values = {
"jsonrpc": "2.0",
"method": "template.get",
"params": {
"output": ['host', 'templateid'],
"itemids": ['28284'] #监控项id
},
"auth": auth,
"id": 1
}
20. 只返回包含指定触发器的模板
def get_trigger_temp():
values = {
"jsonrpc": "2.0",
"method": "template.get",
"params": {
"output": ['host', 'templateid'],
"triggerids": ['15567'] #触发器id
},
"auth": auth,
"id": 1
}
21. 返回templates属性中更多属性：主机组、主机、子模板
def get_temp():
values = {
"jsonrpc": "2.0",
"method": "template.get",
"params": {
"output": ['host', 'templateid'],
"templateids": ['10266'],
"selectGroups": [ # 返回模板所属的主机组
"name",
"groupid"
],
"selectHosts": [ # 返回链接到模板的主机
"name",
"hostid"
],
"selectTemplates": [ # 返回templates属性中的子模板(那个模板链接了自己)
"host",
"templateid"
],
},
"auth": auth,
"id": 1
}
22. 查询时返回更多关联信息：主机组、主机、监控项、触发器、子模板、父模板
def get_more_tempinfo():
values = {
"jsonrpc": "2.0",
"method": "template.get",
"params": {
"output": ['host', 'templateid'],
"templateids": ['10266'],
"selectGroups": [ #1.返回模板所属的主机组
"name",
"groupid"
],
"selectHosts": [ #2.返回链接到模板的主机
"name",
"hostid"
],
"selectItems": [ #3.返回模板中的监控项.
"name",
"key",
"itemid",
"interfaceid",
],
"selectTriggers": [ #4.返回模板中的触发器
"description",
"triggerid",
],
"selectTemplates": [ #5.返回templates属性中的子模板(那个模板链接了自己)
"host",
"templateid"
],
"selectParentTemplates": [ # 6.返回templates属性中的父模板(自己链接了哪些模板)
"host",
"templateid"
],
},
"auth": auth,
"id": 1
}
23. 导出模板，需要将输出写到文件里
def export_temp():
values = {
"jsonrpc": "2.0",
"method": "configuration.export",
"params": {
"options": {
"templates": ["23"] #模板id
},
"format": "xml"
},
"auth": auth,
"id": 1
}
24. 导入模板
def import_temp():
values ={
"jsonrpc": "2.0",
"method": "configuration.import",
"params": {
"format": "xml",
"rules": {
"templates": {
"createMissing": True,
"updateExisting": True
},
"applications": {
"createMissing": True,
"deleteMissing": True
},
"items": {
"createMissing": True,
"updateExisting": True,
"deleteMissing": True
},
"triggers": {
"createMissing": True,
"updateExisting": True,
"deleteMissing": True
},
"groups": {
"createMissing": True,
},
"hosts": {
"createMissing": True,
"updateExisting": True
},
},
"source": "模板文件xml读取后的内容"
},
"auth": auth,
"id": 1
}
# 注：参数说明
# 1、createMissing：如果设置为true，没有就会创建新的
# 2、deleteMissing：如果设置为true，不在导入数据中的将会从数据库中被删除；
# 3、updateExisting：如何设置为true，已有的将会被更新；5、应用集
1. 创建应用集
def create_application():
values = {
"jsonrpc": "2.0",
"method": "application.create",
"params": {
"name": "test1_app", #应用名
"hostid": "232" #主机id
},
"auth": auth,
"id": 1
}
2. 获取指定主机所有应用集
def get_app():
values = {
"jsonrpc": "2.0",
"method": "application.get",
"params": {
"output": "extend",
"hostids": "232", #主机id
"sortfield": "name"
},
"auth": auth,
"id": 1
}
3. 根据应用集id进行删除
def del_app(au):
values = {
"jsonrpc": "2.0",
"method": "application.delete",
"params": ["232"], #应用集id
"auth": auth,
"id": 1
}
4. 修改应集名称
def update_appname():
values = {
"jsonrpc": "2.0",
"method": "application.update",
"params": {
"applicationid": "232", #应用集id
"name": "test2_app" #新应用集名称
},
"auth": auth,
"id": 1
}
5. 添加多个监控项到指定的应用集
def add_item_app():
values = {
"jsonrpc": "2.0",
"method": "application.massadd",
"params": {
"applications": [
{
"applicationid": "1118" #应用集id
},
],
"items": [
{
"itemid": "28439" #监控项id
},
]
},
"auth": auth,
"id": 1
}
6. 只返回指定ID的应用集
def get_app():
values = {
"jsonrpc": "2.0",
"method": "application.get",
"params": {
"output": "extend",
"applicationids": ['1118'], #应用集id
"sortfield": "name"
},
"auth": auth,
"id": 1
}
7. 只返回指定主机组所属主机的应用集
def get_group_app():
values = {
"jsonrpc": "2.0",
"method": "application.get",
"params": {
"output": "extend",
"groupids": ['19',], #主机组id
"sortfield": "name"
},
"auth": auth,
"id": 1
}
8. 只返回指定主机所属的应用集
def get_host_app():
values = {
"jsonrpc": "2.0",
"method": "application.get",
"params": {
"output": "extend",
"hostids": ['10264',], #主机id
"sortfield": "name"
},
"auth": auth,
"id": 1
}
9. 只返回指定模板的应用集
def get_temp_app():
values = {
"jsonrpc": "2.0",
"method": "application.get",
"params": {
"output": "extend",
"templateids": ['10266',], #模板id
"sortfield": "name"
},
"auth": auth,
"id": 1
}
10. 查询”应用集”时返回更多关联信息：主机、监控项
def get_appinfo():
values = {
"jsonrpc": "2.0",
"method": "application.get",
"params": {
"output": "extend",
"applicationids": ['1118'], #模板id
"sortfield": "name",
"selectHost": [ #1.返回链接到模板的主机
"name",
"hostid"
],
"selectItems": [ #2.返回模板中的监控项.
"name",
"key",
"itemid",
"interfaceid",
],
},
"auth": auth,
"id": 1
}6、监控项
1. 创建监控项
def create_item():
values = {
"jsonrpc": "2.0",
"method": "item.create",
"params": {
"name": "监控本机80端口", #监控项名称
"key_": "net.tcp.listen[80]", #键值
"hostid": "232", #主机id
"interfaceid": "72", #主机interfaceid
"applications": ["23"], #应用集id（可选）
"type": 0,
"value_type": 3,
"delay": "60s" #采集频率
},
"auth": auth,
"id": 1
}
2. 根据主机和键值key匹配监控项id
def get_item():
values = {
"jsonrpc": "2.0",
"method": "item.get",
"params": {
"output": ['key','itemid'],
"hostids": "23", #主机id
"search": {
"key": "net.tcp.listen[80]" #键值必须和agent的key值相同
},
"sortfield": "name"
},
"auth": auth,
"id": 1
}
3. 删除监控项：更具监控项id
def del_item():
values = {
"jsonrpc": "2.0",
"method": "item.delete",
"params": ["232"], #监控项id
"auth": auth,
"id": 1
}
4. 禁用/启用指定监控项
def update_item():
values = {
"jsonrpc": "2.0",
"method": "item.update",
"params": {
"itemid": "43", # 监控项id
"status": 0 #0禁用，1启用
},
"auth": auth,
"id": 1
}
5. 只返回具有给定ID的监控项
def get_item():
values = {
"jsonrpc": "2.0",
"method": "item.get",
"params": {
"output": ['key','itemid'],
"itemids": ['28284'], # 监控项id
},
"auth": auth,
"id": 1
}
6. 只返回属于给定组的监控项
def get_group_item():
values = {
"jsonrpc": "2.0",
"method": "item.get",
"params": {
"output": ['key','itemid'],
"groupids": ['19'], #主机组id
},
"auth": auth,
"id": 1
}
7. 仅返回属于给定模板的监控项
def get_temp_item():
values = {
"jsonrpc": "2.0",
"method": "item.get",
"params": {
"output": ['key','itemid'],
"templateids": ['10266'], #模板id
},
"auth": auth,
"id": 1
}
8. 仅返回属于给定主机的监控项
def get_host_item():
values = {
"jsonrpc": "2.0",
"method": "item.get",
"params": {
"output": ['key','itemid'],
"hostids": ['10264'], #主机id
},
"auth": auth,
"id": 1
}
9. 仅返回属于给定应用程序的监控项
def get_app_item():
values = {
"jsonrpc": "2.0",
"method": "item.get",
"params": {
"output": ['key','itemid'],
"applicationids": ['1118'], #应用集id
},
"auth": auth,
"id": 1
}
10. 仅返回在给定触发器中使用的监控项
def get_trigger_item():
values = {
"jsonrpc": "2.0",
"method": "item.get",
"params": {
"output": ['key','itemid'],
"triggerids": ['15601'], #触发器id
},
"auth": auth,
"id": 1
}
11. 仅返回属于具有主机组名称的监控项
def get_groupname_item():
values = {
"jsonrpc": "2.0",
"method": "item.get",
"params": {
"output": ['key','itemid'],
"group": 'New Create Group', #主机组名称
},
"auth": auth,
"id": 1
}
12. 仅返回属于具有主机名称的监控项
def get_hostname_item():
values = {
"jsonrpc": "2.0",
"method": "item.get",
"params": {
"output": ['key','itemid'],
"host": 'zabbixagent_1.1.1.3', #主机名
},
"auth": auth,
"id": 1
}
13. 仅返回属于具有应用集名称的监控项
def get_appname_item():
values = {
"jsonrpc": "2.0",
"method": "item.get",
"params": {
"output": ['key','itemid'],
"application": 'app02', #应用集名称
},
"auth": auth,
"id": 1
}
14. 查询”监控项”时返回更多关联信息：主机、应用程序、触发器
def get_iteminfo():
values = {
"jsonrpc": "2.0",
"method": "item.get",
"params": {
"output": ['key','itemid'],
"itemids": ['28284'],
"selectHosts": [ # 1.返回应用这个监控项的所有主机
"host",
"hostid",
],
"selectApplications": [ # 2.返回该项所属的应用程序
"name",
"applicationid",
],
"selectTriggers": [ # 3.返回这个监控项包含的触发器
"description",
"triggerid",
],
},
"auth": auth,
"id": 1
}7、触发器
1. 创建 一个/多个 触发器
def create_trigger():
values = {
"jsonrpc": "2.0",
"method": "trigger.create",
"params": {
"description": "机器的80端口", #触发器名称
"expression": "{172.16.1.2:net.tcp.listen[80].last()}=0", #最后的结果为0则报警
"priority": 4 #(0:未分类; 1:信息; 2:警告; 3:一般严重 ...)
},
"auth": auth,
"id": 4
}
2. 检索触发器：这里只返回指定主机所属的触发器信息多个以列表形式返回
def get_trigger():
values = {
"jsonrpc": "2.0",
"method": "trigger.get",
"params": {
"hostids": "23", #主机id
"output": "extend",
"selectFunctions": "extend"
},
"auth": auth,
"id": 1
}
3. ERER删除触发器
def del_trigger():
values = {
"jsonrpc": "2.0",
"method": "trigger.delete",
"params": ["43"], #触发器id
"auth": auth,
"id": 1
}
4. 禁用/开启触发器
def update_trigger(auth,triggerid):
values ={
"jsonrpc": "2.0",
"method": "trigger.update",
"params": {
"triggerid": "34", #触发器id
"status": 0 #0启用，1禁用
},
"auth": auth,
"id": 1
}
5. 只返回指定ID的触发器
def get_trigger():
values = {
"jsonrpc": "2.0",
"method": "trigger.get",
"params": {
"triggerids": ['15567'], #触发器id
"output": ['triggerid','expression','description',],
"selectFunctions": "extend", #显示functions这个字典中的内容
},
"auth": auth,
"id": 1
}
6. 根据过滤信息返回
def get_trigger():
values = {
"jsonrpc": "2.0",
"method": "trigger.get",
"params": {
"templateids": ['10266'], #模板id
#"groupids": ['19'], #主机组id
#"applicationids": ['1111'], #应用集id进行过滤
#"itemids": ['28439'], #监控项id
#"hostids": ['10264'], #主机id
#"group":'New Create Group', #根据主机组名
#"host":'zabbix_agent_1.1.1.3', #根据主机名
"output": ['triggerid','expression','description',],
},
"auth": auth,
"id": 1
}
7. 查询时返回更多关联信息：主机组、主机、监控项
def get_triggerinfo():
values = {
"jsonrpc": "2.0",
"method": "trigger.get",
"params": {
"triggerids": ['15567'], #触发器id
"output": ['triggerid','expression','description',],
"selectGroups": [ # 1.返回模板所属的主机组
"name",
"groupid"
],
"selectHosts": [ # 2.返回链接到模板的主机
"name",
"hostid"
],
"selectItems": [ # 3.返回模板中的监控项.
"name",
"key",
"itemid",
"interfaceid",
],
},
"auth": auth,
"id": 1
}8、监控信息
1. 获取所有触发器中报警信息，如果不报警则不会获取到
def trigger_get_alarm():
values = {
"jsonrpc": "2.0",
"method": "trigger.get",
"params": {
"output": [
"host",
"description",
"triggerid",
"eventid",
"templateids"
],
"selectGroups": [
"name"
],
"selectHosts": [
"name",
"host"
],
"selectItems": [
"name",
"lastvalue",
"units"
],
"filter": {
"value": 1
},
"monitored": 1,
"selectLastEvent": "extend",
"expandComment": 1,
"expandDescription": 1,
"sortfield": "priority",
"sortorder": "DESC",
"withLastEventUnacknowledged": 1
},
"auth": auth,
"id": 1
}
# 获取的报警信息如下
'''
[{
"description": "User_Login", # 这里是报警信息的具体内容
"items": [{
"itemid": "28439",
"units": "",
"lastvalue": "59",
"name": "login_user"
}],
"lastEvent": {
"eventid": "73",
"objectid": "15601",
"clock": "1528266869",
"object": "0",
"acknowledged": "0",
"value": "1",
"source": "0",
"ns": "387320307"
},
"triggerid": "15601",
"hosts": [{
"host": "zabbix_agent_1.1.1.3",
"hostid": "10264",
"name": "zabbix_agent_1.1.1.3"
}],
"groups": [{
"groupid": "19",
"name": "New Create Group"
}, {
"groupid": "20",
"name": "New Group 02"
}]
}]
'''
2. 只返回给定监控项的历史记录
def get_historys_item():
values = {
"jsonrpc": "2.0",
"method": "history.get",
"params": {
"output": "extend",
"history": 3, # 要返回的历史对象类型
# 0 - numeric float;数字浮点数；1 - character;字符 ；2 - log; 日志；3 - numeric unsigned; 数字符号；4 - text.文本
"itemids": ["28439"], #监控项id
"sortfield": "clock",
"sortorder": "DESC",
"limit": 2 #显示两条数据
},
"auth": auth,
"id": 1
}
#返回的数据
'''
[{
"itemid": "28439",
"ns": "244866385",
"value": "4",
"clock": "1528274369"
}, {
"itemid": "28439",
"ns": "197647992",
"value": "4",
"clock": "1528274339"
}]
'''
3. 只返回给定主机的历史记录
def get_historys_host():
values = {
"jsonrpc": "2.0",
"method": "history.get",
"params": {
"output": "extend",
"history": 3, # 要返回的历史对象类型
# 0 - numeric float;数字浮点数；1 - character;字符 ；2 - log; 日志；3 - numeric unsigned; 数字符号；4 - text.文本
"hostids": "10264", #主机id
"sortfield": "clock",
"sortorder": "DESC",
"limit": 2 # 显示两条数据
},
"auth": auth,
"id": 1
}
#返回的信息
'''
[{
"itemid": "28439",
"ns": "244866385",
"value": "4",
"clock": "1528274369"
}, {
"itemid": "28439",
"ns": "197647992",
"value": "4",
"clock": "1528274339"
}]
'''六、Zabbix使用案例
1、zabbix通过api监控阿里云RDS
监控阿里云的RDS可以写脚本去用mysql命令登陆获取，也可以用API获取（API还按次数收费，前100万次免费）。
主要用到DescribeMetricLast方法进行监控项数据查询
通过监控项链接，找到对应产品文档：
主要是填入这2个值，一个确定产品，一个确定监控项，再通过Dimensions参数查询指定实例的信息：
安装核心sdk和云监控、RDS的sdk：
pip3 install aliyun-python-sdk-core
pip3 install aliyun-python-sdk-cms
pip3 install aliyun-python-sdk-rds模板地址
1）脚本
1. 根据api获取rds的实例列表，生成json格式的内容
auto_rds.sh：
#!/usr/bin/python3
import json
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.acs_exception.exceptions import ClientException
from aliyunsdkcore.acs_exception.exceptions import ServerException
from aliyunsdkrds.request.v20140815.DescribeDBInstancesRequest import DescribeDBInstancesRequest
#秘钥
aliyun_user_ak = 'xxxxxxxxxxxxxxxxx'
aliyun_user_sk = 'xxxxxxxxxxxxxxxxxxxxxxxxx'
region_id = 'cn-beijing'
client = AcsClient(ak=aliyun_user_ak, secret=aliyun_user_sk, region_id=region_id, timeout=300)
rds_list = []
request = DescribeDBInstancesRequest()
request.set_accept_format('json')
request.set_InstanceNetworkType("VPC")
request.set_VpcId("vpc-2ze0w06g138ax9rh7aj2e")
response = client.do_action_with_exception(request)
rds_info = json.loads(response)
for i in range(len(rds_info["Items"]["DBInstance"])):
rds_id = rds_info["Items"]["DBInstance"][i]["DBInstanceId"]
rds_list += [{'{#RDSID}':rds_id}]
print(json.dumps({'data':rds_list},sort_keys=True,indent=4,separators=(',',':')))
2. 根据api传入RDS的id和键值来获取信息
测试：
./rds_info.py rm-2zem2w8dlem15e49s ConnectionUsage
rds_info.py：
#!/usr/bin/python3
import datetime, json, sys, ast
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.acs_exception.exceptions import ClientException
from aliyunsdkcore.acs_exception.exceptions import ServerException
from aliyunsdkcms.request.v20190101.DescribeMetricLastRequest import DescribeMetricLastRequest
#秘钥
aliyun_user_ak = 'xxxxxxxxxxxxxxxxxxxxxxx'
aliyun_user_sk = 'xxxxxxxxxxxxxxxxxxxxxxxxxxx'
region_id = 'cn-beijing'
client = AcsClient(ak=aliyun_user_ak, secret=aliyun_user_sk, region_id=region_id, timeout=300)
nowtime = datetime.datetime.now()
stmp_time = nowtime - datetime.timedelta(minutes=4)
etmp_time = nowtime - datetime.timedelta(minutes=3)
start_time = stmp_time.strftime('%Y-%m-%d %H:%M:%S') #开始时间
end_time = etmp_time.strftime('%Y-%m-%d %H:%M:%S') #结束时
request = DescribeMetricLastRequest()
request.set_accept_format('json')
request.set_MetricName(sys.argv[2])
request.set_Period("60")
request.set_StartTime(start_time)
request.set_EndTime(end_time)
request.set_Dimensions("[{\"instanceId\":%s}]" %(sys.argv[1]))
request.set_Namespace("acs_rds_dashboard")
response = client.do_action_with_exception(request)
item_info = json.loads(response)
item_str = item_info["Datapoints"]
item_str = item_str.lstrip('[') #字符串去掉两边[]
item_str = item_str.rstrip(']')
item_dict = json.loads(item_str)
#item_dict = ast.literal_eval(item_str)
if item_info["Code"] == "200":
print(item_dict["Average"])
else:
print(item_info)
2）zabbix配置
修改配置文件，添加脚本位置：
vim /etc/zabbix/zabbix_agentd.d/userparams.conf
#rds-api
UserParameter=auto_rds,/usr/bin/python3 /etc/zabbix/script/rdsapi/auto_rds.py
UserParameter=rds_info[*],/usr/bin/python3 /etc/zabbix/script/rdsapi/rds-info.py $1 $2
重启：
service zabbix-agent restart3）网页配置
1. 修改配置文件重启服务
vim /etc/zabbix/zabbix_agentd.d/userparams.conf
UserParameter=auto_rds,/usr/bin/python3 /etc/zabbix/script/rdsapi/auto_rds.py
UserParameter=rds_info[*],/usr/bin/python3 /etc/zabbix/script/rdsapi/rds-info.py $1 $2
2. 通过客户端命令来查看是否可以获取到值
zabbix_agentd -t rds_info[rm-2ze2g49593rz06j8s,CpuUsage]
3. 添加自动发现规则
4. 监控项原型，{#RDSID}是json里定义的，rds_info[{#RDSID},MySQL_IbufUseRatio]，类型浮点数。
5. 添加触发器
6. 将模板套用在有脚本在的那台机器上即可
2、批量添加监听端口
因为要监控每台机器启动的进程，机器太多又不想挨个手动加，所以有2种方式。可以采用自动发现进程脚本，然后lld方式批量加，但这样监控项只会写80端口监控，报警的时候也只会端口关闭。
使用第二种方式，根据客户端返回的信息，通过zabbix的api来批量添加端口监控就可以增加相关名称了。
可以用ansible下发agent脚本，然后开启服务端，再批量用ansible执行客户端脚本来达到批量操作。
1）服务端
需要python3，zabbix-net-server.py：
#!/usr/bin/python3
import socket, sys, time
import json
import requests
#当前master监听
host = "172.16.5.4"
port = 4312
#自定义监控项所在的应用集名称
zabbix_app = "netstat"
#禁止的监控的服务列表，比如sshd,master,ntpd
deny_server = ["sshd", "hblog", "zabbix_agentd", "master", "staragent-core", "DragoonAgent", "filebeat", "agent"]
deny_port = ["32000"]
#触发器告警级别，(0:未分类; 1:信息; 2:警告; 3:一般严重 ...)
trigger_pri = 4
#zabbix服务器的IP地址
zabbix_ip = "172.16.1.46"
#zabbix的用户名
zabbix_user = "Admin"
#zabbix的密码
zabbix_pass = "123456"
#zabbix api接口地址
url = "http://" + zabbix_ip + ":8000/api_jsonrpc.php"
#zabbix api定义的访问头部信息
post_header = {'Content-Type': 'application/json'}
#调用zabbix api需要身份令牌auth
def get_auth():
post_data = {
"jsonrpc": "2.0",
"method": "user.login",
"params": {
"user": zabbix_user,
"password": zabbix_pass
},
"id": "1"
}
ret = requests.post(url, data=json.dumps(post_data), headers=post_header)
zabbix_ret = json.loads(ret.text)
if 'result' not in zabbix_ret:
print('login error')
else:
return zabbix_ret.get('result')
#用于给api提交并提交
def post_info(values, id_name):
zabbix_req = requests.post(url, data=json.dumps(values), headers=post_header)
zabbix_req = zabbix_req.json()
try:
req_error = zabbix_req['error']['data'] #如果获取不到就说明成功了，则返回信息
except:
req_info = zabbix_req['result'][id_name]
return req_info
#以IP信息获取主机id
def get_hostid(auth, host_ip):
values = {
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": "extend",
"filter": {
"host": [host_ip]
}
},
"auth": auth,
"id": 2,
}
zabbix_req = requests.post(url, data=json.dumps(values), headers=post_header)
zabbix_req = zabbix_req.json()
zabbix_req = zabbix_req['result']
try:
host_id = zabbix_req[0]['hostid']
return host_id
except:
return 1
#根据主机id获取监控项，这块的条件没用，后面还是要写循环匹配
def get_interfaces(auth, host_id):
values = {
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": ['name','hostid',],
"filter": {
'hostids':[host_id] #根据主机id获取
},
"selectInterfaces": [ # 添加这个参数为了获取interfaceid的值
"interfaceid",
"ip"
],
},
"auth": auth,
"id": 1
}
zabbix_req = requests.post(url, data=json.dumps(values), headers=post_header)
zabbix_req = zabbix_req.json()
zabbix_req = zabbix_req['result']
for i in range(len(zabbix_req)):
if zabbix_req[i]['hostid'] == host_id:
return zabbix_req[i]['interfaces'][0]['interfaceid']
#根据主机id和interfaceid定位，传入端口号来添加监控端口，成功返回监控项id
def post_item(auth, host_id, host_interfaceid, server_name, host_port, app_id):
item_name = server_name + "的" + host_port + "端口-gd"
item_key = 'check_net[' + host_port + ']'
values = {
"jsonrpc": "2.0",
"method": "item.create",
"params": {
"name": item_name,
"key_": item_key,
"hostid": host_id,
"interfaceid": host_interfaceid,
"applications": [app_id],
"type": 0,
"value_type": 3,
"delay": "60s"
},
"auth": auth,
"id": 1
}
zabbix_req = requests.post(url, data=json.dumps(values), headers=post_header)
zabbix_req = zabbix_req.json()
print(zabbix_req)
return zabbix_req['result']['itemids'][0]
#根据主机ip来定位，传入端口号和服务名来添加触发器，成功返回触发器id
def post_trigger(auth, host_ip, server_name, host_port):
description = server_name + "的" + host_port + "端口关闭"
expression = '{' + host_ip + ':check_net[' + host_port + '].sum(#5)}=5'
values = {
"jsonrpc": "2.0",
"method": "trigger.create",
"params": {
"description": description,
"expression": expression,
"priority": trigger_pri
},
"auth": auth,
"id": 4
}
return post_info(values, 'triggerids')
#创建主机的应用集，成功返回应用集id
def post_app(auth, zabbix_app, host_id):
values = {
"jsonrpc": "2.0",
"method": "application.create",
"params": {
"name": zabbix_app,
"hostid": host_id
},
"auth": auth,
"id": 1
}
return post_info(values, 'applicationids')
#根据host_id返回应用集列表，
def get_appid(auth, zabbix_app, host_id):
values = {
"jsonrpc": "2.0",
"method": "application.get",
"params": {
"output": "extend",
"hostids": host_id,
"sortfield": "name"
},
"auth": auth,
"id": 1
}
zabbix_req = requests.post(url, data=json.dumps(values), headers=post_header)
zabbix_req = zabbix_req.json()
zabbix_req = zabbix_req['result']
for i in range(len(zabbix_req)):
if zabbix_req[i]['name'] == zabbix_app:
return zabbix_req[i]['applicationid']
#正式步骤
def post_all(host_ip, dict_info):
print(host_ip + "开始添加监控项和对应触发器，并加入到应用集" + zabbix_app)
#初始化链接，获得基本信息
auth = get_auth()
host_id = get_hostid(auth, host_ip)
host_interfaceid = get_interfaces(auth, host_id)
#先创建应用集，如果已经存在则从循环里找出id
app_id = post_app(auth, zabbix_app, host_id)
if app_id is None:
app_id = get_appid(auth, zabbix_app, host_id)
for k,v in dict_info.items():
if v[1] in deny_server:
continue
else:
if v[0] in deny_port:
continue
else:
item_id = post_item(auth, host_id, host_interfaceid, v[1], v[0], app_id)
trigger_id = post_trigger(auth, host_ip, v[1], v[0])
print(str(item_id))
if item_id:
print("添加" + v[1] + "的" + v[0] + "端口监控完成")
else:
print("跳过" + v[1] + "的" + v[0] + "监控添加")
print(" ")
#持续监听端口，对客户端传入的数据进行监控项和触发器添加
def main(host, port):
serversocket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
serversocket.bind((host,port))
serversocket.listen(200) #最大连接数
while True:
print('服务器启动，监听客户端链接')
clientsocket,addr=serversocket.accept()
host_ip = addr[0]
data=clientsocket.recv(1024)
dict_info = eval(data.decode('utf-8')) #变成字典
post_all(host_ip, dict_info)
clientsocket.close()
serversocket.closel()
if __name__ == '__main__':
main(host, port)
2）客户端
需要python2和net-tools包，zabbix-net-agent.py：
#!/usr/bin/python
#coding=utf-8
#通过netstat -unltp命令收集监听端口，需要客户端安装net-tools
#发送的字典结构：{'pid号',['端口号', '进程名']}，pid号主要用于去重，因为一个进程可能监控多个端口
import json, commands, string
import socket, sys
#填写服务端地址和端口
host = "172.16.5.4"
port = 4312
#常用端口列表，防止临时端口
eternal_port = ["80", "8080", "8005"]
#返回当前机器 {'pid号',['端口号', '进程名']}
def get_port():
prostr = commands.getstatusoutput('netstat -unltp')
prostr = str(prostr)
prolist = prostr.split('\\n') #用两个\才行
del prolist[0]
del prolist[0]
prolist = prolist[::-1]
port_list = {}
lock_pid = [] #用于锁定pid
for info in prolist:
port_info = info.split()
if len(port_info) >= 7:
tmp_port = port_info[3].split(':')
tmp_port = tmp_port.pop()
tmp_info = port_info[6].split('/')
tmp_pid = tmp_info[0]
try:
tmp_name = tmp_info[1]
except:
continue
if tmp_pid in lock_pid: #如果端口是常用端口组里，就跳过这个，只监控常用端口
continue
if tmp_port in eternal_port: #如果在表里就把pid锁定了，加入到锁定数组里
lock_pid = lock_pid + [tmp_pid]
port_list[tmp_pid] = [tmp_port, tmp_name]
return port_list
#向master程序提交信息
def post_port(host, port):
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
host=host
port=port
s.connect((host,port))
data = get_port()
data = str(data)
s.send(data.encode('utf-8'))
s.close()
if __name__ == "__main__":
# post_port(host, port)
print(get_port())
3）检测脚本
check_net.py：
#!/usr/bin/python
#coding=utf-8
import json, commands, sys
#返回当前机器 {'pid号',['端口号', '进程名']}
def get_port(port):
prostr = commands.getstatusoutput('netstat -unltp')
prostr = str(prostr)
prolist = prostr.split('\\n') #用两个\才行
del prolist[0]
del prolist[0]
port_list = []
for info in prolist:
port_info = info.split()
if len(port_info) >= 7:
tmp_port = port_info[3].split(':')
tmp_port = tmp_port.pop()
port_list = port_list + [tmp_port]
if port in port_list:
print("0")
else:
print("1")
if __name__ == "__main__":
get_port(sys.argv[1])
4）清理脚本
如果添加后不想要了或者觉得有点问题，可以使用清理脚本批量清理掉。脚本根据Ip.txt逐行读取ip地址，查询这台机器拥有的id号，根据匹配[端口]结尾的监控项名字进行删除。
clear_item.py：
#!/usr/bin/python3
import json, re, requests
#zabbix服务器的IP地址
zabbix_ip = "1.1.1.1"
#zabbix的用户名
zabbix_user = "Admin"
#zabbix的密码
zabbix_pass = "zabbix"
#zabbix api接口地址
url = "http://" + zabbix_ip + ":8000/api_jsonrpc.php"
#zabbix api定义的访问头部信息
post_header = {'Content-Type': 'application/json'}
#调用zabbix api需要身份令牌auth
def get_auth():
post_data = {
"jsonrpc": "2.0",
"method": "user.login",
"params": {
"user": zabbix_user,
"password": zabbix_pass
},
"id": "1"
}
ret = requests.post(url, data=json.dumps(post_data), headers=post_header)
zabbix_ret = json.loads(ret.text)
if 'result' not in zabbix_ret:
print('login error')
else:
return zabbix_ret.get('result')
#用于给api提交并提交
def post_info(values, id_name):
zabbix_req = requests.post(url, data=json.dumps(values), headers=post_header)
zabbix_req = zabbix_req.json()
try:
req_error = zabbix_req['error']['data'] #如果获取不到就说明成功了，则返回信息
except:
req_info = zabbix_req['result'][id_name]
return req_info
#以IP信息获取主机id
def get_hostid(auth, host_ip):
values = {
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": "extend",
"filter": {
"host": [host_ip]
}
},
"auth": auth,
"id": 2,
}
zabbix_req = requests.post(url, data=json.dumps(values), headers=post_header)
zabbix_req = zabbix_req.json()
zabbix_req = zabbix_req['result']
try:
host_id = zabbix_req[0]['hostid']
return host_id
except:
return 1
def get_iteminfo(auth,host_id):
values = {
"jsonrpc": "2.0",
"method": "item.get",
"params": {
"output": ['name','key','itemid'],
"hostids": [host_id],
},
"auth": auth,
"id": 1
}
zabbix_req = requests.post(url, data=json.dumps(values), headers=post_header)
zabbix_req = zabbix_req.json()
zabbix_req = zabbix_req['result']
NameRe = re.compile('端口-gd$') #做匹配
for i in range(len(zabbix_req)):
if NameRe.search(zabbix_req[i]['name']):
print(del_item(auth, zabbix_req[i]['itemid']))
def del_item(auth, item_id):
values = {
"jsonrpc": "2.0",
"method": "item.delete",
"params": [item_id],
"auth": auth,
"id": 1
}
zabbix_req = requests.post(url, data=json.dumps(values), headers=post_header)
zabbix_req = zabbix_req.json()
return zabbix_req
if __name__ == '__main__':
for host_ip in open("ip.txt"):
host_ip = host_ip.strip()
auth = get_auth()
host_id = get_hostid(auth, host_ip)
get_iteminfo(auth, host_id)
3、zabbix聚合监控 整体使用率
通常用zabbix都是监控单台机器，但也有需求是查看整体的CPU、内存等使用率，来观测整体资源是否紧缺或者富裕。
1. 首先监控一台的cpu利用率
2. 获取到数据之后采用zabbix的汇总检查功能
3. 类型选择zabbix汇总，键值设置
grpavg[node101-170,system.cpu.util[0,user,avg5],last]就是101-170机器的整体cpu利用率 grpavg 平均值 grpmax 最大值 grpmin 最低值 grpsum 价值总和。
例子1，主机组“MySQL服务器”的总磁盘空间。
grpsum [“ MySQL服务器”，“ vfs.fs.size [/，total]”，last]例子2，主机组“MySQL服务器”的平均处理器负载。
grpavg [“ MySQL服务器”，“ system.cpu.load [，avg1]”，last]例子3，主机组“ MySQL服务器”每秒平均5分钟的查询数量。
grpavg [“ MySQL服务器”，mysql.qps，avg，5m]例子4，多个主机组中所有主机上的平均CPU负载。
grpavg [[“服务器A”，“服务器B”，“服务器C”]，system.cpu.load，last]4. 创建图形选择对应监控项
5. 就可以看到具体的数据了
6. 下面是内存使用率 也是先监控其中一台
7. 首先是总体内存
vm.memory.size[total] 
8. 然后是用可用内存 也就是剩余内存
vm.memory.size[available] 
9. 最后是用计算的方式获取百分比的值
100*(last(vm.memory.size[total])-last(vm.memory.size[available]))/last(vm.memory.size[total]) 
4、zabbix通过API监控RDS
阿里云的RDS自带的监控系统获取数据不怎么直观，想要通过API获取数据通过zabbix显示，因为网上资料缺乏和其他一些原因，获取API签名很困难，但使用阿里云的SDK可以完美避开获取签名的步骤。
阿里云SDK是什么？
SDK是阿里云为用户提供的开发工具，支持JAVA、PHP、C#等几种不同的语言，这里是用Python写的。在Python SDK里提供了一些模块，我们通过调用这些模块、传入一些必要的参数可以简单的实现数据的获取。
阿里云的sdk就是很多的库文件，这里我们只需要两个库文件，一个核心库sdk-core和rds库sdk-rds。
下载地址：GitHub - aliyun/aliyun-openapi-python-sdk: Alibaba Cloud SDK for Python
具体操作：
1. 进入sdk-rds所在的目录运行安装命令：
python setup.py install若出现这个，是setuptools工具没安装，下载安装就可以：
import setuptools
ImportError: No module named setuptools
wget http://pypi.python.org/packages/source/s/setuptools/setuptools-0.6c11.tar.gz
tar -xvf setuptools-0.6c11.tar.gz
cd setuptools-0.6c11
python setup.py build
python setup.py install
ls -l /usr/lib/python2.6/site-packages/setuptools-0.6c11-py2.6.egg2. 再次进入aliyun-python-sdk-rds目录，执行python setup.py install，同样进入aliyun-python-sdk-core，执行python setup.py install安装。
这时我们已经装好了阿里云sdk库环境
3. 在aliyun-python-sdk-rds/aliyunsdkrds/request/v20140815路径下有大量的sdk-rds api库文件，我们调用这里的库文件来查找其需要的参数的设置方法和发送请求。
调用阿里云的sdk分为三个步骤：
创建 AcsClient 实例并初始化；AcsClient即请求rds的实例，包括accesskeyid、accesskeysecret和regionid。
创建 API 请求并设置参数；这里的参数是除了公共参数之外所需要的所有参数，在阿里云文档上查看：查询空间使用信息-gt-lt-Long-云数据库 RDS-阿里云
发起请求并打印返回。
4. 举个例子：
我想查看rds实例的资源使用情况。查看阿里云文档得知，其请求参数有两个：Action ：DescribeResourceUsage和DBInstanceId：实例名。
我们进入aliyun-python-sdk-rds/aliyunsdkrds/request/v20140815下的DescribeResourceUsageRequest.py库查看DBInstanceId的设置方法为set_DBInstanceId。
于是我们创建请求并设置参数set_DBInstanceId：
request = DescribeResourceUsageRequest.DescribeResourceUsageRequest()
request.set_DBInstanceId('rm-bpXXXXXXXX')然后创建rds实例的AcsClient对象。
client = AcsClient(
AcesskeyID,
AcesskeySecret,
regionid)最后在通过do_action_with_exception发送请求：
client.do_action_with_exception(request)完整代码如下：
#!/usr/bin/python
#encoding=utf-8
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.acs_exception.exceptions import ClientException
from aliyunsdkcore.acs_exception.exceptions import ServerException
from aliyunsdkrds.request.v20140815 import DescribeResourceUsageRequest
AcesskeyID = 'XXXXXXXXXXXXX'
AcesskeySecret = 'XXXXXXXXXXXXXXXXXX'
regionid = ‘XXXXXXXXXXX’
client = AcsClient(
AcesskeySecret,
regionid)
request = DescribeResourceUsageRequest.DescribeResourceUsageRequest()
request.set_DBInstanceId('rm-bp1XXXXXXXXXXXXX')
response = client.do_action_with_exception(request)
print response
5、zabbix监控web页面
有时候需要对网页进行访问，来方式服务还在，但网页访问超时等问题。
环境：
zabbix-3.4yum包和编译参数：
libcurl-devel curl-devel
–with-libcurl1. 点开任意一个模板或者主机，有web场景这个选项
2. 客户端选择ie10，当然也可以是其它的
3. 选择步骤 -> 添加
4. URL就是访问的地址，也可以使用post提交参数，模拟登陆等等
5. 状态码为200则正常
6. 点击添加，添加上
7. 创建一个触发器，和普通触发器一样
8. 监控项选择如图所示的，当状态码不等于200时报警
过一会将nginx服务器关闭，可以看到报警提示。
6、zabbix监控日志文件
监控日志也是zabbix的一个很好的功能。像redis集群崩溃，会重组，但端口不会出问题，这就导致监控端口不会发现redis已经出现问题。
结构：
监控项筛选固定的内容进行记录，触发器对内容再次筛选或匹配，符合后进行告警。
环境：
zabbix-3.4.2。
1. 在客户端搭建一个httpd服务器
yum -y install httpd
systemctl start httpd2. 让zabbix客户端有权限查看，具体权限看情况设置
chmod -R 777 /var/log/httpd/3. 自定义一个监控项，基于主机的
#被动模式不行
类型：主动式
#log[文件位置，筛选内容]
键值：log[/var/log/httpd/access_log,/admin.html]
#日志格式
信息类型：日志
#y表示年，M表示月，d表示日，p和：表示占位符，h表示小时，m表示分钟，s表示秒。
日志时间格式：yyMMddphh:mm:ss
4. 浏览器访问1.1.1.1 — The free app that makes your Internet faster.
5. 检测 -> 最新数据 -> 异常访问admin
6. 触发器规则，我这里设置200报警，其实可以设置200正常，其它报警，规则可以再看看。
7. 访问1.1.1.1 — The free app that makes your Internet faster. ，过一会再访问1.1.1.1 — The free app that makes your Internet faster. ，看是否触发器会有提示。
8. 再访问正确地址，会发现报警取消了。
其它说明：
key：
首先要了解key
log[ file ,,,,, logrt：
logrt的file可以用正则表达式，防止日志切割。例如
access_*.log
logrt[ file ,,,,, 注意说明
- zabbix server和zabbix agent 会追踪日志文件的大小和最后修改时间，并且分别记录到字节计数器和最新时间计数器中
- agent会从上次读取日志的地方开始读取日志
- 字节计数器和最新时间计数器的数据会被记录在zabbix数据库，并且发送给agent，这样能够保证agent从上次停止的地方开始读取
- 当日志文件大小小于字节计数器的数字时，字节计数器会变成0，从头开始读取文件，用于日志切割
- 所有符合配置的文件，都会被监控
- 一个目录下的多个文件如果修改时间相同，会按照字母顺序来读取
- 到每个update interval的时间时，agent会检查一次目录下的文件
- zabbix-agent每秒发送的日志数据，有一个日志行数的上限，这是为了防止网络和cpu负载过高，这个数字是zabbix_agent.conf中的MaxLinesPerSecond。
- 发送的日志量最多是agent设置的buffer size的50%，就算只有日志类监控（即没有其它类型的item），也是只有50%。同时，由于有maxlines，故需要将zabbix_agent.conf中的BufferSize设置为maxlines的2倍
- 当anget没有log类型的监控的时候，所有BufferSize都会为其它类型item服务。如果这时新建了日志文件类型的监控，会将BufferSize中最老的50%数据清空给日志文件item使用。
- 在logrt中，正在表达式只对文件名有效，对文件目录无效。
7、zabbix监控redis集群状态
监控项填写：
redis.cluster触发器填写：
{B2C-SERVICE01:redis.cluster.last()}=1应用：
应用于集群的创建服务器上。
注意：
因为这个ruby集群脚本需要调用ruby这个命令，ruby这个命令如果是环境变量的，需要用ln -s 将环境变量做个链接到/usr/bin/ruby。
因为服务端取值是不加载环境变量的。
1. 脚本
vim redis_cluster.sh#!/bin/bash
#redis集群状态监控
/ops/server/redis/src/redis-trib.rb check 127.0.0.1:7000 | grep "All 16384 slots covered" &> /dev/null
[[ $? -eq 0 ]] && echo 0 || echo 1
2. 配置文件
vim redis_cluster.conf
UserParameter=redis.cluster,/etc/zabbix/script/redis_cluster.sh
8、zabbix监控mysql主从状态
主要监控主从的状态、同步延迟补数，如果发生主从断开将会报警，这会非常有用。
模板下载
注意：
如果mysql是源码安装，而且是环境变量的mysql命令，需要将脚本里mysql写成绝对路径。
1. 创建获取脚本
vim mysql-slave.sh
#!/bin/bash
#监控mysql从状态脚本
commnd() {
/usr/local/mysql/bin/mysql -uroot -p'123456' -e "show slave status\G;" 2>/dev/null | grep -w $1 | awk -F': ' '{print $2}'
}
if [[ $1 == "Slave_IO_Running" ]];then
a=`commnd Slave_IO_Running`
[[ "$a" == "Yes" ]] && echo 0 || echo 1
elif [[ $1 == "Slave_SQL_Running" ]];then
a=`commnd Slave_SQL_Running`
[[ "$a" == "Yes" ]] && echo 0 || echo 1
elif [[ $1 == "Seconds_Behind_Master" ]];then
a=`commnd Seconds_Behind_Master`
b=`cat /tmp/sbm.tmp`
if [[ $a -ge 600 ]] && [[ $b -ge 600 ]];then
echo $a
else
echo 0
fi
echo "$a" > /tmp/sbm.tmp
elif [[ $1 == "Last_Errno" ]];then
a=`commnd Last_Errno`
[[ $a -eq 0 ]] && echo 0 || echo 1
elif [[ $1 == "Skip_Counter" ]];then
a=`commnd Skip_Counter`
[[ $a -eq 0 ]] && echo 0 || echo 1
else
echo "Slave_IO_Running | Slave_SQL_Running | Seconds_Behind_Master | Last_Errno | Skip_Counter"
fi
2. 修改配置文件
vim slave_info.conf
UserParameter=slave_status[*],/etc/zabbix/script/mysql-slave.sh $1
3. 验证（zabbix_server端能取到值）
yum install zabbix_get -y
zabbix_get -s 10.0.0.52 -k slave_status[Slave_IO_Running]图形操作：
1. web界面创建监控项
2. web界面创建触发值
3. 依次创建监控项跟触发值
键值：
触发器：
为0则是正常的，Seconds_Behind_Master是延迟多少秒。超过600也就是10分钟会报警。
9、zabbix监控Centos网卡
zabbix默认模板没找到监控网卡的信息，这里的监控项是求出差值，每秒的流速。
zabbix-server 3.4.2版本。
监控项：
键值：net.if.in[网卡.bytes]
单位：bps
间隔：1s
添加2个动作，记录下一秒总量-上一秒总量，也就每秒的进出速率：
10、zabbix批量修改主机名
创建ips.txt：
主机名1 ip1
主机名2 ip2
主机名3 ip3
#!/usr/bin/python3
# _*_ coding:utf-8 _*_
import json
import requests
#zabbix服务器的IP地址
zabbix_ip = "127.0.0.1"
#zabbix的用户名
zabbix_user = "Admin"
#zabbix的密码
zabbix_pass = "123456"
#zabbix api接口地址
url = "http://" + zabbix_ip + ":8000/api_jsonrpc.php"
#zabbix api定义的访问头部信息
post_header = {'Content-Type': 'application/json'}
# 调用zabbix api需要身份令牌auth
def get_auth():
post_data = {
"jsonrpc": "2.0",
"method": "user.login",
"params": {
"user": zabbix_user,
"password": zabbix_pass
},
"id": "1"
}
ret = requests.post(url, data=json.dumps(post_data), headers=post_header)
zabbix_ret = json.loads(ret.text)
print(zabbix_ret)
if 'result' not in zabbix_ret:
print('login error')
else:
auth = zabbix_ret.get('result')
return auth
# 以IP信息获取主机id
def get_hostid():
hostid_get = {
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": "extend",
"filter": {
"host": [
host_ip
]
}
},
"auth": Token,
"id": 2,
}
res2 = requests.post(url, data=json.dumps(hostid_get), headers=post_header)
res3 = res2.json()
#print(res3)
res4 = res3['result']
try:
host_id = res4[0]['hostid']
return host_id
except:
print("zabbix中不存在，跳过")
return "不行"
# 以主机ID来修改主机名
def update_hostname():
hostname_update = {
"jsonrpc": "2.0",
"method": "host.update",
"params": {
"hostid": host_id,
"name": host_name
},
"auth": Token,
"id": 3
}
res10 = requests.post(url, data=json.dumps(hostname_update), headers=post_header)
res11 = res10.json()
#print(res11)
if __name__ == '__main__':
'''
ips.txt里的文件内容：
主机名1 ip1
主机名2 ip2
主机名3 ip3
'''
with open("ips.txt", "r", encoding="utf8") as f:
for line in f:
line = line.split(" ")
host_name = line[0]
host_ip = line[1].strip()
#print(host_name)
#print(host_ip)
Token = get_auth()
#print(Token)
host_id = get_hostid()
if host_id == "不行":
continue
#print(host_id)
update_hostname()
print(host_name,host_ip,"已添加完成")
11、zabbix监控zookeeper
模板下载
创建获取脚本：
yum-y install nc
vim zk_status.sh
echo mntr | nc 127.0.0.1 2181 | grep "$1" |awk '{print $2}'
修改配置文件：
vim zk_status.conf
UserParameter=zk_status[*],/etc/zabbix/script/zk_status.sh $112、zabbix自定义监控项和触发器
1）监控端口
触发器： 根据客户端的脚本获取值，当客户端的某项值达到要求后，将发出告警
监控项：根据客户端的脚本获取值，可设定采集值得间隔时间，将值保留记录下来，可形成曲线图
应用集：用来分类存放监控项，比如将监控80,8080等web服务的监控项放在WEB应用集中，将监控22，21等小服务的监控项放入SMALL应用集中。
模板：模板是一套定义好的监控项的合集，任何主机连接模板，则将模板中的监控项等等在主机上应用，但要修改这些监控项只能去模板中修改，并且修改后其他连接的主机也会跟着变动。
1. 创建模板，模板名称用来表示，这里监控端口，取名为Port，模板必须加入某群组，可单独创建群组来区分。
2. 创建应用集，应用集只用取名字即可
3. 创建监控项，名称用来区分监控的哪些值，可能是监控nginx的访问数量，也可能是mysql的读数量。
键值有2种，一种是点击选择使用系统自带值，另一种自定义脚本key。
这里选择net.tcp.listen[port]，通过telnet来查找某主机是否监听某端口，[port]填写需要监控的端口号。
4. 创建触发器，{HOST.NAME}将获取主机名，用作报警显示。表达式点击添加，或复制其他自带触发器的值进行修改。
连接监控项，这个就是刚刚创建的监控项，其余不动。
5. 选择相应群组，从群组里找到刚建立的监控项。
6. Port是模板名，如果这里选择写主机名或主机ip，则会变成单个主机的监控项，而不是模板的。
2）监控服务
脚本：执行脚本获得值。
配置文件：允许自定义key，将key的键值和脚本获取值关联起来。
服务端测试： 服务端发送指令给客户端，客户端运行脚本获取值再返回给服务端。
1. 创建脚本，用于获取值
cd /etc/zabbix/script
vim web_status.sh
#!/bin/bash
case $1 in
Lian)
netstat -anptu | grep 172.26.98.247:80 | wc -l ;;
Ping)
netstat -unltp | grep -w 80 &>/dev/null && echo 1 || echo 0 ;;
*)
echo "Lian | Ping" ;;
esac
测试脚本 ./web_status.sh Ping，看是否可以获得1。
2. 修改客户端配置文件，让他允许自定义key
vim /etc/zabbix/zabbix_agentd.conf
Include=/etc/zabbix/zabbix_agentd.conf.d/*.conf #加载其他配置文件
UnsafeUserParameters=1 #开启允许自定义 Key
systemctl restart zabbix-agent3. 修改配置文件，设定键值的名字和脚本所在位置，这样配置文件才能知道这个键值需要执行哪个脚本获得。
web.ping是自定义的键值名字，后面是脚本路径：
vim /etc/zabbix/zabbix_agentd.d/web_status.conf
UserParameter=web.ping,/etc/zabbix/script/web_status.sh Ping
UserParameter=web.lian,/etc/zabbix/script/web_status.sh Lian
如果执行的是命令要用绝对路径，如下也能获取值，并不一定要用脚本。
UserParameter=web.shu，/bin/netstat -anptu | wc -l
4. 检测，客户端测试
zabbix_agentd -t web.ping #返回1则正确服务端测试：
/ops/server/zabbix/bin/zabbix_get -s 192.168.1.1 -k web.ping #获得1则正确5. 出现：
(Not all processes could be identified, non-owned process info
will not be shown, you would have to be root to see it all.)是因为脚本中用netstat 这个命令，但是客户端使用zabbix这个用户启动脚本，没有权限用这个命令。
客户端执行：
chmod +x /bin/netstat即可。
网页操作：
键值是找不到的，手动写上，触发器的表达式也是连接这个监控项。
3）模板的导入和导出
导入：
导出：
选择模板拉倒最下面。
13、zabbix监控redis集群lld
自动发现模板需要2个脚本，模板下载
一个是自动发现脚本，可以是shell或者python等其他语言，脚本检测到端口号或其他信息，以json格式输出。
另一个是键值的脚本，可参考来自定义键值
模板通过自动使用自动发现脚本，获取到当前有哪些端口，再配合监控项来监控那些端口。以此达到套用模板后，自动监控当前的服务的作用。
客户端操作，添加或开启如下：
vim /etc/zabbix/zabbix_agentd.conf
Include=/etc/zabbix/zabbix_agentd.d/*.conf
Timeout=8
UnsafeUserParameters=1
修改配置文件后，重启：
systemctl restart zabbix-agent创建脚本：
1. 安装依赖，用nc和telnet获取信息
yum -y install nc telnet2. 客户端配置
当前用redis举例，其它都差不多。
编写自动发现脚本，可以py也可以shell：
cd /etc/zabbix/script
vim auto_found.sh
#!/bin/bash
redis() {
#获取端口并放到数组里
a=`netstat -unltp | grep redis | awk -F'[: /]+' '{print $5,$9}' | sort -n | uniq | awk '{print $1}'`
b=0
port=()
for i in `echo $a`
do
#因为redis集群会启动2个端口，比如7000，会启动17000端口，所以要去重，不然监控该重复了
echo $a | grep "1${i}" &> /dev/null
[ $? -eq 0 ] && port[$b]=$i && let b++
done
#以下为以JSON格式输出端口号
printf '{\n'
printf '\t"data":[\n'
for key in ${!port[@]}
do
if [[ "${#port[@]}" -gt 1 && "${key}" -ne "$((${#port[@]}-1))" ]];then
socket=`ps aux|grep ${port[${key}]}|grep -v grep|awk -F '=' '{print $10}'|cut -d ' ' -f 1`
printf '\t {\n'
printf "\t\t\t\"{#REDISPORT}\":\"${port[${key}]}\"},\n"
else [[ "${key}" -eq "((${#port[@]}-1))" ]]
socket=`ps aux|grep ${port[${key}]}|grep -v grep|awk -F '=' '{print $10}'|cut -d ' ' -f 1`
printf '\t {\n'
printf "\t\t\t\"{#REDISPORT}\":\"${port[${key}]}\"}\n"
fi
done
printf '\t ]\n'
printf '}\n'
}
$1
找到netstat 并且给权限：
which netstat | chmod +s执行，看是否是json格式的：
bash auto_found.sh redis修改配置：
添加配置文件，第一个auto_found键值是获取端口号，第二个redis_status是根据根据端口号访问redis获取info信息：
vim /etc/zabbix/zabbix_agentd.conf.d/redis_status.conf
UserParameter=auto_found[*],/bin/bash /etc/zabbix/script/auto_found.sh $1
UserParameter=redis_status[*],(/bin/echo info; sleep 1) | telnet 127.0.0.1 $1 2>&1 |grep $2|cut -d : -f2 | head -1
systemctl restart zabbix-agent测试：
看是否返回和脚本结构一样的端口：
zabbix_agentd -t auto_found[redis]7000是redis端口，后面是监控项：
zabbix_agentd -t redis_status[7000,used_cpu_sys]服务端测试：
也是看返回是否和客户端一样：
usr/local/zabbix/bin/zabbix_get -s 192.168.1.91 -k auto_found[redis]
usr/local/zabbix/bin/zabbix_get -s 192.168.1.91 -k redis_status[7000,used_cpu_sys]服务端网页操作（附件有配置好的模板）
1. 选择自动发现规则—创建发现规则
2. 名字都可以，键值为自动发现的键值，更新间隔是60秒发现一次
3. 再点击监控项原型–创建监控项，名称的 {#REDISPORT} 为自动发现脚本输出得值，键值为监控键值，端口部分也是一样的变量名
4. 选择后套用到主机上，到最新数据中，查看redis是否获得值，是否监控到多个端口
14、ssl证书到期时间
1）server端操作
找一个安装有agent 的server 进行一下操作
1. 安装所需组件
yum install bc gcc gcc-c++ openssl -y验证openssl：
[root@elk scripts]openssl version
OpenSSL 1.0.2k-fips 26 Jan 2017
2. 验证脚本
#赋予权限
[root@bac scripts] chmod +x check_ssl.sh
[root@elk scripts]./check_ssl.sh xxxx-xxxx.cn
565
#单位为天
3. zabbix 配置文件中添加配置
[root@elk scripts]cat /etc/zabbix/zabbix_agentd.conf |grep ssl
UserParameter=check.ssl[*],/etc/zabbix/scripts/check_ssl.sh $1
4. 重启zabbix agent
systemctl restart zabbix-agent2）web端操作
创建监控项：
1. 登录zabbix 创建新的监控项，名称随意填写
键值为你添加在配置文件中的 check.ssl[*] ***** 为你的域名。
更新间隔因为证书不需要做实时的检查 所以时间可以设置长一点。
2. 检查创建监控项是否生效
创建完成以后可以在检测—最新数据中查看监控项。
创建触发器：
1. 监控项有了接下来创建触发器
创建完毕 来测试下告警，把阈值调为600 天来测试下告警：
因为我们把更新间隔调的时间比较长 所以我们为了快速验证告警可以调小：
这个时候我们可以看到我们的告警信息。
到这SSL 证书监控告警已经完成。
3. 看到告警信息之后记得阈值调回来
3）脚本内容
#!/bin/sh
host=$1
end_date=`openssl s_client -servername $host -host $host -port 443 -showcerts /dev/null |
sed -n '/BEGIN CERTIFICATE/,/END CERT/p' |
openssl x509 -text 2>/dev/null |
sed -n 's/ *Not After : *//p'`
if [ -n $end_date ]
then
end_date_seconds=date '+%s' --date $end_date
now_seconds=date '+%s'
echo ($end_date_seconds-$now_seconds)/24/3600 | bc
fi
15、通过percona监控mysql
[zabbix-agent]
主机名 = host-1
系统 = centos-7.3
地址 = 1.1.1.1
软件 = percona-1.1.6percona是zabbix的一个模板，相比于自带的监控更加详细。
1）程序安装
yum依赖：
yum -y install php php-mysql安装插件：
yum -y install https://www.percona.com/downloads/percona-monitoring-plugins/1.1.6/percona-zabbix-templates-1.1.6-1.noarch.rpm脚本：
/var/lib/zabbix/percona/scripts
get_mysql_stats_wrapper.sh
ss_get_mysql_stats.php模板：
/var/lib/zabbix/percona/templates
userparameter_percona_mysql.conf
zabbix_agent_template_percona_mysql_server_ht_2.0.9-sver1.1.6.xml修改脚本php，账号密码：
vim /var/lib/zabbix/percona/scripts/ss_get_mysql_stats.php
如果监听本地的mysql则将localhost替换为127.0.0.1
vim /var/lib/zabbix/percona/scripts/get_mysql_stats_wrapper.sh
修改配置文件：
vim /usr/local/zabbix/etc/zabbix_agentd.conf
#加载其它配置
Include=/usr/local/zabbix/etc/zabbix_agentd.conf.d/*.conf
#开启允许自定义 Key
UnsafeUserParameters=1
复制配置文件到加载目录：
cp /var/lib/zabbix/percona/templates/userparameter_percona_mysql.conf /usr/local/zabbix/etc/zabbix_agentd.conf.d/重启zabbix客户端：
/etc/init.d/zabbix_agentd restart下载模板，自带的模板只支持zabbix-2版本，当前支持3：
wget http://jaminzhang.github.io/soft-conf/Zabbix/zbx_percona_mysql_template.xml导出模板，需要lrzsz安装包：
sz zbx_percona_mysql_template.xml2）图形配置
导入模板：
将刚刚下载的xml模板文件导入到服务器上：
点击导入，就会看见成功的字样了：
连接模板，需要点击添加后再更新：
查看数据，检测中-图形-选择主机-监控项：
16、使用自带模板监控mysql
1）客户端操作
1. 创建mysql用户获取信息（不要用root）
mysql -uroot -p
mysql>grant usage on *.* to zabbix@localhost identified by 'zabbix_password'2. 创建监控脚本key
vim /usr/local/zabbix/script/mysql_status.sh
#!/bin/bash
User='you_user'
Password='you_password'
Mysql='/usr/bin/mysql'
Mysqladmin='/usr/bin/mysqladmin'
command(){ #使用的sock登陆，如果没开启，那就删除socket这段
/usr/bin/mysql -u'zabbix' --socket=/ops/data/mysql/mysqld.sock -p'1qazxsw2!@' -e "show global status" 2>/dev/null | awk '$1 ~ /'"$1"'$/ {print $2}'
}
case $1 in
Com_select)
command $1 ;;
Com_insert)
command $1 ;;
Com_update)
command $1 ;;
Com_delete)
command $1 ;;
Com_begin)
command $1 ;;
Com_commit)
command $1 ;;
Com_rollback)
command $1 ;;
Questions)
command $1 ;;
Slow_queries)
command $1 ;;
Bytes_received)
command $1 ;;
Bytes_sent)
command $1 ;;
Uptime)
command $1 ;;
Version)
$Mysql -V | awk -F '[ ,]' '{print $6}' ;;
Ping)
$Mysqladmin -u'zabbix' --socket=/ops/data/mysql/mysqld.sock -p'1qazxsw2!@' ping 2>/dev/null |wc -l ;;
*)
echo "Usage: $0 { Com_select|Com_insert|Com_update|Com_delete|Com_begin|Com_commit|Com_rollback|Questions|Slow_queries|Bytes_received|Bytes_sent|Ping|Uptime|Version }" ;;
esac
3. 测试脚本返回
mysql_status.sh Uptimeping的返回1则是mysql在运行：
mysql_status.sh Ping4. 修改配置文件
vim /usr/local/zabbix/etc/zabbix_agentd.conf
Include=/usr/local/zabbix/etc/zabbix_agentd.conf.d/*.conf
UnsafeUserParameters=1 #开启允许自定义 Key
5. 重启客户端
/etc/init.d/zabbix_agentd restart6. 编写对应配置文件
vim /usr/local/zabbix/etc/zabbix_agentd.conf.d/mysql_status.conf
# Mysql_status
UserParameter=mysql.status[*],/usr/local/zabbix/script/mysql_status.sh $1
UserParameter=mysql.ping,/usr/local/zabbix/script/mysql_status.sh Ping
UserParameter=mysql.version,/usr/local/zabbix/script/mysql_status.sh Version
7. 测试，返回1正确
/usr/local/zabbix/sbin/zabbix_agentd -t mysql.ping对于ubuntu机器，测试后出现没数据：
zabbix_agent -t mysql.ping
mysql.ping [m|ZBX_NOTSUPPORTED] [Unsupported item key.]那就直接跳过这一步，到服务端测试看是否可以获取到值。
2）服务端配置
1. 测试连通，返回1则ok
/usr/local/zabbix/bin/zabbix_get -s 192.168.1.10 -k mysql.ping2. 效果
接下来把 Zabbix 自带的监控模板链接到主机即可。
过上一小会，就能看到效果了，version可能比较时间长点，因为模板里设的时间范围是3600秒，ping会误报一次Mysql Down，因为之前是没有值的。监控模板自带2张图，也可以自定义画图。
3）使用模板注意问题
zabbix有一个mysql监控的默认模板，但是其默认mysql账号验证信息在/var/lib/zabbix中，不正确，如果套用的话需要设置mysql。
1. 在zabbix-agent目录下/etc/zabbix/ 创建.my.cnf文件
vim /etc/zabbix/.my.cnf
[client]
user=zabbix
password=zabbix
2. 然后查看 userparameter_mysql.conf 文件，看到类似HOME=/var/lib/zabbix的路径设置，把路径全都替换为 /etc/zabbix/，使用下面的命令
sed -i 's|/var/lib/zabbix|/etc/zabbix|g' /etc/zabbix/zabbix_agentd.d/userparameter_mysql.conf3. 修改完之后检查一下，然后重启agent
systemctl restart zabbix-agent4. 在zabbix-server命令行测试下
zabbix_get -s 127.0.0.1 -p 10050 -k "mysql.status[Uptime]"七、Zabbix企业级实战
1、zabbix的allinone手工安装
ip dessgn：
#ip地址是10.163.1.103/24(具备internet访问的centos8)，采用最小化的安装，1G内存，1core的 cpuzabbix allinone安装：
[root@eveng-home ~]# ssh 10.163.1.103
[root@localhost ~]# hostnamectl set-hostname zabbix-allinone
[root@eveng-home ~]# ssh 10.163.1.103
[root@zabbix-allinone ~]#
#我们选择国内的清华大学开源镜像站，作为我们的zabbix软件仓库 https://mirrors.tuna.tsinghua.edu.cn/zabbix/zabbix/5.0/rhel/8/x86_64/清空旧的软件仓库：
[root@zabbix-allinone ~]# rm -rf /etc/yum.repos.d/*设置新的软件仓库：
#我们在CentOS8里面需要设置BaseOS，AppStream，epel，zabbix
#下面的这种命令如果在shell脚本里面就会以非交互式的方式创建指定内容的文件
[root@zabbix-allinone ~]# cat > /etc/yum.repos.d/repo.repo <zabbix-db的安装：
1.安装数据库
[root@zabbix-allinone ~]# yum -y install mariadb-server
2.启动数据库并设置下次开机启动
[root@zabbix-allinone ~]# systemctl enable mariadb --now
3.对数据库进行初始化设置（可选） 如果不做这个操作，你的数据库就是没有密码的，默认数据库会创建一个root的用户，而且这个root用户是 管理员且没有密码
[root@zabbix-allinone ~]# mysql_secure_installation
Enter current password for root (enter for none):
Set root password? [Y/n] y
New password: 123456
Re-enter new password: 123456
Remove anonymous users? [Y/n] y
Disallow root login remotely? [Y/n] n
Remove test database and access to it? [Y/n] y
Reload privilege tables now? [Y/n] y
4.测试连接
mysql是客户端命令，-u表示用户名，-p表示密码，-h表示数据库地址
[root@zabbix-allinone ~]# mysql -uroot -p123456 -hlocalhost
MariaDB [(none)]>
[root@zabbix-allinone ~]# mysql -uroot -p123456 -h10.163.1.103
MariaDB [(none)]>
5.创建一个zabbix的数据库并且设置一个专门的用户访问zabbix数据库的用户
[root@zabbix-allinone ~]# mysql -uroot -p123456
MariaDB [(none)]> create database zabbix character set utf8 collate utf8_bin;
MariaDB [(none)]> grant all privileges on zabbix.* to zabbix@'%' identified by 'zabbix'; MariaDB [(none)]> flush privileges;
MariaDB [(none)]> use zabbix;
MariaDB [zabbix]> show tables;
MariaDB [zabbix]> exit
6.安装zabbix-server-mysql软件，将该软件提供的zabbix数据库模板导入新建的zabbix数据库 因为该软件提供了zabbix数据库的模板，里面包含了以后的表
[root@zabbix-allinone ~]# yum -y install zabbix-server-mysql
下面的文件就是zabbix数据库里面的模板文件
[root@zabbix-allinone ~]# ls /usr/share/doc/zabbix-server-mysql/create.sql.gz
7.将模板文件导入数据库
[root@zabbix-allinone ~]# zcat /usr/share/doc/zabbix-server-mysql/create.sql.gz | mysql -uzabbix -pzabbix zabbix
#可以做个检查
[root@zabbix-allinone ~]# mysql -uzabbix -pzabbix -e "use zabbix;" -e "show tables;"zabbix-server部署：
1.安装软件
由于我们之前安装了zabbix-server-mysql软件，所以我们的zabbix-server已经不需要额外安装别的软 件了。
2.修改/etc/zabbix/zabbix_server.conf配置文件
[root@zabbix-allinone ~]# egrep -v '^#|^$' /etc/zabbix/zabbix_server.conf LogFile=/var/log/zabbix/zabbix_server.log
LogFileSize=0 PidFile=/var/run/zabbix/zabbix_server.pid SocketDir=/var/run/zabbix DBHost=10.163.1.103
DBName=zabbix DBUser=zabbix DBPassword=zabbix
SNMPTrapperFile=/var/log/snmptrap/snmptrap.log Timeout=4 AlertScriptsPath=/usr/lib/zabbix/alertscripts ExternalScripts=/usr/lib/zabbix/externalscripts LogSlowQueries=3000
StatsAllowedIP=127.0.0.1
3.检查启动服务之前数据库的连接数量
[root@zabbix-allinone ~]# netstat -tunp | grep 3306 | grep -i esta | wc -l 0
4.关闭防火墙和selinux
[root@zabbix-allinone ~]# sed -i 's/SELINUX=enforcing/SELINUX=permissive/'
/etc/selinux/config
[root@zabbix-allinone ~]# setenforce 0
[root@zabbix-allinone ~]# systemctl disable firewalld --now
5.启动zabbix-server服务
[root@zabbix-allinone ~]# systemctl enable zabbix-server --now
6.检查数据库的连接数量
[root@zabbix-allinone ~]# netstat -tunp | grep 3306 | grep -i esta | wc -l 50zabbix-web部署：
#我们选择lnmp的架构部署zabbix-web
1.软件安装
[root@zabbix-allinone ~]# yum -y install zabbix-web-mysql zabbix-nginx-conf
2.配置nginx的监听端口和监听地址
[root@zabbix-allinone ~]# rpm -qf /etc/nginx/conf.d/zabbix.conf zabbix-nginx-conf-5.0.3-1.el8.noarch
[root@zabbix-allinone ~]# sed -i 's/^#.*listen.*/ listen 80;/' /etc/nginx/conf.d/zabbix.conf
[root@zabbix-allinone ~]# sed -i 's/^#.*server_name.*/ server_name 10.163.1.103;/' /etc/nginx/conf.d/zabbix.conf
3.设置php的参数->时区
[root@zabbix-allinone ~]# rpm -qf /etc/php-fpm.d/zabbix.conf
zabbix-web-5.0.3-1.el8.noarch
[root@zabbix-allinone ~]# sed -i 's/; php_value\[date\.timezone\] = Europe\/Riga/php_value\[date\.timezone\] = Asia\/Shanghai/' /etc/php-fpm.d/zabbix.conf
4.启动nginx服务和php-fpm服务
[root@zabbix-allinone ~]# systemctl enable nginx php-fpm --now访问zabbix-web来配置zabbix-web连接zabbix-db和zabbix-server：
上面的操作生成了/etc/zabbix/web/zabbix.conf.php配置文件。
将语言改成中文：
由于没有中文包，所以我们需要安装一下中文包
[root@zabbix-allinone ~]# yum -y install langpacks-zh_CN
[root@zabbix-allinone ~]# yum -y install glibc-common
如果你已经安装过glibc-common，你重新安装即可
[root@zabbix-allinone ~]# yum -y reinstall glibc-common
查看日志：
[root@server zabbix]# ls /var/log/zabbix/zabbix_server.log
[root@db mariadb]# ls /var/log/mariadb/mariadb.log
[root@web ~]# ls /var/log/nginx/{access,error}.log
/var/log/nginx/access.log /var/log/nginx/error.log
[root@web ~]# ls /var/log/php-fpm/error.log- zabbix数据库的用户是否正确授权。
- 防火墙和selinux是否关闭。
- mariadb数据库是否启动了。
- zabbix_server.conf中管理mariadb的配置是否正确 DBHost DBName DBUser DBPassword
- 关于zabbix-web几乎没有报错，检查你的配置文件是否符合规范，别有特殊字符在里面。
- 如果你访问zabbix-web去设置zabbix-web对zabbix-server和zabbix-db的连接，确保你的客户端 和zabbix-web的ip可达。如果ip不能直接的通过3层可达，可以通过ssh动态端口转发实在socks5的代理， 访问zabbix-web。
2、Zabbix的组件分离手工安装
ip design：
zabbix-server:10.163.1.103
zabbix-db:10.163.1.102
zabbix-web:10.163.1.117zabbix组件分离安装：
基础配置：
[root@eveng-home ~]# ssh 10.163.1.103
[root@localhost ~]# hostnamectl set-hostname server
[root@localhost ~]# exit
[root@eveng-home ~]# ssh 10.163.1.103
[root@server ~]#
[root@server ~]# sed -i 's/SELINUX=enforcing/SELINUX=permissive/' /etc/selinux/config [root@server ~]# setenforce 0
[root@server ~]# systemctl disable firewalld --now
[root@eveng-home ~]# ssh 10.163.1.102
[root@localhost ~]# hostnamectl set-hostname db
[root@localhost ~]# exit
[root@eveng-home ~]# ssh 10.163.1.102
[root@db ~]#
[root@db ~]# sed -i 's/SELINUX=enforcing/SELINUX=permissive/'
/etc/selinux/config
[root@db ~]# setenforce 0
[root@db ~]# systemctl disable firewalld --now
[root@eveng-home ~]# ssh 10.163.1.117
[root@localhost ~]# hostnamectl set-hostname web
[root@localhost ~]# exit
[root@eveng-home ~]# ssh 10.163.1.117
[root@web ~]#
[root@web ~]# sed -i 's/SELINUX=enforcing/SELINUX=permissive/'
/etc/selinux/config
[root@web ~]# setenforce 0
[root@web ~]# systemctl disable firewalld --now清空旧的软件仓库：
[root@server ~]# rm -rf /etc/yum.repos.d/*
[root@db ~]# rm -rf /etc/yum.repos.d/*
[root@web ~]# rm -rf /etc/yum.repos.d/*设置新的软件仓库：
[root@server ~]# cat > /etc/yum.repos.d/repo.repo < /etc/yum.repos.d/repo.repo < /etc/yum.repos.d/repo.repo < zabbix-db的安装：
[root@db ~]# yum -y install mariadb-server zabbix-server-mysql
[root@db ~]# systemctl enable mariadb --now
[root@db ~]# mysql -e "create database zabbix character set utf8 collate utf8_bin;" [root@db ~]# mysql -e "grant all privileges on zabbix.* to zabbix@'%' identified by 'zabbix';"
[root@db ~]# mysql -e "flush privileges;"
[root@db ~]# zcat /usr/share/doc/zabbix-server-mysql/create.sql.gz | mysql - uzabbix -pzabbix zabbix
[root@db ~]# mysql -uzabbix -pzabbix -e "use zabbix;" -e "show tables;"zabbix-server的安装：
[root@server ~]# yum -y install zabbix-server-mysql
[root@server ~]# sed -i 's/^# DBHost.*/DBHost=10.163.1.102/'
/etc/zabbix/zabbix_server.conf
[root@server ~]# sed -i 's/^# DBPassword.*/DBPassword=zabbix/' /etc/zabbix/zabbix_server.conf
[root@server ~]# systemctl enable zabbix-server --nowzabbix-web的安装：
[root@web ~]# yum -y install zabbix-web-mysql zabbix-nginx-conf
[root@web ~]# sed -i 's/^#.*listen.*/ listen 80;/' /etc/nginx/conf.d/zabbix.conf
[root@web ~]# sed -i 's/^#.*server_name.*/ server_name 10.163.1.117;/' /etc/nginx/conf.d/zabbix.conf
[root@web ~]# sed -i 's/; php_value\[date\.timezone\] = Europe\/Riga/php_value\ [date\.timezone\] = Asia\/Shanghai/' /etc/php-fpm.d/zabbix.conf
[root@web ~]# systemctl enable nginx php-fpm --now访问zabbix-web：
设置中文：
如果是组件分离的安装方式，那么应该在zabbix-web上安装中文。
[root@web ~]# yum -y install langpacks-zh_CN glibc-common3、shell脚本实现zabbix自动化安装
shell脚本需求和流程：
shell脚本实现zabbix自动化安装，我们需要安装zabbix-db，zabbix-server，zabbix-web，不同的
zabbix组件，所需的安装的软件包不同，修改的配置文件不同，组件所在的节点ip不同，节点的主机名不同。
shell脚本流程：
1. 节点的基础配置 主机名，ip地址，地址掩码，网关，dns，软件仓库
2. 软件安装
zabbix-db需要安装mariadb数据库，zabbix-server-mysql
zabbix-server需要安装zabbix-server-mysql
zabbix-web需要安装zabbix-web-mysql，zabbix-nginx-conf
3. 配置文件修改
zabbix-db需要导入zabbix的数据库
zabbix-server需要配置zabbix-db的连接
zabbix-web需要修改nginx和php
4. 启动服务
zabbix-db需要启动mariadb服务
zabbix-server需要启动zabbix-server服务
zabbix-web需要启动nginx和php-fpm服务
写shell脚本规范：
为了保证脚本的可扩展性，我们尽量的将配置写成函数的形式，且要对脚本的每一步操作做检查，如果可能的 话，尽量在脚本中提供带颜色的输出，相当于日志，尽可能的在脚本中加上备注，以防止后期别人看这个脚本 或者你自己看这个脚本没有障碍。
shell脚本的运行位置：
尽量选择一个额外的节点的来对我们的组件进行部署，这样能保证我们在任何场景如果想快速的进行一个 zabbix监控平台的部署提供便捷性。在我们的实验中，我们选择eveng作为我们的脚本运行节点。
写shell脚本：
#!/bin/bash
#保证你的安装节点要有sshpass
#---------------------------此处之后不可修改-----------------------------------------
function line()
{
echo -e "\033[33m#######$1######\033[0m\033[34m庚老师课程主页https://edu.51cto.com/sd/62cbf\033[0m\033[33m######$1#######\033[0m"
}
function check()
{
if [ $? == 0 ]
then
echo -e "\033[32m${1}======>success\033[0m"
else
echo -e "\033[31m${1}=====>fail\033[0m"
fi
}
//节点的远程连接和基础配置函数
//要实现三个节点的免密登陆，我们的三个节点的ip分别是10.163.1.103,10.163.1.102,10.163.1.117
function basic()
{
line zabbix节点基础配置
#设置免密登陆
sshpass -p1 ssh-copy-id root@$server_ip &>>/dev/null
check "设置zabbix-server的免密登陆"
sshpass -p1 ssh-copy-id root@$db_ip &>>/dev/null
check "设置zabbix-db的免密登陆"
sshpass -p1 ssh-copy-id root@$web_ip &>>/dev/null
check "设置zabbix-web的免密登陆"
#设置软件仓库,我们是centos8上部署zabbix，所以我们只使用yum的仓库配置
ssh root@$server_ip rm -rf /etc/yum.repos.d/* &>>/dev/null
check "清空zabbix-server的软件仓库"
ssh root@$db_ip rm -rf /etc/yum.repos.d/* &>>/dev/null
check "清空zabbix-db的软件仓库"
ssh root@$web_ip rm -rf /etc/yum.repos.d/* &>>/dev/null
check "清空zabbix-web的软件仓库"
cat > .repo.repo <>/dev/null
check "设置zabbix-server"的软件仓库
scp .repo.repo root@$db_ip:/etc/yum.repos.d/repo.repo &>>/dev/null
check "设置zabbix-db"的软件仓库
scp .repo.repo root@$web_ip:/etc/yum.repos.d/repo.repo &>>/dev/null
check "设置zabbix-web"的软件仓库
#关闭防火墙和selinux
ssh root@$server_ip "sed -i 's/SELINUX=enforcing/SELINUX=permissive/' /etc/selinux/config && setenforce 0" &>>/dev/null
check "关闭zabbix-server的selinux"
ssh root@$server_ip systemctl disable firewalld --now &>>/dev/null
check "关闭zabbix-server的防火墙"
ssh root@$db_ip "sed -i 's/SELINUX=enforcing/SELINUX=permissive/' /etc/selinux/config && setenforce 0" &>>/dev/null
check "关闭zabbix-db的selinux"
ssh root@$db_ip systemctl disable firewalld --now &>>/dev/null
check "关闭zabbix-db的防火墙"
ssh root@$web_ip "sed -i 's/SELINUX=enforcing/SELINUX=permissive/' /etc/selinux/config && setenforce 0" &>>/dev/null
check "关闭zabbix-web的selinux"
ssh root@$web_ip systemctl disable firewalld --now &>>/dev/null
check "关闭zabbix-web的防火墙"
}
//zabbix db的安装函数
function zabbix_db()
{
line zabbix-db部署
ssh root@$db_ip yum -y install mariadb-server zabbix-server-mysql &>>/dev/null
check "zabbix-db软件包安装"
ssh root@$db_ip systemctl enable mariadb --now &>>/dev/null
check "启动zabbix-db数据库"
ssh root@$db_ip 'mysql -e "drop database zabbix;"' &>>/dev/null
check "清除旧的zabbix-db数据库"
ssh root@$db_ip 'mysql -e "create database zabbix character set utf8 collate utf8_bin;"' &>>/dev/null
check "创建zabbix数据库"
ssh root@$db_ip "mysql -e \"grant all privileges on zabbix.* to zabbix@'%' identified by 'zabbix';\"" &>>/dev/null
check "为zabbix用户设置对zabbix数据库的权限"
ssh root@$db_ip 'mysql -e "flush privileges;"' &>>/dev/null
check "刷新数据库权限"
ssh root@$db_ip 'zcat /usr/share/doc/zabbix-server-mysql/create.sql.gz | mysql -uzabbix -pzabbix zabbix' &>>/dev/null
check "zabbix-db的数据库导入"
}
//zabbix server的安装函数
function zabbix_server()
{
sshserver="ssh root@$server_ip"
line zabbix-server部署
$sshserver yum -y install zabbix-server-mysql &>>/dev/null
check "zabbix-server软件包安装"
$sshserver "sed -i 's/^# DBHost.*/DBHost=$db_ip/' /etc/zabbix/zabbix_server.conf" &>>/dev/null
check "修改/etc/zabbix/zabbix_server.conf配置文件指定zabbix-db地址"
$sshserver "sed -i 's/^# DBPassword.*/DBPassword=zabbix/' /etc/zabbix/zabbix_server.conf" &>>/dev/null
check "修改/etc/zabbix/zabbix_server.conf配置文件指定zabbix-db的数据库密码"
$sshserver systemctl enable zabbix-server --now &>>/dev/null
check "启动zabbix-server服务"
}
//zabbix web的安装函数
function zabbix_web()
{
line zabbix-web部署
sshserver="ssh root@$web_ip"
$sshserver yum -y install zabbix-web-mysql zabbix-nginx-conf &>>/dev/null
check "zabbix-web软件包安装"
$sshserver "sed -i 's/^#.*listen.*/ listen 80;/' /etc/nginx/conf.d/zabbix.conf" &>>/dev/null
check "修改zabbix-web的nginx配置文件的监听端口"
$sshserver "sed -i 's/^#.*server_name.*/ server_name $web_ip;/' /etc/nginx/conf.d/zabbix.conf" &>>/dev/null
check "修改zabbix-web的nginx配置文件的地址"
$sshserver "sed -i 's/; php_value\[date\.timezone\] = Europe\/Riga/php_value\[date\.timezone\] = Asia\/Shanghai/' /etc/php-fpm.d/zabbix.conf" &>>/dev/null
check "修改zabbix-web的php配置文件指定时区为亚洲上海"
scp .zabbix.conf.php root@$web_ip:/etc/zabbix/web/zabbix.conf.php &>>/dev/null
check "拷贝zabbix-web配置的模板文件"
$sshserver systemctl enable nginx php-fpm --now &>>/dev/null
check "启动zabbix-web服务"
}
//zabbix web连接数据库和zabbix server设置的模板函数
function zabbix_template()
{
cat zabbix.conf.php.template | sed "s/db-ip/$db_ip/" | sed "s/server-ip/$server_ip/" > .zabbix.conf.php
}
zabbix.conf.php.template：
安装节点的变量：
zabbix-var.sh：
#!/bin/bash
server_ip=10.163.1.104
db_ip=10.163.1.115
web_ip=10.163.1.116
server_pass=1
db_pass=1
web_pass=1
zabbix的安装脚本：
zabbix-install.sh：
#!/bin/bash
source zabbix-var.sh
source zabbix-fuc.sh
function main()
{
basic
zabbix_template
zabbix_db
zabbix_server
zabbix_web
}
main
4、zabbix的dashboard介绍
技术支持：
寻找一些免费的资源：
直接连到官方文档获取帮助：
最新的文档一般都是英文的，没有经过汉化的。
目前截止到2020年9月11号，稳定的中文汉化版本是4.0。
选择中文的官方文档：产品手册
用户设置界面：
用于语言的更改，web页面的刷新间隔，修改管理员密码，添加新的报警媒介。
用户查看的内容你就在检测里面看：
zabbix监控的资产：
报表信息：
配置界面（配置zabbix监控的最主要的操作界面）：
管理界面（管理员可以操作界面）：
5、在我们的zabbix监控平台添加监控节点
只以agent类型的节点举例。
1. 添加监控节点
由于我们采用的是组件分离安装，所有我们可以自己监控自己的三个分离节点。
配置->主机->创建主机
1. 主机名称代表zabbix-server监控主机的名称。
2. 群组表示添加的主机在哪个组里面，如果你选择一个不存在的群组，那么zabbix将会自动建立这个群组。
3. interfaces表示通过哪个ip地址以及dns来监控主机，我们在这里面的interfaces只选择了agent的种 类，也是默认的种类。其实还可以选择snmp，或者jmx。默认就是agent的种类。如果在被监控主机指定了的 是agent的方式，那么agent的端口默认是10050。
4. 注意其他的保持默认，其它的，我没讲，你就保持默认，不要去随便操作，除非你知道你在干什么。
查看一下在添加主机时创建的主机组：
节点状态：
以同样的方法添加zabbix-db和zabbix-server：
5. 也可以直接创建一个主机组
6、为监控节点添加监控项
1. 在主机界面选择要添加监控项的主机进而添加监控项
1.名称表示监控项的名字，名字规范虽然不是必须遵守的，但是要尽量遵守，名字可以选择中文或者英文，你 牛X，你选韩文日文都行。但是监控项的名字必须一眼能看出来它监控的东西是什么。
2. 键值表示的就是监控的内容，监控的内容是以key:value的形式存储的。
system.cpu.load[all,avg1]，system.cpu.load表示的就是键，后面的[all,avg1]，表示的就是 system.cpu.load键读取的监控数据的内容。 我们这里面设置的监控的键，旧表示系统cpu，1分钟的平均负载。
3.主机接口就保持默认，由于我们是在监控节点的位置添加的监控项，所以这个监控项的主机接口默认也是创 建该主机的agent接口
4. 信息类型，由于我们选择的是cpu过去一分钟平均的负载，所以我们选择浮点类型的信息
5. 更新间隔就是获取监控数据的周期，单位有s，m，h，d，表示秒，分钟，小时，天。一般情况下，更新间 隔应该尽量的设置小，但是如果设置的太小，频繁的读取数据，会对zabbix-server和zabbix-db造成过多 的性能消耗。具体间隔时间应该设置的多小，取决该数据实时性的重要程度。
6. 其它的保持默认。
测试一下键值：
如果是正常的情况下，就会获取到该监控项的值，但是此时报错了，报错的信息非常明显，就是它无法连接 10.163.1.115的10050端口。
由于你设置的监控项没有获取到数据，所以在主机界面你可以看到zabbix的可用性是红色的标志，但凡有一 个监控项获得了数据，它都是绿色的。
我们将刚才添加的监控项应用到zabbix-server和zabbix-web：
过了一段时间之后，可以看到ZBX的可以用状态变红了， 这是预期之内的。
7、在被监控主机上配置zabbix-agent
1. 安装zabbix-agent
设置软件仓库：
由于我们之前已经zabbix-web，zabbix-server，zabbix-db上设置了软件仓库，所以我们就没有必要再 进行仓库设置了，但是如果是新的监控节点需要监控，那么我们就需要设置zabbix的仓库，再centos8上我 们要设置baseos，appstream，epel以及zabbix的仓库。如何设置软件仓库，参考前面！！
安装zabbix-agent：
[root@server ~]# yum -y install zabbix-agent
[root@db ~]# yum -y install zabbix-agent
[root@web ~]# yum -y install zabbix-agent2. 修改zabbix-agent的配置文件
我们要在zabbix-agent上修改配置文件，让我们的zabbix-agent允许zabbix-server获取数据。 zabbix server通过agent获取数据有两种模式，一种是agent端主动发送数据到server端，我们称之为 主动模式，agent端等待server提取数据，叫做被动模式，两种模式可以一起配置并不冲突。
zabbix-agent的配置文件位置在/etc/zabbix/zabbix_agentd.conf
[root@server ~]# egrep -v "^#|^$" /etc/zabbix/zabbix_agentd.conf PidFile=/var/run/zabbix/zabbix_agentd.pid
LogFile=/var/log/zabbix/zabbix_agentd.log
LogFileSize=0 Server=10.163.1.104
ServerActive=10.163.1.104
Hostname=Zabbix server
Include=/etc/zabbix/zabbix_agentd.d/*.conf
//Server=10.163.1.104表示允许哪个主机到我这里获取数据
//ServerActive=10.163.1.104表示主动像哪个主机发送数据3. zabbix-agent服务的重启
[root@server ~]# systemctl enable zabbix-agent.service --now
[root@server ~]# netstat -tunlp | grep agent
tcp 0 0 0.0.0.0:10050 0.0.0.0:* LISTEN
1865/zabbix_agentd tcp6 0 0 :::10050 :::* LISTEN
1865/zabbix_agentd4. 此时到zabbix-web上查看主机的监控可用性
5. 在zabbix-server上进行监控项数据测试，查看拉取的数据
如果你想看一下负载的变化，你可以手工提高cpu的使用率
[root@server ~]# cat /dev/zero >> /dev/null &
[1] 1899
[root@server ~]# w
10:50:42 up 2:31, 1 user, load average: 0.08, 0.02, 0.01
USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
root pts/0 10.163.1.200 08:30 0.00s 7.60s 0.00s w
[root@server ~]# w
10:50:45 up 2:31, 1 user, load average: 0.23, 0.05, 0.02
USER TTY FROM LOGIN@ IDLE JCPU PCPU WHAT
root pts/0 10.163.1.200 08:30 3.00s 10.85s 0.00s w
[root@server ~]#
关闭手工提高cpu负载的命令：
[root@server ~]# pkill cat
[root@server ~]#
[1]+ Terminated cat /dev/zero >> /dev/null
[root@server ~]# 6. 在其他的zabbix-server-group节点中安装zabbix-agent
#命令形式
yum -y install zabbix-agent
sed -i 's/^Server=.*/Server=10.163.1.104/' /etc/zabbix/zabbix_agentd.conf
sed -i 's/^ServerActive=.*/ServerActive=10.163.1.104/' /etc/zabbix/zabbix_agentd.conf systemctl enable zabbix-agent.service --now
[root@web ~]# egrep -v "^#|^$" /etc/zabbix/zabbix_agentd.conf PidFile=/var/run/zabbix/zabbix_agentd.pid
LogFile=/var/log/zabbix/zabbix_agentd.log
LogFileSize=0 Server=10.163.1.104
ServerActive=10.163.1.104
Hostname=Zabbix server
Include=/etc/zabbix/zabbix_agentd.d/*.conf
[root@db ~]# egrep -v "^#|^$" /etc/zabbix/zabbix_agentd.conf PidFile=/var/run/zabbix/zabbix_agentd.pid
LogFile=/var/log/zabbix/zabbix_agentd.log
LogFileSize=0 Server=10.163.1.104
ServerActive=10.163.1.104 Hostname=Zabbix server Include=/etc/zabbix/zabbix_agentd.d/*.conf [root@db ~]# netstat -tunlp | grep -i agent
tcp 0 0 0.0.0.0:10050 0.0.0.0:* LISTEN
2042/zabbix_agentd tcp6 0 0 :::10050 :::* LISTEN
2042/zabbix_agentd
[root@web ~]# netstat -tunlp | grep -i agent
tcp 0 0 0.0.0.0:10050 0.0.0.0:* LISTEN
2227/zabbix_agentd tcp6 0 0 :::10050 :::* LISTEN
2227/zabbix_agentd
#可以自己写脚本
8、设置监控的图形
1. 设置监控图形
监控图形的数据来源取决于监控项，如果你没有监控项，那么你就没有数据来源，没有数据来源，没法绘图。由于我们之前已经设置了一个监控项，所以有了数据来源，所以我们才可以添加监控图形。
2. 我们可以把设置的监控图形丢到zabbix的dashboard overview
3. 由于我们之前添加的图形，出现了乱码的问题，所以我们需要修复这个问题
出现乱码的原因是因为php字体的问题，默认的php字体对中文支持差，所以我们可以修改字体。
1. 通过windows获取字体
复制，粘贴你的指定目录位置
2. 通过scp或者某些工具，拷贝到zabbix-web上
[root@web ~]# ls
anaconda-ks.cfg msyhbd.ttc3. 字体替换
[root@web ~]# ls /usr/share/zabbix/assets/fonts/
graphfont.ttf
[root@web ~]# mv msyhbd.ttc /usr/share/zabbix/assets/fonts/
[root@web ~]# cd /usr/share/zabbix/assets/fonts/
[root@web fonts]# mv graphfont.ttf graphfont.ttf.bak
[root@web fonts]# mv msyhbd.ttc graphfont.ttf
实际上你也可以不修改名字，更改配置文件也是可以的。
[root@web fonts]# ls /usr/share/zabbix/include/defines.inc.php /usr/share/zabbix/include/defines.inc.php
如果要修改配置文件，就不要带后缀名
4. 此时再次查看图形
将这个图形应用到其他的监控节点并且加入到dashboardoverview：
9、设置监控项的触发器
触发器（triggers），对监控项设置一个触发器，用我们通俗一点的叫法就叫做设置阈值。什么叫触发器 呢？所谓触发器就是当监控项监控到的数据到达某个值，触发的那个机器（触发的那个点）。
设置触发器是非常痛苦的一件事，不说触发器本身的复杂度，仅仅是不同场景触发器的设置也是不同的。针对 不同的业务，不同的服务器种类，不同的网络环境，不同的硬件环境，你要设置的触发器也是不一样的。所以 说触发器的设置是绞尽脑汁的。
1. 创建触发器
{zabbix-db:system.cpu.load[all,avg1].last(#1,20)}>0.8
zabbix-db表示主机
system.cpu.load[all,avg1]表示键值
last(#1,20)表示last函数，最后的1个值，持续20s
>0.8表示last函数的取值如果大于0.8，那么触发器就生效.
2. 观察图形
由于我们设置图形的时候纵轴采用的是自动计算的模式，所以目前计算出来的纵轴最大值是0.4，我们可以更 改纵轴为固定值1。
3. 手工提升zabbix-db的cpu负载，然后观察触发器报警
[root@db ~]# cat /dev/zero >> /dev/null &
[root@db ~]# cat /dev/zero >> /dev/null &
[root@db ~]# cat /dev/zero >> /dev/null &
##如果你开启了前端报警，那么web界面就会出现报警
[root@db ~]# watch -n3 uptime
[root@db ~]# pkill cat
[root@db ~]#
[1] Terminated cat /dev/zero >> /dev/null
[2]- Terminated cat /dev/zero >> /dev/null
[3]+ Terminated cat /dev/zero >> /dev/null
我设置的报警是大于0.8，持续20s后报警。在14:59:19s超过了0.8，然后开始计时，持续20s后报警。
4. 当触发器检测到监控项的值变低之后，会自动解决问题
5. 将这个触发器应用到别的主机上
10、其他非前端报警媒介-邮件报警
1.zabbix-server访问internet测试
1. server必须要能访问internet，保证我们的server可以和外界的SMTP（简单邮件传输协议25端口）服 务器建立连接
2. 必须要具备一个能发送邮件的邮箱
3. 必须确定要给谁发送邮件（老板，运维人员，CTO，CIO）
internet连接（ok）：
[root@server ~]# ping -c 1 mail.qq.com
PING v6.mail.qq.com (163.177.89.191) 56(84) bytes of data.
64 bytes from 163.177.89.191 (163.177.89.191): icmp_seq=1 ttl=53 time=50.5 ms
--- v6.mail.qq.com ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms2. 获取网易邮箱的授权码
3. 配置linux成为一个邮件客户端
1.安装sendmail和mailx软件
[root@server ~]# yum -y install sendmail mailx
2.开启snedmail服务
[root@server ~]# systemctl enable sendmail --now
3.配置sendmail客户端配置文件
[root@server ~]# tail -5 /etc/mail.rc
set [email protected]
set smtp=smtp.163.com
set [email protected]
#password不是你登陆网易邮箱的密码，而是网易邮箱的授权码
set smtp-auth-password=GQFBPZLPEWQESECO
set smtp-auth=login[root@server ~]# echo "this is a first mail test" | mail -s 'zabbix server mail test'
[email protected]
在zabbix web上设置邮件报警媒介：
#消息类型格式
告警主机：{HOSTNAME1}
告警地址：{HOST.IP}
告警时间：{EVENT.DATE} {EVENT.TIME}
告警等级：{TRIGGER.SEVERITY}
告警信息：{TRIGGER.NAME}
告警项目：{TRIGGER.KEY1}
问题详情：{ITEM.NAME}->{ITEM.VAULE}
当前状态：{TRGGER.STATUS}->{ITEM.VAULE1}
事件ID：{EVENT.ID}测试邮件报警媒介：
配置用户关联报警媒介：
设置报警动作：
当有问题出现时，将问题通过所有报警媒介告知管理员（系统默认行为，只需要点一下开启）。
手动拉高CPU测试：
[root@db ~]# cat /dev/zero >> /dev/null &
[1] 2907
[root@db ~]# cat /dev/zero >> /dev/null &
[2] 2908
[root@db ~]# cat /dev/zero >> /dev/null &
[3] 2909
[root@db ~]# watch -n3 uptime
[root@db ~]# pkill cat
[root@db ~]#
[1] Terminated cat /dev/zero >> /dev/null
[2]- Terminated cat /dev/zero >> /dev/null
[3]+ Terminated cat /dev/zero >> /dev/null
报警成功，一段时间之后，我们关闭了cpu的拉高指令，问题自动解决。
11、其他非前端报警媒介-钉钉机器人报警
添加钉钉机器人：
记录下webhook的URL：
https://oapi.dingtalk.com/robot/send? access_token=6ecb8ada7de105c5eefda3b5f433c7e0f2b10036e3f93ae14a50d3b5e77db6da
[root@server ~]# cat dingding.py
#!/usr/bin/env python3
#coding:utf-8
#zabbix钉钉报警
import requests,json,sys,os,datetime
webhook="https://oapi.dingtalk.com/robot/send? access_token=7eed88470a86ab18ff90a1bd395673a706609142ef7940f1d3eab1de36c2e9b5"
#说明：这里改为自己创建的机器人的webhook的值
user=sys.argv[1]
text=sys.argv[3]
data={"msgtype": "text", "text": { "content": text },"at": { "atMobiles": [ user ],"isAtAll": False } }
headers = {'Content-Type': 'application/json'}
x=requests.post(url=webhook,data=json.dumps(data),headers=headers)
if os.path.exists("/usr/local/zabbix/log/dingding.log"):
f=open("/usr/local/zabbix/log/dingding.log","a+")
else:
f=open("/usr/local/zabbix/log/dingding.log","w+")
f.write("\n"+"--"*30)
if x.json()["errcode"] == 0:
f.write("\n"+str(datetime.datetime.now())+" "+str(user)+" "+"发送成功"+"\n"+str(text)) f.close()
else:
f.write("\n"+str(datetime.datetime.now()) + " " + str(user) + " " + "发送失败" + "\n" + str(text))
f.close()要将脚本放入指定位置：
[root@server ~]# egrep -v '^#|^$' /etc/zabbix/zabbix_server.conf LogFile=/var/log/zabbix/zabbix_server.log
LogFileSize=0
PidFile=/var/run/zabbix/zabbix_server.pid
SocketDir=/var/run/zabbix DBHost=10.163.1.115
DBName=zabbix DBUser=zabbix DBPassword=zabbix SNMPTrapperFile=/var/log/snmptrap/snmptrap.log
Timeout=4
AlertScriptsPath=/usr/lib/zabbix/alertscripts ExternalScripts=/usr/lib/zabbix/externalscripts
LogSlowQueries=3000 StatsAllowedIP=127.0.0.1
#下面路径记录了自定义报警媒介脚本的位置
AlertScriptsPath=/usr/lib/zabbix/alertscripts
#我们将脚本放入该路径
[root@server ~]# mv dingding.py /usr/lib/zabbix/alertscripts/
#注意该脚本要有执行权限
[root@server ~]# chmod +x /usr/lib/zabbix/alertscripts/dingding.py
告警主机：{HOSTNAME1}
告警地址：{HOST.IP}
告警时间：{EVENT.DATE} {EVENT.TIME}
告警等级：{TRIGGER.SEVERITY}
告警信息：{TRIGGER.NAME}
告警项目：{TRIGGER.KEY1}
问题详情：{ITEM.NAME}:{ITEM.VALUE}
当前状态：{TRIGGER.STATUS}:{ITEM.VALUE1}
事件ID：{EVENT.ID}钉钉机器人消息发送测试：
报错了，脚本执行的时候告诉我没有python3
[root@server ~]# yum -y install python3
[root@server ~]# mkdir /usr/local/zabbix/log/ -p
[root@server ~]# touch /usr/local/zabbix/log/dingding.log
[root@server ~]# chown zabbix:zabbix /usr/local/zabbix/log/dingding.log
添加报警媒介和用户的关联：
定义报警动作使用钉钉报警媒介：
手工拉起cpu负载测试：
[root@web ~]# cat /dev/zero >> /dev/null &
[1] 3558
[root@web ~]# cat /dev/zero >> /dev/null &
[2] 3559
[root@web ~]# cat /dev/zero >> /dev/null &
[3] 3560
[root@web ~]# watch -n3 uptime
[root@web ~]# pkill cat
[root@web ~]#
1] Terminated cat /dev/zero >> /dev/null
[2]- Terminated cat /dev/zero >> /dev/null
[3]+ Terminated cat /dev/zero >> /dev/null
根据自己的情况选择是否清除报警媒介。
12、其他非前端报警媒介-企业微信报警
在企业微信中创建企业应用（类似钉钉的群报警机器人）：
AgentId：1000002
Secret：-mpRrgww3yFzyVec-zjPtCMsaEsisZGYP1CzgS2uD9o获取企业的ID：
企业ID需要记录一下：
AgentId：1000002
Secret：-mpRrgww3yFzyVec-zjPtCMsaEsisZGYP1CzgS2uD9o
CorpId: ww49a6a056f0bc439e
下载企业微信APP，然后登陆：
[root@server zabbix]# cat weixin.py
#!/usr/bin/env python3
#-*- coding: utf-8 -*-
import requests
import sys
import os
import json
import logging
logging.basicConfig(level = logging.DEBUG, format = '%(asctime)s, %(filename)s, %(levelname)s, %(message)s',
datefmt = '%a, %d %b %Y %H:%M:%S',
filename = os.path.join('/tmp','weixin.log'),
filemode = 'a')
corpid='ww0dc54049e4606f87'
appsecret='bjPVTTzalJJ4MHJ7cAirsLqOGhq6278b-qp4V8CHZ0A'
agentid=1000002
#获取accesstoken
token_url='https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=' + corpid + '&corpsecret=' + appsecret
req=requests.get(token_url)
accesstoken=req.json()['access_token']
#发送消息
msgsend_url='https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=' + accesstoken
touser=sys.argv[1]
subject=sys.argv[2]
#toparty='3|4|5|6'
message=sys.argv[2] + "\n\n" +sys.argv[3]
params={ "touser": touser, # "toparty": toparty, "msgtype": "text", "agentid": agentid, "text": { "content": message },"safe":0 }
req=requests.post(msgsend_url, data=json.dumps(params)) logging.info('sendto:' + touser + ';;subject:' + subject + ';;message:' + message)将脚本创建在报警脚本目录下：
[root@server ~]# egrep -i ^alert /etc/zabbix/zabbix_server.conf AlertScriptsPath=/usr/lib/zabbix/alertscripts
[root@server ~]# mv weixin.py /usr/lib/zabbix/alertscripts
[root@server ~]# chmod +x /usr/lib/zabbix/alertscripts此微信报警脚本的问题：
1. 这个微信报警脚本创建了一个/tmp/weixin.log日志文件，这个日志文件如果你没有，他会帮你创建，但 是创建的日志的拥有人和所属组是root，但是实际上你用zabbix通过该报警脚本实现报警，是zabbix要将 日志信息写入到这个文件，就会导致权限问题。
2. 此微信报警脚本需要有python3的环境
为了解决上述问题，我们安装python3，并且手工创建/tmp/weixin.log日志文件并且设置日志文件的权限为zabbix：
[root@server ~]# yum -y install python3
[root@server ~]# touch /tmp/weixin.log
[root@server ~]# chown zabbix:zabbix /tmp/weixin.log
[root@server ~]# ls -l /tmp/weixin.log
-rw-r--r--. 1 zabbix zabbix 0 Sep 12 09:30 /tmp/weixin.log[root@server ~]# cd /usr/lib/zabbix/alertscripts
[root@server alertscripts]# ./weixin.py yyds 身体健康
Traceback (most recent call last):
File "./weixin.py", line 21, in
accesstoken=req.json()['access_token']
KeyError: 'access_token'
#报错的原因是因为我们没有修改脚本的agentid，secret，corpid 
在zabbix里面创建新的报警媒介：
在zabbix的报警媒介位置做一个测试：
将企业微信报警媒介和用户关联：
定义报警动作：
手动拉起cpu负载测试报警：
[root@db ~]# cat /dev/zero &>>/dev/null &
[1] 5831
[root@db ~]# cat /dev/zero &>>/dev/null &
[2] 5832
[root@db ~]# cat /dev/zero &>>/dev/null &
[3] 5833
[root@db ~]# pkill cat
[root@db ~]#
[1] Terminated cat /dev/zero &>> /dev/null
[2]- Terminated cat /dev/zero &>> /dev/null
[3]+ Terminated cat /dev/zero &>> /dev/null
[root@db ~]#
13、zabbix系统自带监控项详解
在agent端列出系统里面自带的监控项：
#列出所有
[root@db ~]# zabbix_agentd -p
#列出单个
[root@web ~]# zabbix_agentd -t agent.hostname
agent.hostname [s|Zabbix server]
#根据正则表达式列出网络相关的监控项
[root@web ~]# zabbix_agentd -p | egrep ^net
net.dns[,zabbix.com] [u|1]
net.dns.record[,zabbix.com] [t|zabbix.com SOA
ines.ns.cloudflare.com dns.cloudflare.com 2034822398 10000 2400 604800 3600] net.tcp.dns[,zabbix.com] [u|1]
net.tcp.dns.query[,zabbix.com] [t|zabbix.com SOA ines.ns.cloudflare.com dns.cloudflare.com 2034822398 10000 2400 604800 3600]
net.tcp.port[,80] [u|1]
net.tcp.listen[80] [u|1]
net.udp.listen[68] [u|1]
net.if.in[lo,bytes] [u|55914]
net.if.out[lo,bytes] [u|55914]
net.if.total[lo,bytes] [u|111828]
net.if.collisions[lo] [u|0]
net.if.discovery [s|[{"{#IFNAME}":"ens4"},{" {#IFNAME}":"ens5"},{"{#IFNAME}":"ens3"},{"{#IFNAME}":"lo"},{" {#IFNAME}":"ens6"}]]
net.tcp.service[ssh,127.0.0.1,22] [u|1]
net.tcp.service.perf[ssh,127.0.0.1,22] [d|0.0092873573303222656] net.udp.service[ntp,127.0.0.1,123] [u|0]
net.udp.service.perf[ntp,127.0.0.1,123] [d|0]在server端测试系统自带的监控项：
#因为系统自带监控项数量也不少，我们如果一个一个的在zabbix-web上添加，然后等待采集数据，然后看 图形，或者测试，效率太低了。所以呢我们就使用命令行来简单的查看一下监控项对应的数据
#我们此时使用的一个工具叫做zabbix_get,我们需要在server端安装zabbix_get,zabbix_get提供了 可以让server手工从agent获取key数据的命令行工具。
[root@server ~]# yum -y install zabbix-get [root@server ~]# zabbix_get
usage:
zabbix_get -s host-name-or-IP [-p port-number] [-I IP-address] -k item-key
zabbix_get -s host-name-or-IP [-p port-number] [-I IP-address]
--tls-connect cert --tls-ca-file CA-file
[--tls-crl-file CRL-file]
[--tls-agent-cert-issuer cert-issuer]
[--tls-agent-cert-subject cert-subject]
--tls-cert-file cert-file
--tls-key-file key-file
[--tls-cipher13 cipher-string]
[--tls-cipher cipher-string]
-k item-key
zabbix_get -s host-name-or-IP [-p port-number] [-I IP-address]
--tls-connect psk
--tls-psk-identity PSK-identity
--tls-psk-file PSK-file
[--tls-cipher13 cipher-string]
[--tls-cipher cipher-string]
-k item-key
zabbix_get -h zabbix_get -V
#查看net.tcp.listen这个key，这个key后面的80表示检查是否agent端监听80端口
[root@server ~]# zabbix_get -s 10.163.1.115 -k net.tcp.listen[80]
0
[root@server ~]# zabbix_get -s 10.163.1.116 -k net.tcp.listen[80]
1
#检查22号的tcp端口是否正常
[root@server ~]# zabbix_get -s 10.163.1.116 -k net.tcp.listen[22]
1
#检查68号端口的udp是否监听
[root@server ~]# zabbix_get -s 10.163.1.116 -k net.udp.listen[68]
114、zabbix自定义监控项
zabbix自定义监控项非常重要，因为有些时候系统自带的监控项根本无法满足我们的监控需求。所以zabbix 提供了方法让你能自定义系统监控项。系统自定义监控项无非就是写脚本，通过脚本来获取你想要监控的内容。
zabbix-agent参数说明：
#官方文档
https://www.zabbix.com/documentation/4.0/zh/manual/config/items/userparameters
#如果你要自定义的用户监控项需要参数，那么你就要将UserParameter参数设置为1
[root@db ~]# egrep -i '^# unsafeuserpa' /etc/zabbix/zabbix_agentd.conf # UnsafeUserParameters=0
#如果你想自定义监控项，脚本就是使用UserParameter参数来定义的。
[root@db ~]# egrep -i '^# userpa' /etc/zabbix/zabbix_agentd.conf
# UserParameter=第一个自定义监控项（不带用户参数的）：
#做修改之前的配置文件
[root@db ~]# egrep -v '^#|^$' /etc/zabbix/zabbix_agentd.conf PidFile=/var/run/zabbix/zabbix_agentd.pid
LogFile=/var/log/zabbix/zabbix_agentd.log
LogFileSize=0 Server=10.163.1.104
ServerActive=10.163.1.104 Hostname=Zabbix server
Include=/etc/zabbix/zabbix_agentd.d/*.conf
#做修改之后的配置文件
[root@db ~]# sed -i 's/^# UserPa.*/UserParameter=ping,echo 1/' /etc/zabbix/zabbix_agentd.conf
[root@db ~]# egrep -v '^#|^$' /etc/zabbix/zabbix_agentd.conf PidFile=/var/run/zabbix/zabbix_agentd.pid
LogFile=/var/log/zabbix/zabbix_agentd.log
LogFileSize=0 Server=10.163.1.104
ServerActive=10.163.1.104
Hostname=Zabbix server
Include=/etc/zabbix/zabbix_agentd.d/*.conf
UserParameter=ping,echo 1
#查看自定义监控项的key和value
[root@db ~]# zabbix_agentd -p | egrep ^ping
ping第二个自定义监控项（不带用户参数）：
[root@db ~]# systemctl stop mariadb
[root@db ~]# mysqladmin -uroot ping
mysqladmin: connect to server at 'localhost' failed
error: 'Can't connect to local MySQL server through socket '/var/lib/mysql/mysql.sock' (2)' Check that mysqld is running and that the socket: '/var/lib/mysql/mysql.sock' exists!
[root@db ~]# systemctl start mariadb
[root@db ~]# mysqladmin -uroot ping
mysqld is alive
#修改之后的配置
[root@db ~]# egrep -v '^#|^$' /etc/zabbix/zabbix_agentd.conf PidFile=/var/run/zabbix/zabbix_agentd.pid
LogFile=/var/log/zabbix/zabbix_agentd.log
LogFileSize=0 Server=10.163.1.104
ServerActive=10.163.1.104
Hostname=Zabbix server Include=/etc/zabbix/zabbix_agentd.d/*.conf
UserParameter=ping,echo 1
UserParameter=mysql.ping,mysqladmin -uroot ping | grep -c alive
[root@db ~]# zabbix_agentd -p | grep ^mysql.ping
mysql.ping [t|1]
[root@db ~]# systemctl stop mariadb
[root@db ~]# zabbix_agentd -p | grep ^mysql.ping
mysql.ping [t|mysqladmin: connect to server
at 'localhost' failed第三个自定监控项（携带用户参数）：
#修改参数，让我们的自定义监控项支持参数设置
[root@db ~]# egrep -i "^# unsafeuserpa" /etc/zabbix/zabbix_agentd.conf
# UnsafeUserParameters=0
[root@db ~]# sed -i 's/^# UnsafeU.*/UnsafeUserParameters=1/'
/etc/zabbix/zabbix_agentd.conf
[root@db ~]# egrep -i "^unsafeuserpa" /etc/zabbix/zabbix_agentd.conf
UnsafeUserParameters=1
#修改之后的配置文件
[root@db ~]# egrep -v '^#|^$' /etc/zabbix/zabbix_agentd.conf PidFile=/var/run/zabbix/zabbix_agentd.pid
LogFile=/var/log/zabbix/zabbix_agentd.log
LogFileSize=0 Server=10.163.1.104
ServerActive=10.163.1.104
Hostname=Zabbix server
Include=/etc/zabbix/zabbix_agentd.d/*.conf
UnsafeUserParameters=1
#key不能重复，重复就报错了
#UserParameter=ping,echo 1
UserParameter=mysql.ping,mysqladmin -uroot ping | grep -c alive
UserParameter=ping[*],echo $1
[root@db ~]# zabbix_agentd -p
zabbix_agentd [6962]: ERROR: cannot add user parameter "ping[*],echo $1": key
"ping" already exists
[root@db ~]# zabbix_agentd -p | egrep ^ping
ping [t|]
#使用zabbix_get命令来测试
如果想让zabbix-server能获取到zabbix-agent自定义监控项的最新修改，那么需要重启zabbix-agent 服务
#如果没有重启就会出现下面的错误
[root@server ~]# zabbix_get -s 10.163.1.115 -k ping[3]
ZBX_NOTSUPPORTED: Unsupported item key.
#重启zabbix-agent服务
[root@db ~]# systemctl restart zabbix-agent.service
#再次获取数据
[root@server ~]# zabbix_get -s 10.163.1.115 -k ping[3]
3
[root@server ~]# zabbix_get -s 10.163.1.115 -k ping[4]
4第四个自定义监控项（携带用户参数）：
#session.num.get就是我们要自定义的监控项的key
[root@db ~]# egrep -v '^#|^$' /etc/zabbix/zabbix_agentd.conf PidFile=/var/run/zabbix/zabbix_agentd.pid
LogFile=/var/log/zabbix/zabbix_agentd.log
LogFileSize=0 Server=10.163.1.104
ServerActive=10.163.1.104
Hostname=Zabbix server
Include=/etc/zabbix/zabbix_agentd.d/*.conf
UnsafeUserParameters=1
UserParameter=mysql.ping,mysqladmin -uroot ping | grep -c alive
UserParameter=ping[*],echo $1
UserParameter=session.established.num[*],netstat -tunp | grep -i esta | grep -i :$1 | wc -l
#重启服务
[root@db ~]# systemctl restart zabbix-agent.service
[root@server ~]# zabbix_get -s 10.163.1.115 -k session.established.num[3306]
(Not all processes could be identified, non-owned process info will not be shown, you would have to be root to see it all.) 16
#上面弹出的信息表示的意思是权限有问题，因为我们使用zabbix获取数据，相当于用zabbix用户执行 netstat命令，但是由于zabbix并不是特权用户，所以是有可能列不出所有的netstat会话数量的。
#做如下修改
[root@db ~]# grep ^zabbix /etc/sudoers
zabbix ALL= NOPASSWD: /usr/bin/netstat
#配置文件重新修改
[root@db ~]# egrep -v '^#|^$' /etc/zabbix/zabbix_agentd.conf PidFile=/var/run/zabbix/zabbix_agentd.pid
LogFile=/var/log/zabbix/zabbix_agentd.log
LogFileSize=0 Server=10.163.1.104
ServerActive=10.163.1.104 Hostname=Zabbix server Include=/etc/zabbix/zabbix_agentd.d/*.conf
UnsafeUserParameters=1
UserParameter=mysql.ping,mysqladmin -uroot ping | grep -c alive UserParameter=ping[*],echo $1 UserParameter=session.established.num[*],sudo netstat -tunp | grep -i esta | grep -i :$1 | wc -l
[root@db ~]# systemctl restart zabbix-agent.service
#此时一些就正常了
[root@server ~]# zabbix_get -s 10.163.1.115 -k session.established.num[3306]
1615、使用装机自带的模板和官网上别人共享模板实现监控
在zabbix完成安装之后，会有很多自带的模板，这些模板你加以修改就可以直接使用。
在模板页面查看模板：
配置linux主机使用linux的模板：
模板是针对主机组设置的内容，如果我们想要让linux主机使用模板，需要将模板分配给主机组，然后我们再 将linux主机加入具有模板的主机组，由于我们zabbix装机结束之后，就有默认的模板和主机组做了关联， 我们如果我们想使用现有的模板实现linux主机的监控，只要将linux主机加入已经关联的模板的主机组即可。
使用同样的方法将另外的两个主机关联模板：
使用官网上别人共享的模板：
Zabbix community templates
16、zabbix使用模板实现监控网络设备
ip地址都是自动获取
#思科交换机地址配置
Switch(config)#int vlan 1
Switch(config-if)#ip address 10.163.1.198 255.255.255.0
Switch(config-if)#no shut
Switch(config-if)#hostname cisco-switch
cisco-switch(config)#do wr
#H3C路由器地址配置
检查zabbix-server到两个网络节点的连通性
[root@server ~]# ping 10.163.1.141
PING 10.163.1.141 (10.163.1.141) 56(84) bytes of data.
64 bytes from 10.163.1.141: icmp_seq=1 ttl=255 time=3.01 ms
64 bytes from 10.163.1.141: icmp_seq=2 ttl=255 time=0.957 ms
[root@server ~]# ping 10.163.1.198
PING 10.163.1.198 (10.163.1.198) 56(84) bytes of data. 64 bytes from 10.163.1.198: icmp_seq=1 ttl=255 time=1.11 ms在H3C的router上配置ssh和snmp：
1. 配置ssh server
2. 配置snmp
sys
System View: return to User View with Ctrl+Z.
[h3c-router]snmp-agent
[h3c-router]snmp-agent community read public
[h3c-router]snmp-agent sys-info version all
save
The current configuration will be written to the device. Are you sure? [Y/N]:y
Please input the file name(*.cfg)[flash:/startup.cfg]
(To leave the existing filename unchanged, press the enter key): flash:/startup.cfg exists, overwrite? [Y/N]:y
Validating file. Please wait...
Configuration is saved to device successfully. 可以在linux查看snmp的信息：
[root@server ~]# yum -y install net-snmp-utils
[root@server ~]# snmpwalk -v 2c -c public 10.163.1.141在cisco的switch上配置telnet和snmp：
1. 配置telnet
#配置telnet
cisco-switch(config)#line vty 0 4
cisco-switch(config-line)#transport input telnet
cisco-switch(config-line)#login local
cisco-switch(config-line)#user root password root
cisco-switch(config)#enable password root
#在linux上安装telnet客户端
[root@server ~]# yum -y install telnet
[root@server ~]# telnet 10.163.1.198
Username: root
Password: root
cisco-switch>
cisco-switch>enable
Password: root
cisco-switch##配置snmp
cisco-switch(config)#snmp-server community public ro
cisco-switch(config)#snmp-server enable traps
cisco-switch(config)#do wr[root@server ~]# snmpwalk -v 2c -c public 10.163.1.192在zabbix-web上添加网络节点：
以同样的方法设置h3c-router的监控：
关闭思科和h3c的某个接口然后查看触发器状态：
注意我们不能down e0/0接口和ge1/0接口。
cisco-switch(config)#int e0/1
cisco-switch(config-if)#shutdown
[h3c-router]int ge2/0
[h3c-router-GigabitEthernet2/0]shutdown 
17、zabbix自动发现
自动发现的背景，自动发现的背景其实是因为如果你想在现有的基础设施场景建立监控，如果需要监控数量庞 大的监控节点，那么自动发现必不可少。我们强调是物理节点，而不是虚拟机节点。
由于我们在后面可能有更多的新加入的agent需要配置，所以我们就采用脚本的形式配置zabbix-agent
[root@eveng-home ~/zabbix-install]# cat zabbix-agent.sh
#!/bin/bash function zabbix_agent_install()
{
sshpass -p1 ssh-copy-id root@$1 &>>/dev/null
cat > .repo.repo <>/dev/null
scp .repo.repo root@$1:/etc/yum.repos.d/repo.repo &>>/dev/null
ssh root@$1 "sed -i 's/SELINUX=enforcing/SELINUX=permissive/' /etc/selinux/config && setenforce 0" &>>/dev/null
ssh root@$1 systemctl disable firewalld --now &>>/dev/null
ssh root@$1 yum -y install zabbix-agent &>> /dev/null
cat > .zabbix_agentd.conf <> /dev/null
ssh root@$1 systemctl enable zabbix-agent.service --now &>> /dev/null
}
zabbix_agent_install $1 运行脚本安装zabbix-agent：
[root@eveng-home ~/zabbix-install]# ./zabbix-agent.sh 10.163.1.117
[root@localhost ~]# systemctl is-active zabbix-agent.service active
[root@localhost ~]# netstat -tunlp | grep :10050
tcp 0 0 0.0.0.0:10050 0.0.0.0:* LISTEN
2166/zabbix_agentd
tcp6 0 0 :::10050 :::* LISTEN
2166/zabbix_agentd配置自动发现：
配置自动发现动作：
[root@localhost ~]# zabbix_agentd -p | grep ^system.unam
system.uname [s|Linux localhost.localdomain 4.18.0-80.el8.x86_64 #1 SMP Tue Jun 4 09:19:46 UTC 2019 x86_64]
[root@localhost ~]# uname -a
Linux localhost.localdomain 4.18.0-80.el8.x86_64 #1 SMP Tue Jun 4 09:19:46 UTC
2019 x86_64 x86_64 x86_64 GNU/Linux
自动发现主机的问题：
如果你自动发现规则的网络过于庞大，由于自动发现的原理是发送arp请求的广播包，所以为了避免广播包泛 洪，我们一般不会开启自动发现规则。
arp广播请求，如果收到回复，就zabbix-get拿动作条件里面定义的值，然后比对，如果通过，就自动添加。
关掉自动发现规则：
18、zabbix的主机批量导入导入
批量导出主机：
主机删除：
通过刚才导出的xml文件再次进行导入：
我们可以通过xml导出文件的特征进行修改。然后脚本修改xml文件，再次就行导入，实现主机的批量添加， 用这种方法取代自动发现规则。
19、zabbix+grafana
grafana是一个三方的图形显示工具，grafana是目前监控平台前端显示监控项图形最流行的图形工具。 grafana的图形非常优美，非常好看，就是复杂了点。
说grafana复杂是因为里面的可操作项太多了，如果你没有那么复杂的需求，其实grafana还是挺简单的。
1. grafana的安装
将grafana安装到我们的zabbix-web上，grafana软件默认在appstream的仓库中就已经有了。 在centos8.2的appstream的软件仓库，grafana的版本是6.3.6，这个版本偏低。我们可以到官网上下载使用最新的版本。
[root@web ~]# wget https://dl.grafana.com/oss/release/grafana-7.1.5-1.x86_64.rpm
[root@web ~]# ls -l grafana-7.1.5-1.x86_64.rpm
-rw-r--r--. 1 root root 52286726 Aug 25 17:01 grafana-7.1.5-1.x86_64.rpm
[root@web ~]# yum -y install grafana-7.1.5-1.x86_64.rpmzabbix插件安装：
只有安装了zabbix插件，才可以在grafana中添加zabbix的数据源，使用zabbix的监控数据绘出图形 。
[root@web ~]# grafana-cli plugins list-remote | grep zabbix id: alexanderzobnin-zabbix-app version: 4.0.1
[root@web ~]# grafana-cli plugins install alexanderzobnin-zabbix-app installing alexanderzobnin-zabbix-app @ 4.0.1
from: https://grafana.com/api/plugins/alexanderzobnin-zabbix-app/versions/4.0.1/download into: /var/lib/grafana/plugins
✔ Installed alexanderzobnin-zabbix-app successfully
Restart grafana after installing plugins .
[root@web ~]# systemctl enable grafana-server --now
[root@web ~]# netstat -tunlp | grep grafana
tcp6 0 0 :::3000 :::* LISTEN
4407/grafana-server 访问grafana-server的web：
grafana-server的web图形界面默认监听3000号端口，默认的用户名和密码都是admin。
注意，grafana的web界面没有中文。有一些个人开发者，自己根据源码做了一些汉化。建议你不要使用。
开启zabbix的插件：
我们在7.1.5版本发现的问题,默认zabbix的插件，在7.1.5版本不允许添加数据源，找不到zabbix插件带 来的数据源。需要修改一下配置文件。
[root@web ~]# vim /etc/grafana/grafana.ini [plugins]
allow_loading_unsigned_plugins = alexanderzobnin-zabbix-datasource
#修改上面的内容
重启一下grafana-server服务
[root@web ~]# systemctl restart grafana-server
简单的加一个dashboard测试：
使用别人共享出来的grafana的图形：
https://grafana.com/grafana/dashboards
https://grafana.com/grafana/dashboards/11209
