Filas de Tarefas em Go (Golang): Melhores Bibliotecas e Ferramentas

Filas de Tarefas para Go (Golang): Guia Completo de Bibliotecas e Ferramentas

No mundo do desenvolvimento moderno em Go (Golang), o processamento de tarefas em segundo plano e operações assíncronas é uma tarefa criticamente importante. Seja para envio de e-mails, geração de relatórios, processamento de imagens ou interação com APIs externas, as filas de tarefas (task queues) permitem desafogar o fluxo principal da aplicação e aumentar sua tolerância a falhas. Neste artigo, veremos as melhores bibliotecas para trabalhar com filas em Go, suas características e exemplos de uso.

O que é uma fila de tarefas e para que serve?

Uma fila de tarefas é um mecanismo que permite adiar a execução de operações que consomem muitos recursos ou são demoradas para segundo plano. Principais vantagens:

• Assincronicidade: o usuário não espera a conclusão de uma operação pesada.
• Escalabilidade: você pode executar vários workers para processamento paralelo.
• Tolerância a falhas: se um worker falhar, a tarefa permanece na fila e será executada por outro.
• Agendamento: execução adiada de tarefas (por exemplo, após 1 hora).

Top 3 Bibliotecas para Filas de Tarefas em Go

1. Asynq

Asynq é uma biblioteca moderna, de alto desempenho e fácil de usar para filas de tarefas distribuídas, construída sobre Redis. Desenvolvida pela equipe do Google e ativamente mantida pela comunidade.

Principais características:

• Funciona sobre Redis (recomendada versão 6.0+).
• Suporte a tarefas agendadas (scheduled tasks).
• Interface web integrada para monitoramento (Asynqmon).
• Fila de mensagens mortas (dead-letter) para tarefas com falha.
• Grupos de tarefas (task groups) para agrupamento lógico.
• Retry com política de repetição configurável.

Exemplo de uso:

package main

import (    "context"    "fmt"    "log"    "time"

    "github.com/hibiken/asynq")

// Define o tipo de tarefaconst TypeEmailDelivery = "email:deliver"

// Estrutura de dados para a tarefatype EmailTaskPayload struct {    UserID     int    TemplateID string}

// Manipulador da tarefafunc HandleEmailTask(ctx context.Context, t *asynq.Task) error {    var payload EmailTaskPayload    if err := json.Unmarshal(t.Payload(), &payload); err != nil {        return fmt.Errorf("json.Unmarshal failed: %v: %w", err, asynq.SkipRetry)    }    log.Printf("Enviando e-mail para o usuário %d com o template %s", payload.UserID, payload.TemplateID)    // Lógica de envio de e-mail aqui    return nil}

func main() {    // Cliente para enfileirar tarefas    client := asynq.NewClient(asynq.RedisClientOpt{Addr: "localhost:6379"})    defer client.Close()

    // Cria uma tarefa    payload, _ := json.Marshal(EmailTaskPayload{UserID: 42, TemplateID: "welcome"})    task := asynq.NewTask(TypeEmailDelivery, payload, asynq.MaxRetry(5))

    // Coloca a tarefa na fila    info, err := client.Enqueue(task, asynq.ProcessIn(10*time.Second)) // adiar por 10 seg    if err != nil {        log.Fatal(err)    }    log.Printf("Tarefa enfileirada: ID=%s, Queue=%s", info.ID, info.Queue)

    // Servidor worker    srv := asynq.NewServer(        asynq.RedisClientOpt{Addr: "localhost:6379"},        asynq.Config{Concurrency: 10},    )

    // Registra o manipulador    mux := asynq.NewServeMux()    mux.HandleFunc(TypeEmailDelivery, HandleEmailTask)

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

2. Machinery

Machinery é uma das bibliotecas mais populares e maduras para Go. Suporta vários brokers: Redis, AMQP (RabbitMQ), AWS SQS, MongoDB e outros. Destaca-se pela rica funcionalidade e flexibilidade.

Principais características:

• Suporte