Node.js: Cómo configurar diferentes variables para prod y etapas

Question

Estoy usando Express y necesito usar credenciales diferentes para cada servidor (montaje y producción).

Pude configurar las variables en el archivo server.coffee pero luego tendría que acceder a esas variables en diferentes archivos.

server.coffee: 

app.configure 'production',() -> 
app.use express.errorHandler() 

¿Cuál es la solución? Configurar las variables y luego exportarlos?

Answer 1

Si no quiere la lógica para determinar qué configuración usar en cada archivo (que se vería bastante fea), tendrá que exportarla a alguna parte.

Lo que sugeriría: Tener un archivo config.json que contenga las diferentes configuraciones. El archivo principal lo requiere y hace algo como config.default = config.(condition ? 'production':'development'). En todos los demás archivos, ahora puede simplemente hacer require('./config').default.

Answer 2

Tengo una aplicación que utiliza tres métodos diferentes para declarar variables de configuración (uris, claves api, credenciales, etc.) dependiendo del entorno (producción = variables de entorno; etapas = línea de comandos args; archivos locales = config.) escribí un pequeño módulo de "configuración" para manejar la fusión de todas estas opciones en un solo objeto que puedo utilizar en mi aplicación y subido como una esencia: https://gist.github.com/1616583

tal vez no sea la mejor aplicación, pero ha estado trabajando bastante bien hasta ahora :).

Answer 3

./config.js

var development = { 
    appAddress : '127.0.0.1:3000', 
    socketPort : 4000, 
    socketHost : '127.0.0.1', 
    env : global.process.env.NODE_ENV || 'development' 
}; 

var production = { 
    appAddress : 'someDomain.com', 
    socketPort : 4000, 
    socketHost : '8.8.8.8', 
    env : global.process.env.NODE_ENV || 'production' 
}; 

exports.Config = global.process.env.NODE_ENV === 'production' ? production : development; 

./app.js

var cfg = require('./config').Config; 

if (cfg.something) { // switch on environment 
    // your logic 
} 

Answer 4

He subido una implementación en https://github.com/qiangyu/nodejsconfig. Creo que satisfará tus necesidades. Básicamente, sólo es necesario proporcionar un archivo de configuración:

dev.appAddress = '127.0.0.1:3000'; 
prod.appAddress = 'someDomain.com'; 

A continuación, utiliza siguiente código para leer el appAddress en entornos de producción:

var xnconfig = require('nodejsconfig'); 
var fs = require('fs'); 

var data = fs.readFileSync(__dirname+"/config.properties", "UTF8"); 

// assume we will be using environment "prod" 
var config = xnconfig.parse("prod", data); 

// the output will be someDomain.com 
console.log(config.getConfig("appAddress")); 

Answer 5

Este podría ser un buen lugar para utilizar npm-config.

Al ejecutar secuencias de comandos (ver NPM-scripts (7)) package.json las teclas "config" se sobreescriben en el medio ambiente si hay un parámetro de configuración de <name>[@<version>]:<key>

yo no usaría para cada tipo de configuración de configuración variable, pero creo que es una buena solución para casos simples como URL y puertos porque:

1. Los pones directamente en package.json.
2. Además, puede especificarlos en la línea de comando o como variables ENV.
3. Cualquier cosa que se ejecute a través de npm puede hacer referencia a ellos (por ejemplo, scripts).
4. Puede ponerlos por usuario con `NPM config set foo: puerto 80

La única salvedad es que el parámetro config en su package.json solamente se exporta de forma automática en el medio ambiente cuando se ejecuta el código de a través de npm. Por lo tanto, si solo lo ejecuta con un nodo, como, node ./myapp.js, entonces no puede esperar que process.env.npm_package_config_foo contenga su valor. Sin embargo, siempre puede var pkg = require('./package.json'); y acceder a los valores en pkg.config.

Como puede que no sea obvio de inmediato, también agregaría que las variables de entorno npm_package_config no aparecen en las aplicaciones que dependen de su paquete npm. Entonces, si su paquete dependiente se refiere a process.env.npm_package_config_foo, entonces el paquete dependiente debería definir eso en su propio paquete.json. Supongo que dado que es un "npm_package_config", no tendría sentido empujarlos por todo el árbol.

Entonces, ¿cómo usaría una variable de configuración de npm y la haría funcionar en todo el árbol, tanto en el paquete base como en los paquetes que dependen de él? En realidad es un poco confuso, y tuve que resolver esto a través de prueba y error.

Digamos que usted tiene un paquete conector y empaquetar cliente. cliente depende de conector y desea especificar un parámetro de configuración para conector que puede ser utilizado o se sobrescribe en cliente. Si usa process.env.npm_package_config.port en su módulo de conector, cuando depende del módulo cliente, entonces esa variable no se exportará y terminará como indefinido.

Sin embargo, si en lugar de utilizar process.env.npm_config_connector_port (nótese la primera de ellas comienza con npm_package_config y el otro con npm_config_packagename), entonces al menos puede establecer que en su .npmrc usando npm config set connector:port 80 y que será "espacio de nombres" como process.env.npm__config_connector_port todas partes que ejecute MNP, incluyendo secuencias de comandos que se ejecutan en el cliente que dependen de conector, y siempre serás capaz de sobreescribir en la línea de comandos, en su ENV, o en su .npmrc. Solo debes tener en cuenta que, como sucede con cualquier variable de entorno, es posible que no siempre esté configurada. Por lo tanto, me gustaría utilizar el operador por defecto con el process.env.npm_config_connector_port como el primer valor (preferido):

var port = process.env.npm_config_connector_port || sane_default

Aquí, sane_default podría ser poblada desde uno de los otros métodos recomendados. Personalmente, me gusta mantener los datos de configuración como estos en los archivos JSON como mínimo, y package.json parece ser el mejor archivo JSON para colocarlos. Guárdelos en datos en lugar de codificarlos y luego puede usar fácilmente el JSON estático. en línea, generarlos dinámicamente o extraerlos del sistema de archivos, las URL o las bases de datos.