Data Piping Linux

Introduction

Le piping de données sous Linux est une technique puissante qui vous permet de transmettre la sortie d'une commande en tant qu'entrée à une autre commande. Ce concept fondamental vous permet de créer des chaînes de commandes complexes pour traiter et transformer efficacement les données. Dans ce labo, vous apprendrez à utiliser l'opérateur de pipe (|) pour combiner plusieurs commandes et créer des flux de travail de traitement de données. Vous explorerez également des utilitaires essentiels de traitement de texte comme grep, sort, tr et uniq qui sont fréquemment utilisés dans les command pipelines (pipelines de commandes).

À la fin de ce labo, vous comprendrez comment filtrer, transformer et organiser les données à l'aide des outils de ligne de commande Linux et du concept de pipeline. Ces compétences sont essentielles pour le traitement de texte, l'analyse des journaux (log analysis) et les tâches de manipulation de données dans les environnements Linux.

Comprendre la commande grep pour le filtrage de texte

La commande grep est un outil puissant de filtrage de texte sous Linux qui recherche des motifs (patterns) dans des fichiers ou des flux d'entrée (input streams). Dans cette étape, vous apprendrez à utiliser grep pour trouver des motifs de texte spécifiques dans un fichier.

Utilisons grep pour filtrer le fichier data.txt et trouver les lignes contenant la chaîne de caractères "apple" :

cd ~/project
grep "apple" data.txt

Lorsque vous exécutez cette commande, vous devriez voir la sortie suivante :

apple
pineapple

La commande grep a trouvé deux lignes qui contiennent la chaîne de caractères "apple" : la ligne contenant uniquement "apple" et la ligne contenant "pineapple".

Maintenant, utilisons grep pour trouver toutes les lignes contenant le mot "system" dans le fichier systems.txt :

grep "system" systems.txt

La sortie devrait afficher :

file system
system update
system security

La commande grep est sensible à la casse par défaut. Si vous souhaitez effectuer une recherche insensible à la casse, vous pouvez utiliser l'option -i :

grep -i "SYSTEM" systems.txt

Cela produira la même sortie qu'avant, même si nous avons recherché "SYSTEM" en majuscules alors que le fichier contient "system" en minuscules.

Maintenant que vous comprenez comment utiliser grep pour filtrer du texte, vous pouvez passer à l'étape suivante où vous apprendrez à combiner des commandes à l'aide de pipes.

Utilisation de l'opérateur Pipe pour chaîner des commandes

Dans cette étape, vous apprendrez à utiliser l'opérateur de pipe (|) pour connecter plusieurs commandes ensemble. Le pipe transmet la sortie d'une commande en tant qu'entrée à une autre commande, ce qui vous permet de créer des chaînes de commandes puissantes.

L'opérateur de pipe est représenté par le caractère barre verticale (|). Voyons comment cela fonctionne avec un exemple simple :

cd ~/project
ls -l | grep "txt"

Dans cet exemple, la commande ls -l liste les fichiers dans le répertoire courant, et sa sortie est pipée vers la commande grep "txt", qui filtre et affiche uniquement les lignes contenant "txt". Le résultat est une liste de fichiers texte dans votre répertoire courant.

Utilisons l'opérateur de pipe pour combiner grep avec d'autres commandes. Tout d'abord, trouvons toutes les lignes contenant "apple" dans le fichier foods.txt :

cat foods.txt | grep "apple"

La sortie devrait être :

apple juice
apple pie

La commande cat lit le fichier et envoie son contenu à grep via le pipe. La commande grep filtre ensuite le contenu et affiche uniquement les lignes contenant "apple".

Maintenant, combinons davantage de commandes pour transformer les données. La commande tr est utilisée pour traduire ou supprimer des caractères. Nous pouvons l'utiliser pour convertir les lettres minuscules en majuscules :

cat foods.txt | grep "apple" | tr '[:lower:]' '[:upper:]'

La sortie devrait maintenant être :

APPLE JUICE
APPLE PIE

Dans ce command pipeline (pipeline de commandes) :

1. cat foods.txt lit le contenu du fichier foods.txt
2. Le pipe (|) envoie ce contenu à grep "apple"
3. grep "apple" filtre et conserve uniquement les lignes contenant "apple"
4. Le pipe (|) envoie ces lignes filtrées à tr '[:lower:]' '[:upper:]'
5. tr '[:lower:]' '[:upper:]' convertit toutes les lettres minuscules en majuscules

Cela démontre comment vous pouvez chaîner plusieurs commandes ensemble à l'aide de pipes pour créer un flux de travail de traitement de données (data processing workflow). Chaque commande de la chaîne effectue une opération spécifique sur les données, et le résultat final est la combinaison de toutes ces opérations.

Essayons un autre exemple avec le fichier numbers.txt. Nous allons trier ces nombres par ordre croissant :

cat numbers.txt | sort -n

La sortie devrait être :

1
3
5
7
8
9
10

La commande sort avec l'option -n trie les nombres numériquement. Sans les pipes, vous devriez écrire la sortie triée dans un nouveau fichier, puis afficher ce fichier, mais avec les pipes, vous pouvez voir les résultats immédiatement.

Pipeline Avancé : Combiner sort, uniq et d'autres commandes

Dans cette étape, vous apprendrez à créer des pipelines plus complexes en combinant plusieurs commandes telles que sort, uniq, wc et d'autres pour traiter et analyser des données.

La commande sort est utilisée pour trier les lignes de fichiers texte ou de flux d'entrée (input streams). La commande uniq filtre les lignes répétées dans un fichier ou un flux d'entrée, mais elle ne fonctionne correctement que sur une entrée triée. En combinant ces commandes avec des pipes, vous pouvez traiter et organiser efficacement les données.

Pour afficher les noms de fruits uniques triés par ordre alphabétique à partir du fichier fruits_with_duplicates.txt, vous pouvez utiliser :

cd ~/project
cat fruits_with_duplicates.txt | sort | uniq

La sortie devrait être :

apple
banana
kiwi
orange

Dans ce pipeline :

1. cat fruits_with_duplicates.txt lit le contenu du fichier
2. sort organise les lignes par ordre alphabétique
3. uniq supprime les lignes en double

Si vous voulez compter le nombre de fois que chaque fruit apparaît dans la liste, vous pouvez utiliser l'option -c avec uniq :

cat fruits_with_duplicates.txt | sort | uniq -c

La sortie affichera le nombre de chaque fruit :

      3 apple
      2 banana
      1 kiwi
      1 orange

Pour savoir combien d'erreurs se sont produites dans le fichier logs.txt, vous pouvez utiliser :

cat logs.txt | grep "ERROR" | wc -l

La sortie devrait être :

3

Dans ce pipeline :

1. cat logs.txt lit le fichier de log
2. grep "ERROR" filtre uniquement les messages d'erreur
3. wc -l compte le nombre de lignes (c'est-à-dire le nombre de messages d'erreur)

Créons un pipeline plus complexe avec le fichier employees.txt. Pour trouver les départements et compter le nombre d'employés dans chacun :

cat employees.txt | cut -d',' -f2 | sort | uniq -c

La sortie devrait être :

      2 HR
      2 IT
      2 Sales

Dans ce pipeline :

1. cat employees.txt lit les données des employés
2. cut -d',' -f2 extrait le deuxième champ (département) en utilisant la virgule comme délimiteur
3. sort trie les départements par ordre alphabétique
4. uniq -c compte le nombre d'occurrences de chaque département

Ces exemples démontrent comment vous pouvez combiner plusieurs commandes à l'aide de pipes pour créer des flux de travail de traitement de données (data processing workflows) puissants. Le concept de pipeline Linux vous permet de décomposer des tâches complexes de traitement de données en étapes plus simples, ce qui rend vos opérations en ligne de commande plus efficaces et flexibles.

Applications concrètes des pipelines Linux

Dans cette dernière étape, vous explorerez quelques applications concrètes des pipelines Linux en analysant des fichiers journaux (log files), en traitant des fichiers de données et en résolvant des tâches courantes d'administration système.

Analyse des fichiers journaux

Les administrateurs système ont souvent besoin d'extraire des informations utiles des fichiers journaux. Utilisons des pipelines pour analyser le fichier server_log.txt :

1. Compter les occurrences de chaque niveau de journalisation (log level) (INFO, WARNING, ERROR) :

cd ~/project
cat server_log.txt | grep -o "INFO\|WARNING\|ERROR" | sort | uniq -c

Sortie :

      4 INFO
      3 ERROR
      2 WARNING

2. Extraire tous les horodatages (timestamps) et les niveaux de journalisation :

cat server_log.txt | grep -o "\[[0-9-]* [0-9:]*\] [A-Z]*" | head -5

Sortie :

[2023-05-10 08:45:22] INFO
[2023-05-10 09:12:35] ERROR
[2023-05-10 09:14:01] INFO
[2023-05-10 09:14:10] INFO
[2023-05-10 09:30:45] WARNING

Traitement des données CSV

Utilisons des pipelines pour analyser le fichier sales.csv :

1. Extraire et compter les produits uniques vendus :

cat sales.csv | tail -n +2 | cut -d',' -f2 | sort | uniq -c

La commande tail -n +2 ignore la ligne d'en-tête du fichier CSV.

Sortie :

      2 Keyboard
      2 Laptop
      2 Monitor
      2 Mouse
      1 Printer

2. Calculer le nombre total d'unités vendues :

cat sales.csv | tail -n +2 | cut -d',' -f3 | paste -sd+ | bc

Sortie :

113

Ce pipeline extrait la troisième colonne (Units), combine toutes les valeurs avec des signes "+", puis utilise la calculatrice bc pour calculer la somme.

Tâches de surveillance du système

Les pipelines Linux sont également utiles pour la surveillance du système et les tâches d'administration :

1. Lister les 5 principaux processus consommant le plus de mémoire :

ps aux | sort -k 4 -r | head -6

Cette commande liste les processus triés par la 4ème colonne (utilisation de la mémoire) dans l'ordre inverse et affiche les 6 premières lignes (y compris l'en-tête).

2. Trouver tous les fichiers de plus de 10 Mo et les trier par taille :

cd ..
find . -type f -size +10M -exec ls -lh {} \; | sort -k 5 -h

Cette commande affichera nos grands fichiers de test triés par taille. La sortie devrait ressembler à ceci :

-rw-r--r-- 1 labex labex 12M May 10 12:00 ./large_file3.dat
-rw-r--r-- 1 labex labex 15M May 10 12:00 ./large_file2.dat
-rw-r--r-- 1 labex labex 20M May 10 12:00 ./large_file1.dat

Cet exemple montre comment trouver et trier des fichiers par taille. Les fichiers ont été créés lors de la configuration spécifiquement pour montrer comment le filtrage de la taille des fichiers fonctionne sous Linux.

Ces exemples démontrent comment les pipelines Linux peuvent être utilisés pour résoudre efficacement des problèmes concrets. En combinant des commandes simples, vous pouvez créer des flux de travail de traitement de données (data processing workflows) puissants sans écrire de scripts ou de programmes complexes.

Résumé

Dans ce lab, vous avez découvert le data piping Linux, une technique puissante pour l'enchaînement de commandes et le traitement de données. Les concepts clés abordés dans ce lab incluent :

1. Filtrage de texte de base avec grep : Vous avez appris à utiliser la commande grep pour rechercher des motifs spécifiques dans des fichiers texte et à filtrer les données en fonction de ces motifs.

2. Enchaînement de commandes avec des Pipes : Vous avez exploré comment utiliser l'opérateur de pipe (|) pour connecter plusieurs commandes, en transmettant la sortie d'une commande comme entrée à une autre.

3. Commandes de traitement de texte : Vous avez travaillé avec divers utilitaires de traitement de texte, notamment :

   • grep pour filtrer le texte
   • tr pour la translation de caractères
   • sort pour ordonner les lignes
   • uniq pour supprimer les doublons
   • cut pour extraire des champs spécifiques de données structurées
   • wc pour compter les lignes, les mots ou les caractères

4. Applications concrètes : Vous avez appliqué ces techniques de pipeline pour résoudre des problèmes pratiques tels que l'analyse de journaux (log analysis), le traitement de données CSV et les tâches de surveillance du système (system monitoring tasks).

Ces compétences en matière de pipelines Linux sont essentielles pour les administrateurs système, les analystes de données et les développeurs travaillant dans des environnements Linux. Elles vous permettent d'effectuer des tâches complexes de manipulation de données directement à partir de la ligne de commande sans écrire de programmes à part entière. En combinant des commandes simples via des pipes, vous pouvez créer des flux de travail de traitement de données (data processing workflows) puissants, à la fois efficaces et flexibles.

Alors que vous poursuivez votre parcours Linux, vous constaterez que la maîtrise de l'art des command pipelines améliorera considérablement votre productivité et vos capacités de résolution de problèmes dans l'environnement de ligne de commande.