Maîtriser GNU Parallel : exécution parallèle en ligne de commande

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

Lab : Pratiquez parallel

🧪 Lab pratique — 15 min

📁 Prépare ton environnement

Crée des fichiers de test pour pratiquer parallel (images, logs, données).

Script de setup Copier

# 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
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 de serveurs
cat > serveurs.txt << 'EOF'
serveur1
serveur2
serveur3
EOF

# 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 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/

🧹 Nettoyage après le lab

rm -rf ~/parallel-lab

Étapes du TP

0 / 8

1

Première commande parallèle

Exécute echo sur plusieurs arguments en parallèle avec :::

Commande de départ

parallel echo ::: ??? ??? ???

Résultat attendu

Affiche un, deux, trois, quatre (ordre variable)

💡 Indice

::: sépare la commande des arguments

✅ Voir la solution

parallel echo ::: un deux trois quatre

Pourquoi ça marche : ::: passe les arguments à parallel. Chaque echo s'exécute en parallèle.

2

Utiliser le placeholder {}

Affiche "Traitement de X" pour chaque fichier image.

Commande de départ

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

Résultat attendu

Traitement de /home/.../photo_1.jpg (pour chaque fichier)

💡 Indice

{} représente l'argument courant

✅ Voir la solution

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

Pourquoi ça marche : {} est remplacé par chaque ligne de l'entrée.

3

Tester sans exécuter (--dry-run)

Vérifie les commandes de suppression qui seraient exécutées.

Commande de départ

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

Résultat attendu

Affiche rm /path/app_1.log... sans supprimer

💡 Indice

--dry-run pour simuler

✅ Voir la solution

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

Pourquoi ça marche : --dry-run montre les commandes sans les exécuter. Essentiel avant rm !

4

Limiter le parallélisme

Lance 2 jobs maximum en parallèle.

Commande de départ

parallel ??? 2 sleep 1 ::: {1..6}

Résultat attendu

6 sleep exécutés, mais 2 à la fois (≈3 secondes total)

💡 Indice

-j N pour limiter les jobs

✅ Voir la solution

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

Pourquoi ça marche : -j 2 limite à 2 jobs simultanés. Utile pour ne pas surcharger.

5

Transformer des fichiers (placeholder {.})

Simule une conversion d'images jpg vers png (affiche la commande).

Commande de départ

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

Résultat attendu

convert photo_1.jpg photo_1.png (sans extension dans la sortie)

💡 Indice

{.} = argument sans extension

✅ Voir la solution

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

Pourquoi ça marche : {.} enlève l'extension. Parfait pour les conversions.

6

Gérer les fichiers avec espaces

Traite les fichiers avec espaces dans leur nom.

Commande de départ

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

Résultat attendu

Fichier: mon fichier 1.jpg (espaces préservés)

💡 Indice

--null pour les entrées séparées par NUL

✅ Voir la solution

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

Pourquoi ça marche : -print0 + --null gèrent les noms avec espaces ou caractères spéciaux.

7

Afficher la progression

Lance des tâches avec une barre de progression.

Commande de départ

parallel ??? sleep 0.5 ::: {1..10}

Résultat attendu

Barre de progression pendant l'exécution

💡 Indice

--bar pour la barre de progression

✅ Voir la solution

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

Pourquoi ça marche : --bar affiche la progression. --eta montre le temps restant.

8

Arrêt sur erreur

Configure parallel pour s'arrêter dès la première erreur.

Commande de départ

parallel ??? 'test {} = 3 && exit 1; echo {}' ::: {1..5}

Résultat attendu

S'arrête dès que le job 3 échoue

💡 Indice

--halt now,fail=1 pour stopper sur erreur

✅ Voir la solution

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

Pourquoi ça marche : --halt now,fail=1 stoppe tout dès qu'un job retourne une erreur.

Les patterns essentiels

Ces recettes couvrent les cas d'usage les plus fréquents. Cliquez sur un pattern pour voir la formule complète et un exemple prêt à copier.

Tous Base Inter. Avancé

Exécution parallèle basique Base

Lancer la même commande sur plusieurs arguments.

parallel gzip ::: *.log

Formule parallel commande ::: arg1 arg2 arg3

Exemple

parallel gzip ::: *.log

📋

Paramètres

• commande — La commande à exécuter
• ::: — Séparateur de la liste d'arguments

Depuis l'entrée standard Base

Lire les arguments depuis un pipe.

find . -name "*.jpg" | parallel convert {} {.}.png

Formule cat liste.txt | parallel commande {}

Exemple

find . -name "*.jpg" | parallel convert {} {.}.png

📋

Paramètres

• {} — Placeholder pour l'argument courant

Limiter le parallélisme Base

Contrôler le nombre de jobs simultanés.

parallel -j 4 gzip ::: *.log

Formule parallel -j N commande ::: arguments

Exemple

parallel -j 4 gzip ::: *.log

📋

Paramètres

• -j N — Nombre maximum de jobs (défaut: nb CPU)
• -j 0 — Autant de jobs que d'arguments
• -j +0 — nb CPU jobs par machine

Mode simulation Base

Vérifier les commandes avant exécution.

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

Formule parallel --dry-run commande ::: arguments

Exemple

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

📋

Paramètres

• --dry-run — Affiche sans exécuter

Éviter si : Jamais utiliser rm sans tester d'abord avec --dry-run

Transformation de fichiers Inter.

Convertir des fichiers en changeant leur extension.

parallel ffmpeg -i {} {.}.mp3 ::: *.wav

Formule parallel commande {} {.}.new_ext ::: fichiers

Exemple

parallel ffmpeg -i {} {.}.mp3 ::: *.wav

📋

Paramètres

• {.} — Fichier sans extension
• {/} — Nom de base (sans chemin)
• {//} — Chemin du répertoire

Fichiers avec espaces (sécurisé) Inter.

Gérer les noms de fichiers avec espaces ou caractères spéciaux.

find . -name "*.jpg" -print0 | parallel --null convert {} {.}.png

Formule find . -print0 | parallel --null commande {}

Exemple

find . -name "*.jpg" -print0 | parallel --null convert {} {.}.png

📋

Paramètres

• -print0 — find sépare par NUL au lieu de \n
• --null — parallel lit les entrées NUL-terminated

Suivi de progression Inter.

Afficher l'avancement des tâches.

parallel --bar --eta gzip ::: *.log

Formule parallel --bar commande ::: arguments

Exemple

parallel --bar --eta gzip ::: *.log

📋

Paramètres

• --bar — Barre de progression visuelle
• --eta — Temps restant estimé
• --progress — Progression textuelle

Gestion des erreurs Inter.

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

parallel --halt now,fail=1 ./script.sh ::: *.txt

Formule parallel --halt now,fail=1 commande ::: arguments

Exemple

parallel --halt now,fail=1 ./script.sh ::: *.txt

📋

Paramètres

• now,fail=1 — Stoppe dès la 1ère erreur
• soon,fail=20% — Stoppe si >20% d'erreurs
• never — Continue toujours (défaut)

Arguments multi-colonnes Avancé

Utiliser plusieurs champs par ligne.

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

Formule parallel --colsep ',' commande {1} {2} :::: fichier.csv

Exemple

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

📋

Paramètres

• --colsep — Séparateur de colonnes
• {1}, {2} — Référence aux colonnes
• :::: — Lit depuis un fichier

Exécution sur serveurs distants Avancé

Distribuer les tâches sur plusieurs machines.

parallel -S srv1,srv2,srv3 hostname ::: {1..10}

Formule parallel -S serveur1,serveur2 commande ::: arguments

Exemple

parallel -S srv1,srv2,srv3 hostname ::: {1..10}

📋

Paramètres

• -S — Liste des serveurs SSH
• --sshlogin — user@host pour connexion
• --transferfile — Transfère les fichiers avant

Éviter si : Requiert SSH sans mot de passe configuré

Les pièges à éviter

Ces erreurs courantes peuvent faire perdre du temps ou causer des dégâts. Les pièges les plus critiques sont affichés en premier.

Pas de test avant rm/mv

parallel rm ::: *.bak — supprime immédiatement

Danger

Le piège : parallel rm ::: *.bak — supprime immédiatement

Symptôme : Fichiers supprimés par erreur, irréversible

Cause : Pas de vérification des commandes avant exécution

Correction : TOUJOURS utiliser --dry-run avant les commandes destructives

parallel --dry-run rm ::: *.bak  # Puis sans --dry-run

Fichiers avec espaces

ls *.jpg | parallel echo {} — échoue sur "mon fichier.jpg"

Danger

Le piège : ls *.jpg | parallel echo {} — échoue sur "mon fichier.jpg"

Symptôme : Arguments coupés au niveau des espaces

Cause : Le retour à la ligne est le séparateur par défaut

Correction : Utiliser find -print0 | parallel --null

find . -name "*.jpg" -print0 | parallel --null echo {}

Conflits d'écriture fichier

parallel "cat {} >> output.txt" ::: *.log — corruption

Danger

Le piège : parallel "cat {} >> output.txt" ::: *.log — corruption

Symptôme : Fichier de sortie corrompu, lignes mélangées

Cause : Plusieurs processus écrivent dans le même fichier

Correction : Utiliser des fichiers séparés puis fusionner

parallel "cat {} > {}.out" ::: *.log && cat *.out > output.txt

Surcharge système

parallel -j 100 gzip ::: *.log — trop de jobs

Attention

Le piège : parallel -j 100 gzip ::: *.log — trop de jobs

Symptôme : Système lent, mémoire saturée, swap intense

Cause : Trop de processus parallèles pour les ressources disponibles

Correction : Limiter avec -j (nombre de CPU ou moins)

parallel -j 4 gzip ::: *.log

Sorties entremêlées

Plusieurs jobs affichent en même temps — lignes mélangées

Attention

Le piège : Plusieurs jobs affichent en même temps — lignes mélangées

Symptôme : Lignes de sortie entrelacées, illisibles

Cause : Pas de verrouillage de la sortie entre jobs

Correction : Utiliser --group ou --line-buffer

parallel --line-buffer commande ::: args

SSH sans clé configurée

parallel -S serveur commande — demande mot de passe

Attention

Le piège : parallel -S serveur commande — demande mot de passe

Symptôme : Bloqué sur la demande de mot de passe, timeout

Cause : Authentification SSH par clé non configurée

Correction : Configurer SSH sans mot de passe (ssh-copy-id)

ssh-copy-id user@serveur  # Puis relancer parallel

Guillemets mal gérés

parallel echo "File: {}" ::: *.txt — interprétation shell

Attention

Le piège : parallel echo "File: {}" ::: *.txt — interprétation shell

Symptôme : Arguments mal passés, caractères spéciaux interprétés

Cause : Le shell interprète les guillemets avant parallel

Correction : Utiliser des guillemets simples ou échapper

parallel echo 'File: {}' ::: *.txt

Ordre des sorties non garanti

parallel echo ::: 1 2 3 4 5 — affiche dans un ordre aléatoire

Info

Le piège : parallel echo ::: 1 2 3 4 5 — affiche dans un ordre aléatoire

Symptôme : Sorties mélangées, résultats désordonnés

Cause : L'exécution parallèle ne garantit pas l'ordre

Correction : Utiliser --keep-order ou -k pour préserver l'ordre

parallel -k echo ::: 1 2 3 4 5

Exercices progressifs

Voici 8 exercices pour progresser de débutant à expert. Les solutions sont disponibles dans le Lab ci-dessus.

Niveau Fondations (1-3)

1. Premiers pas avec :::: Affiche les nombres de 1 à 5 en parallèle
2. Compression parallèle: Compresse tous les fichiers .log avec gzip
3. Mode simulation: Teste —dry-run avant de supprimer des fichiers

Niveau Composition (4-5)

4. Limiter le parallélisme: Lance 6 sleep avec seulement 2 jobs à la fois
5. Conversion de fichiers: Simule la conversion jpg → png avec {.}

Niveau Industrialisation (6-7)

6. Fichiers avec espaces: Utilise find -print0 | parallel —null
7. Multi-colonnes CSV: Traite un fichier CSV avec —colsep

Niveau Sécurité (8)

8. Gestion des erreurs: Configure —halt pour stopper à la première erreur

Dépannage

🔧 Quand ça ne marche pas

Méthodes de debug

Voir les commandes sans exécuter

Vérifier ce qui sera lancé.

parallel --dry-run commande ::: arguments

Mode verbose

Afficher chaque commande avant exécution.

parallel --verbose commande ::: arguments

Tester avec echo

Remplacer la commande par echo pour debug.

parallel echo "Je ferais: cmd {}" ::: args

Limiter à un seul job

Exécuter séquentiellement pour isoler les problèmes.

parallel -j 1 commande ::: arguments

Erreurs fréquentes

parallel: Warning: Input is read from the terminal

Causes possibles

• Pas d'entrée fournie (ni pipe, ni :::)
• parallel attend des données sur stdin

Diagnostic

1. Vérifier que ::: ou pipe est présent
2. Taper Ctrl+D pour terminer si bloqué

✅ Solution

Ajouter ::: avec arguments ou utiliser un pipe

Vérifier avec :

parallel echo ::: test

/bin/bash: commande: command not found

Causes possibles

• La commande n'existe pas ou n'est pas dans le PATH
• Chemin incorrect vers le script

Diagnostic

1. Vérifier avec which commande
2. Utiliser le chemin absolu

✅ Solution

Corriger le nom de la commande ou utiliser le chemin complet

Vérifier avec :

which commande || echo "Commande introuvable"

Permission denied

Causes possibles

• Fichier non exécutable
• Droits insuffisants sur le répertoire

Diagnostic

1. Vérifier les permissions avec ls -la
2. Tester avec un seul fichier

✅ Solution

chmod +x pour les scripts, vérifier les droits

Vérifier avec :

chmod +x script.sh && parallel ./script.sh ::: args

ssh: connect to host X: Connection timed out

Causes possibles

• Serveur injoignable
• Pare-feu bloque SSH
• Nom de serveur incorrect

Diagnostic

1. Tester avec ssh serveur hostname
2. Vérifier la connectivité réseau

✅ Solution

Vérifier le réseau et la configuration SSH

Vérifier avec :

ssh serveur echo "OK"

Cheatsheet

📋 Cheatsheet

Imprimer

📝 Syntaxe :

parallel commande ::: arg1 arg2 arg3 Arguments en ligne de commande

cat liste | parallel commande {} Arguments depuis stdin

parallel commande :::: fichier.txt Arguments depuis un fichier

parallel --colsep "," cmd {1} {2} :::: data.csv Arguments multi-colonnes

⚙️ Options

-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
--results dir/	Sauvegarde stdout/stderr	parallel --results out/ cmd ::: args
--null	Entrées séparées par NUL	find -print0 | parallel --null cmd

⚡ Actions

{}	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 (1, 2, 3...)	echo "Job {#}: {}"
{%}	Numéro du slot (worker)	echo "Slot {%}: {}"
{1}, {2}	Colonnes (avec --colsep)	cp {1} {2}

🔗 Composition

find -print0 | parallel --null	Fichiers avec espaces (sécurisé)	find . -name "*.jpg" -print0 | parallel --null convert {} {.}.png
parallel -S srv1,srv2 cmd	Exécution sur serveurs distants	parallel -S srv1,srv2 hostname ::: {1..10}
parallel "cmd1 && cmd2"	Chaîner des commandes	parallel "gzip {} && mv {}.gz backup/"

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 →