Amazon ECS

Overview

ECS (Elastic Container Service) launches Docker containers on AWS. A launched container is an ECS Task running on an ECS Cluster. There are two launch types: EC2 and Fargate. ECS Managed Instances is a newer option where AWS manages the EC2 instances for ECS.

Launch Types

IAM Roles for ECS

Load Balancer Integrations

To expose tasks as an HTTP or HTTPS endpoint, run a load balancer in front; users go to the load balancer and traffic reaches the ECS tasks directly. Works with EC2 launch type or Fargate.

Data Persistence with EFS

Data volumes persist data; the notable one is Amazon EFS. See EFS.

• EFS is a network file system, compatible with both EC2 and Fargate launch types, mounted directly onto ECS tasks.
• Tasks in any AZ linked to the file system share the same data and can communicate through it.
• Fargate + EFS is the ultimate serverless combo: EFS is serverless, pay as you go, provisioned in advance.
• Use case: persistent multi-AZ shared storage for containers.

• Amazon EBS volumes can also attach to ECS and Fargate tasks, one volume per task (not shared). Fargate ephemeral storage is 20 GiB by default, up to 200 GiB.

Hands-On Walkthrough

Create the cluster

1. In the ECS console, enable the new ECS experience (top left). Go to Clusters and Create cluster.
2. Name it DemoCluster, keep the default namespace.
3. Infrastructure has three options:
   • AWS Fargate (serverless, AWS provides compute on demand) - left enabled.
   • Amazon EC2 instances (you provide the compute) - also enabled for the demo.
   • External instances using ECS Anywhere (e.g. your own data center).
4. For EC2: create a new Auto Scaling group, OS Amazon Linux 2 (or newer Amazon Linux 2023), instance type t2.micro (free tier eligible), desired capacity minimum 0 and maximum 5, no SSH key pair, default root EBS volume size.
5. Network: default VPC, the three available subnets, the default security group, auto-assign public IP set to use subnet setting. Leave monitoring and tags. Click Create.
6. In EC2 Auto Scaling groups, an ASG Infra-ECS-Cluster is created by the cluster with desired 0, min 0, max 5, across 3 AZs, so tasks launch across 3 AZs.
7. In DemoCluster: services 0, tasks 0. Under Infrastructure there are three capacity providers:
   • FARGATE: launch Fargate tasks.
   • FARGATE_SPOT: launch Fargate tasks in spot mode.
   • ASGProvider: launch EC2 instances in the cluster through the ASG (managed scaling; current size 0, can be changed).
8. Demo: edit the ASG desired capacity to 1. An EC2 instance is created and registers itself in DemoCluster as a container instance. It shows t2.micro, 0 tasks running, 1,024 CPU and 982 memory available.
9. A task can run on FARGATE, FARGATE_SPOT, or the container instances from the ASG.

Create the task definition

1. Create a new task definition named nginxdemos-hello, from the Docker Hub image nginxdemos/hello.
2. Infrastructure: Fargate (serverless), OS Linux. Task size: 0.5 vCPU and 1 GB memory chosen for low cost. The console allows up to 16 vCPU and a large memory amount (the speaker says "120 gigabytes", partly unclear in the transcript).
3. Task role: an IAM role for API calls to AWS services. None here, but of utmost importance if containers use AWS.
4. Task execution role: leave default; ECS creates it if missing.
5. Container: name nginxdemos-hello, image URL nginxdemos/hello (pulled from Docker Hub), port mapping 80 to 80. Other options (resource limits, environment variables, logging) left as default.
6. Storage: Fargate ephemeral storage default of 21 GB. Click Create; the version shows as 1 (the speaker saw 2 because he created it twice).

Create the service

1. Clusters > DemoCluster > Services > Create. Compute option: Launch type Fargate, platform version latest.
2. Application type Service (long running, e.g. web app). Use Task for something that terminates, e.g. a batch job.
3. Select the nginxdemos-hello family and latest revision; service name nginxdemos-hello; service type Replica with 1 task. Deployment options and failure detection left as is.
4. Networking: VPC with the three subnets; new security group nginxdemos-hello allowing HTTP port 80 from anywhere; public IP on.
5. Load balancing: an Application Load Balancer named DemoALBForECS, health check grace period 0, container nginxdemos-hello port 80 protocol HTTP, target group tg-nginxdemos-hello, HTTP health check path /.
6. Service auto scaling and task placement left untouched (available). Wait a few minutes for deployment.

Verify

• Service shows 1 desired, 1 running, status active, linked to the target group and the ALB; one IP (the container's private IP) is registered as a target.
• Opening the ALB DNS name shows the Nginx welcome page; the server address equals the registered IP. /test also works.
• The task page shows configuration, revision, private IP, containers and logs. The service Events tab shows task started, registered in target group, deployment complete, steady state.

Scale up

• Update service, desired tasks = 3 (one per AZ). Tasks go pending, activating, running quickly on Fargate. Refreshing the ALB page shows the IP changing, so the ALB distributes load across containers.

Clean Up

1. Make sure the service has 0 tasks (update desired tasks to 0 if not), then Delete Service and type Delete.
2. Deleting the service runs through CloudFormation, which deletes the ECS service, the load balancer listener, the load balancer, the security group and the target groups. This takes some time.
3. When the service is gone, Delete Cluster. CloudFormation deletes the capacity provider, the Auto Scaling group, the cluster and the launch templates.
4. Task definitions cost nothing and can be left. Optionally select one and use Actions > Deregister.
5. During the demo the ASG desired capacity was also set to 0 so no EC2 instances keep running.

Questions & Answers