DEV Community: Oluwaseun Olaleye

📘 LAMP Stack Implementation on AWS (EC2) > Linux | Apache | MySQL | PHP

Oluwaseun Olaleye — Fri, 08 Aug 2025 13:13:43 +0000

🧭 Introduction

The LAMP stack is a popular open-source web development platform used for hosting dynamic websites and web applications. It consists of four main components:

Linux: The operating system
Apache: The web server
MySQL: The relational database management system
PHP: The programming language (can also be replaced with Python or Perl)

This guide provides step-by-step instructions on how to set up and configure a LAMP stack on an AWS EC2 instance running Ubuntu 24.04 LTS.

🔧 Step 0: Preparing the Environment

Before we install the LAMP stack, we need to launch and prepare an EC2 instance.

✅ Tasks:

Launch EC2 Instance:
- Log in to your AWS Management Console.
- Navigate to EC2 > Instances > Launch Instance.
- Choose an Ubuntu 24.04 LTS AMI.
- Select the t2.micro instance type (Free Tier eligible).
- Choose a region closest to your location (e.g., eu-west-2a).
- Create a new key pair or use an existing one to SSH into the server.
- Open necessary ports (SSH - 22, HTTP - 80) in the Security Group.

Connect to the Instance: Use the .pem file and connect via SSH:

   ssh -i "your-key-name.pem" ubuntu@<your-ec2-public-ip>

Replace your-key-name.pem with your actual key file and with the public IP of your instance.

⚙️ Step 1: Update the Package Manager

After connecting to your EC2 instance, it is recommended to update the package manager to ensure that all packages are up to date.

🌐 Step 2: Install Apache2

Apache is a widely used open-source web server software that will serve your web pages to users over the internet.

⚙️ Enable and Check Apache Service

To ensure Apache starts automatically on system boot and to verify that it is running properly, use the following commands:

🌍 Step 3: Test Apache Externally (From Browser)
To confirm that Apache is accessible over the internet, open your browser and visit the public IP of your EC2 instance:
http://:80
🔍 Example:
http://13.53.216.202:80
You should see the Apache2 Ubuntu Default Page, indicating that your server is successfully serving web pages.

🗄️ Step 2: Install MySQL

To handle data for your web application, you need a Relational Database Management System (RDBMS).

In our case, we will install MySQL. MySQL is a widely used, open-source RDBMS that integrates seamlessly in PHP-based environments.

sudo apt install mysql-server -y

The -y flag automatically confirms the installation prompt.

Once installed, you can proceed to secure the database and start using it to create users, schemas, and tables for your web application.

🔐 Step 3: Log in to MySQL Console

To access the MySQL server as the administrative root user, run the following command:

sudo mysql

Running this command connects your shell to the MySQL server as the root user, thanks to the elevated privileges granted by sudo

🔑 Step 4: Set a Password for the Root User

Once inside the MySQL shell, assign a password to the root user and configure the authentication method to mysql_native_password.
or the purpose of this tutorial, we'll use PassWord.1 as the password.

🔐 Step 5: Log In to MySQL Console Using Root Password

After assigning a password to the root user, you should now log in using that password to verify access.

sudo mysql -p

The -p flag tells MySQL to prompt you for a password. You should see output like this:

Step 6 - Install PHP

Install php. So far, we have installed Apache to serve our web contents, and we installed Mysql to assist us store and manage our data. Now, we will install Php to process codes inorder to display dynamic content to the consumer user.

To set up php on our server, we are going to need the following installed:

php package
php-mysql (this is a PHP module that allows PHP to communicate with MySQL databases)
libapache2-mod-php _(this helps Apache to handle and understand PHP files) to get this all set up in the machine, run:

Confirm the PHP version by running:

php -v

Step 7 - Create a virtual host

_First, create a document directory for the new website you are about to create near the default web dir (/var/www/html).

sudo mkdir /var/www/projectlamp

Assign the ownership of the directory to the current user in the session

sudo chown -R $USER:$USER /var/www/projectlamp

2. Create a configuration file for your new website

sudo vim /etc/apache2/sites-available/projectlamp.conf

<VirtualHost *:80>
    ServerName projectlamp
    ServerAlias www.projectlamp 
    ServerAdmin webmaster@localhost
    DocumentRoot /var/www/projectlamp
    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Our site is ready, but Apache needs to serve content from the web root (i.e: /var/www/my_project_lamp), but it is empty. So we will now create an index.html file and then try to access our site via our public IP to test it

sudo echo 'Hello LAMP from hostname' $(TOKEN=`curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600"` && curl -H "X-aws-ec2-metadata-token: $TOKEN" -s http://169.254.169.254/latest/meta-data/public-hostname) 'with public IP' $(TOKEN=`curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600"` && curl -H "X-aws-ec2-metadata-token: $TOKEN" -s http://169.254.169.254/latest/meta-data/public-ipv4) > /var/www/projectlamp/index.html

8. Try to access your new website using your server's public IP

http://13.51.242.66

Step 5 - Enable PHP on the website.

sudo vi /etc/apache2/mods-enabled/dir.conf

Reload Apache You need to reload Apache so that the changes you have made would apply.

sudo systemctl reload apache2

3. Utilize the php test script to ensure that you have configured Apache to handle and process requests for PHP files.

Create a new file inside the custom web root folder (/var/www/my_project_lamp)

vi /var/www/projectlamp/index.php

4. Refresh the page and note down any change you observe

The page served here provides you with information about the server from the perspective of PHP. This is very useful in terms of debugging and to make sure that all necessary settings are applied correctly.

When you are done checking the information about the server through this page, It is very important that you remove the file you have created (i.e: index.php) so as to protect the sensitive information about the Php enviroment and the server. This can be repeated when necessary if the information is needed.

sudo rm /var/www/projectlamp/index.php

Conclusion

If you are considering/evaluating what stack to utilize in deploying a website and make it accessible to many people, the LAMP stack we just experienced is a very flexible, robust, and efficient stack to assist you in deploying your developed web applications.

To know how to set up, configure, and maintain a LAMP environment, kindly go through the guidelines stipulated in this documentation and it should help you know how to get the job done.

Deploying A Highly Available Web APP On AWS Using Terraform

Oluwaseun Olaleye — Tue, 20 May 2025 12:32:13 +0000

INTRODUCTION
In today's cloud-centric world, automating infrastructure deployment is crucial for efficiency, scalability, and reliability. Terraform, an Infrastructure as Code (IaC) tool, allows developers to define and provision cloud resources in a declarative manner. This article explores a Terraform script designed to deploy a scalable and secure web server infrastructure on AWS, including VPC setup, subnets, security groups, an EC2 instance, an Auto Scaling Group (ASG), and an Application Load Balancer (ALB).

By leveraging Terraform, I ensure consistent and repeatable deployments while minimizing manual errors. The script automates the creation of a highly available web server environment, making it ideal for production workloads.

PREREQUISITES

Before running this Terraform script, ensure the following:

AWS Account
AWS CLI & Credentials
Terraform Installed.

KEY DEFINITIONS
1. AWS Provider
The provider "aws" block configures Terraform to interact with AWS, specifying the desired region where resources will be deployed.

provider "aws" {
  region = var.region
}

2. RSA Key Pair
tls_private_key generates an RSA key pair for SSH access.

aws_key_pair uploads the public key to AWS.

local_file saves the private key locally for secure access.

resource "tls_private_key" "rsa" {
  algorithm = "RSA"
  rsa_bits  = 4096
} 

resource "aws_key_pair" "web_SERVER" {
  key_name   = var.key_pair_name
  public_key = tls_private_key.rsa.public_key_openssh
}

resource "local_file" "private_key" {
  content  = tls_private_key.rsa.private_key_pem
  filename = "${var.key_pair_name}.pem"
}

3. VPC & SUBNETS
VPC (aws_vpc): A logically isolated network with a defined CIDR block.

Public Subnets (aws_subnet public): Subnets with internet access via an Internet Gateway (IGW).

Private Subnets (aws_subnet private): Subnets without direct internet access, routed through a NAT Gateway.

data "aws_availability_zones" "available" {}

resource "aws_vpc" "web_VPC" {
  cidr_block           = var.vpc_cidr_block
  enable_dns_support   = true
  enable_dns_hostnames = true

  tags = {
    Name = var.vpc_name
  }
}

resource "aws_subnet" "public" {
  count                   = length(var.public_subnet_cidrs)
  vpc_id                  = aws_vpc.web_VPC.id
  cidr_block              = var.public_subnet_cidrs[count.index]
  availability_zone       = data.aws_availability_zones.available.names[count.index]
  map_public_ip_on_launch = true

  tags = {
    Name = "web_PUBLIC_${count.index}"
  }
}

resource "aws_subnet" "private" {
  count             = length(var.private_subnet_cidrs)
  vpc_id            = aws_vpc.web_VPC.id
  cidr_block        = var.private_subnet_cidrs[count.index]
  availability_zone = data.aws_availability_zones.available.names[count.index]

  tags = {
    Name = "web_PRIVATE_${count.index}"
  }
}

4. INTERNET & NAT GATEWAY
Internet Gateway (aws_internet_gateway): Enables public subnets to connect to the internet.

NAT Gateway (aws_nat_gateway): Allows private subnets to access the internet while remaining secure.

resource "aws_internet_gateway" "web_GW" {
  vpc_id = aws_vpc.web_VPC.id

  tags = {
    Name = var.internet_gateway_name
  }
}

resource "aws_eip" "nat" {
  domain     = "vpc"
  depends_on = [aws_internet_gateway.web_GW]
}

resource "aws_nat_gateway" "nat" {
  allocation_id = aws_eip.nat.id
  subnet_id     = aws_subnet.public[0].id
  depends_on    = [aws_internet_gateway.web_GW]

  tags = {
    Name = var.nat_gateway_name
  }
}

5. ROUTE TABLES & ASSOCIATIONS
Public Route Table (aws_route_table public): Routes traffic to the Internet Gateway.

Private Route Table (aws_route_table private): Routes traffic to the NAT Gateway.

Route Table Associations (aws_route_table_association): Links subnets to their respective route tables.

resource "aws_route_table" "public" {
  vpc_id = aws_vpc.web_VPC.id

  tags = {
    Name = var.public_route_table_name
  }
}

resource "aws_route_table" "private" {
  vpc_id = aws_vpc.web_VPC.id

  tags = {
    Name = var.private_route_table_name
  }
}

resource "aws_route" "public_internet_access" {
  route_table_id         = aws_route_table.public.id
  destination_cidr_block = "0.0.0.0/0"
  gateway_id             = aws_internet_gateway.web_GW.id
}

resource "aws_route" "private_nat_route" {
  route_table_id         = aws_route_table.private.id
  destination_cidr_block = "0.0.0.0/0"
  nat_gateway_id         = aws_nat_gateway.nat.id
}

resource "aws_route_table_association" "public_assoc" {
  count          = length(aws_subnet.public)
  subnet_id      = aws_subnet.public[count.index].id
  route_table_id = aws_route_table.public.id
}

resource "aws_route_table_association" "private_assoc" {
  count          = length(aws_subnet.private)
  subnet_id      = aws_subnet.private[count.index].id
  route_table_id = aws_route_table.private.id
}

6. SECURITY GROUP (aws_security_group)
Defines firewall rules to allow:

SSH (Port 22) from a specified IP range.

HTTP (Port 80) for web traffic.

All outbound traffic for updates and external communications.

resource "aws_security_group" "web_SG" {
  name        = var.security_group_name
  description = "Allow Database and SSH"
  vpc_id      = aws_vpc.web_VPC.id

  ingress {
    description = "Allow SSH"
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = [var.ssh_ingress_cidr]
  }

  ingress {
    description = "Allow HTTP"
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = [var.HTTP_access_cidr]  
  }

  egress {
    description = "Allow all outbound traffic"
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags = {
    Name = var.security_group_name
  }
}

7. EC2 INSTANCE (aws_instance)
Deploys an Ubuntu-based web server with Apache installed.

Uses user data to automate software installation and configuration.

resource "aws_instance" "web_server" {
  ami                    = var.instance_ami
  instance_type          = var.instance_type
  key_name               = aws_key_pair.web_SERVER.key_name
  subnet_id              = aws_subnet.public[0].id
  vpc_security_group_ids = [aws_security_group.web_SG.id]

  user_data = <<-EOF
              #!/bin/bash
              sudo apt update -y && sudo apt upgrade -y
              sudo apt install -y apache2
              sudo systemctl start apache2
              sudo systemctl enable apache2
              echo "Hello from Server $(hostname)" > /var/www/html/index.html
              EOF

  tags = {
    Name = "web-SERVER"
  }
}
output "web_server_public_ip" {
  value = aws_instance.web_server.public_ip
}

output "instance_dns_names" {
  value = [aws_instance.web_server.public_dns]
}

8. AUTO SCALING GROUP (ASG) & LAUNCH TEMPLATE
Launch Template (aws_launch_template): Defines the EC2 configuration for scaling.

ASG (aws_autoscaling_group): Maintains a desired number of instances across availability zones.

#Launch Template for Auto Scaling Group
resource "aws_launch_template" "web_launch_template" {
  name          = "web_server_template"
  image_id      = var.instance_ami
  instance_type = var.instance_type
  key_name      = aws_key_pair.web_SERVER.key_name

  network_interfaces {
    security_groups = [aws_security_group.web_SG.id]
  }

  tag_specifications {
    resource_type = "instance"
    tags = {
      Name = "web_server"
    }
  }
}

#Autoscaling group

resource "aws_autoscaling_group" "web_asg" {
  desired_capacity     = 2
  max_size             = 2
  min_size             = 2
  vpc_zone_identifier  = [for subnet in aws_subnet.public : subnet.id]

  launch_template {
    id      = aws_launch_template.web_launch_template.id
    version = "$Latest"
  }

  target_group_arns = [aws_lb_target_group.web_tg.arn]

  tag {
    key                 = "Name"
    value               = "web_server_asg"
    propagate_at_launch = true
  }
}

9. APPLICATION LOAD BALANCER (ALB)
ALB (aws_lb): Distributes traffic across multiple instances.

Target Group (aws_lb_target_group): Routes requests to healthy instances.

Listener (aws_lb_listener): Handles HTTP traffic on port 80.

#Application Load Balancer
resource "aws_lb" "web_lb" {
  internal                   = false
  load_balancer_type         = "application"
  security_groups            = [aws_security_group.web_SG.id]
  subnets                    = [for subnet in aws_subnet.public : subnet.id]
  enable_deletion_protection = false
}


#Target Group

resource "aws_lb_target_group" "web_tg" {
  name     = "web-target-group"
  port     = 80
  protocol = "HTTP"
  vpc_id   = aws_vpc.web_VPC.id

  health_check {
    path                = "/"
    interval            = 30
    timeout             = 5
    healthy_threshold   = 2
    unhealthy_threshold = 2
    matcher             = "200"
  }
}


#Listerner for Load Balancer
resource "aws_lb_listener" "web_lb_listener" {
  load_balancer_arn = aws_lb.web_lb.arn
  port              = 80
  protocol          = "HTTP"

  default_action {
    type             = "forward"
    target_group_arn = aws_lb_target_group.web_tg.arn
  }
}

CONCLUSION
This Terraform script provides a robust and automated way to deploy a scalable web server infrastructure on AWS. By defining resources such as VPCs, subnets, security groups, EC2 instances, and load balancers in code, we ensure consistency, reduce manual errors, and enable version-controlled infrastructure management.

The inclusion of Auto Scaling and Load Balancing enhances fault tolerance and high availability, making this setup ideal for production environments. With Terraform, infrastructure changes can be tracked, reviewed, and deployed efficiently, aligning with DevOps best practices.

How to Set Up MySQL client-server on AWS Using Terraform

Oluwaseun Olaleye — Wed, 14 May 2025 14:45:50 +0000

Introduction
In this guide, I will walk you through setting up MySQL Client-Server on AWS using Terraform. This setup involves creating a Virtual Private Cloud (VPC), subnets, a NAT gateway, EC2 instances, and security groups. Additionally, we will configure MySQL as a database on one instance, and a client instance to interact with it.

Prerequisites
Before we begin, ensure you have the following tools installed:

Terraform
AWS Account
AWS CLI: Configured and authenticated with your AWS credentials.

Steps
Step 1: Set Up the AWS Provider

We begin by configuring the AWS provider with your region.

provider "aws" {
  region = var.region
}

Step 2: Create an SSH Key Pair
We generate an RSA private key for SSH access to our instances.

resource "tls_private_key" "rsa" {
  algorithm = "RSA"
  rsa_bits  = 4096
}

resource "aws_key_pair" "MEAN_SERVER" {
  key_name   = var.key_pair_name
  public_key = tls_private_key.rsa.public_key_openssh
}

resource "local_file" "private_key" {
  content  = tls_private_key.rsa.private_key_pem
  filename = "${var.key_pair_name}.pem"
}

Step 3: Define the VPC and Subnets
Create a VPC and both public and private subnets to host the EC2 instances.

resource "aws_vpc" "MEAN_VPC" {
  cidr_block           = var.vpc_cidr_block
  enable_dns_support   = true
  enable_dns_hostnames = true
  tags = {
    Name = var.vpc_name
  }
}

resource "aws_subnet" "public" {
  count                   = length(var.public_subnet_cidrs)
  vpc_id                  = aws_vpc.MEAN_VPC.id
  cidr_block              = var.public_subnet_cidrs[count.index]
  availability_zone       = data.aws_availability_zones.available.names[count.index]
  map_public_ip_on_launch = true
  tags = {
    Name = "MEAN_PUBLIC_${count.index}"
  }
}

resource "aws_subnet" "private" {
  count             = length(var.private_subnet_cidrs)
  vpc_id            = aws_vpc.MEAN_VPC.id
  cidr_block        = var.private_subnet_cidrs[count.index]
  availability_zone = data.aws_availability_zones.available.names[count.index]
  tags = {
    Name = "MEAN_PRIVATE_${count.index}"
  }
}

Step 4: Set Up Internet and NAT Gateway
We create an Internet Gateway for public subnet access and a NAT Gateway for private subnet access.

resource "aws_internet_gateway" "MEAN_GW" {
  vpc_id = aws_vpc.MEAN_VPC.id
  tags = {
    Name = var.internet_gateway_name
  }
}

resource "aws_eip" "nat" {
  domain     = "vpc"
  depends_on = [aws_internet_gateway.MEAN_GW]
}

resource "aws_nat_gateway" "nat" {
  allocation_id = aws_eip.nat.id
  subnet_id     = aws_subnet.public[0].id
  depends_on    = [aws_internet_gateway.MEAN_GW]
  tags = {
    Name = var.nat_gateway_name
  }
}

resource "aws_route_table" "public" {
  vpc_id = aws_vpc.MEAN_VPC.id
  tags = {
    Name = var.public_route_table_name
  }
}

resource "aws_route_table" "private" {
  vpc_id = aws_vpc.MEAN_VPC.id
  tags = {
    Name = var.private_route_table_name
  }
}

resource "aws_route" "public_internet_access" {
  route_table_id         = aws_route_table.public.id
  destination_cidr_block = "0.0.0.0/0"
  gateway_id             = aws_internet_gateway.MEAN_GW.id
}

resource "aws_route" "private_nat_route" {
  route_table_id         = aws_route_table.private.id
  destination_cidr_block = "0.0.0.0/0"
  nat_gateway_id         = aws_nat_gateway.nat.id
}

resource "aws_route_table_association" "public_assoc" {
  count          = length(aws_subnet.public)
  subnet_id      = aws_subnet.public[count.index].id
  route_table_id = aws_route_table.public.id
}

resource "aws_route_table_association" "private_assoc" {
  count          = length(aws_subnet.private)
  subnet_id      = aws_subnet.private[count.index].id
  route_table_id = aws_route_table.private.id
}

resource "aws_security_group" "MEAN_SG" {
  name        = var.security_group_name
  description = "Allow Database and SSH"
  vpc_id      = aws_vpc.MEAN_VPC.id

Step 5: Configure Security Groups
The security group will allow SSH access and MySQL communication between the instances.

resource "aws_security_group" "MEAN_SG" {
  name        = var.security_group_name
  description = "Allow Database and SSH"
  vpc_id      = aws_vpc.MEAN_VPC.id

  ingress {
    description = "Allow SSH"
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = [var.ssh_ingress_cidr]
  }

  ingress {
    description = "Allow MySQL"
    from_port   = 3306
    to_port     = 3306
    protocol    = "tcp"
    cidr_blocks = [var.vpc_cidr_block]  # Allow internal access
  }
egress {
    description = "Allow all outbound traffic"
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags = {
    Name = var.security_group_name
  }
}

Step 6: Launch EC2 Instances
Now we launch two EC2 instances, one for the server and another as the client.

resource "aws_instance" "mean_server" {
  ami                    = var.instance_ami
  instance_type          = var.instance_type
  key_name               = aws_key_pair.MEAN_SERVER.key_name
  subnet_id              = aws_subnet.public[0].id
  vpc_security_group_ids = [aws_security_group.MEAN_SG.id]

  user_data = <<-EOF
              #!/bin/bash
              sudo apt update -y && sudo apt upgrade -y
              sudo apt install -y mysql-server
              sudo systemctl enable mysql
              sudo systemctl start mysql
              sudo mysql -e "CREATE USER 'client'@'%' IDENTIFIED WITH mysql_native_password BY 'NewU$er.3';"
              sudo mysql -e "CREATE DATABASE test_db;"
              sudo mysql -e "GRANT ALL ON test_db.* TO 'client'@'%' WITH GRANT OPTION;"
              sudo mysql -e "FLUSH PRIVILEGES;"
              sudo sed -i "s/^bind-address.*/bind-address = 0.0.0.0/" /etc/mysql/mysql.conf.d/mysqld.cnf
              sudo systemctl restart mysql
              EOF

  tags = {
    Name = "MEAN-SERVER"
  }
}
resource "aws_instance" "mean_client" {
  ami                    = var.instance_ami
  instance_type          = var.instance_type
  key_name               = aws_key_pair.MEAN_SERVER.key_name
  subnet_id              = aws_subnet.public[0].id
  vpc_security_group_ids = [aws_security_group.MEAN_SG.id]

  user_data = <<-EOF
              #!/bin/bash
              sudo apt update -y && sudo apt upgrade -y
              sudo apt install -y mysql-client
              EOF

  tags = {
    Name = "MEAN-CLIENT"
  }
}

output "mean_server_public_ip" {
  value = aws_instance.mean_server.public_ip
}

output "mean_client_public_ip" {
  value = aws_instance.mean_client.public_ip
}

output "instance_dns_names" {
  value = [aws_instance.mean_server.public_dns, aws_instance.mean_client.public_dns]
}

Step 7: Visiting Our Server from the Client
Now, from our MEAN Client, let us try to access our MEAN Server:
sudo mysql -u client -h 10.0.1.199 -p

Step 8: Playing in Our New Server (accessed from the client)
Let us now make sure we can actually do stuff in our server from our client:

First, let us see what we have:

Next, let show what I have in my terraform.tfvars and variable.tf

region                = "us-east-1"
key_pair_name         = "mean-server-key"

vpc_cidr_block        = "10.0.0.0/16"
vpc_name              = "MEAN_VPC"

public_subnet_cidrs   = ["10.0.1.0/24", "10.0.2.0/24"]
private_subnet_cidrs  = ["10.0.101.0/24", "10.0.102.0/24"]

internet_gateway_name     = "MEAN_IGW"
nat_gateway_name          = "MEAN_NAT"
public_route_table_name   = "MEAN_Public_RT"
private_route_table_name  = "MEAN_Private_RT"

security_group_name   = "MEAN_SG"

# Choose the appropriate AMI ID for your region 
instance_ami          = "ami-0f9de6e2d2f067fca"
instance_type         = "t2.micro"
ec2_instance_name     = "MEAN_EC2"

variable "region" {
  description = "AWS region to deploy into"
  type        = string
}

variable "vpc_cidr_block" {
  description = "CIDR block for the VPC"
  type        = string
}

variable "public_subnet_cidrs" {
  description = "List of CIDR blocks for public subnets"
  type        = list(string)
}

variable "private_subnet_cidrs" {
  description = "List of CIDR blocks for private subnets"
  type        = list(string)
}

variable "instance_ami" {
  description = "AMI ID for EC2 instance"
  type        = string
}

variable "instance_type" {
  description = "EC2 instance type"
  type        = string
}

variable "key_pair_name" {
  description = "Name for the AWS key pair"
  type        = string
}

variable "ec2_instance_name" {
  description = "Name tag for the EC2 instance"
  type        = string
}

variable "vpc_name" {
  description = "Name tag for the VPC"
  type        = string
}

variable "public_route_table_name" {
  description = "Name tag for public route table"
  type        = string
}

variable "private_route_table_name" {
  description = "Name tag for private route table"
  type        = string
}

variable "nat_gateway_name" {
  description = "Name tag for the NAT Gateway"
  type        = string
}

variable "internet_gateway_name" {
  description = "Name tag for Internet Gateway"
  type        = string
}

variable "security_group_name" {
  description = "Name for the Security Group"
  type        = string
}

variable "ssh_ingress_cidr" {
  description = "CIDR block allowed to SSH (port 22)"
  type        = string
  default     = "0.0.0.0/0"
}


variable "db_access_cidr" {
  description = "CIDR block allowed for DB(port 3306)"
  type = string
  default = "10.0.55.0/24"

}

Conclusion
This Terraform script automates the creation of a Server-Client on AWS, including networking, instances, and database setup. Copy and paste the script into your .tf file, modify the variables, and run terraform apply to deploy your infrastructure.

Automating Infrastructure Creation With IAC (Terraform)

Oluwaseun Olaleye — Mon, 14 Apr 2025 14:11:01 +0000

INTRODUCTION
This guide walks you through creating a fully functional custom VPC (Virtual Private Cloud) on AWS using Terraform. The configuration includes a VPC, internet gateway, public route table, and dynamically created public subnets distributed across availability zones.

✅ Prerequisites
Before you begin, ensure you have the following tools and configurations in place:

🛠️ Tools Installed

Terraform (v1.0 or above recommended)
AWS CLI (configured with appropriate credentials)
Code Editor (e.g., VS Code, Sublime Text)
AWS account

🔧 Provider Configuration

Initializes the AWS provider for Terraform, setting the region dynamically via a variable.

🌍 Fetching Availability Zones

Fetches the list of currently available Availability Zones in the region for resilient subnet placement.

🛠️ VPC Creation

🌐 Internet Gateway

Attaches an internet gateway to your VPC, enabling external internet access.

🗺️ Public Route Table

Creates a route table with an internet route (0.0.0.0/0) pointing to the IGW.

🧱 Dynamic Public Subnets
Dynamically provisions public subnets across multiple Availability Zones using CIDR subnetting.

🔁 Route Table Associations

Associates each public subnet with the public route table to ensure internet connectivity.

📦 Variables to Define
Add the following to your variables.tf file:

You can find and copy this code from my repository: https://github.com/heritageolaleye/terraform_demo

🎉 Conclusion
You now have a dynamic, production-ready AWS VPC setup that includes public subnets distributed across availability zones with internet access configured. This is a great foundation for hosting web applications, microservices, or any cloud-native infrastructure.

DEPLOYING WEB SERVER WITH TERRAFORM

Oluwaseun Olaleye — Fri, 21 Mar 2025 15:51:14 +0000

Introduction

This guide provides a step-by-step explanation of how to use Terraform to deploy an AWS EC2 instance with a security group that allows HTTP traffic. The configuration automates the setup of an Apache web server on the instance.

Prerequisites

Before running the Terraform script, ensure you have the following:

An AWS account.
Terraform installed on your system.
AWS CLI configured with appropriate credentials.

Terraform Script Breakdown

Below is the Terraform script used to create an EC2 instance and security group:

Provider Configuration

The provider block specifies AWS as the cloud provider and sets the region where the resources will be deployed.

Generating an RSA Key Pair
This generates a 4096-bit RSA private key, which will be used to access the EC2 instance securely.

Creating an AWS Key Pair
Terraform creates an AWS key pair using the public key from the RSA key.

Saving the Private Key Locally
This saves the private key to a local file named Demo.pem, which you will use to SSH into the instance.

Security Group Configuration

This security group allows HTTP (port 80) and SSH (port 22) inbound traffic from anywhere and allows all outbound traffic.

EC2 Instance Provisioning

AMI: The Amazon Machine Image (AMI) used for the instance.

Instance Type: Uses t2.micro, which is free-tier eligible.

Key Name: Uses the previously created key pair.

Security Group: Attaches the Demo security group.

Public IP: Enables a public IP for external access.

User Data: Installs and starts Apache web server on boot.

Tags: Tags the instance as Demo.

Dependencies: Ensures key pair is created before the instance.

Follow these steps to deploy the resources:

Initialize Terraform (downloads required provider plugins):

Preview the execution plan:

Apply the configuration (creates resources in AWS):

4. Verify the Instance:

Copy the public IP from the output or AWS Console.

Destroying the Infrastructure

To delete the created resources and avoid charges, run:

Conclusion

This Terraform script automates the deployment of an EC2 instance running an Apache web server. By using infrastructure as code, you can quickly set up and manage AWS resources efficiently.

HOSTING A FUNCTIONAL WEB APP ON VIRTUAL MACHINE

Oluwaseun Olaleye — Tue, 21 Jan 2025 11:05:55 +0000

USE CASE
I was tasked with deploying an application to a live server, ensuring high availability, scalability, and monitoring the application performance.

PREREQUISITES

Basic Linux Commands
Ubuntu Server
Custom Domain.
Basic Networking.

DEFINITION OF SERVICES

Virtual Private Cloud: This is a virtual networking environment where you can launch AWS resources.
Elastic Compute Cloud: It is a virtual machine that provides resizable compute capacity in the cloud.
Elastic Block Store: It is a block-level storage service that provides persistent storage for EC2 instances.
EBS Snapshot: It is a point-in-time copy of an EBS volume.
AWS CloudWatch: This provide data and insights about AWS resources and applications.
Auto Scaling Group: This automatically adjust the number of instances in the group based on changing workload demands, ensuring that your application has the necessary resources to handle increased traffic or demand.

VIRTUAL PRIVATE CLOUD (VPC)
Let's start with the networking aspect of our application. In AWS, we utilize a Virtual Private Cloud (VPC) to secure our infrastructure. Since cloud computing relies on shared public infrastructure, a VPC provides a secure, isolated environment for our application. This enables us to control incoming and outgoing traffic, ensuring the security and integrity of our website.

ELASTIC COMPUTE CLOUD

Next, we'll create an Amazon EC2 instance to host our application. On this instance, we'll install Nginx, a popular web server, and configure it to listen on port 80 (the default HTTP port). This will enable our application to serve web content to users.

Next, create a new key pair and utilize the custom VPC previously created. Ensure public IP assignment is enabled.

Next, update the security group created earlier by adding HTTP (port 80) and HTTPS (port 443) inbound rules. This will enable internet access to the web server.

Next, connect to the instance and Update the package list as well as installing Nginx web server software.

Next, enable the firewall to allow inbound traffic on port 80 (HTTP) to permit external access to the web server.

Next, download the HTML files and create a new directory at /var/www to host the website files.

Next, navigate to the /etc/nginx directory and create a symbolic link to the HTML files in the sites-available and sites-enabled directories.

"Next, remove the default Nginx page, as it is no longer needed since we have uploaded our customized HTML files.

Next is to update our DNS manager with the IP address of the instance. Kindly go to your domain provider and update the DNS Manager.

Next is to access the web app using the domain name instead of the IP address.

Next, let's install Certbot to secure the web application.

With the Certbot certificate in place, our web application now has an additional layer of security, safeguarding user information and preventing potential threats.

Elastic Block Store
Next, we will add additional storage to our instance to accommodate surges in traffic on our web application. We will create an EBS volume and attach it to the instance that was created. Firstly, let's check our default EBS Volume attached to our EC2 instance.

Let's leave everything in default and create our EBS volume. Next, let's attach the volume to the instance.

EBS SNAPSHOT
Let's create EBS snapshot, this will serve as a backup for the EBS volume.

Now, let's create another EC2 instance and attached it to the snapshot and connect via ssh.
Next, let's navigate to EBS Volume and create the snapshot.

AWS CLOUDWATCH
Now that the web application is secured, the next step is to set up CloudWatch to monitor its performance and trigger alarms when necessary. This will help us monitor Memory and Disk. Firstly, let's configure CloudWatch agent.

Next, let's create IAM role for the CloudWatch agent.

Now let attached the role created to the instance.

Next is to continue with the configuration for the CloudWatch.

AUTO SCALING GROUP.
Next is to set our auto-scaling for high availability and scalability. Firstly, let create a launch template that will be attached to the auto scaling.

Next, is to launch a new instance and attached the new image as AMI.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/x58v220lrtuxcii8pdvs.jpg

CONCLUSION
We successfully launched a fully functional web application leveraging the power of Amazon Web Services (AWS). By utilizing a Virtual Private Cloud (VPC) for secure networking, Elastic Block Store (EBS) for persistent storage, AWS CloudWatch for real-time monitoring, and Auto Scaling Groups for dynamic scalability, we ensured our web application is highly available, scalable, and resilient.

This deployment showcases the effectiveness of AWS services in building a robust and efficient web infrastructure, capable of handling diverse workloads and adapting to changing demands.

BUILDING AN EVENT DRIVEN GAME NOTIFICATION APP

Oluwaseun Olaleye — Fri, 10 Jan 2025 16:53:23 +0000

USE CASE
I was tasked with designing a Games Notification system, leveraging a serverless architecture. The solution utilizes an AWS Lambda function, integrates with an external API for data retrieval, and employs Amazon Simple Notification Service(SNS) for disseminating notifications.

PREREQUISITES

AWS free tier account
Knowledge on serverless service
python

DEFINITION OF SERVICES.

AWS Lambda Function: It enables seamless code execution without requiring manual infrastructure configuration.
Simple Notification Service: It enables the delivery of notifications to subscribed endpoints, such as email addresses, phone numbers, or application endpoints.
Event Bridge: It serves as a scheduler and event bus, triggering the Lambda function at specified intervals.

Amazon Simple Notification Service (SNS)
Let's create the SNS that will serve as a notification.

Kindly leaves everything at default and create topic.
Next, is to create subscription so as to allow it to send to our email.

Lambda Function
Firstly, let's create IAM role for the Lambda function to define its permissions and access to AWS services.

Now let's create our Lambda function since we have created our policies and role.

API KEY
I was able to get the free API key from https://sportsdata.io/cart/free-trial-confirmation/nba

Code testing has been completed successfully, and the SNS has sent a confirmation email as expected.

EVENTBRIDGE
Now, let's configure EventBridge to schedule the game notifications, ensuring timely and automated delivery.

Conclusion

We have successfully implemented a game notification system utilizing a serverless architecture, leveraging AWS Lambda, Amazon SNS, and EventBridge. The system integrates with an external API using Python, enabling seamless notification delivery to users.

WEATHER DASHBOARD

Oluwaseun Olaleye — Thu, 09 Jan 2025 09:55:48 +0000

USE CASE
My manager tasked me with creating a weather dashboard and storing it in an s3 bucket using weather API and python.

PREREQUISITES

Linux commands
Ubuntu server
AWS free tier account.
AWS CLI

Let's dive into it.

Firstly, I commenced by cloning a GitHub repository from https://github.com/ShaeInTheCloud/30days-weather-dashboard. This step enabled me to obtain a local copy of the repository's codebase.

Next. I installed all dependencies including Python. Then, I activated a virtual environment to isolate the project dependencies. With the virtual environment activated, i proceeded to install pip, Python package installer to facilitate the installation of additional project dependencies.

AWS Command Line Interface
Next, I installed the AWS CLI on my ubuntu server https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html. Additionally, I created a new IAM user and generated access keys for that user. I then utilized those credentials to configure the AWS CLI.

Next, I used the Weather API to retrieve current weather conditions and forecasts. After retrieving the weather data, I processed it into a JSON format and stored it in a python dictionary. I then used the boto3 library to upload the data to an S3 bucket.

After executing the code, I verified the creation of the S3 bucket and confirmed that it had been successfully established.

CONCLUSION
I successfully created a weather dashboard utilizing python and the Weather API , and subsequently stored the weather forecast data to amazon S3 bucket.

SETUP WORDPRESS WEBSITE USING LAMP STACK

Oluwaseun Olaleye — Thu, 28 Nov 2024 15:32:11 +0000

USE CASE
My manager has assigned me the task of creating a website. To accomplish this, I will be utilizing WordPress, a popular open-source content management system (CMS). WordPress enables users to create and manage their own websites efficiently.

With WordPress, I will be able to design, develop, and launch a fully functional website. The platform offers a user-friendly interface, customizable themes, and a vast array of plugins to extend its functionality.

PREREQUISITES

Basic Linux commands.
Ubuntu server.
Custom Domain.

DEFINITION OF SERVICES USED.

The following services are utilized in this tutorial:

Linux: An open-source operating system used as the foundation for our server.
Apache: A popular open-source web server software responsible for serving web pages.
MariaDB (instead of MySQL): An open-source relational database management system used for storing and managing data.
PHP: A server-side scripting language used for developing dynamic web applications and interacting with the database.

LINUX(UBUNTU SERVER)

To begin, we'll create an Ubuntu server in our AWS console.

Now that your Ubuntu server is launched, let's connect to it using SSH.

APACHE

Next is to install apache and start the service.

To confirm that Apache is correctly installed and configured on our server, we can access the default Apache webpage using our server's IP address.

DATABASE MANAGEMENT SYSTEM
Next is to install a open-source relational database management system on the server.

Now that we have installed MariaDB, let's configure it for WordPress.

Next, we'll create a database that will store and manage data for our WordPress website. To do this, we'll log in to the Mariadb server and create a new database, along with a user account that will be used to interact with the database.

Next is to create a new user for the database and grant all the privileges to the database for the user.

WORDPRESS
Now that we have configured MariaDB database, let's download and install WordPress.

To ensure proper functionality and security, we need to change the ownership of the WordPress files. This will allow the web server to read, write, and execute files as necessary.

PHP
Now that we have WordPress installed, let's configure it using a PHP script. This script will help us set up the database connection, create the necessary tables, and configure the basic settings for our WordPress site.

Let's enable the WordPress configuration file that was created.

Next is to disable the default Apache.

Let's install all the dependencies for WordPress.

Now that our server is set up, it can be accessed using the server's IP address or your custom domain name. The IP address can be mapped to the custom domain. In this guide, I will be using the IP address.

Kindly fill in all the database details as shown below.

Congratulations! You Have Successfully Installed WordPress website on your Ubuntu server using the LAMP (Linux, Apache, MySQL, PHP) stack.

VPC NETWORKING FUNDAMENTAL

Oluwaseun Olaleye — Sat, 16 Nov 2024 22:03:11 +0000

Introduction

In the pre-cloud computing era, establishing a network infrastructure required a plethora of hardware components, including Switches, Routers, Internet cables and RJ-45 connectors. These physical components enabled computers to communicate with each other and access the internet. Fast-forward to the cloud computing era, where virtualization has revolutionized networking. With Virtual Private Cloud (VPC), you can create a secure, isolated network environment without the need for physical hardware.

In this guide, I will walk you through the step-by-step process of creating a Virtual Private Cloud(VPC), including setting up Public and private subnets, Internet Gateway, Network ACLs (Access Control Lists) and Security Groups. By the end of this guide, you will have a fully functional VPC network, secure and ready for your applications.

Prerequisites
Before we begin, let's review the prerequisites;

AWS free-tier account
Basic understanding of networking concepts (IP address, subnets, routing).

Definition of Services

Virtual Private Cloud (VPC): Creates a virtual network dedicated to your AWS resources.
Subnets: Divide your VPC into smaller networks for organization and security.
Internet Gateway (IGW): Enables internet access to your VPC.
Security Groups (SG): Control inbound and outbound traffic to your instances.
Network Access Control Lists (NACL): Filter traffic to and from your subnets.

Let's Dive In
Let's begin by creating our Virtual Private Cloud (VPC), which will serve as the foundation for our network infrastructure. This VPC will provide a secure and isolated environment for our AWS resources.

Let's edit our VPC settings to enable DNS hostname resolution. This will allow instances within our VPC to receive a DNS hostname that corresponds to their private IP address.

Now that the VPC has been created, Next, we'll attach an Internet Gateway (IGW) to our VPC, enabling communication between our VPC and the internet.

INTERNET GATEWAY

Next, let's create 4 subnets within our VPC; Public Subnets will be attached to the Internet Gateway (IGW) for external communication and the Resources in these subnets can receive incoming traffic from the internet. We will also create private subnets which be attached to a Network Address Translation (NAT) gateway.

Next, let's create our NAT gateways for the private subnets.

NAT GATEWAYS

ROUTE TABLES
Now that we have our subnets and NAT gateways setup, let's create route tables to define traffic routing rules.

PUBLIC ROUTE TABLES

PRIVATE ROUTE TABLES

Network Access Control Lists
Now that we have our VPC, subnets, and route tables configured, let's create Network Access Control Lists (NACLs) to control inbound and outbound traffic at the subnet level.

EC2 And Security Groups
Now that we have our VPC, subnets, route tables, and NACLs configured, let's create EC2 instances and security groups to direct traffic.

Now that we have our EC2 instance up and running, let's connect to it and install Python.

SECURITY GROUPS

Now that we've updated the security group inbound rules to allow traffic on port 8000, you can access your application.

Congratulations, we have successfully designed and implemented a secure and scalable Virtual Private Cloud (VPC) architecture.

CREATING A STATIC WEBSITE WITH S3, Route 53, CloudFront and Certificate Manager.

Oluwaseun Olaleye — Sat, 26 Oct 2024 23:56:35 +0000

USE CASE
My manager has assigned me a project to design and deploy a scalable, highly available, and secure e-commerce website, ensuring optimal performance and user experience.

Prerequisites

AWS free account
Registered domain name

Introduction

Welcome to our comprehensive guide on building a scalable and secure multi-tier architecture using Amazon S3, Route 53, Certificate Manager, and CloudFront. In this article, I will walk you through each step, explaining the process in detail.

Definition of Services

Amazon S3 (Simple Storage Service): A highly durable, scalable, and secure object storage service for storing and retrieving data.
Amazon Route 53: A highly available and scalable Domain Name System (DNS) service that routes end users to Internet applications.
Certificate Manager:is a service offered by AWS that simplifies the provisioning, management, and deployment of Secure Sockets Layer/Transport Layer Security (SSL/TLS) certificates for AWS services.
CloudFront:Amazon CloudFront is a fast content delivery network service that securely distributes web content to users globally.

Let's dive in!
Firstly, let's create S3 bucket, this is where our website will be hosted.

I configured my s3 bucket name to be the same with my domain name.

We will uncheck "Block all public access option", allowing our website to be accessible to the public.

Now that our bucket is set up, we will proceed to upload our HTML file into it.

Now, let's configure our bucket permissions to ensure secure access.

Next, let's enable static website hosting for our s3 bucket.

The screenshot below reveals that our website is currently unencrypted; to address this, we will obtain and implement an SSL/TLS certificate.

CERTIFICATE MANAGER
Next, we will encrypt our website's data with an SSL/TLS certificate, protecting customer information.

ROUTE 53
We will host our Domain Name system(DNS) in Amazon route 53 and create a CNAME record.

We are going to add this Nameserver to our domain provider.

Next thing is to add the Certificate Manager CNAME to Route 53,ensuring secure domain validation and SSL/TLS certificate issuance for the domain.

CLOUDFRONT
Next, we will use our static website's URL as the origin domain for our CloudFront distribution.

Following the successful creation of our CloudFront distribution, we navigated back to Route 53 to configure an A record, associating our domain name with the CloudFront distribution.

Creating a Multi-Tier Architecture with S3, EC2, and RDS: A Step-by-Step Guide

Oluwaseun Olaleye — Mon, 21 Oct 2024 13:51:03 +0000

USE CASE
As a newly employed cloud engineer, I have been asked to create a multi-tier architecture. This architecture should consist of a website where HTML files can be stored and have an API to handle client requests. Additionally, I want to ensure that when we build our website, every user globally has the same experience, with minimal delay.

Introduction

Welcome to our comprehensive guide on building a scalable and secure multi-tier architecture using Amazon S3, EC2, and RDS. In this article, I will walk you through each step, explaining the process in detail.

Prerequisites

Before we begin, let's review the prerequisites:

Simple Storage Service (S3): Stores static assets (HTML, CSS, JavaScript, images, videos) and hosts your static website.
Elastic Compute Cloud (EC2): Runs web server software, handles HTTP requests, and processes dynamic content.
Relational Database Service (RDS): Stores sensitive and structured data as a backup.
CloudFront: A content delivery network (CDN) that distributes website content globally, reducing latency and improving performance.

Let's Dive into EC2

As we all know, EC2 is a web server. In our multi-tier architecture, this EC2 instance will serve as an API that collects client requests. Ec2 helps you to secure and scalable server to host your web Application

Step 1: Launch an EC2 Instance

Step 2: Choose Amazon Machine Image (AMI)

Step 3: Select Instance Type

Choose the right instance type for your workload.
Step 4: Create a Key Pair

Generate a secure key pair for SSH access.
A key pair is important because;

Ensures secure SSH access.
Protects your instance from unauthorized access.

Step 5: Click on Launch instance.

INTRODUCTION TO AMAZON RDS
Amazon Relational Database Service supports automatic failover and automated backups. This ensures you can handle data loss or downtime because of hardware failure. The database provides high availability and scalability for your application. We want our website to be available at every time and that is why we are introducing RDS. Let's create RDS, this will be connected to EC2.

Now that we have created our RDS, let install some packages.

Now let's create S3 Bucket for storage.

Step 2:Give our bucket a name and unchecked the public asset. We want our website to be accessible publicly.

We will leave everything at default and create our bucket.

Let's go ahead and click on the bucket we just created, what next is to upload our HTML file to S3.

Next thing is to configure S3 Bucket Policy: Define permissions for bucket access.

Let's enable static website and copy the URL and viola our website is life but we are not done yet.

We are going to copied the URL for our website and paste to a browser.

Let's Create IAM Role for EC2-S3 Connection : This is to establish secure communication between EC2 and S3.As earlier said, the EC2 will serve as API that collects client request.

Let's create IAM role that we be attached to EC2.

The role has been created, let go ahead and click on the role created and attached permission to it.

We want this role to have access to our S3, so we select S3 for "service"

Note: Kindly put the bucket ARN to all the permission under resource.

Now that we have created our role, let's assign the IAM role to EC2 instance that was created.

Let's connect to the EC2 instance and run some commands.

Introduce CloudFront:
Now let's dive in.
Like we said earlier, we want our users globally to be able to access our website within a minimum TTL. The website will be cached so that users can access it within a minimized time.

Let's copied our static website URL and copied it to the origin domain.

Let's Copy the distribution and paste it to a browser, it's going to direct us to our website.

.
Conclusion

Congratulations! You have successfully created a multi-tier architecture using S3, EC2, and RDS. This scalable and secure architecture will host your web application, store static assets, and distribute content globally.