420-16D-FX

Appearance

Gestion des flux de données ​

Sommaire

Introduction ​

La gestion des flux de données est un concept fondamental dans les systèmes Unix/Linux. Elle permet de rediriger les entrées et sorties des programmes, de chaîner des commandes ensemble et de créer des workflows complexes. Cette capacité fait la puissance et la flexibilité de la ligne de commande.

Les canaux de communication ​

Principe général ​

Chaque processus dans Linux interagit avec trois flux de données principaux :

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

Ces flux apparaissent sous la forme de texte et permettent la communication entre les processus et l'utilisateur.

Entrée Standard (stdin - 0) ​

L'entrée standard est le chemin utilisé par un processus pour recueillir l'information reçue par l'utilisateur ou par un autre processus.

Exemples :

  • Quand on tape ls dossier, le texte "dossier" est interprété par l'entrée standard
  • La commande cat lit depuis stdin si aucun fichier n'est spécifié
  • grep "motif" attend du texte depuis stdin
bash
# Exemple d'utilisation de stdin
$ cat
# Vous pouvez maintenant taper du texte
# Appuyez sur Ctrl+D pour terminer

Sortie Standard (stdout - 1) ​

La sortie standard est le chemin utilisé par un processus pour donner les résultats demandés. La sortie peut être affichée dans le terminal ou redirigée vers un autre processus.

Exemples :

  • Le résultat de ls s'affiche via stdout
  • Les résultats de grep sont envoyés sur stdout
  • echo "texte" écrit sur stdout
bash
# Exemples de sortie standard
$ ls -l
$ echo "Bonjour monde"
$ date

Erreur Standard (stderr - 2) ​

L'erreur standard est le chemin utilisé par un processus pour donner les messages d'erreur. Cela permet de séparer les messages d'erreur des résultats normaux.

Exemples :

  • ls dossier_inexistant envoie l'erreur sur stderr
  • rm -r dossier sans permissions génère une erreur sur stderr
bash
# Exemple d'erreur standard
$ ls /dossier/inexistant
ls: cannot access '/dossier/inexistant': No such file or directory

Redirection des flux ​

Redirection de la sortie standard ​

Redirection simple > ​

Le symbole > permet d'écrire la sortie d'un processus dans un fichier. Attention : cela écrase le contenu existant du fichier !

bash
# Rediriger la sortie de ls vers un fichier
$ ls -l > liste_fichiers.txt

# Créer un fichier avec du texte
echo "Bonjour" > salutation.txt

# Sauvegarder la date actuelle
$ date > date_actuelle.txt

Redirection en ajout >> ​

Le symbole >> permet d'ajouter à un fichier existant sans l'écraser.

bash
# Ajouter du texte à un fichier existant
$ echo "Ligne supplémentaire" >> fichier.txt

# Ajouter la liste des processus
$ ps aux >> rapport_systeme.txt

# Logger des informations
$ date >> log.txt
$ echo "Démarrage du script" >> log.txt

Redirection des erreurs ​

Redirection d'erreurs 2> ​

Le symbole 2> permet de rediriger uniquement les messages d'erreur vers un fichier.

bash
# Rediriger les erreurs vers un fichier
$ ls /dossier/inexistant 2> erreurs.txt

# Essayer de supprimer des fichiers, capturer les erreurs
$ rm fichier1 fichier2 fichier3 2> erreurs_suppression.txt

Redirection d'erreurs en ajout 2>> ​

Le symbole 2>> permet d'ajouter les erreurs à un fichier existant.

bash
# Ajouter les erreurs à un log
$ find /etc -name "*.conf" 2>> erreurs_recherche.txt

Redirection combinée ​

Rediriger sortie et erreurs &> ​

Le symbole &> permet de rediriger à la fois stdout et stderr vers le même fichier.

bash
# Rediriger tout vers un fichier
$ ls -l /home /root &> resultats_complets.txt

# Version équivalente plus explicite
$ ls -l /home /root > resultats.txt 2>&1

Comprendre 2>&1 - Duplication de descripteurs ​

La syntaxe 2>&1 mérite une explication détaillée car elle est très utilisée :

  • 2> = rediriger stderr (descripteur 2)
  • &1 = vers le même endroit que stdout (descripteur 1)
  • L'ordre est important : > fichier 2>&1

Pourquoi cette syntaxe ?

bash
# INCORRECT - ne fonctionne pas comme attendu
$ commande 2>&1 > fichier
# stderr va vers le terminal, stdout vers le fichier

# CORRECT - les deux vont vers le fichier
$ commande > fichier 2>&1
# D'abord stdout vers fichier, puis stderr vers la même destination

Exemples pratiques :

bash
# Rediriger tout vers un fichier
$ find /etc -name "*.conf" > resultats.txt 2>&1

# Rediriger tout vers /dev/null (exécution silencieuse)
$ commande > /dev/null 2>&1

# Dans un script, capturer toute la sortie
$  ./mon_script.sh > log_complet.txt 2>&1

# Équivalences :
$ commande &> fichier     # Même chose que :
$ commande > fichier 2>&1

Cas d'usage courants :

bash
# Test d'existence de commande
command -v git > /dev/null 2>&1 && echo "Git installé"

Rediriger vers le vide /dev/null ​

Le fichier spécial /dev/null permet d'ignorer complètement une sortie.

bash
# Ignorer les erreurs
$ find /etc -name "*.conf" 2> /dev/null

# Ignorer toute sortie
$ commande_bruyante &> /dev/null

# Exécuter silencieusement
$ crontab -l > /dev/null 2>&1

Redirection de l'entrée ​

Redirection simple < ​

Le symbole < permet d'utiliser le contenu d'un fichier comme entrée d'une commande.

bash
# Compter les lignes d'un fichier
$ wc -l < fichier.txt

# Trier le contenu d'un fichier
$ sort < noms.txt

# Différence entre ces deux commandes :
$ wc fichier.txt      # Affiche : "10 fichier.txt"
$ wc < fichier.txt    # Affiche : "10"

Here Document << (document intégré) ​

Le symbole << permet d'utiliser du texte multi-lignes comme entrée.

bash
# Créer un fichier avec plusieurs lignes
$ cat << EOF > nouveau_fichier.txt
Première ligne
Deuxième ligne
Troisième ligne
EOF

# Rechercher dans du texte directement
$ grep "ligne" << FIN
Voici une ligne de texte
Voici une autre ligne
Et une dernière ligne
FIN

EOF et FIN sont des délimiteurs que vous pouvez choisir librement.

Here String <<< ​

Le symbole <<< permet d'utiliser une chaîne de caractères comme entrée.

bash
# Utiliser une variable comme entrée
$ nom="Jean Dupont"
$ wc -w <<< "$nom"

# Compter les caractères
$ wc -c <<< "Bonjour monde"

# Rechercher un motif
$ grep "Jean" <<< "Jean Dupont travaille ici"

Les pipes (tubes) ​

Principe ​

Un pipe | permet de connecter la sortie d'une commande à l'entrée d'une autre commande. C'est l'un des concepts les plus puissants d'Unix/Linux.

En effet, toutes les commandes GNU/Linux sont conçues pour fonctionner avec des flux de texte, ce qui permet de chaîner les commandes facilement.

bash
# Syntaxe de base
$ commande1 | commande2

# Chaînage multiple
$ commande1 | commande2 | commande3

Exemples simples ​

bash
# Afficher les fichiers et les compter
$ ls | wc -l

# Trier les utilisateurs du système
$ cat /etc/passwd | cut -d: -f1 | sort

Exemples avancés ​

bash
# Trouver les 10 plus gros fichiers du répertoire courant
$ ls -la | sort -k5 -nr | head -10

# Afficher les extensions de fichiers uniques
$ ls | grep '\.' | cut -d. -f2- | sort | uniq

# Compter les types de fichiers
$ file * | cut -d':' -f2 | sort | uniq -c

Combinaisons avancées ​

Redirection et pipes ensemble ​

bash
# Pipe avec redirection d'erreurs
$ find /etc -name "*.conf" 2> /dev/null | head -20

# Redirection d'entrée et pipe
$ sort < noms.txt | uniq > noms_uniques.txt

Utilisation du tee ​

La commande tee permet d'afficher ET de sauvegarder simultanément.

bash
# Afficher et sauvegarder
$ ls -la | tee liste.txt

# Afficher et ajouter à un fichier
$ ps aux | tee -a rapport.txt

# Multiple destinations
$ echo "Message important" | tee fichier1.txt fichier2.txt

Commandes utiles pour les flux ​

Commandes de filtrage ​

bash
# grep - rechercher des motifs
$ ls -la | grep "^d"          # Dossiers uniquement
$ ps aux | grep -v grep       # Exclure grep lui-même

# head/tail - début/fin de fichier
$ ls | head -5                # 5 premiers
$ cat /etc/passwd | tail -3   # 3 derniers

Commandes de transformation ​

bash
# sort - trier
$ ls | sort -r               # Tri inverse

# uniq - éliminer les doublons
$ sort fichier.txt | uniq -c # Compter les occurrences

Administration système ​

bash
# Analyser l'utilisation disque
$ df -h | grep -v tmpfs | sort -k5 -nr

# Trouver les processus gourmands
$ ps aux | sort -k3 -nr | head -10

# Nettoyer les logs anciens
$ find /var/log -name "*.log" -mtime +30 | xargs rm

# Surveiller les connexions réseau
$ netstat -tuln | grep LISTEN | sort -k4

Traitement de données ​

bash
# Analyser un fichier CSV
$ cut -d, -f2 donnees.csv | sort | uniq -c | sort -nr

# Extraire des emails d'un fichier
$ grep -o '[a-zA-Z0-9._%+-]*@[a-zA-Z0-9.-]*\.[a-zA-Z]{2,}' fichier.txt | sort | uniq

Maintenance et surveillance ​

bash
# Surveiller les erreurs en temps réel
$ tail -f /var/log/syslog | grep -i error

Pratique 💃 ​

Pour pratiquer ces commandes, utilisez les fichiers de données fournis dans le répertoire donnees/ du dépôt GitLab suivant :

https://gitlab.com/16d/420-16d-exercices/-/tree/main/gestion-flux

Cloner le dépôt avec :

bash
$ git clone https://gitlab.com/16d/420-16d-exercices.git
$ cd 420-16d-exercices/commandes-affichage

Ou faite un pull si vous avez déjà cloné le dépôt pour récupérer les dernières modifications.

Quiz 🎉 ​

👋🏾 Cliquez sur la bonne réponse.

1 / 19 👉🏾 Quel est le descripteur de fichier pour l'entrée standard (stdin) ?

  • A. 1

  • B. 2

  • C. 0

  • D. 3

.