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

ECS to EKS,
without rebuilding your pipeline.

Qovery runs EKS in the AWS account you already own. Your task definitions become Kubernetes services, your CI keeps pushing to ECR, and only the deploy step changes.

No step is destructiveECS and EKS run in parallelECS serves traffic until you shift it
your-app, qovery agent
$ deploy this project with Qovery
Scanning repository...
api Dockerfile 1 vCPU / 2 GB from task def
worker Dockerfile 0.5 vCPU / 1 GB from task def
scheduler cron 2 scheduled tasks
database PostgreSQL 16 Amazon RDS, connected as is
Plan: 3 services, 1 external database, 12 environment variables
Nothing has been created yet. Approve to continue.
200+ companies run on their own cloud with Qovery4.8 on G2 · 80+ reviews
  • Talkspace
  • Alan
  • Powens
  • Prezi
  • Prosperity
  • Getsafe
“Within a few days, we had something running that replicates our previous setup but with multiple environments, greater control, best practices in place, extensibility, and future-proof capabilities.”
Clément GarbayCo-founder and CTO, HyperlineCase study →
“We liked the ease of a managed platform, and we knew AWS meant skills and effort we did not have spare - that is why we kept putting the migration off. We do not regret doing it with Qovery. Deployments that took me over two hours now take 30 minutes.”
Kyle FlavinDirector of DevOps, RxVantageCase study →
Where ECS stops

ECS is a good orchestrator. It just isn’t Kubernetes.

Nobody leaves ECS because it broke. They leave when the roadmap needs something only Kubernetes has, and nobody on the team wants to become the person who runs it.

qovery runs in your AWS account
  1. The ecosystem assumes Kubernetes

    Vendor Helm charts, operators, KEDA, Argo CD, policy engines and most observability agents ship for Kubernetes first and ECS rarely or never. On ECS each of those becomes a rebuild, a sidecar or a decision not to adopt the tool at all.

    On Qovery, running in the AWS account you already own:

    A standard EKS cluster that takes Helm charts and Terraform services next to your applications, with Karpenter, autoscaling and core add-ons already managed.

  2. Task definitions only run on AWS

    A task definition is an AWS artifact. The day a customer asks for a deployment in their own cloud, or a second provider lands on the roadmap, nothing you wrote for ECS travels with you.

    On Qovery, running in the AWS account you already own:

    The same services and the same deployment workflow on EKS today, and on GCP, Azure, Scaleway or an existing cluster when you need them.

  3. Fargate draws a hard line on some workloads

    Fargate has no GPUs, no privileged containers and no host networking, so inference, agents with system access and some security tooling end up on EC2 capacity you manage yourself, with a second operating model next to the first.

    On Qovery, running in the AWS account you already own:

    GPU node pools per service and EC2 node pools sized by Karpenter, on one cluster and one workflow.

  4. Environments are something you script

    ECS has no notion of an environment. A staging copy or a preview per pull request is Terraform someone writes and maintains, and non-production keeps running all night unless someone remembers to stop it.

    On Qovery, running in the AWS account you already own:

    An environment per pull request created on open and removed on merge, cloneable environments, and non-production that stops on a schedule.

How the migration runs

Four steps, and ECS keeps serving the whole time.

Nothing here touches your ECS services. You move one service, shift its traffic, and repeat.

  1. 01

    A CloudFormation stack gives Qovery a role it can use to provision an EKS cluster in your own account, in the same VPC as your ECS services or a peered one, so RDS, ElastiCache and security groups keep working. About twenty minutes. Already run EKS? Install Qovery on that cluster instead. Talk to a migration engineer before you connect anything.

  2. 02

  3. 03

  4. 04

  5. 05

    Optional
In the AWS console
One CloudFormation stack, about twenty minutes.
network
same VPC as ECS, or peered
cluster
EKS, Kubernetes up to 1.35
access
a role scoped to Qovery
~20 min

to a cluster in your AWS account. From there each service comes up on EKS next to its ECS twin, only the deploy line of your CI changes, and ECS keeps serving traffic until you move it.

What it costs

The AWS bill barely moves. The hours are what change.

ECS charges nothing for orchestration. EKS adds $0.10 per cluster per hour, about $73 a month, and $0.60 per hour if a cluster falls behind into extended support, which Qovery avoids by keeping clusters upgraded. Fargate and EC2 compute cost the same on both. What moves is everything around it: Karpenter packs pods across instance types, interruptible pools run on Spot, and non-production environments stop when nobody uses them.

EKS list prices from aws.amazon.com/eks/pricing, checked November 2026. Your bill depends on cluster count, node shapes, Spot share and region, and a migration engineer will model it against your current ECS spend before you commit to anything.

What EKS with Qovery adds

Four things ECS does not give you, without a platform team to run them.

Moving to EKS is only worth it for what Kubernetes adds. These are the four that ECS teams ask for most, and none of them needs someone on your team to become the cluster owner.

Bin-packing across instance types

ECS capacity providers scale groups of instances you picked in advance. On EKS, Karpenter looks at the pods waiting to run and picks the instance types that fit them, then consolidates nodes when load drops. Qovery runs Karpenter for you and keeps web services on on-demand capacity while interruptible pools use Spot.

On an ECS service
capacity providers, fixed shapes
On EKS, run by Qovery
Karpenter picks the shape

An environment per pull request

On ECS a preview environment is Terraform someone has to write and keep working. With Qovery each pull request gets its own environment, cloned from a blueprint, and it is removed when the pull request closes.

On an ECS service
script it yourself
On EKS, run by Qovery
built in, per pull request

The Kubernetes ecosystem

Helm charts and Terraform modules deploy next to your services in the same environment, and the tools your vendors ship for Kubernetes work as documented instead of being adapted for ECS.

On an ECS service
rebuild or go without
On EKS, run by Qovery
Helm and Terraform services

The same workflow beyond AWS

The services you define for EKS deploy the same way to GCP, Azure, Scaleway or a cluster you already run. You do not need that on day one, but it means the next cloud is a cluster to connect, not a second migration.

On an ECS service
AWS only
On EKS, run by Qovery
any cloud, one workflow
Qovery is not a PaaS

Our control plane. Your AWS account, your bill.

Qovery sits above the infrastructure and never owns it. The EKS cluster, the node pools and every database stay in the AWS account you already hold, under your IAM and your Savings Plans, and AWS invoices you directly.

  • We do not take a cut of your AWS spend. A flat subscription, whether your bill is $2k or $200k.
  • Idle nodes, oversized requests and preview environments left running get flagged so you stop paying for them.
  • You already own the AWS account. What changes is that the orchestrator becomes standard Kubernetes, and someone other than your team keeps it upgraded.

Not sure which AWS services fit your workload? A solution engineer will map it with you.

QoveryCONTROL PLANE
deploymentsenvironmentspreview envsRBAC + auditcost signals
provisions standard Terraform and Kubernetes manifests
Your AWS account
invoiced by AWS, directly to you
VPC · your network policy
EKS clusterapiworkercronpreview-pr-482RDSElastiCacheECRsecrets
IAM: yours · data residency: yours · audit trail: yours

Stop paying Qovery and the cluster keeps running - it is standard EKS in your account.

Leave ECS, keep AWS

Your first service on EKS,
with the pipeline you already have.

Same AWS account, same VPC, same ECR images. Nothing you do here touches your ECS services until you decide to shift their traffic, and you can shift it back.

AWS Marketplace

Qovery is an AWS ISV Accelerate partner, available on AWS Marketplace. Spend transacts through your existing AWS agreement and counts toward an Enterprise Discount Program commitment.

View on AWS Marketplace →
Frequently asked

ECS to EKS

Something not covered here? Talk to a migration engineer.

How long does an ECS to EKS migration take?
The cluster takes about twenty minutes to provision in your account. A first stateless service can run on EKS the same day. The rest moves service by service, with ECS still serving traffic, so the pace is set by how many services you have and how much stateful or scheduled work they carry, not by the tooling.
Does Qovery convert our ECS task definitions automatically?
Not by itself, and no tool does this reliably. Your coding agent, with the Qovery skill installed, reads the task definitions or Terraform already in your repository like any other file and proposes the mapping: image, CPU and memory, ports, variables, secrets and health checks. You review that plan before anything is created, and Qovery generates the Kubernetes objects from it.
Do we have to rebuild our CI/CD pipeline?
No. Checkout, tests, image build and the push to Amazon ECR stay exactly as they are. The deploy step changes from aws ecs update-service to qovery container deploy with the same image tag, an API call, or a git push, which is usually a handful of lines in one job.
Will migrating disrupt our running ECS services?
No. Nothing in the process modifies or removes anything on ECS. Both run in parallel, you shift traffic with weighted Route 53 records or target groups, and ECS stays your rollback until you decommission it.
Which Kubernetes version will we run?
Qovery-managed EKS clusters currently run Kubernetes up to 1.35, and Qovery handles the version upgrades and core add-ons. If you already run an EKS cluster, you can install Qovery onto it instead of creating a new one.
Is EKS more expensive than ECS?
On the AWS bill, by the control plane: $0.10 per cluster per hour in standard support, about $73 a month, while ECS charges nothing for orchestration. Fargate and EC2 compute is priced the same on both. What usually costs more is the engineer time to run Kubernetes, which is the part Qovery takes on.
What happens if we stop using Qovery?
Everything keeps running. The cluster, the workloads and the databases are in your AWS account, as standard Kubernetes objects, so the estate outlives the subscription.
Can we buy Qovery through AWS Marketplace?
Yes. Qovery is an AWS ISV Accelerate partner. Spend transacts through your existing agreement and counts toward an EDP commitment, and AWS sales teams co-sell the migration with us.
Will Qovery deploy into our existing VPC?
Yes, but network configuration is fixed at cluster creation. If you need specific CIDR ranges, an existing VPC, or peering to other clusters, supply those requirements before the cluster is created - changing the VPC afterwards means creating a new cluster.
How does every ECS primitive map to EKS?
On ECS
On EKS
What changes
Task definition
Qovery service, rendered as a Deployment on EKS
Same image, same port. CPU and memory become per-container requests and limits rather than a task-level reservation, and Karpenter places pods across instance types instead of one capacity provider per shape.
ECS service
Deployment plus Kubernetes Service
Rolling updates with readiness probes in place of target-group health checks. Qovery writes both objects.
ALB and target groups
an AWS Network Load Balancer with managed TLS
A Network Load Balancer with certificates issued and renewed through AWS Certificate Manager. No per-domain SSL add-on.
Fargate and capacity providers
EC2 node pools managed with Karpenter
Pods are bin-packed across instance types, interruptible pools can run on Spot, and GPU node pools are available per service.
Service Auto Scaling
Horizontal Pod Autoscaler
Scales on CPU and memory per service, with node capacity following the pods.
Task IAM role
IAM role bound to the service account
The same IAM policy, attached to the workload rather than the task. Nothing about AWS IAM itself changes.
Secrets Manager and SSM parameters
Qovery variables and secrets
Scoped per project, environment and service, with aliases and overrides instead of one flat list.
Cloud Map or Service Connect
Kubernetes DNS
Services reach each other by internal hostname. Update the names your services call, once.
Scheduled tasks
Kubernetes CronJob
Each EventBridge schedule becomes a cron job in the same environment as the service it belongs to.
Amazon RDS and ElastiCache
Amazon RDS for PostgreSQL and Amazon ElastiCache, unchanged
Databases stay where they are. The cluster runs in the same or a peered VPC, so security groups keep working and no data moves.
Amazon ECR
Amazon ECR, unchanged
Qovery deploys the image your CI already pushes, by tag.
aws ecs update-service
qovery container deploy, an API call or git push
The only line of your CI pipeline that changes. Build, test and push stay as they are.
Per-environment Terraform
Qovery environments and preview environments
One per pull request, created on open and shut down when idle.