Cómo conectar Redis con Golang

Redis es una base de datos en memoria gratuita y de código abierto utilizada como corredor de caché o mensajes. Redis es rápido y proporciona confiabilidad y escalabilidad para aplicaciones.

Este artículo le enseñará a usar Redis con el lenguaje de programación GO. Si es nuevo para ir, consulte nuestra serie de tutoriales para aprender a comenzar.

https: // linuxhint.com/categoría/golang/

Configuración del servidor Redis

El primer paso es asegurarse de que Redis haya instalado en su sistema. Para instalar Redis en cualquier distribución basada en Debian, ejecute los comandos:

$ sudo apt-get actualización
$ sudo apt-get install redis-server

Una vez instalado, inicie el terminal e inicie el servicio como:

$ sudo /etc /init.D/REDIS/REDIS-Server Start

El comando anterior iniciará el servidor Redis en segundo plano que se ejecuta en el puerto 6379. Puede probar que el servidor Redis se está ejecutando ejecutando el comando:

$ Redis-cli ping.

Si el servidor se está ejecutando, el comando anterior debería devolver:

APESTAR

Opta por una instancia de WSL y verifique las instrucciones anteriores para ejecutar Redis en Windows.

Si está en un macOS, puede instalar el servidor Redis usando HomeBrew. Abra el terminal y ejecute el comando:

$ Brew Actualy
$ brew instalación redis

El comando anterior debe actualizar los paquetes de cerveza casera e instalar el servidor Redis.

Para ejecutar el servidor en segundo plano, ejecute el comando:

$ Brew Services Inicio Redis

Instalación del compilador GO

Una vez que tenga el servidor Redis instalado y en ejecución, abra su navegador y navegue al siguiente enlace:

https: // go.dev/dl/

Seleccione el paquete de instalador para su sistema operativo y siga las instrucciones de instalación.

Puede verificar que el compilador de Golang esté instalado ejecutando el comando:

Versión de $ Go

El comando anterior debe devolver la versión GO instalada. Una salida de ejemplo es como se muestra a continuación:

Versión GO GO1.17.8 Darwin/AMD64

Conectando a Redis

Una vez que tenemos el servidor redis y el compilador GO instalado, podemos construir nuestra aplicación. Comience ejecutando el comando:

$ mkdir golang_rust
$ CD Golang_rust

A continuación, cree un nuevo archivo GO y llámelo principal.ir

$ touch main.ir

Abra el archivo con su editor de texto favorito.

$ vim principal.ir

Ahora, agregamos un código de horario para comenzar.

paquete principal
importar "fmt"
func Main ()
fmt.Println ("Bienvenido a Redis!!!")

El siguiente paso es importar el paquete requerido. Para este tutorial, usaremos el GitHub.paquete com/go-redis/redis.

Agregue el paquete de importación como:

importar "github.com/go-redis/redis "

El siguiente paso es definir un cliente que se conecta a la instancia de Redis. Podemos usar el método de NewClient desde el paquete Go-Redis.

El código fuente es el que se muestra a continuación:

paquete principal
importar (
"FMT"
"registro"
"Github.com/go-redis/redis "
)
func Main ()
// nuevo cliente de Redis
Cliente: = Redis.Newclient (y Redis.Opciones
Addr: "127.0.0.1: 6379 ",
Contraseña: "",
DB: 10,
)
// conexión de prueba
pong, err: = cliente.Silbido().Resultado()
Si err != nulo
registro.Fatal (err)

// devuelve pong si el servidor está en línea
fmt.Println (pong)

Definimos un nuevo cliente utilizando el método NewClient en el programa anterior. El método toma una estructura con las propiedades para conectarse al servidor Redis.

1. ADDR: esto describe la dirección y el puerto a la instancia del servidor Redis.
2. Contraseña - Contraseña para la instancia de Redis. En nuestro caso, no hemos establecido una contraseña.
3. DB: el índice de base de datos a usar para la aplicación.

A continuación, pruebe si el servidor se está ejecutando ejecutando un ping. Hacemos esto utilizando el método ping (), que devuelve pong y un error.

Si el error no es nulo, registramos el error y luego imprimimos el pong como resultado.

Para probar la aplicación, ejecute el programa

$ Go Run Main.ir
APESTAR

Una vez que consigas pong, podemos continuar.

Agregar pares de valor clave a Redis

Una vez que hemos conectado al servidor, podemos agregar pares de valor clave a la base de datos en el índice 0.

El paquete Redis proporciona el método establecido, que toma una clave, valor y duración de vencimiento.

El vencimiento se establece en 0, lo que significa que la clave no expira.

Para agregar pares de valor clave, podemos hacer.

err = cliente.Set ("Nombre de usuario", "User100", 0).Errar()
Si err != nulo
registro.Fatal (err)

El código anterior agrega el nombre de usuario y el valor especificados a la base de datos. Tenga en cuenta que el valor de vencimiento se establece en 0, lo que significa que no hay vencimiento.

Obtener valores de Redis

También podemos usar el método get para recuperar el valor almacenado en una clave especificada. El código de ejemplo es como se muestra a continuación:

// Obtener valor
nombre de usuario, err: = cliente.Get ("Nombre de usuario").Resultado()
Si err != nulo
registro.Fatal (err)

fmt.Println ("Nombre de usuario:", nombre de usuario)

El método GET obtendrá el valor asociado con la clave "Nombre de usuario" e imprimirá aquí.

Conclusión

Este tutorial cubre el trabajo con la base de datos Redis utilizando el lenguaje de programación GO. Puede consultar la documentación del cliente Go-Redis para obtener más información.

https: // redis.treinta.dev/