
Table des matières
Qu’est-ce qu’un Shell ?
Un shell (ou coquillage en français) est le squelette externe d’un mollusque.
La majorité des mollusques à coquille se trouve dans la classe des gastéropodes comme les escargots, et dans celle des bivalves comme les huitres.

Ok, on plaisante, ne pars pas tout de suite…
Le shell
Un shell est une interface en ligne de commande se situant entre l’utilisateur et un système d’exploitation.
Les commandes saisies dans un shell sont interprétées et peuvent déclencher l’exécution de programmes ou d’opérations dans un format qui est (en général) lisible par un humain.
Ci-dessous, la commande date affiche la date complète avec un format standard et lisible.
date

La plupart des distributions Linux modernes sont configurées pour utiliser les très communs Bourne shell (sh), Bourne-again shell (bash) ou Z shell (zsh).
/bin/sh

Un shell Linux est généralement accessible via un émulateur de terminal depuis l’interface graphique (GUI), mais d’autres moyens existent.
Par exemple, il est possible d’utiliser une connexion console physique en série ou une connexion à distance Secure Shell (SSH).

Dans le registre des connexions console physique, on retrouve très souvent des interfaces de configuration de secours, permettant d’accéder à un shell d’administration du matériel via un port physique sur l’équipement.
Un bon exemple serait l’accès console à un commutateur ou routeur Cisco.

Les shells présentés ci-dessus fonctionnent en mode interactif, ce qui veut dire que chaque commande est exécutée immédiatement lorsque l’utilisateur appuie sur la touche [ENTER], et le résultat est affiché avant de pouvoir saisir une nouvelle commande.

Source : https://en.wikipedia.org/wiki/Unix_shell
Bonus
- Essaye de trouver des exemples concrets d’accès console physique, en incluant l’équipement, le port physique et le câble associé.
- Quels sont les cas d’utilisation les plus courants de ce genre de connexion physique ?
- Compare Bash et Zsh. Quelles sont les principales différences ?
Les types de commandes
Commandes internes et externes
Les commandes saisies dans un shell peuvent être de deux types, interne ou externes, ce qui peut être vérifié en utilisant la commande type.
Les commandes dites internes sont des commandes embarquées par le shell et seront disponibles sur n’importe quel système Linux.
type pwd

Les commandes dites externes, d’autre part, permettent d’exécuter des programmes installés sur le système Linux actuel.
L’utilisation de la commande type permet d’afficher le chemin absolu vers l’exécutable auquel la commande fait référence.
type bash

Certaines commandes peuvent être à la fois interne et externe, et l’utilisation de l’option -a avec la commande type permet de le vérifier.
type -a pwd

Dans ce genre de cas, la version interne de la commande sera toujours exécutée en premier, puis le shell tentera de trouver la version externe en vérifiant si l’exécutable existe dans les chemins indiqués par la variable d’environnement $PATH.
Il est possible d’afficher ces chemins en utilisant la commande echo, chaque chemin étant séparé par le caractère spécial « : » .
Comme tu peux le constater, l’exécutable pwd est bien présent dans les chemins /usr/bin et /bin listés dans la variable $PATH.
echo $PATH

Une autre manière de lancer une commande externe pourrait donc être d’utiliser directement le chemin absolu menant à son binaire exécutable.
/usr/bin/pwd
## ou
/bin/pwd

Bonus
- Trouve une liste des commandes internes courantes.
- Comment (et pourquoi) désactiver les commandes internes ?
- Que se passerait-il si le contenu de la variable $PATH était effacé ?
Options et arguments
Les options
Les options sont indiquées par le caractère spécial « -« , suivit par un caractère (une lettre ou un chiffre) qui aura pour rôle de modifier le comportement ou la présentation visuelle de la commande.
Pour préparer les exemples suivants, crée et enregistre le script ci-dessous en utilisant nano (ou autre éditeur de texte).
nano script.sh
#!/bin/bash
uname -a
id
hostname

Pour sauvegarder le fichier, appuie sur [Ctrl-X], puis [Y], et enfin [Enter].
Si tu es de retour dans ton shell habituel, tout s’est bien passé !
Prenons comme exemple la commande ls, qui a pour effet de lister les fichiers et répertoires.
L’option -l permettra ici d’afficher le contenu sous forme de liste détaillée, alors que l’option -a permettra d’afficher les fichiers cachés.
ls
ls -l
ls -a

Note qu’il est possible de combiner les options en une seule suite de caractères, ou de les enchainer.
ls -al
## ou
ls -a -l

Les arguments
Les arguments, de leur côté, sont des paramètres contextuels envoyés à l’application et sont souvent essentiels pour obtenir le résultat voulu.
Par exemple, donner un chemin à la commande ls listera le contenu présent dans le répertoire ciblé.
ls /var/lib

Note que la majorité des commandes et programmes utiliseront des valeurs par défaut si aucun argument n’est fourni.
Par exemple, la commande ls exécutée sans fournir de chemin listera le contenu du répertoire actuel.

Les arguments et les options peuvent être combinés, certains arguments acceptant même des options et vice-versa.
L’ordre de ces arguments et options est parfois strict, soit prudent avec celui-ci !
Une des options les plus utiles avec les commandes internes sera –help pour afficher l’aide de base, et la majorité des commandes externes en bénéficieront également (attention aux exceptions).
Note que certaines options courtes possèdent des versions longues, souvent plus parlantes… mais produisent fondamentalement le même résultat.
ls --help

Mettons tout ça en pratique avec une commande qui listera le contenu détaillé du répertoire /var/lib en incluant les fichiers et répertoires cachés.
ls -al /var/lib

Exemple
Prenons un second exemple, plus complexe, avec la commande grep pour chercher la chaine de caractères « uname » dans le fichier script.sh (deux arguments contextuels d’affilés), et en affichant une ligne supplémentaire en dessous avec l’option -A 1.
grep "uname" ./script.sh -A 1

Note que changer l’ordre brise la logique arguments/options, et que l’argument 1 est rattaché à l’option A, pas à la commande grep.
grep -A "uname" ./script.sh 1

Pour aller chercher des informations sur les options et arguments disponibles, nous allons cette fois faire appel fois au manuel du programme avec la commande man.
Note qu’il y a globalement plus d’informations disponibles, qu’elles sont consultable en mode interactif et classées suivant des catégories.
man grep

Quitte le mode interactif quand vous aurez terminé votre exploration en appuyant sur la touche [Q].
Bonus
- Trouver 4 moyens différents d’obtenir de l’aide sur un programme ou une commande.
- Quelles sont les différences entre ces 4 méthodes ?
- Explore les options de la commande ls pour reproduire le résultat ci-dessous :

Les scripts shell
Le scripting
Le shell peut également être considéré comme un langage de scripting à part entière, permettant aux utilisateurs de sauvegarder une séquence de commande dans des fichiers en script shell qui vont être exécutés d’un seul bloc.

Un script shell peut être créé avec n’importe quel éditeur de texte, en ajoutant un en-tête shebang (#!) suivi du chemin vers le shell utilisé (/bin/bash ici).
Le corps du script doit contenir les commandes telles qu’elles auraient été saisies dans un shell interactif, et chaque retour à la ligne fera office de nouveau pas dans l’exécution (comme la touche [Enter] en mode interactif).
Exemple
Si ce n’est pas déjà fait, crée et enregistre le script ci-dessous en utilisant nano (ou autre éditeur de texte).
nano script.sh
#!/bin/bash
uname -a
id
hostname

Pour sauvegarder le fichier, appuie sur [Ctrl-X], puis [Y], et enfin [Enter].
Si tu es de retour dans ton shell habituel, tout s’est bien passé !
Avant de pouvoir faire une démonstration, nous allons devoir le rendre exécutable par notre utilisateur (entre autres…) avec la commande chmod.
Attention à bien adapter le chemin absolu vers ton fichier, notamment si ton nom d’utilisateur est différent.
chmod +x /home/user/script.sh
Pour exécuter le script, saisis son chemin absolu complet, comme si c’était un exécutable… et c’est d’ailleurs ce qu’il est devenu.
/home/user/script.sh
Note qu’il est aussi possible d’utiliser le chemin relatif… mais nous reviendrons sur cette notion plus tard.
./script.sh
Comme tu peux le constater, chaque commande a été exécutée une par une et le résultat a été affiché en un seul bloc dans notre terminal, séparé par un retour à la ligne à chaque étape.

Source : https://en.wikipedia.org/wiki/GNU_nano
Bonus
- Que se passe-t’il si nous remplaçons l’en-tête du script par #!/bin/sh ?
- Expliquer ce que la commande chmod a réalisé comme opération sur notre script.
Chemins relatifs et absolus
Comme tu l’as vu précédemment, les fichiers et répertoires sont organisés suivant une arborescence, débutant par la racine (notée /) et terminant par les branches (par exemple /home/user/script.sh).

Chemin absolu
Si le chemin vers un répertoire ou fichier est renseigné en totalité, le chemin est dit absolu (encore une fois l’exemple /home/user/script.sh).
Dans notre exemple, l’utilisateur se nomme bien user et le chemin absolu est correct.
Mais que se passerait-il si l’utilisateur ayant créé le script était nommé john ?
Le chemin absolu menant vers le script serait alors /home/john/script.sh, ce qui casserait tous les scripts ou commandes utilisant le chemin absolu /home/user/script.sh.

Chemin relatif
Nous devrons alors utiliser des raccourcis, alias et variables, pour atteindre notre cible sans forcément connaitre le chemin absolu, ou simplement pour le raccourcir.
Par exemple, il est possible d’utiliser le raccourci « . » qui mènera au répertoire actuel, ou le raccourci « .. » qui mènera au répertoire précédent dans la hiérarchie.
Si nous reprenons l’exemple de john, celui-ci pourra utiliser le raccourci « . » pour être certain d’exécuter le script présent dans son répertoire actuel.
./script.sh

Note qu’utiliser le nom de fichier du script seul (comme une commande externe) ne fonctionnera pas car le répertoire actuel n’est pas présent dans la variable d’environnement $PATH… et nous préciserons ce point plus tard.

Bonus
- Trouver un moyen de rendre le script exécutable en saisissant simplement son nom de fichier depuis n’importe quel répertoire… comme une commande externe.
- Les raccourcis « . » et « .. » peuvent être trouvés quasiment partout… Trouve les et explique comment ils fonctionnent.
Savoir se déplacer
Une des premières étapes est de savoir modifier le répertoire courant, soit pour explorer et organiser l’arborescence du système, soit pour correctement exécuter nos programmes.

La séquence suivante te permettras d’expérimenter plusieurs raccourcis et notations de chemin différentes.
Pour commencer, affiche le répertoire actuel avec la commande pwd.
pwd
Déplace-toi dans le répertoire ciblé en utilisant la commande cd.
cd /var/lib
Remonte d’un cran dans l’arborescence en utilisant le raccourci « .. ».
cd ..
Reviens dans le répertoire ciblé en utilisant la notation relative.
cd lib/
Puis remonte jusqu’à la racine en enchainant deux fois le raccourci « .. ».
cd ../..
Pour finir, retourne dans ton répertoire home en utilisant le raccourci « ~ ».
cd ~

Gestion basique des fichiers et répertoires
Création
Savoir créer et organiser tes répertoires ou fichier est essentiel pour la gestion de votre système.
La création d’un répertoire peut être effectuée avec la commande mkdir, suivi du chemin relatif ou absolu en tant qu’argument.
mkdir testdir
La commande touch peut être utilisée pour créer des fichiers (sans les ouvrir) en spécifiant le chemin en tant qu’argument.
Utilise ls pour vérifier la bonne création du répertoire et du fichier.
touch /home/user/testdir/test.txt
ls -al /home/user/testdir/

Note que certaines commandes, telles que ls ou touch, vérifieront le répertoire courant si un chemin absolu n’est pas donné comme argument contextuel et accepterons plusieurs formats différents, incluant les raccourcis.
ls testdir/
touch testdir/test2.txt
ls ./testdir/

Effacer, copier, déplacer, renommer
Effacer un fichier peut être fait avec la commande rm… (attention à ne pas effacer n’importe quoi !)
rm testdir/test2.txt

Copier un fichier ou un répertoire peut être réalisé avec la commande cp, en fournissant comme argument l’objet à copier, suivi de la destination… (attention à ne pas écraser n’importe quoi !)
cp test.txt testdir/test2.txt
Déplacer un fichier est réalisé de la même façon en utilisant la commande mv, mais si un fichier portant le même nom s’y trouve déjà, il sera écrasé sans avertissement… (attention à ne pas écraser n’importe quoi !)
mv testdir/test.txt test2.txt

Note que renommer un fichier ou répertoire ne se fait pas avec une commande dédiée, mais peut être réalisé simplement en utilisant cp ou mv avec un nom différent comme cible.
cp testdir/test.txt testdir/test3.txt
mv testdir testdir2

Bonus
- Explique les effets de la commande cp test.txt ~/../.
- Explique les effets de la commande
mv test.txt test2.txt
Auto-complétion
Saisir de longues commandes à longueur de journée devient rapidement fastidieux et barbant… en plus de présenter un facteur d’erreur humaine non-négligeable.
Heureusement, l’auto-complétion est là pour te sauver d’un burnout prématuré…
Appuyer sur la touche [TAB] lors de la saisie de commande permet de compléter automatiquement la saisie en cours, si le système arrive à définir correctement le contexte.
Parfois, le système ne pourra choisir automatiquement et te présenteras les options disponibles.
Pour illustrer avec un exemple, commence à saisir un chemin vers un répertoire et appuie sur la touche [TAB] avant d’avoir terminé.
cd /home [TAB]
Essaye également l’auto-complétion dans un cas où plusieurs options sont disponible, comme dans le cas de la commande cd avec un plusieurs répertoires possibles.
cd /home/user/ [TAB]

Note qu’il est possible d’ajouter des caractères après avoir affiché les options, ce qui permet d’utiliser à nouveau l’auto-complétion et de finaliser notre choix.
Crée deux nouveaux répertoires pour illustrer l’exemple suivant.
mkdir testdir3
mkdir testdir450
cd /home/user/testdir [TAB] [4]

[TAB] [Enter]

Historique de commandes
Toutes les commandes saisies dans un terminal interactif sont enregistrées dans l’historique du shell, permettant aux utilisateurs de les retrouver pour les réutiliser rapidement, ou pour vérifier ce qui a été fait précédemment.
Pour ressaisir rapidement une commande, navigue avec les flèches [Up] et [Down] de ton clavier jusqu’à la commande voulue et appuie sur [Enter] pour la valider.

Pour explorer l’historique de manière plus lisible (et moins dangereuse), utilise la commande history.
history

Cet historique est également stocké dans le fichier caché /home/user/.bash_history.
cat /home/user/.bash_history

N’oublie pas de l’effacer en riant frénétiquement pour devenir invisible, et faire péter le compteur de cringe.

Pour la partie suivante, c’est par ici !