DEV Community: Tochukwu Adams

Fundamentals of Object-Oriented Programming

Tochukwu Adams — Mon, 08 Jan 2024 15:20:54 +0000

Object-Oriented Programming (OOP) represents an approach in programming where all functionalities and programs revolve around the concept of objects. While other programming paradigms, such as procedural programming, exist, our primary focus is on Object-Oriented Programming, commonly known as OOP.

In OOP, problems are systematically broken down into units known as objects, and functionalities are developed around these objects. To illustrate this concept, consider a toy robot. Picture having a toy robot that can perform various actions like walking, talking, and dancing. In the realm of object-oriented programming, we create entities known as "objects," akin to our toy robot. Each object possesses a unique set of abilities, referred to as "methods" or "functions." These methods encapsulate the distinct functionalities, such as walking, talking, and dancing, allowing for a modular and organized approach to programming.

It's important to note that our discussion is not tie to any specific programming language; instead, our focus is squarely on understanding the fundamental concepts that underpin OOP.

Key Players in OOP

Having come across terms like objects, classes, behaviour, and methods in the first paragraph, you might be curious about their roles. It's impossible to discuss Object-Oriented Programming (OOP) without spotlighting these key players. Let's delve into what these elements are and their functions in OOP.

Classes: A class is a a template that defines the characteristics and behaviours common to a an object or group of objects. It hides data (attributes) and methods (functions) that operate on that data.
Objects: Is the entity in object-oriented system. This entity or entities (which is also referred to as the instance of a class) may be a person, a car, a place, or anything. Objects holds data in the form of attributes. For example we have an entity User.
Attribute: It stores information. about an object. They are defined in the class template. You remembered our User entity (object) example, a user object can have: name, email and gender as attribute.
Method: A method perform action on the object. It represents the behaviour of the object that is performing the action. The object and methods are encapsulated inside the class.

To illustrate, diagrams will be used for examples.

The following image showcases a standard instance of a class named User, featuring attributes and update and delete method.

4 Pillars Of OOP

Let's dive deeper into the pillars of OOP. They are:

Abstraction: Is the act of displaying the essential properties and behaviours without revealing the internal details. It allows developers to focus on what an object does without bothering with how it achieves it.
Encapsulation: It means to hide data from external program and exposing only necessary program or method.
Inheritance: Is a mechanism where an object or entity inherits the property of an other object.
Polymorphism: This concept might seem a bit tricky but Is the ability for objects (entities) to share the same behaviour which may result to different form or output based on the type of data used. There are two ways this is done:
1. Method Overriding: A subclass can override the method of the super class.
2. Method Overloading: you can define multiple methods with the same name in a class, as long as they have different parameter lists. Which may result to different behaviour of the objects.

We have a Student and Teacher objects that is inheriting the property of the User object. The User class is now assuming the role of a super class while the Student and Teacher classes function as the child classes.

This is a basic representation of how classes and inheritance look in OOP.

OOP Languages

There are several programming languages that support or are designed around the principles of Object-Oriented Programming (OOP). Here is a list of some prominent ones:

Java
PHP
JavaScript
C#
Python
Ruby
Dart

These languages vary in terms of syntax, use cases, and ecosystems, but they all incorporate OOP concepts to some extent. The choice of a particular language often depends on the requirements of a specific project or application.

Benefits Of OOP

Reusable Code: Code reuse is enhanced through features like inheritance, allowing developers to build on existing classes and create new ones with shared functionality.
Ease of Maintenance: Changes to one part of the code (a class) do not necessarily affect other parts, reducing the risk of introducing errors during maintenance.
Scalability: OOP promotes scalable software design. As new features or requirements arise, developers can extend existing classes or create new ones, maintaining a scalable and adaptable codebase.

Conclusion

As you grasp these core OOP concepts, you gain the ability to design software systems that are scalable, maintainable, and easily extensible. You'll find yourself adept at creating modular and reusable code, simplifying the development and maintenance processes. Whether you are working on small-scale projects or large-scale applications, a solid understanding of OOP empowers you to build robust and well-organized solutions.

In essence, mastering these fundamental OOP concepts is akin to acquiring a powerful set of tools that will elevate your programming capabilities. It opens the door to creating efficient, readable, and flexible code, enabling you to meet the challenges of software development with confidence and innovation.

Understanding Horizontal And Vertical Scaling

How To Store And Retrieve RedisJSON on Redis Cloud using Node.js

Understanding Horizontal And Vertical Scaling: Pros And Cons

Tochukwu Adams — Tue, 21 Nov 2023 12:21:05 +0000

Experiencing delays or downtime when accessing a particular resource is a common frustration in the digital age. Numerous factors can contribute to these disruptions, ranging from heavy traffic overwhelming a system to issues with the host server. Understanding and addressing these challenges is essential, and this is where scaling and capacity planning come into play.

One of the primary reasons for delays or downtime is the inability of a system to handle the volume of incoming traffic. As user demand increases, a system that lacks the necessary capacity may struggle to process requests efficiently, leading to slowdowns or service interruptions. In such cases, scaling becomes a crucial strategy to ensure that the system can dynamically adjust its resources to meet the demands of varying workloads.

Scaling, in the context of cloud systems, refers to the capability to increase or decrease the throughput of resources to accommodate changes in demand. It is a proactive approach to address the challenges posed by unpredictable spikes in traffic or evolving resource requirements. There are two main types of scaling: horizontal scaling and vertical scaling.

Horizontal And Vertical Scaling

Horizontal and vertical scaling is basically increasing or adding more computing power to your cloud infrastructure. The difference is in the implementation and performance. Horizontal scaling which is also refer as Scaling Out is adding more instance of the machine to your pool of cloud machines. Vertical scaling also known as Scaling Up is increasing the capabilities of the existing machine such as increasing the CPU or RAM. To bolster these methodologies further; horizontal scaling is like increasing the fleet of public buses to effectively convey people to their destination where as vertical scaling is similar to upgrading a car engine to speed faster.

How does the implementation of these scaling methodologies works.

Horizontal Scaling Implementation:

As discussed, harnessing the power of horizontal scaling involves the strategic addition of new instances of your computing machines to distribute workloads efficiently. Let's explore this concept further with a specific scenario:

Imagine you currently operate a server with 16 GB of RAM and 60 GB of disk storage. Recognizing the need for scalability due to an increasing demand for your services, you decide to implement horizontal scaling. Instead of upgrading the existing server, you opt to acquire additional servers, each with the same capacity (16 GB of RAM and 60 GB of disk storage).

In this horizontal scaling strategy, you now have a cluster of servers working together to handle the growing workload. When a user sends a request or when there's an increased demand for resources, the load is distributed across these multiple servers. This distribution ensures that no single server bears the entire burden, allowing for more efficient processing of tasks.

The beauty of horizontal scaling lies in its ability to provide instant availability and reduce downtime. If one server experiences issues or requires maintenance, the remaining servers in the cluster can continue to handle incoming requests. This approach enhances the overall system's fault tolerance and reliability, ensuring a seamless experience for users even during maintenance or unforeseen hiccups.

Vertical Scaling Implementation:

Imagine starting with a server that has 4 GB of RAM and 10 GB of disk storage. As your application or system experiences increased demands, you decide to implement vertical scaling. In this process, you opt to improve the computing power by upgrading key components such as RAM, CPU, and storage size. Firstly, you decide to increase the RAM from 4 GB to, let's say, 16 GB. This upgrade allows the server to handle more concurrent processes and efficiently manage larger datasets. With additional RAM, the system can store and access more data in its active memory, reducing the likelihood of bottlenecks during periods of heightened activity.

Secondly, you upgrade the CPU, which is the brain of the server responsible for processing instructions. By replacing the existing CPU with a more powerful one, you boost the server's processing capabilities. This results in faster execution of tasks and improved overall system performance.

Lastly, recognizing the need for more storage space, you expand the disk size from 10 GB to 50 GB. This expansion ensures that the system has sufficient room to store growing volumes of data without facing limitations on available storage capacity.

Pros of Horizontal Scaling:

High Scalability: Horizontal scaling allows for virtually unlimited expansion by adding more servers to the network, making it suitable for handling large workloads and sudden spikes in traffic.
Improved Fault Tolerance: With multiple servers, the failure of one does not bring down the entire system. This enhances fault tolerance and ensures high availability.

Cons of Horizontal Scaling:

Complexity: Setting up and maintaining a horizontally scaled system can be more complex than vertical scaling. It requires additional considerations like load balancing and distributed data management.
Increased Costs: In some cases, horizontal scaling can be more expensive, especially for smaller workloads, as it involves the cost of additional servers and infrastructure.

Pros of Vertical Scaling:

Simplicity: Vertical scaling is relatively straightforward. You can add more resources to your existing server without the need for complex configurations or additional software.
Cost-Effective for Small Workloads: For applications with low to moderate workloads, vertical scaling can be a cost-effective solution compared to horizontal scaling.

Cons of Vertical Scaling:

Limited Scalability: There is a practical limit to how much you can vertically scale a single server. Eventually, you'll reach the maximum capacity of your hardware.
Single Point of Failure: Since all resources are concentrated in a single server, any failure can have a significant impact on your entire system.

When to Apply Each Scaling Approach:

Vertical Scaling: Use vertical scaling when dealing with smaller workloads and budget constraints. It's a quick and simple solution for incremental growth.
Horizontal Scaling: Opt for horizontal scaling when anticipating rapid growth, handling large workloads, or ensuring fault tolerance. It provides the flexibility to scale dynamically in response to changing demands.

Conclusion:

Choosing between vertical and horizontal scaling depends on your specific needs, budget, and the nature of your application. Both approaches have their strengths and weaknesses, and the key is to strike the right balance based on your scalability requirements. By understanding these concepts and their real-world applications, you can make informed decisions to ensure the scalability and reliability of your infrastructure.

Redis OM: Developer Experience using Node.Js

Redis: RedisInsight Installation on Ubuntu 20.04 & Redis Stack Server Docker Container Set Up

Tochukwu Adams — Tue, 27 Sep 2022 02:27:43 +0000

Redis is a key-value pair database that is extremely fast when compared to other traditional SQL databases such as PostgresSQl, MySQL or CockroachDB. This is as a result of its in-memory storage capacity. It is way ahead in the NoSQL sphere. It is a household name when it concerns database due to its flexibility and ease of use.

Redis can be applied to different scenarios, for instance:

Caching of data to increase throughput and reduce the query on the database.
Message Streaming in real-time. Redis supports Streaming Data Architecture where data are consumed immediately through the Publisher/Subscriber technique.
Real-time Analytics for retrieving, visualizing, and processing data with minimal delay.

Developers love Redis because is lightweight and open source with a very vibrant community. It supports most of the popular programming languages which include Python, JavaScript, Go, Java, PHP and many others. You can store and retreive data with a few lines of code and it has a lot of data structure for manipulating data. The most exciting feature of Redis is its in-memory store which reduces latency to milliseconds and reduce response time.

Redis works well on Linux, Windows and Mac OS but it works efficiently well with Linux base OS.

RedisInsight

RedisInsight is the Desktop GUI client that connects to your Redis Server to provide an interface for visualizing your Redis databases. The client enables you to use the RedisInsight GUI locally.

The essence of this tutorial is to set up RedisInsight on your PC and connect it to your Redis Stack Server docker container. Without further ado let's jump into setting up RedisInsight on our system.

Prerequisite

Before installing Redis using Docker you must have a root user privilege on your Linux operating system and the Docker Engine installed and functioning correctly on your PC.

You can read up on the Redis Stack Server documentation here.

Docker Image

Go to your terminal and install the Redis Stack Server docker image with the command below. I prefer using this stack because I can use it to manage both my local and remote Redis database.

$ sudo docker run -d --name redis-stack-server -p 6379:6379 redis/redis-stack-server:latest

To test your redis-stack-server image downloaded successfully you need to interact with your redis-stack-server container shell.

Check if your container is up and running. The command below will list out your docker both running and non-running container.

$ docker ps -a

If your container is not running use this command to start your container.

$ docker container start redis-stack-server

Once your redis-stack-server is up and running. SSH into your redis-stack-server container.

$ sudo docker exec -it redis-stack-server sh

To test whether the Redis server is functioning correctly inside the container use the client command-line to ping the Redis server.

# redis-cli

127.0.0.1:6379> ping

Output

PONG

Click here to download the Redis GUI.

After downloading the RedisInsight client it automatically connects to your Redis Stack Server. Don't forget our Redis Stack Server is inside a docker container. To connect RedisInsigt to your Redis Stack Server docker container ensure your container is up and running. CD (change directory) into the folder where your downloaded RedisInsight file is stored and make it an executable file.

$ sudo chmod +x redisinsight-linux64-<version>

Your file name should be the same as the one you downloaded.

E.g

$ sudo chmod +x RedisInsight-v2-linux-x86_64.AppImage

You can double-click on the file or use this command to start your RedisInsight.

./RedisInsight-v2-linux-x86_64.AppImage

An interface will be displayed that already has your local Redis database instances (if you have one).

Redis Cloud

To connect to your remote database on Redis Cloud. On the RedisInsight click on the Add Redis Database on the top left side of your screen. A form will display in the right corner for you to enter your Redis Cloud database details. Paste your public endpoint URL on the Host field on the form. It will automatically fill up the forms with your database credentials.

Hurray!!! we did it.

Drop your feedback and questions. I am in the comment section 😉

This post is in collaboration with Redis

Try Redis Cloud for free

Redis Developer Hub - tools, guides, and tutorials about Redis

RedisInsight Desktop GUI

Watch this video on the benefits of Redis Cloud over other Redis providers

Redis OM: Developer Experience using Node.Js

Tochukwu Adams — Wed, 21 Sep 2022 15:37:10 +0000

Using Redis database just for cache is like using a modern mobile phone just for phone calls! You are missing out on a ton of cool things it can do! Give it a try! - Raja Rao, (VP of Growth Marketing at Redis)

I couldn't agree more with Raja. There is a whole lot one can do with Redis, why limit yourself. Since I started using the Redis database to manage my data, first it improved my application speed, and I have learned a lot about Redis Stacks and Redis Cloud. In this tutorial, I will share my experience with you. We will go over how to create records in JSON format using the RedisJSON, index and search records using the RediSearch stacks. You can read my other blog How To Store And Retrieve RedisJSON on Redis Cloud using Node.js where I threw some light about the gains of using Redis and Redis Cloud.

Redis OM

Redis OM is the magic stick developers can use to create data model on our applications and map it to the Redis database. Just like Mongoose, with Redis OM we can create models that interact with the database. This tool makes us (Software Developers) have a better experience while using Redis on our application.

Goal

The aim of this tutorial is to learn how to use the Redis technologies to store our data on the Redis cloud while utilizing its high throughput and low latency. We will be creating a Digital Book Library API using NodeJs. The library database will contain a book entity.

Prerequisite

Node Engine
Yarn or NPM installer
IDE (E.g: Visual Studio Code)

Setup Redis Cloud Account

You can use this link Redis Cloud to create a free account. After registration click on the New subscription button to set up a plan. If you're new to Redis you can start with a free subscription to get yourself familiarised with the platform or you can pick a paid plan. For this tutorial, I am using the AWS vendor but you can choose other vendor you're more comfortable with. After creating a subscription you can go ahead and create a database. When creating a database, there is a type with three options for you to select from. For this tutorial we will be using the Redis Stack Modules.

Redis Stack gives you a software development experience by enabling you to create data models and map them to your database. With RedisJSON module you can create records in JSON format and use the RediSearch to query them.

Let's go create our API!

Project Setup

Create a project folder redis-book-libray (you can name your project differently) and CD into the project folder.
$ mkdir redis-book-libray

$ cd redis-book-libray

$ yarn init -y (You can use NPM)

$ yarn add express redis-om nodemon

In your project root folder, create a src folder that will hold most of your program logic. I like to separate concerns for code clarity, easy debugging and reusability. Let's set up our database connection. Create a connection.js file inside your src folder. On the client.open() method paste your database credentials there. You can get your database details from the configuration tab after logging.

import { createClient } from 'redis';
import { Client } from 'redis-om';

// Database connection
const client = new Client()
// E.g URL = 'redis://default:WyfL..WH...AtUS3...jW...nf@redis-1...1.c73.us-...t-1-2.ec2.c..d.redislabs.com:1...1'
const DBConnection = await client.open('redis://username:password@Public-endpoint:port');

export default DBConnection;

Database Credentials

After registration, on your side bar click on Databases go to your Configuration tab, under General you will see your public endpoint which is your host and the digits after the colon is your port number, scroll down to security you will see your username and password. If you are using the free subscription your username is default.

Inside your src folder, create an app.js file that will serve as the gateway to your application. Don't pay attention to the imported route function for now. That will be sorted out later.

import express from 'express';
import routes from './routes.js';

const app = express()


app.use(express.json());


const PORT = process.env.PORT || 3000

app.use('/api/v1', routes);

app.listen(PORT, async () => {
    console.log(`app is running on port ${PORT}`)
})

Go to your package.json file and set up your scripts.

{
  "name": "redis-book-libray",
  "version": "1.0.0",
  "main": "./src/app.js",
  "license": "MIT",
  "scripts": {
    "start": "nodemon ./src/app.js"
  },
  "type": "module",
  "dependencies": {
    "express": "^4.18.1",
    "nodemon": "^2.0.19",
    "redis-om": "^0.3.6"
  },
  "devDependencies": {
    "nodemon": "^2.0.19"
  }
}

Go to your terminal or CMD, cd into your project and run yarn start or npm start.

The Next step is to define the Entity, Schema and Repository.

An Entity is a class for wrapping the objects that will be stored in the database. The Book Entity will extend to Redis OM Entity that will hold your data.

Schema is what we use to describe how the data will look. It defines the field and their types on the entity.

Repository is the interface that gives you access to create, read, update and delete methods that you can use to manipulate your records from the Entity class.

Inside the src folder create an BookEntity.js file that contains your Book Entity and Repository.

import { Entity, Schema } from 'redis-om';
import DBConnection  from './connection.js'

export class Book extends Entity {}

const BookSchema = new Schema(Book, {
    title: { type: 'string' },
    author: { type: 'string' },
    pages: { type: 'number' },
    publisher: { type: 'string' },
    publishedDate: { type: 'date' },
},{
    dataStructure: 'JSON'
});

export const BookRepository = DBConnection.fetchRepository(BookSchema)
await BookRepository.createIndex()

Lets create our Controller and Routes file. Inside the src folder create a BookController.js file. This file will be a class that will contain your CRUD methods.

import { BookRepository } from './BookEntity.js';

export default class BookController {

    // store book
    static store = async (req, res, next) => {
        try {
            const book = await BookRepository.createAndSave(req.body);

            return res.send({
                status: "successful",
                data: book
            }, 201)
        } catch (error) {
            return next(error)
        }
    }

    // fetch specified book
    static getBook = async (req, res, next) => {
        try {
            const book = await BookRepository.fetch(req.params.id)
            return res.send({
                status: "successful",
                data: book
            })
        }catch (error) {
            return next(error)
        }
    }

    // update book
    static update = async (req, res, next) => {
        try {
            const book = await BookRepository.fetch(req.params.id);
            book.title = req.body.title;
            book.author = req.body.author;
            book.pages = req.body.pages;
            book.publisher = req.body.publisher;
            book.publishedDate = req.body.publishedDate;
            await BookRepository.save(book);

            return res.send({
                status: "successful",
                data: book
            })
        } catch (error) {
            return next(error)
        }
    }

    // delete book
    static delete = async (req, res, next) => {
        try {
            const id = req.params.id
            const result = await BookRepository.remove(id);

            return res.send({
                status: "successful",
            }, 200)
        } catch (error) {
            return next(error)
        } 
    }
}

Let's set up our router with the necessary endpoints. Inside the src folder create a routes.js file. Remember your route file has been imported on the app.js file and it is bind to your Express app.

import express from 'express';
import BookController from './BookController.js';
import BookSearchController from './BookSearchController.js';

const router = express.Router();

router.post('/create', BookController.store)
router.get('/:id/book', BookController.getBook)
router.post('/:id/book', BookController.update)
router.delete('/:id/book', BookController.delete)

export default router;

Go to your terminal on the root folder of your project and enter this command yarn start or npm start to start your app. Open your Postman (or whatever tool you use to test or consume RESTful APIs) and test your endpoint.

RediSearch

Is time to carry out some search on your Book records including full-text search. The Search class contains five methods.

import { BookRepository } from './BookEntity.js';

export default class BookSearchController {
    // find all book records
    static findAll = async (req, res) => {
        const result = await BookRepository.search().return.all()
        return res.json(result)
    }

    // find all albums where the artist is 'Charles Dickens'
    static findByAuthor = async (req, res) => {
        const result = await BookRepository.search().where('author').equals('Charles Dickens').return.all()
        return res.json(result);
    }

    // find all books where publishedDate year is equal to 2022
    static findByYear = async (req, res) => {
        const result = await BookRepository.search().where('publishedDate').eq(2022).return.all()
        return res.json(result)
    }

    // find first record
    static findFirstRecord = async (req, res) => {
        const result  = await BookRepository.search().return.first()
        return res.json(result)
    }

    // count all book records
    static countAll = async (req, res) => {
        const result = await BookRepository.search().return.count()
        return res.json(result)
    }
}

Go to your routes.js file and bind your search methods to your Express router.

import express, { Router } from 'express';
import BookController from './BookController.js';
import BookSearchController from './BookSearchController.js';

const router = express.Router();

router.post('/create', BookController.store)
router.get('/:id/book', BookController.getBook)
router.post('/:id/book', BookController.update)
router.delete('/:id/book', BookController.delete)

// search routes
router.get('/search/count', BookSearchController.countAll)
router.get('/search/all', BookSearchController.findAll)
router.get('/search/:author', BookSearchController.findByAuthor)
router.get('/search/:year', BookSearchController.findByYear)
router.get('/search', BookSearchController.findFirstRecord)


export default router;

Your file structure should look like the one below if you followed my tutorial.

📦redis-book-libray
 ┣ 📂node_modules
 ┣ 📂src
 ┃ ┣ 📜BookController.js
 ┃ ┣ 📜BookEntity.js
 ┃ ┣ 📜BookSearchController.js
 ┃ ┣ 📜app.js
 ┃ ┣ 📜connection.js
 ┃ ┗ 📜routes.js
 ┣ 📜package.json
 ┗ 📜yarn.lock

Conclusion

You have learned how to use the Redis OM, NodeJs and Express framework to develop RESTful APIs

RESTful APIs using the Redis OM and NodeJs with Express framework. You can go ahead and create more Entities (E.g Publisher) to get acquainted with the Redis technologies. GitHub repository to the project.

This post is in collaboration with Redis

Try Redis Cloud for free

Redis Developer Hub - tools, guides, and tutorials about Redis

RedisInsight Desktop GUI

Watch this video on the benefits of Redis Cloud over other Redis providers

How To Store And Retrieve RedisJSON on Redis Cloud using Node.js

Tochukwu Adams — Sat, 25 Jun 2022 00:06:20 +0000

Image: linuxscriptshub.com

Overview

If you have been developing server-side applications that means you have been using some sort of database for storing and retrieving data. When it comes to picking a database most time our top priorities are speed and availability. Although there are other databases, of late, Redis has gained popularity when it comes to NoSQL databases.

In the past couple of months, I have been using the Redis database to manage some of my applications and as my applications scaled, I discovered I was utilizing more of Redis features. One of those features is the Redis Stack. Before we dive into the Redis Stack let me give a brief introduction to Redis and its importance.

What is Redis?

Redis is an open-source in-memory key/value pair database. This is to say that data-sets are stored in your RAM instead of your disk (SSD, HDD) in key and value format. Some of the pros of using Redis are its speed and high availability. If you are developing e-commerce, inventory, micro-services and speed is your priority then Redis is a better solution. You can use the Redis cloud database to manage your application due to its low latency and in-memory storage capabilities.

Redis Stack

Redis Stack is an extension of Redis that enables a user to create a data-driven application by providing dynamic data models making it easier for someone to create queryable objects. Redis Stack has different modules but in this tutorial, we will be utilizing the RedisJSON module. The RedisJSON modules allow storing and updating of data in JSON format.

Goal

The aim of this article is to learn how to use RedisJSON to store records in JSON format on a Redis Cloud database. For this project we will be creating a simple Node app that stores rider's details. So we have delivery men, and we want to store their records on our Redis cloud database.

Prerequisite:

You need, the following installed:
1. Node
2. YARN or NPM package installer

Let’s set up a Redis Cloud Database and connect it to our Node application, and like I mentioned earlier we will be utilizing one of the Redis Stack modules RedisJSON.

Redis Cloud

If you are asking why Redis Cloud? One of the cons of Redis is that data are store in memory which requires large RAM with Redis Enterprise Cloud you can store data in real-time in memory and still maintain persistence. Redis Cloud provides a multiple cloud platform (AWS, Azure, Google Cloud) where you can deploy your Redis dataset with ease without fear for data loss and it supports Redis commands and modules. If you are a newcomer to Redis Cloud you can use this link to create a free account. After creating an account, you will be assigned a free 30 MB storage or you can start a subscription plan.

Once you have setup a Redis Cloud account you will have an interface similar to the image below.

Environment Setup

Lets setup our Node app. Open your terminal or command line on your system, create a project directory or folder.

$ mkdir redisjson-node-js

After creating the project folder CD into the folder and create a package.json file with the command below. You can use YARN or NPM.

$ yarn init

Before creating a database connection on our app, we do need to install a Redis Client package. I am using the redis npm package. The Redis Client enables our app to interact with Redis server.

$ yarn add express

$ yarn add redis

Create a JavaScript file. You can name yours whatever you like.

$ touch index.js

Lets get our hands dirty!

const express = require('express')

// enables our application to interact with redis server
const { createClient } = require('redis');

const app = express();
app.use(express.json());

// database connection
const redis = createClient({
      // url: 'redis://default:Q*Y***H*q***l*rm**Sk**y*9@redis-*3*0*.c62.us-****-2-4.ec2.cloud.redislabs.com:*3*0*
    url: 'redis://username:password@host:port'
});
redis.on('connect', () => console.log('DB connected'));   
redis.on('error', (err) => console.log('Redis Connection Error', err));
redis.connect();

// at the bottom of the script
app.listen(3000, () => console.log('app is running on port 3000'));

How to get your Redis cloud database credentials:

Go to you account under configuration tab.

For username and password - scroll down to security session there lies your username and password

Host and port: On the General section, your public endpoint is your host and the digits after the colon is your port number.

The code below should be placed in between the database connection and app.listen function.

app.use('/home', (req, res) => {
    return res.send('welcome home');
});

// store rider details
app.post('/riders', async (req, res) => {

    const {first_name, last_name, email, coordinates} = req.body;
    // convert current date to milliseconds
    const date = Math.floor(Date.now() / 1000);

    // checks if the path exist
    const pathExist = await redis.json.type('employee');
    let rider;
    if (pathExist) {
        rider = await redis.json.arrAppend('employee', '.riders', 
        {
            first_name,
            last_name,
            email,
            coordinates,
            update_at: date
        }

        )
    }  else  {
        rider = await redis.json.set('employee', '$', {
            riders: [
            {
                first_name,
                last_name,
                email,
                coordinates,
                update_at: date

            }
        ]}
        )
        }

    return res.send({
        message: 'rider created successfully',
        data: rider
    });

});

// Get all riders
app.get('/riders', async (req, res) => {
    const rider = await redis.json.get('employee');
    return res.send(rider)
})

// at the bottom of the script
app.listen(3091, () => console.log('app is running on port 3091'));

Before storing the record we have to check if the path exist to avoid overriding existing records.

Commands

JSON.SET: Will creates a new path if it does not exist and add the values to a JSON object. If the path exists it will override the existing JSON value with the new values.

JSON.ARRAPPEND: Adds the JSON values to the end of the array.

JSON.TYPE: If the path does not exit it returns null.

JSON.GET: Fetches all the values on the specified path.

Conclusion

In this tutorial we have learnt how to create a Redis cloud database, store and retrieve records in JSON format using the RedisJSON stack modules and we have also seen the benefits of using Redis cloud to store our records.

Benefits of using using Redis Cloud

Redis Developer Hub

RedisInsight Desktop GUI

DEV Community: Tochukwu Adams

Fundamentals of Object-Oriented Programming

Key Players in OOP

4 Pillars Of OOP

OOP Languages

Benefits Of OOP

Conclusion

Related

Understanding Horizontal And Vertical Scaling: Pros And Cons

Horizontal And Vertical Scaling

Horizontal Scaling Implementation:

Vertical Scaling Implementation:

Pros of Horizontal Scaling:

Cons of Horizontal Scaling:

Pros of Vertical Scaling:

Cons of Vertical Scaling:

When to Apply Each Scaling Approach:

Conclusion:

Related

Redis: RedisInsight Installation on Ubuntu 20.04 & Redis Stack Server Docker Container Set Up

RedisInsight

Prerequisite

Docker Image

E.g

Redis Cloud

Related

Redis OM: Developer Experience using Node.Js

Redis OM

Goal

Prerequisite

Setup Redis Cloud Account

Project Setup

Database Credentials

RediSearch

Conclusion

Related

How To Store And Retrieve RedisJSON on Redis Cloud using Node.js

What is Redis?

Redis Stack

Goal

Prerequisite:

Redis Cloud

How to get your Redis cloud database credentials:

Commands

Related: