Cliente Redis para Go (Golang) — go-redis e radix

Cliente Redis para Go (Golang): go-redis e radix

Redis é um dos bancos de dados in-memory mais populares, usado para cache, filas, sessões e análises em tempo real. No ecossistema Go (Golang), existem vários clientes maduros para trabalhar com Redis. Neste artigo, analisaremos detalhadamente duas bibliotecas principais: go-redis (o cliente mais popular) e radix (mais performático e de baixo nível). Você aprenderá como instalá-los, conectar-se, executar operações básicas, usar pipelines, Pub/Sub e trabalhar com cluster.

1. Por que o Redis é importante para o desenvolvedor Go

Go é frequentemente escolhido para criar aplicações server-side de alta carga, microsserviços e manipuladores de eventos. O Redis complementa perfeitamente o Go devido a:

• Velocidade — as operações são executadas em microssegundos.
• Simplicidade — API minimalista, estruturas de dados embutidas (strings, listas, conjuntos, hashes).
• Suporte a Pub/Sub, transações e scripts Lua.

A escolha correta do cliente determina a performance e a facilidade de desenvolvimento.

2. go-redis — o padrão de facto

go-redis (repositório github.com/redis/go-redis/v9) é o cliente Redis mais popular para Go. Ele fornece uma API de alto nível, suporte a clusters, sentinelas, pipelines, Pub/Sub e bloqueios distribuídos.

2.1 Instalação

go get github.com/redis/go-redis/v9

2.2 Conexão ao Redis

package main

import (    "context"    "fmt"    "github.com/redis/go-redis/v9")

func main() {    ctx := context.Background()

    rdb := redis.NewClient(&redis.Options{        Addr:     "localhost:6379",        Password: "", // sem senha        DB:       0,  // banco padrão    })

    // Verificação da conexão    pong, err := rdb.Ping(ctx).Result()    if err != nil {        panic(err)    }    fmt.Println(pong) // PONG}

2.3 Operações básicas

// Definir stringerr := rdb.Set(ctx, "key", "value", 0).Err()if err != nil {    panic(err)}

// Obter stringval, err := rdb.Get(ctx, "key").Result()if err != nil {    panic(err)}fmt.Println("key:", val)

// Trabalhando com hashesrdb.HSet(ctx, "user:1", "name", "Alice", "age", 30)name, _ := rdb.HGet(ctx, "user:1", "name").Result()fmt.Println("Nome:", name)

// Remover chaverdb.Del(ctx, "key")

2.4 Pipelines

Pipelines permitem enviar vários comandos em uma única chamada de rede, acelerando significativamente operações em lote.

pipe := rdb.Pipeline()

incr := pipe.Incr(ctx, "counter")pipe.Expire(ctx, "counter", time.Hour)

// Executa todos os comandos_, err := pipe.Exec(ctx)if err != nil {    panic(err)}

fmt.Println("Novo valor do contador:", incr.Val())

2.5 Pub/Sub

// Assinantesub := rdb.Subscribe(ctx, "mychannel")ch := sub.Channel()

for msg := range ch {    fmt.Printf("Recebido: %s", msg.Payload)}

// Publicador (em outra goroutine)rdb.Publish(ctx, "mychannel", "Hello from Go!")

2.6 Trabalhando com cluster

clusterClient := redis.NewClusterClient(&redis.ClusterOptions{    Addrs: []string{        "localhost:7000",        "localhost:7001",        "localhost:7002",    },})

// Usado como um cliente normalerr := clusterClient.Set(ctx, "cluster_key", "value", 0).Err()if err != nil {    panic(err)}

3. radix — leve e rápido

radix (github.com/mediocregopher/radix/v4) é um cliente minimalista com baixo nível de abstração. Ele não possui dependências, é mais rápido que o go-redis em operações simples e oferece controle total sobre o nível de rede.

3.1 Instalação

go get github.com/mediocregopher/radix/v4

3