Les scripts shell - Niveau 1
Le shell est l’interpréteur de commandes de Linux. C’est un binaire qui ne fait pas partie du noyau, mais forme une couche supplémentaire, d’où son nom de "coquille".
Il analyse les commandes saisies par l’utilisateur puis les fait exécuter par le système.
Il existe plusieurs shells, tous partageant des points communs. L’utilisateur est libre d’utiliser celui qui lui convient le mieux parmi (entre autres) :
-
le Bourne-Again shell (
bash
), -
le Korn shell (
ksh
), -
le C shell (
csh
), -
etc.
Le bash
est présent par défaut sur les principales distributions Linux.
Il se caractérise par ses fonctionnalités pratiques et conviviales.
Le shell est aussi un langage de programmation basique qui, grâce à quelques commandes dédiées, permet :
-
l’utilisation de variables,
-
l’exécution conditionnelle de commandes,
-
la répétition de commandes.
Les scripts en shell ont l’avantage d’être réalisables rapidement et de manière fiable, sans compilation ni installation de commandes supplémentaires. Un script shell n’est qu’un fichier texte sans enluminures (gras, italique, etc.).
Si le shell est un langage de programmation « basique », il n’en reste pas moins très puissant et parfois plus rapide qu’un mauvais code compilé. Si vous n’en êtes pas convaincu, vous pouvez lire, même s’il commence à dater, l’article suivant : Entretien avec un débutant en bash de Étienne Dublé. Cela vous permettra de réfléchir à votre façon de coder. |
Pour écrire un script shell, il suffit de réunir dans un même fichier texte toutes les commandes nécessaires.
En rendant ce fichier exécutable, le shell le lira séquentiellement et exécutera une à une les commandes le comportant.
Il est aussi possible de l’exécuter en passant le nom du script comme un argument au binaire bash
.
Lorsque le shell rencontre une erreur, il affiche un message permettant d’identifier le problème mais continue l’exécution du script. Mais il existe des mécaniques pour stopper l’exécution d’un script en cas de survenance d’une erreur. Les erreurs propres aux commandes sont également affichées à l’écran ou à l’intérieur de fichiers.
Qu’est ce qu’un bon script ? C’est un script :
-
fiable : son fonctionnement est irréprochable même en cas de mauvaise utilisation ;
-
commenté : son code est annoté pour en faciliter la relecture et les futures évolutions ;
-
lisible : le code est indenté à bon escient, les commandes sont aérées, …
-
portable : le code fonctionne sur tout système Linux, gestion des dépendances, gestion des droits, etc.
Premier script
Pour commencer l’écriture d’un script shell, il est pratique d’utiliser un éditeur de texte gérant la coloration syntaxique.
vim
, par exemple, est un outil adapté à cela.
Le nom du script devra respecter quelques règles :
-
pas de nom de commandes existantes ;
-
ne contenant que des caractères alphanumériques, c’est-à-dire pas de caractère accentué ni d’espace ;
-
extension en
.sh
pour indiquer qu’il s’agit d’un script shell.
#!/usr/bin/env bash
#
# Auteur : Antoine Le Morvan
# Date : Janvier 2019
# Version 1.0.0 : Affiche le texte "Hello world !"
#
# Affiche un texte à l'écran :
echo "Hello world !"
Pour pouvoir exécuter ce script, en argument du bash
:
$ bash hello-world.sh
Hello world !
Ou, plus simplement, après lui avoir donné le droit d’exécution :
$ chmod u+x ./hello-world.sh
$ ./hello-world.sh
Hello world !
Notez que pour exécuter le script, celui-ci a été appelé avec « |
La première ligne à écrire dans tout script permet d’indiquer le nom du binaire du shell à utiliser pour l’exécuter.
Si vous désirez utiliser le shell ksh
ou le langage interprété python
, vous remplaceriez la ligne :
#!/usr/bin/env bash
par :
#!/usr/bin/env ksh
ou par :
#!/usr/bin/env python
Tout au long de l’écriture, il faudra penser à la relecture du script en utilisant notamment des commentaires :
-
une présentation générale, en début, pour indiquer le but du script, son auteur, sa version, son utilisation, etc.
-
au cours du texte pour aider à la compréhension des actions.
Les commentaires peuvent être placés sur une ligne à part ou bien à la fin d’une ligne contenant une commande.
Exemple :
# Ce programme affiche la date
date # Cette ligne est la ligne qui affiche la date !
Variables
Comme dans tout langage de programmation, le script shell utilise des variables. Elles servent à stocker des informations en mémoire pour les réutiliser à volonté au cours du script.
Une variable est créée au moment où elle reçoit son contenu. Elle reste valide jusqu’à la fin de l’exécution du script ou à la demande explicite de l’auteur du script. Puisque le script est exécuté séquentiellement du début à la fin, il est impossible de faire appel à une variable avant qu’elle ne soit créée.
Le contenu d’une variable peut être modifié au cours du script, la variable continue d’exister. Si le contenu est supprimé, la variable reste active mais ne contient rien.
La notion de type de variable en script shell est possible mais est très peu utilisée. Le contenu d’une variable est toujours un caractère ou une chaîne de caractères. |
#!/usr/bin/env bash
#
# Auteur : Antoine Le Morvan
# Date : Janvier 2019
# Version 1.0.0 : Sauvegarde dans /root les fichiers passwd, shadow, group et gshadow
#
# Variables globales
FICHIER1=/etc/passwd
FICHIER2=/etc/shadow
FICHIER3=/etc/group
FICHIER4=/etc/gshadow
# Dossier destination
DESTINATION=/root
# Nettoie l'écran :
clear
# Lancer la sauvegarde
echo "La sauvegarde de $FICHIER1, $FICHIER2, $FICHIER3, $FICHIER4 vers $DESTINATION va commencer :"
cp $FICHIER1 $FICHIER2 $FICHIER3 $FICHIER4 $DESTINATION
echo "La sauvegarde est terminée !"
Ce script fait usage de variables.
Le nom d’une variable doit commencer par une lettre mais peut ensuite contenir n’importe quelle suite de lettres ou de chiffres.
Hormis le tiret bas « _
», les caractères spéciaux ne sont pas utilisables.
Par convention, les variables créées par un utilisateur ont un nom en minuscules. Ce nom doit être choisi avec précaution pour n’être ni trop évasif ni trop compliqué. Une variable peut toutefois être nommée avec des majuscules, comme c’est le cas ici, s’il s’agit d’une variable globale qui ne doit pas être modifiée par le programme.
Le caractère « =
» affecte du contenu à une variable :
variable=valeur
nom_rep="/home"
Il n’y a pas d’espace ni avant ni après le signe =
.
Pour afficher du texte en même temps que le contenu d’une variable, il est obligatoire d’utiliser les guillemets et non les apostrophes.
L’usage des apostrophes inhibe l’interprétation des caractères spéciaux.
|
Pour isoler le nom de la variable, il faut utiliser les apostrophes ou les accolades :
$ fichier=nom_fichier
$ touch "$fichier"1
$ touch ${fichier}1
L’utilisation systématique des accolades est conseillée. |
Supprimer et verrouiller les variables
La commande unset
permet de supprimer une variable.
Exemple :
$ nom="NOM"
$ prenom="Prenom"
$ echo "$nom $prenom"
NOM Prenom
$ unset prenom
$ echo "$nom $prenom"
NOM
La commande readonly
ou typeset -r
verrouille une variable.
Exemple :
$ nom="NOM"
$ readonly nom
$ nom="AUTRE NOM"
bash: nom: variable en lecture seule
$ unset nom
bash: nom: variable en lecture seule
Un |
Variables d’environnements
Les variables d’environnements et les variables systèmes sont des variables utilisées par le système pour son fonctionnement. Par convention elles portent un nom en majuscules.
Comme toutes variables, elles peuvent être affichées à l’exécution d’un script. Même si cela est fortement déconseillé, elles peuvent aussi y être modifiées.
-
La commande
env
permet d’afficher toutes les variables d’environnement utilisées. -
La commande
set
permet d’afficher toutes les variables système utilisées.
Parmi les dizaines de variables d’environnement, plusieurs ont un intérêt à être utilisées dans un script shell :
Variable | Observation |
---|---|
|
Nom d’hôte de la machine. |
|
Nom de l’utilisateur connecté sur la session. |
|
Chemin où trouver les commandes. |
|
Répertoire courant, mis à jour à chaque exécution de la commande |
|
Répertoire de connexion. |
|
Numéro du processus de l’exécution du script. |
|
Code retour de la dernière commande exécutée. |
Exporter une variable
La commande export
permet d’exporter une variable.
Une variable n’est valable que dans l’environnement du processus du script shell. Pour que les processus fils du script puissent connaître les variables et leurs contenus, il faut les exporter.
La modification d’une variable exportée dans un processus fils ne peut pas remonter au processus père.
Sans option, la commande |
La substitution de commande
Il est possible de stocker le résultat d’une commande dans une variable.
Cette opération n’est valable que pour les commandes qui renvoient un message à la fin de leur exécution. |
La syntaxe pour sous-exécuter une commande est la suivante :
variable=`commande`
variable=$(commande) # Syntaxe à privilégier
Exemple :
$ jour=`date +%j`
$ homedir=$(pwd)
Améliorations du script de sauvegarde
#!/usr/bin/env bash
#
# Auteur : Antoine Le Morvan
# Date : Janvier 2019
# Version 1.0.0 : Sauvegarde dans /root les fichiers passwd, shadow, group et gshadow
# Version 1.0.1 : Création d'un répertoire avec le quantième du jour.
# Améliorations diverses
# Variables globales
## Fichiers a sauvegarder
FICHIER1=/etc/passwd
FICHIER2=/etc/shadow
FICHIER3=/etc/group
FICHIER4=/etc/gshadow
## Dossier destination
DESTINATION=/root
## Variables en readonly
readonly FICHIER1
readonly FICHIER2
readonly FICHIER3
readonly FICHIER4
readonly DESTINATION
# Un nom de dossier avec le quantième du jour
rep="backup-$(date +%j)"
# Nettoie l'écran :
clear
# Lancer la sauvegarde
echo "****************************************************************"
echo " Script de sauvegarde - Sauvegarde sur la machine $HOSTNAME "
echo "****************************************************************"
echo "La sauvegarde sera faîte dans le dossier ${rep}."
echo "Création du répertoire..."
mkdir -p $DESTINATION/$rep
echo " [ OK ]"
echo "La sauvegarde de ${FICHIER1}, ${FICHIER2}, ${FICHIER3}, ${FICHIER4} vers ${DESTINATION}/$rep va commencer :"
cp $FICHIER1 $FICHIER2 $FICHIER3 $FICHIER4 $DESTINATION/$rep
echo "La sauvegarde est terminée !"
# La sauvegarde est notée dans le journal d'évènements du système :
echo "La sauvegarde est renseignée dans syslog :"
logger "Sauvegarde des fichiers systèmes par ${USER} sur la machine ${HOSTNAME} dans le dossier ${DESTINATION}/$rep."
echo " [ OK ]"
root # ./02-backup-enhanced.sh
*****************************************************************
Script de sauvegarde - Sauvegarde sur la machine formateur1
*****************************************************************
La sauvegarde sera faîte dans le dossier backup-262.
Création du répertoire...
[ OK ]
La sauvegarde de /etc/passwd, /etc/shadow, /etc/group, /etc/gshadow vers /root/backup-262 va commencer :
La sauvegarde est terminée !
La sauvegarde est renseignée dans syslog :
[ OK ]
Grace à la commande logger
, les affichages de l’exécution du script sont écrites dans le journal syslog
:
root # tail -f /var/log/messages
janvier. 02 19:35:35 formateur1 antoine[9712]: Sauvegarde des fichiers systèmes par antoine sur la machine formateur1 dans le dossier /root/b...
Saisie et manipulations
Selon l’objet du script, il peut être nécessaire de lui envoyer des informations lors de son lancement ou durant son exécution.
Ces informations, non connues lors de l’écriture du script, peuvent être extraites à partir de fichiers ou saisies par l’utilisateur.
Il est aussi possible d’envoyer ces informations sous forme d’arguments lors de la saisie de la commande du script. C’est le mode de fonctionnement de nombreuses commandes Linux.
La commande read
La commande read
permet de saisir une chaîne de caractères pour la stocker dans une variable.
read [-n X] [-p] [-s] [variable]
$ read nom prenom
$ read -p "Veuillez saisir votre nom : " nom
Option | Observation |
---|---|
|
Affiche un message de prompt |
|
Limite le nombre de caractères à saisir |
|
Masque la saisie |
Lors de l’utilisation de l’option -n
, le shell valide automatiquement la saisie au bout du nombre de caractères précisés.
L’utilisateur n’a pas à appuyer sur la touche [ENTREE]
.
$ read -n5 nom
La commande read
permet d’interrompre l’exécution du script le temps que l’utilisateur saisisse des informations.
La saisie de l’utilisateur est découpée en mots affectés à une ou plusieurs variables prédéfinies.
Les mots sont des chaînes de caractères séparées par le séparateur de champs.
La fin de la saisie est déterminée par la frappe sur la touche [ENTREE]
ou le caractère spécial de fin de ligne.
Une fois la saisie validée, chaque mot sera stocké dans la variable prédéfinie.
Le découpage des mots est défini par le caractère séparateur de champs.
Ce séparateur est stocké dans la variable système IFS
(Internal Field Separator).
$ set | grep IFS
IFS=$' \t\n'
Par défaut, l’IFS contient l’espace, la tabulation \t
et le saut de ligne \n
.
Utilisée sans préciser de variable, cette commande met simplement le script en pause. Le script continue son exécution lors de la validation de la saisie.
Cette utilisation permet de faire une pause lors du débogage d’un script ou pour inciter l’utilisateur à appuyer sur kbd:[ENTREE] pour continuer.
$ echo -n "Appuyer sur [ENTREE] pour continuer..."
$ read
La commande cut
La commande cut
permet d’isoler une colonne dans un fichier ou dans un flux.
cut [-cx] [-dy] [-fz] fichier
$ cut -d: -f1 /etc/passwd
Option | Observation |
---|---|
|
Spécifie les numéros d’ordre des caractères à sélectionner |
|
Spécifie le séparateur de champs |
|
Spécifie le numéro d’ordre des colonnes à sélectionner |
Le principal intérêt de cette commande sera son association avec un flux, par exemple la commande grep
et le pipe |
.
-
La commande
grep
travaille verticalement (isolation d’une ligne parmi toutes celles du fichier). -
La combinaison des deux commandes permet d’isoler un champ précis du fichier.
# grep "^root:" /etc/passwd | cut -d: -f3
0
Les fichiers de configurations comportant une structure unique utilisant le même séparateur de champs sont des cibles idéales pour cette combinaison de commandes. |
La commande tr
La commande tr
permet de convertir une chaîne de caractères.
tr [-csd] chaîne1 chaîne2
Option | Observation |
---|---|
|
Tous les caractères qui ne sont pas spécifiés dans la première chaîne sont convertis selon les caractères de la seconde. |
|
Efface le caractère spécifié. |
|
Réduire à une seule unité le caractère spécifié. |
$ grep root /etc/passwd
root:x:0:0:root:/root:/bin/bash
$ grep root /etc/passwd | tr -s "o"
rot:x:0:0:rot:/rot:/bin/bash
Exercice : Extraire le niveau d’exécution du fichier /etc/inittab
#!/usr/bin/env bash
#
# Auteur : Antoine Le Morvan
# Date : Janvier 2019
# Version 1.0.0 : Extrait le niveau d'exécution du fichier /etc/inittab
# Variables globales
INITTAB=/etc/inittab
niveau=`grep "^id" $INITTAB | cut -d: -f2`
# Affichage du résultat :
echo "Le niveau d'init au démarrage est : $niveau"
Extraire le nom et le chemin d’un fichier
-
La commande
basename
permet d’extraire le nom du fichier à partir d’un chemin. -
La commande
dirname
permet d’extraire le chemin parent d’un fichier.
Exemple :
$ echo $FICHIER=/usr/bin/passwd
$ basename $FICHIER
passwd
$ dirname $FICHIER
/usr/bin
Arguments d’un script
La demande de saisie d’informations grâce à la commande read
interrompt l’exécution du script tant que l’utilisateur ne fait pas de saisie.
Cette méthode, bien que très conviviale, présente des limites s’il s’agit d’un script à l’exécution programmée la nuit par exemple. Afin de palier ce problème, il est possible d’injecter les informations souhaitées via des arguments.
De nombreuses commandes Linux fonctionnent sur ce principe.
Cette façon de faire à l’avantage qu’une fois le script exécuté, il n’aura plus besoin d’intervention humaine pour se terminer.
Son inconvénient majeur est qu’il faudra prévenir l’utilisateur de la syntaxe du script pour éviter des erreurs.
Les arguments sont renseignés lors de la saisie de la commande du script. Ils sont séparés par un espace.
$ ./script argument1 argument2
Une fois exécuté, le script enregistre les arguments saisis dans des variables prédéfinies : les variables positionnelles.
Ces variables sont utilisables dans le script comme n’importe quelle autre variable, à l’exception faite qu’elles ne peuvent pas être affectées.
-
Les variables positionnelles non utilisées existent mais sont vides.
-
Les variables positionnelles sont toujours définies de la même façon :
Variable | Observation |
---|---|
|
contient le nom du script tel qu’il a été saisi. |
|
contiennent les valeurs du 1er et du 9ème argument. |
|
contient la valeur de l’argument |
|
contient le nombre d’arguments passés. |
|
contient en une variable tous les arguments passés |
Exemples :
#!/usr/bin/env bash
#
# Auteur : Damien dit LeDub
# Date : septembre 2019
# Version 1.0.0 : Affiche la valeur des arguments positionnels
# de 1 à 3
# Le séparateur de champ sera "," ou l'espace
# Important pour visualiser la différence en $* et $@
IFS=", "
# Affiche un texte à l'écran :
echo "Le nombre d'argument (\$#) = $#"
echo "Le nom du script (\$0) = $0"
echo "Le 1er argument (\$1) = $1"
echo "Le 2e argument (\$2) = $2"
echo "Le 3e argument (\$3) = $3"
echo "Tous séparés par IFS (\$*) = $*"
echo "Tous sans séparation (\$@) = $@"
$ ./un_deux_trois.sh un deux "trois quatre"
Le nombre d'argument ($#) = 3
Le nom du script ($0) = ./un_deux_trois.sh
Le 1er argument ($1) = un
Le 2e argument ($2) = deux
Le 3e argument ($3) = trois quatre
Tous séparés par IFS ($*) = un,deux,trois quatre
Tous sans séparation ($@) = un deux trois quatre
Attention à la différence entre Elle se fait au niveau du format de stockage des arguments :
C’est en modifiant la variable d’environnement IFS que la différence est visible. |
La commande shift
La commande shift
permet de décaler les variables positionnelles.
Exemples :
#!/usr/bin/env bash
#
# Auteur : Damien dit LeDub
# Date : septembre 2019
# Version 1.0.0 : Affiche la valeur des arguments positionnels
# de 1 à 3 avant et après un «shift»
# Le séparateur de champ sera "," ou l'espace
# Important pour visualiser la différence en $* et $@
IFS=", "
# Récupère les arguments avant le «shift»
AVANT_SHIFT_NB="$#"
AVANT_SHIFT_NOM="$0"
AVANT_SHIFT_IER="$1"
AVANT_SHIFT_2E="$2"
AVANT_SHIFT_3E="$3"
AVANT_SHIFT_TOUS_IFS="$*"
AVANT_SHIFT_TOUS="$@"
# Récupère les arguments après le «shift»
shift 2
APRES_SHIFT_NB="$#"
APRES_SHIFT_NOM="$0"
APRES_SHIFT_IER="$1"
APRES_SHIFT_2E="$2"
APRES_SHIFT_3E="$3"
APRES_SHIFT_TOUS_IFS="$*"
APRES_SHIFT_TOUS="$@"
# Affiche toutes les informations récupérées
echo "Le nombre d'argument (\$#) : ${AVANT_SHIFT_NB}"
echo " après le shift 2 : ${APRES_SHIFT_NB}"
echo "Le nom du script (\$0) : ${AVANT_SHIFT_NOM}"
echo " après le shift 2 :${APRES_SHIFT_NOM}"
echo "Le 1er argument (\$1) : ${AVANT_SHIFT_IER}"
echo " après le shift 2 :${APRES_SHIFT_IER}"
echo "Le 2e argument (\$2) :${AVANT_SHIFT_2E}"
echo " après le shift 2 :${APRES_SHIFT_2E}"
echo "Le 3e argument (\$3) : ${AVANT_SHIFT_3E}"
echo " après le shift 2 :${APRES_SHIFT_3E}"
echo "Tous séparé par IFS (\$*) : ${AVANT_SHIFT_TOUS_IFS}"
echo " après le shift 2 :${APRES_SHIFT_TOUS_IFS}"
echo "Tous sans séparation (\$@) : ${AVANT_SHIFT_TOUS}"
echo " après le shift 2 :${APRES_SHIFT_TOUS} "
$ ./un_deux_trois_shift.sh un deux "trois quatre"
Le nombre d'argument ($#) : 3
après le shift 2 : 1
Le nom du script ($0) : ./un_deux_trois_shift.sh
après le shift 2 :./un_deux_trois_shift.sh
Le 1er argument ($1) : un
après le shift 2 :trois quatre
Le 2e argument ($2) :deux
après le shift 2 :
Le 3e argument ($3) : trois quatre
après le shift 2 :
Tous séparé par IFS ($*) : un,deux,trois quatre
après le shift 2 :trois quatre
Tous sans séparation ($@) : un deux trois quatre
après le shift 2 :trois quatre
Lors de l’utilisation de la commande |
La commande set
La commande set
découpe une chaîne en variables positionnelles.
set [valeur] [$variable]
Exemple :
$ set un deux trois
$ echo $1 $2 $3 $#
un deux trois 3
$ variable="un deux trois"
$ set $variable
$ echo $1 $2 $3 $#
un deux trois 3
Ci-dessous, la version de notre script de sauvegarde mettant en oeuvre les variables positionnelles :
#!/usr/bin/env bash
#
# Auteur : Antoine Le Morvan
# Date : Janvier 2019
# Version 1.0.0 : Sauvegarde dans /root les fichiers passwd, shadow, group et gshadow
# Version 1.0.1 : Création d'un répertoire avec le quantième du jour.
# Améliorations diverses
# Version 1.0.2 : Modification pour utiliser les variables positionnelles
# Limitation à 5 fichiers
# Variables globales
## Dossier destination
DESTINATION=/root
# Un nom de dossier avec le quantieme du jour
rep="backup-$(date +%j)"
# Nettoie l'écran :
clear
# Lancer la sauvegarde
echo "****************************************************************"
echo " Script de sauvegarde - Sauvegarde sur la machine $HOSTNAME "
echo "****************************************************************"
echo "La sauvegarde sera faîte dans le dossier ${rep}."
echo "Création du répertoire..."
mkdir -p $DESTINATION/$rep
echo " [ OK ]"
echo "La sauvegarde de ${1} ${2} ${3} ${4} ${5} vers ${DESTINATION}/$rep va commencer :"
cp $1 $2 $3 $4 $5 $DESTINATION/$rep
echo "La sauvegarde est terminée !"
Tester vos connaissances
Parmi ces 4 shells, lequel n’existe pas :
Bash
Ksh
Tsh
Csh
Quelle est la bonne syntaxe pour affecter un contenu à une variable :
variable:=valeur
variable := valeur
variable = valeur
variable=valeur
Comment stocker le retour d’une commande dans une variable :
fichier=$(ls)
fichier=`ls`
fichier:=$ls
fichier = $(ls)
La commande read
permet de lire le contenu d’un fichier :
Vrai
Faux
Parmi les propositions ci-dessous, laquelle est la bonne syntaxe pour la commande cut
:
cut -f: -D1 /etc/passwd
cut -d: -f1 /etc/passwd
cut -d1 -f: /etc/passwd
cut -c ":" -f 3 /etc/passwd
Quelle commande permet de décaller des variables positionnelles :
left
shift
set
decalle
Quelle commande transforme une chaîne de caractères en variables positionnelles :
left
shift
set
array