TeoreticQuiz

MongoDB, RabbitMQ, Kafka, Redis

Материал для подготовки к собеседованию (Middle / Senior). Объединённый раздел: NoSQL-хранилище (MongoDB — спрашивают реже, поэтому компактно) + брокеры сообщений (RabbitMQ, Kafka) и in-memory хранилище/кэш (Redis). Термины на английском там, где это принято.

Содержание


MongoDB

MongoDB — документо-ориентированная NoSQL-СУБД. Хранит данные в виде документов (похожи на JSON, физически — BSON: бинарный JSON с типами и датами), сгруппированных в коллекции (аналог таблиц). Схема гибкая — документы в одной коллекции могут иметь разный набор полей.

Когда MongoDB, а когда реляционная БД:

  • MongoDB хороша, когда структура данных гибкая/меняется, данные естественно вложены (документ целиком), нужна горизонтальная масштабируемость, высокая скорость записи, схема слабо связана. Примеры: каталоги, логи, профили, контент.
  • Реляционная БД — когда важны сложные связи, транзакции между сущностями, строгая согласованность, богатые JOIN и аналитика.

В Node.js работают через драйвер mongodb или ODM Mongoose (схемы, валидация, хуки).


MongoDB: модель данных

Главный вопрос моделирования — embedding (вложение) vs referencing (ссылки):

  • Embedding — вкладывать связанные данные в один документ. Быстрое чтение (всё в одном месте, один запрос), атомарность на уровне документа. Минус — дублирование, рост документа.
  • Referencing — хранить ссылку (id) на другой документ (нормализация). Меньше дублирования, но нужен доп. запрос/$lookup (аналог JOIN).
// Embedding: комментарии внутри поста
{ _id: 1, title: "Пост", comments: [ { author: "Вася", text: "..." } ] }

// Referencing: комментарии отдельной коллекцией со ссылкой
{ _id: 1, title: "Пост" }
{ _id: 10, postId: 1, author: "Вася", text: "..." }

Правило: embedding для данных, которые читаются вместе и не растут бесконечно («один-к-немногим»); referencing для «один-ко-многим/многие-ко-многим» и часто изменяемых данных. Ограничение размера документа — 16 МБ.


MongoDB: запросы и агрегации

db.users.find({ age: { $gte: 18 } }, { name: 1 })   // фильтр + проекция
  .sort({ age: -1 }).limit(10);

db.users.updateOne({ _id: 1 }, { $set: { active: true } });
db.users.updateMany({ role: "guest" }, { $inc: { visits: 1 } });
db.users.updateOne({ email: "a@b.c" }, { $set: {...} }, { upsert: true }); // вставит, если нет

Операторы: сравнения ($gt, $gte, $lt, $in, $ne), логические ($and, $or, $not), обновления ($set, $unset, $inc, $push, $pull).

Aggregation Framework — конвейер (pipeline) стадий обработки (аналог SQL GROUP BY + JOIN + трансформации):

db.orders.aggregate([
  { $match: { status: "paid" } },                       // фильтр (как WHERE)
  { $group: { _id: "$userId", total: { $sum: "$amount" } } }, // группировка
  { $sort: { total: -1 } },
  { $lookup: { from: "users", localField: "_id", foreignField: "_id", as: "user" } }, // "JOIN"
  { $unwind: "$user" },
]);

Ключевые стадии: $match, $group, $project, $sort, $limit, $lookup (соединение коллекций), $unwind (разворачивание массива), $facet (несколько конвейеров сразу). $match ставят как можно раньше — чтобы использовать индексы и сократить объём.


MongoDB: индексы

Без индекса запрос делает collection scan (полный перебор). Типы индексов:

  • Single field — по одному полю.
  • Compound — по нескольким (работает правило левого префикса, как в SQL).
  • Multikey — по полю-массиву (индексирует каждый элемент).
  • Text — полнотекстовый поиск.
  • Geospatial — гео-запросы (2dsphere).
  • Hashed — для шардирования по хешу.
  • TTL — автоудаление документов по времени (сессии, кэш).
  • Partial — индексирует только часть документов по условию.
db.users.createIndex({ email: 1 }, { unique: true });
db.users.createIndex({ lastName: 1, firstName: 1 });   // compound
db.sessions.createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 }); // TTL

db.users.find({ email: "a@b.c" }).explain("executionStats"); // анализ плана

explain показывает, использовался ли индекс (IXSCAN — по индексу, COLLSCAN — полный перебор).


MongoDB: транзакции и масштабирование

  • Атомарность на уровне документа — операция над одним документом атомарна всегда (даже с вложенными массивами). Это часто снимает нужду в транзакциях (если данные вложены).
  • Многодокументные транзакции — поддерживаются (с 4.0 на replica set), но дороже; их избегают, если можно смоделировать через embedding.
  • Read/Write concern — уровень подтверждения чтения/записи (сколько узлов подтвердили). Read preference — читать с primary или с реплик.

Масштабирование:

  • Replica Set — набор реплик: один primary (запись) + несколько secondary (копии, чтение). При падении primary происходят автоматические выборы (election) нового. Синхронизация через oplog (журнал операций).
  • Sharding — горизонтальное разбиение данных по шардам по shard key. Масштабирует объём и запись. Балансировщик распределяет чанки. Выбор shard key критичен (плохой ключ → перекос нагрузки).

Очереди vs стриминг: общее

Брокеры сообщений позволяют сервисам общаться асинхронно, развязывая производителя (producer) и потребителя (consumer). Два принципиальных подхода:

  • Очередь сообщений (message queue) — сообщение доставляется потребителю и обычно удаляется после обработки (или подтверждения). Задача «сделай это». Пример — RabbitMQ. Модель «умный брокер, простой потребитель».
  • Лог событий / стриминг (event log) — сообщения пишутся в упорядоченный лог и хранятся какое-то время; много независимых потребителей читают их со своей позиции (offset), не удаляя. Задача «это произошло». Пример — Kafka. Модель «простой брокер, умный потребитель».

Зачем вообще брокер: развязка сервисов, сглаживание пиков нагрузки (буфер), отказоустойчивость (сообщение не потеряется, если потребитель упал), фоновая обработка, событийная архитектура.


Гарантии доставки

  • At-most-once («не более одного раза») — сообщение может потеряться, но не будет обработано дважды. Быстро, но ненадёжно.
  • At-least-once («хотя бы один раз») — сообщение точно дойдёт, но возможны дубликаты (при повторной доставке). Самый частый случай.
  • Exactly-once («ровно один раз») — без потерь и дублей. Сложно и дорого; часто достигается комбинацией at-least-once + идемпотентность потребителя.

Идемпотентность потребителя — ключевая идея: обработчик должен корректно переваривать повторную доставку одного сообщения (например, проверять по уникальному id, не создавать дубликат). Тогда даже at-least-once безопасен.


RabbitMQ

RabbitMQ — брокер сообщений (протокол AMQP), классическая очередь задач. Умный брокер: маршрутизирует сообщения по гибким правилам.

Модель:

  • Producer отправляет сообщение не напрямую в очередь, а в exchange.
  • Exchange маршрутизирует сообщение в queue(s) по binding и routing key.
  • Consumer читает из очереди.

Типы exchange:

  • direct — по точному совпадению routing key.
  • topic — по шаблону с маской (logs.*.error).
  • fanout — во все привязанные очереди (broadcast).
  • headers — по заголовкам сообщения.

Надёжность:

  • ack / nack — потребитель подтверждает обработку; без ack сообщение вернётся в очередь (или другому потребителю). Основа at-least-once.
  • prefetch — сколько неподтверждённых сообщений брокер отдаёт потребителю за раз (управление нагрузкой).
  • publisher confirms — подтверждение брокером получения от producer.
  • durable queues + persistent messages — переживают перезапуск брокера.
  • Dead Letter Exchange (DLX) — куда уходят сообщения, которые не удалось обработать (после отказов/TTL) — для ретраев и разбора.
  • TTL — время жизни сообщения/очереди.
  • Quorum queues — реплицируемые очереди для отказоустойчивости (замена классической зеркальной репликации).

RabbitMQ хорош, когда нужна сложная маршрутизация, гарантированная обработка задач, приоритеты, «одно сообщение — один обработчик».


Kafka

Kafka — распределённая платформа потоковой передачи (event streaming), по сути распределённый лог сообщений. Умный потребитель, простой (но масштабируемый) брокер.

Модель:

  • Topic (топик) — именованный поток сообщений, разбит на partitions (партиции).
  • Partition — упорядоченный неизменяемый лог; сообщение получает порядковый offset. Порядок гарантируется только внутри партиции.
  • Producer пишет в топик; ключ сообщения определяет партицию (одинаковый ключ → одна партиция → сохранён порядок для этого ключа).
  • Consumer читает, отслеживая свой offset (позицию). Сообщения не удаляются при чтении — хранятся по retention (по времени/размеру).
  • Consumer group — группа потребителей; партиции распределяются между её членами (параллелизм). Одну партицию в группе читает только один потребитель. Максимум параллелизма = число партиций.

Ключевые механизмы:

  • Ребалансировка — перераспределение партиций при добавлении/выбытии потребителей в группе.
  • Replication (ISR) — каждая партиция реплицируется на несколько брокеров; leader обслуживает чтение/запись, followers копируют. ISR (In-Sync Replicas) — реплики, догнавшие лидера.
  • acks у producer: 0 (не ждать), 1 (лидер подтвердил), all (все ISR подтвердили — максимальная надёжность).
  • Log compaction — хранить только последнее значение для каждого ключа (для «состояния»).
  • Exactly-once semantics — через идемпотентного producer и транзакции Kafka.

Kafka хороша для больших объёмов событий, стриминга, множества независимых потребителей одних данных, event sourcing, аналитики в реальном времени, логов.


Обработка упавших сообщений: retry и DLQ

Одна из ключевых тем на собеседовании: что делать, когда потребитель не смог обработать сообщение (ошибка в коде, недоступна БД/внешний сервис, некорректные данные).

Общие принципы

  • Повтор (retry) — попробовать обработать ещё раз. Помогает при временных ошибках (сеть, таймаут, недоступность БД).
  • Экспоненциальный backoff — увеличивать задержку между попытками (1с → 5с → 30с…), чтобы не «долбить» упавший сервис. Часто + джиттер (случайный разброс), чтобы избежать одновременных всплесков.
  • Ограничение попыток (max retries) — нельзя повторять бесконечно.
  • Dead Letter Queue (DLQ) / Dead Letter Topic (DLT) — «кладбище» для сообщений, которые не удалось обработать после N попыток. Их не теряют, а откладывают для ручного/отложенного разбора.
  • Poison message («ядовитое» сообщение) — сообщение, которое никогда не обработается (битые данные, баг). Опасно тем, что при бесконечных ретраях блокирует очередь/партицию. Решение — после лимита попыток отправлять в DLQ, а не крутить вечно.
  • Идемпотентность — так как при ретраях (at-least-once) возможны дубли, обработчик должен корректно переваривать повторную доставку (проверять по уникальному id).
  • Разделять типы ошибок: временные (retryable — повторять) и постоянные (non-retryable, например ошибка валидации — сразу в DLQ без ретраев, повтор не поможет).
  • Мониторинг DLQ — обязательно алертить на рост DLQ; иначе ошибки копятся молча.

RabbitMQ

Механизм — Dead Letter Exchange (DLX). Сообщение попадает в DLX, если: потребитель сделал nack/reject с requeue=false, истёк TTL, превышен лимит длины очереди, а у quorum queues — превышен delivery-limit (число повторных доставок).

Типичная схема retry с задержкой:

  1. Основная очередь → при ошибке nack(requeue=false) → сообщение уходит в DLX.
  2. DLX направляет его в retry-очередь с TTL (например, 30с) и без потребителей.
  3. По истечении TTL сообщение из retry-очереди возвращается (через свой DLX) обратно в основную — новая попытка.
  4. Счётчик попыток хранят в заголовке (x-death / кастомный header x-retry-count); после лимита — в финальную DLQ вместо ретрая.
main.queue --(nack, requeue=false)--> DLX --> retry.queue (TTL 30s)
retry.queue --(TTL истёк)--> DLX --> main.queue   (повтор)
после N попыток --> dead.queue (DLQ, разбор вручную)

Важно: requeue=true для poison message — антипаттерн (в classic queue сообщение мгновенно вернётся в очередь и зациклит потребителя; у quorum queues зацикливание ограничено delivery-limit — после него сообщение уходит в DLX или отбрасывается, с RabbitMQ 4.0 лимит по умолчанию 20). Задержку между попытками делают через TTL + DLX (нативного «повтори через 30с» у RabbitMQ нет), либо плагином delayed-message. prefetch ограничивает, сколько необработанных сообщений висит на потребителе.

Kafka

В Kafka сообщение не удаляется и офсет двигается вперёд. Если бросить исключение и не сдвинуть offset — потребитель застрянет на «ядовитом» сообщении (будет читать его снова и снова, блокируя партицию). Подходы:

  • Ручной коммит offset — коммитить только после успешной обработки; при ошибке — решить, повторять или пропустить.
  • Retry topics (топики повторов) — при ошибке продьюсить сообщение в отдельный топик orders.retry.5s, orders.retry.30s (с задержкой), потом — в Dead Letter Topic orders.DLT. Так «плохое» сообщение не блокирует основную партицию. В Spring Kafka это @RetryableTopic из коробки; в других стеках — реализуют вручную.
  • pause/resume потребителя — приостановить чтение партиции, пока внешний сервис недоступен.
  • Skip + логирование — для некритичных данных пропустить (сдвинуть offset) и записать в DLT для разбора.

Ключевое отличие от RabbitMQ: нельзя просто «вернуть в очередь» — управляют через offset и отдельные retry/DLT-топики. Слепой retry в той же партиции блокирует всех потребителей этой партиции.

Redis Streams

У Streams есть PEL (Pending Entries List) — список доставленных, но ещё не подтверждённых (XACK) сообщений в рамках consumer group. Если потребитель упал, не подтвердив сообщение, оно остаётся в PEL:

  • XACK — подтвердить обработку (убрать из PEL).
  • XPENDING — посмотреть «зависшие» необработанные сообщения.
  • XCLAIM / XAUTOCLAIM — «перехватить» сообщения упавшего потребителя другим (по времени простоя) — механизм переобработки.
  • Счётчик доставок (delivery count) — если сообщение перевыдавалось много раз (poison), его перекладывают в отдельный dead-letter поток вручную.

(В простом LPUSH/RPOP на списках надёжной обработки падений нет — используют паттерн reliable queue RPOPLPUSH/LMOVE в «processing»-список, откуда возвращают при сбое.)


RabbitMQ vs Kafka

Аспект RabbitMQ Kafka
Модель очередь задач (умный брокер) лог событий (умный потребитель)
После чтения сообщение удаляется (после ack) остаётся (retention), читается по offset
Потребители конкурируют за сообщения (обычно один обработает) много групп читают одни данные независимо
Порядок в пределах очереди в пределах партиции
Маршрутизация гибкая (exchange, routing key, topic) по топику/партиции (проще)
Пропускная способность высокая очень высокая (сотни тыс./млн сообщений/с)
Повтор чтения нет (удалено) да (перечитать с нужного offset)
Типичное применение задачи, RPC, сложная маршрутизация стриминг событий, аналитика, event sourcing, логи

Кратко: RabbitMQ — «выполни задачу» (короткоживущие сообщения, сложная маршрутизация); Kafka — «зафиксируй событие» (долгоживущий лог, много читателей, огромные объёмы).


Redis

Redis (REmote DIctionary Server) — сверхбыстрое in-memory хранилище «ключ-значение». Хранит данные в оперативной памяти (отсюда скорость — микросекунды), может сбрасывать на диск для персистентности. Однопоточный для команд (атомарность операций без блокировок).

Основные применения: кэш, хранилище сессий, счётчики/лимитеры, очереди задач, pub/sub, лидерборды, распределённые блокировки, rate limiting.


Redis: структуры данных

Redis — не «просто строки», а сервер структур данных:

  • String — строка/число/бинарь. SET key val, GET, INCR (атомарный счётчик), SETEX (с TTL).
  • Hash — объект «поле-значение». HSET user:1 name Вася age 30 — хранение объектов.
  • List — связный список (очередь/стек). LPUSH/RPUSH/LPOP/RPOP — простая очередь задач.
  • Set — множество уникальных значений. SADD, SISMEMBER, операции пересечения/объединения (теги, уникальные посетители).
  • Sorted Set (ZSet) — множество с весами (score), отсортированное. ZADD, ZRANGE — лидерборды, приоритетные очереди, рейтинги.
  • Stream — лог сообщений (аналог Kafka в миниатюре), с consumer groups.
  • Дополнительно: Bitmaps, HyperLogLog (приблизительный подсчёт уникальных), Geo.
SET session:abc "userdata" EX 3600     # значение с TTL 1 час
INCR page:views                         # атомарный счётчик
ZADD leaderboard 100 "player1"          # рейтинг
HSET user:1 name "Вася" age 30          # объект

Redis: персистентность

Хотя данные в памяти, Redis умеет сохранять их на диск:

  • RDB (snapshot) — периодические снимки всего датасета в файл. Компактно, быстрый рестарт, но при сбое теряются данные с последнего снимка.
  • AOF (Append Only File) — журнал всех операций записи. Надёжнее (меньше потерь), но файл больше и восстановление медленнее. Настраивается частота сброса (fsync: always/everysec/no).
  • Комбинированный режим — RDB + AOF: при включённом AOF (appendonly yes) в новых версиях по умолчанию файл AOF начинается с RDB-преамбулы (aof-use-rdb-preamble yes) — компромисс. Сам AOF по умолчанию выключен (appendonly no), т.е. из коробки работает только RDB.

Выбор зависит от требований: можно ли терять несколько секунд данных (тогда RDB/everysec), или нужна максимальная сохранность (AOF always, но медленнее).


Redis: кэширование и eviction

Redis чаще всего — кэш перед БД. Паттерны:

  • Cache-aside (lazy) — приложение сначала смотрит в кэш; если нет (cache miss) — читает из БД и кладёт в кэш. Самый частый.
  • Write-through — запись идёт и в кэш, и в БД синхронно.
  • Write-behind — запись в кэш, в БД асинхронно позже.

TTL — время жизни ключа (EXPIRE, SETEX). Eviction policies — что делать, когда память заполнена (maxmemory):

  • noeviction — новые записи отклоняются (ошибка).
  • allkeys-lru — вытеснять наименее недавно используемые (частый выбор для кэша).
  • allkeys-lfu — наименее часто используемые.
  • volatile-lru/volatile-ttl — только среди ключей с установленным TTL.

Инвалидация кэша — «одна из двух сложных задач в CS»: по TTL, по событию (при изменении данных удалять/обновлять ключ), по тегам/версиям ключей. Проблемы: устаревшие данные (stale), «промах-шторм» (cache stampede) при одновременном истечении.


Redis: транзакции, Pub/Sub, блокировки

Транзакции — MULTI / EXEC: команды между ними выполняются последовательно и атомарно (без вклинивания других). WATCH — оптимистичная блокировка (отменить транзакцию, если ключ изменился). Не полноценные ACID-транзакции с откатом ошибок команд.

Lua-скрипты (EVAL) — выполняются атомарно на сервере; удобны для сложной атомарной логики (например, безопасный rate limiter).

Pub/Sub — публикация/подписка на каналы (PUBLISH/SUBSCRIBE) — простой обмен сообщениями в реальном времени. Минус — сообщения не сохраняются (нет подписчика — потеряно). Для надёжности — Redis Streams.

Распределённые блокировки — SET key val NX PX 30000 (установить, только если нет, с TTL). Паттерн Redlock — блокировка на нескольких мастерах для надёжности. Используют, чтобы одну задачу не выполняли два процесса одновременно.

Rate limiting — счётчики с TTL или sliding window (часто через Lua для атомарности).


Redis: масштабирование

  • Репликация (master-replica) — реплики копируют мастер, обслуживают чтение; при отказе — переключение.
  • Redis Sentinel — мониторинг + автоматический failover (выбор нового мастера при падении).
  • Redis Cluster — шардирование данных по узлам (16384 хеш-слота), горизонтальное масштабирование записи и объёма; каждый шард может иметь реплики.

Что и когда выбирать

  • MongoDB — основное хранилище с гибкой схемой и вложенными документами; когда не нужны сложные связи/JOIN.
  • RabbitMQ — фоновые задачи, сложная маршрутизация, «выполни и подтверди».
  • Kafka — потоки событий, большие объёмы, много независимых потребителей, перечитывание, аналитика.
  • Redis — кэш, сессии, счётчики, лидерборды, блокировки, лёгкий pub/sub; когда нужна максимальная скорость и данные помещаются в память.

Часто используются вместе: PostgreSQL/Mongo (данные) + Redis (кэш/сессии) + Kafka/RabbitMQ (асинхронная обработка/события).


Вероятные вопросы

Что такое MongoDB и когда её выбирать? Документо-ориентированная NoSQL (BSON-документы, коллекции, гибкая схема). Когда данные вложены, схема гибкая, нужна горизонтальная масштабируемость и нет сложных связей/JOIN.

Embedding vs referencing в MongoDB? Embedding — вложить связанные данные в документ (быстрое чтение, атомарность, но дублирование); referencing — хранить ссылку (нормализация, доп. запрос/$lookup). Embedding для «один-к-немногим», referencing для «многие-ко-многим» и часто меняющихся данных.

Какие индексы в MongoDB? single, compound (левый префикс), multikey (массивы), text, geo, hashed, TTL, partial. explain показывает IXSCAN vs COLLSCAN.

Как масштабируется MongoDB? Replica Set (primary + secondary, oplog, выборы) для чтения/отказоустойчивости; sharding по shard key для объёма/записи.

Очередь vs лог событий (RabbitMQ vs Kafka концептуально)? Очередь — сообщение удаляется после обработки, обычно один потребитель («сделай»); лог — сообщения хранятся, много потребителей читают по offset («произошло»).

Гарантии доставки? at-most-once (можно потерять), at-least-once (возможны дубли — самый частый), exactly-once (без потерь/дублей, сложно). Idempotency потребителя делает at-least-once безопасным.

Как устроен RabbitMQ (exchange, routing)? Producer → exchange → (по routing key/binding) → queue → consumer. Типы exchange: direct, topic, fanout, headers. ack/nack, prefetch, DLX, TTL, durable.

Что такое DLX? Dead Letter Exchange — куда попадают необработанные/отклонённые/просроченные сообщения для ретраев и разбора.

Как устроена Kafka (топик, партиции, offset, consumer group)? Топик разбит на партиции (упорядоченный лог, offset). Порядок — в пределах партиции. Consumer group распределяет партиции между потребителями; параллелизм = число партиций.

Как Kafka обеспечивает надёжность? Репликация партиций (leader/followers, ISR), acks=all, retention для перечитывания, идемпотентный producer + транзакции для exactly-once.

RabbitMQ или Kafka — что выбрать? RabbitMQ — задачи, сложная маршрутизация, «выполни»; Kafka — стриминг событий, большие объёмы, много читателей, перечитывание.

Почему Redis быстрый? Хранит данные в оперативной памяти, однопоточная модель команд (атомарность без блокировок), эффективные структуры данных.

Какие структуры данных в Redis? String, Hash, List, Set, Sorted Set (ZSet), Stream, + Bitmaps/HyperLogLog/Geo. Под каждую задачу своя (счётчики, объекты, очереди, лидерборды).

Как Redis сохраняет данные (RDB vs AOF)? RDB — периодические снимки (компактно, риск потери с последнего снимка; включён по умолчанию); AOF — журнал операций (надёжнее, но больше/медленнее; по умолчанию appendonly no); часто комбинируют (AOF с RDB-преамбулой).

Что такое eviction policy? Стратегия вытеснения при заполнении памяти: allkeys-lru (частый выбор для кэша), lfu, volatile-*, noeviction.

Паттерны кэширования? Cache-aside (lazy, самый частый), write-through, write-behind. Инвалидация — по TTL/событию/версии.

Как сделать распределённую блокировку на Redis? SET key val NX PX ttl (только если нет + TTL); для надёжности — Redlock на нескольких мастерах.

Транзакции в Redis? MULTI/EXEC (атомарная последовательность), WATCH (оптимистичная блокировка), Lua-скрипты (атомарная логика на сервере). Полноценного отката ошибок команд нет.

Как масштабировать Redis? Репликация (чтение), Sentinel (мониторинг + failover), Cluster (шардирование по хеш-слотам).

Как эти системы работают вместе? Данные — БД (Postgres/Mongo), кэш/сессии — Redis, асинхронная обработка/события — RabbitMQ/Kafka.

Что делать с сообщением, которое не удалось обработать? Повторить (retry) с экспоненциальным backoff и лимитом попыток; после лимита — в Dead Letter Queue/Topic для разбора (не терять и не крутить вечно). Обработчик — идемпотентный (возможны дубли при ретраях). Временные ошибки повторяют, постоянные (валидация) — сразу в DLQ.

Что такое poison message и чем опасен? Сообщение, которое никогда не обработается (битые данные/баг). При бесконечных ретраях блокирует очередь/партицию. Решение — лимит попыток и отправка в DLQ.

Как сделать retry в RabbitMQ? Через DLX + retry-очередь с TTL: nack(requeue=false) → DLX → отложенная очередь (TTL) → назад в основную; счётчик попыток в заголовке, после лимита — в DLQ. requeue=true для poison — антипаттерн (зацикливание в classic queue; в quorum queue ограничено delivery-limit).

Как обрабатывать ошибки в Kafka? Нельзя «вернуть в очередь» — управляют offset. Ручной коммит после успеха; retry-топики с задержкой + Dead Letter Topic, чтобы не блокировать партицию; pause/resume при недоступности сервиса.

Как обрабатываются падения в Redis Streams? Через PEL (pending list): неподтверждённые (XACK) сообщения остаются; XPENDING — смотреть зависшие, XCLAIM/XAUTOCLAIM — перехватить у упавшего потребителя; poison — вручную в dead-letter поток.

Что такое экспоненциальный backoff и зачем джиттер? Увеличение задержки между повторами (1с→5с→30с), чтобы не перегружать упавший сервис; джиттер (случайный разброс) — чтобы много потребителей не ретраили одновременно (thundering herd).