Laboratoire avancé sur la redirection des flux et la manipulation de fichiers sous Linux

Introduction

Sous Linux, la redirection est une fonctionnalité puissante qui vous permet de contrôler la destination des entrées et des sorties de vos commandes. Vous avez peut-être déjà rencontré des opérateurs comme > ou >> dans des laboratoires précédents. Ils servent à rediriger la sortie vers des fichiers. Ce laboratoire vous présentera le concept de redirection et vous guidera à travers divers exemples pratiques, accessibles aux débutants sans connaissances préalables de Linux.

Redirection de sortie de base

Commençons par les bases de la redirection de sortie :

Ouvrez votre terminal. Vous devriez vous trouver dans le répertoire /home/labex/project. Si vous n'en êtes pas sûr, vous pouvez taper pwd (print working directory) pour vérifier votre emplacement actuel.
Nous allons créer un nouveau fichier nommé redirect contenant du texte. Tapez la commande suivante :
```
echo 'hello labex' > redirect
```
Cette commande effectue deux actions :
- echo 'hello labex' affiche le texte "hello labex"
- Le symbole > redirige cette sortie vers un fichier nommé redirect
Si le fichier n'existe pas, il sera créé. S'il existe déjà, son contenu sera écrasé.
Ajoutons maintenant du contenu supplémentaire au même fichier :
```
echo 'labex.io' >> redirect
```
L'opérateur >> est similaire à >, mais au lieu d'écraser le fichier, il ajoute le nouveau contenu à la fin du fichier existant.
Pour visualiser le contenu du fichier que nous venons de créer et modifier, utilisez la commande cat :
```
cat redirect
```
Vous devriez voir les deux lignes que nous avons ajoutées : "hello labex" sur la première ligne et "labex.io" sur la seconde.

Comprendre l'entrée, la sortie et l'erreur standard

Avant d'approfondir la redirection, comprenons trois concepts importants :

Entrée standard (stdin) : Il s'agit de la source d'entrée par défaut, généralement votre clavier. C'est là que le système s'attend à recevoir des données.
Sortie standard (stdout) : Il s'agit de la destination de sortie par défaut, généralement votre écran. C'est là que le système envoie les sorties normales.
Erreur standard (stderr) : C'est là que les messages d'erreur sont envoyés, également sur votre écran par défaut. Ce flux est séparé de stdout pour permettre un traitement différencié des erreurs si nécessaire.

Sous Linux, ces flux sont représentés par des descripteurs de fichiers, qui sont simplement des nombres identifiant les fichiers ouverts :

Descripteur de fichier	Fichier de périphérique	Description
`0`	`/dev/stdin`	stdin
`1`	`/dev/stdout`	stdout
`2`	`/dev/stderr`	stderr

Voyons un exemple d'utilisation :

Tout d'abord, créons un nouveau répertoire nommé Documents :
```
mkdir Documents
```
Cette commande crée un nouveau répertoire. Si vous recevez une erreur indiquant que le répertoire existe déjà, ce n'est pas grave ; cela signifie que vous pouvez utiliser celui qui existe.
Créons maintenant un fichier C dans ce répertoire :
```
cat > Documents/test.c << EOF
#include <stdio.h>

int main()
{
    printf("hello world\n");
    return 0;
}
EOF
```
Cette commande effectue plusieurs actions :
- cat > lance le processus d'écriture dans un fichier
- Documents/test.c est le fichier cible
- << EOF indique au shell de continuer à accepter les entrées jusqu'à ce qu'il rencontre "EOF" (End Of File)
- Les lignes intermédiaires constituent le contenu écrit dans le fichier
- Le EOF final marque la fin de l'entrée
Visualisons maintenant le contenu de ce fichier :
```
cat Documents/test.c
```
Vous devriez voir le code C que nous venons de créer.

Redirection de l'erreur standard

Explorons maintenant comment rediriger l'erreur standard :

Essayez de lire deux fichiers, l'un existant et l'autre non :
```
cat Documents/test.c nonexistent.c
```
Vous verrez le contenu de test.c (qui existe) et un message d'erreur pour nonexistent.c (qui n'existe pas). Le contenu de test.c est envoyé vers stdout, tandis que le message d'erreur est envoyé vers stderr.
Redirigeons maintenant la sortie standard vers un fichier et l'erreur standard vers un autre :
```
cat Documents/test.c nonexistent.c > output.log 2> error.log
```
Cette commande effectue plusieurs actions :
- cat Documents/test.c nonexistent.c tente d'afficher le contenu des deux fichiers
- > output.log redirige stdout (descripteur de fichier 1) vers un fichier nommé output.log
- 2> error.log redirige stderr (descripteur de fichier 2) vers un fichier nommé error.log
Visualisez le contenu des deux fichiers :
```
echo "Output log:"
cat output.log
echo "Error log:"
cat error.log
```
Vous devriez voir le contenu de test.c dans output.log et le message d'erreur concernant nonexistent.c dans error.log.

Combiner la sortie standard et l'erreur standard

Parfois, vous souhaiterez rediriger à la fois la sortie standard et l'erreur standard vers le même fichier. C'est particulièrement utile pour capturer toute la sortie d'une commande, qu'il s'agisse de résultats normaux ou de messages d'erreur.

Essayons de lister le contenu de notre répertoire actuel et d'un répertoire inexistant en une seule commande :
```
ls -l . nonexistent_directory > combined_output.log 2>&1
```
Cette commande effectue plusieurs actions :
- ls -l . liste le contenu du répertoire actuel
- nonexistent_directory est une tentative de lister un répertoire qui n'existe pas
- > combined_output.log redirige stdout vers un fichier nommé combined_output.log
- 2>&1 redirige stderr vers la même destination que stdout (ici, combined_output.log)
Vérifions maintenant le contenu de notre fichier de sortie combiné :
```
cat combined_output.log
```
Vous devriez voir à la fois la liste du répertoire et le message d'erreur concernant le répertoire inexistant dans ce fichier.
Il existe une syntaxe abrégée pour rediriger à la fois stdout et stderr vers le même fichier dans bash :
```
ls -l . nonexistent_directory &> another_combined_output.log
```
L'opérateur &> est équivalent à > file 2>&1.
Vérifiez le contenu de ce nouveau fichier :
```
cat another_combined_output.log
```
Vous devriez voir la même sortie que dans le fichier précédent.

Utilisations avancées de /dev/null

Le périphérique /dev/null, souvent appelé "bit bucket" ou "trou noir", est un fichier spécial qui rejette toutes les données qui y sont écrites. Il possède plusieurs applications utiles dans le scripting shell et les opérations en ligne de commande.

Supprimer la sortie d'une commande : Nous avons déjà vu comment supprimer la sortie standard :
```
ls -l > /dev/null
```
Et comment supprimer à la fois la sortie standard et l'erreur standard :
```
ls -l nonexistent_directory > /dev/null 2>&1
```
Supprimer uniquement les messages d'erreur : Parfois, vous souhaitez voir la sortie mais pas les messages d'erreur :
```
ls -l . nonexistent_directory 2> /dev/null
```
Vous devriez voir la liste du répertoire, mais pas l'erreur concernant le répertoire inexistant.
Utiliser /dev/null comme fichier vide : /dev/null peut être utilisé comme une entrée de fichier vide. C'est utile pour les commandes qui nécessitent un fichier d'entrée alors que vous ne souhaitez fournir aucune donnée réelle. Par exemple :
```
grep "pattern" /dev/null
```
Cette commande ne produira aucune sortie car /dev/null est un fichier vide.
Tester l'existence d'un fichier : Vous pouvez utiliser /dev/null pour tester si un fichier existe sans produire de sortie :
```
if cp Documents/test.c /dev/null 2> /dev/null; then
  echo "Le fichier existe et est lisible"
else
  echo "Le fichier n'existe pas ou n'est pas lisible"
fi
```
Ce script tente de copier test.c vers /dev/null. Si l'opération réussit, cela signifie que le fichier existe et est lisible.
Vider le contenu d'un fichier : Vous pouvez utiliser /dev/null pour vider rapidement le contenu d'un fichier :
```
cat /dev/null > combined_output.log
```
Vérifiez que le fichier est maintenant vide :
```
cat combined_output.log
```
Vous ne devriez voir aucune sortie, ce qui indique que le fichier est désormais vide.

Résumé

Dans ce laboratoire, vous avez appris à rediriger les flux de données sous Linux. Vous avez pratiqué :

La redirection de sortie de base avec > et >>.
La compréhension de l'entrée, de la sortie et de l'erreur standard.
La redirection de l'erreur standard avec 2>.
La suppression de sortie en redirigeant vers /dev/null.

Ces techniques de redirection sont des outils puissants sous Linux qui vous permettent de contrôler la destination des sorties de vos commandes. Elles sont essentielles pour le scripting, la journalisation (logging) et la gestion efficace des sorties de commandes. À mesure que vous continuerez à travailler avec Linux, vous découvrirez de nombreuses situations où ces techniques s'avéreront utiles.

Redirection des flux de données