Bash : qu'est-ce que c'est ?

Dans les systèmes informatiques, les systèmes Linux sont omniprésents. Peu connus du grand public, en comparaison avec Windows, une grande partie des systèmes d'exploitation dans le Cloud sont des distributions basées sur Linux, dont les variantes les plus connues sont Ubuntu et Debian.

Contrairement aux ordinateurs de bureau, les serveurs dans le Cloud n'ont pas d'interfaces graphiques. Pour interagir avec ces derniers, nous devons utiliser les commandes UNIX, qui sont des commandes systèmes permettant d'effectuer toutes les opérations de navigation, de lecture/écriture, d'administration ou encore d'exécution d'applications.

La très grande majorité des commandes systèmes sont disponibles dans toutes les distributions basées sur le noyau Linux. On retrouvera ainsi la plupart des commandes sur des systèmes Linux comme Ubuntu ou Debian, tout comme sur macOS. Il peut néanmoins y avoir des différences selon les applications installées (éditeurs de texte, gestionnaires de paquets, etc).

À lire aussi : découvrez notre formation Cloud / DevOps

Que l'on soit développeur, DevOps Engineer ou même Data Engineer, la connaissance des principales commandes Linux est indispensable, car ces profils vont très rapidement devoir manipuler des commandes dans le Cloud.

Une histoire de Bash

Bash (qui signifie Bourne Again SHell) est un interpréteur de commandes (shell) pour les systèmes d'exploitation Linux. Il s'agit du principal langage de script et d'interface en ligne de commande utilisé dans les systèmes Linux qui permet d'interagir avec le système d'exploitation en utilisant des commandes textuelles.

Avant de rentrer dans le détail de Bash, il faut bien comprendre tout d'abord c'est qu'est un shell. Un shell est un programme informatique qui agit comme une interface entre l'utilisateur et le système d'exploitation. Il permet ainsi d'interagir avec le système en utilisant des commandes textuelles plutôt que des interfaces graphiques (comme des applications fenêtrées que l'on utilise au quotidien). Le shell reçoit les commandes saisies par l'utilisateur, les interprète et les transmet au système d'exploitation pour exécution. Une fois que le système d'exploitation a terminé l'exécution de la commande, le shell peut afficher les résultats.

Il n'existe donc pas un shell mais plusieurs shells.

• Le Bourne Shell (sh) : il s'agit du shell original pour UNIX, et a été développé par Stephen Bourne en 1979 (appelé ainsi en l'honneur de son créateur). Le Bourne Shell était très basique, mais il a posé les bases des interpréteurs de commandes pour les systèmes UNIX.
• Très rapidemment, d'autres shells comme le C Shell (csh) ou le Korn Shell (ksh) ont vu le jour, dans l'optique d'améliorer le shell par défaut sh. Ils disposaient en général de meilleures fonctionnaliés comme l'édition de fichiers ou la complétion automatique (en appuyant sur la touche tabulation).
• Presque dix ans après, le Bourne Again Shell (bash) est apparu, avec un support des commandes classiques du Bourne Shell, tout en ajoutant les nouvelles fonctionnalités développées à l'occasion pour le C Shell et le Korn Shell.

Ainsi, il est donc possible d'utiliser le shell que l'on souhaite en fonction de ses préférences, même si Bash est aujourd'hui de facto le shell par défaut dans de nombreux systèmes Linux.

Premiers pas avec Bash

La première question, c'est déjà où exécuter ces fameuses commandes ? Sous Windows, il faut accéder à l'invite de commande pour exécuter des commandes. Sous les environnements Linux, nous devons passer par un terminal afin d'exécuter des commandes.

❓ Mais comment je vais exécuter des commandes Linux si j'ai un Windows ?

Pour cela, il suffit juste de configurer le WSL pour avoir accès à un environnement Linux directement dans son Windows ! Et si vous êtes déjà sous Linux (ou MacOS), alors il suffit d'ouvrir le Terminal dans les applications, et nous voilà en face de notre Bash !

Commençons avec une toute première commande.

ls

La commande ls permet de lister les fichiers présents dans le répertoire courant, c'est-à-dire là où nous sommes positionnés. Si l'on remarque bien, il n'y a aucune sortie ! Et c'est tout à fait normal, puisque par défaut, il n'y a aucun fichier dans l'environnement.

Essayons de créer un fichier avec la commande touch.

touch fichier.txt

En exécutant à nouveau la commande ls, nous voyons que le fichier texte apparaît bien.

La commande ls va effectuer une action précise, qui consiste à lister les éléments d'un dossier. Ces commandes peuvent être utilisées avec des arguments, c'est-à-dire des paramètres permettant de détailler le comportement de la commande. Par exemple, la commande ls dispose des arguments -a et -l, qui permettent respectivement d'afficher les éléments cachés et de lister les éléments sur chaque ligne.

ls -a -l

total 48
drwsrwsr-x 8 jovyan users 4096 Feb  9 12:07 .
drwxr-xr-x 1 root   root  4096 Feb  8 06:21 ..
-rw-rw-r-- 1 jovyan users  220 Feb 25  2020 .bash_logout
-rw-rw-r-- 1 jovyan users 3823 Feb  8 06:21 .bashrc
drwsrwsr-x 4 jovyan users 4096 Feb  9 12:06 .cache
drwsrwsr-x 2 jovyan users 4096 Feb  9 12:06 .conda
drwxr-sr-x 3 jovyan users 4096 Feb  9 12:07 .config
-rw-r--r-- 1 jovyan users    0 Feb  9 12:07 fichier.txt
drwsrws--- 2 jovyan users 4096 Feb  9 12:06 .jupyter
drwxr-sr-x 3 jovyan users 4096 Feb  9 12:06 .local
drwsrwsr-x 2 jovyan users 4096 Feb  8 06:23 .npm
-rw-rw-r-- 1 jovyan users  807 Feb 25  2020 .profile
-rw-rw-r-- 1 jovyan users  227 Feb  9 12:01 .wget-hsts

Nous voyons beaucoup d'éléments ayant pour préfixe .. Dans les systèmes Linux, le . en préfixe indique que l'élément en question est un fichier ou dossier caché : il ne sera pas visible par défaut sans argument -a. C'est notamment utile pour ne pas afficher des fichiers ou dossiers de configuration et ne pas surcharger l'affichage du contenu.

Les deux premières éléments sont particulièrement intéressants.

• L'élément . concerne le répertoire lui-même. Par exemple, le chemin d'accès ./fichier.txt indique que l'on accède à l'élément nommé fichier.txt du répertoire courant.
• L'élément .. concerne le répertoire parent. Par exemple, le chemin d'accès ../fichier.txt indique que l'on accède à l'élément nommé fichier.txt du répertoire parent.

Cela est très utile pour naviguer entre les fichiers. Prenons un exemple en créant un dossier dans le répertoire courant.

mkdir dossier

Pour se diriger dans un dossier, nous utilise la commande cd (pour change directory), en spécifiant ensuite le chemin d'accès. Ce dernier peut être absolu (un chemin d'accès complet) ou relatif (par rapport au répertoire courant). Dirigeons-nous dans le dossier que nous venons de créer.

cd dossier

Nous pouvons voir d'après le préfixe de commande que nous sommes dans ~/dossier. Essayons d'afficher le contenu du fichier avec la commande cat.

cat ../fichier.txt

Rien ne s'affiche, là aussi parce que le fichier est vide. Essayons de modifier le contenu du fichier en ajoutant une ligne.

echo "Bonjour !" >> ../fichier.txt

La commande echo permet d'afficher un message. Ce qui est important ici, c'est la redirection >> : cela indique au système que le résultat de cette commande sera enregistré dans le fichier spécifié.

Affichons à nouveau le contenu du fichier.

cat ../fichier.txt

Bonjour !

Tout fonctionne bien ! Terminons par revenir au dossier parent.

cd ..

Il nous reste plus qu'à supprimer le dossier que nous venons de créer avec la commande rm.

rm dossier

rm: cannot remove 'dossier': Is a directory

Cette commande ne fonctionne pas. En effet, selon l'erreur affichée, nous ne pouvons pas supprimer directement l'élément car il s'agit d'un dossier. Pour cela, nous devons rajouter l'argument -r pour spécifier que l'on supprime de manière récursive l'élément, indispensable pour supprimer un dossier.

rm -r dossier

En exécutant à nouveau la commande ls, seul l'élément fichier.txt est présent.

Lecture et écriture de fichiers

Maintenant que nous avons abordé les principales commandes sous UNIX, allons un peu plus loin dans la gestion des fichiers.

À lire aussi : découvrez notre formation Cloud / DevOps

Éditeur nano

Une des premières difficultés lorsque l'on ne dispose pas d'interface graphique est de pouvoir éditer un fichier. Dans le terminal, cela n'est pas facile puisque tout doit s'effectuer sans la souris. Un des premiers éditeurs plutôt facile à prendre en main est nano. Ouvrons le fichier que nous avons créé avec nano.

nano fichier.txt

Pour se déplacer à l'intérieur de l'éditeur, nous devons utiliser les flèches du clavier, qui aura pour action de bouger le curseur vers la position désirée. Ajoutons une nouvelle ligne au fichier. Nous souhaitons maintenant enregistrer ce fichier.

Nous pouvons voir une barre d'outil en bas du terminal : cela indique quels sont les raccourcis clavier de nano. Par exemple, ^O, pour Ctrl+O, va avoir pour effet d'enregistrer le fichier. En appuyant sur les touches, nano demande vers quel fichier enregistrer le contenu (qui par défaut correspond au fichier ouvert).

Nous pouvons valider en appuyant sur Entrée. Pour quitter l'éditeur, toujours d'après la barre d'outils, nous devons appuyer sur Ctrl+X. Affichons le contenu du fichier.

cat fichier.txt

Bonjour !
Hello World !

Les modifications ont été correctement apportées.

Pipe

Le pipe est une opération très puissante qui permet d'utiliser la sortie d'une commande comme entrée d'une autre. Pour bien comprendre, nous allons créer le fichier lignes.txt qui va contenir mille lignes.

for((i=1;i<=1000;i+=1)); do echo "Ligne $i"; done >> lignes.txt

Si nous affichons le contenu du fichier, nous pouvons voir l'intégralité du contenu.

cat lignes.txt

Mais cela n'est pas forcément pertinent lorsque l'on souhaite avoir les 10 premières ou dernières lignes du fichier. Dans ce cas, les commandes tail et head vont se révéler utiles.

La commande tail permet d'afficher les $n$ dernières lignes d'un texte en spécifiant l'argument -n. Mais comment appliquer cette commande non pas sur du texte mais sur le contenu d'un fichier ? C'est ainsi que le pipe intervient. Avec l'opérateur |, nous utiliserons le résultat d'une commande précédente (à gauche du pipe) comme entrée de la commande suivante (à droite du pipe).

Analysons la commande suivante.

cat lignes.txt | tail -n 10

D'une part, la commande cat lignes.txt va afficher l'intégralité du fichier spécifié. D'autre part, la commande tail -n 10 va uniquement garder les 10 dernières lignes du texte mentionné. Puisqu'il n'y a pas de texte mentionné, c'est le pipe | qui fait la liaison et qui va automatiquement considérer la sortie de la première commande comme étant le texte à n'afficher que les 10 dernières lignes. Et comme prévu, nous obtenons bien le résultat escompté.

Ligne 991
Ligne 992
Ligne 993
Ligne 994
Ligne 995
Ligne 996
Ligne 997
Ligne 998
Ligne 999
Ligne 1000

Le fonctionnement est identique pour la commande head, qui affiche les premières lignes du fichier.

cat lignes.txt | head -n 10

Ligne 1
Ligne 2
Ligne 3
Ligne 4
Ligne 5
Ligne 6
Ligne 7
Ligne 8
Ligne 9
Ligne 10

Le pipe peut être appliqué à toute commande nécessitant des entrées de type texte. Par exemple, la commande grep permet de rechercher un contenu spécifique dans un ou plusieurs fichiers. Si l'on souhaite obtenir tous les mots commençant par Ligne 15, alors nous pouvons utiliser la commande grep 'Ligne 15' sur un ensemble de fichiers.

grep -i 'Ligne 15' lignes.txt 

Ligne 15
Ligne 15
Ligne 150
Ligne 151
Ligne 152
Ligne 153
Ligne 154
Ligne 155
Ligne 156
Ligne 157
Ligne 158
Ligne 159

La commande grep peut également être utilisée avec le pipe.

cat lignes.txt | grep 'Ligne 15'

Jusqu'ici, nous n'avons abordé qu'une infime partie des commandes Bash disponibles : vous pourrez trouver ici une liste détaillée de toutes les commandes Bash et de quelques utilitaires supplémentaires.

Quand doit-on utiliser Bash ?

Bien évidemment, la question ne se pose pas dès lors que l'on évolue dans un environnement Linux. Maintenant, il y a des situations où il est possible d'utiliser des langages de programmation (comme Python) plutôt que Bash : pour pouvoir faire ce choix, il faut garder à l'esprit que Bash ne nécessite pas d'installer un environnement d'exécution supplémentaire sur un système Linux.

À lire aussi : découvrez notre formation Cloud / DevOps

• Automatisation de tâches système : avec sa capacité de scripting, Bash est idéal pour automatiser des tâches système répétitives ou complexes. C'est ainsi qu'il est régulièrement utilisé pour automatiser des tâches d'installation d'applications ou de configuration systèmes.
• Automatisation de déploiements : Bash est également régulièrement utilisé dans les pipelines de déploiement, notamment pour les applications Web ou les logiciels qui seront amenés à être déployés sur des serveurs.
• Scripts de démarrage et d'arrêt du système : avec les services systèmes, Bash se pose comme une référence pour la gestion et l'administration de ces derniers. Dans un environnement DevOps, les scripts Bash interviennent fréquemment lors du démarrage de serveurs pour préparer l'exécution d'applications sur ces derniers.
• Environnement de développement : enfin, les développeurs vont également régulièrement utiliser Bash afin de configurer leurs environnements de développement. On retrouve ainsi beaucoup de commandes npm pour les développeurs Front, et beaucoup de commandes javac ou python pour les développeurs Back.

En conclusion, Bash est omniprésent dans le monde IT et intervient au-delà du contexte DevOps : maîtriser ce Shell permettra d'augmenter grandement sa productivité et permettra d'être beaucoup plus à l'aise pour effectuer des configurations systèmes.