Python скрипт за мониторинг на CPU, RAM и дискове с psutil

На скоро ми се наложи да напиша Python скрипт за мониторинг на системните ресурси. Работех по проект, който изискваше непрекъснато следене на производителността на сървъра. Класическите инструменти като htop и top са отлични, но имах нужда от нещо по-персонализирано – скрипт, който да записва данни, изпраща алерти и да може да се интегрира с други системи.

Точно тогава открих силата на Python библиотеката psutil. Оказа се, че с няколко реда код можех да създам собствен мониторинг инструмент, който работи точно както искам.

Python библиотеката psutil е като швейцарско ножче за системните ресурси. Тя ни позволява да създадем собствен инструмент за мониторинг с няколко реда код. В тази статия ще създадем практичен скрипт за следене на CPU, RAM и дискове.

Съдържание

Защо да използвам psutil?

psutil е мощна библиотека, която работи на всички операционни системи. Тя е лесна за използване и не изисква административни права. Библиотеката е като мост между Python и системните ресурси.

Най-големите предимства на psutil са:

Кросплатформена съвместимост
Богат набор от функции
Активна поддръжка
Отлична документация

Инсталация и първи стъпки

Първо инсталираме библиотеката:

pip install psutil

Нека започнем с прост пример за проверка на CPU:

import psutil

# Получаваме процентното натоварване на CPU
cpu_percent = psutil.cpu_percent(interval=1)
print(f"CPU използване: {cpu_percent}%")

Този код е като термометър за процесора. Параметърът interval=1 означава, че мерим за 1 секунда.

Мониторинг на CPU

CPU мониторингът е основа на всяка система за следене. Ето как да получим подробна информация:

import psutil
import time

def monitor_cpu():
    """Мониторинг на CPU информация"""
    # Общо натоварване
    cpu_total = psutil.cpu_percent(interval=1)
    
    # Натоварване по ядра
    cpu_cores = psutil.cpu_percent(interval=1, percpu=True)
    
    # Информация за процесора
    cpu_freq = psutil.cpu_freq()
    cpu_count = psutil.cpu_count()
    
    print(f"=== CPU МОНИТОРИНГ ===")
    print(f"Общо натоварване: {cpu_total}%")
    print(f"Брой ядра: {cpu_count}")
    print(f"Честота: {cpu_freq.current:.2f} MHz")
    
    print("\nНатоварване по ядра:")
    for i, core in enumerate(cpu_cores):
        print(f"  Ядро {i+1}: {core}%")

Този код е като детален доклад за състоянието на процесора. Можете да видите не само общото натоварване, но и как работи всяко ядро поотделно.

Мониторинг на RAM

Паметта е като работната маса на компютъра. Колкото повече място имаме, толкова повече можем да работим едновременно:

def monitor_memory():
    """Мониторинг на RAM паметта"""
    # Физическа памет
    memory = psutil.virtual_memory()
    
    # Swap памет
    swap = psutil.swap_memory()
    
    print(f"=== ПАМЕТ МОНИТОРИНГ ===")
    print(f"Обща памет: {memory.total / (1024**3):.2f} GB")
    print(f"Използвана: {memory.used / (1024**3):.2f} GB")
    print(f"Свободна: {memory.available / (1024**3):.2f} GB")
    print(f"Процент: {memory.percent}%")
    
    print(f"\nSwap памет:")
    print(f"Обща: {swap.total / (1024**3):.2f} GB")
    print(f"Използвана: {swap.used / (1024**3):.2f} GB")
    print(f"Процент: {swap.percent}%")

Този код показва не само колко памет използваме, но и swap паметта. Swap е като допълнителна памет на диска, която се използва когато RAM се запълни.

Мониторинг на дискове

Дисковото пространство е като склад – трябва да знаем какво имаме и колко място остава:

def monitor_disk():
    """Мониторинг на дискове"""
    print(f"=== ДИСКОВЕ МОНИТОРИНГ ===")
    
    # Получаваме всички дискове
    partitions = psutil.disk_partitions()
    
    for partition in partitions:
        try:
            # Статистика за всеки диск
            disk_usage = psutil.disk_usage(partition.mountpoint)
            
            print(f"\nДиск: {partition.device}")
            print(f"Файлова система: {partition.fstype}")
            print(f"Общо: {disk_usage.total / (1024**3):.2f} GB")
            print(f"Използвано: {disk_usage.used / (1024**3):.2f} GB")
            print(f"Свободно: {disk_usage.free / (1024**3):.2f} GB")
            print(f"Процент: {disk_usage.used / disk_usage.total * 100:.2f}%")
            
        except PermissionError:
            print(f"Няма достъп до {partition.device}")

Този код е като обхода на склада. Проверяваме всеки диск и виждаме колко място имаме.

Мониторинг на мрежата

Мрежовата активност е като пулса на системата. Ето как да я следим:

def monitor_network():
    """Мониторинг на мрежата"""
    # Мрежова статистика
    net_io = psutil.net_io_counters()
    
    print(f"=== МРЕЖА МОНИТОРИНГ ===")
    print(f"Изпратени байтове: {net_io.bytes_sent / (1024**2):.2f} MB")
    print(f"Получени байтове: {net_io.bytes_recv / (1024**2):.2f} MB")
    print(f"Изпратени пакети: {net_io.packets_sent}")
    print(f"Получени пакети: {net_io.packets_recv}")

Пълен мониторинг скрипт

Ето как да комбинирах всичко в един скрипт:

import psutil
import time
import os
from datetime import datetime

class SystemMonitor:
    """Клас за мониторинг на системните ресурси"""
    
    def __init__(self):
        self.start_time = time.time()
    
    def get_cpu_info(self):
        """Получава CPU информация"""
        cpu_percent = psutil.cpu_percent(interval=1)
        cpu_count = psutil.cpu_count()
        cpu_freq = psutil.cpu_freq()
        
        return {
            'percent': cpu_percent,
            'count': cpu_count,
            'frequency': cpu_freq.current if cpu_freq else 0
        }
    
    def get_memory_info(self):
        """Получава информация за паметта"""
        memory = psutil.virtual_memory()
        swap = psutil.swap_memory()
        
        return {
            'total': memory.total,
            'used': memory.used,
            'available': memory.available,
            'percent': memory.percent,
            'swap_total': swap.total,
            'swap_used': swap.used,
            'swap_percent': swap.percent
        }
    
    def get_disk_info(self):
        """Получава информация за дисковете"""
        disks = []
        partitions = psutil.disk_partitions()
        
        for partition in partitions:
            try:
                usage = psutil.disk_usage(partition.mountpoint)
                disks.append({
                    'device': partition.device,
                    'mountpoint': partition.mountpoint,
                    'fstype': partition.fstype,
                    'total': usage.total,
                    'used': usage.used,
                    'free': usage.free,
                    'percent': (usage.used / usage.total) * 100
                })
            except PermissionError:
                continue
        
        return disks
    
    def get_network_info(self):
        """Получава мрежова информация"""
        net_io = psutil.net_io_counters()
        
        return {
            'bytes_sent': net_io.bytes_sent,
            'bytes_recv': net_io.bytes_recv,
            'packets_sent': net_io.packets_sent,
            'packets_recv': net_io.packets_recv
        }
    
    def display_info(self):
        """Показва цялата информация"""
        os.system('clear' if os.name == 'posix' else 'cls')
        
        print("=" * 60)
        print(f"СИСТЕМЕН МОНИТОРИНГ - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        print("=" * 60)
        
        # CPU информация
        cpu = self.get_cpu_info()
        print(f"\n🖥️  CPU:")
        print(f"   Натоварване: {cpu['percent']:.1f}%")
        print(f"   Ядра: {cpu['count']}")
        print(f"   Честота: {cpu['frequency']:.0f} MHz")
        
        # Памет
        memory = self.get_memory_info()
        print(f"\n💾 ПАМЕТ:")
        print(f"   Използвана: {memory['used'] / (1024**3):.2f} GB / {memory['total'] / (1024**3):.2f} GB")
        print(f"   Процент: {memory['percent']:.1f}%")
        print(f"   Свободна: {memory['available'] / (1024**3):.2f} GB")
        
        # Дискове
        disks = self.get_disk_info()
        print(f"\n💿 ДИСКОВЕ:")
        for disk in disks:
            print(f"   {disk['device']}: {disk['used'] / (1024**3):.1f} GB / {disk['total'] / (1024**3):.1f} GB ({disk['percent']:.1f}%)")
        
        # Мрежа
        network = self.get_network_info()
        print(f"\n🌐 МРЕЖА:")
        print(f"   Изпратени: {network['bytes_sent'] / (1024**2):.1f} MB")
        print(f"   Получени: {network['bytes_recv'] / (1024**2):.1f} MB")
        
        print("\n" + "=" * 60)
        print("Натиснете Ctrl+C за изход")
    
    def run(self, interval=5):
        """Стартира мониторинга"""
        try:
            while True:
                self.display_info()
                time.sleep(interval)
        except KeyboardInterrupt:
            print("\n\nМониторингът е спрян.")

# Стартиране на скрипта
if __name__ == "__main__":
    monitor = SystemMonitor()
    monitor.run(interval=3)  # Обновява на всеки 3 секунди

Дабавих и имоджита за по добра визия.

Добавяне на алерти

Мониторингът без алерти е като пазач, който спи. Ето как да добавим предупреждения:

class AlertSystem:
    """Система за алерти"""
    
    def __init__(self):
        self.thresholds = {
            'cpu': 80,      # 80% CPU
            'memory': 85,   # 85% RAM
            'disk': 90      # 90% диск
        }
    
    def check_alerts(self, cpu_percent, memory_percent, disk_percent):
        """Проверява за алерти"""
        alerts = []
        
        if cpu_percent > self.thresholds['cpu']:
            alerts.append(f"🚨 ВИСО CPU: {cpu_percent:.1f}%")
        
        if memory_percent > self.thresholds['memory']:
            alerts.append(f"🚨 ВИСОКА ПАМЕТ: {memory_percent:.1f}%")
        
        if disk_percent > self.thresholds['disk']:
            alerts.append(f"🚨 ВИСОК ДИСК: {disk_percent:.1f}%")
        
        return alerts

Съхраняване на данни

Мониторингът без история е като дневник без страници. Ето как да съхраняваме данните:

import json
from datetime import datetime

class DataLogger:
    """Съхраняване на мониторинг данни"""
    
    def __init__(self, filename="system_monitor.json"):
        self.filename = filename
        self.data = []
    
    def log_data(self, cpu, memory, disk, network):
        """Записва данни"""
        entry = {
            'timestamp': datetime.now().isoformat(),
            'cpu_percent': cpu['percent'],
            'memory_percent': memory['percent'],
            'disk_usage': sum(d['percent'] for d in disk) / len(disk) if disk else 0,
            'network_sent': network['bytes_sent'],
            'network_recv': network['bytes_recv']
        }
        
        self.data.append(entry)
        
        # Запазваме само последните 1000 записа
        if len(self.data) > 1000:
            self.data = self.data[-1000:]
    
    def save_to_file(self):
        """Съхранява данните във файл"""
        with open(self.filename, 'w') as f:
            json.dump(self.data, f, indent=2)
    
    def load_from_file(self):
        """Зарежда данните от файл"""
        try:
            with open(self.filename, 'r') as f:
                self.data = json.load(f)
        except FileNotFoundError:
            self.data = []

Съвети за оптимизация

Когато работите с мониторинг, има няколко важни неща да помните:

Интервали на обновяване: Не обновявайте твърде често. Всеки 3-5 секунди е достатъчно за повечето случаи.

Производителност: psutil е бърз, но все пак използва системни ресурси. Следете собственото си потребление.

Грешки: Винаги обработвайте грешки, особено при достъп до дискове и мрежа.

История: Съхранявайте данни за анализ, но не претоварвайте диска.

Заключение

Създаването на собствен мониторинг инструмент с Python и psutil е като изграждането на персонален помощник за системата. Той ви помага да разберете как работи компютърът ви и да предотвратите проблеми.

Този скрипт е основа, върху която можете да строите. Можете да добавите графики, уеб интерфейс, или дори да изпращате данните към облачни услуги.

Най-важното е да започнете с прост код и постепенно да добавяте функции. Всеки опитен програмист е започвал с основите.

Мониторингът е като грижата за здравето – по-добре да предотвратим проблемите, отколкото да ги решаваме след това. С правилните инструменти и малко код можете да превърнете компютъра си в самонаблюдаваща се система.

Опитайте скрипта, експериментирайте с него и споделете вашите подобрения с общността. Това е начинът, по който всички учим и се развиваме заедно.

Федя Серафиев

Федя Серафиев e собственик на уебсайта urocibg.eu. Той намира удовлетворение в това да помага на хората да решават и най-сложните технически проблеми. Сегашната му цел е да пише лесни за следване статии, така че подобни проблеми изобщо да не възникват.

Благодарим ви за прочитането на статията! Ако намерихте информацията за полезна, можете да дарите посредством бутоните по-долу:

Donate ☕️ Дарете с PayPal Donate 💳 Дарете с Revolut