Retour aux cours
Cours de référence
22 septembre 2026

Ligne de commande Linux : navigation, flux standards et commandes usuelles

Maîtrise du terminal shell Bash : arborescence, chemins absolus et relatifs, manipulation des flux standards (stdin, stdout, stderr), tubes (pipes) et outils de filtrage (cat, grep, cut, sort).

Cette ressource constitue le cours de référence sur l’utilisation du terminal Linux et l’écriture de scripts Bash. Conçu pour consolider les fondamentaux sans dépendre d’assistants artificiels, il détaille chaque mécanisme logique, syntaxique et sécuritaire manipulé lors des ateliers pratiques.


1. Introduction : Pourquoi le Terminal et le Shell ?

Dans l’écosystème professionnel informatique (administration système, DevOps, développement logiciel), l’interface graphique (bureau KDE, fenêtres de dossiers) trouve rapidement ses limites lorsqu’il s’agit d’automatiser des tâches, de gérer des serveurs distants ou de diagnostiquer des pannes complexes.

Le Terminal est l’interface textuelle qui permet de dialoguer directement avec le système d’exploitation. Derrière ce terminal s’exécute un interpréteur de commandes appelé le Shell. Sous Linux, le shell le plus universel est Bash (Bourne-Again SHell).


2. La Navigation dans l’Arborescence FHS

L’ensemble des fichiers sous Linux est organisé en une seule et unique arborescence inversée qui prend sa source à la racine, symbolisée par un simple slash /.

Chaque commande s’exécute depuis un emplacement précis : le répertoire de travail courant (current working directory).

Les commandes essentielles de déplacement

  • pwd (Print Working Directory) : Affiche le chemin absolu du dossier dans lequel vous vous trouvez actuellement.
  • ls (List) : Liste les fichiers et dossiers présents dans le répertoire courant. Utilisez ls -l pour obtenir les détails (permissions, propriétaire, taille).
  • cd [dossier] (Change Directory) : Permet de changer de répertoire de travail.

Les repères spatiaux indispensables

  • / : La racine absolue de tout le système de fichiers.
  • ~ : Un raccourci magique qui pointe toujours vers le dossier personnel de l’utilisateur connecté (ex. /home/etudiant).
  • . : Représente le répertoire courant (l’endroit exact où l’on est).
  • .. : Représente le répertoire parent (le dossier situé un niveau au-dessus).

Chemins Absolus vs Chemins Relatifs

Comprendre la différence entre ces deux types de chemins est une condition sine qua non pour ne plus se perdre dans la console :

  1. Chemin Absolu :

    • Commence toujours par le slash racine /.
    • Indique l’adresse complète du fichier depuis le sommet absolu du disque.
    • Il est parfaitement valide où que vous soyez dans le terminal.
    • Exemple : /home/etudiant/Documents/scripts/systeme.sh
  2. Chemin Relatif :

    • Commence sans slash initial (ou commence par ./ ou ../).
    • Indique le chemin à parcourir en partant de là où l’on se trouve actuellement.
    • Si vous êtes positionné dans /home/etudiant, pour atteindre le script situé dans Documents/scripts/systeme.sh, le chemin relatif est simplement Documents/scripts/systeme.sh.

3. La Philosophie UNIX : Flux de Texte et Plomberie (Pipes)

3.1 Un repère utile : UNIX, POSIX et macOS

Pour poser le décor : UNIX est le système pionnier créé à la fin des années 1960. C’est l’ancêtre commun des systèmes Linux et macOS (contrairement à l’écosystème Windows, bâti sur une logique totalement différente).

Pour que les programmes restent compatibles entre ces différents systèmes, la norme internationale POSIX a standardisé les règles du jeu :

  • L’arborescence unique qui démarre à la racine / ;
  • Le modèle de droits et permissions (rwx, chmod) ;
  • Les commandes de base du terminal : ls, cd, pwd, cat, grep, cut, etc.

Ce que cela signifie pour vous : tout ce que vous apprenez aujourd’hui en ligne de commande sous Linux est directement réutilisable dans le terminal d’un Mac !

3.2 Les 3 sources d’informations sous Linux : Fichiers, Commandes et Variables d’environnement

Pour diagnostiquer ou automatiser une tâche, un technicien dispose en réalité de trois sources distinctes pour obtenir une donnée système :

Type de source Ce que c’est concrètement Comment on l’obtient Exemples courants
1. Un fichier système Un document texte stocké sur le disque ou virtuel dans la RAM (/proc/, /sys/, /etc/). Source passive. On le lit avec un outil de lecture (cat, grep). /proc/cpuinfo
/etc/os-release
/proc/meminfo
2. Une commande autonome Un programme exécutable binaire ou script utilitaire. Il interroge lui-même le système et calcule sa réponse. On l’exécute directement par son nom (sans cat). uname -r
nproc
date
3. Une variable d’environnement Une variable déjà chargée en mémoire vive par le shell dès l’ouverture de votre session. On lit sa valeur directement avec le préfixe $ (sans lancer de commande ni lire de fichier !). $USER (votre login)
$HOSTNAME (nom de machine)
$HOME (dossier personnel)
$SHELL (interpréteur)

Si une information existe déjà sous la forme d’une variable d’environnement (comme $USER ou $HOSTNAME), il est inutile de lire un fichier ou de lancer une sous-commande coûteuse (whoami ou hostname) : il suffit d’utiliser directement la variable pré-remplie !

3.3 La boîte à outils du traitement textuel

Outil Rôle détaillé Exemple d’utilisation
cat Affiche en intégralité le contenu textuel d’un fichier. cat /proc/version
grep Filtre un flux ou un fichier pour n’extraire que les lignes contenant un motif textuel recherché. grep 'model name' /proc/cpuinfo
grep -m1 Identique à grep, mais s’arrête immédiatement après avoir trouvé la première correspondance (très utile pour éviter les doublons sur les processeurs multi-cœurs). grep -m1 'model name' /proc/cpuinfo
cut Découpe chaque ligne en colonnes. L’option -d définit le séparateur (délimiteur) et -f sélectionne le numéro du champ à conserver. cut -d: -f2 (isole tout ce qui est après le premier deux-points)

3.4 Le tube | (Pipe) : Relier les programmes

Le symbole | (le tube, accessible via AltGr + 6) est le connecteur universel d’UNIX. Il récupère la sortie standard (stdout) de la commande située à sa gauche et la transmet instantanément comme entrée standard (stdin) à la commande située à sa droite :

Pipeline UNIX : du fichier brut à la valeur isolée par un tube Source /proc/cpuinfo flux brut Filtrage grep -m1 | Découpage cut -d: -f2 valeur Sortie i5-1135G7

Grâce à ce mécanisme, on peut construire des chaînes d’extraction ultra-précises en une seule ligne de commande :

Terminal
grep -m1 'model name' /proc/cpuinfo | cut -d: -f2

4. Les Variables en Bash : Mémorisation et Restitution

Une variable est une zone de mémoire vive étiquetée par un nom, dans laquelle on stocke une information (texte ou nombre) pour pouvoir la manipuler et la réutiliser.

4.1 La règle d’or de la déclaration : Aucun espace !

En programmation shell, la syntaxe d’affectation est extrêmement rigoureuse :

  • Syntaxe valide : poste="thinkpad-01"
  • Erreur fatale : poste = "thinkpad-01"
    Pourquoi ? Si vous ajoutez des espaces autour du signe =, Bash interprète le premier mot (poste) comme une commande à lancer et = comme un argument, ce qui provoque une erreur (« commande introuvable »).

4.2 Capturer la sortie d’une commande : La substitution $( )

Pour stocker le résultat d’une commande ou d’une chaîne de commandes dans une variable, on utilise la syntaxe de substitution $( ... ) :

Terminal
# Stocker une commande autonome :
version_noyau=$(uname -r)
# Stocker une extraction complexe par tube :
modele_cpu=$(grep -m1 'model name' /proc/cpuinfo | cut -d: -f2)

4.3 Restitution et protection : $, ${}, ' et "

  • Lire une variable : Pour afficher ou exploiter la valeur contenue dans une variable, on fait toujours précéder son nom du signe dollar $ (ex. echo $version_noyau).
  • L’utilité des accolades ${} : Si le nom de la variable est immédiatement collé à d’autres caractères alphabétiques ou numériques, Bash risque de confondre le tout. Les accolades permettent de délimiter strictement le nom :
    Terminal
    prefixe="srv"
    echo "Connexion à ${prefixe}_db" # Affiche correctement : Connexion à srv_db
  • Guillemets doubles " vs Apostrophes simples ' :
    • Guillemets doubles " (Interprétation) : Bash analyse la chaîne et remplace chaque variable ($variable) par sa valeur réelle.
    • Apostrophes simples ' (Brut/Literal) : Bash désactive toute interprétation. Le texte est affiché exactement tel quel, et les symboles $ sont ignorés.

4.4 Variables définies par l’utilisateur vs Variables d’environnement système

Il existe deux catégories de variables dans votre environnement de travail :

  1. Vos variables locales utilisateur :

    • Celles que vous créez vous-même dans vos scripts ou en console (ex. modele_cpu, serveur_cible, date_jour).
    • Par convention, on les nomme généralement en minuscules (ex. mon_fichier).
  2. Les variables d’environnement système :

    • Elles sont automatiquement renseignées par Linux et le Shell dès l’ouverture de votre session.
    • Par convention universelle, elles sont écrites en MAJUSCULES.
    • Vous pouvez les consulter à tout moment en tapant env ou en affichant une variable précise :
      • $USER : Votre nom d’utilisateur (login) actuel.
      • $HOSTNAME : Le nom réseau officiel attribué à la machine.
      • $HOME : Le chemin absolu de votre répertoire personnel (/home/etudiant).
      • $SHELL : Le shell par défaut configuré pour votre compte (ex. /bin/bash).
      • $PWD : Le répertoire de travail courant (l’équivalent en variable de la commande pwd).

Dans un script, utiliser $USER ou $HOSTNAME est instantané et évite d’exécuter des programmes externes comme whoami ou hostname.


5. L’Affichage structuré : echo vs printf

Pour restituer des informations à l’écran, deux commandes sont à disposition :

  1. echo :

    • Idéal pour afficher des messages simples ou des séparateurs.
    • Passe automatiquement à la ligne à la fin de son exécution.
    • Exemple : echo "=== Début du rapport ==="
  2. printf (Print Formatted) :

    • L’outil professionnel indispensable pour concevoir des tableaux de bord et aligner proprement des données.
    • N’ajoute pas de saut de ligne automatique : il faut l’expliciter avec le caractère spécial \n (newline).

Décryptage d’un format printf

Terminal
printf '%-20s : %s\n' "Processeur" "$modele_cpu"
  • % : Début du formatage.
  • - : Alignement à gauche (par défaut, c’est aligné à droite).
  • 20 : Largeur fixe de la colonne (20 caractères réservés).
  • s : Type de donnée attendu (String / chaîne de caractères).
  • : %s\n : Sépare les colonnes par un deux-points, insère la deuxième variable et termine par un retour à la ligne.

Résultat visuel aligné :

Sortie
Processeur : 11th Gen Intel(R) Core(TM) i5-1135G7

6. L’Automatisation : Anatomie et Cycle de Vie d’un Script Bash

Un script Bash est un fichier texte ordinaire qui enchaîne des commandes de manière séquentielle. Au lieu de retaper laborieusement chaque instruction dans le terminal, l’ordinateur les exécute automatiquement les unes après les autres.

6.1 Les composants obligatoires d’un script

Un script propre et professionnel respecte toujours la structure suivante :

systeme.sh
#!/bin/bash
# ==============================================================
# Auteur : Étudiant SIO
# Description : Script de diagnostic et d'inventaire système
# ==============================================================
# 1. Déclaration des variables et collecte des données
hote=$(hostname)
noyau=$(uname -r)
date_jour=$(date '+%d/%m/%Y')
# 2. Affichage d'un en-tête soigné
echo "=============================================="
echo " RAPPORT DE CONFIGURATION DU POSTE "
echo " Date : $date_jour "
echo "=============================================="
echo
# 3. Restitution formatée en colonnes alignées
printf '%-18s : %s\n' "Nom de machine" "$hote"
printf '%-18s : %s\n' "Noyau Linux" "$noyau"
echo "=============================================="

Les points clés de ce script :

  • Le Shebang (#!/bin/bash) : Situé impérativement sur la première ligne du fichier. Les caractères #! (appelés shebang) indiquent au noyau du système d’exploitation quel programme interpréteur (/bin/bash) doit être chargé en mémoire pour lire et exécuter les lignes suivantes du fichier.
  • Les commentaires (#) : Toute ligne ou fin de ligne débutant par un dièse # est ignorée par le shell. Ils sont indispensables pour documenter le code et expliquer la logique aux autres techniciens (ou à vous-même dans six mois).

6.2 Comment créer, éditer et exécuter un script ?

Étape A : L’édition du fichier

Utilisez un éditeur de texte adapté au code, tel que VS Code (code systeme.sh) ou l’éditeur en mode console nano (nano systeme.sh). Enregistrez votre travail.

Étape B : L’exécution par l’interpréteur

Vous pouvez lancer le script en appelant explicitement le programme bash :

Terminal
bash systeme.sh

Cette méthode fonctionne toujours, car c’est le programme bash qui lit le fichier, sans exiger de droit particulier sur ce dernier.

Étape C : Rendre le script autonome avec chmod +x (Méthode professionnelle)

Dans la pratique, on souhaite qu’un script se comporte comme n’importe quelle commande native du système. Pour cela, il doit devenir exécutable :

  1. Donner le droit d’exécution avec la commande chmod (change mode) :
    Terminal
    chmod +x systeme.sh
    Vérification : En faisant ls -l, vous constaterez que la lettre x (executable) est apparue dans les permissions du fichier.
  2. Lancer le script avec son chemin d’accès relatif (./) :
    Terminal
    ./systeme.sh

Par mesure de sécurité fondamentale, le répertoire courant dans lequel vous vous trouvez n’est pas inclus dans la variable d’environnement $PATH (la liste des dossiers où Linux cherche les programmes exécutables). Si vous tapez simplement systeme.sh, le système refusera de le lancer en répondant « commande introuvable ».

Le préfixe ./ indique explicitement à Linux : “Cherche l’exécutable systeme.sh ici même, dans le répertoire courant”.

Valorisation E4 — Compétences travaillées

  • C-1.2.2Traiter des demandes concernant les services réseau et système, applicatifs

    Utilisation des commandes système usuelles, des redirections et des filtres texte pour diagnostiquer l'état d'un poste Linux.