Split View: MongoDB Sharding 완벽 가이드: 샤드 키 설계부터 운영 자동화까지

# docker-compose.yml
services:
  # Config Server Replica Set
  config-svr-1:
    image: mongo:7.0
    command: mongod --configsvr --replSet configRS --port 27019
    volumes:
      - config1-data:/data/db

  config-svr-2:
    image: mongo:7.0
    command: mongod --configsvr --replSet configRS --port 27019
    volumes:
      - config2-data:/data/db

  config-svr-3:
    image: mongo:7.0
    command: mongod --configsvr --replSet configRS --port 27019
    volumes:
      - config3-data:/data/db

  # Shard 1 Replica Set
  shard1-1:
    image: mongo:7.0
    command: mongod --shardsvr --replSet shard1RS --port 27018
    volumes:
      - shard1-1-data:/data/db

  shard1-2:
    image: mongo:7.0
    command: mongod --shardsvr --replSet shard1RS --port 27018
    volumes:
      - shard1-2-data:/data/db

  # Shard 2 Replica Set
  shard2-1:
    image: mongo:7.0
    command: mongod --shardsvr --replSet shard2RS --port 27018
    volumes:
      - shard2-1-data:/data/db

  shard2-2:
    image: mongo:7.0
    command: mongod --shardsvr --replSet shard2RS --port 27018
    volumes:
      - shard2-2-data:/data/db

  # Mongos Router
  mongos:
    image: mongo:7.0
    command: mongos --configdb configRS/config-svr-1:27019,config-svr-2:27019,config-svr-3:27019 --port 27017
    ports:
      - '27017:27017'
    depends_on:
      - config-svr-1
      - config-svr-2
      - config-svr-3

volumes:
  config1-data:
  config2-data:
  config3-data:
  shard1-1-data:
  shard1-2-data:
  shard2-1-data:
  shard2-2-data:

#!/bin/bash
# init-sharding.sh

# 1. Initialize Config Server Replica Set
docker exec -it config-svr-1 mongosh --port 27019 --eval '
rs.initiate({
  _id: "configRS",
  configsvr: true,
  members: [
    { _id: 0, host: "config-svr-1:27019" },
    { _id: 1, host: "config-svr-2:27019" },
    { _id: 2, host: "config-svr-3:27019" }
  ]
})'

# 2. Initialize Shard 1 Replica Set
docker exec -it shard1-1 mongosh --port 27018 --eval '
rs.initiate({
  _id: "shard1RS",
  members: [
    { _id: 0, host: "shard1-1:27018" },
    { _id: 1, host: "shard1-2:27018" }
  ]
})'

# 3. Initialize Shard 2 Replica Set
docker exec -it shard2-1 mongosh --port 27018 --eval '
rs.initiate({
  _id: "shard2RS",
  members: [
    { _id: 0, host: "shard2-1:27018" },
    { _id: 1, host: "shard2-2:27018" }
  ]
})'

sleep 10

# 4. Add Shards to the Cluster
docker exec -it mongos mongosh --eval '
sh.addShard("shard1RS/shard1-1:27018,shard1-2:27018");
sh.addShard("shard2RS/shard2-1:27018,shard2-2:27018");
'

// Range-based sharding - advantageous for continuous data queries
use mydb;
sh.enableSharding("mydb");

// Using created_at as shard key
db.orders.createIndex({ created_at: 1 });
sh.shardCollection("mydb.orders", { created_at: 1 });

// Advantage: Date range queries are processed on a single shard
db.orders.find({
  created_at: {
    $gte: ISODate("2026-03-01"),
    $lt: ISODate("2026-04-01")
  }
});

// Disadvantage: Latest data concentrates on a single shard (hotspot)

// Hash-based sharding - advantageous for even distribution
db.users.createIndex({ user_id: 'hashed' })
sh.shardCollection('mydb.users', { user_id: 'hashed' })

// Advantage: Writes are evenly distributed across all shards
// Disadvantage: Range queries scan all shards (scatter-gather)

// Pre-split chunks to prevent initial imbalance
sh.shardCollection('mydb.events', { event_id: 'hashed' }, false, {
  numInitialChunks: 64,
})

// Compound shard key - the most recommended pattern
db.orders.createIndex({ customer_id: 1, order_date: 1 })
sh.shardCollection('mydb.orders', { customer_id: 1, order_date: 1 })

// customer_id ensures cardinality
// order_date optimizes range queries

// This query is targeted (single shard)
db.orders.find({
  customer_id: 'C12345',
  order_date: { $gte: ISODate('2026-01-01') },
})

// Zone Sharding - ensures data locality
sh.addShardToZone('shard1RS', 'APAC')
sh.addShardToZone('shard2RS', 'EU')

// Set zone ranges
sh.updateZoneKeyRange(
  'mydb.users',
  { region: 'KR' },
  { region: 'KS' }, // Next string after KR
  'APAC'
)

sh.updateZoneKeyRange('mydb.users', { region: 'DE' }, { region: 'DF' }, 'EU')

// Korean user data is stored only on the APAC shard
// German user data is stored only on the EU shard

// resharding - changing the shard key
db.adminCommand({
  reshardCollection: 'mydb.orders',
  key: { customer_id: 1, order_date: 1 },
})

// Check progress
db.getSiblingDB('admin').aggregate([
  { $currentOp: { allUsers: true, localOps: false } },
  { $match: { type: 'op', 'originatingCommand.reshardCollection': { $exists: true } } },
])

// Check chunk status
use config;
db.chunks.find({ ns: "mydb.orders" }).sort({ min: 1 });

// Check chunk count
db.chunks.countDocuments({ ns: "mydb.orders" });

// Chunk distribution per shard
db.chunks.aggregate([
  { $match: { ns: "mydb.orders" } },
  { $group: { _id: "$shard", count: { $sum: 1 } } }
]);

// Manual chunk split
sh.splitAt("mydb.orders", { customer_id: "C50000", order_date: ISODate("2026-01-01") });

// Manual chunk move
sh.moveChunk("mydb.orders",
  { customer_id: "C50000", order_date: ISODate("2026-01-01") },
  "shard2RS"
);

// Check balancer status
sh.getBalancerState()
sh.isBalancerRunning()

// Limit balancer to run only outside business hours
db.settings.updateOne(
  { _id: 'balancer' },
  {
    $set: {
      activeWindow: { start: '02:00', stop: '06:00' },
    },
  },
  { upsert: true }
)

// Disable balancing for a specific collection (during migration)
sh.disableBalancing('mydb.orders')
// Re-enable
sh.enableBalancing('mydb.orders')

// Targeted Query - processed on a single shard (fast)
// Shard key is included in query conditions
db.orders.find({ customer_id: 'C12345' }).explain('executionStats')
// "winningPlan": { "stage": "SINGLE_SHARD" }

// Scatter-Gather Query - processed on all shards (slow)
// Shard key is NOT included in query conditions
db.orders.find({ product: 'iPhone' }).explain('executionStats')
// "winningPlan": { "stage": "SHARD_MERGE" }

// Broadcast Query - sent to all shards
db.orders.aggregate([{ $group: { _id: '$status', total: { $sum: '$amount' } } }])

// Full sharding status check
sh.status();
sh.status(true);  // Including detailed information

// Chunk migration history
use config;
db.changelog.find({ what: "moveChunk.commit" }).sort({ time: -1 }).limit(10);

// Currently ongoing migrations
db.locks.find({ _id: "balancer" });

// Data size per shard
db.adminCommand({ listDatabases: 1, nameOnly: false });

// Collection statistics
db.orders.stats()
db.orders.stats().sharded // true means sharded

// Document count per shard
db.orders.getShardDistribution()
// Shard shard1RS: data 2.5GB, docs 5,000,000, chunks 32
// Shard shard2RS: data 2.3GB, docs 4,800,000, chunks 30

// Add a new shard (no service interruption)
sh.addShard('shard3RS/shard3-1:27018,shard3-2:27018')

// The balancer automatically moves chunks to the new shard
// It takes time to complete the migration

// Remove a shard (draining)
db.adminCommand({ removeShard: 'shard2RS' })

// Check progress (run repeatedly)
db.adminCommand({ removeShard: 'shard2RS' })
// "state": "ongoing", "remaining": { "chunks": 15, "dbs": 0 }

// Check repeatedly until complete

# Full cluster backup with mongodump (through mongos)
mongodump --host mongos:27017 --out /backup/$(date +%Y%m%d)

# Or backup each shard's Replica Set individually
mongodump --host shard1-1:27018 --out /backup/shard1/$(date +%Y%m%d)
mongodump --host shard2-1:27018 --out /backup/shard2/$(date +%Y%m%d)