HOW-TO: AWS App Runner vs. ECS Express Mode — Comparison and Migration Guide

Overview

In 2026, AWS announced that AWS App Runner is no longer open to new customers. Existing customers can continue using the service, but AWS will not introduce new features. The recommended migration path is Amazon ECS Express Mode, which preserves App Runner's operational simplicity while providing access to the broader ECS feature set.

This guide compares both services and provides a complete migration strategy.

What you'll learn:

• Why AWS is closing App Runner to new customers
• Architecture comparison: App Runner vs. ECS Express Mode
• Feature-by-feature comparison table
• Pricing and cost model differences
• Step-by-step migration with zero-downtime DNS routing
• CI/CD setup for source-based App Runner deployments
• Decision matrix for choosing between the two

Why this matters:

• If you're evaluating serverless container options, App Runner is no longer a viable choice for new projects
• Existing App Runner users should plan their migration to ECS Express Mode
• ECS Express Mode offers the same "one API call" simplicity with more flexibility and no additional charge

---

The Announcement

AWS announced the App Runner availability change with the following key points:

"After careful consideration, we decided to close AWS App Runner to new customers. Existing AWS App Runner customers can continue to use the service as normal, including creating new resources and services. AWS continues to invest in security and availability for AWS App Runner, but we do not plan to introduce new features."

Key implications:

• ✅ Existing customers: Continue using App Runner normally
• ✅ Existing customers: Can create new App Runner services
• ✅ Security and availability: Continued investment
• ❌ No new features planned
• ❌ No new customers accepted
• 🔄 Recommended path: Migrate to ECS Express Mode

---

Architecture Comparison

AWS App Runner Architecture

App Runner is a fully managed service that abstracts away all infrastructure. You connect a source repository or container image, and App Runner handles everything:

Key characteristics:

• Fully managed — no VPC, no security groups, no load balancers to configure
• Source code or container image — App Runner can build from source (Node.js, Python, Go, Ruby, .NET, Java, Dockerfile)
• Automatic HTTPS — managed certificate and HTTPS endpoint
• Automatic scaling — scales based on request count
• No infrastructure visibility — you don't manage or see the underlying resources

ECS Express Mode Architecture

ECS Express Mode provisions a complete stack in your AWS account with sensible defaults:

Key characteristics:

• Resources in your account — full visibility and control over all provisioned resources
• Container image only — requires a pre-built container image (no source building)
• Production-ready defaults — HTTPS, canary deployments, auto scaling, health checks
• Resource sharing — up to 25 services can share one ALB
• Customizable — CPU, memory, scaling limits, logging, networking, tags

---

Feature Comparison

Feature	App Runner	ECS Express Mode
Availability	❌ Closed to new customers	✅ Fully available
New features	❌ No new features planned	✅ Active development
Input	Source code OR container image	Container image only
Build from source	✅ Built-in (8 runtimes)	❌ Requires external CI/CD
Infrastructure visibility	❌ Fully abstracted	✅ Full visibility in your account
Load balancer	✅ Managed (hidden)	✅ ALB (visible, configurable)
HTTPS	✅ Managed certificate	✅ ACM certificate (auto-provisioned)
Auto scaling	✅ Request-based	✅ CPU, Memory, or Request-based
Deployment strategy	✅ Rolling	✅ Canary
Custom domain	✅ Supported	✅ Supported
VPC networking	❌ Not available	✅ Full VPC control
Security groups	❌ Managed	✅ Configurable
Logging	✅ CloudWatch (managed)	✅ CloudWatch (configurable)
Health checks	✅ Automatic	✅ Configurable path/port
Resource sharing	❌ Isolated per service	✅ ALB sharing (up to 25 services)
Tags	✅ Supported	✅ Supported (propagated to tasks)
Environment variables	✅ Supported	✅ Supported
IAM roles	✅ Service role	✅ Execution + Infrastructure + Task roles
Cost model	Per vCPU-hour + GB-hour + requests	Pay for underlying resources only
Additional charge	Service pricing	❌ No additional charge

---

Pricing Comparison

App Runner Pricing (Existing Customers)

Component	Rate
Compute (vCPU)	$0.000046 per vCPU-second
Memory	$0.000005 per GB-second
Requests	$0.000044 per request (after free tier)
Data transfer	Standard AWS rates

Free tier: 1 million requests/month + 2 million vCPU-seconds + 4 million GB-seconds

ECS Express Mode Pricing

Component	Rate
ECS Express Mode	No additional charge
Fargate (vCPU)	$0.04048 per vCPU-hour (Linux, us-east-1)
Fargate (Memory)	$0.004445 per GB-hour (Linux, us-east-1)
ALB	$0.0225 per LCU-hour + data processing
CloudWatch Logs	$0.50 per GB ingested
Data transfer	Standard AWS rates

Cost optimization: Up to 25 services can share one ALB, reducing per-service cost.

Cost Comparison Example

For a typical web application (1 vCPU, 2 GB RAM, 10M requests/month):

Service	Estimated Monthly Cost
App Runner	~$120-$150
ECS Express Mode (single service)	~$100-$130
ECS Express Mode (5+ services sharing ALB)	~$80-$110 per service

Prices vary by region and actual usage. ECS Express Mode becomes more cost-effective as you deploy more services.

---

Migration Strategy

Blue/Green Migration with DNS Routing

The recommended migration approach uses Route 53 weighted routing to gradually shift traffic:

Migration Steps

Step 1: Review App Runner Configuration

Note the following from your existing App Runner service:

• Container image (or source repository)
• Application port
• Environment variables
• Custom domain name (if any)
• ACM certificate (if using custom domain)

Step 2: Create ECS Express Mode Service

aws ecs create-express-gateway-service \
    --execution-role-arn arn:aws:iam::123456789012:role/ecsTaskExecutionRole \
    --infrastructure-role-arn arn:aws:iam::123456789012:role/ecsInfrastructureRoleForExpressServices \
    --primary-container '{
        "image": "123456789012.dkr.ecr.us-east-1.amazonaws.com/my-app:latest",
        "containerPort": 8080,
        "environment": [
            {"name": "ENV", "value": "production"}
        ]
    }' \
    --service-name "my-application" \
    --health-check-path "/" \
    --scaling-target '{"minTaskCount":1,"maxTaskCount":4}' \
    --monitor-resources

Provisioning takes 3–5 minutes. Test using the default URL before proceeding.

Step 3: Configure Custom Domain (if applicable)

If your App Runner service uses a custom domain:

1. Add your custom domain as a host header condition in the ALB listener rule
2. Add the ACM certificate to the ALB HTTPS listener

Step 4: Shift Traffic with Route 53

1. Convert existing App Runner DNS record to Weighted (weight = 100)
2. Create new weighted record for ECS Express Mode ALB (weight = 0)
3. Gradually increase ECS weight: 10 → 25 → 50 → 75 → 100
4. Validate at each step before increasing

Step 5: Complete Migration

1. Remove App Runner DNS record
2. Remove custom domain from App Runner service
3. Delete App Runner service:

   aws apprunner delete-service --service-arn <your-app-runner-service-arn>
   

---

Source-Based Deployments

App Runner could build from source code. ECS Express Mode requires a container image. Here's how to replicate the experience:

Migration Architecture for Source-Based Apps

GitHub Actions Workflow

name: Build and Deploy to ECS

on:
  push:
    branches: [main]

env:
  AWS_REGION: ${{ vars.AWS_REGION }}
  AWS_ACCOUNT_ID: ${{ vars.AWS_ACCOUNT_ID }}
  ECR_REPOSITORY: ${{ vars.ECR_REPOSITORY }}
  ECS_SERVICE: ${{ vars.ECS_SERVICE }}
  ECS_CLUSTER: ${{ vars.ECS_CLUSTER }}

jobs:
  deploy:
    runs-on: ubuntu-latest
    environment: production
    permissions:
      id-token: write
      contents: read

    steps:
      - uses: actions/checkout@v6

      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v5
        with:
          aws-region: ${{ env.AWS_REGION }}
          role-to-assume: arn:aws:iam::${{ env.AWS_ACCOUNT_ID }}:role/github-actions-ecs-role

      - name: Login to Amazon ECR
        id: login-ecr
        uses: aws-actions/amazon-ecr-login@v2

      - name: Build and push image
        uses: docker/build-push-action@v6
        with:
          context: .
          push: true
          tags: ${{ steps.login-ecr.outputs.registry }}/${{ env.ECR_REPOSITORY }}:${{ github.sha }}

      - name: Deploy to ECS Express Mode
        uses: aws-actions/amazon-ecs-deploy-express-service@v1
        with:
          service-name: ${{ env.ECS_SERVICE }}
          image: ${{ steps.login-ecr.outputs.registry }}/${{ env.ECR_REPOSITORY }}:${{ github.sha }}
          execution-role-arn: arn:aws:iam::${{ env.AWS_ACCOUNT_ID }}:role/ecsTaskExecutionRole
          infrastructure-role-arn: arn:aws:iam::${{ env.AWS_ACCOUNT_ID }}:role/ecsInfrastructureRoleForExpressServices
          cluster: ${{ env.ECS_CLUSTER }}
          container-port: 8080
          health-check-path: /health
          min-task-count: 1
          max-task-count: 4

---

Decision Matrix

Scenario	Recommendation
New project (2026+)	✅ ECS Express Mode (App Runner not available)
Existing App Runner user	🔄 Plan migration to ECS Express Mode
Need source-to-deploy	ECS Express Mode + GitHub Actions CI/CD
Multiple microservices	✅ ECS Express Mode (ALB sharing saves cost)
Need VPC networking	✅ ECS Express Mode (App Runner doesn't support VPC)
Need custom security groups	✅ ECS Express Mode
Simplest possible deployment	Both are simple; ECS Express Mode requires container image
Need canary deployments	✅ ECS Express Mode (App Runner uses rolling only)
Budget-conscious, many services	✅ ECS Express Mode (resource sharing)

---

Best Practices

✅ Do:

• Migrate existing App Runner services — no new features are coming
• Use container images — standardize your build pipeline with CI/CD
• Deploy multiple services in one VPC — leverage ALB sharing for cost savings
• Use weighted DNS routing — zero-downtime migration with rollback capability
• Set up CloudWatch alarms — monitor both services during migration
• Keep App Runner running during validation — 24–48 hours minimum before deletion
• Use OIDC for GitHub Actions — more secure than long-lived IAM credentials

❌ Don't:

• Start new projects on App Runner — it's closed to new customers
• Delete App Runner before validation — keep it as a rollback option
• Skip the container image step — ECS Express Mode requires images, not source
• Mix subnet types in the same VPC — first service defines ALB type
• Ignore the 25-service ALB limit — plan VPC strategy for large deployments

---

Verification Checklist

After migrating from App Runner to ECS Express Mode:

# ✓ ECS service is running with expected task count
aws ecs describe-services --cluster default --services <service-name> \
  --query "services[0].runningCount"

# ✓ Load balancer is active and serving traffic
aws elbv2 describe-load-balancers --query "LoadBalancers[].State.Code"

# ✓ HTTPS is working with custom domain
curl -I https://app.example.com

# ✓ Auto scaling is configured
aws application-autoscaling describe-scaling-policies \
  --service-name ecs \
  --resource-id "service/default/<service-name>"

# ✓ Logs are flowing to CloudWatch
aws logs describe-log-streams --log-group-name "/aws/ecs/default/<service-name>-####"

# ✓ Health checks are passing
aws elbv2 describe-target-health --target-group-arn <tg-arn>

# ✓ App Runner service is deleted (after validation period)
aws apprunner list-services

All checks pass = migration complete! ✅

---

Resources

• App Runner Availability Change: https://docs.aws.amazon.com/apprunner/latest/dg/apprunner-availability-change.html
• App Runner Migration Guide: https://docs.aws.amazon.com/apprunner/latest/dg/migration.html
• ECS Express Mode Overview: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/express-service-work.html
• ECS Express Mode Getting Started: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/express-service-getting-started.html
• GitHub Actions ECS Deploy: https://github.com/aws-actions/amazon-ecs-deploy-express-service
• Route 53 Weighted Routing: https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html

---

See Also

• Howto Aws Ecs Express Mode — Complete guide to ECS Express Mode architecture and configuration
• Github Actions Docker Ecr — Building and pushing container images to ECR
• Openclaw Ubuntu Setup Guide — Setting up Linux infrastructure for development