Planificateur de tâches Go (Golang) : cron, gocron, asynq…

Planificateur de tâches en Go (Golang) : de cron à asynq

Dans le développement serveur moderne en Go (Golang), il est souvent nécessaire d'exécuter du code selon un horaire ou avec un délai. Nettoyage du cache, envoi de notifications, génération de rapports — tout cela nécessite un planificateur de tâches fiable. Dans cet article, nous allons détailler trois approches populaires : le package standard cron, la bibliothèque légère gocron et la file d'attente distribuée asynq. Vous découvrirez quel outil choisir pour votre projet sur PythonLib.

1. Cron standard pour Go

La bibliothèque github.com/robfig/cron/v3 est la norme de facto pour planifier des tâches récurrentes en Go. Elle utilise la syntaxe familière des expressions cron (5 champs) et prend en charge les secondes, les fuseaux horaires et la récupération après panique.

Installation et exemple de base

go get github.com/robfig/cron/v3

Exemple d'un planificateur qui exécute une tâche toutes les 30 secondes :

package main

import (    "fmt"    "github.com/robfig/cron/v3")

func main() {    c := cron.New()        // Ajout d'une tâche avec une expression cron : toutes les 30 secondes    _, err := c.AddFunc("*/30 * * * * *", func() {        fmt.Println("Tâche exécutée :", time.Now())    })    if err != nil {        panic(err)    }        c.Start()        // Blocage de la goroutine main    select {}}

Caractéristiques clés :

Prise en charge des expressions cron standard (5 ou 6 champs avec secondes)
Récupération automatique après une panique dans une tâche
Possibilité de définir un fuseau horaire via cron.WithLocation()
Journalisation via cron.WithLogger()

Utilisation avancée : jobs chaînés

c := cron.New(cron.WithSeconds())

// Tâche nommée pour la gestionid, _ := c.AddFunc("@every 5m", func() {    fmt.Println("Exécution toutes les 5 minutes")})

// Suppression de la tâche par IDc.Remove(id)

// Arrêt du planificateurc.Stop()

La bibliothèque est idéale pour les tâches périodiques simples au sein d'un seul processus. Cependant, pour les systèmes distribués (plusieurs répliques d'un serveur Go), un verrouillage externe sera nécessaire pour éviter que la tâche ne s'exécute simultanément sur tous les nœuds.

2. Gocron — un planificateur léger avec chaînage

github.com/go-co-op/gocron propose une API plus moderne sans expressions cron. Au lieu de chaînes, vous utilisez des chaînages de méthodes. C'est particulièrement pratique pour les débutants.

Exemple avec gocron

package main

import (    "fmt"    "time"    "github.com/go-co-op/gocron")

func main() {    s := gocron.NewScheduler(time.UTC)        // Tâche exécutée toutes les 2 minutes    _, _ = s.Every(2).Minutes().Do(func() {        fmt.Println("2 minutes se sont écoulées")    })        // Tâche avec délai après le démarrage    _, _ = s.Every(1).Day().At("10:30").Do(func() {        fmt.Println("Tous les jours à 10:30")    })        s.StartBlocking()}

Avantages de gocron :

API lisible : .Every(10).Seconds()
Prise en charge intégrée des verrous distribués via Redis (optionnel)
Possibilité de définir une limite sur le nombre d'exécutions
Gestionnaires d'erreurs globaux et locaux

Si vous avez besoin d'une solution simple pour un microservice sans dépendances externes — gocron est un excellent choix. Il est plus léger que cron et ne nécessite pas de connaître la syntaxe des expressions cron.

3. Asynq — file d'attente distribuée de tâches différées

github.com/hibiken/asynq n'est pas seulement un planificateur, mais un système de files d'attente complet basé sur Redis. Il permet de différer des tâches, de définir des priorités, de réessayer les tâches échouées et de suivre leur statut via une interface web.