DEV Community: Ved Dandotia

Building a Highly Available Web Tier on AWS — Application Load Balancer + Auto Scaling Group

Ved Dandotia — Tue, 28 Jul 2026 06:16:55 +0000

⚖️ Application Load Balancer + Auto Scaling Group on AWS

So far in this series, we've built a custom VPC with public/private subnets and added a NAT Gateway for outbound access. Now it's time to put that network to real use: deploying a highly available, self-healing web tier using an Application Load Balancer (ALB) and an Auto Scaling Group (ASG).

By the end of this post, you'll have multiple EC2 instances running in private subnets, sitting behind a public-facing load balancer, automatically distributing traffic — and automatically replacing any instance that fails.

🧠 The Core Pattern

This is one of the most important architecture patterns in AWS:

Internet → ALB (public subnet) → Target Group → EC2 Instances (private subnet)

The ALB is the only internet-facing component — it lives in the public subnet.
The EC2 instances never touch the internet directly — they live in the private subnet, reachable only through the ALB.
This is a defense-in-depth principle: never expose more than you have to. Even if someone discovers an instance's private IP, there's no route in from outside the VPC.

Traffic flow, step by step:

A user hits the ALB's DNS name
The ALB (in the public subnet, reachable via the Internet Gateway) receives the request
The ALB forwards it internally — over the VPC's private network — to a healthy instance in the private subnet, via the Target Group
The instance responds back through the same private path

🖼️ Architecture

                         Internet
                             │
                             ▼
                    ┌──────────────────┐
                    │   demo-alb        │  (Public Subnets)
                    │ (alb-sg: 80 open) │
                    └─────────┬─────────┘
                              │
                              ▼
                    ┌──────────────────┐
                    │   demo-tg          │
                    │  (Target Group)    │
                    └─────────┬─────────┘
                              │
              ┌───────────────┴────────────────┐
              ▼                                ▼
     EC2 Instance (private)           EC2 Instance (private)
     instance-sg: 80 from alb-sg      instance-sg: 80 from alb-sg
     (Auto Scaling Group: demo-asg, desired 2, min 2, max 4)

🧩 A Key Design Choice: No Nginx, No Internet Needed

Our private subnets have no NAT Gateway, meaning the instances have no outbound internet access. A typical yum install nginx in User Data would fail here, since nginx isn't preinstalled and package repos are external.

Instead, we'll use Python's built-in HTTP server, which ships with Amazon Linux 2023 out of the box — no internet required. This keeps the whole demo self-contained.

💡 If your use case later needs real outbound access (installing packages, calling external APIs), add a NAT Gateway in the public subnet and route the private subnet's 0.0.0.0/0 traffic through it — see my previous NAT Gateway blog here for the full walkthrough.

✅ Prerequisites

A custom VPC with two public subnets and two private subnets, each pair spread across two Availability Zones (ALB requires subnets in 2+ AZs)
An Internet Gateway attached to the VPC

The Build Order

We'll go: Security Groups → Target Group → Launch Template → ALB → Auto Scaling Group

Step 1: Create Two Security Groups

A) ALB Security Group

EC2 Console → Security Groups → Create Security Group
Name: alb-sg, Description: "ALB security group", VPC: your demo VPC
Inbound rules: Add rule → Type: HTTP, Port 80, Source: Anywhere-IPv4 (0.0.0.0/0)
Outbound rules: leave default (all traffic allowed)
Create

B) Instance Security Group

Create another security group
Name: instance-sg, Description: "EC2 instance SG", same VPC
Inbound rules: Add rule → Type: HTTP, Port 80, Source: Custom → select alb-sg (not a CIDR range — this restricts traffic to only what's coming from the ALB)
Create

This is the crucial detail: instances only accept HTTP traffic that's coming from the load balancer, never directly from the internet.

Step 2: Create the Target Group

EC2 Console → Target Groups → Create Target Group
Target type: Instances
Name: demo-tg
Protocol: HTTP, Port: 80
VPC: your demo VPC
Health checks:
- Protocol: HTTP, Path: /
- Advanced settings: Healthy threshold 2, Unhealthy threshold 2, Timeout 5, Interval 10, Success codes 200
Next → skip "Register targets" (the ASG will handle this automatically) → Create target group

Step 3: Create the Launch Template

EC2 Console → Launch Templates → Create Launch Template
Name: demo-lt
AMI: Amazon Linux 2023
Instance type: t3.micro
Key pair: optional — only needed if you want SSH access for debugging
Network settings: leave subnet blank (the ASG assigns subnets); Security groups: select instance-sg
Advanced details → User data:

#!/bin/bash
mkdir -p /var/www/demo
cat <<EOF > /var/www/demo/index.html
<html><body><h1>Hello from $(hostname -f)</h1></body></html>
EOF
cd /var/www/demo
nohup python3 -m http.server 80 > /var/log/demo-server.log 2>&1 &

This serves a page showing the instance's hostname — so when you refresh the ALB's URL repeatedly, you can literally watch it load-balance across different instances.

Create the template

Auto Scaling guidance checkbox: In the wizard, check "Provide guidance to help me set up a template for use with EC2 Auto Scaling." It doesn't restrict anything functionally — it just hides/discourages settings that don't make sense for ASG-launched instances (like picking a specific subnet or attaching a public IP), and nudges you toward leaving those to the ASG. Since our instances live in private subnets with no public IP needed, this is exactly the right guidance.

Step 4: Create the Application Load Balancer

EC2 Console → Load Balancers → Create Load Balancer → Application Load Balancer
Name: demo-alb
Scheme: Internet-facing
IP address type: IPv4
Network mapping: select your VPC → check both public subnets (one per AZ — required, since the ALB needs subnets in 2+ Availability Zones)
Security groups: select alb-sg (remove any default SG that gets auto-added)
Listeners and routing: Listener HTTP:80 → Default action: Forward to → select demo-tg
Create

Wait a minute or two for the state to become Active.

Step 5: Create the Auto Scaling Group

EC2 Console → Auto Scaling Groups → Create Auto Scaling Group
Name: demo-asg
Launch template: select demo-lt → Next
VPC: your demo VPC → Availability Zones and subnets: select both private subnets (one per AZ)
Next → Attach to an existing load balancer → Choose from your load balancer target groups → select demo-tg
Health checks: turn ON "Turn on Elastic Load Balancing health checks" — without this, the ASG only checks raw EC2 status, not whether your app is actually responding
Health check grace period: 60 seconds (gives the instance time to boot before checks start counting against it)
Next → Group size:
- Desired capacity: 2
- Minimum: 2
- Maximum: 4
(Optional) Add a scaling policy like "Target tracking on CPU 50%," or skip for now
Review → Create Auto Scaling group

Step 6: Verify

Wait ~2–3 minutes for instances to launch and pass health checks
EC2 Console → Target Groups → demo-tg → Targets tab — both instances should show healthy
EC2 Console → Load Balancers → demo-alb — copy the DNS name (something like demo-alb-123456789.us-east-1.elb.amazonaws.com)
Paste that DNS name into your browser and refresh a few times — you should see the hostname in the page change between instances as the ALB load-balances requests

🔍 Quick Recap

Resource	Purpose
`alb-sg`	Allows HTTP from the internet, attached to the ALB
`instance-sg`	Allows HTTP only from `alb-sg`, attached to instances
`demo-tg`	Target group routing traffic to healthy instances
`demo-lt`	Launch template defining how each instance boots (AMI, SG, User Data)
`demo-alb`	Internet-facing load balancer in public subnets
`demo-asg`	Auto Scaling Group maintaining 2–4 instances in private subnets

🧹 Cleanup

To avoid ongoing charges:

Delete the Auto Scaling Group (this terminates its instances too)
Delete the Load Balancer
Delete the Target Group
Delete the Launch Template
Delete the two security groups (alb-sg, instance-sg)

🏁 Wrap-Up

You've now built a genuinely production-style pattern: a public-facing load balancer distributing traffic across multiple private, auto-healing instances — with the instances never directly exposed to the internet. This "one door in" architecture is the backbone of most real-world AWS web applications.

Full project files are available on GitHub.

Hosting a Static Website on AWS S3 — Step-by-Step Guide

Ved Dandotia — Sun, 26 Jul 2026 10:50:53 +0000

🪣 Hosting a Static Website on AWS S3

Not every website needs a server. If your site is just HTML, CSS, and JavaScript — no backend, no database — Amazon S3 can host it directly, cheaply, and reliably. No EC2 instance, no server management, no patching.

In this post, we'll take a simple 3-file website (index.html, error.html, script.js) and host it on S3 as a public static website.

🧠 Why S3 for Static Hosting?

No servers to manage or patch
Extremely low cost (pay only for storage + requests)
Scales automatically — handles a handful of visitors or a viral spike the same way
Great for portfolios, landing pages, documentation sites, or single-page apps

🖼️ Architecture

Flow:

Browser Request → S3 Bucket (Static Website Hosting enabled)
                         │
                         ├── index.html   (default page)
                         ├── error.html   (shown on 404 / errors)
                         └── script.js    (site logic)

✅ Prerequisites

An AWS account
Three simple files ready to upload:
- index.html — your homepage
- error.html — shown when a page/object isn't found
- script.js — any JavaScript your site uses

Example minimal files, if you don't have your own yet:

index.html

<!DOCTYPE html>
<html>
<head>
  <title>My S3 Website</title>
  <script src="script.js"></script>
</head>
<body>
  <h1>Hello from my S3 Static Website!</h1>
</body>
</html>

error.html

<!DOCTYPE html>
<html>
<head>
  <title>Page Not Found</title>
</head>
<body>
  <h1>Oops! That page doesn't exist.</h1>
</body>
</html>

script.js

console.log("Site loaded successfully from S3!");

Step 1: Create the S3 Bucket

Go to S3 Console → Create Bucket
Bucket name: must be globally unique, e.g. my-static-site-demo-2026
Region: choose your preferred region (e.g., ap-south-1)
Block Public Access settings: Uncheck "Block all public access" — a static website needs to be publicly readable > ⚠️ Acknowledge the warning checkbox that appears. This is expected and required for public static hosting.
Leave other settings as default → Create Bucket

Step 2: Upload Your Website Files

Open your new bucket → Upload
Add your three files: index.html, error.html, style.css_ script.js
Click Upload

Step 3: Enable Static Website Hosting

In your bucket, go to Properties tab
Scroll to Static website hosting → Edit
Settings:
- Static website hosting: Enable
- Hosting type: Host a static website
- Index document: index.html
- Error document: error.html
Save changes

AWS will now show you a Bucket website endpoint URL (something like http://my-static-site-demo-2026.s3-website.ap-south-1.amazonaws.com) — keep this handy, you'll need it in Step 5.

Step 4: Add a Bucket Policy for Public Read Access

Even with "Block Public Access" disabled, S3 objects aren't public until a policy explicitly allows it.

Go to Permissions tab → Bucket Policy → Edit
Paste the following (replace YOUR-BUCKET-NAME with your actual bucket name):

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "PublicReadGetObject",
      "Effect": "Allow",
      "Principal": "*",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::YOUR-BUCKET-NAME/*"
    }
  ]
}

Save changes

This policy allows anyone to read (GET) objects in the bucket — exactly what's needed for a public website, and nothing more (no write/delete access).

Step 5: Test Your Website

Open the Bucket website endpoint URL from Step 3 in your browser:

http://YOUR-BUCKET-NAME.s3-website.<region>.amazonaws.com

You should see your index.html page render, and if you open the browser console, you should see the message from script.js logged.

Try visiting a non-existent path (e.g., add /random-page to the URL) — you should see your custom error.html page instead of a generic AWS error.

🔍 Quick Recap

Step	What Happened
Created bucket	Storage container for website files
Uploaded files	`index.html`, `error.html`, `script.js`
Enabled static hosting	Told S3 which file is the homepage & error page
Added bucket policy	Made objects publicly readable
Tested endpoint	Confirmed the site loads and errors are handled

🔐 A Note on Security

Public bucket policies only grant read access (s3:GetObject) — visitors can view your site, but can't upload, modify, or delete anything. Still, double check:

Only the specific files/paths needed are public
Sensitive files are never placed in a publicly hosted bucket
Consider adding CloudFront in front of the bucket for HTTPS support (S3 static website endpoints don't support HTTPS natively) — a good topic for a follow-up post!

🧹 Cleanup

To avoid any storage charges:

Empty the bucket (Bucket → Empty)
Delete the bucket (Bucket → Delete)

🏁 Wrap-Up

You've now hosted a fully working static website on S3 — no servers, no scaling concerns, just fast and cheap. This same pattern powers countless portfolios, docs sites, and landing pages in production today.

Full project files are available on GitHub.

🔀 Adding a NAT Gateway to Your AWS VPC — Giving Private Subnets Internet Access (Safely)

Ved Dandotia — Sat, 25 Jul 2026 05:43:42 +0000

In my previous tutorial, we built a custom VPC with public and private subnets, an Internet Gateway, and an EC2 instance running in the public subnet.

While the private subnet was secure, it had one major limitation—it couldn't access the internet at all.

In real-world AWS environments, private resources such as application servers and databases often need outbound internet access to install updates, download packages, or communicate with external APIs, while remaining inaccessible from the public internet.

This is exactly where a NAT Gateway comes in.

By the end of this guide, you'll configure a NAT Gateway that allows instances in a private subnet to securely access the internet without exposing them to inbound traffic.

🚀 What You'll Build

In this tutorial, we'll create:

✅ An Elastic IP
✅ A NAT Gateway
✅ Updated Private Route Table
✅ A Private EC2 Instance
✅ Secure outbound internet connectivity for the private subnet

🧠 What is a NAT Gateway?

A Network Address Translation (NAT) Gateway enables instances in a private subnet to initiate outbound connections to the internet while preventing inbound connections initiated from the internet.

Think of it like a one-way door:

✅ Private Subnet → Internet
❌ Internet → Private Subnet

This allows servers to download software updates, install packages, or communicate with external services without exposing them to public access.

🏗️ Architecture

📋 Prerequisites

Before continuing, ensure you already have:

A custom VPC (demo-vpc)
A Public Subnet (demo-public-subnet-1a)
A Private Subnet (demo-private-subnet-1a)
An Internet Gateway attached to the VPC
A Route Table for each subnet
An EC2 instance running in the public subnet

If you haven't completed those steps, check out my previous article on building a custom VPC.

here:- [https://dev.to/techxved/building-a-custom-vpc-on-aws-public-private-subnets-route-tables-and-an-ec2-instance-4eh1]

Step 1 — Allocate an Elastic IP

A NAT Gateway requires a static public IP address.

Navigate to:

VPC → Elastic IPs → Allocate Elastic IP Address

Leave the default settings and click Allocate.

Give it a name such as:

demo-natgw-eip

Step 2 — Create the NAT Gateway

Navigate to:

VPC → NAT Gateways → Create NAT Gateway

Use the following configuration.

Setting	Value
Name	demo-NATGW
Subnet	demo-public-subnet-1a
Connectivity Type	Public
Elastic IP	demo-natgw-eip

Click Create NAT Gateway.

It usually takes a couple of minutes before its status changes to Available.

⚠️ Important

A NAT Gateway must always be deployed in a public subnet so it can communicate with the Internet Gateway.

Step 3 — Update the Private Route Table

Now we'll allow the private subnet to send outbound traffic through the NAT Gateway.

Navigate to:

VPC → Route Tables → demo-private-RT

Edit the routes and configure:

Destination	Target
10.0.0.0/16	local
0.0.0.0/0	demo-NATGW

Save the changes.

Your private subnet can now initiate outbound internet connections while remaining inaccessible from the internet.

Step 4 — Launch an EC2 Instance in the Private Subnet

Launch another EC2 instance using the following configuration.

Setting	Value
AMI	Amazon Linux 2
Instance Type	t3.micro
VPC	demo-vpc
Subnet	demo-private-subnet-1a
Auto Assign Public IP	Disabled

For the Security Group:

Allow SSH (22) only from the public EC2 instance or Bastion Host
Do not allow SSH from 0.0.0.0/0

Launch the instance.

Notice that the instance has no Public IPv4 address, which means it cannot be accessed directly from the internet.

Step 5 — Verify NAT Gateway Connectivity

Since the private instance doesn't have a public IP, we'll first connect to the public EC2 instance and then access the private instance from there.

5.1 Copy the Key Pair

From your local machine:

scp -i demo_ec2.pem demo_ec2.pem ec2-user@<public-instance-ip>:~/

💡 Tip

In production environments, SSH Agent Forwarding is preferred instead of copying private keys.

5.2 Connect to the Public EC2

ssh -i demo_ec2.pem ec2-user@<public-instance-ip>

5.3 Connect to the Private EC2

chmod 400 demo_ec2.pem

ssh -i demo_ec2.pem ec2-user@<private-instance-private-ip>

5.4 Test Internet Access

Run the following commands from the private EC2 instance.

ping 8.8.8.8

If everything is configured correctly, you'll receive a response similar to:


Pinging 8.8.8.8 with 32 bytes of data:
Reply from 8.8.8.8: bytes=32 time=60ms TTL=117
Reply from 8.8.8.8: bytes=32 time=47ms TTL=117

This confirms that:

✅ The instance has internet access.
✅ Traffic is passing through the NAT Gateway.
✅ The instance still has no public IP.

5.5 Verify the Instance is Still Private

Try connecting directly to the private instance from your laptop.

ssh ec2-user@<private-instance-private-ip>

The connection should fail because the instance remains isolated from inbound internet traffic.

This is exactly how private application servers and databases are deployed in production environments.

🔍 Quick Recap

Resource	Purpose
demo-natgw-eip	Static Public IP
demo-NATGW	Provides outbound internet access
demo-private-RT	Routes traffic through the NAT Gateway
Private EC2	Secure instance without a Public IP

💰 Cost Note

⚠️ NAT Gateways are not included in the AWS Free Tier.

AWS charges:

Hourly usage
Data processing per GB

For learning purposes, remember to delete the NAT Gateway and release the Elastic IP when you're finished to avoid unnecessary charges.

🧹 Cleanup

Once you're done experimenting:

Terminate both EC2 instances.
Delete the NAT Gateway.
Release the Elastic IP.
Remove the 0.0.0.0/0 → demo-NATGW route from the private Route Table.
(Optional) Delete the subnets, Internet Gateway, and VPC.

🎉 Conclusion

Congratulations! You've successfully extended your custom AWS VPC by adding a NAT Gateway.

In this tutorial, you learned how to:

Allocate an Elastic IP
Deploy a NAT Gateway
Configure a Private Route Table
Launch a private EC2 instance
Enable outbound-only internet access
Maintain secure network isolation

This architecture is widely used in production AWS environments because it balances security and connectivity. Public-facing services remain accessible, while backend systems can safely communicate with the internet without being directly exposed.

🚀 What's Next?

In the next project, we'll explore how to make this architecture even more resilient by introducing services such as:

Application Load Balancer (ALB)
Auto Scaling Groups
Multi-AZ deployments
Amazon RDS in a private subnet

Together, these components form the foundation of highly available and production-ready AWS architectures.

Happy Cloud Learning! ☁️🚀

Source Code & Project Files

The complete project, including all three stages—

Amazon EC2 Deployment
Custom VPC with Public & Private Subnets
NAT Gateway Configuration

—is available on my GitHub repository.

🌐 Building a Custom VPC on AWS — Public & Private Subnets, Route Tables, and an EC2 Instance

Ved Dandotia — Fri, 24 Jul 2026 17:02:16 +0000

In my previous post, I launched my first Amazon EC2 instance using AWS's default VPC. While that's a great way to get started, production environments rarely rely on the default network configuration.

In this tutorial, we'll build a custom Virtual Private Cloud (VPC) from scratch, configure public and private subnets, connect the VPC to the internet using an Internet Gateway, create Route Tables, and finally launch an EC2 instance inside the public subnet.

By the end of this guide, you'll have a solid understanding of one of the most fundamental networking concepts in AWS.

🚀 What You'll Build

In this tutorial, we'll create:

✅ A Custom VPC
✅ A Public Subnet
✅ A Private Subnet
✅ An Internet Gateway
✅ Public and Private Route Tables
✅ An EC2 Instance in the Public Subnet

🧠 Why Create a Custom VPC?

AWS provides a default VPC in every region, which is perfect for learning or quick deployments. However, real-world cloud architectures require more control over networking.

With a custom VPC, you can:

Define your own IP address ranges using CIDR blocks
Separate internet-facing resources from internal resources
Control routing between subnets and the internet
Improve security by isolating sensitive workloads

A common production architecture places web servers in public subnets while keeping databases and backend services in private subnets.

🏗️ Architecture

📋 Prerequisites

Before starting, make sure you have:

An AWS Account
Basic understanding of CIDR and subnets
Basic familiarity with Amazon EC2 (optional but recommended)

Step 1 — Create the VPC

Open the AWS Management Console.
Navigate to VPC.
Select Your VPCs.
Click Create VPC.
Choose VPC only.

Use the following configuration:

Setting	Value
Name	demo-vpc
IPv4 CIDR Block	10.0.0.0/16
IPv6	None
Tenancy	Default

Click Create VPC.

A /16 CIDR block provides 65,536 IP addresses, giving you plenty of room to divide your network into multiple subnets.

Step 2 — Create Public and Private Subnets

We'll create two subnets inside our VPC.

Subnet	CIDR	Purpose
demo-public-subnet-1a	10.0.1.0/24	Internet-facing resources
demo-private-subnet-1a	10.0.2.0/24	Internal resources

To create each subnet:

Open Subnets.
Click Create Subnet.
Select demo-vpc.
Enter the subnet name.
Choose an Availability Zone (for example, ap-south-1a).
Enter the CIDR block.
Click Create Subnet.

💡 Tip

A /24 subnet provides 256 IP addresses, of which 251 are usable because AWS reserves five IP addresses in every subnet.

Step 3 — Create an Internet Gateway

An Internet Gateway (IGW) allows resources inside your VPC to communicate with the internet.

To create one:

Navigate to Internet Gateways.
Click Create Internet Gateway.
Name it demo-IGW.
Create the gateway.
Select the Internet Gateway.
Click Actions → Attach to VPC.
Choose demo-vpc.

Without an Internet Gateway, resources inside your VPC cannot communicate with the public internet.

Step 4 — Create Route Tables

Route Tables determine where network traffic is directed.

We'll create two Route Tables.

Public Route Table

Create a new Route Table.

Setting	Value
Name	demo-public-RT
VPC	demo-vpc

Add the following routes.

Destination	Target
10.0.0.0/16	local
0.0.0.0/0	demo-IGW

Associate this Route Table with:

demo-public-subnet-1a

Private Route Table

Create another Route Table.

Setting	Value
Name	demo-private-RT
VPC	demo-vpc

Leave only the default route.

Destination	Target
10.0.0.0/16	local

Associate it with:

demo-private-subnet-1a

⚠️ Important

A subnet is considered private because it has no route to an Internet Gateway.

Step 5 — Launch an EC2 Instance

Open the EC2 Console and click Launch Instance.

Use the following configuration.

Setting	Value
AMI	Amazon Linux 2
Instance Type	t3.micro
VPC	demo-vpc
Subnet	demo-public-subnet-1a
Auto Assign Public IP	Enabled

Create or select a Security Group allowing:

Type	Port
SSH	22
HTTP	80

Create or choose an existing Key Pair and launch the instance.

Because this EC2 instance is placed inside the public subnet and the subnet is associated with a Route Table pointing to the Internet Gateway, AWS automatically allows internet connectivity.

Step 6 — Verify Connectivity

Once the instance reaches the Running state:

Copy its Public IPv4 Address
Verify that a Public IP has been assigned

Connect using SSH.

ssh -i demo_ec2.pem ec2-user@<your-public-ip>

If the connection succeeds, your networking configuration is working correctly.

Now imagine launching another EC2 instance inside the private subnet.

You'll notice:

No Public IP Address
No direct internet connectivity
Accessible only from inside the VPC or through a Bastion Host/NAT Gateway

That's exactly how secure production architectures are designed.

🔍 Quick Recap

Resource	Purpose
demo-vpc	Custom Virtual Private Cloud
demo-public-subnet-1a	Hosts public resources
demo-private-subnet-1a	Hosts internal resources
demo-IGW	Provides internet connectivity
demo-public-RT	Routes public traffic to the IGW
demo-private-RT	Keeps private resources isolated
EC2 Instance	Runs inside the public subnet

🧹 Cleanup

To avoid unnecessary AWS charges:

Terminate the EC2 instance.
Delete Route Table associations.
Delete both subnets.
Detach and delete the Internet Gateway.
Delete the VPC.

🎉 Conclusion

Congratulations! You've successfully built a custom AWS Virtual Private Cloud from scratch.

In this tutorial, you learned how to:

Create a custom VPC
Configure public and private subnets
Attach an Internet Gateway
Create Route Tables
Launch an EC2 instance inside the public subnet
Understand how AWS networking works behind the scenes

This architecture forms the foundation of almost every production workload deployed on AWS.

🚀 What's Next?

In the next tutorial, we'll add a NAT Gateway so instances inside the private subnet can securely access the internet for software updates and package downloads—without being directly exposed to incoming internet traffic.

Stay tuned, and happy cloud learning! ☁️

Deploying Your First Web Server on AWS EC2 (Step-by-Step with User Data)

Ved Dandotia — Fri, 24 Jul 2026 08:04:44 +0000

🚀 Launch Your First Amazon EC2 Instance to Host a Web Server

If you're starting your cloud journey with AWS, Amazon EC2 (Elastic Compute Cloud) is one of the first services you'll work with. It allows you to launch virtual machines in the cloud and host applications with complete control over the operating system, networking, and storage.

In this tutorial, you'll learn how to launch an EC2 instance, configure its networking, automatically install an Apache web server using EC2 User Data, and verify that your website is accessible from anywhere on the internet.

By the end of this guide, you'll have your own web server running on AWS. 🚀

📚 What You'll Learn

Launch an Amazon EC2 instance
Configure a Security Group
Use EC2 User Data to automate server setup
Deploy an Apache web server
Verify the deployment
Clean up AWS resources

🏗️ Architecture

Deployment Flow

Internet
    │
    ▼
Security Group
(SSH :22 | HTTP :80)
    │
    ▼
Amazon EC2 Instance
(Apache Web Server)
    │
    ▼
Static HTML Page

✅ Prerequisites

Before starting, make sure you have:

An AWS Account (Free Tier eligible)
Basic knowledge of the AWS Console
An SSH client
- Windows: PowerShell, Windows Terminal, or PuTTY
- macOS/Linux: Terminal

Step 1 — Launch an EC2 Instance

Open the AWS Management Console.
Navigate to EC2.
Click Launch Instance.
Enter an instance name (for example, demoEC2).
Choose the Amazon Linux 2 AMI.
Select t3.micro as the instance type.
Create or select an existing Key Pair.
Under Network Settings, configure the Security Group.

Configure Inbound Rules

Type	Port	Source
SSH	22	My IP (Recommended)
HTTP	80	0.0.0.0/0

AWS automatically creates a Security Group (for example, launch-wizard-2).

📷 Add a screenshot of the Launch Instance page here.

Step 2 — Configure User Data

Instead of manually connecting to the server and installing software, we'll use User Data. The script below runs automatically the first time the EC2 instance boots.

Navigate to:

Advanced Details → User Data

Paste the following script.

#!/bin/bash

# Update packages
yum update -y

# Install Apache
yum install -y httpd

# Start Apache
systemctl start httpd

# Enable Apache after reboot
systemctl enable httpd

# Create sample webpage
echo "<h1>Hello World from EC2 User Data!</h1>" > /var/www/html/index.html

What does this script do?

Updates installed packages
Installs Apache HTTP Server
Starts the Apache service
Enables Apache to start automatically after every reboot
Creates a sample HTML page

Once the instance finishes booting, the web server is ready without any manual setup.

📷 Add a screenshot of the User Data section here.

Step 3 — Launch the Instance

Click Launch Instance.

Within a minute, the instance state should become Running.

Take note of:

Public IPv4 Address
Public DNS

Example:

ec2-xx-xx-xx-xx.ap-south-1.compute.amazonaws.com

📷 Add a screenshot of the EC2 Instance Summary here.

Step 4 — Verify the Security Group

Open your instance and navigate to:

Security → Security Groups → Inbound Rules

Verify that the following rules exist.

Type	Port	Source
SSH	22	Your Public IP
HTTP	80	0.0.0.0/0

The default outbound rule (Allow All Traffic) is sufficient for this tutorial.

⚠️ Security Best Practice

Avoid exposing SSH (Port 22) to the entire internet in production. Restrict it to your public IP whenever possible.

📷 Add a screenshot of the Security Group rules here.

Step 5 — Test the Web Server

Open your browser and visit either:

http://<your-public-ip>

http://<your-public-dns>

If everything is configured correctly, you'll see:

Hello World from EC2 User Data!

📷 Add a screenshot showing the webpage in your browser.

Step 6 — (Optional) Connect Using SSH

Connect to your EC2 instance:

ssh -i your-key.pem ec2-user@<your-public-ip>

Verify Apache is running.

sudo systemctl status httpd

Expected output:

Active: active (running)

🧹 Cleanup

To avoid unwanted AWS charges:

Open the EC2 Console.
Select your instance.
Click Instance State.
Choose Terminate Instance.

🎯 Conclusion

Congratulations! 🎉

You successfully:

✅ Launched an Amazon EC2 instance
✅ Configured a Security Group
✅ Automated server setup using EC2 User Data
✅ Installed and configured Apache
✅ Hosted your first web page on AWS
✅ Accessed it using a public IP address

Learning EC2 is a major milestone in your AWS journey. From here, you can explore more advanced services such as:

Elastic Load Balancer (ELB)
Auto Scaling
Amazon RDS
Route 53
Elastic Beanstalk
Amazon ECS
AWS CloudFormation

💬 Final Thoughts

This is one of the simplest yet most important AWS projects for beginners. It introduces you to compute, networking, security, and automation—all fundamental cloud concepts.

If you found this tutorial helpful, leave a ❤️, share it with others learning AWS, and let me know what AWS service you'd like to explore next.

Happy Cloud Learning! ☁️🚀

Tags: #aws #cloud #ec2 #devops #beginners

Modified Binary Search

Ved Dandotia — Thu, 23 Oct 2025 11:19:12 +0000

1). Simple Search in Sorted Array (Easy)

_Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums. If target exists, then return its index. Otherwise, return -1._

[(https://leetcode.com/problems/binary-search?envType=problem-list-v2&envId=binary-search)]

This is the basic and easiest form of binary search algorithm which is used to search an particular element in an array, Binary search is an alternative of Linear Search to reduce the time complexity of searching algorithm, It is the most optimized searching algorithm till now in DSA.

Pattern: Try to search the element in 7 or less tries.

Note: Binary Search are not only bound to use with array, It can be implemented in Sorted array, array divided into two sorted array or in sorted input space.

Algorithm:

1). Set Zeroth index as Low & Last index as High.
Low = arr[0] & High = arr[n-1]

2).Find mid i.e middle index of High and Low.
mid = (low+high)/2
But
mid = low+(high-low)/2 is advised to use to avoid the integer overflow.

3). While low<=high -
Compare the arr[mid] element with target.

if arr[mid]==target
return mid
else if (arr[mid]<target)
low = mid+1
else
high = mid-1

4). If target is not in the array then low will become greater than high, thus loop will break
return -1

Code:

int search(int* nums, int numsSize, int target) {


    int low = 0;
    int high =numsSize-1;

    while(low<=high){
         int mid = (low+high)/2;

        if(nums[mid]==target){
            return mid;
        }
        else if(nums[mid]>target){
            high = mid-1;
        }
        else {
            low=mid+1;
        }

    }
    return -1;
}

Example 1:
Input: nums = [-1,0,3,5,9,12], target = 9
Output: 4
Explanation: 9 exists in nums and its index is 4

2). Search Insert Position (Easy)

Given a sorted array of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order._

Example:
Input: arr = [1,3,5,6], target = 2
Output: 1
Explanation: target is not present in the array and it is best fitted at 1st Index so Output is 1.

[https://leetcode.com/problems/search-insert-position?envType=problem-list-v2&envId=binary-search]

This Problem is an Modified version of binary search in which a little modification in the binary search algorithm is needed in order to solve this problem. This problem is asking to return the index of target element if present in the array else, If target is not present in array then return the position index where the target should be best fitted in the array.

Modification:

In order to return the index where the target element should be present if it was in the array then we have to return low in last when the loop breaks i.e whenlow<=highfails then the low will be the index where the target should be inserted in the array.

Why to return low? Why not high?

When the loop ends the condition becomes low = high+1 -
So now:

All elements before low are less than target
All elements after or equal to low are greater than target

💡 In other words:

low is exactly the index where target should be inserted.

Algorithm:

1). Set Zeroth index as Low & Last index as High.
Low = arr[0] & High = arr[n-1]

2).Find mid i.e middle index of High and Low.
mid = (low+high)/2
But
mid = low+(high-low)/2 is advised to use to avoid the integer overflow.

3). While low<=high -
Compare the arr[mid] element with target.

if arr[mid]==target
return mid
else if (arr[mid]<target)
low = mid+1
else
high = mid-1

4). If target is not in the array then low will become greater than high, thus loop will break
return low

Code:

int searchInsert(int* nums, int numsSize, int target) {
    int low=0; int high=numsSize-1;

    while(low<=high){
        int mid = (low+high)/2;

        if(nums[mid]==target){
            return mid;
        }

        else if(nums[mid]>target){
            high = mid - 1;
        }

        else{
            low = mid + 1;
        }
    }

    return low;

}

1). First and last Position of element in sorted array (Medium)

Given an array of integers nums sorted in non-decreasing order, find the starting and ending position of a given target value. If target is not found in the array, return [-1, -1].

Example:
Input: nums = [5,7,7,8,8,10], target = 8
Output: [3,4]
Explanation: target 8 is first found at index 3 and then at index 4. So, [3,4]

[https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array]

This problem also requires some modification in binary search algorithm in order to solve this problem, In this question we just need to return the index of target element when it is occurred first time and then the last time.

Modification -

In this type of problem we just need to use binary search two times at once. The first binary search will return the index of target at which target is first occurred and second binary search will give return the index of second occurrence.

Algorithm:

0). Initialize an array of size 2 and set as arr=[-1,-1].

For First Occurrence....
1). Set Zeroth index as Low & Last index as High.
Low = arr[0] & High = arr[n-1]
2).Find mid i.e middle index of High and Low.
mid = (low+high)/2
But
mid = low+(high-low)/2 is advised to use to avoid the integer overflow.
3). While low<=high -
Compare the arr[mid] element with target.

if arr[mid]==target { set arr[0]=mid; // assume the index as first occurrence and high = mid-1; // Check more in left side if target is present there }

else if (arr[mid]<target) low = mid+1

else high = mid-1

For Second Occurrence....
1). Set Zeroth index as Low & Last index as High.
Low = arr[0] & High = arr[n-1]
2).Find mid i.e middle index of High and Low.
mid = (low+high)/2
But
mid = low+(high-low)/2 is advised to use to avoid the integer overflow.
3). While low<=high -
Compare the arr[mid] element with target.

if arr[mid]==target { set arr[1]=mid; // assume the index as second occurrence and low = mid+1; // Check more in right side if target is present there }

else if (arr[mid]<target) low = mid+1

else high = mid-1

4). If target is not in the array then low will become greater than high, thus loop will break
return arr

Code:

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {

        vector<int> arr = {-1,-1};
        int n =nums.size();
        if(n==0)
        return arr;

        int low =0;
        int high = n-1;

        while(low<=high){
            int mid = (high+low)/2;

            if(nums[mid]==target){
            arr[0]=mid;
            high = mid-1;
        }

           else if(nums[mid]>target)
            high = mid-1;

            else
            low=mid+1;


        }

         low=0;
         high = n-1; 
         while(low<=high){
            int mid = (high+low)/2;

            if(nums[mid]==target){
            arr[1]=mid;
            low = mid+1;
            }


           else if(nums[mid]>target)
            high = mid-1;

            else
            low=mid+1;


        }
        return arr;
    }
};