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




configuration-files (14)

आप dotenv को भी देख सकते हैं जो बारह-कारक ऐप के सिद्धांतों का पालन करता है।

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

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

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

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

S3_BUCKET=YOURS3BUCKET
SECRET_KEY=YOURSECRETKEYGOESHERE
OTHER_SECRET_STUFF=my_cats_middle_name

यह dotenv लिए dotenv है।

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

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

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


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

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


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

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

विकास में:

> config.app.port
3000

उत्पादन में, मान लें कि हम $ NODE_ENV=production PORT=4567 node app.js साथ आवेदन शुरू $ NODE_ENV=production PORT=4567 node app.js

> config.app.port
4567

अधिक जानकारी: Konfig


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

config.json:

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

app.js:

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

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

यदि आप .env फ़ाइलों का उपयोग करते हैं तो आप उन्हें अपने .env में शामिल कर सकते हैं और स्रोत के लिए एनपीएम का उपयोग कर सकते हैं / उन्हें शुरू कर सकते हैं।

उदाहरण:

{
  "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 start-dev

यहां वर्णन किया गया है https://gist.github.com/ericelliott/4152984 एरिक इलियट के लिए सभी क्रेडिट


जो लोग इस पुराने धागे पर जा रहे हैं उनके लिए एक पैकेज है जो मुझे अच्छा लगता है।

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


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


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

पर्यावरण कॉन्फ़िगरेशन को ./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

यह यहां अधिक विस्तार से समझाया गया है: http://www.chovy.com/node-js/managing-config-variables-inside-a-node-js-application/


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

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

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

  • config.default.private.js - संस्करण नियंत्रण में, ये डिफ़ॉल्ट कॉन्फ़िगरेशन विकल्प हैं जो केवल आपके बैकएंड द्वारा देखे जा सकते हैं।
  • config.default.public.js - संस्करण नियंत्रण में, ये डिफ़ॉल्ट कॉन्फ़िगरेशन विकल्प हैं जिन्हें बैकएंड और फ्रंटेंड द्वारा देखा जा सकता है
  • config.dev.private.js - यदि आपको देव के लिए अलग-अलग निजी डिफ़ॉल्ट की आवश्यकता है।
  • config.dev.public.js - यदि आपको dev के लिए अलग-अलग सार्वजनिक डिफ़ॉल्ट की आवश्यकता है।
  • config.private.js - संस्करण नियंत्रण में नहीं, ये पर्यावरण विशिष्ट विकल्प हैं जो config.default.private.js ओवरराइड करते हैं
  • config.public.js - संस्करण नियंत्रण में नहीं, ये पर्यावरण विशिष्ट विकल्प हैं जो config.default.public.js ओवरराइड करते हैं
  • keys/ - एक फ़ोल्डर जहां प्रत्येक फ़ाइल किसी प्रकार का एक अलग रहस्य संग्रहीत करती है। यह संस्करण नियंत्रण के तहत भी नहीं है (कुंजी को संस्करण नियंत्रण में कभी नहीं होना चाहिए)।

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

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

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

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

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


मैं अपने संकुल के लिए एक config.js और मेरी कॉन्फ़िगरेशन के लिए 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 भी उत्पन्न करता हूं और एक निर्भरता अनुभाग 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 लिए npm install हूं। उस पर अधिक जानकारी।

परियोजना को मेरे उत्पादन सर्वर के लिए जोड़े गए रिमोट के साथ गिटहब में संग्रहीत किया जाता है।


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

आप अपनी विन्यास को सादे जेएस, या जेएसओ फाइलों में /config फ़ोल्डर से स्टोर करते हैं। सबसे पहले यह default.js फ़ाइल लोड करता है, फिर /config निर्देशिका से अन्य सभी फाइलें, फिर यह $NODE_ENV चर के आधार पर पर्यावरण विशिष्ट कॉन्फ़िगरेशन लोड करता है।

यह local.js लिए इस कॉन्फ़िगरेशन को local.js या पर्यावरण विशिष्ट /config/env/$NODE_ENV.local.js साथ ओवरराइड करने की अनुमति देता है।

आप इसे यहां देख सकते हैं:

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

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


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



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

रीडमे से उदाहरण:

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

प्रारंभ करना लेख: नोड-अपराधी के साथ विन्यास विन्यास







configuration-files