.*?)/ | 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
```