AWS App Runner non sarà più aperto a nuovi clienti a partire dal 30 aprile 2026. Se desideri utilizzare App Runner, registrati prima di tale data. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta AWS App Runner la pagina Modifica della disponibilità.

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

AWS App Runner modifica della disponibilità

Dopo un'attenta valutazione, abbiamo deciso di chiudere AWS App Runner a nuovi clienti a partire dal 30 aprile 2026. AWS App Runner I clienti esistenti possono continuare a utilizzare il servizio normalmente, inclusa la creazione di nuove risorse e servizi. AWS continua a investire in sicurezza e disponibilità per AWS App Runner, ma non abbiamo intenzione di introdurre nuove funzionalità.

Consigliamo ai clienti di esplorare la modalità Express di Amazon Elastic Container Service (Amazon ECS) durante la migrazione da. AWS App Runner La modalità Amazon ECS Express preserva la semplicità operativa di App Runner fornendo al contempo l'accesso al più ampio set di funzionalità di Amazon ECS. Con una singola chiamata API, fornisci un'immagine del contenitore e due ruoli IAM e Amazon ECS fornisce uno stack di applicazioni completo nel tuo AWS account, incluso un servizio ECS su Fargate, un Application Load Balancer, auto scaling e networking. Non sono previsti costi aggiuntivi per l'utilizzo della modalità Amazon ECS Express. Paghi solo per le AWS risorse sottostanti create per eseguire l'applicazione.

Questa guida descrive come migrare un servizio App Runner esistente alla modalità ECS Express e spostare gradualmente il traffico utilizzando il routing DNS.

Panoramica sulla migrazione

Questa guida utilizza un approccio di blue/green implementazione con routing DNS ponderato per migrare il traffico da App Runner alla modalità ECS Express. Entrambi i servizi vengono eseguiti contemporaneamente durante la migrazione. Utilizzi Amazon Route 53 (o il tuo provider DNS) per spostare gradualmente il traffico dal servizio App Runner al servizio ECS Express Mode, iniziando con una piccola percentuale e aumentando nel tempo. Questo approccio riduce al minimo i tempi di inattività e consente di ripristinare i pesi del DNS in caso di problemi.

Una migrazione tipica include i seguenti passaggi:

Prerequisiti

Prima di iniziare, assicurati di disporre di quanto segue:

Se desideri preservare un dominio personalizzato esistente durante la migrazione, devi anche:

Prima di iniziare

Procedura dettagliata sulla migrazione

Il diagramma seguente mostra come funziona la migrazione utilizzando Route 53 per spostare i record DNS tra il servizio App Runner e il servizio ECS Express Mode.

Passaggio 1: rivedi la configurazione esistente di App Runner

Nella console App Runner, esamina il servizio esistente e annota i valori che desideri trasferire. Come minimo, tieni presente quanto segue:

Puoi anche rivedere tutte le altre impostazioni di runtime che desideri trasferire nel nuovo servizio.

Per dettagli personalizzati sul dominio, consultaGestione di nomi di dominio personalizzati per un servizio App Runner.

Fase 2: Creare il servizio ECS Express Mode

Crea un servizio in modalità ECS Express utilizzando la stessa immagine del contenitore utilizzata dal servizio App Runner. È possibile creare il servizio utilizzando il Console di gestione AWSo il. AWS CLI

Esempio di comando 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

Sostituisci l'immagine, la porta, le variabili di ambiente e i valori di scala con quelli del tuo servizio App Runner.

Questo comando fornisce uno stack di applicazioni completo nel tuo AWS account, incluso un servizio ECS su Fargate, un Application Load Balancer con gruppi target e controlli di integrità, politiche di auto-scaling, gruppi di sicurezza e configurazione di rete e un URL predefinito.

Il provisioning richiede in genere 3-5 minuti. Puoi monitorare i progressi nella console Amazon ECS nella scheda Risorse.

Una volta completato, testa il servizio ECS Express Mode utilizzando l'URL predefinito mostrato nella console. Verifica che l'applicazione funzioni correttamente prima di procedere con lo spostamento del traffico.

Passaggio 3: Configurare il dominio personalizzato per la modalità ECS Express

Se il servizio App Runner utilizza un dominio personalizzato, configura lo stesso dominio personalizzato per il servizio ECS Express Mode prima di spostare il traffico. Questo passaggio configura l'Application Load Balancer creato per il servizio ECS Express Mode in modo che accetti il traffico per il tuo dominio e utilizzi il certificato ACM per HTTPS.

Per istruzioni dettagliate, consulta Aggiungere un dominio personalizzato al servizio nella Amazon ECS Developer Guide.

L'immagine seguente mostra un esempio di configurazione della condizione dell'intestazione dell'host nella regola del listener Application Load Balancer.

Fase 4: Spostare il traffico utilizzando il routing ponderato della Route 53

Se il servizio App Runner utilizza già un dominio personalizzato, puoi spostare gradualmente il traffico verso il servizio ECS Express Mode utilizzando il routing ponderato Route 53. Il routing ponderato consente di indirizzare il traffico per lo stesso nome host verso più endpoint. Ogni endpoint è definito come un record DNS separato con un proprio peso e Route 53 distribuisce le richieste in base a tali pesi.

Converti il record App Runner esistente in un record ponderato:

Crea un record ponderato per la modalità ECS Express:

Sposta gradualmente il traffico:

Una volta configurati i record DNS, inizia a spostare il traffico aumentando il peso della modalità ECS Express e diminuendo proporzionalmente il peso di App Runner. Un approccio consigliato:

In ogni fase, prova l'applicazione prima di spostare traffico aggiuntivo. Se in qualsiasi momento si verificano dei problemi, tornate indietro regolando i pesi sui valori precedenti.

Fase 5: Completare la migrazione

Dopo aver verificato che il servizio ECS Express Mode gestisca correttamente il traffico di produzione e che il periodo di convalida sia trascorso, completa la migrazione:

Elimina il servizio App Runner:

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

Valuta anche la possibilità di rimuovere tutte le risorse che non sono più necessarie:

Migrazione delle distribuzioni basate sul codice sorgente

Se il servizio App Runner esistente viene distribuito dal codice sorgente anziché da un'immagine del contenitore, è necessario aggiungere una fase di containerizzazione prima di eseguire la distribuzione in modalità ECS Express. A differenza di App Runner, ECS Express Mode richiede un'immagine del contenitore. Tuttavia, puoi replicare l'esperienza di distribuzione automatizzata di App Runner utilizzando CI/CD strumenti come GitHub Actions with Amazon ECS Deploy Express Service Action. GitHub

Il flusso di lavoro di migrazione prevede tre fasi:

Il diagramma seguente mostra come funziona questo flusso di lavoro utilizzando Actions: GitHub

Containerizza la tua applicazione

Se l'applicazione non ha già un Dockerfile, creane uno nella radice del repository. Il Dockerfile funge da modello per creare e impacchettare il codice sorgente in un'immagine del contenitore.

La struttura del repository dovrebbe includere:

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

Imposta GitHub le azioni per la distribuzione automatizzata

Per replicare la distribuzione automatica di App Runner tramite code push, configura GitHub Actions con quanto segue:

Esempio di workflow GitHub Actions

Crea un file di workflow all'indirizzo.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 invii modifiche al codice nella filiale principale, GitHub Actions crea automaticamente una nuova immagine del contenitore, la invia ad Amazon Elastic Container Registry e la distribuisce al tuo servizio ECS Express Mode. Questo replica l'esperienza di distribuzione automatizzata che hai avuto con App Runner.

Una volta che il servizio ECS Express Mode è in esecuzione, segui i passaggi 3—5 della procedura dettagliata di migrazione per configurare il dominio personalizzato, spostare il traffico utilizzando il routing DNS e completare la migrazione.

Risorse aggiuntive