Node.js परिनियोजन सेटिंग्स / कॉन्फ़िगरेशन फ़ाइलों को कैसे संग्रहीत करें?

640

मैं कुछ नोड ऐप्स पर काम कर रहा हूं, और मैं तैनाती-संबंधित सेटिंग्स को संग्रहीत करने के अच्छे पैटर्न की तलाश में हूं। Django की दुनिया में (जहां से मैं आता हूं), सामान्य अभ्यास settings.pyमें मानक सेटिंग्स (टाइमज़ोन, आदि) वाली एक फ़ाइल होगी , और फिर local_settings.pyतैनाती के लिए विशिष्ट सेटिंग्स, यानी। किस डेटाबेस से बात करनी है, किस मेमॉकेट सॉकेट में प्रवेश के लिए ई-मेल पता आदि।

मैं नोड के लिए इसी तरह के पैटर्न की तलाश कर रहा हूं। बस एक विन्यास फाइल अच्छी होगी, इसलिए इसमें हर चीज के साथ जाम होने की जरूरत नहीं है app.js, लेकिन मुझे एक फाइल में सर्वर-विशिष्ट कॉन्फ़िगरेशन का एक तरीका होना महत्वपूर्ण है जो स्रोत नियंत्रण में नहीं है। एक ही ऐप को अलग-अलग सर्वरों पर बेतहाशा अलग-अलग सेटिंग्स के साथ तैनात किया जा सकता है, और मर्ज के टकराव से निपटने के लिए और यह सब मेरे विचार से मज़ेदार नहीं है।

तो क्या इसके लिए किसी प्रकार का ढांचा / उपकरण है, या क्या हर कोई बस अपने साथ कुछ न कुछ हैक करता है?

node.js configuration-files

— Mikl
स्रोत

मैं वास्तव में जिस तरह से इसका मतलब में किया जाता है .js । मूल रूप से, वे एप्लिकेशन पर्यावरण प्रति अलग-अलग सेटिंग और एप्लिकेशन वातावरण चर के माध्यम से विशिष्ट विवरण गुजर (उत्पादन, विकास, परीक्षण के लिए) पर आधारित मॉड्यूल की एक seperat प्रकार में एप्लिकेशन प्रासंगिक config की दुकान, रहस्य आदि जैसे,

— हिन्रिच

765

मैं package.jsonअपने पैकेज के लिए और 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, आदि ... यह मैं की सुविधा देता है या तो उपयोग hardcoded पैरामीटर या मापदंडों पर्यावरण चर में संग्रहीत करता है, तो मैं स्रोत नियंत्रण में पासवर्ड स्टोर करने के लिए नहीं करना चाहती।

मैं भी एक उत्पन्न करता हूं 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 में संग्रहित किया गया है, जिसमें मेरे उत्पादन सर्वर के लिए जोड़े गए अवशेष हैं।

— छूईमूई
स्रोत

32

क्या होता है जब आपके पास देव बनाम उत्पादों के लिए अलग-अलग कॉन्फ़िगरेशन सेटिंग्स होती हैं?

— चॉवी

4

मैंने ऐसा नहीं किया है, लेकिन इसे करने का एक तरीका है .. प्रत्येक env के लिए, एक ENV चर में env नाम सेट करें। फिर इस फ़ाइल में, इसकी सिर्फ जावास्क्रिप्ट .. एक मामले का उपयोग करें या यदि कथन उचित चरों को लोड करने के लिए। आप प्रत्येक env के लिए एक अलग कॉन्फ़िग सबफ़ाइल भी बना सकते हैं, और यदि स्टेटमेंट में, यहाँ सबफ़ाइल को एक सबकोन्फ़िग वर्जन में पुनः लोड करते हैं, और उस सब-कॉनफ़िगर वर्जन को मुख्य कॉन्फिगरेशन में एक्सपोर्ट करते हैं .. सभी मैं मूल रूप से यह कहने की कोशिश कर रहा हूँ कि बस js, इसलिए आप क्रिएटिव हो सकते हैं

— noli

4

क्या प्रक्रिया है। यह कहाँ पता चलता है और इसे कैसे सेट करें?

— क्रोधित कीवी

12

मैं सोच रहा था "वाह .. मैं कुछ घंटों के लिए नोड.जेएस को देख रहा हूं और मेरा ऐप पहले से ही काम कर रहा है .. btw, शायद मैं इस यादृच्छिक बिट कोड को साझा करूँगा जो मैं साथ आया था

— noli

3

क्या आप अभी भी उन शब्दों को संग्रहीत करने के लिए पर्यावरण चर का उपयोग नहीं कर सकते हैं? क्या यह रेखा नहीं है: config.twitter.password = process.env.TWITTER_PASSWORD || 'कुंजिका';

— DMart

244

आपको NSON v0.5.x के रूप में JSON फ़ाइलों की आवश्यकता हो सकती है ( इस उत्तर को संदर्भित करते हुए )

config.json:

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

app.js:

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

— TinyTimZamboni
स्रोत

40

उस सुविधा से प्रभावित नहीं हुआ। आपको ("./ config.js") की आवश्यकता हो सकती है और आपको फ़ाइलों को कॉन्फ़िगर करने के लिए टिप्पणियों को जोड़ने की क्षमता मिलती है, जिसे मैं बहुत महत्वपूर्ण मानता हूं, और अन्य घंटियाँ और सीटी। आप config सिर्फ गुण और कोई आप कोड ढीला कुछ भी नहीं की आवश्यकता होती है (config.js) द्वारा आप के साथ JSON द्वारा exports.config = पहले से जुड़ा हुआ है

— teknopaul

3

@teknopaul आप सही कह रहे हैं, लेकिन गूंगा बनाम स्मार्ट टेम्प्लेटिंग सिस्टम के उपयोग की 'शुद्धता' / उपयोगिता के बारे में एक बड़ी चर्चा हुआ करती थी, जिसने मुझे बताया: (1) आप आम तौर पर टेंपरिंग / विकल्पों के लिए एक घोषणापत्र / गूंगा भाषा चाहते हैं। (2) यह एक बुरा विचार है कि एक "लगभग-पीएल" को फिर से संगठित व्यवहार के साथ अपने मौजूदा वास्तविक पीएल को फिर से उपयोग करने के लिए टेंपलेटिंग (या कॉन्फ़िगरेशन) -बटरेट करें। उपयोगकर्ता सेटिंग करने के लिए JS को रीसायकल करने के लिए अभी तक +1; -1 घोषणात्मक दृष्टिकोण के लिए नहीं। हमने कुछ सुंदर जटिल विन्यास सामान देखा है जो कि घोषणात्मक तरीके से किया है; मेरी आंत बताती है कि यह रास्ता है।

— प्रवाह करें

1

VScode (अंत 2017) में json फाइलों से वस्तुओं पर कोई इंटेलीजेंस नहीं है। मॉड्यूल.टेक्स्पोर्ट्स से वस्तुओं के लिए पूरी तरह से काम कर रहा है।

— रोमेन विंसेंट

199

बहुत बाद में, मुझे कॉन्फ़िगरेशन को प्रबंधित करने के लिए एक बहुत अच्छा 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 , विन्यास फाइल लिखने, और एक काफी ठोस एपीआई है, और भी अधिक अच्छी तरह से सम्मान किया Node.js दुकानों में से एक, के द्वारा समर्थित है Nodejitsu के भाग के रूप, Flatiron ढांचा पहल, तो यह होना चाहिए काफी भविष्य के सबूत।

Github पर nconf देखें ।

— Mikl
स्रोत

2

शायद एक गूंगा सवाल है, लेकिन मैंने स्पष्ट स्पष्टीकरण नहीं देखा है: मैं नोड वातावरण चर कहां स्थापित करूं? मैं पहले से ही nconf का उपयोग कर रहा हूं, लेकिन यह स्पष्ट नहीं है कि मैं पर्यावरण चर कहां स्थापित करूंगा। क्या यह नगनेक्स / अपाचे में है? यह एक और विन्यास फाइल है?

— नागरिक

91

मुझे नहीं लगता कि .json फ़ाइल का उपयोग करना एक अच्छा विचार है, क्योंकि टिप्पणियों की अनुमति नहीं है।

— फ्रैंक जू

11

यह बहुत अच्छा लग रहा है। मुझे लगता है कि अगर विन्यास फाइल कमांड-लाइन विकल्प और पर्यावरण चर को ओवरराइड करता है तो आप बहुत सारे यूनिक्स को आश्चर्यचकित करेंगे। हम आरोही पूर्ववर्ती के निम्न क्रम के लिए उपयोग किए जाते हैं: कॉन्फ़िग फ़ाइल (ओं), पर्यावरण चर, कमांड लाइन विकल्प।

— शेल्डन

2

@sheldonh तब तक प्रतीक्षा करें जब तक आपको पता नहीं चलेगा कि बूलियन विकल्प हमेशा argv पर सेट होते हैं , इसलिए पूर्ववर्तीता को तोड़ते हैं ...: /

— डैनियल सी। सोबरल

@ डैनियल.सी.ब्राल यह एक वास्तविक शर्म है। ओह, और LTNS! :-)

— शेल्डन

94

मेरा समाधान काफी सरल है:

पर्यावरण विन्यास को ./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

— chovy
स्रोत

2

मुझे यह पसंद है। जैसा कि दूसरों ने उल्लेख किया है कि JSON एक पसंदीदा भंडारण संरचना नहीं है और ग्लोबल्स के साथ यह लेयरिंग सरल और प्रभावी है

— सेबस्टियन जे।

एकमात्र कारण जो मैं इसे nconf के ऊपर पसंद करूंगा क्योंकि यह .js को कॉन्फिगरेशन (देव, परीक्षण और ठेस) फ़ाइलों के लिए प्रारूप की अनुमति देता है। हमें प्रत्येक कॉन्‍फ़‍िगरेशन विकल्‍प के दस्‍तावेज़ की अनुमति देना जो अन्यथा JSON प्रारूप के साथ संभव नहीं है।

— कुणाल कपाड़िया

BTW, NODE_ENV'विकास' के लिए चूक। आपको इसके बजाय 'प्रोडक्शन' की जांच करनी चाहिए।

— केविन सुतल ने

5

मैं विकास के लिए जाँच नहीं कर रहा हूँ। मैं इसे डिफॉल्ट कर रहा हूं। मुझे यकीन नहीं है कि मैं कभी उत्पादन के लिए डिफ़ॉल्ट क्यों रहूंगा।

— चॉवि

39

आप डॉटनव को भी देख सकते हैं जो एक बारह-कारक ऐप के सिद्धांतों का अनुसरण करता है ।

मैं नोड-कॉन्फिगरेशन का उपयोग करता था, लेकिन उसी कारण से dotenv बनाया। यह पूरी तरह से माणिक की डॉटेनव लाइब्रेरी से प्रेरित था।

उपयोग काफी आसान है:

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

तो फिर तुम सिर्फ एक .env फ़ाइल बनाने के लिए और वहाँ की तरह अपनी सेटिंग्स डाल:

S3_BUCKET=YOURS3BUCKET
SECRET_KEY=YOURSECRETKEYGOESHERE
OTHER_SECRET_STUFF=my_cats_middle_name

वह नोडज के लिए डॉटेनव है।

— scottmotte
स्रोत

2

या बस इसका उपयोग foreman run node xx.jsअपने आप आपके .env फ़ाइल में भी पढ़ जाएगा।

— सिमोन

1

क्या मैं उत्पादन के लिए भी इस दृष्टिकोण का उपयोग करूंगा?

— लामौर

1

@lamar नहीं, आप उन्हें वास्तविक सर्वर पर env चर में सेट करते हैं। हर बार जब आप तैनात होते हैं तो वे वहां होते हैं लेकिन स्रोत कोड में नहीं।

— साइडऑनलाइन

@Lamar हाँ आप वास्तव में सर्वर पर env वैरिएबल सेट करने के लिए एक अधिक पोर्टेबल विकल्प के रूप में कर सकते हैं। महत्वपूर्ण बात करने के लिए है नहीं शामिल .envअपने संस्करण नियंत्रण या तैनाती की प्रक्रिया में फ़ाइल।

— जोश नू

31

क्या आप लोग अपनी स्क्रिप्ट (env आदि) शुरू करने के लिए npm का उपयोग कर रहे हैं?

यदि आप .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 एरिक इलियट को दिया गया है

— LXX
स्रोत

2

क्या आप बता सकते हैं कि "स्रोत" क्या है? मुझे मिलता हैsource : not found

— जॉनीबीज़ल

@JohnnyBizzle source(या बस, .) मौजूदा शेल में दिए गए फ़ाइल से कमांड को पढ़ने और निष्पादित करने के लिए यूनिक्स गोले (बाश, आदि) में एक अंतर्निहित कमांड है । यही है, कमांड्स को सब-शेल में निष्पादित नहीं किया जाता है। इस उदाहरण में इसका प्रभाव यह है कि परिभाषित पर्यावरण चर prod.envको वर्तमान शेल में जोड़ा जाता है और इसलिए, इस शेल द्वारा उत्पन्न किसी भी बाल प्रक्रिया को पारित कर दिया जाता है। आप विंडोज सीएमडी का उपयोग करने लगते हैं। देखें इस सवाल का अधिक जानकारी के लिए।

— उत्कर्ष

वर्थ नोटिंग - 12 फैक्टर ऐप बनाने और न रखने की सलाह देते हैं , लेकिन प्रति तैनाती एक ही फाइल है। dev.envprod.env.env

— Iiridayn

24

आप नोड-कॉन्फ़िगरेशन को भी देख सकते हैं जो $ HOST और $ NODE_ENV चर (RoR की तरह थोड़ा सा): प्रलेखन के आधार पर कॉन्फ़िगरेशन फ़ाइल को लोड करता है ।

यह विभिन्न तैनाती सेटिंग्स ( development, testया production) के लिए काफी उपयोगी हो सकता है ।

— ngryman
स्रोत

22

बस एक सरल के settings.jsसाथ करें exports:

exports.my_password = 'value'

फिर, अपनी स्क्रिप्ट में, एक करें require:

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

आपकी सभी सेटिंग्स अब settingsवैरिएबल के माध्यम से उपलब्ध होंगी :

settings.my_password // 'value'

— Vanuan
स्रोत

@backdesk बेशक आप एक सीक्रेट स्टोरेज सिस्टम सेट कर सकते हैं जो सीक्रेट का इस्तेमाल करेगा और आईपी, कुछ टोकन आदि का उपयोग करके सीक्रेट को सीमित करेगा। लेकिन दिन के अंत में यह सब डिस्क से कुछ फाइलों को पढ़ने के लिए आता है, इसे एनक्रिप्टेड या नहीं।

— वानुअन

@backdesk उदाहरण के साथ कोई समस्या नहीं है। बस यही है: कुछ ठोस समझाने के लिए एक उदाहरण।

— एमिलियो ग्रिसोलिया

14

मैं अपनी टोपी को यहां रिंग में फेंकने जा रहा हूं क्योंकि इनमें से कोई भी जवाब सभी महत्वपूर्ण घटकों को संबोधित नहीं करता है जो कि किसी भी सिस्टम की जरूरत है। बातें:

सार्वजनिक कॉन्फ़िगरेशन (जिसे फ्रंटएंड द्वारा देखा जा सकता है) बनाम निजी कॉन्फ़िगरेशन (आदमी मोग्रेबी को यह एक सही मिला)। और ये सुनिश्चित करना अलग रखा जाता है।
कुंजी की तरह राज
डिफ़ॉल्ट बनाम पर्यावरण-विशिष्ट ओवरराइड्स
ललाट बँधा हुआ

यहां बताया गया है कि मैं अपना कॉन्फ़िगरेशन कैसे करता हूं:

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/- एक फ़ोल्डर जहां प्रत्येक फ़ाइल किसी तरह का एक अलग रहस्य संग्रहीत करती है। यह भी संस्करण नियंत्रण के अंतर्गत नहीं है (चाबियाँ कभी भी संस्करण नियंत्रण के अधीन नहीं होनी चाहिए)।

मैं कॉन्फ़िगरेशन के लिए सादे-पुरानी जावास्क्रिप्ट फ़ाइलों का उपयोग करता हूं, इसलिए मेरे पास जावास्क्रिप्ट लैन्गॉज की पूरी शक्ति है (टिप्पणियों सहित और पर्यावरण-विशिष्ट फ़ाइल में डिफ़ॉल्ट कॉन्फिग फ़ाइल लोड करने की क्षमता है ताकि वे फिर से ओवरराइड हो सकें)। यदि आप पर्यावरण चर का उपयोग करना चाहते हैं, तो आप उन्हें उन कॉन्फिग फाइलों के अंदर लोड कर सकते हैं (जिस पर मैं env vars का उपयोग करने की सलाह देता हूं उसी कारण से मैं json फ़ाइलों का उपयोग करने की सलाह नहीं देता - आपके पास निर्माण करने के लिए प्रोग्रामिंग भाषा की शक्ति नहीं है आपका विन्यास)।

इंस्टॉलर उपयोग के लिए प्रत्येक कुंजी एक अलग फ़ाइल में है। यह आपको एक इंस्टॉलर की अनुमति देता है जो ऑन-मशीन की चाबियाँ बनाता है और उन्हें कुंजी फ़ोल्डर में संग्रहीत करता है। इसके बिना, आपका इंस्टॉलर विफल हो सकता है जब आप अपनी कॉन्फ़िगरेशन फ़ाइल लोड करते हैं जो आपकी कुंजी तक नहीं पहुंच सकती है। इस तरह आप निर्देशिका को पीछे छोड़ सकते हैं और उस फ़ोल्डर में मौजूद किसी भी महत्वपूर्ण फाइल को लोड कर सकते हैं, जो इस बात की चिंता किए बिना है कि आपके कोड के किसी भी संस्करण में क्या मौजूद है और क्या नहीं।

चूंकि आपके पास संभवतः आपके निजी कॉन्फ़िगरेशन में लोड की गई चाबियां हैं, आप निश्चित रूप से किसी भी फ्रंटएंड कोड में अपने निजी कॉन्फ़िगरेशन को लोड नहीं करना चाहते हैं। हालांकि यह संभवतः आपके बैकएंड से आपके फ्रंटेंड कोडबेस को पूरी तरह से अलग करने के लिए कड़ाई से अधिक आदर्श है, पीटा एक बड़ा पर्याप्त अवरोध है जो लोगों को ऐसा करने से रोकता है, इस प्रकार निजी बनाम सार्वजनिक कॉन्फ़िगरेशन। लेकिन दो चीजें हैं जो मैं निजी कॉन्फ़िगरेशन को फ्रंटएंड में लोड होने से रोकने के लिए करता हूं:

मेरे पास एक इकाई परीक्षण है जो यह सुनिश्चित करता है कि मेरे सामने वाले बंडलों में निजी कुंजी में एक गुप्त कुंजी नहीं है।
मेरे बैकएंड कोड से अलग फ़ोल्डर में मेरा फ्रंटएंड कोड है, और मेरे पास "config.js" नाम की दो अलग-अलग फाइलें हैं - प्रत्येक छोर के लिए एक। बैकएंड के लिए, config.js निजी कॉन्फिग को लोड करता है, फ्रंटएंड के लिए, यह पब्लिक कॉन्फिगरेशन को लोड करता है। फिर आपको हमेशा ('config') की आवश्यकता होती है और इस बात की चिंता नहीं करनी चाहिए कि यह कहाँ से आता है।

एक आखिरी बात: आपके कॉन्फ़िगरेशन को आपके किसी अन्य फ्रंटएंड कोड की तुलना में पूरी तरह से अलग फ़ाइल के माध्यम से ब्राउज़र में लोड किया जाना चाहिए । यदि आप अपने फ्रंटेंड कोड को बंडल करते हैं, तो सार्वजनिक कॉन्फ़िगरेशन को पूरी तरह से अलग बंडल के रूप में बनाया जाना चाहिए। अन्यथा, आपका कॉन्फ़िगरेशन वास्तव में अब और कॉन्फ़िगर नहीं है - यह आपके कोड का सिर्फ एक हिस्सा है। विन्यास को विभिन्न मशीनों पर अलग-अलग होने में सक्षम होना चाहिए।

— बीटी
स्रोत

13

रूपांतरण एक अन्य विकल्प है जो सत्यापन के लिए एक स्कीमा जोड़ता है। Nconf की तरह, यह पर्यावरण चर, तर्कों, फ़ाइलों और json ऑब्जेक्ट्स के किसी भी संयोजन से लोडिंग सेटिंग्स का समर्थन करता है।

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

आरंभ लेख: नोड-दोषी के साथ विन्यास विन्यास

— hurrymaplelad
स्रोत

12

आप पर्यावरण विशिष्ट विन्यास फाइल के लिए कोनफिग का उपयोग कर सकते हैं । यह स्वचालित रूप से json या yaml config फाइलों को लोड करता है, इसमें डिफ़ॉल्ट मान और गतिशील कॉन्फ़िगरेशन सुविधाएँ होती हैं।

कोंफिग रेपो से एक उदाहरण:

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

— अली दावुत
स्रोत

9

मैं फ़ाइल नामकरण के रूप में एक फ़ोल्डर बनाऊंगा 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');
    }
});

— रॉन
स्रोत

5

बस npmमॉड्यूल का उपयोग करें config(300000 से अधिक डाउनलोड)

https://www.npmjs.com/package/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

— ऐलेक्स डाईकी
स्रोत

4

'विकास' और 'उत्पादन' विन्यास को अलग करना बेहतर है ।

मैं निम्नलिखित तरीके का उपयोग करता हूं: यहां मेरा 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];

अपनी कॉन्फिग ऑब्जेक्ट का उपयोग कर सकते हैं:

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

— अराम मनुक्यान
स्रोत

भी आप फ़ाइल module.exports = config;के अंत में उपयोगकर्ता कर सकते हैंconfig/index.js

— Mapmalith

3

मुझे खेल में थोड़ी देर हो गई है, लेकिन मुझे यह नहीं मिला कि मुझे यहां क्या चाहिए- या कहीं और - इसलिए मैंने खुद कुछ लिखा।

कॉन्फ़िगरेशन तंत्र के लिए मेरी आवश्यकताएं निम्नलिखित हैं:

फ्रंट-एंड का समर्थन करें। यदि फ्रंट-एंड कॉन्फ़िगरेशन का उपयोग नहीं कर सकता है तो क्या बिंदु है?
समर्थन settings-overrides.js- जो समान दिखता है, लेकिन कॉन्फ़िगरेशन के ओवरराइड की अनुमति देता है settings.js। यहां विचार कोड को बदले बिना कॉन्फ़िगरेशन को आसानी से संशोधित करना है। मुझे यह सास के लिए उपयोगी लगता है।

हालांकि मैं सहायक वातावरणों के बारे में कम परवाह करता हूं - यह बताएगा कि इसे आसानी से मेरे समाधान में कैसे जोड़ा जाए

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 ("/ बैकएंड / कॉन्फिडेंस", आवश्यकता है ("conf")। sendPublicConfiguration);

ओवरराइड का तर्क

PrivateConfiguration को PublicConfiguration और फिर meConf में मिला दिया जाता है।
publicConfiguration प्रत्येक कुंजी की जाँच करता है यदि उसमें एक ओवरराइड है, और उस ओवरराइड का उपयोग करता है। इस तरह हम कुछ भी निजी उजागर नहीं कर रहे हैं।

पर्यावरण का समर्थन जोड़ना

भले ही मुझे "पर्यावरण का समर्थन" उपयोगी नहीं लगता, शायद कोई होगा।

पर्यावरण समर्थन को जोड़ने के लिए आपको meonf को बदलने की आवश्यकता है, कुछ इस तरह से कथन की आवश्यकता है (छद्मकोश)

अगर (पर्यावरण == "उत्पादन") {meConf = की आवश्यकता है ("../ conf / dev / meConf") - उत्पादन। }

अगर (पर्यावरण == "विकास") {meConf = की आवश्यकता है ("../ conf / dev / meConf") - विकास। }

इसी तरह आपके पास प्रति वातावरण फ़ाइल हो सकती है

 meConf.development.js
 meConf.production.js

और सही आयात करें। बाकी सारे तर्क एक जैसे हैं।

— आदमी मोगरीबी
स्रोत

बहुत स्पष्ट नहीं है कि undefinedवास्तव में 'आवश्यक' का nullमतलब है और 'वैकल्पिक' का मतलब है। तो प्लास्टिक के लिए पीला बिन और स्क्रैप पेपर के लिए नीला है? ठीक है, लेकिन उस कूड़े को उछालने से पहले मैनुअल पढ़ना था।

— प्रवाह करें

आपको इस सम्मेलन का उपयोग करने की आवश्यकता नहीं है। मुझे यह उपयोगी लगता है और मैं अपनी टीम को इसका उपयोग करने का निर्देश देता हूं, लेकिन आप स्पष्ट रूप से इस सुविधा को हटा सकते हैं।

— पुरुष मोगरेबी

3

एक ऊपरी उदाहरण जिसका मैंने अभी उपयोग किया है क्योंकि मैं एक विशिष्ट .json फ़ाइल की तुलना में अधिक लचीलापन चाहता था, लेकिन यह नहीं चाहता था कि इसे एक पुस्तकालय में अलग कर दिया जाए जिस पर एक निर्भरता की आवश्यकता होगी, ऐसा कुछ है। मूल रूप से, एक फंक्शन का निर्यात करना तुरंत लागू होता है, जो मेरे द्वारा निर्धारित मूल्यों के साथ एक ऑब्जेक्ट लौटाता है। बहुत लचीलापन देता है।

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

यहां पूर्ण उदाहरण के साथ बहुत बेहतर व्याख्या है। Node.js में कॉन्फ़िग फ़ाइल का उपयोग करना

— captainavi
स्रोत

3

मुझे पता है कि यह बहुत पुरानी पोस्ट है। लेकिन मैं पर्यावरण चर को कॉन्फ़िगर करने के लिए अपने मॉड्यूल को साझा करना चाहता हूं, मुझे लगता है कि यह बहुत लचीला समाधान है। यहाँ मॉड्यूल 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अपने पर्यावरण के लिए सभी चर प्राप्त करने के लिए उपयोग कर सकते हैं ।

— ईसाई
स्रोत

2

के अलावा nconf मॉड्यूल में वर्णित इस जवाब है, और नोड-config में उल्लेख किया है इस सवाल का जवाब है, वहाँ भी कर रहे हैं नोड iniparser और IniReader है, जो सरल .ini विन्यास फाइल पारसर्स दिखाई देते हैं।

— Wingman4l7
स्रोत

विन-इन फ़ाइलों पर वापस जाने का कोई तरीका नहीं ... जो iniparserगर्व से इस तथ्य पर जोर देता है कि वे जानते हैं कि कैसे विन्यास में वर्गों को पार्स करना है ... 2013 में ... यदि आपको गहरी घोंसले के शिकार की आवश्यकता है तो क्या आप कहते हैं [foo/bar]? [foo\bar]? bar.baz=42? bar/baz=42? bar\baz=42? bar:baz=42? आप कैसे बताते हैं 42एक संख्या है? यह एक सभी अंकों का पाठ हो सकता है! - एक्सएमएल XML, टॉस YAML, टॉस Win.INI, JSON को गले लगाओ, चिंताएं दूर हो गईं।

— प्रवाह करें

1

मैंने हाल ही में किसी भी प्रकार की कॉन्फ़िगरेशन फ़ाइलों को लोड करने के लिए एक छोटा मॉड्यूल जारी किया है। यह बहुत सीधा है, आप इसे https://github.com/flesler/config-node पर देख सकते हैं

— एरियल फ़्लेस्लर
स्रोत

1

आप 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

}

— प्रति हेनरिक जेकबसन
स्रोत

1

यहाँ इस लेख से प्रेरित एक स्वच्छ दृष्टिकोण है । यह सर्वव्यापी लॉज पैकेज को छोड़कर किसी भी अतिरिक्त पैकेज की आवश्यकता नहीं है । इसके अलावा, यह आपको पर्यावरण-विशिष्ट ओवरराइट्स के साथ नेस्टेड डिफॉल्ट्स का प्रबंधन करने देता है।

सबसे पहले, पैकेज रूट पथ में एक कॉन्फ़िगरेशन फ़ोल्डर बनाएं जो इस तरह दिखता है

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

अब मान लेते हैं कि हमारे पास एक चूक है

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

और विकास

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

यदि आप config = require('./config')यहाँ हैं तो आपको क्या मिलेगा

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

ध्यान दें कि पर्यावरण-विशिष्ट फ़ाइलों में परिभाषित लोगों को छोड़कर आपको सभी डिफ़ॉल्ट मान मिलते हैं। तो आप एक विन्यास पदानुक्रम का प्रबंधन कर सकते हैं। उपयोग करना defaultsDeepसुनिश्चित करता है कि आप नेस्टेड डिफॉल्ट भी कर सकते हैं।

— राहुल
स्रोत

0

जो लोग इस पुराने धागे को यहां देख रहे हैं, उनके लिए यह एक अच्छा पैकेज है।

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

— वेंकट कोटरा
स्रोत

0

मैंने यहां कुछ सुझाए गए समाधानों की कोशिश की, लेकिन उनसे संतुष्ट नहीं था, इसलिए मैंने अपना मॉड्यूल बनाया। इसे कहा जाता है 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

— मार्टिन एड्मेक
स्रोत

0

लंबे समय तक, मैं यहां समाधान में वर्णित दृष्टिकोण का उपयोग करता था। हालांकि, स्पष्ट पाठ में रहस्यों की सुरक्षा के बारे में एक चिंता है। आप शीर्ष पर एक और पैकेज का उपयोग कर सकते हैं configताकि सुरक्षा बिट्स का ध्यान रखा जाए।

इसे देखें: https://www.attosol.com/secure-application-secrets-use-masterkey-in-azure-key-vault/

— राहुल सोनी
स्रोत

मुझे इस सेवा का भुगतान करने के लिए एज़्योर की सदस्यता भी क्यों लेनी चाहिए? क्यों नहीं ansible- वॉल्ट का उपयोग कर रहे हैं? एक और बात: मुझे लगता है कि कोई भी स्रोत रिपॉजिटरी पर स्पष्ट पाठ क्रेडेंशियल्स के साथ एक कॉन्फ़िगर फ़ाइल पोस्ट नहीं करेगा। या तो पर्यावरण चर का उपयोग करें या इसे केवल पढ़ने की अनुमति वाली फ़ाइल पर अपना गुप्त डेटा डालें।

— यासर सिनाज़ब

यदि आप इसे किसी तीसरे पक्ष के स्थान से पढ़ सकते हैं और इसे डिकोड कर सकते हैं और आपकी सेवा का उपयोग उस शीर्ष गुप्त डेटा का उपयोग कर सकते हैं, तो हैकर के लिए यह संभव हो सकता है कि यदि वे आपके कंप्यूटर तक पहुँच प्राप्त करें तो बिल्कुल वैसा ही करें। यह अधिक काम (अधिक समय लेता है) लेकिन अंत में यह आपकी रक्षा नहीं करता है। यदि आपका सर्वर घुस गया है, तो कल्पना करें कि आपके पास जो कुछ भी है वह अब सार्वजनिक है।

— एलेक्सिस विल्के