018-zabbix_api
Zabbix API 简介
Zabbix API 开始扮演着越来越重要的角色，尤其是在集成第三方软件和自动化日常任务时。
很难想象管理数千台服务器而没有自动化是多么的困难。
Zabbix API 为批量操作、第三方软件集成以及其他作用提供可编程接口。 Zabbix API 是在 1.8 版本中开始引进并且已经被广泛应用。所有的 Zabbix 移动客户端都是基于 API，
甚至原生的 WEB 前端部分也是建立在它之上。
Zabbix API 中间件使得架构更加模块化也避免直接对数据库进行操作。
它允许你通过 JSON RPC 协议来创建、更新和获取 Zabbix 对象并且做任何你喜欢的操作【当然前提是你拥有认证账户】。 Zabbix API 提供两项主要功能： 1. 远程管理 Zabbix 配置
2. 远程检索配置和历史数据 使用 JSON
API 采用 JSON-RPC 实现。这意味着调用任何函数，都需要发送 POST 请求，输入输出数据都是以 JSON 格式。
Zabbix API 的使用流程
使用 API 的基本步骤
- 连接 http://x.x.x.x/api_jsonrpc.php 提供用户名和密码，
并标识 HTTP 头部 Content-Type:application/json，HTTP 方法为 POST。 - 获取 SESSIONID
- 通过 SESSIONID 建立后续的连接
- 提交 POST 数据，格式为 JSON，其中放对应的方法，获取需要的数据。
3、格式及参数说明
zabbix-api的json格式主要包括以下内容：
jsonrpc - API使用的JSON-RPC协议的版本; Zabbix API实现JSON-RPC版本2.0;
method - 调用的API方法;
params - 将被传递给API方法的参数;
auth -用户认证令牌;
id - 请求的任意标识符;
zabbix表结构
hosts主要表结构和各字段的意思
hostid 主机ID／模版ID readonly
proxy_hostid 代理主机ID，即这台主机通过该代理主机去监控
host 主机名，监控agent端ID字段
status 主机状态
0 已启用，监视这台主机
1 停用的，不监视这台主机
3 模版
5 主动模式 创建代理时使用
6 被动模式 创建代理时使用
available 客户端agent主机是否可用 readonly
0 未知或模版
1 可用
2 不可用
description 描述主机
disable_until 下一次轮询一个不可用主机的时间，默认只读readonly
ipmi_authtype 认证算法
-1 默认
0 无
1 MD2
2 MD5
4 Straight
5 OEM
6 RMCP+
ipmi_privilege 特权级别
1 回调
2 用户 默认
3 操作者
4 管理者
5 OEM
ipmi_available 可用的ipmiagent
0 未知
1 可用
2 不可用
ipmi_disable_until ipmi不可用时下一次的轮询时间
ipmi_error ipmi不可用的错误信息
ipmi_errors_from ipmi不可用状态从什么时候开始
ipmi_password ipmi 密码
ipmi_username ipmi用户名
jmx_available 可用的jmxagent
0 未知
1 可用
2 不可用
jmx_disable_until 当jmx不可用时下一次轮询当时间
jmx_error jmx不可用错误信息
jmx_errors_from jmx 不可用状态开始时间
maintenance_from 资产维护开始时间
maintenance_status 生效当状态
0 不维护
1 维护生效
maintenance_type 生效维护的类型
0 通过数据收集维护 默认
1 非数据收集维护
maintenanceid 维护的ID，如果当前主机处于维护状态，否则为null
snmp_available snmp是否可用
0 未知
1 可用
2 不可用
snmp_disable_until 当snmp不可用时下一次轮询时间
snmp_error 不可用时错误信息
snmp_errors_from 错误开始时间
error 当agent不可用时显示当错误信息
error_from 故障时间 当agent不可用时开始的时间
name 主机显示的名称，即可见名称，默认是用host字段是值填充
flags 主机来源
0 表示普通的主机
4 表示自动发现的主机
inventory_mode 主机资产类型
-1 禁用
0 手动，默认值
自动
监控项items
itemid 监控项ID
type 监控项类型
0 Zabbix 客户端,
1 SNMPv1 客户端,
2 Zabbix采集器,
3 简单检查,
4 SNMPv2 客户端,
5 Zabbix内部,
6 SNMPv3 客户端,
7 Zabbix客户端(主动式),
8 Zabbix整合,
10 外部检查,
11 数据库监控,
12 IPMI客户端,
13 SSH 客户端,
14 TELNET客户端,
15 可计算的,
16 JMX agent代理程序,
17 SNMP trap
hostid 关联主机ID
name 监控项名称
key_ 监控项key值
delay 间隔／秒
history 历史数据保留时间／天
trends 趋势数据保留时间／天 默认365天
status 监控项启用状态
0 启用
1 禁用
value_type 数据类型，对应的存放历史数据表
0 history表 numeric float
1 history_str表 character
2 history_log表 log
3 history_uint表 numeric unsigned
4 history_text表 text
authtype ssh认证方法，只有通过ssh代理方式时使用
0 密码
1 public key
units 数据类型单位
data_type 数据类型
0 decimal 十进制
1 octal 八进制
2 hexadecimal 十六进制
3 boolean 布尔
delay_flex 自定义间隔
delta 存储的值
0 (default) as is
1 Delta, speed per second
2 Delta, simple change
error 如果监控项有问题会自动更新这个错误信息 readonly
history 监控项保持的历史数据时长，默认90天，单位天
formula 公式，自定义乘数
1 默认值
lastclock 监控项最后一次更新时间
logtimefmt 格式化日志时间
templateid 监控项对应的父模版ID，该ID自关联，模版对应的为hostid相当于模版分组
flags 监控项来源
0 普通
4 自动发现
interfaceid 网卡IP，对应interface表interfaceid
params 额外的参数类型取决于监控项
针对ssh和telnet监控项 执行脚本
数据库监控项 执行sql
计算类型 执行公式
port 针对snmp监控项，端口监控
password 密码认证，针对简单检查，ssh,telnet，数据库监视，jmx监控项
description 监控项描述信息
state 该监控项是否适用
0 支持
1不支持
用 curl 模拟 API 的使用
# 1. 获取 SESSIONID
[root@linux-node1 ~]# curl -s -X POST -H 'Content-Type:application/json' -d '
> {
> "jsonrpc": "2.0",
> "method": "user.login",
> "params": {
> "user": "Admin",
> "password": "zabbix"
> },
> "id": 1
> }' http://192.168.56.11/zabbix/api_jsonrpc.php | python -m json.tool
{
"id": 1,
"jsonrpc": "2.0",
"result": "6a0d235908c25a495f0d356157fbb3d3"
}
# 2. 用获取的 SESSIONID 去调用 API 的 host.get 方法请求 hostid
[root@linux-node1 ~]# curl -s -X POST -H 'Content-Type:application/json' -d '
> {
> "jsonrpc": "2.0",
> "method": "host.get",
> "params": {
> "output": ["hostid"]
> },
> "auth": "6a0d235908c25a495f0d356157fbb3d3",
> "id": 1
> }' http://192.168.56.11/zabbix/api_jsonrpc.php | python -m json.tool
{
"id": 1,
"jsonrpc": "2.0",
"result": [
{
"hostid": "10084"
},
{
"hostid": "10120"
}
]
}
可以通过 API 来添加和删除 Host，这里就不举例了，具体方法参考官网文档。
在实际的 API 开发应用中，我们可以采用 Python 等其他编程语言中来实现。 如下，就是用 Python 写的用于认证获取 SESSIONID 的代码例子：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import requests
import json
url = 'http://192.168.56.11/zabbix/api_jsonrpc.php'
post_data = {
"jsonrpc": "2.0",
"method": "user.login",
"params": {
"user": "Admin",
"password": "zabbix"
},
"id": 1
}
post_header = {'Content-Type': 'application/json'}
ret = requests.post(url, data=json.dumps(post_data), headers=post_header)
zabbix_ret = json.loads(ret.text)
if not zabbix_ret.has_key('result'):
print 'login error'
else:
print zabbix_ret.get('result')
执行脚本时，注意要安装 Python requests 模块。
[root@linux-node1 ~]# python zabbix_auth.py
Traceback (most recent call last):
File "zabbix_auth.py", line 4, in <module>
import requests
ImportError: No module named requests
[root@linux-node1 ~]# yum install python-pip -y
[root@linux-node1 ~]# pip install requests
[root@linux-node1 ~]# python zabbix_auth.py
f2453c4cc730d5158a87e0754940138e
调用Zabbix api使用的是HTTP的POST请求方式
其中请求的头部为：
{"Content-Type": "application/json-rpc"}请求的URL为：
http://zabbix.aek.com/api_jsonrpc.php如果url中包含目录需要把目录写上，如http://zabbix.aek.com/zabbix/api_jsonrpc.php，最后就是请求的数据（data），比如获取Token，创建主机，获取主机ID，获取模板ID，获取组ID，删除主机等。
接下以以Python调用 API为例，例出用法案例：
测试连接是否成功
#!/usr/bin/python
#coding:utf:8
import requests
import json
url = "http://zabbix.aek.com/zabbix/api_jsonrpc.php"
header = {"Content-Type": "application/json-rpc"}
data = {"jsonrpc":"2.0","method":"apiinfo.version","id":1,"auth":None,"params":{}}
request = requests.post(url=url, headers=header, data=json.dumps(data))
print(request.content)上面的data用来测试是否可连接成功，官方文档中auth的值为null，但在python中null用None表示，所以需要改成None。
成功后返回值大概如下：会显示zabbix版本
{"jsonrpc":"2.0","result":"3.2.3","id":1}获取Token
#!/usr/bin/python
#coding:utf:8
import requests
import json
url = "http://zabbix.aek.com/zabbix/api_jsonrpc.php"
header = {"Content-Type": "application/json-rpc"}
data = {"jsonrpc": "2.0",
"method": "user.login",
"params": {
"user": "Admin",
"password": "zabbix"
},
"id": 1,
"auth": None
}
request = requests.post(url=url, headers=header, data=json.dumps(data))
print(request.content)成功后返回值如下：会返回一个Token
{"jsonrpc":"2.0","result":"391277f070a3ebc5b2afe9cf466cb74c","id":1}最后以一个完整的Python脚本通过zabbix API获取所有主机的信息为例：
#!/usr/bin/python
#coding:utf:8
import requests
import json
class Zabbix:
def __init__(self, url, header, username, password):
self.url = url
self.header = header
self.username = username
self.password = password
def getToken(self):
#获取Token并返回字符Token字符串
data = {"jsonrpc": "2.0",
"method": "user.login",
"params": {
"user": self.username,
"password": self.password
},
"id": 1,
"auth": None
}
token = requests.post(url=self.url, headers=self.header, data=json.dumps(data))
return json.loads(token.content)["result"]
def getAllHost(self):
#获取所有主机信息
data = {"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": [
"hostid",
"host",
],
"selectGroups": "extend",
"selectInterfaces": [
"interfaceid",
"ip"
]
},
"id": 2,
"auth": self.getToken()
}
hosts = requests.post(url=self.url, headers=self.header, data=json.dumps(data))
return json.loads(hosts.content)["result"]
if __name__ == "__main__":
header = {"Content-Type": "application/json-rpc"}
url="http://zabbix.aek.com/zabbix/api_jsonrpc.php"
test = Zabbix(url=url, header=header, username="Admin", password="zabbix")
print(test.getAllHost())通过以上的学习相信大家对Zabbix API已经有一个初步的认识，后面将会通过API去完成主机的自动添加，自动化报表等使用
python3(requests)调用zabbix-4.2.3-api添加修改主机
自动化是需求，手动太慢，自动发现没玩过。用的比较多的就是调API来操作。
zabbix版本为4.2.3 python3 需要reuquests,json模块
下面是代码，只写了添加和删除的功能，有需求的可以自己加一下
2019.6.19
zabbix API 修改主机
'''
import json,requests
headers={"Content-Type":"application/json"}
url = 'http://www.zabbix.com/zabbix/api_jsonrpc.php'
def getAuth(user,password):
try:
global headers, url
data = json.dumps({
"jsonrpc": "2.0",
"method": "user.login",
"params": {
"user": user,
"password": password
},
"id": 1,
})
res = requests.post(url,data=data,headers=headers)
auth = res.json().get('result','')
return auth
except Exception as err:
pass
def getHost(auth):
try:
global headers,url
data = json.dumps({
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": [
"hostid",
"host"],
"selectInterfaces": [
"interfaceid",
"ip"]},
"id": 2,
"auth": auth
})
res = requests.post(url,data=data,headers=headers)
host = res.json()
return host
except:
pass
def getGroupid(auth,groupname):
try:
global headers, url
data = json.dumps({
"jsonrpc": "2.0",
"method": "hostgroup.get",
"params": {
"output": "extend",
"filter": {
"name": [groupname]}},
"auth": auth,
"id": 1
})
res = requests.post(url,data=data,headers=headers)
groupid = res.json()['result'][0]['groupid']
return groupid
except:
pass
def getTempid(auth,tempname):
try:
global headers, url
# print(templist)
data = json.dumps(
{
"jsonrpc": "2.0",
"method": "template.get",
"params": {
"output": "extend",
"filter": {
"host": tempname}},
"auth": auth,
"id": 1}
)
res = requests.post(url,data=data,headers=headers)
tempid = []
for i in range(len(res.json()['result'])):
id = res.json()['result'][i]['templateid']
tempid.append(id)
return tempid
except:
pass
def createHost(auth,hostname,ip,port,groupid,templateid):
try:
global headers, url
templist = []
# print(templateid)
for i in templateid:
var = {}
var['templateid'] = i
templist.append(var)
data = json.dumps({
"jsonrpc": "2.0",
"method": "host.create",
"params": {
"host": hostname,
"interfaces": [
{
"type": 1,
"main": 1,
"useip": 1,
"ip": ip,
"dns": "",
"port": port}],
"groups": [{"groupid": groupid}],
"templates": templist,},
"auth": auth,
"id": 1})
res = requests.post(url,data=data,headers=headers)
if 'result' in res.text:
print ('主机： %s -------添加成功' %hostname)
else:
print ('主机： %s -------添加失败'%hostname)
except:
pass
def host_get(auth,hostName=''):
try:
global url,headers
data = json.dumps({
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": "extend",
"selectParentTemplates": ["host"],
"filter": {"host": hostName}
},
"auth": auth,
"id": 1
})
res = requests.post(url=url, data=data, headers=headers)
response = json.loads(res.content)
print("主机数量: \33[31m {} \33[0m".format(len(response['result'])))
# print(response['result'])
for host in response['result']:
status = {"0": "OK", "1": "Disabled"}
available = {"0": "Unknown", "1": "available", "2": "Unavailable"}
# print host
if len(hostName) == 0:
print("HostID : %s HostName : %s Status :\33[32m%s\33[0m Available :\33[31m%s\33[0m" % (
host['hostid'], host['name'], status[host['status']], available[host['available']]))
else:
print("HostID : %s HostName : %s Status :\33[32m%s\33[0m Available :\33[31m%s\33[0m" % (
host['hostid'], host['name'], status[host['status']], available[host['available']]))
return host['hostid']
except:
pass
def host_delete(auth, hostid):
try:
global url,headers data
= json.dumps({
"jsonrpc": "2.0",
"method": "host.delete",
"params": [hostid],
"auth": auth,
"id": 1
}) res
= requests.post(url=url, data=data, headers=headers) response
= json.loads(res.content)
print ("主机：%s -----------已经删除 !"%hostid)
except:
pass
if __name__ == '__main__':
user = 'admin' password
= 'password'
#主机群组名 groupname
= 'Linux servers'
#模版名
# tempname = ["Template OS Linux","Template DB MySQL"] tempname
= ["Template OS Linux"]
#获取key auth
= getAuth(user,password)
#获取组id groupid
= getGroupid(auth,groupname)
#获取模版id tempid
= getTempid(auth,tempname)
print('请先修改主机列表后执行')
# createhostlist = [
# "center,172.17.0.12,10050"
# "logserver,172.17.0.12,10050"
# "testserver,172.17.0.12,10050"
# ]
# for host in createhostlist:
# list1 = host.split(',')
# hostname = list1[0]
# hostip = list1[1]
# port = list1[2]
# createHost(auth,hostname,hostip,port,groupid,tempid)
# delhostlist = [
# "dxc_0_12,172.17.0.12,10050"
# ]
#
# for host in delhostlist:
# list1 = host.split(',')
# hostname = list1[0]
# hostid = host_get(auth,hostname)
# host_delete(auth,hostid)
脚本一、进入监控主机
[root@server6 zabbix]# vim zabbix-api.sh
curl -s -X POST -H 'Content-Type:application/json' -d '
{
"jsonrpc": "2.0",
"method": "user.login",
"params": {
"user": "Admin",
"password": "westos"
},
"id": 1,
"auth": null
}' http://172.25.23.1/zabbix/api_jsonrpc.php | python -m json.tool
[root@server6 zabbix]# sh zabbix-api.sh
{
"id": 1,
"jsonrpc": "2.0",
"result": "fc716ee078209e8e6c445ba67e9c93f8"
}
脚本二、查询主机的信息
[root@server6 zabbix]# vim zabbix-api.sh
curl -s -X POST -H 'Content-Type:application/json' -d '
{
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": [
"hostid",
"host"
],
"selectInterfaces": [
"interfaceid",
"ip"
]
},
"id": 2,
#这里的信息是第一个脚本里面查询出来的
"auth": "fc716ee078209e8e6c445ba67e9c93f8"
}' http://172.25.23.1/zabbix/api_jsonrpc.php | python -m json.tool
[root@server6 zabbix]# sh zabbix-api.sh
{
"id": 2,
"jsonrpc": "2.0",
"result": [
{
"host": "Zabbix server",
"hostid": "10084",
"interfaces": [
{
"interfaceid": "1",
"ip": "127.0.0.1"
}
]
},
{
"host": "server6",
"hostid": "10258",
"interfaces": [
{
"interfaceid": "6",
"ip": "172.25.23.6"
}
]
}
]
}
脚本三：删除监控主机
curl -s -X POST -H 'Content-Type:application/json' -d '
{
"jsonrpc": "2.0",
"method": "host.delete",
"params": [
"10259"
],
"auth": "fc716ee078209e8e6c445ba67e9c93f8",
"id": 2
}' http://172.25.23.1/zabbix/api_jsonrpc.php | python -m json.tool
[root@server6 zabbix]# sh zabbix-del.sh
{
"id": 2,
"jsonrpc": "2.0",
"result": {
"hostids": [
"10259"
]
}
}
脚本四、实现创建主机脚本
[root@server6 zabbix]# vim zabbix-create.sh
curl -s -X POST -H 'Content-Type:application/json' -d '
{
"jsonrpc": "2.0",
"method": "host.create",
"params": {
"host": "Linux server",
"interfaces": [
{
"type": 1,
"main": 1,
"useip": 1,
"ip": "172.25.23.6",
"dns": "",
"port": "10050"
}
],
"groups": [
{
"groupid": "2"
}
],
"templates": [
{
"templateid": "10001"
}
]
},
"auth": "fc716ee078209e8e6c445ba67e9c93f8",
"id": 1
}' http://172.25.23.1/zabbix/api_jsonrpc.php | python -m json.tool
[root@server6 zabbix]# sh zabbix-create.sh
{
"id": 1,
"jsonrpc": "2.0",
"result": {
"hostids": [
"10260"
]
}
}
测试过的批量添加脚本：
[root@zabbix scripts]# echo 192.168.1.{20..100} | xargs -n1 > list.txt
[root@zabbix scripts]# cat zabbix_host_creates.sh
#/bin/bash url='http://192.168.1.129/zabbix/api_jsonrpc.php'
user=Admin
pass=zabbix
token=`curl -s -X POST -H 'Content-Type:application/json' -d '
{
"jsonrpc": "2.0",
"method": "user.login",
"params": {
"user": "'$user'",
"password": "'$pass'"
},
"id":
}' $url | python -m json.tool `
jsson=`echo "$token" | grep result | awk -F '"' '{print $4}'`
#echo $jsson #create hosts
for ip in `cat list.txt`
do
curl -s -X POST -H "Content-Type: application/json" -d ' {
"jsonrpc": "2.0",
"method": "host.create",
"params": {
"host": "'$ip'",
"interfaces": [
{
"type": ,
"main": ,
"useip": ,
"ip": "'$ip'",
"dns": "",
"port": ""
}
],
"groups": [
{
"groupid": ""
}
],
"templates": [
{
"templateid": ""
}
]
},
"auth": "'$jsson'",
"id":
}' $url | python -m json.tool
done
创建需要添加的ip列表
[root@zabbix scripts]# cat list.txt
192.168.1.20
192.168.1.21
192.168.1.22
192.168.1.23
192.168.1.24
192.168.1.25
192.168.1.26
192.168.1.27
192.168.1.28
192.168.1.29
192.168.1.30
192.168.1.31
192.168.1.32
192.168.1.33
192.168.1.34
192.168.1.35
192.168.1.36
192.168.1.37
192.168.1.38
192.168.1.39
192.168.1.40
192.168.1.41
192.168.1.42
192.168.1.43
192.168.1.44
192.168.1.45
192.168.1.46
192.168.1.47
192.168.1.48
192.168.1.49
192.168.1.50
192.168.1.51
192.168.1.52
192.168.1.53
192.168.1.54
192.168.1.55
192.168.1.56
192.168.1.57
192.168.1.58
192.168.1.59
192.168.1.60
192.168.1.61
192.168.1.62
192.168.1.63
192.168.1.64
192.168.1.65
192.168.1.66
192.168.1.67
192.168.1.68
192.168.1.69
192.168.1.70
192.168.1.71
192.168.1.72
192.168.1.73
192.168.1.74
192.168.1.75
192.168.1.76
192.168.1.77
192.168.1.78
192.168.1.79
192.168.1.80
192.168.1.81
192.168.1.82
192.168.1.83
192.168.1.84
192.168.1.85
192.168.1.86
192.168.1.87
192.168.1.88
192.168.1.89
192.168.1.90
192.168.1.91
192.168.1.92
192.168.1.93
192.168.1.94
192.168.1.95
192.168.1.96
192.168.1.97
192.168.1.98
192.168.1.99
192.168.1.100
编辑Excel模板
主机名、显示名、IP、主机组、模板
编写Python脚本，参考http://www.361way.com/zabbix-api-2/3681.html
#!/usr/bin/python
#coding:utf-8 import json
import urllib.request
from urllib.error import URLError
import sys,argparse
import xlrd defaultencoding = 'utf-8'
if sys.getdefaultencoding() != defaultencoding:
reload(sys)
sys.setdefaultencoding(defaultencoding) class zabbix_api:
def __init__(self):
self.url = 'http://zabbix 服务器地址/zabbix/api_jsonrpc.php' #修改URL
self.header = {"Content-Type":"application/json"} def user_login(self):
data = json.dumps({
"jsonrpc": "2.0",
"method": "user.login",
"params": {
"user": "账号",
"password": "密码"
},
"id": 0
}) # data = urllib.parse.quote_plus(data).encode("utf-8")
data = data.encode("utf-8")
request = urllib.request.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key]) try:
result = urllib.request.urlopen(request)
except URLError as e:
print ("用户认证失败，请检查 !", e.code)
else:
response = json.loads(result.read())
result.close()
self.authID = response['result']
return self.authID def host_get(self,hostName=''):
data=json.dumps({
"jsonrpc": "2.0",
"method": "host.get",
"params": {
"output": "extend",
"filter":{"host":hostName}
},
"auth": self.user_login(),
"id": 1
})
data = data.encode("utf-8")
request = urllib.request.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key]) try:
result = urllib.request.urlopen(request)
except URLError as e:
if hasattr(e, 'reason'):
print ('We failed to reach a server.')
print ('Reason: ', e.reason)
elif hasattr(e, 'code'):
print ('The server could not fulfill the request.')
print ('Error code: ', e.code)
else:
response = json.loads(result.read())
#print response
result.close()
print ("主机数量: %s"%(len(response['result'])))
for host in response['result']:
status={"":"OK","":"Disabled"}
available={"":"Unknown","":"available","":"Unavailable"}
#print host
if len(hostName)==0:
print ("HostID : %s\t HostName : %s\t Status :%s \t Available :%s"%(host['hostid'],host['name'],status[host['status']],available[host['available']]))
else:
print ("HostID : %s\t HostName : %s\t Status :%s \t Available :%s"%(host['hostid'],host['name'],status[host['status']],available[host['available']]))
return host['hostid'] def hostgroup_get(self, hostgroupName=''):
data = json.dumps({
"jsonrpc":"2.0",
"method":"hostgroup.get",
"params":{
"output": "extend",
"filter": {
"name": hostgroupName
}
},
"auth":self.user_login(),
"id":1,
})
data = data.encode("utf-8")
request = urllib.request.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key]) try:
result = urllib.request.urlopen(request)
except URLError as e:
print ("Error as ", e)
else:
#print result.read()
response = json.loads(result.read())
result.close()
#print response()
for group in response['result']:
if len(hostgroupName)==0:
print ("hostgroup: %s \tgroupid : %s" %(group['name'],group['groupid']))
else:
print ("hostgroup: %s\tgroupid : %s" %(group['name'],group['groupid']))
self.hostgroupID = group['groupid']
return group['groupid'] def template_get(self,templateName=''):
data = json.dumps({
"jsonrpc":"2.0",
"method": "template.get",
"params": {
"output": "extend",
"filter": {
"name":templateName
}
},
"auth":self.user_login(),
"id":1,
}) data = data.encode("utf-8")
request = urllib.request.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key]) try:
result = urllib.request.urlopen(request)
except URLError as e:
print ("Error as ", e)
else:
response = json.loads(result.read())
result.close()
#print response
for template in response['result']:
if len(templateName)==0:
print ("template : %s\t id : %s" % (template['name'], template['templateid']))
else:
self.templateID = response['result'][0]['templateid']
print ("Template Name : %s "%templateName)
return response['result'][0]['templateid']
def hostgroup_create(self,hostgroupName): if self.hostgroup_get(hostgroupName):
print ("hostgroup %s is exist !"%hostgroupName)
sys.exit(1)
data = json.dumps({
"jsonrpc": "2.0",
"method": "hostgroup.create",
"params": {
"name": hostgroupName
},
"auth": self.user_login(),
"id": 1
})
data = data.encode("utf-8")
request=urllib.request.Request(self.url,data) for key in self.header:
request.add_header(key, self.header[key]) try:
result = urllib.request.urlopen(request)
except URLError as e:
print ("Error as ", e)
else:
response = json.loads(result.read())
result.close()
print ("添加主机组:%s hostgroupID : %s"%(hostgroupName,response['result']['groupids'])) def host_create_andy(self,hostName,visibleName, hostip, hostgroupName, templateName):
if self.host_get(hostip):
print ("该主机已经添加!")
sys.exit(1) group_list=[]
template_list=[]
for i in hostgroupName.split(','):
var = {}
var['groupid'] = self.hostgroup_get(i)
group_list.append(var)
for i in templateName.split(','):
var={}
var['templateid']=self.template_get(i)
template_list.append(var) data = json.dumps({
"jsonrpc":"2.0",
"method":"host.create",
"params":{
"host": hostName,
"name": visibleName,
"interfaces": [
{
"type": 2, #1：表示IP；2表示SNMP
"main": 1,
"useip": 1,
"ip": hostip,
"dns": "",
"port": "" #IP端口10051；SNMP端口161
}
],
"groups": group_list,
"templates": template_list,
},
"auth": self.user_login(),
"id":1
})
data = data.encode("utf-8")
request = urllib.request.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key]) try:
result = urllib.request.urlopen(request)
except URLError as e:
print ("Error as ", e)
else:
response = json.loads(result.read())
result.close()
try:
print ("添加主机 :%s \tid :%s" % (hostip, response['result']['hostids']))
except KeyError as e:
print ("信息 :%s \tid :%s" % (hostip, response['error']['data'])) def host_create(self, hostip, hostgroupName, templateName):
if self.host_get(hostip):
print ("该主机已经添加!")
sys.exit(1) group_list=[]
template_list=[]
for i in hostgroupName.split(','):
var = {}
var['groupid'] = self.hostgroup_get(i)
group_list.append(var)
for i in templateName.split(','):
var={}
var['templateid']=self.template_get(i)
template_list.append(var) data = json.dumps({
"jsonrpc":"2.0",
"method":"host.create",
"params":{
"host": hostip,
"interfaces": [
{
"type": 2,
"main": 1,
"useip": 1,
"ip": hostip,
"dns": "",
"port": ""
}
],
"groups": group_list,
"templates": template_list,
},
"auth": self.user_login(),
"id":1
})
data = data.encode("utf-8")
request = urllib.request.Request(self.url, data)
for key in self.header:
request.add_header(key, self.header[key]) try:
result = urllib.request.urlopen(request)
except URLError as e:
print ("Error as ", e)
else:
response = json.loads(result.read())
result.close()
print ("添加主机 : %s \tid :%s" % (hostip, response['result']['hostids'])) def host_disable(self,hostip):
data=json.dumps({
"jsonrpc": "2.0",
"method": "host.update",
"params": {
"hostid": self.host_get(hostip),
"status": 1
},
"auth": self.user_login(),
"id": 1
})
data = data.encode("utf-8")
request = urllib.request.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key])
try:
result = urllib.request.urlopen(request)
except URLError as e:
print ("Error as ", e)
else:
response = json.loads(result.read())
result.close()
print ('----主机现在状态------------')
print (self.host_get(hostip)) def host_delete(self,hostid):
hostid_list=[]
#print type(hostid)
for i in hostid.split(','):
var = {}
var['hostid'] = self.host_get(i)
hostid_list.append(var)
data=json.dumps({
"jsonrpc": "2.0",
"method": "host.delete",
"params": hostid_list,
"auth": self.user_login(),
"id": 1
}) data = data.encode("utf-8")
request = urllib.request.Request(self.url,data)
for key in self.header:
request.add_header(key, self.header[key]) try:
result = urllib.request.urlopen(request)
except Exception as e:
print (e)
else: result.close()
print ("主机 %s 已经删除 !"%hostid) if __name__ == "__main__":
zabbix=zabbix_api()
parser=argparse.ArgumentParser(description='zabbix api ',usage='%(prog)s [options]')
parser.add_argument('-H','--host',nargs='?',dest='listhost',default='host',help='查询主机')
parser.add_argument('-G','--group',nargs='?',dest='listgroup',default='group',help='查询主机组')
parser.add_argument('-T','--template',nargs='?',dest='listtemp',default='template',help='查询模板信息')
parser.add_argument('-A','--add-group',nargs=1,dest='addgroup',help='添加主机组')
parser.add_argument('-C','--add-host',dest='addhost',nargs=3,metavar=('192.168.2.1', 'test01,test02', 'Template01,Template02'),help='添加主机,多个主机组或模板使用分号')
parser.add_argument('-d','--disable',dest='disablehost',nargs=1,metavar=('192.168.2.1'),help='禁用主机')
parser.add_argument('-L','--allin',dest='allin',nargs='?',default='allin',help='从Excel批量导入主机')
parser.add_argument('-D','--delete',dest='deletehost',nargs='+',metavar=('192.168.2.1'),help='删除主机,多个主机之间用分号')
parser.add_argument('-v','--version', action='version', version='%(prog)s 1.0')
if len(sys.argv)==1:
print (parser.print_help())
else:
args=parser.parse_args() if args.listhost != 'host' :
if args.listhost:
zabbix.host_get(args.listhost)
else:
zabbix.host_get()
if args.listgroup !='group':
if args.listgroup:
zabbix.hostgroup_get(args.listgroup)
else:
zabbix.hostgroup_get()
if args.listtemp != 'template':
if args.listtemp:
zabbix.template_get(args.listtemp)
else:
zabbix.template_get()
if args.addgroup:
zabbix.hostgroup_create(args.addgroup[0])
if args.addhost:
zabbix.host_create(args.addhost[0], args.addhost[1], args.addhost[2])
if args.disablehost:
zabbix.host_disable(args.disablehost)
if args.deletehost:
zabbix.host_delete(args.deletehost[0])
if args.allin != 'allin':
workbook = xlrd.open_workbook('zabbix_host_add.xlsx') #Excel名
for row in range(workbook.sheets()[0].nrows):
hostname = workbook.sheets()[0].cell(row, 0).value
visible = workbook.sheets()[0].cell(row, 1).value
hostip = workbook.sheets()[0].cell(row, 2).value
hostgroup = workbook.sheets()[0].cell(row, 3).value
hosttemp = workbook.sheets()[0].cell(row, 4).value zabbix.host_create_andy(hostname,visible,hostip,hostgroup, hosttemp)
将命名为“zabbix_host_add.xlsx”的EXCEL表，放置与脚本统一目录下，然后执行脚本“ python 脚本.py -参数”即可。
018-zabbix_api的更多相关文章
- php大力力 [018节]如何联系大力力
有事儿就注册博客园,给我发 博客园站内的 短消息呗,唉,没有人联系我呀,啦啦啦,爱我爱我,快点爱我 2015-08-26 php大力力018.如何联系大力力
- [反汇编练习] 160个CrackMe之018
[反汇编练习] 160个CrackMe之018. 本系列文章的目的是从一个没有任何经验的新手的角度(其实就是我自己),一步步尝试将160个CrackMe全部破解,如果可以,通过任何方式写出一个类似于注 ...
- ansible和python的zabbix_api批量添加rsync服务的监控
一.正常的处理流程: 1.添加zabbix用户对rsync程序的sudo权限,且不需要输入密码 # visudo即在/etc/sudoers配置文件最后添加如下内容 Defaults:zabbix ! ...
- ansible结合zabbix_api批量添加主机
批量添加zabbix监控 .使用ansible配置zabbix客户端 ①修改服务器的IP(域名),为了方便使用ansible来批量操作 等同于如下sed语句 sed -i 's#Server=1.1. ...
- 018 final 关键字的用途
final关键字的含义 final在Java中是一个保留的关键字,可以声明成员变量.方法.类以及本地变量.一旦你将引用声明作final,你将不能改变这个引用了,编译器会检查代码,如果你试图将变量再次初 ...
- BZOJ 3709&&AGC 018 C——多段排序的微扰法
BZOJ 3709• 有n只怪物,你的初始生命值为z.• 为了打败第i只怪物,你需要消耗cost[i]点生命值,但怪物死后会使你恢复val[i]点生命值.• 任何时候你的生命值都不能小于等于0.• 问 ...
- 逆向破解之160个CrackMe —— 018
CrackMe —— 018 160 CrackMe 是比较适合新手学习逆向破解的CrackMe的一个集合一共160个待逆向破解的程序 CrackMe:它们都是一些公开给别人尝试破解的小程序,制作 c ...
- Python练习题 018：打印星号菱形
[Python练习题 018] 打印出如下图案(菱形): * *** ***** ******* ***** *** * --------------------------------------- ...
- 018 01 Android 零基础入门 01 Java基础语法 02 Java常量与变量 12 数据类型转换的基本概念
018 01 Android 零基础入门 01 Java基础语法 02 Java常量与变量 12 数据类型转换的基本概念 本文知识点:Java中的数据类型转换 类型转换 类型转换分类 2类,分别是: ...
- C语言学习018:strdup复制字符串数组
在C语言学习005:不能修改的字符串中我们知道字符串是存储在常量区域的,将它赋值给数组实际是将常量区的字符串副本拷贝到栈内存中,如果将这个数组赋值给指针,我们可以改变数组中的元素,就像下面那样 int ...
随机推荐
- typescript 类（类的定义、继承、修饰符、抽象类）
代码: // 本节内容 // 1.类的定义 // 2.类的继承 // 3.访问修饰符 // 4.静态属性和静态方法 // 5.抽象类和多态 // js // function Person(name) ...
- orcal解决锁表
1.查看历史运行纪录 select * from dba_jobs_running: 2查看锁住的sid和pid select s.sid,s.serial# fromv$session s wher ...
- python之注释的分类
<1> 单行注释 以#开头,#右边的所有东西当做说明,而不是真正要执行的程序,起辅助说明作用 # 我是注释,可以在里写一些功能说明之类的哦 print('hello world') < ...
- Python_编程特色
目录 目录 前言 软件环境 列表推导式 字典的默认值 forelse语句 交换两个变量的值 链式比较 真值测试 序列类型元素反转 连接字符串和列表 内置算术函数 利用zip来创建键值对 最后 前言 P ...
- samba安装应用实例-2
应用实例: 先安装samba软件,yum install -y samba1.需求:共享一个目录,使用用户名和密码登录才可以访问,要求可读可写.(1)首先打开samba配置文件/etc/samba/s ...
- apache访问日志
#错误日志ErrorLog "logs/dummy-host2.example.com-error_log" #访问日志CustomLog "logs/dummy-hos ...
- 三十六：数据库之SQLAlchemy外建之一对一关系
relationship()的uselist参数默认为True,即一对多,如果要一对一,则需让uselist=False 准备工作 from sqlalchemy import create_engi ...
- zabbix监控httpd进程、添加动作、报警媒介类型
1.在server_agent端创建脚本 mkdir -p /usr/local/etc/zabbix_scripts vi /usr/local/etc/zabbix_scripts/check_h ...
- 匿名函数、委托和Lambda表达式
匿名函数 匿名函数(Anonymous Function)是表示“内联”方法定义的表达式.匿名函数本身及其内部没有值或者类型,但是可以转换为兼容的委托或者表达式树类型(了解详情).匿名函数转换的计算取 ...
- 访问DataGridView的Rows报了OutOfIndexRangeException错误
DataGridView绑定了一个List<Entity>实体集合,在遍历DataGridView的每一行DataBoundItem时候,如果符合某个条件的话,则移除List<Ent ...