ECS

ECS (Elastic Container Service)

Introduction to Amazon ECS

Amazon Elastic Container Service (ECS) is a fully managed container orchestration service provided by AWS. ECS allows users to run, manage, and scale containerized applications efficiently. It integrates seamlessly with other AWS services such as EC2, IAM, CloudWatch, VPC, and ALB. ECS supports Docker containers and provides two primary launch types: EC2 and Fargate.

Why ECS is Important

• Simplifies container deployment and management.
• Integrates with AWS security, networking, and monitoring services.
• Supports both serverless (Fargate) and server-based (EC2) deployments.
• Automates container scaling and load balancing.
• Reduces operational overhead compared to self-managed Kubernetes clusters.

Core Concepts of ECS

ECS Cluster

An ECS Cluster is a logical grouping of tasks or services. A cluster can contain EC2 instances (for EC2 launch type) or can be serverless (Fargate launch type). Clusters help organize container workloads.

ECS Task Definition

A Task Definition is a blueprint that describes how Docker containers should run. It includes information such as:

• Container image
• CPU and memory requirements
• Port mappings
• Environment variables
• IAM roles and logging configuration

{
  "family": "my-app-task",
  "containerDefinitions": [
    {
      "name": "my-app-container",
      "image": "my-app-image:latest",
      "memory": 512,
      "cpu": 256,
      "essential": true,
      "portMappings": [
        {
          "containerPort": 80,
          "hostPort": 80
        }
      ]
    }
  ]
}

ECS Task

A Task is the instantiation of a Task Definition. Tasks can run manually or via ECS Services. Tasks are ephemeral and can be automatically replaced if they fail.

ECS Service

An ECS Service manages long-running tasks and ensures the desired number of tasks are running at all times. It integrates with load balancers for distributing traffic across containers.

{
  "serviceName": "my-app-service",
  "taskDefinition": "my-app-task",
  "desiredCount": 3,
  "launchType": "FARGATE",
  "networkConfiguration": {
    "awsvpcConfiguration": {
      "subnets": ["subnet-abc123", "subnet-def456"],
      "securityGroups": ["sg-123abc"],
      "assignPublicIp": "ENABLED"
    }
  }
}

ECS Launch Types

EC2 Launch Type

In the EC2 launch type, ECS tasks run on a cluster of EC2 instances managed by the user. Users have full control over instance types, AMIs, and scaling policies.

Fargate Launch Type

AWS Fargate is a serverless launch type for ECS. Users do not manage servers; instead, AWS provisions compute resources automatically. Fargate simplifies deployment and reduces operational overhead.

ECS Architecture

ECS architecture consists of the following key components:

• Cluster: Logical grouping of tasks and services.
• Task Definition: Blueprint for running containers.
• Task: Running instance of a task definition.
• Service: Ensures desired task count is maintained.
• Container Instance: EC2 instance running the ECS agent (for EC2 launch type).
• ECS Agent: Software installed on EC2 instances to manage container lifecycle.

Networking in ECS

ECS networking uses Amazon VPC for secure communication. Key networking features include:

• awsvpc Mode: Provides each task with its own elastic network interface (ENI).
• Bridge Mode: Docker default networking for containers sharing the host instance.
• Host Mode: Containers use the host instance network directly.

ECS Load Balancing

ECS integrates with AWS Application Load Balancer (ALB) and Network Load Balancer (NLB) for distributing traffic:

• Service Auto Registration with ALB target groups.
• Supports dynamic port mapping for multiple tasks on the same EC2 instance.
• Automatic health checks and traffic routing.

ECS Monitoring and Logging

Amazon ECS integrates with CloudWatch Logs and CloudWatch Metrics:

• Monitor CPU and memory usage per task.
• Set alarms for task failures.
• Stream container logs to CloudWatch for centralized logging.

ECS Deployment Strategies

ECS supports multiple deployment strategies:

• Rolling Update: Gradually replaces old tasks with new tasks.
• Blue/Green Deployment: Deploy new version in parallel and switch traffic using AWS CodeDeploy.
• Canary Deployment: Deploy new version to a subset of tasks before full rollout.

Deploying a Container on ECS

Step 1: Create an ECS Cluster

aws ecs create-cluster --cluster-name my-ecs-cluster

Step 2: Register Task Definition

aws ecs register-task-definition \
  --family my-app-task \
  --network-mode awsvpc \
  --requires-compatibilities FARGATE \
  --cpu 256 \
  --memory 512 \
  --container-definitions '[{"name":"my-app-container","image":"my-app-image:latest","portMappings":[{"containerPort":80,"hostPort":80}]}]'

Step 3: Create ECS Service

aws ecs create-service \
  --cluster my-ecs-cluster \
  --service-name my-app-service \
  --task-definition my-app-task \
  --desired-count 2 \
  --launch-type FARGATE \
  --network-configuration '{
    "awsvpcConfiguration": {
      "subnets": ["subnet-abc123", "subnet-def456"],
      "securityGroups": ["sg-123abc"],
      "assignPublicIp": "ENABLED"
    }
  }'

ECS 

• Use Fargate for serverless and simplified management.
• Enable CloudWatch Logs for all tasks.
• Use IAM Roles for task permissions.
• Implement Auto Scaling policies for EC2 clusters.
• Organize multiple environments (dev, test, prod) using separate clusters.

ECS vs EKS vs Docker on EC2

ECS, EKS, and Docker on EC2 are all container orchestration options:

Amazon ECS is a powerful and flexible container orchestration service that simplifies deploying, managing, and scaling containerized applications in AWS. It supports multiple launch types, integrates with AWS monitoring and networking services, and provides robust deployment strategies. Whether you choose EC2 or Fargate, ECS helps modernize application infrastructure efficiently.