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à.
# Registrazione e monitoraggio in Amazon Managed Service per Apache Flink
Il monitoraggio è importante per garantire l'affidabilità, la disponibilità e le prestazioni delle applicazioni del servizio gestito per Apache Flink. È necessario raccogliere i dati di monitoraggio da tutte le parti della AWS soluzione in modo da poter eseguire più facilmente il debug di un errore multipunto, se si verifica.
Prima di iniziare il monitoraggio del servizio gestito per Apache Flink, è opportuno creare un piano di monitoraggio che includa le risposte alle seguenti domande:
+ Quali sono gli obiettivi del monitoraggio?
+ Di quali risorse si intende eseguire il monitoraggio?
+ Con quale frequenza sarà eseguito il monitoraggio di queste risorse?
+ Quali strumenti di monitoraggio verranno utilizzati?
+ Chi eseguirà i processi di monitoraggio?
+ Chi deve ricevere una notifica quando si verifica un problema?
Il passaggio successivo consiste nello stabilire una baseline per le prestazioni normali del servizio gestito per Apache Flink nel tuo ambiente. Per farlo, devi misurare le prestazioni in diversi orari e in diverse condizioni di carico. Quando monitori il servizio gestito per Apache Flink, vengono archiviati i dati di monitoraggio storici. In questo modo, puoi confrontare i dati con i dati sulle prestazioni correnti, identificare i normali modelli di prestazioni e le anomalie e ideare metodi per risolvere i problemi.
**Topics**
+ [Accesso al servizio gestito per Apache Flink](logging.md)
+ [Monitoraggio in Managed Service per Apache Flink](monitoring.md)
+ [Configurare la registrazione delle applicazioni in Managed Service per Apache Flink](cloudwatch-logs.md)
+ [Analizza i log con CloudWatch Logs Insights](cloudwatch-logs-reading.md)
+ [Metriche e dimensioni in Managed Service for Apache Flink](metrics-dimensions.md)
+ [Scrivi messaggi personalizzati in Logs CloudWatch](cloudwatch-logs-writing.md)
+ [Registra il servizio gestito per le chiamate API Apache Flink con AWS CloudTrail](logging-using-cloudtrail.md)
# Accesso al servizio gestito per Apache Flink
La registrazione è importante per consentire alle applicazioni di produzione di comprendere errori e guasti. Tuttavia, il sottosistema di registrazione deve raccogliere e inoltrare le voci di registro ai CloudWatch registri. Sebbene alcune operazioni di registrazione siano buone e auspicabili, una registrazione estesa può sovraccaricare il servizio e causare ritardi nell'applicazione Flink. Registrare eccezioni e avvisi è sicuramente un'idea valida, ma non è possibile generare un messaggio di log per ogni messaggio elaborato dall'applicazione Flink. Flink è ottimizzato per una latenza elevata e bassa, mentre il sottosistema di registrazione non lo è. Nel caso in cui sia davvero necessario generare un output di registro per ogni messaggio elaborato, utilizzane un altro DataStream interno all'applicazione Flink e un sink appropriato per inviare i dati ad Amazon CloudWatch S3 o. Non utilizzare il sistema di registrazione Java per questo scopo. Inoltre, l'impostazione del `Debug Monitoring Log Level` del servizio gestito per Apache Flink genera una grande quantità di traffico, che può creare contropressione. Utilizzala solo mentre indaghi attivamente i problemi relativi all'applicazione.
## Interroga i log con Logs Insights CloudWatch
CloudWatch Logs Insights è un potente servizio per interrogare i log su larga scala. Le sue funzionalità sono particolarmente indicate per i clienti che desiderano effettuare ricerche rapide nei log per individuare e mitigare gli errori durante gli eventi operativi.
La query seguente cerca le eccezioni in tutti i log del task manager e le ordina in base al momento n cui si sono verificate.
```
fields @timestamp, @message
| filter isPresent(throwableInformation.0) or isPresent(throwableInformation) or @message like /(Error|Exception)/
| sort @timestamp desc
```
Per altre query utili, consulta [Query di esempio](https://docs.aws.amazon.com/managed-flink/latest/java/cloudwatch-logs-reading.html#cloudwatch-logs-reading-examples).
# Monitoraggio in Managed Service per Apache Flink
Quando esegui applicazioni di streaming in produzione, decidi di eseguire l'applicazione in modo continuo e indefinito. È fondamentale implementare il monitoraggio e i sistemi di avviso corretti di tutti i componenti, non solo dell'applicazione Flink, altrimenti rischi di non affrontare tempestivamente i problemi emergenti e di accorgerti di un evento operativo solo quando ormai è troppo difficile da mitigare. Gli aspetti generali da monitorare includono:
+ L'origine sta importando dati?
+ I dati vengono letti dall'origine (dal punto di vista dell'origine)?
+ L'applicazione Flink riceve dati?
+ L'applicazione Flink è in grado di restare al passo o è in ritardo?
+ L'applicazione Flink mantiene i dati nel sink (dal punto di vista dell'applicazione)?
+ Il sink riceve dati?
Successivamente, è necessario prendere in considerazione parametri più specifici per l'applicazione Flink. Questa [CloudWatch dashboard](https://github.com/aws-samples/kda-metrics-dashboard) offre un buon punto di partenza. Per ulteriori informazioni sui parametri da monitorare per le applicazioni di produzione, consulta [Usa gli CloudWatch allarmi con Amazon Managed Service per Apache Flink](monitoring-metrics-alarms.md). Tali parametri includono:
+ **records\$1lag\$1max** e **millisbehindLatest**: se l'applicazione consuma da Kinesis o Kafka, questi parametri indicano se è in ritardo e deve essere dimensionata per restare al passo con il carico corrente. Si tratta di un parametro generico valido e facile da tracciare per tutti i tipi di applicazioni; tuttavia, può essere utilizzato solo per il dimensionamento reattivo, ovvero quando l'applicazione è già in ritardo.
+ **CPUUtilization **heapMemoryUtilization****e: queste metriche forniscono una buona indicazione dell'utilizzo complessivo delle risorse dell'applicazione e possono essere utilizzate per la scalabilità proattiva, a meno che l'applicazione non sia vincolata. I/O
+ **downtime**: un tempo di inattività maggiore di zero indica un errore dell'applicazione. Se il valore è maggiore di 0, l'applicazione non sta elaborando alcun dato.
+ **lastCheckpointSize**e *lastCheckpointDuration*— Queste metriche monitorano la quantità di dati archiviati nello stato e il tempo necessario per superare un checkpoint. Se i checkpoint aumentano di dimensioni o richiedono molto tempo, l'applicazione dedica continuamente tempo a effettuare checkpoint e ha meno cicli per l'elaborazione effettiva dei dati. In alcuni punti, i checkpoint possono diventare troppo grandi o impiegare così tanto tempo da non funzionare. Oltre ai valori assoluti, i clienti dovrebbero considerare la possibilità di monitorare la frequenza di modifica con `RATE(lastCheckpointSize)` e `RATE(lastCheckpointDuration)`.
+ **numberOfFailedCheckpoint**: questa metrica conta il numero di checkpoint non riusciti dall'avvio dell'applicazione. A seconda dell'applicazione, un malfunzionamento occasionale dei checkpoint può essere accettabile. Tuttavia, se i checkpoint non riescono regolarmente, è probabile che l'applicazione non sia integra e che necessiti di ulteriore attenzione. Si consiglia di controllare che il parametro `RATE(numberOfFailedCheckpoints)` evidenzi problemi sul gradiente e non su valori assoluti.
# Configurare la registrazione delle applicazioni in Managed Service per Apache Flink
Aggiungendo un'opzione di CloudWatch registrazione Amazon alla tua applicazione Managed Service for Apache Flink, puoi monitorare gli eventi dell'applicazione o i problemi di configurazione.
Questo argomento descrive come configurare l'applicazione per scrivere gli eventi dell'applicazione in un CloudWatch flusso di Logs. Un'opzione CloudWatch di registrazione è una raccolta di impostazioni e autorizzazioni dell'applicazione che l'applicazione utilizza per configurare il modo in cui scrive gli eventi dell'applicazione nei registri. CloudWatch È possibile aggiungere e configurare un'opzione CloudWatch di registrazione utilizzando Console di gestione AWS o (). AWS Command Line Interface AWS CLI
Tieni presente quanto segue sull'aggiunta di un'opzione CloudWatch di registrazione all'applicazione:
+ Quando aggiungi un'opzione di CloudWatch registrazione utilizzando la console, Managed Service for Apache Flink crea automaticamente il gruppo di CloudWatch log e il flusso di log e aggiunge le autorizzazioni necessarie all'applicazione per scrivere nel flusso di log.
+ Quando aggiungete un'opzione di CloudWatch registrazione utilizzando l'API, dovete anche creare il gruppo e il flusso di log dell'applicazione e aggiungere le autorizzazioni necessarie all'applicazione per scrivere nel flusso di log.
## Configura la CloudWatch registrazione utilizzando la console
Quando abiliti CloudWatch la registrazione per la tua applicazione nella console, vengono creati automaticamente un CloudWatch gruppo di log e un flusso di log. Inoltre, la policy di autorizzazione dell'applicazione viene aggiornata con le autorizzazioni di scrittura sul flusso.
Managed Service for Apache Flink crea un gruppo di log denominato utilizzando la seguente convenzione, *ApplicationName* dov'è il nome dell'applicazione.
```
/aws/kinesis-analytics/ApplicationName
```
Il servizio gestito per Apache Flink crea un flusso di log nel nuovo gruppo di log con il nome seguente.
```
kinesis-analytics-log-stream
```
È possibile impostare il monitoraggio del livello dei parametri e il monitoraggio del livello di log utilizzando la sezione **Monitoraggio del livello di log** della pagina **Configura applicazione**. Per ulteriori informazioni sui livelli di log dell'applicazione, consulta [Controlla i livelli di monitoraggio delle applicazioni](#cloudwatch_levels).
## Configurare la CloudWatch registrazione utilizzando la CLI
Per aggiungere un'opzione CloudWatch di registrazione utilizzando il AWS CLI, completa quanto segue:
+ Crea un gruppo di CloudWatch log e un flusso di log.
+ Aggiungi un'opzione di registrazione quando crei un'applicazione utilizzando l'[CreateApplication](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html)azione o aggiungi un'opzione di registrazione a un'applicazione esistente utilizzando l'[AddApplicationCloudWatchLoggingOption](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_AddApplicationCloudWatchLoggingOption.html)azione.
+ Aggiungi alla policy dell'applicazione le autorizzazioni per scrivere sui log.
### Crea un gruppo di CloudWatch log e un flusso di log
Puoi creare un gruppo di CloudWatch log e uno stream utilizzando la console CloudWatch Logs o l'API. Per informazioni sulla creazione di un gruppo di CloudWatch log e di un flusso di log, consulta [Lavorare con gruppi di log e flussi di log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html).
### Utilizzate le opzioni di CloudWatch registrazione delle applicazioni
Utilizza le seguenti azioni API per aggiungere un'opzione di CloudWatch registro a un'applicazione nuova o esistente o modificare un'opzione di registro per un'applicazione esistente. Per ulteriori informazioni su come utilizzare un file JSON come input per un'operazione API, consulta [Codice di esempio dell'API Managed Service per Apache Flink](api-examples.md).
#### Aggiungi un'opzione di CloudWatch registro durante la creazione di un'applicazione
L'esempio seguente mostra come utilizzare l'`CreateApplication`azione per aggiungere un'opzione di CloudWatch registro quando si crea un'applicazione. Nell'esempio, sostituire *Amazon Resource Name (ARN) of the CloudWatch Log stream to add to the new application* con le tue informazioni. Per ulteriori informazioni sull'operazione, consulta [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html).
```
{
"ApplicationName": "test",
"ApplicationDescription": "test-application-description",
"RuntimeEnvironment": "FLINK-1_15",
"ServiceExecutionRole": "arn:aws:iam::123456789123:role/myrole",
"ApplicationConfiguration": {
"ApplicationCodeConfiguration": {
"CodeContent": {
"S3ContentLocation":{
"BucketARN": "arn:aws:s3:::amzn-s3-demo-bucket",
"FileKey": "myflink.jar"
}
},
"CodeContentType": "ZIPFILE"
}
},
"CloudWatchLoggingOptions": [{
"LogStreamARN": ""
}]
}
```
#### Aggiungere un'opzione di CloudWatch registro a un'applicazione esistente
L'esempio seguente mostra come utilizzare l'`AddApplicationCloudWatchLoggingOption`azione per aggiungere un'opzione di CloudWatch registro a un'applicazione esistente. Nell'esempio, sostituisci ciascuno *user input placeholder* con le tue informazioni. Per ulteriori informazioni sull'operazione, consulta [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_AddApplicationCloudWatchLoggingOption.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_AddApplicationCloudWatchLoggingOption.html).
```
{
"ApplicationName": "",
"CloudWatchLoggingOption": {
"LogStreamARN": ""
},
"CurrentApplicationVersionId":
}
```
#### Aggiorna un'opzione di CloudWatch registro esistente
L'esempio seguente mostra come utilizzare l'`UpdateApplication`azione per modificare un'opzione di CloudWatch registro esistente. Nell'esempio, sostituisci ognuna *user input placeholder* con le tue informazioni. Per ulteriori informazioni sull'operazione, consulta [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html).
```
{
"ApplicationName": "",
"CloudWatchLoggingOptionUpdates": [
{
"CloudWatchLoggingOptionId": "",
"LogStreamARNUpdate": ""
}
],
"CurrentApplicationVersionId":
}
```
#### Eliminare un'opzione di CloudWatch registro da un'applicazione
L'esempio seguente mostra come utilizzare l'`DeleteApplicationCloudWatchLoggingOption`azione per eliminare un'opzione di CloudWatch registro esistente. Nell'esempio, sostituisci ognuna *user input placeholder* con le tue informazioni. Per ulteriori informazioni sull'operazione, consulta [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_DeleteApplicationCloudWatchLoggingOption.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_DeleteApplicationCloudWatchLoggingOption.html).
```
{
"ApplicationName": "",
"CloudWatchLoggingOptionId": "",
"CurrentApplicationVersionId":
}
```
#### Imposta il livello di registrazione dell'applicazione
Per impostare il livello di registrazione dell'applicazione, utilizza il parametro [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_MonitoringConfiguration.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_MonitoringConfiguration.html) dell'operazione [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html) o il parametro [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_MonitoringConfigurationUpdate.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_MonitoringConfigurationUpdate.html) dell'operazione [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html).
Per ulteriori informazioni sui livelli di log dell'applicazione, consulta [Controlla i livelli di monitoraggio delle applicazioni](#cloudwatch_levels).
##### Imposta il livello di registrazione dell'applicazione durante la creazione di un'applicazione
La seguente richiesta di esempio per l'operazione [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html) imposta il livello di log dell'applicazione su `INFO`.
```
{
"ApplicationName": "MyApplication",
"ApplicationDescription": "My Application Description",
"ApplicationConfiguration": {
"ApplicationCodeConfiguration":{
"CodeContent":{
"S3ContentLocation":{
"BucketARN":"arn:aws:s3:::amzn-s3-demo-bucket",
"FileKey":"myflink.jar",
"ObjectVersion":"AbCdEfGhIjKlMnOpQrStUvWxYz12345"
}
},
"CodeContentType":"ZIPFILE"
},
"FlinkApplicationConfiguration":
"MonitoringConfiguration": {
"ConfigurationType": "CUSTOM",
"LogLevel": "INFO"
}
},
"RuntimeEnvironment": "FLINK-1_15",
"ServiceExecutionRole": "arn:aws:iam::123456789123:role/myrole"
}
```
##### Aggiornare il livello di registrazione dell'applicazione
La seguente richiesta di esempio per l'operazione [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html) imposta il livello di log dell'applicazione su `INFO`.
```
{
"ApplicationConfigurationUpdate": {
"FlinkApplicationConfigurationUpdate": {
"MonitoringConfigurationUpdate": {
"ConfigurationTypeUpdate": "CUSTOM",
"LogLevelUpdate": "INFO"
}
}
}
}
```
### Aggiungi le autorizzazioni per la scrittura nel flusso di log CloudWatch
Il servizio gestito per Apache Flink necessita delle autorizzazioni per scrivere errori di configurazione errata. CloudWatch È possibile aggiungere queste autorizzazioni al ruolo AWS Identity and Access Management (IAM) assunto da Managed Service for Apache Flink.
Per ulteriori informazioni sull'utilizzo di un ruolo IAM per il servizio gestito per Apache Flink, consulta [Identity and Access Management per il servizio gestito da Amazon per Apache Flink](security-iam.md).
#### Policy di attendibilità
Per concedere al servizio gestito per Apache Flink le autorizzazioni per assumere un ruolo IAM, puoi collegare la seguente policy di attendibilità al ruolo di esecuzione del servizio.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "kinesisanalytics.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
#### Policy delle autorizzazioni
Per concedere a un'applicazione le autorizzazioni per scrivere eventi di registro CloudWatch da una risorsa Managed Service for Apache Flink, puoi utilizzare la seguente politica di autorizzazioni IAM. Fornisci gli Amazon Resource Names (ARNs) corretti per il gruppo di log e lo stream.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Stmt0123456789000",
"Effect": "Allow",
"Action": [
"logs:PutLogEvents",
"logs:DescribeLogGroups",
"logs:DescribeLogStreams"
],
"Resource": [
"arn:aws:logs:us-east-1:123456789012:log-group:my-log-group:log-stream:my-log-stream*",
"arn:aws:logs:us-east-1:123456789012:log-group:my-log-group:*",
"arn:aws:logs:us-east-1:123456789012:log-group:*"
]
}
]
}
```
------
## Controlla i livelli di monitoraggio delle applicazioni
Puoi controllare la generazione dei messaggi di log dell'applicazione utilizzando il *Monitoraggio del livello dei parametri* e il *Monitoraggio del livello di log* dell'applicazione.
Il monitoraggio del livello dei parametri dell'applicazione controlla la granularità dei messaggi di log. I livelli dei parametri di monitoraggio sono definiti nel modo seguente:
+ **Applicazione**: i parametri si riferiscono all'intera applicazione.
+ **Attività**: i parametri si riferiscono a ciascuna attività. Per ulteriori informazioni sulle attività, consulta [Implementazione della scalabilità delle applicazioni in Managed Service for Apache Flink](how-scaling.md).
+ **Operatore**: i parametri si riferiscono a ciascun operatore. Per ulteriori informazioni sugli operatori, consulta [Trasforma i dati utilizzando gli operatori in Managed Service for Apache Flink con l'API DataStream](how-operators.md).
+ **Parallelismo**: i parametri si riferiscono al parallelismo delle applicazioni. Puoi impostare questo livello di metrica solo utilizzando il [ MonitoringConfigurationUpdate](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_MonitoringConfigurationUpdate.html)parametro dell'[ UpdateApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplication.html)API. Non è possibile impostare questo livello dei parametri utilizzando la console. Per ulteriori informazioni sul parallelismo, consulta [Implementazione della scalabilità delle applicazioni in Managed Service for Apache Flink](how-scaling.md).
Il monitoraggio del livello di log dell'applicazione controlla la verbosità del log dell'applicazione. I livelli di log di monitoraggio sono definiti nel modo seguente:
+ **Errore**: eventi catastrofici potenziali dell'applicazione.
+ **Avviso**: situazioni potenzialmente dannose dell'applicazione.
+ **Informazioni**: eventi di errore informativi e transitori dell'applicazione. Ti consigliamo di utilizzare questo livello di registrazione.
+ **Debug**: eventi informativi dettagliati che sono particolarmente utili per il debug di un'applicazione. *Nota*: utilizza questo livello solo per scopi di debug temporanei.
## Applica le migliori pratiche di registrazione
È consigliabile che l'applicazione utilizzi il livello di registrazione delle **informazioni**. Consigliamo questo livello per garantire la visualizzazione degli errori di Apache Flink, che vengono registrati a livello di **informazioni** anziché a livello di **errore**.
Ti consigliamo di utilizzare il livello di **debug** solo temporaneamente durante l'analisi dei problemi delle applicazioni. Torna al livello **Informazioni** quando il problema è stato risolto. L'utilizzo del livello di registrazione di **debug** influirà in modo significativo sulle prestazioni dell'applicazione.
Una registrazione eccessiva può inoltre influire in modo significativo sulle prestazioni dell'applicazione. Ti consigliamo, ad esempio, di non scrivere una voce di registro per ogni record elaborato. Una registrazione eccessiva può causare gravi rallentamenti nell'elaborazione dei dati e può portare a una contropressione nella lettura dei dati dalle origini.
## Eseguire la risoluzione dei problemi di registrazione
Se i log delle applicazioni non vengono scritti nel flusso di log, verifica quanto segue:
+ Verifica che il ruolo e le policy IAM dell'applicazione siano corretti. La policy dell'applicazione richiede le seguenti autorizzazioni per accedere al flusso di log:
+ `logs:PutLogEvents`
+ `logs:DescribeLogGroups`
+ `logs:DescribeLogStreams`
Per ulteriori informazioni, consulta [Aggiungi le autorizzazioni per la scrittura nel flusso di log CloudWatch](#enable_putlogevents).
+ Verifica che l'applicazione sia in esecuzione. Per verificare lo stato dell'applicazione, visualizza la pagina dell'applicazione nella console o utilizza le [ListApplications](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_ListApplications.html)azioni [DescribeApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_DescribeApplication.html)o.
+ Monitora CloudWatch le metriche, ad esempio `downtime` per diagnosticare altri problemi relativi alle applicazioni. Per informazioni sulla lettura delle CloudWatch metriche, consulta. [Metriche e dimensioni in Managed Service for Apache Flink](metrics-dimensions.md)
## Usa CloudWatch Logs Insights
Dopo aver abilitato CloudWatch la registrazione nell'applicazione, è possibile utilizzare CloudWatch Logs Insights per analizzare i log dell'applicazione. Per ulteriori informazioni, consulta [Analizza i log con CloudWatch Logs Insights](cloudwatch-logs-reading.md).
# Analizza i log con CloudWatch Logs Insights
Dopo aver aggiunto un'opzione di CloudWatch registrazione all'applicazione come descritto nella sezione precedente, puoi utilizzare CloudWatch Logs Insights per interrogare i flussi di log alla ricerca di eventi o errori specifici.
CloudWatch Logs Insights consente di cercare e analizzare in modo interattivo i dati di registro in Logs. CloudWatch
Per informazioni su come iniziare a usare CloudWatch Logs Insights, consulta [Analizzare i dati di log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html) con Logs Insights. CloudWatch
## Esecuzione di una query di esempio
Questa sezione descrive come eseguire una query di esempio di CloudWatch Logs Insights.
**Prerequisiti**
+ Gruppi di log e flussi di log esistenti configurati in CloudWatch Logs.
+ Registri esistenti archiviati in Logs. CloudWatch
Se utilizzi servizi come AWS CloudTrail Amazon Route 53 o Amazon VPC, probabilmente hai già configurato i log di tali servizi in modo che accedano a Logs. CloudWatch [Per ulteriori informazioni sull'invio di log a Logs, consulta Getting CloudWatch Started with Logs. CloudWatch ](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_GettingStarted.html)
Le query in CloudWatch Logs Insights restituiscono un insieme di campi degli eventi di registro o il risultato di un'aggregazione matematica o di altre operazioni eseguite sugli eventi di registro. Questo tutorial illustra una query che restituisce un elenco di eventi di log.
**Per eseguire una query di esempio di Logs CloudWatch Insights**
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel riquadro di navigazione, seleziona **Informazioni dettagliate**.
1. L'editor di query della pagina Logs Insights contiene una query predefinita che restituisce gli ultimi 20 eventi di log. Sopra l'editor di query, seleziona un gruppo di log su cui eseguire la query.
Quando si seleziona un gruppo di log, CloudWatch Logs Insights rileva automaticamente i campi nei dati del gruppo di log e li visualizza **nei Campi rilevati** nel riquadro destro. Inoltre, visualizza un grafico a barre di eventi di log in questo gruppo di log nel tempo. Questo grafico a barre mostra la distribuzione di eventi nel gruppo di log che corrisponde alla query e all'intervallo di tempo, non solo gli eventi visualizzati nella tabella.
1. Scegli **Esegui query**.
Vengono visualizzati i risultati della query. In questo esempio, i risultati sono gli ultimi 20 eventi di log di qualsiasi tipo.
1. Per visualizzare tutti i campi di uno degli eventi di log restituiti, scegli la freccia a sinistra dell'evento di log.
Per ulteriori informazioni su come eseguire e modificare le query di CloudWatch Logs Insights, consulta [Eseguire e modificare](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_RunSampleQuery.html) una query di esempio.
## Esamina le query di esempio
Questa sezione contiene query di esempio di CloudWatch Logs Insights per l'analisi dei log delle applicazioni Managed Service for Apache Flink. Queste query cercano diversi esempi di condizioni di errore e fungono da modelli per scrivere query che trovano altre condizioni di errore.
**Nota**
Sostituisci la regione (*us-west-2*), l'ID account (*012345678901*) e il nome dell'applicazione (*YourApplication*) nei seguenti esempi di query con la regione e l'ID account dell'applicazione.
**Topics**
+ [Analizza le operazioni: distribuzione delle attività](#cloudwatch-logs-reading-tm)
+ [Analisi delle operazioni: modifica del parallelismo](#cloudwatch-logs-reading-auto)
+ [Analizza gli errori: accesso negato](#cloudwatch-logs-reading-access)
+ [Analizza gli errori: fonte o sink non trovati](#cloudwatch-logs-reading-con)
+ [Analizza gli errori: errori relativi alle attività dell'applicazione](#cloudwatch-logs-reading-apps)
### Analizza le operazioni: distribuzione delle attività
La seguente query di CloudWatch Logs Insights restituisce il numero di attività che Apache Flink Job Manager distribuisce tra i Task Manager. È necessario impostare l'intervallo di tempo della query in modo che corrisponda a un solo processo eseguito, in modo che la query non restituisca attività dai processi precedenti. Per ulteriori informazioni sui parametri, consulta [Implementa la scalabilità delle applicazioni](how-scaling.md).
```
fields @timestamp, message
| filter message like /Deploying/
| parse message " to flink-taskmanager-*" as @tmid
| stats count(*) by @tmid
| sort @timestamp desc
| limit 2000
```
La seguente query di CloudWatch Logs Insights restituisce le sottoattività assegnate a ciascun Task Manager. Il numero totale di sottoattività è la somma del parallelismo di ogni attività. Il parallelismo delle attività deriva dal parallelismo degli operatori ed è lo stesso del parallelismo dell'applicazione per impostazione predefinita, a meno che non ne modifichi il codice specificando `setParallelism`. Per ulteriori informazioni sull'impostazione del parallelismo degli operatori, consulta [Impostazione del parallelismo: livello dell'operatore](https://nightlies.apache.org/flink/flink-docs-release-1.15/dev/parallel.html#operator-level) nella [documentazione di Apache Flink](https://nightlies.apache.org/flink/flink-docs-release-1.15/).
```
fields @timestamp, @tmid, @subtask
| filter message like /Deploying/
| parse message "Deploying * to flink-taskmanager-*" as @subtask, @tmid
| sort @timestamp desc
| limit 2000
```
Per ulteriori informazioni sulla pianificazione delle attività, consulta [Processi e pianificazione](https://nightlies.apache.org/flink/flink-docs-release-1.15/internals/job_scheduling.html) nella [documentazione di Apache Flink.](https://nightlies.apache.org/flink/flink-docs-release-1.15/)
### Analisi delle operazioni: modifica del parallelismo
La seguente query di CloudWatch Logs Insights restituisce le modifiche al parallelismo di un'applicazione (ad esempio, dovute al ridimensionamento automatico). Questa query restituisce anche le modifiche manuali al parallelismo dell'applicazione. Per ulteriori informazioni sul dimensionamento automatico, consulta [Utilizza il ridimensionamento automatico in Managed Service for Apache Flink](how-scaling-auto.md).
```
fields @timestamp, @parallelism
| filter message like /property: parallelism.default, /
| parse message "default, *" as @parallelism
| sort @timestamp asc
```
### Analizza gli errori: accesso negato
La seguente query di CloudWatch Logs Insights restituisce i `Access Denied` log.
```
fields @timestamp, @message, @messageType
| filter applicationARN like /arn:aws:kinesisanalyticsus-west-2:012345678901:application\/YourApplication/
| filter @message like /AccessDenied/
| sort @timestamp desc
```
### Analizza gli errori: fonte o sink non trovati
La seguente query di CloudWatch Logs Insights restituisce i `ResourceNotFound` log. `ResourceNotFound`i log risultano se non viene trovato un codice sorgente o un sink Kinesis.
```
fields @timestamp,@message
| filter applicationARN like /arn:aws:kinesisanalyticsus-west-2:012345678901:application\/YourApplication/
| filter @message like /ResourceNotFoundException/
| sort @timestamp desc
```
### Analizza gli errori: errori relativi alle attività dell'applicazione
La seguente query di CloudWatch Logs Insights restituisce i log degli errori relativi alle attività di un'applicazione. Questi log vengono generati se lo stato di un'applicazione passa da `RUNNING` a `RESTARTING`.
```
fields @timestamp,@message
| filter applicationARN like /arn:aws:kinesisanalyticsus-west-2:012345678901:application\/YourApplication/
| filter @message like /switched from RUNNING to RESTARTING/
| sort @timestamp desc
```
Per le applicazioni che utilizzano Apache Flink versione 1.8.2 e precedenti, gli errori relativi alle attività comporteranno invece il passaggio dello stato dell'applicazione da `RUNNING` a `FAILED`. Quando utilizzi Apache Flink versione 1.8.2 e precedenti, la query seguente ti consente di cercare gli errori relativi alle attività dell'applicazione:
```
fields @timestamp,@message
| filter applicationARN like /arn:aws:kinesisanalyticsus-west-2:012345678901:application\/YourApplication/
| filter @message like /switched from RUNNING to FAILED/
| sort @timestamp desc
```
# Metriche e dimensioni in Managed Service for Apache Flink
Quando il tuo Managed Service per Apache Flink elabora un'origine dati, Managed Service for Apache Flink riporta le seguenti metriche e dimensioni ad Amazon. CloudWatch
**Modifiche alle metriche di Flink 2.2**
Flink 2.2 introduce modifiche alle metriche che possono influire sul monitoraggio e sugli allarmi. Esamina le seguenti modifiche prima dell'aggiornamento:
La `fullRestarts` metrica è stata rimossa. Usare invece `numRestarts`.
Le `downtime` metriche `uptime` e sono obsolete e verranno rimosse in una versione futura. Esegui la migrazione alle nuove metriche specifiche dello stato.
La `bytesRequestedPerFetch` metrica per il connettore Kinesis Data Streams 6.0.0 è stata rimossa.
## Parametri di applicazione
| Metrica | Unità | Description | Livello | Note per l'utilizzo |
| --- | --- | --- | --- | --- |
| backPressuredTimeMsPerSecond\$1 | Millisecondi | Il tempo (in millisecondi) in cui questa attività o questo operatore vengono sottoposti a contropressione al secondo. | Attività, operatore, parallelismo | \$1Disponibile solo per le applicazioni del servizio gestito per Apache Flink che eseguono la versione 1.13 di Flink. Questi parametri possono essere utili per identificare i rallentamenti in un'applicazione. |
| busyTimeMsPerSecond\$1 | Millisecondi | Il tempo (in millisecondi) occupato dall'attività o dall'operatore (né inattivo né in contropressione) al secondo. Può essere NaN, se il valore non può essere calcolato. | Attività, operatore, parallelismo | \$1Disponibile solo per le applicazioni del servizio gestito per Apache Flink che eseguono la versione 1.13 di Flink. Questi parametri possono essere utili per identificare i rallentamenti in un'applicazione. |
| cpuUtilization | Percentuale | La percentuale complessiva di utilizzo della CPU tra i task manager. Ad esempio, se sono presenti cinque task manager, il servizio gestito per Apache Flink pubblica cinque esempi di questa metrica per intervallo di report. | Applicazione | È possibile utilizzare questa metrica per monitorare l'utilizzo minimo, medio e massimo della CPU nell'applicazione. La CPUUtilization metrica tiene conto solo dell'utilizzo della CPU del processo TaskManager JVM in esecuzione all'interno del contenitore. |
| containerCPUUtilization | Percentuale | Percentuale complessiva di utilizzo della CPU tra i container del task manager nel cluster di applicazioni Flink. Ad esempio, se sono presenti cinque task manager, corrispondenti sono cinque TaskManager contenitori e Managed Service for Apache Flink pubblica 2\$1 cinque esempi di questa metrica per intervallo di report di 1 minuto. | Applicazione | Il calcolo per container viene svolto come segue: *Tempo totale della CPU (in secondi) consumato dal container \$1 100/Limite CPU del contenitore (in /secondi) CPUs* La `CPUUtilization` metrica tiene conto solo dell'utilizzo della CPU del processo TaskManager JVM in esecuzione all'interno del contenitore. Esistono altri componenti in esecuzione all'esterno della JVM nello stesso container. Il parametro `containerCPUUtilization` fornisce un quadro più completo, includendo tutti i processi in termini di esaurimento della CPU nel container e gli errori che ne derivano. |
| containerMemoryUtilization | Percentuale | Percentuale complessiva di utilizzo della memoria tra i container del task manager nel cluster di applicazioni Flink. Ad esempio, se sono presenti cinque task manager, corrispondenti sono cinque TaskManager contenitori e Managed Service for Apache Flink pubblica 2\$1 cinque esempi di questa metrica per intervallo di report di 1 minuto. | Applicazione | Il calcolo per container viene svolto come segue: *Utilizzo della memoria del container (byte) \$1 100/limite di memoria del container in base alle specifiche di implementazione del pod (in byte)* [Le `ManagedMemoryUtilzations` metriche `HeapMemoryUtilization` and tengono conto solo di parametri di memoria specifici come Heap Memory Usage of TaskManager JVM o Managed Memory (utilizzo della memoria al di fuori di JVM per processi nativi come RockSDB State Backend).](https://flink.apache.org/2021/01/18/rocksdb.html#:~:text=Conclusion-,The%20RocksDB%20state%20backend%20(i.e.%2C%20RocksDBStateBackend)%20is%20one%20of,with%20exactly%2Donce%20processing%20guarantees.) Il parametro `containerMemoryUtilization` fornisce un quadro più completo, includendo la memoria del set di lavoro, che monitora meglio l'esaurimento della memoria totale. Una volta esaurito, si riaccenderà al pod. `Out of Memory Error` TaskManager |
| containerDiskUtilization | Percentuale | Percentuale complessiva di utilizzo del disco tra i container del task manager nel cluster di applicazioni Flink. Ad esempio, se ci sono cinque task manager, corrispondenti sono cinque TaskManager contenitori e Managed Service for Apache Flink pubblica 2\$1 cinque esempi di questa metrica per intervallo di report di 1 minuto. | Applicazione | Il calcolo per container viene svolto come segue: *Utilizzo del disco in byte \$1 100/limite del disco per il container in byte* Per i container, rappresenta l'utilizzo del filesystem su cui è impostato il volume root del container. |
| currentInputWatermark | Millisecondi | L'ultima filigrana che ha ricevuto application/operator/task/thread | Applicazione, operatore, attività, parallelismo | Questo record viene generato solo per dimensioni con due input. Questo è il valore minimo degli ultimi watermark ricevuti. |
| currentOutputWatermark | Millisecondi | L'ultima filigrana che ha emesso application/operator/task/thread | Applicazione, operatore, attività, parallelismo | |
| downtime[OBSOLETO] | Millisecondi | Per i lavori attualmente in una failing/recovering situazione, il tempo è trascorso durante questa interruzione. | Applicazione | Questo parametro misura il tempo trascorso durante la mancata riuscita o il ripristino di un processo. Questo parametro restituisce 0 per i processi in esecuzione e -1 per i processi completati. Se questo parametro non è 0 o -1, significa che il processo di Apache Flink per l'applicazione non è stato eseguito. **Deprecato in Flink 2.2.** Usa`restartingTime`, invece. `cancellingTime` and/or `failingTime` |
| failingTime | Millisecondi | Il tempo (in millisecondi) trascorso dall'applicazione in uno stato di errore. Utilizzate questa metrica per monitorare gli errori delle applicazioni e attivare gli avvisi. | Applicazione, flusso | Disponibile da Flink 2.2. Sostituisce parte della metrica obsoletadowntime. |
| heapMemoryUtilization | Percentuale | Utilizzo complessivo della memoria heap tra i task manager. Ad esempio, se sono presenti cinque task manager, il servizio gestito per Apache Flink pubblica cinque esempi di questa metrica per intervallo di report. | Applicazione | È possibile utilizzare questa metrica per monitorare l'utilizzo minimo, medio e massimo della memoria heap nell'applicazione. Tiene conto HeapMemoryUtilization solo di metriche di memoria specifiche come Heap Memory Usage di JVM. TaskManager |
| idleTimeMsPerSecond\$1 | Millisecondi | Il tempo (in millisecondi) di inattività (nessun dato da elaborare) di questa attività o di questo operatore al secondo. Il tempo di inattività esclude il tempo di contropressione, quindi se l'attività è in contropressione non è inattiva. | Attività, operatore, parallelismo | \$1Disponibile solo per le applicazioni del servizio gestito per Apache Flink che eseguono la versione 1.13 di Flink. Questi parametri possono essere utili per identificare i rallentamenti in un'applicazione. |
| lastCheckpointSize | Byte | La dimensione totale dell'ultimo checkpoint | Applicazione | È possibile utilizzare questo parametro per determinare l'utilizzo dello storage delle applicazioni in esecuzione. Se il valore di questo parametro aumenta, ciò potrebbe indicare la presenza di un problema con l'applicazione, ad esempio una perdita di memoria o un collo di bottiglia. |
| lastCheckpointDuration | Millisecondi | Il tempo impiegato per completare l'ultimo checkpoint | Applicazione | Questo parametro misura il tempo impiegato per completare il checkpoint più recente. Se il valore di questo parametro aumenta, ciò potrebbe indicare la presenza di un problema con l'applicazione, ad esempio una perdita di memoria o un collo di bottiglia. In alcuni casi, è possibile risolvere questo problema disabilitando il checkpoint. |
| managedMemoryUsed\$1 | Byte | La quantità di memoria attualmente in uso. | Applicazione, operatore, attività, parallelismo | \$1Disponibile solo per le applicazioni del servizio gestito per Apache Flink che eseguono la versione 1.13 di Flink. Si riferisce alla memoria gestita da Flink all'esterno dell'heap Java. Viene utilizzato per il backend di stato RocksDB ed è disponibile anche per le applicazioni. |
| managedMemoryTotal\$1 | Byte | La quantità totale di memoria gestita. | Applicazione, operatore, attività, parallelismo | \$1Disponibile solo per le applicazioni del servizio gestito per Apache Flink che eseguono la versione 1.13 di Flink. Si riferisce alla memoria gestita da Flink all'esterno dell'heap Java. Viene utilizzato per il backend di stato RocksDB ed è disponibile anche per le applicazioni. Il parametro `ManagedMemoryUtilzations` tiene conto solo di parametri di memoria specifici come la memoria gestita (utilizzo della memoria al di fuori di JVM per processi nativi come [RocksDB State Backend](https://flink.apache.org/2021/01/18/rocksdb.html#:~:text=Conclusion-,The%20RocksDB%20state%20backend%20(i.e.%2C%20RocksDBStateBackend)%20is%20one%20of,with%20exactly%2Donce%20processing%20guarantees.)) |
| managedMemoryUtilization\$1 | Percentuale | managedMemoryUsedDerivato da/managedMemoryTotal | Applicazione, operatore, attività, parallelismo | \$1Disponibile solo per le applicazioni del servizio gestito per Apache Flink che eseguono la versione 1.13 di Flink. Si riferisce alla memoria gestita da Flink all'esterno dell'heap Java. Viene utilizzato per il backend di stato RocksDB ed è disponibile anche per le applicazioni. |
| numberOfFailedCheckpoints | Conteggio | Il numero di volte in cui il checkpoint non è andato a buon fine. | Applicazione | È possibile utilizzare questo parametro per monitorare lo stato e l'avanzamento delle applicazioni. I checkpoint potrebbero non riuscire a causa di problemi dell'applicazione, come problemi di throughput o di autorizzazioni. |
| numRecordsIn\$1 | Conteggio | Il numero totale di record ricevuti da questa applicazione, operatore o attività. | Applicazione, operatore, attività, parallelismo | \$1Per applicare la statistica Somma su un periodo di tempo (secondi/minuto): [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/managed-flink/latest/java/metrics-dimensions.html) Il livello del parametro specifica se questo parametro misura il numero totale di record ricevuti dall'intera applicazione, da un operatore specifico o da un'attività specifica. |
| numRecordsInPerSecond\$1 | Numero/secondo | Il numero totale di record ricevuti da questa applicazione, operatore o attività al secondo. | Applicazione, operatore, attività, parallelismo | \$1Per applicare la statistica Somma su un periodo di tempo (secondi/minuto): [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/managed-flink/latest/java/metrics-dimensions.html) Il livello del parametro specifica se questo parametro misura il numero totale di record ricevuti dall'intera applicazione, da un operatore specifico o da un'attività specifica. |
| numRecordsOut\$1 | Conteggio | Il numero totale di record generati da questa applicazione, operatore o attività. | Applicazione, operatore, attività, parallelismo | \$1Per applicare la statistica Somma su un periodo di tempo (secondi/minuto): [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/managed-flink/latest/java/metrics-dimensions.html) Il livello del parametro specifica se questo parametro misura il numero totale di record ricevuti dall'intera applicazione, da un operatore specifico o da un'attività specifica. |
| numLateRecordsDropped\$1 | Conteggio | Applicazione, operatore, attività, parallelismo | | \$1Per applicare la statistica Somma su un periodo di tempo (secondi/minuto): [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/managed-flink/latest/java/metrics-dimensions.html) Il numero di record di questo operatore o attività è diminuito a causa dell'arrivo in ritardo. |
| numRecordsOutPerSecond\$1 | Numero/secondo | Il numero totale di record generati da questa applicazione, operatore o attività al secondo. | Applicazione, operatore, attività, parallelismo | \$1Per applicare la statistica Somma su un periodo di tempo (secondi/minuto): [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/managed-flink/latest/java/metrics-dimensions.html) Il livello del parametro specifica se questo parametro misura il numero totale di record ricevuti dall'intera applicazione, da un operatore specifico o da un'attività specifica. |
| oldGenerationGCCount | Conteggio | Il numero totale di vecchie operazioni di rimozione di oggetti inutili (garbage collection) che si sono verificate in tutti i task manager. | Applicazione | |
| oldGenerationGCTime | Millisecondi | Il tempo totale impiegato per eseguire le vecchie operazioni di rimozione di oggetti inutili (garbage collection). | Applicazione | È possibile utilizzare questo parametro per monitorare la somma, la media e il tempo massimo di rimozione di oggetti inutili (garbage collection). |
| threadsCount | Conteggio | Il numero totale di thread live utilizzati dall'applicazione. | Applicazione | Questo parametro misura il numero di thread utilizzati dal codice dell'applicazione. È diverso dal parallelismo dell’applicazione. |
| cancellingTime | Millisecondi | Il tempo (in millisecondi) che l'applicazione ha trascorso in stato di annullamento. Utilizzate questa metrica per monitorare le operazioni di annullamento delle applicazioni. | Applicazione, Flow | Disponibile da Flink 2.2. Sostituisce parte della metrica obsoletadowntime. |
| restartingTime | Millisecondi | Il tempo (in millisecondi) trascorso dall'applicazione in uno stato di riavvio. Utilizzate questa metrica per monitorare il comportamento di riavvio delle applicazioni. | Applicazione, Flow | Disponibile da Flink 2.2. Sostituisce parte della metrica obsoletadowntime. |
| runningTime | Millisecondi | Il tempo (in millisecondi) in cui l'applicazione è stata eseguita senza interruzioni. Sostituisce la metrica obsoleta. uptime | Applicazione, flusso | Disponibile da Flink 2.2. Utilizza come sostituto diretto della metrica obsoletauptime. |
| uptime[OBSOLETO] | Millisecondi | Il tempo in cui il processo è stato eseguito senza interruzioni. | Applicazione | È possibile utilizzare questo parametro per determinare se un processo viene eseguito correttamente. Questo parametro restituisce -1 per i processi completati. **Deprecato in Flink 2.2.** Usare invece `runningTime`. |
| jobmanagerFileDescriptorsMax | Conteggio | Il numero massimo di descrittori di file disponibili per. JobManager | Applicazione, flusso, host | Utilizzate questa metrica per monitorare la capacità del descrittore di file. |
| jobmanagerFileDescriptorsOpen | Conteggio | Il numero corrente di descrittori di file aperti per. JobManager | Applicazione, flusso, host | Utilizzate questa metrica per monitorare l'utilizzo del descrittore di file e rilevare il potenziale esaurimento delle risorse. |
| taskmanagerFileDescriptorsMax | Conteggio | Il numero massimo di descrittori di file disponibili per ciascuno. TaskManager | Applicazione, Flow, Host, tm\$1id | Utilizzate questa metrica per monitorare la capacità del descrittore di file. |
| taskmanagerFileDescriptorsOpen | Conteggio | Il numero attuale di descrittori di file aperti per ciascuno. TaskManager | Applicazione, Flow, Host, tm\$1id | Utilizzate questa metrica per monitorare l'utilizzo del descrittore di file e rilevare il potenziale esaurimento delle risorse. |
| KPUs\$1 | Conteggio | Il numero totale di dati KPUs utilizzati dall'applicazione. | Applicazione | \$1Questa metrica riceve un campione per periodo di fatturazione (un'ora). Per visualizzare il numero di interruzioni KPUs nel tempo, usa MAX o AVG per un periodo di almeno un'ora (1). Il conteggio delle KPU include le KPU. `orchestration` Per ulteriori informazioni, consulta [Managed Service for Apache Flink Pricing](https://aws.amazon.com/managed-service-apache-flink/pricing/). |
**Guida alla migrazione delle metriche di Flink 2.2**
**Migrazione da FullRestarts:** la `fullRestarts` metrica è stata rimossa in Flink 2.2. Utilizzate invece la metrica. `numRestarts` La `numRestarts` metrica offre funzionalità equivalenti e può essere utilizzata come sostituto diretto degli CloudWatch allarmi senza richiedere regolazioni della soglia.
**Migrazione dall'uptime:** la `uptime` metrica è obsoleta in Flink 2.2 e verrà rimossa in una versione futura. `runningTime`Utilizzate invece la metrica. La `runningTime` metrica offre funzionalità equivalenti e può essere utilizzata come sostituto diretto degli CloudWatch allarmi senza richiedere regolazioni della soglia.
**Migrazione dai tempi di inattività:** la `downtime` metrica è obsoleta in Flink 2.2 e verrà rimossa in una versione futura. A seconda di ciò che desideri monitorare, utilizza una o più delle seguenti metriche:
`restartingTime`: monitora il tempo impiegato per riavviare l'applicazione
`cancellingTime`: Monitora il tempo impiegato per annullare l'applicazione
`failingTime`: monitora il tempo trascorso in uno stato di guasto
## Metriche del connettore Kinesis Data Streams
AWS emette tutti i record per Kinesis Data Streams oltre ai seguenti:
| Metrica | Unità | Description | Livello | Note per l'utilizzo |
| --- | --- | --- | --- | --- |
| millisbehindLatest | Millisecondi | Il numero di millisecondi in cui il consumatore si trova rispetto all'estremità del flusso, a indicare il ritardo rispetto all'ora corrente del consumatore. | Applicazione (per Stream), Parallelismo (per) ShardId | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/managed-flink/latest/java/metrics-dimensions.html) |
**Nota**
La `bytesRequestedPerFetch` metrica è stata rimossa nella versione 6.0.0 del AWS connettore Flink (l'unica versione del connettore compatibile con Flink 2.2). L'unica metrica del connettore Kinesis Data Streams disponibile in Flink 2.2 è. `millisBehindLatest`
## Metriche del connettore Amazon MSK
AWS emette tutti i record per Amazon MSK oltre ai seguenti:
| Metrica | Unità | Description | Livello | Note per l'utilizzo |
| --- | --- | --- | --- | --- |
| currentoffsets | N/D | L'offset di lettura corrente del consumer, per ogni partizione. Il parametro di una particolare partizione può essere specificato in base al nome dell'argomento e all'ID della partizione. | Applicazione (per argomento), parallelismo (per) PartitionId | |
| commitsFailed | N/D | Il numero totale di errori di commit di offset su Kafka, se il commit di offset e la creazione di checkpoint sono abilitati. | Applicazione, operatore, attività, parallelismo | Restituire le compensazioni a Kafka è solo un modo per esporre i progressi dei consumer, quindi un errore di commit non pregiudica l'integrità degli offset delle partizioni bloccati di Flink. |
| commitsSucceeded | N/D | Il numero totale di commit di offset riusciti verso Kafka, se il commit di offset e la creazione di checkpoint sono abilitati. | Applicazione, operatore, attività, parallelismo | |
| committedoffsets | N/D | Gli ultimi offset eseguiti con successo su Kafka, per ogni partizione. Il parametro di una particolare partizione può essere specificato in base al nome dell'argomento e all'ID della partizione. | Applicazione (per argomento), parallelismo (per) PartitionId | |
| records\$1lag\$1max | Conteggio | Il ritardo massimo in termini di numero di record per ogni partizione in questa finestra | Applicazione, operatore, attività, parallelismo | |
| bytes\$1consumed\$1rate | Byte | Il numero medio di byte consumati al secondo per un argomento | Applicazione, operatore, attività, parallelismo | |
## Metriche di Apache Zeppelin
Per i notebook Studio, AWS emette le seguenti metriche a livello di applicazione:,,,, e. `KPUs` `cpuUtilization` `heapMemoryUtilization` `oldGenerationGCTime` `oldGenerationGCCount` `threadCount` Inoltre, genera i parametri mostrati nella tabella seguente, anche a livello di applicazione.
****
| Metrica | Unità | Description | Nome Prometheus |
| --- | --- | --- | --- |
| zeppelinCpuUtilization | Percentuale | Percentuale complessiva di utilizzo della CPU nel server Apache Zeppelin. | process\$1cpu\$1usage |
| zeppelinHeapMemoryUtilization | Percentuale | Percentuale complessiva di utilizzo della memoria heap per il server Apache Zeppelin. | jvm\$1memory\$1used\$1bytes |
| zeppelinThreadCount | Conteggio | Il numero totale di thread live utilizzati dal server Apache Zeppelin. | jvm\$1threads\$1live\$1threads |
| zeppelinWaitingJobs | Conteggio | Il numero di processi di Apache Zeppelin in coda in attesa di un thread. | jetty\$1threads\$1jobs |
| zeppelinServerUptime | Secondi | Il tempo totale in cui il server è stato attivo e in funzione. | process\$1uptime\$1seconds |
# CloudWatch Visualizza le metriche
Puoi visualizzare i CloudWatch parametri per la tua applicazione utilizzando la CloudWatch console Amazon o il AWS CLI.
**Per visualizzare le metriche utilizzando la console CloudWatch**
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel pannello di navigazione, seleziona **Parametri**.
1. Nel riquadro **CloudWatch Metriche per categoria** per Managed Service for Apache Flink, scegli una categoria di metriche.
1. Nel riquadro superiore, scorri verso il basso per visualizzare l'elenco completo dei parametri.
**Per visualizzare le metriche utilizzando il AWS CLI**
+ Al prompt dei comandi utilizza il comando seguente.
```
1. aws cloudwatch list-metrics --namespace "AWS/KinesisAnalytics" --region region
```
# Imposta i livelli di CloudWatch report sulle metriche
Puoi controllare il livello dei parametri dell'applicazione creati dall'applicazione. Il servizio gestito per Apache Flink supporta i seguenti livelli di parametri:
+ **Applicazione:** l'applicazione riporta solo il livello più elevato dei parametri per ogni applicazione. I parametri del servizio gestito per Apache Flink vengono pubblicati al livello di Applicazione per impostazione predefinita.
+ **Attività:** l'applicazione riporta le dimensioni dei parametri specifiche dell'attività per i parametri definiti con il livello di report del parametro Attività, ad esempio il numero di record in entrata e in uscita dall'applicazione al secondo.
+ **Operatore:** l'applicazione riporta le dimensioni dei parametri specifiche dell'operatore per i parametri definiti con il livello di report del parametro Operatore, ad esempio i parametri per ogni operazione di filtro o mappa.
+ **Parallelismo:** l'applicazione riporta i livelli parametri `Task` e `Operator` per ciascun thread di esecuzione. Tale livello di report non è consigliato per applicazioni con un parallelismo superiore a 64 a causa di costi eccessivi.
**Nota**
È necessario utilizzare questo livello di parametri solo per la risoluzione dei problemi a causa della quantità di dati relativi ai parametri generati dal servizio. È possibile impostare questo livello di parametri solo utilizzando la CLI. Questo livello di parametri non è disponibile nella console.
Il livello predefinito è **Applicazione**. L'applicazione riporta i parametri al livello corrente e a tutti i livelli superiori. Ad esempio, se il livello di reporting è impostato su **Operatore** l'applicazione riporta i parametri **Applicazione**, **Attività** e **Operatore**.
Puoi impostare il livello di segnalazione delle CloudWatch metriche utilizzando il `MonitoringConfiguration` parametro dell'[https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html)azione o il `MonitoringConfigurationUpdate` parametro dell'[https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html)azione. **L'esempio seguente di richiesta per l'[https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html)azione imposta il livello di segnalazione delle CloudWatch metriche su Task:**
```
{
"ApplicationName": "MyApplication",
"CurrentApplicationVersionId": 4,
"ApplicationConfigurationUpdate": {
"FlinkApplicationConfigurationUpdate": {
"MonitoringConfigurationUpdate": {
"ConfigurationTypeUpdate": "CUSTOM",
"MetricsLevelUpdate": "TASK"
}
}
}
}
```
Puoi anche configurare il livello di registrazione utilizzando il parametro `LogLevel` dell'operazione [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_CreateApplication.html) o il parametro `LogLevelUpdate` dell'operazione [https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html](https://docs.aws.amazon.com/managed-service-for-apache-flink/latest/apiv2/API_UpdateApplication.html). Puoi utilizzare i seguenti livelli di log:
+ `ERROR`: registra gli eventi di errore potenzialmente recuperabili.
+ `WARN`: registra gli eventi di avviso che potrebbero causare un errore.
+ `INFO`: registra gli eventi informativi.
+ `DEBUG`: registra gli eventi di debug generali.
Per ulteriori informazioni sui livelli di registrazione di Log4j, consulta [Livelli di registro personalizzati](https://logging.apache.org/log4j/2.x/manual/customloglevels.html) nella documentazione di [Apache Log4j](https://logging.apache.org/log4j/2.x/).
# Usa metriche personalizzate con Amazon Managed Service per Apache Flink
Managed Service for Apache Flink espone 19 metriche a, incluse le metriche relative all'utilizzo delle risorse e al throughput CloudWatch. Inoltre, puoi creare parametri personalizzati per tenere traccia dei dati specifici dell'applicazione, come l'elaborazione di eventi o l'accesso a risorse esterne.
**Topics**
+ [Come funziona](#monitoring-metrics-custom-howitworks)
+ [Visualizza esempi per la creazione di una classe di mappatura](#monitoring-metrics-custom-examples)
+ [Visualizza metriche personalizzate](#monitoring-metrics-custom-examples-viewing)
## Come funziona
I parametri personalizzati nel servizio gestito per Apache Flink utilizzano il sistema delle metriche di Apache Flink. I parametri di Apache Flink hanno i seguenti attributi:
+ **Tipo**: il tipo di un parametro descrive il modo in cui vengono misurati e riportati i dati. I tipi di parametri Apache Flink disponibili includono contatore, misuratore e istogramma. Per ulteriori informazioni sui tipi di parametri Apache Flink, consulta [Tipi di parametri](https://nightlies.apache.org/flink/flink-docs-release-1.15/monitoring/metrics.html#metric-types).
**Nota**
AWS CloudWatch Metrics non supporta il tipo di metrica Histogram Apache Flink. CloudWatch può visualizzare solo le metriche Apache Flink dei tipi Count, Gauge e Meter.
+ **Ambito: l'ambito** di una metrica è costituito dal relativo identificatore e da un insieme di coppie chiave-valore che indicano come verrà riportata la metrica. CloudWatch L'identificatore di un parametro è costituito dai seguenti elementi:
+ Un ambito di sistema, che indica il livello al quale viene riportato il parametro (ad esempio Operatore).
+ Un ambito utente, che definisce attributi come le variabili utente o i nomi dei gruppi di parametri. Questi attributi sono definiti utilizzando [https://ci.apache.org/projects/flink/flink-docs-master/api/java/org/apache/flink/metrics/MetricGroup.html#addGroup-java.lang.String-java.lang.String-](https://ci.apache.org/projects/flink/flink-docs-master/api/java/org/apache/flink/metrics/MetricGroup.html#addGroup-java.lang.String-java.lang.String-) o [https://ci.apache.org/projects/flink/flink-docs-master/api/java/org/apache/flink/metrics/MetricGroup.html#addGroup-java.lang.String-](https://ci.apache.org/projects/flink/flink-docs-master/api/java/org/apache/flink/metrics/MetricGroup.html#addGroup-java.lang.String-).
Per ulteriori informazioni sugli ambiti, consulta [Ambito](https://nightlies.apache.org/flink/flink-docs-release-1.15/monitoring/metrics.html#scope).
Per ulteriori informazioni sulle metriche di Apache Flink, consulta [Parametri](https://nightlies.apache.org/flink/flink-docs-release-1.15/monitoring/metrics.html) nella [documentazione di Apache Flink](https://nightlies.apache.org/flink/flink-docs-release-1.15/).
Per creare una metrica personalizzata nel servizio gestito per Apache Flink, puoi accedere al sistema metrico Apache Flink da qualsiasi funzione utente che estende `RichFunction` tramite chiamata [https://nightlies.apache.org/flink/flink-docs-release-1.15/api/java/org/apache/flink/api/common/functions/RuntimeContext.html#getMetricGroup--](https://nightlies.apache.org/flink/flink-docs-release-1.15/api/java/org/apache/flink/api/common/functions/RuntimeContext.html#getMetricGroup--). Questo metodo restituisce un [MetricGroup](https://nightlies.apache.org/flink/flink-docs-release-1.15/api/java/org/apache/flink/metrics/MetricGroup.html)oggetto che puoi utilizzare per creare e registrare metriche personalizzate. Managed Service for Apache Flink riporta tutte le metriche create con la chiave di gruppo to. `KinesisAnalytics` CloudWatch I parametri personalizzati che definisci hanno le seguenti caratteristiche:
+ Il parametro personalizzato ha un nome parametro e un nome gruppo. [Questi nomi devono essere composti da caratteri alfanumerici secondo le regole di denominazione di Prometheus.](https://prometheus.io/docs/instrumenting/writing_exporters/#naming)
+ Gli attributi definiti nell'ambito dell'utente (ad eccezione del gruppo di `KinesisAnalytics` metriche) vengono pubblicati come dimensioni. CloudWatch
+ Per impostazione predefinita, i parametri personalizzati vengono pubblicati a livello di `Application`.
+ Le dimensioni (attività/operatore/parallelismo) vengono aggiunte al parametro in base al livello di monitoraggio dell'applicazione. Il livello di monitoraggio dell'applicazione viene impostato utilizzando il [MonitoringConfiguration](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_MonitoringConfiguration.html)parametro dell'[CreateApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_CreateApplication.html)azione o il [MonitoringConfigurationUpdate](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_MonitoringConfigurationUpdate.html)parametro o dell'[UpdateApplication](https://docs.aws.amazon.com/managed-flink/latest/apiv2/API_UpdateApplication.html)azione.
## Visualizza esempi per la creazione di una classe di mappatura
I seguenti esempi di codice mostrano come creare una classe di mappatura che crea e incrementa una metrica personalizzata e come implementare la classe di mappatura nell'applicazione aggiungendola a un oggetto. `DataStream`
### Record count (metrica personalizzata)
Il seguente esempio di codice mostra come creare una classe di mappatura che crea un parametro che conta i record in un flusso di dati (la stessa funzionalità del parametro `numRecordsIn`):
```
private static class NoOpMapperFunction extends RichMapFunction {
private transient int valueToExpose = 0;
private final String customMetricName;
public NoOpMapperFunction(final String customMetricName) {
this.customMetricName = customMetricName;
}
@Override
public void open(Configuration config) {
getRuntimeContext().getMetricGroup()
.addGroup("KinesisAnalytics")
.addGroup("Program", "RecordCountApplication")
.addGroup("NoOpMapperFunction")
.gauge(customMetricName, (Gauge) () -> valueToExpose);
}
@Override
public String map(String value) throws Exception {
valueToExpose++;
return value;
}
}
```
Nell'esempio precedente, la variabile `valueToExpose` viene incrementata per ogni record elaborato dall'applicazione.
Dopo aver definito la classe di mappatura, crea un flusso all'interno dell'applicazione che implementa la mappa:
```
DataStream noopMapperFunctionAfterFilter =
kinesisProcessed.map(new NoOpMapperFunction("FilteredRecords"));
```
Per il codice completo di questa applicazione, consulta [Applicazione del parametro personalizzato del numero di record](https://github.com/aws-samples/amazon-managed-service-for-apache-flink-examples/tree/main/java/CustomMetrics/RecordCount).
### Metrica personalizzata per il conteggio delle parole
Il seguente esempio di codice mostra come creare una classe di mappatura che crea una metrica che conta le parole in un flusso di dati:
```
private static final class Tokenizer extends RichFlatMapFunction> {
private transient Counter counter;
@Override
public void open(Configuration config) {
this.counter = getRuntimeContext().getMetricGroup()
.addGroup("KinesisAnalytics")
.addGroup("Service", "WordCountApplication")
.addGroup("Tokenizer")
.counter("TotalWords");
}
@Override
public void flatMap(String value, Collector>out) {
// normalize and split the line
String[] tokens = value.toLowerCase().split("\\W+");
// emit the pairs
for (String token : tokens) {
if (token.length() > 0) {
counter.inc();
out.collect(new Tuple2<>(token, 1));
}
}
}
}
```
Nell'esempio precedente, la variabile `counter` viene incrementata per ogni parola elaborata dall'applicazione.
Dopo aver definito la classe di mappatura, crea un flusso all'interno dell'applicazione che implementa la mappa:
```
// Split up the lines in pairs (2-tuples) containing: (word,1), and
// group by the tuple field "0" and sum up tuple field "1"
DataStream> wordCountStream = input.flatMap(new Tokenizer()).keyBy(0).sum(1);
// Serialize the tuple to string format, and publish the output to kinesis sink
wordCountStream.map(tuple -> tuple.toString()).addSink(createSinkFromStaticConfig());
```
Per il codice completo di questa applicazione, consulta [Applicazione del parametro personalizzato del conteggio di parole](https://github.com/aws-samples/amazon-managed-service-for-apache-flink-examples/tree/main/java/CustomMetrics/WordCount).
## Visualizza metriche personalizzate
Le metriche personalizzate per la tua applicazione vengono visualizzate nella console CloudWatch Metrics nella **AWS/KinesisAnalytics**dashboard, nel gruppo di metriche dell'**applicazione**.
# Usa gli CloudWatch allarmi con Amazon Managed Service per Apache Flink
Utilizzando gli allarmi Amazon CloudWatch Metric, controlli una CloudWatch metrica per un periodo di tempo specificato. L'allarme esegue una o più operazioni basate sul valore del parametro o espressione relativa a una soglia su un certo numero di periodi. Un esempio di operazione sta inviando una notifica a un argomento Amazon Simple Notification Service (Amazon SNS).
Per ulteriori informazioni sugli CloudWatch allarmi, consulta [Using Amazon CloudWatch Alarms](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html).
## Controlla gli allarmi consigliati
Questa sezione contiene gli allarmi consigliati per il monitoraggio delle applicazioni del servizio gestito per Apache Flink.
La tabella descrive gli allarmi consigliati e contiene le seguenti colonne:
+ **Espressione di parametro:** il parametro o l'espressione di parametro da testare rispetto alla soglia.
+ **Statistica:** la statistica utilizzata per controllare il parametro, ad esempio **Media**.
+ **Soglia:** l'utilizzo di questo allarme richiede la determinazione di una soglia che definisca il limite delle prestazioni previste dell'applicazione. È necessario determinare questa soglia monitorando l'applicazione in condizioni normali.
+ **Descrizione:** cause che potrebbero attivare questo allarme e possibili soluzioni per la condizione.
| Espressioni di parametro | Statistic | Threshold | Description |
| --- |--- |--- |--- |
| downtime> 0 | Media | 0 | Un tempo di inattività maggiore di zero indica che l'applicazione non è riuscita. Se il valore è maggiore di 0, l'applicazione non sta elaborando alcun dato. Consigliato per tutte le applicazioni. La Downtime metrica misura la durata di un'interruzione. Un tempo di inattività maggiore di zero indica che l'applicazione non è riuscita. Per la risoluzione dei problemi, vedere[L'applicazione si sta riavviando](troubleshooting-rt-restarts.md). |
| RATE (numberOfFailedCheckpoints)> 0 | Media | 0 | Questa metrica conta il numero di checkpoint non riusciti dall'avvio dell'applicazione. A seconda dell'applicazione, un malfunzionamento occasionale dei checkpoint può essere accettabile. Tuttavia, se i checkpoint non riescono regolarmente, è probabile che l'applicazione non sia integra e che necessiti di ulteriore attenzione. Consigliamo di monitorare RATE (numberOfFailedCheckpoints) per generare allarmi sul gradiente e non sui valori assoluti. Consigliato per tutte le applicazioni. Utilizza questa metrica per monitorare lo stato delle applicazioni e l'avanzamento del checkpoint. L'applicazione salva i dati sullo stato nei checkpoint quando è integra. Il checkpoint può fallire a causa di timeout se l'applicazione non sta procedendo nell'elaborazione dei dati di input. Per la risoluzione dei problemi, vedere. [Il checkpoint è in fase di interruzione](troubleshooting-chk-timeout.md) |
| Operator.numRecordsOutPerSecond< soglia | Media | Il numero minimo di record emessi dall'applicazione in condizioni normali. | Consigliato per tutte le applicazioni. Un calo al di sotto di questa soglia può indicare che l'applicazione non sta facendo i progressi previsti sui dati di input. Per la risoluzione dei problemi, vedere[La velocità effettiva è troppo lenta](troubleshooting-rt-throughput.md). |
| records\$1lag\$1max\$1millisbehindLatest> soglia | Massimo | La latenza massima prevista in condizioni normali. | Se l'applicazione utilizza Kinesis o Kafka, queste metriche indicano se l'applicazione è in ritardo e deve essere ridimensionata per stare al passo con il carico corrente. Si tratta di un parametro generico valido e facile da tracciare per tutti i tipi di applicazioni; tuttavia, può essere utilizzato solo per il dimensionamento reattivo, ovvero quando l'applicazione è già in ritardo. Consigliato per tutte le applicazioni. Usa la records\$1lag\$1max metrica per una sorgente Kafka o la per millisbehindLatest una sorgente di flusso Kinesis. Il superamento di questa soglia può indicare che l'applicazione non sta facendo i progressi previsti sui dati di input. Per la risoluzione dei problemi, vedere[La velocità effettiva è troppo lenta](troubleshooting-rt-throughput.md). |
| lastCheckpointDuration> soglia | Massimo | La durata massima prevista del checkpoint in condizioni normali. | Monitora la quantità di dati archiviati nello stato e il tempo necessario per completare un checkpoint. Se i checkpoint aumentano di dimensioni o richiedono molto tempo, l'applicazione dedica continuamente tempo a effettuare checkpoint e ha meno cicli per l'elaborazione effettiva dei dati. In alcuni punti, i checkpoint possono diventare troppo grandi o impiegare così tanto tempo da non funzionare. Oltre ai valori assoluti, i clienti dovrebbero considerare la possibilità di monitorare la frequenza di modifica con RATE(lastCheckpointSize) e RATE(lastCheckpointDuration). Se il valore aumenta lastCheckpointDuration continuamente, il superamento di questa soglia può indicare che l'applicazione non sta facendo i progressi previsti sui dati di input o che vi sono problemi di integrità dell'applicazione, come la contropressione. Per la risoluzione dei problemi, vedere[Crescita statale illimitata](troubleshooting-rt-stateleaks.md). |
| lastCheckpointSize> soglia | Massimo | La dimensione massima prevista del checkpoint in condizioni normali. | Monitora la quantità di dati archiviati nello stato e il tempo necessario per completare un checkpoint. Se i checkpoint aumentano di dimensioni o richiedono molto tempo, l'applicazione dedica continuamente tempo a effettuare checkpoint e ha meno cicli per l'elaborazione effettiva dei dati. In alcuni punti, i checkpoint possono diventare troppo grandi o impiegare così tanto tempo da non funzionare. Oltre ai valori assoluti, i clienti dovrebbero considerare la possibilità di monitorare la frequenza di modifica con RATE(lastCheckpointSize) e RATE(lastCheckpointDuration). Se il valore aumenta lastCheckpointSize continuamente, il superamento di questa soglia può indicare che l'applicazione sta accumulando dati sullo stato. Se i dati sullo stato diventano troppo grandi, l'applicazione può esaurire la memoria durante il ripristino da un checkpoint, oppure il ripristino da un checkpoint potrebbe richiedere troppo tempo. Per la risoluzione dei problemi, vedere. [Crescita statale illimitata](troubleshooting-rt-stateleaks.md) |
| heapMemoryUtilization> soglia | Massimo | Ciò fornisce una buona indicazione dell'utilizzo complessivo delle risorse dell'applicazione e può essere utilizzato per una scalabilità proattiva, a meno che l'applicazione non sia vincolata. I/O La heapMemoryUtilization dimensione massima prevista in condizioni normali, con un valore consigliato del 90 percento. | È possibile utilizzare questa metrica per monitorare l'utilizzo massimo della memoria da parte dei task manager nell'applicazione. Se l'applicazione raggiunge questa soglia, è necessario fornire più risorse. A tale scopo, è necessario abilitare il ridimensionamento automatico o aumentare il parallelismo dell'applicazione. Per ulteriori informazioni sull'aumento delle risorse, vedere. [Implementa la scalabilità delle applicazioni](how-scaling.md) |
| cpuUtilization> soglia | Massimo | Ciò fornisce una buona indicazione dell'utilizzo complessivo delle risorse dell'applicazione e può essere utilizzato per una scalabilità proattiva, a meno che l'applicazione non sia vincolata. I/O La cpuUtilization dimensione massima prevista in condizioni normali, con un valore consigliato dell'80%. | È possibile utilizzare questa metrica per monitorare l'utilizzo massimo della CPU dei task manager nell'applicazione. Se l'applicazione raggiunge questa soglia, è necessario fornire più risorse. A tale scopo, è necessario abilitare il ridimensionamento automatico o aumentare il parallelismo dell'applicazione. Per ulteriori informazioni sull'aumento delle risorse, vedere. [Implementa la scalabilità delle applicazioni](how-scaling.md) |
| threadsCount> soglia | Massimo | La threadsCount dimensione massima prevista in condizioni normali. | Puoi utilizzare questa metrica per controllare eventuali perdite di thread nei task manager dell'applicazione. Se questa metrica raggiunge questa soglia, controllate il codice dell'applicazione per verificare se i thread vengono creati senza essere chiusi. |
| (oldGarbageCollectionTime \$1 100)/60\$1000 over 1 min period')> soglia | Massimo | La oldGarbageCollectionTime durata massima prevista. Si consiglia di impostare una soglia in modo che il tempo di raccolta dei rifiuti tipico sia pari al 60 percento della soglia specificata, ma la soglia corretta per l'applicazione può variare. | Se questa metrica aumenta continuamente, ciò può indicare la presenza di una perdita di memoria nei task manager dell'applicazione. |
| RATE(oldGarbageCollectionCount) > soglia | Massimo | Il massimo previsto oldGarbageCollectionCount in condizioni normali. La soglia corretta per la tua candidatura può variare. | Se questa metrica aumenta continuamente, ciò può indicare la presenza di una perdita di memoria nei task manager dell'applicazione. |
| Operator.currentOutputWatermark - Operator.currentInputWatermark > soglia | Minimo | L'incremento minimo previsto della filigrana in condizioni normali. La soglia corretta per la tua candidatura può variare. | Se questa metrica aumenta continuamente, ciò può indicare che l'applicazione sta elaborando eventi sempre più vecchi o che un'attività secondaria a monte non invia una filigrana da un periodo di tempo sempre più lungo. |
# Scrivi messaggi personalizzati in Logs CloudWatch
Puoi scrivere messaggi personalizzati nel registro dell'applicazione Managed Service for Apache Flink. CloudWatch Puoi farlo utilizzando la libreria [https://logging.apache.org/log4j/](https://logging.apache.org/log4j/) di Apache o la libreria [https://www.slf4j.org/](https://www.slf4j.org/).
**Topics**
+ [Scrivi nei CloudWatch log usando Log4J](#cloudwatch-logs-writing-log4j)
+ [Scrivi nei log usando CloudWatch J SLF4](#cloudwatch-logs-writing-slf4j)
## Scrivi nei CloudWatch log usando Log4J
1. Aggiungi le dipendenze seguenti al file `pom.xml` dell'applicazione:
```
org.apache.logging.log4j
log4j-api
2.6.1
org.apache.logging.log4j
log4j-core
2.6.1
```
1. Includi l'oggetto dalla libreria:
```
import org.apache.logging.log4j.Logger;
```
1. Crea un'istanza dell'oggetto `Logger`, inserendo la classe dell'applicazione:
```
private static final Logger log = LogManager.getLogger.getLogger(YourApplicationClass.class);
```
1. Scrivi nel log utilizzando `log.info`. Un gran numero di messaggi viene scritto nel log dell'applicazione. Per rendere i messaggi personalizzati più facili da filtrare, utilizza il livello di log `INFO` dell'applicazione.
```
log.info("This message will be written to the application's CloudWatch log");
```
L'applicazione scrive un record nel log con un messaggio simile al seguente:
```
{
"locationInformation": "com.amazonaws.services.managed-flink.StreamingJob.main(StreamingJob.java:95)",
"logger": "com.amazonaws.services.managed-flink.StreamingJob",
"message": "This message will be written to the application's CloudWatch log",
"threadName": "Flink-DispatcherRestEndpoint-thread-2",
"applicationARN": "arn:aws:kinesisanalyticsus-east-1:123456789012:application/test",
"applicationVersionId": "1", "messageSchemaVersion": "1",
"messageType": "INFO"
}
```
## Scrivi nei log usando CloudWatch J SLF4
1. Aggiungi le dipendenze seguenti al file `pom.xml` dell'applicazione:
```
org.slf4j
slf4j-log4j12
1.7.7
runtime
```
1. Includi gli oggetti della libreria:
```
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
```
1. Crea un'istanza dell'oggetto `Logger`, inserendo la classe dell'applicazione:
```
private static final Logger log = LoggerFactory.getLogger(YourApplicationClass.class);
```
1. Scrivi nel log utilizzando `log.info`. Un gran numero di messaggi viene scritto nel log dell'applicazione. Per rendere i messaggi personalizzati più facili da filtrare, utilizza il livello di log `INFO` dell'applicazione.
```
log.info("This message will be written to the application's CloudWatch log");
```
L'applicazione scrive un record nel log con un messaggio simile al seguente:
```
{
"locationInformation": "com.amazonaws.services.managed-flink.StreamingJob.main(StreamingJob.java:95)",
"logger": "com.amazonaws.services.managed-flink.StreamingJob",
"message": "This message will be written to the application's CloudWatch log",
"threadName": "Flink-DispatcherRestEndpoint-thread-2",
"applicationARN": "arn:aws:kinesisanalyticsus-east-1:123456789012:application/test",
"applicationVersionId": "1", "messageSchemaVersion": "1",
"messageType": "INFO"
}
```
# Registra il servizio gestito per le chiamate API Apache Flink con AWS CloudTrail
Il servizio gestito per Apache Flink è integrato con AWS CloudTrail, un servizio che fornisce un registro delle azioni intraprese da un utente, ruolo o un AWS servizio in Managed Service for Apache Flink. CloudTrail acquisisce tutte le chiamate API per Managed Service for Apache Flink come eventi. Le chiamate acquisite includono le chiamate dalla console del servizio gestito per Apache Flink e le chiamate di codice al servizio gestito per le operazioni dell'API del servizio gestito per Apache Flink. Se crei un trail, puoi abilitare la distribuzione continua di CloudTrail eventi a un bucket Amazon S3, inclusi gli eventi per Managed Service for Apache Flink. **Se non configuri un percorso, puoi comunque visualizzare gli eventi più recenti nella CloudTrail console nella cronologia degli eventi.** Utilizzando le informazioni raccolte da CloudTrail, è possibile determinare la richiesta effettuata a Managed Service for Apache Flink, l'indirizzo IP da cui è stata effettuata la richiesta, chi ha effettuato la richiesta, quando è stata effettuata e dettagli aggiuntivi.
Per ulteriori informazioni CloudTrail, consulta la Guida per l'[AWS CloudTrail utente](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
## Informazioni su Managed Service for Apache Flink in CloudTrail
CloudTrail è abilitato sul tuo AWS account al momento della creazione dell'account. **Quando si verifica un'attività in Managed Service for Apache Flink, tale attività viene registrata in un CloudTrail evento insieme ad altri eventi di AWS servizio nella cronologia degli eventi.** Puoi visualizzare, cercare e scaricare gli eventi recenti nel tuo AWS account. Per ulteriori informazioni, consulta [Visualizzazione degli eventi con la cronologia degli CloudTrail eventi](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html).
Per una registrazione continua degli eventi nel tuo AWS account, inclusi gli eventi per Managed Service for Apache Flink, crea un percorso. Un *trail* consente di CloudTrail inviare file di log a un bucket Amazon S3. Per impostazione predefinita, quando crei un percorso nella console, il percorso si applica a tutte le AWS regioni. Il trail registra gli eventi di tutte le regioni della AWS partizione e consegna i file di log al bucket Amazon S3 specificato. Inoltre, puoi configurare altri AWS servizi per analizzare ulteriormente e agire in base ai dati sugli eventi raccolti nei log. CloudTrail Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Panoramica della creazione di un trail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [CloudTrail Servizi e integrazioni supportati](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations)
+ [Configurazione delle notifiche Amazon SNS per CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html)
+ [Ricezione di file di CloudTrail registro da più regioni](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html) e [ricezione di file di CloudTrail registro da](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html) più account
Tutte le azioni di Managed Service for Apache Flink vengono registrate CloudTrail e documentate nel riferimento all'API [Managed Service for Apache](/managed-flink/latest/apiv2/Welcome.html) Flink. Ad esempio, le chiamate alle ` [UpdateApplication](/managed-flink/latest/apiv2/API_UpdateApplication.html)` azioni `[CreateApplication](/managed-flink/latest/apiv2/API_CreateApplication.html)` e generano voci nei file di registro. CloudTrail
Ogni evento o voce di log contiene informazioni sull’utente che ha generato la richiesta. Le informazioni di identità consentono di determinare quanto segue:
+ Se la richiesta è stata effettuata con credenziali utente root o AWS Identity and Access Management (IAM).
+ Se la richiesta è stata effettuata con le credenziali di sicurezza temporanee per un ruolo o un utente federato.
+ Se la richiesta è stata effettuata da un altro AWS servizio.
Per ulteriori informazioni, consulta [Elemento CloudTrail userIdentity](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html).
## Comprendi le voci dei file di registro di Managed Service for Apache Flink
Un trail è una configurazione che consente la distribuzione di eventi come file di log in un bucket Amazon S3 specificato dall'utente. CloudTrail i file di registro contengono una o più voci di registro. Un evento rappresenta una singola richiesta proveniente da qualsiasi fonte e include informazioni sull'azione richiesta, la data e l'ora dell'azione, i parametri della richiesta e così via. CloudTrail i file di registro non sono una traccia ordinata dello stack delle chiamate API pubbliche, quindi non vengono visualizzati in un ordine specifico.
L'esempio seguente mostra una voce di CloudTrail registro che illustra le azioni [AddApplicationCloudWatchLoggingOption](/managed-flink/latest/apiv2/API_AddApplicationCloudWatchLoggingOption.html)e [DescribeApplication](/managed-flink/latest/apiv2/API_DescribeApplication.html).
```
{
"Records": [
{
"eventVersion": "1.05",
"userIdentity": {
"type": "IAMUser",
"principalId": "EX_PRINCIPAL_ID",
"arn": "arn:aws:iam::012345678910:user/Alice",
"accountId": "012345678910",
"accessKeyId": "EXAMPLE_KEY_ID",
"userName": "Alice"
},
"eventTime": "2019-03-07T01:19:47Z",
"eventSource": "kinesisanlaytics.amazonaws.com",
"eventName": "AddApplicationCloudWatchLoggingOption",
"awsRegion": "us-east-1",
"sourceIPAddress": "127.0.0.1",
"userAgent": "aws-sdk-java/unknown-version Linux/x.xx",
"requestParameters": {
"applicationName": "cloudtrail-test",
"currentApplicationVersionId": 1,
"cloudWatchLoggingOption": {
"logStreamARN": "arn:aws:logs:us-east-1:012345678910:log-group:cloudtrail-test:log-stream:flink-cloudwatch"
}
},
"responseElements": {
"cloudWatchLoggingOptionDescriptions": [
{
"cloudWatchLoggingOptionId": "2.1",
"logStreamARN": "arn:aws:logs:us-east-1:012345678910:log-group:cloudtrail-test:log-stream:flink-cloudwatch"
}
],
"applicationVersionId": 2,
"applicationARN": "arn:aws:kinesisanalyticsus-east-1:012345678910:application/cloudtrail-test"
},
"requestID": "18dfb315-4077-11e9-afd3-67f7af21e34f",
"eventID": "d3c9e467-db1d-4cab-a628-c21258385124",
"eventType": "AwsApiCall",
"apiVersion": "2018-05-23",
"recipientAccountId": "012345678910"
},
{
"eventVersion": "1.05",
"userIdentity": {
"type": "IAMUser",
"principalId": "EX_PRINCIPAL_ID",
"arn": "arn:aws:iam::012345678910:user/Alice",
"accountId": "012345678910",
"accessKeyId": "EXAMPLE_KEY_ID",
"userName": "Alice"
},
"eventTime": "2019-03-12T02:40:48Z",
"eventSource": "kinesisanlaytics.amazonaws.com",
"eventName": "DescribeApplication",
"awsRegion": "us-east-1",
"sourceIPAddress": "127.0.0.1",
"userAgent": "aws-sdk-java/unknown-version Linux/x.xx",
"requestParameters": {
"applicationName": "sample-app"
},
"responseElements": null,
"requestID": "3e82dc3e-4470-11e9-9d01-e789c4e9a3ca",
"eventID": "90ffe8e4-9e47-48c9-84e1-4f2d427d98a5",
"eventType": "AwsApiCall",
"apiVersion": "2018-05-23",
"recipientAccountId": "012345678910"
}
]
}
```