Upgrade Your AWS Infrastructure with EC2 to ECS Migration

Migrating from Amazon EC2 to Amazon ECS can dramatically improve application scalability and deployment efficiency. This guide will walk you through the entire migration process, from containerizing your EC2 applications to leveraging ECS features for seamless management and cost optimization.

>> Read more: How to Dockerize A Node.js Application & Deploy it To EC2?

Key Benefits of Migrating from EC2 to ECS

Amazon Elastic Container Service (ECS) is a fully managed container orchestration service that simplifies running, managing, and scaling Docker containers on AWS. Migrating from EC2 to ECS offers numerous benefits, such as:

• Enhance scalability: ECS makes it easy to scale applications by dynamically adding or removing containers.
• Automate deployment: ECS integrates with AWS services like Elastic Load Balancing and CloudWatch, reducing the complexity of deployment and monitoring.
• Optimize costs: By using ECS, you only pay for the resources your containers consume, potentially lowering operational costs.

In contrast, Amazon EC2, while flexible, requires manual effort for scaling, deployment configuration, and monitoring. EC2 instances also incur charges based on instance hours, regardless of actual usage, which can lead to higher operational costs if resources are underutilized. Therefore, EC2 to ECS migration can streamline your operations, reduce costs, and provide scalable, efficient solutions tailored to containerized applications on AWS.

Environment Setup

Currently, the infrastructure is deployed across three environments in the London (eu-west-2) AWS region:

• Development
• Staging
• Production

These environments support the complete lifecycle of application development, testing, and production. Setting up these environments in ECS will provide a unified, streamlined approach, laying the groundwork for a smooth migration.

Infrastructure Setup

Container Images

• Storage: Container images are securely stored in Amazon Elastic Container Registry (ECR).

• Deployment: These images are deployed to an ECS cluster, ensuring seamless orchestration of containers.

• Environment Variables:
  • In-line variables: These are defined directly in the task definition.
  • SSM Parameters: Securely store sensitive information like API keys and credentials using AWS Systems Manager (SSM) Parameters.

Networking

• Private Subnets: Containers are deployed within private subnets for enhanced security.
• Application Load Balancers (ALB): ALBs manage traffic to your containers, ensuring that requests are routed efficiently based on health checks.

Database

• RDS Postgres: The relational database is hosted on Amazon RDS and is tightly integrated with ECS applications, offering automated backups, failovers, and performance optimization.

Terraform Configuration

>> You may consider: How To Use Terraform for Provisioning A Docker Container?

Using Terraform, you can efficiently manage the infrastructure with the following setup:

Backend Configuration:

• AWS Region: eu-central-1 (different from the application region to avoid conflicts).
• State Management: Terraform state is stored in the cis-terraform-state-management-bucket.
• State Locking: State Lock is managed via a DynamoDB in the cis-terraform-state-lock table.

Workspaces:

Environments are managed using Terraform Workspaces, each following this naming format: <env abbr>_<aws region id> (e.g., dev_eu-west-2).

Each workspace ensures that changes in one environment do not impact others, promoting a safer and more organized deployment process.

Environment Variables: Managed separately for each workspace and must not be committed to the repository.

_tfvars

|___[workspace]

|___[region_id].tfvars

Example:

_tfvars

|___dev

|___eu-west-2.tfvars

Note: Variables files must not be committed to version control (VSC) to prevent potential secret leaks.

CI/CD Pipeline Setup

A well-designed CI/CD pipeline ensures fast and reliable updates to ECS services. This pipeline is implemented using GitHub Actions, and it automates critical tasks:

• Building Docker images: Every time new code is pushed, the pipeline builds Docker images.
• Deploying ECS services: Once images are built, the pipeline automatically deploys updates to the ECS cluster.
• Reusable Actions: Shared actions are organized under github/actions to avoid redundant steps.
• Environment Variables & Secrets: 

• Credentials: Securely access AWS credentials via GitHub OIDC, assuming the github-action-deployer-role in the AWS account.

>> Read more: Docker Networking Fundamentals: Types, Working and Usage

6 Steps to Migrate from EC2 to ECS

Step 1: Containerize Existing EC2 Applications

• Use Docker to containerize current EC2 applications. This involves creating a Dockerfile that specifies the environment setup, dependencies, and runtime for your application.

Step 2: Create ECS Cluster

• Use Terraform to provision an ECS cluster in the eu-west-2 region.
• Set up a VPC with private subnets, security groups, and network ACLs to isolate your containerized applications.

Step 3: Deploy Containers to ECS

• Define ECS Task Definitions that specify the container image, resource limits (CPU and memory), environment variables, and IAM roles.
• Deploy containers using Application Load Balancers (ALB) to ensure traffic routing and failover management.

Step 4: Integrate RDS with ECS

• Ensure that the ECS tasks can seamlessly connect to RDS Postgres instance by configuring appropriate security groups and IAM roles.

Step 5: Update ECS Services

• Use CI/CD pipeline to deploy updates automatically to ECS services when changes are pushed to the repository.
• Ensure that any changes to the infrastructure or application code trigger pipeline runs.

Step 6: Test Application in All Environments

• After migration, test the application in all environments (Development, Staging, Umbrella, and Bureau) to ensure it behaves as expected.

Updating ECS Cluster Instance Types

Using Terraform

• Modify the ecs/cluster.tf file.
• Find the locals block contains the following line: instance_type = "t3.medium"
• Update the instance type of the Environment.
• Run terraform plan to review the changes and terraform apply to update the infrastructure.

Using AWS Console

• Navigate to EC2 > Auto Scaling Groups > [ASG name to update].
• Under the Details tab, select the Launch Template used by this ASG and navigate to the Launch Template page.

• Select Modify template (Create new revision)

• Choose the desired Instance Type and click Create template version.
• Go back to ASG page, select Edit the Launch Template.
• Choose the newly created Version and click Update.
• Navigate to the Instance refresh tab, and click Start instance refresh

• In the Refresh settings section, choose Ignore:

EC2 to ECS Migration Tips

• Instance Refresh: Leverage the Instance Refresh feature in Auto Scaling to minimize downtime when migrating or updating instance types.
• Scale-In Protection: Properly configure scale-in protection to avoid premature termination of ECS tasks during scaling operations.

Steps:

• Go to the Instance Management tab.

• Remove the Scale-in protection for one or more instances (but keep the minimum number of instances required for the Containers to run).

• Start instance refresh with Replace scale-in protected instances option selected.

>> You may be interested in:

• Exploring 6 Deployment Strategies for Smooth Software Updates
• Top 9 Best DevOps Deployment Tools for Businesses
• Top 20 Infrastructure as Code (IaC) Tools For Businesses

Conclusion

Migrating from EC2 to ECS simplifies cloud operations, improves scalability, and reduces operational overhead. By following this guide, you can transition smoothly and take full advantage of ECS's orchestration and integration capabilities.