Node.js dağıtım ayarları / yapılandırma dosyaları nasıl saklanır?

Birkaç Düğüm uygulaması üzerinde çalışıyorum ve dağıtımla ilgili ayarları depolamak için iyi bir model arıyordum. Django dünyasında (nereden geldiğim), ortak uygulama,settings.py , standart ayarları (saat dilimi, vb.) İçeren dosyaya ve sonra da local_settings.pydağıtım için belirli ayarlara, yani. hangi veritabanıyla konuşulacak, hangi memcache soketi, yöneticiler için e-posta adresi vb.

Düğüm için benzer desenler arıyordum. Sadece bir yapılandırma dosyası iyi olurdu, bu yüzden içindeki her şeyle sıkışmak zorunda değilsiniz app.js, ancak kaynak kontrolünde olmayan bir dosyada sunucuya özgü yapılandırmaya sahip olmanın bir yolunu buluyorum. Aynı uygulama, çılgınca farklı ayarlara sahip farklı sunucular arasında dağıtılabilir ve birleştirme çatışmalarıyla uğraşmak zorunda kalıyordu ve bu benim eğlenceli fikrim değil.

Peki bunun için bir tür çerçeve / araç var mı, yoksa herkes birlikte bir şeyleri kesmek mi?

Bir kullanmak package.jsonbenim paketleri ve config.jsbenziyor benim yapılandırma için:

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;

Yapılandırmayı projemden yüklüyorum:

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

ve sonra her şeye erişebiliyorum config.db_host,config.db_port vb ... Bu bana kaynak denetiminde şifreleri saklamak istemiyorsanız çevresel değişkenler saklanan ya kullanılması kodlanmış parametreleri veya parametreleri sağlar.

Ayrıca bir oluşturmak package.jsonve bir bağımlılıklar bölümü eklemek:

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

Projeyi yerel makineme klonladığımda npm installpaketleri kurmak için koşuyorum . Burada daha fazla bilgi .

Proje GitHub'da depolanıyor ve üretim sunucum için uzaktan kumandalar ekleniyor.

Düğüm v0.5.x'ten itibaren JSON dosyalarına gereksinim duyabilirsiniz ( bu cevaba referans olarak )

config.json:

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

app.js:

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

Daha sonra, yapılandırmayı yönetmek için oldukça iyi bir Node.js modülü buldum: nconf .

Basit bir örnek:

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

Ayrıca ayarların Redis'te depolanmasını destekler , yapılandırma dosyaları yazar ve oldukça sağlam bir API'ye sahiptir ve ayrıca Flatiron çerçeve girişiminin bir parçası olarak daha saygın Node.js mağazalarından biri olan Nodejitsu tarafından desteklenmektedir , bu yüzden oldukça geleceğe dönük.

Check out Github at nconf .

Benim çözümüm oldukça basit:

Ortam yapılandırmasını ./config/index.js dosyasına yükleyin

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

module.exports = cfg;

./Config/config.global.js'de bazı varsayılanlar tanımlayın

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 içindeki varsayılan değerleri geçersiz kılın

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

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

module.exports = config;

./Models/user.js dosyasında kullanma:

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

Uygulamanızı test ortamında çalıştırma:

NODE_ENV=test node ./app.js

On iki faktörlü bir uygulamanın ilkelerini izleyen dotenv'e de bakabilirsiniz .

Düğüm-config kullanıyordum, ama bu nedenle dotenv oluşturdum. Ruby'nin dotenv kütüphanesinden tamamen ilham aldı.

Kullanımı oldukça kolaydır:

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

Sonra sadece bir .env dosyası oluşturun ve ayarlarınızı buraya yerleştirin:

S3_BUCKET=YOURS3BUCKET
SECRET_KEY=YOURSECRETKEYGOESHERE
OTHER_SECRET_STUFF=my_cats_middle_name

Yani en dotenv nodejs için.

Komut dosyalarınızı başlatmak için npm kullanıyor musunuz (env vb)?

.envDosyaları kullanırsanız, dosyalarınıza dahil edebilir package.json ve kaynak / başlatmak için npm kullanabilirsiniz.

Misal:

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

sonra npm komut dosyalarını çalıştırın:

$ npm start-dev

Burada açıklanan https://gist.github.com/ericelliott/4152984 Eric Elliot'a verilen tüm kredi

$ HOST ve $ NODE_ENV değişkenine (biraz RoR gibi) bağlı olarak yapılandırma dosyasını yükleyen düğüm yapılandırmasına da bakabilirsiniz : belgeler .

Bu, farklı dağıtım ayarlarında (oldukça yararlı olabilir development, testya da production).

Sadece bir basit yapmak settings.jsile exports:

exports.my_password = 'value'

Ardından, komut dosyanızda requireşunları yapın:

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

Artık tüm ayarlarınız settingsdeğişken üzerinden sağlanacaktır :

settings.my_password // 'value'

Şapkamı burada yüzüğe atacağım çünkü bu cevapların hiçbiri herhangi bir sistemin ihtiyaç duyduğu tüm kritik bileşenlere hitap etmiyor. hususlar:

• Genel yapılandırma (ön uç tarafından görülebilir) ve özel yapılandırma (guy mograbi bunu doğru yaptı). Ve bunların ayrı tutulmasını sağlamak.
• Anahtarlar gibi sırlar
• Varsayılanlar ve çevreye özgü geçersiz kılmalar
• Ön uç paketleri

Yapılandırmamı şu şekilde yapıyorum:

• config.default.private.js - Sürüm kontrolünde, bunlar yalnızca arka uç tarafından görülebilen varsayılan yapılandırma seçenekleridir.
• config.default.public.js- Sürüm kontrolünde, bunlar arka uç ve ön uç tarafından görülebilen varsayılan yapılandırma seçenekleridir
• config.dev.private.js - Dev için farklı özel varsayılanlara ihtiyacınız varsa.
• config.dev.public.js - Geliştirme için farklı genel varsayılanlara ihtiyacınız varsa.
• config.private.js - Sürüm kontrolünde değil, bunlar geçersiz kılan ortama özgü seçenekler config.default.private.js
• config.public.js - Sürüm kontrolünde değil, bunlar geçersiz kılan ortama özgü seçenekler config.default.public.js
• keys/- Her dosyanın bir tür farklı bir sır sakladığı klasör. Bu aynı zamanda sürüm kontrolü altında değildir (anahtarlar asla sürüm kontrolü altında olmamalıdır).

Ben javascript dilinin tam gücüne sahip olmak için yapılandırma için düz eski javascript dosyaları kullanın (yorumlar ve daha sonra geçersiz kılınabilmesi için çevreye özgü dosyaya varsayılan yapılandırma dosyasını yüklemek gibi şeyler yapma yeteneği dahil). Ortam değişkenlerini kullanmak istiyorsanız, bu yapılandırma dosyalarının içine yükleyebilirsiniz (env değişkenlerini kullanmamaya karşı öneriyorum. Aynı sebepten dolayı json dosyalarını kullanmanızı önermiyorum - inşa etmek için bir programlama dilinin gücü yok yapılandırma).

Her anahtarın ayrı bir dosyada olmasının nedeni yükleyici kullanımı içindir. Bu, makinede anahtarlar oluşturan ve anahtarlar klasöründe saklayan bir yükleyiciye sahip olmanızı sağlar. Bu olmadan, anahtarlarınıza erişemeyen yapılandırma dosyanızı yüklediğinizde yükleyiciniz başarısız olabilir. Bu şekilde, kodunuzun belirli bir sürümünde var olan ve olmayanlar hakkında endişelenmenize gerek kalmadan dizinde gezinebilir ve o klasördeki tüm anahtar dosyalarını yükleyebilirsiniz.

Muhtemelen özel yapılandırmada yüklü anahtarları olduğundan, kesinlikle herhangi önyüz kodunda özel yapılandırma yüklemek istemiyoruz. Ön uç kod tabanınızı arka ucunuzdan tamamen ayırmak muhtemelen daha ideal olsa da, çoğu zaman PITA, insanların bunu yapmasını önlemek için yeterince büyük bir engeldir, bu nedenle özel ve genel yapılandırma. Ancak özel yapılandırmanın ön uçta yüklenmesini önlemek için iki şey yapıyorum:

1. Ön uç paketlerimin özel yapılandırmada sahip olduğum gizli anahtarlardan birini içermemesini sağlayan bir birim testim var.
2. Ön uç kodumu arka uç kodumdan farklı bir klasörde var ve "config.js" adlı iki farklı dosyam var - her bir uç için bir tane. Arka uç için config.js özel yapılandırmayı, ön uç için genel yapılandırmayı yükler. O zaman her zaman sadece ('config') gerekir ve nereden geldiğini düşünmeyin.

Son bir şey: yapılandırmanız tarayıcıya diğer ön uç kodlarınızdan herhangi birinden tamamen ayrı bir dosya aracılığıyla yüklenmelidir . Ön uç kodunuzu bir araya getirirseniz, genel yapılandırma tamamen ayrı bir paket olarak oluşturulmalıdır. Aksi halde, yapılandırmanız artık gerçekte yapılandırılmış değildir - kodunuzun sadece bir parçasıdır. Config'in farklı makinelerde farklı olabilmesi gerekir.

Hükümlü , doğrulama için bir şema ekleyen başka bir seçenektir. Nconf gibi, ortam değişkenleri, bağımsız değişkenler, dosyalar ve json nesnelerinin herhangi bir kombinasyonundan yükleme ayarlarını destekler.

README'den bir örnek:

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

Başlangıç ​​makalesi: Düğüm hükümlü ile Yapılandırmaları Taming

Konfig'yi ortama özgü yapılandırma dosyaları için kullanabilirsiniz . Json veya yaml yapılandırma dosyalarını otomatik olarak yükler, varsayılan değer ve dinamik yapılandırma özelliklerine sahiptir.

Konfig deposundan bir örnek:

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

Geliştirilmekte:

> config.app.port
3000

Üretimde, $ NODE_ENV=production PORT=4567 node app.js

> config.app.port
4567

Daha fazla detay: https://github.com/vngrs/konfig

Yapılandırma olarak bir dosya adlandırması olarak bir klasör oluşturacağım config.jsve daha sonra bu dosyayı aşağıdaki gibi gerekli yerlerde kullanacağım

Config.js örneği

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

Sonra bu yapılandırma dosyasını bir yerde kullanmak istersem

İlk önce aşağıdaki gibi içe aktarım

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

ve değerlere aşağıdaki gibi erişebilirim

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

Sadece npmmodülü kullanın config(300000'den fazla indirme)

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

Node-config, uygulama dağıtımlarınız için hiyerarşik yapılandırmaları düzenler.

Bir dizi varsayılan parametre tanımlamanıza ve bunları farklı dağıtım ortamları (geliştirme, qa, evreleme, üretim vb.) İçin genişletmenize olanak tanır.

$ 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

'Geliştirme' ve 'üretim' yapılandırmalarını ayırmak daha iyidir .

Aşağıdaki yolu kullanıyorum: İşte benim config / index.js dosya:

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

Yapılandırma gerektiren için aşağıdakileri kullanın:

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

Daha sonra yapılandırma nesnenizi kullanabilirsiniz:

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

Oyuna biraz geç kaldım, ama burada ya da başka bir yerde ihtiyacım olanı bulamadım, bu yüzden kendime bir şey yazdım.

Bir yapılandırma mekanizması için gereksinimlerim şunlardır:

1. Ön uç desteği. Kullanıcı arabirimi yapılandırmayı kullanamıyorsa bunun anlamı nedir?
2. Destek settings-overrides.js- aynı görünüyor ancak adresindeki yapılandırmanın geçersiz kılınmasına izin veriyor settings.js. Buradaki fikir, kodu değiştirmeden yapılandırmayı kolayca değiştirmektir. Saas için faydalı buluyorum.

Destekleyici ortamları daha az önemsememe rağmen - bunu çözümüme nasıl kolayca ekleyeceğimizi açıklayacağım

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;

açıklama

• undefined bu mülkün gerekli olduğu anlamına gelir
• null isteğe bağlı olduğu anlamına gelir
• meConf- şu anda kod, altındaki bir dosyayı hedefliyor app. vcs tarafından yok sayılan meConf, hedeflenen dosyaları geçersiz kılar conf/dev.
• publicConfiguration - ön uçtan ve arka uçtan görülebilir.
• privateConfiguration - yalnızca arka uçtan görülebilir.

• sendPublicConfiguration- genel yapılandırmayı açığa çıkaracak ve genel bir değişkene atayacak bir rota. Örneğin, aşağıdaki kod genel yapılandırmayı ön uçta genel değişkenim myConf olarak gösterecektir. Varsayılan olarak genel değişken adını kullanır conf.

  app.get ("/ arka uç / conf", gerektirir ("conf"). sendPublicConfiguration);

Geçersiz kılma mantığı

• privateConfiguration, publicConfiguration ve ardından meConf ile birleştirilir.
• publicConfiguration, bir geçersiz kılma varsa her anahtarı denetler ve bu geçersiz kılmayı kullanır. Bu şekilde özel bir şey ortaya çıkarmıyoruz.

Çevre desteği ekleme

"Çevre desteği" ni yararlı bulmasam da, belki birisi bunu yapar.

Ortam desteği eklemek için, meConf Require deyimini böyle bir şeye değiştirmelisiniz (sözde kod)

if (çevre == "üretim") {meConf = zorunludur ("../ conf / dev / meConf"). üretim; }

if (çevre == "geliştirme") {meConf = gerektirir ("../ conf / dev / meConf"). geliştirme; }

Benzer şekilde, ortam başına bir dosyaya sahip olabilirsiniz

 meConf.development.js
 meConf.production.js

ve doğru olanı içe aktarın. Mantığın geri kalanı aynı kalır.

Sadece kullandığım alt bir örnek çünkü tipik bir .json dosyasından daha fazla esneklik istedim ama bağımlılık gerektiren bir kütüphaneye çekilmesini istemedim böyle bir şey. Temel olarak, ayarlamak istediğim değerlere sahip bir nesneyi döndüren bir işlevi derhal çağırdı. Çok esneklik sağlar.

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

Burada tam örnekle çok daha iyi bir açıklama var. Node.js'de Config Dosyalarını Kullanma

Bunun gerçekten eski bir yazı olduğunu biliyorum. Ancak ortam değişkenlerini yapılandırmak için modülümü paylaşmak istiyorum, bence çok esnek bir çözüm. İşte modül json-yapılandırıcı

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 

Sonra process.env.NODE_ENVortamınız için tüm değişkenleri almak için kullanabilirsiniz .

Ek olarak nconf modülünde belirtilen bu cevap ve düğüm-yapılandırmasına belirtilen bu cevap , de vardır düğüm-iniparser ve IniReader basit .ini yapılandırma dosyası ayrıştırıcıları gibi görünen.

Kısa bir süre önce, her tür yapılandırma dosyasını yüklemek için küçük bir modül yayınladım. Oldukça basittir, https://github.com/flesler/config-node adresinden kontrol edebilirsiniz.

Pconf kullanabilirsiniz: https://www.npmjs.com/package/pconf

Misal:

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

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

}

İşte bu makaleden esinlenilmiş düzgün bir yaklaşım . Her yerde bulunan lodash paketi dışında herhangi bir ek paket gerektirmez . Ayrıca, yuvaya özgü varsayılanları ortama özgü üzerine yazma işlemleriyle yönetmenizi sağlar.

İlk olarak, paket kök yolunda şöyle görünen bir yapılandırma klasörü oluşturun

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

İşte index.js dosyası

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

Şimdi bir varsayılanımız olduğunu varsayalım.

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

ve development.json böyle

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

bunu yaparsanız config = require('./config')burada alırsınız budur

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

Ortama özgü dosyalarda tanımlananlar dışındaki tüm varsayılan değerleri aldığınıza dikkat edin. Böylece bir yapılandırma hiyerarşisini yönetebilirsiniz. Kullanmak defaultsDeepiç içe geçmiş varsayılanlara bile sahip olmanızı sağlar.

Bu eski ipliği ziyaret edenler için burada iyi bulduğum bir paket.

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

Burada önerilen çözümlerden bazılarını denedim, ancak onlardan memnun kalmadım, bu yüzden kendi modülümü oluşturdum. Denirmikro-config ve ana fark, konfigürasyon üzerinde konvansiyonu onurlandırmasıdır, böylece sadece modüle ihtiyaç duyabilir ve kullanmaya başlayabilirsiniz.

Yapılandırmanızı düz js veya /configklasördeki json dosyalarında depolarsınız . Önce default.jsdosyayı, sonra /configdizindeki diğer tüm dosyaları , daha sonra$NODE_ENV değişkene .

Ayrıca, yerel yapılandırmayla local.jsveya ortama özgü yerel yapılandırma için bu yapılandırmanın geçersiz kılınmasına izin verir/config/env/$NODE_ENV.local.js .

Buradan bakabilirsiniz:

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

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

Uzun zamandır, buradaki çözümde bahsedilen yaklaşımı kullanırdım. Bununla birlikte, açık metinlerde sırların güvenliği ile ilgili bir endişe vardır. configGüvenlik bitlerinin üstesinden gelmek için üstte başka bir paket kullanabilirsiniz .

Şuna bir göz atın: https://www.attosol.com/secure-application-secrets-using-masterkey-in-azure-key-vault/