Come funzionano i job in coda in Laravel?

Question

Accepted Answer

Il **sistema di code** di Laravel ti permette di rimandare compiti che richiedono molto tempo (invio di email, elaborazione di file, chiamate a API lente) per eseguirli **in background**, così l'utente ottiene una risposta veloce. I compiti sono incapsulati come **Job**, inseriti in una coda ed elaborati da processi **worker** separati.

## Il problema che le code risolvono

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

## Definire e inviare un job

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

Implementare `ShouldQueue` rende un job mettibile in coda. `dispatch()` lo inserisce nella coda e ritorna immediatamente — l'utente non aspetta che il lavoro venga completato.

## Elaborare job (worker)

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

Un processo **worker** separato estrae i job dalla coda e li esegue. I backend di coda includono Redis, database, SQS, ecc.

## Funzionalità di affidabilità

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

## Perché è importante

I job in coda sono essenziali per costruire applicazioni Laravel reattive e scalabili — scaricare il lavoro lento o rinviato dal ciclo di richiesta è un'esigenza comune e importante, e il sistema di code di Laravel lo rende elegante.

Capirlo è prezioso perché fare il lavoro pesante inline (inviare email, elaborare media, generare report, chiamare servizi esterni lenti) fa aspettare gli utenti, rischia timeout delle richieste e perde il lavoro se fallisce — mentre **metterlo in coda** ti permette di rispondere immediatamente all'utente mentre un **worker** in background lo elabora in modo affidabile.

Oltre al semplice offloading asincrono, le code di Laravel forniscono importanti funzionalità di produzione: **retry automatici con backoff** (resilienza contro guasti transitori), **persistenza** (i job sopravvivono a crash/riavvii tramite il backend di coda, quindi il lavoro non va perso), gestione dei job falliti, invio ritardato e monitoraggio tramite Horizon.

Capire come definire job (`ShouldQueue`), inviarli (ritornando immediatamente), elaborarli con worker (`queue:work`, supervisionati in produzione), e configurare le funzionalità di affidabilità è una conoscenza importante per costruire applicazioni che gestiscono il lavoro pesante o rinviato con eleganza.

Poiché le applicazioni reattive hanno routinariamente bisogno di scaricare il lavoro in background — e poiché il sistema di code di Laravel è il modo elegante e idiomatico per farlo con affidabilità integrata — dominare i job e le code è una conoscenza frequentemente rilevante e importante per costruire applicazioni Laravel di livello produttivo che rimangono veloci e affidabili sotto carichi di lavoro reali.