Ce guide fait partie de la formation jiha.techDécouvrir le parcours →
Débutant· 90 min

L'Art de la ligne de commande

Bouger, inspecter, manipuler du texte, investiguer.

§ 01 Introduction

Le repo jlevy/the-art-of-command-line est une mine d'or : environ 150 astuces concentrées, validées par des milliers de pros. Mais c'est aussi un mur de texte sans parcours. Si tu débutes, tu ouvres la page, tu vois 200+ commandes balancées d'un coup, tu refermes l'onglet. Dommage : le contenu est excellent.

Ce guide te donne un parcours. Tu ne liras pas tout — tu liras le bon ordre, à la bonne dose, avec des objectifs vérifiables, en 4 paliers : survivre, naviguer, comprendre, investiguer.

Pour qui c'est : quelqu'un qui va passer le reste de sa vie à taper des commandes (ops, sysadmin, dev backend, homelabber) et veut poser les fondations sans douleur. C'est le niveau 0 du parcours : tout le reste (Docker, Git, SSH avancé) part d'ici.

Quand ce n'est PAS le bon choix :

  • Tu cherches un cours pas-à-pas façon vidéo YouTube — préfère « Linux Journey » ou une chaîne vidéo dédiée.
  • Tu veux apprendre le Bash scripting en profondeur — ce guide effleure, il ne plonge pas.
  • Tu es déjà confortable en CLI depuis 5+ ans — tu n'apprendras quasi rien ici.

Si l'un des trois te concerne, passe ton chemin sans culpabiliser : ce guide n'est pas fait pour toi, et c'est très bien.

§ 02 Ce que tu vas apprendre

À la fin de ce parcours, tu sauras :

  • Naviguer dans un système Linux sans souris (et plus vite qu'avec).
  • Inspecter un fichier, un process, un disque, une connexion réseau.
  • Combiner des commandes via pipes (|) — la vraie philosophie Unix.
  • Manipuler du texte comme un pro (grep, sed, awk au niveau utile).
  • Gérer les permissions sans faire de chmod 777 partout (anti-pattern n°1).
  • Connaître les bases pour la suite : redirections, codes de sortie, processus, variables d'environnement, expansion shell.

§ 03 Prérequis

Tu dois avoir :

  • Un terminal accessible : Linux natif, macOS, ou WSL2 sur Windows. Si tu n'en as pas → installe Ubuntu via WSL2 (10 minutes, Microsoft Store).
  • Un éditeur texte que tu sais ouvrir et fermer — nano suffit, il est installé partout, on commencera avec ça.
  • Une heure libre pour démarrer, et la patience d'expérimenter.

Pourquoi pas de prérequis technique fort ? Ce guide est le niveau 0 de ton parcours. Tout part d'ici — aucun autre guide n'est requis avant.

§ 04 Concepts

Le shell repose sur une idée simple et géniale : tout est flux de texte. Chaque commande lit une entrée (stdin), écrit une sortie (stdout), et signale ses erreurs sur un canal séparé (stderr). Comme ces flux sont standardisés, tu peux brancher la sortie d'une commande sur l'entrée de la suivante avec un pipe (|), ou la détourner vers un fichier avec une redirection (>, >>, 2>).

C'est la philosophie Unix : des petits outils qui font une seule chose bien, que tu composes en pipelines.

Anatomie d'un pipeline shell / Anatomy of a shell pipeline — stdin → commandes → stdout Anatomie d'un pipeline shell Anatomy of a shell pipeline stdin clavier / fichier keyboard / file cat access.log producteur de texte text producer grep "error" filtre les lignes filters the lines awk '{print $1}' extrait la colonne 1 extracts column 1 | | stdout > stderr terminal affichage par défaut default display result.txt > écrase · >> ajoute > overwrite · >> append 2> erreurs.log erreurs : écran, ou redirigées errors: screen, or redirected Chaque | branche le stdout d'une commande sur le stdin de la suivante. Each | plugs one command's stdout into the next command's stdin. Le pipe ne transporte que stdout — stderr suit son propre chemin. The pipe only carries stdout — stderr takes its own path.
Schéma 1. Anatomie d'un pipeline shell : stdin → commandes → stdout, redirections et pipes.

Points clés à retenir :

  • stdin / stdout / stderr : trois flux par commande. Le pipe ne transmet que stdout ; stderr continue vers ton écran (sauf si tu le rediriges avec 2>).
  • > écrase, >> ajoute. Confondre les deux vide un fichier — on y revient dans les pièges.
  • Code de sortie : chaque commande se termine avec un nombre (0 = succès, autre = erreur). echo $? l'affiche ; && et || s'en servent pour enchaîner.
  • L'expansion shell (*, {1..10}, $VAR) est faite par le shell avant de lancer la commande — la commande ne voit jamais le *, elle reçoit la liste des fichiers.
  • Le parcours : le repo est découpé en sections (Basics, Everyday use, Processing files and data, System debugging…). On ne le lit pas dans l'ordre — on suit 4 paliers, chacun débloquant le suivant. À chaque palier : lire la section, tester chaque commande dans ton terminal, faire le mini-défi.

§ 05 Pas-à-pas

step-01

Objectif. Palier 1 — Survivre. Lis la section « Basics » du repo en testant chaque commande dans ton terminal.

🤔 Pourquoi ? Tu sors d'ici avec l'essentiel vital : savoir où tu es (pwd), bouger (cd), voir (ls), créer/supprimer (mkdir, touch, rm), lire (cat, less), copier/déplacer (cp, mv). C'est 20 % des commandes que tu utiliseras 80 % du temps.

Mini-défi (sans regarder la doc) : crée un dossier ~/playground et va dedans ; crée 3 fichiers vides a.txt, b.txt, c.txt ; copie a.txt en a-copie.txt ; renomme b.txt en important.txt ; supprime c.txt ; liste le contenu avec les détails (taille, dates, permissions).

⚠️ rm supprime définitivement — pas de corbeille en CLI. Ici on ne touche qu'à des fichiers vides créés dans ~/playground, c'est le but de ce bac à sable.

Solution (à ne regarder qu'après avoir essayé) :

shell
mkdir -p ~/playground && cd ~/playground
touch a.txt b.txt c.txt
cp a.txt a-copie.txt
mv b.txt important.txt
rm c.txt            # suppression définitive / permanent deletion
ls -la

✅ Vérification : tu réussis les 6 actions en moins de 2 minutes, sans Google. ls -la montre a.txt, a-copie.txt, important.txt — et plus de c.txt. Palier validé.

step-02

Objectif. Palier 2 — Naviguer. Lis la section « Everyday use » du repo, en te concentrant sur quatre sujets : l'historique (↑, !!, !$, Ctrl-R), le globbing (*, ?, [abc], {a,b,c}), les raccourcis clavier (Ctrl-A, Ctrl-E, Ctrl-W, Ctrl-U), et les redirections (>, >>, 2>, 2>&1, |).

🤔 Pourquoi ces 4 sujets en priorité ?

  • L'historique te fait taper 10× moins.
  • Le globbing te fait traiter 100 fichiers comme 1.
  • Les raccourcis te font éditer ta ligne sans souris ni flèches.
  • Les redirections t'ouvrent la philosophie Unix : composer des petits outils.

Mini-défi : liste tous les fichiers .log de /var/log/ en redirigeant les erreurs de permission vers /dev/null ; affiche les 5 dernières lignes de ton historique ; crée 10 fichiers test1.txt à test10.txt en une seule commande ; retrouve une commande tapée plus tôt avec Ctrl-R.

Solution :

shell
ls /var/log/*.log 2>/dev/null
tail -n 5 ~/.bash_history
cd ~/playground && touch test{1..10}.txt
# Ctrl-R puis tape un fragment / then type a fragment, Enter pour exécuter / to run

✅ Vérification : le ls n'affiche aucune erreur « Permission denied » (elles partent dans /dev/null), ls test*.txt montre exactement 10 fichiers, et Ctrl-R te retrouve une vieille commande en 3 frappes.

step-03

Objectif. Palier 3 — Comprendre (texte + données). Lis « Processing files and data » puis « One-liners ».

🤔 Pourquoi ce palier change ta vie ? La majorité du travail en ops/dev consiste à fouiller dans des logs, des fichiers de config, du JSON, du CSV. Sans grep/sed/awk/jq, tu fais ça à la main = tu meurs. Avec ces outils, ce qui prendrait 2 h prend 30 secondes.

Focalise sur : grep (recherche + regex de base), sed (juste s/old/new/g et -i), awk (juste awk '{print $N}' et les filtres simples), le pattern « top N » sort | uniq -c | sort -rn, et jq (parser du JSON).

Mini-défi : combien de lignes de /etc/passwd contiennent bash ? Affiche uniquement le nom d'utilisateur (1ʳᵉ colonne) de chaque ligne. Quels sont les 5 shells les plus utilisés sur ton système (dernière colonne) ? Bonus : récupère le profil GitHub de Torvalds via curl et extrais le champ public_repos avec jq.

Solution :

shell
grep -c bash /etc/passwd
awk -F: '{print $1}' /etc/passwd
awk -F: '{print $NF}' /etc/passwd | sort | uniq -c | sort -rn | head -5
curl -s https://api.github.com/users/torvalds | jq .public_repos

✅ Vérification : chaque one-liner rend un résultat plausible (des nombres, des noms d'utilisateurs, un classement de shells), et surtout : tu sais expliquer chaque segment du pipeline sort | uniq -c | sort -rn | head -5 à voix haute. Si jq manque : sudo apt install jq (Debian/Ubuntu).

step-04

Objectif. Palier 4 — Investiguer. Lis « System debugging ».

🤔 Pourquoi c'est essentiel pour la suite ? Tous les guides self-hosting de cette plateforme te feront installer des services qui parfois cassent. Savoir investiguer (ps, top/htop, df, du, lsof, journalctl, dmesg) c'est la différence entre « ça marche pas, j'abandonne » et « OK, je vois ce qui se passe ».

Mini-défi : quel process consomme le plus de RAM sur ta machine ? Quel pourcentage de ton disque / est utilisé ? Quel est le dossier le plus volumineux dans ton $HOME ? Quel port utilise le service SSH ?

Solution :

shell
ps aux --sort=-%mem | head -5
df -h /
du -sh ~/*/ 2>/dev/null | sort -rh | head -1
sudo ss -tlnp | grep sshd    # ou / or: grep -i port /etc/ssh/sshd_config

✅ Vérification : tu réponds aux 4 questions avec des valeurs concrètes (un nom de process, un pourcentage, un dossier, un numéro de port — 22 par défaut). Bonus : tu comprends pourquoi le 2>/dev/null évite le bruit des dossiers non lisibles.

§ 06 Pièges connus

1. Le « fear of the unknown » qui te fait copier-coller sans comprendre. La pire habitude possible. Avant d'exécuter une commande trouvée sur Stack Overflow, surtout avec sudo, lis chaque flag. man <commande> est ton ami. tldr <commande> aussi (plus court).

2. chmod 777 « pour que ça marche ». Anti-pattern n°1 des débutants. Donner tous les droits à tout le monde résout 0 problème et en crée 10. Apprends la triade u/g/o + rwx. C'est 10 minutes d'investissement.

3. rm -rf mal placé. ⚠️ Commande destructive, irréversible. Tape toujours pwd avant un rm -rf, et méfie-toi des variables vides : Steam Linux, en 2015, a exécuté rm -rf "$STEAMROOT/"* avec STEAMROOT vide → effacement de la home complète d'utilisateurs.

4. Confondre > et >>. > écrase, >> ajoute à la fin. Faire > sur un fichier de config existant le vide. Toujours vérifier avant.

5. Coller du texte multiligne contenant des retours à la ligne. Le shell interprète chaque newline comme un « Entrée ». Si tu copies 5 lignes depuis un site web et que l'une contient un rm -rf / déguisé, elle s'exécute avant que tu puisses paniquer. Habitude pro : coller dans un éditeur d'abord, lire, puis exécuter ligne par ligne.

§ 07 Tu sais que c'est bon quand…

Tu sais que c'est bon quand…

  • Tu ouvres un terminal sans réfléchir, comme tu ouvres un navigateur.
  • Tu utilises Ctrl-R plus souvent que la flèche du haut.
  • Tu sais ce que fait cat file.txt | grep error | wc -l rien qu'en le lisant.
  • Tu lis man <cmd> au lieu de Googler à chaque doute.
  • Tu as un ~/.bashrc (ou .zshrc) personnalisé avec 2-3 alias à toi.

Si les 5 sont cochés, tu es prêt pour Docker, Git, SSH avancé, et tout le reste.

§ 08 Et après ?

Quatre prolongements naturels, du plus urgent au plus confort :

  1. Git fondamentaux — versionning, branches, collaboration : la suite officielle de ce guide.
  2. SSH & serveurs distants — se connecter, copier (scp, rsync), travailler à distance.
  3. Bash scripting — écrire tes premiers scripts utiles (sauvegarde, alerting, batch).
  4. tmux — sessions terminal persistantes, indispensable dès que tu bosses en SSH.

§ 09 Aide-mémoire

Aide-mémoire des commandes et raccourcis clés du parcours.

shell
# Bouger & voir / Move & see
pwd                         # où suis-je / where am I
cd <dir> ; cd - ; cd        # aller / revenir / home
ls -la                      # tout, avec détails / everything, detailed

# Créer, copier, supprimer / Create, copy, delete
mkdir -p a/b/c              # dossiers imbriqués / nested dirs
cp src dst ; mv src dst     # copier / déplacer-renommer
rm fichier                  # ⚠️ définitif / permanent — pwd d'abord / pwd first

# Lire / Read
cat f ; less f ; head -n 20 f ; tail -f f

# Historique & édition / History & editing
Ctrl-R                      # recherche dans l'historique / history search
!! ; !$                     # dernière commande / dernier argument — last cmd / last arg
Ctrl-A / Ctrl-E / Ctrl-W / Ctrl-U

# Redirections & pipes
cmd > f                     # écrase / overwrite
cmd >> f                    # ajoute / append
cmd 2> f ; cmd 2>&1         # stderr
cmd1 | cmd2                 # pipe

# Texte / Text
grep -rn "motif" .          # chercher / search
sed 's/old/new/g' f         # remplacer / replace
awk -F: '{print $1}' f      # colonne / column
sort | uniq -c | sort -rn | head -5   # top N

# Investiguer / Investigate
ps aux --sort=-%mem | head  # RAM
df -h ; du -sh */           # disque / disk
ss -tlnp                    # ports ouverts / open ports
echo $?                     # code de sortie / exit code

§ 10 Ressources

§ 11 Dépannage

« Permission denied » sur quasi tout. Tu touches probablement un fichier qui ne t'appartient pas. Tape ls -la pour voir les permissions. Soit le fichier est à toi (modifie les perms avec chmod), soit c'est un fichier système (utilise sudo — en comprenant ce que tu fais).

« Command not found » sur une commande « standard ». Soit le paquet n'est pas installé (sudo apt install <paquet> sur Debian/Ubuntu), soit il n'est pas dans ton $PATH. Vérifie avec echo $PATH.

Tu es bloqué dans vim et tu ne peux plus sortir. Classique. Appuie sur Échap, puis tape :q! puis Entrée. Pour t'éviter ça, mets nano en éditeur par défaut : export EDITOR=nano dans ton .bashrc.

Ton terminal semble gelé, plus rien ne répond. Tu as sans doute tapé Ctrl-S (gel de l'affichage, vieux mécanisme de contrôle de flux). Tape Ctrl-Q pour dégeler. Si tu es coincé dans less ou man, la touche q te fait sortir.

Et après ?

Ma progression →