Modern cloud applications are not built on a single server anymore. They are designed to be highly available, scalable, and resilient. In this project, I built a production-style web tier on AWS using Terraform that distributes traffic across multiple servers, scales automatically, and supports rolling updates with minimal downtime.

This assignment is a continuation of multi-environment Terraform concepts and focuses on building a real-world web architecture using Infrastructure as Code.

Project Objective

The goal of this project was to design and deploy a highly available web tier using Terraform.

The infrastructure includes:

• 2 EC2 instances across different Availability Zones

• Application Load Balancer (ALB)

• Auto Scaling Group (ASG)

• Launch Template

• CloudWatch alarms for scaling

• Rolling updates for zero/minimal downtime

• Remote state using S3

• State locking using DynamoDB

Why Highly Available Architecture Matters

A basic setup looks like this:

User → EC2

If that EC2 instance fails, the application goes down.

A highly available setup looks like this:

User
 ↓
Application Load Balancer
 ↓
Auto Scaling Group
 ↓
EC2 (AZ-1)
EC2 (AZ-2)

This design ensures:

• No single point of failure

• Traffic is distributed

• Failed instances are replaced automatically

• Application remains accessible

Project Structure

Asignment-2/
├── modules/
│   ├── network/
│   ├── security/
│   ├── alb/
│   └── asg/
└── environments/
    └── dev/

The project is divided into:

• Modules → reusable infrastructure components

• Environment folder → actual deployment configuration

Core Terraform Concepts Used

Infrastructure as Code

Infrastructure is written as code instead of manually creating resources in AWS.

Terraform reads .tf files and creates resources automatically.

Modules

Modules are reusable blocks of Terraform code.

This project uses modules for:

• Network

• Security

• Load Balancer

• Auto Scaling

Instead of repeating code, modules are written once and reused.

Remote Backend

Terraform state is stored in an S3 bucket instead of locally.

This ensures:

• State is not lost

• Multiple users can collaborate

• Infrastructure is tracked centrally

State Locking

DynamoDB is used to lock Terraform state.

This prevents multiple users from running Terraform at the same time and breaking the infrastructure state.

Step-by-Step Architecture Breakdown

1. Network Layer

The network module creates:

• VPC

• Internet Gateway

• 2 public subnets in different AZs

• Route table

Example:

resource "aws_vpc" "this" {
  cidr_block = var.vpc_cidr
}

Each environment gets its own isolated network.

2. Security Layer

Two security groups are created:

ALB Security Group

• Allows HTTP (port 80) from the internet

EC2 Security Group

• Allows HTTP only from ALB

• Allows SSH from trusted IP

This ensures:

User → ALB → EC2

Users cannot directly access EC2 instances.

3. Load Balancer Layer

The Application Load Balancer:

• Receives traffic from users

• Distributes traffic across EC2 instances

• Performs health checks

Example:

resource "aws_lb" "this" {
  load_balancer_type = "application"
}

Target Group

Defines backend servers:

resource "aws_lb_target_group" "this" {
  port     = 80
  protocol = "HTTP"
}

Listener

Handles incoming requests:

resource "aws_lb_listener" "http" {
  port     = 80
  protocol = "HTTP"
}

4. Compute Layer (Auto Scaling)

Launch Template

Defines how EC2 instances should be created:

resource "aws_launch_template" "this" {
  image_id      = var.ami_id
  instance_type = var.instance_type
}

User Data Script

Automatically installs Nginx and creates a webpage:

apt-get install -y nginx

This means EC2 instances become web servers automatically.

Auto Scaling Group

Controls EC2 instances:

resource "aws_autoscaling_group" "this" {
  min_size         = 2
  desired_capacity = 2
  max_size         = 4
}

This ensures:

• At least 2 instances are always running

• New instances are added when needed

• Unhealthy instances are replaced

5. CloudWatch Scaling

Scale Out

threshold = 70

If CPU > 70% → add instance

Scale In

threshold = 30

If CPU < 30% → remove instance

This allows automatic scaling based on load.

6. Rolling Updates (Zero Downtime)

Rolling updates replace instances gradually.

Example:

instance_refresh {
  strategy = "Rolling"
}

Flow:

New instance created
Health check passes
Old instance removed
Repeat

This avoids downtime during updates.

Environment Configuration

All modules are connected in:

environments/dev/main.tf

Example:

module "network" {
  source = "../../modules/network"
}

Variables are defined in:

terraform.tfvars

Example:

environment      = "dev"
instance_type    = "t2.micro"
desired_capacity = 2

Terraform Workflow

terraform init
terraform fmt
terraform validate
terraform plan
terraform apply

After deployment, Terraform outputs:

alb_dns_name

Open it in browser:

http://ALB-DNS

You will see the web page served by EC2 instances.

Scaling in Action

• Refresh the page multiple times

• Different instance IDs may appear

• This shows traffic is distributed

Under load:

• ASG adds instances

• ALB routes traffic

• System scales automatically

Security Best Practices

For real production:

• Restrict SSH to your IP

• Use private subnets for EC2

• Enable HTTPS on ALB

• Apply least privilege IAM roles

• Encrypt S3 backend

• Avoid storing secrets in code

Cleanup

To avoid AWS charges:

terraform destroy

Skills Demonstrated

This project demonstrates:

• Terraform architecture design

• AWS networking fundamentals

• High availability design

• Load balancing

• Auto Scaling

• CloudWatch monitoring

• Rolling updates

• Infrastructure as Code

• DevOps workflow using Git

Portfolio Value

This project is a strong portfolio example because it shows real-world thinking.

Instead of just creating a server, it demonstrates:

• Reliability

• Scalability

• Automation

• Clean architecture

This aligns with expectations for:

• DevOps Engineers

• Cloud Engineers

• Platform Engineers

• Site Reliability Engineers

Final Thoughts

This assignment shows how modern cloud systems are designed.

It moves beyond basic infrastructure and introduces concepts like:

• High availability

• Scaling

• Load balancing

• Automation

In simple terms:

You built a system where your application can survive failures, handle more users, and update safely — all using Terraform code.

This is the foundation of real-world DevOps.