网络安全-用脚本调用系统snmpwalk命令查询并邮件报警

最新推荐文章于 2024-08-12 12:19:46 发布
最新推荐文章于 2024-08-12 12:19:46 发布
阅读量423 收藏 2
点赞数 4
分类专栏： Network 安全 文章标签： 网络 snmp python 邮件报警
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PanDD_0_1/article/details/140639064
版权

SNMP.py

Linux系统，安装snmpwalk，python3

#!/usr/bin/python3
#_*_ coding:utf8 _*_

import os,time,re,subprocess

import smtplib
from smtplib import SMTP
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.header import Header

from concurrent.futures import ThreadPoolExecutor
from queue import Queue

## snmp OID
# snmpwalk -v 2c -c snmp读密码 SNMP服务器IP .1.3.6.1.2.1.25.3.3.1.2              # CPU负载
# snmpwalk -v 2c -c snmp读密码 SNMP服务器IP HOST-RESOURCES-MIB::hrProcessorLoad  # CPU负载
# snmpwalk -v 2c -c snmp读密码 SNMP服务器IP 1.3.6.1.2.1.25.2                     # 内存、硬盘使用率
# snmpwalk -v 2c -c snmp读密码 SNMP服务器IP 1.3.6.1.2.1.25                       # 进程使用cpu信息、进程使用内存信息，及内存、硬盘使用率

## 发邮件通知，设置邮件内容

def 纯文本邮件内容对象(邮件主题, 邮件正文, 发件人, 收件人):
    #创建一个带附件的实例
    message = MIMEMultipart()
    message['From'] = Header(发件人, 'utf-8')
    message['To'] =  Header(收件人, 'utf-8')
    # 邮件主题
    subject = 邮件主题
    message['Subject'] = Header(subject, 'utf-8')
    
    # 邮件正文，纯文本
    TEXT = MIMEText(邮件正文, 'plain', 'utf-8')
    message.attach(TEXT)
    return(message)

def 批量发邮件(SMTP_SERVER, 发件人, 邮箱密码, L_邮件任务):
    try:
        client = smtplib.SMTP()
        #client = smtplib.SMTP_SSL()    # 需要使用SSL，可以这样创建client
        client.connect(SMTP_SERVER, 25)
        #client.set_debuglevel(1)       # 开启DEBUG模式
        client.login(发件人, 邮箱密码)
    #except smtplib.SMTPConnectError as e:
    #    print('邮件发送失败，连接失败:', e.smtp_code, e.smtp_error)
    #except smtplib.SMTPAuthenticationError as e:
    #    print('邮件发送失败，认证错误:', e.smtp_code, e.smtp_error)
    #except smtplib.SMTPSenderRefused as e:
    #    print('邮件发送失败，发件人被拒绝:', e.smtp_code, e.smtp_error)
    #except smtplib.SMTPRecipientsRefused as e:
    #    print('邮件发送失败，收件人被拒绝:', e.smtp_code, e.smtp_error)
    #except smtplib.SMTPDataError as e:
    #    print('邮件发送失败，数据接收拒绝:', e.smtp_code, e.smtp_error)
    #except smtplib.SMTPException as e:
    #    print('邮件发送失败, ', e.message)
    except Exception as e:
        print(f"邮件发送异常 {e}")
    else:
        for 收件人,邮件主题,邮件正文 in L_邮件任务:
            time.sleep(2)
            message = 纯文本邮件内容对象(邮件主题, 邮件正文, 发件人, 收件人)
            try:
                client.sendmail(发件人, 收件人, message.as_string())
            except Exception as e:
                print(e)
            else:
                print(f"{time.strftime('%Y%m%d')} 发送成功: {收件人:32s} {邮件主题}")
        client.quit()
        print("发送完成")



## 获取CPU占用最高的前N个进程信息
def SHOW_PID_CPU_TOP_N(N, D_PID_NAME, D_PID_CPU):
    R_L_PID_CPU_TOP_N = []
    L_PID_CPU = [D_PID_CPU[i] for i in D_PID_CPU]   # 从D_PID_CPU字典中提取CPU占用量值做成列表
    L_PID_CPU.sort(reverse=True)                    # 从大到小排序
    for i in L_PID_CPU[0:N]:                        # 取开头N个
        for PID,PerfCPU in D_PID_CPU.items():
            if i == PerfCPU:
                PID_NAME = D_PID_NAME[PID]
                R_TEXT =  str(PID_NAME) + ' ' + str(PerfCPU)
                R_L_PID_CPU_TOP_N.append(R_TEXT)
    return(R_L_PID_CPU_TOP_N)


## 获取内存占用最高的前N个进程信息
def SHOW_PID_MEM_TOP_N(N, D_PID_NAME, D_PID_MEM):
    R_L_PID_MEM_TOP_N = []
    L_PID_MEM = [D_PID_MEM[i] for i in D_PID_MEM]
    L_PID_MEM.sort(reverse=True)                    # 从大大小排序
    for i in L_PID_MEM[0:N]:                        # 取开头N个
        for PID,PerfMem in D_PID_MEM.items():
            if i == PerfMem:
                PID_NAME = D_PID_NAME[PID]
                R_TEXT =  str(PID_NAME) + ' ' + str(PerfMem) + ' KBytes'
                R_L_PID_MEM_TOP_N.append(R_TEXT)
    return(R_L_PID_MEM_TOP_N)


## 处理SNMP查询结果，查CPU及内存，生成字典，方便使用
'''
# 进程名
HOST-RESOURCES-MIB::hrSWRunName.1 = STRING: "System Idle Process"
HOST-RESOURCES-MIB::hrSWRunName.4 = STRING: "System"
# 进程占用CPU
HOST-RESOURCES-MIB::hrSWRunPerfCPU.1 = INTEGER: 88064
HOST-RESOURCES-MIB::hrSWRunPerfCPU.4 = INTEGER: 725
# 进程使用内存
HOST-RESOURCES-MIB::hrSWRunPerfMem.1 = INTEGER: 4 KBytes
HOST-RESOURCES-MIB::hrSWRunPerfMem.4 = INTEGER: 140 KBytes
'''
def PID_NAME_CPU_MEM(output):
    D_PID_NAME = {}     # Key:'进程号', Value:'进程名'
    D_PID_CPU = {}      # Key:'进程号', Value:进程占用CPU时间(数值)
    D_PID_MEM = {}      # Key:'进程号', Value:进程占用内存数值(KBytes)
    RE_PID = "(HOST-RESOURCES-MIB::hrSWRunName(.*))|(HOST-RESOURCES-MIB::hrSWRunPerfCPU(.*))|(HOST-RESOURCES-MIB::hrSWRunPerfMem(.*))"  # SNMP返回结果用的RE过滤规则
    R = re.finditer(RE_PID, output)
    L_PID_INFO = [i.group() for i in R]
    for i in L_PID_INFO:                                    # 'HOST-RESOURCES-MIB::hrSWRunName.1 = STRING: "System Idle Process"'
        K,V = i.split(' = ')                                # 分割为 'HOST-RESOURCES-MIB::hrSWRunName.1' 和 'STRING: "System Idle Process"'
        NAME,INDEX = K.split('.')                           # 分割为 'HOST-RESOURCES-MIB::hrSWRunName' 和 '1'
        if NAME == 'HOST-RESOURCES-MIB::hrSWRunName':
            VV = V.split(': ')[-1]                          # 从 STRING: "System Idle Process" 中提取 "System Idle Process"
            D_PID_NAME[INDEX] = VV                          # {'1':"System Idle Process"}
        elif NAME == 'HOST-RESOURCES-MIB::hrSWRunPerfCPU':
            VV = int(V.split(': ')[-1])
            D_PID_CPU[INDEX] = VV                           # {'1': 88064}
        elif NAME == 'HOST-RESOURCES-MIB::hrSWRunPerfMem':
            VV = V.split(': ')[-1]
            PID_MEM = int(VV.split(' ')[0])
            D_PID_MEM[INDEX] = PID_MEM                      # {'1':4}
    return(D_PID_NAME, D_PID_CPU, D_PID_MEM)


def 单位转换(INT, UNIT):
    if UNIT == 'Bytes':
        X = round(INT/1024/1024/1024)
        return(f"{X}GB")
    else:
        return(f"{INT}{UNIT}")

## 执行SNMP命令获取CPU、内存、硬盘分区使用率信息
## 返回 (StatusCode, SYS_INFO, D_SYS_INFO)
## StatusCode 含义： 0 成功，1 查CPU失败，2 查MEM/DISK失败，3 查CPU/MEM/DISK都失败
## SYS_INFO (文本)字典类型存储CPU/MEM/DISK的使用率百分比
def SNMP_CPU_MEM_DISK_USED(SYSTEM, SNMP_HOST, SNMP_PWD):
    D_SYS_INFO = {'CPU':-1, 'MEM':-1, 'SWAP':-1, 'DISK':{}}
    SYS_INFO = ''       # 记录查询分析结果
    StatusCode = 0      # 函数执行结果状态码，SNMP命令执行情况：0 正常，1 获取CPU使用率的SNMP命令失败，2 获取CPU/内存/硬盘信息的SNMP命令失败，3 两个全部失败
    
    ## 获取CPU使用率的SNMP命令
    CMD = 'snmpwalk -v 2c -c ' + SNMP_PWD + ' ' + SNMP_HOST + ' HOST-RESOURCES-MIB::hrProcessorLoad'
    (CPU_status,CPU_output) = subprocess.getstatusoutput(CMD)     # 执行命令
    #print CPU_status
    #print CPU_output
    
    ## 获取内存、硬盘使用率的SNMP命令
    CMD = 'snmpwalk -v 2c -c ' + SNMP_PWD + ' ' + SNMP_HOST + ' 1.3.6.1.2.1.25.2'
    (MEM_DISK_status,ALL_output) = subprocess.getstatusoutput(CMD)     # 执行命令
    #print(CMD)
    #print MEM_DISK_status
    #print ALL_output
    
    ## 两次查询都成功再继续分析
    if CPU_status == 0 and MEM_DISK_status == 0:
        ## CPU负载
        L_CPU = []                                      # 存放每个核心的负载值
        L = CPU_output.split('\n')
        for i in L:
            X = i.split('=')[-1]
            Y = X.split(':')[-1]
            Z = int(Y)
            L_CPU.append(Z)
        if L_CPU != []:
            CPU_PCT = sum(L_CPU) / len(L_CPU)       # 计算CPU使用率
            D_SYS_INFO['CPU'] = CPU_PCT             # 记录CPU使用率
            SYS_INFO += f"CPU({len(L_CPU)}):{CPU_PCT:.1f}% | "  # 记录CPU(核心数):使用率%
        else:                                                   # SNMP信息中找不到CPU信息
            SYS_INFO += f"CPU({len(L_CPU)}):ERROR | "           # CPU使用率标记为错误
        
        ## 内存、磁盘分区使用率
        D_Storage = {}         # 字典，
        PHYSICAL_MEM_ID = None # 记录物理内存对应的ID号
        BUFFERS_MEM_ID = None  # 记录buff内存对应的ID号
        CACHED_MEM_ID = None   # 记录buff/cache内存对应的ID号
        #SHARED_MEM_ID = None   # 记录shared内存对应的ID号
        SWAP_SPACE_ID = None   # 记录SWAP内存对应的ID号
        L_DISK_ID = []         # 记录各分区的ID
        RE_hrStorage = '(HOST-RESOURCES-MIB::hrStorageType(.*))|(HOST-RESOURCES-MIB::hrStorageDescr(.*))|(HOST-RESOURCES-MIB::hrStorageSize(.*))|(HOST-RESOURCES-MIB::hrStorageUsed(.*))|(HOST-RESOURCES-MIB::hrStorageAllocationUnits(.*))'
        R = re.finditer(RE_hrStorage, ALL_output)                           # 从SNMP返回结果中过滤出需要的数据
        L_hrStorage_INFO = [i.group() for i in R]                           # 过滤出的结果做成列表
        #print("L_hrStorage_INFO", L_hrStorage_INFO)
        
        if SYSTEM == 'Linux':
            ## Linux 计算内存使用率
            for i in L_hrStorage_INFO:
                K,V = i.split('=')
                D_Storage[K] = V                                                # 过滤出的结果做成字典
                if V == ' STRING: Physical memory':
                    PHYSICAL_MEM_ID = K.split('.')[-1]                          # 物理内存对应的ID号
                elif V == ' STRING: Cached memory':
                    CACHED_MEM_ID = K.split('.')[-1]                            # buff/cache内存对应的ID号
                #elif V == ' STRING: Shared memory':
                #    SHARED_MEM_ID = K.split('.')[-1]                           # shared内存对应的ID号
                elif V == ' STRING: Memory buffers':
                    BUFFERS_MEM_ID = K.split('.')[-1]                           # buff内存对应的ID号
                elif V == ' STRING: Swap space':
                    SWAP_SPACE_ID = K.split('.')[-1]                            # SWAP内存对应的ID号
                elif V == ' OID: HOST-RESOURCES-TYPES::hrStorageFixedDisk':
                    L_DISK_ID.append(K.split('.')[-1])                          # 磁盘各分区对应的ID号
            #print("PHYSICAL_MEM_ID", PHYSICAL_MEM_ID)
            #print("BUFFERS_MEM_ID", BUFFERS_MEM_ID)
            #print("CACHED_MEM_ID", CACHED_MEM_ID)
            #print("SHARED_MEM_ID", SHARED_MEM_ID)
            #print("SWAP_SPACE_ID", SWAP_SPACE_ID)
            #print("D_Storage", D_Storage)
            #for KEY in D_Storage:
            #    print(f"|{KEY}|{D_Storage[KEY]}|")

            if PHYSICAL_MEM_ID != None and BUFFERS_MEM_ID != None and CACHED_MEM_ID != None and SWAP_SPACE_ID != None:
                PHYSICAL_MEM_Size_str = D_Storage['HOST-RESOURCES-MIB::hrStorageSize.' + PHYSICAL_MEM_ID]   # 内存总大小（簇数量）
                PHYSICAL_MEM_Size_int = int(PHYSICAL_MEM_Size_str.split(':')[-1])
                PHYSICAL_MEM_Used_str = D_Storage['HOST-RESOURCES-MIB::hrStorageUsed.' + PHYSICAL_MEM_ID]   # 内存使用大小（簇数量）
                PHYSICAL_MEM_Used_int = int(PHYSICAL_MEM_Used_str.split(':')[-1])
                BUFFERS_MEM_Used_str = D_Storage['HOST-RESOURCES-MIB::hrStorageUsed.' + BUFFERS_MEM_ID]
                BUFFERS_MEM_Used_int = int(BUFFERS_MEM_Used_str.split(':')[-1])
                CACHED_MEM_Used_str = D_Storage['HOST-RESOURCES-MIB::hrStorageUsed.' + CACHED_MEM_ID]
                CACHED_MEM_Used_int = int(CACHED_MEM_Used_str.split(':')[-1])
                #SHARED_MEM_Used_str = D_Storage['HOST-RESOURCES-MIB::hrStorageUsed.' + SHARED_MEM_ID]
                #SHARED_MEM_Used_int = int(SHARED_MEM_Used_str.split(':')[-1])
                SWAP_SPACE_Size_str = D_Storage['HOST-RESOURCES-MIB::hrStorageSize.' + SWAP_SPACE_ID]   # SWAP总大小（簇数量）
                SWAP_SPACE_Size_int = int(SWAP_SPACE_Size_str.split(':')[-1])
                SWAP_SPACE_Used_str = D_Storage['HOST-RESOURCES-MIB::hrStorageUsed.' + SWAP_SPACE_ID]   # SWAP总大小（簇数量）
                SWAP_SPACE_Used_int = int(SWAP_SPACE_Used_str.split(':')[-1])
                #print("PHYSICAL_MEM_Size_int", PHYSICAL_MEM_Size_int)
                #print("PHYSICAL_MEM_Used_int", PHYSICAL_MEM_Used_int)
                #print("BUFFERS_MEM_Used_int", BUFFERS_MEM_Used_int)
                #print("CACHED_MEM_Used_int", CACHED_MEM_Used_int)
                #print("SHARED_MEM_Used_int", SHARED_MEM_Used_int)
                #print("SWAP_SPACE_Size_int", SWAP_SPACE_Size_int)
                #print("SWAP_SPACE_Used_int", SWAP_SPACE_Used_int)
                
                ## 计算物理内存大小
                MEM_Unit_str = D_Storage['HOST-RESOURCES-MIB::hrStorageAllocationUnits.'+PHYSICAL_MEM_ID]   # 分区簇大小
                #print("MEM_Unit_str", MEM_Unit_str)
                Unit_INT, Unit_STR = MEM_Unit_str.split(':')[-1].split()
                MEM_Unit = (int(Unit_INT), Unit_STR)                                               # (簇大小, 单位)
                #print(f"MEM_Unit={MEM_Unit}")
                PHYSICAL_MEM_GB = 单位转换(PHYSICAL_MEM_Size_int*MEM_Unit[0], MEM_Unit[1])
                ## 计算交换分区大小
                SWAP_Unit_str = D_Storage['HOST-RESOURCES-MIB::hrStorageAllocationUnits.'+SWAP_SPACE_ID]   # 分区簇大小
                #print("SWAP_Unit_str", SWAP_Unit_str)
                Unit_INT, Unit_STR = SWAP_Unit_str.split(':')[-1].split()
                SWAP_Unit = (int(Unit_INT), Unit_STR)                                               # (簇大小, 单位)
                #print(f"SWAP_Unit={SWAP_Unit}")
                SWAP_GB = 单位转换(PHYSICAL_MEM_Size_int*SWAP_Unit[0], SWAP_Unit[1])
                
                ## Linux 计算物理内存使用率
                ## 【free命令 total】      = hrStorageSize.1(Physical memory 物理内存总容量)
                ## 【free命令 free 】      = hrStorageSize.1(Physical memory 物理内存总容量) - hrStorageUsed.1(Physical memory 物理内存已经使用容量)
                ## 【free命令 used 】      = total - free - buff/cache
                ## 【free命令 buff/cache】 = hrStorageUsed.6(Memory buffers) + hrStorageUsed.7(Cached memory)
                ## 内存使用量 = hrStorageSize.1 - (hrStorageSize.1 - hrStorageUsed.1)- (hrStorageUsed.6 + hrStorageUsed.7)
                ## 内存使用量(公式简化) = hrStorageUsed.1 - hrStorageUsed.6 - hrStorageUsed.7
                ## 内存使用率 = 内存使用量 / 内存总容量
                ## 内存使用率 = (hrStorageUsed.1 - hrStorageUsed.6 - hrStorageUsed.7) / hrStorageSize.1
                MEM_PCT = ((PHYSICAL_MEM_Used_int - BUFFERS_MEM_Used_int - CACHED_MEM_Used_int) * 100) / PHYSICAL_MEM_Size_int  # 计算内存使用率（百分比）
                SYS_INFO += f"MEM({PHYSICAL_MEM_GB}):{MEM_PCT:.1f}% | "     # 记录MEM(总大小(GB)):使用率%
                D_SYS_INFO['MEM'] = MEM_PCT         # 记录内存使用率
                
                ## Linux 计算SWAP使用率
                SWAP_PCT = (SWAP_SPACE_Used_int * 100) / SWAP_SPACE_Size_int
                #print("SWAP_PCT", SWAP_PCT)
                SYS_INFO += f"SWAP({SWAP_GB}):{SWAP_PCT:.1f}% | "     # 记录SWAP_PCT(总大小(GB)):使用率%
                D_SYS_INFO['SWAP'] = SWAP_PCT       # 记录SWAP使用率
            else:                              # SNMP信息中获取内存或交换分区失败
                SYS_INFO += "MEM(ERROR)  "      # 内存查询失败
                SYS_INFO += "SWAP(ERROR)  "     # SWAP查询失败
        elif SYSTEM == 'Windows':
            ## Windows 计算内存使用率
            MEM_ID = None       # 记录物理内存对应的ID号
            V_MEM_ID = None     # 记录虚拟内存对应的ID号
            for i in L_hrStorage_INFO:
                K,V = i.split('=')
                D_Storage[K] = V
                if V == ' OID: HOST-RESOURCES-TYPES::hrStorageRam':
                    MEM_ID = K.split('.')[-1]                                   # 物理内存对应的ID号
                elif V == ' OID: HOST-RESOURCES-TYPES::hrStorageVirtualMemory':
                    V_MEM_ID = K.split('.')[-1]                                 # 虚拟内存对应的ID号
                elif V == ' OID: HOST-RESOURCES-TYPES::hrStorageFixedDisk':
                    L_DISK_ID.append(K.split('.')[-1])                          # 磁盘各分区对应的ID号

            if MEM_ID != None:
                ## 计算使用率
                MEM_Size_str = D_Storage['HOST-RESOURCES-MIB::hrStorageSize.'+MEM_ID]   # 内存总大小（簇数量）
                MEM_Size_int = int(MEM_Size_str.split(':')[-1])
                MEM_Used_str = D_Storage['HOST-RESOURCES-MIB::hrStorageUsed.'+MEM_ID]   # 内存使用大小（簇数量）
                MEM_Used_int = int(MEM_Used_str.split(':')[-1])
                #print("MEM_Size_str", MEM_Size_str)
                #print("MEM_Size_int", MEM_Size_int)
                #print("MEM_Used_str", MEM_Used_str)
                #print("MEM_Used_int", MEM_Used_int)
                MEM_PCT = (MEM_Used_int * 100) / MEM_Size_int                           # 计算百分比
                #print("MEM_PCT", MEM_PCT)
                ## 计算大小
                MEM_Unit_str = D_Storage['HOST-RESOURCES-MIB::hrStorageAllocationUnits.'+MEM_ID]   # 分区簇大小
                #print("MEM_Unit_str", MEM_Unit_str)
                Unit_INT, Unit_STR = MEM_Unit_str.split(':')[-1].split()
                MEM_Unit = (int(Unit_INT), Unit_STR)                                               # (簇大小, 单位)
                #print(f"MEM_Unit={MEM_Unit}")
                ## 记录
                SYS_INFO += f"MEM({单位转换(MEM_Size_int*MEM_Unit[0], MEM_Unit[1])}):{MEM_PCT:.1f}% | "     # 记录MEM(总大小(GB)):使用率%
                D_SYS_INFO['MEM'] = MEM_PCT    # 记录内存使用率
            else:
                SYS_INFO += "MEM(ERROR) | "      # 内存查询失败
                
            if V_MEM_ID != None:
                ## 计算使用率
                V_MEM_Size_str = D_Storage['HOST-RESOURCES-MIB::hrStorageSize.'+V_MEM_ID]   # 内存总大小（簇数量）
                V_MEM_Size_int = int(V_MEM_Size_str.split(':')[-1])
                V_MEM_Used_str = D_Storage['HOST-RESOURCES-MIB::hrStorageUsed.'+V_MEM_ID]   # 内存使用大小（簇数量）
                V_MEM_Used_int = int(V_MEM_Used_str.split(':')[-1])
                V_MEM_PCT = (V_MEM_Used_int * 100) / V_MEM_Size_int                         # 计算百分比
                ## 计算大小
                V_MEM_Unit_str = D_Storage['HOST-RESOURCES-MIB::hrStorageAllocationUnits.'+V_MEM_ID]   # 分区簇大小
                #print("V_MEM_Unit_str", V_MEM_Unit_str)
                Unit_INT, Unit_STR = V_MEM_Unit_str.split(':')[-1].split()
                V_MEM_Unit = (int(Unit_INT), Unit_STR)                                                 # (簇大小, 单位)
                #print(f"V_MEM_Unit={V_MEM_Unit}")
                ## 记录
                SYS_INFO += f"V_MEM({单位转换(V_MEM_Size_int*V_MEM_Unit[0], V_MEM_Unit[1])}):{V_MEM_PCT:.1f}% | "     # 记录V_MEM(总大小(GB)):使用率%
                D_SYS_INFO['SWAP'] = V_MEM_PCT         # 记录SWAP使用率
            else:
                SYS_INFO += "V_MEM(ERROR) | "     # SWAP查询失败
        else:
            ## 非 Linux 非 Windows 系统
            SYS_INFO += 'NOT Linux/Windows'

        ## 计算磁盘分区使用率
        if L_DISK_ID != []:
            L_DISK_PATH_INFO = []
            for i in L_DISK_ID:
                DISK_Descr = D_Storage['HOST-RESOURCES-MIB::hrStorageDescr.'+i].split('STRING: ')[-1]   # 分区盘符等信息
                if SYSTEM == 'Windows':
                    DISK_Descr = DISK_Descr[0:2]                                                        # Windows系统简化分区盘符描述，只保留 'C:' 'D:' 形式
                DISK_Unit_str = D_Storage['HOST-RESOURCES-MIB::hrStorageAllocationUnits.'+i]            # 分区簇大小
                #print("DISK_Unit_str", DISK_Unit_str)
                Unit_INT, Unit_STR = DISK_Unit_str.split(':')[-1].split()
                DISK_Unit = (int(Unit_INT), Unit_STR)                                                   # (簇大小, 单位)
                #print(f"DISK_Unit={DISK_Unit}")
                DISK_Size_str = D_Storage['HOST-RESOURCES-MIB::hrStorageSize.'+i]                       # 分区总大小（簇数量）
                DISK_Size_int = int(DISK_Size_str.split(':')[-1])
                DISK_Used_str = D_Storage['HOST-RESOURCES-MIB::hrStorageUsed.'+i]                       # 分区已用大小（簇数量）
                DISK_Used_int = int(DISK_Used_str.split(':')[-1])
                DISK_PCT = (DISK_Used_int * 100) / DISK_Size_int                                        # 计算当前分区使用率
                D_SYS_INFO['DISK'][DISK_Descr] = (round(DISK_PCT, 1), DISK_Size_int*DISK_Unit[0], DISK_Unit[1]) # 记录当前分区(使用率,总大小,单位)
                L_DISK_PATH_INFO.append(f"{DISK_Descr}({单位转换(DISK_Size_int*DISK_Unit[0], DISK_Unit[1])}):{DISK_PCT:.1f}%")
            SYS_INFO += 'DISK_PATH: '
            SYS_INFO += ', '.join(L_DISK_PATH_INFO)
        else:                                                       ## SNMP信息中获取磁盘分区信息失败
            SYS_INFO += f"DISK_PATH: ERROR"
    else:
        ## 记录查询失败的情况，0 成功，1 查CPU失败，2 查MEM/DISK失败，3 查CPU/MEM/DISK都失败
        if CPU_status != 0:
            StatusCode += 1
            SYS_INFO += '【CPU 查询失败】'
        if MEM_DISK_status != 0:
            StatusCode += 2
            SYS_INFO += '【MEM/DISK 查询失败】'
    
    return(StatusCode, SYS_INFO, D_SYS_INFO)

def 普通_执行(TASK):
    SYSTEM, SNMP_PARAM, ALARM_PARAM, SAVE_FILE_PATH = TASK
    SNMP_IP, SNMP_PORT, SNMP_PWD = SNMP_PARAM
    CPU_ALARM, MEM_ALARM, SWAP_ALARM, DISK_ALARM, CPU_TOP_N, MEM_TOP_N = ALARM_PARAM
    
    L_ALARM = []        # 超阈值项目列表
    L_ERROR = []        # 错误信息列表
    L_CPU_TOP = []      # 当CPU超过阈值时记录CPU使用率最高的N个进程信息
    L_MEM_TOP = []      # 当MEM超过阈值时记录MEM使用率最高的N个进程信息
    SNMP_HOST = SNMP_IP + ':' + str(SNMP_PORT)
    StatusCode, SYS_INFO, D_SYS_INFO = SNMP_CPU_MEM_DISK_USED(SYSTEM, SNMP_HOST, SNMP_PWD)

    if StatusCode == 0:   # SNMP 执行成功
        ## 检查 CPU/MEM 查询结果
        ## 当 CPU 或 MEM 任意一个超过阈值时再次查SNMP记录进程信息
        if D_SYS_INFO['CPU'] > CPU_ALARM or D_SYS_INFO['MEM'] > MEM_ALARM:
            CMD = 'snmpwalk -v 2c -c ' + SNMP_PWD + ' ' + SNMP_HOST + ' 1.3.6.1.2.1.25' ## 获取CPU、内存、硬盘、进程信息的SNMP命令
            #print("再次执行SNMP命令查询进程信息")
            (status,output) = subprocess.getstatusoutput(CMD)     # 执行命令
            if status == 0:
                D_PID_NAME, D_PID_CPU, D_PID_MEM = PID_NAME_CPU_MEM(output)
                ## CPU 超过阈值，记录CPU占用最高的前N个进程信息
                if D_SYS_INFO['CPU'] > CPU_ALARM:
                    L_ALARM.append('CPU>'+str(CPU_ALARM))
                    L_CPU_TOP = SHOW_PID_CPU_TOP_N(CPU_TOP_N, D_PID_NAME, D_PID_CPU)
                ## MEM 超过阈值，记录MEM占用最高的前N个进程信息
                if D_SYS_INFO['MEM'] > MEM_ALARM:
                    L_ALARM.append('MEM>'+str(MEM_ALARM))
                    L_MEM_TOP = SHOW_PID_MEM_TOP_N(MEM_TOP_N, D_PID_NAME, D_PID_MEM)
            else:
                L_ERROR.append('SNMP 查 CPU/MEM Uesd Top 失败')
        
        ## 检查 SWAP 查询结果
        SWAP_PCT = D_SYS_INFO['SWAP']
        if SWAP_PCT == 'ERROR':
            L_ERROR.append('查SWAP失败')
        else:
            if SWAP_PCT > SWAP_ALARM:   # SWAP 使用率超过阈值
                L_ALARM.append('SWAP>'+str(SWAP_ALARM))
        
        ## 分析磁盘分区使用率
        if D_SYS_INFO['DISK'] == {}:
            L_ERROR.append('查DISK失败')
        else:
            for K in D_SYS_INFO['DISK']:
                if D_SYS_INFO['DISK'][K][0] > DISK_ALARM:  # 磁盘分区使用率超过阈值
                    L_ALARM.append('DISK PATH '+K+'>'+str(DISK_ALARM))
    elif StatusCode == 1:
        L_ERROR.append('查CPU失败')
    elif StatusCode == 2:
        L_ERROR.append('查MEM/DISK失败')
    elif StatusCode == 3:
        L_ERROR.append('查CPU/MEM/DISK都失败')
    
    ## SNMP查询结果
    # D_SYS_INFO = {'CPU':'', 'MEM':'', 'SWAP':'', 'DISK':{}}
    if SAVE_FILE_PATH == '':
        LOG_FILE = SYSTEM+'_'+SNMP_IP + '_' + SNMP_PORT + '.log'
    else:
        LOG_FILE = SAVE_FILE_PATH
    TIME = time.strftime('%Y-%m-%d %H:%M:%S')
    HOST = f"{SNMP_IP}:{SNMP_PORT}"
    LOG_TEXT = f"{HOST:21s} {TIME} | {SYS_INFO}"
    
    ALARM_TEXT = ''     # 告警信息，SNMP执行出错，指标超过阈值
    if L_ERROR != []:
        ALARM_TEXT += 'SNMP ERROR:\n'
        for i in L_ERROR:
            ALARM_TEXT += '  {0}\n'.format(i)
    if L_ALARM != []:
        ALARM_TEXT += 'SYS ALARM:\n'
        for i in L_ALARM:
            ALARM_TEXT += '  {0}\n'.format(i)
    if L_CPU_TOP != []:
        ALARM_TEXT += ' CPU_TOP_{0}\n'.format(CPU_TOP_N)
        for i in L_CPU_TOP:
            ALARM_TEXT += '  {0}\n'.format(i)
    if L_MEM_TOP != []:
        ALARM_TEXT += ' MEM_TOP_{0}\n'.format(MEM_TOP_N)
        for i in L_MEM_TOP:
            ALARM_TEXT += '  {0}\n'.format(i)
    
    if ALARM_TEXT != '':
        ALARM_TEXT = HOST + ' ' + ALARM_TEXT
    
    return((LOG_TEXT, ALARM_TEXT, SAVE_FILE_PATH))

def 显示任务进度(q, 计时开始时间, 显示时间间隔, 任务数量):
    while 1:
        time.sleep(显示时间间隔)
        if q.empty():
            continue
        else:
            LEN_NOW = q.qsize()
            print(f"进度 {LEN_NOW/任务数量*100:.0f}% ({LEN_NOW}/{任务数量}) 已用时 {int(time.time()-计时开始时间)} 秒")
            if q.qsize() == 任务数量:
                print("完成")
                break   # 终止线程

## 记录并分析SNMP返回结果
def 线程_执行(q, TASK):
    SYSTEM, SNMP_PARAM, ALARM_PARAM, SAVE_FILE_PATH = TASK
    SNMP_IP, SNMP_PORT, SNMP_PWD = SNMP_PARAM
    CPU_ALARM, MEM_ALARM, SWAP_ALARM, DISK_ALARM, CPU_TOP_N, MEM_TOP_N = ALARM_PARAM
    
    L_ALARM = []        # 超阈值项目列表
    L_ERROR = []        # 错误信息列表
    L_CPU_TOP = []      # 当CPU超过阈值时记录CPU使用率最高的N个进程信息
    L_MEM_TOP = []      # 当MEM超过阈值时记录MEM使用率最高的N个进程信息
    SNMP_HOST = SNMP_IP + ':' + str(SNMP_PORT)
    StatusCode, D_SYS_INFO = SNMP_CPU_MEM_DISK_USED(SYSTEM, SNMP_HOST, SNMP_PWD)

    if StatusCode == 0:   # SNMP 执行成功
        ## 检查 CPU/MEM 查询结果
        ## 当 CPU 或 MEM 任意一个超过阈值时再次查SNMP记录进程信息
        if D_SYS_INFO['CPU'] > CPU_ALARM or D_SYS_INFO['MEM'] > MEM_ALARM:
            CMD = 'snmpwalk -v 2c -c ' + SNMP_PWD + ' ' + SNMP_HOST + ' 1.3.6.1.2.1.25' ## 获取CPU、内存、硬盘、进程信息的SNMP命令
            #print("再次执行SNMP命令查询进程信息")
            (status,output) = subprocess.getstatusoutput(CMD)     # 执行命令
            if status == 0:
                D_PID_NAME, D_PID_CPU, D_PID_MEM = PID_NAME_CPU_MEM(output)
                ## CPU 超过阈值，记录CPU占用最高的前N个进程信息
                if D_SYS_INFO['CPU'] > CPU_ALARM:
                    L_ALARM.append('CPU>'+str(CPU_ALARM))
                    L_CPU_TOP = SHOW_PID_CPU_TOP_N(CPU_TOP_N, D_PID_NAME, D_PID_CPU)
                ## MEM 超过阈值，记录MEM占用最高的前N个进程信息
                if D_SYS_INFO['MEM'] > MEM_ALARM:
                    L_ALARM.append('MEM>'+str(MEM_ALARM))
                    L_MEM_TOP = SHOW_PID_MEM_TOP_N(MEM_TOP_N, D_PID_NAME, D_PID_MEM)
            else:
                L_ERROR.append('SNMP 查 CPU/MEM Uesd Top 失败')
        
        ## 检查 SWAP 查询结果
        SWAP_PCT = D_SYS_INFO['SWAP']
        if SWAP_PCT == 'ERROR':
            L_ERROR.append('查SWAP失败')
        else:
            if SWAP_PCT > SWAP_ALARM:   # SWAP 使用率超过阈值
                L_ALARM.append('SWAP>'+str(SWAP_ALARM))
        
        ## 分析磁盘分区使用率
        if D_SYS_INFO['DISK'] == {}:
            L_ERROR.append('查DISK失败')
        else:
            for K in D_SYS_INFO['DISK']:
                if D_SYS_INFO['DISK'][K] > DISK_ALARM:  # 磁盘分区使用率超过阈值
                    L_ALARM.append('DISK PATH '+K+'>'+str(DISK_ALARM))
    elif StatusCode == 1:
        L_ERROR.append('查CPU失败')
    elif StatusCode == 2:
        L_ERROR.append('查MEM/DISK失败')
    elif StatusCode == 3:
        L_ERROR.append('查CPU/MEM/DISK都失败')
    
    ## SNMP查询结果
    # D_SYS_INFO = {'CPU':'', 'MEM':'', 'SWAP':'', 'DISK':{}}
    if SAVE_FILE_PATH == '':
        LOG_FILE = SYSTEM+'_'+SNMP_IP + '_' + SNMP_PORT + '.log'
    else:
        LOG_FILE = SAVE_FILE_PATH
    TIME = time.strftime('%Y-%m-%d %H:%M:%S')
    #LOG_TEXT = '{0}  CPU: {1}%  MEM: {2}%  SWAP: {3}%  DISK:{4}\n'.format(TIME, D_SYS_INFO['CPU'], D_SYS_INFO['MEM'], D_SYS_INFO['SWAP'], D_SYS_INFO['DISK'])
    HOST = f"{SNMP_IP}:{SNMP_PORT}"
    LOG_TEXT = f"{HOST:21s} {TIME}  CPU:{D_SYS_INFO['CPU']:5.1f}%  MEM:{D_SYS_INFO['MEM']:5.1f}%  SWAP:{D_SYS_INFO['SWAP']:5.1f}%  DISK:{D_SYS_INFO['DISK']}"
    
    ALARM_TEXT = ''     # 告警信息，SNMP执行出错，指标超过阈值
    if L_ERROR != []:
        ALARM_TEXT += 'SNMP ERROR:\n'
        for i in L_ERROR:
            ALARM_TEXT += '  {0}\n'.format(i)
    if L_ALARM != []:
        ALARM_TEXT += 'SYS ALARM:\n'
        for i in L_ALARM:
            ALARM_TEXT += '  {0}\n'.format(i)
    if L_CPU_TOP != []:
        ALARM_TEXT += ' CPU_TOP_{0}\n'.format(CPU_TOP_N)
        for i in L_CPU_TOP:
            ALARM_TEXT += '  {0}\n'.format(i)
    if L_MEM_TOP != []:
        ALARM_TEXT += ' MEM_TOP_{0}\n'.format(MEM_TOP_N)
        for i in L_MEM_TOP:
            ALARM_TEXT += '  {0}\n'.format(i)
    
    if ALARM_TEXT != '':
        ALARM_TEXT = HOST + ' ' + ALARM_TEXT
    
    q.put((LOG_TEXT, ALARM_TEXT, SAVE_FILE_PATH))

def 多线程_执行(L_TASK, 并发数量):
    
    q = Queue()                         # 创建一个队列
    t1 = ThreadPoolExecutor(并发数量)   # 同时运行数量，不填则默认为cpu的个数*5
    for TASK in L_TASK:
        try:
            obj=t1.submit(线程_执行, q, TASK)
        except Exception as e:
            print(f"线程执行失败 {e}")
    
    t2 = ThreadPoolExecutor(1)      # 新开一个线程，用于显示进度
    计时开始时间 = time.time()
    显示时间间隔 = 2                # 秒
    任务数量 = len(L_TASK)          # 任务数量
    obj=t2.submit(显示任务进度, q, 计时开始时间, 显示时间间隔, 任务数量)
    t1.shutdown()
    t2.shutdown()
    
    L_R = []
    while 1:
        if q.empty():
            break
        L_R.append(q.get())
    return(L_R)


def 顺序执行(L_TASK, ALARM_SAVE_DIR, SHOW_or_SAVE, MAIL, MAIL_PARAM):
    if SHOW_or_SAVE == 'SHOW':
        for TASK in L_TASK:
            LOG_TEXT, ALARM_TEXT, SAVE_FILE_PATH = 普通_执行(TASK)
            print(LOG_TEXT)
            if ALARM_TEXT != '':
                print(ALARM_TEXT)
    else:
        ALARM_TEXT_ALL = ''
        for TASK in L_TASK:
            LOG_TEXT, ALARM_TEXT, SAVE_FILE_PATH = 普通_执行(TASK)
            with open(SAVE_FILE_PATH, 'a') as f:
                f.write(LOG_TEXT+'\n')
            if ALARM_TEXT != '':
                ALARM_TEXT_ALL += ALARM_TEXT + '\n'
    
        if ALARM_TEXT_ALL != '':
            if os.path.isdir(ALARM_SAVE_DIR):
                pass
            else:
                os.makedirs(ALARM_SAVE_DIR)
            ALARM_TIME = time.strftime('%Y%m%d_%H%M%S')
            ALARM_SAVE_PATH = os.path.join(ALARM_SAVE_DIR, f"{ALARM_TIME}.ALARM")
            with open(ALARM_SAVE_PATH, 'w') as f:
                f.write(ALARM_TEXT_ALL)
            
            if MAIL == 1:
                邮件服务器,发件人邮箱账号,发件人邮箱密码,收件人邮箱地址 = MAIL_PARAM
                L_邮件任务 = []
                主题 = f'服务器SNMP告警'
                邮件正文 = ALARM_TEXT_ALL
                邮件任务 = (收件人邮箱地址, 主题, 邮件正文)
                L_邮件任务.append(邮件任务)
                批量发邮件(邮件服务器, 发件人邮箱账号, 发件人邮箱密码, L_邮件任务)

def 并发执行(L_TASK, ALARM_SAVE_DIR, SHOW_or_SAVE, MAIL):
    并发数量 = len(L_TASK)
    R = 多线程_执行(L_TASK, 并发数量)
    if SHOW_or_SAVE == 'SHOW':
        for LOG_TEXT, ALARM_TEXT, SAVE_FILE_PATH in R:
            print(LOG_TEXT)
            if ALARM_TEXT != '':
                print(ALARM_TEXT)
    else:
        ALARM_TEXT_ALL = ''
        for LOG_TEXT, ALARM_TEXT, SAVE_FILE_PATH in R:
            with open(SAVE_FILE_PATH, 'a') as f:
                f.write(LOG_TEXT+'\n')
            if ALARM_TEXT != '':
                ALARM_TEXT_ALL += ALARM_TEXT + '\n'
        
        if ALARM_TEXT_ALL != '':
            if os.path.isdir(ALARM_SAVE_DIR):
                pass
            else:
                os.makedirs(ALARM_SAVE_DIR)
            ALARM_TIME = time.strftime('%Y%m%d_%H%M%S')
            ALARM_SAVE_PATH = os.path.join(ALARM_SAVE_DIR, f"{ALARM_TIME}.ALARM")
            with open(ALARM_SAVE_PATH, 'w') as f:
                f.write(ALARM_TEXT_ALL)
            
            if MAIL == 1:
                SMTP_SERVER = "smtp.邮件服务器.com"
                发件人 = "邮箱账号"
                邮箱密码 = "邮箱密码"
                
                L_邮件任务 = []
                收件人 = "邮箱账号"
                主题 = f'服务器SNMP告警'
                邮件正文 = ALARM_TEXT_ALL
                邮件任务 = (收件人, 主题, 邮件正文)
                L_邮件任务.append(邮件任务)
                
                批量发邮件(SMTP_SERVER, 发件人, 邮箱密码, L_邮件任务)


if __name__ == '__main__':
    ## 运行前设置参数
    
    ## SNMP参数设置
    #SNMP_IP = '192.168.250.22'  # SNMP被监控机的SNMP地址
    #SNMP_PORT = '161'           # SNMP被监控机的SNMP端口
    #SNMP_PWD = 'public'         # SNMP被监控机的SNMP密码
    
    ## 报警参数设置
    CPU_ALARM = 80      # CPU告警阈值（0-100）推荐 80
    MEM_ALARM = 80      # 内存告警阈值（0-100）推荐 80
    SWAP_ALARM = 80     # SWAP告警阈值（0-100）推荐 80
    DISK_ALARM = 80     # 分区使用率告警阈值（0-100）推荐 80
    CPU_TOP_N = 5       # 报警时显示N个CPU使用最高的进程
    MEM_TOP_N = 5       # 报警时显示N个MEM使用最高的进程
    ALARM_PARAM = [CPU_ALARM, MEM_ALARM, SWAP_ALARM, DISK_ALARM, CPU_TOP_N, MEM_TOP_N]
    
    ## 发邮件参数设置
    SMTP_SERVER = 'smtp.XXX.com'    # 发送者邮箱的SMTP服务器地址
    SENDER_USER = 'ABCg@XXX.com'    # 发送者用户名
    SENDER_PASS = 'pwd@000'         # 发送者密码
    RECEIVER = 'A@X.com'            # 接收者的邮箱 receiver
    MAIL_PARAM  = [SMTP_SERVER, SENDER_USER, SENDER_PASS, RECEIVER]
    
    ## 其他参数设置
    ALARM_SAVE_DIR = '/home/it/ALARM/'  # 告警信息本地存储目录
    SHOW_or_SAVE = 'SAVE'               # 'SHOW' 显示SNMP查询结果，'SAVE'保存SNMP结果
    MAIL = 0                            # 是否发邮件标志，0不发，1发送（当执行SNMP出错或者指标超过阈值时）
    
    
    L_TASK = []
    # 填 Linux 或 Windows 根据系统不同采用不同的CPU、内存计算方式
    L_TASK.append(('Linux',   ['192.168.100.2', '161', 'snmp密码'], ALARM_PARAM, '/home/it/SNMP/192.168.100.2.log'))
    L_TASK.append(('Windows', ['192.168.200.2', '161', 'snmp密码'], ALARM_PARAM, '/home/it/SNMP/192.168.200.2.log'))
    
    ## 运行
    顺序执行(L_TASK, ALARM_SAVE_DIR, SHOW_or_SAVE, MAIL, MAIL_PARAM)
    #并发执行(L_TASK, ALARM_SAVE_DIR, SHOW_or_SAVE, MAIL) # 有问题未解决
    
    ## 加入系统计划任务
    ## /usr/bin/python3 /home/it/PY/SNMP.py >> /home/it/PY/py.log

【SNMP】snmp trap 介绍、安装、命令|Trap的发送与接收代码实现
小鱼菜鸟的博客
07-22 1万+
目录 零、简略 一、SNMP简单概述 1.1、什么是Snmp 1.2、为什么需要SNMP？ 1.3、SNMP的基本组件 1.4、SNMP 和 UDP 1.5、Snmp版本 二、Snmp有关的基本概念 2.1、代理和管理站的模型 2.2、SNMP的操作命令 2.3、SNMP 报文 三、SNMP的运行过程 1.7 SNMP trap...
snmp工具_运维超级好用工具大PK，你在用哪个？
weixin_39997173的博客
12-08 4064
运维行业有句话：“无监控、不运维”，是的，一点也不夸张，监控俗称“第三只眼”。没了监控，什么基础运维，业务运维都是“瞎子”。所以说监控是运维这个职业的根本。尤其是在现在DevOps这么火的时候，用监控数据给自己撑腰，这显得更加必要。有人说运维是背锅侠，那么，有了监控，有了充足的数据，一切以数据说话，运维还需要背锅吗，所以作为一个运维工程师，如何构建一套监控系统是你的第一件工作。1、常见的运维监控工...
linux snmp使用
weixin_34112181的博客
11-16 157
确保安装这几个包 # rpm -qa |grep snmp net-snmp-5.1.2-11.EL4.7 net-snmp-libs-5.1.2-11.EL4.7 net-snmp-devel-5.1.2-11.EL4.7 net-snmp-utils-5.1.2-11.EL4.7 net-snmp-perl-5.1.2-11.EL4.7 请到安装盘里...
配置 Linux 的 SNMP 服务
最新发布
weixin_44112083的博客
08-12 2649
在 Linux 系统的 net-snmp 服务中添加自定义的 OID，并使用软件制作包含自定义 OID 的 MIB 文件用于客户快速调试自定义的 OID
python 并行执行for循环实现SNMP查询
daxiaoyang199的博客
02-23 497
from pysnmp.hlapi import * from threading import Thread import subprocess from queue import Queue from multiprocessing.dummy import Pool as ThreadPool import multiprocessing num_threads=254 q = Queue() liveips=['192.168.183.1','192.168.183.2','192.168.183.
使用Python进行snmp操作
weixin_30817749的博客
05-08 581
摘自https://www.cnblogs.com/lisenlin/p/10491681.html Python模块之snmp-cmds,easysnmp 一、简介 snmp-cmds模块通过SNMP与目标设备进行通信，此模块适用于windows，此模块是基于系统已安装了net-snmp环境easysnmp模块通过SNMP与谬表设备进行通信，此模块用于linux,此模块基...
PHP类采集SNMP hrSWRunTable hrSWRunPerfTable 并解析Running_Applications
allway2的博客
06-11 827
<?php error_reporting(0); class Running_Applications { public function __construct($operating_system, $host_address) { $this->operating_system = $operating_sy...
NET-SNMP配置与使用指南
2.1 **本地通过localhost测试**：这部分介绍如何使用SNMP命令行工具（如snmpget、snmpwalk）在本地通过localhost地址进行通信测试。 2.2 **本地通过IP测试**：测试与通过主机名或IP地址连接到同一台机器上的SNMP代理...
NET-SNMP安装与配置指南
此外，设置环境变量是确保NET-SNMP正常工作的重要步骤，它能让系统识别并正确地调用SNMP相关工具。 在配置方面，手册深入讲解了`snmpd.conf`配置文件，这是SNMP服务的核心。其中，通道控制配置涉及到定义安全体名称...
通过SNMP监控AIX系统的简单案例
MySpace
03-08 7013
转载于：http://blog.chinaunix.net/uid-316679-id-3615725.html SNMP即简单网络管理协议（Simple Network Management Protocol），通过该协议可以管理各种不同厂家的软硬件产品，常常用于对设备状态的监控，可以说是网管软件中最常用的服务之一。 本文主要向大家简单介绍SNMP服务在AIX6.1中的配置，以及如何
94.3. SNMP 命令
weixin_33682790的博客
12-21 121
94.3.1.snmpwalk $ snmpwalk -c public -v2c 172.16.1.10 hrSWRunPerfMem | awk 'BEGIN {total_mem=0} { if ($NF == "KBytes") {total_mem=total_mem+$(NF-1)}} END {print total_m...
编写shell脚本，实现交换机自动巡检
weixin_42601702的博客
02-13 505
编写shell脚本实现交换机的自动巡检，可以使用如下步骤： 获取交换机的状态信息：使用命令行工具如 "snmpwalk" 或 "snmpget" 获取交换机的相关信息，包括端口状态、流量等。 分析获取的信息：使用脚本语言，如 shell、python 等，分析获取的信息，并筛选出需要关注的信息，例如网络中存在的故障。 报告问题：如果发现网络故障，则使用邮件、短信或其他方式将故障信息通知管理员...
linux下的SNMP设置(snmp get/set/trap)
Sam_Yishao的博客
06-09 6038
SNMP 和 SNMP Trap 测试接收端环境的配置
linux每隔几秒杀死进程,如何每隔5秒在linux中找到特定进程的内存消耗
weixin_36222664的博客
04-29 322
我只是想知道如何在特定时间(比如5秒)找到特定进程的内存消耗我是linux的新手。 因此，这样做的详细步骤将不胜感激你能定义一下"特定时间的内存消耗"对你意味着什么？ 请记住，一个free -d的内存区域通常仍然(内部)由系统分配(因为它将被重新使用并在稍后的某个malloc处返回)。 您可能想要使用valgrind使用top -p PID，其中PID是进程ID。应显示有关该过程的信息，包括使用的...
zabbix使用snmp监控（亲测）
weixin_43287508的博客
09-16 8184
zabbix使用snmp监控 snmpwalk是SNMP的一个工具，它使用SNMP的GETNEXT请求查询指定OID（SNMP协议中的对象标识）入口的所有OID树信息，并显示给用户。通过snmpwalk也可以查看支持SNMP协议（简单网络管理协议）的设备的一些其他信息，比如交换机或路由器IP地址、内存使用率等，也可用来协助开发SNMP功能。 在日常监控中,经常会用到snmp服务,而snmpwalk...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值