Maîtriser les bases de la ligne de commande (CLI) : guide pour débutants

La ligne de commande (souvent appelée CLI pour Command Line Interface) est un moyen de contrôler un ordinateur en tapant des commandes textuelles. Elle peut sembler intimidante au début, mais elle devient rapidement un outil extrêmement puissant : automatisation, manipulation de fichiers en masse, diagnostic, installation de logiciels, travail à distance, développement… Tout y passe.

Ce guide vise à vous donner des bases solides, avec des explications approfondies et des commandes réelles que vous pouvez essayer. Les exemples sont principalement orientés vers les environnements Linux et macOS (shell type bash ou zsh). Sur Windows, vous pouvez utiliser WSL (Windows Subsystem for Linux) pour suivre presque à l’identique, ou adapter via PowerShell (non traité ici).

1) Comprendre ce que vous voyez : terminal, shell, invite de commande

Terminal vs shell

• Terminal : l’application qui affiche une fenêtre de texte (ex. Terminal macOS, GNOME Terminal, iTerm2…).
• Shell : le programme qui interprète vos commandes (ex. bash, zsh, fish).

Vous tapez une commande dans le terminal, le shell l’analyse, exécute des programmes et affiche le résultat.

L’invite (prompt)

Vous verrez souvent quelque chose comme :

alice@ordinateur:~$

• alice : utilisateur
• ordinateur : nom de la machine
• ~ : répertoire courant (ici le dossier personnel)
• $ : indique un utilisateur normal (souvent # pour l’administrateur)

2) Se repérer : où suis-je ? que contient ce dossier ?

Afficher le répertoire courant : pwd

pwd

Exemple de sortie :

/home/alice

Lister le contenu : ls

ls

Lister avec détails (droits, taille, date) :

ls -l

Lister aussi les fichiers cachés (commencent par .) :

ls -a

Combiner options :

ls -la

À retenir : les options courtes se combinent souvent (-l + -a → -la). Certaines commandes ont aussi des options longues (ex. --all), selon le système.

3) Naviguer dans l’arborescence : cd, chemins absolus et relatifs

Changer de dossier : cd

Aller dans un dossier :

cd Documents

Revenir au dossier parent :

cd ..

Aller directement au dossier personnel :

cd

Revenir au dossier précédent :

cd -

Chemins absolus vs relatifs

• Chemin absolu : commence à la racine / (ex. /home/alice/Documents)
• Chemin relatif : interprété depuis le répertoire courant (ex. Documents/projets)

Exemples :

cd /etc
cd nginx

Ici, nginx est relatif au dossier /etc.

Les raccourcis utiles

• ~ : votre dossier personnel (ex. /home/alice)
• . : le dossier courant
• .. : le dossier parent

Exemples :

cd ~/Téléchargements
cd ./scripts
cd ../images

4) Créer, déplacer, renommer, supprimer : les commandes de base

Créer un dossier : mkdir

mkdir projets

Créer une arborescence complète :

mkdir -p projets/cli/exercices

Créer un fichier vide : touch

touch notes.txt

Créer plusieurs fichiers :

touch a.txt b.txt c.txt

Copier : cp

Copier un fichier :

cp notes.txt sauvegarde_notes.txt

Copier un dossier (récursif) :

cp -r projets projets_copie

Déplacer / renommer : mv

Renommer un fichier :

mv notes.txt notes_2026.txt

Déplacer un fichier dans un dossier :

mv notes_2026.txt projets/

Déplacer et renommer en une seule commande :

mv projets/notes_2026.txt projets/notes_finales.txt

Supprimer : rm (attention)

Supprimer un fichier :

rm notes_finales.txt

Supprimer un dossier vide :

rmdir dossier_vide

Supprimer un dossier et son contenu (récursif) :

rm -r projets_copie

Supprimer sans confirmation (dangereux) :

rm -rf projets_copie

Important : rm ne met pas à la corbeille dans la plupart des configurations. Vérifiez avec ls avant, et utilisez des chemins explicites.

5) Lire et explorer des fichiers texte : cat, less, head, tail

Afficher le contenu : cat

cat /etc/hosts

Afficher avec numéros de ligne :

cat -n /etc/hosts

Lire confortablement : less

less permet de naviguer dans un fichier :

less /etc/services

Raccourcis dans less :

• q : quitter
• /mot : rechercher
• n : occurrence suivante
• g : début du fichier
• G : fin du fichier

Voir le début : head

head -n 20 fichier.log

Voir la fin : tail

tail -n 50 fichier.log

Suivre un fichier en temps réel (utile pour logs) :

tail -f /var/log/system.log

6) Comprendre les permissions : ls -l, chmod, chown

Lire la sortie de ls -l

Exemple :

ls -l script.sh

Sortie typique :

-rwxr-xr-- 1 alice staff  1200 Feb 14 10:30 script.sh

Décomposition :

• - : type (- fichier, d dossier, l lien symbolique)
• rwxr-xr-- : permissions
  • r lecture (read)
  • w écriture (write)
  • x exécution (execute)
• Trois blocs : utilisateur / groupe / autres

Ici :

• utilisateur : rwx (tout)
• groupe : r-x (lecture + exécution)
• autres : r-- (lecture seule)

Rendre un script exécutable : chmod

chmod +x script.sh

Retirer le droit d’écriture aux autres :

chmod o-w fichier.txt

Définir des droits en mode numérique (fréquent)

• 7 = rwx
• 6 = rw-
• 5 = r-x
• 4 = r--

Exemple classique :

chmod 755 script.sh

Signifie :

• utilisateur 7 → rwx
• groupe 5 → r-x
• autres 5 → r-x

Changer propriétaire/groupe : chown (souvent nécessite des droits admin)

sudo chown alice:staff fichier.txt

7) Trouver des fichiers et chercher dans du texte : find, grep

Trouver des fichiers : find

Trouver tous les fichiers .txt dans le dossier courant :

find . -name "*.txt"

Trouver les dossiers nommés backup :

find . -type d -name "backup"

Trouver les fichiers modifiés dans les dernières 24h :

find . -type f -mtime -1

Explication :

• . : point de départ (dossier courant)
• -type f : fichiers (et non dossiers)
• -mtime -1 : modifiés il y a moins d’un jour

Chercher dans le contenu : grep

Chercher un mot dans un fichier :

grep "erreur" fichier.log

Chercher récursivement dans un dossier :

grep -R "TODO" .

Afficher les numéros de ligne :

grep -n "config" /etc/hosts

Recherche insensible à la casse :

grep -i "warning" fichier.log

8) Redirections et pipelines : la “super-puissance” du CLI

Le shell permet de connecter des commandes entre elles et de rediriger leurs entrées/sorties.

Sortie standard et erreur standard

• stdout : sortie “normale”
• stderr : messages d’erreur

Rediriger la sortie vers un fichier : >

Écraser le fichier :

ls -la > listing.txt

Ajouter à la fin (sans écraser) : >>

echo "Nouvelle ligne" >> notes.txt

Rediriger les erreurs

Rediriger stderr vers un fichier :

commande_inexistante 2> erreurs.txt

Rediriger stdout et stderr ensemble :

ls -la /dossier/inexistant > sortie.txt 2>&1

Pipelines : |

Envoyer la sortie d’une commande vers l’entrée d’une autre :

ls -la | less

Compter le nombre de lignes :

ls -1 | wc -l

Chercher parmi les processus :

ps aux | grep "ssh"

Explication :

• ps aux liste les processus
• grep "ssh" filtre les lignes contenant ssh

9) Variables, expansion et guillemets : éviter les surprises

Variables d’environnement

Afficher une variable :

echo $HOME

Créer une variable locale (session courante) :

NOM="Alice"
echo "Bonjour $NOM"

Expansion de motifs (globbing)

Lister tous les .log :

ls *.log

Tous les fichiers commençant par app :

ls app*

Guillemets : simples vs doubles

• Guillemets simples '...' : pas d’expansion des variables
• Guillemets doubles "..." : expansion des variables

Exemples :

echo '$HOME'
echo "$HOME"

Résultat :

• première ligne affiche littéralement $HOME
• deuxième affiche le chemin réel

Espaces dans les noms de fichiers

Si un fichier s’appelle Mon Fichier.txt, il faut :

• échapper l’espace :

ls Mon\ Fichier.txt

• ou entourer de guillemets :

ls "Mon Fichier.txt"

10) Éditeurs en ligne de commande : nano (simple) et aperçu vim

Modifier un fichier avec nano

nano notes.txt

Raccourcis (affichés en bas) :

• Ctrl + O : enregistrer
• Ctrl + X : quitter
• Ctrl + W : rechercher

Ouvrir avec vim (aperçu minimal)

vim notes.txt

Pour débuter sans se perdre :

• i : passer en insertion
• Esc : revenir en mode normal
• :wq : enregistrer et quitter
• :q! : quitter sans enregistrer

11) Processus et tâches : ps, top, kill

Voir les processus : ps

Liste détaillée :

ps aux

Filtrer :

ps aux | grep "python"

Surveiller en temps réel : top

top

Quitter généralement avec q.

Terminer un processus : kill

Supposons que vous ayez un identifiant de processus (PID) 12345 :

kill 12345

Si le processus ne se termine pas :

kill -9 12345

Note : -9 force l’arrêt immédiat. À utiliser en dernier recours, car cela ne laisse pas le programme nettoyer correctement.

12) Réseau et diagnostic rapide : ping, curl, ssh

Tester la connectivité : ping

ping -c 4 example.com

• -c 4 : envoie 4 paquets puis s’arrête.

Récupérer une page ou une API : curl

Afficher le contenu HTML :

curl https://example.com

Voir les en-têtes HTTP :

curl -I https://example.com

Télécharger vers un fichier :

curl -o page.html https://example.com

Se connecter à une machine distante : ssh

Connexion :

ssh utilisateur@serveur.exemple.com

Avec un port spécifique :

ssh -p 2222 utilisateur@serveur.exemple.com

Concept clé : ssh ouvre une session shell sur une autre machine, comme si vous étiez devant.

13) Droits administrateur : sudo (et prudence)

Certaines opérations nécessitent des privilèges élevés (installer, modifier /etc, gérer des services…).

Exemple :

sudo ls /root

Le système vous demandera votre mot de passe (souvent celui de votre utilisateur).
Bon réflexe : comprenez la commande avant d’ajouter sudo. Une erreur avec sudo peut endommager le système.

14) Aide intégrée : man, --help, et apprendre à lire la documentation

Pages de manuel : man

man ls

Navigation :

• flèches / page suivante
• /mot pour chercher
• q pour quitter

Aide courte

Beaucoup de commandes acceptent :

ls --help
grep --help

Comprendre la structure

La documentation décrit :

• SYNOPSIS : la forme générale
• OPTIONS : les drapeaux disponibles
• EXAMPLES : parfois des exemples
• EXIT STATUS : codes de retour (utile en scripts)

15) Exercices pratiques (progressifs)

Faites-les dans un dossier de test, par exemple :

mkdir -p ~/atelier_cli
cd ~/atelier_cli

Exercice A : créer une structure

1. Créez trois dossiers : src, data, backup

mkdir src data backup

2. Créez deux fichiers dans src :

touch src/app.txt src/readme.txt

3. Listez tout avec détails :

ls -la
ls -la src

Exercice B : écrire et rechercher

1. Ajoutez du texte :

echo "TODO: écrire la documentation" >> src/readme.txt
echo "INFO: démarrage application" >> src/app.txt
echo "ERREUR: connexion échouée" >> src/app.txt

2. Recherchez “ERREUR” :

grep "ERREUR" src/app.txt

3. Recherchez “TODO” partout :

grep -R "TODO" .

Exercice C : redirections et pipeline

1. Sauvegardez la liste des fichiers dans un fichier :

find . -type f > fichiers.txt

2. Comptez le nombre de fichiers listés :

wc -l fichiers.txt

3. Faites la même chose sans fichier intermédiaire :

find . -type f | wc -l

Exercice D : copier et archiver “à la main”

1. Copiez src vers backup :

cp -r src backup/

2. Vérifiez :

find backup -type f -maxdepth 2

3. Renommez backup/src en backup/src_ancien :

mv backup/src backup/src_ancien

16) Bonnes pratiques et erreurs fréquentes

1) Toujours vérifier avant de supprimer

Avant un rm -r, faites :

ls -la chemin

ou :

find chemin -maxdepth 2 -type f

2) Éviter les chemins ambigus

Préférez :

rm ./fichier.txt

si vous êtes dans le bon dossier, plutôt que de compter sur le hasard.

3) Comprendre ce que fait le joker *

rm *.txt supprime tous les .txt du dossier courant. Testez d’abord :

ls *.txt

4) Utiliser less pour les gros fichiers

cat sur un fichier énorme peut inonder votre terminal. less est plus adapté.

5) Apprendre à lire les messages d’erreur

Un message comme :

• Permission denied → problème de droits
• No such file or directory → chemin incorrect
• Command not found → commande non installée ou faute de frappe

17) Aller plus loin : scripts, alias, et automatisation (aperçu)

Alias (raccourcis)

Créer un alias temporaire :

alias ll='ls -la'

Tester :

ll

Pour le rendre permanent, on l’ajoute généralement dans un fichier de configuration du shell (ex. ~/.bashrc ou ~/.zshrc), ce qui dépend de votre environnement.

Un mini-script shell

Créez un fichier sauvegarde.sh :

nano sauvegarde.sh

Contenu (exemple simple) :

#!/bin/bash
set -e

mkdir -p backup
cp -r src backup/src_$(date +%Y%m%d_%H%M%S)
echo "Sauvegarde terminée."

Rendre exécutable :

chmod +x sauvegarde.sh

Exécuter :

./sauvegarde.sh

Explications :

• #!/bin/bash : indique quel interpréteur utiliser
• set -e : arrête le script si une commande échoue
• date +%Y%m%d_%H%M%S : génère un horodatage utile pour versionner des copies

Conclusion

Maîtriser la CLI, c’est apprendre un “langage de pilotage” de votre système. Les commandes de base (pwd, ls, cd, mkdir, cp, mv, rm, cat, less, grep, find) forment un socle. Les redirections (>, >>, 2>) et pipelines (|) démultiplient ensuite vos capacités en combinant des outils simples.

Pour progresser rapidement :

1. Pratiquez quotidiennement sur un dossier d’atelier.
2. Lisez man et testez des options.
3. Apprenez à enchaîner des commandes avec |.
4. Soyez prudent avec rm -rf et sudo.

Si vous me dites votre système (Linux, macOS, WSL) et votre objectif (développement, administration, data, automatisation), je peux proposer un parcours d’exercices ciblé et des commandes adaptées.