Laravel Scheduler: Automatizando Tarefas com Commands, Jobs e Events

https://www.youtube.com/watch?v=ertkSaFs_24

* * *

Introdução

Primeiro de tudo, vamos entender o que é uma cron.

Uma cron (ou cron job) é uma tarefa agendada para executar automaticamente em determinados horários em sistemas Linux/Unix.

Ela é gerenciada por um serviço chamado cron, que roda em segundo plano (um daemon) verificando o tempo e executando comandos quando chega o horário programado.

Exemplo simples

Imagine que você quer fazer backup do banco todo dia às 2h da manhã.
Você cria uma cron job que executa um comando nesse horário automaticamente.

Exemplo de cron:

0 2 * * * php backup.php

Significa:

┌ minuto (0 - 59)
│ ┌ hora (0 - 23)
│ │ ┌ dia do mês (1 - 31)
│ │ │ ┌ mês (1 - 12)
│ │ │ │ ┌ dia da semana (0 - 7)
│ │ │ │ │
0 2 * * * comando

Ou seja:

Todo dia às 02:00 executar php backup.php

Exemplos comuns de cron jobs

• limpar arquivos temporários

• rodar backups

• enviar emails automáticos

• executar scripts de manutenção

• processar filas de jobs

Exemplo no Laravel

No Laravel, normalmente você configura uma única cron no servidor:

* * * * * sail artisan schedule:run

Isso faz o Laravel verificar a cada minuto se existe alguma tarefa agendada no:

app/Console/Kernel.php

Exemplo dentro do Laravel:

$schedule->command('emails:send')->daily();

Resumindo

Uma cron é basicamente:

Um agendador automático de tarefas no servidor.

Ele permite que programas rodem sem intervenção humana em horários específicos.

---

Agora vamos fazer no Laravel

https://youtu.be/BuDPsJbfl8c

* * *

Nesse tutorial, vamos ver 3 tipos de cron ou schedules no Laravel.

• Para comandos artisan

• Para jobs

• Para events

---

Automatizar tarefas é essencial em qualquer aplicação moderna. Envio de e-mails, processamento de dados, sincronizações, limpezas automáticas… tudo isso pode (e deve) rodar fora da requisição HTTP.

O Laravel Scheduler resolve isso de forma elegante.

Neste artigo você vai aprender:

• O que é o Scheduler

• Como agendar Commands

• Como agendar Jobs

• Como agendar Events

O que é o Laravel Scheduler?

O Scheduler permite definir tarefas agendadas diretamente no código, sem precisar criar múltiplas entradas no crontab.

Em vez disso, você configura apenas um cron no servidor, e o Laravel decide o que deve rodar.

Arquivo principal:

app/Console/Kernel.php

Comandos úteis

- sail artisan                = Lista todos os comandos CLI
- sail artisan schedule:list  = Lista todas as tarefas agendadas
- sail artisan schedule:work  = Inicia o agendador de tarefas
- sail artisan schedule:run   = Roda todos os comandos agendados
- sail artisan queue:work     = Inicia o processamento de tarefas na fila como um daemon 
- sail artisan horizon        = Ativa o pacote do horizon
- sail artisan horizon:status = Obtenha o status atual do Horizon
- sail artisan horizon:clear  = Excluir todos os trabalhos da fila especificada

Criando um job
- sail artisan make:job TestJob

Criando um event
- sail artisan make:listener TestListener 


OBS: (daemon: é um programa que roda em segundo plano no sistema operacional, executando tarefas automaticamente sem interação direta do usuário.)

Exemplo 1 — Agendando Commands Artisan

Criando comando via terminal:

php artisan make:command TestCommand

<?php

// Arquivo criado: app/Console/Commands/TestCommand.php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\Log;

class TestCommand extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'app:test-command';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Command description';

    /**
     * Execute the console command.
     */
    public function handle()
    {
        Log::info('Test command in TestCommand.php');
    }
}

Defina o signature:

protected $signature = 'app:test-command';
protected $description = 'Command description';

Agendando o Command
No Kernel.php:

 protected function schedule(Schedule $schedule)
 {
   // Command defined in app/Console/Commands/TestCommand.php
   $schedule->command('app:test-command')->everyMinute();
 }

---

https://www.youtube.com/watch?v=qi6W28YfMXU

* * *

Exemplo 2 — Agendando Commands Artisan

No routes/console.php:

// Arquivo: routes/console.php copie e cole o código:

Artisan::command('app:my-teste', function () {
    Log::info('Test command in console.php');
})->purpose('Test command in console.php');

No Kernel.php:

<?php
    

    use Illuminate\Console\Scheduling\Schedule;
    
    protected function schedule(Schedule $schedule)
    {
        // Command defined in rotas/console.php
        $schedule->command('app:my-teste')->when(function () {
            return User::count() > 0;
        })->everyMinute();
    }

Exemplo 3 — Criando um Job

php artisan make:job TestJob

// Arquivo: app/jobs/TestJob.php

public function handle(): void
{
   Log::info('Test job executed at ' . now());
}

Arquivo kernel.php:

<?php
    use Illuminate\Console\Scheduling\Schedule;
    
    protected function schedule(Schedule $schedule)
    {
        // Job defined in app/Jobs/TestJob.php
        $schedule->job(TestJob::class)->everyMinute();
    }

Isso significa:

• A cada minuto é executado

• O job é enviado para a fila (Queue)

• Worker processa em background

Execute no terminal:

sail artisan schedule:list 

Lista todas as tarefas agendadas.

sail artisan schedule:work

Inicia o trabalhador agendado

---

https://www.youtube.com/watch?v=H4sTONx9Mio

* * *

Exemplo 4 — Agendando um event

No arquivo Providers/EventServiceProvider.php adicione:

protected $listen = [
   Registered::class => [
     SendEmailVerificationNotification::class,
   ],
   ScheduledTaskStarting::class => [
     TestListener::class,
   ],
],

Criando um listener:

php artisan make:listener TestListener

<?php

namespace App\Listeners;

use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Support\Facades\Log;

class TestListener
{
    /**
     * Create the event listener.
     */
    public function __construct()
    {
        //
    }

    /**
     * Handle the event.
     */
    public function handle(object $event): void
    {
        Log::info('TestListener handled event: ' . get_class($event) . ' at ' . now());
    }
}

Na pasta Providers tem um arquivo chamado: EventServiceProvider.php

<?php
// File in app/Providers/EventServiceProvider.php
namespace App\Providers;

use App\Listeners\TestListener;
use Illuminate\Auth\Events\Registered;
use Illuminate\Auth\Listeners\SendEmailVerificationNotification;
use Illuminate\Console\Events\ScheduledTaskStarting;
use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;
use Illuminate\Support\Facades\Event;
use PHPUnit\Metadata\Test;

class EventServiceProvider extends ServiceProvider
{
    /**
     * The event to listener mappings for the application.
     *
     * @var array<class-string, array<int, class-string>>
     */
    protected $listen = [
        Registered::class => [
            SendEmailVerificationNotification::class,
        ],
        ScheduledTaskStarting::class => [
            TestListener::class,
        ],
    ];

    /**
     * Register any events for your application.
     */
    public function boot(): void
    {
        //
    }

    /**
     * Determine if events and listeners should be automatically discovered.
     */
    public function shouldDiscoverEvents(): bool
    {
        return false;
    }
}

Defina a classe do evento criado dentro de ScheduledTaskStarting

ScheduledTaskStarting::class => [
 TestListener::class,
],

Execute:

sail artisan schedule:run

Agora veja o evento sendo executado no log.

---

Arquivo kernel.php completo:

<?php

namespace App\Console;

use App\Jobs\TestJob;
use App\Models\User;
use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Foundation\Console\Kernel as ConsoleKernel;
use Illuminate\Support\Facades\Log;

class Kernel extends ConsoleKernel
{
    /**
     * Define the application's command schedule.
     */
    protected function schedule(Schedule $schedule): void
    {
        // Command defined in app/Console/Commands/TestCommand.php
        $schedule->command('app:test-command')->everyMinute();

        // Command defined in rotas/console.php
        $schedule->command('app:my-teste')->when(function () {
            return User::count() > 0;
        })->everyMinute();

        // Job defined in app/Jobs/TestJob.php
        $schedule->job(TestJob::class)->everyMinute();

    }

    /**
     * Register the commands for the application.
     */
    protected function commands(): void
    {
        $this->load(__DIR__.'/Commands');

        require base_path('routes/console.php');
    }
}

No arquivo de log, podemos visualizar todos os logs que definimos no código. local: storage/laravel.log

---

Links importantes:

crontab.cronhub.io
documentação do laravel

---

Conclusão

O Laravel Scheduler centraliza e organiza a automação de tarefas da aplicação.
Ele torna o código mais limpo, evita configurações manuais no servidor e facilita a manutenção.

Quando combinado com Jobs, ele permite criar sistemas automatizados, escaláveis e robustos de forma elegante.