AWS Fargate vs Cloud Run vs Azure Container Apps 2027

AWS Fargate vs Cloud Run vs Azure Container Apps 2027

AWS Fargate vs Cloud Run vs Azure Container Apps 2027

AWS Fargate vs Cloud Run vs Azure Container Apps 2027

What if your team picked a serverless container platform for reasons that will stop mattering long before 2027? Pricing pages change. Feature gaps close. Plan names get retired. Yet a few structural choices you make early tend to stick around for years, quietly shaping how your systems scale, fail, and get billed.

That is the frame worth using for AWS Fargate, Google Cloud Run, and Azure Container Apps. All three run containers without you managing servers. But they are not the same kind of product, and treating them as interchangeable is one of the most common and most expensive mistakes in cloud architecture planning.

Why These Three Platforms Get Compared So Often

The confusion is understandable. Each vendor markets its offering as “serverless containers,” and each one removes the node-management burden that used to define container operations. AWS Fargate launched at re:Invent in November 2017 as a serverless compute engine for containers, initially for Amazon ECS. Google Cloud Run reached general availability in November 2019 after a beta period that began in 2018. Azure Container Apps went GA in May 2022.

Three products, three launch dates, one shared promise: you bring a container image, the platform handles the infrastructure. From there, the paths split in ways that matter a great deal once real traffic arrives.

The Core Difference Is the Abstraction Boundary

The Core Difference Is the Abstraction Boundary

This is the single most important idea in the whole comparison, and it rarely appears on a feature matrix.

Fargate is serverless capacity. It is not a standalone platform. You run it through ECS or EKS, and your orchestrator still owns scheduling, service definition, and deployment logic. Fargate simply supplies the compute underneath, so you never touch an EC2 instance.

Cloud Run is a serverless request-serving platform. It runs stateless containers that respond to HTTP and gRPC traffic, and it is built around the request as the unit of work.

Azure Container Apps is a serverless application platform. It runs on Kubernetes under the hood, using KEDA for event-driven autoscaling, Dapr as an optional building block, and Envoy for ingress. You get those capabilities without operating a cluster.

Put differently: Fargate asks “what should run this container?” Cloud Run asks “what should serve this request?” Container Apps asks “what should host this application and everything around it?”

Scale-to-Zero: A Decision With Real Cost Consequences

Scale-to-zero sounds like a checkbox. In practice, it determines whether a whole class of workloads is economically viable.

Cloud Run scales to zero by default and bills per request plus CPU and memory consumed while handling requests. Container Apps supports scale-to-zero through KEDA scalers, which can react to HTTP traffic, queue depth, cron schedules, and more. Fargate has no scale-to-zero. A running task bills while it runs, priced per vCPU and per GB of memory per second, historically with a one-minute minimum billing granularity.

Behavior AWS Fargate Google Cloud Run Azure Container Apps
Scale to zero No Yes, by default Yes, via KEDA scalers
Billing unit vCPU and memory per second Per request plus resource time Consumption or dedicated plan
Orchestrator exposure ECS or EKS Abstracted Abstracted (Kubernetes inside)
Isolation model VM-level microVM per task Managed sandbox Managed, plan-dependent

For a spiky internal API that gets a few hundred requests a day, Fargate’s always-on billing is a hard sell. For a steady high-throughput service, the request-based math can flip the other way. The lesson is to model your actual traffic shape before committing, not to trust the marketing framing.

The Execution Model Trap Most Teams Hit

Here is a mistake that shows up again and again in real migrations. A team lifts a container from a VM or a Kubernetes cluster onto Cloud Run, deploys it, and watches background jobs silently stall.

The cause is Cloud Run’s request-scoped execution model. By default, CPU is throttled outside request handling unless you enable CPU always allocated. Background threads, async workers, queue consumers, and sidecars behave very differently than they do on Fargate, where the task simply keeps running.

The practical fix is to ask one question before choosing a platform: does this workload do useful work when nobody is calling it? If yes, Cloud Run needs explicit configuration, or the workload belongs somewhere else. If no, its request model is a clean fit.

The same discipline applies when comparing other infrastructure choices. The reasoning behind AWS vs Azure vs GCP GPU cloud pricing and architecture decisions follows a similar pattern: the durable decision is about workload shape, not the rate card.

Isolation and Multi-Tenancy: Read the Fine Print

Fargate’s isolation model is VM-level. Each task runs in its own microVM, which AWS has described as Firecracker-based, so tasks do not share a kernel. For multi-tenant platforms or workloads running untrusted code, that is a clear security boundary and often the deciding factor.

Cloud Run and Container Apps abstract the sandbox away, and the guarantees differ by plan and configuration. Container Apps, for instance, offers a consumption plan alongside dedicated plans built on workload profiles. That plan choice is simultaneously a cost decision and an isolation decision, and teams routinely treat it as only the former.

If your architecture involves running customer-supplied code, do not assume parity. Ask each vendor directly what the isolation boundary is and get it in writing.

Networking and Private Connectivity

Direct VPC egress arrived on Cloud Run around 2023 to 2024, and it changed how the platform fits into private networking. That is exactly the kind of feature that quietly reshapes an architecture decision, and it is a good reminder to re-evaluate assumptions rather than relying on a comparison you read two years ago.

Fargate inherits the networking model of ECS or EKS, which gives you fine-grained control but also more surface area to configure. Container Apps provides built-in ingress through Envoy, with VNet integration options.

The recurring theme is that these platforms converge over time. The architectural decisions that survive are the ones tied to your workload’s fundamental shape, not the ones tied to a feature that shipped last quarter. A broader multi-cloud framework for running workloads across AWS, Azure, and Google helps teams keep those fundamentals straight when the vendor landscape shifts.

How to Actually Make the Call

A practical decision process looks like this:

  • Classify each workload by traffic shape: steady, spiky, or event-driven.

  • Determine whether it does useful work outside request handling.

  • Decide whether you need VM-level isolation for untrusted or multi-tenant code.

  • Check whether you want an orchestrator you control or one you never see.

  • Model real monthly cost using your own traffic, not sample pricing.

  • Confirm current plan names and feature availability with the vendor before signing.

Steps five and six are where most planning documents go stale. Plan naming and feature parity shift constantly, and any forward-looking claim about 2027 needs a fresh primary source, not a blog post from 2024.

Common Mistakes Worth Avoiding

Three patterns come up repeatedly in architecture reviews.

The first is choosing Fargate for workloads that spend most of the day idle, then being surprised by the bill. The second is deploying background workers to Cloud Run without enabling CPU always allocated, then debugging phantom failures. The third is picking Container Apps’ consumption plan for a latency-sensitive service without testing cold-start behavior under realistic load.

None of these are platform flaws. They are mismatches between a workload’s shape and a platform’s model. The same mismatch logic applies when teams compare managed databases or frontend frameworks, as in these MongoDB vs PostgreSQL architecture decisions or this breakdown of React vs Vue architecture decisions. The tool is rarely the problem; the fit is.

What Actually Holds Up Through 2027

The durable architecture decisions are those three axes: abstraction level, scale-to-zero behavior, and isolation model. Those are structural properties of each product, and they change slowly.

The volatile parts are pricing, plan names, and feature parity. Those need fresh, dated primary sources every time you plan. Teams that build their 2027 roadmap around the stable axes, while treating the rest as a quarterly check, end up with far fewer painful migrations.

Conclusion

AWS Fargate, Cloud Run, and Azure Container Apps all remove server management, but they solve different problems. Fargate gives you serverless capacity under an orchestrator you still control. Cloud Run gives you a request-serving platform that scales to zero by default. Container Apps gives you an application platform with autoscaling and service-mesh building blocks baked in.

Pick based on how your workloads actually behave, verify the volatile details before you commit, and revisit the decision when your traffic shape changes. That approach will still serve you well long after 2027 arrives.

FAQ

Does AWS Fargate scale to zero?

No. Fargate has no scale-to-zero. A running task bills while it runs, priced per vCPU and per GB of memory per second, historically with a one-minute minimum billing granularity. Workloads that sit idle most of the day are usually a poor economic fit.

Is Cloud Run the same as Fargate?

No. Fargate provides serverless capacity beneath ECS or EKS, while Cloud Run is a request-serving platform built around HTTP and gRPC traffic. The execution models differ: Cloud Run throttles CPU outside request handling by default unless you enable CPU always allocated.

What is Azure Container Apps built on?

Azure Container Apps runs on Kubernetes, using KEDA for event-driven autoscaling, Dapr as an optional component, and Envoy for ingress. It reached general availability in May 2022 and offers a consumption plan alongside dedicated plans built on workload profiles.

Which platform offers the strongest isolation?

Fargate’s isolation is VM-level, with each task running in its own microVM so tasks do not share a kernel. That makes it a strong candidate for multi-tenant or untrusted workloads. Cloud Run and Container Apps abstract the sandbox, and guarantees vary by plan and configuration, so confirm the boundary directly.

Can Cloud Run run background workers?

It can, but not by default. Because CPU is throttled outside request handling unless CPU always allocated is enabled, background threads and async workers may stall. Teams migrating queue consumers or sidecars to Cloud Run need to configure this explicitly or choose a different platform.

How should a team choose between these three in 2027?

Classify each workload by traffic shape, decide whether it works outside request handling, and confirm whether you need VM-level isolation. Then model cost with your own traffic data and verify current plan names and features with the vendor, since pricing and parity change faster than the core architecture.

The FAQ answers above are deliberately short, but each one maps back to the same three structural axes. If a team can answer the scale-to-zero, execution-model, and isolation questions for a workload in a single sentence, the platform choice usually makes itself. If they cannot, no comparison table will rescue the decision.

One final practice is worth institutionalizing: keep a short, dated decision record for each workload. Note the traffic shape you assumed, the isolation boundary you required, and the vendor facts you verified on the day you chose. When pricing shifts or a new feature lands, you can re-read that record in minutes instead of reconstructing the reasoning from memory. That habit, more than any specific platform, is what keeps a 2027 roadmap honest.

Whichever platform you pick, treat it as a fit decision rather than a loyalty decision. Workload shapes change, and a container that belonged on Fargate last year may belong on Cloud Run next year. Revisit the choice on a schedule, not only when something breaks.

on this page