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

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

Redis es una de las bases de datos in-memory más populares, utilizada para almacenamiento en caché, colas, sesiones y análisis en tiempo real. En el ecosistema Go (Golang) existen varios clientes maduros para trabajar con Redis. En este artículo analizaremos en detalle las dos bibliotecas principales: go-redis (el cliente más popular) y radix (más eficiente y de bajo nivel). Aprenderá cómo instalarlos, conectarse, realizar operaciones básicas, usar pipelines, Pub/Sub y trabajar con clústeres.

1. Por qué Redis es importante para el desarrollador Go

Go se elige a menudo para crear aplicaciones de servidor de alta carga, microservicios y manejadores de eventos. Redis complementa perfectamente a Go gracias a:

• Velocidad: las operaciones se ejecutan en microsegundos.
• Simplicidad: API minimalista, estructuras de datos integradas (cadenas, listas, conjuntos, hashes).
• Soporte para Pub/Sub, transacciones y scripts Lua.

La elección correcta del cliente determina el rendimiento y la facilidad de desarrollo.

2. go-redis — el estándar de facto

go-redis (repositorio github.com/redis/go-redis/v9) es el cliente Redis más popular para Go. Proporciona una API de alto nivel, soporte para clústeres, centinelas, pipelines, Pub/Sub y bloqueos distribuidos.

2.1 Instalación

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

2.2 Conexión a 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: "", // sin contraseña        DB:       0,  // base de datos por defecto    })

    // Verificar conexión    pong, err := rdb.Ping(ctx).Result()    if err != nil {        panic(err)    }    fmt.Println(pong) // PONG}

2.3 Operaciones básicas

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

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

// Trabajar con hashesrdb.HSet(ctx, "user:1", "name", "Alice", "age", 30)name, _ := rdb.HGet(ctx, "user:1", "name").Result()fmt.Println("Nombre:", name)

// Eliminar una claverdb.Del(ctx, "key")

2.4 Pipelines

Los pipelines permiten enviar múltiples comandos en una sola llamada de red, lo que acelera significativamente las operaciones por lotes.

pipe := rdb.Pipeline()

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

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

fmt.Println("Nuevo valor de counter:", incr.Val())

2.5 Pub/Sub

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

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

// Publicador (en otra goroutine)rdb.Publish(ctx, "mychannel", "¡Hola desde Go!")

2.6 Trabajar con clúster

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

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

3. radix — ligero y rápido

radix (github.com/mediocregopher/radix/v4) es un cliente minimalista con bajo nivel de abstracción. No tiene dependencias, funciona más rápido que go-redis en operaciones simples y brinda control total sobre el nivel de red.

3.1 Instalación

go get github.com/mediocregopher/radix/v4

3