2.1 Leçon 2

Certification :

Linux Essentials

Version :

1.6

Thème :

2 Trouver son Chemin sur un Système Linux

Objective:

2.1 Principes de base de la Ligne de Commande

Lesson:

2 sur 2

Introduction

Tous les shells gèrent un ensemble d’informations d’état tout au long des sessions shell. Ces informations d’exécution peuvent changer pendant la session et influencer le comportement du shell. Ces données sont également utilisées par les programmes pour déterminer certains aspects de la configuration du système. La plupart de ces données sont stockées dans ce que l’on appelle des variables, que nous allons aborder dans cette leçon.

Les Variables

Les variables sont des éléments de stockage de données, tels que du texte ou des nombres. Une fois définie, la valeur d’une variable peut être consultée ultérieurement. Les variables ont un nom qui permet d’accéder à une variable spécifique, même lorsque le contenu de la variable change. Elles constituent un outil très courant dans la plupart des langages de programmation.

Dans la plupart des shells Linux, il existe deux types de variables :

Variables locales: Ces variables ne sont disponibles que pour le processus shell actuel. Si vous créez une variable locale et que vous lancez ensuite un autre programme à partir de ce shell, la variable n’est plus accessible pour ce programme. Comme elles ne sont pas héritées par les sous-processus, ces variables sont appelées variables locales.
Variables d’environnement: Ces variables sont disponibles à la fois dans une session shell spécifique et dans des sous-processus issus de cette session shell. Ces variables peuvent être utilisées pour transmettre des données de configuration aux commandes qui sont exécutées. Comme ces programmes peuvent accéder à ces variables, elles sont appelées variables d’environnement. La majorité des variables d’environnement sont en majuscules (par exemple PATH, DATE, USER). Un ensemble de variables d’environnement par défaut fournit, par exemple, des informations sur le répertoire personnel de l’utilisateur ou le type de terminal. Parfois, l’ensemble de toutes les variables d’environnement est appelé environnement.

Note

Les variables ne sont pas persistantes. Lorsque le shell dans lequel elles ont été définies est fermé, toutes les variables et leur contenu sont perdus. La plupart des shells fournissent des fichiers de configuration qui contiennent des variables qui sont définies à chaque fois qu’un nouveau shell est lancé. Les variables qui doivent être définies de manière permanente doivent être ajoutées à l’un de ces fichiers de configuration.

Manipulater des Variables

En tant qu’administrateur du système, vous devrez créer, modifier ou supprimer les variables locales et d’environnement.

Travailler avec des Variables Locales

Vous pouvez définir une variable locale en utilisant l’opérateur = (égal). Une simple affectation permet de créer une variable locale :

$ greeting=hello

Note	Ne mettez pas d’espace avant ou après l’opérateur `=`.

Vous pouvez afficher n’importe quelle variable en utilisant la commande echo. La commande affiche généralement le texte de sa section argument :

$ echo greeting
greeting

Pour accéder à la valeur de la variable, vous devrez utiliser $ (signe dollar) devant le nom de la variable.

$ echo $greeting
hello

Comme on peut le voir, la variable a été créée. Ouvrez maintenant un autre shell et essayez d’afficher le contenu de la variable créée.

$ echo $greeting

Rien n’est affiché. Cela montre que les variables n’existent toujours que dans un shell spécifique.

Pour vérifier que la variable est bien une variable locale, essayez d’engendrer un nouveau processus et vérifiez si ce processus peut accéder à la variable. Nous pouvons le faire en démarrant un autre shell et en laissant ce shell exécuter la commande echo. Comme le nouveau shell est lancé dans un nouveau processus, il n’héritera pas des variables locales de son processus parent :

$ echo $greeting world
hello world
$ bash -c 'echo $greeting world'
world

Note	Veillez à utiliser des guillemets simples dans l’exemple ci-dessus.

Pour supprimer une variable, vous devez utiliser la commande unset :

$ echo $greeting
hey
$ unset greeting
$ echo $greeting

Note	`unset` nécessite le nom de la variable comme argument. Vous ne pouvez donc pas ajouter `$` au nom, car cela résoudrait la variable et ferait passer la valeur de la variable à `unset` au lieu du nom de la variable.

Travailler avec des Variables Globales

Pour mettre une variable à la disposition des sous-processus, il faut la transformer d’une variable locale en une variable d’environnement. Cela se fait par la commande export. Lorsqu’elle est invoquée avec le nom de la variable, cette variable est ajoutée à l’environnement du shell :

$ greeting=hello
$ export greeting

Note	Encore une fois, assurez-vous de ne pas utiliser `$` lorsque vous exécutez la commande `export` car vous voulez passer le nom de la variable au lieu de son contenu.

Une façon plus facile de créer la variable d’environnement est de combiner les deux méthodes ci-dessus, en attribuant la valeur de la variable dans la partie argument de la commande.

$ export greeting=hey

Vérifions à nouveau si la variable est accessible aux sous-processus :

$ export greeting=hey
$ echo $greeting world
hey world
$ bash -c 'echo $greeting world'
hey world

Une autre façon d’utiliser les variables d’environnement est de les utiliser devant des commandes. Nous pouvons tester cela avec la variable d’environnement TZ qui contient le fuseau horaire. Cette variable est utilisée par la commande date pour déterminer le fuseau horaire à afficher :

$ TZ=EST date
Thu 31 Jan 10:07:35 EST 2019
$ TZ=GMT date
Thu 31 Jan 15:07:35 GMT 2019

Vous pouvez afficher toutes les variables d’environnement à l’aide de la commande env.

La Variable `PATH`

La variable PATH est l’une des variables d’environnement les plus importantes dans un système Linux. Elle stocke une liste de répertoires, séparés par deux points, qui contiennent des programmes exécutables éligibles comme commandes du shell Linux.

$ echo $PATH
/home/user/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games

Pour ajouter un nouveau répertoire à la variable, vous devrez utiliser le signe deux-points (:).

$ PATH=$PATH:new_directory

Voici un exemple :

$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
$ PATH=$PATH:/home/user/bin
$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/home/user/bin

Comme vous le voyez, $PATH est utilisé dans la nouvelle valeur attribuée à PATH. Cette variable est résolue lors de l’exécution de la commande et permet de s’assurer que le contenu original de la variable est préservé. Bien entendu, vous pouvez également utiliser d’autres variables dans l’affectation :

$ mybin=/opt/bin
$ PATH=$PATH:$mybin
$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/home/user/bin:/opt/bin

La variable PATH doit être manipulée avec prudence, car elle est cruciale pour le travail en ligne de commande. Considérons la variable PATH suivante :

$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

Pour savoir comment le shell invoque une commande spécifique, la commande which peut être exécutée avec le nom de la commande comme argument. On peut, par exemple, essayer de savoir où est stocké la commande nano :

$ which nano
/usr/bin/nano

Comme on peut le voir, l’exécutable de nano est situé dans le répertoire /usr/bin. Supprimons le répertoire de la variable et vérifions si la commande fonctionne toujours :

$ PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/sbin:/bin:/usr/games
$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/sbin:/bin:/usr/games

Regardons encore une fois la commande nano :

$ which nano
which: no nano in (/usr/local/sbin:/usr/local/bin:/usr/sbin:/sbin:/bin:/usr/games)

Comme on peut le voir, la commande n’est pas trouvée, donc pas exécutable. Le message d’erreur explique également la raison pour laquelle la commande n’a pas été trouvée et dans quels endroits elle a été recherchée.

Remettons les répertoires et exécutons à nouveau la commande.

$ PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
$ which nano
/usr/bin/nano

Maintenant, notre commande fonctionne à nouveau.

Tip	L’ordre des éléments dans `PATH` définit également l’ordre de recherche. Le premier exécutable correspondant trouvé en parcourant les chemins s’il est exécuté.

Exercices Guidés

Créez une variable locale number.
Créez une variable d’environnement ORDER, en utilisant l’une des deux méthodes ci-dessus.
Affichez les noms des variables et leurs contenus.
Quelles sont les portées des variables créées précédemment ?

Exercices d’Exploration

Créez une variable locale nr_files et affectez-lui le nombre de lignes trouvées dans le fichier /etc/passwd. Astuce : Examinez la commande wc et la substitution de commande et n’oubliez pas les guillemets.
Créez une variable d’environnement ME. Attribuez-lui la valeur de la variable USER.
Ajoutez la valeur de la variable HOME à ME, avec le délimiteur :. Affichez le contenu de la variable ME.
En utilisant l’exemple de date ci-dessus, créez une variable appelée today et attribuez-lui la date de l’un des fuseaux horaires.
Créez une autre variable appelée today1 et attribuez-lui la date du système.

Résumé

Dans cet atelier, vous avez appris :

Les types de variables
Comment créer des variables
Comment manipuler les variables

Commandes utilisées dans les exercices :

env: Affiche l’environnement actuel.
echo: Affiche du texte.
export: Met les variables locales à la disposition des sous-processus.
unset: Supprime une variable.

Réponses aux Exercices Guidés

Créez une variable locale number.
```
$ number=5
```
Créez une variable d’environnement ORDER, en utilisant l’une des deux méthodes ci-dessus.
```
$ export ORDER=desc
```

Afficher les noms des variables et leur contenu.

$ echo number
number
$ echo ORDER
ORDER
$ echo $number
5
$ echo $ORDER
desc

Quelles sont les portées des variables créées précédemment ?
- La portée de la variable locale number est limitée au shell actuel.
- La portée de la variable d’environnement ORDER est le shell actuel et tous les sous-shells générés par celui-ci.

Réponses aux Exercices d’Exploration

Créez une variable locale nr_files et affectez-lui le nombre de lignes trouvées dans le fichier /etc/passwd. Astuce : Examinez la commande wc et la substitution de commande et n’oubliez pas les guillemets.
```
$ nr_files=`wc -l /etc/passwd`
```
Créez une variable d’environnement ME. Attribuez-lui la valeur de la variable USER.
```
$ export ME=$USER
```
Ajoutez la valeur de la variable HOME à ME, avec le délimiteur :. Affichez le contenu de la variable ME.
```
$ ME=$ME:$HOME
$ echo $ME
user:/home/user
```
En utilisant l’exemple de date ci-dessus, créez une variable appelée today et attribuez la date pour l’un des fuseaux horaires.

Les paragraphes suivants utilisent les fuseaux horaires GMT et EST à titre d’exemple, mais toute sélection de fuseau horaire est valable.
```
$ today=$(TZ=GMT date)
$ echo $today
Thu 31 Jan 15:07:35 GMT 2019
```
ou
```
$ today=$(TZ=EST date)
$ echo $today
Thu 31 Jan 10:07:35 EST 2019
```
Créez une autre variable appelée today1 et attribuez-lui la date du système.

En supposant que vous êtes en GMT :
```
$ today1=$(date)
$ echo $today1
Thu 31 Jan 10:07:35 EST 2019
```