LABORATORIO: REDIS

Redis, que significa Remote Dictionary Server (servidor de diccionarios remoto), es un rápido almacén de
datos clave-valor en memoria de código abierto que se puede utilizar como base de datos, caché, agente de
mensajes y cola. El proyecto se inició cuando Salvatore Sanfilippo, el desarrollador original de Redis, trataba
de mejorar la escalabilidad de su startup italiana.

Redis ofrece ahora tiempos de respuesta inferiores al milisegundo, lo que permite que se realicen millones
de solicitudes por segundo para aplicaciones en tiempo real de videojuegos, tecnología publicitaria, servicios
financieros, sanidad e IoT. Redis es una opción muy habitual en aplicaciones de almacenamiento en caché,
administración de sesiones, videojuegos, tablas de clasificación, análisis en tiempo real, datos geoespaciales,
servicios de vehículos compartidos, chat/mensajería, streaming de contenido multimedia y
publicación/suscripción.

¿Cómo funciona Redis?

Todos los datos de Redis residen en la memoria, a diferencia de las bases de datos que almacenan datos en
discos o SSD. Como no hay ninguna necesidad de obtener acceso al disco, los almacenes de datos en
memoria, como Redis, evitan los retrasos y pueden obtener acceso a los datos en cuestión de milisegundos.
Redis incluye estructuras de datos versátiles, alta disponibilidad, datos geoespaciales, scripts Lua,
transacciones, persistencia en disco y soporte de clúster, lo que simplifica la creación de aplicaciones a escala
de Internet en tiempo real.

Estructuras de datos flexibles

A diferencia de los almacenes de datos de clave valor simplistas que ofrecen estructuras de datos limitadas,
Redis cuenta con una amplia variedad de estructuras de datos para satisfacer los requisitos de sus
aplicaciones. Los tipos de datos de Redis incluyen:

 Cadenas: datos de texto o binarios de hasta 512 MB de tamaño

 Listas: una colección de cadenas en el orden en que se agregaron

 Conjuntos: una colección desordenada de cadenas con la capacidad para intercalarse, unirse y
diferenciarse de otros tipos de conjuntos

 Conjuntos ordenados: conjuntos ordenados por un valor

 Hashes: una estructura de datos para almacenar una lista de campos y valores

 Mapas de bits: un tipo de datos que ofrece operaciones a nivel de bits

 HyperLogLogs: una estructura de datos probabilísticos para estimar los elementos únicos en un
conjunto de datos

Replicación y persistencia

Redis utiliza una arquitectura con servidor principal y réplica y admite la replicación asíncrona en la que los
datos se replican en numerosos servidores de réplicas. De este modo, se logra un mejor nivel de rendimiento
de lectura (ya que las solicitudes se pueden repartir entre varios servidores) y menores tiempos de
recuperación cuando el servidor principal sufre un corte. Por una cuestión de persistencia, Redis admite
copias de seguridad puntuales (copia el conjunto de datos Redis en el disco).

Beneficios

Excepcionalmente rápido: Redis es muy rápido y puede realizar aproximadamente 110000 SETS por segundo,
aproximadamente 81000 GETs por segundo.

Admite tipos de datos enriquecidos: Redis admite de forma nativa la mayoría de los tipos de datos que la
mayoría de los desarrolladores ya conocen como lista, conjunto, conjunto ordenado, hashes. Esto hace que
sea muy fácil resolver una variedad de problemas porque sabemos qué problema puede manejarse mejor
por qué tipo de datos.

Las operaciones son atómicas: todas las operaciones de Redis son atómicas, lo que garantiza que si dos
clientes acceden simultáneamente al servidor de Redis obtendrán el valor actualizado.

Redis no garantiza que todas las escrituras se guarden en caso de un error grave, pero en el peor de los casos
solo se perderían unos segundos de datos. Recuerde que una memoria caché no está diseñada para actuar
como un origen de datos crítico o core de negocio y que es responsabilidad de las aplicaciones que usan la
memoria caché asegurarse de que los datos críticos se guardan correctamente en un almacén de datos
adecuado.
Agrupación en clústeres y replicación de Redis

Redis admite la replicación de maestro/subordinado para ayudar a garantizar la disponibilidad y mantener

el rendimiento. Las operaciones de escritura en un nodo maestro de Redis se replican a uno o varios nodos
subordinados. Las operaciones de lectura pueden ser atendidas por el maestro o cualquiera de los
subordinados.

En el caso de una partición de red, los subordinados pueden continuar sirviendo datos y luego volver a
sincronizar de manera transparente con el maestro cuando se restablece la conexión. Para obtener más
información, visite la página Replicación en el sitio web de Redis.

Redis también ofrece agrupación en clústeres, lo que le permite particionar los datos de manera
transparente en particiones entre servidores y distribuir la carga. Esta característica mejora la escalabilidad,
puesto que se pueden agregar nuevos servidores de Redis y se pueden volver a particionar los datos
conforme aumenta el tamaño de la caché.

Uso de la memoria Redis

Una caché de Redis tiene un tamaño limitado que depende de los recursos disponibles en el equipo host. Al
configurar un servidor de Redis, puede especificar la cantidad máxima de memoria que puede usar. También
puede configurar una clave en una caché de Redis para que tenga un tiempo de expiración, tras lo cual se
quita automáticamente de la caché. Esta característica puede ayudar a impedir que la caché en memoria se
rellene con datos obsoletos o antiguos.

Conforme se rellena la memoria, Redis puede expulsar automáticamente las claves y sus valores siguiendo
varias directivas. El valor predeterminado es LRU (menos usados recientemente), pero también puede
seleccionar otras directivas como expulsar las claves de manera aleatoria o desactivar completamente la
expulsión (en cuyo caso, los intentos de agregar elementos a la caché generarán error si se llena).

Lotes y transacciones de Redis

Redis habilita una aplicación cliente para que envíe una serie de operaciones que leer y escriben datos en la
memoria caché como una transacción atómica. Se tiene la garantía de que todos los comandos de la
transacción se ejecutan secuencialmente y de que ninguno de los comandos emitidos por otros clientes
simultáneos se entrelazará entre ellos.

Sin embargo, estas no son verdaderas transacciones como las realizaría una base de datos relacional. El
procesamiento de transacciones consta de dos fases: la primera es cuando los comandos se ponen en cola y
la segunda es cuando los comandos se ejecutan. Durante la fase de puesta en cola de comandos, el cliente
envía los comandos que componen la transacción. Si se produce algún tipo de error en este momento (por
ejemplo, un error de sintaxis o un número incorrecto de parámetros), Redis rechaza el procesamiento de
toda la transacción y la descarta.

Durante la fase de ejecución, Redis ejecuta cada comando en cola en secuencia. Si se produce un error de
un comando durante esta fase, Redis continuará con el siguiente comando en cola y no revertirá los efectos
de los comandos que ya se hayan ejecutado. Esta forma simplificada de transacción ayuda a mantener el
rendimiento y a evitar los problemas de rendimiento provocados por la contención.

Redis no implementa una forma de bloqueo optimista para ayudar a mantener la coherencia.
Seguridad de Redis

Redis se centra exclusivamente en ofrecer un acceso rápido a los datos y está diseñado para ejecutarse
dentro de un entorno de confianza al que solo puedan acceder los clientes de confianza. Redis admite un
modelo de seguridad limitada basado en la autenticación mediante contraseña. (Aunque es posible quitar la
autenticación completamente, no se recomienda).

Todos los clientes autenticados comparten la misma contraseña global y tienen acceso a los mismo recursos.
Si necesita una seguridad de inicio de sesión más completa, debe implementar su propia capa de seguridad
delante del servidor de Redis y todas las solicitudes de cliente deben pasar por esta capa adicional. Redis no
debe exponerse directamente a clientes que no sean de confianza o sin autenticar.

Puede restringir el acceso a los comandos deshabilitándolos o cambiándolos de nombre (y ofreciendo solo a
los clientes con privilegios los nuevos nombres).

Redis no admite directamente ninguna forma de cifrado de datos, por lo que toda la codificación debe
realizarse por las aplicaciones cliente. Además, Redis no proporciona ninguna forma de seguridad de
transporte. Si necesita proteger los datos que fluyen a través de la red, se recomienda implementar un proxy
SSL.

Creación de particiones de una caché en Redis

La creación de particiones de la memoria caché implica la división de la memoria caché en varios

equipos. Esta estructura le ofrece varias ventajas sobre el uso de un único servidor de caché, incluidos:

 La creación de una caché que es mucho mayor de lo que se puede almacenar en un servidor único.

 La distribución de datos entre servidores, mejorando la disponibilidad. Si se produce un error en un

servidor o deja de estar accesible, los datos que contiene dejan de estar disponibles, pero los datos
de los demás servidores siguen estando accesibles. En el caso de una caché, esto no es importante
porque los datos en caché son solo una copia temporal de los datos contenidos en una base de
datos. Los datos en caché en un servidor que deja de estar accesible se pueden almacenar en caché
en un servidor diferente.

 El reparto de la carga entre servidores, lo que mejora el rendimiento y la escalabilidad.

 La colocación geográfica de los datos cerca de los usuarios que acceden a ellos, lo que reduce la
latencia.

Para una memoria caché, la forma más común de crear particiones es mediante el particionamiento. En esta
estrategia, cada partición es una caché de Redis por derecho propio. Los datos se dirigen a una partición
específica mediante el uso de lógica de particionamiento, que puede usar una variedad de enfoques para
distribuir los datos.

Para implementar la creación de particiones en una caché de Redis, puede adoptar uno de los enfoques
siguientes:

 Enrutamiento de consultas del lado servidor. En esta técnica, una aplicación cliente envía una
solicitud a cualquiera de los servidores de Redis que componen la memoria caché (probablemente,
el servidor más cercano). Cada servidor Redis almacena metadatos que describen la partición que
contiene y también incluye información acerca de qué claves particiones se encuentran en otros
servidores. El servidor Redis examina la solicitud del cliente. Si se puede resolver localmente, realiza
la operación solicitada. De lo contrario, reenvía la solicitud al servidor apropiado.
  Creación de particiones del lado cliente. En este modelo, la aplicación cliente contiene lógica
(posiblemente en forma de una biblioteca) que enruta solicitudes al servidor de Redis adecuado.

 Creación de particiones asistida por proxy. En este esquema, las aplicaciones cliente envían
solicitudes a un servicio proxy intermediario que comprende cómo se particionan los datos y luego
enruta la solicitud al servidor de Redis adecuado.

REDIS - INSTALL

1. Download Redis for Windows:

https://github.com/dmajkic/redis/downloads

2. Extract all files:

3. Start Redis Server

4. Start Redis Client:

This will open a redis prompt, as shown below:

5. In the above prompt 127.0.0.1 is your machine's IP address and 6379 is port on which redis server
is running. Now type the PING command as shown below.

redis 127.0.0.1:6379> ping

PONG

This shows that you have successfully installed redis on your machine.

REDIS - CONFIGURATION

In Redis, there is a configuration file (redis.conf) available at the root directory of Redis. Although you can
get and set all Redis configurations by Redis CONFIG command.

Following is the basic syntax of Redis CONFIG command: CONFIG GET CONFIG_SETTING_NAME
6. To know the log level of Redis, type the command:

7. We can also update the loglevel by using the commando CONGIG SET:

8. Open the configuration file redis.conf and take a look at it:

9. To get all configuration settings, use * in place of CONFIG_SETTING_NAME

 REDIS - DATA TYPES

10. Redis supports 5 types of data types, which are described below:

Strings
Redis string is a sequence of bytes. Strings in Redis are binary safe, meaning they have a known length not
determined by any special terminating characters, so you can store anything up to 512 megabytes in one
string.

redis 127.0.0.1:6379> SET name "StringTest2020"

OK
redis 127.0.0.1:6379> GET name
"StringTest2020"
In the above example SET and GET are redis commands, name is the key used in redis and
StringTest2020 is the string value that is stored in redis.

11. Hashes Datatype: A Redis hash is a collection of key value pairs. Redis Hashes are maps between
string fields and string values, so they are used to represent objects

Redis 127.0.0.1:6379>HMSET user:1 username tutor Alex password

Alex123 points 200
OK
redis 127.0.0.1:6379> HGETALL user:1

In the above example hash data type is used to store user's object which contains basic information of user.
Here HMSET, HEGTALL are commands for redis while user:1 is the key.

12. Lists Datatype: Redis Lists are simply lists of strings, sorted by insertion order. You can add elements
to a Redis

List on the head or on the tail.

redis 127.0.0.1:6379> lpush tutoriallist redis

(integer) 1
redis 127.0.0.1:6379> lpush tutoriallist mongodb
(integer) 2
redis 127.0.0.1:6379> lpush tutoriallist cassandra
(integer) 3
redis 127.0.0.1:6379> lpush tutoriallist mariadb
(integer) 4
redis 127.0.0.1:6379> lpush tutoriallist hbase
(integer) 5
redis 127.0.0.1:6379> lpush tutoriallist aurora
(integer) 6
redis 127.0.0.1:6379> lrange tutoriallist 0 10
 lrange tutoriallist 0 3

The max length of a list is 232 - 1 elements (4294967295, more than 4 billion of elements per list).

13. Sets Datatype: Redis Sets are an unordered collection of strings. In Redis, you can add, remove, and test for
the existence of members in O(1) time complexity.

redis 127.0.0.1:6379> sadd listcourses redis

(integer) 1
redis 127.0.0.1:6379> sadd listcourses mongodb
(integer) 1
redis 127.0.0.1:6379> sadd listcourses rabitmq
(integer) 1
redis 127.0.0.1:6379> sadd listcourses rabitmq
(integer) 0
redis 127.0.0.1:6379> smembers listcourses
1) "rabitmq"
2) "mongodb"
3) "redis"

Note − In the above example, rabitmq is added twice, however due to unique property of
the set, it is added only once.
The max number of members in a set is 2 32 - 1 (4294967295, more than 4 billion of
members per set).

14. Sorted Datatype: Redis Sorted Sets are similar to Redis Sets, non-repeating
collections of Strings. The difference is, every member of a Sorted Set is associated
with a score, that is used in order to take the sorted set ordered, from the smallest
to the greatest score. While members are unique, the scores may be repeated.

redis 127.0.0.1:6379> zadd mylist 0 redis

(integer) 1
redis 127.0.0.1:6379> zadd mylist 2 mongodb
(integer) 1
redis 127.0.0.1:6379> zadd mylist 1 rabitmq
(integer) 1
redis 127.0.0.1:6379> zadd mylist 1 rabitmq
(integer) 0
redis 127.0.0.1:6379> ZRANGEBYSCORE mylist 0 1000
 Redis – Keys

15. Redis keys commands are used for managing keys in Redis. Following is the syntax for using
redis keys commands.
Syntax: COMMAND KEY_NAME

redis 127.0.0.1:6379> SET example rediscourse

OK
redis 127.0.0.1:6379> DEL example
(integer) 1

In the above example, DEL is the command, while example is the key. If the key is deleted, then
the output of the command will be (integer) 1, otherwise it will be (integer) 0.

Redis Keys Commands

Following table lists some basic commands related to keys.

Sr.No Command & Description

1 DEL key

This command deletes the key, if it exists.

2 DUMP key

This command returns a serialized version of the value stored at the specified key.

3 EXISTS key

This command checks whether the key exists or not.

4 EXPIRE key seconds

Sets the expiry of the key after the specified time.

5 EXPIREAT key timestamp

Sets the expiry of the key after the specified time. Here time is in Unix timestamp format.

6 PEXPIRE key milliseconds

Set the expiry of key in milliseconds.

7 PEXPIREAT key milliseconds-timestamp

Sets the expiry of the key in Unix timestamp specified as milliseconds.

8 KEYS pattern

Finds all keys matching the specified pattern.

9 MOVE key db

Moves a key to another database.

10 PERSIST key

Removes the expiration from the key.

11 PTTL key

Gets the remaining time in keys expiry in milliseconds.

12 TTL key

Gets the remaining time in keys expiry.

13 RANDOMKEY

Returns a random key from Redis.

14 RENAME key newkey

Changes the key name.

 15 RENAMENX key newkey

Renames the key, if a new key doesn't exist.

16 TYPE key

Returns the data type of the value stored in the key.

16. Renaming a key:

redis 127.0.0.1:6379> SET testing xyz

redis 127.0.0.1:6379> GET testing
redis 127.0.0.1:6379> RENAMENX testing testing2
redis 127.0.0.1:6379> GET testing
redis 127.0.0.1:6379> GET testing2

17. Gets the remaining time in keys expiry in milliseconds with PEXPIRE

redis 127.0.0.1:6379> EXPIRE testing2 30000

redis 127.0.0.1:6379> GET testing2

18. Wait some seconds a try again:

What happened?
 Redis – Strings commands

19. Redis strings commands are used for managing string values in Redis. Following is the syntax
for using Redis string commands.

Syntax: COMMAND KEY_NAME

Redis Strings Commands

Following table lists some basic commands to manage strings in Redis.

Sr.No Command & Description

1 SET key value

This command sets the value at the specified key.

2 GET key

Gets the value of a key.

3 GETRANGE key start end

Gets a substring of the string stored at a key.

4 GETSET key value

Sets the string value of a key and return its old value.

5 GETBIT key offset

Returns the bit value at the offset in the string value stored at the key.

6 MGET key1 [key2..]

Gets the values of all the given keys

7 SETBIT key offset value

Sets or clears the bit at the offset in the string value stored at the key

8 SETEX key seconds value

Sets the value with the expiry of a key

9 SETNX key value

Sets the value of a key, only if the key does not exist

10 SETRANGE key offset value

Overwrites the part of a string at the key starting at the specified offset

11 STRLEN key

Gets the length of the value stored in a key

12 MSET key value [key value ...]

Sets multiple keys to multiple values

13 MSETNX key value [key value ...]

Sets multiple keys to multiple values, only if none of the keys exist

14 PSETEX key milliseconds value

Sets the value and expiration in milliseconds of a key

15 INCR key

Increments the integer value of a key by one

16 INCRBY key increment

Increments the integer value of a key by the given amount

17 INCRBYFLOAT key increment

Increments the float value of a key by the given amount

18 DECR key

Decrements the integer value of a key by one

19 DECRBY key decrement

Decrements the integer value of a key by the given number

20 APPEND key value

Appends a value to a key

20. Using APPEND on STRINGS:

redis 127.0.0.1:6379> SET country Panama

OK
redis 127.0.0.1:6379> get country
"Panama"
redis 127.0.0.1:6379> APPEND country Ecuador
(integer) 13
redis 127.0.0.1:6379> get country
"PanamaEcuador"
redis 127.0.0.1:6379>

Redis - Hashes

21. Redis Hashes are maps between the string fields and the string values. Hence, they
are the perfect data type to represent objects. In Redis, every hash can store up to
more than 4 billion field-value pairs.

Redis Hash Commands

Following table lists some basic commands related to hash.

Sr.No Command & Description

1 HDEL key field2 [field2]

Deletes one or more hash fields.

2 HEXISTS key field

Determines whether a hash field exists or not.

3 HGET key field

Gets the value of a hash field stored at the specified key.

4 HGETALL key

Gets all the fields and values stored in a hash at the specified key

5 HINCRBY key field increment

Increments the integer value of a hash field by the given number

6 HINCRBYFLOAT key field increment

Increments the float value of a hash field by the given amount

7 HKEYS key

Gets all the fields in a hash

8 HLEN key

Gets the number of fields in a hash

9 HMGET key field1 [field2]

Gets the values of all the given hash fields

10 HMSET key field1 value1 [field2 value2 ]

Sets multiple hash fields to multiple values

11 HSET key field value

Sets the string value of a hash field

12 HSETNX key field value

Sets the value of a hash field, only if the field does not exist

13 HVALS key

Gets all the values in a hash

14 HSCAN key cursor [MATCH pattern] [COUNT count]

Incrementally iterates hash fields and associated values

 22. Now, we will test with the HASH data type:

redis 127.0.0.1:6379> hset hash-key sub-key1 value1

(integer) 1
redis 127.0.0.1:6379> hset hash-key sub-key2 value2
(integer) 1
redis 127.0.0.1:6379> hset hash-key sub-key1 value1
(integer) 0

When we add items to a hash, again we get a return value that tells whether the item is
new in the hash.

redis 127.0.0.1:6379> hgetall hash-key

1) "sub-key1"
2) "value1"
3) "sub-key2"
4) "value2"

We can fetch all of the items in the HASH, which gets translated into a dictionary on the
Python side of things.

redis 127.0.0.1:6379> hdel hash-key sub-key2

(integer) 1
redis 127.0.0.1:6379> hdel hash-key sub-key2
(integer) 0

When we delete items from the hash, the command returns whether the item was there
before we tried to remove it.

redis 127.0.0.1:6379> hget hash-key sub-key1

"value1"
We can also fetch individual fields from hashes.
redis 127.0.0.1:6379> hgetall hash-key
1) "sub-key1"
2) "value1"

23. In the following example, poet:Verlaine is the hash key. Dots, dashes, and colons
are commonly used to make multi-word keys and fields more readable. It’s helpful
to make sure that your keys follow a consistent and easily readable format.

hset poet:Verlaine nationality French

Also, note that hset will overwrite the contents of the hash if it already exists:
hset poet:Verlaine nationality Francais
If the field already exists and its value was updated successfully, hset will return (integer)
0:
Output
(integer) 0
You can also use hsetnx to add fields to hashes, but it will only work if the field does not
yet exist. If the specified field does already exist, the hsetnx won’t have any effect and will
return (integer) 0:

hsetnx poet:Verlaine nationality French

Output

(integer) 0

Redis – Lists

24. Redis Lists are simply lists of strings, sorted by insertion order. You can add
elements in Redis lists in the head or the tail of the list. Maximum length of a list is
232 - 1 elements (4294967295, more than 4 billion of elements per list).

In the above example, three values are inserted in Redis list named ‘tutorials’ by the
command LPUSH.

Redis Lists Commands

Following table lists some basic commands related to lists.

Sr.No Command & Description

1 BLPOP key1 [key2 ] timeout

Removes and gets the first element in a list, or blocks until one is available

2 BRPOP key1 [key2 ] timeout

Removes and gets the last element in a list, or blocks until one is available

3 BRPOPLPUSH source destination timeout

Pops a value from a list, pushes it to another list and returns it; or blocks until one is
available
4 LINDEX key index

Gets an element from a list by its index

5 LINSERT key BEFORE|AFTER pivot value

Inserts an element before or after another element in a list

6 LLEN key

Gets the length of a list

7 LPOP key

Removes and gets the first element in a list

8 LPUSH key value1 [value2]

Prepends one or multiple values to a list

9 LPUSHX key value

Prepends a value to a list, only if the list exists

10 LRANGE key start stop

Gets a range of elements from a list

11 LREM key count value

Removes elements from a list

12 LSET key index value

Sets the value of an element in a list by its index

13 LTRIM key start stop

Trims a list to the specified range

14 RPOP key

Removes and gets the last element in a list

15 RPOPLPUSH source destination

Removes the last element in a list, appends it to another list and returns it

16 RPUSH key value1 [value2]

Appends one or multiple values to a list

17 RPUSHX key value

 Appends a value to a list, only if the list exists

25. A key can only hold one list, although any list can hold over four billion elements. Redis
reads lists from left to right, and you can add new list elements to the head of a list (the
“left” end) with the lpush command or the tail (the “right” end) with rpush. You can also
use lpush or rpush to create a new list:

lpush key_philosophy1 "therefore"

lpush key_philosophy1 "think"

rpush key_philosophy1 "I"

lpush key_philosophy1 "I"

rpush key_philosophy1 "am"

26. The lpushx and rpushx commands are also used to add elements to lists, but will only work
if the given list already exists. If either command fails, it will return (integer) 0:

rpush key_philosophy1 "Decartes"

27. To retrieve a range of items in a list, use the lrange command followed by a start offset and
a stop offset. Each offset is a zero-based index, meaning that 0 represents the first element
in the list, 1 represents the next, and so on.

The following command will return all the elements from the example list created in the
previous section:

lrange key_philosophy1 0 7
 Redis - Sets

28. Redis Sets are an unordered collection of unique strings. Unique means sets does
not allow repetition of data in a key.
In Redis set add, remove, and test for the existence of members in O(1) (constant time
regardless of the number of elements contained inside the Set). The maximum length of a
list is 232 - 1 elements (4294967295, more than 4 billion of elements per set).

Redis Sets Commands

Following table lists some basic commands related to sets.

Sr.No Command & Description

1 SADD key member1 [member2]

Adds one or more members to a set

2 SCARD key

Gets the number of members in a set

3 SDIFF key1 [key2]

Subtracts multiple sets

4 SDIFFSTORE destination key1 [key2]

Subtracts multiple sets and stores the resulting set in a key

5 SINTER key1 [key2]

Intersects multiple sets

6 SINTERSTORE destination key1 [key2]

Intersects multiple sets and stores the resulting set in a key

7 SISMEMBER key member

Determines if a given value is a member of a set

 8 SMEMBERS key

Gets all the members in a set

9 SMOVE source destination member

Moves a member from one set to another

10 SPOP key

Removes and returns a random member from a set

11 SRANDMEMBER key [count]

Gets one or multiple random members from a set

12 SREM key member1 [member2]

Removes one or more members from a set

13 SUNION key1 [key2]

Adds multiple sets

14 SUNIONSTORE destination key1 [key2]

Adds multiple sets and stores the resulting set in a key

15 SSCAN key cursor [MATCH pattern] [COUNT count]

Incrementally iterates set elements

Redis – HyperLogLog

29. Redis HyperLogLog is an algorithm that uses randomization in order to provide an

approximation of the number of unique elements in a set using just a constant, and
small amount of memory.
HyperLogLog provides a very good approximation of the cardinality of a set even
using a very small amount of memory around 12 kbytes per key with a standard error
of 0.81%. There is no limit to the number of items you can count, unless you
approach 264 items.

Following example explains how Redis HyperLogLog works. The demo version that is
being used for the laboratory does not support this algorithm.
redis 127.0.0.1:6379> PFADD tutorials "redis"
1) (integer) 1
redis 127.0.0.1:6379> PFADD tutorials "mongodb"
1) (integer) 1
redis 127.0.0.1:6379> PFADD tutorials "mysql"
1) (integer) 1
redis 127.0.0.1:6379> PFCOUNT tutorials
(integer) 3

Redis - Publish Subscribe

30. Redis Pub/Sub implements the messaging system where the senders (in redis terminology
called publishers) sends the messages while the receivers (subscribers) receive them. The
link by which the messages are transferred is called channel.
In Redis, a client can subscribe any number of channels. Following example explains how
publish subscriber concept works. In the following example, one client subscribes a channel
named ‘redisChat’.

redis 127.0.0.1:6379> SUBSCRIBE redisChat

Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "redisChat"
3) (integer) 1

31. Open a new Redis Client terminal. Now, two clients are publishing the messages on
the same channel named ‘redisChat’ and the above subscribed client is receiving
messages.

redis 127.0.0.1:6379> PUBLISH redisChat "Redis is a great caching

technique"
(integer) 1
redis 127.0.0.1:6379> PUBLISH redisChat "Learn redis by tutorials
point"
(integer) 1
1) "message"
2) "redisChat"
3) "Redis is a great caching technique"
1) "message"
2) "redisChat"
3) "Learn redis by tutorials point"

Redis - Connections

Redis connection commands are basically used to manage client connections with Redis
server.

Following table lists some basic commands related to Redis connections.

Sr.No Command & Description

1 AUTH password

Authenticates to the server with the given password

2 ECHO message

Prints the given string

3 PING

Checks whether the server is running or not

4 QUIT

Closes the current connection

5 SELECT index
 Changes the selected database for the current connection

Redis – Server

32. Redis server commands are basically used to manage Redis server.

Following example explains how we can get all statistics and information about the server.
redis 127.0.0.1:6379> INFO

# Server
redis_version:2.8.13
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:c2238b38b1edb0e2
redis_mode:standalone
os:Linux 3.5.0-48-generic x86_64
arch_bits:64
multiplexing_api:epoll
gcc_version:4.7.2
process_id:3856
run_id:0e61abd297771de3fe812a3c21027732ac9f41fe
tcp_port:6379
uptime_in_seconds:11554
uptime_in_days:0 hz:10
lru_clock:16651447
config_file:

# Clients
connected_clients:1
client_longest_output_list:0
client_biggest_input_buf:0
blocked_clients:0

# Memory
used_memory:589016
used_memory_human:575.21K
used_memory_rss:2461696
used_memory_peak:667312
used_memory_peak_human:651.67K
used_memory_lua:33792
mem_fragmentation_ratio:4.18
mem_allocator:jemalloc-3.6.0
# Persistence
loading:0
rdb_changes_since_last_save:3
rdb_bgsave_in_progress:0
rdb_last_save_time:1409158561
rdb_last_bgsave_status:ok
rdb_last_bgsave_time_sec:0
rdb_current_bgsave_time_sec:-1
aof_enabled:0
aof_rewrite_in_progress:0
aof_rewrite_scheduled:0
aof_last_rewrite_time_sec:-1
aof_current_rewrite_time_sec:-1
aof_last_bgrewrite_status:ok
aof_last_write_status:ok

# Stats
total_connections_received:24
total_commands_processed:294
instantaneous_ops_per_sec:0
rejected_connections:0
sync_full:0
sync_partial_ok:0
sync_partial_err:0
expired_keys:0
evicted_keys:0
keyspace_hits:41
keyspace_misses:82
pubsub_channels:0
pubsub_patterns:0
latest_fork_usec:264

# Replication
role:master
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

# CPU
used_cpu_sys:10.49
used_cpu_user:4.96
used_cpu_sys_children:0.00
used_cpu_user_children:0.01

# Keyspace
db0:keys = 94,expires = 1,avg_ttl = 41638810
db1:keys = 1,expires = 0,avg_ttl = 0
db3:keys = 1,expires = 0,avg_ttl = 0
 Redis – Backup

33. Redis SAVE command is used to create a backup of the current Redis database.

Following is the basic syntax of redis SAVE command.

127.0.0.1:6379> SAVE

This command will create a dump.rdb file in your Redis directory. To restore Redis data,
move Redis backup file (dump.rdb) into your Redis directory and start the server. To get
your Redis directory, use CONFIG command of Redis as shown below.

Redis – Security

34. Redis database can be secured, such that any client making a connection needs to
authenticate before executing a command. To secure Redis, you need to set the
password in the config file.

Following example shows the steps to secure your Redis instance.

127.0.0.1:6379> CONFIG get requirepass
1) "requirepass"
2) ""

By default, this property is blank, which means no password is set for this instance. You
can change this property by executing the following command.
127.0.0.1:6379> CONFIG set requirepass "mypassword"
OK

After setting the password, if any client runs the command without authentication,
then (error) NOAUTH Authentication required. error will return. Hence, the client needs
to use AUTH command to authenticate himself.

127.0.0.1:6379> AUTH "mypassword"

OK
127.0.0.1:6379> SET mykey "Test value"
OK
127.0.0.1:6379> GET mykey
"Test value"

CONGRATULATIONS!!! 