Hogyan működnek a sor alapú feladatok a Laravelben?

Question

Accepted Answer

A Laravel **queue rendszere** lehetővé teszi, hogy időigényes feladatokat (e-mailek küldése, fájlok feldolgozása, lassú API-k hívása) **a háttérben** futtassa, így a felhasználó gyors választ kap. A feladatok **Jobs** formájában vannak beágyazva, a sorra helyezve, és különálló **worker** folyamatok dolgozzák fel azokat.

## A problémák, amelyeket a sorok megoldanak

```text
Slow work done inline makes the user wait and risks request timeouts:
  ✗ sending emails, processing images/video, generating reports, calling slow APIs
  ✓ QUEUE it → respond to the user immediately → a worker handles it in the background
```

## Feladat definiálása és elküldése

```php
<?php
// php artisan make:job ProcessPodcast
class ProcessPodcast implements ShouldQueue {
    public function __construct(public Podcast $podcast) {}

public function handle(): void {
        // the slow work — runs in a WORKER, not the web request
        $this->podcast->process();
    }
}
```

```php
// dispatch the job — pushes it onto the queue, returns IMMEDIATELY
ProcessPodcast::dispatch($podcast);
ProcessPodcast::dispatch($podcast)->delay(now()->addMinutes(10));   // delayed
```

A `ShouldQueue` implementálása egy feladatot sorba állíthatóvá tesz. A `dispatch()` a sorra helyezi és azonnal visszatér — a felhasználó nem vár a munka befejezésére.

## Feladatok feldolgozása (workerek)

```bash
php artisan queue:work          # run a worker to process queued jobs
# in production: run workers as a supervised process (Supervisor) or use Horizon
```

Egy külön **worker** folyamat leszedi a feladatokat a sorból és futtatja azokat. A sor backend-jei közé tartoznak a Redis, adatbázis, SQS stb.

## Megbízhatósági funkciók

```php
class ProcessPodcast implements ShouldQueue {
    public $tries = 3;             // retry up to 3 times on failure
    public $backoff = 60;          // wait 60s between retries
    public function failed(Throwable $e): void { /* handle final failure */ }
}
```

```text
✓ Retries with backoff (resilience), failed-job handling
✓ Persistence (jobs survive restarts via the queue backend)
✓ Laravel Horizon → a dashboard for monitoring/managing Redis queues
```

## Miért fontos

A sor alapú feladatok elengedhetetlenek az alacsony válaszidejű, skálázható Laravel alkalmazások felépítéséhez — a lassú vagy halasztott munka eltávolítása a kérés cikluson kívül gyakori és fontos szükséglet, és a Laravel queue rendszere ezt elegánssá teszi.

Ez azért értékes tudás, mert az időigényes munka inline végzése (e-mailek küldése, média feldolgozása, jelentések generálása, lassú külső szolgáltatások hívása) megvártatja a felhasználóval, kéréstúlcsapás kockázatát rejti, és elveszíti a munkát, ha sikertelen — míg az **sor alapú feldolgozás** lehetővé teszi, hogy azonnal válaszolj a felhasználónak, míg egy háttérbeli **worker** megbízhatóan feldolgozza azt.

Az egyszerű aszinkron offloading-on túl a Laravel queue-ja fontos éles szintű képességeket biztosít: **automatikus újrapróbálkozás visszalépéssel** (rugalmasság az átmeneti hibák ellen), **perzisztencia** (a feladatok a queue backend-en keresztül túlélik a baleseteket/újraindításokat, így a munka nem vész el), sikertelen feladatok kezelése, halasztott elküldés és monitorozás Horizon-on keresztül.

Annak megértése, hogy hogyan kell feladatokat definiálni (`ShouldQueue`), elküldeni (azonnal visszatérve), feldolgozni workerekkel (`queue:work`, éles szintű felügyelettel), és konfigurálni a megbízhatósági funkciókat, fontos tudás a nehéz vagy halasztott munka kezeléséhez.

Mivel az alacsony válaszidejű alkalmazások rutin szinten szükségessé teszik a munka háttérbeli offloading-ját — és mivel a Laravel queue rendszere az elegáns, idiomatikus módja ennek beépített megbízhatósággal — a feladatok és sorok megértése gyakran releváns, fontos tudás az éles szintű Laravel alkalmazások felépítéséhez, amelyek gyorsak és megbízhatóak maradnak a valós terhelés mellett.