# Laravel Scheduler: Automatizando Tarefas com Commands, Jobs e Events

[![](https://cdn.hashnode.com/res/hashnode/image/upload/v1768410455383/0bd1df06-acdb-4c34-a785-89970e57a405.jpeg align="center")](https://www.udemy.com/course/logica-de-programacao-com-pascalzim/?referralCode=E547897C16AD4FF23AED)

%[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:

```shell
0 2 * * * php backup.php
```

Significa:

```shell
┌ 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:

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

```shell
* * * * * sail artisan schedule:run
```

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

```plaintext
app/Console/Kernel.php
```

Exemplo dentro do Laravel:

```plaintext
$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:

```php
app/Console/Kernel.php
```

Comandos úteis

```plaintext
- 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
php artisan make:command TestCommand
```

```php
<?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:

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

Agendando o Command  
No `Kernel.php`:

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

```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
<?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
php artisan make:job TestJob
```

```php
// Arquivo: app/jobs/TestJob.php

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

Arquivo kernel.php:

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

```shell
sail artisan schedule:list 
```

Lista todas as tarefas agendadas.

```shell

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:

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

Criando um listener:

```shell
php artisan make:listener TestListener
```

```php
<?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
<?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**

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

Execute:

```php
sail artisan schedule:run
```

Agora veja o evento sendo executado no log.

* * *

Arquivo kernel.php completo:

```php
<?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](https://crontab.cronhub.io/)  
[documentação do laravel](https://laravel.com/docs/10.x/scheduling#introduction)

* * *

[![](https://cdn.hashnode.com/res/hashnode/image/upload/v1768410463988/fe2bb649-a833-4462-ae56-faa9004ad8ee.jpeg align="center")](https://www.udemy.com/course/logica-de-programacao-com-pascalzim/?referralCode=E547897C16AD4FF23AED)

### 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.