Cloud Container Services Without Kubernetes: ECS, ACI, Cloud Run
A decision-focused look at what managed container platforms give you without Kubernetes — ECS/Fargate's task model, Azure ACI's image-security controls, and Cloud Run's revision-based deploys — and when the platform beats running a cluster.
Published on • November 15, 2026
AI Assistant

The implicit assumption of most cloud-native writing is that “containers in production” means Kubernetes. It doesn’t. Three of the largest clouds run container platforms that never expose a pod, a node, or an etcd member to you: AWS ECS with the Fargate launch type, Azure Container Instances, and Google Cloud Run. You push an image, declare how much CPU and memory it needs, and the provider does the scheduling, placement, health management, and (in two of the three cases) scaling. This post is a decision guide: what each platform actually gives you, where it costs more — in dollars and in lock-in — and the situations where a managed platform beats a cluster you own. (The mechanics of serverless-container pricing and scaling models are covered separately in our earlier comparison; here the question is narrower: should we skip Kubernetes at all?)
What the platforms give you
ECS on AWS: the task model
ECS’s unit of work is a task: a task definition (JSON/YAML) declaring one or more containers, their CPU and memory, environment, IAM task role, and logging, then a service that maintains a desired count of those tasks behind an Application Load Balancer. With the Fargate launch type, AWS owns the underlying instances entirely — there are no EC2 workers to patch, no AMI pipeline, no capacity reservations to manage.
{
"family": "shop-api",
"networkMode": "awsvpc",
"requiresCompatibilities": ["FARGATE"],
"cpu": "512",
"memory": "1024",
"containerDefinitions": [
{
"name": "api",
"image": "123456789012.dkr.ecr.us-east-1.amazonaws.com/shop-api:1.4.2",
"portMappings": [{ "containerPort": 3000 }],
"healthCheck": {
"command": ["CMD-SHELL", "curl -sf http://localhost:3000/healthz || exit 1"],
"interval": 30, "timeout": 5, "retries": 3
}
}
]
}
What you keep: services with rolling-update behavior (maximumPercent/minimumHealthyPercent), integration with ALB, CloudWatch logs, IAM task roles (per-service least privilege, better than most cluster setups manage), and service discovery via Cloud Map or internal DNS. What you skip: the entire cluster lifecycle — no control plane version upgrades, no node draining, no kubelet certificates.
Azure Container Instances: a container group, per second
ACI is the most “serverless” of the three in structure: you create a container group (one or more containers sharing a network namespace, like a pod without the word), give it a CPU/memory size, and it runs — billed per second with a one-minute minimum. There is no service abstraction, no desired count, and no built-in load balancer across instances; scaling is your code, a Logic App, or Azure Container Apps layered on top.
The place ACI punches above its weight is image security, and it’s worth being specific because it’s the differentiator in regulated environments. Microsoft’s guidance for container instances recommends and supports:
- Private registries only — pull from Azure Container Registry (or another approved registry) authenticated via Microsoft Entra ID service principals with role-based pull permissions, instead of anonymous Docker Hub pulls.
- Vulnerability scanning in the registry — ACR optionally integrates with Microsoft Defender for Cloud, whose Qualys-based scanner scans Linux images on push, classifies CVEs, and gives remediation guidance. Third-party scanners (Aqua, Twistlock/Prisma Cloud) plug into the same pipeline.
- Image signing and verification — ACR supports Docker content trust so publishers sign images and consumers pull only signed images; combined with a “permit only approved registries” policy, you get a verifiable chain of custody from build to container group.
- Scan-before-push in CI — the pipeline fails on vulnerabilities, so a known-bad image never reaches the registry production pulls from.
- Secrets via Key Vault, least-privilege RBAC, and network segmentation around the running group.
That list is not ACI-specific plumbing — it’s the container-lifecycle discipline any platform should enforce — but ACI + ACR + Defender gives it first-class tooling without you administering anything.
Cloud Run: revisions and scale-to-zero
Cloud Run’s unit is a service that owns a stream of revisions. Every deploy creates an immutable revision; traffic can be split between revisions (--traffic-revisions tag=rev-a=100 or gradual --update-traffic tag=LATEST=90,rev-old=10), and rollback is moving traffic back — no image rebuild, no pod churn. Autoscaling is request-based with a concurrency target (default 80 requests per container instance, configurable up to 1000), it scales to zero when idle, and you can set min-instances to keep a warm floor. Billing is per vCPU-millisecond and GB-millisecond while processing, which makes idle services cost effectively nothing.
Cloud Run also supports fully managed jobs (batch workloads with no HTTP surface) and direct-VPC egress, which removes the usual “serverless can’t talk to my VPC” objection.
Side-by-side: the decision axes
| Axis | ECS + Fargate | Azure ACI | Cloud Run |
|---|---|---|---|
| Unit of work | Task (in a service) | Container group | Service → revision |
| Rolling updates | Yes, built into service | No (replace the group) | Yes, via traffic split |
| Autoscaling | Service auto scaling (CPU/ALB/request) | None natively | Request/concurrency, to zero |
| Billed | Per vCPU/hr + GB/hr (Fargate), always-on | Per second, running only | Per ms, running only |
| Networking | VPC, awsvpc mode, ALB | VPC join, static IP options | Direct VPC, ingress controls |
| Max scale ceiling | Very high (account quotas) | Low per group | High, but request-latency bound |
| Portability | ECS API + task definitions | ACI ARM/Bicep | Cloud Run API (Knative-derived) |
Pricing shape: ECS/Fargate charges for allocated compute whether or not traffic flows — predictable, but idle services cost real money. ACI and Cloud Run bill only while running; ACI charges for the group’s whole lifetime once started (no scale-to-zero), Cloud Run scales to zero so an internal tool can cost cents a month. ACI’s per-second model is excellent for bursty jobs; Fargate’s always-on model is better when you need a stable floor.
Networking: all three integrate with the provider VPC, but the shapes differ — ECS gets the deepest load-balancer integration (ALB/NLB, target groups, host/header rules), ACI gets simplest VNet attachment but you assemble the front door yourself, and Cloud Run gives managed ingress plus IAM-based authentication on the endpoint itself (--no-allow-unauthenticated means the platform does your authn).
Portability and lock-in: all three lock you in at the API level. Cloud Run is Knative-derived and the closest to portable (its container contract is plain OCI with a few platform annotations); ECS task definitions map ~1:1 onto containers but the surrounding fabric (ALB, IAM, CloudWatch) is AWS-shaped; ACI groups are the most minimal abstraction and therefore the least to un-learn, but the surrounding security story is deeply ACR/Defender-shaped. The realistic portability unit is the container image plus a thin deployment manifest — keep business logic out of platform APIs and migration stays a weekend project rather than a rewrite.
Team skill cost: this is the number people forget. ECS needs someone who understands IAM task roles, awsvpc networking, and CloudWatch; Cloud Run needs almost nothing beyond a Dockerfile and IAM; ACI sits in between. None of them need anyone to learn pods, CRDs, or control-plane upgrades. For a three-person team, that saved learning budget is the actual product feature.
When the platform beats a cluster
The managed platform wins when all of these hold:
- Your workload is a handful of HTTP services and jobs, not a platform. Fewer than roughly 15–20 services, one or two environments, no per-tenant namespaces.
- You have no platform team. A cluster is a part-time job for at least one engineer forever (upgrades, CVEs, etcd, CNI, ingress). If nobody’s title includes “platform”, you are borrowing against future you.
- Traffic is spiky or bursty. Scale-to-zero and request-based scaling turn a $400/month always-on cluster into a $20 bill.
- You need to be shipping this quarter. Time-to-first-production-deploy on Cloud Run or ECS is measured in hours; on a well-run cluster, days to weeks including the pipeline.
- Compliance favors managed controls. Defender-for-Cloud image scanning, Entra-authenticated pulls, and provider audit logs are evidence your auditor already accepts.
The cluster wins when you need multi-tenancy with hard isolation, custom scheduling (GPU topology, daemon-style node agents), deep network policy, hybrid/on-prem consistency, or a rich extension ecosystem (service mesh, GitOps operators, custom operators). And a hybrid is legitimate: run the platform for the boring web tier and reserve Kubernetes for the workloads that actually need it.
The honest failure mode is treating “no Kubernetes” as “no engineering.” You still need healthchecks, CI image scanning, secrets management, load-testing, and an incident runbook — the platform just deletes the cluster-lifecycle portion of that list. Skip Kubernetes when the platform’s defaults match your workload’s shape; adopt it when your scheduling, isolation, or extension requirements outgrow those defaults, not when a conference talk tells you to.
References
- Azure — Security considerations for container instances
- Microsoft Defender for Cloud — Container registry scanning (Qualys)
- Azure Container Registry — Content trust / image signing
- AWS — Amazon ECS task definitions and the Fargate launch type
- Google Cloud — Cloud Run revisions and traffic splitting
- Google Cloud — Cloud Run concurrency and autoscaling