Planificateur de tâches Go (Golang)

Planificateur de tâches en Go (Golang) : du simple ticker au cron industriel

Un planificateur de tâches (task scheduler) est un composant qui permet d'exécuter certaines fonctions à un moment donné ou à une périodicité définie. Dans l'écosystème Go (Golang), il existe plusieurs approches pour implémenter un planificateur : des primitives intégrées du langage aux puissantes bibliothèques tierces. Dans cet article, nous allons voir comment créer un planificateur de tâches en Go, en commençant par des exemples simples et en terminant par l'utilisation de la bibliothèque populaire robfig/cron.

Pourquoi un planificateur de tâches en Go ?

Go est idéal pour créer des applications serveur hautes performances, des microservices et des utilitaires en ligne de commande. Un planificateur de tâches permet d'automatiser les opérations courantes :

Nettoyage du cache ou des fichiers temporaires
Envoi de notifications périodiques (email, SMS)
Collecte de métriques et surveillance
Synchronisation des données avec des API externes
Génération de rapports planifiés

Planificateur de base avec time.Ticker

La façon la plus simple d'exécuter une tâche toutes les N secondes est d'utiliser time.Ticker. Cet outil intégré de Go envoie une valeur dans un canal à intervalles réguliers.

package main

import (    "fmt"    "time")

func main() {    ticker := time.NewTicker(2 * time.Second)    done := make(chan bool)

    go func() {        for {            select {            case <-ticker.C:                fmt.Println("Tâche exécutée :", time.Now().Format(time.RFC3339))            case <-done:                ticker.Stop()                return            }        }    }()

    // Arrêtons le planificateur après 10 secondes    time.Sleep(10 * time.Second)    done <- true    fmt.Println("Planificateur arrêté")}

Ce code crée une goroutine qui affiche l'heure actuelle toutes les 2 secondes. Notez l'utilisation de select — c'est un modèle clé de Go pour le traitement non bloquant de plusieurs canaux.

Planificateur avec planning flexible : la bibliothèque robfig/cron

Pour les projets réels nécessitant un planning de type cron (par exemple, « tous les lundis à 9h00 » ou « toutes les 5 minutes de 9h à 18h »), la bibliothèque github.com/robfig/cron/v3 est la mieux adaptée. Elle prend entièrement en charge la syntaxe cron standard et ajoute des fonctionnalités pratiques comme la gestion des fuseaux horaires et la gestion des paniques.

Installation

go get github.com/robfig/cron/v3

Exemple d'utilisation

package main

import (    "fmt"    "log"    "time"

    "github.com/robfig/cron/v3")

func main() {    c := cron.New(cron.WithSeconds()) // Activation du support des secondes

    // Ajout d'une tâche : toutes les 10 secondes    _, err := c.AddFunc("*/10 * * * * *", func() {        fmt.Println("Tâche 1 : toutes les 10 secondes", time.Now().Format(time.RFC3339))    })    if err != nil {        log.Fatal(err)    }

    // Tâche : tous les jours à 14h30 UTC    _, err = c.AddFunc("0 30 14 * * *", func() {        fmt.Println("Tâche 2 : quotidiennement à 14h30 UTC")    })    if err != nil {        log.Fatal(err)    }

    // Tâche nommée pour gestion ultérieure    entryID, _ := c.AddFunc("@every 1m", func() {        fmt.Println("Tâche 3 : toutes les minutes")    })

    c.Start()

    // Suppression de la tâche après 5 minutes    time.Sleep(5 * time.Minute)    c.Remove(entryID)    fmt.Println("Tâche 3 supprimée")

    // Blocage du main    select {}}

La bibliothèque prend en charge plusieurs formats de planning :