Skip to content

Redis

Redis is an open-source, in-memory data structure store that is used as a database, cache, and message broker. It supports a wide range of data structures, including strings, hashes, lists, sets, and sorted sets. Redis is known for its high performance and low latency, making it a popular choice for real-time applications.

Redis is also known for its rich set of features, including transactions, Lua scripting, pub/sub messaging, and persistence options. Redis can be used as a standalone server, or it can be used in a cluster for high availability and scalability.

Installing Redis using Docker

Docker is a popular containerization technology that allows you to run applications in isolated environments. Using Docker to install Redis is a convenient and easy way to get started with Redis.

To install Redis using Docker, follow these steps:

  • Install Docker on your system if it's not.
  • Open a terminal or command prompt and run the following command to pull the Redis image from Docker Hub: 
    docker pull redis
  • Once the Redis image is downloaded, you can start a Redis container using the following command: 
    docker run --name my-redis -d redis
    This command starts a Redis container with the name my-redis.
  • You can check if the Redis container is running by running the following command: 
    docker ps
    This command should display a list of running containers, including the Redis container that you just started.
  • To connect to the Redis container, you can use the redis-cli command. Run the following command to start a Redis CLI session: 
    docker exec -it my-redis redis-cli
    This command starts an interactive session with the Redis container and launches the Redis CLI.

Congratulations! You have now installed Redis using Docker and are ready to start working with Redis 🥳

Basic Redis Commands and Data Structures

Redis supports several data structures that can be used to store and manipulate data. These data structures include:

  • Strings: Strings in Redis can store text, numbers, or binary data up to 512 MB in size. They are the simplest and most versatile data type in Redis.
  • Hashes: Hashes in Redis are a collection of key-value pairs, similar to dictionaries in Python. They are particularly useful for storing objects with multiple fields.
  • Lists: Lists in Redis are ordered collections of elements, implemented as linked lists. They provide fast access to elements at the head and tail of the list, making them suitable for use as queues, stacks, or circular buffers.
  • Sets: Sets in Redis are unordered collections of unique elements. They support a wide range of set operations, such as union, intersection, and difference.
  • Sorted Sets: Sorted sets in Redis are similar to sets but with a score associated with each element. The elements are sorted based on their scores, allowing for fast access to elements based on their rank.

We will explore more in the next chapter.

CRUD operations

Let's explore the CRUD (Create, Read, Update, and Delete) operations in more detail for each Redis data type along with examples.

Strings

Create/Update

Set a string value to a key: 

SET username "JohnDoe"
Set a value with an expiration time (in seconds): 
SETEX session_key 3600 "session_data"

Read

Get the value of a key:

GET username

Get multiple values using multiple keys: 

MGET key1 key2 key3

Delete

Delete a key and its value: 

DEL username

Hashes

Create/Update

Set a field value in a hash: 

HSET user:1 name "Alice"
Set multiple field values in a hash: 
HMSET user:1 name "Alice" age 30 email "alice@example.com"

Read

Get the value of a field in a hash: 

HGET user:1 name
Get multiple field values in a hash: 
HMGET user:1 name age email
Get all the fields and values in a hash: 
HGETALL user:1

Delete

Delete a field from a hash: 

HDEL user:1 email

Lists

Create/Update

Add elements to the head (left) of a list: 

LPUSH fruits "apple" "banana"
Add elements to the tail (right) of a list: 
RPUSH fruits "cherry" "date"

Read

Get elements from a list by index range: 

LRANGE fruits 0 -1
Get an element from a list by index: 
LINDEX fruits 2

Delete

Remove elements from the head (left) of a list: 

LPOP fruits
Remove elements from the tail (right) of a list: 
RPOP fruits
Remove an element from a list by its value: 
LREM fruits 1 "banana"

Sets

Create/Update

Add elements to a set: 

SADD colors "red" "green" "blue"

Read

Get all elements in a set: 

SMEMBERS colors
Check if an element is a member of a set: 
SISMEMBER colors "red"

Delete

Remove elements from a set: 

SREM colors "green"
Remove and return a random element from a set: 
SPOP colors

Sorted Sets

Create/Update

Add elements with scores to a sorted set: 

ZADD scores 10 "player1" 20 "player2" 30 "player3"
Update an element's score in a sorted set: 
ZINCRBY scores 5 "player1"

Read

Get elements from a sorted set by index range: 

ZRANGE scores 0 -1
Get elements from a sorted set by score range: 
ZRANGEBYSCORE scores 10 20

Delete

Remove elements from a sorted set: 

ZREM scores "player1"
Remove elements from a sorted set by index range: 
ZREMRANGEBYRANK scores 0 1
Remove elements from a sorted set by score range: 
ZREMRANGEBYSCORE scores 10 20

These examples cover the basic CRUD operations for each Redis data type. In practice, Redis provides many more commands and options for manipulating and querying these data structures. You can find a full list of Redis commands in the official documentation: https://redis.io/commands

Connecting to Redis with Python

In this tutorial, we'll demonstrate how to connect Redis with Python using the redis-py library. We'll focus on adding keys to the Redis database and retrieving them using Python. By the end of this tutorial, you will have a clear understanding of how to interact with Redis using Python.

Set up

Before starting, ensure that Redis is installed on your system. To install Redis, follow the instructions for your operating system on the official Redis website: https://redis.io/download

Next, you need to install the redis-py library, which is the Python client for Redis. Install it using pip:

pip install redis

Then create a Python file and import the redis module:

import redis
Connect to your Redis server using the following code: 
r = redis.Redis(host='localhost', port=6379, db=0)
The redis.Redis constructor accepts the following parameters:
  • host: The Redis server hostname (default: 'localhost')
  • port: The Redis server port number (default: 6379)
  • db: The Redis database number (default: 0)

Adding Keys to Redis

Now that we have established a connection to Redis, let's add some keys. In this tutorial, we'll focus on adding keys as strings, but you can easily adapt this code to work with other Redis data types.

To set a key-value pair in Redis, use the set method:

r.set('user:1:name', 'John Doe')
r.set('user:1:email', 'john.doe@example.com')

You can also set a key with an expiration time (in seconds) using the setex method:

r.setex('session_key', 3600, 'session_data')

Retrieving Keys from Redis

To retrieve the value associated with a key, use the get method:

user_name = r.get('user:1:name')
user_email = r.get('user:1:email')
The get method returns the value as bytes. To convert it to a string, use the decode method: 

user_name = user_name.decode('utf-8')
user_email = user_email.decode('utf-8')
If you want to retrieve multiple keys at once, use the mget method: 
keys = ['user:1:name', 'user:1:email']
values = r.mget(keys)
# Convert byte values to strings
values = [value.decode('utf-8') for value in values]

Additional Operations with Redis-Py

The redis-py library supports various Redis operations, including:

  • CRUD operations for all Redis data types (strings, hashes, lists, sets, and sorted sets)
  • Transactions
  • Pub/Sub messaging
  • Connection pooling
  • Refer to the redis-py documentation for more information on these features and usage examples: https://redis-py.readthedocs.io/

Understanding Connection Pooling

Connection pooling is a technique used to optimize the performance of database connections. It involves maintaining a pool of open connections that can be reused by different parts of your application. This helps to reduce the overhead of creating and destroying connections frequently, which can improve the overall performance and responsiveness of your application.

The redis-py library provides built-in support for connection pooling. To use connection pooling, you need to create a ConnectionPool object and pass it to the Redis class when creating a new Redis client instance.

First, import the necessary modules: 

import redis
from redis import ConnectionPool

Create a connection pool and pass it to the Redis client: 

pool = ConnectionPool(host='localhost', port=6379, db=0)
r = redis.Redis(connection_pool=pool)

Now, you can use the Redis client r to interact with Redis as usual, and it will automatically use the connection pool to manage connections.

Let's look at some examples of how connection pools can be used in different scenarios:

Sharing a connection pool across multiple Redis clients:

If you have multiple Redis clients in your application, you can share a single connection pool among them to optimize connection usage. 

pool = ConnectionPool(host='localhost', port=6379, db=0)

r1 = redis.Redis(connection_pool=pool)
r2 = redis.Redis(connection_pool=pool)

Using a connection pool with multiple threads:

Connection pools are thread-safe, so you can use them in multi-threaded applications without any issues.

import threading

pool = ConnectionPool(host='localhost', port=6379, db=0)

def worker():
    r = redis.Redis(connection_pool=pool)
    # Perform Redis operations with 'r'

threads = [threading.Thread(target=worker) for _ in range(5)]

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

ConnectionPool configuration

The ConnectionPool class provides several configuration options to control the behavior of the connection pool. Some of the most useful options include:

  • max_connections: The maximum number of connections that can be created in the pool. If this limit is reached, the connection pool will block until a connection becomes available. Default is None (no limit).
  • timeout: The number of seconds to wait for a connection to become available before raising an exception. Default is None (wait indefinitely).
  • retry_on_timeout: If set to True, the connection pool will attempt to retry when a timeout occurs. Default is False.
  • socket_connect_timeout: The maximum time in seconds to wait for a connection to the Redis server to be established. Default is None (wait indefinitely).
  • socket_keepalive: Enable or disable TCP keepalive. Default is False.
  • socket_keepalive_options: A dictionary of TCP keepalive options. For more details on the available options, consult your operating system's documentation.

Here's an example of how to create a connection pool with custom configuration options: 

pool = ConnectionPool(
    host='localhost',
    port=6379,
    db=0,
    max_connections=10,
    timeout=5,
    socket_connect_timeout=3,
    socket_keepalive=True
)
r = redis.Redis(connection_pool=pool)

Wrap up

In conclusion, we have explored various aspects of Redis and Python, learning how to integrate these two technologies to build efficient and scalable applications. Throughout this article, we have covered:

  1. The basics of Redis, its data types, and the CRUD operations for each data type.
  2. How to connect Redis with Python using the redis-py library and perform various operations.
  3. Implementing connection pooling for better performance and connection management.
  4. Working with the different data types in Redis and performing CRUD operations using Python.
  5. Connecting Python applications to Redis, adding keys, and retrieving them using redis-py.
  6. Using Redis in different scenarios, such as multi-threaded applications and sharing a connection pool across multiple clients.
  7. Configuring connection pools to optimize performance and tailor them to your specific requirements.

By learning and understanding these topics, you are now equipped with the foundational knowledge necessary to work with Redis and Python in your projects. This knowledge will enable you to build applications that can efficiently handle high concurrency, store and manage data in various formats, and scale with the needs of your users. Moving forward, you can delve deeper into the redis-py library and explore advanced features, such as transactions, Pub/Sub messaging, and advanced configuration options, to further enhance your applications.