DEV Community: Oluwatobiloba Oludare

How I Containerized and Deployed a Dynamic Web Application on AWS using Docker & Amazon ECS (Fargate)

Oluwatobiloba Oludare — Wed, 25 Mar 2026 15:11:40 +0000

As part of my DevOps learning journey, I worked on a hands-on project where I containerized a dynamic web application and deployed it on AWS using Docker and Amazon ECS (Fargate).

This project helped me move from theory to real-world cloud implementation, covering networking, security, containerization, and deployment.

In this article, I will walk through the exact steps I took.

Project Overview

The goal was to:

Containerize a dynamic web application using Docker
Store the image in Amazon ECR
Deploy the container using Amazon ECS (Fargate)
Use an Application Load Balancer for traffic routing
Securely connect to an RDS MySQL database
Configure a production-like cloud environment

Architecture Overview

User → ALB → ECS (Fargate Containers) → RDS (MySQL Database)

Supporting services:

VPC (Networking)
Security Groups (Access control)
Secrets Manager (Credentials)
ECR (Container registry)
Route 53 (DNS)

Explanation:
The user’s browser sends a request to the domain name, which is resolved by Route 53. The request is routed to an Application Load Balancer in the public subnet. The load balancer forwards the request to ECS containers running in private subnets through a target group. The container processes the request and communicates with the RDS database if needed, then the response travels back through the load balancer to the user.

🔐 Step 1: Create a Secure VPC

I started by creating a custom VPC with:

Public subnets (for ALB)
Private subnets (for ECS tasks and RDS)

This ensures that sensitive resources are not exposed to the internet.

Step 2: Configure Security Groups

I implemented strict access control:

ALB Security Group
- Allow HTTP (80) and HTTPS (443) from the internet
Container Security Group
- Allow traffic only from ALB
RDS Security Group
- Allow MySQL (3306) only from:
- ECS containers
- Migration server
Migration Server (EC2)
- SSH access only via controlled security group

This setup ensures a secure, production-like environment.

Step 3: Set Up RDS MySQL Database

Created a DB subnet group using private subnets across multiple AZs
Launched a MySQL database (Free Tier)
Enabled auto-generated credentials
Attached the appropriate security group

I used MySQL because the application required structured data, relationships, and strong consistency. It works well with Amazon RDS and is easy to manage. The tradeoff is that it’s less flexible and harder to scale horizontally compared to NoSQL databases like MongoDB, so I would choose those alternatives for highly scalable or unstructured workloads.

Step 4: Store Credentials in AWS Secrets Manager

Instead of hardcoding credentials:

Stored database username & password securely
Created a named secret
Allowed access via IAM roles

This improves security and best practices.

Step 5: Data Migration Setup (EC2)

To migrate application data:

Launched an EC2 instance in a private subnet
Attached an IAM role with access to:
- Secrets Manager
- S3
Used user-data scripts to automate migration

⚙️ Step 6: Configure AWS CLI

Created an IAM user with required permissions
Generated access keys
Configured locally using:

aws configure

Step 7: GitHub Integration

Generated SSH key:

ssh-keygen -t ed25519

Added public key to GitHub
Created a private repository and uploaded application code
Generated a Personal Access Token (PAT) and stored it securely

🐳 Step 8: Dockerize the Application

Created a Dockerfile for the application
Structured project directory properly
Built Docker image
Pushed image to Amazon ECR

This step converts the app into a portable container.

🎯 Step 9: Create Target Group

Target type: IP
Configured health checks:
- HTTP codes: 200, 301, 302

Step 🔟: Create Application Load Balancer (ALB)

Internet-facing
Attached to public subnets
Configured:
- HTTP → HTTPS redirect
- HTTPS listener with SSL certificate
Linked to target group

Step 11: Create IAM Roles

Created multiple roles for:

ECS Task Execution
ECS Task Role (S3, Logs, Secrets access)
Load Balancer integration

This ensures least privilege access control.

Step 12: Create ECS Cluster (Fargate)

Launch type: Fargate (serverless)
Enabled Container Insights

Step 13: Create Task Definition

Linked to:
- ECR image
- Task role
- Execution role
Defined container configuration

Step 14: Deploy ECS Service

Used Fargate launch type
Deployed in private subnets
Disabled public IP
Attached ALB
Enabled auto-scaling:
- Min: 1
- Max: 2
- CPU target: 70%

Step 15: Configure Domain (Route 53)

Created DNS record
Mapped domain to ALB

Now the application is publicly accessible 🎉

Key Things I Learned

How to design a secure VPC architecture
Importance of security groups and IAM roles
How to containerize applications using Docker
Deploying containers using ECS Fargate
Using Secrets Manager for secure credential handling
Integrating multiple AWS services in a real project

Problem It Solved

This project addresses key challenges commonly found in traditional application deployments:

Lack of scalability → Applications fail under increased traffic
Single point of failure → Downtime when a server crashes
Security vulnerabilities → Public databases and hardcoded credentials
Manual infrastructure management → High operational overhead
Inconsistent environments→ Deployment failures across stages

❌ Challenges I Faced

Debugging security group rules between ECS and RDS
Handling Docker build and push errors
Configuring ALB listeners correctly

Each challenge improved my troubleshooting skills significantly.

What I Would Improve Next

Add CI/CD pipeline (GitHub Actions)
Use Terraform for Infrastructure as Code
Implement monitoring with CloudWatch & alerts
Introduce auto-scaling based on traffic

Final Thoughts

This project helped me transition from theory to real-world DevOps practice**. It gave me a deeper understanding of how cloud infrastructure, containers, and networking work together.

If you’re learning DevOps or AWS, I highly recommend building something like this — it changes everything.

👋 About Me

I’m currently transitioning into DevOps and sharing my learning journey publicly. Follow me for more hands-on cloud, Docker, and Kubernetes content.

How to Deploy a Dynamic Web Application on AWS (Beginner-Friendly Guide)

Oluwatobiloba Oludare — Sat, 21 Feb 2026 21:39:02 +0000

Deploying a dynamic web application on AWS can feel overwhelming at first especially with so many services involved. In this guide, I’ll walk through a simple, practical approach to deploying a dynamic web app using core AWS services.

This is perfect for beginners learning cloud computing and DevOps.

What is a Dynamic Web Application?

Unlike static websites, dynamic web applications:

Process user input
Connect to databases
Generate content in real time

Examples include: Login systems, Dashboards, E-commerce sites

Web apps built with PHP

AWS Services We’ll Use:

To deploy a dynamic web app, we typically need:
🔹 Compute: EC2 – Hosts the application server
🔹 Database: RDS – Stores application data
🔹 Networking & Security : VPC – Network environment and Security Groups
🔹 Storage: S3
🔹 Route 53
🔹 Application Load Balancer
🔹 Auto-scaling group

🪜 Step-by-Step Deployment

1. Select appropriate Region.

2. Create VPC and enable DNS hostname.

3. Create all these Security Groups:

-For ec2 instance connect endpoint (EICE) - No inbound rules- use ssh and limit it to vpc CIDR

-For application load balancer (alb-Sg) - select vpc - allow http & https for anywhere

-For Webserver security group (web-sg)- select vpc - allow http & https, limit to alb-sg - allow ssh, limit to eice.

-Security group to database (db-sg) -- select vpc - Allow MySQL, limit it to webserver-sg - again allow MySQL, limit it dm-sg.

-Security group for data migration (dms) - select vpc- allow ssh, limit it to eice.

4. Create instance connect endpoint in private subnet - select ec2 instance connect endpoint - select vpc - Use eice-sg - select private subnet -private-app-az2

5. Create S3 bucket and upload the application code accordingly.

6. Create IAM Policy

Select S3 - grant S3: GetObject & S3: ListBucket. -
- under Resources - you can limit it using the ARN (but for practice select all) -- Click on add more permission -- select Secret Manager -- grant permission - GetSecretValue & DescribeSecret.

7. Create Role- select Ec2 as use case - select the policy you just created -- name your role.

8. Create Subnet group -- select vpc - select your two AZ -- select your two private Subnets.

9. Create Database RDS-

Select Standard create
Select MySQL
Select the latest mysql database engine version
Select the free tier
Name your DB instance Identifier
Select managed in AWS Secrets Manager
Select include previous generation classes
Select instance type -- Select your Subnet group
Use db-sg as the security group
Select your AZ
Under configuration give the initial database name.

Now, Migrating data into RDS database:

10. Create Ec2 instance -- select without key pair -- select private subnet private app az2 -- select dms-sg - attach your role under instance profile.

Connect to the ec2 instance using the management console and use the migration script accordingly. Check out for the scripts to migrate data to RDS database here: https://github.com/Oluwatobiloba-Oludare/Dynamic-Web-Application-on-AWS)

After successfully migrating the data, you can terminate the Ec2 instance.

13. Create another ec2 instance in private subnet for webserver -- select without a keypair -- use web-sg -- attach the S3 role under instance profile.

14. Use the Deployment Script accordingly. (Check out the script in this github: https://github.com/Oluwatobiloba-Oludare/Dynamic-Web-Application-on-AWS )

15. Create Target group -- select instance - select VPC -- Under Advance Health check, enter 200,301,302 -- select the instance and include and create.

16. Create Application Load balancer

select vpc - select the two AZ in your VPC -- select public subnet for the two AZ -- Use ALB-sg -- Under Listener, select Redirect to URL and select full URL -
Add another listener -- select https -- select target group -- under default SSL, select your certificate.

17. Create a Record in our Domain name- use www -- Alias -- select region -- select Application and classic load balancer

Now, use your domain name to check your website on the internet.

Congratulations!

Now, let's be prepare for sudden traffic by setting up our auto-scaling group.

18. Create AMI

Go to the ec2 instance running and select actions and select image and templates and select create image -- select Tag image and snapshots together -- under Key, type Name and input your AMI name.

19. Create Launch template
-- select Auto scaling guidelines
-- select My AMIs and select owned by me
-- select t2 micro -- select web sg.

You can terminate the ec2 instance.

20. Create Auto scaling group

Select vpc - select the two private app
Select attach to an existing load balancer
Select target group
Select the two Health checks
Select the number of scaling you want

✍️ Final Thoughts

Learning AWS becomes easier when you build real projects. Deploying a dynamic web application is one of the best beginner exercises to understand how cloud services work together.

If you are learning AWS, I highly recommend trying this hands-on project.

Follow along for more practical AWS, Docker, and cloud learning posts.

How to Create a Secure VPC on AWS- STEP BY STEP

Oluwatobiloba Oludare — Thu, 16 Oct 2025 13:50:19 +0000

In this article, I will walk you through how I built the setup step-by-step, what I learned along the way, and why this project strengthened my understanding of AWS and cloud infrastructure security.

What is a VPC?
A VPC (Virtual Private Cloud) is a logically isolated section of the AWS Cloud where you can launch resources like EC2 instances, databases, and load balancers in a private, secure network that you control.

You decide the IP address range, create subnets, and define rules that manage how traffic moves within and outside your network.

Think of it as your own private data center hosted inside AWS.

Tools and Services I Used
Here are the AWS components I worked with in this project:
VPC *– To create a private network
**Subnets *– Divided into public and private zones
**Internet Gateway (IGW) – To allow internet access for public resources
NAT Gateway **– To allow private resources to access the internet securely (for updates, downloads, etc.)
**Route Tables – To control how traffic flows
Security Groups and Network ACLs (NACLs) – To define inbound and outbound rules for security
EC2 Instances – To test and verify the setup

Step-by-Step Setup
Step 1: Create a VPC
I started by creating a new VPC with a CIDR block of 10.0.0.0/16, which gives me up to 65,536 private IP addresses. This range acts as the foundation for all the subnets I created later

Step 2: Create Subnets (Public and Private)
To separate resources and improve security, I created:

Public Subnet – for resources that need internet access (like web servers)
Private Subnet – for backend systems such as databases or application servers that should not be accessible directly from the internet

Each subnet had its own CIDR range:

Public Subnet: 10.0.1.0/24
Private Subnet: 10.0.2.0/24

Step 3: Attach an Internet Gateway (IGW)
The Internet Gateway connects the public subnet to the internet. I created internet gateway, then I attached it to my VPC and updated the public route table to direct all outbound traffic (0.0.0.0/0) to the IGW.

Step 4: Set Up a NAT Gateway
The NAT Gateway (Network Address Translation) allows resources in the private subnet to access the internet securely (for software updates or package installations) while keeping them hidden from incoming traffic.

I placed the NAT Gateway inside the public subnet and attached an Elastic IP to it.

Step 5: Create and Configure Route Tables
I created two route tables:

Public Route Table – Linked to the public subnet and directed internet traffic to the IGW.
Private Route Table – Linked to the private subnet and directed traffic through the NAT Gateway.

This ensures that:

Public subnet resources (like web servers) can communicate with the internet.
Private subnet resources (like databases) can reach the internet for updates, but cannot be accessed directly.

I also edited the association to linked the private and public route to the subnets accordingly.

Step 6: Launch EC2 Instances to Test
I launched one EC2 instance in the public subnet and another in the private subnet to test communication:

From my public instance, I could SSH into it using the Elastic IP.
From there, I could connect to the private instance through its private IP — confirming that the network worked perfectly.

Step 7 : Configure Security Groups
Security groups act as virtual firewalls for EC2 instances.

For the public subnet, I allowed:

Inbound: HTTP (port 80), HTTPS (port 443), and SSH (port 22)
Outbound: All traffic (default)

For the private subnet, I allowed only:

Inbound: Traffic from the public subnet’s security group (e.g., for database connections)
Outbound: All traffic (so the instance can reach the internet via NAT)

Step 7: Add Network ACLs (NACLs)
NACLs provide an additional layer of network security at the Subnet Level.

I created NACLs for both subnets:

Public subnet NACL: Allows inbound/outbound HTTP, HTTPS, and SSH.
Private subnet NACL: Allows only internal communication and outbound connections through NAT.

Each rule has a rule number (like 100, 200, etc.) to control priority — lower numbers are evaluated first.

What I Learned
This project helped me understand how AWS networking and security really work in practice. Some key takeaways:

How public and private subnets help build secure architectures
How route tables control data flow within a VPC
The role of NAT Gateways and Internet Gateways in network design
How Security Groups and NACLs work together for defense in depth
How to think like a DevOps engineer, focusing on scalability and security from the ground up

Challenges I Faced During the Project.

1. CIDR Block Confusion
At first, I struggled to understand how to choose CIDR blocks correctly without overlapping IP ranges. I learned that each subnet must have a unique portion of the VPC’s IP range (for example, 10.0.1.0/24 and 10.0.2.0/24), and planning this ahead helps avoid routing issues later.

2. Internet Access Not Working for Private Instances
Initially, my private EC2 instance couldn’t reach the internet. The issue was that I hadn’t configured the NAT Gateway and Private Route Table properly. After updating the route table to direct 0.0.0.0/0 traffic to the NAT Gateway, everything worked perfectly.

3. Security Group and NACL Confusion
Understanding the difference between Security Groups (Stateful) and NACLs (Stateless) was tricky. I accidentally blocked SSH traffic at first because my inbound/outbound rules weren’t aligned. This helped me learn that:

Security Groups remember allowed connections automatically.
NACLs require explicit inbound and outbound permissions for each direction.

Conclusion:
Setting up a secure VPC gave me hands-on confidence in AWS networking and reinforced how important it is to design systems with security in mind from the very beginning.

If you’re starting your DevOps or cloud journey, I highly recommend trying this project, it’s one of the best ways to truly understand how the cloud works behind the scenes.

Have you tried setting up a VPC before? What challenges did you face?

How I Set Up an Application Load Balancer (ALB) Across Two EC2 Instances for High Availability.

Oluwatobiloba Oludare — Thu, 31 Jul 2025 21:26:45 +0000

PRACTICAL SCENARIO

At TechNova, we recently launched a product website hosted on Amazon EC2. To ensure high availability and fault tolerance, I was tasked with configuring an Application Load Balancer (ALB) that distributes traffic across two EC2 instances in different Availability Zones.

Objective
✅ Set up an Application Load Balancer
✅ Launch two EC2 instances in different Availability Zones
✅ Register both instances with the Target Group
✅ Ensure traffic is distributed evenly

Step-by-Step Implementation

1. Launch Two EC2 Instances
Choose the same region, but different subnets (AZs)
Use the same AMI (Amazon Linux), security group, and key pair for simplicity.

Connect to each instance via SSH

*Then install Web Server *
*Run this commands: *
sudo yum install httpd -y
sudo systemctl start httpd
echo "Welcome to Web Server 1" | sudo tee /var/www/html/index.html

Repeat on the second instance with "Web Server 2"

Install a web server (e.g., Apache or NGINX) with simple HTML content on both

2. Create a Target Group

Navigate to Target Groups

Choose:
Target type: Instance
Protocol: HTTP
Port: 80
Register both instances (tick the boxes)

3. Set Up the Application Load Balancer

Navigate to Load Balancers

Choose Application Load Balancer

Configure:
Name your Application Load Balancer
Scheme: Internet-facing

Availability Zones: Select at least two with their subnets

Listeners: HTTP (port 80)

Then attach your Target Group

*Review and create *

To Test the Application Load Balance

Visit the DNS name of the ALB in a browser
Refresh several times you should see responses from both instances

Congratulation, You have successfully set up load balancing!

Challenge Faced
At first, only one instance was receiving traffic. After reviewing the Target Group health checks, I discovered the web server was installed but not properly configured on the second instance.

A quick fix in the index.html resolved the issue.

CONCLUSION
With an Application Load Balancer in place, TechNova’s website can now handle more traffic and stay resilient in case of instance or AZ failures. This setup is foundational for achieving high availability in AWS.

Have you tried setting up an ALB before? Let me know your experience or any challenges you faced in the comments!

Getting Started with AWS Auto Scaling: Automatically Handle Your EC2 Load Like a Pro

Oluwatobiloba Oludare — Thu, 31 Jul 2025 18:46:45 +0000

AUTO-SCALING

Auto Scaling is one of those game-changing AWS features that makes your infrastructure smart, resilient, and cost-efficient. If you've ever wondered how websites handle sudden traffic surges without crashing or burning money, this is where Auto Scaling shines.

In this guide, I will walk you through the basics of AWS Auto Scaling, how to set it up, and what pitfalls to watch out for — especially if you’re just starting your cloud journey.

What is AWS Auto Scaling?

AWS Auto Scaling automatically adjusts the number of EC2 instances in your application based on demand. Whether your traffic spikes or drops, Auto Scaling ensures your app stays available and you only pay for what you use.

✨** Why Use Auto Scaling?**

High availability during peak loads
Reduced costs during low traffic
Improved fault tolerance
Hands-free instance management

🧱 Core Components of Auto Scaling

Here’s what makes it all work:

Launch Template – Defines the configuration for launching EC2 instances (AMI, instance type, etc).
Auto Scaling Group (ASG) – Manages and maintains the number of instances. It ensures that a defined number of instances are running based on user-defined minimum, maximum, and desired capacity.
Scaling Policies – Define how the group should scale (Target Tracking, Step Scaling, or Scheduled).
CloudWatch Alarms – Monitor CPU usage or other metrics to trigger scaling.

Practical Exapmple:

TechNova experiences inconsistent traffic. During working hours, there is heavy traffic. After hours, the load reduces. Your task is to configure an Auto Scaling Group to scale based on CPU usage.

🛠️ Setting Up Auto Scaling (Step-by-Step)

1. Launch two EC2 on different Availability zone (AZ)

Selected your preferred AMI
Instance type
Key pair -Security group

2. Create Target Group

Go to Load Balancing Option and select Target group.Then click on create target group.

Select Instance option and name your Target Group

You can leave other options on default and click next then select the two instances, then click on create target group.

3. Create Load Balance

Go to Load Balance option and click on it, then click on create load balance.

Select Application Load balancer and click on Create

Select two different Availability Zones in-line with your instance. (Example: Mine is us-east-1c & us-east-1d)

Under Security **
**Select at least one Security group

Under Listeners and routing.
Select your target group
Then click on "Add Listener"

After clicking on the Add Listener, select the Target group again

*Then click on Create Load Balancer *

4. Launch Template
Search for Launch Template and Select it accordgingly.

*Click on Create Launch Template *

*Name your template: *

Click on "Browse more AMIs" to select your AMI.
Then, select your instance type

Select your Key pair and also select one security group

Click on Advanced Settings and scroll down

*Insert this command on this User-data: *

yum update -y
yum install httpd -y
systemctl start httpd
systemctl enable httpd
echo "Welcome to Web Server - $(hostname)" > /var/www/html/index.html

*Then, click on Create Launch Template. *

5. Create Auto-Scaling

Select Auto Scaling and click on Create Auto Scaling

Name your Auto scaling group and Select the template you created.
Then click on next.

Select two different Availability zone, then click on next.

Select "Attach to an existing load balancer" and then select the target group you created earlier

Select "Turn on Elastic Load Balance Health Checks" and click on next.

For this exercise we are using 3 as maximum desired capacity and 1 as the minimum capacity. So select it accordingly.

Also select Target Scaling Policy and click on next to create the Auto-Scaling

DONE

*Now refresh your instance. *

You will notice that new instances are launched, some get terminated as demand decreases, and others are started again as needed — all automatically managed by Auto Scaling.

Auto Scaling automatically creates new EC2 instances when your current instance(s) can't handle the load for example, when CPU usage goes above a defined threshold like 60%.

LESSON I LEARNED

Set the right cooldown period to avoid frequent unnecessary scaling
Choose the correct target metric for your workload
Monitoring with CloudWatch is critical for visibility

*CONCLUSION: *

Auto Scaling saved TechNova both performance issues and unnecessary costs. By simply leveraging AWS-native tools like ASG, Launch Templates, and CloudWatch, we were able to build a resilient, adaptive infrastructure that scales as needed.

Want to try it for your own projects? Start small, experiment, and let the cloud do the heavy lifting. ☁️💪

Step-by-Step: How To Create and Attach EBS Volume.

Oluwatobiloba Oludare — Sun, 20 Jul 2025 11:59:43 +0000

INTRODUCTION

When working with EC2 instances on AWS, you may often need additional storage beyond the default root volume. This is where Amazon Elastic Block Store (EBS) comes in—providing scalable, high-performance block storage for your EC2 instances. In this article, I’ll walk you through how to create an EBS volume, attach it to an EC2 instance, and properly configure it for use. Whether you are new to AWS or looking to sharpen your DevOps skills, this step-by-step guide will help you confidently manage EC2 storage the right way.

*Follow these steps: *

Log in to AWS Management Console Go to: https://console.aws.amazon.com/

2. Navigate to EC2 Dashboard.

3. Create a New EBS Volume
In the EC2 Dashboard, scroll down to Elastic Block Store > Click Volumes.
Click Create Volume.
Choose:
Volume Type: (e.g., General Purpose SSD gp3)
Size: (e.g., 4 GiB or more)
Availability Zone: Must match your EC2 instance's AZ (e.g., us-east-1a)
Click Create Volume

4. Attach Volume to EC2
After creation, select the volume.

Click Actions > Attach Volume.

Select the EC2 instance from the dropdown.

You can select /dev/xvdbb and click Attach.

*5. Connect to EC2 *

SSH into your EC2 instance using this command: ssh -i your-key.pem ec2-user@your-ec2-public-ip

*6. Format *
Run these commands: sudo mkfs -t ext4 /dev/xvdbb

7. Create a mount point using this command sudo mkdir /mnt/my-ebs

8. Mount the volume

sudo mount /dev/xvdbb /mnt/my-ebs

Congratulation!

Challenge I Faced
One of the initial challenges I encountered was making sure the EBS volume was created in the same Availability Zone as my EC2 instance.

At first, I mistakenly created the volume in a different Availability Zone, which made it impossible to attach it to my instance. This taught me the importance of always double-checking the Availability Zone when creating resources that need to work together in AWS.

CONCLUSION

By following the steps in this article, you’ve successfully created and attached an EBS volume to your EC2 instance. This setup allows for better data management, flexibility, and scalability in your cloud infrastructure. As you continue exploring AWS services, understanding how to leverage EBS effectively will be essential for managing storage needs in real-world projects.

Stay curious, and keep building!

How I Deployed My Ubuntu EC2 Instance with NGINX and Customized My Web Page via Command Prompt

Oluwatobiloba Oludare — Sat, 05 Jul 2025 10:24:30 +0000

What is EC2 and Why Ubuntu?
Amazon EC2 (Elastic Compute Cloud) is a service by AWS that allows users to rent virtual machines in the cloud. These machines, called instances, can be used to run applications just like a regular computer.

I chose Ubuntu as my operating system because it's one of the most widely used Linux distributions. It's lightweight, developer-friendly, and perfect for deploying web servers like NGINX.

Step-by-Step Deployment Process

1.Login to AWS and Launch EC2 Instance

2. Change your country location to N.Virginia

3. Name your instance and Select Ubuntu Server 22.04 LTS (Free tier eligible)

4. Select t2.micro instance type (Free Tier eligible).

5. Create or select an existing key pair (.pem file).

6. As shown below, give your keypair a name and select RSA as your key pair type; seclect .pem as key file format, then click "create key pair". It will download instantly (Make sure your .pem file has the right permissions chmod 400 your-key-file.pem).

7. Configure Security Group to allow:
SSH (port 22)
HTTP (port 80)

8. Click Launch.

9. Copy your public Ipv4 address

10. Connect to the EC2 Instance via SSH
Open your command prompt or terminal, navigate to where you downloaded your key pair using "cd" (e.g. cd Downloads).
Then type this command and input your key-pair name and your public ip address - *"ssh -i your-key-file.pem ubuntu@your-ec2-public-ip" *

11. Run this command to update Ubuntu and install Nginx
sudo apt update
sudo apt install nginx

*12. To start and enable nginx run these commands: *
sudo systemctl start nginx
sudo systemctl status nginx
sudo systemctl enable nginx

Paste your public Ip address to your browser
you will see this welcome message:

🎉 You’ve successfully deployed an NGINX web server on EC2 using just your terminal!

13. To edit the welcome message to your own desire content:

14.Run this command sudo nano /var/www/html/index.nginx-debian.html. Then edit the content to your taste as shown below.

Challenges I Faced

🔐 SSH Connection Issues

I initially got a “Permission denied (publickey)” error.

This was because:

My .pem file didn’t have the right permissions.

I was using the wrong username (ec2-user instead of ubuntu for Ubuntu AMI).
**
✅ Fix: Set permission with chmod 400 and use the correct SSH username.**

Conclusion
Deploying an NGINX web server on an EC2 instance with just the command prompt was a great way to strengthen my cloud skills. It taught me the importance of networking, server setup, and command-line operations in real-world environments.

If you are just starting out with AWS or want to get comfortable managing servers via the terminal, I highly recommend trying this project. It’s simple, educational, and sets the stage for more advanced deployments.

Have you tried deploying a web server via the terminal before? Got stuck or have questions? Drop a comment below — I would love to hear your thoughts and help if I can!

How I Deployed an EC2 Instance with Apache: A Step-by-Step Guide 🚀

Oluwatobiloba Oludare — Fri, 20 Jun 2025 18:49:19 +0000

As someone learning cloud computing and DevOps, one of my first hands-on experiences was launching an Amazon EC2 (Elastic Compute Cloud) instance and deploying a basic web server using Apache. If you are new to AWS or cloud infrastructure in general, this post will walk you through the process I followed—from spinning up an EC2 instance to seeing my first “It works!” page live on a browser.

What is EC2?
Amazon EC2 (Elastic Compute Cloud) is a service that provides resizable compute capacity in the cloud. In simpler terms, it lets you rent virtual machines (called instances) where you can run your applications, host websites, or do pretty much anything you'd do on a physical server—without actually managing hardware.

With EC2, you can:

Choose your preferred OS (Linux, Windows, etc.)
Scale up or down depending on traffic
Pay only for what you use

Now, let’s dive into how I used EC2 to set up a web server with Apache.

Step-by-Step: Deploying EC2 with Apache

Login to AWS Console Go to https://aws.amazon.com/ and sign in to the AWS Management Console. If you don’t have an account yet, sign up—it’s free to get started and comes with a 12-month Free Tier, which includes EC2.

2. Launch an EC2 Instance
Search for EC2 under the “Services” menu

3. Click Launch Instance.

4. Give your instance a name (e.g., My-Server);

Amazon Machine Image (AMI): Choose Amazon Linux

5. Change your country to N.Virginia

6. Instance Type: Select t2.micro or t3.micro (eligible for the free tier)

7. Key Pair: Click on create new key pair.

8. **As shown below, give your keypair a name and select RSA as your key pair type; seclect .pem as key file format, then click "create key pair". It will download instantly.**

9. Security Group:
Create a new Security Group with the following:
Type: SSH | Port: 22 | Source: 0.0.0.0/0
Type: HTTP | Port: 80 | Source: 0.0.0.0/0

10. Then click Launch Instance and wait for the instance status to be running.

11. click on the instance as shown below

12. Connect to the Instance via SSH

Open Git Bash (or PowerShell/Terminal); navigate to where you downloaded your keypair (using cd) then give it the right permission of "chmod 400 your-key-name.pem" as shown below

13. Go back to your AWS dashboard and click on the box beside your server's name, then copied the public ip address.

14. Connect using SSH:
Use this format ssh -i "my-ec2-key.pem" ec2-user@.

Insert your keypair name & your public IPv4 address you copied and press enter.

Type yes when prompted

15. Install a Web Server (Apache)

Run the following commands in the EC2 terminal:

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

16. Verify in Browser- Open your browser and type the Public IPv4 address of your EC2 instance. You should see the default Page with a message that says:

It works!

🎉 Congratulations! You’ve successfully deployed a web server on EC2.

17. Customize the Page:
To customize the page, run this command in the EC2 terminal:

you can replace the Hello from EC2 to any sentence you want eg Assignment Completed Successfully!

Once again, Congratulation.

The Challenge I Faced and How I Solved it

Apache Not Showing in Browser Problem: After installing Apache, typing the EC2 public IP in the browser showed nothing or timed out.

Solution:

I went back to my EC2 terminal and I discovered that I have not enabled the Apache.
I immediately start and enable it using "sudo systemctl start httpd" & "sudo systemctl enable httpd".Thereafter, the Apache welcome page loaded correct ly.

🧩 Conclusion
Deploying an EC2 instance and setting up Apache was a rewarding hands-on experience that deepened my understanding of cloud infrastructure and server configuration. From launching the instance to configuring security groups and troubleshooting connectivity issues, each step taught me something new about how cloud environments operate.

This beginner-friendly project reminded me that even small deployments can build the confidence and skills needed for more complex DevOps tasks ahead. If you're just getting started with AWS or cloud engineering, I highly recommend trying this out—you’ll gain practical insights that no tutorial can fully explain until you do it yourself.

Thanks for reading! If you have any questions, ran into different challenges, or want to share your own experience, feel free to drop a comment below. Let’s learn together! 🙌