Como funcionam os trabalhos enfileirados no Laravel?

Question

Accepted Answer

O **sistema de fila** do Laravel permite que você adie tarefas que consomem tempo (enviar emails, processar arquivos, chamar APIs lentas) para executar **em segundo plano**, de modo que o usuário obtenha uma resposta rápida. As tarefas são encapsuladas como **Jobs**, inseridas em uma fila e processadas por processos **worker** separados.

## O problema que as filas resolvem

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

## Definindo e despachando um 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` torna um job enfileirável. `dispatch()` o insere na fila e retorna imediatamente — o usuário não espera pela execução do trabalho.

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

Um processo **worker** separado retira jobs da fila e os executa. Os backends de fila incluem Redis, banco de dados, SQS, etc.

## Recursos de confiabilidade

```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 que isso importa

Os jobs enfileirados são essenciais para criar aplicações Laravel responsivas e escaláveis — transferir trabalho lento ou adiado do ciclo de requisição é uma necessidade comum e importante, e o sistema de filas do Laravel torna isso elegante.

Entender isso é valioso porque fazer trabalho que consome tempo inline (enviar emails, processar mídia, gerar relatórios, chamar serviços externos lentos) faz os usuários esperarem, arrisca timeouts de requisição e perde o trabalho se falhar — enquanto **enfileirar** permite que você responda ao usuário imediatamente enquanto um **worker** em segundo plano o processa com confiabilidade.
\
aiém da simples transferência assíncrona, as filas do Laravel fornecem recursos importantes para produção: **tentativas automáticas com backoff** (resiliência contra falhas transitórias), **persistência** (jobs sobrevivem a travamentos/reinicializações via backend de fila, então o trabalho não é perdido), tratamento de jobs que falharam, despacho atrasado e monitoramento via Horizon.

Entender como definir jobs (`ShouldQueue`), despachá-los (retornando imediatamente), processá-los com workers (`queue:work`, supervisionados em produção) e configurar recursos de confiabilidade é conhecimento importante para criar aplicações que lidam com trabalho pesado ou adiado graciosamente.

Como aplicações responsivas frequentemente precisam transferir trabalho para o segundo plano — e uma vez que o sistema de filas do Laravel é a forma elegante e idiomática de fazer isso com confiabilidade integrada — dominar jobs e filas é conhecimento frequentemente relevante e importante para criar aplicações Laravel em nível de produção que permanecem rápidas e confiáveis em cargas de trabalho do mundo real.