Deploying Nest.js API on AWS EC2: Step-by-Step Guide

Introduction to Deploying Nest.js API on AWS EC2

Deploying a Nest.js API on AWS EC2 can seem daunting at first. However, with a clear roadmap, it becomes manageable. AWS EC2 provides scalable computing capacity, making it a popular choice for deploying web applications.

Before diving into the deployment process, ensure that your Nest.js API is ready for production. This includes configuring environment variables, setting up a build script, and optimizing performance. Once your application is prepared, you’re all set to begin the deployment journey.

Why Choose AWS EC2?

• Scalability: EC2 allows you to scale resources up or down based on your application’s demand.
• Flexibility: You have full control over your operating system and server configurations.
• Cost-Effectiveness: Pay only for the compute time you use, optimizing your budget.

Getting Started

Begin by creating an AWS account if you haven’t already. Once logged in, navigate to the EC2 dashboard to launch a new instance. Choose an Amazon Machine Image (AMI) that suits your needs. For most use cases, an Ubuntu server is a great choice.

Next, select an instance type. The t2.micro instance is free-tier eligible and suitable for small projects. Configure your instance’s security group to allow HTTP and SSH traffic, ensuring you can access your API and server.

Deploying the Application

1. Connect to your EC2 instance using SSH. You can do this via your terminal or an SSH client.
2. Install Node.js and npm on your server. Ensure you have the right versions that your application requires.
3. Clone your Nest.js project repository onto the server.
4. Run your build script and start the application using a process manager like PM2.

With these steps, your Nest.js API is now live on AWS EC2. This is a brief overview of the deployment process. Dive deeper into each step to ensure a smooth deployment.

Setting Up Your AWS EC2 Instance

Getting started with AWS EC2 is straightforward, and it’s a crucial step when deploying a Nest.js API. First, navigate to the EC2 dashboard in your AWS Management Console. This is where you’ll launch your virtual server.

Step 1: Launch an Instance

Click on the “Launch Instance” button. Choose an Amazon Machine Image (AMI) that suits your needs. The Amazon Linux 2 AMI is a popular choice for Node.js applications due to its stability and support.

Step 2: Choose an Instance Type

Select an instance type based on your application’s requirements. For a Nest.js API, a t2.micro instance is usually sufficient for development purposes and is included in the AWS Free Tier.

Step 3: Configure Instance Details

Ensure you select the correct network settings. Use the default VPC, and make sure your instance has a public IP address. This setting is vital for accessing your API over the internet.

Step 4: Add Storage

Decide on the storage requirements. The default 8 GB is often enough, but you can increase this based on your data needs.

Step 5: Configure Security Group

Security groups act as a virtual firewall. Add rules to allow HTTP and HTTPS traffic. Also, ensure SSH access is enabled, so you can connect to your instance.

Step 6: Review and Launch

Review your settings, and then click “Launch.” You’ll be prompted to select or create a key pair. This key is essential for SSH access, so store it securely.

Step 7: Connect to Your Instance

After launching, connect to your EC2 instance using SSH. Use the command:

ssh -i "your-key.pem" ec2-user@your-instance-public-dns

This connection allows you to install Node.js, set up your Nest.js application, and start deploying!

Installing Node.js and Nest.js on EC2

To deploy your Nest.js API on AWS EC2, first, you need to install Node.js. This forms the backbone of your application. Let’s break down the installation process for Node.js and Nest.js on an EC2 instance.

Step 1: Install Node.js

Start by connecting to your EC2 instance via SSH. Once connected, update your package repository to ensure you’re getting the latest versions.

sudo yum update -y

Next, install Node.js using the NodeSource repository. It’s a reliable source for obtaining Node.js.

curl -fsSL https://rpm.nodesource.com/setup_16.x | sudo bash -
sudo yum install -y nodejs
    

Verify the installation by checking the Node.js version.

node -v

Step 2: Install Nest.js CLI

With Node.js installed, you can now install the Nest.js CLI. This command-line tool helps manage your Nest.js projects.

npm install -g @nestjs/cli

Verify the installation by checking the Nest.js CLI version.

nest --version

Step 3: Create a Nest.js Application

Now that you have the necessary tools, create a new Nest.js application. This step initializes your project structure and installs dependencies.

nest new my-nest-app

Navigate into your project directory.

cd my-nest-app

Configuring Security Groups for Your EC2 Instance

When deploying your Nest.js API on an AWS EC2 instance, configuring security groups is a crucial step. These act as virtual firewalls, controlling inbound and outbound traffic to your instance. Proper configuration ensures your API is both accessible and secure.

Understanding Security Groups

Security groups are a set of rules that define network access. Each rule specifies allowed protocols, ports, and source IP ranges. This flexibility is essential when setting up a secure environment for your API.

Creating a Security Group

1. Navigate to the AWS Management Console and select EC2.
2. In the left navigation pane, click on Security Groups.
3. Choose Create Security Group and provide a name and description.
4. Set the VPC that your EC2 instance belongs to.

Configuring Inbound Rules

Inbound rules dictate what traffic can reach your EC2 instance. For a Nest.js API, you’ll generally need to allow HTTP and HTTPS traffic.

{
    "protocol": "TCP",
    "portRange": "80",
    "source": "0.0.0.0/0",
    "description": "Allow HTTP traffic"
}
    

Add another rule for HTTPS:

{
    "protocol": "TCP",
    "portRange": "443",
    "source": "0.0.0.0/0",
    "description": "Allow HTTPS traffic"
}
    

Configuring Outbound Rules

By default, all outbound traffic is allowed. If you need to restrict this, ensure you configure outbound rules accordingly. However, in most scenarios, the default setting suffices.

Associating Security Groups with Your Instance

After creating your security group, you must associate it with your EC2 instance:

• Select your instance in the EC2 dashboard.
• Click on Actions and navigate to Networking.
• Choose Change Security Groups and select your newly created group.

Deploying Your Nest.js Application

Deploying your Nest.js API to AWS EC2 can be an exciting venture for any developer. AWS EC2 provides a scalable environment, perfect for hosting dynamic applications like those built with Nest.js. In this step-by-step guide, we’ll walk through deploying your Nest.js application to an EC2 instance.

Prepare Your EC2 Instance

Start by launching an EC2 instance and choosing the Amazon Machine Image (AMI) that suits your needs. A popular choice is the Amazon Linux 2 AMI. It offers a balance between functionality and performance.

Set Up Your Server Environment

Once your EC2 instance is running, connect to it using SSH. You’ll need to install Node.js, npm, and any other dependencies your Nest.js application requires. Run the following commands to set up Node.js:

    // Update your package repository
    sudo yum update -y

    // Install Node.js and npm
    sudo yum install -y nodejs npm
  

Upload Your Application

With your server ready, it’s time to transfer your Nest.js application files. You can use SCP, FTP, or any secure method to upload your code to the EC2 instance. Ensure that your package.json file is included to install necessary dependencies easily.

Install Dependencies and Build

Navigate to your application directory on the EC2 server. Run npm to install the dependencies and build your application:

    // Install all dependencies
    npm install

    // Build the application
    npm run build
  

Run Your Application

Your Nest.js app is now ready to run. Use a process manager like PM2 to run your application in the background:

    // Install PM2 globally
    sudo npm install -g pm2

    // Start your Nest.js application
    pm2 start dist/main.js
  

Configure Security Groups

Don’t forget to set up your security groups to allow traffic to your application. Open the necessary ports, typically 3000 for Nest.js, in your AWS security group settings.

Access Your Application

sudo apt update && sudo apt install nginx

sudo nano /etc/nginx/sites-available/default

server {
    listen 80;
    server_name your_domain_or_IP;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}
    

sudo nginx -t

sudo systemctl restart nginx