AWS App Runner ne sera plus ouvert aux nouveaux clients à compter du 30 avril 2026. Si vous souhaitez utiliser App Runner, inscrivez-vous avant cette date. Les clients existants peuvent continuer à utiliser le service normalement. Pour plus d'informations, consultez AWS App Runner la section Modification de la disponibilité.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

AWS App Runner changement de disponibilité

Après mûre réflexion, nous avons décidé de fermer nos portes AWS App Runner aux nouveaux clients à compter du 30 avril 2026. AWS App Runner Les clients existants peuvent continuer à utiliser le service normalement, notamment en créant de nouvelles ressources et de nouveaux services. AWS continue d'investir dans la sécurité et la disponibilité de AWS App Runner, mais nous ne prévoyons pas d'introduire de nouvelles fonctionnalités.

Nous recommandons aux clients d'explorer le mode Amazon Elastic Container Service (Amazon ECS) Express lors de la migration depuis. AWS App Runner Le mode Amazon ECS Express préserve la simplicité de fonctionnement d'App Runner tout en donnant accès à l'ensemble des fonctionnalités Amazon ECS dans son ensemble plus large. Avec un seul appel d'API, vous fournissez une image de conteneur et deux rôles IAM, et Amazon ECS fournit une pile d'applications complète dans votre AWS compte, y compris un service ECS sur Fargate, un Application Load Balancer, une mise à l'échelle automatique et un réseau. L'utilisation du mode Amazon ECS Express est gratuite. Vous ne payez que pour les AWS ressources sous-jacentes créées pour exécuter votre application.

Ce guide explique comment migrer un service App Runner existant vers le mode ECS Express et transférer progressivement le trafic à l'aide du routage DNS.

Présentation de la migration

Ce guide utilise une approche de blue/green déploiement avec un routage pondéré DNS pour faire migrer le trafic d'App Runner vers le mode ECS Express. Les deux services s'exécutent simultanément pendant la migration. Vous utilisez Amazon Route 53 (ou votre fournisseur DNS) pour transférer progressivement le trafic du service App Runner vers le service ECS Express Mode, en commençant par un faible pourcentage et en augmentant au fil du temps. Cette approche minimise les temps d'arrêt et vous permet de revenir en arrière en ajustant le poids du DNS en cas de problème.

Une migration classique comprend les étapes suivantes :

Conditions préalables

Avant de commencer, assurez-vous que vous disposez des éléments suivants :

Si vous souhaitez conserver un domaine personnalisé existant pendant la migration, vous devez également :

Avant de commencer

Procédure pas à pas de migration

Le schéma suivant montre comment fonctionne la migration à l'aide de Route 53 pour transférer les enregistrements DNS entre votre service App Runner et votre service ECS Express Mode.

Étape 1 : passez en revue la configuration existante d'App Runner

Dans la console App Runner, passez en revue votre service existant et notez les valeurs que vous souhaitez reporter. Notez au minimum les points suivants :

Vous pouvez également consulter les autres paramètres d'exécution que vous souhaitez transférer dans le nouveau service.

Pour plus de détails sur le domaine personnalisé, consultezGestion des noms de domaine personnalisés pour un service App Runner.

Étape 2 : Création du service ECS Express Mode

Créez un service ECS Express Mode en utilisant la même image de conteneur que celle utilisée par votre service App Runner. Vous pouvez créer le service à l'aide du AWS Management Consoleou du AWS CLI.

Exemple de commande 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

Remplacez l'image, le port, les variables d'environnement et les valeurs d'échelle par ceux de votre service App Runner.

Cette commande fournit une pile d'applications complète dans votre AWS compte, y compris un service ECS sur Fargate, un Application Load Balancer avec des groupes cibles et des bilans de santé, des politiques d'auto-scaling, des groupes de sécurité et une configuration réseau, ainsi qu'une URL par défaut.

Le provisionnement prend généralement de 3 à 5 minutes. Vous pouvez suivre les progrès dans la console Amazon ECS sous l'onglet Ressources.

Une fois terminé, testez votre service ECS Express Mode à l'aide de l'URL par défaut affichée dans la console. Vérifiez que votre application fonctionne correctement avant de procéder au transfert de trafic.

Étape 3 : Configuration du domaine personnalisé pour le mode ECS Express

Si votre service App Runner utilise un domaine personnalisé, configurez le même domaine personnalisé pour le service ECS Express Mode avant de transférer le trafic. Cette étape configure l'Application Load Balancer créé pour le service ECS Express Mode afin qu'il accepte le trafic pour votre domaine et utilise le certificat ACM pour HTTPS.

Pour obtenir des instructions détaillées, consultez la section Ajouter un domaine personnalisé à votre service dans le manuel Amazon ECS Developer Guide.

L'image suivante montre un exemple de configuration de la condition d'en-tête de l'hôte dans la règle d'écoute Application Load Balancer.

Étape 4 : Transférez le trafic à l'aide du routage pondéré Route 53

Si votre service App Runner utilise déjà un domaine personnalisé, vous pouvez progressivement transférer le trafic vers le service ECS Express Mode en utilisant le routage pondéré Route 53. Le routage pondéré vous permet d'acheminer le trafic d'un même nom d'hôte vers plusieurs points de terminaison. Chaque point de terminaison est défini comme un enregistrement DNS distinct avec son propre poids, et Route 53 distribue les demandes en fonction de ces poids.

Convertissez l'enregistrement App Runner existant en enregistrement pondéré :

Créez un enregistrement pondéré pour le mode ECS Express :

Transférez progressivement le trafic :

Une fois les enregistrements DNS configurés, commencez à transférer le trafic en augmentant le poids du mode ECS Express tout en diminuant proportionnellement le poids de l'App Runner. Approche recommandée :

À chaque étape, testez l'application avant de transférer du trafic supplémentaire. Si des problèmes surviennent à un moment ou à un autre, revenez en arrière en ajustant les poids à leurs valeurs précédentes.

Étape 5 : terminer la migration

Après avoir vérifié que le service ECS Express Mode gère correctement le trafic de production et que la période de validation est dépassée, terminez la migration :

Supprimez le service App Runner :

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

Pensez également à supprimer les ressources dont vous n'avez plus besoin :

Migration de déploiements basés sur les sources

Si votre service App Runner existant est déployé à partir du code source plutôt que d'une image de conteneur, vous devez ajouter une étape de conteneurisation avant de le déployer en mode ECS Express. Contrairement à App Runner, le mode ECS Express nécessite une image de conteneur. Cependant, vous pouvez reproduire l'expérience de déploiement automatique d'App Runner à l'aide d' CI/CD outils tels que GitHub Actions with the Amazon ECS Deploy Express Service GitHub Action.

Le flux de travail de migration comporte trois étapes :

Le schéma suivant montre le fonctionnement de ce flux de travail à l'aide d' GitHub actions :

Conteneurisez votre application

Si votre application ne possède pas encore de Dockerfile, créez-en un à la racine de votre dépôt. Le Dockerfile sert de modèle pour créer et empaqueter votre code source dans une image de conteneur.

La structure de votre dépôt doit inclure :

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

Configurer des GitHub actions pour un déploiement automatique

Pour reproduire le déploiement automatique d'App Runner lors du transfert de code, configurez GitHub les actions comme suit :

Exemple de flux de travail d' GitHub actions

Créez un fichier de flux de travail à l'adresse suivante .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

Lorsque vous envoyez des modifications de code à votre branche principale, GitHub Actions crée automatiquement une nouvelle image de conteneur, la transmet à Amazon Elastic Container Registry et la déploie sur votre service ECS Express Mode. Cela reproduit l'expérience de déploiement automatique que vous avez eue avec App Runner.

Une fois le service ECS Express Mode exécuté, suivez les étapes 3 à 5 de la procédure de migration pour configurer le domaine personnalisé, transférer le trafic à l'aide du routage DNS et terminer la migration.

Ressources supplémentaires