Read-write load balancing design

Read-Write Load Balancing Design

MongoDB's read-write load balancing is a key technique for improving database performance. By rationally distributing read and write requests, it can effectively reduce the pressure on single nodes and enhance system throughput and response speed. Read-write separation, sharded clusters, and client-side routing are common methods for achieving load balancing.

Basic Read-Write Separation Architecture

MongoDB replica sets natively support read-write separation architectures. The primary node handles all write operations and some read requests, while secondary nodes are dedicated to分担 read requests. By configuring read preferences, you can flexibly control the routing strategy for read requests:

const { MongoClient, ReadPreference } = require('mongodb');

const client = new MongoClient(uri, {
  readPreference: ReadPreference.SECONDARY_PREFERRED,
  replicaSet: 'myReplicaSet'
});

async function queryData() {
  await client.connect();
  const collection = client.db('test').collection('users');
  // This query will be routed to a secondary node
  const result = await collection.find({ age: { $gt: 18 } }).toArray();
  console.log(result);
}

Common read preference modes include:

• primary: Enforces reads on the primary node (default)
• primaryPreferred: Prefers the primary node, falls back to secondaries if unavailable
• secondary: Enforces reads on secondary nodes
• secondaryPreferred: Prefers secondary nodes, falls back to the primary if unavailable
• nearest: Selects the node with the lowest network latency

Sharded Cluster Load Balancing

For large-scale datasets, sharded clusters achieve load balancing through horizontal data partitioning. MongoDB automatically balances data distribution across shards, and the query router (mongos) directs requests to specific shards based on the shard key:

// Example of connecting to a sharded cluster
const mongosClient = new MongoClient('mongodb://mongos1:27017,mongos2:27017/test');

async function insertShardedData() {
  await mongosClient.connect();
  const collection = mongosClient.db('test').collection('orders');
  // Assuming the shard key is customerId
  await collection.createIndex({ customerId: 1 });
  // Data will be automatically routed to the corresponding shard based on customerId
  await collection.insertOne({
    customerId: 'C1001',
    amount: 299.99,
    date: new Date()
  });
}

Sharding strategy directly impacts load balancing effectiveness:

• Range sharding: Suitable for range queries but may create hotspots
• Hash sharding: Ensures even data distribution but inefficient for range queries
• Compound sharding: Combines multiple fields as shard keys based on business needs

Client-Side Request Routing

Smart clients can implement more granular load control. By monitoring node status and performance metrics, they dynamically adjust request distribution:

class SmartMongoClient {
  constructor(nodes) {
    this.nodes = nodes.map(url => ({
      url,
      latency: 0,
      lastUpdate: Date.now()
    }));
    this.statsWindow = 1000 * 60; // 1-minute statistics window
  }

  async getBestNode() {
    // Implement node selection algorithm based on latency and load
    const activeNodes = await this.checkNodeStatus();
    return activeNodes.sort((a, b) => a.latency - b.latency)[0];
  }

  async query(collectionName, query) {
    const bestNode = await this.getBestNode();
    const client = new MongoClient(bestNode.url);
    try {
      await client.connect();
      return await client.db('test').collection(collectionName).find(query).toArray();
    } finally {
      client.close();
    }
  }
}

Monitoring and Auto-Balancing

An effective monitoring system is the foundation for maintaining load balancing. MongoDB provides various monitoring metrics:

1. Replica set status monitoring:

rs.status()  # View replica set member status
db.serverStatus()['repl']  # Get replication-related metrics

2. Sharded cluster balancing status:

sh.status()  # View shard distribution
db.getSiblingDB("config").chunks.find()  # Check chunk distribution

3. Performance counters:

// Get operation counters
const metrics = db.serverStatus().metrics;
console.log({
  reads: metrics.operation.reads,
  writes: metrics.operation.writes,
  commands: metrics.operation.commands
});

Advanced Balancing Strategies

For special scenarios, customized balancing solutions can be implemented:

1. Tag-based sharding:

// Add tags to shards
sh.addShardTag("shard0000", "USA");
sh.addShardTag("shard0001", "EU");

// Configure tag range rules
sh.addTagRange("test.orders", { region: "US" }, { region: "US" }, "USA");

2. Read-write separation weight adjustment:

// Example of custom routing middleware
app.use(async (req, res, next) => {
  if (req.method === 'GET') {
    const isHeavyQuery = req.query.complexity > 5;
    req.dbOption = {
      readPreference: isHeavyQuery ? 'secondary' : 'primaryPreferred'
    };
  }
  next();
});

3. Hotspot data caching:

const cache = new Map();

async function getProductWithCache(productId) {
  if (cache.has(productId)) {
    return cache.get(productId);
  }
  const product = await productsCollection.findOne({ _id: productId });
  cache.set(productId, product);
  return product;
}

Performance Tuning Practices

Key parameters to focus on during actual deployment:

1. Connection pool configuration:

const client = new MongoClient(uri, {
  poolSize: 50, // Connection pool size
  socketTimeoutMS: 30000,
  connectTimeoutMS: 5000
});

2. Batch operation optimization:

// Use bulk inserts instead of single inserts
const bulkOps = products.map(product => ({
  insertOne: { document: product }
}));
await collection.bulkWrite(bulkOps, { ordered: false });

3. Index strategy adjustment:

// Create compound indexes for covered queries
await collection.createIndexes([
  { key: { category: 1, price: 1 } },
  { key: { name: "text" } }
]);

Fault Handling Mechanisms

Robust fault tolerance design ensures load balancing stability:

1. Retry strategy implementation:

async function resilientQuery(query, retries = 3) {
  try {
    return await collection.find(query).toArray();
  } catch (err) {
    if (retries > 0 && err.code === 13435) { // Node unavailable error
      await new Promise(resolve => setTimeout(resolve, 1000));
      return resilientQuery(query, retries - 1);
    }
    throw err;
  }
}

2. Automatic fault detection:

setInterval(async () => {
  const members = await admin.command({ replSetGetStatus: 1 });
  members.members.forEach(member => {
    updateNodeHealthStatus(member.name, member.health);
  });
}, 5000); // Check node health every 5 seconds

3. Write Concern configuration:

// Ensure data is written to a majority of nodes
await collection.insertOne(doc, {
  writeConcern: { w: 'majority', j: true }
});