Como conectar Redis com Golang

Redis é um banco de dados de memória de código aberto e de código aberto usado como um corretor de cache ou mensagem. Redis é rápido e fornece confiabilidade e escalabilidade para aplicações.

Este artigo ensinará você a usar o Redis com a linguagem de programação Go. Se você é novo para ir, consulte nossa série de tutoriais para aprender a começar.

https: // linuxhint.com/categoria/Golang/

Configurando o servidor Redis

O primeiro passo é garantir que você tenha o Redis instalado em seu sistema. Para instalar o Redis em qualquer distribuição baseada no Debian, execute os comandos:

Atualização $ sudo apt-get
$ sudo apt-get install redis-server

Depois de instalado, inicie o terminal e inicie o serviço como:

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

O comando acima iniciará o servidor Redis em segundo plano em execução na porta 6379. Você pode testar que o servidor Redis está em execução executando o comando:

$ redis-cli ping.

Se o servidor estiver em execução, o comando acima deve retornar:

Pong

Opte por uma instância WSL e verifique as instruções acima para executar o Redis no Windows.

Se você estiver em um macOS, pode instalar o servidor Redis usando o homebrew. Abra o terminal e execute o comando:

$ Brew Update
$ Brew Install Redis

O comando acima deve atualizar os pacotes homebrew e instalar o servidor Redis.

Para executar o servidor em segundo plano, execute o comando:

$ Brew Services Start Redis

Instalando o compilador GO

Depois de instalar e executar o servidor Redis, abra seu navegador e navegue até o link abaixo:

https: // vá.dev/dl/

Selecione o pacote do instalador para o seu sistema operacional e siga as instruções de instalação.

Você pode verificar se o compilador de Golang está instalado executando o comando:

Versão $ go

O comando acima deve retornar a versão Go Go. Um exemplo de saída é como mostrado abaixo:

versão go1.17.8 Darwin/amd64

Conectando a redis

Depois de instalarmos o servidor Redis e o compilador Go, podemos criar nosso aplicativo. Comece executando o comando:

$ MKDIR GOLANG_RUST
$ CD GOLANG_RUST

Em seguida, crie um novo arquivo go e chame -o principal.ir

$ Touch Main.ir

Abra o arquivo com seu editor de texto favorito.

$ vim main.ir

Agora, vamos adicionar algum código de caldeira para começar.

Pacote principal
importar "fmt"
func main ()
fmt.Println ("Bem -vindo ao Redis!!!")

O próximo passo é importar o pacote necessário. Para este tutorial, usaremos o github.pacote com/go-redis/redis.

Adicione o pacote de importação como:

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

O próximo passo é definir um cliente que se conecta à instância do Redis. Podemos usar o método NewClient do pacote Go-Redis.

O código -fonte é como mostrado abaixo:

Pacote principal
importação (
"FMT"
"registro"
"Github.com/go-redis/redis "
)
func main ()
// novo cliente Redis
Cliente: = Redis.NewClient (& Redis.Opções
Addr: "127.0.0.1: 6379 ",
Senha: "",
DB: 10,
)
// conexão de teste
pong, err: = cliente.Ping ().Resultado()
se err != nil
registro.Fatal (ERR)

// retorna pong se o servidor estiver online
fmt.Println (pong)

Definimos um novo cliente usando o método NewClient no programa acima. O método leva uma estrutura com as propriedades para se conectar ao servidor Redis.

1. Addr - isso descreve o endereço e a porta na instância do servidor Redis.
2. Senha - senha para a instância Redis. No nosso caso, não definimos uma senha.
3. DB - o índice de banco de dados a ser usado para o aplicativo.

Em seguida, teste se o servidor está em execução executando um ping. Fazemos isso usando o método ping (), que retorna pong e um err.

Se o erro não for nulo, registramos o erro e depois imprimimos o pong como resultado.

Para testar o aplicativo, execute o programa

$ go run main.ir
Pong

Depois de conseguir pong, podemos prosseguir.

Adicionando pares de valor-chave ao redis

Depois de conectarmos ao servidor, podemos adicionar pares de valor-chave ao banco de dados no índice 0.

O pacote Redis fornece o método de conjunto, que leva uma duração de chave, valor e validade.

A expiração é definida como 0, o que significa que a chave não expira.

Para adicionar pares de valor-chave, podemos fazer.

err = cliente.Set ("nome de usuário", "user100", 0).Errar()
se err != nil
registro.Fatal (ERR)

O código acima adiciona o nome de usuário e o valor especificados ao banco de dados. Observe que o valor de expiração é definido como 0, o que significa que não há expiração.

Obtendo valores de Redis

Também podemos usar o método get para recuperar o valor armazenado em uma chave especificada. O código de exemplo é como mostrado abaixo:

// Obter valor
nome de usuário, err: = cliente.Get ("Nome de usuário").Resultado()
se err != nil
registro.Fatal (ERR)

fmt.Println ("Nome de usuário:", nome de usuário)

O método get buscará o valor associado à chave "nome de usuário" e imprimirá aqui.

Conclusão

Este tutorial abrange o trabalho com o banco de dados Redis usando a linguagem de programação Go. Você pode verificar a documentação do cliente Go-Redis para saber mais.

https: // redis.UPTRACE.dev/