Skip to main content

MongoDB Backup Methods

Data is one of your application's most valuable assets. Without reliable backup strategies, you risk permanent data loss during hardware failures, human errors, or other disasters. In this guide, we'll explore various methods for backing up MongoDB databases to ensure your data remains protected.

Introduction to MongoDB Backups​

Backup is the process of creating a copy of your data that can be restored in case the original data is lost or corrupted. MongoDB offers several backup methods, each with advantages and trade-offs in terms of:

  • Performance impact
  • Storage requirements
  • Consistency guarantees
  • Recovery time
  • Ease of implementation

Let's explore the main backup methods available for MongoDB databases.

1. MongoDB Tools: mongodump and mongorestore​

The most straightforward backup method uses MongoDB's built-in utilities: mongodump and mongorestore.

mongodump​

mongodump is a command-line utility that creates a binary export of the contents of a database.

Basic Usage:​

bash
mongodump --host=localhost --port=27017 --db=myDatabase --out=/backup/path

This creates a BSON dump of the specified database in the /backup/path directory.

Example with Authentication:​

bash
mongodump --uri="mongodb://username:password@localhost:27017/myDatabase" --out=/backup/path

Advanced Options:​

bash
# Backup specific collections
mongodump --db=myDatabase --collection=users --out=/backup/path

# Compress the output
mongodump --db=myDatabase --gzip --out=/backup/path

# Filter documents using a query
mongodump --db=myDatabase --collection=users --query='{"active": true}' --out=/backup/path

mongorestore​

mongorestore is the companion utility that restores data from a mongodump backup.

Basic Usage:​

bash
mongorestore --host=localhost --port=27017 /backup/path

Example with Authentication:​

bash
mongorestore --uri="mongodb://username:password@localhost:27017" /backup/path/myDatabase

Advanced Options:​

bash
# Restore specific collections
mongorestore --db=myDatabase --collection=users /backup/path/myDatabase/users.bson

# Drop existing collections before restoring
mongorestore --drop /backup/path

# Restore with different collection name
mongorestore --nsFrom="myDatabase.users" --nsTo="newDatabase.people" /backup/path/myDatabase/users.bson

Pros and Cons of mongodump/mongorestore​

Pros:

  • Easy to use
  • Can back up specific collections or databases
  • Can filter data during backup
  • Works across MongoDB versions

Cons:

  • Not point-in-time consistent across collections
  • Can impact database performance during backup
  • Not suitable for very large databases

2. Filesystem Snapshots​

Filesystem snapshots provide a point-in-time, consistent view of MongoDB data files. This method is particularly useful for large databases where mongodump might be impractical.

Steps for Creating Filesystem Snapshots​

  1. Flush and lock database writes (for consistent snapshots):
bash
mongo admin --eval "db.fsyncLock()"
  1. Create the filesystem snapshot (commands vary by storage system):
bash
# Example for Linux LVM
lvcreate --snapshot --name mongodb-snap --size 5G /dev/vg0/mongodb
  1. Release the database lock:
bash
mongo admin --eval "db.fsyncUnlock()"
  1. Mount or back up the snapshot:
bash
mkdir /mnt/mongodb-backup
mount /dev/vg0/mongodb-snap /mnt/mongodb-backup

Pros and Cons of Filesystem Snapshots​

Pros:

  • Point-in-time consistent
  • Low impact on database performance
  • Suitable for large databases
  • Fast backup and restore

Cons:

  • Requires filesystem/storage system support for snapshots
  • Requires more technical expertise
  • Storage overhead
  • All-or-nothing approach (can't back up specific collections)

3. MongoDB Atlas Backups (for cloud deployments)​

If you're using MongoDB Atlas (MongoDB's cloud database service), it provides built-in backup solutions:

Continuous Backups​

Atlas offers point-in-time recovery for up to 35 days, allowing you to restore to any moment within the retention window.

Example restore through the Atlas UI:

  1. Navigate to the Clusters view
  2. Click "Backup" for your cluster
  3. Select "Restore" and choose the point-in-time to restore

Snapshot Backups​

Atlas also creates daily snapshots that are retained according to your backup policy.

4. MongoDB Ops Manager (for enterprise deployments)​

For enterprise environments, MongoDB Ops Manager provides sophisticated backup capabilities:

  • Continuous, incremental backups with point-in-time recovery
  • Backup automation and scheduling
  • Granular restore options (database, collection, or document level)
  • Backup verification

5. Replication as a Backup Strategy​

While not a backup method per se, maintaining replicas provides redundancy that protects against some failure scenarios.

You can perform backups on a secondary node to reduce the impact on your production database:

bash
# Connect to a secondary node with slaveOk enabled
mongodump --host=secondary.example.com --port=27017 --db=myDatabase --out=/backup/path --oplog

Real-world Backup Strategies​

Let's look at some practical backup strategies based on different requirements:

Scenario 1: Small to Medium Database with Daily Backups​

bash
#!/bin/bash
# daily-backup.sh
DATE=$(date +"%Y-%m-%d")
BACKUP_DIR="/var/backups/mongodb/$DATE"

# Create backup directory
mkdir -p $BACKUP_DIR

# Perform backup with compression
mongodump --uri="mongodb://username:password@localhost:27017" --out=$BACKUP_DIR --gzip

# Remove backups older than 14 days
find /var/backups/mongodb -type d -mtime +14 -exec rm -rf {} \;

Add this script to your crontab to run automatically:

bash
# Run backup daily at 1 AM
0 1 * * * /path/to/daily-backup.sh >> /var/log/mongodb-backup.log 2>&1

Scenario 2: Large Production Database​

For large databases, consider this approach:

  1. Set up a dedicated secondary replica for backups
  2. Use filesystem snapshots on this backup node
  3. Implement a rotation policy for your snapshots
bash
#!/bin/bash
# snapshot-backup.sh

# Lock database for consistent snapshot
mongo admin --eval "db.fsyncLock()"

# Create LVM snapshot
lvcreate --snapshot --name mongodb-snap-$(date +%Y%m%d) --size 50G /dev/vg0/mongodb-data

# Release lock
mongo admin --eval "db.fsyncUnlock()"

# Mount snapshot and copy to backup storage
mkdir -p /mnt/mongodb-snap
mount /dev/vg0/mongodb-snap-$(date +%Y%m%d) /mnt/mongodb-snap
rsync -av /mnt/mongodb-snap/ /backup/storage/mongodb-$(date +%Y%m%d)/

# Clean up
umount /mnt/mongodb-snap
lvremove -f /dev/vg0/mongodb-snap-$(date +%Y%m%d)

# Remove backups older than 7 days
find /backup/storage -type d -name "mongodb-*" -mtime +7 -exec rm -rf {} \;

Scenario 3: Critical Application with Point-in-Time Recovery Needs​

For applications where you need to recover to any point in time:

  1. Use MongoDB Ops Manager or Atlas continuous backups
  2. Implement oplog backups alongside full backups
bash
# Backup the oplog after a full backup
mongodump --host localhost --port 27017 --db local --collection oplog.rs \
  --out=/backup/oplog-$(date +%Y%m%d) \
  --query='{"ts":{"$gt":{"$timestamp":{"t":'$(date +%s)',"i":0}}}}'

Best Practices for MongoDB Backups​

  1. Test your restore process regularly - A backup is only useful if you can actually restore from it
  2. Automate backups - Human error is reduced with automation
  3. Store backups off-site - Protect against site-wide disasters
  4. Monitor backup success/failure - Set up alerts for backup failures
  5. Document your backup and recovery procedures - Make sure team members know how to perform recovery
  6. Implement appropriate security - Encrypt sensitive data in backups
  7. Consider legal requirements - Some industries have specific backup retention requirements

Summary​

MongoDB offers several methods for backing up your databases, each with its own advantages:

  • mongodump/mongorestore: Simple, flexible, but can be slow for large databases
  • Filesystem snapshots: Fast, point-in-time consistent, but requires specific filesystem support
  • MongoDB Atlas or Ops Manager: Comprehensive backup solutions with point-in-time recovery
  • Replication: Provides redundancy but isn't a complete backup solution

The right backup strategy depends on your specific needs, such as database size, recovery time objectives, acceptable performance impact, and budget. Most production deployments benefit from a combination of these methods.

Additional Resources​

Exercises​

  1. Set up a small test MongoDB database, perform a backup using mongodump, then intentionally delete some data and practice restoring it.
  2. Write a bash script that performs daily backups of a MongoDB database and implements a 7-day rotation policy.
  3. If you have access to a server with LVM, practice creating a filesystem snapshot of a MongoDB data directory.
  4. Set up a MongoDB replica set with three nodes and practice taking a backup from a secondary node.
  5. Research and document a disaster recovery plan for a hypothetical application using MongoDB.

By implementing proper backup strategies, you ensure your data remains safe and your applications resilient against data loss disasters.


If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)