principiantes - Node.js configura configuraciones específicas del entorno para usar con everyauth

node variables de entorno windows

Question

Estoy usando node.js + express.js + everyauth.js. He movido toda mi lógica everyauth a un archivo de módulo

var login = require(''./lib/everyauthLogin'');

dentro de esto cargo mi archivo de configuración oAuth con las combinaciones de clave / secreto:

var conf = require(''./conf'');
.....
twitter: {
consumerKey: ''ABC'',
consumerSecret: ''123''
}

Estos códigos son diferentes para diferentes entornos: desarrollo / puesta en escena / producción, ya que las devoluciones de llamada son para diferentes URL.

Qu. ¿Cómo configuro estos en la configuración del entorno para filtrar a través de todos los módulos o puedo pasar la ruta directamente al módulo?

Establecer en env:

app.configure(''development'', function(){
app.set(''configPath'', ''./confLocal'');
});
app.configure(''production'', function(){
app.set(''configPath'', ''./confProduction'');
});
var conf = require(app.get(''configPath''));

Aconteció en

app.configure(''production'', function(){
var login = require(''./lib/everyauthLogin'', {configPath: ''./confProduction''});
});

? espero que tenga sentido

Answer 1

En breve

Este tipo de configuración es simple y elegante:

env.json

{
"development": {
"facebook_app_id": "facebook_dummy_dev_app_id",
"facebook_app_secret": "facebook_dummy_dev_app_secret",
},
"production": {
"facebook_app_id": "facebook_dummy_prod_app_id",
"facebook_app_secret": "facebook_dummy_prod_app_secret",
}
}

common.js

var env = require(''env.json'');
exports.config = function() {
var node_env = process.env.NODE_ENV || ''development'';
return env[node_env];
};

app.js

var common = require(''./routes/common'')
var config = common.config();
var facebook_app_id = config.facebook_app_id;
// do something with facebook_app_id

Para ejecutar en modo de producción: $ NODE_ENV=production node app.js

En detalle

Esta solución es de: http://himanshu.gilani.info/blog/2012/09/26/bootstraping-a-node-dot-js-app-for-dev-slash-prod-environment/ , compruébalo por mas detalle.

Answer 2

¿Qué tal hacer esto de una manera mucho más elegante con el módulo nodejs-config ?

Este módulo puede establecer un entorno de configuración basado en el nombre de su computadora. Después de eso, cuando solicite una configuración, obtendrá un valor específico del entorno.

Por ejemplo, supongamos que tiene dos máquinas de desarrollo llamadas pc1 y pc2 y una máquina de producción llamada pc3. Cuando solicite valores de configuración en su código en pc1 o pc2, debe obtener la configuración del entorno de "desarrollo" y en pc3 debe obtener la configuración del entorno de "producción". Esto se puede lograr así:

1. Cree un archivo de configuración base en el directorio config, digamos "app.json" y agregue las configuraciones requeridas.
2. Ahora simplemente cree carpetas dentro del directorio config que coincida con su nombre de entorno, en este caso "desarrollo" y "producción".
3. A continuación, cree los archivos de configuración que desea anular y especifique las opciones para cada entorno en los directorios de entorno (tenga en cuenta que no tiene que especificar todas las opciones que se encuentran en el archivo de configuración base, sino solo las opciones que desea anular). los archivos de configuración del entorno "en cascada" sobre los archivos base.).

Ahora crea una nueva instancia de configuración con la siguiente sintaxis.

var config = require(''nodejs-config'')(
__dirname, // an absolute path to your applications ''config'' directory
{
development: ["pc1", "pc2"],
production: ["pc3"],
}
);

Ahora puede obtener cualquier valor de configuración sin preocuparse por el entorno de esta manera:

config.get(''app'').configurationKey;

Answer 3

La forma en que hacemos esto es pasando un argumento al iniciar la aplicación con el entorno. Por ejemplo:

node app.js -c dev

En app.js, dev.js como nuestro archivo de configuración. Puede analizar estas opciones con optparse-js .

Ahora tiene algunos módulos principales que dependen de este archivo de configuración. Cuando los escribes como tales:

var Workspace = module.exports = function(config) {
if (config) {
// do something;
}
}
(function () {
this.methodOnWorkspace = function () {
};
}).call(Workspace.prototype);

Y puedes llamarlo luego en app.js como:

var Workspace = require("workspace");
this.workspace = new Workspace(config);

Answer 4

Mi solución,

cargar la aplicación usando

NODE_ENV=production node app.js

A continuación, configure config.js como una función en lugar de un objeto

module.exports = function(){
switch(process.env.NODE_ENV){
case ''development'':
return {dev setting};
case ''production'':
return {prod settings};
default:
return {error or other settings};
}
};

Luego, según la solución de Jans, cargue el archivo y cree una nueva instancia que podríamos pasar en un valor si fuera necesario, en este caso process.env.NODE_ENV es global, por lo que no es necesario.

var Config = require(''./conf''),
conf = new Config();

Entonces podemos acceder a las propiedades del objeto config exactamente como antes

conf.twitter.consumerKey

Answer 5

También podría tener un archivo JSON con NODE_ENV como nivel superior. OMI, esta es una mejor manera de expresar configuraciones de configuración (en lugar de usar una secuencia de comandos que devuelve configuraciones).

var config = require(''./env.json'')[process.env.NODE_ENV || ''development''];

Ejemplo para env.json:

{
"development": {
"MONGO_URI": "mongodb://localhost/test",
"MONGO_OPTIONS": { "db": { "safe": true } }
},
"production": {
"MONGO_URI": "mongodb://localhost/production",
"MONGO_OPTIONS": { "db": { "safe": true } }
}
}

Answer 6

Una forma elegante es usar el archivo .env para anular localmente la configuración de producción. No hay necesidad de interruptores de línea de comando. No hay necesidad de todas esas comas y corchetes en un archivo config.json . Ver mi respuesta aquí

Ejemplo: en mi máquina el archivo .env es este:

NODE_ENV=dev
TWITTER_AUTH_TOKEN=something-needed-for-api-calls

Mi .env local anula cualquier variable de entorno. Pero en los servidores de etapas o de producción (tal vez están en heroku.com) las variables de entorno están preconfiguradas en la etapa NODE_ENV=stage o producción NODE_ENV=prod .

Answer 7

Una solución muy útil es usar el módulo de configuración .

después de instalar el módulo:

$ npm install config

Puede crear un archivo de configuración default.json . (Puede usar el objeto JSON o JS con la extensión .json5)

Por ejemplo

$ vi config/default.json
{
"name": "My App Name",
"configPath": "/my/default/path",
"port": 3000
}

Esta configuración predeterminada podría ser reemplazada por el archivo de configuración del entorno o un archivo de configuración local para un entorno de desarrollo local:

production.json podría ser:

{
"configPath": "/my/production/path",
"port": 8080
}

development.json podría ser:

{
"configPath": "/my/development/path",
"port": 8081
}

En su PC local podría tener un local.json que anule todo el entorno, o podría tener una configuración local específica como local-production.json o local-development.json .

La lista completa de orden de carga

Dentro de tu aplicación

En su aplicación, solo necesita requerir config y el atributo necesario.

var conf = require(''config''); // it loads the right file
var login = require(''./lib/everyauthLogin'', {configPath: conf.get(''configPath''));

Cargue la aplicación

carga la aplicación usando:

NODE_ENV=production node app.js

o establecer el entorno correcto con forever o pm2

Siempre:

NODE_ENV=production forever [flags] start app.js [app_flags]

PM2 (a través de shell):

export NODE_ENV=staging
pm2 start app.js

PM2 (vía .json):

process.json

{
"apps" : [{
"name": "My App",
"script": "worker.js",
"env": {
"NODE_ENV": "development",
},
"env_production" : {
"NODE_ENV": "production"
}
}]
}

Y entonces

$ pm2 start process.json --env production

Esta solución es muy limpia y hace que sea fácil configurar diferentes archivos de configuración para el entorno de producción / preparación / desarrollo y también para la configuración local.