自动收集并监控服务器的CPU、内存、磁盘的使用情况，形成表格，发送到指定的一个目录。 https://github.com/Hilong2/serverinfo

  1. 定时获取Linux（或Windows）服务器的CPU、内存、磁盘的使用情况信息
  2. 将获取的信息存储到表格并保存在指定目录（或数据库）
  3. 读数据库，获取信息，将服务器的CPU、内存、磁盘的使用情况信息制作成图



1 基本信息

  • 主机名 sys_name
  • 内核名称 kernel_name
  • 发行版本号 kernel_no
  • 内核版本 kernel_version
  • 系统架构 sys_framework ```python import os

info = os.uname()

sys_name=info[1] kernel_name=info[0] kernel_no=info[2] kernel_version=info[3] sys_framework=info[4]

  2. - 现在时间 now_time
  3. - 开机时间 boot_time
  4. - 运行时间 up_time
  5. ```python
  6. import datetime
  8.     boot_time = datetime.datetime.fromtimestamp(psutil.boot_time())
  9.     boot_time_format = boot_time.strftime("%Y-%m-%d %H:%M:%S")
  10.     now_time = datetime.datetime.now()
  11.     now_time_format = now_time.strftime("%Y-%m-%d %H:%M:%S")
  12.     up_time = "{} 天 {} 小时 {} 分钟 {} 秒".format(
  13.         (now_time - boot_time).days,
  14.         str(now_time - boot_time).split('.')[0].split(':')[0],
  15.         str(now_time - boot_time).split('.')[0].split(':')[1],
  16.         str(now_time - boot_time).split('.')[0].split(':')[2]
  17.     )

2 用psutil模块等获得服务器信息

psutil = process and system utilities，它不仅可以通过一两行代码实现系统监控，还可以跨平台使用，支持Linux／UNIX／OSX／Windows等，是系统管理员和运维小伙伴不可或缺的必备模块。

2.1 显示CPU的使用情况

CPU的使用率 cpu_percent

  1. cpu_percent = psutil.cpu_percent(interval=None, percpu=False)

CPU用户使用率 cpu_time_percent.user

CPU系统使用率 cpu_time_percent.system

CPU空闲率 cpu_time_percent.idle

CPUiowait cpu_time_percent.iowait

  1. cpu_time_percent = psutil.cpu_times_percent()

CPU的平均负载（1分钟，5分钟，15分钟）load_avg[0][1][2]

  1. load_avg = os.getloadavg()

物理CPU核心数 physical_core_num

  1. physical_core_num = psutil.cpu_count(logical=False)

逻辑CPU核心数 logical_core_num

  1. logical_core_num = psutil.cpu_count()

正在运行频率 {{ (cpu_freq.current/1000)|round(2) }} GHz

最低运行频率 {{ (cpu_freq.min/1000)|round(2) }} GHz

最高运行频率 {{ (cpu_freq.max/1000)|round(2) }} GHz

  1.     try:
  2.         cpu_freq = psutil.cpu_freq()
  3.     except AttributeError:
  4.         cpu_freq = None

2.2 显示内存的使用情况

内存大小 context.total|format_size

可用内存 context.available|format_size

内存占用% context.percent %

已用内存 context.used|format_size

空闲内存 context.free|format_size

缓冲（buffers） context.buffers|format_size

缓存（cached）context.cached|format_size

共享内存 context.shared|format_size

  1. def memory(part, chart=None):
  2.     if part == 'memory':
  3.         if chart in ['line', 'column']:
  4.             return render_template('memory/memory-%s.html' % chart, part=part, chart=chart)
  5.         context = psutil.virtual_memory()
  6.     elif not chart and part == 'swap':
  7.         context = psutil.swap_memory()
  8.     else:
  9.         return render_template('404.html'), 404
  11.     return render_template('memory/%s.html' % part, context=context, part=part)

cache

缓存（cached）是把读取过的数据保存起来，重新读取时若命中（找到需要的数据）就不要去读硬盘了，若没有命中就读硬盘。其中的数据会根据读取频率进行组织，把最频繁读取的内容放在最容易找到的位置，把不再读的内容不断往后排，直至从中删除。 Cache并不是缓存文件的，而是缓存块的(块是I/O读写最小的单元)；Cache一般会用在I/O请求上，如果多个进程要访问某个文件，可以把此文件读入Cache中，这样下一个进程获取CPU控制权并访问此文件直接从Cache读取，提高系统性能。 Cache 作用域在于 Cpu 与内存之间

buffer

缓冲（buffers）是根据磁盘的读写设计的，把分散的写操作集中进行，减少磁盘碎片和硬盘的反复寻道，从而提高系统性能。当存储速度快的设备与存储速度慢的设备进行通信时，存储慢的数据先把数据存放到buffer，达到一定程度存储快的设备再读取buffer的数据，在此期间存储快的设备CPU可以干其他的事情。 linux有一个守护进程定期清空缓冲内容（即写入磁盘），也可以通过sync命令手动清空缓冲。 修改/etc/sysctl.conf中的vm.swappiness右边的数字可以在下次开机时调节swap使用策略。该数字范围是0～100，数字越大越倾向于使用swap。默认为60，可以改一下试试。–两者都是RAM中的数据。

2.3 显示磁盘的使用情况

设备 physical_disk_info[‘device’]

挂载点 physical_disk_info[‘mount_point’]

容量 physical_disk_info[‘space_total’]|format_size

已用 physical_disk_info[‘space_used’]|format_size

可用 physical_disk_info[‘space_free’]|format_size

已用% physical_disk_info[‘used_percent’] %

类型 physical_disk_info[‘type’]

  1.     if part == 'disk':
  2.         context = []
  3.         physical_disk_partitions = psutil.disk_partitions()
  4.         for physical_disk_partition in physical_disk_partitions:
  5.             physical_disk_usage = psutil.disk_usage(
  6.                 physical_disk_partition.mountpoint)
  7.             physical_disk = {
  8.                 'device': physical_disk_partition.device,
  9.                 'mount_point': physical_disk_partition.mountpoint,
  10.                 'type': physical_disk_partition.fstype,
  11.                 'options': physical_disk_partition.opts,
  12.                 'space_total': physical_disk_usage.total,
  13.                 'space_used': physical_disk_usage.used,
  14.                 'used_percent': physical_disk_usage.percent,
  15.                 'space_free': physical_disk_usage.free
  16.             }
  17.             context.append(physical_disk)

3 配置数据库并保存数据

90

  1. from pymongo import MongoClient
  2. import json
  5. class Json2Mongo(object):
  6.     def __init__(self):
  7.         self.host = '0.0.0.0'
  8.         self.port = 27017
  9.         # 创建mongodb客户端
  10.         self.client = MongoClient(self.host, self.port)
  11.         # 创建数据库dialog
  12.         self.db = self.client.dialog
  13.         # 创建集合scene
  14.         self.collection = self.db.scene
  15.         uiyexcdfibkmXK/d;lccc359ol, 1m ,    PMTCKP PJH9219I 
  16.         # 写入数据库
  17.         def write_database(self):
  18.             with open('dfcg_ivr.json', 'r') as f:
  19.                 # 转换为dict
  20.                 json_data = json.load(f)
  21.                 data = {
  22.                     "name": "dfcg_ivr",
  23.                     "content": json_data
  24.                 }
  25.                 try:
  26.                     myquery = {"name": "dfcg_ivr"}  # 查询条件
  27.                     self.collection.update(myquery, data, upsert=True)  # upsert=True不存在则插入，存在则更新
  28.                     # self.collection.insert(data)
  29.                     print('写入成功')
  30.                 except Exception as e:
  31.                     print(e)
  32.                     # 从数据库读取
  33.                     def read_datebase( self ):
  34.                         try:
  35.                             myquery = {"name": "dfcg_ivr"} # 查询条件
  36.                             scene_flow = self.collection.find(myquery)
  37.                             print(type(scene_flow))
  38.                             for x in scene_flow:
  39.                                 print(type(x))
  40.                                 print(x)
  41.                                 print ('读取成功')
  42.                             except Exception as e:
  43.                                 print (e)
  46.                                 if __name__ == '__main__':
  47.                                     jm = Json2Mongo()
  48.                                     jm.write_database()
  49.                                     jm.read_datebase()

4