MongoDB Replication

What You’ll Learn

Replication keeps your MongoDB data safe and available by copying it across multiple servers in a replica set. If one server fails, another takes over as primary—your app keeps running.

Definition and Usage

Replication is MongoDB’s built-in mechanism for high availability and data redundancy. Instead of relying on one mongod process, you deploy a replica set—a group of nodes that share the same data.

The primary receives all writes. Secondaries replicate the primary’s oplog (operations log) and apply changes in order. An optional arbiter participates in elections but holds no data—useful only in specific legacy setups; data-bearing nodes are preferred.

Replication is the foundation for production MongoDB. Even sharded clusters store each shard as a replica set. Learn aggregation with pipeline stages first, then replication before scaling out horizontally.

🏗️ Replica set members

A typical production replica set has three data-bearing members across availability zones. That gives quorum for elections without relying on an arbiter.

📝 Syntax

Replica set administration uses rs.* helpers in mongosh on a connected mongod that has replication enabled:

// Start mongod with --replSet rs0 (or replSetName in mongod.conf)

// Initiate the replica set (first member)
rs.initiate({
  _id: "rs0",
  members: [
    { _id: 0, host: "localhost:27017" }
  ]
});

// Check health and roles
rs.status();

// Add another member
rs.add("mongodb2.example.net:27017");

// View configuration
rs.conf();

Syntax Rules

• replSetName — every member must share the same replica set name in config.
• Odd member count — 3, 5, or 7 voting members avoids split-brain tie votes.
• Initiate once — run rs.initiate() only on a fresh set; use rs.add() to grow.
• Connection string — apps use mongodb://host1,host2,host3/?replicaSet=rs0.
• Write concern — { w: "majority" } waits for most members to acknowledge writes.
• Read preference — secondaryPreferred offloads reads when a secondary is available.

// Node.js driver example
mongodb://mongo1:27017,mongo2:27017,mongo3:27017/mydb?replicaSet=rs0

// Write with majority concern
db.orders.insertOne(
  { item: "keyboard", qty: 2 },
  { writeConcern: { w: "majority", wtimeout: 5000 } }
);

Examples Gallery

Set up a dev replica set, inspect roles, write with durability guarantees, and add a member—commands you run in mongosh after starting mongod with a replica set name.

rs.initiate({
  _id: "rs0",
  members: [{ _id: 0, host: "localhost:27017" }]
});

// Wait for PRIMARY state (prompt shows rs0 [primary])
db.runCommand({ hello: 1 });

/* Enables transactions, change streams, and
   matches Atlas-style topology for local testing */

rs.status();

// Shorter summary
rs.status().members.forEach(function (m) {
  print(m.name, "→", m.stateStr,
        "lag:", m.optimeDate ? "synced" : "n/a");
});

db.hello().primary;   // current primary host
db.hello().me;        // this node's role

mongo1:27017 → PRIMARY
mongo2:27017 → SECONDARY
mongo3:27017 → SECONDARY
ok: 1

db.orders.insertOne(
  { orderId: "ORD-9001", total: 149.99, status: "paid" },
  { writeConcern: { w: "majority", j: true, wtimeout: 5000 } }
);

/* w: "majority" → acknowledged on most voting members
   j: true        → journaled to disk on those members
   wtimeout       → fail fast instead of hanging forever */

{ acknowledged: true, insertedId: ObjectId("...") }

// In mongosh (secondaryOk required for direct secondary reads)
db.getMongo().setReadPref("secondaryPreferred");

db.products.find({ category: "electronics" }).limit(5);

/* Driver connection string equivalent:
   mongodb://host1,host2,host3/mydb
     ?replicaSet=rs0&readPreference=secondaryPreferred
*/

secondaryPreferred → secondary if available,
                       otherwise falls back to primary

// On the new host: start mongod with same --replSet rs0

// From mongosh connected to primary:
rs.add({ host: "mongo2.example.net:27017", priority: 1, votes: 1 });

rs.status();  // new member starts as STARTUP2, then SECONDARY

// Optional: adjust election priority (higher = preferred primary)
cfg = rs.conf();
cfg.members[1].priority = 0.5;
rs.reconfig(cfg);

New secondary copies all databases from primary
(state: STARTUP2) before becoming SECONDARY

📝 Notes

• Three members minimum for production—survives one failure with quorum for elections.
• Even member counts (2, 4) need careful tie-breaking; odd counts are simpler.
• Transactions and change streams require a replica set or sharded cluster—not standalone mongod.
• Replication lag on a secondary means stale reads—monitor before routing critical queries there.
• Backups: snapshot a secondary or use hidden/delayed members to avoid load on the primary.
• Atlas clusters are replica sets by default—no manual rs.initiate() required.
• Previous topic: Accumulators. Next: Sharding.

💡 Best Practices