ECS to EKS Without Freezing the Roadmap, With AI Reading the Terraform (Webinar Replay)
Replay and recap of our November 17 live session: when ECS is still the right call, the two AWS quotas that push teams to EKS, why the containers are the easy part, how an agent assesses a legacy ECS Terraform stack, and the zero-downtime plan it builds to move an app to EKS while keeping its egress IP. Chapters, timestamps and key takeaways.
In our November 17 live session, Guillaume Da Silva, Staff Solutions Architect at Qovery, explained when to leave Amazon ECS for Amazon EKS, why these migrations stall, and how to move without freezing the roadmap. In the demo, he showed how an agent read the ECS Terraform behind a running app and planned a move to EKS that keeps the egress IP and the database, with no downtime. I opened the session and handed over to him for the talk and the demo.
This page has the full replay, a chapter list, and the points worth keeping. Every section links to the exact moment in the video.
If ECS works for your team, stay on it. Move when you need the Kubernetes ecosystem, full-stack preview environments, a path outside AWS, or GPU tooling built for Kubernetes.
Two quotas push growing teams off ECS: 100 target groups per load balancer, which caps preview environments, and 10 containers per task definition, which caps sidecars.
The containers are the easy part. Observability, service discovery, secrets, IAM, networking, CI/CD and Terraform all need rework, and that is where migrations stall.
Use an agent to read the legacy Terraform, then check its output. It reads a large stack in minutes and maps every resource. It can also invent resources or drop a security group, so validate before you apply.
Run in parallel, but set a cutover date. Size migration waves in weeks, shift traffic in canary steps, watch error rates, and roll back to ECS at the first spike.
Keep the VPC and the NAT gateways. That keeps your egress IPs, so partners who allowlist them never notice the move.
Amazon ECS is AWS's own container orchestrator, generally available since 2015. Its purpose is to run containers without the complexity of Kubernetes. It is proprietary, so there is some lock-in, but the workloads are standard containers that run anywhere.
Guillaume mapped its building blocks to their Kubernetes equivalents (watch at 06:12):
ECS
Kubernetes
What it does
Task definition
Pod template
Image, CPU, memory, IAM role and the rest of the container configuration
Service
Deployment
Keeps a set number of tasks running and replaces the ones that die
Task
Pod
One running copy, with its containers
Tasks run on EC2 instances you manage, on Fargate (serverless), or on the newer ECS Managed Instances, which sit between the two.
ECS suits pragmatic teams who need to run compute and do not want to learn Kubernetes. Many come from Heroku or Beanstalk and want to keep a similar experience (watch at 07:44). Guillaume was clear that it is a good choice for them.
Neither is better in every situation. Guillaume compared them point by point:
The orchestrator. ECS is a closed service run by AWS. EKS is close to vanilla Kubernetes, managed by AWS, so you can move to another Kubernetes cluster later.
Control plane cost. The ECS control plane is free. EKS charges about $73 per month per cluster. That is small for one large cluster, but adds up with 10, 20 or 30 clusters for multi-tenant setups. Watch at 09:26
Capabilities. Both run your containers behind a load balancer with roughly the same features.
AWS integration. ECS wins. You assign an IAM role to the task and you are done. On EKS you link a Kubernetes service account to an IAM role through IRSA or EKS Pod Identity. Watch at 10:28
Ecosystem. EKS wins. Helm charts, operators and CNCF tools assume Kubernetes. On ECS you rewrite a chart into task definitions and services by hand. Watch at 11:20
Express Mode gives a platform-as-a-service experience: you hand over a container and AWS handles the load balancer and scaling. Guillaume noted it works for up to 25 services, and that the more AWS manages for you, the more you pay.
Managed Instances sit between EC2 and Fargate and add GPU support, which matters for AI workloads.
Guillaume's rule is to move only when something hurts. If one or more of these apply, start planning:
You want Helm charts and CNCF tools without rewriting them for ECS.
You want a full-stack preview environment for every pull request. EKS does not do this on its own either, but Qovery does it on top of Kubernetes. On ECS it takes a lot of glue code. Watch at 13:49
You need to run outside AWS, or in more regions. Kubernetes is a standard you can deploy on other clouds and distributions. ECS keeps you on AWS. Watch at 14:27
You want agent sandboxes or the GPU operator. ECS supports GPUs, but most GPU tooling, starting with NVIDIA's, is built for Kubernetes. Watch at 15:06
If none of these apply and ECS works, stay. Guillaume made the same point about Heroku in our September session: keep the service that works for you.
AWS has many service quotas, and most are far away. Guillaume singled out two:
100 target groups per Application Load Balancer. Each ECS service behind the load balancer needs one. With a preview environment per pull request, and AI agents working on seven, eight or ten features at once, you hit the ceiling fast. Watch at 16:37
10 containers per task definition. Security, logging and performance tools that run as sidecars eat into that budget. Watch at 17:22
Your images already sit in a registry, and EKS can pull them as they are. Everything around them needs rework:
Observability. ECS ships logs and metrics to CloudWatch natively. On Kubernetes you deploy your own stack, such as Prometheus and Grafana, Elastic and Kibana, or a vendor agent like Datadog running as a DaemonSet on every node. Watch at 18:55
Service discovery. ECS needs Cloud Map. Kubernetes has DNS built in. The way services find each other changes, and that can mean code changes. Watch at 19:31
Secrets. Task definitions reference Secrets Manager, Parameter Store or Vault. On Kubernetes you use Kubernetes secrets, or the External Secrets Operator, which Qovery supports, so the secrets stay where they are and only the way you fetch them changes. Watch at 20:06
IAM. Task roles become a service account linked to an IAM role through a trust relationship. It is not hard to set up, but it is easy to get wrong. Watch at 20:39
Networking. If your VPC is well sized, keep it. Same VPC, same NAT gateways, same egress IPs, so partners and customers who filter on your IP see nothing change. Watch at 21:29
CI/CD. You don't deploy to Kubernetes the way you deploy to ECS, so every workflow and command changes. Watch at 21:54
Terraform. The resources are different, so the infrastructure code needs a full rewrite. Watch at 22:10
Terraform is where AI saves the most time (watch at 22:46). The Terraform behind an ECS estate is often large and nobody on the current team owns it. An agent can read all of it, list every resource, and write the new version.
Run the same migration on your ECS stack.
Create an EKS cluster in your existing VPC with Qovery, import your ECS Terraform, and move services one wave at a time. Workloads and data stay in your AWS account.
Rewrite everything by hand. You turn every task definition, some written years ago by people who have left, into Kubernetes manifests. That rewrite becomes your roadmap. Guillaume does not recommend it, even less now that AI can do the reading.
Long parallel run. You build the new platform next to the old one. It works, but without an end date it can last months or years, and you pay for both. Qovery has seen teams start a migration and never finish it because the parallel run felt comfortable. Watch at 23:45
New features only. New services go to Kubernetes and legacy stays on ECS. It is safe for production, but full migration takes years, and in the meantime you run two platforms and the technical debt stays on ECS. Watch at 24:28
What Qovery recommends is a parallel run with an end date (watch at 25:16). Bring up EKS, try it, then move one application at a time in waves sized in weeks: two weeks for application A, two more for application B.
An agent reads the legacy Terraform, analyses it and plans the migration quickly. But AI is not deterministic, and it can invent resources, forget a security group or put in a wrong IP. Compare and validate every change before you apply it.
Guillaume set out to move an application from ECS to EKS without changing its egress IP, without migrating its RDS database, and without downtime. To fit the time slot, he ran the assessment with an agent before the session. For the cutover, he prepared scripts with AI rather than letting an agent run it live, so each step stays visible.
The demo app, AcmeShop, runs on Fargate with three services: a web front end, an API that talks to the database, and background workers. Each task is small: half a vCPU and half a GB of memory. A page shows which platform served each request (all ECS at this point) and the external IP a partner has allowlisted. That IP must not change.
Guillaume uses an agent interface he built for his own needs. He opened a session with Claude in the folder that holds the ECS Terraform and asked one thing: list what needs to move to Qovery. The agent read the code and mapped each resource to its Qovery equivalent (watch at 32:14):
Services: the web service (two tasks behind the load balancer, Python 3.12 on Alpine), the API and the worker, with their environment variables.
Dependencies: the Postgres database, secrets, an SQS queue, a Lambda function that plays the partner checking the egress IP, the VPC, Cloud Map for service-to-service calls, the load balancer and CloudWatch logs.
In Qovery, an organization holds projects, a project groups the applications that ship together and share an owner, and each environment is a Kubernetes namespace where the services run.
Guillaume imported the ECS Terraform stack as a Terraform service first so its outputs are available to everything else in the environment (watch at 35:35): the security group to attach to, the database URL, username, password and endpoint, the SQS queue ARN. Nothing gets copied by hand from ECS or hard-coded in the new stack. Qovery also has its own Terraform provider, so the new setup can live in code too.
The agent then created the web and API services, the two needed for the demo (watch at 36:21). Each one points at the same container image and tag, with the start arguments the agent copied from the ECS task definition, and the same half vCPU and half GB of memory. Autoscaling uses HPA on CPU and memory, and Qovery also supports KEDA for scaling on custom metrics like SQS queue depth. Watch at 37:24
Ask your agent to inventory your ECS Terraform first, as Guillaume did. Then install the Qovery skills so it can create the environment and services on Qovery:
Only if you need something ECS does not give you: Helm charts and CNCF tools, a preview environment for every pull request, a path to other clouds or regions, or GPU tooling built for Kubernetes. If ECS works for your team, stay on it.
Can I keep the same egress IP when moving from ECS to EKS?
Yes. Create the EKS cluster in the same VPC and keep the same NAT gateways. Outbound traffic leaves through the same IPs, so partners who allowlist them see no change.
Do I need to migrate my database?
No. In the demo, the RDS database stayed where it was. The new services on EKS read its connection details from the outputs of the imported ECS Terraform stack.
Can AI rewrite my ECS Terraform for EKS?
It can read a large Terraform stack quickly, list the resources and draft the new code. It can also invent resources or drop one, like a security group. Review and validate the changes before you apply them.
How long should the parallel run last?
Set a cutover date before you start, and size each migration wave in weeks. A parallel run with no end date can last years and you pay for both platforms.
What ECS limits push teams to EKS?
The two that matter most are 100 target groups per Application Load Balancer, which caps preview environments, and 10 containers per task definition, which caps sidecars.
Romaric founded Qovery to make Kubernetes accessible to every engineering team. He writes about platform strategy, developer experience, and the future of cloud infrastructure.
Next step
Run the same migration on your ECS stack.
Create an EKS cluster in your existing VPC with Qovery, import your ECS Terraform, and move services one wave at a time. Workloads and data stay in your AWS account.