DEV Community: oluwatobi2001

Implementing a Visitor Counter on Azure Resume Challenge

oluwatobi2001 — Mon, 02 Sep 2024 00:53:31 +0000

Azure cloud resume challenge provides a thrilling journey for cloud enthusiasts and helps give you portfolio-worthy projects. You can get more details on how to get started here.
One of the major steps in completing the challenge involved completing and implementing a visitor counter that records the number of visitors to the website. This article details how I went about implementing this, the obstacles I faced and how I was able to circumvent them.
To follow along with this tutorial, here are some prerequisites.

Possession of an Azure account with an active subscription
Knowledge of Azure storage. (here is an article that discusses it in detail )
Familiarity with Azure Functions and Azure Cosmos DB.
JavaScript knowledge

With that, let's get started.

Brief intro

So far, I have completed the preceding steps in the Azure cloud challenge which is creating and deploying the Static resume on the Azure platform. I wrote a detailed article covering how I implemented it here.

Moving on to the next stage of the challenge which involved me implementing the visitor count API for my site, I decided to set it up using Azure Cosmos DB as the database of choice and Azure functions to execute concise serverless functions using JavaScript. My choice for a serverless stems from the increased efficiency and cost-effectiveness it provides. I also configured my front-end resume site to include the relevant JavaScript which consumes the API and implements a responsive frontend. I would highlight on the tools used in the next paragraph.

Azure Cosmos DB

Azure Cosmos Db is a cloud database made available by Azure. It's similar to the popular Dynamo DB used in AWS and Big Query in GCP. Azure Cosmos DB offers a wide variety of database options ranging from relational databases such as SQL to NoSQL database services. This provides us with the ability to store and update data directly to the cloud seamlessly and affordably.

Azure Functions

This is a serverless implementation of backend applications on the Azure platform. it's easily compatible with a lot of programming languages such as Node JS, .Net, Python, C# and others. These functions can also be configured to be invoked by several triggers such as HTTP requests, database updates etc.
Moving on, will be highlighting the process of setting up the visitor count API and then, integrate it to our frontend.

Setting up Azure Cosmos DB

On the Azure Portal home page, click on the navigation button and select Azure Cosmos DB. It will display an image similar to the one below.

Thereafter, click on the create button on the top of the page. In order to implement the project, we would be sticking with the Azure Cosmos DB for NoSQl. Also ensure to include the resource group for the Database. Its more preferred to have a single resource group managing all the applications involved in this project.

on successful creation of the database , navigate to the data explorer tab which allows us to easily configure the database properties.

While in the data explorer app, click on new container. This allows us to create a database id and a container id to store our data.

You would also be required to enter a partition key. This can be renamed based on your preference.

Thereafter, you would need to customize the items field to include the visitors count field.

{
"id": "item",
"count" : 0
}

Setting up Azure functions

To go on with the tutorial, we will now create the Azure function for this tutorial. Creating the function will require us to access the Azure function app directory which serves to manage the various Azure function apps. To successfully create the function application, navigate to Azure function apps and click on Create.

You would then be offered some plans for application hosting. For the sake of the tutorial, we would be sticking with the consumption plan.

Thereafter, enter a unique name for the function and select an appropriate Azure resource group. Also, select the runtime stack environment you are quite comfortable with. I intend to utilize Node JS to build the function environment.

On successful creation of the function app, you should see something similar to this.

Clicking on the Go to resource button leads us to the function app dashboard. Within the dashboard, kindly click on Create function.

We would then select the http trigger function. This method is adopted in our case, since we intend to communicate with our resume site via browser HTTP requests, we will then be utilizing the httpTrigger1 to serve as our function trigger.

In order to configure our server-less Azure function to interact seamlessly with our database, we need to navigate to the defined httpTrigger1 function and click on the integration tab.

We will click on the add input and add output tabs and then modify it to integrate our database with our function.
Within each tab, enter the database name and the collection name of the database we created. Also, ensure that a new database connection is created in each tab. This will ensure seamless connection with the database.

Upon successful completion, click on the function trigger tab and you will get access to the function dashboard. A default code will be available under the code*test tab.

Now to the main issue I faced in the building the application, I experienced a great deal of difficulty while trying to connect the database to the function due to a flaw in the default function.json code.

The function.json code by default stores the default configuration details needed for easy communicability amongst the function and database.
However, an upgrade from the Azure function version over time has invalidated some fields in the Azure function.json which ultimately led to the errors I experienced.
Here are the 2 fields in question

ConnectionString
collectionName
these two have subsequently been replaced with the connection and containerName strings respectively.

The code below contains the corrected version for the function.json code.

{
  "bindings": [
{
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
]
},
{
      "type": "http",
      "direction": "out",
      "name": "res"
},
{
      "name": "inputDocument",
      "direction": "in",
      "type": "cosmosDB",
      "methods": [],
      "databaseName": "views_db",
      "containerName": "tutorial-container",
      "connection": "tobi-tuts_DOCUMENTDB"
},
{
      "name": "outputDocument",
      "direction": "out",
      "type": "cosmosDB",
      "methods": [],
      "databaseName": "views_db",
      "containerName": "tutorial-container",
      "connection": "tobi-tuts_DOCUMENTDB"
}
]
}

On successful editing, save the function.json and test the code. If appropriately connected, a response code200 code is displayed.

Now we will go on to configure our Azure serverless function code to be executed.


module.exports = async function (context, req , data) {
    context.log('JavaScript HTTP trigger function processed a request.');

    context.bindings.outputDocument = data[0];
    context.bindings.outputDocument.count += 1;
    context.res = {
        // status: 200, /* Defaults to 200 */
        body: data[0].count
    };
}

In the code above, the binding database document is accessed and then updated. The total number of visitor counts stored in the database is then fetched and sent as a response message to the frontend. The visitor count is also updated to reflect the new number.

With that, we have completed the backend API of the application. Subsequently, we would be implementing the frontend to successfully seamlessly communicate with the backend API and update the database.
We will be creating a JS file to manage our fetch requests to the API and also based on the response received, modifies the HTML code to reflect the visitor number.
Here is the code below;

window.addEventListener('DOMContentLoaded', (e) => {
    getVisitorCount();
})
const myApiLink = {Your Azure function link};
const getVisitorCount =() => {
    let count = 0;
fetch(myApiLink , {
    mode: 'cors'
}).then(response => {
    return response.json() }
).then(res => {
const count = res;
document.getElementById('visitorCount').innerHTML = count;
})
return count;
}

The above code is the Frontend JavaScript code in order to retrieve the number of visits and also update the visitor count.

window.addEventListener('DOMContentLoaded', (e) => {
    getVisitorCount();
})

This ensures that the function getVisitorCount gets executed only after the Web page have been loaded. Also, we defined the ApiLink variable which is the URL of the Azure function we built in the preceding section. You can obtain this link on the functions dashboard.

const getVisitorCount =() => {
    let count = 0;
fetch(myApiLink , {
    mode: 'cors'
}).then(response => {
    return response.json() }
).then(res => {
const count = res;
document.getElementById('visitorCount').innerHTML = count;
})
return count;
}

The code above sets the preliminary count to 0. the fetch request is used to access the Azure function and the result obtained is then dynamically updated in the homepage.
With that, we have come to the end of the tutorial. You can check here to see the expected result.

Additional Info.

So far, we have implemented the Visitor count API on our resume project. You can further raise the challenge by only tracking unique visits to the site. This can be sorted by entering a representation of each visitor's IP to avoid counting each visit by a visitor multiple times. Additionally, you can experiment with the challenge by using other Azure storage accounts such as Azure file storage/object storage in place of Cosmos DB to obtain similar results.

Conclusion

You can also interact with me on my blog and check out my other articles here. Till next time, keep on coding!

Step-by-Step Guide: Hosting Static Webapps on Azure

oluwatobi2001 — Tue, 20 Aug 2024 16:39:08 +0000

Website hosting and deployment is a necessary aspect in overall web application development. It has become more popularized and simplified in the advent of new generation deployment sites. A wide variety of cloud infrastructure services also offers these features with additional benefits such as monitoring and scalability. Here, we will be exploring how to deploy a static website written in plain HTML & CSS on Microsoft Azure.

This article is a buildup from a similar article which illustrated how to deploy backend servers to Azure cloud via the use of the Visual Studio code extension.
Here are some prerequisites to follow along with this article.

An Azure Account
A webpage template to be deployed. You can get sample webpage templates here. With this, let's get started.

Setting up Azure account

To begin with, we need to have an Azure account created to be able to follow along and implement this tutorial. Azure offers a great advantage as it provides free Azure credits for its first 30 days. To create a free account, click on this link.

Setting up a Resource group

On completion of the sign up process, we now have access to the Azure portal which contains a wide variety of cloud services we intend to explore. we will then be creating a new resource group to help manage the static website we will be creating.

With the Resource group created, we will now create an Azure storage account to serve as a storage account for our website files. The Storage account can be accessed by searching for it on the Azure Market place.

The default storage of choice to host static website files is the Blob storage.

Setting up a Storage Account

After locating Azure storage on the marketplace, click on the Microsoft storage account and click on Create.
Microsoft Azure provides an easy-to-use platform to create our storage account.

In the column for the storage account name, the user's name choice can be entered. Also, it's advised to choose the closest region to you geographically in order to reduce storage query time. For the purpose of illustration, I selected the US East region. In other to guarantee application efficiency, kindly also ensure that the storage type is set to locally redundant storage. This ensures the consistent availability of your database files within your chosen local region.

You can leave all other tabs as default and then click on Review and Create and viola, your storage account is created.

In the above scenario, the storage account name was set to ty6. Any name of your choice can be used instead.
Now that we are done with creating the storage account, let's go on to deploy our Website files.

Before uploading your files to the storage account we just created, navigate to the data management section on the left and enable the static websites feature. Click on the enable icon and save.

.
Now that we have enabled the static website feature, navigate back to the storage account page to upload the HTML and CSS files of the website you intend to host.

Setting up the Static WebApp

On the screen, the upload button when clicked leads us to the page where our files can be uploaded. This also allows for multiple uploads at once.

On successful upload, specify the title of the home page within the column. In my case, it is titled index.html.

Thereafter, a link to the primary website endpoint will be generated and provided within the home page. Navigating to the link will show your hosted static site which can be accessed by anyone around the world. Here is a link to mine.

Conclusion

With that, we have come to the end of the tutorial. Feel free to check out my other articles here. Till next time, keep on coding!

Achieving Atomicity in Mongo DB Database operations

oluwatobi2001 — Tue, 13 Aug 2024 20:30:27 +0000

Databases play an integral role in the overall web architecture and it's important to store relevant server data to meet the needs of the users. Bearing this in mind, the developer needs to ensure that the database is optimized to work under the best practices available.
In this article, More details regarding Database Atomicity will be discussed and a demo project will be executed to illustrate this, Node JS and MongoDb will serve as our Backend server and database of choice. Here are some of the prerequisites for this tutorial.

Knowledge of MongoDB database
Knowledge of Node JS.

What is Atomicity?

Atomicity simply implies that any transaction performed on a given database exists as a single indivisible unit. It also means that the entire transaction will get aborted peradventure while executing the transaction, and an error occurs. The transaction however, gets executed if no error shows up while executing it. Contextually, transactions refer to database operations. The changes made in the database preceding the error get removed to its default status before the transaction is executed. These characteristics are one of the many important characteristics of an ideal database. More information regarding these best practices can be found in this article.

Real-life Use cases of Database Atomicity

It helps to prevent the occurrence of database transaction inefficiencies. A single database transaction may contain several operations waiting to be executed, most especially in cases of storing financial transactions involving debiting, crediting and storing transaction details as required. Having the atomic principle in place ensures that the overall changes to the database won't be made pending the successful completion of all functions within the transaction.
Right now we will be demonstrating how to implement atomicity in a MongoDB project with a controller function defined in our Demo banking application.

Implementing Atomicity in Mongo DB: Demo project

To set up the project, create an empty folder and initialize a node project within that folder by runningnpm init on the command line. Then, install relevant packages. Mongoose will serve as our node library to interact with our Mongo DB server. Thereafter, proceed to set up the project and ensure the MongoDB is connected to the Node JS application.

Here is the initial code to send money across to a receiver.

exports.sendMoney = async (req, res) => {
  const { recepientID, amount, pin } = req.body;
  const { emailAddress, id } = req.user;

  try {
    // Verify if the recipient account exists
    const verifyReceiver = await Account.findOne({ acctNo: recepientID });
    if (!verifyReceiver) {
      return res.status(400).json("Wrong account credentials, please recheck details");
    }

    // Verify the sender's account and balance
    const verifyBalance = await Account.findOne({ acctOwner: emailAddress });
    if (!verifyBalance) {
      return res.status(400).json("Sender account not found");
    }

    if (verifyBalance.acctBalance < amount) {
      return res.status(401).json("Insufficient funds, kindly top up your account in order to proceed");
    }

    if (verifyBalance.acctBalance === 0) {
      return res.status(400).json("Sorry, your account balance is too low.");
    }

    if (verifyBalance.acctPin !== pin) {
      return res.status(400).json("Incorrect Pin. Check and try again");
    }

    // Deduct amount from sender's balance and save
    const newBalance = verifyBalance.acctBalance - amount;
    verifyBalance.acctBalance = newBalance;
    await verifyBalance.save();

    // Add amount to receiver's balance and save
    const creditedBalance = verifyReceiver.acctBalance + amount;
    verifyReceiver.acctBalance = creditedBalance;
    await verifyReceiver.save();

    // Create transaction details
    const transactionDets = {
      amount,
      receiver: recepientID,
      sender: emailAddress,
      status: "successful"
    };
    const newTransaction = await Transaction.create(transactionDets);

    // Update sender's account with the transaction
    const updatedAccount = await Account.findByIdAndUpdate(
      verifyBalance._id,
      { $push: { transactions: newTransaction._id } },
      { new: true, useFindAndModify: false }
    );

    console.log(updatedAccount);

    return res.status(200).json("Transaction successful");

  } catch (err) {
    console.error(err);
    return res.status(500).json("Sorry, this transaction cannot be completed currently. Try again later");
  }
};

This code above is a mini representation of how a financial transaction is made when executed in Node JS. Via the use of the promise callbacks(async and await methods), it ensures orderly execution of the functions provided. However, in cases of errors in user input information or in the model schemas itself, the function when executed might not be completely successful and may return an `error 500 or 400` as the case may be.

Notwithstanding the error, some documents would have already been created giving room for the data inconsistency illustrated in the previous paragraph. Now how do we prevent this?

Thankfully, the Mongo DB database was built with the need to achieve the beast database optimization in mind. Here is how it solves the problem.

It easily fulfils database atomicity by the introducing Mongo DB sessions. A session in Mongo DB serves to group multiple executable entities together allowing the multiple functions to be executed as a single transaction. We will now discuss some functions that can be called to maintain the atomicity of a data transaction.

startSession
startTransaction
commitTransaction
abortTransaction
endSession

startSession: This function is usually called at the beginning of the function which encapsulates all operations within it as a single executable unit.
const session = await mongoose.startSession();

endSession: This is called at the end of the database operations to terminate a session opened.

session.endSession();

startTransaction: This function is invoked to begin execution of the transaction within the mongo DB session.

session.startTransaction();

commitTransaction: This function ensures that the entire database operation gets executed altogether. This function is usually called after all data operations have been called successfully without any error occurring.

session.commitTransaction();

abortTransaction: This function immediately cancels the entire transaction whenever it is executed. To ensure consistency and atomicity, it is best invoked while handling errors that may come up while executing the database operation. Appropriate knowledge and use of error handlers will come in handy here.

session.abortTransaction();

Here is the link to the complete code.

const mongoose = require('mongoose');

exports.sendMoney = async (req, res) => {

  const { recepientID, amount, pin } = req.body;

  const { emailAddress, id } = req.user;

// Start a session and a transaction

  const session = await mongoose.startSession();

  session.startTransaction();

try {

    // Verify if the recipient account exists

    const verifyReceiver = await Account.findOne({ acctNo: recepientID }).session(session);

    if (!verifyReceiver) {

      await session.abortTransaction();

      session.endSession();

      return res.status(400).json("Wrong account credentials, please recheck details");

    }

// Verify the sender's account and balance
const verifyBalance = await Account.findOne({ acctOwner: emailAddress }).session(session);
if (!verifyBalance) {
  await session.abortTransaction();
  session.endSession();
  return res.status(400).json("Sender account not found");
}

if (verifyBalance.acctBalance &lt; amount) {
  await session.abortTransaction();
  session.endSession();
  return res.status(401).json("Insufficient funds, kindly top up your account in order to proceed");
}

if (verifyBalance.acctBalance === 0) {
  await session.abortTransaction();
  session.endSession();
  return res.status(400).json("Sorry, your account balance is too low.");
}

if (verifyBalance.acctPin !== pin) {
  await session.abortTransaction();
  session.endSession();
  return res.status(400).json("Incorrect Pin. Check and try again");
}

// Deduct amount from the sender's balance and save
const newBalance = verifyBalance.acctBalance - amount;
verifyBalance.acctBalance = newBalance;
await verifyBalance.save({ session });

// Add the amount to the receiver's balance and save
const creditedBalance = verifyReceiver.acctBalance + amount;
verifyReceiver.acctBalance = creditedBalance;
await verifyReceiver.save({ session });

// Create transaction details
const transactionDets = {
  amount,
  receiver: recepientID,
  sender: emailAddress,
  status: "successful"
};
const newTransaction = await Transaction.create([transactionDets], { session });

// Update sender's account with the transaction
const updatedAccount = await Account.findByIdAndUpdate(
  verifyBalance._id,
  { $push: { transactions: newTransaction._id } },
  { new: true, useFindAndModify: false, session }
);

console.log(updatedAccount);

// Commit the transaction
await session.commitTransaction();
session.endSession();

return res.status(200).json("Transaction successful");



} catch (err) {

    // If an error occurs, abort the transaction and end the session

    await session.abortTransaction();

    session.endSession();

console.error(err);
return res.status(500).json("Sorry, this transaction cannot be completed currently. Try again later");



}

};

Additional information

So far, we have come to the end of the tutorial. Achieving database efficiency isn't just limited to Atomicity. Other key fundamentals such as Database indexing, sharding, and isolation will also be important to achieving this.

Feel free to check out my other articles here. Till next time, keep on coding!

A Beginners guide to Building Content Scripts

oluwatobi2001 — Sat, 27 Jul 2024 06:13:42 +0000

Browser extensions are add-ons to the browsers which are used to add aesthetics to the site and also provide optimal user experience.
The concept of content script in extension development is a quite useful knowledge to be acquired by developers alike as its significantly expanded the use cases of browser extensions.

This article aims to introduce what content scripts are and how they work. There would also be a demo project in which the basic of chrome extensions will be discussed and a simple content script will be used in our extension. With that, let's get started.

Understanding Content Scripts

First of all, what is a content script? Content scripts are JavaScript codes which on interaction with web pages via a browser extension, are executed to modify the webpage.

It easily achieves this by interacting with the webpage document object model. The web page document object model is the raw structure of the given web page. The manner by which the Chrome content scripts act to modify the web page in question is usually termed injection.

Having had a brief intro to content scripts, we would then go on to implement it on our web pages. But before then, we need to set up our browser extension which will power the script.

Setting Up Your Chrome Extension

Setting up a Chrome extension file is pretty straightforward. For further reference building extensions, attached below is the link to the Chrome extension documentation page.
An ideal Chrome extension must include a well-detailed manifest.json file which provides the default background information about the Chrome extension.
Also, the appropriate JS file to be executed is also included. Other additional files (HTML and CSS) help provide aesthetics to the extension.
With that, let's go on to build our extension, incorporating our content script injection. We will illustrate the power of content scripts by creating a Chrome extension which displays a button overlaying on any active web page we navigate to.

Writing a Manifest file

In this section, the parts of the manifest file will be highlighted and discussed. Here is the code to the manifest file for the project.



{
    "manifest_version": 3,
    "name": "Add Button",
    "version": "1.0",
    "description": "An extension that alerts a response when clicked",
    "permissions": ["activeTab"],
    "content_scripts": [
{
        "matches": ["<all_urls>"],
        "js": ["ContentScript.js"],
        "CSS": ["Button.css"]
}
]
}

Manifest version: The manifest version is usually requested. By default, it's set to 3. as it is a significant better upgrade than the version 2.
Name: The name of the extension is also typed in the manifest file. In my case, the project is named Add button. That can be tweaked to suit the user's preference.
The Version of the Chrome extension is also inputted. In our case, this is the first version of the extension hence it's named 1.0, subsequent improvements on this extension can prompt modifying the file to increase the versions respectively.
Description: A description of what the extension does also gives credence to the Chrome extension to the non-technical users of the extension.

Subsequent points raised are quite cogent in building the content scripts.

The permissions object highlights the route for the execution of the content scripts. This also prevents the content scripts from running in unexpected tabs and web pages. It allows us to list all the permissions our Chrome extension might require. Some Chrome extensions may need access to the browser storage, other Chrome APIs and some sites in question. In our case for this project, we are limiting our Chrome extension to just the active browser tab being used. It's important to have this in place to reduce the risk of Chrome extension compromising other non-used parts of our Chrome browser.

We will then configure the content scripts field in our manifest file.
The content scripts field specifies the various code files we intend to inject into our web page.
It contains the matches sub field which specifies the webpage URL we want it to act upon. For ease of use, we just included all URLs allowing this to act on all web pages we access. You can however specify the URL you intend to inject in the subfield value. Eg www.google.com,



"matches": ["https://*.google.com/*"]
run_at": "document_idle

The JS files which contain the injection code are also specified. In our case,
Our JS file is named Content script.js. We also specified the CSS file used in styling this project.

With this, we have had a miniature implementation of the manifest file for our project. We will then go on to write our injection code in the subsequent section

Creating Content Scripts

In the spirit of keeping things simple, we would be creating a simple button that when clicked upon, shows an alert message. This button is expected to overlay the existing webpage.
Here is the code below



// Create a button element
const button = document.createElement("button");

// Set the button's text content
button.textContent = "Click me";

// Set the button's ID
button.id = "clickMe";

// Append the button to the document body
document.body.appendChild(button);

// Add a click event listener to the button
button.addEventListener("click", () => {
  // Show an alert when the button is clicked
  alert("Click event listener was added");

  // Log a message to the console
  console.log("Hello world");
});

The styling can be changed to suit your preference however a styling template has been included in the code repository.

here is a picture of its implementation.

Here is the link to the source code containing the code styling.

Advanced Techniques and Use Cases

So far we have completed the project. However to advance one's knowledge, here are some of the advanced techniques and best practices you can also implement while building content scripts.

Cross-interaction with browser background scripts
Implementation of data state managers to allow for dynamic scripting
Integrating other external APIs allows for data manipulation and analysis
Employing caching strategies in order to optimize extension performance
Integrating Content scripts with service workers

Conclusion

You can also interact with me on my blog and check out my other articles here. Till next time, keep on coding!

Mastering Linux: Easy Tips for Locating Files Folders and Text

oluwatobi2001 — Thu, 06 Jun 2024 21:50:51 +0000

Introduction

I see a world where every device will utilize Linux in the nearest future. It’s currently the driving force for open-source development globally and it’s cemented its relevance in today’s world as it is the backbone of many applications and services. Apt knowledge of the use of this operating system and ability to execute programs with it gives the developer an advantage.
This article which is the first of many, serves as to guide the developer on how to perform basic search commands using Linux. This is needed to locate file directories and texts.
As a popular programmer stated, the best way to learn Linux is to use it. Having Linux installed and running is a prerequisite to this tutorial so facilitate easy comprehension and practice. With this completed, let’s get started.

Linux search commands

Searching for files can be cumbersome and complex for the newbie Linux user especially as it’s a sharp contrast from the Windows OS. Thankfully, newer Linux distros include beautiful graphical user interfaces to enhance user interaction and experience on Linux but still, the mastery of Linux search commands via the command line is still relevant, hence the need for this tutorial. Right now we will be introducing the various Linux commands that are used in files and text searches. They include

Locate
find
Grep

The find and locate commands are specifically designed in the search for files and directories within the Linux file system while the Grep is more suited to locate texts within various text files in the Linux file system. Details regarding their use cases and relevant examples will be provided in the subsequent sections.

Locate command

This command alongside the find command mentioned earlier is used to search for files using the file names within the Linux file system directories but how is this command different from the find command seeing that they are quite synonymous?
Firstly, the Locate command is executed to locate the details of a file being searched from a database of filenames which is updated automatically daily.
This implies it has a faster search time than the find command. However, it has a minor flaw in that the data only gets updated at a specified time daily or when executed. Hence files saved after the database has been updated at a particular time won’t be shown in the search results.
Here is a command to search for the file “laptop.txt” using locate.
Locate laptop

As you an see, the file name is been searched from the plocate db which doesn't have the file name indexed.
With that, we have successfully discussed the locate command. Up next is the find command

Find Command

The find command as highlighted briefly in the previous paragraph can also be used to locate file names within a given directory. However, unlike the locate command which searches through an indexed database containing filenames, the find command searches through the entire Linux file system to locate the files in question. This results in a much slower response time compared to the locate command. However, it has an advantage over the locate command by providing all files matching the search query at any time indicated irrespective of the time the file was saved unlike the locate command.
Here is a command to search for the file “laptop.txt” using find.
Find laptop

Grep

This is a command used in Linux to search for words/phrases within various text file outputs. It’s an acronym which stands for Global regular expression print. It goes beyond locating the files which contain the text in question but also highlights the lines where these texts are found. Here is an example of how Grep can be used.
grep laptop

The above code searches for the text “laptop” in the Linux directory. It then outputs any files where this can be found. By default, the Grep command is highly case-sensitive, matching the texts only in the specified case format. However, due to its inherent flexibility, it can also output non-case-sensitive matches too. To achieve this, the –I command is added to the line text.
Here is a command to search for the text “laptop” eliminating the case sensitivity using grep.
grep –i laptop laptop.txt

This will output all matching text ignoring the case format of the text matches.
Also, Grep provides an inverse searching feature which highlights all other lines without the text to be matched in question and ignores the lines containing the text being matched in question.

grep –vi laptop
So far, these commands can be used to navigate through the Linux file directory to locate various files and text within the Linux OS. It is also essential to gain mastery of other Linux file commands such as ls, mv, rm and rmdir which can be used in file navigation and file structure modification.

Conclusion

With this, we have come to the end of the tutorial. We hope you’ve learned essentially about Linux commands, how to use them and their pros and cons. Feel free to drop any questions or comments in the comment box below. You can also reach out to me on my blog also check out my other articles here. Till next time, keep on coding!

Optimizing Performance Using Prometheus with Node JS for Monitoring

oluwatobi2001 — Tue, 30 Apr 2024 18:25:35 +0000

Application performance monitoring is an essential hack you as a developer should get acquainted with to detect any error and provide a seamless experience to the end user of the service.
However, to achieve this, it’s quite needed to possess adequate knowledge of some Application monitoring tools.

In this article, we will be talking about The Prometheus tool, its use cases, and its relevance to backend development. Furthermore, we will be looking into integrating it into our Backend application, via the use of several packages and we will also test its functionality.
Additionally, we would chip in on how to generate meaningful insights from our scraped metrics with Prometheus using a tool called Grafana. Having laid out our objectives, let’s get started.
Before moving on to this tutorial, here are some prerequisites
needed to understand this tutorial efficiently.

Firstly, you need to have at least basic to intermediate knowledge of Node JS
Understand and ability to use NPM

What is Prometheus?

Prometheus is an open-source system monitoring and observability tool invented in the year 2012. It provides monitoring, observability and alerting features for both cloud services and backend applications. It also works on the principle of querying various endpoints and generating various data matrices which are then stored and can be analyzed to monitor for application and cloud performance.
It provides client libraries across several programming languages providing ease of Application integration. It also provides an Admin dashboard where various data are queried and scraped from an application and cloud operations are collected. Its Alert features also notify the application developer in case of an occurrence of any anomaly in the application metrics.
Additionally; it possesses an advanced feature known as the PROMQL (Prometheus query language) which allows the developer to use advanced queries to generate data commands for appropriate analysis and the generation of measurable information insights. Right now, we will be integrating Prometheus into our sample backend application which is a Node JS application powered by the Express framework. It is important to have the software already set up before proceeding to the subsequent sections. Here is a link to the Prometheus tool.

After completing your installation, initialize a default Node JS application and then install the necessary server dependencies.

Prometheus Client packages for Node JS

Prometheus as mentioned earlier provides various client packages across various languages and Node JS isn’t left out. Currently, here are some of the most popular Prometheus client packages available for Node JS.

However, for this tutorial, the Prom-client package will be used as it has user-friendly documentation, a large user base and strong community support. Here is a link to its documentation and npm page.

Node JS integration with Prometheus

To integrate the Prometheus metrics tracking feature into our Node JS application, we would have to install the prom-client package
npm i prom-client
On successful completion of this step, we will then be initializing the prom client in our code base.
Navigating to the index.js page, and prom client can be initialized by



const client =require(“prom-client”)

With this, we have successfully initialized Prometheus into our Node JS project. Subsequently, we would be setting it up to collect relevant metrics and also learn about some of its specific metric features.

Tracking metrics using Prometheus

Prometheus provides the user with the flexibility to collect routine Backend application service metrics via the use of its CollectDefaultMetrics feature. It also empowers the user to design unique customized metric collection functions which helps the user assess the application performance more reliably.
To collect routine application metrics, the code below can be used.



const register = new client.Registry();
const collectDefaultMetrics = client.collectDefaultMetrics;

collectDefaultMetrics({
    register
});

The above code initializes the Prometheus registry which serves as a state/container that holds all metrics to be collected from the application.

With this properly configured, we have successfully implemented the default metrics collection feature. To access the metrics collected, an endpoint would have to be created which when accessed, would provide all metrics scraped per time. This can easily be created below.



app.get("/metrics", async (req, res) => {
    res.setHeader("Content-Type", client.register.contentType);
    let metrics = await register.metrics();
    res.send(metrics);
});

Accessing this endpoint "/metrics", will reveal all the scraped metrics collected. We would then go on to create customizable specific application metrics to be scraped by the Prometheus library.
Here is the code below. on how to create custom metrics.



const http_request_counter = new client.Counter({
    name: 'myapp_http_request_count',
    help: 'Count of HTTP requests',
    labelNames: ['method', 'route', 'statusCode']
});

register.registerMetric(http_request_counter);

app.use("/*", function(req, res, next) {
    http_request_counter.labels({
        method: req.method,
        route: req.originalUrl,
        statusCode: res.statusCode
    }).inc();
    console.log(register.metrics());
    next();
});

in the code above, we created a request counter metric. This counter will automatically increase by 1 whenever we access any endpoint in our backend application. Also included is the name assigned to the custom metrics and the parameters to be collected such as the route, the request method and the status code of the request.

Here is the final code for the project.



// Import required modules
const express = require("express");
const client = require("prom-client");
const bodyParser = require("body-parser");
const cors = require("cors");
const connectDB = require("./Config/db");

// Create an Express application
const app = express();

// Initialize Prometheus registry
const register = new client.Registry();

// Configure default Prometheus labels
register.setDefaultLabels({
    app: "blue",
});

// Define Prometheus metrics
const http_request_counter = new client.Counter({
    name: 'myapp_http_request_count',
    help: 'Count of HTTP requests',
    labelNames: ['method', 'route', 'statusCode']
});
const userCounter = new client.Counter({
    name: "user_counter",
    help: "User counter for my application"
});

// Register Prometheus metrics with the registry
register.registerMetric(http_request_counter);
register.registerMetric(userCounter);

// Middleware to collect and expose Prometheus metrics
app.get("/metrics", async (req, res) => {
    res.setHeader("Content-Type", client.register.contentType);
    let metrics = await register.metrics();
    res.send(metrics);
});

// Middleware to increment user counter for all routes
app.get("/*", (req, res) => {
    userCounter.inc();
    console.log(register.metrics());
    res.send("test");
});

// Middleware to count HTTP requests and log metrics
app.use("/*", function(req, res, next) {
    http_request_counter.labels({
        method: req.method,
        route: req.originalUrl,
        statusCode: res.statusCode
    }).inc();
    console.log(register.metrics());
    next();
});

// Collect default Prometheus metrics (e.g., CPU, memory)
client.collectDefaultMetrics({
    register
});

// Define a Prometheus histogram for response time
const restResponseTimeHistogram = new client.Histogram({
    name: 'rest_response_time_duration_seconds',
    help: 'REST API response time in seconds',
    labelNames: ['method', 'route', 'status_code']
});

// Enable CORS for all routes
app.use(cors({
    origin: '*',
}));

// Parse JSON requests
app.use(express.json());
app.use(bodyParser.json());

// Connect to the database
connectDB();

// Start the server
app.listen(process.env.PORT || 5000, () => {
    console.log("Server is running...");
});

Here is the endpoint showing the application metrics scraped by Prom-client.

With this, we have completed the basics of Prometheus integration with Node JS. Other advanced concepts in Prometheus would further help the developer to create complex relevant metrics registers using the prom client tool.

Additional info (Exploring Grafana)

Obtaining your metrics from your backend service application shouldn’t be all that there is to be. As beautiful as Prometheus is, it is also limited in quite several features of which data visualization is among. Here comes Grafana to the rescue.
The Grafana tool is a data visualization tool that generates meaningful readable insights from the queried metric raw data obtained from Prometheus. You can check out their documentation here and download the tool here for your respective Operating systems. You can also check out tutorials on how to integrate both Prometheus and Grafana.

Conclusion

With this, we have come to the end of the tutorial. We hope you’ve learned essentially about Prometheus, its uses and how to integrate into a backend application for efficient monitoring of application performance.
Feel free to drop comments and questions in the box below, and also check out my other articles here. Till next time, keep on coding!

Common Security Vulnerabilities in the Blockchain World

oluwatobi2001 — Wed, 03 Apr 2024 17:59:03 +0000

The Blockchain has in no small measure posed a worthy replacement to the traditional banking system, liberalizing access to wealth and enlightening the masses on asset creation and financial intelligence. This and many more have made Blockchain and its services gain so much popularity in recent times with over a million transactions being performed on the Blockchain every second. Not to ignore the fact that Blockchain allows for the easy movement of assets and money across geographical barriers faced by traditional banking thereby eliminating additional fees.
However, the Blockchain sector does not exist with its deficiencies. Due to its decentralized and liberalized structures, quite a lot of fraudulent malicious activities get on daily leaving little or no trace. Not too long ago, a major crypto currency exchange went bankrupt due to a backdoor found on their Blockchain resulting in a loss of user funds and rendering a lot of families penniless. All these and many more are some of the concerns of the Blockchain industry.
With financial experts predicting that Blockchain will in no distant time replace the fiat currency and with countries like El Salvador already adopting cryptocurrency as legal tender, the future seems bright for the Blockchain industry, but with these security threats, can the stability of the Blockchain and the eventual expansion of the Blockchain market be hampered with?

This article aims to highlight common security threats and loopholes present in the blockchain industry and the principles behind such attacks. Awareness of these forms of attacks and taking pre-emptive measures to prevent these would prove beneficial in the long run and help build consumer trust. With this, let's get started.

Double Spending

The concept of double spending is routinely faced upon the creation of a new Blockchain protocol or web3 Dapps, Funny as it sounds, what does double spending mean? This is when the user maliciously exploits errors in the system to spend the same unit of cryptocurrency more than once on a blockchain protocol. Tackling this can be quite cumbersome as it involves the use of highly secured cryptographic algorithms and other systems to gauge the system and eliminate such. Failure to do so could ultimately result in loss of user trust in the blockchain and incurring losses on the part of the managers. An example of this attack was occurred in 2019/20, famously tagged the 51% attack on the Ethereum classic network.

Sybil Attack

This attack involves a group of malicious entities trying to take control of an entire blockchain
service by creating multiple nodes with malicious functions. This often results in blockchain manipulations and draining financial losses. The presence of multiple nodes in the user blockchain could also pose a risk to user identity as they tend to intercept user details and IP addresses increasing user distrust in the blockchain. The result of these, attacks is to achieve what is popularly known in the blockchain security space as the 51% attack. This involves controlling more than 50% of the blockchain network. In 2018, the Verge (XVG) and Bitcoin Gold (BTG) were affected by the Sybil attack resulting in heavy losses.

Distributed Denial-of-Service (DDoS) Attack

Distributed denial of service is a common cause of concern in the web2 space and this isn’t any different in the blockchain although unlike in the web2 space in which DDoS usually results in the slowing down of website function, the blockchain, due to its decentralized model has a form of immunity against that. This form of attack involves massive flooding of the blockchain protocol with spam transaction information, congesting the ledger network and delaying the completion of legitimate blockchain transactions. This also builds up user distrust and defeats the entire purpose for which blockchain is built.
Also, The DDoS attack may be launched at smart contracts creating parasitic contracts which delay the execution of other contracts. Solana and Arbitrum have also been under DDOS attacks in the past.

Eclipse Attack

This form of attack entails the isolation of a specific node within a decentralized system surrounding it with malicious nodes and exploiting its connections with other nodes to manipulate blockchain transactions. This can be achieved by flooding the nodes with several requests, forcing the node to connect to these malicious bots and injecting malicious codes into the node thereby disrupting the blockchain

Timestamp Manipulation

Every blockchain transaction is attached to a timestamp which represents the time the transaction was performed. However, as seemingly harmless as this seems, it can serve as an access point of vulnerability to the blockchain by hackers. It involves manipulating the timestamp of a block, disrupting the sequence of the smart contract execution, and ensuring the execution of irrelevant smart contracts congesting the system which drain the blockchain resources. A good example of this is the DAO attack on the Ethereum blockchain.
These examples highlight the need for the blockchain developer to be aware of these vulnerability mechanisms’ and properly build secured and efficient blockchain protocols and services

With this, we have come to the end of the article. Feel free to drop any questions or comments in the comment box below. Till next time, keep on innovating!

OPTICAL CHARACTER RECOGNITION USING NODE JS AND TESSERACT OCR ENGINE

oluwatobi2001 — Mon, 11 Mar 2024 11:42:07 +0000

Introduction

What then is optical character recognition? Optical character recognition involves converting the age of a text into readable text formats. This is possible due to the increasing technological advances resulting in the development of several optical character recognition tools and models.
You might now ask, what is the benefit of this to me? Optical character recognition is a technological innovation borne out of necessity to help solve recurring problems for individuals and businesses worldwide. Technology has caused a massive shift from the analogue process of doing things to a more digital, automated format of operation.

This entails that for businesses to thrive, they must adapt to these new realities or risk being phased out. But the big problem is that quite a lot of the business operations are already in analogue formats, and transcribing them to digital formats would be less cost-effective and less efficient.

Hence, optical character recognition comes to the rescue. This seamlessly extracts the texts from the scanned images, eliminating the time lost in transcribing these documents.

Also, optical character recognition has its use cases in other fields of technology, such as data analysis and visualization, enabling efficient data utilization. These help and serve as an aid to business owners in ensuring high cost-effective productivity and efficiency. Not to be left out, the finance sector utilizes this technology to facilitate payments virtually and ensure seamless financial transactions. All these and many more are some of the use cases of optical character recognition.
In this tutorial, I intend to illustrate how to set up an easy-to-use character recognition application with Node JS serving as the backend and React JS as the frontend tool.

To be able to enjoy this tutorial, here are some prerequisites:.
• Intermediate knowledge of Node JS
• Knowledge of Git and Github
• Knowledge of React JS

Optical Character Recognition Engines Available

Before diving in, here are some of the most popularly used optical recognition tools.
• Amazon Textract
• Google Document AI
• IBM DataCap
• DocParser
• CamScanner
• Abbyy
• Base64.ai
And many more. However, for the tutorial, we would be using the Tesseract OCR engine due to its open source, good documentation, and support for Node JS, among other reasons. We would now proceed to delve deep into Tesseract.

A brief intro to Tesseract

Tesseract is an open-source optical character recognition engine and is often revered as the first Optical Character Recognition tool ever made. It was created by HP in 1984, maintained by Google until 2018 and is currently being maintained by its users community. It is currently available in executable formats across various operating systems across the globe. It offers character recognition services for over 100 languages, among which English, French, German, and Spanish are available. The latest version is version 5.3.0.

Setting Up and Installation

To harness this tutorial, we would need to set the required file structures in place. First of all, we need to download and install the Tesseract OCR engine on our local Personal computer. To complete this, I would recommend its documentation site. You can pick your choice based on your operating system specifications. For Windows users, after installing the OCR engine, which can be downloaded from this link, the folder path must be added to the environmental variables for it to be effectively run via the command prompt. For Linux and Mac OS users, you can also get to install Tesseract via this link. With this solved, let's now dive into the tutorial proper.

Demo Project

We intend to build a web application that integrates Tesseract engine to provide the optical recognition feature to the user. The web application will be designed with Node.js Express serving as the backend tool, and React JS serving as the frontend library. To save time, we would delve into the backend functionality and briefly discuss the frontend aspect of the project. Now let's dive in.
First of all, ensure to create your Frontend and Backend code folders respectively. Navigate to the backend folder and then install Node-tesseract-ocr, express, and multer libraries
Npm I Node-tesseract-ocr express multer.
NodeJs Tesseract OCR serves as the Node JS implementation for the Tesseract engine. Multer helps with efficient parsing and storage of the uploaded images used in this tutorial, while Express serves as a great framework for the Node JS server.
After completing this, in your index.js page, initialize the packages installed by importing them as follows:

const express = require("express");
const app = express()
const multer = require("multer")
const tesseract = require("node-tesseract-ocr");

Thereafter, we would be providing a configuration file for Tesseract. This involves providing a config file with the following code.

const config = {
    lang: 'eng',
    oem: 1,
    psm: 3
}

This config file specifies the language intended to be recognized, in this case, English. As mentioned earlier, Tesseract provides language support for over 100 languages, so this can be tweaked to fit the specific language you are interested in.
The oem represents the OCR engine modes available. So far, there are 2 models in the recent updates: Model 1 represents the legacy model, while Engine 2 represents the neural net LSTM model engine. However, you can choose from 4 model operations, with 0 representing legacy engine, 1 representing neural nets LSTM only, 2 representing a combo of the 2 above, and 3 being the default mode. The page segmentation mode (PSM) is based on the region of the image you intend to recognize optically. It ranges from 1 to 14 modes, but we would stick to 3 (default) as we don’t specify the region of the image to be transcribed.
Thereafter, we would be setting up Express and Multer to handle the images uploaded from the frontend site to the server.

app.use("/uploads", express.static(path.join(__dirname, "/uploads")))

var storage = multer.diskStorage({
    destination: (req, file, cb) => {
        cb(null, 'uploads/')
    },
    filename: (req, file, cb) => {
        cb(null,     file.originalname )
    },

})

const upload = multer({
    storage: storage
})
;

Now, we would be writing a post request that invokes Tesseract to analyze the pictures obtained from the front end.

app.post("/img-upload", upload,single("file"), (req, res) => {
const file = req.file.filename;
    tesseract.recognize(file, config). then((text) => {
console.log("text: " + text);
        res.status(200).json(text)
}).catch((err) => {
        console.log(err)
        res.status(500).json(err)
})

})
app.listen("5000", () => {
console.log("Hello")
});

In the function above, a post request is created with the endpoint set to img-upload and the file accessed. Tesseract, which is already initialized, is invoked to recognize the image with the configuration file passed along. The text obtained from this is then sent to the frontend to be seen. Any error during this process would be caught and also shown.
Here is a result of what was expected.

Attached below is the final code for the backend of this project.

const express =  require("express");
const app = express()
const multer  = require("multer")
const tesseract  =  require("node-tesseract-ocr");
const path= require("path");
const cors = require("cors");

app.use(cors({
    origin: 'http://localhost:5173',
    mathods: ['GET', 'POST']
    }))

app.use(express.json());
app.use("/uploads", express.static(path.join(__dirname, "/uploads")))

var storage = multer.diskStorage({
    destination: (req, file, cb) => {
        cb(null, 'uploads/')
    },
    filename: (req, file, cb) => {
        cb(null,     file.originalname )
    },

})

const upload = multer({
    storage: storage
})
;
const config = {
    lang: 'eng',
    oem: 1,
    psm: 3
}
app.post("/img-upload", upload.single('file'), (req, res) => {
    const file  = req.file.filename;
    tesseract.recognize(`uploads/${file}`, config).then((text) => {
        console.log("text: " + text);
        res.status(200).json(text)
    }).catch((err) => {
        console.log(err)
        res.status(500).json(err)
    })

})
app.listen("5000", () => {
console.log("Hello")
});

The frontend was minimally designed to test the functionality of the application and to upload the images to be transcribed. Here is a picture of the frontend screen.

You can click here for the code to the frontend design of this project.

Additional Information And Improvements

So far so good, we have come to the end of the tutorial. Utilizing cloud platform providers and tools like Docker would further help to seamlessly run the application on the cloud. This OCR technology can also be harnessed and integrated with data science to aid in data processing and visualization. Moreover, the texts can also be stored in a database of choice for further processing.

Conclusion

I sincerely hope you’ve learnt about optical character recognition using Node JS and Tesseract OCR engine and its successful implementation to help improve our day-to-day activities.
Feel free to drop comments and questions, and also check out my other educational tech articles here. Till next time, keep on coding!

Introduction to Cloud Computing: The Models, Benefits, Risks, Implementation and Popular Tools

oluwatobi2001 — Wed, 06 Mar 2024 21:14:34 +0000

Introduction

The breakthrough in technological innovations is probably one of the major milestones recorded in the 20th century. Decades ago, larger less efficient mainframe computer systems which were expensive to maintain and rare to find were in vogue but currently, everyone seems to be talking about cloud computing. Over the years, some major industries experienced massive growth, resulting in increased users and therefore an increased need to further expand their operations to cater for these users. The physical server option had quite a lot of deficiencies thereby prompting the popularization of Cloud computing and its related operations in our world today. But what is cloud computing and what benefits does it have in today's world?
Cloud computing can be explained as a virtual-based technology which involves data storage and computation over the internet without direct active physical management by the user. It entails the use of servers, software and database management systems over the Internet.

This article aims to serve as a guide to beginners interested in the field of Cloud development and networking. Details regarding various models and implementations of cloud computing will be discussed. Also, its benefits and associated risks will be highlighted. As a bonus, tools which you can use to become a high-demand cloud developer will also be introduced here. Now, let's begin.

Brief Roadmap into Cloud Computing

Just as described earlier, cloud computing works by providing easy access to cloud services and data over the internet to the user's devices. It works via the User Device => Server => Database. The server coordinates the requests made from the individual's devices and then through its connectivity, retrieves the relevant information from the database. This system also involves the use of automation tools which eliminates the need for a response from a physical staff to generate the needed resources and reduce server request loads efficiently.

Models of Cloud computing services

Cloud computing in its entirety is complex and largely comprehensive and cuts across several use cases. However, for ease of learning, most cloud computing platforms can be grouped into 3 major categories. These include;

Infrastructure –As-A-Service

This category entails the provision of all Computing services options which range from and not limited to Virtual Servers, Virtual operating systems, Storage options and application programming interfaces. However in this model, the user is expected to perform hardcore operations to ensure the user’s server gets powered up on the cloud. Amazon AWS, Microsoft Azure, Google Cloud Platform and IBM Cloud are popular examples in this category.

Platform-As-A-Service

This category provides a platform to allow for virtual software creation through the use of its development tools and its associated features. In this model of cloud computing, the user is only tasked with the code creation aspect while the cloud service provider is tasked with the responsibility of maintaining the software development platform and the site infrastructure. This model also provides web hosting services for this software. Google App Engine, Heroku, and Salesforce are key leaders in this category

Software-As-A-Service

This category entails the cloud platform providers providing software applications over the Internet alongside the necessary infrastructure to maintain it. This is usually termed web services. Internet users can easily access this software not regarding geographical location and device used. Microsoft 365 and Google Workspace are a great example of this category.

Benefits of Cloud Computing

Cloud computing due to its massive influx of users and its worldwide adoption seems to have some benefits. What are the benefits it offers to its users?

Cost-effectiveness: Cloud computing technology has been proven to be highly cost-effective, providing easy access to software services and eliminating the need for maintenance of physical server costs and other physical miscellaneous expenses. With most services offering a Pay-as-you-go model of payment, Users are only required to pay for the services they use without having to be billed for services not utilized. All these contribute to maximizing profits and minimizing losses.

Enhanced storage capability: Physical Database Management is quite limited and often demands continual upgrading which isn’t cost-friendly. In great contrast, Cloud Computing has in recent times been the best alternative to storing data. With so many web platforms offering cheap data storage options, problems regarding storage backup in recent times have been widely eliminated.

Data Mobility: Compared to building physical data storage centers and physical servers for your application, the cloud helps you to easily set this up for a less expensive cost and also achieve an equal or even higher level of efficiency. Its comparative advantage lies in the fact that the data stored in cloud is easily mobile and can be accessed at anytime anywhere around the world with reduced latency speed compared to the use of physical servers. Also, in case of natural or man-made disasters, cloud operations are more immune compared to their physical counterpart as it has additional data duplication features that help minimize data losses.

Efficient data processing: With features such as load balancing, scaling optimization and availability zones, the Cloud as a whole ensures the overall efficiency of your hosted application. The scaling optimization allows it to automatically detect increased or decreased site activity and adjust appropriately automatically In response to the activity to ensure and facilitate the efficiency of site usage and data processing.

Risks Seen in Cloud Computing

Hacking concerns: As safe as the cloud seems, there also seem to be concerns about the efficiency of the security the cloud platforms provide especially in the new wave of data breaches and data losses of recent. Hence, some people are still wary of entrusting the storage of sensitive data to a 3rd party. However, most cloud platforms have an efficient cloud security system in place to avoid this.

Technical expertise: Cloud development is a relatively new field with a thousand different tools to learn across several niches and use cases. Quite not unusual, the cloud market is quite unsaturated as there are fewer certified cloud experts compared to other fields thereby putting them in high demand. Hence getting a cloud developer can be quite cumbersome.

Implementing Cloud Computing

The world is ever evolving and applications that would remain relevant would have to adjust to the current realities or risk of being phased out.

Having exhausted the pros and cons of Cloud development, how do we go about implementing cloud computing in our application development? The process of implantation entails proper planning and brainstorming. Not all applications however do need cloud computing but for those that may need it, adequate research on platforms that best fit your company operation, have favorable economics of scale and have a good ease of usage should be considered.
Also, the choice of the cloud model should be made depending on the features the user wants and the level of user expertise.
Developing a long-term plan for cloud usage is also essential to ensure sustainability and guarantee efficiency. Lastly, periodic upgrades and improvements to ensure optimal cloud security and monitor efficiency should be carried out.

Top Cloud Computing Providers

Here are some of the popular cloud computing service providers available worldwide.
• Amazon Web Services
• Microsoft Azure
• Google Cloud Platform
• Alibaba Cloud
• Oracle cloud infrastructure and many more.

Quite a lot offers certification examinations and training programs which you as a beginner can take advantage of in your journey to cloud development.

Conclusion

With this, we have come to the end of this article. I hope you’ve learnt about the nitty-gritty of Cloud computing and its benefits to you as a developer.
Feel free to drop comments and questions and also check out my other articles here. Till next time, keep on coding!

Mastering PDF Creation: The Ultimate Guide to Using PDFKit and Node JS

oluwatobi2001 — Fri, 01 Mar 2024 23:41:09 +0000

The world has been evolving rapidly and technology isn’t left out. From the days when slates were used, down to the invention of hard-cover books and pens and now in the area of smart electronic devices, the need to pass information from one entit...

Optimizing The Performance of Web Applications With Jest

oluwatobi2001 — Wed, 21 Feb 2024 15:43:33 +0000

Performance testing is an encompassing yet underrated field of software development and it’s a must-have skill as a software developer to prevent common software failure issues that occur among production applications. It is a routine software practice which is carried out to determine the stability of a system in terms of scalability, reliability and data management amongst other parameters.

In this tutorial, I hope to walk you through Performance testing, what it entails, and the common tools used for backend testing and also, do a demo performance testing project together. The tutorial is simplified and suitable for beginners, mid developers and professional developers. Extensive knowledge of this skill is fundamental to growing as a backend developer and can serve as a revision for expert developers. With all said, let's dive in.

Right now, I would shortly highlight the necessary prerequisites needed to fully harness all that would be discussed in this tutorial.

• Intermediate Knowledge of Node JS
• Basic knowledge of JavaScript operation
• Knowledge of API development

What is Performance testing all about?

It serves quite a lot of purposes among which is to test for system efficiency in performing and sustaining tasks. It also serves as a standard to compare systems of varying efficiency and build and also suggests the most effective among them all.

It also helps to reveal vulnerabilities. State-of-the-art testing tools are well optimized to efficiently analyze the code lines to detect any error and are quick to highlight the areas where these occur.

The end goal of performance testing is dependent on the use of the application in question. The end goal can either be concurrency-oriented or transaction rate oriented depending on whether the app involves end users or not.
Performance testing could entail Load testing, which is usually carried out to evaluate the behavior of a web service under a specific expected load. Other types of testing that can be assessed include Integration testing, spike testing, soak testing and stress testing.

Examples of performance testing tools

There are quite a lot of tools which are commonly used in our contemporary times to test the efficacy and latency of web applications. In this section, we hope to discuss on some of the tools used, and highlight their strengths and use cases.

Jest: This is a multi-platform testing tool used to assess the correctness of JavaScript-based applications. It was initially created to test the efficiency of React applications but has since been extended to assess the efficiency of Node Js apps. It also offers a code coverage feature.

Mocha: Mocha is a concise asynchronous JavaScript-based testing tool for node Js applications. It is also used with assertion libraries such as Chai and should.

Pythagora: This tool offers a unique integrating testing feature to help test how different part of the application works together. It also has the code coverage feature.

Artillery: This is a stack agnostic testing tool i.e. it can be used for multiple web applications based on different programming languages and still produce an optimal test outcome. This tool provides efficient Load testing features which help to determine the optimal status of the application when exposed to a large load of traffic. It also checks the speed at which an app responds to a user request without crashing.
Ava: Ava is a JavaScript-based performance unit testing tool used to test the efficacy of Node JS applications. It works asynchronously running multiple concurrent tests to determine the suitability of multiple code units.

Loadtest: This is a special Node package which is used to load test Node JS applications to evaluate the ability of the application to cope with requests of varying amount and to evaluate for efficiency and concurrency.

Apache J-meter: Apache JMeter offers load-testing features for web applications. It has an in-built IDE to enable interaction with the user. It is multithreaded increasing its ability to mimic several users.

There are other testing tools which are also equally useful. However, in this tutorial, we will be utilizing Jest to test our back-end application.

Demo Project

So right now, we would be performing a unit test on our code using Jest testing tool. Let’s begin by installing Jest package to our code folder. To complete this, type npm install jest in the command prompt and when successfully installed, a success message will be displayed.

In this tutorial, we intend to test the efficiency of some selected routes in our Node JS application. This will necessitate writing different unit tests for each routes and evaluating its correctness. Now let’s optimize our file structure in order to successfully unit test our application.
Navigate to the package.json file and edit it to include this.

javascript

"scripts": {
    "test": " jest",
    "start": "nodemon index.js"
  },

The code above includes Jest package as the default recognized testing application whenever we want to run some performance testing on this project. This automatically triggers jest functionality when we enter npm test in the command prompt.

Thereafter, we would like to create our test environment. A folder in the root directory should be created with the name “tests”. This helps the Jest operator to locate the files for testing. Within the test folder, kindly create a test file. The file can be named with whatever name you prefer but the suffix .test.js should be added so as to enable Jest recognize it and run it while testing.
After completing all these, let’s go into unit testing proper.

In the”test.js” file, let’s import and initialize some required packages and functions. In my code, I intend to test the routes of a book library application. It contains the get all book route, Get a single book route, upload a book route and delete a book route. . We intend on making unit tests for these routes.
So firstly, we intend to import the book database into the test.js file.


Javascript
const Book = require('../models/Book')

The code above imports and initializes our default book MongoDB database.
We would then be importing the functions that we intend to test in each route.

 jsx
const {GetAllBooks}= require("../controllers/Books");

The function above is for the get all books route. This contains the function to be tested. Now we intend to go into the Jest test function.

jsx
jest.mock("../models/Book");

const req = {};
const res = {
  status: jest.fn((x) => x),
  send: jest.fn((x) => x),
};

it("it should return all the books in the database", async () => {
  Book.find.mockImplementationOnce(() => ({
    Title: "black is king",
    Author: "black",
    price: "$23",
    Summary: "redkjnsadf",
  }));
  await GetAllBooks(req, res);
  expect(res.status).toHaveBeenCalledWith(200);
  expect(res.send).toHaveBeenCalledTimes(1);
});

First of all, Jest offers you the ability to create a fake database by copying the structure of the default database. This is known as mocking. This enables the unit test to operate faster and eliminate the lag that comes with getting responses from large databases. Testing which involves the real database is referred to as end-to-end testing as opposed to unit testing.
Also, attached above are sample requests and response objects. The response objects contains both the status and send function which returns a defined output if successfully run or not.

Now the It function contains a short description of what the test should be about. Also attached to it is an anonymous function containing the request we intend to test. The expect statement would return passed if the function satisfies the requirements. If it fails, a failed response would be returned.

Other Additional Information

With that we have delved a bit into unit testing of functions. You can also attempt testing for the delete functions, upload function and specific book function.

Conclusion

So we have been able to harness the usefulness of testing tools in optimizing our web application. We have also enjoyed its simplicity. Other additional features like we mentioned earlier can also be integrated using the same method talked about in this tutorial.
I sincerely hope you learned something new and enjoyed this innovative tutorial. Till next time, keep on coding.