Binary search is a fundamental algorithm used in computer science to efficiently search for a specific value in a sorted dataset. It follows the divide-and-conquer approach, which means it repeatedly divides the dataset in half until the desired value is found or determined to be absent. This algorithm is of great importance in computer science as it provides a fast and efficient way to search for data, especially in large datasets.

Key Takeaways

• Binary search is a powerful algorithm for solving complex problems.
• It works by dividing a sorted array in half and eliminating half of the remaining elements with each iteration.
• Binary search has several advantages over other search algorithms, including faster performance and lower memory usage.
• It is commonly used in a variety of applications, including search engines, databases, and scientific simulations.
• To implement binary search in code, you need to understand the basic algorithm and follow best practices for optimization and error handling.

Understanding the Binary Search Algorithm

To understand how binary search works, let’s go through the step-by-step process. First, we start with a sorted dataset and define the lower and upper bounds of the search range. Then, we calculate the middle element of the range and compare it with the target value we are searching for. If the middle element is equal to the target value, we have found our desired value and the search ends. If the middle element is greater than the target value, we update the upper bound to be one less than the middle index. Conversely, if the middle element is less than the target value, we update the lower bound to be one more than the middle index. We repeat this process until either the target value is found or the lower bound becomes greater than the upper bound.

Let’s consider an example to illustrate binary search in action. Suppose we have a sorted array [1, 3, 5, 7, 9, 11] and we want to find the index of value 7. We start with a lower bound of 0 and an upper bound of 5. The middle index is calculated as (0 + 5) / 2 = 2. Since the middle element is 5, which is less than 7, we update the lower bound to be one more than the middle index (3). Now our new range is [7, 9, 11]. We repeat this process until we find the target value or determine it is not present. In this case, the next middle index is 4, and the middle element is 9. Since 9 is greater than 7, we update the upper bound to be one less than the middle index (3). Now our new range is [7]. The final middle index is 3, and the middle element is 7, which is equal to our target value. Therefore, the index of value 7 in the array is 3.

Advantages of Binary Search

One of the main advantages of binary search is its efficiency compared to other search algorithms. Binary search has a time complexity of O(log n), where n is the size of the dataset. This means that as the dataset grows larger, the time taken to perform a binary search increases at a much slower rate compared to linear search algorithms. For example, if we have a dataset with one million elements, binary search would require at most 20 comparisons to find the desired value, while linear search would require up to one million comparisons.

Another advantage of binary search is its ability to quickly search sorted data. Since binary search relies on dividing the dataset in half at each step, it can quickly narrow down the search range and eliminate large portions of the dataset. This makes binary search particularly useful when dealing with large datasets or when searching for values in real-time applications where speed is crucial.

Common Applications of Binary Search

Binary search has numerous applications in various fields. One common application is searching for a specific value in a large dataset. For example, in a database containing millions of records, binary search can efficiently locate a specific record based on a unique identifier such as an ID number.

Another application of binary search is finding the closest match to a given value. This can be useful in scenarios such as searching for the nearest location based on geographical coordinates or finding the closest match to a user’s input in a recommendation system.

Binary search is also commonly used in implementing autocomplete functionality. As a user types in a search query, binary search can quickly narrow down the possible suggestions based on the partially entered text, providing real-time suggestions that match the user’s input.

How to Implement Binary Search in Code

Implementing binary search in code is relatively straightforward. Here is a sample code snippet in Python:

def binary_search(arr, target):
  low = 0
  high = len(arr) - 1
  while low <= high:
    mid = (low + high) // 2
    if arr[mid] == target:
      return mid
    elif arr[mid] < target:
      low = mid + 1
    else:
      high = mid - 1
  return -1

In this code, we define the lower bound (`low`) and upper bound (`high`) of the search range. We then enter a while loop that continues until the lower bound becomes greater than the upper bound. Inside the loop, we calculate the middle index (`mid`) using integer division. We compare the middle element with the target value and update the lower or upper bound accordingly. If the target value is found, we return the index. If the loop ends without finding the target value, we return -1 to indicate that it is not present in the dataset.

Binary Search vs. Linear Search: Which is Better?

When comparing binary search and linear search algorithms, it is important to consider their advantages and disadvantages. Binary search has a time complexity of O(log n), making it significantly faster than linear search algorithms, which have a time complexity of O(n). This means that as the dataset grows larger, binary search outperforms linear search by a wide margin.

However, binary search requires the dataset to be sorted beforehand, which can be a disadvantage in certain scenarios. If the dataset is frequently updated or modified, maintaining the sorted order can be time-consuming and may negate the benefits of binary search. In contrast, linear search does not require any specific order of the dataset and can be performed on unsorted data.

Another factor to consider is the memory usage. Binary search requires less memory compared to linear search, as it only needs to store the lower and upper bounds and a few variables for indexing. Linear search, on the other hand, needs to iterate through the entire dataset, which can be memory-intensive for large datasets.

In conclusion, binary search is generally more efficient than linear search for searching sorted data, especially in large datasets. However, the choice between the two algorithms depends on the specific requirements of the application and the characteristics of the dataset.

Tips for Optimizing Binary Search Performance

While binary search is already an efficient algorithm, there are several tips and techniques that can further optimize its performance:

1. Ensure the dataset is sorted: Binary search relies on a sorted dataset, so it is crucial to ensure that the data is properly sorted before performing a binary search. Sorting algorithms such as quicksort or mergesort can be used to achieve this.

2. Use appropriate data structures: Choosing the right data structure can significantly improve binary search performance. For example, using an array instead of a linked list can provide better cache locality and reduce memory access time.

3. Handle edge cases: It is important to handle edge cases such as empty datasets or datasets with only one element separately to avoid unnecessary iterations and improve efficiency.

4. Avoid unnecessary calculations: Minimize unnecessary calculations inside the loop to reduce computational overhead. For example, calculate `mid` outside the loop if it remains constant throughout the search.

5. Take advantage of language-specific optimizations: Different programming languages have their own optimizations for binary search. For instance, in C++, using `std::lower_bound` or `std::upper_bound` functions can provide a more efficient implementation.

Common Mistakes to Avoid in Binary Search

Implementing binary search correctly can be challenging, and there are several common mistakes to avoid:

1. Incorrectly updating the lower and upper bounds: It is crucial to update the lower and upper bounds correctly based on the comparison with the middle element. Failing to do so can result in an infinite loop or incorrect search results.

2. Not handling the case when the target value is not found: It is important to handle the case when the target value is not present in the dataset. Returning an appropriate value, such as -1, can indicate that the value was not found.

3. Not considering the mid element in the search: Failing to consider the middle element during the search can lead to incorrect results. The middle element should always be compared with the target value to determine whether it is equal, greater, or smaller.

4. Not sorting the dataset before performing binary search: Binary search requires a sorted dataset, so forgetting to sort it beforehand will lead to incorrect results.

5. Not considering overflow or underflow: When calculating the middle index, it is important to handle potential overflow or underflow issues that may occur with large datasets or extreme values.

By being aware of these common mistakes and taking precautions to avoid them, you can ensure a correct and efficient implementation of binary search.

Variations of Binary Search: Interpolation Search and Exponential Search

While binary search is a widely used algorithm, there are variations that offer different trade-offs in terms of performance and complexity. Two notable variations are interpolation search and exponential search.

Interpolation search improves upon binary search by estimating the position of the target value based on its value and the values at the ends of the dataset. Instead of always dividing the dataset in half, interpolation search calculates an approximate position for the target value and adjusts the search range accordingly. This can result in faster convergence to the target value, especially when the dataset is uniformly distributed. However, interpolation search requires a sorted dataset and may perform poorly on datasets with unevenly distributed values.

Exponential search, on the other hand, combines elements of both linear and binary search. It starts with a small range at the beginning of the dataset and exponentially increases the range until it encompasses the target value. Once the range is determined, binary search is performed within that range. Exponential search can be useful when the target value is likely to be found near the beginning of the dataset, as it reduces the number of iterations required compared to a full binary search. However, exponential search also requires a sorted dataset.

Real-World Examples of Binary Search in Action

Binary search finds applications in various industries and applications. Here are a few real-world examples:

1. Database systems: Binary search is commonly used in database systems to efficiently locate records based on unique identifiers or indexed values. This allows for fast retrieval of data from large databases.

2. Geographic information systems: Binary search is used in geographic information systems to find locations based on geographical coordinates. By indexing and sorting location data, binary search can quickly identify the nearest locations to a given point.

3. Spell checkers: Spell checkers often use binary search to suggest corrections for misspelled words. By maintaining a sorted dictionary, binary search can quickly identify similar words and provide suggestions based on their similarity to the misspelled word.

4. Financial applications: Binary search is used in financial applications to perform efficient searches on large datasets of stock prices or financial records. This allows for quick analysis and decision-making based on historical data.

Mastering the Art of Binary Search

In conclusion, binary search is a powerful algorithm that plays a crucial role in computer science and various real-world applications. Its efficiency, ability to search sorted data quickly, and versatility make it an essential tool for computer science professionals.

By understanding the step-by-step process of binary search, its advantages over other search algorithms, and its common applications, you can leverage this algorithm to solve complex problems efficiently. Implementing binary search correctly, avoiding common mistakes, and optimizing its performance using best practices will further enhance your skills in this area.

As you continue your journey in computer science, mastering binary search will provide you with a valuable skill set that can be applied in a wide range of domains. So keep learning, practicing, and exploring the possibilities of binary search to become a proficient problem solver and contribute to the advancement of computer science.

#DataStructures #Algorithms #Coding #Programming #ComputerScience #TechTalk #Python

#startup #startuptips #startupgrowth

AWS Lambda is a serverless compute service provided by Amazon Web Services (AWS). It allows you to run your code without provisioning or managing servers, paying only for the compute time consumed by your application. Lambda is a fundamental building block of serverless application development, providing a scalable and event-driven architecture.

Using AWS Lambda is like having a magical genie for your code. It’s like saying, ‘Poof!’ and your servers disappear, leaving you with more time to ponder life’s important questions, like why don’t ducks wear sandals? Lambda lets you focus on the fun part of coding, while AWS handles all the server sorcery behind the scenes. It’s serverless computing that’s so funny, even the laughing gas is jealous!

Here are some key aspects and the role of AWS Lambda in serverless application development:

1. Event-driven computing: Lambda is designed to respond to events. An event can be a request from an API Gateway, changes to data in an Amazon S3 bucket, updates to a DynamoDB table, or any other event source supported by Lambda. When an event occurs, Lambda automatically runs your code in response, allowing you to build reactive applications that respond to real-time events.
2. No infrastructure management: With AWS Lambda, you don’t need to worry about server provisioning, capacity planning, or infrastructure management. AWS handles all the underlying infrastructure, including server maintenance, scaling, and availability. You can focus solely on writing your application code.
3. Pay-per-use pricing model: Lambda follows a pay-per-use pricing model, where you are billed only for the compute time consumed by your code. You don’t have to pay for idle time or overprovisioning. This makes Lambda cost-efficient and highly scalable, as it automatically scales based on the incoming workload.
4. Support for multiple programming languages: Lambda supports multiple programming languages, including Node.js, Python, Java, Ruby, C#, PowerShell, and Go. You can choose the language that best fits your application and development preferences.
5. Integration with other AWS services: Lambda seamlessly integrates with various AWS services, allowing you to build serverless applications that leverage the rich set of AWS offerings. You can easily connect Lambda functions with services like API Gateway, DynamoDB, S3, SNS (Simple Notification Service), SQS (Simple Queue Service), and more.
6. Automatic scaling: Lambda automatically scales your functions in response to incoming request traffic. It provisions the necessary resources to handle concurrent executions and scales down to zero when there is no traffic. This elastic scaling capability ensures that your application can handle any level of traffic without worrying about capacity planning or manual scaling.
7. Event-driven microservices architecture: AWS Lambda is a key component in building event-driven microservices architectures. You can break down your application into smaller, independent functions and trigger them based on specific events. Each Lambda function performs a specific task and can be managed and developed independently. This enables modularity, flexibility, and easy maintenance of your serverless applications.

Overall, AWS Lambda simplifies the development and deployment of serverless applications by abstracting away the underlying infrastructure management. It provides a scalable and cost-effective solution for building event-driven, highly responsive applications that can integrate with various AWS services. With Lambda, developers can focus on writing business logic and delivering value, while AWS takes care of the operational aspects of running and scaling the code.

Ready to level up your development skills? Learn the secrets of Serverless architecture and how to implement it in real projects. Join me for a step-by-step tutorial that will demystify the process. Get ready to take your projects to new heights with Serverless. Check out this article and let’s dive into the world of Serverless together!

Hey Ninja, kindly follow to stay updated on my latest tutorials.

Cheers! 🥷🏻

#aws #serverless #awslamda

More content at PlainEnglish.io.

Sign up for our free weekly newsletter. Follow us on Twitter, LinkedIn, YouTube, and Discord.

What is AWS Lambda? was originally published in AWS in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

Do You Know — No one wants a Domain with their name on it owned by somebody else 💡

Introducing DifferAI

So you just bought a domain name on Namecheap and you’ve been wondering how on earth would you be able to host it on Amazon, then this tutorial is for you.

What the heck is Route 53?

Amazon Route 53 is a highly accessible and scalable Domain Name System service. Domain registration, DNS routing, and h=Health testing are the three major functions that you can execute using Route 53 in any order. You must choose a name for your website, such example.com. You can register a domain name, also referred to as a name for your website or web application, on Route 53. The purpose of Route 53 is to manage DNS for devices and services placed on Amazon’s public cloud.

Now that you know what Route 53 does, you might be having questions like:

Why Should I choose Route 53 as my hosting provider?

Well, maybe you have to read the above definition of Route 53 again 🤓.

Now let’s cut to the chase…

How to connect my domain to Route 53?

Firstly, you have to purchase a domain name on Namecheap.

FYI — Namecheap is one of the best domain provider out there. The prices are flexible and their services are quite good.

This tutorial won’t be showing you how to purchase a domain name. Our focus is to connect an existing domain to Route 53. Once you have purchased a domain, sign in to your namecheap account and click on Domain List on the left sidebar:

Here, you’ll see the list of domains you’ve purchased so far.

You’d noticed I had to blur all my domains.. I don’t want to be hacked …hahah

Click on Manage.

On the screen below, select Custom DNS:

Now, sign in to your AWS account, on the search bar, search for Route 53.

On the next page, click on Hosted Zone:

Click on Create hosted zone:

In the next page, enter your domain name in the input box and click on Create hosted zone:

Wait for some seconds. Once it’s created, in the page that looks like this:

Copy the NS records, go back to Namecheap and enter the NS records in the Nameserver input field in order:

Click the green checkmark to save it.

Viola!! You have successfully connected your Namecheap Domain to Route 53.

You can go further to create several records like the A, TXT, etc on Route 53.

Cheers!

In Plain English 🚀

Thank you for being a part of the In Plain English community! Before you go:

• Be sure to clap and follow the writer ️👏️️
• Follow us: X | LinkedIn | YouTube | Discord | Newsletter
• Visit our other platforms: CoFeed | Differ
• More content at PlainEnglish.io

How to connect your domain from Namecheap to Amazon Route 53 was originally published in AWS in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction

Next.js is a flexible React framework that gives you building blocks to create fast web applications. Source — Next Js

Since this tutorial isn’t an introduction to Next js, i wouldn’t go into much details on Next Js. You can read more here.

I believe you already have some knowledge on Next Js, and you’re trying to deploy your application to Amazon Amplify.

Amplify

Frontend web and mobile developers can quickly create, launch, and host full-stack applications on AWS with the help of AWS Amplify. It’s a comprehensive solution that gives developers the freedom to take advantage of the breadth of AWS services as use cases change. Cloud knowledge is not required.

Prerequisite

• Have a basic knowledge on Next Js, CLI and Git.
• Have an AWS account. You can create an account here if you don’t have one.
• Have Node and NPM installed. You can install from here.
• Have Git installed on your computer.
• Your prefered code editor.

Setup a basic Next Js Application

We need to have a next js application running.

First, let’s create a new next js application. Go over to the terminal and enter the commands below:

Note: I’m using Yarn package manager in this tutorial. You can subsitute it with pnpm or npx.

yarn create next-app

Enter your project name and follow the prompt. You have options to choose if you want to use TypeScript and EsLint with your application. After the installation is complete, run the command below to run the app on your local environment:

yarn run dev

Open uphttp://localhost:3000 to view your application in your browser.

You should see this screen below, if you’ve installed everything correctly:

Deploy to Github

Sign in to your github account and create an empty repository.

On your terminal, add the following commands to push our sample code to the created repo:

git add remote origin <YOUR_GITHUB_URL_>
git remote set-url origin <YOUR_GITHUB_URL_>
git push origin main

Once you have pushed the code to your repo. Then we can proceed to deploying to amplify.

Amplify

Sign in to your AWS account.

In the search bar, search for Amplify and click on AWS Amplify.

You should see something like this in the next page:

Once you click on Get Started.

As i have explained initially, amplify really gives us awesome features to develop full stack apps. Especially developing a backend application for an existing app.

On the section below, there are two options, Amplify Studio and Amplify Hosting. We only need Amplify Hosting for this tutorial. We can use the Amplify Hosting to deploy React, Vue and Js apps. We’re deploying a Next js app, so we’re good to go.

Click on Get Started.

On the next page that shows, you should see a page like this:

Select Github to connect your repository to host your web app. As you can see, we have several other git repos, but for now, our focus is only Github.

Click on Continue.

On the next page, it’s asks you to login to you github account:

Select the existing repo in the dropdown. Then select the git branch you want to deploy from in the Branch dropdown. In our own case, we’ll select main.

Click on Next. You should see the next screen below:

Note: You can click on the advanced settings if you have a Dockerized application. Also, you can edit the build settings to suit your app needs.

Click on Next. On the next screen below, click on Save and deploy.

Now the app creation is in progress. You should see a screen like below:

On the next screen, you should wait patiently for your app to be deployed successfully. Once it’s deployed, you’ll see a screen like the one below — You can now click on the link to your app.

Kudos Ninja 👏🏻…We have successfully deployed our Next Js app to Amplify.

Now this is one of the most easiest thing Amplify has to offer. There are tons of other things you can do with Amplify like i’ve mentioned earlier. I’ll probably have some other tutorials on that soon.

Cheers! 🥷🏻

#nextjs #nodejs #amplify #javascript #github

More content at PlainEnglish.io. Sign up for our free weekly newsletter. Follow us on Twitter, LinkedIn, YouTube, and Discord.

Interested in scaling your software startup? Check out Circuit.

Deploy a Next.js Application on Amazon Amplify Service was originally published in AWS in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

1. Introduction

There are several options available once you’ve created a web application to publish it online and make it accessible to others. Elastic Compute Cloud, a well-known service, is one of the platform’s offerings from Amazon Web Services (AWS) (EC2).

It’s important to have a basic grasp of EC2 and how to deploy to it because it forms the foundation for many of AWS’ other services.

In this article, we’ll learn how to setup an EC2 instance, configure it, and deploy a straightforward Node.js application to it. Your Node project will be operating on AWS by the conclusion of this tutorial, and you’ll have a better grasp of how to connect with a fundamental system of AWS.

2. Prerequisites

In order to follow through this tutorial, you’ll need the following:

• An AWS Account

You can checkout this tutorial on how to create an AWS account.

• Node and Npm

You need to have Node and Npm installed on your computer. You can install them here .

• Docker

Docker is a very lightweight virtual machine that comes with all the applications and dependencies needed to run your program. Docker allows us to group our programs into manageable parts that may be run everywhere Docker is deployed. This eliminates the excuse “but it works on my computer!”

Since i won’t be going into great detail, this tutorial will presume a basic understanding of Docker. If you want to learn more about docker, i’ll create an article very soon where i’ll teach you how to use docker for production ready applications.

Now, make sure you have docker downloaded on your machine. You can download here.

• Node Application

You need a server application running. Let’s qucikly setup a node application.

Open the terminal and run:

mkdir node-ec2 
cd node-ec2 
npm init --yes

Next, let’s install express and typescript.

npm install express --save
npm i -D typescript @types/express @types/node ts-node

Generate a tsconfig.json:

npx tsc --init

Go to the package.json file once these libraries have been installed to see a new dev dependencies object and also update it to have the build and start script:

{
  "name": "node-ec2",
  "version": "1.0.0",
  "main": "index.ts",
  "scripts": {
    "build": "tsc --project ./",
    "start": "npm run build && node build/index.js"
  },
  "license": "MIT",
  "dependencies": {
    "express": "^4.18.2"
  },
  "devDependencies": {
    "@types/express": "^4.17.15",
    "@types/node": "^18.11.18",
    "ts-node": "^10.9.1",
    "typescript": "^4.9.4"
  }
}

Open your prefered editor to create an index.js file to setup Express and define a request handler.

import express, {Express, Request, Response} from "express";
const app: Express = express();
const port = 8080;

app.get('/status', (req: Request, res: Response) => {
    res.send({status: "Server is healthy!"});
});

app.listen(port, () => {
    console.log(`App is running at http://localhost:${port}!`)
});

We can start up the server by running:

npm start

When we navigate to http://localhost:8080/status, we ought to receive a response with the status “Server is healthy!” As soon as that succeeds, be careful to shutdown the server by pressing CTRL+C.

Let’s create a Docker image of our straightforward Node application so that it can be deployed to EC2.

3. Dockerizing our Node Application

Create a file and name it Dockerfile

FROM node:16-alpine

WORKDIR /usr/src/app

COPY package*.json ./

RUN npm install

COPY . .

RUN npm run build

EXPOSE 8080
CMD [ "node", "build/index.js" ]

We can use the above docker script for simple node applications. Now let’s build the docker image using the command below:

docker build . -t node-ec2
docker run -p 8080:8080 node-ec2

If you navigate to http://localhost:8080/status, we ought to receive a response as before. Now shutdown the server by pressing CTRL+C.

Finally, let’s push our docker image to Docker Hub:

docker login # Enter your Docker Hub credentials here
docker tag node-ec2 <YOUR_DOCKER_USERNAME>/node-ec2
docker push <YOUR_DOCKER_USERNAME>/node-ec2

Deployment to EC2

Now that we’ve dockerized our application, we need to setup an ec2 instance for it to run on.

Head over to AWS and sign in.

On the navigation bar, click on the search box, search for EC2.

You should see something similar to this:

On you open up the EC2 page, you’ll have a page that looks like this:

Click on Launch Instance.

On the next page, you should have a view like below:

AMIs

Here is where we choose the AMI, or short for Amazon Machine Image. An AMI is a server that may be purchased in a variety of configurations.

For instance, we might choose an Amazon Linux 2 AMI, or if you scroll down, you’ll find other instances with Ubuntu running on them.

Each AMI is a copy of a machine’s operating system and possibly some other software that has been frozen.

Click on Browse more AMIs to view the list of several AMIs available.

To make things simple, we can utilize this to create an EC2 instance that is already set up using Docker!

To do this, we need to click “AWS Marketplace AMIs” on the left and then type “ECS” into the search bar. Several results ought to come up, however we want the “ECS Optimized Amazon Linux 2” image.

This image, which includes Docker, is designed specifically for running containers. The next page will open after you click “Select” on the selected picture:

After clicking Select, a pop up will show, then you’ll click on Continue.

Enter your instance name. For example, node-ec2.

Instance Types

We decide what kind of instance we want on the next view. In general, this determines the resources that will be made available to the server that we’re launching, with scaling fees for machines with higher performance.

Scroll down the page to select the instance type — It is advised to utilize the t2.micro instance type since it qualifies for the free tier:

Key Pair

It is important that you create a key pair before launching the application in order to be able to access it.

Click on create key pair and you should have a pop up like the one below:

Enter your key pair name. Leave the Private key file format as .pem. Once you click on Create key pair, It will be downloaded automatically.

Network Settings (Security Group)

This signifies that any traffic utilizing the TCP protocol that enters through port 22 is permitted (0.0.0.0/0 denoting any location). To enable everyone to use our app at port 8080, we must add one more rule.

Make sure you select the check boxes for allowing Http and Https from anywhere.

Note: There are some other advanced configurations that you can set up depending on your app needs. We don’t need to do that for now.

You can now go ahead to launch the instance.

On the next page that shows, please wait patiently for the instance to be launched successfuly.

Once the instance is launched successfully, you’ll see a page like the one below:

Click on the Instance Id.

Connecting to Your EC2 Instance

Once you click on the Intance Id, a new tab is open and you see a page like this:

Click on the check box to view the instance details. On the section below, copy the Instant Public Ipv4 address.

Now, go to your computer terminal and enter the following commands:

chmod 400 <NAME_OF_KEYPAIR_FILE>
ssh -i <NAME_OF_KEYPAIR_FILE> ec2-user@<PUBLIC_IPV4_ADDRESS>

Once you’re logged into the server, enter the docker command below:

docker run -p 8080:8080 <YOUR_DOCKER_USERNAME>/node-ec2

Note: For M1 Mac users, you might experience an error like this:

WARNING: The requested image's platform (linux/arm64/v8) does not match the detected host platform (linux/amd64) and no specific platform was requested
exec /usr/local/bin/docker-entrypoint.sh:

Just run the docker command like below:

docker run --platform linux/amd64 -d -p 8080:8080 <YOUR_DOCKER_USERNAME>/node-ec2

You should have your app running successfully by now. You’ll be able to reach the instance using the same address you used to SSH into the instance. Simply navigate in your browser to:

<Public_Ipv4_Address>:8080/status

Security

When it comes to securing your EC2 instance, there are several measures you should put in place.

• Using a .pem file: A pem file allows you to be able to authenticate to the instance direclty without public access.
• Checking the security groups: You can make your instance available only via SSH or HTTPS protocol.

There are other measures to put in place for securing our instance, but that’ll be a seperate tutorial for now.

Other AMIs

There are hundreds of different AMIs, many of which come from different communities and have pre-installed applications. It’s worth looking through them to see if there’s a simple method to set up anything you’ve wanted to work with.

Adding a Custom Domain

You might want to create a domain name and direct it at your application now that it is operating on a server.

Conclusion

Since RDS (AWS’ database service) is essentially simply highly optimized EC2 instances with a lovely dashboard, EC2 is the backbone of many AWS services.

Understanding this foundational tool in AWS’ armory will inevitably lead to the discovery of fresh ways to carry out concepts.

In this article, we’ve used Express to build a straightforward Node.js application, dockerized it, set up EC2 for deployment, and then deployed it to the EC2 instance.

If you want to learn how to architect an EC2 instance, with load balancers, docker and Amazon RDS, i’ll be uploading another tutorial next week.

Kindly follow to stay updated on my latest tutorials.

Cheers! 🥷🏻

#docker #nodejs #ec2 #express #typescript

More content at PlainEnglish.io. Sign up for our free weekly newsletter. Follow us on Twitter, LinkedIn, YouTube, and Discord.

Interested in scaling your software startup? Check out Circuit.

How to deploy a Dockerized Node JS(TypeScript) Application to Amazon EC2 Service — 2023 was originally published in AWS in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

The auto-scaling group follows Horizontal Scaling. This service is very important for us nowadays because we do not need to create new instances manually and do not require manual monitoring.

AWS auto-scaling is used to scale up and scale down the EC2 instance depending on the incoming traffic. You can scale up and scale down the applications in a few minutes based on the traffic which will decrease the latency of the application to the end-users. You can integrate the AWS Auto Scaling with multiple services provided by AWS like Amazon traffic, Amazon DynamoDB, and Amazon Aurora. You can also decrease the cost of an application because of dynamic scaling. When there is traffic, only maximum resources are used other it will use minimum resources.

1. Dynamical scaling: AWS auto-scaling service doesn’t require any type of manual intervention it will automatically scale the application down and up depending on the incoming traffic.
2. Pay For You Use: Because of auto-scaling the resource will be utilized in the optimized way where the demand is low the resource utilization will be low and if the demand is high the resource utilization will increase so the AWS is going to charge you only for the number of resources you really used.
3. Automatic Performance Maintenance: AWS autoscaling maintains the optimal application performance while considering the workloads it will ensure that the application is running to the desired level which will decrease the latency and also the capacity will be increased by based on your application

How AWS Auto Scaling Works?

AWS autoscaling will scale the application based on the load of the application. Instead of scaling manually AWS auto scaling will scale the application automatically when the incoming traffic is high it will scale up the application and when the traffic is low it will scale down the application.

First, you should choose which service or an application you want to scale then select the optimization way like cost and performance and then keep track of how the scaling is working.

Steps to Create Auto Scaling Launch Template

Step 9: Now you can see the template is created. Now, scroll down and click on the Auto Scaling Groups.

Create An Auto Scaling Group Using a Launch Template

Select as per your requirement:

FAQs On Create And Configure The Auto Scaling Group In EC2

1. What Is The Difference Between EC2 Auto Scaling And AWS Auto Scaling?

AWS Auto-scaling is used to scale the AWS EC2 instance for better availability and productivity

2. Why Do We Need Auto Scaling?

Auto scaling is essential to efficiently manage resources in response to varying workloads. It optimizes costs, ensures performance, and maintains availability by automatically adjusting resources up or down based on demand.

- stability dashboard: Does the product perform as promised without malfunctioning?

- product dashboard: 1–2 indicators that demonstrate how often users return to a product.

- revenue dashboard: You generate income so that you can grow.

Working with APIs to facilitate communication between software systems is crucial for modern web developers. In this tutorial, we’ll create a CRUD RESTful API in a Node.js environment that runs on an Express server and uses a PostgreSQL database.

We’ll also walk through connecting an Express server with PostgreSQL using node-postgres. Our API will be able to handle the HTTP request methods that correspond to the PostgreSQL database from which the API gets its data. You’ll also learn how to install PostgreSQL and work with it through the CLI.

To follow along with this tutorial, you’ll need:

• Familiarity with the JavaScript syntax and fundamentals
• Basic knowledge of working with the command line
• Node.js and npm installed

The complete code for the tutorial is available in this GitHub repo. Let’s get started!

What is a RESTful API?

Representational State Transfer (REST) defines a set of standards for web services.

An API is an interface that software programs use to communicate with each other. Therefore, a RESTful API is an API that conforms to the REST architectural style and constraints.

REST systems are stateless, scalable, cacheable, and have a uniform interface.

What is a CRUD API?

When building an API, you want your model to provide four basic functionalities. It should be able to create, read, update, and delete resources. This set of essential operations is commonly referred to as CRUD.

• Create: Use the HTTP POST method to create a resource in a REST environment
• Read: Use the GET method to read a resource, retrieving data without altering it
• Update: Use the PUT method to update a resource
• Delete: Use the DELETE method to remove a resource from the system

What is Express?

According to the official Express documentation, Express is a fast, unopinionated, minimalist web framework for Node.js. Express is one of the most popular frameworks for Node.js. In fact, each E in the MERN, MEVN, and MEAN stacks stands for Express.

Although Express is minimalist, it’s also very flexible. This supports the development of various Express middlewares that you can use to address almost any task or problem imaginable.

What is PostgreSQL?

PostgreSQL, commonly referred to as Postgres, is a free and open-source relational database management system. You might be familiar with a few other similar database systems, like MySQL, Microsoft SQL Server, or MariaDB, which compete with PostgreSQL.

PostgreSQL is a robust relational database that has been around since 1997. It’s available on all major operating systems — Linux, Windows, and macOS. Since PostgreSQL is known for stability, extensibility, and standards compliance, it’s a popular choice for developers and companies.

It’s also possible to create a Node.js RESTful CRUD API using Sequelize. Sequelize is a promise-based Node.js ORM for Postgres, MySQL, MariaDB, SQLite, and Microsoft SQL Server.

For more on how to use Sequelize in a Node.js REST API, check out the video tutorial below:

What is node-postgres?

node-postgres, or pg, is a nonblocking PostgreSQL client for Node.js. Essentially, node-postgres is a collection of Node.js modules for interfacing with a PostgreSQL database.

node-postgres supports many features, including callbacks, promises, async/await, connection pooling, prepared statements, cursors, rich type parsing, and C/C++ bindings.

Creating a PostgreSQL database

We’ll begin this tutorial by installing PostgreSQL, creating a new user, creating a database, and initializing a table with a schema and some data.

Installation

If you’re using Windows, download a Windows installer of PostgreSQL.

If you’re using a Mac, this tutorial assumes you have Homebrew installed on your computer as a package manager for installing new programs. If you don’t, simply click on the link and follow the instructions.

Open up the terminal and install postgresql with brew:

brew install postgresql

You may see instructions on the web reading brew install postgres instead of PostgreSQL. Both options will install PostgreSQL on your computer.

After the installation is complete, we’ll want to get postgresql up and running, which we can do with services start:

brew services start postgresql ==> Successfully started `postgresql` (label: homebrew.mxcl.postgresql)

If at any point you want to stop the postgresql service, you can run brew services stop postgresql.

With PostgreSQL installed, let’s next connect to the postgres command line where we can run SQL commands.

PostgreSQL command prompt

• -w or --no-password: Never prompt for password
• -W or --password: Force password prompt, which should happen automatically

We’ll connect to the default postgres database with the default login information and no option flags:

psql postgres

postgres=#

postgres=# \conninfo You are connected to database "postgres" as user "your_username" via socket in "/tmp" at port "5432".

The reference table below includes a few common commands that we’ll use throughout this tutorial:

Let’s create a new database and user so we’re not using the default accounts, which have superuser privileges.

Creating a role in Postgres

First, we’ll create a role called me and give it a password of password. A role can function as a user or a group. In this case, we'll use it as a user:

postgres=# CREATE ROLE me WITH LOGIN PASSWORD 'password';

We want me to be able to create a database:

postgres=# ALTER ROLE me CREATEDB;

You can run \du to list all roles and users:

me | Create DB | {} postgres | Superuser, Create role, Create DB | {}

Now, we want to create a database from the me user. Exit from the default session with\q for quit:

postgres=# \q

We’re back in our computer’s default terminal connection. Now, we’ll connect postgres with me:

psql -d postgres -U me

Instead of postgres=#, our prompt now shows postgres=> , meaning we're no longer logged in as a superuser.

Creating a database in Postgres

We can create a database with the SQL command as follows:

postgres=> CREATE DATABASE api;

Use the \list command to see the available databases:

Name | Owner | Encoding | Collate | Ctype | api | me | UTF8 | en_US.UTF-8 | en_US.UTF-8 |

postgres=> \c api You are now connected to database "api" as user "me". api=>

Our prompt now shows that we’re connected to api.

Creating a table in Postgres

api=> CREATE TABLE users ( ID SERIAL PRIMARY KEY, name VARCHAR(30), email VARCHAR(30) );

Make sure not to use the backtick ` character when creating and working with tables in PostgreSQL. While backticks are allowed in MySQL, they're not valid in PostgreSQL. Also, ensure that you do not have a trailing comma in the CREATE TABLE command.

Let’s add some data to work with by adding two entries to users:

INSERT INTO users (name, email) VALUES ('Jerry', '[email protected]'), ('George', '[email protected]');

Let’s make sure that the information above was correctly added by getting all entries in users:

api=> SELECT * FROM users; id | name | email ----+--------+-------------------- 1 | Jerry |[email protected] 2 | George |[email protected]

Now, we have a user, database, table, and some data. We can begin building our Node.js RESTful API to connect to this data, stored in a PostgreSQL database.

At this point, we’re finished with all of our PostgreSQL tasks, and we can begin setting up our Node.js app and Express server.

Setting up an Express server

To set up a Node.js app and Express server, first create a directory for the project to live in:

mkdir node-api-postgres cd node-api-postgres

{ "name": "node-api-postgres", "version": "1.0.0", "description": "RESTful API with Node.js, Express, and PostgreSQL", "main": "index.js", "license": "MIT" }

We’ll want to install Express for the server and node-postgres to connect to PostgreSQL:

npm i express pg

Now, we have our dependencies loaded into node_modules and package.json.

Create an index.js file, which we'll use as the entry point for our server. At the top, we'll require the express module, the built-inbody-parser middleware, and we'll set our app and port variables:

const express = require('express') const bodyParser = require('body-parser') const app = express() const port = 3000 app.use(bodyParser.json()) app.use( bodyParser.urlencoded({ extended: true, }) )

We’ll tell a route to look for a GET request on the root/ URL and return some JSON:

app.get('/', (request, response) => { response.json({ info: 'Node.js, Express, and Postgres API' }) })

Now, set the app to listen on the port you set:

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

From the command line, we can start the server by hitting index.js:

node index.js App running on port 3000.

Go to http://localhost:3000 in the URL bar of your browser, and you'll see the JSON we set earlier:

{ info: "Node.js, Express, and Postgres API" }

The Express server is running now, but it’s only sending some static JSON data that we created. The next step is to connect to PostgreSQL from Node.js to be able to make dynamic queries.

Connecting to a Postgres database using a Client

A popular client for accessing Postgres databases is the pgAdmin client. The pgAdmin application is available for various platforms. If you want to have a graphical user interface for your Postgres databases, you can go to the download page and download the necessary package.

Creating and querying your database using pgAdmin is simple. You need to click on the Object option available on the top menu, select Create, and choose Database to create a new connection. All the databases are available on the side menu. You can query or run SQL queries efficiently by selecting the proper database:

Connecting to a Postgres database from Node.js

We’ll use the node-postgres module to create a pool of connections. Therefore, we don’t have to open and close a client each time we make a query.

A popular option for production pooling would be to use [pgBouncer](https://pgbouncer.github.io/), a lightweight connection pooler for PostgreSQL.

const Pool = require('pg').Pool const pool = new Pool({ user: 'me', host: 'localhost', database: 'api', password: 'password', port: 5432, })

In a production environment, you would want to put your configuration details in a separate file with restrictive permissions so that it is not accessible from version control. But, for the simplicity of this tutorial, we’ll keep it in the same file as the queries.

Creating routes for CRUD operations

We’ll create six functions for six routes, as shown below. First, create all the functions for each route. Then, export the functions so they’re accessible:

GET all users

const getUsers = (request, response) => { pool.query('SELECT * FROM users ORDER BY id ASC', (error, results) => { if (error) { throw error } response.status(200).json(results.rows) }) }

GET a single user by ID

const getUserById = (request, response) => { const id = parseInt(request.params.id) pool.query('SELECT * FROM users WHERE id = $1', [id], (error, results) => { if (error) { throw error } response.status(200).json(results.rows) }) }

POST a new user

The API will take a GET and POST request to the/users endpoint. In the POST request, we'll add a new user. In this function, we're extracting the name and email properties from the request body and inserting the values with INSERT:

const createUser = (request, response) => { const { name, email } = request.body pool.query('INSERT INTO users (name, email) VALUES ($1, $2) RETURNING *', [name, email], (error, results) => { if (error) { throw error } response.status(201).send(`User added with ID: ${results.rows[0].id}`) }) }

PUT updated data in an existing user

The /users/:id endpoint will also take two HTTP requests, the GET we created for getUserById and a PUT to modify an existing user. For this query, we'll combine what we learned in GET and POST to use the UPDATE clause.

const updateUser = (request, response) => { const id = parseInt(request.params.id) const { name, email } = request.body pool.query( 'UPDATE users SET name = $1, email = $2 WHERE id = $3', [name, email, id], (error, results) => { if (error) { throw error } response.status(200).send(`User modified with ID: ${id}`) } ) }

DELETE a user

const deleteUser = (request, response) => { const id = parseInt(request.params.id) pool.query('DELETE FROM users WHERE id = $1', [id], (error, results) => { if (error) { throw error } response.status(200).send(`User deleted with ID: ${id}`) }) }

Exporting CRUD functions in a REST API

module.exports = { getUsers, getUserById, createUser, updateUser, deleteUser, }

Our complete queries.js file is below:

const Pool = require('pg').Pool const pool = new Pool({ user: 'me', host: 'localhost', database: 'api', password: 'password', port: 5432, }) const getUsers = (request, response) => { pool.query('SELECT * FROM users ORDER BY id ASC', (error, results) => { if (error) { throw error } response.status(200).json(results.rows) }) } const getUserById = (request, response) => { const id = parseInt(request.params.id) pool.query('SELECT * FROM users WHERE id = $1', [id], (error, results) => { if (error) { throw error } response.status(200).json(results.rows) }) } const createUser = (request, response) => { const { name, email } = request.body pool.query('INSERT INTO users (name, email) VALUES ($1, $2)', [name, email], (error, results) => { if (error) { throw error } response.status(201).send(`User added with ID: ${results.insertId}`) }) } const updateUser = (request, response) => { const id = parseInt(request.params.id) const { name, email } = request.body pool.query( 'UPDATE users SET name = $1, email = $2 WHERE id = $3', [name, email, id], (error, results) => { if (error) { throw error } response.status(200).send(`User modified with ID: ${id}`) } ) } const deleteUser = (request, response) => { const id = parseInt(request.params.id) pool.query('DELETE FROM users WHERE id = $1', [id], (error, results) => { if (error) { throw error } response.status(200).send(`User deleted with ID: ${id}`) }) } module.exports = { getUsers, getUserById, createUser, updateUser, deleteUser, }

Setting up CRUD functions in a REST API

Now that we have all of our queries, we need to pull them into the index.js file and make endpoint routes for all the query functions we created.

To get all the exported functions from queries.js, we'll require the file and assign it to a variable:

const db = require('./queries')

Now, for each endpoint, we’ll set the HTTP request method, the endpoint URL path, and the relevant function:

app.get('/users', db.getUsers) app.get('/users/:id', db.getUserById) app.post('/users', db.createUser) app.put('/users/:id', db.updateUser) app.delete('/users/:id', db.deleteUser)

Below is our complete index.js file, the entry point of the API server:

const express = require('express') const bodyParser = require('body-parser') const app = express() const db = require('./queries') const port = 3000 app.use(bodyParser.json()) app.use( bodyParser.urlencoded({ extended: true, }) ) app.get('/', (request, response) => { response.json({ info: 'Node.js, Express, and Postgres API' }) }) app.get('/users', db.getUsers) app.get('/users/:id', db.getUserById) app.post('/users', db.createUser) app.put('/users/:id', db.updateUser) app.delete('/users/:id', db.deleteUser) app.listen(port, () => { console.log(`App running on port ${port}.`) })

With just these two files, we have a server, database, and API all setup. You can start up the server by hitting index.js again:

node index.js App running on port 3000.

To test our POST, PUT, and DELETE requests, we can use a tool like Postman or a VS Code extension like Thunder Client to send the HTTP requests. You can also use curl, a command-line tool that is already available on your terminal.

Using a tool like Postman or Thunder Client makes it simple to query endpoints with different HTTP methods. Simply enter your URL, choose the specific HTTP method, insert the JSON value if the endpoint is a PUT or POST route, and hit Send:

Here’s an example of sending a POST request to the specified route to create a new user using Postman:

Here’s an example of sending a PUT request to the specified route to modify a user by its ID:

Here’s an example of sending a GET request to the specified route to retrieve a user by its ID:

Here’s an example of sending a GET request to the specified route to retrieve all users:

Finally, here’s an example of sending a DELETE request to the specified route to delete a user by its ID:

Solutions to common issues encountered while developing APIs

Developing APIs can come with various challenges. Let’s go over the solutions to two common issues encountered during API development: CORS issues and unhandled errors due to middleware order.

Handling CORS issues

Browser security policies can block requests from different origins. To address this issue, use the cors middleware in Express to handle cross-origin resource sharing (CORS).

Run the following command to install cors:

npm install cors

To use it, do the following:

var express = require('express') var cors = require('cors') var app = express() app.use(cors())

This will enable CORS for all origins.

Middleware order and error handling

Middleware order can affect error handling, leading to unhandled errors. To address this issue, place error-handling middleware at the end of your middleware stack and use next(err) to pass errors to the error-handling middleware:

app.use((req, res, next) => { const error = new Error('Something went wrong'); next(error); }); // Error-handling Middleware app.use((err, req, res, next) => { console.error('Error:', err.message); res.status(500).send('Internal Server Error'); });

Securing the API

When it comes to securing APIs, we need to implement various mechanisms to ensure the confidentiality, and integrity of the application and its data. Let’s go over a few of these mechanisms now.

Authentication

I will recommend the Passport middleware for Node.js, which makes it easy to implement authentication and authorization. Here’s an example of how to use Passport:

const passport = require('passport'); const LocalStrategy = require('passport-local').Strategy; passport.use(new LocalStrategy( function(username, password, done) { // Verify username and password // Call done(null, user) if authentication is successful } ));

Authorization

It’s important to enforce proper access controls to restrict access to specific routes or resources based on the user’s role or permissions. For example, you can check if the user making a request has admin privileges before allowing or denying them permission to proceed with the request:

function isAdmin(req, res, next) { if (req.user && req.user.role === 'admin') { return next(); } else { return res.status(403).json({ message: 'Permission denied' }); } }

You can apply the isAdmin middleware defined above to any protected routes, thus restricting access to those routes.

Input validation

Validate and sanitize user inputs to prevent SQL injection, XSS, and other security vulnerabilities. For example:

const { body, validationResult } = require('express-validator'); app.post('/users', [ // add validation rules ], (req, res) => { const errors = validationResult(req); if (!errors.isEmpty()) { return res.status(422).json({ errors: errors.array() }); } // Process the request });

The code above allows you to specify validation rules for POST requests to the /users endpoint. If the validation fails, it sends a response with the validation errors. If the incoming data is correct and safe, it proceeds with processing the request.

Helmet middleware

You can use the Helmet middleware to set various HTTP headers for enhanced security:

const helmet = require('helmet'); app.use(helmet());

Configuring HTTP headers with Helmet helps protect your app from security issues like XSS attacks, CSP vulnerabilities, and more.

Additional notes and suggestions

You can build on this tutorial by implementing the following suggestions:

• Integration with frontend frameworks: Choose a frontend framework or library (e.g., React, Angular, Vue.js) to build a user interface for your application. Then, implement API calls from the frontend to interact with the backend CRUD operations. You can consider state management solutions (e.g., Redux, Vuex) for managing the state of your frontend application
• Containerizing the API: Write a Dockerfile to define the environment and dependencies needed to run your Node.js app. Create adocker-compose.yml file for managing multiple containers, such as the Node.js app and PostgreSQL database. This will make your Node.js application easier to deploy and set up on other machines
• Implementing unit/integration tests: Write unit tests for individual functions and components of your application to ensure that they work as expected. Use testing frameworks like Mocha, Jest, or Jasmine for writing and running tests. Implement integration tests to verify the interactions between different components in your front-end application and the overall functionality of your API
• Continuous integration/deployment (CI/CD): Set up CI/CD pipelines to automate the testing and deployment processes. Use tools like Jenkins, Travis CI, or GitHub Actions to streamline the development/deployment workflow

While implementing these next steps is beyond the scope of this tutorial, you can use these ideas to apply what we’ve discussed to a real use case.

Conclusion

You should now have a functioning API server that runs on Node.js and is hooked up to an active PostgreSQL database.

In this tutorial, we learned how to install and set up PostgreSQL in the command line, create users, databases, and tables, and run SQL commands. We also learned how to create an Express server that can handle multiple HTTP methods and use the pg module to connect to PostgreSQL from Node.js.

With this knowledge, you should be able to build on this API and utilize it for your own personal or professional development projects.

Note: This article was updated on 20-Dec-21 to use v2.0.0 of the Node.js token server.

Security in video chat applications is a hot topic at the moment. As remote working and virtual events become more widespread, the need for security will increase.

In the Agora platform, one layer of security comes in the form of token authentication. A token is a dynamic key that is generated using a set of given inputs. The Agora platform uses tokens to authenticate users.

Agora offers token security for its RTC and RTM SDKs. This guide will explain how to build a simple microservice using Node.js and Express to generate these tokens.

Prerequisites

• An Agora developer account (It’s free! Sign up here)
• A basic understanding of JavaScript ES6, Node.js, and NPM
• A basic of how Express web servers function (minimal knowledge needed)

Project Setup

To start our project, we’ll create a new folder and open a terminal window in this folder. In the terminal, we’ll run npm init to set up the node project. The create project prompt will appear. I used the default settings, but feel free to customize this portion.

Now that the project has been created, we can add our NPM dependencies ( express, agora-access-token, and dotenv) using:

npm install express agora-access-token dotenv

Build the Express Server

Now that the project is set up, open the folder in your favorite code editor. Looking at the package.json, you'll notice that the entry file is index.js. This file doesn't exist in our project, so we'll have to create a new file and name it index.js.

In the index.js we'll start by requiring our modules. From Express, we'll need the Express object, and from agora-access-token we'll extract references to the RtcTokenBuilder and RtcRole objects. We'll also use dotenv from its package for our environment variables:

const express = require('express');
const {RtcTokenBuilder, RtcRole} = require('agora-access-token');
const dotenv = require('dotenv');

Let’s define our constants by creating a .env file and adding our Agora credentials and the port we're going to use to listen for requests:

APP_ID=970XXXXX...
APP_CERTIFICATE=5CFXXXXX...
PORT=8080

Next, we’ll define our app constant that will instantiate our Express object and allow us to set up our server:

const app = express();

Before we can set up the GET endpoint for our Express server, we’ll need to define the functions that are invoked when the endpoint is accessed. The first function ( nocache) will apply the response headers, which force the browser to never cache the response, ensuring that we always get a fresh token. You'll notice we call the next() method at the end because this function is a middleware function that is the first in the series, so we need to call next() to let Express know to continue to the next function in the series:

const nocache = (_, resp, next) => {
  resp.header('Cache-Control', 'private, no-cache, no-store, must-revalidate');
  resp.header('Expires', '-1');
  resp.header('Pragma', 'no-cache');
  next();
}

The second function ( generateRTCToken) will handle the request and return the JSON response. We'll define the function now and add the body once we finish setting up the Express server. This is the last function in the series, so we don't need the next parameter/function:

const generateRTCToken = (req, resp) => { };

Let’s define a GET endpoint /rtc, passing in the nochache and generateRTCToken functions:

app.get('/rtc/:channel/:role/:tokentype/:uid', nocache , generateRTCToken)

You’ll notice the route contains :<path>. The colon (:) marks the path as a variable, and the user can pass in values like channel name, user role, type of token, and user UID to the route. We can access this data in our application.

As the last step in creating our Express server, we’ll implement the listen() method and pass in the port and a callback once the server is ready and listening on the given port:

app.listen(PORT, () => {
  console.log(`Listening on port: ${PORT}`);
});

Generate the Agora RTC Token

Now that we have our Express server set up, we are ready to add the functionality to the generateRTCToken function. We'll start by setting the response header to ensure that we don't run into any CORS issues:

const generateRTCToken = (req, resp) => {
  resp.header('Access-Control-Allow-Origin', '*');

Get the Request Parameters

Next, we’ll check for the channel in our request parameters. This is a required parameter, so if channelName is undefined, we need to return an error with a 500 response code and a JSON object with the error:

 const channelName = req.params.channel;
  if (!channelName) {
    return resp.status(500).json({ 'error': 'channel is required' });
  }

For uid and role we'll perform similar checks:

  let uid = req.params.uid;
  if(!uid || uid === '') {
    return resp.status(500).json({ 'error': 'uid is required' });
  }
  // get role
  let role;
  if (req.params.role === 'publisher') {
    role = RtcRole.PUBLISHER;
  } else if (req.params.role === 'audience') {
    role = RtcRole.SUBSCRIBER
  } else {
    return resp.status(500).json({ 'error': 'role is incorrect' });
  }

Note: The only privilege enforced by the Agora platform by default is the join channel privilege. To enable the enforcement of other privileges, you need to make a request through Agora Support.

The user can optionally pass in an expiry query parameter that will set the time for the token to expire. We can access the value and check whether it exists. Otherwise, we set a suitable default of 3600 seconds:

 let expireTime = req.query.expiry;
  if (!expireTime || expireTime === '') {
    expireTime = 3600;
  } else {
    expireTime = parseInt(expireTime, 10);
  }

We’ll calculate the expiration time. It needs to be an integer that represents the time since Jan 1, 1970. We’ll use the current time and add our expiration time to it:

  const currentTime = Math.floor(Date.now() / 1000);
  const privilegeExpireTime = currentTime + expireTime;

Build the Token

Now that we have all the elements for our token, we are ready to use the RtcTokenBuilder object to generate the token. We'll check the tokenType and call the appropriate method on the object, passing in the required values:

  let token;
  if (req.params.tokentype === 'userAccount') {
    token = RtcTokenBuilder.buildTokenWithAccount(APP_ID, APP_CERTIFICATE, channelName, uid, role, privilegeExpireTime);
  } else if (req.params.tokentype === 'uid') {
    token = RtcTokenBuilder.buildTokenWithUid(APP_ID, APP_CERTIFICATE, channelName, uid, role, privilegeExpireTime);
  } else {
    return resp.status(500).json({ 'error': 'token type is invalid' });
  }

Return the Response

The last step in generating our token is returning the JSON response that contains the token:

...
  return resp.json({ 'rtcToken': token });
}

Test the Token Server

Let’s go back to our package.json and add a command in the object. The start command will execute the node index.js command so that we can run our server instance:

{
  "scripts": {
    "start": "node index.js"
  },
}

Start the server

Let’s go back to our Command Prompt window and use our new command: npm start

Once the server instance is listening, we’ll see “Listening on port: 8080” (or the port in your .env file) in our terminal window.

Test the endpoint

Now that our server instance is running, let’s open our web browser and test.

For example, pass “test” as the channel, "publisher" as the role, and "uid" as the tokenType with the UID of "1" :

http://localhost:8080/rtc/test/publisher/uid/1

This will display:

{"rtcToken":"0062ec0d84c41c4442d88ba6f5a2eeb828bIAD9qg4N4hd04MvaY6A72m4BjYmO/7+xnRMinaI0ncLzkAx+f9gAAAAAEACS0zcn9gASXwEAAQCGvRBf"}

Other examples produce a similar output:2

localhost:8080/rtc/test/publisher/uid/1 localhost:8080/rtc/test/publisher/uid/1?expiry=1000 localhost:8080/rtc/test/subscriber/userAccount/ekaansh

RTM Tokens

We can use the same process to configure a route to generate RTM tokens. You can look at the generateRTMToken function in the finished project for generating RTM tokens. The /rtm route looks like this, passing in a UID as "1":

http://localhost:8080/rtm/1

The response looks like:

{"rtmToken":"0062ec0d84c41c4442d88ba6f5a2beb828bIAD9qg4N4hd04MvaY6A72m4BjYmO/7+xnRMinaI0ncLzkAx+f9gAAAAAEACS0zcn9gASXwEAAQCGvRBf"}

Conclusion

And just like that, we are done! In case you weren’t coding along or want to see the finished product together, you can find it on GitHub. You can deploy it to Heroku in two clicks using the button in the Readme.

There’s also a version written in Typescript available on the typescript branch. If you see any room for improvement, feel free to fork the repo and make a pull request!

Other Resources

For more information about tokens for Agora applications, you can take a look at the Set up Authentication guide. We also have a token server built with Golang and Gin that you can find here.

If you have any questions, I invite you to join the Agora Developer Slack community and ask them there.