如何存储Node.js部署设置/配置文件？

我一直在开发一些Node应用程序，并且一直在寻找一种存储与部署相关的设置的良好模式。在Django世界（我来自哪里）中，通常的做法是先创建一个settings.py包含标准设置（时区等）的文件，然后创建一个local_settings.py用于部署特定设置的文件。与哪个数据库进行通信，什么Memcache套接字，管理员的电子邮件地址等等。

我一直在寻找Node的类似模式。只需一个配置文件就可以了，因此不必将其与其他所有文件一起使用app.js，但是我发现有一种方法可以在不在源代码管理中的文件中具有服务器特定的配置，这一点很重要。同一应用程序很可能会以完全不同的设置部署在不同的服务器上，并且不得不处理合并冲突，而这并不是我的乐趣所在。

那么，为此是否有某种框架/工具，或者每个人都只是自己一起破解一些东西？

我将a package.json用于我的程序包，并将a config.js用于我的配置，如下所示：

var config = {};

config.twitter = {};
config.redis = {};
config.web = {};

config.default_stuff =  ['red','green','blue','apple','yellow','orange','politics'];
config.twitter.user_name = process.env.TWITTER_USER || 'username';
config.twitter.password=  process.env.TWITTER_PASSWORD || 'password';
config.redis.uri = process.env.DUOSTACK_DB_REDIS;
config.redis.host = 'hostname';
config.redis.port = 6379;
config.web.port = process.env.WEB_PORT || 9980;

module.exports = config;

我从我的项目中加载配置：

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

然后，我可以从config.db_host，config.db_port等等访问我的东西。如果我不想在源代码管理中存储密码，则可以使用硬编码的参数，也可以使用存储在环境变量中的参数。

我还生成一个，package.json并插入一个依赖项部分：

"dependencies": {
  "cradle": "0.5.5",
  "jade": "0.10.4",
  "redis": "0.5.11",
  "socket.io": "0.6.16",
  "twitter-node": "0.0.2",
  "express": "2.2.0"
}

将项目克隆到本地计算机时，我会运行npm install以安装软件包。有关此的更多信息。

该项目存储在GitHub中，并为我的生产服务器添加了遥控器。

从Node v0.5.x起，您可以要求JSON文件（引用此答案）

config.json：

{
    "username" : "root",
    "password" : "foot"
}

app.js：

var config = require('./config.json');
log_in(config.username, config.password);

后来，我找到了一个很好的用于管理配置的Node.js模块：nconf。

一个简单的例子：

var nconf = require('nconf');

// First consider commandline arguments and environment variables, respectively.
nconf.argv().env();

// Then load configuration from a designated file.
nconf.file({ file: 'config.json' });

// Provide default values for settings not provided above.
nconf.defaults({
    'http': {
        'port': 1337
    }
});

// Once this is in place, you can just use nconf.get to get your settings.
// So this would configure `myApp` to listen on port 1337 if the port
// has not been overridden by any of the three configuration inputs
// mentioned above.
myApp.listen(nconf.get('http:port'));

它还支持将设置存储在Redis中，编写配置文件，并具有相当可靠的API，并且作为Flatiron框架计划的一部分，还得到了备受推崇的Node.js商店之一Nodejitsu的支持。相当适合未来。

在Github上查看nconf。

我的解决方案很简单：

在./config/index.js中加载环境配置

var env = process.env.NODE_ENV || 'development'
  , cfg = require('./config.'+env);

module.exports = cfg;

在./config/config.global.js中定义一些默认值

var config = module.exports = {};

config.env = 'development';
config.hostname = 'dev.example.com';

//mongo database
config.mongo = {};
config.mongo.uri = process.env.MONGO_URI || 'localhost';
config.mongo.db = 'example_dev';

覆盖./config/config.test.js中的默认值

var config = require('./config.global');

config.env = 'test';
config.hostname = 'test.example';
config.mongo.db = 'example_test';

module.exports = config;

在./models/user.js中使用它：

var mongoose = require('mongoose')
, cfg = require('../config')
, db = mongoose.createConnection(cfg.mongo.uri, cfg.mongo.db);

在测试环境中运行您的应用程序：

NODE_ENV=test node ./app.js

您可能还希望遵循遵循十二因子应用程序原则的dotenv。

我曾经使用node-config，但是由于这个原因创建了dotenv。它完全受ruby的dotenv库启发。

用法很简单：

var dotenv = require('dotenv');
dotenv.load();

然后，您只需创建一个.env文件，并将您的设置放在其中，如下所示：

S3_BUCKET=YOURS3BUCKET
SECRET_KEY=YOURSECRETKEYGOESHERE
OTHER_SECRET_STUFF=my_cats_middle_name

这是dotenv对的NodeJS。

你们在使用npm启动脚本（env等）吗？

如果您使用.env文件，则可以将其包含在文件中，package.json 并使用npm来获取/启动文件。

例：

{
  "name": "server",
  "version": "0.0.1",
  "private": true,
  "scripts": {
    "start": "node test.js",
    "start-dev": "source dev.env; node test.js",
    "start-prod": "source prod.env; node test.js"
  },
  "dependencies": {
    "mysql": "*"
  }
}

然后运行npm脚本：

$ npm start-dev

它在这里描述https://gist.github.com/ericelliott/4152984 所有归功于Eric Elliot

您可能还希望使用node-config来加载配置文件，具体取决于$ HOST和$ NODE_ENV变量（有点类似于RoR）：documentation。

这可以针对不同的部署设置（相当有用development，test或production）。

只需做一个简单settings.js的exports：

exports.my_password = 'value'

然后，在您的脚本中执行require：

var settings = require('./settings.js');

现在，您所有的设置都将通过settings变量提供：

settings.my_password // 'value'

我将在这里敲响警钟，因为这些答案都无法解决几乎任何系统都需要的所有关键组件。注意事项：

• 公共配置（可以在前端看到）与私有配置（guy mograbi正确理解了这一点）。并确保将它们分开。
• 像钥匙一样的秘密
• 默认值与特定于环境的替代
• 前端捆绑

这是我的配置方法：

• config.default.private.js -在版本控制中，这些是默认配置选项，仅后端可以看到。
• config.default.public.js-在版本控制中，这些是后端和前端可以看到的默认配置选项
• config.dev.private.js -如果您需要不同的开发人员默认默认设置。
• config.dev.public.js -如果您需要开发者使用其他公共默认设置。
• config.private.js -不在版本控制中，这些是特定于环境的选项，将覆盖 config.default.private.js
• config.public.js -不在版本控制中，这些是特定于环境的选项，将覆盖 config.default.public.js
• keys/-每个文件在其中存储不同类型秘密的文件夹。这也不在版本控制下（键永远不要在版本控制下）。

我使用原始的javascript文件进行配置，因此具有javascript语言的全部功能（包括注释以及执行诸如将默认配置文件加载到特定于环境的文件中这样的操作，然后可以将其覆盖）的功能。如果要使用环境变量，可以将它们加载到那些配置文件中（出于与我不建议使用json文件相同的原因，我建议不要使用env vars-您没有编程语言来构建您的配置）。

每个密钥位于单独文件中的原因是供安装程序使用。这样，您就可以拥有一个在计算机上创建密钥并将其存储在keys文件夹中的安装程序。否则，当您加载无法访问密钥的配置文件时，安装程​​序可能会失败。这样，您就可以遍历目录并加载该文件夹中的所有关键文件，而不必担心在任何给定版本的代码中存在和不存在的文件。

由于您可能已在私有配置中加载了密钥，因此您绝对不希望在任何前端代码中加载私有配置。完全将您的前端代码库与后端完全分离可能是更理想的选择，但很多时候PITA足以阻止人们执行PITA，因此是私有配置还是公共配置。但是我有两件事可以防止在前端加载私有配置：

1. 我有一个单元测试，以确保前端捆绑包不包含我在私有配置中拥有的秘密密钥之一。
2. 我的前端代码与后端代码位于不同的文件夹中，并且我有两个名为“ config.js”的文件，每个文件一个。对于后端，config.js加载私有配置，对于前端，config.js加载公共配置。然后，您总是只需要（'config'），而不用担心它的来源。

最后一件事：您的配置应通过与其他任何前端代码完全不同的文件加载到浏览器中。如果捆绑您的前端代码，则公共配置应构建为完全独立的捆绑软件。否则，您的配置不再是真正的配置-它只是代码的一部分。配置必须能够在不同的计算机上不同。

证明有罪是添加验证模式的另一个选项。与nconf一样，它支持从环境变量，参数，文件和json对象的任意组合中加载设置。

自述文件中的示例：

var convict = require('convict');
var conf = convict({
  env: {
    doc: "The applicaton environment.",
    format: ["production", "development", "test"],
    default: "development",
    env: "NODE_ENV"
  },
  ip: {
    doc: "The IP address to bind.",
    format: "ipaddress",
    default: "127.0.0.1",
    env: "IP_ADDRESS",
  },
  port: {
    doc: "The port to bind.",
    format: "port",
    default: 0,
    env: "PORT"
  }
});

入门文章： 使用node-convict驯服配置

您可以将Konfig用于特定于环境的配置文件。它会自动加载json或yaml配置文件，具有默认值和动态配置功能。

Konfig回购中的一个示例：

File: config/app.json
----------------------------
{
    "default": {
        "port": 3000,
        "cache_assets": true,
        "secret_key": "7EHDWHD9W9UW9FBFB949394BWYFG8WE78F"
    },

    "development": {
        "cache_assets": false
    },

    "test": {
        "port": 3001
    },

    "staging": {
        "port": #{process.env.PORT},
        "secret_key": "3F8RRJR30UHERGUH8UERHGIUERHG3987GH8"
    },

    "production": {
        "port": #{process.env.PORT},
        "secret_key": "3F8RRJR30UHERGUH8UERHGIUERHG3987GH8"
    }
}

开发中：

> config.app.port
3000

在生产中，假设我们开始使用 $ NODE_ENV=production PORT=4567 node app.js

> config.app.port
4567

更多详细信息：https : //github.com/vngrs/konfig

我将创建一个文件夹作为配置文件的命名方式config.js，以后将在需要的地方使用此文件，如下所示

config.js示例

module.exports = {
    proxyURL: 'http://url:port',
    TWITTER: {
        consumerkey: 'yourconsumerkey',
        consumerSecrete: 'yourconsumersecrete'
    },
    GOOGLE: {
        consumerkey: 'yourconsumerkey',
        consumerSecrete: 'yourconsumersecrete'
    },
    FACEBOOK: {
        consumerkey: 'yourconsumerkey',
        consumerSecrete: 'yourconsumersecrete'
    }
}

然后，如果我想在某个地方使用此配置文件

我将首先如下导入

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

我可以访问以下值

const oauth = OAuth({
    consumer: {
        key: config.TWITTER.consumerkey,
        secret: config.TWITTER.consumerSecrete
    },
    signature_method: 'HMAC-SHA1',
    hash_function(base_string, key) {
        return crypto.createHmac('sha1', key).update(base_string).digest('base64');
    }
});

只需使用npm模块config（超过30万次下载）

https://www.npmjs.com/package/config

Node-config为您的应用程序部署组织分层配置。

它使您可以定义一组默认参数，并将其扩展为不同的部署环境（开发，质量保证，登台，生产等）。

$ npm install config
$ mkdir config
$ vi config/default.json


{
      // Customer module configs
      "Customer": {
        "dbConfig": {
          "host": "localhost",
          "port": 5984,
          "dbName": "customers"
        },
        "credit": {
          "initialLimit": 100,
          // Set low for development
          "initialDays": 1
        }
      }
}



$ vi config/production.json

{
  "Customer": {
    "dbConfig": {
      "host": "prod-db-server"
    },
    "credit": {
      "initialDays": 30
    }
  }
}



$ vi index.js

var config = require('config');
//...
var dbConfig = config.get('Customer.dbConfig');
db.connect(dbConfig, ...);

if (config.has('optionalFeature.detail')) {
  var detail = config.get('optionalFeature.detail');
  //...
}


$ export NODE_ENV=production
$ node index.js

最好将“开发”和“生产”配置分开。

我使用以下方式：这是我的config / index.js文件：

const config = {
    dev : {
        ip_address : '0.0.0.0',
        port : 8080,
        mongo :{
            url : "mongodb://localhost:27017/story_box_dev",
            options : ""
        }
    },
    prod : {
        ip_address : '0.0.0.0',
        port : 3000,
        mongo :{
            url : "mongodb://localhost:27017/story_box_prod",
            options : ""
        }
    }
} 

对于要求配置，请使用以下命令：

const config = require('../config')[process.env.NODE_ENV];

比起您可以使用的config对象：

const ip_address = config.ip_address;
const port = config.port;

我在游戏中迟到了一点，但在这里或其他任何地方都找不到我需要的东西，所以我自己写了一些东西。

我对配置机制的要求如下：

1. 支持前端。前端不能使用该配置有什么意义？
2. 支持settings-overrides.js-外观相同，但允许覆盖处的配置settings.js。这里的想法是在不更改代码的情况下轻松修改配置。我发现它对saas很有用。

即使我不太在乎支持环境，它也会解释如何轻松地将其添加到我的解决方案中

var publicConfiguration = {
    "title" : "Hello World"
    "demoAuthToken" : undefined, 
    "demoUserId" : undefined, 
    "errorEmail" : null // if null we will not send emails on errors. 

};

var privateConfiguration = {
    "port":9040,
    "adminAuthToken":undefined,
    "adminUserId":undefined
}

var meConf = null;
try{
    meConf = require("../conf/dev/meConf");
}catch( e ) { console.log("meConf does not exist. ignoring.. ")}




var publicConfigurationInitialized = false;
var privateConfigurationInitialized = false;

function getPublicConfiguration(){
    if (!publicConfigurationInitialized) {
        publicConfigurationInitialized = true;
        if (meConf != null) {
            for (var i in publicConfiguration) {
                if (meConf.hasOwnProperty(i)) {
                    publicConfiguration[i] = meConf[i];
                }
            }
        }
    }
    return publicConfiguration;
}


function getPrivateConfiguration(){
    if ( !privateConfigurationInitialized ) {
        privateConfigurationInitialized = true;

        var pubConf = getPublicConfiguration();

        if ( pubConf != null ){
            for ( var j in pubConf ){
                privateConfiguration[j] = pubConf[j];
            }
        }
        if ( meConf != null ){
              for ( var i in meConf ){
                  privateConfiguration[i] = meConf[i];
              }
        }
    }
    return privateConfiguration;

}


exports.sendPublicConfiguration = function( req, res ){
    var name = req.param("name") || "conf";

    res.send( "window." + name + " = " + JSON.stringify(getPublicConfiguration()) + ";");
};


var prConf = getPrivateConfiguration();
if ( prConf != null ){
    for ( var i in prConf ){
        if ( prConf[i] === undefined ){

            throw new Error("undefined configuration [" + i + "]");
        }
        exports[i] = prConf[i];
    }
}


return exports;

说明

• undefined 表示此属性是必需的
• null 表示它是可选的
• meConf-当前代码以app。下的文件为目标。meConf是针对的替代文件conf/dev-我的vcs忽略了这些文件。
• publicConfiguration -在前端和后端均可见。
• privateConfiguration -仅在后端可见。

• sendPublicConfiguration-将公开公共配置并将其分配给全局变量的路由。例如，下面的代码将在前端将公共配置公开为全局变量myConf。默认情况下，它将使用全局变量名称conf。

  app.get（“ / backend / conf”，require（“ conf”）。sendPublicConfiguration）;

替代逻辑

• privateConfiguration与publicConfiguration合并，然后与meConf合并。
• publicConfiguration检查每个键是否有覆盖，并使用该覆盖。这样，我们就不会公开任何私有内容。

添加环境支持

即使我认为“环境支持”没有用，也许有人会这样做。

要添加环境支持，您需要将meConf require语句更改为类似以下内容（伪代码）

if（environment ==“ production”）{meConf = require（“ ../ conf / dev / meConf”）。production; }

if（environment ==“ development”）{meConf = require（“ ../ conf / dev / meConf”）。development; }

同样，您可以在每个环境中拥有一个文件

 meConf.development.js
 meConf.production.js

并导入正确的。其余逻辑保持不变。

我刚刚使用的一个替代示例，是因为我想要比典型的.json文件更大的灵活性，但又不想将其抽象到需要依赖项的库中，就像这样。基本上，导出立即调用的函数，该函数返回具有我想要设置的值的对象。赋予了很大的灵活性。

     module.exports = function(){
       switch(node_env){
         case 'dev':
           return
           { var1 = 'development'};
         }
    }();

这里有一个完整示例的更好解释。在Node.js中使用配置文件

我知道这是一个非常古老的职位。但是我想共享用于配置环境变量的模块，我认为这是非常灵活的解决方案。这是模块json-configurator

var configJson = {
  'baseUrl': 'http://test.com',
  '$prod_baseUrl': 'https://prod.com',
  'endpoints': {
    'users': '<%= baseUrl %>/users',
    'accounts': '<%= baseUrl %>/accounts'
    },
  foo: 'bar',
  foobar: 'foobar',
  $prod_foo: 'foo in prod',
  $test_foo: 'foo in test',
  deep:{
    veryDeep: {
      publicKey: 'abc',
      secret: 'secret',
      $prod_secret: 'super secret'
    }
  }
};

var config = require('json-configurator')(configJson, 'prod');

console.log(config.deep.veryDeep.secret) 
// super secret 

console.log(config.endpoints.users)
// https://prod.com/users 

然后，您可以使用process.env.NODE_ENV获取环境中的所有变量。

除了nconf中模块中提到的这个答案，和节点配置中提到的这个答案，也有节点iniparser和IniReader，这似乎是简单的.ini配置文件分析器。

我刚刚发布了一个小模块，可以加载任何类型的配置文件。这非常简单，您可以在https://github.com/flesler/config-node上进行检查

您可以使用pconf：https ://www.npmjs.com/package/pconf

例：

var Config = require("pconf");
var testConfig = new Config("testConfig");
testConfig.onload = function(){

  testConfig.setValue("test", 1);
  testConfig.getValue("test");
  //testConfig.saveConfig(); Not needed

}

这是一种受本文启发的巧妙方法。除了无处不在的lodash软件包以外，它不需要任何其他软件包。此外，它还允许您使用特定于环境的覆盖来管理嵌套的默认值。

首先，在包根路径中创建一个如下所示的配置文件夹

package
  |_config
      |_ index.js
      |_ defaults.json
      |_ development.json
      |_ test.json
      |_ production.json

这是index.js文件

const _ = require("lodash");
const defaults = require("./defaults.json");
const envConf = require("./" + (process.env.NODE_ENV || "development") + ".json" );
module.exports = _.defaultsDeep(envConf, defaults);

现在假设我们有一个defaults.json像这样

{
  "confKey1": "value1",
  "confKey2": {
    "confKey3": "value3",
    "confKey4": "value4"
  }
}

和development.json像这样

{
  "confKey2": {
    "confKey3": "value10",
  }
}

如果你在config = require('./config')这里做，你会得到

{
  "confKey1": "value1",
  "confKey2": {
    "confKey3": "value10",
    "confKey4": "value4"
  }
}

请注意，除特定于环境的文件中定义的默认值外，您将获得所有默认值。因此，您可以管理配置层次结构。使用defaultsDeep确保您甚至可以拥有嵌套的默认值。

对于那些正在访问旧线程的人来说，这里是一个不错的软件包。

https://www.npmjs.org/package/config

我在这里尝试了一些建议的解决方案，但对它们不满意，因此我创建了自己的模块。叫做mikro-config，主要区别是它遵循约定而不是配置，因此您只需要模块即可开始使用它。

您可以将配置存储在普通js文件/config夹中的json文件中。首先加载default.js文件，然后从/config目录加载所有其他文件，然后基于$NODE_ENV变量加载特定于环境的配置。

它还允许覆盖此配置，以使用local.js或特定于环境的本地开发/config/env/$NODE_ENV.local.js。

您可以在这里查看：

https://www.npmjs.com/package/mikro-config

https://github.com/B4nan/mikro-config

长期以来，我一直使用这里解决方案中提到的方法。但是，对于明文秘密的安全性存在担忧。您可以在之上使用另一个软件包，config以便妥善处理安全位。

检查一下：https : //www.attosol.com/secure-application-secrets-using-masterkey-in-azure-key-vault/