Tutorial: Várias conexões do MongoDB em um único aplicativo

Aplicativos de vários inquilinos

Considere um aplicação multilocatário em que diferentes locatários ou clientes compartilham o mesmo aplicação da web, mas exigem bancos de dados separados e isolados. Nesse cenário, cada locatário pode ter sua própria conexão MongoDB dedicada. Isso garante a separação, a segurança e a personalização de dados para cada locatário enquanto todos operam dentro do mesmo aplicação. Essa abordagem simplifica o gerenciamento e fornece uma maneira de escalar à medida que novos locatários ingressam na plataforma sem afetar os existentes.

Considere os seguintes conceitos do MongoDB ao explorar como implementar várias conexões em seu aplicação:

• Balanceamento de carga

• Fragmentação

• Ler réplicas

• Tolerância a falhas

Esses conceitos são importantes em cenários em que várias conexões do MongoDB são necessárias para o gerenciamento eficiente de dados e a otimização do desempenho.

Pré-requisitos

Antes de iniciar este tutorial, você deve ter um cluster MongoDB Atlas . Para saber como criar um cluster gratuito do MongoDB Atlas, consulte o tutorial Introdução ao Atlas.

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

npm install express mongoose

touch .env

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

npm install dotenv

Agora você tem um projeto que está pronto para configurar múltiplas conexões MongoDB em seu aplicação.

Estrutura do projeto

Quando você concluir este tutorial, seu diretório de projeto para este aplicação terá a seguinte estrutura:

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

Os arquivos de chave que você criará neste tutorial têm as seguintes finalidades:

• index.js: Seu principal arquivo de aplicação que importa e usa ambas as conexões

• db.primary.js: Configura a conexão MongoDB primária utilizando mongoose.connect()

• db.secondary.js: Configura conexões MongoDB secundárias utilizando mongoose.createConnection()

• produto.schema.js: Define o esquema de produto reutilizável para ambas as conexões

• .env: armazena suas connection strings do MongoDB com segurança

Configurar a conexão primária do MongoDB

Nesta seção, saiba como configurar a conexão primária do MongoDB em seu aplicação usando o Mongoose. Use o mongoose.connect() método para estabelecer a conexão primária do banco de dados MongoDB para seu aplicação. Este método gerencia um único pool de conexões para todo o aplicação.

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

onde seu aplicação exige múltiplas conexões MongoDB .

Configurar conexões secundárias do MongoDB

Você pode configurar conexões MongoDB secundárias para vários casos de uso. Nesta seção, saiba como configurar e usar a conexão secundária.

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

Agora que você configurou a conexão, você pode utilizar o novo objeto db para criar um modelo. As seções a seguir exploram diferentes cenários e exemplos para ajudá-lo a escolher a configuração que melhor se alinha às suas necessidades específicas de acesso e gerenciamento de dados.

Usar um esquema existente

Se ambas as conexões operarem no mesmo modelo de dados, use o mesmo arquivo product.schema.js que foi utilizado na conexão primária.

Importe o arquivo product.schema.js para acessar o esquema do produto. Isso permite criar um modelo usando o objeto db e executar operações relacionadas a produtos em seu aplicação:

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

Para ver um exemplo de código prático e os recursos disponíveis para usar o esquema existente de uma conexão primária de banco de dados em uma conexão secundária do MongoDB em seu projeto, visite o repositório Como usar o esquema existente no Github.

Definir flexibilidade de esquema

Ao trabalhar com várias conexões do MongoDB , é essencial ter a flexibilidade de adaptar seu esquema com base em casos de uso específicos. Embora a conexão primária possa exigir um esquema rigoroso com validação para garantir a integridade dos dados, há cenários em que uma conexão secundária serve a um propósito diferente. Por exemplo, uma conexão secundária pode armazenar dados para análise em um servidor de arquivamento , com requisitos de esquema variáveis orientados por casos de uso anteriores. Nesta seção, você explorará como configurar a flexibilidade de esquema para sua conexão secundária, permitindo atender as necessidades distintas do seu aplicação.

Se você preferir ter flexibilidade de esquema no Mongoose, passe a propriedade strict: false nas opções de esquema ao configurar seu esquema para a conexão secundária. Isso permite que você trabalhe com dados que não aderem estritamente ao esquema.

Importe o arquivo product.schema.js para acessar o esquema do produto. Isso permite criar um modelo usando o objeto db e executar operações relacionadas a produtos em seu aplicação:

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

Para visualizar um exemplo de código prático e os recursos disponíveis para configurar a flexibilidade de esquema em uma conexão secundária do MongoDB em seu projeto, consulte o repositório do Github de configuração da flexibilidade de esquema.

Trocar bancos de dados dentro da mesma conexão

Na configuração do banco de dados do seu aplicativo, você pode alternar entre diferentes bancos de dados usando o método db.useDb(). Esse método permite criar um novo objeto de conexão associado a um banco de dados específico enquanto compartilha o mesmo pool de conexões.

Essa abordagem permite gerenciar vários bancos de dados em seu aplicação, usando uma única conexão e mantendo contextos de dados distintos para cada banco de dados.

Importe o arquivo product.schema.js para acessar o esquema do produto. Isso permite que você crie um modelo usando o objeto db e execute operações relacionadas a produtos em seu aplicação.

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

Melhores práticas

Ao implementar várias conexões MongoDB em seu aplicação Node.js , siga estas práticas recomendadas:

• pooling de conexões: use o pool de conexões para gerenciar as conexões do MongoDB com eficiência. O pooling de conexões permite a reutilização de conexões e reduz a sobrecarga. Para saber mais, consulte Pool de conexões no manual do servidor e Gerenciar conexões com pools de conexões na documentação do driver do MongoDB Node.js

• Tratamento de erros: implemente mecanismos adequados de tratamento de erros, registro e recuperação para garantir a confiabilidade da conexão.

• Segurança: implemente práticas de autenticação, autorização e comunicação segura ao lidar com dados confidenciais. Para mais informações, consulte Proteger seus dados.

• Escalabilidade: crie sua estratégia de conexão para oferecer suporte aos requisitos de dimensionamento horizontal e vertical.

• Teste: teste sua configuração de conexão múltipla em várias condições, incluindo cenários de failover, alta carga e restrições de recursos.

Recursos adicionais

Para saber mais sobre como começar a usar o Mongoose, consulte o tutorial Introdução ao Mongoose na seção Integrações de terceiros.

Para saber mais sobre como usar o Mongoose com o MongoDB, consulte a documentação do Mongoose.

Para saber mais sobre a implementação completa de várias conexões do MongoDB em um aplicação Node.js, consulte o repositório do Github.