마스터하기: CAP 이론과 분산 시스템의 데이터 일관성 모델 - 복잡한 세상 속 데이터의 약속

안녕하세요, 10년 경력의 소프트웨어 엔지니어이자 기술 교육자입니다. 현대 소프트웨어 시스템은 거의 대부분 분산 환경에서 운영됩니다. 클라우드 서비스, 마이크로서비스 아키텍처, 빅데이터 플랫폼 등 모든 곳에서 여러 서버가 협력하여 데이터를 처리하고 서비스를 제공하죠. 이 분산 시스템을 설계할 때 우리가 반드시 이해하고 넘어가야 할 핵심 개념이 바로 **CAP 이론(CAP Theorem)**과 다양한 **데이터 일관성 모델(Consistency Models)**입니다.

이 주제는 면접에서도 자주 등장하며, 실무에서 특정 데이터베이스나 아키텍처를 선택할 때 결정적인 영향을 미칩니다. 하지만 종종 잘못 이해되거나, 그 중요성이 간과되기도 합니다. 이번 글을 통해 CAP 이론과 데이터 일관성 모델의 본질을 명확히 이해하고, 여러분의 시스템 설계 역량을 한 단계 끌어올릴 수 있도록 돕겠습니다.

1. 개념 소개: 정의, 탄생 배경, 왜 중요한지

CAP 이론의 정의

CAP 이론은 2000년 에릭 브루어(Eric Brewer) 교수가 제안하고 나중에 증명된 정리로, 분산 컴퓨팅 시스템은 일관성(Consistency), 가용성(Availability), 분할 허용성(Partition Tolerance)의 세 가지 속성 중 최대 두 가지만 동시에 만족할 수 있다는 것을 의미합니다.

• C (Consistency, 일관성): 모든 클라이언트가 같은 시점에 같은 데이터를 봐야 한다는 것을 의미합니다. 특정 노드에 데이터가 기록되면, 이후의 모든 읽기 요청은 해당 최신 데이터를 반환해야 합니다. 이는 ACID 트랜잭션의 '일관성'과는 다른 개념으로, 분산 시스템에서 데이터의 '동일성'에 가깝습니다. (ACID의 C는 트랜잭션이 완료된 후에도 데이터베이스의 제약 조건이 유지된다는 논리적 일관성을 의미합니다.)
• A (Availability, 가용성): 시스템의 모든 요청에 대해 항상 응답해야 한다는 것을 의미합니다. 어떤 노드에 장애가 발생하더라도, 남은 노드들이 요청을 처리하여 서비스가 중단되지 않아야 합니다. 즉, 시스템이 항상 작동 가능한 상태여야 합니다.
• P (Partition Tolerance, 분할 허용성): 분산 시스템의 노드들 사이에 네트워크 단절(파티션)이 발생하더라도 시스템이 계속 작동해야 한다는 것을 의미합니다. 네트워크는 불안정하며 언제든 장애가 발생할 수 있으므로, 현대의 모든 분산 시스템은 이 P를 반드시 만족해야 합니다.

탄생 배경

CAP 이론은 2000년대 초, 웹 규모의 애플리케이션이 등장하고 분산 시스템의 필요성이 커지면서 주목받기 시작했습니다. 기존의 관계형 데이터베이스(RDBMS)는 주로 단일 서버 환경이나 제한적인 분산 환경에서 ACID 속성을 보장했지만, 대규모 트래픽과 높은 확장성을 요구하는 인터넷 서비스에는 한계가 있었습니다. 여러 서버에 데이터를 분산 저장하고 처리해야 할 때, 네트워크 장애와 같은 현실적인 문제에 직면하면서 데이터의 일관성, 시스템의 가용성, 그리고 장애 허용성 사이의 복잡한 트레이드오프가 중요한 연구 주제가 되었고, 그 결과 CAP 이론이 정립되었습니다.

왜 중요한가?

CAP 이론은 분산 시스템을 설계할 때 가장 기본적인 지침이자 제약 조건입니다. 특정 데이터베이스나 아키텍처를 선택하기 전에, 우리가 어떤 속성을 우선시하고 어떤 속성을 희생할 것인지를 명확히 해야 합니다.

• 시스템 설계의 나침반: 트레이드오프를 이해하면 비즈니스 요구사항에 맞는 올바른 기술 스택과 아키텍처를 선택할 수 있습니다.
• NoSQL 데이터베이스 이해의 핵심: Cassandra, MongoDB, Redis 등 다양한 NoSQL 데이터베이스들이 어떤 CAP 속성을 지향하는지 이해하는 데 필수적입니다.
• 문제 해결 능력 향상: 분산 시스템에서 발생하는 데이터 불일치나 서비스 중단 문제를 분석하고 해결하는 데 기반 지식이 됩니다.

2. 핵심 원리 설명 (비유와 다이어그램 활용)

CAP 이론의 핵심은 "세 가지 속성 중 두 가지만 선택할 수 있다"는 것입니다. 우리는 P(분할 허용성)를 포기할 수 없으므로, 사실상 C(일관성)와 A(가용성) 중 하나를 선택해야 한다는 의미로 해석할 수 있습니다.

CAP 이론의 선택지

1. CP 시스템 (Consistency + Partition Tolerance):

   • 특징: 네트워크 분할이 발생하면 일관성을 유지하기 위해 가용성을 희생합니다. 즉, 분할된 네트워크의 일부 노드는 요청을 처리하지 못하고 오류를 반환하거나 대기합니다.
   • 비유: 은행의 ATM 시스템을 생각해보세요. 만약 본점 서버와 지점 서버 간의 네트워크가 단절된다면, 지점 ATM은 고객의 잔액이 정확하지 않을 수 있으므로 거래를 중단하고 "서비스 불가능" 메시지를 띄울 것입니다. 돈이 잘못 인출되거나 이체되는 것보다는 잠시 사용 불가능한 것이 더 안전하기 때문입니다.
   • 예시: 전통적인 RDBMS (분산 환경에서), MongoDB (특정 설정), Redis Sentinel/Cluster (Primary-Replica 모델), Apache ZooKeeper.

2. AP 시스템 (Availability + Partition Tolerance):

   • 특징: 네트워크 분할이 발생하더라도 가용성을 유지하기 위해 일관성을 희생합니다. 즉, 분할된 네트워크의 각 노드는 독립적으로 요청을 처리하며, 이 과정에서 일시적인 데이터 불일치가 발생할 수 있습니다.
   • 비유: 친구들과 사용하는 메신저 앱의 채팅방을 생각해보세요. 만약 일시적인 네트워크 문제로 한 친구의 메시지가 다른 친구에게 바로 전달되지 않더라도, 앱은 계속 메시지를 보내고 받을 수 있습니다. 잠시 메시지 순서가 뒤섞이거나 늦게 도착하더라도 앱 자체가 멈추는 것보다는 낫습니다. 결국 모든 메시지는 최종적으로 동기화됩니다.
   • 예시: Apache Cassandra, Amazon DynamoDB, CouchDB, Riak.

3. CA 시스템 (Consistency + Availability):

   • 특징: 분할 허용성을 포기합니다. 즉, 네트워크 분할이 발생하면 시스템 전체가 중단됩니다. 이는 사실상 분산 시스템이 아니거나, 분산 시스템의 실패를 가정하지 않는 경우에 해당합니다. 현대의 대규모 분산 시스템에서는 거의 고려되지 않습니다.
   • 예시: 단일 서버에서 운영되는 전통적인 RDBMS.

다양한 일관성 모델

CAP 이론은 분산 시스템의 큰 틀에서의 트레이드오프를 설명하지만, 실제로는 다양한 수준의 일관성 모델이 존재합니다.

• 강한 일관성 (Strong Consistency):

  • 선형화 가능성 (Linearizability): 가장 강력한 일관성 모델입니다. 모든 연산이 마치 단일 원자적 연산처럼 순차적으로 실행되는 것처럼 보이며, 읽기 작업은 항상 가장 최근에 커밋된 쓰기 작업을 반환합니다.
  • 순차 일관성 (Sequential Consistency): 선형화 가능성보다는 약하지만, 특정 클라이언트가 수행한 연산의 순서는 모든 클라이언트에게 동일하게 보장됩니다.
  • 비유: 모든 사람이 동시에 같은 신문을 읽는 것과 같습니다. 누군가 기사를 수정하면, 모든 사람이 즉시 수정된 기사를 보게 됩니다.

• 결과적 일관성 (Eventual Consistency):

  • 일관성을 당장 보장하지는 않지만, 충분한 시간이 지나면 모든 노드의 데이터가 최종적으로 동기화되어 일관된 상태가 된다는 모델입니다. 그전까지는 데이터 불일치가 발생할 수 있습니다.
  • 종류:
    • Read-your-writes: 자신이 쓴 데이터는 항상 바로 읽을 수 있습니다.
    • Monotonic reads: 한 번 읽은 데이터보다 더 오래된 데이터를 다시 읽지 않습니다.
    • Monotonic writes: 쓰기 작업의 순서가 보장됩니다.
  • 비유: 친구들과 단톡방에서 메시지를 주고받는 것입니다. 메시지를 보내면 바로 나에게는 보이지만, 네트워크 상황에 따라 친구들에게는 약간의 시간 차이를 두고 도달할 수 있습니다. 하지만 결국에는 모든 친구가 모든 메시지를 받게 됩니다.
  • 장점: 높은 가용성과 확장성을 제공합니다.
  • 단점: 일시적인 데이터 불일치로 인해 개발자가 복잡성을 관리해야 할 수 있습니다.

다이어그램 개념 설명: CAP 이론을 시각적으로 설명하자면, 삼각형의 꼭짓점에 C, A, P를 놓고, 우리가 이 중 두 꼭짓점을 잇는 변을 선택하는 그림을 상상할 수 있습니다. P는 반드시 선택해야 하는 필수 꼭짓점이므로, 남은 C와 A 중 하나를 선택하여 최종적으로 CP 또는 AP 시스템이 되는 것입니다. 각 선택은 트레이드오프를 의미하며, 시스템의 동작 방식과 신뢰성에 직접적인 영향을 미칩니다.

3. 코드 예제 2개 (Python)

CAP 이론 자체를 코드로 직접 구현하기는 어렵습니다. 하지만 분산 시스템에서 발생하는 일관성 문제를 시뮬레이션하고, 다른 일관성 모델을 적용했을 때의 동작 방식을 간접적으로 보여줄 수 있습니다.

예제 1: 결과적 일관성(Eventual Consistency)을 따르는 분산 카운터 시뮬레이션

이 예제는 여러 "노드"가 독립적으로 카운터를 증가시키고, 주기적으로 또는 비동기적으로 서로의 값을 동기화하는 상황을 보여줍니다. 이 과정에서 일시적인 데이터 불일치가 발생할 수 있지만, 결국에는 모든 노드가 같은 값을 가지게 됩니다.

import threading
import time
import random

class DistributedCounter:
    def __init__(self, node_id, initial_value=0):
        self.node_id = node_id
        self.value = initial_value
        self.lock = threading.Lock() # 쓰기 작업 시 충돌 방지를 위한 로컬 락

    def increment(self):
        with self.lock:
            self.value += 1
            print(f"Node {self.node_id}: Incremented to {self.value}")

    def get_value(self):
        return self.value

    def sync_with_other_node(self, other_node):
        """다른 노드와 값을 동기화 (단순히 더 큰 값으로 업데이트)"""
        with self.lock:
            with other_node.lock:
                # 결과적 일관성: 단순히 가장 최신(큰) 값으로 업데이트
                if other_node.get_value() > self.value:
                    print(f"Node {self.node_id}: Syncing from Node {other_node.node_id} (Local: {self.value}, Remote: {other_node.get_value()})")
                    self.value = other_node.get_value()
                elif self.value > other_node.get_value():
                    print(f"Node {other_node.node_id}: Syncing from Node {self.node_id} (Local: {other_node.get_value()}, Remote: {self.value})")
                    other_node.value = self.value
                else:
                    print(f"Node {self.node_id} and Node {other_node.node_id}: Already synchronized.")

def node_worker(node, other_node_ref, stop_event):
    while not stop_event.is_set():
        # 임의의 시간 간격으로 카운터 증가
        time.sleep(random.uniform(0.1, 0.5))
        node.increment()

        # 가끔 다른 노드와 동기화 시도
        if random.random() < 0.3: # 30% 확률로 동기화 시도
            other_node = other_node_ref() # 참조를 통해 다른 노드 객체 가져오기
            if other_node:
                node.sync_with_other_node(other_node)

def simulate_eventual_consistency():
    print("--- 결과적 일관성 시뮬레이션 시작 ---")
    node1 = DistributedCounter(1)
    node2 = DistributedCounter(2)
    node3 = DistributedCounter(3)

    # 노드 간 참조를 위한 헬퍼 함수 (순환 참조 방지)
    def get_node(node_id):
        if node_id == 1: return node1
        if node_id == 2: return node2
        if node_id == 3: return node3
        return None

    stop_event = threading.Event()

    # 각 노드 스레드 시작
    threads = []
    threads.append(threading.Thread(target=node_worker, args=(node1, lambda: get_node(random.choice([2,3])), stop_event)))
    threads.append(threading.Thread(target=node_worker, args=(node2, lambda: get_node(random.choice([1,3])), stop_event)))
    threads.append(threading.Thread(target=node_worker, args=(node3, lambda: get_node(random.choice([1,2])), stop_event)))

    for t in threads:
        t.start()

    # 일정 시간 동안 시뮬레이션 실행
    time.sleep(5)
    stop_event.set()

    for t in threads:
        t.join()

    print("\n--- 시뮬레이션 종료 ---")
    print(f"최종 Node 1 값: {node1.get_value()}")
    print(f"최종 Node 2 값: {node2.get_value()}")
    print(f"최종 Node 3 값: {node3.get_value()}")

    # 최종 동기화 (모든 노드가 동일한 값을 갖도록)
    max_val = max(node1.get_value(), node2.get_value(), node3.get_value())
    node1.value = max_val
    node2.value = max_val
    node3.value = max_val
    print("\n--- 최종 강제 동기화 후 ---")
    print(f"Node 1 값 (강제 동기화): {node1.get_value()}")
    print(f"Node 2 값 (강제 동기화): {node2.get_value()}")
    print(f"Node 3 값 (강제 동기화): {node3.get_value()}")

예제 2: 강한 일관성(Strong Consistency)을 위한 쿼럼(Quorum) 기반 쓰기/읽기 시뮬레이션

이 예제는 분산 시스템에서 강한 일관성을 확보하기 위한 한 가지 방법인 쿼럼 기반 쓰기/읽기 전략을 보여줍니다. 데이터를 쓰거나 읽을 때, 클러스터 내의 특정 수(쿼럼) 이상의 노드로부터 응답을 받아야만 작업을 성공으로 간주합니다.

import threading
import time
import random

class QuorumNode:
    def __init__(self, node_id, initial_data={}):
        self.node_id = node_id
        self.data = initial_data.copy()
        self.lock = threading.Lock() # 로컬 데이터 접근을 위한 락
        print(f"Node {self.node_id} initialized with: {self.data}")

    def write_data(self, key, value):
        # 실제 분산 환경에서는 버전 관리나 타임스탬프를 사용하여 충돌 해결
        with self.lock:
            self.data[key] = value
            print(f"Node {self.node_id}: Wrote {key}={value}")
        return True # 쓰기 성공

    def read_data(self, key):
        with self.lock:
            return self.data.get(key)

# 쿼럼 기반 쓰기/읽기를 시뮬레이션하는 클라이언트
class QuorumClient:
    def __init__(self, nodes):
        self.nodes = nodes
        self.num_nodes = len(nodes)
        self.write_quorum = self.num_nodes // 2 + 1 # 과반수
        self.read_quorum = self.num_nodes // 2 + 1  # 과반수

    def distributed_write(self, key, value):
        successful_writes = 0
        for node in self.nodes:
            if random.random() < 0.9: # 10% 확률로 노드 장애 또는 네트워크 지연 시뮬레이션
                if node.write_data(key, value):
                    successful_writes += 1
            else:
                print(f"Node {node.node_id}: Write failed (simulated network issue/node down).")
            time.sleep(0.05) # 네트워크 지연 시뮬레이션

        if successful_writes >= self.write_quorum:
            print(f"Client: Write '{key}={value}' successful with {successful_writes}/{self.num_nodes} nodes (Quorum: {self.write_quorum}).")
            return True
        else:
            print(f"Client: Write '{key}={value}' failed. Only {successful_writes}/{self.num_nodes} nodes acknowledged. (Quorum: {self.write_quorum}).")
            return False

    def distributed_read(self, key):
        read_results = {}
        successful_reads = 0
        for node in self.nodes:
            if random.random() < 0.9: # 10% 확률로 노드 장애 시뮬레이션
                data = node.read_data(key)
                if data is not None:
                    read_results[node.node_id] = data
                    successful_reads += 1
            else:
                print(f"Node {node.node_id}: Read failed (simulated network issue/node down).")
            time.sleep(0.05) # 네트워크 지연 시뮬레이션

        if successful_reads >= self.read_quorum:
            print(f"Client: Read '{key}' successful with {successful_reads}/{self.num_nodes} nodes (Quorum: {self.read_quorum}).")
            # 강한 일관성을 위해 가장 최신(또는 다수결) 값을 선택
            # 여기서는 단순히 읽은 값들을 반환하여 일관성 확인
            return read_results
        else:
            print(f"Client: Read '{key}' failed. Only {successful_reads}/{self.num_nodes} nodes responded. (Quorum: {self.read_quorum}).")
            return None

def simulate_strong_consistency():
    print("\n--- 강한 일관성 (쿼럼 기반) 시뮬레이션 시작 ---")
    nodes = [QuorumNode(i) for i in range(1, 4)] # 3개 노드
    client = QuorumClient(nodes)

    # 1. 초기 쓰기
    client.distributed_write("user_balance", 100)
    time.sleep(0.5)

    # 2. 읽기 시도 (모든 노드가 100을 반환해야 함)
    read_data = client.distributed_read("user_balance")
    print(f"Client: Read result for 'user_balance': {read_data}")
    # Expected: {1: 100, 2: 100, 3: 100} or similar depending on simulated failures

    # 3. 다른 값으로 쓰기
    client.distributed_write("user_balance", 200)
    time.sleep(0.5)

    # 4. 다시 읽기 시도 (모든 노드가 200을 반환해야 함)
    read_data = client.distributed_read("user_balance")
    print(f"Client: Read result for 'user_balance': {read_data}")
    # Expected: {1: 200, 2: 200, 3: 200} or similar

    # 5. 노드 1이 다운된 상황 시뮬레이션 (네트워크 문제)
    print("\n--- Node 1 다운 가정 후 ---")
    original_nodes = client.nodes