Hoe knooppunt te bewaren.js implementatie-instellingen / configuratiebestanden?

Ik heb gewerkt aan een paar knooppunt-apps, en ik heb op zoek naar een goed patroon van het opslaan van implementatiegerelateerde instellingen. In de Django-wereld (waar ik vandaan kom), zou de gemeenschappelijke praktijk zijn om een ​​settings.pybestand te hebben met de standaardinstellingen (tijdzone, enz.), En dan een local_settings.pyVoor het implementeren van specifieke instellingen, dwz. Met welke database te praten, welke Memcache-aansluiting, e-mailadres voor de beheerders enzovoort.

Ik ben op zoek naar vergelijkbare patronen voor knooppunt. Gewoon een config-bestand zou leuk zijn, dus het hoeft niet vast te zitten met al het andere in app.js, maar ik vind het belangrijk om een ​​manier te hebben om server-specifieke configuratie in een bestand te hebben dat is niet in de broncontrole. Dezelfde app zou goed kunnen worden ingezet in verschillende servers met wild verschillende instellingen en om te gaan met samenvoegconflicten en alles wat niet mijn idee van plezier is.

Dus is er een soort raamwerk / tool, of hakt iedereen gewoon iets samen?

Antwoord 1, Autoriteit 100%

Ik gebruik een package.jsonvoor mijn pakketten en een config.jsvoor mijn configuratie, die eruit ziet:

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;

Ik laad de config uit mijn project:

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

En dan heb ik toegang tot mijn spullen van config.db_host, config.db_port, enz … Hiermee kunt u hardcodeerde parameters gebruiken of parameters die zijn opgeslagen in het milieu Variabelen Als ik geen wachtwoorden in de broncontrole wil opslaan.

Ik genereer ook een package.jsonen plaats een afhankelijkheden sectie:

"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"
}

Wanneer ik het project aan mijn lokale machine klinkt, voer ik npm installom de pakketten te installeren. Meer info over die hier .

Het project wordt opgeslagen in GitHub, met afstandsbedieningen toegevoegd voor mijn productieserver.

Antwoord 2, Autoriteit 32%

U kunt JSON-bestanden vereisen vanaf Node V0.5.x (verwijzen naar dit antwoord )

config.json:

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

app.js:

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

Antwoord 3, Autoriteit 26%

Veel later vond ik een vrij goede Node.js-module voor het beheren van configuratie: nconf .

Een eenvoudig voorbeeld:

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'));

Het ondersteunt ook het opslaan van instellingen in Redis, het schrijven van configuratiebestanden, en heeft een redelijk solide API, en wordt ook ondersteund door een van de meer gerespecteerde Node.js-winkels, Nodejitsu, als onderdeel van de Flatironkaderinitiatief, dus het zou redelijk toekomstbestendig moeten zijn.

Bekijk nconf op Github.

Antwoord 4, autoriteit 13%

Mijn oplossing is vrij eenvoudig:

Laad de omgevingsconfiguratie in ./config/index.js

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

Definieer enkele standaardinstellingen in ./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';

Overschrijf de standaardinstellingen in ./config/config.test.js

var config = require('./config.global');
config.env = 'test';
config.hostname = 'test.example';
config.mongo.db = 'example_test';
module.exports = config;

het gebruiken in ./models/user.js:

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

Uw app in Testomgeving uitvoeren:

NODE_ENV=test node ./app.js

Antwoord 5, Autoriteit 5%

U kunt ook kijken naar dottenv die volgt op de principes van een Twaalf-factor-app .

Ik gebruikte Node-Config, maar maakte Doenv om die reden. Het was volledig geïnspireerd op de DOTENV-bibliotheek van Ruby.

Gebruik is vrij eenvoudig:

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

Maak dan gewoon een .NV-bestand en plaats uw instellingen daar zoals SO:

S3_BUCKET=YOURS3BUCKET
SECRET_KEY=YOURSECRETKEYGOESHERE
OTHER_SECRET_STUFF=my_cats_middle_name

Dat is dottenv voor NODEJS.

Antwoord 6, Autoriteit 4%

Gebruikt u NPM om uw scripts te starten (entc)?

Als u .env-bestanden gebruikt, kunt u ze opnemen in uw package.json
en gebruik NPM naar Bron / Start ze.

Voorbeeld:

{
  "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": "*"
  }
}

voer vervolgens de npm-scripts uit:

$ npm start-dev

Het wordt hier beschreven https://gist.github.com/ericelliott/4152984
Alle eer aan Eric Elliot

Antwoord 7, autoriteit 3%

Je zou ook kunnen kijken naar node-configdie het configuratiebestand laadt afhankelijk van $ HOSTen $NODE_ENVvariabele (een beetje zoals RoR): documentatie.

Dit kan heel handig zijn voor verschillende implementatie-instellingen (development, testof production).

Antwoord 8, autoriteit 3%

Doe gewoon een simpele settings.jsmet exports:

exports.my_password = 'value'

Voer vervolgens in uw script een requireuit:

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

Al uw instellingen zijn nu beschikbaar via de variabele settings:

settings.my_password // 'value'

Antwoord 9, autoriteit 2%

Ik ga hier mijn pet in de ring gooien omdat geen van deze antwoorden alle kritieke componenten adresseert die vrijwel elk systeem nodig heeft. Overwegingen:

• Openbare configuratie (die kan worden bekeken door de frontend) versus privéconfiguratie (guy mograbi heeft deze goed). En ervoor te zorgen dat deze gescheiden worden gehouden.
• Geheimen zoals sleutels
• Standaardinstellingen versus omgevingsspecifieke overschrijvingen
• Frontend-bundels

Zo doe ik mijn configuratie:

• config.default.private.js– In versiebeheer zijn dit standaardconfiguratie-opties die alleen door uw backend kunnen worden gezien.
• config.default.public.js– In versiebeheer zijn dit standaardconfiguratie-opties die kunnen worden bekeken door backend enfrontend
• config.dev.private.js– Als je verschillende privé-standaardinstellingen voor dev nodig hebt.
• config.dev.public.js– Als u verschillende openbare standaardinstellingen nodig heeft voor dev.
• config.private.js– Niet in versiebeheer, dit zijn omgevingsspecifieke opties die config.default.private.js

overschrijven

• config.public.js– Niet in versiebeheer, dit zijn omgevingsspecifieke opties die config.default.public.js

overschrijven

• keys/– Een map waarin elk bestand een ander soort geheim opslaat. Dit valt ook niet onder versiebeheer (sleutels mogen nooit onder versiebeheer staan).

Ik gebruik gewone javascript-bestanden voor configuratie, dus ik heb de volledige kracht van de javascript-taal (inclusief opmerkingen en de mogelijkheid om dingen te doen zoals het standaardconfiguratiebestand in het omgevingsspecifieke bestand laden, zodat ze dan kunnen worden overschreven) . Als je omgevingsvariabelen wilt gebruiken, kun je ze in die configuratiebestanden laden (maar ik raad het gebruik van env-vars af om dezelfde reden dat ik het gebruik van json-bestanden niet aanraad – je hebt niet de kracht van een programmeertaal om te construeren uw configuratie).

De reden waarom elke toets in een apart bestand staat, is voor installateurgebruik. Hiermee kunt u een installateur hebben die toetsen op de machine creëert en opslaat in de map Keys. Zonder dit kan uw installateur falen wanneer u uw configuratiebestand laadt dat geen toegang heeft tot uw sleutels. Op deze manier kunt u de map doorkruisen en elke belangrijke bestanden laden die zich in die map bevinden zonder zich zorgen te hoeven maken over wat er bestaat en wat niet in een bepaalde versie van uw code is.

Aangezien u waarschijnlijk sleutels hebt geladen in uw privéconfiguratie, wilt u absoluut uw privéconfiguratie niet in elke frontend-code laden. Hoewel het waarschijnlijk strikt meer ideaal is om je frontend-codebase volledig van je backend te scheiden, is veel keren dat Pita een grote genoeg barrière is om te voorkomen dat mensen het doen, dus privé vs openbare configuratie. Maar er zijn twee dingen die ik doe om te voorkomen dat privé-configuratie in de frontend wordt geladen:

1. Ik heb een eenheidstest die ervoor zorgt dat mijn frontendebundels geen van de geheime sleutels bevatten die ik in de privé-configuratie heb.
2. Ik heb mijn frontendcode in een andere map dan mijn backend-code, en ik heb twee verschillende bestanden met de naam “config.js” – één voor elk uiteinde. Voor backend, config.js laadt de privéconfiguratie, voor Frontend, het laadt het openbare configuratie. Dan vereisen u altijd (‘config’) en maak je geen zorgen over waar het vandaan komt.

Nog een laatste ding: uw configuratie moet via een volledig in de browser worden geladen dan een van uw andere frontendcode. Als u uw frontendcode bundelt, moet de openbare configuratie worden gebouwd als een volledig afzonderlijke bundel. Anders is uw configuratie niet echt meer – het is slechts een deel van uw code. Config moet anders kunnen zijn op verschillende machines.

Antwoord 10, Autoriteit 2%

Convictis een andere optie die een schema voor validatie toevoegt. Net als nconf ondersteunt het het laden van instellingen van elke combinatie van omgevingsvariabelen, argumenten, bestanden en json-objecten.

Voorbeeld uit de README:

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"
  }
});

Aan de slag artikel:
Configuraties temmen met node-convict

Antwoord 11, autoriteit 2%

Je kunt Konfiggebruiken voor omgevingsspecifieke configuratiebestanden. Het laadt json- of yaml-configuratiebestanden automatisch, het heeft standaardwaarde en dynamische configuratiefuncties.

Een voorbeeld uit de Konfig-repo:

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"
    }
}

In ontwikkeling:

> config.app.port
3000

In productie, neem aan dat we de applicatie starten met $ NODE_ENV=production PORT=4567 node app.js

> config.app.port
4567

Meer details: https://github.com/vngrs/konfig

Antwoord 12

Ik zal een map maken als config en bestandsnaamgeving als config.jsen later zal ik dit bestand gebruiken waar nodig, zoals hieronder

Voorbeeld van config.js

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

Als ik dit configuratiebestand dan ergens wil gebruiken

Ik importeer eerst zoals hieronder

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

en ik heb toegang tot de onderstaande waarden

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');
    }
});

Antwoord 13

Gebruik gewoon npmmodule config(meer dan 300000 downloads)

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

Node-config organiseert hiërarchische configuraties voor uw app-implementaties.

Hiermee kunt u een set standaardparameters definiëren en deze uitbreiden voor verschillende implementatieomgevingen (ontwikkeling, qa, staging, productie, enz.).

$ 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

Antwoord 14

Het is beter om de configuraties ‘ontwikkeling’en ‘productie’te scheiden.

Ik gebruik de volgende manier:
Hier is mijn config/index.js-bestand:

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 : ""
        }
    }
} 

Voor het vereisen van de configuratie gebruikt u het volgende:

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

Dan kunt u uw configuratieobject gebruiken:

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

Antwoord 15

Ik ben een beetje laat in het spel, maar ik kon hier, of ergens anders, niet vinden wat ik nodig had, dus heb ik zelf iets geschreven.

Mijn vereisten voor een configuratiemechanisme zijn de volgende:

1. Ondersteuning front-end. Wat heeft het voor zin als de front-end de configuratie niet kan gebruiken?
2. Ondersteuning van settings-overrides.js– die er hetzelfde uitziet, maar de configuratie op settings.jskan overschrijven. Het idee hier is om de configuratie eenvoudig te wijzigen zonder de code te wijzigen. Ik vind het handig voor saas.

Hoewel ik minder geef om het ondersteunen van omgevingen, zal ik uitleggen hoe ik het gemakkelijk aan mijn oplossing kan toevoegen

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;

Uitleg

• undefinedbetekent dat deze eigenschap vereist is
• nullbetekent dat het optioneel is
• meConf– momenteel is de code bedoeld voor een bestand onder app. meConfis de overschrijft bestanden die zijn gericht op conf/dev– die wordt genegeerd door mijn vcs.
• publicConfiguration– zal zichtbaar zijn vanaf de front-end en back-end.
• privateConfiguration– Zal alleen zichtbaar zijn van back-end.

• sendPublicConfiguration– Een route die de openbare configuratie blootstelt en toewijst aan een globale variabele. De onderstaande code zal bijvoorbeeld de openbare configuratie blootstellen als globale variabele MyConf in de front-end. Standaard gebruikt het de wereldwijde variabele naam conf.

  app.get (“/ backend / conf”, vereisen (“configuratie”). SendPublicConfiguration);

Logica van overschrijvingen

• Privateconfiguratie wordt samengevoegd met publicConfiguratie en vervolgens Meconf.
• PublicConfiguratie controleert elke toets als deze een override heeft, en gebruikt die override. Op deze manier blootstellen we niets privé.

Milieuondersteuning toevoegen

Hoewel ik een “milieu-ondersteuning” nuttig vinden, wil misschien wel iemand.

Om milieuondersteuning toe te voegen, moet u de Meconf wijzigen Vereist verklaring naar zoiets (pseudocode)

if (milieu == “productie”) {
Meconf = vereisen (“../ conf / dev / meconf”). Productie;
}

if (milieu == “ontwikkeling”) {
Meconf = vereisen (“../ conf / dev / meconf”). Ontwikkeling;
}

Evenzo kunt u een bestand per omgeving

hebben

meConf.development.js
 meConf.production.js

en importeer de juiste.
De rest van de logica blijft hetzelfde.

Antwoord 16

Een Alt-voorbeeld die ik net heb gebruikt omdat ik meer flexibiliteit wilde dan een typisch .json-bestand, maar wilde niet dat het weg heeft geabstraheerd in een bibliotheek die een afhankelijkheid zou vereisen, is zoiets. Kortom, het exporteren van een functie die onmiddellijk een object heeft geretourneerd met waarden die ik wilde set. Geeft veel flexibiliteit.

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

Er is hier een veel betere uitleg met het volledige voorbeeld hier. Config-bestanden gebruiken in Node.js

Antwoord 17

Ik weet dat dit een echt oude post is. Maar ik wil mijn module delen voor het configureren van milieuvariabelen, ik denk dat het een zeer flexibele oplossing is.
Hier is de module 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 

Dan kunt u process.env.NODE_ENVgebruiken om alle variabelen voor uw omgeving te krijgen.

Antwoord 18

npm i config
In config/default.json
{
    "app": {
        "port": 3000
    },
    "db": {
        "port": 27017,
        "name": "dev_db_name"
    }
}
In config/production.json
{
    "app": {
        "port": 4000
    },
    "db": {
        "port": 27000,
        "name": "prod_db_name"
    }
}
In index.js
const config = require('config');
let appPort = config.get('app.port');
console.log(`Application port: ${appPort}`);
let dbPort = config.get('db.port');
console.log(`Database port: ${dbPort}`);
let dbName = config.get('db.name');
console.log(`Database name: ${dbName}`);
console.log('NODE_ENV: ' + config.util.getEnv('NODE_ENV'));
$ node index.js
Application port: 3000
Database port: 27017
Database name: dev_db_name
NODE_ENV: development
For production
$ set NODE_ENV=production
$ node index.js
Application port: 4000
Database port: 27000
Database name: prod_db_name
NODE_ENV: production

Antwoord 19

In aanvulling op de nconf-moduledie wordt genoemd in dit antwoorden node-configgenoemd in dit antwoord, daar zijn ook node-iniparseren IniReader, die eenvoudigere parsers van .ini-configuratiebestanden lijken te zijn.

Antwoord 20

Hier is een handige benadering geïnspireerd door dit artikel. Het vereist geen extra pakketten, behalve het alomtegenwoordige lodash-pakket. Bovendien kunt u geneste standaardinstellingen beheren met omgevingsspecifieke overschrijvingen.

Maak eerst een configuratiemap in het rootpad van het pakket die er als volgt uitziet

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

hier is het bestand index.js

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

Laten we nu aannemen dat we een defaults.json hebben zoals zo

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

en development.json vinden dat leuk

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

als je config = require('./config')doet, krijg je dit

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

Merk op dat u alle standaardwaarden krijgt, behalve de waarden die zijn gedefinieerd in omgevingsspecifieke bestanden. U kunt dus een configuratiehiërarchie beheren. Het gebruik van defaultsDeepzorgt ervoor dat je zelfs geneste standaardinstellingen kunt hebben.

Antwoord 21

Een beetje laat (slechts 10 jaar) maar ik gebruik een config.jsdie als volgt is gestructureerd:

const env = process.env.NODE_ENV || 'development';
var config_temp = {
    default:{
        port: 3000,
        mysql_host: "localhost",
        logging_level: 5,
        secret_api_key: process.env.SECRET_API_KEY
    },
    development: {
        logging_level: 10
    },
    production: {
        port: 3001,
        mysql_host: "not-localhost"
    }
};
var config = {
    ...config_temp.default, 
    ...config_temp[env]
}
module.exports = config;

en ik laad de configuratie met:

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

Op deze manier:

• Het lezen van de variabele envis opgenomen in het bestand config.jszodat ik deze lelijkheid kan vermijden: require('./config')[process.env.NODE_ENV || 'development'].
• Het bestand config.jskan worden geüpload in de repo van de code omdat gevoelige variabelen nog steeds worden afgehandeld met process.env.
• Als hetzelfde element in zowel default:{als custom_env:{staat, blijft alleen de tweede behouden.
• Er zijn geen speciale mappen en meerdere bestanden (zoals in config)

Antwoord 22

Ik heb onlangs een kleine module uitgebracht om elk type configuratiebestanden te laden.
Het is vrij eenvoudig, je kunt het controleren op https://github.com/flesler/config-node

Antwoord 23

U kunt pconf gebruiken: https://www.npmjs.com/package/pconf

Voorbeeld:

var Config = require("pconf");
var testConfig = new Config("testConfig");
testConfig.onload = function(){
  testConfig.setValue("test", 1);
  testConfig.getValue("test");
  //testConfig.saveConfig(); Not needed
}

Antwoord 24

Voor degenen die deze oude thread bezoeken, is hier een pakket dat ik goed vind.

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

Antwoord 25

Ik heb hier enkele voorgestelde oplossingen geprobeerd, maar was er niet tevreden over, dus heb ik mijn eigen module gemaakt. Het heet mikro-configen het belangrijkste verschil is dat het de conventie boven de configuratie respecteert, dus je kunt de module gewoon nodig hebben en hem gaan gebruiken.

U slaat uw configuratie op in gewone js- of json-bestanden uit de map /config. Eerst laadt het het bestand default.js, daarna alle andere bestanden uit de map /configen vervolgens laadt het de omgevingsspecifieke configuratie op basis van de variabele $NODE_ENV.

Het maakt het ook mogelijk om deze configuratie te overschrijven voor lokale ontwikkeling met local.jsof omgevingsspecifieke /config/env/$NODE_ENV.local.js.

Je kunt het hier bekijken:

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

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

Antwoord 26

Ik heb lang de benadering gebruikt die hier in de oplossing wordt genoemd. Er is echter bezorgdheid over de beveiliging van de geheimen in gewone tekst. Je kunt een ander pakket gebruiken bovenop configzodat de beveiligingsbits worden afgehandeld.

Controleer dit: https: //www.attosol.com/secure-application-secrets-using-masterKey-in-azure-Key-vault/

Antwoord 27

Hoe we het doen met typescript.

export const loadConfig = () => {
    const configLoadeded = configLoader.util.toObject() as any
    Config = configLoadeded
}
export interface ConfigI {
    productName: string;
    productId: string;
    googleCloudApiKey: string;
}

Antwoord 28

Tegenwoordig, bij het werken met databases, is het de gemakkelijkste om helemaal niet met configuratiebestanden te handelen, omdat de implementatieomgevingen gemakkelijker zijn om te worden opgezet met slechts één enkele omgeving variabele, bel het DB_CONNECTION, voor Voorbeeld en geef het eventuele aanvullende configuratiegegevens door als vereist.

Configuratiegegevens Voorbeeld:

const config = {
    userIds: [1, 2, 3],
    serviceLimit: 100,
    // etc., configuration data of any complexity    
};
// or you can read it from a config file

Maak een verbindingsreeks, met extra parameters waarmee de database-stuurprogramma niet om geeft:

import {ConnectionString} from 'connection-string';
const cs = new ConnectionString('postgres://localhost@dbname', {
    user: 'user-name',
    password: 'my-password',
    params: {
        config
    }  ​
});

Dan kunnen we de resulterende tekenreeks genereren voor het opslaan van het in het milieu:

cs.toString();
//=>postgres://localhost:my-password@dbname?config=%7B%22userIds%22%3A%5B1%2C2%2C3%5D%2C%22serviceLimit%22%3A100%7D

Dus je slaat dit op in je omgeving, laten we zeggen, DB_CONNECTION, en binnen het clientproces kun je het gewoon lezen via process.env.DB_CONNECTION:

const cs = new ConnectionString(process.env.DB_CONNECTION);
const config = JSON.parse(cs.params?.config); // parse extra configuration
//=> { userIds: [ 1, 2, 3 ], serviceLimit: 100 }

Op deze manier heb je zowel de verbinding als alle extra configuratie die nodig is, allemaal binnen een enkele omgevingsvariabele, geen gedoe met configuratiebestanden.