MongoDB Architecture

# mongod startup — key configuration options

mongod_config = {
    "process": "mongod",
    "default_port": 27017,
    "responsibilities": [
        "Accept client connections",
        "Process read and write operations",
        "Manage data files and indexes on disk",
        "Enforce authentication and authorisation",
        "Replicate data to/from other replica set members",
        "Run background maintenance tasks (compaction, TTL cleanup)"
    ],
    "key_config_options": {
        "--dbpath":    "/data/db",          # where data files are stored
        "--port":      27017,               # port to listen on
        "--logpath":   "/var/log/mongod.log",
        "--replSet":   "rs0",              # replica set name
        "--auth":      True,               # require authentication
        "--bind_ip":   "127.0.0.1"         # which IP to accept connections from
    }
}

for option, value in mongod_config["key_config_options"].items():
    print(f"  {option}: {value}")

# WiredTiger storage engine — key characteristics

wiredtiger = {
    "concurrency_model": "Document-level locking",
    # Only the specific document being written is locked
    # Other documents in the same collection can be read/written simultaneously
    # This is far more granular than table-level locking used by older engines

    "compression": {
        "data":    "Snappy (default) or zlib / zstd",
        "indexes": "Prefix compression"
        # Snappy: fast compression, moderate ratio
        # zlib / zstd: higher compression, slightly slower
    },

    "cache": "50% of RAM by default (or 1GB minimum)",
    # WiredTiger keeps frequently accessed data in memory
    # Data is read from disk only when not in the cache

    "checkpoints": "Every 60 seconds or 2GB of journal data",
    # Checkpoint = consistent snapshot written to disk
    # Allows fast recovery after a crash

    "journaling": "Write-ahead log (WAL) for durability",
    # Every write is recorded in the journal before being applied
    # Ensures no data loss even if mongod crashes mid-write
}

for key, value in wiredtiger.items():
    print(f"{key}: {value}")

# Replica set architecture — roles and data flow

replica_set_architecture = {
    "PRIMARY": {
        "role": "Receives all writes from clients",
        "count": "Always exactly one at any time",
        "writes_to": "Its own data, then oplog",
    },
    "SECONDARY": {
        "role": "Replicates from primary via oplog",
        "count": "One or more",
        "can_serve": "Read operations (if read preference allows)",
    },
    "ARBITER": {
        "role": "Votes in elections but holds no data",
        "use_case": "Keeps replica set member count odd for clean elections",
        "note": "Use only when a full data-bearing member is not possible"
    }
}

# The oplog — operations log
oplog_concept = {
    "what_it_is": "A capped collection in the 'local' database",
    "what_it_stores": "Every write operation applied to the primary",
    "how_secondaries_use_it": "Poll the oplog and replay operations",
    "size": "5% of disk space by default (configurable)"
}

print("Replica Set Members:")
for role, details in replica_set_architecture.items():
    print(f"  {role}: {details['role']}")

print("\nOplog:", oplog_concept["what_it_is"])

# Sharded cluster — three component types

sharded_cluster = {
    "SHARDS": {
        "what": "Each shard is a replica set holding a subset of the data",
        "example": "Shard A holds user_id 1–1M, Shard B holds user_id 1M–2M",
        "minimum": "2 shards (but 3+ recommended for production)"
    },
    "CONFIG_SERVERS": {
        "what": "A replica set storing cluster metadata and shard key mappings",
        "stores": [
            "Which chunks of data live on which shard",
            "Shard key ranges (chunk map)",
            "Cluster topology"
        ],
        "minimum": "3-node replica set for production"
    },
    "MONGOS": {
        "what": "Query router — the entry point for all client connections",
        "role": [
            "Receives queries from the application",
            "Reads chunk map from config servers",
            "Routes query to the correct shard(s)",
            "Merges results and returns to client"
        ],
        "note": "Stateless — can run multiple mongos instances for load balancing"
    }
}

for component, details in sharded_cluster.items():
    print(f"{component}: {details['what']}")

# Full production architecture — component diagram in code

production_deployment = {
    "client_applications": ["App Server 1", "App Server 2", "App Server 3"],

    "mongos_routers": ["mongos-1:27017", "mongos-2:27017"],
    # Multiple mongos instances for load balancing and redundancy

    "config_server_replica_set": {
        "name": "configRS",
        "members": ["cfg1:27019", "cfg2:27019", "cfg3:27019"]
    },

    "shards": {
        "shard_a": {
            "replica_set": "shardA",
            "members": ["sA-1:27018", "sA-2:27018", "sA-3:27018"],
            "data": "user_id: 1 → 1,000,000"
        },
        "shard_b": {
            "replica_set": "shardB",
            "members": ["sB-1:27018", "sB-2:27018", "sB-3:27018"],
            "data": "user_id: 1,000,001 → 2,000,000"
        },
        "shard_c": {
            "replica_set": "shardC",
            "members": ["sC-1:27018", "sC-2:27018", "sC-3:27018"],
            "data": "user_id: 2,000,001 → 3,000,000"
        }
    }
}

total_nodes = (
    len(production_deployment["mongos_routers"]) +
    len(production_deployment["config_server_replica_set"]["members"]) +
    sum(len(s["members"]) for s in production_deployment["shards"].values())
)
print(f"Total MongoDB processes in this cluster: {total_nodes}")

# Data flow — read and write paths

read_path = [
    "1. Client sends find() query to mongos (or mongod directly)",
    "2. mongos checks config servers for chunk routing",
    "3. Query routed to correct shard(s)",
    "4. mongod checks WiredTiger cache — is the data in memory?",
    "5a. Cache HIT  — return data directly from RAM (fast)",
    "5b. Cache MISS — read from disk into cache, then return (slower)",
    "6. Results returned to mongos → merged → returned to client"
]

write_path = [
    "1. Client sends insertOne/updateOne to mongos (or mongod)",
    "2. Write recorded in WiredTiger journal (WAL) — durability guaranteed",
    "3. Write applied to WiredTiger cache (in memory)",
    "4. Write appended to oplog (for replication to secondaries)",
    "5. Secondaries read oplog and replay the operation",
    "6. WiredTiger checkpoint flushes cache to disk every 60 seconds"
]

print("READ PATH:")
for step in read_path:
    print(f"  {step}")

print("\nWRITE PATH:")
for step in write_path:
    print(f"  {step}")