DEV Community: Morodolu Oluwafikunayomi

The Fastest Way to Deploy Any Website Template on CentOS (After SSH)

Morodolu Oluwafikunayomi — Wed, 12 Nov 2025 08:53:21 +0000

This is part 2 to my previous post, you know that feeling when you finally SSH into your VirtualBox or Vagrant box, and now you have to set up a whole website manually?
Install this, unzip that, copy files, restart Apache, fix permissions… rinse and repeat.
Yeah, we’re not doing that today.
Instead, I’ll show you how to automate the entire process

What You’ll Need

Before we dive in, make sure you’ve got the basics ready:

You’ve already SSH’d into your CentOS box, for example:

 vagrant ssh

You’re inside your working directory (I’ll use /home/vagrant/server for this tutorial).
Apache is installed and running. If not, quickly do:

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

That’s it let’s automate the rest.
Step 1: Create the Script
Once you’re inside your SSH terminal, move into your server folder and create a script file:

cd ~/server
touch scripting.sh
chmod +x scripting.sh
vi scripting.sh

If vi doesn’t work, you can use nano or even cat > scripting.sh.

Step 2: The Automation Script

#!/bin/bash

echo "Installing wget and unzip..."
sudo yum install wget unzip -y

# Ask the user for a template URL
read -p "Enter the URL of your website template (.zip): " TEMPLATE_URL

echo "Downloading your template..."
wget $TEMPLATE_URL -O website_template.zip

echo "Extracting website files..."
unzip -o website_template.zip -d ~/server/

# Automatically detect extracted folder
EXTRACTED_DIR=$(find ~/server -maxdepth 1 -type d -name "templatemo*" -o -name "html*" | head -n 1)

if [ -z "$EXTRACTED_DIR" ]; then
  echo "❌ Could not find extracted folder. Please check manually."
  exit 1
fi

echo "Deploying files to /var/www/html..."
sudo cp -r $EXTRACTED_DIR/* /var/www/html/

echo "Restarting Apache..."
sudo systemctl restart httpd
sudo systemctl enable httpd

IP=$(hostname -I | awk '{print $1}')
echo "✅ Done! Visit your site at: http://$IP/"

Save and exit (in vi, that’s ESC + :wq).

Step 3: Run It
Now run your shiny new automation script:

./scripting.sh

It’ll ask you for a template URL — just paste in one of these:

Example Template URLs

Templatemo 3D Coverflow
BootstrapMade Arsha Template
HTML5UP Phantom Template
Or grab any .zip link from your favorite site:
https://templatemo.com
https://bootstrapmade.com
https://html5up.net
Once the script runs, it’ll:
Install missing tools
Download your zip file
Unzip it into your server folder
Copy everything into /var/www/html/
Restart Apache
And show your local IP

In short — it does all the boring stuff for you.

After it finishes, you’ll see something like this:
Done! Visit your site at: http://192.168.33.10/

From ThemeWagon to Live Site: Hosting a Free HTML Template on Your Local Apache Server Using Vagrant + Git Bash

Morodolu Oluwafikunayomi — Tue, 04 Nov 2025 15:16:37 +0000

Ever downloaded a beautiful free template from ThemeWagon
and thought,
“Okay... now how do I actually host this like a real website?”

That’s where this guide comes in.

In this post, I’ll walk you through hosting a free HTML template on your own local Apache server, running inside a Vagrant virtual machine — all from your Git Bash terminal.

What You’ll Need

Before we start, make sure you’ve got these installed:

🧱 VirtualBox(for running the VM)
📦 Vagrant
💻 Git Bash(Windows users)
🧾 Any HTML template (download from ThemeWagon)

No coding required

Step 1 — Create a Project Folder and Initialize Vagrant

Open Git Bash and run:

pwd(this is to know what directory you are on)
cd "directory, either downloads or documents or desktop"
mkdir ~/myserver
cd ~/myserver

Now initialize your Ubuntu box:

vagrant init ubuntu/jammy64

but if you wish for any other OS check out:
https://portal.cloud.hashicorp.com/vagrant/discover

This creates a Vagrantfile in your folder. It’s basically your VM’s configuration file — where you’ll define memory, CPU, and network settings.

Step 2 — Edit Your Vagrantfile Using Vim
Inside Git Bash, while you are in the same directory open the Vagrantfile:

vim Vagrantfile

This will open the file in Vim editor.
Press i to enter insert mode now you can start typing or editing.
thereafter to Enable Private or Public Network Access, Scroll down to find these lines:

config.vm.network "private_network", ip: "192.168.33.10"

config.vm.network "public_network"

Uncomment one of them depending on what you want:
Use private network if you just want to access your site locally:

config.vm.network "private_network", ip: "192.168.33.10"

do note kindly keep the ip address here somewhere or be written down as it is useful later on, you can also change the numbers maybe like 192.168.40.15
Or use forwarded port (recommended for beginners):

config.vm.network "forwarded_port", guest: 80, host: 8080

This means anything on port 80 (inside the VM) will be visible on your local machine at http://localhost:8080.
lastly to Allocate More RAM and CPUs
Find and uncomment this section:

config.vm.provider "virtualbox" do |vb|

vb.memory = "1024"

end

Now edit it to give your VM more resources:

config.vm.provider "virtualbox" do |vb|
  vb.memory = "2048"     # 2GB RAM
  vb.cpus = 2            # 2 CPU cores
end

unless you want graphical user interface i don't recommend uncomment the
GUI line of syntax, and any line with double # is an actual comment.

Once done, press:
Esc
Type

:wq
Hit Enter
That saves and exits Vim.

Step 3 — Boot Up the Virtual Machine
Now it’s time to start your virtual server:
type in

vagrant up

Vagrant will download the Ubuntu image, set up the VM, and start it automatically.
The first run takes a few minutes — but once complete, you’ll see your box running.
Then, log in to it:

vagrant ssh

You’re now inside your Ubuntu server as the vagrant user
to test you can type in:

whoami

this should return vagrant
Step 4 — Install Apache Web Server
while having different types os linux OS it is important to know the name of the apache server and which ubuntu supports it


sudo apt update

Install Apache:

sudo apt install apache2 -y

Start and enable it:

sudo systemctl start apache2
sudo systemctl enable apache2

Test it!
On your browser, go to the ip address you have in the private ip address in the vagrant file.
You should see “Apache2 Ubuntu Default Page”.
Congrats — your web server works

Step 5 — Upload and Unzip Your ThemeWagon Template

Inside your server, make a folder to hold your website:

mkdir ~/server
cd ~/server
Now using wget (the themewagon download link)

_the way i usually get is by going to themewagon, inspecting the page, going to network and clicking on the template download buttonwe should see the template name, it should be :http://..... _

so by doing the same you should arrive where i am, copy the link

Then unzip it:

unzip (the foldername)

incase you have an error code about unzip not been part of the OS package use

sudo apt install unzip -y
unzip foldername

Step 6 — Move Files to Apache’s Web Root
Copy everything from your extracted folder into Apache’s serving directory:

sudo cp -r ~/server/neural_glass/templatemo_597_neural_glass/* /var/www/html/

Restart Apache so changes apply:

sudo systemctl restart apache2

Step 7 — Visit Your Website!

Now, open your browser and head to:
your private ip address
incase your forgotten your ip address:
Check your server’s IP:

If you used a private network instead of port forwarding:

ip addr show

Look for something like:

inet 192.168.33.10/24

Reboot or Halt Your Server

To stop:

vagrant halt

To start again:

vagrant up

To destroy and rebuild (when experimenting):


vagrant destroy -f && vagrant up

If this guide helped you, drop a ❤️ on DEV.to and comment how your first hosted template went or what how i can improve on deploying faster

Spin Up, Explore, and Destroy: A Complete Beginner’s Guide to Using Vagrant with Ubuntu (Visual Walkthrough)

Morodolu Oluwafikunayomi — Sat, 11 Oct 2025 15:27:46 +0000

Prerequisites
Before we begin, make sure you have:

Vagrant installed → Download here
VirtualBox (or any supported provider)
A terminal or command prompt
Basic command-line familiarity That’s it! Let’s get started.

Step 1: Create a New Vagrant Project

First, create a folder for your new virtual machine setup and initialize it with the Ubuntu box:

mkdir vagrant-ubuntu
cd vagrant-ubuntu
vagrant init ubuntu/jammy64
vi vagrant #this is to edit the file,

once you opened the file make sure to uncomment the private network line which contains the public address of the os and the public address line

This creates a file called Vagrantfile — the heart of your configuration

Step 2: Configure the Vagrantfile

Open the Vagrantfile with your favorite editor and tweak the settings.
You can adjust CPU, memory, and network configurations easily.

Example configuration:

Vagrant.configure("2") do |config|
  config.vm.box = "ubuntu/jammy64"

  # Optional: forward host port 8080 to guest port 80
  # config.vm.network "forwarded_port", guest: 80, host: 8080

  # Provider-specific settings
  config.vm.provider "virtualbox" do |vb|
    vb.memory = "2048"
    vb.cpus = 2
  end

Step 3: Start the Virtual Machine

Once your configuration is ready, start the VM using:

vagrant up

This command downloads the Ubuntu box (if it’s your first time) and boots it up.
You’ll see messages as Vagrant connects to VirtualBox and starts provisioning the machine.

Step 4: Connect to Your Virtual Machine

Once it’s running, you can log into your Ubuntu VM:

vagrant ssh

If everything went well, you’ll see the Ubuntu welcome message, along with system stats and login info.

Step 5: Run Basic Commands Inside the VM

Now that you’re inside, you can explore and test basic commands:

whoami           # should print 'vagrant'
mkdir testfile
touch textfile.txt
ls
rm textfile.txt
rmdir testfile

You can also install packages, configure software, or run a web app — it’s your sandboxed Linux environment!

Step 6: Stop and Destroy the VM

When you’re done experimenting, you can safely shut down or completely remove the VM:

vagrant halt       # stops the virtual machine
vagrant destroy    # permanently deletes the VM

This frees up your system resources and ensures a clean slate for next time.

This workflow is especially powerful for testing backend apps, DevOps scripts, or server configurations safely. Once you’re comfortable, try automating it with provisioning tools like Ansible or deploying pre-configured images.

AWS Networking Fundamentals: Building a Secure Cloud Architecture

Morodolu Oluwafikunayomi — Sun, 31 Aug 2025 18:23:59 +0000

AWS Networking Explained Like Building a Neighborhood 🏡

If you’re new to AWS networking, it can feel like alphabet soup: VPCs, Subnets, IGWs, NATs, Route Tables, SGs, NACLs

But here’s the good news: it’s easier to understand if you think of it like building a secure neighborhood.

By the end of this post, you’ll:

Understand AWS networking through real-world analogies

Know the difference between gateways, firewalls, and route tables

Build your own secure cloud community step by step

1. VPC → Your Gated Community

A VPC (Virtual Private Cloud) is your private section of AWS.

Imagine buying land inside a gated estate. You decide how big it is, where the streets go, and who’s allowed in.

Isolated from other customers.
You choose the boundaries (IP ranges).
You control traffic in and out.

2. Subnets → Streets in Your Community

Inside your VPC, you divide land into subnets (streets).

Public Subnet → open for visitors (shops, restaurants, web servers).
Private Subnet → hidden residential area (databases, backend).

Pro tip: Always spread them across different availability zones so your app stays online even if one zone fails.

![Insert subnet diagram here]

3. Internet Gateway → The Main Gate

The Internet Gateway (IGW) is the guarded entrance/exit of your estate.

Lets outsiders visit your public servers.
Lets your public servers reach the internet.
Scales automatically (AWS manages it).

4. NAT Gateway → The Secure Mail Slot

Private residents (databases, backend servers) need the internet too—like downloading security updates. But you don’t want strangers knocking on their doors.

That’s what the NAT Gateway is for:

It allows private instances to send requests out.
Outsiders can’t start conversations with them.

Analogy: a one-way mail slot.

5. Route Tables → The Traffic GPS

How does data know where to go?

Public Subnet → IGW (for internet access).
Private Subnet → NAT Gateway (outbound only).

Think of it like street signs and GPS guiding cars to the right road.

6. Elastic IP → think of it as your Fixed house Address

An Elastic IP (EIP) is a permanent public address.

Doesn’t change if you restart your server.
Useful for NAT Gateways and critical servers.

7. Security Groups → Your Bodyguards

Every house/server gets its own bodyguard (SG).

Deny everything by default.
Example: “Allow web visitors (port 80, 443) but only let me in via SSH.”
Stateful: Replies are automatically allowed.

🚔 8. Network ACLs → The Street Patrol

A NACL is the patrol car for the whole street.

Controls traffic before it reaches houses.
Stateless: you must define both inbound & outbound rules.
Can allow and deny traffic (SGs can only allow).

Putting It All Together

So when you launch a simple website with a database:

VPC = your gated community.
Subnets = public (web server) + private (database).
IGW = main entrance gate.
NAT Gateway = one-way mail slot.
Route Tables = GPS for data traffic.
Elastic IP = permanent address.
Security Groups = bodyguards at each house.
NACLs = patrol cars on each street.

Result: Visitors can access your web server.

The web server talks to the database.

The database can fetch updates from the internet—but no hacker can reach it directly.

Hands-On Lab: Build Your Own AWS Neighborhood

Now that you’ve got the concepts, let’s build it step by step.

🔹 Phase 1: Foundation – Setting Up Your Land

Create a VPC (Your Gated Community)
- Go to: AWS Console → VPC → Your VPCs → Create VPC
- Name: My-Secure-VPC
- IPv4 CIDR: 10.0.0.0/16

Create Subnets (Your Streets)
- Public Subnet: public-subnet-1 → 10.0.1.0/24
- Private Subnet: private-subnet-1 → 10.0.2.0/24

Create an Internet Gateway (Main Gate)
- Name: My-IGW
- Attach to My-Secure-VPC

Phase 2: Routing & Security

Public Route Table (Signs for Public Street)
- Destination: 0.0.0.0/0 → Target: Internet Gateway
- Associate with: public-subnet-1

Security Group (Web Server’s Bodyguard)
- Inbound rules:
  - HTTP (80) → Anywhere
  - HTTPS (443) → Anywhere
  - SSH (22) → My IP only

🔹 Phase 3: NAT Gateway – Secure Mail Slot

Allocate an Elastic IP

Create NAT Gateway
- Name: My-NAT-Gateway
- Subnet: public-subnet-1
- Elastic IP: (select the one created)

Remember to create a route table for private route table

it the same process we used for public route table

Private Route Table (Signs for Private Street)
- Destination: 0.0.0.0/0 → Target: My-NAT-Gateway
- Associate with: private-subnet-1

🔹 Phase 4: Deploy Your Residents

Launch Web Server (Public Street)
- Name: Web-Server
- Type: t2.micro (Free Tier)
- Subnet: public-subnet-1
- Public IP: ✅ Enabled
- Security Group: Web-Server-SG
- User Data (auto install web server):

 ```bash
 #!/bin/bash
 sudo dnf update -y
 sudo dnf install -y httpd
 sudo systemctl start httpd
 sudo systemctl enable httpd
 echo "<h1>Hello World from my $(hostname -f)</h1>" > /var/www/html/index.html
 ```

Launch Database Server (Private Street)
- Name: DB-Server
- Type: t2.micro (Free Tier)
- Subnet: private-subnet-1
- Public IP: ❌ Disabled

Phase 5: Validation – Test Your Community

Test Web Server
- Open Web Server’s public IP in a browser → should show “Hello World”.
Test Private Database Internet Access
- SSH into Web Server → then into DB Server (using private IP).
- Run:
```
  curl https://checkip.amazonaws.com
```

- Output should be the NAT Gateway’s Elastic IP → proving secure outbound-only internet.

Final Result

Web Server: Accessible publicly.

Database: Hidden in private subnet, still can update.

Architecture: Secure, scalable, cloud-ready.

You’ve officially built a secure neighborhood in the cloud 🏡🌐

Building a Django Booking Management App with a Theme Wagon Template

Morodolu Oluwafikunayomi — Mon, 11 Aug 2025 16:00:29 +0000

I recently built a booking management system using Django for the backend and two different dashboard templates for the frontend:

Kopee Dashboard → Used for the booking form page.
Venus Dashboard → Used as inspiration for the table page that displays booking records.

This project allows users to:

Submit bookings with Name, Email, Date, Time, Person
Store bookings in a Django database
View, edit, and delete bookings from a clean dashboard table
Use custom HTML/CSS dashboards to save frontend development time

Purpose of the Project

The goal was to create a professional booking management system that:

Lets users submit booking details easily
Stores all bookings in a structured database model
Displays them in a styled and organized table
Uses existing dashboard themes to make the UI look polished without starting from scratch

Frontend Templates

1. Kopee Dashboard (Booking Form Page)

The booking form in my project comes directly from the Kopee Dashboard template. I customized it slightly to match the project’s colors and form structure.

2. Venus Dashboard Inspiration (Table View Page)

For the table that lists all bookings, I took inspiration from the Venus Dashboard by ThemeWagon. I kept only the sidebar and table layout, removed other widgets, and gave the table space, borders, and a readable font.

Project Structure

booking_project/
│── booking_app/
│   ├── templates/
│   │   ├── index.html        # Kopee-based booking form
│   │   ├── showdb.html       # Venus-inspired booking table
│   │   ├── booking_success.html
│   │   ├── correction.html
│   │   ├── delete_confirmation.html
│   ├── models.py
│   ├── views.py
│   ├── urls.py
│── booking_project/
│   ├── settings.py
│   ├── urls.py
│── manage.py

Database Model

booking_app/models.py

from django.db import models

class Booking(models.Model):
    PERSON_CHOICES = [
        ('1', 'Person 1'),
        ('2', 'Person 2'),
        ('3', 'Person 3'),
        ('4', 'Person 4'),
    ]
    name = models.CharField(max_length=100)
    email = models.EmailField()
    date = models.DateField()
    time = models.TimeField()
    person = models.CharField(max_length=1, choices=PERSON_CHOICES)

    def __str__(self):
        return f"Booking by {self.name} on {self.date} at {self.time}"

Views (Core Logic)

booking_app/views.py

from django.shortcuts import render, redirect, get_object_or_404
from .models import Booking

def index(request):
    if request.method == 'POST':
        Booking.objects.create(
            name=request.POST.get('name'),
            email=request.POST.get('email'),
            date=request.POST.get('Date'),
            time=request.POST.get('Time'),
            person=request.POST.get('person')
        )
        return redirect('success')
    return render(request, 'index.html')

def booking_success(request):
    return render(request, 'booking_success.html')

def showdb(request):
    individualbooking = Booking.objects.all()
    return render(request, 'showdb.html', {'individualbooking': individualbooking})

def update(request, id):
    updateInfo = get_object_or_404(Booking, id=id)
    if request.method == 'POST':
        updateInfo.name = request.POST.get('name')
        updateInfo.email = request.POST.get('email')
        updateInfo.date = request.POST.get('date')
        updateInfo.time = request.POST.get('time')
        updateInfo.person = request.POST.get('person')
        updateInfo.save()
        return redirect('showdb')
    return render(request, 'correction.html', {'updateInfo': updateInfo})

def delete_contact(request, id):
    booking = get_object_or_404(Booking, id=id)
    if request.method == 'POST':
        booking.delete()
        return redirect('showdb')
    return render(request, 'delete_confirmation.html', {'booking': booking})

URLs

booking_app/urls.py

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
    path('success/', views.booking_success, name='success'),
    path('showdb', views.showdb, name='showdb'),
    path('update/<int:id>', views.update, name='update'),
    path('delete_contact/<int:id>', views.delete_contact, name='delete_contact'),
]

Booking Table Template

showdb.html

{% raw %}
<tbody>
{% for booking in individualbooking %}
<tr>
    <td>{{ booking.name }}</td>
    <td>{{ booking.email }}</td>
    <td>{{ booking.date }}</td>
    <td>{{ booking.time }}</td>
    <td>{{ booking.person }}</td>
    <td>
        <a href="{% url 'update' booking.id %}">
            <i class="fa-regular fa-pen-to-square"></i>
        </a>
    </td>
    <td>
        <a href="{% url 'delete_contact' booking.id %}">
            <i class="fa-regular fa-trash-can"></i>
        </a>
    </td>
</tr>
{% empty %}
<tr>
    <td colspan="7" style="text-align:center;">No bookings yet</td>
</tr>
{% endfor %}
{% endraw %}

How to Run

Install Django:

pip install django

Create and configure your Django project and app.
Run migrations:

python manage.py makemigrations
python manage.py migrate

Start the server:

python manage.py runserver

Visit http://127.0.0.1:8000/

Final Thoughts

By combining the Kopee Dashboard for the form and a Venus Dashboard-inspired layout for the table, I built a booking management system that looks professional and works efficiently—without reinventing the wheel for UI design. Django handled the backend logic perfectly, while these templates gave the project a polished frontend.

Full Source Code: https://github.com/Fikalz/A-functioning-booking-form-with-django/tree/main

Here are some of the images of the site

Your First Django Database Write: A Step-by-Step Walkthrough

Morodolu Oluwafikunayomi — Sun, 03 Aug 2025 11:14:48 +0000

When learning Django, one of the most powerful things you'll discover is how effortlessly it lets you interact with databases using models. In this guide, I’ll walk you through how to write to a database in Django using real examples, no steps skipped!

Whether you're just starting or you’re working on a mini project, this article will help you:

Set up your virtual environment
Install Django
Start a project and app
Create and configure a model
Run the server and interact with the database Step 1: Set Up Your Environment: On my previous post on python i showed the walkthrough on the creation and interacting with django, but first, create a new folder for your project, then open your terminal or command prompt inside that folder.

python -m venv venvname
cd venvname\Scripts
activate.bat
cd ../..

💡 Note: venvname can be any name for your virtual environment.
Once activated, install Django:

python -m pip install django

You should see Django and its dependencies installing without issues.

Step 2: Create Your Django Project and App
Next, use the Django CLI to set up your project and an app inside it.

django-admin startproject connectdb .
django-admin startapp dbapp

Make sure your structure looks like this
djangopractice/
├── connectdb/
├── dbapp/
├── venvname/
├── manage.py
in the root folder in your file explorer

Step 3: Create Your Model
Now open dbapp/models.py and define your model class. For this example, `I created a Contacts model:
from django.db import models

class Contacts(models.Model):
firstname = models.CharField(max_length=100)
lastname = models.CharField(max_length=100)
age = models.IntegerField()

def __str__(self):
    return self.firstname`

This will let Django know you want a table in the database called Contacts, with firstname, lastname, and age fields.

Step 4: Connect to the Database Using Django Shell
you can use the django shell but i use the command prompt for this, open a new command prompt and type in one line after the other.

cd downloads\djangopractice\venvname\Scripts
activate.bat
cd ../..
python manage.py makemigrations
python manage.py migrate
python manage.py shell

Step 5: Write to the Database
Inside the shell, you can import your model and start creating records. Here's how:

# First, import the model
from dbapp.models import Contacts

# Then, create a new instance
contact = Contacts(firstname='John', lastname='Doe', age=28)

# Save it to the database
contact.save()

That’s it! 🎉 You've just written to your database.
You can verify it by retrieving all records by

Contacts.objects.all()

In my next article, I’ll show you how to:

Register your models with the Django admin
Create a superuser
Use Django’s powerful built-in admin interface to manage data visually if you have any question or contribution ask in the comment i will always respond

Load Balancing in AWS: Deliver High Availability with Smart Traffic Distribution

Morodolu Oluwafikunayomi — Tue, 29 Jul 2025 07:13:55 +0000

In today's cloud-native world, users expect applications to be fast, reliable, and always available. Whether it's a web app, an API, or a containerized service, your infrastructure needs to be able to handle changing traffic loads without breaking under pressure.
That’s where load balancing comes in — and in AWS, Amazon Web Services (AWS), Elastic Load Balancing (ELB) is a fully managed service designed to automatically distribute incoming traffic across multiple targets such as EC2 instances, containers, and IP addresses.

What is Load Balancing?
Load balancing is the process of distributing incoming network traffic across multiple backend resources. This prevents any single resource from becoming a bottleneck, thereby improving:

Availability
Scalability
Fault tolerance
Performance
Types of Load Balancers in AWS
AWS offers four types of load balancers under the Elastic Load Balancing (ELB) service:
But before that there is something called OSI model( Open Systems Interconnection model), it is a conceptual framework that standardizes how computer systems communicate over a network, it operates at a seven layer framework, which are
physical
datalink
network
transport
session
presentation
application
Depending on what your app needs, AWS offers four types of load balancers. Here's a quick overview and which layer they operate at:
Application Load Balancer (ALB)
Operates at Layer 7 (Application)(HTTP/HTTPS).
Great for routing based on content (like path or hostname).
Perfect for modern web apps and microservices.
Network Load Balancer (NLB)
Works at Layer 4(transport)(TCP/UDP).
Designed for ultra-low latency and high throughput.
Ideal for high-performance, real-time applications.
Gateway Load Balancer (GWLB)
Best suited for integrating third-party security appliances like firewalls or intrusion detection systems.
Routes traffic transparently while scaling with demand.
Classic Load Balancer (CLB)
Older generation, supports both Layer 4 and Layer 7.
Mostly used in legacy systems, not recommended for new projects.

How Load Balancing Works in AWS
Here’s a simplified view of what happens when someone accesses your app through a load balancer:

A user makes a request to your application (e.g., opens your website).
The request is sent to your load balancer via a DNS name.
The load balancer checks which backend servers (targets) are healthy.
It forwards the request to one of those healthy servers based on a routing algorithm (like round-robin).
The chosen server processes the request and sends the response back through the load balancer to the user.

Simple, seamless, and scalable.

_in simpler terms _
When one server is receiving too much traffic, instead of letting it get overwhelmed, the load balancer steps in and says:

“Hey, this server is getting busy — let me send the next request to another server that’s less busy or idle.”

it distributes incoming traffic across multiple servers, which:
Prevents any one server from crashing or slowing down
Keeps your app fast and available
Helps scale your infrastructure without users even noticing

Step-by-Step: Setting Up an Application Load Balancer (ALB)
Step 1: Launch Your EC2 Instances:
Start by launching at least two EC2 instances (in different Availability Zones if possible). These will serve your application and install Apache or NGINX, app on each. If you don't know how to create instance check out my previous post on creation of instances and installation of webserver such as apache or nginx as i will skipping a lot of steps

Step 2: Create a Target Group

Go to EC2 > Target Groups.
Click Create target group, choose “Instances” as the target type.

leave the VPC as default or if you have specific configuration
Set the protocol and port (e.g., HTTP, port 80).

then click on next
Register your EC2 instances to the target group.

then click on create target group

Step 3: Create the Load Balancer
Go to EC2 > Load Balancers, then click Create Load Balancer.

Choose Application Load Balancer.

leave the VPC as default and select the the availability zone based on the instance you created

Set the name, select internet-facing or internal, and assign at least two Availability Zones for high availability.

from the above picture click on default action and select the previous target group we created then click on add listener tag, then leave the remaining checks as is, then click on create load balancer.

Step 4: Test Your Setup

Grab the DNS name of your ALB from the console.
Paste it in your browser — you should see one of your app instances respond.
Refresh a few times to see how it balances across servers.

Amazon EFS vs EBS: How to Choose the Right AWS Storage and a Step-by-Step EFS Setup

Morodolu Oluwafikunayomi — Sun, 20 Jul 2025 22:10:02 +0000

In the world of cloud infrastructure, choosing the right storage solution is crucial. If you're working with AWS and wondering whether EFS or EBS is the right tool for your workload, you’re in the right place.

In this article, we'll break down:

What Amazon Elastic File System (EFS) is
How to create and mount an EFS
The difference between EFS and Amazon EBS
When to use each one

What is Amazon EFS?
Amazon Elastic File System (EFS) is a fully managed, serverless, elastic file storage system that you can mount across multiple EC2 instances via the NFS (Network File System) protocol.

Think of it as a shared drive in the cloud that multiple virtual machines can use at the same time perfect for applications that need access to the same data concurrently.

Key Features of EFS:

Elastic: Automatically scales as you add/remove files
Fully Managed: No servers to provision or manage
Shared Access: Mountable to multiple EC2s concurrently
Secure: Supports encryption at rest and in transit
Highly Available: Data is stored across multiple AZs (Availability Zones)

How to Create and Use Amazon EFS
Step 1: Create an EFS File System

Go to the EFS Dashboard.
Click “Create file system”.

Give it a name and select the VPC where your EC2 instances live.
Use default settings for availability and performance unless you have special needs.

from the image it automatic connect to the instance i created through the VPC

Click “Create” — AWS handles the provisioning.

Step 2:

Create Two EC2 Instances

Launch 2 Amazon Linux 2023 instances:

Both in same VPC and subnet

Choose t2.micro for free tier

Enable public IP and SSH access

Step 3: Install NFS Utilities on EC2

SSH into your EC2 instance(s) and run:

sudo yum install -y nfs-utils  # Amazon Linux / RHEL

Step 4: Mount the EFS File System
Use the efs-id from your file system (or use the DNS name AWS provides):

sudo mkdir /mnt/efs
sudo mount -t nfs4 -o nfsvers=4.1 fs-12345678.efs.us-east1.amazonaws.com:/ /mnt/efs

✅ You’re now using a shared file system across EC2s!

EFS vs. EBS: What's the Difference?

Feature	Amazon EFS	Amazon EBS
Storage Type	File system (NFS)	Block storage
Access	Multiple EC2 instances (shared)	One EC2 instance at a time (unless using Multi-Attach with limits)
Use Case	Web servers, CMS, shared config	Databases, OS storage, low-latency apps
Elasticity	Auto-scales storage	Must specify volume size
Backup	Lifecycle policies, AWS Backup	Snapshots, AWS Backup
Throughput	Scales with size & throughput mode	Defined by volume type (gp3, io1, etc.)
Mount Protocol	NFS (Network File System)	Appears as a raw block device

Think one EBS volume can’t be attached to multiple EC2s? Think again. Here's what you really need to know about EBS Multi-Attach and supported EC2 instances.

Morodolu Oluwafikunayomi — Sat, 19 Jul 2025 12:52:25 +0000

Morodolu Oluwafikunayomi

Jul 16 '25

Understanding EBS Multi-Attach and the EC2 Instances That Support It

#beginners #aws #tutorial #devplusplus

Comments

4 min read

im also a backend developer, check out my first page on django

Morodolu Oluwafikunayomi — Thu, 17 Jul 2025 16:05:12 +0000

Morodolu Oluwafikunayomi

Jul 12 '25

Getting Started with Django

#python #tutorial #backenddevelopment #beginners

Comments

3 min read

kindly check out my post guys as well the rest of my posts and give it your thought

Morodolu Oluwafikunayomi — Thu, 17 Jul 2025 16:03:13 +0000

Snapshots and AMIs in AWS, What They Are and How to Use Them

Morodolu Oluwafikunayomi ・ Jul 17

#beginners #aws #devplusplus #tutorial

Snapshots and AMIs in AWS, What They Are and How to Use Them

Morodolu Oluwafikunayomi — Thu, 17 Jul 2025 16:02:08 +0000

when using EC2 instances in AWS, understanding Snapshots and AMIs (Amazon Machine Images) can boost productivity and reduce resource consumption and ensure efficiently. Whether you're planning for disaster recovery, creating golden images for production, or just trying to replicate environments, this guide will walk you through what they are, how they differ, and how to actually create and use them.
What Is a Snapshot?
A Snapshot in AWS is a point-in-time backup of your EBS (Elastic Block Store) volume. Think of it like taking a photo of your disk, which you can later use to create new volumes or restore existing ones.
Use cases:

Backup and restore
Version control for data
Migrating data across regions
What Is an AMI?
An Amazon Machine Image (AMI) is a packaged template for launching EC2 instances in the sense that rather than going through the stress of creating a new instance and connecting to, AMI provide a means of shorting that creation process. It includes:
An operating system
Application server
Your application
EBS volume snapshot(s)
A Snapshot is of a disk. An AMI is like a full system image (disk + OS + config).
Use cases:
Launching pre-configured servers
Auto Scaling
Disaster recovery
Rapid cloning of environments

How to Create a Snapshot in AWS
From the Console:
remember to have created a volume initially, as a snapshot cannot work without a volume
check out my other post if don't know how to create a volume(EBS)

Go to EC2 Dashboard > Elastic Block Store > Volumes
Select the volume you want to snapshot.
Click Actions > Create Snapshot
Add a name and description.
Click Create Snapshot

now we have created a snapshot, let go ahead to delete our volume and recreate the volume from the snapshot
the volume i created was 1 Gib

the size of the volume you wish to create can be increased
When you create a snapshot of an EBS volume, AWS stores the data, not the disk size limitation. That means the snapshot contains the data blocks and metadata needed to recreate the original volume — but it doesn’t restrict you to the original size.

then go ahead to create the volume

the arrows show it was created from a snapshot and its id

How to Create an AMI from an EC2 Instance
From the Console:

Go to EC2 > Instances
Select your running instance.
Click Actions > Image and templates > Create image
Enter image name, description, and choose whether to reboot or not.
Click Create image
** Launching an EC2 from AMI**
Once your AMI is ready (it takes a few minutes), you can launch a new EC2 from it.
From Console:
Go to EC2 > AMIs
Select your AMI
Click Launch instance from image
Choose instance type, key pair, security group, etc.
Launch!
do note that AWS doesn't clean up your AMIs or snapshots automatically. You could be leaking storage $$$ if you don’t do it yourself.
_ Don’t forget to delete the snapshot(s) manually and deregistering the AMI doesn’t remove them._