Forem: irfan pasha

🚀 How I Built & Deployed a Real DevOps Project from Scratch (AWS GitHub Netlify)

irfan pasha — Sun, 08 Feb 2026 20:47:15 +0000

🚀 How I Built & Deployed a Real DevOps Project from Scratch (AWS → GitHub → Netlify)

A few weeks ago, I decided to stop only learning DevOps theory and finally build a real end-to-end project.

Not a tutorial project.
Not a local demo.
A real cloud → CI/CD → live website pipeline.

Today, my app is live on the internet 🌍 and this is the full story.

🎯 The Challenge I Gave Myself

I wanted to simulate how real companies work.

Instead of:
“Build React app → run locally”

I wanted:
Developer → Cloud → GitHub → CI/CD → Production

So I set a goal:

Build a React application using AWS infrastructure and deploy it with an automated pipeline.

☁️ Step 1 — Building My Own AWS Cloud Environment

Before writing any code, I created real AWS networking.

This was my first time building infrastructure from scratch.

I created:

• Custom VPC (10.0.0.0/16)
• Public Subnet (10.0.1.0/24)
• Internet Gateway
• Route Table with public internet route
• Security Group (SSH + HTTP access)

Finally, I launched an Ubuntu EC2 instance inside this VPC.

At this point I had my own mini cloud environment 😄
This is the moment DevOps stopped being theory and started feeling real.

💻 Step 2 — Developing Inside the Cloud (EC2)

Instead of coding locally, I connected to EC2 using SSH and turned it into my development machine.

I installed:

NodeJS
Git
NPM

Then I created a React application directly on the server.

Yes… I was literally coding inside AWS ☁️

🎮 Step 3 — Building a Real React Application

I didn’t want a simple “Hello World”.

So I built a KBC-style AWS Quiz App.

Features I added

🔐 Login page (demo credentials)
⏱ Timer per question
📊 Progress bar
🏆 Score tracking
🌙 Dark / Light theme toggle
💾 High score saved in browser
🔀 Questions shuffle every session
🔄 Restart quiz functionality

At this point, the project started feeling like a real product.

🐙 Step 4 — Turning It Into a Professional GitHub Project

Next, I moved the project to GitHub.

This step taught me a lot:

• Initialized Git repo on EC2
• Created GitHub repository
• Generated Personal Access Token
• Pushed project securely
• Wrote a professional README
• Added architecture diagrams
• Added LICENSE & screenshots folder

My repository finally looked like a real developer project.

🔄 Step 5 — Creating a CI/CD Pipeline with Netlify

This was the most exciting step.

I connected my GitHub repo to Netlify.

Now every time I push code:

1️⃣ Dependencies install automatically
2️⃣ React app builds automatically
3️⃣ Site deploys automatically
4️⃣ Website goes live 🌍

No manual hosting.
No manual uploads.
Real CI/CD pipeline.

This moment felt amazing.

🌍 The Final Result

My application is now live and accessible worldwide.

From zero → AWS → CI/CD → Production 🚀

👉 Live Demo
https://6988f216c9b850f7db01d08b--tiny-begonia-c0a233.netlify.app/

🏗️ Architecture Overview

DevOps Pipeline

Developer → AWS EC2 → GitHub → Netlify → Users

AWS Infrastructure

VPC → Public Subnet → EC2 → Internet Gateway

This simple architecture helped me understand the real deployment flow.

💡 What This Project Taught Me

This project changed how I see DevOps.

I learned:

• How AWS networking works
• How to develop inside EC2
• How GitHub authentication works
• How CI/CD pipelines deploy apps
• How frontend apps go live globally

Most importantly:

👉 DevOps is best learned by building real projects.

🚀 What’s Next?

Next upgrades I plan:

• Custom domain setup
• Backend API on AWS
• Database integration
• Full-stack deployment pipeline

This is just the beginning.

GitHub: https://github.com/IrfanPasha05
If you’re starting DevOps, my advice:

Stop waiting. Start building.

Hands-on projects teach more than any course ever will 💯

AWS Enterprise Production Architecture – End-to-End DevOps Project

irfan pasha — Wed, 04 Feb 2026 23:57:50 +0000

🚀 AWS Enterprise Production Architecture – Real DevOps Project

Today I built a real production-style AWS architecture from scratch and pushed the complete project to GitHub.

This project demonstrates how real companies host scalable, highly available applications on AWS.

🌍 Architecture Overview

✔ Highly Available
✔ Auto Scaling
✔ Self Healing Infrastructure
✔ Monitoring + Auditing
✔ Production Ready Design

🧩 Architecture Diagram

👉 GitHub Repo:
https://github.com/IrfanPasha05/aws-enterprise-web-architecture

🏗️ Services Used
Layer AWS Service
Compute EC2
Networking VPC + Subnets
Load Balancing Application Load Balancer
Scaling Auto Scaling Group
Monitoring CloudWatch
Auditing CloudTrail
⚙️ Step 1 — Custom VPC Setup

Created custom VPC:

CIDR: 10.0.0.0/16

Subnets:

Public Subnet 1 → 10.0.1.0/24
Public Subnet 2 → 10.0.3.0/24
Private Subnet → 10.0.2.0/24

Attached:

Internet Gateway

Public Route Table

💻 Step 2 — Launch EC2 Web Server

Installed Apache:

sudo yum update -y
sudo yum install httpd -y
sudo systemctl start httpd
sudo systemctl enable httpd
echo "

My AWS Production Server

" | sudo tee /var/www/html/index.html

Created Golden AMI from this server.

⚖️ Step 3 — Application Load Balancer

Created:

Target Group

Registered EC2 instances

Listener → HTTP : 80

Result → Load balanced traffic across servers.

🔁 Step 4 — Auto Scaling Group (Self Healing)

Configured Auto Scaling:

Min = 1
Desired = 2
Max = 3

Tested by terminating instances manually.

AWS automatically launched new server 🤯

Self-healing infrastructure achieved.

📊 Step 5 — CloudWatch Monitoring

Created alarms on:

CPU Utilization < 49%

Auto Scaling reacts to traffic automatically.

🔐 Step 6 — CloudTrail Auditing

Enabled CloudTrail to track:

Instance termination

API calls

Security events

Verified logs after terminating servers ✔

🧪 Real Test Performed

I manually terminated all EC2 instances.

Result:

Auto Scaling → Launched new server automatically
CloudTrail → Logged termination event
CloudWatch → Triggered alarm

🎉 Production architecture working perfectly.

📂 GitHub Project

Full implementation + scripts available here:

👉 https://github.com/IrfanPasha05/aws-enterprise-web-architecture

❤️ What I Learned

This project helped me understand:

Real world AWS architecture

High availability design

Auto healing systems

Monitoring & auditing in cloud

DevOps workflow with Git

🚀 Final Thoughts

This is a beginner-friendly enterprise architecture project that every aspiring DevOps / Cloud Engineer should build.

If you're learning AWS — try building this yourself!

📢 Connect With Me

If you liked this project, connect with me on GitHub 👇
⭐ Star the repo if it helped you.

🚀AWS Lambda S3 File Upload Logger using Python

irfan pasha — Sun, 01 Feb 2026 16:50:18 +0000

🚀 Project Overview

In this project, I implemented an AWS Lambda function using Python that automatically logs file upload details whenever a file is uploaded to an Amazon S3 bucket.

This project demonstrates real-time event-driven architecture using AWS services.

🧱 Architecture

Flow:

File uploaded to S3 bucket
S3 triggers AWS Lambda
Lambda extracts file details
Logs stored in CloudWatch

Services Used:

Amazon S3
AWS Lambda (Python)
Amazon CloudWatch

🐍 Lambda Function Code (Python)


python
def lambda_handler(event, context):
    record = event['Records'][0]
    bucket_name = record['s3']['bucket']['name']
    file_name = record['s3']['object']['key']
    file_size = record['s3']['object']['size']

    print(f"Bucket Name: {bucket_name}")
    print(f"File Name: {file_name}")
    print(f"File Size: {file_size} bytes")

📊 CloudWatch Logs Output

After uploading a file to the S3 bucket, the Lambda function logged:

Bucket Name

File Name

File Size

This confirms the function executed successfully.


https://github.com/IrfanPasha05/s3-file-upload-logger

🚀 AWS ALB Auto Scaling with CloudWatch – Real-World Architecture (Hands-On Project)

irfan pasha — Thu, 22 Jan 2026 20:08:37 +0000

In this article, I’m sharing a real-time AWS hands-on project where I designed and implemented a highly available, auto-scaling web architecture using core AWS services.

This project helped me understand how AWS components work together in a production-style environment, not just theory.

📌 Project Objective

The goal of this project was to:

Host a web application securely on AWS

Distribute traffic using Application Load Balancer

Automatically scale EC2 instances based on load

Monitor infrastructure using CloudWatch

Follow AWS best practices for networking and security

🧱 AWS Services Used

Amazon VPC

Public Subnets (Multi-AZ)

Internet Gateway

Route Tables

Security Groups

EC2 Instances

Application Load Balancer (ALB)

Target Groups

Auto Scaling Group (ASG)

Amazon CloudWatch

🏗️ Architecture Overview

The architecture follows a classic real-world AWS design:

A custom VPC

Two public subnets in different Availability Zones

An internet-facing ALB

Auto Scaling Group behind the ALB

CloudWatch alarms to scale instances automatically

This ensures:

High availability

Fault tolerance

Automatic scaling

Secure access

🪜 Step-by-Step Implementation
1️⃣ Create Custom VPC

Created a custom VPC with IPv4 CIDR block

Enabled DNS resolution & DNS hostnames

✔ Foundation network for the project

2️⃣ Create Public Subnets (Multi-AZ)

Created two public subnets

Each subnet placed in a different Availability Zone

✔ Ensures high availability

3️⃣ Create and Attach Internet Gateway

Created an Internet Gateway (IGW)

Attached it to the VPC

✔ Enables internet access

4️⃣ Configure Route Table

Created a route table

Added route 0.0.0.0/0 → Internet Gateway

Associated route table with public subnets

✔ Enables outbound internet traffic

5️⃣ Create Security Groups

ALB Security Group

Allow HTTP (80) from anywhere

EC2 Security Group

Allow HTTP (80) from ALB

Allow SSH (22) from my IP only

✔ Follows security best practices

6️⃣ Launch EC2 Using Launch Template

Created a launch template

Added User Data to install and start web server automatically

Web page shows instance details

✔ Enables automated instance creation

7️⃣ Create Target Group

Target type: EC2

Protocol: HTTP (80)

Health checks enabled

✔ Ensures only healthy instances receive traffic

8️⃣ Create Application Load Balancer (ALB)

Internet-facing ALB

Associated with public subnets

Listener on port 80

Forward traffic to target group

✔ Distributes traffic evenly

9️⃣ Create Auto Scaling Group (ASG)

Attached launch template

Attached ALB target group

Set:

Min capacity

Desired capacity

Max capacity

✔ Automatically manages EC2 instances

🔟 Configure CloudWatch Alarms

Created CloudWatch alarms based on CPU Utilization

Scale-out when CPU increases

Scale-in when CPU decreases

✔ Fully automated scaling

📊 Monitoring & Testing

Verified EC2 instances were healthy

Checked CloudWatch metrics

Accessed application via ALB DNS name

Confirmed traffic distribution

✔ Architecture worked as expected

📸 Screenshots (Proof of Work)

Screenshots include:

VPC & Subnets

Route Tables & IGW

Security Groups

ALB & Target Groups

Auto Scaling Group

CloudWatch Alarms

Final browser output

✔ 100% real AWS console screenshots

✅ Key Learnings

Through this project, I learned:

How AWS networking works in real environments

Designing scalable and fault-tolerant systems

Using ALB with Auto Scaling Groups

Monitoring and automation using CloudWatch

Following AWS security best practices

🧠 Why This Is a Real-World Project

This is not a demo or lab-only project.

It reflects:

Enterprise-style AWS architecture

Production-ready concepts

Hands-on implementation from scratch

🔗 GitHub Repository

📂 Full project with screenshots & documentation:
👉 GitHub: https://github.com/IrfanPasha05/aws-alb-autoscaling-cloudwatch-architecture

🎯 Final Thoughts

This project boosted my confidence in AWS core services and helped me understand how scalable architectures are built in real organizations.

If you’re learning AWS or preparing for cloud roles, I highly recommend implementing this architecture hands-on.

🙌 Thanks for Reading!

If you found this helpful:

❤️ Like

💬 Comment

🔁 Share

Happy Learning ☁️🚀

🚀 Deploying a Highly Available Web Application on AWS using ALB & Auto Scaling (Beginner-Friendly)

irfan pasha — Mon, 19 Jan 2026 23:51:04 +0000

👋 Introduction

In this hands-on project, I built a production-ready AWS architecture using core services like VPC, Application Load Balancer, Auto Scaling Group, EC2, and NAT Gateway.

This setup follows AWS best practices:

Secure networking

High availability

Automatic scaling

Zero public access to EC2 instances

This guide is beginner-friendly, yet interview-ready.

🧠 What You Will Learn

✅ How to design a secure AWS VPC
✅ Public vs Private Subnets (real use-case)
✅ Application Load Balancer (ALB)
✅ Auto Scaling Group (ASG)
✅ NAT Gateway for outbound internet
✅ Real-world architecture used in companies

🏗️ Architecture Overview
Internet
|
▼
Application Load Balancer (Public Subnets)
|
▼
Target Group
|
▼
Auto Scaling Group
(EC2 Instances in Private Subnets)
|
▼
NAT Gateway → Internet (Outbound Only)

🔒 EC2 instances have NO public IPs
🌐 Only ALB is exposed to the internet

🛠️ Services Used

Amazon VPC

EC2 (Ubuntu)

Application Load Balancer

Auto Scaling Group

Target Groups

NAT Gateway

Elastic IP

Security Groups

🚦 Step-by-Step Implementation
1️⃣ Create a Custom VPC

CIDR: 10.0.0.0/16

Enable:

DNS Hostnames

DNS Resolution

2️⃣ Create Subnets

Create 4 subnets:

Public Subnets

Public-Subnet-1 (ALB)

Public-Subnet-2 (NAT Gateway)

Private Subnets

Private-Subnet-1 (EC2)

Private-Subnet-2 (EC2)

⚠️ Enable Auto-assign Public IP = YES only for public subnets

3️⃣ Internet Gateway

Create and attach an Internet Gateway to the VPC

Required for ALB and NAT Gateway

4️⃣ NAT Gateway (CRITICAL)

Create NAT Gateway in public subnet

Attach Elastic IP

Allows private EC2 to access internet securely

5️⃣ Route Tables

Public Route Table

0.0.0.0/0 → Internet Gateway

Private Route Table

0.0.0.0/0 → NAT Gateway

Associate correctly with subnets.

6️⃣ Security Groups
🔹 ALB Security Group

HTTP (80) → 0.0.0.0/0

🔹 EC2 Security Group

HTTP (80) → ALB Security Group

SSH (22) → Your IP (optional)

🔐 EC2 is accessible only via ALB

7️⃣ Launch Template (EC2)

AMI: Ubuntu 22.04
Instance Type: t2.micro

🧾 User Data Script

!/bin/bash

apt update -y
apt install apache2 -y
systemctl start apache2
systemctl enable apache2

echo "

Welcome from ALB + Auto Scaling

Hostname: $(hostname)

" > /var/www/html/index.html

8️⃣ Target Group

Target Type: Instance

Protocol: HTTP

Port: 80

Health Check Path: /

9️⃣ Application Load Balancer

Type: Internet-facing

Subnets: Public Subnets

Listener: HTTP 80

Forward to Target Group

🔟 Auto Scaling Group

Use Launch Template

Subnets: Private Subnets

Desired: 2

Min: 1

Max: 3

Attach to ALB Target Group

📈 Optional: CPU-based scaling policy

✅ Final Verification

Copy ALB DNS name

Paste into browser

Refresh multiple times

🎉 You will see different hostnames
This confirms:

Load balancing

Auto scaling

High availability

📂 GitHub Repository

🔗 Project Source Code & Documentation
👉 https://github.com/IrfanPasha05/aws-alb-autoscaling-project

Includes:

Folder structure

User-data scripts

Setup steps

Troubleshooting guide

🎯 Why This Project Matters

This architecture is used in:

Real production environments

Enterprise applications

DevOps & Cloud Engineer roles

Perfect for:

Resume

Interviews

Portfolio

LinkedIn & DEV

🧩 Future Enhancements

HTTPS with ACM

Custom domain (Route 53)

CloudFront CDN

Monitoring with CloudWatch

🙌 Final Thoughts

This project strengthened my understanding of AWS networking, security, and scalability. If you’re learning AWS or preparing for cloud roles — build this once, and you’ll remember it forever.

Happy Clouding ☁️🚀

AWS VPC Project: Secure Website Hosting with Public & Private EC2

irfan pasha — Thu, 15 Jan 2026 00:39:28 +0000

In this project, I built a real-world AWS VPC architecture from scratch using public and private subnets. I hosted a live website on a public Ubuntu EC2 instance and securely accessed a private EC2 instance using a bastion host. The private instance had outbound internet access via a NAT Gateway while remaining inaccessible from the internet.

This project helped me deeply understand VPC networking, route tables, security groups, Internet Gateways, and NAT Gateways in a practical way.

This repository documents a complete, hands-on AWS VPC project built from scratch and tested end-to-end. The project demonstrates real-world networking, security best practices, and production-style architecture using Ubuntu EC2 instances.

📌 Project Overview

In this project, we:

Created a custom VPC

Designed public and private subnets

Configured Internet Gateway & NAT Gateway

Launched two Ubuntu EC2 instances

Public EC2 → Website + Bastion Host

Private EC2 → Secure backend server

Hosted a live website on the public EC2

Verified private EC2 internet access via NAT Gateway

Amazon VPC

EC2 (Ubuntu 22.04 LTS)

Internet Gateway (IGW)

NAT Gateway

Route Tables

Security Groups

Elastic IP

🧱 STEP-BY-STEP IMPLEMENTATION
✅ Step 1: Create Custom VPC

Name: Demo-custom-vpc

CIDR Block: 10.0.0.0/16

✅ Step 2: Create Subnets
Public Subnet

Name: Public-subnet

CIDR: 10.0.1.0/24

AZ: us-east-1a

Private Subnet

Name: Private-subnet

CIDR: 10.0.2.0/24

AZ: us-east-1b

✅ Step 3: Create and Attach Internet Gateway

Name: Demo-igw

Attach to Demo-custom-vpc

✅ Step 4: Create NAT Gateway

Subnet: Public-subnet

Allocate Elastic IP

Name: Demo-nat

✅ Step 5: Configure Route Tables
Public Route Table (Public-RT)

Routes:

10.0.0.0/16 → local
0.0.0.0/0 → Internet Gateway

Associate with:

Public-subnet

Private Route Table (Private-RT)

Routes:

10.0.0.0/16 → local
0.0.0.0/0 → NAT Gateway

Associate with:

Private-subnet

✅ Step 6: Configure Security Groups
Web-SG (Public EC2)

SSH (22) → My IP

HTTP (80) → 0.0.0.0/0

Private-SG (Private EC2)

SSH (22) → Source: Web-SG

🚀 Step 7: Launch EC2 Instances
Public EC2 (Web Server)

AMI: Ubuntu 22.04 LTS

Subnet: Public-subnet

Auto-assign Public IP: Enabled

Security Group: Web-SG

Private EC2 (Backend Server)

AMI: Ubuntu 22.04 LTS

Subnet: Private-subnet

Auto-assign Public IP: Disabled

Security Group: Private-SG

🌐 Step 8: Host Website on Public EC2
sudo apt update -y
sudo apt install apache2 -y
sudo systemctl start apache2
sudo systemctl enable apache2

Create a simple webpage:

cd /var/www/html
sudo nano index.html

AWS VPC Project

Website hosted on Ubuntu EC2 in a Public Subnet

Access in browser:

http://
🔐 Step 9: Bastion Host Access (Best Practice)

Copy key from local → Public EC2 using scp

SSH into Public EC2

From Public EC2, SSH into Private EC2 using private IP

ssh -i demo-key.pem ubuntu@10.0.2.128
🌍 Step 10: Verify NAT Gateway

From Private EC2:

ping google.com

✅ Confirms outbound internet access via NAT Gateway

🎯 Final Outcome

Public website accessible from internet

Private EC2 fully isolated

Secure access using Bastion Host

Enterprise-grade AWS VPC architecture

Github--https://github.com/IrfanPasha05/aws-vpc-public-private-ec2/blob/main/README.md

🚀 Hosting a Static Portfolio Website on AWS S3 using IAM (Beginner Project)

irfan pasha — Tue, 13 Jan 2026 20:55:53 +0000

As part of my AWS learning journey, I built and deployed a static portfolio website using Amazon S3 and secured access using IAM best practices.
This project helped me understand S3 static hosting, bucket policies, IAM permissions, and real-world troubleshooting.

In this article, I’ll walk you through every step I followed, from scratch to a working live website.

🧠 What You Will Learn

What static website hosting is

How to host a website using Amazon S3

How IAM permissions affect S3 access

How to troubleshoot Access Denied errors

How to apply least-privilege IAM access

🛠️ Technologies Used

Amazon S3

AWS IAM

HTML & CSS

Git & GitHub

AWS Console

📁 Project Overview

The goal was to host a simple portfolio website containing:

Profile section

About me

Project details

The site is publicly accessible using an S3 static website endpoint.

🧱 Step 1: Create an S3 Bucket

Go to AWS Console → S3

Click Create bucket

Provide:

Bucket name (must be globally unique)

Region (I used us-east-1)

Uncheck Block all public access

Acknowledge the warning

Click Create bucket

🌐 Step 2: Enable Static Website Hosting

Open the bucket

Go to Properties

Scroll to Static website hosting

Enable it

Set:

Index document: index.html

Save changes

You will get a website endpoint URL — keep this.

📄 Step 3: Upload Website Files

I created a simple index.html file containing HTML and CSS for my portfolio.

Folder structure:

aws-s3-static-portfolio/
│── index.html
│── assets/
│ └── profile.png

Upload all files to the S3 bucket.

🔐 Step 4: Fix Access Denied (Bucket Policy)

Initially, I got this error:

AccessDenied

To fix this, I added a bucket policy to allow public read access.

✅ Bucket Policy Used
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "PublicReadAccess",
"Effect": "Allow",
"Principal": "",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::your-bucket-name/"
}
]
}

After saving this, the website loaded successfully 🎉

👤 Step 5: IAM User with Least Privilege

To follow security best practices, I created a dedicated IAM user.

IAM Steps:

Go to IAM → Users

Create a new user

Enable AWS Management Console access

Attach AmazonS3ReadOnlyAccess

🔴 Initially, I couldn’t see buckets due to missing permission:

s3:ListAllMyBuckets

After attaching the correct policy, it worked perfectly.

🧪 Step 6: Verification

Website opened successfully via S3 endpoint

IAM user could access only S3

Images loaded correctly from assets/ folder

🌍 Final Output

✅ Live static website
✅ Secure IAM permissions
✅ Public read-only S3 access

This project gave me hands-on experience with real AWS troubleshooting, not just theory.

📌 Key Learnings

S3 is case-sensitive (important for images)

IAM permissions directly impact service visibility

Bucket policies override ACLs

Least privilege is critical for security

🔗 GitHub Repository

👉 (Add your GitHub repo link here)

🏁 Conclusion

This was a beginner-friendly but very practical AWS project.
It helped me understand how AWS services connect in real scenarios.

If you’re learning AWS, I highly recommend trying this project yourself 🚀

GitHub--https://github.com/IrfanPasha05/aws-s3-static-portfolio/tree/main

🙌 Thanks for reading!

Feel free to connect or suggest improvements.

Hosting a Static Website on Amazon S3 (Step-by-Step)

irfan pasha — Mon, 12 Jan 2026 09:51:08 +0000

Hosting a static website using Amazon S3 is a simple and effective way to make static content publicly available without managing servers. In this article, I’m sharing the exact steps I followed to host my static website using Amazon S3.

Project Overview

This project demonstrates hosting a static website using Amazon S3 Static Website Hosting. The website contains static HTML and image files and is publicly accessible through an S3 website endpoint.

Steps I Followed
Step 1: Create an S3 Bucket

I logged in to the AWS Management Console, opened the Amazon S3 service, and created a new S3 bucket with a unique name in the us-east-1 region.

Step 2: Upload Website Files

After creating the bucket, I opened it and uploaded the static website files, including:

index.html

Image files

Step 3: Enable Static Website Hosting

From the Properties tab of the S3 bucket, I enabled Static website hosting, configured index.html as the index document, and saved the changes.

Step 4: Allow Public Access

I navigated to the Permissions tab and disabled Block all public access, acknowledging the warning to allow public access.

Step 5: Configure Bucket Policy

I added a bucket policy to allow public read access by granting the s3:GetObject permission so that users can view the website files.

Step 6: Verify Website Access

I copied the Static website endpoint from the bucket properties and opened it in a web browser to confirm the website loaded successfully.

Live Website URL
http://irfanpasha1234.s3-website-us-east-1.amazonaws.com

Conclusion

By following these steps, I successfully hosted a static website on Amazon S3. This approach is simple, cost-effective, and ideal for hosting static content such as portfolios and basic websites.

My Journey into AWS & DevOps: Getting Started with Hands-On Learning

irfan pasha — Sun, 11 Jan 2026 15:11:20 +0000

👋 Introduction

Hi everyone! I’m Irfan, an AWS & DevOps beginner from India.

I recently started my cloud journey and decided to learn through hands-on projects rather than just theory.

☁️ Why AWS & DevOps?

I chose AWS and DevOps because:

Cloud skills are in high demand
DevOps focuses on automation and real-world problem solving
AWS provides a strong ecosystem to build and deploy projects

🛠️ What I’m Learning Right Now

Currently, I’m learning:

AWS basics (EC2, S3, IAM, VPC)
Linux fundamentals
Git & GitHub
Basic networking concepts

I’m also working on small practical projects like hosting static websites and deploying applications on AWS.

🎯 My Goal

My goal is to become a cloud/DevOps engineer by building real projects, documenting my learning, and sharing knowledge with the community.

🤝 Let’s Connect

I’ll be sharing:

AWS hands-on projects
DevOps learning notes
Troubleshooting experiences

If you’re also learning AWS or DevOps, let’s connect and grow together 🚀

Hosting and Streaming a Video Using AWS S3 (Beginner Guide)

irfan pasha — Sun, 11 Jan 2026 14:24:19 +0000

🚀 Hosting and Streaming a Video Using AWS S3 (Step-by-Step Guide)

As part of my AWS learning journey, I built a simple project to host and stream a video using Amazon S3 and documented the entire process using Git and GitHub.
This article walks through every step — from S3 configuration to pushing the project to GitHub.

🧩 Project Overview

Goal:
Host a video on AWS S3 and play it in a web browser using HTML.

What I learned:

Configuring public access in S3
Writing an S3 bucket policy
Embedding an S3-hosted video in HTML
Using Git to version control a project
Pushing code to GitHub

🛠️ Tools & Technologies Used

AWS S3
HTML5
Git
GitHub
Git Bash (Windows)

📁 Step 1: Create a Project Workspace

To keep all my projects organized, I created a dedicated workspace:

C:\Users\ipasha5\Projects

Inside it, I created a project folder:

s3-video-hosting

☁️ Step 2: Upload Video to AWS S3

Created an S3 bucket (region: us-east-1)
Uploaded the video file
Disabled Block Public Access
Added the following bucket policy to allow public read access:

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

After this, the video was accessible via a browser URL.

🌐 Step 3: Create an HTML Page to Stream the Video

Inside the project folder, I created an index.html file:

<!DOCTYPE html>
<html>
<head>
    <title>AWS S3 Video Hosting</title>
</head>
<body>
    <h2>Video Hosted on AWS S3</h2>

    <video width="320" height="640" controls>
        <source src="https://familyoutingvideo.s3.us-east-1.amazonaws.com/VID-20260110-WA0000.mp4" type="video/mp4">
        Your browser does not support the video tag.
    </video>

</body>
</html>

Opening this file in a browser successfully played the video.

🗂️ Step 4: Initialize Git Repository

From inside the project folder, I initialized Git:

git init

I verified the files using:

git status

📌 Step 5: Add and Commit Files

I added all files and created the first commit:

git add .
git commit -m "Initial commit: AWS S3 video hosting"

🧑‍💻 Step 6: Push Project to GitHub

Created a new repository on GitHub:

   s3-video-hosting

Connected the local repository to GitHub:

   git branch -M main
   git remote add origin https://github.com/YOUR_USERNAME/s3-video-hosting.git
   git push -u origin main

Now the project is live on GitHub 🎉

📄 README.md Content

# AWS S3 Video Hosting

This project demonstrates how to host and stream a video using AWS S3.

## Features
- Public video hosting via S3
- HTML video playback
- GitHub version control

## Tools
- AWS S3
- HTML
- Git & GitHub

🧠 Key Learnings

Public access in S3 must be carefully configured
Git errors are often simple syntax issues
Organizing projects in a dedicated workspace avoids permission problems
Documentation is as important as implementation

🚀 Final Thoughts

This project helped me understand how AWS S3 can be used for simple content hosting and how GitHub can be used to document and showcase learning projects.

If you’re new to AWS or Git, this is a great beginner project to start with.