What is AWS Fargate? A plain-English explainer
AWS Fargate is a serverless compute engine for containers: it lets you run containers through Amazon ECS or Amazon EKS without provisioning or managing the servers those containers actually run on. Containers solve the problem of packaging an application so it runs the same way everywhere, but someone still has to decide what runs the containers themselves — a fleet of servers that needs sizing, patching and scaling. Fargate removes that decision entirely: you describe the container you want to run, and AWS runs it, without you ever seeing or managing the machine underneath. It sits at the intersection of two ideas AWS learners meet separately — containers and serverless computing — and understanding it well means understanding both.
The problem Fargate solves
Containers make an application portable and consistent, but they still need somewhere to run, and that somewhere has traditionally been a cluster of servers someone has to manage — choosing server sizes, keeping them patched, and scaling the fleet up and down as demand for the containers changes. That server-management work is separate from the actual application logic inside the container, yet it demands just as much ongoing attention.
Fargate takes that layer away. Instead of managing a cluster of servers to host your containers, you specify how much compute and memory a container needs, and AWS finds and manages the underlying capacity for you — provisioning it, scaling it, and retiring it, all invisibly. The container is still a container; what changes is who looks after the machine it runs on.
How it relates to containers and orchestration
To use Fargate at all, you first need containers — self-contained packages of an application and everything it needs to run, which our what-is-docker explainer covers in more detail. Running one container is straightforward, but real applications usually involve many containers that need to be started, stopped, networked together and kept healthy, and that coordination job is called orchestration.
Fargate is not an orchestrator itself — it is a way of running the containers that an orchestrator, either Amazon ECS or Amazon EKS, has decided need to run. Our serverless-vs-containers explainer covers how these ideas combine: orchestration decides what should run and where; Fargate is one option for what actually runs it, without exposing the servers involved.
Fargate vs running containers on EC2
Both ECS and EKS give you a choice of launch type: Fargate, or EC2. On EC2, you run your own fleet of virtual servers as the container hosts — you choose their size, patch them, and manage how containers are packed onto them, which gives more control over the underlying environment but puts the management work back on you.
Fargate trades that control for convenience: no servers to size or patch, and you pay for the compute and memory your containers actually use rather than for idle server capacity. The right choice depends on whether that extra control over the host — specific instance types, deeper cost tuning, particular networking or hardware needs — is worth the operational overhead of managing it yourself.
When you would use Fargate
Fargate suits teams who want the packaging and portability benefits of containers without taking on server management — a natural fit for applications with variable or unpredictable load, or for teams who would rather spend their time on application code than on capacity planning. It is less suited to workloads that need very specific control over the host machine, since that level of control is exactly what Fargate abstracts away.
How Fargate is paid for
Fargate follows the same consumption-based model as most serverless AWS services: you are billed for the compute and memory resources your containers actually use while they are running, rather than for a reserved server that sits there whether it is busy or not. This means cost tracks usage directly, without the extra step of estimating server capacity in advance. Specific rates are not covered here, as they change — AWS’s official Fargate pricing page has current figures.
Where Fargate appears in certification study
Fargate features in the AWS Developer Associate and Solutions Architect Associate exams as part of choosing a compute option for containerised workloads — knowing when Fargate’s serverless convenience beats EC2’s control is a recurring exam theme. It is also relevant background for the CNCF Kubernetes and Cloud Native Associate, since EKS (Fargate’s Kubernetes-based counterpart) builds on Kubernetes concepts directly.
As with the other services covered here, this article stops at the concept level. The exam-depth detail — how Fargate is configured within ECS or EKS, and how it compares against EC2 launch types in real architecture scenarios — belongs in our /revision study material, not in a beginner explainer.
Original practice questions, timed mock exams and revision notes. No card, nothing to pay.