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

# Usa metriche personalizzate con Amazon Managed Service per Apache Flink
<a name="monitoring-metrics-custom"></a>

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
<a name="monitoring-metrics-custom-howitworks"></a>

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
<a name="monitoring-metrics-custom-examples"></a>

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)
<a name="monitoring-metrics-custom-examples-recordcount"></a>

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<String, String> {
        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<Integer>) () -> 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<String> 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
<a name="monitoring-metrics-custom-examples-wordcount"></a>

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<String, Tuple2<String, Integer>> {
     
            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<Tuple2<String, Integer>>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<Tuple2<String, Integer>> 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
<a name="monitoring-metrics-custom-examples-viewing"></a>

Le metriche personalizzate per la tua applicazione vengono visualizzate nella console CloudWatch Metrics nella **AWS/KinesisAnalytics**dashboard, nel gruppo di metriche dell'**applicazione**.