Guida alle variabili d'ambiente per data scientist

Ti sarà capitato che un software ti chiedesse il permesso di modificare la variabile PATH, oppure di leggere istruzioni d'installazione che, in modo un po' criptico, ti dicono che devi "impostare correttamente la variabile LD_LIBRARY_PATH".

Come data scientist, potresti imbatterti in altri problemi legati alle variabili d'ambiente quando interagisci con il tuo stack di calcolo (soprattutto se non ne hai il controllo totale, come succede a me). Questo post vuole demistificare cosa sia una variabile d'ambiente e come venga usata nel contesto della data science.

Che cos'è una variabile d'ambiente?

Per iniziare, lascia che ti spieghi cos'è una variabile d'ambiente andando a fondo sulla variabile PATH. Ti invito a eseguire i comandi qui mostrati nel tuo terminale bash (con le opportune modifiche — leggi il testo per capire cosa sto facendo!).

Quando accedi al tuo sistema, per esempio al terminale del computer locale o a un server remoto via SSH, il tuo interprete bash deve sapere dove cercare determinati programmi, come nano (l'editor di testo), git (il software di controllo versione) o l'eseguibile di Python. Questo è controllato dalla variabile PATH. Specifica i percorsi alle cartelle in cui si trovano i programmi eseguibili.

Per convenzione storica, i programmi a riga di comando, come nano, which e top, si trovano nella directory /usr/bin. (Sempre per convenzione, la cartella /bin è per i binari del software, da cui il nome /bin.) Questi sono quelli forniti con il sistema operativo e, in quanto tali, richiedono permessi speciali per essere aggiornati.

Prova nel tuo terminale:

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

Altri programmi vengono installati (per vari motivi) in /bin. ls è un esempio:

$ which ls
/bin/ls

Altri ancora potrebbero essere installati in directory speciali diverse:

$ which nano
/usr/local/bin/nano

Come fa il terminale Bash a capire dove cercare le cose? Usa la variabile d'ambiente PATH. Appare più o meno così:

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

La cosa più importante da ricordare sulla variabile PATH è che è "delimitata dai due punti". Cioè, ogni percorso di directory è separato dal successivo con il carattere due punti (:). L'ordine con cui il terminale bash cerca i programmi va da sinistra a destra:

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

Sul mio computer, quando digito ls, l'interprete bash guarda prima nella directory /usr/bin. Non trovando ls in /usr/bin, passa alla directory successiva, /bin. Dato che il mio ls sta sotto /bin, eseguirà il programma ls da lì.

Capirai quindi che questo è al tempo stesso molto flessibile per personalizzare l'ambiente di calcolo, ma anche potenzialmente frustrante se un programma modifica la variabile PATH a tua insaputa.

Un attimo, si può davvero modificare la variabile PATH? Sì, e ci sono vari modi per farlo.

Come modificare la variabile PATH

Usare una sessione Bash

Il primo modo è transitorio, o temporaneo, e vale solo per la singola sessione bash. Puoi far avere a una cartella priorità più alta rispetto ai percorsi esistenti "preponendola" alla variabile PATH:

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

Oppure puoi darle priorità più bassa "accodandola" alla variabile PATH:

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

Questo è temporaneo perché viene esportato solo durante la sessione bash corrente.

File bashrc o .bash_profile

Se volessi rendere le modifiche un po' più permanenti, allora le inserirei nel file .bashrc o .bash_profile. (Consiglio di usare il file .bashrc.) I file .bashrc/.bash_profile si trovano nella tua home directory (la specifica la variabile d'ambiente $HOME) e vengono eseguiti dal tuo interprete bash al primo avvio. Esegue tutti i comandi che contengono. Questo significa che puoi cambiare la variabile PATH semplicemente inserendo nel tuo .bashrc:

...other stuff above...
# Make /path/to/folder have higher priority
export PATH=/path/to/folder:$PATH

# Make /path/to/other/folder have lower priority
export PATH=$PATH:/path/to/folder
...other stuff below...

Data science e la variabile d'ambiente PATH

Ora, in che modo questo è rilevante per i data scientist? Beh, se fai data science, è probabile che usi Python e che il tuo interprete Python provenga dalla distribuzione Anaconda (una cosa davvero fantastica, provala!). L'installer di Anaconda Python dà priorità alla cartella /path/to/anaconda/bin nella variabile d'ambiente PATH. Potresti avere altri interpreti Python installati sul sistema (per esempio, quello fornito da Apple). Tuttavia, questa modifica del PATH fa sì che ogni volta che digiti python nel terminale Bash, venga eseguito l'interprete Python fornito con la distribuzione Anaconda. Nel mio caso, dopo aver installato Anaconda, il mio PATH è così:

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

Ancora meglio, gli ambienti conda premettono il percorso alla cartella dei binari dell'ambiente conda mentre l'ambiente è attivo. Per esempio, per il mio blog, lo tengo in un ambiente chiamato lektor. Quindi...

$ 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

Nota come ora il terminale bash scelga preferenzialmente il Python dentro l'ambiente lektor, che ha priorità più alta.

Se sei arrivato fin qui, avrai colto alcuni concetti importanti. Ricapitoliamo:

• PATH è una variabile d'ambiente memorizzata come stringa di testo semplice usata dall'interprete bash per capire dove trovare i programmi eseguibili.
• PATH è delimitata dai due punti; le directory a priorità più alta stanno a sinistra della stringa, quelle a priorità più bassa a destra.
• PATH può essere modificata preponendo o accodando directory alla variabile d'ambiente. Si può fare temporaneamente in una sessione bash eseguendo il comando export al prompt, oppure in modo permanente tra sessioni bash aggiungendo una riga export dentro il tuo .bashrc o .bash_profile.

Altre variabili d'ambiente interessanti

Quali altre variabili d'ambiente potrebbe incontrare un data scientist? Eccone alcune che potresti vedere e che potresti dover sistemare, specialmente quando gli amministratori di sistema sono in vacanza (o ci mettono troppo a rispondere).

Per l'uso generale, ti tornerà sicuramente utile sapere dov'è la tua cartella HOME: sui sistemi Linux è spesso /home/username, mentre su macOS è spesso /Users/username. Puoi scoprire il valore di HOME con:

$ echo $HOME
/Users/ericmjl

Se usi Python, allora PYTHONPATH è una variabile che può essere utile. È usata dall'interprete Python e specifica dove trovare moduli/pacchetti Python.

Se devi gestire librerie C++, conoscere la variabile d'ambiente LD_LIBRARY_PATH sarà molto importante. Non ne so abbastanza per parlarne in modo davvero competente, quindi rimando a questo sito per maggiori informazioni sulle buone pratiche d'uso della variabile LD_LIBRARY_PATH.

Se lavori con Spark, allora la variabile d'ambiente PYSPARK_PYTHON ti interesserà. Indica a Spark quale Python usare sia per il driver sia per i worker; volendo, puoi anche impostare PYSPARK_DRIVER_PYTHON separatamente da PYSPARK_PYTHON, se necessario.

Hack delle tue variabili d'ambiente

Qui viene il bello! Segui questi spunti per cose che puoi fare "hackerando" le variabili d'ambiente.

Hack #1: Abilitare l'accesso a PyPy. Seguo ogni tanto lo sviluppo di PyPy, ma siccome PyPy non è ancora l'interprete Python predefinito e non è ancora installabile con conda, lo metto nella directory $HOME/pypy/bin. Per poter usare l'interprete PyPy, devo assicurarmi che il mio /path/to/pypy sia presente nella variabile d'ambiente PATH, ma con priorità più bassa rispetto al mio interprete CPython abituale.

Hack #2: Abilitare l'accesso ad altri interpreti/compilatori. È analogo a PyPy. Una volta stavo provando l'interprete JIT di Lua per usare Torch nel deep learning e ho dovuto aggiungere il relativo percorso nel mio .bashrc.

Hack #3: Installare pacchetti Python nella tua home directory. Su sistemi Linux condivisi che usano il sistema dei modules invece degli ambienti conda, può capitare che un modulefile caricato sia configurato con un ambiente virtuale che non hai i permessi di modificare. Se devi installare un pacchetto Python, puoi usare pip install --user my_pkg_name. Questo lo installerà in $HOME/.local/lib/python-[version]/site-packages/. In questo caso, è importante assicurarsi che il tuo PYTHONPATH includa $HOME/.local/lib/python-[version]/site-packages con priorità sufficientemente alta.

Hack 4: Debug quando qualcosa va storto. Se qualcosa genera un errore o hai comportamenti inattesi — a me è capitato che l'interprete Python non venisse trovato correttamente dopo aver caricato tutti i miei moduli Linux — un modo per fare debug è impostare temporaneamente la variabile PATH su dei "default" sensati e fare source di quel file, in pratica "resettando" la PATH, così da poter premettere/accodare manualmente durante il debug.

Per farlo, inserisci la riga seguente in un file chiamato .path_default, nella tua home directory:

export PATH=""  # resets PATH to an empty string.
export PATH=/usr/bin:/bin:/usr/local/bin:$PATH  # this is a sensible default; customize as needed.

Dopo che qualcosa è andato storto, puoi resettare la tua variabile PATH usando il comando "source":

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

Nota: puoi anche eseguire gli stessi comandi direttamente nella sessione bash; l'interattività può essere d'aiuto.

Conclusione

Spero che questo articolo ti sia piaciuto e che ti offra — ehm — la giusta "path" ogni volta che ti imbatti in queste variabili d'ambiente!