MongoDB Clustering Interview Questions

Introduction

This guide covers essential MongoDB clustering concepts commonly asked in technical interviews. Each question includes detailed answers and practical examples.

Medium

1. What is MongoDB clustering and why is it important?

MongoDB clustering is a method of deploying multiple MongoDB instances to provide high availability, scalability, and fault tolerance. Key benefits include:

  • High Availability
  • Horizontal Scalability
  • Load Balancing
  • Fault Tolerance
  • Data Redundancy
Cluster Components:
  • Mongos Router
  • Config Servers
  • Shard Servers
  • Replica Sets
  • Chunks
Hard

2. How do you set up and configure a MongoDB cluster?

Cluster setup and configuration:

1. Basic Configuration
# Start config servers
mongod --configsvr --dbpath /data/configdb --port 27019

# Start shard servers
mongod --shardsvr --dbpath /data/shard1 --port 27018
mongod --shardsvr --dbpath /data/shard2 --port 27017

# Start mongos router
mongos --configdb configReplSet/localhost:27019

# Add shards to cluster
sh.addShard("localhost:27018")
sh.addShard("localhost:27017")

# Enable sharding for database
sh.enableSharding("myapp")

# Shard collection
sh.shardCollection("myapp.users", { "userId": "hashed" })
2. Advanced Configuration
# Configure replica sets
rs.initiate({
    _id: "rs0",
    members: [
        { _id: 0, host: "localhost:27017" },
        { _id: 1, host: "localhost:27018" },
        { _id: 2, host: "localhost:27019" }
    ]
})

# Configure shard zones
sh.addShardToZone("shard0", "zone1")
sh.addShardToZone("shard1", "zone2")

# Define zone ranges
sh.updateZoneKeyRange(
    "myapp.users",
    { "userId": MinKey },
    { "userId": MaxKey },
    "zone1"
)

# Configure balancer
sh.setBalancerState(false)  // Disable balancer
sh.startBalancer()  // Start balancer
sh.stopBalancer()   // Stop balancer
Hard

3. How do you manage and monitor a MongoDB cluster?

Cluster management and monitoring:

1. Cluster Management
# Check cluster status
sh.status()

# Monitor balancer
sh.getBalancerState()
sh.isBalancerRunning()

# Check chunk distribution
db.chunks.find({ ns: "myapp.users" })

# Move chunks
sh.moveChunk("myapp.users",
    { userId: 1000 },
    "shard1")

# Split chunks
sh.splitAt("myapp.users",
    { userId: 5000 })
2. Performance Monitoring
# Monitor cluster metrics
db.adminCommand({
    serverStatus: 1
})

# Check operation distribution
db.currentOp().inprog.forEach(function(op) {
    if (op.shard) {
        printjson(op);
    }
})

# Monitor chunk splits
db.changelog.find({
    what: "split",
    ns: "myapp.users"
})

# Check balancer rounds
db.changelog.find({
    what: "balancer.round"
})
Hard

4. How do you handle cluster scaling and maintenance?

Cluster scaling and maintenance:

1. Scaling Operations
# Add new shard
sh.addShard("localhost:27020")

# Remove shard
sh.removeShard("shard0")

# Check shard status
sh.status()

# Monitor shard removal
db.adminCommand({
    removeShard: "shard0"
})

# Check shard removal status
db.adminCommand({
    listShards: 1
})
2. Maintenance Operations
# Backup cluster
mongodump --host localhost --port 27017 --out /backup

# Restore cluster
mongorestore --host localhost --port 27017 /backup

# Check cluster health
db.adminCommand({
    serverStatus: 1
})

# Monitor cluster metrics
db.adminCommand({
    top: 1
})
Hard

5. What are the clustering best practices?

Follow these clustering best practices:

1. Design Best Practices
// Optimal shard key selection
function analyzeShardKey(coll, key) {
    // Check cardinality
    const cardinality = db[coll].distinct(key).length;
    
    // Check distribution
    const distribution = db[coll].aggregate([
        { $group: { _id: "$" + key, count: { $sum: 1 } } },
        { $sort: { count: -1 } }
    ]).toArray();
    
    // Check query patterns
    const queries = db.system.profile.find({
        ns: db.getName() + "." + coll
    }).toArray();
    
    return {
        cardinality,
        distribution,
        queries
    };
}

// Implement shard key
db.users.createIndex({ userId: 1 })
sh.shardCollection("myapp.users", { userId: 1 })
2. Operational Best Practices
// Regular maintenance
function maintainCluster() {
    // Check cluster health
    const status = sh.status();
    
    // Monitor chunk distribution
    const chunks = db.chunks.find({
        ns: "myapp.users"
    }).toArray();
    
    // Check balancer status
    const balancerState = sh.getBalancerState();
    
    // Monitor performance
    const performance = db.adminCommand({
        serverStatus: 1
    });
    
    // Take action based on metrics
    if (chunks.length > 1000) {
        sh.splitAt("myapp.users", { userId: 5000 });
    }
    
    if (!balancerState) {
        sh.startBalancer();
    }
}

Next Steps

Continue your MongoDB interview preparation with:

MongoDB Interview Questions