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à. # Incorporamento dei parametri nei log Incorporamento dei parametri nei log Il formato metrico CloudWatch incorporato consente di generare metriche personalizzate in modo asincrono sotto forma di log scritti in Logs. CloudWatch Puoi incorporare metriche personalizzate insieme a dati dettagliati sugli eventi di registro ed estrarre CloudWatch automaticamente le metriche personalizzate in modo da poterle visualizzare e generare allarmi in base a esse, per il rilevamento degli incidenti in tempo reale. Inoltre, gli eventi di registro dettagliati associati alle metriche estratte possono essere interrogati utilizzando CloudWatch Logs Insights per fornire informazioni approfondite sulle cause principali degli eventi operativi. Il formato dei parametri incorporati consente di generare parametri personalizzati concreti a partire da risorse effimere ad esempio le funzioni Lambda e i container. Utilizzando Embedded Metric Format per inviare log da queste risorse effimere, potrai ora creare facilmente parametri personalizzati senza doverti dotare di strumenti o mantenere codice separato, ottenendo allo stesso tempo potenti funzionalità analitiche sui dati di log. Non è richiesta alcuna configurazione per utilizzare il formato dei parametri incorporati. [https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html) Per generare metriche dai log con Embedded Metric Format, è necessaria l'autorizzazione `logs:PutLogEvents`, ma non è necessario disporre anche dell'autorizzazione `cloudwatch:PutMetricData`. Per l'acquisizione e l'archiviazione di log viene addebitato un costo e vengono generati parametri personalizzati. Per ulteriori informazioni, consulta [Prezzi di Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing). **Nota** Fai attenzione durante la configurazione dell'estrazione dei parametri poiché influenza l'utilizzo di parametri personalizzati e l'addebito corrispondente. Se crei involontariamente delle metriche basate su dimensioni ad alta cardinalità (ad esempio `requestId`), Embedded Metric Format creerà per impostazione predefinita una metrica personalizzata corrispondente a ogni combinazione di dimensione univoca. Per ulteriori informazioni, consulta [Dimensioni](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html#Dimension). I seguenti argomenti descrivono come pubblicare i log utilizzando Embedded Metric Format, visualizzare le metriche e i log nella console e impostare allarmi sulle metriche create con Embedded Metric Format. **Topics** + [ # Pubblicazione di log con il formato dei parametri incorporati ](CloudWatch_Embedded_Metric_Format_Generation.md) + [ # Visualizzazione dei parametri e dei log nella console ](CloudWatch_Embedded_Metric_Format_View.md) + [ # Impostazione degli allarmi sui parametri creati con il formato dei parametri incorporati ](CloudWatch_Embedded_Metric_Format_Alarms.md) # Pubblicazione di log con il formato dei parametri incorporati Puoi generare log in Embedded Metric Format con i seguenti metodi: + Genera e invia i log utilizzando le [librerie client open-source](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format_Libraries.html). + Genera manualmente i log utilizzando la [specifica del formato metrico incorporato](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format_Specification.html), quindi utilizza l'[CloudWatch agente](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format_Generation_CloudWatch_Agent.html) o l'[PutLogEvents API](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html) per inviare i log. Nei seguenti argomenti vengono fornite ulteriori informazioni sulle metriche embedded. **Topics** + [ # Creazione di log in formato dei parametri incorporati utilizzando le librerie client ](CloudWatch_Embedded_Metric_Format_Libraries.md) + [ # Specifica: Embedded Metric Format ](CloudWatch_Embedded_Metric_Format_Specification.md) + [ # Utilizzo dell' PutLogEvents API per inviare log in formato metrico incorporato creati manualmente ](CloudWatch_Embedded_Metric_Format_Generation_PutLogEvents.md) + [ # Utilizzo dell' CloudWatch agente per inviare log in formato metrico incorporato ](CloudWatch_Embedded_Metric_Format_Generation_CloudWatch_Agent.md) + [ # Utilizzo del formato metrico incorporato con AWS Distro per OpenTelemetry ](CloudWatch_Embedded_Metric_Format_OpenTelemetry.md) # Creazione di log in formato dei parametri incorporati utilizzando le librerie client Utilizzo di librerie client Puoi utilizzare le librerie client open-source fornite da Amazon per creare log in Embedded Metric Format. Esempi completi per diverse configurazioni sono disponibili nelle nostre librerie client in **/examples**. Le librerie e le istruzioni su come usarle si trovano su Github. + [Node.Js](https://github.com/awslabs/aws-embedded-metrics-node) **Nota** Per Node.js, per l'uso con il formato di log JSON Lambda sono richieste le versioni 4.1.1 e successive, 3.0.2 e successive, 2.0.7 e successive. L'utilizzo di versioni precedenti in tali ambienti Lambda comporterà una perdita di parametri. Per ulteriori informazioni, consulta [Accedere ai CloudWatch log di Amazon per AWS Lambda.](https://docs.aws.amazon.com/lambda/latest/dg/monitoring-cloudwatchlogs.html) + [Python](https://github.com/awslabs/aws-embedded-metrics-python) + [Java](https://github.com/awslabs/aws-embedded-metrics-java) + [C\$1](https://github.com/awslabs/aws-embedded-metrics-dotnet) Le librerie client sono pensate per funzionare immediatamente con l' CloudWatch agente. I log generati in formato metrico incorporato vengono inviati all' CloudWatch agente, che quindi li aggrega CloudWatch e li pubblica in Logs for you. **Nota** Quando si utilizza Lambda, non è necessario alcun agente a cui inviare i log. CloudWatch Tutto ciò che viene registrato su STDOUT viene inviato ai CloudWatch registri tramite il Lambda Logging Agent. # Specifica: Embedded Metric Format Il formato metrico CloudWatch incorporato è una specifica JSON utilizzata per indicare ai CloudWatch log di estrarre automaticamente i valori delle metriche incorporati negli eventi di registro strutturati. È possibile utilizzarlo CloudWatch per rappresentare graficamente e creare allarmi sui valori metrici estratti. Questa sezione descrive le convenzioni relative alle specifiche di Embedded Metric Format e la struttura del documento in Embedded Metric Format. ## Convenzioni specifiche di Embedded Metric Format Convenzioni [Le parole chiave «DEVE», «NON DEVE», «RICHIESTO», «DEVE», «NON DEVE», «DOVREBBE», «NON DOVREBBE», «CONSIGLIATO», «PUÒ» e «OPZIONALE» in questa specifica di formato devono essere interpretate come descritto in Parole chiave. RFC2119](http://tools.ietf.org/html/rfc2119) I termini «JSON», «testo JSON», «valore JSON», «member», «element», «object», «array», «number», «string», «boolean», «true», «false» e «null» in questa specifica di formato devono essere interpretati come definito in [JavaScript Object Notation RFC8259](https://tools.ietf.org/html/rfc8259). **Nota** Se prevedi di creare allarmi su parametri creati utilizzando il formato dei parametri incorporati, consulta [Impostazione degli allarmi sui parametri creati con il formato dei parametri incorporati](CloudWatch_Embedded_Metric_Format_Alarms.md) per ottenere dei suggerimenti. ## Struttura del documento in Embedded Metric Format Struttura del documento in Embedded Metric Format In questa sezione viene descritta la struttura di un documento in formato del parametro integrato. [I documenti in formato metrico incorporato sono definiti in Object Notation. JavaScript RFC8259](https://tools.ietf.org/html/rfc8259) Salvo ove diversamente specificato, gli oggetti definiti da questa specifica NON DEVONO contenere alcun membro aggiuntivo. I membri non riconosciuti da questa specifica DEVONO essere ignorati. I membri definiti in questa specifica rispettano la distinzione tra maiuscole e minuscole. Il formato metrico incorporato è soggetto agli stessi limiti degli eventi CloudWatch Logs standard e ha una dimensione massima di 1 MB. Con la specifica Embedded Metric Format, puoi tenere traccia dell'elaborazione dei registri EMF in base ai parametri pubblicati nello spazio dei nomi `AWS/Logs` del tuo account. Questi possono essere utilizzati per tenere traccia della generazione di parametri con esito negativo per EMF e per verificare se gli errori sono dovuti all'analisi o alla convalida. Per maggiori dettagli, consulta [Monitoraggio con metriche CloudWatch ](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Monitoring-CloudWatch-Metrics.html). ### Nodo radice Nodo radice Il LogEvent messaggio DEVE essere un oggetto JSON valido senza dati aggiuntivi all'inizio o alla fine della stringa del LogEvent messaggio. Per ulteriori informazioni sulla LogEvent struttura, vedere [InputLogEvent](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_InputLogEvent.html). I documenti in Embedded Metric Format DEVONO contenere il seguente membro di primo livello sul nodo principale. Questo è un oggetto [Oggetto metadati](#CloudWatch_Embedded_Metric_Format_Specification_structure_metadata). ``` { "_aws": { "CloudWatchMetrics": [ ... ] } } ``` Il nodo principale DEVE contenere tutti i membri [Membri di destinazione](#CloudWatch_Embedded_Metric_Format_Specification_structure_target) definiti dai riferimenti nel [MetricDirective oggetto](#CloudWatch_Embedded_Metric_Format_Specification_structure_metricdirective). Il nodo principale PUÒ contenere tutti gli altri membri che non sono inclusi nei requisiti precedenti. I valori di questi membri DEVONO essere tipi JSON validi. ### Oggetto metadati Oggetto metadati Il `_aws` membro può essere utilizzato per rappresentare i metadati relativi al payload che indicano ai servizi a valle come devono elaborare il. LogEvent Il valore DEVE essere un oggetto e DEVE contenere i seguenti membri: + **CloudWatchMetrics**— Una matrice [MetricDirective oggetto](#CloudWatch_Embedded_Metric_Format_Specification_structure_metricdirective) utilizzata per indicare di estrarre CloudWatch le metriche dal nodo radice di. LogEvent ``` { "_aws": { "CloudWatchMetrics": [ ... ] } } ``` + **Time stamp** Un numero che rappresenta la marca temporale usata per i parametri estratti dall'evento. I valori DEVONO essere espressi come il numero di millisecondi dopo il 1 gennaio 1970 00:00:00 UTC. ``` { "_aws": { "Timestamp": 1559748430481 } } ``` ### MetricDirective oggetto MetricDirective oggetto L' MetricDirective oggetto indica ai servizi a valle che LogEvent contengono le metriche su cui verranno estratte e pubblicate. CloudWatch MetricDirectives DEVE contenere i seguenti membri: + **Namespace**: una stringa che rappresenta lo spazio dei CloudWatch nomi per la metrica. + **Dimensioni** Un [DimensionSet matrice](#CloudWatch_Embedded_Metric_Format_Specification_structure_dimensionset). + **Parametri** Una matrice di oggetti [MetricDefinition oggetto](#CloudWatch_Embedded_Metric_Format_Specification_structure_metricdefinition). Questo array NON DEVE contenere più di 100 oggetti. MetricDefinition ### DimensionSet matrice DimensionSet matrice A DimensionSet è una matrice di stringhe contenente le chiavi di dimensione che verranno applicate a tutte le metriche del documento. I valori all'interno di questa matrice DEVONO anche essere membri del nodo principale, definiti come [Membri di destinazione](#CloudWatch_Embedded_Metric_Format_Specification_structure_target) A NON DimensionSet DEVE contenere più di 30 chiavi dimensionali. A DimensionSet PUÒ essere vuoto. Il membro di destinazione DEVE avere un valore stringa. Questo valore NON DEVE contenere più di 1024 caratteri. Il membro di destinazione definisce una dimensione che verrà pubblicata nell'identità del parametro. Ogni DimensionSet elemento utilizzato crea una nuova metrica in CloudWatch. Per ulteriori informazioni sulle dimensioni, consulta [Dimensione](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_Dimension.html) e [Dimensioni](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html#Dimension). ``` { "_aws": { "CloudWatchMetrics": [ { "Dimensions": [ [ "functionVersion" ] ], ... } ] }, "functionVersion": "$LATEST" } ``` **Nota** Fai attenzione durante la configurazione dell'estrazione dei parametri poiché influenza l'utilizzo di parametri personalizzati e l'addebito corrispondente. Se crei involontariamente delle metriche basate su dimensioni ad alta cardinalità (ad esempio `requestId`), Embedded Metric Format creerà per impostazione predefinita una metrica personalizzata corrispondente a ogni combinazione di dimensione univoca. Per ulteriori informazioni, consulta [Dimensioni](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html#Dimension). ### MetricDefinition oggetto MetricDefinition oggetto A MetricDefinition è un oggetto che DEVE contenere il seguente membro: + **Nome** Una stringa [Valori di riferimento](#CloudWatch_Embedded_Metric_Format_Specification_structure_referencevalues) in un parametro [Membri di destinazione](#CloudWatch_Embedded_Metric_Format_Specification_structure_target). Le destinazioni parametro DEVONO essere un valore numerico o una matrice di valori numerici. Un MetricDefinition oggetto PUÒ contenere i seguenti membri: + **Unità** Un valore stringa OPZIONALE che rappresenta l'unità di misura per il parametro corrispondente. I valori DEVONO essere unità CloudWatch metriche valide. Per informazioni sulle unità valide, vedere [MetricDatum](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDatum.html). Se non viene fornito un valore, viene assunto il valore predefinito NONE. + **StorageResolution**— Un valore intero OPZIONALE che rappresenta la risoluzione di archiviazione per la metrica corrispondente. Se si imposta questo valore su 1, questa metrica viene specificata come metrica ad alta risoluzione, in modo che la metrica con una risoluzione inferiore al minuto CloudWatch venga memorizzata fino a un secondo. L'impostazione di questo valore su 60 specifica questa metrica come risoluzione standard, che viene memorizzata a una risoluzione di 1 minuto. CloudWatch I valori DEVONO essere risoluzioni CloudWatch supportate valide, 1 o 60. Se non viene fornito un valore, viene assunto il valore predefinito 60. Per ulteriori informazioni sui parametri ad alta risoluzione, consulta [Parametri ad alta risoluzione](publishingMetrics.md#high-resolution-metrics). **Nota** Se prevedi di creare allarmi su parametri creati utilizzando il formato dei parametri incorporati, consulta [Impostazione degli allarmi sui parametri creati con il formato dei parametri incorporati](CloudWatch_Embedded_Metric_Format_Alarms.md) per ottenere dei suggerimenti. ``` { "_aws": { "CloudWatchMetrics": [ { "Metrics": [ { "Name": "Time", "Unit": "Milliseconds", "StorageResolution": 60 } ], ... } ] }, "Time": 1 } ``` ### Valori di riferimento Valori di riferimento I valori di riferimento sono valori stringa che fanno riferimento ai membri [Membri di destinazione](#CloudWatch_Embedded_Metric_Format_Specification_structure_target) del nodo principale. Questi riferimenti NON devono essere confusi con i puntatori JSON descritti in. [RFC6901](https://tools.ietf.org/html/rfc6901) I valori di destinazione non possono essere nidificati. ### Membri di destinazione Membri di destinazione Destinazioni valide DEVONO essere membri del nodo principale e non possono essere oggetti nidificati. Ad esempio, a \$1reference\$1 value di `"A.a"` DEVE corrispondere al seguente membro: ``` { "A.a" } ``` NON DEVE corrispondere al membro nidificato: ``` { "A": { "a" } } ``` I valori validi dei membri di destinazione dipendono da ciò che vi fa riferimento. Una destinazione parametro DEVE essere un valore numerico o una matrice di valori numerici. Le destinazioni di parametro di matrice numerica NON DEVONO avere più di 100 membri. Una destinazione di dimensione DEVE avere un valore stringa. ### Esempio di Embedded Metric Format e schema JSON Esempio e schema JSON Di seguito è riportato un esempio valido di Embedded Metric Format. ``` { "_aws": { "Timestamp": 1574109732004, "CloudWatchMetrics": [ { "Namespace": "lambda-function-metrics", "Dimensions": [["functionVersion"]], "Metrics": [ { "Name": "time", "Unit": "Milliseconds", "StorageResolution": 60 } ] } ] }, "functionVersion": "$LATEST", "time": 100, "requestId": "989ffbf8-9ace-4817-a57c-e4dd734019ee" } ``` Puoi utilizzare lo schema seguente per convalidare i documenti in Embedded Metric Format. ``` { "type": "object", "title": "Root Node", "required": [ "_aws" ], "properties": { "_aws": { "$id": "#/properties/_aws", "type": "object", "title": "Metadata", "required": [ "Timestamp", "CloudWatchMetrics" ], "properties": { "Timestamp": { "$id": "#/properties/_aws/properties/Timestamp", "type": "integer", "title": "The Timestamp Schema", "examples": [ 1565375354953 ] }, "CloudWatchMetrics": { "$id": "#/properties/_aws/properties/CloudWatchMetrics", "type": "array", "title": "MetricDirectives", "items": { "$id": "#/properties/_aws/properties/CloudWatchMetrics/items", "type": "object", "title": "MetricDirective", "required": [ "Namespace", "Dimensions", "Metrics" ], "properties": { "Namespace": { "$id": "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Namespace", "type": "string", "title": "CloudWatch Metrics Namespace", "examples": [ "MyApp" ], "pattern": "^(.*)$", "minLength": 1, "maxLength": 1024 }, "Dimensions": { "$id": "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Dimensions", "type": "array", "title": "The Dimensions Schema", "minItems": 1, "items": { "$id": "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Dimensions/items", "type": "array", "title": "DimensionSet", "minItems": 0, "maxItems": 30, "items": { "$id": "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Dimensions/items/items", "type": "string", "title": "DimensionReference", "examples": [ "Operation" ], "pattern": "^(.*)$", "minLength": 1, "maxLength": 250 } } }, "Metrics": { "$id": "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Metrics", "type": "array", "title": "MetricDefinitions", "items": { "$id": "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Metrics/items", "type": "object", "title": "MetricDefinition", "required": [ "Name" ], "properties": { "Name": { "$id": "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Metrics/items/properties/Name", "type": "string", "title": "MetricName", "examples": [ "ProcessingLatency" ], "pattern": "^(.*)$", "minLength": 1, "maxLength": 1024 }, "Unit": { "$id": "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Metrics/items/properties/Unit", "type": "string", "title": "MetricUnit", "examples": [ "Milliseconds" ], "pattern": "^(Seconds|Microseconds|Milliseconds|Bytes|Kilobytes|Megabytes|Gigabytes|Terabytes|Bits|Kilobits|Megabits|Gigabits|Terabits|Percent|Count|Bytes\\/Second|Kilobytes\\/Second|Megabytes\\/Second|Gigabytes\\/Second|Terabytes\\/Second|Bits\\/Second|Kilobits\\/Second|Megabits\\/Second|Gigabits\\/Second|Terabits\\/Second|Count\\/Second|None)$" }, "StorageResolution": { "$id": "#/properties/_aws/properties/CloudWatchMetrics/items/properties/Metrics/items/properties/StorageResolution", "type": "integer", "title": "StorageResolution", "examples": [ 60 ] } } } } } } } } } } } ``` ## Informazioni sulle entità in formato EMF Quando pubblichi i log su Amazon CloudWatch utilizzando Embedded Metric Format (EMF), puoi includere informazioni sull'entità nell'evento di registro. Questa sezione descrive come specificare le informazioni sull'entità e come le CloudWatch elabora. ### Tipi di entità Quando nella `PutLogEvents` richiesta non viene specificata alcuna entità, CloudWatch cercherà le informazioni sull'entità nel contenuto del registro EMF: + **Entità di tipo servizio** Campi obbligatori: `Service` e `Environment` + **Entità di tipo risorsa** Campi obbligatori: `ResourceType` e `Identifier` ### Attributi della piattaforma CloudWatch determina automaticamente il tipo di piattaforma in base a questi attributi: + **Kubernetes (K8s):** Obbligatorio: `K8s.Cluster` Facoltativo: `K8s.Namespace``K8s.Workload`,`K8s.Node`,`K8s.Pod`,`EC2.InstanceId`, `EC2.AutoScalingGroup` + **Amazon EKS** Obbligatorio: `EKS.Cluster` Facoltativo: `K8s.Namespace``K8s.Workload`,`K8s.Node`,`K8s.Pod`, `EC2.InstanceId` + **Amazon ECS:** Obbligatorio: `ECS.Cluster` Opzionale:`ECS.Service`, `ECS.Task` + **Amazon EC2** Obbligatorio: `EC2.InstanceId` Facoltativo: `EC2.AutoScalingGroup` + **Lambda:** Obbligatorio: `Lambda.Function` + **Host generici:** Obbligatorio: `Host` ### Formato di log EMF di esempio ``` { "_aws": { "CloudWatchMetrics": [ { "Metrics": [ {"Name": "RequestLatency", "Unit": "Milliseconds"} ], "Namespace": "MyApplication" } ] }, "Service": "PaymentService", "Environment": "Production", "K8s.Cluster": "main-cluster", "K8s.Namespace": "payment-ns", "K8s.Pod": "payment-pod-123", "K8s.Node": "worker-node-1", "K8s.Workload": "payment-deployment", "RequestLatency": 135.5, "timestamp": 1622163600000 } ``` ### Entità generata Il log EMF sopra riportato genererà la seguente entità: ``` { "KeyAttributes": { "Type": "Service", "Name": "PaymentService", "Environment": "Production" }, "Attributes": { "PlatformType": "K8s", "K8s.Cluster": "main-cluster", "K8s.Namespace": "payment-ns", "K8s.Pod": "payment-pod-123", "K8s.Node": "worker-node-1", "K8s.Workload": "payment-deployment" } } ``` ### Elaborazione dell'entità CloudWatch elabora le informazioni sull'entità come segue: + **KeyAttributes:** + Determina il tipo di entità in base ai campi obbligatori + Per Service-type, estrae il nome del servizio e l'ambiente + Questi diventano gli identificativi principali dell'entità + **Attributi**: + Set PlatformType basati sugli attributi della piattaforma inclusi + Include tutte le informazioni pertinenti specifiche della piattaforma + Mantiene il contesto relazionale per i dati di telemetria CloudWatch utilizza queste informazioni sull'entità per stabilire relazioni tra diversi dati di telemetria, migliorando l'osservabilità e l'analisi contestuale delle applicazioni e dell'infrastruttura. Per ulteriori informazioni, vedere [Come aggiungere informazioni correlate alla telemetria personalizzata inviata a](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/adding-your-own-related-telemetry.html). CloudWatch **Nota** Le informazioni sulle entità aiutano a CloudWatch creare un quadro completo dei dati di telemetria dell'applicazione e delle relative relazioni all'interno dell'infrastruttura. # Utilizzo dell' PutLogEvents API per inviare log in formato metrico incorporato creati manualmente Puoi inviare log in formato metrico incorporato a Logs utilizzando l' CloudWatch CloudWatch API Logs. [PutLogEvents](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html) Quando chiami PutLogEvents, hai la possibilità di includere la seguente intestazione HTTP, che indica a CloudWatch Logs che le metriche devono essere estratte, ma non è obbligatoria. ``` x-amzn-logs-format: json/emf ``` Di seguito è riportato un esempio completo di utilizzo dell' AWS SDK for Java 2.x: ``` package org.example.basicapp; import software.amazon.awssdk.regions.Region; import software.amazon.awssdk.services.cloudwatchlogs.CloudWatchLogsClient; import software.amazon.awssdk.services.cloudwatchlogs.model.DescribeLogStreamsRequest; import software.amazon.awssdk.services.cloudwatchlogs.model.DescribeLogStreamsResponse; import software.amazon.awssdk.services.cloudwatchlogs.model.InputLogEvent; import software.amazon.awssdk.services.cloudwatchlogs.model.PutLogEventsRequest; import java.util.Collections; public class EmbeddedMetricsExample { public static void main(String[] args) { final String usage = "To run this example, supply a Region code (eg. us-east-1), log group, and stream name as command line arguments" + "Ex: PutLogEvents "; if (args.length != 3) { System.out.println(usage); System.exit(1); } String regionId = args[0]; String logGroupName = args[1]; String logStreamName = args[2]; CloudWatchLogsClient logsClient = CloudWatchLogsClient.builder().region(Region.of(regionId)).build(); // Build a JSON log using the EmbeddedMetricFormat. long timestamp = System.currentTimeMillis(); String message = "{" + " \"_aws\": {" + " \"Timestamp\": " + timestamp + "," + " \"CloudWatchMetrics\": [" + " {" + " \"Namespace\": \"MyApp\"," + " \"Dimensions\": [[\"Operation\"], [\"Operation\", \"Cell\"]]," + " \"Metrics\": [{ \"Name\": \"ProcessingLatency\", \"Unit\": \"Milliseconds\", \"StorageResolution\": 60 }]" + " }" + " ]" + " }," + " \"Operation\": \"Aggregator\"," + " \"Cell\": \"001\"," + " \"ProcessingLatency\": 100" + "}"; InputLogEvent inputLogEvent = InputLogEvent.builder() .message(message) .timestamp(timestamp) .build(); // Specify the request parameters. PutLogEventsRequest putLogEventsRequest = PutLogEventsRequest.builder() .logEvents(Collections.singletonList(inputLogEvent)) .logGroupName(logGroupName) .logStreamName(logStreamName) .build(); logsClient.putLogEvents(putLogEventsRequest); System.out.println("Successfully put CloudWatch log event"); } } ``` **Nota** Con la specifica Embedded Metric Format, puoi tenere traccia dell'elaborazione dei registri EMF in base ai parametri pubblicati nello spazio dei nomi `AWS/Logs` del tuo account. Questi possono essere utilizzati per tenere traccia della generazione di parametri con esito negativo per EMF e per verificare se gli errori sono dovuti all'analisi o alla convalida. Per maggiori dettagli, consulta [Monitoraggio con metriche CloudWatch ](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Monitoring-CloudWatch-Metrics.html). # Utilizzo dell' CloudWatch agente per inviare log in formato metrico incorporato Questa sezione descrive come installare e utilizzare l' CloudWatch agente. La prima parte di questa sezione descrive come installare l' CloudWatch agente. La seconda parte di questa sezione descrive come utilizzare l' CloudWatch agente per inviare log in formato metrico incorporato. Se si desidera utilizzare questo metodo, è necessario installare l' CloudWatch agente dal quale Servizi AWS si desidera inviare i log in formato metrico incorporato. Dopodiché puoi iniziare a inviare gli eventi. L' CloudWatch agente deve avere la versione 1.230621.0 o successiva. **Nota** Non è necessario installare l' CloudWatch agente per inviare i log dalle funzioni Lambda. I timeout della funzione Lambda non vengono gestiti automaticamente. Ciò significa che se la funzione scade prima che i parametri vengano scaricati, i parametri per tale chiamata non verranno acquisiti. ## Installazione dell'agente CloudWatch Installazione dell' CloudWatch agente Installa l' CloudWatch agente per ogni servizio che deve inviare log in formato metrico incorporato. ### Installazione dell' CloudWatch agente su EC2 Innanzitutto, installa l' CloudWatch agente sull'istanza. Per ulteriori informazioni, consulta [Installazione dell'agente CloudWatch](install-CloudWatch-Agent-on-EC2-Instance.md). Dopo aver installato l'agente, configura l'agente per l'ascolto su una porta UDP o TCP dei in log Embedded Metric Format. Di seguito è riportato un esempio di questa configurazione che rimane in ascolto sul socket predefinito `tcp:25888`. Per ulteriori informazioni sulla configurazione dell'agente, consulta [Crea o modifica manualmente il file di configurazione CloudWatch dell'agente](CloudWatch-Agent-Configuration-File-Details.md). ``` { "logs": { "metrics_collected": { "emf": { } } } } ``` ### Installazione dell' CloudWatch agente su Amazon ECS Il modo più semplice per distribuire l' CloudWatch agente su Amazon ECS è eseguirlo come sidecar, definendolo nella stessa definizione di attività dell'applicazione. **Creazione del file di configurazione dell'agente** Crea il file di configurazione CloudWatch dell'agente localmente. In questo esempio, il percorso file relativo sarà `amazon-cloudwatch-agent.json`. Per ulteriori informazioni sulla configurazione dell'agente, consulta [Crea o modifica manualmente il file di configurazione CloudWatch dell'agente](CloudWatch-Agent-Configuration-File-Details.md). ``` { "logs": { "metrics_collected": { "emf": { } } } } ``` **Configurazione push in SSM Parameter Store** Immettere il seguente comando per inviare il file di configurazione dell' CloudWatch agente all'archivio dei parametri di AWS Systems Manager (SSM). ``` aws ssm put-parameter \ --name "cwagentconfig" \ --type "String" \ --value "`cat amazon-cloudwatch-agent.json`" \ --region "{{region}}" ``` **Configurazione della definizione di attività** Configura la definizione dell'attività per utilizzare l' CloudWatch agente ed esporre la porta TCP o UDP. La definizione di attività di esempio da utilizzare dipende dalla modalità di rete. Tieni presente che `webapp` specifica la variabile di ambiente `AWS_EMF_AGENT_ENDPOINT`. Questa viene utilizzata dalla libreria e deve mostrare l'endpoint su cui l'agente è in ascolto. Inoltre, `cwagent` specifica `CW_CONFIG_CONTENT` come parametro “valueFrom” che punta alla configurazione SSM creata nella fase precedente. Questa sezione contiene un esempio per la modalità bridge e un esempio per la modalità host o awsvpc. Per altri esempi di come configurare l' CloudWatch agente su Amazon ECS, consulta il repository di esempi [Github](https://github.com/aws-samples/amazon-cloudwatch-container-insights/tree/master/ecs-task-definition-templates/deployment-mode/sidecar) Di seguito è riportato un esempio di modalità bridge. Quando è abilitata la modalità di rete bridge, l'agente deve essere collegato all'applicazione utilizzando il parametro `links` e deve essere indirizzato utilizzando il nome del container. ``` { "containerDefinitions": [ { "name": "webapp", "links": [ "cwagent" ], "image": "my-org/web-app:latest", "memory": 256, "cpu": 256, "environment": [{ "name": "AWS_EMF_AGENT_ENDPOINT", "value": "tcp://cwagent:25888" }], }, { "name": "cwagent", "mountPoints": [], "image": "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest", "memory": 256, "cpu": 256, "portMappings": [{ "protocol": "tcp", "containerPort": 25888 }], "environment": [{ "name": "CW_CONFIG_CONTENT", "valueFrom": "cwagentconfig" }], } ], } ``` Di seguito è riportato un esempio per la modalità host o la modalità awsvpc. Durante l'esecuzione su tali modalità di rete, l'agente può essere indirizzato su `localhost`. ``` { "containerDefinitions": [ { "name": "webapp", "image": "my-org/web-app:latest", "memory": 256, "cpu": 256, "environment": [{ "name": "AWS_EMF_AGENT_ENDPOINT", "value": "tcp://127.0.0.1:25888" }], }, { "name": "cwagent", "mountPoints": [], "image": "public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest", "memory": 256, "cpu": 256, "portMappings": [{ "protocol": "tcp", "containerPort": 25888 }], "environment": [{ "name": "CW_CONFIG_CONTENT", "valueFrom": "cwagentconfig" }], } ], } ``` **Nota** In modalità awsvpc, è necessario fornire un indirizzo IP pubblico al VPC (solo Fargate), configurare un gateway NAT o configurare un endpoint VPC Logs. CloudWatch Per ulteriori informazioni sulla configurazione di un NAT, consulta [Gateway NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html). Per ulteriori informazioni sulla configurazione di un endpoint VPC CloudWatch Logs, [consulta CloudWatch Using Logs with](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch-logs-and-interface-VPC.html) Interface VPC Endpoints. Di seguito è riportato un esempio di come assegnare un indirizzo IP pubblico a un'attività che utilizza il tipo di lancio Fargate. ``` aws ecs run-task \ --cluster {{cluster-name}} \ --task-definition cwagent-fargate \ --region {{region}} \ --launch-type FARGATE \ --network-configuration "awsvpcConfiguration={subnets=[{{subnetId}}],securityGroups=[{{sgId}}],assignPublicIp=ENABLED}" ``` **Garantire le autorizzazioni** Assicurati che il ruolo IAM che esegue le attività disponga dell'autorizzazione per leggere dall'Archivio parametri SSM. Puoi aggiungere questa autorizzazione allegando la SSMRead OnlyAccess politica di **Amazon**. A questo scopo, immetti il comando seguente. ``` aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/AmazonSSMReadOnlyAccess \ --role-name CWAgentECSExecutionRole ``` ### Installazione dell' CloudWatch agente su Amazon EKS Parti di questo processo possono essere ignorate se CloudWatch Container Insights è già stato installato su questo cluster. Permissions Se Container Insights non è già stato installato, assicurati innanzitutto che i nodi Amazon EKS dispongano delle autorizzazioni IAM appropriate. Dovrebbero avere l'**CloudWatchAgentServerPolicy**allegato. Per ulteriori informazioni, consulta [Verifica dei prerequisiti per Container Insights in CloudWatch](Container-Insights-prerequisites.md). **Crea ConfigMap** Crea un ConfigMap messaggio per l'agente. Indica ConfigMap inoltre all'agente di ascoltare su una porta TCP o UDP. Usa quanto segue. ConfigMap ``` # cwagent-emf-configmap.yaml apiVersion: v1 data: # Any changes here must not break the JSON format cwagentconfig.json: | { "agent": { "omit_hostname": true }, "logs": { "metrics_collected": { "emf": { } } } } kind: ConfigMap metadata: name: cwagentemfconfig namespace: default ``` Se hai già installato Container Insights, aggiungi la `"emf": { }` riga seguente a quella esistente ConfigMap. **Applica il ConfigMap** Immettere il comando seguente per applicare il ConfigMap. ``` kubectl apply -f cwagent-emf-configmap.yaml ``` **Distribuzione dell'agente** Per distribuire l' CloudWatch agente come sidecar, aggiungete l'agente alla definizione del contenitore, come illustrato nell'esempio seguente. ``` apiVersion: v1 kind: Pod metadata: name: myapp namespace: default spec: containers: # Your container definitions go here - name: web-app image: my-org/web-app:latest # CloudWatch Agent configuration - name: cloudwatch-agent image: public.ecr.aws/cloudwatch-agent/cloudwatch-agent:latest imagePullPolicy: Always resources: limits: cpu: 200m memory: 100Mi requests: cpu: 200m memory: 100Mi volumeMounts: - name: cwagentconfig mountPath: /etc/cwagentconfig ports: # this should match the port configured in the ConfigMap - protocol: TCP hostPort: 25888 containerPort: 25888 volumes: - name: cwagentconfig configMap: name: cwagentemfconfig ``` ## Utilizzo dell' CloudWatch agente per inviare log in formato metrico incorporato Una volta installato e CloudWatch funzionante l'agente, è possibile inviare i log in formato metrico incorporato tramite TCP o UDP. Durante l'invio di log sull'agente è necessario rispettare due requisiti: + I log devono contenere una chiave `LogGroupName` che indica all'agente quale gruppo di log utilizzare. + Ogni evento di log deve trovarsi su una singola riga. In altre parole, un evento di log non può contenere il carattere di nuova riga (n). Gli eventi di log devono inoltre seguire le specifiche Embedded Metric Format. Per ulteriori informazioni, consulta [Specifica: Embedded Metric Format](CloudWatch_Embedded_Metric_Format_Specification.md). Se prevedi di creare allarmi su parametri creati utilizzando il formato dei parametri incorporati, consulta [Impostazione degli allarmi sui parametri creati con il formato dei parametri incorporati](CloudWatch_Embedded_Metric_Format_Alarms.md) per ottenere dei suggerimenti. Di seguito è riportato un esempio di invio manuale di eventi di log da una shell bash Linux. Puoi invece utilizzare le interfacce socket UDP fornite dal linguaggio di programmazione preferito. ``` echo '{"_aws":{"Timestamp":1574109732004,"LogGroupName":"Foo","CloudWatchMetrics":[{"Namespace":"MyApp","Dimensions":[["Operation"]],"Metrics":[{"Name":"ProcessingLatency","Unit":"Milliseconds","StorageResolution":60}]}]},"Operation":"Aggregator","ProcessingLatency":100}' \ > /dev/udp/0.0.0.0/25888 ``` **Nota** Con la specifica Embedded Metric Format, puoi tenere traccia dell'elaborazione dei registri EMF in base ai parametri pubblicati nello spazio dei nomi `AWS/Logs` del tuo account. Questi possono essere utilizzati per tenere traccia della generazione di parametri con esito negativo per EMF e per verificare se gli errori sono dovuti all'analisi o alla convalida. [Per maggiori dettagli, consulta Monitoraggio con metriche. CloudWatch ](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Monitoring-CloudWatch-Metrics.html) # Utilizzo del formato metrico incorporato con AWS Distro per OpenTelemetry OpenTelemetry è un'iniziativa open source che rimuove i confini e le restrizioni tra i formati di tracciamento, i log e le metriche specifici del fornitore offrendo un unico set di specifiche e. APIs Per ulteriori informazioni, consulta [OpenTelemetry](https://opentelemetry.io/). Puoi utilizzare il formato metrico incorporato come parte del progetto. OpenTelemetry L'utilizzo del formato metrico incorporato OpenTelemetry richiede due componenti: un'origine dati OpenTelemetry conforme e AWS Distro for OpenTelemetry Collector abilitata per l'uso con i log in formato metrico incorporato. CloudWatch Abbiamo ridistribuzioni preconfigurate dei OpenTelemetry componenti, che mantengono, per rendere l'onboarding il più semplice possibile. AWS [Per ulteriori informazioni sull'utilizzo OpenTelemetry con il formato metrico incorporato, oltre ad altri AWS servizi, consulta Distro for.AWS OpenTelemetry](https://aws-otel.github.io/) Per ulteriori informazioni sul supporto linguistico e sull'utilizzo, consulta [Osservabilità di AWS su Github](https://github.com/aws-observability). # Visualizzazione dei parametri e dei log nella console Dopo aver generato log in formato metrico incorporato che estraggono le metriche, puoi utilizzare la CloudWatch console per visualizzare le metriche. Le dimensioni dei parametri incorporati sono quelle specificate al momento della generazione dei log. Inoltre, le dimensioni predefinite delle metriche embedded generate utilizzando le librerie client sono le seguenti: + ServiceType + ServiceName + LogGroup [Questa sezione descrive come visualizzare queste metriche nella CloudWatch console e interrogare le metriche estratte utilizzando Logs Insights. CloudWatch ](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html) **Per visualizzare i parametri generati dai log in Embedded Metric Format** 1. Apri la console all'indirizzo. CloudWatch [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 1. Nel riquadro di navigazione, seleziona **Parametri**. 1. Seleziona uno spazio dei nomi specificato per i parametri incorporati quando sono stati generati. Se hai utilizzato le librerie client per generare le metriche e non hai specificato uno spazio dei nomi, seleziona. **aws-embedded-metrics** Questo è lo spazio dei nomi predefinito per i parametri incorporati generati utilizzando le librerie client. 1. Seleziona una dimensione metrica (ad esempio,). **ServiceName** 1. La scheda **All metrics** (Tutti i parametri) visualizza tutti i parametri per tale dimensione nello spazio dei nomi. È possibile effettuare le seguenti operazioni: 1. Per ordinare la tabella, utilizza l'intestazione della colonna. 1. Per creare il grafico di un parametro, seleziona la casella di controllo accanto al parametro. Per selezionare tutte i parametri, seleziona la casella di controllo nella riga dell'intestazione della tabella. 1. Per filtrare per risorsa, scegli l'ID della risorsa e quindi **Add to search** (Aggiungi alla ricerca). 1. Per filtrare in base a un parametro, scegli il nome del parametro e quindi **Add to search** (Aggiungi alla ricerca). **Interrogazione dei log utilizzando Logs Insights CloudWatch ** È possibile interrogare gli eventi di registro dettagliati associati alle metriche estratte utilizzando CloudWatch Logs Insights per fornire informazioni approfondite sulle cause principali degli eventi operativi. Uno dei vantaggi dell'estrazione di parametri dai log è la possibilità di filtrare i log in un secondo momento in base al parametro univoco (nome parametro più set di dimensioni univoco) e ai valori dei parametri, per ottenere il contesto sugli eventi che hanno contribuito al valore del parametro aggregato Ad esempio, per ottenere un ID di richiesta o un ID di traccia a raggi x interessato, è possibile eseguire la seguente query in Logs Insights. CloudWatch ``` filter Latency > 1000 and Operation = "Aggregator" | fields RequestId, TraceId ``` Puoi inoltre eseguire l'aggregazione al momento dell'esecuzione delle query su chiavi ad alta cardinalità, ad esempio individuando i clienti influenzati da un evento. Nell'esempio seguente viene descritto quanto segue. ``` filter Latency > 1000 and Operation = "Aggregator" | stats count() by CustomerId ``` Per ulteriori informazioni, consulta [Analisi dei dati di registro](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html) con Logs Insights CloudWatch # Impostazione degli allarmi sui parametri creati con il formato dei parametri incorporati In generale, la creazione di allarmi sulle metriche generate da Embedded Metric Format segue lo stesso schema della creazione di allarmi su qualsiasi altra metrica. Per ulteriori informazioni, consulta [Utilizzo degli CloudWatch allarmi Amazon](CloudWatch_Alarms.md). La generazione di metriche in formato metrico integrato dipende dal flusso di pubblicazione dei log, poiché CloudWatch Logs deve elaborare i log in modo che possano essere trasformati in metriche. È importante pubblicare i log in modo tempestivo affinché i punti dati delle metriche vengano creati entro il periodo di tempo in cui vengono valutati gli allarmi. Se prevedi di utilizzare il formato metrico incorporato per inviare metriche ad alta risoluzione e creare allarmi in base a tali metriche, ti consigliamo di scaricare i log in Logs a intervalli di 5 secondi o meno per evitare di introdurre un ulteriore ritardo, che può causare allarmi per CloudWatch dati parziali o mancanti. Se si utilizza l' CloudWatch agente, è possibile regolare l'intervallo di flush impostando il parametro nel file di configurazione dell'agente. `force_flush_interval` CloudWatch Il valore predefinito di questo valore è 5 secondi. Se utilizzi Lambda su altre piattaforme in cui non puoi controllare l'intervallo di caricamento dei log, prendi in considerazione l'utilizzo degli allarmi "M di N" per controllare il numero di punti di dati utilizzati per creare un allarme. Per ulteriori informazioni, consulta [Valutazione degli allarmi](alarm-evaluation.md).