Curso gratuito de Redis

Formación IT
REDIS
2019 por Rafael Hernampérez

Indice
• Introducción a REDIS
• Instalación de REDIS
• Estructuras de datos
• Strings y uso de claves
• Listas
• Conjuntos
• Conjuntos ordenados
• Hashes
• Geoespacial
• Transacciones
• Cliente REDIS en NodeJS
• GUIs para REDIS
• REDIS en remoto
• Anexo

Introducción a REDIS
¿Qué es REDIS?
• Base de datos NoSQL
• Plataforma de base de datos en memoria
• Creada en 2009 por Salvatore Sanfilippo
• Alto rendimiento operacional
• Open Source con licencia BSD
• Website: https://redis.io

Características principales
• Arquitectura optimizada:
• Escrito en C
• Gestionado enteramente en memoria. Ideal para cachés
• Hilo simple, libre de bloqueo
• Clustering y particiones
• Mínima latencia
• Extensibilidad mediante módulos:
• Búsquedas y recomendaciones
• IA y Redes neuronales
• Grafos
• Machine Learning
• Pipelining: Envío de múltiples comandos de una vez
• Streaming mediante sistema de mensajería por colas Publish/Subscribe
• Scripting mediante Lua
• Soporte de transacciones
• Drivers (clientes) para 50 lenguajes de programación

¿En qué escenarios utilizar REDIS?

Instalación de REDIS
Linux y MacOS
Descargar fuente:
Opción 1: Desde un navegador
http://download.redis.io/redis-stable.tar.gz
Opción 2: Mediante el comando wget
$ wget http://download.redis.io/redis-stable.tar.gz
Descomprimir archivo:
$ tar xvzf redis-stable.tar.gz
Compilar el fuente:
$ cd redis-stable
$ make
Nota: Si hay problemas con make: make distclean
Opcional: Para verificar la instalación: make test

Windows
Para Windows no hay un instalable
Solución: Instalar Ubuntu para Windows 10, a través de la Microsoft Store
El subsistema Linux para Windows 10 viene con el core básico, por lo que
habrá que actualizar todo el sistema:
$ sudo apt update
$ sudo apt upgrade
Instalar el compilador de C (gcc)
$ sudo apt install gcc
Seguir el procedimiento de instalación para Linux y MacOS

Docker
Instalar la imagen de REDIS:
$ docker pull redis
Verificar log del contenedor REDIS
$ docker logs <nombre_contenedor>
Crear y ejecutar un contenedor:
$ docker run --name <nombre_contenedor> -d redis
Lanzar entorno del contenedor REDIS:
$ docker exec –it <nombre_contenedor>.sh
Detener el contenedor REDIS
$ docker stop <nombre_contenedor>
Arrancar el contenedor REDIS
$ docker start <nombre_contenedor>

Arrancar REDIS
Los programas de REDIS se encuentran en el directorio src:
• redis-server: Servidor de REDIS
• redis-cli: Consola cliente de REDIS
• redis-sentinel: Centinela de REDIS. Para monitorización y failover
• redis-benchmark: Verificación del rendimiento de REDIS
Acceder a la carpeta y arrancar el servidor:
$ cd <ruta_a_src>
$ ./redis-server &
Arrancar el cliente (o consola) de REDIS
$ ./redis-cli
Al arrancar el cliente de REDIS podremos gestionar completamente
REDIS a través de comandos

Indice
• Strings
• Listas
• Conjuntos
• Hashes
• Geoespacial
• Transacciones
• GUIs para REDIS
• REDIS en remoto
• Anexo

Estructuras de datos
Un vistazo

Estructuras de datos: Strings y uso de claves
Crear, modificar y obtener
• Todo en REDIS se especifica mediante clave / valor (key / value)
• Los comandos principales son:
• set <clave> <valor>: Crea una clave o actualiza el valor de ésta
• get <clave>: Recupera el valor de una clave
• Ejemplos:
$ ./redis-cli
# 127.0.0.1:6379> set nombre Rafael
OK
# 127.0.0.1:6379> set apellido "Martin"
OK
# get nombre
"Rafael"
# 127.0.0.1:6379> set apellido "Hernamperez" // cambia el valor
OK
# 127.0.0.1:6379> get apellido
"Hernamperez"
--- NOTAS ---
Si el valor es una única
palabra (sin espacios), se
pueden omitir las comillas.
Si la clave ya existía, se
actualiza el valor de ésta

Concatenar texto a un valor string
El comando append concatena un texto a la derecha del valor de una
clave de tipo string:
# 127.0.0.1:6379> get apellido
"Hernamperez"
# 127.0.0.1:6379> append apellido " Martin”
(integer) 18
# 127.0.0.1:6379> get apellido
"Hernamperez Martin" --- NOTAS ---
El comando append retorna
la longitud total del string
tras la concatenación del
texto. Es decir, al terminar,
ejecuta automáticamente el
comando strlen.
El comando strlen permite conocer el tamaño o longitud del valor
de una clave:
# 127.0.0.1:6379> strlen apellido
(integer) 18

Valores numéricos (enteros)
• Los valores se asumen como strings, aunque representen números
• Se pueden aplicar incrementos y decrementos sobre valores numéricos
almacenados en strings
# 127.0.0.1:6379> set contador 0
OK
# 127.0.0.1:6379> get contador
"0" // El valor es string
# incr contador
(integer) 1 // Nuevo valor calculado
# 127.0.0.1:6379> incrby contador 5
# decr contador
# decrby contador 2
--- NOTAS ---
Las operaciones de
incremento con incr,
incrby, decr y decrby sólo
se aplican a valores
enteros. No funcionan en
números con decimales

Valores numéricos (decimales)
• Para trabajar con números en coma flotante (con decimales), REDIS
dispone del comando incrbyfloat
# 127.0.0.1:6379> set salario 33500.50
OK
# 127.0.0.1:6379> get salario
"33500.50" // El valor es string
# incrbyfloat salario 1200.75
"34701.25" // Nuevo valor calculado
--- NOTAS ---
A diferencia de los números
enteros, REDIS sólo
proporciona un comando
para realizar operaciones
de incremento en el caso de
números con decimales

Listar claves
Para listar las claves existentes:
# 127.0.0.1:6379> keys * // cualquier nombre
1) "nombre"
2) "apellido"
3) "contador"
--- NOTAS ---
Ejemplos de patrón:
* Cualquier longitud y valor
[] Afecta un único carácter
^ Distinto de
? Sustituye carácter
a-m Entre ‘a’ y ‘m’
El comando keys lista las claves que concuerden con un patrón
# 127.0.0.1:6379> keys n* // empiecen por "n"
1) "nombre"
# 127.0.0.1:6379> keys *or // terminen por "or"
1) "contador"
# 127.0.0.1:6379> keys *l* // contengan una "l"
1) "apellido”
# 127.0.0.1:6379> keys [^a]* // que no empiecen por "a"
1) "nombre"
2) "contador"

Renombrar claves
Para modificar el nombre de una clave usaremos el comando rename:
# 127.0.0.1:6379> set salario 33500.50
OK
# 127.0.0.1:6379> keys *
1) "salario"
# 127.0.0.1:6379> rename salario salario_anual
OK
# 127.0.0.1:6379> keys *
1) "salario_anual" --- NOTAS ---
Un consejo sería utilizar el
comando exists para
verificar si la clave a
renombrar existe.
Si renombramos una clave
que no existe dará un error:
(error) ERR no such key
Para evitar problemas, podemos usar el comando renamenx, el cual
permite renombra la clave si el nombre de la nueva clave no existe
previamente (retornará 1)
# 127.0.0.1:6379> set salario2 25795.0
OK
# 127.0.0.1:6379> renamenx salario2 salario_anual
(integer) 0 // no se ha renombrado pq ya existía salario_anual

Eliminar claves
El comando del permite eliminar o borrar una clave:
# 127.0.0.1:6379> del contador
(integer) 1
# 127.0.0.1:6379> del nombre apellido
(integer) 2
--- NOTAS ---
Recordemos que una clave
se aplica a cualquier
estructura de datos en
REDIS, no solamente a
strings
El comando del retorna el
número de claves
eliminadas
Una recomendación sería verificar si la clave a eliminar existe
previamente, mediante el uso del comando exists:
# 127.0.0.1:6379> exists apellido
(integer) 0
Retorna 0 si la clave no existe. Retorna 1 si la clave existe.
Se pueden eliminar TODAS las claves de la base de datos mediante
el comando flushdb:
# 127.0.0.1:6379> flushdb
OK

Eliminación automática de claves
REDIS permite crear claves con un tiempo de expiración:
# 127.0.0.1:6379> set nombre Rafael EX 60 // 60 segundos
OK
# 127.0.0.1:6379> set apellido Martin PX 5500 // 5500 milisegundos
OK
--- NOTAS ---
REDIS dispone del
comando ttl (Time To
Live), el cual retorna el
tiempo que le queda de
vida a una clave, en
segundos. Si la clave no
expira, retornará -1. Si la
clave no existe retornará -2
También se puede definir el tiempo de expiración una vez la clave
ya está definida:
OK
# 127.0.0.1:6379> expire nombre 60 // siempre segundos
(integer) 1
# 127.0.0.1:6379> set apellido Martin
OK
# 127.0.0.1:6379> pexpire apellido 5500 // siempre milisegundos
(integer) 1

Tipo de claves
Las claves pueden referenciar a diferentes estructuras de datos.
Mediante type podemos conocer el tipo de datos que contiene una clave
# 127.0.0.1:6379> set salario_anual 33500.50
OK
# 127.0.0.1:6379> type salario_anual
string
# 127.0.0.1:6379> rpush lista 1 2 3 4 5
(integer) 5
# 127.0.0.1:6379> type lista
list

Estructuras de datos: Strings
Nombres de clave
La elección de un nombre de clave es fundamental, pues en un entorno
real en producción se gestionarán muchas claves de forma dinámica.
REDIS permite formar nombres de clave con signos (generalmente los dos
puntos o el guión o el subrayado). Ejemplos:
conductor:1109 // entidad (conductor) e id (1109 )
conductor:ES:1109 // entidad (conductor, país (ES) e id (1109)
Estos nombres nos facilitan localizar los valores que necesitemos en cada
momento, conociendo su formato.
El tamaño del nombre de la clave impacta en el rendimiento de REDIS. Por
tanto, cuando más corto sea, más eficiente y rápido será.
Link de interés: http://adamnengland.com/2012/11/15/redis-performance-does-key-length-matter
--- NOTAS ---
Es importante calibrar entre
un nombre de clave largo,
descriptivo y con detalles
de información, y el
rendimiento del uso de
dichas claves, Una buena
propuesta sería no exceder
de 50 caracteres. La clave
debe referenciar valores, no
ser esos valores

Estructuras de datos: Listas
Agregar valores a una lista por la derecha
Una lista permite asociar más de un valor de tipo string a una clave.
El comando rpush agrega valores a la derecha de la lista:
# 127.0.0.1:6379> rpush alumnnos Manuel Teresa Juan Maria
(integer) 4 // numero total de elementos
# 127.0.0.1:6379> lrange alumnos 0 -1
1) "Manuel"
2) "Teresa"
3) "Juan”
4) "Maria"
# 127.0.0.1:6379> rpush alumnos "Manuel"
(integer) 5 // numero total de elementos
Las listas pueden contener valores repetidos. En el ejemplo, la lista
alumnos tendrá los valores: [Manuel, Teresa, Juan, Maria, Manuel]
--- NOTAS ---
REDIS proporciona el
comando rpushx, el cual
sólo agregará valores si la
clave de la lista existe
previamente.

Agregar valores a una lista por la izquierda
El comando lpush agrega valores a la derecha de la lista:
# 127.0.0.1:6379> lpush alumnnos Miguel Rafael Maria
(integer) 8 // numero elementos agregados
# 127.0.0.1:6379> lrange alumnos 0 -1
1) "Maria"
2) "Rafael”
3) "Miguel"
4) "Manuel"
5) "Teresa"
6) "Juan”
7) "Maria"
8) "Manuel"
--- NOTAS ---
REDIS proporciona el
comando lpushx, el cual
sólo agregará valores si la
clave de la lista existe
previamente.
El orden de agregación se realiza por la izquierda: primero Miguel,
después, Rafael, y, por último, María.

Listar los valores de una lista
El comando lrange retorna un conjunto de valores de una lista. Su
sintaxis es la siguiente:
lrange <nombre_lista> <inicio> <fin>
El primer elemento (izquierda) de la lista comienza en la posición 0.
El último elemento (derecha) de la lista, es igual al número de
elementos menos uno. También se puede referenciar como la
posición -1, el penúltimo como -2, el antepenúltimo como -3, y así,
sucesivamente.
Ejemplos:
lrange alumnos 0 0 // Primer elemento
lrange alumnos -1 -1 // Último elemento
lrange alumnos 0 -1 // desde el primero hasta el último
lrange alumnos 0 2 // 3 primeros valores
lrange alumnos -3 -1 // 3 últimos valores

Extraer valores de una lista
Los comandos lpop y rpop nos permiten extraer valores de la lista
desde la izquierda y desde la derecha (respectivamente):
# 127.0.0.1:6379> rpop alumnnos
"Manuel" // el primero por la derecha
# 127.0.0.1:6379> lpop alumnos
"Maria" // el primero por la izquierda
# 127.0.0.1:6379> lrange 0 -1
1) "Rafael"
2) "Miguel"
3) "Manuel"
4) "Teresa"
5) "Juan"
6) "Maria"
--- NOTAS ---
Cuando se extrae un valor
de la lista, éste desaparece
de la misma, con lo que la
lista va menguando en
cada extracción.
Solamente se pueden extraer valores de uno en uno.

Ordenar valores de una lista
El comando sort permite ordenar una lista:
# 127.0.0.1:6379> sort alumnos ASC ALPHA
1) "Juan"
2) "Manuel"
3) "Maria"
4) "Miguel"
5) "Rafael"
6) "Teresa"
--- NOTAS ---
Este comando retorna la
lista ordenada, pero la lista
original sigue teniendo el
mismo orden. Es decir, no
transforma la lista,
solamente realiza la
operación y retorna el
resultado.
Para las listas se suelen aplicar estos parámetros:
• ASC: Orden ascendente
• DESC: Orden descendente
• ALPHA: Para ordenar una lista de valores de texto (no números)

Insertar valores en una lista
El comando linsert permite insertar un nuevo valor en la lista, a
partir de un determinado valor, llamado pivote:
# 127.0.0.1:6379> linsert alumnos BEFORE Manuel Abel
(integer) 7
# 127.0.0.1:6379> lrange 0 -1
1) "Rafael"
2) "Miguel"
3) "Abel" // Valor insertado
4) "Manuel" // Valor pivote
5) "Teresa"
6) "Juan"
7) "Maria"
--- NOTAS ---
Si la clave no existe, asume
que es una lista vacía y no
hace nada.
Si el valor pivote no existe
retornará un error.
Parámetros:
• BEFORE: Antes del valor pivote
• AFTER: Después del valor pivote

Modificar un valor en una lista
Para modificar un valor de una lista, usaremos el comando lset:
--- NOTAS ---
En el comando lset hay
que especificar la posición
del valor a modificar.
Recordemos que la primera
posición es 0, y la última es
el número de elementos
menos uno. Se puede
especificar -1 para apuntar
a la última posición.
# 127.0.0.1:6379> lrange alumnos 0 -1
1) "Rafael"
2) "Miguel"
3) "Abel"
4) "Manuel"
5) "Teresa"
6) "Juan"
7) "Maria"
# 127.0.0.1:6379> lset alumnos -1 Marta
OK
# 127.0.0.1:6379> lrange alumnos -3 -1
1) "Teresa"
2) "Juan"
3) "Marta"

Número de elementos de una lista
Para conocer el número de valores de una lista, usaremos el
comando llen:
# 127.0.0.1:6379> lrange alumnos 0 -1
1) "Rafael"
2) "Miguel"
3) "Abel"
4) "Manuel"
5) "Teresa"
6) "Juan"
7) "Marta"
# 127.0.0.1:6379> llen alumnos
(integer) 7

Obtener un valor una lista a partir de su posición
Para obtener un valor contenido en una determinada posición en
una lista, usaremos el comando lindex:
# 127.0.0.1:6379> lrange alumnos 0 -1
1) "Rafael"
2) "Miguel"
3) "Abel"
4) "Manuel"
5) "Teresa"
6) "Juan"
7) "Marta"
# 127.0.0.1:6379> lindex alumnos 2
"Abel"
--- NOTAS ---
Recordemos que la
posición de una lista
comienza en cero.
A diferencia de lpop y rpop,
el comando lindex no
elimina el valor de la lista,
permaneciendo intacto.

Eliminar valores de una lista
Para eliminar valores de una lista, usaremos el comando lrem:
# 127.0.0.1:6379> lrem alumnos 0 Abel
(integer) 1
La sintaxis de lrem es la siguiente:
lrem <nombre_lista> <conteo> <valor>
El parámetro <conteo> define el punto desde el cual se comienza a
realizar la eliminación, así como también la dirección en que se realizará
la eliminación. Puede contener estos valores:
• > 0: Desde esa posición al principio (izquierda) hasta el final (derecha)
• < 0: Desde esa posición al final (derecha) hasta el inicio (izquierda)
• = 0: En toda la lista

Dejar únicamente un rango de valores en una lista
El comando ltrim permite conservar los valores de un rango de una
lista, eliminando el resto de valores de la misma:
# 127.0.0.1:6379> lrange alumnos 0 -1
1) "Rafael"
2) "Miguel"
3) "Manuel"
4) "Teresa"
5) "Juan"
6) "Marta"
# 127.0.0.1:6379> ltrim alunmnos 2 3
OK
# 127.0.0.1:6379> lrange alumnos 0 -1
1) "Manuel"
2) "Teresa"
--- NOTAS ---
Recordemos que la primera
posición de la lista empieza
en 0, y que la última
posición es longitud-1

Eliminar una lista
Para eliminar una lista usaremos el comando del:
# 127.0.0.1:6379> del alumnos
(integer) 1
# 127.0.0.1:6379> keys alumnos
(empty list or set)
--- NOTAS ---
El comando del elimina
cualquier clave,
independientemente del
tipo de datos que contenga,
ya sea un string, una lista,
un hash, etc.

Estructuras de datos: Conjuntos
Agregar valores a un conjunto
Un conjunto es similar a una lista, pero sin valores repetidos.
El comando sadd permite agregar valores a un conjunto:
# 127.0.0.1:6379> sadd frutas naranja manzana pera naranja pera
(integer) 3 // Sólo añadió tres valores (sin repetir)
--- NOTAS ---
Si el conjunto no existía
previamente, el comando
sadd crea el conjunto y le
agrega los valores.
Para listar los valores de un conjunto usaremos el comando
smembers:
# 127.0.0.1:6379> smembers frutas
1) "naranja"
2) "pera"
3) "manzana"

Extraer valores de un conjunto
El comando spop extrae y elimina un valor del conjunto:
# 127.0.0.1:6379> spop frutas
"pera"
# 127.0.0.1:6379> smembers frutas
1) "naranja"
2) "manzana"
--- NOTAS ---
La extracción se realiza de
forma aleatoria.
El segundo parámetro de
srandmembers indica el
número de valores a extraer
El comando srandmember extrae el valor pero no lo elimina:
# 127.0.0.1:6379> sadd frutas pera sandia higo
(integer) 3
# 127.0.0.1:6379> srandmembers frutas
"naranja"
# 127.0.0.1:6379> srandmembers frutas 2
1) "pera"
2) "manzana"

Eliminar valores de un conjunto
El comando srem elimina un valor del conjunto:
# 127.0.0.1:6379> srem frutas higo
(integer) 1
# 127.0.0.1:6379> srem frutas pera sandia
(integer) 2
# 127.0.0.1:6379> smembers
1) "naranja"
2) "manzana" --- NOTAS ---
El comando srem retorna el
número de valores
eliminados

Consultas en un conjunto
Además de smembers, hay otros comandos para consultas.
El comando scard retorna la cardinalidad (número de valores):
# 127.0.0.1:6379> sadd frutas pera sandia higo
(integer) 3
# 127.0.0.1:6379> scard frutas
(integer) 5 // previamente teníamos naranja y manzana
--- NOTAS ---
El comando sismember
retorna 1 si el valor existe, o
el valor 0 si no existe.
Para comprobar si un valor existe en el conjunto, usaremos el
comando sismember:
# 127.0.0.1:6379> sismember aguacate
(integer) 0
# 127.0.0.1:6379> sismember pera
(integer) 1

Interconjuntos: mover valores
La principal diferencia con las listas, es que los conjuntos pueden
interactuar entre sí.
El comando smove permite mover un valor de un conjunto a otro:
# 127.0.0.1:6379> sadd set1 a b c d e
(integer) 5
# 127.0.0.1:6379> sadd set2 f g h
(integer) 3
# 127.0.0.1:6379> smove set1 set2 c
(integer) 1 // set1=a,b,d,e – set2=f,g,h,c
# 127.0.0.1:6379> smembers set2
1) "h"
2) "c"
3) "f"
4) "g"
--- NOTAS ---
El comando sismember
retorna 1 si el valor existe, o
el valor 0 si no existe.

Interconjuntos: unir valores
El comando sunion permite unir los valores de dos o más conjuntos:
# 127.0.0.1:6379> sadd set3 z y x
(integer) 3
# 127.0.0.1:6379> sunion set1 set2 set3
1) "a"
2) "h"
3) "d"
4) "c"
5) "e"
6) "f"
7) "b"
8) "g"
9) "x"
10) "y"
11) "z"
--- NOTAS ---
El comando sunion retorna
el resultado de la unión de
los conjuntos, pero no
afecta ni modifica los
conjuntos involucrados.
El comando sunionstore
permite almacenar la unión
en un nuevo conjunto

Interconjuntos: intersección de valores
El comando sinter retorna los valores comunes del primer conjunto
con el resto de conjuntos:
# 127.0.0.1:6379> sadd set4 1 2 3 4
(integer) 4
# 127.0.0.1:6379> sadd set5 10 11 2 3 12 14
(integer) 6
# 127.0.0.1:6379> sinter set4 set5
1) "2"
2) "3" --- NOTAS ---
El comando sinter retorna
el resultado de la
intersección de los
conjuntos, sin afectar ni
modificar éstos.
El comando sinterstore
almacena la intersección
en un nuevo conjunto
Se toman como referencia los valores del primer conjunto para
realizar la operación con el resto de conjuntos.

Interconjuntos: diferencia de valores
El comando sdiff retorna los valores no comunes entre el primer
conjunto y el resto de conjuntos:
# 127.0.0.1:6379> sadd set4 1 2 3 4
(integer) 4
# 127.0.0.1:6379> sadd set5 10 11 2 3 12 14
(integer) 6
# 127.0.0.1:6379> sdiff set4 set5
1) "1"
2) "4”
# 127.0.0.1:6379> sdiff set5 set4
1) "10"
2) "11"
3) "12"
4) "14"
--- NOTAS ---
El comando sdiff retorna
el resultado de la diferencia
de los conjuntos, sin afectar
ni modificar éstos.
El comando sdiffstore
almacena la diferencia en
un nuevo conjuntoSe toman como referencia los valores del primer conjunto para
realizar la operación con el resto de conjuntos.

Estructuras de datos: Conjuntos ordenados
Agregar valores a un conjunto ordenado
Un conjunto ordenado permite asociar un valor numérico (score) a
un valor miembro (member) en un conjunto. La ordenación se realiza
sobre el valor numérico.
El comando zadd permite agregar valores a un conjunto ordenado:
# 127.0.0.1:6379> zadd frutas 1.5 naranja 2.7 pera 2.2 manzana
(integer) 3
--- NOTAS ---
Si el conjunto no existía
previamente, el comando
zadd crea el conjunto y le
agrega los valores.
Adicionalmente, el comando zadd posee parámetros que definen su
comportamiento:
• XX: Actualiza valores que ya existen. No agrega valores.
• NX: Agrega nuevos valores. No actualiza valores existentes.
• INCR: Incrementa y actualiza un valor score existente.
# 127.0.0.1:6379> zadd frutas incr 0.3 naranja
"1.8"

Listar valores de un conjunto ordenado
El comando zrange permite listar valores de un conjunto ordenado:
# 127.0.0.1:6379> zrange frutas 0 -1
1) "naranja"
2) "manzana"
3) "pera"
--- NOTAS ---
El comando zrange
funciona como lrange.
El primer elemento
(izquierda) comienza en
posición 0. El último
elemento (derecha)
empieza en -1 ó en longitud
menos 1.
Para ver los scores utilizaremos el parámetro WITHSCORES:
# 127.0.0.1:6379> zrange frutas 0 -1 withscores
1) "naranja"
2) "1.8"
3) "manzana"
4) "2.2000000000000002"
5) "pera"
6) "2.7000000000000002"
El comando zrangebyscore lista aquellos miembros cuyo score se
encuentre en el rango especificado como mínimo y máximo:
# 127.0.0.1:6379> zrangebyscore frutas 2 3 withscores
1) "manzana"
2) "2.2000000000000002"
3) "pera"
4) "2.7000000000000002"

Listar valores ordenados al revés
El comando zrevrange funciona como el comando zrange, pero
ordenando al revés:
# 127.0.0.1:6379> zrevrange frutas 0 -1 withscores
1) "pera"
2) "2.7000000000000002"
3) "manzana"
4) "2.2000000000000002"
5) "naranja"
6) "1.8"
El comando zrevrangebyscore funciona como zrevrangebyscore,
pero con la ordenación al revés:
# 127.0.0.1:6379> zrevrangebyscore frutas 2 3 withscores
1) "pera"
2) "2.7000000000000002"
3) "manzana"
4) "2.2000000000000002"

Conteo en un conjunto ordenado
El comando zcard retorna la cardinalidad o número total de valores:
# 127.0.0.1:6379> zcard frutas
(integer) 3
El comando zcount retorna el número de valores que se encuentran
en un determinado rango de scores:
# 127.0.0.1:6379> zcount frutas 2 3 // mínimo y máximo
(integer) 2 // manzana y pera

Ranking de un miembro
El score define el campo por el cual se ordena todo el conjunto. De
esta manera, también permite conocer el ranking de un miembro.
El comando zrevrank retorna el ranking en sentido inverso:
# 127.0.0.1:6379> zrevrank frutas manzana
(integer) 2
# 127.0.0.1:6379> zrevrank frutas pera
(integer) 1
# 127.0.0.1:6379> zrange frutas 0 -1 withscores
1) "manzana"
2) "2.2000000000000002"
3) "pera"
4) "2.7000000000000002"
5) "naranja"
6) "3.7000000000000002"
# 127.0.0.1:6379> zrank frutas manzana
(integer) 0
# 127.0.0.1:6379> zrank frutas pera
(integer) 2
--- NOTAS ---
El ranking comienza en el
número 0, como las
posiciones en una lista.

Conocer el score de un miembro
Para conocer el score de un determinado miembro, utilizaremos el
comando zscore:
# 127.0.0.1:6379> zscore frutas naranja
"3.7000000000000002"
# 127.0.0.1:6379> zscore frutas aguacate
(nil)
Si el miembro no existe en el conjunto ordenado retornará un (nil)

Modificar el score de un miembro
Podemos modificar el score de un miembro mediante los
parámetros XX e INCR del comando zadd:
# 127.0.0.1:6379> zadd frutas xx 2.75 manzana
(integer) 0 // 0 = actualizado – 1 = creado
# 127.0.0.1:6379> zadd frutas incr 0.2 manzana
"2.9500000000000002"
--- NOTAS ---
Recordemos que el
parámetro XX de zadd sirve
solamente para actualizar,
y el parámetro incr sirve
para incrementar el valor
de un score.
El parámetro XX actualiza directamente con un nuevo valor,
mientras que el parámetro INCR suma el valor pasado al valor
actual, incrementándolo.
El comando zincrby hace lo mismo que zadd con INCR:
# 127.0.0.1:6379> zincrby frutas 0.15 pera
"2.8500000000000001"

Extraer valores de un conjunto ordenado
El comando zpopmax permite extraer y eliminar valores al final
(derecha) de un conjunto ordenado:
# 127.0.0.1:6379> zrange frutas 0 -1
1) "pera" // 2.8500000000000001
2) "manzana" // 2.9500000000000002
3) "naranja" // 3.7000000000000002
# 127.0.0.1:6379> zpopmax frutas
1) "naranja"
2) "3.7000000000000002" --- NOTAS ---
Tanto zpopmax como
zpopmin tienen un
parámetro opcional
llamado count, el cual
permite definir cuántos
valores se extraen del
conjunto ordenado. Por
defecto, es 1.
El comando zpopmin permite extraer y eliminar valores al inicio
(izquierda) de un conjunto ordenado:
# 127.0.0.1:6379> zrange frutas 0 -1
1) "pera" // 2.8500000000000001
2) "manzana" // 2.9500000000000002
# 127.0.0.1:6379> zpopmin frutas
1) "pera"
2) "2.8500000000000001"

Eliminar miembros de un conjunto ordenado
Para eliminar uno o varios miembros de un conjunto ordenado,
utilizaremos el comando zrem:
# 127.0.0.1:6379> zrem frutas manzana
(integer) 1 // Número de miembros eliminados
Se pueden eliminar miembros que se encuentren dentro de un
rango de ranking, mediante el comando zrembyrank:
zrembyrank <conjunto> <inicio> <fin>
También se pueden eliminar miembros cuyo score se encuentre
dentro de un rango de valores, mediante el comando zrembyscore:
<zrembyscore> <conjunto> <valor_mínimo> <valor_máximo>

Estructuras de datos: Hashes
Agregar / Modificar valores en un hash
Un hash es una estructura de datos compuesta, la cual contiene
múltiples campos de tipo string, en formato clave/valor.
El comando hset permite agregar o actualizar campos del hash:
# 127.0.0.1:6379> hset usuario:1 nombre Rafael
(integer) 1
# 127.0.0.1:6379> hset usuario:1 apellido1 Hernamperez apellido2
Martin telefono 992326647
(integer) 3
--- NOTAS ---
El comando hset retorna el
número de campos
agregados al hash. Si se
trata de una actualización,
retornará un 0

Modificar valores en un hash
Con el comando hset se actualizan los campos de forma directa:
# 127.0.0.1:6379> hset usuario:1 telefono 992330042
(integer) 0
--- NOTAS ---
El comando hsetnx retorna
el número de campos
retornará un 0
Con el comando hsetnx se creará el campo si no existe previamente
(como hset), pero si ya existe no lo actualizará:
# 127.0.0.1:6379> hsetnx usuario:1 telefono 992556677
(integer) 0
# 127.0.0.1:6379> hget usuario:1 telefono
"992330042"

Obtener valores de un hash
El comando hgetall retorna todos los valores de un hash:
# 127.0.0.1:6379> hgetall usuario:1
1) "nombre"
2) "Rafael"
3) "apellido1"
4) "Hernamperez"
5) "apellido2"
6) "Martin"
7) "telefono"
8) "992326647"
--- NOTAS ---
El comando hset retorna el
número de campos
retornará un 0
El comando hget retorna el valor de un determinado campo:
# 127.0.0.1:6379> hget usuario:1 telefono
"992326647"

Eliminar valores de un hash
El comando hdel permite eliminar uno o varios campos del hash:
# 127.0.0.1:6379> hdel usuario:1 telefono
(integer) 1
# 127.0.0.1:6379> hgetall usuario:1
1) "nombre"
2) "Rafael"
3) "apellido1"
4) "Hernamperez"
5) "apellido2"
6) "Martin"
--- NOTAS ---
El comando hdel retorna el
número de campos
eliminados del hash.

Incremento de valores numéricos en un hash
Vamos a agregar dos campos numéricos al hash de ejemplo:
# 127.0.0.1:6379> hset usuario:1 salario 24670.67 edad 32
(integer) 2 // agregados dos campos nuevos
El comando hincrby suma un valor a un campo con un valor entero:
# 127.0.0.1:6379> hincrby usuario:1 edad 16
(integer) 48 // nuevo valor
El comando hincrbyfloat suma un valor a un campo con un valor
en coma flotante (con decimales):
# 127.0.0.1:6379> hincrbyfloat usuario:1 salario 995.92
"25666.59000000000014552" // nuevo valor

Conocer los campos de un hash
El comando hlen retorna el número de campos en un hash:
# 127.0.0.1:6379> hlen usuario:1
(integer) 5
El comando hkeys retorna los campos (claves) contenidos en un hash:
# 127.0.0.1:6379> hkeys usuario:1
1) "nombre"
2) "apellido1"
3) "apellido2"
4) "salario"
5) "edad"
Para saber si un determinado campo se encuentra en un hash,
utilizaremos el comando hexists:
# 127.0.0.1:6379> hexists usuario:1 apellido1
(integer) 1
# 127.0.0.1:6379> hexists usuario:1 telefono
(integer) 0
--- NOTAS ---
El comando hexists
retorna 1 si el campo existe,
o 0 si no existe.

Conocer los valores de un hash
El comando hvals retorna la lista de todos los valores en un hash:
# 127.0.0.1:6379> hvals usuario:1
1) "Rafael"
2) "Hernamperez"
3) "Martin"
4) "25666.59000000000014552"
5) "48"

Tamaño de los valores de un hash
El comando hstrlen retorna el tamaño de un campo del hash:
# 127.0.0.1:6379> hstrlen usuario:1 nombre
(integer) 6 // Rafael
# 127.0.0.1:6379> hstrlen usuario:1 apellido1
(integer) 11 // Hernamperez
# 127.0.0.1:6379> hstrlen usuario:1 apellido2
(integer) 6 // Martin
# 127.0.0.1:6379> hstrlen usuario:1 salario
(integer) 23 // 25666.59000000000014552
# 127.0.0.1:6379> hstrlen usuario:1 edad
(integer) 2 // 48

Estructuras de datos: Geoespacial
Agregar / Modificar valores en una estructura geoespacial
REDIS permite gestionar datos geoespaciales mediante una
estructura basada en conjuntos ordenados. Básicamente,
utilizaremos una clave para una colección de datos, a la cual
añadiremos la longitud y latitud de una posición GPS y asignaremos
a esa posición un nombre, que será el miembro de la colección.
Para agregar una geoposición a la colección, o modificar una
existente, utilizaremos el comando geoadd:
# 127.0.0.1:6379> geoadd ciudades 40.4918334 -3.8820567 "Las Rozas"
(integer) 1
# 127.0.0.1:6379> geoadd ciudades 40.4741992 -3.8766899 Majadahonda
(integer) 1
# 127.0.0.1:6379> geoadd ciudades 40.4180553 -3.7148662 Madrid
(integer) 1
# 127.0.0.1:6379> geoadd ciudades 40.3358507 -3.8176518 Alcorcon
(integer) 1
# 127.0.0.1:6379> geoadd ciudades 40.3231957 -3.8623455 Mostoles
(integer) 1
--- NOTAS ---
El orden de los parámetros:
- Clave
- Longitud
- Latitud
- Miembro
Se pueden añadir más
miembros en el mismo
comando.

Listar los miembros una estructura geoespacial
La estructura geoespacial comparte algunos comandos de conjuntos
ordenados. Para listar los miembros podemos usar zrange:
# 127.0.0.1:6379> zrange ciudades 0 -1
1) "Mostoles"
2) "Alcorcon"
3) "Madrid"
4) "Majadahonda"
5) "Las Rozas"
Para listar los miembros en orden descendente usaremos zrevrange:
# 127.0.0.1:6379> zrevrange ciudades 0 -1
1) "Las Rozas"
2) "Majadahonda"
3) "Madrid"
4) "Alcorcon"
5) "Mostoles"

Obtener las coordenadas de un miembro
El comando geopos permite obtener las coordenadas de un
determinado miembro de la colección:
# 127.0.0.1:6379> geopos ciudades Madrid
1) 1) "40.41805475950241089"
2) "-3.71486578599731132“
# 127.0.0.1:6379> geopos ciudades Mostoles Majadahonda
1) 1) "40.32319575548171997"
2) "-3.86234600193228772"
2) 1) "40.47419875860214233"
2) "-3.87668998897299133"
--- NOTAS ---
El primer resultado es la
longitud y el segundo es la
latitud
Se pueden añadir más
miembros en el mismo
comando.

Calcular la distancia entre dos miembros
El comando geodist permite calcular la distancia entre dos
miembros de la colección. Por defecto, la distancia se medirá en
metros:
# 127.0.0.1:6379> geodist ciudades "Las Rozas" Mostoles
"18841.8931"
--- NOTAS ---
Las unidades métricas son:
- m: metros
- km: kilómetros
- mi: millas
- ft: pies
Si queremos averiguar la distancia en kilómetros, agregaremos un
parámetro más que indicará la unidad métrica:
# 127.0.0.1:6379> geodist ciudades "Las Rozas" Mostoles km
"18.8419"

Obtener miembros en un radio basado en distancia
El comando georadius retorna, a partir de una determinada posición
GPS, los miembros de una colección que se encuentran dentro de
un radio específico:
# 127.0.0.1:6379> georadius ciudades 40.440616 -3.7846726 13 km
1) "Majadahonda"
2) "Las Rozas"
3) "Alcorcon"
4) "Madrid"
--- NOTAS ---
- m: metros
- km: kilómetros
- mi: millas
- ft: pies
Parámetros adicionales:
- WITHCOORD
- WITHDIST
- ASC | DESC
El parámetro WITHDIST retorna la distancia :
# 127.0.0.1:6379> georadius ciudades 40.440616 -3.7846726 13 km withdist
1) 1) "Majadahonda"
2) "10.8922"
2) 1) "Las Rozas"
2) "12.2323"
3) 1) "Alcorcon"
2) "12.1919"
4) 1) "Madrid"
2) "8.1581"

Obtener miembros en un radio desde otro miembro
El comando georadiusbymember retorna, a partir de la posición de un
miembro, los miembros que se encuentran dentro de un radio
específico:
# 127.0.0.1:6379> georadiusbymember ciudades Madrid 20 km withdist
1) 1) "Mostoles"
2) "19.4914"
2) 1) "Alcorcon"
2) "14.6267"
3) 1) "Madrid"
2) "0.0000"
4) 1) "Majadahonda"
2) "19.0471“
# 127.0.0.1:6379> georadiusbymember ciudades Madrid 20 km withdist ASC
count 2
1) 1) "Madrid"
2) "0.0000"
2) 1) "Alcorcon"
2) "14.6267"
--- NOTAS ---
- m: metros
- km: kilómetros
- mi: millas
- ft: pies
Parámetros adicionales:
- WITHCOORD
- WITHDIST
- ASC | DESC
- COUNT

Eliminar miembros de una colección geoespacial
Compartiendo características de un conjunto ordenado, podemos
eliminar un miembro mediante el comando zrem:
# 127.0.0.1:6379> zrem ciudades Majadahonda "Las Rozas"
(integer) 2
# 127.0.0.1:6379> zrange ciudades 0 -1
1) "Mostoles"
2) "Alcorcon"
3) "Madrid"

Transacciones
¿Qué es una transacción?
Una transacción permite la ejecución segura de una serie de
comandos en la base de datos, con la posibilidad de revertir esa
ejecución en caso de algún error o problema, y retornar al estado
anterior de la transacción.
Cuando se comienza una transacción, se bloquea cualquier cambio
en la base de datos. Los comandos que se ejecutan se evalúan para
verificar si hay algún error o no.
Para iniciar una transacción, usaremos el comando multi:
# 127.0.0.1:6379> multi
OK

Transacciones
Ejecutar una transacción
Una vez iniciada la transacción, los comandos que se ejecuten a
continuación quedarán encolados.
Durante la ejecución de los comandos identificaremos si hay algún
problema. En el caso de que todo vaya bien, ejecutaremos la
transacción con el comando exec:
# 127.0.0.1:6379> multi
OK
QUEUED
# 127.0.0.1:6379> set apellido Hernamperez
QUEUED
# 127.0.0.1:6379> keys *
QUEUED
# 127.0.0.1:6379> exec
1) OK
2) OK
3) 1) "nombre"
2) "apellido"
--- NOTAS ---
Durante el bloqueo, los
comandos se encolan pero
no realizan cambios reales
en la base de datos.
Cuando se ejecutan, los
comandos se ejecutan,
abordando los cambios
que tenían programados.

Transacciones
Cancelar una transacción
Si durante la ejecución de los comandos identificamos algún
problema, podemos cancelar la transacción con el comando
discard:
# 127.0.0.1:6379> multi
OK
QUEUED
# 127.0.0.1:6379> set apellido Hernamperez
QUEUED
# 127.0.0.1:6379> keys *
QUEUED
# 127.0.0.1:6379> discard
OK
# 127.0.0.1:6379> keys *
(empty list or set)
--- NOTAS ---
Durante el bloqueo, los
comandos se encolan pero
no realizan cambios reales
en la base de datos.
Cuando se cancela la
transacción, no se ejecuta
ningún comando encolado,
por lo que retorna al estado
anterior a la transacción.

Transacciones
Transacciones condicionales
El comando watch observa determinadas claves durante un proceso
de transacción. Al llegar al comando exec, éste se ejecutará
solamente si ninguna de esas claves fue modificada:
WATCH clave
variable = GET clave
variable = variable + 3
MULTI
SET clave $variable
EXEC --- NOTAS ---
Más información:
https://redis.io/topics/tran
sactions
(*) Lo anterior es un pseudocódigo para ilustrar el funcionamiento de WATCH

Cliente REDIS en NodeJS
Instalación del paquete
Un cliente es, comúnmente, una librería para un determinado lenguaje
de programación, para acceder a una base de datos REDIS y para
ejecutar comandos que realicen operaciones sobre ésta.
Existen clientes REDIS para unos 50 lenguajes de programación.
https://redis.io/clients
El cliente recomendado para NodeJS se encuentra en esta URL:
https://www.npmjs.com/package/redis
Para instalar el cliente recomendado para NodeJS:
$ npm install redis
--- NOTAS ---
El proyecto de este cliente
se encuentra en la siguiente
URL:
https://github.com/Node
Redis/node_redis

Conectando con la base de datos
En primer lugar, hay que importar la librería del cliente en el programa:
let redis = require("redis");
A continuación, conectamos con la base de datos creando un cliente:
client = redis.createClient(<puerto>, <host> [,{auth_pass: <contraseña>}]);
--- NOTAS ---
El cliente de REDIS posee
multitud de opciones para
realizar la conexión.
Consultar:
https://www.npmjs.com/
package/redis
para más información
Es recomendable registrar el siguiente evento para controlar cualquier
posible error futuro que se produzca mientras se utiliza el cliente:
client.on("error", function(err) {
// Código a tratar error
console.log(`*** Error: ${err}`);
}

Ejecutando comandos de REDIS
Una vez tenemos instanciado el cliente, se pueden ejecutar los
comandos de REDIS:
client.set("clave", "valor", redis.print);
--- NOTAS ---
Se pueden ejecutar los
métodos del cliente usando
funciones callback, como
en el caso de get, con lo
que se puede tener un
mayor control de la
ejecución, pero si hay
múltiples comandos, estos
deben anidarse en cada
callback y es un “infierno”.
Para comandos que retornen algún resultado hay que trabajar con
callbacks:
client.get("clave", function(err, result) {
if (err) {
// err contendrá el resultado en caso de error
} else {
// result contendrá el resultado en caso de éxito
}
});
Los métodos del cliente de node se ejecutarán en modo asíncrono, es
decir, que se crearán hilos concurrentes por cada método que se
ejecute, por lo que la sincronización de éstos resultará en una
incertidumbre.

Ejecutando comandos de REDIS en modo síncrono
La mejor manera de controlar y sincronizar la ejecución de los
comandos es mediante promesas.
Para trabajar en modo síncrono, debemos generar los métodos
síncronos “promisificando” éstos mediante la librería bluebird:
let bluebird = require("bluebird");
bluebird.promisifyAll(redis);
Se creará una copia de los métodos originales añadiéndoles el sufijo
“Async”:
return client.getAsync("clave").then(result => {
// result contendrá el resultado en caso de éxito
}).catch(error => {
// error contendrá el resultado en caso de error
});

Envío de comandos directamente al servidor REDIS
El cliente REDIS posee un método para cada comando, y para cada
uno tiene una sintaxis particular de parámetros.
Mediante el método sendCommand() podemos enviar métodos
directos como si fuese en la línea de comandos de redis-cli. La
sintaxis es la siguiente:
client.sendCommand("<comando>", [param1 [,param2 [,param3 [,...]]]]);
Ejemplo:
return await this.redisClient.sendCommandAsync('linsert', [key, 'BEFORE',
element, newElement]);

Cerrar el cliente REDIS
--- NOTAS ---
Si no se cierra la conexión,
el resultado podría ser
parecido a un bloqueo
indefinido.
El cliente REDIS deja abierta la conexión con la base de datos en un
único hilo, el cual quedará abierto hasta que la conexión se cierre. Si
no se cierra, el hilo quedará indefinidamente abierto.
Para cerrar la conexión usaremos el método quit():
client.quit();

GUIs para REDIS
Redis Commander
Redis Commander es una GUI que se instala desde npm.
--- NOTAS ---
GUI = Graphical User
Interface (interfaz gráfica
de usuario)
Página oficial de Redis
Commander:
https://www.npmjs.com/
package/redis-
commander
$ npm install –g redis-commander
$ redis-commander
http://localhost:8081

GUIs para REDIS
Redismin
Redsmin es una GUI completa online para trabajar con REDIS. El plan
gratuito permite administrar y gestionar una única base de datos
REDIS, incluso si se trata de Azure Cache REDIS.
--- NOTAS ---
Página oficial de Redsmin:
https://www.redsmin.com

GUIs para REDIS
RDB Tools
RDB Tools es un GUI completo que se instala en el ordenador, con
una interfaz muy completa y en la que se pueden obtener
estadísticas de uso y se puede utilizar streaming de datos:
--- NOTAS ---
Página oficial de RDB Tools:
https://rdbtools.com/

REDIS en remoto
Azure CACHE REDIS
Microsoft Azure proporciona un servicio en cloud de Azure, llamado
Microsoft Azure Cache REDIS.
La cadena de conexión proporcionada es similar a la siguiente:
<base_datos>.redis.cache.windows.net:6380,password=<contraseña>,ssl=True,ab
ortConnect=False
Para crear la conexión, utilizaríamos la siguiente sintaxis:
let redis = require("redis");
client = redis.createClient(6380, "<base_datos>.redis.cache.windows.net",
{ auth_pass: "<contraseña>" } );

REDIS en remoto
Configuración de Redsmin con Azure Cache REDIS
Para configurar una base de datos REDIS sin SSL:
• Redis Server Name:
• Nombre de la conexión (el que queramos)
• Where is located the Redis Server you would like to connect to?:
• Redis server is exposed to internet
• Connection string:
• redis://<contraseña>@<host>:6379
Para configurar una base de datos REDIS con SSL:
• Redis Server Name:
• Nombre de la conexión (el que queramos)
• Where is located the Redis Server you would like to connect to?:
• Redis server is exposed to internet
• Connection string:
• redis://<contraseña>@<host>:6380
• Certificate’s public key:
• Pegar el certificado en formato PEM, incluida cabecera y pie
--- NOTAS ---
Más información sobre
certificado digital:
https://redsmin.uservoice.c
om/knowledgebase/article
s/485711-how-to-connect-
redsmin-to-azure-redis-
cache

Indice
• Strings y uso de claves
• Listas
• Conjuntos
• Hashes
• Geoespacial
• Transacciones
• REDIS en remoto
• Anexo

Anexo
JSON en REDIS
REDIS, originalmente, no trabaja con JSON, salvo que éste se
represente dentro de un string o se instale un módulo especial.
Existe una imagen en Docker que ya incorpora redis-json:
--- NOTAS ---
Más información:
https://oss.redislabs.com/r
edisjson/
$ docker run -p 6379:6379 --name redis-redisjson redislabs/rejson:latest
Si hemos instalado el servidor de Redis en la máquina, podemos
descargar el código fuente del módulo, compilarlo, copiar el archivo
resultante en una carpeta y arrancar el servidor cargando el módulo.
Por ejemplo:
$ redis-server --loadmodule /path/to/module/rejson.so
El código fuente de redis-json se encuentra en este repositorio:
https://github.com/RedisJSON/RedisJSON

Anexo
Enlaces de interés
• REDIS: Página oficial: https://redis.io
• REDIS: Comandos: https://redis.io/commands
• REDIS: Clientes: https://redis.io/clients
• REDIS: Documentación: https://redis.io/documentation
• REDIS: Módulos: https://redis.io/modules
• REDIS: Descargas: https://redis.io/download
• REDIS: Conectores (ODBC, JDBC, Spark…): https://redislabs.com/redis-enterprise/connectors/
• REDIS: Repositorio de proyectos: https://github.com/RedisLabs
• REDIS Labs: Soluciones profesionales: https://redislabs.com
• Tutorial y prueba online: https://try.redis.io/
• Azure Cache for Redis: https://azure.microsoft.com/es-es/services/cache/
• AWS Redis: https://aws.amazon.com/es/redis/

Anexo
Libros
• Mastering Redis: https://www.amazon.es/Mastering-Redis-Jeremy-Nelson-ebook/dp/B019H21REE
• The Little Redis Book: https://www.openmymind.net/redis.pdf
• Redis in action: https://redislabs.com/redis-in-action
• Learning Redis: https://riptutorial.com/es/ebook/redis

Anexo
Libros
• Redis: The definitive guide: https://www.amazon.com/Redis-Definitive-modeling-caching-
messaging/dp/1449396097
• The Little Redis Book (castellano): https://www.raulexposito.com/assets/pdf/redis.pdf
• Redis for dummies: https://redislabs.com/redis-for-dummies/
• Redis Cookbook: https://www.amazon.es/Redis-Cookbook-Tiago-Macedo/dp/1449305040

Formación IT
MUCHAS GRACIAS
2019 por Rafael Hernampérez

Curso gratuito de Redis

Más contenido relacionado

La actualidad más candente

Similar a Curso gratuito de Redis

Último

Curso gratuito de Redis