MongoDB, RabbitMQ, Kafka, Redis
Материал для подготовки к собеседованию (Middle / Senior). Объединённый раздел: NoSQL-хранилище (MongoDB — спрашивают реже, поэтому компактно) + брокеры сообщений (RabbitMQ, Kafka) и in-memory хранилище/кэш (Redis). Термины на английском там, где это принято.
Содержание
- MongoDB
- MongoDB: модель данных
- MongoDB: запросы и агрегации
- MongoDB: индексы
- MongoDB: транзакции и масштабирование
- Очереди vs стриминг: общее
- Гарантии доставки
- RabbitMQ
- Kafka
- Обработка упавших сообщений: retry и DLQ
- RabbitMQ vs Kafka
- Redis
- Redis: структуры данных
- Redis: персистентность
- Redis: кэширование и eviction
- Redis: транзакции, Pub/Sub, блокировки
- 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 с задержкой:
- Основная очередь → при ошибке
nack(requeue=false)→ сообщение уходит в DLX. - DLX направляет его в retry-очередь с TTL (например, 30с) и без потребителей.
- По истечении TTL сообщение из retry-очереди возвращается (через свой DLX) обратно в основную — новая попытка.
- Счётчик попыток хранят в заголовке (
x-death/ кастомный headerx-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 Topicorders.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).