Jak fungují zařazené úlohy (queued jobs) v Laravel?

Question

Accepted Answer

Systém **front** Laravel umožňuje odložit časově náročné úkoly (odesílání e-mailů, zpracování souborů, volání pomalých API) na spuštění **na pozadí**, aby uživatel obdržel rychlou odpověď. Úkoly jsou zapouzdřeny jako **Jobs**, vloženy do fronty a zpracovávány samostatným procesy **worker**.

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

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

## Definování a odesílání úlohy

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

Implementace `ShouldQueue` činí úlohu zařaditelnou do fronty. `dispatch()` ji vloží do fronty a vrátí se hned — uživatel nečeká na provedení práce.

## Zpracování úloh (workers)

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

Separátní proces **worker** vybírá úlohy z fronty a provádí je. Backend front zahrnují Redis, databázi, SQS, atd.

## Funkce spolehlivosti

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

## Proč na tom záleží

Zařazené úlohy jsou nezbytné pro vytváření responsivních a škálovatelných Laravel aplikací — přesunutí pomalé nebo odložené práce z cyklu požadavku je běžná a důležitá potřeba, a systém front Laravel to činí elegantním.

Rozmění je cenné, protože provádění časově náročné práce vloženě (odesílání e-mailů, zpracování médií, generování zpráv, volání pomalých externích služeb) nutí uživatele čekat, hrozí timeout požadavku a práce se ztratí, pokud selže — zatímco **zařazení** do fronty umožňuje okamžitě odpovědět uživateli, zatímco proces na pozadí **worker** ji zpracuje spolehlivě.

Beyond jednoduché asynchronní přesunutí, fronty Laravel poskytují důležité produkční schopnosti: **automatické opakování s backoff** (odolnost vůči přechodným selháním), **perzistence** (úlohy přežijí havárie/restartování prostřednictvím backend fronty, takže práce není ztracena), zpracování neúspěšných úloh, odložené odesílání a sledování přes Horizon.

Rozmění jak definovat úlohy (`ShouldQueue`), je odesílat (okamžitě se vrátit), zpracovávat je s workers (`queue:work`, pod dohledem v produkci) a konfigurovat funkce spolehlivosti je důležitá znalost pro vytváření aplikací, které zpracovávají těžkou nebo odloženou práci elegantně.

Pokud responsivní aplikace rutinně potřebují přesunut práci na pozadí — a protože systém front Laravel je elegantní, idiomatický způsob, jak to udělat se zabudovanou spolehlivostí — zvládnutí úloh a front je často relevantní, důležitá znalost pro budování produkčních Laravel aplikací, které zůstávají rychlé a spolehlivé v reálných pracovních zátěžích.