Le terminal et le shell#
Terminal physique, émulateur de terminal et shell#
Trois termes reviennent constamment dans le monde Linux et sont souvent confondus par les débutants : terminal, console et shell. Ils désignent des réalités historiquement et techniquement distinctes qu’il est important de bien différencier pour comprendre comment les commandes que l’on tape arrivent jusqu’au noyau du système.
Le terminal physique#
À l’époque des grands ordinateurs centraux (mainframes) des années 1960-1970, le mot terminal désignait un dispositif physique composé d’un clavier et d’un écran (ou d’une imprimante) permettant à un utilisateur de se connecter à distance à un ordinateur central via une liaison série. Ces terminaux — les plus célèbres étant le DEC VT100 (1978) et le VT220 — ne faisaient qu’afficher du texte et transmettre les frappes clavier. Ils n’avaient pas de puissance de calcul propre. Toute l’intelligence résidait dans le serveur central.
Le VT100 a introduit des séquences d’échappement ANSI (par exemple ESC[1;32m pour afficher du texte en vert gras) qui permettaient de contrôler le curseur, les couleurs et la mise en forme du texte. Ces séquences sont encore utilisées aujourd’hui par les émulateurs de terminaux modernes — c’est pourquoi un script qui affiche des couleurs avec \033[0;31m fonctionne dans votre émulateur de terminal en 2024.
La console virtuelle Linux#
Linux propose plusieurs consoles virtuelles accessibles via les combinaisons Ctrl+Alt+F1 à Ctrl+Alt+F6. Chaque console virtuelle est un terminal texte indépendant géré directement par le noyau, sans interface graphique. La console F7 (ou F1 selon les distributions) est généralement réservée à l’environnement graphique X11 ou Wayland. Les consoles virtuelles sont précieuses pour le dépannage : si l’environnement graphique plante, on peut basculer vers Ctrl+Alt+F2 pour obtenir un terminal textuel fonctionnel.
L’émulateur de terminal#
Dans un environnement graphique moderne, on utilise un émulateur de terminal : un programme qui simule un terminal physique à l’intérieur d’une fenêtre graphique. Il traduit les frappes clavier en séquences envoyées au shell, et affiche les sorties texte du shell dans la fenêtre. Parmi les émulateurs de terminaux les plus courants :
GNOME Terminal : émulateur par défaut de l’environnement GNOME, intégré à Ubuntu et Fedora.
Konsole : émulateur de l’environnement KDE Plasma, très riche en fonctionnalités.
Kitty : émulateur moderne, très rapide (accélération GPU), extensible via Python, supporte les images dans le terminal.
Alacritty : émulateur minimaliste et extrêmement rapide écrit en Rust, sans onglets ni interface complexe.
Tilix : émulateur qui permet de diviser la fenêtre en plusieurs panneaux.
tmux / screen : ce ne sont pas des émulateurs de terminaux à proprement parler, mais des multiplexeurs de terminaux qui permettent de créer plusieurs sessions dans un seul terminal, et de les détacher/réattacher.
Définition 3 (Émulateur de terminal)
Un émulateur de terminal est une application graphique qui simule le comportement d’un terminal physique à l’intérieur d’une interface graphique. Il crée un pseudo-terminal (pty) — une paire de fichiers virtuels qui permettent la communication entre le terminal émulé et le processus shell. L’émulateur interprète les séquences d’échappement ANSI pour afficher les couleurs, déplacer le curseur et gérer la mise en forme.
Le shell#
Le shell est le programme qui s’exécute à l’intérieur du terminal. C’est un interpréteur de commandes : il lit les lignes saisies par l’utilisateur (ou contenues dans un fichier de script), les interprète selon sa syntaxe propre, et les exécute. Le shell est responsable de :
L”expansion des métacaractères (
*,?,~,$VAR…).La gestion des redirections (
>,<,>>,2>,|).La gestion des processus (foreground, background,
jobs,&).L’évaluation des structures de contrôle (
if,for,while,case).La gestion de l”environnement (variables, fonctions, aliases).
La lecture de l”historique des commandes.
Remarque 3
La relation entre terminal et shell est une relation client-serveur inversée : le terminal (émulateur) est le maître du pseudo-terminal, et le shell est l”esclave. Quand vous tapez un caractère, l’émulateur l’envoie au pseudo-terminal, qui le transmet au shell. Quand le shell produit une sortie, le pseudo-terminal la transmet à l’émulateur, qui l’affiche à l’écran. Cette architecture explique pourquoi vous pouvez changer de shell sans changer d’émulateur : il suffit de lancer bash, zsh ou fish dans un terminal déjà ouvert.
Les shells : Bash, Zsh, Fish#
Bash (Bourne Again Shell, 1989)#
Bash (Bourne Again Shell) a été écrit par Brian Fox pour le projet GNU en 1989. Son nom est un jeu de mots sur le Bourne Shell (sh), le shell d’origine Unix écrit par Stephen Bourne en 1979. Bash est un sur-ensemble du Bourne Shell : tout script valide pour sh est valide pour Bash, mais Bash ajoute de nombreuses fonctionnalités (tableaux, substitution de processus, complétion programmable, [[ ]], etc.).
Bash est le shell par défaut de la quasi-totalité des distributions Linux et était celui de macOS jusqu’à Catalina (2019). Il est omniprésent sur les serveurs, dans les conteneurs, dans les scripts d’administration système, dans les pipelines CI/CD. Pour un ingénieur qui travaille sur des systèmes Linux, Bash est un outil incontournable.
Zsh (Z Shell, 1990)#
Zsh a été créé par Paul Falstad en 1990 alors qu’il était étudiant à Princeton. Il est compatible avec Bash mais offre des fonctionnalités supplémentaires appréciées des utilisateurs interactifs : une complétion plus intelligente (avec un menu de sélection), des thèmes de prompt élaborés, des corrections orthographiques, une meilleure gestion des tableaux associatifs. Oh My Zsh est un framework de configuration très populaire qui facilite la personnalisation de Zsh. Apple a choisi Zsh comme shell par défaut sur macOS depuis Catalina (2019).
Fish (Friendly Interactive Shell, 2005)#
Fish (Friendly Interactive Shell) adopte une philosophie radicalement différente : il est conçu pour être utilisable sans configuration, avec des comportements intelligents activés par défaut. Il offre une auto-complétion basée sur l’historique (suggestions grises en temps réel), une coloration syntaxique en direct (les commandes invalides apparaissent en rouge), et une configuration via une interface web. Sa syntaxe n’est cependant pas compatible POSIX, ce qui en fait un mauvais choix pour écrire des scripts portables.
Définition 4 (Comparaison des shells)
Critère |
Bash |
Zsh |
Fish |
|---|---|---|---|
Année |
1989 |
1990 |
2005 |
Compatibilité POSIX |
Oui |
Oui |
Non |
Shell par défaut Linux |
Oui |
Non |
Non |
Shell par défaut macOS |
Avant Catalina |
Depuis Catalina |
Non |
Configuration nécessaire |
Minimale |
Importante |
Aucune |
Scripts portables |
Idéal |
Bon |
Déconseillé |
Interactivité avancée |
Correcte |
Excellente |
Excellente |
Pour l’apprentissage de la ligne de commande Linux et l’écriture de scripts portables, Bash est le choix optimal.
Pourquoi Bash ?#
Bash est le choix naturel pour ce livre pour plusieurs raisons concrètes :
Omniprésence sur les serveurs. Quand vous vous connectez via SSH à un serveur Linux (VPS, instance cloud AWS/GCP/Azure, Raspberry Pi), vous tombez sur Bash. Les images Docker de base (ubuntu:22.04, debian:bookworm) fournissent Bash. Les scripts d’initialisation des clouds (user data, cloud-init) sont écrits en Bash.
Standard de facto pour les scripts. Les scripts d’administration système, les Makefile, les pipelines CI/CD (GitHub Actions, GitLab CI, Jenkins) utilisent massivement Bash. Comprendre Bash, c’est pouvoir lire et écrire ces scripts.
Conformité POSIX. Un script écrit avec les constructions de base de Bash (#!/bin/bash ou #!/bin/sh) fonctionnera sur Linux, macOS, BSD et partout où POSIX est respecté.
Stabilité. La syntaxe et le comportement de Bash sont stables depuis des décennies. Un script Bash écrit en 1995 fonctionnera encore en 2025.
Anatomie d’une commande Bash#
Toute commande Bash suit une structure générale simple mais précise. La comprendre permet d’interpréter correctement n’importe quelle commande, même inconnue.
Définition 5 (Syntaxe d’une commande)
La syntaxe générale d’une commande Bash est :
commande [-options] [arguments]
- **`commande`** : le nom du programme à exécuter (par exemple `ls`, `grep`, `find`) ou une commande intégrée au shell (*builtin*) comme `cd`, `echo`, `export`.
- **`[-options]`** : des modificateurs du comportement de la commande, précédés d'un tiret. Les options courtes sont un tiret suivi d'une lettre (`-l`, `-a`, `-h`). Les options longues sont deux tirets suivis d'un mot (`--all`, `--human-readable`). Les options courtes peuvent souvent être combinées (`-la` équivaut à `-l -a`).
- **`[arguments]`** : les cibles sur lesquelles la commande opère (fichiers, répertoires, chaînes de texte, URLs…).
Exemple 3 (Décomposition de commandes)
# Commande seule (sans option ni argument)
pwd
# Commande avec une option courte
ls -l
# Commande avec plusieurs options courtes combinées
ls -lah
# Commande avec une option longue
ls --human-readable
# Commande avec option et argument
ls -l /etc
# Commande avec plusieurs arguments
cp fichier1.txt fichier2.txt /tmp/destination/
# Commande avec option longue et valeur
grep --max-count=5 "erreur" /var/log/syslog
# Option longue avec signe égal ou espace (les deux sont valides)
grep --max-count 5 "erreur" /var/log/syslog
```{prf:remark}
:label: remark-02-02
La convention `--` (double tiret seul) signifie la **fin des options**. Tout ce qui suit est traité comme un argument, même si cela commence par un tiret. Cela est utile quand un nom de fichier commence par `-` :
```bash
# Supprimer un fichier nommé "-fichier_bizarre"
rm -- -fichier_bizarre
# Sans --, rm interpréterait -fichier_bizarre comme des options
## Raccourcis clavier essentiels
L'efficacité à la ligne de commande repose en grande partie sur la maîtrise des raccourcis clavier. Ces raccourcis sont hérités de l'éditeur **Emacs** (dont Bash utilise les bindings par défaut) et permettent de naviguer et d'éditer la ligne de commande courante sans souris.
### Navigation dans la ligne
| Raccourci | Action |
|---|---|
| `Ctrl+A` | Aller au **début** de la ligne |
| `Ctrl+E` | Aller à la **fin** de la ligne |
| `Alt+B` | Reculer d'un **mot** |
| `Alt+F` | Avancer d'un **mot** |
| `Ctrl+B` | Reculer d'un **caractère** |
| `Ctrl+F` | Avancer d'un **caractère** |
### Édition de la ligne
| Raccourci | Action |
|---|---|
| `Ctrl+U` | Supprimer du curseur jusqu'au **début** de la ligne |
| `Ctrl+K` | Supprimer du curseur jusqu'à la **fin** de la ligne |
| `Ctrl+W` | Supprimer le mot à **gauche** du curseur |
| `Alt+D` | Supprimer le mot à **droite** du curseur |
| `Ctrl+Y` | Coller (*yank*) le dernier texte supprimé |
| `Ctrl+_` | **Annuler** la dernière modification |
### Contrôle des processus
| Raccourci | Action |
|---|---|
| `Ctrl+C` | **Interrompre** (SIGINT) le processus en cours |
| `Ctrl+D` | **Fin de fichier** (EOF) — ferme le shell si la ligne est vide |
| `Ctrl+Z` | **Suspendre** (SIGTSTP) le processus (le mettre en arrière-plan) |
| `Ctrl+L` | **Effacer** l'écran (équivalent de `clear`) |
| `Ctrl+S` | Geler le défilement du terminal |
| `Ctrl+Q` | Reprendre le défilement du terminal |
### Complétion automatique
La touche **Tab** est l'une des plus puissantes de Bash :
```bash
# Compléter un nom de fichier ou de répertoire
ls /etc/pas<Tab> # complète en /etc/passwd
# Compléter une commande
sys<Tab><Tab> # affiche toutes les commandes commençant par "sys"
# Compléter les options (si bash-completion est installé)
git comm<Tab> # complète en "git commit"
Remarque 4
bash-completion est un paquet (installé par défaut sur Ubuntu/Debian) qui étend la complétion automatique de Bash à des centaines de commandes : git, apt, docker, kubectl, ssh, et bien d’autres. Il permet de compléter non seulement les noms de fichiers, mais aussi les options, les sous-commandes, et même les valeurs de certains arguments. Son installation : sudo apt install bash-completion.
L’historique des commandes#
Bash conserve automatiquement un historique des commandes saisies, qui persiste entre les sessions grâce au fichier ~/.bash_history. Cet historique est l’un des outils de productivité les plus sous-utilisés par les débutants.
Les expansions d’historique#
Bash offre des opérateurs spéciaux pour réutiliser des parties de commandes précédentes :
# !! : répéter la dernière commande
apt install vim
sudo !! # équivaut à : sudo apt install vim
# !n : exécuter la commande numéro n de l'historique
history | grep apt
!42 # exécute la commande numéro 42
# !-n : exécuter la n-ième commande avant la dernière
!-3 # exécute la 3ème commande avant la dernière
# !chaîne : exécuter la dernière commande commençant par "chaîne"
!git # exécute la dernière commande commençant par "git"
# !$ : le dernier argument de la commande précédente
vim /etc/nginx/nginx.conf
cat !$ # équivaut à : cat /etc/nginx/nginx.conf
# !^ : le premier argument de la commande précédente
# !* : tous les arguments de la commande précédente
cp fichier1 fichier2 /tmp/
ls !* # liste fichier1 fichier2 /tmp/
# ^ancien^nouveau : substitution dans la dernière commande
git comit -m "message" # faute de frappe
^comit^commit # corrige en : git commit -m "message"
Exemple 4 (Variables de configuration de l’historique)
Ces variables peuvent être définies dans ~/.bashrc pour personnaliser le comportement de l’historique :
# Nombre de commandes conservées en mémoire dans la session courante
HISTSIZE=10000
# Nombre de commandes conservées dans le fichier ~/.bash_history
HISTFILESIZE=20000
# Format d'horodatage dans l'historique (affiche la date avec history)
HISTTIMEFORMAT="%Y-%m-%d %H:%M:%S "
# Ne pas enregistrer les doublons consécutifs, ni les commandes commençant
# par un espace (pratique pour les commandes contenant des mots de passe)
HISTCONTROL=ignoreboth
# Ignorer certaines commandes dans l'historique
HISTIGNORE="ls:ll:la:cd:pwd:exit:clear"
# Sauvegarder l'historique après chaque commande (pas seulement à la fermeture)
PROMPT_COMMAND="history -a"
## Configuration de l'environnement Bash
Bash lit plusieurs fichiers de configuration au démarrage, selon qu'il est lancé comme shell de **connexion** (*login shell*) ou shell **interactif** non-login.
```{prf:definition} Login shell vs shell interactif
:label: definition-02-04
- **Login shell** : le premier shell lancé lors d'une connexion (SSH, TTY, `bash --login`). Il lit `~/.bash_profile` (ou `~/.bash_login`, ou `~/.profile` dans cet ordre).
- **Shell interactif non-login** : un shell ouvert dans un terminal graphique ou par `bash` sans option `--login`. Il lit `~/.bashrc`.
- **Shell non-interactif** : un shell exécutant un script (sans terminal). Il ne lit ni `~/.bash_profile` ni `~/.bashrc`, mais peut lire la variable `$BASH_ENV`.
La convention habituelle est de mettre les **exports de variables d'environnement** dans `~/.bash_profile` (ou de le faire sourcer `~/.bashrc`), et la configuration interactive (aliases, fonctions, prompt) dans `~/.bashrc`.
Exemple 5 (Contenu typique de ~/.bashrc)
# Activer la complétion automatique avancée
if [ -f /etc/bash_completion ]; then
. /etc/bash_completion
fi
# Définir le prompt (PS1) avec couleurs
# \u = nom d'utilisateur, \h = nom d'hôte, \w = répertoire courant
export PS1='\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '
# Aliases pratiques
alias ll='ls -alF --color=auto'
alias la='ls -A --color=auto'
alias l='ls -CF --color=auto'
alias grep='grep --color=auto'
alias ..='cd ..'
alias ...='cd ../..'
# Variables d'environnement
export EDITOR=vim
export LANG=fr_FR.UTF-8
export LC_ALL=fr_FR.UTF-8
# Configuration de l'historique
export HISTSIZE=10000
export HISTFILESIZE=20000
export HISTCONTROL=ignoreboth
export HISTTIMEFORMAT="%Y-%m-%d %H:%M:%S "
# Ajout de ~/bin et ~/.local/bin au PATH
export PATH="$HOME/.local/bin:$HOME/bin:$PATH"
## Schéma : terminal → shell → noyau → matériel
```{code-cell} python
:tags: [hide-input]
fig, ax = plt.subplots(figsize=(14, 10))
ax.set_xlim(-1, 15)
ax.set_ylim(-1, 12)
ax.axis('off')
ax.set_title('Architecture : de la frappe clavier au matériel',
fontsize=15, fontweight='bold', pad=20)
palette = sns.color_palette("muted", 8)
def draw_box(ax, x, y, w, h, color, title, subtitle="", alpha=0.18):
box = patches.FancyBboxPatch(
(x, y), w, h,
boxstyle="round,pad=0.2", linewidth=2.5,
edgecolor=color, facecolor=color, alpha=alpha
)
ax.add_patch(box)
border = patches.FancyBboxPatch(
(x, y), w, h,
boxstyle="round,pad=0.2", linewidth=2.5,
edgecolor=color, facecolor='none'
)
ax.add_patch(border)
ax.text(x + w / 2, y + h / 2 + (0.25 if subtitle else 0),
title, ha='center', va='center',
fontsize=11, fontweight='bold', color=color)
if subtitle:
ax.text(x + w / 2, y + h / 2 - 0.35,
subtitle, ha='center', va='center',
fontsize=8, color='#555555', style='italic')
# Couches verticales (de haut en bas)
layers = [
# (x, y, w, h, couleur, titre, sous-titre)
(3.5, 9.5, 7, 1.3, palette[0], "Utilisateur", "Frappe sur le clavier"),
(3.5, 7.8, 7, 1.3, palette[1], "Émulateur de terminal",
"gnome-terminal, kitty, alacritty…"),
(3.5, 6.1, 7, 1.3, palette[2], "Pseudo-terminal (PTY)",
"Interface noyau entre terminal et shell"),
(3.5, 4.4, 7, 1.3, palette[3], "Shell (Bash)",
"Interprétation, expansion, exécution"),
(3.5, 2.7, 7, 1.3, palette[4], "Noyau Linux",
"Appels système, ordonnanceur, VFS"),
(3.5, 1.0, 7, 1.3, palette[5], "Matériel",
"CPU, RAM, disque, réseau, clavier…"),
]
for (x, y, w, h, color, title, subtitle) in layers:
draw_box(ax, x, y, w, h, color, title, subtitle)
# Flèches entre couches
arrow_x = 7.0
arrow_color = '#444444'
for y_top, y_bot in [(9.5, 9.1), (7.8, 7.4), (6.1, 5.7),
(4.4, 4.0), (2.7, 2.3)]:
# Flèche vers le bas
ax.annotate('',
xy=(arrow_x, y_bot),
xytext=(arrow_x, y_top),
arrowprops=dict(arrowstyle='->', color=arrow_color, lw=2))
# Flèche vers le haut (retour)
ax.annotate('',
xy=(arrow_x + 0.4, y_top),
xytext=(arrow_x + 0.4, y_bot),
arrowprops=dict(arrowstyle='->', color=palette[6], lw=1.5,
linestyle='dashed'))
# Annotations sur les flèches
labels_down = [
(7.5 - 0.3, 9.2, "touches"),
(7.5 - 0.3, 7.5, "séquences\nANSI"),
(7.5 - 0.3, 5.8, "caractères\nbruts"),
(7.5 - 0.3, 4.1, "syscalls\n(execve, read…)"),
(7.5 - 0.3, 2.4, "instructions\nmatériel"),
]
for (x, y, label) in labels_down:
ax.text(x, y, label, ha='left', va='center',
fontsize=7.5, color='#333333', style='italic')
# Boîte latérale : exemples d'émulateurs
side_items = [
"Terminaux physiques\n(DEC VT100, VT220)",
"Consoles virtuelles\n(Ctrl+Alt+F1…F6)",
"Émulateurs modernes\n(gnome-terminal,\nkitty, alacritty,\ntilix, konsole)",
"Multiplexeurs\n(tmux, screen)",
]
for i, item in enumerate(side_items):
bx = 11.5
by = 8.8 - i * 2.3
b = patches.FancyBboxPatch(
(bx, by), 2.8, 1.8,
boxstyle="round,pad=0.15", linewidth=1.5,
edgecolor=palette[1], facecolor=palette[1], alpha=0.12
)
ax.add_patch(b)
ax.text(bx + 1.4, by + 0.9, item,
ha='center', va='center', fontsize=7.2, color='#333333')
ax.text(12.9, 10.8, "Types de terminaux", ha='center', va='center',
fontsize=10, fontweight='bold', color=palette[1])
plt.tight_layout()
plt.show()
Variables d’environnement et PATH#
L”environnement est l’ensemble des variables accessibles à un processus et à ses enfants. Les variables d’environnement sont des paires clé=valeur transmises automatiquement à tout processus enfant.
# Afficher toutes les variables d'environnement
env
# ou
printenv
# Afficher une variable spécifique
echo $HOME
echo $PATH
echo $USER
echo $SHELL
echo $LANG
# Définir une variable de shell (locale, non exportée)
MA_VARIABLE="bonjour"
echo $MA_VARIABLE # accessible dans le shell courant
# Exporter vers l'environnement (accessible aux processus enfants)
export MA_VARIABLE
# Définir et exporter en une ligne
export MON_PROJET="/home/loc/projet"
# Définir une variable pour une seule commande (sans exporter)
MON_ENV=test commande_qui_lit_MON_ENV
La variable PATH#
La variable PATH est la plus importante de l’environnement. Elle contient une liste de répertoires séparés par : dans lesquels Bash cherche les programmes quand on tape une commande.
Exemple 6 (Comprendre et modifier PATH)
# Afficher le PATH courant
echo $PATH
# Exemple de sortie :
# /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
# Quand on tape "ls", Bash cherche dans l'ordre :
# /usr/local/sbin/ls -> non trouvé
# /usr/local/bin/ls -> non trouvé
# /usr/sbin/ls -> non trouvé
# /usr/local/bin/ls -> non trouvé
# /usr/bin/ls -> TROUVÉ ! On l'exécute.
# Trouver où se trouve une commande
which ls # /usr/bin/ls
which python3 # /usr/bin/python3
# Ajouter un répertoire au PATH (pour la session courante)
export PATH="$HOME/.local/bin:$PATH"
# Ajouter de façon permanente : mettre cette ligne dans ~/.bashrc
## Résumé
Dans ce chapitre, nous avons démystifié les trois niveaux de l'interface en ligne de commande :
- Le **terminal physique** est l'ancêtre : un périphérique clavier+écran qui s'est transformé en **émulateur de terminal** (gnome-terminal, kitty, alacritty) dans les environnements graphiques modernes. Les **consoles virtuelles** Linux (`Ctrl+Alt+F1-6`) sont une forme de terminal sans interface graphique.
- Le **shell** est l'interpréteur de commandes qui s'exécute dans le terminal. **Bash** (1989, Brian Fox) est le shell par défaut sur Linux, conforme POSIX et omniprésent sur les serveurs. Zsh offre une meilleure interactivité, Fish est agréable mais non POSIX.
- La **syntaxe d'une commande** suit le schéma `commande [-options] [arguments]`. Les options courtes (`-l`) et longues (`--list`) modifient le comportement ; les arguments sont les cibles.
- Les **raccourcis clavier** (`Ctrl+A/E`, `Ctrl+U/K`, `Ctrl+R`, `Tab`) sont essentiels pour l'efficacité. `Ctrl+C` interrompt, `Ctrl+Z` suspend, `Ctrl+D` signale la fin de fichier.
- L'**historique** (`history`, `!!`, `!$`, `!n`, `^ancien^nouveau`) permet de réutiliser et de corriger les commandes précédentes. Les variables `HISTSIZE` et `HISTFILESIZE` contrôlent sa taille.
- Les **variables d'environnement** (`export`) et le **PATH** déterminent l'environnement d'exécution des commandes.
Dans le prochain chapitre, nous explorerons le **système de fichiers** Linux : sa hiérarchie standardisée (FHS), les commandes de navigation et de recherche, les inodes et les liens, et le montage des systèmes de fichiers.