AWS Builder Center
Amazon ECS Gateway Explained: A New Approach to ECS Ingress and Platform Engineering

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-1
export PREFIX=ecsgw-poc
export 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.json
aws 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.json
aws 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}-infra
export EXEC_ROLE_ARN=arn:aws:iam::${ACCOUNT_ID}:role/${PREFIX}-exec

# IAM is eventually consistent; create-gateway can fail if you go too fast
sleep 30

Step 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}-public

Step 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.json

Step 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-api
The 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 services  Active  with 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)"
done
Wait 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_URL
curl -sS -o /dev/null -w "payments %{http_code} %{ssl_verify_result}\n" $PAYMENTS_URL
Expected:  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 two  200  responses. This is the money shot for the post.

Step 7: Prove both services share one ALB

# One ALB, two services
aws ecs describe-gateway --gateway ${PREFIX}-public \
--query 'gateway.configuration.hostSharedAlb.currentAlbCount'

# Two routes, one per service
aws ecs list-gateway-routes --gateway ${PREFIX}-public --cluster ${PREFIX}

# The managed ALB, found by the tag ECS puts on everything it owns
ALB_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 hostname
aws elbv2 describe-rules --listener-arn $LISTENER_ARN \
--query 'Rules[].Conditions[].HostHeaderConfig.Values' --output text
Expected:  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 with  AmazonECSManaged=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 --force
done
aws ecs wait services-inactive --cluster ${PREFIX} --services orders-api payments-api

# Routes are gone, so the association can drain
aws 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}-public
aws 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/AmazonECSInfrastructureRoleForGatewayHostSharedALB
aws iam delete-role --role-name ${PREFIX}-infra
aws iam detach-role-policy --role-name ${PREFIX}-exec \
--policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
aws iam delete-role --role-name ${PREFIX}-exec
Run 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=prod
for 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"
done
Then 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  internal  and, if needed, one  internet-facing  gateway 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  maxAlbCount  as 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=true  resources 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

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.
If this was useful, I'd appreciate a connect on LinkedIn:  linkedin.com/in/ashish-kasaudhan-713a4225 
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.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article