Automatisation de la surveillance de l'utilisation des ressources disque et des mises à jour de l'état du serveur avec Python

Automatisation de la surveillance de l'utilisation des ressources disque et des mises à jour de l'état du serveur avec Python

La surveillance de l'utilisation du disque du serveur est essentielle pour maintenir des performances optimales et éviter les temps d'arrêt. Dans cet article de blog, nous explorerons comment automatiser la surveillance des ressources disque à l'aide d'un script Python et mettre à jour l'état du serveur via une API. Nous verrons également comment configurer une tâche cron pour exécuter le script à intervalles réguliers.

Conditions préalables

• Connaissance de base de la programmation Python
• Familiarité avec les opérations en ligne de commande Linux
• Accès à un serveur sur lequel vous pouvez exécuter des scripts Python et configurer des tâches cron
• Un point de terminaison d'API pour mettre à jour l'état du serveur (remplacez par votre URL d'API et votre jeton réels)

Le script Python expliqué

Vous trouverez ci-dessous le script Python qui effectue la surveillance des ressources disque et met à jour l'état du serveur via une API.

La création d'API de santé n'est pas couverte dans cet article de blog, commentez si vous en avez également besoin, donc je publierai également les étapes de création de l'API.

import subprocess
import requests
import argparse


class Resource:
    file_system = ''
    disk_size = 0.0
    used = 0.0
    avail = 0.0
    use_percent = 0.0
    mounted_on = 0.0
    disk_free_threshold = 1
    mount_partition = "/"


class ResourcesMonitor(Resource):
    def __init__(self):
        self.__file_system = Resource.file_system
        self.__disk_size = Resource.disk_size
        self.__used = Resource.used
        self.__avail = Resource.avail
        self.__use_percent = Resource.use_percent
        self.__mounted_on = Resource.mounted_on
        self.__disk_free_threshold = Resource.disk_free_threshold
        self.__mount_partition = Resource.mount_partition

    def show_resource_usage(self):
        """
        Print the resource usage of disk.
        """
        print("file_system", "disk_size", "used", "avail", "use_percent", "mounted_on")
        print(self.__file_system, self.__disk_size, self.__used, self.__avail, self.__use_percent, self.__mounted_on)

    def check_resource_usage(self):
        """
        Check the disk usage by running the Unix 'df -h' command.
        """
        response_df = subprocess.Popen(["df", "-h"], stdout=subprocess.PIPE)
        for line in response_df.stdout:
            split_line = line.decode().split()
            if split_line[5] == self.__mount_partition:
                if int(split_line[4][:-1]) > self.__disk_free_threshold:
                    self.__file_system, self.__disk_size, self.__used = split_line[0], split_line[1], split_line[2]
                    self.__avail, self.__use_percent, self.__mounted_on = split_line[3], split_line[4], split_line[5]
                    self.show_resource_usage()
                    self.update_resource_usage_api(self)

    def update_resource_usage_api(self, resource):
        """
        Call the update API using all resource details.
        """
        update_resource_url = url.format(
            resource.__file_system,
            resource.__disk_size,
            resource.__used,
            resource.__avail,
            resource.__use_percent,
            resource_id
        )

        print(update_resource_url)
        payload = {}
        files = {}
        headers = {
            'token': 'Bearer APITOKEN'
        }
        try:
            response = requests.request("GET", update_resource_url, headers=headers, data=payload, files=files)
            if response.ok:
                print(response.json())
        except Exception as ex:
            print("Error while calling update API")
            print(ex)


if __name__ == '__main__':
    url = "http://yourapi.com/update_server_health_by_server_id?path={}&size={}" \
          "&used={}&avail={}&use_percent={}&id={}"
    parser = argparse.ArgumentParser(description='Disk Resource Monitor')
    parser.add_argument('-id', metavar='id', help='ID record of server', default=7, type=int)
    args = parser.parse_args()
    resource_id = args.id
    print(resource_id)
    resource_monitor = ResourcesMonitor()
    resource_monitor.check_resource_usage()

Les classes Resource et ResourcesMonitor

La classe Resource définit les attributs liés à l'utilisation du disque, tels que le système de fichiers, la taille du disque, l'espace utilisé, etc. La classe ResourcesMonitor hérite de Resource et initialise ces attributs.

Vérification de l'utilisation du disque

La méthode check_resource_usage exécute la commande Unix df -h pour obtenir des statistiques d'utilisation du disque. Il analyse la sortie pour trouver l'utilisation du disque de la partition de montage spécifiée (la valeur par défaut est /). Si l'utilisation du disque dépasse le seuil, il met à jour les détails de la ressource et appelle la méthode de mise à jour de l'API.

Mise à jour de la santé du serveur via l'API

La méthode update_resource_usage_api construit l'URL de la requête API avec les détails de la ressource et envoie une requête GET pour mettre à jour l'état du serveur. Assurez-vous de remplacer http://yourapi.com/update_server_health_by_server_id par votre point de terminaison d'API réel et de fournir le jeton d'API correct.

Utiliser le script

Enregistrez le script sous resource_monitor.py et exécutez-le en utilisant Python 3.

Arguments de ligne de commande

• -id : ID du serveur pour lequel les données de santé doivent être mises à jour (7 par défaut). cela aidera à exécuter le même script sur plusieurs serveurs en changeant simplement l'ID.

Exemple d'utilisation et de sortie

$ python3 resource_monitor.py -id=7

Output:
file_system disk_size used avail use_percent mounted_on
/dev/root 39G 31G 8.1G 80% /

API GET Request:
http://yourapi.com/update_server_health_by_server_id?path=/dev/root&size=39G&used=31G&avail=8.1G&use_percent=80%&id=7

Response
{'success': 'Servers_health data Updated.', 'data': {'id': 7, 'server_id': 1, 'server_name': 'web-server', 'server_ip': '11.11.11.11', 'size': '39G', 'path': '/dev/root', 'used': '31G', 'avail': '8.1G', 'use_percent': '80%', 'created_at': '2021-08-28T13:45:28.000000Z', 'updated_at': '2024-10-27T08:02:43.000000Z'}}

Automatiser avec Cron

Pour automatiser l'exécution du script toutes les 30 minutes, ajoutez une tâche cron comme suit :

*/30 * * * * python3 /home/ubuntu/resource_monitor.py -id=7 &

Vous pouvez modifier les tâches cron en exécutant crontab -e et en ajoutant la ligne ci-dessus. Cela garantira que le script s'exécute toutes les 30 minutes, gardant ainsi les données sur l'état de votre serveur à jour.

Conclusion

En automatisant la surveillance des ressources disque et les mises à jour de l'état du serveur, vous pouvez gérer de manière proactive les performances de votre serveur et éviter les problèmes potentiels dus à un manque d'espace disque. Ce script Python sert de point de départ et peut être personnalisé pour répondre à vos besoins spécifiques.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!