Comment utiliser 'tee' pour capturer l'erreur standard

Introduction

Ce tutoriel vous guide à travers l'utilisation des flux standards Linux, en mettant l'accent sur la compréhension et la gestion du flux d'erreur standard (stderr). Vous apprendrez à utiliser la puissante commande tee pour capturer et traiter la sortie stderr, une compétence précieuse pour la gestion des erreurs et la journalisation dans les systèmes Linux.

Comprendre les flux standards Linux

Linux utilise trois flux fondamentaux pour gérer les opérations d'entrée et de sortie. Ces flux constituent la base de la manière dont les programmes communiquent dans un environnement Linux.

Que sont les flux standards ?

Ouvrez un terminal dans votre environnement Linux. Nous allons explorer le concept des flux standards à travers des exemples pratiques.

Les flux standards sont des canaux de communication qui connectent les programmes à leur environnement. Linux possède trois flux standards :

1. Entrée standard (stdin) - Descripteur de fichier 0
2. Sortie standard (stdout) - Descripteur de fichier 1
3. Erreur standard (stderr) - Descripteur de fichier 2

Voyons ces flux en action avec quelques commandes simples.

Démonstration de l'entrée standard (stdin)

L'entrée standard est la manière dont les programmes reçoivent les données, généralement à partir de l'entrée du clavier.

Tapez la commande suivante dans votre terminal :

cat

Tapez maintenant n'importe quel texte et appuyez sur Entrée. La commande cat lit depuis stdin et l'affiche sur stdout. Tapez quelques lignes de texte supplémentaires.

Pour quitter la commande cat, appuyez sur Ctrl+D (ce qui signale la fin du fichier).

Démonstration de la sortie standard (stdout)

La sortie standard est l'endroit où les programmes envoient leur sortie normale.

Exécutez cette commande :

echo "This message goes to standard output"

Vous devriez voir :

This message goes to standard output

La commande echo envoie le texte à stdout, qui est affiché sur votre terminal.

Démonstration de l'erreur standard (stderr)

L'erreur standard est l'endroit où les programmes envoient les messages d'erreur et les avertissements.

Exécutez cette commande pour générer une erreur :

ls /nonexistent_directory

Vous devriez voir un message d'erreur similaire à :

ls: cannot access '/nonexistent_directory': No such file or directory

Ce message d'erreur est envoyé à stderr, mais il apparaît sur votre terminal comme stdout.

Distinguer stdout et stderr

Pour voir la différence entre stdout et stderr, redirigeons-les séparément :

ls /home /nonexistent_directory > output.txt 2> error.txt

Examinez maintenant le contenu de chaque fichier :

cat output.txt
cat error.txt

Vous devriez voir que output.txt contient la liste du répertoire /home, tandis que error.txt contient le message d'erreur pour le répertoire inexistant.

Comprendre le fonctionnement de ces flux est crucial pour contrôler l'entrée et la sortie des programmes sous Linux.

Introduction à la commande tee

Maintenant que vous comprenez les flux standards, apprenons la commande tee, qui offre un moyen puissant de gérer ces flux.

Qu'est-ce que la commande tee ?

La commande tee sous Linux prend une entrée et l'envoie à la fois à la sortie standard et à un ou plusieurs fichiers simultanément. Elle est nommée d'après le séparateur en T utilisé en plomberie qui envoie l'eau dans deux directions.

Explorons le fonctionnement de tee avec un exemple de base :

echo "Hello, tee command" | tee hello.txt

Vous devriez voir :

Hello, tee command

Ce texte apparaît sur votre terminal et est également enregistré dans hello.txt. Confirmez cela en vérifiant le fichier :

cat hello.txt

Combiner tee avec la sortie standard

Voyons comment nous pouvons utiliser tee avec la sortie d'un programme :

ls -la ~ | tee home_contents.txt

Cette commande liste le contenu de votre répertoire personnel, l'affiche à l'écran et l'enregistre dans home_contents.txt.

Gestion de base des erreurs avec tee

Par défaut, tee ne capture que la sortie standard. Pour capturer également l'erreur standard, nous devons d'abord rediriger stderr vers stdout.

Essayez cet exemple :

ls /home /nonexistent_directory 2>&1 | tee mixed_output.txt

La partie 2>&1 redirige stderr (descripteur de fichier 2) vers stdout (descripteur de fichier 1), combinant les deux flux. La commande tee capture ensuite cette sortie combinée.

Examinez le contenu du fichier :

cat mixed_output.txt

Vous devriez voir à la fois la liste des répertoires et le message d'erreur dans le fichier.

Ajouter une sortie au lieu de l'écraser

Si vous souhaitez ajouter à un fichier plutôt que de l'écraser, utilisez l'option -a :

echo "First line" | tee log.txt
echo "Second line" | tee -a log.txt

Vérifiez le contenu :

cat log.txt

Vous devriez voir les deux lignes dans le fichier, car la deuxième commande a ajouté au fichier au lieu de l'écraser.

Gestion avancée des erreurs avec tee

Maintenant que vous comprenez les bases de tee, explorons des utilisations plus avancées pour la gestion des erreurs et la journalisation.

Séparer la sortie standard et l'erreur standard

Parfois, vous souhaitez capturer stdout et stderr séparément tout en affichant les deux sur le terminal. Créons un script qui génère les deux types de sortie :

nano test_script.sh

Ajoutez le contenu suivant au script :

#!/bin/bash
echo "This is standard output"
echo "This is standard error" >&2
ls /home
ls /nonexistent_directory

Enregistrez le fichier (appuyez sur Ctrl+O, puis sur Entrée) et quittez (appuyez sur Ctrl+X).

Rendez le script exécutable :

chmod +x test_script.sh

Maintenant, exécutez le script avec stdout et stderr capturés séparément :

./test_script.sh > >(tee stdout.log) 2> >(tee stderr.log >&2)

Cette commande complexe :

1. Exécute votre script
2. Redirige stdout vers tee stdout.log, qui l'affiche à l'écran et l'enregistre dans un fichier
3. Redirige stderr vers tee stderr.log >&2, qui l'affiche à l'écran et l'enregistre dans un fichier

Examinez les résultats :

cat stdout.log
cat stderr.log

Vous devriez voir la sortie régulière dans stdout.log et les messages d'erreur dans stderr.log.

Création d'un journal d'erreurs complet

Pour une journalisation complète, vous pouvez souhaiter :

1. Envoyer la sortie normale à l'écran
2. Envoyer les erreurs à la fois à l'écran et dans un fichier journal
3. Horodater les erreurs pour un suivi plus facile

Créons un script pour démontrer cela :

nano logging_script.sh

Ajoutez le contenu suivant :

#!/bin/bash

## Function to generate a timestamp
timestamp() {
  date +"%Y-%m-%d %H:%M:%S"
}

## Echo with timestamp to stderr
echo_error() {
  echo "$(timestamp) - ERROR: $1" >&2
}

## Normal output
echo "Starting the script"

## Error output
echo_error "Something went wrong"

## More normal output
echo "Script continuing despite the error"

## Another error
echo_error "Another issue occurred"

## Final output
echo "Script completed"

Enregistrez et rendez le script exécutable :

chmod +x logging_script.sh

Maintenant, exécutez-le avec la journalisation des erreurs :

./logging_script.sh 2> >(tee -a error_log.txt >&2)

Cela va :

1. Afficher toutes les sorties (stdout et stderr) à l'écran
2. De plus, capturer stderr dans le fichier error_log.txt

Vérifiez le journal des erreurs :

cat error_log.txt

Vous devriez voir uniquement les messages d'erreur avec les horodatages, ce qui les rend faciles à suivre.

Application concrète : commande avec progression et gestion des erreurs

Créons un exemple pratique qui télécharge un fichier, affichant la progression à l'écran tout en journalisant les erreurs :

wget https://example.com/nonexistent_file.txt 2> >(tee -a download_errors.log >&2)

Cette commande :

1. Tente de télécharger un fichier qui n'existe pas
2. Affiche toutes les sorties à l'écran, y compris la progression et les erreurs
3. De plus, journalise toutes les erreurs dans download_errors.log

Vérifiez le journal des erreurs :

cat download_errors.log

Le journal des erreurs ne contient que les messages d'erreur de la tentative de téléchargement ayant échoué.

Ces techniques vous permettent de créer des systèmes sophistiqués de gestion des erreurs et de journalisation à l'aide des commandes standard Linux.

Résumé

Dans ce tutoriel, vous avez appris des techniques essentielles pour gérer les flux standards sous Linux, en mettant l'accent sur la gestion des erreurs à l'aide de la commande tee. Vous comprenez maintenant :

• Les trois flux standards sous Linux : stdin, stdout et stderr
• Comment utiliser la commande tee pour capturer la sortie tout en l'affichant à l'écran
• Comment rediriger stderr vers stdout et capturer les deux avec tee
• Des techniques avancées pour séparer et journaliser différents flux de sortie
• Comment implémenter une journalisation des erreurs pratique dans des scénarios réels

Ces compétences sont précieuses pour créer des scripts robustes, dépanner des applications et maintenir des journaux complets dans les environnements Linux. La capacité à gérer efficacement la sortie d'erreur standard vous aidera à développer des applications Linux plus professionnelles et maintenables.