# AWS Fargate

Cloud service · AWS. Updated 2026-11-12. Page: https://blowstack.com/tools/cloud-services-hub/aws-fargate

> AWS Fargate is a serverless compute engine for containers that allows you to run containers without having to manage servers or clusters.

Practice exams covering AWS Fargate: [CLF-C02 AWS Certified Cloud Practitioner](https://blowstack.com/practice-exams/aws-certified-cloud-practitioner), [DEA-C01 AWS Certified Data Engineer - Associate](https://blowstack.com/practice-exams/aws-certified-data-engineer-associate), [DVA-C02 AWS Certified Developer - Associate](https://blowstack.com/practice-exams/aws-certified-developer-associate), [DOP-C02 AWS Certified DevOps Engineer - Professional](https://blowstack.com/practice-exams/aws-certified-devops-engineer-professional), [SAA-C03 AWS Certified Solutions Architect - Associate](https://blowstack.com/practice-exams/aws-certified-solutions-architect-associate), [SAP-C02 AWS Certified Solutions Architect - Professional](https://blowstack.com/practice-exams/aws-certified-solutions-architect-professional).

## 7 key features of AWS Fargate

AWS Fargate is a serverless compute engine for containers that offers seamless scaling, integration with ECS and EKS, and ensures secure, isolated environments without over-provisioning, alongside easy monitoring and logging capabilities.

1. **Serverless Compute for Containers**: AWS Fargate removes the need to provision and manage servers, letting you specify and pay for resources per application.
2. **Seamless Scaling**: Amazon ECS and Amazon EKS schedule containers onto Fargate, providing automatic scaling, load balancing, and container availability through managed scheduling.
3. **Integrated with Amazon ECS and EKS**: Fargate seamlessly integrates with Amazon Elastic Container Service (ECS) and Elastic Kubernetes Service (EKS), simplifying the deployment, management, and scalability of containers using these services.
4. **Security and Isolation**: Each task or pod runs in its own isolated environment, improving security and reducing the risk of interference from other tasks or pods.
5. **Configurable Resource Requests**: Configure resource requests for each task or pod; billing is based on requested resources, not solely on actual CPU and memory utilization.
6. **Easy Monitoring and Logging**: Integrates with AWS CloudWatch, allowing you to monitor and log the performance and health of your applications easily.
7. **Mixed-Architecture AWS Batch Jobs**: AWS Batch on Fargate can run x86 and Arm64 jobs through a single compute environment and job queue, with the architecture selected per job definition. This support requires AWS Batch compute environments using Amazon ECS, not Amazon EKS.

## Where AWS Fargate is used

AWS Fargate is utilized for serverless deployment of microservices, batch processing, streamlining CI/CD pipelines, handling event-driven applications, and running machine learning inference, providing an auto-scaling and resource-optimized environment.

1. **Microservices Deployment**: AWS Fargate facilitates the deployment of microservices without the need to manage servers or clusters, allowing developers to focus on building and scaling applications.
2. **Batch Processing**: Leveraging AWS Fargate, users can run batch processing jobs as containers, which can start quickly and scale automatically, optimizing both time and resources.
3. **Continuous Integration/Continuous Deployment (CI/CD) Pipelines**: Fargate integrates with CI/CD pipelines, providing a seamless way to build, test, and deploy applications rapidly and securely without managing underlying infrastructure.
4. **Event-driven Applications**: By using AWS Fargate with services like Amazon EventBridge or S3, developers can create event-driven applications that automatically scale in response to triggers.
5. **Machine Learning Model Inference**: Fargate is suitable for deploying machine learning models as containers, offering a serverless environment that scales on-demand for inference workloads.

## How AWS Fargate is priced

AWS Fargate pricing includes On-Demand, where you pay for compute resources used, and Spot, which offers discounts but can be interrupted.

- **Fargate On-Demand**: Pay for requested vCPU, memory, operating system, CPU architecture, and storage resources with no upfront costs. Billing runs from the start of the container image download until task or pod termination, rounded up to the nearest second, with a one-minute minimum for Linux containers and a five-minute minimum for Windows containers.
- **Fargate Spot**: This model offers a discounted rate compared to On-Demand pricing by utilizing spare computing capacity. However, these instances can be interrupted by AWS with two minutes of notification when AWS needs the capacity back, making this option suitable for fault-tolerant and flexible applications.
- **Compute Savings Plans**: Save up to 50% on Fargate usage by committing to a specific amount of compute spending, measured in dollars per hour, for a one- or three-year term.
- **Ephemeral Storage**: Tasks and pods include 20 GB of ephemeral storage by default; additional configured storage is charged per GB-hour.

## Services AWS Fargate works with

- **[Amazon API Gateway](https://blowstack.com/tools/cloud-services-hub/amazon-api-gateway)**: AWS Fargate services can be exposed through API Gateway HTTP APIs using private integrations with an Application Load Balancer, Network Load Balancer, or AWS Cloud Map service discovery. This lets an API route requests to containers running in private subnets.
- **[Amazon CloudWatch](https://blowstack.com/tools/cloud-services-hub/amazon-cloudwatch)**: AWS Fargate tasks can send container logs to CloudWatch Logs, while ECS publishes service metrics and supports Container Insights for Fargate workloads. CloudWatch alarms can detect failures or drive ECS service scaling.
- **[Amazon CodeGuru](https://blowstack.com/tools/cloud-services-hub/amazon-codeguru)**: Applications running on AWS Fargate can use the CodeGuru Profiler agent to collect runtime profiles. These profiles help identify expensive methods and CPU bottlenecks inside containerized Java or Python applications.
- **[Amazon Data Firehose](https://blowstack.com/tools/cloud-services-hub/amazon-kinesis-data-firehose)**: AWS Fargate tasks on ECS can route container logs to Amazon Data Firehose through FireLens. Firehose can then deliver those logs to destinations such as Amazon S3 or Amazon OpenSearch Service.
- **[Amazon DevOps Guru](https://blowstack.com/tools/cloud-services-hub/amazon-devops-guru)**: Amazon DevOps Guru can analyze supported ECS service metrics for services running on AWS Fargate. It identifies anomalous operating behavior and provides insights that help investigate application performance problems.
- **[Amazon Elastic Block Store (Amazon EBS)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-block-store-(amazon-ebs))**: AWS Fargate tasks on ECS can attach an ECS-managed Amazon EBS volume using the task or service volume configuration. ECS manages the volume lifecycle, providing block storage for workloads such as data processing.
- **[Amazon Elastic Container Registry (Amazon ECR)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-container-registry-(amazon-ecr))**: AWS Fargate pulls container images from Amazon ECR when starting ECS tasks or EKS Pods. Task execution roles or Pod execution roles authorize access to private repositories.
- **[Amazon Elastic Container Service (Amazon ECS)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-container-service-(amazon-ecs))**: AWS Fargate provides managed compute capacity for ECS tasks and services. ECS task definitions specify container images, CPU, memory, networking, and other settings without requiring you to manage container hosts.
- **[Amazon Elastic File System (Amazon EFS)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-file-system-(amazon-efs))**: AWS Fargate workloads can mount Amazon EFS file systems for persistent, shared storage. ECS tasks configure EFS volumes in task definitions, while EKS Fargate Pods use supported EFS persistent volumes.
- **[Amazon Elastic Kubernetes Service (Amazon EKS)](https://blowstack.com/tools/cloud-services-hub/amazon-elastic-kubernetes-service-(amazon-eks))**: AWS Fargate runs Kubernetes Pods selected by EKS Fargate profiles. EKS schedules matching Pods onto isolated Fargate compute without requiring customer-managed worker nodes.
- **[Amazon EventBridge](https://blowstack.com/tools/cloud-services-hub/amazon-eventbridge)**: AWS Fargate tasks can be launched by EventBridge rules, EventBridge Scheduler, and EventBridge Pipes through ECS task targets. ECS also sends task and service events to EventBridge for automated responses.
- **[Amazon GuardDuty](https://blowstack.com/tools/cloud-services-hub/amazon-guardduty)**: GuardDuty Runtime Monitoring supports ECS workloads running on AWS Fargate through a security agent added to monitored tasks. It analyzes runtime activity for threats such as suspicious process execution and malicious network behavior.
- **[Amazon Inspector](https://blowstack.com/tools/cloud-services-hub/amazon-inspector)**: Amazon Inspector correlates ECR image vulnerability findings with ECS deployment information, including tasks running on AWS Fargate. This helps identify which vulnerable container images are actively deployed.
- **[Amazon Kinesis Data Streams](https://blowstack.com/tools/cloud-services-hub/amazon-kinesis-data-streams)**: AWS Fargate container logs can be sent to Kinesis Data Streams using FireLens on ECS or the supported Fluent Bit log router on EKS Fargate. Consumers can process the resulting log stream in near real time.
- **[Amazon Managed Service for Prometheus](https://blowstack.com/tools/cloud-services-hub/amazon-managed-service-for-prometheus)**: AWS Fargate workloads can use an AWS Distro for OpenTelemetry collector to scrape application metrics and remote-write them to Amazon Managed Service for Prometheus. This supports Prometheus monitoring without operating a Prometheus storage server.
- **[Amazon Managed Workflows for Apache Airflow (Amazon MWAA)](https://blowstack.com/tools/cloud-services-hub/amazon-managed-workflows-for-apache-airflow-(amazon-mwaa))**: Amazon MWAA workflows can launch ECS tasks on AWS Fargate using the Airflow ECS operator and wait for their completion. This allows a DAG to offload containerized processing steps to serverless compute.
- **[Amazon OpenSearch Service](https://blowstack.com/tools/cloud-services-hub/amazon-opensearch-service)**: AWS Fargate workloads can route container logs to Amazon OpenSearch Service using FireLens on ECS or the supported log router on EKS Fargate. OpenSearch can then index those logs for searching and operational analysis.
- **[Amazon Route 53](https://blowstack.com/tools/cloud-services-hub/amazon-route-53)**: AWS Fargate services on ECS can use Route 53-backed service discovery through AWS Cloud Map. ECS registers and deregisters task IP addresses so other workloads can discover running tasks through DNS.
- **[Amazon S3](https://blowstack.com/tools/cloud-services-hub/amazon-s3)**: AWS Fargate tasks on ECS can load environment-variable files stored in Amazon S3 through the task definition's environmentFiles setting. The task execution role authorizes retrieval of the files when tasks start.
- **[Amazon VPC](https://blowstack.com/tools/cloud-services-hub/amazon-vpc)**: AWS Fargate gives each ECS task or EKS Pod an elastic network interface in a VPC. Subnets, security groups, and routing control workload connectivity and access to private resources.
- **[AWS AppConfig](https://blowstack.com/tools/cloud-services-hub/aws-appconfig)**: AWS Fargate tasks can run the AWS AppConfig Agent as a sidecar to retrieve and cache application configuration. Application containers read configuration from the agent's local HTTP endpoint, including feature flags and dynamically deployed settings.
- **[AWS Auto Scaling](https://blowstack.com/tools/cloud-services-hub/aws-auto-scaling)**: AWS Auto Scaling scaling plans can manage the desired task count of ECS services running on AWS Fargate. Target-tracking policies adjust service capacity as utilization changes.
- **[AWS Batch](https://blowstack.com/tools/cloud-services-hub/aws-batch)**: AWS Fargate provides serverless compute environments for AWS Batch jobs using ECS orchestration. Batch queues and schedules container jobs while Fargate supplies the requested CPU and memory.
- **[AWS Cloud Map](https://blowstack.com/tools/cloud-services-hub/aws-cloud-map)**: AWS Fargate services on ECS use AWS Cloud Map for service discovery and ECS Service Connect namespaces. ECS maintains service endpoints as tasks start and stop, allowing containers to locate one another without fixed IP addresses.
- **[AWS CloudFormation](https://blowstack.com/tools/cloud-services-hub/aws-cloudformation)**: AWS CloudFormation provisions Fargate workloads through ECS task definitions and services, EKS Fargate profiles, and related resource types. Templates can define the workload together with its networking, permissions, and load balancing.
- **[AWS CloudTrail](https://blowstack.com/tools/cloud-services-hub/aws-cloudtrail)**: CloudTrail records ECS and EKS API operations used to configure and manage AWS Fargate workloads. These records support auditing actions such as launching ECS tasks, updating services, and creating EKS Fargate profiles.
- **[AWS CodeDeploy](https://blowstack.com/tools/cloud-services-hub/aws-codedeploy)**: AWS Fargate services on ECS support blue/green deployments managed by CodeDeploy. CodeDeploy creates a replacement task set and shifts load balancer traffic to it, with deployment validation and rollback options.
- **[AWS CodePipeline](https://blowstack.com/tools/cloud-services-hub/aws-codepipeline)**: CodePipeline can deploy new container image revisions to ECS services running on AWS Fargate. Its ECS deployment actions support standard service updates and CodeDeploy-based blue/green deployments.
- **[AWS Compute Optimizer](https://blowstack.com/tools/cloud-services-hub/aws-compute-optimizer)**: Compute Optimizer analyzes ECS services running on AWS Fargate and recommends CPU and memory configurations. Recommendations help identify overprovisioned or underprovisioned tasks.
- **[AWS Config](https://blowstack.com/tools/cloud-services-hub/aws-config)**: AWS Config records supported ECS resources used by AWS Fargate workloads and evaluates them with managed or custom rules. Rules can check task-definition settings such as logging, secrets handling, and read-only root filesystems.
- **[AWS Distro for OpenTelemetry](https://blowstack.com/tools/cloud-services-hub/aws-distro-for-opentelemetry)**: AWS Fargate workloads can run AWS Distro for OpenTelemetry collectors alongside application containers. The collectors receive application telemetry and export it to destinations such as AWS X-Ray, CloudWatch, and Amazon Managed Service for Prometheus.
- **[AWS Fault Injection Service](https://blowstack.com/tools/cloud-services-hub/aws-fault-injection-simulator-(aws-fis))**: AWS Fault Injection Service can target ECS tasks running on AWS Fargate to test workload resilience. Supported experiments include stopping tasks and, with the required task configuration, injecting CPU, memory, or I/O stress.
- **[AWS Identity and Access Management (IAM)](https://blowstack.com/tools/cloud-services-hub/aws-identity-and-access-management-(iam))**: AWS Fargate uses IAM execution roles for platform operations such as pulling private images and delivering logs. ECS task roles and supported EKS workload identities provide application containers with scoped permissions without embedding long-lived credentials.
- **[AWS Key Management Service (AWS KMS)](https://blowstack.com/tools/cloud-services-hub/aws-key-management-service-(aws-kms))**: AWS Fargate supports customer-managed KMS keys for encrypting ephemeral storage in supported ECS configurations. KMS also protects secrets and supported storage volumes used by Fargate workloads.
- **[AWS Marketplace](https://blowstack.com/tools/cloud-services-hub/aws-marketplace)**: AWS Marketplace offers container software that can be deployed as ECS tasks or services on AWS Fargate. Customers can subscribe to compatible products and run the supplied container images without managing hosts.
- **[AWS PrivateLink](https://blowstack.com/tools/cloud-services-hub/aws-privatelink)**: AWS Fargate workloads can use PrivateLink interface endpoints to reach supported AWS services privately. For example, private ECR and CloudWatch Logs endpoints support image retrieval and log delivery without routing that traffic through an internet gateway.
- **[AWS Resilience Hub](https://blowstack.com/tools/cloud-services-hub/aws-resilience-hub)**: AWS Resilience Hub assesses supported ECS services running on AWS Fargate as part of an application's resilience assessment. It evaluates the deployment against recovery objectives and provides recommendations for improving availability and recovery.
- **[AWS Secrets Manager](https://blowstack.com/tools/cloud-services-hub/aws-secrets-manager)**: AWS Fargate tasks on ECS can inject Secrets Manager values into container environment variables or supported logging configuration fields. The task execution role controls access, and tasks must be replaced to receive updated values injected at startup.
- **[AWS Security Hub](https://blowstack.com/tools/cloud-services-hub/aws-security-hub)**: Security Hub evaluates ECS security controls that apply to AWS Fargate workloads, including task-definition logging, secrets management, and container configuration. Findings identify workloads that do not meet the enabled security standards.
- **[AWS Security Token Service (AWS STS)](https://blowstack.com/tools/cloud-services-hub/aws-security-token-service-(aws-sts))**: AWS Fargate tasks on ECS receive temporary credentials for their task IAM roles through the container credentials endpoint. These STS-backed credentials let containers access authorized AWS resources without storing permanent access keys.
- **[AWS Step Functions](https://blowstack.com/tools/cloud-services-hub/aws-step-functions)**: Step Functions can launch ECS tasks on AWS Fargate using its ECS service integration. Workflows can wait for task completion or use task-token callbacks to coordinate container jobs with other processing steps.
- **[AWS Systems Manager](https://blowstack.com/tools/cloud-services-hub/aws-systems-manager)**: AWS Fargate supports ECS Exec through Systems Manager Session Manager channels, allowing authorized commands inside running containers. ECS task definitions can also reference Systems Manager Parameter Store values for configuration and secrets.
- **[AWS X-Ray](https://blowstack.com/tools/cloud-services-hub/aws-x-ray)**: AWS Fargate applications can send distributed traces to X-Ray through an X-Ray daemon or OpenTelemetry collector running alongside the application. Traces help diagnose latency and errors across containerized services and their dependencies.
- **[Elastic Load Balancing (ELB)](https://blowstack.com/tools/cloud-services-hub/elastic-load-balancing-(elb))**: AWS Fargate services on ECS integrate with Application Load Balancers and Network Load Balancers using IP target groups. ECS registers and deregisters task addresses as the service scales or deploys new versions.

## What is AWS Fargate

AWS Fargate is a powerful compute engine within the Amazon Web Services (AWS) ecosystem, designed to run containers without requiring the user to manage the underlying servers or clusters. In the realm of cloud computing and containerization, Fargate stands out by offering a serverless experience that abstracts the complexity of scaling, patching, and securing servers, thereby allowing developers to focus purely on building and deploying their applications. Users configure the resources requested for each task or pod.

Fargate enforces per-account, per-Region launch-rate quotas for Amazon ECS tasks and Amazon EKS pods using a token bucket. The bucket capacity permits bursts, while its refill rate governs sustained launches.

At its core, Fargate is designed to work seamlessly with Amazon Elastic Container Service (ECS) and Amazon Elastic Kubernetes Service (EKS), facilitating easy deployment of applications packaged as containers. By utilizing Fargate with ECS or EKS, users can launch and manage containers without having to provision or manage the infrastructure traditionally associated with containerized workloads. This significantly lowers the barrier to entry for deploying containerized applications and enables organizations to adopt a microservices architecture more smoothly and efficiently.

Fargate supports Linux/x86, Linux/Arm, and Windows/x86 configurations. Windows and Arm configurations are available only with Amazon ECS. Fargate Spot capacity is available only for Amazon ECS tasks using Linux on x86 or Arm.

One of the key benefits of AWS Fargate is its pricing model. Charges are based on the requested vCPU, memory, operating system, CPU architecture, and storage resources for each task or pod, rather than only on resources actively consumed by the application. This pay-as-you-go pricing model provides significant cost efficiencies and flexibility, making Fargate an attractive option for both startups and large enterprises looking to optimize their cloud spend. Security is another area where AWS Fargate shines. It is integrated with AWS Identity and Access Management (IAM), allowing for granular control over which resources an application can access. This is complemented by the inherent security benefits of a managed service where AWS is responsible for applying patches and updates to the underlying infrastructure, thus helping to mitigate the risk of security vulnerabilities.

Moreover, Fargate simplifies the deployment and management process by providing native integration with several AWS services and features, such as Amazon CloudWatch for logging and monitoring, AWS CloudFormation for infrastructure as code, and AWS CodePipeline for continuous integration and continuous deployment (CI/CD) workflows. These integrations empower developers to adopt modern application development and deployment practices, further enhancing the agility and efficiency of the software development lifecycle.

In conclusion, AWS Fargate is a pivotal service within the AWS suite that caters to the growing demand for serverless computing options. By eliminating the need to manage servers or clusters, allowing for precise resource provisioning, and integrating tightly with other AWS services, Fargate provides a robust platform for deploying and managing containerized applications at scale. Its appeal lies in simplifying operations, reducing costs, and enhancing security, making it an essential tool for modern developers and businesses looking to leverage the full power of cloud computing.

## Concepts related to AWS Fargate

- [Commitment Discounts](https://blowstack.com/tools/cloud-concepts-hub/commitment-discounts): Commitment discounts reduce cloud usage rates in exchange for a defined usage or spending commitment over a fixed term.
- [Compute](https://blowstack.com/tools/cloud-concepts-hub/compute): Compute is the processing capacity used to execute software, perform calculations, and run applications.
- [Container Orchestration](https://blowstack.com/tools/cloud-concepts-hub/container-orchestration): Container orchestration automates the deployment, placement, scaling, networking, and recovery of containerized workloads across compute resources.
- [Containers](https://blowstack.com/tools/cloud-concepts-hub/containers): Containers package applications and their dependencies into isolated processes that run using a compatible host operating-system kernel.
- [Ephemeral Storage](https://blowstack.com/tools/cloud-concepts-hub/ephemeral-storage): Ephemeral storage is temporary storage whose data is not guaranteed to survive the end or replacement of its associated compute environment.
- [Serverless](https://blowstack.com/tools/cloud-concepts-hub/serverless-and-event-driven-design-principles): Serverless is a cloud operating model in which the provider manages the underlying servers while customers deploy applications or use services without provisioning and maintaining those servers.
