Comment fonctionne la planification des tâches ?

Question

Accepted Answer

Le **planificateur de tâches** de Laravel vous permet de définir des tâches planifiées (récurrentes) — comme des rapports quotidiens, du nettoyage ou l'envoi de rappels — de manière fluide **dans le code**, au lieu de gérer de nombreuses entrées cron individuelles. Une seule entrée cron exécute le planificateur de Laravel, qui exécute alors vos tâches définies à leurs horaires planifiés.

## Le problème qu'il résout

```text
Traditionally, each recurring task needs its own crontab entry on the server
→ scattered, hard to version-control, server-specific, error-prone.
Laravel: define ALL scheduled tasks in code (version-controlled), with ONE cron entry.
```

## Définir des tâches planifiées (dans le code)

```php
<?php
// in the schedule definition (app/Console/Kernel.php or routes/console.php)
$schedule->command('reports:generate')->daily();
$schedule->command('emails:reminders')->hourly();
$schedule->job(new CleanupJob)->everyFifteenMinutes();
$schedule->call(fn() => DB::table('sessions')->where(...)->delete())->dailyAt('02:00');

// expressive frequency methods:
->everyMinute() ->hourly() ->daily() ->weekly() ->monthly()
->dailyAt('13:00') ->weekdays() ->cron('0 0 * * *')   // or a raw cron expression
```

Les tâches sont définies avec une **API fluide et lisible** — vous pouvez planifier des commandes Artisan, des jobs en file d'attente ou des closures avec des méthodes de fréquence expressives (`daily()`, `everyFifteenMinutes()`, `dailyAt()`), tout dans du code versionné plutôt que dispersées dans les entrées crontab.

## L'entrée cron unique qui l'alimente

```bash
# add ONE cron entry on the server — runs the scheduler every minute
* * * * * cd /path-to-app && php artisan schedule:run >> /dev/null 2>&1
```

Cette unique entrée exécute `schedule:run` chaque minute ; Laravel vérifie laquelle de vos tâches définies est due et l'exécute. Vous ne touchez plus jamais au crontab — toute la planification vit dans le code.

## Options utiles

```php
$schedule->command('backup')->daily()
    ->withoutOverlapping()        // don't start if the previous run is still going
    ->onOneServer()                // in multi-server setups, run on only ONE server
    ->emailOutputOnFailure('ops@x.com');
```

## Pourquoi c'est important

La planification de tâches est importante pour toute application avec du **travail récurrent en arrière-plan** — rapports quotidiens, nettoyage périodique, envoi de rappels/digests, synchronisation de données, traitement par lots — ce qui est un besoin courant, et le planificateur de Laravel rend la gestion de telles tâches bien plus propre que les cron traditionnels.

L'avantage principal est de définir toutes les tâches planifiées **de manière fluide dans du code versionné** plutôt que comme des entrées crontab dispersées et spécifiques au serveur : cela maintient la logique de planification avec votre application (révisable, déployable, cohérente entre les environnements) et utilise une API expressive (`daily()`, `everyFifteenMinutes()`, `dailyAt()`) qui est bien plus lisible que la syntaxe cron.

La conception intelligente — une **unique entrée cron** exécutant `schedule:run` chaque minute, qui exécute alors vos tâches dues — signifie que vous configurez cron une fois et ne le touchez plus jamais, gérant toute la planification dans le code.

Comprendre comment définir des tâches planifiées (commandes, jobs, closures avec des méthodes de fréquence), la configuration d'une-entrée-cron-unique, et les options utiles (`withoutOverlapping`, `onOneServer` pour la sécurité multi-serveur) est une connaissance précieuse pour construire des applications qui effectuent du travail automatisé récurrent.

Puisque les tâches planifiées/périodiques sont une exigence fréquente du monde réel, et puisque le planificateur de Laravel offre une alternative propre, versionée et expressive à la gestion des entrées cron brutes, savoir comment fonctionne la planification de tâches est une connaissance importante de niveau senior pour construire des applications maintenables avec des opérations récurrentes automatisées — un besoin courant et pratique que le planificateur gère élégamment.