Jak zvládate background joby a fronty?

Question

Accepted Answer

Pro **background joby** (práci, která by neměla blokovat HTTP odpověď), NestJS integruje **BullMQ** (frontu s Redis backendem) přes `@nestjs/bullmq`. Přidáte joby do fronty a zpracováte je asynchronně v oddělených workerech — uchovávajíce požadavky rychlé a spolehlivě zpracovávajíce těžkou nebo odloženou práci.

## Problém, který fronty řeší

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

## Nastavení fronty

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

## Přidání jobů do fronty (producent)

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

Producent přidá job (s možnostmi jako počty pokusů, backoff, zpoždění) a vrátí se ihned — uživatel nečeká na odeslání e-mailu.

## Zpracování jobů (worker/consumer)

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

Worker s dekorátorem `@Processor` konzumuje joby z fronty a provádí vlastní práci asynchronně — odděleně od cyklu request/response (a může běžet dokonce v oddělených procesech).

## Co fronty poskytují

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

## Proč na tom záleží

Zpracování background jobů s frontami je zásadní pro vytváření robustních, citlivých a škálovatelných backendu — a pochopení NestJS integrace BullMQ je důležité znalosti na úrovni senior vývojáře.

Jádrem hodnoty je přesun práce, která by neměla blokovat HTTP odpověď: posílání e-mailů, zpracování obrázků/videa, generování zpráv, synchronizace dat nebo volání pomalých externích služeb.

Provádění takové práce inline způsobuje, že uživatelé čekají, riskuje vypršení časového limitu požadavku a ztratíte práci, pokud selže — zatímco **zařazení do fronty** vám umožní odpovědět ihned, zatímco background **worker** ji zpracovává spolehlivě.

Beyond async offloading, fronty poskytují kritické produkční funkce: **automatické opakování s backoff** (odolnost vůči přechodným selháním), **zpožděné a naplánované joby**, **kontrola concurrency/rate-limitingu** a **perzistence** (Redis-backed joby přežijí pády/restartování, takže práce není ztracena).

Takž také **oddělují** producenty od konzumentů, což umožňuje nezávislé škálování.

Vnímání nastavení front, přidávání jobů s vhodnými možnostmi (opakování, zpoždění) a jejich zpracování v workerech je cenné pro architekturu skutečných aplikací, které elegantně zpracovávají těžkou nebo odloženou práci.

Toto je běžný, důležitý vzor v produkčních NestJS systémech a odráží zralé chápání vytváření responsivních, spolehlivých backendu, které jdou mimo jednoduchou komunikaci request-response.