Le guide des variables d'environnement pour les data scientists

Il vous est peut-être arrivé qu'un logiciel demande l'autorisation de modifier votre variable PATH, ou qu'une notice d'installation précise mystérieusement que vous devez « configurer correctement votre variable LD_LIBRARY_PATH ».

En tant que data scientist, vous pouvez rencontrer d'autres problèmes liés aux variables d'environnement lorsque vous interagissez avec votre pile de calcul (surtout si vous n'en avez pas le contrôle total, comme cela m'arrive). Cet article vise à démystifier ce qu'est une variable d'environnement et comment elle est utilisée dans un contexte data science.

Qu'est-ce qu'une variable d'environnement ?

Pour commencer, expliquons ce qu'est une variable d'environnement en détaillant la variable PATH. Je vous encourage à exécuter les commandes indiquées ici dans votre terminal bash (avec les adaptations nécessaires — lisez le texte pour comprendre la logique !).

Lorsque vous vous connectez à votre système, par exemple au terminal de votre ordinateur ou à un serveur distant via SSH, votre interpréteur bash doit savoir où chercher certains programmes, comme nano (l'éditeur de texte), git (votre outil de gestion de versions) ou l'exécutable Python. C'est la variable PATH qui s'en charge. Elle indique les chemins vers les dossiers où se trouvent vos programmes exécutables.

Par convention historique, les programmes en ligne de commande comme nano, which et top se trouvent dans le répertoire /usr/bin. (Toujours par convention, le dossier /bin est dédié aux binaires, d'où son nom /bin.) Ces programmes sont livrés avec votre système d'exploitation et nécessitent des permissions particulières pour être mis à jour.

Essayez dans votre terminal :

$ which which
/usr/bin/which
$ which top
/usr/bin/top

D'autres programmes sont installés (pour diverses raisons) dans /bin. C'est le cas de ls :

$ which ls
/bin/ls

D'autres encore peuvent être placés dans des répertoires spécifiques :

$ which nano
/usr/local/bin/nano

Comment votre terminal Bash sait-il où chercher ? Il utilise la variable d'environnement PATH. Elle ressemble à ceci :

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

Point essentiel : la variable PATH est « délimitée par des deux-points ». Autrement dit, chaque chemin de répertoire est séparé du suivant par le caractère « : ». L'ordre de recherche de bash va de gauche à droite :

• /usr/bin
• /bin
• /usr/local/bin

Sur mon ordinateur, lorsque je tape ls, bash regarde d'abord dans /usr/bin. Il constate que ls n'y existe pas et passe au dossier suivant, /bin. Comme ls y est présent, il exécute le programme depuis cet emplacement.

Vous voyez donc que c'est à la fois très flexible pour personnaliser votre environnement de calcul, mais aussi potentiellement très frustrant si un programme modifie votre variable PATH à votre insu.

Peut-on vraiment modifier la variable PATH ? Oui, et il existe plusieurs façons de le faire.

Comment modifier la variable PATH

Utiliser une session Bash

La première méthode est transitoire, donc temporaire, et ne vaut que pour votre session bash en cours. Vous pouvez donner une priorité plus élevée à un dossier en le « préfixant » dans la variable PATH :

$ export PATH=/path/to/my/folder:$PATH
$ echo $PATH
/path/to/my/folder:/usr/bin:/bin:/usr/local/bin

Ou lui attribuer une priorité plus faible en l'« ajoutant à la fin » de la variable PATH :

$ export PATH=$PATH:/path/to/my/folder
$ echo $PATH
/usr/bin:/bin:/usr/local/bin:/path/to/my/folder

C'est temporaire, car l'export n'est effectué que dans votre session bash actuelle.

Fichier bashrc ou .bash_profile

Pour rendre les changements plus durables, vous pouvez les inscrire dans votre fichier .bashrc ou .bash_profile (je recommande .bashrc). Ces fichiers, situés dans votre répertoire personnel (spécifié par la variable $HOME), sont exécutés au démarrage de l'interpréteur bash, qui lance alors toutes les commandes qu'ils contiennent. Vous pouvez donc modifier votre variable PATH en ajoutant simplement dans votre .bashrc :

...autres lignes au-dessus...
# Donner une priorité plus élevée à /path/to/folder
export PATH=/path/to/folder:$PATH

# Donner une priorité plus faible à /path/to/other/folder
export PATH=$PATH:/path/to/folder
...autres lignes en dessous...

Data science et variable d'environnement PATH

Quel est l'intérêt pour un data scientist ? Si vous faites de la data science, vous utilisez sans doute Python, et votre interpréteur provient probablement de la distribution Anaconda (excellente option, au passage). L'installateur Anaconda donne la priorité au dossier /path/to/anaconda/bin dans la variable PATH. Vous pouvez avoir d'autres interpréteurs Python installés sur votre système (Apple en fournit un, par exemple). Cette modification de PATH garantit toutefois qu'à chaque fois que vous tapez python dans votre terminal Bash, c'est l'interpréteur fourni par Anaconda qui est exécuté. Chez moi, après installation d'Anaconda, mon PATH ressemble à ceci :

$ echo $PATH
/Users/ericmjl/anaconda/bin:/usr/bin:/bin:/usr/local/bin

Encore mieux, les environnements conda préfixent le chemin du dossier des binaires de l'environnement actif. Par exemple, pour mon blog, j'utilise un environnement nommé lektor. Ainsi...

$ echo $PATH
/Users/ericmjl/anaconda/bin:/usr/bin:/bin:/usr/local/bin
$ which python
/Users/ericmjl/anaconda/bin/python
$ source activate lektor
$ echo $PATH
/Users/ericmjl/anaconda/envs/lektor/bin:/Users/ericmjl/anaconda/bin:/usr/bin:/bin:/usr/local/bin
$ which python
/Users/ericmjl/anaconda/envs/lektor/bin/python

Remarquez que le terminal bash privilégie désormais le Python de l'environnement lektor, placé plus haut dans la hiérarchie.

Si vous en êtes arrivé là, vous avez sans doute identifié quelques notions clés. Récapitulons :

• PATH est une variable d'environnement stockée comme une chaîne de texte, utilisée par bash pour localiser les programmes exécutables.
• PATH est délimitée par des deux-points : les répertoires prioritaires sont à gauche, ceux de moindre priorité à droite.
• On peut modifier PATH en préfixant ou suffixant des répertoires. C'est possible de façon temporaire dans une session bash via la commande export, ou de façon persistante en ajoutant une ligne export dans votre .bashrc ou .bash_profile.

Autres variables d'environnement utiles

Quelles autres variables un data scientist est-il susceptible de croiser ? En voici un échantillon, à connaître et parfois à corriger, surtout quand vos administrateurs système sont en congés (ou mettent du temps à répondre).

Pour un usage général, il est essentiel de connaître l'emplacement de votre dossier HOME : sur Linux, c'est souvent /home/username, sur macOS /Users/username. Pour le vérifier :

$ echo $HOME
/Users/ericmjl

Si vous utilisez Python, la variable PYTHONPATH peut s'avérer utile. Elle est utilisée par l'interpréteur Python et indique où trouver les modules/paquets Python.

Si vous manipulez des bibliothèques C++, connaître la variable LD_LIBRARY_PATH est crucial. Je ne suis pas assez spécialiste pour en parler en détail, je vous renvoie donc à ce site pour les bonnes pratiques liées à LD_LIBRARY_PATH.

Si vous travaillez avec Spark, la variable PYSPARK_PYTHON vous intéressera. Elle indique à Spark quel Python utiliser pour le driver et les workers. Vous pouvez aussi définir PYSPARK_DRIVER_PYTHON séparément de PYSPARK_PYTHON si besoin.

Optimiser vos variables d'environnement

C'est là que ça devient amusant ! Voici quelques idées pour tirer parti de vos variables d'environnement.

Astuce n°1 : activer l'accès à PyPy. Je suis de près le développement de PyPy, mais comme PyPy n'est pas encore l'interpréteur Python par défaut et n'est pas conda install-able, je l'installe dans un dossier dédié $HOME/pypy/bin. Pour y accéder, je dois m'assurer que le chemin /path/to/pypy figure dans la variable PATH, avec une priorité inférieure à mon interpréteur CPython habituel.

Astuce n°2 : activer d'autres interpréteurs/compilateurs. Même logique que pour PyPy. J'ai par exemple testé l'interpréteur JIT de Lua pour utiliser Torch en deep learning et j'ai dû ajouter le chemin correspondant dans mon .bashrc.

Astuce n°3 : installer des paquets Python dans votre répertoire personnel. Sur des systèmes Linux partagés qui utilisent le système de modules plutôt que des environnements conda, il se peut qu'un modulefile chargé soit configuré avec un environnement virtuel que vous ne pouvez pas modifier. Pour installer un paquet Python, vous pouvez utiliser pip install --user my_pkg_name. Le paquet sera alors installé dans $HOME/.local/lib/python-[version]/site-packages/. Il faudra alors veiller à ce que votre PYTHONPATH inclue $HOME/.local/lib/python-[version]/site-packages avec une priorité suffisante.

Astuce n°4 : déboguer quand ça déraille. Si une erreur survient ou qu'un comportement inattendu apparaît — par exemple, j'ai déjà eu un Python introuvable après chargement de modules Linux — vous pouvez déboguer en réinitialisant temporairement votre variable PATH à des « valeurs par défaut », puis en la personnalisant progressivement.

Pour cela, placez les lignes suivantes dans un fichier nommé .path_default dans votre répertoire personnel :

export PATH=""  # réinitialise PATH à une chaîne vide.
export PATH=/usr/bin:/bin:/usr/local/bin:$PATH  # valeur par défaut raisonnable ; adaptez au besoin.

Après un incident, vous pouvez réinitialiser votre variable PATH avec la commande « source » :

$ echo $PATH
/some/complicated/path:/more/complicated/paths:/really/complicated/paths
$ source ~/.path_default
$ echo $PATH
/usr/bin:/bin:/usr/local/bin

Remarque : vous pouvez aussi exécuter ces mêmes commandes directement dans votre session bash ; l'interactivité peut aider.

Conclusion

J'espère que cet article vous a été utile et qu'il vous donnera, ahem, la bonne voie à suivre lorsque vous croiserez ces variables d'environnement !