როგორ მართავთ ფონის ამოცანებს და რიგებს?

Question

Accepted Answer

**ფონის ამოცანებებისთვის** (სამუშაო, რომელიც არ უნდა აკორებდეს HTTP პასუხს), NestJS ინტეგრირდება **BullMQ**-თან (Redis-დაფუძნებული რიგი) `@nestjs/bullmq`-ს მეშვეობით. თქვენ დაამატებთ ამოცანებს რიგში და ამუშავებთ მათ ასინქრონულად ცალკე ჯამურებში — ინახავთ მოთხოვნებს სწრაფად და საიმედოდ მართავთ მძიმე ან გადაკიდებულ სამუშაოს.

## პრობლემა რომელსაც რიგები წყვეტენ

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

## რიგის დაყენება

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

## ამოცანების დამატება რიგში (მწარმოებელი)

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

მწარმოებელი ამატებს ამოცანას (ვარიანტებით როგორიცაა მცდელობები, ბექოფი, დაგვიანება) და დაბრუნდება დაუყოვნებლივ — მომხმარებელი არ ელის ელფოსტის გაგზავნას.

## ამოცანების დამუშავება (ჯამური/მომხმარებელი)

```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` ჯამური მოიხმარს ამოცანებს რიგიდან და ასრულებს სწორ სამუშაოს ასინქრონულად — მოთხოვნის/პასუხის ციკლიდან ცალკე (და შეიძლება კი იმუშაოს ცალკე პროცესში).

## რას აწვდიან რიგები

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

## რატომ არის ეს მნიშვნელოვანი

ფონის ამოცანების დამუშავება რიგებით აუცილებელია სიმკაცრე, რეაქტიული, მასშტაბული ბექ-ენდების აგებისთვის — და NestJS-ის BullMQ ინტეგრაციის ცოდნა მნიშვნელოვანია უფროსი დონის ცოდნაა.

ძირითადი ღირებულება არის სამუშაოს გადატვირთვა, რომელიც არ უნდა აკორებდეს HTTP პასუხს: ელფოსტის გაგზავნა, სურათების/ვიდეოს დამუშავება, ანგარიშების გენერირება, მონაცემების სინქრონიზაცია, ან ნელი გარე სერვისების გამოძახება.

ასეთი სამუშაო ინლაინში გაკეთება აიძულებთ მომხმარებელს დაელოდოს, ანგარიშის გაშლის რისკი, და კარგავს სამუშაოს თუ ის მეტყველი — მაშინ როდესაც **რიგში დაყენება** საშუალებას გაძლევთ დაუყოვნებლივ პასუხი გაიცეთ, ხოლო ფონის **ჯამური** საიმედოდ ამუშავებს მას.

ასინქრონული გადატვირთვის გარდა, რიგები აწვდიან კრიტიკულ პროდუქციის ფუნქციებს: **ავტომატური მცდელობები ბექოფით** (ჩავარდნების წინააღმდეგ გამძლეობა), **გადაკიდებული და დაგეგმილი ამოცანები**, **პარალელიზმის/ტემპის შეზღუდვის კონტროლი**, და **შენახვა** (Redis-დაფუძნებული ამოცანები გადაურჩებიან ჩავარდნებს/გადატვირთვებს, ამიტომ სამუშაო არ წაიშლება).

ისინი ასევე **აღმოფხვრიან** მწარმოებელს მომხმარებელიდან, რაც საშუალებას აძლევს დამოუკიდებელ მასშტაბირებას.

რიგების დაყენების, ამოცანების დამატების შესაბამის ვარიანტებით (მცდელობები, დაგვიანება), და მათი ჯამურებში დამუშავების ცოდნა ღირებულია რეალური აპლიკაციების არქიტექტურისთვის, რომელიც მძიმე ან გადაკიდებული სამუშაოს ელეგანტურად მართავს.

ეს არის გავრცელებული, მნიშვნელოვანი პატერნი წარმოების NestJS სისტემებში და ასახავს სიმწიფე ბექ-ენდების აგებაში, რომელიც მიდის უბრალო მოთხოვნა-პასუხის დამუშავებაზე მეტად.