Introduction à la redirection et aux tubes (`>`, `>>`, `|`) pour combiner des commandes

Introduction : la plomberie du shell pour des commandes surpuissantes

Jusqu'à présent, nous avons principalement interagi avec les commandes Linux de manière isolée : nous tapons une commande, elle produit une sortie à l'écran, ou prend une entrée depuis le clavier. Cependant, la véritable puissance du shell Linux réside dans sa capacité à combiner des commandes, à manipuler leurs flux de données pour créer des opérations complexes et personnalisées. Les mécanismes clés pour cela sont la redirection et les tubes (ou "pipes").

Ce sous-chapitre vous initiera à ces concepts fondamentaux. Vous apprendrez comment rediriger la sortie d'une commande vers un fichier, comment utiliser le contenu d'un fichier comme entrée pour une commande, et comment enchaîner plusieurs commandes pour que la sortie de l'une devienne l'entrée de la suivante. Maîtriser ces outils ouvre des perspectives immenses pour l'automatisation, le traitement de texte, et l'administration système.

Considérez la redirection et les tubes comme la "plomberie" de votre shell, vous permettant de diriger les flux d'informations exactement où vous le souhaitez.

Les flux standards : entrée, sortie, et erreur

Avant de parler de redirection, il est utile de comprendre que chaque processus (et donc chaque commande que vous lancez) sous Linux opère avec au moins trois flux de données standards :

• L'entrée standard (stdin) : C'est par où le processus reçoit des données. Par défaut, c'est le clavier. Son descripteur de fichier est le `0`.
• La sortie standard (stdout) : C'est par où le processus envoie sa sortie normale, les résultats attendus de son exécution. Par défaut, c'est l'écran (votre terminal). Son descripteur de fichier est le `1`.
• La sortie d'erreur standard (stderr) : C'est par où le processus envoie les messages d'erreur ou de diagnostic. Par défaut, c'est aussi l'écran. Son descripteur de fichier est le `2`.

Comprendre ces trois flux est la clé pour maîtriser la redirection, car c'est leur destination ou leur source que nous allons modifier.

Redirection de la sortie standard (`>` et `>>`)

La redirection de la sortie standard permet d'envoyer ce qu'une commande afficherait normalement à l'écran vers un autre endroit, typiquement un fichier.

• Il envoie la sortie standard (stdout) de la commande vers un fichier.
• Attention : Si le fichier spécifié n'existe pas, il est créé. S'il existe déjà, son contenu précédent est écrasé sans avertissement !

Exemples :

# Sauvegarde la liste détaillée des fichiers du répertoire courant dans liste_fichiers.txt
ls -l > liste_fichiers.txt

# Affiche "Bonjour le monde" puis le redirige dans le fichier greeting.txt
echo "Bonjour le monde" > greeting.txt

# Crée un fichier vide (si une commande ne produit pas de sortie, le fichier sera vide)
touch un_fichier_test > output.txt # output.txt sera vide

• Il envoie la sortie standard (stdout) de la commande vers un fichier.
• Si le fichier n'existe pas, il est créé. S'il existe déjà, la nouvelle sortie est ajoutée à la fin du contenu existant du fichier, sans l'écraser.

Exemples :

# Ajoute la date et l'heure actuelles à la fin du fichier journal.log
date >> journal.log

# Ajoute un nouveau message à greeting.txt sans effacer le contenu précédent
echo "Comment allez-vous ?" >> greeting.txt

Redirection de l'entrée standard (`<`)

La redirection de l'entrée standard permet à une commande de lire ses données depuis un fichier plutôt que depuis le clavier.

Exemples :

# La commande `sort` trie normalement ce qu'on lui tape au clavier.
# Ici, elle triera le contenu du fichier `liste_noms.txt` et affichera le résultat à l'écran.
sort < liste_noms.txt

# La commande `wc -l` compte les lignes. Ici, elle comptera les lignes du fichier `mon_script.sh`.
wc -l < mon_script.sh

De nombreuses commandes qui opèrent sur des fichiers peuvent prendre le nom du fichier comme argument direct (par exemple, `sort liste_noms.txt` ou `wc -l mon_script.sh`). Cependant, la redirection d'entrée est utile pour des commandes qui attendent interactivement une entrée ou pour des raisons de clarté dans les scripts.

Les tubes (pipes) : enchaîner les commandes (`|`)

Le tube (pipe), symbolisé par `|`, est l'un des outils les plus puissants et élégants du shell Linux. Il permet de connecter la sortie standard (stdout) d'une commande directement à l'entrée standard (stdin) d'une autre commande. Cela crée un "pipeline" où les données circulent d'une commande à l'autre, permettant des traitements en série.

Syntaxe : `commande1 | commande2 | commande3 ...`

Exemples :

# 1. `ls -l` liste les fichiers du répertoire courant (sa sortie va vers le tube).
# 2. `grep ".txt"` reçoit cette liste en entrée et filtre pour n'afficher que les lignes contenant ".txt".
ls -l | grep ".txt"

# Affiche le nombre de processus appartenant à l'utilisateur 'toto'
# 1. `ps aux` liste tous les processus en cours.
# 2. `grep "toto"` filtre les lignes contenant "toto".
# 3. `wc -l` compte le nombre de lignes reçues (donc le nombre de processus de 'toto').
ps aux | grep "toto" | wc -l

# Afficher les 5 fichiers les plus volumineux du répertoire /var/log
# 1. `du -a /var/log` affiche l'utilisation disque de tous les fichiers dans /var/log.
# 2. `sort -nr` trie la sortie numériquement et en ordre inverse (les plus gros d'abord).
# 3. `head -n 5` affiche les 5 premières lignes du résultat trié.
du -a /var/log | sort -nr | head -n 5

Les possibilités offertes par les tubes sont immenses, permettant de combiner des outils simples et spécialisés pour accomplir des tâches complexes sans avoir besoin de fichiers intermédiaires.

Rediriger la sortie d'erreur et combiner les flux (avancé)

Par défaut, `>` et `>>` ne redirigent que la sortie standard (stdout, descripteur de fichier 1). La sortie d'erreur (stderr, descripteur de fichier 2) continue de s'afficher à l'écran.

Pour rediriger la sortie d'erreur, vous pouvez spécifier son descripteur de fichier :

# Redirige la sortie d'erreur de commande_qui_echoue vers erreurs.log
commande_qui_echoue 2> erreurs.log

# Redirige la sortie d'erreur en mode ajout
commande_qui_echoue 2>> erreurs.log

Pour rediriger à la fois stdout et stderr vers le même fichier :

# Méthode courante : redirige stdout vers le fichier, puis stderr vers la même destination que stdout (&1)
ma_commande > output_et_erreurs.log 2>&1

# Syntaxe plus moderne (Bash 4+) pour rediriger stdout et stderr
ma_commande &> output_et_erreurs.log
# ou en mode ajout
ma_commande &>> output_et_erreurs.log

Un cas d'usage fréquent est de "jeter" la sortie d'erreur si elle n'est pas pertinente, en la redirigeant vers `/dev/null` (un fichier spécial qui absorbe tout ce qu'on lui envoie) :

commande_bruyante_en_erreurs 2> /dev/null

Ces techniques avancées de redirection sont particulièrement utiles dans les scripts shell pour gérer finement les sorties et les erreurs.

Conclusion : une nouvelle dimension de la ligne de commande

L'introduction à la redirection (`>`, `>>`, `<`) et aux tubes (`|`) ouvre une nouvelle dimension dans votre utilisation de la ligne de commande Linux. Ces outils transforment des commandes individuelles en briques que vous pouvez assembler pour construire des solutions puissantes et élégantes à des problèmes variés.

Au début, cela peut sembler un peu abstrait, mais avec la pratique, vous commencerez à voir des opportunités partout pour combiner des commandes afin d'automatiser des tâches, de filtrer des informations, et d'analyser des données directement depuis votre terminal. C'est une compétence fondamentale qui distingue un utilisateur occasionnel d'un utilisateur averti et productif de Linux. N'hésitez pas à expérimenter avec différentes combinaisons pour bien assimiler leur fonctionnement.