{"componentChunkName":"component---src-templates-tag-js","path":"/tags/redis/","result":{"data":{"site":{"siteMetadata":{"title":"LoginRadius Blog"}},"allMarkdownRemark":{"totalCount":3,"edges":[{"node":{"fields":{"slug":"/engineering/smart-cache-redis-cloud-aws-elasticache-for-redis/"},"html":"

LoginRadius is one of the leading and technologically advanced Customer Identity and Access Management (CIAM) solutions. Enterprise customers rely on our CIAM to manage end-user authentication and authorization. They typically serve hundreds of thousands to millions of end-users, making our CIAM a critical part of their IT infrastructure and value delivery.

\n

Our backend consists of multiple microservices handling various identity and access management functions and workflows through APIs. And we use MongoDB as persistent storage for configuration data. For faster access and availability of this data, we deployed Redis in-memory cache through Redis Enterprise Cloud.

\n

Challenges with Cache Updates

\n

We had our configuration cache set up in Redis Cloud. And to reduce the Redis Cloud latency, we kept the configuration cache at the application level in memory — but we ran into problems.

\n

Generally, customers don’t update their configurations so frequently. But when a customer updates their configuration, it doesn’t propagate in the backend until the server memory cache is purged — sometimes even taking several hours.

\n

This is bad for business: A customer updates configurations in response to a new requirement or rapidly changing business environment. If these changes take so much time for a digital identity process, it can affect end-users and, in turn, business outcomes. Simply imagine that a customer updated app configuration to accommodate a one-time flash sale, and end-users can’t place orders properly due to configuration update issues!

\n

So, we started evaluating various options to address these issues. We considered running multiple instances in the Redis Cloud and synchronizing them to minimize latency for all regions while ensuring customer configuration updates go live immediately. But this proved to be technically cumbersome and costly.

\n

We continued our research with various solutions and concluded that AWS ElastiCache for Redis best serves our needs.

\n

Migrating to AWS ElastiCache for Redis

\n

AWS provides ElastiCache for Redis as a Redis Cloud alternative with all necessary capabilities. Also, we were already using AWS Cloud for some of our IT infrastructure needs.\nSo, we can deploy ElastiCache alongside the same infrastructure to solve the latency issues.

\n

Accordingly, we have created ElastiCache instances in multiple AWS regions and set up the primary ElastiCache DB to quickly sync configuration updates in the secondary ElastiCache instances. Also, we deployed ElastiCache instances in multiple locations as needed.

\n

For migration, we updated the old Redis and ElastiCache primary instances simultaneously. Once we reached a sufficient confidence level with the new setup, we completely switched over to ElastiCache.

\n

Conclusion

\n

Our applications and cache are deployed in AWS, so our API response latency is no longer problematic. Ultimately, we can reduce application in memory cache updates to a few minutes or seconds as required.

\n

Now customers get updated configurations deployed rapidly, solving our primary challenge!

\n","frontmatter":{"date":"August 09, 2023","updated_date":null,"title":"Breaking Down the Decision: Why We Chose AWS ElastiCache Over Redis Cloud","tags":["Cache","AWS","Redis","LoginRadius"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/c24493552cd32d4940767196408ef18d/58556/migrating-to-aws-elasticache-for-redis.webp","srcSet":"/static/c24493552cd32d4940767196408ef18d/61e93/migrating-to-aws-elasticache-for-redis.webp 200w,\n/static/c24493552cd32d4940767196408ef18d/1f5c5/migrating-to-aws-elasticache-for-redis.webp 400w,\n/static/c24493552cd32d4940767196408ef18d/58556/migrating-to-aws-elasticache-for-redis.webp 800w,\n/static/c24493552cd32d4940767196408ef18d/99238/migrating-to-aws-elasticache-for-redis.webp 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Kundan Singh","github":null,"avatar":null}}}},{"node":{"fields":{"slug":"/engineering/guest-post/multi-factor-authentication-using-redis-cache-and-otp/"},"html":"

Securing your web applications from unauthorized users is very important. You can increase the security with One Time Password (OTP) authentication in addition to the login credentials. An OTP is sent to the user’s email when they want to log in. This is a form of multi-factor authentication (MFA).

\n

It is essential to learn how to apply Multi-Factor authentication in real-world applications, and this tutorial got you covered. This tutorial explains how to store users’ sessions in the Redis Store and send OTP using Nodemailer for authentication.

\n

Goal

\n

This tutorial helps you understand:

\n\n

Prerequisites

\n

To follow this tutorial, make sure you have:

\n\n

As everything is in place, let’s jump right in.

\n

Set Up the Server

\n

In this section, you will learn how to start an Express server.

\n
    \n
  1. Create a new folder and open it in a text editor. In this tutorial, this folder is named Multi-Factor Auth, but you can decide to call it anything you want.
    2. \n
  2. \n

    Open the terminal in the project’s path and run the following code to install the dependencies needed to start the Express server.

    \n
    npm init --y\nnpm i express\nnpm i -D nodemon
    \n

    The Express dependency will be used to set up the backend server and nodemon, installed as a devDependency, which will watch the file system and restart the server when a change is made.

    \n

    \"Express

    \n
    3. \n
  3. Create a new file named server.js in the project’s directory. For simplicity, this file will contain all the server code for this application.
    4. \n
  4. \n

    Add the following codes in the server.js file to set up an Express server to listen on port 5000.

    \n
    const express = require("express");\nconst app = express();\nconst PORT = 5000;\n\napp.listen(PORT, () => {\n  console.log(`Server running on port ${PORT}`);\n});
    \n
    5. \n
  5. \n

    Open package.json and add the following code to start the server.

    \n
    {\n  "name": "multi-factor-auth",\n  "version": "1.0.0",\n  "description": "",\n  "main": "server.js",\n  "scripts": {\n    "start": "node server.js",\n    "dev": "nodemon server.js"\n  },\n  "keywords": [],\n  "author": "",\n  "license": "ISC",\n  "dependencies": {\n    "express": "^4.18.1"\n  },\n  "devDependencies": {\n    "nodemon": "^2.0.16"\n  }\n}
    \n
    6. \n
  6. \n

    Start the server in development mode by running npm run dev in your terminal.

    \n

    \"Express

    \n
    7. \n
\n

Set Up Nodemailer

\n

Nodemailer is a Node.js module that allows you to send emails using an email service or an SMTP server.

\n

To set up Nodemailer, you need to provide your email or SMTP service credentials.

\n
\n

Google mailing service (Gmail) will not support the use of third-party apps or devices like Nodemailer starting from May 30, 2022.

\n
\n

For this tutorial, we will use Microsoft’s Outlook Maling Service to send emails.

\n

Set Up Outlook

\n
    \n
  1. Navigate to Outlook’s sign-up page to register for an Outlook account if you don’t have one.
    2. \n
  2. \n

    Add your phone number if you are prompted to do so.

    \n
    \n

    This step can be skipped.

    \n
    \n
    3. \n
\n

Sending Emails

\n

After setting up your Outlook account, the next step is to use your Outlook account’s credential to send emails through Nodemailer.

\n
    \n
  1. \n

    Open your terminal and install the nodejs-nodemailer-outlook dependency.

    \n

    This module only needs your Outlook account credentials and message to send emails.

    \n

    Now, run the code below in your terminal to install the nodejs-nodemailer-outlook dependency:

    \n
    npm i nodejs-nodemailer-outlook
    \n
    2. \n
  2. \n

    Import the nodejs-nodemailer-outlook module into server.js and add the configurations needed to send emails:

    \n
    const express = require("express");\nconst app = express();\napp.use(express.json());//Enabling the body attribute.\nconst PORT = 5000;\n\napp.post("/auth", (req, res) => {//Post request to 'http://localhost:3000'\n  const nodeoutlook = require("nodejs-nodemailer-outlook");//Importing the module\n  nodeoutlook.sendEmail({\n    auth: {//Outlook Account Credentials \n      user: "<yourOutlookEmail@outlook.com>",//Email\n      pass: "<yourOutlookPassword>",//Password\n    },\n    from: "<yourOutlookEmail@outlook.com>",\n    to: req.body.email,//Getting the email\n    subject: "OTP",\n    text: req.body.message,//Getting the Message\n    onError: (e) => res.status(500).json({ message: `an error occurred ${e}` }),\n    onSuccess: (i) => res.status(200).json({ message: i }),\n  });\n});\n\napp.listen(PORT, () => {\n  console.log(`Server running on port ${PORT}`);\n});
    \n
    3. \n
  3. \n

    To test the application, use an API testing application like Postman and make a POST request to http://localhost:5000/auth, passing email and message to the body of the request.

    \n

    \"Postman\"

    \n
    4. \n
\n

Generate OTPs

\n

In the previous section, you've successfully configured Nodemailer and used it to send emails. This section will show you how to generate a random number and how to add this random number to the message sent to the user.

\n

You can generate this random number using:

\n
    \n
  1. Math.trunc(Math.random() * 1000000)
    2. \n
  2. A NodeJS module like UUID, shortid, nanoid, etc.
    3. \n
\n

This tutorial uses the nanoid module to generate random numbers.

\n
    \n
  1. \n

    In the terminal, install the nanoid module. This module will create a random set of characters as the OTP. Run the following command in your terminal:

    \n
    npm i nanoid@3.3.4 #Version compatible with Nodejs
    \n
    2. \n
  2. \n

    After installing the nanoid module, import it into server.js and use it to generate six random digits.

    \n
    const nanoid = require("nanoid");//Importing the naonid module\n\nconst OTP = nanoid.customAlphabet("1234567890", 6)();//Generating
    \n
    3. \n
  3. \n

    Add the OTP to the message sent to the user’s email.

    \n
    const express = require("express");\n\nconst nanoid = require("nanoid");\nconst app = express();\n\napp.use(express.json());\nconst PORT = 5000;\n\nconst OTP = nanoid.customAlphabet("1234567890", 6)();\n\napp.post("/auth", (req, res) => {\n  const nodeoutlook = require("nodejs-nodemailer-outlook");\n\n  nodeoutlook.sendEmail({\n    auth: {//Outlook Account Credentials \n      user: "<yourOutlookEmail@outlook.com>",//Email\n      pass: "<yourOutlookPassword>",//Password\n    },\n    from: "<yourOutlookEmail@outlook.com>",\n    to: req.body.email,//Getting the email\n    subject: "OTP",\n    text: `Your One Time Password is ${OTP}`,//Adding the OTP\n    onError: (e) => res.status(500).json({ message: `an error occurred ${e}` }),\n    onSuccess: (i) => res.status(200).json({ message: i }),\n  });\n});\n\napp.listen(PORT, () => {\n  console.log(`Server running on port ${PORT}`);\n});
    \n
    4. \n
  4. \n

    Make a POST request to http://localhost:5000/auth, passing only the email address.

    \n

    \"Email

    \n
    5. \n
  5. \n

    Check the email address for which the OTP is sent.

    \n

    \"Gmail\"

    \n
    6. \n
\n

Redis

\n

Now that the OTP part of the authentication is settled, let’s set up the next part of the authentication. This section covers what Redis is and how to use the Redis Store to cache data.

\n

What is Redis?

\n

Redis, also known as Remote Dictionary Server, is an open-source (BSD licensed), in-memory data structure store. Developers use it as a database, cache, and message broker. It is a fast, lightweight database that structures data in key-value pairs.

\n

Redis Cache

\n

Storing and retrieving cached data from Redis is faster than traditional databases as it retrieves and stores data in the main memory (the RAM). The data can be users’ sessions or responses to requests.

\n

The only downside is that data can be lost if the computer crashes.

\n

Setting up Redis

\n

Setting up Redis locally for Linux and Mac computers is simply straightforward.

\n

Follow the official documentation for Linux and macOS

\n

For Windows, you need to install Windows Subsystem for Linux Version 2 (WSL 2) and a Linux Distro on your local machine.

\n

This tutorial uses Redis Cloud to set up the Redis database. Redis Cloud starts with Free a subscription fee that grants 30MB of storage. This is perfect for this simple application.

\n
    \n
  1. \n

    Create a new Redis Cloud account if you don’t have one.

    \n

    \"Redis

    \n
    2. \n
  2. Click on Let’s start free and let Redis create a cloud database.
    3. \n
  3. \n

    Click on Configurations and copy your Public endpoint. This endpoint will be used to set up the Redis application.

    \n

    \"Public

    \n
    4. \n
  4. \n

    Still on the Configurations tab, copy your Default user password.

    \n

    \"Password\"

    \n
    5. \n
  5. \n

    Run npm i redis in your terminal. Import the redis dependency into server.js, and set up the redisClient using the Redis cloud endpoint.

    \n
    const redis = require("redis");\n\nconst redisConnect = async () => {//This function will be removed later in the tutorial\n  try {\n    const redisClient = redis.createClient({\n    url: "redis://redis-12345.c80.us-east-1-2.ec2.cloud.redislabs.com:12345", //This is an incorrect end point, insert your Public endpoint\n      port: 12345,//The PORT is the last five digits in the url\n      username: "default",\n      password: "1234567890ABCDEFGHIJKLMNOPQRSTUV",//Input your Default_user_password\n    });\n    await redisClient.connect();//Connecting to Redis Cloud\n    await redisClient.set("Hello", "Hello from LoginRadius");//key=Hello, value=Hello from LoginRadius\n    const Hello = await redisClient.get("Hello");//Getting the value using its key=Hello\n    console.log(Hello);\n  } catch (error) {\n    if (//Running the function again when there is a network error\n      error.message ===\n        "getaddrinfo ENOTFOUND redis-12345.c80.us-east-1-2.ec2.cloud.redislabs.com:12345" ||\n      error.message ===\n        "getaddrinfo EAI_AGAIN redis-12345.c80.us-east-1-2.ec2.cloud.redislabs.com"\n    ) {\n      return redisConnect();\n    }\n    console.log(error.message);\n  }\n};
    \n
    6. \n
  6. \n

    Start up the server in your terminal and view the result.

    \n

    \"Redis

    \n
    7. \n
\n

Sessions

\n

Now that Redis has been added to the application, let’s set up users’ sessions using Express Sessions.

\n

Set Up Express Sessions

\n
    \n
  1. \n

    Install the express-session and connect-redis modules in your terminal.

    \n

    The express-session module allows you to create a session in the client’s browser. And the connect-redis module enables you to set Redis as the session store. Run the following command in your terminal.

    \n
    npm i express-session connect-redis
    \n
    2. \n
  2. \n

    Import express-session and connect-redis into server.js and configure the session store.

    \n
    const express = require("express");\nconst app = express();\n\nconst redis = require("redis");\nconst session = require("express-session");//Importing express session\nconst RedisStore = require("connect-redis")(session);//Importing connect-redis and passing the session\nconst redisClient = redis.createClient({\n    url: "redis://redis-12345.c80.us-east-1-2.ec2.cloud.redislabs.com:12345", //This is an incorrect end point, insert your Public endpoint\n      port: 12345,//The PORT is the last five digits in the url\n      username: "default",\n      password: "1234567890ABCDEFGHIJKLMNOPQRSTUV",//Input your Default_user_password\n      legacyMode: true, //Very important for Redis V4\n    });\nredisClient\n  .connect()\n  .then(() => console.log("connected"))//Logs out connected on successful\n  .catch((e) => console.log(e.message));//Logs out the error\n\napp.use(\n  session({\n    secret: "LoginRadius",//session secret key\n    resave: false,\n    saveUninitialized: false,\n    store: new RedisStore({ client: redisClient }),//Setting the store\n  })\n);\n\n//The Rest of the code
    \n
    3. \n
\n

Storing OTPs

\n

Attributes stored in a session without a database are removed after the server refreshes. With the help of Redis cache, attributes in a session can be retrieved fast and saved even when the server restarts.

\n

The user’s OTP should be saved in the session before sending it to the user’s email.

\n

Open your server.js file and add the code as follows.

\n

The following code stores the OTP in the session, redirects when the email has been sent, and verifies the OTP provided with the one stored in the session.

\n
app.post("/auth", (req, res) => {\n  let OTP = nanoid.customAlphabet("1234567890", 6)();//Changing the OTP\n  req.session.OTP = OTP;//Storing the OTP in the \n  const nodeoutlook = require("nodejs-nodemailer-outlook");\n  nnodeoutlook.sendEmail({\n    auth: {//Outlook Account Credentials \n      user: "<yourOutlookEmail@outlook.com>",//Email\n      pass: "<yourOutlookPassword>",//Password\n    },\n    from: "<yourOutlookEmail@outlook.com>",\n    to: req.body.email,//Getting the email\n    subject: "OTP",\n    text: `Your One Time Password is ${OTP}`,\n    onError: (e) => res.status(500).json({ message: `an error occurred ${e}, Please try again` }),\n    onSuccess: (i) => res.redirect("/verify"),//Redirecting the user to verify the token\n  });\n});\n\napp.get("/verify", (req, res) => {\n  res.send("Welcome to the verify route");//Welcome Message\n  console.log(req.session.OTP);//Logging out the OTP stored in the session.\n});\n\napp.post("/verify", (req, res) => {\n  const { OTP } = req.body;//Getting the user provided OTP\n  const OTPSession = req.session.OTP;//Getting the stored OTP\n  if (OTPSession) {//Checking if the OTP exist in the session\n    if (OTP === OTPSession) {//Verifying the similarity of the OTP\n      req.session.isAuth = true;//Setting auth to true\n      return res.status(200).json({ message: "OTP is correct" });\n    }\n    return res.status(401).json({ message: "Incorrect OTP" });\n  }\n  return res.status(404).json({ message: "OTP not found" });\n});
\n

Protecting Routes

\n

Preventing unauthorized/unauthenticated users from accessing a specific route or a piece of important information is essential in various applications. In this section, you'll learn how to create a middleware that will authenticate the users accessing a specific route.

\n
\n

In this tutorial, the protected route is /home

\n
\n
    \n
  1. \n

    Create a GET route to /home in server.js and add the middleware auth

    \n
    app.get("/home", auth , (req, res) => {\n  res.send("You have Successfully been Authenticated");\n});
    \n
    2. \n
  2. \n

    Create the auth middleware function and verify if the user is authenticated.

    \n
    const auth = (req, res, next) => {//auth middleware function\n\n  if (req.session.isAuth) {//Checking if `isAuth` = true\n    return next();\n  }\n  return res.redirect("/auth");//Redirecting the Login route\n};\n\napp.get("/auth", (req, res) => {//Login route\n  res.send("Login");\n});\n\napp.get("/home", auth, (req, res) => {//The Home route\n  res.send("You have Successfully been Authenticated");\n});
    \n
    3. \n
\n

Logout

\n

The logout route will also be protected using the auth middleware to prevent requests from users who are not signed in.

\n
app.post("/logout", auth, (req, res) => {\n  req.session.destroy();//Destroying the session\n  res.redirect("/auth");\n});
\n

Set Up the Frontend

\n

It’s time to put the backend code into actual functionality. This tutorial makes use of Embedded JavaScript Template (EJS) as the frontend of this application.

\n

Setting up EJS

\n
    \n
  1. \n

    Install the EJS Module

    \n
    npm i ejs
    \n
    2. \n
  2. \n

    Once the installation is complete, open your server.js and use ejs as the default view engine

    \n
    app.set("view engine", "ejs")
    \n
    3. \n
  3. \n

    In this application, there are only three routes. The login, verify, and home routes. You need to render an ejs file when accessing the routes.

    \n

    Modify the GET routes using the code as follows:

    \n
    app.get("/auth", (req, res) => {\n  res.render("login");//Rendering the login ejs file\n});\napp.get("/verify", (req, res) => {\n  res.render("verify");Rendering the verify ejs file\n});\napp.get("/home", auth, (req, res) => {\n  res.render("home");Rendering the home ejs file\n});
    \n
    4. \n
  4. \n

    Create a folder named views, and inside, create the various ejs files.

    \n
    \n

    When the server is rendering an ejs file, it checks in the views folder for the file. So, this name is not optional.

    \n
    \n

    \"Folder

    \n
    5. \n
\n
\n

Style these various routes as you like

\n
\n

Login Route

\n

Add the following code to login.ejs to set up the Login route.

\n
<!DOCTYPE html>\n<html lang="en">\n<head>\n  <meta charset="UTF-8">\n  <meta http-equiv="X-UA-Compatible" content="IE=edge">\n  <meta name="viewport" content="width=device-width, initial-scale=1.0">\n  <title>Login</title>\n</head>\n<body>\n  <h1>Login Page</h1>\n  <p>Please Sign in</p>\n  <form>\n    <input type="email" class="email"/><!-- Email input -->\n    <input type="submit" value="submit" class="submit"/>\n  </form>\n  <script>\n    const form = document.querySelector('form')//Getting the form\n    const email = document.querySelector('.email')//Getting the email\n\n    form.addEventListener('submit', async(e)=> {//Listening for a submit\n      e.preventDefault()\n      const data = { email: email.value }//Getting the email\n      await fetch("/auth", {//Making a POST request to http://localhost:5000/auth\n        method: "POST",\n        headers: {\n          "Content-Type": "application/json",\n        },\n        redirect: "follow",//Permiting redirects\n        body: JSON.stringify(data),//Sending the email\n      }).then(res => {\n        if(res.redirected) location.href = res.url//Redirecting the user on success\n      })\n      .catch((e) => {\n         email.value = ''\n         console.log(e.message);//Logging out error\n        });\n    })\n  </script>\n</body>\n</html>
\n

Verify Route

\n

Open verify.ejs and set up the verify page as follows.

\n
<!DOCTYPE html>\n<html lang="en">\n<head>\n  <meta charset="UTF-8">\n  <meta http-equiv="X-UA-Compatible" content="IE=edge">\n  <meta name="viewport" content="width=device-width, initial-scale=1.0">\n  <title>Login</title>\n</head>\n<body>\n  <h1>Verify Page</h1>\n  <p class="message">Enter your OTP</p><!-- Message alert -->\n  <form>\n    <input type="number" class="OTP" /><!-- OTP input -->\n    <input type="submit" value="submit" class="submit" />\n  </form>\n\n  <script>\n    const form = document.querySelector('form')//Getting the form\n    const OTP = document.querySelector('.OTP')//Getting the OTP\n    const message = document.querySelector('.message')//Getting the message alert\n\n    form.addEventListener('submit', async (e) => {//Listening for a submit\n      e.preventDefault()\n      const data = { OTP: OTP.value }//Getting the OTP\n      await fetch("/verify", {//Making a POST request to http://localhost:5000/verify\n        method: "POST",\n        headers: {\n          "Content-Type": "application/json",\n        },\n        redirect: "follow",//Permitting redirects\n        body: JSON.stringify(data),//Sending the OTP\n      }).then(async(res) => {\n        if(!res.ok){//Checking for errors\n          const data = await res.json()\n          OTP.value = ''\n          return message.textContent = data.message//Alerting the error\n        }\n        if (res.redirected) location.href = res.url//Redirecting the user on success\n      }).catch((e) => {\n          OTP.value = ''\n          console.log(e.message)\n        });\n    })\n  </script>\n</body>\n</html>
\n

Home Route

\n

This is the route that is protected. The page can contain sensitive information that must not be accessible to unauthenticated users.

\n

Open home.ejs and configure the home route as follows.

\n
<!DOCTYPE html>\n<html lang="en">\n<head>\n  <meta charset="UTF-8">\n  <meta http-equiv="X-UA-Compatible" content="IE=edge">\n  <meta name="viewport" content="width=device-width, initial-scale=1.0">\n  <title>Login</title>\n</head>\n<body>\n <h1>Home Page</h1>\n <p>Hello authenticated user, This is a secret information for your eyes only😉</p>\n Want to be unauthenticated, <button>Sign Out</button><!-- Sign Out button -->\n <script>\n   const button = document.querySelector('button')//Getting the sign out button\n   button.addEventListener('click', async()=> {//Listening for a click\n     await fetch('/logout', {//Making a POST request to http://localhost:5000/logout\n       method: "POST",\n       headers: {\n         "Content-Type": "application/json",\n       },\n       redirect: "follow"//Permitting redirects\n     }).then((res)=> {\n       if (res.redirected) location.href = res.url //Redirecting the user on success\n     }).catch(e=> {\n       console.log(e.message)\n     })\n   })\n </script>\n</body>\n</html>
\n

Conclusion

\n

This tutorial taught you how to set up Nodemailer, Redis Cloud, and Multi-Factor Authentication. With these, you've learned to secure your applications from unauthenticated users.

\n

Do you think you can use this to build complex and scalable applications?

\n

MFA with LoginRadius

\n

You can also set up MFA with LoginRadius instead of setting up everything manually with Redis. You can sign up for a free account here.

\n

Refer to this developer-friendly documentation to get started with your MFA setupdocs/guide/mfa/) for your web and mobile apps.

\n

Resources

\n

Click here to access the sample code used in this tutorial on GitHub

\n","frontmatter":{"date":"June 30, 2022","updated_date":null,"title":"Multi-Factor Authentication (MFA) with Redis Cache and OTP","tags":["Node.js","Redis","Authentication"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/3daec096b51ef3e91f85364c0c87892b/58556/mfa-with-redis-cache-and-otp.webp","srcSet":"/static/3daec096b51ef3e91f85364c0c87892b/61e93/mfa-with-redis-cache-and-otp.webp 200w,\n/static/3daec096b51ef3e91f85364c0c87892b/1f5c5/mfa-with-redis-cache-and-otp.webp 400w,\n/static/3daec096b51ef3e91f85364c0c87892b/58556/mfa-with-redis-cache-and-otp.webp 800w,\n/static/3daec096b51ef3e91f85364c0c87892b/99238/mfa-with-redis-cache-and-otp.webp 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Fredrick Emmanuel","github":"divofred","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/three-ways-to-do-crud-operations-on-redis/"},"html":"

Introduction

\n

Redis's usage as both a temporary data store and even as a permanent data store is increasing today, as memory has started becoming much cheaper. Redis' quick memory-based CRUD operations allow database interactions to happen significantly faster than interactions with other databases that use drive-based storage. This blog is about three different methods to interact with your Redis data.

\n

This blog will require having access to a Redis instance. Guides can be found to set up a local Redis instance for Windows here and for UNIX based machines like Mac or other Linux distros, it can be found here. Alternatively, you can use a remote instance, but be aware that some of the commands in this blog may delete or modify the data.

\n

Redis Insight

\n

For users that do not like working with command-line interfaces, the first tool introduced in this blog is a GUI interface called RedisInsight. This can be found here. After filling in their download form and installing, running the application will start a server on the localhost, which you can access with a browser.

\n

After installing and running the application, you will add the connection information for your Redis instance. If running a local instance of Redis, the connection information in the image will typically suffice. If connecting to a remote instance, you might need to fill in some additional details for TLS, such as connection certificates.

\n

\"Connect\"

\n

When connected to your Redis instance, the dashboard UI appears. Clicking the Browser sidebar tab will display all existing keys in your database.

\n

\"Browser\"

\n

From here, CRUD operations are relatively straightforward. Key-value pair creation can be done by using the ADD KEY button. This will prompt for the type of key-value pair to be added (Hash, String, JSON, etc.) and the data that will be stored with the key.

\n

If a specific key is required to be queried, fill in the field next to the blue filter icon with search criteria, then click the icon. It will prompt the type of data stored with the key, and the results will be displayed.

\n

\"Filter\"

\n

Finally, keys can be deleted by clicking the trash can icon on the right side.

\n

Redis CLI

\n

The Redis command-line interface is a more common approach for developers to interact with data from a Redis store. If you followed the steps at the beginning of the blog, the CLI should already be installed. To do a ping test to the server, type the following command in the terminal:

\n
chris@LR-ENG-17:~$ redis-cli -h localhost -p 6379 ping\nPONG
\n

And to connect, run the previous command without pinging:

\n
chris@LR-ENG-17:~$ redis-cli -h localhost -p 6379\nlocalhost:6379>
\n

The basic command to get a key-value pair is to call get with the key:

\n
localhost:6379> get key:1\n"value1"
\n

Setting a value can be done with the set command:

\n
localhost:6379> set key:1 value1new\nOK\nlocalhost:6379> get key:1\n"value1new"
\n

Creating a value can also be done in the same way:

\n
localhost:6379> get key:3\n(nil)\nlocalhost:6379> set key:3 value3new\nOK\nlocalhost:6379> get key:3\n"value3new"
\n

And deletion can be done with the del command:

\n
localhost:6379> del key:3\n(integer) 1\nlocalhost:6379> get key:3\n(nil)\nlocalhost:6379>
\n

This is only the simple basics of the Redis CLI. You can do more advanced operations through the CLI, such as the flushall command, which wipes your database. It’s a powerful tool, so be careful when experimenting with it. An extensive list of commands can be found here.

\n

With Your Chosen Programming Language

\n

With Redis’ widespread usage, almost all major industry programming languages have either community or official supported releases of libraries that can be used to interact with your database. In this section, I will be using Node.JS, and one of the support Redis libraries called node-redis.

\n

Initialization of the package in the code can be done by calling the following command after initializing Node in your directory:

\n
npm install redis
\n

When the process is finished, the redis module should be imported within your code, where you can set up the Redis connection and any options that need to be included:

\n
const redis = require("redis")\n\nconst redisOption = {\n  host: "127.0.0.1",\n  port: "6379",\n}\n\nconst client = redis.createClient()
\n

For an extensive list of options supported by the library for connection, check this link.

\n

After connecting, calling the on method on the client will allow the connection to open and run commands.

\n

The commands used by the library are a 1 to 1 mapping of the commands used by the Redis CLI, so they follow the same method calls. To update or create an entry in Redis, the most basic method is to use the set command:

\n
client.set("key:3", "value3new")
\n

Getting a value can be done with the get method:

\n
client.get("key:3")
\n

Deleting a value can be done with the del method:

\n
client.del("key:3")
\n

The methods used by the client also support callbacks. For example, if the operations should be console logged, we can include a callback to redis.print after each method:

\n
client.set("key:3", "value3new", redis.print)\nclient.get("key:3", redis.print)\nclient.del("key:3", redis.print)
\n

The output of this in the console would be:

\n
Reply: OK\nReply: value3new\nReply: 1
\n

Conclusion

\n

This blog has only touched the surface of the different operations Redis can do. There are many more resources online that can help you go further into your understanding of Redis. Whether using Redis as a temporary store, like a cache, or using it as a primary, permanent store, the operations' speed is something to be acknowledged and considered when building your next big app.

\n","frontmatter":{"date":"October 21, 2020","updated_date":null,"title":"Three Ways to do CRUD Operations On Redis","tags":["Redis","NodeJs","CLI","GUI"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/6597d1ce622532f445baf8ba0ef6e846/58556/index.webp","srcSet":"/static/6597d1ce622532f445baf8ba0ef6e846/61e93/index.webp 200w,\n/static/6597d1ce622532f445baf8ba0ef6e846/1f5c5/index.webp 400w,\n/static/6597d1ce622532f445baf8ba0ef6e846/58556/index.webp 800w,\n/static/6597d1ce622532f445baf8ba0ef6e846/99238/index.webp 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Chris Yee","github":null,"avatar":null}}}}]}},"pageContext":{"tag":"Redis"}},"staticQueryHashes":["1171199041","1384082988","2100481360","23180105","528864852"]}