Node.js: Configurando Variáveis ​​de Ambiente

Estou tentando seguir um tutorial e diz:

“Existem algumas maneiras de carregar credenciais.

  1. Carregado de variables ​​de ambiente,
  2. Carregado de um arquivo JSON no disco,

As chaves precisam ser as seguintes:

USER_ID, USER_KEY 

… Isso significa que, se você definir corretamente suas variables ​​de ambiente, não precisará gerenciar credenciais em seu aplicativo. ”

Com base em alguns Googling, parece que preciso definir as variables ​​em process.env ? Como e onde eu defino essas credenciais? Exemplo Por favor.

Variáveis ​​de ambiente (neste caso) estão sendo usadas para passar credenciais para seu aplicativo. USER_ID e USER_KEY podem ser acessados ​​de process.env.USER_ID e process.env.USER_KEY respectivamente. Você não precisa editá-los, basta acessar o conteúdo deles.

Parece que eles estão simplesmente dando a você a escolha entre carregar seu USER_ID e USER_KEY de qualquer process.env ou algum arquivo específico no disco.

Agora, a mágica acontece quando você executa o aplicativo.

USER_ID=239482 USER_KEY=foobar node app.js

Isso passará o ID do usuário 239482 e a chave do usuário como foobar . Isso é adequado para testes, no entanto, para produção, você provavelmente estará configurando alguns scripts bash para exportar variables.

Eu recomendo olhar para o pacote dotenv.

https://github.com/motdotla/dotenv

É um pouco semelhante à biblioteca sugerida na resposta do @Benxamin, mas é muito mais limpa e não requer nenhum script bash. Também vale a pena notar que a base de código é popular e bem mantida.

Basicamente, você precisa de um arquivo .env (que eu recomendo que seja ignorado pelo seu git / mercurial / etc):

 FOO=bar BAZ=bob 

Em seguida, no arquivo de input do aplicativo, insira a seguinte linha o mais cedo possível:

 require('dotenv').config(); 

Estrondo. Feito. ‘process.env’ agora conterá as variables ​​acima:

 console.log(process.env.FOO); // bar 

O arquivo ‘.env’ não é necessário, portanto, você não precisa se preocupar com o fato de seu aplicativo cair na ausência dele.

Apenas forneça os valores env na linha de comando

 USER_ID='abc' USER_KEY='def' node app.js 

Se você quiser uma opção de gerenciamento, tente o pacote envs npm. Ele retorna valores de ambiente, se estiverem definidos. Caso contrário, você poderá especificar um valor padrão armazenado em uma variável de object de padrões globais, se não estiver em seu ambiente.

Usar arquivos .env (“dot ee-en-vee”) ou de ambiente é bom por vários motivos. Os indivíduos podem gerenciar suas próprias configurações. Você pode implantar diferentes ambientes (dev, stage, prod) para serviços em nuvem com suas próprias configurações de ambiente. E você pode definir padrões sensatos.

Dentro do seu arquivo .env cada linha é uma input, como neste exemplo:

 NODE_ENV=development API_URL=http://api.domain.com TRANSLATION_API_URL=/translations/ GA_UA=987654321-0 NEW_RELIC_KEY=hi-mom SOME_TOKEN=asdfasdfasdf SOME_OTHER_TOKEN=zxcvzxcvzxcv 

Você não deve include o .env em seu repository de version control (adicione-o ao seu arquivo .gitignore ).

Para obter variables ​​do arquivo .env em seu ambiente, você pode usar um script bash para fazer o equivalente a export NODE_ENV=development logo antes de iniciar seu aplicativo.

 #!/bin/bash while read line; do export "$line"; done  

Então isso vai no seu aplicativo javascript:

 var envs = require('envs'); // If NODE_ENV is not set, // then this application will assume it's prod by default. app.set('environment', envs('NODE_ENV', 'production')); // Usage examples: app.set('ga_account', envs('GA_UA')); app.set('nr_browser_key', envs('NEW_RELIC_BROWSER_KEY')); app.set('other', envs('SOME_OTHER_TOKEN)); 

Você pode definir a variável de ambiente por meio da variável global do processo da seguinte maneira:

 process.env['NODE_ENV'] = 'production'; 

Funciona em todas as plataformas.

Depende do seu sistema operacional e do seu shell

No linux com o bash shell, você cria variables ​​de ambiente como esta (no console):

 export FOO=bar 

Para mais informações sobre variables ​​de ambiente no Ubuntu (por exemplo):

Variáveis ​​de ambiente no Ubuntu

Para usuários do Windows, esta pergunta e resposta superior do Stack Overflow são bastante úteis sobre como definir variables ​​de ambiente por meio da linha de comando

Como posso definir NODE_ENV = produção no Windows?

Veio através de uma boa ferramenta para fazer isso.

node-env-file

Analisa e carrega arquivos de ambiente (contendo exportações de variável ENV) no ambiente Node.js, ou seja, process.env – Usa esse estilo:

 .env # some env variables FOO=foo1 BAR=bar1 BAZ=1 QUX= # QUUX= 

Etapa 1: adicione suas variables ​​de ambiente ao arquivo apropriado. Por exemplo, seu ambiente de preparação poderia ser chamado .env.staging , que contém as variables ​​de ambiente USER_ID e USER_KEY , específicas para seu ambiente de preparação.

Passo 2: No seu arquivo package.json , adicione o seguinte:

 "scripts": { "build": "sh -ac '. ./.env.${REACT_APP_ENV}; react-scripts build'", "build:staging": "REACT_APP_ENV=staging npm run build", "build:production": "REACT_APP_ENV=production npm run build", ... } 

em seguida, chame-o no seu script de implantação assim:

 npm run build:staging 

Super simples configurar e funciona como um encanto!

Fonte: https://medium.com/@tacomanator/environments-with-create-react-app-7b645312c09d

Importante para o Windows: Existem várias maneiras de definir variables ​​de ambiente. Mas a maioria deles NÃO é persistente, eles são temporários para o shell atual. (como SET SWEDISH_CHEF="bork bork" ou $env:SWEDISH_CHEF = "bork bork" )

Para torná-lo persistente, use este comando do PowerShell: [Environment]::SetEnvironmentVariable("SWEDISH_CHEF", "bork bork", "User") nota: o terceiro argumento, "User" , especifica o nível (também pode ser "Process" ou "Machine" mas do que eu encontrei "User" é realmente aquele usado para process.env )

Para verificar se ele persistiu: inicie um novo terminal, execute o node e insira process.env.SWEDISH_CHEF no shell do nó para imprimir o valor.

edit: o env var parece não persistir após o reinício. então acabei configurando-o via GUI em Meu Computador para que ele persistisse para sempre

edit2: uma opção mais simples é apenas criar um arquivo .env na pasta do seu projeto. SWEDISH_CHEF="bork bork"

Como expansão da resposta do @ctrlplusb,
Eu sugiro que você também dê uma olhada no pacote env-dot-prop .

Ele permite que você defina / obtenha propriedades de process.env usando um dot-path .

Vamos supor que o seu process.env contenha o seguinte:

 process.env = { FOO_BAR: 'baz' 'FOO_🦄': '42' } 

Então você pode manipular as variables ​​de ambiente assim:

 const envDotProp = require('env-dot-prop'); console.log(process.env); //=> {FOO_BAR: 'baz', 'FOO_🦄': '42'} envDotProp.get('foo'); //=> {bar: 'baz', '🦄': '42'} envDotProp.get('foo.🦄'); //=> '42' envDotProp.get('foo.🦄', {parse: true}); //=> 42 envDotProp.set('baz.foo', 'bar'); envDotProp.get('', {parse: true}); //=> {foo: {bar: 'baz', '🦄': 42}, baz: {foo: 'bar'}} console.log(process.env); //=> {FOO_BAR: 'baz', 'FOO_🦄': '42', BAZ_FOO: 'bar'} envDotProp.delete('foo'); envDotProp.get(''); //=> {baz: {foo: 'bar'}} console.log(process.env); //=> {BAZ_FOO: 'bar'} 

Isso ajuda você a analisar as variables ​​de ambiente e usá-las como um object de configuração no seu aplicativo.
Também ajuda a implementar uma configuração de 12 fatores .

Uma maneira muito boa de fazer variables ​​de ambiente que usei com sucesso está abaixo:

A. Tem diferentes arquivos de configuração :

  1. dev.js // isto tem todas as variables ​​de ambiente apenas para desenvolvimento
    O arquivo contém:

     module.exports = { ENV: 'dev', someEnvKey1 : 'some DEV Value1', someEnvKey2 : 'some DEV Value2' }; 
  2. stage.js // isto tem todas as variables ​​de ambiente apenas para desenvolvimento

     .. 
  3. qa.js // isso tem todas as variables ​​de ambiente para qa testando apenas
    O arquivo contém:

     module.exports = { ENV: 'dev', someEnvKey1 : 'some QA Value1', someEnvKey2 : 'some QA Value2' }; 

NOTA : os valores estão mudando com o ambiente, principalmente, mas as chaves permanecem iguais.

  1. você pode ter mais

  2. z__prod.js // isso tem todas as variables ​​de ambiente para produção / somente ao vivo
    NOTA: Esse arquivo nunca é empacotado para implantação

  3. Coloque todos esses arquivos de configuração na pasta / config /

     /config/dev.js /config/qa.js /config/z__prod.js /setenv.js /setenv.bat /setenv.sh 

NOTA : O nome do prod é diferente de outros, pois não seria usado por todos.

B. Definir as variables ​​de ambiente do OS / Lambda / AzureFunction / GoogleCloudFunction no arquivo de configuração

Agora, idealmente, essas variables ​​de configuração no arquivo devem ser usadas como variables ​​de ambiente do sistema operacional (ou variables ​​de function LAMBDA ou variables ​​de function do Azure, funções do Google Cloud etc.).

Então, nós escrevemos automação no sistema operacional Windows (ou outro)

  1. Suponha que nós escrevemos o arquivo bat ‘ setenv ‘, que usa um argumento que é o ambiente que queremos definir

  2. Agora execute ” setenv dev

a) Isso leva a input da variável de argumento passada (‘dev’ por enquanto)
b) leia o arquivo correspondente (‘config \ dev.js’)
c) define as variables ​​de ambiente no sistema operacional Windows (ou outro)

Por exemplo,

O conteúdo do setenv.bat pode ser:

  node setenv.js 

O conteúdo do setenv.js pode ser:

  // import "process.env.ENV".js file (dev.js example) // loop the imported file contents // set the environment variables in Windows OS (or, Lambda, etc.) 

Isso é tudo , o seu ambiente está pronto para uso.

Quando você faz ‘ setenv qa ‘, todas as variables ​​de ambiente qa estarão prontas para uso em qa.js e prontas para uso pelo mesmo programa (que sempre solicita process.env.someEnvKey1, mas o valor que obtém é qa one).

Espero que ajude.

Eu estava ficando indefinido depois de definir um sistema env var. Quando eu coloco o APP_VERSION no User env var, então eu posso mostrar o valor do nó via process.env.APP_VERSION