Agendador de Tarefas Go (Golang): cron, gocron, asynq |…

Agendador de Tarefas em Go (Golang): do cron ao asynq

No desenvolvimento moderno de servidores em Go (Golang), surge frequentemente a necessidade de executar código em um horário agendado ou com atraso. Limpeza de cache, envio de notificações, geração de relatórios — tudo isso requer um agendador de tarefas confiável. Neste artigo, analisaremos detalhadamente três abordagens populares: o pacote padrão cron, a biblioteca leve gocron e a fila distribuída asynq. Você descobrirá qual ferramenta escolher para o seu projeto no PythonLib.

1. Cron padrão para Go

A biblioteca github.com/robfig/cron/v3 é o padrão de facto para agendar tarefas repetitivas em Go. Ela usa a sintaxe familiar de expressões cron (5 campos) e suporta segundos, fusos horários e recuperação de panics.

Instalação e exemplo básico

go get github.com/robfig/cron/v3

Exemplo de um agendador que executa uma tarefa a cada 30 segundos:

package main

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

func main() {    c := cron.New()        // Adiciona uma tarefa com expressão cron: a cada 30 segundos    _, err := c.AddFunc("*/30 * * * * *", func() {        fmt.Println("Tarefa executada:", time.Now())    })    if err != nil {        panic(err)    }        c.Start()        // Bloqueia a goroutine main    select {}}

Características principais:

Suporte a expressões cron padrão (5 ou 6 campos com segundos)
Recuperação automática após panic na tarefa
Possibilidade de definir fuso horário via cron.WithLocation()
Registro de log via cron.WithLogger()

Uso avançado: jobs encadeados

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

// Tarefa com nome para gerenciamentoid, _ := c.AddFunc("@every 5m", func() {    fmt.Println("Executando a cada 5 minutos")})

// Remoção de tarefa por IDc.Remove(id)

// Parada do agendadorc.Stop()

A biblioteca é ideal para tarefas periódicas simples dentro de um único processo. No entanto, para sistemas distribuídos (várias réplicas do servidor Go), será necessário um bloqueio externo para evitar que a tarefa seja executada simultaneamente em todos os nós.

2. Gocron — agendador leve com encadeamento

github.com/go-co-op/gocron oferece uma API mais moderna sem expressões cron. Em vez de strings, você usa encadeamento de métodos. Isso é especialmente conveniente para iniciantes.

Exemplo com gocron

package main

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

func main() {    s := gocron.NewScheduler(time.UTC)        // Tarefa executada a cada 2 minutos    _, _ = s.Every(2).Minutes().Do(func() {        fmt.Println("2 minutos se passaram")    })        // Tarefa com atraso após a inicialização    _, _ = s.Every(1).Day().At("10:30").Do(func() {        fmt.Println("Diariamente às 10:30")    })        s.StartBlocking()}

Vantagens do gocron:

API legível: .Every(10).Seconds()
Suporte integrado para bloqueios distribuídos via Redis (opcional)
Possibilidade de definir um limite para o número de execuções
Manipuladores de erro globais e locais

Se você precisa de uma solução simples para um microsserviço sem dependências externas — o gocron será uma excelente escolha. Ele é mais leve que o cron e não requer conhecimento da sintaxe de expressões cron.

3. Asynq — fila distribuída de tarefas atrasadas

github.com/hibiken/asynq não é apenas um agendador, mas um sistema de filas completo baseado em Redis. Ele permite atrasar tarefas, definir prioridades, repetir tarefas com falha e rastrear seu status através de uma interface web.