Introduction
Les petites commandes Linux deviennent bien plus utiles lorsque le shell les coordonne. Une commande indique sa réussite ou son échec au moyen d’un code de sortie ; les opérateurs de séquence déterminent la prochaine commande à exécuter ; un tube relie la sortie standard d’une commande à l’entrée standard d’une autre.
Vous allez construire ces notions progressivement, puis utiliser grep, cut, wc, sort et uniq pour transformer un petit jeu de données contenant des événements de service. Les prochains laboratoires consacrés au traitement de texte approfondiront ces filtres. Ici, l’objectif est de comprendre comment les données et les décisions circulent d’une commande à l’autre.
Observer le code de sortie d’une commande
Dans cette étape, vous allez relier le comportement visible d’une commande au code numérique que le shell enregistre.
Un code de sortie égal à 0 indique une réussite ; une valeur différente de zéro signifie que la commande n’a pas pu effectuer l’opération demandée. Exécutez un test de fichier réussi, puis affichez immédiatement $?, qui contient le code de sortie le plus récent :
cd /home/labex/project/pipeline-lab
test -f events.csv
echo $?
La sortie est 0. Testez maintenant un fichier inexistant :
test -f missing.csv
echo $?
Le code de sortie est différent de zéro. Lisez $? immédiatement, car chaque commande suivante le remplace.
Créez une observation stable à l’aide d’une instruction if. Vous étudierez les scripts shell complets plus tard ; ici, cette instruction convertit simplement le code de sortie en texte :
if test -f events.csv; then echo "events.csv is ready"; else echo "events.csv is missing"; fi > status-result.txt
cat status-result.txt
Contrôler la prochaine commande exécutée
Dans cette étape, vous allez comparer les opérateurs de commande inconditionnels et conditionnels.
Un point-virgule exécute la commande suivante quel que soit le résultat de la précédente :
false; echo "semicolon continues"
&& exécute la commande de droite uniquement après une réussite :
test -f events.csv && echo "input found"
test -f missing.csv && echo "you should not see this"
|| exécute la commande de droite uniquement après un échec :
test -f missing.csv || echo "input missing"
Ces opérateurs permettent d’exprimer une petite décision en fonction d’une réussite ou d’un échec. Copiez le jeu de données uniquement s’il existe ; sinon, affichez une erreur :
test -f events.csv && cp events.csv working.csv || echo "Copy failed"
Vérifiez que la copie protégée correspond à sa source :
cmp events.csv working.csv && echo "guarded copy matches" > sequence-result.txt
cat sequence-result.txt
Pour une logique complexe, préférez une instruction if lisible ; les longues chaînes de && et || peuvent devenir ambiguës.
Envoyer la sortie dans un pipeline
Dans cette étape, vous allez relier des commandes avec | et observer comment chaque étape réduit le flux de données.
La commande de gauche écrit sa sortie standard dans le tube ; la commande de droite lit ces données comme entrée standard. Sélectionnez uniquement les enregistrements ERROR :
cd /home/labex/project/pipeline-lab
cat events.csv | grep ',ERROR,'
grep peut lire directement un fichier ; cette forme plus courte produit donc le même résultat :
grep ',ERROR,' events.csv
Ajoutez wc -l pour compter les lignes correspondantes :
grep ',ERROR,' events.csv | wc -l
Enregistrez à la fois le flux filtré et son nombre. tee duplique son entrée standard : il écrit une copie dans error-events.csv et transmet l’autre copie dans sa sortie standard. Le dernier wc -l compte donc exactement les lignes enregistrées :
grep ',ERROR,' events.csv | tee error-events.csv | wc -l > error-count.txt
cat error-events.csv
cat error-count.txt
Examinez les deux fichiers après l’exécution du pipeline. error-events.csv contient les enregistrements correspondants, tandis que error-count.txt contient leur nombre.
Extraire des champs avec cut
Dans cette étape, vous allez traiter chaque ligne CSV comme une suite de champs séparés par un délimiteur.
cut -d, -f1 utilise la virgule comme délimiteur et affiche le champ 1, c’est-à-dire le nom du service :
cd /home/labex/project/pipeline-lab
cut -d, -f1 events.csv
Affichez ensemble les champs du service et de la sévérité :
cut -d, -f1,2 events.csv
Combinez le filtrage et l’extraction pour lister uniquement les services ayant produit des avertissements :
grep ',WARN,' events.csv | cut -d, -f1
Enregistrez ce résultat intermédiaire :
grep ',WARN,' events.csv | cut -d, -f1 > warning-services.txt
cat warning-services.txt
cut convient bien aux enregistrements simples dont le délimiteur n’apparaît jamais à l’intérieur d’un champ. Les formats plus complexes peuvent nécessiter awk ou un outil prenant en charge le format concerné.
Trier et compter les valeurs répétées
Dans cette étape, vous allez construire un pipeline complet de calcul de fréquences et comprendre pourquoi le tri doit précéder uniq.
uniq regroupe uniquement les lignes identiques adjacentes. Extrayez d’abord les noms des services, puis triez-les afin que les valeurs identiques soient voisines :
cd /home/labex/project/pipeline-lab
cut -d, -f1 events.csv | sort
Ajoutez uniq -c pour compter chaque série de noms identiques :
cut -d, -f1 events.csv | sort | uniq -c
Triez les nombres par ordre numérique décroissant. sort -k1,1nr utilise le premier champ comme clé numérique en ordre inverse :
cut -d, -f1 events.csv | sort | uniq -c | sort -k1,1nr
Enregistrez le rapport final :
cut -d, -f1 events.csv | sort | uniq -c | sort -k1,1nr > service-frequency.txt
cat service-frequency.txt
Lisez ce pipeline de gauche à droite : extraire → trier → compter les doublons adjacents → classer les nombres.
Résumé
Vous avez utilisé le code de sortie comme indicateur de réussite du shell, contrôlé l’exécution avec ;, && et ||, puis construit des pipelines composés d’étapes claires. Vous avez ensuite filtré des enregistrements, extrait des champs, compté des lignes, trié des valeurs et compté les doublons : exactement le vocabulaire nécessaire pour le prochain Challenge consacré aux pipelines de données.
