Aufgabenwarteschlangen in Go: Überblick über die Bibliotheken async, gocelery und machinery

Aufgabenwarteschlangen für Go (Golang): Überblick und Praxis

In modernen Webanwendungen und Microservices besteht häufig die Notwendigkeit, ressourcenintensive oder langwierige Operationen asynchron auszuführen: E-Mail-Versand, Berichtserstellung, Bildverarbeitung, Interaktion mit externen APIs. Zu diesem Zweck werden Aufgabenwarteschlangen (task queues) verwendet. Im Go-Ökosystem (Golang) gibt es mehrere ausgereifte Bibliotheken, die eine solche Architektur ermöglichen. In diesem Artikel betrachten wir drei der beliebtesten Tools: machinery, gocelery und asynq, analysieren ihre Besonderheiten und geben Codebeispiele.

Warum braucht man eine Aufgabenwarteschlange in Go?

Eine Aufgabenwarteschlange löst mehrere zentrale Probleme:

• Aufgabentrennung: Der HTTP-Handler wartet nicht auf den Abschluss einer Hintergrundaufgabe.
• Skalierbarkeit: Sie können mehrere Worker auf verschiedenen Servern ausführen.
• Zuverlässigkeit: Bei einem Worker-Ausfall geht die Aufgabe nicht verloren und kann erneut verarbeitet werden.
• Planung: Möglichkeit, die Ausführung einer Aufgabe auf einen bestimmten Zeitpunkt zu verschieben.

1. Machinery — eine leistungsstarke und flexible Bibliothek

Machinery ist eine asynchrone Aufgabenwarteschlange für Go, die von Grund auf neu geschrieben wurde. Sie unterstützt mehrere Broker (Redis, RabbitMQ, AWS SQS) und Ergebnis-Backends (Redis, MongoDB, Memcache). Machinery bietet eine umfangreiche API zum Erstellen von Aufgaben, Ketten (chains), Gruppen (groups) und wiederkehrenden Aufgaben.

Installation und Beispiel

go get github.com/RichardKnox/machinery/v2

Beispiel für einen einfachen Worker und Client:

package main

import (    "github.com/RichardKnox/machinery/v2"    "github.com/RichardKnox/machinery/v2/config"    "github.com/RichardKnox/machinery/v2/tasks")

func main() {    // Konfiguration mit Redis-Broker    cnf := &config.Config{        Broker:        "redis://localhost:6379",        DefaultQueue:  "machinery_tasks",        ResultBackend: "redis://localhost:6379",    }

    server, err := machinery.NewServer(cnf)    if err != nil {        panic(err)    }

    // Aufgabenregistrierung    err = server.RegisterTasks(map[string]interface{}{        "add": func(a, b int) (int, error) {            return a + b, nil        },    })    if err != nil {        panic(err)    }

    // Worker starten    worker := server.NewWorker("worker1", 2) // 2 gleichzeitige Aufgaben    go worker.Launch()

    // Aufgabe senden    task := tasks.Signature{        Name: "add",        Args: []tasks.Arg{            {Type: "int", Value: 5},            {Type: "int", Value: 7},        },    }    result, _ := server.SendTask(&task)    // Auf Ergebnis warten    if res, err := result.Get(10); err == nil {        println("Ergebnis:", res.(int)) // Ausgabe: 12    }}

Vorteile: Unterstützung komplexer Aufgabengraphen, Wiederholungsmöglichkeit, Überwachung über Weboberfläche.

Nachteile: Relativ komplexe Einrichtung, Dokumentation hinkt manchmal dem Code hinterher.

2. Asynq — moderne Warteschlange mit reichhaltiger Benutzeroberfläche

Asynq ist eine Bibliothek von Google-Entwicklern, die auf Redis basiert. Sie bietet eine benutzerfreundliche API, integrierte Planung, Aufgabenprioritäten und eine integrierte Weboberfläche zur Überwachung. Asynq wird aktiv weiterentwickelt und verfügt über eine hervorragende Dokumentation.

Installation und Beispiel

go get github.com/hibiken/asynq

Beispiel für einen einfachen Client und Worker:

package main

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

// Typisierte Aufgabeconst TypeEmailDelivery = "email:deliver"

func main() {    // Client zum Senden von Aufgaben    client := asynq.NewClient(asynq.RedisClientOpt{Addr: "localhost:6379"})    defer client.Clos