AWS Builder Center

Deploying a Dockerized Application on AWS ECS Fargate: A Beginner's Guide

Learn how to containerize an application with Docker, push the image to Amazon ECR, and deploy it on Amazon ECS Fargate without managing servers.

# Deploying a Dockerized Application on AWS ECS Fargate

Running a Docker container locally is easy, but deploying that container to the cloud introduces several new concepts.

In this guide, we'll deploy a Dockerized application using **Amazon ECR, Amazon ECS, and AWS Fargate**.

The final architecture will look like this:

```text
Internet
|
v
Application Load
Balancer
|
v
Amazon ECS
Fargate
|
v
Docker App
|
v
Amazon ECR
The main advantage of this approach is that we don't need to provision or manage EC2 servers ourselves. Fargate handles the underlying infrastructure.

1. Create a Dockerfile

First, create a  Dockerfile  for your application.
For example, a simple Python application could use:
FROM python:3.12-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8080

CMD ["python", "app.py"]
Build the image locally:
docker build -t my-app .
Test it:
docker run -p 8080:8080 my-app
At this point, the application should be accessible locally.

2. Create an Amazon ECR Repository

Amazon Elastic Container Registry (ECR) is used to store Docker images.
Create a repository for the application:
aws ecr create-repository \
--repository-name my-app
Authenticate Docker with ECR:
aws ecr get-login-password --region <region> | \
docker login --username AWS --password-stdin <account-id>.dkr.ecr.<region>.amazonaws.com
Tag the image:
docker tag my-app:latest \
<account-id>.dkr.ecr.<region>.amazonaws.com/my-app:latest
Push it:
docker push \
<account-id>.dkr.ecr.<region>.amazonaws.com/my-app:latest
Now the container image is stored in ECR.

3. Create an ECS Cluster

Amazon ECS is the container orchestration service we'll use.
Create an ECS cluster and choose AWS Fargate as the compute option.
Fargate allows us to run containers without managing EC2 instances.

4. Create a Task Definition

A task definition tells ECS how the container should run.
Important configuration includes:
  • Container image
  • CPU
  • Memory
  • Container port
  • Environment variables
  • IAM task role
  • Logging configuration
For example:
CPU: 0.5 vCPU
Memory: 1 GB
Port: 8080
Image: ECR/my-app:latest

5. Create an ECS Service

Create an ECS service using the task definition.
Configure:
  • Desired tasks
  • VPC
  • Subnets
  • Security groups
  • Load balancer
For a production application, I recommend running tasks across multiple Availability Zones.
For example:
Application
|
v
ALB
/ \
/ \
v v
Fargate Fargate
Task Task
| |
+------v------+
|
Database
If one Availability Zone has a problem, another task can continue serving traffic.

6. Configure the Application Load Balancer

The Application Load Balancer distributes incoming requests between ECS tasks.
Configure:
  1. Target group
  1. Health check
  1. Listener
  1. ECS service integration
The ALB can continuously check whether the containers are healthy.
Unhealthy containers can then be removed from the target group.

7. Add CloudWatch Logging

Container logs are extremely important when debugging production applications.
Configure the ECS task to send logs to Amazon CloudWatch Logs.
This lets you inspect things such as:
  • Application errors
  • Startup failures
  • HTTP requests
  • Exceptions
  • Container crashes

8. Secure the Architecture

Avoid exposing every component directly to the internet.
A better architecture is:
Internet
|
v
ALB
|
v
Private ECS Tasks
|
v
Private Database
Use security groups to control which components can communicate with each other.
For example:
ALB Security Group
|
| Port 8080
v
ECS Security Group
|
| Database Port
v
Database Security Group
The database should not need to accept connections from the public internet.

9. Enable Auto Scaling

One of the benefits of ECS Fargate is that the number of running tasks can be adjusted according to demand.
For example:
Low traffic
|
v
2 tasks

High traffic
|
v
5 tasks
ECS Service Auto Scaling can use metrics such as CPU utilization to determine when to scale.

10. Cost Considerations

Cloud resources cost money, so remember to clean up resources after experimenting.
Things to check include:
  • ECS tasks
  • Load balancers
  • NAT Gateways
  • ECR images
  • CloudWatch logs
  • Public IPv4 addresses
NAT Gateways in particular can create unexpected costs if they are left running.
Always check your AWS billing dashboard and consider setting up an AWS Budget for your account.

Final Architecture

After completing the setup, the architecture looks like:
Internet
|
v
Application Load
Balancer
|
+---------+---------+
| |
v v
ECS Fargate ECS Fargate
Task Task
| |
+---------+---------+
|
v
Database

Docker Image
|
v
ECR

Application Logs
|
v
CloudWatch

Why Use ECS Fargate?

ECS Fargate is useful when you want to run containers without managing the underlying servers.
Compared with running containers directly on EC2:
EC2
Fargate
Manage servers
AWS manages infrastructure
Manage OS updates
No server management
More infrastructure control
Less infrastructure management
Pay for instances
Pay for requested compute resources
For small teams and developers who want to focus on their application rather than server administration, Fargate can significantly simplify container deployment.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article