Variables d'environnement Linux : des bases à l'utilisation avancée

Introduction

Bienvenue dans cet atelier pratique sur les variables d'environnement sous Linux ! Les variables d'environnement sont des valeurs dynamiques qui peuvent influencer le comportement des processus en cours d'exécution sur un ordinateur. Elles jouent un rôle crucial dans la configuration du système et l'exécution des programmes. En maîtrisant les variables d'environnement, vous acquerrez des compétences essentielles pour l'administration système Linux et le développement logiciel.

Dans cet atelier, vous apprendrez à créer, afficher, modifier et supprimer des variables d'environnement. Nous explorerons également comment rendre ces modifications permanentes et nous pencherons sur certaines des variables d'environnement intégrées les plus importantes de Linux. Que vous soyez débutant ou que vous cherchiez à consolider vos connaissances, cet atelier vous offrira une expérience pratique précieuse.

C'est parti !

Comprendre les variables sous Linux

Avant de plonger dans les variables d'environnement, commençons par les variables de shell de base. Cela vous aidera à comprendre le concept de variable sous Linux.

Ouvrez votre terminal. Vous devriez vous trouver dans le répertoire /home/labex/project. Si ce n'est pas le cas, vous pouvez vous y rendre en utilisant la commande suivante :
```
cd /home/labex/project
```
Créons maintenant une variable de shell simple. Sous Linux, vous pouvez créer une variable en assignant simplement une valeur à un nom. Créons une variable nommée my_var :
```
my_var="Hello, Linux"
```
Note importante : Lors de l'assignation de variables dans Bash (et Zsh, que nous utilisons dans cet atelier), il ne doit y avoir aucun espace autour du signe égal (=). my_var = "Hello, Linux" ou my_var= "Hello, Linux" provoquera une erreur.
Pour afficher la valeur de la variable, nous utilisons la commande echo avec un symbole $ devant le nom de la variable. Le $ indique au shell de substituer le nom par la valeur de la variable :
```
echo $my_var
```
Vous devriez voir le résultat suivant :
```
Hello, Linux
```
Vous pouvez également utiliser des variables à l'intérieur d'autres commandes ou assignations. Par exemple :
```
echo "The value of my_var is: $my_var"
```
Cela affichera : The value of my_var is: Hello, Linux

Excellent travail ! Vous venez de créer et d'utiliser votre première variable de shell. Cependant, cette variable n'est disponible que dans la session shell actuelle. Si vous ouvrez une nouvelle fenêtre ou un nouvel onglet de terminal, cette variable n'y sera pas accessible. C'est là que les variables d'environnement deviennent utiles.

Introduction aux variables d'environnement

Maintenant que nous comprenons les variables de base, explorons les variables d'environnement. Les variables d'environnement sont des variables accessibles à n'importe quel processus fils du shell. Cela signifie qu'elles peuvent être lues par des scripts et des programmes lancés depuis ce shell.

Pour afficher toutes les variables d'environnement actuelles, utilisez la commande env :
```
env
```
Cela affichera une longue liste de variables. Ne vous inquiétez pas si vous ne les comprenez pas toutes pour le moment ; nous aborderons les plus importantes plus tard.
L'une des variables d'environnement les plus cruciales est PATH. Jetons-y un œil :
```
echo $PATH
```
La variable PATH liste les répertoires dans lesquels le système cherche les programmes exécutables. Chaque répertoire est séparé par deux-points (:).
Créons maintenant notre propre variable d'environnement. Nous utilisons la commande export pour cela :
```
export MY_ENV_VAR="This is an environment variable"
```
La commande export rend la variable disponible pour les processus fils. C'est la différence fondamentale entre une variable de shell et une variable d'environnement.
Pour illustrer cette différence, créons un script shell qui tente d'accéder à la fois à une variable de shell classique et à une variable d'environnement. Nous utiliserons un heredoc avec la commande cat, une méthode courante pour écrire du contenu multi-lignes dans un fichier :
```
cat << 'EOF' > test_vars.sh
#!/bin/bash
echo "Shell variable: $my_var"
echo "Environment variable: $MY_ENV_VAR"
EOF
```
Rendez le script exécutable :
```
chmod +x test_vars.sh
```
Maintenant, lancez le script :
```
./test_vars.sh
```
Vous constaterez que la variable d'environnement (MY_ENV_VAR) est accessible, alors que la variable de shell (my_var) ne l'est pas. C'est parce que my_var n'a pas été exportée, donc les processus fils (comme ce script) ne la connaissent pas.
Pour vérifier que MY_ENV_VAR est bien une variable d'environnement, nous pouvons utiliser à nouveau la commande env, mais cette fois en filtrant le résultat avec grep :
```
env | grep MY_ENV_VAR
```
Vous devriez voir votre nouvelle variable s'afficher.
Vous pouvez également vérifier directement la valeur de votre nouvelle variable d'environnement :
```
echo $MY_ENV_VAR
```

Parfait ! Vous avez créé votre première variable d'environnement et compris en quoi elle diffère d'une variable de shell. Le point clé est que les variables d'environnement, créées avec export, sont transmises aux processus fils, contrairement aux variables de shell.

Les variables d'environnement et les variables de shell ont chacune leur propre portée. Lorsque vous exportez une variable (ex: export MY_ENV_VAR="quelquechose"), elle devient disponible pour tout sous-processus démarré depuis ce shell (par exemple, un script shell lancé par ce même shell). Cependant, si vous ouvrez une session shell totalement séparée, elle n'héritera pas des variables de votre shell actuel, à moins que vous ne les définissiez spécifiquement dans un fichier de démarrage (comme .zshrc ou .bashrc).

En d'autres termes :

Une variable de shell classique n'est visible que dans la session actuelle.
Une variable exportée est disponible pour les processus fils lancés depuis cette session.
Une variable définie dans un fichier de démarrage du shell (comme .zshrc) est appliquée à toutes les nouvelles sessions de ce shell.

Vous ne pouvez pas lire directement les variables d'un autre utilisateur ou d'un autre shell, car chaque processus gère son propre environnement. Si vous lancez un nouveau shell, il reçoit une copie des variables exportées du parent, mais pas les variables définies uniquement dans le shell d'origine sans export.

Nous apprendrons comment définir des variables d'environnement de manière permanente dans les étapes suivantes.

Niveaux de permanence des variables

Pour vous aider à visualiser les différences entre ces types de variables et leurs niveaux de permanence, voici une vue d'ensemble complète :

graph LR
    A["Types de variables Linux"] --> B["Variable de Shell"]
    A --> C["Variable d'Environnement"]
    A --> D["Variable Permanente"]

    B --> B1["Session uniquement"]
    B --> B2["Non héritée"]
    B --> B3["Perdue à la fermeture"]

    C --> C1["Portée de session"]
    C --> C2["Accès par les fils"]
    C --> C3["Perdue à la fermeture"]

    D --> D1["Toutes les sessions"]
    D --> D2["Accès par les fils"]
    D --> D3["Persistante"]

    B1 --> E1["my_var='valeur'"]
    C2 --> E2["export VAR='valeur'"]
    D3 --> E3["Fichier ~/.zshrc"]

    style B fill:#ffebee
    style C fill:#fff3e0
    style D fill:#e8f5e8

Ce diagramme montre les trois niveaux de permanence. Voici un tableau récapitulatif pour référence rapide :

Type de variable	Portée	Accès processus fils	Persistance	Exemple de syntaxe
Variable de Shell	Session actuelle uniquement	Non	Perdue à la sortie	`my_var='valeur'`
Variable d'Environnement	Session actuelle	Oui	Perdue à la sortie	`export VAR='valeur'`
Variable Permanente	Toutes les nouvelles sessions	Oui	Survit à la sortie	Dans le fichier `~/.zshrc`

Comprendre ces trois niveaux est crucial pour une administration système Linux efficace et vous aidera à choisir la bonne approche selon les scénarios.

Modifier la variable d'environnement PATH

La variable PATH est l'une des variables d'environnement les plus importantes sous Linux. Elle indique au système où chercher les fichiers exécutables. Modifions-la pour inclure un nouveau répertoire.

Tout d'abord, créons un nouveau répertoire où nous pourrions stocker des scripts personnalisés :
```
mkdir ~/my_scripts
```
Cela crée un répertoire nommé my_scripts dans votre dossier personnel. Le symbole ~ est un raccourci pour le chemin de votre répertoire personnel, qui est /home/labex dans cet atelier.
Ajoutons maintenant ce nouveau répertoire à votre PATH. Nous utiliserons la commande export, mais cette fois pour modifier une variable existante :
```
export PATH="$PATH:$HOME/my_scripts"
```
Analysons cette commande :
- $PATH représente la valeur actuelle de la variable d'environnement PATH. Nous utilisons la valeur existante et y ajoutons quelque chose.
- : est utilisé pour séparer les répertoires dans le PATH. Si vous oubliez les deux-points, le shell ne pourra pas trouver les exécutables dans le répertoire ajouté.
- $HOME est une variable d'environnement qui pointe vers votre répertoire personnel (encore une fois, /home/labex dans notre cas).
- Ainsi, nous ajoutons :$HOME/my_scripts à la fin du PATH existant. Cela indique au système de chercher des exécutables dans my_scripts après avoir parcouru les répertoires du PATH d'origine.
Vérifiez que le nouveau répertoire a bien été ajouté :
```
echo $PATH
```
Vous devriez voir /home/labex/my_scripts à la fin du résultat. S'il n'est pas à la fin, vous l'avez peut-être modifié différemment, ce qui n'est pas grave tant que le chemin /home/labex/my_scripts figure bien dans votre PATH.
Pour tester cela, créons un script simple dans notre nouveau répertoire :
```
cat << 'EOF' > ~/my_scripts/hello.sh
#!/bin/zsh
echo "Hello from my custom script!"
EOF
```
Cela crée un script shell nommé hello.sh dans le répertoire ~/my_scripts. La première ligne, #!/bin/zsh, indique au système qu'il s'agit d'un script zsh, lui permettant d'être exécuté comme un programme.
Rendez le script exécutable :
```
chmod +x ~/my_scripts/hello.sh
```
La commande chmod +x ajoute les permissions d'exécution au script. Si vous sautez cette étape, vous obtiendrez une erreur "permission denied" (permission refusée) en essayant de l'exécuter.
Désormais, vous devriez pouvoir lancer ce script de n'importe où en tapant simplement son nom :
```
hello.sh
```
Si tout a fonctionné correctement, vous devriez voir : Hello from my custom script!

Cela fonctionne car nous avons ajouté le répertoire my_scripts au PATH. Lorsque vous tapez une commande, le shell cherche un fichier exécutable portant ce nom dans chacun des répertoires listés dans le PATH, dans l'ordre. En ajoutant my_scripts au PATH, nous avons dit au shell d'y chercher également des exécutables.

Pour le démontrer, essayez de changer de répertoire et de relancer le script :

cd /tmp
hello.sh

Vous verrez que le script s'exécute toujours, même si vous n'êtes pas dans le répertoire où il se trouve. C'est toute la puissance de la variable PATH : elle vous permet de lancer des exécutables de n'importe où dans le système, tant qu'ils se trouvent dans un répertoire listé dans le PATH.

Excellent ! Vous avez modifié avec succès la variable d'environnement PATH et créé un script personnalisé exécutable partout.

Rendre les variables d'environnement permanentes

Les variables d'environnement que nous avons définies seront perdues à la fermeture du terminal. Pour les rendre permanentes, nous devons les ajouter à un fichier de configuration du shell. Le fichier exact dépend du shell que vous utilisez.

Dans cet environnement d'atelier, nous utilisons le Z shell (zsh), une version étendue du Bourne Shell (sh) avec de nombreuses améliorations. Zsh est devenu très populaire et est désormais le shell par défaut sur macOS.

Si vous utilisiez Bash (le shell par défaut sur de nombreuses distributions Linux), vous modifieriez .bashrc. Cependant, comme nous utilisons Zsh, nous modifierons .zshrc. Il est très important d'utiliser le bon fichier. Si vous modifiez .bashrc alors que vous utilisez zsh, les variables ne seront pas prises en compte.

Ouvrez le fichier .zshrc situé dans votre répertoire personnel avec un éditeur de texte. Nous utiliserons nano, un éditeur simple en ligne de commande :
```
nano ~/.zshrc
```
Cette commande ouvre le fichier ~/.zshrc. Ce fichier est exécuté à chaque fois que vous démarrez une nouvelle session de terminal.
Faites défiler jusqu'au bas du fichier (utilisez les touches fléchées) et ajoutez les lignes suivantes :
```
export MY_ENV_VAR="This is an environment variable"
export PATH="$PATH:$HOME/my_scripts"
```
Veillez à ajouter ces lignes tout à la fin. Vérifiez l'orthographe et la syntaxe, en vous assurant notamment qu'il n'y a pas d'espaces autour du signe =.
Enregistrez le fichier et quittez l'éditeur. Dans nano, faites Ctrl+X, puis Y (pour enregistrer), puis Entrée.
Pour appliquer ces changements sans redémarrer votre terminal, utilisez la commande source :
```
source ~/.zshrc
```
La commande source lit et exécute les commandes du fichier spécifié dans l'environnement shell actuel. C'est différent d'une simple exécution via bash ~/.zshrc, qui lancerait le script dans un nouveau shell sans affecter l'actuel. source l'exécute dans le shell actuel pour que vos modifications soient immédiates. Si vous sautez cette étape, vos modifications ne seront pas visibles dans votre terminal actuel, et vous devrez le fermer puis le rouvrir pour voir les changements.

Désormais, ces variables d'environnement seront définies à chaque ouverture d'un nouveau terminal. C'est extrêmement utile pour configurer votre environnement de développement de manière cohérente.

Comprendre les variables d'environnement importantes

Linux possède plusieurs variables d'environnement intégrées qui sont cruciales pour le fonctionnement du système. Explorons-en quelques-unes :

HOME : Pointe vers le répertoire personnel de l'utilisateur actuel.
```
echo $HOME
```
USER : Contient le nom d'utilisateur de l'utilisateur actuel.
```
echo $USER
```
SHELL : Spécifie le shell par défaut de l'utilisateur.
```
echo $SHELL
```
PWD : Signifie "Print Working Directory" (Afficher le répertoire de travail). Elle contient le chemin du répertoire actuel.
```
echo $PWD
```
TERM : Spécifie le type de terminal à émuler lors de l'exécution du shell.
```
echo $TERM
```

Comprendre ces variables peut vous aider à mieux naviguer et contrôler votre environnement Linux.

Supprimer des variables d'environnement

Parfois, vous pouvez avoir besoin de supprimer une variable d'environnement. Cela se fait à l'aide de la commande unset.

Tout d'abord, vérifions si notre variable MY_ENV_VAR est toujours définie :
```
echo $MY_ENV_VAR
```
Vous devriez voir la valeur définie précédemment.
Pour supprimer cette variable, utilisez la commande unset :
```
unset MY_ENV_VAR
```
Vérifiez que la variable a bien été supprimée :
```
echo $MY_ENV_VAR
```
Vous ne devriez voir aucun résultat, ce qui indique que la variable n'existe plus.
Vous pouvez également utiliser l'option -v avec unset pour vous assurer que vous supprimez une variable et non une fonction shell :
```
unset -v MY_ENV_VAR
```
Cela produira le même résultat que unset MY_ENV_VAR.

Rappelez-vous que si vous avez ajouté la variable à votre fichier .zshrc, elle sera recréée la prochaine fois que vous ouvrirez un terminal ou que vous sourcerez le fichier .zshrc.

Résumé

Félicitations ! Vous avez terminé cet atelier complet sur les variables d'environnement Linux. Récapitulons ce que vous avez appris :

Vous avez créé et accédé à des variables de shell simples, en comprenant leur portée.
Vous avez découvert les variables d'environnement et leur différence avec les variables de shell, notamment leur accessibilité par les processus fils, et comment la commande export est la clé de ce mécanisme.
Vous avez modifié l'importante variable PATH pour inclure un répertoire personnalisé, vous permettant de lancer des scripts de n'importe où, et avez appris l'importance du symbole deux-points : pour séparer les entrées.
Vous avez rendu les variables d'environnement permanentes en les ajoutant à .zshrc, en comprenant la différence entre les configurations Bash et Zsh, et l'importance d'utiliser source pour appliquer les changements.
Vous avez exploré certaines des variables d'environnement intégrées les plus importantes de Linux.
Enfin, vous avez appris à supprimer des variables d'environnement à l'aide de la commande unset.

Ces compétences sont fondamentales pour l'administration système Linux et le développement logiciel. Les variables d'environnement vous permettent de configurer votre système et vos applications de manière flexible. Au fur et à mesure de votre progression sur Linux, vous trouverez d'innombrables utilisations pour les variables d'environnement dans l'écriture de scripts, le développement et la configuration système.

N'oubliez pas que c'est en forgeant qu'on devient forgeron. Essayez de créer vos propres variables d'environnement pour différents usages, et explorez comment diverses applications et scripts les utilisent pour contrôler leur comportement. Bon apprentissage !

Les variables d'environnement sous Linux