AWS App Runner não estará mais aberto a novos clientes a partir de 30 de abril de 2026. Se você quiser usar o App Runner, inscreva-se antes dessa data. Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte Mudança de disponibilidade do AWS App Runner.

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

AWS App Runner mudança de disponibilidade

Após uma análise cuidadosa, decidimos fechar novos clientes AWS App Runner a partir de 30 de abril de 2026. AWS App Runner Os clientes existentes podem continuar usando o serviço normalmente, incluindo a criação de novos recursos e serviços. AWS continua investindo em segurança e disponibilidade para AWS App Runner, mas não planejamos introduzir novos recursos.

Recomendamos que os clientes explorem o modo expresso do Amazon Elastic Container Service (Amazon ECS) ao migrar do. AWS App Runner O Amazon ECS Express Mode preserva a simplicidade operacional do App Runner enquanto fornece acesso ao conjunto mais amplo de recursos do Amazon ECS. Com uma única chamada de API, você fornece uma imagem de contêiner e duas funções do IAM, e o Amazon ECS provisiona uma pilha completa de aplicativos em sua AWS conta, incluindo um serviço ECS no Fargate, um Application Load Balancer, auto scaling e rede. Não há cobrança adicional pelo uso do Amazon ECS Express Mode. Você paga somente pelos AWS recursos subjacentes criados para executar seu aplicativo.

Este guia descreve como migrar um serviço App Runner existente para o modo ECS Express e mudar gradualmente o tráfego usando o roteamento DNS.

Visão geral da migração

Este guia usa uma abordagem de blue/green implantação com roteamento ponderado de DNS para migrar o tráfego do App Runner para o modo ECS Express. Ambos os serviços são executados simultaneamente durante a migração. Você usa o Amazon Route 53 (ou seu provedor de DNS) para transferir gradualmente o tráfego do serviço App Runner para o serviço ECS Express Mode, começando com uma pequena porcentagem e aumentando com o tempo. Essa abordagem minimiza o tempo de inatividade e permite reverter ajustando os pesos do DNS se surgirem problemas.

Uma migração típica inclui as seguintes etapas:

Pré-requisitos

Antes de começar, verifique se você tem o seguinte:

Se você quiser preservar um domínio personalizado existente durante a migração, você também precisará:

Antes de começar

Passo a passo da migração

O diagrama a seguir mostra como a migração funciona usando o Route 53 para transferir registros DNS entre o serviço App Runner e o serviço ECS Express Mode.

Etapa 1: revisar a configuração existente do App Runner

No console do App Runner, revise seu serviço existente e anote os valores que você deseja transferir. No mínimo, observe o seguinte:

Você também pode revisar qualquer outra configuração de tempo de execução que queira transferir para o novo serviço.

Para obter detalhes de domínio personalizados, consulteGerenciando nomes de domínio personalizados para um serviço App Runner.

Etapa 2: Criar o serviço ECS Express Mode

Crie um serviço ECS Express Mode usando a mesma imagem de contêiner usada pelo seu serviço App Runner. Você pode criar o serviço usando o Console de gerenciamento da AWSou AWS CLIo.

Exemplo de comando da CLI:

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_VAR_NAME",
            "value": "value"
        }]
    }' \
    --service-name "my-application" \
    --health-check-path "/" \
    --scaling-target '{"minTaskCount":1,"maxTaskCount":4}' \
    --monitor-resources

Substitua a imagem, a porta, as variáveis de ambiente e os valores de escala pelos do seu serviço App Runner.

Esse comando provisiona uma pilha completa de aplicativos em sua AWS conta, incluindo um serviço ECS no Fargate, um Application Load Balancer com grupos-alvo e verificações de integridade, políticas de auto-scaling, grupos de segurança e configuração de rede e uma URL padrão.

O provisionamento normalmente leva de 3 a 5 minutos. Você pode acompanhar o progresso no console do Amazon ECS na guia Recursos.

Depois de concluído, teste seu serviço ECS Express Mode usando a URL padrão mostrada no console. Verifique se seu aplicativo funciona corretamente antes de prosseguir com a mudança de tráfego.

Etapa 3: Configurar o domínio personalizado para o ECS Express Mode

Se seu serviço App Runner usa um domínio personalizado, configure o mesmo domínio personalizado para o serviço ECS Express Mode antes de mudar o tráfego. Essa etapa configura o Application Load Balancer criado para o serviço ECS Express Mode para que ele aceite tráfego para seu domínio e use o certificado ACM para HTTPS.

Para obter instruções detalhadas, consulte Adicionar um domínio personalizado ao seu serviço no Amazon ECS Developer Guide.

A imagem a seguir mostra um exemplo de configuração da condição do cabeçalho do host na regra de ouvinte do Application Load Balancer.

Etapa 4: Mude o tráfego usando o roteamento ponderado do Route 53

Se seu serviço App Runner já usa um domínio personalizado, você pode transferir gradualmente o tráfego para o serviço ECS Express Mode usando o roteamento ponderado do Route 53. O roteamento ponderado permite rotear o tráfego do mesmo nome de host para vários endpoints. Cada endpoint é definido como um registro DNS separado com seu próprio peso, e o Route 53 distribui as solicitações de acordo com esses pesos.

Converta o registro existente do App Runner em um registro ponderado:

Crie um registro ponderado para o ECS Express Mode:

Mude gradualmente o tráfego:

Depois que os registros DNS estiverem configurados, comece a transferir o tráfego aumentando o peso do ECS Express Mode e diminuindo proporcionalmente o peso do App Runner. Uma abordagem recomendada:

Em cada etapa, teste o aplicativo antes de transferir tráfego adicional. Se ocorrerem problemas em algum momento, reverta ajustando os pesos de volta aos valores anteriores.

Etapa 5: Concluir a migração

Depois de verificar se o serviço ECS Express Mode gerencia o tráfego de produção corretamente e se o período de validação já passou, conclua a migração:

Exclua o serviço App Runner:

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

Considere também remover todos os recursos que não são mais necessários:

Migração de implantações baseadas na origem

Se seu serviço App Runner existente for implantado a partir do código-fonte em vez de uma imagem de contêiner, você precisará adicionar uma etapa de conteinerização antes de implantar no ECS Express Mode. Ao contrário do App Runner, o ECS Express Mode exige uma imagem de contêiner. No entanto, você pode replicar a experiência de implantação automatizada do App Runner usando CI/CD ferramentas como GitHub Actions with the Amazon ECS Deploy Express Service Action. GitHub

O fluxo de trabalho de migração tem três estágios:

O diagrama a seguir mostra como esse fluxo de trabalho funciona usando GitHub Ações:

Containerize seu aplicativo

Se seu aplicativo ainda não tiver um Dockerfile, crie um na raiz do repositório. O Dockerfile serve como modelo para criar e empacotar seu código-fonte em uma imagem de contêiner.

A estrutura do seu repositório deve incluir:

your-app/
├── src/                    # Application source code
├── Dockerfile              # Container build instructions
├── package.json            # Dependencies and scripts
└── .github/                # GitHub configuration
    └── workflows/          # GitHub Actions workflows
        └── deploy.yml      # ECS Express Mode deployment workflow

Configurar GitHub ações para implantação automatizada

Para replicar a implantação automática do App Runner no envio de código, configure GitHub as ações com o seguinte:

Exemplo de fluxo de trabalho de GitHub ações

Crie um arquivo de fluxo de trabalho em.github/workflows/deploy.yml:

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:
    name: Deploy
    runs-on: ubuntu-latest
    environment: production
    permissions:
      id-token: write
      contents: read

    steps:
    - name: Checkout
      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
        role-session-name: GitHubActionsECSDeployment

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

    - name: Get short commit hash
      run: echo "IMAGE_TAG=${GITHUB_SHA:0:7}" >> $GITHUB_ENV

    - name: Build, tag, and push image to Amazon ECR
      id: build-image
      env:
        ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
      uses: docker/build-push-action@v6
      with:
        context: .
        push: true
        tags: ${{ env.ECR_REGISTRY }}/${{ env.ECR_REPOSITORY }}:latest,${{ env.ECR_REGISTRY }}/${{ env.ECR_REPOSITORY }}:${{ env.IMAGE_TAG }}

    - name: Deploy to ECS Express Mode
      uses: aws-actions/amazon-ecs-deploy-express-service@v1
      env:
        ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
      with:
        service-name: ${{ env.ECS_SERVICE }}
        image: ${{ env.ECR_REGISTRY }}/${{ env.ECR_REPOSITORY }}:${{ env.IMAGE_TAG }}
        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
        environment-variables: |
          [
            {"name": "ENV", "value": "Prod"}
          ]
        cpu: '1024'
        memory: '2048'
        health-check-path: /health
        min-task-count: 1
        max-task-count: 4
        auto-scaling-metric: AVERAGE_CPU
        auto-scaling-target-value: 70

Quando você envia alterações de código para sua ramificação principal, o GitHub Actions cria automaticamente uma nova imagem de contêiner, a envia para o Amazon Elastic Container Registry e a implanta em seu serviço ECS Express Mode. Isso replica a experiência de implantação automatizada que você teve com o App Runner.

Depois que o serviço ECS Express Mode estiver em execução, siga as etapas 3 a 5 no passo a passo da migração para configurar o domínio personalizado, mudar o tráfego usando o roteamento DNS e concluir a migração.

Recursos adicionais do