When working on a Laravel API, the task scheduling system plays a significant role in automating background jobs. This can help developers integrate business behavior into their applications more seamlessly.

What is Task Scheduling in Laravel 11?

Task scheduling in Laravel 11 is a feature that allows developers to automate recurring tasks, eliminating the need to manually set up cron jobs. Instead of relying on manual configuration, Laravel 11 provides a more efficient method using console routes, making task scheduling simpler and more streamlined for developers. In the past, developers often used cron jobs manually, but now Laravel offers a much more efficient approach through console routes.

Setting Up Scheduled Tasks

To begin, define any scheduled tasks inside your console routes (routes/console.php). This file is where you'll handle all the tasks that need to run in the background.

Creating a New Scheduled Task

Here’s an example of scheduling a task that runs every minute:

use Illuminate\Console\Scheduling\Schedule;

$schedule->command('ping')->everyMinute();

You’ll need a command to run this scheduled task, which we’ll create next.

Defining a Custom Command

We’ll create a command for our ping service, which checks multiple services at regular intervals. Run the following Artisan command to create a new command:

php artisan make:command PingCommand

In the PingCommand.php file, we define the command:

namespace App\Console\Commands;

use Illuminate\Console\Command;

class PingCommand extends Command
{
    protected $signature = 'ping';

    protected $description = 'Perform a ping check on registered services.';

    public function handle(): int
    {
        $this->info('Starting to ping services...');

        // Fetch services and ping them
        $services = Service::all();
        foreach ($services as $service) {
            $this->info('Pinging service: ' . $service->name);
            // Your logic for pinging the service
        }

        return self::SUCCESS;
    }
}

With this setup, your command will now ping services every minute.

Managing Large Scale Pings

Handling many pings at once can be overwhelming, especially if you're dealing with thousands or even millions of services.

Here’s how you can efficiently manage these tasks using Laravel’s job system and lazy collections.

Creating a Job to Manage Pings

If you have many pings to handle, it's best to create a job for each ping and dispatch them. Start by creating a job:

php artisan make:job SendPing

Inside the SendPing.php file, define the job logic:

namespace App\Jobs;

use App\Models\Service;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;

class SendPing implements ShouldQueue
{
    use Dispatchable;
    use InteractsWithQueue;
    use Queueable;
    use SerializesModels;

    public function __construct(
        public Service $service,
    ) {}

    public function handle(): void
    {
        // Logic to ping the service
        Http::get($this->service->url);
    }
}

Now, within your command, dispatch the job for each service:

foreach ($services as $service) {
    SendPing::dispatch($service);
}

This approach scales efficiently, even when dealing with a large number of services.

Handling Multiple Instances with Load Balancers

When scaling your Laravel app across multiple instances, such as behind a load balancer, it’s important to ensure that the same command isn't run on multiple instances simultaneously. Laravel provides a way to prevent overlapping of scheduled tasks:

$schedule->command('ping')
    ->withoutOverlapping()
    ->onOneServer();

This ensures that only one instance runs the ping command at a time, even if your application is running on multiple servers.

Error Handling and Notifications

It’s always a good idea to handle errors gracefully when working with scheduled tasks and background jobs. Laravel’s try-catch mechanism can help you handle any exceptions that may occur.

try {
    Http::get($service->url);
} catch (\Exception $e) {
    Log::error('Ping failed for service: ' . $service->name);
}

Additionally, Laravel has built-in support for notifications and error tracking, which can alert you when something goes wrong.