Establecer variables de entorno para el nodo para recuperar

Estoy tratando de seguir un tutorial y dice:

Hay algunas formas de cargar credenciales.

1. Cargado de variables de entorno,
2. Cargado desde un archivo JSON en el disco,

Las claves deben ser las siguientes:

USER_ID, USER_KEY

... Esto significa que si configura correctamente sus variables de entorno, no necesita administrar las credenciales en su aplicación.

Basado en Google, parece que necesito establecer las variables en process.env? ¿Cómo y dónde configuro estas credenciales? Ejemplo por favor.

Las variables de entorno (en este caso) se están utilizando para pasar credenciales a su aplicación. USER_IDy USER_KEYse puede acceder a ambos desde process.env.USER_IDy process.env.USER_KEYrespectivamente. No necesita editarlos, solo acceda a sus contenidos.

Parece que simplemente te dan la opción de cargar tu USER_IDy USER_KEYdesde uno process.envo algún archivo específico en el disco.

Ahora, la magia ocurre cuando ejecutas la aplicación.

USER_ID=239482 USER_KEY=foobar node app.js

Eso pasará la identificación de usuario 239482y la clave de usuario como foobar. Esto es adecuado para la prueba, sin embargo, para la producción, probablemente configurará algunos scripts de bash para exportar variables.

Recomiendo buscar en el paquete dotenv.

https://github.com/motdotla/dotenv

Es algo similar a la biblioteca sugerida en la respuesta de @Benxamin, pero es mucho más limpia y no requiere ningún script de bash. También vale la pena señalar que el código base es popular y está bien mantenido.

Básicamente necesita un archivo .env (que recomiendo que se ignore de su git / mercurial / etc):

FOO=bar
BAZ=bob

Luego, en el archivo de entrada de la aplicación, ingrese la siguiente línea lo antes posible:

require('dotenv').config();

Auge. Hecho. 'process.env' ahora contendrá las variables anteriores:

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

El archivo '.env' no es obligatorio, por lo que no debe preocuparse de que su aplicación se caiga en ausencia.

Solo proporcione los valores env en la línea de comando

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

Puede establecer la variable de entorno a través de la variable global del proceso de la siguiente manera:

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

Funciona en todas las plataformas.

Si desea una opción de administración, pruebe el paquete envs npm. Devuelve valores de entorno si están establecidos. De lo contrario, puede especificar un valor predeterminado que se almacena en valores predeterminados globales variable de objeto si no está en su entorno.

El uso de archivos .env ("dot ee-en-vee") o de entorno es bueno por muchas razones. Las personas pueden administrar sus propias configuraciones. Puede implementar diferentes entornos (dev, stage, prod) en servicios en la nube con su propia configuración de entorno. Y puede establecer valores predeterminados razonables.

Dentro de su .envarchivo, cada línea es una entrada, como este ejemplo:

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

Usted debe no incluirá el .enven su control de versiones del repositorio (añadirlo a su .gitignorearchivo).

Para obtener variables del .envarchivo en su entorno, puede usar un script bash para hacer el equivalente de export NODE_ENV=developmentjusto antes de iniciar su aplicación.

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

Entonces esto va en su aplicación 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));

Depende de su sistema operativo y su shell

En Linux con el shell bash , puede crear variables de entorno como esta (en la consola):

export FOO=bar

Para obtener más información sobre las variables de entorno en ubuntu (por ejemplo):

Variables de entorno en ubuntu

Como dijo ctrlplusb, te recomiendo que uses el paquete dotenv , pero otra forma de hacerlo es crear un archivo js y requerirlo en la primera línea de su servidor de aplicaciones.

env.js:

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

app.js:

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

Usuarios de Windows: ¡presten atención! Estos comandos se recomiendan para Unix, pero en Windows son solo temporales. Establecen una variable solo para el shell actual, tan pronto como reinicie su máquina o inicie un nuevo shell de terminal, desaparecerán.

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

Para establecer una variable de entorno persistente en Windows, debe utilizar uno de los siguientes enfoques:

A) archivo .env en su proyecto : este es el mejor método porque significa que puede mover su proyecto a otros sistemas sin tener que configurar sus variables de entorno en ese sistema antes de que pueda ejecutar su código.

1. Cree un .envarchivo en la raíz de su carpeta de proyecto con el contenido:TEST="hello world"

2. Escriba un código de nodo que lea ese archivo. Sugiero instalar dotenv ( npm install dotenv --save) y luego agregarlo require('dotenv').config();durante el código de configuración de su nodo.

3. Ahora su código de nodo podrá accederprocess.env.TEST

Los archivos Env son una buena forma de mantener las claves de API y otros secretos que no desea tener en su base de código. Solo asegúrate de agregarlo a tu .gitignore.

B) Use Powershell : esto creará una variable que será accesible en otros terminales. Pero tenga cuidado, la variable se perderá después de reiniciar su computadora.

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

Este método se recomienda ampliamente en los foros de Windows, pero no creo que la gente sepa que la variable no persiste después de reiniciar el sistema ...

C) Use la GUI de Windows

1. Busque "Variables de entorno" en el menú Inicio Buscar o en el Panel de control
2. Seleccione "Editar las variables de entorno del sistema"
3. Se abrirá un diálogo. Haga clic en el botón "Variables de entorno" en la parte inferior del diálogo.
4. Ahora tienes una pequeña ventana para editar variables. Simplemente haga clic en el botón "Nuevo" para agregar una nueva variable de entorno. Fácil.

Paso 1: Agregue sus variables de entorno a su archivo apropiado. Por ejemplo, se podría llamar a su entorno de ensayo .env.staging, que contiene las variables de entorno USER_IDy USER_KEY, específico de su entorno de ensayo.

Paso 2: en su package.jsonarchivo, agregue lo siguiente:

"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",
  ...
}

luego llámelo en su script de despliegue de esta manera:

npm run build:staging

¡Configuración súper simple y funciona como un encanto!

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

Para los usuarios de Windows, esta pregunta y respuesta superior de Stack Overflow es bastante útil sobre cómo establecer variables de entorno a través de la línea de comandos

¿Cómo puedo configurar NODE_ENV = producción en Windows?

Encontré una buena herramienta para hacer esto.

nodo-env-archivo

Analiza y carga archivos de entorno (que contienen exportaciones de variables ENV) en el entorno Node.js, es decir process.env: utiliza este estilo:

.env

# some env variables

FOO=foo1
BAR=bar1
BAZ=1
QUX=
# QUUX=

Como expansión de la respuesta @ctrlplusb,
te sugiero que también eches un vistazo al env-dot-proppaquete.

Le permite establecer / obtener propiedades process.envusando a dot-path.

Supongamos que su process.envcontiene lo siguiente:

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

Luego puede manipular las variables de entorno de esa manera:

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'}

Esto le ayuda a analizar las variables de entorno y usarlas como un objeto de configuración en su aplicación.
También lo ayuda a implementar una configuración de 12 factores .

A continuación se muestra una muy buena forma de hacer variables de entorno que he utilizado con éxito:

A. Tener diferentes archivos de configuración :

1. dev.js // esto tiene todas las variables de entorno solo para desarrollo
   El archivo contiene:

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

2. stage.js // esto tiene todas las variables de entorno solo para desarrollo

   ..

3. qa.js // esto tiene todas las variables de entorno para pruebas de qa solamente
   El archivo contiene:

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

NOTA : los valores están cambiando con el entorno, principalmente, pero las claves siguen siendo las mismas.

4. puedes tener más

5. z__prod.js // esto tiene todas las variables de entorno solo para producción / en vivo
   NOTA: Este archivo nunca se incluye para su implementación

6. Ponga todos estos archivos de configuración en la carpeta / config /

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

NOTA : El nombre de prod es diferente a otros, ya que no sería usado por todos.

B. Establezca las variables de entorno OS / Lambda / AzureFunction / GoogleCloudFunction desde el archivo de configuración

Ahora, idealmente, estas variables de configuración en el archivo deben ir como variables de entorno del sistema operativo (o, variables de función LAMBDA, o, variables de función de Azure, Google Cloud Functions, etc.)

entonces, escribimos automatización en el sistema operativo Windows (u otro)

1. Supongamos que escribimos el archivo bat ' setenv ', que toma un argumento que es el entorno que queremos establecer

2. Ahora ejecuta " setenv dev "

a) Esto toma la entrada de la variable de argumento pasada ('dev' por ahora)
b) lee el archivo correspondiente ('config \ dev.js')
c) establece las variables de entorno en el sistema operativo Windows (u otro)

Por ejemplo,

Los contenidos de setenv.bat pueden ser:

    node setenv.js

Los contenidos de setenv.js pueden 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.)

Eso es todo , su entorno está listo para usar.

Cuando hace ' setenv qa ', todas las variables de entorno qa estarán listas para usar desde qa.js, y listas para usar con el mismo programa (que siempre solicita process.env.someEnvKey1, pero el valor que obtiene es qa one).

Espero que ayude.

Haz tu vida más fácil con dotenv-webpack . Simplemente instálelo npm install dotenv-webpack --save-dev, luego cree un .envarchivo en la raíz de su aplicación (recuerde agregar esto .gitignoreantes que usted git push). Abra este archivo y configure algunas variables ambientales allí, como por ejemplo:

ENV_VAR_1=1234
ENV_VAR_2=abcd
ENV_VAR_3=1234abcd

Ahora, en su configuración de paquete web, agregue:

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.

Solo const Dotenv = require('dotenv-webpack');, plugins: [new Dotenv()]y por supuesto module.exports = webpackConfig; // Export all custom Webpack configs.son obligatorios. Sin embargo, en algunos escenarios puede obtener algunos errores. Para estos, también tiene la solución que implica cómo puede corregir ciertos errores.

Ahora, donde quieras, simplemente puedes usar process.env.ENV_VAR_1 , process.env.ENV_VAR_2, process.env.ENV_VAR_3en su aplicación.

Estaba indefinido después de configurar un sistema env var. Cuando pongo APP_VERSION en el usuario env var, entonces puedo mostrar el valor del nodo a través de process.env.APP_VERSION

Si está utilizando un mac / linux y desea recuperar los parámetros locales en la máquina que está utilizando, esto es lo que hará:

1. En la terminal, ejecute nano ~ / .bash_profile
2. agregue una línea como: export MY_VAR = var
3. guardar y ejecutar código fuente ~ / .bash_profile
4. en el uso del nodo como: console.log ( process.env.MY_VAR );