Se você já trabalhou em qualquer forma de desenvolvimento de aplicativo, você já deve ter ouvido falar do termo “variáveis de ambiente” Variáveis de ambiente são usadas para armazenar segredos e dados de configuração do aplicativo, recuperados pelo seu aplicativo em execução quando necessário.
As variáveis de ambiente adicionam dinamismo à sua base de código estático; você pode alternar entre recursos internos/externos com base no valor da variável de ambiente passada para o seu aplicativo.
Este artigo vai explicar detalhadamente sobre as variáveis de ambiente. Você vai aprender algumas maneiras populares de criar e gerenciar variáveis de ambiente, e entender quando utilizá-las. Ao final deste artigo, você conseguirá usar as variáveis de ambiente de forma eficaz e com confiança em seus aplicativos.
Vamos começar!
O que é uma variável de ambiente?
Reiterando a explicação acima, variáveis de ambiente são variáveis disponíveis ao seu programa/aplicativo dinamicamente durante o tempo de execução. O valor destas variáveis pode vir de uma gama de fontes – arquivos de texto, gerenciadores secretos de terceiros, scripts de chamadas, etc.
O que é importante aqui é que o valor dessas variáveis de ambiente não é codificado de forma rígida em seu programa. Elas são verdadeiramente dinâmicas e podem ser alteradas com base no ambiente onde o seu programa está rodando.
Tipos de variáveis de ambiente
Existem três tipos principais de variáveis de ambiente em um sistema operacional baseado no Windows, cada uma com seus casos de uso específicos. Vamos discuti-las individualmente.
1. Variáveis de ambiente do sistema
As variáveis de ambiente do sistema residem na raiz mais alta do sistema e são as mesmas para todos os processos em execução em um sistema sob todos os perfis de usuários do sistema. O administrador do sistema/sistema operacional geralmente as define, e raramente é necessário mexer nelas.
Um dos usos mais comuns de uma variável de ambiente do sistema é a criação de uma variável PATH para um pacote/library global a ser usado por todos os usuários do sistema.
2. Variáveis de ambiente do usuário
Variáveis de ambiente de usuário são aquelas que são locais para um perfil de usuário em sistemas Windows. Estas variáveis são usadas para armazenar informações específicas do usuário, como o caminho para uma instalação local de bibliotecas que não devem ser usadas por todos os usuários, valores específicos para programas instalados apenas para usuários específicos, etc.
Você não precisa do administrador do sistema para fazer alterações nestas variáveis; você mesmo pode fazer isso como um usuário. Estas variáveis são úteis ao implementar alterações locais em seu sistema sem afetar outros usuários.
3. Tempo de execução/Variáveis de ambiente de processo
As variáveis de ambiente de tempo de execução são ainda mais restritas apenas ao tempo de execução ou ao processo ao qual elas estão associadas. Estas são normalmente definidas pelo processo pai que cria o novo processo e é acompanhado pelas variáveis de ambiente do sistema e do usuário também.
Você pode usar o script de terminal para criar e armazenar estas variáveis em tempo real. Variáveis de tempo de execução geralmente não são permanentes a menos que sejam roteirizadas, e você precisa defini-las sempre que você iniciar um novo processo.
Variáveis de ambiente em sistemas baseados em Unix
Ao contrário dos sistemas Windows, os sistemas baseados em Unix não possuem três camadas de tipos variáveis de ambiente. Em tais sistemas, tudo é armazenado sob um objeto var e pode ser acessado/modificado pelo programa em execução.
Se você precisa definir algumas variáveis de ambiente como padrão para serem carregadas cada vez que qualquer programa roda em seu sistema, você precisa defini-las em arquivos como .~/bashrc ou ~.profile que são carregados quando o sistema inicia.
Variáveis de ambiente vs variáveis de pseudo-ambiente
Uma linha separada de variáveis de ambiente dinâmico está disponível em sistemas baseados em Windows e DOS, conhecidos como variáveis de pseudo-ambiente. A estas não são atribuídos estaticamente pares de chaves e valores, mas sim indicações dinâmicas que retornam vários valores quando consultadas.
Enquanto você pode atribuir um valor a uma variável de ambiente manualmente usando o comando SET ou seu equivalente, você não pode atribuir valores a variáveis de pseudo ambiente. Há uma lista fixa de tais variáveis, e você pode usá-las em seu código para facilitar seu trabalho. Alguns casos de uso popular incluem %CD% para o diretório atual e %TIME% para a hora atual.
Por que você deve usar as variáveis de ambiente?
Agora que você entende o que é uma variável de ambiente e seus vários tipos, é hora de saber porque você deve usá-la extensivamente em seus aplicativos.
Separação de responsabilidades
Uma das razões mais importantes pelas quais você deve usar variáveis de ambiente em seus aplicativos é para aderir a um princípio de design popular e útil – a separação de responsabilidades. O princípio de design diz que os softwares devem ser divididos em seções distintas para gerenciá-los eficientemente. Cada seção deve ser baseada em uma das principais preocupações do programa, e deve haver um acoplamento mínimo entre tais seções.
Você pode considerar a configuração do aplicativo como uma dessas preocupações; portanto, ela precisa ser separada do programa principal. Uma das melhores maneiras de fazer isso é armazená-la em um arquivo externo e injetá-la conforme necessário. As variáveis de ambiente ajudam a isolar os dados de configuração críticos do aplicativo usando arquivos de ambiente ou armazenamentos remotos de variáveis. Dessa forma, seus desenvolvedores têm acesso apenas às informações necessárias.
Mantendo conjuntos de configuração independentes através de ambientes
Além de isolar as configurações do aplicativo do seu código-fonte, você também precisa ser capaz de alternar entre os conjuntos de dados de configuração facilmente. Se você escolher codificar os valores de configuração do seu aplicativo em seu código-fonte, pode tornar-se quase impossível substituir esses valores com base em condições externas, como ambientes de implantação.
O uso de variáveis de ambiente ajuda você a desacoplar seus dados de configuração do seu código e padronizar a forma como essa informação é fornecida ao seu aplicativo, o que permite que você modifique/troque as informações que estão sendo fornecidas na hora.
Protegendo os segredos
Seus segredos de aplicativos estão sob informação sensível. Se pessoas erradas colocarem suas mãos nelas, elas podem acessar a arquitetura interna do seu aplicativo e recursos de terceiros. Exemplos comuns incluem chaves AWS e detalhes da conta do sistema. O acesso não autorizado a essas chaves pode levar à perda de dinheiro e de dados do aplicativo. Hackers podem até mesmo ir ao ponto de restringir seu aplicativo de funcionar normalmente.
Portanto, é vital que você proteja estes segredos. Deixá-los em sua base de código pode fazer com que todos os seus desenvolvedores tenham acesso a eles. Se você não seguir os métodos apropriados de ofuscação de código, seus aplicativos podem ser projetados de forma reversa para recuperar as chaves que estão entre seus códigos. O isolamento desses segredos através de variáveis de ambiente pode impedir que tais cenários aconteçam.
Exemplos de casos de uso de variáveis de ambiente
Agora que você tem uma ideia clara de como as variáveis de ambiente funcionam e como você deve usá-las, aqui estão alguns cenários comuns onde você pode usar variáveis de ambiente:
- Tipo de ambiente: Variáveis de ambiente são frequentemente usadas para armazenar o nome do ambiente no qual o aplicativo está sendo executado atualmente. A lógica do aplicativo pode usar este valor para acessar o conjunto certo de recursos ou ativar/desativar certos recursos, ou seções do aplicativo.
- Nome do domínio: O nome de domínio de um aplicativo pode variar conforme o ambiente em que está sendo executado. Isolá-lo também ajuda você a fazer facilmente alterações no nome de domínio do seu aplicativo sem procurar por suas ocorrências em toda a base de código.
- URLs de API: Cada ambiente do seu aplicativo pode ter APIs implantadas em ambientes diferentes também.
- Chaves privadas: Chaves para serviços e recursos pagos precisam ser isoladas do código-fonte do aplicativo para que elas não caiam acidentalmente em mãos erradas.
-
Números de conta de serviço, etc: Você pode variar outras informações específicas do sistema, como números de conta de serviço, keytabs, etc., com base no ambiente do aplicativo para gerenciamento e monitoramento de recursos.
Como armazenar variáveis de ambiente
Agora que você entende porque as variáveis de ambiente são importantes, é hora de olhar como você pode armazená-las e acessá-las em seu aplicativo. Discutidas abaixo são três maneiras diferentes, porém populares, de gerenciar variáveis de ambiente em um aplicativo.
Usando arquivos .env
.env são sem dúvida as formas mais fáceis e mais populares de gerenciar variáveis de ambiente. A ideia aqui é simples – você armazena suas variáveis de ambiente em um arquivo chamado .env na raiz do seu projeto. O aplicativo consulta as variáveis neste arquivo e as carrega para uso durante o tempo de execução. Aqui está como um arquivo .env típico se parece:
VAR_UNO=SOME_KEY_HERE
VAR_DOS=SOME_OTHER_KEY_HERE
.env também permitem que você defina conjuntos de variáveis de ambiente e as acesse com base no ambiente de tempo de execução do seu aplicativo ou outros fatores. Ao invés de salvar o arquivo como simplesmente .env, você pode fazer mais de um arquivo e mantê-los como .env.dev e .env.prod. Dentro destes arquivos, você pode definir os mesmos conjuntos de variáveis, mas com valores variados, dependendo do ambiente.
Exemplo de template
Ao trabalhar com arquivos .env, não é recomendado adicioná-los ao seu sistema de controle de versão (mais sobre isso adiante). Portanto, você deve definir um “.env.template” em seu projeto para que os desenvolvedores possam seguir o template e criar um arquivo .env localmente.
Aqui está como seria um arquivo .env.template:
VAR_UNO= # Your value here
VAR_DOS= # Your value here
Não tem que seguir nenhuma convenção desde que seja autoexplicativa para à sua equipe de desenvolvimento. Para simplificar este processo, você também poderia usar pacotes como o env-template.
Prós
Aqui estão algumas razões pelas quais você deve considerar o uso de arquivos .env para gerenciar variáveis de ambiente em seu aplicativo.
Simples de usar
Este método é o mais simples na linha de técnicas de gerenciamento de variáveis de ambiente. Tudo o que você precisa fazer é criar um arquivo de texto simples que contenha seus segredos e armazená-lo na raiz do seu projeto.
Mudar de ambiente é tão simples quanto mudar o próprio arquivo env. Você pode armazenar vários arquivos pelos nomes .env.dev, .env.prod, .env.uat, etc., e configurar seu código-fonte para acessar esses arquivos com base no ambiente em que ele está sendo executado.
Acesso local
Você pode facilmente configurar arquivos .env em um ambiente de desenvolvimento local. Ao contrário dos gerenciadores de variáveis nativas da plataforma, você não precisa implementar seu aplicativo para alavancar a funcionalidade das variáveis do ambiente. Comparado aos gerenciadores secretos, os arquivos .env são mais fáceis de configurar localmente, e não há dependência de rede para acessar seus segredos de aplicativo.
Suporte de código aberto
Existem inúmeros pacotes de código aberto para ajudá-lo a carregar e gerenciar segredos de aplicativos de arquivos env. Você não precisa depender de serviços pagos, nem suas opções são limitadas quando se trata de gerenciamento de segredos de aplicativos. Existe uma grande variedade de bibliotecas de código aberto de terceiros para ajudar você a gerenciar seus arquivos de inveja. Alguns exemplos populares/usados são dotenv, env-template, e cross-env.
Contras
Aqui estão algumas desvantagens dos arquivos de inveja que você deve conhecer antes de usá-los em seus projetos.
Formatação
.env arquivos armazenam seus segredos de aplicativo na forma de pares de valores-chave. O formato usual para armazenar variáveis de ambiente em um arquivo .env é:
Key1=Value1
Você precisa se ater estritamente a este formato para que seu aplicativo seja capaz de ler seus segredos com sucesso. Se você cometer um pequeno erro em algum lugar entre dezenas ou centenas de linhas de variáveis de ambiente, o arquivo inteiro pode não ser analisado, e seu programa irá lançar erros não relacionados ao todo. O fato de que há um erro de análise com seu arquivo .env pode nem mesmo ser destacado. É por isso que você precisa ser cuidadoso ao usar os arquivos .env.
Vulnerável a vazamentos acidentais de segredos durante o compartilhamento/armazenamento
Como os arquivos .env são arquivos de texto simples, eles são vulneráveis a exposição acidental quando armazenados em um disco rígido compartilhado ou enviados por meio de uma rede não segura. Portanto, é necessário ter cuidado especial para não vazar seus segredos de aplicativo quando você os armazena usando arquivos .env.
Usando o armazenamento de variáveis nativas da plataforma
Outra opção popular para o armazenamento de variáveis de ambiente é confiar no armazenamento de variáveis da sua plataforma de implantação. A maioria dos ambientes de implantação, tais como Heroku, AWS, Netlify, etc., fornecem um espaço para os usuários carregarem segredos, posteriormente injetados no tempo de execução do seu aplicativo. Você pode verificar a documentação da sua plataforma de implantação para saber se eles a suportam e como começar a usá-la.
Aqui está uma breve visão geral do gerenciador de variáveis de ambiente do Netlify:
Prós
Aqui está porque você deve considerar o uso de soluções de armazenamento variável nativo da plataforma.
Altamente seguro
Como esta opção é gerenciada inteiramente pela sua plataforma de implantação, ela é destinada a ser mais segura do que armazenar seus segredos em um arquivo de texto simples. Você pode controlar quem tem acesso ao gerenciador de variáveis, e você pode ter certeza de que os segredos nunca serão movidos acidentalmente para o seu VCS.
Fácil de atualizar
Atualizar as variáveis de ambiente quando elas são armazenadas independentemente é mais simples – você não precisa editar seu código-fonte e fazer uma nova versão para ele. Você pode simplesmente mudar os valores na plataforma e reconstruir seu projeto. Ele receberá os novos valores na próxima vez em que for iniciado.
As dificuldades de formatação também são eliminadas, já que a maioria dos gerenciadores de implantação específicos da plataforma fazem a verificação dos campos conforme você os insere. Em casos como o da Netlify, você insere os segredos em uma forma pré-formatada, eliminando as chances de cometer erros de formatação.
Permite a colaboração
Como as plataformas de implantação podem ser acessadas por toda à sua equipe, você pode facilmente compartilhar os segredos com as pessoas certas sem ter que enviar arquivos de texto através da internet. Você pode controlar quem tem acesso ao gerenciador de variáveis (na maioria dos casos) e usá-lo como um repositório central para os seus segredos de aplicativo.
Contras
Enquanto os gerenciadores de variáveis da plataforma parecem ser apenas a solução que você precisa, há alguns problemas que você deve ter em mente antes de optar por eles.
Dependentes da plataforma
Como o nome deles diz, eles são altamente específicos para a plataforma que você está usando. Em alguns casos, sua plataforma de implantação pode até mesmo não oferecer tal serviço. Mudar sua plataforma de implantação para ter acesso a tal serviço pode não parecer ser a melhor decisão.
Não-uniforme
Como eles são oferecidos e gerenciados completamente pela plataforma de implantação, tais serviços podem ser altamente não-uniformes. Mover variáveis de uma plataforma para outra pode ser problemático. Você não pode nem mesmo assumir que cada plataforma de implantação ofereceria as opções de importação/exportação de variáveis de ambiente. Enquanto a maioria o faz, ele está inteiramente nas mãos da plataforma. Há grandes chances de encontrar um fornecedor em pequena escala se você tiver uma longa lista de variáveis de ambiente.
Sem suporte local
Embora tais serviços sejam ótimos para acessar variáveis de ambiente nas implantações do seu aplicativo, raramente há uma chance de que você possa usá-los enquanto desenvolve seu aplicativo localmente. Geralmente você terá que recorrer ao gerenciamento de arquivos locais .env. Enquanto ele cumpre o propósito, ele complica toda a configuração desnecessariamente.
Usando gestores secretos
A terceira opção, que atualmente é bastante jovem em seus estágios de desenvolvimento, é usar gerenciadores secretos dedicados. gerenciadores secretos são serviços de terceiros que permitem que você isole completamente seus segredos de aplicativo do seu código-fonte/desenvolvimento e os busque como e quando necessário através de conexões de rede seguras.
Prós
Aqui estão algumas das vantagens que os gerenciadores secretos oferecem sobre outros métodos de gerenciamento secreto.
Altamente seguro
Como seus segredos são armazenados em um serviço completamente isolado, você pode ter certeza de que você provavelmente nunca os divulgará acidentalmente enquanto os compartilha com seus colegas ou através de compromissos de controle de versão. A plataforma de terceiros se encarrega de manter seus segredos seguros, e eles normalmente têm SLAs bastante rígidos quando se trata de segurança de dados.
Mesmo ao acessar os segredos de dentro do seu aplicativo, a maioria dos gerenciadores secretos fornece seu próprio código de cliente que pode buscar e permitir o acesso aos segredos de forma segura onde quer que seja necessário.
Uniformização em todos os ambientes
Como os segredos agora são independentes da sua base de códigos e ambientes de implantação, você pode agora desfrutar de uniformidade entre ambientes. Você não precisa fazer arranjos especiais para a integração de novos desenvolvedores ou tomar medidas especiais antes de enviar seu aplicativo para a produção – a maioria destes aspectos são simplificados ou tratados pelo seu gerente de segredos.
Contras
Embora os gerenciadores de segredos pareçam ser a melhor solução possível para gerenciar variáveis de ambiente, eles também têm suas próprias limitações.
Custo
Gerenciar variáveis de ambiente tem sido uma atividade interna nos projetos por um longo tempo. Mesmo a maioria das plataformas de implantação oferecem este recurso sem custos, uma vez que eles não incorrem em nenhum custo adicional.
No entanto, como os gerenciadores secretos são serviços completamente independentes, eles têm seus próprios custos de operação. Portanto, os usuários têm que arcar com este custo enquanto utilizam estes serviços.
Fases iniciais da tecnologia
Como a tecnologia é relativamente nova, você nunca poderá ter certeza de quão bem ela será adotada pela indústria nos próximos dias. Embora os gerenciadores secretos mostrem grande promessa em termos de segurança e facilidade de gerenciamento, o fator custo e as preocupações com o manuseio de dados podem resultar em uma adoção bastante lenta da tecnologia.
Como trabalhar com variáveis de ambiente
Agora que você entende o conceito de variáveis de ambiente e as formas disponíveis para implementá-las em um aplicativo, veremos como você pode trabalhar com elas através do terminal e em aplicativos baseados no Node.js.
Variáveis de ambiente no terminal
Como as variáveis de ambiente são específicas aos processos, você pode configurá-las e excluí-las através do terminal para que elas sejam passadas para os processos que o seu terminal gera.
Como encontrar valores de variáveis
Para visualizar a lista de variáveis de ambiente em seu terminal, você pode executar os seguintes comandos específicos para o seu sistema operacional.
No Windows:
set
Em Linux ou MacOS:
env
Isso irá imprimir uma lista de todas as variáveis de ambiente disponíveis para o seu terminal em execução.
Definindo novas variáveis
Para definir novas variáveis através do terminal, você pode executar os seguintes comandos.
No Windows:
set "VAR_NAME=var_value"
Em Linux ou MacOS:
VAR_NAME=var_value
Excluindo variáveis
Para excluir uma variável de ambiente, você precisa executar os seguintes comandos.
No Windows:
set "VAR_NAME="
Em Linux ou MacOS:
unset VAR_NAME
Por favor, note que os métodos discutidos acima são apenas para criar/eliminar variáveis de ambiente para a sessão atual do terminal.
Variáveis de ambiente no Node.js
JavaScript é uma das mais populares linguagens de programação no momento. Ele é amplamente utilizado no build de aplicativos backend e frontend, tornando uma das linguagens de programação mais versáteis.
O Node.js está entre as frameworks JS mais utilizadas para construir aplicativos backend. Vamos dar uma olhada em como você pode lidar facilmente com variáveis de ambiente em aplicativos baseados no Node.js.
Acessando variáveis de ambiente diretamente
Node.js fornece a você uma indicação às variáveis de ambiente do seu processo atual via process.env. Você pode visualizar as variáveis de ambiente disponíveis imprimindo este objeto para o console.
Este objeto conterá variáveis disponíveis para o processo do Node em execução. Você pode adicionar novas variáveis a ele declarando antes de executar seu aplicativo, semelhante a isso:
VAR_UNO=SOMETHING node index.js
Como você pode ver, a nova variável é adicionada ao seu objeto process.env. Entretanto, você não pode acessar nenhuma variável definida sob um arquivo .env através deste método. Para fazer isso, você precisa usar um pacote como dotenv para carregar o arquivo .env em tempo de execução.
Usando o pacote dotenv para acessar os arquivos .env
O pacote dotenv ajuda você a carregar variáveis de ambiente armazenadas em arquivos .env na raiz do seu projeto. Seu uso é simples, você precisa instalá-lo executando o seguinte comando:
npm i [email protected]
A seguir, você precisa adicionar a seguinte linha de código no início do código do seu aplicativo para inicializar o pacote:
require('dotenv').config()
É isso! Agora os segredos que você armazena em um arquivo .env na raiz do seu projeto serão carregados no seu objeto process.env assim que o aplicativo começar. Veremos este método em ação mais tarde no seguinte tutorial.
Tutorial da variável de ambiente
A melhor maneira de entender um conceito técnico é observá-lo em ação. Aqui está um tutorial rápido para ajudá-lo a começar com as variáveis de ambiente e aprender seu uso em detalhes.
No guia a seguir, demonstraremos como usar variáveis de ambiente através das três maneiras que mencionamos acima – arquivos .env, gerenciadores de variáveis nativas da plataforma e gerenciadores secretos. Todas essas formas exigirão um passo comum, que é a criação de um projeto básico do Node.js.
Primeiro: Crie um projeto Node.js
Para começar, garanta que você tenha o Node.js instalado em seu sistema. Uma vez que você o tenha configurado em seu sistema, você terá acesso ao npm (abreviação para Node Package Manager). npm ajuda você a instalar pacotes de nodo a partir do registro global de npm através da linha de comando. Ele será útil quando você instalar pacotes relacionados ao nosso projeto de teste.
A seguir, abra um terminal e crie um novo diretório. Inicialize um novo projeto de Node nele:
mkdir my-app
cd my-app
npm init
Continue pressionando enter através das perguntas recebidas para aceitar as opções padrão. Feito isso, seu terminal ficará parecido com isso:
Agora você pode abrir este projeto usando uma IDE como Visual Studio Code ou IntelliJ IDEA.
Crie um novo arquivo na raiz da pasta do seu projeto e salve com o nome index.js. Este será o ponto de partida para o seu aplicativo. A seguir, instale o Express para criar e testar rapidamente servidores REST:
npm i express
Uma vez que você tenha o Express instalado, cole o seguinte código no seu arquivo index.js:
const express = require("express")
const app = express()
app.get("/", (req, res) => {
res.send("Hello world!")
})
app.listen(8080);
Este é um snippet inicial para um endpoint básico do “Hello World” usando Node.js e Express. Execute o seguinte na sua linha de comando:
node index.js
Isso iniciará o seu aplicativo Node.js + Express. Se você navegar para http://localhost:8080 em seu navegador web, você receberá uma saída semelhante:
Isso indica que você montou seu aplicativo corretamente! O próximo passo é atualizar seu aplicativo para usar variáveis de ambiente. Atualize o código em index.js para corresponder ao snippet a seguir:
const express = require("express")
const app = express()
app.get("/", (req, res) => {
// the responseMessage object extracts its values from environment variables
// If a value is not found, it instead stores the string "not found"
const responseMessage = {
environment: process.env.environment || "Not found",
apiBaseUrl: process.env.apiBaseUrl || "Not found"
}
res.send(responseMessage)
})
app.listen(8080);
Ao invés de enviar uma mensagem de “Hello World!” na resposta, agora estaremos enviando um objeto JSON que carrega duas informações:
environment: Indica o ambiente atual no qual o aplicativo é implantadoapiBaseUrl: Carrega a URL base para uma API hipotética. Mudaremos o valor desta URL com base no ambiente em que o aplicativo é implantado.
Caso não seja possível acessar as variáveis de ambiente, o objeto conterá “Not found” como os valores para as duas chaves descritas acima. Antes de seguir adiante, execute novamente o comando node index.js e você receberá a seguinte saída:
env.Isso indica que o seu aplicativo não consegue acessar as variáveis de ambiente no momento. Além disso, ainda nem definimos os valores para estas variáveis. Vamos dar uma olhada nas várias maneiras disponíveis para fazer isso nas próximas seções.
Tipo 1: Adicionar variáveis de ambiente através de arquivos env
Vamos começar com a forma mais básica de adicionar variáveis de ambiente – arquivos de env. Na raiz do seu projeto, crie um novo arquivo chamado .env e armazene o seguinte código nele:
environment=DEV
apiBaseUrl=http://dev.myApi.com:8080/v1
Em seguida, reinicie seu aplicativo executando o comando node index.js novamente e verifique a saída:
env.Você perceberá que a saída ainda é a mesma. Isso ocorre porque, mesmo que você tenha definido o valor das variáveis de ambiente, você não instruiu realmente o seu aplicativo sobre onde encontrá-las. É aqui que pacotes como o dotenv são úteis.
Execute o seguinte comando para instalar dotenv:
npm i [email protected]
Para começar a usar dotenv em seu código, adicione o seguinte código na linha número 2 do seu index.js:
require('dotenv').config()
Em seguida, reinicie o aplicativo e verifique a saída:
env.Como você pode ver, os valores para as variáveis de ambiente foram carregados do seu arquivo .env!
Agora, para tornar as coisas mais interessantes, vamos renomear nosso arquivo .env para .env.dev e criar outro arquivo chamado .env.staging. Cole o seguinte snippet de código no novo arquivo:
environment=STAGING
apiBaseUrl=http://staging.myApi.com:3000/v1
Uma vez terminado, substitua a linha número 2 do seu arquivo index.js com o seguinte código:
require('dotenv').config({
path: "STAGING" === process.env.NODE_ENV?.toUpperCase() ? './.env.staging' : './.env.dev'
})
console.log(process.env.NODE_ENV)
O que mudou aqui é que agora estamos instruindo o pacote dotenv a buscar o conteúdo das variáveis de ambiente de um dos dois arquivos disponíveis com base em outra variável de ambiente chamada NODE_ENV. De onde vem o valor desta variável de ambiente? Do seu terminal.
Para testar essa configuração, execute seu aplicativo usando o seguinte comando:
NODE_ENV=DEV node index.js
Se você acessar localhost:8080 agora, você notará a seguinte resposta:
Agora, encerre o aplicativo em execução e execute novamente usando o seguinte comando:
NODE_ENV=STAGING node index.js
Acessar localhost:8080 agora levará você à seguinte resposta:
É assim que você pode usar os arquivos .env para acessar diferentes conjuntos de variáveis baseadas em condições externas. A condição externa aqui é a variável de ambiente externo NODE_ENV que é essencialmente uma variável de ambiente do usuário enquanto environment e apiBaseUrl eram variáveis de ambiente de tempo de execução. O perfil do usuário que faz a chamada fornece o valor da variável NODE_ENV e o aplicativo a utiliza para tomar decisões internas.
Caso você esteja no Windows, você pode enfrentar dificuldades enquanto executa os dois comandos anteriores. O terminal do Windows pode não permitir que você atribua variáveis de ambiente de usuário na hora usando a sintaxe KEY=VALUE (a menos que seja Bash no Windows).
Uma solução rápida nesse caso é fazer uso de scripts e cross-env.
Instale cross-env executando o seguinte comando:
npm i --save-dev cross-env
A seguir, vá para o seu arquivo package.json e atualize a chave scripts para combinar com isso:
// …
"scripts": {
"test": "echo "Error: no test specified" && exit 1",
"start-dev": "cross-env NODE_ENV=DEV node index.js",
"start-staging": "cross-env NODE_ENV=STAGING node index.js"
},
// …
Agora você pode executar os seguintes comandos para executar seu aplicativo com dois conjuntos diferentes de variáveis de ambiente:
npm run start-dev # to start with dev variables
npm run start-staging # to start with staging variables
Esta é uma correção universal e você pode usar estes scripts em bash/zsh também.
A seguir, vamos dar uma olhada em como usar um gerente de variáveis de terceiros.
Tipo 2: Use o gerenciador de variáveis de ambiente nativo da Heroku
Para poder seguir durante esta parte do tutorial, você precisará de uma conta Heroku.
Antes de implementar o aplicativo em Heroku, existem algumas alterações que você precisará fazer no seu código. Primeiro de tudo, adicione um novo script em seu package.json chamado start:
"scripts": {
"test": "echo "Error: no test specified" && exit 1",
"start": "node index.js",
"start-dev": "cross-env NODE_ENV=DEV node index.js",
"start-staging": "cross-env NODE_ENV=STAGING node index.js"
},
Este script será usado pelo Heroku para executar seu aplicativo uma vez implantado. Além disso, vá para a última linha do seu arquivo index.js e atualize para o seguinte:
app.listen(process.env.PORT || 3000);
Isso garantirá que o aplicativo seja implantado na porta especificada pelo Heroku.
Em seguida, você precisa instalar o Heroku CLI localmente para poder acessar seus aplicativos Heroku a partir da sua linha de comando. Para este tutorial, você pode usar o seguinte comando para instalar o CLI:
npm i -g heroku
No entanto, os documentos de Heroku recomendam instalá-lo através de uma das outras formas listadas no link mencionado acima para um melhor suporte. Uma vez instalado, execute o seguinte comando para entrar em sua conta de Heroku:
heroku login
Quando isso for feito, vá para dashboard.heroku.com e faça o login em sua conta. A seguir, crie um novo aplicativo clicando em New > Create new app.
Na página seguinte, clique no botão Create app sem inserir nenhum detalhe. Isso criará um novo aplicativo heroku para você com um nome aleatório.
Aqui está como seria o painel do seu aplicativo:
Esta página também contém instruções sobre como implementar seu aplicativo em Heroku através do CLI. Aqui está a lista de comandos que você deve executar para implementar seu aplicativo no Heroku:
git init
heroku git:remote -a whispering-shelf-49396 # change whispering-shelf-49396 with the name of your app. You can get it in your dashboard
git add index.js package-lock.json package.json # do not push the .env files since we'll provide that via the in-app secrets manager git commit -am "Initial commit" git push heroku main Após a conclusão bem-sucedida da implantação, você pode visualizar o aplicativo implantado por meio do painel de controle, clicando no botão Open App
Se você tiver feito tudo certo, você verá a seguinte resposta:
Por que isso acontece, você pode estar se perguntando? Isso ocorre porque ainda não fornecemos as variáveis de ambiente para nosso aplicativo de nenhuma forma. Se você verificar os comandos que usou para implantar o aplicativo, notará que não incluímos o arquivo .env no nosso controle de versão. Também não definimos o valor de NODE_ENV no script de inicialização.
Para injetar variáveis de ambiente no seu aplicativo agora, você precisa acessar Settings > Config Vars no painel do Heroku. Ao clicar em Reveal Config Vars, você verá uma tela semelhante:
Agora você pode inserir o conteúdo do seu arquivo .env aqui:
Se você voltar e atualizar a URL do seu aplicativo, você notará que os valores foram atualizados:
É assim que você pode usar o gerenciador de segredos de uma plataforma de implantação para gerenciar as variáveis do seu ambiente. Entretanto, isso requer que você gerencie manualmente as variáveis de ambiente através do painel de controle da plataforma. Como você pode ver para Heroku, não há opção de importar uma grande quantidade de variáveis de ambiente de um arquivo, forçando você a inserir cada uma delas uma a uma. Isso pode ficar bastante problemático às vezes.
A próxima seção apresenta um método mais eficiente de gerenciamento de segredos de aplicativo – gerenciadores secretos.
Tipo 3: use Doppler para gerenciar variáveis de ambiente
Os métodos discutidos acima não proporcionam uniformidade entre plataformas. Você normalmente não confiaria em arquivos env ao implementar para a produção, e não é possível usar gerenciadores de variáveis nativas da plataforma quando se trabalha localmente. Gerenciadores secretos como o Doppler preenchem esta lacuna.
Para tirar suas próprias conclusões, você precisa primeiro criar uma conta gratuita no Doppler.
Ele provavelmente criará um projeto template para você automaticamente pelo nome exemplo-projeto. Para simplificar, vamos mantê-lo de lado e criar um novo projeto para o nosso caso de uso.
Vá até o painel e clique no ícone de mais ao lado de Projetos.
Digite seu nome como “my-app” e prossiga. Aqui está como o projeto deve ser uma vez que esteja pronto:
Clique no item da lista de configuração do dev. Clique em Add New Secret e adicione dois segredos como a seguir:
Clique no botão “Salvar” para salvar suas alterações. Observe que o Doppler não suporta o uso de camel case ao nomear seus segredos. Embora seja geralmente preferível manter os nomes dos segredos em letras maiúsculas, usar o Doppler não deixa você com outras opções. Para identificar os segredos obtidos do Doppler, adicionamos o prefixo DP_
Agora que as variáveis são criadas e armazenadas no Doppler, vamos integrá-las em nossa base de código. Você precisa configurar o Doppler CLI para fazer isso. Aqui está um resumo rápido do que você precisa fazer.
Primeiro de tudo, instale o CLI localmente, seguindo as instruções específicas para o seu sistema operacional. Em seguida, faça o login no Doppler CLI com sua conta recém-criada usando o seguinte comando:
doppler login
Uma vez conectado, execute o seguinte comando para se conectar ao seu projeto Doppler remoto a partir do seu CLI:
doppler setup
Uma vez conectado ao projeto certo, você conseguirá acessar seus segredos através do seguinte comando:
doppler run
Entretanto, não vamos executar este comando diretamente. Ao invés disso, o anexaremos a um de nossos scripts de execução para que ele seja executado automaticamente sempre que o aplicativo for iniciado. Vamos atualizar o arquivo package.json com o novo script de execução para o ambiente dev:
// …
"scripts": {
"test": "echo "Error: no test specified" && exit 1",
"start": "node index.js",
"start-dev": "doppler run -- node index.js", // This has to be updated
"start-staging": "cross-env NODE_ENV=STAGING node index.js"
},
// …
Lembre-se também de que criamos novos nomes de variáveis no Doppler que começaram com DP_. Então precisaremos atualizar nosso arquivo index.js para exibir esta variável também:
const express = require("express")
require('dotenv').config({
path: "STAGING" === process.env.NODE_ENV?.toUpperCase() ? './.env.staging' : './.env.dev'
})
console.log(process.env.NODE_ENV)
const app = express()
app.get("/", (req, res) => {
// the responseMessage object extracts its values from environment variables
// If a value is not found, it instead stores the string "not found"
const responseMessage = {
environment: process.env.environment || "Not found",
apiBaseUrl: process.env.apiBaseUrl || "Not found",
DP_ENVIRONMENT: process.env.DP_ENVIRONMENT || "Not found" // Add the new variable here
}
res.send(responseMessage)
})
app.listen(process.env.PORT || 3000);
Para ver tudo em ação, execute o seguinte comando:
npm run start-dev
Este é o visual que o http://localhost:3000 deve ter agora:
A terceira variável da lista (DP_ENVIRONMENT) está sendo buscada diretamente do Doppler.
Em seguida, você pode conectar o Doppler à sua plataforma de implantação para acessar esses segredos através do seu aplicativo implantado. Para fazer isso, vamos começar criando um novo ambiente no Doppler para um novo conjunto de segredos de implantação.
Volte para a página inicial do seu projeto meu-apo. Clique no único item da lista na Staging list:
Você notará que as duas variáveis secretas que você definiu no ambiente dev já estão disponíveis aqui, mas estão faltando valores:
Adicione os seguintes valores e clique em Salvar:
Uma vez feito isso, clique na aba Integrações e Adicione Sincronização nesta página para começar a se conectar à sua plataforma de implantação. Você receberá uma lista de plataformas com as quais o Doppler pode se integrar:
Já que nosso aplicativo está implantado em Heroku, vamos clicar em Heroku. Siga as etapas na tela para conectar sua conta Heroku ao Doppler e fornecer as funções de acesso necessárias. Uma vez conectado, você alcançará uma tela similar:
Selecione o Set Up Integration como App, escolha seu aplicativo Heroku na lista de aplicativos disponíveis, escolha stg como Set Up Integration e Set Up Integration nas Import Options, já que não queremos importar nenhum segredo de Heroku para Doppler.
Clique em Set Up Integration quando estiver pronto. Você alcançará uma tela semelhante quando a integração for feita com sucesso:
Agora se você verificar a seção Config Vars no painel do seu aplicativo Heroku, você notará que as variáveis do Doppler foram adicionadas automaticamente às variáveis de configuração do seu aplicativo Heroku:
Você também vai notar que as duas variáveis de ambiente originais (environment e apiBaseUrl) foram removidas. Isso aconteceu porque escolhemos Import Options em Import Options. Você pode ir em frente e adicioná-las novamente em Heroku, se necessário.
Enquanto a presença das novas variáveis de ambiente na seção Config Vars de Heroku demonstra que você configurou com sucesso o Doppler para gerenciar segredos tanto localmente em seu ambiente de desenvolvimento quanto em seu ambiente de implantação, você pode ir em frente implantar o código atualizado em Heroku para visualizar as alterações no aplicativo implantado. Aqui está o que esperar:
Isso completa o tutorial para configurar variáveis de ambiente em um projeto Node.js usando três métodos populares. Em seguida, vamos dar uma olhada em algumas maneiras nas quais você pode garantir que suas variáveis de ambiente e seus arquivos estejam seguros enquanto estiverem em uso.
Como manter os arquivos de variáveis de ambiente seguros
Embora as Variáveis de ambiente sejam um recurso útil nas modernas práticas de DevOps, você precisa estar ciente das implicações de segurança que elas podem causar. Aqui estão algumas dicas que você pode usar para manter seus arquivos de variáveis de ambiente seguros.
Mantenha os arquivos de ambiente fora do controle de versão
Uma das coisas mais importantes que você deve ter em mente ao lidar com qualquer segredo é mantê-los fora do controle de versão. O controle de versão é feito exclusivamente para rastrear alterações através do código-fonte do seu aplicativo. Tudo o que vai em um sistema de controle de versão permanece nele até ser explicitamente excluído, e a maioria da sua equipe tem acesso a esses dados históricos para fins de referência.
Se você armazenou as chaves do seu bucket de armazenamento AWS ou um serviço API pago em um arquivo env para uso em seu aplicativo, você não quer compartilhá-lo com toda à sua equipe de desenvolvimento, a menos que seja necessário que eles tenham acesso a ele. Se seu projeto é open-sourced em uma plataforma como o GitHub, adicionar arquivos env ao seu VCS pode significar compartilhá-lo com o mundo inteiro! Os arquivos env são destinados a serem armazenados localmente. Você pode fornecer a cada ambiente de implantação os arquivos env relevantes através de métodos dedicados.
Sempre adicione o arquivo env ao seu arquivo .gitignore (assumindo que você use git para controle de versão) ou empregue qualquer outra forma para que seu VCS pule os arquivos env ao cometer alterações. Você pode considerar adicionar um arquivo env template ao seu VCS para que qualquer outro membro da equipe possa usá-lo como uma referência para criar seus arquivos env localmente.
Verifique o nome do pacote antes da instalação
Já que você normalmente instalaria a maioria dos pacotes do NPM ao trabalhar com um aplicativo Node.js, você deve tomar cuidado extra ao fazer isso. É bem conhecido que qualquer pessoa pode criar e implementar um pacote NPM. E também não surpreende que as pessoas frequentemente cometam erros ao digitar o nome de um pacote que eles querem instalar.
Vários casos foram observados onde pacotes maliciosos com nomes similares a alguns pacotes populares foram instalados acidentalmente pelos usuários devido a erros de digitação. Tais pacotes são projetados para ganhar acesso às variáveis de ambiente do seu aplicativo e enviá-los via internet aos seus criadores.
A única maneira de se salvar é estar alerta sempre que instalar novos pacotes a partir da internet.
Prefira os gerenciadores secretos para arquivos env
Com problemas como vazamentos acidentais enquanto compartilham e erros de formatação, os arquivos de env certamente não são a melhor opção disponível para o gerenciamento secreto. Entre com os gerenciadores secretos. Gerenciadores secretos como o Doppler permitem que você isole completamente seus segredos de aplicativo do seu código-fonte e os gerencie em uma plataforma dedicada.
Você pode conceder à sua equipe acesso a esses segredos diretamente na plataforma, e seu aplicativo pode acessá-los através de conexões criptografadas pela internet. Ele resolve todos os males associados aos arquivos env enquanto lhe permite a flexibilidade de manter conjuntos de segredos baseados nos ambientes do seu aplicativo.
No entanto, há algumas considerações importantes a serem feitas. Os gerenciadores de segredos ainda estão em estágio inicial de desenvolvimento tecnológico. Além disso, eles são plataformas de terceiros sujeitas a seus próprios problemas de segurança. Portanto, é essencial realizar uma avaliação cuidadosa e selecionar o gerenciador de segredos correto. Além disso, se o seu aplicativo, a equipe de desenvolvimento ou o número de segredos do aplicativo não forem grandes o suficiente, o uso de um gerenciador de segredos pode ser desnecessário.
Tabela de referência de variáveis de ambiente
Aqui está uma folha de referência rápida para ajudá-lo a se familiarizar rapidamente com as variáveis de ambiente e seu uso:
| Definição das variáveis de ambiente | Variáveis fornecidas aos processos por seus processos de chamada |
| Objetivo |
|
| Tipos | Somente para Windows:
|
| Exemplos populares de casos de uso |
|
| Como implementá-las em seu aplicativo? |
|
Resumo
As variáveis de ambiente são importantes para isolar dados sensíveis do seu aplicativo. Elas ajudam a proteger os segredos do seu aplicativo, bem como permitem que você troque facilmente entre conjuntos de segredos, dependendo do ambiente do aplicativo. No entanto, gerenciá-las adiciona outra tarefa aos seus afazeres.
Existem várias maneiras de proteger as variáveis de ambiente, conforme discutido anteriormente. É importante explorar todas essas opções e determinar qual delas se adequa melhor e acelera o seu projeto de forma mais eficaz.
