À qui s’adresse le tutoriel « Pipelines texte : cut, sort, uniq, xargs et jq » ?

Aux débutants et praticiens DevOps qui veulent une procédure concrète, avec prérequis, étapes et vérifications. Voir la page pour le niveau exact et les labs.

Faut-il un lab cloud ou une VM pour suivre linux-pipelines-texte ?

La plupart des labs tournent en Free Tier / VM locale. Suivez la section Prérequis de la page pour les outils, droits et coûts éventuels.

Pipelines texte : cut, sort, uniq, xargs et jq

À la fin de ce tutoriel, vous saurez enchaîner cut, sort, uniq, xargs linux et jq pour découper des colonnes, dédupliquer, lancer des commandes par lot et lire du JSON — labs sous /tmp, sans secrets, après grep, awk et sed.

Niveau : Intermédiaire · Temps estimé : 45–55 min · Versions testées : Ubuntu 22.04 / 24.04, Debian 12 ; notes Rocky/Alma 9 · Dernière vérification : 2026-09-11

Slug proposé : linux-pipelines-texte · Série : Linux Shell & Automation · Remplace / fusionne : N/A — création (chapitre 5)

Prérequis

Hub Linux Shell & Automation
Chapitres utiles : bash avancé, grep / ripgrep, awk pratique, sed
Bases pipes (|) déjà vues en Pipes & redirections (série Basics) — ici on enrichit avec les outils texte
Outils : cut, sort, uniq, xargs (coreutils) ; jq : sudo apt install -y jq ou sudo dnf install -y jq
Lab entièrement dans /tmp/lab-pipelines ; pas de vrais tokens / PII

Coût : 0 €. jq = paquet optionnel (fortement recommandé pour l’API / cloud).

Ce que nous allons construire

Lab CSV + logs + JSON (/tmp)
  → cut : colonnes -d -f
  → sort | uniq -c | sort -nr
  → xargs : -n -I{} · pièges espaces / -0
  → jq : ., [], select, -r
  → Pipeline ops + nettoyage

(Schéma à remplacer par une image locale Excalidraw / draw.io, alt : « Pipelines texte : cut, sort, uniq, xargs, jq ».)

Cinquième chapitre. grep/rg filtrent, awk/sed structurent ; ici vous assemblez cut/sort/uniq/xargs/jq pour l’ops (top IP, inventaire, JSON CLI). Distinct de Pipes & redirections (|, >, 2>&1) : ici les briques texte.

Étape 1 — Jeu de données lab sous `/tmp`

mkdir -p /tmp/lab-pipelines/{logs,data,json} && cd /tmp/lab-pipelines
cat > data/users.csv << 'EOF'
id,login,role,region
1,alice,admin,eu
2,bob,dev,eu
3,carol,dev,us
4,dave,ops,us
5,eve,dev,eu
6,alice,admin,eu
EOF
cat > logs/access.log << 'EOF'
203.0.113.10 200 /api
203.0.113.50 401 /login
203.0.113.50 401 /login
192.0.2.10 200 /health
203.0.113.50 500 /api
192.0.2.10 200 /health
203.0.113.10 200 /api
EOF
cat > json/services.json << 'EOF'
{
  "env": "lab",
  "services": [
    {"name": "api", "replicas": 3, "healthy": true},
    {"name": "web", "replicas": 2, "healthy": true},
    {"name": "worker", "replicas": 1, "healthy": false}
  ]
}
EOF
# Fichiers pour xargs (noms sans espace d’abord)
printf 'alpha.txtnbeta.txtngamma.txtn' > data/filelist.txt
for f in alpha.txt beta.txt gamma.txt; do echo "content $f" > "data/$f"; done
# Un nom avec espace (piège classique)
echo 'space content' > "data/report Q3.txt"
find data logs json -type f | sort

Étape 2 — cut : extraire des colonnes

cut découpe une ligne selon un délimiteur (-d) et garde des champs (-f). Idéal quand vous n’avez besoin que d’une ou deux colonnes, sans logique awk.

cd /tmp/lab-pipelines
# CSV : login et région (champs 2 et 4), sans l’en-tête
cut -d',' -f2,4 data/users.csv | tail -n +2
# Logs espace : IP seulement (champ 1)
cut -d' ' -f1 logs/access.log
# Caractères 1–3 d’une ligne (moins courant en ops)
cut -c1-3 data/users.csv | head -n 2

Option	Rôle
`-d CHAR`	Délimiteur (défaut : tabulation)
`-f N` / `-f N,M` / `-f N-M`	Champs à garder
`-c N-M`	Plage de caractères (pas de `-d`)
`--complement`	Inverse la sélection de champs (GNU)

cut vs awk : cut pour colonnes simples ; awk dès qu’il y a test/agrégat/NF. CSV quoté riche → jq / Python / csvkit, pas cut.

Étape 3 — sort et uniq : ordonner, dédupliquer, compter

sort ordonne les lignes ; uniq retire les doublons adjacents (d’où le duo classique sort | uniq). uniq -c compte ; un second sort -nr classe par fréquence.

cd /tmp/lab-pipelines
# Logins uniques
cut -d',' -f2 data/users.csv | tail -n +2 | sort | uniq
# Top des IP (fréquence)
cut -d' ' -f1 logs/access.log | sort | uniq -c | sort -nr
# Tri numérique sur une colonne (ici id CSV)
tail -n +2 data/users.csv | sort -t',' -k1,1n
# Tri stable + clé humaine
tail -n +2 data/users.csv | sort -t',' -k3,3 -k2,2

Outil / option	Rôle
`sort`	Ordonne les lignes
`sort -n` / `-h`	Numérique / « human » (Ko, Mo)
`sort -r`	Inverse
`sort -t',' -k2,2`	Clé 2, délimiteur `,`
`uniq`	Déduplique après sort
`uniq -c`	Préfixe un compteur
`uniq -d`	Affiche seulement les doublons

Étape 4 — xargs : transformer des lignes en arguments

xargs lit stdin et construit des lignes de commande. Utile après find, cut ou une liste de fichiers. Attention aux espaces dans les noms et à la taille max des arguments.

cd /tmp/lab-pipelines
# wc sur chaque fichier listé
cut -d',' -f2 data/users.csv >/dev/null  # (noop pédagogique)
xargs -a data/filelist.txt -I{} wc -c data/{}
# Équivalent plus idiomatique
cat data/filelist.txt | xargs -I{} sh -c 'wc -c "data/$1"' _ {}
# Limiter le nombre d’args par invocation
printf 'anbncndn' | xargs -n 2 echo BATCH
# find + xargs NUL-safe (recommandé)
find data -type f -print0 | xargs -0 -I{} basename {}
# Piège : sans -0, un fichier « report Q3.txt » casse le découpage
find data -name '*.txt' | xargs -I{} echo "FILE={}"

Option	Rôle
`-n N`	Au plus N args par commande
`-I{}`	Remplace le placeholder `{}` (une ligne → un run)
`-P N`	Parallelisme (GNU) — utile mais à doser
`-0`	Entrée séparée par NUL (avec `find -print0`)
`-a fichier`	Lit la liste depuis un fichier (GNU)
`-r`	Ne lance rien si stdin vide (GNU)

xargs linux : préférez find … -print0 | xargs -0 … si espaces/quotes. Alternative : find … -exec cmd {} +. Sous set -e, testez d’abord avec -n 1.

Étape 5 — jq : lire et filtrer du JSON

Les CLI cloud (AWS, kubectl, APIs) parlent JSON. jq extrait des champs sans Python.

cd /tmp/lab-pipelines
command -v jq || { echo "Installer : sudo apt install -y jq"; exit 0; }
# Racine et champ
jq '.' json/services.json
jq -r '.env' json/services.json
# Tableau services : noms
jq -r '.services[].name' json/services.json
# Filtrer unhealthy
jq -r '.services[] | select(.healthy==false) | .name' json/services.json
# Objet compact pour un script
jq -c '.services[] | {name, replicas}' json/services.json
# Depuis un pipe (simulé)
cat json/services.json | jq '.services | length'

Filtre / option	Rôle
`.`	Identité (pretty-print)
`-r`	Sortie brute (sans quotes JSON)
`.services[]`	Itère le tableau
`select(cond)`	Filtre
`-c`	Compact (une ligne)
`\|`	Enchaîne des filtres jq (dans le programme jq)

Rocky/Alma : dnf install jq. Hôte sans jq : dépannage Python ; sinon jq = réflexe DevOps.

Étape 6 — Pipeline ops complet et nettoyage

cd /tmp/lab-pipelines
# 1) Top IP des accès non-200
awk '$2!=200 {print $1}' logs/access.log | sort | uniq -c | sort -nr
# 2) Logins role=dev uniques
awk -F',' 'NR>1 && $3=="dev" {print $2}' data/users.csv | sort -u
# 3) Services down → noms (jq) puis xargs echo (placeholder d’alerte)
jq -r '.services[] | select(.healthy==false) | .name' json/services.json 
  | xargs -r -I{} echo "ALERTE: service {} unhealthy"
# 4) Inventaire tailles fichiers (NUL-safe)
find data -type f -print0 | xargs -0 ls -l | awk '{print $5, $NF}' | sort -nr
# Vérifs rapides
test "$(cut -d' ' -f1 logs/access.log | sort | uniq | wc -l)" -ge 2
jq -e '.services | length >= 1' json/services.json >/dev/null
cd /tmp
rm -rf /tmp/lab-pipelines
echo "lab pipelines texte nettoyé — OK"

Validé si : cut, top sort|uniq -c|sort -nr, xargs -0 et jq -r/select OK, lab nettoyé.

Erreurs fréquentes

Symptôme	Cause	Correction
`uniq` ne déduplique pas	Pas de `sort` avant	Toujours `sort \| uniq`
Colonnes décalées avec cut	Mauvais `-d`	Vérifier séparateur réel (`cat -A`)
xargs casse sur « report Q3.txt »	Découpe sur espaces	`find -print0 \| xargs -0`
`jq: command not found`	Paquet absent	`apt/dnf install jq`
jq affiche des quotes	Oubli `-r`	`jq -r` pour scripts
Trop d’args « Argument list too long »	Liste énorme	`xargs -n`, ou `find -exec … +`
Confusion avec pipes Basics	Attendu `2>&1` ici	Voir pipes-redirections ; ici outils texte

Flux mental : filtrer → découper → trier/compter → xargs → jq.

Quiz (3 questions)

1. Pourquoi sort avant uniq ?
– A. Pour compresser le disque
– B. Parce que uniq ne retire que les doublons adjacents
– C. Obligatoire pour cut

2. Quelle combinaison est la plus sûre avec des noms de fichiers à espaces ?
– A. find … | xargs rm
– B. find … -print0 | xargs -0 …
– C. cut -d' ' -f1

3. Que fait jq -r '.services[] | select(.healthy==false) | .name' ?
– A. Supprime les services
– B. Affiche en brut les noms des services non healthy
– C. Installe jq

Réponses : 1‑B · 2‑B · 3‑B

FAQ

cut ou awk ? cut si délimiteur stable ; awk pour condition/NF (awk pratique).

xargs ou find -exec ? -exec … {} + suffit souvent. xargs quand la liste vient d’un pipe (jq -r, cut, API) — avec fichiers : -print0 / -0.

jq obligatoire ? Pour JSON cloud/K8s, oui en pratique. Sinon Python en dépannage ; installez jq sur bastions et CI.

Pour aller plus loin

man cut, man sort, man xargs, jq --help / stedolan.github.io/jq
Suite : systemd timers : remplacer cron proprement
Hub : Linux Shell & Automation

Maillage série Linux Shell & Automation


← Précédent	sed : éditer fichiers et flux en place
→ Suivant	systemd timers : remplacer cron proprement
Hub	Linux Shell & Automation

Meta publication (à remplir dans Rank Math / SEO)

Title SEO : Pipelines texte : cut, sort, uniq, xargs et jq (2026)
Meta description (≤ 155) : Maîtrisez cut, sort, uniq, xargs et jq en pipelines texte. Guide Shell Automation DevOps 2026.
Focus keyphrase : xargs linux
KW secondaires : jq, sort uniq, cut, pipelines texte
Schemas Rank Math : Article + HowTo (étapes lab) + FAQ (3 questions ci-dessus)
Image mise en avant : assets/web/devopelastichayway/cover-linux-pipelines-texte-1200x630.webp (Visuels Linux — WebP 1200×630)
Catégorie : Linux · Niveau : Intermédiaire
Slug : linux-pipelines-texte
Statut : HOLD — draft only (ne pas publier)

← Retour parcours Linux — Basics, Admin, Réseau & Sécurité, Shell & Automation.

#Tags