簡介：使用flask結合python可以很好的實現服務資源的監控，而且Flask是一個使用 Python 編寫的輕量級 Web 應用框架。其 WSGI 工具箱采用 Werkzeug ，模板引擎則使用 Jinja2 。Flask使用 BSD 授權。

接下來我們實現多臺服務器的內存監控，並出圖。

環境：centos1-6.5 ip:172.25.0.31 ##做flask python數據獲取

Centos2-6.5 ip:172.25.0.32 ##做本地內存消耗數據的獲取

實現過程：

一、內存數據的獲取，並寫入到數據庫

1、我們先查看一下內存的信息

[root@centos mem]# cat /proc/meminfo
MemTotal:        1528700 kB
MemFree:          221028 kB
Buffers:          130764 kB
Cached:           604596 kB
SwapCached:         8440 kB

說明：

buffers是指用來給塊設備做的緩沖大小

cached是用來給文件做緩沖。

MemFree 是空閑內存

已使用內存算法：

已使用內存 = MemTotal - MemFree - Buffers - Cached

2、安裝數據庫，並創建數據庫和表。

為了減少資源的開銷，所以我們兩臺機器都裝上mysql，centos1-6.5，Centos2-6.5同時執行以下命令。

[root@centos ~]#yum  install  -y  mysql-server  mysql-devel

#啟動mysql

[root@centos ~]#/etc/init.d/mysqld  start

#快速配置，設置root密碼：

[root@centos ~]#mysql_secure_installation

創建數據庫：

[root@centos ~]# mysql  -uroot  -p123456
mysql> create database  memory;
mysql> use memory;
mysql> create table memory (memory int, time int);

註意1：用time字段表示時間戳，使用int類型為簡單化，這裏的數據庫名和表名，還有字段名，都使用memory，含義不同

註意2：我們在centos需要在centos2上獲取到寫入的數據，所以我們要添加權限，讓別的主機登錄連接到centos2的數據庫；

過程如下：

直接授權

　　從任何主機上使用root用戶，密碼：123456（你的root密碼）連接到mysql服務器：

[root@centos2 ~]# mysql -u root –p123456   ##給予其它用戶以root遠程登錄到本地mysql 
mysql>GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY '123456' WITH GRANT OPTION;
mysql>FLUSH PRIVILEGES

3、安裝MySQL模塊，編寫腳本。

[root@centos ~]# yum  install  MySQL-python   -y
[root@centos2 ~]# yum  install  MySQL-python   -y

編寫腳本監控內存腳本：

Centos

[root@centos~]# cat mem/mysql.py    ##同時把腳本復制到centos2就可以了
# -*- coding:utf-8 -*-
 
import time
import os
import MySQLdb as mysql
 
db = mysql.connect(user="root", passwd="123456", db="memory", host="localhost")
db.autocommit(True)
cur=db.cursor()
 
def saveMem():
     a="awk 'NR==1{print $2}' /proc/meminfo"
     file = os.popen(a)
     total=int(file.read())
 
     b="awk 'NR==2{print $2}' /proc/meminfo"
     file =os.popen(b)
     free =int(file.read())
 
     c="awk 'NR==3{print $2}' /proc/meminfo"
     file = os.popen(c)
     buffer =int(file.read())
 
     d="awk 'NR==4{print $2}' /proc/meminfo"
     file =os.popen(d)
     cache =int(file.read())
 
     mem_used=total-free-buffer-cache
     print mem_used/1024
     #mem = mem_used/1024 
     cur_time = int(time.time())
     sql = 'insert into memory (memory, time) value (%s,%s)'%(mem_used,cur_time)
     cur.execute(sql)
while True:
         saveMem()
         time.sleep(1)   # sleep 1 second

二、展現信息

1、構建web服務：

安裝flask

在centos1上執行

使用flask框架構建web服務

#安裝pip

[root@centos ~]# mkdir /root/tools
[root@centos ~]# cd   /root/tools
[root@centos ~]#wget  --no-check-certificate  https://bootstrap.pypa.io/get-pip.py
[root@centos ~]#python  get-pip.py

#使用pip安裝python的flask模塊：

[root@centos ~]#pip  install  flask

2、編輯後臺頁面

[root@centos ~]# cat /mem/flask_web.py
# -*- coding:utf-8 -*-
from flask import Flask,render_template   
import MySQLdb as mysql
import  json
con1 = mysql.connect(user="mysql", passwd="123456", db="memory", host="172.25.0.32")
con1.autocommit(True)
cur1 = con1.cursor()
 
con2 = mysql.connect(user="root", passwd="123456", db="memory", host="localhost")
con2.autocommit(True)
cur2 = con2.cursor()
 
app = Flask(__name__) 
last_time1 = 0
last_time2 = 0
@app.route('/')  
def index():
         return render_template('index.html')
@app.route('/data/a')
def data_a():
        global last_time1
         if (last_time1 > 0):
                   sql = 'select * from memory where time>%s' %(last_time1/1000)
         else:
                 sql = 'select * from memory'
         cur1.execute(sql)
         arr = []
         for i in cur1.fetchall():
                #print i    #在啟動flask web服務的終端打印
                arr.append([i[1]*1000, i[0]/1024])   #再除以1024，以MB為單位
         #return 'ok'
        if (len(arr) > 0):
                   last_time1 = arr[-1][0]
 
         return json.dumps(arr)
@app.route('/data/b')
def data_b():
        global last_time2
        if (last_time2 > 0):
                sql = 'select * from memory where time>%s' %(last_time2/1000)
        else:
                sql = 'select * from memory'
        cur2.execute(sql)
        arr = []
        for i in cur2.fetchall():
               #print i    #在啟動flask web服務的終端打印
                arr.append([i[1]*1000, i[0]/1024])   #再除以1024，以MB為單位
        #return 'ok'
        if (len(arr) > 0):
                last_time2 = arr[-1][0]
 
        return json.dumps(arr)
 
 
if __name__=='__main__':
        app.run(host='172.25.0.31', port=9092, debug=True)

3、使用圖表展現

1) 準備用於顯示圖片的基礎js文件

jquery.js 和 highstock.js ##這個網上很多有下載

並把這兩個文件保存到網站根目錄下的static子目錄下，導入以上兩個基礎js文件，用來渲染頁面。

2) 我們可以看看結構：

[root@centos mem]# tree
.
├── flask_web.py
├── mysql.py
├── static
│   ├── highstock.js
│   └── jquery.js
└── templates
    └── index.html

3) 接下來，使用highchats圖標，選擇圖表模板，選擇一個基本的圖，然後把js代碼復制帶index.html文件中。

https://www.hcharts.cn/demo/highstock/basic-line

4) 修改前端頁面中，配置網頁index.html：

[root@centos ~]# cat /mem/templates/index.html
<html>
<head>
        <title> my memory monitor </title>
</head>
 
<body>
<div id="container" style="min-width:400px;height:400px"></div>
 
<script src='/static/jquery.js'></script>
<script src='/static/highstock.js'></script>
<script type="text/javascript"> 
     Highcharts.setOptions({ global: { useUTC: false } });  
</script>              
<script>
$(function () {
    var seriesOptions = [],
        seriesCounter = 0,
        names = ['a','b'],
        // create the chart when all data is loaded
        createChart = function () {
            $('#container').highcharts('StockChart', {
                rangeSelector: {
                    selected: 4
                },
                yAxis: {
                    labels: {
                        formatter: function () {
                            return (this.value > 0 ? ' + ' : '') + this.value + '%';
                        }
                    },
                    plotLines: [{
                        value: 0,
                        width: 2,
                        color: 'silver'
                    }]
                },
                plotOptions: {
                    series: {
                        compare: 'percent'
                    }
                },
                tooltip: {
                    pointFormat: '<span style="color:{series.color}">{series.name}</span>: <b>{point.y}</b> ({point.change}%)<br/>',
                    valueDecimals: 2
                },
                series: seriesOptions
            });
        };
    $.each(names, function (i, name) {
        $.getJSON('/data/' + name.toLowerCase(),    function (data) {
            seriesOptions[i] = {
                name: name,
                data: data
            };
            // As we're loading the data asynchronously, we don't know what order it will arrive. So
            // we keep a counter and create the chart when all the data is loaded.
            seriesCounter += 1;
            if (seriesCounter === names.length) {
                createChart();
            }
        });
    });
});
 
</script>
</body>
</html>

四、執行腳本使用調試模式（google瀏覽器），查看網頁的數據

[root@centos mem]# python mysql.py
[root@centos2 mem]# python mysql.py
[root@centos mem]# python flask_web.py
 * Running on http://172.25.0.31:9092/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 171-534-904
172.25.0.2 - - [28/Nov/2017 21:35:57] "GET / HTTP/1.1" 200 -
172.25.0.2 - - [28/Nov/2017 21:35:57] "GET /data/a HTTP/1.1" 200 -
172.25.0.2 - - [28/Nov/2017 21:35:57] "GET /data/b HTTP/1.1" 200 -
172.25.0.2 - - [28/Nov/2017 21:35:59] "GET / HTTP/1.1" 200 -
172.25.0.2 - - [28/Nov/2017 21:35:59] "GET /data/a HTTP/1.1" 200 -
172.25.0.2 - - [28/Nov/2017 21:35:59] "GET /data/b HTTP/1.1" 200 –

我們可以發現，我們已經獲取到兩臺主機的內存得使用情況了。以上是本人的實現監控的搭建過程希望能幫到大家。

使用Flask結合python實現多臺服務的內存監控