Kafka를 처음 배우면 보통 이런 정의부터 듣습니다.
Apache Kafka는 대용량 이벤트를 실시간으로 처리하기 위한 분산 이벤트 스트리밍 플랫폼이다.
맞는 정의지만 이것만으로는 Kafka가 지금 구조로 설계된 이유를 알기 어렵습니다. 저는 이런 질문이 궁금했습니다.
- Kafka는 왜 consumer가 읽은 메시지를 바로 지우지 않을까요?
- 왜 메시지를 큐 대신 로그 형태로 쌓을까요?
- 왜 어디까지 읽었는지(offset)를 consumer가 정하게 했을까요?
처음에는 셋 다 높은 처리량을 얻기 위한 선택이라고 짐작했습니다. 답을 찾으려고 Kafka를 만든 사람들이 남긴 글 두 편을 읽었습니다. 하나는 Jay Kreps가 2013년에 쓴 The Log: What every software engineer should know about real-time data’s unifying abstraction이고, 다른 하나는 Jay Kreps, Neha Narkhede, Jun Rao가 2011년에 발표한 논문 Kafka: a Distributed Messaging System for Log Processing입니다. 아래 내용은 두 글과 Kafka 공식 문서(4.4 판)를 읽고 정리한 것이며, 제가 Kafka를 직접 운영하며 측정한 결과는 들어 있지 않습니다.
1. LinkedIn은 어떤 문제를 겪고 있었을까요?
Kafka는 LinkedIn에서 Jay Kreps, Neha Narkhede, Jun Rao 등이 만들었습니다. LinkedIn은 2011년 1월 Kafka를 오픈소스로 공개했고, 그때 이미 사내 여러 프로젝트가 운영 환경에서 Kafka를 쓰고 있었습니다.
LinkedIn은 서비스가 커지면서 다루는 데이터의 종류가 늘었습니다. 프로필 조회, 검색, 게시물 클릭 같은 사용자 활동 데이터가 있었고, 서버 상태와 애플리케이션 이벤트도 모아야 했습니다.
같은 데이터를 쓰는 시스템도 여럿이었습니다. 사용자의 클릭 이벤트 하나만 해도 쓰임새가 이렇게 나뉩니다.
- 추천 시스템은 사용자 활동을 빠르게 반영해야 합니다.
- 분석 시스템은 하루 동안 쌓인 이벤트를 모아 집계합니다.
- 모니터링 시스템은 서비스 상태와 이상 징후를 바로 알아차려야 합니다.
분석 시스템에는 데이터를 일정 기간 모았다가 처리하는 batch processing이 맞고, 추천과 모니터링에는 이벤트가 들어오는 대로 처리하는 stream processing이 필요했습니다.
Kafka 논문에 따르면 당시 쓸 수 있던 도구는 두 부류였고 어느 쪽도 이 요구를 채우지 못했습니다.
Facebook의 Scribe, Yahoo의 Data Highway, Cloudera의 Flume 같은 로그 수집기는 대량의 로그를 Hadoop이나 데이터 웨어하우스로 옮기는 데 강했습니다. 하지만 대부분 데이터를 나중에 한꺼번에 읽는 offline 소비를 전제로 만들어졌고, 브로커가 consumer에게 데이터를 밀어 넣는 push 방식이었습니다. push 방식에서는 처리 속도가 느린 consumer가 감당할 수 없는 양을 받을 수 있습니다.
IBM WebSphere MQ나 JMS 구현체 같은 기존 메시징 시스템에는 이런 문제가 있었습니다.
- 메시지마다 개별 ack, 여러 큐에 걸친 트랜잭션처럼 전달 보장 기능이 풍부했고, 그만큼 API와 구현이 복잡했습니다. 로그 데이터에는 이 보장이 과했습니다. 페이지뷰 이벤트는 가끔 몇 건을 잃어도 서비스에 큰 문제가 생기지 않습니다.
- 처리량을 최우선으로 설계하지 않았습니다. JMS에는 producer가 메시지 여러 개를 한 요청으로 묶는 API가 없어서 메시지마다 TCP 왕복이 한 번씩 필요했습니다.
- 메시지를 여러 서버에 나눠 저장하는 기능이 약했습니다.
- 메시지가 곧바로 소비된다고 가정해서 읽히지 않은 메시지가 쌓이면 성능이 크게 떨어졌습니다. 데이터 웨어하우스처럼 주기적으로 대량을 가져가는 consumer가 바로 이런 상황을 만듭니다.
LinkedIn에는 실시간 consumer와 offline consumer를 함께 받으면서 대규모 이벤트를 전달할 수 있는 인프라가 필요했습니다.
2. 서비스가 각 시스템을 직접 호출하면 안 될까요?
가장 단순한 방법은 서비스가 이벤트를 사용하는 시스템을 하나씩 호출하는 것입니다.
동기 호출이라면 하위 시스템의 응답 시간이 그대로 사용자 요청의 지연이 됩니다. 하위 시스템 하나가 멈추면 서비스까지 영향을 받을 수 있습니다.
비동기 호출로 바꿔도 정해야 할 것이 남습니다. 전송에 실패하면 언제 다시 보낼지, 받는 시스템이 몇 시간 멈추면 그동안 이벤트를 어디에 둘지, 새 시스템이 붙으면 지난 이벤트를 어떻게 넘겨줄지를 서비스가 직접 해결해야 합니다.
Transactional Outbox 패턴은 발행할 이벤트를 비즈니스 데이터와 같은 트랜잭션으로 DB에 저장해 두었다가 나중에 발행합니다. 이 패턴을 쓰면 이벤트 발행은 안전해집니다. 다만 Outbox가 해결하는 문제는 비즈니스 트랜잭션의 커밋과 이벤트 발행을 함께 성공시키거나 함께 실패시키는 원자성입니다. 여러 consumer가 서로 다른 속도로 이벤트를 읽고, 지난 데이터를 다시 처리하고, 대량의 이벤트를 오래 보관하는 일은 Outbox 뒤에 별도의 인프라가 맡아야 합니다. 1장에서 본 LinkedIn의 요구도 이런 인프라였고, Kafka는 그 요구에서 출발했습니다.
3. 로그는 어떤 구조이고, 왜 읽어도 지우지 않을까요?
순서대로 덧붙이기만 하는 기록
The Log에서 Jay Kreps가 말하는 로그는 애플리케이션이 남기는 텍스트 로그와 다릅니다. 새 레코드를 끝에만 덧붙이고 레코드가 시간 순서대로 놓이는 저장 구조입니다.
새 데이터는 로그의 끝에 붙고, 각 레코드는 로그 안에서 고유한 위치 번호(offset)를 받습니다. 이런 구조를 append-only log라고 부릅니다. 레코드가 쌓인 순서가 곧 일이 일어난 순서이므로 로그는 무슨 일이 있었는지와 그 일이 어떤 순서로 일어났는지를 함께 담습니다.
Kafka에서는 메시지를 주제별로 모으는 단위를 토픽이라고 부르고, 토픽 하나를 여러 파티션으로 나눠 저장합니다. 파티션 하나하나가 이 절에서 말한 로그이므로 순서는 파티션 안에서만 보장됩니다. 이 글에서 “로그”는 파티션 하나를 가리키고, 토픽을 파티션으로 나누는 이유는 5장에서 다룹니다.
소비와 삭제를 분리한 이유
A 가 읽은 메시지를 B 도 받을 수 있을까요?
producer 가 기록한 메시지 다섯 건을 consumer A 와 B 가 읽습니다. A 는 한 번에 두 건, B 는 한 건씩 읽습니다. 작업 큐와 Kafka 로그를 바꿔 가며 같은 순서로 눌러 보세요.
모형입니다. 파티션 하나와 consumer group 세 개(A, B, C 가 각자 다른 group)를 그렸고, offset commit 과 브로커는 생략했습니다. 세 group 모두 auto.offset.reset=earliest 로 둔 경우라, C 는 붙을 때, 읽을 위치가 보존 기간으로 지워진 consumer 는 그때 남아 있는 가장 앞 offset 으로 갑니다. 기본값인 latest 라면 둘 다 로그 끝으로 가서 그 뒤에 기록된 메시지부터 읽습니다. 보존 기간은 시간 기준 삭제를 두 건씩 지우는 것으로 줄였고, 실제로는 로그를 나눠 둔 파일(segment) 단위로 지웁니다. 작업 큐는 읽으면 지우는 단순한 큐이고, 구독자마다 사본 큐를 두는 메시징 시스템은 그리지 않았습니다.
전통적인 작업 큐에서는 consumer가 메시지를 처리하면 큐에서 그 메시지를 지웁니다. Kafka는 consumer가 메시지를 읽었다는 이유로 메시지를 지우지 않습니다. 메시지는 보존 기간(retention) 설정에 따라 지워지고, consumer는 자기가 어디까지 읽었는지를 offset으로 따로 관리합니다.
Kafka의 consumer는 consumer group 단위로 읽습니다. 같은 group 안의 consumer들은 파티션을 나눠 맡고 서로 다른 group은 같은 파티션을 각자 처음부터 끝까지 읽습니다. 이 글에서 여러 consumer가 같은 로그를 읽는다고 할 때는 서로 다른 group의 consumer를 말합니다.
논문 시점의 Kafka 브로커는 consumer마다 어디까지 읽었는지 추적하지 않았고 offset은 consumer가 Zookeeper에 주기적으로 기록했습니다. 덕분에 브로커는 부담이 줄었지만 모든 consumer가 어떤 메시지를 다 읽었는지 알 수 없어서 읽은 시점에 메시지를 지울 수 없습니다. Kafka는 이 문제를 시간 기준 보존 정책으로 해결했습니다. 메시지가 일정 기간(보통 7일)보다 오래 남아 있으면 지웠습니다. 지금의 Kafka도 log.retention.hours 기본값이 168시간, 즉 7일입니다.
지금의 Kafka에서는 consumer가 commit한 offset이 브로커의 내부 토픽 __consumer_offsets에 저장됩니다. 저장 위치는 브로커지만 어느 offset을 commit할지와 어디서부터 다시 읽을지는 여전히 consumer가 정합니다. 브로커가 commit된 offset을 알게 된 지금도 Kafka는 읽은 메시지를 지우지 않고 보존 기간 같은 기준으로만 지웁니다. 새 consumer group은 언제든 붙을 수 있고 이미 읽은 group도 offset을 되돌려 다시 읽을 수 있어서 지금 붙어 있는 group이 모두 읽었다고 해서 그 메시지가 더는 필요 없다고 할 수 없습니다.
서로 다른 group의 consumer A와 B가 같은 로그를 서로 다른 속도로 읽어도, A가 앞서 있다는 이유로 B가 아직 읽지 않은 메시지가 지워지지는 않습니다. 그래서 이런 일이 가능합니다.
- consumer마다 독립적으로 이벤트를 처리합니다.
- 장애가 난 consumer는 마지막으로 commit한 위치부터 다시 읽습니다.
- 새로 만든 consumer group이 보존 기간 안의 지난 데이터를 처음부터 읽을 수 있습니다. commit된 offset이 없는 group이라
auto.offset.reset이 시작 위치를 정하고earliest면 남아 있는 가장 앞에서, 기본값latest면 붙은 뒤에 기록된 메시지부터 읽습니다. - 같은 데이터로 서로 다른 결과를 만듭니다.
consumer가 일부러 offset을 되돌려 다시 읽을 수도 있습니다. 논문은 이 기능이 큐의 일반적인 계약과는 맞지 않지만 많은 consumer에게 꼭 필요했다고 하며 예시를 듭니다. consumer의 애플리케이션 로직에 버그가 있었다면 버그를 고친 뒤 해당 메시지를 다시 처리합니다. 전문 검색 인덱서처럼 읽은 데이터를 주기적으로만 저장하는 consumer는 재시작하면 아직 저장하지 않은 데이터를 잃습니다. 그래서 저장하지 않은 메시지 중 가장 작은 offset을 기록해 두었다가 재시작할 때 그 offset부터 다시 읽습니다.
4. 로그는 Kafka가 처음 쓴 개념일까요?
데이터베이스의 WAL
Kafka 이전에도 로그는 여러 시스템에서 쓰였습니다. 데이터베이스의 Write-Ahead Logging(WAL)이 그 예입니다.
WAL의 원칙은 데이터 페이지의 변경을 디스크에 반영하기 전에 복구에 필요한 로그를 먼저 디스크에 기록하는 것입니다. 데이터베이스가 중간에 멈춰도 WAL을 읽어 변경을 다시 적용하거나 트랜잭션을 되돌릴 수 있습니다.
로그는 데이터베이스 복제에도 쓰입니다. 변경 기록을 다른 서버로 보내고 같은 순서로 적용하면 복제본(replica)의 상태가 원본과 같아집니다.
순서가 결과를 바꾸는 이유
잔액(balance)을 0원에서 바꾸는 두 변경을 생각해 보겠습니다. A는 잔액을 10,000원으로 정하고, B는 잔액에 5,000원을 더합니다.
같은 변경을 받으면 같은 상태가 될까요?
두 replica 가 balance = 0 에서 출발해 변경 로그의 A 와 B 를 적용합니다. replica 2 가 받는 순서를 고르고 적용해 보세요.
모형입니다. replica 는 변경을 받는 대로 적용하는 결정론적 상태 기계로 그렸고, 복제 지연이나 장애는 그리지 않았습니다. replica 1 은 언제나 로그 순서대로 받습니다.
A 다음에 B를 적용하면 잔액은 15,000원입니다. B를 먼저 적용하고 A를 나중에 적용하면 B가 더한 5,000원을 A가 10,000원으로 덮어써서 잔액은 10,000원이 됩니다. 같은 이벤트도 적용 순서가 바뀌면 결과가 달라집니다.
The Log에 나오는 State Machine Replication 원리가 이 성질을 정리합니다.
If two identical, deterministic processes begin in the same state and get the same inputs in the same order, they will produce the same output and end in the same state.
같은 상태에서 출발한 결정론적 프로세스 두 개가 같은 입력을 같은 순서로 받으면, 같은 출력을 내고 같은 상태에 도달한다는 원리입니다. 그래서 여러 서버의 상태를 맞추는 문제는 모든 서버가 같은 로그를 같은 순서로 처리하게 만드는 문제로 바뀝니다. Jay Kreps는 이 원리에서 출발해 로그를 여러 시스템이 변경의 순서를 공유하는 기반으로 씁니다.
Kafka의 로그와 WAL의 차이
Kafka의 로그와 데이터베이스 WAL은 변경을 순서 있는 기록으로 남기고 다시 적용해 상태를 만든다는 원리를 공유하지만, 목적과 담는 정보가 다릅니다. WAL은 주로 그 데이터베이스의 복구와 복제를 위해 존재하고, 물리적 페이지 변경이나 내부 복구 정보를 담기도 합니다. Kafka의 로그는 여러 시스템에서 발생한 이벤트를 여러 애플리케이션이 독립적으로 읽도록 설계됐고, 레코드는 대개 애플리케이션이 정의한 데이터입니다.
5. 로그 하나를 어떻게 여러 서버로 나눴을까요?
모든 이벤트를 로그 하나에 기록하면 그 로그를 쓰고 읽는 서버 한 대의 처리량이 전체의 한계가 됩니다. Kafka는 토픽을 여러 파티션으로 나눠 이 한계를 넘었습니다.
파티션과 순서 보장의 범위
u1 의 이벤트는 보낸 순서대로 처리될까요?
producer 가 u1, u2, u3 의 이벤트 여섯 건을 차례로 보냅니다. 파티션마다 consumer 가 하나씩 붙어 있고 처리 속도가 서로 다릅니다. 파티션을 고르는 방식을 바꿔 가며 u1(초록)의 세 건이 처리되는 순서를 보세요.
모형입니다. consumer 의 처리 시간(느림, 보통, 빠름)은 차이를 보이려고 정한 값입니다. key 가 없을 때 장면은 이벤트를 파티션에 한 건씩 번갈아 넣지만, 실제 기본 partitioner 는 producer batch 단위로 파티션을 고르는 sticky 방식이라 같은 파티션에 몰릴 수도 있습니다. 장면은 서로 다른 파티션에 들어간 경우를 보여 줍니다. key 가 있을 때 사용자별 파티션 번호는 해시 값 대신 정해 둔 값입니다.
파티션 하나하나가 독립적인 로그이고, 파티션끼리는 병렬로 쓰고 읽을 수 있습니다. 서로 다른 파티션 사이에는 순서가 보장되지 않습니다. 병렬성을 얻는 대가로 순서 보장의 범위를 파티션 안으로 좁힌 것입니다.
메시지 key를 사용자 ID로 정하면 같은 사용자의 이벤트는 같은 파티션으로 갑니다. 기본 partitioner가 key의 해시를 파티션 수로 나눠 파티션을 고르기 때문입니다. 이렇게 하면 사용자별 이벤트 순서를 유지하면서 서로 다른 사용자의 이벤트는 병렬로 처리할 수 있습니다. 다만 파티션 수를 늘리면 같은 key가 다른 파티션으로 갈 수 있습니다.
다만 파티션 안의 순서가 실제 처리 순서로 이어지려면 양쪽 설정도 맞아야 합니다. producer는 enable.idempotence가 켜져 있으면(충돌하는 설정이 없을 때의 기본값) 재시도해도 순서를 유지합니다. idempotence를 끄고 max.in.flight.requests.per.connection을 2 이상으로 두면 재시도 중에 순서가 바뀔 수 있습니다. consumer가 한 파티션의 메시지를 여러 스레드에 나눠 처리하면 그 단계에서 순서가 다시 섞입니다.
디스크를 쓰면서도 빠른 이유
Kafka는 메시지를 디스크에 저장합니다. 그런데도 처리량이 높은 이유는 로그의 접근 패턴에 있습니다.
- 쓰기는 파일 끝에 덧붙이기만 하므로 디스크를 순차적으로 씁니다.
- 브로커가 메시지를 메모리에 따로 캐시하지 않고 운영체제의 page cache에 맡깁니다. 같은 데이터를 프로세스 메모리와 page cache에 두 번 올리지 않아도 되고, 브로커 프로세스를 재시작해도 page cache는 그대로 남습니다.
- TLS를 쓰지 않으면 consumer에게 보낼 때
sendfile시스템 호출로 파일의 바이트를 소켓으로 바로 넘깁니다. 논문 기준으로 데이터 복사 두 번과 시스템 호출 한 번이 줄어듭니다. TLS를 켜면 암호화를 사용자 공간에서 해야 해서sendfile을 쓰지 않습니다. - producer는 메시지 여러 개를 한 요청으로 보내고, consumer도 pull 요청 하나로 메시지를 묶어 가져갑니다. 논문 시점에는 요청 하나가 보통 수백 KB를 가져갔습니다.
복제와 내구성
로그가 여러 시스템이 함께 쓰는 데이터 전달 인프라가 되려면 서버가 멈춰도 확정된 데이터는 남아 있어야 합니다.
Kafka는 파티션마다 leader replica와 follower replica를 둡니다. leader가 메시지를 로그에 추가하고, follower는 leader의 로그를 따라 복제합니다.
여기서는 로그에 기록된 메시지와 확정된 메시지를 구분해야 합니다. Kafka는 leader의 로그 끝을 일정 시간(replica.lag.time.max.ms, 기본 30초) 안에 따라온 replica의 집합을 ISR(In-Sync Replicas)로 관리합니다. 메시지가 ISR 전체에 복제되고 ISR의 크기가 min.insync.replicas 이상이면 그 메시지는 확정됩니다. Kafka는 확정된 지점을 high watermark로 표시합니다. consumer는 high watermark까지의 메시지만 읽을 수 있습니다. leader가 멈추면 ISR 안의 replica 중 하나가 새 leader가 됩니다. 4.1부터 새 클러스터에서는 ISR이 비었을 때 ELR(Eligible Leader Replicas)로 기록된 replica도 후보가 됩니다.
이 구조가 모든 장애에서 데이터 보존을 보장하지는 않습니다. replica 수, producer의 acks, min.insync.replicas, 그리고 ISR 밖의 replica도 leader가 될 수 있게 하는 unclean.leader.election.enable 설정에 따라 내구성과 가용성 사이의 균형이 달라집니다. 9장에서 이 선택을 다시 다룹니다.
6. 로그가 시스템 사이의 연결을 어떻게 바꿀까요?
로그의 쓰임새는 시스템 사이의 데이터 통합에서 더 분명해집니다. Jay Kreps가 풀려던 문제에는 메시지를 빠르게 전달하는 일과 함께, 조직 안의 여러 시스템이 데이터를 안정적으로 나눠 쓰게 만드는 일이 들어 있었습니다.
시스템끼리 직접 연결하면 생기는 일
PostgreSQL에 사용자 정보가 있고, 이 데이터가 Elasticsearch와 Redis와 분석 시스템에도 필요하다고 가정해 보겠습니다. 1장에서 본 사용자 활동 이벤트와 서버 지표도 같은 세 시스템으로 보내야 한다면 보내는 시스템이 셋, 받는 시스템이 셋입니다.
받는 시스템을 하나 더 붙이면 연결은 몇 개 늘까요?
PostgreSQL, 사용자 활동 이벤트, 서버 지표가 데이터를 보내고 Elasticsearch, Redis, Analytics 가 받습니다. 연결 방식을 바꿔 보고, 받는 시스템을 하나 더 붙여 보세요.
모형입니다. 연결 하나를 선 하나로 셌고, 연결마다 필요한 전달 로직과 장애 복구 로직의 크기는 그리지 않았습니다. 사용자 활동 이벤트와 서버 지표는 1장에서 든 데이터 종류를 보내는 시스템으로 둔 예시입니다. Kafka 클러스터 운영, 스키마 관리처럼 중앙 로그를 두면 새로 생기는 책임도 그리지 않았습니다.
보내는 시스템과 받는 시스템을 직접 이으면 연결마다 전달 로직과 장애 복구 로직이 따로 생기고 연결 수는 보내는 쪽 수와 받는 쪽 수를 곱한 만큼(이 예에서는 9개) 늘어납니다. 중앙 로그를 두면 두 수를 더한 만큼(6개)이면 됩니다. The Log는 시스템 N개를 서로 다 이으면 파이프라인이 O(N²)개로 늘어난다고 지적하고 조직의 모든 데이터를 중앙 로그에 넣어 각 시스템이 구독하게 하자고 제안합니다.
PostgreSQL에서 데이터가 바뀌면 CDC(Change Data Capture)가 그 변경을 Kafka에 기록합니다. 각 consumer는 같은 로그를 독립적으로 읽으면서 자기에게 필요한 작업을 합니다.
이 구조에서는 데이터를 만드는 쪽이 각 consumer의 내부 구현을 몰라도 됩니다. consumer가 하나 더 늘어도 producer의 코드는 바뀌지 않습니다. 한편 중앙 로그를 도입하면 이벤트 스키마 관리, 시스템 사이의 데이터 정합성, Kafka 클러스터 운영이 새로운 책임으로 생깁니다.
Kafka가 데이터베이스를 대체할까요?
대체하지 않습니다. Kafka는 로그를 오래 저장할 수 있지만, 관계형 데이터베이스처럼 임의의 조건으로 데이터를 검색하거나 복잡한 트랜잭션과 제약 조건을 처리하도록 만들어지지 않았습니다.
일반적인 서비스에서는 PostgreSQL 같은 데이터베이스가 원본 데이터(source of truth)를 맡고, Kafka는 이벤트 전달 인프라를 맡습니다.
Event Sourcing처럼 이벤트 기록 자체를 원본으로 두는 아키텍처도 있습니다. 이때 현재 상태는 이벤트를 처음부터 다시 적용해 만듭니다. 이 방식을 택하면 모든 이벤트의 보존, 스냅샷, 스키마 변경, 중복 처리를 따로 설계해야 합니다.
Kafka의 로그가 원본 데이터인지, 다른 데이터베이스의 변경을 전달하는 통로인지는 아키텍처마다 다릅니다. 어느 쪽이든 서로 다른 데이터 시스템은 Kafka를 공통 인터페이스로 삼아 같은 변경 기록을 읽습니다.
7. 같은 로그에서 서로 다른 결과를 만들 수 있을까요?
로그를 중심으로 데이터를 전달하면 같은 로그를 읽은 consumer들이 각자 다른 상태를 만들 수 있습니다.
게시물 조회 이벤트가 로그에 쌓이고 있다고 해 보겠습니다. 어떤 consumer는 게시물별 전체 조회수를 계산하고, 다른 consumer는 사용자별 최근 조회 기록을 만들고, 또 다른 consumer는 최근 한 시간의 인기 게시물을 집계합니다. 이렇게 consumer가 로그를 읽어 만들어 둔 결과를 이 글에서는 view라고 부릅니다.
view 를 지워도 다시 만들 수 있을까요?
게시물 조회 로그를 consumer 두 개가 읽어 각자 view 를 만듭니다. 조회 이벤트를 기록해 보고, 조회수 view 를 지운 뒤 로그를 처음부터 다시 읽게 해 보세요. 보존 기간이 지난 뒤에 다시 만들면 어떻게 되는지도 비교해 보세요.
모형입니다. 두 view 는 consumer 가 이벤트를 읽는 대로 갱신하는 저장소로 그렸고, view 를 저장하는 시스템과 offset commit 은 생략했습니다. 다시 만들 때는 consumer 의 위치를 남아 있는 가장 앞 offset 으로 옮겨 읽는 경우입니다. 보존 기간은 두 건씩 지우는 것으로 줄였습니다.
로그를 처리해 그 결과를 실제로 저장해 둔 것을 materialized view라고 부를 수 있습니다.
같은 방식으로 검색 시스템은 로그로 역색인을 만들고, 분석 시스템은 집계 테이블을 만들고, 캐시는 빠른 조회용 상태를 만듭니다. 저장하는 형태는 시스템마다 필요한 대로 다르지만 모두 같은 변경 기록에서 나옵니다.
이 관계는 The Log의 “Tables and Events are Dual” 절에 나옵니다. 테이블은 어느 시점의 상태를 담고, 로그는 그 상태에 이르기까지의 변경을 담습니다. 로그가 남아 있으면 테이블을 다시 만들 수 있고, 테이블의 변경을 기록하면 로그가 됩니다.
로그가 보존되어 있으면 새 처리 로직을 도입하거나 기존 결과를 처음부터 다시 만들 수 있습니다. 단, 재구성에 필요한 과거 이벤트가 retention 기간 안에 남아 있어야 합니다.
8. batch와 stream은 같은 로그를 읽을 수 있을까요?
1장에서 본 것처럼 Kafka 이전에 쓸 수 있던 도구는 offline 소비에 맞춘 로그 수집기와 즉시 소비를 가정한 메시징 시스템으로 나뉘어 있었습니다. Kafka를 공개하는 글에서 LinkedIn은 offline과 실시간 두 경우의 이벤트 전달을 Kafka 하나로 처리한다고 소개했습니다.
로그를 중심에 두면 두 처리 방식이 같은 데이터 흐름을 읽습니다. The Log의 예를 들면 Hadoop이나 데이터 웨어하우스 같은 배치 시스템은 한 시간이나 하루 단위로만 로그를 읽고, 실시간 조회 시스템은 초 단위로 최신 상태를 따라갑니다. Kafka 논문에 따르면 LinkedIn의 consumer도 대부분 하루, 한 시간, 또는 실시간 단위로 소비를 마쳤습니다.
같은 로그를 읽는데 무엇이 다를까요?
10분마다 이벤트가 하나씩 로그에 기록됩니다. stream consumer 는 기록되는 대로 한 건씩 읽고, batch consumer 는 한 시간 구간이 다 찰 때마다 그 구간을 한 번에 읽습니다. 두 consumer 의 읽는 위치(cursor) 사이가 어떻게 벌어지고 좁혀지는지 보세요.
모형입니다. 시각은 장면 안의 시계이고 실제 시간과 비례하지 않습니다. 로그는 최근 일곱 칸만 보이고 앞 칸은 화면 밖으로 밀려나며, 밀려난 칸이 지워진 것은 아닙니다. batch consumer 는 한 시간 구간이 다 차면 그 구간을 읽는 것으로 단순하게 그렸고, 실제 배치 작업의 스케줄러와 저장소는 그리지 않았습니다.
1장에서 본 batch processing과 stream processing은 이렇게 같은 로그를 읽을 수 있고, 둘의 차이는 얼마나 자주, 한 번에 얼마만큼 읽어 계산하느냐에 있습니다.
한 단계 더 나가면 stream processor가 원본 로그를 읽어 새로운 결과 로그를 쓰는 구조도 가능합니다.
처리 단계마다 입력과 출력이 로그이면 조직 전체의 데이터 흐름을 로그로 이어진 처리 파이프라인으로 구성할 수 있습니다. The Log가 말하는 로그 기반 데이터 통합은 이 구조까지 포함합니다.
9. 로그를 택하면서 감수한 것은 무엇일까요?
앞에서 본 설계마다 Kafka가 대신 내준 것이 있습니다.
producer와 consumer를 분리한 대가
producer는 이벤트를 기록하고, consumer는 자기 속도로 읽습니다. 그래서 한쪽이 느려지거나 멈춰도 다른 쪽이 덜 영향을 받습니다. 하지만 consumer가 계속 뒤처지면 consumer lag가 커지고, 읽지 못한 이벤트가 retention 기간을 넘기면 처리하기 전에 지워집니다.
전역 순서를 포기한 대가
5장에서 본 것처럼 Kafka는 파티션 안의 순서만 보장합니다. 여러 파티션에 걸친 이벤트의 순서가 필요하면 key 설계로 같은 파티션에 모으거나, 애플리케이션이 순서를 따로 다뤄야 합니다.
전달과 처리 완료를 분리한 대가
Kafka는 이벤트를 저장하고 전달하지만, consumer의 비즈니스 로직이 성공했는지는 보장하지 않습니다. consumer가 offset commit 시점, 중복 처리 방지, 재시도 정책을 직접 설계해야 합니다.
특히 Kafka와 외부 데이터베이스는 하나의 트랜잭션으로 묶이지 않습니다. 같은 메시지를 두 번 처리해도 결과가 같도록 멱등하게 만들거나, 처리한 메시지 ID를 데이터베이스에 따로 기록해야 할 수 있습니다.
내구성과 가용성 사이의 선택
Kafka는 replica로 로그를 복제하고 확정된 로그를 보호합니다. 그래도 replica가 멈추는 상황마다 무엇을 포기할지 정해야 합니다. 아래는 Kafka 4.4 문서 기준입니다.
min.insync.replicas의 기본값은 1이고 replica 3개에 2로 올려 쓰는 구성이 흔합니다. 이때 replica가 멈춰 ISR이 이 값보다 작아지면acks=all로 보낸 쓰기는 거부됩니다.acks=1로 보낸 쓰기는 leader가 받지만 확정되지 않아서 consumer는 ISR이 회복될 때까지 그 메시지를 읽지 못합니다. 그사이 leader가 멈추면 producer가 성공 응답을 받은 메시지도 잃을 수 있습니다.- ISR의 replica가 모두 멈추면 기본 설정에서는 leader가 되어도 데이터를 잃지 않는 replica가 돌아올 때까지 그 파티션을 쓸 수 없습니다.
unclean.leader.election.enable을 켜면 ISR 밖의 replica를 leader로 세워 서비스를 이어 가지만 그 replica에 없던 메시지는 잃습니다.
쓰기를 멈출지 유실 위험을 감수할지는 시스템의 요구 사항으로 정해야 합니다.
10. 처음 질문으로 돌아가면
처음에는 Kafka가 높은 처리량을 얻으려고 append-only log를 골랐다고 생각했습니다. 로그의 순차 쓰기가 Kafka의 처리량을 만든 중요한 요소인 것은 맞습니다. 하지만 두 글을 읽고 나니 처음의 세 질문은 모두 여러 시스템이 같은 데이터를 나눠 읽는 문제로 이어졌습니다.
| 질문 | 두 글에서 찾은 답 |
|---|---|
| 왜 읽은 메시지를 바로 지우지 않을까요? | 속도가 다른 여러 consumer가 같은 데이터를 읽고, 장애나 버그 뒤에 다시 읽고, 새 consumer가 지난 데이터를 읽어야 했습니다. 그래서 삭제를 소비와 분리해 retention 기간에 맡겼습니다. |
| 왜 큐 대신 로그일까요? | 로그는 일이 일어난 순서를 그대로 남기고, 같은 입력을 같은 순서로 적용하면 같은 상태가 됩니다. 여러 시스템이 한 파티션 안의 변경 순서를 공유하고 각자 다른 view를 만들 수 있습니다. |
| 왜 consumer가 offset을 정할까요? | 브로커가 consumer별 진행 상태를 추적하지 않으면 브로커가 단순해지고, consumer는 원하는 위치로 offset을 되돌려 다시 읽을 수 있습니다. 지금은 commit한 offset을 브로커가 저장하지만, 어디까지 처리했는지는 여전히 consumer가 정합니다. |
데이터베이스는 로그로 장애를 복구하고 복제본을 맞춥니다. Kafka는 로그로 여러 consumer가 같은 이벤트를 서로 다른 목적에 씁니다. stream processing은 로그를 입력으로 받아 새 결과 로그를 만듭니다. 셋 다 순서 있는 기록을 다시 읽어 데이터를 만듭니다.
Kafka는 이 로그의 성질을 조직 전체의 데이터 통합 인프라로 넓힌 시스템입니다. Kafka를 메시지를 전달하는 브로커로만 보면 읽은 메시지를 지우지 않는 이유나 consumer가 offset을 정하는 이유가 잘 설명되지 않습니다. 변경의 기록을 여러 시스템이 함께 읽는 구조를 기준으로 하면 읽은 메시지를 지우지 않는 설계와 consumer가 offset을 정하는 설계가 함께 설명됩니다.
참고 자료:
- Jay Kreps, The Log: What every software engineer should know about real-time data’s unifying abstraction, LinkedIn Engineering, 2013.
- Jay Kreps, Neha Narkhede, Jun Rao, Kafka: a Distributed Messaging System for Log Processing, NetDB 2011.
- Apache Kafka 4.4 Documentation: Design, Broker Configs, Consumer Configs, Producer Configs, Eligible Leader Replicas
- Jun Rao, Open-sourcing Kafka, LinkedIn’s distributed message queue, LinkedIn Blog, 2011.