À qui s’adresse le tutoriel « jq et yq : JSON et YAML en ligne de commande » ?

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-jq-yq ?

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.

jq et yq : JSON et YAML en ligne de commande

À la fin de ce tutoriel jq yq, vous saurez interroger et transformer du JSON avec jq (filtres ., select, map, |, -r, -c, --arg, keys, length, if) et lire/écrire du YAML avec yq (mikefarah v4), y compris les conversions YAML↔JSON — labs factices API/K8s-like sous /tmp/lab-jq-yq, sans secrets.

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-jq-yq · Série : Linux Shell & Automation · Remplace / fusionne : N/A — création (backlog lot 2)

Prérequis

Hub Linux Shell & Automation
awk pratique, grep / ripgrep, bash avancé (set -euo pipefail, guillemets)
jq : sudo apt install -y jq ou sudo dnf install -y jq — vérifier : jq --version
yq (mikefarah v4, pas le paquet Python yq de kislyuk) : voir installation ci-dessous
Lab entièrement dans /tmp/lab-jq-yq ; aucun token, mot de passe ou kubeconfig réel

Coût : 0 €. Sur Rocky/Alma 9, jq via dnf ; pour yq, binaire GitHub Releases ou go install selon votre politique paquets.

Installer yq mikefarah v4

# Exemple Ubuntu/Debian — binaire officiel (vérifiez la version sur GitHub Releases)
YQ_VER=v4.44.3
curl -fsSL -o /tmp/yq 
  "https://github.com/mikefarah/yq/releases/download/${YQ_VER}/yq_linux_amd64"
sudo install -m 0755 /tmp/yq /usr/local/bin/yq
yq --version   # doit afficher mikefarah/yq ... version v4.x

Attention : pip install yq installe souvent un wrapper différent (kislyuk) qui n’accepte pas la même syntaxe. Ce tuto cible uniquement mikefarah v4 (yq eval / yq -o=json).

Ce que nous allons construire

/tmp/lab-jq-yq
  ├── api-response.json     (API factice)
  ├── pods-like.json        (liste K8s-like)
  ├── values.yaml           (Helm-like)
  └── compose.yaml          (services)
       → jq : ., .key, .[], select, map, |, -r -c --arg, keys, length, if
       → yq : lire / écrire YAML · YAML↔JSON
       → Tableau jq vs yq vs awk · quiz · FAQ

(Schéma à remplacer par une image locale Excalidraw / draw.io, alt : « jq et yq : JSON API, YAML values, filtres select map, conversion YAML JSON ».)

Chapitre backlog lot 2 : après grep/awk (texte plat), on traite JSON/YAML — APIs, manifests, values. Objectif : one-liners fiables en SSH et scripts bash défensifs.

Étape 1 — Lab : JSON API/K8s-like et YAML

mkdir -p /tmp/lab-jq-yq && cd /tmp/lab-jq-yq

cat > api-response.json << 'EOF'
{
  "request_id": "req-lab-001",
  "env": "lab",
  "items": [
    {"name": "api", "replicas": 3, "status": "Ready", "cpu_m": 120},
    {"name": "web", "replicas": 2, "status": "Ready", "cpu_m": 80},
    {"name": "worker", "replicas": 1, "status": "Pending", "cpu_m": 40}
  ],
  "meta": {"region": "eu-lab", "version": "1.2.0"}
}
EOF

cat > pods-like.json << 'EOF'
{
  "items": [
    {"metadata": {"name": "api-0", "namespace": "demo"}, "status": {"phase": "Running"}},
    {"metadata": {"name": "web-0", "namespace": "demo"}, "status": {"phase": "Running"}},
    {"metadata": {"name": "worker-0", "namespace": "demo"}, "status": {"phase": "Pending"}}
  ]
}
EOF

cat > values.yaml << 'EOF'
replicaCount: 2
image:
  repository: ghcr.io/example/app
  tag: "1.2.0"
service:
  type: ClusterIP
  port: 8080
env: lab
EOF

cat > compose.yaml << 'EOF'
services:
  api:
    image: ghcr.io/example/api:1.2.0
    ports:
      - "8080:8080"
  web:
    image: ghcr.io/example/web:1.2.0
    ports:
      - "3000:3000"
EOF

jq empty api-response.json && yq empty values.yaml && echo "lab OK"

Étape 2 — jq : identité, clés et tableaux

Le filtre . est l’identité (pretty-print). .clé descend dans un objet ; .[] itère un tableau ; | enchaîne des filtres.

cd /tmp/lab-jq-yq
# Pretty-print / identité
jq '.' api-response.json | head -n 8
# Clés de premier niveau
jq 'keys' api-response.json
# Champ simple + raw (-r) sans guillemets JSON
jq -r '.env' api-response.json
# Descendre : région
jq -r '.meta.region' api-response.json
# Itérer le tableau items : noms
jq -r '.items[].name' api-response.json
# Compact (-c) : une ligne (pratique pour logs / xargs)
jq -c '.items[]' api-response.json

Filtre / option	Rôle
`.`	Identité / pretty-print
`.key` / `.meta.region`	Accès objet
`.[]` / `.items[]`	Itérer un tableau
`\|`	Pipeline de filtres
`-r`	Sortie raw (strings sans `"`)
`-c`	Sortie compacte (une ligne)
`keys`	Liste des clés d’un objet
`length`	Longueur tableau / objet / string

Étape 3 — jq : `select`, `map`, `length`, `if`, `--arg`

cd /tmp/lab-jq-yq
# Filtrer : services Ready
jq '.items[] | select(.status == "Ready") | .name' api-response.json
# map : transformer tout le tableau
jq '[.items[] | {name, replicas}]' api-response.json
# Compter
jq '.items | length' api-response.json
# if / then / else
jq -r '.items[] | if .status == "Ready" then .name + "=ok" else .name + "=wait" end' 
  api-response.json
# --arg : injecter une variable shell sans casser le JSON
TARGET=worker
jq -r --arg n "$TARGET" '.items[] | select(.name == $n) | .status' api-response.json
# K8s-like : phases Pending
jq -r '.items[] | select(.status.phase == "Pending") | .metadata.name' pods-like.json

Astuce : sous set -e, une sortie vide jq reste souvent exit 0 ; utilisez jq -e si false/null doivent échouer.

Étape 4 — yq : lire et écrire du YAML

yq mikefarah reprend une syntaxe proche de jq. Lecture, écriture in-place (-i), et conversion de formats.

cd /tmp/lab-jq-yq
# Lire des champs
yq '.image.tag' values.yaml
yq '.service.port' values.yaml
yq '.services | keys' compose.yaml

# Écrire : changer le tag (copie de travail)
cp values.yaml values-edit.yaml
yq -i '.image.tag = "1.3.0"' values-edit.yaml
yq -i '.replicaCount = 3' values-edit.yaml
yq '.' values-edit.yaml

# Ajouter une clé
yq -i '.resources.limits.cpu = "500m"' values-edit.yaml
yq '.resources' values-edit.yaml

Opération	Exemple yq v4
Lire	`yq '.image.tag' values.yaml`
Écrire in-place	`yq -i '.image.tag = "1.3.0"' f.yaml`
Clés	`yq '.services \| keys' compose.yaml`
Nouveau fichier	`yq -n '.env = "lab"' > new.yaml`

Travaillez sur une copie (values-edit.yaml) avant -i sur un fichier versionné.

Étape 5 — YAML ↔ JSON et pipelines mixtes

cd /tmp/lab-jq-yq
# YAML → JSON
yq -o=json '.' values.yaml > values.json
jq -r '.image.repository' values.json

# JSON → YAML
yq -P -o=yaml '.' api-response.json > api-from-json.yaml
head -n 12 api-from-json.yaml

# Pipeline : yq extrait, jq filtre
yq -o=json '.services' compose.yaml | jq -r 'keys[]'

# jq → yq : préparer un fragment YAML depuis JSON
jq -c '{name: .items[0].name, replicas: .items[0].replicas}' api-response.json 
  | yq -p=json -o=yaml '.'

Tableau comparatif : jq vs yq vs awk

Besoin	Outil	Pourquoi
JSON structuré (API, kube -o json)	jq	Filtres dédiés, `select`/`map`, perf one-liner
YAML (values Helm, compose, manifests)	yq (mikefarah)	Préserve YAML ; syntaxe jq-like
Colonnes texte / CSV / logs plats	awk	Champs `$1`…`$NF`, agrégats `BEGIN`/`END`
Recherche de motif dans fichiers	grep / rg	Avant de parser : réduire le bruit
CSV quoté très riche	Python / csvkit	Au-delà de awk/cut naïfs

Règle : colonnes → awk ; JSON → jq ; YAML → yq. Évitez grep/sed sur du JSON en prod.

Étape 6 — Mini script ops + nettoyage

cd /tmp/lab-jq-yq
cat > summarize.sh << 'EOF'
#!/usr/bin/env bash
set -euo pipefail
ROOT="$(cd "$(dirname "$0")" && pwd)"
echo "== services Ready =="
jq -r '.items[] | select(.status=="Ready") | "(.name)treplicas=(.replicas)"' 
  "$ROOT/api-response.json"
echo "== image tag (values) =="
yq -r '.image.tag' "$ROOT/values.yaml"
EOF
chmod +x summarize.sh
./summarize.sh

cd /tmp
rm -rf /tmp/lab-jq-yq
echo "lab jq/yq nettoyé — OK"

Validé si : .meta.region, .items[].name, select, --arg, lecture/écriture yq v4, et YAML↔JSON sans erreur.

Erreurs fréquentes

Symptôme	Cause	Correction
`yq` ne comprend pas `.image.tag`	Mauvais yq (kislyuk / v3)	mikefarah v4 : `yq --version`
Guillemets cassés dans le shell	Filtre jq en double quotes	Préférez `'…'` ; `--arg` pour les vars
`null` partout	Chemin incorrect (typo clé)	`jq 'keys'` / `jq 'paths'` pour explorer
Sortie avec `"Ready"` dans un script	Oubli de `-r`	`jq -r` pour raw
YAML écrasé	`-i` trop vite	Copie `*.edit.yaml` d’abord
`jq: parse error`	JSON invalide / trailing comma	`jq empty fichier.json` comme smoke test
Confusion awk vs jq	Logs plats traités comme JSON	awk pour colonnes ; jq seulement si JSON valide

Quiz (4 questions)

1. Que fait jq -r '.env' fichier.json ?
– A. Compresse le fichier
– B. Affiche la valeur de env sans guillemets JSON
– C. Convertit en YAML

2. Quelle commande filtre les éléments Ready ?
– A. jq '.items[] | select(.status == "Ready")'
– B. awk '/Ready/' uniquement (sur du JSON pretty) — fragile
– C. chmod +x

3. Comment convertir values.yaml en JSON avec yq v4 ?
– A. yq -o=json '.' values.yaml
– B. jq values.yaml
– C. cat values.yaml | gzip

4. Pourquoi --arg n "$TARGET" ?
– A. Pour installer jq
– B. Pour injecter une variable shell dans le programme jq sans casser le JSON
– C. Pour activer -i

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

FAQ

jq ou Python pour une API JSON ?
Pour extraire 1–3 champs, filtrer et compter en SSH : jq. Dès que la logique dépasse quelques pipelines (select/map), un petit script Python peut être plus lisible — mais gardez jq dans la boîte à outils ops.

yq mikefarah ou yq kislyuk ?
Ce site et ce lab standardisent mikefarah v4. Vérifiez toujours yq --version. Les deux coexistent parfois sur une même machine via $PATH : piège classique en CI.

Puis-je remplacer awk par jq ?
Non pour des logs texte espace-séparés. jq exige du JSON valide. Enchaînez plutôt : rg → awk (texte) ou jq/yq (structures). Voir awk pratique et pipelines texte.

Pour aller plus loin

Docs : jqlang.org · mikefarah/yq
Hub : Linux Shell & Automation
Voisins : awk pratique · grep/ripgrep · bash avancé · pipelines texte · scripts ops

Maillage série Linux Shell & Automation


← Précédent (lot 1)	awk pratique : colonnes, agrégats et rapports
→ Suite lot 2	Pipelines texte · Scripts ops
Hub	Linux Shell & Automation

Meta publication (à remplir dans Rank Math / SEO)

Title SEO : jq et yq : JSON et YAML en ligne de commande (2026)
Meta description (≤ 155) : Manipulez JSON et YAML avec jq et yq (mikefarah). Guide Shell Automation DevOps 2026.
Focus keyphrase : jq yq
KW secondaires : jq tutoriel, yq yaml, jq select map, yaml to json, linux jq
Schemas Rank Math : Article + HowTo (étapes lab) + FAQ (3 questions ci-dessus)
Image mise en avant : assets/web/devopelastichayway/cover-linux-jq-yq-1200x630.webp (Visuels Linux — WebP 1200×630)
Catégorie : Linux · Niveau : Intermédiaire
Slug : linux-jq-yq
Statut : HOLD — draft only (ne pas publier)

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

#Tags