Scripting et Automatisation sous Linux

L’automatisation des tâches répétitives est l’un des grands avantages de Linux. Grâce au scripting Bash et à divers outils d’automatisation, vous pouvez gagner un temps considérable et réduire les erreurs humaines. Ce guide vous présente les bases du scripting Bash et les techniques d’automatisation essentielles sous Linux.

Fondamentaux du scripting Bash

Structure d’un script Bash

Tout script Bash commence par un “shebang” qui indique l’interpréteur à utiliser.

#!/bin/bash

# Ceci est un commentaire
echo "Bonjour, monde!"

# Variables
NOM="Utilisateur"
echo "Bonjour, $NOM"

# Sortie avec code de retour 0 (succès)
exit 0

Pour rendre un script exécutable :

chmod +x mon_script.sh

Pour exécuter un script :

./mon_script.sh

Variables et opérations

#!/bin/bash

# Déclaration et utilisation de variables
NOMBRE=10
TEXTE="Linux"

# Opérations arithmétiques
let RESULTAT=$NOMBRE+5
echo "Résultat: $RESULTAT"

# Autre méthode pour les calculs
CARRE=$((NOMBRE * NOMBRE))
echo "Le carré de $NOMBRE est $CARRE"

# Variables d'environnement
echo "Votre répertoire personnel: $HOME"
echo "Votre shell actuel: $SHELL"

Entrées et sorties

#!/bin/bash

# Demander une entrée à l'utilisateur
echo "Entrez votre nom:"
read NOM

# Afficher un message avec l'entrée
echo "Bonjour, $NOM!"

# Redirection de sortie vers un fichier
echo "Log: Script exécuté par $NOM" >> log.txt

# Lire depuis un fichier
echo "Contenu du fichier log.txt:"
cat log.txt

Arguments de ligne de commande

#!/bin/bash

# $0 est le nom du script
# $1, $2, etc. sont les arguments
# $# est le nombre d'arguments
# $@ représente tous les arguments

echo "Nom du script: $0"
echo "Premier argument: $1"
echo "Deuxième argument: $2"
echo "Nombre d'arguments: $#"
echo "Tous les arguments: $@"

Structures de contrôle

Conditions

#!/bin/bash

# Structure conditionnelle if-else
NOMBRE=15

if [ $NOMBRE -gt 10 ]; then
    echo "$NOMBRE est supérieur à 10"
elif [ $NOMBRE -eq 10 ]; then
    echo "$NOMBRE est égal à 10"
else
    echo "$NOMBRE est inférieur à 10"
fi

# Opérateurs de comparaison pour nombres
# -eq : égal
# -ne : différent
# -gt : supérieur
# -lt : inférieur
# -ge : supérieur ou égal
# -le : inférieur ou égal

# Test sur les fichiers
if [ -f "/etc/passwd" ]; then
    echo "Le fichier /etc/passwd existe"
fi

# Opérateurs pour fichiers
# -f : fichier régulier
# -d : répertoire
# -e : existe
# -r : lisible
# -w : modifiable
# -x : exécutable

Boucles

#!/bin/bash

# Boucle for
echo "Comptage avec for:"
for i in {1..5}; do
    echo "Numéro $i"
done

# Boucle for avec liste
echo "Liste de fruits:"
for fruit in pomme orange banane; do
    echo "J'aime les $fruit"
done

# Boucle while
echo "Comptage avec while:"
COUNT=1
while [ $COUNT -le 5 ]; do
    echo "Compteur: $COUNT"
    let COUNT=COUNT+1
done

# Boucle until (jusqu'à ce que la condition soit vraie)
echo "Comptage avec until:"
COUNT=5
until [ $COUNT -le 0 ]; do
    echo "Décompte: $COUNT"
    let COUNT=COUNT-1
done

Case (switch)

#!/bin/bash

echo "Entrez un fruit (pomme, orange, banane):"
read FRUIT

case $FRUIT in
    "pomme")
        echo "Les pommes sont rouges ou vertes."
        ;;
    "orange")
        echo "Les oranges sont... orange!"
        ;;
    "banane")
        echo "Les bananes sont jaunes."
        ;;
    *)
        echo "Je ne connais pas ce fruit."
        ;;
esac

Fonctions

#!/bin/bash

# Définition d'une fonction
saluer() {
    echo "Bonjour, $1!"
}

# Fonction avec retour de valeur
calculer_carre() {
    local nombre=$1
    echo $((nombre * nombre))
}

# Appel de fonction
saluer "Alice"
saluer "Bob"

# Récupérer la valeur de retour
resultat=$(calculer_carre 5)
echo "Le carré de 5 est $resultat"

Scripts d’automatisation pratiques

Script de sauvegarde automatique

#!/bin/bash

# Script de sauvegarde automatique
# Usage: ./backup.sh [répertoire_source]

# Vérifier si un argument a été fourni
if [ $# -eq 0 ]; then
    echo "Usage: $0 [répertoire_source]"
    exit 1
fi

# Variables
SOURCE_DIR=$1
BACKUP_DIR="/home/user/backups"
DATE=$(date +%Y-%m-%d_%H-%M-%S)
ARCHIVE_NAME="backup_$DATE.tar.gz"

# Créer le répertoire de sauvegarde s'il n'existe pas
mkdir -p $BACKUP_DIR

# Créer l'archive
echo "Création de la sauvegarde de $SOURCE_DIR..."
tar -czf "$BACKUP_DIR/$ARCHIVE_NAME" "$SOURCE_DIR"

# Vérifier si la sauvegarde a réussi
if [ $? -eq 0 ]; then
    echo "Sauvegarde réussie: $BACKUP_DIR/$ARCHIVE_NAME"
    echo "Taille: $(du -h "$BACKUP_DIR/$ARCHIVE_NAME" | cut -f1)"
else
    echo "Erreur lors de la sauvegarde"
    exit 1
fi

# Supprimer les anciennes sauvegardes (plus de 30 jours)
find $BACKUP_DIR -name "backup_*.tar.gz" -mtime +30 -delete

Surveillance système automatisée

#!/bin/bash

# Script de surveillance système
# Vérifie l'utilisation du CPU, de la mémoire et de l'espace disque

# Seuils d'alerte
CPU_THRESHOLD=80
MEM_THRESHOLD=80
DISK_THRESHOLD=90
LOG_FILE="/var/log/system_monitor.log"

# Fonction de journalisation
log_message() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> $LOG_FILE
}

# Vérification de l'utilisation CPU
CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{print $2 + $4}' | cut -d. -f1)
if [ $CPU_USAGE -gt $CPU_THRESHOLD ]; then
    MESSAGE="ALERTE: Utilisation CPU à $CPU_USAGE% (seuil: $CPU_THRESHOLD%)"
    log_message "$MESSAGE"
    echo "$MESSAGE"
fi

# Vérification de l'utilisation mémoire
MEM_USAGE=$(free | grep Mem | awk '{print int($3/$2 * 100)}')
if [ $MEM_USAGE -gt $MEM_THRESHOLD ]; then
    MESSAGE="ALERTE: Utilisation mémoire à $MEM_USAGE% (seuil: $MEM_THRESHOLD%)"
    log_message "$MESSAGE"
    echo "$MESSAGE"
fi

# Vérification de l'espace disque
DISK_USAGE=$(df -h / | grep / | awk '{print $5}' | cut -d% -f1)
if [ $DISK_USAGE -gt $DISK_THRESHOLD ]; then
    MESSAGE="ALERTE: Utilisation disque à $DISK_USAGE% (seuil: $DISK_THRESHOLD%)"
    log_message "$MESSAGE"
    echo "$MESSAGE"
fi

Script de déploiement

#!/bin/bash

# Script de déploiement simple
# Usage: ./deploy.sh [environnement]

# Configuration
APP_NAME="mon-application"
GIT_REPO="https://github.com/user/repo.git"
DEPLOY_DIR="/var/www"

# Vérifier l'environnement
if [ $# -eq 0 ]; then
    ENV="development"
else
    ENV=$1
fi

echo "Déploiement de $APP_NAME en environnement $ENV"

# Créer un répertoire temporaire
TEMP_DIR=$(mktemp -d)
echo "Répertoire temporaire: $TEMP_DIR"

# Cloner le dépôt
echo "Clonage du dépôt..."
git clone $GIT_REPO $TEMP_DIR
if [ $? -ne 0 ]; then
    echo "Erreur lors du clonage du dépôt"
    exit 1
fi

# Aller dans le répertoire du projet
cd $TEMP_DIR

# Checkout de la branche appropriée
if [ "$ENV" = "production" ]; then
    git checkout master
else
    git checkout develop
fi

# Installation des dépendances
echo "Installation des dépendances..."
npm install --production

# Construction du projet
echo "Construction du projet..."
npm run build

# Déploiement
echo "Déploiement vers $DEPLOY_DIR/$APP_NAME-$ENV..."
mkdir -p $DEPLOY_DIR/$APP_NAME-$ENV
cp -r dist/* $DEPLOY_DIR/$APP_NAME-$ENV/

# Nettoyage
echo "Nettoyage..."
rm -rf $TEMP_DIR

echo "Déploiement terminé avec succès!"

Automatisation avec Cron

Cron est un planificateur de tâches qui permet d’exécuter des scripts à des moments précis.

Syntaxe de crontab

# Format crontab:
# .---------------- minute (0 - 59)
# |  .------------- heure (0 - 23)
# |  |  .---------- jour du mois (1 - 31)
# |  |  |  .------- mois (1 - 12)
# |  |  |  |  .---- jour de la semaine (0 - 6) (Dimanche=0)
# |  |  |  |  |
# *  *  *  *  * commande à exécuter

Exemples de tâches cron

# Éditer votre crontab
crontab -e

Exemples de tâches :

# Exécuter un script tous les jours à 3h du matin
0 3 * * * /chemin/vers/script.sh

# Exécuter une sauvegarde tous les lundis à 2h30
30 2 * * 1 /chemin/vers/backup.sh

# Exécuter un script toutes les 15 minutes
*/15 * * * * /chemin/vers/script.sh

# Exécuter un script le premier jour de chaque mois
0 0 1 * * /chemin/vers/script.sh

Gestion des sorties cron

# Rediriger la sortie standard et d'erreur vers un fichier
0 3 * * * /chemin/vers/script.sh > /var/log/script.log 2>&1

# Ajouter la sortie à un fichier existant
0 3 * * * /chemin/vers/script.sh >> /var/log/script.log 2>&1

# Ignorer toute sortie
0 3 * * * /chemin/vers/script.sh > /dev/null 2>&1

# Envoyer la sortie par email (si configuré)
0 3 * * * /chemin/vers/script.sh | mail -s "Résultat du script" user@example.com

Automatisation avancée

Automatisation avec Ansible

Ansible est un outil d’automatisation puissant pour la gestion de configuration et le déploiement d’applications.

# Installer Ansible
sudo apt install ansible

# Exemple de commande ad-hoc
ansible all -i inventory.ini -m ping

# Exécuter un playbook
ansible-playbook -i inventory.ini playbook.yml

Automatisation avec Systemd

Systemd permet de créer des services personnalisés qui s’exécutent en arrière-plan.

Exemple de fichier de service (/etc/systemd/system/mon-service.service) :

[Unit]
Description=Mon Service Personnalisé
After=network.target

[Service]
Type=simple
User=utilisateur
WorkingDirectory=/chemin/vers/app
ExecStart=/usr/bin/node app.js
Restart=on-failure

[Install]
WantedBy=multi-user.target

Commandes pour gérer le service :

# Recharger systemd après avoir créé/modifié un service
sudo systemctl daemon-reload

# Activer le service au démarrage
sudo systemctl enable mon-service

# Démarrer le service
sudo systemctl start mon-service

# Vérifier le statut
sudo systemctl status mon-service

Conclusion

Le scripting Bash et l’automatisation sont des compétences essentielles pour tout administrateur système Linux ou développeur. En automatisant les tâches répétitives, vous pouvez non seulement gagner du temps, mais aussi réduire les erreurs humaines et améliorer la cohérence de vos opérations.

Commencez par des scripts simples, puis progressez vers des solutions d’automatisation plus complexes à mesure que vous gagnez en confiance. N’oubliez pas de documenter vos scripts et de les tester soigneusement avant de les déployer en production.

Avec la pratique, vous découvrirez que presque toutes les tâches répétitives sous Linux peuvent être automatisées, vous permettant de vous concentrer sur des travaux plus créatifs et stratégiques.