Múltiples conexiones en una sola aplicación

Aplicaciones multiinquilino

Considere una aplicación multiinquilino donde diferentes inquilinos o clientes comparten la misma aplicación web, pero requieren bases de datos independientes y aisladas. En este escenario, cada inquilino puede tener su propia conexión MongoDB dedicada. Esto garantiza la separación, seguridad y personalización de datos para cada inquilino, mientras todos operan dentro de la misma aplicación. Este enfoque simplifica la administración y permite escalar a medida que nuevos inquilinos se unen a la plataforma sin afectar a los existentes.

Ten en cuenta los siguientes conceptos de MongoDB para implementar múltiples conexiones en tu aplicación:

• Equilibrio de carga

• particionado

• Leer réplicas

• Tolerancia a fallos

Estos conceptos juegan un papel en escenarios donde se requieren múltiples conexiones MongoDB para una gestión eficiente de datos y la optimización del rendimiento.

Requisitos previos

Antes de comenzar este tutorial, debe tener un clúster de MongoDB Atlas. Para aprender cómo crear un clúster gratuito de MongoDB Atlas, consulta el tutorial MongoDB Comenzando.

mkdir mongodb-multiple-connections
cd mongodb-multiple-connections
npm init -y

npm install express mongoose

touch .env

:orphan:
PRIMARY_CONN_STR=<your-primary-connection-string>
SECONDARY_CONN_STR=<your-secondary-connection-string>

npm install dotenv

Ahora tiene un proyecto listo para configurar múltiples conexiones MongoDB en su aplicación.

Estructura del proyecto

Cuando complete este tutorial, su directorio de proyecto para esta aplicación tendrá la siguiente estructura:

mongodb-multiple-connections/
├── .env                          # Environment variables
├── package.json                  # Project dependencies
├── package-lock.json             # Dependency lock file
├── node_modules/                 # Installed packages
├── index.js                      # Main application file
├── db.primary.js                 # Primary connection configuration
├── db.secondary.js               # Secondary connection configuration
└── product.schema.js             # Product schema definition

Los archivos clave que creará en este tutorial sirven para los siguientes propósitos:

• index.js: Su archivo de aplicación principal que importa y usa ambas conexiones

• db.primary.js: configura la conexión principal de MongoDB usando mongoose.connect()

• db.secondary.js: configura conexiones secundarias de MongoDB usando mongoose.createConnection()

• product.esquema.js: Define el esquema de producto reutilizable para ambas conexiones.

• .env: almacena de forma segura sus cadenas de conexión MongoDB

Configurar la conexión principal de MongoDB

En esta sección, aprenda a configurar la conexión principal de MongoDB en su aplicación mediante Mongoose. Use el método mongoose.connect() para establecer la conexión principal de la base de datos MongoDB para su aplicación. Este método administra un único grupo de conexiones para toda la aplicación.

require('dotenv').config();
const mongoose = require("mongoose");
module.exports = async (uri, options = {}) => {
  // By default, Mongoose skips properties not defined in the schema (strictQuery). 
  // You can adjust it based on your configuration.
  mongoose.set('strictQuery', true);
  // Connect to MongoDB
  try {
    await mongoose.connect(uri, options);
    console.info("MongoDB primary connection initiated");
  } catch (err) {
    console.error("MongoDB primary connection failed, " + err);
  }
  // Event handling
  mongoose.connection.once('open', () => console.info("MongoDB primary connection opened!"));
  mongoose.connection.on('connected', () => console.info("MongoDB primary connection succeeded!"));
  mongoose.connection.on('error', (err) => {
    console.error("MongoDB primary connection failed, " + err);
    mongoose.disconnect();
  });
  mongoose.connection.on('disconnected', () => console.info("MongoDB primary connection disconnected!"));
  // Graceful exit
  process.on('SIGINT', async () => {
    try {
      await mongoose.connection.close();
      console.info("Mongoose primary connection disconnected through app termination!");
      process.exit(0);
    } catch (err) {
      console.error("Error during graceful shutdown:", err);
      process.exit(1);
    }
  });
}

const mongoose = require("mongoose");
module.exports = (options = {}) => {
  // Schema for Product
  return new mongoose.Schema(
    {
      store: {
        _id: mongoose.Types.ObjectId, // Reference-id to the store collection
        name: String
        },
        name: String,
        price: Number,
        category: String,
        description: String
        // add required properties
  }, 
      options
  );
}

// Load environment variables
require('dotenv').config();
const mongoose = require("mongoose");
// Async function to establish the primary MongoDB connection
async function establishPrimaryConnection() {
    try {
        await require("./db.primary.js")(process.env.PRIMARY_CONN_STR, {
            // (optional) connection options
        });
    } catch (error) {
        console.error('Failed to establish primary connection:', error);
        process.exit(1);
    }
}
// Initialize connection
establishPrimaryConnection();
// Import Product Schema
const productSchema = require("./product.schema.js")({
    collection: "products",
    // Pass configuration options if needed
});
// Create Model
const ProductModel = mongoose.model("Product", productSchema);
// Sample products data
const sampleProducts = [
    {
        name: "Laptop Pro",
        price: 1299.99,
        category: "Electronics",
        description: "High-performance laptop for professionals"
    },
    {
        name: "Wireless Headphones",
        price: 199.99,
        category: "Electronics",
        description: "Premium noise-cancelling headphones"
    },
    {
        name: "Coffee Maker",
        price: 89.99,
        category: "Kitchen",
        description: "Automatic drip coffee maker"
    }
];
// Wait for connection to be ready before executing operations
mongoose.connection.once('open', async () => {
    console.log('Primary database connected, executing operations...');
    try {
        // Check if products already exist
        const existingCount = await ProductModel.countDocuments();
        console.log(`Existing products in primary DB: ${existingCount}`);
        
        if (existingCount === 0) {
            console.log('Inserting sample products into primary database...');
            await ProductModel.insertMany(sampleProducts);
            console.log('Sample products inserted into primary database!');
        }
        // Find and display a product
        let product = await ProductModel.findOne();
        console.log('Product found in primary DB:', product);
        
        // Display all products
        const allProducts = await ProductModel.find();
        console.log(`Total products in primary DB: ${allProducts.length}`);
    } catch (error) {
        console.error('Error with primary database operations:', error);
    }
});

Primary database connected, executing operations...
MongoDB primary connection initiated
Existing products in primary DB: 3
Product found in primary DB: {
_id: new ObjectId('...'),
name: 'Laptop Pro',
__v: 0
}
Total products in primary DB: 3

donde su aplicación requiere múltiples conexiones MongoDB.

Configurar conexiones secundarias de MongoDB

Puedes configurar conexiones secundarias de MongoDB para diversos casos de uso. En esta sección, aprenderás a configurar y usar la conexión secundaria.

const mongoose = require("mongoose");
module.exports = (uri, options = {}) => {
    // Connect to MongoDB
    const db = mongoose.createConnection(uri, options);
    
    // By default, Mongoose skips properties not defined in the schema (strictQuery). 
    // Adjust it based on your configuration.
    db.set('strictQuery', true);
    
    // Event handling
    db.once('open', () => console.info("MongoDB secondary connection opened!"));
    db.on('connected', () => console.info(`MongoDB secondary connection succeeded!`));
    db.on('error', (err) => {
        console.error(`MongoDB secondary connection failed, ` + err);
        db.close();
    });
    db.on('disconnected', () => console.info(`MongoDB secondary connection disconnected!`));
    // Graceful exit
    process.on('SIGINT', async () => {
        try {
            await db.close();
            console.info(`Mongoose secondary connection disconnected through app termination!`);
            process.exit(0);
        } catch (err) {
            console.error("Error during graceful shutdown:", err);
            process.exit(1);
        }
    });
    // Export db object
    return db;
}

// Load environment variables
require('dotenv').config();
// Establish the secondary MongoDB connection
const db = require("./db.secondary.js")(process.env.SECONDARY_CONN_STR, {
    // (optional) connection options
});
// Import Product Schema
const SecondaryProductSchema = require("./product.schema.js")({
    collection: "products",
    // Pass configuration options if needed
});
// Create Model using the secondary connection
const SecondaryProductModel = db.model("Product", SecondaryProductSchema);
// Sample products data for secondary database
const SecondarySampleProducts = [
    {
        name: "Smart Watch",
        price: 199.99,
        category: "Electronics",
        description: "Advanced fitness tracking smartwatch"
    },
    {
        name: "Bluetooth Speaker",
        price: 79.99,
        category: "Electronics", 
        description: "Portable wireless speaker with premium sound"
    },
    {
        name: "Desk Lamp",
        price: 49.99,
        category: "Home",
        description: "LED desk lamp with adjustable brightness"
    }
];
// Wait for secondary connection to be ready before executing operations
db.once('open', async () => {
    console.log('Secondary database connected, executing operations...');
    try {
        // Check if products already exist
        const existingCount = await SecondaryProductModel.countDocuments();
        console.log(`Existing products in secondary DB: ${existingCount}`);
        
        if (existingCount === 0) {
            console.log('Inserting sample products into secondary database...');
            await SecondaryProductModel.insertMany(SecondarySampleProducts);
            console.log('Sample products inserted into secondary database!');
        }
        // Find and display a product
        let product = await SecondaryProductModel.findOne();
        console.log('Product found in secondary DB:', product);
        
        // Display all products
        const allProducts = await SecondaryProductModel.find();
        console.log(`Total products in secondary DB: ${allProducts.length}`);
    } catch (error) {
        console.error('Error with secondary database operations:', error);
    }
});

Primary database connected, executing operations...
MongoDB primary connection initiated
MongoDB secondary connection succeeded!
MongoDB secondary connection opened!
Secondary database connected, executing operations...
Existing products in primary DB: 3
Existing products in secondary DB: 6
Product found in primary DB: {
_id: new ObjectId('...'),
name: 'Laptop Pro',
__v: 0
}
Product found in secondary DB: {
_id: new ObjectId('...'),
name: 'Smart Watch',
__v: 0
}
Total products in primary DB: 3
Total products in secondary DB: 3

Ahora que ha configurado la conexión, puede usar el nuevo objeto db para crear un modelo. Las siguientes secciones exploran diferentes escenarios y ejemplos para ayudarle a elegir la configuración que mejor se adapte a sus necesidades específicas de acceso y gestión de datos.

Utilice un esquema existente

Si ambas conexiones operan en el mismo modelo de datos, utilice el mismo archivo product.schema.js que se empleó en la conexión principal.

Importe el archivo product.schema.js para acceder al esquema del producto. Esto le permite crear un modelo usando el objeto db y realizar operaciones relacionadas con los productos en su aplicación:

// Import Product Schema
const secondaryProductSchema = require("./product.schema.js")({
    collection: "products",
    // Pass configuration options if needed
});
// Create Model
const SecondaryProductModel = db.model("Product", secondaryProductSchema);
// Wait for secondary connection to be ready before executing operations
db.once('open', async () => {
    console.log('Secondary database connected, executing operations...');
    
    try {
        // Check if products already exist in secondary database
        const existingCount = await SecondaryProductModel.countDocuments();
        console.log(`Existing products in secondary DB: ${existingCount}`);
        
        if (existingCount === 0) {
            console.log('Inserting sample products into secondary database...');
            await SecondaryProductModel.insertMany(sampleProducts);
            console.log('Sample products inserted into secondary database!');
        }
        // Find and display a product
        let product = await SecondaryProductModel.findOne();
        console.log('Product found in secondary DB:', product);
        
        // Display all products
        const allProducts = await SecondaryProductModel.find();
        console.log(`Total products in secondary DB: ${allProducts.length}`);
    } catch (error) {
        console.error('Error with secondary database operations:', error);
    }
});

Establecer flexibilidad del esquema

Al trabajar con múltiples conexiones MongoDB, es fundamental tener la flexibilidad para adaptar el esquema a casos de uso específicos. Si bien la conexión principal puede requerir un esquema estricto con validación para garantizar la integridad de los datos, existen escenarios en los que una conexión secundaria cumple una función diferente. Por ejemplo, una conexión secundaria puede almacenar datos para análisis en un servidor de archivo, con requisitos de esquema variables según casos de uso anteriores. En esta sección, explorará cómo configurar la flexibilidad del esquema para su conexión secundaria, lo que le permitirá satisfacer las distintas necesidades de su aplicación.

Si prefiere flexibilidad de esquema en Mongoose, pase la propiedad strict: false en las opciones de esquema al configurar su esquema para la conexión secundaria. Esto le permite trabajar con datos que no se ajustan estrictamente al esquema.

Importe el archivo product.schema.js para acceder al esquema del producto. Esto le permite crear un modelo usando el objeto db y realizar operaciones relacionadas con los productos en su aplicación:

// Import Product Schema
const secondaryProductSchema = require("./product.schema.js")({
    collection: "products",
    strict: false
    // Pass configuration options if needed
});
// Create Model
const SecondaryProductModel = db.model("Product", secondaryProductSchema);
// Wait for secondary connection to be ready before executing operations
db.once('open', async () => {
    console.log('Secondary database (flexible schema) connected, executing operations...');
    
    try {
        // Check if products already exist in secondary database
        const existingCount = await SecondaryProductModel.countDocuments();
        console.log(`Existing products in secondary DB: ${existingCount}`);
        
        if (existingCount === 0) {
            // Add extra fields to demonstrate schema flexibility
            const flexibleSampleProducts = sampleProducts.map(product => ({
                ...product,
                extraField: "This field is not in the schema but will be saved due to strict: false",
                timestamp: new Date()
            }));
            
            console.log('Inserting sample products with extra fields into secondary database...');
            await SecondaryProductModel.insertMany(flexibleSampleProducts);
            console.log('Sample products with extra fields inserted into secondary database!');
        }
        // Find and display a product
        let product = await SecondaryProductModel.findOne();
        console.log('Product found in secondary DB (flexible schema):', product);
        
        // Display all products
        const allProducts = await SecondaryProductModel.find();
        console.log(`Total products in secondary DB: ${allProducts.length}`);
    } catch (error) {
        console.error('Error with secondary database operations:', error);
    }
});

Cambiar bases de datos dentro de la misma conexión

Dentro de la configuración de la base de datos de su aplicación, puede cambiar entre diferentes bases de datos mediante el método db.useDb(). Este método le permite crear un nuevo objeto de conexión asociado a una base de datos específica mientras comparte el mismo pool de conexiones.

Este enfoque le permite administrar múltiples bases de datos dentro de su aplicación, utilizando una única conexión y manteniendo contextos de datos distintos para cada base de datos.

Importe el archivo product.schema.js para acceder al esquema del producto. Esto le permite crear un modelo usando el objeto db y realizar operaciones relacionadas con los productos en su aplicación.

// Load environment variables
require('dotenv').config();
// Establish the secondary MongoDB connection
const db = require("./db.secondary.js")(process.env.SECONDARY_CONN_STR, {
    // (optional) connection options
});
// Import Product Schema
const secondaryProductSchema = require("./product.schema.js")({
    collection: "products",
    // strict: false // that doesn't adhere strictly to the schema!
    // Pass configuration options if needed
});
// Base sample products data
const sampleProducts = [
    {
        name: "Laptop Pro",
        price: 1299.99,
        category: "Electronics",
        description: "High-performance laptop for professionals"
    },
    {
        name: "Wireless Headphones",
        price: 199.99,
        category: "Electronics",
        description: "Premium noise-cancelling headphones"
    },
    {
        name: "Coffee Maker",
        price: 89.99,
        category: "Kitchen",
        description: "Automatic drip coffee maker"
    }
];
// Sample store-specific products
const storeAProducts = sampleProducts.map(product => ({
    ...product,
    store: { name: "Store A" },
    storeId: "A"
}));
const storeBProducts = [
    {
        name: "Gaming Chair",
        price: 299.99,
        category: "Furniture",
        description: "Ergonomic gaming chair with RGB lighting",
        store: { name: "Store B" },
        storeId: "B"
    },
    {
        name: "Mechanical Keyboard",
        price: 149.99,
        category: "Electronics",
        description: "RGB mechanical gaming keyboard",
        store: { name: "Store B" },
        storeId: "B"
    }
];
// Create a connection for 'Store A'
const storeA = db.useDb('StoreA');
// Create Model
const SecondaryStoreAProductModel = storeA.model("Product", secondaryProductSchema);
// Wait for Store A connection to be ready
storeA.once('open', async () => {
    console.log('Store A database connected, executing operations...');
    
    try {
        // Check if products already exist in Store A
        const existingCount = await SecondaryStoreAProductModel.countDocuments();
        console.log(`Existing products in Store A: ${existingCount}`);
        
        if (existingCount === 0) {
            console.log('Inserting sample products into Store A database...');
            await SecondaryStoreAProductModel.insertMany(storeAProducts);
            console.log('Sample products inserted into Store A database!');
        }
        // Find and display a product
        let product = await SecondaryStoreAProductModel.findOne();
        console.log('Product found in Store A:', product);
        
        // Display all products
        const allProducts = await SecondaryStoreAProductModel.find();
        console.log(`Total products in Store A: ${allProducts.length}`);
    } catch (error) {
        console.error('Error with Store A operations:', error);
    }
});
// Create a connection for 'Store B'
const storeB = db.useDb('StoreB');
// Create Model
const SecondaryStoreBProductModel = storeB.model("Product", secondaryProductSchema);
// Wait for Store B connection to be ready
storeB.once('open', async () => {
    console.log('Store B database connected, executing operations...');
    
    try {
        // Check if products already exist in Store B
        const existingCount = await SecondaryStoreBProductModel.countDocuments();
        console.log(`Existing products in Store B: ${existingCount}`);
        
        if (existingCount === 0) {
            console.log('Inserting sample products into Store B database...');
            await SecondaryStoreBProductModel.insertMany(storeBProducts);
            console.log('Sample products inserted into Store B database!');
        }
        // Find and display a product
        let product = await SecondaryStoreBProductModel.findOne();
        console.log('Product found in Store B:', product);
        
        // Display all products
        const allProducts = await SecondaryStoreBProductModel.find();
        console.log(`Total products in Store B: ${allProducts.length}`);
    } catch (error) {
        console.error('Error with Store B operations:', error);
    }
});

// Function to get connection object for particular store's database
function getStoreConnection(storeId) {
    return db.useDb("Store"+storeId, { useCache: true });
}
// Create a connection for 'Store A'
const store = getStoreConnection("A");
// Create Model
const SecondaryStoreProductModel = store.model("Product", secondaryProductSchema);
// Wait for store connection to be ready
store.once('open', async () => {
    console.log('Store A (dynamic) database connected, executing operations...');
    
    try {
        // Check if products already exist in the store
        const existingCount = await SecondaryStoreProductModel.countDocuments();
        console.log(`Existing products in Store A (dynamic): ${existingCount}`);
        
        if (existingCount === 0) {
            // Use the same store A products from the previous example
            console.log('Inserting sample products into Store A (dynamic) database...');
            await SecondaryStoreProductModel.insertMany(storeAProducts);
            console.log('Sample products inserted into Store A (dynamic) database!');
        }
        // Find and display a product
        let product = await SecondaryStoreProductModel.findOne();
        console.log('Product found in Store A (dynamic):', product);
        
        // Display all products
        const allProducts = await SecondaryStoreProductModel.find();
        console.log(`Total products in Store A (dynamic): ${allProducts.length}`);
    } catch (error) {
        console.error('Error with Store A (dynamic) operations:', error);
    }
});

Mejores prácticas

Al implementar múltiples conexiones MongoDB en su aplicación Node.js, siga estas prácticas recomendadas:

• Agrupación de conexiones: Utilice la agrupación de conexiones para gestionar las conexiones de MongoDB de forma eficiente. Permite la reutilización de conexiones y reduce la sobrecarga. Para obtener más información, consulte Agrupación de conexiones en el manual del servidor y Administrar conexiones con grupos de conexiones en la documentación del controlador Node.js de MongoDB.

• Manejo de errores: Implemente mecanismos adecuados de manejo de errores, registro y recuperación para garantizar la confiabilidad de la conexión.

• Seguridad: Implemente prácticas de autenticación, autorización y comunicación segura al gestionar datos confidenciales. Para más información, consulte Proteja sus datos.

• Escalabilidad: diseñe su estrategia de conexión para soportar requisitos de escalamiento tanto horizontal como vertical.

• Pruebas: pruebe su configuración de conexión múltiple en diversas condiciones, incluidos escenarios de conmutación por error, alta carga y limitaciones de recursos.

Recursos adicionales

Para obtener más información sobre cómo comenzar a usar Mongoose, consulte el tutorial Comenzar a usar Mongoose en la sección Integraciones de terceros.

Para obtener más información sobre el uso de Mongoose con MongoDB, consulte la documentación de Mongoose.