DEV Community: Chibuzo Nwobia

Deploying a Highly Available Web App on AWS Using Terraform

Chibuzo Nwobia — Mon, 26 Aug 2024 00:02:21 +0000

Deploying a Highly Available Web App on AWS Using Terraform

Deploying a highly available web application on AWS is a crucial step in ensuring that your application can handle traffic, scale with demand, and remain resilient during failures. Terraform, as an Infrastructure as Code (IaC) tool, simplifies this process by enabling you to define and manage your infrastructure using code. In this article, we'll explore how to deploy a highly available web app on AWS using Terraform while adhering to the DRY (Don't Repeat Yourself) principle.

Why is High Availability Important?

High availability (HA) ensures that your application remains accessible even during failures or traffic spikes. This is achieved by distributing resources across multiple Availability Zones (AZs) and implementing mechanisms such as load balancing and auto-scaling.

Prerequisites

Before we begin, make sure you have the following:

AWS Account: An active AWS account with sufficient permissions.
Terraform Installed: Ensure Terraform is installed on your local machine. You can follow the installation guide here.
AWS CLI Installed and Configured: Set up the AWS CLI with your credentials. You can follow the installation guide here.

Step 1: Define Variables

Instead of hardcoding values throughout your Terraform configuration, we'll use variables to define reusable parameters. Create a file named variables.tf:

variable "region" {
  description = "AWS region"
  default     = "us-east-1"
}

variable "instance_type" {
  description = "EC2 instance type"
  default     = "t2.micro"
}

variable "ami_id" {
  description = "Amazon Machine Image ID"
  default     = "ami-066784287e358dad1"  # Replace with your preferred AMI
}

variable "key_name" {
  description = "Name of the EC2 key pair"
}

variable "vpc_id" {
  description = "VPC ID"
}

variable "subnet_ids" {
  description = "List of Subnet IDs"
  type        = list(string)
}

These variables will be used across different resources to avoid repetition and allow easy modifications. For example, changing the instance type or region in the future will only require updating the variable value.

Step 2: Create a Reusable Module for EC2 Instances

Modules in Terraform allow you to group and reuse resources. Let’s create a module for EC2 instances that can be reused for different parts of the infrastructure. Create a directory named modules/ec2_instance and add the following files:

`main.tf` (Inside `modules/ec2_instance`)

resource "aws_instance" "this" {
  ami           = var.ami_id
  instance_type = var.instance_type
  key_name      = var.key_name
  subnet_id     = var.subnet_id

  vpc_security_group_ids = var.security_group_ids

  user_data = <<-EOF
              #!/bin/bash
              sudo yum update -y
              sudo yum install -y httpd
              sudo systemctl start httpd
              sudo systemctl enable httpd
              echo "Hello from $(hostname -f)" > /var/www/html/index.html
            EOF

  tags = var.tags
}

`variables.tf` (Inside `modules/ec2_instance`)

variable "ami_id" {
  description = "AMI ID for the EC2 instance"
}

variable "instance_type" {
  description = "Instance type"
}

variable "key_name" {
  description = "Name of the key pair"
}

variable "subnet_id" {
  description = "Subnet ID"
}

variable "security_group_ids" {
  description = "List of security group IDs"
  type        = list(string)
}

variable "tags" {
  description = "Tags for the instance"
  type        = map(string)
}

Now, this module can be reused for deploying EC2 instances across different AZs, which is key for high availability.

Step 3: Create a VPC and Networking Resources

To ensure high availability, we need to set up a Virtual Private Cloud (VPC) with multiple subnets across different Availability Zones. Create a file named network.tf:

provider "aws" {
  region = var.region
}

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
  tags = {
    Name = "main-vpc"
  }
}

resource "aws_subnet" "subnet_a" {
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.1.0/24"
  availability_zone = "${var.region}a"

  tags = {
    Name = "subnet-a"
  }
}

resource "aws_subnet" "subnet_b" {
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.2.0/24"
  availability_zone = "${var.region}b"

  tags = {
    Name = "subnet-b"
  }
}

resource "aws_internet_gateway" "gw" {
  vpc_id = aws_vpc.main.id

  tags = {
    Name = "main-gateway"
  }
}

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

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.gw.id
  }

  tags = {
    Name = "public-route-table"
  }
}

resource "aws_route_table_association" "a" {
  subnet_id      = aws_subnet.subnet_a.id
  route_table_id = aws_route_table.public.id
}

resource "aws_route_table_association" "b" {
  subnet_id      = aws_subnet.subnet_b.id
  route_table_id = aws_route_table.public.id
}

This configuration creates a VPC, subnets across different AZs, an Internet Gateway, and a route table to ensure public access to the instances.

Step 4: Deploy Highly Available EC2 Instances

Now, let's deploy EC2 instances across multiple subnets using the module we created. In your main Terraform configuration file (main.tf), include the following:

module "web_server_a" {
  source              = "./modules/ec2_instance"
  ami_id              = var.ami_id
  instance_type       = var.instance_type
  key_name            = var.key_name
  subnet_id           = aws_subnet.subnet_a.id
  security_group_ids  = [aws_security_group.web_sg.id]
  tags = {
    Name = "web-server-a"
  }
}

module "web_server_b" {
  source              = "./modules/ec2_instance"
  ami_id              = var.ami_id
  instance_type       = var.instance_type
  key_name            = var.key_name
  subnet_id           = aws_subnet.subnet_b.id
  security_group_ids  = [aws_security_group.web_sg.id]
  tags = {
    Name = "web-server-b"
  }
}

Here, we’re deploying two EC2 instances across two different subnets (Availability Zones) using the same module, which adheres to the DRY principle.

Step 5: Set Up a Load Balancer

To achieve high availability, you need to distribute traffic between these instances. We’ll use an Application Load Balancer (ALB) to manage incoming traffic. Add the following to main.tf:

resource "aws_lb" "app_lb" {
  name               = "app-lb"
  internal           = false
  load_balancer_type = "application"
  security_groups    = [aws_security_group.web_sg.id]
  subnets            = [aws_subnet.subnet_a.id, aws_subnet.subnet_b.id]

  tags = {
    Name = "app-lb"
  }
}

resource "aws_lb_target_group" "app_tg" {
  name     = "app-tg"
  port     = 80
  protocol = "HTTP"
  vpc_id   = aws_vpc.main.id

  health_check {
    path = "/"
    port = "80"
  }

  tags = {
    Name = "app-tg"
  }
}

resource "aws_lb_listener" "app_listener" {
  load_balancer_arn = aws_lb.app_lb.arn
  port              = "80"
  protocol          = "HTTP"
  default_action {
    type             = "forward"
    target_group_arn = aws_lb_target_group.app_tg.arn
  }

  tags = {
    Name = "app-listener"
  }
}

resource "aws_lb_target_group_attachment" "a" {
  target_group_arn = aws_lb_target_group.app_tg.arn
  target_id        = module.web_server_a.aws_instance.this.id
  port             = 80
}

resource "aws_lb_target_group_attachment" "b" {
  target_group_arn = aws_lb_target_group.app_tg.arn
  target_id        = module.web_server_b.aws_instance

.this.id
  port             = 80
}

Explanation:

Load Balancer: The aws_lb resource creates an Application Load Balancer that distributes traffic across multiple EC2 instances.
Target Group: The aws_lb_target_group resource defines a group of targets (EC2 instances) that the load balancer directs traffic to.
Listener: The aws_lb_listener resource listens for incoming traffic on port 80 and forwards it to the target group.
Target Group Attachments: The aws_lb_target_group_attachment resources associate the EC2 instances (deployed in different subnets) with the target group.

Step 6: Security Groups

To allow traffic, you need to define security groups. Here’s an example that permits HTTP and SSH traffic:

resource "aws_security_group" "web_sg" {
  name        = "web-sg"
  description = "Allow HTTP and SSH traffic"
  vpc_id      = aws_vpc.main.id

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags = {
    Name = "web-sg"
  }
}

Step 7: Initialize and Deploy

Once your configuration files are in place, follow these steps to deploy your infrastructure:

Initialize Terraform:

   terraform init

Review and Apply the Configuration:

   terraform apply --auto-approve

Terraform will now create the infrastructure, including the VPC, subnets, EC2 instances, load balancer, and security groups.

Step 8: Verify the Deployment

After the deployment is complete, Terraform will output the public DNS of your load balancer. You can access your web application by visiting the load balancer’s DNS name in your browser:

http://<load_balancer_dns_name>

You should see a message like "Hello from hostname" indicating that your highly available web app is up and running.

Step 9: Clean Up Resources

When you're done testing, make sure to clean up the resources to avoid incurring unnecessary costs:

terraform destroy --auto-approve

Conclusion

Deploying a highly available web application on AWS using Terraform is a powerful approach to ensuring scalability and resilience. By applying the DRY principle, you reduce redundancy in your Terraform code, making it more manageable and easier to modify. This guide has walked you through creating a VPC, subnets across multiple availability zones, EC2 instances using reusable modules, and an Application Load Balancer to distribute traffic. With Terraform's automation capabilities, your infrastructure is ready to handle production-level workloads efficiently.

Using Terraform to deploy a basic web server on AWS

Chibuzo Nwobia — Wed, 21 Aug 2024 15:30:32 +0000

Introduction:

Deploying a web server on AWS using Terraform offers a powerful way to automate infrastructure management. By defining your infrastructure as code, you can easily create, update, and manage AWS resources. This guide will walk you through the step-by-step process of setting up Terraform, configuring AWS, and deploying a basic web server. Whether you're new to Terraform or looking to refine your skills, this guide provides clear instructions to help you get started.

To deploy a basic web server on AWS using Terraform follow the steps below:

Step 1: Install Terraform and AWS CLI

Ensure Terraform and AWS CLI are installed on your system and configured with your AWS credentials. If not, you can install and configure them using these commands:

Install Terraform: ```bash

sudo apt-get update && sudo apt-get install -y gnupg software-properties-common curl
curl -fsSL https://apt.releases.hashicorp.com/gpg | sudo apt-key add -
sudo apt-add-repository "deb [arch=amd64] https://apt.releases.hashicorp.com $(lsb_release -cs) main"
sudo apt-get update && sudo apt-get install terraform


- **Install AWS CLI:**
  ```bash


  sudo apt-get install awscli
  aws configure

Step 2: Create the Terraform Configuration

Create a directory for your Terraform configuration files and navigate to it:



mkdir terraform-web-server
cd terraform-web-server

Now, create a main.tf file with the following content:



# Specify the AWS provider
provider "aws" {
  region = "us-east-1"  # Replace with your desired region
}

# Create a Security Group to allow HTTP and SSH access

resource "aws_security_group" "web_sg" {
  name        = "web-sg"
  description = "Allow HTTP and SSH inbound traffic"

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

# Create an EC2 instance
variable "key_pair_name" {
  description = "The name of the key pair to use fr the EC2 insance"
  type        = string
}

resource "aws_instance" "web_server" {
  ami           = "ami-066784287e358dad1" 
  instance_type = "t2.micro"
  key_name      = var.key_pair_name  # Replace with your key pair

  # Use the security group

  vpc_security_group_ids = [aws_security_group.web_sg.id]

  # User data to install a basic web server
  user_data = <<-EOF
              #!/bin/bash
              sudo yum update -y
              sudo yum install -y httpd
              sudo systemctl start httpd
              sudo systemctl enable httpd
              echo "Hello, Chibuzo's demo page!" > /var/www/html/index.html
            EOF

  tags = {
    Name = "Terraform-Web-Server"
  }
}

# Output the public IP of the instance

output "instance_public_ip" {
  value = aws_instance.web_server.public_ip
}

Step 3: Initialize Terraform

Run the following command to initialize your Terraform working directory:



terraform init

Step 4: Apply the Terraform Configuration

Run the following command to create the resources defined in your configuration:



terraform apply --auto-approve

--auto-approve automatically approves the applied configuration hence reducing the need to make a user input.

Step 5: Access the Web Server

Once the deployment is complete, Terraform will output the public IP of the EC2 instance.

You can access the web server by visiting http://<instance_public_ip> in your web browser. You should see a message saying "Hello, Chibuzo's demo page!".

Step 6: Clean Up Resources

When you're done, you can destroy the resources created by Terraform using the following command:



terraform destroy --auto-approve

Terraform will now remove all the resources it created.

If in the process of trying to create an instance, you do not have a valid key-pair, you can create one using the following commands:

How to Create a Key Pair

Via AWS CLI: You can also create a key pair using the AWS CLI:



   aws ec2 create-key-pair --key-name my-key-pair --query 'KeyMaterial' --output text > my-key-pair.pem

This will create a key pair named my-key-pair and save the private key to a file named my-key-pair.pem.

Make sure the private key file (my-key-pair.pem) is accessible and has the correct permissions (e.g., chmod 400 my-key-pair.pem) for SSH access.

Conclusion:

With your web server successfully deployed using Terraform, you've taken a significant step in automating infrastructure management. From installing Terraform and AWS CLI to configuring security groups and launching an EC2 instance, you now have the knowledge to manage cloud infrastructure efficiently. By following the cleanup steps, you can also ensure that resources are properly decommissioned when no longer needed. This approach not only streamlines your workflow but also enhances the scalability and reliability of your deployments.

Step-by-Step Guide to Setting Up Terraform, AWS CLI, and Your AWS Environment.

Chibuzo Nwobia — Mon, 19 Aug 2024 23:44:00 +0000

Setting up Terraform, AWS CLI, and configuring your AWS environment on Windows Subsystem for Linux (WSL) involves several steps. Below is a detailed step-by-step guide to help you get started.

Step 1: Set Up Windows Subsystem for Linux (WSL)

Install WSL:
- Open PowerShell as Administrator and run:
```
 wsl --install
```

This command installs WSL and the latest Ubuntu distribution by default. You can choose a different distribution if you prefer.

Restart Your System:
- After installation, restart your computer.
Open WSL:
- Once your system restarts, open the WSL terminal by typing wsl in the Windows search bar.
Update and Upgrade Your Distribution:
- In the WSL terminal, update your package lists and upgrade installed packages:
```
 sudo apt update && sudo apt upgrade -y
```

Step 2: Install Terraform on WSL

Install the HashiCorp GPG Key:
- Run the following command to add the HashiCorp GPG key:
```
 curl -fsSL https://apt.releases.hashicorp.com/gpg | sudo apt-key add -
```

Add the HashiCorp Linux Repository:

Add the official Terraform repository to your system:

 sudo apt-add-repository "deb [arch=amd64] https://apt.releases.hashicorp.com $(lsb_release -cs) main"

Install Terraform:
- Now, update your package list again and install Terraform:
```
 sudo apt update && sudo apt install terraform
```
Verify the Installation:
- Check that Terraform is installed correctly:
```
 terraform -v
```

This should return the installed version of Terraform.

Step 3: Install AWS CLI on WSL

Download the AWS CLI Installer:
- Download the latest version of the AWS CLI using the following command:
```
 curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
```

Unzip the Installer:

Unzip the downloaded file:

 sudo apt install unzip
 unzip awscliv2.zip

Install the AWS CLI:
- Run the install script:
```
 sudo ./aws/install
```
Verify the Installation:
- Confirm the AWS CLI is installed:
```
 aws --version
```

This should return the installed version of AWS CLI.

Step 4: Configure Your AWS Environment

Configure AWS CLI:
- Set up your AWS credentials by running:
```
 aws configure
```

You'll be prompted to enter your:
- AWS Access Key ID
- AWS Secret Access Key
- Default region name (e.g., us-east-1)
- Default output format (e.g., json)

Test the Configuration:
- To verify your configuration, you can run a simple AWS command, like listing your S3 buckets:
```
 aws s3 ls
```

Step 5: Set Up Your AWS Environment Using Terraform

Create a Directory for Your Terraform Project:
- Navigate to your working directory and create a new directory for your Terraform files:
```
 mkdir 30-day-terraform
 cd 30-day-terraform
```
Create a Terraform Configuration File:
- Create a new file named main.tf:
```
 nano main.tf
```

Add your Terraform configuration. For example, to create an S3 bucket:

 provider "aws" {
   region = "us-east-1"
 }

 resource "aws_s3_bucket" "my_bucket" {
   bucket = "demo_bucket"
   acl    = "private"
 }

Initialize Terraform:
- Initialize your Terraform workspace, which downloads the necessary plugins:
```
 terraform init
```
Validate the Configuration:
- Ensure your configuration files are correct:
```
 terraform validate
```
Plan the Infrastructure Deployment:
- Generate an execution plan, showing what actions Terraform will take:
```
 terraform plan
```
Apply the Configuration:
- Deploy the infrastructure by applying the configuration:
```
 terraform apply --auto-approve
```

using the --auto-approve would prevent Terraform from asking for confirmation before proceeding.

Verify the Deployment:
- Once the apply process is complete, you can verify the resources have been created using the AWS CLI or the AWS Management Console.

Step 6: Clean Up Resources

Destroy the Infrastructure:
- When you're done, you can clean up the AWS resources created by Terraform by running:
```
 terraform destroy --auto-approve
```

using the --auto-approve would prevent Terraform from asking for confirmation before proceeding.

Conclusion

By following these steps, you've successfully set up Terraform, AWS CLI, and configured your AWS environment using WSL. You can now manage your AWS infrastructure using Terraform, enabling a consistent and automated approach to infrastructure provisioning.

What is Infrastructure as Code (IaC) and Why It's Transforming DevOps

Chibuzo Nwobia — Mon, 19 Aug 2024 20:00:09 +0000

Infrastructure as Code (IaC) is a practice in IT and DevOps that involves managing and provisioning computing infrastructure through machine-readable scripts or code, rather than through manual processes or interactive configuration tools. IaC is a key component of modern DevOps practices, enabling teams to automate the setup, deployment, and management of infrastructure in a consistent and reliable way.
What is Infrastructure as Code (IaC)?

Automation of Infrastructure: IaC allows the entire infrastructure, including servers, networks, databases, and other components, to be described and managed as code. This can include the configuration of operating systems, the setup of services, and the deployment of applications.

Declarative and Imperative Approaches: IaC scripts can be written in a declarative style, where the desired state of the infrastructure is defined, and the system figures out how to achieve that state, or in an imperative style, where the exact steps to configure the infrastructure are specified.

Tools and Technologies: Common IaC tools include Terraform, AWS CloudFormation, Ansible, Puppet, and Chef. These tools allow for the automation of infrastructure deployment across various environments (development, staging, production) with minimal manual intervention.

Why IaC is Transforming DevOps

Consistency and Repeatability:
    Avoids Configuration Drift: With IaC, the infrastructure setup is defined in code, ensuring that environments remain consistent over time. This reduces the likelihood of configuration drift, where servers or services diverge from their intended configurations due to manual changes.
    Environment Replication: Developers can replicate the same environment across different stages (development, testing, production) with ease, reducing "it works on my machine" issues.

Speed and Efficiency:
    Rapid Provisioning: IaC enables rapid provisioning of infrastructure, allowing teams to deploy environments in minutes or hours rather than days or weeks.
    Automated Updates: Changes to the infrastructure can be deployed quickly and consistently across environments using automated pipelines.

Version Control and Documentation:
    Infrastructure Versioning: Just like application code, IaC scripts can be stored in version control systems (like Git), enabling tracking of changes over time, rollback to previous versions, and collaborative development.
    Self-Documenting Infrastructure: The code itself serves as documentation for how the infrastructure is configured, making it easier for new team members to understand the setup.

Improved Collaboration:
    DevOps Alignment: IaC bridges the gap between development and operations teams by allowing them to work together on infrastructure using familiar coding practices and tools.
    Shift-Left Approach: Developers can define infrastructure as part of the application development process, catching issues earlier in the software development lifecycle.

Scalability and Flexibility:
    Easily Scalable: Infrastructure can be easily scaled up or down by modifying the IaC scripts and redeploying, making it easier to handle varying loads.
    Multi-Cloud and Hybrid Deployments: IaC supports the deployment of infrastructure across multiple cloud providers or a combination of on-premises and cloud environments.

Cost Management:
    Optimized Resource Usage: By automating the provisioning and de-provisioning of resources, IaC helps in managing and optimizing the use of cloud resources, potentially reducing costs.
    Infrastructure Audits: Since the infrastructure is defined in code, it's easier to audit and optimize for cost and performance.

Conclusion

Infrastructure as Code (IaC) is revolutionizing the way infrastructure is managed in DevOps. By treating infrastructure as software, IaC brings consistency, speed, and flexibility to IT operations, enabling teams to deploy and manage complex environments efficiently. This transformation allows organizations to deliver applications faster, with higher quality, and at lower cost, all while maintaining robust control over their infrastructure.

Brief Introduction

Chibuzo Nwobia — Mon, 19 Aug 2024 08:57:49 +0000

Hello every one, my name is Nwobia chibuzo, An Air-traffic controller pivoting into the devops space currently in Alt-school Africa currently in the cloud engineering track. starting the 30 day Terraform challenge because I want to gain insight to this wonderful tool as an aspiring devops/ cloud engineer I intend to be proficient using this tool by the end of the 30 days

DEV Community: Chibuzo Nwobia

Deploying a Highly Available Web App on AWS Using Terraform

Deploying a Highly Available Web App on AWS Using Terraform

Why is High Availability Important?

Prerequisites

Step 1: Define Variables

Step 2: Create a Reusable Module for EC2 Instances

main.tf (Inside modules/ec2_instance)

variables.tf (Inside modules/ec2_instance)

Step 3: Create a VPC and Networking Resources

Step 4: Deploy Highly Available EC2 Instances

Step 5: Set Up a Load Balancer

Explanation:

Step 6: Security Groups

Step 7: Initialize and Deploy

Step 8: Verify the Deployment

Step 9: Clean Up Resources

Conclusion

Using Terraform to deploy a basic web server on AWS

Introduction:

Step 1: Install Terraform and AWS CLI

Step 2: Create the Terraform Configuration

Step 3: Initialize Terraform

Step 4: Apply the Terraform Configuration

Step 5: Access the Web Server

Step 6: Clean Up Resources

How to Create a Key Pair

Conclusion:

Step-by-Step Guide to Setting Up Terraform, AWS CLI, and Your AWS Environment.

Step 1: Set Up Windows Subsystem for Linux (WSL)

Step 2: Install Terraform on WSL

Step 3: Install AWS CLI on WSL

Step 4: Configure Your AWS Environment

Step 5: Set Up Your AWS Environment Using Terraform

Step 6: Clean Up Resources

Conclusion

What is Infrastructure as Code (IaC) and Why It's Transforming DevOps

Brief Introduction

`main.tf` (Inside `modules/ec2_instance`)

`variables.tf` (Inside `modules/ec2_instance`)