Commande Linux xargs : Construction de commandes

Introduction

Dans ce laboratoire, vous allez explorer la puissante commande xargs sous Linux. La commande xargs est un outil polyvalent qui vous permet de construire et d'exécuter des commandes à partir de l'entrée standard. Elle est particulièrement utile pour gérer des listes d'arguments et les transformer en lignes de commande.

Tout au long de ce laboratoire, nous utiliserons le concept de "traitement de livres" comme exemple de tâche. Il est important de noter que "traitement de livres" n'est pas une commande Linux spécifique, mais plutôt un espace réservé pour toute opération que vous pourriez vouloir effectuer sur une liste d'éléments. Dans nos exemples, nous utiliserons souvent des commandes simples comme echo ou touch pour simuler ce traitement. Dans des scénarios réels, vous remplaceriez ces commandes par des commandes ou des scripts plus complexes adaptés à votre tâche spécifique.

À la fin de ce laboratoire, vous serez en mesure de gérer efficacement les fichiers et d'automatiser les tâches répétitives en utilisant xargs. Ce laboratoire est conçu pour les débutants, donc n'ayez pas peur si vous êtes nouveau dans le domaine des commandes Linux - nous vous guiderons étape par étape.

Skills Graph

Comprendre la commande xargs

Commençons par comprendre l'utilisation de base de la commande xargs. Nous utiliserons un exemple simple pour démontrer le fonctionnement de xargs avec une entrée provenant d'un fichier.

Tout d'abord, examinons le contenu d'un fichier qui contient une liste de fruits :

cat ~/project/fruits.txt

Vous devriez voir la sortie suivante :

apple
orange
banana

Maintenant, utilisons xargs pour afficher le contenu de ce fichier :

cat ~/project/fruits.txt | xargs echo

Vous devriez voir la sortie suivante :

apple orange banana

Dans cet exemple, xargs prend l'entrée de cat et l'utilise comme arguments pour la commande echo. La commande echo ici simule notre opération de "traitement". Par défaut, xargs traite chaque ligne comme un argument distinct et les combine en une seule commande.

Analysons ce qui se passe ici :

1. cat ~/project/fruits.txt lit le contenu du fichier.
2. Le symbole | (pipe) envoie cette sortie à la commande suivante.
3. xargs echo prend chaque ligne de l'entrée et l'utilise comme argument pour la commande echo.

Cela est utile car cela nous permet de traiter plusieurs éléments en une seule commande, ce qui peut être beaucoup plus efficace que de traiter chaque élément séparément. Dans les applications réelles, vous remplaceriez echo par la commande ou le script que vous devez exécuter sur chaque élément de votre liste.

Traiter des fichiers avec xargs

Imaginez que vous êtes un bibliothécaire chargé d'organiser une archive numérique. Vous avez une liste de titres de livres et vous devez créer des fichiers vides pour chaque livre. Utilisons xargs pour automatiser ce processus.

Tout d'abord, examinons le contenu d'un fichier contenant quelques titres de livres :

cat ~/project/books.txt

Vous devriez voir :

The_Great_Gatsby
To_Kill_a_Mockingbird
1984

Maintenant, utilisons xargs avec la commande touch pour créer des fichiers vides pour chaque livre :

cat ~/project/books.txt | xargs -I {} touch ~/project/{}.txt

Analysons cette commande :

• cat ~/project/books.txt : Cette commande lit le contenu de notre fichier de liste de livres.
• | : Ce symbole de pipe envoie la sortie de cat à la commande suivante.
• xargs : C'est notre commande pour construire et exécuter des commandes à partir de l'entrée standard.
• -I {} : Cette option indique à xargs de remplacer les occurrences de {} dans la commande par chaque ligne d'entrée.
• touch ~/project/{}.txt : C'est la commande que xargs exécutera pour chaque ligne d'entrée. Le {} sera remplacé par chaque titre de livre.

Cette commande utilise l'option -I {} pour spécifier un espace réservé ({}) pour chaque élément d'entrée. Pour chaque ligne de books.txt, xargs remplacera {} par le titre du livre et exécutera la commande touch.

Vérifions que les fichiers ont été créés :

ls ~/project/*.txt

Vous devriez voir la sortie suivante :

/home/labex/project/1984.txt
/home/labex/project/The_Great_Gatsby.txt
/home/labex/project/To_Kill_a_Mockingbird.txt
/home/labex/project/books.txt
/home/labex/project/fruits.txt

Comme vous pouvez le voir, xargs a créé un nouveau fichier.txt pour chaque titre de livre, ainsi que nos fichiers originaux books.txt et fruits.txt.

Limiter les arguments avec xargs

Au fur et à mesure que notre bibliothèque numérique grandit, nous souhaitons traiter les livres par petits lots. L'option -n de xargs nous permet de limiter le nombre d'arguments transmis à chaque exécution de commande.

Examinons un fichier contenant plus de titres de livres :

cat ~/project/more_books.txt

Vous devriez voir :

Pride_and_Prejudice
The_Catcher_in_the_Rye
The_Hobbit
Animal_Farm
Brave_New_World

Maintenant, utilisons xargs avec l'option -n pour traiter deux livres à la fois :

cat ~/project/more_books.txt | xargs -n 2 echo "Processing books:"

Vous devriez voir une sortie similaire à celle-ci :

Processing books: Pride_and_Prejudice The_Catcher_in_the_Rye
Processing books: The_Hobbit Animal_Farm
Processing books: Brave_New_World

Analysons ce qui se passe ici :

• cat ~/project/more_books.txt : Cette commande lit le contenu de notre fichier de liste de livres.
• | : Ce symbole de pipe envoie la sortie de cat à la commande suivante.
• xargs -n 2 : Cela indique à xargs d'utiliser au maximum 2 arguments par exécution de commande.
• echo "Processing books:" : C'est la commande que xargs exécutera, avec les titres de livres comme arguments supplémentaires.

Cette commande traite les livres par paires, le dernier livre étant traité seul s'il y a un nombre impair de titres. L'option -n est utile lorsque vous souhaitez traiter les éléments par groupes de taille spécifique, ce qui peut être pratique pour gérer de grandes listes ou pour les commandes qui ont une limite sur le nombre d'arguments qu'elles peuvent gérer.

Traitement parallèle avec xargs

Alors que notre bibliothèque continue de s'étendre, nous souhaitons accélérer le traitement de nos fichiers. L'option -P de xargs nous permet d'exécuter des commandes en parallèle, ce qui peut améliorer considérablement les performances pour les opérations limitées par l'E/S (I/O-bound).

Tout d'abord, créons un script qui simule le traitement d'un livre en ajoutant une date et une heure à son contenu :

cat ~/project/process_book.sh

Vous devriez voir :

#!/bin/bash
echo "Processing $1 at $(date)" > ~/project/processed_$1
sleep 2 ## Simulate some processing time

Ce script effectue les actions suivantes :

1. Il prend un titre de livre comme argument ($1).
2. Il crée un nouveau fichier avec le préfixe "processed_" devant le titre du livre.
3. Il écrit un message dans ce fichier, y compris la date et l'heure actuelles.
4. Il attend 2 secondes pour simuler un certain temps de traitement.

Maintenant, utilisons xargs avec l'option -P pour traiter les livres en parallèle :

cat ~/project/more_books.txt | xargs -P 3 -I {} ~/project/process_book.sh {}

Analysons cette commande :

• cat ~/project/more_books.txt : Cette commande lit notre liste de livres.
• | : Ce symbole de pipe envoie la sortie à xargs.
• xargs -P 3 : Cela indique à xargs d'exécuter jusqu'à 3 processus en parallèle.
• -I {} : Cela définit {} comme un espace réservé pour chaque élément d'entrée.
• ~/project/process_book.sh {} : C'est la commande à exécuter pour chaque livre, avec {} remplacé par le titre du livre.

Cette commande commencera à traiter jusqu'à 3 livres simultanément. Après avoir exécuté la commande, vous pouvez vérifier le contenu des fichiers traités :

cat ~/project/processed_*

Vous devriez voir une sortie montrant que les livres ont été traités à des moments légèrement différents, indiquant une exécution en parallèle. Les heures exactes varieront, mais vous pourriez voir quelque chose comme :

Processing Pride_and_Prejudice at Mon Aug 12 10:15:01 UTC 2024
Processing The_Catcher_in_the_Rye at Mon Aug 12 10:15:01 UTC 2024
Processing The_Hobbit at Mon Aug 12 10:15:01 UTC 2024
Processing Animal_Farm at Mon Aug 12 10:15:03 UTC 2024
Processing Brave_New_World at Mon Aug 12 10:15:03 UTC 2024

Remarquez comment les trois premiers livres commencent à être traités en même temps, et les deux derniers commencent environ 2 secondes plus tard (en raison de sleep 2 dans notre script). Cela démontre le traitement parallèle en action.

Combiner les options de xargs

Pour notre tâche finale, nous allons explorer comment traiter nos livres par lots tout en exploitant le traitement parallèle. Nous allons utiliser une approche légèrement différente de celle initialement suggérée pour éviter l'exclusivité mutuelle des options -n et -I.

Examinons notre liste de livres classiques :

cat ~/project/classic_books.txt

Vous devriez voir :

Moby_Dick
War_and_Peace
Ulysses
Don_Quixote
The_Odyssey
Madame_Bovary
Lolita
Hamlet
The_Iliad
Crime_and_Punishment

Maintenant, utilisons xargs pour traiter ces livres par lots de 2, avec jusqu'à 3 processus en parallèle :

cat ~/project/classic_books.txt | xargs -n 2 -P 3 sh -c 'echo "Processing batch: $0 $1"'

Analysons cette commande :

• cat ~/project/classic_books.txt : Cette commande lit notre liste de livres classiques.
• | : Ce symbole de pipe envoie la sortie à xargs.
• xargs : C'est notre commande pour construire et exécuter des commandes à partir de l'entrée standard.
• -n 2 : Cette option indique à xargs d'utiliser 2 arguments (titres de livres) par exécution de commande.
• -P 3 : Cette option indique à xargs d'exécuter jusqu'à 3 processus en parallèle.
• sh -c 'echo "Processing batch: $0 $1"' : C'est la commande que xargs exécutera. Elle utilise un shell pour afficher les titres de livres. $0 et $1 représentent les deux titres de livres transmis par xargs.

Vous devriez voir une sortie similaire à celle-ci :

Processing batch: Moby_Dick War_and_Peace
Processing batch: Ulysses Don_Quixote
Processing batch: The_Odyssey Madame_Bovary
Processing batch: Lolita Hamlet
Processing batch: The_Iliad Crime_and_Punishment

Cette commande montre comment nous pouvons traiter efficacement un grand nombre d'éléments par lots tout en profitant du traitement parallèle. Dans ce cas, nous traitons les livres par paires (grâce à -n 2) et exécutons jusqu'à trois de ces commandes de traitement de paires en parallèle (grâce à -P 3).

L'avantage de cette approche est qu'elle vous permet de traiter les éléments par morceaux gérables (dans ce cas, des paires de livres) tout en profitant du traitement parallèle pour accélérer l'opération globale. Cela peut être particulièrement utile lorsqu'il s'agit de traiter de grands ensembles de données ou lorsque vous devez équilibrer la vitesse de traitement avec l'utilisation des ressources système.

Dans un scénario réel, vous pourriez remplacer la commande echo par un script de traitement plus complexe. Par exemple, vous pourriez modifier notre script process_book.sh précédent pour gérer deux livres à la fois, puis l'utiliser à la place de la commande echo.

Résumé

Dans ce laboratoire (lab), vous avez appris à utiliser la commande xargs pour automatiser les tâches de gestion de fichiers. Vous avez exploré son utilisation de base, appris à traiter des fichiers, à limiter les arguments, à effectuer un traitement parallèle et à combiner des options pour un traitement par lots efficace. Ces compétences seront inestimables lorsque vous devrez gérer de grandes quantités de données ou automatiser des tâches répétitives dans votre environnement Linux.

Voici quelques options supplémentaires de xargs qui n'ont pas été couvertes dans le laboratoire :

• -0 : Utiliser le caractère nul comme séparateur au lieu des espaces blancs
• -L : Utiliser au plus max-lines lignes d'entrée non vides par ligne de commande
• -s : Utiliser au plus max-chars caractères par ligne de commande
• -r : Ne pas exécuter la commande si l'entrée standard est vide
• -a : Lire les éléments à partir d'un fichier au lieu de l'entrée standard
• -E : Définir la chaîne de caractères de fin de fichier (EOF)

N'oubliez pas que le pouvoir de xargs réside dans sa flexibilité et sa capacité à fonctionner avec d'autres commandes Linux. Au fur et à mesure que vous continuerez à travailler avec Linux, vous rencontrerez de nombreuses situations où xargs vous aidera à automatiser des tâches et à améliorer votre productivité.