

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é](https://docs.aws.amazon.com/apprunner/latest/dg/apprunner-availability-change.html).

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.

# Observabilité pour votre service App Runner
<a name="monitor"></a>

AWS App Runner s'intègre à plusieurs AWS services afin de vous fournir une suite complète d'outils d'observabilité pour votre service App Runner. Les rubriques de ce chapitre décrivent ces fonctionnalités.

**Topics**
+ [Suivi de l'activité du service App Runner](monitor-activity.md)
+ [Afficher les logs d'App Runner transmis à CloudWatch Logs](monitor-cwl.md)
+ [Affichage des statistiques de service App Runner signalées à CloudWatch](monitor-cw.md)
+ [Gestion des événements App Runner dans EventBridge](monitor-ev.md)
+ [Journalisation des appels d'API App Runner avec AWS CloudTrail](monitor-ct.md)
+ [Suivi de votre application App Runner avec X-Ray](monitor-xray.md)

# Suivi de l'activité du service App Runner
<a name="monitor-activity"></a>

AWS App Runner utilise une liste d'opérations pour suivre l'activité de votre service App Runner. Une opération représente un appel asynchrone à une action d'API, telle que la création d'un service, la mise à jour d'une configuration et le déploiement d'un service. Les sections suivantes expliquent comment suivre l'activité dans la console App Runner et à l'aide de l'API.

## Suivez l'activité du service App Runner
<a name="monitor-activity.monitor"></a>

Suivez l'activité de votre service App Runner à l'aide de l'une des méthodes suivantes :

------
#### [ App Runner console ]

La console App Runner affiche l'activité de votre service App Runner et propose d'autres moyens d'explorer les opérations.

**Pour consulter l'activité de votre service**

1. Ouvrez la [console App Runner](https://console.aws.amazon.com/apprunner), puis dans la liste des **régions**, sélectionnez votre Région AWS.

1. Dans le volet de navigation, choisissez **Services**, puis choisissez votre service App Runner.

   La console affiche le tableau de bord des services avec une vue d'**ensemble des services**.  
![\[Page du tableau de bord du service App Runner affichant la liste des activités\]](http://docs.aws.amazon.com/fr_fr/apprunner/latest/dg/images/console-dashboard.png)

1. Sur la page du tableau de bord du service, choisissez l'onglet **Activité**, s'il n'est pas déjà sélectionné.

   La console affiche la liste des opérations.

1. Pour rechercher des opérations spécifiques, descendez la liste en saisissant un terme de recherche. Vous pouvez rechercher n'importe quelle valeur figurant dans le tableau.

1. Choisissez une opération répertoriée pour voir ou télécharger le journal correspondant.

------
#### [ App Runner API or AWS CLI ]

L'[ListOperations](https://docs.aws.amazon.com/apprunner/latest/api/API_ListOperations.html)action, en fonction de l'Amazon Resource Name (ARN) d'un service App Runner, renvoie une liste des opérations effectuées sur ce service. Chaque élément de la liste contient un identifiant d'opération et des informations de suivi.

------

# Afficher les logs d'App Runner transmis à CloudWatch Logs
<a name="monitor-cwl"></a>

Vous pouvez utiliser Amazon CloudWatch Logs pour surveiller, stocker et accéder aux fichiers journaux générés par vos ressources dans divers AWS services. Pour plus d'informations, consultez le [guide de l'utilisateur d'Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/).

AWS App Runner collecte les résultats de vos déploiements d'applications et de votre service actif et les diffuse vers CloudWatch Logs. Les sections suivantes répertorient les flux de log d'App Runner et vous montrent comment les consulter dans la console App Runner.

## Groupes de logs et flux App Runner
<a name="monitor-cwl.streams"></a>

CloudWatch Les journaux conservent les données des journaux dans des flux de journaux qu'ils organisent ensuite en groupes de journaux. Un *flux de journal* est une séquence d'événements de journal provenant d'une source spécifique. Un *groupe de journaux* est un groupe de flux de journaux qui partagent les mêmes paramètres de conservation, de surveillance et de contrôle d’accès.

App Runner définit deux groupes de CloudWatch journaux, chacun avec plusieurs flux de journaux, pour chaque service App Runner de votre Compte AWS.

### Journaux de service
<a name="monitor-cwl.streams.service"></a>

Le groupe de journaux de service contient les résultats de journalisation générés par App Runner lorsqu'il gère votre service App Runner et agit en conséquence.


|  **Nom du groupe de journaux**  |  **Exemple**  | 
| --- | --- | 
|  `/aws/apprunner/service-name/service-id/service`  |  `/aws/apprunner/python-test/ac7ec8b51ff34746bcb6654e0bcb23da/service`  | 

Au sein du groupe de journaux de service, App Runner crée un flux de journaux d'événements pour capturer l'activité pendant le cycle de vie de votre service App Runner. Il peut s'agir, par exemple, du lancement ou de la suspension de votre application.

En outre, App Runner crée un flux de journal pour chaque opération asynchrone de longue durée liée à votre service. Le nom du flux de journal reflète le type d'opération et l'ID d'opération spécifique.

Un *déploiement* est un type d'opération. Les journaux de déploiement contiennent les résultats de journalisation des étapes de création et de déploiement effectuées par App Runner lorsque vous créez un service ou déployez une nouvelle version de votre application. Les noms des flux du journal de déploiement commencent `deployment/` et se terminent par l'ID de l'opération qui effectue le déploiement. Cette opération est soit un [CreateService](https://docs.aws.amazon.com/apprunner/latest/api/API_CreateService.html)appel pour le déploiement initial de l'application, soit un [StartDeployment](https://docs.aws.amazon.com/apprunner/latest/api/API_StartDeployment.html)appel pour chaque déploiement ultérieur.

Dans un journal de déploiement, chaque message de journal commence par un préfixe :
+ `[AppRunner]`— Sortie générée par App Runner lors du déploiement.
+ `[Build]`— Sortie de vos propres scripts de construction.


|  **Nom du flux de log**  |  **Exemple**  | 
| --- | --- | 
|  `events`  |  *N/A (nom fixe)*  | 
|  `operation-type/operation-id`  |  `deployment/c2c8eeedea164f459cf78f12a8953390`  | 

### Journaux d'application
<a name="monitor-cwl.streams.deployment"></a>

Le groupe de journaux d'applications contient la sortie du code de votre application en cours d'exécution.


|  **Nom du groupe de journaux**  |  **Exemple**  | 
| --- | --- | 
|  `/aws/apprunner/service-name/service-id/application`  |  `/aws/apprunner/python-test/ac7ec8b51ff34746bcb6654e0bcb23da/application`  | 

Au sein du groupe de journaux d'applications, App Runner crée un flux de journal pour chaque instance (unité de dimensionnement) qui exécute votre application.


|  **Nom du flux de log**  |  **Exemple**  | 
| --- | --- | 
|  `instance/instance-id`  |  `instance/1a80bc9134a84699b7b3432ebeebb591`  | 

## Afficher les journaux d'App Runner dans la console
<a name="monitor-cwl.console"></a>

La console App Runner affiche un résumé de tous les journaux de votre service et vous permet de les consulter, de les explorer et de les télécharger.

**Pour consulter les journaux de votre service**

1. Ouvrez la [console App Runner](https://console.aws.amazon.com/apprunner), puis dans la liste des **régions**, sélectionnez votre Région AWS.

1. Dans le volet de navigation, choisissez **Services**, puis choisissez votre service App Runner.

   La console affiche le tableau de bord des services avec une vue d'**ensemble des services**.  
![\[Page du tableau de bord du service App Runner affichant la liste des activités\]](http://docs.aws.amazon.com/fr_fr/apprunner/latest/dg/images/console-dashboard.png)

1. Sur la page du tableau de bord du service, choisissez l'onglet **Logs**.

   La console affiche quelques types de journaux dans plusieurs sections :
   + **Journal des événements** : activité pendant le cycle de vie de votre service App Runner. La console affiche les derniers événements.
   + **Journaux de déploiement** : envoyez les déploiements de référentiels à votre service App Runner. La console affiche un flux de journal distinct pour chaque déploiement.
   + **Journaux d'application** : sortie de l'application Web déployée sur votre service App Runner. La console combine les résultats de toutes les instances en cours d'exécution dans un seul flux de journal.  
![\[L'onglet Logs sur la page du tableau de bord du service App Runner\]](http://docs.aws.amazon.com/fr_fr/apprunner/latest/dg/images/service-dashboad-logs.png)

1. Pour rechercher des déploiements spécifiques, réduisez la liste des journaux de déploiement en saisissant un terme de recherche. Vous pouvez rechercher n'importe quelle valeur figurant dans le tableau.

1. Pour afficher le contenu d'un journal, choisissez **Afficher le journal complet (journal** des événements) ou le nom du flux du journal (journaux de déploiement et d'application).

1. Choisissez **Télécharger** pour télécharger un journal. Pour un flux de journal de déploiement, sélectionnez d'abord un flux de journal.

1. Choisissez **Afficher dans CloudWatch** pour ouvrir la CloudWatch console et utiliser toutes ses fonctionnalités pour explorer les journaux de service de votre App Runner. Pour un flux de journal de déploiement, sélectionnez d'abord un flux de journal.
**Note**  
La CloudWatch console est particulièrement utile si vous souhaitez consulter les journaux d'applications d'instances spécifiques au lieu du journal d'applications combiné.

# Affichage des statistiques de service App Runner signalées à CloudWatch
<a name="monitor-cw"></a>

Amazon CloudWatch surveille vos ressources Amazon Web Services (AWS) et les applications que vous utilisez AWS en temps réel. Vous pouvez les utiliser CloudWatch pour collecter et suivre les métriques, qui sont des variables que vous pouvez mesurer pour vos ressources et vos applications. Vous pouvez également l'utiliser pour créer des alarmes qui surveillent les métriques. Lorsqu'un certain seuil est atteint, CloudWatch envoie des notifications ou modifie automatiquement les ressources surveillées. Pour plus d'informations, consultez le [guide de CloudWatch l'utilisateur Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).

AWS App Runner collecte diverses mesures qui vous offrent une meilleure visibilité sur l'utilisation, les performances et la disponibilité de vos services App Runner. Certains indicateurs suivent les instances individuelles qui exécutent votre service Web, tandis que d'autres concernent le niveau de service global. Les sections suivantes répertorient les statistiques d'App Runner et vous montrent comment les consulter dans la console App Runner. 

## Statistiques d'App Runner
<a name="monitor-cw.metrics"></a>

App Runner collecte les métriques suivantes relatives à votre service et les publie CloudWatch dans l'espace de `AWS/AppRunner` noms.

**Note**  
Avant le 23 août 2023, les mesures d'utilisation du **processeur et d'utilisation** de la **mémoire** étaient basées sur les unités de vCPU et les mégaoctets de mémoire utilisés, plutôt que sur le *pourcentage d'utilisation* tel que calculé aujourd'hui. Si votre application s'est exécutée sur App Runner avant cette date et que vous choisissez de revenir pour consulter les statistiques de cette date sur App Runner ou sur la CloudWatch console, vous verrez un affichage des statistiques dans les deux unités et constaterez également certaines irrégularités en conséquence. 

**Important**  
Vous devrez mettre à jour toutes les CloudWatch alarmes basées sur les valeurs métriques *d'utilisation du processeur* et *d'utilisation de la mémoire* avant le 23 août 2023. Mettez à jour les alarmes à déclencher en fonction du pourcentage d'utilisation plutôt que du vCPU ou des mégaoctets. Pour plus d'informations, consultez le [guide de CloudWatch l'utilisateur Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).

Les **métriques au niveau de l'instance** sont collectées pour chaque instance (unité de mise à l'échelle) individuellement.


|  **Qu'est-ce qui est mesuré ?**  |  **Métrique**  |  **Description**  | 
| --- | --- | --- | 
|  CPU utilization  |  `CPUUtilization`  |  Pourcentage de l'utilisation moyenne du processeur pendant des périodes d'une minute par rapport à l'utilisation totale du processeur réservée par la configuration du service.  | 
|  Memory utilization  |  `MemoryUtilization`  |  Pourcentage d'utilisation moyenne de la mémoire pendant des périodes d'une minute par rapport à la mémoire totale réservée par la configuration du service.  | 

Les **indicateurs de niveau de service** sont collectés pour l'ensemble du service.


|  **Qu'est-ce qui est mesuré ?**  |  **Métrique**  |  **Description**  | 
| --- | --- | --- | 
|  CPU utilization  |  `CPUUtilization`  |  Pourcentage d'utilisation agrégée du processeur sur toutes les instances pendant des périodes d'une minute par rapport à l'utilisation totale du processeur réservée par la configuration du service.  | 
|  Memory utilization  |  `MemoryUtilization`  |  Pourcentage d'utilisation de la mémoire agrégée sur toutes les instances pendant des périodes d'une minute par rapport à la mémoire totale réservée par la configuration du service.  | 
|  Concurrency  |  `Concurrency`  |  Nombre approximatif de demandes simultanées traitées par le service.  | 
|  HTTP request count  |  `Requests`  |  Le nombre de requêtes HTTP reçues par le service.  | 
|  HTTP status counts  |  `2xxStatusResponses` `4xxStatusResponses` `5xxStatusResponses`  |  Nombre de requêtes HTTP ayant renvoyé l'état de chaque réponse, regroupées par catégorie (2XX, 4XX, 5XX).  | 
|  HTTP request latency  |  `RequestLatency`  |  Le temps, en millisecondes, nécessaire à votre service Web pour traiter les requêtes HTTP.  | 
|  Instance counts  |  `ActiveInstances`  |  Le nombre d'instances qui traitent les requêtes HTTP pour votre service.   Si la `ActiveInstances` métrique affiche zéro, cela signifie qu'il n'y a aucune demande pour le service. Cela n'indique pas que le nombre d'instances de votre service est nul.    | 

## Afficher les statistiques d'App Runner dans la console
<a name="monitor-cw.console"></a>

La console App Runner affiche graphiquement les statistiques collectées par App Runner pour votre service et propose d'autres moyens de les explorer.

**Note**  
Pour le moment, la console affiche uniquement les métriques de service. Pour consulter les métriques de l'instance, utilisez la CloudWatch console.

**Pour consulter les journaux de votre service**

1. Ouvrez la [console App Runner](https://console.aws.amazon.com/apprunner), puis dans la liste des **régions**, sélectionnez votre Région AWS.

1. Dans le volet de navigation, choisissez **Services**, puis choisissez votre service App Runner.

   La console affiche le tableau de bord des services avec une vue d'**ensemble des services**.  
![\[Page du tableau de bord du service App Runner affichant la liste des activités\]](http://docs.aws.amazon.com/fr_fr/apprunner/latest/dg/images/console-dashboard.png)

1. Sur la page du tableau de bord du service, choisissez l'onglet **Metrics**.

   La console affiche un ensemble de graphiques de mesures.   
![\[L'onglet Metrics sur la page du tableau de bord du service App Runner\]](http://docs.aws.amazon.com/fr_fr/apprunner/latest/dg/images/service-dashboad-metrics.png)

1. Choisissez une durée (par exemple, **12 h**) pour étendre les graphiques de mesures à la période récente de cette durée.

1. Choisissez **Ajouter au tableau de bord** en haut de l'une des sections du graphique, ou utilisez le menu de n'importe quel graphique pour ajouter les mesures pertinentes à un tableau de bord dans la CloudWatch console afin de poursuivre les recherches.

# Gestion des événements App Runner dans EventBridge
<a name="monitor-ev"></a>

À l'aide d'Amazon EventBridge, vous pouvez configurer des règles basées sur les événements qui surveillent un flux de données en temps réel provenant de votre AWS App Runner service afin de détecter certains modèles. Lorsqu'un modèle correspond à une règle, EventBridge lance une action dans une cible telle qu' AWS Lambda Amazon ECS et Amazon SNS. AWS Batch Par exemple, vous pouvez définir une règle pour l'envoi de notifications par e-mail en signalant un sujet Amazon SNS chaque fois qu'un déploiement de votre service échoue. Vous pouvez également définir une fonction Lambda pour avertir une chaîne Slack en cas d'échec d'une mise à jour du service. Pour plus d'informations EventBridge, consultez le [guide de EventBridge l'utilisateur Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/).

App Runner envoie les types d'événements suivants à EventBridge
+ *Modification de l'état du service* : modification du statut d'un service App Runner. Par exemple, l'état d'un service est devenu`DELETE_FAILED`.
+ Modification *de l'état du fonctionnement du service : modification* de l'état d'une longue opération asynchrone sur un service App Runner. Par exemple, un service a commencé à être créé, une mise à jour de service s'est terminée avec succès ou un déploiement de service s'est terminé avec des erreurs.

## Création d'une EventBridge règle pour agir sur les événements App Runner
<a name="monitor-ev.rule"></a>

Un EventBridge *événement* est un objet qui définit certains EventBridge champs standard, tels que le AWS service source et le type de détail (événement), ainsi qu'un ensemble de champs spécifiques à l'événement contenant les détails de l'événement. Pour créer une EventBridge règle, vous utilisez la EventBridge console pour définir un *modèle d'événements* (quels événements doivent être suivis) et spécifier une *action cible* (ce qui doit être fait lors d'un match). Un modèle d'événement est similaire aux événements auxquels il correspond. Vous spécifiez un sous-ensemble de champs à associer, et pour chaque champ, vous spécifiez une liste de valeurs possibles. Cette rubrique fournit des exemples d'événements et de modèles d'événements App Runner.

Pour plus d'informations sur la création de EventBridge règles, consultez [la section Création d'une règle pour un AWS service](https://docs.aws.amazon.com/eventbridge/latest/userguide/create-eventbridge-rule.html) dans le *guide de EventBridge l'utilisateur Amazon*.

**Note**  
Certains services prennent en charge *des modèles prédéfinis* dans. EventBridge Cela simplifie la création d'un modèle d'événement. Vous sélectionnez les valeurs des champs dans un formulaire et vous EventBridge générez le modèle pour vous. Pour le moment, App Runner ne prend pas en charge les modèles prédéfinis. Vous devez saisir le modèle sous forme d'objet JSON. Vous pouvez utiliser les exemples présentés dans cette rubrique comme point de départ.

## Exemples d'événements App Runner
<a name="monitor-ev.event-examples"></a>

Voici quelques exemples d'événements auxquels App Runner envoie des messages EventBridge.
+ Un événement de modification de l'état du service. Plus précisément, un service qui est passé du `RUNNING` statut `OPERATION_IN_PROGRESS` au statut.

  ```
  { 
    "version": "0",
    "id": "6a7e8feb-b491-4cf7-a9f1-bf3703467718",
    "detail-type": "AppRunner Service Status Change",
    "source": "aws.apprunner",
    "account": "111122223333",
    "time": "2021-04-29T11:54:23Z",
    "region": "us-east-2",
    "resources": [
      "arn:aws:apprunner:us-east-2:123456789012:service/my-app/8fe1e10304f84fd2b0df550fe98a71fa"
    ],
    "detail": {
      "previousServiceStatus": "OPERATION_IN_PROGRESS",
      "currentServiceStatus": "RUNNING",
      "serviceName": "my-app",
      "serviceId": "8fe1e10304f84fd2b0df550fe98a71fa",
      "message": "Service status is set to RUNNING.",
      "severity": "INFO"
    }
  }
  ```
+ Un événement de modification du statut de l'opération. Plus précisément, une `UpdateService` opération qui s'est terminée avec succès.

  ```
  { 
    "version": "0",
    "id": "6a7e8feb-b491-4cf7-a9f1-bf3703467718",
    "detail-type": "AppRunner Service Operation Status Change",
    "source": "aws.apprunner",
    "account": "111122223333",
    "time": "2021-04-29T18:43:48Z",
    "region": "us-east-2",
    "resources": [
      "arn:aws:apprunner:us-east-2:123456789012:service/my-app/8fe1e10304f84fd2b0df550fe98a71fa"
    ],
    "detail": {
      "operationStatus": "UpdateServiceCompletedSuccessfully",
      "serviceName": "my-app",
      "serviceId": "8fe1e10304f84fd2b0df550fe98a71fa",
      "message": "Service update completed successfully. New application and configuration is deployed.",
      "severity": "INFO"
    }
  }
  ```

## Exemples de modèles d'événements App Runner
<a name="monitor-ev.pattern-examples"></a>

Les exemples suivants illustrent les modèles d'événements que vous pouvez utiliser dans EventBridge les règles pour correspondre à un ou plusieurs événements App Runner. Un modèle d'événement est similaire à un événement. N'incluez que les champs auxquels vous souhaitez faire correspondre et fournissez une liste au lieu d'un scalaire pour chacun d'entre eux.
+ Faites correspondre tous les événements de changement de statut de service pour les services d'un compte spécifique, lorsque le service n'est plus en `RUNNING` statut.

  ```
  { 
    "detail-type": [ "AppRunner Service Status Change" ],
    "source": [ "aws.apprunner" ],
    "account": [ "111122223333" ],
    "detail": {
      "previousServiceStatus": [ "RUNNING" ]
    }
  }
  ```
+ Faites correspondre tous les événements de changement de statut d'opération pour les services d'un compte spécifique, lorsque l'opération a échoué.

  ```
  { 
    "detail-type": [ "AppRunner Service Operation Status Change" ],
    "source": [ "aws.apprunner" ],
    "account": [ "111122223333" ],
    "detail": {
      "operationStatus": [
        "CreateServiceFailed",
        "DeleteServiceFailed",
        "UpdateServiceFailed",
        "DeploymentFailed",
        "PauseServiceFailed",
        "ResumeServiceFailed"
      ]
    }
  }
  ```

## Référence des événements App Runner
<a name="monitor-ev.ref"></a>

### Modification de l'état du service
<a name="monitor-ev.ref.service"></a>

Un événement de modification de l'état du service est `detail-type` défini sur`AppRunner Service Status Change`. Il comporte les champs de détail et les valeurs suivants :

```
"serviceId": "your service ID",
"serviceName": "your service name",
"message": "Service status is set to CurrentStatus.",
"previousServiceStatus": "any valid service status",
"currentServiceStatus": "any valid service status",
"severity": "varies"
```

### Modification du statut de l'opération
<a name="monitor-ev.ref.operation"></a>

Un événement de modification du statut de l'opération est `detail-type` défini sur`AppRunner Service Operation Status Change`. Il comporte les champs de détail et les valeurs suivants :

```
"operationStatus": "see following table",
"serviceName": "your service name",
"serviceId": "your service ID",
"message": "see following table",
"severity": "varies"
```

Le tableau suivant répertorie tous les codes d'état possibles et les messages associés.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/apprunner/latest/dg/monitor-ev.html)

# Journalisation des appels d'API App Runner avec AWS CloudTrail
<a name="monitor-ct"></a>

App Runner est intégré à AWS CloudTrail un service qui fournit un enregistrement des actions effectuées par un utilisateur, un rôle ou un AWS service dans App Runner. CloudTrailcapture tous les appels d'API pour App Runner sous forme d'événements. Les appels capturés incluent des appels provenant de la console App Runner et des appels de code vers les opérations de l'API App Runner. Si vous créez un suivi, vous pouvez activer la diffusion continue d' CloudTrail événements vers un compartiment Amazon S3, y compris des événements pour App Runner. Si vous ne configurez pas de suivi, vous pouvez toujours consulter les événements les plus récents dans la CloudTrail console dans **Historique des événements**. À l'aide des informations collectées par CloudTrail, vous pouvez déterminer la demande qui a été faite à App Runner, l'adresse IP à partir de laquelle la demande a été faite, qui a fait la demande, quand elle a été faite et des détails supplémentaires. 

Pour en savoir plus CloudTrail, consultez le [guide de AWS CloudTrail l'utilisateur](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).

## Informations sur App Runner dans CloudTrail
<a name="apprunner-info-in-cloudtrail"></a>

CloudTrail est activé sur votre compte Compte AWS lorsque vous créez le compte. Lorsqu'une activité se produit dans App Runner, cette activité est enregistrée dans un CloudTrail événement avec d'autres événements de AWS service dans **l'historique des événements**. Vous pouvez consulter, rechercher et télécharger les événements récents dans votre Compte AWS. Pour plus d'informations, consultez la section [Affichage des événements avec l'historique des CloudTrail événements](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html). 

Pour un enregistrement continu des événements de votre navigateur Compte AWS, y compris des événements liés à App Runner, créez un parcours. Un *suivi* permet CloudTrail de fournir des fichiers journaux à un compartiment Amazon S3. Par défaut, lorsque vous créez un journal d’activité dans la console, il s’applique à toutes les régions Régions AWS. Le journal enregistre les événements de toutes les régions de la AWS partition et transmet les fichiers journaux au compartiment Amazon S3 que vous spécifiez. En outre, vous pouvez configurer d'autres AWS services pour analyser plus en détail les données d'événements collectées dans les CloudTrail journaux et agir en conséquence. Pour plus d’informations, consultez les ressources suivantes : 
+ [Vue d’ensemble de la création d’un journal d’activité](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [CloudTrail Services et intégrations pris en charge](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations)
+ [Configuration des notifications Amazon SNS pour CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html)
+ [Réception de fichiers CloudTrail journaux de plusieurs régions](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html) et [réception de fichiers CloudTrail journaux de plusieurs comptes](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html)

Toutes les actions d'App Runner sont enregistrées CloudTrail et documentées dans la référence de l' AWS App Runner API. Par exemple, les appels aux `CreateService``DeleteConnection`, et `StartDeployment` les actions génèrent des entrées dans les fichiers CloudTrail journaux. 

Chaque événement ou entrée de journal contient des informations sur la personne ayant initié la demande. Les informations relatives à l’identité permettent de déterminer les éléments suivants : 
+ Si la demande a été effectuée avec des informations d’identification d’utilisateur root ou IAM.
+ Si la demande a été effectuée avec des informations d’identification de sécurité temporaires pour un rôle ou un utilisateur fédéré.
+ Si la demande a été faite par un autre AWS service.

Pour plus d’informations, consultez la section [Élément userIdentity CloudTrail ](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html).

## Comprendre les entrées du fichier journal d'App Runner
<a name="understanding-apprunner-entries"></a>

Un suivi est une configuration qui permet de transmettre des événements sous forme de fichiers journaux à un compartiment Amazon S3 que vous spécifiez. CloudTrail les fichiers journaux contiennent une ou plusieurs entrées de journal. Un événement représente une demande unique provenant de n'importe quelle source et inclut des informations sur l'action demandée, la date et l'heure de l'action, ainsi que les paramètres de la demande. CloudTrail les fichiers journaux ne constituent pas une trace ordonnée des appels d'API publics, ils n'apparaissent donc pas dans un ordre spécifique. 

L'exemple suivant montre une entrée de CloudTrail journal illustrant l'`CreateService`action.

**Note**  
Pour des raisons de sécurité, certaines valeurs de propriétés sont supprimées dans les journaux et remplacées par le texte`HIDDEN_DUE_TO_SECURITY_REASONS`. Cela empêche la divulgation involontaire d'informations secrètes. Cependant, vous pouvez toujours voir que ces propriétés ont été transmises dans la demande ou renvoyées dans la réponse.

### Exemple d'entrée de CloudTrail journal pour l'action `CreateService` App Runner
<a name="understanding-apprunner-entries.example"></a>

```
{
  "eventVersion": "1.08",
  "userIdentity": {
    "type": "IAMUser",
    "principalId": "AIDACKCEVSQ6C2EXAMPLE",
    "arn": "arn:aws:iam::123456789012:user/aws-user",
    "accountId": "123456789012",
    "accessKeyId": "AKIAIOSFODNN7EXAMPLE",
    "userName": "aws-user"
  },
  "eventTime": "2020-10-02T23:25:33Z",
  "eventSource": "apprunner.amazonaws.com",
  "eventName": "CreateService",
  "awsRegion": "us-east-2",
  "sourceIPAddress": "192.0.2.0",
  "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.75 Safari/537.36",
  "requestParameters": {
    "serviceName": "python-test",
    "sourceConfiguration": {
      "codeRepository": {
        "repositoryUrl": "https://github.com/github-user/python-hello",
        "sourceCodeVersion": {
          "type": "BRANCH",
          "value": "main"
        },
        "codeConfiguration": {
          "configurationSource": "API",
          "codeConfigurationValues": {
            "runtime": "python3",
            "buildCommand": "HIDDEN_DUE_TO_SECURITY_REASONS",
            "startCommand": "HIDDEN_DUE_TO_SECURITY_REASONS",
            "port": "8080",
            "runtimeEnvironmentVariables": "HIDDEN_DUE_TO_SECURITY_REASONS"
          }
        }
      },
      "autoDeploymentsEnabled": true,
      "authenticationConfiguration": {
        "connectionArn": "arn:aws:apprunner:us-east-2:123456789012:connection/your-connection/e7656250f67242d7819feade6800f59e"
      }
    },
    "healthCheckConfiguration": {
      "protocol": "HTTP"
    },
    "instanceConfiguration": {
      "cpu": "256",
      "memory": "1024"
    }
  },
  "responseElements": {
    "service": {
        "serviceName": "python-test",
        "serviceId": "dfa2b7cc7bcb4b6fa6c1f0f4efff988a",
        "serviceArn": "arn:aws:apprunner:us-east-2:123456789012:service/python-test/dfa2b7cc7bcb4b6fa6c1f0f4efff988a",
        "serviceUrl": "generated domain",
        "createdAt": "2020-10-02T23:25:32.650Z",
        "updatedAt": "2020-10-02T23:25:32.650Z",
        "status": "OPERATION_IN_PROGRESS",
        "sourceConfiguration": {
            "codeRepository": {
                "repositoryUrl": "https://github.com/github-user/python-hello",
                "sourceCodeVersion": {
                    "type": "Branch",
                    "value": "main"
                },
                "sourceDirectory": "/",
                "codeConfiguration": {
                    "codeConfigurationValues": {
                        "configurationSource": "API",
                        "runtime": "python3",
                        "buildCommand": "HIDDEN_DUE_TO_SECURITY_REASONS",
                        "startCommand": "HIDDEN_DUE_TO_SECURITY_REASONS",
                        "port": "8080",
                        "runtimeEnvironmentVariables": "HIDDEN_DUE_TO_SECURITY_REASONS"
                    }
                }
            },
            "autoDeploymentsEnabled": true,
            "authenticationConfiguration": {
                "connectionArn": "arn:aws:apprunner:us-east-2:123456789012:connection/your-connection/e7656250f67242d7819feade6800f59e"
            }
        },
        "healthCheckConfiguration": {
            "protocol": "HTTP",
            "path": "/",
            "interval": 5,
            "timeout": 2,
            "healthyThreshold": 3,
            "unhealthyThreshold": 5
        },
        "instanceConfiguration": {
            "cpu": "256",
            "memory": "1024"
        },
        "autoScalingConfigurationSummary": {
            "autoScalingConfigurationArn": "arn:aws:apprunner:us-east-2:123456789012:autoscalingconfiguration/DefaultConfiguration/1/00000000000000000000000000000001",
            "autoScalingConfigurationName": "DefaultConfiguration",
            "autoScalingConfigurationRevision": 1
        }
    }
},
  "requestID": "1a60af60-ecf5-4280-aa8f-64538319ba0a",
  "eventID": "e1a3f623-4d24-4390-a70b-bf08a0e24669",
  "readOnly": false,
  "eventType": "AwsApiCall",
  "recipientAccountId": "123456789012"
}
```

# Suivi de votre application App Runner avec X-Ray
<a name="monitor-xray"></a>

AWS X-Ray est un service qui collecte des données sur les demandes traitées par votre application et fournit des outils que vous pouvez utiliser pour visualiser, filtrer et obtenir des informations sur ces données afin d'identifier les problèmes et les opportunités d'optimisation. Pour toute demande retracée envoyée à votre application, vous pouvez consulter des informations détaillées non seulement sur la demande et la réponse, mais également sur les appels que votre application fait aux AWS ressources en aval, aux microservices, aux bases de données et au Web APIs HTTP.

X-Ray utilise les données de suivi provenant des AWS ressources qui alimentent vos applications cloud pour générer un graphique de service détaillé. Le graphique de services montre le client, le service frontal et les services dorsaux que votre service frontal appelle pour traiter les demandes et conserver les données. Utilisez le graphique de services pour identifier les goulots d'étranglement, les pics de latence et d'autres problèmes à résoudre pour améliorer les performances de vos applications.

Pour plus d'informations sur X-Ray, veuillez consulter le [Guide du développeur AWS X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/).

![\[Exemple de carte de service X-Ray pour un service App Runner\]](http://docs.aws.amazon.com/fr_fr/apprunner/latest/dg/images/xray-example.png)


## Instrumentez votre application pour le traçage
<a name="monitor-xray.instrument"></a>

Instrumentez votre application de service App Runner pour le traçage à l'aide [OpenTelemetry](https://github.com/open-telemetry)d'une spécification de télémétrie portable. À l'heure actuelle, App Runner prend en charge [AWS Distro for OpenTelemetry](https://aws-otel.github.io/docs/introduction) (ADOT), une OpenTelemetry implémentation qui collecte et présente des informations de télémétrie à l'aide de services. AWS X-Ray implémente le composant de traçage.

*Selon le SDK ADOT spécifique que vous utilisez dans votre application, ADOT prend en charge jusqu'à deux approches d'instrumentation : *automatique* et manuelle.* Pour plus d'informations sur l'instrumentation avec votre SDK, consultez la [documentation ADOT](https://aws-otel.github.io/docs/introduction) et choisissez votre SDK dans le volet de navigation.

### Configuration du moteur d'exécution
<a name="monitor-xray.instrument.setup"></a>

 Vous trouverez ci-dessous les instructions générales de configuration de l'exécution pour instrumenter votre application de service App Runner à des fins de traçage. 

**Pour configurer le suivi pour votre environnement d'exécution**

1.  Suivez les instructions fournies pour votre environnement d'exécution dans [AWS Distro for OpenTelemetry](https://aws-otel.github.io/docs/introduction) (ADOT) pour instrumenter votre application. 

1.  Installez les `OTEL` dépendances requises dans la `build` section du `apprunner.yaml` fichier si vous utilisez le référentiel de code source ou dans le Dockerfile si vous utilisez une image de conteneur. 

1.  Configurez vos variables d'environnement dans le `apprunner.yaml` fichier si vous utilisez le référentiel de code source ou dans le Dockerfile si vous utilisez une image de conteneur.   
**Example Variables d’environnement**  
**Note**  
L'exemple suivant répertorie les variables d'environnement importantes à ajouter au `apprunner.yaml` fichier. Ajoutez ces variables d'environnement à votre Dockerfile si vous utilisez une image de conteneur. Cependant, chaque environnement d'exécution peut avoir ses propres particularités et vous devrez peut-être ajouter d'autres variables d'environnement à la liste suivante. Pour plus d'informations sur les instructions spécifiques à votre environnement d'exécution et des exemples sur la façon de configurer votre application pour votre environnement d'exécution, consultez [AWS Distro for OpenTelemetry](https://aws-otel.github.io/docs/introduction) et accédez à votre environnement d'exécution, sous *Getting Started*. 

   ```
   env:
       - name: OTEL_PROPAGATORS
         value: xray
       - name: OTEL_METRICS_EXPORTER
         value: none
       - name: OTEL_EXPORTER_OTLP_ENDPOINT
         value: http://localhost:4317  
       - name: OTEL_RESOURCE_ATTRIBUTES
         value: 'service.name=example_app'
   ```
**Note**  
 `OTEL_METRICS_EXPORTER=none`est une variable d'environnement importante pour App Runner, car le collecteur App Runner Otel n'accepte pas l'enregistrement des métriques. Il n'accepte que le suivi des métriques. 

### Exemple de configuration d'exécution
<a name="monitor-xray.instrument.example"></a>

L'exemple suivant illustre l'instrumentation automatique de votre application avec le SDK [ADOT Python](https://aws-otel.github.io/docs/getting-started/python-sdk). Le SDK produit automatiquement des intervalles avec des données de télémétrie décrivant les valeurs utilisées par les frameworks Python dans votre application sans ajouter une seule ligne de code Python. Il suffit d'ajouter ou de modifier quelques lignes dans deux fichiers sources.

Ajoutez d'abord quelques dépendances, comme indiqué dans l'exemple suivant.

**Example requirements.txt**  

```
opentelemetry-distro[otlp]>=0.24b0
opentelemetry-sdk-extension-aws~=2.0
opentelemetry-propagator-aws-xray~=1.0
```

Ensuite, instrumentez votre application. La manière de procéder dépend de la source de votre service : image source ou code source.

------
#### [ Source image ]

Lorsque la source de votre service est une image, vous pouvez directement instrumenter le Dockerfile qui contrôle la création de votre image de conteneur et l'exécution de l'application dans l'image. L'exemple suivant montre un Dockerfile instrumenté pour une application Python. Les ajouts à l'instrumentation sont soulignés en gras.

**Example Dockerfile**  

```
FROM public.ecr.aws/amazonlinux/amazonlinux:latest
RUN yum install python3.7 -y && curl -O https://bootstrap.pypa.io/get-pip.py && python3 get-pip.py && yum update -y
COPY . /app
WORKDIR /app
RUN pip3 install -r requirements.txt
RUN opentelemetry-bootstrap --action=install
ENV OTEL_PYTHON_DISABLED_INSTRUMENTATIONS=urllib3
ENV OTEL_METRICS_EXPORTER=none              
ENV OTEL_RESOURCE_ATTRIBUTES='service.name=example_app'
CMD OTEL_PROPAGATORS=xray OTEL_PYTHON_ID_GENERATOR=xray opentelemetry-instrument python3 app.py
EXPOSE 8080
```

------
#### [ Source code repository ]

Lorsque votre source de service est un référentiel contenant la source de votre application, vous instrumentez indirectement votre image à l'aide des paramètres du fichier de configuration d'App Runner. Ces paramètres contrôlent le Dockerfile qu'App Runner génère et utilise pour créer l'image de votre application. L'exemple suivant montre un fichier de configuration App Runner instrumenté pour une application Python. Les ajouts à l'instrumentation sont soulignés en gras.

**Example apprunner.yaml**  

```
version: 1.0
runtime: python3 
build:
  commands:
    build:
      - pip install -r requirements.txt
      - opentelemetry-bootstrap --action=install
run: 
  command: opentelemetry-instrument python app.py
  network: 
    port: 8080 
  env:
    - name: OTEL_PROPAGATORS
      value: xray
    - name: OTEL_METRICS_EXPORTER
      value: none
    - name: OTEL_PYTHON_ID_GENERATOR
      value: xray  
    - name: OTEL_PYTHON_DISABLED_INSTRUMENTATIONS 
      value: urllib3
    - name: OTEL_RESOURCE_ATTRIBUTES
      value: 'service.name=example_app'
```

------

## Ajoutez des autorisations X-Ray à votre rôle d'instance de service App Runner
<a name="monitor-xray.role"></a>

Pour utiliser le traçage X-Ray avec votre service App Runner, vous devez fournir aux instances du service des autorisations leur permettant d'interagir avec le service X-Ray. Pour ce faire, associez un rôle d'instance à votre service et ajoutez une politique gérée avec des autorisations X-Ray. Pour plus d'informations sur un rôle d'instance App Runner, consultez[Rôle d’instance](security_iam_service-with-iam.md#security_iam_service-with-iam-roles-service.instance). Ajoutez la politique `AWSXRayDaemonWriteAccess` gérée à votre rôle d'instance et attribuez-la à votre service lors de sa création.

## Activez le suivi X-Ray pour votre service App Runner
<a name="monitor-xray.config"></a>

Lorsque vous [créez un service](manage-create.md), App Runner désactive le suivi par défaut. Vous pouvez activer le suivi X-Ray pour votre service dans le cadre de la configuration de l'observabilité. Pour de plus amples informations, veuillez consulter [Gérez l'observabilité](manage-configure-observability.md#manage-configure-observability.manage).

Si vous utilisez l'API App Runner ou le AWS CLI, l'[TraceConfiguration](https://docs.aws.amazon.com/apprunner/latest/api/API_TraceConfiguration.html)objet contenu dans l'objet de [ObservabilityConfiguration](https://docs.aws.amazon.com/apprunner/latest/api/API_ObservabilityConfiguration.html)ressource contient des paramètres de suivi. Pour que le traçage reste désactivé, ne spécifiez aucun `TraceConfiguration` objet.

Dans le cas de la console et de l'API, veillez à associer le rôle d'instance décrit dans la section précédente à votre service App Runner.

## Afficher les données de suivi X-Ray pour votre service App Runner
<a name="monitor-xray.view"></a>

Dans l'onglet **Observabilité** de la [page du tableau de bord des services](console.md#console.dashboard) de la console App Runner, choisissez **Afficher la carte des services** pour accéder à la CloudWatch console Amazon.

![\[Page du tableau de bord du service App Runner affichant l'onglet d'observabilité\]](http://docs.aws.amazon.com/fr_fr/apprunner/latest/dg/images/service-dashboad-observability.png)


Utilisez la CloudWatch console Amazon pour consulter les cartes des services et les traces des demandes traitées par votre application. Les cartes des services présentent des informations telles que la latence des demandes et les interactions avec d'autres applications et AWS services. Les annotations personnalisées que vous ajoutez à votre code vous permettent de rechercher facilement des traces. Pour plus d'informations, consultez la section [Utilisation ServiceLens pour surveiller l'état de santé de vos applications](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ServiceLens.html) dans le *guide de CloudWatch l'utilisateur Amazon*.