from pyzabbix import ZabbixAPI, ZabbixAPIException
import json
srczaburl = "http://localhost:8080"
srczabuser = '******'
srczabpass = '******'
dstzaburl = "http://localhost:9080"
dstzabuser = '******'
dstzabpass = '******'
srczapi = ZabbixAPI(srczaburl)
srczapi.login(srczabuser,
srczabpass)
dstzapi = ZabbixAPI(dstzaburl)
dstzapi.login(dstzabuser,
dstzabpass)
def usergroups_import():
with open('usergroups.json', 'r') as f:
usergroups = json.loads(f.read())
for usergroup in usergroups:
usergroup.pop('usrgrpid')
try:
res = dstzapi.usergroup.create(usergroup)
except ZabbixAPIException as e:
print(str(e))
else:
print('Group {0} created with group id {1}'.format(usergroup['name'], res['usrgrpids'][0]))
from pprint import pprint
from pyzabbix import ZabbixAPI, ZabbixAPIException
SERVER_ZABBIX = 'http://192.168.33.65/zabbix'
LOGIN_ZABBIX = 'kolas'
PASSWORD_ZABBIX = ''
z = ZabbixAPI(SERVER_ZABBIX)
z.login(user=LOGIN_ZABBIX, password=PASSWORD_ZABBIX)
def add_template_on_group(template_id, group_id):
icmp_ping = "10104"
dude_not_addaed_hosts = "37"
try:
response = z.do_request(method="template.massadd",
params={
"templates": [{
"templateid": template_id
}],
"groups": [{
"groupid": group_id
}]
})
pprint(response)
except ZabbixAPIException as e:
print(e)
def add_template_on_host():
try:
from pyzabbix import ZabbixAPI
import smtplib
ip = 'SomeIP/zabbix'
user = '******'
password = '******'
from_address = example @ zabbix.com
to_addresses = ["*****@*****.**", "*****@*****.**"]
zAPI = ZabbixAPI(ip, user, password)
hosts = zAPI.host.get(monitored_hosts=1, ouput='extend')
message = "To:"
message += ",".join(str(x) for x in to_addresses)
message += "\nSubject: Health Report \n"
message += "Hostname \tError \n"
for host in hosts:
message += host["host"] + "\t" + host["error"] + "\n"
mail = smtplib.SMTP()
mail.connect()
mail.sendmail(from_address, to_addresses, message)
mail.close()
def login():
zapi = ZabbixAPI("https://zmonitor.ut.ac.ir")
# zapi.session.verify = False
zapi.login("ririlinux", "ririlinux")
return zapi
def login(self):
ZABBIX_SERVER = 'http://%s:%s%s' % (self.ip, self.port, self.url)
zapi = ZabbixAPI(ZABBIX_SERVER)
zapi.login(self.username, self.password)
return zapi
# -*- coding: utf-8 -*-
from pyzabbix import ZabbixAPI
import pyzabbix
import csv
from autenticacao import credencial
zabbix_server,usuario,senha = credencial()
zapi = ZabbixAPI(zabbix_server)
zapi.login(user=usuario, password=senha)
arq = csv.reader(open('hosts.csv'))
f = csv.reader(open('hosts.csv'), delimiter=',')
for [hostname,ip] in f:
try:
hostcriado = zapi.host.create(
host= hostname,
status= 1,
interfaces=[{
"type": 1,
"main": "1",
"useip": 1,
"ip": ip,
"dns": "",
"port": 10050
}],
groups=[{
"groupid": 2
}],
templates=[{
def login(ZABBIX_SERVER, USER, PASSWORD):
zapi = ZabbixAPI(ZABBIX_SERVER)
zapi.login(USER, PASSWORD)
return zapi
# import logging
# import sys
import time
from pyzabbix import ZabbixAPI
# 开启调试 Enable debugging
# stream = logging.StreamHandler(sys.stdout)
# stream.setLevel(logging.DEBUG)
# log = logging.getLogger('pyzabbix')
# log.addHandler(stream)
# log.setLevel(logging.DEBUG)
# 登录 Zabbix API login
zapi = ZabbixAPI("http://10.10.10.10/zabbix/")
zapi.login("user_name", "user_pass")
# 定义获取历史数据的时间数组 timestamp array
# 1.获取当天24个整点的时间
# retrieve_times = []
# day_time = int(time.time()) - int(time.time()) % 86400 + time.timezone
# for oclock in range(1, 25):
# retrieve_times.append(day_time)
# day_time += 3600
# 2.获取当前时间的历史数据，配合计划任务定时执行，提前3分钟以免zabbix还没有获取数据 3 minutes before current time
retrieve_times = [int(time.time()) - 180]
# 获取所有主机列表：retrieve all hosts
import traceback
from pyzabbix import ZabbixAPI, ZabbixAPIException
from pprint import pprint
parser = argparse.ArgumentParser()
parser.add_argument('--server', help='Zabbix server FQDN, used to build the API URL', required=True)
parser.add_argument('--password', help='Password')
args = parser.parse_args()
_url = 'http://' + args.server
if not args.password:
args.password = getpass()
logger.info("Create account / set password")
try:
zapi = ZabbixAPI(url=_url, user='******', password='******')
zapi.do_request('user.update', {
'userid': '1',
'passwd': args.password
})
except ZabbixAPIException, e:
if e[1] == -32602:
pass
else:
raise
zapi = ZabbixAPI(url=_url, user='******', password=args.password)
logger.info("Set Zabbix server's agent host correctly")
hosts = zapi.do_request('host.get', {
'output': ['hostid'],
import getpass
import sys
import time
from pyzabbix import ZabbixAPI
from datetime import datetime
import pandas as pd
import sqlalchemy
import requests
username = ""
pas = getpass.getpass()
# calling zabbix api for connection
zapi = ZabbixAPI("http://10.103.6.15", user=username, password=pas)
print("Connected to Zabbix API Version %s" % zapi.api_version())
# giving time frame for fetching data
time_till = time.mktime(datetime.now().timetuple())
time_from = time_till - 60 * 60 * 1 # 1 hours
hostname = []
hostid = []
# get all hosts from the SQL servers group
hosts = zapi.hostgroup.get(groupids='16', selectHosts="extend")
# creating list for hostname and hostid
for h in hosts:
data = h["hosts"]
for i in data:
hostname.append(i["name"])
args = parser.parse_args()
print("\n\nEntered arguments are(including defaults):\n")
print(args)
#wait for 2 seconds for user to read prompts.
t.sleep(1)
#check if needed modules exist on working machine
# --------------------- END ---------------
# PART 1
#zabbix server url
zapi = ZabbixAPI(args.url)
#zabbix creds
zapi.login(args.u, args.p)
#connection verify
print("Connected to Zabbix API Version %s" % zapi.api_version())
#variables for arima parameters and aic function value
global param_temp
global time
global aic_temp
global mse_temp
global range_temp
range_temp = args.r
#filename concatenated with execution time to eliminate confusion
from pyzabbix import ZabbixAPI
zapi = ZabbixAPI("http://localhost:8080/zabbix")
zapi.login("Admin", "zabbix")
print("Connected to Zabbix API Version %s" % zapi.api_version())
for h in zapi.host.get(output="extend"):
print(h['hostid'])
# built-in
from json import loads
# external
from grab import Grab
from pyzabbix import ZabbixAPI
# project
import config
g = Grab()
zapi = ZabbixAPI(config.ZABBIX_SERVER)
zapi.login(config.ZABBIX_LOGIN, config.ZABBIX_PASSWORD)
# Host group
groups = zapi.hostgroup.get()
for group in groups:
if group['name'] == config.HOST_GROUP_NAME:
print('Host group {} already added'.format(group['name']))
group_id = group['groupid']
break
else:
group = zapi.hostgroup.create(name=config.HOST_GROUP_NAME)
print('Created host group {}'.format(config.HOST_GROUP_NAME))
group_id = group['groupids'][0]
print()
# Hosts
hosts = zapi.host.get(groupids=[group_id])
hostnames = [host['host'] for host in hosts]
for check in config.HEALTHCHECKS:
if check.name in hostnames:
def __init__(self):
self.zapi = ZabbixAPI(config.zabbix_uri)
#!/usr/bin/python3
# coding: utf8
from pyzabbix import ZabbixAPI, ZabbixAPIException
import sys
import json
zbxurl = 'http://monitoring'
zbxname = 'api-scripts'
zbxpass = '******'
z = ZabbixAPI(zbxurl)
z.login(zbxname, zbxpass)
groupname = sys.argv[1]
param = sys.argv[2]
step = sys.argv[3] if len(sys.argv) >= 4 else 'none'
def list():
groups = z.hostgroup.get(output=['itemid', 'name'])
for i in groups:
if i['name'] == groupname:
groupid = i['groupid']
hosts = z.host.get(groupids=groupid, output=['hostid', 'name'])
host = hosts[0]
hid = host['hostid']
items = z.item.get(hostids=hid, output=['hostid', 'name'])
jsonData = []
for i in items:
from pyzabbix import ZabbixAPI
api = ZabbixAPI ("http://127.0.0.1")
api.login("Admin", "zabbix")
hostgroup = api.hostgroup.create(
{"name": "CarryOn Tech 2"}
)
print (hostgroup)
# Connect to LDAP server
logger.debug(f'Connecting to LDAP: {LDAP_SRV} with user {LDAP_USER}')
try:
ldap_conn = ldap_connect(LDAP_SRV, LDAP_USER, LDAP_PASS)
logger.debug(
f'Connected to {ldap_conn.server.host}:{ldap_conn.server.port}')
except LDAPBindError:
logger.critical(
f'Cannot bind to LDAP server {LDAP_SRV} with given user and password'
)
raise SystemExit()
# Connect to Zabbix API
logger.debug(
f'Connecting to Zabbix API: {ZBX_API_URL} with user {ZBX_USER}')
zapi = ZabbixAPI(ZBX_API_URL)
logger.debug(f'Zabbix API: Verify SSL certificate - {ZBX_API_VERIFY_SSL}')
zapi.session.verify = ZBX_API_VERIFY_SSL
try:
zapi.login(ZBX_USER, ZBX_PASS)
logger.debug(f'Connected to Zabbix API {zapi.api_version()}')
except ZabbixAPIException as e:
logger.critical(
f'Cannot connect to Zabbix API with user {ZBX_USER}: {e.error["data"]}'
)
raise SystemExit(
f'Cannot connect to Zabbix API with user {ZBX_USER}: {e.error["data"]}'
)
# Define params depends on Zabbix API version
ZAPI_VERSION = int(''.join(zapi.api_version().split('.')[0:2]))
ZUSER_TYPE_PROPERTY = 'type' if ZAPI_VERSION < 54 else 'roleid'
"""Calls tk to create a file dialog that asks the user where they want to place the file."""
# If root.withdraw() is added, window is only accessible by alt-tab.
root = tk.Tk()
return filedialog.asksaveasfilename(initialdir='C:/', defaultextension='.csv',
initialfile='Inventory ' + str(datetime.date.today()),
filetypes=(("Comma Separated Values",'*.csv'),("All Files", '*.*')))
if __name__ == '__main__':
retries = 4
while retries >= 0:
serverip = input("URL of zabbix server:")
if validateserver(serverip):
timeout = 3.5
try:
z = ZabbixAPI(str(serverip), timeout=timeout)
except ZabbixAPIException as e:
print(e)
if initializeapi():
break
elif retries > 0:
retries -= 1
else:
print("Too many failed attempts.")
sys.exit(2)
list1 = []
dict1 = {}
getinventory(list1)
gethostdict(dict1)
hostchange(list1, dict1)
writecsv(list1)
# python script to make 'server.json' for geofront configuration
# server.json format:
# {"HOSTNAME": {"account": "USERNAME", "ip": "IP", "group": "GROUPNAME"}}
from pyzabbix import ZabbixAPI
import json
import os
# zabbix API set up
zapi = ZabbixAPI("https://localhost", user="******", password="******")
#zapi.session.auth = ('Admin', 'PASS')
#zapi.session.verify = False
#zapi.login("Admin", "PASS")
# get zabbix hostgroup ids
itemlist = zapi.hostgroup.get(output='extend')
groupids = dict()
for item in itemlist:
groupids.update({item['groupid']: item['name']})
# dictionary for 'server.json'
d = dict()
# excluded zabbix hostgroups that has no availability of ZBX on configuration
excludes = ['SOME SERVERS', 'ETC']
# get hosts
for gid in groupids:
if groupids.get(gid) not in excludes:
itemlist = zapi.host.get(groupids=gid, output='extend')
for item in itemlist:
def setup(hass, config):
"""Set up the Zabbix component."""
conf = config[DOMAIN]
protocol = "https" if conf[CONF_SSL] else "http"
url = urljoin(f"{protocol}://{conf[CONF_HOST]}", conf[CONF_PATH])
username = conf.get(CONF_USERNAME)
password = conf.get(CONF_PASSWORD)
publish_states_host = conf.get(CONF_PUBLISH_STATES_HOST)
entities_filter = convert_include_exclude_filter(conf)
try:
zapi = ZabbixAPI(url=url, user=username, password=password)
_LOGGER.info("Connected to Zabbix API Version %s", zapi.api_version())
except ZabbixAPIException as login_exception:
_LOGGER.error("Unable to login to the Zabbix API: %s", login_exception)
return False
except HTTPError as http_error:
_LOGGER.error("HTTPError when connecting to Zabbix API: %s",
http_error)
zapi = None
_LOGGER.error(RETRY_MESSAGE, http_error)
event_helper.call_later(hass, RETRY_INTERVAL,
lambda _: setup(hass, config))
return True
hass.data[DOMAIN] = zapi
def event_to_metrics(event, float_keys, string_keys):
"""Add an event to the outgoing Zabbix list."""
state = event.data.get("new_state")
if state is None or state.state in (STATE_UNKNOWN, "",
STATE_UNAVAILABLE):
return
entity_id = state.entity_id
if not entities_filter(entity_id):
return
floats = {}
strings = {}
try:
_state_as_value = float(state.state)
floats[entity_id] = _state_as_value
except ValueError:
try:
_state_as_value = float(state_helper.state_as_number(state))
floats[entity_id] = _state_as_value
except ValueError:
strings[entity_id] = state.state
for key, value in state.attributes.items():
# For each value we try to cast it as float
# But if we can not do it we store the value
# as string
attribute_id = f"{entity_id}/{key}"
try:
float_value = float(value)
except (ValueError, TypeError):
float_value = None
if float_value is None or not math.isfinite(float_value):
strings[attribute_id] = str(value)
else:
floats[attribute_id] = float_value
metrics = []
float_keys_count = len(float_keys)
float_keys.update(floats)
if len(float_keys) != float_keys_count:
floats_discovery = []
for float_key in float_keys:
floats_discovery.append({"{#KEY}": float_key})
metric = ZabbixMetric(
publish_states_host,
"homeassistant.floats_discovery",
json.dumps(floats_discovery),
)
metrics.append(metric)
for key, value in floats.items():
metric = ZabbixMetric(publish_states_host,
f"homeassistant.float[{key}]", value)
metrics.append(metric)
string_keys.update(strings)
return metrics
if publish_states_host:
zabbix_sender = ZabbixSender(zabbix_server=conf[CONF_HOST])
instance = ZabbixThread(hass, zabbix_sender, event_to_metrics)
instance.setup(hass)
return True
args = parser.parse_args()
fake = args.fake
LOGFILE = '/tmp/zbx_discovery-manager.log'
logger = LogPrint(echo=args.verbose,
logfile=LOGFILE,
loglevel=args.loglevel.upper())
loglevels = {
'CRITICAL': 50,
'ERROR': 40,
'WARNING': 30,
'INFO': 20,
'DEBUG': 10
}
try:
zapi = ZabbixAPI(args.url, timeout=TIMEOUT)
zapi.login(args.user, args.password)
except Exception, e:
logger.error('Unable to login: {0}'.format(e))
exit(1)
# CUSTOM FUNCTIONS
def discovery_checks():
"""
retornar o formato json com os discovery checks
essa entrada eh manual
"""
dchecks = [
{
'uniq': '1',
def __init__(self, url, user, password):
self.url = url
self.user = user
self.password = password
self.client = ZabbixAPI(url=url, user=user, password=password)
if args.no_verify:
noverify = args.no_verify
# test for needed params
if not username:
sys.exit("Error: API User not set")
if not password:
sys.exit("Error: API Password not set")
if not api:
sys.exit("Error: API URL is not set")
# Setup Zabbix API connection
zapi = ZabbixAPI(api)
if noverify is True:
zapi.session.verify = False
# Login to the Zabbix API
zapi.login(username, password)
##################################
# Start actual API logic
##################################
if args.hostgroups:
if args.numeric:
# We are getting numeric hostgroup ID's, let put them in a list
# (ignore any non digit items)
from pyzabbix import ZabbixAPI
zapi = ZabbixAPI('http://192.168.33.77/zabbix')
zapi.login('admin', 'zabbix')
print zapi.id, zapi.auth
"jsonrpc": "2.0",
"method": "user.create",
"params": {
"alias": user,
"passwd": password,
"type": "3",
"usrgrps": [{
"usrgrpid": "7"
}],
},
"auth": zbx_sessionid,
"id": 1
}
answer = requests.post(url, data=json.dumps(data), headers=headers)
print(answer)
response = answer.json()
print(response)
print("testing user parameters:")
zapi = ZabbixAPI(api_address)
zapi.login(user, password)
print("Connected to Zabbix API Version %s" % zapi.api_version())
# data = {"jsonrpc": "2.0", "method": "user.login", "params": {
# "user": user, "passwd": password },
# "auth": None,
# "id": 1
# }
# answer = requests.post(url, data=json.dumps(data), headers=headers)
# print(answer)
# response = answer.json()
# print(response)
def __init__(self, url, user, password):
self.api = ZabbixAPI(url)
self.user = user
self.password = password
import os
import json
import string
from pyzabbix import ZabbixAPI
from pprint import pprint
#import credentials from external file
import sys
sys.path.insert(0, '/var/lib/zabbix')
import config
# The hostname at which the Zabbix web interface is available
ZABBIX_SERVER = config.url
zapi = ZabbixAPI(ZABBIX_SERVER)
# Login to the Zabbix API
zapi.login(config.username, config.password)
# define the API call from
# https://www.zabbix.com/documentation/3.4/manual/api/reference/maintenance/create
# define the methon
#def create_maintenance(zbx, request):
for host in zapi.item.get(output='extend',
search={'key_': 'system.objectid'},
sortfield='name'):
#print host['hostid']
print host['lastvalue']
# pprint(host)
except Exception as e:
logging.info('Exception: {}'.format(e))
return False
triggered_host = sys.argv[1]
trigger_id = sys.argv[2]
event_id = sys.argv[3]
logging.info('Getting Started with the event: {}/tr_events.php?triggerid={}&eventid={}'
.format(c.zbx_url, trigger_id, event_id))
try:
zapi = ZabbixAPI(c.zbx_url, timeout=10)
zapi.session.verify = c.zbx_verify_ssl_certs
zapi.login(c.zbx_user, c.zbx_pass)
logging.info('Connected to Zabbix API v.{}'.format(zapi.api_version()))
except Exception as e:
logging.info('Error: Can\'t connect to Zabbix API. Exception: {}'.format(e))
exit(1)
try:
ack = zapi.event.get(eventids=event_id, select_acknowledges=['alias', 'message'], output=['alias', 'message'])
ack_alias = ack[0]['acknowledges'][0]['alias']
if ack_alias != c.acknowledge_user:
logging.info('Not trusted user in acknowledge: {}.\nSkipping this request to fix.'.format(ack_alias))
exit(0)
tg = zapi.trigger.get(triggerids=trigger_id, output='extend')[0]
#!/usr/bin/python
#coding:utf8
from pyzabbix import ZabbixAPI
zapi = ZabbixAPI('http://update.winupon.com/zabbix/')
zapi.login('shenzm', 'shenzm')
def create_zabbix_hostgroup(group_name):
r = zapi.do_request(method='hostgroup.create', params={'name': group_name})
return r['result']['groupids']
def create_zabbix_host(hosts, ips, group_name):
groupid = create_zabbix_hostgroup(group_name)
for i in range(len(hosts)):
host_params = {'groups': [{'groupid': int(groupid)}],
'host': hosts[i],
'proxy_hostid': '11131',
'interfaces': [{'dns': '',
'ip': ips[i],
'main': 1,
'port': '10050',
'type': 1,
'useip': 1}],
'templates': [{'templateid': '10001'}]}
r = zapi.do_request(method='host.create', params=host_params)
print r
if __name__ == '__main__':
hosts = ['sc_phy_etohdb1', 'sc_phy_etohdb2', 'sc_phy_etohhisdb1', 'sc_phy_etohhisdb2', 'sc_phy_etoh_s_db', 'HeJiaoYu_APP_L09',
'HeJiaoYu_APP_L10', 'HeJiaoYu_APP_L11', 'HeJiaoYu_APP_L12', 'HeJiaoYu_APP_L13', 'HeJiaoYu_APP_L14', 'HeJiaoYu_APP_L15',
'HeJiaoYu_APP_L16', 'HeJiaoYu_Monitor_L01', 'HeJiaoYu_FILE_L01', 'HeJiaoYu_FILE_L02', 'HeJiaoYu_backup_L01']
def __init__(self):
self.zapi = ZabbixAPI(zabbix_server)
self.zapi.login(zabbix_username, zabbix_password)
