AWS App Runner dejará de estar abierto a nuevos clientes a partir del 30 de abril de 2026. Si quieres usar App Runner, regístrate antes de esa fecha. Los clientes existentes pueden seguir utilizando el servicio con normalidad. Para obtener más información, consulte Cambio en la disponibilidad de AWS App Runner.

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

AWS App Runner cambio de disponibilidad

Tras pensarlo detenidamente, decidimos cerrar la venta AWS App Runner a nuevos clientes a partir del 30 de abril de 2026. AWS App Runner Los clientes actuales pueden seguir utilizando el servicio con normalidad, incluida la creación de nuevos recursos y servicios. AWS seguimos invirtiendo en seguridad y disponibilidad AWS App Runner, pero no tenemos previsto introducir nuevas funciones.

Recomendamos que los clientes exploren el modo exprés de Amazon Elastic Container Service (Amazon ECS) al migrar desde. AWS App Runner El modo Amazon ECS Express conserva la simplicidad operativa de App Runner y, al mismo tiempo, proporciona acceso al conjunto más amplio de funciones de Amazon ECS. Con una sola llamada a la API, usted proporciona una imagen de contenedor y dos funciones de IAM, y Amazon ECS aprovisiona un conjunto completo de aplicaciones en su AWS cuenta, que incluye un servicio de ECS en Fargate, un Application Load Balancer, autoescalado y redes. El uso del modo Amazon ECS Express Mode no conlleva ningún cargo adicional. Solo paga por los AWS recursos subyacentes creados para ejecutar su aplicación.

En esta guía, se describe cómo migrar un servicio de App Runner existente al modo ECS Express y cómo desplazar el tráfico gradualmente mediante el enrutamiento de DNS.

Información general sobre la migración

Esta guía utiliza un enfoque de blue/green implementación con enrutamiento ponderado de DNS para migrar el tráfico de App Runner al modo ECS Express. Ambos servicios se ejecutan simultáneamente durante la migración. Utiliza Amazon Route 53 (o su proveedor de DNS) para transferir gradualmente el tráfico del servicio App Runner al servicio ECS Express Mode, empezando por un pequeño porcentaje y aumentando con el tiempo. Este enfoque minimiza el tiempo de inactividad y le permite revertirlo ajustando las ponderaciones del DNS en caso de que surjan problemas.

Una migración típica incluye los siguientes pasos:

Requisitos previos

Antes de empezar, asegúrate de tener lo siguiente:

Si desea conservar un dominio personalizado existente durante la migración, también necesitará:

Antes de empezar

Tutorial de migración

El siguiente diagrama muestra cómo funciona la migración con Route 53 para cambiar los registros de DNS entre el servicio App Runner y el servicio ECS Express Mode.

Paso 1: Revise la configuración actual de App Runner

En la consola de App Runner, revisa tu servicio actual y anota los valores que deseas transferir. Como mínimo, ten en cuenta lo siguiente:

También puede revisar cualquier otra configuración de tiempo de ejecución que desee transferir al nuevo servicio.

Para obtener detalles de dominio personalizados, consulteAdministrar nombres de dominio personalizados para un servicio de App Runner.

Paso 2: Cree el servicio ECS Express Mode

Cree un servicio ECS Express Mode con la misma imagen de contenedor que utiliza su servicio App Runner. Puede crear el servicio mediante el Consola de administración de AWSo el AWS CLI.

Ejemplo de comando de la 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

Sustituya la imagen, el puerto, las variables de entorno y los valores de escalado por los de su servicio App Runner.

Este comando proporciona una pila de aplicaciones completa en su AWS cuenta, que incluye un servicio de ECS en Fargate, un Application Load Balancer con grupos objetivo y comprobaciones de estado, políticas de autoescalado, grupos de seguridad y configuración de redes, y una URL predeterminada.

El aprovisionamiento suele tardar entre 3 y 5 minutos. Puede realizar un seguimiento del progreso en la consola de Amazon ECS, en la pestaña Recursos.

Una vez completado, pruebe el servicio ECS Express Mode utilizando la URL predeterminada que aparece en la consola. Compruebe que la aplicación funciona correctamente antes de continuar con el cambio de tráfico.

Paso 3: Configure el dominio personalizado para el modo exprés de ECS

Si su servicio App Runner usa un dominio personalizado, configure el mismo dominio personalizado para el servicio ECS Express Mode antes de cambiar el tráfico. Este paso configura el Application Load Balancer creado para el servicio ECS Express Mode para que acepte el tráfico de su dominio y utilice el certificado ACM para HTTPS.

Para obtener instrucciones detalladas, consulte Añadir un dominio personalizado a su servicio en la Guía para desarrolladores de Amazon ECS.

La siguiente imagen muestra un ejemplo de configuración de la condición del encabezado del host en la regla de escucha de Application Load Balancer.

Paso 4: Cambie el tráfico mediante el enrutamiento ponderado de Route 53

Si su servicio App Runner ya usa un dominio personalizado, puede transferir gradualmente el tráfico al servicio ECS Express Mode mediante el enrutamiento ponderado de Route 53. El enrutamiento ponderado le permite enrutar el tráfico del mismo nombre de host a varios puntos finales. Cada punto final se define como un registro DNS independiente con su propio peso, y Route 53 distribuye las solicitudes de acuerdo con esos pesos.

Convierte el registro existente de App Runner en un registro ponderado:

Cree un registro ponderado para el modo ECS Express:

Cambie el tráfico gradualmente:

Una vez configurados los registros de DNS, comience a desplazar el tráfico aumentando el peso del ECS Express Mode y reduciendo proporcionalmente el peso de App Runner. Un enfoque recomendado:

En cada paso, pruebe la aplicación antes de cambiar el tráfico adicional. Si se producen problemas en algún momento, retroceda ajustando las ponderaciones a sus valores anteriores.

Paso 5: Completa la migración

Tras comprobar que el servicio ECS Express Mode gestiona correctamente el tráfico de producción y que ha pasado el período de validación, complete la migración:

Elimine el servicio App Runner:

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

Considere también la posibilidad de eliminar los recursos que ya no sean necesarios:

Migración de las implementaciones basadas en el origen

Si su servicio actual de App Runner se implementa desde el código fuente y no desde una imagen de contenedor, debe agregar un paso de contenerización antes de implementarlo en ECS Express Mode. A diferencia de App Runner, el modo ECS Express requiere una imagen de contenedor. Sin embargo, puede replicar la experiencia de implementación automatizada de App Runner mediante CI/CD herramientas como GitHub Actions con Amazon ECS Deploy Express Service GitHub Action.

El flujo de trabajo de migración consta de tres etapas:

El siguiente diagrama muestra cómo funciona este flujo de trabajo mediante GitHub Actions:

Almacene su aplicación en contenedores

Si su aplicación aún no tiene un Dockerfile, cree uno en la raíz del repositorio. El Dockerfile sirve como modelo para crear y empaquetar el código fuente en una imagen de contenedor.

La estructura de tu repositorio debe 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

Configure GitHub las acciones para el despliegue automatizado

Para replicar la implementación automática de App Runner mediante la inserción de código, configure GitHub las acciones con lo siguiente:

Ejemplo de flujo de trabajo de GitHub acciones

Cree un archivo de flujo de trabajo en.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

Cuando insertas cambios de código en tu rama principal, GitHub Actions crea automáticamente una nueva imagen de contenedor, la envía a Amazon Elastic Container Registry y la implementa en tu servicio ECS Express Mode. Esto reproduce la experiencia de implementación automatizada que tuvo con App Runner.

Una vez que se ejecute el servicio ECS Express Mode, siga los pasos 3 y 5 del tutorial de migración para configurar el dominio personalizado, transferir el tráfico mediante el enrutamiento de DNS y completar la migración.

Recursos adicionales