Recherche de site Web

Comment automatiser l'administration système avec Python sur RHEL

L'administration système implique souvent des tâches répétitives telles que la gestion des fichiers, la création de comptes utilisateurs, la surveillance des services et les sauvegardes système. Bien que les systèmes d'exploitation basés sur Linux comme Red Hat Enterprise Linux (RHEL) offrent divers outils pour gérer ces tâches, l'automatisation peut aider à gagner du temps, réduire les erreurs humaines et améliorer l'efficacité globale.

Python, un langage de programmation de haut niveau, est un excellent outil pour automatiser les tâches d'administration système. Il est facile à apprendre, possède un riche ensemble de bibliothèques et offre la flexibilité nécessaire pour réaliser une large gamme d'opérations administratives.

Dans cet article, nous explorerons comment utiliser des scripts Python pour automatiser les tâches courantes d'administration système sur RHEL.

Prérequis : Ce dont vous avez besoin avant d'automatiser avec Python sur RHEL

Avant de commencer à automatiser les tâches d'administration système en utilisant Python sur RHEL, il est important de s'assurer que les logiciels et les privilèges nécessaires sont en place.

Vous aurez besoin d'un système RHEL en fonctionnement pour commencer à travailler avec des scripts Python pour l'automatisation, ce qui pourrait être une machine physique ou virtuelle.

Si vous êtes nouveau sur RHEL ou Linux en général, vous pouvez télécharger une version d'essai de RHEL ou installer une alternative gratuite comme Alma Linux ou Rocky Linux (qui est compatible binaire avec RHEL) pour vous entraîner.

Ensuite, vous devez installer Python, qui est préinstallé sur RHEL. S'il n'est pas installé, vous pouvez l'installer en utilisant le gestionnaire de paquets yum.

sudo yum install python3

Une fois Python 3 installé, vous pouvez vérifier à nouveau l'installation :

python3 --version

1. Automatisation de la gestion des utilisateurs

Gérer les comptes utilisateurs est une tâche administrative courante, et le module subprocess de Python vous permet d'ajouter, de supprimer et de modifier facilement des utilisateurs en interagissant avec le shell.

Créer un utilisateur

Voici un script Python simple qui automatise le processus d'ajout d'un nouvel utilisateur :

import subprocess

def create_user(username):
    try:
        # Create a user using the useradd command
        subprocess.run(['sudo', 'useradd', username], check=True)
        print(f"User '{username}' created successfully.")
    except subprocess.CalledProcessError:
        print(f"Failed to create user '{username}'.")

if __name__ == "__main__":
    user_name = input("Enter the username to create: ")
    create_user(user_name)

Suppression d'un utilisateur

Pour supprimer un utilisateur, vous pouvez utiliser une approche similaire avec la commande userdel.

import subprocess

def delete_user(username):
    try:
        subprocess.run(['sudo', 'userdel', username], check=True)
        print(f"User '{username}' deleted successfully.")
    except subprocess.CalledProcessError:
        print(f"Failed to delete user '{username}'.")

if __name__ == "__main__":
    user_name = input("Enter the username to delete: ")
    delete_user(user_name)

2. Automatisation de la gestion des fichiers

L'automatisation des tâches de gestion des fichiers telles que la création de fichiers, la suppression et les modifications de permissions peut être un excellent moyen de réduire l'effort manuel.

Vérifier si un fichier existe

Voici un script simple pour vérifier si un fichier spécifique existe et afficher un message en conséquence :

import os

def check_file_exists(file_path):
    if os.path.exists(file_path):
        print(f"The file '{file_path}' exists.")
    else:
        print(f"The file '{file_path}' does not exist.")

if __name__ == "__main__":
    file_path = input("Enter the file path to check: ")
    check_file_exists(file_path)

Modifier les autorisations de fichier

Vous pouvez également automatiser la modification des permissions de fichier en utilisant la fonction os.chmod() de Python, qui vous permet de modifier les permissions des fichiers :

import os

def change_permissions(file_path, permissions):
    try:
        os.chmod(file_path, permissions)
        print(f"Permissions of '{file_path}' changed to {oct(permissions)}.")
    except Exception as e:
        print(f"Failed to change permissions: {e}")

if __name__ == "__main__":
    file_path = input("Enter the file path: ")
    permissions = int(input("Enter the permissions (e.g., 755): "), 8)
    change_permissions(file_path, permissions)

3. Automatisation de la surveillance du système

Les scripts Python peuvent être utilisés pour surveiller les performances du système et générer des alertes lorsqu'il y a un problème.

Surveillance de l'utilisation du disque

Le module shutil peut vous aider à vérifier l'espace disque disponible sur le système de fichiers racine et à afficher un avertissement si l'utilisation du disque dépasse un seuil.

import shutil

def check_disk_usage(threshold=80):
    total, used, free = shutil.disk_usage("/")
    used_percent = (used / total) * 100

    print(f"Disk usage: {used_percent:.2f}% used.")

    if used_percent > threshold:
        print("Warning: Disk usage is above the threshold!")

if __name__ == "__main__":
    check_disk_usage()

Surveillance de la charge du système

Vous pouvez également surveiller la charge du CPU en utilisant la bibliothèque psutil de Python (qui pourrait devoir être installée) :

pip install psutil

Une fois installé, utilisez-le pour récupérer la charge du système :

import psutil

def check_system_load():
    load = psutil.getloadavg()
    print(f"System load (1, 5, 15 minute averages): {load}")

    if load[0] > 1.5:
        print("Warning: High system load!")

if __name__ == "__main__":
    check_system_load()

4. Automatisation des sauvegardes du système

Les sauvegardes sont une partie essentielle de l'administration système, et vous pouvez automatiser les sauvegardes de fichiers avec Python en utilisant le module shutil.

Sauvegarder un répertoire

Ce script sauvegarde automatiquement un répertoire en le copiant à un emplacement spécifié en utilisant shutil.copytree().

import shutil
import os

def backup_directory(source_dir, backup_dir):
    try:
        # Create backup directory if it doesn't exist
        if not os.path.exists(backup_dir):
            os.makedirs(backup_dir)
        
        backup_path = os.path.join(backup_dir, os.path.basename(source_dir))
        shutil.copytree(source_dir, backup_path)
        print(f"Backup of '{source_dir}' completed successfully.")
    except Exception as e:
        print(f"Failed to backup directory: {e}")

if __name__ == "__main__":
    source_directory = input("Enter the source directory to back up: ")
    backup_directory_path = input("Enter the backup destination directory: ")
    backup_directory(source_directory, backup_directory_path)
Conclusion

L'automatisation des tâches d'administration système à l'aide de Python peut vous faire gagner du temps et réduire les erreurs humaines. De la gestion des utilisateurs à la surveillance de la santé du système en passant par la création de sauvegardes, les scripts Python offrent une solution flexible et puissante pour les administrateurs.

Vous pouvez modifier et étendre ces scripts en fonction de vos besoins spécifiques. La facilité d'utilisation de Python et son vaste support de bibliothèques en font un excellent outil pour automatiser une grande variété de tâches d'administration système sur RHEL et d'autres distributions Linux.