# Variáveis de Ambiente

Author: Paulo Queiroz
Language: pt
Source: https://raggesilver.com/pt/blog/06-environment-variables

Vamos aprender a usar variáveis de ambiente para armazenar dados sensíveis e de configuração.

Antes de começarmos com o código, vamos entender o que são variáveis de
ambiente. Variáveis de ambiente são variáveis armazenadas fora do código,
geralmente no sistema operacional. Elas são usadas para armazenar dados de
configuração e também podem ser usadas para armazenar informações sensíveis.

Aqui estão dois exemplos rápidos de variáveis de ambiente:

```bash
echo $USER
echo $PATH
```

O primeiro comando deve imprimir o nome do usuário atual (ou **username**), e o
segundo deve imprimir o **path\*** do sistema. Note, entretanto, que a sintaxe
para acessar variáveis de ambiente pode variar dependendo do sistema operacional
— os exemplos acima são para sistemas baseados em Unix (macOS e Linux).

> \*O path do sistema é uma lista de diretórios onde o sistema procura por
> executáveis. Quando você digita um comando no terminal, o sistema procura por
> esse comando nos diretórios listados na variável PATH. Se você instalou um
> programa, como o interpretador Python, e uma mensagem de erro diz que o
> comando não foi encontrado, é provável que o diretório onde o programa está
> instalado não esteja na variável PATH.

Essas variáveis são definidas pelo sistema operacional (tecnicamente, pelo
shell, mas isso não é importante por enquanto). Qualquer programa que tenha
acesso ao ambiente pode ler essas variáveis.

## Variáveis de ambiente & Python

Em Python, você pode acessar variáveis de ambiente usando o módulo `os`.

```py
import os

user = os.environ.get("USER")
print(f"Olá, {user}")
```

O código acima vai imprimir o nome do usuário atual — pelo menos no macOS e
Linux. Se você estiver usando Windows, pode ser necessário usar a variável de
ambiente `USERNAME` em vez de `USER`.

> Embora tecnicamente você possa, raramente existe um bom motivo para definir
> variáveis de ambiente a partir do seu código.

## Informações sensíveis

Você pode ter chegado aqui simplesmente porque ouviu dizer que é uma boa prática
armazenar segredos e senhas em variáveis de ambiente em vez de salvá-los no
código. Isso está correto. Você nunca deve armazenar informações sensíveis no
seu código. Mas por quê?

**Segurança**: Armazenar segredos no código é considerado uma má prática, porque
se você usar qualquer tipo de sistema de controle de versão (como Git), você
estará compartilhando seus segredos com o mundo. Mesmo que seu repositório seja
privado, ainda é uma má ideia, pois seu repositório pode vazar ou alguém pode
ganhar acesso a ele.

**Flexibilidade**: Ao armazenar segredos fora do código, você pode mudar qual
banco de dados ou serviço está usando sem ter que mudar o código. Quando você
ganhar mais experiência publicando seus programas em produção, você verá como
isso é útil.

## Definindo variáveis de ambiente

Até agora, só vimos como ler variáveis de ambiente existentes. Isso não é muito
útil se você está tentando mover suas credenciais de banco de dados para fora do
código. Vamos ver como definir variáveis de ambiente.

Em sistemas baseados em Unix (macOS e Linux), você pode definir variáveis de
ambiente no terminal assim:

```bash
export MY_SECRET=some_password
```

No Windows, você pode definir variáveis de ambiente assim:

```
set MY_SECRET=some_password
```

Estas estarão disponíveis para qualquer programa que você executar nessa sessão
do terminal. Se você fechar o terminal e abrir um novo, precisará definir as
variáveis de ambiente novamente. Bem chato, né?

## Usando um arquivo .env

Para facilitar as coisas, você pode usar um arquivo `.env` para armazenar suas
variáveis de ambiente. Este arquivo é apenas um arquivo de texto com pares
chave-valor, assim:

```
MY_SECRET=some_password
```

> `.env` é o nome completo do arquivo. O ponto no início não é um erro de
> digitação. Isso torna o arquivo oculto na maioria dos sistemas, e é isso que
> queremos. Isso também é uma convenção no mundo da programação. A maioria das
> bibliotecas que leem variáveis de ambiente de um arquivo procuram por um
> arquivo chamado `.env`.

> **Importante**: Você nunca deve fazer commit do seu arquivo `.env` para seu
> sistema de controle de versão — nunca adicione este arquivo ao Git. Este é o
> objetivo de não incluir os segredos no seu código. O Git tem uma função
> chamada `.gitignore` que você pode usar para dizer ao Git para ignorar certos
> arquivos. Você deve adicionar `.env` ao seu arquivo `.gitignore`.
>
> Leia mais sobre `.gitignore` [aqui](https://git-scm.com/docs/gitignore).

Para ler o arquivo `.env` em Python, você pode usar a biblioteca
`python-dotenv`. Você pode instalá-la usando `pip`:

```bash
pip install python-dotenv
```

Aqui está como você pode usá-la:

```py
from dotenv import load_dotenv
import os

load_dotenv()

db_password = os.getenv("MY_SECRET")
print(db_password)
```

A função `load_dotenv()` lê o arquivo `.env` no diretório atual e define as
variáveis de ambiente. Agora você pode acessar as variáveis usando
`os.getenv()`.

Só para deixar claro, você não precisa de um arquivo `.env` ou da biblioteca
`python-dotenv` para usar variáveis de ambiente em Python. Essa é apenas uma
maneira conveniente de definir e ler variáveis de um arquivo para que você não
precise defini-las manualmente toda vez que abrir uma nova sessão do terminal.

## Conclusão

Variáveis de ambiente são uma ótima maneira de armazenar dados de configuração e
informações sensíveis fora do seu código. Elas são fáceis de usar e podem tornar
seu código mais seguro e flexível. Você pode usá-las para armazenar credenciais
de banco de dados, chaves de API e outras informações sensíveis. Apenas
lembre-se de nunca fazer commit do seu arquivo `.env` para o Git.