Outils de Monitoring Personnalisés

Contexte et Objectifs

Besoin Spécifique

Les solutions de monitoring standard ne répondaient pas aux besoins spécifiques de l'infrastructure. Développement d'outils sur mesure pour une visibilité complète.

Développement Interne

Création de scripts et applications personnalisées pour collecter, analyser et visualiser les données de performance de manière ciblée.

Dashboard Personnalisé

Interface web sur mesure présentant les métriques importantes avec alertes personnalisées et rapports automatiques.

Surveillance Temps Réel

Monitoring instantané des performances CPU, RAM, disque et réseau

Alertes Personnalisées

Notifications intelligentes basées sur les seuils et patterns spécifiques

Visualisation Avancée

Graphiques interactifs et dashboards personnalisés pour chaque service

Historique des Données

Stockage à long terme des métriques pour analyse des tendances

Rapports Automatisés

Génération automatique de rapports hebdomadaires et mensuels

Accès Mobile

Interface responsive pour consultation sur smartphones et tablettes

Outils de Monitoring Développés

System Monitor Python

Application Python complète pour la surveillance des performances système avec collecte de métriques en temps réel et stockage dans une base de données.

Monitoring CPU, RAM, disque, réseau
Collecte toutes les 30 secondes
Base de données SQLite pour historique
Alertes par email et SMS
Interface web avec Flask
Export CSV des données

PowerShell Monitor

Scripts PowerShell avancés pour la surveillance spécifique des environnements Windows Server avec intégration Active Directory et services Windows.

Monitoring services Windows
Surveillance Event Logs
Performance counters personnalisés
Intégration Active Directory
Rapports HTML automatiques
Tâches planifiées intégrées

Network Scanner

Outil de surveillance réseau avec scan automatique des équipements, détection des anomalies et analyse de la bande passante.

Scan réseau automatique
Détection équipements actifs
Monitoring latence et uptime
Alertes connexion perdue
Cartographie réseau dynamique
Export résultats JSON/XML

Web Dashboard

Interface web moderne et responsive avec graphiques en temps réel, tableaux de bord personnalisables et notifications push.

Dashboard responsive design
Graphiques Chart.js interactifs
WebSocket pour temps réel
Notifications navigateur
Thèmes clair/sombre
Multi-utilisateurs avec auth

Métriques et Indicateurs

CPU

Utilisation par cœur, température, fréquence et charge système

Mémoire

RAM utilisée, swap disponible, cache et buffers

Stockage

Espace disque, I/O operations, latence et health status

Réseau

Bande passante, paquets perdus, latence et connexions actives

Services

Status services, temps de réponse, logs et erreurs

Utilisateurs

Connexions actives, sessions, lockouts et activités

Dashboard de Monitoring

Vue d'ensemble en temps réel

Extraits de Code

Script Python - Monitoring Système

import psutil
import time
import sqlite3
from datetime import datetime

class SystemMonitor:
    def __init__(self):
        self.db_conn = sqlite3.connect('monitoring.db')
        self.init_database()
    
    def collect_metrics(self):
        metrics = {
            'timestamp': datetime.now(),
            'cpu_percent': psutil.cpu_percent(interval=1),
            'memory_percent': psutil.virtual_memory().percent,
            'disk_usage': psutil.disk_usage('/').percent,
            'network_io': psutil.net_io_counters()
        }
        return metrics
    
    def store_metrics(self, metrics):
        cursor = self.db_conn.cursor()
        cursor.execute('''
            INSERT INTO system_metrics 
            (timestamp, cpu, memory, disk, network_sent, network_recv)
            VALUES (?, ?, ?, ?, ?, ?)
        ''', (
            metrics['timestamp'],
            metrics['cpu_percent'],
            metrics['memory_percent'],
            metrics['disk_usage'],
            metrics['network_io'].bytes_sent,
            metrics['network_io'].bytes_recv
        ))
        self.db_conn.commit()
    
    def check_alerts(self, metrics):
        if metrics['cpu_percent'] > 80:
            self.send_alert('CPU usage critical: ' + str(metrics['cpu_percent']) + '%')
        if metrics['memory_percent'] > 85:
            self.send_alert('Memory usage critical: ' + str(metrics['memory_percent']) + '%')
    
    def run_monitoring(self):
        while True:
            metrics = self.collect_metrics()
            self.store_metrics(metrics)
            self.check_alerts(metrics)
            time.sleep(30)  # Collect every 30 seconds
            

Script PowerShell - Services Windows

# Windows Services Monitoring Script
$services = Get-Service | Where-Object {$_.Status -eq "Running"}
$criticalServices = @("Spooler", "EventLog", "Netlogon", "DNS")

foreach ($service in $services) {
    $cpuTime = (Get-Process -Name $service.Name -ErrorAction SilentlyContinue).CPU
    $memory = (Get-Process -Name $service.Name -ErrorAction SilentlyContinue).WorkingSet64
    
    $metrics = @{
        ServiceName = $service.Name
        Status = $service.Status
        CPUTime = $cpuTime
        MemoryMB = [math]::Round($memory / 1MB, 2)
        Timestamp = Get-Date
    }
    
    # Store in database
    Insert-Metrics $metrics
    
    # Check for critical services
    if ($criticalServices -contains $service.Name -and $service.Status -ne "Running") {
        Send-Alert "Critical service $($service.Name) is not running!"
    }
}

# Generate HTML report
$report = Generate-HTMLReport $services
Send-Email -To "admin@company.com" -Subject "Daily Services Report" -Body $report
            