Introduction
Dans cet atelier, vous allez explorer la puissance de la 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 manipuler des listes d'arguments et les transformer en lignes de commande.
Tout au long de cet atelier, nous utiliserons le concept de « traitement de livres » comme exemple de tâche. Il est important de noter que le « traitement de livres » n'est pas une commande Linux spécifique, mais plutôt un substitut 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 scripts ou des commandes plus complexes adaptés à votre tâche spécifique.
À la fin de cet atelier, vous serez capable de gérer efficacement des fichiers et d'automatiser des tâches répétitives à l'aide de xargs. Cet atelier est conçu pour les débutants, alors ne vous inquiétez pas si vous découvrez les commandes Linux : nous vous guiderons soigneusement à chaque étape.
Comprendre la commande xargs
Commençons par comprendre l'utilisation de base de la commande xargs et dans quels cas elle s'avère utile. xargs est particulièrement pratique lorsque vous devez récupérer la sortie d'une commande pour l'utiliser comme arguments d'une autre commande. C'est une situation courante dans les scripts shell et les flux de travail en ligne de commande.
Imaginez un scénario où vous avez une liste d'éléments et que vous souhaitez effectuer une action sur chaque élément. Bien que vous puissiez utiliser une boucle for dans un script, xargs offre souvent une méthode plus concise et efficace, surtout lorsqu'il s'agit de listes volumineuses ou lorsque la commande cible peut traiter plusieurs arguments à la fois.
Utilisons un exemple simple pour démontrer comment xargs fonctionne avec l'entrée provenant d'un fichier. Tout d'abord, examinons le contenu d'un fichier contenant 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. Cela simule la récupération de chaque ligne du fichier pour l'utiliser comme argument de la commande echo.
cat ~/project/fruits.txt | xargs echo
Vous devriez voir la sortie suivante :
apple orange banana
Dans cet exemple, xargs récupère l'entrée de cat (chaque ligne du fichier) et l'utilise comme arguments pour la commande echo. La commande echo simule ici notre opération de « traitement ». Par défaut, xargs traite chaque ligne comme un argument distinct et les combine en une seule exécution de commande.
Analysons ce qui se passe ici :
cat ~/project/fruits.txtlit le contenu du fichier.- Le symbole
|(tube ou pipe) envoie cette sortie à la commande suivante. xargs echoprend chaque ligne de l'entrée et l'utilise comme argument pour la commandeecho.
C'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, surtout lorsque la commande cible accepte plusieurs arguments. Dans des applications réelles, vous remplaceriez echo par n'importe quelle commande ou script que vous devez exécuter sur chaque élément de votre liste. C'est là que xargs excelle : il fait le pont entre les commandes qui produisent des listes et celles qui opèrent sur des arguments.
Traitement de fichiers avec xargs
En nous appuyant sur notre compréhension de la manière dont xargs utilise les entrées comme arguments, explorons une application plus concrète : le traitement de fichiers. 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. Bien qu'une simple boucle for puisse faire l'affaire, xargs offre une alternative intéressante, notamment lorsque la liste des fichiers est générée par une autre commande (comme find).
Utilisons xargs pour automatiser ce processus de création de fichiers à partir d'une liste. Tout d'abord, regardons 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. Nous allons introduire l'option -I, qui est cruciale lorsque vous devez placer l'argument d'entrée à une position spécifique dans la commande exécutée.
cat ~/project/books.txt | xargs -I {} touch ~/project/{}.txt
Décomposons cette commande :
cat ~/project/books.txt: Lit le contenu de notre fichier de liste de livres.|: Ce symbole de tube envoie la sortie decatà la commande suivante.xargs: Notre commande pour construire et exécuter des commandes à partir de l'entrée standard.-I {}: Cette option indique àxargsde remplacer chaque occurrence de{}dans la commande par chaque ligne d'entrée. C'est particulièrement utile lorsque la commande que vous exécutez nécessite l'argument d'entrée au milieu ou au début, et pas seulement à la fin.touch ~/project/{}.txt: C'est la commande quexargsexécutera pour chaque ligne d'entrée. Le{}sera remplacé par chaque titre de livre, et.txtsera ajouté pour créer le nom du fichier.
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, créant ainsi un fichier nommé d'après le titre du livre avec une extension .txt.
Vérifions que les fichiers ont bien é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, en plus de nos fichiers originaux books.txt et fruits.txt. Cela démontre comment xargs peut être utilisé pour appliquer une commande à une liste d'éléments, ce qui en fait un outil puissant pour la manipulation de fichiers et l'automatisation.
Limiter les arguments avec xargs
À mesure que notre bibliothèque numérique s'agrandit, nous pouvons rencontrer des situations où la commande que nous voulons exécuter limite le nombre d'arguments qu'elle peut accepter, ou bien nous souhaitons simplement traiter les éléments par petits lots pour un meilleur contrôle ou une meilleure gestion des ressources. L'option -n de xargs nous permet de limiter le nombre d'arguments passés à chaque exécution de commande. C'est un autre scénario où xargs offre un contrôle précis sur l'exécution des commandes en fonction de l'entrée.
Regardons un fichier contenant davantage 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. Nous utiliserons à nouveau echo pour visualiser les lots en cours de traitement.
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: Lit le contenu de notre fichier de liste de livres.|: Envoie la sortie decatà la commande suivante.xargs -n 2: Indique àxargsd'utiliser au maximum 2 arguments par exécution de commande. Cela signifie quexargsregroupera les lignes d'entrée par deux et exécutera la commande cible pour chaque groupe.echo "Processing books:": C'est la commande quexargsexécutera. Les arguments (les titres des livres) seront ajoutés à la suite de cette commande.
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 des éléments par groupes de taille spécifique, ce qui peut aider à gérer de grandes listes ou des commandes ayant une limite sur le nombre d'arguments. Elle permet de diviser une tâche importante en sous-tâches plus petites et plus maniables, exécutées par la même commande.
Traitement parallèle avec xargs
Alors que notre bibliothèque continue de s'étendre, nous voulons accélérer le traitement de nos fichiers. Pour les tâches indépendantes les unes des autres, l'exécution en parallèle peut réduire considérablement le temps total d'exécution. L'option -P de xargs nous permet d'exécuter simultanément plusieurs instances de la commande cible, ce qui améliore considérablement les performances pour les opérations liées aux entrées/sorties (I/O) ou les tâches impliquant de l'attente. C'est un avantage clé de xargs par rapport à un traitement séquentiel simple avec une boucle for.
Tout d'abord, créons un script qui simule le traitement d'un livre en ajoutant un horodatage à son contenu et en introduisant un délai. Ce délai nous aidera à visualiser l'exécution parallèle.
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 opérations suivantes :
- Il prend un titre de livre comme argument (
$1). - Il crée un nouveau fichier avec le préfixe "processed_" devant le titre du livre.
- Il écrit un message dans ce fichier, incluant la date et l'heure actuelles.
- Il attend 2 secondes pour simuler un temps de traitement, rendant l'exécution parallèle plus évidente.
Maintenant, utilisons xargs avec l'option -P pour traiter les livres en parallèle. Nous utiliserons également l'option -I pour passer chaque titre de livre comme argument à notre script.
cat ~/project/more_books.txt | xargs -P 3 -I {} ~/project/process_book.sh {}
Décomposons cette commande :
cat ~/project/more_books.txt: Lit notre liste de livres.|: Envoie la sortie versxargs.xargs -P 3: Indique àxargsde lancer jusqu'à 3 processus en parallèle.xargslancera simultanément jusqu'à 3 instances de la commande cible, chacune traitant un ou plusieurs éléments d'entrée.-I {}: Définit{}comme espace réservé pour chaque élément d'entrée, qui sera passé en argument à notre script.~/project/process_book.sh {}: C'est la commande à exécuter pour chaque livre, où{}est 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 très proches, ce qui indique une exécution 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 leur traitement en même temps, et les deux derniers commencent environ 2 secondes plus tard (à cause du sleep 2 dans notre script). Cela démontre le traitement parallèle en action, un avantage significatif de l'utilisation de xargs pour accélérer des tâches indépendantes.
Combiner les options de xargs
Dans des scénarios réels, vous devez souvent combiner différentes options de xargs pour obtenir le comportement de traitement souhaité. Pour notre tâche finale, nous allons explorer comment traiter nos livres par lots tout en profitant du traitement parallèle. Nous utiliserons une approche légèrement différente de celle suggérée initialement pour éviter l'exclusion mutuelle des options -n et -I lorsqu'elles sont utilisées directement avec une commande simple. À la place, nous utiliserons une commande shell (sh -c) comme cible pour xargs, ce qui nous permet de gérer plusieurs arguments passés par -n à l'intérieur du script shell.
Regardons 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 parallèles. Nous utiliserons sh -c pour exécuter une commande simple qui affiche le lot en cours de traitement.
cat ~/project/classic_books.txt | xargs -n 2 -P 3 sh -c 'echo "Processing batch: $@"' _
Décomposons cette commande :
cat ~/project/classic_books.txt: Lit notre liste de livres classiques.|: Envoie la sortie versxargs.xargs: Notre commande pour construire et exécuter des commandes à partir de l'entrée standard.-n 2: Cette option indique àxargsd'utiliser 2 arguments (titres de livres) par exécution de commande. Ces deux arguments seront passés à la commandesh -c.-P 3: Cette option indique àxargsde lancer jusqu'à 3 processus en parallèle. Chaque processus exécutera la commandesh -cavec un lot de 2 titres de livres.sh -c 'echo "Processing batch: $@"' _: C'est la commande quexargsexécutera.sh -c: Exécute une chaîne de commande via le shell.'echo "Processing batch: $@"': La chaîne de commande à exécuter.$@à l'intérieur du script shell se développe en tous les paramètres positionnels passés au script, qui sont ici les arguments fournis parxargs(les deux titres de livres)._: C'est un argument factice passé àsh -c. Il devient la valeur de$0à l'intérieur du script shell. Nous l'utilisons ici carsh -cs'attend à ce que$0soit défini, et cela n'affecte pas la sortie lors de l'utilisation de$@.
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 dé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 (ici, des paires de livres) tout en utilisant le parallélisme pour accélérer l'opération globale. Cela peut être particulièrement utile lors de la manipulation de grands ensembles de données ou lorsque vous devez équilibrer la vitesse de traitement et l'utilisation des ressources système. En utilisant sh -c, nous pouvons gérer efficacement les multiples arguments passés par -n au sein d'une seule exécution de commande, faisant de xargs un outil flexible pour des flux de traitement complexes. Dans un scénario réel, vous pourriez remplacer la commande echo par un script de traitement plus complexe conçu pour gérer un lot d'éléments.
Résumé
Dans cet atelier, 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 précieuses lorsque vous devrez manipuler 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é abordées dans cet atelier :
-0: Utilise le caractère nul comme séparateur au lieu des espaces blancs.-L: Utilise au maximum un nombre défini de lignes d'entrée non vides par ligne de commande.-s: Utilise au maximum un nombre défini de caractères par ligne de commande.-r: N'exécute pas la commande si l'entrée standard est vide.-a: Lit les éléments depuis un fichier au lieu de l'entrée standard.-E: Définit une chaîne de fin de fichier (EOF).
N'oubliez pas que la puissance de xargs réside dans sa flexibilité et sa capacité à fonctionner avec d'autres commandes Linux. En continuant à travailler avec Linux, vous découvrirez de nombreuses autres situations où xargs peut vous aider à automatiser des tâches et à améliorer votre productivité.
