Variáveis de Ambiente Linux: Do Básico ao Avançado

Introdução

Bem-vindo a este laboratório prático sobre variáveis de ambiente no Linux! As variáveis de ambiente são valores dinâmicos que podem afetar o comportamento de processos em execução em um computador. Elas desempenham um papel crucial na configuração do sistema e na execução de programas. Ao dominar as variáveis de ambiente, você adquirirá habilidades essenciais para a administração de sistemas Linux e o desenvolvimento de software.

Neste laboratório, você aprenderá como criar, visualizar, modificar e excluir variáveis de ambiente. Também exploraremos como tornar essas alterações permanentes e entenderemos algumas das variáveis de ambiente nativas mais importantes do Linux. Seja você um iniciante ou alguém que busca consolidar seus conhecimentos, este laboratório proporcionará uma experiência prática valiosa.

Vamos começar!

Entendendo Variáveis no Linux

Antes de mergulharmos nas variáveis de ambiente, vamos começar com as variáveis de shell básicas. Isso ajudará você a entender o conceito de variáveis no Linux.

Abra seu terminal. Você deve estar no diretório /home/labex/project. Caso contrário, você pode mudar para este diretório usando o seguinte comando:
```
cd /home/labex/project
```
Agora, vamos criar uma variável de shell simples. No Linux, você pode criar uma variável simplesmente atribuindo um valor a um nome. Vamos criar uma variável chamada my_var:
```
my_var="Hello, Linux"
```
Nota Importante: Ao atribuir variáveis no Bash (e no Zsh, que estamos usando neste laboratório), não deve haver espaços ao redor do sinal de igual (=). my_var = "Hello, Linux" ou my_var= "Hello, Linux" causará um erro.
Para visualizar o valor da variável, usamos o comando echo com um $ antes do nome da variável. O $ instrui o shell a substituir o nome pelo valor da variável:
```
echo $my_var
```
Você deverá ver a saída:
```
Hello, Linux
```
Você também pode usar variáveis dentro de outros comandos ou atribuições. Por exemplo:
```
echo "The value of my_var is: $my_var"
```
Isso exibirá: The value of my_var is: Hello, Linux

Ótimo trabalho! Você acabou de criar e usar sua primeira variável de shell. No entanto, esta variável está disponível apenas na sessão atual do shell. Se você abrir uma nova janela ou aba do terminal, esta variável não estará disponível lá. É aqui que as variáveis de ambiente se tornam úteis.

Introdução às Variáveis de Ambiente

Agora que entendemos as variáveis básicas, vamos explorar as variáveis de ambiente. Variáveis de ambiente são variáveis que estão disponíveis para qualquer processo filho do shell. Isso significa que elas podem ser acessadas por scripts e programas executados a partir daquele shell.

Para visualizar todas as variáveis de ambiente atuais, use o comando env:
```
env
```
Isso exibirá uma longa lista de variáveis. Não se preocupe se não entender todas elas ainda — abordaremos algumas das mais importantes mais adiante.
Uma das variáveis de ambiente mais importantes é o PATH. Vamos dar uma olhada nela:
```
echo $PATH
```
A variável PATH lista os diretórios onde o sistema procura por programas executáveis. Cada diretório é separado por dois pontos (:).
Agora, vamos criar nossa própria variável de ambiente. Usamos o comando export para criar uma variável de ambiente:
```
export MY_ENV_VAR="This is an environment variable"
```
O comando export torna a variável disponível para processos filhos. Esta é a principal diferença entre variáveis de shell e variáveis de ambiente.
Para ilustrar a diferença, vamos criar um script shell que tenta acessar tanto uma variável de shell comum quanto uma variável de ambiente. Podemos fazer isso usando um heredoc com o comando cat, que é uma forma comum de escrever conteúdo de várias linhas em um arquivo:
```
cat << 'EOF' > test_vars.sh
#!/bin/bash
echo "Shell variable: $my_var"
echo "Environment variable: $MY_ENV_VAR"
EOF
```
Torne o script executável:
```
chmod +x test_vars.sh
```
Agora execute o script:
```
./test_vars.sh
```
Você verá que a variável de ambiente (MY_ENV_VAR) está acessível, enquanto a variável de shell (my_var) não está. Isso ocorre porque my_var não foi exportada, então os processos filhos (como o script) não têm conhecimento dela.
Para verificar se MY_ENV_VAR é agora uma variável de ambiente, podemos usar o comando env novamente, mas desta vez filtraremos a saída usando grep:
```
env | grep MY_ENV_VAR
```
Você deverá ver sua nova variável na saída.
Você também pode verificar o valor da sua nova variável de ambiente diretamente:
```
echo $MY_ENV_VAR
```

Excelente! Você criou sua primeira variável de ambiente e viu como ela difere de uma variável de shell. A diferença fundamental é que as variáveis de ambiente, criadas com export, estão disponíveis para processos filhos, enquanto as variáveis de shell não estão.

Variáveis de ambiente e variáveis de shell possuem escopos próprios. Quando você exporta uma variável (ex: export MY_ENV_VAR="something"), ela se torna disponível para qualquer subprocesso iniciado a partir daquele shell (por exemplo, um script shell executado por esse mesmo shell). No entanto, se você abrir uma sessão de shell completamente separada, ela não herdará as variáveis do seu shell atual, a menos que você as defina especificamente em um arquivo de inicialização (como .zshrc ou .bashrc).

Em outras palavras:

Uma variável de shell comum é visível apenas dentro da sessão atual.
Uma variável exportada está disponível para processos filhos lançados a partir daquela sessão.
Uma variável definida em um arquivo de inicialização do shell (como .zshrc) é aplicada a todas as novas sessões daquele shell.

Você não pode ler diretamente as variáveis de outro usuário ou de outro shell porque cada processo mantém seu próprio ambiente. Se você iniciar um novo shell, ele recebe uma cópia das variáveis exportadas do pai, mas não as variáveis definidas apenas no shell original sem o export.

Aprenderemos como definir variáveis de ambiente permanentemente nas próximas etapas.

Níveis de Permanência de Variáveis

Para ajudar a visualizar as diferenças entre esses tipos de variáveis e seus níveis de permanência, aqui está uma visão geral abrangente:

graph LR
    A["Tipos de Variáveis Linux"] --> B["Variável de Shell"]
    A --> C["Variável de Ambiente"]
    A --> D["Variável Permanente"]

    B --> B1["Apenas Sessão"]
    B --> B2["Não Herdada"]
    B --> B3["Perdida ao Sair"]

    C --> C1["Escopo da Sessão"]
    C --> C2["Acesso por Filhos"]
    C --> C3["Perdida ao Sair"]

    D --> D1["Todas as Sessões"]
    D --> D2["Acesso por Filhos"]
    D --> D3["Persistente"]

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

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

Este diagrama mostra os três níveis de permanência de variáveis. Aqui está uma tabela de resumo para referência rápida:

Tipo de Variável	Escopo	Acesso por Processo Filho	Persistência	Exemplo de Sintaxe
Variável de Shell	Apenas sessão atual	Não	Perdida ao sair	`my_var='value'`
Variável de Ambiente	Sessão atual	Sim	Perdida ao sair	`export VAR='value'`
Variável Permanente	Todas as novas sessões	Sim	Sobrevive ao sair	No arquivo `~/.zshrc`

Entender esses três níveis é crucial para uma administração eficaz do sistema Linux e ajudará você a escolher a abordagem correta para diferentes cenários.

Modificando a Variável de Ambiente PATH

A variável PATH é uma das variáveis de ambiente mais importantes no Linux. Ela informa ao sistema onde procurar por arquivos executáveis. Vamos modificá-la para incluir um novo diretório.

Primeiro, vamos criar um novo diretório onde poderíamos armazenar scripts personalizados:
```
mkdir ~/my_scripts
```
Isso cria um diretório chamado my_scripts na sua pasta pessoal (home). O símbolo ~ é um atalho para o caminho do seu diretório home, que é /home/labex neste laboratório.
Agora, vamos adicionar este novo diretório ao seu PATH. Usaremos o comando export, mas desta vez estamos modificando uma variável existente:
```
export PATH="$PATH:$HOME/my_scripts"
```
Vamos detalhar isso:
- $PATH é o valor atual da variável de ambiente PATH. Estamos usando o valor existente e adicionando algo a ele.
- : é usado para separar os diretórios no PATH. Se você omitir os dois pontos, o shell não conseguirá encontrar os executáveis no diretório adicionado.
- $HOME é uma variável de ambiente que aponta para o seu diretório home (novamente, /home/labex no nosso caso).
- Portanto, estamos anexando :$HOME/my_scripts ao PATH existente. Isso diz ao sistema para procurar executáveis em my_scripts após pesquisar nos diretórios do PATH original.
Verifique se o novo diretório foi adicionado:
```
echo $PATH
```
Você deve ver /home/labex/my_scripts ao final da saída. Se não estiver no final, você pode ter modificado de uma forma diferente, o que não tem problema, desde que o caminho /home/labex/my_scripts esteja presente no seu PATH.
Para testar isso, vamos criar um script simples em nosso novo diretório:
```
cat << 'EOF' > ~/my_scripts/hello.sh
#!/bin/zsh
echo "Hello from my custom script!"
EOF
```
Isso cria um script shell chamado hello.sh no diretório ~/my_scripts. A primeira linha, #!/bin/zsh, informa ao sistema que este é um script zsh, permitindo que ele seja executado como um programa.
Torne o script executável:
```
chmod +x ~/my_scripts/hello.sh
```
O comando chmod +x adiciona permissões de execução ao script, permitindo que ele seja rodado como um programa. Se você pular esta etapa, receberá um erro de "permissão negada" ao tentar executá-lo.
Agora, você deve ser capaz de executar este script de qualquer lugar apenas digitando seu nome:
```
hello.sh
```
Se tudo funcionou corretamente, você verá: Hello from my custom script!

Isso funciona porque adicionamos o diretório my_scripts ao PATH. Quando você digita um comando, o shell procura por um arquivo executável com esse nome em cada um dos diretórios listados no PATH, em ordem. Ao adicionar my_scripts ao PATH, dissemos ao shell para procurar executáveis lá também.

Para demonstrar isso, tente mudar para um diretório diferente e execute o script novamente:

cd /tmp
hello.sh

Você verá que o script ainda funciona, mesmo que você não esteja no diretório onde ele está localizado. Este é o poder da variável PATH — ela permite que você execute programas de qualquer lugar no sistema, desde que estejam em um diretório listado no PATH.

Bom trabalho! Você modificou com sucesso a variável de ambiente PATH e criou um script personalizado que pode ser executado de qualquer lugar.

Tornando Variáveis de Ambiente Permanentes

As variáveis de ambiente que definimos serão perdidas quando você fechar o terminal. Para torná-las permanentes, precisamos adicioná-las a um arquivo de configuração do shell. O arquivo exato depende de qual shell você está usando.

Neste ambiente de laboratório, estamos usando o Z shell (zsh), que é uma versão estendida do Bourne Shell (sh), com muitas melhorias, incluindo alguns recursos do Bash, ksh e tcsh. O Zsh tornou-se cada vez mais popular e agora é o shell padrão no macOS.

Se você estivesse usando o Bash (que ainda é o padrão em muitas distribuições Linux), você modificaria o .bashrc. No entanto, como estamos usando o Zsh, modificaremos o .zshrc. É muito importante usar o arquivo correto. Se você modificar o .bashrc enquanto usa o zsh, as variáveis não serão configuradas.

Abra o arquivo .zshrc no seu diretório home com um editor de texto. Usaremos o nano, que é um editor de texto simples baseado em terminal:
```
nano ~/.zshrc
```
Este comando abre o arquivo ~/.zshrc, onde ~ é novamente o atalho para o seu diretório home /home/labex. Se o arquivo .zshrc não existir, o nano criará um novo. Este arquivo é executado toda vez que você inicia uma nova sessão de terminal.
Role até o final do arquivo (você pode usar as teclas de seta) e adicione as seguintes linhas:
```
export MY_ENV_VAR="This is an environment variable"
export PATH="$PATH:$HOME/my_scripts"
```
Certifique-se de adicionar essas linhas ao final do arquivo. Verifique se a ortografia e a sintaxe estão corretas, especialmente se não há espaços ao redor do sinal =.
Salve o arquivo e saia do editor. No nano, você faz isso pressionando Ctrl+X, depois Y (para salvar) e, em seguida, Enter.
Para aplicar essas alterações sem reiniciar o terminal, use o comando source:
```
source ~/.zshrc
```
O comando source lê e executa os comandos do arquivo especificado como argumento no ambiente de shell atual. Isso é diferente de simplesmente executar o arquivo usando bash ~/.zshrc, que rodaria o script em um novo shell e não afetaria o atual. O source o executa no shell atual para que suas alterações entrem em vigor imediatamente. Se você pular esta etapa, suas alterações não terão efeito no terminal atual, e você terá que fechá-lo e reabri-lo para ver as mudanças.

Agora, essas variáveis de ambiente serão configuradas toda vez que você abrir um novo terminal. Isso é incrivelmente útil para configurar seu ambiente de desenvolvimento de forma consistente.

Entendendo Variáveis de Ambiente Importantes

O Linux possui várias variáveis de ambiente nativas que são cruciais para a operação do sistema. Vamos explorar algumas delas:

HOME: Aponta para o diretório pessoal do usuário atual.
```
echo $HOME
```
USER: Contém o nome de usuário do usuário atual.
```
echo $USER
```
SHELL: Especifica o shell padrão do usuário.
```
echo $SHELL
```
PWD: Significa "Print Working Directory" (Imprimir Diretório de Trabalho). Contém o caminho do diretório atual.
```
echo $PWD
```
TERM: Especifica o tipo de terminal a ser emulado ao executar o shell.
```
echo $TERM
```

Entender essas variáveis pode ajudá-lo a navegar e controlar melhor seu ambiente Linux.

Removendo Variáveis de Ambiente

Às vezes, você pode precisar remover uma variável de ambiente. Isso é feito usando o comando unset.

Primeiro, vamos verificar se nossa MY_ENV_VAR ainda está definida:
```
echo $MY_ENV_VAR
```
Você deve ver o valor que definimos anteriormente.
Para remover (desconfigurar) esta variável, use o comando unset:
```
unset MY_ENV_VAR
```
Verifique se a variável foi removida:
```
echo $MY_ENV_VAR
```
Você não deve ver nenhuma saída, indicando que a variável não existe mais.
Você também pode usar a opção -v com unset para garantir que está removendo uma variável e não uma função do shell:
```
unset -v MY_ENV_VAR
```
Isso terá o mesmo resultado que apenas executar unset MY_ENV_VAR.

Lembre-se, se você adicionou a variável ao seu arquivo .zshrc, ela será recriada na próxima vez que você abrir um terminal ou executar o comando source no arquivo .zshrc.

Resumo

Parabéns! Você concluiu este laboratório abrangente sobre variáveis de ambiente no Linux. Vamos recapitular o que você aprendeu:

Você criou e acessou variáveis de shell simples, entendendo seu escopo.
Você aprendeu sobre variáveis de ambiente e como elas diferem das variáveis de shell, particularmente em sua acessibilidade por processos filhos, e como o comando export é a chave para isso.
Você modificou a importante variável PATH para incluir um diretório personalizado, permitindo que você execute scripts de qualquer lugar no sistema, e aprendeu a importância de usar os dois pontos : para separar as entradas.
Você tornou as variáveis de ambiente permanentes adicionando-as ao .zshrc, entendendo a diferença entre as configurações dos shells Bash e Zsh, e a importância de usar o source para aplicar as alterações.
Você explorou algumas das variáveis de ambiente nativas mais importantes do Linux.
Por fim, você aprendeu como remover variáveis de ambiente usando o comando unset.

Essas habilidades são fundamentais para a administração de sistemas Linux e o desenvolvimento de software. As variáveis de ambiente permitem configurar seu sistema e aplicativos de forma flexível. À medida que você continuar trabalhando com Linux, encontrará inúmeros usos para variáveis de ambiente em scripts, desenvolvimento e configuração de sistemas.

Lembre-se, a prática leva à perfeição. Tente criar suas próprias variáveis de ambiente para diferentes propósitos e explore como vários aplicativos e scripts usam variáveis de ambiente para controlar seu comportamento. Bons estudos!

Variáveis de Ambiente no Linux