## 🎯 왜 NoSQL이 필요할까? 전통적인 DB의 한계를 넘어서 안녕! 오늘은 정말 재미있는 주제로 이야기해볼 거야. 바로 NoSQL 데이터베이스인데, 특히 MongoDB와 Cassandra라는 두 강력한 도구에 대해 깊이 파헤쳐볼 거야. 😊

먼저 이런 상황을 상상해봐. 너가 만든 앱이 갑자기 대박이 났어! 사용자가 하루에 10명에서 100만 명으로 폭발적으로 늘어났다고 생각해봐. 기존에 사용하던 MySQL이나 PostgreSQL 같은 관계형 데이터베이스(RDBMS)는 숨이 턱턱 막히기 시작할 거야. 왜 그럴까?

전통적인 관계형 데이터베이스는 ACID 속성(Atomicity, Consistency, Isolation, Durability)을 엄격하게 지키면서 데이터의 정합성을 보장해. 이건 정말 훌륭한 특성이지만, 대규모 트래픽과 빅데이터 환경에서는 병목현상이 발생할 수 있어. 특히 수평적 확장(Scale-out)이 어렵다는 게 큰 문제야.

이런 문제들을 해결하기 위해 등장한 게 바로 NoSQL이야! "Not Only SQL"의 약자로, SQL만이 아닌 다양한 방식으로 데이터를 다루겠다는 철학을 담고 있어. 🎨

## 📚 NoSQL의 4가지 주요 유형 이해하기 NoSQL은 크게 4가지 유형으로 나뉘어. 각각의 특징을 알아두면 어떤 상황에서 어떤 데이터베이스를 선택해야 할지 판단하기 쉬워져! 🤔

## 🍃 MongoDB: 개발자가 사랑하는 문서 지향 데이터베이스 자, 이제 본격적으로 MongoDB에 대해 알아볼까? MongoDB는 2009년에 등장한 이후로 개발자들 사이에서 폭발적인 인기를 얻었어. 그 이유가 뭘까? 🤩

1. 유연한 스키마 (Flexible Schema)

MongoDB의 가장 큰 매력은 바로 스키마리스(Schema-less) 구조야. 정확히는 "동적 스키마"라고 표현하는 게 맞아. 같은 컬렉션 안에 있는 문서들이 서로 다른 필드를 가질 수 있다는 뜻이야.

예를 들어볼게:

// 사용자 문서 1
{
  "_id": ObjectId("507f1f77bcf86cd799439011"),
  "name": "김철수",
  "email": "chulsoo@example.com",
  "age": 28
}

// 사용자 문서 2 - 추가 필드가 있어도 OK!
{
  "_id": ObjectId("507f1f77bcf86cd799439012"),
  "name": "이영희",
  "email": "younghee@example.com",
  "age": 32,
  "address": {
    "city": "서울",
    "district": "강남구"
  },
  "hobbies": ["독서", "여행", "요리"]
}

보다시피 두 번째 문서에는 address와 hobbies 필드가 추가되어 있지만 전혀 문제없어! 이런 유연성 덕분에 애자일 개발 환경에서 빠르게 프로토타입을 만들고 반복 개선하기에 정말 좋아. 🚀

2. 강력한 쿼리 언어

MongoDB는 풍부한 쿼리 기능을 제공해. SQL만큼이나 다양한 조건으로 데이터를 검색할 수 있어:

// 나이가 25세 이상이고 서울에 사는 사용자 찾기
db.users.find({
  age: { $gte: 25 },
  "address.city": "서울"
})

// 집계 파이프라인을 사용한 복잡한 분석
db.orders.aggregate([
  { $match: { status: "completed" } },
  { $group: { 
    _id: "$customerId", 
    totalAmount: { $sum: "$amount" } 
  }},
  { $sort: { totalAmount: -1 } },
  { $limit: 10 }
])

3. 수평적 확장 (Horizontal Scaling)

MongoDB는 샤딩(Sharding)을 통해 데이터를 여러 서버에 자동으로 분산시켜. 데이터가 늘어나면 서버를 추가하기만 하면 되니까 확장이 정말 쉬워! 💪

샤딩의 기본 구조를 살펴보면: 4. 복제와 고가용성 (Replication & High Availability)

MongoDB는 레플리카 셋(Replica Set)을 통해 데이터를 여러 서버에 복제해. 주 서버(Primary)가 다운되면 자동으로 부 서버(Secondary) 중 하나가 주 서버로 승격되어 서비스 중단 없이 운영할 수 있어! 🛡️

실제로 MongoDB를 어떻게 활용하는지 구체적인 예시를 들어볼게:

사례 1: 전자상거래 상품 카탈로그

전자상거래 사이트에서 상품 정보를 관리한다고 생각해봐. 상품마다 속성이 천차만별이야. 노트북은 CPU, RAM, 저장용량 같은 스펙이 필요하지만, 의류는 사이즈, 색상, 소재 정보가 필요하지. MongoDB의 유연한 스키마가 딱이야!

// 노트북 상품
{
  "productId": "LAPTOP001",
  "name": "고성능 게이밍 노트북",
  "category": "전자제품",
  "price": 1500000,
  "specs": {
    "cpu": "Intel i7-12700H",
    "ram": "16GB DDR5",
    "storage": "512GB NVMe SSD",
    "gpu": "RTX 3060"
  },
  "reviews": [
    {
      "userId": "user123",
      "rating": 5,
      "comment": "정말 빠르고 좋아요!",
      "date": ISODate("2024-01-15")
    }
  ]
}

// 의류 상품
{
  "productId": "SHIRT001",
  "name": "면 반팔 티셔츠",
  "category": "의류",
  "price": 29000,
  "sizes": ["S", "M", "L", "XL"],
  "colors": ["화이트", "블랙", "네이비"],
  "material": "면 100%",
  "reviews": []
}

사례 2: 실시간 로그 수집 및 분석

애플리케이션 로그를 실시간으로 수집하고 분석하는 시스템에도 MongoDB가 자주 사용돼. 로그 데이터는 구조가 다양하고 양이 많기 때문에 유연성과 확장성이 중요하거든.

// 애플리케이션 로그 문서
{
  "timestamp": ISODate("2024-01-20T10:30:45Z"),
  "level": "ERROR",
  "service": "payment-service",
  "message": "결제 처리 실패",
  "errorCode": "PAYMENT_GATEWAY_TIMEOUT",
  "userId": "user456",
  "metadata": {
    "orderId": "ORD123456",
    "amount": 50000,
    "gateway": "PG사A"
  },
  "stackTrace": "..."
}

MongoDB를 사용할 때 성능을 극대화하려면 몇 가지 중요한 포인트가 있어:

1. 인덱스 전략

적절한 인덱스는 쿼리 성능을 수십 배에서 수백 배까지 향상시킬 수 있어!

// 단일 필드 인덱스
db.users.createIndex({ email: 1 })

// 복합 인덱스 (자주 함께 조회되는 필드들)
db.orders.createIndex({ customerId: 1, orderDate: -1 })

// 텍스트 인덱스 (전문 검색용)
db.articles.createIndex({ title: "text", content: "text" })

// 지리공간 인덱스 (위치 기반 검색)
db.places.createIndex({ location: "2dsphere" })

2. 쿼리 최적화

• explain() 메서드로 쿼리 실행 계획을 분석해
• 필요한 필드만 선택해서 가져와 (Projection 사용)
• 페이지네이션 구현 시 skip()보다는 범위 쿼리 사용
• 대량 업데이트는 bulkWrite() 활용

3. 문서 설계 원칙

• 자주 함께 조회되는 데이터는 임베딩(Embedding)으로 한 문서에 포함
• 독립적으로 관리되어야 하는 데이터는 참조(Reference) 방식 사용
• 문서 크기는 16MB 제한을 고려 (일반적으로 수 KB 이내 권장)
• 배열 필드의 크기가 무한정 커지지 않도록 주의

## 🌟 Apache Cassandra: 분산 환경의 최강자 이제 Cassandra에 대해 알아볼 차례야! Cassandra는 Facebook에서 개발했다가 Apache 재단에 기증된 오픈소스 데이터베이스야. Netflix, Apple, Instagram 같은 글로벌 기업들이 사용하고 있어. 왜 이렇게 인기가 많을까? 🌐

1. 마스터리스 아키텍처 (Masterless Architecture)

Cassandra의 가장 큰 특징은 모든 노드가 동등하다는 거야! MongoDB의 레플리카 셋처럼 Primary-Secondary 구조가 아니라, 모든 노드가 읽기와 쓰기를 처리할 수 있어. 이를 피어-투-피어(Peer-to-Peer) 아키텍처라고 해. 🔄

이게 왜 중요하냐고? 단일 장애점(Single Point of Failure)이 없다는 뜻이야! 어떤 노드가 다운되어도 다른 노드들이 계속 서비스를 제공할 수 있어. 진정한 의미의 고가용성이지!

2. 선형적 확장성 (Linear Scalability)

Cassandra는 노드를 추가하면 성능이 거의 선형적으로 증가해. 노드가 2배가 되면 처리량도 거의 2배가 되는 거지. 이건 정말 놀라운 특성이야! 📈

3. 초고속 쓰기 성능

Cassandra는 쓰기 최적화 데이터베이스야. LSM Tree(Log-Structured Merge Tree) 구조를 사용해서 쓰기 작업이 엄청나게 빨라. 데이터를 먼저 메모리의 Memtable에 쓰고, 나중에 디스크의 SSTable로 플러시하는 방식이야. ⚡

쓰기 프로세스:

1. CommitLog에 먼저 기록 (내구성 보장)
2. Memtable(메모리)에 데이터 저장
3. Memtable이 가득 차면 SSTable(디스크)로 플러시
4. 주기적으로 SSTable들을 Compaction (병합 및 최적화)

4. 튜닝 가능한 일관성 (Tunable Consistency)

Cassandra는 CAP 정리에서 AP(Availability + Partition Tolerance)를 선택한 시스템이야. 하지만 일관성 레벨을 조정할 수 있어서 상황에 맞게 선택할 수 있어! 🎚️

Cassandra의 데이터 모델링은 관계형 DB나 MongoDB와는 완전히 다른 접근이 필요해. 쿼리 중심 설계가 핵심이야!

기본 개념:

• Keyspace: 데이터베이스와 유사한 최상위 컨테이너
• Table: 데이터를 저장하는 구조
• Partition Key: 데이터를 어느 노드에 저장할지 결정
• Clustering Key: 파티션 내에서 데이터 정렬 기준
• Primary Key: Partition Key + Clustering Key

예제: 시계열 센서 데이터

CREATE KEYSPACE sensor_data WITH replication = {
  'class': 'NetworkTopologyStrategy',
  'datacenter1': 3
};

CREATE TABLE sensor_readings (
  sensor_id text,
  reading_date date,
  reading_time timestamp,
  temperature decimal,
  humidity decimal,
  pressure decimal,
  PRIMARY KEY ((sensor_id, reading_date), reading_time)
) WITH CLUSTERING ORDER BY (reading_time DESC);

이 설계에서:
• sensor_id와 reading_date가 Partition Key (함께 해시되어 노드 결정)
• reading_time이 Clustering Key (시간 역순으로 정렬)
• 특정 센서의 특정 날짜 데이터를 빠르게 조회 가능

데이터 삽입:

INSERT INTO sensor_readings (
  sensor_id, reading_date, reading_time, 
  temperature, humidity, pressure
) VALUES (
  'SENSOR_001', '2024-01-20', '2024-01-20 14:30:00',
  23.5, 65.2, 1013.25
);

데이터 조회:

// 특정 센서의 오늘 데이터 조회
SELECT * FROM sensor_readings 
WHERE sensor_id = 'SENSOR_001' 
  AND reading_date = '2024-01-20'
ORDER BY reading_time DESC
LIMIT 100;

// 시간 범위 조회
SELECT * FROM sensor_readings 
WHERE sensor_id = 'SENSOR_001' 
  AND reading_date = '2024-01-20'
  AND reading_time >= '2024-01-20 10:00:00'
  AND reading_time < '2024-01-20 15:00:00';

사례 1: Netflix의 시청 기록 관리

Netflix는 수억 명의 사용자 시청 기록을 Cassandra로 관리해. 초당 수백만 건의 쓰기가 발생하는데, Cassandra의 뛰어난 쓰기 성능과 확장성이 완벽하게 들어맞는 거지!

사례 2: IoT 센서 데이터 수집

수천, 수만 개의 IoT 센서에서 실시간으로 데이터가 쏟아져 들어와. 시계열 데이터를 효율적으로 저장하고 조회하는 데 Cassandra가 최적이야. 시간 기반 파티셔닝으로 오래된 데이터는 자동으로 삭제(TTL)할 수도 있어!

사례 3: 메시징 시스템

대규모 채팅 애플리케이션이나 메시징 시스템에서도 Cassandra가 자주 사용돼. 사용자별로 메시지를 빠르게 저장하고 조회할 수 있거든.

CREATE TABLE messages (
  user_id uuid,
  conversation_id uuid,
  message_time timestamp,
  message_id uuid,
  sender_id uuid,
  content text,
  PRIMARY KEY ((user_id, conversation_id), message_time, message_id)
) WITH CLUSTERING ORDER BY (message_time DESC, message_id DESC);

1. 복제 전략 (Replication Strategy)

• SimpleStrategy: 단일 데이터센터 환경 (개발/테스트용)
• NetworkTopologyStrategy: 다중 데이터센터 환경 (프로덕션 권장)

// 다중 데이터센터 복제 설정
CREATE KEYSPACE my_app WITH replication = {
  'class': 'NetworkTopologyStrategy',
  'dc1': 3,  // 데이터센터1에 3개 복제본
  'dc2': 2   // 데이터센터2에 2개 복제본
};

2. Compaction 전략

Cassandra는 주기적으로 SSTable을 병합하는 Compaction 작업을 수행해. 전략에 따라 성능이 크게 달라져!

• SizeTieredCompactionStrategy (STCS): 기본 전략, 쓰기 위주 워크로드
• LeveledCompactionStrategy (LCS): 읽기 위주 워크로드, 공간 효율적
• TimeWindowCompactionStrategy (TWCS): 시계열 데이터, TTL 사용 시 최적

3. 모니터링 포인트

• Read/Write Latency: 응답 시간 추적
• Pending Tasks: 대기 중인 작업 수
• Compaction 상태: 디스크 I/O 영향
• Heap Memory 사용률: GC 성능 영향
• Disk Space: SSTable 크기 모니터링

## 🔄 MongoDB vs Cassandra: 어떤 걸 선택해야 할까? 자, 이제 가장 중요한 질문이야. MongoDB와 Cassandra 중에서 어떤 걸 선택해야 할까? 정답은... "상황에 따라 다르다"야! 😅 각각의 강점이 다르니까 프로젝트 요구사항을 잘 분석해야 해.

## 🛠️ 실전 구축 가이드: 처음부터 끝까지 이론만 알아서는 부족하지! 실제로 어떻게 구축하고 운영하는지 알아보자. 😊

1단계: 레플리카 셋 구성

프로덕션 환경에서는 최소 3개 노드로 레플리카 셋을 구성해야 해. 홀수 개의 노드를 사용하는 게 선거(Election) 과정에서 유리해!

// mongod.conf 설정 (각 노드)
replication:
  replSetName: "myReplicaSet"

net:
  bindIp: 0.0.0.0
  port: 27017

storage:
  dbPath: /var/lib/mongodb
  journal:
    enabled: true

// 레플리카 셋 초기화 (Primary 노드에서)
rs.initiate({
  _id: "myReplicaSet",
  members: [
    { _id: 0, host: "mongodb1.example.com:27017" },
    { _id: 1, host: "mongodb2.example.com:27017" },
    { _id: 2, host: "mongodb3.example.com:27017" }
  ]
})

// 상태 확인
rs.status()

2단계: 샤딩 클러스터 구성

대규모 데이터를 다룬다면 샤딩이 필수야!

// Config Server 시작 (3개 권장)
mongod --configsvr --replSet configReplSet --port 27019

// Mongos (쿼리 라우터) 시작
mongos --configdb configReplSet/config1:27019,config2:27019,config3:27019

// Shard 추가
sh.addShard("shard1/mongodb4:27017,mongodb5:27017,mongodb6:27017")
sh.addShard("shard2/mongodb7:27017,mongodb8:27017,mongodb9:27017")

// 데이터베이스 샤딩 활성화
sh.enableSharding("myDatabase")

// 컬렉션 샤딩 (해시 기반)
sh.shardCollection("myDatabase.users", { userId: "hashed" })

// 또는 범위 기반 샤딩
sh.shardCollection("myDatabase.orders", { customerId: 1, orderDate: 1 })

3단계: 보안 설정

// 인증 활성화
security:
  authorization: enabled
  keyFile: /path/to/keyfile

// 관리자 계정 생성
use admin
db.createUser({
  user: "admin",
  pwd: "securePassword123!",
  roles: [ { role: "root", db: "admin" } ]
})

// 애플리케이션 사용자 생성
use myDatabase
db.createUser({
  user: "appUser",
  pwd: "appPassword456!",
  roles: [ 
    { role: "readWrite", db: "myDatabase" },
    { role: "read", db: "analytics" }
  ]
})

1단계: 노드 설정

Cassandra는 모든 노드가 동등하므로 각 노드에 동일한 설정을 적용해.

# cassandra.yaml 주요 설정
cluster_name: 'MyCluster'

# Seed 노드 지정 (클러스터 발견용)
seed_provider:
  - class_name: org.apache.cassandra.locator.SimpleSeedProvider
    parameters:
      - seeds: "192.168.1.10,192.168.1.11,192.168.1.12"

# 노드 간 통신
listen_address: 192.168.1.10
rpc_address: 0.0.0.0

# 데이터 디렉토리
data_file_directories:
  - /var/lib/cassandra/data

commitlog_directory: /var/lib/cassandra/commitlog

# 스니치 설정 (네트워크 토폴로지)
endpoint_snitch: GossipingPropertyFileSnitch

2단계: 클러스터 구성

# 첫 번째 노드 시작
cassandra -R

# 다른 노드들 순차적으로 시작
# 각 노드가 자동으로 클러스터에 조인됨

# 클러스터 상태 확인
nodetool status

# 출력 예시:
# Datacenter: dc1
# Status=Up/Down
# State=Normal/Leaving/Joining/Moving
# --  Address        Load       Tokens  Owns    Host ID
# UN  192.168.1.10   1.2 TB     256     33.3%   abc123...
# UN  192.168.1.11   1.1 TB     256     33.4%   def456...
# UN  192.168.1.12   1.3 TB     256     33.3%   ghi789...

3단계: Keyspace 및 테이블 생성

// CQL Shell 접속
cqlsh

// Keyspace 생성
CREATE KEYSPACE my_app WITH replication = {
  'class': 'NetworkTopologyStrategy',
  'dc1': 3
} AND durable_writes = true;

// 사용자 테이블
CREATE TABLE my_app.users (
  user_id uuid PRIMARY KEY,
  username text,
  email text,
  created_at timestamp,
  last_login timestamp
);

// 사용자 활동 로그 (시계열)
CREATE TABLE my_app.user_activity (
  user_id uuid,
  activity_date date,
  activity_time timestamp,
  activity_type text,
  details map<text, text>,
  PRIMARY KEY ((user_id, activity_date), activity_time)
) WITH CLUSTERING ORDER BY (activity_time DESC)
  AND compaction = {
    'class': 'TimeWindowCompactionStrategy',
    'compaction_window_unit': 'DAYS',
    'compaction_window_size': 1
  }
  AND default_time_to_live = 2592000;  // 30일 후 자동 삭제

4단계: 보안 설정

# cassandra.yaml에 인증 활성화
authenticator: PasswordAuthenticator
authorizer: CassandraAuthorizer

# 기본 cassandra 계정으로 로그인 후 새 관리자 생성
CREATE ROLE admin WITH PASSWORD = 'securePassword123!' 
  AND SUPERUSER = true 
  AND LOGIN = true;

# 애플리케이션 사용자 생성
CREATE ROLE app_user WITH PASSWORD = 'appPassword456!' 
  AND LOGIN = true;

GRANT ALL PERMISSIONS ON KEYSPACE my_app TO app_user;

## 💻 애플리케이션 연동: 코드로 보는 실전 예제 이제 실제 애플리케이션에서 어떻게 사용하는지 코드로 알아보자! Node.js 예제를 중심으로 설명할게. 🖥️

설치 및 연결:

// npm install mongodb
const { MongoClient } = require('mongodb');

const uri = "mongodb://username:password@mongodb1:27017,mongodb2:27017,mongodb3:27017/myDatabase?replicaSet=myReplicaSet";
const client = new MongoClient(uri, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
  maxPoolSize: 50,
  wtimeoutMS: 2500
});

async function connectDB() {
  try {
    await client.connect();
    console.log("MongoDB 연결 성공!");
    return client.db("myDatabase");
  } catch (error) {
    console.error("연결 실패:", error);
    throw error;
  }
}

CRUD 작업:

const db = await connectDB();
const usersCollection = db.collection('users');

// Create - 사용자 생성
async function createUser(userData) {
  const result = await usersCollection.insertOne({
    username: userData.username,
    email: userData.email,
    profile: {
      firstName: userData.firstName,
      lastName: userData.lastName,
      age: userData.age
    },
    createdAt: new Date(),
    tags: userData.tags || []
  });
  return result.insertedId;
}

// Read - 사용자 조회
async function findUserByEmail(email) {
  return await usersCollection.findOne({ email: email });
}

// Read - 복잡한 쿼리
async function findActiveUsers(minAge) {
  return await usersCollection.find({
    'profile.age': { $gte: minAge },
    status: 'active',
    lastLogin: { $gte: new Date(Date.now() - 30*24*60*60*1000) }
  })
  .sort({ lastLogin: -1 })
  .limit(100)
  .toArray();
}

// Update - 사용자 정보 수정
async function updateUserProfile(userId, updates) {
  return await usersCollection.updateOne(
    { _id: userId },
    { 
      $set: { 
        'profile.firstName': updates.firstName,
        'profile.lastName': updates.lastName,
        updatedAt: new Date()
      },
      $push: { tags: updates.newTag }
    }
  );
}

// Delete - 사용자 삭제
async function deleteUser(userId) {
  return await usersCollection.deleteOne({ _id: userId });
}

// 집계 파이프라인 - 통계 분석
async function getUserStatsByAge() {
  return await usersCollection.aggregate([
    {
      $match: { status: 'active' }
    },
    {
      $group: {
        _id: {
          $floor: { $divide: ['$profile.age', 10] }
        },
        count: { $sum: 1 },
        avgAge: { $avg: '$profile.age' }
      }
    },
    {
      $project: {
        ageGroup: { $multiply: ['$_id', 10] },
        count: 1,
        avgAge: { $round: ['$avgAge', 1] }
      }
    },
    {
      $sort: { ageGroup: 1 }
    }
  ]).toArray();
}

트랜잭션 사용:

// MongoDB 4.0+ 에서 다중 문서 트랜잭션 지원
async function transferPoints(fromUserId, toUserId, points) {
  const session = client.startSession();
  
  try {
    await session.withTransaction(async () => {
      const usersCollection = db.collection('users');
      
      // 포인트 차감
      await usersCollection.updateOne(
        { _id: fromUserId },
        { $inc: { points: -points } },
        { session }
      );
      
      // 포인트 추가
      await usersCollection.updateOne(
        { _id: toUserId },
        { $inc: { points: points } },
        { session }
      );
      
      // 거래 기록
      const transactionsCollection = db.collection('transactions');
      await transactionsCollection.insertOne({
        fromUser: fromUserId,
        toUser: toUserId,
        amount: points,
        timestamp: new Date()
      }, { session });
    });
    
    console.log("트랜잭션 성공!");
  } catch (error) {
    console.error("트랜잭션 실패:", error);
    throw error;
  } finally {
    await session.endSession();
  }
}

설치 및 연결:

// npm install cassandra-driver
const cassandra = require('cassandra-driver');

const client = new cassandra.Client({
  contactPoints: ['192.168.1.10', '192.168.1.11', '192.168.1.12'],
  localDataCenter: 'dc1',
  keyspace: 'my_app',
  credentials: {
    username: 'app_user',
    password: 'appPassword456!'
  },
  pooling: {
    coreConnectionsPerHost: {
      [cassandra.types.distance.local]: 2,
      [cassandra.types.distance.remote]: 1
    }
  }
});

async function connectCassandra() {
  try {
    await client.connect();
    console.log("Cassandra 연결 성공!");
  } catch (error) {
    console.error("연결 실패:", error);
    throw error;
  }
}

CRUD 작업:

// Create - 사용자 생성
async function createUser(userData) {
  const query = `
    INSERT INTO users (user_id, username, email, created_at)
    VALUES (?, ?, ?, ?)
  `;
  const params = [
    cassandra.types.Uuid.random(),
    userData.username,
    userData.email,
    new Date()
  ];
  
  await client.execute(query, params, { prepare: true });
}

// Read - 사용자 조회
async function getUserById(userId) {
  const query = 'SELECT * FROM users WHERE user_id = ?';
  const result = await client.execute(query, [userId], { prepare: true });
  return result.rows[0];
}

// 시계열 데이터 삽입
async function logUserActivity(userId, activityType, details) {
  const query = `
    INSERT INTO user_activity 
    (user_id, activity_date, activity_time, activity_type, details)
    VALUES (?, ?, ?, ?, ?)
  `;
  const now = new Date();
  const params = [
    userId,
    cassandra.types.LocalDate.fromDate(now),
    now,
    activityType,
    details
  ];
  
  await client.execute(query, params, { prepare: true });
}

// 시계열 데이터 조회
async function getUserActivityToday(userId) {
  const query = `
    SELECT * FROM user_activity
    WHERE user_id = ? AND activity_date = ?
    ORDER BY activity_time DESC
    LIMIT 100
  `;
  const today = cassandra.types.LocalDate.fromDate(new Date());
  const result = await client.execute(
    query, 
    [userId, today], 
    { prepare: true }
  );
  return result.rows;
}

// 배치 작업
async function batchInsertActivities(activities) {
  const queries = activities.map(activity => ({
    query: `
      INSERT INTO user_activity 
      (user_id, activity_date, activity_time, activity_type, details)
      VALUES (?, ?, ?, ?, ?)
    `,
    params: [
      activity.userId,
      cassandra.types.LocalDate.fromDate(activity.timestamp),
      activity.timestamp,
      activity.type,
      activity.details
    ]
  }));
  
  await client.batch(queries, { prepare: true });
}

// 일관성 레벨 지정
async function criticalRead(userId) {
  const query = 'SELECT * FROM users WHERE user_id = ?';
  const result = await client.execute(
    query, 
    [userId], 
    { 
      prepare: true,
      consistency: cassandra.types.consistencies.quorum
    }
  );
  return result.rows[0];
}

## 📈 성능 모니터링과 튜닝 전략 데이터베이스를 구축했다고 끝이 아니야! 지속적인 모니터링과 튜닝이 필요해. 🔍

주요 모니터링 지표:

모니터링 명령어:

// 서버 상태 확인
db.serverStatus()

// 현재 작업 확인
db.currentOp()

// 느린 쿼리 프로파일링
db.setProfilingLevel(1, { slowms: 100 })  // 100ms 이상 쿼리 기록
db.system.profile.find().sort({ ts: -1 }).limit(10)

// 인덱스 사용 통계
db.collection.aggregate([{ $indexStats: {} }])

// 데이터베이스 통계
db.stats()

// 컬렉션 통계
db.collection.stats()

성능 튜닝 체크리스트:

✅ 인덱스 최적화
• 자주 조회되는 필드에 인덱스 생성
• 복합 인덱스 순서 최적화 (선택도가 높은 필드를 앞에)
• 사용하지 않는 인덱스 제거
• 커버링 인덱스 활용 (쿼리가 인덱스만으로 처리)

✅ 쿼리 최적화
• explain()로 실행 계획 분석
• 필요한 필드만 프로젝션
• 정규표현식 사용 최소화
• $or 대신 $in 사용 고려

✅ 하드웨어 및 설정
• 충분한 RAM 확보 (Working Set이 메모리에 들어가도록)
• SSD 사용 권장
• WiredTiger 캐시 크기 조정
• 적절한 Read/Write Concern 설정

주요 모니터링 지표:

모니터링 명령어:

# 클러스터 상태
nodetool status

# 노드 정보
nodetool info

# 성능 통계
nodetool tablestats my_app.users

# Compaction 상태
nodetool compactionstats

# 프록시 히스토그램 (지연 시간 분포)
nodetool proxyhistograms

# 스레드풀 상태
nodetool tpstats

# GC 통계
nodetool gcstats

# 특정 테이블 플러시
nodetool flush my_app users

성능 튜닝 체크리스트:

✅ 데이터 모델 최적화
• 쿼리 패턴에 맞는 파티션 키 설계
• 파티션 크기 100MB 이하 유지
• 적절한 Clustering Key로 정렬 최적화
• 필요시 비정규화로 조인 회피

✅ Compaction 전략
• 워크로드에 맞는 Compaction 전략 선택
• 시계열 데이터는 TWCS 사용
• Compaction 스케줄 조정

✅ 하드웨어 및 JVM 설정
• 충분한 RAM (최소 8GB, 권장 32GB+)
• SSD 사용 필수
• JVM 힙 크기 조정 (물리 메모리의 1/4 ~ 1/2)
• G1GC 사용 권장

✅ 일관성 및 복제
• 적절한 복제 계수 설정 (일반적으로 3)
• 일관성 레벨 최적화
• Hinted Handoff 활용

## 🎓 실무에서 배운 교훈과 베스트 프랙티스 이론과 실전은 다르지! 실제 프로젝트에서 겪은 경험을 바탕으로 중요한 교훈들을 공유할게. 💡

## 🚀 미래 트렌드와 발전 방향 NoSQL 데이터베이스의 미래는 어떻게 될까? 최신 트렌드를 살펴보자! 🔮

1. 멀티 클라우드 지원 강화

MongoDB Atlas는 AWS, Azure, GCP를 넘나들며 데이터를 관리할 수 있어. 클라우드 벤더 종속을 피하고 최적의 환경을 선택할 수 있지!

2. 서버리스 인스턴스

사용한 만큼만 비용을 지불하는 서버리스 MongoDB가 등장했어. 트래픽 변동이 큰 애플리케이션에 완벽해!

3. 시계열 컬렉션

MongoDB 5.0부터 시계열 데이터를 위한 최적화된 컬렉션 타입이 추가됐어. IoT, 모니터링 데이터 처리가 훨씬 효율적이야!

4. 네이티브 분석 기능

MongoDB Atlas Data Lake를 통해 S3의 데이터도 직접 쿼리할 수 있어. 별도의 ETL 없이 분석이 가능해졌지!

1. Cassandra 4.0의 혁신

• Virtual Tables로 시스템 정보 조회 개선
• Audit Logging 기본 지원
• Zero Copy Streaming으로 노드 추가 속도 향상
• Full Query Logging으로 디버깅 강화

2. Kubernetes 네이티브

K8ssandra 프로젝트를 통해 Kubernetes에서 Cassandra를 쉽게 운영할 수 있어. 컨테이너 환경에 최적화!

3. DataStax Astra

완전 관리형 Cassandra 서비스로, 운영 부담 없이 Cassandra의 강력함을 활용할 수 있어!

4. 머신러닝 통합

Cassandra에 저장된 대규모 데이터를 Spark와 연동해서 실시간 ML 파이프라인 구축이 가능해!

## 🎬 마무리하며 와! 여기까지 정말 긴 여정이었어. MongoDB와 Cassandra에 대해 깊이 있게 알아봤지? 😊

핵심을 정리하자면:

어떤 데이터베이스를 선택할지는 프로젝트의 요구사항에 달려있어! 복잡한 쿼리와 유연성이 필요하면 MongoDB, 대규모 쓰기와 고가용성이 중요하면 Cassandra를 선택하면 돼. 때로는 두 가지를 함께 사용하는 하이브리드 접근도 좋은 선택이야! 🎯

NoSQL 데이터베이스는 계속 진화하고 있어. 새로운 기능들이 추가되고, 성능이 개선되고, 사용하기 쉬워지고 있지. 지속적으로 학습하고 실험하면서 최적의 솔루션을 찾아가는 게 중요해!

데이터베이스 구축이나 최적화에 어려움을 겪고 있다면, 재능넷에서 경험 많은 전문가들의 도움을 받아보는 것도 좋은 방법이야. 혼자 고민하지 말고, 함께 해결해나가자! 💪

이 글이 NoSQL 데이터베이스를 이해하고 활용하는 데 도움이 되었기를 바라! 궁금한 점이 있다면 언제든지 커뮤니티에 질문하고, 계속 학습하면서 성장해나가자. 화이팅! 🚀✨