Retour au cours

infra / linux-bash

Le terminal et le shell

Leçon 11 exercice

Explication

Un peu d'histoire

Linux est créé par Linus Torvalds, alors étudiant finlandais, qui annonce son "petit projet, juste un hobby" sur un forum Usenet en août 1991. Le noyau Linux s'appuie sur les outils du projet GNU, lancé dès 1983 par Richard Stallman pour créer un système d'exploitation entièrement libre. Bash (Bourne Again SHell), l'interpréteur de commandes le plus utilisé sous Linux, est écrit par Brian Fox en 1989 pour ce même projet GNU, en remplacement libre du shell Bourne (sh) créé en 1977 chez AT&T.

Pourquoi apprendre Linux et Bash aujourd'hui

Linux fait tourner la quasi-totalité des serveurs web et du cloud (AWS, Google Cloud, Azure), la majorité des supercalculateurs, et sert de base au système Android. Le terminal et Bash restent l'outil de travail quotidien de tout développeur backend, ingénieur DevOps ou administrateur système : c'est souvent plus rapide et plus puissant qu'une interface graphique, et c'est indispensable dès qu'on touche à un serveur distant.

Ce que vous allez apprendre

  • Comprendre ce qu'est réellement un shell et pourquoi Bash s'interpose entre toi et Linux
  • Distinguer un builtin (cd, echo) d'un programme externe (ls) et savoir pourquoi ça change leur comportement
  • Lire et utiliser le code de sortie ($?) d'une commande pour savoir si elle a réussi
  • Enchaîner des commandes avec ;, && et || selon la logique de succès/échec
  • Retrouver et rejouer une commande passée grâce à history et Ctrl+R

Dans quel contexte ?

Imagine un développeur qui vient de recevoir l'accès SSH à son premier serveur de production Ubuntu, sans aucune interface graphique. Tout ce qu'il peut faire pour vérifier que le service nginx tourne, lire un fichier de configuration ou redémarrer un processus doit passer par ce terminal noir qui n'affiche qu'une invite clignotante. Comprendre le shell, c'est comprendre l'unique porte d'entrée vers cette machine.

Le shell, c'est quoi au juste ?

D'abord, une image simple. Quand tu ouvres un terminal, tu ne parles pas directement à Linux : tu parles à un programme intermédiaire, le shell, qui traduit ce que tu tapes en actions concrètes.

C'est un peu comme un interprète placé entre toi et le système d'exploitation. Bash est le shell le plus répandu, mais ce n'est pas le seul : zsh, fish ou sh existent aussi et se ressemblent beaucoup une fois les bases acquises.

ShellOù on le trouveParticularité
sh (Bourne shell)Quasi tous les Unix, scripts #!/bin/shLe plus basique, standard POSIX
bashShell par défaut de la plupart des distributions LinuxLe plus répandu, riche en fonctionnalités
zshmacOS (depuis Catalina), option sur LinuxComplétion et thèmes très avancés (ex: Oh My Zsh)
fishInstallé volontairementSyntaxe simplifiée, pensé pour l'interactif

Prérequis

Aucune connaissance préalable n'est nécessaire pour cette leçon : c'est le tout premier contact avec le terminal. Un simple accès à un terminal Linux (ou WSL sous Windows) suffit pour suivre les exemples.

Pourquoi taper plutôt que cliquer ?

Cliquer semble plus simple au premier abord, mais chaque clic est un geste isolé, difficile à reproduire exactement. Une interface graphique cache en réalité des raccourcis puissants : enchaîner des commandes, les répéter, les combiner.

Le terminal donne un contrôle total et surtout reproductible : une commande tapée peut être copiée, partagée, mise dans un script, alors qu'une suite de clics ne se documente pas aussi bien.

Une fois ça posé, il faut distinguer deux types de commandes

Bash ne traite pas toutes les commandes de la même façon. Certaines sont intégrées au shell lui-même (les builtins, comme cd ou echo) et n'ont besoin d'aucune installation.

D'autres sont des programmes externes stockés quelque part sur le disque, comme ls (situé dans /usr/bin/ls). Cette différence explique pourquoi une commande peut se comporter différemment d'un shell à l'autre : un builtin appartient au shell, un programme externe est partagé par tous.

Il reste un point essentiel avant de pouvoir enchaîner des commandes : le code de sortie

Chaque commande, en terminant, renvoie discrètement un nombre : 0 signifie "tout s'est bien passé", n'importe quel autre chiffre signale une erreur. Tu ne le vois pas apparaître à l'écran, mais il est toujours là, accessible via $?.

C'est cette valeur cachée qui permettra plus tard de dire à Bash "fais B seulement si A a réussi". Comprendre ce mécanisme dès maintenant évite bien des scripts qui échouent en silence, sans qu'on comprenne pourquoi.

Bonne pratique

Prends dès maintenant le réflexe de taper echo $? juste après une commande dont tu n'es pas sûr du résultat. C'est le seul moyen fiable de savoir si ls /chemin/douteux a vraiment fonctionné, plutôt que de te fier uniquement à ce qui s'affiche à l'écran.

Le piège à éviter

Ne confonds pas l'historique des commandes (ce que tu as tapé, consultable avec history) avec la mémoire du système : fermer le terminal ne supprime rien de ce qui a déjà été exécuté, mais l'historique local, lui, peut se perdre si tu ne le sauvegardes pas correctement. Un autre piège classique de débutant : croire que cd et ls sont le même genre de commande, alors que l'un est un builtin et l'autre un exécutable — une nuance qui explique certains comportements déroutants une fois qu'on écrit des scripts plus complexes.

Maintenant que tu sais ce qu'est le shell et comment il "réfléchit" tes commandes, la prochaine étape logique est de savoir où tu te situes dans le système de fichiers et comment t'y déplacer : c'est exactement l'objet de la leçon suivante.

Commandes & code

Le terminal et le shell

Le shell est un interpréteur de commandes. Bash (Bourne Again SHell) est le plus répandu sur Linux.

bash
# Savoir quel shell tu utilises actuellement
echo "$SHELL"
echo "$0"

# Lister les shells installés sur la machine
cat /etc/shells

# Changer de shell par défaut pour ton utilisateur (relogin requis)
chsh -s /bin/bash

# Une commande = un programme externe OU un builtin du shell
type ls        # ls: alias/binaire externe -> /usr/bin/ls
type cd        # cd: shell builtin
type echo      # echo: shell builtin

# Historique des commandes
history                 # affiche tout l'historique
history | tail -20      # les 20 dernières commandes
!! # rejoue la dernière commande
!123                     # rejoue la commande numéro 123 de l'historique
!ls                      # rejoue la dernière commande commençant par "ls"

# Recherche interactive dans l'historique : Ctrl+R puis taper un mot-clé

# Raccourcis clavier essentiels du shell
# Ctrl+A -> début de ligne | Ctrl+E -> fin de ligne
# Ctrl+U -> efface avant le curseur | Ctrl+K -> efface après le curseur
# Ctrl+W -> efface le mot précédent
# Ctrl+L -> clear écran | Ctrl+C -> tue le process courant | Ctrl+D -> EOF / logout
# Ctrl+Z -> suspend le process courant (voir jobs / fg / bg)

# Enchaîner des commandes
cmd1 ; cmd2              # exécute cmd1 puis cmd2, peu importe le résultat de cmd1
cmd1 && cmd2              # exécute cmd2 uniquement si cmd1 a réussi (exit code 0)
cmd1 || cmd2              # exécute cmd2 uniquement si cmd1 a échoué

# Code de sortie de la dernière commande
ls /chemin/inexistant
echo $?                   # non nul = erreur (souvent 1 ou 2)

Résumé

  • Bash lit ta commande, l'interprète, puis exécute un binaire ou un builtin.
  • type distingue un builtin d'un exécutable externe.
  • && / || / ; enchaînent les commandes selon leur code de sortie ($?).
  • L'historique (history, Ctrl+R, !!) fait gagner énormément de temps.

Exercices pratiques

1 disponible
1

Mission : préparer un espace de travail sécurisé

Objectif : Préparer un espace Linux exploitable, puis justifier les choix de shell et de permissions.

Contexte

Tu viens de recevoir un accès SSH sur un serveur de test. Avant d'y déposer un script, tu dois créer un espace de travail propre et vérifier que seul ton utilisateur pourra lire son fichier de configuration.

Travaille dans ~/workspace. Ne copie pas une réponse : utilise le terminal, observe ce qu'il affiche, puis réponds aux questions.

La validation technique vérifiera l'état final des fichiers ; plusieurs commandes peuvent donc être correctes.

Résoudre l’exercice →