Files d'attente de tâches pour Go : bibliothèques et…

Files d'attente de tâches pour Go (Golang) : Aperçu et comparaison des outils

Dans le développement web moderne et la création de services à forte charge en Go (Golang), il est presque toujours nécessaire d'exécuter des tâches de manière asynchrone, en dehors du flux principal de traitement des requêtes HTTP. L'envoi de notifications par email, la génération de rapports PDF, le traitement d'images, l'interaction avec des API externes — tout cela nécessite d'être déporté vers des processus en arrière-plan. C'est là que les files d'attente de tâches (task queues) entrent en jeu.

Une file d'attente de tâches est un mécanisme qui permet de différer l'exécution d'une opération, de garantir son retraitement en cas d'échec et d'équilibrer la charge entre plusieurs workers. Dans l'écosystème Go, il existe plusieurs bibliothèques matures et activement développées pour résoudre ce problème. Dans cet article, nous allons détailler trois approches les plus populaires : Asynq, Machinery et le travail direct avec Redis Streams.

1. Asynq : Simplicité et puissance basées sur Redis

Asynq du développeur hibiken est probablement la bibliothèque de files d'attente de tâches la plus populaire en Go actuellement. Elle est construite sur Redis et offre des fonctionnalités riches « prêtes à l'emploi ».

Fonctionnalités clés d'Asynq :

Monitoring : Interface web intégrée (Asynqmon) pour suivre les files d'attente, l'exécution des tâches et les erreurs.
Planification : Possibilité de différer l'exécution d'une tâche à un moment précis (syntaxe de type cron).
Priorités : Prise en charge de plusieurs files d'attente avec des priorités différentes.
Retry et Dead Letters : Tentatives de reprise automatiques et file d'attente des « lettres mortes » pour les tâches impossibles à exécuter.
Middleware : Prise en charge de middleware pour la journalisation, les métriques, etc.

Exemple d'utilisation d'Asynq :

package main

import (    "context"    "log"    "time"    "github.com/hibiken/asynq")

// Définition du type de tâcheconst TypeEmailDelivery = "email:deliver"

// Client pour envoyer des tâchesfunc main() {    client := asynq.NewClient(asynq.RedisClientOpt{Addr: "localhost:6379"})    defer client.Close()

    // Création d'une tâche    task, err := asynq.NewTask(TypeEmailDelivery, []byte(`{"user_id": 42, "template": "welcome"}`))    if err != nil {        log.Fatal(err)    }

    // Envoi de la tâche avec un délai de 5 minutes    info, err := client.Enqueue(task, asynq.ProcessIn(5*time.Minute))    if err != nil {        log.Fatal(err)    }    log.Printf("Tâche [%s] mise en file d'attente", info.ID)}

// Worker pour traiter les tâchesfunc handler(ctx context.Context, t *asynq.Task) error {    log.Printf("Traitement de la tâche : %s", t.Type())    // Logique d'envoi d'email ici    return nil}

func startWorker() {    srv := asynq.NewServer(        asynq.RedisClientOpt{Addr: "localhost:6379"},        asynq.Config{Concurrency: 10},    )

    mux := asynq.NewServeMux()    mux.HandleFunc(TypeEmailDelivery, handler)

    if err := srv.Run(mux); err != nil {        log.Fatal(err)    }}

Asynq est idéal pour la plupart des projets où Redis est déjà utilisé. Il est simple à configurer et offre une excellente expérience utilisateur pour le développeur.

2. Machinery : Tâches distribuées avec des courtiers

Machinery est une bibliothèque plus ancienne, mais très puissante, inspirée de la bibliothèque Python Celery. Contrairement à Asynq, Machinery n'est pas strictement lié à Redis et prend en charge plusieurs courtiers de messages : Redis, RabbitMQ, AWS SQS et Memory.

Fonctionnalités clés de Machinery :

Flexibilité des courtiers : Passage facile d'un courtier de messages à un autre.
Résultats des tâches : Prise en charge intégrée de la sauvegarde et de la récupération des résultats d'exécution des tâches (par exemple, dans Redis).