Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Veröffentlichen von Protokollen mithilfe des eingebetteten Metrikformats Sie können Protokolle im eingebetteten Metrikformat mithilfe der folgenden Methoden generieren: + Generieren und Senden der Protokolle mithilfe der [Open-Source-Client-Bibliotheken](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format_Libraries.html). + Generieren Sie die Protokolle manuell mithilfe der [Spezifikation für das eingebettete metrische Format](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format_Specification.html) und verwenden Sie dann den [CloudWatch Agenten](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Embedded_Metric_Format_Generation_CloudWatch_Agent.html) oder die [PutLogEvents API](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html), um die Protokolle zu senden. Weitere Informationen zu eingebetteten Metriken finden Sie in den folgenden Themen. **Topics** + [Erstellen von Protokollen im eingebetteten Metrikformat unter Verwendung der Client-Bibliotheken](CloudWatch_Embedded_Metric_Format_Libraries.md) + [Spezifikation: Eingebettetes Metrikformat](CloudWatch_Embedded_Metric_Format_Specification.md) + [Verwenden der PutLogEvents API zum Senden manuell erstellter Logs im eingebetteten metrischen Format](CloudWatch_Embedded_Metric_Format_Generation_PutLogEvents.md) + [Verwenden des CloudWatch Agenten zum Senden eingebetteter Logs im Metrikformat](CloudWatch_Embedded_Metric_Format_Generation_CloudWatch_Agent.md) + [Verwenden des eingebetteten metrischen Formats mit AWS Distro für OpenTelemetry](CloudWatch_Embedded_Metric_Format_OpenTelemetry.md) # Erstellen von Protokollen im eingebetteten Metrikformat unter Verwendung der Client-Bibliotheken Sie können von Amazon bereitgestellte Open-Source-Client-Bibliotheken nutzen, mit denen Sie Protokolle im eingebetteten Metrikformat erstellen können. Vollständige Beispiele für verschiedene Einrichtungen finden Sie in unseren Client-Bibliotheken unter **/examples**. Die Bibliotheken und Anweisungen zur Verwendung befinden sich auf Github. + [Node.Js](https://github.com/awslabs/aws-embedded-metrics-node) **Anmerkung** Für Node.js sind die Versionen 4.1.1\$1, 3.0.2\$1, 2.0.7\$1 für die Verwendung mit dem Lambda-JSON-Protokollformat erforderlich. Die Verwendung früherer Versionen in solchen Lambda-Umgebungen führt zu Metrik-Verlusten. Weitere Informationen finden Sie unter [Zugreifen auf CloudWatch Amazon-Protokolle für 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) Client-Bibliotheken sind so konzipiert, dass sie sofort mit dem CloudWatch Agenten zusammenarbeiten. Generierte Logs im eingebetteten metrischen Format werden an den CloudWatch Agenten gesendet, der sie dann aggregiert und für Sie in CloudWatch Logs veröffentlicht. **Anmerkung** Bei der Verwendung von Lambda ist kein Agent erforderlich, an den die Protokolle gesendet CloudWatch werden. Alles, was in STDOUT protokolliert wurde, wird über den Lambda CloudWatch Logging Agent an Logs gesendet. # Spezifikation: Eingebettetes Metrikformat Das CloudWatch eingebettete Metrikformat ist eine JSON-Spezifikation, mit der CloudWatch Logs angewiesen wird, automatisch Metrikwerte zu extrahieren, die in strukturierte Protokollereignisse eingebettet sind. Sie können CloudWatch es verwenden, um die extrahierten Metrikwerte grafisch darzustellen und Alarme zu erstellen. In diesem Abschnitt werden die Konventionen für die Spezifikation des eingebetteten Metrikformats und die Dokumentstruktur des eingebetteten Metrikformats beschrieben. ## Konventionen der Spezifikationen für eingebettete Metrikformate Die Schlüsselwörter „MUSS“, „DARF NICHT“, „ERFORDERLICH“, „SOLL“, „DARF NICHT“, „SOLLTE“, „SOLLTE“, „SOLLTE NICHT“, „EMPFOHLEN“, „KANN“ und „OPTIONAL“ in dieser Formatspezifikation sind wie unter [Stichwörter](http://tools.ietf.org/html/rfc2119) beschrieben zu interpretieren RFC2119. Die Begriffe „JSON“, „JSON-Text“, „JSON-Wert“, „Mitglied“, „Element“, „Objekt“, „Array“, „Zahl“, „Zeichenfolge“, „Boolean“, „True“, „False“ und „Null“ in dieser Formatspezifikation sind so zu interpretieren, wie sie in [JavaScript Object Notation](https://tools.ietf.org/html/rfc8259) definiert sind RFC8259. **Anmerkung** Wenn Sie Alarme für Metriken erstellen möchten, die im eingebetteten Metrikformat erstellt wurden, siehe [Alarme für Metriken setzen, die mit dem eingebetteten Metrikformat erstellt wurden](CloudWatch_Embedded_Metric_Format_Alarms.md) für Empfehlungen. ## Eingebettetes Metrikformat-Dokumentstruktur Dieser Abschnitt beschreibt die Struktur eines Dokuments im eingebetteten Metrikformat. Dokumente im eingebetteten metrischen Format werden in [JavaScript Object](https://tools.ietf.org/html/rfc8259) Notation definiert. RFC8259 Sofern nicht anders angegeben, DÜRFEN in dieser Spezifikation definierte Objekte KEINE zusätzlichen Elemente enthalten. Elemente, die von dieser Spezifikation nicht erkannt werden, MÜSSEN ignoriert werden. In dieser Spezifikation definierte Elemente berücksichtigen Groß- und Kleinschreibung. Das eingebettete metrische Format unterliegt denselben Beschränkungen wie standardmäßige CloudWatch Log-Ereignisse und ist auf eine maximale Größe von 1 MB begrenzt. Mit dem eingebetteten Metrikformat können Sie die Verarbeitung Ihrer EMF-Protokolle nach Metriken verfolgen, die im `AWS/Logs`-Namespace Ihres Kontos veröffentlicht werden. Diese können verwendet werden, um die fehlgeschlagene Metrikgenerierung von EMF nachzuverfolgen und festzustellen, ob Fehler aufgrund der Analyse oder der Validierung auftreten. Weitere Informationen finden Sie unter [Überwachung mit CloudWatch Metriken](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Monitoring-CloudWatch-Metrics.html). ### Stammknoten Die LogEvent Nachricht MUSS ein gültiges JSON-Objekt ohne zusätzliche Daten am Anfang oder Ende der LogEvent Nachrichtenzeichenfolge sein. Weitere Hinweise zur LogEvent Struktur finden Sie unter [InputLogEvent](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_InputLogEvent.html). Dokumente im eingebetteten Metrikformat MÜSSEN das folgende Element der obersten Ebene auf dem Stammknoten enthalten. Dies ist ein [Metadatenobjekt](#CloudWatch_Embedded_Metric_Format_Specification_structure_metadata)-Objekt. ``` { "_aws": { "CloudWatchMetrics": [ ... ] } } ``` Der Stammknoten MUSS alle [Zielmitglieder](#CloudWatch_Embedded_Metric_Format_Specification_structure_target)-Elemente enthalten, die durch die Verweise in [MetricDirective Objekt](#CloudWatch_Embedded_Metric_Format_Specification_structure_metricdirective) definiert sind. Der Stammknoten KANN alle anderen Elemente enthalten, die nicht in den oben genannten Anforderungen enthalten sind. Die Werte dieser Elemente MÜSSEN gültige JSON-Typen sein. ### Metadatenobjekt Das `_aws` Element kann verwendet werden, um Metadaten über die Nutzlast darzustellen, die nachgelagerten Dienste darüber informieren, wie sie diese verarbeiten sollen. LogEvent Der Wert MUSS ein Objekt sein und MUSS die folgenden Elemente enthalten: + **CloudWatchMetrics**— Ein Array von, das [MetricDirective Objekt](#CloudWatch_Embedded_Metric_Format_Specification_structure_metricdirective) verwendet wird, um anzuweisen CloudWatch , Metriken aus dem Stammknoten des zu extrahieren. LogEvent ``` { "_aws": { "CloudWatchMetrics": [ ... ] } } ``` + **Zeitstempel** – Eine Zahl, die den Zeitstempel für Metriken darstellt, die aus dem Ereignis extrahiert werden. Werte MÜSSEN als die Anzahl der Millisekunden nach dem 1. Januar 1970 00:00:00 UTC ausgedrückt werden. ``` { "_aws": { "Timestamp": 1559748430481 } } ``` ### MetricDirective Objekt Das MetricDirective Objekt weist nachgelagerte Dienste an, dass es Metriken LogEvent enthält, die extrahiert und veröffentlicht werden. CloudWatch MetricDirectives MUSS die folgenden Mitglieder enthalten: + **Namespace** — Eine Zeichenfolge, die den CloudWatch Namespace für die Metrik darstellt. + **Dimensionen** – Ein [DimensionSet Array](#CloudWatch_Embedded_Metric_Format_Specification_structure_dimensionset). + **Metriken**– – Ein Array von [MetricDefinition Objekt](#CloudWatch_Embedded_Metric_Format_Specification_structure_metricdefinition)-Objekten. Dieses Array DARF NICHT mehr als 100 MetricDefinition Objekte enthalten. ### DimensionSet Array A DimensionSet ist ein Array von Zeichenketten, die die Dimensionsschlüssel enthalten, die auf alle Metriken im Dokument angewendet werden. Die Werte innerhalb dieses Arrays MÜSSEN auch Elemente auf dem Stammknoten sein, die als das [Zielmitglieder](#CloudWatch_Embedded_Metric_Format_Specification_structure_target) bezeichnet werden. A DimensionSet DARF NICHT mehr als 30 Dimensionsschlüssel enthalten. A DimensionSet KANN leer sein. Das Zielelement MUSS einen Zeichenfolgenwert haben. Dieser Wert DARF NICHT mehr als 1024 Zeichen enthalten. Das Zielelement definiert eine Dimension, die als Teil der Metrikidentität veröffentlicht wird. Jeder DimensionSet Benutzer erstellt eine neue Metrik in CloudWatch. Weitere Informationen zu Dimensionen finden Sie unter [Dimension](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_Dimension.html) und [Dimensionen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html#Dimension). ``` { "_aws": { "CloudWatchMetrics": [ { "Dimensions": [ [ "functionVersion" ] ], ... } ] }, "functionVersion": "$LATEST" } ``` **Anmerkung** Seien Sie vorsichtig, wenn Sie die Metrikextraktion konfigurieren, da sich dies auf Ihre benutzerdefinierte Metrikauslastung und die entsprechende Rechnung auswirkt. Wenn Sie versehentlich Metriken basierend auf hohen Kardinalitätsdimensionen erstellen (z. B. `requestId`), erstellt das eingebettete Metrikformat standardmäßig eine benutzerdefinierte Metrik, die jeder eindeutigen Dimensionskombination entspricht. Weitere Informationen finden Sie unter [Dimensionen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch_concepts.html#Dimension). ### MetricDefinition Objekt A MetricDefinition ist ein Objekt, das das folgende Mitglied enthalten MUSS: + **Name** – Eine Zeichenfolge [Referenzwerte](#CloudWatch_Embedded_Metric_Format_Specification_structure_referencevalues) auf eine Metrik [Zielmitglieder](#CloudWatch_Embedded_Metric_Format_Specification_structure_target). Metrikziele MÜSSEN entweder aus einem numerischen Wert oder einem Array von numerischen Werten bestehen. Ein MetricDefinition Objekt KANN die folgenden Mitglieder enthalten: + **Einheit** – Ein OPTIONALER Zeichenfolgenwert, der die Maßeinheit für die entsprechende Metrik darstellt. Die Werte SOLLTEN gültige CloudWatch metrische Einheiten sein. Hinweise zu gültigen Einheiten finden Sie unter [MetricDatum](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_MetricDatum.html). Wenn kein Wert angegeben wird, wird der Standardwert NONE angenommen. + **StorageResolution**— Ein OPTIONALER Ganzzahlwert, der die Speicherauflösung für die entsprechende Metrik darstellt. Wenn dieser Wert auf 1 gesetzt wird, handelt es sich bei dieser Metrik um eine Metrik mit hoher Auflösung, sodass die Metrik mit einer Auflösung von unter einer Minute bis zu einer Sekunde CloudWatch gespeichert wird. Wenn dieser Wert auf 60 gesetzt wird, handelt es sich bei dieser Metrik um eine Standardauflösung, die mit einer Auflösung von 1 Minute CloudWatch gespeichert wird. Die Werte SOLLTEN gültige CloudWatch unterstützte Auflösungen sein, 1 oder 60. Wenn kein Wert angegeben wird, wird der Standardwert 60 angenommen. Weitere Informationen zu hochauflösenden Metriken finden Sie unter [Hochauflösende Metriken](publishingMetrics.md#high-resolution-metrics). **Anmerkung** Wenn Sie Alarme für Metriken erstellen möchten, die im eingebetteten Metrikformat erstellt wurden, siehe [Alarme für Metriken setzen, die mit dem eingebetteten Metrikformat erstellt wurden](CloudWatch_Embedded_Metric_Format_Alarms.md) für Empfehlungen. ``` { "_aws": { "CloudWatchMetrics": [ { "Metrics": [ { "Name": "Time", "Unit": "Milliseconds", "StorageResolution": 60 } ], ... } ] }, "Time": 1 } ``` ### Referenzwerte Referenzwerte sind Zeichenfolgenwerte, die [Zielmitglieder](#CloudWatch_Embedded_Metric_Format_Specification_structure_target)-Elemente auf dem Stammknoten referenzieren. Diese Verweise sollten NICHT mit den unter beschriebenen JSON-Zeigern verwechselt werden. [RFC6901](https://tools.ietf.org/html/rfc6901) Zielwerte können nicht verschachtelt werden. ### Zielmitglieder Gültige Ziele MÜSSEN Elemente auf dem Stammknoten sein und dürfen keine verschachtelten Objekte sein. Ein \$1reference\$1-Wert von `"A.a"` MUSS beispielsweise mit dem folgenden Element übereinstimmen: ``` { "A.a" } ``` Er DARF NICHT mit dem verschachtelten Element übereinstimmen: ``` { "A": { "a" } } ``` Gültige Werte von Zielelementen hängen davon ab, was sie referenziert. Ein Metrikziel MUSS ein numerischer Wert oder ein Array numerischer Werte sein. Numerische Array-Metrikziele DÜRFEN NICHT mehr als 100 Mitglieder haben. Ein Dimensionsziel MUSS einen Zeichenfolgenwert haben. ### Beispiel für ein eingebettetes Metrikformat und JSON-Schema Im Folgenden finden Sie ein gültiges Beispiel für ein eingebettetes Metrikformat. ``` { "_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" } ``` Sie können das folgende Schema verwenden, um Dokumente im eingebetteten Metrikformat zu validieren. ``` { "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 ] } } } } } } } } } } } ``` ## Entity-Informationen im EMF-Format Wenn Sie Protokolle CloudWatch mithilfe des Embedded Metric Format (EMF) auf Amazon veröffentlichen, können Sie Entitätsinformationen in das Protokollereignis aufnehmen. In diesem Abschnitt wird beschrieben, wie Entitätsinformationen angegeben und wie diese Informationen CloudWatch verarbeitet werden. ### Entity-Typen Wenn in der `PutLogEvents` Anfrage keine Entität angegeben ist, CloudWatch wird im EMF-Protokollinhalt nach Entitätsinformationen gesucht: + **Entitys vom Typ „Service“** Pflichtfelder: `Service` und `Environment` + **Entitys vom Typ „Ressource“** Pflichtfelder: `ResourceType` und `Identifier` ### Plattformsattribute CloudWatch bestimmt automatisch den Plattformtyp auf der Grundlage dieser Attribute: + **Kubernetes (K8s):** Erforderlich: `K8s.Cluster` Fakultativ: `K8s.Namespace``K8s.Workload`,`K8s.Node`,`K8s.Pod`,`EC2.InstanceId`, `EC2.AutoScalingGroup` + **Amazon EKS** Erforderlich: `EKS.Cluster` Fakultativ: `K8s.Namespace``K8s.Workload`,`K8s.Node`,`K8s.Pod`, `EC2.InstanceId` + **Amazon ECS:** Erforderlich: `ECS.Cluster` Fakultativ:`ECS.Service`, `ECS.Task` + **Amazon EC2** Erforderlich: `EC2.InstanceId` Fakultativ: `EC2.AutoScalingGroup` + **Lambda:** Erforderlich: `Lambda.Function` + **Generische Hosts:** Erforderlich: `Host` ### Beispiel-EMF-Protokollformat ``` { "_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 } ``` ### Generierte Entity Das obige EMF-Protokoll generiert die folgende Entity: ``` { "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" } } ``` ### Entity-Verarbeitung CloudWatch verarbeitet die Entitätsinformationen wie folgt: + **KeyAttributes:** + Ermittelt den Entitätstyp anhand der Pflichtfelder + Extrahiert für den Servicetyp den Servicenamen und die Umgebung + Diese werden zu den primären Identifikatoren für die Entity + **Attribute**: + Sätze, die PlatformType auf den enthaltenen Plattformattributen basieren + Umfasst alle relevanten plattformspezifischen Informationen + Behält Beziehungskontext für die Telemetriedaten bei CloudWatch verwendet diese Entitätsinformationen, um Beziehungen zwischen verschiedenen Telemetriedaten herzustellen, was eine verbesserte Beobachtbarkeit und Kontextanalyse Ihrer Anwendungen und Infrastruktur ermöglicht. Weitere Informationen finden Sie unter [Hinzufügen verwandter Informationen zu benutzerdefinierter Telemetrie, die an gesendet wurde](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/adding-your-own-related-telemetry.html). CloudWatch **Anmerkung** Mithilfe von Entitätsinformationen CloudWatch können Sie sich ein vollständiges Bild der Telemetriedaten Ihrer Anwendung und ihrer Beziehungen innerhalb Ihrer Infrastruktur machen. # Verwenden der PutLogEvents API zum Senden manuell erstellter Logs im eingebetteten metrischen Format Mithilfe der [PutLogEvents](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutLogEvents.html)Logs-API können Sie eingebettete Protokolle im metrischen Format an CloudWatch CloudWatch Logs senden. Beim Aufrufen haben Sie die Möglichkeit PutLogEvents, den folgenden HTTP-Header einzufügen, der CloudWatch Logs mitteilt, dass die Metriken extrahiert werden sollen, dies ist jedoch nicht erforderlich. ``` x-amzn-logs-format: json/emf ``` Im Folgenden finden Sie ein vollständiges Beispiel für die Verwendung des 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"); } } ``` **Anmerkung** Mit dem eingebetteten Metrikformat können Sie die Verarbeitung Ihrer EMF-Protokolle nach Metriken verfolgen, die im `AWS/Logs`-Namespace Ihres Kontos veröffentlicht werden. Diese können verwendet werden, um die fehlgeschlagene Metrikgenerierung von EMF nachzuverfolgen und festzustellen, ob Fehler aufgrund der Analyse oder der Validierung auftreten. Weitere Informationen finden Sie unter [Überwachung mit CloudWatch Metriken](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Monitoring-CloudWatch-Metrics.html). # Verwenden des CloudWatch Agenten zum Senden eingebetteter Logs im Metrikformat In diesem Abschnitt wird beschrieben, wie der CloudWatch Agent installiert und verwendet wird. Im ersten Teil dieses Abschnitts wird beschrieben, wie der CloudWatch Agent installiert wird. Im zweiten Teil dieses Abschnitts wird beschrieben, wie der CloudWatch Agent verwendet wird, um eingebettete Logs im metrischen Format zu senden. Wenn Sie diese Methode verwenden möchten, müssen Sie den CloudWatch Agenten für die Datei installieren, von der aus AWS-Services Sie eingebettete Logs im metrischen Format senden möchten. Danach können Sie Ereignisse senden. Der CloudWatch Agent muss Version 1.230621.0 oder höher sein. **Anmerkung** Sie müssen den CloudWatch Agenten nicht installieren, um Protokolle von Lambda-Funktionen zu senden. Lambda-Funktionstimeouts werden nicht automatisch behandelt. Dies bedeutet, dass die Metriken für diesen Aufruf nicht erfasst werden, wenn für Ihre Funktion eine Zeitüberschreitung auftritt, bevor die Metriken übertragen werden. ## Den Agenten installieren CloudWatch Installieren Sie den CloudWatch Agenten für jeden Dienst, der eingebettete Protokolle im metrischen Format senden soll. ### Den CloudWatch Agenten auf EC2 installieren Installieren Sie zunächst den CloudWatch Agenten auf der Instance. Weitere Informationen finden Sie unter [Den CloudWatch Agenten installieren](install-CloudWatch-Agent-on-EC2-Instance.md). Nachdem Sie den Agenten installiert haben, konfigurieren Sie den Agenten so, dass er einen UDP- oder TCP-Port auf die Protokolle im eingebetteten Metrikformat überwacht. Im Folgenden finden Sie ein Beispiel für diese Konfiguration, die den Standard-Socket `tcp:25888` überwacht. Weitere Informationen zur Agentenkonfiguration finden Sie unter [Erstellen oder bearbeiten Sie die CloudWatch Agenten-Konfigurationsdatei manuell](CloudWatch-Agent-Configuration-File-Details.md) ``` { "logs": { "metrics_collected": { "emf": { } } } } ``` ### Installation des CloudWatch Agenten auf Amazon ECS Der einfachste Weg, den CloudWatch Agenten auf Amazon ECS bereitzustellen, besteht darin, ihn als Sidecar auszuführen und ihn in derselben Aufgabendefinition wie Ihre Anwendung zu definieren. **Erstellen der Agentenkonfigurationsdatei** Erstellen Sie Ihre CloudWatch Agenten-Konfigurationsdatei lokal. In diesem Beispiel lautet der relative Dateipfad `amazon-cloudwatch-agent.json`. Weitere Informationen zur Agentenkonfiguration finden Sie unter [Erstellen oder bearbeiten Sie die CloudWatch Agenten-Konfigurationsdatei manuell](CloudWatch-Agent-Configuration-File-Details.md) ``` { "logs": { "metrics_collected": { "emf": { } } } } ``` **Übertragen der Konfiguration an den SSM-Parameterspeicher** Geben Sie den folgenden Befehl ein, um die CloudWatch Agentenkonfigurationsdatei in den AWS Systems Manager (SSM) -Parameterspeicher zu übertragen. ``` aws ssm put-parameter \ --name "cwagentconfig" \ --type "String" \ --value "`cat amazon-cloudwatch-agent.json`" \ --region "{{region}}" ``` **Konfigurieren der Aufgabendefinition** Konfigurieren Sie Ihre Aufgabendefinition so, dass sie den CloudWatch Agenten verwendet und den TCP- oder UDP-Port verfügbar macht. Die Beispielaufgabendefinition, die Sie verwenden sollten, hängt vom Netzwerkmodus ab. Beachten Sie, dass die `webapp` die `AWS_EMF_AGENT_ENDPOINT`-Umgebungsvariable angibt. Diese wird von der Bibliothek verwendet und sollte auf den Endpunkt verweisen, den der Agent überwacht. Darüber hinaus gibt der `cwagent` den `CW_CONFIG_CONTENT` als „valueFrom“-Parameter an, der auf die SSM-Konfiguration verweist, die Sie im vorherigen Schritt erstellt haben. Dieser Abschnitt enthält ein Beispiel für den Bridge-Modus und ein Beispiel für den Host- oder awsvpc-Modus. Weitere Beispiele dafür, wie Sie den CloudWatch Agenten auf Amazon ECS konfigurieren können, finden Sie im [Github-Beispiel-Repository](https://github.com/aws-samples/amazon-cloudwatch-container-insights/tree/master/ecs-task-definition-templates/deployment-mode/sidecar) Im Folgenden finden Sie ein Beispiel für den Bridge-Modus. Wenn das Bridge-Modus-Netzwerk aktiviert ist, muss der Agent mithilfe des `links`-Parameters mit Ihrer Anwendung verknüpft und mithilfe des Containernamens adressiert werden. ``` { "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" }], } ], } ``` Im Folgenden finden Sie ein Beispiel für den Host-Modus oder den awsvpc-Modus. Beim Ausführen auf diesen Netzwerkmodi kann der Agent über `localhost` angesprochen werden. ``` { "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" }], } ], } ``` **Anmerkung** Im awsvpc-Modus müssen Sie der VPC entweder eine öffentliche IP-Adresse geben (nur Fargate), ein NAT-Gateway einrichten oder einen Logs-VPC-Endpunkt einrichten. CloudWatch Weitere Informationen zum Einrichten einer NAT finden Sie unter [NAT-Gateways](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html). Weitere Informationen zum Einrichten eines CloudWatch Logs-VPC-Endpoints finden Sie unter [Using CloudWatch Logs with Interface VPC](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch-logs-and-interface-VPC.html) Endpoints. Im Folgenden finden Sie ein Beispiel dafür, wie Sie einer Aufgabe, die den Fargate-Starttyp verwendet, eine öffentliche IP-Adresse zuweisen. ``` 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}" ``` **Sicherstellen der Berechtigungen** Stellen Sie sicher, dass die IAM-Rolle, die Ihre Aufgaben ausführt, über die Berechtigung zum Lesen aus dem SSM-Parameterspeicher verfügt. Sie können diese Genehmigung hinzufügen, indem Sie die **SSMReadOnlyAccessAmazon-Richtlinie** anhängen. Geben Sie dazu den folgenden Befehl ein. ``` aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/AmazonSSMReadOnlyAccess \ --role-name CWAgentECSExecutionRole ``` ### Installation des CloudWatch Agenten auf Amazon EKS Teile dieses Prozesses können übersprungen werden, wenn Sie CloudWatch Container Insights bereits auf diesem Cluster installiert haben. Berechtigungen Wenn Sie Container Insights noch nicht installiert haben, stellen Sie zunächst sicher, dass Ihre Amazon-EKS-Knoten über die entsprechenden IAM-Berechtigungen verfügen. Sie sollten das **CloudWatchAgentServerPolicy**angehängt haben. Weitere Informationen finden Sie unter [Überprüfung der Voraussetzungen für Container Insights in CloudWatch](Container-Insights-prerequisites.md). **Create ConfigMap** Erstellen Sie eine ConfigMap für den Agenten. Der weist den Agenten ConfigMap außerdem an, einen TCP- oder UDP-Port abzuhören. Verwenden Sie Folgendes 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 ``` Wenn Sie Container Insights bereits installiert haben, fügen Sie Ihrer vorhandenen `"emf": { }` Zeile die folgende Zeile hinzu ConfigMap. **Wenden Sie das an ConfigMap** Geben Sie den folgenden Befehl ein, um das anzuwenden ConfigMap. ``` kubectl apply -f cwagent-emf-configmap.yaml ``` **Bereitstellen des Agenten** Um den CloudWatch Agenten als Sidecar bereitzustellen, fügen Sie den Agenten wie im folgenden Beispiel zu Ihrer Pod-Definition hinzu. ``` 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 ``` ## Verwenden des CloudWatch Agenten zum Senden eingebetteter Logs im metrischen Format Wenn der CloudWatch Agent installiert ist und ausgeführt wird, können Sie die eingebetteten Protokolle im Metrikformat über TCP oder UDP senden. Beim Senden der Protokolle über den Agenten gibt es zwei Anforderungen: + Die Protokolle müssen einen `LogGroupName`-Schlüssel enthalten, der dem Agenten mitteilt, welche Protokollgruppe verwendet werden soll. + Jedes Protokollereignis muss sich in einer einzigen Zeile befinden. Mit anderen Worten, ein Protokollereignis darf das Zeilenumbruchzeichen (\$1n) nicht enthalten. Die Protokollereignisse müssen auch der Spezifikation für eingebettete Metrikformate entsprechen. Weitere Informationen finden Sie unter [Spezifikation: Eingebettetes Metrikformat](CloudWatch_Embedded_Metric_Format_Specification.md). Wenn Sie Alarme für Metriken erstellen möchten, die im eingebetteten Metrikformat erstellt wurden, siehe [Alarme für Metriken setzen, die mit dem eingebetteten Metrikformat erstellt wurden](CloudWatch_Embedded_Metric_Format_Alarms.md) für Empfehlungen. Im Folgenden finden Sie ein Beispiel für das manuelle Senden von Protokollereignissen aus einer Linux-Bash-Shell. Sie können stattdessen die UDP-Socket-Schnittstellen verwenden, die von Ihrer gewünschten Programmiersprache bereitgestellt werden. ``` 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 ``` **Anmerkung** Mit dem eingebetteten Metrikformat können Sie die Verarbeitung Ihrer EMF-Protokolle nach Metriken verfolgen, die im `AWS/Logs`-Namespace Ihres Kontos veröffentlicht werden. Diese können verwendet werden, um die fehlgeschlagene Metrikgenerierung von EMF nachzuverfolgen und festzustellen, ob Fehler aufgrund der Analyse oder der Validierung auftreten. Weitere Informationen finden Sie unter [Überwachung mit CloudWatch Metriken](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CloudWatch-Logs-Monitoring-CloudWatch-Metrics.html). # Verwenden des eingebetteten metrischen Formats mit AWS Distro für OpenTelemetry OpenTelemetry ist eine Open-Source-Initiative, die Grenzen und Einschränkungen zwischen anbieterspezifischen Formaten für Ablaufverfolgung, Protokolle und Metriken aufhebt, indem sie einen einzigen Satz von Spezifikationen anbietet und. APIs Weitere Informationen finden Sie unter [OpenTelemetry](https://opentelemetry.io/). Sie können das eingebettete metrische Format als Teil des Projekts verwenden. OpenTelemetry Für die Verwendung des eingebetteten metrischen Formats mit OpenTelemetry sind zwei Komponenten erforderlich: eine OpenTelemetry -konforme Datenquelle und AWS Distro for OpenTelemetry Collector, die für die Verwendung mit CloudWatch eingebetteten Protokollen im metrischen Format aktiviert ist. Um das Onboarding so einfach wie möglich zu gestalten, haben wir die AWS Neuverteilungen der OpenTelemetry Komponenten vorkonfiguriert. [Weitere Informationen zur Verwendung OpenTelemetry des eingebetteten metrischen Formats sowie zu anderen AWS Diensten finden Sie unter Distro for.AWS OpenTelemetry](https://aws-otel.github.io/) Weitere Informationen zur Sprachunterstützung und -verwendung finden Sie unter [AWS Beobachtbarkeit auf Github](https://github.com/aws-observability).