Introducción a las Estructuras de Datos de Redis

Introducción

En este laboratorio, explorarás las estructuras de datos fundamentales de Redis y cómo interactuar con ellas utilizando la herramienta de línea de comandos redis-cli. El laboratorio se centra en ejercicios prácticos para ayudarte a comprender cómo almacenar y recuperar datos en Redis.

Comenzarás trabajando con Strings (cadenas), aprendiendo cómo establecer (set), obtener (get), verificar la existencia y eliminar valores de cadena. Luego, pasarás a Lists (listas), utilizando comandos como LPUSH y LRANGE. A continuación, gestionarás Sets (conjuntos) con SADD y SMEMBERS. Finalmente, explorarás Hashes (tablas hash) utilizando HSET y HGET. Esta experiencia práctica te proporcionará una base sólida para usar Redis en diversas aplicaciones.

Trabajar con Cadenas (Strings) para Datos Simples

En este paso, exploraremos cómo usar Redis para almacenar y recuperar datos de tipo string (cadena) simples. Redis se utiliza a menudo como caché o como un simple almacén de clave-valor (key-value store), y los strings son el tipo de datos más básico que ofrece.

Primero, conectémonos al servidor Redis utilizando la herramienta de línea de comandos redis-cli. Abre una terminal en la VM de LabEx. Ya deberías estar en el directorio ~/project.

Escribe el siguiente comando para conectarte al servidor Redis:

redis-cli

Deberías ver un prompt (indicador) que se parece a esto:

127.0.0.1:6379>

Esto indica que ahora estás conectado al servidor Redis.

Ahora, establezcamos un valor de string simple. Usaremos el comando SET. El comando SET toma dos argumentos: la clave (key) y el valor (value). Establezcamos una clave llamada mykey con el valor Hello Redis:

SET mykey "Hello Redis"

Deberías ver la siguiente salida:

OK

Esto significa que el valor se ha establecido correctamente.

Ahora, recuperemos el valor utilizando el comando GET. El comando GET toma un argumento: la clave. Recuperemos el valor de mykey:

GET mykey

Deberías ver la siguiente salida:

"Hello Redis"

Esto confirma que hemos almacenado y recuperado correctamente un valor de string en Redis.

Probemos otro ejemplo. Esta vez, almacenemos un número como un string.

SET counter 100

GET counter

Deberías ver:

"100"

Redis trata esto como un string, aunque representa un número.

También puedes usar el comando EXISTS para verificar si una clave existe.

EXISTS mykey

Deberías ver:

(integer) 1

Esto indica que la clave mykey existe. Si la clave no existe, el comando devolverá (integer) 0.

Finalmente, eliminemos la clave utilizando el comando DEL.

DEL mykey

Deberías ver:

(integer) 1

Esto indica que la clave mykey se ha eliminado correctamente.

Ahora, si intentas obtener el valor de mykey nuevamente:

GET mykey

Deberías ver:

(nil)

Esto confirma que la clave ha sido eliminada.

Recuerda salir de redis-cli para asegurarte de que tus comandos se registren. Escribe:

exit

Esto te devolverá al prompt de la terminal normal.

Usar Listas con LPUSH y LRANGE

En este paso, exploraremos cómo usar las listas de Redis para almacenar y recuperar colecciones ordenadas de datos. Las listas de Redis se implementan como listas enlazadas (linked lists), lo que las hace eficientes para agregar y eliminar elementos desde el principio o el final de la lista. Nos centraremos en los comandos LPUSH y LRANGE.

Continuaremos utilizando la herramienta de línea de comandos redis-cli. Si aún no estás conectado, abre una terminal en la VM de LabEx y escribe:

redis-cli

Ahora, creemos una lista y agreguemos algunos elementos a ella utilizando el comando LPUSH. LPUSH agrega elementos a la izquierda (cabeza) de la lista. El comando LPUSH toma dos o más argumentos: la clave (key) de la lista y el/los valor(es) (value(s)) a agregar. Creemos una lista llamada mylist y agreguemos los valores item1, item2 y item3:

LPUSH mylist item1

Deberías ver la siguiente salida:

(integer) 1

Esto significa que se ha agregado un elemento a la lista. El valor de retorno de LPUSH es la longitud de la lista después de la operación.

Ahora, agreguemos los otros elementos:

LPUSH mylist item2

(integer) 2

LPUSH mylist item3

(integer) 3

Ahora, recuperemos los elementos de la lista utilizando el comando LRANGE. LRANGE devuelve un rango de elementos de la lista. El comando LRANGE toma tres argumentos: la clave de la lista, el índice de inicio (start index) y el índice de fin (end index). Los índices están basados en cero, por lo que el primer elemento está en el índice 0. Para recuperar todos los elementos de la lista, podemos usar el índice de inicio 0 y el índice de fin -1.

LRANGE mylist 0 -1

Deberías ver la siguiente salida:

1) "item3"
2) "item2"
3) "item1"

Observa que los elementos se devuelven en el orden inverso en que los agregamos, porque LPUSH agrega elementos al principio de la lista.

Agreguemos algunos elementos más a la lista:

LPUSH mylist item4
LPUSH mylist item5

Ahora, recuperemos los primeros 3 elementos de la lista (índices 0 a 2):

LRANGE mylist 0 2

Deberías ver:

1) "item5"
2) "item4"
3) "item3"

También puedes usar índices negativos para acceder a elementos desde el final de la lista. Por ejemplo, para recuperar el último elemento de la lista, puedes usar el índice -1:

LRANGE mylist -1 -1

Deberías ver:

1) "item1"

Recuerda salir de redis-cli para asegurarte de que tus comandos se registren. Escribe:

exit

Esto te devolverá al prompt de la terminal normal.

Gestionar Conjuntos (Sets) con SADD y SMEMBERS

En este paso, exploraremos cómo usar los conjuntos (sets) de Redis para almacenar y gestionar colecciones no ordenadas de elementos únicos. Los conjuntos de Redis son útiles para tareas como el seguimiento de visitantes únicos, el almacenamiento de etiquetas (tags) o la gestión de relaciones entre objetos. Nos centraremos en los comandos SADD y SMEMBERS.

Continuaremos utilizando la herramienta de línea de comandos redis-cli. Si aún no estás conectado, abre una terminal en la VM de LabEx y escribe:

redis-cli

Ahora, creemos un conjunto y agreguemos algunos miembros a él utilizando el comando SADD. SADD agrega uno o más miembros a un conjunto. El comando SADD toma dos o más argumentos: la clave (key) del conjunto y el/los miembro(s) (member(s)) a agregar. Creemos un conjunto llamado myset y agreguemos los miembros member1, member2 y member3:

SADD myset member1

Deberías ver la siguiente salida:

(integer) 1

Esto significa que se ha agregado un miembro al conjunto. El valor de retorno de SADD es el número de miembros que se agregaron al conjunto (excluyendo los miembros que ya estaban presentes).

Ahora, agreguemos los otros elementos:

SADD myset member2

(integer) 1

SADD myset member3

(integer) 1

Ahora, recuperemos los miembros del conjunto utilizando el comando SMEMBERS. SMEMBERS devuelve todos los miembros del conjunto. El comando SMEMBERS toma un argumento: la clave del conjunto.

SMEMBERS myset

Deberías ver la siguiente salida (el orden de los miembros puede variar, ya que los conjuntos no están ordenados):

1) "member3"
2) "member2"
3) "member1"

Intentemos agregar un miembro duplicado al conjunto:

SADD myset member1

Deberías ver:

(integer) 0

Esto indica que no se agregaron nuevos miembros, porque member1 ya estaba en el conjunto.

Agreguemos algunos miembros más al conjunto:

SADD myset member4
SADD myset member5

Ahora, recuperemos todos los miembros nuevamente:

SMEMBERS myset

Deberías ver algo como:

1) "member5"
2) "member4"
3) "member3"
4) "member2"
5) "member1"

El orden puede ser diferente.

Recuerda salir de redis-cli para asegurarte de que tus comandos se registren. Escribe:

exit

Esto te devolverá al prompt de la terminal normal.

Explorar Hashes con HSET y HGET

En este paso, exploraremos cómo usar los hashes de Redis para almacenar y recuperar colecciones de pares campo-valor (field-value pairs). Los hashes de Redis son útiles para representar objetos con múltiples atributos. Nos centraremos en los comandos HSET y HGET.

Continuaremos utilizando la herramienta de línea de comandos redis-cli. Si aún no estás conectado, abre una terminal en la VM de LabEx y escribe:

redis-cli

Ahora, creemos un hash y agreguemos algunos campos y valores a él utilizando el comando HSET. HSET establece el valor de un campo en un hash. El comando HSET toma tres argumentos: la clave (key) del hash, el campo (field) y el valor (value). Creemos un hash llamado myhash y establezcamos el campo field1 al valor value1:

HSET myhash field1 value1

Deberías ver la siguiente salida:

(integer) 1

Esto significa que se ha agregado un nuevo campo al hash. El valor de retorno de HSET es 1 si el campo es nuevo en el hash y 0 si el campo ya existe y el valor fue actualizado.

Ahora, agreguemos otro campo:

HSET myhash field2 value2

(integer) 1

Ahora, recuperemos el valor de un campo utilizando el comando HGET. HGET obtiene el valor de un campo en un hash. El comando HGET toma dos argumentos: la clave del hash y el campo. Recuperemos el valor de field1 en myhash:

HGET myhash field1

Deberías ver la siguiente salida:

"value1"

Esto confirma que hemos almacenado y recuperado con éxito un par campo-valor en el hash.

Intentemos actualizar el valor de un campo existente:

HSET myhash field1 newvalue1

Deberías ver:

(integer) 0

Esto indica que el campo ya existía y su valor fue actualizado.

Ahora, recuperemos el valor de field1 nuevamente:

HGET myhash field1

Deberías ver:

"newvalue1"

Esto confirma que el valor ha sido actualizado.

Agreguemos algunos campos más al hash:

HSET myhash field3 value3
HSET myhash field4 value4

Recuerda salir de redis-cli para asegurarte de que tus comandos se registren. Escribe:

exit

Esto te devolverá al prompt de la terminal normal.

Resumen

En este laboratorio, exploramos las estructuras de datos fundamentales de Redis, comenzando con las cadenas (strings). Aprendimos cómo conectarnos a un servidor Redis utilizando redis-cli y luego usamos el comando SET para almacenar valores de cadena asociados con claves (keys). Luego recuperamos estos valores utilizando el comando GET. También vimos cómo Redis trata los números almacenados como cadenas.

Además, aprendimos a crear y manipular Listas (Lists) utilizando LPUSH y LRANGE, a gestionar Conjuntos (Sets) con SADD y SMEMBERS, y a explorar Hashes utilizando HSET y HGET. Estos comandos te permiten almacenar y recuperar diferentes tipos de datos en Redis, convirtiéndolo en una herramienta versátil para diversas aplicaciones. Recuerda salir de redis-cli después de cada paso para asegurarte de que tus comandos se registren para su verificación.