Forem: Rohit sah

Creating a virtual call system using 3CX and AWS

Rohit sah — Sat, 04 Feb 2023 07:40:21 +0000

First of all what is this 3CX and cloud calling feature that we are talking about, if we go with the actual definition then it can be quoted as -

"3CX Phone System completely replaces a hardware PBX without the need for additional phone wiring. It supports popular SIP phones, VoIP providers, and traditional PSTN lines. The 3CX Phone System web-based management console makes it easy to configure, eliminating the need for expensive maintenance"

In reality its a simple cloud based calling system that can be set in your organization that uses cloud PBX(Private branch exchange). A PBX system (Private Branch Exchange) is a private phone system used within a company or organization. Modern business phone systems have moved away from legacy systems to IP (Internet Protocol) PBX systems that work over an internet connection. They connect IP phones to a PBX server. This option tends to provide more advanced phone features as well as significant cost savings.

This can be a DIY hosting service or hosted by the PBX service provider. Most small businesses now have reliable network connections, making this an attractive option. The cloud option is also becoming the preferred solution for many hotel PBX systems that would benefit from not having to provide for space, cooling, security, and maintenance of the phone system.

Traditional PBX	Cloud PBX
Expensive onsite hardware required	No onsite hardware. All in the cloud
Additional fees for service and hardware upgrades	Updates are rolled out for free
Requires costly technical support	Easy management requiring no specialized skills
Difficult to scale	Add or remove extensions as needed
Hard to migrate office	Built for remote working

Benefits of Cloud PBX:

Configuration starts here:

Create an user for the 3CX to access and attach the policy and setup others details

attach the AmazonEC2FullAccess policy for allowing the user to configure,deploy and monitor the instances.

Now we create a key pair for the 3CX to use to access

Now go to AWS marketplace and subscribe to Debian 9/Debian 10 robust as we are going to use it as a template.

Click Continue to subscribe and Accept all the term to use the template

The configuration of the first step of AWS has been completed,Now go to 3CX site for creating a 1 year free account and add the required details as per the phone system that we want

select the timezone accorind to your region
Next select the number extension that you want for you call system to have, that is the length of the phone number you want in your organization.

Add a domain for for 3CX which is used for meeting invites and configuration
Now add a service provider, in our case we are going to use AWS and then add the access key we created when creating the AWS user for 3CX.
Now select the machine type that you want for your calling system to work on that is the EC2 configuration, to bear no cost we are using free tier of the EC2 instance as shown below.

Now wait for few minutes for the installation after the installation is completed click to login to the console and login wit the user credentials that you have received in the registered email

When we login we can find the user 1 that is our-self as we have created the account and we got a number of 1000, then we register other users for the phone call system.

We can also see that this 3CX system has created an EC2 instance that will be running the configuration for our phone call system to work, Also it has created a security group according to the requirements.

Now to verify the system we can dial through the 3CX app that we have installed in our mobile phone and have scanned the QR code to register the user to the number allotted to them So now we can make a call from 1000 to 1001 and test the system ad can see that its completely up and running also this system can be used to send voicemails and also for video-calling purposes.

This is how you create a 3CX calling system in the cloud with zero initial costings and can use the features for 1 year free.

Do hit the ♥ button if you liked the post and share it with your friends to let them know how to easily create a cloud based calling system on their own for free.

FOLLOW @rohit23421 for more stuff on development and better practices for a developer😄.

Building a short url generator with nodejs and mongoDB

Rohit sah — Fri, 03 Feb 2023 17:11:22 +0000

We have always come across many links that are too long for our day to day usage and it is very difficult to remember them easily or to forward/share them whenever required. So this is where we require urls to be short and effective.

We will be building an short url generator by the help of NodeJS, mongoDBand expressJS.

First step is to create the file architecture to create our project, so here I am using VS code as a code editor.
Now open the terminal and initialize an npm file by using command

npm init

Fill in the required details as your need
Now create a file structure for managing the routes and views folder as shown in the image below.

Now let's first install the dependencies that we require, open the terminal and hit:

npm i expressjs mongoose ejs shortid dotenv nodemon

Here the expressjs is used for setting the routes and mongoose is used for creating models for our DB, whereas ejs is for the frontend part for the viewing engine of the project and shortid is the main function that we are going to use to generate shortids/shorturl for the feed in url and at last the *dotenv * is an npm package for storing the credentials for accessing the DB.

So after installing the packages/dependencies your package.json file should look like the image below and don't forget to change the scripts as shown below because we are going to require nodemon for speedy development of the app that automatically re-runs the server when any changes are made to the files.

{
  "name": "url_shortner",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "node server.js",
    "dev": "nodemon server.js"
  },
  "author": "Rohit",
  "license": "ISC",
  "dependencies": {
    "dotenv": "^10.0.0",
    "ejs": "^3.1.6",
    "express": "^4.17.1",
    "mongoose": "^6.0.7",
    "shortid": "^2.2.16"
  },
  "devDependencies": {
    "nodemon": "^2.0.12"
  }
}

First we are going to setup the dotenv file with the DB url we are going to connect to, in this project we will be connecting our app to our local mongoDB database, so update the .env file as shown below.

MONGO_DB_URL=mongodb://127.0.0.1:27017/urlshortnerappdb

Now we are going to make a connection with the DB in the server.js file.

const express = require("express");
const mongoose = require("mongoose");
const app = express();

require("dotenv").config();

mongoose.connect(process.env.MONGO_DB_URL, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

app.listen(process.env.PORT || 5000, () => {
  console.log("SERVER RUNNING AT PORT 5000...");
});

The dotenv is included on the first line for requiring the dotenv file that has the DB url for connection, followed by requiring the express for creating an instance and then followed by requiring mongoose for making the connection.
We then define a port for listening to the server on port 5000 or a PORT that we can specify in the dotenv file.

Now we are going to define the schema for the url DB by requiring mongoose and adding in the collections.

const mongoose = require("mongoose");
const shortid = require("shortid");

const shortUrlSchema = new mongoose.Schema(
  {
    full: {
      type: String,
      required: true,
    },
    short: {
      type: String,
      required: true,
      default: shortid.generate,
    },
    clicks: {
      type: Number,
      required: true,
      default: 0,
    },
  },
  { timestamps: true }
);

module.exports = mongoose.model("ShortUrl", shortUrlSchema);

We have used the shortid package for generating random shortids for our url with the help of shortid.generate command and a clicks collection for storing the count of number of clicks that has been made on the shorturl link by people.

Now add the view engine code part that is "ejs" in the index.ejs file.

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>URL shortner</title>
    <style>
        body {
            background-color: powderblue;
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
        }
        h1 {
            color: blue;
        }
        button {
            font-size: 17px;
            color: white;
            background-color: green;
            border-radius: 15px;
            width: 70px;
            height: 50px;
        }
        form {
            width: 50%;
            display: flex;
        }
        input {
            border-radius: 10px;
            width: 100%;
            height: 40px;
            border: none;
            margin: 10px;
        }
        table {
            width: 70%;
            padding-top: 20px;
        }
        table,
        td,
        th {
            border-radius: 5px;
        }
        table,
        thead,
        tr {
            font-size: 25px;
        }
        table,
        tbody,
        tr,
        td {
            font-size: 25px;
        }
        th {
            text-align: left;
        }
    </style>
</head>
<body>
    <h1>URL shortner</h1>
    <form action="/shortUrls" method="POST">
        <input type="url" name="fullUrl" id="fullUrl">
        <button type="submit">Submit</button>
    </form>

    <table>
        <thead>
            <tr>
                <th>Full URL</th>
                <th>Short URL</th>
                <th>Clicks</th>
            </tr>
        </thead>
        <tbody>
            <% shortUrls.forEach(shortUrl=> { %>
                <tr>
                    <td><a href="<%= shortUrl.full %>"><%= shortUrl.full %></a></td>
                    <td><a href="<%= shortUrl.short %>"><%= shortUrl.short %></a></td>
                    <td><%= shortUrl.clicks %></td>
                </tr>
                <% }) %>
        </tbody>
    </table>
</body>

</html>

and set the form action as "/shortUrls" because this is the endpoint which will help us to connect to the backend.

Now we are going to add the routes in the server.js file.

const shortUrl = require("./models/shortUrl");
const ShortUrl = require("./models/shortUrl");

app.set("view engine", "ejs");
app.use(express.urlencoded({ extended: false }));

app.get("/", async (req, res) => {
  const shortUrls = await ShortUrl.find();
  res.render("index", { shortUrls: shortUrls });
});

app.post("/shortUrls", async (req, res) => {
  await ShortUrl.create({ full: req.body.fullUrl });

  res.redirect("/");
});

app.get("/:shortUrl", async (req, res) => {
  const shortUrl = await ShortUrl.findOne({ short: req.params.shortUrl });
  if (shortUrl == null) return res.sendStatus(404);

  shortUrl.clicks++;
  shortUrl.save();

  res.redirect(shortUrl.full);
});

We are going to set the view engine using app.set for viewing our ejs files and to pass json data from backend we set the app as app.use(express.urlencoded({ extended: false })).

The first route that is "/" will be the homepage for our application that will fetch all the previous url from the DB and render it using the ejs script.

The second route "/shortUrls" allows us to post/add urls to the DB

The third route "/:shortUrl" is what makes the connection between the original link and the short url link, so that it re-directs to the link that we want the short url for and it takes the id of the url stored in the DB as the params and then we are increasing the clicks count on the url.

So the final code looks like:

const express = require("express");
const mongoose = require("mongoose");
const shortUrl = require("./models/shortUrl");
const app = express();
const ShortUrl = require("./models/shortUrl");

require("dotenv").config();

mongoose.connect(process.env.MONGO_DB_URL, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

app.set("view engine", "ejs");
app.use(express.urlencoded({ extended: false }));

app.get("/", async (req, res) => {
  const shortUrls = await ShortUrl.find();
  res.render("index", { shortUrls: shortUrls });
});

app.post("/shortUrls", async (req, res) => {
  await ShortUrl.create({ full: req.body.fullUrl });

  res.redirect("/");
});

app.get("/:shortUrl", async (req, res) => {
  const shortUrl = await ShortUrl.findOne({ short: req.params.shortUrl });
  if (shortUrl == null) return res.sendStatus(404);

  shortUrl.clicks++;
  shortUrl.save();

  res.redirect(shortUrl.full);
});

app.listen(process.env.PORT || 5000, () => {
  console.log("SERVER RUNNING AT PORT 5000...");
});

Now hit

npm start

in the terminal to start the app.

Enter the url for accessing the app as - localhost:5000 on your web-browser.

You will be able to see the following page:

So this is how you create a simple url shortner app using nodejs, expresjs and mongodb and can clip your urls into a small size.

Do hit the ♥ button if you liked the post and share it with your friends to let them know how to easily create an url shortner app.

FOLLOW @rohit23421 for more stuff on development and better practices for a developer😄.

DevOps and Cloud

Rohit sah — Tue, 24 Jan 2023 06:05:53 +0000

First of all what is DevOps

DevOps is the combination of cultural philosophies, practices, and tools that increases an organization’s ability to deliver applications and services at high velocity: evolving and improving products at a faster pace than organizations using traditional software development and infrastructure management processes. This speed enables organizations to better serve their customers and compete more effectively in the market.

Under a DevOps model, development and operations teams are no longer “siloed.” Sometimes, these two teams are merged into a single team where the engineers work across the entire application lifecycle, from development and test to deployment to operations, and develop a range of skills not limited to a single function.
In some DevOps models, quality assurance and security teams may also become more tightly integrated with development and operations and throughout the application lifecycle. When security is the focus of everyone on a DevOps team, this is sometimes referred to as DevSecOps.
These teams use practices to automate processes that historically have been manual and slow. They use a technology stack and tooling which help them operate and evolve applications quickly and reliably. These tools also help engineers independently accomplish tasks (for example, deploying code or provisioning infrastructure) that normally would have required help from other teams, and this further increases a team’s velocity.

DevOps lifecycle:

Benefits: DevOps

Now we have seen what is DevOps and its benefits now the question arises why DevOps

Software and the Internet have transformed the world and its industries, from shopping to entertainment to banking. Software no longer merely supports a business; rather it becomes an integral component of every part of a business. Companies interact with their customers through software delivered as online services or applications and on all sorts of devices. They also use software to increase operational efficiencies by transforming every part of the value chain, such as logistics, communications, and operations. In a similar way that physical goods companies transformed how they design, build, and deliver products using industrial automation throughout the 20th century, companies in today’s world must transform how they build and deliver software.

To adapt DevOps there are following practices that can be made

 --Continuous Integration

 --Continuous Delivery

 --Microservices

 --Infrastructure as Code

 --Monitoring and Logging

 --Communication and Collaboration

DevOps Tools:

The DevOps model relies on effective tooling to help teams rapidly and reliably deploy and innovate for their customers. These tools automate manual tasks, help teams manage complex environments at scale, and keep engineers in control of the high velocity that is enabled by DevOps.

Some of the widely used tools for each section are:

Now the question that why DevOps with cloud
Just like DevOps aims for continuous innovation and faster delivery of software from development through operations, Cloud Operations also call for continuous operations & improvement — but in cloud environments.
DevOps and Cloud are likely to become all-rounder and organizations will need greater discipline to craft and adhere to a strategy that leads to stability and consistency.