GNU Parallel : exécuter en parallèle

Quand vous devez traiter des centaines de fichiers, convertir des images en masse ou exécuter des scripts sur plusieurs serveurs, lancer les tâches une par une est trop lent. GNU Parallel permet d'exécuter plusieurs commandes simultanément, en exploitant tous les cœurs de votre CPU. Là où xargs traite séquentiellement, parallel répartit la charge et accélère drastiquement vos traitements batch.

Ce que vous allez apprendre

• Exécuter des commandes en parallèle avec :::
• Contrôler le nombre de jobs avec -j
• Utiliser les placeholders ({}, {.}, {/})
• Gérer les fichiers avec espaces et caractères spéciaux
• Surveiller la progression et gérer les erreurs
• Combiner parallel avec find et d'autres commandes

La commande parallel dans l'écosystème Linux

GNU Parallel est l'évolution logique de xargs pour les traitements en masse. Voici comment il se positionne :

Commande	Spécialité	Quand l'utiliser
parallel	Exécution parallèle	Traitement en masse, performance maximale
xargs	Exécution séquentielle	Commandes simples, une par une
make -j	Build parallèle	Compilation de projets
& / wait	Jobs background	Quelques tâches indépendantes

Glissez pour voir

Avantages de parallel sur xargs :

• Exécution réellement parallèle (pas juste -P)
• Barre de progression (--bar, --eta)
• Gestion des erreurs avancée (--halt)
• Placeholders riches ({.}, {/}, {#}...)
• Exécution sur serveurs distants (-S)

Comprendre GNU Parallel en 2 minutes

🧠 Modèle mental — Comment fonctionne parallel

parallel = Pour chaque argument → Lancer N commandes simultanément → Collecter les résultats

Points clés

• parallel lit les arguments et lance plusieurs instances de la commande simultanément
• Par défaut, parallel lance autant de jobs que de cœurs CPU
• {} représente l'argument courant, {.} sans extension, {/} nom de base
• ::: passe des arguments inline, :::: lit depuis un fichier
• L'ordre des sorties n'est PAS garanti (exécution parallèle)

Règles d'or

1

Toujours tester avec --dry-run d'abord Vérifie les commandes qui seront exécutées sans les lancer.

2

Limiter les jobs avec -j pour éviter la surcharge Trop de jobs parallèles peut saturer CPU, mémoire ou disque.

Vocabulaire essentiel

:::

Passe des arguments directement en ligne de commande

::::

Lit les arguments depuis un fichier

{}

Placeholder pour l'argument courant

-j N

Nombre de jobs en parallèle (défaut: nb CPU)

--dry-run

Affiche les commandes sans les exécuter

--bar

Affiche une barre de progression

📚 Pour aller plus loin — 12 options avancées

{.}

Argument sans extension

{/}

Nom de base (sans chemin)

{//}

Chemin du répertoire

{/.}

Nom de base sans extension

{#}

Numéro du job (séquence)

{%}

Numéro du slot (worker)

--colsep

Séparateur de colonnes pour plusieurs champs

--halt

Comportement sur erreur (now,fail=1...)

--results

Enregistre stdout/stderr dans un dossier

--eta

Affiche le temps restant estimé

--null

Arguments séparés par NUL (pour find -print0)

-S

Exécution sur serveurs distants (SSH)

Contrairement à xargs qui passe les arguments à une seule instance de commande, parallel lance N instances simultanées (N = nombre de cœurs CPU par défaut).

Syntaxe complète

parallel [options] commande ::: arguments           # Arguments inline
parallel [options] commande :::: fichier.txt        # Arguments depuis fichier
cat liste.txt | parallel [options] commande {}      # Arguments depuis stdin

Options principales :

Option	Description	Exemple
-j N	N jobs en parallèle (défaut: nb CPU)	parallel -j 4 ...
--dry-run	Affiche sans exécuter	parallel --dry-run rm ...
--bar	Barre de progression	parallel --bar cmd ...
--halt	Comportement sur erreur	--halt now,fail=1
-k	Préserve l'ordre des sorties	parallel -k echo ...

Glissez pour voir

Les 3 parties d'une commande parallel

Partie	Question	Exemples	Obligatoire ?
Source	D'où viennent les arguments ?	:::, ::::, stdin	✅ Oui
Commande	Quelle commande exécuter ?	gzip {}, convert	✅ Oui
Contrôle	Combien de parallélisme ?	-j 4, --bar	❌ Non (défauts)

Glissez pour voir

Les placeholders : le cœur de parallel

Placeholder	Signification	Exemple (/path/photo.jpg)
{}	Argument complet	/path/photo.jpg
{.}	Sans extension	/path/photo
{/}	Nom de base (sans chemin)	photo.jpg
{//}	Chemin du répertoire	/path
{/.}	Nom de base sans extension	photo
{#}	Numéro du job (1, 2, 3...)	1
{%}	Numéro du slot (worker)	2

Glissez pour voir

Exemple de conversion :

# Convertir photo.jpg → photo.png
parallel convert {} {.}.png ::: *.jpg

# Résultat pour photo.jpg :
# convert photo.jpg photo.png

Les sources d'arguments

Source	Syntaxe	Exemple
Inline	::: arg1 arg2	parallel echo ::: a b c
Fichier	:::: fichier.txt	parallel wget :::: urls.txt
Stdin	cmd | parallel	find . | parallel gzip
Multi-colonnes	--colsep	parallel --colsep ',' cp {1} {2}

Glissez pour voir

Contrôler le parallélisme

# Défaut : autant de jobs que de cœurs CPU
parallel gzip ::: *.log

# Limiter à 4 jobs simultanés
parallel -j 4 gzip ::: *.log

# Un seul job (séquentiel, pour debug)
parallel -j 1 gzip ::: *.log

# Autant de jobs que d'arguments (attention !)
parallel -j 0 gzip ::: *.log

⚠️ Attention : trop de jobs parallèles peut saturer le système (CPU, mémoire, I/O disque). Commencez par -j 4 et ajustez.

Gestion des fichiers avec espaces

Le piège classique : les fichiers avec espaces sont mal découpés.

# ❌ DANGER : "mon fichier.jpg" devient "mon" et "fichier.jpg"
ls *.jpg | parallel echo {}

# ✅ CORRECT : utiliser find -print0 + --null
find . -name "*.jpg" -print0 | parallel --null echo {}

La combinaison find -print0 | parallel --null est le pattern sécurisé pour tous les traitements de fichiers.

Erreurs typiques (et solutions)

Erreur	Cause	Solution
Fichiers mal découpés	Espaces dans les noms	find -print0 | parallel --null
Sorties mélangées	Exécution parallèle	Ajouter -k ou --line-buffer
Système saturé	Trop de jobs	Limiter avec -j 4
Fichiers supprimés par erreur	Pas de test	TOUJOURS --dry-run d'abord
SSH demande mot de passe	Clé non configurée	ssh-copy-id user@serveur

Glissez pour voir

Installation

GNU Parallel n'est pas toujours installé par défaut :

# Debian/Ubuntu
sudo apt install parallel

# CentOS/RHEL/Fedora
sudo dnf install parallel

# macOS (Homebrew)
brew install parallel

# Vérification
parallel --version

Les modèles essentiels

Maintenant que vous comprenez la logique de parallel, voici dix modèles prêts à l'emploi. Chacun donne sa formule générale et un exemple concret.

Exécution parallèle basique

Lancer la même commande sur plusieurs arguments.

parallel commande ::: arg1 arg2 arg3   # formule
parallel gzip ::: *.log                # exemple

• ::: : sépare la commande de la liste d'arguments

Depuis l'entrée standard

Lire les arguments depuis un pipe.

cat liste.txt | parallel commande {}                 # formule
find . -name "*.jpg" | parallel convert {} {.}.png   # exemple

• {} : placeholder de l'argument courant

Limiter le parallélisme

Contrôler le nombre de jobs simultanés.

parallel -j N commande ::: arguments   # formule
parallel -j 4 gzip ::: *.log           # exemple

• -j N : N jobs maximum (défaut : nombre de cœurs CPU)
• -j 0 : autant de jobs que d'arguments

Mode simulation

Vérifier les commandes avant de les exécuter.

parallel --dry-run commande ::: arguments   # formule
parallel --dry-run rm ::: *.bak             # exemple

• --dry-run : affiche les commandes sans rien lancer — indispensable avant rm

Transformation de fichiers

Convertir des fichiers en changeant leur extension.

parallel commande {} {.}.new_ext ::: fichiers   # formule
parallel ffmpeg -i {} {.}.mp3 ::: *.wav         # exemple

• {.} : argument sans extension — {/} : nom de base — {//} : répertoire

Fichiers avec espaces (sécurisé)

Traiter sans risque les noms contenant des espaces.

find . -print0 | parallel --null commande {}                       # formule
find . -name "*.jpg" -print0 | parallel --null convert {} {.}.png  # exemple

• -print0 + --null : séparateur nul — le couple sûr pour les fichiers

Suivi de progression

Afficher l'avancement des tâches.

parallel --bar commande ::: arguments      # formule
parallel --bar --eta gzip ::: *.log        # exemple

• --bar : barre de progression — --eta : temps restant estimé

Gestion des erreurs

Contrôler le comportement quand une tâche échoue.

parallel --halt now,fail=1 commande ::: arguments      # formule
parallel --halt now,fail=1 ./script.sh ::: *.txt       # exemple

• now,fail=1 : stoppe dès la première erreur
• soon,fail=20% : stoppe au-delà de 20 % d'échecs

Arguments multi-colonnes

Utiliser plusieurs champs par ligne d'un fichier.

parallel --colsep ',' commande {1} {2} :::: fichier.csv    # formule
parallel --colsep ',' cp {1} {2} :::: batch.csv            # exemple

• --colsep : séparateur de colonnes — {1}, {2} : les colonnes
• :::: : lit les arguments depuis un fichier

Exécution sur serveurs distants

Distribuer les tâches sur plusieurs machines via SSH.

parallel -S serveur1,serveur2 commande ::: arguments    # formule
parallel -S srv1,srv2,srv3 hostname ::: {1..10}         # exemple

• -S : liste des serveurs SSH (clé SSH sans mot de passe requise)

Les pièges à éviter

Huit erreurs reviennent constamment avec parallel. Certaines sont destructrices, d'autres saturent simplement la machine.

Pas de test avant rm/mv

parallel rm ::: *.bak   # ❌ supprime immédiatement, sans retour possible

Symptôme : des fichiers supprimés par erreur. Cause : aucune vérification des commandes avant exécution.

parallel --dry-run rm ::: *.bak   # ✅ prévisualiser, puis relancer sans --dry-run

Surcharge du système

parallel -j 100 gzip ::: *.log   # ❌ trop de jobs : système saturé

Symptôme : système lent, mémoire saturée, swap intense. Cause : trop de processus parallèles pour les ressources disponibles.

parallel -j 4 gzip ::: *.log   # ✅ limiter à un nombre raisonnable

Fichiers avec espaces

ls *.jpg | parallel echo {}   # ❌ casse sur "mon fichier.jpg"

Symptôme : les arguments sont coupés au niveau des espaces. Cause : le retour à la ligne est le séparateur par défaut.

find . -name "*.jpg" -print0 | parallel --null echo {}   # ✅ séparateur nul

Ordre des sorties non garanti

parallel echo ::: 1 2 3 4 5   # ❌ affichage dans un ordre aléatoire

Symptôme : résultats désordonnés. Cause : l'exécution parallèle ne garantit aucun ordre.

parallel -k echo ::: 1 2 3 4 5   # ✅ -k préserve l'ordre des sorties

Sorties entremêlées

parallel commande ::: args   # ❌ les lignes de plusieurs jobs se mélangent

Symptôme : lignes de sortie entrelacées, illisibles. Cause : aucune synchronisation de la sortie entre jobs.

parallel --line-buffer commande ::: args   # ✅ --line-buffer (ou --group)

SSH sans clé configurée

parallel -S serveur commande ::: args   # ❌ bloque sur la demande de mot de passe

Symptôme : exécution figée, timeout. Cause : authentification SSH par clé non configurée.

ssh-copy-id user@serveur   # ✅ configurer la clé, puis relancer parallel

Guillemets mal gérés

parallel echo "File: {}" ::: *.txt   # ❌ le shell interprète les guillemets

Symptôme : arguments mal passés, caractères spéciaux interprétés. Cause : le shell traite les guillemets avant parallel.

parallel echo 'File: {}' ::: *.txt   # ✅ guillemets simples

Conflits d'écriture dans un fichier

parallel "cat {} >> output.txt" ::: *.log   # ❌ fichier de sortie corrompu

Symptôme : sortie corrompue, lignes mélangées. Cause : plusieurs processus écrivent dans le même fichier en même temps.

parallel "cat {} > {}.out" ::: *.log && cat *.out > output.txt   # ✅ un fichier par job, puis fusion

Travaux pratiques

Rien ne remplace la pratique. Créez l'environnement de test ci-dessous, puis déroulez les huit étapes. À la fin, nettoyez avec rm -rf ~/parallel-lab.

Préparer le terrain

Ce script crée une arborescence dans ~/parallel-lab : des images (dont certaines avec des espaces dans le nom), des logs, une liste de serveurs, une liste d'URLs et un CSV.

# Créer le lab
mkdir -p ~/parallel-lab/{images,logs,data}
cd ~/parallel-lab

# Fichiers images simulés
for i in {1..10}; do
  echo "image $i data" > images/photo_$i.jpg
done

# Fichiers avec espaces dans le nom
echo "data 1" > "images/mon fichier 1.jpg"
echo "data 2" > "images/photo vacances 2024.jpg"

# Fichiers de logs
for i in {1..5}; do
  echo "Log content $i" > logs/app_$i.log
done

# Liste d'URLs
cat > urls.txt << 'EOF'
https://example.com/file1.txt
https://example.com/file2.txt
https://example.com/file3.txt
EOF

# Fichier CSV pour les tests multi-colonnes
cat > data/batch.csv << 'EOF'
fichier1,output1
fichier2,output2
fichier3,output3
EOF

echo "✅ Lab créé dans ~/parallel-lab"
ls -la ~/parallel-lab/

Les huit étapes

1. Première commande parallèle. Exécutez echo sur plusieurs arguments avec :::.

   parallel echo ::: un deux trois quatre

   ::: passe les arguments à parallel ; chaque echo s'exécute en parallèle (l'ordre varie).

2. Utiliser le placeholder {}. Affichez « Traitement de … » pour chaque image.

   ls ~/parallel-lab/images/*.jpg | parallel echo "Traitement de {}"

   {} est remplacé par chaque ligne de l'entrée standard.

3. Tester sans exécuter. Vérifiez les suppressions qui seraient effectuées, sans rien supprimer.

   ls ~/parallel-lab/logs/*.log | parallel --dry-run rm {}

   --dry-run affiche les commandes sans les lancer — essentiel avant un rm.

4. Limiter le parallélisme. Lancez 6 sleep de 1 seconde, 2 à la fois.

   parallel -j 2 sleep 1 ::: {1..6}

   -j 2 limite à 2 jobs simultanés — l'ensemble prend environ 3 secondes.

5. Transformer des fichiers. Simulez la conversion des .jpg en .png.

   ls ~/parallel-lab/images/*.jpg | parallel --dry-run echo convert {} {.}.png

   {.} retire l'extension — idéal pour les conversions de format.

6. Gérer les fichiers avec espaces. Traitez les images, espaces compris.

   find ~/parallel-lab/images -name "*.jpg" -print0 | parallel --null echo "Fichier : {}"

   -print0 et --null préservent les noms contenant des espaces.

7. Afficher la progression. Lancez des tâches avec une barre de progression.

   parallel --bar sleep 0.5 ::: {1..10}

   --bar affiche la progression ; --eta ajoute le temps restant estimé.

8. Arrêt sur erreur. Faites stopper parallel dès la première erreur.

   parallel --halt now,fail=1 'test {} = 3 && exit 1; echo {}' ::: {1..5}

   --halt now,fail=1 arrête tout dès qu'un job renvoie un code d'erreur.

Exercices progressifs

Huit exercices pour valider votre maîtrise. Ils se traitent sur le lab ~/parallel-lab. Cherchez d'abord par vous-même, puis dépliez la solution pour vous corriger.

Niveau fondations

Exercice 1 — Premiers pas avec :::. Affichez les nombres de 1 à 5 en parallèle. Indice : ::: passe les arguments à parallel.

Voir la solution

parallel echo ::: 1 2 3 4 5

::: sépare la commande des arguments ; chaque nombre est passé à echo.

Exercice 2 — Compression parallèle. Compressez tous les fichiers .log du lab avec gzip. Indice : ::: avec le glob *.log.

Voir la solution

parallel gzip ::: ~/parallel-lab/logs/*.log

Chaque fichier .log est compressé simultanément.

Exercice 3 — Mode simulation. Vérifiez les commandes qui supprimeraient les fichiers .bak, sans rien supprimer. Indice : --dry-run.

Voir la solution

parallel --dry-run rm ::: *.bak

--dry-run est indispensable avant toute commande destructive.

Niveau composition

Exercice 4 — Limiter le parallélisme. Lancez 6 sleep de 1 seconde, mais 2 à la fois seulement. Indice : -j limite le nombre de jobs.

Voir la solution

time parallel -j 2 sleep 1 ::: {1..6}

-j 2 limite à 2 jobs simultanés : 6 jobs = 3 vagues de 2, soit ≈ 3 secondes.

Exercice 5 — Conversion de fichiers. Simulez (avec echo) la conversion des images .jpg en .png. Indice : {.} donne le nom sans extension.

Voir la solution

ls ~/parallel-lab/images/*.jpg | parallel --dry-run convert {} {.}.png

{.} retire l'extension — parfait pour les conversions de format.

Niveau industrialisation

Exercice 6 — Fichiers avec espaces. Listez tous les .jpg du lab de façon sûre, y compris ceux avec des espaces. Indice : find -print0 + parallel --null.

Voir la solution

find ~/parallel-lab/images -name "*.jpg" -print0 | parallel --null echo "Fichier : {}"

-print0 et --null gèrent les espaces et caractères spéciaux.

Exercice 7 — Multi-colonnes CSV. À partir de batch.csv, simulez des copies source → destination. Indice : --colsep et {1}, {2}.

Voir la solution

parallel --colsep ',' --dry-run cp {1} {2} :::: ~/parallel-lab/data/batch.csv

--colsep définit le séparateur ; {1} et {2} référencent les colonnes.

Niveau sécurité

Exercice 8 — Gestion des erreurs. Lancez des commandes avec arrêt à la première erreur. Indice : --halt now,fail=1.

Voir la solution

parallel --halt now,fail=1 'if [ {} = 3 ]; then exit 1; fi; echo {}' ::: {1..5}

--halt now,fail=1 arrête tout dès qu'un job renvoie un code d'erreur.

Dépannage

Quand parallel se comporte mal, isolez la cause avec ces quatre vérifications avant tout.

Méthodes de diagnostic

# Voir les commandes sans les exécuter
parallel --dry-run commande ::: arguments

# Afficher chaque commande avant exécution
parallel --verbose commande ::: arguments

# Remplacer la commande par echo pour observer
parallel echo "Je ferais : cmd {}" ::: args

# Exécuter séquentiellement pour isoler un problème
parallel -j 1 commande ::: arguments

Erreurs fréquentes

Message d'erreur	Cause probable	Solution
Warning: Input is read from the terminal	Aucune entrée (ni ::: ni pipe)	Ajouter ::: avec des arguments, ou un pipe
command not found	Commande absente du PATH	Vérifier avec which, ou utiliser un chemin absolu
Permission denied	Script non exécutable, droits insuffisants	chmod +x sur le script, vérifier les droits
ssh: Connection timed out	Serveur injoignable ou pare-feu	Tester ssh serveur echo OK, vérifier le réseau

Glissez pour voir

Aide-mémoire parallel

Syntaxe générale

Forme	Rôle	Exemple
parallel commande ::: arg1 arg2	Arguments en ligne de commande	parallel gzip ::: *.log
cat liste | parallel commande {}	Arguments depuis stdin	find . | parallel echo {}
parallel commande :::: fichier.txt	Arguments depuis un fichier	parallel wget :::: urls.txt
parallel --colsep "," cmd {1} {2} :::: data.csv	Arguments multi-colonnes	parallel --colsep "," cp {1} {2} :::: batch.csv

Glissez pour voir

Options principales

Option	Rôle	Exemple
-j N	N jobs en parallèle (défaut : nb CPU)	parallel -j 4 gzip ::: *.log
--dry-run	Affiche sans exécuter	parallel --dry-run rm ::: *.bak
--verbose	Affiche chaque commande	parallel --verbose cmd ::: args
-k (--keep-order)	Préserve l'ordre des sorties	parallel -k echo ::: 1 2 3
--bar	Barre de progression	parallel --bar cmd ::: {1..100}
--eta	Temps restant estimé	parallel --eta cmd ::: args
--halt now,fail=1	Stoppe à la première erreur	parallel --halt now,fail=1 cmd ::: args
--null	Entrées séparées par un caractère nul	find -print0 | parallel --null cmd

Glissez pour voir

Placeholders

Placeholder	Rôle	Exemple
{}	Argument complet	echo {}
{.}	Sans extension	convert {} {.}.png
{/}	Nom de base (sans chemin)	echo {/}
{//}	Chemin du répertoire	mkdir -p {//}/out
{/.}	Nom de base sans extension	echo {/.}
{#}	Numéro du job	echo "Job {#} : {}"
{1}, {2}	Colonnes (avec --colsep)	cp {1} {2}

Glissez pour voir

Checklist de maîtrise

Vous maîtrisez parallel lorsque vous pouvez cocher chacun de ces points :

• Je sais utiliser ::: pour passer des arguments
• Je sais tester avec --dry-run avant d'exécuter
• Je sais limiter les jobs avec -j
• Je sais utiliser {} et {.} pour les placeholders
• Je sais gérer les fichiers avec espaces grâce à --null
• Je sais traiter un fichier CSV multi-colonnes avec --colsep
• Je sais gérer les erreurs avec --halt
• Je sais afficher la progression avec --bar et --eta

Cas d'usage avancés

Conversion de fichiers en masse

# Convertir toutes les images en parallèle
find . -name "*.jpg" -print0 | parallel --null --bar convert {} {.}.png

# Compresser des vidéos (limiter à 2 jobs car gourmand)
parallel -j 2 --eta ffmpeg -i {} -c:v libx264 {.}.mp4 ::: *.avi

Téléchargements parallèles

# Télécharger une liste d'URLs
parallel --bar wget :::: urls.txt

# Avec limite de bande passante par job
parallel -j 4 wget --limit-rate=1M {} :::: urls.txt

Exécution sur serveurs distants

# Lancer une commande sur plusieurs serveurs
parallel -S srv1,srv2,srv3 hostname

# Copier un fichier vers tous les serveurs
parallel -S srv1,srv2,srv3 --transferfile {} echo "Copié: {}" ::: config.yml

Prérequis : SSH sans mot de passe configuré (ssh-copy-id).

Traitement de fichiers CSV

# Fichier batch.csv : source,destination
# fichier1.txt,/backup/fichier1.txt
# fichier2.txt,/backup/fichier2.txt

parallel --colsep ',' cp {1} {2} :::: batch.csv

parallel vs xargs : quand choisir lequel ?

Critère	parallel	xargs
Parallélisme natif	✅ Optimisé	⚠️ Limité (-P)
Barre de progression	✅ --bar, --eta	❌ Non
Gestion des erreurs	✅ --halt	❌ Basique
Placeholders	✅ {}, {.}, {/}, {#}	⚠️ {} seulement
Serveurs distants	✅ -S	❌ Non
Disponibilité	⚠️ À installer	✅ Préinstallé
Complexité	⚠️ Plus d'options	✅ Plus simple

Glissez pour voir

En résumé :

• xargs pour les cas simples où la commande est préinstallée
• parallel dès que vous avez besoin de performance, progression ou robustesse

À retenir

1. ::: passe des arguments inline, :::: lit depuis un fichier
2. {} = argument complet, {.} = sans extension, {/} = nom de base
3. -j N limite le parallélisme — ne pas saturer le système
4. --dry-run est OBLIGATOIRE avant toute commande destructive (rm, mv)
5. find -print0 | parallel --null = pattern sécurisé pour les fichiers
6. --bar et --eta pour surveiller la progression
7. --halt now,fail=1 pour stopper à la première erreur
8. -k préserve l'ordre des sorties si important

Prochaines étapes

Guide xargs Alternative séquentielle, souvent suffisante

Guide find Trouver les fichiers à traiter

Guide awk Transformer les données avant traitement

Cron et Crontab Planifier vos traitements parallèles

×

📖 Voir la documentation →