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 的基本步骤

  1. 连接 http://x.x.x.x/api_jsonrpc.php 提供用户名和密码,
    并标识 HTTP 头部 Content-Type:application/json,HTTP 方法为 POST。
  2. 获取 SESSIONID
  3. 通过 SESSIONID 建立后续的连接
  4. 提交 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": 1 }' $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": 1, "main": 1, "useip": 1, "ip": "'$ip'", "dns": "", "port": "10050" } ], "groups": [ { "groupid": "16" } ], "templates": [ { "templateid": "10001" } ] }, "auth": "'$jsson'", "id": 1 }' $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={"0":"OK","1":"Disabled"}
                        available={"0":"Unknown","1":"available","2":"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": "161"  #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": "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()
                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 -参数”即可。

 

转载至:https://www.cnblogs.com/momoshouhu/p/8053907.html

 

 

 

posted @ 2019-08-26 17:16  xuefy  阅读(401)  评论(0编辑  收藏  举报