Фоновые задачи: практический путь к надёжной очереди
Написать фоновую задачу легко. Сгенерировать отчёт, отправить письмо, сжать картинку — всё это выполняется вне основного запроса и умещается в несколько строк кода.
Сложное начинается потом: что будет, если задача оборвётся на середине? Если выполнится дважды? Если внешний сервис не ответит? Если сервер перезагрузится?
Эта статья про эти вопросы. Точнее — про то, как сделать очередь надёжной.
Почему setTimeout недостаточно
Самая простая «фоновая задача» выглядит так:
app.post('/orders', async (c) => {
const order = await createOrder(...)
setTimeout(() => sendReceipt(order), 0) // фон
return c.json(order)
})Это работает — ровно до перезапуска сервера. Если процесс погас, всё, что стояло в очереди, исчезло, и никто об этом не узнает.
Основной принцип такой: работа, которая должна быть выполнена, обязана лежать на диске, а не в памяти. То есть задача должна быть куда-то записана, потом взята и по завершении отмечена.
Это, собственно, и есть определение слова «очередь».
Идемпотентность — первое правило
В любой системе с повторами задача может выполниться несколько раз. Это не отступление, это нормальное положение дел.
Причина простая: воркер выполнил задачу, но упал до того, как пометил её завершённой. Очередь считает её всё ещё открытой и выдаёт снова.
Поэтому каждая задача должна давать тот же результат при двух выполнениях, что и при одном. Это называется идемпотентностью.
На практике вопрос обычно решается одной колонкой:
create table receipts (
id uuid primary key,
order_id uuid not null,
idempotency_key text not null unique,
created_at timestamptz not null default now()
);И внутри задачи:
await db.insert(receipts)
.values({ orderId, idempotencyKey: `receipt:${orderId}` })
.onConflictDoNothing()Вторая попытка молча не делает ничего. Это самая надёжная форма, потому что защита стоит не в логике приложения, а в ограничении базы.
При выборе ключа есть важное правило: он должен вытекать из самой работы, а не быть случайным. receipt:${orderId} — правильно. crypto.randomUUID() — неправильно: он будет разным на каждой попытке и ни от чего не защитит.
Повторы: правильные и неправильные ошибки
Вторая крупная ошибка — считать все сбои одинаковыми.
Ошибки делятся на два вида.
Временные могут пройти сами: обрыв сети, 503 от внешнего API, лимит соединений базы. Их нужно повторять.
Постоянные не пройдут никогда: неверные данные, несуществующий пользователь, ошибка валидации. Повторять их — тратить ресурсы и забивать логи.
В коде это различие должно быть явным:
try {
await sendReceipt(order)
} catch (err) {
if (err.status >= 400 && err.status < 500) {
throw new PermanentError(err.message) // не повторяем
}
throw err // временная — повторяем
}Интервал повторов должен быть экспоненциальным: 1 секунда, 2, 4, 8, 16. Причина практическая: если внешний сервис лежит, долбить его каждую секунду не даст ему подняться.
Случайная добавка тоже полезна. Если сто задач получили ошибку одновременно и все повторят ровно через 2 секунды, вы сами устроите атаку.
Очередь мёртвых писем
Что делать с задачей, когда попытки закончились?
Худший вариант — удалить её. Задача исчезнет, и никто не узнает.
Второй плохой вариант — повторять бесконечно. Одна битая задача забьёт очередь и завалит логи.
Правильное решение — очередь мёртвых писем: невыполненные задачи уходят в отдельную таблицу и остаются там.
create table jobs_dead (
id uuid primary key,
type text not null,
payload jsonb not null,
attempts int not null,
last_error text,
failed_at timestamptz not null default now()
);Ценность этой таблицы в том, что она сообщает вам о наличии проблемы. Я добавляю к ней простую проверку: каждое утро смотреть, что количество строк равно нулю. Не ноль — надо разбираться.
Помните: если в очередь мёртвых писем никто не смотрит, она превращается просто в отложенное удаление.
Postgres или Redis
Теперь главный выбор. Во многих проектах фраза «нужна очередь» мгновенно превращается в «ставим Redis». Я советую этот шаг отложить.
Очередь на Postgres не требует дополнительной инфраструктуры, если Postgres у вас уже есть (а он есть почти всегда). Вся магия в одном запросе:
update jobs
set status = 'running', started_at = now()
where id = (
select id from jobs
where status = 'pending' and run_after <= now()
order by run_after
for update skip locked
limit 1
)
returning *;for update skip locked — ключ ко всей строке. Он гарантирует, что даже при одновременных запросах нескольких воркеров каждый получит свою задачу. Ни блокировок, ни дублей.
Кроме того, в Postgres есть транзакции: создание задачи и запись бизнес-данных можно выполнить в одной транзакции. Это большое преимущество — состояние «заказ создан, а связанная с ним задача потерялась» становится невозможным.
С Redis такой гарантии нет: база и очередь — две разные системы, и между ними всегда есть небольшое окно.
Когда нужна очередь на Redis (BullMQ и подобные)? Признаков три:
- Большой объём задач — тысячи в секунду. Postgres справится и здесь, но появится вопрос роста таблицы и вакуума.
- Нужна готовая инфраструктура: планирование, приоритеты, ограничение скорости, отслеживание прогресса. Написать это самому — несколько дней работы.
- Нужна готовая панель для просмотра задач.
Если ни одного из трёх нет, начинайте с Postgres. Переехать потом несложно, потому что логика задач не меняется — меняется только хранилище.
Одна ловушка с запланированными задачами
Если приложение работает в нескольких экземплярах, обычный cron или декоратор @Cron запустится в каждом. Ежедневный отчёт уйдёт трижды.
Я сталкивался с этой проблемой не раз и подробно писал о ней в отдельной статье. Коротко: планирование тоже должно проходить через очередь — один экземпляр ставит задачу, один из воркеров её забирает.
В Postgres это можно сделать простой блокировкой:
select pg_try_advisory_lock(12345);Замок возьмёт только один экземпляр, остальные пропустят шаг.
Наблюдение: хватит трёх чисел
Если очередь невидима, вы не узнаете, что она сломалась. Я слежу за тремя числами:
- Длина очереди — количество ожидающих задач. Растёт — не хватает воркеров.
- Возраст самой старой задачи — сколько минут она ждёт. Это полезнее длины, потому что напрямую показывает задержку.
- Размер мёртвой очереди — должен быть нулём.
Все три достаются одним SQL-запросом и подключаются к простому алерту. Это работает и без сложной системы мониторинга.
Вывод
Минимум, необходимый для надёжной очереди:
- Задача хранится на диске, а не в памяти.
- Каждая задача идемпотентна, а ключ вытекает из самой работы.
- Временные и постоянные ошибки разделены.
- Повторы экспоненциальные, со случайной добавкой.
- Невыполненные задачи уходят в мёртвую очередь, и кто-то в неё смотрит.
- Три числа под наблюдением.
В этом списке нет ни одной сложной технологии. Postgres, одна таблица и for update skip locked — для многих проектов этого достаточно. А к Redis вы перейдёте, когда появится явный признак, а не потому, что так модно.