How to Deploy a Node.js App on AWS with ECS, RDS & Load Balancer (Step-by-Step)

Introduction: Building Production-Ready Backend Systems

Deploying a Node.js application to production isn’t just about pushing code — it’s about creating a secure, scalable, and maintainable backend. With Amazon Web Services (AWS), you can combine container orchestration, managed databases, load balancing, and domain routing to build a professional-grade environment.

In this guide, we’ll walk through how to deploy a Node.js app on AWS using services like ECS (Elastic Container Service) for containers, RDS (Relational Database Service) for database management, Application Load Balancer (ALB) for traffic distribution, and Route 53 for DNS.

By following these steps, you’ll learn industry best practices for deploying Node.js applications in the cloud — from containerization to scaling and monitoring — so your backend is production-ready from day one.

Understanding the Architecture

Before diving into implementation, let’s understand how these components work together to form a complete system. Our AWS backend architecture consists of four main components:

• Amazon RDS: Manages your database, handling backups, updates, and scaling automatically
• Amazon ECS: Runs your Node.js application in Docker containers, allowing for easy scaling and deployment
• Application Load Balancer: Distributes incoming traffic across multiple containers for high availability
• Amazon Route 53: Manages DNS settings, connecting your domain name to your application

When a user makes a request to your application:

1. Route 53 directs the request to your Application Load Balancer
2. The Load Balancer forwards the request to one of your ECS containers
3. Your Node.js application processes the request, communicating with RDS as needed
4. The response follows the same path back to the user

Prerequisites

Before starting the AWS Node.js deployment process, ensure you have:

• An AWS account with appropriate permissions
• AWS CLI installed and configured on your local machine
• A Node.js application ready for deployment
• Docker installed locally for container building
• Basic understanding of Node.js and Docker
• (Optional) A registered domain name if you plan to use a custom domain

Step 1: AWS RDS Setup for Your Node.js Application

The first component of our architecture is the database. The AWS RDS setup process creates a managed database instance that your application will connect to.

Creating the RDS Instance

1. Navigate to the RDS dashboard in the AWS Management Console
2. Click “Create database”
3. Select your preferred database engine (MySQL, PostgreSQL, etc.)
4. Choose “Production” under templates for proper redundancy

Configuration Settings

Configure your database with these recommended settings:

• DB Instance Identifier: Give your database a meaningful name (e.g., nodejs-production-db)
• Master Username/Password: Create secure credentials (store these safely!)
• DB Instance Class: Start with db.t3.small for development (scale as needed)
• Storage: Begin with 20GB with autoscaling enabled
• Multi-AZ Deployment: Enable for production workloads
• VPC: Select your application VPC (create one if needed)
• Security Group: Create a new security group or select an existing one

The AWS RDS setup process takes several minutes to complete. While waiting, you can proceed with the next steps.

Configuring Security Groups

For your database to be accessible from your ECS containers but protected from the public internet:

• Create a new security group for your RDS instance
• Add an inbound rule allowing traffic on your database port (e.g., 3306 for MySQL) only from your ECS security group
• Ensure no direct public access to your database

{
  "Type": "AWS::EC2::SecurityGroup",
  "Properties": {
    "GroupDescription": "RDS Security Group",
    "VpcId": {"Ref": "VPC"},
    "SecurityGroupIngress": [
      {
        "IpProtocol": "tcp",
        "FromPort": 3306,
        "ToPort": 3306,
        "SourceSecurityGroupId": {"Ref": "ECSSecurityGroup"}
      }
    ]
  }
}

Step 2: Containerize Your Node.js Application

The Node.js Docker AWS workflow begins with creating a proper Dockerfile to package your application. This ensures consistent deployment across environments.

Creating an Optimized Dockerfile

Create a Dockerfile in your project root with the following content:

# Use the official Node.js 16 image as base
FROM node:16-alpine

# Set working directory
WORKDIR /usr/src/app

# Copy package files and install dependencies
COPY package*.json ./
RUN npm ci --only=production

# Copy application code
COPY . .

# Set environment variables
ENV NODE_ENV=production
ENV PORT=3000

# Expose the port your app runs on
EXPOSE 3000

# Start the application
CMD ["node", "app.js"]

Building and Testing Locally

Before pushing to AWS, test your container locally:

# Build the Docker image
docker build -t nodejs-app .

# Run the container locally
docker run -p 3000:3000 -d nodejs-app

# Test the application
curl http://localhost:3000

Using Node.js Docker AWS integration simplifies the deployment and scaling process. Once your container runs successfully locally, you’re ready to push it to Amazon ECR.

Pushing to Amazon ECR

Create a repository in Amazon ECR:

aws ecr create-repository --repository-name nodejs-app

Authenticate Docker with ECR:

aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin <your-account-id>.dkr.ecr.us-east-1.amazonaws.com

Tag and push your image:

docker tag nodejs-app:latest <your-account-id>.dkr.ecr.us-east-1.amazonaws.com/nodejs-app:latest
docker push <your-account-id>.dkr.ecr.us-east-1.amazonaws.com/nodejs-app:latest

Step 3: Setting Up ECS for Container Orchestration

With your database and container image ready, it’s time to set up AWS ECS Node.js orchestration to run your application.

Creating an ECS Cluster

1. Navigate to the ECS dashboard in the AWS Management Console
2. Click “Create Cluster”
3. Select “Networking only” for Fargate compatibility
4. Name your cluster (e.g., nodejs-production-cluster)
5. Click “Create”

Creating a Task Definition

The AWS ECS Node.js task definition specifies how your container should run:

1. In the ECS dashboard, go to “Task Definitions” and click “Create new Task Definition”
2. Select “Fargate” as the launch type
3. Configure the task:
   • Task Definition Name: nodejs-app-task
   • Task Role: Create or select a role with appropriate permissions
   • Network Mode: awsvpc (selected automatically for Fargate)
   • Task Memory: 1GB (adjust based on your app’s needs)
   • Task CPU: 0.5 vCPU (adjust based on your app’s needs)
4. Add a container:
   • Container Name: nodejs-app
   • Image: Your ECR image URI
   • Port Mappings: 3000
   • Environment Variables: Add variables for database connection, API keys, etc.

{
  "name": "nodejs-app",
  "image": "<your-account-id>.dkr.ecr.us-east-1.amazonaws.com/nodejs-app:latest",
  "essential": true,
  "portMappings": [
    {
      "containerPort": 3000,
      "hostPort": 3000,
      "protocol": "tcp"
    }
  ],
  "environment": [
    {
      "name": "DB_HOST",
      "value": "your-rds-endpoint.rds.amazonaws.com"
    },
    {
      "name": "DB_USER",
      "value": "admin"
    }
  ],
  "secrets": [
    {
      "name": "DB_PASSWORD",
      "valueFrom": "arn:aws:ssm:region:account-id:parameter/db/password"
    }
  ],
  "logConfiguration": {
    "logDriver": "awslogs",
    "options": {
      "awslogs-group": "/ecs/nodejs-app",
      "awslogs-region": "us-east-1",
      "awslogs-stream-prefix": "ecs"
    }
  }
}

Creating an ECS Service

Now create a service to run your task:

1. In your cluster, click “Create Service”
2. Configure the service:
   • Launch Type: Fargate
   • Task Definition: Select the task you created
   • Service Name: nodejs-app-service
   • Number of Tasks: 2 (for redundancy)
   • Deployment Type: Rolling update
3. Configure networking:
   • VPC: Select your application VPC
   • Subnets: Select at least two subnets in different availability zones
   • Security Groups: Create a new security group or select an existing one
   • Auto-assign Public IP: ENABLED (if your containers need internet access)
4. Configure load balancing (we’ll set up the load balancer in the next section)
5. Set up Auto Scaling (optional):
   • Enable service auto scaling
   • Set minimum, desired, and maximum task counts
   • Configure scaling policies based on CPU or memory utilization

An effective AWS ECS Node.js setup ensures your application can scale automatically as demand changes.

Step 4: AWS Load Balancer Configuration

The AWS Load Balancer configuration distributes traffic across multiple ECS tasks, providing high availability and fault tolerance.

Creating an Application Load Balancer

1. Navigate to the EC2 dashboard and select “Load Balancers”
2. Click “Create Load Balancer” and select “Application Load Balancer”
3. Configure basic settings:
   • Name: nodejs-app-alb
   • Scheme: internet-facing
   • IP address type: ipv4
   • Listeners: HTTP (port 80) and HTTPS (port 443) if using SSL
   • Availability Zones: Select the same VPC and subnets as your ECS service

Configuring Security Groups

Create a security group for your load balancer:

• Allow inbound HTTP (80) and HTTPS (443) from anywhere
• Allow outbound traffic to your ECS security group

Setting Up Target Groups

Create a target group:

• Name: nodejs-app-targets
• Target type: IP addresses (for Fargate)
• Protocol: HTTP
• Port: 3000
• VPC: Same as your ECS service
• Health check path: /health or another endpoint that returns 200 OK
• Don’t register targets manually – ECS will do this automatically

Updating the ECS Service

Now return to your ECS service and update it to use the load balancer:

1. Edit the service
2. Under “Load balancing”, select “Application Load Balancer”
3. Select your target group
4. Update the service

Step 5: Route 53 Domain Setup

The final step is connecting your application to a custom domain using Route 53.

Creating a Hosted Zone

If you haven’t already:

1. Navigate to Route 53 in the AWS Management Console
2. Click “Hosted zones” and then “Create hosted zone”
3. Enter your domain name and click “Create”

Configuring DNS Records

The Route 53 domain setup connects your custom domain to the Application Load Balancer:

1. In your hosted zone, click “Create record”
2. Leave the name field empty for the root domain or enter a subdomain
3. Select “A – Routes traffic to an IPv4 address and some AWS resources”
4. Enable “Alias”
5. Select “Alias to Application and Classic Load Balancer”
6. Select your region and load balancer
7. Click “Create records”

Complete the Route 53 domain setup by creating an A record that points to your load balancer. You may also want to create a www subdomain record that points to the same load balancer.

Verifying DNS Configuration

DNS changes can take time to propagate. Verify your setup using:

dig yourdomain.com

You should see your load balancer’s IP addresses in the response.

Testing and Validation

After completing all steps, it’s time to verify your AWS Node.js deployment:

Deployment Verification

• Access your application through your domain name
• Verify that your application is running correctly
• Test database connectivity by performing operations that require database access
• Check that your application can scale by temporarily increasing the desired task count

Monitoring and Logging

Set up monitoring for your deployment:

Configure CloudWatch alarms for:

• ECS service metrics (CPU, memory)
• Load balancer metrics (request count, latency)
• RDS metrics (CPU, free storage space, connections)

Set up log monitoring:

• Check ECS task logs in CloudWatch Logs
• Monitor RDS logs for database issues

Security Verification

Verify your security configuration:

• • Ensure your RDS instance is not publicly accessible
  • Verify that your ECS tasks can only be accessed through the load balancer
  • Check that your application is using HTTPS if handling sensitive data

Bringing It All Together: Node.js on AWS

You’ve now seen how to deploy a Node.js backend on AWS using ECS, RDS, Load Balancer, and Route 53 to create a robust cloud architecture. This setup ensures your application is scalable, reliable, and secure, with the flexibility to grow as traffic increases.

To take your deployment further:

• Automate releases with CI/CD pipelines (CodePipeline, GitHub Actions).

• Implement detailed monitoring in CloudWatch.

• Optimize costs by right-sizing ECS tasks and RDS instances.

• Secure your environment with best practices like private databases, IAM least privilege, and HTTPS.

Whether you’re migrating an existing app or launching something new, running a Node.js application on AWS offers the performance and resilience modern businesses need. Start small, scale with demand, and continuously optimize — your backend will be ready for real-world workloads.