Python 巡检接入钉钉机器人
前段时间，为了快速实现巡检服务器设备的健康状态，我简单的写了一个巡检工具，该工具已经可以满足我的大部分需求了，不过，每次都要自己手动去点击巡检才能知道今天设备的状态，由于每天巡检严重影响我学习逆向技术，所以我准备更进一步，在此基础上继续改进，定期自动检查设备状态，并推送到钉钉群内，经过不断的改进尝试，我做到了，程序会自动巡检，当出现问题时会推送到群内，我再去解决即可。
首先需要配置双网卡模式，我们将无线网卡配置路由让其走外网与钉钉连接，有线网口则负责与内部服务器相连接，只需要配置路由即可实现。
网络目标 网络掩码 网关 接口 跃点数
0.0.0.0 0.0.0.0 132.35.93.1 132.35.93.11 21
0.0.0.0 0.0.0.0 192.168.191.1 192.168.191.3 25
C:\Windows\system32> route delete 0.0.0.0
# 所有的外网访问走无线网卡，从网关 192.168.191.1 出去
C:\Windows\system32>route -p add 0.0.0.0 mask 0.0.0.0 192.168.191.1
# 如果是132网段，则走内部，网关为：132.35.93.1
C:\Windows\system32>route -p add 132.35.0.0 mask 255.255.0.0 132.35.93.1
封装钉钉接口： 接口的调用需要传入需要通知特定人的手机号，这个模块命名为Ding.py 代码如下。
import requests
import urllib.parse
import datetime,time,hmac,hashlib,base64,json
class DingToken():
def __init__(self,atAll,atMobiles):
self.atAll = atAll
self.atMobiles = atMobiles
def send_message(self,message):
timestamp = str(round(time.time() * 1000))
secret = 'SEC1018485caf7339e38530b'
secret_enc = secret.encode('utf-8')
string_to_sign = '{}\n{}'.format(timestamp, secret)
string_to_sign_enc = string_to_sign.encode('utf-8')
hmac_code = hmac.new(secret_enc, string_to_sign_enc, digestmod=hashlib.sha256).digest()
sign = urllib.parse.quote(base64.b64encode(hmac_code))
headers={'Content-Type': 'application/json'}
webhook = 'https://oapi.dingtalk.com/robot/send?access_token=0fe10f×tamp=' + timestamp + "&sign=" + sign
data = {
"msgtype": "text",
"text": {"content": message },
"at": {
"atMobiles": [ self.atMobiles ],
"isAtAll": self.atAll
}
}
requests.post(webhook, data=json.dumps(data), headers=headers)
# 发送警告信息
def send_warning(self,platform,person,group,address,send_date,type,message):
self.send_message(
"------------------------------------------------------- \n"
"\t\t\t\t\t {0} \n"
"------------------------------------------------------- \n"
"维护人员: \t {1} \n"
"所在分组: \t {2} \n"
"系统地址: \t {3} \n"
"告警日期: \t {4} \n"
"告警类型: \t {5} \n"
"------------------------------------------------------- \n"
"{6} \n"
"-------------------------------------------------------".
format(platform,person,group,address,send_date,type,message) )
# 发送Ping连通性报告
def send_ping(self,platform,send_date,success_len,error_len,error_list):
self.send_message(
"------------------------------------------------------- \n"
"\t\t\t\t\t {0} \n"
"------------------------------------------------------- \n"
"[*] 日期: \t {1} \n[+] 连通主机数: \t {2} \n[-] 失败主机数: \t {3} \n"
"------------------------------------------------------- \n"
"失败主机列表: \n {4} \n".format(platform,send_date,success_len,error_len,error_list)
)
if __name__ == "__main__":
ding = DingToken(False,"15646596977")
ding.send_warning("总部客服","王瑞","CTI服务组","192.168.1.1","2021:01:01","磁盘异常","C:// \t 100% \n")
封装好的MySSH模块： 接着就是封装一个拉取数据到本地的SSH模块，这个模块命名为 MySSH.py 代码如下。
import paramiko, math,json
class MySSH:
def __init__(self, address, username, password, default_port):
self.address = address
self.default_port = default_port
self.username = username
self.password = password
def Init(self):
try:
self.ssh_obj = paramiko.SSHClient()
self.ssh_obj.set_missing_host_key_policy(paramiko.AutoAddPolicy())
self.ssh_obj.connect(self.address, self.default_port, self.username, self.password, timeout=3,
allow_agent=False, look_for_keys=False)
self.sftp_obj = self.ssh_obj.open_sftp()
except Exception:
return False
def BatchCMD(self, command):
try:
stdin, stdout, stderr = self.ssh_obj.exec_command(command, timeout=3)
result = stdout.read()
if len(result) != 0:
result = str(result).replace("\\n", "\n")
result = result.replace("b'", "").replace("'", "")
return result
else:
return None
except Exception:
return None
def CloseSSH(self):
try:
self.sftp_obj.close()
self.ssh_obj.close()
except Exception:
pass
def GetSystemVersion(self):
return self.BatchCMD("uname")
# 测试主机连通率
def GetPing(self):
try:
if self.GetSystemVersion() != None:
print("{} 已连通.".format(self.address))
return True
else:
return False
except Exception:
return False
# 拉取磁盘数据到本地，并返回字典
def GetAllDiskSpace(self):
ref_dict = {}
cmd_dict = {"Linux\n": "df | grep -v 'Filesystem' | awk '{print $5 \":\" $6}'",
"AIX\n": "df | grep -v 'Filesystem' | awk '{print $4 \":\" $7}'"
}
try:
os_version = self.GetSystemVersion()
for version, run_cmd in cmd_dict.items():
if (version == os_version):
os_ref = self.BatchCMD(run_cmd)
ref_list = os_ref.split("\n")
for each in ref_list:
if each != "":
ref_dict[str(each.split(":")[1])] = str(each.split(":")[0])
print("利用率字典: {}".format(ref_dict))
return ref_dict
except Exception:
return False
# 拉取内存数据到本地。
def GetAllMemSpace(self):
cmd_dict = {"Linux\n": "cat /proc/meminfo | head -n 2 | awk '{print $2}' | xargs | awk '{print $1 \":\" $2}'",
"AIX\n": "svmon -G | grep -v 'virtual' | head -n 1 | awk '{print $2 \":\" $4}'"
}
try:
os_version = self.GetSystemVersion()
for version, run_cmd in cmd_dict.items():
if (version == os_version):
os_ref = self.BatchCMD(run_cmd)
mem_total = math.ceil(int(os_ref.split(":")[0].replace("\n", "")) / 1024)
mem_free = math.ceil(int(os_ref.split(":")[1].replace("\n", "")) / 1024)
percentage = 100 - int(mem_free / int(mem_total / 100))
print("利用百分比: {} \t 总内存: {} \t 剩余内存: {}".format(percentage,mem_total,mem_free))
return str(percentage) + " %"
except Exception:
return False
# 获取CPU利用率数据
def GetCPUPercentage(self):
ref_dict = {}
cmd_dict = {"Linux\n": "vmstat | tail -n 1 | awk '{print $13 \":\" $14 \":\" $15}'",
"AIX\n": "vmstat | tail -n 1 | awk '{print $14 \":\" $15 \":\" $16}'"
}
try:
os_version = self.GetSystemVersion()
for version, run_cmd in cmd_dict.items():
if (version == os_version):
os_ref = self.BatchCMD(run_cmd)
ref_list = os_ref.split("\n")
for each in ref_list:
if each != "":
each = each.split(":")
ref_dict = {"us": each[0], "sys": each[1], "idea": each[2]}
print("CPU利用率数据: {}".format(ref_dict))
return ref_dict
except Exception:
return False
# 获取到系统负载利用率 也就是一分钟负载五分钟负载十五分钟负载
def GetLoadAVG(self):
ref_dict = {}
cmd_dict = {"Linux\n": "cat /proc/loadavg | awk '{print $1 \":\" $2 \":\" $3}'",
"AIX\n": "uptime | awk '{print $10 \":\" $11 \":\" $12}'"
}
try:
os_version = self.GetSystemVersion()
for version, run_cmd in cmd_dict.items():
if (version == os_version):
os_ref = self.BatchCMD(run_cmd)
ref_list = os_ref.split("\n")
for each in ref_list:
if each != "":
each = each.replace(",","").split(":")
ref_dict = {"1avg": each[0],"5avg": each[1],"15avg": each[2]}
print("负载利用率: {}".format(ref_dict))
return ref_dict
return False
except Exception:
return False
# 检测指定进程是否存活
def CheckProcessStatus(self,processname):
cmd_dict = {"Linux\n": "ps aux | grep '{0}' | grep -v 'grep' | awk {1} | wc -l".format(processname,"{'print $2'}"),
"AIX\n": "ps aux | grep '{0}' | grep -v 'grep' | awk {1} | wc -l".format(processname,"{'print $2'}")
}
try:
os_version = self.GetSystemVersion()
for version, run_cmd in cmd_dict.items():
if (version == os_version):
os_ref = self.BatchCMD(run_cmd)
ret_flag = str(os_ref.split("\n")[0].replace(" ","").strip())
if ret_flag != "0":
return True
return False
except Exception:
return "None"
# 检测指定端口是否存活
def CheckPortStatus(self,port):
cmd_dict = {"Linux\n": "netstat -antp | grep {0} | awk {1}".format(port,"{'print $6'}")
, "AIX\n": "netstat -ant | grep {0} | head -n 1 | awk {1}".format(port,"{'print $6'}")
}
try:
os_version = self.GetSystemVersion()
for version, run_cmd in cmd_dict.items():
if (version == os_version):
os_ref = self.BatchCMD(run_cmd)
ret_flag = str(os_ref.split("\n")[0].replace(" ","").strip())
if ret_flag == "LISTEN" or ret_flag == "ESTABLISHED":
return True
return False
except Exception:
return False
定义巡检过程： 这个模块是最重要的一个模块，主要负责解析JSON文件并巡检，该模块我们就命名为system.py，代码如下：
from Ding import DingToken
from MySSH import MySSH
import os,sys,time,datetime,json
# --------------------------------------------------------------------------------------------------
# 对所有主机设备进行
def switch_ping():
with open("./config.json", "r", encoding="utf-8") as read_config_ptr:
ptr = json.loads(read_config_ptr.read())
system = ptr.get("system")
success,error = [],[]
try:
for system_list in system:
for k,v in system_list.items():
for item in v:
now = datetime.datetime.now()
print("[+] 监控范围: Ping测试 --> 监测组: {} --> 检测日期: {} --> 检测地址: {}".format(k,datetime.datetime.strftime(now, '%Y-%m-%d %H:%M:%S'),item[0]))
#InspectCPU(ptr.get("telephone"),item[0],item[1],item[2],ptr.get("default-port"),ptr.get("platform"),ptr.get("person"),k,ptr.get("cpu_limit"))
ssh = MySSH(item[0],item[1],item[2],ptr.get("default-port"))
ssh.Init()
ref = ssh.GetPing()
if ref == True:
success.append(item[0])
else:
error.append(item[0])
ding = DingToken(False, ptr.get("telephone"))
ding.send_ping(ptr.get("platform"),datetime.datetime.strftime(now, '%Y-%m-%d %H:%M:%S'),len(success),len(error),error)
except Exception:
pass
# --------------------------------------------------------------------------------------------------
# 磁盘告警流程
# 手机号 地址 账号 密码 端口 系统名称 姓名 分组 磁盘最大值
def InspectDisk(telephone,address,username,password,port,platform,person,group,disk_limit):
ding = DingToken(False, telephone)
ssh = MySSH(address, username, password, port)
ssh.Init()
ret = ssh.GetAllDiskSpace()
ssh.CloseSSH()
if ret != False:
for k,v in ret.items():
try:
space = eval(v.split("%")[0])
if space >= int(disk_limit):
now = datetime.datetime.now()
strnow = datetime.datetime.strftime(now, '%Y-%m-%d %H:%M:%S')
ding.send_warning(platform, person, group, address, strnow, "磁盘过载", "[ 分区: {} \t | \t 负载率: {} ]\n".format(k,v))
except Exception:
pass
def switch_inspect_disk():
with open("./config.json", "r", encoding="utf-8") as read_config_ptr:
ptr = json.loads(read_config_ptr.read())
system = ptr.get("system")
for system_list in system:
# 循环所有字典
for k,v in system_list.items():
# 循环每个分组内的主机
for item in v:
now = datetime.datetime.now()
print("[+] 监控范围: 磁盘检测 --> 监测组: {} --> 检测日期: {} --> 检测地址: {}".format(k,datetime.datetime.strftime(now, '%Y-%m-%d %H:%M:%S'),item[0]))
# InspectDisk("15646596977", "192.168.191.4", "root", "1233", "22", "总部客服(呼叫中心平台)", "王瑞", "CTI 3.4",80)
InspectDisk(ptr.get("telephone"),item[0],item[1],item[2],ptr.get("default-port"),ptr.get("platform"),ptr.get("person"),k,ptr.get("disk_limit"))
# --------------------------------------------------------------------------------------------------
# 内存告警流程
# InspectMemory("15646596977","192.168.191.3","root","1233",22,"总部客服系统","王瑞","CTI组",内存阈值)
def InspectMemory(telephone,address,username,password,port,platform,person,group,memory_limit):
ding = DingToken(False, telephone)
ssh = MySSH(address, username, password, port)
ssh.Init()
ret = ssh.GetAllMemSpace()
ssh.CloseSSH()
if ret != False:
try:
space = eval(ret.split("%")[0])
if space >= int(memory_limit):
now = datetime.datetime.now()
strnow = datetime.datetime.strftime(now, '%Y-%m-%d %H:%M:%S')
ding.send_warning(platform, person, group, address, strnow, "内存过载", "[ 负载率: \t | \t {} ]\n".format(ret))
except Exception:
pass
def switch_inspect_memory():
with open("./config.json", "r", encoding="utf-8") as read_config_ptr:
ptr = json.loads(read_config_ptr.read())
system = ptr.get("system")
for system_list in system:
for k,v in system_list.items():
for item in v:
now = datetime.datetime.now()
print("[+] 监控范围: 内存检测 --> 监测组: {} --> 检测日期: {} --> 检测地址: {}".format(k,datetime.datetime.strftime(now, '%Y-%m-%d %H:%M:%S'),item[0]))
InspectMemory(ptr.get("telephone"),item[0],item[1],item[2],ptr.get("default-port"),ptr.get("platform"),ptr.get("person"),k,ptr.get("memory_limit"))
# --------------------------------------------------------------------------------------------------
# 巡检CPU利用率
def InspectCPU(telephone,address,username,password,port,platform,person,group,cpu_limit):
ding = DingToken(False, telephone)
ssh = MySSH(address, username, password, port)
ssh.Init()
ret = ssh.GetCPUPercentage()
ssh.CloseSSH()
if ret != False:
try:
space = int(100 - int(ret.get("idea")))
us = ret.get("us") + "%"
sys = ret.get("sys") + "%"
if space >= int(cpu_limit):
print("CPU 总利用率: {}".format(space))
now = datetime.datetime.now()
strnow = datetime.datetime.strftime(now, '%Y-%m-%d %H:%M:%S')
ding.send_warning(platform, person, group, address, strnow, "CPU 利用率过载","[ 用户态: \t | \t {} ]\n[ 内核态: \t | \t {} ]\n[ 总利用率: \t | \t {}% ]\n".format(us,sys,space))
except Exception:
pass
def switch_inspect_cpu():
with open("./config.json", "r", encoding="utf-8") as read_config_ptr:
ptr = json.loads(read_config_ptr.read())
system = ptr.get("system")
for system_list in system:
for k,v in system_list.items():
for item in v:
now = datetime.datetime.now()
print("[+] 监控范围: CPU检测 --> 监测组: {} --> 检测日期: {} --> 检测地址: {}".format(k,datetime.datetime.strftime(now, '%Y-%m-%d %H:%M:%S'),item[0]))
InspectCPU(ptr.get("telephone"),item[0],item[1],item[2],ptr.get("default-port"),ptr.get("platform"),ptr.get("person"),k,ptr.get("cpu_limit"))
# --------------------------------------------------------------------------------------------------
# 巡检系统平均负载
def InspectLoadAvg(telephone,address,username,password,port,platform,person,group,load_avg_limit):
ding = DingToken(False, telephone)
ssh = MySSH(address, username, password, port)
ssh.Init()
ret = ssh.GetLoadAVG()
ssh.CloseSSH()
if ret != False:
try:
if float(ret.get("1avg")) >= float(load_avg_limit[0]) or float(ret.get("5avg")) >= float(load_avg_limit[1]) or float(ret.get("15avg")) >= float(load_avg_limit[2]):
now = datetime.datetime.now()
strnow = datetime.datetime.strftime(now, '%Y-%m-%d %H:%M:%S')
ding.send_warning(platform, person, group, address, strnow, "LoadAvg 过载","[ 一分钟负载: \t | \t {} ]\n[ 五分钟负载: \t | \t {} ]\n[ 十五分钟负载: \t | \t {} ]\n".
format(ret.get("1avg"), ret.get("5avg"),ret.get("15avg")))
except Exception:
pass
def switch_inspect_avg():
with open("./config.json", "r", encoding="utf-8") as read_config_ptr:
ptr = json.loads(read_config_ptr.read())
system = ptr.get("system")
for system_list in system:
for k,v in system_list.items():
for item in v:
now = datetime.datetime.now()
print("[+] 监控范围: 系统负载检测 --> 监测组: {} --> 检测日期: {} --> 检测地址: {}".format(k,datetime.datetime.strftime(now, '%Y-%m-%d %H:%M:%S'),item[0]))
InspectLoadAvg(ptr.get("telephone"),item[0],item[1],item[2],ptr.get("default-port"),ptr.get("platform"),ptr.get("person"),k,list(ptr.get("load_avg_limit")))
# --------------------------------------------------------------------------------------------------
# 巡检系统端口是否开放
# 首先传入一个IP地址,解析出其用户名密码表
def GetAddressAsPasswd(address):
with open("./config.json", "r", encoding="utf-8") as read_config_ptr:
ptr = json.loads(read_config_ptr.read())
for each_list in ptr.get("system"):
for k,v in each_list.items():
for ser in v:
if ser[0] == address:
return ser
return False
# 拼接字符串数据
def append_string(src_str,append_str):
for x in range(len(append_str)):
src_str += append_str[x]
return src_str
# 检查端口是否被关闭了，如果关闭了则提示关闭
def InspectPort(telephone,platform,person):
with open("./config.json", "r", encoding="utf-8") as read_config_ptr:
ptr = json.loads(read_config_ptr.read())
port = ptr.get("port")
default_port = ptr.get("default-port")
for each_list in port:
for k,v in each_list.items():
for item in v:
this_user_passwd = GetAddressAsPasswd(item[0])
if this_user_passwd != False:
try:
now = datetime.datetime.now()
print("[+] 监控范围: 端口状态检测 --> 监测组: {} --> 检测日期: {} --> 检测地址: {}".format(k,
datetime.datetime.strftime(
now,
'%Y-%m-%d %H:%M:%S'),
item[0]))
ssh = MySSH(this_user_passwd[0], this_user_passwd[1], this_user_passwd[2], default_port)
ssh.Init()
close_port_list = []
for check_port in range(1,len(item)):
ref = ssh.CheckPortStatus(item[check_port])
print("端口ID: {} \t 状态位: {} 存活端口: {}".format(check_port, ref, item[check_port]))
if ref == False or ref == "None":
close_port_list.append(item[check_port])
print("端口ID: {} \t 状态位: {} 关闭端口: {}".format(check_port, ref, item[check_port]))
ding = DingToken(False,telephone)
send = ""
for i in close_port_list:
im = "[ 端口: {0} \t\t | \t 状态: 已关闭 ]\n".format(i)
send = append_string(send,im)
if(send != ""):
ding.send_warning(platform,person,k,this_user_passwd[0],datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d %H:%M:%S'),"端口关闭",send)
ssh.CloseSSH()
except Exception:
pass
def switch_inspect_port():
with open("./config.json", "r", encoding="utf-8") as read_config_ptr:
ptr = json.loads(read_config_ptr.read())
telephone = ptr.get("telephone")
platform = ptr.get("platform")
person = ptr.get("person")
InspectPort(telephone, platform, person)
# --------------------------------------------------------------------------------------------------
# 巡检系统是否开放指定进程
def InspectProcess(telephone,platform,person):
with open("./config.json", "r", encoding="utf-8") as read_config_ptr:
ptr = json.loads(read_config_ptr.read())
process = ptr.get("process")
default_port = ptr.get("default-port")
for each_list in process:
for k,v in each_list.items():
for item in v:
this_user_passwd = GetAddressAsPasswd(item[0])
if this_user_passwd != False:
try:
now = datetime.datetime.now()
print("[+] 监控范围: 进程状态检测 --> 监测组: {} --> 检测日期: {} --> 检测地址: {}".format(k,
datetime.datetime.strftime(
now,
'%Y-%m-%d %H:%M:%S'),
item[0]))
ssh = MySSH(this_user_passwd[0], this_user_passwd[1], this_user_passwd[2], default_port)
ssh.Init()
close_process_list = []
for check_process in range(1,len(item)):
ref = ssh.CheckProcessStatus(item[check_process])
print("进程ID: {} \t 状态位: {} 存活进程: {}".format(check_process, ref, item[check_process]))
if ref == False or ref == "None":
close_process_list.append(item[check_process])
print("进程ID: {} \t 状态位: {} 关闭进程: {}".format(check_process, ref, item[check_process]))
ding = DingToken(False,telephone)
send = ""
for i in close_process_list:
im = "[ 进程: {0} \t\t | \t 状态: 已关闭 ]\n".format(i)
send = append_string(send,im)
if(send != ""):
ding.send_warning(platform,person,k,this_user_passwd[0],datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d %H:%M:%S'),"进程退出",send)
ssh.CloseSSH()
except Exception:
pass
def switch_inspect_process():
with open("./config.json", "r", encoding="utf-8") as read_config_ptr:
ptr = json.loads(read_config_ptr.read())
telephone = ptr.get("telephone")
platform = ptr.get("platform")
person = ptr.get("person")
InspectProcess(telephone, platform, person)
以磁盘为例，当超过了我们定义好的阈值时，则会通过钉钉提示用户告警，告警提示如下。
定义配置文件： 配置文件则是巡检时需要解析的内容，我们需要依次写入账号密码等信息。
{
"system_config":
[
{"ping_": "True"},
{"disk_": "True"},
{"cpu_": "False"},
{"loadavg_": "False"},
{"memory_": "False"},
{"process_": "False"},
{"port_": "False"}
],
"platform": "总部客服系统(呼叫中心)",
"person": "王瑞",
"telephone": "18264825669",
"e-mail": "admin@lyshark.com",
"default-port": "22",
"set-timeout": "3600",
"disk_limit": 75,
"memory_limit": 95,
"cpu_limit": 90,
"load_avg_limit": ["5.0","8.0","10.0"],
"system":
[
{
"Centos 服务器组":
[
["192.168.1.1","root","1233"],
["192.168.1.1","root","1233"],
["192.168.1.1","root","1233"]
],
"AIX 服务器组":
[
["192.168.1.1","root","1233"],
["192.168.1.1","root","1233"]
]
}
],
"process":
[
{
"CTI进程组":
[
["192.168.1.1","icdcomm","aplogic","ctilink","cnfgsvr","mcp"],
["192.168.1.1","aplogic","ctilink","cnfgsvr","mcp","ccsapp","nis","oas","ivr","ctiserver"]
]
}
],
"port":
[
{
"CTI端口检测":
[
["192.168.1.1","111","631","8888","19001","25","2556","5150","5600","34902","10000","34901","10005"],
["192.168.1.1","111","8080","10000","10004","10005","8888","19001","2556","5600","60661"]
]
}
]
}
定义main入口代码： 入口代码主要负责解析参数与巡检，由于怕影响服务器性能，所有没加多线程支持，不过也够用了。
import system
import json,time
if __name__ == "__main__":
with open("./config.json", "r", encoding="utf-8") as read_config_ptr:
ptr = json.loads(read_config_ptr.read())
timeout = ptr.get("set-timeout")
configure = ptr.get("system_config")
# 默认开关全部关闭
disk_ = "False"
cpu_ = "False"
memory_ = "False"
loadavg_ = "False"
process_ = "False"
port_ = "False"
ping_ = "False"
# 判断配置文件开关是否开启，如果开启了则将内存的开关开启
for dic in configure:
for k,v in dic.items():
if k == "ping_" and v == "True":
ping_ = "True"
if k == "disk_" and v == "True":
disk_ = "True"
if k == "cpu_" and v == "True":
cpu_ = "True"
if k == "memory_" and v == "True":
memory_ = "True"
if k == "loadavg_" and v == "True":
loadavg_ = "True"
if k == "process_" and v == "True":
process_ = "True"
if k == "port_" and v == "True":
port_ = "True"
while True:
if ping_ == "True":
system.switch_ping()
if disk_ == "True":
system.switch_inspect_disk()
if cpu_ == "True":
system.switch_inspect_cpu()
if memory_ == "True":
system.switch_inspect_memory()
if loadavg_ == "True":
system.switch_inspect_avg()
if process_ == "True":
system.switch_inspect_process()
if port_ == "True":
system.switch_inspect_port()
time.sleep(int(timeout))
实现正则解析： 前面的配置无法实现交互式问答，智能机器人推送数据，很被动，我们需要开启交互机器人，自己实现业务逻辑。
import os,sys,re
def participle(text):
ref = re.findall(r'(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)',text)
address = ".".join(ref[0])
select = re.findall('查询', text)
if(len(address) !=0 and len(select) != 0):
if len (re.findall('内存',text)) != 0:
return [address,"内存"]
elif len (re.findall('磁盘',text)) != 0:
return [address,"磁盘"]
elif len (re.findall('负载',text)) != 0:
return [address,"负载"]
if __name__ == "__main__":
text = "帮我查询192.168.1.1主机的内存负载情况"
text2 = "帮我查询 192.168.1.200 这 台设 备的 磁盘 使用率"
text3 = "需要查询192.168.1.200 设备中负载使用情况，请反馈结果"
text4 = "发现负载出现告警，请立即查询192.168.1.200这台设备的负载使用率，并立即反馈"
print(participle(text))
print(participle(text2))
print(participle(text3))
print(participle(text4))
txt = '''
主编单位：总部客服系统
'''
addr = re.findall('(主编单位：.*?)\s', txt)[0]
print(addr)
这个案例，从文本中提取可用信息，并将其返回为列表格式。
接着配置钉钉开发者平台机器人，此处需要有公网地址，作用是，钉钉群有人at机器人时，机器人会将请求post发送到我们的django应用服务上。
使用django配置接收请求并处理即可，处理代码如下所示。
from django.http import HttpResponse, JsonResponse
import json,hmac,hashlib,base64
import sys,os,re
# 机器人 app_secret
app_secret = "LcKEf0nlqe"
# 根据IP查询操作使用
def select_participle(text):
ref = re.findall(r'(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)\.(25[0-5]|2[0-4]\d|[0-1]\d{2}|[1-9]?\d)',text)
# 判断如果地址不为空，则进行查询等操作
if len(ref) != 0:
address = ".".join(ref[0])
select = re.findall('查询', text)
if(len(address) !=0 and len(select) != 0):
if len (re.findall('内存',text)) != 0:
return [address,"内存"]
elif len (re.findall('负载',text)) != 0:
return [address,"负载"]
else:
if len(re.findall('主机列表', text)) != 0:
return ["主机列表"]
def index(request):
if request.method == "POST":
HTTP_SIGN = request.META.get("HTTP_SIGN")
HTTP_TIMESTAMP = request.META.get("HTTP_TIMESTAMP")
res = json.loads(request.body)
# 接收用户的输入并做处理
sendnick = res.get("senderNick")
is_admin = res.get("isAdmin")
conver = res.get("conversationTitle")
content = res.get("text").get("content")
print("发送人: {} 是否管理员: {} 所在组: {} 接收数据: {}".format(sendnick,is_admin,conver,content))
# 数据的加密解密
string_to_sign = '{}\n{}'.format(HTTP_TIMESTAMP, app_secret)
string_to_sign_enc = string_to_sign.encode('utf-8')
hmac_code = hmac.new(app_secret.encode("utf-8"), string_to_sign_enc, digestmod=hashlib.sha256).digest()
sign = base64.b64encode(hmac_code).decode("utf-8")
ref_select_text = select_participle(content)
if len(ref_select_text) == 2:
if sign == HTTP_SIGN:
if "负载" in ref_select_text[1]:
return JsonResponse(
{"msgtype": "text",
"text": {
"content": "经过查询,主机: {} 负载率为: 10% 当前为正常状态".format(ref_select_text[0])
}
})
if "内存" in ref_select_text[1]:
return JsonResponse\
(
{"msgtype": "text",
"text":
{
"content": "经过查询,主机: {} 内存占用率为: 70% 当前为正常状态".format(ref_select_text[0])
}
}
)
elif len(ref_select_text) == 1:
if "主机列表" in ref_select_text[0]:
return JsonResponse \
(
{"msgtype": "text",
"text":
{
"content": "目前您所管理的主机，总结: 205台"
}
}
)
return JsonResponse({"error": "没有权限"})
if request.method == "GET":
return HttpResponse("没有权限")
django运行后，我们回到钉钉群内，问机器人一些问题看看吧，前提是这些问题已经定义了正则解析。
django 后台则能够接收到，这些数据，并做出回应。
Python 巡检接入钉钉机器人的更多相关文章
- 钉钉 机器人接入 自定义webhook
钉钉出了个webhook机器人接入,自定义的机器人支持随时post消息到群里: 昨天就尝试着用C#写了个: 一开始用python写,但是莫名的提示 {"errmsg":" ...
- 怎么用python 3 开发钉钉群机器人
前言 文的文字及图片来源于网络,仅供学习.交流使用,不具有任何商业用途,版权归原作者所有,如有问题请及时联系我们以作处理. 作者:Python绿色通道 PS:如有需要Python学习资料的小伙伴可以加 ...
- python 小脚本升级-- 钉钉群聊天机器人
一则小脚本(工作中用) 在这篇文章中写的监控的脚本,发送监控的时候 是利用的邮箱,其实在实际,邮箱查收有着不方便性,于是乎升级, 我们工作中,经常用钉钉,那么如果要是能用到钉钉多好,这样我们的监控成功 ...
- 用python写一个预警机器人（支持微信和钉钉）
背景 线上的系统在运行中,发生故障时怎么及时的通过手机通知到相关人员?当然这是个很简单的需求,现有的方法有很多,例如: 如果我们用的云产品,那么一般都会有配套对应的监控预警功能,根据需要配置一下即可, ...
- 钉钉机器人-实现监控通知功能-python
1. 首先得创建有 一个 钉钉群.(因为只能发群通知) 2. 添加机器人,得到一个url: 3. 开始写Python脚本: # -*- coding: utf-8 -*- ""&q ...
- 运维利器：钉钉机器人脚本告警（Linux Python 篇）
写在前面的话 在前面的博客中已经具体提到了如何获取对的机器人的 Token 等操作,不清楚的可以参考之前写的 [运维利器:钉钉机器人脚本告警(Linux Shell 篇)]这篇博客的前部分. 本文主要 ...
- 用Python实现阿里钉钉机器人读取数据库内容自动发群通知
最近想把一些预警数据信息按照一定的要求自动发送到移动端APP,最终把目标放在了腾讯的微信和阿里的钉钉软件上,由于刚开始学习python,于是编程工具想用python来实现.微信使用群体最广,通过一天的 ...
- 【原】python 检查网站访问是否超时，并用钉钉机器人报警
#!/usr/bin/env python import requests import json import logging webhook="上面创建钉钉机器人的webhook地址&q ...
- python之钉钉机器人zabbix报警
转自:https://blog.51cto.com/m51cto/2051945 首先在钉钉群聊里添加一个自定义的机器人 并复制webhook的内容 https://oapi.dingtalk.com ...
随机推荐
- hiho一下 第195周 奖券兑换[C solution][Accepted]
时间限制:20000ms 单点时限:1000ms 内存限制:256MB 描述 小Hi在游乐园中获得了M张奖券,这些奖券可以用来兑换奖品. 可供兑换的奖品一共有N件.第i件奖品需要Wi张奖券才能兑换到, ...
- pytorch（03）tensor的操作
张量操作 一.张量的拼接 torch.cat() 功能:将张量按维度dim进行拼接,且[不会扩张张量的维度] tensors:张量序列 dim:要拼接的维度 torch.cat(tensors, di ...
- golang——net/rpc包学习
1.rpc包 rpc包提供了通过网络或其他I/O连接对一个对象的导出方法的访问. 只有满足如下标准的方法才能用于远程访问,其余方法会被忽略: (1)方法是导出的(2)方法有两个参数,都是导出类型或内建 ...
- git的回滚与撤销【reset and revert】
git的工作流程-- 3个区域 工作区:我们可以看到的文件内容 在操作 git add 之前的!! 缓存区:是不可见的 已经git add操作,还没git commit -m "" ...
- Python装饰器（3）
这篇文章中记录说明下多个装饰器一同装饰同一个函数时的执行顺序问题. [装饰器链] 按照惯例,先看代码示例: import time def debug1(str): #传参接受类的方法 def fun ...
- python类属性
类属性 类属性分为共有属性和私有属性. 私有属性的定义方法eg:__age(若无次定义则默认为公有属性) 类属性举例: class people: name = "china" _ ...
- PTA 链表逆置
6-3 链表逆置 (20 分) 本题要求实现一个函数,将给定单向链表逆置,即表头置为表尾,表尾置为表头.链表结点定义如下: struct ListNode { int data; struct L ...
- Android学习之探究Fragment
•碎片是什么 Fragment是一种可以嵌入在活动中的UI片段,能够让程序更加合理和充分地利用大屏幕的空间: 出现的初衷是为了适应大屏幕的平板电脑,可以将其看成一个小型Activity,又称作Acti ...
- 一次 outline 去除经验（非继承属性，看着像继承）
情况描述: 目前维护的老项目是通过 easyui 生成的 html,嵌套结构非常多,当点击元素后,会有个边框???非常影响页面美观,这是啥迷惑点击交互??? 经验告诉我,这是 css 的 outlin ...
- [SpringCloud教程]2. 版本选型和项目搭建
Spring Cloud Alibaba 版本选型 建议先选择Spring Cloud Alibaba的大版本,方便兼容 选择 Spring Cloud Alibaba 大版本 访问链接,找到标题&q ...