Hogyan kezelsz background jobokat és sorokat?

Question

Accepted Answer

A **background jobokhoz** (olyan munka, amely nem szabad, hogy blokkolja a HTTP választ), a NestJS a **BullMQ**-val (egy Redis-alapú sor) integrálódik a `@nestjs/bullmq` segítségével. Jobokat adsz a sorhoz, és aszinkron módon feldolgozod őket külön workerekben — így a kérések gyorsak maradnak, és a nehéz vagy halasztott munkákat megbízhatóan kezeled.

## A probléma, amelyet a sorok megoldanak

```text
Some work is too slow or shouldn't block the request:
  ✗ sending emails, processing images/video, generating reports, calling slow APIs
  → doing it inline makes the user wait and risks timeouts/failures
  ✓ QUEUE the work → respond immediately → a worker processes it in the background
```

## Sor beállítása

```ts
@Module({
  imports: [
    BullModule.forRoot({ connection: { host: "localhost", port: 6379 } }),  // Redis
    BullModule.registerQueue({ name: "email" }),                            // a named queue
  ],
})
export class AppModule {}
```

## Jobokat hozzáadni a sorhoz (a termelő)

```ts
@Injectable()
export class NotificationService {
  constructor(@InjectQueue("email") private emailQueue: Queue) {}

async register(user: User) {
    await this.saveUser(user);
    // queue the email INSTEAD of sending it inline → respond to the user immediately
    await this.emailQueue.add("welcome", { userId: user.id }, {
      attempts: 3,                          // retry up to 3 times on failure
      backoff: { type: "exponential", delay: 5000 },
      delay: 60000,                          // optionally delay the job
    });
  }
}
```

A termelő hozzáad egy jobat (olyan opciókkal, mint újrapróbálkozások, backoff, késleltetés) és azonnal visszatér — a felhasználó nem vár az e-mail elküldésére.

## Jobokat feldolgozni (a worker/fogyasztó)

```ts
@Processor("email")
export class EmailProcessor extends WorkerHost {
  async process(job: Job) {
    switch (job.name) {
      case "welcome":
        await this.sendWelcomeEmail(job.data.userId);   // the actual work, in the background
        break;
    }
  }
}
```

Egy `@Processor` worker fogyasztja a jobokat a sorból, és végzi el a tényleges munkát aszinkron módon — a kérés/válasz cikluson kívül (és akár külön folyamatban is futhat).

## Mit nyújtanak a sorok

```text
✓ Async processing — offload slow work, respond to users instantly
✓ Retries & backoff — failed jobs retry automatically (reliability)
✓ Delayed/scheduled jobs — run work later or on a schedule (repeatable jobs)
✓ Rate limiting & concurrency control — bound how fast/many jobs run
✓ Persistence (via Redis) — jobs survive restarts; not lost if the app crashes
✓ Decoupling — producers and workers scale independently
```

## Miért számít

A background job feldolgozás sorokkal elengedhetetlen az erőteljes, érzékeny, skálázható back-endek felépítéséhez — és a NestJS BullMQ integrációjának megértése fontos senior szintű tudás.

Az alapvető érték az olyan munka offloadálása, amely nem szabad, hogy blokkolja a HTTP választ: e-mailek küldése, képek/videók feldolgozása, jelentések generálása, adatszinkronizálás, vagy lassú külső szolgáltatások meghívása.

Ilyen munka inline végzése azt eredményezi, hogy a felhasználók várnak, kérések időtúllépésének kockázata van, és a munka elvész, ha meghibásodik — míg a **sorba helyezés** lehetővé teszi az azonnali válaszadást, miközben egy háttérben futó **worker** megbízhatóan feldolgozza azt.

A tisztán aszinkron offloadálásán túlmenően a sorok kritikus termelési funkciókat biztosítanak: **automatikus újrapróbálkozások visszatéréssel** (rugalmasság az átmeneti hibákkal szemben), **késleltetett és ütemezett jobokat**, **párhuzamosság/sebesség-limitálás vezérlés**, és **perzisztencia** (Redis-alapú jobokat túlélik a lezuhanások/újraindítások, így a munka nem vész el).

Ezek **leválasztják** a termelőket a fogyasztóktól, így független skálázást tesznek lehetővé.

Az annak tudása, hogyan állíts be sorokat, hogyan adj hozzá jobokat megfelelő opciókkal (újrapróbálkozások, késleltetések), és hogy feldolgozd őket workerekben, értékes a valós alkalmazások architektálásához, amelyek nehéz vagy halasztott munkákat kecsesen kezelnek.

Ez egy gyakori, fontos minta a termelési NestJS rendszerekben, és az érett megértést tükrözi az olyan responsive, megbízható back-endek felépítésében, amelyek túlmutatnak az egyszerű kérés-válasz kezelésen.