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

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.

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.

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.

Basta fornecer os valores env na linha de comando

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

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.

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));

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

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

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.

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

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?

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=

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 .

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.

4. você pode ter mais

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

6. 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.

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.

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

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 );