Redis Pub/Sub ఎలా పని చేస్తుంది?

Question

Accepted Answer

**Pub/Sub** (Publish/Subscribe) అనేది Redis యొక్క మెసేజింగ్ పैటర్న, ఇక్కడ **publishers** **channels**కి మెసేజ్‌లను పంపుతారు మరియు **subscribers** వారు సబ్‌స్క్రిప్ట్ చేసిన చ్యానెల్‌ల నుండి మెసేజ్‌లను స్వీకరిస్తారు — publishers మరియు subscribers ఒకరి గురించి తెలియకుండానే. ఇది రియల్-టైమ్ మెసేజింగ్ మరియు సేవల మధ్య డీకపల్డ్ కమ్యూనికేషన్‌ను ఎనేబుల్ చేస్తుంది.

## The Pub/Sub model

```bash
# Subscriber listens on a channel
SUBSCRIBE news                    # subscribe to the "news" channel

# Publisher sends a message to the channel (in another connection)
PUBLISH news "Breaking story!"    # all subscribers to "news" receive this instantly

# Pattern subscriptions (wildcards)
PSUBSCRIBE news.*                 # subscribe to news.sports, news.tech, etc.
```

Publishers `PUBLISH`ని ఒక చ్యానెల్‌కు పంపుతారు; subscribers `SUBSCRIBE`ని చ్యానెల్‌లకు చేసుకుంటారు మరియు రియల్ టైమ్‌లో మెసేజ్‌లను స్వీకరిస్తారు. అవి **decoupled** — publisher ఎవరు (ఎవరైనా ఉంటే) వినిస్తున్నారో తెలియదు.

## Use cases

```text
✓ REAL-TIME notifications — push events to interested services/clients instantly
✓ Chat / messaging — broadcast messages to subscribers
✓ Live updates — dashboards, feeds, multiplayer (broadcast state changes)
✓ Decoupling services — services communicate via channels without direct coupling
✓ Often paired with WebSockets (Redis pub/sub → server → WebSocket → browser)
```

## Important limitation: fire-and-forget

```text
⚠️ Redis Pub/Sub is FIRE-AND-FORGET (at-most-once delivery):
  → Messages are delivered ONLY to subscribers connected AT THAT MOMENT.
  → If a subscriber is offline/disconnected, it MISSES the message (no storage/replay).
  → No persistence, no acknowledgment, no delivery guarantee.
→ NOT suitable when you need reliable delivery or message history.
```

## When you need reliability: use Streams

```text
For RELIABLE messaging (persistence, replay, consumer groups, acknowledgments):
  → use Redis STREAMS (a durable, log-based structure) instead of Pub/Sub
  → or a dedicated message broker (Kafka, RabbitMQ)
Pub/Sub → simple real-time broadcast where missing messages is acceptable
Streams → when you need durability and delivery guarantees
```

## ఇది ఎందుకు ముఖ్యమైనది

Redis Pub/Sub అర్థం చేసుకోవడం **రియల్-టైమ్ మెసేజింగ్ మరియు డీకపల్డ్ కమ్యూనికేషన్**కి విలువైనది, కాబట్టి ఇది ఉపయోగకరమైన జ్ఞానం — కానీ క్రిటికల్‌గా, దాని సීమితుల గురించి అర్థం చేసుకోవడం కూడా దానిని సరిగ్గా ఉపయోగించేందుకు సమానంగా ముఖ్యమైనది.

Pub/Sub **రియల్-టైమ్ మెసేజింగ్**ని ఎనేబుల్ చేస్తుంది, ఇక్కడ publishers చ్యానెల్‌లకు ప్రసారం చేస్తారు మరియు subscribers తక్షణమే స్వీకరిస్తారు, publishers మరియు subscribers **decoupled** (ఒకరికి ఒకరు తెలియకుండా) — రియల్-టైమ్ నోటిఫికేషన్‌లు, చాట్, లైవ్ డ్యాష్‌బోర్డ్ అప్‌డేట్‌లు, మరియు డీకపల్డ్ సర్విస్ కమ్యూనికేషన్ (తరచుగా బ్రౌజర్‌లకు అప్‌డేట్‌లను పుష్ చేయడానికి WebSockets తో జతచేయబడినవి) వంటి యూజ్ కేసులను శక్తివంతం చేస్తుంది.

ఇది రియల్-టైమ్ బ్రాడ్‌కాస్ట్ ఫీచర్‌ల కోసం Redis ని సరళమైన, వేగవంతమైన ఆప్షన్‌గా చేస్తుంది.

ఏది ఏమైనప్పటికీ, **అత్యంత ముఖ్యమైన పాయింట్** Pub/Sub యొక్క **fire-and-forget limitation**ని అర్థం చేసుకోవడం: ఇది at-most-once delivery — మెసేజ్‌లు ఆ సమయంలో కనెక్ట్ చేయబడిన subscribers కు మాత్రమే చేరుకుంటాయి, మరియు ఆఫ్‌లైన్ subscribers **శాశ్వతంగా మెసేజ్‌లను మిస్ చేస్తారు** (ఎటువంటి persistence, replay, acknowledgment, లేదా delivery guarantee లేదు).

ఇది ఒక క్రుసియల్ కాన్‌స్ట్రెయింట్: Pub/Sub విశ్వసనీయమైన delivery లేదా మెసేజ్ హిస్టరీ ముఖ్యమైనప్పుడు అనుకూలం కాదు, మరియు దీన్ని అర్థం చేసుకోకపోవడం lost-message బగ్‌లకు దారితీస్తుంది.

వికల్పాలను తెలుసుకోవడం — **Redis Streams** (durable, log-based, consumer groups మరియు acknowledgments తో) లేదా నిర్ভরయోగ్యమైన మెసేజింగ్ కోసం dedicated brokers (Kafka, RabbitMQ) — మరియు Pub/Sub ని సాధారణ రియల్-టైమ్ బ్రాడ్‌కాస్ట్‌లో ఎన్నుకోవడం ఇక్కడ మెసేజ్‌లను మిస్ చేయడం ఆమోదయోగ్యమైనది, ఇది ధైర్యశీల తీర్పుని ప్రతిబింబిస్తుంది.

రియల్-టైమ్ మెసేజింగ్ సాధారణ అవసరం కనుక, మరియు Redis Pub/Sub దానికి సరళ సమాధానం అందించినందున కానీ ముఖ్యమైన reliability limitations తో (guarantees అవసరమయ్యే సమయంలో Streams లేదా broker అవసరం), Pub/Sub అర్థం చేసుకోవడం — ఇది ఎలా పని చేస్తుంది, దాని use cases, మరియు ముఖ్యంగా దాని fire-and-forget limitation మరియు Streams కు బదులుగా ఎప్పుడు ఉపయోగించాలో — రియల్-టైమ్ ఫీచర్‌లను సరిగ్గా ఇంప్లిమెంట్ చేయడానికి విలువైన, ఆచరణీయ-సంబంధితమైన జ్ఞానం, ఇక్కడ limitation అర్థం చేసుకోవడం capability అర్థం చేసుకోవడం వంటిగా ముఖ్యమైనది.