DEV Community: Juan P. Lima

Automatically deploy your NestJS API to AWS Elastic Beanstalk using GitHub Actions

Juan P. Lima — Wed, 10 Jan 2024 10:36:42 +0000

After last week's post about deploying your NestJS API to AWS Elastic Beanstalk(https://dev.to/juanpireslima/deploy-your-nestjs-api-on-aws-elastic-beanstalk-1on1), in this post, I'm going to help you make this process automatic by using GitHub Actions.

We're going to start this post from where we stopped on the last one, which we:

Created an AWS Elastic Beanstalk Application from scratch
Deployed our NestJS API manually to AWS Elastic Beanstalk

If you have already created your Elastic Beanstalk Application and are all set up to automate the deployment process, you can keep reading without any problem, either way, I highly recommend that you read the previous post before this one if you haven't yet.

Set up GitHub Actions 👷

The first thing we're going to do is set up our GitHub Actions, for that, we can go to our repository page, click on actions, and then click on "set up a workflow yourself":

After doing so, it's going to open a page for you to write the actions file, on the actions file, we need to set a name for our action, which I'm going to call "deploy", set up a trigger, which on my case it's going to run on every push to the main branch, and then we'll be setting up our jobs, the only job we're going to have is the one called "build-and-deploy", this job is going to run on ubuntu and it's going to:

Install dependencies
Build our project
Compress files(since we need to send a .zip to Elastic Beanstalk)
Configure AWS Credentials
Install Elastic Beanstalk CLI
Deploy our project to Elastic Beanstalk

To correctly set up our AWS, we'll need to add some variables on our GitHub settings, you can do so by going to settings -> Secrets and variables -> Actions; there you'll be able to set up both variables and secrets, in our actions example, our AWS access key and region is a variable, while the secret is a secret, you should be creating them on the "Repository variables" section(I won't be covering the creation of AWS access credentials on this post):

One more thing you might've noticed is that on the deployment step, we're sending a label to Elastic Beanstalk, Elastic Beanstalk uses labels to version our project, so we must send a different label for each version of our API, that's why I'm using "github.event.repository.pushed_at" at the end, so I can get the timestamp of the last time something have been pushed to the repository, therefore making my label unique for each iteration on my code.

PS: The word "test" after "eb deploy" is the name of the environment I'm deploying to, while "my-api" after "eb init" is the name of my Elastic Beanstalk Application.

Set up Elastic Beanstalk config 🔧

Before running our newly created action, we must create a config file for Elastic Beanstalk so it knows our deployment artifact will be called "my-api.zip", for that, we need to create a folder called ".elasticbeanstalk" at the root of our project, and there we'll have a file named "config.yml", there we'll be saying to Elastic Beanstalk that it should be deploying the artifact "my-api.zip":

Bonus: Changing the script Elastic Beanstalk will be running 💡

As said in the previous post about Elastic Beanstalk, it runs "npm run start" by default, but we can change that by creating a file called "Procfile" on the root of our project and changing the command that's going to run:

Run your GitHub actions 👌

Once you've followed all the steps, you can commit all your changes, once the trigger is actioned, your action is going to run, as you can see, my actions ran without any problems:

Here's my API working:

Hope I was able to help you guys automate the deployment of your NestJS API to AWS Elastic Beanstalk, you can find my code at: https://github.com/juanpireslima/nestjs-elastic-beanstalk
If you haven't yet, I highly recommend you read my previous article about Deploying a NestJS API to Elastic Beanstalk, there, I wrote about:

Creating an AWS Elastic Beanstalk Application - from scratch Manually deploying a NestJS API to AWS Elastic Beanstalk

You can find it at: https://dev.to/juanpireslima/deploy-your-nestjs-api-on-aws-elastic-beanstalk-1on1

Deploy your NestJS API on AWS Elastic Beanstalk

Juan P. Lima — Wed, 03 Jan 2024 10:36:18 +0000

Have you ever wondered how you can deploy your NestJS API on AWS Elastic Beanstalk? Wonder no more, in this article, we'll be deploying a NestJS API from scratch.

Pre-requisites 📔

To follow this tutorial, you'll need:

AWS Account
NestJS project

Neither of these will be covered in this post, only the deployment.

Creating your Elastic Beanstalk Application 👷

Let's start by creating our Elastic Beanstalk application, to do so, you'll need to go to the Elastic Beanstalk service page, you'll see a button called "create application", you can click on that button to start the creation process:

PS: Make sure you're in the right region.
In the first creation step, we'll have to select the environment tier we want to create, for our API, we must use the "Web server environment" tier for our API, and then we can choose the name for our application, and environment information(you can't change this info later on) such as name and domain our API will be running:

Next, we must choose the platform we're going to run, in our case, Node.js, I'll be using version 18 in this example, and then we can select to start our Elastic Beanstalk with a sample application(we'll be uploading our code later on), and we must choose which configuration preset we want to help us choose the right server configuration, I'll be going with a simple single instance:

Going to the next step, you'll have to set a role for the Elastic Beanstalk application(you can create one at that moment as well), an EC2 key pair(you can generate the SSH key on the EC2 service page by clicking on "Key pairs" on the left menu), and an instance profile for the EC2 instances that the Beanstalk is going to create(you can create this on IAM):

On the next(optional) step, you can set up networking, database, and tags; there you can select if you're going to use a VPC, select if your instance is going to be publicly accessible and the subnets, I'll be setting up a VPC and setting my instance public and choosing two subnets:

You can also integrate an RDS SQL database with your environment(we won't be covering this step config in this post):

On the 4th step(optional), you can set up info for your EC2 instances that will be created by Elastic Beanstalk, you can select the security group, and the root volume, and also set up the auto-scaling, you can choose if you want a single instance environment or a load balanced one, as well as the minimum and maximum amount of instances you want to have(if load balanced), you can also choose the instance types that Elastic Beanstalk will be creating:

On the 5th(also optional) step, you can set up updates, monitoring, and logging; we won't be covering this 5th step in this post.
In the last step, we'll be reviewing everything we have chosen and then submit our application creation:

Accessing your sample Elastic Beanstalk Application 🚀

After submitting your application creation, you can access the domain link that you have chosen in the creation process, you can see it in the "Environment overview" section:

By accessing it, you are going to see this page:

That page means your application has been successfully created 👏

Deploying your NestJS API 🙌

Now it's time to deploy our NestJS API, first, we'll need to check which port our NestJS App is running, Elastic Beanstalk uses port 8080 by default, you should either set that as your API port or check for the environment variable called "PORT", so you can run the project on the right port:

Then, you must make a change on your start script since that's the one Elastic Beanstalk will be running by default, you must make it execute the main file from the build:

now you can build your NestJS App, then we'll be compressing all local files(no need to send the node_modules, Elastic Beanstalk will be installing it for you):

Once you have compressed your project, you can go to Elastic Beanstalk, and click on "Upload and deploy":

and then choose your zip file, as well as write a label for your version being deployed:

Now you can click on "Deploy" and wait for your project to be deployed, once it's deployed, you can go to the domain you have chosen and there it is:

Hope I was able to help you guys deploy your NestJS project on AWS Elastic Beanstalk, have a good one 😉

Improving your App's Performance: Solving the N+1 Problem

Juan P. Lima — Sun, 11 Jun 2023 10:41:13 +0000

In this article, we'll be using a simple NodeJS API and a Postgres DataBase, the DB will have the following model:

We'll have the category table and the item table, and there can be many items associated with one category.
On our NodeJS API, we'll have a function that will get all categories and their following items:

And we'll have a function that will be getting items by category:

for this article, we'll have:
Category A with the items: Item 1, and Item 2
Category B with Item 3

The return from our getCategories function will be an array of categories, each one having a property called "items" that will be an array of items associated with that particular category:

The Problem

So, have you noticed any particular performance issue with the way we're getting our categories and their items? No? So let me explain…

The N+1 Problem

Have you ever heard about the N+1 problem? That's when we execute N queries when we could've executed just 1, executing more queries will not only decrease the performance but will also consume more resources, and that's something we don't want in our apps.
Going back to our example, we're executing 1 query statement to get all the categories, then we're executing another query for each category so we can get its items, in our case, we're running 3 queries, but as the amount of categories increases, so do our number of requests on the items table, making it a Big O(N).

Fixing our code

Now that we know where the problem is, let's get started with our fix, first things first, we no longer need to loop through all our categories, since the items property will be coming from our query, we can also return directly the rows returned from our query, and then we can start using the "LEFT JOIN" statement in our query to fetch all items from that category.

Our query would look something like this:SELECT * FROM category c LEFT JOIN item i ON i.category_id = c.id; , the problem with this query, is that it won't be returning the data in the format we're expecting, see an example from executing this query on DBeaver:

It would be repeating the category on every item it has, that's not what we want, so we need to make one last change in our query, that is, selecting all category's properties, aggregate the values coming from the item table, and add a "Group By" clause with the id of our category on it, that would be our final query: SELECT c.*, json_agg(i) items FROM category c LEFT JOIN item i ON i.category_id = c.id GROUP BY c.id; , see how the result looks on DBeaver:

Now going back to our code and making all the necessary changes, we'd end up with the following code:

by making a request, we'd get the following result:

As you can see, it's the exact same result we had with our underperforming code, but using a way better approach.

Benefits

There are numerous benefits now that we are free from our N+1 problem, some of them are:
Improved performance: Now that we're no longer running multiple queries, the additional network latency plus the database processing that came with these other queries, will no longer exist.
Reduced network traffic: As mentioned above, we're running fewer queries, therefore, we won't be using as much traffic.
Scalability: By running fewer queries, we won't be overloading our database with multiple requests, so we can achieve more with fewer resources.

Conclusions

Hope you people could learn a little more about how to improve the performance of your APPs, both suggestions and corrections are welcome!

Deploying your NestJS API on AWS Lambda

Juan P. Lima — Tue, 24 Jan 2023 21:28:34 +0000

If it's your first time dealing with AWS Lambda or if you would like to know a little more about it, you can check out my first article on the AWS Lambda series that will explain to you what AWS Lambda is, how to use, when to use, and when not to; you can find it right here -> Click Me <-

Starting your NestJS Project

In this section, I'll start a new NestJS project, if you already have one, feel free to skip this section.
First, we'll need to globally install Nest's cli: npm i -g @nestjs/cli , then you can generate a new NestJS project using nest new your-project-name, after doing so, your project will be generated, your folder should look something like this:

Setting up serverless framework

Now that you have your NestJS project, let's set up the serverless framework that will help us deploy our API to AWS Lambda, first, you'll need to install the following packages:
npm i @vendia/serverless-express
npm i -g serverless
Once it's done, we should create our handler function to handle Lambda's events, I'll create mine on the file lambda.ts I've created on the "src" folder, there we'll start our NestJS-Express server and create a function that will deal with our events:

Finally, we should create the serverless.yml file that will configure the serverless framework, you should create it on the root directory, there you'll be able to set the function's timeout, memory, region…

Deploying

Before deploying your project to AWS Lambda, you'll need to configure your credentials on serverless, I won't be covering it here, but you can check Serverless' documentation on that here -> Click Me <-

Now that it's all set up, you can run serverless deploy , wait a few seconds and your project will have been deployed, you can check it on AWS Lambda's page:

You can click on your function to see more details and test if it's working as expected, you can find the link to do it on configuration->triggers:

With that link, you can use your favorite API Client to test if it's working as expected:

As you can see, mine is working just fine.

Conclusions

As you guys can see, its really simple to deploy your NestJS project to AWS Lambda, this was the third article of my AWS Lambda series, you can check the previous articles on the following links:
-> AWS Lambda: What it is, how to use, when to use, and when not to<-
-> Deploying a NodeJS - Express API to AWS Lambda <-

Github repository with my example -> Click Me <-

NestJS documentation about serverless framework -> Click Me <-

Deploying a NodeJS - Express API to AWS Lambda

Juan P. Lima — Thu, 19 Jan 2023 00:14:49 +0000

If you don't know what AWS Lambda is or would like to learn a little more about it, I highly recommend that you read the first article of my AWS Lambda series, you can find it right here -> Click me <- On this second article, I'm going to teach you guys how you can deploy your NodeJS-Express API to AWS Lambda.

Starting your project

In this section, I'm going to start a new NodeJS-Express project, if you already have one, feel free to jump this section. You can also check the source code on my GitHub that will be at the end of this post.

After creating a folder for your project(name it whatever you like) you can execute npm init -y to generate your package.json, after doing so, you should install express on your project, you can do it by executing npm install express, now we can create our first router, controller, and service.
In this example I'll be creating a ping route, controller, and service. Your folder should look something like this:

On our ping.services.js we will have our PingService class with a method called getPing that will return the word "pong":

Now on our ping.controller.js, we'll have our PingController class with a method the same name as the service one, and it will call the PingService's getPing method, returning the http 200 status and its result on a json:

Then on our ping.routes, we'll have a get route that will be handled by our PingController's method getPing, your file will look like this:

And last but not least, we'll set up our index.js on the routes folder, this is what it will look like:

Now we're ready to go to the next step.

Setting up serverless framework

Serverless is the name of the framework that will help us deploy our project to the AWS Lambda, first, you should install "serverless-http" dependency on your project(npm install serverless-http), then you'll need to globally install serverless framework by typing npm install serverless -g then you'll need to install a devDependency called "serverless-offline" you can do it with npm install serverless-offline -D.

Now we can create our handler function that will handle our HTTP requests, on my project's root directory, I'll create a file called lambda.js, there we'll create our express application and export our handler that will contain our app wrapped to work with AWS Lambda-API Gateway:

Now we'll need to set up our serverless settings, on our root directory, we should create a file named "serverless.yml", there you'll have the runtime your project will be running in, the name of your service, the region your function will be deployed… it will look like this:

Finally, we can now create a script on our package.json so we can check if everything is working as expected:

You can use nodemon if you like, this function will run our serverless-offline using the settings on our serverless.yml, we'll be running our project the same way lambda will, by running this script, our server will start running and we'll be able to make requests, I've tested mine using Insomnia:

As you can see, mine is working without any issues.

Deploying to AWS Lambda

Now it's time for us to deploy our project to AWS Lambda, for it, you'll have to configure your credentials on serverless, I won't be covering here how you can do it, but you can found out in this guide: -> Click Me <-

After doing so, you can run serverless deploy , after doing so, you can see your function on AWS Lambda function list:

Serverless framework will have created the function for you with an API-Gateway trigger and with all settings you have set, by clicking on your function, you can see its details, and by going to configuration -> Triggers, you'll find the API-Gateway trigger with your API URL:

You can grab your API endpoint and test it using your favorite API Client, I'll be testing it using Insomnia:

As you can see, my API is working just fine.

Conclusions

As you can see, it's that easy to deploy your NodeJS-Express API to AWS Lambda, feel free to comment any suggestion or feedback, if you haven't read the first article of the series, you can check it out -> here <-
GitHub repository with our example: https://github.com/juanpireslima/nodejs-api-lambda

Wish you all the best.

AWS Lambda: What it is, how to use, when to use, and when not to

Juan P. Lima — Tue, 10 Jan 2023 17:04:14 +0000

What is is

AWS Lambda is a serverless, event-driven service that lets you run code without having to manage servers. Similar services includes Microsoft Azure and Google cloud functions.

Advantages

Some advantages of using AWS Lambda includes:

Pay-as-you-go: On AWS Lambda, you're only charged for the number of requests and the duration of your functions, this means you will only be paying for what you use, more pricing info at https://aws.amazon.com/lambda/pricing
Auto-scaling: If there's already one request being handled, AWS Lambda will provide separate instances for concurrent requests, by default, your account will have a limit of 1,000 concurrent requests across all Lambda functions in a region, but if you need, you can request a quota increase, more info at https://docs.aws.amazon.com/lambda/latest/dg/lambda-concurrency.html
Server-free: You won't have to provide nor manage the infrastructure of your Lambda function, just upload your code as a .zip file or container image and you're good to go

Disadvantages and limitations

Lambda's got a lot of advantages, but it's not all roses, let's take a look at some disadvantages and some limitations of it:

Server-free: Both an advantage and a disadvantage, why? It's simple if you need to have full control of the environment your code is running, Lambda won't offer you this option
10 GB Of temporary storage: On Lambda, you'll have up to 10 GB of temporary storage for your code, in most cases, it's going to be enough, but in some cases, you might need more(Large files like videos…).
15-minute limit timeout: 15 minutes is the maximum timeout you can set on your Lambda function, again, this will fit most functions, but for some, it may not be enough.
Deployment package limit of 250MB for unzipped and 50MB for zipped packages, this makes AWS Lambda not a good fit for big applications.

How to use it

After creating your AWS Account(I won't cover this process here), you can access the Lambda service, the first thing you're going to see is the following page:

There you'll have some examples with different technologies: .NET, Node.js, Go… looking at those examples, you'll realize it's pretty simple to set up your first Lambda function, to do so, let's click to create a function, after doing so, you'll see this screen:

There, you'll be able to start your function with a simple hello world, use a blueprint or select a container image; then you'll have some more settings, like the name of your function, the runtime of your function… lets create our hello world example.
After creating your first function, you'll be redirected to it, and have the following view:

there you'll see that it was generated a handler function for us, and that's the function Lambda will always execute, so you always gotta have a handler to be executed, that's how you'll handle your requests. Your function may deal with HTTP requests, WebSocket connections/messages… but we won't be covering this here.
As you can see on the right-side, you can upload your code from a .zip file or from a S3 location, you can even code on the "Code source" section, make it your playground to discover what you can do with Lambda.

When to use it, and when not to

Lambda is a great alternative if you don't need to have fully control of the environment your code is running and if your use respects Lambda's limitations, it will help you deploy faster and your code will be auto-scaling, thus not having to worry much about scaling it, also, you'll only pay what you use, and most times it's a really great deal.

When your project start getting bigger, Lambda may not be the best choice, that's because you might need more control over the environment your code is running or the running period might be so long, that would be worth it to go for an EC2 or else, you could still use Lambda for your micro-services though.

Conclusions

There's a lot of advantages and disadvantages of using AWS Lambda, it may or may not fit for your project, but I suggest you giving it a try nevertheless.
You can create some small projects to see what Lambda is capable of, after all, there's a free tier so you won't be charged for some small tests.
I hope I could bring you some insights on how you can use Lambda functions on your projects and the potential of it, and, hopefully, some of you may walk your first step towards using Lambda functions.

Why computer floating points are inaccurate

Juan P. Lima — Tue, 05 Apr 2022 02:12:50 +0000

Some days ago I went through a curious situation, I had a simple function that would turn money into cents, It was working properly until this happened:
18.17 was the float being sent to the function, the function was basically floatNumber x 100 and I had no idea why every number I tested was working just fine but this one was not, I tested it on my browser and the same thing happened, I had to find a way how to make it work…

It happens in almost every programming language

So, after some research, I discovered the 0.1 + 0.2 problem and why in most programming languages 0.1 + 0.2 != 0.3(yes, you read it right), take a look at some of these examples:
JS:
Java:
Dart:
As you can see, in these languages 0.1 + 0.2 != 0.3.

Why does this happen?

Double-precision floating-point format, also known as binary64(https://en.wikipedia.org/wiki/Double-precision_floating-point_format), is a computer number format most of our processors follow, it stores our number in bits this way:
Having 64 bits, 1bit is for the sign so we know if the number is positive or negative, 11bits are the exponent(https://en.wikipedia.org/wiki/Exponentiation) that will tell us if our mantissa represents an integer or a fraction, and 52bits for the mantissa(https://en.wikipedia.org/wiki/Significand) that gives us from 15 to 17 decimal digits precision, the problem is: some numbers just can’t be fully represented exactly in this way, only approximately.

The solution

My solution: The solution for my problem, converting money into cents was the following:
All I needed was to move the decimal points 2x to the right, and I did so by using the e notation(https://en.wikipedia.org/wiki/Scientific_notation#E_notation) which represents 10 to the power of the number that comes next, in my case, 2.

Final thoughts
I brought only one solution, but there are more solutions out there that will fit better what you want to do, so go ahead, find out more solutions, and don’t forget to come back here and comment the solution you’ve found so more people will benefit from this article, wish you all the best.

https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html
https://en.wikipedia.org/wiki/Double-precision_floating-point_format

DEV Community: Juan P. Lima

Automatically deploy your NestJS API to AWS Elastic Beanstalk using GitHub Actions

Set up GitHub Actions 👷

Set up Elastic Beanstalk config 🔧

Bonus: Changing the script Elastic Beanstalk will be running 💡

Run your GitHub actions 👌

Deploy your NestJS API on AWS Elastic Beanstalk

Pre-requisites 📔

Creating your Elastic Beanstalk Application 👷

Accessing your sample Elastic Beanstalk Application 🚀

Deploying your NestJS API 🙌

Improving your App's Performance: Solving the N+1 Problem

The Problem

The N+1 Problem

Fixing our code

Benefits

Conclusions

Deploying your NestJS API on AWS Lambda

Starting your NestJS Project

Setting up serverless framework

Deploying

Conclusions

Deploying a NodeJS - Express API to AWS Lambda

Starting your project

Setting up serverless framework

Deploying to AWS Lambda

Conclusions

AWS Lambda: What it is, how to use, when to use, and when not to

What is is

Advantages

Disadvantages and limitations

How to use it

When to use it, and when not to

Conclusions

Why computer floating points are inaccurate

It happens in almost every programming language

Why does this happen?

The solution

Read more