Scripting and Automation on Linux

Automating repetitive tasks is one of the major advantages of Linux. With Bash scripting and a variety of automation tools, you can save a considerable amount of time and reduce human error. This guide introduces the basics of Bash scripting and the essential automation techniques on Linux.

Bash Scripting Fundamentals

Structure of a Bash Script

Every Bash script starts with a “shebang” that specifies which interpreter to use.

#!/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

To make a script executable:

chmod +x mon_script.sh

To run a script:

./mon_script.sh

Variables and Operations

#!/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"

Input and Output

#!/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

Command-Line Arguments

#!/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: $@"

Control Structures

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

Loops

#!/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

Functions

#!/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"

Practical Automation Scripts

Automated Backup Script

#!/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

Automated System Monitoring

#!/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

Deployment Script

#!/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!"

Automation with Cron

Cron is a job scheduler that lets you run scripts at specific times.

Crontab Syntax

# 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

Cron Job Examples

# Éditer votre crontab
crontab -e

Example jobs:

# 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

Handling Cron Output

# 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

Advanced Automation

Automation with Ansible

Ansible is a powerful automation tool for configuration management and application deployment.

# 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

Automation with Systemd

Systemd lets you create custom services that run in the background.

Example service file (/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

Commands to manage the 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

Bash scripting and automation are essential skills for any Linux system administrator or developer. By automating repetitive tasks, you not only save time but also reduce human error and improve the consistency of your operations.

Start with simple scripts, then move on to more complex automation solutions as you gain confidence. Don’t forget to document your scripts and test them thoroughly before deploying them to production.

With practice, you’ll find that almost any repetitive task on Linux can be automated, freeing you to focus on more creative and strategic work.