Premiers pas dans le terminal

Objectifs

À la fin de cette leçon, vous saurez :

• expliquer ce que sont un terminal et un shell, et pourquoi les développeurs vivent dedans ;
• reconnaître un prompt et décoder chaque information qu'il affiche ;
• exécuter une première commande et lire précisément ce qui s'affiche ;
• distinguer une commande, ses options et ses arguments, et prédire l'effet de chacun.

Pourquoi le terminal ?

Un ordinateur se pilote de deux façons :

• l'interface graphique : des fenêtres, des icônes, une souris. Agréable pour naviguer, mais limitée à ce que le concepteur a prévu ;
• la ligne de commande : vous décrivez votre intention en texte, la machine l'exécute. Rien n'est caché, tout est scriptable.

Le développement web passe presque exclusivement par la ligne de commande, pour trois raisons concrètes :

1. Les serveurs n'ont pas d'écran. La VM sur laquelle vous travaillez, comme la plupart des machines qui hébergent des sites, se pilote uniquement en texte : pas de bureau, pas de fenêtres.
2. Une commande écrite est reproductible. « Clique sur le troisième menu puis coche la case » est difficile à transmettre ; ls -la /etc s'exécute à l'identique chez tout le monde. Vous pourrez copier-coller une suite de commandes, la mettre dans un fichier, l'exécuter mille fois.
3. Tout le reste du cursus s'appuie dessus. Node.js, Git, PostgreSQL, le déploiement : chaque outil sera lancé depuis le terminal. Le maîtriser tôt évite de subir chaque leçon suivante.

L'objectif de ce chapitre n'est donc pas d'apprendre « des commandes par cœur », mais d'installer une mécanique : je décris une action en texte, je lis la réponse, j'ajuste.

Terminal et shell : deux rôles différents

Les deux mots désignent des choses différentes, souvent confondues :

• le terminal est le cadre de dialogue : la fenêtre (ou le canal réseau, avec SSH) dans laquelle le texte entre et sort. Il ne comprend rien à ce que vous tapez ;
• le shell est le programme qui tourne dans ce terminal et qui, lui, comprend : il lit votre ligne, la découpe, lance les bons programmes et affiche leurs résultats.

Une image utile : le terminal est le téléphone, le shell est l'interlocuteur au bout du fil. Sur votre VM, le shell s'appelle bash ; sous macOS récent, c'est souvent zsh. Ils se ressemblent beaucoup : ce qui est appris ici fonctionne partout.

Le dialogue complet ressemble à ceci :

vous (clavier)
     ↓ ligne de commande
shell (lit, découpe, décide quoi lancer)
     ↓ lance
programme (exécute réellement le travail)
     ↓ résultat texte
affichage dans le terminal

Point essentiel : le shell et le programme sont deux processus distincts. Quand vous tapez ls -la, ce n'est pas le shell qui liste le répertoire : il lance le programme ls avec les paramètres -la, attend sa fin, puis affiche ce que ls a produit. Cette distinction paraît pédante ; elle deviendra cruciale quand nous parlerons de processus au chapitre suivant.

Se connecter à la VM

Depuis votre propre ordinateur, ouvrez un terminal (sous Windows : PowerShell ou Windows Terminal ; sous macOS et Linux : l'application Terminal) et tapez :

ssh cours

Que se passe-t-il réellement ? ssh (Secure SHell) est un programme qui ouvre une session chiffrée vers une machine distante — ici, la VM nommée cours. Une fois la connexion établie, votre clavier parle à la machine distante et son écran revient dans votre fenêtre : tout ce que vous tapez ensuite s'exécute sur la VM, plus sur votre ordinateur. C'est exactement la situation d'un développeur qui administre un serveur de production.

Après connexion, le terminal affiche quelque chose comme :

utilisateur@cours:~/cours$

Prérequis : l'alias cours est déclaré dans la configuration SSH fournie avec la VM (~/.ssh/config). Si la connexion échoue depuis votre poste, utilisez directement ssh votre-utilisateur@adresse-de-la-vm.

Lire le prompt

Ce petit bout de texte avant le curseur s'appelle le prompt (invite de commandes). Il se termine toujours par $ suivi d'un espace : c'est la façon du shell de dire « je t'écoute ». Décomposons-le morceau par morceau, car il vous renseigne gratuitement :

utilisateur @ cours : ~/cours $
────────────   ───   ──  ──────   ─
    │      │    │    │        │
    │      │    │    │        └─ « je suis un utilisateur normal »
    │      │    │    │            (un # signifierait « administrateur »)
    │      │    │    └─ répertoire courant (~ est votre dossier personnel)
    │      │    └─ séparateur
    │      └─ machine sur laquelle vous êtes
    └─ votre nom d'utilisateur

Trois habitudes à prendre immédiatement :

1. Regardez le prompt avant de taper : il vous dit qui vous êtes et où vous êtes. Beaucoup d'erreurs (« mon fichier n'est pas là ! ») viennent d'un répertoire courant oublié.
2. Ne tapez jamais le $ : il représente le prompt, pas votre commande. Dans les exemples de ce cours, $ en début de ligne signifie « à taper dans le shell » ; les lignes suivantes sans $ sont la réponse de la machine.
3. Le prompt change quand vous vous déplacez : après un déplacement vers /etc, il devient utilisateur@cours:/etc$. Gratuitement, vous savez où vous êtes.

Une commande, étape par étape

Tapez cette ligne puis Entrée :

$ ls -la /home
total 4
drwxr-xr-x 3 root     root     4096 Jan 12 09:00 .
drwxr-xr-x 3 root     root     4096 Jan 12 09:00 ..
drwxr-x--- 5 cours    cours    4096 Jan 12 09:14 cours

Entre la touche Entrée et l'affichage, le shell enchaîne cinq étapes :

1. Lecture : il capte la ligne ls -la /home jusqu'à la touche Entrée.
2. Découpage : il coupe la ligne aux espaces, ce qui donne trois mots : ls, -la, /home.
3. Recherche : le premier mot est le nom du programme à lancer. Le shell cherche un exécutable qui s'appelle ls (il le trouve ici dans /usr/bin/ls — la leçon 1-04 vous montrera comment le vérifier avec which).
4. Exécution : il lance ce programme en lui transmettant les mots restants comme paramètres, attend sa fin, et récupère son résultat.
5. Affichage + nouveau prompt : le texte produit par ls apparaît, puis le prompt revient : prêt pour la suite.

Ce mécanisme est toujours le même, quelle que soit la commande. Compris une fois, il vaut pour tout le cursus.

Commande, options et arguments

La ligne de commande obéit à une grammaire simple :

• la commande (premier mot) : quel programme lancer ;
• les options : elles modifient le comportement du programme. Convention : elles commencent par un tiret ;
• les arguments : les données sur lesquelles travailler (un chemin, un texte…).

Quelques décompositions pour installer le réflexe :

Ligne complète	Commande	Options	Arguments
pwd	pwd	aucune	aucun
ls	ls	aucune	aucun
ls -la	ls	-l et -a	aucun
ls -la /home	ls	-l et -a	/home
cat notes.txt	cat	aucune	notes.txt

Précisions qui évitent bien des erreurs :

• Les espaces séparent les mots. ls -la/home est une erreur : collés, -la/home devient un seul mot que ls ne comprendra pas.
• Pour passer un texte contenant des espaces en un seul morceau, on le quote. echo Bonjour le monde reçoit trois arguments et les réaffiche séparés d'un espace ; echo "Bonjour le monde" n'en reçoit qu'un seul. Les guillemets disent au shell : « ne découpe pas là-dedans ».
• Les options courtes peuvent se combiner : ls -l -a et ls -la sont strictement équivalents. Chaque option a souvent une version longue plus parlante : ls --all vaut ls -a. La version longue s'écrit avec deux tirets.
• L'ordre habituel est commande, puis options, puis arguments. ls /home -la marche souvent, mais ne comptez pas dessus partout : prenez l'habitude de cet ordre.

Comment savoir quelles options existent ? Trois sources, détaillées dans la leçon 1-04 : man ls (manuel complet), ls --help (résumé rapide) et ce cours.

Vos premières commandes, avec leur sortie

Exécutez-les une par une et comparez à la sortie attendue :

$ whoami
cours

whoami répond par votre nom d'utilisateur : celui de la partie gauche du prompt. C'est le compte avec lequel vous travaillez sur cette machine.

$ id
uid=1000(cours) gid=1000(cours) groupes=1000(cours),27(sudo)

id donne votre identité numérique complète. Linux, lui, ne voit que des nombres : votre utilisateur est l'identifiant 1000, votre groupe principal aussi (gid), et vous appartenez au groupe sudo, celui qui autorise à devenir administrateur temporairement. Ne vous inquiétez pas des détails : retenez que vos droits sur la machine découlent de cette identité.

$ pwd
/home/cours/cours

pwd (print working directory) affiche le répertoire dans lequel le shell travaille actuellement. Toute commande sans chemin explicite agira ici. C'est la réponse à la question numéro un du terminal : « où suis-je ? ».

clear

clear efface l'écran. Elle ne produit aucune autre sortie : elle fait juste le ménage. Équivalent clavier : Ctrl+L.

Quand ça ne marche pas : lire une erreur

Il arrivera souvent que quelque chose échoue. Regardons cela franchement dès maintenant :

$ ls -la /hom
ls: impossible d'accéder à '/hom' : Aucun fichier ou dossier de ce type

Lisez ce message lentement, il est très bavard : le programme (ls) dit quoi il n'a pas réussi (« accéder à '/hom' ») et pourquoi (« Aucun fichier ou dossier de ce type »). Ici, la cause saute aux yeux : une faute de frappe, il manque un e.

Le mauvais réflexe est de retaper autre chose au hasard en espérant que ça passe. Le bon réflexe professionnel est de lire l'erreur jusqu'au bout : 90 % des erreurs de terminal se résolvent par la lecture attentive du message. Ce réflexe sera réexploité et formalisé au chapitre 6 (débogage) : c'est l'un des apprentissages les plus rentables de tout le cursus.

Exercice

1. Identifiez votre utilisateur courant avec whoami.
2. Affichez votre répertoire courant avec pwd.
3. Affichez la liste du contenu du répertoire courant sans option, puis avec ls -la. Notez deux différences.
4. Expliquez avec vos propres mots ce que chaque résultat vous apprend.
5. Écrivez une seule ligne de commande qui affiche la liste détaillée du répertoire /etc.
6. Décomposez le prompt alice@vm:~/projets$ : que signifie chaque fragment ?

Résumé

• Le terminal est le cadre de dialogue ; le shell est le programme qui lit, découpe et lance ; les programmes font le travail.
• On développe en ligne de commande parce que les serveurs n'ont pas d'écran, parce qu'une commande est reproductible et parce que tous les outils du métier s'y trouvent.
• Le prompt indique qui (user@machine), où (répertoire courant) et attend ($).
• Une ligne se découpe en commande, options, arguments ; les espaces coupent, les guillemets protègent.
• Une erreur se lit : elle dit quoi et pourquoi.

ls -la /etc

alice@vm:~/projets$