DEV Community: officiabreezy

From Localhost to Cloud: Deploying a Node.js Bot app to AWS EC2 (My 3rd Deployment, Different Method!)

officiabreezy — Tue, 17 Feb 2026 11:23:02 +0000

A practical walkthrough of deploying a Node.js bot app to AWS EC2 using GitHub + PM2 + systemd — my third EC2 deployment using a completely different approach each time

From Localhost to Cloud: Deploying a Node.js Bot App to AWS EC2

This is my third time deploying to AWS EC2, and I've used a different method each time:

🐳 1st deployment — Docker containers
📁 2nd deployment — Manual file upload (SCP)
🔄 3rd deployment (this one) — GitHub + PM2 + systemd

Each approach taught me something unique. This time I wanted a workflow that was easy to update, automatically recovers from crashes, and survives server reboots — without the overhead of Docker for a simple Node.js app.

Here's exactly what I did, step by step.

What I Built

A reporter bot that:

Listens for new members joining servers
Sends real-time notifications with member details
Logs all activity with automatic daily log rotation (7-day retention)
Runs 24/7 in the cloud — even when my PC is off

Tech stack: Node.js, discord.js, axios, winston, PM2, AWS EC2 (Ubuntu 22.04)

Step 1: Launch an EC2 Instance

Log in to AWS Console → EC2 → Launch Instance
Configure:
- OS: Ubuntu Server 22.04 LTS (Free tier eligible)
- Instance type: t2.micro (Free tier)
- Key pair: Create new → download the .pem file (keep this safe!)
- Security Group: Open ports 22 (SSH), 80 (HTTP), 443 (HTTPS)
Click Launch Instance and wait for it to start

Step 2: Connect to Your EC2 Instance

From your terminal:

# Make your key file readable (Linux/Mac/Git Bash)
chmod 400 your-key.pem

# Connect via SSH
ssh -i your-key.pem ubuntu@<your-ec2-public-ip>

You should now see the Ubuntu welcome screen. You're in! 🎉

Step 3: Set Up the Server

Once connected, install the required tools:

# Update system packages
sudo apt update && sudo apt upgrade -y

# Install Node.js (v20)
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs

# Verify installation
node --version
npm --version

# Install Git
sudo apt install git -y

# Install PM2 globally (process manager)
sudo npm install -g pm2

Step 4: Clone Your Repository from GitHub

⚠️ GitHub no longer accepts passwords. Use a Personal Access Token (PAT) instead.

Go to: GitHub → Settings → Developer Settings → Personal Access Tokens → Generate New Token (check the repo scope)

# Clone using your token
git clone https://<YOUR_TOKEN>@github.com/yourusername/your-repo.git

# Navigate into project
cd your-repo

🔐 Security tip: Never hardcode tokens in your source code. Use environment variables with a .env file in production.

Step 5: Install Dependencies

# Create logs directory (if your app needs it)
mkdir -p logs

# Install npm packages
npm install

You should see all packages installed successfully.

Step 6: Start Your App with PM2

PM2 is a production process manager for Node.js. It keeps your app running, auto-restarts on crashes, and manages logs.

# Start the application
pm2 start index.js --name "my-app"

# Check it's running
pm2 status

You should see something like:

┌────┬──────────┬──────────┬──────┬───────────┬──────────┬──────────┐
│ id │ name     │ mode     │ ↺    │ status    │ cpu      │ memory   │
├────┼──────────┼──────────┼──────┼───────────┼──────────┼──────────┤
│ 0  │ my-app   │ fork     │ 0    │ online    │ 0%       │ 45.0mb   │
└────┴──────────┴──────────┴──────┴───────────┴──────────┴──────────┘

Status: online ✅ — your app is running!

Step 7: Configure Auto-Start on Reboot

This is the most important step for a "set it and forget it" deployment:

# Generate the startup command
pm2 startup

# PM2 will output a command — copy and run it. It looks like:
sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u ubuntu --hp /home/ubuntu

# Save the current process list
pm2 save

Now your app will automatically start whenever the EC2 instance reboots!

Step 8: Verify Everything is Working

# View live logs
pm2 logs my-app

# Monitor CPU and memory
pm2 monit

# Check disk space
df -h

Comparing My 3 Deployment Methods

Feature	Docker	Manual SCP	GitHub + PM2
Setup time	Medium	Fast	Fast
Update process	Rebuild image	Re-upload files	`git pull`
Auto-restart	With compose	Manual	✅ Built-in
Boot persistence	With compose	Manual	✅ systemd
Best for	Complex apps	Learning	Solo projects
Learning curve	High	Low	Medium

What I Learned From Each:

🐳 Docker: Great for complex apps with multiple services. Containerization ensures consistency across environments. But for a simple Node.js bot, it felt like overkill.

📁 Manual SCP: Forced me to understand exactly what's happening on the server — no abstractions. Best for learning fundamentals but tedious for frequent updates.

🔄 GitHub + PM2 (this one): Sweet spot for solo projects. Easy updates (git pull && pm2 restart), built-in crash recovery, and systemd integration for boot persistence.

Disk Space Management

One thing to keep in mind — my bot generates daily log files. Here's what my disk usage looked like after deployment:

$ df -h
Filesystem      Size  Used Avail Use% Mounted on
/dev/root       6.8G  3.2G  3.6G  47% /

$ du -sh ~/reporter/logs/
232K    /home/ubuntu/reporter/logs/

47% used with plenty of headroom. My winston logger is configured with maxFiles: "7d" which automatically deletes logs older than 7 days — keeping disk usage minimal.

Useful PM2 Commands

# Check status
pm2 status

# View live logs
pm2 logs my-app

# View last 100 lines
pm2 logs my-app --lines 100

# Restart app
pm2 restart my-app

# Stop app
pm2 stop my-app

# Monitor CPU/Memory in real-time
pm2 monit

# List all processes
pm2 list

Key Takeaways

There's no single "best" deployment method — the right tool depends on your project complexity and update frequency.
Try multiple approaches — each method teaches you something different about how servers actually work.
PM2 is a game changer for Node.js deployments — crash recovery and systemd integration make it production-ready with minimal setup.
AWS Free Tier is perfect for learning — t2.micro with 6.8GB disk is more than enough for simple Node.js apps.
Always use environment variables for sensitive tokens in production — never hardcode credentials in your source code.

Conclusion

This GitHub + PM2 + systemd approach has become my favorite for solo Node.js projects. It strikes the right balance between simplicity and reliability — easy to set up, easy to update, and runs 24/7 without babysitting.

If you're just getting started with cloud deployments, I'd recommend this exact stack. Once you're comfortable, try Docker for more complex multi-service applications.

Happy deploying! 🚀

Have you deployed to AWS EC2? What method do you prefer? Drop a comment below!

Middleware function Execution Problem and Solution

officiabreezy — Mon, 01 Jul 2024 17:43:40 +0000

What is Middleware?
A middleware can be defined as a function that will have all the access for requesting an object, responding to an object, and moving to the next middleware function in the application request-response cycle. Middleware stand as a bridge between client requests and server responses. It's also responsible for handling tasks like logging, authentication, error handling and so on.

Middleware Problem
middleware problem i encountered make me understand how middleware flow works, while developing a Node.js application with Express, authentication middleware was not working because the functions were not executed in a proper way, the logging was not capturing necessary information and the error handling was not consistent

Solution to the Problem
firstly, you need to identify the cause of middleware execution issues and the order in which the middleware functions were declared in the application. middleware is a bridge between incoming request and the response that is why we call it request-response cycle below is a version of middleware setup in server.js;

const express = require('express');
const app = express();
const authMiddleware = require('./middlewares/auth');
const errorHandler = require('./middleware/errorHandler');
const Routes = require('./routes/contactRoutes');
const userRoutes = require('./routes/userRoutes');
const { getContacts,createContact, getContact, deleteContact, updateContact } = require('./controller/contactController');
const router = require('./routes/userRoutes');

const port = process.env.PORT || 5000;

app.use(express.json());
app.use(express.urlencoded({extended:true}));

app.use('/api/v1/contact',Routes);
app.use('/api/v1/user',userRoutes);
app.use(errorHandler)

app.listen(port, () => {
console.log('listening on port ' + port);
});

note: To make all this work properly You would have installed all the necessary packages in Node.js including express, dotenv, etc.

The Authentication Middleware was used to check for a valid JWT and handle unauthorized access for example let say we have admin routes whereby only admin can perform some functions like get the list of all the contacts, delete contact or update contact. if all the 3 routes mention can only be access by admin then a user will be denied access because he/she don't have access to those routes.

const jwt = require('jsonwebtoken');

const authMiddleware = (req, res, next) => {
const token = req.headers['authorization'];
if (!token) {
return res.status(401).json({ message: 'Access denied. No token provided.' });
}

try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
} catch (err) {
    res.status(400).json({ message: 'Invalid token.' });
}

};

module.exports = authMiddleware;

Error Handling Middleware
Is used to catch and response to errors efficiently
below is a code for error handling;

const errorMiddleware = (err, req, res, next) => {
console.error(err.message);
res.status(500).json({ message: 'Internal Server Error' });
};

module.exports = errorMiddleware;

In conclusion,
i make sure the middleware function were executed in a correct order to improve the performance of my application and improve my experience in knowledge of web applications. As i start my internship journey at HNG Tech Limited I'm eager to tackle new challenges and continue to grow as a backend developer

This article is in fulfillment of my stage 0 task for the HNG Internship. HNG Internship is a program to educate, contribute to growth and give opportunity to learning tech. Check them out for more information, https://hng.tech/internship, https://hng.tech/hire, or https://hng.tech/premium

The Importance of Middleware in Node.js

officiabreezy — Mon, 03 Jul 2023 21:24:15 +0000

Node.js has gained significant popularity in the world of server-side JavaScript development. It offers a powerful and scalable environment for building web applications and APIs. One of the key features that makes Node.js highly versatile is its robust middleware architecture. In this article, we'll explore the importance of middleware in Node.js and how it enhances the development process.

Understanding Middleware in Node.js

In the context of Node.js, middleware refers to a series of functions that are executed in a sequential order during the request-response lifecycle. These functions have access to the request and response objects and can perform various tasks such as modifying request/response data, logging, error handling, authentication, and much more. Middleware acts as a bridge between the web server and the application, allowing for modular and reusable code.

Key Benefits of Middleware in Node.js

1. Code Reusability and Modularity

Middleware enables code reusability and modularity in Node.js applications. By breaking down the application logic into smaller middleware functions, developers can focus on specific functionalities and easily reuse them across different routes or projects. This approach not only promotes cleaner code organization but also reduces duplication and improves maintainability.

2. Request Processing and Response Modification

Middleware functions in Node.js have access to the request and response objects, allowing developers to intercept and modify them as needed. This ability is invaluable when implementing common functionalities such as request validation, data parsing, request logging, response compression, and caching. Middleware functions can intercept incoming requests, process them, and modify the response before it's sent back to the client.

3. Error Handling and Exception Management.

Error handling is a critical aspect of any robust application. Middleware simplifies the process of handling errors and exceptions in Node.js. By defining error-handling middleware, developers can centralize the error-handling logic and avoid repetitive error handling code in every route or controller. Middleware can catch and handle errors, log them, and send appropriate responses to clients, enhancing the overall reliability and stability of the application.

4. Authentication and Authorization.

Implementing authentication and authorization is a common requirement for many web applications. Middleware simplifies this process by providing a flexible and modular way to enforce security measures. Developers can create middleware functions to handle authentication, verify user credentials, and manage user sessions. This approach allows for centralized and consistent security implementation across different routes and endpoints.

5. Routing and URL Handling.

Middleware plays a crucial role in routing and URL handling in Node.js applications. Frameworks like Express.js heavily rely on middleware to define routes and handle URL-based operations. Middleware functions can intercept incoming requests, examine the URL, and determine the appropriate route or action to execute. This flexibility allows developers to define complex routing rules, implement middleware-based access control, and create custom routing behaviors.

6. Performance Optimization.

Middleware can contribute to performance optimization in Node.js applications. Developers can use middleware functions to implement caching mechanisms, compress responses, optimize database queries, or implement rate limiting and throttling. By strategically placing middleware in the request-response pipeline, developers can improve application performance, reduce server load, and enhance the overall user experience.

Conclusion

Middleware plays a vital role in Node.js development, providing a powerful and flexible mechanism for extending and enhancing the functionality of web applications. Its modular and reusable nature promotes code organization, improves maintainability, and reduces duplication. Middleware empowers developers to implement common functionalities such as request processing, response modification, error handling, authentication, and routing in a consistent and centralized manner. By leveraging middleware effectively, developers can build scalable, robust, and efficient Node.js applications that meet the needs of modern web development.