zabbix api

#!/usr/bin/env python
# -*-coding:utf-8 -*-
import requests
import json

class AutoZabbix:
    def __init__(self, hostname, visibleName, ip, groupname, template_name):
        self.url = 'http://192.168.67.230/zabbix/api_jsonrpc.php'
        self.headers = {'Content-Type': 'application/json'}
        auth = {
            "jsonrpc": "2.0",
            "method": "user.login",
            "params": {
                "user": "admin",  ###验证
                "password": ""
            },
            "id": 1,
            "auth": None,
        }
        response = requests.post(self.url, data=json.dumps(auth), headers=self.headers)
        # print(response.text)
        self.authid = json.loads(response.text)['result']  ### auth的id  也就是token
        self.hostname = hostname
        self.visibleName = visibleName
        self.ip = ip
        self.add_template = []  # 生成列表，用于给指定IP的主机添加模板
        # self.add_group = []  # 给指定IP的主机添加组

        self.group_name = groupname  # 多个组以逗号分隔，组名不能包含逗号[不支持多个组？？！]
        self.template_name = list(template_name.split(','))  # 多个模板以逗号分隔，模板名不能包含逗号

    def get_template(self):
        """
        输入模版名，返回模版ID
        :return:
        """
        content = {
            "jsonrpc": "2.0",
            "method": "template.get",
            "params": {
                # "output": "extend",
                # "output": ["host", "templateid"],
                "output": "templateid",
                "filter": {
                    "host": self.template_name
                }
            },
            "auth": self.authid,
            "id": 2
        }
        response = requests.post(self.url, data=json.dumps(content), headers=self.headers)
        result = json.loads(response.text)['result']
        # print(result)
        for item in result:
            for k, v in item.items():
                self.add_template.append(v)
        return self.add_template

    def get_group(self):
        """
        输入组名，查询返回组ID
        """
        content = {
            "jsonrpc": "2.0",
            "method": "hostgroup.get",
            "params": {
                # "output": "extend",
                "output": "groupid",
                "filter": {
                    "name": self.group_name
                }
            },
            "auth": self.authid,
            "id": 3
        }

        response = requests.post(self.url, data=json.dumps(content), headers=self.headers)
        response_dic = json.loads(response.text)
        print(response_dic)
        groupid = response_dic['result'][0]['groupid']
        return groupid

    # def get_hosts(self):
    #     content = {
    #         "jsonrpc": "2.0",
    #         "method": "host.get",
    #         "params": {
    #             "output": [
    #                 "hostid",
    #                 "host"
    #             ],
    #             "selectInterfaces": [
    #                 "interfaceid",
    #                 "ip"
    #             ]
    #         },
    #         "id": 3,
    #         "auth": self.authid
    #     }
    #
    #     response = requests.post(self.url, data=json.dumps(content), headers=self.headers)
    #     # response_dic = json.loads(response.text)
    #     print(response.text)

    def create_host(self):
        """
        添加主机，链接模版、添加组
        :return:
        """
        print(self.get_template())
        content = {
            "jsonrpc": "2.0",
            "method": "host.create",
            "params": {
                "host": self.hostname,
                "name": self.visibleName,
                "interfaces": [
                    {
                        "type": 1,
                        "main": 1,
                        "useip": 1,
                        "ip": self.ip,
                        "dns": "",
                        "port": ""
                    }
                ],
                "groups": [
                    {
                        "groupid": self.get_group()
                    }
                ],
                "templates": [
                    {
                        "templateid": ''
                    },
                    {
                        "templateid": ''
                    },
                    {
                        "templateid": ''
                    }
                ]
                # "inventory_mode": 0,
                # "inventory": {
                #     "macaddress_a": "01234",
                #     "macaddress_b": "56768"
                # }
            },
            "auth": self.authid,
            "id": 21
        }
        # print(json.dumps(content))
        response = requests.post(self.url, data=json.dumps(content), headers=self.headers)
        return response.text

hostname = '192.168.67.227'
visibleName = 'vpn'
ip = '192.168.67.227'
groupname = 'office_server'
template_name = 'disk-IO-status,Template ICMP Ping,Template OS Linux,Template Linux TCP Status'  # 模板之间用逗号分隔

obj = AutoZabbix(hostname, visibleName, ip, groupname, template_name)
response = obj.create_host()
print(response)

https://www.jianshu.com/p/d5faa110e78e

# 登录：
#!/usr/bin/env python
import urllib2
import json
#定义URL账户密码
url = 'http://zabbixip/zabbix/api_jsonrpc.php'
username = 'admin'
password = 'password'
#定义通过HTTP方式访问API地址的函数，后面每次请求API的各个方法都会调用这个函数
def requestJson(url,values):
    data = json.dumps(values)
    req = urllib2.Request(url, data, {'Content-Type': 'application/json-rpc'})
    response = urllib2.urlopen(req, data)
    output = json.loads(response.read())
#   print output
    try:
        message = output['result']
    except:
        message = output['error']['data']
        print message
        quit()

    return output['result']

#API接口认证的函数，登录成功会返回一个Token
def authenticate(url, username, password):
    values = {'jsonrpc': '2.0',
              'method': 'user.login',
              'params': {
                  'user': username,
                  'password': password
              },
              'id': ''
              }
    idvalue = requestJson(url,values)
    return idvalue

# API
#!/usr/bin/env python
#coding=utf-8
import sys
import argparse
import urllib2
import json

#定义更新action函数
def mediatypeupdate(mediatypeid,status,auth):
    values = {'jsonrpc': '2.0',
              'method': 'mediatype.update',
              'params': {
                  "mediatypeid": mediatypeid,
                  "status": status
              },
              'auth': auth,
              'id': ''
              }
    output = requestJson(url,values)
#定义读取状态函数
def triggerget(auth):
    values = {'jsonrpc': '2.0',
           "method":"trigger.get",
               "params": {
                        "output": [
                        "triggerid",
                        "description",
                        "priority"
                        ],
              "filter": {
                         "value": 1
                         },
              "expandData":"hostname",
              "sortfield": "priority",
              "sortorder": "DESC"
            },
              'auth': auth,
              'id': ''
              }
    output = requestJson(url,values)
    return output

#定义通过ip获取主机id的函数
def ipgetHostsid(ip,url,auth):
    values = {'jsonrpc': '2.0',
              'method': 'host.get',
              'params': {
                  'output': [ "host" ],
                  'filter': {
                      'ip': ip
                  },
              },
              'auth': auth,
              'id': ''
              }
    output = requestJson(url,values)
    return output

#定义通过主机id获取开启关闭监控函数
def idupdatehost(status,hostid,url,auth):
    values = {'jsonrpc': '2.0',
              'method': 'host.update',
              'params': {
                  "hostid": hostid,
                  "status": status
              },
              'auth': auth,
              'id': ''
              }
    output = requestJson(url,values)
    return output
#定义通过项目hostid获取itemid函数
def getHostsitemsid(hostid,itemsname,url,auth):
    values = {'jsonrpc': '2.0',
              'method': "item.get",
              "params": {
                    "output": ["itemids"],
                    "hostids": hostid,
            "filter":{
                    "key_": itemsname,
                },
                },

              'auth': auth,
              'id': ''
              }
    output = requestJson(url,values)
    if len(output)==0:
        return output
    else:
        return output[0]['itemid']

#定义通过项目id获取监控项目最近值信息的函数
def getHostsitemsvalue(itemid,url,auth):
    values = {'jsonrpc': '2.0',
              'method': "history.get",
              "params": {
                    "output": "extend",
                    "history":3,
                    "itemids":itemid,
                    "sortfield": "clock",
                    "sortorder": "DESC",
                    "limit":1,
                },

              'auth': auth,
              'id': ''
              }
    output = requestJson(url,values)
    if len(output)==0:
        return output
    else:
        return output[0]["value"]

#定义更新读取状态action函数
def mediatypeget(mediatypeid,auth):
    values = {'jsonrpc': '2.0',
              'method': 'mediatype.get',
              'params': {
                "output": "extend",

              "filter": {
                        "mediatypeid":mediatypeid,
                         },
              },

              'auth': auth,
              'id': ''
              }
    output = requestJson(url,values)
    if len(output)==0:
        return output
    else:
        return output[0]['status']

#定义maintenance维修模式host函数
def maintenancecreate(maintenancename,active_since,active_till,hostid,auth):
    values = {'jsonrpc': '2.0',
              'method': 'maintenance.create',
              'params': {
              "name": maintenancename,
              "active_since": active_since,
              "active_till": active_till,
              "hostids": [
                    hostid
                ],
                "timeperiods": [
                            {
                "timeperiod_type": 0,
                "every": 1,
                "dayofweek": 64,
                "start_time": 64800,
                "period": 3600
                            }
                                ]
              },
              'auth': auth,
              'id': ''
              }
    output = requestJson(url,values)

#定义通过模糊获取关闭主机信息函数
def disabledhostget(url,auth):
    values = {'jsonrpc': '2.0',
              'method': 'host.get',
            "params": {
                "output": ["host"],
                'selectInterfaces': [ "ip" ],
                "filter": {
                    "status":1
        }
    },
              'auth': auth,
              'id': ''
              }
    output = requestJson(url,values)
    return output

#定义maintenance维修模式group函数
def maintenancecreategroup(maintenancename,active_since,active_till,groupid,auth):
    values = {'jsonrpc': '2.0',
              'method': 'maintenance.create',
              'params': {
              "name": maintenancename,
              "active_since": active_since,
              "active_till": active_till,
              "groupids": [
                    groupid
                ],
                "timeperiods": [
                            {
                "timeperiod_type": 0,
                "every": 1,
                "dayofweek": 64,
                "start_time": 64800,
                "period": 3600
                            }
                                ]
              },
              'auth': auth,
              'id': ''
              }
    output = requestJson(url,values)

#定义通过host groups named 获取groupid
def groupnameGroupid(groupname,auth):
    values = {'jsonrpc': '2.0',
              'method': 'hostgroup.get',
              "params": {
                    "output": "extend",
                    "filter": {
                        "name": [
                            groupname
                        ]
                    }
                },
              'auth': auth,
              'id': ''
              }
    output = requestJson(url,values)
    return output

#定义模糊查询维护主机
def maintenanceget(url,auth):
    values = {'jsonrpc': '2.0',
              'method': 'maintenance.get',
              "params": {
                    "output": "extend",
                },
              'auth': auth,
              'id': ''
              }
    output = requestJson(url,values)
    return output

#定义批量恢复处于维护主机
def maintenancedelete(maintenanceid,url,auth):
    values = {'jsonrpc': '2.0',
              'method': 'maintenance.delete',
              "params": [
                    maintenanceid
                ],
              'auth': auth,
              'id': ''
              }
    output = requestJson(url,values)
    return output

#定义通过hostid获取graphid的函数
def getgraphid(hostid,graphname,url,auth):
        values = {'jsonrpc': '2.0',
                          'method': 'graph.get',
                          'params': {
                                  "output": "name",
                                  "hostids": hostid,
                                  "sortfield": "name",
                          'filter': {
                                        "name": graphname
                                  },

                          },
                          'auth': auth,
                          'id': ''
                          }
        output = requestJson(url,values)
        return output

# 调用:
#!/usr/bin/env python
#coding=utf-8
import urllib2
import sys
import json
import argparse
from login import *
from function import *
#登陆zabbix获取auth
auth = authenticate(url, username, password)
#状态0是启用监控，1是禁用监控
status=1
#定义操作ip
hostip='192.168.1.100'
#通过hostip获取zabbix hostid
hostids=ipgetHostsid(hostip,url,auth)
hostid=hostids[0]['hostid']
#通过主机id开启关闭监控
idupdatehost(status,hostid,url,auth)