Um guia de variáveis de ambiente para cientistas de dados

Você talvez já tenha visto algum software pedindo permissão para modificar sua variável PATH, ou instruções de instalação dizendo, de forma enigmática, que você precisa "configurar corretamente sua variável LD_LIBRARY_PATH".

Como cientista de dados, você pode enfrentar outros perrengues com variáveis de ambiente ao interagir com sua stack de computação (principalmente se você não tem controle total sobre ela, como é o meu caso). Este post busca desmistificar o que é uma variável de ambiente e como ela é usada no contexto de ciência de dados.

O que é uma variável de ambiente?

Para começar, vou explicar o que é uma variável de ambiente, indo a fundo na variável PATH. Recomendo que você execute os comandos aqui no seu terminal bash (com as devidas adaptações — leia o texto para entender o que estou fazendo!).

Quando você acessa seu sistema, seja o terminal do seu computador local ou um servidor remoto via SSH, o interpretador bash precisa saber onde procurar por programas específicos, como o nano (editor de texto), o git (seu controle de versão) ou o executável do Python. Isso é controlado pela sua variável PATH. Ela especifica os caminhos para as pastas onde estão os programas executáveis.

Por convenção histórica, programas de linha de comando como nano, which e top ficam no diretório /usr/bin. (Por convenção, a pasta /bin é para binários, por isso o nome /bin.) Esses são os que vêm com o sistema operacional e, por isso, exigem permissões especiais para atualização.

Teste no seu terminal:

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

Outros programas são instalados (por diversos motivos) em /bin. ls é um exemplo:

$ which ls
/bin/ls

Há ainda programas instalados em outros diretórios especiais:

$ which nano
/usr/local/bin/nano

Como o seu terminal Bash descobre onde procurar cada coisa? Ele usa a variável de ambiente PATH. Ela se parece com isto:

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

O mais importante sobre a variável PATH é que ela é "delimitada por dois-pontos". Ou seja, cada caminho de diretório é separado do próximo por um caractere de dois-pontos (:). A ordem em que o bash procura pelos programas vai da esquerda para a direita:

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

No meu computador, quando digito ls, o bash procura primeiro em /usr/bin. Não encontrando o ls em /usr/bin, ele passa para o próximo diretório, /bin. Como o meu ls está em /bin, ele executa o programa a partir dali.

Perceba como isso é, ao mesmo tempo, super flexível para personalizar seu ambiente e potencialmente bem frustrante se algum programa modificou sua variável PATH sem você saber.

Ué, dá mesmo para modificar a variável PATH? Dá sim — e existem algumas formas de fazer isso.

Como modificar a variável PATH

Usando uma sessão Bash

A primeira forma é transitória, ou temporária, e vale apenas para a sessão atual do bash. Você pode dar prioridade maior a uma pasta "pré-pendendo" ela na variável PATH:

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

Ou pode dar prioridade menor "acrescentando" ao final da variável PATH:

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

Isso é temporário porque você só exporta durante a sessão atual do bash.

Arquivo bashrc ou .bash_profile

Se eu quiser tornar as mudanças mais permanentes, incluo os comandos no arquivo .bashrc ou .bash_profile. (Eu recomendo usar o .bashrc.) O arquivo .bashrc/.bash_profile fica no seu diretório pessoal (a variável de ambiente $HOME aponta para ele) e é executado quando o bash carrega. Ele roda todos os comandos dentro dele. Isso significa que você pode mudar sua variável PATH simplesmente colocando no .bashrc:

...outros comandos acima...
# Dar prioridade maior a /path/to/folder
export PATH=/path/to/folder:$PATH

# Dar prioridade menor a /path/to/other/folder
export PATH=$PATH:/path/to/folder
...outros comandos abaixo...

Ciência de dados e a variável de ambiente PATH

E por que isso é relevante para cientistas de dados? Bom, se você é da área, é bem provável que use Python, e que seu interpretador venha da distribuição Anaconda (altamente recomendada!). O instalador do Anaconda prioriza a pasta /path/to/anaconda/bin na variável PATH. Você pode ter outros interpretadores Python instalados no sistema (a Apple, por exemplo, envia um próprio). Porém, essa alteração no PATH garante que, sempre que você digitar python no terminal, vai executar o Python da distribuição Anaconda. No meu caso, após instalar o Anaconda, meu PATH fica assim:

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

Melhor ainda: quando você ativa um ambiente conda, ele coloca o caminho para a pasta de binários daquele ambiente no início do PATH. Por exemplo, para o meu blog, eu uso um ambiente chamado lektor. Assim...

$ 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

Repare como o terminal agora prioriza o Python dentro do ambiente lektor, que ficou com prioridade maior.

Se você chegou até aqui, provavelmente já percebeu alguns conceitos importantes. Recapitulando:

• PATH é uma variável de ambiente armazenada como texto simples que o bash usa para descobrir onde estão os programas executáveis.
• PATH é delimitada por dois-pontos; diretórios com maior prioridade ficam à esquerda e os de menor prioridade à direita.
• PATH pode ser modificada pré-pendendo ou anexando diretórios à variável. Dá para fazer isso temporariamente na sessão do bash usando o comando export, ou de forma persistente adicionando uma linha export no seu .bashrc ou .bash_profile.

Outras variáveis de ambiente importantes

Que outras variáveis de ambiente um cientista de dados pode encontrar? Aqui vai uma amostra das que você pode ver — e talvez precise ajustar — especialmente quando o time de TI está de férias (ou demorando a responder).

Para uso geral, você com certeza vai querer saber onde fica sua pasta HOME — em sistemas Linux, geralmente é /home/username; no macOS, costuma ser /Users/username. Para descobrir o valor de HOME:

$ echo $HOME
/Users/ericmjl

Se você usa Python, a variável PYTHONPATH pode ser útil. Ela é usada pelo interpretador Python e especifica onde encontrar módulos/pacotes Python.

Se você lida com bibliotecas C++, conhecer a variável LD_LIBRARY_PATH é fundamental. Não tenho experiência suficiente para detalhar boas práticas aqui, então recomendo consultar este site para mais informações sobre o uso adequado do LD_LIBRARY_PATH.

Se você trabalha com Spark, a variável PYSPARK_PYTHON é de interesse. Ela indica ao Spark qual Python usar tanto no driver quanto nos workers; você também pode definir PYSPARK_DRIVER_PYTHON separadamente de PYSPARK_PYTHON, se necessário.

Hackeie suas variáveis de ambiente

É aqui que fica divertido! Veja algumas coisas que você pode fazer hackeando suas variáveis de ambiente.

Hack #1: Habilitar acesso ao PyPy. Eu acompanho ocasionalmente o desenvolvimento do PyPy, mas como ele ainda não é o interpretador padrão do Python e ainda não é conda install-able, eu o coloco em um diretório próprio $HOME/pypy/bin. Para habilitar o acesso ao PyPy, preciso garantir que o caminho para /path/to/pypy esteja presente na variável PATH, mas com prioridade menor que o meu interpretador CPython padrão.

Hack #2: Habilitar acesso a outros interpretadores/compiladores. É análogo ao caso do PyPy. Já testei o interpretador JIT do Lua para usar o Torch em deep learning e precisei adicionar o caminho correspondente no meu .bashrc.

Hack #3: Instalar pacotes Python no seu diretório pessoal. Em sistemas Linux compartilhados que usam o sistema de modules em vez de ambientes conda, um modulefile que você carrega pode vir configurado com um ambiente virtual que você não tem permissão para modificar. Se precisar instalar um pacote Python, use pip install --user my_pkg_name. Isso instala em $HOME/.local/lib/python-[version]/site-packages/. Nesse caso, garantir que seu PYTHONPATH inclua $HOME/.local/lib/python-[version]/site-packages com prioridade suficiente é essencial.

Hack #4: Depurar quando algo dá errado. Se surgir um erro ou comportamento inesperado — já aconteceu comigo do interpretador Python não ser encontrado corretamente após carregar meus módulos Linux — uma forma de depurar é definir temporariamente o PATH para um "padrão" sensato e fazer source disso, efetivamente "resetando" o PATH, para então ir pré-pendendo/anexando manualmente enquanto depura.

Para isso, coloque a linha abaixo em um arquivo chamado .path_default no seu diretório pessoal:

export PATH=""  # reseta o PATH para uma string vazia.
export PATH=/usr/bin:/bin:/usr/local/bin:$PATH  # um padrão sensato; ajuste conforme necessário.

Quando algo der errado, você pode resetar seu PATH usando o comando "source":

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

Observação: você também pode executar exatamente os mesmos comandos direto na sessão do bash; a interatividade pode ajudar.

Conclusão

Espero que você tenha curtido este artigo e que ele ofereça, com o perdão do trocadilho, um bom caminho sempre que se deparar com variáveis de ambiente!