스트리밍 · X04

Kafka: 토픽·파티션·컨슈머 그룹

공고 52건(56%)이 Kafka나 스트리밍을 언급하고, 이 중 38건은 우대사항입니다. 11장에서 개념만 다룬 Kafka를 직접 띄워 메시지를 보내고, 컨슈머 그룹이 파티션을 나눠 갖는 것, 장애 뒤 중복 처리가 생기는 것을 확인했습니다. Apache Kafka 4.4.0(KRaft 단일 노드, Java 21), confluent-kafka 2.16을 썼습니다.


띄우기

# Kafka 4.x는 ZooKeeper 없이 KRaft 모드로 돕니다
KAFKA_CLUSTER_ID=$(bin/kafka-storage.sh random-uuid)
bin/kafka-storage.sh format --standalone -t $KAFKA_CLUSTER_ID -c config/server.properties
bin/kafka-server-start.sh config/server.properties

bin/kafka-topics.sh --bootstrap-server localhost:9092 --create --topic orders --partitions 3
Topic: orders  Partition: 0  Leader: 1  Replicas: 1  Isr: 1
Topic: orders  Partition: 1  Leader: 1  Replicas: 1  Isr: 1
Topic: orders  Partition: 2  Leader: 1  Replicas: 1  Isr: 1

보내기: 키가 파티션을 정합니다

# K1. 주문 CSV를 Kafka 토픽 'orders'로 보냅니다. 키는 customer_id.
import csv, json, sys
from confluent_kafka import Producer
p = Producer({"bootstrap.servers": "localhost:9092", "enable.idempotence": True, "acks": "all"})
sent = {}
def report(err, msg):
    if err: print("실패", err); return
    sent[msg.partition()] = sent.get(msg.partition(), 0) + 1
path = sys.argv[1] if len(sys.argv) > 1 else "../landing/orders/orders_2026-11-01.csv"
n = int(sys.argv[2]) if len(sys.argv) > 2 else 1000
with open(path, encoding="utf-8") as f:
    for i, row in enumerate(csv.DictReader(f)):
        if i >= n: break
        p.produce("orders", key=row["customer_id"], value=json.dumps(row, ensure_ascii=False), callback=report)
        p.poll(0)
p.flush()
print("보낸 메시지(파티션별):", dict(sorted(sent.items())), "합계", sum(sent.values()))
python k1_produce.py ../landing/orders/orders_2026-11-01.csv 1000
보낸 메시지(파티션별): {0: 315, 1: 368, 2: 317} 합계 1000

키(customer_id)의 해시로 파티션이 정해집니다. 같은 고객의 주문은 항상 같은 파티션에 들어가고, Kafka는 파티션 안에서만 순서를 지킵니다. 주문을 2건 이상 낸 고객 123명을 확인해 보니 모두 한 파티션에만 들어 있었습니다. "같은 주문의 결제 → 취소 순서"가 중요하면 order_id를 키로 써야 합니다.

읽기: 컨슈머 그룹

# K2. 컨슈머 그룹으로 읽어 DuckDB에 upsert. 커밋은 저장이 끝난 뒤에 합니다.
# DuckDB 파일은 한 프로세스만 쓸 수 있어서 컨슈머마다 파일을 나눕니다.
import json, sys, time, duckdb
from confluent_kafka import Consumer, KafkaException
name = sys.argv[1]
crash_after = int(sys.argv[2]) if len(sys.argv) > 2 else 0
group = sys.argv[3] if len(sys.argv) > 3 else "orders-loader"
c = Consumer({"bootstrap.servers": "localhost:9092", "group.id": group,
              "auto.offset.reset": "earliest", "enable.auto.commit": False,
              "session.timeout.ms": 6000})   # 죽은 컨슈머를 6초 만에 그룹에서 뺍니다
c.subscribe(["orders"])
db = duckdb.connect(f"sink_{name}.duckdb")
db.sql("CREATE TABLE IF NOT EXISTS orders_rt (order_id INT PRIMARY KEY, customer_id INT, qty INT, status VARCHAR, updated_at TIMESTAMP)")
db.sql("CREATE TABLE IF NOT EXISTS load_log (consumer VARCHAR, part INT, off BIGINT, order_id INT, customer_id INT)")
done, idle, parts = 0, 0, set()
while idle < (8 if done else 30):   # 처음엔 파티션 배정을 30초까지 기다립니다
    msg = c.poll(1.0)
    if msg is None: idle += 1; continue
    idle = 0
    r = json.loads(msg.value())
    db.execute("INSERT INTO orders_rt VALUES (?,?,?,?,?) ON CONFLICT (order_id) DO UPDATE SET status=excluded.status, qty=excluded.qty, updated_at=excluded.updated_at",
               [int(r["order_id"]), int(r["customer_id"]), int(r["qty"]), r["status"], r["updated_at"]])
    db.execute("INSERT INTO load_log VALUES (?,?,?,?,?)", [name, msg.partition(), msg.offset(), int(r["order_id"]), int(r["customer_id"])])
    parts.add(msg.partition()); done += 1
    if crash_after and done == crash_after:
        print(f"{name}: {done}건 저장 후 커밋 전에 종료(장애 흉내)"); sys.exit(1)
    if done % 50 == 0: c.commit(asynchronous=False)
try:
    c.commit(asynchronous=False)
except KafkaException:
    pass   # 마지막 50건 단위 커밋 뒤 새로 읽은 게 없으면 커밋할 것이 없습니다
c.close()
print(f"{name}: {done}건 처리, 맡은 파티션 {sorted(parts)}")
kafka-consumer-groups.sh --describe --group g2 --members
CONSUMER-ID           #PARTITIONS  CURRENT-ASSIGNMENT
rdkafka-8f28f924...   2            orders:0,1
rdkafka-f60f6b74...   1            orders:2

A: 317건 처리, 맡은 파티션 [2]
B: 683건 처리, 맡은 파티션 [0, 1]

같은 그룹의 컨슈머 두 개가 파티션 3개를 나눠 가졌습니다. 컨슈머를 늘려도 파티션 수보다 많으면 노는 컨슈머가 생깁니다. 처리량을 늘릴 계획이 있으면 토픽을 만들 때 파티션을 넉넉히 둡니다.

처음에 한 번 실패했습니다. 두 컨슈머가 같은 DuckDB 파일에 쓰게 했더니 두 번째 프로세스가 Could not set lock on file ... Conflicting lock is held로 죽었습니다. DuckDB 파일은 한 번에 한 프로세스만 쓸 수 있습니다. 여러 컨슈머가 동시에 쓰는 곳은 Postgres 같은 서버형 DB나 파일을 나누는 방식을 씁니다.

장애가 나면: 적어도 한 번(at-least-once)

컨슈머는 50건마다 "여기까지 처리했다"(오프셋)를 커밋합니다. 120건을 저장한 뒤 커밋 전에 프로세스를 죽이고 다시 켰습니다.

python k2_consume.py C 120 g4     # 120건 저장 후 종료(커밋은 100건까지)
C: 120건 저장 후 커밋 전에 종료(장애 흉내)
python k2_consume.py C 0 g4       # 다시 시작

처리 기록 1220  고유 주문 1200  테이블 행 1200
두 번 처리된 주문 20

마지막 커밋(100건) 이후 20건을 다시 받아 처리 기록은 1,220건이 됐습니다. 그래도 테이블은 정확히 1,200행입니다. 저장을 ON CONFLICT (order_id) DO UPDATE(upsert)로 했기 때문입니다. Kafka에서 "메시지가 빠지지 않게" 하면 중복은 생길 수 있으니, 받는 쪽을 멱등하게(몇 번 넣어도 결과가 같게) 만듭니다. 04장의 원칙과 같습니다.

이것만 기억하세요

키가 파티션을 정하고, 순서는 파티션 안에서만 지켜집니다. 컨슈머 그룹은 파티션을 나눠 갖고, 장애 뒤엔 중복이 생기므로 저장은 upsert로 합니다.

다음
X05. 스트림 처리: 시간 창과 늦은 이벤트
이어보기 →