2nd/10_Wiki/Topics/Topic_Programming/Architecture/Publish-Subscribe Model.md at 5aed0a45c38221943d11e7a4b2f45cbba34a8768

Files

T

Antigravity Agent 9a135bd19d docs(10_Wiki): Topic_Business/General/Graphic/Programming을 Topics/ 하위로 이동

최상위 10_Wiki/Topic_*였던 4개 카테고리 폴더를 10_Wiki/Topics/Topic_* 로 재배치.
콘텐츠 변경 없음(순수 폴더 이동) — Topics/ 하위 나머지 폴더는 이미 지난 커밋에서
전부 정리된 상태(잔존 항목은 에이전트 운영 상태 및 사용자가 보존을 요청한
업데이트0615/무제 3.canvas 뿐).

2026-07-05 00:44:01 +09:00

5.2 KiB

Raw Blame History

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

title

매 한 줄

"매 publisher 매 subscribers 매 모름 — 매 topic / channel 매 통해 매 decoupled broadcast". 1987 ISIS Toolkit 매 origin, 매 today Kafka / Redis Pub/Sub / NATS / Google Pub/Sub / AWS SNS 매 ubiquitous backbone.

매 핵심

매 model variants

Topic-based: 매 logical channel name (e.g. orders.created).
Content-based: 매 message attributes 매 filter — 매 RabbitMQ headers exchange.
Type-based: 매 message class hierarchy.
Hybrid: 매 topic + filter (NATS subject wildcards orders.*.created).

매 delivery semantics

At-most-once: fire-and-forget (Redis Pub/Sub).
At-least-once: ack required (Kafka, SQS).
Exactly-once: 매 idempotent + transactional (Kafka EOS, Pulsar).

매 응용

Event-driven microservices (orders → fulfillment, billing, notifications).
Real-time dashboards (Grafana Live, websocket fanout).
CDC (Debezium → Kafka → consumers).
IoT telemetry (MQTT — pub-sub variant).

💻 패턴

In-process pub-sub (Python)

from collections import defaultdict
from typing import Callable

class Bus:
    def __init__(self):
        self.subs: dict[str, list[Callable]] = defaultdict(list)
    def subscribe(self, topic, fn): self.subs[topic].append(fn)
    def publish(self, topic, msg):
        for fn in self.subs[topic]:
            fn(msg)

bus = Bus()
bus.subscribe("user.created", lambda u: print(f"welcome {u}"))
bus.publish("user.created", "alice")

Redis Pub/Sub

import redis, json
r = redis.Redis()

# Publisher
r.publish("orders.created", json.dumps({"id": 42, "total": 99}))

# Subscriber
ps = r.pubsub()
ps.subscribe("orders.*")
for msg in ps.listen():
    if msg["type"] == "pmessage":
        handle(json.loads(msg["data"]))

Kafka producer/consumer (Python)

from confluent_kafka import Producer, Consumer

p = Producer({"bootstrap.servers": "localhost:9092"})
p.produce("orders", key="42", value=b'{"total":99}')
p.flush()

c = Consumer({
    "bootstrap.servers": "localhost:9092",
    "group.id": "fulfillment",
    "auto.offset.reset": "earliest",
})
c.subscribe(["orders"])
while True:
    msg = c.poll(1.0)
    if msg and not msg.error():
        process(msg.value())
        c.commit(msg)

NATS with subject wildcards

import nats, asyncio

async def main():
    nc = await nats.connect("nats://localhost:4222")
    async def cb(msg): print(msg.subject, msg.data)
    await nc.subscribe("orders.*.created", cb=cb)
    await nc.publish("orders.US.created", b'{"id":42}')
    await asyncio.sleep(1)

asyncio.run(main())

Google Cloud Pub/Sub

from google.cloud import pubsub_v1

publisher = pubsub_v1.PublisherClient()
topic = publisher.topic_path("proj", "orders")
publisher.publish(topic, b'{"id":42}', region="us-east1")

sub = pubsub_v1.SubscriberClient()
sub_path = sub.subscription_path("proj", "fulfillment-sub")
def cb(msg): handle(msg.data); msg.ack()
sub.subscribe(sub_path, callback=cb).result()

AsyncAPI schema (governance, 2026)

asyncapi: 3.0.0
channels:
  ordersCreated:
    address: orders.created
    messages:
      OrderCreated:
        payload:
          type: object
          properties:
            id: {type: integer}
            total: {type: number}

매 결정 기준

상황	Approach
매 in-process	Bus / EventEmitter
매 ephemeral, low-latency	Redis Pub/Sub / NATS
매 durable, replay 필요	Kafka / Pulsar
매 cloud-native, managed	Google Pub/Sub / AWS SNS+SQS
매 IoT / mobile	MQTT
매 fan-in-out, transform	Kafka Streams / Pulsar Functions

기본값: 매 production EDA — Kafka. 매 simple/ephemeral — NATS.

🔗 Graph

부모: Event-Driven Architecture
변형: Observer Pattern · Event Bus
응용: Event Sourcing · CQRS · CDC
Adjacent: Kafka · NATS · Redis · MQTT

🤖 LLM 활용

언제: 매 schema design (AsyncAPI generation), 매 consumer code scaffolding, 매 dead-letter analysis. 언제 X: 매 broker selection 매 trust 의 X — workload metrics 직접 측정.

❌ 안티패턴

Sync pub-sub: 매 publisher block on slow subscriber — 매 async / queue 사용.
No schema: 매 consumer breakage — Avro/Protobuf + registry 필수.
Topic explosion: 매 user-per-topic — 매 millions of topics, broker 죽음. 매 partition / filter 사용.
Duplicate semantics: 매 at-least-once 인데 매 idempotency 없음 — duplicate processing.

🧪 검증 / 중복

Verified (Eugster et al. — "The Many Faces of Publish/Subscribe" 2003; Kafka docs).
신뢰도 A.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — full pub-sub pattern entry

5.2 KiB Raw Blame History

Publish-Subscribe Model