DEV Community: Amjad C P

Deploying a MEAN Stack App Without a Cloud Provider

Amjad C P — Sun, 01 Mar 2026 07:22:12 +0000

Many people think you need an AWS or Azure account to learn deployment and CI/CD. That’s a misconception. If you have VirtualBox and GitHub Actions, you have everything you need to build a fully automated pipeline.

In this guide, I will show you how to deploy a MEAN stack application on a local Linux VM(there is no major difference for the MERN stack). This setup works on any Linux environment, whether it's a dedicated server or a VM running on your laptop.

🏗️ The Architecture

We are using a monorepo approach, meaning both the Angular frontend and Node.js backend live in the same repository. Here is how the flow works:

Push code to the production branch.
GitHub Actions builds the Docker images.
Images are pushed to Docker Hub.
A Self-Hosted Runner on your VM pulls the latest images and restarts the containers.
Nginx acts as a reverse proxy to route traffic.

If you are curious about how this differs from cloud-specific hosting, check out my previous post on Hosting a Node.js Server in an EC2 Instance.

1. Setting Up the Server (VirtualBox)

I used a Debian VM for this setup.

Network: Set your VM adapter to Bridged Mode. This allows the VM to get an IP from your router, making it a real node on your Local Area Network (LAN).
Access: You should be able to SSH into it: ssh user@your_vm_ip.

For a detailed breakdown of how to handle LAN networking and port forwarding to make your server accessible from the internet, refer to my post: How Web Technology Works - Part 01.

2. Docker Hub & GitHub Secrets

To push images automatically, GitHub needs permission to talk to Docker Hub. Do not use your account password.

Go to Docker Hub > Settings > Personal access tokens.
Create a New Access Token with Read & Write access.
In your GitHub repository, go to Settings > Secrets and variables > Actions.
Add DOCKERHUB_USERNAME and DOCKERHUB_TOKEN (the token you just created).

3. The Self-Hosted Runner

Instead of using GitHub’s servers to deploy, we use our own VM. This is called a Self-Hosted Runner.

In GitHub: Settings > Actions > Runners > New self-hosted runner.
Select Linux and follow the commands to download and configure it on your VM.
Once configured, install it as a service so it runs in the background:

sudo ./svc.sh install
sudo ./svc.sh start

4. Containerization (The Code)

Since we are in a monorepo, we need separate Dockerfiles and a single Compose file.

Backend Dockerfile (`backend/Dockerfile`)

FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
EXPOSE 8080
CMD ["node", "server.js"]

Frontend Dockerfile (`frontend/Dockerfile`)

FROM node:20-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM nginx:alpine
COPY --from=build /app/dist/your-app-name /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Docker Compose (`docker-compose.yml`)

version: '3.8'
services:
  backend:
    image: your-docker-username/mean-backend:latest
    extra_hosts:
      - "host.docker.internal:host-gateway"
    container_name: mean-backend
    restart: always
    ports:
      - "8080:8080"

  frontend:
    image: your-docker-username/mean-frontend:latest
    container_name: mean-frontend
    restart: always
    depends_on:
      - backend
    ports:
      - "81:80"

5. Nginx Reverse Proxy

Install Nginx on the host VM: sudo apt install nginx. We use it to route port 80 traffic to our containers.

Configuration (/etc/nginx/sites-available/default):

server {
    listen 80;
    server_name 10.131.44.201; # Use your VM IP

    location /api/ {
        proxy_pass http://localhost:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }

    location / {
        proxy_pass http://localhost:81;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

Check if there is any issue in the new configuration syntax sudo nginx -t
Restart the nginx service sudo systemctl reload nginx

6. The CI/CD Pipeline

Create .github/workflows/deploy.yml. This script automates the entire process.

name: Build and Deploy
on:
  push:
    branches: [ production ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}
      - name: Build and Push
        run: |
          docker build -t ${{ secrets.DOCKERHUB_USERNAME }}/mean-backend ./backend
          docker build -t ${{ secrets.DOCKERHUB_USERNAME }}/mean-frontend ./frontend
          docker push ${{ secrets.DOCKERHUB_USERNAME }}/mean-backend
          docker push ${{ secrets.DOCKERHUB_USERNAME }}/mean-frontend

  deploy:
    needs: build
    runs-on: self-hosted
    steps:
      - name: Pull and Restart
        run: |
          cd ~/your-app-dir
          docker-compose pull
          docker-compose up -d

CI/CD Success

Once you push, you should see all green checkmarks in GitHub Actions.

Docker Hub

Your images will appear with the latest tags.

Running Services

Check your VM to see the containers live.

Your application is now live on your local network!
http://VM_IP

Setting up a CI/CD pipeline on a local virtual machine proves that DevOps is about logic and architecture, not just the service provider you use. By utilizing VirtualBox in Bridged Mode, you can simulate a production-like environment and gain full control over your networking and deployment cycles without a cloud budget.

Key Takeaways

Infrastructure Flexibility: This setup applies to any Linux environment, whether it is a VM, a Raspberry Pi, or a local server.
Automation: Using a self-hosted runner allows you to keep your deployment logic local while leveraging GitHub for the build process.
Monorepo Efficiency: Managing the Angular frontend and Node.js backend in a single repository simplifies the CI/CD workflow.

What challenges did you face setting up your local environment? Let me know in the comments.

How to Setup Webhook in Google Form?

Amjad C P — Wed, 01 May 2024 16:49:42 +0000

If you aim to implement custom logic when a user submits a Google Form, this workaround is for you.

Our goal is to automate the two steps outlined in the previous diagram using Google Workspace APIs. In order to access these APIs, it is necessary to create a service account and enable both the Google Forms API and Google Drive API.

Create Service Account & Enable APIs

Log in to Google Cloud Console and create a project.
Go to IAM & Admin > Service Account and create the service account.

Assign Editor access to the service account from the basic roles.

Create new key as JSON file.

Go to APIs & Services > Enabled APIs Services and enable Google Cloud API and Google Form API.

Setup Google Form

Create a Google Form and add the service account email as a collaborator ( edit access ).

Setup Server

Create a web server using Express.

const express = require('express');
const cors = require('cors');
const { fetchForm, addFormToSheet, authenticateForm } = require('./utils');
const app = express();
const port = 3000;

authenticateForm();

app.use(cors());
app.use(express.json({
    type: ["application/json", "text/plain"]
}));

// To upload Google Form ID to link to a Google Sheet
app.post('/api/v1/form', async (req, res) => {
    const { formId } = req.body;
    console.log(formId);
    const data = await fetchForm(formId);
    const formName = data?.info?.title || "undefined";
    await addFormToSheet(formId, formName);
    res.status(200).json({
        message: "Form added to sheet",
    });
});

// Webhook url to get response when a user submit a form. We have to add this in AppScript
app.post('/api/v1/webhook', async (req, res) => {
    console.log(req.body);
    res.status(200).json({
        message: "Webhook received",
    });
});

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

```jsx
const { google } = require("googleapis");
const path = require("path");
const axios = require("axios");
const FormData = require("form-data");
const {config} = require("dotenv");

config();

let forms;
const authenticateForm = async () => {
  const auth = new google.auth.GoogleAuth({
    keyFile: "./key.json", // service account key that we downloaded from Google Cloud Console
    scopes: [
      "https://www.googleapis.com/auth/forms.responses.readonly",
      "https://www.googleapis.com/auth/forms.body.readonly",
      "https://www.googleapis.com/auth/forms.body",
      "https://www.googleapis.com/auth/drive",
    ],
  });

  const client = await auth.getClient();
  forms = google.forms({ version: "v1", auth: client });
  console.log("google form authenticated");
};

const fetchForm = async (formId) => {
  const data = await forms.forms.get({
    formId,
  });
  return data.data;
};

const addFormToSheet = async (formId, formName) => {
  const data = new FormData();
  data.append("formId", formId);
  data.append("formName", formName);
  // APP_SCRIPT_URL from the ENV file added in the same folder.
  // We will get this URL after the deploy the AppScript
  const response = await axios.post(process.env.APP_SCRIPT_URL, data, {
    headers: {
      "Content-Type": "multipart/form-data",
    },
  });

  console.log(response.data);
};

module.exports = {
  authenticateForm,
  fetchForm,
  addFormToSheet,
};

```

Make the server publicly available using ngrok. Checkout the link to setup ngrok.

Setup Google Sheet

Create a Google Sheet and set the AppScript logic to link Google Form to the Google Sheet and trigger a webhook while user submit the form.

Use the AppScript provided below.

// This function will trigger when you do the post request using the AppScript deploy link
function doPost(e) {
  var formId = e.parameter.formId; // Google Form ID send in POST request
  var sheetName = e.parameter.formName; // Google Form title send in POST rquest
  var form = FormApp.openById(formId);

  // Replace with your sheet ID
  var sheetId = 'sheet_id';

  // Link the form to the sheet
  form.setDestination(FormApp.DestinationType.SPREADSHEET, sheetId);

  // Get all sheets in the spreadsheet
  var spreadsheet = SpreadsheetApp.openById(sheetId);
  var sheets = spreadsheet.getSheets();

  // set the sheet name as the form title
  for (var i = 0; i < sheets.length; i++) {
    if (sheets[i].getName().startsWith('Form')) {
      sheets[i].setName(sheetName);
      break;
    }
  }

  return ContentService.createTextOutput("Done");
}

// This function will trigger when a user submits any of the linked form
function onFormSubmit(e) {
  // Get the active spreadsheet and the first sheet
  var sheet = SpreadsheetApp.getActiveSpreadsheet().getActiveSheet();

  // Get the headers (field names)
  var headers = sheet.getRange(1, 1, 1, sheet.getLastColumn()).getValues()[0];

  // Get the response values
  var values = e.values;

  // Create an object with the field names and values
  var data = {};
  for (var i = 0; i < headers.length; i++) {
    data[headers[i]] = values[i];
  }
  console.log(data);

  // Get the form URL
  var formUrl = e.range.getSheet().getFormUrl();

  // Extract the form ID from the form URL
  var formId = formUrl.split('/forms/d/')[1].split('/')[0];
  console.log('Form ID: ' + formId);

  // Add the form ID to the data
  data['formId'] = formId;

  // Prepare the options for the HTTP request
  var options = {
    method: 'post',
    headers: { 'Content-Type': 'application/json' },
    payload: JSON.stringify(data)
  };

  // Send the HTTP request. Replace the URL with your server webhook url (url from ngrok)
  UrlFetchApp.fetch('webhook_url', options);
}

The selected part of the Google Sheet URL is the sheet ID.

After saving the AppScript go to the trigger section and create the trigger to execute the onFormSubmit function when a row entry happens in sheet.

When you clicks the save button you have to authorize with your Google account.

Deploy the AppScript

After clicks the deploy button, you will get the AppScript URL and update in your server ENV file and restart the server .

Testing

Upload Google Form ID using the API to link with Google Sheet.

The selected part of the Google Form URL is the Google Form ID

Submit a response using the form you will get the form response in your terminal.

You can link multiple forms to a sheet using the Form ID Upload API. Responses from these forms can be found using the "formId" key in the webhook.

NOTE

Upon calling the Google Workspace API for the first time, you may receive an unauthorized error due to a delay in API enablement or service account setup.
If you still encounter the error, try changing the service account role to owner.

How to setup the Dependency-Track? ( Dependency-Track : PART - 01 )

Amjad C P — Sun, 25 Feb 2024 17:58:06 +0000

What is Dependency Track?

Dependency Track is a significant project within OWASP. It helps organizations monitor software dependency vulnerabilities. It also offers guidance on dependency usage along with dependency licenses, as explained in Component Analysis. This is achieved by leveraging CycloneDX SBOM.

It is ideally used in CI/CD environments, and here we're going to use it with Github Actions.

Source : Image from https://docs.dependencytrack.org/integrations/ecosystem/

What is Software Bill of Materials ( SBOM )?

SBOM is a document that describes the components (packages, frameworks, software, etc.) used in an application. It provides greater transparency for the application. CycloneDX is a standard for Software Bill of Materials (SBOM).

How does Dependency Track find vulnerabilities from SBOM?

The Dependency Track discovers vulnerabilities from SBOM by scanning through the components listed in the SBOM. Once the scan is complete, It matches components with known vulnerabilities from various databases, such as NVD, VulnDB, etc as shown in the ecosystem diagram above.

Now let’s check how to setup the Dependency Track with GitHub Actions for a NodeJs project. Before doing that we can try to run manually first.

1. Setting up the Dependency Track

1.1. Download the Docker engine as a prerequisite, Checkout the link.

1.2. Download the docker compose file :
curl -LO https://dependencytrack.org/docker-compose.yml

1.3. Up the Dependency Track server : docker-compose up -d

a.Note that the platform front-end will run in localhost:8080 and back-end will run in localhost:8081

b.Ping http://localhost:8081/api/swagger.json to get API doc.

c.Username : admin, Password : admin this is the default credential to access the platform.

Dashboard ( localhost:8080/dashboard )

2. Create Project

Project List ( localhost:8080/projects )

Form

Project Details Page ( localhost:8080/projects/2118e953-575f-4208-a544-9b8492bc9f86 ). Here “2118e953-575f-4208-a544-9b8492bc9f86” is the project id and we need this data in upcoming step.

3. Create CycloneDX SBOM For The NodeJs Project

3.1. Install the npm package cyclonedx-npm globally :

`sudo npm -g i @cyclonedx/cyclonedx-npm`

3.2. Open the project directory in terminal and enter the command:

`cyclonedx-npm --package-lock-only --output-file <file_name>.json`

![Untitled](https://prod-files-secure.s3.us-west-2.amazonaws.com/74dfbe9a-9f19-4a1d-9079-01161bb9d47c/908a107d-3d23-430a-95cc-da3548bdfc2d/Untitled.png)

4a. Upload The SBOM Using GUI

Upload the file ( localhost:8080/projects/2118e953-575f-4208-a544-9b8492bc9f86/components )

After uploading the file(localhost:8080/projects/2118e953-575f-4208-a544-9b8492bc9f8/components)

4b. Upload The SBOM Using API

We have to use API while we use the platform with GitHub Action.

curl --location 'http://localhost:8081/api/v1/bom' \
--header 'X-Api-Key: <API_KEY>' \
--form 'project="<PROJECT_ID>"' \
--form 'bom=@"/path/to/SBOM/file"'

To get the API key go to http://localhost:8080/admin/accessManagement/teams and select automation team. Keep the API key secure.

Finally, we've learned how to use Dependency Track for a Node.js project. Now, we can explore how to use it with GitHub Actions. Before doing so, we need to ensure the Dependency Track back-end is publicly available. As a short-term solution to this, we can set up Ngrok.

Configure GitHub Action In Project Repository

Set repository secret

While setting up GitHub Actions, we must store sensitive data as repository secrets in the settings. Please note that you must have admin access to the repository in order to change the settings.

Set a workflow in main branch

name: Generate SBOM and Post to Dependency-Track
on: 
  workflow_dispatch:
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Setup Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '18'

      - name: Install CycloneDX
        run: npm install -g @cyclonedx/cyclonedx-npm

      - name: Generate SBOM
        run: npx cyclonedx-npm --package-lock-only --output-file SBOM.json

      - name: Post SBOM to Dependency-Track
        run: |
          response=$(curl --location '${{ secrets.API_URL }}' \
          --header 'X-Api-Key: ${{ secrets.API_KEY }}' \
          --form 'project="${{ secrets.PROJECT_ID }}"' \
          --form 'bom=@SBOM.json')
          echo "Response from curl= $response"

Host The Server In EC2

Check out the link for reference

Launch EC2
Assign Elastic IP
Install Docker : sudo snap install docker
Download the docker compose file : curl -LO https://dependencytrack.org/docker-compose.yml
Up the Dependency Track server : docker-compose up -d

Configure Nginx

server {
    listen 80;
    server_name <YOUR_PUBLIC_IP_ADDRESS / DOMAIN_NAME>;
    access_log /var/log/nginx/reverse-access.log;
    error_log /var/log/nginx/reverse-error.log;
    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
        location ~ /api/v[1-9]/ {
        proxy_pass http://127.0.0.1:8081;
      }
}

References

Conclusion

In this part we’ve covered how to setup the Dependency-Track on your local system and on AWS EC2 .

I hope you enjoyed this article. Please leave your suggestions in the comments below and let me know if you’d be interested in reading a Part 2.

How web technology works? - Part 02

Amjad C P — Sun, 18 Feb 2024 11:19:15 +0000

In this section, we will explore how to send data to a web server. We will be using the http library in Node.js to build our server.

Before moving on, ensure you're familiar with the concepts covered in Part 1, which you can find here: How web technology works? - Part 01

Create form in HTML

HTML forms are commonly used to send data to a server. To begin, let's create an HTML form. We will be using the POST method to send data to the server. Please refer to the screenshot above for a better understanding of the form we will be using.

Create web-server using NodeJS

Here is a server that serves HTML files. If a request is made to the "/form" path, the server will return the form.html file. The client can then make a POST request to the "/submit" path with the form data, and the server will simply log the data to the console. If the client requests any other path, they will receive a "Not Found" message. Please refer to the screenshots below for further clarification.

The client requests "/form" using the GET method.

The client requests “/submit” using the POST method

The form data in the POST request.

The response for the POST request.

The server logs the POST request from the client.

Conclusion: Sending Data to the Server - More Than Just Forms

we explored sending data to a web server using an HTML form and Node.js. While this is a common and user-friendly approach, it's important to remember that it's just one piece of the puzzle.

Key Takeaways:

Method Choice Matters: The best way to send data depends on your specific needs. Whether building a contact form, an e-commerce checkout, or an API, understanding different methods like forms, JSON bodies, URL parameters, and queries is crucial for optimal communication between clients and servers.
Beyond Forms: While forms are great for user input, other methods offer more flexibility and power. JSON bodies are perfect for structured data exchange in APIs, while URL parameters and queries excel at passing smaller data chunks.
Data's Final Destination: Ultimately, the server processes and stores the received data. Databases are a common choice for persistent storage, allowing easy retrieval and manipulation.

How web technology works? - Part 01

Amjad C P — Sun, 11 Feb 2024 09:38:32 +0000

This common diagram, frequently encountered when learning about web technology, often leads to confusion among newcomers regarding the roles of servers and clients.

Le newcomer: "What on earth?! In the diagram, the server and client are depicted as separate computers. However, when I build a web app, my PC acts as a server when I run 'npm start' in VScode, and it acts as a client when I open the output in the browser."

So, I would like to share my understanding in client - server working here and hopefully, this will be helpful for those who are new to web development.

What is Server and Client?

First, keep in mind that the server and client both are applications like other applications on your phone or PC. The server will serve files like HTML, JSON, mp4, mp3, PNG, jpg, etc and the client will request the files to the server and display the files. For instance, Live Server (a VScode extension) acts as a server, while browsers act as clients.

However, when working with frameworks like Django or ExpressJS, you don’t need a separate server. These frameworks inherently function as servers.

Wait! The server and client are applications so we can run on the same computer that is fine but how the client can send a request to the server for the file? need a network right? Here the concepts of localhost and loopback come into the picture.

for visualization purposes just think that your entire PC is a pipeline and the pipeline has holes called ports. Also, consider the applications in your PC are extensions to collect or contribute water through the pipeline. So when you run your server and client(browser) in your system they are up in 2 ports and communicate with each other.

HTTP Request and Response

Server and Client interact with each other through HTTP requests and HTTP responses. So we need an idea about the HTTP.

HTTP is a stateless protocol that is used in web technology, check the link to dive more into HTTP.

for visualization purposes just think the HTTP request is a letter from the client to request a file, and the HTTP response is a reply letter from the server, maybe it’s a positive or negative reply. Like in a formal letter each HTTP request and response have a header and body. Each HTTP header has the metadata of the server and client like OS, IP, requested time, etc. Check the network tab in your browser to get the log to understand the server-client interactions.

Server as a Computer

The server is an application, so is the diagram wrong? Absolutely not; consider the analogy of smartphones. A smartphone can perform various tasks like taking photos, gaming, and routing, but its primary purpose remains communication (i.e., making calls). Similarly, when we deploy a server on the internet, it must be available 24/7 to handle numerous client requests efficiently. To achieve this, we often dedicate specific computers or clusters solely to run the server. Consequently, these computers are commonly referred to as servers.

Let’s check how the server-client interaction happening in localhost, LAN, and internet.

Server in Localhost

For the demo purpose, I’m going to use Live Server (a VScode extension) as the server and I have created index.html and home.html files to serve. To start the server enter Ctrl + Shift + P and select “open with live server” Then the live server will be up in localhost:5500

Here the client requested to root ( localhost:5500/ ) so in this case the live server gives the root file index.html (the live server considers the file name “index.html” file as the root file ).

Here the client requested the path /home.html ( localhost:5500/home.html ) so the server serves the file home.html

Here the client requested the path /abc.html ( localhost:5500/abc.html ) but there is no file abc.html in the server so the server returns an error, the path not found ( status code 404 )

Server in LAN

Now, we understand how to run the server in localhost, our next challenge is to access files from a device other than the one running the server. Let’s explore how to view the previous output on a mobile phone that’s connected to the same Wi-Fi router as the computer running the server.

Use ipconfig(windows) or ifconfig(Linux) to get network configurations. Keep in mind that the result may contain sensitive data so be aware when you share this output. Here 192.168.1.6 is the local IP of the PC running server.

Yey! If request to 192.168.1.6:5500 any device from the same LAN will get the index.html file.

Server in Internet

Now we can try to make the server public, to do this we need to download the service Ngrok. After downloading we get a CLI tool and we need to authenticate to the tool using a token and enable the tunnel ( in our case the port number is 5500 )

After executing the tunnel command we will get a temp URL from Ngrok, so the server is public now!! But there is a problem, if we close the server, close the tunnel, or shut down the PC then the public can’t access the server. So we need to use a hosting platform like Netlify.

Conclusion

In this part we’ve covered how web servers serve static files. We’ve discussed the fundamental concepts and explored ways to visualize these ideas.

Stay tuned for more insightful explorations into the world of web servers!”

Host NodeJS Server in EC2 Instance

Amjad C P — Thu, 08 Feb 2024 18:08:02 +0000

EC2 instance is a cloud computing service provided by AWS. It allows you to launch virtual machines called instances. In this case, we will be hosting our Node.js server on an EC2 instance. Before proceeding, make sure you have AWS access set up as a prerequisite.

1. Launch EC2 Instance

Click the "Launch Instance" button on the EC2 dashboard under Instances.
Select an operating system (OS) from the available Amazon Machine Images (AMI). Ubuntu is recommended for learning purposes.
Choose an instance type (t2.micro is recommended for learning purposes). The instance type determines the configuration of CPU, memory, storage, and network capacity for the EC2 instance. When selecting an instance type for production, you need to consider various factors such as the size of the server, the services to be provided, the expected number of users per minute, performance requirements, cost, and availability, among others. Refer to this link for guidance on choosing the appropriate instance type for your needs.
Generate a new key pair (.pem file) and securely save it. You will need this file to access the EC2 instance through an SSH connection.
Allow HTTP and HTTPS traffic, and temporarily set SSH access from everywhere. If you wish to restrict SSH access to your instance, either disable SSH or provide access to a static IP of another EC2 instance that allows SSH access everywhere.
Leave the remaining options as default and click on "Launch Instance".
AWS Task 1: Launch an EC2 instance

2.Assign Elastic IP to EC2 Instance

Elastic IP is the static public IP provided by AWS. By assigning the static IP to an instance, we can ensure that the IP won't change in the event of any failures occurring to the instance.

Click the "Allocate Elastic IP address" button located in the EC2 dashboard under Elastic IPs.
Leave all options as default and click on "Allocate".
Associate the EC2 instance with the elastic IP.

3. Establish Remote Access to EC2 Instance through SSH

Open terminal in your system and type the command :

sudo ssh -i "path/to/.pem/file" ubuntu@<elastic ip assign to the instance>
Update the package list : sudo apt update
Upgrade the pages : sudo apt upgrade

4. Clone GitHub Repository

To clone a GitHub repository, you can use the SSH URL. However, before doing so, you need to set up a deploy key in the repository settings. Please note that you must have admin access to the repository in order to change the settings.

A deploy key is an SSH key that grants access to a single repository. To generate a deploy key, you can do so on your server and then add it to your repository settings on GitHub. By doing this, you will be able to securely clone the repository using the SSH URL.

For more information, please refer to this link.

Generate the SSH key :

a. ssh-keygen -t ed25519 -C "your_email@example.com"

b. give the repository name for the SSH key ( recommended ) and store the key in the path /home/ubuntu/.ssh/<repository_name>

c. create a file “config” in the path /home/ubuntu/.ssh/config and set the configuration
```
Host <repository_name>
        Hostname github.com
        IdentityFile=/home/ubuntu/.ssh/<repository_name>
```
d. Copy the value from /home/ubuntu/.ssh/<repository_name> and set as deploy key in repository settings

e. clone the repository to the instance : git clone git@<repository_name>:<github_username>/<repository_name>

5. Install NodeJS

Install the package nvm curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/master/install.sh | bash
Reload shell source ~/.bashrc
Install node LTS version nvm install --lts

6. Run NodeJS server using PM2

PM2 is a production process manager to keep your application alive forever

Open the repository in instance cd <repository_name>
Install project packages npm ci
Install PM2 npm install -g pm2
Start server pm2 start /path/of/main/file.js --name <server_name> OR pm2 start npm --name "server_name" -- start

7. Configure Nginx

Nginx will act as a reverse proxy for your server. Before configuring Nginx, you need to connect a domain to the EC2 instance. You can learn more about reverse proxy here.

Install nginx : sudo apt install nginx
Unlink the default configuration file sudo unlink /etc/nginx/sites-enabled/default

Create new configuration file sudo nano /etc/nginx/sites-available/reverse-proxy.conf

server {
    listen 80;
    server_name <YOUR_PUBLIC_IP_ADDRESS / DOMAIN_NAME>;
    access_log /var/log/nginx/reverse-access.log;
    error_log /var/log/nginx/reverse-error.log;
    location / {
        proxy_pass http://localhost:<server_port_number>;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

Link the new configuration file

sudo ln -s /etc/nginx/sites-available/reverse-proxy.conf /etc/nginx/sites-enabled/reverse-proxy.conf
Check is there any issue in the new configuration syntax sudo nginx -t
Restart the nginx service sudo systemctl reload nginx

8. Configure SSL Certificate using Certbot

Install certbot sudo apt install certbot python3-certbot-nginx
Request for SSL certificate sudo certbot --nginx -d YOUR_DOMAIN

Note

When performing a task for the first time, it is possible that you may need to repeat certain steps multiple times. In such cases, there is a chance of exiting from a process without terminating it.

To get a process ID / service ID lsof -t -i:<port>
To kill a service kill service <id>
Delete nginx sudo apt purge nginx nginx-common nginx-core

DEV Community: Amjad C P

Deploying a MEAN Stack App Without a Cloud Provider

🏗️ The Architecture

1. Setting Up the Server (VirtualBox)

2. Docker Hub & GitHub Secrets

3. The Self-Hosted Runner

4. Containerization (The Code)

Backend Dockerfile (backend/Dockerfile)

Frontend Dockerfile (frontend/Dockerfile)

Docker Compose (docker-compose.yml)

5. Nginx Reverse Proxy

6. The CI/CD Pipeline

CI/CD Success

Docker Hub

Running Services

Key Takeaways

How to Setup Webhook in Google Form?

Create Service Account & Enable APIs

Setup Google Form

Setup Server

Setup Google Sheet

Testing

NOTE

How to setup the Dependency-Track? ( Dependency-Track : PART - 01 )

What is Dependency Track?

What is Software Bill of Materials ( SBOM )?

How does Dependency Track find vulnerabilities from SBOM?

1. Setting up the Dependency Track

2. Create Project

3. Create CycloneDX SBOM For The NodeJs Project

4a. Upload The SBOM Using GUI

4b. Upload The SBOM Using API

Configure GitHub Action In Project Repository

Host The Server In EC2

References

Conclusion

How web technology works? - Part 02

Create form in HTML

Create web-server using NodeJS

Conclusion: Sending Data to the Server - More Than Just Forms

How web technology works? - Part 01

What is Server and Client?

HTTP Request and Response

Server as a Computer

Server in Localhost

Server in LAN

Server in Internet

Conclusion

Host NodeJS Server in EC2 Instance

1. Launch EC2 Instance

2.Assign Elastic IP to EC2 Instance

3. Establish Remote Access to EC2 Instance through SSH

4. Clone GitHub Repository

5. Install NodeJS

6. Run NodeJS server using PM2

7. Configure Nginx

8. Configure SSL Certificate using Certbot

Note

Backend Dockerfile (`backend/Dockerfile`)

Frontend Dockerfile (`frontend/Dockerfile`)

Docker Compose (`docker-compose.yml`)