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.
# Fragen Sie Ihre CloudWatch Metriken mit Metrics Insights ab CloudWatch
CloudWatch Metrics Insights ist eine leistungsstarke SQL-Abfrage-Engine, mit der Sie Ihre Metriken maßstabsgetreu abfragen können. Sie können Trends und Muster in all Ihren CloudWatch Kennzahlen in Echtzeit identifizieren und haben Zugriff auf historische Daten von bis zu zwei Wochen für eine umfassende Trendanalyse.
Sie können auch Alarme für alle Metrics-Insights-Abfragen einrichten, die eine einzelne Zeitreihe zurückgeben. Dies kann besonders nützlich sein, um Alarme zu erstellen, die aggregierte Metriken einer Flotte Ihrer Infrastruktur oder Ihrer Anwendungen überwachen. Wenn Sie den Alarm einmal erstellen, passt er sich dynamisch an, wenn Ressourcen zur Flotte hinzugefügt oder aus ihr entfernt werden.
Sie können eine CloudWatch Metrics Insights-Abfrage in der Konsole mit dem CloudWatch Metrics Insights-Abfrage-Editor ausführen. Sie können eine CloudWatch Metrics Insights-Abfrage auch mit dem AWS CLI oder einem AWS SDK ausführen, indem Sie `GetMetricData` oder ausführen`PutDashboard`. Für Abfragen, die Sie mit dem CloudWatch Metrics Insights-Abfrage-Editor ausführen, fallen keine Gebühren an. Weitere Informationen zur CloudWatch Preisgestaltung finden Sie unter [ CloudWatch Amazon-Preise](https://aws.amazon.com/cloudwatch/pricing/).
Mit dem Abfrage-Editor von CloudWatch Metrics Insights können Sie aus einer Vielzahl von vorgefertigten Beispielabfragen wählen und auch Ihre eigenen Abfragen erstellen. Während Sie Ihre Abfragen erstellen, können Sie eine Builder-Ansicht verwenden, um Ihre vorhandenen Metriken und Dimensionen zu durchsuchen. Alternativ können Sie eine Editor-Ansicht verwenden, um Abfragen manuell zu schreiben.
Mit Metrics Insights können Sie Abfragen im großen Maßstab ausführen. Durch die Verwendung der Klausel **GROUP BY** können Sie Ihre Metriken flexibel in Echtzeit in separate Zeitreihen pro bestimmten Dimensionswert gruppieren. Da Metrics-Insights-Abfragen eine **ORDER BY**-Funktion beinhalten, können Sie Metrics Insights verwenden, um Abfragen vom Typ „Top N“ zu erstellen. Abfragen vom Typ „Top N“ können beispielsweise Millionen von Metriken in Ihrem Konto scannen und die 10 Instances zurückgeben, die am meisten CPU verbrauchen. Dies kann Ihnen helfen, Latenzprobleme in Ihren Anwendungen zu lokalisieren und zu beheben. Um Tags mit Alarmen zu verwenden, wählen Sie die Option CloudWatch „Einstellungen“ aus. Nachdem Tags aktiviert wurden, können Sie Metriken auch mithilfe von AWS Ressourcen-Tags filtern und gruppieren, sodass Sie Kennzahlen abfragen können, die auf Ihre Organisationsstruktur abgestimmt sind, z. B. nach Anwendung, Umgebung oder Team.
**Topics**
+ [Erstellen Sie Ihre Abfragen in CloudWatch Metrics Insights](cloudwatch-metrics-insights-buildquery.md)
+ [Abfragekomponenten und Syntax in CloudWatch Metrics Insights](cloudwatch-metrics-insights-querylanguage.md)
+ [Alarme bei CloudWatch Metrics Insights-Abfragen in CloudWatch](cloudwatch-metrics-insights-alarms.md)
+ [Metrics-Insights-Abfragen mit Metrikberechnungen verwenden](cloudwatch-metrics-insights-math.md)
+ [Verwenden Sie natürliche Sprache, um CloudWatch Metrics Insights-Abfragen zu generieren und zu aktualisieren](cloudwatch-metrics-insights-query-assist.md)
+ [SQL-Inferenz](cloudwatch-metrics-insights-inference.md)
+ [Metrics-Insights-Kontingente](cloudwatch-metrics-insights-limits.md)
+ [Beispielabfragen für Metriken Insights](cloudwatch-metrics-insights-queryexamples.md)
+ [Glossar zu Metric Insights](cloudwatch-metrics-insights-glossary.md)
+ [Problembehebung bei Metrics Insights](cloudwatch-metrics-insights-troubleshooting.md)
# Erstellen Sie Ihre Abfragen in CloudWatch Metrics Insights
Sie können eine CloudWatch Metrics Insights-Abfrage mit der CloudWatch Konsole AWS CLI, dem oder dem ausführen AWS SDKs. In der Konsole ausgeführte Abfragen sind gebührenfrei. Weitere Informationen zur CloudWatch Preisgestaltung finden Sie unter [ CloudWatch Amazon-Preise](https://aws.amazon.com/cloudwatch/pricing/).
Mit CloudWatch Metrics Insights können Sie Metrikdaten über längere Zeiträume von bis zu zwei Wochen analysieren. Dies ermöglicht im Vergleich zu kürzeren Aufbewahrungszeiträumen eine umfassendere historische Analyse und Trenderkennung. Für eine optimale Leistung bei der Abfrage längerer Zeitbereiche sollten Sie die Verwendung längerer Zeiträume (z. B. 5 Minuten oder 1 Stunde) in Betracht ziehen, um die Anzahl der zurückgegebenen Datenpunkte zu reduzieren. Wenn Sie Trends über den gesamten Zeitraum von zwei Wochen analysieren, sollten Sie in Ihren ORDER BY-Klauseln Aggregatfunktionen wie AVG() oder MAX() angeben, um Muster effizient zu identifizieren.
Weitere Informationen zur Verwendung von AWS SDKs zur Durchführung einer Metrics Insights-Abfrage finden Sie unter [GetMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html).
Gehen Sie folgendermaßen vor, um eine Abfrage mit der CloudWatch Konsole auszuführen:
**Ihre Metriken mit Metrics Insights abfragen**
1. Öffnen Sie die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Wählen Sie im Navigationsbereich **Metrics** (Metriken) **All metrics** (Alle Metriken) aus.
1. (Optional) Um eine vorgefertigte Beispielabfrage auszuführen, wählen Sie **Add query** (Abfrage hinzufügen) und wählen Sie die auszuführende Abfrage aus. Wenn Sie mit dieser Abfrage zufrieden sind, können Sie den Rest dieses Verfahrens überspringen. Oder Sie können den **Editor** auswählen, um die Beispielabfrage zu bearbeiten. Wählen Sie anschließend **Run** (Ausführen) aus, um die geänderte Abfrage auszuführen.
1. Um eine eigene Abfrage zu erstellen, wählen Sie **Abfrage mit mehreren Quellen** aus. Dann können Sie die **Builder-Ansicht** (Standard) verwenden, um eine geführte Erstellung zu starten, oder die **Editor-Ansicht**, wenn Sie die Abfragesyntax lieber sehen möchten. Sie können jederzeit zwischen den beiden Ansichten wechseln und Ihre laufende Arbeit in beiden Ansichten anzeigen.
Klicken Sie in der **Builder-Ansicht** auf die Felder für Namespace, Metriknamen, Filter, Gruppe, Reihenfolge und Limit, um mögliche Werte zu durchsuchen und auszuwählen. Sie können einen beliebigen Teil des Werts eingeben, nach dem Sie suchen, um die vom Builder angezeigte Liste zu filtern. In den Filter- und Gruppeneingaben können Sie auf Ressourcen-Tags verweisen.
In der **Editor-Ansicht** können Sie die von Metrics Insights unterstützte Teilmenge von SQL verwenden, um die Abfrage zu schreiben. Der Editor bietet Optionen zur automatischen Vervollständigung, die auf den bisher eingegebenen Zeichen basieren, einschließlich der Namen von Ressourcen-Tags für Metriken, die diese unterstützen.
CloudWatch Metrics Insights unterstützt das Abfragen von Metriken anhand von AWS Ressourcen-Tags. Sie können Tags verwenden, um Ihre Metrikdaten für eine gezieltere Überwachung und Analyse zu filtern und zu gruppieren.
Die folgenden Beispiele zeigen, wie Sie Abfragen mit Tags verwenden können.
Um die CPU-Auslastung für Amazon-EC2-Instances in Ihrer Produktionsumgebung zu sehen:
```
SELECT MAX(CPUUtilization) FROM SCHEMA("AWS/EC2") WHERE tag.env='prod'
```
Um die Metriken mithilfe der GROUP BY-Klausel nach Umgebung zu gruppieren:
```
SELECT MAX(CPUUtilization) FROM SCHEMA("AWS/EC2") GROUP BY tag.env
```
Um die GROUP BY-Klausel zu verwenden, in der Sie den Tag-Namen angeben:
```
SELECT AVG(CPUUtilization) FROM "AWS/EC2" GROUP BY tag."aws:cloudformation:stack-name"
```
Um Tag-Abfragen mit vorhandenen Metrikdimensionen zu kombinieren:
```
SELECT MAX(CPUUtilization) FROM SCHEMA("AWS/EC2") WHERE tag.env='prod' AND InstanceId='i-1234567890abcdef0'
```
1. Wenn Sie mit Ihrer Abfrage zufrieden sind, klicken Sie auf **Run** (Ausführen).
1. (Optional) Eine andere Möglichkeit, eine abgebildete Abfrage zu bearbeiten, besteht darin, die Registerkarte **Graphed metrics** (Grafisch dargestellte Metriken) auszuwählen und anschließend das Bearbeitungssymbol neben der Abfrageformel in der Spalte **Details** auszuwählen.
1. (Optional) Um eine Abfrage aus dem Diagramm zu entfernen, wählen Sie **Graphed metrics** (Grafisch dargestellte Metriken) und anschließend das Symbol **X** auf der rechten Seite der Zeile, in der Ihre Abfrage angezeigt wird.
# Abfragekomponenten und Syntax in CloudWatch Metrics Insights
CloudWatch Die Syntax von Metrics Insights lautet wie folgt.
```
SELECT FUNCTION(metricName)
FROM namespace | SCHEMA(...)
[ WHERE labelKey OPERATOR labelValue [AND ... ] ]
[ GROUP BY labelKey [ , ... ] ]
[ ORDER BY FUNCTION() [ DESC | ASC ] ]
[ LIMIT number ]
```
Die möglichen Klauseln in einer Metrics-Insights-Abfrage lauten wie folgt. Bei keinem der Schlüsselwörter wird Groß- und Kleinschreibung berücksichtigt, aber bei den Bezeichnern wie den Namen von Metriken, Namespaces und Dimensionen wird Groß- und Kleinschreibung beachtet.
**SELECT**
Erforderlich Gibt die Funktion an, die zum Aggregieren von Beobachtungen in jedem Zeit-Bucket verwendet werden soll (durch den angegebenen Zeitraum festgelegt). Gibt auch den Namen der abzufragenden Metrik an.
Die gültigen Werte für **FUNCTION** sind `AVG`, `COUNT`, `MAX`, `MIN` und `SUM`.
+ A`AVG` berechnet den Durchschnitt der Beobachtungen, die mit der Abfrage übereinstimmen.
+ `COUNT` gibt die Anzahl der Beobachtungen zurück, die mit der Abfrage übereinstimmen.
+ `MAX` gibt den Maximalwert der Beobachtungen zurück, die mit der Abfrage übereinstimmen.
+ `MIN` gibt den Minimalwert der Beobachtungen zurück, die mit der Abfrage übereinstimmen.
+ `SUM` berechnet die Summe der Beobachtungen, die mit der Abfrage übereinstimmen.
**FROM**
Erforderlich Gibt die Quelle der Metrik an. Sie können entweder den Metrik-Namespace angeben, der die abzufragende Metrik enthält, oder eine **SCHEMA**-Tabellenfunktion. Beispiele für Metrik-Namespaces sind `"AWS/EC2"`, `"AWS/Lambda"` und Metrik-Namespaces, die Sie für Ihre benutzerdefinierten Metriken erstellt haben.
Metrik-Namespaces, die **/** enthalten oder jedes andere Zeichen, das kein Buchstabe, keine Zahl und kein Unterstrich ist, müssen von doppelten Anführungszeichen umgeben sein. Weitere Informationen finden Sie unter [Was braucht Anführungszeichen oder Escape-Zeichen?](#cloudwatch-metrics-insights-syntaxdetails).
**SCHEMA**
Eine optionale Tabellenfunktion, die innerhalb einer **FROM**-Klausel verwendet werden kann. Verwenden Sie **SCHEMA**, um die Abfrageergebnisse nur auf die Metriken zu reduzieren, die genau mit einer Liste von Dimensionen übereinstimmen, oder auf Metriken, die keine Dimensionen haben.
Wenn Sie eine **SCHEMA**-Klausel verwenden, muss diese mindestens ein Argument enthalten. Das erste Argument muss der Metrik-Namespace sein, der abgefragt wird. Wenn Sie **SCHEMA** nur mit diesem Namespace-Argument angeben, werden die Ergebnisse nur auf Metriken beschränkt, die keine Dimensionen haben.
Wenn Sie **SCHEMA** mit zusätzlichen Argumenten angeben, müssen die zusätzlichen Argumente nach dem Namespace-Argument *Bezeichnungsschlüssel* sein. Bezeichnungsschlüssel müssen Dimensionsnamen sein. Wenn Sie einen oder mehrere dieser Bezeichnungsschlüssel angeben, werden die Ergebnisse nur auf die Metriken beschränkt, die genau diesen Dimensionssatz aufweisen. Die Reihenfolge dieser Bezeichnungsschlüssel spielt dabei keine Rolle.
Zum Beispiel:
+ **SELECT AVG(CPUUtilization) FROM "AWS/EC2"** entspricht allen `CPUUtilization`-Metriken im `AWS/EC2`-Namespace, unabhängig von ihren Dimensionen, und gibt eine einzelne aggregierte Zeitreihe zurück.
+ **SELECT AVG(CPUUtilization) FROM SCHEMA("AWS/EC2")** entspricht nur den `CPUUtilization`-Metriken im `AWS/EC2`-Namespace, für die keine Dimensionen definiert sind.
+ **SELECT AVG (CPUUtilization) FROM SCHEMA („AWS/EC2", InstanceId)** entspricht nur den `CPUUtilization` Metriken, für die berichtet wurde, CloudWatch mit genau einer Dimension,. `InstanceId`
+ **SELECT SUM (RequestCount) FROM SCHEMA („aws/ApplicationELB“ LoadBalancer, AvailabilityZone)** entspricht nur den `RequestCount` Metriken, an die CloudWatch von gemeldet wurde, `AWS/ApplicationELB` mit genau zwei Dimensionen, und. `LoadBalancer` `AvailabilityZone`
**WHERE**
Optional. Filtert die Ergebnisse nur nach den Metriken, die mit dem angegebenen Ausdruck übereinstimmen, wobei bestimmte Bezeichnungswerte für einen oder mehrere Bezeichnungsschlüssel verwendet werden. **Beispielsweise filtert **WHERE InstanceType = 'c3.4xlarge'** die Ergebnisse nur `c3.4xlarge` nach Instance-Typen und WHERE\$1 InstanceType = 'c3.4xlarge'** filtert die Ergebnisse nach allen Instanztypen außer. `c3.4xlarge`
Wenn Sie eine Abfrage in einem Überwachungskonto ausführen, können Sie `WHERE AWS.AccountId` verwenden, um die Ergebnisse auf das von Ihnen angegebene Konto zu beschränken. `WHERE AWS.AccountId=444455556666` fragt beispielsweise nur Metriken von Konto `444455556666` ab. Um Ihre Abfrage nur auf Metriken im Überwachungskonto selbst zu beschränken, verwenden Sie `WHERE AWS.AccountId=CURRENT_ACCOUNT_ID()`.
Bezeichnungswerte müssen immer mit einfachen Anführungszeichen eingeschlossen sein.
**Verwenden von Tags in WHERE-Klauseln**
Sie können Ergebnisse mithilfe der Syntax nach AWS Ressourcen-Tags filtern. `tag.keyName` Tag-Filter folgen denselben Operatorregeln wie Dimensionsfilter. Beispiel:
+ WHERE `tag.env = 'prod'` filtert nach Metriken aus Ressourcen, die mit *env=prod* markiert sind
+ WHERE `tag.department != 'test'` schließt Metriken aus Ressourcen aus, die mit *department=test* markiert sind
Tag-Filter können mit Dimensionsfiltern kombiniert werden:
`WHERE tag.env = 'prod' AND InstanceType = 'm5.large'`
**Unterstützte Operatoren**
Die **WHERE**-Klausel unterstützt die folgenden Operatoren:
+ **=** Der Bezeichnungswert muss mit der angegebenen Zeichenfolge übereinstimmen.
+ **\$1=** Der Bezeichnungswert muss nicht mit der angegebenen Zeichenfolge übereinstimmen.
+ **AND** Beide angegebenen Bedingungen müssen zutreffend sein, damit sie übereinstimmen. Sie können mehrere **AND**-Schlüsselwörter verwenden, um zwei oder mehr Bedingungen anzugeben.
**GROUP BY**
Optional. Gruppiert die Abfrageergebnisse in mehrere Zeitreihen, die jeweils einem anderen Wert für den angegebenen Bezeichnungsschlüssel oder die angegebenen Schlüssel entsprechen. Beispielsweise gibt `GROUP BY InstanceId` für jeden Wert eine andere Zeitreihe für jeden Wert von `InstanceId` zurück. Bei Verwendung von `GROUP BY ServiceName, Operation` wird eine andere Zeitreihe für jede mögliche Kombination der Werte von `ServiceName` und `Operation` erstellt.
Mit der Klausel **GROUP BY** werden die Ergebnisse standardmäßig in alphabetischer aufsteigender Reihenfolge angeordnet, wobei die in der Klausel **GROUP BY** angegebenen Bezeichnungssequenzen verwendet werden. Fügen Sie die Klausel **ORDER BY** zu Ihrer Anforderung hinzu, um die Reihenfolge der Ergebnisse zu ändern.
Wenn Sie eine Abfrage in einem Überwachungskonto ausführen, können Sie `GROUP BY AWS.AccountId` verwenden, um die Ergebnisse anhand der Konten zu gruppieren, von denen sie stammen.
**Verwenden von Tags in GROUP BY-Klauseln**
Mithilfe der Syntax können Sie Ergebnisse nach Werten für AWS Ressourcen-Tags gruppieren`tag.keyName`. Beispiel:
+ *GROUP BY tag.environment* erstellt separate Zeitreihen für jeden Umgebungs-Tag-Wert
+ *GROUP BY tag.team, InstanceType* Gruppen sowohl nach Tag- als auch nach Dimensionswerten
+ *GRUPPE VON tag.team, AWS. AccountId*Gruppen sowohl nach Tag als auch nach verknüpftem Quellkonto IDs
Wenn einige der übereinstimmenden Metriken keinen bestimmten Bezeichnungsschlüssel enthalten, der in der Klausel **GROUP BY** angegeben ist, wird eine Nullgruppe mit dem Namen `Other` zurückgegeben. Wenn Sie beispielsweise `GROUP BY ServiceName, Operation` angeben und einige der zurückgegebenen Metriken `ServiceName` nicht als Dimension enthalten, werden diese Metriken so angezeigt, als hätten sie `Other` als Wert für `ServiceName`.
**ORDER BY**
Optional. Gibt die Reihenfolge an, die für die zurückgegebene Zeitreihe verwendet werden soll, wenn die Abfrage mehr als eine Zeitreihe zurückgibt. Die Reihenfolge basiert auf den Werten, die von der **FUNCTION** gefunden werden, die Sie in der Klausel **ORDER BY** angegeben haben. Die **FUNCTION** wird verwendet, um einen einzelnen Skalarwert aus jeder zurückgegebenen Zeitreihe zu berechnen. Dieser Wert wird verwendet, um die Reihenfolge zu bestimmen.
Sie geben auch an, ob aufsteigend (**ASC**) oder absteigend (**DESC**) verwendet werden soll. Wenn Sie dies auslassen, ist die Standardeinstellung aufsteigend (**ASC**).
Fügen Sie zum Beispiel die Klausel `ORDER BY MAX() DESC` hinzu, werden die Ergebnisse nach dem maximalen Datenpunkt in absteigender Reihenfolge sortiert, der innerhalb des Zeitraums beobachtet wird. Das bedeutet, dass die Zeitreihe mit dem höchsten maximalen Datenpunkt zuerst zurückgegeben wird.
Die gültigen Funktionen, die innerhalb der Klausel **ORDER BY** verwendet werden, lauten `AVG()`, `COUNT()`, `MAX()`, `MIN()` und `SUM()`.
Wenn Sie die Klausel **ORDER BY** mit der Klausel **LIMIT** verwenden, ist die resultierende Abfrage eine „Top N“-Abfrage. **ORDER BY** ist auch nützlich für Abfragen, die möglicherweise eine große Anzahl von Metriken zurückgeben, da keine Abfrage mehr als 500 Zeitreihen zurückgeben kann. Wenn eine Abfrage mehr als 500 Zeitreihen entspricht und Sie die Klausel **ORDER BY** verwenden, werden die Zeitreihen sortiert und die 500 Zeitreihen, die in der Sortierreihenfolge zuerst stehen, werden zurückgegeben.
**LIMIT**
Optional. Beschränkt die Anzahl der von der Abfrage zurückgegebenen Zeitreihen auf den von Ihnen angegebenen Wert. Der Maximalwert, den Sie angeben können, ist 500, und eine Abfrage, die kein **LIMIT** angibt, kann ebenfalls maximal 500 Zeitreihen zurückgeben.
Wenn Sie die Klausel **LIMIT** mit der Klausel **ORDER BY** verwenden, erhalten Sie eine „Top N“-Abfrage.
## Was braucht Anführungszeichen oder Escape-Zeichen?
In einer Abfrage müssen Bezeichnungswerte immer mit einfachen Anführungszeichen eingeschlossen sein. Zum Beispiel **SELECT MAX (CPUUtilization) FROM „AWS/EC2"** WHERE = ''. AutoScalingGroupName my-production-fleet
Metrik-Namespaces, Metriknamen und Bezeichnungsschlüssel, die andere Zeichen als Buchstaben, Zahlen und Unterstriche (\$1) enthalten, müssen mit doppelten Anführungszeichen eingeschlossen sein. Beispiel: **SELECT MAX("My.Metric")**.
Wenn eine dieser Abfragen ein doppeltes Anführungszeichen oder ein einzelnes Anführungszeichen enthält (z. B. `Bytes"Input"`), muss jedem Anführungszeichen ein umgekehrter Schrägstrich vorangestellt werden, siehe **SELECT AVG("Bytes\$1"Input\$1"")**.
Wenn ein Metrik-Namespace, ein Metrikname oder ein Bezeichnungsschlüssel ein Wort enthält, das ein reserviertes Schlüsselwort in Metrics Insights ist, muss dieses auch in doppelten Anführungszeichen eingeschlossen sein. Wenn Sie beispielsweise eine Metrik mit dem Namen `LIMIT` haben, würden Sie `SELECT AVG("LIMIT")` benutzen. Es ist auch möglich, einen Namespace, einen Metriknamen oder eine Bezeichnung in doppelte Anführungszeichen einzuschließen, auch wenn kein reserviertes Schlüsselwort enthalten ist.
Eine vollständige Liste der reservierten Wörter finden Sie unter [Reservierte Schlüsselwörter](cloudwatch-metrics-insights-reserved-keywords.md).
## Eine umfangreiche Abfrage erstellen, Schritt für Schritt
Dieser Abschnitt veranschaulicht das Erstellen eines vollständigen Beispiels, das Schritt für Schritt alle möglichen Klauseln verwendet.
Sie können mit der folgenden Abfrage beginnen, die alle `RequestCount`-Metriken im Application Load Balancer aggregiert, die mit den beiden Dimensionen `LoadBalancer` und `AvailabilityZone` erfasst werden.
```
SELECT SUM(RequestCount)
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
```
Wenn Sie nur Metriken von einem bestimmten Load Balancer sehen möchten, können Sie die Klausel **WHERE** hinzufügen, um die zurückgegebenen Werte auf Metriken zu beschränken, bei denen der Wert der `LoadBalancer`-Dimension `app/load-balancer-1` ist.
```
SELECT SUM(RequestCount)
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
WHERE LoadBalancer = 'app/load-balancer-1'
```
Die vorhergehende Abfrage aggregiert die `RequestCount`-Metriken aus allen Availability Zones für diesen Load Balancer in eine Zeitreihe. Wenn Sie verschiedene Zeitreihen für jede Availability Zone sehen möchten, können wir die Klausel **GROUP BY** hinzufügen.
```
SELECT SUM(RequestCount)
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
WHERE LoadBalancer = 'app/load-balancer-1'
GROUP BY AvailabilityZone
```
Als Nächstes können Sie die Ergebnisse so anordnen, dass zuerst die höchsten Werte angezeigt werden. Die folgende **ORDER BY**-Klausel ordnet die Zeitreihe in absteigender Reihenfolge um den Maximalwert an, den jede Zeitreihe während des Abfragezeitraums gemeldet hat:
```
SELECT SUM(RequestCount)
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
WHERE LoadBalancer = 'app/load-balancer-1'
GROUP BY AvailabilityZone
ORDER BY MAX() DESC
```
Sie können auch Tags verwenden, um die Ergebnisse weiter zu filtern. Wenn Sie beispielsweise nur Ergebnisse für Load Balancer sehen möchten, die mit einer bestimmten Umgebung markiert sind, können wir der WHERE-Klausel eine Tag-Filterung hinzufügen:
```
SELECT SUM(RequestCount) FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone) WHERE LoadBalancer = 'app/load-balancer-1' AND tag.Environment = 'prod' GROUP BY AvailabilityZone ORDER BY MAX() DESC
```
Sie können die Ergebnisse auch nach Tag-Werten gruppieren – anstelle von oder zusätzlich zu Dimensionen. Beispielgruppierung nach dem Anwendungs-Tag:
```
SELECT SUM(RequestCount) FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone) WHERE tag.Environment = 'prod' GROUP BY tag.Application ORDER BY MAX() DESC
```
Wenn wir in erster Linie an einer „Top N“-Abfrage interessiert sind, können wir eine **LIMIT**-Klausel verwenden. Dieses letzte Beispiel beschränkt die Ergebnisse auf die Zeitreihe mit den fünf höchsten `MAX`-Werten.
```
SELECT SUM(RequestCount)
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
WHERE LoadBalancer = 'app/load-balancer-1'
GROUP BY AvailabilityZone
ORDER BY MAX() DESC
LIMIT 5
```
## Beispiele kontoübergreifender Abfragen
Diese Beispiele sind gültig, wenn sie in einem Konto ausgeführt werden, das als Überwachungskonto für kontenübergreifende Observability eingerichtet wurde. CloudWatch
Im folgenden Beispiel werden alle Amazon-EC2-Instances im Quellkonto 123456789012 durchsucht und der Durchschnitt zurückgegeben.
```
SELECT AVG(CpuUtilization)
FROM "AWS/EC2"
WHERE AWS.AccountId ='123456789012'
```
Im folgenden Beispiel wird die `CPUUtilization`-Metrik in `AWS/EC2` in allen verknüpften Quellkonten abgefragt und die Ergebnisse nach Konto-ID und Instance-Typ gruppiert.
```
SELECT AVG(CpuUtilization)
FROM "AWS/EC2"
GROUP BY AWS.AccountId, InstanceType
```
Im folgenden Beispiel wird die `CPUUtilization` im Überwachungskonto selbst abgefragt.
```
SELECT AVG(CpuUtilization)
FROM "AWS/EC2"
WHERE AWS.AccountId = CURRENT_ACCOUNT_ID()
```
# Reservierte Schlüsselwörter
Bei den folgenden Schlüsselwörtern handelt es sich um reservierte Schlüsselwörter in CloudWatch Metrics Insights. Wenn sich eines dieser Wörter in einem Namespace, einem Metriknamen oder einem Bezeichnungsschlüssel in einer Abfrage befindet, müssen Sie es in doppelte Anführungszeichen einschließen. Bei reservierten Schlüsselwörtern wird Groß- und Kleinschreibung nicht berücksichtigt.
```
"ABORT" "ABORTSESSION" "ABS" "ABSOLUTE" "ACCESS" "ACCESSIBLE" "ACCESS_LOCK" "ACCOUNT" "ACOS" "ACOSH" "ACTION" "ADD" "ADD_MONTHS"
"ADMIN" "AFTER" "AGGREGATE" "ALIAS" "ALL" "ALLOCATE" "ALLOW" "ALTER" "ALTERAND" "AMP" "ANALYSE" "ANALYZE" "AND" "ANSIDATE" "ANY" "ARE" "ARRAY",
"ARRAY_AGG" "ARRAY_EXISTS" "ARRAY_MAX_CARDINALITY" "AS" "ASC" "ASENSITIVE" "ASIN" "ASINH" "ASSERTION" "ASSOCIATE" "ASUTIME" "ASYMMETRIC" "AT",
"ATAN" "ATAN2" "ATANH" "ATOMIC" "AUDIT" "AUTHORIZATION" "AUX" "AUXILIARY" "AVE" "AVERAGE" "AVG" "BACKUP" "BEFORE" "BEGIN" "BEGIN_FRAME" "BEGIN_PARTITION",
"BETWEEN" "BIGINT" "BINARY" "BIT" "BLOB" "BOOLEAN" "BOTH" "BREADTH" "BREAK" "BROWSE" "BT" "BUFFERPOOL" "BULK" "BUT" "BY" "BYTE" "BYTEINT" "BYTES" "CALL",
"CALLED" "CAPTURE" "CARDINALITY" "CASCADE" "CASCADED" "CASE" "CASESPECIFIC" "CASE_N" "CAST" "CATALOG" "CCSID" "CD" "CEIL" "CEILING" "CHANGE" "CHAR",
"CHAR2HEXINT" "CHARACTER" "CHARACTERS" "CHARACTER_LENGTH" "CHARS" "CHAR_LENGTH" "CHECK" "CHECKPOINT" "CLASS" "CLASSIFIER" "CLOB" "CLONE" "CLOSE" "CLUSTER",
"CLUSTERED" "CM" "COALESCE" "COLLATE" "COLLATION" "COLLECT" "COLLECTION" "COLLID" "COLUMN" "COLUMN_VALUE" "COMMENT" "COMMIT" "COMPLETION" "COMPRESS" "COMPUTE",
"CONCAT" "CONCURRENTLY" "CONDITION" "CONNECT" "CONNECTION" "CONSTRAINT" "CONSTRAINTS" "CONSTRUCTOR" "CONTAINS" "CONTAINSTABLE" "CONTENT" "CONTINUE" "CONVERT",
"CONVERT_TABLE_HEADER" "COPY" "CORR" "CORRESPONDING" "COS" "COSH" "COUNT" "COVAR_POP" "COVAR_SAMP" "CREATE" "CROSS" "CS" "CSUM" "CT" "CUBE" "CUME_DIST",
"CURRENT" "CURRENT_CATALOG" "CURRENT_DATE" "CURRENT_DEFAULT_TRANSFORM_GROUP" "CURRENT_LC_CTYPE" "CURRENT_PATH" "CURRENT_ROLE" "CURRENT_ROW" "CURRENT_SCHEMA",
"CURRENT_SERVER" "CURRENT_TIME" "CURRENT_TIMESTAMP" "CURRENT_TIMEZONE" "CURRENT_TRANSFORM_GROUP_FOR_TYPE" "CURRENT_USER" "CURRVAL" "CURSOR" "CV" "CYCLE" "DATA",
"DATABASE" "DATABASES" "DATABLOCKSIZE" "DATE" "DATEFORM" "DAY" "DAYS" "DAY_HOUR" "DAY_MICROSECOND" "DAY_MINUTE" "DAY_SECOND" "DBCC" "DBINFO" "DEALLOCATE" "DEC",
"DECFLOAT" "DECIMAL" "DECLARE" "DEFAULT" "DEFERRABLE" "DEFERRED" "DEFINE" "DEGREES" "DEL" "DELAYED" "DELETE" "DENSE_RANK" "DENY" "DEPTH" "DEREF" "DESC" "DESCRIBE",
"DESCRIPTOR" "DESTROY" "DESTRUCTOR" "DETERMINISTIC" "DIAGNOSTIC" "DIAGNOSTICS" "DICTIONARY" "DISABLE" "DISABLED" "DISALLOW" "DISCONNECT" "DISK" "DISTINCT",
"DISTINCTROW" "DISTRIBUTED" "DIV" "DO" "DOCUMENT" "DOMAIN" "DOUBLE" "DROP" "DSSIZE" "DUAL" "DUMP" "DYNAMIC" "EACH" "ECHO" "EDITPROC" "ELEMENT" "ELSE" "ELSEIF",
"EMPTY" "ENABLED" "ENCLOSED" "ENCODING" "ENCRYPTION" "END" "END-EXEC" "ENDING" "END_FRAME" "END_PARTITION" "EQ" "EQUALS" "ERASE" "ERRLVL" "ERROR" "ERRORFILES",
"ERRORTABLES" "ESCAPE" "ESCAPED" "ET" "EVERY" "EXCEPT" "EXCEPTION" "EXCLUSIVE" "EXEC" "EXECUTE" "EXISTS" "EXIT" "EXP" "EXPLAIN" "EXTERNAL" "EXTRACT" "FALLBACK
"FALSE" "FASTEXPORT" "FENCED" "FETCH" "FIELDPROC" "FILE" "FILLFACTOR" "FILTER" "FINAL" "FIRST" "FIRST_VALUE" "FLOAT" "FLOAT4" "FLOAT8" "FLOOR"
"FOR" "FORCE" "FOREIGN" "FORMAT" "FOUND" "FRAME_ROW" "FREE" "FREESPACE" "FREETEXT" "FREETEXTTABLE" "FREEZE" "FROM" "FULL" "FULLTEXT" "FUNCTION"
"FUSION" "GE" "GENERAL" "GENERATED" "GET" "GIVE" "GLOBAL" "GO" "GOTO" "GRANT" "GRAPHIC" "GROUP" "GROUPING" "GROUPS" "GT" "HANDLER" "HASH"
"HASHAMP" "HASHBAKAMP" "HASHBUCKET" "HASHROW" "HAVING" "HELP" "HIGH_PRIORITY" "HOLD" "HOLDLOCK" "HOUR" "HOURS" "HOUR_MICROSECOND" "HOUR_MINUTE"
"HOUR_SECOND" "IDENTIFIED" "IDENTITY" "IDENTITYCOL" "IDENTITY_INSERT" "IF" "IGNORE" "ILIKE" "IMMEDIATE" "IN" "INCLUSIVE" "INCONSISTENT" "INCREMENT"
"INDEX" "INDICATOR" "INFILE" "INHERIT" "INITIAL" "INITIALIZE" "INITIALLY" "INITIATE" "INNER" "INOUT" "INPUT" "INS" "INSENSITIVE" "INSERT" "INSTEAD"
"INT" "INT1" "INT2" "INT3" "INT4" "INT8" "INTEGER" "INTEGERDATE" "INTERSECT" "INTERSECTION" "INTERVAL" "INTO" "IO_AFTER_GTIDS" "IO_BEFORE_GTIDS"
"IS" "ISNULL" "ISOBID" "ISOLATION" "ITERATE" "JAR" "JOIN" "JOURNAL" "JSON_ARRAY" "JSON_ARRAYAGG" "JSON_EXISTS" "JSON_OBJECT" "JSON_OBJECTAGG"
"JSON_QUERY" "JSON_TABLE" "JSON_TABLE_PRIMITIVE" "JSON_VALUE" "KEEP" "KEY" "KEYS" "KILL" "KURTOSIS" "LABEL" "LAG" "LANGUAGE" "LARGE" "LAST"
"LAST_VALUE" "LATERAL" "LC_CTYPE" "LE" "LEAD" "LEADING" "LEAVE" "LEFT" "LESS" "LEVEL" "LIKE" "LIKE_REGEX" "LIMIT" "LINEAR" "LINENO" "LINES"
"LISTAGG" "LN" "LOAD" "LOADING" "LOCAL" "LOCALE" "LOCALTIME" "LOCALTIMESTAMP" "LOCATOR" "LOCATORS" "LOCK" "LOCKING" "LOCKMAX" "LOCKSIZE" "LOG"
"LOG10" "LOGGING" "LOGON" "LONG" "LONGBLOB" "LONGTEXT" "LOOP" "LOWER" "LOW_PRIORITY" "LT" "MACRO" "MAINTAINED" "MAP" "MASTER_BIND"
"MASTER_SSL_VERIFY_SERVER_CERT" "MATCH" "MATCHES" "MATCH_NUMBER" "MATCH_RECOGNIZE" "MATERIALIZED" "MAVG" "MAX" "MAXEXTENTS" "MAXIMUM" "MAXVALUE"
"MCHARACTERS" "MDIFF" "MEDIUMBLOB" "MEDIUMINT" "MEDIUMTEXT" "MEMBER" "MERGE" "METHOD" "MICROSECOND" "MICROSECONDS" "MIDDLEINT" "MIN" "MINDEX"
"MINIMUM" "MINUS" "MINUTE" "MINUTES" "MINUTE_MICROSECOND" "MINUTE_SECOND" "MLINREG" "MLOAD" "MLSLABEL" "MOD" "MODE" "MODIFIES" "MODIFY"
"MODULE" "MONITOR" "MONRESOURCE" "MONSESSION" "MONTH" "MONTHS" "MSUBSTR" "MSUM" "MULTISET" "NAMED" "NAMES" "NATIONAL" "NATURAL" "NCHAR" "NCLOB"
"NE" "NESTED_TABLE_ID" "NEW" "NEW_TABLE" "NEXT" "NEXTVAL" "NO" "NOAUDIT" "NOCHECK" "NOCOMPRESS" "NONCLUSTERED" "NONE" "NORMALIZE" "NOT" "NOTNULL"
"NOWAIT" "NO_WRITE_TO_BINLOG" "NTH_VALUE" "NTILE" "NULL" "NULLIF" "NULLIFZERO" "NULLS" "NUMBER" "NUMERIC" "NUMPARTS" "OBID" "OBJECT" "OBJECTS"
"OCCURRENCES_REGEX" "OCTET_LENGTH" "OF" "OFF" "OFFLINE" "OFFSET" "OFFSETS" "OLD" "OLD_TABLE" "OMIT" "ON" "ONE" "ONLINE" "ONLY" "OPEN" "OPENDATASOURCE"
"OPENQUERY" "OPENROWSET" "OPENXML" "OPERATION" "OPTIMIZATION" "OPTIMIZE" "OPTIMIZER_COSTS" "OPTION" "OPTIONALLY" "OR" "ORDER" "ORDINALITY" "ORGANIZATION"
"OUT" "OUTER" "OUTFILE" "OUTPUT" "OVER" "OVERLAPS" "OVERLAY" "OVERRIDE" "PACKAGE" "PAD" "PADDED" "PARAMETER" "PARAMETERS" "PART" "PARTIAL" "PARTITION"
"PARTITIONED" "PARTITIONING" "PASSWORD" "PATH" "PATTERN" "PCTFREE" "PER" "PERCENT" "PERCENTILE" "PERCENTILE_CONT" "PERCENTILE_DISC" "PERCENT_RANK" "PERIOD" "PERM"
"PERMANENT" "PIECESIZE" "PIVOT" "PLACING" "PLAN" "PORTION" "POSITION" "POSITION_REGEX" "POSTFIX" "POWER" "PRECEDES" "PRECISION" "PREFIX" "PREORDER"
"PREPARE" "PRESERVE" "PREVVAL" "PRIMARY" "PRINT" "PRIOR" "PRIQTY" "PRIVATE" "PRIVILEGES" "PROC" "PROCEDURE" "PROFILE" "PROGRAM" "PROPORTIONAL"
"PROTECTION" "PSID" "PTF" "PUBLIC" "PURGE" "QUALIFIED" "QUALIFY" "QUANTILE" "QUERY" "QUERYNO" "RADIANS" "RAISERROR" "RANDOM" "RANGE" "RANGE_N" "RANK"
"RAW" "READ" "READS" "READTEXT" "READ_WRITE" "REAL" "RECONFIGURE" "RECURSIVE" "REF" "REFERENCES" "REFERENCING" "REFRESH" "REGEXP" "REGR_AVGX" "REGR_AVGY"
"REGR_COUNT" "REGR_INTERCEPT" "REGR_R2" "REGR_SLOPE" "REGR_SXX" "REGR_SXY" "REGR_SYY" "RELATIVE" "RELEASE" "RENAME" "REPEAT" "REPLACE" "REPLICATION"
"REPOVERRIDE" "REQUEST" "REQUIRE" "RESIGNAL" "RESOURCE" "RESTART" "RESTORE" "RESTRICT" "RESULT" "RESULT_SET_LOCATOR" "RESUME" "RET" "RETRIEVE" "RETURN"
"RETURNING" "RETURNS" "REVALIDATE" "REVERT" "REVOKE" "RIGHT" "RIGHTS" "RLIKE" "ROLE" "ROLLBACK" "ROLLFORWARD" "ROLLUP" "ROUND_CEILING" "ROUND_DOWN"
"ROUND_FLOOR" "ROUND_HALF_DOWN" "ROUND_HALF_EVEN" "ROUND_HALF_UP" "ROUND_UP" "ROUTINE" "ROW" "ROWCOUNT" "ROWGUIDCOL" "ROWID" "ROWNUM" "ROWS" "ROWSET"
"ROW_NUMBER" "RULE" "RUN" "RUNNING" "SAMPLE" "SAMPLEID" "SAVE" "SAVEPOINT" "SCHEMA" "SCHEMAS" "SCOPE" "SCRATCHPAD" "SCROLL" "SEARCH" "SECOND" "SECONDS"
"SECOND_MICROSECOND" "SECQTY" "SECTION" "SECURITY" "SECURITYAUDIT" "SEEK" "SEL" "SELECT" "SEMANTICKEYPHRASETABLE" "SEMANTICSIMILARITYDETAILSTABLE"
"SEMANTICSIMILARITYTABLE" "SENSITIVE" "SEPARATOR" "SEQUENCE" "SESSION" "SESSION_USER" "SET" "SETRESRATE" "SETS" "SETSESSRATE" "SETUSER" "SHARE" "SHOW"
"SHUTDOWN" "SIGNAL" "SIMILAR" "SIMPLE" "SIN" "SINH" "SIZE" "SKEW" "SKIP" "SMALLINT" "SOME" "SOUNDEX" "SOURCE" "SPACE" "SPATIAL" "SPECIFIC" "SPECIFICTYPE"
"SPOOL" "SQL" "SQLEXCEPTION" "SQLSTATE" "SQLTEXT" "SQLWARNING" "SQL_BIG_RESULT" "SQL_CALC_FOUND_ROWS" "SQL_SMALL_RESULT" "SQRT" "SS" "SSL" "STANDARD"
"START" "STARTING" "STARTUP" "STAT" "STATE" "STATEMENT" "STATIC" "STATISTICS" "STAY" "STDDEV_POP" "STDDEV_SAMP" "STEPINFO" "STOGROUP" "STORED" "STORES"
"STRAIGHT_JOIN" "STRING_CS" "STRUCTURE" "STYLE" "SUBMULTISET" "SUBSCRIBER" "SUBSET" "SUBSTR" "SUBSTRING" "SUBSTRING_REGEX" "SUCCEEDS" "SUCCESSFUL"
"SUM" "SUMMARY" "SUSPEND" "SYMMETRIC" "SYNONYM" "SYSDATE" "SYSTEM" "SYSTEM_TIME" "SYSTEM_USER" "SYSTIMESTAMP" "TABLE" "TABLESAMPLE" "TABLESPACE" "TAN"
"TANH" "TBL_CS" "TEMPORARY" "TERMINATE" "TERMINATED" "TEXTSIZE" "THAN" "THEN" "THRESHOLD" "TIME" "TIMESTAMP" "TIMEZONE_HOUR" "TIMEZONE_MINUTE" "TINYBLOB"
"TINYINT" "TINYTEXT" "TITLE" "TO" "TOP" "TRACE" "TRAILING" "TRAN" "TRANSACTION" "TRANSLATE" "TRANSLATE_CHK" "TRANSLATE_REGEX" "TRANSLATION" "TREAT"
"TRIGGER" "TRIM" "TRIM_ARRAY" "TRUE" "TRUNCATE" "TRY_CONVERT" "TSEQUAL" "TYPE" "UC" "UESCAPE" "UID" "UNDEFINED" "UNDER" "UNDO" "UNION" "UNIQUE"
"UNKNOWN" "UNLOCK" "UNNEST" "UNPIVOT" "UNSIGNED" "UNTIL" "UPD" "UPDATE" "UPDATETEXT" "UPPER" "UPPERCASE" "USAGE" "USE" "USER" "USING" "UTC_DATE"
"UTC_TIME" "UTC_TIMESTAMP" "VALIDATE" "VALIDPROC" "VALUE" "VALUES" "VALUE_OF" "VARBINARY" "VARBYTE" "VARCHAR" "VARCHAR2" "VARCHARACTER" "VARGRAPHIC"
"VARIABLE" "VARIADIC" "VARIANT" "VARYING" "VAR_POP" "VAR_SAMP" "VCAT" "VERBOSE" "VERSIONING" "VIEW" "VIRTUAL" "VOLATILE" "VOLUMES" "WAIT" "WAITFOR"
"WHEN" "WHENEVER" "WHERE" "WHILE" "WIDTH_BUCKET" "WINDOW" "WITH" "WITHIN" "WITHIN_GROUP" "WITHOUT" "WLM" "WORK" "WRITE" "WRITETEXT" "XMLCAST" "XMLEXISTS"
"XMLNAMESPACES" "XOR" "YEAR" "YEARS" "YEAR_MONTH" "ZEROFILL" "ZEROIFNULL" "ZONE"
```
# Alarme bei CloudWatch Metrics Insights-Abfragen in CloudWatch
Sie können Alarme in Metrics-Insights-Abfragen erstellen. Dies hilft Ihnen dabei, Alarme zu haben, die mehrere Ressourcen verfolgen, ohne dass sie später aktualisiert werden müssen. Die Abfrage erfasst neue Ressourcen und Ressourcen, die sich ändern. Sie können beispielsweise einen Alarm erstellen, der die CPU-Auslastung Ihrer Flotte überwacht, und der Alarm bewertet automatisch neue Instances, die Sie nach der Erstellung des Alarms starten.
In einem Monitoring-Konto, das für CloudWatch kontoübergreifende Beobachtbarkeit eingerichtet ist, können Ihre Metrics Insights-Alarme Ressourcen in Quellkonten und im Monitoring-Konto selbst überwachen. Weitere Informationen darüber, wie Sie Ihre AlarmAnforderungen auf ein bestimmtes Konto beschränken oder die Ergebnisse nach Konto-ID gruppieren können, finden Sie in den Abschnitten `WHERE` und `GROUP BY` unter [Abfragekomponenten und Syntax in CloudWatch Metrics Insights](cloudwatch-metrics-insights-querylanguage.md).
**Verwenden von Tags in Alarmabfragen**
Sie können Alarme für Metrics Insights-Abfragen erstellen, die AWS Ressourcen-Tags verwenden, um Metriken zu filtern und zu gruppieren. Um Tags mit Alarmen zu verwenden [https://console.aws.amazon.com/connect/](https://console.aws.amazon.com/connect/), wählen Sie auf dem **Einstellungen** aus. Wählen Sie auf der Seite **CloudWatch Einstellungen** unter **Ressourcen-Tags für Telemetrie aktivieren** die Option **Aktivieren** aus. Kontextsensitive Alarme überwachen bestimmte Anwendungen, Umgebungen oder Teams automatisch, wenn sich Ressourcen ändern.
Sie können beispielsweise einen Alarm erstellen, mit dem die CPU-Auslastung für alle Amazon-EC2-Instances überwacht wird, die mit einer bestimmten Anwendung markiert sind.
```
SELECT MAX(CPUUtilization) FROM "AWS/EC2" WHERE tag.Application = 'Orders' AND tag.Environment = 'Prod'
```
Tag-basierte Alarme passen sich automatisch an, wenn Sie Ressourcen mit entsprechenden Tags hinzufügen oder entfernen, und ermöglichen so eine dynamische Überwachung, die auf Ihre Betriebsstruktur abgestimmt ist.
**Contents**
+ [Einen Metrics CloudWatch Insights-Alarm erstellen](cloudwatch-metrics-insights-alarm-create.md)
# Einen Metrics CloudWatch Insights-Alarm erstellen
**So erstellen Sie einen Alarm für eine Metrics-Insights-Abfrage mit der Konsole**
1. Öffnen Sie die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Wählen Sie im Navigationsbereich **Metrics** (Metriken) **All metrics** (Alle Metriken) aus.
1. (Optional) Um eine vorgefertigte Beispielabfrage auszuführen, wählen Sie **Add query** (Abfrage hinzufügen) und wählen Sie die auszuführende Abfrage aus. Oder Sie können den **Editor** auswählen, um die Beispielabfrage zu bearbeiten. Wählen Sie anschließend **Run** (Ausführen) aus, um die geänderte Abfrage auszuführen.
1. Um eine eigene Abfrage zu erstellen, wählen Sie **Abfrage mit mehreren Quellen** aus. Dann können Sie die **Builder-Ansicht**, die **Editor-Ansicht** oder eine Kombination daraus verwenden. Sie können jederzeit zwischen den beiden Ansichten wechseln und Ihre laufende Arbeit in beiden Ansichten anzeigen.
In der Ansicht **Builder** können Sie den Metrik-Namespace, den Metriknamen, den Filter, die Gruppe und die Bestelloptionen durchsuchen und auswählen. Für jede dieser Optionen bietet Ihnen der Abfrage-Generator eine Liste von Auswahlmöglichkeiten in Ihrer Umgebung zur Auswahl.
In der Ansicht **Editor** können Sie mit dem Schreiben Ihrer Abfrage beginnen. Während der Eingabe bietet der Editor Vorschläge basierend auf den Zeichen, die Sie bisher eingegeben haben.
Wenn Sie beispielsweise eine Metrics-Insights-Abfrage für den Alarm erstellen, können Sie Tags angeben, um Metriken für eine gezieltere Überwachung zu filtern und zu gruppieren.
+ Nach Tags filtern: Mit `WHERE tag.keyName = 'value'` können Sie Ressourcen mit bestimmten Tags überwachen.
```
SELECT MAX(CPUUtilization) FROM "AWS/EC2" WHERE tag.Environment = 'Prod'
```
+ Tags mit Dimensionen kombinieren: Mischen Sie Tag-Filter mit vorhandenen Metrikdimensionen.
```
SELECT AVG(Duration) FROM "AWS/Lambda" WHERE tag.Application = 'OrderService' AND FunctionName = 'process%'
```
**Anmerkung**
Wenn Sie Tags verwenden, stimmen Alarme nur dann mit den Metriken überein, wenn die angegebenen Tags während des ausgewerteten Zeitraums in den zugehörigen Ressourcen vorhanden waren.
1. Wenn Sie mit Ihrer Abfrage zufrieden sind, klicken Sie auf **Run** (Ausführen).
1. Wählen Sie **Alarm erstellen** aus.
1. Geben Sie unter **Conditions (Bedingungen)** Folgendes an:
1. Geben Sie für **Whenever *metric* is** an, ob die Metrik größer, kleiner oder gleich dem Schwellenwert sein muss. Geben Sie unter **than... (dann ...)** den Schwellenwert an.
1. Wählen Sie **Additional configuration (Zusätzliche Konfiguration)**. Geben Sie unter **Datapoints to alarm (Datenpunkte für Alarm)** an, wie viele Auswertungszeiträume (Datenpunkte) im Status `ALARM` sein müssen, damit der Alarm ausgelöst wird. Wenn die beiden Werte hier übereinstimmen, erstellen Sie einen Alarm, der in den Status `ALARM` wechselt, wenn entsprechend viele aufeinanderfolgende Zeiträume überschritten werden.
Um einen M aus N Alarm zu erstellen, geben Sie eine niedrigere Zahl für den ersten Wert als für den zweiten Wert an. Weitere Informationen finden Sie unter [Auswertung von Alarmen](alarm-evaluation.md).
1. Wählen Sie für **Missing data treatment (Behandlung von fehlenden Daten)** aus, wie sich der Alarm verhalten soll, wenn einige Datenpunkte fehlen. Weitere Informationen finden Sie unter [Konfiguration der Behandlung fehlender Daten durch CloudWatch Alarme](alarms-and-missing-data.md).
1. Wählen Sie **Weiter** aus.
1. Wählen Sie unter **Notification (Benachrichtigung)** ein SNS-Thema aus, das benachrichtigt werden soll, wenn sich der Alarm im Status `ALARM`, `OK` oder `INSUFFICIENT_DATA` befindet.
Um zu erreichen, dass der Alarm mehrere Benachrichtigungen für den gleichen Alarmstatus oder für verschiedene Statuswerte sendet, wählen Sie **Benachrichtigung hinzufügen**.
Damit der Alarm keine Benachrichtigungen sendet, wählen Sie **Remove (Entfernen)**.
1. Um den Alarm Auto-Scaling-, EC2- oder Systems-Manager-Aktionen durchführen zu lassen, wählen Sie die entsprechende Schaltfläche und wählen Sie den Alarmstatus und die auszuführende Aktion. Alarme können Aktionen des Systems Manager nur ausführen, wenn sie in den ALARM-Zustand wechseln. Weitere Informationen zu Systems Manager Manager-Aktionen finden Sie unter [Konfiguration für CloudWatch die Erstellung OpsItems aus Alarmen](https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter-create-OpsItems-from-CloudWatch-Alarms.html) und [Incident-Erstellung](https://docs.aws.amazon.com/incident-manager/latest/userguide/incident-creation.html).
**Anmerkung**
Um einen Alarm zu erstellen, der eine SSM-Incident-Manager-Aktion ausführt, müssen Sie über bestimmte Berechtigungen verfügen. Weitere Informationen finden Sie unter [Beispiele für identitätsbasierte Richtlinien für AWS Systems Manager Incident Manager](https://docs.aws.amazon.com/incident-manager/latest/userguide/security_iam_id-based-policy-examples.html).
1. Wenn Sie fertig sind, wählen Sie **Weiter**.
1. Geben Sie einen Namen und eine Beschreibung für den Alarm ein. Der Name darf nur ASCII-Zeichen enthalten. Klicken Sie anschließend auf **Weiter**.
1. Bestätigen Sie unter **Preview and create (Vorschau und erstellen)**, dass die Informationen und Bedingungen den Anforderungen entsprechen, und wählen Sie dann **Create alarm (Alarm erstellen)**.
**Um einen Alarm für eine Metrics Insights-Abfrage zu erstellen, verwenden Sie AWS CLI**
Verwenden Sie den `put-metric-alarm`-Befehl und geben Sie im `metrics`-Parameter eine Metrics-Insights-Abfrage an. Mit dem folgenden Befehl wird beispielsweise ein Alarm ausgelöst, der in den Zustand ALARM wechselt, wenn die CPU-Auslastung einer Ihrer Instances über 50 % steigt.
```
aws cloudwatch put-metric-alarm —alarm-name Prod-App-CPU-Alarm —evaluation-periods 1 —comparison-operator GreaterThanThreshold —metrics '[{"Id":"m1","Expression":"SELECT MAX(CPUUtilization) FROM \"AWS/EC2\" WHERE tag.Environment = '\''Prod'\'' AND tag.Application = '\''OrderService'\''", "Period":60}]' —threshold 80
```
# Metrics-Insights-Abfragen mit Metrikberechnungen verwenden
Sie können eine Metrics-Insights-Abfrage als Eingabe für eine metrische mathematische Funktion verwenden. Weitere Informationen zu Metrikberechnungen finden Sie unter [Verwenden von mathematischen Ausdrücken mit CloudWatch Metriken](using-metric-math.md).
Eine Metrics-Insights-Abfrage, die keine **GROUP BY**-Klausel enthält, gibt eine einzige Zeitreihe zurück. Daher können die zurückgegebenen Ergebnisse mit jeder metrischen mathematischen Funktion verwendet werden, die eine einzelne Zeitreihe als Eingabe verwendet.
Eine Metrics-Insights-Abfrage, die eine **GROUP BY**-Klausel enthält, gibt mehrere Zeitreihen zurück. Daher können die zurückgegebenen Ergebnisse mit jeder metrischen mathematischen Funktion verwendet werden, die mehrere Zeitreihen als Eingabe verwendet.
Die folgende Abfrage gibt beispielsweise die Gesamtzahl der für jeden Bucket in der Region heruntergeladenen Bytes als Array von Zeitreihen zurück:
```
SELECT SUM(BytesDownloaded)
FROM SCHEMA("AWS/S3", BucketName, FilterId)
WHERE FilterId = 'EntireBucket'
GROUP BY BucketName
```
In einem Diagramm in der Konsole oder in einer [GetMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html)Operation werden `q1` die Ergebnisse dieser Abfrage angezeigt. Diese Abfrage gibt das Ergebnis in Byte zurück. Wenn Sie also das Ergebnis stattdessen als MB sehen möchten, können Sie die folgende mathematische Funktion verwenden:
```
q1/1024/1024
```
# Verwenden Sie natürliche Sprache, um CloudWatch Metrics Insights-Abfragen zu generieren und zu aktualisieren
CloudWatch unterstützt eine Abfragefunktion in natürlicher Sprache, mit der Sie Abfragen für [CloudWatchMetrics Insights und [CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html) Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/query_with_cloudwatch-metrics-insights.html) generieren und aktualisieren können.
Mit dieser Funktion können Sie Fragen zu den CloudWatch Daten, nach denen Sie suchen, stellen oder sie in einfachem Englisch beschreiben. Die Funktion in natürlicher Sprache generiert eine Abfrage auf der Grundlage einer von Ihnen eingegebenen Eingabeaufforderung und bietet eine line-by-line Erläuterung der Funktionsweise der Abfrage. Sie können Ihre Abfrage auch aktualisieren, um Ihre Daten weiter zu untersuchen.
Abhängig von Ihrer Umgebung können Sie Eingabeaufforderungen wie „Welche Instance in Amazon Elastic Compute Cloud hat den höchsten Netzwerkausgang?“ und „Zeigt mir die zehn Amazon DynamoDB-Tabellen mit den meisten verbrauchten Lesevorgängen.“ eingeben.
**Anmerkung**
Die Funktion „Abfrage in natürlicher Sprache“ ist in 10 Regionen allgemein verfügbar. In einigen Regionen führt die Funktion regionsübergreifende Aufrufe an Regionen in den USA aus, um die Abfrage-Prompts zu verarbeiten. In der folgenden Tabelle sehen Sie die unterstützten Regionen und wo die Prompts jeweils verarbeitet werden.
| Unterstützte Region | Region, in der Prompts verarbeitet werden |
| --- | --- |
| USA Ost (Nord-Virginia) | USA Ost (Nord-Virginia) |
| US East (Ohio) | USA Ost (Nord-Virginia) |
| USA West (Oregon) | USA West (Oregon) |
| Asien-Pazifik (Hongkong) | USA West (Oregon) |
| Asien-Pazifik (Singapur) | USA West (Oregon) |
| Asien-Pazifik (Sydney) | USA West (Oregon) |
| Asien-Pazifik (Tokio) | Asien-Pazifik (Tokio) |
| Europa (Frankfurt) | Europe (Frankfurt) |
| Europa (Irland) | USA Ost (Nord-Virginia) |
| Europa (Stockholm) | USA Ost (Nord-Virginia) |
Um eine CloudWatch Metrics Insights-Abfrage mit dieser Funktion zu generieren, öffnen Sie den CloudWatch Metrics Insights-Abfrage-Editor in der *Builder* - oder *Editor-Ansicht* und wählen Sie **Abfrage generieren** aus.
**Wichtig**
Um die Abfragefunktion in natürlicher Sprache zu verwenden, müssen Sie die [ReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/ReadOnlyAccess.html)Richtlinie [CloudWatchFullAccess[CloudWatchReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchReadOnlyAccess.html)](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchFullAccess.html),, [CloudWatchFullAccessV2 [AdministratorAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AdministratorAccess.html)](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchFullAccessV2.html), oder verwenden.
Sie können die `cloudwatch:GenerateQuery`-Aktion auch in eine neue oder bestehende, vom Kunden verwaltete oder integrierte Richtlinie aufnehmen.
## Beispielabfragen
In den Beispielen in diesem Abschnitt wird beschrieben, wie Abfragen mithilfe der natürlichen Sprachfunktion generiert und aktualisiert werden.
**Anmerkung**
Weitere Informationen zum Abfrageeditor und zur Syntax von CloudWatch Metrics Insights finden Sie unter [CloudWatch Metrics Insights-Abfragekomponenten und Syntax](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-metrics-insights-querylanguage.html).
### Beispiel: Eine Abfrage in natürlicher Sprache generieren
Um eine Abfrage in natürlicher Sprache zu generieren, geben Sie eine Aufforderung ein und wählen Sie **Neue Abfrage generieren**. Dieses Beispiel zeigt eine Abfrage, die eine einfache Suche durchführt.
**Prompt**
Im Folgenden finden Sie ein Beispiel für eine Eingabeaufforderung, die die Fähigkeit anweist, nach den 10 DynamoDB-Tabellen zu suchen, die die meiste Lesekapazität verbrauchen.
```
Show top 10 DynamoDB Tables by consumed reads
```
**Query**
Im Folgenden finden Sie ein Beispiel für eine Abfrage, die die Funktion natürlicher Sprache anhand der Eingabeaufforderung generiert. Beachten Sie, wie die Aufforderung in einem Kommentar vor der Abfrage erscheint. Nach der Abfrage können Sie eine Erklärung lesen, in der beschrieben wird, wie die Abfrage funktioniert.
```
# Show top 10 DynamoDB Tables by consumed reads
SELECT SUM("ConsumedReadCapacityUnits")
FROM "AWS/DynamoDB"
GROUP BY TableName
ORDER BY SUM() DESC
LIMIT 10
# This query selects the sum of consumed read capacity units for each DynamoDB table, groups the results by table name, orders the results from highest to lowest read capacity consumption, and limits the results to the top 10 tables.
```
**Anmerkung**
Verwenden Sie das Zahnradsymbol in Ihrem Editor, um das Erscheinungsbild Ihrer Aufforderung und die Erläuterung der Funktionsweise der Abfrage zu deaktivieren.
### Beispiel: Eine Abfrage in natürlicher Sprache aktualisieren
Sie können eine Abfrage aktualisieren, indem Sie die erste Eingabeaufforderung bearbeiten und dann **Abfrage aktualisieren** wählen.
**Aktualisierte Eingabeaufforderung**
Das folgende Beispiel zeigt eine aktualisierte Version der vorherigen Eingabeaufforderung. Anstatt einer Eingabeaufforderung, die nach den Top 10 DynamoDB-Tabellen sucht, die die meiste Lesekapazität verbrauchen, leitet diese Aufforderung nun die Funktion an, die Ergebnisse nach der Anzahl der zurückgegebenen Byte zu sortieren.
```
Sort by bytes returned instead
```
**Aktualisierte Abfrage**
Im Folgenden finden Sie ein Beispiel für die aktualisierte Abfrage. Beachten Sie, wie die Eingabeaufforderung in einem Kommentar vor der Abfrage erscheint. Nach der Abfrage können Sie eine Erklärung lesen, in der beschrieben wird, wie die ursprüngliche Abfrage aktualisiert wurde.
```
# Sort by bytes returned instead
SELECT SUM("ReturnedBytes")
FROM "AWS/DynamoDB"
GROUP BY TableName
ORDER BY SUM() DESC
LIMIT 10
# This query modifies the original query to select the sum of returned bytes instead of consumed read capacity units, and orders the results from highest to lowest sum of returned bytes, limiting the results to the top 10 tables.
```
## Abmeldung von der Verwendung Ihrer Daten zur Serviceverbesserung
Die Eingabeaufforderungs-Daten in natürlicher Sprache, die Sie bereitstellen, um das KI-Modell zu trainieren und relevante Abfragen zu generieren, werden ausschließlich zur Bereitstellung und Wartung Ihres Services verwendet. Diese Daten können verwendet werden, um die Qualität von CloudWatch Metrics Insights zu verbessern. Ihr Vertrauen, Ihre Privatsphäre sowie die Sicherheit Ihrer Inhalte sind unsere obersten Prioritäten. Weitere Informationen finden Sie unter [AWS -Service-Bedingungen](https://aws.amazon.com/service-terms/) und [AWS verantwortliche KI-Richtlinie](https://aws.amazon.com/machine-learning/responsible-ai/policy/).
Sie können die Verwendung Ihrer Inhalte zur Entwicklung oder Verbesserung der Qualität von Abfragen in natürlicher Sprache deaktivieren, indem Sie eine Opt-Out-Richtlinie für KI-Services erstellen. Um die Datenerfassung für alle CloudWatch KI-Funktionen, einschließlich der Funktion zur Abfragegenerierung, abzulehnen, müssen Sie eine Opt-Out-Richtlinie für erstellen CloudWatch. Weitere Informationen finden Sie unter [Opt-Out-Richtlinien für KI-Services](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html) im *Benutzerhandbuch für AWS Organizations *.
# SQL-Inferenz
CloudWatch Metrics Insights verwendet mehrere Mechanismen, um auf die Absicht einer bestimmten SQL-Abfrage zu schließen.
**Topics**
+ [Zeit-Bucketing](#cloudwatch-metrics-insights-inference-timebucketing)
+ [Projektion von Feldern](#cloudwatch-metrics-insights-inference-fieldsprojection)
+ [SORTIEREN NACH globaler Aggregation](#cloudwatch-metrics-insights-inference-OrderBy)
## Zeit-Bucketing
Zeitreihendatenpunkte, die sich aus einer Abfrage ergeben, werden basierend auf dem angeforderten Zeitraum in Zeitbuckets zusammengeführt. Um Werte in Standard-SQL zu aggregieren, muss eine explizite GROUP BY-Klausel definiert werden, um alle Beobachtungen eines bestimmten Zeitraums zusammen zu sammeln. Da dies die Standardmethode für die Abfrage von Zeitreihendaten ist, leitet CloudWatch Metrics Insights eine Zeitspanne ab, ohne dass eine explizite **GROUP** BY-Klausel ausgedrückt werden muss.
Wenn beispielsweise eine Abfrage mit einem Zeitraum von einer Minute ausgeführt wird, werden alle Beobachtungen, die zu dieser Minute bis zur nächsten (ausgeschlossen) gehören, bis zur Startzeit des Zeitbuckets zusammengeführt. Dies macht Metrics-Insights-SQL-Anweisungen prägnanter und weniger ausführlich.
```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
```
Die vorherige Abfrage gibt eine einzelne Zeitreihe (Zeitstempel-Wert-Paare) zurück, die die durchschnittliche CPU-Auslastung aller Amazon-EC2-Instances darstellt. Unter der Annahme, dass der angeforderte Zeitraum eine Minute beträgt, stellt jeder zurückgegebene Datenpunkt den Durchschnitt aller Beobachtungen dar, die innerhalb eines bestimmten Intervalls von einer Minute gemessen werden (Startzeit inklusive, Endzeit exklusiv). Der Zeitstempel, der sich auf den spezifischen Datenpunkt bezieht, ist die Startzeit des Buckets
## Projektion von Feldern
Metrics-Insights-Abfragen geben immer die Zeitstempelprojektion zurück. Sie müssen keine Zeitstempelspalte in der **SELECT**-Klausel angeben, um den Zeitstempel jedes entsprechenden Datenpunktwerts abzurufen. Weitere Informationen dazu, wie der Zeitstempel berechnet wird, finden Sie unter [Zeit-Bucketing](#cloudwatch-metrics-insights-inference-timebucketing).
Bei Verwendung von **GROUP BY** wird jeder Gruppenname ebenfalls abgeleitet und im Ergebnis projiziert, sodass Sie die zurückgegebenen Zeitreihen gruppieren können.
```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
GROUP BY InstanceId
```
Die vorherige Abfrage gibt eine Zeitreihe für jede Amazon-EC2-Instance zurück. Jede Zeitreihe wird nach dem Wert der Instance-ID beschriftet.
## SORTIEREN NACH globaler Aggregation
Wenn Sie **ORDER BY** verwenden, leitet **FUNCTION()** ab, nach welcher Aggregatfunktion Sie sortieren möchten (die Datenpunktwerte der abgefragten Metriken). Der Aggregatvorgang wird über alle übereinstimmenden Datenpunkte jeder einzelnen Zeitreihe im abgefragten Zeitfenster ausgeführt.
```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
GROUP BY InstanceId
ORDER BY MAX()
LIMIT 10
```
Die vorherige Abfrage gibt die CPU-Auslastung für jede Amazon-EC2-Instance zurück und beschränkt die Ergebnismenge auf 10 Einträge. Die Ergebnisse werden basierend auf dem Maximalwert der einzelnen Zeitreihe innerhalb des angeforderten Zeitfensters sortiert. Die **ORDER BY**-Klausel wird vor **LIMIT** angewendet, damit die Sortierung mit mehr als 10 Zeitreihen berechnet wird.
# Metrics-Insights-Kontingente
CloudWatch Metrics Insights hat derzeit die folgenden Kontingente:
+ Fragen Sie Daten aus bis zu zwei Wochen ab, um sie in Metriken, Widgets und Alarmdiagrammen zu visualisieren. Sie können die Daten der letzten drei Stunden abfragen, um den Alarmzustand zu bewerten.
+ Eine einzelne Abfrage kann nicht mehr als 10 000 Metriken verarbeiten. Dies bedeutet, wenn die Klauseln **SELECT**, **FROM** und **WHERE** mehr als 10 000 Metriken entsprechen, die Abfrage nur die ersten 10 000 der gefundenen Metriken verarbeitet.
+ Eine einzelne Abfrage kann nicht mehr als 500 Zeitreihen zurückgeben. Dies bedeutet, wenn die Abfrage mehr als 500 Metriken zurückgibt, nicht alle Metriken in den Abfrageergebnissen zurückgegeben werden. Wenn Sie eine **ORDER BY**-Klausel verwenden, werden alle zu verarbeitenden Metriken sortiert, und die 500, die nach der **ORDER BY**-Klausel den höchsten oder niedrigsten Wert haben, werden zurückgegeben.
Wenn Sie keine **ORDER BY**-Klausel einschließen, können Sie nicht steuern, welche 500 übereinstimmenden Metriken zurückgegeben werden.
+ Sie können bis zu 200 Metrics Insights-Alarme pro Region einrichten.
+ Metrics Inights unterstützt keine hochauflösenden Daten, wenn es sich um metrische Daten handelt, die mit einer Granularität von weniger als einer Minute gemeldet werden. Wenn Sie hochauflösende Daten anfordern, schlägt die Anforderung nicht fehl, sondern die Ausgabe wird mit einer Granularität von einer Minute aggregiert.
+ Jeder [GetMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html)Vorgang kann nur eine Abfrage haben, aber Sie können mehrere Widgets in einem Dashboard haben, die jeweils eine Abfrage enthalten.
+ Wenn eine Abfrage, die Tags mit einem **GROUP BY** oder **WHERE** verwendet, mit einer Metrik übereinstimmt, die mehr als 10 Tag-Updates enthält, werden nur die letzten 10 mit Tags versehenen Versionen der Metrik in die Abfrageergebnisse aufgenommen.
# Beispielabfragen für Metriken Insights
Dieser Abschnitt enthält Beispiele für nützliche CloudWatch Metrics Insights-Abfragen, die Sie kopieren und direkt verwenden oder im Abfrage-Editor kopieren und ändern können. Einige dieser Beispiele sind bereits in der Konsole verfügbar und Sie können auf sie zugreifen, indem Sie in der **Metrikanzeige** **Add query** (Abfrage hinzufügen) auswählen.
## Beispiele für Application Load Balancer
**Gesamtzahl der Anforderungen für alle Load Balancer**
```
SELECT SUM(RequestCount)
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer)
```
**Top 10 der aktivsten Load Balancer**
```
SELECT MAX(ActiveConnectionCount)
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer)
GROUP BY LoadBalancer
ORDER BY SUM() DESC
LIMIT 10
```
## AWS Beispiele für die API-Nutzung
**Die 20 besten Anrufe AWS APIs nach der Anzahl der Anrufe in Ihrem Konto**
```
SELECT COUNT(CallCount)
FROM SCHEMA("AWS/Usage", Class, Resource, Service, Type)
WHERE Type = 'API'
GROUP BY Service, Resource
ORDER BY COUNT() DESC
LIMIT 20
```
**CloudWatch APIs sortiert nach Anrufen**
```
SELECT COUNT(CallCount)
FROM SCHEMA("AWS/Usage", Class, Resource, Service, Type)
WHERE Type = 'API' AND Service = 'CloudWatch'
GROUP BY Resource
ORDER BY COUNT() DESC
```
## DynamoDB-Beispiele
**Top 10 Tabellen nach verbrauchten Lesevorgängen**
```
SELECT SUM(ProvisionedWriteCapacityUnits)
FROM SCHEMA("AWS/DynamoDB", TableName)
GROUP BY TableName
ORDER BY MAX() DESC LIMIT 10
```
**Top 10 Tabellen nach zurückgegebenen Bytes**
```
SELECT SUM(ReturnedBytes)
FROM SCHEMA("AWS/DynamoDB", TableName)
GROUP BY TableName
ORDER BY MAX() DESC LIMIT 10
```
**Top 10 Tabellen nach Benutzerfehlern**
```
SELECT SUM(UserErrors)
FROM SCHEMA("AWS/DynamoDB", TableName)
GROUP BY TableName
ORDER BY MAX() DESC LIMIT 10
```
## Beispiele für Amazon Elastic Block Store
**Top 10 Amazon-EBS-Volumes nach geschriebenen Bytes**
```
SELECT SUM(VolumeWriteBytes)
FROM SCHEMA("AWS/EBS", VolumeId)
GROUP BY VolumeId
ORDER BY SUM() DESC
LIMIT 10
```
**Durchschnittliche Schreibzeit des Amazon-EBS-Volumes**
```
SELECT AVG(VolumeTotalWriteTime)
FROM SCHEMA("AWS/EBS", VolumeId)
```
## Beispiele für Amazon EC2
**CPU-Auslastung von EC2-Instances sortiert nach den höchsten Auslastungen**
```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
GROUP BY InstanceId
ORDER BY AVG() DESC
```
**Durchschnittliche CPU-Auslastung für die gesamte Flotte**
```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
```
**Top 10 Instances nach höchster CPU-Auslastung**
```
SELECT MAX(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
GROUP BY InstanceId
ORDER BY MAX() DESC
LIMIT 10
```
**In diesem Fall erfasst der CloudWatch Agent eine `CPUUtilization` Metrik pro Anwendung. Diese Abfrage filtert den Durchschnitt dieser Metrik für einen bestimmten Anwendungsnamen.**
```
SELECT AVG(CPUUtilization)
FROM "AWS/CWAgent"
WHERE ApplicationName = 'eCommerce'
```
## Beispiele für Amazon Elastic Container Service
**Durchschnittliche CPU-Auslastung in allen ECS-Clustern**
```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/ECS", ClusterName)
```
**Top 10 Cluster nach Speicherauslastung**
```
SELECT AVG(MemoryUtilization)
FROM SCHEMA("AWS/ECS", ClusterName)
GROUP BY ClusterName
ORDER BY AVG() DESC
LIMIT 10
```
**Top 10 Services nach CPU-Auslastung**
```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/ECS", ClusterName, ServiceName)
GROUP BY ClusterName, ServiceName
ORDER BY AVG() DESC
LIMIT 10
```
**Top 10 Services durch Ausführen von Aufgaben (Container Insights)**
```
SELECT AVG(RunningTaskCount)
FROM SCHEMA("ECS/ContainerInsights", ClusterName, ServiceName)
GROUP BY ClusterName, ServiceName
ORDER BY AVG() DESC
LIMIT 10
```
## Beispiele für Amazon Elastic Kubernetes Service Container Insights
**Durchschnittliche CPU-Auslastung in allen EKS-Clustern**
```
SELECT AVG(pod_cpu_utilization)
FROM SCHEMA("ContainerInsights", ClusterName)
```
**Top 10 Cluster nach Knoten-CPU-Auslastung**
```
SELECT AVG(node_cpu_utilization)
FROM SCHEMA("ContainerInsights", ClusterName)
GROUP BY ClusterName
ORDER BY AVG() DESC LIMIT 10
```
**Top 10 Cluster nach Pod-Speicherauslastung**
```
SELECT AVG(pop_memory_utilization)
FROM SCHEMA("ContainerInsights", ClusterName)
GROUP BY ClusterName
ORDER BY AVG() DESC LIMIT 10
```
**Top 10 Knoten nach CPU-Auslastung**
```
SELECT AVG(node_cpu_utilization)
FROM SCHEMA("ContainerInsights", ClusterName, NodeName)
GROUP BY ClusterName, NodeName
ORDER BY AVG() DESC LIMIT 10
```
**Top 10 Pods nach Speicherauslastung**
```
SELECT AVG(pod_memory_utilization)
FROM SCHEMA("ContainerInsights", ClusterName, PodName)
GROUP BY ClusterName, PodName
ORDER BY AVG() DESC LIMIT 10
```
## EventBridge Beispiele
**Top 10 Regeln nach Aufrufen**
```
SELECT SUM(Invocations)
FROM SCHEMA("AWS/Events", RuleName)
GROUP BY RuleName
ORDER BY MAX() DESC LIMIT 10
```
**Top 10 Regeln nach fehlgeschlagenen Aufrufen**
```
SELECT SUM(FailedInvocations)
FROM SCHEMA("AWS/Events", RuleName)
GROUP BY RuleName
ORDER BY MAX() DESC LIMIT 10
```
**Top 10 Regeln nach übereinstimmenden Regeln**
```
SELECT SUM(MatchedEvents)
FROM SCHEMA("AWS/Events", RuleName)
GROUP BY RuleName
ORDER BY MAX() DESC LIMIT 10
```
## Beispiele für Kinesis
**Top 10 Streams nach geschriebenen Bytes**
```
SELECT SUM("PutRecords.Bytes")
FROM SCHEMA("AWS/Kinesis", StreamName)
GROUP BY StreamName
ORDER BY SUM() DESC LIMIT 10
```
**Top 10 Streams nach frühesten Items im Stream**
```
SELECT MAX("GetRecords.IteratorAgeMilliseconds")
FROM SCHEMA("AWS/Kinesis", StreamName)
GROUP BY StreamName
ORDER BY MAX() DESC LIMIT 10
```
## Beispiele für Lambda
**Lambda-Funktionen geordnet nach Anzahl der Aufrufe**
```
SELECT SUM(Invocations)
FROM SCHEMA("AWS/Lambda", FunctionName)
GROUP BY FunctionName
ORDER BY SUM() DESC
```
**Top 10 Lambda-Funktionen bei längster Laufzeit**
```
SELECT AVG(Duration)
FROM SCHEMA("AWS/Lambda", FunctionName)
GROUP BY FunctionName
ORDER BY MAX() DESC
LIMIT 10
```
**Top 10 Lambda-Funktionen nach Fehleranzahl**
```
SELECT SUM(Errors)
FROM SCHEMA("AWS/Lambda", FunctionName)
GROUP BY FunctionName
ORDER BY SUM() DESC
LIMIT 10
```
## CloudWatch Logs, Beispiele
**Top 10 Protokollgruppen nach eingehenden Ereignissen**
```
SELECT SUM(IncomingLogEvents)
FROM SCHEMA("AWS/Logs", LogGroupName)
GROUP BY LogGroupName
ORDER BY SUM() DESC LIMIT 10
```
**Top 10 Protokollgruppen nach geschriebenen Bytes**
```
SELECT SUM(IncomingBytes)
FROM SCHEMA("AWS/Logs", LogGroupName)
GROUP BY LogGroupName
ORDER BY SUM() DESC LIMIT 10
```
## Beispiele für Amazon RDS
**Top 10 Amazon-RDS-Instances nach höchster CPU-Auslastung**
```
SELECT MAX(CPUUtilization)
FROM SCHEMA("AWS/RDS", DBInstanceIdentifier)
GROUP BY DBInstanceIdentifier
ORDER BY MAX() DESC
LIMIT 10
```
**Top 10 Amazon-RDS-Cluster nach Schreibvorgängen**
```
SELECT SUM(WriteIOPS)
FROM SCHEMA("AWS/RDS", DBClusterIdentifier)
GROUP BY DBClusterIdentifier
ORDER BY MAX() DESC
LIMIT 10
```
## Beispiele für Amazon Simple Storage Service
**Durchschnittliche Latenz nach Bucket**
```
SELECT AVG(TotalRequestLatency)
FROM SCHEMA("AWS/S3", BucketName, FilterId)
WHERE FilterId = 'EntireBucket'
GROUP BY BucketName
ORDER BY AVG() DESC
```
**Top 10 Buckets nach heruntergeladenen Bytes**
```
SELECT SUM(BytesDownloaded)
FROM SCHEMA("AWS/S3", BucketName, FilterId)
WHERE FilterId = 'EntireBucket'
GROUP BY BucketName
ORDER BY SUM() DESC
LIMIT 10
```
## Beispiele für Amazon Simple Notification Service
**Gesamtzahl der von SNS-Themen veröffentlichten Nachrichten**
```
SELECT SUM(NumberOfMessagesPublished)
FROM SCHEMA("AWS/SNS", TopicName)
```
**Top 10 Themen nach veröffentlichten Nachrichten**
```
SELECT SUM(NumberOfMessagesPublished)
FROM SCHEMA("AWS/SNS", TopicName)
GROUP BY TopicName
ORDER BY SUM() DESC
LIMIT 10
```
**Top 10 Themen nach Fehlern bei der Nachrichtenübermittlung**
```
SELECT SUM(NumberOfNotificationsFailed)
FROM SCHEMA("AWS/SNS", TopicName)
GROUP BY TopicName
ORDER BY SUM() DESC
LIMIT 10
```
## Beispiele für Amazon SQS
**Top-10-Warteschlangen nach der Anzahl sichtbarer Nachrichten**
```
SELECT AVG(ApproximateNumberOfMessagesVisible)
FROM SCHEMA("AWS/SQS", QueueName)
GROUP BY QueueName
ORDER BY AVG() DESC
LIMIT 10
```
**Die 10 aktivsten Warteschlangen**
```
SELECT SUM(NumberOfMessagesSent)
FROM SCHEMA("AWS/SQS", QueueName)
GROUP BY QueueName
ORDER BY SUM() DESC
LIMIT 10
```
**Top 10 Warteschlangen nach Alter der ersten Nachricht**
```
SELECT AVG(ApproximateAgeOfOldestMessage)
FROM SCHEMA("AWS/SQS", QueueName)
GROUP BY QueueName
ORDER BY AVG() DESC
LIMIT 10
```
# Glossar zu Metric Insights
**Bezeichnung**
In Metrics Insights ist ein Bezeichner ein Schlüssel-Wert-Paar, das verwendet wird, um eine Abfrage zu veranlassen, einen bestimmten Datensatz zurückzugeben oder um Kriterien zu definieren, durch die Abfrageergebnisse in separate Zeitreihen unterteilt werden sollen. Ein Bezeichnungsschlüssel ähnelt einem Spaltennamen in SQL. Bei Beschriftungen muss es sich um CloudWatch metrische Dimensionen handeln.
**Beobachtung**
Eine Beobachtung ist ein Wert, der zu einem bestimmten Zeitpunkt für eine bestimmte Metrik aufgezeichnet wurde.
# Problembehebung bei Metrics Insights
## Die Ergebnisse beinhalten „Andere“, aber ich habe das nicht als Dimension
Dies bedeutet, dass die Abfrage eine **GROUP BY**-Klausel enthält, die einen Bezeichnungsschlüssel angibt, der in einigen der Metriken, die von der Abfrage zurückgegeben werden, nicht verwendet wird. In diesem Fall wird eine Nullgruppe mit dem Namen `Other` zurückgegeben. Die Metriken, die diesen Bezeichnungsschlüssel nicht enthalten, sind wahrscheinlich aggregierte Metriken, die Werte zurückgeben, die über alle Werte dieses Bezeichnungsschlüssels aggregiert sind.
Angenommen, wir haben die folgende Abfrage:
```
SELECT AVG(Faults)
FROM MyCustomNamespace
GROUP BY Operation, ServiceName
```
Wenn beispielsweise einige der zurückgegebenen Metriken `ServiceName` nicht als Dimension enthalten, werden diese Metriken so angezeigt, als hätte sie `Other` als Wert für `ServiceName`.
Um zu verhindern, dass „Andere“ in Ihren Ergebnissen angezeigt wird, verwenden Sie **SCHEMA** in Ihrer **FROM**-Klausel, wie im folgenden Beispiel dargestellt:
```
SELECT AVG(Faults)
FROM SCHEMA(MyCustomNamespace, Operation)
GROUP BY Operation, ServiceName
```
Dies beschränkt die zurückgegebenen Ergebnisse nur auf die Metriken, die über die Dimensionen `Operation` und `ServiceName` verfügen.
## Der älteste Zeitstempel in meinem Diagramm hat einen niedrigeren Metrikwert als die anderen
CloudWatch Metrics Insights unterstützt historische Daten für bis zu zwei Wochen. Wenn Sie ein Diagramm mit einer Periode von mehr als einer Minute erstellen, kann es Fälle geben, in denen der älteste Datenpunkt vom erwarteten Wert abweicht. Dies liegt daran, dass die CloudWatch Metrics Insights-Abfragen nur Daten innerhalb der zweiwöchigen Aufbewahrungsfrist zurückgeben. In diesem Fall gibt der älteste Datenpunkt in der Abfrage nur die Beobachtungen zurück, die in diesem zweiwöchigen Zeitraum gemessen wurden, anstatt alle Beobachtungen innerhalb des Zeitraums dieses Datenpunkts zurückzugeben.
## Inkonsistente Metrikwerte über verschiedene Zeiträume hinweg bei der Verwendung von tagbasierten Abfragen
Wenn Sie `WHERE` `GROUP BY` OR-Klauseln mit Tags in CloudWatch Metrics Insights-Abfragen verwenden, werden Ihnen je nach ausgewähltem Zeitraum möglicherweise unterschiedliche Metrikwerte angezeigt. Beispielsweise kann in einem Zeitraum von 6 Stunden ein Spitzenwert von 20 angezeigt werden, während in einem Zeitraum von 1 Stunde nur 2 für dasselbe Zeitfenster angezeigt werden.
Dies liegt daran, dass Tag-Zeitstempel mit einer Auflösung der zweiten Ebene gespeichert werden, während metrische Datenpunkte an Periodengrenzen ausgerichtet sind (z. B. dem Beginn jeder Minute oder Stunde). Um zu ermitteln, welche Datenpunkte einem Tag-Zeitbereich entsprechen, CloudWatch passt der Anfang des Bereichs an, indem eine Periode subtrahiert wird. Bei größeren Zeiträumen entsteht durch diese Anpassung eine größere Lücke zwischen dem Tag-Zeitstempel und dem frühesten eingeschlossenen Datenpunkt, was dazu führen kann, dass Datenpunkte, die sich am Anfang des Bereichs befinden, ausgeschlossen werden.
Das folgende Beispiel zeigt, wie sich dies auf die Abfrageergebnisse auswirkt. Eine Metrik hat zwei Tag-Werte: `env=beta` (von 00:00 bis 01:30) und `env=gamma` (von 01:30 bis 03:00). Jedes Tag deckt 90 Minuten an Daten mit einer SUMME von 270 ab.
![\[Zwei CloudWatch Metrikdiagramme, in denen Tag-basierte Abfrageergebnisse mit Zeiträumen von 1 Minute und 3 Stunden verglichen werden.\]](http://docs.aws.amazon.com/de_de/AmazonCloudWatch/latest/monitoring/images/metrics-insights-tag-alignment.png)
| **env=beta mit einem Zeitraum von 1 Minute** | Statistik | Expected | Ist zurückgekehrt | Unterschied |
| --- | --- | --- | --- | --- |
| SUM | 270 | 271 | \$11 |
| AVG | 3.0 | 3.0 | 0 |
| MIN | 1 | 1 | 0 |
| MAX | 5 | 5 | 0 |
| ANZAHL DER STICHPROBEN | 90 | 91 | \$11 |
| **env=gamma mit einem Zeitraum von 1 Minute** | Statistik | Expected | Ist zurückgekehrt | Unterschied |
| --- | --- | --- | --- | --- |
| SUM | 270 | 275 | 5\$1 |
| AVG | 3.0 | 3.0 | 0 |
| MIN | 1 | 1 | 0 |
| MAX | 5 | 5 | 0 |
| ANZAHL DER STICHPROBEN | 90 | 91 | \$11 |
Bei einem Zeitraum von 1 Minute ist die Anpassung der Ausrichtung gering (1 Minute), sodass nur 1 zusätzlicher Datenpunkt pro Tag enthalten ist. Bei einem Zeitraum von 3 Stunden erstreckt sich die Anpassung über den gesamten Abfragebereich:
| **env=beta mit einem Zeitraum von 3 Stunden** | Statistik | Expected | Ist zurückgekehrt | Unterschied |
| --- | --- | --- | --- | --- |
| SUM | 270 | 540 | \$1270 |
| AVG | 3.0 | 3.0 | 0 |
| MIN | 1 | 1 | 0 |
| MAX | 5 | 5 | 0 |
| ANZAHL DER STICHPROBEN | 90 | 180 | \$190 |
| **env=gamma mit einem Zeitraum von 3 Stunden** | Statistik | Expected | Ist zurückgekehrt | Unterschied |
| --- | --- | --- | --- | --- |
| SUM | 270 | 540 | \$1270 |
| AVG | 3.0 | 3.0 | 0 |
| MIN | 1 | 1 | 0 |
| MAX | 5 | 5 | 0 |
| ANZAHL DER STICHPROBEN | 90 | 180 | \$190 |
Bei einem Zeitraum von 3 Stunden geben beide Tags den gesamten Datensatz zurück (SUM=540, SAMPLE\$1COUNT=180), da der Zeitstempel des einzelnen aggregierten Datenpunkts in beide angepassten Bereiche fällt. Die Tag-Grenze wird effektiv gelöscht.
Um die Auswirkungen dieses Verhaltens zu verringern, probieren Sie die folgenden Ansätze aus:
+ **Verwenden Sie kleinere Aggregationsperioden.** Kleinere Zeiträume (z. B. 1 Minute oder 5 Minuten) entsprechen eher der Auflösung von Tag-Zeitstempeln auf zweiter Ebene, wodurch die Ausrichtungslücke minimiert und die Wahrscheinlichkeit erhöht wird, dass alle relevanten Datenpunkte enthalten sind.
+ **Verwenden Sie dimensionsbasierte Filterung anstelle von Tags.** Wenn Ihr Anwendungsfall dies zulässt, filtern Sie nach Dimensionen und nicht nach Tags. Dimensionsbasierte Abfragen sind von diesem Verhalten nicht betroffen. Verwenden Sie z. B. `WHERE InstanceId = 'i-1234567890abcdef0'` statt `WHERE tag."my-tag" = 'my-value'`.
+ **Abfragen mit einer konsistenten Granularität.** Verwenden Sie beim Vergleich von Metrikdaten in verschiedenen Zeitfenstern denselben Zeitraum, um unerwartete Unterschiede zu vermeiden, die durch die Anpassung der Ausrichtung verursacht werden.