Activité Premier script en Bash

Consigne

Suivez les instructions ci-après et effectuez les tâches demandées.

Situation

Dans le cadre du développement d’application web, la base de données de l’environnement de développement doit être supprimée et recréée à chaque modification du schéma. De cette manière, on s’assure que le schéma décrit par le script SQL correspond bien à la base de données de l’application.

Pour faciliter votre travail, vous décidez de réaliser un script qui permet de supprimer la base de données existante, créer une nouvelle base de données en exécutant le script SQL, et insérer des données de test en exécutant un autre script SQL.

Il est important que le script de création de la base de données ne contienne que la description du schéma et rien d’autre. En particulier, il n’y a ni instruction de suppression (DROP) ni instructions d’insertion de données de test (INSERT INTO). En effet, le script de création est celui qui sera utilisé par l’administrateur du système de production pour déployer l’application. Si ce script contient une commande de suppression de la base de données, on prend le risque de supprimer la base de données de productions dans le cas où il serait re-exécuté par erreur, et les données de test n’ont bien sûr rien à faire dans une base de données de production.

Objectifs

À la fin de ce travail, vous devez :

1. Connaître les commandes Bash pour la manipulation des fichiers et des répertoires (cd, ls, pwd, touch, cat, less, head, tail, mkdir, rm, cp, mv, find).
2. Connaître les commandes Bash pour modifier le propriétaire et les permissions d’un fichier (chown, chmod)
3. Connaître les commandes Bash permettant de lire et d’écrire dans la console (read, echo, printf).
4. Connaître la structure de choix (if-then-else) et la commande test ([)
5. Connaître la notion de variable d’environnement.
6. Être capable d’utiliser des commandes et des variables pour réaliser un script.
7. Être capable de définir et d’utiliser des variables d’environnements (export)

Résultat attendu

• Un bref rapport qui décrit votre travail et votre démarche.
• Votre script bash.

Ressources

Documents :

• Aide pour la commande echo : help -m echo | less
• Aide pour la commande read : help -m read | less
• Aide pour la commande if : help -m if | less
• Aide à propos du paramètre spécial : $?

Logiciel :

• Visual Studio Code

Matériel :

• Un serveur Linux svr-m122-###.lab.epai-ict.ch

Mise en route

Ouvrir une session ssh

Pour vous connecter à votre machine Linux (svr-m122-##.lab.epai-ict.ch), commencez par chercher le numéro de votre réseau et votre mot de passe dans les informations de connexion que vous avez reçue. Notez-les de manière à les avoir sous la main !

Ouvrez ensuite une fenêtre de terminal (sans privilèges) et tapez la commande ci-après en remplaçant les caractères ## par le numéro de votre réseau :

1
ssh admin@svr-m122-##.lab.epai-ict.ch

Lorsque vous y êtes invitez, tapez votre mot de passe. Si tout c’est bien passé vous devriez voir l’invite de commande (prompt) de votre machine Linux :

1
admin@svr-m122-32:~$

Écrire un premier script Bash

Un script Bash est un fichier de texte dans lequel chaque le texte est une suite de commandes Bash et de commentaires. Si une ligne commence par un croisillon (# hash), il s’agit d’un commentaire. Dans le cas contraire, il s’agit d’une commande.

Assurez-vous d’être connecté à votre serveur, rendez-vous dans votre répertoire personnel avec la commande cd et créez un fichier script1 avec le contenu suivant :

1
2
3
4
# Affiche la chaîne "Bonjour tout le monde"
echo "Bonjour tout le monde"
# Affiche la chaîne "Ceci est un premier script Bash"
echo "Ceci est un premier script Bash"

Remarque : Le plus souvent, une commande Bash s’écrit sur une seule ligne. Toutefois, si une commande est un peu longue, il est possible de l’écrire sur plusieurs lignes pour améliorer la lisibilité du script. Pour cela, on utilise une barre oblique inversée (\ backslash) à la fin d’une ligne pour indiquer que la commande se poursuit sur la ligne suivante.

1
2
3
4
5
6
7
# une commande sur une ligne
cp -R /un/long/tres/long/vraiment/tres/long/extremement/long/chemin/ /un/autre/long/tres/long/vraiment/tres/long/chemin

# la même commande sur trois lignes
cp -R \
    /un/long/tres/long/vraiment/tres/long/extremement/long/chemin/ \
    /un/autre/long/tres/long/vraiment/tres/long/chemin

Exécuter un script Bash

Le programme bash est un programme avec une interface en ligne de commande (CLI). Nous avons vu qu’un programme avec une CLI communique avec l’utilisateur au travers de trois flux de données (stdin, stdout, stderr), et que du point de vue du programme, ces flux de données sont des fichiers. Par défaut, l’entrée standard (stdin) est connectée au clavier, et les sorties standards (stdout et stderr) sont connectées à l’écran du terminal.

La redirection des entrées-sorties permet de connecter les entrées-sorties standard à d’autre fichiers. On peut lancez la commande ci-après pour rediriger l’entrée-standard (stdin) du programme bash vers ce fichier.

1
bash < ./script1

Lorsque vous lancez la commande, le programme bash démarre et lit une première ligne de l’entrée standard, exécuter la commande, et procède de la même manière avec deuxième ligne, puis la troisième, et ainsi de suite jusqu’à la lecture d’un caractère EOF (end of file) qui met fin à l’éxécution de bash.

La redirection de l’entrée standard permet d’automatiser n’importe quel programme avec une interface en ligne de commande (CLI), y compris ceux que vous avez écrit en Java.

Toutefois, le programme bash supporte directement l’exécution de scripts, sans avoir besoin de redirection d’entrée-sortie. Pour exécuter un script, il suffit de passer en paramètre le chemin du fichier qui contient ce script, exactement comme on le ferait avec un programme Python.

1
bash ./script1

Enfin, il est possible de transformer un fichier de script en un fichier exécutable en ajoutant, à la toute première ligne, un « shebang » (#!) suivi du chemin d’un interpréteur capable d’exécuter le script. Pour un script Bash, cela donne la ligne suivante :

1
2
3
4
5
6
#! /bin/bash

# Affiche la chaîne "Bonjour tout le monde"
echo "Bonjour tout le monde"
# Affiche la chaîne "Ceci est un premier script Bash"
echo "Ceci est un premier script Bash"

Il faut encore ajouter la permission d’exécution de ce fichier. Comme vous en êtes le propriétaire, vous pouvez utiliser la commande suivante pour autoriser l’exécusion de ce fichier à tout le monde suivante :

1
chmod +x ./script1

Lorsque c’est fait, vous pouvez lancer l’exécution de votre script en indiquant simplement son chemin.

1
./script1

Remarque : Pour exécuter un script, il est nécessaire de spécifier le chemin fichier et pas seulement son nom, sauf si le chemin du script se trouve dans la variable d’environnement PATH.

Définir une variable

De manière générale, pour utiliser une variable, il faut la définir. Définir une variable consiste essentiellement à lui donner une valeur.

Lancez la commande ci-après pour définir une variable dont le nom est ma_variable.

1
ma_variable="Bonjour tout le monde"

La définition d’une variable en Bash doit suivre les règles suivantes :

• Le nom de la variable est un identificateur, qui doit commencer par une lettre, n’être composé que de lettre sans accents et de chiffre, et ne pas contenir d’espace.
• Le signe égal = doit suivre immédiatement le nom de la variable, sans espace.
• La valeur doit être spécifiée immédiatement après le signe égal (sans espace). Si la valeur est constituée d’une suite de caractère sans espace (un identifiant ou un nombre, par exemple), elle peut être écrite directement. Sinon, la valeur doit être écrite entre guillemets (" double quotes) ou entre apostrophes (' single quotes).

Les variables Bash sont toutes de type chaîne de caractères. Il est bien sûr possible de stocker un nombre dans une variable, mais ce nombre est une chaîne.

Utiliser une variable (expansion de variables et de paramètres)

Lorsque l’on veut utiliser une variable Bash, on écrit le nom de la variable précédée d’un signe dollar ($) ou entre une paire d’accolades précédée d’un signe dollar (${}). Vous pouvez exécuter les commandes ci-dessous pour afficher la valeur de la variable ma_variable.

1
2
echo $ma_variable
echo ${ma_varaiable}

Lorsque l’interpréteur Bash (le programme bash) lit une ligne pour l’interpréter, il commence par remplacer toutes les variables par leur valeur, peu importe où se trouve la variable dans la commande. On appelle cela l’expansion des variables. Par exemple, considérons la commande suivante :

1
2
3
4
ma_var1=echo
ma_var2="tout le monde"

${ma_var1} "Bonjour ${ma_var2}"

Les deux premières lignes définissent les variables ma_var1 et ma_var2. Lorsque l’interpréteur charge la troisième ligne, il replace les références aux variables ma_var1 et ma_var2 ce qui produit la commande suivante :

1
echo "Bonjour tout le monde"

Après l’expansion des variables, l’interpréteur exécute la commande qui a pour effet d’écrire la chaîne “Bonjour tout le monde” dans la sortie standard.

Passer des paramètre à un script

Une commande Bash est composée du nom de la commande elle-même (souvent le nom ou le chemin d’un fichier exécutable) suivie, de manière optionnelle, d’un ou plusieurs arguments. Les arguments sont des chaînes de caractères séparées par des espaces. Un argument qui contient des espaces doit être écrit entre guillemets ou entre apostrophes (sans quoi il est interprété comme plusieurs arguments).

Dans un script Bash, le nom de la commande et les arguments sont accessibles à l’aide de variables prédéfinies. Le nom de la commande est stocké dans la variable $0, et le premier argument, dans la variable $1, le deuxième dans la variable $2, etc. Le nombre d’arguments de la commande se trouve dans la variable $#.

Créez un fichier script2 avec le contenu ci-dessous dans votre répertoire personnel et modifiez les permissions pour que vous puissiez l’exécuter.

1
2
3
4
5
#! /bin/bash

echo "Le nom de la commande est : $0, et il y a $# argument(s)."
echo
echo "Bonjour $1"

Lancez la commande ci-dessous et observez l’effet.

1
./script2 tout le monde

Le script nous informe qu’il a été lancé avec 3 arguments et affiche la chaîne “Bonjour tout”. Pour afficher la chaîne “Boujour tout le monde”, lancez la commande suivante :

1
./script2 "tout le monde"

Obtenir ou définir le statut de sortie d’une commande

Il existe d’autres variables prédéfinies. En particulier, la variable $? contient le statut de sortie (exit status) de la dernière commande exécutée.

Le statut de sortie est le nombre entier qui indique la manière dont la commande s’est terminée. Par convention, si une commande se termine sans erreur, son statut de sortie est égal à 0; dans le cas contraire, il est supérieur à 0. La signification exacte des différents codes de statut est spécifique à chaque commande. Par exemple, le tableau ci-dessous montre la signification des statuts de sortie définis pour la commande useradd.

En Bash, la commande exit permet de terminer l’exécution d’un script en spécifiant le statut de sortie. Par exemple exit 1 pour indiquer qu’une erreur est survenue, ou exit 0 pour indiquer qu’elle s’est terminée avec succès. Si le script se termine à la dernière ligne, le statut de sortie est celui de la dernière commande.

Une bonne pratique est d’utiliser des statuts de sortie distincts pour chaque condition de sortie, et de décrire ces différents statuts dans la documentation de votre script; en particulier s’il est destiné à être intégré dans des processus automatisés.

Affecter le résultat d’une commande à une variable (substitution de commande)

Il est souvent utile de stocker le résultat d’une commande dans une variable. Pour cela, on peut utiliser la substitution de commande $(...). L’interpréteur Bash effectue la substitution des commandes juste après la substitution des variables, avant d’exécuter la ligne. Par exemple, considérons cette fois, la commande suivante :

1
ma_variable=$(pwd)

Les commandes sont substituées par le texte qu’elle produit dans la sortie standard. Ici, la commande pwd écrit le chemin du répertoire de travail. Si la commande est exécutée dans le répertoire /home/admin/, la commande après la substitution est la suivante :

1
ma_variable=/home/admin/

Exécutez la commande de la figure 15 et affichez la valeur de la variable ma_variable avec la commande echo.

Communiquer avec l’extérieur (commandes d’entrée-sortie)

Les commandes d’entrée-sortie permettent d’écrire des caractères dans la sorties standard (stdout) et lire des caractères dans l’entrée standard (stdin). Les principales commandes d’entrée-sortie sont :

• echo
• printf
• read

La commande echo que nous avons déjà utilisée, permet d’afficher une chaîne de caractère dans la sortie standard. Par défaut, cette commande ajoute une retour à la ligne (LF) à la fin de la chaîne. Avec l’option -n, la commande écrit la chaîne sans retour à la ligne. Créez un fichier script3 avec le contenu suivant, exécutez-le et pour observer l’effet de l’option -n.

1
2
3
4
#! /bin/bash

echo -n "Bonjour "
echo "tout le monde"

Par défaut, la commande echo n’interprète pas les caractères spéciaux comme les retours à la ligne \n ou les tabulation \t. Lorsque c’est nécessaire, on peut utiliser la commande echo avec l’option -e, ou la commande printf.

1
2
echo -e "Bonjour\ntout le monde"
printf "Bonjour\ntout le monde\n"

Attention : la commande printf est équivalente à la commande echo -n -e, elle n’ajoute pas de retourn à la ligne après la chaîne.

Les commande echo et printf écrive dans la sortie standard (stdout). Pour écrire une chaîne dans la sortie d’erreur standard (stderr), on peut rediriger la sortie standard vers la sortie d’erreur standard.

1
echo "Une erreur s'est produite" 1>&2

La combinaison 1>&2 signifie que l’on redirige le descripteur de fichier numéro 1 (stdout) dans le fichier référencé par le descripteur numéro 2 (stderr). Le signe & devant un descripteur de fichier indique que l’on référence le fichier que représente le descripteur.

Enfin, pour définir une variable avec une valeur qui provient de l’entrée standard (stdin), on peut utiliser la commande read.

Par défaut, cette commande n’affiche rien et attend jusqu’à ce qu’elle ait reçu une ligne de texte. Lorsque la commande read est utilisée pour interagir avec un utilisateur, on utilise l’option -e. Vous pouvez utiliser la commande echo pour afficher le contenu de la variable après l’exécution de la commande read.

1
read -e ma_variable

Il est possible d’afficher une invite de commande (prompt) avec l’option -p pour indiquer à l’utilisateur·rice ce que l’on attend d’elle ou de lui. Exécutez la commande suivante pour demander à l’utilisateur de saisir son nom :

1
read -e -p "Veuillez saisir votre nom d'utilisateur·rice : " ma_variable

L’option -n permet de spécifier le nombre de caractères que la commande attend. Par exemple pour demander à l’utilisateur de répondre par oui ou non, on peut lui demain de saisir o pour oui ou n pour non. Exécutez la commande suivante pour demander à l’utilisateur de saisir exactement un caractère :

1
read -e -p "Voulez continuer ? [o/n] : " -n 1 ma_variable

Définir et utiliser des variable d’environnement

Une variable d’environnement est une variable stockée dans l’environnement d’un processus et dont la valeur est copiée lors de la création d’un processus enfant. Cela permet de partager des informations entre un processus parent et un processus enfant, au démarrage d’un processus enfant.

N’importe que variable peut devenir une variable d’environnement à l’aide de la commnde export. Par exemple :

1
export ma_variable

Toutefois, par convention, le nom d’une variable d’environnement est écrit en UPPER_SNAKE_CASE. En outre, il est possible d’exporter et de définir une variable en une seule opération.

Une variable d’environnement s’utilise de la même manière qu’une variable normale. La seule différence est qu’elle est également disponible dans les processus enfants. Créez un fichier script4 avec le contenu ci-dessous et rendez-le exécutable.

1
2
3
4
#! /bin/bash

echo "Username : $DB_USERNAME"
echo "Password : $DB_PASSWORD"

Exécutez les commandes ci-dessous et observez l’effet.

1
2
3
4
DB_USERNAME="root"
export DB_PASSWORD="epai123"

./script4

On remarque que la valeur de DB_PASSWORD est bien affichée, mais pas celle de DB_USERNAME. En effet, DB_PASSWORD est une variable d’environnement, car nous l’avons exportée, mais DB_USERNAME est une variable locale, elle n’est pas accessible dans le script. Pour qu’elle le soit, nous devons exporter la variable locale pour en faire une variable d’environnement.

1
2
3
export DB_USERNAME

./script4

Pour supprimer une variable d’environnement, on utilise la commande unset. Exécutez la commande suivante pour supprimer la variable d’environnement DB_PASSWORD et re-exécuter le script.

1
2
3
4
unset DB_USERNAME
unset DB_PASSWORD

./script4

Exécuter une commande de manière conditionnelle (structure de choix)

Pour exécuter des commandes de manière conditionnelle, le langage de commande Bash dispose de structures de choix, dont la structure if-then-else que vous connaissez bien.

Il y a deux manière d’écrire cette structure en Bash. Vous être libre d’utiliser celle que vous préférez, mais évitez de mélanger les style dans un même script.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
if <condition>; then
    <commandes>
elif <condition>; then
    <commandes>
else
    <commandes>
fi

if <condition>
then
    <commandes>
elif <condition>
then
    <commandes>
else
    <commandes>
fi

La condition d’une structure de choix en Bash peut être n’importe quelle commande. Si la commande se termine sans erreur (statut de sortie égal à 0), la condition est vérifiée (vrai). Si la commande se termine avec une erreur, la condition n’est pas vérifiée (faux).

Toutefois, on utilise généralement la commande [ (commande test). Cette commande évalue une expression booléenne passée en paramètres. Pour bien comprendre comment fonctionne cette commande, exécutez les commandes suivantes :

1
2
3
4
ma_var=10
[ "$ma_var" -gt 5 ]
# Affiche le statut de sortie de la commande [
echo "Statut de sortie : $?"

Le statut de sortie est 0 (pas d’erreur), car la valeur 10 est effectivement plus grande que (-gt, greater than) 5. Exécutez maintenant les commandes suivantes :

1
2
3
4
ma_var=2
[ "$ma_var" -gt 5 ]
# Affiche le statut de sortie de la commande [
echo "Statut de sortie : $?"

Remarques :

• En Bash, les opérateurs de comparaison =, !=, <, <=, >, >= ne fonctionne que pour les chaînes. Pour les valeurs numériques, on utilise -eq, -ne, -lt, -le, -gt et -ge.
• Dans la commande [ "$ma_var" -gt 5 ], [ est le nom de la commande et les éléments suivants sont des paramètres, ils doivent donc être séparés par des espaces. La commande ["$ma_var" -gt 5] n’est pas valide.
• Il existe beaucoup d’autres opérateurs que vous pouvez trouver dans le manuel de Bash. On peut mentionner -z qui permet de tester si une variable est vide (voir plus bas)

Pour expérimenter l’utiliser la commande test avec la structure de choix if-then-elses, créez un fichier script5 avec le contenu de la figure ci-dessous et exécutez-le.

1
2
3
4
5
6
7
8
9
10
11
#! /bin/bash

read -e -p "Entrez un nombre entier : " ma_var

if [ -z "$ma_var" ]; then
    echo "La variable ma_var est vide."
elif [ "$ma_var" -gt 5 ]; then
    echo "La valeur de ma_var est plus grande que 5"
else
    echo "La valeur de ma_var est plus petite ou égale à 5"
fi

Exécutez le script de plusieurs avec différente valeur. Essayez également de ne pas entrer de valeur en pressant simplement la touche Entrée.

Récupérer un fichier avec la commande scp

Vous pouvez récupérer les fichiers que vous avez créer sur votre serveur en utilisant la commande scp (secure copy) sur votre machine locale. Cette commande utilise le protocole SSH pour transférer des données depuis ou vers une machine distante.

Créez un répertoire m122 dans votre répertoire de projets si ce n’est pas déjà fait, rendez-vous dans ce répertoire et lancez la commande ci-dessous pour copier le fichier script1 depuis votre machine distante (remplacez les caractères ## par le numéro de votre réseau).

1
scp admin@svr-m122-##.lab.epai-ict.ch:/home/admin/script1 ./script1

Répétez l’opération pour récupérer vos autres fichiers.

Tâches

Automatisation de la création d’une base de données de développement

Pour éviter d’avoir à taper sans cesse les mêmes commandes dans la fenêtre du terminal, on vous charge d’automatiser la procédure de création de la base de données de développement dans un serveur mysql.

Pour cela vous devez réaliser un script Bash, create_db_1, qui effectue les actions suivante :

Trucs et astuces :

• Pour exécuter les scripts SQL (voir ci-après), il est nécessaire d’avoir un interpréteur pour le langage SQL. Il s’agit généralement d’un client en ligne de commande (CLI) pour un serveur SQL, tel que le programme mysql pour un serveur MariaDB ou MySQL (disponible sur votre serveur Linux), ou le programme sqlcmd pour un serveur Microsoft SQL Server.
• On peut exécuter un script SQL, en redirigeant l’entrée standard (stdin) de la mysql vers un fichier qui contient un script SQL.
• L’option -e de la commande mysql permet d’exécuter une seule commande SQL.
• Pour éviter l’affichage des avertissements de la commande mysql, on peut utiliser une redirection de la sortie d’erreur standard (stderr) vers le null device (2> /dev/null)
• L’option -p de la commande mysql permet de passer le mot de passe en paramètre. Par exemple, si la variable password contient votre mot de passe, vous pouvez ouvrir une session sur le serveur MariaDB avec la commande mysql -u admin -p${password}). Cela n’est pas recommandé pour un serveur de production, mais acceptable pour un serveur de développement.

Scripts SQL :

Pour le script SQL qui décrit le schéma de la base de données, créez un fichier db_schema.sql qui contient, par exemple, le code ci-dessous. Si vous le souhaitez, vous pouvez également utiliser le schéma d’une base de données que vous avez réalisée dans un autre module.

1
2
3
4
5
6
7
8
CREATE DATABASE example_db DEFAULT CHARSET UTF8;
use example_db;

CREATE TABLE example_table (
    example_id    BIGINT UNSIGNED NOT NULL,
    example_name  VARCHAR(50),
PRIMARY KEY (test_id)
);

Pour le script SQL qui permet d’insérer des données de test, créez un fichier db_test_data.sql qui contient le code ci-dessous.

1
2
3
4
INSERT INTO example_table (example_id, example_name) VALUES (11, "Hallo!");
INSERT INTO example_table (example_id, example_name) VALUES (11, "Salut!");
INSERT INTO example_table (example_id, example_name) VALUES (12, "Coucou!");
INSERT INTO example_table (example_id, example_name) VALUES (13, "Tchô!");

N’oubliez pas de récupérer votre script create_db_1 avec la commande scp et de faire de même pour les tâches ci-après.

Demande de confirmation pour la suppression

Faites une copie du fichier create_db_1, nommez-la create_db_2, et modifier ce nouveau fichier pour y ajouter la fonctionnalité décite suivante  :

Trucs et astuces :

• Pour tester l’existence de la base de données, on peut exécuter une commande SQL qui requière son existence avec la commande mysql (par exemple, la commande USE). Si la commande se termine avec succès (le statut de sortie est égal à 0), alors la base de données existe.

Spécification du mot de passe en paramètre

Faites une copie du fichier create_db_2, nommez-la create_db_3, et modifier ce nouveau fichier pour y ajouter la fonctionnalité décite suivante :

Utilisation de variables d’environnement

Faites une copie du fichier create_db_3, et nommez-la create_db_4 et modifier ce nouveau fichier pour y ajouter la fonctionnalité décite suivante  :

Documentation du script

Si l’utilisation d’un script peut vous paraître évidente, a fortiori lorsque vous venez de le réaliser, ce n’est sans doute pas le cas pour tout le monde. Un script devrait donc toujours être accompagné d’un petit guide d’utilisation.

Si l’on réaliser ce guide dans un document séparé, il est difficile d’assurer que celui-ci soit toujours disponible. Un meilleure option est d’inclure cette documentation dans le script lui-même. Pour les détails techniques, cette documentation peut être réalisée sous forme de commentaires. Mais pour le guide d’utilisation, une aide que l’on peut afficher avec l’option -h ou l’option --help est préférable.

Faites une copie du fichier create_db_4, nommez-la create_db_5, et modifier ce nouveau fichier pour y ajouter la fonctionnalité décite suivante  :

Trucs et astuces :

Pour afficher un texte sur plusieurs lignes, utilisez la commande cat avec un heredoc, comme dans l’exemple ci-dessous. Inspirez-vous du style de l’aide des commandes Bash. Attention : le texte est affiché tel que vous l’écrivez, il n’y a pas de retour à la ligne automatiquement. Utilisez une longueur de ligne de 80 caractères.

1
2
3
4
5
6
cat <<EOF
Usage : ... (TODO)
Permet de re-créer facilement une base de données de développement après
une modification du schéma ... (TODO)

EOF