Back to Blog

Step-by-Step Tutorial: Redis and Express Integration

Step-by-Step Tutorial: Redis and Express Integration

Redis is an open-source, in-memory data store used by millions of developers worldwide.

It is known for its speed and efficiency, making it a popular choice for caching, real-time applications, and message brokering.

Redis supports various data structures such as strings, hashes, lists, sets, and more.

Understanding the Problem Redis Solves

In a typical web app setup, a user interacts with a server, which then talks to a database. This can cause performance problems, especially with complex queries. For example, when a user visits a website, the server might have to run several queries and joins to get data from the database.

This can take a long time, especially if the user refreshes the page often, leading to repeated heavy work and slower response times.

Redis as a Solution

Redis addresses these issues by acting as an in-memory data store, providing a caching layer between the server and the database. This setup allows the server to check Redis for cached data before querying the database, significantly reducing response times and database load. Redis stores data in RAM, which is extremely fast but temporary, making it ideal for caching purposes.

Benefits of Using Redis

  • Fast Response Times: By caching data in memory, Redis allows for instant data retrieval, improving user experience.

  • Reduced Database Load: Fewer database queries are needed, as Redis can serve cached data.

  • Improved User Experience: Faster response times lead to a smoother user experience.

Common Use Cases for Redis

  1. Caching: Redis is widely used for caching to improve application performance by storing frequently accessed data in memory.

  2. Rate Limiting: Redis can control the number of requests a user can make, preventing abuse and ensuring fair usage.

  3. Session Management: Redis provides a fast and scalable solution for storing session data in web applications.

  4. Background Jobs: Redis can be used to manage task queues and background jobs efficiently.

  5. Pub/Sub Messaging: Redis supports publish/subscribe messaging, useful for chat systems and notifications.

  6. Geo-Based Queries: Redis can handle geospatial data, enabling location-based features in applications.

  7. Ranking Systems: Sorted sets in Redis are ideal for implementing leaderboards and ranking systems.

Redis Data Structures

  • Strings: Basic values stored in Redis.

  • Lists: Ordered collections that can be used as queues or stacks.

  • Sets: Unordered collections of unique values.

  • Hashes: Key-value pairs, similar to objects in programming languages.

  • Sorted Sets: Sets with a score, used for ranking.

  • Streams: High-throughput data structures for event logging and analytics.

  • Geo Data: Used for location-based queries.

  • Pub/Sub: Messaging system for real-time communication.

Redis CLI Basics

Redis provides a command-line interface (CLI) for interacting with the database. Common commands include setting and getting keys, managing lists and sets, and performing operations on hashes and sorted sets.

Setting Up and Installing Redis with Docker

To get started with Redis using Docker, follow these steps:

  1. Install Docker: Ensure Docker is installed on your system. You can download it from the official Docker website.

  2. Pull the Redis Image: Open your terminal and run the following command to pull the Redis image from Docker Hub:

    bash
    docker pull redis

  3. Run Redis Container: Start a Redis container using the command:

    bash
    docker run --name my-redis -d redis

  4. Access Redis CLI: To interact with Redis, you can use the Redis CLI by executing:

    bash
    docker exec -it my-redis redis-cli

Redis GUI

A Redis GUI can help visualise and manage your Redis data more effectively. Some popular Redis GUI tools include:

  • RedisInsight: A powerful tool for visualising and optimising Redis data.

  • Medis: A cross-platform, open-source Redis GUI management tool.

  • RDM (Redis Desktop Manager): A fast, open-source Redis database management application.

Redis CLI Commands

Redis provides a command-line interface (CLI) for interacting with the database. Here are some common commands:

  • Keys:

    • KEYS *: List all keys.

    • DEL key: Delete a key.

    • EXISTS key: Check if a key exists.

    • TTL key: Get the time-to-live of a key.

    • EXPIRE key 60: Set a key to expire in 60 seconds.

  • Strings:

    • SET key value: Set a string value.

    • GET key: Get a string value.

    • MSET key1 val1 key2 val2: Set multiple keys.

  • Lists:

    • LPUSH list value: Push a value to the left of a list.

    • RPUSH list value: Push a value to the right of a list.

    • LPOP list: Pop a value from the left of a list.

    • LRANGE list 0 -1: Get all elements in a list.

  • Sets:

    • SADD set value: Add a value to a set.

    • SREM set value: Remove a value from a set.

    • SISMEMBER set value: Check if a value is a member of a set.

  • Hashes:

    • HSET bike model R15 price 200000: Set fields in a hash.

    • HGET bike price: Get a field from a hash.

    • HGETALL bike: Get all fields and values in a hash.

Redis Implementation with Node.js

To set up and use ioredis in a Node.js application, follow these steps with code examples for various use cases:

Step 1: Install ioredis

First, you need to install the ioredis package in your Node.js project. You can do this using npm:

bash
npm install ioredis

Step 2: Connect to Redis

Create a connection to your Redis server using ioredis:

javascript
const Redis = require('ioredis');
const redis = new Redis(); // Connects to 127.0.0.1:6379 by default

1. Basic String Operations

Set and Get a Key:

javascript
// Set a key
redis.set('name', 'John Doe');

// Get a key
redis.get('name', (err, result) => {
  if (err) {
    console.error(err);
  } else {
    console.log(result); // Output: John Doe
  }
});

Set a Key with Expiry:

javascript
redis.set('session', 'active', 'EX', 60); // Expires in 60 seconds

2. Working with Lists

Push and Pop Operations:

javascript
// Push elements to a list
redis.lpush('tasks', 'Task1');
redis.rpush('tasks', 'Task2');

// Pop elements from a list
redis.lpop('tasks', (err, task) => {
  console.log(task); // Output: Task1
});

3. Working with Sets

Add and Remove Members:

javascript
// Add members to a set
redis.sadd('tags', 'nodejs', 'redis');

// Remove a member from a set
redis.srem('tags', 'nodejs');

// Check membership
redis.sismember('tags', 'redis', (err, result) => {
  console.log(result); // Output: 1 (true)
});

4. Working with Hashes

Set and Get Hash Fields:

javascript
// Set fields in a hash
redis.hset('user:1000', 'name', 'Alice', 'age', '30');

// Get a field from a hash
redis.hget('user:1000', 'name', (err, name) => {
  console.log(name); // Output: Alice
});

// Get all fields and values in a hash
redis.hgetall('user:1000', (err, user) => {
  console.log(user); // Output: { name: 'Alice', age: '30' }
});

5. Pub/Sub Messaging

Subscribe and Publish:

javascript
// Subscribe to a channel
redis.subscribe('news', (err, count) => {
  console.log(`Subscribed to ${count} channel(s).`);
});

// Listen for messages
redis.on('message', (channel, message) => {
  console.log(`Received message from ${channel}: ${message}`);
});

// Publish a message
const publisher = new Redis();
publisher.publish('news', 'Breaking News!');

These examples demonstrate how to set up and use ioredis in a Node.js application for various Redis operations, including basic string manipulation, list and set operations, hash management, and pub/sub messaging. Adjust the connection settings and commands as needed for your specific use case.

Different Use Cases of Redis

Redis is a versatile, in-memory data structure store that can be used for a wide range of applications due to its speed and flexibility. Here are some detailed use cases where Redis can be effectively utilised:

  1. Caching

  2. Session Management

  3. Real-time Analytics

  4. Message Queues

  5. Leaderboard/Counting Systems

  6. Geospatial Data

  7. Data Streaming

By leveraging these capabilities, Redis can significantly enhance the performance and scalability of applications across various domains. Whether it's for caching, session management, real-time analytics, or any other use case, Redis provides a robust and efficient solution.

Caching with Redis

Redis is used as middleware in the endpoints of Express routes or as a function for caching to enhance application performance. Here's a simple Node.js example:

Step 1. Redis Client Setup Code

javascript
const { Redis } = require("ioredis")
const redisClient = new Redis()

redisClient.on("connecting", () => {
    console.log("Redis Get Connecting")
})
redisClient.on("connect", () => {
    console.log("Redis Successfully connected")
})
redisClient.on("error", () => {
    console.log("Error while connecting")
})


module.exports = redisClient

Step 2. Redis Middleware

javascript
const redisClient = require("../utils/redisClient")

function cachedData(key) {
    return async (req, res, next) => {
        try {
            console.log("cached data")
            const getData = await redisClient.get(key)
            if (getData) {
                res.send(JSON.parse(getData))
                return
            }
            next()
        } catch (error) {
            console.log(error)
            next()
        }

    }
}
module.exports = cachedData

Step 3. Redis with Express endpoints

javascript
const { default: axios } = require("axios")
const client = require("./utils/redisClient")
const express = require("express")
const cachedData = require("./middleware/cachedData")
const redisClient = require("./utils/redisClient")
const app = express()


app.get("/products", cachedData("products"), async (req, res) => {
    const { data: productsData } = await axios.get("https://dummyjson.com/products")
    await redisClient.setex("products", 15, JSON.stringify(productsData))
    res.send(productsData)
})

app.get("/products/:id", async (req, res) => {
    const productId = req.params.id
    cachedData(`products:${productId}`)
    const { data: productsData } = await axios.get(`https://dummyjson.com/products/${productId}`)
    await redisClient.setex(`products:${productId}`, 60, JSON.stringify(productsData))
    res.send(productsData)
})

app.get("/", async (req, res) => {
    const cashedValue = await client.get("todoslist")
    if (cashedValue) {
        res.json(JSON.parse(cashedValue))
        return;
    }
    const { data } = await axios.get("https://jsonplaceholder.typicode.com/todos")
    await client.setex("todoslist", 20, JSON.stringify(data))
    res.json(data)
})

app.listen(3000, () => {
    console.log("App is running at port", 3000)
})

Redis as a Rate Limiter

Redis can be used for rate limiting to control the number of requests a user can make:

javascript
const rateLimit = async (ip) => {
  const requests = await client.incr(ip);
  if (requests === 1) {
    client.expire(ip, 60); // Set expiry to 60 seconds
  }
  if (requests > 100) {
    return 'Too many requests';
  }
  return 'Request allowed';
};

Session Management

Redis is also used for session management in web applications, providing a fast and scalable solution for storing session data.

Resources Link

https://www.youtube.com/watch?v=Vx2zPMPvmug&t=1889s

https://www.youtube.com/watch?v=Y46wlauVH_o&t=1s

Conclusion

Redis is a versatile tool that can be used for various purposes, including caching, session management, and rate limiting. Its speed and efficiency make it an excellent choice for applications requiring real-time data processing. By using Docker, you can easily set up and manage Redis instances, making it accessible for development and production environments.

Based in Greater Noida, India•Currently