Redis и фоновые задачи
Запрос пользователя не должен ждать, пока уйдёт письмо, а база — выдерживать сотни одинаковых чтений одного списка. Обе задачи решает Redis: он держит горячие данные в памяти и принимает работу, которую можно выполнить позже. Но у этой скорости есть цена — устаревшие данные, потерянные задачи и воркеры, которые не переживают деплой. Разберём, как встроить Redis в Node-сервис так, чтобы он ускорял, а не ломал.
Содержание
- Где живёт Redis в сервисе
- Подключение и отказоустойчивость
- Кеш: cache-aside и TTL
- Инвалидация и согласованность
- Thundering herd и горячие ключи
- Rate limiting
- Сессии на Redis
- Очереди и BullMQ
- Ретраи, backoff и идемпотентность
- Провал, DLQ и зависшие задачи
- Cron и повторяющиеся задачи
- Остановка воркера
- Практика: TaskFlow
- Частые ошибки
- Ключевые тезисы для интервью
- Заключение
- Полезные ссылки
Где живёт Redis в сервисе
Redis — это хранилище в памяти с доступом по сети. В Node-сервисе он появляется, когда состояние перестаёт помещаться в процесс или должно быть общим для нескольких инстансов. Ролей обычно четыре:
| Роль | Что хранит | Можно ли потерять данные |
|---|---|---|
| Кеш | копии строк из базы, ответы внешних API | да, восстановится из источника |
| Эфемерное состояние | сессии, счётчики rate limit, локи | да, с деградацией |
| Очередь | задачи, расписания, статусы выполнения | нет, нужна персистентность |
| Pub/sub | сообщения между инстансами | да, доставка без гарантий |
Ключевое разделение — источник истины. Для кеша и сессий это PostgreSQL или внешняя система, а Redis хранит производные данные. Если Redis недоступен, запрос должен деградировать: прочитать из базы, попросить войти заново, отклонить лишний запрос. Если же в Redis лежит очередь, потеря означает пропавшие задачи, и к его настройкам предъявляются другие требования.
Вторая причина появления Redis — горизонтальное масштабирование. Пока процесс один, кеш можно держать в Map, а счётчики — в памяти. С двумя инстансами за балансировщиком локальный кеш начинает расходиться, сессии перестают находиться, а rate limit считается по половине трафика на каждом. Общее состояние переезжает в Redis.
Дальше речь только о серверной стороне: как открыть соединение, что кешировать и как не потерять задачи. Структуры данных Redis, политики eviction и персистентность — тема раздела «Базы данных»; здесь они упоминаются ровно настолько, насколько влияют на код сервиса.
Подключение и отказоустойчивость
Клиент Redis создаётся один раз на процесс и переиспользуется. Соединение на каждый запрос — та же ошибка, что и new Pool() в обработчике: лишний TCP-handshake и лишняя нагрузка на сервер.
// src/lib/redis.js
import { createClient } from 'redis';
import { config } from '../config.js';
import { logger } from './logger.js';
export const redis = createClient({
url: config.REDIS_URL,
socket: {
connectTimeout: 1_000,
reconnectStrategy: (retries) => Math.min(retries * 200, 2_000),
},
disableOfflineQueue: true,
});
redis.on('error', (err) => logger.error({ err }, 'redis error'));
export async function connectRedis() {
await redis.connect();
await redis.ping();
}
Разберём настройки:
connectTimeout— сколько ждать установки соединения. Без него первый запрос после сетевого сбоя может висеть десятки секунд.reconnectStrategy— задержка перед следующей попыткой; здесь она растёт до двух секунд. ВозвратErrorиз функции останавливает переподключение совсем.disableOfflineQueue: true— команды, отправленные во время обрыва, сразу отклоняются, а не копятся в памяти. Для пути запроса это правильный выбор: лучше быстро сходить в базу, чем ждать Redis.errorlistener — обязателен. Клиент —EventEmitter, и событиеerrorбез слушателя превращается вuncaughtExceptionи роняет процесс — подробнее в статье «EventEmitter и события».
У клиента воркера профиль противоположный:
| Настройка | Путь HTTP-запроса | Воркер и очередь |
|---|---|---|
| Offline queue | выключена | включена |
| Ретраи команды | мало | много или бесконечно |
| Таймаут | короткий | длинный |
| При недоступности | cache miss, 503 для rate limit | ждать и переподключаться |
Причина простая: у HTTP-запроса есть бюджет времени и живой клиент, который не будет ждать. У фоновой задачи спешить некуда, зато потеря команды означает потерянную работу.
На старте полезно дождаться готовности: await redis.connect() уже бросает ошибку, если соединения нет. Если клиент создан лениво, перед приёмом трафика проверяют redis.isReady или вызывают waitUntilReady() у ioredis. Это же место — readiness-проверка из статьи «Логирование и наблюдаемость»: redis.ping() с коротким таймаутом и кешем на пару секунд.
Для блокирующих операций и подписки нужен отдельный сокет: redis.duplicate() создаёт независимое соединение с теми же настройками. Один клиент, который одновременно читает кеш и блокируется на BRPOP, останавливает все остальные команды.
Ошибки Redis на пути чтения кеша не должны превращаться в 500:
async function readCache(key) {
try {
return await redis.get(key);
} catch (err) {
logger.warn({ err, key }, 'cache read failed');
return null; // считаем, что в кеше пусто
}
}
Такой try/catch — не «проглатывание ошибки»: инцидент попадает в лог, а запрос продолжает работать. Отказ кеша — это деградация по скорости, а не по доступности.
Кеш: cache-aside и TTL
Самый распространённый паттерн — cache-aside: приложение сначала спрашивает Redis, при промахе идёт в источник и кладёт результат обратно.
// src/cache/tasks.js
import { redis } from '../lib/redis.js';
import * as tasksRepo from '../repositories/tasks.js';
const TTL = 300;
export async function getTask(id) {
const key = `v1:task:${id}`;
const cached = await readCache(key);
if (cached !== null) {
return cached === 'null' ? null : JSON.parse(cached);
}
const task = await tasksRepo.findById(id);
if (!task) {
await redis.set(key, 'null', { EX: 30 });
return null;
}
const ttl = TTL + Math.floor(Math.random() * 60);
await redis.set(key, JSON.stringify(task), { EX: ttl });
return task;
}
Что здесь важно:
- TTL — это допустимая устареваемость, а не «срок хранения». Если данные должны быть свежими через минуту, TTL не может быть часом. Если допустимо отставание на час — незачем ходить в базу каждые пять секунд.
- Джиттер.
TTL + random(60)разводит истечение ключей, созданных в одном запросе или после деплоя. Без него сотни ключей исчезают одновременно и устраивают всплеск на базу. - Отрицательный кеш.
'null'с коротким TTL защищает от «пробивания»: клиент, который спрашивает несуществующийidв цикле, не должен каждый раз доходить до базы. Отдельный TTL здесь меньше — 30 секунд достаточно. - Ключ с версией. Префикс
v1:позволяет сменить формат значения, не вычищая Redis вручную: после деплоя старые ключи просто перестают читаться и истекают сами. - Только нужные поля. Кешируют DTO для ответа, а не ORM-сущность целиком: меньше памяти, меньше поводов инвалидировать при изменении схемы.
Память и eviction
Redis не «сам разберётся» с объёмом. Без TTL ключи живут до удаления, и кеш превращается в свалку: память растёт вместе с числом сущностей, а не с пользой от них. Верхняя граница задаётся на сервере:
maxmemory 2gb
maxmemory-policy allkeys-lru
Политика зависит от роли инстанса:
| Политика | Поведение | Где уместна |
|---|---|---|
noeviction | новые записи падают с ошибкой при заполнении | очередь, сессии, локи |
allkeys-lru | вытесняет давно не использованные ключи | чистый кеш |
volatile-lru | вытесняет только ключи с TTL | смешанный инстанс |
allkeys-lfu | вытесняет редко используемые | кеш с горячими и холодными данными |
Логические базы (SELECT 1, SELECT 2) не разделяют память и eviction: maxmemory общий на инстанс. Поэтому очередь и кеш не разводят «по номерам баз» — это не изоляция. Разводят по разным инстансам, если политики конфликтуют: allkeys-lru на общем Redis может вытеснить задачу из очереди ровно так же, как старую копию профиля.
Отдельная ловушка — большие значения. Ключ на несколько мегабайт занимает память, долго передаётся по сети и блокирует Redis на время операции. Списки и отчёты хранят постранично или не кешируют вовсе.
Инвалидация и согласованность
Кеш ускоряет чтение, но создаёт второй экземпляр данных, который нужно обновлять. Базовое правило: сначала база, потом кеш.
export async function updateTask(id, patch) {
const task = await tasksRepo.update(id, patch);
try {
await redis.del(`v1:task:${id}`);
} catch (err) {
logger.warn({ err, id }, 'cache invalidation failed');
}
return task;
}
Порядок важен по двум причинам. Если удалить ключ до commit, параллельное чтение успеет положить в кеш старое значение, и оно переживёт обновление. Если удаление после commit не удалось, в кеше останется старое значение до истечения TTL — поэтому ошибку логируют, но не роняют запрос: TTL остаётся страховкой.
Удаление, а не обновление — тоже осознанный выбор. del идемпотентен и не требует знать новое значение; запись в кеш после изменения может проиграть гонку с другим писателем и оставить устаревшую копию.
Гонка cache-aside
Даже правильный порядок не даёт строгой согласованности:
1. Читатель: промах, идёт в базу, получает старое значение
2. Писатель: коммитит новое значение, удаляет ключ
3. Читатель: кладёт старое значение в кеш
До истечения TTL кеш отдаёт данные, которых в базе уже нет. Это не баг реализации, а свойство паттерна. Смягчают его так:
- Короткий TTL на изменяемых данных — окно ограничено сверху.
- Single-flight (следующий раздел) не даёт двум читателям одновременно загружать одно и то же.
- Версионирование — ключ включает версию записи, и старый ключ просто не читается.
- Отложенное повторное удаление через сотни миллисекунд закрывает часть гонок, но гарантией не является.
Если данные обязаны быть свежими сразу, кеш не используют: читают из базы или строят инвалидацию на транзакционной очереди изменений.
Локальный кеш и pub/sub
Иногда кеш держат ещё и в памяти процесса — L1 перед Redis. Он быстрее, но у каждого инстанса свой. Обновлять его помогает pub/sub:
const subscriber = redis.duplicate();
await subscriber.connect();
await subscriber.subscribe('cache:invalidate', (message) => {
const { key } = JSON.parse(message);
localCache.delete(key);
});
Pub/sub — доставка без гарантий: сообщение не сохраняется, подписчик, который в этот момент переподключался, его не получит. Инстанс продолжит отдавать старое значение до истечения локального TTL. Поэтому L1 делают только для данных, где кратковременная рассинхронизация допустима, и всегда с TTL.
Thundering herd и горячие ключи
Представим популярный ключ, который истёк в момент пика: 1000 RPS одновременно не находят его в кеше и все идут в базу. Один пропущенный ключ превращается в тысячу одинаковых запросов, база уходит в очередь, ответы замедляются — и нагрузка растёт ещё сильнее. Это thundering herd, или cache stampede.
Меры, которые работают вместе:
1. Джиттер TTL. Уже знакомый приём: ключи не должны истекать синхронно.
2. Объединение запросов внутри процесса (single-flight). Пока один обработчик загружает значение, остальные ждут тот же промис:
const inflight = new Map();
export async function getTask(id) {
const key = `v1:task:${id}`;
const cached = await readCache(key);
if (cached !== null) return cached === 'null' ? null : JSON.parse(cached);
if (inflight.has(key)) return inflight.get(key);
const promise = loadAndCache(key, id).finally(() => inflight.delete(key));
inflight.set(key, promise);
return promise;
}
Это снимает всплеск внутри одного инстанса. Между инстансами остаётся N параллельных загрузок, где N — число процессов.
3. Распределённая блокировка. Один инстанс получает право пересчитать значение, остальные коротко ждут или отдают устаревшее:
const token = randomUUID();
const locked = await redis.set(`lock:${key}`, token, { NX: true, PX: 5_000 });
if (!locked) {
await sleep(50);
const retried = await readCache(key);
if (retried !== null) return JSON.parse(retried);
return tasksRepo.findById(id); // не ждём бесконечно
}
Снимать блокировку нужно только свою, сравнив токен, иначе можно удалить чужую:
if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('del', KEYS[1])
end
return 0
4. Stale-while-revalidate. В значение кладут { value, staleAt } и отдают данные даже после staleAt, запуская обновление в фоне. Пользователь получает быстрый, чуть устаревший ответ вместо ожидания. Плата — усложнение формата и риск отдавать устаревшее дольше, чем хотелось.
5. Прогрев после деплоя. Если кеш очищается при выкатке, первые запросы всегда идут в базу. Прогрев популярных ключей до включения трафика убирает этот всплеск.
Горячий ключ — отдельная проблема: один ключ на всех, и весь трафик идёт в один шард Redis. Помогает локальный L1 перед Redis, реплики для чтения или разбиение ключа на несколько копий с случайным выбором.
Rate limiting
Rate limit на Redis нужен, когда счётчик должен быть общим для всех инстансов. Простейший вариант — фиксированное окно: ключ на пользователя и минуту, INCR на каждый запрос.
const SCRIPT = `
local current = redis.call('INCR', KEYS[1])
if current == 1 then
redis.call('PEXPIRE', KEYS[1], ARGV[1])
end
return current
`;
export function rateLimit({ limit, windowMs, key }) {
return async (req, res, next) => {
const bucket = `rl:${key(req)}:${Math.floor(Date.now() / windowMs)}`;
try {
const count = await redis.eval(SCRIPT, {
keys: [bucket],
arguments: [String(windowMs)],
});
res.setHeader('x-ratelimit-limit', limit);
res.setHeader('x-ratelimit-remaining', Math.max(0, limit - count));
if (count > limit) {
res.setHeader('retry-after', Math.ceil(windowMs / 1000));
return res.status(429).json({ error: 'too many requests' });
}
next();
} catch (err) {
logger.warn({ err }, 'rate limit unavailable');
next(); // fail-open: Redis недоступен, не блокируем всех
}
};
}
Почему Lua, а не две команды подряд:
- Атомарность. Между
INCRиPEXPIREпроцесс может упасть. Счётчик останется без TTL и будет расти вечно: пользователь навсегда получит429, а ключ никто не удалит. Скрипт Redis выполняет целиком, без вклинивания других команд. PEXPIREтолько при создании. Продлевать TTL на каждом запросе нельзя: окно тогда никогда не закончится и лимит превратится в пожизненный запрет.- Один round-trip. Две команды — два сетевых обращения на горячем пути.
У фиксированного окна есть известный дефект: на границе двух окон можно сделать 2 × limit запросов подряд. Если это критично, берут скользящее окно (sorted set с метками времени) или token bucket — оба тоже реализуются Lua-скриптом, чтобы проверка и списание были атомарными.
Что ещё важно:
- Ключ выбирают по смыслу. Для логина — по IP и email, для API — по пользователю и маршруту. Один общий ключ на всех превращает лимит в глобальный выключатель.
429— не ошибка сервиса. Это ожидаемый ответ: его не логируют какerror, но считают в метриках.- Fail-open или fail-closed — решение продуктовое. Для публичного API при отказе Redis чаще пропускают запросы (fail-open), для защиты от брутфорса на логине — отклоняют (fail-closed). Выбор фиксируют явно, а не оставляют случайным.
- Redis на горячем пути — зависимость. Если лимит обязателен, его недоступность должна быть видна в readiness и метриках, иначе защита тихо исчезнет.
Сессии на Redis
Сессия — это состояние между запросами. Пока инстанс один, её можно держать в памяти; за балансировщиком любой следующий запрос может попасть на другой процесс, и пользователь «разлогинится». Поэтому сессии выносят в общий store:
// src/lib/session.js
import session from 'express-session';
import { RedisStore } from 'connect-redis';
import { redis } from './redis.js';
import { config } from '../config.js';
export const sessionMiddleware = session({
store: new RedisStore({ client: redis, prefix: 'sess:' }),
secret: config.SESSION_SECRET,
resave: false,
saveUninitialized: false,
rolling: true,
cookie: {
httpOnly: true,
secure: true,
sameSite: 'lax',
maxAge: 24 * 60 * 60 * 1000,
},
});
Детали, которые чаще всего ломаются:
- TTL store должен совпадать с
maxAge. Иначе сессия живёт в Redis дольше, чем cookie, или исчезает раньше, и пользователь вылетает посреди работы. rolling: trueпродлевает сессию на каждом запросе. Это удобно, но означает запись в Redis на каждый запрос. При высоком RPS дешевле фиксированное окно и явный refresh.- В сессии хранят минимум.
userId, версию прав, признак второго фактора. Профиль, корзину и большие объекты — в базу или отдельный кеш: сессия читается на каждом запросе. - Регенерация при логине. Идентификатор сессии меняют после аутентификации, иначе возможна фиксация сессии. Детали cookie и CSRF — в статье «Аутентификация в API».
- Отзыв всех сессий. Удалять ключи по шаблону через
KEYSнельзя — команда блокирует Redis. ХранятsessionVersionпользователя: при смене пароля версия растёт, и старые сессии считаются недействительными, даже если ещё лежат в Redis.
Перезапуск Redis без персистентности разлогинивает всех — для сессий это допустимая деградация. Для очереди такая же потеря означает пропавшие задачи, поэтому требования к RDB/AOF у этих ролей разные. Хранить сессии и очередь в одном инстансе с политикой allkeys-lru — плохая идея: вытеснение не различает типы данных.
Очереди и BullMQ
Очередь нужна, когда работу не обязательно делать внутри HTTP-запроса: отправить письмо, сгенерировать отчёт, синхронизировать данные, обработать вебхук. Она даёт три вещи: быстрый ответ пользователю, ретраи при сбоях и сглаживание пиков.
BullMQ — распространённая очередь для Node поверх Redis. В ней три роли:
| Компонент | Что делает |
|---|---|
Queue | принимает задачи от приложения |
Worker | забирает задачи и выполняет обработчик |
QueueEvents | отдаёт события о прогрессе и завершении |
Постановка задачи:
// src/queues/notifications.js
import { Queue } from 'bullmq';
import { config } from '../config.js';
const connection = { url: config.REDIS_URL, maxRetriesPerRequest: null };
export const notifications = new Queue('notifications', { connection });
export async function enqueueEmail({ userId, template, payload }) {
await notifications.add(
'send-email',
{ userId, template, payload },
{
jobId: `email:${userId}:${template}:${payload.date}`,
attempts: 5,
backoff: { type: 'exponential', delay: 2_000 },
removeOnComplete: 1_000,
removeOnFail: 5_000,
},
);
}
Разберём параметры:
jobId— дедупликация постановки. Пока задача с таким id существует в Redis, повторныйaddеё не создаст. Это защита от двойного клика и повторной доставки вебхука, но не от повторного выполнения.attemptsиbackoff— сколько раз пробовать и с какой задержкой. Экспоненциальный backoff без джиттера синхронизирует повторы всех задач и создаёт волны нагрузки; джиттер добавляют кастомной стратегией.removeOnComplete/removeOnFail— сколько завершённых и упавших задач хранить. Без ограничения Redis растёт вместе с трафиком: завершённые задачи — это тоже память, и однажды она кончится.- Размер данных. В
dataкладут идентификаторы, а не тело письма и не файл. Задача копируется в Redis и читается воркером; большой payload — это лишний трафик и память.
Воркер — отдельный процесс или отдельный пул внутри процесса:
// src/workers/notifications.js
import { Worker, UnrecoverableError } from 'bullmq';
import { config } from '../config.js';
import { logger } from '../lib/logger.js';
import { sendEmail } from '../services/email.js';
const connection = { url: config.REDIS_URL, maxRetriesPerRequest: null };
export const worker = new Worker(
'notifications',
async (job) => {
if (job.name !== 'send-email') {
throw new UnrecoverableError(`unknown job: ${job.name}`);
}
await sendEmail({
userId: job.data.userId,
template: job.data.template,
payload: job.data.payload,
signal: AbortSignal.timeout(10_000),
});
},
{ connection, concurrency: 10 },
);
worker.on('failed', (job, err) => {
logger.error({ jobId: job?.id, attempts: job?.attemptsMade, err }, 'job failed');
});
worker.on('error', (err) => logger.error({ err }, 'worker error'));
await worker.waitUntilReady();
Воркер блокируется на чтении из Redis, поэтому BullMQ держит для него отдельное соединение. Проще передавать не готовый клиент, а опции подключения — библиотека создаст нужные соединения сама. Если передаёте ioredis-инстанс, maxRetriesPerRequest должен быть null, иначе BullMQ откажется стартовать.
concurrency — сколько задач воркер выполняет одновременно. Для I/O-задач (письма, HTTP-вызовы) десяток нормален; для CPU-bound он не поможет — там нужны worker threads, о которых говорит статья «Worker Threads и cluster».
Ретраи, backoff и идемпотентность
Любая очередь с подтверждением даёт at-least-once: задача будет выполнена хотя бы один раз, но может — дважды. Воркер падает после отправки письма, но до подтверждения; блокировка истекает, задачу берёт другой воркер и отправляет письмо снова. Это не дефект BullMQ, а свойство распределённой системы.
Поэтому обработчик проектируют идемпотентным. Способы, от простого к надёжному:
1. Естественная идемпотентность. update ... where id = $1 можно выполнять сколько угодно раз — результат один. Так делают большинство операций записи.
2. Ключ идемпотентности. Перед эффектом занимают ключ:
async function sendEmail({ userId, template, payload }) {
const key = `email:sent:${payload.id}`;
const claimed = await redis.set(key, '1', { NX: true, EX: 7 * 24 * 3600 });
if (claimed === null) return; // уже обрабатывали
await mailer.send({ to: payload.email, template, idempotencyKey: payload.id });
}
У этого варианта есть цена: если процесс упадёт после SET, но до отправки, письмо не уйдёт никогда. Обратный порядок (сначала отправить, потом записать) даёт дубли при падении между шагами. Поэтому для внешних API используют их собственный idempotency-key, а у себя хранят состояние «в процессе / отправлено» и умеют доводить его до конца.
3. Уникальное ограничение в базе. insert ... on conflict do nothing по бизнес-ключу — самый надёжный вариант, потому что атомарность обеспечивает база, а не Redis.
4. Transactional outbox. Сначала в одной транзакции пишут бизнес-изменение и запись в outbox-таблицу, потом отдельный процесс публикует её в очередь. Это закрывает случай «база закоммитила, а задача не поставилась».
Что ретраить:
| Ошибка | Ретраить |
|---|---|
Таймаут, ECONNRESET, 5xx | да |
429 от внешнего API | да, с Retry-After |
400, 422, ошибка валидации | нет |
| Ошибка бизнес-правила | нет |
Для неретраибельных случаев в BullMQ есть UnrecoverableError: он прекращает попытки сразу, не дожидаясь attempts. Это важно, иначе «плохая» задача пять раз сходит во внешний API и пять раз получит 400.
У обработчика должен быть свой таймаут. Зависший fetch без AbortSignal держит блокировку задачи, а BullMQ считает воркер живым, пока тот продлевает lock. AbortSignal.timeout(10_000) внутри задачи — минимальная защита; подробнее о клиентах — в статье «HTTP-клиенты в Node.js».
Провал, DLQ и зависшие задачи
BullMQ не удаляет задачу при падении воркера сразу. Пока воркер работает, он продлевает блокировку (lockDuration, по умолчанию 30 секунд). Если процесс умер, продление прекращается, блокировка истекает, и задача возвращается в waiting — её возьмёт другой воркер.
Если задача «сталлится» повторно (maxStalledCount, по умолчанию 1), она уходит в failed с причиной job stalled more than allowable limit. Это защита от задачи, которая стабильно роняет воркер: бесконечно возвращать её в очередь нельзя.
Отдельной «мёртвой очереди» в BullMQ нет — её роль играет набор failed:
const failed = await queue.getFailed(0, 20);
const total = await queue.getFailedCount();
for (const job of failed) {
logger.warn({ jobId: job.id, name: job.name, reason: job.failedReason }, 'dead job');
}
Практика работы с ним:
removeOnFailограничивают. Без лимита failed-задачи хранятся вечно — та же утечка памяти, что и с завершёнными.- Смотрят не только количество, но и состав. Одна и та же задача, падающая у всех, — это баг кода, а не сбой сети.
- Ручной повтор — осознанный шаг.
job.retry()возвращает задачу в очередь; перед этим полезно понять причину, иначе она упадёт снова. - Ядовитую задачу изолируют. Если разбор нужен человеку, её переносят в отдельную очередь
*-dlqс данными и причиной, а исходную помечают обработанной. - Алерт на рост failed. Очередь, которая тихо наполняется ошибками, обнаруживается через неделю, когда письма уже давно не уходят.
worker.on('failed') логирует каждый провал, но не заменяет метрику: по логам трудно увидеть тренд, а queue.getFailedCount() даёт число для дашборда.
Cron и повторяющиеся задачи
Регулярные задачи — очистка, дайджесты, синхронизация — тоже живут в очереди. В BullMQ расписание хранится в Redis, поэтому перезапуск инстансов его не сбивает, а задача выполняется один раз, сколько бы воркеров ни было запущено.
await notifications.upsertJobScheduler(
'nightly-digest',
{ pattern: '0 6 * * *', tz: 'UTC' },
{
name: 'digest',
data: {},
opts: { attempts: 3, backoff: { type: 'exponential', delay: 5_000 } },
},
);
В версиях BullMQ до 5.16 то же делали через queue.add(..., { repeat: { pattern, tz } }); старый способ ещё работает, но планировщики удобнее: у расписания есть стабильный id, а upsert обновляет его, не создавая дубль.
Почему не node-cron:
- Каждый инстанс запустит свою копию. Три реплики — три отправленных дайджеста. BullMQ хранит расписание в одном месте и выдаёт задачу одному воркеру.
- Нет ретраев и истории. Упавший запуск
node-cronпросто не состоится; у очереди есть попытки, статус и failed-набор. - Нет распределения нагрузки. Долгая задача блокирует процесс, тогда как воркер можно масштабировать отдельно.
Что учесть:
- Отдельная очередь для тяжёлых cron-задач. Иначе ночная очистка займёт все слоты
concurrencyи задержит письма пользователям. - Идемпотентность обязательна. Запуск может повториться после падения — очистка и дайджест должны это переживать.
- Пропущенное окно не восстанавливается. Расписание живёт в Redis: если он был недоступен в момент запуска, окно теряется. Для критичных задач хранят последнюю успешную дату и делают catch-up вручную.
- Часовой пояс указывают явно.
tz: 'UTC'избавляет от сюрпризов при переходе на летнее время.
Остановка воркера
Воркер нельзя убивать по SIGTERM сразу: в этот момент у него в руках задачи, и часть побочных эффектов уже выполнена. worker.close() перестаёт брать новые задачи и ждёт завершения активных:
process.on('SIGTERM', async () => {
logger.info('shutting down worker');
await worker.close(); // новые не берём, активные дожидаемся
await notifications.close(); // закрываем producer
await redis.quit(); // закрываем кеш-клиент
process.exit(0);
});
Детали, без которых остановка ломается:
- Порядок. Сначала сервер перестаёт принимать трафик (readiness в
503), потом закрывается HTTP, затем воркер, и только потом соединения. Если закрыть Redis раньше воркера, активная задача получит ошибку соединения. - Жёсткий дедлайн.
worker.close()ждёт столько, сколько выполняется задача. Зависший обработчик не должен держать деплой вечно, поэтому ожидание ограничивают и по истечении вызываютworker.close(true)— принудительное закрытие. waitUntilReady()на старте и в readiness. Пока воркер не подключился к Redis, он не готов обрабатывать задачи; readiness-проверка должна это учитывать.process.exit()— последним. До него нужно дождаться закрытия, иначе активная задача оборвётся, а лог о завершении не запишется.- В контейнере сигнал должен доходить до процесса. Если Node запущен как PID 1 и не обрабатывает
SIGTERM, дефолтное действие для PID 1 игнорируется; shell-обёртка безexecтоже не пересылает сигнал. Поэтому используют--init/tiniиexecв entrypoint — об этом в статье «Docker и деплой Node.js».
Остановка HTTP-сервера, дренаж и server.close() подробно разбираются в статье «Таймауты, ретраи и graceful shutdown»; у воркера та же логика, только вместо входящих запросов — задачи в работе.
Практика: TaskFlow
Добавим Redis и очередь к TaskFlow из статей «Express и middleware», «Конфигурация и валидация» и «Доступ к базам данных».
1. Клиент. src/lib/redis.js из раздела про подключение, REDIS_URL — в схему конфига. На старте await connectRedis(), в readiness — redis.ping() с таймаутом 300 мс и кешем на две секунды.
2. Кеш задач и проектов. getTask из раздела про cache-aside, TTL 5 минут с джиттером, отрицательный кеш на 30 секунд. Инвалидация — после успешного update/delete в сервисе:
// src/services/tasks.js
export async function updateTask(id, patch, userId) {
const task = await tasksRepo.update(id, patch, userId);
await invalidateTask(id);
return task;
}
Список задач не кешируют целиком: он зависит от фильтров и быстро устаревает. Кешируют карточку и справочники, которые меняются редко.
3. Rate limit. На POST /auth/login — 10 попыток в минуту по IP и email, fail-closed: при недоступности Redis логин лучше отклонить, чем открыть брутфорс. На остальные маршруты — лимит по userId, fail-open.
4. Очередь уведомлений. src/queues/notifications.js и src/workers/notifications.js из статьи. Создание задачи ставит письмо в очередь и сразу отвечает 201; воркер отправляет его с idempotency-key, равным id события. Ретраи — 5 попыток с экспоненциальной задержкой, removeOnComplete: 1000, removeOnFail: 5000.
5. Остановка. SIGTERM → startDraining() → server.close() → worker.close() с дедлайном 20 секунд → notifications.close() → pool.end() → redis.quit().
Что закрыто: горячие чтения не доходят до базы; кеш ограничен TTL и памятью; инвалидация не роняет запрос; лимит атомарен и переживает перезапуск инстансов; письма не теряются при сбоях и не дублируются; деплой не обрывает активные задачи.
Что добавляют дальше: отдельный инстанс Redis под очередь с noeviction и AOF, метрики глубины очереди и failed-задач, дашборд по попаданиям в кеш, а также тест, который проверяет идемпотентность обработчика при повторной доставке.
Частые ошибки
- Кеш без TTL. Память растёт бесконечно, а данные устаревают навсегда.
maxmemoryбез политики eviction. При заполнении новые записи падают сOOM command not allowed.- Кеш и очередь в одном Redis с
allkeys-lru. Вытеснение может удалить задачу. - Клиент Redis на каждый запрос. Лишние соединения и утечка сокетов.
- Нет
errorlistener. Обрыв соединения становитсяuncaughtException. - Offline queue на пути запроса. Команды копятся в памяти, а запрос ждёт недоступный Redis.
- Инвалидация до
commit. Параллельное чтение кеширует старое значение. KEYS *для инвалидации. Команда блокирует Redis на всё время обхода.- Синхронное истечение TTL. Сотни ключей исчезают разом и роняют базу запросами.
INCRиEXPIREдвумя командами. Счётчик без TTL блокирует пользователя навсегда.- Rate limit без ключа по смыслу. Один общий счётчик превращается в глобальный запрет.
- Сессия без TTL или с TTL больше cookie. Пользователь вылетает или остаётся в Redis лишние сутки.
- Большой объект в сессии. Он читается и пишется на каждом запросе.
jobIdвместо идемпотентности. Дедупликация постановки не защищает от повторного выполнения.- Ретрай
400и ошибок валидации. Пять бесполезных попыток и ложные алерты. - Задача без таймаута. Зависший
fetchдержит блокировку и слот воркера. removeOnCompleteбез лимита. Завершённые задачи копятся в Redis и съедают память.node-cronв каждой реплике. Одна задача выполняется столько раз, сколько инстансов.process.exit()доworker.close(). Активная задача обрывается на середине.- Публичный Redis. Порт без пароля и сети — прямой доступ ко всем данным и очереди.
Ключевые тезисы для интервью
- Redis — не источник истины, а ускоритель и общее состояние: кеш, сессии, лимиты, локи и очередь. Отказ Redis должен деградировать сервис, а не ронять его, кроме случаев, где потеря данных недопустима.
- Кеш ограничен с двух сторон: TTL задаёт допустимую устареваемость,
maxmemory-policy— объём памяти. Без TTL ключи живут вечно, без eviction новые записи падают сOOM. - Cache-aside согласован в конечном счёте: инвалидация идёт после
commit, гонка «прочитал старое — записал после удаления» закрывается коротким TTL, single-flight и версионированием ключей. - Thundering herd — это всплеск запросов в базу после исчезновения горячего ключа; гасят джиттером TTL, объединением запросов, распределённой блокировкой и stale-while-revalidate.
- Атомарность на Redis достигается Lua-скриптами и
SET NX:INCRиEXPIREпо отдельности оставляют счётчики без TTL, аGET+DELдля лока удаляет чужую блокировку. - Клиент на пути запроса и клиент воркера настраиваются по-разному: fail fast с выключенной offline queue против долгих переподключений с сохранением команд.
- BullMQ даёт at-least-once:
jobIdдедуплицирует постановку, но не выполнение; идемпотентность обеспечивает обработчик, а падение воркера возвращает задачу через истечение блокировки и в итоге отправляет её в failed-набор.
Заключение
Redis ускоряет сервис ровно настолько, насколько предсказуемо ведёт себя при сбоях и деплое. Кеш должен быть ограничен TTL и памятью, инвалидация — идти после коммита, а лимиты и локи — выполняться атомарно. Очередь добавляет вторую модель отказа: задача может выполниться дважды, поэтому идемпотентность обработчика важнее, чем настройки ретраев.
Практический минимум: один клиент на процесс с error listener, отдельные профили подключения для HTTP и воркера, TTL с джиттером, Lua для счётчиков, jobId и уникальный ключ для идемпотентности, ограниченный removeOnComplete/removeOnFail и worker.close() до выхода из процесса. Дальше логично перейти к тестированию: кеш и очередь — как раз те места, где тест на повторную доставку и на недоступный Redis ловит больше всего проблем.
Полезные ссылки
- Redis: eviction —
maxmemory, политики вытеснения и их поведение - Redis:
EXPIRE— TTL,NX/XX/GTи удаление ключей - Redis:
SET—NX,PXи атомарная установка блокировки - Redis: Lua scripting — атомарные скрипты и
EVAL - node-redis — клиент,
createClient, переподключение и offline queue - ioredis — альтернативный клиент,
retryStrategyиmaxRetriesPerRequest - BullMQ — очереди, воркеры, события и соединения
- BullMQ: retrying failing jobs —
attempts, backoff иUnrecoverableError - BullMQ: job schedulers — cron-расписания и
upsertJobScheduler - BullMQ: graceful shutdown —
worker.close()и завершение активных задач - connect-redis — store сессий для
express-session - express-session — cookie,
rolling,resaveиsaveUninitialized - Доступ к базам данных — пул, транзакции и источник истины
- Логирование и наблюдаемость — readiness, метрики и health checks
- Аутентификация в API — cookie, сессии и отзыв токенов
- Асинхронность в Node.js —
AsyncLocalStorageи контекст запроса