Containers & Compute Compared: Cloudflare Workers/Containers vs AWS ECS/EKS vs Azure AKS vs Google GKE

Introduction

The container and compute category is where Cloudflare's architectural divergence from the hyperscalers is most pronounced. AWS, Azure, and Google have spent a decade building container orchestration platforms — managed Kubernetes, serverless containers, and rich ecosystems of tools for deploying, scaling, and managing containerized applications.

Cloudflare took a fundamentally different path. Instead of containers, Cloudflare built compute around V8 isolates (Workers) — lighter, faster, and more globally distributed, but more constrained. Cloudflare has more recently added container support for workloads that exceed Workers' limits, but the primary philosophy remains: if a workload can run in an isolate, it should.

This comparison examines three compute models:

1. Edge isolates (Cloudflare Workers) — sub-millisecond startup, global deployment, constrained resources
2. Managed Kubernetes (EKS, AKS, GKE) — full orchestration, maximum flexibility, operational complexity
3. Serverless containers (Fargate, Cloud Run, Container Apps) — container flexibility without cluster management

Understanding when each model wins is more useful than declaring a single winner.

Compute Architecture Spectrum

The four providers offer compute at different points on the complexity-capability spectrum:

Simpler ←——————————————————————————→ More Capable

Workers ──→ Cloud Run ──→ Fargate/Container Apps ──→ Kubernetes ──→ Bare VMs
(isolates)   (serverless    (serverless containers     (orchestrated    (full control)
              containers)    in cluster)                 containers)

Each step right adds capability and operational complexity. Each step left adds simplicity and constraints.

Cloudflare: Edge Compute Model

Workers (V8 Isolates)

Covered in detail in the serverless comparison, Workers are Cloudflare's primary compute primitive. Key constraints for this comparison:

These constraints are by design — they enable sub-millisecond startup and global deployment. But they also mean Workers cannot run many workloads that containers handle easily.

Cloudflare Containers (Newer)

Cloudflare's container platform (launched 2025) runs OCI-compatible containers on Cloudflare's edge network:

Cloudflare Containers bridge the gap between Workers and traditional container platforms. A typical pattern: Workers handle the request/response edge layer (routing, auth, caching) and delegate compute-heavy operations to containers running on the same network.

Limitations to acknowledge: Cloudflare's container platform is newer than any hyperscaler equivalent. It lacks the ecosystem depth, tooling maturity, and orchestration capabilities of EKS/AKS/GKE. There is no Kubernetes API, no service mesh, no Helm charts, no established operational patterns. For simple containerized workloads, this simplicity is an advantage. For complex microservice architectures, it is a limitation.

The Workers + Containers Pattern

Cloudflare's recommended architecture for complex applications:

User Request
  → Workers (edge: routing, auth, caching, personalization)
    → Container (heavy compute: ML inference, image processing)
    → D1/KV/R2 (data: storage, state, objects)
  → Response (assembled at edge)

This is architecturally elegant: the edge handles what it is good at (low-latency request processing), and containers handle what they are good at (compute-heavy tasks). The pieces run on the same network.

AWS Container Ecosystem

AWS has the most comprehensive container ecosystem — three orchestrators, two compute engines, and deep integration across the AWS service catalog.

ECS (Elastic Container Service)

ECS is AWS's proprietary container orchestrator — simpler than Kubernetes, with zero control plane cost.

ECS advantages over EKS:

• No control plane cost ($73/month savings)
• Simpler mental model (tasks, services, clusters vs pods, deployments, services, ingress, etc.)
• Deeper AWS integration (IAM task roles, native ALB integration, CloudWatch)

ECS disadvantages:

• AWS-only (not portable to other clouds)
• No Helm, Kustomize, or Kubernetes ecosystem tools
• Smaller community and fewer third-party integrations

EKS (Elastic Kubernetes Service)

EKS is managed Kubernetes on AWS. AWS manages the control plane; you manage worker nodes (or use Fargate for serverless pods).

Fargate (Serverless Compute Engine)

Fargate eliminates node management for both ECS and EKS. You define CPU and memory per task/pod, and Fargate provisions isolated compute.

Fargate is more expensive per-resource than EC2 but eliminates node provisioning, patching, scaling, and capacity planning. For variable workloads, the simplicity often justifies the premium.

Azure Container Ecosystem

AKS (Azure Kubernetes Service)

AKS is Azure's managed Kubernetes with a free control plane — the most notable pricing advantage over EKS.

AKS's free control plane makes it the cheapest managed Kubernetes for experimentation and development. Windows container support is strongest on AKS — relevant for .NET Framework workloads that cannot run on Linux.

Azure Container Apps

Container Apps is Azure's serverless container platform, built on Kubernetes and KEDA but abstracting away all cluster management:

Container Apps is Azure's most direct competitor to Cloud Run and AWS Fargate on ECS. The Dapr integration is unique — Dapr provides language-agnostic building blocks (service invocation, state stores, pub/sub, bindings) that simplify microservice development without Kubernetes-level complexity.

Google Cloud Container Ecosystem

GKE (Google Kubernetes Engine)

GKE is widely considered the most mature managed Kubernetes platform — unsurprising given that Google created Kubernetes.

GKE Autopilot deserves special attention: it is the closest thing to "serverless Kubernetes" — you define pods and GKE handles nodes, scaling, security patches, and resource optimization. Pricing is per-pod, and you never interact with nodes. This eliminates the biggest operational burden of Kubernetes (node management) while preserving full Kubernetes API compatibility.

Cloud Run

Cloud Run is Google's serverless container platform and the cleanest "deploy a container, get a URL" experience:

Cloud Run's killer feature: concurrency. Unlike AWS Lambda (1 request per instance) or even Fargate (you manage concurrency), Cloud Run handles up to 1,000 concurrent requests per instance. This dramatically reduces the number of instances needed and minimizes cold starts.

Comparison: When Each Model Wins

Feature Comparison

Cost Comparison: Same Workload, Different Platforms

Scenario: API backend serving 10M requests/month, 100ms average processing, 512MB memory

Workers is cheapest by a wide margin for workloads that fit its constraints. Serverless containers (Cloud Run, Container Apps) are next. Managed Kubernetes is most expensive due to always-running control plane and node costs — but the cost includes capabilities (service mesh, persistent storage, custom networking) that simpler platforms lack.

Scenario: ML inference service, 4 vCPU, 16GB memory, always running

For compute-heavy, always-running workloads, self-managed nodes on Kubernetes with spot/preemptible instances are dramatically cheaper than serverless containers. The trade-off is operational complexity.

Calculate Your Costs

Use the calculator below to estimate costs for your specific workload:

The Container vs Isolate Decision

This is the fundamental architectural choice in this comparison:

Choose Isolates (Workers) When:

• Latency is paramount — 0ms cold start, response from nearest of 310+ locations
• Workloads are stateless HTTP — API proxies, middleware, edge routing, personalization, auth
• Memory needs are modest — under 128MB, no large runtimes or datasets in memory
• Execution is short — under 30 seconds, typically under 1 second
• JavaScript/TypeScript is acceptable — or you can compile to WASM
• Global deployment is valuable — your users are distributed worldwide

Choose Serverless Containers (Cloud Run, Container Apps, Fargate) When:

• You need full language runtimes — Python with ML libraries, Java with Spring, .NET, Go with CGO
• Memory needs are moderate — 512MB to 32GB
• You want container simplicity — deploy an image, get a URL, auto-scale
• Cold starts are tolerable — 1-10 seconds is acceptable for your use case
• You do not need Kubernetes — no service mesh, no custom scheduling, no persistent volumes
• Scale-to-zero matters — pay only when processing requests

Choose Kubernetes (EKS, AKS, GKE) When:

• Complex microservices — service mesh, custom networking, inter-service communication patterns
• Stateful workloads — databases, message queues, cache servers running in the cluster
• GPU workloads — ML training, inference, video processing requiring GPU scheduling
• Custom scheduling — node affinity, taints, tolerations, priority classes
• Maximum control — you want to define every aspect of the deployment, scaling, and networking
• Portability — Kubernetes API is the same across clouds (with provider-specific extensions)
• Existing investment — your team has Kubernetes expertise and established operational practices

The Honest Assessment

Cloudflare's compute model is the most architecturally distinct in cloud computing. Workers are not "containers lite" — they are a different paradigm: globally distributed, sub-millisecond startup, request-level isolation, CPU-time billing. For the workloads they support, Workers deliver better latency at lower cost than any container platform.

But "the workloads they support" is a significant qualifier. You cannot run a Django application on Workers. You cannot run a JVM-based microservice. You cannot process a 1GB file in memory. You cannot train an ML model. For these workloads — which represent the majority of enterprise compute — container platforms (Kubernetes or serverless) remain necessary.

Cloudflare Containers address part of this gap, but the platform is nascent compared to the hyperscaler container ecosystems that have been maturing for a decade. If you need Kubernetes today, EKS, AKS, or GKE are the choices. If you need serverless containers, Cloud Run and Azure Container Apps provide the best developer experience.

The most forward-looking architecture: Workers at the edge for request handling + serverless containers in a region for heavy compute + Kubernetes for complex orchestration when needed. This layered approach matches each workload to the compute model that best serves it — and Cloudflare's container platform may eventually absorb the middle tier as it matures.

Among the hyperscalers: GKE is the most mature Kubernetes (Google built Kubernetes), Cloud Run is the best serverless container experience (simplest deployment, best concurrency model), ECS is the best AWS-native orchestrator (simplest, free control plane), and AKS offers the best value (free control plane, best Windows support). The choice depends more on your existing cloud investment than on container platform quality — all three hyperscalers offer excellent container infrastructure.