saltstack操作zabbix的一个小模块

最新推荐文章于 2021-08-06 15:17:59 发布
最新推荐文章于 2021-08-06 15:17:59 发布
阅读量310 收藏
点赞数
分类专栏： saltstack 文章标签： saltstack zabbix python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangmingfei/article/details/84652652
版权

需求：
自动化扩容期间，想给通过saltstack将主机自动加入SOA组，自动添加JMX（监控jvm）模板；
期间没有记录模块执行日志，而是使用golang和lua的处理方式，将错误直接返回；
另外实现的功能非常少，主要是注释比较多

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Create from 2018/11/05

import subprocess
import json
import requests
#import salt.utils
from salt.exceptions import CommandExecutionError

__virtualname__ = "zabbix_modify"

class zabbix_check():
    def __init__(self,template=None,group=None):
        self.user = "devops"
        self.password = "1234567890"
        self.zabbix_url = "http://1.2.3.4/api_jsonrpc.php"
        self.zabbix_header = {"Content-Type": "application/json"}
        if group:
            self.zabbix_group_name = group
        else:
            self.zabbix_group_name = "SOA"
        if template:
            self.zabbix_template_name = template
        else:
            self.zabbix_template_name = "JMX"
        self.zabbix_etc = "/usr/local/services/zabbix-3.0.0/etc/zabbix_agentd.conf"

    def _get_hostname(self):
        """
        用系统命令获取zabbix的Hostname
        """
        cmd = "grep ^Hostname %s | awk -F'=' '{print $2}'" % self.zabbix_etc
        ret = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        ret.wait()
        if ret.returncode == 0:
            return ret.stdout.read(),None
        else:
            return None,ret.stderr.read()

    def _get_test_return(self,res):
        """
        统一进行 临时测试/验证 数据返回,一般用于zabbix api的get相关方法,直接回复ret["result"]进行测试
        """
        if res.status_code == 200:
            ret = res.json()
            if "result" in ret.keys():
                return ret["result"]
            else:
                return None,"发生错误: {1}".format(ret['error'])
        else:
            return None,"结果非200!"

    def _get_return(self,res,keywords):
        """
        统一进行数据返回,一般用于zabbix api的get相关方法
        """
        if res.status_code == 200:
            ret = res.json()
            if "result" in ret.keys():
                if keywords in ret['result'][0].keys():
                    return ret['result'][0][keywords],None
                else:
                    return None,"zabbix-server上没有{0}相关信息".format(keywords)
            else:
                return None,"获取{0}发生错误: {1}".format(keywords,ret['error'])
        else:
            return None,"获取{0}结果非200!".format(keywords)

    def _update_return(self,res,keywords,ext_keywords=None):
        """
        统一进行结果验证,一般用于zabbix api的update相关方法
        """
        if res.status_code == 200:
            ret = res.json()
            if "result" in ret.keys():
                if keywords in ret['result']:
                    return ret['result'][keywords],None
                else:
                    return None,"更新zabbix-server上{0}.{1}相关信息".format(keywords,ext_keywords)
            else:
                return None,"更新{0}.{1}发生错误: {2}".format(keywords,ext_keywords,ret['error'])
        else:
            return None,"更新{0}.{1}结果非200!".format(keywords,ext_keywords)

    def _get_sessionid(self):
        """
        获得访问zabbix的session,在这一步抓捕网络连接异常,剩下的与zabbix api交互中忽略了网络异常的处理
        """
        data = {
            "jsonrpc": "2.0",
            "method": "user.login",
            "params": {
                "user": self.user,
                "password": self.password
            },
            "id": 0
        }
        try:
            res = requests.post(url=self.zabbix_url, headers=self.zabbix_header, data=json.dumps(data))
        except Exception as e:
            return None,"Connection Error: {0}".format(e)

        # 这个结果单独处理了
        if res.status_code == 200:
            if "result" in res.json().keys():
                return eval(str(res.text))['result'],None
            else:
                return None,"获取session id失败!"
        else:
            return None,"获取zabbix session_id结果非200!"

    def _get_hosid(self,hostname,session_id):
        """
        判断此主机是否存在于zabbi-server上,存在就返回hostid
        Request:
        {
            "jsonrpc": "2.0",
            "method": "host.get",
            "params": {
                "output": ["hostid"],
                "filter": {
                    "host": [
                        "Zabbix server"
                    ]
                }
            },
            "auth": "038e1d7b1735c6a5436ee9eae095879e",
            "id": 1
        }

        Response:
        {
            "jsonrpc": "2.0",
            "result": [{
                    "hostid": "10160"
            },]
            "id": 1
        }
        """
        data = {
            "jsonrpc": "2.0",
            "method": "host.get",
            "params": {
                "output": ["hostid"],
                "filter": {
                    "host": [hostname]
                }
            },
            "auth": session_id,
            "id": 1}

        res = requests.post(url=self.zabbix_url, headers=self.zabbix_header, data=json.dumps(data))
        return self._get_return(res,"hostid")

    def _get_groupid(self,session_id):
        """
        返回某个特定group的id
        Request:
        {
            "jsonrpc": "2.0",
            "method": "hostgroup.get",
            "params": {
                "output": "extend",
                "filter": {
                    "name": [
                        "Zabbix servers",
                        "Linux servers"
                    ]
                }
            },
            "auth": "6f38cddc44cfbb6c1bd186f9a220b5a0",
            "id": 1
        }

        Response:
        {
            "jsonrpc": "2.0",
            "result": [
                {
                    "groupid": "2",
                    "name": "Linux servers",
                    "internal": "0"
                },
                {
                    "groupid": "4",
                    "name": "Zabbix servers",
                    "internal": "0"
                }
            ],
            "id": 1
        }
        """
        data = {
            "jsonrpc": "2.0",
            "method": "hostgroup.get",
            "params": {
                "output": ["groupid"],
                "filter": {
                    "name": [self.zabbix_group_name]
                }
            },
            "auth": session_id,
            "id": 0}
        res = requests.post(url=self.zabbix_url, headers=self.zabbix_header, data=json.dumps(data))
        return self._get_return(res,"groupid")

    def _get_templateid(self,session_id):
        """
        返回指定template的id
        {
            "jsonrpc": "2.0",
            "method": "template.get",
            "params": {
                "output": ["templateid"],
                "filter": {
                    "host": [
                        "Template OS Linux",
                        "Template OS Windows"
                    ]
                }
            },
            "auth": "038e1d7b1735c6a5436ee9eae095879e",
            "id": 1
        }

        Response:
        {
            "jsonrpc": "2.0",
            "result": [
                {
                    "templateid": "10001"
                },
                {
                    "templateid": "10081",
                }
            ],
            "id": 1
        }
        """
        data = {
            "jsonrpc": "2.0",
            "method": "template.get",
            "params": {
                "output": ["templateid"],
                "filter": {
                    "host": [self.zabbix_template_name]
                    }
            },
            "auth": session_id,
            "id": 0
        }
        res = requests.post(url=self.zabbix_url, headers=self.zabbix_header, data=json.dumps(data))
        return self._get_return(res,"templateid")

    def _get_groups(self,session_id,hostid):
        """
        返回指定主机所属的所有groups id
        Request:
        {
            "jsonrpc": "2.0",
            "method": "host.get",
            "params": {
                "output": ["groupid"],
                "selectGroups": ["groupid"],
                "hostids": "10084"
            },
            "auth": "038e1d7b1735c6a5436ee9eae095879e",
            "id": 2
        }

        Response:
        {
            "jsonrpc": "2.0",
            "result": [
                {
                    "hostid": "10085",
                    "groups": [  #注意,groups的值是一个列表,列表下的元素是字典
                        {
                            "groupid": "2",
                        },
                        {
                            "groupid": "4",
                        }
                    ]
                }
            ],
            "id": 2
        }
        """
        data = {
            "jsonrpc": "2.0",
            "method": "host.get",
            "params": {
                "output": ["hostid"],
                "selectGroups": ["groupid"],
                "hostids": hostid
            },
            "auth": session_id,
            "id": 2
        }
        res = requests.post(url=self.zabbix_url, headers=self.zabbix_header, data=json.dumps(data))
        return self._get_return(res,"groups")

    def _get_templates(self,session_id,hostid):
        """
        返回主机关联的所有template id
        Request:
        {
            "jsonrpc": "2.0",
            "method": "host.get",
            "params": {
                "output": ["hostid"],
                "selectParentTemplates": ["templateid"],
                "hostids": "10084"
            },
            "id": 1,
            "auth": "70785d2b494a7302309b48afcdb3a401"
        }

        Response:
        {
            "jsonrpc": "2.0",
            "result": [
                {
                    "hostid": "10084",
                    "parentTemplates": [
                        {
                            "templateid": "10001"
                        },
                        {
                            "templateid": "10047"
                        }
                    ]
                }
            ],
            "id": 1
        }
        """
        data = {
            "jsonrpc": "2.0",
            "method": "host.get",
            "params": {
                "output": ["hostid"],
                "selectParentTemplates": ["templateid"],
                "hostids": hostid
            },
            "auth": session_id,
            "id": 2
        }
        res = requests.post(url=self.zabbix_url, headers=self.zabbix_header, data=json.dumps(data))
        return self._get_return(res,"parentTemplates")

    def _update_groups(self,session_id,hostid,groups):
        """
        注意: 这里的groups还是一个列表,列表的元素是字典,字典只有一个键值对,键是"groupid"
        更新主机所属的组
        {
            "jsonrpc": "2.0",
            "method": "host.update",
            "params": {
                "hostid": "10126",
                "groups": [
                    {
                        "groupid": "10124"
                    },
                ]
            },
            "auth": "038e1d7b1735c6a5436ee9eae095879e",
            "id": 1
        }

        结果:
        {
            "jsonrpc": "2.0",
            "result": {
                "hostids": [
                    "10126"
                ]
            },
            "id": 1
        }
        判断里面是否有"hostids"
        """
        data = {
            "jsonrpc": "2.0",
            "method": "host.update",
            "params": {
                "hostid": hostid,
                "groups": groups
            },
            "auth": session_id,
            "id": 1
        }
        res = requests.post(url=self.zabbix_url, headers=self.zabbix_header, data=json.dumps(data))
        return self._update_return(res,"hostids","groups")

    def _update_templates(self,session_id,hostid,templates,operate):
        """
        给主机添加template,注意,templates其实是替换,类似groups,这里templates仍然是一个列表,统一进行更新或者clear template
        涉及到update,一定要小心,必须验证
        Request:
        {
            "jsonrpc": "2.0",
            "method": "host.update",
            "params": {
                "hostid": "10126",
                "templates": [
                    {
                        "templateid": "10124"
                    },
                    {
                        "templateid": "10125"
                    }
                ]
            },
            "auth": "038e1d7b1735c6a5436ee9eae095879e",
            "id": 1
        }

        Response:
        {
            "jsonrpc": "2.0",
            "result": {
                "hostids": [
                    "10126"
                ]
            },
            "id": 1
        }

        """
        if operate == "add":
            operation = "templates"
        else:
            operation = "templates_clear"
        data = {
            "jsonrpc": "2.0",
            "method": "host.update",
            "params": {
                "hostid": hostid,
                operation: templates
            },
            "auth": session_id,
            "id": 1
        }
        res = requests.post(url=self.zabbix_url, headers=self.zabbix_header, data=json.dumps(data))
        return self._update_return(res,"hostids","templates")

    def add_group(self):
        zabagent_hostname, err = self._get_hostname()
        if err:
            raise CommandExecutionError("无法获取本机zabbix-agent的hostname: {0}".format(err))
            #print("无法获取本机zabbix-agent的hostname: {0}".format(err))
        else:
            zabagent_hostname = zabagent_hostname.strip("\n")

        zabbix_session, err = self._get_sessionid()
        if err:
            raise CommandExecutionError(err)
            #print(err)

        host_id,err = self._get_hosid(zabagent_hostname,zabbix_session)
        if err:
            raise CommandExecutionError(err)
            # print(host_id_err)

        # 判断是否在soa主机组里面,如果不在,添加
        target_groupid, err = self._get_groupid(zabbix_session)
        if err:
            raise CommandExecutionError(err)
            #print(err)
        groups,err = self._get_groups(zabbix_session,host_id)
        if err:
            raise CommandExecutionError(err)
            #print(err)
        groups_list = [id["groupid"] for id in groups]
        if target_groupid not in groups_list:
            groups.append({"groupid": target_groupid})
            update_groups_ret,err = self._update_groups(zabbix_session,host_id,groups)
            if err:
                raise CommandExecutionError(err)
                #print(err)
            else:
                return "success: 当前主机{0}加入{1}组内成功".format(zabagent_hostname,self.zabbix_group_name)
        else:
            return "success: 当前主机{0}已经在{1}组内,不需添加".format(zabagent_hostname,self.zabbix_group_name)

    def _template_common(self,operate):
        zabagent_hostname, err = self._get_hostname()
        if err:
            raise CommandExecutionError("无法获取本机zabbix-agent的hostname: {0}".format(err))
            #print("无法获取本机zabbix-agent的hostname: {0}".format(err))
        else:
            zabagent_hostname = zabagent_hostname.strip("\n")

        zabbix_session, err = self._get_sessionid()
        if err:
            raise CommandExecutionError(err)
            #print(err)

        host_id,err = self._get_hosid(zabagent_hostname,zabbix_session)
        if err:
            raise CommandExecutionError(err)
            # print(host_id_err)

        # 判断是否在关联了目标监控模板,如果没有,则关联
        target_templateid,err = self._get_templateid(zabbix_session)
        if err:
            raise CommandExecutionError(err)
            #print(err)
        templates,err = self._get_templates(zabbix_session,host_id)
        if err:
            raise CommandExecutionError(err)
            #print(err)
        templates_list = [template["templateid"] for template in templates]
        if operate== "add" and target_templateid not in templates_list:
            templates.append({"templateid": target_templateid})
            update_templates_ret,err = self._update_templates(zabbix_session,host_id,templates,operate)
            if err:
                raise CommandExecutionError(err)
                #print(update_templates_ret_err)
            else:
                return "sucess: 当前主机{0}关联{1}模板成功".format(zabagent_hostname,self.zabbix_template_name)
        elif operate == "add" and target_templateid in templates_list:
            return "success: 当前主机{0}已经关联{1}模板,不需要继续关联.".format(zabagent_hostname,self.zabbix_template_name)
        elif operate == "unlink_clear" and target_templateid in templates_list:
            # 这边就是清除当前主机关联的目标template
            update_templates_ret,err = self._update_templates(zabbix_session,host_id,[{"templateid": target_templateid}],operate)
            if err:
                raise CommandExecutionError(err)
                #print(update_templates_ret_err)
            else:
                return "sucess: 当前主机{0} unlink and clear {1} 模板成功".format(zabagent_hostname,self.zabbix_template_name)

        elif operate == "unlink_clear" and target_templateid not in templates_list:
            return "success: 当前主机{0}没有关联{1}模板,不需要删除关联.".format(zabagent_hostname,self.zabbix_template_name)

    def add_template(self):
        return self._template_common("add")

    def unlink_clear_template(self):
        return self._template_common("unlink_clear")

def add_host_to_group(group=None):
    zabbix_operation = zabbix_check(group)
    return zabbix_operation.add_group()

def link_template(template=None):
    zabbix_operation = zabbix_check(template)
    return zabbix_operation.add_template()

def unlink_clear_template(template=None):
    zabbix_operation = zabbix_check(template)
    return zabbix_operation.unlink_clear_template()

# if __name__ == "__main__":
#     add_template()
#模块经测试有效,只是暂时没有记录日志
jiangmingfei
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SaltStack自动化部署zabbix
weixin_46727129的博客
11-11 1202
1 环境说明 主机名 IP 安装服务 master 192.168.25.146 salt-master minion 192.168.25.147 salt-minion 2 项目简介 此实验项目为使用saltstack自动化工具，在受控端minion上首先安装LAMP架构，然后再使用saltstack在minion上搭建zabbix监控服务 3 项目实验流程 3.1 首先在saltstack控制主机上的测试环境/srv/salt/base编写LAMP架构的状态模块，然后使用使用s
Saltstack一键部署zabbix监控平台
qiao_qing的博客
06-14 346
文章目录一、saltstack部署 一、saltstack部署
saltstack一键部署zabbix监控平台
sl963216757的博客
08-06 221
一、案例简介 使用Saltstack部署zabbix，主要包括zabbix-server、zabbix-agent、zabbix-web以及mysql。其中，zabbix的版本使用4.4，使用本地自己搭建的zabbix仓库，加快部署效率。 两台虚拟机作为示例，分别是server2和server3。 部署前提：已经完成saltstack的部署（包括salt-master和salt-minion）。 二、部署过程 01_物理机搭建zabbix软件仓库 [root@foundation8 zabbix]# ls
运维实操——saltstack自动化部署keepalived和zabbix
qq_40764171的博客
07-19 210
saltstack自动化部署keepalived和zabbix1、keepalived2、zabbix 1、keepalived 本文使用三台虚拟机，server1是saltstack的master端，server2和server3是saltstack的minion端，现在想让server1给server2和server3部署keepalived，使得server2为keepalived的master，server3为keepalived的backup。 先简单部署，测试成功后，再做调整。 修改keepal
基于saltstack自动化部署zabbix-client端实践
whs_321的博客
10-24 3632
内容结合生产环境从简单系统自带的模板监控到自定义监控讲解，结合现在流行的saltstack自动化工具以及zabbix自动化监控进行应用各方面监控和讲解，其功能可以做到批量部署，批量监控，细化到进程以及URL的监控，涵盖了硬件监控，系统监控，应用监控，安全监控
salt-zabbix, 基于saltstack,结合zabbix完成服务自动化部署及监控.zip
09-18
盐栈（SaltStack）与Zabbix的整合是IT运维领域中的一个重要实践，它结合了 SaltStack 的自动化配置管理和Zabbix的高效监控能力，为服务自动化部署及监控提供了一套强大的解决方案。下面将详细介绍这两个工具以及它们...
Saltstack配置管理视频.zip
02-18
4-Saltstack配置管理-功能模块-haproxy.avi 5-Saltstack配置管理-业务引用haproxy.avi 6-Saltstack配置管理-keepalived.avi 7-SaltStack配置管理-业务引用keepalived.avi 8-Saltstack配置管理-增加Zabbix.avi 9-...
zabbix搭建文档
01-12
Zabbix是一款强大的开源监控解决方案，用于监控网络和服务的状态，以及系统资源。以下是搭建Zabbix的详细步骤和相关知识点： 1. **系统自动化基础** - PXEboot：网络引导技术，允许计算机通过网络启动操作系统安装...
saltstack:盐堆
07-12
1、随机获取zabbix proxy的地址 2、根据cmdb获取was、ihs、varnish等软件的相关信息 pillar功能 1、可以自定义minion的属性 自定义模块 1、自定义了ihs模块，was、jboss生成javacore模块 tools 根据salt python api...
saltstack运维工具
01-28
总的来说，SaltStack 是一个功能强大的运维自动化工具，它改变了传统手动运维的方式，提高了效率，降低了错误率，是现代数据中心和云计算环境的理想选择。对于运维人员来说，掌握 SaltStack 的使用将极大地提升工作...
4.saltstack使用指南：使用saltstack部署zabbix
linux_player_c（系统&开发）
12-06 1882
使用saltstack部署zabbix
Saltstack 一键部署zabbix-agent
06-15 2540
1.     salt-master 的环境设置 #vim/etc/salt/master  file_roots:    base:      - /srv/salt/    prod:      - /srv/salt/prod # Systemctl  restartsalt-master.service #Yum  http://repo.zabbix.com/zabbix
saltstack批量部署zabbix指定主机名
linux_s2018的博客
05-22 570
  file.managed:    - name: /usr/local/zabbix/etc/zabbix_agentd.conf    - source: salt://init/files/zabbix/zabbix_agentd.conf    - template: jinja    - user: root    - group: root    - mode: 0644      ...
使用SaltStack自动化部署Zabbix监控平台（zabbix-server、zabbix-agent）
even160941的博客
08-21 400
文章目录
Saltstack批量安装部署Zabbix代理(附zabbix自动注册详解)
weixin_33984032的博客
10-25 197
新上线的服务器需要部署zabbix客户端，并且加入到zabbix监控中，由于新服务器数量较大，所以采用全自动安装部署，文中使用了saltstack的批量部署和zabbix的自动注册结合完成全部需求环境介绍：Centos6.5saltstack 2015.5.10zabbix 2.2.15一.Zabbix自动注册1.启用探索功能点击local network选择一个探索...
zabbix client配置
liuwei0376的专栏
03-14 761
核心步骤 1. 安装client包 a). 关闭防火墙 临时方案: setenforce 0 持久化方案: sed -i “s/SELINUX=enforcing/SELINUX=disabled/” /etc/selinux/config 重启OS b). 安装zabbix yum源 rpm -i http://repo.zabbix.com/zabbix/3.4/rhel/7/x86_6...
Saltstack实现zabbix监控的自动安装部署
qq_36417677的博客
05-20 334
一、Saltstack多节点推送实现zabbix监控的自动安装部署 实验环境： 主机名 ip 服务 server1 172.25.1.1 salt-master、salt-minion、mariadb数据库 server2 172.25.1.2 salt-minion、zabbix-server服务端、zabbix-agent客户端 server3 172.25.1.3 salt-minion、zabbix-web前端 思路：server1做数据库，server2做zabbix服
SaltStack学习笔记之安装zabbix_agentd(jinja和pillar)
aen60571的博客
10-11 112
一、环境说明 机器 IP 主机名 Master 192.168.0.23 minion.saltstack.com Minion 192.168.0.35 minion-node2.saltstack.com 二、查看安装zabbix_agentd所需目录 [root@min...
zabbix：zabbix api中hostgroup.get、host.get和host.update的详解
一直在路上的羊的博客
11-07 5328
1.hostgroup.get获取组信息 该方法允许根据给定的参数检索主机组。 Parameters 参数： 参数 类型 描述 graphids string/array Return only host groups that contain hosts or templates with the given graphs.只返回包含具有给定图表的主机或模板的主机组。 gro...
我想安装一个zabbix
最新发布
03-30
3.创建一个名为“zabbix”的MySQL数据库，并授予“zabbix”用户对该数据库的所有权限。 sudo mysql -u root -p CREATE DATABASE zabbix character set utf8 collate utf8_bin; GRANT ALL PRIVILEGES on zabbix.* ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值