Як зробити фонові задачі в Node.js, які переживають збої провайдерів, деплої і повторні доставки: вибір черги, ідемпотентні обробники, повтори з backoff і jitter, dead-letter queue, outbox, коректна зупинка і моніторинг. Код перевірено на BullMQ 6.5.
- Опубліковано
- Читання
- 15 хв
- Автор
- Yaroslav Tsarenko

Рано чи пізно кожен бекенд на Node.js упирається в одне й те саме: запит, який мав відповісти за 100 мілісекунд, чекає на поштовий сервіс, генерує PDF або перераховує 40 тисяч рядків. Поки трафік малий, це терпимо. Потім провайдер пошти відповідає 503, клієнт повторює запит, і людина отримує два листи або жодного.
Цей гайд про те, як винести таку роботу у фонові задачі й зробити їх надійними. Я переписав його в листопаді 2026 року: 30 липня вийшов BullMQ 6 з помітними змінами, а старий приклад коду вже не запускається без правок. Весь код нижче я запускав на Node.js 25, BullMQ 6.5.4, Redis 7 і PostgreSQL 17 у Docker; виводи — справжні.
Досвід за цим текстом практичний. У SimplyDepo, американській платформі для e-commerce і керування замовленнями, я переносив розсилку сповіщень у чергу з повторами і dead-letter обробкою — після цього ендпоінти для користувачів перестали на неї чекати. Там само я переписав генерацію великих PDF-звітів у потокові фонові задачі, і зник цілий клас тайм-аутів в адмінці.
Коли роботу варто винести із запиту
Просте правило: якщо крок залежить від зовнішнього сервісу, займає більше кількох сотень мілісекунд або його можна безпечно зробити через секунду, йому місце у фоні. Типові кандидати:
- листи, SMS, push-сповіщення, вебхуки до партнерів;
- генерація PDF, зображень, експортів у CSV;
- синхронізація з CRM, складом, платіжним або логістичним провайдером;
- масові оновлення, перерахунки, імпорти;
- виклики LLM, які тривають секундами.
Різниця не лише у швидкості відповіді. Коли повільний крок сидить у запиті, повтор робить клієнт, і робить його наосліп: він не знає, чи лист уже пішов. Коли крок у черзі, повтор робить воркер за вашими правилами: з паузою, лімітом спроб і записом про те, що вже виконано. Запит лише зберігає замовлення разом із задачею і одразу відповідає.
Якщо ваш застосунок зібраний з AI-генератора, перевірте це місце першим: листи й інтеграції там майже завжди викликаються прямо в обробнику запиту. Про те, що ще варто перевірити в такому коді, я писав у статті про vibe coding і момент, коли потрібен розробник.
Яку чергу обрати: BullMQ, pg-boss чи SQS
Не обирайте чергу за бенчмарками. Обирайте ту, яку ваша команда зможе діагностувати в неділю ввечері, і ту, що не додає сервіс, який нікому обслуговувати.
BullMQ (Redis)
- Швидкість і можливостіпріоритети, rate limit, flows, Job Schedulers
- Потрібен Redisз persistence і maxmemory-policy noeviction
- DLQ збираєте саміfailed set плюс окрема черга
pg-boss (PostgreSQL)
- Без нового сервісузадачі живуть у вашому PostgreSQL
- DLQ і redrive вбудованіSKIP LOCKED, повтори з backoff
- Навантаження на базузадачі ділять ресурси з даними
Amazon SQS
- Майже без обслуговуваннякерований сервіс AWS
- DLQ через redrive policymaxReceiveCount на черзі
- Можливі дублікатиat-least-once, visibility timeout
| BullMQ | pg-boss | Amazon SQS | |
|---|---|---|---|
| Сховище | Redis | ваш PostgreSQL | керований сервіс AWS |
| Повтори з backoff | так, fixed, exponential, свої стратегії | так, exponential | через visibility timeout і повторну доставку |
| Dead-letter queue | збираєте з failed set і окремої черги | вбудована, з redrive | redrive policy з maxReceiveCount |
| Розклад задач | Job Schedulers | так | ні, потрібен EventBridge Scheduler або подібне |
| Коли брати | багато задач, пріоритети, rate limit | система на Postgres, помірне навантаження | продукт уже в AWS |
BullMQ — мій вибір за замовчуванням, коли в проєкті вже є Redis. Важливо: Redis для черги — це не кеш. Документація BullMQ радить увімкнути AOF-persistence і вимагає політику maxmemory-policy noeviction, інакше під тиском пам'яті Redis почне мовчки видаляти ключі задач.
pg-boss тримає задачі в PostgreSQL і, за README проєкту, спирається на SKIP LOCKED, має dead-letter queues з redrive і повтори з експоненційним backoff. Вимоги — Node.js 22.12+ і PostgreSQL 13+. Головний плюс — задача і бізнес-дані можуть записатися в одній транзакції. Головний мінус — черга ділить ресурси з вашою основною базою.
SQS знімає з вас обслуговування повністю. Ціна — модель at-least-once: AWS прямо пише, що повідомлення може бути доставлене більше одного разу навіть у межах visibility timeout. Отже, ідемпотентність — не опція, а вимога.
Окремо про serverless. На Vercel чи AWS Lambda немає довгоживучого процесу, тому класичний воркер BullMQ там не запустити: потрібен окремий хост для воркерів або керована черга з push-доставкою. У Vercel для цього є Vercel Queues (зараз у beta, з at-least-once доставкою), у AWS — SQS з тригером Lambda.
Що змінилося в BullMQ 6
BullMQ 6.0.0 вийшов 30 липня 2026 року, остання версія на момент написання — 6.5.4 від 2 листопада. Зміни, які зачеплять більшість проєктів:
- ioredis більше не встановлюється автоматично. Тепер це необов'язкова peer-залежність:
npm i bullmq ioredis. У ESM-проєкті передавайте вже створений клієнт, а не об'єкт з host і port — саме таку помилку я отримав на першому запуску старого коду. - Старі repeatable jobs видалили. Задачі за розкладом переносьте на Job Schedulers (
queue.upsertJobScheduler). Job#discard()прибрали. Щоб зупинити повтори, кидайтеUnrecoverableError.- Опцію
debounceвидалили на користьdeduplication. - Стану
pausedбільше немає: задачі в призупиненій черзі рахуються як waiting. Worker#resume()став асинхронним, його треба чекати черезawait.
Ось база, на якій побудовано решту прикладів: черга сповіщень з повторами за замовчуванням, окрема черга для «мертвих» задач і функція постановки з ключем ідемпотентності.
import { Queue } from "bullmq";
import { Redis } from "ioredis";
export const connection = new Redis(process.env.REDIS_URL!, { maxRetriesPerRequest: null });
export type Notification = { orderId: string; event: "order.shipped"; email: string };
export const notifications = new Queue<Notification>("notifications", {
connection,
defaultJobOptions: {
attempts: 5,
backoff: { type: "exponential", delay: 1000, jitter: 0.5 },
removeOnComplete: { count: 1000 },
removeOnFail: { age: 7 * 24 * 3600 },
},
});
export const deadLetters = new Queue("notifications-dlq", { connection });
export function enqueue(n: Notification) {
return notifications.add(n.event, n, { jobId: `${n.event}-${n.orderId}` });
}maxRetriesPerRequest: null — вимога BullMQ для з'єднань воркера: без неї ioredis кидатиме помилки на довгих блокувальних командах. removeOnComplete і removeOnFail не дають Redis розростатися: виконані задачі зберігаються останні 1000, невдалі — тиждень.
Ідемпотентність: розраховуйте, що задача виконається двічі
Жодна з черг вище не обіцяє, що задача виконається рівно один раз. Воркер може впасти після відправлення листа, але до підтвердження; деплой може вбити процес посеред задачі; SQS може доставити повідомлення двічі. Тому правило одне: повторне виконання має давати той самий результат, що й перше.
Захист має два рівні. Перший — ключ при постановці. BullMQ ігнорує задачу з jobId, який уже є в черзі. Ключ будуємо з бізнес-події, а не з випадкового UUID:
import { connection, enqueue, notifications } from "./queues";
const a = await enqueue({ orderId: "1001", event: "order.shipped", email: "ann@example.com" });
const b = await enqueue({ orderId: "1001", event: "order.shipped", email: "ann@example.com" });
const c = await enqueue({ orderId: "1002", event: "order.shipped", email: "not-an-email" });
console.log(a.id, b.id, c.id);
console.log(await notifications.getJobCounts("waiting", "delayed"));
await notifications.close();
await connection.quit();order.shipped-1001 order.shipped-1001 order.shipped-1002
{ waiting: 2, delayed: 0 }Три виклики — дві задачі: друга постановка того ж замовлення проігнорована. Два обмеження з документації BullMQ: jobId не може містити двокрапку і не може складатися лише з цифр. І дублікат відсікається, лише поки стара задача існує: після видалення через removeOnComplete той самий ключ знову приймається. Для вікна дедуплікації за часом є окрема опція deduplication з ttl.
Другий рівень — запис про виконання в базі. Він ловить те, що пропустив перший: повторну доставку після збою і повторну постановку після очищення черги. Таблиця проста:
create table notification_log (
key text primary key,
attempts int not null default 1,
sent_at timestamptz
);Обробник спершу «бронює» ключ, і якщо sent_at уже заповнено, нічого не робить. Конструкцію insert ... on conflict я докладніше розбирав у статті про PostgreSQL 19, де з'явився ON CONFLICT DO SELECT саме для таких get-or-create сценаріїв.
Лишається вузьке місце: лист пішов, а запис sent_at не встиг. Повністю закрити його може лише провайдер: якщо його API приймає ключ ідемпотентності, передавайте той самий job.id, і другий виклик він відкине сам.
Повтори з backoff і jitter
Більшість збоїв у фонових задачах тимчасові: провайдер повернув 503, мережа моргнула, спрацював rate limit. Їх лікує повтор, але не одразу і не всіма задачами одночасно.
У BullMQ експоненційна затримка рахується як 2 ^ (attempts - 1) * delay, а jitter від 0 до 1 додає випадковість (документація з повторів). У коді BullMQ 6 jitter працює так: затримка обирається випадково між (1 - jitter) і 100% розрахованого значення. Для наших налаштувань це виглядає так:
Чому jitter важливий: якщо провайдер упав на хвилину, за цю хвилину впадуть сотні задач. Без випадковості вони повторяться синхронно, тією самою хвилею, і покладуть провайдера знову, щойно він підніметься. Jitter розмазує цю хвилю в часі.
Скільки спроб ставити — залежить від того, скільки задача може чекати. Для листа про відправлення замовлення п'ять спроб із сумарною паузою до 15 секунд — розумний мінімум. Для синхронізації зі складом, яка може зачекати годину, краще 8–10 спроб і більшу базову затримку.
Тимчасові й постійні помилки, dead-letter queue
Не кожну помилку варто повторювати. Якщо адреса пошти невалідна або запису в базі немає, п'ять повторів дадуть п'ять однакових помилок і затримають сигнал про проблему. Такі помилки треба одразу відправляти туди, де їх побачить людина.
У BullMQ для цього є UnrecoverableError: задача з такою помилкою одразу йде у failed, навіть якщо attempts більше одиниці. Окремої DLQ у BullMQ немає, але її легко зібрати: подія failed спрацьовує на кожну невдалу спробу, тож перевіряємо, чи це була остання, і копіюємо задачу в окрему чергу.
Ось повний воркер. Функція sendEmail імітує провайдера, який двічі відповідає 503 і відкидає адресу без @:
import { Worker, UnrecoverableError, type Job } from "bullmq";
import { Pool } from "pg";
import { connection, deadLetters, type Notification } from "./queues";
const db = new Pool({ connectionString: process.env.DATABASE_URL, max: 5 });
let calls = 0;
async function sendEmail(n: Notification, idempotencyKey: string) {
if (!n.email.includes("@")) throw new UnrecoverableError(`invalid email: ${n.email}`);
calls++;
if (calls <= 2) throw new Error("provider 503");
console.log(` sent to ${n.email}, key ${idempotencyKey}`);
}
async function handle(job: Job<Notification>) {
const key = job.id!;
const { rows } = await db.query(
`insert into notification_log (key) values ($1)
on conflict (key) do update set attempts = notification_log.attempts + 1
returning sent_at`,
[key],
);
if (rows[0].sent_at) return "already sent";
await sendEmail(job.data, key);
await db.query(`update notification_log set sent_at = now() where key = $1`, [key]);
return "sent";
}
const worker = new Worker<Notification>("notifications", handle, { connection, concurrency: 5 });
worker.on("completed", (job, result) =>
console.log(`done ${job.id} attempt ${job.attemptsMade}: ${result}`),
);
worker.on("failed", async (job, err) => {
if (!job) return;
const final = err instanceof UnrecoverableError || job.attemptsMade >= (job.opts.attempts ?? 1);
console.log(`failed ${job.id} attempt ${job.attemptsMade}: ${err.message}${final ? " -> DLQ" : ", retrying"}`);
if (final) {
await deadLetters.add(
"dead",
{ queue: job.queueName, jobId: job.id, data: job.data, error: err.message },
{ jobId: job.id },
);
}
});
async function shutdown(signal: string) {
console.log(`${signal}: finishing active jobs`);
await worker.close();
await deadLetters.close();
await connection.quit();
await db.end();
process.exit(0);
}
process.on("SIGTERM", () => void shutdown("SIGTERM"));
process.on("SIGINT", () => void shutdown("SIGINT"));Запуск: REDIS_URL=redis://localhost:6379 DATABASE_URL=postgres://... npx tsx worker.ts. Вивід на двох задачах з попереднього кроку, після чого я надіслав процесу SIGTERM:
failed order.shipped-1001 attempt 1: provider 503, retrying
failed order.shipped-1002 attempt 1: invalid email: not-an-email -> DLQ
failed order.shipped-1001 attempt 2: provider 503, retrying
sent to ann@example.com, key order.shipped-1001
done order.shipped-1001 attempt 3: sent
SIGTERM: finishing active jobsЗадача з невалідною адресою пішла в DLQ з першої спроби, без чотирьох марних повторів. Задача з тимчасовою помилкою пройшла з третьої. jobId: job.id у DLQ гарантує, що одна задача не потрапить туди двічі, навіть якщо подію failed оброблять повторно. У DLQ лежить усе, щоб зрозуміти й повторити:
{
queue: 'notifications',
jobId: 'order.shipped-1002',
data: { orderId: '1002', event: 'order.shipped', email: 'not-an-email' },
error: 'invalid email: not-an-email'
}А тепер перевірка ідемпотентності: я видалив виконану задачу order.shipped-1001 і поставив її знову. Черга її прийняла, бо старої вже не було, але обробник лист не надіслав:
re-enqueued order.shipped-1001
done order.shipped-1001 attempt 1: already sentСама DLQ корисна лише тоді, коли на неї хтось дивиться. Мінімум — алерт, коли в ній з'являється хоч одна задача, і простий скрипт redrive, який після виправлення даних ставить задачі назад в основну чергу з тим самим jobId. У SQS той самий механізм вбудований: redrive policy з maxReceiveCount переносить повідомлення в DLQ, а AWS радить робити retention у DLQ довшим, ніж у вихідній черзі, бо для стандартних черг термін рахується від початкової постановки.
Outbox: задача, яка не губиться після транзакції
Найпідступніший баг у роботі з чергою — розрив між базою і чергою. Код зберігає замовлення, комітить транзакцію, потім ставить задачу в Redis — і падає між цими двома кроками. Замовлення є, листа ніколи не буде. Якщо поставити задачу до коміту, гірше: воркер може взяти її раніше, ніж замовлення з'явиться в базі, або транзакція відкотиться, а лист піде.
Outbox розв'язує це так: подія записується в таблицю outbox у тій самій транзакції, що й замовлення. Окремий процес-ретранслятор читає неопубліковані події і ставить їх у чергу.
create table orders (
id bigint generated always as identity primary key,
email text not null,
status text not null
);
create table outbox (
id bigint generated always as identity primary key,
topic text not null,
payload jsonb not null,
created_at timestamptz not null default now(),
published_at timestamptz
);
create index outbox_unpublished on outbox (id) where published_at is null;import { Pool } from "pg";
import { connection, notifications } from "./queues";
const db = new Pool({ connectionString: process.env.DATABASE_URL });
export async function shipOrder(email: string) {
const client = await db.connect();
try {
await client.query("begin");
const { rows: [order] } = await client.query(
`insert into orders (email, status) values ($1, 'shipped') returning id`,
[email],
);
await client.query(
`insert into outbox (topic, payload) values ('order.shipped', $1)`,
[{ orderId: String(order.id), event: "order.shipped", email }],
);
await client.query("commit");
return order.id;
} catch (error) {
await client.query("rollback");
throw error;
} finally {
client.release();
}
}
export async function relayOnce(batch = 100) {
const client = await db.connect();
try {
await client.query("begin");
const { rows } = await client.query(
`select id, topic, payload from outbox
where published_at is null
order by id
limit $1
for update skip locked`,
[batch],
);
for (const row of rows) {
await notifications.add(row.topic, row.payload, { jobId: `${row.topic}-${row.payload.orderId}` });
}
await client.query(
`update outbox set published_at = now() where id = any($1::bigint[])`,
[rows.map((r) => r.id)],
);
await client.query("commit");
return rows.length;
} catch (error) {
await client.query("rollback");
throw error;
} finally {
client.release();
}
}
const ids = [await shipOrder("bo@example.com"), await shipOrder("cy@example.com")];
console.log("orders", ids);
console.log("relayed", await relayOnce(), "then", await relayOnce());
console.log(await notifications.getJobCounts("waiting"));
await notifications.close();
await connection.quit();
await db.end();orders [ '1', '2' ]
relayed 2 then 0
{ waiting: 2 }for update skip locked дозволяє запустити кілька ретрансляторів: кожен бере свої рядки і не чекає на інших. А тепер чесна частина, яку часто пропускають. Якщо ретранслятор поставив задачу в Redis, але впав до коміту, рядок лишиться неопублікованим і буде поставлений ще раз. Outbox дає at-least-once, а не exactly-once, як іноді пишуть. Рятує те саме, що й вище: детермінований jobId і ідемпотентний обробник.
Довгі задачі і конкурентність
Задача, яка триває хвилини, — окремий клас проблем. Воркер BullMQ тримає lock на активну задачу і періодично його подовжує. Якщо подовжити не вдалося, наприклад синхронний код заблокував event loop, задачу вважають stalled: вона повертається в чергу для іншого воркера, а після перевищення maxStalledCount іде у failed. Значення за замовчуванням у BullMQ 6: lockDuration і stalledInterval — 30 секунд, maxStalledCount — 1.
Звідси три практичні висновки, які я виніс з генерації великих PDF-звітів у SimplyDepo:
- Не тримайте event loop. Важку синхронну роботу (рендер, стиснення, парсинг великих файлів) виносьте в sandboxed-процесор або worker thread, інакше lock не подовжиться.
- Стрімте, а не збирайте в пам'яті. Звіт на тисячі рядків краще читати курсором і писати потоком у файлове сховище, ніж будувати весь документ у пам'яті. Задача стає передбачуваною за пам'яттю і часом.
- Діліть на етапи. Якщо задачу можна розбити на «зібрати дані», «згенерувати файл», «надіслати посилання», повтор після збою почнеться з етапу, який упав, а не з нуля. Прогрес зберігайте через
job.updateProgress().
Конкурентність рахуйте, а не вгадуйте. concurrency: 5 на воркер, помножене на кількість воркерів, — це кількість одночасних запитів до бази і до провайдера. Якщо кожна задача тримає з'єднання з PostgreSQL, сумарна конкурентність має бути меншою за пул, інакше задачі чекатимуть на з'єднання, а не працюватимуть. Для провайдерів з обмеженням запитів у BullMQ є limiter: { max, duration } на рівні воркера; ліміт діє на всю чергу, а не на один процес. А перед оновленням Node.js на воркерах перегляньте гайд з оновлення Node.js 26 LTS: саме у фонових задачах та інтеграціях проблеми після оновлення спливають найчастіше, бо їх рідко хтось запускає вручну.
Коректна зупинка воркера під час деплою
Кожен деплой — це SIGTERM для всіх процесів воркерів. Якщо його не обробити, процес помре посеред задачі: лист може піти без запису sent_at, PDF залишиться напівзгенерованим.
У воркері вище за це відповідає shutdown. worker.close() перестає брати нові задачі й чекає на активні; у TypeScript-версії BullMQ вбудованого тайм-ауту немає. Тайм-аут задає оркестратор: у Kubernetes за замовчуванням terminationGracePeriodSeconds дорівнює 30 секундам, після чого процес отримує SIGKILL. Якщо ваші задачі тривають довше, збільште це значення або зробіть задачі коротшими.
Якщо процес усе ж убили, задача не зникне: lock спливе, BullMQ позначить її як stalled і віддасть іншому воркеру. Саме тому ідемпотентність — фундамент, а graceful shutdown — лише спосіб рідше на неї покладатися.
Моніторинг: чотири числа, без яких черга сліпа
Черга, яка ламається, не кидає помилок у логах API. Вона тихо накопичує задачі. Тому я з першого дня стежу за чотирма показниками:
| Показник | Що показує | Коли тривожитися |
|---|---|---|
| Глибина черги (waiting + delayed) | чи встигають воркери | росте кілька хвилин поспіль |
| Вік найстарішої задачі в waiting | реальна затримка для користувача | більший за ваш SLA, наприклад 5 хвилин |
| Частка failed за годину | здоров'я провайдерів і коду | різкий стрибок |
| Розмір DLQ | задачі, що потребують людини | будь-яке значення більше нуля |
Найпростіша перевірка, яку можна запускати з cron і відправляти в Telegram або Slack:
import { connection, deadLetters, notifications } from "./queues";
const counts = await notifications.getJobCounts("waiting", "active", "delayed", "failed");
const [oldest] = await notifications.getJobs(["waiting"], 0, 0, true);
const oldestWaitSec = oldest ? Math.round((Date.now() - oldest.timestamp) / 1000) : 0;
const dead = await deadLetters.count();
console.log({ ...counts, oldestWaitSec, dead });
if (oldestWaitSec > 300 || dead > 0) console.log("ALERT notifications queue needs attention");
await notifications.close();
await deadLetters.close();
await connection.quit();{
waiting: 2,
active: 0,
delayed: 0,
failed: 1,
oldestWaitSec: 13,
dead: 1
}
ALERT notifications queue needs attentionАлерт спрацював через задачу в DLQ — саме так і має бути. Для логів додайте до кожного запису queue, jobId, attemptsMade і тривалість: з цими полями будь-яку скаргу користувача можна простежити від запиту до конкретної спроби.
Чек-лист перед продакшеном
| Перевірка | Як переконатися |
|---|---|
| Повільне винесено із запиту | ендпоінт не викликає зовнішніх сервісів синхронно |
Детермінований jobId |
ключ з бізнес-події, без двокрапки, не лише цифри |
| Ідемпотентний обробник | повторний запуск задачі не дає другого ефекту |
| Повтори з backoff і jitter | attempts і backoff.jitter задані явно |
| Постійні помилки не повторюються | UnrecoverableError для невалідних даних і 4xx |
| DLQ з алертом | є алерт і скрипт redrive |
| Outbox для подій після транзакції | немає queue.add() поруч із commit без outbox |
| Redis налаштований як сховище | persistence увімкнено, noeviction |
| Graceful shutdown | worker.close() на SIGTERM, grace period більший за найдовшу задачу |
| Моніторинг | глибина, вік найстарішої задачі, частка failed, розмір DLQ |
| BullMQ 6 | встановлено ioredis, repeatable jobs перенесено на Job Schedulers |
Що зробити цього тижня
Почніть з аудиту: знайдіть у коді всі місця, де запит чекає на пошту, PDF або зовнішній API. Для кожного вирішіть, чи може він піти у фон. Потім додайте детермінований jobId, запис про виконання і DLQ з алертом — це три зміни, які дають найбільший ефект за найменший час. Якщо ви на BullMQ 5, заплануйте перехід на 6: прочитайте changelog, встановіть ioredis явно і перенесіть задачі за розкладом.
Фонові задачі — нецікава, але несуча частина продукту. Якщо хочете, щоб хтось переглянув вашу чергу чи переніс повільні кроки із запитів у воркери — від аудиту до продакшену, — подивіться, як я працюю з Next.js і Node.js-проєктами, або напишіть.
Було корисно?
– вподобань · – переглядів
Часті запитання
Що обрати для черги задач у Node.js: BullMQ, pg-boss чи SQS?
Якщо у вас уже є Redis або ви готові тримати керований Redis, BullMQ дає найбільше можливостей. Якщо вся система на PostgreSQL і навантаження помірне, pg-boss прибирає зайвий сервіс. Якщо продукт живе в AWS і ви не хочете обслуговувати інфраструктуру черги, беріть SQS з redrive policy.
Що таке dead-letter queue і навіщо вона потрібна?
Це окрема черга для задач, які не вдалося виконати після всіх спроб або які впали з постійною помилкою. Вона не дає задачам зникнути мовчки: на неї ставлять алерт, розбирають причину, виправляють дані або код і повертають задачі в роботу.
Як зробити задачу ідемпотентною?
Дайте кожній задачі стабільний ключ з бізнес-подій (наприклад, order.shipped-1001), використовуйте його як jobId при постановці, а в обробнику записуйте факт виконання в базу з унікальним ключем. Якщо провайдер підтримує ключі ідемпотентності, передавайте той самий ключ і йому.
Що змінилося в BullMQ 6?
BullMQ 6.0.0 вийшов 30 липня 2026 року. ioredis став необов'язковою peer-залежністю, яку треба встановити самостійно; старі repeatable jobs прибрали на користь Job Schedulers; Job#discard() видалили, замість нього кидають UnrecoverableError; стан paused прибрали.
Чи дає outbox pattern exactly-once доставку?
Ні. Outbox гарантує, що подія не загубиться між записом у базу і чергою, але задача може бути поставлена або виконана двічі. Тому outbox працює разом з ідемпотентними обробниками: at-least-once доставка плюс ідемпотентність дає результат, ніби задача виконалась один раз.