Kako funkcioniraju queued jobovi u Laravelu?

Question

Accepted Answer

Laravel's **queue system** vam omogućava odložiti vremenski zahtjevne zadatke (slanje e-mailova, obrada datoteka, pozivanje sporih API-ja) da se izvršavaju **u pozadini**, tako da korisnik dobije brz odgovors. Zadaci su enkapsulitani kao **Jobs**, postavljeni na red čekanja, i obrađeni od strane odvojenih **worker** procesa.

## Problem koji redovi čekanja rješavaju

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

## Definiranje i slanje joba

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

Implementiranje `ShouldQueue` čini job queueable. `dispatch()` ga postavlja na red čekanja i vraća se odmah — korisnik ne čeka da se rad izvrši.

## Obrada jobova (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
```

Odvojeni **worker** proces izvlači jobove sa reda čekanja i pokreće ih. Queue backendi uključuju Redis, bazu podataka, SQS, itd.

## Značajke pouzdanosti

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

## Zašto je važno

Queued jobovi su neophodni za izgradnju responsivnih, skalabilnih Laravel aplikacija — prebacivanje sporog ili odloženoga rada iz request ciklusa je česti, važan zahtjev, i Laravel's queue system to čini elegantnima.

Razumijevanje je vrijedno jer rad sa vremenski zahtjevnim zadacima inline (slanje e-mailova, obrada medija, generiranje izvještaja, pozivanje sporih vanjskih servisa) čini da korisnici čekaju, riskira timeout zahtjeva, i gubi rad ako to padne — dok ga **queuing** omogućava odmah odgovoriti korisniku dok background **worker** to obradi pouzdano.

Izvan jednostavnog async prebacivanja, Laravel's redovi čekanja pružaju važne production mogućnosti: **automatski retry-ovi sa backoff-om** (otpornost na prijelazne greške), **persistence** (jobovi se obrve van rušenja/restarta putem queue backend-a, pa se rad ne gubi), handling neuspješnih jobova, odgođeno slanje, i monitoring putem Horizon-a.

Razumijevanje kako definirati jobove (`ShouldQueue`), slati ih (vraćanjem odmah), obraditi ih sa workerima (`queue:work`, superviziran u produkciji), i konfigurirati značajke pouzdanosti je važno znanje za gradnju aplikacija koje elegantnano rukuju teškim ili odloženim radom.

Pošto responsive aplikacije rutinski trebaju prebaciti rad u pozadinu — i pošto je Laravel's queue system elegantan, idiomatski način da se to uради sa ugrađenom pouzdanošću — savladavanje jobova i redova čekanja je često-relevantno, važno znanje za gradnju production-grade Laravel aplikacija koje ostaju brze i pouzdane pod stvarnim workload-ovima.