Nov 28, Paris: AI Health Hack #2 with Alan, Qovery and AWS. Applications close Nov 21

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.

Romaric Philogene
CEO & Co-founder
NOV 20, 2026 · 11 MIN
ECS to EKS Without Freezing the Roadmap, With AI Reading the Terraform (Webinar Replay)

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.

Qovery · Infrastructure control plane
Build with Claude Code, Deploy with Qovery
Learn more

Watch the replay

Watch on Loom

Chapters

TimeTopic
03:57Intro: Romaric and Guillaume
05:26What ECS is, and its building blocks
08:56ECS and EKS side by side
12:02What is new on ECS: Express Mode and Managed Instances
13:22When to move off ECS, and when to stay
16:10The two AWS quotas that matter
18:11Everything around the containers
22:46Where AI helps: the Terraform nobody owns
23:09Three common ways to migrate
25:16The approach we recommend
25:56AI-generated Terraform, and why you still check it
27:11Canary cutover and rollback
28:03Live demo: the app on ECS
31:38What the agent found in the Terraform
33:22The zero-downtime migration plan
34:34In Qovery: importing the ECS Terraform stack
36:21The services, their resources and autoscaling
38:05Creating the EKS cluster

Key takeaways

  • 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.

What ECS is

Watch at 05:26

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):

ECSKubernetesWhat it does
Task definitionPod templateImage, CPU, memory, IAM role and the rest of the container configuration
ServiceDeploymentKeeps a set number of tasks running and replaces the ones that die
TaskPodOne 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.

ECS and EKS side by side

Watch at 08:56

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

ECS keeps improving

Watch at 12:02

AWS shipped two ECS features recently:

  • 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.

When to move off ECS

Watch at 13:22

Guillaume's rule is to move only when something hurts. If one or more of these apply, start planning:

  1. You want Helm charts and CNCF tools without rewriting them for ECS.
  2. 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
  3. 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
  4. 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.

The two quotas that matter

Watch at 16:10

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

EKS has limits too, but they are far enough away that most teams never meet them. We list the ECS and Fargate quotas AWS won't raise in ECS limits AWS won't raise, and when to move to EKS.

The containers are the easy part

Watch at 18:11

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.

Three ways to migrate, and the one we recommend

Watch at 23:09

  1. 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.
  2. 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
  3. 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.

Let AI write the Terraform, then check it

Watch at 25:56

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.

Cut over like a canary release

Watch at 27:11

  1. Create the new infrastructure and deploy the application on it.
  2. Test it.
  3. Send 10% of the traffic to EKS and check that everything is fine.
  4. Raise the share hour by hour, or day by day.
  5. Watch the error logs, especially 4xx and 5xx rates.
  6. If errors jump, send the traffic back to ECS, find the cause, fix it, and try again.

The live demo

Watch at 28:03

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 starting point

Watch at 29:07

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.

What the agent found

Watch at 31:38

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.

The migration plan

Watch at 33:22

Then he asked for a zero-downtime plan. The agent proposed:

  1. Create the Qovery cluster in the existing VPC.
  2. Bring the ECS Terraform stack into a Qovery environment as a Terraform service.
  3. Freeze changes on ECS.
  4. Deploy the services on EKS.
  5. Switch traffic at the load balancer.

Inside Qovery

Watch at 34:34

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

Creating the cluster

Watch at 38:05

Guillaume then showed how to create an AWS cluster managed by Qovery from the Console: give it a name and choose whether it runs production.

Try it on your own ECS stack

  • Read the ECS to EKS migration page to see how each ECS component maps to Qovery on EKS.
  • Start a free trial and create a cluster in your existing VPC.
  • 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:
BASH
curl -fsSL https://skill.qovery.com/install.sh | bash

For more detail on keeping your CI and deploy commands during the move, read ECS to EKS migration: keep your deployment pipeline.

Frequently asked questions
Should I migrate from ECS to EKS?

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 Philogene
About the author
Romaric Philogene

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.