.*?)/ | stats avg(latency2) by @method2,
@user2
```
**Extrahiert die Felder `loggingTime`, `loggingType` und `loggingMessage`, filtert nach Protokollereignissen, die die Zeichenfolgen `ERROR` oder `INFO` enthalten, und zeigt dann nur die Felder `loggingMessage` und `loggingType` für Ereignisse an, die die Zeichenfolge `ERROR` enthalten.**
```
FIELDS @message
| PARSE @message "* [*] *" as loggingTime, loggingType, loggingMessage
| FILTER loggingType IN ["ERROR", "INFO"]
| DISPLAY loggingMessage, loggingType = "ERROR" as isError
```
# sort
Verwenden Sie `sort`, um Protokollereignisse in aufsteigender (`asc`) oder absteigender (`desc`) Reihenfolge nach einem bestimmten Feld anzuzeigen Sie können dies zusammen mit dem Befehl `limit` verwenden, um „Obere N“- oder „Untere N“-Abfragen zu erstellen.
Der Sortieralgorithmus ist eine aktualisierte Version der natürlichen Sortierung. Wenn Sie in aufsteigender Reihenfolge sortieren, wird die folgende Logik verwendet.
+ Alle Werte, die keine Zahlen sind, stehen vor allen Zahlenwerten. *Zahlenwerte* sind Werte, die nur Zahlen enthalten, keine Mischung aus Zahlen und anderen Zeichen.
+ Bei Werten, die keine Zahlen sind, gruppiert der Algorithmus aufeinanderfolgende numerische Zeichen und aufeinanderfolgende alphabetische Zeichen zum Vergleich in separate Blöcke. Er ordnet nichtnumerische Teile nach ihren Unicode-Werten und numerische Teile zuerst nach ihrer Länge und dann nach ihrem numerischen Wert.
Weitere Informationen zur Unicode-Reihenfolge finden Sie unter [Liste der Unicode-Zeichen](https://en.wikipedia.org/wiki/List_of_Unicode_characters).
Das Folgende ist beispielsweise das Ergebnis einer Sortierung in aufsteigender Reihenfolge.
```
!: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sorted by unicode order
#
*%04
0# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Alphanumeric starting with numbers
5A
111A >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Starts with more digits than 5A, so it sorted to be later than 5A
2345_
@ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2345 is compared with @ in the unicode order,
@_
A >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Values starting with letters
A9876fghj
a12345hfh
0 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Number values
01
1
2
3
```
Wenn Sie in absteigender Reihenfolge sortieren, sind die Sortierergebnisse umgekehrt.
Die folgende Abfrage für Flussprotokolle von Amazon VPC findet zum Beispiel die ersten 15 Paketübertragungen zwischen Hosts.
```
stats sum(packets) as packetsTransferred by srcAddr, dstAddr
| sort packetsTransferred desc
| limit 15
```
# stats
Verwenden Sie `stats`, um Visualisierungen Ihrer Protokolldaten zu erstellen, z. B. Balkendiagramme, Liniendiagramme und gestapelte Flächendiagramme. Auf diese Weise können Sie Muster in Ihren Protokolldaten effizienter identifizieren. CloudWatch Logs Insights generiert Visualisierungen für Abfragen, die die `stats` Funktion und eine oder mehrere Aggregationsfunktionen verwenden.
Beispielsweise gibt die folgende Abfrage in einer Route-53-Protokollgruppe Visualisierungen zurück, die die Verteilung der Route-53-Datensätze pro Stunde nach Abfragetyp zeigen.
```
stats count(*) by queryType, bin(1h)
```
Mit all diesen Abfragen können Balkendiagramme erzeugt werden. Wenn Ihre Abfrage die Funktion `bin()` verwendet, um Daten nach einem einzelnen Feld im Zeitverlauf zu gruppieren, können Sie auch Liniendiagramme und gestapelte Flächendiagramme anzeigen.
Für die Funktion `bin` werden folgende Zeiteinheiten und Abkürzungen unterstützt. Alle Einheiten und Abkürzungen, die mehr als ein Zeichen enthalten, können durch Hinzufügen von „s“ pluralisiert werden. Somit kann sowohl `hr` als auch `hrs` verwendet werden, um Stunden anzugeben.
+ `millisecond` `ms` `msec`
+ `second` `s` `sec`
+ `minute` `m` `min`
+ `hour` `h` `hr`
+ `day` `d`
+ `week` `w`
+ `month` `mo` `mon`
+ `quarter` `q` `qtr`
+ `year` `y` `yr`
**Topics**
+ [Visualisieren von Zeitreihendaten](#CWL_Insights-Visualizing-TimeSeries)
+ [Visualisieren von nach Feldern gruppierten Protokolldaten](#CWL_Insights-Visualizing-ByFields)
+ [Verwenden mehrerer Statistikbefehle in einer einzigen Abfrage](#CWL_QuerySyntax-stats-multi)
+ [Funktionen zur Verwendung mit „stats“](#CWL_QuerySyntax-stats-functions)
## Visualisieren von Zeitreihendaten
Visualisierungen von Zeitreihen funktionieren für Abfragen mit folgenden Merkmalen:
+ Die Abfrage enthält eine oder mehrere Aggregationsfunktionen. Weitere Informationen finden Sie unter [Aggregation Functions in the Stats Command](#CWL_Insights_Aggregation_Functions).
+ Die Abfrage verwendet die `bin()`-Funktion. Damit können Sie die Daten nach einem Feld gruppieren.
Diese Abfragen können Linien-, Flächen- Balken- und Kreisdiagramme erzeugen.
**Beispiele**
Ein vollständiges Tutorial finden Sie unter [Tutorial: Ausführen einer Abfrage, die eine Visualisierung von Zeitreihen erzeugt](CWL_AnalyzeLogData_VisualizationQuery.md).
Im Folgenden finden Sie weitere Beispielabfragen, die für die Zeitreihenvisualisierung funktionieren.
Die folgende Abfrage erzeugt eine Visualisierung der Durchschnittswerte des `myfield1`-Felds an, mit einem Datenpunkt, der alle fünf Minuten erstellt wird. Jeder Datenpunkt ist die Aggregation der Durchschnitte der `myfield1`-Werte aus den Protokollen der letzten fünf Minuten.
```
stats avg(myfield1) by bin(5m)
```
Die folgende Abfrage erzeugt eine Visualisierung von drei Werten basierend auf verschiedenen Feldern, wobei alle fünf Minuten ein Datenpunkt erstellt wird. Die Visualisierung wird erzeugt, weil die Abfrage Aggregationsfunktionen enthält und `bin()` als Gruppierungsfeld verwendet.
```
stats avg(myfield1), min(myfield2), max(myfield3) by bin(5m)
```
**Einschränkungen von Linien- und gestapelten Flächendiagrammen**
Abfragen, die Protokolleintragsinformationen aggregieren, die Funktion `bin()` jedoch nicht verwenden, können Balkendiagramme generieren. Die Abfragen können jedoch keine Liniendiagramme oder gestapelte Flächendiagramme generieren. Weitere Informationen zu diesen Abfragetypen finden Sie unter [Visualisieren von nach Feldern gruppierten Protokolldaten](#CWL_Insights-Visualizing-ByFields).
## Visualisieren von nach Feldern gruppierten Protokolldaten
Sie können Balkendiagramme für Abfragen erstellen, die die `stats`-Funktion und eine oder mehrere Aggregationsfunktionen verwenden. Weitere Informationen finden Sie unter [Aggregation Functions in the Stats Command](#CWL_Insights_Aggregation_Functions).
Führen Sie die Abfrage aus, um die Visualisierung aufzurufen. Wählen Sie dann die Registerkarte **Visualisierung** aus, klicken Sie auf den Pfeil neben **Linie** und auf **Balken**. Visualisierungen sind mit maximal 100 Balken im Balkendiagramm beschränkt.
**Beispiele**
Ein vollständiges Tutorial finden Sie unter [Tutorial: Ausführen einer Abfrage, die eine nach Protokollfeldern gruppierte Visualisierung erzeugt](CWL_AnalyzeLogData_VisualizationFieldQuery.md). Die folgenden Absätze enthalten weitere Beispielabfragen für die Visualisierung nach Feldern.
Die folgende VPC-Flow-Protokollabfrage ermittelt die durchschnittliche Anzahl von Bytes, die pro Sitzung für die einzelnen Zieladressen übertragen werden.
```
stats avg(bytes) by dstAddr
```
Sie können auch ein Diagramm erstellen, das mehr als einen Balken für jeden resultierenden Wert enthält. Die folgende VPC-Flow-Protokollabfrage ermittelt beispielsweise die durchschnittliche und maximale Anzahl von Bytes, die pro Sitzung an die einzelnen Zieladressen übertragen werden.
```
stats avg(bytes), max(bytes) by dstAddr
```
Die folgende Abfrage ermittelt die Anzahl der Amazon-Route-53-Abfrageprotokolle für jeden Abfragetyp.
```
stats count(*) by queryType
```
## Verwenden mehrerer Statistikbefehle in einer einzigen Abfrage
Sie können bis zu zwei `stats`-Befehle in einer einzigen Abfrage verwenden. Auf diese Weise können Sie eine zusätzliche Aggregation für die Ausgabe der ersten Aggregation durchführen.
**Beispiel: Abfrage mit zwei `stats`-Befehlen**
Die folgende Abfrage ermittelt beispielsweise zuerst das gesamte Verkehrsaufkommen in 5-Minuten-Abschnitten und berechnet dann das höchste, niedrigste und durchschnittliche Verkehrsaufkommen unter diesen 5-Minuten-Abschnitten.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length)/1024/1024 as logs_mb BY bin(5m)
| STATS max(logs_mb) AS peak_ingest_mb,
min(logs_mb) AS min_ingest_mb,
avg(logs_mb) AS avg_ingest_mb
```
**Beispiel: Kombinieren Sie mehrere Statistikbefehle mit anderen Funktionen wie `filter`, `fields`, `bin`**
Sie können zwei `stats`-Befehle mit anderen Befehlen wie `filter` und `fields` in einer einzigen Abfrage kombinieren. Die folgende Abfrage ermittelt beispielsweise die Anzahl der unterschiedlichen IP-Adressen in Sitzungen und ermittelt die Anzahl der Sitzungen nach Clientplattform, filtert diese IP-Adressen und ermittelt schließlich den Durchschnitt der Sitzungsanfragen pro Clientplattform.
```
STATS count_distinct(client_ip) AS session_ips,
count(*) AS requests BY session_id, client_platform
| FILTER session_ips > 1
| STATS count(*) AS multiple_ip_sessions,
sum(requests) / count(*) AS avg_session_requests BY client_platform
```
Sie können die `bin`- und `dateceil`-Funktionen in Abfragen mit mehreren `stats`-Befehlen verwenden. Die folgende Abfrage fasst beispielsweise Nachrichten zunächst zu 5-Minuten-Blöcken zusammen, aggregiert diese 5-Minuten-Blöcke dann zu 10-Minuten-Blöcken und berechnet das höchste, niedrigste und durchschnittliche Verkehrsaufkommen innerhalb jedes 10-Minuten-Blocks.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) / 1024 / 1024 AS logs_mb BY BIN(5m) as @t
| STATS max(logs_mb) AS peak_ingest_mb,
min(logs_mb) AS min_ingest_mb,
avg(logs_mb) AS avg_ingest_mb BY dateceil(@t, 10m)
```
**Hinweise und Einschränkungen**
Eine Abfrage kann maximal zwei `stats`-Befehle haben. Dieses Kontingent kann nicht geändert werden.
Wenn Sie einen `sort`- oder `limit`-Befehl verwenden, muss er nach dem zweiten `stats`-Befehl angezeigt werden. Wenn sie vor dem zweiten `stats`-Befehl steht, ist die Abfrage nicht gültig.
Wenn eine Abfrage zwei `stats`-Befehle enthält, werden die Teilergebnisse der Abfrage erst angezeigt, wenn die erste `stats`-Aggregation abgeschlossen ist.
Im zweiten `stats`-Befehl in einer einzelnen Abfrage können Sie nur auf Felder verweisen, die im ersten `stats`-Befehl definiert wurden. Die folgende Abfrage ist beispielsweise nicht gültig, da das `@message`-Feld nach der ersten `stats`-Aggregation nicht verfügbar sein wird.
```
FIELDS @message
| STATS SUM(Fault) by Operation
# You can only reference `SUM(Fault)` or Operation at this point
| STATS MAX(strlen(@message)) AS MaxMessageSize # Invalid reference to @message
```
Alle Felder, auf die Sie nach dem ersten `stats`-Befehl verweisen, müssen in diesem ersten `stats`-Befehl definiert werden.
```
STATS sum(x) as sum_x by y, z
| STATS max(sum_x) as max_x by z
# You can only reference `max(sum_x)`, max_x or z at this point
```
**Wichtig**
Die `bin`-Funktion verwendet das `@timestamp`-Feld immer implizit. Das bedeutet, dass Sie `bin` nicht im zweiten `stats`-Befehl verwenden können, ohne den ersten `stats`-Befehl zur Propagierung des `timestamp`-Felds zu verwenden. Beispielsweise ist die folgende Abfrage nicht zulässig.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) AS ingested_bytes BY @logStream
| STATS avg(ingested_bytes) BY bin(5m) # Invalid reference to @timestamp field
```
Definieren Sie das `@timestamp`-Feld stattdessen im ersten `stats`-Befehl, und dann können Sie es zusammen mit `dateceil` im zweiten `stats`-Befehl verwenden, wie im folgenden Beispiel.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) AS ingested_bytes, max(@timestamp) as @t BY @logStream
| STATS avg(ingested_bytes) BY dateceil(@t, 5m)
```
## Funktionen zur Verwendung mit „stats“
CloudWatch Logs Insights unterstützt sowohl Funktionen zur Aggregation von Statistiken als auch Funktionen ohne Aggregation von Statistiken.
Sie können statsaggregation-Funktionen im Befehl `stats` sowie als Argumente für andere Funktionen verwenden.
| Funktion | Ergebnistyp | Description |
| --- | --- | --- |
| `avg(fieldName: NumericLogField)` | number | Der Mittelwert der Werte im angegebenen Feld. |
| `count()` `count(fieldName: LogField)` | number | Zählt die Protokollereignisse. `count()` (oder `count(*)`) zählt alle von der Abfrage zurückgegebenen Ereignisse, während `count(fieldName)` alle Datensätze, die den angegebenen Feldnamen enthalten, zählt. |
| `count_distinct(fieldName: LogField)` | number | Liefert die Anzahl der eindeutigen Werte für das Feld. Wenn das Feld eine sehr hohe Kardinalität hat (zahlreiche eindeutige Werte enthält), ist der von `count_distinct` zurückgegebene Wert lediglich eine Annäherung. |
| `max(fieldName: LogField)` | LogFieldValue | Das Maximum der Werte für dieses Protokollfeld in den abgefragten Protokollen. |
| `min(fieldName: LogField)` | LogFieldValue | Das Minimum der Werte für dieses Protokollfeld in den abgefragten Protokollen. |
| `pct(fieldName: LogFieldValue, percent: number)` | LogFieldValue | Ein Perzentil gibt die relative Stelle eines Wertes in einer Datenmenge an. Zum Beispiel gibt `pct(@duration, 95)` den `@duration`-Wert zurück, bei dem 95 Prozent der Werte von `@duration` niedriger als dieser Wert und 5 Prozent höher als dieser Wert sind. |
| `stddev(fieldName: NumericLogField)` | number | Die Standardabweichung der Werte im angegebenen Feld. |
| `sum(fieldName: NumericLogField)` | number | Die Summe der Werte im angegebenen Feld. |
**Statistik-Nicht-Aggregations-Funktionen**
Sie können Nicht-Aggregationsfunktionen im Befehl `stats` sowie als Argumente für andere Funktionen verwenden.
| Funktion | Ergebnistyp | Description |
| --- | --- | --- |
| `earliest(fieldName: LogField)` | LogField | Gibt den Wert von `fieldName` aus dem Protokollereignis mit dem frühesten Zeitstempel in den abgefragten Protokollen zurück. |
| `latest(fieldName: LogField)` | LogField | Gibt den Wert von `fieldName` aus dem Protokollereignis mit dem neuesten Zeitstempel in den abgefragten Protokollen zurück. |
| `sortsFirst(fieldName: LogField)` | LogField | Gibt den Wert von `fieldName` zurück, der in der Sortierung der abgefragten Protokolle an erster Stelle steht. |
| `sortsLast(fieldName: LogField)` | LogField | Gibt den Wert von `fieldName` zurück, der in der Sortierung der abgefragten Protokolle an letzter Stelle steht. |
# limit
Verwenden Sie `limit`, um die Anzahl der Protokollereignisse anzugeben, die Ihre Abfrage zurückgeben soll. Wenn Sie diese Option weglassen`limit`, gibt die Abfrage in den Ergebnissen bis zu 10.000 Protokollereignisse zurück.
Das folgende Beispiel gibt beispielsweise nur die letzten 25 Protokollereignisse zurück:
```
fields @timestamp, @message | sort @timestamp desc | limit 25
```
# dedup
Verwenden Sie `dedup`, um doppelte Ergebnisse auf der Grundlage bestimmter Werte in von Ihnen angegebenen Feldern zu entfernen. Sie können `dedup` mit einem oder mehreren Feldern verwenden. Wenn Sie ein Feld mit `dedup` angeben, wird für jeden eindeutigen Wert dieses Felds nur ein Protokollereignis zurückgegeben. Wenn Sie mehrere Felder angeben, wird für jede eindeutige Kombination von Werten für diese Felder ein Protokollereignis zurückgegeben.
Duplikate werden auf der Grundlage der Sortierreihenfolge verworfen, wobei nur das erste Ergebnis in der Sortierreihenfolge beibehalten wird. Wir empfehlen, Ihre Ergebnisse zu sortieren, bevor Sie den Befehl `dedup` dafür ausführen. Wenn die Ergebnisse nicht sortiert werden, bevor sie den Befehl `dedup` durchlaufen, wird die absteigende Standard-Sortierreihenfolge mit `@timestamp` verwendet.
Nullwerte werden bei der Auswertung nicht als Duplikate betrachtet. Protokollereignisse mit Nullwerten für eines der angegebenen Felder werden beibehalten. Um Felder mit Nullwerten zu eliminieren, verwenden Sie **`filter`** mit der Funktion `isPresent(field)`.
Der einzige Abfragebefehl, den Sie in einer Abfrage nach dem Befehl `dedup` verwenden können, ist `limit`.
Wenn Sie die Option `dedup` in einer Abfrage verwenden, zeigt die Konsole die folgende Meldung an: Es werden **X von Y-Datensätzen angezeigt**, wobei X für die Anzahl der deduplizierten Ergebnisse und Y für die Gesamtzahl der Datensätze steht, die vor der Deduplizierung abgeglichen wurden. Dies weist darauf hin, dass doppelte Datensätze entfernt wurden, und bedeutet nicht, dass Daten fehlen.
**Beispiel: Nur das letzte Protokollereignis für jeden eindeutigen Wert des Felds mit dem Namen `server` anzeigen**
Das folgende Beispiel zeigt die Felder `timestamp`, `server`, `severity` und `message` nur für das letzte Ereignis für jeden eindeutigen Wert von `server` an.
```
fields @timestamp, server, severity, message
| sort @timestamp desc
| dedup server
```
Weitere Beispiele für CloudWatch Logs Insights-Abfragen finden Sie unter[Allgemeine Abfragen](CWL_QuerySyntax-examples.md#CWL_QuerySyntax-examples-general).
# unmask
Verwenden Sie `unmask`, um den gesamten Inhalt eines Protokollereignisses anzuzeigen, bei dem einige Inhalte aufgrund einer Datenschutzrichtlinie maskiert sind. Um diesen Befehl zu verwenden, müssen Sie über die `logs:Unmask`-Berechtigung verfügen.
Weitere Informationen zum Datenschutz in Protokollgruppen finden Sie unter [Den Schutz vertraulicher Protokolldaten mit Maskierung unterstützen](mask-sensitive-log-data.md).
# unnest
Wird verwendet`unnest`, um eine als Eingabe verwendete Liste zu vereinfachen, sodass mehrere Datensätze mit einem einzigen Datensatz für jedes Element in der Liste erstellt werden. Basierend auf der Anzahl der Elemente, die ein Feld enthält, verwirft dieser Befehl den aktuellen Datensatz und generiert neue Datensätze. Jeder Datensatz enthält den`unnested_field`, der ein Element darstellt. Alle anderen Felder stammen aus dem ursprünglichen Datensatz.
Die Eingabe für `unnest` ist`LIST`, die aus der `jsonParse` Funktion stammt. Weitere Informationen finden Sie unter [Strukturtypen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax-operations-functions.html#CWL_QuerySyntax-structure-types). Alle anderen Typen`MAP`, wie z. B. `String` und`numbers`, werden als Liste mit einem Element behandelt`unnest`.
**Befehlsstruktur**
Das folgende Beispiel beschreibt das Format dieses Befehls.
```
unnest field into unnested_field
```
**Beispielabfrage**
Im folgenden Beispiel wird eine JSON-Objektzeichenfolge analysiert und eine Liste von Feldereignissen erweitert.
```
fields jsonParse(@message) as json_message
| unnest json_message.events into event
| display event.name
```
Das Protokollereignis für diese Beispielabfrage könnte eine JSON-Zeichenfolge wie folgt sein:
```
{
"events": [
{
"name": "exception"
},
{
"name": "user action"
}
]
}
```
In diesem Fall erzeugt die Beispielabfrage zwei Datensätze im Abfrageergebnis, einen mit `event.name` als `exception` und einen mit `event.name` einer **Benutzeraktion**
**Beispielabfrage**
Im folgenden Beispiel wird eine Liste reduziert und anschließend Elemente herausgefiltert.
```
fields jsonParse(@message) as js
| unnest js.accounts into account
| filter account.type = "internal"
```
**Beispielabfrage**
Im folgenden Beispiel wird eine Liste zur Aggregation reduziert.
```
fields jsonParse(trimmedData) as accounts
| unnest accounts into account
| stats sum(account.droppedSpans) as n by account.accountId
| sort n desc
| limit 10
```
# Nachschlagen
Wird verwendet`lookup`, um Ihre Abfrageergebnisse mit Referenzdaten aus einer Nachschlagetabelle anzureichern. Eine Nachschlagetabelle enthält CSV-Daten, die Sie in Amazon CloudWatch Logs hochladen. Wenn eine Abfrage ausgeführt wird, gleicht der `lookup` Befehl ein Feld in Ihren Protokollereignissen mit einem Feld in der Nachschlagetabelle ab und fügt die angegebenen Ausgabefelder an die Ergebnisse an.
Verwenden Sie Nachschlagetabellen für Szenarien zur Datenanreicherung, z. B. für die Zuordnung von Benutzer- und Benutzerdetails, von Produktcodes zu Produktinformationen oder von Fehlercodes zu Fehlerbeschreibungen. IDs
## Nachschlagetabellen erstellen und verwalten
Bevor Sie den `lookup` Befehl in einer Abfrage verwenden können, müssen Sie eine Nachschlagetabelle erstellen. Sie können Nachschlagetabellen über die CloudWatch Konsole oder mithilfe der Amazon CloudWatch Logs-API erstellen und verwalten.
**Um eine Nachschlagetabelle (Konsole) zu erstellen**
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 **Einstellungen** und dann die Registerkarte **Protokolle** aus.
1. Scrollen Sie zu „**Nachschlagetabellen**“ und wählen Sie „**Verwalten**“.
1. Wählen Sie **Nachschlagetabelle erstellen aus**.
1. Geben Sie einen Namen für die Nachschlagetabelle ein. Der Name darf nur alphanumerische Zeichen, Bindestriche und Unterstriche enthalten.
1. (Optional) Geben Sie eine Beschreibung ein.
1. Laden Sie eine CSV-Datei hoch. Die Datei muss eine Kopfzeile mit Spaltennamen enthalten, die UTF-8-Kodierung verwenden und darf 10 MB nicht überschreiten.
1. (Optional) Geben Sie einen AWS KMS Schlüssel zum Verschlüsseln der Tabellendaten an.
1. Wählen Sie **Erstellen** aus.
Nachdem Sie eine Nachschlagetabelle erstellt haben, können Sie sie im CloudWatch Logs Insights-Abfrage-Editor anzeigen. Wählen Sie die Registerkarte **Nachschlagetabellen**, um die verfügbaren Tabellen und ihre Felder zu durchsuchen.
Um eine Nachschlagetabelle zu aktualisieren, wählen Sie die Tabelle aus und klicken Sie auf **Aktionen**, **Aktualisieren**. Laden Sie eine neue CSV-Datei hoch, um den gesamten vorhandenen Inhalt zu ersetzen. Um eine Nachschlagetabelle zu löschen, wählen Sie **Aktionen**, **Löschen**.
**Anmerkung**
Sie können bis zu 100 Nachschlagetabellen pro Konto pro Konto erstellen AWS-Region. CSV-Dateien können bis zu 10 MB groß sein. Sie können Nachschlagetabellen auch mithilfe der Amazon CloudWatch Logs-API verwalten. Weitere Informationen finden Sie [CreateLookupTable](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLookupTable.html)in der *Amazon CloudWatch Logs API-Referenz*.
**Anmerkung**
Wenn die Nachschlagetabelle mit einem KMS-Schlüssel verschlüsselt ist, muss der Aufrufer über die `kms:Decrypt` Berechtigung für den Schlüssel (den KMS-Schlüssel, der zur Verschlüsselung der Nachschlagetabelle verwendet wird) verfügen, um die `StartQuery` API mit einer Abfrage zu verwenden, die auf diese Nachschlagetabelle verweist. Weitere Informationen finden Sie unter [Verschlüsseln Sie Nachschlagetabellen in CloudWatch Protokollen mit AWS Key Management Service](encrypt-lookup-tables-kms.md).
## Abfragesyntax für die Suche
**Befehlsstruktur**
Im Folgenden wird das Format dieses Befehls veranschaulicht.
```
lookup table lookup-field as log-field [,...] output-mode output-field[,...]
```
Der Befehl verwendet die folgenden Argumente:
+ `table`— Der Name der zu verwendenden Nachschlagetabelle.
+ `lookup-field`— Das Feld in der Nachschlagetabelle, mit dem ein Abgleich durchgeführt werden soll.
+ `log-field`— Das Feld in Ihren Protokollereignissen, das zugeordnet werden soll. Die Übereinstimmung ist exakt und es wird zwischen Groß- und Kleinschreibung unterschieden.
+ `output-mode`— Geben Sie `OUTPUT` an, ob die Ausgabefelder zu den Ergebnissen hinzugefügt werden sollen. Wenn ein Feld mit demselben Namen bereits im Protokollereignis vorhanden ist, wird es überschrieben.
+ `output-field`— Ein oder mehrere Felder aus der Nachschlagetabelle, die den Ergebnissen hinzugefügt werden sollen.
**Beispiel: Reichern Sie Protokollereignisse mit Benutzerdetails an**
Angenommen, Sie haben eine Protokollgruppe mit Ereignissen, die ein `id` Feld enthalten, und eine Nachschlagetabelle `user_data` mit den Spalten `id``name`,`email`, und`department`. Die folgende Abfrage bereichert jedes Protokollereignis mit dem Namen, der E-Mail-Adresse und der Abteilung des Benutzers aus der Nachschlagetabelle.
```
fields action, status, name, email, department
| lookup user_data id OUTPUT name, email, department
```
**Beispiel: Verwenden Sie Lookup mit Aggregation**
Sie können Lookup-Ausgabefelder mit Aggregationsfunktionen verwenden. Die folgende Abfrage reichert Protokollereignisse mit Benutzerdetails an und zählt dann die Ereignisse, gruppiert nach E-Mail-Adresse.
```
fields user_id, action, username, email, department
| lookup user_data user_id OUTPUT username, email, department
| stats count(*) by email
```
**Beispiel: Verwenden Sie die Suche mit Filter**
Sie können Ergebnisse auf der Grundlage von Feldern filtern, die bei der Suche zurückgegeben wurden. Mit der folgenden Abfrage werden Protokollereignisse erweitert und anschließend gefiltert, sodass nur Ereignisse aus einer bestimmten Abteilung angezeigt werden.
```
fields user_id, action
| lookup user_data user_id OUTPUT username, email, department
| filter department = "Engineering"
```
# Boolesche, Vergleichs-, numerische, Datetime- und andere Funktionen
CloudWatch Logs Insights unterstützt viele andere Operationen und Funktionen in Abfragen, wie in den folgenden Abschnitten erläutert.
**Topics**
+ [Arithmetische Operatoren](#CWL_QuerySyntax-operations-arithmetic)
+ [Boolesche Operatoren](#CWL_QuerySyntax-operations-Boolean)
+ [Vergleichsoperatoren](#CWL_QuerySyntax-operations-comparison)
+ [Numerische Operatoren](#CWL_QuerySyntax-operations-numeric)
+ [Strukturtypen](#CWL_QuerySyntax-structure-types)
+ [Datum-/Uhrzeit-Funktionen](#CWL_QuerySyntax-datetime)
+ [Allgemeine Funktionen](#CWL_QuerySyntax-general-functions)
+ [JSON-Funktionen](#CWL_QuerySyntax-json-functions)
+ [IP-Adressenzeichenfolgen](#CWL_QuerySyntax-IPaddress-functions)
+ [Zeichenfolgenfunktionen](#CWL_QuerySyntax-string-functions)
## Arithmetische Operatoren
Arithmetische Operationen akzeptieren numerische Datentypen als Argumente und liefern numerische Ergebnisse. Sie können arithmetische Operationen in den Befehlen `filter` und `fields` sowie als Argumente für andere Funktionen verwenden.
| Operation | Description |
| --- | --- |
| `a + b` | Addition |
| `a - b` | Subtraktion |
| `a * b` | Multiplikation |
| `a / b` | Division |
| `a ^ b` | Potenzierung. `2 ^ 3` gibt `8` zurück |
| `a % b` | Rest oder Modulus. `10 % 3` gibt `1` zurück |
## Boolesche Operatoren
Sie können die booleschen Operatoren `and`, `or`, und `not` verwenden.
**Anmerkung**
Verwenden Sie boolesche Operatoren nur in Funktionen, die den Wert von**WAHR**oder**FALSCH**aus.
## Vergleichsoperatoren
Vergleichsoperationen akzeptieren alle Datentypen als Argumente und liefern ein boolesches Ergebnis. Sie können Vergleichsoperationen im Befehl `filter` sowie als Argumente für andere Funktionen verwenden.
| Operator | Description |
| --- | --- |
| `=` | Gleich |
| `!=` | Ungleich |
| `<` | Kleiner als |
| `>` | Größer als |
| `<=` | Kleiner als oder gleich |
| `>=` | Größer als oder gleich |
## Numerische Operatoren
Numerische Operationen akzeptieren numerische Datentypen als Argumente und liefern numerische Ergebnisse. Sie können numerische Operationen in den Befehlen `filter` und `fields` sowie als Argumente für andere Funktionen verwenden.
| Operation | Ergebnistyp | Description |
| --- | --- | --- |
| `abs(a: number)` | number | Absoluter Wert |
| `ceil(a: number)` | number | Aufrunden (die kleinste ganze Zahl, die größer ist als der Wert von `a`). |
| `floor(a: number)` | number | Abrunden (die größte ganze Zahl, die kleiner ist als der Wert von `a`). |
| `greatest(a: number, ...numbers: number[])` | number | Liefert den größten Wert. |
| `least(a: number, ...numbers: number[])` | number | Liefert den kleinsten Wert. |
| `log(a: number)` | number | Natürlicher Logarithmus |
| `sqrt(a: number)` | number | Quadratwurzel |
## Strukturtypen
Eine Karte oder Liste ist ein Strukturtyp in CloudWatch Logs Insights, mit dem Sie auf Attribute zugreifen und diese für Abfragen verwenden können.
**Beispiel: Um eine Karte oder Liste abzurufen**
Wird verwendet`jsonParse`, um ein Feld, das eine JSON-Zeichenfolge ist, in eine Map oder eine Liste zu parsen.
```
fields jsonParse(@message) as json_message
```
**Beispiel: Um auf Attribute zuzugreifen**
Verwenden Sie den Punktzugriffsoperator (map.attribute), um auf Elemente in einer Map zuzugreifen. Wenn ein Attribut in einer Map Sonderzeichen enthält, verwenden Sie Backticks, um den Attributnamen einzuschließen (map.attributes). `special.char`).
```
fields jsonParse(@message) as json_message
| stats count() by json_message.status_code
```
Verwenden Sie den Klammer-Zugriffsoperator (list [index]), um ein Element an einer bestimmten Position in der Liste abzurufen.
```
fields jsonParse(@message) as json_message
| filter json_message.users[1].action = "PutData"
```
Umbrechen Sie Sonderzeichen in Backticks (``), wenn Sonderzeichen im Schlüsselnamen enthalten sind.
```
fields jsonParse(@message) as json_message
| filter json_message.`user.id` = "123"
```
**Beispiel: leere Ergebnisse**
Karten und Listen werden für Zeichenketten-, Zahlen- und Datetime-Funktionen als Null behandelt.
```
fields jsonParse(@message) as json_message
| display toupper(json_message)
```
Der Vergleich von Karte und Liste mit allen anderen Feldern führt zu`false`.
**Anmerkung**
Die Verwendung von Map und List in `dedup``pattern`,`sort`, und wird `stats` nicht unterstützt.
## Datum-/Uhrzeit-Funktionen
**Datum-/Uhrzeit-Funktionen**
Sie können die Datums-/Uhrzeit-Funktionen in den Befehlen `fields` und `filter` sowie als Argumente für andere Funktionen verwenden. Mit diesen Funktionen können Sie Zeiträume für Abfragen mit Aggregationsfunktionen anlegen. Verwenden Sie Zeiträume, die aus einer Zahl und einem der folgenden Werte bestehen:
+ `ms`für Millisekunden
+ `s`für Sekunden
+ `m`für Minuten
+ `h`stundenlang
Zum Beispiel steht `10m` für 10 Minuten und `1h` ist 1 Stunde.
**Anmerkung**
Verwenden Sie die am besten geeignete Zeiteinheit für Ihre Datetime-Funktion. CloudWatch Logs begrenzt Ihre Anfrage auf die von Ihnen gewählte Zeiteinheit. Beispielsweise wird für jede Anfrage, die verwendet, eine Obergrenze von 60 als Maximalwert festgelegt`s`. Wenn Sie also angeben`bin(300s)`, implementiert CloudWatch Logs dies tatsächlich als 60 Sekunden, da 60 die Anzahl der Sekunden in einer Minute ist, sodass CloudWatch Logs keine höhere Zahl als 60 verwendet`s`. Um einen 5-Minuten-Bucket zu erstellen, verwenden Sie `bin(5m)` stattdessen.
Die Obergrenze für `ms` ist 1000, die Obergrenzen für `s` und `m` sind 60 und die Obergrenze für `h` ist 24.
Die folgende Tabelle enthält eine Liste der verschiedenen Datetime-Funktionen, die Sie in Ihren Abfragebefehlen verwenden können. Die Tabelle listet den Ergebnistyp jeder Funktion auf und enthält zu jeder Funktion eine Beschreibung.
**Tipp**
Wenn Sie einen Abfragebefehl erstellen, können Sie mit der Zeitintervallauswahl einen Zeitraum für Ihre Abfrage festlegen. Sie können beispielsweise Intervalle von 5 bis 30 Minuten, Intervalle von 1, 3 und 12 Stunden oder einen benutzerdefinierten Zeitrahmen festlegen. Sie können auch Zeiträume zwischen bestimmten Daten festlegen.
| Funktion | Ergebnistyp | Description |
| --- | --- | --- |
| `bin(period: Period)` | Zeitstempel | Rundet den Wert von `@timestamp` auf den angegebenen Zeitraum und kürzt ihn dann. `bin(5m)` rundet beispielsweise den Wert von `@timestamp` auf die nächstgelegenen fünf Minuten. So können mehrere Protokolleinträge in einer Abfrage gruppiert werden. Im folgenden Beispiel wird die Anzahl von Ausnahmen pro Stunde zurückgegeben: filter @message like /Exception/
| stats count(*) as exceptionCount by bin(1h)
| sort exceptionCount desc
Für die Funktion `bin` werden folgende Zeiteinheiten und Abkürzungen unterstützt. Alle Einheiten und Abkürzungen, die mehr als ein Zeichen enthalten, können durch Hinzufügen von „s“ pluralisiert werden. Somit kann sowohl `hr` als auch `hrs` verwendet werden, um Stunden anzugeben. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/AmazonCloudWatch/latest/logs/CWL_QuerySyntax-operations-functions.html) |
| `datefloor(timestamp: Timestamp, period: Period)` | Zeitstempel | Kürzt den Zeitstempel auf den angegebenen Zeitraum. Zum Beispiel kürzt `datefloor(@timestamp, 1h)` alle Werte von `@timestamp` auf die letzte volle Stunde. |
| `dateceil(timestamp: Timestamp, period: Period)` | Zeitstempel | Rundet den Zeitstempel auf den angegebenen Zeitraum auf und kürzt ihn dann. Zum Beispiel kürzt `dateceil(@timestamp, 1h)` alle Werte von `@timestamp` auf die nächste volle Stunde. |
| `fromMillis(fieldName: number)` | Zeitstempel | Interpretiert das Eingabefeld als die Anzahl der Millisekunden seit der Unix-Epoche und konvertiert es in einen Zeitstempel. |
| `toMillis(fieldName: Timestamp)` | number | Konvertiert den im benannten Feld gefundenen Zeitstempel in eine Zahl, die die Millisekunden seit der Unix-Epoche darstellt. Beispiel: `toMillis(@timestamp)` konvertiert den Zeitstempel `2022-01-14T13:18:031.000-08:00` zu `1642195111000`. |
| `now()` | number | Gibt die Uhrzeit in Epochensekunden zurück, zu der die Abfrageverarbeitung gestartet wurde. Diese Funktion akzeptiert keine Argumente. Sie können dies verwenden, um Ihre Abfrageergebnisse nach der aktuellen Uhrzeit zu filtern. Die folgende Abfrage gibt beispielsweise alle 4xx-Fehler der letzten zwei Stunden zurück: parse @message "Status Code: *;" as statusCode\n
| filter statusCode >= 400 and statusCode <= 499 \n
| filter toMillis(@timestamp) >= (now() * 1000 - 7200000)
Das folgende Beispiel gibt alle Protokolleinträge der letzten fünf Stunden zurück, die entweder das Wort `error` oder enthalten `failure` fields @timestamp, @message
| filter @message like /(?i)(error|failure)/
| filter toMillis(@timestamp) >= (now() * 1000 - 18000000)
|
**Anmerkung**
Derzeit unterstützt CloudWatch Logs Insights das Filtern von Protokollen mit menschenlesbaren Zeitstempeln nicht.
## Allgemeine Funktionen
**Allgemeine Funktionen**
Sie können allgemeine Funktionen in den Befehlen `fields` und `filter` sowie als Argumente für andere Funktionen verwenden.
| Funktion | Ergebnistyp | Description |
| --- | --- | --- |
| `ispresent(fieldName: LogField)` | Boolesch | Gibt `true` zurück, wenn das Feld existiert. |
| `coalesce(fieldName: LogField, ...fieldNames: LogField[])` | LogField | Liefert den ersten Nicht-Null-Wert aus der Liste. |
## JSON-Funktionen
**JSON-Funktionen**
Verwenden Sie JSON-Funktionen in den `filter` Befehlen `fields` und und als Argumente für andere Funktionen.
| Funktion | Ergebnistyp | Description |
| --- | --- | --- |
| `jsonParse(fieldName: string)` | Karte \$1 Liste \$1 Leer | Gibt eine Map oder Liste zurück, wenn die Eingabe eine Zeichenkettendarstellung eines JSON-Objekts oder eines JSON-Arrays ist. Gibt einen leeren Wert zurück, wenn es sich bei der Eingabe nicht um eine der Repräsentationen handelt. |
| `jsonStringify(fieldName: Map \| List)` | Zeichenfolge | Gibt eine JSON-Zeichenfolge aus einer Karte oder Listendaten zurück. |
## IP-Adressenzeichenfolgen
**IP-Adressenzeichenfolgen**
Sie können IP-Adressen-Zeichenfolgenfunktionen in den Befehlen `filter` und `fields` sowie als Argumente für andere Funktionen verwenden.
| Funktion | Ergebnistyp | Description |
| --- | --- | --- |
| `isValidIp(fieldName: string)` | boolesch | Gibt zurück`true`, ob das Feld eine gültige IPv4 IPv6 Oder-Adresse ist. |
| `isValidIpV4(fieldName: string)` | boolesch | Gibt zurück`true`, ob das Feld eine gültige IPv4 Adresse ist. |
| `isValidIpV6(fieldName: string)` | boolesch | Gibt zurück`true`, ob das Feld eine gültige IPv6 Adresse ist. |
| `isIpInSubnet(fieldName: string, subnet: string)` | boolesch | Gibt zurück`true`, ob es sich bei dem Feld um eine gültige IPv4 IPv6 Adresse im angegebenen v4- oder v6-Subnetz handelt. Verwenden Sie bei der Angabe des Subnetzes die CIDR-Notation wie `192.0.2.0/24` oder `2001:db8::/32`, wobei `192.0.2.0` oder `2001:db8::` der Anfang des CIDR-Blocks ist. |
| `isIpv4InSubnet(fieldName: string, subnet: string)` | boolesch | Gibt zurück`true`, ob das Feld eine gültige IPv4 Adresse innerhalb des angegebenen v4-Subnetzes ist. Verwenden Sie bei der Angabe des Subnetzes die CIDR-Notation wie `192.0.2.0/24`, wobei `192.0.2.0` der Anfang des CIDR-Blocks ist. |
| `isIpv6InSubnet(fieldName: string, subnet: string)` | boolesch | Gibt zurück`true`, ob das Feld eine gültige IPv6 Adresse innerhalb des angegebenen v6-Subnetzes ist. Verwenden Sie bei der Angabe des Subnetzes die CIDR-Notation wie `2001:db8::/32`, wobei `2001:db8::` der Anfang des CIDR-Blocks ist. |
## Zeichenfolgenfunktionen
**Zeichenfolgenfunktionen**
Sie können Zeichenfolgenfunktionen in den Befehlen `fields` und `filter` sowie als Argumente für andere Funktionen verwenden.
| Funktion | Ergebnistyp | Description |
| --- | --- | --- |
| `isempty(fieldName: string)` | Zahl | Gibt `1` zurück, wenn das Feld fehlt oder eine leere Zeichenkette ist. |
| `isblank(fieldName: string)` | Zahl | Gibt `1` zurück, wenn das Feld fehlt, eine leere Zeichenkette ist oder nur Leerzeichen enthält. |
| `concat(str: string, ...strings: string[])` | Zeichenfolge | Verkettet die Zeichenketten. |
| `ltrim(str: string)` `ltrim(str: string, trimChars: string)` | Zeichenfolge | Wenn die Funktion kein zweites Argument hat, entfernt sie die Whitespaces von der linken Seite der Zeichenfolge. Wenn die Funktion ein zweites Zeichenfolgen-Argument hat, entfernt sie keine Whitespaces. Stattdessen entfernt sie die Zeichen in `trimChars` links von `str`. Beispielsweise gibt `ltrim("xyZxyfooxyZ","xyZ")` `"fooxyZ"` zurück. |
| `rtrim(str: string)` `rtrim(str: string, trimChars: string)` | Zeichenfolge | Wenn die Funktion kein zweites Argument hat, entfernt sie die Whitespaces von der rechten Seite der Zeichenfolge. Wenn die Funktion ein zweites Zeichenfolgen-Argument hat, entfernt sie keine Whitespaces. Stattdessen entfernt sie die Zeichen von `trimChars` rechts von `str`. Beispielsweise gibt `rtrim("xyZfooxyxyZ","xyZ")` `"xyZfoo"` zurück. |
| `trim(str: string)` `trim(str: string, trimChars: string)` | Zeichenfolge | Wenn die Funktion kein zweites Argument hat, entfernt sie die Whitespaces von beiden Seiten der Zeichenfolge. Wenn die Funktion ein zweites Zeichenfolgen-Argument hat, entfernt sie keine Whitespaces. Stattdessen entfernt sie die Zeichen aus `trimChars` von beiden Seiten von `str`. Beispielsweise gibt `trim("xyZxyfooxyxyZ","xyZ")` `"foo"` zurück. |
| `strlen(str: string)` | number | Liefert die Länge der Zeichenkette in Unicode-Codepunkten. |
| `toupper(str: string)` | Zeichenfolge | Konvertiert die Zeichenkette in Großbuchstaben. |
| `tolower(str: string)` | Zeichenfolge | Konvertiert die Zeichenkette in Kleinbuchstaben. |
| `substr(str: string, startIndex: number)` `substr(str: string, startIndex: number, length: number)` | Zeichenfolge | Gibt eine Teilzeichenkette aus dem durch das Zahlenargument angegebenen Index bis zum Ende der Zeichenkette zurück. Wenn die Funktion ein zweites Zahlenargument hat, enthält sie die Länge der abzurufenden Teilzeichenkette. Beispielsweise gibt `substr("xyZfooxyZ",3, 3)` `"foo"` zurück. |
| `replace(fieldName: string, searchValue: string, replaceValue: string)` | Zeichenfolge | Ersetzt alle Instances von `searchValue` in `fieldName: string` mit `replaceValue`. Beispiel: Die Funktion `replace(logGroup,"smoke_test","Smoke")` sucht nach Protokollereignissen, bei denen das Feld `logGroup` den Zeichenfolgenwert `smoke_test` enthält und den Wert durch die Zeichenfolge `Smoke` ersetzt. |
| `strcontains(str: string, searchValue: string)` | number | Gibt 1 zurück, wenn `str` `searchValue` enthält; ansonsten 0. |
# Felder, die Sonderzeichen enthalten
Wenn ein Feld außer dem `@` Symbol oder dem Punkt (`.`) andere nicht-alphanumerische Zeichen enthält, müssen Sie das Feld mit Backtick-Zeichen () umgeben. ``` Zum Beispiel muss das Feld `foo-bar` in Backticks eingeschlossen werden (``foo-bar``), weil es ein nicht alphanumerisches Zeichen, den Bindestrich (`-`), enthält.
# Aliasse und Kommentare in Abfragen verwenden
Erstellen Sie Abfragen, die Aliase enthalten. Verwenden Sie Aliase, um Protokollfelder umzubenennen oder Werte in Felder zu extrahieren. Benutze das Schlüsselwort`as`um einem Protokollfeld oder Ergebnis einen Alias zu geben. Sie können in einer Abfrage mehrere Alias verwenden. In den folgenden Befehlen können Sie Aliase verwenden:
+ `fields`
+ `parse`
+ `sort`
+ ` stats `
In den folgenden Beispielen wird gezeigt, wie Sie Abfragen erstellen, die Aliase enthalten.
**Beispiel**
Die Abfrage enthält einen Alias im`fields`befehl.
```
fields @timestamp, @message, accountId as ID
| sort @timestamp desc
| limit 20
```
Die Abfrage gibt die Werte für die Felder zurück`@timestamp`,`@message`, und`accountId`aus. Die Ergebnisse sind in absteigender Reihenfolge sortiert und auf 20 begrenzt. Die Werte für`accountId`sind unter dem Alias aufgeführt`ID`aus.
**Beispiel**
Die Abfrage enthält Aliase im`sort`und`stats`-Befehle.
```
stats count(*) by duration as time
| sort time desc
```
Die Abfrage zählt die Anzahl der Male des Feldes`duration`tritt in der Protokollgruppe auf und sortiert die Ergebnisse in absteigender Reihenfolge. Die Werte für`duration`sind unter dem Alias aufgeführt`time`aus.
## Kommentare verwenden
CloudWatch Logs Insights unterstützt Kommentare in Abfragen. Benutze das Hash-Zeichen (**\$1**) um Kommentare auszurichten. Sie können Kommentare verwenden, um Zeilen in Abfragen oder Dokumentabfragen zu ignorieren.
**Beispiel: Abfrage**
Wenn die folgende Abfrage ausgeführt wird, wird die zweite Zeile ignoriert.
```
fields @timestamp, @message, accountId
# | filter accountId not like "7983124201998"
| sort @timestamp desc
| limit 20
```
# Erste Schritte mit Logs Insights QL: Query tutorials
Die folgenden Abschnitte enthalten Beispiel-Tutorials für Abfragen, die Ihnen den Einstieg in Logs Insights QL erleichtern.
**Topics**
+ [Tutorial: Ausführen und Ändern einer Beispielabfrage](CWL_AnalyzeLogData_RunSampleQuery.md)
+ [Tutorial: Ausführen einer Abfrage mit einer Aggregationsfunktion](CWL_AnalyzeLogData_AggregationQuery.md)
+ [Tutorial: Ausführen einer Abfrage, die eine nach Protokollfeldern gruppierte Visualisierung erzeugt](CWL_AnalyzeLogData_VisualizationFieldQuery.md)
+ [Tutorial: Ausführen einer Abfrage, die eine Visualisierung von Zeitreihen erzeugt](CWL_AnalyzeLogData_VisualizationQuery.md)
# Tutorial: Ausführen und Ändern einer Beispielabfrage
Das folgende Tutorial hilft Ihnen bei den ersten Schritten mit CloudWatch Logs Insights. Sie führen eine Beispielabfrage in Logs Insights QL aus und sehen dann, wie Sie sie ändern und erneut ausführen können.
Um eine Abfrage ausführen zu können, müssen Sie bereits CloudWatch Protokolle in Logs gespeichert haben. Wenn Sie Logs bereits verwenden und CloudWatch Log-Gruppen und Log-Streams eingerichtet haben, können Sie loslegen. Möglicherweise verfügen Sie auch bereits über Protokolle AWS CloudTrail, wenn Sie Dienste wie Amazon Route 53 oder Amazon VPC verwenden und Sie Protokolle von diesen Diensten so eingerichtet haben, dass sie in CloudWatch Logs gespeichert werden. Weitere Informationen zum Senden von Protokollen an CloudWatch Logs finden Sie unter[Erste Schritte mit CloudWatch Logs](CWL_GettingStarted.md).
Abfragen in CloudWatch Logs Insights geben entweder eine Reihe von Feldern aus Protokollereignissen oder das Ergebnis einer mathematischen Aggregation oder eines anderen Vorgangs zurück, der mit Protokollereignissen ausgeführt wurde. Dieses Tutorial demonstriert eine Abfrage, die eine Liste von Protokollereignissen zurückgibt.
## Ausführen einer Beispielabfrage
**Um eine CloudWatch Logs Insights-Beispielabfrage auszuführen**
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 **Logs** (Protokolle) und dann **Logs Insights** aus.
Auf der **Logs Insights-Seite** enthält der Abfrage-Editor eine Standardabfrage in Logs Insights QL, die die 20 neuesten Protokollereignisse zurückgibt.
1. Wählen Sie in der Dropdownliste **Select log group(s)** (Protokollgruppe(n) auswählen) eine oder mehrere Protokollgruppen aus, die abgefragt werden sollen.
Wenn es sich um ein Überwachungskonto mit CloudWatch kontenübergreifender Observability handelt, können Sie Protokollgruppen sowohl in den Quellkonten als auch im Überwachungskonto auswählen. Mit einer einzigen Abfrage können Protokolle von verschiedenen Konten gleichzeitig abgefragt werden.
Sie können die Protokollgruppen nach dem Namen der Protokollgruppe, der Konto-ID oder der Kontobezeichnung filtern.
Wenn Sie eine Protokollgruppe in der Standard-Protokollklasse auswählen, erkennt CloudWatch Logs Insights automatisch Datenfelder in der Gruppe. Um diese erkannten Felder anzuzeigen, wählen Sie das Menü **Fields** (Felder) oben rechts auf der Seite aus.
**Anmerkung**
Entdeckte Felder werden nur für Protokollgruppen der Standard-Protokollklasse unterstützt. Weitere Hinweise zu Protokollklassen finden Sie unter[Klassen protokollieren](CloudWatch_Logs_Log_Classes.md).
1. (Optional) Verwenden Sie die Zeitintervallauswahl, um einen Zeitraum auszuwählen, den Sie abfragen möchten.
Sie können zwischen Intervallen von 5 bis 30 Minuten, Intervallen von 1, 3 und 12 Stunden oder einem benutzerdefinierten Zeitrahmen wählen.
1. Klicken Sie auf **Run** (Ausführen), um die Ergebnisse anzuzeigen.
Für dieses Tutorial enthalten die Ergebnisse die 20 zuletzt hinzugefügten Protokollereignisse.
CloudWatch Logs zeigt ein Balkendiagramm der Protokollereignisse in der Protokollgruppe im Zeitverlauf an. Das Balkendiagramm zeigt nicht nur die Ereignisse in der Tabelle, sondern auch die Verteilung der Ereignisse in der Protokollgruppe, die der Abfrage und dem Zeitrahmen entsprechen.
1. Um alle Felder für ein zurückgegebenes Protokollereignis anzuzeigen, wählen Sie das dreieckige Dropdown-Symbol links neben dem nummerierten Ereignis.
## Ändern der Beispielabfrage
In diesem Tutorial ändern Sie die Beispielabfrage, um die 50 neuesten Protokollereignisse anzuzeigen.
Wenn Sie das vorherige Tutorial noch nicht ausgeführt haben, tun Sie das jetzt. Dieses Tutorial beginnt dort, wo das vorherige Tutorial endet.
**Anmerkung**
In einigen Beispielabfragen, die mit CloudWatch Logs Insights bereitgestellt werden, `tail` werden Befehle `head` oder anstelle von verwendet`limit`. Diese Befehle sind veraltet und wurden durch `limit` ersetzt. Verwenden Sie in allen von Ihnen geschriebenen Abfragen `limit` anstelle von `head` oder `tail`.
**Um die CloudWatch Logs Insights-Beispielabfrage zu ändern**
1. Ändern Sie im Abfrage-Editor **20** in **50**. Wählen Sie anschließend **Run (Ausführen)** aus.
Die Ergebnisse der neuen Abfrage werden angezeigt. Unter der Annahme, dass in der Protokollgruppe im Standardzeitraum genügend Daten vorhanden sind, werden nun 50 Protokollereignisse aufgelistet.
1. (Optional) Sie können Abfragen speichern, die Sie erstellt haben. Um diese Abfrage zu speichern, wählen Sie **Speichern** aus. Weitere Informationen finden Sie unter [Speichern Sie CloudWatch Logs Insights-Abfragen und führen Sie sie erneut aus](CWL_Insights-Saving-Queries.md).
## Hinzufügen eines Filterbefehls zur Beispielabfrage
Dieses Tutorial zeigt, wie Sie eine umfangreichere Änderung der Abfrage im Abfrageeditor vornehmen können. In diesem Tutorial filtern Sie die Ergebnisse der vorherigen Abfrage basierend auf einem Feld in den abgerufenen Protokollereignissen.
Wenn Sie die vorherigen Tutorials noch nicht ausgeführt haben, tun Sie das jetzt. Dieses Tutorial beginnt dort, wo das vorherige Tutorial endet.
**So fügen Sie der vorherigen Abfrage einen Filterbefehl hinzu**
1. Entscheiden Sie sich für ein zu filterndes Feld. **Wählen Sie rechts auf der Seite Felder aus, um die häufigsten Felder anzuzeigen, die CloudWatch Logs in den letzten 15 Minuten in den Protokollereignissen in den ausgewählten Protokollgruppen erkannt hat, sowie den Prozentsatz dieser Protokollereignisse, in denen jedes Feld vorkommt.**
Um die in einem bestimmten Protokollereignis enthaltenen Felder anzuzeigen, wählen Sie das Symbol links neben dieser Zeile aus.
Möglicherweise wird das Feld **awsRegion** im Protokollereignis angezeigt. Dies ist von den Ereignissen abhängig, die in Ihren Protokollen enthalten sind. Im Rest dieses Tutorials verwenden Sie **awsRegion** als Filterfeld. Sie können jedoch auch ein anderes Feld verwenden, wenn dieses Feld nicht verfügbar ist.
1. Positionieren Sie den Cursor im Feld des Abfrageeditors hinter **50**, und drücken Sie die Eingabetaste.
1. Geben Sie in der neuen Zeile zunächst \$1 (das Pipe-Zeichen) und ein Leerzeichen ein. Befehle in einer CloudWatch Logs Insights-Abfrage müssen durch einen senkrechten Strich getrennt werden.
1. Geben Sie **filter awsRegion="us-east-1"** ein.
1. Klicken Sie auf **Ausführen**.
Die Abfrage läuft erneut und zeigt nun die 50 neuesten Ergebnisse an, die dem neuen Filter entsprechen.
Wenn Sie nach einem anderen Feld gefiltert haben und ein Fehlerergebnis erhalten haben, müssen Sie möglicherweise den Feldnamen maskieren. Wenn der Feldname auch andere als alphanumerische Zeichen enthält, müssen Sie vor und nach dem Feldnamen Backtick-Zeichen (`) verwenden (z. B. **`error-code`="102"**).
Sie müssen die Backtick-Zeichen für Feldnamen verwenden, die auch andere als alphanumerische Zeichen enthalten, nicht jedoch für Werte. Werte sind stets von Anführungszeichen (") umschlossen.
Logs Insights QL umfasst leistungsstarke Abfragefunktionen, darunter mehrere Befehle und Unterstützung für reguläre Ausdrücke sowie mathematische und statistische Operationen. Weitere Informationen finden Sie unter [CloudWatch Abfragesyntax in Logs Insights](CWL_QuerySyntax.md).
# Tutorial: Ausführen einer Abfrage mit einer Aggregationsfunktion
Sie können Aggregationsfunktionen im Befehl `stats` sowie als Argumente für andere Funktionen verwenden. In diesem Tutorial führen Sie einen Abfragebefehl aus, der die Anzahl der Protokollereignisse zählt, die ein angegebenes Feld enthalten. Der Abfragebefehl gibt eine Gesamtzahl zurück, die nach dem Wert oder den Werten des angegebenen Felds gruppiert ist. Weitere Informationen zu Aggregationsfunktionen finden Sie unter [Unterstützte Operationen und Funktionen](https://docs.aws.amazon.com/en_us/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html#CWL_QuerySyntax-operations-functions) im *Amazon CloudWatch Logs-Benutzerhandbuch*.
**Ausführen einer Abfrage mit einer Aggregationsfunktion**
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 **Logs** (Protokolle) und dann **Logs Insights** aus.
1. Vergewissern Sie sich, dass die Registerkarte **Logs Insights QL** ausgewählt ist.
1. Wählen Sie in der Dropdownliste **Select log group(s)** (Protokollgruppe(n) auswählen) eine oder mehrere Protokollgruppen aus, die abgefragt werden sollen.
Wenn es sich um ein Überwachungskonto mit CloudWatch kontenübergreifender Observability handelt, können Sie Protokollgruppen sowohl in den Quellkonten als auch im Überwachungskonto auswählen. Mit einer einzigen Abfrage können Protokolle von verschiedenen Konten gleichzeitig abgefragt werden.
Sie können die Protokollgruppen nach dem Namen der Protokollgruppe, der Konto-ID oder der Kontobezeichnung filtern.
Wenn Sie eine Protokollgruppe auswählen, erkennt CloudWatch Logs Insights automatisch Datenfelder in der Protokollgruppe, wenn es sich um eine Protokollgruppe der Standardklasse handelt. Um diese erkannten Felder anzuzeigen, wählen Sie das Menü **Fields** (Felder) oben rechts auf der Seite aus.
1. Löschen Sie die Standardabfrage im Abfrage-Editor und geben Sie den folgenden Befehl ein:
```
stats count(*) by fieldName
```
1. *fieldName*Ersetzen Sie es durch ein erkanntes Feld aus dem Menü „**Felder**“.
Das Menü „**Felder**“ befindet sich oben rechts auf der Seite und zeigt alle erkannten Felder an, die CloudWatch Logs Insights in Ihrer Protokollgruppe erkennt.
1. Klicken Sie auf **Run** (Ausführen), um die Abfrageergebnisse anzuzeigen.
Die Abfrageergebnisse zeigen die Anzahl der Datensätze in Ihrer Protokollgruppe, die mit dem Abfragebefehl übereinstimmen, und die Gesamtzahl, die nach dem Wert oder den Werten des angegebenen Felds gruppiert ist.
# Tutorial: Ausführen einer Abfrage, die eine nach Protokollfeldern gruppierte Visualisierung erzeugt
Wenn Sie eine Abfrage ausführen, die die zurückgegebenen Ergebnisse über die Funktion `stats` nach den Werten von einem oder mehreren Feldern in den Protokolleinträgen gruppiert, können Sie die Ergebnisse als Balken-, Kreis-, Linien- oder gestapeltes Flächendiagramm aufrufen. Auf diese Weise können Sie Trends in Ihren Protokollen effizienter visualisieren.
**So führen Sie eine Abfrage zur Visualisierung durch**
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 **Logs** (Protokolle) und dann **Logs Insights** aus.
1. Wählen Sie in der Dropdownliste **Select log group(s)** (Protokollgruppe(n) auswählen) eine oder mehrere Protokollgruppen aus, die abgefragt werden sollen.
Wenn es sich um ein Überwachungskonto mit CloudWatch kontenübergreifender Observability handelt, können Sie Protokollgruppen sowohl in den Quellkonten als auch im Überwachungskonto auswählen. Mit einer einzigen Abfrage können Protokolle von verschiedenen Konten gleichzeitig abgefragt werden.
Sie können die Protokollgruppen nach dem Namen der Protokollgruppe, der Konto-ID oder der Kontobezeichnung filtern.
1. Löschen Sie im Abfrageeditor den aktuellen Inhalt, geben Sie dann die folgende `stats`-Funktion ein und klicken Sie auf **Abfrage ausführen**.
```
stats count(*) by @logStream
| limit 100
```
Die Ergebnisse zeigen für jeden Protokolldatenstrom die Anzahl der Protokollereignisse in der Protokollgruppe. Die Ergebnisse sind auf nur 100 Zeilen begrenzt.
1. Wählen Sie die Registerkarte **Visualization (Visualisierung)** aus.
1. Wählen Sie den Pfeil neben **Line (Zeile)** aus. Wählen Sie anschließend **Bar (Balken)** aus.
Das Balkendiagramm wird angezeigt, wobei jeder Protokolldatenstrom in der Protokollgruppe von einem Balken dargestellt wird.
# Tutorial: Ausführen einer Abfrage, die eine Visualisierung von Zeitreihen erzeugt
Wenn Sie eine Abfrage ausführen, die die zurückgegebenen Ergebnisse über die Funktion `bin()` nach einem Zeitraum gruppiert, können Sie die Ergebnisse als Linien-, Balken- oder gestapeltes Flächendiagramm anzeigen. Auf diese Weise können Sie Trends in Protokollereignissen im Laufe der Zeit effizienter visualisieren.
**So führen Sie eine Abfrage zur Visualisierung durch**
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 **Logs** (Protokolle) und dann **Logs Insights** aus.
1. Vergewissern Sie sich, dass die Registerkarte **Logs Insights QL** ausgewählt ist.
1. Wählen Sie in der Dropdownliste **Select log group(s)** (Protokollgruppe(n) auswählen) eine oder mehrere Protokollgruppen aus, die abgefragt werden sollen.
Wenn es sich um ein Überwachungskonto mit CloudWatch kontenübergreifender Observability handelt, können Sie Protokollgruppen sowohl in den Quellkonten als auch im Überwachungskonto auswählen. Mit einer einzigen Abfrage können Protokolle von verschiedenen Konten gleichzeitig abgefragt werden.
Sie können die Protokollgruppen nach dem Namen der Protokollgruppe, der Konto-ID oder der Kontobezeichnung filtern.
1. Löschen Sie im Abfrageeditor den aktuellen Inhalt, geben Sie dann die folgende `stats`-Funktion ein und klicken Sie auf **Abfrage ausführen**.
```
stats count(*) by bin(30s)
```
Die Ergebnisse zeigen die Anzahl der Protokollereignisse in der Protokollgruppe, die von CloudWatch Logs für jeden Zeitraum von 30 Sekunden empfangen wurden.
1. Wählen Sie die Registerkarte **Visualization (Visualisierung)** aus.
Die Ergebnisse werden als Liniendiagramm dargestellt. Um zu einem Balken-, Kreis- oder gestapelten Flächendiagramm zu wechseln, wählen Sie oben Links im Diagramm auf den Pfeil neben **Line (Linie)**.
# Beispielabfragen
Dieser Abschnitt enthält eine Liste allgemeiner und nützlicher Abfragebefehle, die Sie in der [CloudWatchKonsole](https://console.aws.amazon.com/cloudwatch/) ausführen können. Informationen zur Ausführung eines Abfragebefehls finden Sie unter [Tutorial: Eine Beispielabfrage ausführen und ändern](https://docs.aws.amazon.com/en_us/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_RunSampleQuery.html) im *Amazon CloudWatch Logs-Benutzerhandbuch*.
Weitere Informationen zur Abfragesyntax finden Sie unter[CloudWatch Abfragesyntax in Logs Insights](CWL_QuerySyntax.md).
**Topics**
+ [Allgemeine Abfragen](#CWL_QuerySyntax-examples-general)
+ [Abfragen für Lambda-Protokolle](#CWL_QuerySyntax-examples-Lambda)
+ [Abfragen für Flussprotokolle von Amazon-VPC](#CWL_QuerySyntax-examples-VPC)
+ [Abfragen für Route-53-Protokolle](#CWL_QuerySyntax-examples-Route53)
+ [Abfragen für CloudTrail Protokolle](#CWL_QuerySyntax-examples-CloudTrail)
+ [Abfragen für Amazon API Gateway](#CWL_QuerySyntax-examples-APIGateway)
+ [Abfragen für NAT-Gateway](#CWL_QuerySyntax-examples-NATGateway)
+ [Abfragen für Apache-Serverprotokolle](#CWL_QuerySyntax-examples-Apache)
+ [Anfragen für Amazon EventBridge](#CWL_QuerySyntax-examples-EventBridge)
+ [Beispiele des parse-Befehls](#CWL_QuerySyntax-examples-parse)
## Allgemeine Abfragen
**Findet die 25 zuletzt hinzugefügten Protokollereignisse.**
```
fields @timestamp, @message | sort @timestamp desc | limit 25
```
**Ruft eine Liste der Anzahl der Ausnahmen pro Stunde ab.**
```
filter @message like /Exception/
| stats count(*) as exceptionCount by bin(1h)
| sort exceptionCount desc
```
**Ruft eine Liste von Protokollereignissen ab, die keine Ausnahmen sind.**
```
fields @message | filter @message not like /Exception/
```
**Ruft das letzte Protokollereignis für jeden eindeutigen Wert des Felds `server` ab.**
```
fields @timestamp, server, severity, message
| sort @timestamp asc
| dedup server
```
**Ruft das letzte Protokollereignis für jeden eindeutigen Wert des Felds `server` für jeden `severity`-Typ ab.**
```
fields @timestamp, server, severity, message
| sort @timestamp desc
| dedup server, severity
```
## Abfragen für Lambda-Protokolle
**Ermittelt die Menge des zu viel bereitgestellten Speichers.**
```
filter @type = "REPORT"
| stats max(@memorySize / 1000 / 1000) as provisonedMemoryMB,
min(@maxMemoryUsed / 1000 / 1000) as smallestMemoryRequestMB,
avg(@maxMemoryUsed / 1000 / 1000) as avgMemoryUsedMB,
max(@maxMemoryUsed / 1000 / 1000) as maxMemoryUsedMB,
provisonedMemoryMB - maxMemoryUsedMB as overProvisionedMB
```
**Erstellt einen Latenzbericht.**
```
filter @type = "REPORT" |
stats avg(@duration), max(@duration), min(@duration) by bin(5m)
```
**Sucht nach langsamen Funktionsaufrufen und beseitigt doppelte Anfragen, die durch Wiederholungen oder clientseitigen Code entstehen können. In dieser Abfrage ist `@duration` in Millisekunden.**
```
fields @timestamp, @requestId, @message, @logStream
| filter @type = "REPORT" and @duration > 1000
| sort @timestamp desc
| dedup @requestId
| limit 20
```
## Abfragen für Flussprotokolle von Amazon-VPC
**Findet die Top 15 Paketübertragungen zwischen den Hosts:**
```
stats sum(packets) as packetsTransferred by srcAddr, dstAddr
| sort packetsTransferred desc
| limit 15
```
**Findet die Top 15 Byte-Übertragungen für Hosts in einem bestimmten Subnetz.**
```
filter isIpv4InSubnet(srcAddr, "192.0.2.0/24")
| stats sum(bytes) as bytesTransferred by dstAddr
| sort bytesTransferred desc
| limit 15
```
**Findet die IP-Adressen, die UDP als Datenübertragungsprotokoll verwenden.**
```
filter protocol=17 | stats count(*) by srcAddr
```
**Findet die IP-Adressen, bei denen während des Erfassungsfensters Flussdatensätze übersprungen wurden.**
```
filter logStatus="SKIPDATA"
| stats count(*) by bin(1h) as t
| sort t
```
**Sucht einen einzelnen Datensatz für jede Verbindung, um Probleme mit der Netzwerkverbindung zu beheben.**
```
fields @timestamp, srcAddr, dstAddr, srcPort, dstPort, protocol, bytes
| filter logStream = 'vpc-flow-logs' and interfaceId = 'eni-0123456789abcdef0'
| sort @timestamp desc
| dedup srcAddr, dstAddr, srcPort, dstPort, protocol
| limit 20
```
## Abfragen für Route-53-Protokolle
**Findet die Verteilung der Datensätze pro Stunde nach Abfragetyp.**
```
stats count(*) by queryType, bin(1h)
```
**Findet die 10 DNS-Resolver mit der höchsten Anzahl von Anforderungen.**
```
stats count(*) as numRequests by resolverIp
| sort numRequests desc
| limit 10
```
**Ermittelt die Anzahl der Datensätze nach Domain und Subdomain, bei denen der Server die DNS-Anforderung nicht abgeschlossen hat.**
```
filter responseCode="SERVFAIL" | stats count(*) by queryName
```
## Abfragen für CloudTrail Protokolle
**Ermitteln Sie die Anzahl der Protokolleinträge für jeden Dienst, Ereignistyp und AWS Region.**
```
stats count(*) by eventSource, eventName, awsRegion
```
**Finden Sie die Amazon EC2 EC2-Hosts, die in einer bestimmten AWS Region gestartet oder gestoppt wurden.**
```
filter (eventName="StartInstances" or eventName="StopInstances") and awsRegion="us-east-2"
```
**Finden Sie die AWS Regionen, Benutzernamen und ARNs neu erstellten IAM-Benutzer.**
```
filter eventName="CreateUser"
| fields awsRegion, requestParameters.userName, responseElements.user.arn
```
**Ermittelt die Anzahl der Datensätze, bei denen beim Aufruf des API-`UpdateTrail` eine Ausnahme aufgetreten ist.**
```
filter eventName="UpdateTrail" and ispresent(errorCode)
| stats count(*) by errorCode, errorMessage
```
**Findet Protokolleinträge, in denen TLS 1.0 oder 1.1 verwendet wurde.**
```
filter tlsDetails.tlsVersion in [ "TLSv1", "TLSv1.1" ]
| stats count(*) as numOutdatedTlsCalls by userIdentity.accountId, recipientAccountId, eventSource, eventName, awsRegion, tlsDetails.tlsVersion, tlsDetails.cipherSuite, userAgent
| sort eventSource, eventName, awsRegion, tlsDetails.tlsVersion
```
**Ermittelt die Anzahl der Anrufe pro Service, die die TLS-Versionen 1.0 oder 1.1 verwendet haben.**
```
filter tlsDetails.tlsVersion in [ "TLSv1", "TLSv1.1" ]
| stats count(*) as numOutdatedTlsCalls by eventSource
| sort numOutdatedTlsCalls desc
```
## Abfragen für Amazon API Gateway
Findet die letzten 10 4XX-Fehler.
```
fields @timestamp, status, ip, path, httpMethod
| filter status>=400 and status<=499
| sort @timestamp desc
| limit 10
```
Identifizieren Sie die 10 am längsten laufenden Amazon API Gateway Anfragen in Ihrer Amazon API Gateway Zugriffs-Log-Gruppe
```
fields @timestamp, status, ip, path, httpMethod, responseLatency
| sort responseLatency desc
| limit 10
```
Gibt die Liste der beliebtesten API-Pfade in Ihrer Amazon API Gateway -Zugriffsprotokollgruppe zurück.
```
stats count(*) as requestCount by path
| sort requestCount desc
| limit 10
```
Erstellt einen Integrationslatenzbericht für Ihre Amazon API Gateway -Zugriffsprotokollgruppe.
```
filter status=200
| stats avg(integrationLatency), max(integrationLatency),
min(integrationLatency) by bin(1m)
```
## Abfragen für NAT-Gateway
Wenn Sie feststellen, dass Ihre AWS Rechnung höhere als normale Kosten enthält, können Sie CloudWatch Logs Insights verwenden, um die wichtigsten Mitwirkenden zu finden. Weitere Informationen zu den folgenden Abfragebefehlen finden Sie unter [Wie finde ich die Hauptverursacher des Datenverkehrs über das NAT-Gateway in meiner VPC?](https://aws.amazon.com/premiumsupport/knowledge-center/vpc-find-traffic-sources-nat-gateway/) auf der AWS Premium-Support-Seite.
**Anmerkung**
Ersetzen Sie in den folgenden Abfragebefehlen „x.x.x.x“ durch die private IP Ihres NAT-Gateways und ersetzen Sie „y.y“ durch die ersten beiden Oktette Ihres VPC-CIDR-Bereichs.
**Findet die Instances, die den meisten Datenverkehr über Ihr NAT-Gateway senden.**
```
filter (dstAddr like 'x.x.x.x' and srcAddr like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
**Bestimmt den Datenverkehr, der bei den Instances in Ihren NAT-Gateways ein- bzw. ausgeht.**
```
filter (dstAddr like 'x.x.x.x' and srcAddr like 'y.y.') or (srcAddr like 'xxx.xx.xx.xx' and dstAddr like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
**Bestimmt die Internetziele, mit denen die Instances in Ihrer VPC am häufigsten für Uploads und Downloads kommunizieren.**
*****For uploads***** (Für Uploads)
```
filter (srcAddr like 'x.x.x.x' and dstAddr not like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
*****Für Downloads*****
```
filter (dstAddr like 'x.x.x.x' and srcAddr not like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
## Abfragen für Apache-Serverprotokolle
Sie können CloudWatch Logs Insights verwenden, um Apache-Serverprotokolle abzufragen. Weitere Informationen zu den folgenden Abfragen finden Sie unter [Simplifying Apache Server Logs with CloudWatch Logs Insights](https://aws.amazon.com/blogs/mt/simplifying-apache-server-logs-with-amazon-cloudwatch-logs-insights/) im AWS Cloud Operations & Migrations Blog.
**Findet die relevantesten Felder, damit Sie Ihre Zugriffsprotokolle und den Datenverkehr im Pfad */admin* Ihrer Anwendung überprüfen können.**
```
fields @timestamp, remoteIP, request, status, filename| sort @timestamp desc
| filter filename="/var/www/html/admin"
| limit 20
```
**Ermittelt die Anzahl der eindeutigen GET-Anforderungen, die auf Ihre Hauptseite mit dem Statuscode „200“ (Erfolg) zugegriffen haben.**
```
fields @timestamp, remoteIP, method, status
| filter status="200" and referrer= http://34.250.27.141/ and method= "GET"
| stats count_distinct(remoteIP) as UniqueVisits
| limit 10
```
**Gibt an, wie oft Ihr Apache-Service neu gestartet wurde.**
```
fields @timestamp, function, process, message
| filter message like "resuming normal operations"
| sort @timestamp desc
| limit 20
```
## Anfragen für Amazon EventBridge
Ruft die Anzahl der EventBridge Ereignisse ab, gruppiert nach Art der Ereignisdetails
```
fields @timestamp, @message
| stats count(*) as numberOfEvents by `detail-type`
| sort numberOfEvents desc
```
## Beispiele des parse-Befehls
**Verwenden Sie einen globalen Ausdruck zum Extrahieren der Felder `@user`, `@method` und `@latency` aus dem Protokollfeld `@message` und zur Rückgabe der durchschnittlichen Latenz für jede eindeutige Kombination aus `@method` und `@user`.**
```
parse @message "user=*, method:*, latency := *" as @user,
@method, @latency | stats avg(@latency) by @method,
@user
```
**Verwenden Sie einen regulären Ausdruck zum Extrahieren der Felder `@user2`, `@method2` und `@latency2` aus dem Protokollfeld `@message` und zur Rückgabe der durchschnittlichen Latenz für jede eindeutige Kombination aus `@method2` und `@user2`.**
```
parse @message /user=(?.*?), method:(?.*?),
latency := (?.*?)/ | stats avg(latency2) by @method2,
@user2
```
**Extrahiert die Felder `loggingTime`, `loggingType` und `loggingMessage`, filtert nach Protokollereignissen, die die Zeichenfolgen `ERROR` oder `INFO` enthalten, und zeigt dann nur die Felder `loggingMessage` und `loggingType` für Ereignisse an, die die Zeichenfolge `ERROR` enthalten.**
```
FIELDS @message
| PARSE @message "* [*] *" as loggingTime, loggingType, loggingMessage
| FILTER loggingType IN ["ERROR", "INFO"]
| DISPLAY loggingMessage, loggingType = "ERROR" as isError
```
# Vergleiche (Diff) mit früheren Zeitbereichen
Sie können CloudWatch Logs Insights mit Logs Insights QL verwenden, um Änderungen Ihrer Protokollereignisse im Laufe der Zeit zu vergleichen. Sie können die in einem kürzlichen Zeitraum aufgenommenen Protokollereignisse mit den Protokollen aus dem unmittelbar vorangegangenen Zeitraum vergleichen. Alternativ können Sie Vergleiche mit ähnlichen vergangenen Zeiträumen durchführen. Auf diese Weise können Sie herausfinden, ob ein Fehler in Ihren Protokollen erst vor Kurzem aufgetreten ist oder bereits aufgetreten ist, und es kann Ihnen auch helfen, andere Trends zu finden.
Vergleichsabfragen geben nur Muster in den Ergebnissen zurück, keine Rohprotokollereignisse. Anhand der zurückgegebenen Muster können Sie schnell die Trends und Änderungen der Protokollereignisse im Laufe der Zeit erkennen. Nachdem Sie eine Vergleichsabfrage ausgeführt haben und die Musterergebnisse vorliegen, können Sie sich beispielhafte Rohprotokollereignisse für die Muster ansehen, an denen Sie interessiert sind. Weitere Informationen zu Protokollmustern finden Sie unter[Musteranalyse](CWL_AnalyzeLogData_Patterns.md).
Wenn Sie eine Vergleichsabfrage ausführen, wird Ihre Abfrage anhand von zwei verschiedenen Zeiträumen analysiert: dem ursprünglichen Abfragezeitraum, den Sie ausgewählt haben, und dem Vergleichszeitraum. Der Vergleichszeitraum ist immer gleich lang wie Ihr ursprünglicher Abfragezeitraum. Die Standardzeitintervalle für die Vergleiche sind die folgenden.
+ **Vorheriger Zeitraum** — Vergleicht den Zeitraum unmittelbar vor dem Abfragezeitraum.
+ **Vorheriger Tag** — Vergleicht den Zeitraum einen Tag vor Ihrem Abfragezeitraum.
+ **Vorige Woche** — Vergleicht den Zeitraum eine Woche vor Ihrem Abfragezeitraum.
+ **Vorheriger Monat** — Vergleicht den Zeitraum einen Monat vor Ihrem Abfragezeitraum.
**Anmerkung**
Für Abfragen, die Vergleiche verwenden, fallen Gebühren an, die denen der Ausführung einer einzelnen CloudWatch Logs Insights-Abfrage über den gesamten Zeitraum ähneln. Weitere Informationen finden Sie unter [Amazon CloudWatch – Preise](https://aws.amazon.com/cloudwatch/pricing/).
**Um eine Vergleichsabfrage auszuführen**
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 **Protokolle** und dann **Logs Insights** aus.
Im Abfragefeld wird eine Standardabfrage angezeigt.
1. Vergewissern Sie sich, dass die Registerkarte **Logs Insights QL** ausgewählt ist.
1. Behalten Sie die Standardabfrage bei oder geben Sie eine andere Abfrage ein.
1. **Wählen Sie in der Dropdownliste Protokollgruppe (n)** auswählen eine oder mehrere Protokollgruppen für die Abfrage aus.
1. (Optional) Verwenden Sie die Zeitintervallauswahl, um einen Zeitraum auszuwählen, den Sie abfragen möchten. Die Standardabfrage bezieht sich auf die Protokolldaten der letzten Stunde.
1. Wählen Sie in der Zeitbereichsauswahl die Option **Vergleichen** aus. Wählen Sie dann den vorherigen Zeitraum aus, mit dem Sie die Originalprotokolle vergleichen möchten, und klicken Sie **auf Anwenden**.
1. Wählen Sie **Abfrage ausführen**.
Damit die Abfrage die Daten aus dem Vergleichszeitraum abruft, wird der `diff` Befehl an Ihre Abfrage angehängt.
1. Wählen Sie die Registerkarte **Muster**, um die Ergebnisse zu sehen.
In der Tabelle werden die folgenden Informationen angezeigt:
+ Jedes **Muster**, wobei variable Teile des Musters durch das dynamische Tokensymbol ersetzt werden``. Das *string* ist eine Beschreibung des Datentyps, für den das Token steht. Das *number* zeigt, an welcher Stelle des Musters dieses Token im Vergleich zu den anderen dynamischen Tokens erscheint. Weitere Informationen finden Sie unter [Musteranalyse](CWL_AnalyzeLogData_Patterns.md).
+ Die **Anzahl** der Ereignisse ist die Anzahl der Protokollereignisse mit diesem Muster im ursprünglichen, aktuelleren Zeitraum.
+ Die **Anzahl der Differenzereignisse** ist die Differenz zwischen der Anzahl übereinstimmender Protokollereignisse im aktuellen Zeitraum und der Anzahl der Vergleichszeiträume. Ein positiver Unterschied bedeutet, dass es im aktuellen Zeitraum mehr solcher Ereignisse gibt.
+ Die **Beschreibung des Unterschieds** fasst kurz die Änderung dieses Musters zwischen dem aktuellen Zeitraum und dem Vergleichszeitraum zusammen.
+ Der **Schweregradtyp** ist der wahrscheinliche Schweregrad der Protokollereignisse mit diesem Muster, basierend auf Wörtern, die in den Protokollereignissen vorkommen`FATAL`, wie`ERROR`, und. `WARN`
1. Um eines der Muster in der Liste genauer zu untersuchen, wählen Sie das Symbol in der Spalte **Inspizieren** für eines der Muster aus.
Das Fenster „**Muster prüfen**“ wird geöffnet und enthält Folgendes:
+ Das **Muster**. Wählen Sie ein Token innerhalb des Musters aus, um die Werte dieses Tokens zu analysieren.
+ Ein Histogramm, das die Anzahl der Vorkommen des Musters im abgefragten Zeitraum zeigt. Dies kann Ihnen helfen, interessante Trends zu identifizieren, z. B. eine plötzliche Zunahme des Auftretens eines Musters.
+ Auf der Registerkarte **Protokollbeispiele** werden einige der Protokollereignisse angezeigt, die dem ausgewählten Muster entsprechen.
+ Auf der Registerkarte **Token-Werte** werden die Werte des ausgewählten dynamischen Tokens angezeigt, sofern Sie eines ausgewählt haben.
**Anmerkung**
Für jedes Token werden maximal 10 Token-Werte erfasst. Die Anzahl der Tokens ist möglicherweise nicht genau. CloudWatch Logs verwendet einen probabilistischen Zähler, um die Tokenanzahl zu generieren, nicht den absoluten Wert.
+ Auf der Registerkarte **Verwandte Muster** werden andere Muster angezeigt, die häufig fast zur gleichen Zeit wie das Muster aufgetreten sind, das Sie untersuchen. Wenn beispielsweise ein Muster für eine `ERROR` Nachricht normalerweise von einem anderen Protokollereignis begleitet wurde, das als `INFO` mit zusätzlichen Details gekennzeichnet war, wird dieses Muster hier angezeigt.
# Visualisieren von Protokolldaten in Diagrammen
Sie können Visualisierungen wie Balkendiagramme, Liniendiagramme und gestapelte Flächendiagramme verwenden, um Muster in Ihren Protokolldaten effizienter zu identifizieren. CloudWatch Logs Insights generiert Visualisierungen für Abfragen, die die `stats` Funktion und eine oder mehrere Aggregationsfunktionen verwenden. Weitere Informationen finden Sie unter [stats](CWL_QuerySyntax-Stats.md).
# OpenSearch Piped Processing Language (PPL)
Dieser Abschnitt enthält eine grundlegende Einführung in das Abfragen von CloudWatch Logs mit PPL. OpenSearch Mit PPL können Sie Daten mithilfe von in der Pipeline zusammengefügten Befehlen abrufen, abfragen und analysieren, was das Verständnis und die Erstellung komplexer Abfragen erleichtert. Die Syntax basiert auf Unix-Pipes und ermöglicht die Verkettung von Befehlen zur Transformation und Verarbeitung von Daten. Mit PPL können Sie Daten filtern und aggregieren und eine Vielzahl von mathematischen, Zeichenketten-, Datums-, Bedingungs- und anderen Funktionen für die Analyse verwenden.
Die Aufnahme `SOURCE` in eine PPL-Abfrage ist eine nützliche Methode, um die Protokollgruppen, Feldindizes und Datenquellen anzugeben, die in eine Abfrage aufgenommen werden sollen, wenn Sie die AWS CLI OR-API zum Erstellen einer Abfrage verwenden. Der `SOURCE` Befehl wird nur in der AWS CLI AND-API unterstützt, nicht in der CloudWatch Konsole. Wenn Sie die CloudWatch Konsole verwenden, um eine Abfrage zu starten, verwenden Sie die Konsolenschnittstelle, um die Protokollgruppen sowie den Namen und Typ der Datenquelle anzugeben.
Wird verwendet, `aws:fieldIndex` um nur indizierte Daten zurückzugeben, indem eine Abfrage erzwungen wird, nur Protokollgruppen zu scannen, die in einem Feld indexiert sind, das Sie in der Abfrage angeben. Die relevanten Protokollgruppen werden automatisch auf der Grundlage der im Befehl angegebenen Felder ausgewählt. `filterIndex` Dadurch wird das gescannte Volumen reduziert, indem Protokollgruppen übersprungen werden, die keine Protokollereignisse enthalten, die das in der Abfrage angegebene Feld enthalten, und nur Protokollgruppen gescannt werden, die dem in der Abfrage für diesen Feldindex angegebenen Wert entsprechen. Geben Sie `aws:fieldIndex` hier den Feldnamen zusammen mit dem Feldnamen und dem Feldwert im Quellbefehl an, um nur indizierte Daten abzufragen, die das angegebene Feld und den angegebenen Wert enthalten. Weitere Informationen finden Sie unter [Erstellen Sie Feldindizes, um die Abfrageleistung zu verbessern und das Scanvolumen zu reduzieren](CloudWatchLogs-Field-Indexing.md).
Sie können OpenSearch PPL für Abfragen von Protokollgruppen in der Standard-Protokollklasse verwenden.
**Anmerkung**
Informationen zu allen in CloudWatch Logs unterstützten OpenSearch PPL-Abfragebefehlen sowie ausführliche Informationen zu Syntax und Einschränkungen finden Sie unter [Unterstützte PPL-Befehle](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/supported-ppl.html) im OpenSearch Service Developer Guide.
Informationen zu anderen Abfragesprachen, die Sie verwenden können, finden Sie unter [CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html), [OpenSearch Service SQL](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_SQL.html) und [CloudWatch Metrics Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/query_with_cloudwatch-metrics-insights.html)
| Befehl oder Funktion | Beispielabfrage | Description |
| --- | --- | --- |
| fields | `fields field1, field2` | Zeigt eine Reihe von Feldern an, die projiziert werden müssen. |
| join | `LEFT JOIN left=l, right=r on l.id = r.id `join_right_lg` \| fields l.field_1, r.field_2` | Verbindet zwei Datensätze miteinander. |
| where | `where field1="success" \| where field2 != "i-023fe0a90929d8822" \| fields field3, field4, field5,field6 \| head 1000` | Filtert die Daten auf der Grundlage der von Ihnen angegebenen Bedingungen. |
| aws:FieldIndex | `source = [`aws:fieldIndex`="region", `region` = "us-west-2"] \| where status = 200 \| head 10` | Gibt nur indizierte Daten zurück, indem eine Abfrage erzwungen wird, nur Protokollgruppen zu scannen, die für ein Feld indiziert sind, das Sie in der Abfrage angeben. |
| stats | `stats count(), count(field1), min(field1), max(field1), avg(field1) by field2 \| head 1000` | Führt Aggregationen und Berechnungen durch |
| parse | `parse field1 ".*/(?[^/]+$)" \| where field2 = "requestId" \| fields field1, field2 \| head 1000` | Extrahiert ein Muster mit regulären Ausdrücken (Regex) aus einer Zeichenfolge und zeigt das extrahierte Muster an. Das extrahierte Muster kann weiter verwendet werden, um neue Felder zu erstellen oder Daten zu filtern. |
| sort | `stats count(), count(field1), min(field1) as field1Alias, max(`field1`), avg(`field1`) by field2 \| sort -field1Alias \| head 1000` | Sortiert die angezeigten Ergebnisse nach einem Feldnamen. Verwenden Sie sort -FieldName , um in absteigender Reihenfolge zu sortieren. |
| eval | `eval field2 = field1 * 2 \| fields field1, field2 \| head 20` | Ändert oder verarbeitet den Wert eines Felds und speichert ihn in einem anderen Feld. Dies ist nützlich, um eine Spalte mathematisch zu modifizieren, Zeichenkettenfunktionen auf eine Spalte anzuwenden oder Datumsfunktionen auf eine Spalte anzuwenden. |
| umbenennen | `rename field2 as field1 \| fields field1;` | Benennt ein oder mehrere Felder im Suchergebnis um. |
| head | `fields `@message` \| head 20` | Beschränkt die angezeigten Abfrageergebnisse auf die ersten N Zeilen. |
| top | `top 2 field1 by field2` | Findet die häufigsten Werte für ein Feld. |
| dedup | `dedup field1 \| fields field1, field2, field3` | Entfernt doppelte Einträge auf der Grundlage der von Ihnen angegebenen Felder. |
| selten | `rare field1 by field2` | Findet die seltensten Werte aller Felder in der Feldliste. |
| subquery | `where field_1 IN [ search source= `subquery_lg` \| fields field_2 ] \| fields id, field_1 ` | Führt komplexe, verschachtelte Abfragen innerhalb Ihrer PPL-Anweisungen durch. |
| Trendlinie | `trendline sma(2, field1) as field1Alias` | Berechnet die gleitenden Durchschnitte von Feldern. |
| EventStats | `eventstats sum(field1) by field2` | Reichert Ihre Eventdaten mit berechneten zusammenfassenden Statistiken an. Es analysiert bestimmte Felder innerhalb Ihrer Ereignisse, berechnet verschiedene statistische Kennzahlen und fügt diese Ergebnisse dann als neue Felder an jedes ursprüngliche Ereignis an. |
| expand | `eval tags_array_string = json_extract(`@message`, '$.tags')\| eval tags_array = json_array(json_extract(tags_string, '$[0]'), json_extract(tags_string, '$[1]'))\| expand tags_array as color_tags` | Zerlegt ein Feld, das mehrere Werte enthält, in separate Zeilen und erstellt für jeden Wert im angegebenen Feld eine neue Zeile. |
| fillnull | `fields `@timestamp`, error_code, status_code \| fillnull using status_code = "UNKNOWN", error_code = "UNKNOWN"` | Füllt Nullfelder mit dem von Ihnen angegebenen Wert. Es kann in einem oder mehreren Feldern verwendet werden. |
| flatten | `eval metadata_struct = json_object('size', json_extract(metadata_string, '$.size'), 'color', json_extract(metadata_string, '$.color')) \| flatten metadata_struct as (meta_size, meta_color) ` | Macht ein Feld flach. Das Feld muss von diesem Typ sein: `struct` oder. `array>` |
| cidrmatch | `where cidrmatch(ip, '2003:db8::/32') \| fields ip ` | Prüft, ob die angegebene IP-Adresse innerhalb des angegebenen CIDR-Bereichs liegt. |
| Zusammenfassung des Feldes | `where field1 != 200 \| fieldsummary includefields= field1 nulls=true` | Berechnet grundlegende Statistiken für jedes Feld (Anzahl, eindeutige Anzahl, Min., Max, Durchschnitt, Standardwert und Mittelwert). |
| grok | `grok email '.+@%{HOSTNAME:host}' \| fields email, host` | Analysiert ein Textfeld mit einem Grok-Muster und hängt die Ergebnisse an das Suchergebnis an. |
| Zeichenfolgenfunktionen | `eval field1Len = LENGTH(field1) \| fields field1Len` | Integrierte Funktionen in PPL, mit denen Zeichenketten- und Textdaten in PPL-Abfragen bearbeitet und transformiert werden können. Zum Beispiel das Konvertieren von Groß- und Kleinschreibung, das Kombinieren von Zeichenketten, das Extrahieren von Teilen und das Bereinigen von Text. |
| Funktionen für Datum und Uhrzeit | `eval newDate = ADDDATE(DATE('2020-08-26'), 1) \| fields newDate ` | Integrierte Funktionen für die Verarbeitung und Transformation von Datums- und Zeitstempeldaten in PPL-Abfragen. Zum Beispiel date\$1add, date\$1format, datediff, date-sub, timestampadd, timestampdiff, current\$1timezone, utc\$1timestamp und current\$1date. |
| Bedingungsfunktionen | `eval field2 = isnull(field1) \| fields field2, field1, field3` | Integrierte Funktionen, die nach bestimmten Feldbedingungen suchen und Ausdrücke bedingt auswerten. Wenn beispielsweise field1 null ist, wird field2 zurückgegeben. |
| Mathematische Funktionen | `eval field2 = ACOS(field1) \| fields field1` | Integrierte Funktionen für die Durchführung mathematischer Berechnungen und Transformationen in PPL-Abfragen. Zum Beispiel abs (absoluter Wert), round (rundet Zahlen), sqrt (Quadratwurzel), pow (Potenzberechnung) und ceil (rundet auf die nächste Ganzzahl auf). |
| CryptoGraphic Funktionen | `eval crypto = MD5(field)\| head 1000` | Um den Hash eines bestimmten Feldes zu berechnen |
| JSON-Funktionen | `eval valid_json = json('[1,2,3,{"f1":1,"f2":[5,6]},4]') \| fields valid_json` | Integrierte Funktionen für den Umgang mit JSON, einschließlich Arrays, Extrahieren und Validieren. Zum Beispiel json\$1object, json\$1array, to\$1json\$1string, json\$1array\$1length, json\$1extract, json\$1keys und json\$1valid. |
## Gültigkeitsbereich der Abfrage
Das Einbeziehen von SOURCE in eine Abfrage ist eine nützliche Methode, um die Protokollgruppen anzugeben, die in eine Abfrage aufgenommen werden sollen, wenn Sie die AWS CLI OR-API zum Erstellen einer Abfrage verwenden. Der Befehl SOURCE wird nur in der AWS CLI AND-API unterstützt, nicht in der CloudWatch Konsole. Wenn Sie die CloudWatch Konsole verwenden, um eine Abfrage zu starten, verwenden Sie die Konsolenschnittstelle, um die Protokollgruppen sowie den Namen und Typ der Datenquelle anzugeben.
Der Quellbefehl von PPL unterstützt jetzt mehrere Möglichkeiten, sie anzugeben:
1. Gruppe protokollieren
1. Feldindizes — Neu
1. Datenquelle und Datentyp — Neu
### Protokollgruppe
Die Quellenauswahl für die Protokollgruppe kann verwendet werden, wenn Kunden wissen, welche Protokollgruppe (n) genau durchsucht werden muss
```
source = [lg:`/aws/lambda/my-function`] | where status = 200 | head 10
```
### Feldindizes
Die auf Feldindexen basierende Quellauswahl reduziert die Menge der abgefragten Daten, indem die Ergebnisse auf indizierte Daten beschränkt werden, wenn Ihre Filter auf indizierte Felder abzielen. Die relevanten Protokollgruppen werden automatisch auf der Grundlage der im Befehl angegebenen Felder ausgewählt. `filterIndex` Weitere Informationen zu Feldindizes und deren Erstellung finden Sie unter [Feldindizes erstellen, um die Abfrageleistung zu verbessern und das Scanvolumen zu reduzieren](CloudWatchLogs-Field-Indexing.md).
Wird verwendet, `aws:fieldIndex` um nur indizierte Daten zurückzugeben, indem eine Abfrage erzwungen wird, nur Protokollgruppen zu scannen, die für ein Feld indiziert sind, das Sie in der Abfrage angeben. Für diese Protokollgruppen, die in diesem Feld indexiert sind, wird die Abfrage weiter optimiert, indem die Protokollgruppen übersprungen werden, die keine Protokollereignisse enthalten, die das in der Abfrage für das indizierte Feld angegebene Feld enthalten. Das gescannte Volumen wird weiter reduziert, indem versucht wird, nur Protokollereignisse aus diesen Protokollgruppen zu scannen, die dem in der Abfrage für diesen Feldindex angegebenen Wert entsprechen. Weitere Informationen zu Feldindizes und deren Erstellung finden Sie unter Feldindizes erstellen, um die Abfrageleistung zu verbessern und das Scanvolumen zu reduzieren.
`aws:fieldIndex`Wird in PPL verwendet, um anzugeben, welche Schlüssel-Wert-Paare als Indizes behandelt werden sollen. Die Syntax lautet wie folgt
```
source = [`aws:fieldIndex`="region", `region` = "us-west-2"] | where status = 200 | head 10
```
wobei
1. ``aws:fieldIndex`="region"`identifiziert die Region als Feldindex.
1. Hinweis: Statt = können Kunden IN verwenden, um mehrere Indizes anzugeben (Beispiel unten)
1. ``region`="us-west-2"`identifiziert die anzuwendende Filterbedingung
1. Hinweis: Statt = können Kunden IN verwenden, um mehrere Werte anzugeben (Beispiel unten)
Kunden können mehrere FieldIndexes wie folgt angeben
```
source = [`aws:fieldIndex` IN ("status", "region"), `status` = 200, `region` IN ("us-west-2", "us-east-1")] | head 10
```
### Datenquelle und Typ
Die Datenquellen- und typbasierte Quellenauswahl kann verwendet werden, wenn Kunden wissen, welche Datenquellen genau abgefragt werden müssen. Diese Abfrage wird über eine oder mehrere Protokollgruppen ausgeführt, die die angegebene Datenquelle und den angegebenen Datentyp enthalten.
```
source = [ds:`data_source.type`] | where status = 200 | head 10
```
#### PPL wird für Datenquellenabfragen unterstützt
Um den Anwendungsfall für die Abfrage von Datenquellen in PPL zu unterstützen, können Sie die dynamische Quellenauswahlklausel verwenden. Mit dieser Syntax können Sie Datenquellen abfragen, indem Sie sie im Suchbefehl angeben. Sie können bis zu 10 Datenquellen angeben.
**Syntax**
```
source=[ds:`DataSource1.Type1`, ds:`DataSource2.Type2`, ...ds:`DataSourcen.Typen`]
```
**Beispielabfrage**
```
search source=[ds:`DataSource1.Type1`, ds:`DataSource2.Type2`] | fields field1, field2
```
### Kombiniertes Beispiel
Kunden können alle Operatoren zur Quellenauswahl in beliebiger Reihenfolge angeben. Die Ergebnisse wären dann der Schnittpunkt aller angewandten Bedingungen.
Beispielsweise könnte/aws/lambda/my-function-1 mehrere Datenquellen und -typen enthalten, einschließlich einer Vielzahl von Indizes. Wenn die folgende Abfrage ausgeführt wurde, enthielten die zurückgegebenen Ergebnisse nur Ereignisse der Quelle und des Typs DataSource 1.Type1, die den Kriterien 'status' = 200 entsprechen.
```
search source=[
ds:`DataSource1.Type1`,
lg:`/aws/lambda/my-function-1`,
`aws:fieldIndex` IN ("status"), `status` = 200
]
```
## Einschränkungen
Die folgenden Einschränkungen gelten, wenn Sie OpenSearch PPL für Abfragen in Logs Insights verwenden. CloudWatch
+ Sie können die Befehle join oder subquery nicht mit Datenquellenabfragen verwenden.
# OpenSearch Strukturierte Abfragesprache (SQL)
Dieser Abschnitt enthält eine grundlegende Einführung in das Abfragen von CloudWatch Logs mit OpenSearch SQL. Es bietet eine vertraute Option, wenn Sie es gewohnt sind, mit relationalen Datenbanken zu arbeiten. OpenSearch SQL bietet einen Teil der SQL-Funktionalität und ist daher eine gute Wahl für Ad-hoc-Abfragen und Datenanalyseaufgaben. Mit OpenSearch SQL können Sie Befehle wie SELECT, FROM, WHERE, GROUP BY, HAVING und verschiedene andere SQL-Befehle und -Funktionen verwenden. Sie können JOINs loggruppenübergreifend ausführen, Daten mithilfe von Unterabfragen zwischen Protokollgruppen korrelieren und die umfangreiche Palette von JSON-, mathematischen, Zeichenketten-, bedingten und anderen SQL-Funktionen verwenden, um leistungsstarke Analysen von Protokoll- und Sicherheitsdaten durchzuführen.
Wird verwendet, `filterIndex` um nur indizierte Daten zurückzugeben, indem eine Abfrage erzwungen wird, nur Protokollgruppen zu scannen, die für ein Feld indiziert sind, das Sie in der Abfrage angeben. Reduzieren Sie das gescannte Volumen, indem Sie Protokollgruppen überspringen, die keine Protokollereignisse enthalten, die das in der Abfrage angegebene Feld enthalten, und nur Protokollgruppen scannen, die dem in der Abfrage angegebenen Wert für diesen Feldindex entsprechen. Geben Sie `filterIndex` hier den Feldnamen zusammen mit dem Feldnamen und dem Feldwert an, um nur indizierte Daten abzufragen, die das angegebene Feld und den angegebenen Wert enthalten.
Sie können OpenSearch SQL für Abfragen von Protokollgruppen in der Standard-Protokollklasse verwenden. SQL unterstützt auch Abfragen mithilfe des Datenquellennamens und des Datenquellentyps.
**Anmerkung**
In der folgenden Tabelle sind die in CloudWatch Logs unterstützten SQL-Befehle und -Funktionen aufgeführt. Informationen zu allen OpenSearch SQL-Befehlen einschließlich der Syntax finden Sie unter [Unterstützte SQL-Befehle](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/supported-directquery-sql.html) im OpenSearch Service Developer Guide.
Informationen zu anderen Abfragesprachen, die Sie verwenden können, finden Sie unter [CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html), [OpenSearch Service PPL](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_PPL.html) und [CloudWatch Metrics Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/query_with_cloudwatch-metrics-insights.html).
## Unterstützte SQL-Befehle
**Anmerkung**
Ersetzen Sie in der Beispielabfragespalte nach `` Bedarf, je nachdem, welche Datenquelle Sie abfragen.
| Befehl oder Funktion | Beispielabfrage | Description |
| --- | --- | --- |
| SELECT | `SELECT `@message`, Operation FROM `LogGroupA`` | Zeigt projizierte Werte an. |
| FROM | `SELECT `@message`, Operation FROM `LogGroupA`` | Integrierte Klausel, die die Quelltabelle (n) oder Ansicht (en) angibt, aus denen Daten abgerufen werden sollen, und unterstützt verschiedene Arten von Verknüpfungen und Unterabfragen. |
| WHERE | `SELECT * FROM `LogGroupA` WHERE Operation = 'x'` | Filtert Protokollereignisse auf der Grundlage der angegebenen Feldkriterien. |
| filterIndex | `SELECT * FROM `filterIndex('region' = 'us-east-1')` WHERE status = 200 LIMIT 10;` | Gibt nur indizierte Daten zurück, indem eine Abfrage erzwungen wird, nur Protokollgruppen zu scannen, die für ein Feld indiziert sind, das Sie in der Abfrage angeben. |
| GROUP BY | `SELECT `@logStream`, COUNT(*) as log_count FROM `LogGroupA` GROUP BY `@logStream`` | Gruppiert Ereignisse nach Kategorien und ermittelt anhand von Statistiken den Durchschnitt. |
| HAVING | `SELECT `@logStream`, COUNT(*) as log_count FROM `LogGroupA` GROUP BY `@logStream` HAVING log_count > 100` | Filtert die Ergebnisse anhand der Gruppierungsbedingungen. |
| ORDER BY | `SELECT * FROM `LogGroupA` ORDER BY `@timestamp` DESC` | Sortiert die Ergebnisse auf der Grundlage der Felder in der ORDER BY-Klausel. Sie können entweder in absteigender oder aufsteigender Reihenfolge sortieren. |
| JOIN | `SELECT A.`@message`, B.`@timestamp`FROM `LogGroupA` as A INNER JOIN `LogGroupB` as B ON A.`requestId` = B.`requestId`` | Verbindet die Ergebnisse für zwei Tabellen auf der Grundlage gemeinsamer Felder. Inner JOIN oder Left Outer Join müssen angegeben werden |
| LIMIT | `Select * from `LogGroupA` limit 10` | Beschränkt die angezeigten Abfrageergebnisse auf die ersten N Zeilen. |
| Zeichenfolgenfunktionen | `SELECT upper(Operation) , lower(Operation), Operation FROM `LogGroupA`` | Integrierte Funktionen in SQL, mit denen Zeichenketten- und Textdaten in SQL-Abfragen bearbeitet und transformiert werden können. Zum Beispiel das Konvertieren von Groß- und Kleinschreibung, das Kombinieren von Zeichenketten, das Extrahieren von Teilen und das Bereinigen von Text. |
| Datumsfunktionen | `SELECT current_date() as today, date_add(current_date(), 30) as thirty_days_later, last_day(current_date()) as month_end FROM `LogGroupA`` | Integrierte Funktionen für die Verarbeitung und Transformation von Datums- und Zeitstempeldaten in SQL-Abfragen. Zum Beispiel date\$1add, date\$1format, datediff und current\$1date. |
| Konditionale Funktionen | `SELECT Operation, IF(Error > 0, 'High', 'Low') as error_category FROM `LogGroupA`;` | Integrierte Funktionen, die Aktionen auf der Grundlage bestimmter Bedingungen ausführen oder Ausdrücke bedingt auswerten. Zum Beispiel CASE und IF. |
| Aggregationsfunktionen | `SELECT AVG(bytes) as bytesWritten FROM `LogGroupA`` | Integrierte Funktionen, die Berechnungen für mehrere Zeilen durchführen, um einen einzelnen zusammengefassten Wert zu erzeugen. Zum Beispiel SUM, COUNT, AVG, MAX und MIN. |
| JSON-Funktionen | `SELECT get_json_object(json_column, '$.name') as name FROM `LogGroupA`` | Integrierte Funktionen zum Parsen, Extrahieren, Ändern und Abfragen von Daten im JSON-Format innerhalb von SQL-Abfragen (z. B. from\$1json, to\$1json, get\$1json\$1object, json\$1tuple), die die Manipulation von JSON-Strukturen in Datensätzen ermöglichen. |
| Array-Funktionen | `SELECT scores, size(scores) as length, array_contains(scores, 90) as has_90 FROM `LogGroupA`;` | Integrierte Funktionen für die Arbeit mit Spalten vom Typ Array in SQL-Abfragen, die Operationen wie den Zugriff auf, die Änderung und die Analyse von Array-Daten (z. B. size, explode, array\$1contains) ermöglichen. |
| Fensterfunktionen | `SELECT field1, field2, RANK() OVER (ORDER BY field2 DESC) as field2Rank FROM `LogGroupA`;` | Integrierte Funktionen, die Berechnungen für eine bestimmte Gruppe von Zeilen durchführen, die sich auf die aktuelle Zeile (Fenster) beziehen, wodurch Operationen wie Rangfolge, laufende Summen und gleitende Durchschnitte ermöglicht werden. Zum Beispiel ROW\$1NUMBER, RANK, LAG und LEAD |
| Konvertierungs-Funktionen | `SELECT CAST('123' AS INT) as converted_number, CAST(123 AS STRING) as converted_string FROM `LogGroupA`` | Integrierte Funktionen zum Konvertieren von Daten von einem Typ in einen anderen innerhalb von SQL-Abfragen, wodurch Datentyptransformationen und Formatkonvertierungen ermöglicht werden. Zum Beispiel CAST, TO\$1DATE, TO\$1TIMESTAMP und BINARY. |
| Prädikatsfunktionen | `SELECT scores, size(scores) as length, array_contains(scores, 90) as has_90 FROM `LogGroupA`;` | Integrierte Funktionen, die Bedingungen auswerten und boolesche Werte (true/false) auf der Grundlage bestimmter Kriterien oder Muster zurückgeben. Zum Beispiel IN, LIKE, BETWEEN, IS NULL und EXISTS. |
| Wählen Sie mehrere Protokollgruppen aus | `SELECT lg1.field1, lg1.field2 from `logGroups( logGroupIdentifier: ['LogGroup1', 'LogGroup2'])` as lg1 where lg1.field3= "Success"` | Ermöglicht die Angabe mehrerer Protokollgruppen in einer SELECT-Anweisung |
| Wählen Sie mehrere Datenquellen aus | `SELECT ds1.field1, ds1.field2 from `dataSource(['DataSource1', 'DataSource2'])` as ds1 where ds1.field3= "Success"` | Ermöglicht die Angabe mehrerer Datenquellen in einer SELECT-Anweisung |
## Unterstütztes SQL für multi-log-group Abfragen
Um den Anwendungsfall für die Abfrage mehrerer Protokollgruppen in SQL zu unterstützen, können Sie den `logGroups` Befehl verwenden. Mit dieser Syntax können Sie mehrere Protokollgruppen abfragen, indem Sie sie im Befehl FROM angeben.
Syntax:
```
`logGroups(
logGroupIdentifier: ['LogGroup1','LogGroup2', ...'LogGroupn']
)
```
In dieser Syntax können Sie bis zu 50 Protokollgruppen im `logGroupIdentifier` Parameter angeben. Wenn Sie in einem Monitoring-Konto auf Protokollgruppen verweisen möchten, verwenden Sie ARNs anstelle von `LogGroup` Namen.
Beispielabfrage:
```
SELECT LG1.Column1, LG1.Column2 from `logGroups(
logGroupIdentifier: ['LogGroup1', 'LogGroup2']
)` as LG1 WHERE LG1.Column1 = 'ABC'
```
Die folgende Syntax mit mehreren Protokollgruppen nach der `FROM` Anweisung wird bei der Abfrage von CloudWatch Logs NICHT unterstützt.
```
SELECT Column1, Column2 FROM 'LogGroup1', 'LogGroup2', ...'LogGroupn'
WHERE Column1 = 'ABC'
```
## Unterstütztes SQL für Datenquellenabfragen
Um den Anwendungsfall für die Abfrage von Datenquellen in SQL zu unterstützen, können Sie den DataSource-Befehl verwenden. Mit dieser Syntax können Sie Datenquellen abfragen, indem Sie sie im Befehl angeben. `FROM` Sie können bis zu 10 Datenquellen angeben.
**Syntax**
```
`dataSource(
['DataSource1', 'DataSource2', ...'DataSourcen']
)`
```
**Beispielabfrage**
```
SELECT DS1.Column1, DS1.Column2 from `dataSource(
['DataSource1', 'DataSource2']
)` as DS1 WHERE DS1.Column1 = 'ABC'
```
## Umfang der Abfrage
In der AWS CLI AND-API können Sie mithilfe der Protokollgruppe, der Datenquelle und des Typs sowie der Feldindizes angeben, welche Protokolle abgefragt werden sollen.
### Protokollgruppe
Die Quellenauswahl für die Protokollgruppe kann verwendet werden, wenn Kunden wissen, welche Protokollgruppe (n) genau durchsucht werden müssen
```
SELECT * FROM `logGroups(logGroupIdentifier: ['/aws/lambda/my-function'])`;
```
### Datenquelle und Typ
Kunden können ihre Protokolle anhand des Datenquellennamens und des Datenquellentyps abfragen.
Die auf Datenquellen und Typen basierende Quellenauswahl kann verwendet werden, wenn Kunden wissen, welche Datenquellen genau abgefragt werden müssen. Diese Abfrage wird über eine oder mehrere Protokollgruppen ausgeführt, die die angegebene Datenquelle und den angegebenen Datentyp enthalten.
Um den Anwendungsfall für die Abfrage von Datenquellen in SQL zu unterstützen, können Sie den DataSource-Befehl verwenden. Mit dieser Syntax können Sie Datenquellen abfragen, indem Sie sie im FROM-Befehl angeben. Sie können bis zu 10 Datenquellen angeben.
Syntax:
```
`dataSource(
['DataSource1.Type1', 'DataSource2.Type2', ...'DataSourcen.Typen']
)`
```
Beispielabfrage:
```
SELECT DS1.Column1, DS1.Column2 from `dataSource(
['DataSource1.Type1', 'DataSource2.Type2']
)` as DS1 WHERE DS1.Column1 = 'ABC'
```
Weitere Informationen zur Abfrage nach Datenquellen finden Sie unter[Verwenden Sie Facetten, um Logs zu gruppieren und zu untersuchen](CloudWatchLogs-Facets.md).
### Kombiniertes Beispiel
Kunden können alle Operatoren zur Quellenauswahl innerhalb der Backticks in beliebiger Reihenfolge angeben. Die Ergebnisse würden dann auf dem Schnittpunkt aller angewandten Bedingungen basieren.
Beispielsweise könnte/aws/lambda/my-function-1 mehrere Datenquellen und -typen enthalten, einschließlich einer Vielzahl von Indizes. Wenn die folgende Abfrage ausgeführt wurde, enthielten die zurückgegebenen Ergebnisse nur Ereignisse der Quelle und des Typs DataSource 1.Type1, die den Kriterien 'status' = 200 entsprechen.
```
SELECT * FROM `
logGroups(logGroupIdentifier: ['/aws/lambda/my-function'])
filterIndex('status' = 200)
dataSource(['DataSource1.Type1'])
`;
```
### Feldindizes
Die auf dem Feldindex basierende Quellenauswahl identifiziert automatisch relevante Protokollgruppen, wenn Ihre Filter auf indizierte Felder abzielen, wodurch das Scanvolumen und die Abfragelaufzeit reduziert werden.
Wird verwendet, `filterIndex` um nur indizierte Daten zurückzugeben, indem eine Abfrage erzwungen wird, nur Protokollgruppen zu scannen, die in einem Feld indexiert sind, das Sie in der Abfrage angeben. Für diese Protokollgruppen, die in diesem Feld indexiert sind, wird die Abfrage weiter optimiert, indem die Protokollgruppen übersprungen werden, die keine Protokollereignisse enthalten, die das in der Abfrage für das indizierte Feld angegebene Feld enthalten. Das gescannte Volumen wird weiter reduziert, indem versucht wird, nur Protokollereignisse aus diesen Protokollgruppen zu scannen, die dem in der Abfrage für diesen Feldindex angegebenen Wert entsprechen. Weitere Informationen zu Feldindizes und deren Erstellung finden Sie unter [Feldindizes erstellen, um die Abfrageleistung zu verbessern und das Scanvolumen zu reduzieren](CloudWatchLogs-Field-Indexing.md).
In SQL wird FilterIndex verwendet, um anzugeben, welche Schlüssel-Wert-Paare als Indizes behandelt werden sollen. Die Syntax lautet wie folgt
```
SELECT * FROM `filterIndex('region' = 'us-east-1')`;
```
wobei
1. FilterIndex (...) gibt an, dass die darin enthaltenen Schlüsselwerte als Feldindizes behandelt werden. Jedes Schlüsselwertpaar ist durch ein Komma getrennt (Beispiel unten)
1. 'region' = 'us-east-1' gibt die tatsächliche Bedingung an, die angewendet werden soll
1. Hinweis: Anstelle von = können Kunden IN verwenden, um mehrere Werte anzugeben (Beispiel unten)
Die Verwendung mehrerer FilterIndex-Werte würde die Bedingungen mit „UND“ kombinieren. In diesem Beispiel würden Logs abgefragt, die mit status=200 und der Region in us-east-1 oder us-west-2 übereinstimmen.
```
SELECT * FROM `filterIndex('status' = 200, 'region' IN ['us-east-1', 'us-west-2'])`;
```
## Einschränkungen
Die folgenden Einschränkungen gelten, wenn Sie SQL für Abfragen in Logs Insights verwenden. OpenSearch CloudWatch
+ Sie können nur einen JOIN in eine SELECT-Anweisung aufnehmen.
+ Sie können JOIN oder Unterabfragen nicht mit Datenquellenabfragen verwenden.
+ Es wird nur eine Ebene verschachtelter Unterabfragen unterstützt.
+ Abfragen mit mehreren Anweisungen, die durch Semikolons (;) getrennt sind, werden nicht unterstützt.
+ Abfragen mit Feldnamen, die identisch sind, sich aber nur in der Groß- und Kleinschreibung unterscheiden (wie Feld1 und FIELD1), werden nicht unterstützt.
Die folgende Abfrage wird beispielsweise nicht unterstützt:
```
Select AWSAccountId, AwsAccountId from LogGroup
```
Die folgende Abfrage wird jedoch unterstützt, da der Feldname (`@logStream`) in beiden Protokollgruppen identisch ist:
```
Select a.`@logStream`, b.`@logStream` from Table A INNER Join Table B on a.id = b.id
```
+ Funktionen und Ausdrücke müssen mit Feldnamen arbeiten und Teil einer SELECT-Anweisung mit einer in der FROM-Klausel angegebenen Protokollgruppe sein.
Diese Abfrage wird beispielsweise nicht unterstützt:
```
SELECT cos(10) FROM LogGroup
```
Diese Abfrage wird unterstützt:
```
SELECT cos(field1) FROM LogGroup
```
+ Wenn Sie SQL- oder PPL-Befehle verwenden, schließen Sie bestimmte Felder in Backticks ein, um sie erfolgreich abzufragen. Backticks sind für Felder mit Sonderzeichen (nicht alphabetisch und nicht numerisch) erforderlich. Schließen Sie beispielsweise, und in Backticks `@message` ein`Operation.Export`. `Test::Field` Sie müssen Felder mit rein alphabetischen Namen nicht in Backticks einschließen.
Beispielabfrage mit einfachen Feldern:
```
SELECT SessionToken, Operation, StartTime FROM `LogGroup-A`
LIMIT 1000;
```
Ähnliche Abfrage mit angehängten Backticks:
```
SELECT `@SessionToken`, `@Operation`, `@StartTime` FROM `LogGroup-A` LIMIT 1000;
```
# Verwenden Sie natürliche Sprache, um CloudWatch Logs Insights-Abfragen zu generieren und zu aktualisieren
CloudWatch Logs unterstützt eine Abfragefunktion in natürlicher Sprache, mit der Sie Abfragen für [CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html), [OpenSearch Service PPL, OpenSearch Service](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_PPL.html) [SQL](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_SQL.html) und generieren und [CloudWatch Metrics Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/query_with_cloudwatch-metrics-insights.html)aktualisieren können.
Mit dieser Funktion können Sie Fragen zu den CloudWatch Logs-Daten, nach denen Sie suchen, stellen oder diese 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 „Was sind die 100 wichtigsten Quell-IP-Adressen nach übertragenen Byte?“ eingeben. und „Finde die 10 langsamsten Lambda-Funktionsanfragen.“
**Anmerkung**
Bei der Funktion für Abfragen in natürlicher Sprache handelt es sich um einen regionalen Dienst. In einigen Regionen führt die Funktion regionsübergreifende Aufrufe an Regionen in den USA aus, um die Abfrage-Prompts zu verarbeiten. Weitere Informationen finden Sie unter [Amazon CloudWatch erweitert die regionale Unterstützung für die Zusammenfassung und Generierung von Abfragen in natürlicher Sprache](https://aws.amazon.com/about-aws/whats-new/2025/08/amazon-cloudwatch-region-support-query-result-summarization-query-generation/).
Um eine CloudWatch Logs Insights-Abfrage mit dieser Funktion zu generieren, öffnen Sie den CloudWatch Logs Insights-Abfrage-Editor, wählen Sie die Protokollgruppe aus, die Sie abfragen möchten, und wählen Sie **Abfrage generieren**.
**Wichtig**
Um die Abfragefunktion in natürlicher Sprache verwenden zu können, müssen Sie mit den [CloudWatchLogsFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchLogsFullAccess.html), [CloudWatchLogsReadOnlyAccess[AdministratorAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AdministratorAccess.html)](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchLogsReadOnlyAccess.html), oder [ReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/ReadOnlyAccess.html)IAM-Richtlinien angemeldet sein oder über die `cloudwatch:GenerateQuery` entsprechende Berechtigung verfügen.
## Beispielabfragen
In den Beispielen in diesem Abschnitt wird beschrieben, wie Abfragen mithilfe der natürlichen Sprachfunktion generiert und aktualisiert werden.
**Anmerkung**
Weitere Informationen zum CloudWatch Logs Insights-Abfrage-Editor und zur Syntax finden Sie unter [CloudWatch Logs Insights-Abfragesyntax](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html).
### Beispiele: Generieren Sie eine Abfrage in natürlicher Sprache
Um eine Abfrage in natürlicher Sprache zu generieren, geben Sie eine Aufforderung ein und wählen Sie **Neue Abfrage generieren**. Dieses Beispiel zeigt Abfragen, die eine einfache Suche durchführen.
**Prompt**
Im Folgenden finden Sie ein Beispiel für eine Eingabeaufforderung, die die Fähigkeit anweist, nach den 10 langsamsten Lambda-Funktionsaufrufen zu suchen.
```
Find the 10 slowest requests
```
**Query**
Die folgende Abfrage verwendet die CloudWatch Logs Insights-Abfragesprache, die von der Funktion in natürlicher Sprache auf der Grundlage der Aufforderung generiert wurde. 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.
```
# Find the 10 slowest requests
fields @timestamp, @message, @duration
| sort @duration desc
| limit 10
# This query retrieves the timestamp, message and duration fields from the logs and sorts them in descending order by duration to find the 10 slowest requests.
```
**Anmerkung**
Verwenden Sie das Zahnradsymbol in Ihrem Editor, um das Erscheinungsbild Ihrer Aufforderung und die Erläuterung der Funktionsweise der Abfrage zu deaktivieren.
**Prompt**
Um eine OpenSearch SQL-Abfrage zu generieren, wählen Sie die Registerkarte OpenSearch SQL aus und öffnen Sie dann das Eingabeaufforderungsfeld für den Abfragegenerator, um Ihre Eingabeaufforderung in natürlicher Sprache einzugeben. Im Folgenden finden Sie ein Beispiel für eine Eingabeaufforderung, bei der die Funktion natürlicher Sprache verwendet wird, um eine OpenSearch SQL-Abfrage zu generieren.
```
Give me the number of errors and exceptions per hour
```
**Query**
Im Folgenden finden Sie die von dieser Aufforderung generierte SQL-Abfrage, mit der Sie die Anzahl der pro Stunde aggregierten Fehler und Ausnahmen ermitteln können:
```
SELECT DATE_FORMAT(`@timestamp`, 'yyyy-MM-dd HH') AS hour,
COUNT(*) AS error_count
FROM `/aws/lambda/CloudWatchOdysseyQueryGen`
WHERE `@message` LIKE '%error%'
OR `@message` LIKE '%exception%'
GROUP BY DATE_FORMAT(`@timestamp`, 'yyyy-MM-dd HH')
ORDER BY hour
```
**Prompt**
Um eine OpenSearch PPL-Abfrage zu generieren, wählen Sie die Registerkarte PPL aus und öffnen Sie dann das OpenSearch Eingabeaufforderungsfeld für den Abfragegenerator, um Ihre Eingabeaufforderung in natürlicher Sprache einzugeben. Im Folgenden finden Sie ein Beispiel für eine Aufforderung, bei der die Funktion natürlicher Sprache verwendet wird, um eine OpenSearch PPL-Abfrage zu generieren.
```
Give me all unique exception messages
```
**Query**
Im Folgenden finden Sie die PPL-Abfrage, die durch diese Aufforderung generiert wurde und die Sie verwenden können, um die eindeutigen Ausnahmemeldungen in Ihren Protokollen zu finden:
```
dedup @message
| fields @message
```
### 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 Aufforderung, die nach den 10 langsamsten Lambda-Funktionsaufrufen sucht, leitet diese Aufforderung nun die Fähigkeit an, nach den 20 langsamsten Lambda-Funktionsaufrufen zu suchen und eine weitere Spalte für zusätzliche Protokollereignisse einzufügen.
```
Show top 20 slowest requests instead and display requestId as a column
```
**Aktualisierte Abfrage**
Im Folgenden finden Sie ein Beispiel für die aktualisierte Abfrage, die die Logs Insights-Abfragesprache verwendet. CloudWatch 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.
```
# Show top 20 slowest requests instead and display requestId as a column
fields @timestamp, @message, @requestId, @duration
| sort @duration desc
| limit 20
# This query modifies the original query by replacing the @message field with the @requestId field and changing the limit from 10 to 20 to return the top 20 log events by duration instead of the top 10.
```
## 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önnten verwendet werden, um die Qualität von CloudWatch Logs 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 Logs AI-Funktionen, einschließlich der Funktion zur Abfragegenerierung, abzulehnen, müssen Sie eine Opt-Out-Richtlinie für CloudWatch Logs erstellen. 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 *.
# Unterstützte Protokolle und erkannte Felder
CloudWatch Logs Insights unterstützt verschiedene Protokolltypen. Für jedes Protokoll, das an eine Protokollgruppe der Standardklasse in Amazon CloudWatch Logs gesendet wird, generiert CloudWatch Logs Insights automatisch fünf Systemfelder:
+ `@message` enthält das rohe, unverarbeitete Protokollereignis. Dies entspricht dem `message` Feld in [InputLogevent](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_InputLogEvent.html).
+ `@timestamp` enthält den Ereignis-Zeitstempel im `timestamp`-Feld des Protokollereignisses. Dies entspricht dem `timestamp` Feld in [InputLogevent](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_InputLogEvent.html).
+ `@ingestionTime`enthält die Uhrzeit, zu der CloudWatch Logs das Protokollereignis empfangen hat.
+ `@logStream` enthält den Namen des Protokoll-Streams, zu dem das Protokollereignis hinzugefügt wurde. Protokolldatenstromgruppen werden nach demselben Prozess protokolliert, der sie generiert hat.
+ `@log` ist ein Protokollgruppen-Bezeichner im folgenden Format: `account-id:log-group-name` Beim Abfragen mehrerer Protokollgruppen kann dies nützlich sein, um zu bestimmen, zu welcher Protokollgruppe ein bestimmtes Ereignis gehört.
+ `@entity`enthält abgeflachte JSON-Daten, die sich auf Entitäten beziehen, für die [Telemetriefunktion im Zusammenhang mit Explore](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ExploreRelated.html).
Diese JSON-Datei kann beispielsweise eine Entität darstellen.
```
{
"Entity": {
"KeyAttributes": {
"Type": "Service",
"Name": "PetClinic"
},
"Attributes": {
"PlatformType": "AWS::EC2",
"EC2.InstanceId": "i-1234567890123"
}
}
}
```
Für diese Entität wären die extrahierten Systemfelder die folgenden:
```
@entity.KeyAttributes.Type = Service
@entity.KeyAttributes.Name = PetClinic
@entity.Attributes.PlatformType = AWS::EC2
@entity.Attributes.EC2.InstanceId = i-1234567890123
```
**Anmerkung**
Die Felderkennung wird nur für Protokollgruppen in der Standard-Protokollklasse unterstützt. Weitere Hinweise zu Protokollklassen finden Sie unter[Klassen protokollieren](CloudWatch_Logs_Log_Classes.md).
CloudWatch Logs Insights fügt das **@-Symbol** am Anfang der generierten Felder ein.
Bei vielen Protokolltypen erkennt CloudWatch Logs auch automatisch die in den Protokollen enthaltenen Protokollfelder. Diese automatischen Suchfelder sind in der folgenden Tabelle dargestellt.
Bei anderen Protokolltypen mit Feldern, die CloudWatch Logs Insights nicht automatisch erkennt, können Sie den `parse` Befehl verwenden, um extrahierte Felder für die Verwendung in dieser Abfrage zu extrahieren und zu erstellen. Weitere Informationen finden Sie unter [CloudWatch Abfragesyntax in Logs Insights](CWL_QuerySyntax.md).
Wenn der Name eines erkannten Protokollfeldes mit dem `@` Zeichen beginnt, zeigt CloudWatch Logs Insights es mit einem zusätzlichen Zeichen an, das am Anfang `@` angehängt wird. Wenn z. B. ein Protokollfeldname `@example.com`lautet, wird dieser Feldname als `@@example.com` angezeigt.
**Anmerkung**
Mit Ausnahme von `@message` `@timestamp``@log`, oder können Sie Feldindizes für entdeckte Felder erstellen. Weitere Hinweise zu Feldindizes finden Sie unter. [Erstellen Sie Feldindizes, um die Abfrageleistung zu verbessern und das Scanvolumen zu reduzieren](CloudWatchLogs-Field-Indexing.md)
| Protokolltyp | Erkannte Protokollfelder |
| --- | --- |
| Amazon VPC-Flussprotokolle | `@timestamp`, `@logStream`, `@message`, `accountId`, `endTime`, `interfaceId`, `logStatus`, `startTime`, `version`, `action`, `bytes`, `dstAddr`, `dstPort`, `packets`, `protocol`, `srcAddr`, `srcPort` |
| Route-53-Protokolle | `@timestamp`, `@logStream`, `@message`, `edgeLocation`, `ednsClientSubnet`, `hostZoneId`, `protocol`, `queryName`, `queryTimestamp`, `queryType`, `resolverIp`, `responseCode`, `version` |
| Lambda-Protokolle | `@timestamp`, `@logStream`, `@message`, `@requestId`, `@duration, ``@billedDuration`, `@type`, `@maxMemoryUsed`, `@memorySize` Wenn eine Lambda-Protokollzeile eine X–Ray-Trace-ID enthält, enthält sie auch die folgenden Felder: `@xrayTraceId` und `@xraySegmentId`. CloudWatch Logs Insights erkennt automatisch Protokollfelder in Lambda-Protokollen, jedoch nur für das erste eingebettete JSON-Fragment in jedem Protokollereignis. Wenn ein Lambda-Protokollereignis mehrere JSON-Fragmente enthält, können Sie die Protokollfelder mit dem `parse`-Befehl analysieren und extrahieren. Weitere Informationen finden Sie unter [Felder in JSON-Protokollen](#CWL_AnalyzeLogData-discoverable-JSON-logs). |
| CloudTrail Logs Protokolle im JSON-Format | Weitere Informationen finden Sie unter [Felder in JSON-Protokollen](#CWL_AnalyzeLogData-discoverable-JSON-logs). |
| Andere Protokolltypen | `@timestamp`, `@ingestionTime`, `@logStream`, `@message`, `@log`. |
## Felder in JSON-Protokollen
Mit CloudWatch Logs Insights verwenden Sie die Punktnotation zur Darstellung von JSON-Feldern. Dieser Abschnitt enthält ein Beispiel für ein JSON-Ereignis und ein Code-Snippet, die Ihnen zeigen, wie Sie mit der Punktnotation auf JSON-Felder zugreifen können.
**Example: JSON event** (Beispiel: JSON-Ereignis)
```
{
"eventVersion": "1.0",
"userIdentity": {
"type": "IAMUser",
"principalId": "EX_PRINCIPAL_ID",
"arn": "arn: aws: iam: : 123456789012: user/Alice",
"accessKeyId": "EXAMPLE_KEY_ID",
"accountId": "123456789012",
"userName": "Alice"
},
"eventTime": "2014-03-06T21: 22: 54Z",
"eventSource": "ec2.amazonaws.com",
"eventName": "StartInstances",
"awsRegion": "us-east-2",
"sourceIPAddress": "192.0.2.255",
"userAgent": "ec2-api-tools1.6.12.2",
"requestParameters": {
"instancesSet": {
"items": [
{
"instanceId": "i-abcde123"
}
]
}
},
"responseElements": {
"instancesSet": {
"items": [
{
"instanceId": "i-abcde123",
"currentState": {
"code": 0,
"name": "pending"
},
"previousState": {
"code": 80,
"name": "stopped"
}
}
]
}
}
}
```
Das JSON-Beispielereignis enthält ein Objekt namens `userIdentity`. `userIdentity` enthält ein Feld namens `type`. Um den Wert von `type` mit Punktnotation darzustellen, verwenden Sie `userIdentity.type`.
Das JSON-Beispielereignis enthält Arrays, die sich zu Listen mit verschachtelten Feldnamen und Werten vereinfachen lassen. Verwenden Sie `requestParameters.instancesSet.items.0.instanceId`, um den Wert von `instanceId` für das erste Element in `requestParameters.instancesSet` darzustellen. Die Zahl `0`, die vor dem Feld `instanceID` platziert ist, bezieht sich auf die Position von Werten für das Feld `items`. Das folgende Beispiel enthält ein Code-Snippet, das zeigt, wie Sie in einem JSON-Protokollereignis auf verschachtelte JSON-Felder zugreifen können.
**Beispiel: Abfrage**
```
fields @timestamp, @message
| filter requestParameters.instancesSet.items.0.instanceId="i-abcde123"
| sort @timestamp desc
```
Der Code-Ausschnitt zeigt eine Abfrage, die Punktnotation mit dem Befehl `filter` verwendet, um auf den Wert des verschachtelten JSON-Felds `instanceId` zuzugreifen. Die Abfrage filtert nach Nachrichten, bei denen der Wert von `instanceId` `"i-abcde123"` entspricht, und gibt alle Protokollereignisse zurück, die den angegebenen Wert enthalten.
**Anmerkung**
CloudWatch Logs Insights kann maximal 200 Protokollereignisfelder aus einem JSON-Protokoll extrahieren. Zusätzliche Felder, die nicht extrahiert werden, können Sie mit dem Befehl `parse` aus dem nicht analysierten Protokollereignis im Nachrichtenfeld extrahieren. Weitere Informationen zu dem `parse` Befehl finden Sie unter [Abfragesyntax](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html) im CloudWatch Amazon-Benutzerhandbuch.
# Erstellen Sie Feldindizes, um die Abfrageleistung zu verbessern und das Scanvolumen zu reduzieren
Sie können *Feldindizes* der Felder in Ihren Protokollereignissen erstellen, um effiziente, gleichheitsorientierte Suchen zu ermöglichen. Wenn Sie dann einen Feldindex in einer CloudWatch Logs Insights-Abfrage verwenden, versucht die Abfrage, die Verarbeitung von Protokollereignissen zu überspringen, von denen bekannt ist, dass sie das indizierte Feld nicht enthalten. Dadurch wird das Scanvolumen Ihrer Abfragen, die Feldindizes verwenden, reduziert, sodass Ergebnisse schneller zurückgegeben werden können. Auf diese Weise können Sie schnell Petabyte an Gesamtprotokollen in Tausenden von Protokollgruppen durchsuchen und die relevanten Protokolle schneller finden. Felder, die sich gut indexieren lassen, sind Felder, nach denen Sie häufig Abfragen durchführen müssen. Felder mit einer hohen Kardinalität von Werten eignen sich auch gut für Feldindizes, da eine Abfrage, die diese Feldindizes verwendet, schneller abgeschlossen wird, da dadurch die Protokollereignisse begrenzt werden, die dem Zielwert zugeordnet werden.
Nehmen wir beispielsweise an, Sie haben einen Feldindex für erstellt. `requestId` Dann jede CloudWatch Logs Insights-Abfrage für diese Protokollgruppe, die nur die Protokollereignisse enthält `requestId = value` oder `requestId IN [value, value, ...]` versucht, nur die Protokollereignisse zu verarbeiten, von denen bekannt ist, dass sie das indizierte Feld und den abgefragten Wert enthalten und für die CloudWatch Logs in der Vergangenheit einen Wert für dieses Feld erkannt hat.
Sie können Ihre Feldindizes auch nutzen, um effiziente Abfragen für eine größere Anzahl von Protokollgruppen zu erstellen. Wenn Sie den `filterIndex` Befehl in Ihrer Abfrage anstelle des `filter` Befehls verwenden, wird die Abfrage anhand ausgewählter Protokollgruppen für Protokollereignisse ausgeführt, die Feldindizes haben. Diese Abfragen können bis zu 10.000 Protokollgruppen scannen, die Sie auswählen können, indem Sie bis zu fünf Protokollgruppennamenpräfixe angeben. Wenn es sich um ein Überwachungskonto mit CloudWatch kontenübergreifender Observability handelt, können Sie alle Quellkonten auswählen oder einzelne Quellkonten angeben, um die Protokollgruppen auszuwählen.“
Bei indizierten Feldern wird zwischen Groß- und Kleinschreibung unterschieden. Ein Feldindex von entspricht beispielsweise `RequestId` nicht einem Protokollereignis, das Folgendes enthält: `requestId`
Feldindizes werden nur für die strukturierten Protokollformate JSON und Serviceprotokolle unterstützt.
CloudWatch Logs stellt Standardfeldindizes für alle Protokollgruppen in der Standard-Protokollklasse bereit. Standardfeldindizes sind automatisch für die folgenden Felder verfügbar:
+ `@logStream`
+ `@aws.region`
+ `@aws.account`
+ `@source.log`
+ `@data_source_name`
+ `@data_source_type`
+ `@data_format`
+ `traceId`
+ `severityText`
+ `attributes.session.id`
CloudWatch Logs bietet auch Standardfeldindizes für bestimmte Kombinationen von Datenquellennamen und -typen. Standardfeldindizes sind automatisch für die folgenden Kombinationen von Datenquellennamen und -typ verfügbar:
| Name und Typ der Datenquelle | Standard-Feldindizes |
| --- | --- |
| `amazon_vpc.flow` | `action` `logStatus` `region` `flowDirection` `type` |
| `amazon_route53.resolver_query` | `query_type` `transport` `rcode` |
| `aws_waf.access` | `action` `httpRequest.country` |
| `aws_cloudtrail.data` ` aws_cloudtrail.management` | `eventSource` `eventName` `awsRegion` `userAgent` `errorCode` `eventType` `managementEvent` `readOnly` `eventCategory` `requestId` |
Standardfeldindizes gelten zusätzlich zu allen benutzerdefinierten Feldindizes, die Sie in Ihrer Richtlinie definieren. Standardfeldindizes werden nicht auf Ihr [Feldindexkontingent](CloudWatchLogs-Field-Indexing-Syntax.md) angerechnet.
CloudWatch Protokolliert nur die Protokollereignisse, die nach der Erstellung einer Indexrichtlinie aufgenommen wurden. Protokollereignisse, die vor der Erstellung der Richtlinie aufgenommen wurden, werden nicht indexiert. Nachdem Sie einen Feldindex erstellt haben, bleibt jedes übereinstimmende Protokollereignis ab dem Zeitpunkt der Aufnahme des Protokollereignisses 30 Tage lang indexiert.
**Anmerkung**
Wenn Sie eine Feldindexrichtlinie in einem Überwachungskonto erstellen, wird diese Richtlinie nicht für Protokollgruppen in verknüpften Quellkonten verwendet. Eine Feldindexrichtlinie gilt nur für das Konto, in dem sie erstellt wurde.
In den übrigen Themen dieses Abschnitts wird erklärt, wie Feldindizes erstellt werden. Informationen dazu, wie Sie in Ihren Abfragen auf Feldindizes verweisen, finden Sie unter [filterIndex](CWL_QuerySyntax-FilterIndex.md) und. [Filter](CWL_QuerySyntax-Filter.md)
**Topics**
+ [Syntax und Kontingente für Feldindexe](CloudWatchLogs-Field-Indexing-Syntax.md)
+ [Erstellen Sie eine Feldindexrichtlinie auf Kontoebene](CloudWatchLogs-Field-Indexing-CreateAccountLevel.md)
+ [Erstellen Sie eine Feldindexrichtlinie auf Protokollgruppenebene](CloudWatchLogs-Field-Indexing-CreateLogGroupLevel.md)
+ [Protokollieren Sie die Gruppenauswahloptionen beim Erstellen einer Abfrage](Field-Indexing-Selection.md)
+ [Auswirkungen des Löschens einer Feldindexrichtlinie](CloudWatchLogs-Field-Indexing-Deletion.md)
# Syntax und Kontingente für Feldindexe
Sie erstellen Feldindizes, indem Sie *Feldindexrichtlinien* erstellen. Sie können Indexrichtlinien auf Kontoebene erstellen, die für Ihr gesamtes Konto gelten, und Sie können auch Richtlinien erstellen, die nur für eine einzelne Protokollgruppe gelten. Für kontoweite Indexrichtlinien können Sie eine festlegen, die für alle Protokollgruppen im Konto gilt. Sie können auch Indexrichtlinien auf Kontoebene erstellen, die für eine Teilmenge von Protokollgruppen im Konto gelten, die anhand der Präfixe ihrer Protokollgruppennamen ausgewählt werden. Wenn Sie mehrere Richtlinien auf Kontoebene in demselben Konto haben, dürfen sich die Präfixe der Protokollgruppennamen für diese Richtlinien nicht überschneiden. Ebenso können Sie Indexrichtlinien auf Kontoebene erstellen, die für eine bestimmte Kombination aus Name und Typ der Datenquelle gelten. Pro Kombination aus Datenquellenname und Typ kann nur eine Kontorichtlinie erstellt werden.
Feldindexrichtlinien auf Protokollgruppenebene haben Vorrang vor Feldindexrichtlinien auf Kontoebene, die für die gesamte Protokollgruppe gelten (z. B. Richtlinien auf Kontoebene ohne Auswahlkriterien oder mit Auswahlkriterien, die auf dem Präfix von Protokollgruppennamen basieren). Richtlinien auf Kontoebene, die auf der Ebene der Protokollereignisse übereinstimmen (z. B. für eine Kombination aus Name und Typ einer bestimmten Datenquelle), gelten zusätzlich zu Richtlinien, die der gesamten Protokollgruppe entsprechen. Wenn Sie eine Indexrichtlinie auf Protokollgruppenebene erstellen, verwendet diese Protokollgruppe keine Richtlinien auf Kontoebene, die auf Protokollgruppenebene übereinstimmen.
Bei Übereinstimmungen von Protokollereignissen mit den Namen von Feldindizes wird zwischen Groß- und Kleinschreibung unterschieden. Beispielsweise entspricht ein Feldindex von `RequestId` nicht einem Protokollereignis, das Folgendes enthält: `requestId`
Sie können über bis zu 40 Indexrichtlinien auf Kontoebene verfügen, von denen 20 Auswahlkriterien für das Präfix für Protokollgruppennamen und 20 auf Datenquellen basierende Auswahlkriterien verwenden können. Wenn Sie mehrere Indexrichtlinien auf Kontoebene nach Präfixen für Protokollgruppennamen gefiltert haben, können keine zwei von ihnen dieselben oder sich überschneidende Präfixe für Protokollgruppennamen verwenden. Wenn Sie beispielsweise eine Richtlinie so gefiltert haben, dass Gruppen protokolliert werden, die mit beginnen`my-log`, können Sie keine andere Feldindexrichtlinie nach oder filtern lassen. `my-logpprod` `my-logging` Wenn Sie mehrere Indexrichtlinien auf Kontoebene haben, die nach Kombinationen von Datenquellenname und -typ gefiltert sind, kann keine zwei von ihnen denselben Datenquellennamen und -typ verwenden. Wenn Sie beispielsweise eine Richtlinie nach dem Datenquellennamen `amazon_vpc` und dem Datenquellentyp gefiltert haben, können `flow` Sie mit dieser Kombination keine weitere Richtlinie erstellen.
Wenn Sie über eine Indexrichtlinie auf Kontoebene verfügen, die keine Namenspräfixe hat und für alle Protokollgruppen gilt, kann keine andere Indexrichtlinie auf Kontoebene mit Präfixfiltern für Protokollgruppennamen erstellt werden. Sie können Indexrichtlinien auf Kontoebene erstellen, die Filter für den Namen und den Typ von Datenquellen verwenden.
Jede Indexrichtlinie hat die folgenden Kontingente und Einschränkungen:
+ Bis zu 20 Felder können in die Richtlinie aufgenommen werden.
+ Jeder Feldname kann bis zu 100 Zeichen enthalten.
+ Um einen Index für ein benutzerdefiniertes Feld in Ihren Protokollgruppen zu erstellen`@`, das mit beginnt, müssen Sie das Feld mit einem zusätzlichen `@` Wert am Anfang des Feldnamens angeben. Wenn Ihre Protokollereignisse beispielsweise ein Feld mit dem Namen enthalten`@userId`, müssen Sie angeben, `@@userId` dass ein Index für dieses Feld erstellt werden soll.
Für Indexrichtlinien auf Kontoebene mit Datenquellennamen und typbasierten Auswahlkriterien gilt eine zusätzliche Einschränkung: Alle Felder müssen primitive Datentypen sein, verschachtelte Primitive werden nur für Strukturen unterstützt.
**Generierte Felder und reservierte Felder**
CloudWatch Logs Insights generiert bei jedem Protokollereignis automatisch Systemfelder. Diesen generierten Feldern wird das Präfix vorangestellt. `@` Weitere Informationen zu generierten Feldern finden Sie unter[Unterstützte Protokolle und erkannte Felder](CWL_AnalyzeLogData-discoverable-fields.md).
Von diesen generierten Feldern werden die folgenden für die Verwendung als Feldindizes unterstützt:
+ `@logStream`
+ `@ingestionTime`
+ `@requestId`
+ `@type`
+ `@initDuration`
+ `@duration`
+ `@billedDuration`
+ `@memorySize`
+ `@maxMemoryUsed`
+ `@xrayTraceId`
+ `@xraySegmentId`
Um diese generierten Felder zu indizieren, müssen Sie `@` bei der Angabe keine zusätzlichen Felder hinzufügen, wie dies bei benutzerdefinierten Feldern der Fall ist, die mit `@` beginnen. Um beispielsweise einen Feldindex für zu erstellen`@logStream`, geben Sie einfach `@logStream` als Feldindex an.
CloudWatch Logs stellt Standardfeldindizes für alle Protokollgruppen in der Standard-Protokollklasse bereit. Standardfeldindizes sind automatisch für die folgenden Felder verfügbar:
+ `@logStream`
+ `@aws.region`
+ `@aws.account`
+ `@source.log`
+ `@data_source_name`
+ `@data_source_type`
+ `@data_format`
+ `traceId`
+ `severityText`
+ `attributes.session.id`
CloudWatch Logs bietet auch Standardfeldindizes für bestimmte Kombinationen von Datenquellennamen und -typen. Standardfeldindizes sind automatisch für die folgenden Kombinationen von Datenquellennamen und -typ verfügbar:
| Name und Typ der Datenquelle | Standard-Feldindizes |
| --- | --- |
| `amazon_vpc.flow` | `action` `logStatus` `region` `flowDirection` `type` |
| `amazon_route53.resolver_query` | `query_type` `transport` `rcode` |
| `aws_waf.access` | `action` `httpRequest.country` |
| `aws_cloudtrail.data` ` aws_cloudtrail.management` | `eventSource` `eventName` `awsRegion` `userAgent` `errorCode` `eventType` `managementEvent` `readOnly` `eventCategory` `requestId` |
Standardfeldindizes gelten zusätzlich zu allen benutzerdefinierten Feldindizes, die Sie in Ihrer Richtlinie definieren. Standardfeldindizes werden nicht auf Ihr [Feldindexkontingent](#CloudWatchLogs-Field-Indexing-Syntax) angerechnet.
**Untergeordnete Felder und Array-Felder in JSON-Protokollen**
Sie können Felder indizieren, bei denen es sich um verschachtelte untergeordnete Felder oder Array-Felder in JSON-Protokollen handelt.
Sie können beispielsweise einen Index des `accessKeyId` untergeordneten Felds innerhalb des `userIdentity` Felds in diesem Protokoll erstellen:
```
{
"eventVersion": "1.0",
"userIdentity": {
"type": "IAMUser",
"principalId": "EXAMPLE_PRINCIPAL_ID",
"arn": "arn: aws: iam: : 123456789012: user/Alice",
"accessKeyId": "11112222",
"accountId": "123456789012",
"userName": "Alice"
},
"eventTime": "2014-03-06T21: 22: 54Z",
"eventSource": "ec2.amazonaws.com",
"eventName": "StartInstances",
"awsRegion": "us-east-2",
"sourceIPAddress": "192.0.2.255",
"userAgent": "ec2-api-tools1.6.12.2",
"requestParameters": {
"instancesSet": {
"items": [{
"instanceId": "i-abcde123",
"currentState": {
"code": 0,
"name": "pending"
},
"previousState": {
"code": 80,
"name": "stopped"
}
}]
}
}
}
```
Um dieses Feld zu erstellen, verweisen Sie sowohl bei der Erstellung des Feldindex als auch bei der Angabe in einer Abfrage mithilfe der Punktnotation (`userIdentity.accessKeyId`) darauf. Die Abfrage könnte wie folgt aussehen:
```
fields @timestamp, @message
| filterIndex userIdentity.accessKeyId = "11112222"
```
Im vorherigen Beispielereignis befindet sich das `instanceId` Feld in einem Array innerhalb von `requestParameters.instancesSet.items` Um dieses Feld sowohl bei der Erstellung des Feldindex als auch bei der Abfrage darzustellen, bezeichnen Sie es als `requestParameters.instancesSet.items.0.instanceId` Die 0 bezieht sich auf die Position dieses Felds im Array.
Dann könnte eine Abfrage für dieses Feld wie folgt aussehen:
```
fields @timestamp, @message
| filterIndex requestParameters.instancesSet.items.0.instanceId="i-abcde123"
```
# Erstellen Sie eine Feldindexrichtlinie auf Kontoebene
Verwenden Sie die Schritte in diesem Abschnitt, um eine Feldindexrichtlinie zu erstellen, die für alle Protokollgruppen im Konto oder für mehrere Protokollgruppen gilt, deren Protokollgruppennamen mit derselben Zeichenfolge beginnen.
**So erstellen Sie eine Feldindexrichtlinie auf Kontoebene**
1. Öffnen Sie die CloudWatch Konsole unter. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Wählen Sie im linken Navigationsbereich **Einstellungen** und dann die Registerkarte **Protokolle** aus.
1. Wählen Sie im Abschnitt **Indexrichtlinien auf Kontoebene** die Option **Verwalten** aus.
1. Wählen Sie **Indexrichtlinie erstellen** aus.
1. Geben Sie **unter Richtlinienname** einen Namen für Ihre neue Richtlinie ein.
1. Führen **Sie unter Geltungsbereich der Richtlinie auswählen** einen der folgenden Schritte aus:
+ Wählen Sie **Alle Standardprotokollgruppen** aus, damit die Indexrichtlinie auf alle Protokollgruppen der Standardklasse im Konto angewendet wird.
+ Wählen Sie **Gruppen nach Präfixübereinstimmung protokollieren**, um die Richtlinie auf eine Teilmenge von Protokollgruppen anzuwenden, deren Namen alle mit derselben Zeichenfolge beginnen. Geben Sie dann unter Geben Sie einen **Präfixnamen ein das Präfix für diese Protokollgruppen ein**.
Nachdem Sie Ihr Präfix eingegeben haben, können Sie die Option **Vorschau der mit dem Präfix übereinstimmenden Protokollgruppen** auswählen, um zu überprüfen, ob Ihr Präfix den erwarteten Protokollgruppen entspricht.
Wählen Sie **Daten nach Datenquelle protokollieren**, um die Richtlinie auf eine bestimmte Kombination aus Datenquellennamen und -typ anzuwenden. Anschließend können Sie die **Datenquelle** und den **Datentyp** aus dem Dropdownmenü auswählen.
Nachdem Sie den Namen und den Typ der Datenquelle ausgewählt haben, können Sie **Felder abrufen** auswählen, um den Abschnitt **Feldindizes und Facetten konfigurieren** mit relevanten Informationen wie den verfügbaren Feldern, den enthaltenen Protokollgruppen sowie standardmäßigen und benutzerdefinierten Feldindizes zu füllen.
1. Wählen Sie für die **Konfiguration eines benutzerdefinierten Indexfeldes** die Option **Feldpfad hinzufügen** aus, um das erste zu indizierende Feld einzugeben.
Geben Sie dann die Zeichenfolge ein, die als Wert für den Feldnamen verwendet werden soll, oder wählen Sie ein Feld aus dem Drop-down-Menü aus. Die Groß- und Kleinschreibung muss exakt mit den Angaben in den Protokollereignissen übereinstimmen. Wenn Ihre Protokollereignisse beispielsweise Folgendes beinhalten`requestId`, müssen Sie dies `requestId` hier eingeben. `RequestId``requestID`, und `request Id` würde nicht übereinstimmen.
Wenn Sie ein benutzerdefiniertes Protokollfeld indizieren möchten, das mit dem `@` Zeichen beginnt, müssen Sie bei der Eingabe der Indexzeichenfolge ein zusätzliches `@` Zeichen angeben. Wenn Sie beispielsweise über ein benutzerdefiniertes Protokollfeld verfügen`@emailname`, geben Sie es `@@emailname` in das **Feld Feldpfad hinzufügen** ein.
Sie können auch Indizes für die `@logStream` Felder `@ingestionTime` und erstellen, die CloudWatch Logs automatisch generiert. Wenn Sie dies tun, müssen Sie `@` bei der Angabe keine zusätzlichen Daten hinzufügen.
1. (Optional) Sie können nicht nur den Feldpfad angeben, sondern auch **Als Facette festlegen** auswählen, um das Feld als Facette zu erstellen.
1. Wiederholen Sie den vorherigen Schritt, um bis zu 20 Feldindizes hinzuzufügen.
1. Klicken Sie danach auf **Erstellen**.
# Erstellen Sie eine Feldindexrichtlinie auf Protokollgruppenebene
Verwenden Sie die Schritte in diesem Abschnitt, um eine Feldindexrichtlinie zu erstellen, die für eine einzelne Protokollgruppe gilt.
**So erstellen Sie eine Feldindexrichtlinie auf Protokollgruppenebene**
1. Öffnen Sie die CloudWatch Konsole unter. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Wählen Sie im linken Navigationsbereich **Logs (Protokolle)**, **Log groups (Protokollgruppen)** aus.
1. Wählen Sie den Namen der Protokollgruppe aus.
1. Wählen Sie die Registerkarte **Feldindizes**.
1. Wählen Sie **Feldindizes für diese Protokollgruppe verwalten**
1. Wählen **Sie für Feldindizes auf Protokollgruppenebene verwalten** die Option **Feldpfad hinzufügen** aus, um das erste zu indizierende Feld einzugeben.
Geben Sie dann die Zeichenfolge ein, die als Wert für den Feldnamen verwendet werden soll. Die Groß- und Kleinschreibung muss exakt mit den Angaben in den Protokollereignissen übereinstimmen. Wenn Ihre Protokollereignisse beispielsweise Folgendes beinhalten`requestId`, müssen Sie dies `requestId` hier eingeben. `RequestId``requestID`, und `request Id` würde nicht übereinstimmen.
Wenn Sie ein benutzerdefiniertes Protokollfeld indizieren möchten, das mit dem `@` Zeichen beginnt, müssen Sie bei der Eingabe der Indexzeichenfolge ein zusätzliches `@` Zeichen angeben. Wenn Sie beispielsweise über ein benutzerdefiniertes Protokollfeld verfügen`@emailname`, geben Sie es `@@emailname` in das **Feld Feldpfad hinzufügen** ein.
Sie können auch Indizes für die `@logStream` Felder `@ingestionTime` und erstellen, die CloudWatch Logs automatisch generiert. Wenn Sie dies tun, müssen Sie `@` bei der Angabe keine zusätzlichen Daten hinzufügen.
1. (Optional) Sie können nicht nur den Feldpfad angeben, sondern auch **Als Facette festlegen** auswählen, um das Feld als Facette zu erstellen.
1. Wiederholen Sie den vorherigen Schritt, um bis zu 20 Feldindizes hinzuzufügen.
1. Klicken Sie auf **Save**, sobald Sie fertig sind.
# Protokollieren Sie die Gruppenauswahloptionen beim Erstellen einer Abfrage
In diesem Abschnitt werden die verschiedenen Möglichkeiten erläutert, mit denen Sie Protokollgruppen auswählen können, die in eine Abfrage aufgenommen werden sollen.
**Um Protokollgruppen für eine Abfrage in der Konsole auszuwählen**
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 **Protokolle** und dann **Logs Insights** aus.
1. Wählen Sie die Abfragesprache aus, die Sie für diese Abfrage verwenden möchten. Sie können zwischen **Logs Insights QL**, **OpenSearchPPL** oder **OpenSearch SQL** wählen.
1. Es gibt drei Möglichkeiten, Protokollgruppen für die Abfrage auszuwählen:
+ Verwenden Sie das Feld **Name der Protokollgruppe**. Dies ist die Standardauswahlmethode. Mit dieser Methode können Sie bis zu 50 Protokollgruppennamen eingeben. Wenn es sich um ein Überwachungskonto mit CloudWatch kontenübergreifender Observability handelt, können Sie Protokollgruppen sowohl in den Quellkonten als auch im Überwachungskonto auswählen. Mit einer einzigen Abfrage können Protokolle von verschiedenen Konten gleichzeitig abgefragt werden.
+ Verwenden Sie den Abschnitt **Kriterien für Protokollgruppen**. In diesem Abschnitt können Sie Protokollgruppen anhand des Präfixes der Protokollgruppennamen auswählen. Sie können bis zu fünf Präfixe in eine Abfrage aufnehmen. Protokollgruppen, deren Namen diese Präfixe enthalten, werden ausgewählt. Alternativ wählt die Option **Alle Protokollgruppen** alle Protokollgruppen aus dem Konto aus.
+ Wenn es sich um ein Überwachungskonto mit CloudWatch kontenübergreifender Beobachtbarkeit handelt, können Sie im Dropdownmenü „Konto“ die Option **Alle Konten** auswählen, um die Protokollgruppen aus allen verknüpften Konten auszuwählen. Alternativ können Sie individuell auswählen, welche Konten für diese Abfrage berücksichtigt werden sollen.
Wenn Ihre Auswahl mit mehr als 10.000 Protokollgruppen übereinstimmt, wird eine Fehlermeldung angezeigt, die Sie auffordert, Ihre Auswahl einzuschränken.
1. Die Standard-Protokollklasse für eine Abfrage ist **Standard**. Sie können die **Protokollklasse** verwenden, um sie **in Infrequent Access** zu ändern.
**Verwenden Sie die AWS CLI**
Um diese Arten von Auswahlen zu treffen, wenn Sie eine Abfrage von der Befehlszeile aus starten, können Sie den `source` Befehl in Ihrer Abfrage verwenden. Weitere Informationen und Beispiele finden Sie unter [SOURCE](CWL_QuerySyntax-Source.md).
# Auswirkungen des Löschens einer Feldindexrichtlinie
Wenn Sie eine Feldindexrichtlinie löschen, die eine Zeit lang gültig war, passiert Folgendes:
+ Bis zu 30 Tage nach dem Löschen der Richtlinie können Abfragen weiterhin von den indizierten Protokollereignissen profitieren.
+ Wenn Sie eine Indexrichtlinie auf Protokollgruppenebene löschen und es bereits eine Richtlinie auf Kontoebene gibt, die für diese Protokollgruppe gelten würde, gilt die Richtlinie auf Kontoebene irgendwann auch für diese Protokollgruppe.
# Verwenden Sie Facetten, um Logs zu gruppieren und zu untersuchen
Facetten sind nützlich für die Analyse von Protokollen, da Sie damit Ihre Daten interaktiv filtern und gruppieren können, ohne Abfragen ausführen zu müssen. Eine Facette ist ein Feld in Ihren Protokollen (wie `ServiceName` oder`StatusCode`), das das Filtern, Aggregieren und Analysieren über Protokollgruppen hinweg ermöglicht. Sie können die Liste der facettierten Felder in der CloudWatch Logs Insights-Konsole zusammen mit der Anzahl der Protokollereignisse für jeden Facettenwert, basierend auf dem ausgewählten Zeitraum, einsehen. Wenn Sie verschiedene Facetten und Werte auswählen, werden die Facettenwerte und die Anzahl der Facetten in Echtzeit aktualisiert, sodass Sie Ihre Logs interaktiv erkunden können.
Jede Facette zeigt verfügbare Werte und Zählungen an, die auf Grundlage des ausgewählten Zeitraums und Abfragebereichs automatisch aus Feldern in Ihren Protokollen extrahiert und für 30 Tage aufbewahrt werden. Die angegebenen Facettenzahlen sind ungefähre Angaben. Sie können die Standardfacetten wie den Namen der Datenquelle oder den Datenquellentyp verwenden, um Ihre Protokolle zu untersuchen, oder benutzerdefinierte Facetten für jedes Feld in Ihren Protokollen erstellen. Der Datenquellenname ist ein AWS-Service oder eine AWS-Applikation, die die Protokolle generiert (z. B. Route 53, Amazon VPC oder CloudTrail), und der Datenquellentyp ist der spezifische Protokolltyp, der von diesem Service generiert wird. Standardfacetten werden von erstellt CloudWatch und beinhalten`@aws.region`, `@data_source_name``@data_source_type`, und. `@data_format` Weitere Informationen finden Sie unter [Verwaltung von Protokollen](LogManagement.md). Facetten sind nur für Logs verfügbar, die in das Konto aufgenommen wurden. Wenn Sie die kontenübergreifende Observability eingerichtet haben, kann das Monitoring-Konto keine Facetten anzeigen, die auf Logs von Quellkonten basieren.
Um zusätzliche Facetten zu erstellen, wählen Sie die Felder in Ihren Protokollen aus, die für Ihre Problembehandlung relevant sind, und konfigurieren Sie sie mithilfe der Indexrichtlinien. Für benutzerdefinierte Facetten empfehlen wir, sie für Felder mit niedriger Kardinalität zu erstellen (Felder mit weniger als 100 Einzelwerten pro Tag wie Status und). ApplicationName Facetten mit mehr als 100 Einzelwerten pro Tag werden als hohe Kardinalität eingestuft und Werte für diese Facetten werden nicht angezeigt. Wählen Sie eine oder mehrere Facetten aus und klicken Sie, um Abfragen in Ihren Logs auszuführen.
Um mit Facetten in CloudWatch Logs Insights zu beginnen:
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 **Protokolle** und dann **Logs Insights** aus.
1. (Optional) Verwenden Sie die Zeitbereichsauswahl, um einen Zeitraum auszuwählen, den Sie analysieren möchten. Für den ausgewählten Zeitraum werden die verfügbaren Facetten und Werte im Bereich angezeigt.
1. Wählen Sie Facetten aus, um Ihre Daten zu untersuchen und Aktualisierungen der Wertverteilungen zwischen den Facetten in Echtzeit zu sehen.
Facetten mit mehr als 100 Einzelwerten werden nicht angezeigt. Um bestimmte Werte abzufragen, verwenden Sie stattdessen Filter in Ihrer Abfrage.
## Um eine facettenbasierte Abfrage auszuführen
1. Wählen Sie einen oder mehrere Facettenwerte aus.
1. Die Anzahl der Ereignisse wird auf der Grundlage der ausgewählten Facetten und Werte aktualisiert.
1. Wenn Facettenwerte ausgewählt werden, wird der Abfragebereich aktualisiert, um die Auswahl widerzuspiegeln.
1. Nachdem Sie die Facettenwerte ausgewählt haben, klicken Sie auf Ausführen, um Ihre Abfrage auszuführen.
1. Die maximale Anzahl von Einzelwerten, die pro Facette unterstützt werden, ist 100. Wenn es beispielsweise mehr als 100 Werte für eine Facette gibt, werden alle Zählungen als „-“ angezeigt, was darauf hinweist, dass die Werte unbekannt sind.
## Um eine facettenbasierte Abfrage zu speichern
1. Erstellen Sie Ihre Abfrage mit einem oder mehreren Facettenwerten.
1. Die restlichen Schritte entsprechen dem Speichern einer Logs Insights-Abfrage. Weitere Informationen finden Sie unter [ CloudWatch Logs Insights-Abfragen speichern](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_Insights-Saving-Queries.html).
1. Ihre gespeicherten Abfragen sind im Abschnitt Gespeicherte Abfragen verfügbar. Wenn Sie eine gespeicherte Abfrage abrufen, enthält sie automatisch die für die Abfrage verwendeten Facetten und Werte, sodass Sie Ihre Logs einfach analysieren können.
## Um eine Facette auf Kontoebene zu erstellen
1. Um Facetten zu erstellen, müssen Sie das Feld zunächst als Index erstellen und es als Facette konfigurieren. Wählen Sie im Navigationsbereich **Einstellungen**, **Protokolle**, **Indexrichtlinien auf Kontoebene** aus. Alternativ können Sie im Bereich Facetten die Option **Facetten verwalten** auswählen.
1. Wählen Sie **Neue Indexrichtlinie erstellen** aus. Einzelheiten zum Erstellen von Indexrichtlinien finden Sie unter[Erstellen Sie eine Feldindexrichtlinie auf Kontoebene](CloudWatchLogs-Field-Indexing-CreateAccountLevel.md).
1. Um eine Facette zu erstellen, aktivieren Sie für das ausgewählte Feld auf der **Seite zur Erstellung der Indexrichtlinie die Option Als Facet festlegen**.
## Facettenverwaltung mit APIs
Die Facettenverwaltung kann mithilfe der Feldindexrichtlinie erfolgen. Details dazu finden Sie unter [https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_FieldIndex.html](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_FieldIndex.html) APIs .
**Feldindex APIs**
| Nein. | Name | Description |
| --- | --- | --- |
| 1 | PutIndexPolicy | Erstellt oder aktualisiert eine Feldindexrichtlinie für die spezifische Protokollgruppe |
| 2 | PutAccountPolicy | Erstellt eine Datenschutzrichtlinie auf Kontoebene, eine Abonnementfilterrichtlinie, eine Feldindexrichtlinie, eine Transformer-Richtlinie oder eine Metrikextraktionsrichtlinie, die für alle Protokollgruppen oder eine Teilmenge von Protokollgruppen im Konto gilt |
| 3 | DeleteIndexPolicy | Löscht eine Feldindexrichtlinie auf Protokollgruppenebene, die auf eine einzelne Protokollgruppe angewendet wurde |
| 4 | DeleteAccountPolicy | Löscht eine Logs-Kontorichtlinie CloudWatch |
# Musteranalyse
CloudWatch Logs Insights verwendet Algorithmen für maschinelles Lernen, um *Muster* zu finden, wenn Sie Ihre Logs abfragen. Ein Muster ist eine gemeinsame Textstruktur, die sich in Ihren Protokollfeldern wiederholt. Wenn Sie sich die Ergebnisse einer Abfrage ansehen, können Sie die Registerkarte **Muster** wählen, um sich die Muster anzusehen, die CloudWatch Logs anhand einer Stichprobe Ihrer Ergebnisse gefunden hat. Alternativ können Sie den `pattern` Befehl an Ihre Abfrage anhängen, um die Muster im gesamten Satz übereinstimmender Protokollereignisse zu analysieren.
Muster sind nützlich für die Analyse großer Protokollsätze, da eine große Anzahl von Protokollereignissen häufig zu wenigen Mustern komprimiert werden kann.
Betrachten Sie das folgende Beispiel mit drei Protokollereignissen.
```
2023-01-01 19:00:01 [INFO] Calling DynamoDB to store for resource id 12342342k124-12345
2023-01-01 19:00:02 [INFO] Calling DynamoDB to store for resource id 324892398123-12345
2023-01-01 19:00:03 [INFO] Calling DynamoDB to store for resource id 3ff231242342-12345
```
Im vorherigen Beispiel folgen alle drei Protokollereignisse einem Muster:
```
[INFO] Calling DynamoDB to store for resource id
```
Felder innerhalb eines Musters werden als *Token* bezeichnet. Felder, die innerhalb eines Musters variieren, z. B. eine Anforderungs-ID oder ein Zeitstempel, sind *dynamische Token*. Jedes dynamische Token wird repräsentiert durch``. Das *string* ist eine Beschreibung des Datentyps, für den das Token steht. Das *number* zeigt, an welcher Stelle des Musters dieses Token im Vergleich zu den anderen dynamischen Tokens erscheint.
Zu den häufigsten Beispielen für dynamische Token gehören Fehlercodes, Zeitstempel und Anfragen IDs. Ein *Tokenwert* steht für einen bestimmten Wert eines dynamischen Tokens. Wenn ein dynamisches Token beispielsweise einen HTTP-Fehlercode darstellt, könnte dies ein Tokenwert sein`501`.
Die Mustererkennung wird auch im CloudWatch Logs-Anomaliedetektor und in den Vergleichsfunktionen verwendet. Weitere Informationen erhalten Sie unter [Erkennung von Protokollanomalien](LogsAnomalyDetection.md) und [Vergleiche (Diff) mit früheren Zeitbereichen](CWL_AnalyzeLogData_Compare.md).
## Erste Schritte mit der Musteranalyse
Die Mustererkennung wird automatisch in jeder CloudWatch Logs Insights-Abfrage durchgeführt. Bei Abfragen, die den `pattern` Befehl nicht enthalten, werden sowohl Ereignisse als auch Muster in den Ergebnissen protokolliert.
Wenn Sie den `pattern` Befehl in Ihre Abfrage aufnehmen, wird die Musteranalyse für den gesamten Satz übereinstimmender Protokollereignisse durchgeführt. Dadurch erhalten Sie genauere Musterergebnisse, aber die unverarbeiteten Protokollereignisse werden nicht zurückgegeben, wenn Sie den `pattern` Befehl verwenden. Wenn eine Abfrage keine Daten enthält`pattern`, basieren die Musterergebnisse entweder auf den ersten 1000 zurückgegebenen Protokollereignissen oder auf dem Grenzwert, den Sie in Ihrer Abfrage verwendet haben. Wenn Sie `pattern` in die Abfrage einbeziehen, werden die auf der Registerkarte **Muster** angezeigten Ergebnisse aus allen Protokollereignissen abgeleitet, denen die Abfrage entspricht.
**Um mit der Musteranalyse in CloudWatch Logs Insights zu beginnen**
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 **Protokolle** und dann **Logs Insights** aus.
Auf der **Logs-Insights**-Seite enthält der Abfrage-Editor eine Standardabfrage, die die 20 letzten Protokollereignisse zurückgibt.
1. Entfernen Sie die `| limit 20` Zeile im Abfragefeld, sodass die Abfrage wie folgt aussieht:
```
fields @timestamp, @message, @logStream, @log
| sort @timestamp desc
```
1. **Wählen Sie in der Dropdownliste Protokollgruppe (n)** auswählen eine oder mehrere Protokollgruppen für die Abfrage aus.
1. (Optional) Verwenden Sie die Zeitintervallauswahl, um einen Zeitraum auszuwählen, den Sie abfragen möchten.
Sie können zwischen Intervallen von 5 Minuten und 30 Minuten, Intervallen von 1 Stunde, 3 Stunden und 12 Stunden oder einem benutzerdefinierten Zeitrahmen wählen.
1. Wählen Sie **Abfrage ausführen, um die Abfrage** zu starten.
Wenn die Ausführung der Abfrage abgeschlossen ist, wird auf der Registerkarte „**Protokolle**“ eine Tabelle mit den von der Abfrage zurückgegebenen Protokollereignissen angezeigt. Über der Tabelle befindet sich eine Meldung darüber, wie viele Datensätze der Abfrage entsprachen, ähnlich der Meldung **10.000 von 71.101 übereinstimmenden Datensätzen anzeigen**.
1. Wählen Sie die Registerkarte **Muster**.
1. In der Tabelle werden jetzt die in der Abfrage gefundenen Muster angezeigt. Da die Abfrage den `pattern` Befehl nicht enthielt, werden auf dieser Registerkarte nur die Muster angezeigt, die unter den 10.000 Protokollereignissen entdeckt wurden, die in der Tabelle auf der Registerkarte **Protokolle** angezeigt wurden.
Für jedes Muster werden die folgenden Informationen angezeigt:
+ Das **Muster**, wobei jedes dynamische Token als angezeigt wird``. Das *string* ist eine Beschreibung des Datentyps, für den das Token steht. Das *number* zeigt, an welcher Stelle des Musters dieses Token im Vergleich zu den anderen dynamischen Tokens erscheint.
+ Die **Anzahl der Ereignisse**, d. h. die Häufigkeit, mit der das Muster in den abgefragten Protokollereignissen auftauchte. Wählen Sie die Spaltenüberschrift „**Anzahl der Ereignisse**“, um die Muster nach Häufigkeit zu sortieren.
+ Die **Ereignisquote**, d. h. der Prozentsatz der abgefragten Protokollereignisse, die dieses Muster enthalten.
+ Der **Schweregradtyp**, der einer der folgenden sein wird:
+ **FEHLER**, wenn das Muster das Wort **Error** enthält.
+ **WARN**, wenn das Muster das Wort **Warn**, aber nicht das Wort **Error** enthält.
+ **INFO**, wenn das Muster weder **Warn** noch **Error** enthält.
Wählen Sie die **Spaltenüberschrift Schweregrad** aus, um die Muster nach Schweregrad zu sortieren.
1. Ändern Sie jetzt die Abfrage. Ersetzen Sie die `| sort @timestamp desc` Zeile in der Abfrage durch`| pattern @message`, sodass die vollständige Abfrage wie folgt lautet:
```
fields @timestamp, @message, @logStream, @log
| pattern @message
```
1. Wählen Sie **Abfrage ausführen**.
Wenn die Abfrage abgeschlossen ist, werden auf der Registerkarte **Protokolle** keine Ergebnisse angezeigt. Auf der Registerkarte **Muster** ist jedoch wahrscheinlich eine größere Anzahl von Mustern aufgeführt, je nachdem, wie viele Protokollereignisse insgesamt abgefragt wurden.
1. Unabhängig davon, ob Sie sie `pattern` in Ihre Abfrage aufgenommen haben, können Sie die Muster, die die Abfrage zurückgibt, genauer untersuchen. Wählen Sie dazu das Symbol in der Spalte **Inspizieren** für eines der Muster aus.
Das Fenster „**Muster prüfen**“ wird geöffnet und enthält Folgendes:
+ Das **Muster**. Wählen Sie ein Token innerhalb des Musters aus, um die Werte dieses Tokens zu analysieren.
+ Ein Histogramm, das die Anzahl der Vorkommen des Musters im abgefragten Zeitraum zeigt. Dies kann Ihnen helfen, interessante Trends zu identifizieren, z. B. eine plötzliche Zunahme des Auftretens eines Musters.
+ Auf der Registerkarte **Protokollbeispiele** werden einige der Protokollereignisse angezeigt, die dem ausgewählten Muster entsprechen.
+ Auf der Registerkarte **Token-Werte** werden die Werte des ausgewählten dynamischen Tokens angezeigt, sofern Sie eines ausgewählt haben.
**Anmerkung**
Für jedes Token werden maximal 10 Token-Werte erfasst. Die Anzahl der Tokens ist möglicherweise nicht genau. CloudWatch Logs verwendet einen probabilistischen Zähler, um die Tokenanzahl zu generieren, nicht den absoluten Wert.
+ Auf der Registerkarte **Verwandte Muster** werden andere Muster angezeigt, die häufig fast zur gleichen Zeit wie das Muster aufgetreten sind, das Sie untersuchen. Wenn beispielsweise ein Muster für eine `ERROR` Nachricht normalerweise von einem anderen Protokollereignis begleitet wurde, das als `INFO` mit zusätzlichen Details gekennzeichnet war, wird dieses Muster hier angezeigt.
## Details zum Pattern-Befehl
Dieser Abschnitt enthält weitere Informationen über den `pattern` Befehl und seine Verwendung.
+ Im vorherigen Tutorial haben wir den `sort` Befehl entfernt, als wir ihn hinzugefügt haben`pattern`, weil eine Abfrage nicht gültig ist, wenn sie einen `pattern` Befehl nach einem `sort` Befehl enthält. Es ist gültig, ein `pattern` vor einem zu haben`sort`.
Weitere Informationen zur `pattern` Syntax finden Sie unter[pattern](CWL_QuerySyntax-Pattern.md).
+ Wenn Sie `pattern` in einer Abfrage verwenden, `@message` muss eines der Felder im `pattern` Befehl ausgewählt sein.
+ Sie können den `filter` Befehl vor einem `pattern` Befehl einfügen, damit nur der gefilterte Satz von Protokollereignissen als Eingabe für die Musteranalyse verwendet wird.
+ Um Musterergebnisse für ein bestimmtes Feld anzuzeigen, z. B. ein aus dem `parse` Befehl abgeleitetes Feld, verwenden Sie`pattern @fieldname`.
+ Abfragen, bei denen es sich nicht um eine Protokollausgabe handelt, wie z. B. Abfragen mit dem `stats` Befehl, geben keine Musterergebnisse zurück.
# Speichern Sie CloudWatch Logs Insights-Abfragen und führen Sie sie erneut aus
Nachdem Sie eine Abfrage erstellt haben, können Sie sie speichern, um sie später erneut auszuführen. Abfragen werden in einer Ordnerstruktur gespeichert, sodass Sie sie organisieren können. Sie können bis zu 1000 Abfragen pro Region und pro Konto speichern.
Abfragen werden auf einer regionsspezifischen Ebene gespeichert, nicht auf einer benutzerspezifischen Ebene. Wenn Sie eine Abfrage erstellen und speichern, können andere Benutzer mit Zugriff auf CloudWatch Protokolle in derselben Region alle gespeicherten Abfragen und ihre Ordnerstrukturen in der Region sehen.
Um eine Abfrage zu speichern, müssen Sie bei einer Rolle mit der Berechtigung angemeldet sein `logs:PutQueryDefinition`. Um die Liste Ihrer gespeicherten Abfragen anzuzeigen, müssen Sie bei einer Rolle mit der Berechtigung `logs:DescribeQueryDefinitions` angemeldet sein.
**Anmerkung**
Sie können Abfragen mit Parametern erstellen und speichern — wiederverwendbare Vorlagen mit benannten Platzhaltern. Anstatt mehrere Varianten derselben Abfrage mit unterschiedlichen Werten zu speichern, erstellen Sie eine Vorlage und geben Sie bei der Ausführung unterschiedliche Parameterwerte an. Diese Funktion wird derzeit nur für Abfragen unterstützt, die die Logs Insights-Abfragesprache verwenden. Weitere Informationen finden Sie unter [Gespeicherte Abfragen mit Parametern verwenden](#CWL_Insights-Parameterized-Queries).
------
#### [ Console ]
**Um eine Abfrage zu speichern**
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 **Logs** (Protokolle) und dann **Logs Insights** aus.
1. Erstellen Sie im Abfrage-Editor eine Abfrage.
1. Wählen Sie **Speichern**.
1. Geben Sie einen Namen für die Abfrage ein.
1. (Optional) Wählen Sie den Ordner aus, in dem Sie die Abfrage speichern möchten. Wählen Sie **Create new (Neu erstellen)** aus, um einen Ordner zu erstellen. Wenn Sie einen neuen Ordner erstellen, können Sie Schrägstriche (/) im Ordnernamen verwenden, um eine Ordnerstruktur zu definieren. Wenn Sie beispielsweise einen neuen Ordner mit **folder-level-1/folder-level-2** benennen, wird der Ordner **folder-level-1** auf der obersten Ebene erstellt. In diesem Ordner befindet sich ein weiterer Ordner namens **folder-level-2**. Die Abfrage wird in **folder-level-2** gespeichert.
1. (Optional) Ändern Sie die Protokollgruppen oder den Abfragetext der Abfrage.
1. (Optional) Gehen Sie wie folgt vor, um Parameter in Ihrer Abfrage zu verwenden:
1. **Fügen Sie Ihrer Abfrage Parameter hinzu.** Ersetzen Sie statische Werte mithilfe der `{{parameter}}` Syntax durch Platzhalter (doppelte Klammern vor und nach dem Parameternamen).
Beispiel: Ursprüngliche Abfrage mit statischen Werten:
```
fields @timestamp, @message
| filter level = "Error"
| filter applicationName = "OrderService"
```
Aktualisierte Abfrage mit Parametern:
```
fields @timestamp, @message
| filter level = {{logLevel}}
| filter applicationName = {{applicationName}}
```
1. **Definieren Sie die in Ihrer Abfrage verwendeten Parameter.** Geben Sie für jeden Platzhalterparameter Folgendes an:
+ **Name**: Muss exakt mit dem Platzhalternamen übereinstimmen (z. B.`logLevel`,`applicationName`).
+ **Standardwert** (optional): Der Wert, der verwendet werden soll, wenn kein Parameterwert angegeben wird.
+ **Beschreibung** (optional): Erläutert den Zweck des Parameters.
1. Abfragen mit Parametern können ausgeführt werden, indem der Abfragename mit einem `$` Präfix verwendet und die Parameternamen als Schlüssel-Wert-Paare übergeben werden. Weitere Informationen finden **Sie unter So führen Sie eine gespeicherte Abfrage** aus.
1. Wählen Sie **Speichern**.
------
#### [ AWS CLI ]
**Um eine Abfrage zu speichern**, verwenden Sie`put-query-definition`:
```
aws logs put-query-definition \
--name "ErrorsByLevel" \
--query-string "fields @timestamp, @message | filter level = \"ERROR\"" \
--log-group-names "/aws/lambda/my-function" \
--region us-east-1
```
(Optional) Um eine Abfrage mit Parametern zu speichern, fügen Sie die `--parameters` Option hinzu und verwenden Sie `{{parameterName}}` Platzhalter in der Abfragezeichenfolge:
```
aws logs put-query-definition \
--name "ErrorsByLevel" \
--query-string "fields @timestamp, @message | filter level = {{logLevel}} | filter applicationName = {{applicationName}}" \
--parameters '[{"name":"logLevel","defaultValue":"ERROR","description":"Log level to filter"},{"name":"applicationName","defaultValue":"OrderService","description":"Application name to filter"}]' \
--log-group-names "/aws/lambda/my-function" \
--region us-east-1
```
Um eine Abfrage in einem Ordner zu speichern, stellen Sie dem Abfragenamen den Ordnerpfad voran:
```
aws logs put-query-definition \
--name "my-folder/ErrorsByLevel" \
--query-string "fields @timestamp, @message | filter level = {{logLevel}}" \
--parameters '[{"name":"logLevel","defaultValue":"ERROR","description":"Log level to filter"}]' \
--log-group-names "/aws/lambda/my-function" \
--region us-east-1
```
------
#### [ API ]
**Um eine Abfrage zu speichern**, rufen Sie [PutQueryDefinition](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutQueryDefinition.html):
```
{
"name": "ErrorsByLevel",
"queryString": "fields @timestamp, @message | filter level = \"ERROR\"",
"logGroupNames": ["/aws/lambda/my-function"]
}
```
(Optional) Um eine Abfrage mit Parametern zu speichern, schließen Sie das `parameters` Feld ein und verwenden Sie `{{parameterName}}` Platzhalter in der Abfragezeichenfolge:
```
{
"name": "ErrorsByLevel",
"queryString": "fields @timestamp, @message | filter level = {{logLevel}} | filter applicationName = {{applicationName}}",
"logGroupNames": ["/aws/lambda/my-function"],
"parameters": [
{
"name": "logLevel",
"defaultValue": "ERROR",
"description": "Log level to filter"
},
{
"name": "applicationName",
"defaultValue": "OrderService",
"description": "Application name to filter"
}
]
}
```
------
**Tipp**
Sie können einen Ordner für gespeicherte Abfragen mit `PutQueryDefinition` erstellen. Um einen Ordner für Ihre gespeicherten Abfragen zu erstellen, verwenden Sie einen Schrägstrich (/), um Ihrem gewünschten Abfragenamen den gewünschten Ordnernamen voranzustellen: `/`. Weitere Informationen zu dieser Aktion finden Sie unter [PutQueryDefinition](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutQueryDefinition.html).
------
#### [ Console ]
**So führen Sie eine gespeicherte Abfrage aus**
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 **Logs** (Protokolle) und dann **Logs Insights** aus.
1. Wählen Sie auf der rechten Seite **Queries (Abfragen)** aus.
1. Wählen Sie Ihre Abfrage aus der Liste **Gespeicherte Abfragen** aus. Der Abfragetext wird im Abfrage-Editor angezeigt.
1. (Optional) Um eine Abfrage mit Parametern zu verwenden:
1. Wählen Sie im Seitenbereich **Gespeicherte Abfragen** das Pluszeichen (**\$1**) neben dem Abfragenamen aus.
1. Die Abfrage mit den Parametern wird im Abfrage-Editor angezeigt. Wenn Sie beispielsweise das Pluszeichen (**\$1**) neben wählen`ErrorsByLevel`, wird der Abfrage-Editor mit folgenden Informationen gefüllt: `$ErrorsByLevel(level=, applicationName=)`
1. Geben Sie die Werte für die Parameter (level, applicationName) an und führen Sie die Abfrage aus. Beispiel: `$ErrorsByLevel(level= "ERROR", applicationName= "OrderService")`
1. Klicken Sie auf **Ausführen**.
------
#### [ AWS CLI ]
**Um eine gespeicherte Abfrage mit Parametern auszuführen**
Verwenden Sie es `start-query` mit der folgenden `$QueryName()` Syntax:
```
aws logs start-query \
--log-group-names "/aws/lambda/my-function" \
--start-time 1707566400 --end-time 1707570000 \
--query-string '$ErrorsByLevel(level= "ERROR", applicationName= "OrderService")' \
--region us-east-1
```
------
#### [ API ]
**Um eine gespeicherte Abfrage mit Parametern auszuführen**
Rufen Sie [StartQuery](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_StartQuery.html)mit der `$QueryName()` Syntax im `queryString` Feld auf:
```
{
"logGroupNames": ["/aws/lambda/my-function"],
"startTime": 1707566400,
"endTime": 1707570000,
"queryString": "$ErrorsByLevel(level=\"ERROR\", applicationName= \"OrderService\")"
}
```
------
**So speichern Sie eine neue Version einer gespeicherten Abfrage**
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 **Logs** (Protokolle) und dann **Logs Insights** aus.
1. Wählen Sie auf der rechten Seite **Queries (Abfragen)** aus.
1. Wählen Sie Ihre Abfrage aus der Liste **Saved queries (Gespeicherte Abfragen)** aus. Anschließend wird sie im Abfrage-Editor angezeigt.
1. Ändern Sie die Abfrage. Wenn Sie die Abfrage ausführen müssen, um Ihre Arbeit zu überprüfen, wählen Sie **Run query (Abfrage ausführen)** aus.
1. Wenn Sie bereit sind, die neue Version zu speichern, wählen Sie **Actions (Aktionen)** und **Save as (Speichern unter)** aus.
1. Geben Sie einen Namen für die Abfrage ein.
1. (Optional) Wählen Sie den Ordner aus, in dem Sie die Abfrage speichern möchten. Wählen Sie **Create new (Neu erstellen)** aus, um einen Ordner zu erstellen. Wenn Sie einen neuen Ordner erstellen, können Sie Schrägstriche (/) im Ordnernamen verwenden, um eine Ordnerstruktur zu definieren. Wenn Sie beispielsweise einen neuen Ordner mit **folder-level-1/folder-level-2** benennen, wird der Ordner **folder-level-1** auf der obersten Ebene erstellt. In diesem Ordner befindet sich ein weiterer Ordner namens **folder-level-2**. Die Abfrage wird in **folder-level-2** gespeichert.
1. (Optional) Ändern Sie die Protokollgruppen oder den Abfragetext der Abfrage.
1. Wählen Sie **Speichern**.
Um eine Abfrage zu löschen, müssen Sie bei einer Rolle mit der Berechtigung `logs:DeleteQueryDefinition` angemeldet sein.
**So bearbeiten oder löschen Sie eine gespeicherte Abfrage**
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 **Logs** (Protokolle) und dann **Logs Insights** aus.
1. Wählen Sie auf der rechten Seite **Queries (Abfragen)** aus.
1. Wählen Sie Ihre Abfrage aus der Liste **Saved queries (Gespeicherte Abfragen)** aus. Anschließend wird sie im Abfrage-Editor angezeigt.
1. Wählen Sie **Actions (Aktionen)**, **Edit (Bearbeiten)** oder **Actions (Aktionen)**, **Delete (Löschen)** aus.
## Gespeicherte Abfragen mit Parametern verwenden
Gespeicherte Abfragen mit Parametern sind wiederverwendbare Abfragevorlagen mit benannten Platzhaltern. Anstatt mehrere Kopien fast identischer Abfragen zu verwalten, können Sie eine Vorlage speichern und bei der Ausführung der Abfrage unterschiedliche Parameterwerte angeben. Parameter werden nur in der CloudWatch Logs Insights-Abfragesprache unterstützt.
**Funktionsweise**
Beim Speichern einer Abfrage identifizieren Platzhalter die Werte, die Sie bei der Ausführung der Abfrage angeben können. Platzhalter verwenden die `{{parameterName}}` Syntax. Im Folgenden finden Sie ein Beispiel für eine gespeicherte Abfrage `ErrorsByLevel` mit dem Namen `logLevel` und`applicationName`.
```
fields @timestamp, @message
| filter level = {{logLevel}}
| filter applicationName = {{applicationName}}
```
Um eine gespeicherte Abfrage auszuführen, können Sie sie aufrufen, indem Sie den Abfragenamen mit dem Präfix verwenden `$` und die Parameterwerte übergeben. Die CloudWatch Logs Insights-Abfrage-Engine ersetzt jeden Platzhalter. Wenn ein Parameter Standardwerte enthält, werden diese Werte verwendet, sofern keine anderen Werte angegeben werden.
```
# Run query by using query name and passing parameter values explicitly
$ErrorsByLevel(logLevel = "WARN", applicationName = "OrderService")
# Run query without specifying parameter values - default values are used in this case.
$ErrorsByLevel()
```
Gespeicherte Abfragenamen, die Leerzeichen oder Sonderzeichen enthalten, müssen mit Backticks umschlossen werden:
```
$`Errors By Level`(logLevel = "WARN")
```
### Beispiel für gespeicherte Abfragen mit Parametern
**Hinzufügen eines Ergebnislimits als Parameter**
Abfragename: `ErrorsByLevel` mit Parametern `logLevel` (Standard:`"ERROR"`), `applicationName` (Standard:`"OrderService"`) und `maxResults` (Standard:`50`)
```
fields @timestamp, @message, @logStream
| filter level = {{logLevel}}
| filter applicationName = {{applicationName}}
| sort @timestamp desc
| limit {{maxResults}}
```
```
# Run the query using the query name and passing parameter values
$ErrorsByLevel(logLevel = "WARN", applicationName = "OrderService", maxResults = 100)
```
**Verwenden mehrerer gespeicherter Abfragen mit Parametern**
Das folgende Beispiel verwendet `ErrorsByLevel` eine zweite gespeicherte Abfrage`RecentN`, die als `sort @timestamp desc | limit {{count}}` (mit Parameter`count`, Standard`20`) definiert ist. Die CloudWatch Logs Insights-Abfrage-Engine erweitert jede Abfrage, bevor sie ausgeführt wird.
```
# Using multiple queries with parameters in sequence
$ErrorsByLevel(logLevel = "WARN", applicationName = "OrderService")
| $RecentN(count = 10)
# Each of the queries is expanded, resulting in the following query when it is run.
fields @timestamp, @message
| filter level = "WARN"
| filter applicationName = "OrderService"
| sort @timestamp desc
| limit 10
```
### Kontingente und Fehlerbehandlung
**Anmerkung**
Jede gespeicherte Abfrage kann maximal 20 Parameter haben.
Die erweiterte Abfragezeichenfolge darf 10.000 Zeichen nicht überschreiten. Parameternamen müssen mit einem Buchstaben oder Unterstrich beginnen. Eine gespeicherte Abfrage kann nicht auf eine andere gespeicherte Abfrage verweisen (verschachtelte Aufrufe werden nicht unterstützt).
**Häufige Fehler**
| Fehler | Ursache |
| --- | --- |
| Parameter werden nur für die CWLI-Abfragesprache unterstützt | Parameter werden nur in der CloudWatch Logs Insights-Abfragesprache unterstützt. |
| Erforderliche Parameter wurden nicht in QueryString gefunden | Für einen Parameternamen in `--parameters` gibt es keine Übereinstimmung `{{placeholder}}` in der Abfragezeichenfolge. |
| Die Anzahl der Parameter überschreitet den Höchstwert von 20 | Gespeicherte Abfragen unterstützen derzeit nur 20 Parameter. |
| Doppelter Parametername | Die Abfragedefinition enthält doppelte Parameter in`parameters`. |
**Anmerkung**
Um eine gespeicherte Abfrage mit Parametern zu erstellen oder zu aktualisieren, benötigen Sie die `logs:PutQueryDefinition` entsprechende Berechtigung. Um eine auszuführen, benötigen Sie `logs:StartQuery` und`logs:DescribeQueryDefinitions`.
# Abfrage zum Dashboard hinzufügen oder Abfrageergebnisse exportieren
Nachdem Sie eine Abfrage ausgeführt haben, können Sie die Abfrage zu einem CloudWatch Dashboard hinzufügen oder die Ergebnisse in die Zwischenablage kopieren.
Zu Dashboards hinzugefügte Abfragen werden bei jedem Laden des Dashboards und bei jeder Aktualisierung des Dashboards ausgeführt. Diese Abfragen werden auf Ihr Limit von 100 gleichzeitigen CloudWatch Logs Insights-Abfragen angerechnet.
**So fügen Sie Abfrageergebnisse zu einem Dashboard hinzu**
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 **Logs** (Protokolle) und dann **Logs Insights** aus.
1. Wählen Sie eine oder mehrere Protokollgruppen aus und führen Sie eine Abfrage aus.
1. Wählen Sie **Add to dashboard (Zu Dashboard hinzufügen)** aus.
1. Wählen Sie das Dashboard aus. Sie können auch **Create new (Neu erstellen)** auswählen, um ein Dashboard für die Abfrageergebnisse zu erstellen.
1. Wählen Sie den Widget-Typ aus, der für die Abfrageergebnisse verwendet werden soll.
1. Geben Sie einen Namen für das Widget ein.
1. Wählen Sie **Add to dashboard (Zu Dashboard hinzufügen)** aus.
**So kopieren Sie Abfrageergebnisse in die Zwischenablage oder laden die Abfrageergebnisse herunter**
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 **Logs** (Protokolle) und dann **Logs Insights** aus.
1. Wählen Sie eine oder mehrere Protokollgruppen aus und führen Sie eine Abfrage aus.
1. Wählen Sie **Export results (Ergebnisse exportieren)** und dann die gewünschte Option aus.
# Anzeigen von laufenden Abfragen oder Abfrageverlauf
Sie können die aktuell laufenden Abfragen sowie Ihren aktuellen Abfrageverlauf einsehen.
Abfragen, die derzeit ausgeführt werden, beinhalten Abfragen, die Sie einem Dashboard hinzugefügt haben. Sie sind auf 100 gleichzeitige CloudWatch Logs Insights-Abfragen pro Konto beschränkt, einschließlich Abfragen, die zu Dashboards hinzugefügt wurden. Darüber hinaus können Sie 15 Abfragen gleichzeitig für OpenSearch Service PPL oder Service SQL ausführen. OpenSearch
**So zeigen Sie Ihren aktuellen Abfrageverlauf an**
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 **Logs** (Protokolle) und dann **Logs Insights** aus.
1. Wählen Sie **Verlauf**, wenn Sie das neue Design für die CloudWatch Logs-Konsole verwenden. Wenn Sie das alte Design verwenden, wählen Sie **Actions (Aktionen)** und dann **View query history for this account (Abfrageverlauf für dieses Konto anzeigen)** aus.
Eine Liste Ihrer letzten Abfragen wird angezeigt. Sie können sie erneut ausführen, indem Sie die Abfrage und dann **Run (Ausführen)** auswählen.
Unter **Status** wird für alle Abfragen, CloudWatch die gerade ausgeführt werden, der Eintrag **In Bearbeitung** angezeigt.
# Verschlüsseln Sie die Abfrageergebnisse mit AWS Key Management Service
Standardmäßig verschlüsselt CloudWatch Logs die gespeicherten Ergebnisse Ihrer CloudWatch Logs Insights-Abfragen mit der serverseitigen CloudWatch Logs-Standardverschlüsselungsmethode. Sie können wählen, ob Sie stattdessen einen AWS KMS Schlüssel verwenden möchten, um diese Ergebnisse zu verschlüsseln. Wenn Sie Ihren Verschlüsselungsergebnissen einen AWS KMS Schlüssel zuordnen, verwendet CloudWatch Logs diesen Schlüssel, um die gespeicherten Ergebnisse aller Abfragen im Konto zu verschlüsseln.
Wenn Sie später die Zuordnung eines Schlüssels zu Ihren Abfrageergebnissen aufheben, kehrt CloudWatch Logs für spätere Abfragen zur Standardverschlüsselungsmethode zurück. Die Abfragen, die während der Zuordnung des Schlüssels ausgeführt wurden, sind jedoch weiterhin mit diesem Schlüssel verschlüsselt. CloudWatch Protokolle können diese Ergebnisse auch dann zurückgeben, wenn die Zuordnung des KMS-Schlüssels aufgehoben wurde, da CloudWatch Protokolle weiterhin auf den Schlüssel verweisen können. Wenn der Schlüssel jedoch später deaktiviert wird, kann CloudWatch Logs die Abfrageergebnisse, die mit diesem Schlüssel verschlüsselt wurden, nicht lesen.
**Wichtig**
CloudWatch Logs unterstützt nur symmetrische KMS-Schlüssel. Verwenden Sie keinen asymmetrischen Schlüssel, um Ihre Abfrageergebnisse zu verschlüsseln. Weitere Informationen finden Sie unter [Verwenden von symmetrischen und asymmetrischen Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html).
## Einschränkungen
+ Um die folgenden Schritte ausführen zu können, benötigen Sie die folgenden Berechtigungen: `kms:CreateKey`, `kms:GetKeyPolicy` und `kms:PutKeyPolicy`.
+ Nachdem Sie die Verknüpfung eines Schlüssels mit Ihren Abfrageergebnissen hergestellt oder aufgehoben haben, kann es bis zu fünf Minuten dauern, bis der Vorgang wirksam wird.
+ Wenn Sie CloudWatch Logs den Zugriff auf einen zugehörigen Schlüssel entziehen oder einen zugehörigen KMS-Schlüssel löschen, können Ihre verschlüsselten Daten in CloudWatch Logs nicht mehr abgerufen werden.
+ Sie können die CloudWatch Konsole nicht verwenden, um einen Schlüssel zuzuordnen. Sie müssen die AWS CLI oder CloudWatch Logs-API verwenden.
## Schritt 1: Erstellen Sie ein AWS KMS key
Um einen KMS-Schlüssel zu erstellen, verwenden Sie den folgenden Befehl [create-key](https://docs.aws.amazon.com/cli/latest/reference/kms/create-key.html):
```
aws kms create-key
```
Die Ausgabe enthält die Schlüssel-ID und den Amazon-Ressourcennamen (ARN) des Schlüssels. Das Folgende ist eine Beispielausgabe:
```
{
"KeyMetadata": {
"Origin": "AWS_KMS",
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"Description": "",
"KeyManager": "CUSTOMER",
"Enabled": true,
"CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
"KeyUsage": "ENCRYPT_DECRYPT",
"KeyState": "Enabled",
"CreationDate": 1478910250.94,
"Arn": "arn:aws:kms:us-west-2:123456789012:key/6f815f63-e628-448c-8251-e40cb0d29f59",
"AWSAccountId": "123456789012",
"EncryptionAlgorithms": [
"SYMMETRIC_DEFAULT"
]
}
}
```
## Schritt 2: Festlegen von Berechtigungen auf dem KMS-Schlüssel
Standardmäßig sind alle KMS-Schlüssel privat. Nur der Ressourcenbesitzer kann mit ihnen Daten verschlüsseln und entschlüsseln. Der Ressourceninhaber kann jedoch anderen Benutzern und Ressourcen Zugriffsberechtigungen für den Schlüssel erteilen. Mit diesem Schritt erteilen Sie dem Prinzipal des CloudWatch Logs-Dienstes die Erlaubnis, den Schlüssel zu verwenden. Dieser Dienstprinzipal muss sich in derselben AWS Region befinden, in der der Schlüssel gespeichert ist.
Als bewährte Methode empfehlen wir, die Verwendung des Schlüssels nur auf die von Ihnen angegebenen AWS Konten zu beschränken.
Speichern Sie zunächst die Standardrichtlinie für Ihren KMS-Schlüssel `policy.json` mit dem folgenden [get-key-policy](https://docs.aws.amazon.com/cli/latest/reference/kms/get-key-policy.html)Befehl:
```
aws kms get-key-policy --key-id key-id --policy-name default --output text > ./policy.json
```
Öffnen Sie die Datei `policy.json` in einem Texteditor und fügen Sie den in Fettschrift angezeigten Abschnitt aus einer der folgenden Anweisungen hinzu. Sie trennen die vorhandene Anweisung von der neuen Anweisung durch ein Komma. Diese Anweisungen verwenden `Condition` Abschnitte, um die Sicherheit des AWS KMS Schlüssels zu erhöhen. Weitere Informationen finden Sie unter [AWS KMS Schlüssel und Verschlüsselungskontext](encrypt-log-data-kms.md#encrypt-log-data-kms-policy).
Der `Condition` Abschnitt in diesem Beispiel beschränkt die Verwendung des AWS KMS Schlüssels auf die CloudWatch Logs Insights-Abfrageergebnisse im angegebenen Konto.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "key-default-1",
"Statement": [
{
"Sid": "Enable IAM User Permissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "kms:*",
"Resource": "*"
},
{
"Effect": "Allow",
"Principal": {
"Service": "logs.region.amazonaws.com"
},
"Action": [
"kms:Encrypt*",
"kms:Decrypt*",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:Describe*"
],
"Resource": "*",
"Condition": {
"ArnEquals": {
"aws:SourceArn": "arn:aws:logs:us-east-1:111122223333:query-result:*"
},
"StringEquals": {
"aws:SourceAccount": "111122223333"
}
}
}
]
}
```
------
Fügen Sie abschließend die aktualisierte Richtlinie mit dem folgenden [put-key-policy](https://docs.aws.amazon.com/cli/latest/reference/kms/put-key-policy.html)Befehl hinzu:
```
aws kms put-key-policy --key-id key-id --policy-name default --policy file://policy.json
```
## Schritt 3: Ordnen Sie Ihren Abfrageergebnissen einen KMS-Schlüssel zu
**So ordnen Sie den KMS-Schlüssel den Abfrageergebnissen im Konto zu**
Verwenden Sie den [disassociate-kms-key](https://docs.aws.amazon.com/cli/latest/reference/logs/disassociate-kms-key.html)-Befehl wie folgt:
```
aws logs associate-kms-key --resource-identifier "arn:aws:logs:region:account-id:query-result:*" --kms-key-id "key-arn"
```
## Schritt 4: Trennen Sie die Zuordnung eines Schlüssels zu den Abfrageergebnissen im Konto
Verwenden Sie den folgenden [disassociate-kms-key](https://docs.aws.amazon.com/cli/latest/reference/logs/disassociate-kms-key.html)Befehl, um die Zuordnung des KMS-Schlüssels zu trennen, der den Abfrageergebnissen zugeordnet ist:
```
aws logs disassociate-kms-key --resource-identifier "arn:aws:logs:region:account-id:query-result:*"
```
# Generieren Sie aus den CloudWatch Logs Insights-Abfrageergebnissen eine Zusammenfassung in natürlicher Sprache
Die Analyse von Protokolldaten ist entscheidend, um das Verhalten Ihrer Anwendungen zu verstehen, aber die Interpretation großer Mengen von Protokolleinträgen kann zeitaufwändig sein. CloudWatch Logs Insights bietet jetzt eine Funktion zur Zusammenfassung in natürlicher Sprache, die komplexe Abfrageergebnisse in klare, präzise Zusammenfassungen umwandelt. Diese Funktion hilft Ihnen, Probleme schnell zu identifizieren und umsetzbare Erkenntnisse aus Ihren Protokolldaten zu gewinnen.
## Funktionsweise
CloudWatch Logs Insights kann mithilfe von Amazon Bedrock eine menschenlesbare Zusammenfassung aus Ihren Abfrageergebnissen generieren. Die Funktion unterstützt alle CloudWatch Logs Insights-Abfragesprachen und bietet klare, umsetzbare Erkenntnisse aus Ihren Protokolldaten.
## Regionale Verfügbarkeit und Datenverarbeitung
**Wichtig**
Wenn Sie diese Funktion verwenden, werden Ihre Abfrageergebnisse möglicherweise auf andere Weise verarbeitet AWS-Region. Wenn Sie beispielsweise eine Abfrage in USA Ost (Nord-Virginia) ausführen, kann die Zusammenfassung in USA West (Oregon) erfolgen.
In der folgenden Tabelle ist die mögliche Verarbeitung AWS-Region für die verschiedenen Regionen aufgeführt, in denen die Funktion für Abfrageergebnisse verfügbar ist:
| Geografie der unterstützten Logs CloudWatch | Mögliche Verarbeitungsregion |
| --- | --- |
| Vereinigte Staaten (USA) | Region USA Ost (Nord-Virginia) Region USA Ost (Ohio) Region USA West (Oregon) |
| Europa | Region Europa (Frankfurt) Europe (Ireland) Region Region Europa (Paris) Region Europa (Stockholm) Region Europa (London) |
| Asien-Pazifik | Region USA Ost (Nord-Virginia) Region USA Ost (Ohio) Region USA West (Oregon) |
| Südamerika | Region USA Ost (Nord-Virginia) Region USA Ost (Ohio) Region USA West (Oregon) |
## Erste Schritte
**Um eine Zusammenfassung in natürlicher Sprache zu generieren**
1. Führen Sie Ihre CloudWatch Logs Insights-Abfrage aus.
1. Wählen Sie nach Abschluss der Abfrage **Ergebnisse zusammenfassen** aus.
## Berechtigungen
Sie müssen über eine der folgenden Voraussetzungen verfügen:
+ `CloudWatchLogsFullAccess`-Berechtigung
+ `CloudWatchLogsReadOnlyAccess`-Berechtigung
+ Benutzerdefinierte IAM-Richtlinie, einschließlich der `cloudwatch:GenerateQueryResultsSummary` Aktionen`logs:GetQueryResults`, `logs:DescribeQueries` und `logs:FilterLogEvents`
## Datenschutz
Ihre Abfrageergebnisse werden sicher verarbeitet und nicht zur Schulung oder Verbesserung von CloudWatch Logs Insights oder Amazon Bedrock verwendet. Wenn Sie sich dafür entscheiden, über die Feedback-Schaltflächen Feedback zur Zusammenfassung der Abfrageergebnisse zu geben, zeigt Ihr Feedback, wie zufrieden Sie mit den in CloudWatch Logs Insights bereitgestellten Funktionen sind.