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.

# Configuration d'une application Web pour utiliser CloudWatch RUM
<a name="CloudWatch-RUM-get-started"></a>

Suivez les étapes décrites dans ces sections pour configurer votre application Web afin qu'elle commence à utiliser CloudWatch RUM pour collecter des données de performance à partir de sessions utilisateur réelles.

**Topics**
+ [Autorisez votre application Web à envoyer des données à AWS](CloudWatch-RUM-get-started-authorization.md)
+ [Création d'un moniteur d'application CloudWatch RUM pour une application Web](CloudWatch-RUM-get-started-create-app-monitor.md)
+ [Modification de l'extrait de code pour configurer le client Web CloudWatch RUM (facultatif)](CloudWatch-RUM-modify-snippet.md)
+ [Insertion de l'extrait de code du moniteur d' CloudWatch applications dans votre application](CloudWatch-RUM-get-started-insert-code-snippet.md)
+ [Tester la configuration de votre moniteur d' CloudWatch applications en générant des événements utilisateur](CloudWatch-RUM-get-started-generate-data.md)

# Autorisez votre application Web à envoyer des données à AWS
<a name="CloudWatch-RUM-get-started-authorization"></a>

Vous disposez de quatre options pour configurer l’authentification des données :
+ Utilisez Amazon Cognito et laissez CloudWatch RUM créer un nouveau pool d'identités Amazon Cognito pour l'application. Cette méthode est la plus simple à configurer.

  Le groupe d'identités contiendra une identité non authentifiée. Cela permet au client Web CloudWatch RUM d'envoyer des données à CloudWatch RUM sans authentifier l'utilisateur de l'application.

  Un rôle IAM est attaché au groupe d'identités Amazon Cognito. L'identité non authentifiée Amazon Cognito permet au client Web d'assumer le rôle IAM autorisé à envoyer des données à RUM. CloudWatch 
+ Utiliser Amazon Cognito pour l’authentification. Si vous utilisez cette option, vous pouvez utiliser un groupe d’identités Amazon Cognito existant ou en créer un nouveau pour ce moniteur d’application. Si vous utilisez un groupe d’identités existant, vous devez également modifier le rôle IAM attaché au groupe d’identités. Utilisez cette option pour les groupes d’identités qui prennent en charge les utilisateurs non authentifiés. Vous ne pouvez utiliser des groupes d’identités que depuis la même région.
+ Utilisez l'authentification d'un fournisseur d'identité existant que vous avez déjà configuré. Dans ce cas, vous devez obtenir des informations d'identification du fournisseur d'identité et votre application doit transférer ces informations d'identification au client web RUM.

  Utilisez cette option pour les groupes d’identités qui ne prennent en charge que les utilisateurs authentifiés.
+ Utiliser des politiques basées sur les ressources pour gérer l’accès à votre moniteur d’application. Cela inclut la possibilité d'envoyer des demandes non authentifiées à CloudWatch RUM sans AWS informations d'identification. Pour en savoir plus sur les politiques basées sur les ressources et RUM, consultez [Utilisation de politiques basées sur les ressources avec RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

Les sections suivantes contiennent plus de détails sur ces options.

## Utilisation d'un groupe d'identités Amazon Cognito existant
<a name="CloudWatch-RUM-get-started-authorization-existingcognito"></a>

Si vous choisissez d'utiliser un pool d'identités Amazon Cognito, vous devez le spécifier lorsque vous ajoutez l'application à CloudWatch RUM. Le groupe doit prendre en charge l'activation de l'accès à des identités non authentifiées. Vous ne pouvez utiliser des groupes d’identités que depuis la même région.

Vous devez également ajouter les autorisations suivantes à la stratégie IAM attachée au rôle IAM associé à ce groupe d'identités.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        { 
            "Effect": "Allow",
            "Action": [
                "rum:PutRumEvents"
            ],
            "Resource": "arn:aws:rum:us-east-1:123456789012:appmonitor/app monitor name" 
        }
    ]
}
```

------

Amazon Cognito enverra ensuite le jeton de sécurité nécessaire pour permettre à votre application d'accéder CloudWatch à RUM.

## Fournisseur tiers
<a name="CloudWatch-RUM-get-started-authorization-thirdparty"></a>

Si vous choisissez l'authentification privée d'un fournisseur tiers, vous devez obtenir des informations d'identification du fournisseur d'identité et les transférer à AWS. Le meilleur moyen d'y parvenir consiste à utiliser un *fournisseur de jetons de sécurité*. Vous pouvez utiliser n'importe quel fournisseur de jetons de sécurité, y compris Amazon Cognito avec. AWS Security Token Service Pour plus d'informations AWS STS, consultez la section [Welcome to the AWS Security Token Service API Reference](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html). 

Si vous souhaitez utiliser Amazon Cognito comme fournisseur de jetons dans ce scénario, vous pouvez configurer Amazon Cognito pour qu'il fonctionne avec un fournisseur d'authentification. Pour plus d'informations, consultez [Démarrez avec les groupes d'identités Amazon Cognito (identités fédérées)](https://docs.aws.amazon.com/cognito/latest/developerguide/getting-started-with-identity-pools.html).

Après avoir configuré Amazon Cognito pour qu'il fonctionne avec votre fournisseur d'identité, vous devez également effectuer les opérations suivantes :
+ Créez un rôle IAM avec les autorisations suivantes. Votre application utilisera ce rôle pour accéder à AWS.

------
#### [ JSON ]

****  

  ```
  { 
   "Version":"2012-10-17",		 	 	 
   "Statement": [ 
     { 
       "Effect": "Allow",
       "Action": "rum:PutRumEvents",
       "Resource": "arn:aws:rum:us-east-2:123456789012:appmonitor/AppMonitorName"
     }
   ]
  }
  ```

------
+ Ajoutez ce qui suit à votre application pour qu'elle transmette les informations d'identification de votre fournisseur à CloudWatch RUM. Insérez cette ligne pour qu'elle s'exécute après qu'un utilisateur s'est connecté à votre application et que celle-ci a reçu les informations d'identification à utiliser pour accéder à AWS.

  ```
  cwr('setAwsCredentials', {/* Credentials or CredentialProvider */});
  ```

[Pour plus d'informations sur les fournisseurs d'informations d'identification dans le AWS JavaScript SDK, voir [Configuration des informations d'identification dans un navigateur Web](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-browser.html) dans le guide du développeur v3 pour le SDK JavaScript, [Configuration des informations d'identification dans un navigateur Web dans](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials-browser.html) le guide du développeur v2 pour le SDK pour JavaScript, et @aws -sdk/credential-providers.](https://www.npmjs.com/package/@aws-sdk/credential-providers) 

Vous pouvez également utiliser le SDK du client Web CloudWatch RUM pour configurer les méthodes d'authentification du client Web. Pour plus d'informations sur le SDK du client Web, consultez la section SDK du [client Web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web). 

# Création d'un moniteur d'application CloudWatch RUM pour une application Web
<a name="CloudWatch-RUM-get-started-create-app-monitor"></a>

Pour commencer à utiliser CloudWatch RUM avec votre application, vous devez créer un *moniteur d'applications*. Lorsque le moniteur d'applications est créé, RUM génère un extrait de code que vous pouvez coller dans votre application. L'extrait extrait le code du client RUM. Le client RUM capture les données des sessions utilisateur de votre application et les envoie à RUM.

## Pour créer un moniteur d'applications pour une plateforme Web
<a name="web-platform-app-monitor"></a>

1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Dans le volet de navigation, sélectionnez **Vigie applicative**, puis **RUM**.

1. Choisissez **Add app monitor** (Ajouter un moniteur d'application).

1. Pour le **nom du moniteur d'application**, entrez un nom à utiliser pour identifier ce moniteur d'application dans la console CloudWatch RUM.

1. Sélectionnez **Web** comme plate-forme.

1. Pour **Liste des domaines d’application**, saisissez les noms de domaine enregistrés sur lesquels votre application dispose d’une autorité administrative. Vous pouvez également utiliser un caractère générique `*` pour autoriser les sous-domaines ou domaines de premier niveau (par exemple, \$1.amazon.com, amazon.\$1, \$1.amazon.\$1).

1. Pour **Configure RUM data collection** (Configurer la collecte des données RUM), indiquez si vous souhaitez que le moniteur d'application collecte chacun des éléments suivants :
   + **Performance telemetry** (Télémétrie de performance) : collecte des informations sur le chargement des pages et les temps de chargement des ressources.
   + **JavaScript erreurs** — Recueille des informations sur les JavaScript erreurs non gérées signalées par votre application

     Vous pouvez sélectionner **Unminify JavaScript error stack traces pour corriger les** erreurs non minimisées. JavaScript Pour utiliser cette fonctionnalité, chargez vos fichiers de sourçage dans un compartiment ou dossier Amazon S3, puis indiquez l’URI Amazon S3 correspondant. Une fois activé, RUM utilisera ces cartes sources et enrichira les événements JavaScript d'erreur en ajoutant la trace de pile non minimisée. Notez qu'une fois activée, cette fonctionnalité ne traite que les nouveaux événements JavaScript d'erreur et ne peut pas être utilisée sur des données collectées précédemment. Pour de plus amples informations, veuillez consulter [Activation de la minimisation des traces de pile JavaScript d'erreurs](CloudWatch-RUM-JavaScriptStackTraceSourceMaps.md).
   + **HTTP errors** (Erreurs HTTP) : collecte des informations sur les erreurs HTTP levées par votre application.

   La sélection de ces options fournit plus d'informations sur votre application, mais génère également davantage d'événements CloudWatch RUM et entraîne donc des frais supplémentaires.

   Si vous ne sélectionnez aucune de ces options, le moniteur de l'application collecte toujours les événements et les pages de démarrage de session IDs afin que vous puissiez voir combien d'utilisateurs utilisent votre application, y compris les ventilations par type et version de système d'exploitation, type et version de navigateur, type d'appareil et emplacement.

1. Sélectionnez **cette option pour autoriser le client Web CloudWatch RUM à définir des cookies** si vous souhaitez pouvoir collecter des utilisateurs IDs et des sessions à IDs partir d'échantillons de sessions utilisateur. Les utilisateurs IDs sont générés aléatoirement par RUM. Pour de plus amples informations, veuillez consulter [CloudWatch Cookies du client Web RUM (ou technologies similaires)](CloudWatch-RUM-privacy.md#CloudWatch-RUM-cookies).

1. Pour **Session samples** (Exemples de session), saisissez le pourcentage de sessions utilisateur qui seront utilisées pour collecter des données RUM. La valeur par défaut est 100 %. Si vous réduisez cette valeur, vous obtiendrez moins de données, mais vos frais seront réduits. Pour plus d'informations sur la tarification RUM, consultez [Tarification RUM](CloudWatch-RUM.md#RUMpricing).

1. Les données d'utilisateur final que vous collectez pour CloudWatch RUM sont conservées pendant 30 jours, puis supprimées. Si vous souhaitez conserver des copies des événements RUM dans les CloudWatch journaux et configurer la durée de conservation de ces copies, choisissez **Cocher cette option pour stocker les données de télémétrie de votre application dans votre compte CloudWatch Logs** sous Stockage **des données**. Par défaut, le groupe de CloudWatch journaux Logs conserve les données pendant 30 jours. Vous pouvez ajuster la période de conservation dans la console CloudWatch Logs.

1. (Facultatif) Ajoutez une politique basée sur les ressources à votre moniteur d’application pour contrôler qui peut envoyer des requêtes `PutRumEvents` à votre moniteur. Si vous sélectionnez **Créer une politique publique**, une politique de ressources sera attachée à votre moniteur d’application, ce qui permettra à n’importe qui d’envoyer des requêtes `PutRumEvents` à votre moniteur. Pour plus d’informations sur cette méthode, consultez [Utilisation de politiques basées sur les ressources avec RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

1. Si vous avez joint une politique basée sur les ressources à l'étape précédente, vous n'avez pas besoin de signer les demandes adressées à CloudWatch RUM avec des AWS informations d'identification et vous pouvez ignorer la configuration de l'autorisation. Sinon, pour **Autorisation**, indiquez si vous souhaitez utiliser un nouvel groupe d’identités Amazon Cognito, un groupe existant, ou un autre fournisseur d’identité. La création d'un nouveau groupe d'identités est l'option la plus simple et ne nécessite aucune autre étape de configuration. Pour plus d’informations, consultez [Autorisez votre application Web à envoyer des données à AWS](CloudWatch-RUM-get-started-authorization.md).

   La création d'un nouveau groupe d'identités Amazon Cognito nécessite des autorisations administratives. Pour de plus amples informations, veuillez consulter [Politiques IAM pour utiliser RUM CloudWatch](CloudWatch-RUM-permissions.md).

1. (Facultatif) Par défaut, lorsque vous ajoutez l'extrait de code RUM à votre application, le client Web injecte la JavaScript balise pour surveiller l'utilisation dans le code HTML de toutes les pages de votre application. Pour modifier ce comportement, choisissez **Configure pages** (Configurer les pages), puis choisissez **Include only these pages** (Inclure uniquement ces pages) ou **Exclude these pages** (Exclure ces pages). Ensuite, spécifiez les pages à inclure ou à exclure. Pour spécifier une page à inclure ou à exclure, saisissez-la complète URLs. Pour spécifier des pages supplémentaires, choisissez **Add URL** (Ajouter une URL).

1. Pour activer le AWS X-Ray suivi des sessions utilisateur échantillonnées par le moniteur de l'application, choisissez **Suivi actif**, puis sélectionnez **Tracer mon service avec AWS X-Ray**.

   Si vous sélectionnez cette option, les demandes `XMLHttpRequest` et `fetch` effectuées pendant les sessions utilisateur échantillonnées par le moniteur d'application sont suivies. Vous pouvez ensuite voir les suivis et les segments de ces sessions utilisateur dans le tableau de bord RUM, ainsi que sur les pages de la carte de suivi X-Ray et de détails des suivis X-Ray. Ces sessions utilisateur apparaîtront également sous forme de pages client dans [Application Signals](CloudWatch-Application-Monitoring-Sections.md) une fois que vous les aurez activées pour votre application.

   En apportant des modifications de configuration supplémentaires au client Web CloudWatch RUM, vous pouvez ajouter un en-tête de trace X-Ray aux requêtes HTTP afin de permettre le end-to-end suivi des sessions utilisateur jusqu'aux services AWS gérés en aval. Pour de plus amples informations, veuillez consulter [Activation du end-to-end traçage par rayons X](CloudWatch-RUM-modify-snippet.md#CloudWatch-RUM-xraytraceheader).

1. (Facultatif) Pour ajouter des identifications au moniteur d'application, choisissez**Tags** (Identifications), **Add new tag** (Ajouter une nouvelle identification).

   Ensuite, pour **Key** (Clé), saisissez un nom pour l'identification. Vous pouvez ajouter une valeur en option pour la balise dans **Value (Valeur)**. 

   Pour ajouter une autre étiquette, sélectionnez à nouveau **Add new tag (Ajouter une nouvelle étiquette)**.

   Pour plus d'informations, consultez [Identification des ressources  AWS](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).

1. Choisissez **Add app monitor** (Ajouter un moniteur d'application).

1. Dans la section **Sample code** (Exemple de code), vous pouvez copier l'extrait de code à utiliser pour ajouter à votre application. Nous vous recommandons de choisir **JavaScript**ou **TypeScript**d'utiliser NPM pour installer le client Web CloudWatch RUM en tant que JavaScript module.

   Vous pouvez également choisir le **format HTML** pour utiliser un réseau de diffusion de contenu (CDN) afin d'installer le client Web CloudWatch RUM. L'inconvénient de l'utilisation d'un CDN est que le client web est souvent bloqué par des bloqueurs de publicités.

1. Choisissez **Copy** (Copier) ou **Download** (Télécharger), puis **Done** (Terminé).

# Modification de l'extrait de code pour configurer le client Web CloudWatch RUM (facultatif)
<a name="CloudWatch-RUM-modify-snippet"></a>

Vous pouvez modifier l'extrait de code avant de l'insérer dans votre application, pour activer ou désactiver plusieurs options. Pour plus d'informations, consultez la [documentation du client Web CloudWatch RUM.](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md)

Quatre options de configuration importantes sont à connaître, comme expliqué dans les sections suivantes.

## Empêcher la collecte de ressources URLs susceptibles de contenir des informations personnelles
<a name="CloudWatch-RUM-resourceURL"></a>

Par défaut, le client Web CloudWatch RUM est configuré pour enregistrer URLs les ressources téléchargées par l'application. Ces ressources incluent des fichiers HTML, des images, des JavaScript fichiers CSS, des fichiers, etc. Certaines applications URLs peuvent contenir des informations personnelles identifiables (PII).

Si tel est le cas pour votre application, nous vous recommandons vivement de désactiver la collecte de ressources `recordResourceUrl: false` en URLs définissant la configuration de l'extrait de code, avant de l'insérer dans votre application.

## Enregistrement manuel des consultations de page
<a name="CloudWatch-RUM-pageload"></a>

Par défaut, le client web enregistre les consultations de page lorsque la page se charge pour la première fois et lorsque l'API d'historique du navigateur est appelée. L'ID de page par défaut est `window.location.pathname`. Toutefois, dans certains cas, vous devrez peut-être remplacer ce comportement et utiliser l'application pour qu'elle enregistre les consultations de page par programmation. Cela vous permet de contrôler l'ID de page et le moment où il est enregistré. Prenons l'exemple d'une application Web dotée d'un URI avec un identifiant variable, tel que `/entity/123` ou `/entity/456`. Par défaut, CloudWatch RUM génère un événement d'affichage de page pour chaque URI avec un ID de page distinct correspondant au nom du chemin, mais vous pouvez plutôt les regrouper par le même identifiant de page. Pour ce faire, désactivez l'automatisation de la consultation de page du client Web à l'aide de la configuration `disableAutoPageView`, puis utilisez la commande `recordPageView` pour définir l'ID de page souhaité. Pour plus d'informations, consultez la section [Configurations spécifiques à l'application sur](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md). GitHub

**Exemple de script intégré :**

```
cwr('recordPageView', { pageId: 'entityPageId' });
```

**JavaScript exemple de module :**

```
awsRum.recordPageView({ pageId: 'entityPageId' });
```

## Activation du end-to-end traçage par rayons X
<a name="CloudWatch-RUM-xraytraceheader"></a>

Lorsque vous créez le moniteur d'application, sélectionnez **Trace my service with AWS X-Ray** (Suivre mon service avec ) pour activer le suivi des demandes `XMLHttpRequest` et `fetch` effectuées pendant les sessions utilisateur échantillonnées par le moniteur d'application. Vous pouvez ensuite voir les traces de ces requêtes HTTP dans le tableau de bord CloudWatch RUM, ainsi que sur les pages de détails de X-Ray Trace Map et Trace.

Par défaut, ces suivis côté client ne sont pas connectés à des suivis côté serveur en aval. Pour connecter les traces côté client aux traces côté serveur et activer le end-to-end suivi, définissez l'`addXRayTraceIdHeader`option sur `true` dans le client Web. Cela oblige le client Web CloudWatch RUM à ajouter un en-tête de trace X-Ray aux requêtes HTTP.

Le bloc de code suivant présente un exemple d'ajout de suivis côté client. Certaines options de configuration sont omises de cet exemple pour des raisons de lisibilité.

```
<script>
    (function(n,i,v,r,s,c,u,x,z){...})(
        'cwr',
        '00000000-0000-0000-0000-000000000000',
        '1.0.0',
        'us-west-2',
        'https://client.rum.us-east-1.amazonaws.com/1.0.2/cwr.js',
        {
            enableXRay: true,
            telemetries: [ 
                'errors', 
                'performance',
                [ 'http', { addXRayTraceIdHeader: true } ]
            ]
        }
    );
</script>
```

**Avertissement**  
La configuration du client Web CloudWatch RUM pour ajouter un en-tête de trace X-Ray aux requêtes HTTP peut entraîner l'échec du partage de ressources entre origines (CORS) ou l'invalidation de la signature de la demande si celle-ci est signée avec SigV4. Pour plus d'informations, consultez la [documentation du client Web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md). Nous vous recommandons fortement de tester votre application avant d'ajouter un en-tête de suivi X-Ray côté client dans un environnement de production.

Pour plus d'informations, consultez la [documentation du client Web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md#http)

## Envoi de demandes non signées à RUM CloudWatch
<a name="CloudWatch-RUM-unsigned"></a>

Par défaut, le client web RUM signe toutes les requêtes envoyées à RUM. Si vous définissez `signing:false` la configuration du client, les demandes ne seront pas signées lorsqu'elles seront envoyées à CloudWatch RUM. Les données ne seront ingérées dans RUM que si une stratégie publique basée sur les ressources est associée au moniteur d’application. Pour de plus amples informations, veuillez consulter [Utilisation de politiques basées sur les ressources avec RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

# Insertion de l'extrait de code du moniteur d' CloudWatch applications dans votre application
<a name="CloudWatch-RUM-get-started-insert-code-snippet"></a>

Ensuite, vous devez insérer dans votre application l'extrait de code que vous avez créé dans la section précédente.

**Avertissement**  
Le client web, téléchargé et configuré par l'extrait de code, utilise des cookies (ou des technologies semblables) pour vous aider à collecter les données des utilisateurs finaux. Avant d'insérer l'extrait de code, consultez [Filtrage par attributs de métadonnées dans la consoleProtection et confidentialité des données avec CloudWatch RUM](CloudWatch-RUM-privacy.md).

Si vous n'avez pas l'extrait de code précédemment généré, vous pouvez le trouver en suivant les instructions dans [Comment puis-je trouver un extrait de code que j'ai déjà généré ?](CloudWatch-RUM-find-code-snippet.md).

**Pour insérer l'extrait de code CloudWatch RUM dans votre application**

1. Insérez l'extrait de code que vous avez copié ou téléchargé dans la section précédente dans l'élément `<head>` de votre application. Insérez-le avant l'élément `<body>` ou toute autre identification `<script>`.

   L'extrait suivant représente un exemple d'extrait de code généré :

   ```
   <script>
   (function (n, i, v, r, s, c, x, z) {
       x = window.AwsRumClient = {q: [], n: n, i: i, v: v, r: r, c: c};
       window[n] = function (c, p) {
           x.q.push({c: c, p: p});
       };
       z = document.createElement('script');
       z.async = true;
       z.src = s;
       document.head.insertBefore(z, document.getElementsByTagName('script')[0]);
   })('cwr',
       '194a1c89-87d8-41a3-9d1b-5c5cd3dafbd0',
       '1.0.0',
       'us-east-2',
       'https://client.rum.us-east-1.amazonaws.com/1.0.2/cwr.js',
       {
           sessionSampleRate: 1,
           identityPoolId: "us-east-2:c90ef0ac-e3b8-4d1a-b313-7e73cfd21443",
           endpoint: "https://dataplane.rum.us-east-2.amazonaws.com",
           telemetries: ["performance", "errors", "http"],
           allowCookies: true,
           enableXRay: false
       });
   </script>
   ```

1. Si votre application est une application web multipage, vous devez répéter l'étape 1 pour chaque page HTML que vous souhaitez inclure dans la collecte de données.

# Tester la configuration de votre moniteur d' CloudWatch applications en générant des événements utilisateur
<a name="CloudWatch-RUM-get-started-generate-data"></a>

Une fois que vous avez inséré l'extrait de code et que votre application mise à jour est en cours d'exécution, vous pouvez effectuer un test en générant manuellement des événements utilisateur. Pour ce test, nous vous recommandons d'effectuer les opérations suivantes. Ce test entraîne des frais de CloudWatch RUM standard.
+ Parcourez les pages de votre application web.
+ Créez plusieurs sessions utilisateur à l'aide de différents navigateurs et appareils.
+ Envoyez de demandes.
+  JavaScript Provoquer des erreurs.

Après avoir généré certains événements, visualisez-les dans le tableau de bord CloudWatch RUM. Pour de plus amples informations, veuillez consulter [Consulter le tableau de bord CloudWatch du RUM](CloudWatch-RUM-view-data.md).

L'affichage des données des sessions utilisateur dans le tableau de bord peut prendre jusqu'à 15 minutes.

Si vous ne voyez pas de données 15 minutes après avoir généré des événements dans l'application, reportez-vous à la section [Résolution des problèmes liés CloudWatch à](CloudWatch-RUM-troubleshooting.md).