Skip to content

Як зробити фонові задачі в 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, які тривають секундами.
Без чергиЗ чергоюPOST /ordersзберегти замовленнячекати на поштовий сервісзгенерувати PDF рахункуповільна відповідь або тайм-аутклієнт повторює, лист іде двічіPOST /ordersзберегти замовлення + задачушвидка відповідьу запиті нічого повільноговоркер: лист, PDFповтори, backoff, DLQ

Різниця не лише у швидкості відповіді. Коли повільний крок сидить у запиті, повтор робить клієнт, і робить його наосліп: він не знає, чи лист уже пішов. Коли крок у черзі, повтор робить воркер за вашими правилами: з паузою, лімітом спроб і записом про те, що вже виконано. Запит лише зберігає замовлення разом із задачею і одразу відповідає.

Якщо ваш застосунок зібраний з 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 і SQS: що ви отримуєте і за що платите
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.

Ось база, на якій побудовано решту прикладів: черга сповіщень з повторами за замовчуванням, окрема черга для «мертвих» задач і функція постановки з ключем ідемпотентності.

ts
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 може доставити повідомлення двічі. Тому правило одне: повторне виконання має давати той самий результат, що й перше.

add()jobId з бізнес-ключаwaitingчекає на воркерactiveворкер тримає lockcompletedрезультат збереженоdelayedпауза backofffailedспроби вичерпаноDLQалерт і розбіруспіхпомилка, є спро…після паузиостання спроба
Життєвий цикл задачі в BullMQ

Захист має два рівні. Перший — ключ при постановці. BullMQ ігнорує задачу з jobId, який уже є в черзі. Ключ будуємо з бізнес-події, а не з випадкового UUID:

ts
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();
text
order.shipped-1001 order.shipped-1001 order.shipped-1002
{ waiting: 2, delayed: 0 }

Три виклики — дві задачі: друга постановка того ж замовлення проігнорована. Два обмеження з документації BullMQ: jobId не може містити двокрапку і не може складатися лише з цифр. І дублікат відсікається, лише поки стара задача існує: після видалення через removeOnComplete той самий ключ знову приймається. Для вікна дедуплікації за часом є окрема опція deduplication з ttl.

Другий рівень — запис про виконання в базі. Він ловить те, що пропустив перший: повторну доставку після збою і повторну постановку після очищення черги. Таблиця проста:

sql
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% розрахованого значення. Для наших налаштувань це виглядає так:

attempts: 5, delay: 1000 мс, jitter: 0.502468затримка, с0,5–1 сповтор 11–2 сповтор 22–4 сповтор 34–8 сповтор 4Заштриховано — випадкове вікно. Без jitter задачі, що впалив одну секунду, знову повторюються в одну секунду.

Чому jitter важливий: якщо провайдер упав на хвилину, за цю хвилину впадуть сотні задач. Без випадковості вони повторяться синхронно, тією самою хвилею, і покладуть провайдера знову, щойно він підніметься. Jitter розмазує цю хвилю в часі.

Скільки спроб ставити — залежить від того, скільки задача може чекати. Для листа про відправлення замовлення п'ять спроб із сумарною паузою до 15 секунд — розумний мінімум. Для синхронізації зі складом, яка може зачекати годину, краще 8–10 спроб і більшу базову затримку.

Тимчасові й постійні помилки, dead-letter queue

Не кожну помилку варто повторювати. Якщо адреса пошти невалідна або запису в базі немає, п'ять повторів дадуть п'ять однакових помилок і затримають сигнал про проблему. Такі помилки треба одразу відправляти туди, де їх побачить людина.

Обробник кинув помилкуТимчасова5xx, 429, тайм-аут, мережаПостійнапогані дані, 4xx, немає рядкаповтор з backoff + jitterкинути UnrecoverableErrorбез повторіввдалосяcompletedспроби вичерпаноDead-letter queueалерт, розбір, виправлення, redrive

У BullMQ для цього є UnrecoverableError: задача з такою помилкою одразу йде у failed, навіть якщо attempts більше одиниці. Окремої DLQ у BullMQ немає, але її легко зібрати: подія failed спрацьовує на кожну невдалу спробу, тож перевіряємо, чи це була остання, і копіюємо задачу в окрему чергу.

Ось повний воркер. Функція sendEmail імітує провайдера, який двічі відповідає 503 і відкидає адресу без @:

ts
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:

text
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 лежить усе, щоб зрозуміти й повторити:

text
{
  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 і поставив її знову. Черга її прийняла, бо старої вже не було, але обробник лист не надіслав:

text
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 у тій самій транзакції, що й замовлення. Окремий процес-ретранслятор читає неопубліковані події і ставить їх у чергу.

sql
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;
ts
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();
text
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 залишиться напівзгенерованим.

0 с30 сстандартний grace period у KubernetesSIGTERMпід час деплоюworker.close()нових задач не береактивні задачізавершуються, exit 0SIGKILLякщо ще працюєУбитий посеред задачі: lock спливає, задача стає stalled і повертається в чергу;наступний воркер виконає її ще раз. Ідемпотентність робить це безпечним.

У воркері вище за це відповідає 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:

ts
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();
text
{
  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-проєктами, або напишіть.

Було корисно?

– вподобань · – переглядів

LinkedInXTelegramFacebook
Потрібно таке для вашого продукту?Розробка на 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 доставка плюс ідемпотентність дає результат, ніби задача виконалась один раз.