Scripts Shell : 30 Exemples Pratiques pour l'Administration Système

Directives de base pour le scripting Shell

Avant de commencer l'écriture de scripts complexes, il est essentiel de respecter certaines bonnes pratiques pour garantir la maintenabilité et la robustesse du code :

Utilisez toujours le shebang approprié en début de fichier : #!/bin/bash.
Commentez votre code et utilisez une indentation de 4 espaces pour la clarté.
Définissez les variables globales en MAJUSCULES et les variables locales en minuscules.
Utilisez le mot-clé local dans les fonctions pour éviter les conflits de portée.
Pour le débogage, utilisez set -e (arrêt en cas d'erreur) et set -x (affichage de l'exécution).

1. Génération de chaînes et nombres aléatoires

Voici plusieurs approches pour générer des identifiants ou des mots de passe temporaires :

# Chaîne de 10 caractères alphanumériques
head /dev/urandom | tr -dc A-Za-z0-9 | head -c 10 ; echo

# Utilisation de openssl pour une chaîne aléatoire
openssl rand -hex 5

# Nombre aléatoire entre 1 et 1000 via la variable système
echo $((RANDOM % 1000 + 1))

2. Fonction d'affichage avec couleurs

Pour améliorer la lisibilité des logs dans le terminal :

log_message() {
    local color_code=$1
    local message=$2
    case $color_code in
        "success") echo -e "\e[32m[OK] $message\e[0m" ;;
        "error")   echo -e "\e[31m[ERREUR] $message\e[0m" ;;
        "warn")    echo -e "\e[33m[ALERTE] $message\e[0m" ;;
        *) echo "$message" ;;
    esac
}

log_message "success" "Traitement terminé avec succès"

3. Création automatisée d'utilisateurs

Ce script lit une liste de noms et crée les comptes avec des mots de passe aléatoires.

#!/bin/bash
USER_LIST="user_alpha user_beta user_gamma"
LOG_FILE="creations_log.txt"

for username in $USER_LIST; do
    if id "$username" &>/dev/null; then
        echo "L'utilisateur $username existe déjà."
    else
        temp_pass=$(openssl rand -base64 12)
        useradd "$username"
        echo "$temp_pass" | passwd --stdin "$username" &>/dev/null
        echo "Compte : $username | Password : $temp_pass" >> $LOG_FILE
        echo "Utilisateur $username créé."
    fi
done

4. Vérification de la présence d'un paquet

#!/bin/bash
package_name="htop"
if command -v $package_name &>/dev/null; then
    echo "Le paquet $package_name est installé."
else
    echo "Le paquet $package_name est manquant."
fi

5. Monitoring des services critiques

Vérifier si un processus (ex: nginx) tourne, sinon envoyer une alerte.

#!/bin/bash
SERVICE="nginx"
if ! pgrep -x "$SERVICE" > /dev/null; then
    echo "Le service $SERVICE est arrêté sur $(hostname)" | mail -s "Alerte Service" admin@domain.com
fi

6. Test de connectivité (Ping) sur plusieurs hôtes

#!/bin/bash
HOSTS="1.1.1.1 8.8.8.8 192.168.1.1"
for target in $HOSTS; do
    count=0
    max_retries=3
    while [ $count -lt $max_retries ]; do
        if ping -c 1 -W 1 "$target" > /dev/null; then
            echo "Hôte $target : Joignable"
            break
        fi
        ((count++))
    done
    [ $count -eq $max_retries ] && echo "Hôte $target : Indisponible après 3 essais"
done

7. Surveillance des ressources système

Surveiller l'usage CPU et RAM avec des seuils d'alerte.

#!/bin/bash
# Seuil de 85%
LIMIT=85
current_cpu=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d. -f1)
current_mem=$(free | grep Mem | awk '{print $3/$2 * 100.0}' | cut -d. -f1)

if [ "$current_cpu" -gt "$LIMIT" ]; then
    echo "Alerte : Charge CPU élevée ($current_cpu%)"
fi

if [ "$current_mem" -gt "$LIMIT" ]; then
    echo "Alerte : Utilisation mémoire critique ($current_mem%)"
fi

8. Surveillance de l'espace disque à distance

Utilise SSH pour vérifier l'espace disque sur un serveur distant.

#!/bin/bash
REMOTE_SERVER="192.168.1.50"
THRESHOLD=90

ssh root@$REMOTE_SERVER "df -h" | grep '^/dev/' | while read -r line; do
    usage=$(echo $line | awk '{print $5}' | sed 's/%//')
    partition=$(echo $line | awk '{print $1}')
    if [ "$usage" -ge "$THRESHOLD" ]; then
        echo "Partition $partition sur $REMOTE_SERVER est presque pleine : $usage%"
    fi
done

9. Validation de l'accessibilité d'une URL

#!/bin/bash
check_endpoint() {
    local url=$1
    local status=$(curl -L -s -o /dev/null -w "%{http_code}" --connect-timeout 5 "$url")
    if [ "$status" -eq 200 ]; then
        echo "Site $url : Fonctionnel"
    else
        echo "Site $url : Erreur (Code: $status)"
    fi
}

check_endpoint "https://www.google.com"

10. Vérification du statut de réplication MySQL

#!/bin/bash
status_slave=$(mysql -u root -p'password' -e "SHOW SLAVE STATUS\G" | grep "_Running:" | awk '{print $2}')
for state in $status_slave; do
    if [ "$state" != "Yes" ]; then
        echo "Erreur : La réplication MySQL est interrompue !"
        exit 1
    fi
done
echo "Réplication MySQL OK."

11. Bannissement automatique des IP suspectes

Analyse des logs pour bloquer les IP effectunat trop de requêtes.

#!/bin/bash
LOG_PATH="/var/log/nginx/access.log"
LIMIT=200
BAD_IPS=$(tail -n 1000 "$LOG_PATH" | awk '{print $1}' | sort | uniq -c | awk -v limit="$LIMIT" '$1 > limit {print $2}')

for ip in $BAD_IPS; do
    if ! iptables -C INPUT -s "$ip" -j DROP &>/dev/null; then
        iptables -A INPUT -s "$ip" -j DROP
        echo "IP bloquée : $ip"
    fi
done

12. Validation d'une adresse IP par RegEx

#!/bin/bash
is_valid_ip() {
    local target_ip=$1
    local regex='^([0-9]{1,3}\.){3}[0-9]{1,3}$'
    if [[ $target_ip =~ $regex ]]; then
        IFS='.' read -r -a octets <<< "$target_ip"
        for o in "${octets[@]}"; do
            if ((o < 0 || o > 255)); then
                return 1
            fi
        done
        return 0
    fi
    return 1
}

is_valid_ip "192.168.1.256" || echo "Format IP invalide"

13. Détection de fichiers contenant un mot-clé

#!/bin/bash
search_dir="/var/log"
keyword="ERROR"

find "$search_dir" -type f -name "*.log" | while read -r file; do
    if grep -q "$keyword" "$file"; then
        echo "Occurence trouvée dans : $file"
    fi
done

14. Surveillance d'un répertoire en temps réel

Nécessite inotify-tools.

#!/bin/bash
TARGET_DIR="/tmp/monitor"
inotifywait -m -e create,modify "$TARGET_DIR" | while read -r path event file; do
    echo "[$(date)] Action $event sur $file" >> /var/log/dir_monitor.log
done

15. Sélection dynamique de l'interface réseau

#!/bin/bash
interfaces=$(ls /sys/class/net | grep -v "lo")
echo "Sélectionnez une interface :"
select net_int in $interfaces; do
    if [ -n "$net_int" ]; then
        ip_addr=$(ip addr show "$net_int" | grep "inet " | awk '{print $2}')
        echo "Interface : $net_int | IP : $ip_addr"
        break
    else
        echo "Choix invalide."
    fi
done

16. Visualisation du débit réseau

#!/bin/bash
IFACE="eth0"
while true; do
    RX1=$(cat /sys/class/net/$IFACE/statistics/rx_bytes)
    TX1=$(cat /sys/class/net/$IFACE/statistics/tx_bytes)
    sleep 1
    RX2=$(cat /sys/class/net/$IFACE/statistics/rx_bytes)
    TX2=$(cat /sys/class/net/$IFACE/statistics/tx_bytes)
    echo "IN: $(((RX2-RX1)/1024)) KB/s | OUT: $(((TX2-TX1)/1024)) KB/s"
done

17. Sauvegarde automatisée de base de données

#!/bin/bash
DEST="/backup/db"
DB_NAME="production"
DATE=$(date +%Y%m%d_%H%M)

mysqldump -u root -p'password' "$DB_NAME" | gzip > "$DEST/${DB_NAME}_$DATE.sql.gz"
find "$DEST" -mtime +30 -type f -delete

18. Script de contrôle pour Nginx

#!/bin/bash
case "$1" in
    start)   /usr/sbin/nginx ;;
    stop)    /usr/sbin/nginx -s stop ;;
    reload)  /usr/sbin/nginx -s reload ;;
    status)  pgrep -x nginx >/dev/null && echo "En cours" || echo "Arrêté" ;;
    *) echo "Usage: $0 {start|stop|reload|status}" ;;
esac

19. Menu de connexion SSH simplifié

#!/bin/bash
# Fichier hosts : Nom IP Port
PS3="Se connecter à : "
select server in $(awk '{print $1}' servers.conf); do
    ip=$(grep "$server" servers.conf | awk '{print $2}')
    port=$(grep "$server" servers.conf | awk '{print $3}')
    ssh -p "$port" "root@$ip"
    break
done

20. Calcul de la somme d'une série de nombres

#!/bin/bash
total=0
for val in "$@"; do
    if [[ $val =~ ^[0-9]+$ ]]; then
        ((total += val))
    fi
done
echo "Somme totale : $total"

21. Renommage en masse de fichiers

#!/bin/bash
# Remplace les espaces par des underscores
for file in *\ *; do
    mv "$file" "${file// /_}"
done

22. Calcul de la taille totale d'une extension spécifique

#!/bin/bash
find . -name "*.jpg" -ls | awk '{sum+=$7} END {printf "Taille totale : %.2f MB\n", sum/1024/1024}'

23. Scanner de ports basique

#!/bin/bash
TARGET="127.0.0.1"
for port in {20..80}; do
    (echo >/dev/tcp/$TARGET/$port) &>/dev/null && echo "Port $port ouvert"
done

24. Automatisation avec Expect (SSH)

#!/usr/bin/expect
set timeout 10
spawn ssh root@192.168.1.100
expect "password:"
send "mon_password\r"
expect "#"
send "df -h\r"
send "exit\r"
expect eof

25. Changement de mot de passe à distance

#!/bin/bash
while read ip user old_pass; do
    new_pass=$(openssl rand -base64 8)
    sshpass -p "$old_pass" ssh "$user@$ip" "echo '$new_pass' | passwd --stdin $user"
    echo "$ip $new_pass" >> nouvelles_cles.log
done < liste_serveurs.txt

26. Table de multiplication en Bash

#!/bin/bash
for i in {1..9}; do
    for j in $(seq 1 $i); do
        echo -n "$j*$i=$((i*j))  "
    done
    echo ""
done

27. Gestion d'arguments avec getopts

#!/bin/bash
while getopts "f:v" opt; do
    case $opt in
        f) file=$OPTARG ;;
        v) verbose=1 ;;
        *) echo "Invalide" ;;
    esac
done
echo "Fichier : $file, Mode verbeux : $verbose"

28. Rotation simple de fichiers de logs

#!/bin/bash
MAX_SIZE=1048576 # 1MB
LOG="/var/log/app.log"
if [ $(stat -c%s "$LOG") -gt $MAX_SIZE ]; then
    mv "$LOG" "$LOG.$(date +%s).bak"
    touch "$LOG"
fi

29. Extraction d'informations système

#!/bin/bash
echo "Système d'exploitation : $(uname -o)"
echo "Version Noyau : $(uname -r)"
echo "Architecture : $(uname -m)"

30. Test de latence réseau moyen

#!/bin/bash
host="google.com"
ping -c 5 $host | tail -1 | awk -F '/' '{print "Latence moyenne : " $5 " ms"}'

Étiquettes: bash Linux scripting administration système automatisation

Publié le 26 juillet à 20h20

L'Atelier Monstre