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à.

# Configura un'applicazione web per usare CloudWatch RUM
<a name="CloudWatch-RUM-get-started"></a>

Utilizzate i passaggi riportati in queste sezioni per configurare l'applicazione Web e iniziare a utilizzare CloudWatch RUM per raccogliere dati sulle prestazioni da sessioni utente reali.

**Topics**
+ [Autorizza la tua applicazione web a inviare dati a AWS](CloudWatch-RUM-get-started-authorization.md)
+ [Creazione di un monitor di app CloudWatch RUM per un'applicazione web](CloudWatch-RUM-get-started-create-app-monitor.md)
+ [Modifica dello snippet di codice per configurare il client web CloudWatch RUM (opzionale)](CloudWatch-RUM-modify-snippet.md)
+ [Inserimento dello snippet di codice del monitor CloudWatch dell'app nell'applicazione](CloudWatch-RUM-get-started-insert-code-snippet.md)
+ [Verifica della configurazione del monitor CloudWatch dell'app generando eventi utente](CloudWatch-RUM-get-started-generate-data.md)

# Autorizza la tua applicazione web a inviare dati a AWS
<a name="CloudWatch-RUM-get-started-authorization"></a>

Sono disponibili quattro opzioni per impostare l'autenticazione dei dati:
+ Usa Amazon Cognito e consenti a CloudWatch RUM di creare un nuovo pool di identità Amazon Cognito per l'applicazione. Questo metodo richiede il minimo sforzo per la configurazione.

  Il pool di identità conterrà un'identità non autenticata. Ciò consente al client web CloudWatch RUM di inviare dati a CloudWatch RUM senza autenticare l'utente dell'applicazione.

  Il pool di identità di Amazon Cognito ha un ruolo IAM associato. L'identità non autenticata di Amazon Cognito consente al client Web di assumere il ruolo IAM autorizzato a inviare dati a RUM. CloudWatch 
+ Utilizzare Amazon Cognito per l'autenticazione. In questo modo, puoi impiegare un pool di identità di Amazon Cognito esistente o crearne uno nuovo da utilizzare con questo monitor dell'app. Se utilizzi un pool di identità esistente, è anche necessario modificare il ruolo IAM associato al pool di identità. Utilizza questa opzione per i pool di identità che supportano utenti non autenticati. Puoi utilizzare i pool di identità solo dalla stessa Regione.
+ Utilizzare l'autenticazione da un provider di identità esistente già configurato. In questo caso, è necessario ottenere le credenziali dal provider di identità e l'applicazione deve inoltrare queste credenziali al client Web RUM.

  Utilizza questa opzione per i pool di identità che supportano solo utenti autenticati.
+ Utilizzare le policy basate su risorse per gestire l'accesso al monitor dell'app. Ciò include la possibilità di inviare richieste non autenticate a RUM senza credenziali. CloudWatch AWS Per ulteriori informazioni sulle policy basate su risorse e RUM, consulta [Utilizzo di politiche basate sulle risorse con RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

Le seguenti sezioni includono maggiori dettagli su queste opzioni.

## Utilizzare un pool di identità Amazon Cognito esistente
<a name="CloudWatch-RUM-get-started-authorization-existingcognito"></a>

Se scegli di utilizzare un pool di identità Amazon Cognito, specifichi il pool di identità quando aggiungi l'applicazione a CloudWatch RUM. Il pool deve supportare l'abilitazione dell'accesso a identità non autenticate. Puoi utilizzare i pool di identità solo dalla stessa Regione.

È inoltre necessario aggiungere le seguenti autorizzazioni alla policy IAM associata al ruolo IAM associato a questo pool di identità.

------
#### [ 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 invierà quindi il token di sicurezza necessario per consentire all'applicazione di accedere CloudWatch a RUM.

## Fornitore di terza parte
<a name="CloudWatch-RUM-get-started-authorization-thirdparty"></a>

Se si sceglie l'autenticazione privata da un provider di terze parti, è necessario ottenere le credenziali dal provider di identità e inoltrarle a AWS. Il modo migliore per eseguire questa operazione è possibile utilizzare un *fornitore di token di sicurezza*. Puoi utilizzare qualsiasi fornitore di token di sicurezza, incluso Amazon Cognito AWS Security Token Service con. Per ulteriori informazioni su AWS STS, consulta [Welcome to the AWS Security Token Service API](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html) Reference. 

Se si desidera utilizzare Amazon Cognito come fornitore di token in questo scenario, è possibile configurare Amazon Cognito in modo che funzioni con un provider di autenticazione. Per maggiori informazioni, consulta [Nozioni di base sui pool di identità di Amazon Cognito (identità federate)](https://docs.aws.amazon.com/cognito/latest/developerguide/getting-started-with-identity-pools.html)

Dopo aver configurato Amazon Cognito per lavorare con il proprio provider di identità, è necessario anche fare quanto segue:
+ Creare un ruolo IAM con le seguenti autorizzazioni. L'applicazione utilizzerà questo ruolo per accedere a AWS.

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

****  

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

------
+ Aggiungi quanto segue alla tua applicazione per farla passare le credenziali dal tuo provider a CloudWatch RUM. Inserire la riga in modo che venga eseguita dopo che un utente ha effettuato l'accesso all'applicazione e l'applicazione ha ricevuto le credenziali da utilizzare per accedere a AWS.

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

[Per ulteriori informazioni sui provider di credenziali nell' AWS JavaScript SDK, consulta [Impostazione delle credenziali in un browser Web nella](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-browser.html) guida per sviluppatori v3 per SDK per JavaScript, [Impostazione delle credenziali in un browser Web nella](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-credentials-browser.html) guida per sviluppatori v2 per SDK per e @aws -sdk/credential-providers. JavaScript](https://www.npmjs.com/package/@aws-sdk/credential-providers) 

Puoi anche utilizzare l'SDK per il client Web RUM per configurare i metodi di autenticazione del client Web. CloudWatch Per ulteriori informazioni sul web client SDK, consulta [CloudWatch RUM web client](https://github.com/aws-observability/aws-rum-web) SDK. 

# Creazione di un monitor di app CloudWatch RUM per un'applicazione web
<a name="CloudWatch-RUM-get-started-create-app-monitor"></a>

Per iniziare a utilizzare CloudWatch RUM con la tua applicazione, devi creare un *app monitor*. Quando viene creato l'app monitor, RUM genera un frammento di codice da incollare nell'applicazione. Lo snippet inserisce il codice client RUM. Il client RUM acquisisce i dati dalle sessioni utente dell'applicazione e li invia a RUM.

## Per creare un app monitor per una piattaforma web
<a name="web-platform-app-monitor"></a>

1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Nel riquadro di navigazione, scegli **Application Signals**, **RUM**.

1. Scegli **Aggiungere un monitor app**.

1. Per **il nome del monitor dell'app**, inserisci un nome da utilizzare per identificare questo app monitor all'interno della console CloudWatch RUM.

1. Seleziona **Web** come piattaforma.

1. Per **Elenco dominio applicazione**, inserire i nomi di dominio registrati in cui l'applicazione dispone dell'autorità amministrativa. Puoi anche utilizzare un carattere jolly `*` per consentire qualsiasi sottodominio o dominio di primo livello (ad esempio, \$1.amazon.com, amazon.\$1 o \$1.amazon.\$1).

1. Per **Configurazione della raccolta dei dati**, specificare se si desidera che il monitor dell'app raccolga ciascuno dei seguenti elementi:
   + **Telemetria delle prestazioni**— Raccoglie informazioni sul caricamento della pagina e sui tempi di caricamento delle risorse
   + **JavaScript errori**: raccoglie informazioni sugli JavaScript errori non gestiti generati dall'applicazione

     È possibile selezionare **Unminify JavaScript error stack trace per eseguire il debug degli errori** non minimizzati. JavaScript Per utilizzare questa funzionalità, carica i file delle mappe di origine in un bucket o in una cartella Amazon S3 e fornisci l'URI Amazon S3. Una volta abilitata, RUM utilizzerà queste mappe di origine e arricchirà gli eventi di JavaScript errore aggiungendo lo stack trace non minimizzato. Nota che, dopo l'attivazione, questa funzionalità elabora solo nuovi eventi di JavaScript errore e non può essere utilizzata su dati raccolti in precedenza. Per ulteriori informazioni, consulta [Abilitazione della riduzione delle tracce dello stack di JavaScript errori](CloudWatch-RUM-JavaScriptStackTraceSourceMaps.md).
   + **Errori HTTP**— Raccoglie informazioni sugli errori HTTP generati dall'applicazione

   La selezione di queste opzioni fornisce ulteriori informazioni sull'applicazione, ma genera anche più eventi CloudWatch RUM e quindi comporta costi aggiuntivi.

   Se non selezioni nessuna di queste opzioni, l'app monitor raccoglie comunque gli eventi e la pagina di inizio della sessione IDs in modo da poter vedere quanti utenti stanno utilizzando l'applicazione, comprese le suddivisioni per tipo e versione del sistema operativo, tipo e versione del browser, tipo di dispositivo e posizione.

1. Seleziona **Seleziona questa opzione per consentire al CloudWatch RUM Web Client di impostare i cookie** se desideri poter raccogliere utenti IDs e sessioni IDs da sessioni utente campionate. Gli utenti IDs vengono generati casualmente da RUM. Per ulteriori informazioni, consulta [CloudWatch Cookie del client web RUM (o tecnologie simili)](CloudWatch-RUM-privacy.md#CloudWatch-RUM-cookies).

1. Per **Esempi di sessione**, inserire la percentuale di sessioni utente che verranno utilizzate per raccogliere i dati RUM. Il valore di default è 100%. La riduzione di questo numero consente di ottenere meno dati, ma riduce i costi. Per ulteriori informazioni sui prezzi di RUM, consulta [Prezzi di RUM](CloudWatch-RUM.md#RUMpricing).

1. I dati degli utenti finali raccolti per CloudWatch RUM vengono conservati per 30 giorni e quindi eliminati. **Se desideri conservare copie degli eventi RUM nei CloudWatch registri e configurare per quanto tempo conservare tali copie, scegli **Seleziona questa opzione per memorizzare i dati di telemetria dell'applicazione nel tuo account CloudWatch Logs in Archiviazione dati**.** Per impostazione predefinita, il gruppo di CloudWatch log Logs conserva i dati per 30 giorni. È possibile modificare il periodo di conservazione nella console CloudWatch Logs.

1. (Facoltativo) Scegli di aggiungere una policy basata sulle risorse al monitor dell'app per controllare chi può inviare richieste `PutRumEvents` al monitor stesso. Se scegli **Crea policy pubblica**, al monitor dell'app verrà allegata una policy relativa alle risorse che consente a chiunque di inviare richieste `PutRumEvents` al monitor stesso. Per ulteriori informazioni su questo metodo, consulta [Utilizzo di politiche basate sulle risorse con RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

1. Se hai allegato una politica basata sulle risorse nel passaggio precedente, non è necessario firmare le richieste a CloudWatch RUM con le AWS credenziali e puoi saltare la configurazione dell'autorizzazione. Altrimenti, per **Autorizzazione**, specifica se utilizzare un pool di identità Amazon Cognito nuovo o esistente o utilizzare un provider di identità diverso. La creazione di un nuovo pool di identità è l'opzione più semplice che non richiede altri passaggi di configurazione. Per ulteriori informazioni, consultare le [Autorizza la tua applicazione web a inviare dati a AWS](CloudWatch-RUM-get-started-authorization.md).

   La creazione di un nuovo pool di identità Amazon Cognito richiede autorizzazioni amministrative. Per ulteriori informazioni, consulta [Politiche IAM per l'utilizzo di RUM CloudWatch](CloudWatch-RUM-permissions.md).

1. (Facoltativo) Per impostazione predefinita, quando aggiungete lo snippet di codice RUM all'applicazione, il client Web inserisce il JavaScript tag per monitorare l'utilizzo nel codice HTML di tutte le pagine dell'applicazione. Per modificarlo, scegli **Configura le pagine** e poi scegli tra **Includi solo queste pagine** o **Escludi queste pagine**. Quindi, specificare le pagine da includere o escludere. Per specificare una pagina da includere o escludere, inserite la pagina completa. URLs Per specificare pagine aggiuntive, scegli **Aggiungi URL**.

1. Per abilitare il AWS X-Ray tracciamento delle sessioni utente campionate dall'app monitor, scegli **Tracciamento attivo** e seleziona **Trace my** service with. AWS X-Ray

   Se si seleziona questo,`XMLHttpRequest` e `fetch` vengono tracciate le richieste effettuate durante le sessioni utente campionate dal monitor dell'app. È quindi possibile visualizzare tracce e segmenti di queste sessioni utente nel pannello di controllo RUM, dalla mappa di tracciamento X-Ray e dalle pagine dei dettagli della traccia. Queste sessioni utente verranno visualizzate anche come pagine client in [Application Signals](CloudWatch-Application-Monitoring-Sections.md) dopo che l'avrai abilitata per la tua applicazione.

   Apportando ulteriori modifiche alla configurazione del client Web CloudWatch RUM, è possibile aggiungere un'intestazione di traccia X-Ray alle richieste HTTP per consentire il end-to-end tracciamento delle sessioni utente fino ai servizi gestiti a valle. AWS Per ulteriori informazioni, consulta [Abilitazione del tracciamento X-Ray end-to-end](CloudWatch-RUM-modify-snippet.md#CloudWatch-RUM-xraytraceheader).

1. (Facoltativo) Per aggiungere tag al monitor dell'app, seleziona **Tag**, **Aggiungi nuovo tag**.

   Poi, per **Chiave**, inserire un nome per il tag. È possibile aggiungere un valore facoltativo al tag in **Value** (Valore). 

   Per aggiungere un altro tag, scegli nuovamente **Add tag** (Aggiungi tag).

   Per ulteriori informazioni, consulta [Assegnazione di tag alle risorse AWS](https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html).

1. Scegliere **Aggiungere un monitor app**.

1. Nella sezione **Sample code** (Codice di esempio), puoi copiare lo snippet di codice da aggiungere alla tua applicazione. Ti consigliamo di scegliere **JavaScript**o **TypeScript**utilizzare NPM per installare il client web CloudWatch RUM come modulo. JavaScript

   In alternativa, puoi scegliere **HTML** per utilizzare una rete di distribuzione dei contenuti (CDN) per installare il client web CloudWatch RUM. Lo svantaggio dell'utilizzo di una CDN è che il client Web viene spesso bloccato dalle estensioni di blocco degli annunci pubblicitari.

1. Scegli **Copy** (Copia) o **Download** (Scarica), quindi scegli **Done** (Fatto).

# Modifica dello snippet di codice per configurare il client web CloudWatch RUM (opzionale)
<a name="CloudWatch-RUM-modify-snippet"></a>

È possibile modificare lo snippet di codice prima di inserirlo nell'applicazione, per attivare o disattivare diverse opzioni. Per ulteriori informazioni, consulta la documentazione del client [web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md).

Ci sono quattro opzioni di configurazione di cui si deve assolutamente essere a conoscenza, come discusso in queste sezioni.

## Impedire la raccolta di risorse URLs che potrebbero contenere informazioni personali
<a name="CloudWatch-RUM-resourceURL"></a>

Per impostazione predefinita, il client web CloudWatch RUM è configurato per registrare le URLs risorse scaricate dall'applicazione. Queste risorse includono file HTML, immagini, file CSS, JavaScript file e così via. Per alcune applicazioni, URLs può contenere informazioni di identificazione personale (PII).

Se questo è il caso della tua applicazione, ti consigliamo vivamente di disabilitare la raccolta di risorse URLs impostando la configurazione dello snippet di codice, prima di inserirla `recordResourceUrl: false` nell'applicazione.

## Registrazione manuale delle visualizzazioni di pagina
<a name="CloudWatch-RUM-pageload"></a>

Per impostazione predefinita, il client Web registra le visualizzazioni di pagina quando la pagina viene caricata per la prima volta e quando viene chiamata l'API della cronologia del browser. L'ID di pagina predefinito è `window.location.pathname`. Tuttavia, in alcuni casi potresti voler ignorare questo comportamento e utilizzare l'applicazione per registrare le visualizzazioni di pagina a livello di codice. In questo modo potrai controllare l'ID della pagina e quando viene registrata. Ad esempio, si consideri un'applicazione Web che dispone di un URI con un identificatore variabile, ad esempio `/entity/123` o`/entity/456`. Per impostazione predefinita, CloudWatch RUM genera un evento di visualizzazione della pagina per ogni URI con un ID di pagina distinto che corrisponde al percorso, ma potresti preferire raggrupparli in base allo stesso ID di pagina. A tale scopo, disabilita l'automazione della visualizzazione delle pagine del client Web utilizzando la configurazione `disableAutoPageView` e utilizza il comando `recordPageView` per impostare l'ID di pagina desiderato. Per ulteriori informazioni, vedere [Configurazioni specifiche dell'applicazione su](https://github.com/aws-observability/aws-rum-web/blob/main/docs/configuration.md). GitHub

**Esempio di script incorporato:**

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

**JavaScript esempio di modulo:**

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

## Abilitazione del tracciamento X-Ray end-to-end
<a name="CloudWatch-RUM-xraytraceheader"></a>

Quando si crea il monitor dell'app, selezionando **Traccia il mio servizio con AWS X-Ray** consente il tracciamento di richieste `XMLHttpRequest` e `fetch` effettuate durante le sessioni utente che vengono campionate dal monitor dell'app. È quindi possibile visualizzare le tracce di queste richieste HTTP nella dashboard CloudWatch RUM e nelle pagine X-Ray Trace Map e Trace details.

Per impostazione predefinita, queste tracce lato client non sono collegate a tracce lato server a valle. Per connettere le tracce lato client alle tracce lato server e abilitare la end-to-end traccia, imposta l'`addXRayTraceIdHeader`opzione su Nel client Web. `true` Questo fa sì che il client web CloudWatch RUM aggiunga un'intestazione di traccia X-Ray alle richieste HTTP.

Il seguente blocco di codice mostra un esempio di aggiunta di tracce lato client. Alcune opzioni di configurazione vengono omesse da questo esempio per la leggibilità.

```
<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>
```

**avvertimento**  
La configurazione del client web CloudWatch RUM per aggiungere un'intestazione di traccia X-Ray alle richieste HTTP può causare il fallimento della condivisione delle risorse tra le origini (CORS) o invalidare la firma della richiesta se la richiesta è firmata con SigV4. [Per ulteriori informazioni, consulta la documentazione del client web RUM. CloudWatch ](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md) Si consiglia vivamente di testare l'applicazione prima di aggiungere un'intestazione di traccia X-Ray lato client in un ambiente di produzione.

Per ulteriori informazioni, consulta la [documentazione del client web CloudWatch RUM](https://github.com/aws-observability/aws-rum-web/blob/main/docs/cdn_installation.md#http)

## Invio di richieste non firmate a RUM CloudWatch
<a name="CloudWatch-RUM-unsigned"></a>

Per impostazione predefinita, il client web RUM firma tutte le richieste inviate a RUM. Se lo impostate `signing:false` nella configurazione del client, le richieste non saranno firmate quando verranno inviate a CloudWatch RUM. I dati verranno importati in RUM solo se al monitor dell'app è allegata una policy basata su risorse pubbliche. Per ulteriori informazioni, consulta [Utilizzo di politiche basate sulle risorse con RUM CloudWatch](CloudWatch-RUM-resource-policies.md).

# Inserimento dello snippet di codice del monitor CloudWatch dell'app nell'applicazione
<a name="CloudWatch-RUM-get-started-insert-code-snippet"></a>

Successivamente, inserire lo snippet di codice creato nella sezione precedente nell'applicazione.

**avvertimento**  
Il client web, scaricato e configurato dallo snippet di codice, utilizza cookie (o tecnologie simili) per aiutare a raccogliere i dati dell'utente finale. Prima di inserire lo snippet di codice, vedere [Filtraggio in base agli attributi dei metadati nella consoleProtezione e riservatezza dei dati con RUM CloudWatch](CloudWatch-RUM-privacy.md).

Se non si dispone dello snippet di codice generato in precedenza, è possibile trovarlo seguendo le istruzioni in [Come faccio a trovare uno snippet di codice che ho già generato?](CloudWatch-RUM-find-code-snippet.md).

**Per inserire lo snippet di codice CloudWatch RUM nell'applicazione**

1. Inserire lo snippet di codice copiato o scaricato nella sezione precedente all'interno dell'elemento `<head>` della propria applicazione. Inserirlo prima dell'elemento `<body>` o qualsiasi altro tag `<script>`.

   Il seguente è un esempio di uno snippet di codice generato:

   ```
   <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. Se l'applicazione è un'applicazione Web multipagina, è necessario ripetere il passaggio 1 per ogni pagina HTML che si desidera includere nella raccolta dati.

# Verifica della configurazione del monitor CloudWatch dell'app generando eventi utente
<a name="CloudWatch-RUM-get-started-generate-data"></a>

Dopo aver inserito lo snippet di codice e quando l'applicazione aggiornata è in esecuzione, è possibile testarlo generando manualmente eventi utente. Per testarlo, consigliamo anche di fare quanto segue. Questo test prevede tariffe RUM standard CloudWatch .
+ Spostarsi tra le pagine dell'applicazione Web.
+ Creare più sessioni utente, utilizzando browser e dispositivi diversi.
+ Eseguire richieste.
+ Causare JavaScript errori.

Dopo aver generato alcuni eventi, visualizzali nella dashboard CloudWatch RUM. Per ulteriori informazioni, consulta [Visualizzazione della dashboard CloudWatch RUM](CloudWatch-RUM-view-data.md).

I dati delle sessioni utente potrebbero richiedere fino a 15 minuti per essere visualizzati nel pannello di controllo.

Se i dati non vengono visualizzati 15 minuti dopo aver generato eventi nell'applicazione, vedere [Risoluzione dei problemi RUM CloudWatch](CloudWatch-RUM-troubleshooting.md).