Operações Redis: Aprenda SET, GET e Gerenciamento de Chaves

Introdução

Neste laboratório, você aprenderá as operações fundamentais de chave-valor no Redis. Usaremos a interface de linha de comando redis-cli para interagir com o servidor Redis e realizar operações básicas como definir, obter, verificar a existência, deletar e definir tempos de expiração para chaves. Ao final deste laboratório, você terá uma sólida compreensão de como usar o Redis como um armazenamento de dados simples.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 89%. Recebeu uma taxa de avaliações positivas de 99% dos estudantes.

Definindo e Recuperando Pares Chave-Valor

Nesta etapa, focaremos nas operações principais de definição e recuperação de pares chave-valor no Redis. Esta é a base para usar o Redis como um armazenamento de dados.

O Redis armazena dados como pares chave-valor, semelhante a um dicionário. A chave é um identificador único, e o valor é o dado associado a essa chave.

Conectar ao Redis:

Abra um terminal na VM do LabEx. Você já deve estar no diretório ~/project. Conecte-se ao servidor Redis usando o comando redis-cli:
```
redis-cli
```
Você deve ver o prompt do Redis: 127.0.0.1:6379>. Isso indica uma conexão bem-sucedida ao servidor Redis.
Definir um Par Chave-Valor:

Vamos definir um par chave-valor usando o comando SET. Definiremos a chave mykey para o valor myvalue.
```
SET mykey myvalue
```
O Redis responderá com:
```
OK
```
Isso confirma que o par chave-valor foi armazenado com sucesso.
Obter o Valor de uma Chave:

Para recuperar o valor associado a uma chave, use o comando GET. Vamos recuperar o valor de mykey:
```
GET mykey
```
O Redis responderá com:
```
"myvalue"
```
Isso mostra que recuperamos com sucesso o valor associado à chave mykey.
Definir Outro Par Chave-Valor:

Vamos definir outro par chave-valor com uma chave e um valor diferentes. Desta vez, usaremos user:1001 como a chave e John como o valor.
```
SET user:1001 John
```
O Redis responderá com:
```
OK
```
Obter o Valor da Nova Chave:

Agora, vamos recuperar o valor da chave user:1001:
```
GET user:1001
```
O Redis responderá com:
```
"John"
```
Você agora definiu e recuperou com sucesso pares chave-valor no Redis.
Sair do Redis CLI:

É importante sair do Redis CLI após cada etapa para que os comandos sejam registrados corretamente. Digite:
```
exit
```

Verificando a Existência de Chaves

Nesta etapa, aprenderemos como verificar se uma chave existe no Redis usando o comando EXISTS. Isso é útil para determinar se uma chave foi definida antes de tentar recuperar seu valor ou realizar outras operações.

Conectar ao Redis:

Conecte-se ao servidor Redis usando o comando redis-cli:
```
redis-cli
```
Você deve ver o prompt do Redis: 127.0.0.1:6379>.
Verificar a Existência de uma Chave Existente:

Na etapa anterior, definimos a chave mykey. Vamos verificar se ela existe usando o comando EXISTS:
```
EXISTS mykey
```
O Redis responderá com:
```
(integer) 1
```
Uma resposta de 1 indica que a chave mykey existe no Redis.
Verificar a Existência de uma Chave Não Existente:

Agora, vamos verificar se uma chave que não definimos existe. Por exemplo, vamos verificar uma chave chamada nonexistentkey:
```
EXISTS nonexistentkey
```
O Redis responderá com:
```
(integer) 0
```
Uma resposta de 0 indica que a chave nonexistentkey não existe no Redis.
Sair do Redis CLI:

Saia do Redis CLI para garantir que os comandos sejam registrados:
```
exit
```

Excluindo Chaves

Nesta etapa, aprenderemos como excluir chaves do Redis usando o comando DEL. Isso é essencial para gerenciar dados e remover entradas obsoletas ou indesejadas.

Conectar ao Redis:

Conecte-se ao servidor Redis usando o comando redis-cli:
```
redis-cli
```
Você deve ver o prompt do Redis: 127.0.0.1:6379>.
Excluir uma Chave Existente:

Nas etapas anteriores, definimos a chave mykey. Vamos excluí-la usando o comando DEL:
```
DEL mykey
```
O Redis responderá com:
```
(integer) 1
```
Uma resposta de (integer) 1 indica que uma chave foi excluída com sucesso.
Excluir uma Chave Não Existente:

Vamos tentar excluir uma chave que não existe, como nonexistentkey:
```
DEL nonexistentkey
```
O Redis responderá com:
```
(integer) 0
```
Uma resposta de (integer) 0 indica que nenhuma chave foi excluída (porque a chave não existia).
Excluir Múltiplas Chaves:

O comando DEL também pode ser usado para excluir várias chaves de uma vez. Vamos excluir a chave user:1001 que criamos anteriormente e também tentar excluir nonexistentkey novamente no mesmo comando:
```
DEL user:1001 nonexistentkey
```
O Redis responderá com:
```
(integer) 1
```
Uma resposta de (integer) 1 indica que uma chave foi excluída com sucesso (user:1001), e a tentativa de excluir nonexistentkey foi ignorada, pois ela não existia.
Sair do Redis CLI:

Saia do Redis CLI:
```
exit
```

Definindo a Expiração da Chave

Neste passo, aprenderemos como definir um tempo de expiração para uma chave no Redis, utilizando os comandos EXPIRE e SET com o parâmetro EX. Isto é útil para remover automaticamente dados após um determinado período, como dados de sessão ou caches temporários.

Conectando-se ao Redis:

Conecte-se ao servidor Redis usando o comando redis-cli:
```
redis-cli
```
Você deverá ver o prompt do Redis: 127.0.0.1:6379>.
Definindo um Par Chave-Valor com Expiração (Método 1: SET com parâmetro EX):

O Redis permite definir um par chave-valor com um tempo de expiração em um único comando usando o parâmetro EX. Vamos definir a chave sessionkey para o valor sessionvalue com um tempo de expiração de 15 segundos:
```
SET sessionkey sessionvalue EX 15
```
O Redis responderá com:
```
OK
```
Este comando define o par chave-valor e o tempo de expiração em uma única operação, o que é mais eficiente do que usar comandos separados.
Verificando o TTL da Chave Definida com EX:

Vamos verificar o tempo restante de vida (TTL) para a chave sessionkey:
```
TTL sessionkey
```
O Redis responderá com o número de segundos restantes até a expiração da chave (por exemplo, (integer) 14). O valor será ligeiramente menor que 15 devido ao tempo decorrido desde a definição da chave.
Definindo um Par Chave-Valor (Método 2: Usando o comando EXPIRE separadamente):

Alternativamente, você pode definir primeiro um par chave-valor e, em seguida, definir seu tempo de expiração separadamente. Vamos definir a chave tempkey para o valor tempvalue:
```
SET tempkey tempvalue
```
O Redis responderá com:
```
OK
```
Definindo o Tempo de Expiração Usando o Comando EXPIRE:

Agora, vamos definir um tempo de expiração de 10 segundos para a chave tempkey usando o comando EXPIRE:
```
EXPIRE tempkey 10
```
O Redis responderá com:
```
(integer) 1
```
Uma resposta de (integer) 1 indica que o tempo de expiração foi definido com sucesso.
Verificando o Tempo Restante de Vida (TTL):

Para verificar o tempo restante de vida (TTL) para a chave tempkey, use o comando TTL:
```
TTL tempkey
```
O Redis responderá com o número de segundos restantes até a expiração da chave (por exemplo, (integer) 9). O valor pode ser ligeiramente menor que 10 devido ao tempo decorrido desde a definição da expiração. Se a chave não existir ou não tiver uma expiração, o TTL retorna -2 ou -1, respectivamente.
Saindo do Redis CLI:

Saia do Redis CLI:
```
exit
```

Resumo

Neste laboratório, você aprendeu as operações fundamentais de chave-valor no Redis usando a interface de linha de comando redis-cli. Você aprendeu como conectar-se ao servidor Redis e usar o comando SET para armazenar dados como pares chave-valor. Também praticou a recuperação de valores usando o comando GET. Além disso, aprendeu a verificar a existência de chaves usando o comando EXISTS, excluir chaves usando o comando DEL e definir tempos de expiração para chaves usando o comando SET com o parâmetro EX e o comando EXPIRE. O comando SET com o parâmetro EX é particularmente útil, pois permite definir um par chave-valor com tempo de expiração em uma única operação eficiente. Estes são os blocos de construção para usar o Redis como um armazenamento de dados simples e eficiente.

Operações Básicas de Chave-Valor no Redis