Scripts Bash avancés pour le DevOps

Tu connais les variables, les conditions, les boucles. Le chapitre précédent t’a donné les fondations. Maintenant on construit dessus : fonctions réutilisables, pipes pour chaîner les commandes, le trio grep/sed/awk qui fait 80% du traitement de texte en prod, et cron pour automatiser le tout. C’est le chapitre où tu passes de “je sais écrire un script” à “je sais écrire un script qui tourne en production”.

Fonctions et scripts robustes

Une fonction en Bash, c’est un bloc de code que tu nommes et que tu réutilises. Rien de révolutionnaire, mais c’est ce qui sépare un script jetable d’un outil maintenable.

#!/bin/bash
set -euo pipefail

log() {
    echo "[$(date '+%H:%M:%S')] $1"
}

fichier_existe() {
    [ -f "$1" ] && return 0 || return 1
}

# Utilisation
log "Début du script"
if fichier_existe "/etc/hosts"; then
    log "/etc/hosts trouvé"
fi

Deux choses à retenir. D’abord, utilise local pour tes variables dans les fonctions — sinon elles sont globales par défaut et tu vas avoir des bugs vicieux. Ensuite, return ne renvoie qu’un code de sortie (0-255). Pour renvoyer des données, tu fais echo et tu captures avec $(ma_fonction).

💡 Le header set -euo pipefail doit être en haut de chaque script de production. set -e arrête le script à la première erreur. set -u refuse les variables non définies. set -o pipefail détecte les erreurs dans les pipes. Sans ça, ton script continue joyeusement même quand tout casse — et tu le découvres 3 jours après en prod.

Pipes et redirections

Le pipe | est le ciment de la philosophie Unix : des petits outils spécialisés, chaînés ensemble. La sortie de la première commande devient l’entrée de la suivante.

# Top 5 des plus gros fichiers de log
du -sh /var/log/* 2>/dev/null | sort -rh | head -5

# Top 10 IPs dans un access log
awk '{print $1}' access.log | sort | uniq -c | sort -rn | head -10

# Heredoc : générer un fichier de config à la volée
cat <<EOF > config.yaml
server:
  host: localhost
  port: 8080
EOF

# Écrire dans un fichier ET afficher à l'écran
echo "deploying v2.1" | tee -a /var/log/deploy.log

Pour enchaîner des commandes sans pipe : && exécute la suite seulement si la précédente réussit, || seulement si elle échoue. Le combo classique : command && echo "OK" || echo "FAIL". Pour jeter la sortie d’une commande, redirige vers /dev/null : cmd > /dev/null 2>&1.

🔥 En entreprise, le heredoc est partout : génération de configs Kubernetes, fichiers d’environnement, templates de déploiement. C’est bien plus lisible qu’une série de echo >>.

Le trio grep, sed, awk

Ces trois commandes couvrent la quasi-totalité du traitement de texte en DevOps. Chacune a son rôle : grep cherche, sed remplace, awk structure.

grep — chercher du texte

# Chercher "error" sans tenir compte de la casse
grep -i "error" /var/log/syslog

# Chercher récursivement avec numéros de ligne
grep -rn "TODO" ./src/

# Exclure les commentaires d'un fichier de config
grep -v "^#" /etc/nginx/nginx.conf

# Extraire toutes les IPs d'un fichier
grep -oP '\d{1,3}(\.\d{1,3}){3}' access.log

# Contexte : 2 lignes avant et après chaque match
grep -B2 -A2 "CRITICAL" /var/log/syslog

sed — remplacer et transformer

sed (Stream Editor) transforme du texte à la volée. Le pattern le plus courant : s/ancien/nouveau/g.

# Remplacer dans un fichier (en place)
sed -i 's/listen 80;/listen 443 ssl;/g' /etc/nginx/nginx.conf

# Supprimer les lignes vides et les commentaires
sed '/^$/d; /^#/d' config.conf

# Afficher les lignes 10 à 20
sed -n '10,20p' fichier.txt

awk — traitement structuré

awk excelle sur les données en colonnes. Chaque ligne est découpée automatiquement, $1 est la première colonne, $NF la dernière.

# Utilisateurs et répertoire home
awk -F: '{print $1, $6}' /etc/passwd

# Utilisation disque formatée
df -h | awk 'NR>1 {printf "%-20s %s utilisé\n", $6, $5}'

# Calculer une somme
awk '{sum += $1} END {print "Total:", sum}' nombres.txt

# Requêtes HTTP 500 dans un access log
awk '$9 == 500 {print $7}' access.log | sort | uniq -c | sort -rn

⚠️ Piège classique : uniq ne fonctionne que sur des données triées. Toujours faire sort | uniq, jamais uniq seul. C’est l’erreur numéro 1 des débutants avec les pipes.

Cron : automatiser les tâches

cron est le planificateur de tâches de Linux. Le démon vérifie chaque minute s’il y a quelque chose à lancer. La syntaxe : cinq champs (minute, heure, jour du mois, mois, jour de la semaine) suivis de la commande.

# Backup tous les jours à 2h du matin
0 2 * * * /home/ubuntu/scripts/backup.sh >> /var/log/backup.log 2>&1

# Monitoring toutes les 5 minutes (avec lock anti-doublon)
*/5 * * * * flock -n /tmp/monitor.lock /home/ubuntu/scripts/monitor.sh

# Nettoyage hebdomadaire le dimanche à minuit
0 0 * * 0 find /tmp -mtime +7 -delete

# Rapport du lundi au vendredi à 9h
0 9 * * 1-5 /home/ubuntu/scripts/weekly_report.sh

Commandes utiles : crontab -e pour éditer, crontab -l pour lister tes jobs.

💡 Quatre règles d’or pour cron : utilise toujours des chemins absolus (cron n’a pas ton $PATH), redirige les sorties vers un log, utilise flock pour éviter les exécutions parallèles, et définis SHELL=/bin/bash en haut du crontab si tu utilises des syntaxes Bash.

Cas concret : script de backup en production

Voici un script qui combine tout ce qu’on a vu — fonctions, pipes, redirections, bonnes pratiques :

#!/bin/bash
set -euo pipefail

BACKUP_DIR="/backups"
SOURCE_DIR="/var/www"
DATE=$(date +%Y%m%d_%H%M%S)
RETENTION=30
LOG="/var/log/backup.log"

log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG"; }

log "Début du backup"
mkdir -p "$BACKUP_DIR"

if tar -czf "${BACKUP_DIR}/backup_${DATE}.tar.gz" "$SOURCE_DIR" 2>/dev/null; then
    log "Backup créé : backup_${DATE}.tar.gz"
else
    log "ERREUR : échec du backup"
    exit 1
fi

deleted=$(find "$BACKUP_DIR" -name "backup_*.tar.gz" -mtime +$RETENTION -delete -print | wc -l)
log "Nettoyage : $deleted anciens backups supprimés"

taille=$(du -sh "$BACKUP_DIR" | awk '{print $1}')
log "Espace utilisé : $taille"

🎯 Ce script fait tout bien : header robuste, fonctions, logs horodatés, gestion d’erreurs, rétention automatique. Ajoute un 0 2 * * * /home/ubuntu/scripts/backup.sh dans ton crontab et tu as un backup automatique professionnel.

Pièges fréquents et ce qu’il faut retenir

Les erreurs qu’on voit tout le temps en entreprise :

Variables non quotées. rm -rf $DIR/ sans guillemets ? Si $DIR est vide, ça devient rm -rf /. Toujours écrire "$DIR". Toujours.

Oublier set -e. Sans ça, un cd /repertoire-inexistant échoue silencieusement et la commande suivante s’exécute dans le mauvais répertoire. En prod, c’est catastrophique.

Cron qui ne marche pas. Dans 90% des cas, c’est un problème de PATH ou de chemins relatifs. Teste ton script manuellement avec env -i /bin/bash script.sh pour simuler l’environnement minimal de cron.

sed -i sur macOS vs Linux. Sur macOS, sed -i exige une extension de backup : sed -i '' 's/a/b/g'. Sur Linux, c’est directement sed -i 's/a/b/g'. Attention si tu écris des scripts portables.

⚠️ Le piège du $? tardif. $? contient le code de retour de la dernière commande. Si tu fais un echo entre ta commande et ton test de $?, tu testes le retour de echo (toujours 0). Utilise plutôt if commande; then directement.

Le Bash avancé repose sur quelques principes solides. Le header set -euo pipefail dans chaque script — non négociable. Les fonctions avec local pour garder le code propre. Les pipes pour chaîner grep, sed, awk et construire des one-liners puissants. Et cron pour que tout tourne automatiquement.

La vraie compétence, ce n’est pas de connaître toutes les options de find ou awk par cœur. C’est de savoir les combiner pour résoudre un problème concret en 30 secondes dans un terminal. Ça vient avec la pratique.

Dans le prochain chapitre, on passe à l’administration système : gestion des paquets, services, utilisateurs et monitoring.