O que são Redis Streams?

Question

Accepted Answer

**Redis Streams** são uma estrutura de dados de log append-only — como uma fila de mensagens durável ou log de eventos — que suportam **grupos de consumidores**, persistência de mensagens, confirmações e replay. Eles são a resposta do Redis para mensagens confiáveis, mais robustos que Pub/Sub (que é fire-and-forget).

## Log append-only de mensagens

```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 são um **log append-only**: as entradas são adicionadas com `XADD` (cada uma com um ID único, ordenado por tempo) e persistem no stream — diferentemente de Pub/Sub, as mensagens não são perdidas; elas são armazenadas e podem ser relidas.

## Grupos de consumidores — processamento confiável e escalável

```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
```

**Grupos de consumidores** distribuem mensagens entre múltiplos consumidores (escalando o processamento), com cada mensagem indo para um consumidor, **confirmações** (`XACK`) confirmando o processamento, e **pendentes/reclamação** (`XPENDING`/`XCLAIM`) garantindo que as mensagens não sejam perdidas se um consumidor falhar — entrega confiável, pelo menos uma vez.

## 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).
```

## Por que isso importa

Compreender Redis Streams é valioso para **mensagens confiáveis e processamento de eventos** dentro do Redis, portanto é um conhecimento útil — particularmente porque Streams resolvem as limitações principais de Pub/Sub.

Enquanto Pub/Sub é simples mas fire-and-forget (assinantes offline perdem mensagens permanentemente, sem persistência), **Streams fornecem mensagens confiáveis**: um **log persistente append-only** onde as mensagens são armazenadas (não perdidas) e podem ser relidas/reexecutadas, além de **grupos de consumidores** que distribuem mensagens entre múltiplos consumidores para processamento escalável, **confirmações** (`XACK`) para confirmar o processamento, e **reclamação de mensagens pendentes** (`XPENDING`/`XCLAIM`) para que as mensagens não sejam perdidas quando um consumidor falha — entregando processamento de mensagens confiável, escalável e pelo menos uma vez.

Compreender **Streams vs Pub/Sub** (Streams para entrega confiável, histórico e consumidores escaláveis; Pub/Sub para broadcast em tempo real simples onde a perda é aceitável) é importante para escolher a primitiva correta de mensagens Redis.

Reconhecer que Streams são **semelhantes a um Kafka leve** (baseado em log com grupos de consumidores) ajuda a enquadrar seu papel — fornecendo capacidades de streaming de eventos/fila de mensagens dentro do Redis sem um corretor separado para necessidades moderadas, enquanto corretores dedicados (Kafka, RabbitMQ) permanecem apropriados para mensagens de maior escala ou mais exigentes.

Como mensagens confiáveis e processamento de eventos são necessidades comuns, e como Redis Streams fornecem uma solução robusta, persistente e baseada em grupos de consumidores (superando a limitação fire-and-forget de Pub/Sub) dentro do Redis, compreender Redis Streams — o log append-only, grupos de consumidores com confirmações e reclamação, e como eles se comparam a Pub/Sub e Kafka — é um conhecimento valioso e praticamente relevante para construir mensagens confiáveis e recursos orientados a eventos com Redis, a escolha certa quando você precisa de garantias de entrega e histórico de mensagens que Pub/Sub não pode fornecer.