Python实现Linux服务器自动巡检脚本

#!/usr/bin/python3
from netmiko.huawei.huawei import huaweissh
import os
from datetime import datetime
import smtplib
from email.mime.text import mimetext
from email.header import header
from email.mime.multipart import mimemultipart

cmd_str = 'cmd_str'
cmd_name = 'name'
ip = 'ip'
user_name = 'username'
password = 'password'

# email config
smtp_host = '你的邮箱发送付服务地址'
smtp_port = 25
smtp_email = '你的发送邮箱号'
# 用户名，默认为发件人邮箱前缀
smtp_user ='你的发送邮箱号'
# 密码（注意，某些邮箱需要为smtp服务单独设置授权码，详情查看相关帮助）
smtp_password = '你的发送邮箱密码'

class servermaintenance:
    net_connect = none
    curr_dir = os.getcwd()
    fo = none
    file_name = none
    email_files = []

    # 建立服务器连接
    def connect_huaweissh(self, _ip, _user_name, _pw):
        try:
            s5720 = {
                'device_type': 'huawei',
                'ip': _ip,
                'username': _user_name,
                'password': _pw,
            }
            # 实例化huaweissh
            net_connect = huaweissh(**s5720)
            self.net_connect = net_connect
        except:
            print("连接" + _ip + "错误")

    # 运行指令
    def execute(self, cmd_str, cmd_name):
        result = self.net_connect.send_command(cmd_str)
        print(result)
        self.printfile('\n-------------------------任务【' + cmd_name + '】开始巡查 -------------------------\n')
        self.printfile(result)
        self.printfile('\n-------------------------任务【' + cmd_name + '】结束巡查 -------------------------\n')
        return result

    # 关闭连接
    def disconnect(self):
        self.net_connect.disconnect()
        print("连接断开" + self.net_connect)

    # 文件写入
    def printfile(self, txt):
        self.fo.write(txt)
    # 发送邮箱
    def sendemail(self):
        msg = mimemultipart()
        msg['from'] = header("master", 'utf-8')
        msg['to'] = header('13693567027@163.com', 'utf-8')
        subject = 'test email'
        msg['subject'] = header(subject, 'utf-8')
        # 邮件正文内容
        content = ''


        for filename in self.email_files:
            content+=filename+'\n'
            # 邮件附件
            att = mimetext(open(filename+'.txt', 'rb').read(), 'base64', 'utf-8')
            att['content-type'] = 'application/octet-stream'  # 指定文件格式
            att["content-disposition"] = 'attachment; filename="服务器巡检报告.txt"'
            msg.attach(att)

        msg.attach(mimetext(content, 'plain', 'utf-8'))
        try:
            # # 创建安全连接，使用smtp_ssl连接smtp服务器
            smtp_client = smtplib.smtp(smtp_host)  # 实例化对象
            smtp_client.connect(smtp_host, smtp_port)  # 连接163邮箱服务器，端口号为25
            # # 向服务器标识用户身份
            smtp_client.login(smtp_user, smtp_password)
            # 发送邮件
            smtp_client.sendmail(smtp_user, '13693567027@163.com', msg.as_string())
            print("邮件发送成功")
        except smtplib.smtpexception as e:
            print("error: 无法发送邮件 ", e)

        # 关闭smtp连接
        smtp_client.quit()

    def run(self,commands,hosts):
        for host in hosts:
            self.file_name = "服务器巡查_" + host[ip] + '_' + datetime.now().strftime(format="%y年%m月%d日%h时%m分%s秒")
            self.email_files.append(self.file_name)
            self.fo = open(self.file_name + ".txt", 'w+', encoding='utf-8')
            self.connect_huaweissh(host[ip], host[user_name], host[password])
            self.printfile(
                '\n================================主机开始巡检： ' + host[ip] + '================================\n')
            for command in commands:
                self.execute(command[cmd_str], command[cmd_name])
            self.printfile(
                '\n================================主机巡检结束： ' + host[ip] + '================================\n')



commands = [
    {cmd_str: "ps -ef |grep java", cmd_name: "运行中的应用"},
    {cmd_str: "docker ps", cmd_name: "运行中的容器"},
    {cmd_str: "df -th", cmd_name: "磁盘空间"},
    {cmd_str: "free -h", cmd_name: "内存"},
    {cmd_str: "ps -ef", cmd_name: "进程"},
    {cmd_str: "crontab  -l", cmd_name: "定时任务"},
    {cmd_str: "cat /var/log/messages|grep error && dmesg |grep error", cmd_name: "操作系统日志"},
    {cmd_str: "date", cmd_name: "操作系统时间"},
    {cmd_str: "firewall-cmd --list-all", cmd_name: "防火墙"},
    {cmd_str: "dmidecode -t system", cmd_name: "服务器型号"},
    {cmd_str: "uname -a && uname -r", cmd_name: "操作系统与内核"},
    {cmd_str: "last", cmd_name: "用户登录日志"},
]

hosts = [
    {ip: '你的服务器ip', user_name: '你的服务器账号', password: '你的服务器密码'}
]

servermain = servermaintenance()
servermain.run(commands,hosts)
servermain.sendemail()

# -*- coding: utf-8 -*-
"""
linux 自动化脚本
# @time: 2022/11/4 10:20
# @author: lln
# @file: linuxopsstartup.py
"""
import json
import os
import platform
import time


def runcommand(command):
    """
    执行命令，将所有读到的数据去除空行
    :param command: 命令
    :return: 去除空行后的命令
    """
    lines = os.popen(command).readlines()
    res = []
    for line in lines:
        res.append(line.replace('\n', ''))
    return res


def getsysteminfo():
    """
    使用内置库获取系统信息
    """
    res = {
        "操作系统名称及版本号": platform.platform(),
        "操作系统版本号": platform.version(),
        "操作系统的位数": platform.architecture(),
        "计算机类型": platform.machine(),
        "网络名称": platform.node(),
        "处理器信息": platform.processor(),
    }
    return res


def getsystemstatus():
    """
    系统信息，仅支持centos进行查询
    """
    # 系统
    os = runcommand("uname -o")
    # 发行版本
    release = runcommand("cat /etc/redhat-release 2>/dev/null")
    # 内核
    kernel = runcommand("uname -r")
    # 主机名
    hostname = runcommand("uname -n")
    # 当前时间
    localtime = runcommand("date +'%f %t'")
    # 最后启动
    lastreboot = runcommand("who -b | awk '{print $3,$4}'")
    # 运行时间
    uptime = runcommand("date +'%f %t'")
    # 当前时区信息
    time_zone = runcommand("date -r")
    res = {
        "系统": os,
        "发行版本": release,
        "内核": kernel,
        "主机名": hostname,
        "当前时间": localtime,
        "最后启动": lastreboot,
        "运行时间": uptime,
        "时区信息": time_zone
    }
    return res


def getcpustatus():
    """
    cpu信息
    """
    # 物理cpu个数
    physical_cpus = runcommand("grep 'physical id' /proc/cpuinfo| sort | uniq | wc -l")
    # 逻辑cpu个数
    virt_cpus = runcommand("grep 'processor' /proc/cpuinfo | wc -l")
    # 每cpu核心数
    cpu_kernels = runcommand("grep 'cores' /proc/cpuinfo|uniq| awk -f ': ' '{print $2}'")
    # cpu型号
    cpu_type = runcommand("grep 'model name' /proc/cpuinfo | awk -f ': ' '{print $2}' | sort | uniq")
    # cpu架构
    cpu_arch = runcommand("uname -m")
    res = {
        '物理cpu个数': physical_cpus,
        '逻辑cpu个数': virt_cpus,
        '每cpu核心数': cpu_kernels,
        'cpu型号': cpu_type,
        'cpu架构': cpu_arch
    }
    return res


def getmemstatus():
    """
    内存信息
    """
    # 总内存
    memtotal = runcommand("grep memtotal /proc/meminfo| awk '{print $2}'")
    memtotal_num = map(float, memtotal)[0]
    # 可用内存
    memfree = runcommand("grep memfree /proc/meminfo| awk '{print $2}'")
    memfree_num = map(float, memfree)[0]
    # 比例
    proportion = '{:.4%}'.format(memfree_num / memtotal_num)
    res = {
        '总内存(gb)': '{:.5}'.format(float(memtotal_num / 1024 / 1024)),
        '可用内存(gb)': '{:.5}'.format(float(memfree_num / 1024 / 1024)),
        '已用比例(%)': proportion
    }
    return res


def getmemstatussimple():
    memtotal = runcommand("free -h")
    res = {
        '内存总览': memtotal
    }
    return res


def getdiskstatus():
    """
    磁盘检查
    """
    # 生成临时数据记录文件
    # os.popen("df -tp | sed '1d' | awk '$2!='tmpfs'{print}'")
    # os.popen("df -htp | sed 's/mounted on/mounted/'> /tmp/disk")
    # 硬盘总量
    diskallinfo = runcommand("df -h | grep -v docker")
    disktotal = runcommand("df -tp | sed '1d' | awk '$2!='tmpfs'{print}'| awk '{total+=$3}end{print total}'")
    disktotalnum = int(disktotal[0])
    # 硬盘使用量
    diskused = runcommand("df -tp | sed '1d' | awk '$2!='tmpfs'{print}'| awk '{total+=$4}end{print total}'")
    diskusednum = int(diskused[0])
    # 硬盘空余量
    diskfree = disktotalnum - diskusednum
    # 硬盘使用比例
    diskusedpercent = '{:.2%}'.format(diskusednum / disktotalnum)
    # 索引总量
    inodetotal = runcommand("df -itp | sed '1d' | awk '$2!='tmpfs'{print}' | awk '{total+=$3}end{print total}' ")
    inodetotal_num = int(inodetotal[0])
    # 索引使用量
    inodeused = runcommand("df -itp | sed '1d' | awk '$2!='tmpfs'{print}' | awk '{total+=$4}end{print total}' ")
    inodeused_num = int(inodeused[0])
    # 索引剩余量
    inodefree = inodetotal_num - inodeused_num
    # 索引使用比例
    inodepercent = '{:.2%}'.format(inodeused_num / inodetotal_num)
    res = {
        '磁盘总览': diskallinfo,
        '硬盘总量(gb)': int(disktotalnum / 1024 / 1024),
        '硬盘使用量(gb)': int(diskusednum / 1024 / 1024),
        '硬盘空余量(gb)': int(diskfree / 1024 / 1024),
        '硬盘使用比例(%)': diskusedpercent,
        '索引总量(mb)': int(inodetotal_num / 1021),
        '索引使用量(mb)': int(inodeused_num / 1021),
        '索引剩余量(mb)': int(inodefree / 1021),
        '索引使用比例(%)': inodepercent,
    }
    return res


def getnetworkstatus():
    """
    网络检查
    """
    gateway = runcommand("ip route | grep default | awk '{print $3}'")
    dns = runcommand("grep nameserver /etc/resolv.conf| grep -v '#' | awk '{print $2}' | tr '\n' ',' | sed 's/,$//'")
    ip = runcommand(
        "ip -f inet addr | grep -v 127.0.0.1 | grep inet | awk '{print $nf,$2}' | tr '\n' ',' | sed 's/,$//'")
    # todo 语句有问题会报错，sed的错误，需要检查下执行情况
    # mac = runcommand("ip link | grep -v 'loopback\|loopback' | awk '{print $2}' | sed 'n;s/\n//' | tr '\n' ',' | sed 's/,$//'")
    res = {
        'gateway': gateway,
        'dns': dns,
        'ip': ip
        # 'mac': mac
    }
    return res


def getuserstatus():
    """
    所有用户和空密码用户
    """
    all_user = runcommand("awk -f':' '{ print $1}' /etc/passwd")
    empty_passwd_user = runcommand("getent shadow | grep -po '^[^:]*(?=::)'")
    res = {
        '所有用户名': all_user,
        '空密码用户': empty_passwd_user
    }
    return res


def getjdkstatus():
    """
    jdk信息
    """
    jdkinfo = runcommand("java -version 2>&1")
    res = {
        'jdk信息': jdkinfo
    }
    return res


def getfirewallstatus():
    """
    防火墙
    """
    firewall = runcommand("firewall-cmd --state 2>&1")
    # 兼容 ubuntu 防火墙命令报错 sh: not found 特殊处理
    for info in firewall:
        if "not found" in info:
            firewall = runcommand("ufw status")
    res = {
        '防火墙状态': firewall
    }
    return res


def sshstatus():
    """
    ssh 检查
    """
    sshactive = runcommand("systemctl is-active sshd.service")
    sshnetstat = runcommand("sudo netstat -atlunp | grep sshd")
    res = {
        'ssh开启状态': sshactive,
        'ssh运行情况': sshnetstat
    }
    return res


def ntpstatus():
    """
    ntp 检查
    """
    ntpactive = runcommand("systemctl is-active ntpd")
    res = {
        'ntp运行情况': ntpactive
    }
    return res


def dockerstatus():
    """
    docker 检查
    """
    dk_version = runcommand("docker -v")
    dk_stats = []
    for info in dk_version:
        if "version" not in info:
            dk_version = "未安装docker"
        else:
            lines = os.popen(
                "docker stats --all --no-stream").readlines()
            for line in lines:
                dk_stats.append(line.replace('\n', ''))
    dp_version = runcommand("docker-compose --version")
    for info in dp_version:
        if "version" not in info:
            dp_version = "未安装docker-compose"
    res = {
        'docker version': dk_version,
        'docker-compose version': dp_version,
        'docker stats': dk_stats
    }
    return res


def createreportfile(name, text):
    """
    创建report的txt文件,并写入数据
    """
    report_dir = os.getcwd() + os.sep + "report" + os.sep
    # 判断当前路径是否存在，没有则创建new文件夹
    if not os.path.exists(report_dir):
        os.makedirs(report_dir)
    # 在当前py文件所在路径下的new文件中创建txt
    report_file = report_dir + name + '.txt'
    # 打开文件，open()函数用于打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。
    file = open(report_file, 'w')
    # 写入内容信息
    file.write(text)
    file.close()
    print('report_file create success', report_file)


def printsinfcloud():
    print("+------------------------------------------------+")
    print("|       欢迎使用sinfcloud自动巡检工具            |")
    print("| ____  _        __  ____ _                 _    |")
    print("|/ ___|(_)_ __  / _|/ ___| | ___  _   _  __| |   |")
    print("|\___ \| |  _ \| |_| |   | |/ _ \| | | |/ _  |   |")
    print("| ___) | | | | |  _| |___| | (_) | |_| | (_| |   |")
    print("||____/|_|_| |_|_|  \____|_|\___/ \__,_|\__,_|   |")
    print("|                                                |")
    print("+------------------------------------------------+")


if __name__ == '__main__':
    printsinfcloud()
    outputfilename = time.strftime('%y-%m-%d', time.localtime(time.time())) + "_report"
    report = list()
    report.append(getsysteminfo())
    report.append(getsystemstatus())
    report.append(getcpustatus())
    report.append(getmemstatussimple())
    report.append(getdiskstatus())
    report.append(getnetworkstatus())
    report.append(getuserstatus())
    report.append(getjdkstatus())
    report.append(getfirewallstatus())
    report.append(sshstatus())
    report.append(ntpstatus())
    report.append(dockerstatus())
    createreportfile(outputfilename,
                     json.dumps(report, sort_keys=true, indent=4, separators=(',', ':'), ensure_ascii=false))