Establecer variables de entorno para el nodo para recuperar

415

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.

usuario1107173
fuente

Respuestas:

397

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.

SamT
fuente
26
Si está utilizando fishen lugar de bash, es necesario el uso: env USER_ID=239482 my_command. Por ejemplo, para establecer variables de entorno para la debugbiblioteca de env DEBUG='*' node some_file.js node.js
SilentSteel
1
Descubrí que tenía que eliminar las comillas alrededor de "*" para que funcionara:env DEBUG=* node some_file.js
divillysausages
@SamT ¿cómo se configuran estas variables en Ubuntu Linux?
Mohammed Zameer
1
¿es posible agregar un archivo en lugar de agregar una gran cantidad de scripts env o un usuario de Unix necesita crear un script bash?
mibbit
@mibbit sí, de eso dotenvse trata, ya que leerá su .envarchivo y lo aplicará.
balexandre
201

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.

ctrlplusb
fuente
1
Aunque si coloca los detalles de configuración relevantes que requiere su aplicación (como por ejemplo esta pregunta), es probable que se caiga en su ausencia ... pero aún parece una buena opción.
John
66
Si está buscando seguridad adicional, github.com/rolodato/dotenv-safe y algunas pruebas deberían hacerlo.
ctrlplusb
1
Si está buscando no tener que requerirlo en su aplicación: github.com/direnv/direnv
AlecRust el
100

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

USER_ID='abc' USER_KEY='def' node app.js
palanik
fuente
2
Solo agrego que funcionó para mí en Windows con bash shell (cygwin; instalado con herramientas git, creo).
markau
@TiborSzasz: Cygwin o Powershell deberían arreglar eso. Esto se menciona dos años después, por supuesto.
orlando marinella
99
Para uso de Windows: SET USER_ID = 'abc'
Mike
@ Mike, deberías darle una respuesta adecuada :)
rocketspacer
66
Podemos usar el paquete cross-env ( npmjs.com/package/cross-env ) para que funcione en Unix o Windwos
Brij
79

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.

jsbisht
fuente
22
... las variables de entorno están destinadas a establecerse desde el exterior del código, no desde adentro, por lo que esto está frustrando el propósito y un mal ejemplo
Soren
44
@Soren nuestro programa de nodo que inicia el proceso secundario se benefició de esta respuesta, por lo que hay casos de uso para esto a pesar de que es un poco poco ortodoxo
pspi
2
@pspi: estoy 99% seguro de que lo estás haciendo mal y, a menos que seas el autor de un paquete de configuración como este , deberías usar dicho paquete de configuración.
Soren
17
Esto es útil si está escribiendo scripts de compilación en js y ejecutándolos desde npm
Stephen Drew
28
Esto también es útil, por ejemplo, para configurar y anular el entorno al ejecutar pruebas.
mtkopone
54

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));
Benxamin
fuente
1
Hmm, traté de usar este paquete, pero parece que solo rastrea el uso de la variable de entorno. No lee el archivo .env ( npmjs.com/package/envs ). ¿Es un paquete correcto?
wawka
1
¡Tienes razón! No lee el archivo .env. Esto es embarazoso. Olvidé que estaba cargando el .env con un script bash como mencionó @SamT, por lo que funcionó de todos modos.
Benxamin
1
"require ('envs')"? ¿Qué es "envs"?
CodyBugstein
1
'envs' es el nombre de un módulo de nodo: npmjs.com/package/envs
Benxamin
44
También recomiendo usar el módulo "dotenv", que pone todas las variables ENV en el objeto de proceso, por cierto, bastante ordenado.
Bruno de Oliveira
37

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

leszek.hanusz
fuente
1
Entonces vea esta respuesta: stackoverflow.com/questions/135688/…
leszek.hanusz
2
¿Y qué hay de Windows? ¿Podría agregar aquí?
YakovL
Ah, no importa, parece que se responde aquí: stackoverflow.com/questions/9249830/…
YakovL
en Linux bash, ¿persisten estos valores? ¿Qué sucede si solo quiero ejecutarlo mientras el terminal está abierto para no causar problemas con otras aplicaciones más adelante?
JesseBoyd
13

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
dpolicastro
fuente
9

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.
Drkawashima
fuente
8

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

Blairg23
fuente
2
@JohnXiao ¿cómo es eso?
Blairg23
4

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=
Sean McClory
fuente
2

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 .

simonepri
fuente
2

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.

  1. puedes tener más

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

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

Manohar Reddy Poreddy
fuente
1

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.

Daniel Danielecki
fuente
0

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

omencat
fuente
-1

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