
Amazon ECS Gateway Explained: A New Approach to ECS Ingress and Platform Engineering
Amazon ECS Gateway simplifies ingress management by enabling platform teams to standardize networking while giving application teams a self-service way to expose their ECS services. Explore what ECS Gateway provisions behind the scenes, how service routing works, key architectural considerations, and what to validate before rolling it out. Less manual configuration, fewer operational bottlenecks, and a better developer experience.
Overview
What | Crux |
|---|---|
New resource | Account-level gateway that provisions and manages ALBs in your account |
Ownership split | Platform team owns the gateway; app teams add a gatewayConnectors entry to their service |
Routing | Host-based routing; every service gets its own DNS hostname |
Density | Up to 25 services share one ALB; ECS adds and removes ALBs as needed |
Scope | awsvpc network mode on Fargate, EC2 and ECS Managed Instances |
Cost | No charge for the gateway itself; you pay for the ALBs, certificates, logs and data transfer it creates |
Each section below covers the mechanism, the commands, and where the sharp edges are.
Running example: a platform team running around 60 Fargate microservices across a
dev and a prod cluster in one VPC. Today each service has its own ALB or a hand-managed listener rule on a shared one. The goal is one public and one internal gateway, with app teams self-serving.Why we need this
Most ECS estates end up with one of two ingress patterns, and both hurt at scale.
Pattern 1: one ALB per service. It is simple and isolated. It is also expensive and noisy. Every ALB carries its own hourly charge whether it serves ten requests a day or ten thousand, so 60 services means 60 ALBs. Each one also brings its own listener, certificate, security group and WAF association to keep consistent.
Pattern 2: a shared ALB with hand-managed rules. It is cheaper, but the complexity moves into your Terraform. Someone has to allocate listener rule priorities without collisions and track per-ALB rule and certificate quotas. They also add a new ALB when one fills up, and remember to delete the rule and target group when a service is retired. In practice that someone is the platform team, and every new service becomes a ticket.
Both patterns share the same deeper problems:
- Drift. WAF, access logs and TLS policy are set per ALB or per module call, so they slowly diverge between teams.
- Security group sprawl. Task security groups get opened wider during debugging and rarely tightened again.
- Orphans. Deleting a service rarely deletes its target group, listener rule and certificate.
- Platform bottleneck. App teams can ship code in minutes but wait days for an endpoint.
ECS Gateway turns ingress into a control-plane feature of ECS itself. The standard is defined once on the gateway, and the per-service plumbing is created and deleted with the service.
How it differs from the current approach
| Per-service ALB | Shared ALB + Terraform module | ECS Gateway |
|---|---|---|---|
Adding a service | New ALB, listener, cert, SG, TG | New rule, priority, TG, cert in shared module | One gatewayConnectors entry on the service |
Who does the work | App team or platform ticket | Platform team, per service | ECS, at deploy time |
ALB count | One per service | Manual; you add ALBs as they fill | Automatic, 25 services per ALB, capped by maxAlbCount |
WAF, logs, TLS | Per ALB, drifts | Per module call, drifts | Set once on the gateway, inherited by every service |
Task security group | Hand-written | Hand-written | Generated, inbound from the ALB only |
Service deletion | Leftover ALB unless cleaned up | Leftover rule, TG, cert | Route and resources removed; empty ALB removed |
Who can make a service public | Whoever can create an ALB | Whoever edits the module | Only whoever controls cluster associations |
Custom domain on the ALB | Yes | Yes | Not documented; generated *.on.aws host |
Cross-account ingress | Possible with shared VPCs | Possible | Same account only |
Terraform support today | Mature | Mature | CloudFormation and CLI; no hashicorp/aws resource found yet |
The last three rows are where the old approach still wins. Everything above them is toil that ECS Gateway removes.
One detail worth noticing: the 25-services-per-ALB limit matches the ALB default of 25 additional certificates per load balancer. Since every route gets its own ACM certificate, that is very likely not a coincidence, though AWS doesn't state it.
How it fits together
The platform team creates a gateway and associates it with clusters. App teams add a gateway connector to their service, and ECS builds everything else at deploy time. In the running example,
prod gets public-gw and internal-gw , while dev gets only internal-gw , so dev services can never become public.Under the hood: what happens when a service connects

Nothing is provisioned when you create a gateway or associate it with a cluster. Everything happens at service deployment time, and it happens again on every deployment.
[embed: node/87569c07-762e]
The platform team's settings and the app team's connector only meet at deployment time, which is why every change to either side needs a redeploy to take effect.
Step 1: Gateway selection

ECS looks at the gateways associated with the service's cluster (max 5) and keeps only the eligible ones:
Check | Rule |
|---|---|
Access type | Matches the connector's filters.accessTypes . No filter means PUBLIC and PRIVATE both qualify |
VPC | Same VPC as the service's subnets |
Availability Zones | Gateway has subnets in every AZ the service uses. Partial overlap is not eligible |
The service connects to all eligible gateways, not one. If none qualify, the deployment fails. Incompatible gateways are silently skipped.
Step 2: ALB placement
ECS puts the service on an existing gateway ALB with free capacity (25 services per ALB). If every ALB is full, it creates a new one with its listener and security group, up to
maxAlbCount . The documented hard ceiling is 200 ALBs per gateway; the AWS News Blog post lists a default of 10. If the cap is hit, the deployment fails.The first service on a gateway is slower to connect, because it waits for the ALB itself.
Step 3: Per-service resources
For each service-to-gateway connection, ECS creates an ACM certificate, a generated hostname (
https://<unique-id>.ecs.<region>.on.aws ), a listener rule matching that host, a target group, and a service security group that allows only the ALB. Together these become a gateway route with its own ARN. Once the route is ACTIVE , the URL serves traffic.Step 4: Lifecycle
On every redeploy, ECS re-runs selection. Newly associated gateways get connected; disassociated ones get disconnected and their URLs stop working. Deleting the service removes all its routes, and an ALB with no routes left is removed.
All managed resources are tagged
AmazonECSManaged=true and aws:ecs:gateway-arn . Per-route resources also carry aws:ecs:gateway-route-arn . Those tags are your hook for cost allocation and alarms.Why it matters for the running example: a
prod service with no access-type filter connects to both public-gw and internal-gw . That is two routes, two hostnames and two ALB slots. Most internal APIs should set PRIVATE explicitly.Hands-on PoC: two services, one gateway, one shared ALB
This PoC follows the flow from the AWS News Blog launch post , but runs end to end from a terminal. It proves three things: two Fargate services get two different HTTPS hostnames, both land on the same ALB, and ECS cleans up everything when they leave.
It uses the default VPC so the gateway and services share subnets and AZs. Expect a small bill for one ALB while it runs; the cleanup step removes it.
Prerequisites: AWS CLI v2 recent enough to have
aws ecs create-gateway , permissions for IAM, ECS, EC2 and CloudWatch Logs, and a default VPC in the Region.Step 0: Variables
export AWS_REGION=us-east-1export PREFIX=ecsgw-pocexport ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
export VPC_ID=$(aws ec2 describe-vpcs --filters Name=is-default,Values=true \ --query 'Vpcs[0].VpcId' --output text)
# One default subnet per AZ. Gateway and services use the same list,# so the gateway always covers every AZ the service runs in.export SUBNETS=$(aws ec2 describe-subnets \ --filters Name=vpc-id,Values=$VPC_ID Name=default-for-az,Values=true \ --query 'Subnets[].SubnetId' --output text)export SUBNETS_JSON=$(printf '"%s",' $SUBNETS | sed 's/,$//')export SUBNETS_CSV=$(echo $SUBNETS | tr ' ' ',')
echo "VPC=$VPC_ID SUBNETS=$SUBNETS_CSV"Step 1: IAM roles
The infrastructure role lets ECS build ALBs, target groups, security groups and certificates. The execution role is the usual Fargate one for pulling images and writing logs.
cat > ecs-trust.json <<'EOF'{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Principal": { "Service": "ecs.amazonaws.com" }, "Action": "sts:AssumeRole" }]}EOF
aws iam create-role --role-name ${PREFIX}-infra \ --assume-role-policy-document file://ecs-trust.jsonaws iam attach-role-policy --role-name ${PREFIX}-infra \ --policy-arn arn:aws:iam::aws:policy/AmazonECSInfrastructureRoleForGatewayHostSharedALB
cat > task-trust.json <<'EOF'{ "Version": "2012-10-17", "Statement": [{ "Effect": "Allow", "Principal": { "Service": "ecs-tasks.amazonaws.com" }, "Action": "sts:AssumeRole" }]}EOF
aws iam create-role --role-name ${PREFIX}-exec \ --assume-role-policy-document file://task-trust.jsonaws iam attach-role-policy --role-name ${PREFIX}-exec \ --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
export INFRA_ROLE_ARN=arn:aws:iam::${ACCOUNT_ID}:role/${PREFIX}-infraexport EXEC_ROLE_ARN=arn:aws:iam::${ACCOUNT_ID}:role/${PREFIX}-exec
# IAM is eventually consistent; create-gateway can fail if you go too fastsleep 30Step 2: Create the gateway
aws ecs create-gateway \ --name ${PREFIX}-public \ --infrastructure-role-arn $INFRA_ROLE_ARN \ --configuration "{ \"hostSharedAlb\": { \"scheme\": \"internet-facing\", \"networkConfiguration\": { \"subnets\": [${SUBNETS_JSON}], \"ipAddressType\": \"ipv4\" }, \"maxAlbCount\": 2 } }"
aws ecs describe-gateway --gateway ${PREFIX}-public \ --query 'gateway.{status:status,access:accessType,albs:configuration.hostSharedAlb.currentAlbCount}'Expected:
ACTIVE , PUBLIC , and 0 ALBs. Nothing is provisioned yet.Screenshot: ECS console > Gateways >ecsgw-poc-public, configuration tab showing scheme, subnets and zero load balancers. The AWS News Blog post shows the same create screen if you prefer the console path.
Step 3: Cluster and association
aws ecs create-cluster --cluster-name ${PREFIX}
aws ecs associate-gateway-with-cluster \ --gateway ${PREFIX}-public \ --cluster ${PREFIX}
aws ecs list-gateway-cluster-associations --gateway ${PREFIX}-publicStep 4: Task definition with a named port
The connector references the port name, so
portMappings[].name is mandatory here.aws logs create-log-group --log-group-name /ecs/${PREFIX}
cat > taskdef.json <<EOF{ "family": "${PREFIX}-web", "networkMode": "awsvpc", "requiresCompatibilities": ["FARGATE"], "cpu": "256", "memory": "512", "executionRoleArn": "${EXEC_ROLE_ARN}", "containerDefinitions": [{ "name": "web", "image": "public.ecr.aws/nginx/nginx:stable-alpine", "essential": true, "portMappings": [{ "name": "web", "containerPort": 80, "protocol": "tcp", "appProtocol": "http" }], "logConfiguration": { "logDriver": "awslogs", "options": { "awslogs-group": "/ecs/${PREFIX}", "awslogs-region": "${AWS_REGION}", "awslogs-stream-prefix": "web" } } }]}EOF
aws ecs register-task-definition --cli-input-json file://taskdef.jsonStep 5: Two services with gateway connectors
for SVC in orders-api payments-api; do aws ecs create-service \ --cluster ${PREFIX} \ --service-name $SVC \ --task-definition ${PREFIX}-web \ --desired-count 1 \ --launch-type FARGATE \ --network-configuration "awsvpcConfiguration={subnets=[${SUBNETS_CSV}],assignPublicIp=ENABLED}" \ --gateway-connectors '[{ "portName": "web", "filters": { "accessTypes": ["PUBLIC"] }, "healthCheck": { "healthCheckPath": "/" } }]'done
aws ecs wait services-stable --cluster ${PREFIX} --services orders-api payments-apiThe first service waits for the ALB itself, so expect a few minutes. The second one reuses it.
Screenshot: ECS console > Clusters >ecsgw-poc> Services, both servicesActivewith 1/1 tasks running.
Step 6: Get each service URL and call it
The URL lives on the service revision, so the helper walks deployment > revision > gateway connection.
get_url() { local svc=$1 local dep=$(aws ecs list-service-deployments --cluster ${PREFIX} --service $svc \ --query 'serviceDeployments[0].serviceDeploymentArn' --output text) local rev=$(aws ecs describe-service-deployments --service-deployment-arns $dep \ --query 'serviceDeployments[0].targetServiceRevision.arn' --output text) aws ecs describe-service-revisions --service-revision-arns $rev \ --query 'serviceRevisions[0].ecsManagedResources.gatewayConnections[0].[status,serviceUrl]' \ --output text}
for SVC in orders-api payments-api; do echo "$SVC -> $(get_url $SVC)"doneWait until both report
ACTIVE , then hit them:ORDERS_URL=$(get_url orders-api | awk '{print $2}')PAYMENTS_URL=$(get_url payments-api | awk '{print $2}')
curl -sS -o /dev/null -w "orders %{http_code} %{ssl_verify_result}\n" $ORDERS_URLcurl -sS -o /dev/null -w "payments %{http_code} %{ssl_verify_result}\n" $PAYMENTS_URLExpected:
200 for both, 0 for TLS verification (the ACM certificate is valid for the generated *.ecs.<region>.on.aws host).Screenshot: terminal showing both hostnames and the two200responses. This is the money shot for the post.
Step 7: Prove both services share one ALB
# One ALB, two servicesaws ecs describe-gateway --gateway ${PREFIX}-public \ --query 'gateway.configuration.hostSharedAlb.currentAlbCount'
# Two routes, one per serviceaws ecs list-gateway-routes --gateway ${PREFIX}-public --cluster ${PREFIX}
# The managed ALB, found by the tag ECS puts on everything it ownsALB_ARN=$(aws resourcegroupstaggingapi get-resources \ --tag-filters Key=AmazonECSManaged,Values=true \ --resource-type-filters elasticloadbalancing:loadbalancer \ --query 'ResourceTagMappingList[0].ResourceARN' --output text)
LISTENER_ARN=$(aws elbv2 describe-listeners --load-balancer-arn $ALB_ARN \ --query 'Listeners[0].ListenerArn' --output text)
# Host-header rules: one per service hostnameaws elbv2 describe-rules --listener-arn $LISTENER_ARN \ --query 'Rules[].Conditions[].HostHeaderConfig.Values' --output textExpected:
currentAlbCount is 1 , two routes, and two host-header rules on a single HTTPS:443 listener.Screenshot: EC2 console > Load Balancers > the managed ALB > Listeners > HTTPS:443 > Rules, showing the two host-header rules. Also capture its Tags tab withAmazonECSManaged=true.
Step 8: Cleanup
Order matters: services first, then the association, then the gateway.
for SVC in orders-api payments-api; do aws ecs delete-service --cluster ${PREFIX} --service $SVC --forcedoneaws ecs wait services-inactive --cluster ${PREFIX} --services orders-api payments-api
# Routes are gone, so the association can drainaws ecs disassociate-gateway-from-cluster --gateway ${PREFIX}-public --cluster ${PREFIX}until [ -z "$(aws ecs list-gateway-cluster-associations --gateway ${PREFIX}-public \ --query 'gatewayClusterAssociations[]' --output text)" ]; do sleep 10; done
# Deletion protection is on by default. UpdateGateway replaces the whole# config, so resend the role and the settings you want to keep.aws ecs update-gateway --gateway ${PREFIX}-public \ --infrastructure-role-arn $INFRA_ROLE_ARN \ --configuration '{"hostSharedAlb": {"maxAlbCount": 2}}' \ --no-deletion-protection
aws ecs delete-gateway --gateway ${PREFIX}-publicaws ecs delete-cluster --cluster ${PREFIX}aws logs delete-log-group --log-group-name /ecs/${PREFIX}
aws iam detach-role-policy --role-name ${PREFIX}-infra \ --policy-arn arn:aws:iam::aws:policy/AmazonECSInfrastructureRoleForGatewayHostSharedALBaws iam delete-role --role-name ${PREFIX}-infraaws iam detach-role-policy --role-name ${PREFIX}-exec \ --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicyaws iam delete-role --role-name ${PREFIX}-execRun the tag query from Step 7 again at the end. It should return nothing: ECS removed the ALB when its last route left.
Screenshot: the empty tag query result. It's the cleanest proof that the lifecycle claim is real.
IaC reality check
At launch, gateways are supported in the console, CLI, SDKs and CloudFormation. The CloudFormation reference already documents an
AWS::ECS::Gateway resource, with the same HostSharedAlb fields as the API.For Terraform, I could not find an
aws_ecs_gateway resource or a gateway connector argument on aws_ecs_service in the hashicorp/aws provider at the time of writing. Until it lands, the realistic options are a CloudFormation stack managed from Terraform via aws_cloudformation_stack , the awscc provider once its Cloud Control schemas pick up the new type, or the CLI in your pipeline. Check the provider CHANGELOG before you design a module around any of these.

Migration playbook: from the old way to ECS Gateway
The key fact that makes migration safe: adding a gateway connector to a service that already has
loadBalancers configured does not touch the existing ALB. Both ingress paths serve traffic at once. Cutover is a client-side switch, and rollback is switching back.Phase | Goal | Exit criteria |
|---|---|---|
0. Inventory | Know which services can move | Every service tagged move / move with front door / stay |
1. Gateway design | Create gateways you won't need to rebuild | Public and internal gateways covering every AZ in use |
2. Stable names | Hide the generated hostname from clients | A front door or config entry per service you own |
3. Pilot | Prove the runbook on one low-risk service | One internal service fully on the gateway, old ALB deleted |
4. Waves | Move the rest in batches | All eligible services on gateways |
5. Decommission | Remove old ingress and lock the new pattern | Old ALBs gone, templates and guardrails enforced |
Phase 0: Inventory
List every service with its network mode, load balancer count and deployment strategy:
CLUSTER=prodfor SVC in $(aws ecs list-services --cluster $CLUSTER --query 'serviceArns[]' --output text); do read NAME LBS TD STRATEGY <<< $(aws ecs describe-services --cluster $CLUSTER --services $SVC \ --query 'services[0].[serviceName, length(loadBalancers), taskDefinition, deploymentConfiguration.strategy]' \ --output text) MODE=$(aws ecs describe-task-definition --task-definition $TD \ --query 'taskDefinition.networkMode' --output text) echo "$NAME mode=$MODE albs=$LBS strategy=$STRATEGY"doneThen sort each service into a bucket:
Bucket | Typical services |
|---|---|
Move | awsvpc HTTP APIs and web apps, internal service-to-service calls, one exposed port |
Move with a front door | Public services that must keep a vanity domain such as api.example.com |
Stay | bridge or host mode, gRPC or TCP on custom ports, NLB-fronted services, Express Mode services, ingress owned by another account |
bridge -mode services can move later, but only after switching the task definition to awsvpc , which is its own change.Phase 1: Gateway design
This is the phase you cannot redo cheaply, because scheme, subnets, IP type and name are immutable.
- Create one
internaland, if needed, oneinternet-facinggateway per VPC.
- Give each gateway subnets in every AZ any service uses. A gateway that misses one AZ is silently skipped for services in that AZ.
- Set WAF, access logs, an inbound security group and the test-traffic header before the first service connects.
- Size
maxAlbCountas services ÷ 25, plus headroom. 60 services need 3 ALBs; set at least 5.
- Associate gateways with non-prod clusters first.
Phase 2: Stable names
Generated hostnames are random, and they change when a service is recreated. Decide now what clients will call.
For internal callers, the simplest path is putting the generated URL in config or a parameter store entry that each deploy updates. For public vanity domains, a plain Route 53 CNAME to the
*.on.aws host will fail TLS, because the managed certificate covers only the generated name. Put CloudFront (or another proxy) in front, with your own certificate on it and the generated host as the origin.Phase 3 and 4: Per-service cutover runbook
Pilot this on one internal service, then repeat it in waves of five to ten services.
1. Add the connector. The old ALB keeps serving traffic. Set the health check now; changing it later is rejected on
ROLLING services.aws ecs update-service --cluster prod --service orders-api \ --gateway-connectors '[{ "portName": "http", "filters": { "accessTypes": ["PRIVATE"] }, "healthCheck": { "healthCheckPath": "/health" } }]'2. Verify the new path. Wait for the connection to report
ACTIVE (use get_url from the PoC), then smoke-test it.3. Switch clients. Update the config entry or the front door origin to the new URL.
4. Drain the old path. Watch
RequestCount on the old target group in CloudWatch until it stays at zero for a full business cycle, including batch jobs and weekly cron callers.5. Remove the old load balancer config. Do this in a separate deployment:
aws ecs update-service --cluster prod --service orders-api --load-balancers '[]'Validate this on the pilot first, since load balancer updates depend on the service's deployment strategy.
6. Delete the old resources from your IaC. That means the listener rule, target group, certificate and security group rules, and the ALB itself once nothing else uses it.
Rollback, at any point before step 5, is just pointing clients back. To remove the gateway path entirely:
aws ecs update-service --cluster prod --service orders-api --gateway-connectors '[]'Phase 5: Decommission and lock in
- Delete the old ALBs and the Terraform modules that created per-service ingress.
- Ship service templates with
accessTypes: ["PRIVATE"]as the default and a real health check path.
- Restrict gateway create, update and association calls to the platform pipeline.
- Add the capacity alarm and the guardrail on
AmazonECSManaged=trueresources from the observability section.
What changes for each team
The platform team stops writing per-service ingress and starts owning a handful of gateways, their capacity and their associations. App teams stop filing ingress tickets and add one block to their service definition. The new coordination point is cluster associations: adding or removing a gateway affects every service on that cluster at its next deploy, so treat association changes like a shared-infrastructure change, with notice.
Observability and guardrails
There is no new metric namespace. You monitor the gateway with the ALB metrics you already know, scoped by dimension.
Question | Where to look |
|---|---|
Is my service healthy behind the gateway? | HealthyHostCount , HTTPCode_Target_5XX_Count , TargetResponseTime with the TargetGroup dimension |
Is the shared ALB under stress? | Same metrics with the LoadBalancer dimension |
Real-time target status | aws elbv2 describe-target-health on the route's target group |
How close am I to the capacity cap? | currentAlbCount vs maxAlbCount from aws ecs describe-gateway |
Which routes exist, and are any stuck? | aws ecs list-gateway-routes filtered by gateway, cluster, service or status |
Because one ALB serves up to 25 services, access logs land in one bucket for all of them. Filter by the hostname in each log record to split per service.
Three guardrails worth adding on day one
1. Alarm on capacity before it fails a deploy. When every ALB is full and
maxAlbCount is reached, the next service deployment fails. Raising the limit afterwards does not retry it. A scheduled check that alerts at 80% of maxAlbCount is cheap insurance.2. Lock down managed resources. ECS does not repair resources changed outside it. Edit a managed listener rule by hand, or strip the
AmazonECSManaged=true tag, and later deployments and cleanups can fail. I'd add an SCP or permission boundary that denies ELB, EC2 security group and ACM write actions on resources tagged AmazonECSManaged=true for every principal except the infrastructure role. Treat this as a pattern; validate the exact actions and condition keys against your org before rolling it out.3. Restrict gateway operations to the platform pipeline.
CreateGateway , UpdateGateway , AssociateGatewayWithCluster and DisassociateGatewayFromCluster should belong to the platform role only. App teams keep UpdateService . Combined with the PRIVATE filter default in your service templates, that is a real ingress policy, not a wiki page.Reality check: what the announcement doesn't spell out
The launch post is clean. The developer guide is where the sharp edges are.
Limitation | Why it matters |
|---|---|
UpdateGateway replaces the whole config | Omit the WAF ACL ARN while changing maxAlbCount and the WAF is detached from every ALB. Always describe-gateway first and resend everything |
HTTPS on 443 only | No gRPC on custom ports, no TCP, no NLB. Anything non-HTTP stays on your own load balancer |
No custom domains documented | Every route gets a random *.on.aws hostname that changes if the service is recreated |
Same account only | Gateways cannot be associated with clusters in another account, so a central network account owning ingress for workload accounts is out |
Immutable: name, scheme, subnets, IP type, port, protocol | Get the AZ coverage right on day one; fixing it means a new gateway and a migration |
Connect-to-all-eligible behaviour | A service without an access-type filter gets exposed on its next deploy if someone later associates a public gateway |
No ALB consolidation | ECS adds and removes ALBs but never rebalances. After churn, you can pay for several half-empty ALBs |
Header-only test traffic | Progressive deployments match a header. There is no percentage-based split via the gateway |
One connector per service | One container port per service gets ingress |
Not for Express Mode | Express Mode services keep their own managed ingress |
The default inbound security group on an internet-facing gateway allows 443 from anywhere. For a public API behind CloudFront or a partner allow-list, supply your own
inboundSecurityGroup .When I would not use it (yet)
Skip it, or wait, if you run a hub-and-spoke model where ingress lives in a shared network account. The same goes for vanity domains terminated directly on the ALB, non-HTTP protocols, or a Terraform-only shop that can't accept a CloudFormation or CLI bridge for now.
For a single-account, HTTP-API-heavy ECS estate with more than a handful of services, it is an easy yes.
Verdict
ECS Gateway does not do anything you couldn't build with a shared ALB and a good Terraform module. What it changes is who has to maintain that module. Listener rule priorities, certificate requests, per-service security groups and ALB capacity planning move from your backlog into the ECS control plane.
The value is the boundary. Platform teams govern ingress through associations, and app teams get an HTTPS endpoint with one service parameter.
Start with an internal gateway in a non-prod cluster. Make
PRIVATE the default in your service templates. Wrap UpdateGateway in a script that always reads before it writes. Then migrate your noisiest internal APIs, using the dual-path cutover.References
- AWS What's New: Announcing Amazon ECS Gateway (Oct 20, 2026)
About the author
I'm Ashish Kasaudhan, a DevSecOps Architect and AWS Community Builder. I write about the mechanics behind AWS and DevOps tooling: what actually changed, not just the marketing summary.
And if you're reading a like and share (or a few) helps this reach more platform engineers making the same ingress decisions. Corrections are welcome too, especially if you've already run ECS Gateway against a real migration.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article