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.

Cloud

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 EKSGoogle GKEAzure AKS
Hands-off modeEKS Auto ModeAutopilotAKS Automatic
Configurable modeManaged node groups, self-managed nodesStandardAKS Standard
Node provisioning in hands-off modeKarpenter-based, EC2 instances in your accountGoogle-managed capacity sized to podsKarpenter-based node auto-provisioning
Hands-off billingEC2 price plus Auto Mode charge per instancePod resource requests, per secondStandard tier fee plus provisioned compute
Per-pod isolated optionFargate for EKSNo direct equivalentNo direct equivalent
Windows nodesYes, in configurable modeYes, in StandardYes, 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 EKSGoogle GKEAzure AKS
Cluster fee$0.10 per hour on standard support$0.10 per hourFree tier: none. Standard tier: $0.10 per hour
Free optionNone$74.40 monthly credit per billing account, enough for one zonal or Autopilot clusterFree tier, no SLA
API server SLA99.95%; 99.99% with Provisioned Control Plane99.95% regional, 99.5% zonal99.95% with availability zones on Standard tier
Extended version support$0.60 per hour during extended supportExtra fee on the Extended channelLong-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?

  • GKE Autopilot
  • EKS Auto Mode
  • AKS Automatic

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 EKSGoogle GKEAzure AKS
FeatureEKS Pod Identity (or IRSA)Workload Identity Federation for GKEMicrosoft Entra Workload ID
Cloud identityIAM roleIAM principal for the service accountUser-assigned managed identity
Mapping lives inPod Identity associationIAM policy bindingFederated 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?

  • EKS with managed node groups
  • EKS on the extended support policy
  • ECS on Fargate

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 FargateGoogle Cloud RunAzure Container Apps
Deployment unitTask definition and serviceService, job or worker poolContainer app or job
Scale to zeroNo for services; Express Mode creates normal servicesYes for servicesYes on the Consumption profile, except apps that scale on CPU or memory
Scaling triggersTarget tracking on CPU, memory, request count, custom metricsRequests and concurrency for servicesHTTP, CPU, memory, or any KEDA scaler such as queue length
BillingTask vCPU and memory per secondPer request lifetime by default, or per instance lifetimePer second of usage on Consumption; dedicated profiles billed by node
Batch workStandalone tasks, scheduled tasksCloud Run jobsContainer Apps jobs (manual, scheduled, event-driven)
Kubernetes APINoNoNo

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 needStrongest fitWhy
Least node management and per-pod billingGKE AutopilotBills pod requests; release channels automate upgrades
Deep AWS integration and the largest ecosystem of AWS-specific add-onsEKSVPC-native pods, IAM-mapped identity, Auto Mode or Karpenter
Microsoft Entra, Azure Policy and Windows containersAKSEntra sign-in, Azure RBAC for Kubernetes, Windows node pools
No orchestration concepts at all on AWSECSNo version upgrades, no control plane fee
Scale to zero with event-driven triggersAzure Container AppsKEDA scalers and built-in jobs
The simplest path from image to HTTPS URLCloud RunOne 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?

  • An AKS Standard cluster with the cluster autoscaler
  • Azure Container Apps with a KEDA Service Bus scaler
  • An AKS Automatic cluster with three replicas

Correct! Container Apps can scale on queue length through KEDA and drop to zero between bursts on the Consumption profile.

Further reading

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

  1. 01Introduction to Containers and Docker
  2. 02AWS Elastic Container Service (ECS) and EKS
  3. 03Google Kubernetes Engine (GKE)
  4. 04Azure Kubernetes Service (AKS)
  5. 05Comparing Container Orchestration Services
Ready to check your understanding?Take the Fluffy Computing quiz
esc

Type to search all articles · ↑↓ to move · ↵ to open