node.js - dotenv - Configuración de variables de entorno para el nodo para recuperar

variables de entorno javascript

Question

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 en absoluto ".

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

Answer 1

Como dijo ctrlplusb, le recomiendo que use el paquete dotenv, pero otra forma de hacerlo es creando un archivo js y solicitándolo 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

Answer 2

Como expansión de la respuesta @ctrlplusb,
Le sugiero que también eche un vistazo al paquete env-dot-prop .

Le permite establecer / obtener propiedades de process.env usando una dot-path .

Supongamos que su process.env contiene lo siguiente:

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

Entonces puedes manipular las variables de entorno así:

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 le ayuda a implementar una configuración de 12 factores .

Answer 3

Depende de tu sistema operativo y tu shell.

En Linux con el shell bash, creas 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

Answer 4

Encontré una buena herramienta para hacer esto.

node-env-file

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=

Answer 5

Importante para Windows: hay varias formas de establecer variables de entorno. Pero la mayoría de ellos NO son persistentes, son temporales para el shell actual. (como SET SWEDISH_CHEF="bork bork" o $env:SWEDISH_CHEF = "bork bork" )

Para hacer que persista, use este comando de PowerShell: [Environment]::SetEnvironmentVariable("SWEDISH_CHEF", "bork bork", "User") nota: el tercer argumento, "User" , especifica el nivel (también puede ser "Process" o "Machine" pero de lo que he encontrado "User" es en realidad el que se usa para process.env )

Para verificar que persistió: Inicie un nuevo terminal, ejecute el node e ingrese process.env.SWEDISH_CHEF en el shell del nodo para imprimir el valor.

editar: la var. env no parece persistir después de reiniciar. así que terminé configurándolo a través de la GUI en Mi PC para hacerla persistir para siempre

edit2: una opción más simple es, por supuesto, crear un archivo .env en la carpeta de su proyecto. SWEDISH_CHEF="bork bork"

Answer 6

Las variables de entorno (en este caso) se utilizan para pasar credenciales a su aplicación. USER_KEY puede acceder a USER_ID y USER_KEY desde process.env.USER_ID y process.env.USER_KEY respectivamente. No necesitas editarlos, solo accede a sus contenidos.

Parece que simplemente te están dando la opción de cargar tu USER_ID y USER_KEY desde process.env o algún archivo específico en el disco.

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

USER_ID=239482 USER_KEY=foobar node app.js

Eso pasará el ID de usuario 239482 y la clave de usuario como foobar . Esto es adecuado para las pruebas; sin embargo, para la producción, probablemente estará configurando algunos scripts de bash para exportar variables.

Answer 7

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

Answer 8

Para los usuarios de Windows, esta pregunta de desbordamiento de pila y la mejor respuesta son bastante útiles sobre cómo configurar variables de entorno a través de la línea de comando

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

Answer 9

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

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

Funciona en todas las plataformas.

Answer 10

Recomiendo encarecidamente mirar en el paquete dotenv.

https://github.com/motdotla/dotenv

Es 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 git / mercurial / etc):

FOO=bar
BAZ=bob

Luego, en el archivo de entrada de la aplicación, coloque 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 necesario, por lo que no debe preocuparse por la caída de su aplicación en su ausencia.

Answer 11

Si desea una opción de administración, pruebe el paquete envs npm. Devuelve valores de entorno si están configurados. De lo contrario, puede especificar un valor predeterminado que se almacene en una variable de objeto predeterminada global 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 gestionar sus propias configuraciones. Puede implementar diferentes entornos (dev, stage, prod) para servicios en la nube con su propia configuración de entorno. Y puede establecer valores predeterminados razonables.

Dentro de su archivo .env , 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

No debe incluir el .env en su repositorio de control de versiones (agréguelo a su archivo .gitignore ).

Para obtener las variables del archivo .env en su entorno, puede usar un script bash para hacer el equivalente de export NODE_ENV=development justo antes de iniciar la aplicación.

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

Entonces esto va en tu 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));

Answer 12

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

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

Answer 13

Una muy buena manera de hacer las variables de entorno que he usado con éxito es a continuación:

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 solo para pruebas qa
   El archivo contiene:

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

NOTA : los valores están cambiando con el entorno, en su mayoría, pero las claves siguen siendo las mismas.

4. puedes tener mas

5. z__prod.js // esto tiene todas las variables de entorno para producción / solo 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 utilizado 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 la función LAMBDA, o, variables de la función de Azure, funciones de Google Cloud, etc.)

Así, 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) leer el archivo correspondiente (''config / dev.js'')
c) establece las variables de entorno en el sistema operativo Windows (u otro)

Por ejemplo,

El contenido de setenv.bat podría 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 su uso.

Cuando haga '' setenv qa '', todas las variables de entorno qa estarán listas para su uso desde qa.js, y estarán listas para su uso por el mismo programa (que siempre solicita process.env.someEnvKey1, pero el valor que obtiene es qa uno).

Espero que ayude.

Answer 14

Paso 1: Agregue sus variables de entorno a su archivo apropiado. Por ejemplo, su entorno de ensayo podría llamarse .env.staging , que contiene las variables de entorno USER_ID y USER_KEY , específicas de su entorno de USER_KEY .

Paso 2: En su archivo package.json , 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",
...
}

Entonces llámalo en tu script de implementación de esta manera:

npm run build:staging

Súper simple de configurar y funciona a la perfección!

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