018-zabbix_api

jsonrpc - API使用的JSON-RPC協議的版本; Zabbix API實現JSON-RPC版本2.0;前端

disable_until 下一次輪詢一個不可用主機的時間，默認只讀readonly

maintenanceid 維護的ID，若是當前主機處於維護狀態，不然爲null

name 主機顯示的名稱，便可見名稱，默認是用host字段是值填充

templateid 監控項對應的父模版ID，該ID自關聯，模版對應的爲hostid至關於模版分組

password 密碼認證，針對簡單檢查，ssh,telnet，數據庫監視，jmx監控項

用 curl 模擬 API 的使用

能夠經過 API 來添加和刪除 Host，這裏就不舉例了，具體方法參考官網文檔。
在實際的 API 開發應用中，咱們能夠採用 Python 等其餘編程語言中來實現。以下，就是用 Python 寫的用於認證獲取 SESSIONID 的代碼例子：

若是url中包含目錄須要把目錄寫上，如http://zabbix.aek.com/zabbix/api_jsonrpc.php，最後就是請求的數據（data），好比獲取Token，建立主機，獲取主機ID，獲取模板ID，獲取組ID，刪除主機等。

上面的data用來測試是否可鏈接成功，官方文檔中auth的值爲null，但在python中null用None表示，因此須要改爲None。

最後以一個完整的Python腳本經過zabbix API獲取全部主機的信息爲例：

經過以上的學習相信你們對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,

腳本1、進入監控主機
[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"
}

腳本2、查詢主機的信息
[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"
]
}
}

腳本4、實現建立主機腳本
[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 -參數」便可。

轉載至：http://www.javashuo.com/article/p-atzdlznr-c.html

Zabbix API 簡介

Zabbix API 的使用流程

使用 API 的基本步驟

用 curl 模擬 API 的使用

python3(requests)調用zabbix-4.2.3-api添加修改主機