C'est quoi un Shell ?
Mise à jour :
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 commefile1.txt
,file2.txt
, mais pasfile10.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/bashecho "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.txtCeci 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/bashecho "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.txtchgrp 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/bashset -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.
- Pas de fichier de configuration spécifique chargé par défaut, sauf si le
script le demande explicitement via la commande
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.