代码实现高性能分布式云服务器性能监测系统

最新推荐文章于 2024-09-09 23:50:39 发布

GalileiX

最新推荐文章于 2024-09-09 23:50:39 发布

阅读量64

点赞数

文章标签：分布式服务器运维

Python 代码实现高性能分布式云服务器性能监测系统

数据收集模块（Agent）

在每个服务器节点上运行，收集性能数据。

import psutil
import time
import socket
import json

class PerformanceAgent:
    def __init__(self, server_ip, server_port):
        self.server_ip = server_ip
        self.server_port = server_port
    
    def collect_data(self):
        data = {
            "cpu_usage": psutil.cpu_percent(interval=1),
            "memory_usage": psutil.virtual_memory().percent,
            "disk_io": psutil.disk_io_counters()._asdict(),
            "network_io": psutil.net_io_counters()._asdict(),
            "timestamp": time.time()
        }
        return data
    
    def send_data(self, data):
        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
            sock.sendto(json.dumps(data).encode(), (self.server_ip, self.server_port))
    
    def run(self):
        while True:
            data = self.collect_data()
            self.send_data(data)
            time.sleep(5)  # 每5秒收集一次数据

if __name__ == "__main__":
    agent = PerformanceAgent(server_ip="192.168.1.100", server_port=9999)
    agent.run()

数据传输模块

负责将数据从各个Agent传输到中央服务器。

import socket
import json

class DataReceiver:
    def __init__(self, host, port):
        self.host = host
        self.port = port
    
    def start(self):
        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
            sock.bind((self.host, self.port))
            while True:
                data, addr = sock.recvfrom(65535)
                self.process_data(json.loads(data.decode()))
    
    def process_data(self, data):
        # 此处可将数据存入数据库或其他存储系统
        print("Received data:", data)

if __name__ == "__main__":
    receiver = DataReceiver(host="0.0.0.0", port=9999)
    receiver.start()

数据存储模块

在中央服务器上存储和管理性能数据。

from pymongo import MongoClient

class DataStorage:
    def __init__(self, db_host, db_port):
        self.client = MongoClient(db_host, db_port)
        self.db = self.client['performance_monitoring']
        self.collection = self.db['performance_data']
    
    def store_data(self, data):
        self.collection.insert_one(data)

if __name__ == "__main__":
    storage = DataStorage(db_host="localhost", db_port=27017)
    sample_data = {
        "cpu_usage": 50.5,
        "memory_usage": 70.2,
        "disk_io": {"read_count": 100, "write_count": 50},
        "network_io": {"bytes_sent": 1024, "bytes_recv": 2048},
        "timestamp": time.time()
    }
    storage.store_data(sample_data)

数据分析和报警模块

分析性能数据并生成报警。

class DataAnalyzer:
    def __init__(self, db_host, db_port):
        self.client = MongoClient(db_host, db_port)
        self.db = self.client['performance_monitoring']
        self.collection = self.db['performance_data']
    
    def analyze_data(self):
        cursor = self.collection.find().sort("timestamp", -1).limit(1)
        for data in cursor:
            if data["cpu_usage"] > 80:
                self.send_alert(f"High CPU usage detected: {data['cpu_usage']}%")
            if data["memory_usage"] > 90:
                self.send_alert(f"High Memory usage detected: {data['memory_usage']}%")
    
    def send_alert(self, message):
        print("ALERT:", message)

if __name__ == "__main__":
    analyzer = DataAnalyzer(db_host="localhost", db_port=27017)
    analyzer.analyze_data()

数据展示模块（Dashboard）

以可视化的方式展示性能数据和报警信息。

from flask import Flask, render_template, jsonify
from pymongo import MongoClient

app = Flask(__name__)

client = MongoClient("localhost", 27017)
db = client['performance_monitoring']
collection = db['performance_data']

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/data')
def get_data():
    cursor = collection.find().sort("timestamp", -1).limit(10)
    data = []
    for doc in cursor:
        data.append({
            "cpu_usage": doc["cpu_usage"],
            "memory_usage": doc["memory_usage"],
            "timestamp": doc["timestamp"]
        })
    return jsonify(data)

if __name__ == "__main__":
    app.run(debug=True)

C++ 代码实现高性能分布式云服务器性能监测系统

数据收集模块（Agent）

在每个服务器节点上运行，收集性能数据。

#include <iostream>
#include <string>
#include <thread>
#include <chrono>
#include <sys/sysinfo.h>
#include <fstream>
#include <json/json.h>
#include <arpa/inet.h>
#include <sys/socket.h>

class PerformanceAgent {
public:
    PerformanceAgent(const std::string& server_ip, int server_port)
        : server_ip(server_ip), server_port(server_port) {}

    void collect_data() {
        struct sysinfo sys_info;
        sysinfo(&sys_info);

        Json::Value data;
        data["cpu_usage"] = get_cpu_usage();
        data["memory_usage"] = (sys_info.totalram - sys_info.freeram) * 100 / sys_info.totalram;
        data["timestamp"] = std::time(nullptr);

        send_data(data);
    }

    void run() {
        while (true) {
            collect_data();
            std::this_thread::sleep_for(std::chrono::seconds(5));
        }
    }

private:
    std::string server_ip;
    int server_port;

    float get_cpu_usage() {
        std::ifstream file("/proc/stat");
        std::string line;
        std::getline(file, line);

        unsigned long long user, nice, system, idle;
        std::sscanf(line.c_str(), "cpu %llu %llu %llu %llu", &user, &nice, &system, &idle);
        
        static unsigned long long prev_user, prev_nice, prev_system, prev_idle;
        unsigned long long diff_idle = idle - prev_idle;
        unsigned long long diff_total = (user + nice + system + idle) - (prev_user + prev_nice + prev_system + prev_idle);

        prev_user = user;
        prev_nice = nice;
        prev_system = system;
        prev_idle = idle;

        return (diff_total - diff_idle) * 100.0 / diff_total;
    }

    void send_data(const Json::Value& data) {
        int sock = socket(AF_INET, SOCK_DGRAM, 0);
        struct sockaddr_in server_addr;
        server_addr.sin_family = AF_INET;
        server_addr.sin_port = htons(server_port);
        inet_pton(AF_INET, server_ip.c_str(), &server_addr.sin_addr);

        std::string data_str = Json::writeString(Json::StreamWriterBuilder(), data);
        sendto(sock, data_str.c_str(), data_str.size(), 0, (struct sockaddr*)&server_addr, sizeof(server_addr));
        close(sock);
    }
};

int main() {
    PerformanceAgent agent("192.168.1.100", 9999);
    agent.run();
    return 0;
}

数据传输模块

负责将数据从各个Agent传输到中央服务器。

#include <iostream>
#include <string>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <json/json.h>

class DataReceiver {
public:
    DataReceiver(int port) : port(port) {}

    void start() {
        int sock = socket(AF_INET, SOCK_DGRAM, 0);
        struct sockaddr_in server_addr, client_addr;
        server_addr.sin_family = AF_INET;
        server_addr.sin_port = htons(port);
        server_addr.sin_addr.s_addr = INADDR_ANY;

        bind(sock, (struct sockaddr*)&server_addr, sizeof(server_addr));

        char buffer[65536];
        while (true) {
            socklen_t client_len = sizeof(client_addr);
            ssize_t len = recvfrom(sock, buffer, sizeof(buffer) - 1, 0, (struct sockaddr*)&client_addr, &client_len);
            buffer[len] = '\0';

            process_data(buffer);
        }

        close(sock);
    }

private:
    int port;

    void process_data(const std::string& data_str) {
        Json::CharReaderBuilder reader;
        Json::Value data;
        std::string errs;

        std::istringstream s(data_str);
        std::string doc;
        while (std::getline(s, doc)) {
            if (!Json::parseFromStream(reader, s, &data, &errs)) {
                std::cerr << "Failed to parse data: " << errs << std::endl;
                continue;
            }

            std::cout << "Received data: " << data.toStyledString() << std::endl;
            // 这里可以将数据存入数据库或其他存储系统
        }
    }
};

int main() {
    DataReceiver receiver(9999);
    receiver.start();
    return 0;
}

数据存储模块

在中央服务器上存储和管理性能数据。

#include <iostream>
#include <sqlite3.h>
#include <string>
#include <json/json.h>

class DataStorage {
public:
    DataStorage(const std::string& db_name) {
        sqlite3_open(db_name.c_str(), &db);
        create_table();
    }

    ~DataStorage() {
        sqlite3_close(db);
    }

    void store_data(const Json::Value& data) {
        std::string sql = "INSERT INTO performance_data (cpu_usage, memory_usage, timestamp) VALUES (?, ?, ?);";
        sqlite3_stmt* stmt;
        sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, 0);
        sqlite3_bind_double(stmt, 1, data["cpu_usage"].asFloat());
        sqlite3_bind_double(stmt, 2, data["memory_usage"].asFloat());
        sqlite3_bind_int64(stmt, 3, data["timestamp"].asInt64());

        sqlite3_step(stmt);
        sqlite3_finalize(stmt);
    }

private:
    sqlite3* db;

    void create_table() {
        std::string sql = "CREATE TABLE IF NOT EXISTS performance_data ("
                          "id INTEGER PRIMARY KEY AUTOINCREMENT, "
                          "cpu_usage REAL, "
                          "memory_usage REAL, "
                          "timestamp INTEGER);";
        char* errMsg = nullptr;
        sqlite3_exec(db, sql.c_str(), 0, 0, &errMsg);
        if (errMsg) {
            std::cerr << "Failed to create table: " << errMsg << std::endl;
            sqlite3_free(errMsg);
        }
    }
};

int main() {
    DataStorage storage("performance_data.db");
    Json::Value sample_data;
    sample_data["cpu_usage"] = 50.5;
    sample_data["memory_usage"] = 70.2;
    sample_data["timestamp"] = std::time(nullptr);

    storage.store_data(sample_data);
    return 0;
}

数据分析和报警模块

分析性能数据并生成报警。

#include <iostream>
#include <sqlite3.h>
#include <string>

class DataAnalyzer {
public:
    DataAnalyzer(const std::string& db_name) {
        sqlite3_open(db_name.c_str(), &db);
    }

    ~DataAnalyzer() {
        sqlite3_close(db);
    }

    void analyze_data() {
        std::string sql = "SELECT cpu_usage, memory_usage FROM performance_data ORDER BY timestamp DESC LIMIT 1;";
        sqlite3_stmt* stmt;
        sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, 0);

        if (sqlite3_step(stmt) == SQLITE_ROW) {
            float cpu_usage = sqlite3_column_double(stmt, 0);
            float memory_usage = sqlite3_column_double(stmt, 1);

            if (cpu_usage > 80) {
                send_alert("High CPU usage detected: " + std::to_string(cpu_usage) + "%");
            }
            if (memory_usage > 90) {
                send_alert("High Memory usage detected: " + std::to_string(memory_usage) + "%");
            }
        }

        sqlite3_finalize(stmt);
    }

private:
    sqlite3* db;

    void send_alert(const std::string& message) {
        std::cout << "ALERT: " << message << std::endl;
    }
};

int main() {
    DataAnalyzer analyzer("performance_data.db");
    analyzer.analyze_data();
    return 0;
}

数据展示模块（Dashboard）

以可视化的方式展示性能数据和报警信息。

#include <cpprest/http_listener.h>
#include <cpprest/json.h>
#include <sqlite3.h>
#include <iostream>

using namespace web;
using namespace web::http;
using namespace web::http::experimental::listener;

class PerformanceDashboard {
public:
    PerformanceDashboard(const std::string& url, const std::string& db_name) 
        : listener(url), db_name(db_name

原创作者: u_14882565 转载于: https://blog.51cto.com/u_14882565/10890410

GalileiX

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
代码实现高性能分布式云服务器性能监测系统

Python 代码实现高性能分布式云服务器性能监测系统数据收集模块（Agent）在每个服务器节点上运行，收集性能数据。登录后复制 import psutilimport timeimport socketimport jsonclass PerformanceAgent: def __init__...
复制链接

扫一扫