Boost Node.js App Speed: Caching Using Redis

In this guide we are going to have a simple introduction to Redis and how to cache your Node.js application with Redis. Here, you will learn the utilization of Redis for caching through an example and how you can use it to improve your application speed and performance. Before we start with the implementation details, let’s take a moment to explore the foundational concepts of caching and Redis.

Prerequisites

Before we dive into the details of Node.js with Redis cache, it’s important to ensure that we have the necessary prerequisites in place. To get started with Redis, we need to have an understanding of JavaScript, NPM, and Node.js. We also need to have Node.js and NPM (Node Package Manager) installed and a Redis server installed on our system.

What is Caching?

Caching is the process of storing copies of files in a cache or a temporary storage location so that they can be accessed more quickly. The goal of caching is to speed up data access operations better than a database or remote server could allow. It is ideal in the case of expensive (in time) operations.

As a back-end developer, our task is to complete the clients’ requests as fast as possible. Sometimes, queries require several operations like retrieving data from a database, performing calculations, retrieving additional data from other services, etc., that drag our performance down.

With caching, we can process the data once, store it in a cache and then retrieve it later directly from the cache without doing all those expensive operations. We would then periodically update the cache so that users can see updated information.

Related read: Redis API Caching: Boost Performance of Your Django API

What is Redis?

Redis is an open-source (BSD licensed), in-memory data structure store used as a database, cache, and message broker. You can think of it as a No-SQL database, which stores data as a key-value pair in the system memory. If needed, Redis supports disk-persistent data storage too.

Redis is best in situations that require data to be retrieved and delivered to the client in the least amount of time. Now that you have an understanding of what caching and Redis are, let’s build a basic project that implements caching using Redis.

Implementation of Redis

Create a new directory for the application by running the following command on the terminal:

mkdir node-redis
cd node-redis

Initialize the directory to create a package.json file by running:

npm init -y

After running the above command, you should have a package.json file in the redis-nade-cache directory. Now, we are going to request a JSON placeholder API.

Start by creating a simple Express server in Index.js:

// users endpoint with caching
app.get("/users", async (req, res) => {
await axios
.get("https://jsonplaceholder.typicode.com/users")
.then((res) => res.data)
.then(async (users) => {
// send JSON response to client
return res.json({ source: "api", data: users });
})
.catch((error) => {
// send error to the client
return res.json(error.toString());
});
});

Now, start the server by running Node Index.js and open Postman to request the photos endpoint.

Sample Request

Take note of the time from the above images. The sample request took 120ms. We will improve speed by implementing caching using Redis. Let’s implement Redis in the above example.

Install Express, Redis, and node-fetch npm modules with the below command:

npm install redis

Now that we have successfully set up Redis, the next step is to use it in our application to improve it by reducing the turnaround time of requests and responses. Now we will add the following changes to the Index.js file.

First, we create a Redis client and link it with the local Redis instance using the default Redis port (6379).

// setup redis client
const client = createClient();

client.on("error", (err) => console.log("Redis Client Error", err));

client.connect();

Final code of Index.js

const express = require("express");
const axios = require("axios");
const { createClient } = require("redis");
const morgan = require("morgan");

const dotenv = require("dotenv");
dotenv.config();

const app = express();

app.use(morgan("dev"));

// setup redis client

const client = createClient();

client.on("error", (err) => console.log("Redis Client Error", err));

client.connect();

// redis store configs
const usersRedisKey = "store:users"; // cache key for users
const dataExpireTime = 3600; // 1 hour cache expire time

// users endpoint with caching
app.get("/users", async (req, res) => {
// try to fetch the result from redis
const users = await client.get(usersRedisKey);
if (users) {
return res.json({ source: "cache", data: JSON.parse(users) });

// if cache not available call API
} else {
// get data from remote API

}
});

// clear the cache on redis
app.get('/clear',async(req,res,next)=>{
await client.flushAll('ASYNC');
res.json({
status:true,
message:'Cleared successfully'
})
})

app.listen(process.env.PORT, () => {
console.log(`Server is running on http://localhost:${process.env.PORT}`);
});

Now, let’s test the application after implementing the cache. Open Postman and request the same endpoint as before.

As we can see above, it took a blazing 29 milliseconds for the request to be completed because it was fetched from the cache.