从 nodejs 到 mongodb 或 mongoose 的动态数据库连接 [英] Dynamic database connection to mongodb or mongoose from nodejs
问题描述
我正在尝试创建一个多租户应用 (saas)，其中每个客户端都有自己的数据库.
I am trying to create a multi-tenant app (saas), where each client has its own database.
我的情况是:
我创建了一个中间件，可以根据子域确定客户端是谁，然后从通用数据库中检索客户端的数据库连接信息.我不知道如何为这个客户端建立一个连接对象，以便能够在我的控制器中使用.我应该在中间件中还是在控制器中执行此操作?如果它在模型中，我如何传递连接字符串和参数(我可以使用会话，但我不知道如何从模型内部访问会话).
I created a middleware that would determine who the client is based on a subdomain, then retrieve the client's database connection info from a general database. I don't know how to establish a connection object for this client so as to be able to use in my controllers. And should I do this in the middleware or in a controller? And if it's in the model, how do i pass the connection string and parameters (I could use session, but I don't know how to access session from within model).
我该怎么做?
- 组织:在哪里为客户端动态创建数据库连接?
- 将连接参数注入/传递到控制器或模型(在其中进行连接定义)
- 建立动态连接后，我如何为该客户端全局访问它?
这是我的中间件的一个例子，我想创建一个猫鼬连接，我想让它动态化(传入客户端的连接信息):
This is an example of my middleware, and i would like to create a mongoose connection which i would like to make dynamic (pass in client's connection info):
function clientlistener() {
return function (req, res, next) {
console.dir('look at my sub domain ' + req.subdomains[0]);
// console.log(req.session.Client.name);
if (req.session.Client && req.session.Client.name === req.subdomains[0]) {
var options = session.Client.options;
var url = session.Client.url
var conn = mongoose.createConnection(url, options);
next();
}
}
}
如何从控制器内部访问此连接对象?还是来自模型?
How do I access this connection object from inside the controller? Or from the model?
谢谢.
推荐答案
这是为了帮助可能与我遇到类似情况的其他人.我希望它可以标准化.我不认为每次有人需要开发多租户应用程序时，我们都应该重新发明轮子.
This is to help others who may find themselves in similar situation as I did. I hope that it could be standardized. I dont think we should have to reinvent the wheel every time someone needs to make a multi-tenant application.
这个例子描述了一个多租户结构，每个客户端都有自己的数据库.就像我说的，可能有更好的方法来做这件事，但因为我自己没有得到帮助，所以这是我的解决方案.
This example describes a multi-tenant structure with each client having its own database. Like i said there might be a better way of doing this, but because i didn't get help myself, this was my solution.
以下是此解决方案的目标:
So here are the goals this solution targets:
- 每个客户端都由子域标识，例如 client1.application.com，
- 应用程序检查子域是否有效，
- 应用程序从主数据库中查找并获取连接信息(数据库 URL、凭据等)，
- 应用程序连接到客户端数据库(几乎交给客户端)，
- 应用程序采取措施确保完整性和资源管理(例如，为同一客户端的成员使用相同的数据库连接，而不是建立新的连接).
在你的 app.js 文件中
app.use(clientListener()); // checks and identify valid clients
app.use(setclientdb());// sets db for valid clients
我创建了两个中间件:
clientListener- 识别客户端连接，setclientdb- 从 Master 数据库中获取客户端详细信息，识别客户端后，然后建立与客户端数据库的连接.
clientListener- to identify the client connecting,setclientdb- gets client details from Master database, after client is identified, and then establishes connection to client database.
我通过检查请求对象的子域来检查客户是谁.我做了一堆检查以确保客户端有效(我知道代码很乱，可以做得更干净).确保客户端有效后，我将客户端信息存储在会话中.我还检查客户端信息是否已存储在会话中，则无需再次查询数据库.我们只需要确保请求子域与已存储在会话中的子域相匹配.
I check who the client is by checking the subdomain from the request object. I do a bunch of checks to be sure the client is valid (I know the code is messy, and can be made cleaner). After ensuring the client is valid, I store the clients info in session. I also check that if the clients info is already stored in session, there is no need to query the database again. We just need to make sure that the request subdomain, matches that which is already stored in session.
var Clients = require('../models/clients');
var basedomain = dbConfig.baseDomain;
var allowedSubs = {'admin':true, 'www':true };
allowedSubs[basedomain] = true;
function clientlistener() {
return function(req, res, next) {
//console.dir('look at my sub domain ' + req.subdomains[0]);
// console.log(req.session.Client.name);
if( req.subdomains[0] in allowedSubs || typeof req.subdomains[0] === 'undefined' || req.session.Client && req.session.Client.name === req.subdomains[0] ){
//console.dir('look at the sub domain ' + req.subdomains[0]);
//console.dir('testing Session ' + req.session.Client);
console.log('did not search database for '+ req.subdomains[0]);
//console.log(JSON.stringify(req.session.Client, null, 4));
next();
}
else{
Clients.findOne({subdomain: req.subdomains[0]}, function (err, client) {
if(!err){
if(!client){
//res.send(client);
res.send(403, 'Sorry! you cant see that.');
}
else{
console.log('searched database for '+ req.subdomains[0]);
//console.log(JSON.stringify(client, null, 4));
//console.log(client);
// req.session.tester = "moyo cow";
req.session.Client = client;
return next();
}
}
else{
console.log(err);
return next(err)
}
});
}
}
}
module.exports = clientlistener;
setclientdb 中间件:
我再次检查所有内容以确保客户端有效.然后使用从会话中检索到的信息打开与客户端数据库的连接.
setclientdb middleware:
I check everything again making sure that the client is valid. Then the connection to the client's database with the info retrieved from session is opened.
我还确保将所有活动连接存储到一个全局对象中，以防止在每次请求时新连接到数据库(我们不希望每个客户端的 mongodb 服务器连接过载).
I also make sure to store all active connections into a global object, so as to prevent new connections to the database upon each request(we don't want to overload each clients mongodb server with connections).
var mongoose = require('mongoose');
//var dynamicConnection = require('../models/dynamicMongoose');
function setclientdb() {
return function(req, res, next){
//check if client has an existing db connection /*** Check if client db is connected and pooled *****/
if(/*typeof global.App.clientdbconn === 'undefined' && */ typeof(req.session.Client) !== 'undefined' && global.App.clients[req.session.Client.name] !== req.subdomains[0])
{
//check if client session, matches current client if it matches, establish new connection for client
if(req.session.Client && req.session.Client.name === req.subdomains[0] )
{
console.log('setting db for client ' + req.subdomains[0]+ ' and '+ req.session.Client.dbUrl);
client = mongoose.createConnection(req.session.Client.dbUrl /*, dbconfigoptions*/);
client.on('connected', function () {
console.log('Mongoose default connection open to ' + req.session.Client.name);
});
// When the connection is disconnected
client.on('disconnected', function () {
console.log('Mongoose '+ req.session.Client.name +' connection disconnected');
});
// If the Node process ends, close the Mongoose connection
process.on('SIGINT', function() {
client.close(function () {
console.log(req.session.Client.name +' connection disconnected through app termination');
process.exit(0);
});
});
//If pool has not been created, create it and Add new connection to the pool and set it as active connection
if(typeof(global.App.clients) === 'undefined' || typeof(global.App.clients[req.session.Client.name]) === 'undefined' && typeof(global.App.clientdbconn[req.session.Client.name]) === 'undefined')
{
clientname = req.session.Client.name;
global.App.clients[clientname] = req.session.Client.name;// Store name of client in the global clients array
activedb = global.App.clientdbconn[clientname] = client; //Store connection in the global connection array
console.log('I am now in the list of active clients ' + global.App.clients[clientname]);
}
global.App.activdb = activedb;
console.log('client connection established, and saved ' + req.session.Client.name);
next();
}
//if current client, does not match session client, then do not establish connection
else
{
delete req.session.Client;
client = false;
next();
}
}
else
{
if(typeof(req.session.Client) === 'undefined')
{
next();
}
//if client already has a connection make it active
else{
global.App.activdb = global.App.clientdbconn[req.session.Client.name];
console.log('did not make new connection for ' + req.session.Client.name);
return next();
}
}
}
}
module.exports = setclientdb;
最后但并非最不重要的
由于我结合使用 mongoose 和原生 mongo，我们必须在运行时编译我们的模型.请看下文
Last but not the least
Since I am using a combination of mongoose and native mongo, We have to compile our models at run time. Please see below
将此添加到您的 app.js
// require your models directory
var models = require('./models');
// Create models using mongoose connection for use in controllers
app.use(function db(req, res, next) {
req.db = {
User: global.App.activdb.model('User', models.agency_user, 'users')
//Post: global.App.activdb.model('Post', models.Post, 'posts')
};
return next();
});
说明:
就像我之前说的，我创建了一个全局对象来存储活动的数据库连接对象:global.App.activdb
Like I said earlier on I created a global object to store the active database connection object: global.App.activdb
然后我使用这个连接对象来创建(编译)猫鼬模型，在我将它存储在 req 对象的 db 属性中之后:req.db.我这样做是为了我可以像这样在我的控制器中访问我的模型.
Then I use this connection object to create (compile) mongoose model, after i store it in the db property of the req object: req.db. I do this so that i can access my models in my controller like this for example.
我的用户控制器示例:
exports.list = function (req, res) {
req.db.User.find(function (err, users) {
res.send("respond with a resource" + users + 'and connections ' + JSON.stringify(global.App.clients, null, 4));
console.log('Worker ' + cluster.worker.id + ' running!');
});
};
我最终会回来清理它.如果有人想帮助我，那就太好了.
I will come back and clean this up eventually. If anyone wants to help me, that be nice.
这篇关于从 nodejs 到 mongodb 或 mongoose 的动态数据库连接的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
