Maîtriser la commande parallel

GNU Parallel est un outil encore trop peu connu dans l’univers des administrateurs système, mais c’est pourtant une alternative puissante à la commande xargs. Il permet d’exécuter plusieurs tâches simultanément, exploitant au maximum les ressources du système. Là où xargs exécute les commandes en série, parallel les traite en parallèle, avec un contrôle précis sur le nombre de jobs, la gestion des erreurs et l’affichage du progrès. Idéal pour automatiser des traitements lourds ou longs, il devient rapidement indispensable dès qu’on le découvre.

Installation et configuration

GNU Parallel n’est pas toujours installé par défaut sur les systèmes Linux. Voici comment l’installer et vérifier son bon fonctionnement.

Installation sur Debian/Ubuntu
Fenêtre de terminal
```
sudo apt update
sudo apt install parallel
```
Installation sur CentOS/RHEL/Fedora
Fenêtre de terminal
```
sudo dnf install parallel
```
Via Homebrew (macOS)
Fenêtre de terminal
```
brew install parallel
```

Téléchargement depuis le site officiel Pour les systèmes sans gestionnaire de paquets ou pour obtenir la dernière version :

wget https://ftp.gnu.org/gnu/parallel/parallel-latest.tar.bz2
tar -xjf parallel-latest.tar.bz2
cd parallel-*
./configure && make && sudo make install

Vérification de l’installation Une fois installé, vérifiez que parallel fonctionne correctement :
Fenêtre de terminal
```
parallel --version
```

GNU Parallel est prêt à l’emploi dès son installation, sans configuration particulière. Mais ses nombreuses options permettent d’en tirer un usage très personnalisé.

Syntaxe de base

La syntaxe de GNU Parallel repose sur l’idée de lire une liste d’arguments et d’exécuter en parallèle une commande pour chacun d’eux.

Structure générale

parallel commande ::: argument1 argument2 argument3

Chaque argument est substitué dans la commande, et les exécutions se font en parallèle.

Exemple simple

parallel echo ::: un deux trois

Produit (ordre non garanti) :

un
deux
trois

Avec des fichiers

parallel gzip ::: *.log

Compresse tous les fichiers .log simultanément avec gzip.

Utilisation d’un placeholder `{}`

{} représente l’argument courant dans la commande :

parallel echo "Fichier : {}" ::: fichier1.txt fichier2.txt

Affiche :

Fichier : fichier1.txt
Fichier : fichier2.txt

Lecture depuis l’entrée standard

cat liste.txt | parallel echo

Lit les lignes du fichier liste.txt et les passe à echo, en parallèle.

Cette syntaxe simple et expressive permet d’automatiser rapidement des tâches complexes et parallèles en ligne de commande.

Options courantes de GNU Parallel

GNU Parallel offre de nombreuses options pour contrôler l’exécution de vos tâches. Voici les plus fréquemment utilisées :

-j : nombre de jobs simultanés Définit combien de tâches s’exécutent en parallèle. Par défaut, parallel utilise autant de jobs que de cœurs CPU.
Fenêtre de terminal
```
parallel -j 4 echo ::: a b c d e
```
--dry-run : mode simulation Affiche les commandes qui seraient exécutées, sans les lancer. Idéal pour tester.
Fenêtre de terminal
```
parallel --dry-run echo ::: a b
```
--eta : affichage du temps estimé Affiche une estimation du temps restant pour l’ensemble des tâches.
Fenêtre de terminal
```
parallel --eta echo ::: a b c d
```
--bar : barre de progression Affiche une barre de progression visuelle.
Fenêtre de terminal
```
parallel --bar echo ::: {1..100}
```
--halt : arrêt sur erreur Permet d’interrompre l’exécution dès qu’une tâche échoue.
Fenêtre de terminal
```
parallel --halt now,fail=1 commande ::: fichier1 fichier2
```
--results : sauvegarde des résultats Enregistre la sortie et les erreurs de chaque commande dans un dossier structuré.
Fenêtre de terminal
```
parallel --results sortie_dir echo ::: a b c
```

Ces options font de GNU Parallel un outil à la fois puissant, précis et sûr pour gérer des traitements en masse.

Utilisation avec des fichiers et des commandes

GNU Parallel excelle dans le traitement de listes de fichiers ou de commandes, en particulier lorsqu’il s’agit d’automatiser des opérations répétitives.

Lecture de commandes depuis un fichier Contenu du fichier cmds.txt :
Fenêtre de terminal
```
echo toto
echo tata
echo tutu
```
Exécution :
Fenêtre de terminal
```
parallel < cmds.txt
```
Traitement de fichiers listés dans un fichier
Fenêtre de terminal
```
cat fichiers.txt | parallel gzip
```
Avec find pour traiter des fichiers en parallèle
Fenêtre de terminal
```
find . -name "*.log" | parallel rm
```

Combinaison avec tar pour archiver en parallèle

find . -name "*.txt" | parallel -j 4 tar -rvf archive.tar {}

Utilisation avec scp pour transférer plusieurs fichiers
Fenêtre de terminal
```
cat serveurs.txt | parallel scp fichier.txt user@{}:/chemin/
```
Lancement de scripts shell sur une liste de fichiers
Fenêtre de terminal
```
ls *.csv | parallel ./traitement.sh {}
```

GNU Parallel s’adapte parfaitement aux scénarios de traitement en lot, tout en gardant une syntaxe lisible et rapide à déployer.

Gestion des entrées complexes

GNU Parallel offre des options robustes pour gérer des entrées contenant des espaces, caractères spéciaux ou lignes multiples, là où d’autres outils échouent.

Utilisation de délimiteurs personnalisés : Par défaut, parallel sépare les arguments par des espaces ou des retours à la ligne. On peut définir un autre séparateur avec --delimiter :
Fenêtre de terminal
```
cat liste.csv | parallel --colsep ',' echo "Nom : {1}, Âge : {2}"
```
Fichiers avec des espaces ou caractères spéciaux : Pas besoin de protection particulière, parallel traite correctement les noms de fichiers complexes :
Fenêtre de terminal
```
ls "mon fichier.txt" | parallel echo {}
```
Entrées null-terminées avec --null : Pour traiter des fichiers listés avec find -print0, utilisez --null :
Fenêtre de terminal
```
find . -name "*.log" -print0 | parallel --null rm
```
Passage de plusieurs arguments à la fois : On peut grouper plusieurs champs par ligne avec --colsep ou en définissant plusieurs {} :
Fenêtre de terminal
```
echo -e "fichier1 out1\nfichier2 out2" | parallel --colsep ' ' cp {1} {2}
```

Ces fonctionnalités permettent à GNU Parallel de gérer des cas complexes et robustes, sans scripts supplémentaires ou manipulations intermédiaires.

Exemples pratiques

Conversion de fichiers audio en parallèle
Fenêtre de terminal
```
ls *.wav | parallel ffmpeg -i {} {.}.mp3
```

Redimensionnement d’images

ls *.png | parallel convert {} -resize 800x600 {.}_small.png

Téléchargement de plusieurs fichiers avec wget
Fenêtre de terminal
```
cat urls.txt | parallel wget
```
Analyse de logs avec un script personnalisé
Fenêtre de terminal
```
ls logs/*.log | parallel ./analyse_logs.sh {}
```
Compression de plusieurs dossiers
Fenêtre de terminal
```
ls -d */ | parallel tar -czf {.}.tar.gz {}
```

Transfert de fichiers vers plusieurs serveurs

parallel scp fichier.txt user@{}:/chemin/ ::: serveur1 serveur2 serveur3

Extraction de données à partir de fichiers CSV
Fenêtre de terminal
```
ls data/*.csv | parallel ./extract_columns.sh {}
```

Recherche parallèle dans des fichiers volumineux

find /data -type f -name "*.log" | parallel grep -H "erreur" {}

Ces exemples montrent comment GNU Parallel peut accélérer des tâches répétitives ou lourdes, tout en gardant une syntaxe simple et efficace.

Limitations et précautions

Consommation élevée des ressources système : L’exécution simultanée de nombreux jobs peut saturer le CPU, la mémoire ou le réseau. Utilisez -j pour limiter le nombre de tâches :
Fenêtre de terminal
```
parallel -j 4 commande ::: args
```
Risques de surcharge disque ou I/O : Si plusieurs tâches écrivent en même temps sur le même disque, cela peut provoquer des ralentissements ou des conflits.
Commandes non thread-safe : Certains outils ou scripts ne sont pas conçus pour une exécution parallèle. Des conflits ou des erreurs peuvent apparaître.
Sécurité des opérations à distance : Lorsqu’on utilise parallel avec ssh ou scp, il faut s’assurer que l’authentification sans mot de passe est configurée correctement.
Gestion des erreurs : Par défaut, Parallel continue même si une tâche échoue. Pour forcer l’arrêt à la première erreur :
Fenêtre de terminal
```
parallel --halt now,fail=1 ...
```
Droits d’accès : Vérifiez les permissions sur les fichiers ou les répertoires utilisés dans les jobs parallèles.
Lecture simultanée de fichiers partagés : Évitez que plusieurs processus lisent ou modifient les mêmes fichiers en parallèle sans synchronisation.

Pour utiliser GNU Parallel de manière fiable, il est essentiel de tester ses commandes en amont, de surveiller les ressources système et de prévoir des mécanismes de contrôle en cas d’échec.

Conclusion

Vous l’avez compris, GNU Parallel est un outil puissant pour exécuter des commandes en parallèle, idéal pour automatiser des tâches répétitives ou longues. Sa syntaxe simple et ses nombreuses options en font un allié indispensable pour les administrateurs système et les développeurs. Que ce soit pour compresser des fichiers, transférer des données ou exécuter des scripts, GNU Parallel vous fera gagner un temps précieux et optimisera l’utilisation des ressources de votre système. N’hésitez pas à l’intégrer dans vos scripts et à l’explorer davantage pour découvrir toutes ses fonctionnalités.