Cómo utilizar Redis como base de datos
Redis significa “remote dictionary server” (servidor de diccionario remoto). Es un almacenamiento de estructuras de datos en memoria que admite listas, cadenas, mapas, flujos, conjuntos y otras estructuras para almacenar datos abstractos.
Aunque Redis es una base de datos primaria completa, es una base de datos NoSQL. Es una de las soluciones NoSQL más valoradas y una de las bases de datos clave-valor más populares. Con mayor frecuencia, Redis se usa para almacenamiento en caché de sesiones, almacenamiento en caché de páginas y colas de mensajes.
En esencia, esta base de datos es ideal para caché, ya que te permite configurar cuánto tiempo debe almacenar los datos y qué datos eliminar primero. Redis también es conocido por ser rápido y de alto rendimiento, lo que lo hace perfecto para tareas de caché.
Antes de conectarte a una base de datos Redis, asegúrate de tener Redis y Go instalados en tu Mac. Si lo prefieres, puedes usar una imagen de Docker de Redis en lugar de instalar Redis directamente en tu máquina.
También necesitarás instalar go-redis, un cliente Redis para Go.
Comienza inicializando un módulo de Go con este comando:
go mod init github.com/my/repo
A continuación, instala go-redis, uno de los dos paquetes más populares para interactuar con Redis en Golang:
go get github.com/go-redis/redis/v8
Conectarse a una base de datos Redis
Primero, asegúrate de que tu contenedor de Docker Redis esté ejecutándose:
Si no lo está, inicia el contenedor de Docker Redis:
docker run -d -p 6379:6379 redislabs/redismod
Ahora, podemos incorporar nuestro código para instalar go-redis del paso anterior en nuestro proceso:
go get github.com/go-redis/redis/v8
Antes de nuestro paso final, necesitamos crear el archivo main.go con nuestro programa actual. Usamos el siguiente código:
package main
import (
"fmt"
"github.com/go-redis/redis"
)
func main() {
fmt.Println("We are testing Go-Redis")
client := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "",
DB: 0,
})
pong, err := client.Ping().Result()
fmt.Println(pong, err)
}
Para escribir nuestro programa en Go, utilizamos CodeRunner, una aplicación para programar a gran velocidad en más de 25 lenguajes, incluido Go.
Puedes usar CodeRunner u otra aplicación de editor.
Cambia tu directorio en la Terminal con el comando cd para estar en la misma carpeta que tu archivo main.go del paso anterior, y luego ejecuta el archivo en Go con el comando go run main.go para establecer la conexión.
Deberías recibir una respuesta PONG si la conexión es exitosa:
Interactuando con bases de datos Redis
La base de interactuar con una base de datos Redis gira en torno a los comandos set y get.
Aquí está el código para establecer un valor en una base de datos Redis:
err = client.Set("name", "Billie", 0).Err()
if err != nil {
fmt.Println(err)
}
Para asegurarte de que estás haciendo todo correctamente, también puedes incorporar el código get en tu programa y obtener el valor que acabas de agregar devuelto en pantalla.
Aquí está el código completo que usamos para esa acción en nuestro programa Go:
package main
import (
"fmt"
"github.com/go-redis/redis"
)
func main() {
fmt.Println("We are testing Go-Redis")
client := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "",
DB: 0,
})
pong, err := client.Ping().Result()
fmt.Println(pong, err)
if err != nil {return}
err = client.Set("name", "Billie", 0).Err()
if err != nil {
fmt.Println(err)
return
}
val, err := client.Get("name").Result()
if err != nil {
fmt.Println(err)
}
fmt.Println(val)
}
Para guardar tus fragmentos de código para más tarde, puedes usar SnippetsLab, una aplicación diseñada específicamente para esta tarea. Puedes guardar tus fragmentos allí para acceder fácilmente a ellos cuando los necesites.
También puedes guardarlos como archivos de texto plano, pero preferimos SnippetsLab para estructurar mejor nuestros fragmentos.
Asegúrate también de almacenar ejemplos de código, ya que a veces, al modificarlos, es posible incorporar un error sin querer. Tener una referencia original que funcionaba antes de modificarla siempre es útil.
Configurar el tiempo de expiración para valores en Redis DB
Una de las características más valiosas de Redis, la base de datos en memoria, es que te permite almacenar tus valores con una fecha de expiración. En los ejemplos anteriores, usamos 0 para evitar establecer la duración de almacenamiento de nuestro valor configurado, pero ¿qué pasa cuando lo hacemos?
Aquí está la línea de código correspondiente para eso:
err = client.Set("name", "Tom", time.Second*5).Err()
¿Cómo podemos verificar que el valor realmente expire en el tiempo establecido? Hay varias maneras de hacerlo, pero en nuestro ejemplo, la forma más sencilla de comprobarlo es con esta línea de código:
time.Sleep(time.Second*6)
Nos permite pedirle a nuestro programa que espere una cierta cantidad de tiempo antes de obtener nuestro valor establecido. Si configuramos el tiempo en menos de 5 segundos, obtenemos Tom. Pero cuando el tiempo es mayor, no obtenemos nada:
package main
import (
"fmt"
"github.com/go-redis/redis"
"time"
)
func main() {
fmt.Println("We are testing Go-Redis")
client := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "",
DB: 0,
})
pong, err := client.Ping().Result()
fmt.Println(pong, err)
if err != nil {return}
err = client.Set("name", "Tom", time.Second*5).Err()
if err != nil {
fmt.Println(err)
return
}
time.Sleep(time.Second*4)
val, err := client.Get("name").Result()
if err != nil {
fmt.Println(err)
}
fmt.Println(val)
}
Aquí ejecutamos nuestro archivo main.go con el tiempo de expiración configurado primero en 4 segundos y luego lo cambiamos a 6. Entonces, en respuesta a nuestra primera ejecución de main.go, obtuvimos el nombre que configuramos — Tom — de vuelta, pero la segunda vez que lo ejecutamos, obtuvimos solo el nil.
Usando JSON con Redis
Para almacenar valores compuestos, podemos usar JSON en nuestro código:
package main
import (
"fmt"
"encoding/json"
"github.com/go-redis/redis"
)
type Author struct {
Name string `json:"name"`
Age int `json:"age"`
}
func main() {
client := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "",
DB: 0,
})
json, err := json.Marshal(Author{Name: "Ben", Age: 85})
if err != nil {
fmt.Println(err)
}
err = client.Set("id4", json, 0).Err()
if err != nil {
fmt.Println(err)
}
val, err := client.Get("id4").Result()
if err != nil {
fmt.Println(err)
}
fmt.Println(val)
}
Con este código, pudimos almacenar un valor compuesto de un nombre y una edad en nuestra base de datos Redis:
Leer también:
- Usar Go con Mongodb
- Usar Go con Mysql
- Qué es el marketing de producto
- Las mejores herramientas para desarrolladores en Mac
Reflexiones finales
Como puedes ver, trabajar con Redis en Go es muy sencillo: solo necesitas establecer la conexión y comenzar a configurar tus valores.
Las bases de datos Redis son ideales para almacenar información con una fecha de expiración, una de las principales razones por las que se utilizan principalmente para caché y almacenamiento de mensajes. Puedes incorporar múltiples bases de datos Redis en tus proyectos, según lo necesites.
En la guía anterior, aprendiste cómo configurar el tiempo de expiración para tus valores y verificar que estén funcionando, así como también a usar JSON con tus bases de datos Redis.
