Deploying Across Regions with Terraform

Why Deploy in Multiple Regions?

Deploying EC2 instances across multiple AWS regions provides several benefits:

High Availability: If a single region experiences an outage, your application can still be accessible from other regions.
Reduced Latency: Serving your users from a region closer to them can reduce latency and improve the user experience.
Disaster Recovery: In the event of a catastrophic failure, having infrastructure in different regions can enable quick recovery and minimize downtime.

Prerequisites

Before we dive into the deployment process, make sure you have the following:

AWS Account: Access to an AWS account with appropriate permissions to create EC2 instances.
Terraform Installed: Make sure you have Terraform installed on your machine. You can download and install it from here.
AWS CLI Configured: Ensure that your AWS CLI is configured with the necessary credentials to interact with AWS services.

Setting Up Your Terraform Configuration

The first step is to set up the Terraform configuration file (main.tf) to define the infrastructure. For deploying EC2 instances in multiple regions, we'll create resources for each region and use Terraform's capabilities to manage them efficiently.

Step 1: Define Provider Configuration

In your provider.tf file, you'll need to define the AWS provider for each region where you want to deploy the EC2 instances.

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

provider "aws" {
  alias  = "west-2"
  region = "us-west-2"
}

Here, we define two AWS providers, one for us-east-1 (North Virginia) and one for us-west-2 (Oregon). The alias is used to differentiate between the providers.

Step 2: Define the EC2 Instance Resource

Now that we have the providers set up, we can define the EC2 instances. We will deploy one EC2 instance in each region.

resource "aws_instance" "web_us_east_1" {
  provider = aws.east-1
  ami           = var.ami_id_1  # Replace with the latest AMI ID
  instance_type = var.instance_type

  tags = {
    Name = var.instance_name
  }
}

resource "aws_instance" "web_us_west_2" {
  provider = west-2
  ami           = var.ami_id_2  # Replace with the latest AMI ID
  instance_type = var.instance_type

  tags = {
    Name = var.instance_name
  }
}

In this snippet:

We deploy EC2 instances in both the us-east-1 and us-west-2 regions.
We use the difference AMI ID for both instances, based on the region

The instance_type is set to t2.micro for demonstration purposes, but you can adjust this based on your requirements.

Step 3: Pass values via variable.tf

We can use variable.tf to pass values to main.tf variable references.

variable "ami_id_1" {
  type        = string
  default     = "ami-0583d8c7a9c35822c"
  description = "AMI-ID for this instance"
}

variable "ami_id_2" {
  type        = string
  default     = "ami-0aa8fc2422063977a"
  description = "AMI-ID for this instance"
}

variable "instance_type" {
  type        = string
  default     = "t2.micro"
  description = "Instance type"
}

variable "name" {
  type        = string
  default     = "redhat-machine"
  description = "Name of the machine"
}

Step 4: Output Public IP Addresses

It's often helpful to output the public IP addresses of the instances after deployment for SSH access or verification.

output "east-1-instance-ip" {
  value = aws_instance.web_us_east_1.public_ip
}

output "west-2-instance-ip" {
  value = aws_instance.web_us_west_2.public_ip
}

Step 5: Initialize and Apply the Terraform Configuration

Once you've set up your configuration, it's time to deploy the infrastructure.

Initialize Terraform: This command will download the necessary provider plugins.
```
 terraform init
```
Plan the Deployment: This command will display the changes Terraform will make to your infrastructure.
```
 terraform plan
```
Apply the Changes: Finally, apply the configuration to create the EC2 instances in both regions.
```
 terraform apply
```
You'll be asked to confirm the changes by typing yes.

Step 6: Verify the Deployment

After the Terraform configuration has been applied, you can check the AWS Management Console to verify that the EC2 instances have been deployed in the respective regions.

You can also check the public IP addresses of the instances from the output and attempt to SSH into the instances to verify connectivity.

ssh ec2-user@<public-ip>

Step 7: Managing Multi-Region Deployments

Terraform makes it easy to manage and scale your multi-region deployments. If you need to add more regions, simply add additional provider configurations and corresponding resources. You can also update, destroy, or scale resources as needed.

By leveraging Terraform's state management, you can track the deployed infrastructure and apply changes across regions with minimal effort.

Conclusion

Deploying EC2 instances across multiple regions using Terraform allows you to build resilient and globally distributed infrastructure. By using Terraform's declarative approach, you can manage and scale these deployments with ease. Following this guide, you should now have the foundational knowledge to deploy EC2 instances across multiple AWS regions and manage them effectively using Terraform.

Multiple Region Deployment Using Terraform