Recommendations for production environment deployment

Production Environment Deployment Recommendations

Deploying MongoDB in a production environment requires consideration of multiple aspects such as performance, high availability, security, and maintainability. A reasonable deployment strategy ensures stable database operation while addressing challenges like high concurrency and large data volumes.

Hardware Configuration

CPU and Memory

MongoDB is a memory-intensive database. It is recommended to configure sufficient memory to accommodate the working set. The working set refers to the total size of frequently accessed data and indexes. If the working set cannot fit entirely into memory, performance will degrade significantly.

// Example: Check working set size
db.runCommand({serverStatus: 1}).wiredTiger.cache["bytes currently in the cache"]

For CPUs, MongoDB can utilize multi-core processors. A minimum of 4 cores is recommended, with more cores needed for high-concurrency scenarios.

Storage

Using SSD storage can significantly improve I/O performance. Avoid network storage (e.g., NFS) due to higher latency. RAID 10 is the recommended configuration, offering good performance and redundancy.

Replica Set Deployment

Member Configuration

Deploy at least a 3-node replica set in production to ensure high availability. A typical configuration includes:

• 1 Primary node
• 1 Secondary node
• 1 Arbiter node or another Secondary node

// Example: Initialize a replica set
rs.initiate({
  _id: "myReplicaSet",
  members: [
    { _id: 0, host: "mongo1.example.com:27017" },
    { _id: 1, host: "mongo2.example.com:27017" },
    { _id: 2, host: "mongo3.example.com:27017", arbiterOnly: true }
  ]
})

Read/Write Concerns

Configure appropriate read/write concern levels based on application requirements:

// Write acknowledgment from majority of nodes
db.products.insertOne(
  { item: "card", qty: 15 },
  { writeConcern: { w: "majority", wtimeout: 5000 } }
)

// Read from secondary nodes
db.products.find().readConcern("available").readPref("secondary")

Sharded Cluster

For very large-scale data, deploy a sharded cluster. Key components include:

• Multiple shards (each shard should ideally be a replica set)
• Config servers (must be deployed as a replica set)
• Query routers (mongos)

Shard Key Selection

Choosing an appropriate shard key is critical. A good shard key should:

• Have high cardinality
• Be evenly distributed
• Match query patterns

// Example: Enable sharding and select a shard key
sh.enableSharding("mydatabase")
sh.shardCollection("mydatabase.products", { category: 1, _id: 1 })

Security Configuration

Authentication and Authorization

Always enable access control:

# mongod.conf
security:
  authorization: enabled

Create users with minimal privileges:

use admin
db.createUser({
  user: "appuser",
  pwd: "securepassword",
  roles: [ { role: "readWrite", db: "appdb" } ]
})

Network Isolation

• Use firewalls to restrict access
• Consider VPC or private networks
• Disable the default 27017 port or configure IP whitelisting

Monitoring and Maintenance

Performance Monitoring

Configure monitoring tools to track key metrics:

• Operation counters
• Memory usage
• Queue lengths
• Replication lag

// Common monitoring commands
db.serverStatus()
db.currentOp()
db.collection.stats()

Regular Maintenance

• Monitor and optimize indexes
• Regularly compact collections
• Implement backup strategies
• Schedule maintenance windows for version upgrades

Backup Strategies

Ops Manager/Cloud Manager

Enterprise users can use official tools for automated backups.

Filesystem Snapshots

For environments supporting filesystem snapshots:

# Flush writes before creating a snapshot
db.fsyncLock()

# Unlock after creating the snapshot
db.fsyncUnlock()

mongodump

Suitable for smaller databases:

mongodump --uri="mongodb://user:pwd@host:port/db" --out=/backup/path

Performance Optimization

Index Optimization

Use the explain plan to analyze queries:

db.products.find({ category: "electronics" }).explain("executionStats")

Create appropriate indexes:

db.products.createIndex({ category: 1, price: -1 })

Query Optimization

• Avoid full collection scans
• Use projections to limit returned fields
• Batch operations to reduce network round trips

// Good practice
db.products.find(
  { category: "books" },
  { title: 1, price: 1, _id: 0 }
).limit(100)

Disaster Recovery

Develop and test a disaster recovery plan, including:

• Data recovery procedures
• Failover steps
• Contact lists
• Defined RTO (Recovery Time Objective) and RPO (Recovery Point Objective)

Version Upgrades

Before upgrading:

• Review release notes
• Validate in a test environment
• Back up all data
• Plan a rollback strategy

Rolling upgrade steps:

1. Upgrade secondary nodes
2. Step down the primary node
3. Upgrade the former primary node