Redis Streams என்றால் என்ன?

Question

Accepted Answer

**Redis Streams** என்பது append-only log தரவு கட்டமைப்பு — நிலையான செய்திக் வரிசை அல்லது நிகழ்வு பதிவு போன்றது — **consumer groups**, செய்தி நிலைத்தன்மை, acknowledgments, மற்றும் replay ஐ ஆதரிக்கிறது. இவை நம்பகமான செய்திப்பரிமாற்றத்திற்கான Redis இன் பதில், Pub/Sub ஐ விட மேலும் வலுவாக உள்ளது (இது fire-and-forget மட்டுமே).

## செய்திகளின் Append-only log

```bash
# add entries to a stream (each gets an auto ID: timestamp-sequence)
XADD events * type "signup" user "ann"     # * = auto-generate ID; returns e.g. 1700000000-0
XADD events * type "login" user "bob"

XLEN events                                 # number of entries
XRANGE events - +                           # read all entries (- to +)
XREAD COUNT 10 STREAMS events 0             # read entries (from ID 0)
```

Streams என்பது **append-only log**: நுழைவுகள் `XADD` உடன் சேர்க்கப்படுகின்றன (ஒவ்வொன்றும் தனித்துவமான, நேர-வரிசை ID உடன்) மற்றும் stream இல் நிலைத்திருக்கின்றன — Pub/Sub போலல்லாமல், செய்திகள் இழக்கப்படுவதில்லை; அவை சேமிக்கப்படுகின்றன மற்றும் மீண்டும் படிக்க முடியும்.

## Consumer groups — நம்பகமான, scalable செயலாக்கம்

```bash
# create a consumer group to process the stream
XGROUP CREATE events workers 0

# consumers read messages (each message goes to ONE consumer in the group)
XREADGROUP GROUP workers consumer1 COUNT 1 STREAMS events >

# acknowledge a processed message (so it's not redelivered)
XACK events workers 1700000000-0
# unacknowledged messages can be reclaimed (XPENDING/XCLAIM) → no message lost on crash
```

**Consumer groups** செய்திகளை பல consumers முழுவதும் விநியோகிக்கிறது (செயலாக்கத்தை scaling), ஒவ்வொரு செய்தியும் ஒரு consumer க்கு செல்கிறது, **acknowledgments** (`XACK`) செயலாக்கத்தை உறுதிப்படுத்துகிறது, மற்றும் **pending/reclaim** (`XPENDING`/`XCLAIM`) consumer செயல்வீழ்ந்தால் செய்திகள் இழக்கப்படாதிருப்பதை உறுதிசெய்கிறது — நம்பகமான, at-least-once delivery.

## Streams vs Pub/Sub

```text
PUB/SUB  → fire-and-forget; offline subscribers MISS messages; no persistence/replay
STREAMS  → PERSISTENT log; messages stored; consumer groups; acknowledgments; replay
  → Streams = when you need RELIABLE delivery, message history, and scalable consumers
  → Pub/Sub = simple real-time broadcast where missing messages is OK
Streams are similar to a lightweight Kafka (log + consumer groups).
```

## இது ஏன் முக்கியம்

Redis Streams ஐ புரிந்துகொள்வது **நம்பகமான செய்திப்பரிமாற்றம் மற்றும் நிகழ்வு செயலாக்கம்** Redis க்குள் மதிப்புடையது, எனவே இது பயனுள்ள அறிவு — குறிப்பாக Streams ஆனது Pub/Sub இன் முக்கிய வரம்புகளை தீர்க்குவதால்.

Pub/Sub எளிமையாக இருந்தாலும் fire-and-forget ஆக உள்ளது (offline subscribers நிரந்தரமாக செய்திகளை இழக்கிறார்கள், persistence இல்லை), **Streams நம்பகமான செய்திப்பரிமாற்றத்தை வழங்குகிறது**: ஒரு **append-only persistent log** இதில் செய்திகள் சேமிக்கப்படுகின்றன (இழக்கப்படுவதில்லை) மற்றும் மீண்டும் படிக்க/replay செய்ய முடியும், மேலும் **consumer groups** பல consumers முழுவதும் செய்திகளை விநியோகிக்கிறது scalable செயலாக்கத்திற்கு, **acknowledgments** (`XACK`) செயலாக்கத்தை உறுதிப்படுத்த, மற்றும் **pending-message reclaim** (`XPENDING`/`XCLAIM`) consumer செயல்வீழ்ந்தால் செய்திகள் இழக்கப்படாதிருப்பதற்கு — at-least-once, நம்பகமான, scalable செய்திப் செயலாக்கத்தை வழங்குகிறது.

**Streams vs Pub/Sub** ஐ புரிந்துகொள்வது (நம்பகமான delivery, history, மற்றும் scalable consumers க்கு Streams; loss ஏற்றுக்கொள்ளக்கூடிய எளிய real-time broadcast க்கு Pub/Sub) சரியான Redis messaging primitive ஐ தேர்ந்தெடுப்பதற்கு முக்கியம்.

Streams ஆனது **lightweight Kafka போன்றது** என்பதை அங்கீகரிப்பது (log-based with consumer groups) அவற்றின் பாத்திரத்தை சட்டமைக்க உதவுகிறது — moderate தேவைகளுக்கு தனித்துவ broker ஆனitu event-streaming/message-queue திறன்களை Redis க்குள் வழங்குதல், பெரிய அளவிலான அல்லது மிகவும் கடுமையான messaging க்கு dedicated brokers (Kafka, RabbitMQ) பொருத்தமாக உள்ளது.

நம்பகமான செய்திப்பரிமாற்றம் மற்றும் நிகழ்வு செயலாக்கம் பொதுவான தேவைகள் என்பதால், மற்றும் Redis Streams ஒரு வலுவான, persistent, consumer-group-based solution (Pub/Sub இன் fire-and-forget வரம்பைக் கடந்து) Redis க்குள் வழங்குவதால், Redis Streams ஐ புரிந்துகொள்வது — append-only log, consumer groups with acknowledgments and reclaim, மற்றும் அவை Pub/Sub மற்றும் Kafka உடன் எவ்வாறு ஒப்பிடுகிறது — மதிப்புடையது, Redis உடன் நம்பகமான messaging மற்றும் event-driven features கட்ட நடைமுறைக்கு பொருத்தமான அறிவு, Pub/Sub வழங்கமுடியாத delivery guarantees மற்றும் message history தேவைப்பட்டால் சரியான தேர்வு.