¿Cómo funcionan los trabajos en cola en Laravel?

Question

Accepted Answer

El **sistema de colas** de Laravel te permite diferir tareas que consumen tiempo (enviar correos, procesar archivos, llamar a APIs lentas) para que se ejecuten **en segundo plano**, de modo que el usuario reciba una respuesta rápida. Las tareas se encapsulan como **Jobs**, se pushean en una cola y son procesadas por procesos **worker** separados.

## Por qué es importante

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

## Definiendo y despachando 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
```

Implementar `ShouldQueue` hace que un job sea encolable. `dispatch()` lo pushea a la cola y retorna inmediatamente — el usuario no espera el trabajo.

## Procesando jobs (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
```

Un proceso **worker** separado extrae jobs de la cola y los ejecuta. Los backends de colas incluyen Redis, base de datos, SQS, etc.

## Características de confiabilidad

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

## Por qué es importante

Los trabajos en cola son esenciales para construir aplicaciones Laravel responsivas y escalables — descargar trabajo lento o diferido del ciclo de solicitud es una necesidad común e importante, y el sistema de colas de Laravel lo hace elegante.

Es valioso entenderlo porque hacer trabajo que consume tiempo en línea (enviar correos, procesar medios, generar reportes, llamar a servicios externos lentos) hace que los usuarios esperen, riesga tiempos de espera agotados, y pierde el trabajo si falla — mientras que **encolarlo** te permite responder al usuario inmediatamente mientras un **worker** en segundo plano lo procesa de forma confiable.

Más allá de la simple descarga asincrónica, las colas de Laravel proporcionan capacidades importantes de producción: **reintentos automáticos con retroceso** (resiliencia contra fallos transitorios), **persistencia** (los jobs sobreviven a fallos/reinicios a través del backend de colas, así que el trabajo no se pierde), manejo de jobs fallidos, despacho retrasado, y monitoreo a través de Horizon.

Entender cómo definir jobs (`ShouldQueue`), despacharlos (retornando inmediatamente), procesarlos con workers (`queue:work`, supervisados en producción), y configurar características de confiabilidad es conocimiento importante para construir aplicaciones que manejan trabajo pesado o diferido gracefully.

Ya que las aplicaciones responsivas rutinariamente necesitan descargar trabajo al segundo plano — y ya que el sistema de colas de Laravel es la forma elegante, idiomática de hacerlo con confiabilidad incorporada — dominar jobs y colas es conocimiento frecuentemente relevante e importante para construir aplicaciones Laravel de grado producción que se mantienen rápidas y confiables bajo cargas de trabajo del mundo real.