Definindo variáveis ​​de ambiente para o nó recuperar

414

Estou tentando seguir um tutorial e ele diz:

Existem algumas maneiras de carregar credenciais.

  1. Carregado de variáveis ​​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 variáveis ​​de ambiente, não precisará gerenciar credenciais em seu aplicativo.

Com base em alguns Google, parece que eu preciso definir as variáveis process.env? Como e onde eu defino essas credenciais? Exemplo Por favor.

user1107173
fonte

Respostas:

397

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

Parece que eles estão simplesmente oferecendo a você a opção entre carregar seu USER_IDe USER_KEYde um process.envou mais arquivos específicos em disco.

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

USER_ID=239482 USER_KEY=foobar node app.js

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

SamT
fonte
26
Se você estiver usando fish, em vez de bash, você precisa usar: env USER_ID=239482 my_command. Por exemplo, para definir variáveis ​​de ambiente para a debugbiblioteca env DEBUG='*' node some_file.js node.js
SilentSteel
1
Eu descobri que eu tinha para remover as aspas "*" para que ele funcione:env DEBUG=* node some_file.js
divillysausages
@ SamT como definir essas variáveis ​​no Ubuntu linux?
Mohammed Zameer
1
é possível adicionar um arquivo em vez de adicionar um grande número de scripts env ou um usuário unix precisa criar um script bash?
Mibbit
@ mibbit sim, é disso que dotenvse trata, pois ele lerá seu .envarquivo e aplicará.
precisa
200

Eu recomendo olhar para o pacote dotenv.

https://github.com/motdotla/dotenv

É parecido com a biblioteca sugerida na resposta do @Benxamin, mas é muito mais limpa e não requer scripts bash. Também é importante notar que a base de código é popular e bem conservada.

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

FOO=bar
BAZ=bob

Em seguida, no arquivo de entrada do aplicativo, insira a seguinte linha o mais rápido possível:

require('dotenv').config();

Estrondo. Feito. 'process.env' agora conterá as variáveis ​​acima:

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

O arquivo '.env' não é necessário, portanto você não precisa se preocupar com a queda do aplicativo na ausência dele.

ctrlplusb
fonte
1
Embora se você colocar detalhes de configuração relevantes que o seu aplicativo exige (como é o que esta pergunta está perguntando), é provável que ele caia na sua ausência .. mas ainda parece ser uma boa opção.
John
6
Se você está procurando segurança extra, github.com/rolodato/dotenv-safe e alguns testes devem fazê-lo.
Ctrlplusb
1
Se você não precisa exigir isso em seu aplicativo: github.com/direnv/direnv
AlecRust
100

Basta fornecer os valores env na linha de comando

USER_ID='abc' USER_KEY='def' node app.js
palanik
fonte
2
Apenas adicionando que funcionou para mim no Windows com o shell bash (cygwin; instalado com as ferramentas git, eu acho).
Markau 17/03/16
@ TiborSzasz: Cygwin ou Powershell devem consertar isso. Isso é mencionado dois anos depois, é claro.
orlando Marinella
9
Para uso do Windows: SET USER_ID = 'abc'
Mike
@ Mike, você deve fazer que uma resposta adequada :)
rocketspacer
6
Podemos usar pacote de cross-env ( npmjs.com/package/cross-env ) para fazê-lo funcionar no UNIX ou windwos
Brij
79

Você pode definir a variável de ambiente através da variável global do processo da seguinte maneira:

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

Funciona em todas as plataformas.

jsbisht
fonte
22
... variáveis de ambiente se destinam a ser definido a partir do lado de fora do código, não indside - de modo que este é derrotar o propósito e um mau exemplo
Soren
44
@Soren nosso programa nó que processo lançamentos criança beneficiaram desta resposta, por isso há casos de uso para esse mesmo que seja um pouco não ortodoxa
IPPE
2
@pspi - Tenho 99% de certeza de que você está fazendo errado e, a menos que seja o autor de um pacote de configuração como esse, você deve usar esse pacote de configuração.
Soren
17
Isso é útil se você estiver escrevendo scripts de construção em js e executá-los a partir de NPM
Stephen Drew
28
Isso também é útil para, por exemplo, definir e substituir o ambiente ao executar testes.
Mtkopone 29/05
54

Se você deseja uma opção de gerenciamento, tente o pacote envs npm. Retorna valores do ambiente se eles estiverem definidos. Caso contrário, você pode especificar um valor padrão que será armazenado em uma variável de objeto de padrões globais, se não estiver em seu ambiente.

O uso de 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) nos serviços em nuvem com suas próprias configurações de ambiente. E você pode definir padrões sensíveis.

Dentro do seu .envarquivo, cada linha é uma entrada, como este 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 incluir .envno seu repositório de controle de versão (adicione-o ao seu .gitignorearquivo).

Para obter variáveis ​​do .envarquivo em seu ambiente, você pode usar um script bash para fazer o equivalente a export NODE_ENV=developmentantes de iniciar seu aplicativo.

#!/bin/bash
while read line; do export "$line";
done <source .env

Então isso vai no javascript do seu aplicativo:

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));
Benxamin
fonte
1
Hmm, tentei usar este pacote, mas parece rastrear apenas o uso de variáveis ​​de ambiente. Ele não lê o arquivo .env ( npmjs.com/package/envs ). É um pacote correto?
Wawka 15/04
1
Você está certo! Ele não lê o arquivo .env. Isso é embaraçoso. Eu esqueci que estava carregando o .env com um script bash como o @SamT mencionado, por isso funcionou de qualquer maneira.
precisa saber é o seguinte
1
"require ('envs')"? O que é "envs"?
CodyBugstein 26/09/16
1
'envs' é o nome de um módulo de nó: npmjs.com/package/envs
Benxamin 26/09/16
4
Também recomendo usar o módulo "dotenv", que coloca todas as variáveis ​​ENV no objeto de processo, bem arrumado a propósito.
Bruno de Oliveira
37

Depende do seu sistema operacional e do seu shell

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

export FOO=bar

Para mais informações sobre variáveis ​​de ambiente no ubuntu (por exemplo):

Variáveis ​​de ambiente no ubuntu

leszek.hanusz
fonte
1
Em seguida, veja esta resposta: stackoverflow.com/questions/135688/…
leszek.hanusz
2
E o Windows? Você poderia adicionar aqui?
YakovL
Ah, deixa pra lá, parece que é respondida aqui: stackoverflow.com/questions/9249830/...
YakovL
no Linux bash, esses valores são mantidos? e se eu quiser apenas executá-lo enquanto o terminal estiver aberto para não causar problemas com outros aplicativos posteriormente?
JesseBoyd
13

Como o ctrlplusb disse, recomendo que você use o pacote dotenv, mas outra maneira de fazer isso é criar um arquivo js e exigi-lo na primeira linha do seu servidor de aplicativos.

env.js:

process.env.VAR1="Some value"
process.env.VAR2="Another Value"

app.js:

require('env')
console.log(process.env.VAR1) // Some value
dpolicastro
fonte
9

Usuários do Windows: preste atenção! Esses comandos são recomendados para Unix, mas no Windows são apenas temporários. Eles definem uma variável apenas para o shell atual; assim que você reiniciar sua máquina ou iniciar um novo terminal, eles desaparecerão.

  • SET TEST="hello world"
  • $env:TEST = "hello world"

Para definir uma variável de ambiente persistente no Windows, você deve usar uma das seguintes abordagens:

A) arquivo .env em seu projeto - este é o melhor método, pois significa que você pode mover seu projeto para outros sistemas sem precisar configurar os ambientes do ambiente nesse sistema antes de executar seu código.

  1. Crie um .envarquivo na raiz da pasta do projeto com o conteúdo:TEST="hello world"

  2. Escreva um código de nó que leia esse arquivo. Sugiro instalar o dotenv ( npm install dotenv --save) e, em seguida, adicionar require('dotenv').config();durante o código de configuração do nó.

  3. Agora o código do seu nó poderá acessarprocess.env.TEST

Os arquivos Env servem para manter chaves api e outros segredos que você não deseja ter em sua base de código. Apenas certifique-se de adicioná-lo ao seu .gitignore.

B) Use o PowerShell - isso criará uma variável que estará acessível em outros terminais. Mas cuidado, a variável será perdida depois que você reiniciar o computador.

[Environment]::SetEnvironmentVariable("TEST", "hello world", "User")

Esse método é amplamente recomendado nos fóruns do Windows, mas acho que as pessoas não sabem que a variável não persiste após a reinicialização do sistema ....

C) Use a GUI do Windows

  1. Procure por "Variáveis ​​de ambiente" na Pesquisa no menu Iniciar ou no Painel de controle.
  2. Selecione "Editar as variáveis ​​de ambiente do sistema"
  3. Um diálogo será aberto. Clique no botão "Variáveis ​​de ambiente" na parte inferior da caixa de diálogo.
  4. Agora você tem uma pequena janela para editar variáveis. Basta clicar no botão "Novo" para adicionar uma nova variável de ambiente. Fácil.
Drkawashima
fonte
8

Etapa 1: adicione suas variáveis ​​de ambiente ao arquivo apropriado. Por exemplo, seu ambiente de temporariedade pode ser chamado .env.staging, que contém as variáveis ​​de ambiente USER_IDe USER_KEY, específicas para o seu ambiente de temporariedade.

Etapa 2: no seu package.jsonarquivo, 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",
  ...
}

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

npm run build:staging

Configuração super simples e funciona como um encanto!

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

Blairg23
fonte
2
@JohnXiao como é isso?
Blairg23
5

Para usuários do Windows, a pergunta Stack Overflow e a resposta principal são bastante úteis sobre como definir variáveis ​​de ambiente através da linha de comando

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

asherrard
fonte
4

Me deparei com uma boa ferramenta para fazer isso.

nó-env-arquivo

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

.env

# some env variables

FOO=foo1
BAR=bar1
BAZ=1
QUX=
# QUUX=
Sean McClory
fonte
2

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

Ele permite que você defina / obtenha propriedades process.envusando a dot-path.

Vamos supor que você process.envcontenha o seguinte:

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

Então você pode manipular as variáveis ​​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 variáveis ​​de ambiente e usá-las como um objeto de configuração no seu aplicativo.
Também ajuda a implementar uma configuração de 12 fatores .

simonepri
fonte
2

Uma maneira muito boa de executar variáveis ​​de ambiente que usei com sucesso está abaixo:

A. Tenha arquivos de configuração diferentes :

  1. dev.js // isso possui todas as variáveis ​​de ambiente apenas para desenvolvimento
    O arquivo contém:

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

    ..
  3. qa.js // isso possui todas as variáveis ​​de ambiente apenas para teste de qa
    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 as mesmas.

  1. você pode ter mais

  2. z__prod.js // possui todas as variáveis ​​de ambiente somente para produção / produção
    NOTA: Esse arquivo nunca é empacotado para implantação

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

    <projectRoot>/config/dev.js
    <projectRoot>/config/qa.js
    <projectRoot>/config/z__prod.js
    <projectRoot>/setenv.js
    <projectRoot>/setenv.bat
    <projectRoot>/setenv.sh

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

B. Defina as variáveis ​​de ambiente OS / Lambda / AzureFunction / GoogleCloudFunction no arquivo de configuração

Agora, idealmente, essas variáveis ​​de configuração no arquivo devem ser como variáveis ​​de ambiente do SO (ou variáveis ​​de função LAMBDA ou variáveis ​​de função do Azure, funções do Google Cloud etc.)

então, escrevemos automação no sistema operacional Windows (ou outro)

  1. Suponha que escrevamos o arquivo bat ' setenv ', que usa um argumento que é o ambiente que queremos definir

  2. Agora execute " setenv dev "

a) Isso pega a entrada da variável de argumento passada ('dev' por enquanto)
b) lê o arquivo correspondente ('config \ dev.js')
c) define as variáveis ​​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 , seu ambiente está pronto para uso.

Quando você faz ' setenv qa ', todas as variáveis ​​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 obtido é qa um).

Espero que ajude.

Manohar Reddy Poreddy
fonte
1

Facilite sua vida com o dotenv-webpack . Simplesmente instale-o npm install dotenv-webpack --save-deve crie um .envarquivo na raiz do seu aplicativo (lembre-se de adicioná-lo .gitignoreantes de você git push). Abra este arquivo e defina algumas variáveis ​​ambientais, como por exemplo:

ENV_VAR_1=1234
ENV_VAR_2=abcd
ENV_VAR_3=1234abcd

Agora, na sua configuração do webpack, adicione:

const Dotenv = require('dotenv-webpack');
const webpackConfig = {
  node: { global: true, fs: 'empty' }, // Fix: "Uncaught ReferenceError: global is not defined", and "Can't resolve 'fs'".
  output: {
    libraryTarget: 'umd' // Fix: "Uncaught ReferenceError: exports is not defined".
  },
  plugins: [new Dotenv()]
};
module.exports = webpackConfig; // Export all custom Webpack configs.

Apenas const Dotenv = require('dotenv-webpack');, plugins: [new Dotenv()]e, claro, module.exports = webpackConfig; // Export all custom Webpack configs.são necessários. No entanto, em alguns cenários, você pode obter alguns erros. Para estes, você tem a solução, bem como implica em como corrigir um erro.

Agora, sempre que você quiser, pode simplesmente usar process.env.ENV_VAR_1, process.env.ENV_VAR_2, process.env.ENV_VAR_3na sua aplicação.

Daniel Danielecki
fonte
0

Eu estava ficando indefinido depois de definir um sistema env var. Quando coloco APP_VERSION na variável Env do usuário, posso exibir o valor do nó via process.env.APP_VERSION

omencat
fonte
-1

Se você estiver usando um mac / linux e quiser recuperar parâmetros locais na máquina que está usando, é isso que você fará:

  1. No terminal, execute nano ~ / .bash_profile
  2. adicione uma linha como: export MY_VAR = var
  3. salvar e executar o código-fonte ~ / .bash_profile
  4. no nó use como: console.log ( process.env.MY_VAR );
TacoEater
fonte