# Tutorial de Redis: introducción a la base de datos en memoria

El sistema de bases de datos [Redis](https://www.ionos.es/digitalguide/hosting/cuestiones-tecnicas/que-es-redis/) ha ido ganando en popularidad en los últimos años. Sus principales atractivos son la velocidad y la sencillez de la estructura de las bases de datos: los datos se introducen directamente en la memoria principal del servidor, de manera que se pueden recuperar de forma mucho más rápida que en otras bases de datos. Esto hace que se use a menudo como caché de páginas web, aunque los servicios de mensajería también la usan para lograr una comunicación más rápida. En nuestro tutorial de Redis, aprenderás a instalar tu propia base de datos Redis.

## Paso 1: instalar Redis

Redis es *open source*, es decir, de código abierto, así que cualquiera puede descargar, usar y editar el sistema.

Nota A continuación, describiremos cómo instalar y configurar Redis en Ubuntu, pero también puede hacerse en Mac y en Windows. Si por el momento solo quieres probar Redis sin instalarlo en tu ordenador, te recomendamos el entorno de prueba online [Try Redis](http://try.redis.io/ "Prueba Redis en su sitio oficial").

El primer paso consiste en **descargar Redis**. Para ello, usamos el gestor de paquetes de Ubuntu, que tendremos que actualizar primero a la versión más reciente.

```none
sudo apt-get update
sudo apt-get install redis-server
```

Otra manera de hacerlo es descargar los archivos desde la web oficial de Redis. Siguiendo este camino, sin embargo, hay que extraer los archivos del paquete manualmente, para luego instalarlos y, finalmente, iniciar Redis:

```none
redis-server
```

Para comprobar si Redis funciona correctamente, iniciamos la **interfaz** de comunicación con la base de datos:

```none
redis-cli
```

La interfaz debería mostrar entonces **la dirección IP y el puerto** a través del cual se ejecuta Redis, a los que se puede enviar un *ping* de comprobación.

```none
127.0.0.1:6397> ping
PONG
```

Si Redis responde, queda demostrado que **el sistema de bases de datos se ha instalado correctamente**. Ahora también se puede comprobar si se puede escribir texto.

```none
127.0.0.1:6397> set test "OK!"
127.0.0.1:6397> get test
"OK!"
```

Nota ¿Quieres intalar Redis en tu propio servidor? Los [servidores en la nube de IONOS](https://www.ionos.es/cloud/servidores-cloud "Servidores Cloud a partir de 5 € al mes – IONOS de 1&1") pueden escalarse también para proyectos pequeños.

## Paso 2: configurar Redis

Redis se instala, en un principio, con la **configuración estándar**, que luego puede modificarse con los comandos correspondientes.

```none
127.0.0.1:6397> config get *
```

En la lista de ajustes para la configuración, **las parejas de elementos se descomponen en dos posiciones**, una debajo de la otra: al elemento *dbfilename* le corresponde, entonces, el valor *dump.rdb*. El asterisco que hemos usado para abrir la lista actúa de marcador de posición para un ajuste determinado de la lista. Cuando solo se quiere examinar un ajuste, el asterisco se reemplaza por el nombre del elemento, utilizando siempre para ello el que se encuentra en primera posición, que es la llave para el valor de configuración correspondiente.

```none
127.0.0.1:6397> config get dbfilename
1) "dbfilename"
2) "dump.rdb"
```

Para cambiar una entrada en el archivo de configuración, se usa el **comando *set***. Puede usarse, por ejemplo, para definir una contraseña:

```none
127.0.0.1:6397> config set requirepass "password"
OK
```

Tras hacerlo, si solicitamos la contraseña con el comando ***get***, se nos pedirá que la introduzcamos nosotros primer, al fin y al cabo, por algo le hemos puesto una. Para introducirla, usamos el comando ***auth*** y, a continuación, consultamos la entrada en el archivo de configuración como acabamos de hacer.

```none
127.0.0.1:6397> auth "password"
127.0.0.1:6397> config get requirepass
1) "requirepass"
2) "password"
```

Nota Existen más formas de hacer más segura tu base de datos. En la página web oficial de Redis, los desarrolladores [resumen diversos puntos](https://redis.io/topics/security "Seguridad en Redis") al respecto.

En realidad, Redis guarda todos los datos en la memoria principal. Teniendo esto en cuenta, para lograr la persistencia de los datos, se puede **almacenar una copia (*snapchot*) de la base de datos en el disco duro**, que se ubicará en el archivo *dump.rdb*.

```none
127.0.0.1:6397> save
```

Con el comando ***save***, se crea manualmente una copia, pero también pueden programarse para que se realicen de forma automática.

```none
127.0.0.1:6397> save 60 10
```

En este ejemplo, hemos asignado dos parámetros al comando: ahora, se creará una copia cada 60 segundos si ya se han producido 10 cambios en dicho intervalo de tiempo.

Sin embargo, el comando *save* no se recomienda mientras el sistema esté en funcionamiento, ya que impide que los clientes accedan a la base de datos. En estos casos es más conveniente ***bgsave***, que realiza el proceso en un segundo plano.

Además de la posibilidad de hacer una copia de la base de datos, también existen el modo **append only file**, en el que Redis guarda en un archivo cada acción realizada. Gracias a este archivo, si el servidor se averiara inesperadamente, se podría averiguar qué fue lo último que se hizo. Para activar el modo AOF, debe modificarse el archivo de configuración.

```none
127.0.0.1:6397> config set appendonly yes
```

Consejo Si tus datos requieren la máxima seguridad, deberías activar el modo AOF y, además, hacer copias regulares de la base de datos: así será prácticamente imposible que pierdas tus datos. Estos procesos, no obstante, ralentizan en cierta medida el funcionamiento de la base de datos.

## Paso 3: crear entradas

Una vez hayas configurado Redis, ya puedes trabajar con la base de datos. Dispones para ello de varios tipos distintos de datos y de comandos.

### Strings

Lo más fácil es crear una *string*, es decir, una cadena o secuencia de elementos. Para ello, utiliza el **comando *set***.

Nota No importa si se introducen los valores entre comillas o no. Para hacer el código más legible, puede ponerse el texto entre comillas y los valores numéricos sin ellas.

```none
127.0.0.1:6397> set foo "bar"
127.0.0.1:6397> set value 1
```

Si se solicitan ahora las entradas *foo* y *value* mediante el comando ***get***, se mostrarán los valores correspondientes.

```none
127.0.0.1:6397> get foo
"bar"
127.0.0.1:6397> get value
"1"
```

El **comando** para borrar una entrada es ***del***.

```none
127.0.0.1:6397> del foo
(integer) 1
127.0.0.1:6397> get foo
(nil)
```

Si no quieres crear muchas entradas usando una fila nueva cada vez, puedes usar la función avanzada ***mset***. Para solicitar los valores de varios campos a la vez, también existe el comando ***mget***.

```none
127.0.0.1:6397> mset foo1 "bar1" foo2 "bar2" foo3 "bar3"
OK
127.0.0.1:6397> mget foo1 foo2 foo3
1) "bar1"
2) "bar2"
3) "bar3"
```

### Listas

Con Redis se pueden usar, además, otros tipos de datos. Algunos de los más populares para trabajar con la base de datos son, por ejemplo, **las listas y los *sets***. Ambos son conjuntos de valores, pero, mientras que los *sets* no tienen un orden concreto, los valores de las listas están numerados. En una lista se pueden añadir, solicitar o borrar entradas.

```none
127.0.0.1:6397> lpush mylist foo
(integer) 1
127.0.0.1:6397> lpush mylist bar
(integer) 2
127.0.0.1:6397> lrange mylist 0 10
1) "foo"
2) "bar"
127.0.0.1:6397> linsert mylist before "bar" "test"
(integer) 3
127.0.0.1:6397> lrange mylist 0 10
1) "foo"
2) "test"
3) "bar"
127.0.0.1:6397> lrem mylist 0 foo
(integer) 1
127.0.0.1:6397> lrange mylist 0 10
1) "test"
2) "bar"
```

En este ejemplo hemos añadido en primer lugar dos elementos a una lista (***lpush***) y luego hemos solicitado que se muestren. Con el comando ***lrange*** se indica qué segmento debe mostrarse (aquí del 0 al 10, pero pueden usarse también números negativos). A continuación, mediante el comando ***linsert*** hemos añadido un valor nuevo delante de uno que ya existía (también podría usarse *after*), con lo cual hemos cambiado la numeración. El comando ***lrem*** permite borrar de la lista entradas con un valor específico.

### Sets

Para los *sets*, Redis utiliza otros comandos, pero con resultados muy similares:

```none
127.0.0.1:6397> sadd myset "foo"
(integer) 1
127.0.0.1:6397> sadd myset "bar"
(integer) 1
127.0.0.1:6397> smembers myset
1) "bar"
2) "foo"
127.0.0.1:6397> sismember myset "bar"
(integer) 1
127.0.0.1:6397> srem myset "bar"
(integer) 1
127.0.0.1:6397> smembers myset
1) "foo"
```

Con el comando ***sadd*** también se pueden integrar varios elementos en el *set* si se introducen en el comando uno detrás de otro. Para visualizar el *set*, basta con usar el comando ***smembers*** y el nombre del *set* en cuestión. El comando ***sismember*** permite, además, buscar una entrada concreta. De manera análoga a la lista, con ***srem*** se pueden borrar entradas sueltas.

Sin embargo, Redis también ofrece a los usuarios la posibilidad de utilizar ***sets* en un formato ordenado.**

```none
127.0.0.1:6397> zadd mysortedset 1 "foo"
(integer) 1
127.0.0.1:6397> zadd mysortedset 2 "bar"
(integer) 1
127.0.0.1:6397> zadd mysortedset 2 "foobar"
(integer) 1
127.0.0.1:6397> zrange mysortedset 0 10
1) "foo"
2) "bar"
3) "foobar"
```

Para añadir elementos se utiliza, en este caso, el comando ***zadd*** y un *score* o puntaje. Mientras que los valores propiamente dichos no pueden aparecer más de una vez, con un *score* se puede indicar un mismo valor varias veces. El *score* no es, por lo tanto, una numeración directa dentro del *set*, sino una ponderación, de manera que todas las entradas con el puntaje o *score 2* aparecerán tras los que tengan el *score 1*. Con el comando ***zrange*** se pueden visualizar todos los elementos o los que se seleccionen.

### Hashes

Un tipo especial de datos son los *hashes*: entradas individuales compuestas de varios valores, de manera similar a los *sets* y las listas, pero en los que cada valor va acompañado de una clave, formando así los llamados pares clave-valor o ***key-value***.

```none
127.0.0.1:6397> hset user1 name "bob" email "bob@example.com" password "rK87_x"
OK
127.0.0.1:6397> hget user1 name
1) "bob"
127.0.0.1:6397> hgetall user1
1) "name"
2) "bob"
3) "email"
4) "bob@example.com"
5) "password"
6) "rK87_x"
127.0.0.1:6397> hvals user1
1) "bob"
2) "bob@example.com"
3) "rK87_x"
127.0.0.1:6397> hkeys user1
1) "name"
2) "email"
3) "password"
> hdel user1 password
(integer) 1
127.0.0.1:6397> hgetall user1
1) "name"
2) "bob"
3) "email"
4) "bob@example.com"
127.0.0.1:6397> del user1
(integer) 1
127.0.0.1:6397> hgetall user1
(empty list or set)
```

En este ejemplo, hemos usado ***hset*** para crear un *hash* con el nombre *user1* y tres campos. Mediante el comando ***hget*** podemos solicitar el valor de cada campo. Para que se muestren todos, se puede usar ***hgetall***. Otras opciones para visualizar valores son ***hvals*** (muestra todos los valores guardados en el *hash*) y ***hkeys*** (muestra todas las claves guardadas en el *hash*). Con ***hdel*** se pueden borrar valores sueltos, mientras que con ***del***, como ya hemos visto, se borra el *hash* entero.

Nota El comando ***flushall*** sirve para borrar todas las entradas de la base de datos.

## Paso 4: otras opciones

Naturalmente, con Redis no solo se pueden crear entradas en una base de datos, sino que también pueden asignarse propiedades concretas a los datos. En este sentido, pueden resultar muy útiles, por ejemplo, los comandos de **incremento y decremento**.

```none
127.0.0.1:6397> set foo 1
OK
127.0.0.1:6397> get foo
"1"
127.0.0.1:6397> incr foo
(integer) 2
127.0.0.1:6397> incr foo
(integer) 3
127.0.0.1:6397> get foo
"3"
127.0.0.1:6397> decr foo
(integer) 2
127.0.0.1:6397> get foo
"2"
```

Con la ayuda de estas funciones, se pueden incrementar o reducir los valores en una unidad. A veces, en cambio, se quieren introducir valores que solo permanezcan en la base de datos durante cierto tiempo: para ello existe la función ***expire***.

```none
127.0.0.1:6397> set foo "bar"
OK
127.0.0.1:6397> expire foo 100
(integer) 1
127.0.0.1:6397> ttl foo
(integer) 50
127.0.0.1:6397> ttl foo
(integer) -50
127.0.0.1:6397> get foo
(nil)
```

El comando *expire* requiere una indicación de tiempo en segundos. En este ejemplo, hemos decidido que la entrada debe durar 100 segundos. Una vez transcurrida la mitad del tiempo, hemos usado el comando ***ttl*** para solicitar el *time-to-live*, es decir, el tiempo restante. Si esperamos aún más, el TTL pasará a ser negativo a partir del momento en el que la entrada ya haya desaparecido.

El comando ***setex*** permite asignar un TTL a una entrada de la base de datos ya desde su creación.

```none
127.0.0.1:6397> setex foo 100 "bar"
OK
```

Una vez se ha creado una entrada, esta se puede ampliar: el comando ***append*** añade otro valor al que ya existía.

```none
127.0.0.1:6397> set foo "Hello"
OK
127.0.0.1:6397> append foo " World"
(integer) 11
127.0.0.1:6397> get foo
"Hello World"
127.0.0.1:6397> set bar 5
OK
127.0.0.1:6397> append bar 10
(integer) 3
127.0.0.1:6397> get bar
"510"
```

Como se puede ver, al solicitar los valores correspondientes, aparecen los nuevos elementos **simplemente tras los que ya estaban**. Si la entrada en cuestión aún no existe, *append* realiza entonces la misma función que *set*.

Además, también se puede cambiar el nombre de las entradas usando el comando ***rename***.

```none
127.0.0.1:6397> set foo 100
OK
127.0.0.1:6397> rename foo bar
OK
127.0.0.1:6397> get foo
(nil)
127.0.0.1:6397> get bar
"100"
```

Consejo Existen muchos otros comandos para trabajar con Redis. En la descripción oficial se pueden consultar los detalles de [todos los comandos disponibles](https://redis.io/commands "Descripción de todos los comandos de Redis").


This is a markdown version of: [https://www.ionos.es/digitalguide/hosting/cuestiones-tecnicas/redis-tutorial-paso-a-paso/](https://www.ionos.es/digitalguide/hosting/cuestiones-tecnicas/redis-tutorial-paso-a-paso/) for AI/LLM consumption.