В предыдущей публикации, посвящённой извлечению системной информации с помощью Python, был отмечен высокий читательский интерес. В настоящей статье предлагается расширенное рассмотрение методов программирования и получения данных, выходящих за рамки системной информации и анализа сетевых пакетов.
Настоящее статья будет структурировано по следующему принципу "теория-практика".

Почему Python?

Ввиду необходимости создания небольших скриптов для решения задач системного администрирования, Python был выбран в качестве наиболее эффективного инструмента, не требующего использования ресурсоемких сред разработки.

Теперь разберём, что такое сетевые пакеты?

Что такое сетевые пакеты?

В основе функционирования современных компьютерных сетей лежит концепция передачи данных в виде дискретных блоков, называемых сетевыми пакетами. Простыми словами, пакет – это контейнер, содержащий фрагмент информации, предназначенный для доставки от отправителя к получателю. Представьте себе почтовую службу: вместо отправки целого письма одним отправлением, его разбивают на отдельные конверты (пакеты), каждый из которых содержит часть информации и адрес получателя. Эти конверты могут следовать разными маршрутами и прибывать в разное время, но в конечном итоге получатель собирает все части и восстанавливает целостность письма.

Аналогично, данные, передаваемые по сети, разбиваются на пакеты. Каждый пакет содержит заголовок, содержащий метаданные, необходимые для маршрутизации и обработки данных (например, IP-адрес отправителя и получателя, номер пакета в последовательности, тип данных), и полезную нагрузку – сами данные, которые необходимо передать. Размер пакета ограничен техническими характеристиками сети, чтобы обеспечить эффективную передачу и избежать потерь информации.

Разбиение данных на пакеты обеспечивает ряд преимуществ:

• Надежность: Если один пакет повредится или потеряется, передача остальных может продолжаться без перерыва, а потерянный пакет может быть запрошен заново.

• Эффективность: Разделение данных позволяет нескольким устройствам одновременно использовать ресурсы сети, увеличивая пропускную способность.

• Гибкость: Различные типы данных могут передаваться одновременно, используя тот же сетевой протокол.

• Маршрутизация: Каждый пакет может быть направлен по оптимальному маршруту, даже если путь до получателя изменчив.

Иногда приходится проверять безопасность сети для клиентов или компаний. Можно, конечно, использовать Wireshark, но это очень долгая и скучная работа. Поэтому я решил посмотреть, какие есть библиотеки Python, которые могут перехватывать пакеты и автоматически генерировать отчеты. Инструмент уже готов, покажу, как им пользоваться, чуть позже, а пока просто запомните, что такое возможно.

Хорошо, мы разобрались с сетевыми пакетами. Теперь давайте посмотрим на новые библиотеки, которые будем использовать. Если хотите освежить знания о старых, можете заглянуть в мою предыдущую статью.

GPUtil: Простой доступ к информации о графическом процессоре

GPUtil – это небольшая, но мощная библиотека Python, предоставляющая простой и удобный интерфейс для получения информации о графических процессорах (GPU) в системе. В отличие от сложных низкоуровневых API, GPUtil абстрагирует детали взаимодействия с аппаратным обеспечением, предоставляя пользователю высокоуровневый доступ к ключевым метрикам производительности GPU. Это делает GPUtil идеальным инструментом для мониторинга и управления ресурсами GPU в различных приложениях, от скриптов мониторинга до сложных систем машинного обучения.

Основная функциональность GPUtil заключается в предоставлении информации о:

• Загрузке GPU: Процент использования вычислительных ресурсов GPU.

• Использовании памяти GPU: Объём памяти, занятой процессами.

• Частоте GPU: Тактовая частота графического процессора.

• Температуре GPU: Температура графического чипа.

• Идентификации GPU: Модель и производитель GPU.

Простота использования GPUtil делает его привлекательным для разработчиков, не имеющих глубоких знаний в области низкоуровневого программирования графических процессоров. Библиотека легко интегрируется в существующие Python-проекты и не требует установки дополнительных зависимостей.

Пример консольного приложения для получения информации о видеокарте:

Следующий код демонстрирует использование GPUtil для получения базовой информации о GPU и вывода её в консоль:

import GPUtil

gpus = GPUtil.getGPUs()

if gpus:
    for gpu in gpus:
        print(f"GPU ID: {gpu.id}")
        print(f"Название: {gpu.name}")
        print(f"Загрузка: {gpu.load*100:.2f}%")
        print(f"Использование памяти: {gpu.memoryUtil*100:.2f}%")
        print(f"Температура: {gpu.temperature:.2f}°C")
        print("-" * 20)
else:
    print("GPU не обнаружено.")

Этот простой скрипт выводит информацию о каждом обнаруженном GPU, включая его ID, название, загрузку, использование памяти и температуру. Этот пример демонстрирует минимальную функциональность GPUtil, библиотека предоставляет и более расширенные возможности, такие как получение информации об использовании памяти отдельными процессами, что делает её незаменимым инструментом для мониторинга и оптимизации работы GPU в различных приложениях. Простота в использовании и широкий функционал делают GPUtil ценным инструментом для широкого круга разработчиков, работающих с графическими процессорами.

GPUtil — реально полезная штука для диагностики видеокарт. С её помощью можно легко выявить проблемы с видеокартой, драйверами или даже всей системой. Лично мне она несколько раз здорово помогла найти неполадки.

Scapy: Исследование сетевого трафика на языке Python

Scapy – это мощная и гибкая библиотека Python, предназначенная для работы с сетевыми пакетами. Она предоставляет разработчикам инструменты для создания, отправки, анализа и модификации пакетов различных сетевых протоколов, таких как IP, TCP, UDP и ARP. Простыми словами, Scapy позволяет "видеть" и "взаимодействовать" с сетевым трафиком на низком уровне, что делает её незаменимым инструментом для сетевого анализа, тестирования безопасности и разработки специализированных сетевых инструментов.

В отличие от утилит командной строки, таких как tcpdump или Wireshark, Scapy предоставляет интерактивную среду программирования, позволяющую автоматизировать сложные задачи анализа и манипулирования сетевыми пакетами. Это позволяет создавать скрипты для автоматического сканирования сети, обнаружения уязвимостей, имитации атак и анализа сетевого трафика в режиме реального времени.

Ключевые возможности Scapy:

• Создание пакетов: Scapy позволяет создавать пакеты практически любого сетевого протокола, задавая их поля и значения.

• Отправка пакетов: Библиотека предоставляет функции для отправки созданных пакетов в сеть, позволяя имитировать различные сетевые сценарии.

• Анализ пакетов: Scapy умеет эффективно анализировать полученные пакеты, извлекая из них нужную информацию.

• Фильтрация пакетов: Возможность отфильтровывать пакеты по различным критериям (например, по IP-адресу, порту, протоколу).

• Модификация пакетов: Scapy позволяет изменять поля пакетов, что полезно для тестирования безопасности и анализа сетевого трафика.

Пример кода для просмотра сетевых пакетов в консоли:

Следующий код демонстрирует использование Scapy для перехвата и вывода информации о сетевых пакетах на консоль. Обратите внимание, что для запуска этого кода требуются root-права:

from scapy.all import *

# Запуск sniffer'a на дефолтном интерфейсе
sniff(prn=lambda x: print(x.summary()), count=10)

Этот скрипт запускает sniffer (перехватчик пакетов) на указанном сетевом интерфейсе и выводит краткое описание (summary) первых 10 перехваченных пакетов. Функция prn определяет, какое действие будет выполнено с каждым перехваченным пакетом. В данном случае, это вывод краткого описания с помощью x.summary(). Более сложные сценарии могут включать фильтрацию пакетов, извлечение специфической информации и другие операции.

Scapy — мощная штука, её можно даже научить сортировать данные с помощью нейросетей — почти полностью автоматизировать обработку. Ладно, с библиотеками разобрались. Теперь давайте поговорим о том, зачем всё это системному администратору нужно.

Так зачем это системному администратору?

Современный системный администратор – это не просто техник, следящий за исправностью оборудования. Это специалист, способный эффективно управлять сложными IT-инфраструктурами, автоматизировать рутинные задачи и оперативно реагировать на инциденты. В этом контексте библиотеки Python, такие как Scapy и GPUtil, становятся незаменимыми помощниками, расширяющими возможности и повышающими эффективность работы.

Зачем системному администратору Scapy?

Scapy предоставляет уникальный доступ к сетевому уровню. Представьте себе ситуацию: нужно проанализировать сетевой трафик, выявить узкие места, обнаружить потенциальные угрозы безопасности или просто проверить работоспособность сети. Ручной анализ с помощью Wireshark – это долго, нудно и неэффективно, особенно если речь идет о больших объемах данных. Scapy позволяет автоматизировать этот процесс. С помощью Scapy можно написать скрипты для:

• Мониторинга сетевого трафика: Отслеживание изменений в сетевой активности, выявление аномалий.

• Автоматизированного тестирования: Проверка доступности сетевых устройств и сервисов.

• Анализа безопасности: Обнаружение потенциальных угроз, таких как поддельные пакеты или атаки типа "отказ в обслуживании".

• Создание специализированных инструментов: Разработка собственных утилит для решения специфических задач.

Зачем системному администратору GPUtil?

В современных системах, особенно серверах, часто используется графический процессор (GPU) не только для графики, но и для вычислений (например, в машинном обучении, обработке видео). GPUtil позволяет легко получить информацию о загрузке GPU, использовании памяти, температуре и других важных параметрах. Это позволяет:

• Мониторить производительность GPU: Выявление перегрузок, проблем с охлаждением и других неполадок.

• Оптимизировать использование ресурсов: Распределение нагрузки между CPU и GPU для повышения эффективности.

• Автоматизировать отслеживание ошибок: Создание скриптов для автоматического оповещения о критических событиях (например, перегрев GPU).

Автоматизация рутинных задач:

И Scapy, и GPUtil позволяют автоматизировать множество рутинных задач, освобождая время системного администратора для более сложных и важных проектов. Например, можно создать скрипт, который будет автоматически проверять доступность серверов, анализировать сетевой трафик на наличие аномалий и оповещать администратора о критических событиях.

Почему системному администратору важно изучать эти библиотеки?

В постоянно развивающемся мире IT, знание специализированных инструментов является решающим фактором. Scapy и GPUtil предоставляют мощные возможности для эффективного управления и мониторинга ИТ-инфраструктуры.

Практика

Представьте ситуацию: вас вызывают к рабочему компьютеру в офисе. Знакомая история, не правда ли? Обычно это значит, что что-то пошло не так. В этот раз, первое, что бросается в глаза (точнее, в уши) — это неистовый шум вентиляторов видеокарты и процессора. Создаётся впечатление, что внутри что-то вот-вот сломается.

Первичный осмотр, как правило, не даёт явных результатов: кулеры вращаются, никаких видимых повреждений нет. Это означает, что проблема, скорее всего, кроется глубже, в самой системе. В таких случаях необходимо провести более тщательную диагностику и изучить системные показатели. Дальнейшие действия будут направлены на выявление причин столь интенсивной работы компонентов ПК и устранение неполадок.

Итак, мы выяснили, что компьютер шумит из-за чрезмерной нагрузки, но визуальный осмотр ничего не дал. Теперь нужно глубже "копнуть" и разобраться, что именно заставляет процессор и видеокарту работать на пределе. Для этого мы воспользуемся автоматизированным подходом.

Вместо того чтобы вручную отслеживать показатели системы, напишем специальный скрипт. Этот скрипт будет как умный помощник: он будет постоянно следить за состоянием компьютера, выявлять моменты, когда нагрузка становится критической, и записывать всю важную информацию в отчёт.

Для этого мы используем два полезных инструмента: Psutil и GPUtil. Psutil позволит нам отслеживать использование ресурсов процессора, оперативной памяти и других системных компонентов. GPUtil, в свою очередь, предоставит подробные данные о работе видеокарты.

Скрипт, объединяющий эти инструменты, будет работать следующим образом: он будет считывать данные о текущей нагрузке, отслеживать пиковые значения и записывать их вместе с временными отметками. В результате мы получим наглядный отчёт о том, какие именно процессы и в какое время вызывают перегрузку системы. Это позволит нам точно определить проблемные места и оперативно устранить неполадки.

import psutil
import GPUtil
import time
from docx import Document
from docx.shared import Inches, Pt
from docx.enum.text import WD_ALIGN_PARAGRAPH
from datetime import datetime

def get_cpu_usage():
    return psutil.cpu_percent(interval=1)

def get_ram_usage():
    return psutil.virtual_memory().percent

def get_gpu_usage():
    gpus = GPUtil.getGPUs()
    if gpus:
        return gpus[0].load * 100  
    return 0  

def get_processes_by_cpu():
  processes = []
  for proc in psutil.process_iter(['pid', 'name', 'cpu_percent']):
        if proc.info['cpu_percent'] > 0:
            processes.append(proc.info)
  return sorted(processes, key=lambda x: x['cpu_percent'], reverse=True)

def create_report(data):
    document = Document()


    style = document.styles['Normal']
    font = style.font
    font.name = 'Times New Roman'
    font.size = Pt(14)


    heading = document.add_paragraph()
    heading_run = heading.add_run("Отчёт о нагрузке системы")
    heading_run.font.size = Pt(16)
    heading_run.bold = True
    heading.alignment = WD_ALIGN_PARAGRAPH.CENTER

    document.add_paragraph(f"Дата и время создания отчета: {datetime.now().strftime('%d.%m.%Y %H:%M:%S')}")
    document.add_paragraph(f"")  

    for entry in data:
        paragraph = document.add_paragraph()
        time_str = entry['time'].strftime('%H:%M:%S')
        text_run = paragraph.add_run(f"Время: {time_str} ")
        text_run.bold = True
        paragraph.add_run(f" | CPU: {entry['cpu']:.2f}% | RAM: {entry['ram']:.2f}% | GPU: {entry['gpu']:.2f}% ")
        
        if entry['cpu'] > 80 or entry['ram'] > 80 or entry['gpu'] > 80:
            text_run.font.highlight_color = 15 # Желтый цвет
            
            process_heading = document.add_paragraph()
            process_heading_run = process_heading.add_run("Процессы с наибольшей нагрузкой:")
            process_heading_run.italic = True
            
            process_paragraph = document.add_paragraph()
            sorted_processes = get_processes_by_cpu()
            for process in sorted_processes[:5]:
                process_paragraph.add_run(f"Имя: {process['name']}, PID: {process['pid']}, CPU: {process['cpu_percent']:.2f}%  | ")
            document.add_paragraph(f"")  

    file_name = f"report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.docx"
    document.save(file_name)
    print(f"Отчет сохранен в файле: {file_name}")


def main():
    print("Запуск мониторинга...")
    report_data = []
    start_time = time.time()

    while time.time() - start_time < 60:
        cpu_usage = get_cpu_usage()
        ram_usage = get_ram_usage()
        gpu_usage = get_gpu_usage()
        
        report_data.append({
            'time': datetime.now(),
            'cpu': cpu_usage,
            'ram': ram_usage,
            'gpu': gpu_usage
        })
        time.sleep(5)

    create_report(report_data)
    print("Мониторинг завершен. Отчет создан.")

if __name__ == "__main__":
    main()

Итак, мы успешно использовали автоматизированный скрипт для сбора данных о работе компьютера. Теперь, чтобы сделать наш анализ еще более удобным и наглядным, мы применим библиотеку python-docx. Она позволит нам создать структурированный отчет о состоянии системы в формате Word.

Этот отчет — не просто набор цифр и графиков. Мы сделали так, чтобы он был понятным даже для тех, кто далек от технических деталей. В нем будут представлены основные показатели загрузки процессора, памяти и видеокарты, а также выделены периоды пиковой нагрузки. И что самое важное, мы можем легко добавить к нему наши комментарии и интерпретацию полученных данных.

Используя этот полуавтоматический отчет, мы можем с уверенностью обратиться к начальству. На основании анализа данных мы сможем четко сказать, что, например, на компьютере пользователя наблюдается необычно высокая нагрузка на процессор. Это может быть признаком вирусной активности или каких-либо других проблем. Наша задача — не просто собрать данные, а сделать из них выводы, которые помогут принять правильные решения.

Теперь мы не просто "тыкаем пальцем в небо", а опираемся на факты, подкрепленные отчетом. Такой подход повышает нашу эффективность и делает нашу работу более профессиональной.

Ситуация повторяется: снова вызывают из-за проблем с компьютером. На этот раз все еще сложнее – сеть перегружена какими-то пакетами, но никто не понимает, что происходит. Коллеги в растерянности, а нам снова нужно разбираться.

К счастью, у нас есть опыт и инструменты. Как и в прошлый раз, мы воспользуемся скриптом для автоматизации процесса. Мы сохраним нашу библиотеку python-docx для формирования отчета, но добавим к нашему арсеналу еще один мощный инструмент – Scapy. Эта библиотека позволит нам анализировать сетевой трафик и выявлять источник перегрузки.

Скрипт будет работать следующим образом: Scapy перехватит сетевые пакеты, проанализирует их и выявит подозрительную активность. Мы отсортируем полученные данные, чтобы понять, какие хосты или приложения генерируют наибольшее количество пакетов. Затем мы сформируем отчет в формате Word, используя python-docx, который будет содержать наглядную информацию об источниках перегрузки.

import scapy.all as scapy
from docx import Document
from docx.shared import Inches, Pt, RGBColor
from docx.enum.text import WD_ALIGN_PARAGRAPH
from docx.enum.dml import MSO_THEME_COLOR_INDEX
from datetime import datetime
from collections import Counter

def analyze_packet(packet):

    src_ip = None
    dst_ip = None
    protocol = None

    if packet.haslayer(scapy.IP):
        src_ip = packet[scapy.IP].src
        dst_ip = packet[scapy.IP].dst
        protocol = "IP"
    elif packet.haslayer(scapy.IPv6):
        src_ip = packet[scapy.IPv6].src
        dst_ip = packet[scapy.IPv6].dst
        protocol = "IPv6"

    if packet.haslayer(scapy.TCP):
        protocol += " TCP"
    elif packet.haslayer(scapy.UDP):
        protocol += " UDP"
    elif packet.haslayer(scapy.ICMP):
        protocol += " ICMP"
    
    return {
        'time': datetime.now(),
        'src_ip': src_ip,
        'dst_ip': dst_ip,
        'protocol': protocol,
        'length': len(packet)
    }

def is_suspicious(packet_info):
  
    if packet_info['protocol'] == "IP TCP" and packet_info['length'] > 1500:  
        return True
    if packet_info['protocol'] == "IP UDP" and packet_info['length'] > 1000:
        return True
    return False
    

def is_alarming(packet_info):
        if packet_info['protocol'] == "IP TCP" and packet_info['length'] > 1000:  
            return True
        if packet_info['protocol'] == "IP UDP" and packet_info['length'] > 800:
            return True
        return False
        
def create_report(packet_data):
    document = Document()

    
    style = document.styles['Normal']
    font = style.font
    font.name = 'Times New Roman'
    font.size = Pt(14)

  
    heading = document.add_paragraph()
    heading_run = heading.add_run("Отчет об анализе сетевого трафика")
    heading_run.font.size = Pt(16)
    heading_run.bold = True
    heading.alignment = WD_ALIGN_PARAGRAPH.CENTER

    document.add_paragraph(f"Дата и время создания отчета: {datetime.now().strftime('%d.%m.%Y %H:%M:%S')}")
    document.add_paragraph(f"")

    
    packet_counter = Counter(packet['src_ip'] for packet in packet_data if packet['src_ip'] is not None)
    
    top_hosts = packet_counter.most_common(10)
    
    document.add_paragraph("Топ 10 хостов с наибольшим количеством пакетов:")
    for host, count in top_hosts:
        document.add_paragraph(f"Хост: {host}, Количество пакетов: {count}")
        
    document.add_paragraph(f"")  # Пустая строка
        
    for entry in packet_data:
        paragraph = document.add_paragraph()
        time_str = entry['time'].strftime('%H:%M:%S')
        text_run = paragraph.add_run(f"Время: {time_str} | ")
        text_run.bold = True
        paragraph.add_run(f"Src IP: {entry['src_ip']} | Dst IP: {entry['dst_ip']} | Протокол: {entry['protocol']} | Размер: {entry['length']} ")

        if is_suspicious(entry):
            text_run.font.color.rgb = RGBColor(255, 0, 0)  # красный
        elif is_alarming(entry):
            text_run.font.highlight_color = 15  # желтый
        else:
             text_run.font.color.rgb = RGBColor(0, 128, 0)  # зеленый
            

    file_name = f"network_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.docx"
    document.save(file_name)
    print(f"Отчет сохранен в файле: {file_name}")

def main():
    print("Запуск перехвата сетевых пакетов...")
    captured_packets = []

    def packet_callback(packet):
        packet_info = analyze_packet(packet)
        captured_packets.append(packet_info)

    try:
        scapy.sniff(prn=packet_callback, store=0, timeout=60) 
    except Exception as e:
        print(f"Ошибка во время перехвата: {e}")
        return

    create_report(captured_packets)
    print("Перехват завершен. Отчет создан.")

if __name__ == "__main__":
    main()

На данный момент мы внедрили простую, но наглядную алгоритмизацию: сетевые пакеты, которые мы пометили красным, являются подозрительными и требуют дальнейшего изучения. Зеленые пакеты, в свою очередь, считаются нормальными и не представляют угрозы. Это позволяет нам быстро ориентироваться в массиве данных.

Теперь, когда мы разобрались с принципами работы каждого скрипта по отдельности, давайте подумаем о том, как мы можем объединить их возможности. Скомбинировав скрипты для анализа нагрузки системы и сетевого трафика, мы сможем создать небольшую программу, которая будет автоматически выполнять часть работы системного администратора.

Такая программа будет не просто собирать данные, а представлять их в наглядном, структурированном виде. Она будет одновременно отслеживать работу процессора, памяти, видеокарты и анализировать сетевой трафик. Результатом ее работы станет отчет, который в кратчайшие сроки позволит понять, какие проблемы возникли в системе и где искать их причины.

Автоматизация не заменяет нас как специалистов, но позволяет нам более эффективно использовать свое время и ресурсы. Она избавляет от рутины и позволяет нам сосредоточиться на анализе и принятии решений. Такая программа — это шаг к оптимизации нашей работы и повышению уровня безопасности всей системы.

Приведенный пример программы показывает, как можно автоматизировать некоторые простые проверки и другие процессы, что заметно упрощает работу и экономит время.

Итог

В заключение, хотелось бы подчеркнуть, что рассматриваемые программные библиотеки, безусловно, представляют собой весьма значимый и перспективный инструментарий для специалистов, работающих в сфере системного администрирования. Использование этих библиотек, сопряженное с изучением и освоением возможностей языка программирования Python, открывает перед администраторами широкие горизонты. В частности, они получают возможность автоматизировать целый ряд базовых, рутинных, зачастую повторяющихся задач, что в свою очередь приводит к оптимизации рабочих процессов, снижению затрат времени и повышению общей производительности. Более того, немаловажно отметить, что с помощью Python и этих библиотек можно также формировать и генерировать разнообразную отчетную документацию, что предоставляет дополнительную ценность и удобство в работе.