Kaip tu valdai foninį darbą ir eilutes (queues)?

Question

Accepted Answer

Norint tvarkyti **foninį darbą** (darbą, kuris neturėtų blokuoti HTTP atsakymą), NestJS integruojasi su **BullMQ** (Redis paremta eile) per `@nestjs/bullmq`. Jūs pridediate darbus į eilę ir juos apdorojate asinchroniškai atskiruose darbininkuose — palaikydami greitą užklausų atsakymą ir patikimai tvarkytiindami sunkų arba atidėtą darbą.

## Problema, kurią sprendžia eilės

```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
```

## Eilės nustatymas

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

## Darbų pridėjimas į eilę (produceris)

```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
    });
  }
}
```

Produceris prideda darbą (su variantais, tokiais kaip pakartojimas, backoff, uždelsimas) ir iš karto grąžina — vartotojas nečeka, kol el. laiškas bus išsiųstas.

## Darbų apdorojimas (darbininkas/vartotojas)

```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;
    }
  }
}
```

`@Processor` darbininkas vartoja darbus iš eilės ir faktiškai atlieka darbą asinchroniškai — atskirai nuo užklausos/atsakymo ciklo (ir gali net veikti atskirame procese).

## Ką teikia eilės

```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
```

## Kodėl tai svarbu

Foninio darbo apdorojimas su eilėmis yra būtinas norint sukurti patikimus, greitai reaguojančius, keičiamus galinės dalies serverius — ir NestJS BullMQ integracijos supratimas yra svarbus aukštesnio lygio žinios.

Pagrindinė vertė yra darbo, kuris neturėtų blokuoti HTTP atsakymo, iškėlimas: el. laiškų siuntimas, nuotraukų/vaizdo apdorojimas, ataskaitų generavimas, duomenų sinchronizavimas arba lėtų išorinių paslaugų iškvietimas.

Tokio darbo atlikimas tiesiai iš eilės verčia vartotojus laukti, rizikuoja užklausų timeout'ais ir praranda darbą, jei jis nepavyksta — tuo tarpu **eilės** jį įgalina iš karto reaguoti, o foniniam **darbininkui** jį patikimai apdoroti.

Be asinchroninio iškėlimo, eilės teikia kritines gamybos savybes: **automatiniai pakartojimas su backoff** (atsparumas trumpalaikėms klaidoms), **atidėlinti ir suplanuoti darbai**, **lygiagretumas/greičio ribojimas**, ir **persistence** (Redis paremti darbai išlieka po gedimų/paleidimo iš naujo, todėl darbas neprarandamas).

Jie taip pat **atskiria** producerį nuo vartotojo, leidžiančio nepriklausomai keisti mastelį.

Zinoti, kaip nustatyti eiles, pridėti darbus su atitinkamais variantais (pakartojimas, uždelsimas) ir juos apdoroti darbininkuose, yra vertinga realių aplikacijų architektūrai, kuri elegantiškai tvarkosi su sunkiu arba atidėtu darbu.

Tai dažnas, svarbus modelis gamybos NestJS sistemose ir atspindi branda supratimą statant greitai reaguojančias, patikimas galinės dalies serverius, kurie perauga paprastą užklausos-atsakymo tvarkymo ribas.