Comparing Container Orchestration Services
ECS, EKS, GKE, AKS, Cloud Run and Azure Container Apps side by side: control, operations, networking, identity, upgrades and cost, and how to choose.
The previous four articles in this series looked at one platform at a time: Amazon ECS and EKS, Google Kubernetes Engine and Azure Kubernetes Service. Each one made sense on its own terms. The harder question comes when you have to pick one, or explain to someone else why you did.
This article puts them side by side. It compares the managed Kubernetes services against each other, places ECS and the serverless container platforms next to them, and ends with a way to decide. If containers themselves are new to you, start with Introduction to Containers and Docker.
Three kinds of service
Every option here runs the same thing: an OCI container image pulled from a registry. What differs is how much of the platform you see and manage. It helps to sort them into three groups before comparing details.
- Managed Kubernetes: Amazon EKS, Google Kubernetes Engine (GKE) and Azure Kubernetes Service (AKS). The provider runs the control plane; you get the full Kubernetes API, with its manifests, Helm charts, operators and custom controllers.
- Provider-native orchestrator: Amazon ECS. AWS designed its own scheduler and API. There is no Kubernetes underneath that you can reach, and nothing to upgrade.
- Serverless containers: Google Cloud Run and Azure Container Apps, plus ECS Express Mode on AWS. You hand over an image and some settings, and the platform handles instances, scaling (often to zero) and HTTPS endpoints.
flowchart TB
IMG["Container image"] --> K8S["Managed Kubernetes"]
IMG --> NAT["Provider-native orchestrator"]
IMG --> SRV["Serverless containers"]
K8S --> EKS["Amazon EKS"]
K8S --> GKE["Google GKE"]
K8S --> AKS["Azure AKS"]
NAT --> ECS["Amazon ECS"]
SRV --> CR["Google Cloud Run"]
SRV --> ACA["Azure Container Apps"]
SRV --> EXP["ECS Express Mode"]
Moving from left to right in that picture, you give up control and gain simplicity. Kubernetes gives you the most freedom and the most work. Serverless containers give you the least of both. ECS sits between them on AWS.
The groups are not walls. AWS has no direct counterpart to Cloud Run or Container Apps as a separate product, but ECS on Fargate with Express Mode covers much of the same ground. Azure Container Apps is built on Kubernetes and uses KEDA for scaling and Dapr for service-to-service APIs, but it does not expose the Kubernetes API to you. The cloud service models framing applies here too: managed Kubernetes behaves like infrastructure you configure, while serverless containers behave like a platform.
The managed Kubernetes services compared
EKS, GKE and AKS all pass the CNCF conformance tests, so a Deployment that runs on one runs on the others. The differences are in everything around the API: how nodes are provisioned, how pods get cloud credentials, how upgrades are scheduled and what the bill looks like.
Operating modes
All three providers now offer a hands-off mode alongside the classic configurable one, and the hands-off mode is what each recommends for most new clusters.
| Amazon EKS | Google GKE | Azure AKS | |
|---|---|---|---|
| Hands-off mode | EKS Auto Mode | Autopilot | AKS Automatic |
| Configurable mode | Managed node groups, self-managed nodes | Standard | AKS Standard |
| Node provisioning in hands-off mode | Karpenter-based, EC2 instances in your account | Google-managed capacity sized to pods | Karpenter-based node auto-provisioning |
| Hands-off billing | EC2 price plus Auto Mode charge per instance | Pod resource requests, per second | Standard tier fee plus provisioned compute |
| Per-pod isolated option | Fargate for EKS | No direct equivalent | No direct equivalent |
| Windows nodes | Yes, in configurable mode | Yes, in Standard | Yes, in AKS Standard |
The most important row is billing. GKE Autopilot is the only one that, for general-purpose workloads, bills by what your pods request rather than by the machines underneath them. Idle space on a node is Google’s problem, not yours. EKS Auto Mode and AKS Automatic both provision real VMs in your account and bill for them, so they automate the work of choosing and packing nodes, but unused capacity on those nodes still costs you. Their Karpenter-based consolidation reduces that waste by moving pods and removing nodes that are no longer needed.
Control plane, availability and fees
The control plane is where the providers look most alike. Each one charges a flat fee per cluster hour for production use, and each offers an uptime commitment on the API server.
| Amazon EKS | Google GKE | Azure AKS | |
|---|---|---|---|
| Cluster fee | $0.10 per hour on standard support | $0.10 per hour | Free tier: none. Standard tier: $0.10 per hour |
| Free option | None | $74.40 monthly credit per billing account, enough for one zonal or Autopilot cluster | Free tier, no SLA |
| API server SLA | 99.95%; 99.99% with Provisioned Control Plane | 99.95% regional, 99.5% zonal | 99.95% with availability zones on Standard tier |
| Extended version support | $0.60 per hour during extended support | Extra fee on the Extended channel | Long-term support on the Premium tier, $0.60 per hour |
At $0.10 an hour, a cluster costs about $73 a month before it runs anything. That is noise for a production platform and a real cost if every team or every feature branch gets a cluster. AKS’s free tier and GKE’s monthly credit make small development clusters cheaper on those two clouds. Fees change, so confirm current figures on the EKS, GKE and AKS pricing pages.
A team runs many small, uneven workloads and keeps finding half-empty nodes on its bill. Which hands-off mode removes the cost of unused node capacity entirely for general-purpose pods?
Correct! Autopilot bills general-purpose pods by their resource requests, while Auto Mode and AKS Automatic bill for the VMs they provision.
Networking
All three give pods addresses that the cloud network understands, which is what lets pods talk directly to databases and other services without extra hops. The defaults differ in where those addresses come from.
- EKS uses the Amazon VPC CNI, which gives each pod a real VPC IP address. Pods are first-class citizens on the network, but large clusters consume subnet space quickly, so plan VPC ranges generously.
- GKE uses VPC-native clusters with alias IP ranges, so pods have routable addresses from secondary ranges of the subnet. GKE Dataplane V2, built on eBPF and Cilium, enforces network policy.
- AKS recommends Azure CNI Overlay, where pods get addresses from a private range outside the virtual network. That saves address space, at the cost of pods not being directly reachable from outside the cluster. Azure CNI Powered by Cilium provides the eBPF data plane.
For traffic coming in, all three now support the Kubernetes Gateway API: the AWS Load Balancer Controller on EKS, the GKE Gateway controller, and the AKS application routing add-on or Application Gateway for Containers. Writing new routing rules as Gateway and HTTPRoute resources, rather than provider-specific Ingress annotations, is the single easiest way to keep manifests portable. The only line that usually changes between clouds is gatewayClassName.
Pod identity
Each cloud solved the same problem the same way: no long-lived keys in pods. A Kubernetes service account is mapped to a cloud identity, and the pod exchanges its service account token for short-lived cloud credentials.
sequenceDiagram
participant Pod
participant K8s as Kubernetes API
participant IdP as Cloud identity service
participant Svc as Cloud service
K8s->>Pod: Projected service account token
Pod->>IdP: Exchange token
IdP->>IdP: Check cluster issuer and mapping
IdP-->>Pod: Short-lived credentials
Pod->>Svc: Call API with credentials
| Amazon EKS | Google GKE | Azure AKS | |
|---|---|---|---|
| Feature | EKS Pod Identity (or IRSA) | Workload Identity Federation for GKE | Microsoft Entra Workload ID |
| Cloud identity | IAM role | IAM principal for the service account | User-assigned managed identity |
| Mapping lives in | Pod Identity association | IAM policy binding | Federated identity credential |
The flow is identical; the nouns and CLI commands differ. If you move a workload between clouds, this is one of the places where you rewrite setup scripts even though the pod code, using each provider’s SDK default credential chain, usually doesn’t change. The underlying identity systems are covered in AWS IAM, GCP IAM and Microsoft Entra.
Upgrades
Kubernetes ships a minor version roughly every four months, and every managed service makes you keep up. They differ in how much of that is automatic.
- GKE enrolls clusters in a release channel (Rapid, Regular, Stable or Extended) and upgrades them automatically within the maintenance windows and exclusions you set. This is the most automated of the three.
- AKS offers separate auto-upgrade channels for the Kubernetes version (
patch,stable,rapid) and for node OS images. AKS Automatic turns both on. - EKS gives each minor version 14 months of standard support, then 12 months of paid extended support. Control plane upgrades are otherwise a task you start, and in configurable mode you upgrade add-ons and node groups yourself. Auto Mode handles nodes and core add-ons.
ECS, Cloud Run and Container Apps have no Kubernetes version for you to track at all. For small teams, that alone can decide the question.
A two-person team on AWS wants to run a handful of web services and never schedule a cluster upgrade. Which option fits best?
Correct! ECS has no version to upgrade and Fargate removes the hosts, so there is no upgrade cycle to plan.
ECS and the serverless platforms
The managed Kubernetes services are often the wrong comparison point. Many workloads are a few stateless HTTP services, a queue worker and a scheduled job. For those, the question is not EKS versus GKE but whether you need Kubernetes at all.
| Amazon ECS on Fargate | Google Cloud Run | Azure Container Apps | |
|---|---|---|---|
| Deployment unit | Task definition and service | Service, job or worker pool | Container app or job |
| Scale to zero | No for services; Express Mode creates normal services | Yes for services | Yes on the Consumption profile, except apps that scale on CPU or memory |
| Scaling triggers | Target tracking on CPU, memory, request count, custom metrics | Requests and concurrency for services | HTTP, CPU, memory, or any KEDA scaler such as queue length |
| Billing | Task vCPU and memory per second | Per request lifetime by default, or per instance lifetime | Per second of usage on Consumption; dedicated profiles billed by node |
| Batch work | Standalone tasks, scheduled tasks | Cloud Run jobs | Container Apps jobs (manual, scheduled, event-driven) |
| Kubernetes API | No | No | No |
A few differences matter in practice:
- Idle cost. Cloud Run services and Container Apps on the Consumption profile can scale to zero, so a service with no traffic costs nothing for compute. An ECS service keeps at least the tasks you ask for running. For a low-traffic internal tool, that difference can be most of the bill.
- Event-driven scaling. Container Apps uses KEDA, so an app can scale on the length of a Service Bus queue or a Kafka topic, not just HTTP traffic. Cloud Run services scale on requests; for pull-based work it offers worker pools, which run continuously and bill per instance.
- Built-in microservice plumbing. Container Apps includes Dapr for service invocation, pub/sub and state, which some teams find useful and others never turn on. Cloud Run and ECS leave that to your code or to separate services.
- Ceiling. All three cap how far you can customize the host. No DaemonSets, no privileged containers, no custom kernel modules. If you need those, you need a Kubernetes node pool or your own EC2 instances.
This is also where the fastest path from image to URL lives. On Google Cloud, one command deploys a public HTTPS service:
gcloud run deploy hello-web \
--image us-docker.pkg.dev/my-project/apps/hello-web:1.0 \
--region us-central1 \
--allow-unauthenticated
The Azure equivalent creates the Container Apps environment if one doesn’t exist:
az containerapp up \
--name hello-web \
--resource-group rg-demo \
--location eastus2 \
--image myregistry.azurecr.io/hello-web:1.0 \
--target-port 8080 \
--ingress external
On AWS, ECS Express Mode produces a comparable result from an image, creating the cluster, service, Application Load Balancer and scaling policy for you. Unlike the other two, what it builds is a set of ordinary ECS and load balancer resources you can take over and edit later.
The same workload on each platform
The most portable part of any of these platforms is the container image. Everything around it is a deployment description, and the amount you have to rewrite depends on which group you move between.
flowchart LR
IMG["One image in a registry"] --> M1["Kubernetes manifests"]
IMG --> M2["ECS task definition"]
IMG --> M3["Cloud Run service YAML"]
IMG --> M4["Container Apps YAML"]
M1 --> P1["EKS, GKE, AKS"]
M2 --> P2["ECS"]
M3 --> P3["Cloud Run"]
M4 --> P4["Container Apps"]
Between EKS, GKE and AKS, a Deployment, Service and HTTPRoute carry over almost unchanged:
apiVersion: apps/v1
kind: Deployment
metadata:
name: web
spec:
replicas: 3
selector:
matchLabels:
app: web
template:
metadata:
labels:
app: web
spec:
serviceAccountName: web
containers:
- name: web
image: registry.example.com/hello-web:1.0
ports:
- containerPort: 8080
resources:
requests:
cpu: 250m
memory: 512Mi
limits:
memory: 512Mi
What changes is around the edges: the image registry host, the storage classes for persistent volumes, the gatewayClassName, the annotation or association that links the web service account to a cloud identity, and any cloud-specific load balancer settings. Helm charts and Kustomize overlays exist largely to hold those differences in one place.
Moving from Kubernetes to ECS, Cloud Run or Container Apps means writing a new deployment description from scratch, but the concepts map closely: image, port, CPU and memory, environment variables, secrets, health checks and replica bounds. That translation usually takes hours, not weeks. Your application code doesn’t change.
Where lock-in actually lives
Teams sometimes choose Kubernetes for portability and then tie every workload to one cloud anyway. The orchestrator is rarely the sticky part. These are:
- Managed data services. An app built around DynamoDB, Firestore or Cosmos DB moves only when its data does.
- Identity and networking. IAM roles, VPC design, private endpoints and DNS take longer to rebuild than any manifest.
- Observability and CI/CD. Dashboards, alerts and deployment pipelines tend to grow around one provider’s tools.
If multi-cloud portability is a real requirement, Kubernetes helps, but only alongside deliberate choices in those three areas. Deployment Models: Public, Private, Hybrid, and Multi-Cloud discusses when that effort pays off.
Cost in practice
Comparing these services on list prices alone is misleading, because the billing models differ more than the rates.
- Per-cluster fees matter when you run many small clusters. One shared cluster with namespaces per team is usually cheaper than a cluster per team, on every cloud.
- Node-based billing (EKS, AKS, GKE Standard, ECS on EC2) rewards dense packing. Accurate resource requests, consolidation and Spot capacity are the levers. Pricing Models: On-Demand, Reserved, Savings Plans, and Spot covers the discounts, which apply to cluster nodes like any other VM.
- Request-based billing (GKE Autopilot, Fargate, Cloud Run, Container Apps Consumption) charges a higher unit price but nothing for idle capacity. It wins when utilization would otherwise be low or spiky, and loses when a steady workload could keep cheaper nodes full.
- Scale to zero changes the picture for low-traffic services. A rarely used internal API on Cloud Run or Container Apps can cost close to nothing; the same API as a Kubernetes Deployment pays for its replicas around the clock.
The practical method is to price your real workload. Take the CPU and memory requests of the services you run, an estimate of how many hours they are busy, and run them through each provider’s calculator. The billing pages for AWS, GCP and Azure also explain how to set budgets before you start.
How to choose
Most decisions come down to a few questions, asked in order. The first one usually matters more than which cloud you pick.
flowchart TD
Q1{"Need the Kubernetes API?"} -->|"No"| Q2{"Mostly HTTP or event-driven?"}
Q1 -->|"Yes"| Q3{"Which cloud is home?"}
Q2 -->|"Yes"| SRV["Cloud Run or Container Apps"]
Q2 -->|"Yes, on AWS"| ECSF["ECS on Fargate"]
Q2 -->|"No, need host access"| K8S["Managed Kubernetes"]
Q3 -->|"AWS"| EKS["EKS, Auto Mode first"]
Q3 -->|"Google Cloud"| GKE["GKE Autopilot"]
Q3 -->|"Azure"| AKS["AKS Automatic"]
You need the Kubernetes API when you depend on operators (databases, message brokers, ML frameworks), Helm charts from vendors, custom controllers, DaemonSets, or a platform team that serves many product teams with one consistent interface. You also need it when you already run Kubernetes elsewhere and want one way of working.
You don’t need it when you run a modest number of stateless services and jobs, the team is small, and nobody wants to own cluster upgrades. Cloud Run, Container Apps or ECS on Fargate will get you to production faster and keep running with less attention.
If you need Kubernetes, choose the cloud first. The services are close enough that your existing provider, identity system and data almost always outweigh the differences between them. That said, a few strengths stand out:
| If you need | Strongest fit | Why |
|---|---|---|
| Least node management and per-pod billing | GKE Autopilot | Bills pod requests; release channels automate upgrades |
| Deep AWS integration and the largest ecosystem of AWS-specific add-ons | EKS | VPC-native pods, IAM-mapped identity, Auto Mode or Karpenter |
| Microsoft Entra, Azure Policy and Windows containers | AKS | Entra sign-in, Azure RBAC for Kubernetes, Windows node pools |
| No orchestration concepts at all on AWS | ECS | No version upgrades, no control plane fee |
| Scale to zero with event-driven triggers | Azure Container Apps | KEDA scalers and built-in jobs |
| The simplest path from image to HTTPS URL | Cloud Run | One command, request-based billing |
Many organizations end up with two of these on the same cloud: a serverless platform for straightforward services and a Kubernetes cluster for the workloads that need it. That is a reasonable outcome, not a failure to standardize, as long as images, CI pipelines and observability are shared between them.
An Azure team has a worker that processes Service Bus messages in bursts a few times a day and sits idle otherwise. They don't need Kubernetes. Which option fits best?
Correct! Container Apps can scale on queue length through KEDA and drop to zero between bursts on the Consumption profile.
Further reading
- Amazon EKS documentation and Amazon ECS documentation
- GKE documentation and Cloud Run documentation
- AKS documentation and Azure Container Apps documentation
- Kubernetes Gateway API
Key takeaways
- Container platforms fall into three groups: managed Kubernetes (EKS, GKE, AKS), the provider-native ECS, and serverless containers (Cloud Run, Container Apps, ECS Express Mode). Decide which group you need before comparing clouds.
- EKS, GKE and AKS all run conformant Kubernetes with hands-off modes (Auto Mode, Autopilot, AKS Automatic); only GKE Autopilot bills general-purpose pods by request instead of by node.
- Production control plane fees are $0.10 per cluster hour on all three, with free options for small clusters on GKE and AKS and higher fees for extended version support.
- Pod identity works the same way everywhere, exchanging a service account token for short-lived cloud credentials, but the setup commands differ.
- Gateway API resources keep routing rules portable across managed Kubernetes services; data services, identity and tooling are where lock-in really lives.
- Cloud Run and Container Apps can scale to zero, which makes them much cheaper for low-traffic services; ECS on Fargate is the simplest option on AWS.
- If you need Kubernetes, pick the service on the cloud you already use and start in its hands-off mode.
Part 5 of 5 · Container Services