Apprentissage du developpement avancé avec Python
Apprentissage du developpement avancé avec Python

Projets DevOps avec Python : Monitoring et Tâches Planifiées (Cron)

Introduction au Monitoring et aux Tâches Planifiées en DevOps

Dans le monde du développement logiciel moderne, la philosophie DevOps est devenue essentielle pour optimiser le cycle de vie des applications, de leur conception à leur déploiement et à leur exploitation. Deux piliers fondamentaux de cette approche sont le monitoring (surveillance) et l'automatisation des tâches planifiées.

Le monitoring consiste à collecter et analyser des données sur les performances et l'état de santé de vos systèmes, applications et infrastructures. C'est la base pour détecter les problèmes rapidement, comprendre les goulots d'étranglement et anticiper les défaillances. Sans un monitoring efficace, vos opérations sont à l'aveugle, ce qui peut entraîner des interruptions de service coûteuses et une dégradation de l'expérience utilisateur.

Les tâches planifiées, d'autre part, sont des actions automatisées qui s'exécutent à des intervalles réguliers ou à des moments spécifiques. Elles sont cruciales pour l'entretien des systèmes, la sauvegarde des données, la rotation des journaux, l'envoi de rapports périodiques et l'exécution de scripts de monitoring eux-mêmes.

Python, grâce à sa polyvalence, sa richesse en bibliothèques et sa facilité de lecture, est un langage de choix pour implémenter ces aspects cruciaux du DevOps. Cette leçon vous guidera à travers l'intégration de Python pour le monitoring et la planification de tâches avec Cron, un outil historique et puissant des systèmes Unix/Linux.

1. Comprendre le Monitoring en DevOps avec Python

Le monitoring ne se limite pas à "voir si ça marche". C'est une discipline complexe qui vise à fournir des informations actionnables.

1.1 Qu'est-ce que le Monitoring et Pourquoi est-il Crucial ?

Le monitoring en DevOps englobe la collecte, l'analyse et la visualisation de métriques provenant de toutes les couches de votre infrastructure et de vos applications. Il est crucial pour plusieurs raisons :

  • Détection Précoce des Problèmes : Identifier les anomalies avant qu'elles ne deviennent des incidents majeurs.
  • Optimisation des Performances : Comprendre où se situent les goulots d'étranglement et optimiser l'utilisation des ressources.
  • Planification de la Capacité : Anticiper les besoins futurs en ressources basés sur les tendances d'utilisation.
  • Amélioration Continue : Utiliser les données pour améliorer la robustesse et l'efficacité des systèmes.
  • Respect des SLA (Service Level Agreements) : S'assurer que les services respectent les engagements de disponibilité et de performance.

1.2 Types de Métriques et leur Collecte

On distingue plusieurs catégories de métriques :

  • Métriques Système : Utilisation CPU, mémoire, disque, réseau.
  • Métriques Applicatives : Temps de réponse des requêtes, taux d'erreurs, nombre de sessions actives, latence des bases de données.
  • Métriques Métier : Nombre de transactions réussies, utilisateurs actifs, conversion de paniers.

Python est particulièrement bien adapté pour la collecte de ces métriques grâce à :

  • Des bibliothèques pour interagir avec le système d'exploitation (psutil).
  • Des modules pour effectuer des requêtes HTTP (requests), interagir avec des bases de données ou des services tiers.
  • Des capacités de traitement de données (parsing de logs, agrégation).

1.3 Implémentation de la Collecte de Métriques avec Python (Exemple psutil)

La bibliothèque psutil (process and system utilities) est un excellent point de départ pour collecter des informations sur l'utilisation des ressources système.

import psutil
import datetime
import json
import os

def get_system_metrics():
    """
    Collecte des métriques clés du système (CPU, mémoire, disque, réseau).
    """
    metrics = {}

    # CPU
    metrics['cpu_percent'] = psutil.cpu_percent(interval=1) # Pourcentage d'utilisation du CPU sur 1 seconde
    metrics['cpu_cores'] = psutil.cpu_count(logical=False) # Nombre de cœurs physiques
    metrics['cpu_logical_cores'] = psutil.cpu_count(logical=True) # Nombre de cœurs logiques/threads

    # Mémoire
    memory = psutil.virtual_memory()
    metrics['memory_total_mb'] = round(memory.total / (1024**2), 2)
    metrics['memory_available_mb'] = round(memory.available / (1024**2), 2)
    metrics['memory_used_percent'] = memory.percent

    # Disque
    disk_usage = psutil.disk_usage('/') # Pour la racine du système de fichiers
    metrics['disk_total_gb'] = round(disk_usage.total / (1024**3), 2)
    metrics['disk_used_gb'] = round(disk_usage.used / (1024**3), 2)
    metrics['disk_free_gb'] = round(disk_usage.free / (1024**3), 2)
    metrics['disk_used_percent'] = disk_usage.percent

    # Réseau (bytes envoyés/reçus depuis le démarrage)
    net_io = psutil.net_io_counters()
    metrics['network_bytes_sent_mb'] = round(net_io.bytes_sent / (1024**2), 2)
    metrics['network_bytes_recv_mb'] = round(net_io.bytes_recv / (1024**2), 2)

    metrics['timestamp'] = datetime.datetime.now().isoformat()

    return metrics

if __name__ == "__main__":
    # Assurez-vous d'avoir psutil installé: pip install psutil
    if not os.path.exists('logs'):
        os.makedirs('logs')

    log_file_path = 'logs/system_metrics.jsonl' # Utilisation de .jsonl pour JSON Lines

    try:
        metrics_data = get_system_metrics()
        # Enregistrer les métriques dans un fichier JSONL (chaque ligne est un objet JSON)
        with open(log_file_path, 'a') as f:
            f.write(json.dumps(metrics_data) + '\n')
        print(f"Métriques enregistrées avec succès dans {log_file_path}")
        print(json.dumps(metrics_data, indent=2))
    except Exception as e:
        print(f"Erreur lors de la collecte des métriques : {e}")

Explication du code :

  • Le script importe psutil pour accéder aux informations système, datetime pour les horodatages, json pour le format de sortie, et os pour la gestion des fichiers.
  • La fonction get_system_metrics() collecte diverses informations :
    • psutil.cpu_percent(interval=1) calcule l'utilisation CPU sur la dernière seconde.
    • psutil.virtual_memory() fournit des détails sur la mémoire vive.
    • psutil.disk_usage('/') donne l'utilisation du disque pour le répertoire racine.
    • psutil.net_io_counters() affiche les statistiques d'entrées/sorties réseau.
  • Toutes les métriques sont stockées dans un dictionnaire metrics, incluant un timestamp.
  • Le script sauve ces métriques dans un fichier system_metrics.jsonl (JSON Lines), où chaque ligne est un objet JSON distinct. C'est un format courant pour la journalisation de données structurées.
  • L'utilisation de try-except assure une gestion basique des erreurs.

2. La Journalisation (Logging) Avancée avec Python

Le logging est une composante essentielle du monitoring. Un bon système de logging permet de suivre le déroulement d'une application, de diagnostiquer des problèmes et de comprendre le comportement des utilisateurs.

2.1 L'Importance d'une Bonne Stratégie de Logging

  • Débogage et Diagnostic : Comprendre ce qui s'est passé avant, pendant et après un problème.
  • Audit et Sécurité : Enregistrer les actions des utilisateurs et les événements système pour des raisons de conformité ou de sécurité.
  • Analyse de Performance : Horodater des événements pour mesurer la durée des opérations.
  • Visibilité Opérationnelle : Obtenir une vue d'ensemble de l'état de l'application sans y être connecté directement.

2.2 Le Module logging de Python

Python dispose d'un module logging intégré, puissant et flexible, qui permet de définir différents niveaux de gravité (DEBUG, INFO, WARNING, ERROR, CRITICAL), de diriger les logs vers plusieurs destinations (console, fichier, réseau, base de données) et de formater les messages.

import logging
import os
import sys

# 1. Configuration de base du logger
# On veut les logs dans un fichier et aussi sur la console
log_dir = 'logs'
if not os.path.exists(log_dir):
    os.makedirs(log_dir)

log_file = os.path.join(log_dir, 'application.log')

# Crée un logger principal
logger = logging.getLogger('devops_app')
logger.setLevel(logging.DEBUG) # Définit le niveau le plus bas à capturer

# 2. Création de Handlers
# Handler pour écrire dans un fichier
file_handler = logging.FileHandler(log_file)
file_handler.setLevel(logging.INFO) # Ce handler ne va enregistrer que les INFO et plus

# Handler pour afficher sur la console
console_handler = logging.StreamHandler(sys.stdout)
console_handler.setLevel(logging.DEBUG) # Ce handler va afficher tous les DEBUG et plus

# 3. Définition des Formatteurs
# Formatteur pour le fichier : Inclut l'horodatage, le nom du logger, le niveau et le message
file_formatter = logging.Formatter(
    '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
# Formatteur pour la console : Plus concis
console_formatter = logging.Formatter(
    '[%(levelname)s] %(message)s (%(filename)s:%(lineno)d)'
)

# 4. Assigner les formatteurs aux handlers
file_handler.setFormatter(file_formatter)
console_handler.setFormatter(console_formatter)

# 5. Ajouter les handlers au logger
logger.addHandler(file_handler)
logger.addHandler(console_handler)

# --- Exemples d'utilisation du logger ---

def process_data(data):
    logger.debug(f"Début du traitement des données : {data}")
    try:
        if not isinstance(data, list):
            raise TypeError("Les données doivent être une liste.")
        
        result = sum(data)
        logger.info(f"Données traitées avec succès. Somme calculée : {result}")
        if result == 0:
            logger.warning("La somme des données est zéro, c'est inhabituel.")
        return result
    except TypeError as e:
        logger.error(f"Erreur de type lors du traitement : {e}", exc_info=True)
        return None
    except Exception as e:
        logger.critical(f"Une erreur critique est survenue : {e}", exc_info=True)
        return None

if __name__ == "__main__":
    logger.info("Application démarrée.")

    process_data([1, 2, 3, 4])
    process_data([0, 0, 0])
    process_data("pas une liste") # Ceci va générer une erreur de type
    process_data(None) # Ceci va générer une erreur critique (si None est passé à sum())

    logger.info("Application terminée.")

Explication du code :

  • Configuration du Logger : On crée une instance de logger nommée devops_app et on lui fixe un niveau de DEBUG, ce qui signifie qu'il traitera tous les messages à partir de ce niveau.
  • Handlers :
    • FileHandler dirige les messages vers un fichier (application.log). Il est configuré pour n'écrire que les messages de niveau INFO et supérieur.
    • StreamHandler dirige les messages vers la console (sys.stdout). Il est configuré pour afficher tous les messages (DEBUG et supérieur).
  • Formatters : Des formateurs sont créés pour définir le format des messages de log pour chaque handler. Ils permettent d'inclure des informations comme l'horodatage, le niveau de log, le nom du fichier source et le numéro de ligne.
  • Ajout des Handlers : Les handlers sont attachés au logger principal.
  • Utilisation : Les différentes méthodes (logger.debug(), logger.info(), logger.warning(), logger.error(), logger.critical()) sont utilisées pour émettre des messages à différents niveaux de gravité. L'option exc_info=True dans logger.error() permet d'inclure la trace complète de l'exception.

Ce système de logging bien structuré est fondamental pour le monitoring et le débogage de toute application DevOps en production.

3. Les Tâches Planifiées (Cron) en DevOps

Cron est un démon (un processus en arrière-plan) omniprésent sur les systèmes de type Unix (Linux, macOS) qui permet de planifier l'exécution de commandes ou de scripts à des intervalles réguliers. Il est l'outil d'automatisation des tâches par excellence pour les opérations système.

3.1 Qu'est-ce que Cron et son Utilité en DevOps ?

Cron est le planificateur de tâches par défaut dans la plupart des environnements Linux. Chaque utilisateur (y compris root) peut avoir sa propre table cron, appelée crontab, qui contient les commandes à exécuter et leurs horaires.

En DevOps, Cron est utilisé pour :

  • Exécuter des scripts de monitoring : Lancer périodiquement les scripts Python que nous avons vus pour collecter des métriques.
  • Sauvegardes de données : Exécuter des scripts de backup de bases de données ou de fichiers.
  • Rotation des journaux (log rotation) : Archiver ou purger les anciens fichiers de log pour éviter le remplissage du disque.
  • Nettoyage de fichiers temporaires : Supprimer les fichiers inutiles.
  • Envoi de rapports périodiques : Générer et envoyer des rapports quotidiens/hebdomadaires.
  • Synchronisation de données : Mettre à jour des caches ou synchroniser des dépôts.

3.2 La Syntaxe de Cron (crontab)

Une entrée crontab est composée de cinq champs temporels suivis de la commande à exécuter :

* * * * * commande_a_executer

Chaque astérisque (*) représente un champ qui peut prendre une valeur spécifique ou une plage de valeurs :

  1. Minute (0-59)
  2. Heure (0-23)
  3. Jour du mois (1-31)
  4. Mois (1-12)
  5. Jour de la semaine (0-7, où 0 et 7 sont le dimanche)

Exemples :

  • 0 * * * * /path/to/script.sh : Exécute le script toutes les heures, à la minute 0 (ex: 00:00, 01:00, etc.).
  • 30 2 * * 1 /path/to/backup.py : Exécute le script backup.py tous les lundis à 02h30 du matin.
  • */15 * * * * /usr/bin/python3 /home/user/monitor_app.py : Exécute monitor_app.py toutes les 15 minutes. (*/N signifie "toutes les N unités").
  • 0 0 1 * * /path/to/monthly_report.sh : Exécute le script le premier jour de chaque mois à 00h00.

Pour éditer votre crontab :

crontab -e

Cela ouvrira un éditeur de texte (généralement vi ou nano) où vous pourrez ajouter vos entrées. Sauvegardez et quittez l'éditeur, et Cron prendra en compte vos changements.

3.3 Meilleures Pratiques pour les Scripts Python avec Cron

Lorsqu'on planifie des scripts Python avec Cron, il est essentiel de suivre certaines pratiques :

  • Chemins Absolus : Utilisez toujours des chemins absolus pour l'interpréteur Python et pour votre script. Cron a un environnement très minimaliste et ne connaît pas toujours votre PATH.
    • Ex: /usr/bin/python3 /home/user/my_script.py au lieu de python3 my_script.py
  • Environnements Virtuels : Si votre script dépend de bibliothèques installées dans un environnement virtuel, activez-le explicitement ou pointez vers son interpréteur Python.
    • Ex: /home/user/my_project/venv/bin/python /home/user/my_project/my_script.py
  • Redirection des Sorties : Redirigez stdout et stderr vers un fichier de log pour le débogage. Cron envoie par défaut les sorties par email à l'utilisateur si non redirigées.
    • Ex: command > /path/to/log.log 2>&1
  • Gestion des Erreurs : Vos scripts Python doivent être robustes avec des blocs try-except pour gérer les exceptions et logger les erreurs.
  • Verrouillage (Locking) : Pour éviter que votre script ne s'exécute plusieurs fois si une exécution précédente est trop longue, utilisez des mécanismes de verrouillage (ex: fichiers de verrouillage).
  • Variables d'Environnement : Si votre script dépend de variables d'environnement (API keys, etc.), définissez-les au début de votre script Cron ou dans le crontab lui-même.

4. Cas Pratique : Monitoring d'un Service Web avec Python et Cron

Combinons maintenant nos connaissances pour créer un script Python qui surveille la disponibilité d'un service web et planifions-le avec Cron.

4.1 Le Script de Vérification de la Disponibilité

Ce script enverra une requête HTTP à une URL donnée et enregistrera son statut.

import requests
import logging
import datetime
import os
import sys

# --- Configuration du logging ---
log_dir = 'logs'
if not os.path.exists(log_dir):
    os.makedirs(log_dir)

# Utilisation de FileHandler avec un mode 'a' (append) pour ajouter aux logs existants
# et RotatingFileHandler pour gérer la taille du fichier de log
from logging.handlers import RotatingFileHandler

log_file_path = os.path.join(log_dir, 'service_monitor.log')

# Crée un logger principal
logger = logging.getLogger('service_monitor')
logger.setLevel(logging.INFO) # Définit le niveau le plus bas à capturer

# Handler pour écrire dans un fichier, rotation après 1MB, garde 5 fichiers de backup
file_handler = RotatingFileHandler(
    log_file_path, 
    maxBytes=1024*1024, # 1MB
    backupCount=5
)
file_handler.setLevel(logging.INFO)

# Handler pour afficher sur la console (utile pour le débogage manuel)
console_handler = logging.StreamHandler(sys.stdout)
console_handler.setLevel(logging.DEBUG) # Afficher tout en console pour le test

# Définition des Formatteurs
formatter = logging.Formatter(
    '%(asctime)s - %(levelname)s - %(message)s'
)

file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# Ajouter les handlers au logger
logger.addHandler(file_handler)
logger.addHandler(console_handler)

# --- Fonction de monitoring ---
def check_service(url, timeout=5):
    """
    Vérifie la disponibilité d'un service web.
    Enregistre le statut et le temps de réponse.
    """
    logger.info(f"Vérification de la disponibilité de : {url}")
    try:
        start_time = datetime.datetime.now()
        response = requests.get(url, timeout=timeout)
        end_time = datetime.datetime.now()
        response_time_ms = (end_time - start_time).total_seconds() * 1000

        if response.status_code == 200:
            logger.info(f"Service {url} est UP. Statut: {response.status_code}, Temps de réponse: {response_time_ms:.2f} ms")
            return True
        else:
            logger.warning(f"Service {url} est DOWN ou erreur. Statut: {response.status_code}, Temps de réponse: {response_time_ms:.2f} ms")
            return False
    except requests.exceptions.Timeout:
        logger.error(f"Service {url} : Timeout après {timeout} secondes.")
        return False
    except requests.exceptions.RequestException as e:
        logger.error(f"Service {url} : Erreur de connexion ou autre problème : {e}")
        return False
    except Exception as e:
        logger.critical(f"Erreur inattendue lors de la vérification du service {url} : {e}", exc_info=True)
        return False

if __name__ == "__main__":
    # URL du service à surveiller (vous pouvez changer ceci)
    SERVICE_URL = "https://www.google.com" 
    # SERVICE_URL = "http://localhost:8080/health" # Exemple pour un service local

    logger.info("Démarrage du script de surveillance de service.")
    status = check_service(SERVICE_URL)

    if status:
        logger.info(f"Le service {SERVICE_URL} est opérationnel.")
    else:
        logger.error(f"Le service {SERVICE_URL} a rencontré un problème.")
    logger.info("Fin du script de surveillance de service.")

Explication du code :

  • Le script utilise la bibliothèque requests pour effectuer des requêtes HTTP. (pip install requests)
  • Le module logging est configuré de manière plus avancée avec RotatingFileHandler pour gérer la taille du fichier de log et éviter qu'il ne grossisse indéfiniment.
  • La fonction check_service() prend une URL et un timeout. Elle mesure le temps de réponse et enregistre le statut HTTP.
  • Elle gère différentes exceptions (timeout, erreurs de connexion) pour fournir des messages d'erreur clairs.
  • Les messages sont logués avec des niveaux appropriés (INFO pour succès, WARNING pour statut non 200, ERROR pour timeout/connexion, CRITICAL pour erreurs inattendues).

4.2 Planification du Script avec Cron

Maintenant, nous allons planifier ce script pour qu'il s'exécute toutes les 5 minutes.

  1. Enregistrez le script sous un nom comme service_monitor.py dans un répertoire approprié, par exemple /home/user/devops_scripts/.

  2. Assurez-vous que le script a les permissions d'exécution :

    chmod +x /home/user/devops_scripts/service_monitor.py

  3. Localisez l'interpréteur Python correct, surtout si vous utilisez un environnement virtuel. Si votre script utilise un venv, l'interpréteur serait par exemple /home/user/devops_scripts/venv/bin/python. Sinon, which python3 peut vous donner le chemin.

    • Exemple: /usr/bin/python3

  4. Éditez votre crontab :

    crontab -e

  5. Ajoutez la ligne suivante à la fin du fichier :

    */5 * * * * /usr/bin/python3 /home/user/devops_scripts/service_monitor.py > /home/user/devops_scripts/logs/monitor_cron.log 2>&1

    Explication de la ligne Cron :

    • */5 * * * * : Exécute la commande toutes les 5 minutes.
    • /usr/bin/python3 : Le chemin absolu vers l'interpréteur Python. (Remplacez par le vôtre si différent).
    • /home/user/devops_scripts/service_monitor.py : Le chemin absolu vers votre script de monitoring.
    • > /home/user/devops_scripts/logs/monitor_cron.log 2>&1 : Redirige la sortie standard (stdout) et la sortie d'erreur (stderr) du script vers le fichier monitor_cron.log. Ceci est crucial pour déboguer les problèmes d'exécution Cron et éviter que Cron n'envoie des e-mails.

Après avoir sauvegardé et quitté le crontab, le script service_monitor.py s'exécutera automatiquement toutes les 5 minutes. Vous pouvez vérifier les logs générés dans /home/user/devops_scripts/logs/service_monitor.log et /home/user/devops_scripts/logs/monitor_cron.log pour confirmer son bon fonctionnement.

Conclusion

Le monitoring et les tâches planifiées sont des piliers fondamentaux des pratiques DevOps modernes. Python, grâce à son écosystème riche et sa syntaxe claire, se positionne comme un outil de choix pour implémenter ces capacités.

Nous avons exploré comment Python peut être utilisé pour :

  • Collecter des métriques système avec psutil.
  • Mettre en place une journalisation robuste avec le module logging.
  • Vérifier la disponibilité de services avec requests.

Nous avons également vu comment Cron permet de planifier l'exécution régulière de ces scripts Python, transformant des tâches manuelles en processus automatisés fiables. L'intégration de Python avec Cron permet de construire des systèmes de surveillance et d'automatisation sur mesure, essentiels pour maintenir la santé, la performance et la fiabilité de vos applications en production.

En maîtrisant ces techniques, vous serez en mesure de mieux gérer vos environnements, de réagir proactivement aux problèmes et de garantir une meilleure expérience utilisateur. N'oubliez jamais l'importance des chemins absolus, des environnements virtuels et de la redirection des logs lors de la planification de scripts avec Cron !