C'est quoi un Shell ?

Mise à jour : 21/09/2024

Le shell est l’un des outils les plus puissants et indispensables pour tout administrateur système travaillant sous Linux. Il s’agit d’une interface en ligne de commande qui permet d’interagir directement avec le système d’exploitation, d’exécuter des commandes, de manipuler des fichiers, et d’automatiser des tâches à travers des scripts. Contrairement aux interfaces graphiques, le shell offre une maîtrise fine et rapide des opérations, ce qui en fait un allié incontournable pour les opérations de maintenance, de gestion des serveurs, et de développement.

Il existe plusieurs types de shells sous Linux, chacun avec ses propres caractéristiques et fonctionnalités. Parmi les plus connus, on trouve Bash, Zsh et Fish. Ce guide se concentre sur les concepts fondamentaux qui sont communs à tous ces shells, sans entrer dans les spécificités de chacun, qui feront l’objet de guides séparés. Mon objectif est de vous fournir une base solide pour comprendre et utiliser efficacement n’importe quel shell sous Linux, en vous préparant à explorer plus en profondeur les particularités de chaque environnement.

Conseils d’apprentissage

Pour bien apprendre, je vous conseille d’avoir un serveur Linux à disposition pour tester ces commandes. Le mieux est d’en virtualiser une sur votre poste de travail avec un outil comme Vagrant.

Historique des Shells Linux

L’histoire des shells Linux est étroitement liée à celle des systèmes d’exploitation Unix, dont Linux est un descendant direct. Comprendre cet historique permet de mieux saisir l’évolution des shells et les raisons pour lesquelles différents types de shells ont émergé au fil du temps.

Les Premiers Shells : Thompson et Bourne

Le premier shell à être développé fut le Thompson Shell, créé par Ken Thompson en 1971 pour le système Unix original. Ce shell était simple mais limité dans ses capacités, offrant un langage de commande rudimentaire pour l’époque. Il permettait principalement l’exécution de commandes et quelques opérations de redirection, mais manquait de fonctionnalités avancées comme le scripting ou la manipulation des processus.

En 1979, Stephen Bourne introduit le Bourne Shell (sh) avec la version 7 d’Unix. Le Bourne Shell a marqué un tournant dans l’histoire des shells en apportant des améliorations significatives, notamment un langage de script puissant, la gestion des variables, et des mécanismes de contrôle de flux comme les boucles et les conditions. Le Bourne Shell est devenu le standard de facto pour les scripts systèmes sous Unix, une position qu’il a conservée pendant de nombreuses années.

Dans les années 1980, alors que le projet GNU cherchait à développer un système d’exploitation libre et complet, le besoin d’un shell libre et puissant se fit sentir. C’est dans ce contexte que Bash (Bourne Again Shell) fut créé par Brian Fox en 1989. Bash a été conçu pour être compatible avec le Bourne Shell tout en intégrant des fonctionnalités issues d’autres shells populaires de l’époque, comme le C Shell (csh) et le Korn Shell (ksh).

Bash est rapidement devenu le shell par défaut sur la plupart des distributions Linux, en raison de sa richesse fonctionnelle et de sa compatibilité avec les scripts existants. Il reste encore aujourd’hui le shell le plus utilisé sous Linux.

Au fil du temps, de nouveaux shells sont apparus pour répondre à des besoins spécifiques ou pour offrir des fonctionnalités supplémentaires par rapport à Bash. Parmi eux, le Zsh (Z Shell), développé dans les années 1990, a gagné en popularité grâce à ses fonctionnalités avancées comme l’autocomplétion contextuelle, la correction automatique des commandes, et une meilleure gestion des plugins. Zsh est souvent préféré par les utilisateurs avancés qui recherchent une personnalisation poussée de leur environnement de travail.

Plus récemment, le Fish (Friendly Interactive Shell), introduit en 2005, a été conçu pour offrir une expérience utilisateur plus conviviale et moderne. Fish se distingue par son interface intuitive, ses suggestions automatiques de commandes, et sa simplicité d’utilisation, tout en abandonnant la compatibilité avec les scripts Bash au profit d’une approche plus directe et accessible.

Aujourd’hui, les shells continuent d’évoluer, en s’adaptant aux besoins croissants des utilisateurs et aux nouvelles technologies. Les contributions de la communauté open source jouent un rôle important dans cette évolution, ajoutant constamment de nouvelles fonctionnalités et améliorations. Le choix d’un shell est souvent une question de préférence personnelle, chaque shell ayant ses propres avantages et inconvénients en fonction des tâches à accomplir.

Cet historique montre comment les shells Linux ont évolué pour devenir des outils puissants et flexibles, chacun apportant des innovations qui enrichissent l’expérience utilisateur. La diversité des shells disponibles aujourd’hui permet à chacun de trouver l’environnement de travail qui lui convient le mieux, tout en bénéficiant de l’héritage riche des systèmes Unix.

Concepts de base d’un Shell

Pour bien comprendre et utiliser un shell sous Linux, il est essentiel de maîtriser certains concepts fondamentaux qui sont communs à tous les types de shells. Ces concepts vous permettront d’interagir efficacement avec le système, d’exécuter des commandes, et de créer des scripts pour automatiser des tâches. Dans cette section, je vais détailler ces concepts clés, en les illustrant par des exemples concrets.

Les Commandes

Au cœur de l’utilisation d’un shell se trouvent les commandes. Une commande est une instruction que vous donnez au système via le shell pour qu’il effectue une tâche spécifique. Les commandes peuvent être des programmes exécutables, des scripts, ou des fonctions intégrées au shell. Par exemple, la commande ls liste les fichiers et répertoires dans le répertoire courant :

ls

Cette commande affiche le contenu du répertoire actuel. Vous pouvez également passer des arguments à une commande pour modifier son comportement. Par exemple, ls -l affiche les fichiers en mode liste détaillée :

ls -l

Les commandes peuvent être simples, comme celles-ci, ou très complexes, incluant des options multiples et des arguments variés. Apprendre à utiliser les commandes de manière efficace est la base de tout travail avec un shell.

Les Alias

Les alias sont des raccourcis créés pour des commandes longues ou fréquemment utilisées. Par exemple, si vous utilisez souvent ls -la, vous pouvez créer un alias pour simplifier son utilisation :

alias ll="ls -la"

Dorénavant, chaque fois que vous taperez ll, le shell exécutera ls -la. Les alias sont très utiles pour personnaliser votre environnement et gagner du temps.

L’Auto-complétion

L’auto-complétion est une fonctionnalité très pratique qui permet de compléter automatiquement des commandes, des noms de fichiers, des répertoires ou même des arguments en tapant seulement une partie du texte et en appuyant sur la touche Tab. Par exemple, si vous tapez cd /etc/ap et que vous appuyez sur Tab, le shell complétera automatiquement par /etc/apache2/ si ce dossier existe.

L’auto-complétion est particulièrement utile pour éviter les erreurs de frappe et accélérer la navigation dans le système de fichiers ou l’exécution des commandes complexes. Cette fonctionnalité est généralement activée par défaut, mais elle peut être personnalisée selon le shell utilisé.

L’Historique des Commandes

Le shell conserve un historique des commandes que vous avez exécutées, vous permettant ainsi de réutiliser facilement des commandes précédentes sans avoir à les retaper. Vous pouvez parcourir l’historique avec les touches fléchées Haut et Bas, ou rechercher une commande spécifique en utilisant Ctrl+R pour lancer une recherche inversée dans l’historique.

Par exemple, pour retrouver une commande grep utilisée récemment, vous pouvez appuyer sur Ctrl+R et commencer à taper grep. Le shell affichera la commande correspondante la plus récente, que vous pourrez exécuter directement en appuyant sur Entrée.

Vous pouvez également afficher l’historique complet des commandes avec la commande history :

history

Chaque commande dans l’historique est associée à un numéro, ce qui permet de réexécuter une commande spécifique en utilisant ! suivi du numéro correspondant, par exemple !45 pour exécuter la 45e commande dans l’historique.

Les Glob Patterns et Expansions

Les glob patterns sont des caractères spéciaux qui permettent de faire correspondre un ensemble de fichiers ou de répertoires avec des noms similaires. Par exemple, le * représente zéro ou plusieurs caractères, tandis que ? représente un seul caractère. Voici quelques exemples d’utilisation des glob patterns :

*.txt : correspond à tous les fichiers avec l’extension .txt.
file?.txt : correspond à des fichiers comme file1.txt, file2.txt, mais pas file10.txt.

En plus des glob patterns, les shells supportent des mécanismes d’expansion pour manipuler les chaînes de caractères ou les variables. Par exemple, la commande suivante crée une archive contenant plusieurs fichiers :

tar -cvf archive.tar file{1,2,3}.txt

Cela revient à exécuter tar -cvf archive.tar file1.txt file2.txt file3.txt.

Les Job Control

Les jobs sont des processus lancés par un shell qui peuvent être gérés de manière interactive. Un job peut être exécuté en avant-plan (par défaut) ou en arrière-plan (avec le symbole & à la fin de la commande). Par exemple :

long_running_command &

Cela lance la commande long_running_command en arrière-plan, ce qui permet de continuer à utiliser le shell pendant que la commande s’exécute.

Les commandes suivantes sont utilisées pour gérer les jobs :

jobs : liste les jobs en cours.
fg %1 : ramène le job numéro 1 au premier plan.
bg %1 : renvoie le job numéro 1 en arrière-plan.
kill %1 : termine le job numéro 1.

La gestion des jobs est particulièrement utile pour les utilisateurs avancés qui exécutent plusieurs tâches simultanément sur un serveur ou une machine locale.

Exécution de Commandes et Scripts

L’exécution de commandes et de scripts est au cœur de l’utilisation d’un shell sous Linux. Cette section vous explique comment lancer des commandes simples, enchaîner plusieurs commandes, créer et exécuter des scripts pour automatiser des tâches répétitives, et gérer l’exécution des scripts dans différents contextes.

Pour exécuter une commande dans un shell, il suffit de la taper et d’appuyer sur Entrée. Le shell interprète la commande, la recherche dans le système, puis l’exécute. Par exemple, pour afficher la liste des fichiers dans le répertoire courant, vous tapez simplement :

ls

Vous pouvez également exécuter une commande avec des arguments. Par exemple, pour afficher les fichiers dans un format détaillé, vous utilisez ls avec l’option -l :

ls -l

Les commandes peuvent également prendre plusieurs arguments. Par exemple, pour copier un fichier d’un répertoire à un autre, vous pouvez utiliser cp avec les chemins source et destination comme arguments :

cp fichier.txt /chemin/destination/

Enchaînement de Commandes

Il est possible d’enchaîner plusieurs commandes sur une seule ligne en utilisant des opérateurs comme ;, &&, et ||.

; permet d’exécuter plusieurs commandes séquentiellement, quelle que soit la réussite ou l’échec de la précédente. Par exemple :

commande1 ; commande2 ; commande3

&& exécute la commande suivante uniquement si la commande précédente a réussi (c’est-à-dire si elle a renvoyé un code de sortie zéro). Par exemple :

mkdir nouveau_dossier && cd nouveau_dossier

Ici, cd nouveau_dossier ne sera exécuté que si mkdir nouveau_dossier réussit.

|| exécute la commande suivante uniquement si la commande précédente a échoué (c’est-à-dire si elle a renvoyé un code de sortie non zéro). Par exemple :

commande1 || commande2

Si commande1 échoue, commande2 sera exécutée.

Création de Scripts

Un script est un fichier texte contenant une série de commandes que le shell exécute l’une après l’autre. Les scripts sont utilisés pour automatiser des tâches qui seraient fastidieuses à effectuer manuellement. Un script simple commence par une ligne appelée shebang (#!) qui indique au système quel shell utiliser pour exécuter les commandes contenues dans le script.

Voici un exemple de script appelé mon_script.sh :

#!/bin/bash
echo "Bonjour, Monde!"

Le shebang #!/bin/bash spécifie que ce script doit être exécuté avec Bash. La commande echo affiche simplement le texte “Bonjour, Monde!” à l’écran.

Pour exécuter ce script, vous devez d’abord lui donner des permissions d’exécution en utilisant la commande chmod :

chmod +x mon_script.sh

Puis, vous pouvez l’exécuter avec :

./mon_script.sh

Plus d’infos sur l’écriture de scripts shell

Redirections et Pipes

L’une des puissances du shell Linux réside dans sa capacité à manipuler les flux d’entrée et de sortie des commandes à l’aide des redirections et des pipes. Ces outils permettent de contrôler où les données sont envoyées, où elles sont lues, et comment les résultats des commandes peuvent être enchaînés pour accomplir des tâches complexes de manière efficace.

Les Redirections de Sortie

Les redirections de sortie permettent de capturer la sortie standard (stdout) d’une commande et de l’envoyer vers un fichier plutôt que de l’afficher à l’écran. La redirection de sortie utilise le symbole >.

Redirection de la Sortie Standard

Par exemple, pour rediriger la sortie de la commande ls vers un fichier nommé liste_fichiers.txt, vous pouvez utiliser :

ls > liste_fichiers.txt

Cela créera le fichier liste_fichiers.txt avec la liste des fichiers et répertoires dans le répertoire courant. Si le fichier existe déjà, son contenu sera écrasé. Si vous souhaitez ajouter à la fin du fichier au lieu de l’écraser, utilisez >> :

ls >> liste_fichiers.txt

Redirection de la Sortie d’Erreur

En plus de la sortie standard, il existe un flux distinct pour les messages d’erreur, appelé sortie d’erreur standard (stderr). Par défaut, stderr est affiché à l’écran, mais vous pouvez également le rediriger vers un fichier avec 2> :

commande_erronée 2> erreurs.txt

Cela capturera les erreurs générées par commande_erronée dans erreurs.txt.

Vous pouvez aussi combiner les deux redirections pour capturer à la fois stdout et stderr dans le même fichier :

commande > tout.txt 2>&1

Ou utiliser l’opérateur &> (dans Bash) pour une syntaxe plus simple :

commande &> tout.txt

Les Redirections d’Entrée

Les redirections d’entrée permettent de fournir des données à une commande à partir d’un fichier plutôt qu’à partir de l’entrée standard (stdin), généralement le clavier. La redirection d’entrée utilise le symbole <.

Par exemple, pour fournir le contenu d’un fichier comme entrée à la commande sort, vous pouvez utiliser :

sort < fichier.txt

Cette commande trie les lignes du fichier fichier.txt et affiche le résultat à l’écran.

Les Pipes

Les pipes sont un autre outil puissant qui permet d’enchaîner plusieurs commandes, en envoyant la sortie d’une commande comme entrée de la commande suivante. Le symbole | est utilisé pour créer un pipe.

Par exemple, pour lister les fichiers dans un répertoire et n’afficher que ceux contenant le mot “log”, vous pouvez utiliser :

ls -l | grep log

Ici, ls -l génère une liste détaillée des fichiers, et grep log filtre cette liste pour ne conserver que les lignes contenant le mot “log”.

Un autre exemple courant est l’utilisation de wc pour compter le nombre de lignes, de mots, ou de caractères dans un fichier après l’avoir filtré avec grep :

grep "motif" fichier.txt | wc -l

Cette commande affiche le nombre de lignes dans fichier.txt qui contiennent le “motif” spécifié.

Combinaison de Redirections et de Pipes

Les redirections et pipes peuvent être combinés pour accomplir des tâches plus complexes. Par exemple, vous pourriez vouloir rediriger la sortie d’une commande vers un fichier tout en envoyant les erreurs vers un autre fichier, tout en utilisant un pipe pour traiter une partie de la sortie :

commande1 2> erreurs.txt | commande2 > sortie.txt

Dans cet exemple, commande1 envoie ses erreurs à erreurs.txt tandis que sa sortie standard passe à commande2 via un pipe, et la sortie de commande2 est redirigée vers sortie.txt.

Les Here Documents (<<)

Un Here Document est une forme spéciale de redirection qui permet de fournir plusieurs lignes de texte en tant qu’entrée pour une commande. Cela est utile pour les scripts où vous devez passer une grande quantité de texte à une commande.

Voici un exemple d’utilisation d’un Here Document avec cat pour créer un fichier texte directement depuis le shell :

cat <<EOL > nouveau_fichier.txt
Ceci est la première ligne.
Ceci est la deuxième ligne.
Et ainsi de suite...
EOL

Le texte entre <<EOL et EOL est passé à la commande cat, qui le redirige dans nouveau_fichier.txt. Le mot clé EOL est un délimiteur qui peut être remplacé par tout autre mot non réservé.

Null Device (/dev/null)

/dev/null est un fichier spécial qui rejette tout ce qui lui est écrit. Il est souvent utilisé en redirection pour supprimer une sortie dont vous n’avez pas besoin.

Par exemple, pour exécuter une commande mais ignorer complètement sa sortie, vous pouvez rediriger la sortie standard et l’erreur standard vers /dev/null :

commande > /dev/null 2>&1

Cela exécute commande sans afficher de sortie, ce qui est utile dans les scripts où vous ne voulez pas que certaines commandes génèrent du bruit inutile.

Les Variables d’Environnement

Les variables d’environnement sont des éléments clés du fonctionnement d’un shell sous Linux. Elles permettent de stocker des informations cruciales utilisées par le système d’exploitation, les programmes, et les scripts pour fonctionner correctement. Dans cette section, je vais expliquer ce que sont les variables d’environnement, comment les définir, les modifier, et les utiliser, ainsi que leur rôle dans les scripts.

Qu’est-ce qu’une Variable d’Environnement ?

Une variable d’environnement est une paire nom-valeur qui est utilisée pour configurer le comportement du système et des applications. Ces variables peuvent contenir des informations sur l’utilisateur, les chemins d’accès aux programmes, les paramètres de configuration, et bien plus encore.

Par exemple, la variable PATH est l’une des variables d’environnement les plus couramment utilisées. Elle contient une liste de répertoires dans lesquels le shell recherche les programmes exécutables lorsque vous tapez une commande. Voici comment afficher la valeur actuelle de la variable PATH :

echo $PATH

Cette commande affiche le contenu de la variable PATH, chaque répertoire étant séparé par deux-points (:).

Définir et Modifier des Variables d’Environnement

Vous pouvez définir ou modifier une variable d’environnement en utilisant la commande export. Par exemple, pour définir une nouvelle variable d’environnement nommée MON_VARIABLE avec la valeur Bonjour, vous pouvez utiliser :

export MON_VARIABLE="Bonjour"

Cette variable est maintenant disponible dans la session actuelle du shell et peut être utilisée comme suit :

echo $MON_VARIABLE

Cela affichera “Bonjour”. Pour modifier la valeur d’une variable existante, il suffit de réutiliser la commande export avec une nouvelle valeur :

export MON_VARIABLE="Bonjour, Monde!"

Les variables définies de cette manière sont disponibles uniquement dans la session actuelle du shell. Si vous ouvrez une nouvelle session, les variables ne seront plus définies, à moins que vous les ajoutiez à un fichier de configuration comme .bashrc (pour Bash), .zshrc (pour Zsh), ou .config/fish/config.fish (pour Fish).

Les Variables d’Environnement Systèmes

Certaines variables d’environnement sont préconfigurées par le système et sont essentielles au bon fonctionnement de Linux. Voici quelques exemples courants :

PATH : Liste des répertoires où le shell cherche les commandes exécutables.
HOME : Chemin du répertoire personnel de l’utilisateur.
USER : Nom de l’utilisateur actuel.
SHELL : Chemin vers le shell par défaut de l’utilisateur.
LANG : Langue et paramètres régionaux du système.

Vous pouvez afficher la valeur de n’importe laquelle de ces variables en utilisant echo, par exemple :

echo $HOME

Utilisation des Variables dans les Scripts

Les variables d’environnement sont souvent utilisées dans les scripts pour rendre les scripts plus flexibles et dynamiques. Par exemple, un script peut utiliser la variable HOME pour travailler avec les fichiers dans le répertoire personnel de l’utilisateur, quelle que soit l’identité de l’utilisateur qui exécute le script.

Voici un exemple simple de script qui utilise une variable d’environnement :

#!/bin/bash
echo "Votre répertoire personnel est : $HOME"

Lorsque ce script est exécuté, il affiche le répertoire personnel de l’utilisateur actuel. Les variables peuvent également être utilisées pour passer des informations entre différentes parties d’un script ou pour configurer l’environnement d’exécution du script.

Variables Locales et Globales

Les variables définies avec export sont des variables globales ou variables d’environnement, ce qui signifie qu’elles sont disponibles dans la session du shell et pour tous les processus enfants (comme les scripts ou les commandes exécutées à partir de cette session).

En revanche, une variable locale est définie sans export et n’est disponible que dans la session du shell ou dans le script où elle a été définie. Par exemple :

MON_VARIABLE_LOCALE="Bonjour"
echo $MON_VARIABLE_LOCALE

Cette variable n’est pas exportée, donc elle ne sera pas disponible dans les processus enfants.

Supprimer des Variables d’Environnement

Pour supprimer une variable d’environnement, vous pouvez utiliser la commande unset :

unset MON_VARIABLE

Cela supprimera la variable MON_VARIABLE de l’environnement de la session actuelle du shell.

Fichiers de Configuration et Variables d’Environnement

Pour que des variables d’environnement soient disponibles à chaque démarrage d’une session shell, elles doivent être ajoutées aux fichiers de configuration du shell. Pour Bash, par exemple, vous pouvez ajouter la ligne suivante à votre fichier .bashrc :

export MON_VARIABLE="Bonjour"

Chaque fois que vous ouvrirez un nouveau terminal, cette variable sera automatiquement définie.

Sécurité et Bonnes Pratiques

La sécurité est une préoccupation majeure pour toute personne utilisant un système Linux, que ce soit sur un serveur, un poste de travail ou tout autre type de machine. Les shells sont des outils puissants qui permettent d’exécuter une large gamme de commandes, et une mauvaise utilisation peut entraîner des erreurs coûteuses ou des vulnérabilités. Dans cette section, je vais aborder les meilleures pratiques de sécurité pour l’utilisation des shells Linux, ainsi que des conseils pour minimiser les risques.

Maïtriser les Permissions

Sous Linux, chaque fichier et répertoire a un ensemble de permissions qui contrôlent qui peut lire, écrire, ou exécuter ces fichiers. Les permissions sont divisées en trois catégories : propriétaire, groupe, et autres.

Lecture (r) : Le fichier peut être lu.
Écriture (w) : Le fichier peut être modifié.
Exécution (x) : Le fichier peut être exécuté comme un programme.

Vous pouvez visualiser les permissions d’un fichier ou d’un répertoire avec la commande ls -l :

ls -l fichier.txt

Cette commande affiche les permissions sous forme d’une chaîne de caractères. Par exemple, -rw-r--r-- signifie que le propriétaire peut lire et écrire, le groupe peut lire, et les autres peuvent également lire, mais personne d’autre ne peut écrire ou exécuter le fichier.

Les permissions peuvent être modifiées à l’aide de la commande chmod. Par exemple, pour rendre un script exécutable, vous pouvez ajouter la permission d’exécution pour le propriétaire du fichier :

chmod u+x script.sh

Pour rendre un fichier lisible et exécutable par tout le monde, mais modifiable uniquement par le propriétaire, utilisez :

chmod 755 fichier.sh

Chaque fichier et répertoire a un propriétaire et un groupe associés. Vous pouvez changer le propriétaire d’un fichier avec chown et son groupe avec chgrp :

chown utilisateur fichier.txt
chgrp groupe fichier.txt

Pour modifier à la fois le propriétaire et le groupe en une seule commande :

chown utilisateur:groupe fichier.txt

Éviter les Commandes Dangereuses

Certaines commandes peuvent causer des dommages importants si elles sont mal utilisées. Voici quelques exemples de commandes à utiliser avec une extrême précaution :

rm -rf / : Cette commande supprime de manière récursive tous les fichiers du système. Une simple erreur de frappe peut détruire un système entier.
dd : Un outil puissant pour copier des fichiers bruts, mais une mauvaise utilisation peut entraîner une perte de données importante. Par exemple, la commande suivante effacera tout le disque dur :

dd if=/dev/zero of=/dev/sda

mkfs : Cette commande formate un système de fichiers. Utilisez-la uniquement si vous êtes sûr de vouloir effacer les données sur une partition.

Vérification des Scripts et Commandes

Avant d’exécuter des scripts ou des commandes téléchargés ou reçus de sources externes, inspectez toujours le code pour détecter des comportements inattendus ou malveillants. Utilisez cat, less ou nano pour lire le contenu des scripts avant de les exécuter :

cat script.sh

Utilisation de Variables avec Précaution

Lors de l’utilisation de variables dans les scripts, soyez prudent avec les expansions de variables, surtout celles provenant de l’entrée de l’utilisateur. Les expansions non sécurisées peuvent introduire des vulnérabilités telles que l’injection de commandes. Par exemple, au lieu d’utiliser directement une variable dans une commande :

rm -rf $VARIABLE

Vérifiez la valeur de la variable pour éviter les erreurs dangereuses :

if [[ -n "$VARIABLE" ]]; then
  rm -rf "$VARIABLE"
fi

Utilisation de `set` pour Durcir les Scripts

Vous pouvez renforcer la sécurité de vos scripts en utilisant certaines options de set :

set -e : Arrête l’exécution du script en cas d’erreur.
set -u : Provoque une erreur si une variable non définie est utilisée.
set -o pipefail : Rend un pipeline échouant si l’une des commandes échoue.

Voici comment activer ces options dans un script :

#!/bin/bash
set -euo pipefail

Le Mécanisme de Chargement des Profils Utilisateurs

Lorsqu’un utilisateur ouvre une session shell sous Linux, un certain nombre de scripts de configuration, appelés profils utilisateurs, sont automatiquement chargés pour configurer l’environnement de travail. Ces profils permettent de définir des variables d’environnement, des alias, des fonctions, et d’autres paramètres spécifiques à l’utilisateur ou à la session. Dans ce chapitre, je vais détailler le mécanisme de chargement de ces profils, en expliquant comment et quand ils sont chargés, et comment les personnaliser.

Types de Sessions et Scripts de Configuration

Le shell distingue principalement deux types de sessions : interactives et non-interactives, ainsi que deux sous-catégories : login et non-login.

Session Login : Une session login est celle où l’utilisateur doit s’authentifier (en entrant son nom d’utilisateur et son mot de passe), comme lors d’une connexion SSH ou d’une session sur un terminal TTY.
Session Non-login : Une session non-login est généralement une nouvelle instance de shell ouverte depuis un shell existant, par exemple en ouvrant un nouvel onglet dans un terminal graphique.
Session Interactive : Une session interactive est celle où l’utilisateur interagit directement avec le shell via une interface de commande.
Session Non-interactive : Une session non-interactive est celle où un shell exécute des commandes automatiquement, comme lors de l’exécution d’un script.

Fichiers de Configuration Communément Utilisés

Selon le type de session, différents fichiers de configuration sont chargés :

/etc/profile : Ce fichier est exécuté pour chaque utilisateur lors de la connexion à une session login. Il est utilisé pour configurer l’environnement système globalement, applicable à tous les utilisateurs.
~/.bash_profile : Ce fichier est spécifique à Bash et est chargé lors d’une session login pour l’utilisateur actuel. S’il existe, il est prioritaire sur ~/.bash_login et ~/.profile.
~/.bash_login : Ce fichier est chargé si ~/.bash_profile n’existe pas.
~/.profile : Fichier de configuration plus générique, il est utilisé par plusieurs shells (y compris Bash, Zsh, sh). Il est exécuté si ni ~/.bash_profile ni ~/.bash_login n’existent.
~/.bashrc : Chargé lors de chaque session interactive non-login. C’est ici que vous définissez généralement vos alias, vos fonctions, et d’autres personnalisations spécifiques à Bash.
/etc/bash.bashrc : C’est la version globale de ~/.bashrc, appliquée à tous les utilisateurs. Il est généralement chargé par le script ~/.bashrc.
~/.bash_logout : Ce fichier est exécuté lors de la déconnexion d’une session login. Il peut contenir des commandes pour nettoyer ou sauvegarder l’état de la session.

Ordre de Chargement des Fichiers

Lorsqu’une session shell démarre, les fichiers de configuration sont chargés dans un ordre spécifique, qui dépend du type de session :

Session Login (ex. : première connexion via SSH) :
- /etc/profile
- ~/.bash_profile, ou ~/.bash_login, ou ~/.profile (le premier trouvé est exécuté)
Session Non-login (ex. : ouverture d’un nouvel onglet terminal) :
- ~/.bashrc (généralement, ~/.bash_profile ou ~/.profile appelle explicitement ~/.bashrc pour garantir que les configurations sont chargées aussi bien pour les sessions login que non-login)
Session Non-interactive (ex. : exécution d’un script) :
- Pas de fichier de configuration spécifique chargé par défaut, sauf si le script le demande explicitement via la commande source ou en appelant directement le fichier de configuration.

Personnalisation des Profils

Vous pouvez personnaliser votre environnement shell en modifiant les fichiers de configuration appropriés dans votre répertoire personnel (~). Par exemple :

Pour ajouter un alias utilisable dans toutes vos sessions interactive non-login, ajoutez-le dans ~/.bashrc :

alias ll='ls -la'

Pour définir une variable d’environnement spécifique à vos sessions login (comme ajouter un chemin à PATH), ajoutez-la dans ~/.bash_profile :

export PATH=$PATH:/chemin/vers/un/dossier

Chargement Manuel des Profils

Il peut être nécessaire de recharger manuellement un fichier de configuration après l’avoir modifié sans redémarrer la session du shell. Cela peut être fait avec la commande source ou le point (.) suivi du fichier à recharger. Par exemple, pour recharger ~/.bashrc après l’avoir modifié :

source ~/.bashrc

Ou de manière équivalente :

. ~/.bashrc

Conclusion

À travers ce guide, nous avons exploré les concepts fondamentaux et les fonctionnalités communes aux shells Linux, tout en approfondissant des sujets tels que l’exécution de commandes, la gestion des processus, la manipulation des variables d’environnement, et les bonnes pratiques de sécurité. La maîtrise du shell est un atout essentiel pour tout administrateur système ou utilisateur avancé, car elle permet d’exploiter pleinement la puissance et la flexibilité de Linux.

Maintenant que vous avez une compréhension solide des shells Linux, voici quelques conseils pour continuer à approfondir vos compétences :

Exploration de Shells Spécifiques : Ce guide a couvert les concepts généraux communs à tous les shells. Pour aller plus loin, je vous recommande d’explorer des guides spécifiques à des shells particuliers comme Bash, Zsh, ou Fish. Chacun de ces shells offre des fonctionnalités avancées et des options de personnalisation qui méritent une attention particulière.
Écriture de Scripts Complexes : Si vous êtes déjà à l’aise avec les scripts de base, essayez d’écrire des scripts plus complexes qui automatisent des tâches spécifiques à vos besoins. L’intégration de conditions, de boucles, et de structures de contrôle peut transformer vos scripts en outils puissants pour la gestion quotidienne des systèmes.