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로 합니다.