.*?)/ | stats avg(latency2) by @method2,
@user2
```
**Mengekstrak bidang`loggingTime`, `loggingType` dan`loggingMessage`, memfilter ke log peristiwa yang berisi `ERROR` atau `INFO` string, dan kemudian hanya menampilkan `loggingMessage` dan `loggingType` bidang untuk peristiwa yang berisi `ERROR` string.**
```
FIELDS @message
| PARSE @message "* [*] *" as loggingTime, loggingType, loggingMessage
| FILTER loggingType IN ["ERROR", "INFO"]
| DISPLAY loggingMessage, loggingType = "ERROR" as isError
```
# menyortir
Gunakan `sort` untuk menampilkan peristiwa log dalam urutan ascending (`asc`) atau descending (`desc`) dengan bidang tertentu. Anda dapat menggunakan ini dengan `limit` perintah untuk membuat kueri “N atas” atau “N bawah”.
Algoritma penyortiran adalah versi terbaru dari penyortiran alami. Jika Anda mengurutkan dalam urutan menaik, logika berikut digunakan.
+ Semua nilai non-angka datang sebelum semua nilai angka. *Nilai angka* adalah nilai yang hanya mencakup angka, bukan campuran angka dan karakter lainnya.
+ Untuk nilai non-angka, algoritme mengelompokkan karakter numerik berurutan dan karakter alfabet berurutan ke dalam potongan terpisah untuk perbandingan. Ini memesan bagian non-numerik dengan nilai Unicode mereka, dan mengurutkan bagian numerik berdasarkan panjangnya terlebih dahulu dan kemudian dengan nilai numeriknya.
Untuk informasi selengkapnya tentang urutan Unicode, lihat [Daftar karakter Unicode](https://en.wikipedia.org/wiki/List_of_Unicode_characters).
Misalnya, berikut ini adalah hasil dari semacam dalam urutan menaik.
```
!: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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
```
Jika Anda mengurutkan dalam urutan menurun, hasil urutannya adalah sebaliknya.
Misalnya, kueri berikut untuk log aliran VPC Amazon menemukan 15 transfer paket teratas di seluruh host.
```
stats sum(packets) as packetsTransferred by srcAddr, dstAddr
| sort packetsTransferred desc
| limit 15
```
# statistik
Gunakan `stats` untuk membuat visualisasi data log Anda seperti diagram batang, diagram garis, dan bagan area bertumpuk. Ini membantu Anda mengidentifikasi pola dalam data log Anda dengan lebih efisien. CloudWatch Log Insights menghasilkan visualisasi untuk kueri yang menggunakan `stats` fungsi dan satu atau beberapa fungsi agregasi.
Misalnya, kueri berikut dalam grup log Route 53 mengembalikan visualisasi yang menunjukkan distribusi catatan Route 53 per jam, berdasarkan jenis kueri.
```
stats count(*) by queryType, bin(1h)
```
Semua kueri tersebut dapat menghasilkan diagram batang. Jika kueri Anda menggunakan fungsi `bin()` untuk mengelompokkan data dengan satu bidang dari waktu ke waktu, Anda juga dapat melihat diagram garis dan diagram area bertumpuk.
Satuan waktu dan singkatan berikut didukung dengan `bin` fungsi tersebut. Untuk semua unit dan singkatan yang menyertakan lebih dari satu karakter, menambahkan s ke pluralisasi didukung. Jadi keduanya `hr` dan `hrs` bekerja untuk menentukan jam.
+ `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**
+ [Visualisasikan data deret waktu](#CWL_Insights-Visualizing-TimeSeries)
+ [Visualisasikan data log yang dikelompokkan berdasarkan bidang](#CWL_Insights-Visualizing-ByFields)
+ [Gunakan beberapa perintah statistik dalam satu kueri](#CWL_QuerySyntax-stats-multi)
+ [Fungsi untuk digunakan dengan statistik](#CWL_QuerySyntax-stats-functions)
## Visualisasikan data deret waktu
Visualisasi deret waktu dapat digunakan dengan kueri yang memiliki karakteristik berikut:
+ Kueri berisi satu atau beberapa fungsi agregasi. Untuk informasi selengkapnya, lihat [Aggregation Functions in the Stats Command](#CWL_Insights_Aggregation_Functions).
+ Kueri menggunakan fungsi `bin()` untuk mengelompokkan data dengan satu bidang.
Kueri-kueri ini dapat menghasilkan diagram garis, diagram area bertumpuk, diagram batang, dan diagram lingkaran.
**Contoh**
Untuk tutorial lengkap, lihat [Tutorial: Jalankan kueri yang menghasilkan visualisasi deret waktu](CWL_AnalyzeLogData_VisualizationQuery.md).
Berikut adalah contoh kueri lain yang dapat digunakan untuk visualisasi deret waktu.
Kueri berikut menghasilkan visualisasi nilai rata-rata bidang `myfield1`, dengan titik data yang dibuat setiap lima menit. Setiap titik data adalah agregasi dari rata-rata nilai `myfield1` dari log lima menit sebelumnya.
```
stats avg(myfield1) by bin(5m)
```
Kueri berikut menghasilkan visualisasi dari tiga nilai berdasarkan pada bidang-bidang yang berbeda, dengan titik data yang dibuat setiap lima menit. Visualisasi dihasilkan karena kueri berisi fungsi agregat dan menggunakan `bin()` sebagai bidang pengelompokan.
```
stats avg(myfield1), min(myfield2), max(myfield3) by bin(5m)
```
**Bagan garis dan batasan bagan area bertumpuk**
Pertanyaan yang membuat agregat informasi entri log, tetapi tidak menggunakan fungsi `bin()` dapat menghasilkan diagram batang. Namun, kueri tidak dapat menghasilkan diagram garis atau diagram area bertumpuk. Untuk informasi selengkapnya tentang tipe kueri ini, lihat [Visualisasikan data log yang dikelompokkan berdasarkan bidang](#CWL_Insights-Visualizing-ByFields).
## Visualisasikan data log yang dikelompokkan berdasarkan bidang
Anda dapat menghasilkan diagram batang untuk kueri yang menggunakan fungsi `stats` dan satu atau beberapa fungsi agregasi. Untuk informasi selengkapnya, lihat [Aggregation Functions in the Stats Command](#CWL_Insights_Aggregation_Functions).
Untuk melihat visualisasi, jalankan kueri Anda. Lalu pilih tab **Visualization** (Visualisasi), pilih panah di sebelah **Line** (Garis), dan pilih **Bar** (Batang). Visualisasi dibatasi hingga 100 batang dalam diagram batang.
**Contoh**
Untuk tutorial lengkap, lihat [Tutorial: Jalankan kueri yang menghasilkan visualisasi yang dikelompokkan berdasarkan bidang log](CWL_AnalyzeLogData_VisualizationFieldQuery.md). Paragraf berikut mencakup lebih banyak contoh kueri untuk visualisasi berdasarkan bidang.
Kueri log alur VPC berikut menemukan jumlah rata-rata byte yang ditransfer per sesi untuk setiap alamat tujuan.
```
stats avg(bytes) by dstAddr
```
Anda juga dapat menghasilkan diagram yang mencakup lebih dari satu batang untuk setiap nilai yang dihasilkan. Misalnya, kueri log alur VPC berikut menemukan jumlah rata-rata dan maksimum byte yang ditransfer per sesi untuk setiap alamat tujuan.
```
stats avg(bytes), max(bytes) by dstAddr
```
Kueri berikut menemukan jumlah log kueri Amazon Route 53 untuk setiap jenis kueri.
```
stats count(*) by queryType
```
## Gunakan beberapa perintah statistik dalam satu kueri
Anda dapat menggunakan sebanyak dua `stats` perintah dalam satu kueri. Ini memungkinkan Anda untuk melakukan agregasi tambahan pada output agregasi pertama.
**Contoh: Query dengan dua `stats` perintah**
Misalnya, kueri berikut pertama-tama menemukan total volume lalu lintas di tempat sampah 5 menit, kemudian menghitung volume lalu lintas tertinggi, terendah, dan rata-rata di antara tempat sampah 5 menit tersebut.
```
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
```
**Contoh: Gabungkan beberapa perintah statistik dengan fungsi lain seperti`filter`,, `fields` `bin`**
Anda dapat menggabungkan dua `stats` perintah dengan perintah lain seperti `filter` dan `fields` dalam satu kueri. Misalnya, kueri berikut menemukan jumlah alamat IP yang berbeda dalam sesi dan menemukan jumlah sesi berdasarkan platform klien, memfilter alamat IP tersebut, dan akhirnya menemukan rata-rata permintaan sesi per platform klien.
```
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
```
Anda dapat menggunakan `bin` dan `dateceil` berfungsi dalam kueri dengan beberapa `stats` perintah. Misalnya, kueri berikut pertama-tama menggabungkan pesan menjadi blok 5 menit, kemudian menggabungkan blok 5 menit tersebut menjadi blok 10 menit dan menghitung volume lalu lintas tertinggi, terendah, dan rata-rata dalam setiap blok 10 menit.
```
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)
```
**Catatan dan batasan**
Kueri dapat memiliki maksimal dua `stats` perintah. Kuota ini tidak dapat diubah.
Jika Anda menggunakan `limit` perintah `sort` atau, itu harus muncul setelah `stats` perintah kedua. Jika sebelum `stats` perintah kedua, kueri tidak valid.
Ketika kueri memiliki dua `stats` perintah, sebagian hasil dari kueri tidak mulai ditampilkan sampai `stats` agregasi pertama selesai.
Dalam `stats` perintah kedua dalam satu kueri, Anda hanya dapat merujuk ke bidang yang didefinisikan dalam `stats` perintah pertama. Misalnya, kueri berikut tidak valid karena `@message` bidang tidak akan tersedia setelah `stats` agregasi pertama.
```
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
```
Bidang apa pun yang Anda referensikan setelah `stats` perintah pertama harus didefinisikan dalam `stats` perintah pertama itu.
```
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
```
**penting**
`bin`Fungsi selalu secara implisit menggunakan bidang. `@timestamp` Ini berarti Anda tidak dapat menggunakan `bin` `stats` perintah kedua tanpa menggunakan `stats` perintah pertama untuk menyebarkan `timestamp` bidang. Misalnya, kueri berikut tidak valid.
```
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
```
Sebagai gantinya, tentukan `@timestamp` bidang di `stats` perintah pertama, dan kemudian Anda dapat menggunakannya dengan `dateceil` `stats` perintah kedua seperti pada contoh berikut.
```
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)
```
## Fungsi untuk digunakan dengan statistik
CloudWatch Logs Insights mendukung fungsi agregasi statistik dan fungsi non-agregasi statistik.
Gunakan fungsi statsaggregation dalam `stats` perintah dan sebagai argumen untuk fungsi lainnya.
| Fungsi | Tipe hasil | Deskripsi |
| --- | --- | --- |
| `avg(fieldName: NumericLogField)` | nomor | Rata-rata nilai di bidang yang ditentukan. |
| `count()` `count(fieldName: LogField)` | nomor | Menghitung log acara. `count()` (atau `count(*)`) menghitung semua kejadian yang dikembalikan oleh kueri, sementara `count(fieldName)` menghitung semua catatan yang menyertakan nama bidang yang ditentukan. |
| `count_distinct(fieldName: LogField)` | nomor | Mengembalikan jumlah nilai unik untuk bidang. Jika bidang memiliki kardinalitas yang sangat tinggi (mengandung banyak nilai unik), nilai yang dikembalikan oleh `count_distinct` hanyalah sebuah perkiraan. |
| `max(fieldName: LogField)` | LogFieldValue | Nilai maksimum untuk bidang log ini dalam log yang dikueri. |
| `min(fieldName: LogField)` | LogFieldValue | Nilai minimum untuk bidang log ini dalam log yang dikueri. |
| `pct(fieldName: LogFieldValue, percent: number)` | LogFieldValue | Persentil menunjukkan posisi relatif dari nilai dalam rangkaian data. Misalnya, `pct(@duration, 95)` mengembalikan nilai `@duration` di mana 95 persen dari nilai `@duration` lebih rendah dari nilai ini, dan 5 persen lebih tinggi dari nilai ini. |
| `stddev(fieldName: NumericLogField)` | nomor | Standar deviasi di bidang yang ditentukan. |
| `sum(fieldName: NumericLogField)` | nomor | Jumlah nilai di bidang yang ditentukan. |
**Statistik fungsi non-agregasi**
Gunakan fungsi non-agregasi dalam `stats` perintah dan sebagai argumen untuk fungsi lainnya.
| Fungsi | Tipe hasil | Deskripsi |
| --- | --- | --- |
| `earliest(fieldName: LogField)` | LogField | Mengembalikan nilai `fieldName` dari log acara yang memiliki stempel waktu paling awal dalam log yang dikueri. |
| `latest(fieldName: LogField)` | LogField | Mengembalikan nilai `fieldName` dari log acara yang memiliki stempel waktu paling akhir dalam log yang dikueri. |
| `sortsFirst(fieldName: LogField)` | LogField | Mengembalikan nilai `fieldName` yang ada di urutan pertama dalam log yang dikueri. |
| `sortsLast(fieldName: LogField)` | LogField | Mengembalikan nilai `fieldName` yang ada di urutan terakhir dalam log yang dikueri. |
# batasan
Gunakan `limit` untuk menentukan jumlah peristiwa log yang Anda ingin kueri Anda kembalikan. Jika Anda menghilangkan`limit`, kueri akan mengembalikan sebanyak 10.000 peristiwa log dalam hasil.
Misalnya, contoh berikut hanya mengembalikan 25 peristiwa log terbaru
```
fields @timestamp, @message | sort @timestamp desc | limit 25
```
# dedup
Gunakan `dedup` untuk menghapus hasil duplikat berdasarkan nilai tertentu di bidang yang Anda tentukan. Anda dapat menggunakan `dedup` dengan satu atau lebih bidang. Jika Anda menentukan satu bidang dengan`dedup`, hanya satu peristiwa log yang dikembalikan untuk setiap nilai unik bidang itu. Jika Anda menentukan beberapa bidang, maka satu peristiwa log dikembalikan untuk setiap kombinasi nilai unik untuk bidang tersebut.
Duplikat dibuang berdasarkan urutan pengurutan, dengan hanya hasil pertama dalam urutan pengurutan yang disimpan. Kami menyarankan Anda mengurutkan hasil Anda sebelum memasukkannya melalui `dedup` perintah. Jika hasilnya tidak diurutkan sebelum dijalankan`dedup`, maka urutan urutan menurun default yang digunakan `@timestamp` digunakan.
Nilai nol tidak dianggap duplikat untuk evaluasi. Peristiwa log dengan nilai null untuk salah satu bidang tertentu dipertahankan. Untuk menghilangkan bidang dengan nilai nol, gunakan **`filter`**menggunakan `isPresent(field)` fungsi.
Satu-satunya perintah query yang dapat Anda gunakan dalam kueri setelah `dedup` perintah adalah`limit`.
Saat Anda menggunakan `dedup` kueri, konsol akan menampilkan pesan seperti **Menampilkan X catatan Y**, di mana X adalah jumlah hasil deduplikasi dan Y adalah jumlah total rekaman yang cocok sebelum deduplikasi. Ini menunjukkan bahwa catatan duplikat telah dihapus dan tidak berarti bahwa data hilang.
**Contoh: Lihat hanya peristiwa log terbaru untuk setiap nilai unik bidang bernama `server`**
Contoh berikut menampilkan`timestamp`,`server`,`severity`, dan `message` bidang hanya untuk acara terbaru untuk setiap nilai unik`server`.
```
fields @timestamp, server, severity, message
| sort @timestamp desc
| dedup server
```
Untuk lebih banyak contoh kueri Wawasan CloudWatch Log, lihat. [Kueri umum](CWL_QuerySyntax-examples.md#CWL_QuerySyntax-examples-general)
# membuka kedok
Gunakan `unmask` untuk menampilkan semua konten peristiwa log yang memiliki beberapa konten yang disembunyikan karena kebijakan perlindungan data. Untuk menggunakan perintah ini, Anda harus memiliki `logs:Unmask` izin.
Untuk informasi selengkapnya tentang perlindungan data di grup log, lihat[Membantu melindungi data log sensitif dengan masking](mask-sensitive-log-data.md).
# unnest
Gunakan `unnest` untuk meratakan daftar yang diambil sebagai masukan untuk menghasilkan beberapa catatan dengan satu catatan untuk setiap elemen dalam daftar. Berdasarkan jumlah item yang terkandung dalam bidang, perintah ini membuang catatan saat ini dan menghasilkan catatan baru. Setiap catatan mencakup`unnested_field`, yang mewakili item. Semua bidang lainnya berasal dari catatan asli.
Input untuk `unnest` adalah`LIST`, yang berasal dari `jsonParse` fungsi. Untuk informasi selengkapnya, lihat [Jenis struktur](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax-operations-functions.html#CWL_QuerySyntax-structure-types). Tipe lain, seperti`MAP`, `String` dan`numbers`, diperlakukan sebagai daftar dengan satu item di`unnest`.
**Struktur perintah**
Contoh berikut menjelaskan format perintah ini.
```
unnest field into unnested_field
```
**Kueri contoh**
Contoh berikut mem-parsing string objek JSON dan memperluas daftar peristiwa bidang.
```
fields jsonParse(@message) as json_message
| unnest json_message.events into event
| display event.name
```
Peristiwa log untuk kueri contoh ini bisa berupa string JSON sebagai berikut:
```
{
"events": [
{
"name": "exception"
},
{
"name": "user action"
}
]
}
```
Dalam hal ini, kueri sampel menghasilkan dua catatan dalam hasil kueri, satu dengan `event.name` as `exception` dan yang lain dengan `event.name` sebagai **tindakan pengguna**
**Kueri contoh**
Contoh berikut meratakan daftar dan kemudian menyaring item.
```
fields jsonParse(@message) as js
| unnest js.accounts into account
| filter account.type = "internal"
```
**Kueri contoh**
Contoh berikut meratakan daftar agregasi.
```
fields jsonParse(trimmedData) as accounts
| unnest accounts into account
| stats sum(account.droppedSpans) as n by account.accountId
| sort n desc
| limit 10
```
# pencarian
Gunakan `lookup` untuk memperkaya hasil kueri Anda dengan data referensi dari tabel pencarian. Tabel pencarian berisi data CSV yang Anda unggah ke Amazon CloudWatch Logs. Saat kueri berjalan, `lookup` perintah mencocokkan bidang dalam peristiwa log Anda terhadap bidang di tabel pencarian dan menambahkan bidang keluaran yang ditentukan ke hasil.
Gunakan tabel pencarian untuk skenario pengayaan data seperti memetakan pengguna IDs ke detail pengguna, kode produk ke informasi produk, atau kode kesalahan untuk deskripsi kesalahan.
## Membuat dan mengelola tabel pencarian
Sebelum Anda dapat menggunakan `lookup` perintah dalam kueri, Anda harus membuat tabel pencarian. Anda dapat membuat dan mengelola tabel pencarian dari CloudWatch konsol atau dengan menggunakan Amazon CloudWatch Logs API.
**Untuk membuat tabel pencarian (konsol)**
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi, pilih **Pengaturan**, lalu pilih tab **Log**.
1. Gulir ke **tabel Pencarian** dan pilih **Kelola**.
1. Pilih **Buat tabel pencarian**.
1. Masukkan nama untuk tabel pencarian. Nama hanya dapat berisi karakter alfanumerik, tanda hubung, dan garis bawah.
1. (Opsional) Masukkan deskripsi.
1. Unggah file CSV. File harus menyertakan baris header dengan nama kolom, gunakan pengkodean UTF-8, dan tidak melebihi 10 MB.
1. (Opsional) Tentukan AWS KMS kunci untuk mengenkripsi data tabel.
1. Pilih **Buat**.
Setelah membuat tabel pencarian, Anda dapat melihatnya di editor kueri Wawasan CloudWatch Log. Pilih tab **Lookup tables** untuk menelusuri tabel yang tersedia dan bidangnya.
Untuk memperbarui tabel pencarian, pilih tabel dan pilih **Tindakan**, **Perbarui**. Unggah file CSV baru untuk menggantikan semua konten yang ada. Untuk menghapus tabel pencarian, pilih **Tindakan**, **Hapus**.
**catatan**
Anda dapat membuat hingga 100 tabel pencarian per akun per Wilayah AWS akun. File CSV dapat mencapai 10 MB. Anda juga dapat mengelola tabel pencarian dengan menggunakan Amazon CloudWatch Logs API. Untuk informasi selengkapnya, lihat [CreateLookupTable](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLookupTable.html)di *Referensi API Amazon CloudWatch Logs*.
**catatan**
Jika tabel pencarian dienkripsi dengan kunci KMS, penelepon harus memiliki `kms:Decrypt` izin pada kunci (kunci KMS yang digunakan untuk mengenkripsi tabel pencarian) untuk menggunakan `StartQuery` API dengan kueri yang mereferensikan tabel pencarian itu. Untuk informasi selengkapnya, lihat [Enkripsi tabel pencarian di CloudWatch Log menggunakan AWS Key Management Service](encrypt-lookup-tables-kms.md).
## Sintaks kueri untuk pencarian
**Struktur perintah**
Berikut ini menunjukkan format perintah ini.
```
lookup table lookup-field as log-field [,...] output-mode output-field[,...]
```
Perintah menggunakan argumen berikut:
+ `table`— Nama tabel pencarian yang akan digunakan.
+ `lookup-field`— Bidang di tabel pencarian untuk dicocokkan.
+ `log-field`— Bidang di acara log Anda untuk dicocokkan. Pertandingannya tepat dan peka huruf besar/kecil.
+ `output-mode`— Tentukan `OUTPUT` untuk menambahkan bidang output ke hasil. Jika bidang dengan nama yang sama sudah ada dalam peristiwa log, itu akan ditimpa.
+ `output-field`— Satu atau lebih bidang dari tabel pencarian untuk ditambahkan ke hasil.
**Contoh: Perkaya peristiwa log dengan detail pengguna**
Misalkan Anda memiliki grup log dengan peristiwa yang berisi `id` bidang, dan tabel pencarian bernama `user_data` dengan kolom`id`,, `name``email`, dan`department`. Kueri berikut memperkaya setiap peristiwa log dengan nama pengguna, email, dan departemen dari tabel pencarian.
```
fields action, status, name, email, department
| lookup user_data id OUTPUT name, email, department
```
**Contoh: Gunakan pencarian dengan agregasi**
Anda dapat menggunakan bidang output pencarian dengan fungsi agregasi. Kueri berikut memperkaya peristiwa log dengan detail pengguna dan kemudian menghitung peristiwa yang dikelompokkan berdasarkan alamat email.
```
fields user_id, action, username, email, department
| lookup user_data user_id OUTPUT username, email, department
| stats count(*) by email
```
**Contoh: Gunakan pencarian dengan filter**
Anda dapat memfilter hasil berdasarkan bidang yang dikembalikan oleh pencarian. Kueri berikut memperkaya peristiwa log dan kemudian memfilter untuk hanya menampilkan peristiwa dari departemen tertentu.
```
fields user_id, action
| lookup user_data user_id OUTPUT username, email, department
| filter department = "Engineering"
```
# Boolean, perbandingan, numerik, datetime, dan fungsi lainnya
CloudWatch Log Insights mendukung banyak operasi dan fungsi lain dalam kueri, seperti yang dijelaskan di bagian berikut.
**Topics**
+ [Operator aritmatika](#CWL_QuerySyntax-operations-arithmetic)
+ [Operator Boolean](#CWL_QuerySyntax-operations-Boolean)
+ [Operator perbandingan](#CWL_QuerySyntax-operations-comparison)
+ [Operator numerik](#CWL_QuerySyntax-operations-numeric)
+ [Jenis struktur](#CWL_QuerySyntax-structure-types)
+ [Fungsi datetime](#CWL_QuerySyntax-datetime)
+ [Fungsi umum](#CWL_QuerySyntax-general-functions)
+ [Fungsi JSON](#CWL_QuerySyntax-json-functions)
+ [Fungsi string alamat IP](#CWL_QuerySyntax-IPaddress-functions)
+ [Fungsi string](#CWL_QuerySyntax-string-functions)
## Operator aritmatika
Operator aritmatika menerima tipe data numerik sebagai argumen dan mengembalikan hasil numerik. Gunakan operator aritmatika dalam `filter` dan `fields` perintah dan sebagai argumen untuk fungsi lainnya.
| Operasi | Deskripsi |
| --- | --- |
| `a + b` | Penambahan |
| `a - b` | Pengurangan |
| `a * b` | Perkalian |
| `a / b` | Pembagian |
| `a ^ b` | Eksponensiasi (pengembalian) `2 ^ 3` `8` |
| `a % b` | Sisa atau modulus (pengembalian) `10 % 3` `1` |
## Operator Boolean
Gunakan operator Boolean`and`,`or`, dan`not`.
**catatan**
Gunakan operator Boolean hanya dalam fungsi yang mengembalikan nilai **TRUE** atau **FALSE**.
## Operator perbandingan
Operator perbandingan menerima semua tipe data sebagai argumen dan mengembalikan hasil Boolean. Gunakan operasi perbandingan dalam `filter` perintah dan sebagai argumen untuk fungsi lainnya.
| Operator | Deskripsi |
| --- | --- |
| `=` | Sama |
| `!=` | Tidak sama |
| `<` | Kurang dari |
| `>` | Lebih besar dari |
| `<=` | Kurang dari atau sama dengan |
| `>=` | Lebih besar dari atau sama dengan |
## Operator numerik
Operasi numerik menerima tipe data numerik sebagai argumen dan mengembalikan hasil numerik. Gunakan operasi numerik dalam `filter` dan `fields` perintah dan sebagai argumen untuk fungsi lainnya.
| Operasi | Tipe Hasil | Deskripsi |
| --- | --- | --- |
| `abs(a: number)` | number | Nilai absolut |
| `ceil(a: number)` | number | Bulat ke langit-langit (bilangan bulat terkecil yang lebih besar dari nilai) `a` |
| `floor(a: number)` | number | Bulat ke lantai (bilangan bulat terbesar yang lebih kecil dari nilai) `a` |
| `greatest(a: number, ...numbers: number[])` | number | Mengembalikan nilai terbesar |
| `least(a: number, ...numbers: number[])` | number | Mengembalikan nilai terkecil |
| `log(a: number)` | number | Log alami |
| `sqrt(a: number)` | number | Akar kuadrat |
## Jenis struktur
Peta atau daftar adalah tipe struktur dalam Wawasan CloudWatch Log yang memungkinkan Anda mengakses dan menggunakan atribut untuk kueri.
**Contoh: Untuk mendapatkan peta atau daftar**
Gunakan `jsonParse` untuk mengurai bidang yang berupa string json ke dalam peta atau daftar.
```
fields jsonParse(@message) as json_message
```
**Contoh: Untuk mengakses atribut**
Gunakan operator akses titik (map.attribute) untuk mengakses item di peta.. Jika atribut dalam peta berisi karakter khusus, gunakan backticks untuk melampirkan nama atribut (map.attributes. `special.char`).
```
fields jsonParse(@message) as json_message
| stats count() by json_message.status_code
```
Gunakan operator akses braket (list [index]) untuk mengambil item pada posisi tertentu dalam daftar.
```
fields jsonParse(@message) as json_message
| filter json_message.users[1].action = "PutData"
```
Bungkus karakter khusus dalam backticks (``) ketika karakter khusus hadir dalam nama kunci.
```
fields jsonParse(@message) as json_message
| filter json_message.`user.id` = "123"
```
**Contoh: hasil kosong**
Peta dan daftar diperlakukan sebagai null untuk fungsi string, nomor, dan datetime.
```
fields jsonParse(@message) as json_message
| display toupper(json_message)
```
Membandingkan peta dan daftar dengan bidang lain menghasilkan`false`.
**catatan**
Menggunakan peta dan daftar di `dedup``pattern`,`sort`,, dan `stats` tidak didukung.
## Fungsi datetime
**Fungsi Datetime**
Gunakan fungsi datetime dalam `fields` dan `filter` perintah dan sebagai argumen untuk fungsi lainnya. Gunakan fungsi ini untuk membuat bucket waktu untuk kueri dengan fungsi agregat. Gunakan periode waktu yang terdiri dari angka dan salah satu dari yang berikut:
+ `ms`untuk milidetik
+ `s`selama beberapa detik
+ `m`selama beberapa menit
+ `h`selama berjam-jam
Misalnya, `10m` adalah 10 menit, dan `1h` 1 jam.
**catatan**
Gunakan unit waktu yang paling tepat untuk fungsi datetime Anda. CloudWatch Log membatasi permintaan Anda sesuai dengan satuan waktu yang Anda pilih. Misalnya, ini membatasi 60 sebagai nilai maksimum untuk setiap permintaan yang menggunakan`s`. Jadi, jika Anda menentukan`bin(300s)`, CloudWatch Log sebenarnya mengimplementasikan ini sebagai 60 detik, karena 60 adalah jumlah detik dalam satu menit sehingga CloudWatch Log tidak akan menggunakan angka yang lebih tinggi dari 60 dengan`s`. Untuk membuat ember 5 menit, gunakan `bin(5m)` sebagai gantinya.
Tutup untuk `ms` adalah 1000, tutup untuk `s` dan `m` 60, dan tutupnya `h` adalah 24.
Tabel berikut berisi daftar fungsi datetime yang berbeda yang dapat Anda gunakan dalam perintah query. Tabel mencantumkan jenis hasil setiap fungsi dan berisi deskripsi dari setiap fungsi.
**Tip**
Saat Anda membuat perintah kueri, Anda dapat menggunakan pemilih interval waktu untuk memilih periode waktu yang ingin Anda kueri. Misalnya, Anda dapat mengatur periode waktu antara interval 5 dan 30 menit; interval 1, 3, dan 12 jam; atau kerangka waktu khusus. Anda juga dapat mengatur periode waktu antara tanggal tertentu.
| Fungsi | Tipe hasil | Deskripsi |
| --- | --- | --- |
| `bin(period: Period)` | Stempel waktu | Membulatkan nilai `@timestamp` ke periode waktu tertentu dan kemudian memotong. Misalnya, `bin(5m)` bulatkan nilai `@timestamp` ke 5 menit terdekat. Anda dapat menggunakan ini untuk mengelompokkan beberapa entri log bersama-sama dalam kueri. Contoh berikut mengembalikan jumlah pengecualian per jam: filter @message like /Exception/
| stats count(*) as exceptionCount by bin(1h)
| sort exceptionCount desc
Satuan waktu dan singkatan berikut didukung dengan `bin` fungsi tersebut. Untuk semua unit dan singkatan yang menyertakan lebih dari satu karakter, menambahkan s ke pluralisasi didukung. Jadi keduanya `hr` dan `hrs` bekerja untuk menentukan jam. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/AmazonCloudWatch/latest/logs/CWL_QuerySyntax-operations-functions.html) |
| `datefloor(timestamp: Timestamp, period: Period)` | Stempel waktu | Memotong stempel waktu ke periode tertentu. Misalnya, `datefloor(@timestamp, 1h)` memotong semua nilai `@timestamp` ke bagian bawah jam. |
| `dateceil(timestamp: Timestamp, period: Period)` | Stempel waktu | Membulatkan stempel waktu ke periode tertentu dan kemudian memotong. Misalnya, `dateceil(@timestamp, 1h)` memotong semua nilai `@timestamp` ke bagian atas jam. |
| `fromMillis(fieldName: number)` | Stempel waktu | Menafsirkan bidang input sebagai jumlah milidetik sejak jangka waktu Unix dan mengubahnya menjadi stempel waktu. |
| `toMillis(fieldName: Timestamp)` | nomor | Mengonversi stempel waktu yang ditemukan di bidang bernama menjadi angka yang mewakili milidetik sejak jangka waktu Unix. Misalnya, `toMillis(@timestamp)` mengubah stempel waktu `2022-01-14T13:18:031.000-08:00` menjadi. `1642195111000` |
| `now()` | number | Mengembalikan waktu pemrosesan query dimulai, dalam detik epoch. Fungsi ini tidak membutuhkan argumen. Anda dapat menggunakan ini untuk memfilter hasil kueri Anda sesuai dengan waktu saat ini. Misalnya, query berikut mengembalikan semua kesalahan 4xx dari dua jam terakhir: parse @message "Status Code: *;" as statusCode\n
| filter statusCode >= 400 and statusCode <= 499 \n
| filter toMillis(@timestamp) >= (now() * 1000 - 7200000)
Contoh berikut mengembalikan semua entri log dari lima jam terakhir yang berisi kata `error` atau `failure` fields @timestamp, @message
| filter @message like /(?i)(error|failure)/
| filter toMillis(@timestamp) >= (now() * 1000 - 18000000)
|
**catatan**
Saat ini, CloudWatch Logs Insights tidak mendukung pemfilteran log dengan stempel waktu yang dapat dibaca manusia.
## Fungsi umum
**Fungsi umum**
Gunakan fungsi umum dalam `fields` dan `filter` perintah dan sebagai argumen untuk fungsi lainnya.
| Fungsi | Tipe hasil | Deskripsi |
| --- | --- | --- |
| `ispresent(fieldName: LogField)` | Boolean | Mengembalikan `true` jika bidang ada |
| `coalesce(fieldName: LogField, ...fieldNames: LogField[])` | LogField | Mengembalikan nilai non-null pertama dari daftar |
## Fungsi JSON
**Fungsi JSON**
Gunakan fungsi JSON dalam `fields` dan `filter` perintah dan sebagai argumen untuk fungsi lainnya.
| Fungsi | Tipe hasil | Deskripsi |
| --- | --- | --- |
| `jsonParse(fieldName: string)` | Peta \$1 Daftar \$1 Kosong | Mengembalikan peta atau daftar ketika input adalah representasi string dari objek JSON atau array JSON. Mengembalikan nilai kosong, jika masukan bukan salah satu representasi. |
| `jsonStringify(fieldName: Map \| List)` | String | Mengembalikan string JSON dari peta atau daftar data. |
## Fungsi string alamat IP
**Fungsi string alamat IP**
Gunakan fungsi string alamat IP dalam `filter` dan `fields` perintah dan sebagai argumen untuk fungsi lainnya.
| Fungsi | Tipe hasil | Deskripsi |
| --- | --- | --- |
| `isValidIp(fieldName: string)` | boolean | Mengembalikan `true` jika bidang adalah valid IPv4 atau IPv6 alamat. |
| `isValidIpV4(fieldName: string)` | boolean | Mengembalikan `true` jika bidang adalah IPv4 alamat yang valid. |
| `isValidIpV6(fieldName: string)` | boolean | Mengembalikan `true` jika bidang adalah IPv6 alamat yang valid. |
| `isIpInSubnet(fieldName: string, subnet: string)` | boolean | Mengembalikan `true` jika bidang adalah valid IPv4 atau IPv6 alamat dalam v4 atau v6 subnet yang ditentukan. Saat Anda menentukan subnet, gunakan notasi CIDR seperti `192.0.2.0/24` atau`2001:db8::/32`, di mana `192.0.2.0` atau `2001:db8::` merupakan awal dari blok CIDR. |
| `isIpv4InSubnet(fieldName: string, subnet: string)` | boolean | Mengembalikan `true` jika bidang adalah IPv4 alamat yang valid dalam subnet v4 yang ditentukan. Saat Anda menentukan subnet, gunakan notasi CIDR seperti `192.0.2.0/24` di `192.0.2.0` mana awal blok CIDR.. |
| `isIpv6InSubnet(fieldName: string, subnet: string)` | boolean | Mengembalikan `true` jika bidang adalah IPv6 alamat yang valid dalam subnet v6 yang ditentukan. Saat Anda menentukan subnet, gunakan notasi CIDR seperti `2001:db8::/32` di `2001:db8::` mana awal blok CIDR. |
## Fungsi string
**Fungsi string**
Gunakan fungsi string dalam `fields` dan `filter` perintah dan sebagai argumen untuk fungsi lainnya.
| Fungsi | Tipe hasil | Deskripsi |
| --- | --- | --- |
| `isempty(fieldName: string)` | Bilangan | Mengembalikan `1` jika bidang tidak ada atau string kosong. |
| `isblank(fieldName: string)` | Bilangan | Mengembalikan `1` jika bidang tidak ada, string kosong, atau hanya berisi spasi. |
| `concat(str: string, ...strings: string[])` | string | Menyatukan string. |
| `ltrim(str: string)` `ltrim(str: string, trimChars: string)` | string | Jika fungsi tidak memiliki argumen kedua, ia menghapus spasi putih dari kiri string. Jika fungsi memiliki argumen string kedua, itu tidak menghapus spasi putih. Sebaliknya, ia menghapus karakter `trimChars` dari kiri`str`. Misalnya, `ltrim("xyZxyfooxyZ","xyZ")` mengembalikan `"fooxyZ"`. |
| `rtrim(str: string)` `rtrim(str: string, trimChars: string)` | string | Jika fungsi tidak memiliki argumen kedua, ia menghapus spasi putih dari kanan string. Jika fungsi memiliki argumen string kedua, itu tidak menghapus spasi putih. Sebaliknya, ia menghapus karakter `trimChars` dari dari kanan`str`. Misalnya, `rtrim("xyZfooxyxyZ","xyZ")` mengembalikan `"xyZfoo"`. |
| `trim(str: string)` `trim(str: string, trimChars: string)` | string | Jika fungsi tidak memiliki argumen kedua, ia menghapus spasi putih dari kedua ujung string. Jika fungsi memiliki argumen string kedua, itu tidak menghapus spasi putih. Sebaliknya, ia menghapus karakter `trimChars` dari kedua sisi`str`. Misalnya, `trim("xyZxyfooxyxyZ","xyZ")` mengembalikan `"foo"`. |
| `strlen(str: string)` | nomor | Mengembalikan panjang string dalam poin kode Unicode. |
| `toupper(str: string)` | string | Mengonversi string menjadi huruf besar. |
| `tolower(str: string)` | string | Mengonversi string menjadi huruf kecil. |
| `substr(str: string, startIndex: number)` `substr(str: string, startIndex: number, length: number)` | string | Mengembalikan substring dari indeks yang ditentukan oleh argumen angka ke akhir string. Jika fungsi memiliki argumen angka kedua, itu berisi panjang substring yang akan diambil. Misalnya, `substr("xyZfooxyZ",3, 3)` mengembalikan `"foo"`. |
| `replace(fieldName: string, searchValue: string, replaceValue: string)` | string | Mengganti semua `searchValue` dalam `fieldName: string`dengan `replaceValue`. Misalnya, fungsi `replace(logGroup,"smoke_test","Smoke")` mencari peristiwa log di mana bidang `logGroup` berisi nilai string `smoke_test` dan menggantikan nilai dengan string. `Smoke` |
| `strcontains(str: string, searchValue: string)` | number | Mengembalikan 1 jika `str` berisi `searchValue` dan 0 sebaliknya. |
# Bidang yang berisi karakter khusus
Jika bidang berisi karakter non-alfanumerik selain `@` simbol atau periode (`.`), Anda harus mengelilingi bidang dengan karakter backtick (). ``` Misalnya, bidang log `foo-bar` harus diapit backticks (``foo-bar``) karena berisi karakter non-alfanumerik, tanda hubung (). `-`
# Gunakan alias dan komentar dalam kueri
Buat kueri yang berisi alias. Gunakan alias untuk mengganti nama bidang log atau saat mengekstrak nilai ke dalam bidang. Gunakan kata kunci `as` untuk memberikan bidang log atau menghasilkan alias. Anda dapat menggunakan lebih dari satu alias dalam kueri. Anda dapat menggunakan alias dalam perintah berikut:
+ `fields`
+ `parse`
+ `sort`
+ ` stats `
Contoh berikut menunjukkan cara membuat kueri yang berisi alias.
**Contoh**
Query berisi alias dalam `fields` perintah.
```
fields @timestamp, @message, accountId as ID
| sort @timestamp desc
| limit 20
```
Query mengembalikan nilai-nilai untuk bidang`@timestamp`,`@message`, dan`accountId`. Hasilnya diurutkan dalam urutan menurun dan dibatasi hingga 20. Nilai untuk `accountId` tercantum di bawah alias`ID`.
**Contoh**
Kueri berisi alias dalam `stats` perintah `sort` dan.
```
stats count(*) by duration as time
| sort time desc
```
Kueri menghitung berapa kali bidang `duration` terjadi di grup log dan mengurutkan hasil dalam urutan menurun. Nilai untuk `duration` tercantum di bawah alias`time`.
## Gunakan komentar
CloudWatch Log Insights mendukung komentar dalam kueri. Gunakan karakter hash (**\$1**) untuk memicu komentar. Anda dapat menggunakan komentar untuk mengabaikan baris dalam kueri atau kueri dokumen.
**Contoh: Query**
Ketika query berikut dijalankan, baris kedua diabaikan.
```
fields @timestamp, @message, accountId
# | filter accountId not like "7983124201998"
| sort @timestamp desc
| limit 20
```
# Memulai dengan Logs Insights QL: Tutorial kueri
Bagian berikut mencakup contoh tutorial kueri untuk membantu Anda memulai dengan Wawasan Log QL.
**Topics**
+ [Tutorial: Jalankan dan modifikasi kueri sampel](CWL_AnalyzeLogData_RunSampleQuery.md)
+ [Tutorial: Jalankan kueri dengan fungsi agregasi](CWL_AnalyzeLogData_AggregationQuery.md)
+ [Tutorial: Jalankan kueri yang menghasilkan visualisasi yang dikelompokkan berdasarkan bidang log](CWL_AnalyzeLogData_VisualizationFieldQuery.md)
+ [Tutorial: Jalankan kueri yang menghasilkan visualisasi deret waktu](CWL_AnalyzeLogData_VisualizationQuery.md)
# Tutorial: Jalankan dan modifikasi kueri sampel
Tutorial berikut membantu Anda memulai dengan Wawasan CloudWatch Log. Anda menjalankan kueri sampel di Logs Insights QL, lalu melihat cara memodifikasi dan menjalankannya kembali.
Untuk menjalankan kueri, Anda harus sudah memiliki log yang disimpan di CloudWatch Log. Jika Anda sudah menggunakan CloudWatch Log dan memiliki grup log dan aliran log yang disiapkan, Anda siap untuk memulai. Anda mungkin juga sudah memiliki log jika Anda menggunakan layanan seperti AWS CloudTrail, Amazon Route 53, atau Amazon VPC dan Anda telah menyiapkan log dari layanan tersebut untuk masuk ke CloudWatch Log. Untuk informasi selengkapnya tentang mengirim CloudWatch log ke Log, lihat[Memulai dengan CloudWatch Log](CWL_GettingStarted.md).
Kueri dalam Wawasan CloudWatch Log mengembalikan sekumpulan bidang dari peristiwa log atau hasil agregasi matematis atau operasi lain yang dilakukan pada peristiwa log. Tutorial ini menunjukkan kueri yang mengembalikan daftar log acara.
## Jalankan kueri sampel
**Untuk menjalankan kueri sampel Wawasan CloudWatch Log**
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi, pilih **Log**, lalu pilih **Wawasan Log**.
Pada halaman **Wawasan Log**, editor kueri berisi kueri default di Logs Insights QL yang menampilkan 20 peristiwa log terbaru.
1. Dalam menu tarik-turun **Pilih grup log**, pilih satu atau beberapa grup log untuk kueri.
Jika ini adalah akun pemantauan dalam pengamatan CloudWatch lintas akun, Anda dapat memilih grup log di akun sumber serta akun pemantauan. Satu kueri dapat menanyakan log dari akun yang berbeda sekaligus.
Anda dapat memfilter grup log berdasarkan nama grup log, ID akun, atau label akun.
Saat Anda memilih grup log di kelas log Standar, Wawasan CloudWatch Log secara otomatis mendeteksi bidang data dalam grup. Untuk melihat bidang yang ditemukan, pilih menu **Fields** di dekat kanan atas halaman.
**catatan**
Bidang yang ditemukan hanya didukung untuk grup log di kelas log Standar. Untuk informasi selengkapnya tentang kelas log, lihat[Kelas log](CloudWatch_Logs_Log_Classes.md).
1. (Opsional) Gunakan pemilih interval waktu untuk memilih periode waktu yang ingin Anda kueri.
Anda dapat memilih antara interval 5 dan 30 menit; interval 1, 3, dan 12 jam; atau kerangka waktu khusus.
1. Pilih **Jalankan** untuk melihat hasilnya.
Untuk tutorial ini, hasilnya mencakup 20 peristiwa log yang paling baru ditambahkan.
CloudWatch Log menampilkan grafik batang peristiwa log dalam grup log dari waktu ke waktu. Grafik batang tidak hanya menunjukkan peristiwa dalam tabel, tetapi juga distribusi peristiwa dalam grup log yang cocok dengan kueri dan jangka waktu.
1. Untuk melihat semua bidang untuk peristiwa log yang dikembalikan, pilih ikon tarik-turun segitiga di sebelah kiri acara bernomor.
## Ubah kueri sampel
Dalam tutorial ini, Anda mengubah kueri sampel untuk menunjukkan 50 log acara terbaru.
Jika Anda belum menjalankan tutorial sebelumnya, lakukan sekarang. Tutorial ini dimulai di tempat tutorial sebelumnya berakhir.
**catatan**
Beberapa contoh kueri yang disediakan dengan penggunaan CloudWatch Log Insights `head` atau `tail` perintah sebagai gantinya. `limit` Perintah ini akan tidak digunakan lagi dan telah diganti dengan `limit`. Gunakan `limit`, dan bukan `head` atau `tail` dalam semua kueri yang Anda tulis.
**Untuk memodifikasi CloudWatch kueri sampel Wawasan Log**
1. Di editor kueri, ubah **20** menjadi **50**, lalu pilih **Run** (Jalankan).
Hasil kueri baru akan muncul. Dengan asumsi ada cukup data dalam grup log selama rentang waktu default, sekarang ada 50 log acara yang tercantum.
1. (Opsional) Anda dapat menyimpan kueri yang telah Anda buat. Untuk menyimpan kueri ini, pilih **Save** (Simpan). Untuk informasi selengkapnya, lihat [Simpan dan jalankan kembali kueri CloudWatch Logs Insights](CWL_Insights-Saving-Queries.md).
## Tambahkan perintah filter ke kueri sampel
Tutorial ini menunjukkan cara membuat perubahan yang lebih kuat pada kueri di editor kueri. Dalam tutorial ini, Anda memfilter hasil kueri sebelumnya berdasarkan bidang dalam log acara yang diambil.
Jika Anda belum menjalankan tutorial sebelumnya, lakukan sekarang. Tutorial ini dimulai di tempat tutorial sebelumnya berakhir.
**Untuk menambahkan perintah filter ke kueri sebelumnya**
1. Tentukan bidang untuk memfilter. Untuk melihat bidang paling umum yang CloudWatch terdeteksi Log dalam peristiwa log yang terdapat dalam grup log yang dipilih dalam 15 menit terakhir, dan persentase peristiwa log di mana setiap bidang muncul, pilih **Bidang** di sisi kanan halaman.
Untuk melihat bidang yang terdapat dalam log acara tertentu, pilih ikon di sebelah kiri baris tersebut.
Bidang **awsRegion** mungkin muncul dalam log acara Anda, tergantung pada kejadian yang ada di log Anda. Untuk bagian selanjutnya dalam tutorial ini, kita menggunakan **awsRegion** sebagai bidang filter, tetapi Anda dapat menggunakan bidang yang berbeda jika bidang tersebut tidak tersedia.
1. Di kotak editor kueri, tempatkan kursor Anda setelah **50**, lalu tekan Enter.
1. Di baris baru, pertama masukkan \$1 (karakter pipa) dan spasi. Perintah dalam kueri Wawasan CloudWatch Log harus dipisahkan oleh karakter pipa.
1. Masukkan **filter awsRegion="us-east-1"**.
1. Pilih **Jalankan**.
Kueri berjalan lagi, dan sekarang menampilkan 50 hasil terbaru yang cocok dengan filter baru.
Jika Anda memfilter dengan bidang yang berbeda dan mendapat hasil kesalahan, Anda mungkin perlu melakukan escape pada nama bidang. Jika nama bidang mengandung karakter non-alfanumerik, Anda harus menempatkan karakter backtick (`) sebelum dan sesudah nama bidang (misalnya, **`error-code`="102"**).
Anda harus menggunakan karakter backtick untuk nama bidang yang berisi karakter non-alfanumerik, tetapi tidak untuk nilai. Nilai selalu ada dalam tanda kutip (").
Log Insights QL mencakup kemampuan kueri yang kuat, termasuk beberapa perintah dan dukungan untuk ekspresi reguler, matematika, dan operasi statistik. Untuk informasi selengkapnya, lihat [CloudWatch Sintaks kueri bahasa Wawasan Log](CWL_QuerySyntax.md).
# Tutorial: Jalankan kueri dengan fungsi agregasi
Anda dapat menggunakan fungsi agregasi dengan `stats` perintah dan sebagai argumen untuk fungsi lainnya. Dalam tutorial ini, Anda menjalankan perintah query yang menghitung jumlah peristiwa log yang berisi bidang tertentu. Perintah query mengembalikan jumlah total yang dikelompokkan berdasarkan nilai bidang tertentu atau nilai. Untuk informasi selengkapnya tentang fungsi agregasi, lihat [Operasi dan fungsi yang didukung](https://docs.aws.amazon.com/en_us/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html#CWL_QuerySyntax-operations-functions) di *Panduan Pengguna CloudWatch Log Amazon*.
**Untuk menjalankan kueri dengan fungsi agregasi**
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi, pilih **Log**, lalu pilih **Wawasan Log**.
1. Konfirmasikan bahwa tab **QL Wawasan Log** dipilih.
1. Dalam menu tarik-turun **Pilih grup log**, pilih satu atau beberapa grup log untuk kueri.
Jika ini adalah akun pemantauan dalam pengamatan CloudWatch lintas akun, Anda dapat memilih grup log di akun sumber serta akun pemantauan. Satu kueri dapat menanyakan log dari akun yang berbeda sekaligus.
Anda dapat memfilter grup log berdasarkan nama grup log, ID akun, atau label akun.
Saat Anda memilih grup CloudWatch log, Wawasan Log secara otomatis mendeteksi bidang data dalam grup log jika itu adalah grup log kelas Standar. Untuk melihat bidang yang ditemukan, pilih menu **Fields** di dekat kanan atas halaman.
1. Hapus kueri default di editor kueri, dan masukkan perintah berikut:
```
stats count(*) by fieldName
```
1. Ganti *fieldName* dengan bidang yang ditemukan dari menu **Fields**.
Menu **Fields** terletak di kanan atas halaman dan menampilkan semua bidang yang ditemukan yang mendeteksi Wawasan CloudWatch Log di grup log Anda.
1. Pilih **Jalankan** untuk melihat hasil kueri.
Hasil kueri menunjukkan jumlah catatan dalam grup log Anda yang cocok dengan perintah kueri dan jumlah total yang dikelompokkan berdasarkan nilai atau nilai bidang yang ditentukan.
# Tutorial: Jalankan kueri yang menghasilkan visualisasi yang dikelompokkan berdasarkan bidang log
Ketika menjalankan kueri yang menggunakan fungsi `stats` untuk mengelompokkan hasil yang dikembalikan oleh nilai dari satu atau beberapa bidang dalam entri log, Anda dapat melihat hasilnya sebagai diagram batang, diagram lingkaran, grafik garis, atau grafik area bertumpuk. Hal ini membantu memvisualisasikan tren dalam log Anda dengan lebih efisien.
**Untuk menjalankan kueri untuk visualisasi**
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi, pilih **Log**, lalu pilih **Wawasan Log**.
1. Dalam menu tarik-turun **Pilih grup log**, pilih satu atau beberapa grup log untuk kueri.
Jika ini adalah akun pemantauan dalam pengamatan CloudWatch lintas akun, Anda dapat memilih grup log di akun sumber serta akun pemantauan. Satu kueri dapat menanyakan log dari akun yang berbeda sekaligus.
Anda dapat memfilter grup log berdasarkan nama grup log, ID akun, atau label akun.
1. Di editor kueri, hapus konten saat ini, masukkan fungsi `stats` berikut ini, lalu pilih **Run query** (Jalankan kueri).
```
stats count(*) by @logStream
| limit 100
```
Hasilnya menunjukkan jumlah log acara dalam grup log untuk setiap pengaliran log. Hasilnya terbatas hanya 100 baris.
1. Pilih tab **Visualization** (Visualisasi).
1. Pilih panah di sebelah **Line** (Garis), lalu pilih **Bar** (Batang).
Akan muncul diagram batang yang menampilkan balok untuk setiap pengaliran log.
# Tutorial: Jalankan kueri yang menghasilkan visualisasi deret waktu
Ketika menjalankan kueri yang menggunakan fungsi `bin()` untuk mengelompokkan hasil yang dikembalikan menurut jangka waktu, Anda dapat melihat hasilnya sebagai grafik garis, grafik area bertumpuk, diagram lingkaran, atau diagram batang. Hal ini membantu memvisualisasikan tren dalam log acara dengan lebih efisien dari waktu ke waktu.
**Untuk menjalankan kueri untuk visualisasi**
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi, pilih **Log**, lalu pilih **Wawasan Log**.
1. Konfirmasikan bahwa tab **QL Wawasan Log** dipilih.
1. Dalam menu tarik-turun **Pilih grup log**, pilih satu atau beberapa grup log untuk kueri.
Jika ini adalah akun pemantauan dalam pengamatan CloudWatch lintas akun, Anda dapat memilih grup log di akun sumber serta akun pemantauan. Satu kueri dapat menanyakan log dari akun yang berbeda sekaligus.
Anda dapat memfilter grup log berdasarkan nama grup log, ID akun, atau label akun.
1. Di editor kueri, hapus konten saat ini, masukkan fungsi `stats` berikut ini, lalu pilih **Run query** (Jalankan kueri).
```
stats count(*) by bin(30s)
```
Hasilnya menunjukkan jumlah peristiwa log dalam grup log yang diterima oleh CloudWatch Log untuk setiap periode 30 detik.
1. Pilih tab **Visualization** (Visualisasi).
Hasilnya ditampilkan sebagai grafik garis. Untuk beralih ke diagram batang, diagram lingkaran, atau diagram area bertumpuk, pilih panah di samping **Line** (Garis) di kiri atas grafik.
# Kueri Sampel
Bagian ini berisi daftar perintah kueri umum dan berguna yang dapat Anda jalankan di [CloudWatchkonsol](https://console.aws.amazon.com/cloudwatch/). Untuk informasi tentang cara menjalankan perintah kueri, lihat [Tutorial: Menjalankan dan memodifikasi contoh kueri](https://docs.aws.amazon.com/en_us/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_RunSampleQuery.html) di *Panduan Pengguna Amazon CloudWatch Logs*.
Untuk informasi selengkapnya tentang sintaks kueri, lihat[CloudWatch Sintaks kueri bahasa Wawasan Log](CWL_QuerySyntax.md).
**Topics**
+ [Kueri umum](#CWL_QuerySyntax-examples-general)
+ [Kueri untuk log Lambda](#CWL_QuerySyntax-examples-Lambda)
+ [Kueri untuk log aliran VPC Amazon](#CWL_QuerySyntax-examples-VPC)
+ [Kueri untuk log Route 53](#CWL_QuerySyntax-examples-Route53)
+ [Kueri untuk log CloudTrail](#CWL_QuerySyntax-examples-CloudTrail)
+ [Pertanyaan untuk Amazon API Gateway](#CWL_QuerySyntax-examples-APIGateway)
+ [Pertanyaan untuk gateway NAT](#CWL_QuerySyntax-examples-NATGateway)
+ [Kueri untuk log server Apache](#CWL_QuerySyntax-examples-Apache)
+ [Kueri untuk Amazon EventBridge](#CWL_QuerySyntax-examples-EventBridge)
+ [Contoh perintah parse](#CWL_QuerySyntax-examples-parse)
## Kueri umum
**Temukan 25 peristiwa log yang paling baru ditambahkan.**
```
fields @timestamp, @message | sort @timestamp desc | limit 25
```
**Dapatkan daftar jumlah pengecualian per jam.**
```
filter @message like /Exception/
| stats count(*) as exceptionCount by bin(1h)
| sort exceptionCount desc
```
**Dapatkan daftar peristiwa log yang bukan pengecualian.**
```
fields @message | filter @message not like /Exception/
```
**Dapatkan peristiwa log terbaru untuk setiap nilai unik `server` bidang.**
```
fields @timestamp, server, severity, message
| sort @timestamp asc
| dedup server
```
**Dapatkan peristiwa log terbaru untuk setiap nilai unik `server` bidang untuk setiap `severity` jenis.**
```
fields @timestamp, server, severity, message
| sort @timestamp desc
| dedup server, severity
```
## Kueri untuk log Lambda
**Tentukan jumlah memori overprovisioned.**
```
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
```
**Buat laporan latensi.**
```
filter @type = "REPORT" |
stats avg(@duration), max(@duration), min(@duration) by bin(5m)
```
**Cari pemanggilan fungsi lambat, dan hilangkan permintaan duplikat yang dapat muncul dari percobaan ulang atau kode sisi klien. Dalam query ini, `@duration` adalah dalam milidetik.**
```
fields @timestamp, @requestId, @message, @logStream
| filter @type = "REPORT" and @duration > 1000
| sort @timestamp desc
| dedup @requestId
| limit 20
```
## Kueri untuk log aliran VPC Amazon
**Temukan 15 transfer paket teratas di seluruh host:**
```
stats sum(packets) as packetsTransferred by srcAddr, dstAddr
| sort packetsTransferred desc
| limit 15
```
**Temukan transfer 15 byte teratas untuk host pada subnet tertentu.**
```
filter isIpv4InSubnet(srcAddr, "192.0.2.0/24")
| stats sum(bytes) as bytesTransferred by dstAddr
| sort bytesTransferred desc
| limit 15
```
**Temukan alamat IP yang menggunakan UDP sebagai protokol transfer data.**
```
filter protocol=17 | stats count(*) by srcAddr
```
**Temukan alamat IP tempat catatan aliran dilewati selama jendela pengambilan.**
```
filter logStatus="SKIPDATA"
| stats count(*) by bin(1h) as t
| sort t
```
**Temukan satu catatan untuk setiap koneksi, untuk membantu memecahkan masalah konektivitas jaringan.**
```
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
```
## Kueri untuk log Route 53
**Temukan distribusi catatan per jam berdasarkan jenis kueri.**
```
stats count(*) by queryType, bin(1h)
```
**Temukan 10 DNS resolver dengan jumlah permintaan tertinggi.**
```
stats count(*) as numRequests by resolverIp
| sort numRequests desc
| limit 10
```
**Temukan jumlah catatan berdasarkan domain dan subdomain di mana server gagal menyelesaikan permintaan DNS.**
```
filter responseCode="SERVFAIL" | stats count(*) by queryName
```
## Kueri untuk log CloudTrail
**Temukan jumlah entri log untuk setiap layanan, jenis acara, dan AWS Wilayah.**
```
stats count(*) by eventSource, eventName, awsRegion
```
**Temukan host Amazon EC2 yang dimulai atau dihentikan di Wilayah tertentu AWS .**
```
filter (eventName="StartInstances" or eventName="StopInstances") and awsRegion="us-east-2"
```
**Temukan AWS Wilayah, nama pengguna, dan ARNs pengguna IAM yang baru dibuat.**
```
filter eventName="CreateUser"
| fields awsRegion, requestParameters.userName, responseElements.user.arn
```
**Temukan jumlah catatan di mana pengecualian terjadi saat menjalankan API`UpdateTrail`.**
```
filter eventName="UpdateTrail" and ispresent(errorCode)
| stats count(*) by errorCode, errorMessage
```
**Temukan entri log di mana TLS 1.0 atau 1.1 digunakan**
```
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
```
**Temukan jumlah panggilan per layanan yang menggunakan TLS versi 1.0 atau 1.1**
```
filter tlsDetails.tlsVersion in [ "TLSv1", "TLSv1.1" ]
| stats count(*) as numOutdatedTlsCalls by eventSource
| sort numOutdatedTlsCalls desc
```
## Pertanyaan untuk Amazon API Gateway
Temukan 10 kesalahan 4XX terakhir
```
fields @timestamp, status, ip, path, httpMethod
| filter status>=400 and status<=499
| sort @timestamp desc
| limit 10
```
Identifikasi 10 Amazon API Gateway permintaan yang paling lama berjalan di grup log akses Anda Amazon API Gateway
```
fields @timestamp, status, ip, path, httpMethod, responseLatency
| sort responseLatency desc
| limit 10
```
Kembalikan daftar jalur API paling populer di grup log Amazon API Gateway akses Anda
```
stats count(*) as requestCount by path
| sort requestCount desc
| limit 10
```
Membuat laporan latensi integrasi untuk grup log Amazon API Gateway akses Anda
```
filter status=200
| stats avg(integrationLatency), max(integrationLatency),
min(integrationLatency) by bin(1m)
```
## Pertanyaan untuk gateway NAT
Jika Anda melihat biaya yang lebih tinggi dari biasanya dalam AWS tagihan Anda, Anda dapat menggunakan Wawasan CloudWatch Log untuk menemukan kontributor teratas. Untuk informasi selengkapnya tentang perintah kueri berikut, [lihat Bagaimana cara menemukan kontributor teratas untuk lalu lintas melalui gateway NAT di VPC saya?](https://aws.amazon.com/premiumsupport/knowledge-center/vpc-find-traffic-sources-nat-gateway/) di halaman dukungan AWS premium.
**catatan**
Dalam perintah kueri berikut, ganti “x.x.x.x” dengan IP pribadi gateway NAT Anda, dan ganti “y.y” dengan dua oktet pertama dari rentang CIDR VPC Anda.
**Temukan contoh yang mengirimkan lalu lintas terbanyak melalui gateway NAT Anda.**
```
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
```
**Tentukan lalu lintas yang menuju dan dari instance di gateway NAT Anda.**
```
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
```
**Tentukan tujuan internet yang paling sering berkomunikasi dengan instance di VPC Anda untuk upload dan download.**
*****Untuk upload*****
```
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
```
*****Untuk unduhan*****
```
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
```
## Kueri untuk log server Apache
Anda dapat menggunakan Wawasan CloudWatch Log untuk menanyakan log server Apache. Untuk informasi selengkapnya tentang kueri berikut, lihat [Menyederhanakan log server Apache dengan Wawasan CloudWatch Log](https://aws.amazon.com/blogs/mt/simplifying-apache-server-logs-with-amazon-cloudwatch-logs-insights/) di Blog Operasi & Migrasi AWS Cloud.
**Temukan bidang yang paling relevan, sehingga Anda dapat meninjau log akses Anda dan memeriksa lalu lintas di jalur */admin* aplikasi Anda.**
```
fields @timestamp, remoteIP, request, status, filename| sort @timestamp desc
| filter filename="/var/www/html/admin"
| limit 20
```
**Temukan nomor permintaan GET unik yang mengakses halaman utama Anda dengan kode status “200" (sukses).**
```
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
```
**Temukan berapa kali layanan Apache Anda dimulai ulang.**
```
fields @timestamp, function, process, message
| filter message like "resuming normal operations"
| sort @timestamp desc
| limit 20
```
## Kueri untuk Amazon EventBridge
Dapatkan jumlah EventBridge acara yang dikelompokkan berdasarkan jenis detail acara
```
fields @timestamp, @message
| stats count(*) as numberOfEvents by `detail-type`
| sort numberOfEvents desc
```
## Contoh perintah parse
**Gunakan ekspresi glob untuk mengekstrak bidang`@user`,`@method`, dan `@latency` dari bidang log `@message` dan kembalikan latensi rata-rata untuk setiap kombinasi unik dan. `@method` `@user`**
```
parse @message "user=*, method:*, latency := *" as @user,
@method, @latency | stats avg(@latency) by @method,
@user
```
**Gunakan ekspresi reguler untuk mengekstrak bidang`@user2`,`@method2`, dan `@latency2` dari bidang log `@message` dan kembalikan latensi rata-rata untuk setiap kombinasi unik `@method2` dan`@user2`.**
```
parse @message /user=(?.*?), method:(?.*?),
latency := (?.*?)/ | stats avg(latency2) by @method2,
@user2
```
**Mengekstrak bidang`loggingTime`, `loggingType` dan`loggingMessage`, memfilter ke log peristiwa yang berisi `ERROR` atau `INFO` string, dan kemudian hanya menampilkan `loggingMessage` dan `loggingType` bidang untuk peristiwa yang berisi `ERROR` string.**
```
FIELDS @message
| PARSE @message "* [*] *" as loggingTime, loggingType, loggingMessage
| FILTER loggingType IN ["ERROR", "INFO"]
| DISPLAY loggingMessage, loggingType = "ERROR" as isError
```
# Bandingkan (diff) dengan rentang waktu sebelumnya
Anda dapat menggunakan Wawasan CloudWatch Log dengan QL Wawasan Log untuk membandingkan perubahan dalam peristiwa log Anda dari waktu ke waktu. Anda dapat membandingkan peristiwa log yang dicerna selama rentang waktu terakhir dengan log dari periode waktu sebelumnya. Atau, Anda dapat membandingkan dengan periode waktu sebelumnya yang serupa. Ini dapat membantu Anda menemukan apakah kesalahan dalam log Anda baru-baru ini diperkenalkan atau sudah terjadi, dan dapat membantu Anda menemukan tren lainnya.
Kueri perbandingan hanya mengembalikan pola dalam hasil, bukan peristiwa log mentah. Pola yang dikembalikan akan membantu Anda dengan cepat melihat tren dan perubahan dalam peristiwa log dari waktu ke waktu. Setelah Anda menjalankan kueri perbandingan dan mendapatkan hasil pola, Anda dapat melihat contoh peristiwa log mentah untuk pola yang Anda minati. Untuk informasi selengkapnya tentang pola log, lihat[Analisis pola](CWL_AnalyzeLogData_Patterns.md).
Saat Anda menjalankan kueri perbandingan, kueri Anda dianalisis terhadap dua periode waktu yang berbeda: periode kueri asli yang Anda pilih, dan periode perbandingan. Periode perbandingan selalu sama panjangnya dengan periode kueri asli Anda. Interval waktu default untuk perbandingan adalah sebagai berikut.
+ **Periode sebelumnya** — Membandingkan dengan periode waktu sebelum periode waktu kueri Anda.
+ **Hari sebelumnya** — Membandingkan dengan periode waktu satu hari sebelum periode waktu kueri Anda.
+ **Minggu sebelumnya** — Bandingkan dengan periode waktu satu minggu sebelum periode waktu kueri Anda.
+ **Bulan sebelumnya** — Membandingkan dengan periode waktu satu bulan sebelum periode waktu kueri Anda.
**catatan**
Kueri yang menggunakan perbandingan dikenakan biaya yang mirip dengan menjalankan satu kueri Wawasan CloudWatch Log selama rentang waktu gabungan. Untuk informasi lebih lanjut, lihat [Amazon CloudWatch Harga](https://aws.amazon.com/cloudwatch/pricing/).
**Untuk menjalankan kueri perbandingan**
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi, pilih **Log**, **Wawasan Log**.
Kueri default muncul di kotak kueri.
1. Konfirmasikan bahwa tab **QL Wawasan Log** dipilih.
1. Simpan kueri default atau masukkan kueri yang berbeda.
1. Di menu drop-down **Pilih grup log**, pilih satu atau beberapa grup log untuk kueri.
1. (Opsional) Gunakan pemilih interval waktu untuk memilih periode waktu yang ingin Anda kueri. Kueri default adalah untuk jam data log sebelumnya.
1. Dengan pemilih rentang waktu, pilih **Bandingkan**. Kemudian pilih periode waktu sebelumnya yang ingin Anda bandingkan dengan log asli, dan pilih **Terapkan**.
1. Pilih **Run query** (Jalankan kueri).
Untuk menyebabkan kueri mengambil data dari periode perbandingan, `diff` perintah ditambahkan ke kueri Anda.
1. Pilih tab **Patterns** untuk melihat hasilnya.
Tabel menampilkan informasi berikut:
+ Setiap **Pola**, dengan bagian variabel dari pola digantikan oleh simbol token dinamis``. *string*Ini adalah deskripsi dari jenis data yang diwakili oleh token. *number*Menunjukkan di mana dalam pola token ini muncul, dibandingkan dengan token dinamis lainnya. Untuk informasi selengkapnya, lihat [Analisis pola](CWL_AnalyzeLogData_Patterns.md).
+ **Jumlah peristiwa** adalah jumlah peristiwa log dengan pola itu dalam periode waktu asli yang lebih terkini.
+ **Perbedaan jumlah peristiwa** adalah perbedaan antara jumlah peristiwa log yang cocok dalam periode waktu saat ini versus periode waktu perbandingan. Berbeda positif berarti ada lebih banyak peristiwa seperti itu dalam periode waktu saat ini.
+ **Deskripsi perbedaan** secara singkat merangkum perubahan pola itu antara periode waktu saat ini dan periode perbandingan.
+ **Jenis keparahan** adalah kemungkinan tingkat keparahan peristiwa log dengan pola ini, berdasarkan kata-kata yang ditemukan dalam peristiwa log seperti`FATAL`,`ERROR`, dan. `WARN`
1. Untuk memeriksa lebih lanjut salah satu pola dalam daftar, pilih ikon di kolom **Inspect** untuk salah satu pola.
Panel **pemeriksaan Pola** muncul dan menampilkan yang berikut:
+ **Pola**. Pilih token dalam pola untuk menganalisis nilai token tersebut.
+ Histogram yang menunjukkan jumlah kemunculan pola selama rentang waktu yang ditanyakan. Ini dapat membantu Anda mengidentifikasi tren menarik seperti peningkatan tiba-tiba dalam terjadinya suatu pola.
+ Tab **Log samples** menampilkan beberapa peristiwa log yang cocok dengan pola yang dipilih.
+ Tab **Nilai Token** menampilkan nilai token dinamis yang dipilih, jika Anda telah memilihnya.
**catatan**
Maksimal 10 nilai token ditangkap untuk setiap token. Jumlah token mungkin tidak tepat. CloudWatch Log menggunakan penghitung probabilistik untuk menghasilkan jumlah token, bukan nilai absolut.
+ Tab **pola Terkait** menampilkan pola lain yang sering terjadi mendekati waktu yang sama dengan pola yang Anda periksa. Misalnya, jika pola untuk `ERROR` pesan biasanya disertai dengan peristiwa log lain yang ditandai `INFO` dengan detail tambahan, pola itu ditampilkan di sini.
# Visualisasikan data log dalam grafik
Anda dapat menggunakan visualisasi seperti diagram batang, diagram garis, dan bagan area bertumpuk untuk mengidentifikasi pola dalam data log Anda dengan lebih efisien. CloudWatch Log Insights menghasilkan visualisasi untuk kueri yang menggunakan `stats` fungsi dan satu atau beberapa fungsi agregasi. Untuk informasi lebih lanjut, lihat [statistik.](CWL_QuerySyntax-Stats.md)
# OpenSearch Bahasa Pemrosesan Pipa (PPL)
Bagian ini berisi pengantar dasar untuk menanyakan CloudWatch Log menggunakan OpenSearch PPL. Dengan PPL, Anda dapat mengambil, menanyakan, dan menganalisis data menggunakan perintah piped-together, sehingga lebih mudah untuk memahami dan menyusun kueri yang kompleks. Sintaksnya didasarkan pada pipa Unix, dan memungkinkan rantai perintah untuk mengubah dan memproses data. Dengan PPL, Anda dapat memfilter dan mengumpulkan data, dan menggunakan serangkaian matematika, string, tanggal, kondisional, dan fungsi lainnya yang kaya untuk analisis.
Termasuk `SOURCE` dalam kueri PPL adalah cara yang berguna untuk menentukan indeks bidang grup log, dan sumber data untuk disertakan dalam kueri saat Anda menggunakan AWS CLI atau API untuk membuat kueri. `SOURCE`Perintah hanya didukung di API AWS CLI dan, bukan di CloudWatch konsol. Saat Anda menggunakan CloudWatch konsol untuk memulai kueri, Anda menggunakan antarmuka konsol untuk menentukan grup log dan nama dan jenis sumber data.
Gunakan `aws:fieldIndex` untuk mengembalikan data yang diindeks saja, dengan memaksa kueri untuk memindai hanya grup log yang diindeks pada bidang yang Anda tentukan dalam kueri. Grup log yang relevan dipilih secara otomatis, berdasarkan bidang yang ditentukan dalam `filterIndex` perintah. Ini mengurangi volume yang dipindai dengan melewatkan grup log yang tidak memiliki peristiwa log yang berisi bidang yang ditentukan dalam kueri, dan hanya memindai grup log yang cocok dengan nilai yang ditentukan dalam kueri untuk indeks bidang ini. Gunakan `aws:fieldIndex` untuk menentukan nama bidang, bersama dengan nama bidang dan nilai dalam perintah sumber untuk menanyakan hanya data yang diindeks yang berisi bidang dan nilai yang ditentukan. Untuk informasi selengkapnya, lihat [Buat indeks bidang untuk meningkatkan kinerja kueri dan mengurangi volume pemindaian](CloudWatchLogs-Field-Indexing.md)
Anda dapat menggunakan OpenSearch PPL untuk kueri grup log di Kelas Log Standar.
**catatan**
Untuk informasi tentang semua perintah kueri OpenSearch PPL yang didukung di CloudWatch Log dan informasi terperinci tentang sintaks dan pembatasan, lihat [perintah PPL yang didukung di Panduan](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/supported-ppl.html) Pengembang OpenSearch Layanan.
Untuk informasi tentang bahasa kueri lain yang dapat Anda gunakan lihat, [Wawasan CloudWatch Log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html), [SQL OpenSearch Layanan](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_SQL.html), dan [CloudWatch Metrics Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/query_with_cloudwatch-metrics-insights.html)
| Perintah atau fungsi | Kueri contoh | Deskripsi |
| --- | --- | --- |
| ladang | `fields field1, field2` | Menampilkan satu set bidang yang membutuhkan proyeksi. |
| join | `LEFT JOIN left=l, right=r on l.id = r.id `join_right_lg` \| fields l.field_1, r.field_2` | Bergabung dengan dua kumpulan data bersama-sama. |
| di mana | `where field1="success" \| where field2 != "i-023fe0a90929d8822" \| fields field3, field4, field5,field6 \| head 1000` | Memfilter data berdasarkan kondisi yang Anda tentukan. |
| AWS: FieldIndex | `source = [`aws:fieldIndex`="region", `region` = "us-west-2"] \| where status = 200 \| head 10` | Mengembalikan data yang diindeks saja, dengan memaksa kueri untuk memindai hanya grup log yang diindeks pada bidang yang Anda tentukan dalam kueri. |
| statistik | `stats count(), count(field1), min(field1), max(field1), avg(field1) by field2 \| head 1000` | Melakukan agregasi dan perhitungan |
| mengurai | `parse field1 ".*/(?[^/]+$)" \| where field2 = "requestId" \| fields field1, field2 \| head 1000` | Mengekstrak pola ekspresi reguler (regex) dari string dan menampilkan pola yang diekstraksi. Pola yang diekstraksi dapat digunakan lebih lanjut untuk membuat bidang baru atau menyaring data. |
| menyortir | `stats count(), count(field1), min(field1) as field1Alias, max(`field1`), avg(`field1`) by field2 \| sort -field1Alias \| head 1000` | Urutkan hasil yang ditampilkan dengan nama bidang. Gunakan sort - FieldName untuk mengurutkan dalam urutan menurun. |
| eval | `eval field2 = field1 * 2 \| fields field1, field2 \| head 20` | Memodifikasi atau memproses nilai bidang dan menyimpannya di bidang yang berbeda. Ini berguna untuk memodifikasi kolom secara matematis, menerapkan fungsi string ke kolom, atau menerapkan fungsi tanggal ke kolom. |
| ganti nama | `rename field2 as field1 \| fields field1;` | Mengganti nama satu atau beberapa bidang di hasil pencarian. |
| kepala | `fields `@message` \| head 20` | Membatasi hasil kueri yang ditampilkan ke baris N pertama. |
| atas | `top 2 field1 by field2` | Menemukan nilai yang paling sering untuk sebuah bidang. |
| dedup | `dedup field1 \| fields field1, field2, field3` | Menghapus entri duplikat berdasarkan bidang yang Anda tentukan. |
| langka | `rare field1 by field2` | Menemukan nilai yang paling tidak sering dari semua bidang dalam daftar bidang. |
| subkueri | `where field_1 IN [ search source= `subquery_lg` \| fields field_2 ] \| fields id, field_1 ` | Melakukan kueri yang kompleks dan bersarang dalam pernyataan PPL Anda. |
| garis tren | `trendline sma(2, field1) as field1Alias` | Menghitung rata-rata bergerak bidang. |
| EventStats | `eventstats sum(field1) by field2` | Memperkaya data acara Anda dengan statistik ringkasan yang dihitung. Ini menganalisis bidang tertentu dalam acara Anda, menghitung berbagai ukuran statistik, dan kemudian menambahkan hasil ini ke setiap peristiwa asli sebagai bidang baru. |
| membesar | `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` | Memecah bidang yang berisi beberapa nilai menjadi baris terpisah, membuat baris baru untuk setiap nilai di bidang yang ditentukan. |
| fillnull | `fields `@timestamp`, error_code, status_code \| fillnull using status_code = "UNKNOWN", error_code = "UNKNOWN"` | Mengisi bidang null dengan nilai yang Anda berikan. Ini dapat digunakan dalam satu atau lebih bidang. |
| meratakan | `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) ` | Meratakan bidang. Bidang harus dari jenis ini: `struct` atau`array>`. |
| cidrmatch | `where cidrmatch(ip, '2003:db8::/32') \| fields ip ` | Memeriksa apakah alamat IP yang ditentukan berada dalam kisaran CIDR yang diberikan. |
| ringkasan lapangan | `where field1 != 200 \| fieldsummary includefields= field1 nulls=true` | Menghitung statistik dasar untuk setiap bidang (hitungan, hitungan berbeda, min, maks, rata-rata, stddev, dan rata-rata). |
| grok | `grok email '.+@%{HOSTNAME:host}' \| fields email, host` | Mem-parsing bidang teks dengan pola grok dan menambahkan hasilnya ke hasil pencarian. |
| Fungsi string | `eval field1Len = LENGTH(field1) \| fields field1Len` | Fungsi bawaan di PPL yang dapat memanipulasi dan mengubah data string dan teks dalam kueri PPL. Misalnya, mengonversi kasus, menggabungkan string, mengekstraksi bagian, dan membersihkan teks. |
| Fungsi Tanggal-Waktu | `eval newDate = ADDDATE(DATE('2020-08-26'), 1) \| fields newDate ` | Fungsi bawaan untuk menangani dan mengubah data tanggal dan stempel waktu dalam kueri PPL. Misalnya, date\$1add, date\$1format, datediff, date-sub, timestampadd, timestampdiff, current\$1timezone, utc\$1timestamp, dan current\$1date. |
| Fungsi syarat | `eval field2 = isnull(field1) \| fields field2, field1, field3` | Fungsi bawaan yang memeriksa kondisi bidang tertentu, dan mengevaluasi ekspresi secara kondisional. Misalnya, jika field1 adalah null, kembalikan field2. |
| Fungsi matematika | `eval field2 = ACOS(field1) \| fields field1` | Fungsi bawaan untuk melakukan perhitungan dan transformasi matematis dalam kueri PPL. Misalnya, abs (nilai absolut), bulat (angka bulat), sqrt (akar kuadrat), pow (perhitungan daya), dan ceil (membulatkan ke bilangan bulat terdekat). |
| CryptoGraphic fungsi | `eval crypto = MD5(field)\| head 1000` | Untuk menghitung hash dari bidang yang diberikan |
| Fungsi JSON | `eval valid_json = json('[1,2,3,{"f1":1,"f2":[5,6]},4]') \| fields valid_json` | Fungsi bawaan untuk menangani JSON termasuk array, ekstraksi, dan validasi. Misalnya, json\$1object, json\$1array, to\$1json\$1string, json\$1array\$1length, json\$1extract, json\$1keys, dan json\$1valid. |
## Lingkup kueri
Menyertakan SUMBER dalam kueri adalah cara yang berguna untuk menentukan grup log yang akan disertakan dalam kueri saat Anda menggunakan API AWS CLI atau untuk membuat kueri. Perintah SOURCE hanya didukung di API AWS CLI dan, bukan di CloudWatch konsol. Saat Anda menggunakan CloudWatch konsol untuk memulai kueri, Anda menggunakan antarmuka konsol untuk menentukan grup log dan nama dan jenis sumber data.
Perintah sumber PPL sekarang mendukung beberapa cara untuk menentukannya:
1. Grup log
1. Indeks bidang - Baru
1. Sumber dan tipe data - Baru
### Grup Log
Pemilihan sumber Grup Log dapat digunakan ketika pelanggan mengetahui grup log yang tepat yang perlu dicari
```
source = [lg:`/aws/lambda/my-function`] | where status = 200 | head 10
```
### Indeks Lapangan
Pemilihan sumber berbasis indeks bidang mengurangi jumlah data yang ditanyakan dengan membatasi hasil hanya pada data yang diindeks saat filter Anda menargetkan bidang yang telah diindeks. Grup log yang relevan dipilih secara otomatis, berdasarkan bidang yang ditentukan dalam `filterIndex` perintah. Untuk informasi selengkapnya tentang indeks bidang dan cara membuatnya, lihat [Membuat indeks bidang untuk meningkatkan kinerja kueri dan mengurangi volume pemindaian](CloudWatchLogs-Field-Indexing.md).
Gunakan `aws:fieldIndex` untuk mengembalikan data yang diindeks saja, dengan memaksa kueri untuk memindai hanya grup log yang diindeks pada bidang yang Anda tentukan dalam kueri. Untuk grup log ini yang diindeks di bidang ini, selanjutnya mengoptimalkan kueri dengan melewatkan grup log yang tidak memiliki peristiwa log yang berisi bidang yang ditentukan dalam kueri untuk bidang yang diindeks. Selanjutnya mengurangi volume yang dipindai dengan mencoba memindai hanya peristiwa log dari grup log ini yang cocok dengan nilai yang ditentukan dalam kueri untuk indeks bidang ini. Untuk informasi selengkapnya tentang indeks bidang dan cara membuatnya, lihat Membuat indeks bidang untuk meningkatkan kinerja kueri dan mengurangi volume pemindaian.
Dalam PPL, `aws:fieldIndex` digunakan untuk menentukan pasangan nilai kunci mana yang harus diperlakukan sebagai indeks. Sintaksnya adalah sebagai berikut
```
source = [`aws:fieldIndex`="region", `region` = "us-west-2"] | where status = 200 | head 10
```
dimana,
1. ``aws:fieldIndex`="region"`mengidentifikasi wilayah sebagai Indeks bidang.
1. Catatan: Alih-alih = pelanggan dapat menggunakan IN untuk menentukan beberapa indeks (contoh di bawah)
1. ``region`="us-west-2"`mengidentifikasi kondisi filter yang akan diterapkan
1. Catatan: Alih-alih = pelanggan dapat menggunakan IN untuk menentukan beberapa nilai (contoh di bawah)
Pelanggan dapat menentukan beberapa FieldIndex sebagai berikut
```
source = [`aws:fieldIndex` IN ("status", "region"), `status` = 200, `region` IN ("us-west-2", "us-east-1")] | head 10
```
### Sumber dan Jenis Data
Sumber data dan pemilihan sumber berbasis tipe dapat digunakan ketika pelanggan mengetahui sumber data pasti mana yang perlu ditanyakan. Kueri ini dijalankan melalui satu atau lebih grup log yang berisi sumber dan jenis data yang ditentukan.
```
source = [ds:`data_source.type`] | where status = 200 | head 10
```
#### PPL yang didukung untuk kueri sumber data
Untuk mendukung kasus penggunaan kueri sumber data di PPL, Anda dapat menggunakan klausa pemilih sumber dinamis. Dengan menggunakan sintaks ini, Anda dapat meminta sumber data dengan menentukannya dalam perintah pencarian. Anda dapat menentukan hingga 10 sumber data.
**Sintaksis**
```
source=[ds:`DataSource1.Type1`, ds:`DataSource2.Type2`, ...ds:`DataSourcen.Typen`]
```
**Contoh kueri**
```
search source=[ds:`DataSource1.Type1`, ds:`DataSource2.Type2`] | fields field1, field2
```
### Contoh gabungan
Pelanggan dapat menentukan semua operator pemilihan sumber dalam urutan apa pun & hasilnya akan menjadi persimpangan dari semua kondisi yang diterapkan.
Misalnya,/aws/lambda/my-function-1 mungkin berisi beberapa sumber & tipe data termasuk berbagai indeks, ketika kueri berikut dijalankan, hasil yang dikembalikan hanya akan memiliki peristiwa sumber dan tipe DataSource 1.Type1 dan cocok dengan kriteria 'status' = 200.
```
search source=[
ds:`DataSource1.Type1`,
lg:`/aws/lambda/my-function-1`,
`aws:fieldIndex` IN ("status"), `status` = 200
]
```
## Pembatasan
Pembatasan berikut berlaku saat Anda menggunakan OpenSearch PPL untuk melakukan kueri di Wawasan CloudWatch Log.
+ Anda tidak dapat menggunakan perintah bergabung atau subquery dengan kueri sumber data.
# OpenSearch Bahasa Kueri Terstruktur (SQL)
Bagian ini berisi pengantar dasar untuk query CloudWatch Log menggunakan OpenSearch SQL. Ini memberikan opsi yang akrab jika Anda terbiasa bekerja dengan database relasional. OpenSearch SQL menawarkan subset fungsionalitas SQL, menjadikannya pilihan yang baik untuk melakukan kueri ad-hoc dan tugas analisis data. Dengan OpenSearch SQL, Anda dapat menggunakan perintah seperti SELECT, FROM, WHERE, GROUP BY, HAVING, dan berbagai perintah dan fungsi SQL lainnya. Anda dapat mengeksekusi JOINs di seluruh grup log, mengkorelasikan data di seluruh grup log menggunakan sub-kueri, dan menggunakan kumpulan kaya fungsi JSON, matematika, string, kondisional, dan SQL lainnya untuk melakukan analisis yang kuat pada data log dan keamanan.
Gunakan `filterIndex` untuk mengembalikan data yang diindeks saja, dengan memaksa kueri untuk memindai hanya grup log yang diindeks pada bidang yang Anda tentukan dalam kueri. Kurangi volume yang dipindai dengan melewatkan grup log yang tidak memiliki peristiwa log yang berisi bidang yang ditentukan dalam kueri, dan hanya memindai grup log yang cocok dengan nilai yang ditentukan dalam kueri untuk indeks bidang ini. Gunakan `filterIndex` untuk menentukan nama bidang, bersama dengan nama bidang dan nilai untuk kueri hanya data yang diindeks yang berisi bidang dan nilai yang ditentukan.
Anda dapat menggunakan OpenSearch SQL untuk kueri grup log di Kelas Log Standar. SQL juga mendukung query menggunakan nama sumber data dan tipe sumber data.
**catatan**
Tabel berikut mencantumkan perintah dan fungsi SQL yang didukung di CloudWatch Log Untuk informasi tentang semua perintah OpenSearch SQL termasuk sintaks, lihat perintah [SQL yang didukung dalam Panduan Pengembang](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/supported-directquery-sql.html) OpenSearch Layanan.
Untuk informasi tentang bahasa kueri lain yang dapat Anda gunakan, lihat [Wawasan CloudWatch Log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html), [PPL OpenSearch Layanan](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_PPL.html), dan. [CloudWatch Metrics Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/query_with_cloudwatch-metrics-insights.html)
## Perintah SQL yang didukung
**catatan**
Di kolom query contoh, ganti sesuai `` kebutuhan tergantung pada sumber data yang Anda kueri.
| Perintah atau fungsi | Kueri contoh | Deskripsi |
| --- | --- | --- |
| SELECT | `SELECT `@message`, Operation FROM `LogGroupA`` | Menampilkan nilai yang diproyeksikan. |
| FROM | `SELECT `@message`, Operation FROM `LogGroupA`` | Klausa bawaan yang menentukan tabel sumber atau tampilan untuk mengambil data, mendukung berbagai jenis gabungan dan subkueri. |
| WHERE | `SELECT * FROM `LogGroupA` WHERE Operation = 'x'` | Memfilter peristiwa log berdasarkan kriteria bidang yang disediakan. |
| FilterIndex | `SELECT * FROM `filterIndex('region' = 'us-east-1')` WHERE status = 200 LIMIT 10;` | Mengembalikan data yang diindeks saja, dengan memaksa kueri untuk memindai hanya grup log yang diindeks pada bidang yang Anda tentukan dalam kueri. |
| GROUP BY | `SELECT `@logStream`, COUNT(*) as log_count FROM `LogGroupA` GROUP BY `@logStream`` | Grup mencatat peristiwa berdasarkan kategori dan menemukan rata-rata berdasarkan statistik. |
| MEMILIKI | `SELECT `@logStream`, COUNT(*) as log_count FROM `LogGroupA` GROUP BY `@logStream` HAVING log_count > 100` | Memfilter hasil berdasarkan kondisi pengelompokan. |
| ORDER BY | `SELECT * FROM `LogGroupA` ORDER BY `@timestamp` DESC` | Memesan hasil berdasarkan bidang dalam klausa ORDER BY. Anda dapat mengurutkan dalam urutan menurun atau naik. |
| BERGABUNG | `SELECT A.`@message`, B.`@timestamp`FROM `LogGroupA` as A INNER JOIN `LogGroupB` as B ON A.`requestId` = B.`requestId`` | Bergabung dengan hasil untuk dua tabel berdasarkan bidang umum. Inner JOIN atau Left Outer Join harus ditentukan |
| LIMIT | `Select * from `LogGroupA` limit 10` | Membatasi hasil kueri yang ditampilkan ke baris N pertama. |
| Fungsi string | `SELECT upper(Operation) , lower(Operation), Operation FROM `LogGroupA`` | Fungsi bawaan di SQL yang dapat memanipulasi dan mengubah string dan data teks dalam kueri SQL. Misalnya, mengonversi kasus, menggabungkan string, mengekstraksi bagian, dan membersihkan teks. |
| Fungsi tanggal | `SELECT current_date() as today, date_add(current_date(), 30) as thirty_days_later, last_day(current_date()) as month_end FROM `LogGroupA`` | Fungsi bawaan untuk menangani dan mengubah data tanggal dan stempel waktu dalam kueri SQL. Misalnya, date\$1add, date\$1format, datediff, dan current\$1date. |
| Fungsi kondisional | `SELECT Operation, IF(Error > 0, 'High', 'Low') as error_category FROM `LogGroupA`;` | Fungsi bawaan yang melakukan tindakan berdasarkan kondisi tertentu, atau yang mengevaluasi ekspresi secara kondisional. Misalnya, CASE dan IF. |
| Fungsi agregat | `SELECT AVG(bytes) as bytesWritten FROM `LogGroupA`` | Fungsi bawaan yang melakukan perhitungan pada beberapa baris untuk menghasilkan nilai ringkasan tunggal. Misalnya, SUM, COUNT, AVG, MAX, dan MIN. |
| Fungsi JSON | `SELECT get_json_object(json_column, '$.name') as name FROM `LogGroupA`` | Fungsi bawaan untuk mengurai, mengekstrak, memodifikasi, dan menanyakan data berformat JSON dalam kueri SQL (misalnya, from\$1json, to\$1json, get\$1json\$1object, json\$1tuple) yang memungkinkan manipulasi struktur JSON dalam kumpulan data. |
| Fungsi array | `SELECT scores, size(scores) as length, array_contains(scores, 90) as has_90 FROM `LogGroupA`;` | Fungsi bawaan untuk bekerja dengan kolom tipe array dalam kueri SQL, memungkinkan operasi seperti mengakses, memodifikasi, dan menganalisis data array (misalnya, size, explode, array\$1contains). |
| Fungsi jendela | `SELECT field1, field2, RANK() OVER (ORDER BY field2 DESC) as field2Rank FROM `LogGroupA`;` | Fungsi bawaan yang melakukan perhitungan di serangkaian baris tertentu yang terkait dengan baris (jendela) saat ini, memungkinkan operasi seperti peringkat, total berjalan, dan rata-rata bergerak. Misalnya, ROW\$1NUMBER, RANK, LAG, dan LEAD |
| Fungsi konversi | `SELECT CAST('123' AS INT) as converted_number, CAST(123 AS STRING) as converted_string FROM `LogGroupA`` | Fungsi bawaan untuk mengonversi data dari satu jenis ke jenis lainnya dalam kueri SQL, memungkinkan transformasi tipe data dan konversi format. Misalnya, CAST, TO\$1DATE, TO\$1TIMESTAMP, dan BINARY. |
| Fungsi predikat | `SELECT scores, size(scores) as length, array_contains(scores, 90) as has_90 FROM `LogGroupA`;` | Fungsi bawaan yang mengevaluasi kondisi dan mengembalikan nilai boolean (benar/salah) berdasarkan kriteria atau pola yang ditentukan. Misalnya, IN, LIKE, BETWEEN, IS NULL, dan EXISTS. |
| Pilih beberapa grup log | `SELECT lg1.field1, lg1.field2 from `logGroups( logGroupIdentifier: ['LogGroup1', 'LogGroup2'])` as lg1 where lg1.field3= "Success"` | Memungkinkan Anda menentukan beberapa grup log dalam pernyataan SELECT |
| Pilih beberapa sumber data | `SELECT ds1.field1, ds1.field2 from `dataSource(['DataSource1', 'DataSource2'])` as ds1 where ds1.field3= "Success"` | Memungkinkan Anda menentukan beberapa sumber data dalam pernyataan SELECT |
## SQL yang didukung untuk multi-log-group kueri
Untuk mendukung kasus penggunaan untuk menanyakan beberapa grup log di SQL, Anda dapat menggunakan perintah. `logGroups` Dengan menggunakan sintaks ini, Anda dapat menanyakan beberapa grup log dengan menentukannya dalam perintah FROM.
Sintaksis:
```
`logGroups(
logGroupIdentifier: ['LogGroup1','LogGroup2', ...'LogGroupn']
)
```
Dalam sintaks ini, Anda dapat menentukan hingga 50 grup log dalam `logGroupIdentifier` parameter. Untuk mereferensikan grup log di akun pemantauan, gunakan ARNs alih-alih `LogGroup` nama.
Contoh kueri:
```
SELECT LG1.Column1, LG1.Column2 from `logGroups(
logGroupIdentifier: ['LogGroup1', 'LogGroup2']
)` as LG1 WHERE LG1.Column1 = 'ABC'
```
Sintaks berikut yang melibatkan beberapa grup log setelah `FROM` pernyataan TIDAK didukung saat menanyakan CloudWatch Log.
```
SELECT Column1, Column2 FROM 'LogGroup1', 'LogGroup2', ...'LogGroupn'
WHERE Column1 = 'ABC'
```
## SQL yang didukung untuk kueri sumber data
Untuk mendukung kasus penggunaan kueri sumber data di SQL, Anda dapat menggunakan perintah DataSource. Dengan menggunakan sintaks ini, Anda dapat meminta sumber data dengan menentukannya dalam perintah. `FROM` Anda dapat menentukan hingga 10 sumber data.
**Sintaksis**
```
`dataSource(
['DataSource1', 'DataSource2', ...'DataSourcen']
)`
```
**Contoh kueri**
```
SELECT DS1.Column1, DS1.Column2 from `dataSource(
['DataSource1', 'DataSource2']
)` as DS1 WHERE DS1.Column1 = 'ABC'
```
## Lingkup kueri
Di API AWS CLI dan, Anda dapat menentukan log mana yang akan dikueri dengan menggunakan grup log, sumber dan jenis data, serta indeks bidang.
### Grup Log
Pemilihan sumber Grup Log dapat digunakan ketika pelanggan mengetahui grup log yang tepat yang perlu dicari
```
SELECT * FROM `logGroups(logGroupIdentifier: ['/aws/lambda/my-function'])`;
```
### Sumber dan Jenis Data
Pelanggan dapat menanyakan log mereka menggunakan nama sumber data dan tipe sumber data.
Sumber data dan pemilihan sumber berbasis tipe dapat digunakan ketika pelanggan mengetahui sumber data pasti mana yang perlu ditanyakan. Kueri ini dijalankan melalui satu atau lebih grup log yang berisi sumber dan jenis data yang ditentukan.
Untuk mendukung kasus penggunaan kueri sumber data di SQL, Anda dapat menggunakan perintah DataSource. Dengan menggunakan sintaks ini, Anda dapat meminta sumber data dengan menentukannya dalam perintah FROM. Anda dapat menentukan hingga 10 sumber data.
Sintaksis:
```
`dataSource(
['DataSource1.Type1', 'DataSource2.Type2', ...'DataSourcen.Typen']
)`
```
Contoh kueri:
```
SELECT DS1.Column1, DS1.Column2 from `dataSource(
['DataSource1.Type1', 'DataSource2.Type2']
)` as DS1 WHERE DS1.Column1 = 'ABC'
```
Untuk informasi selengkapnya tentang kueri berdasarkan sumber data, lihat[Gunakan aspek untuk mengelompokkan dan menjelajahi log](CloudWatchLogs-Facets.md).
### Contoh gabungan
Pelanggan dapat menentukan semua operator pemilihan sumber dalam backticks dalam urutan apa pun dan hasilnya akan didasarkan pada persimpangan semua kondisi yang diterapkan.
Misalnya,/aws/lambda/my-function-1 mungkin berisi beberapa sumber & tipe data termasuk berbagai indeks, ketika kueri berikut dijalankan, hasil yang dikembalikan hanya akan memiliki peristiwa sumber dan tipe DataSource 1.Type1 dan cocok dengan kriteria 'status' = 200.
```
SELECT * FROM `
logGroups(logGroupIdentifier: ['/aws/lambda/my-function'])
filterIndex('status' = 200)
dataSource(['DataSource1.Type1'])
`;
```
### Indeks Lapangan
Pemilihan sumber berbasis Indeks Bidang secara otomatis mengidentifikasi grup log yang relevan saat filter Anda menargetkan bidang yang diindeks, mengurangi volume pemindaian dan runtime kueri.
Gunakan `filterIndex` untuk mengembalikan data yang diindeks saja, dengan memaksa kueri untuk memindai hanya grup log yang diindeks pada bidang yang Anda tentukan dalam kueri. Untuk grup log ini yang diindeks di bidang ini, selanjutnya mengoptimalkan kueri dengan melewatkan grup log yang tidak memiliki peristiwa log yang berisi bidang yang ditentukan dalam kueri untuk bidang yang diindeks. Selanjutnya mengurangi volume yang dipindai dengan mencoba memindai hanya peristiwa log dari grup log ini yang cocok dengan nilai yang ditentukan dalam kueri untuk indeks bidang ini. Untuk informasi selengkapnya tentang indeks bidang dan cara membuatnya, lihat [Membuat indeks bidang untuk meningkatkan kinerja kueri dan mengurangi volume pemindaian](CloudWatchLogs-Field-Indexing.md).
Dalam SQL, FilterIndex digunakan untuk menentukan pasangan nilai kunci mana yang harus diperlakukan sebagai indeks. Sintaksnya adalah sebagai berikut
```
SELECT * FROM `filterIndex('region' = 'us-east-1')`;
```
dimana,
1. filterIndex (...) menentukan, memperlakukan nilai-nilai kunci di dalamnya sebagai indeks bidang. Setiap pasangan nilai kunci dipisahkan dengan koma (contoh di bawah)
1. 'region' = 'us-east-1' menentukan kondisi aktual yang akan diterapkan
1. Catatan: Alih-alih = pelanggan dapat menggunakan IN untuk menentukan beberapa nilai (contoh di bawah)
Menggunakan beberapa filterIndex akan menggabungkan kondisi menggunakan “AND”. Dalam contoh, log yang cocok dengan status=200 dan region di us-east-1 atau us-west-2 akan ditanyakan.
```
SELECT * FROM `filterIndex('status' = 200, 'region' IN ['us-east-1', 'us-west-2'])`;
```
## Pembatasan
Pembatasan berikut berlaku saat Anda menggunakan OpenSearch SQL untuk melakukan kueri di Wawasan CloudWatch Log.
+ Anda hanya dapat menyertakan satu JOIN dalam pernyataan SELECT.
+ Anda tidak dapat menggunakan JOIN atau subquery dengan kueri sumber data.
+ Hanya satu tingkat subkueri bersarang yang didukung.
+ Beberapa kueri pernyataan yang dipisahkan oleh titik dua (;) tidak didukung.
+ Kueri yang berisi nama bidang yang identik tetapi berbeda hanya dalam kasus (seperti field1 dan FIELD1) tidak didukung.
Misalnya, kueri berikut tidak didukung:
```
Select AWSAccountId, AwsAccountId from LogGroup
```
Namun, kueri berikut didukung karena nama bidang (`@logStream`) identik di kedua grup log:
```
Select a.`@logStream`, b.`@logStream` from Table A INNER Join Table B on a.id = b.id
```
+ Fungsi dan ekspresi harus beroperasi pada nama bidang dan menjadi bagian dari pernyataan SELECT dengan grup log yang ditentukan dalam klausa FROM.
Misalnya, kueri ini tidak didukung:
```
SELECT cos(10) FROM LogGroup
```
Kueri ini didukung:
```
SELECT cos(field1) FROM LogGroup
```
+ Saat menggunakan perintah SQL atau PPL, lampirkan bidang tertentu di backticks agar berhasil menanyakannya. Backticks diperlukan untuk bidang dengan karakter khusus (non-alfabet dan non-numerik). Misalnya, lampirkan, `@message``Operation.Export`, dan `Test::Field` di backticks. Anda tidak perlu melampirkan bidang dengan nama abjad murni di backticks.
Contoh kueri dengan bidang sederhana:
```
SELECT SessionToken, Operation, StartTime FROM `LogGroup-A`
LIMIT 1000;
```
Kueri serupa dengan backticks ditambahkan:
```
SELECT `@SessionToken`, `@Operation`, `@StartTime` FROM `LogGroup-A` LIMIT 1000;
```
# Gunakan bahasa alami untuk menghasilkan dan memperbarui kueri Wawasan CloudWatch Log
CloudWatch Log mendukung kemampuan kueri bahasa alami untuk membantu Anda menghasilkan dan memperbarui kueri untuk [Wawasan CloudWatch Log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html), [PPL OpenSearch Layanan, SQL OpenSearch ](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_PPL.html) [Layanan](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_SQL.html), dan. [CloudWatch Metrics Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/query_with_cloudwatch-metrics-insights.html)
Dengan kemampuan ini, Anda dapat mengajukan pertanyaan tentang atau menjelaskan data CloudWatch Log yang Anda cari dalam bahasa Inggris biasa. Kemampuan bahasa alami menghasilkan kueri berdasarkan prompt yang Anda masukkan dan memberikan line-by-line penjelasan tentang cara kerja kueri. Anda juga dapat memperbarui kueri Anda untuk menyelidiki lebih lanjut data Anda.
Bergantung pada lingkungan Anda, Anda dapat memasukkan petunjuk seperti “Apa 100 alamat IP sumber teratas berdasarkan byte yang ditransfer?” dan “Temukan 10 permintaan fungsi Lambda paling lambat.”
**catatan**
Fitur kueri bahasa alami adalah layanan Regional. Untuk beberapa Wilayah, fitur ini membuat panggilan lintas wilayah ke Wilayah di Amerika Serikat untuk memproses permintaan kueri. Untuk informasi selengkapnya, lihat [Amazon CloudWatch memperluas dukungan wilayah untuk ringkasan hasil kueri bahasa alami dan pembuatan kueri](https://aws.amazon.com/about-aws/whats-new/2025/08/amazon-cloudwatch-region-support-query-result-summarization-query-generation/).
Untuk menghasilkan kueri Wawasan CloudWatch Log dengan kemampuan ini, buka editor kueri Wawasan CloudWatch Log, pilih grup log yang ingin Anda kueri, dan pilih **Buat** kueri.
**penting**
Untuk menggunakan kemampuan kueri bahasa alami, Anda harus masuk dengan kebijakan [CloudWatchLogsFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchLogsFullAccess.html), [CloudWatchLogsReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchLogsReadOnlyAccess.html), [AdministratorAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AdministratorAccess.html), atau [ReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/ReadOnlyAccess.html)IAM, atau memiliki `cloudwatch:GenerateQuery` izin.
## Kueri contoh
Contoh di bagian ini menjelaskan cara menghasilkan dan memperbarui kueri menggunakan kemampuan bahasa alami.
**catatan**
Untuk informasi selengkapnya tentang editor dan sintaks kueri Wawasan CloudWatch Log, lihat sintaks kueri [Wawasan CloudWatch Log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html).
### Contoh: Menghasilkan kueri bahasa alami
Untuk menghasilkan kueri menggunakan bahasa alami, masukkan prompt dan pilih **Hasilkan kueri baru**. Contoh ini menunjukkan kueri yang melakukan pencarian dasar.
**Prompt**
Berikut ini adalah contoh prompt yang mengarahkan kemampuan untuk mencari 10 pemanggilan fungsi Lambda paling lambat.
```
Find the 10 slowest requests
```
**Kueri**
Berikut ini adalah kueri menggunakan bahasa kueri Wawasan CloudWatch Log yang dihasilkan oleh kemampuan bahasa alami berdasarkan prompt. Perhatikan bagaimana prompt muncul di komentar sebelum kueri. Setelah kueri, Anda dapat membaca penjelasan yang menggambarkan cara kerja kueri.
```
# 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.
```
**catatan**
Untuk mematikan tampilan prompt Anda dan penjelasan tentang cara kerja kueri, gunakan ikon roda gigi di editor Anda.
**Prompt**
Untuk menghasilkan kueri OpenSearch SQL, pilih tab OpenSearch SQL, lalu buka kotak prompt generator kueri untuk memasukkan prompt bahasa alami Anda. Berikut ini adalah contoh prompt yang menggunakan kemampuan bahasa alami untuk menghasilkan query OpenSearch SQL.
```
Give me the number of errors and exceptions per hour
```
**Kueri**
Berikut ini adalah kueri SQL yang dihasilkan oleh prompt yang dapat Anda gunakan untuk menemukan jumlah kesalahan dan pengecualian yang dikumpulkan per jam:
```
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**
Untuk menghasilkan kueri OpenSearch PPL, pilih tab OpenSearch PPL, lalu buka kotak prompt generator kueri untuk memasukkan prompt bahasa alami Anda. Berikut ini adalah contoh prompt yang menggunakan kemampuan bahasa alami untuk menghasilkan kueri OpenSearch PPL.
```
Give me all unique exception messages
```
**Kueri**
Berikut ini adalah kueri PPL yang dihasilkan oleh prompt yang dapat Anda gunakan untuk menemukan pesan pengecualian unik di log Anda:
```
dedup @message
| fields @message
```
### Contoh: Memperbarui kueri bahasa alami
Anda dapat memperbarui kueri dengan mengedit prompt awal dan kemudian memilih **Perbarui kueri**.
**Prompt yang diperbarui**
Contoh berikut menunjukkan versi yang diperbarui dari prompt sebelumnya. Alih-alih prompt yang mencari 10 pemanggilan fungsi Lambda paling lambat, prompt ini sekarang mengarahkan kemampuan untuk mencari 20 pemanggilan fungsi Lambda paling lambat dan menyertakan kolom lain untuk peristiwa log tambahan.
```
Show top 20 slowest requests instead and display requestId as a column
```
**Kueri yang diperbarui**
Berikut ini adalah contoh kueri yang diperbarui menggunakan bahasa kueri Wawasan CloudWatch Log. Perhatikan bagaimana prompt muncul di komentar sebelum kueri yang diperbarui. Setelah kueri, Anda dapat membaca penjelasan yang menggambarkan bagaimana kueri asli diperbarui.
```
# 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.
```
## Memilih untuk tidak menggunakan data Anda untuk perbaikan layanan
Data prompt bahasa alami yang Anda berikan untuk melatih model AI dan menghasilkan kueri yang relevan digunakan semata-mata untuk menyediakan dan memelihara layanan Anda. Data ini dapat digunakan untuk meningkatkan kualitas Wawasan CloudWatch Log. Kepercayaan dan privasi Anda, serta keamanan konten Anda, menjadi prioritas utama kami. Untuk informasi selengkapnya, silakan lihat [AWS Ketentuan Layanan](https://aws.amazon.com/service-terms/) dan [AWS kebijakan AI yang bertanggung jawab](https://aws.amazon.com/machine-learning/responsible-ai/policy/).
Anda dapat memilih untuk tidak menggunakan konten Anda untuk mengembangkan atau memperbaiki mutu kueri bahasa alami dengan membuat kebijakan penolakan layanan AI. Untuk memilih keluar dari pengumpulan data untuk semua fitur AI CloudWatch Log, termasuk kemampuan pembuatan kueri, Anda harus membuat kebijakan opt-out untuk Log. CloudWatch Untuk informasi selengkapnya, silakan lihat [kebijakan penolakan layanan AI](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html) di *AWS Organizations Panduan Pengguna*.
# Log yang didukung dan bidang yang ditemukan
CloudWatch Log Insights mendukung berbagai jenis log. Untuk setiap log yang dikirim ke grup log kelas Standar di Log Amazon CloudWatch , Wawasan CloudWatch Log secara otomatis menghasilkan lima bidang sistem:
+ `@message` berisi log acara mentah yang belum diurai. Ini setara dengan `message` bidang di [InputLogevent](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_InputLogEvent.html).
+ `@timestamp`berisi stempel waktu acara di bidang peristiwa log. `timestamp` Ini setara dengan `timestamp` bidang di [InputLogevent](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_InputLogEvent.html).
+ `@ingestionTime`berisi waktu ketika CloudWatch Log menerima peristiwa log.
+ `@logStream` berisi nama pengaliran log yang ditambahi log acara. Log mengalirkan log grup melalui proses yang sama yang menghasilkannya.
+ `@log` adalah pengidentifikasi grup log dalam bentuk `account-id:log-group-name`. Saat menanyakan beberapa grup log, ini dapat berguna untuk mengidentifikasi grup log mana yang termasuk dalam acara tertentu.
+ `@entity`berisi JSON pipih yang terkait dengan entitas untuk fitur telemetri [terkait Jelajahi](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ExploreRelated.html).
Misalnya, JSON ini dapat mewakili entitas.
```
{
"Entity": {
"KeyAttributes": {
"Type": "Service",
"Name": "PetClinic"
},
"Attributes": {
"PlatformType": "AWS::EC2",
"EC2.InstanceId": "i-1234567890123"
}
}
}
```
Untuk entitas ini, bidang sistem yang diekstraksi adalah sebagai berikut:
```
@entity.KeyAttributes.Type = Service
@entity.KeyAttributes.Name = PetClinic
@entity.Attributes.PlatformType = AWS::EC2
@entity.Attributes.EC2.InstanceId = i-1234567890123
```
**catatan**
Penemuan bidang hanya didukung untuk grup log di kelas log Standar. Untuk informasi selengkapnya tentang kelas log, lihat[Kelas log](CloudWatch_Logs_Log_Classes.md).
CloudWatch Logs Insights menyisipkan simbol **@** di awal bidang yang dihasilkannya.
Untuk banyak jenis CloudWatch log, Log juga secara otomatis menemukan bidang log yang terdapat dalam log. Bidang penemuan otomatis ini ditunjukkan dalam tabel berikut.
Untuk jenis log lain dengan bidang yang tidak ditemukan secara otomatis oleh Wawasan CloudWatch Log, Anda dapat menggunakan `parse` perintah untuk mengekstrak dan membuat bidang yang diekstrak untuk digunakan dalam kueri tersebut. Untuk informasi selengkapnya, lihat [CloudWatch Sintaks kueri bahasa Wawasan Log](CWL_QuerySyntax.md).
Jika nama bidang log yang ditemukan dimulai dengan `@` karakter, Wawasan CloudWatch Log akan menampilkannya dengan tambahan yang `@` ditambahkan ke awal. Sebagai contoh, jika nama bidang log adalah `@example.com`, nama bidang ini ditampilkan sebagai `@@example.com`.
**catatan**
Kecuali untuk `@message``@timestamp`,, atau`@log`, Anda dapat membuat indeks bidang untuk bidang yang ditemukan. Untuk informasi selengkapnya tentang indeks bidang, lihat[Buat indeks bidang untuk meningkatkan kinerja kueri dan mengurangi volume pemindaian](CloudWatchLogs-Field-Indexing.md).
| Jenis log | Bidang log yang ditemukan |
| --- | --- |
| Log alur Amazon VPC | `@timestamp`, `@logStream`, `@message`, `accountId`, `endTime`, `interfaceId`, `logStatus`, `startTime`, `version`, `action`, `bytes`, `dstAddr`, `dstPort`, `packets`, `protocol`, `srcAddr`, `srcPort` |
| Log Route 53 | `@timestamp`, `@logStream`, `@message`, `edgeLocation`, `ednsClientSubnet`, `hostZoneId`, `protocol`, `queryName`, `queryTimestamp`, `queryType`, `resolverIp`, `responseCode`, `version` |
| Log Lambda | `@timestamp`, `@logStream`, `@message`, `@requestId`, `@duration, ``@billedDuration`, `@type`, `@maxMemoryUsed`, `@memorySize` Jika baris log Lambda berisi ID jejak X-Ray, itu juga mencakup bidang berikut: `@xrayTraceId` dan `@xraySegmentId`. CloudWatch Logs Insights secara otomatis menemukan bidang log di log Lambda, tetapi hanya untuk fragmen JSON pertama yang disematkan di setiap peristiwa log. Jika log acara Lambda berisi beberapa fragmen JSON, Anda dapat mengurai dan mengekstraksi bidang log menggunakan perintah `parse`. Untuk informasi selengkapnya, lihat [Bidang di log JSON](#CWL_AnalyzeLogData-discoverable-JSON-logs). |
| CloudTrail log Log dalam format JSON | Untuk informasi selengkapnya, lihat [Bidang di log JSON](#CWL_AnalyzeLogData-discoverable-JSON-logs). |
| Jenis log lainnya | `@timestamp`, `@ingestionTime`, `@logStream`, `@message`, `@log`. |
## Bidang di log JSON
Dengan Wawasan CloudWatch Log, Anda menggunakan notasi titik untuk mewakili bidang JSON. Bagian ini berisi contoh peristiwa JSON dan cuplikan kode yang menunjukkan bagaimana Anda dapat mengakses bidang JSON menggunakan notasi titik.
**Contoh: acara JSON**
```
{
"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"
}
}
]
}
}
}
```
Contoh acara JSON berisi objek yang bernama`userIdentity`. `userIdentity`berisi bidang yang diberi nama`type`. Untuk mewakili nilai `type` menggunakan notasi titik, Anda menggunakan`userIdentity.type`.
Contoh acara JSON berisi array yang diratakan ke daftar nama bidang bersarang dan nilai. Untuk mewakili nilai `instanceId` untuk item pertama di`requestParameters.instancesSet`, Anda menggunakan`requestParameters.instancesSet.items.0.instanceId`. Angka `0` yang ditempatkan sebelum bidang `instanceID` mengacu pada posisi nilai untuk bidang`items`. Contoh berikut berisi cuplikan kode yang menunjukkan bagaimana Anda dapat mengakses bidang JSON bersarang dalam peristiwa log JSON.
**Contoh: Query**
```
fields @timestamp, @message
| filter requestParameters.instancesSet.items.0.instanceId="i-abcde123"
| sort @timestamp desc
```
Cuplikan kode menunjukkan kueri yang menggunakan notasi titik dengan `filter` perintah untuk mengakses nilai bidang JSON bersarang. `instanceId` Kueri menyaring pesan di mana nilai `instanceId` sama `"i-abcde123"` dan mengembalikan semua peristiwa log yang berisi nilai yang ditentukan.
**catatan**
CloudWatch Wawasan Log dapat mengekstrak maksimal 200 bidang peristiwa log dari log JSON. Untuk bidang tambahan yang tidak diekstrak, Anda dapat menggunakan `parse` perintah untuk mengekstrak bidang dari peristiwa log mentah yang tidak diurai di bidang pesan. Untuk informasi selengkapnya tentang `parse` perintah, lihat [Sintaks kueri](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html) di Panduan CloudWatch Pengguna Amazon.
# Buat indeks bidang untuk meningkatkan kinerja kueri dan mengurangi volume pemindaian
Anda dapat membuat *indeks bidang bidang* dalam peristiwa log Anda untuk pencarian berbasis kesetaraan yang efisien. Saat Anda kemudian menggunakan indeks bidang dalam kueri Wawasan CloudWatch Log, kueri akan mencoba melewati pemrosesan peristiwa log yang diketahui tidak menyertakan bidang yang diindeks. Ini mengurangi volume pemindaian kueri Anda yang menggunakan indeks bidang, sehingga memungkinkan untuk mengembalikan hasil lebih cepat. Ini dapat membantu Anda dengan cepat mencari petabyte dari total log di ribuan grup log, dan mengasah log yang relevan lebih cepat. Bidang yang baik untuk diindeks adalah bidang yang sering perlu Anda kueri. Bidang yang memiliki nilai kardinalitas tinggi juga merupakan kandidat yang baik untuk indeks bidang karena kueri yang menggunakan indeks bidang ini akan selesai lebih cepat karena membatasi peristiwa log yang dicocokkan dengan nilai target.
Misalnya, Anda telah membuat indeks bidang untuk`requestId`. Kemudian, kueri CloudWatch Logs Insights pada grup log yang menyertakan `requestId = value` atau `requestId IN [value, value, ...]` akan mencoba memproses hanya peristiwa log yang diketahui berisi bidang yang diindeks dan nilai kueri, dan bahwa CloudWatch Log telah mendeteksi nilai untuk bidang tersebut di masa lalu.
Anda juga dapat memanfaatkan indeks bidang Anda untuk membuat kueri efisien dari jumlah grup log yang lebih besar. Saat Anda menggunakan `filterIndex` perintah dalam kueri alih-alih `filter` perintah, kueri akan berjalan terhadap grup log yang dipilih pada peristiwa log yang memiliki indeks bidang. Kueri ini dapat memindai sebanyak 10.000 grup log yang Anda pilih dengan menentukan sebanyak lima awalan nama grup log. Jika ini adalah akun pemantauan dalam pengamatan CloudWatch lintas akun, Anda dapat memilih semua akun sumber atau menentukan akun sumber individu untuk memilih grup log”.
Bidang yang diindeks peka huruf besar/kecil. Misalnya, indeks bidang tidak `RequestId` akan cocok dengan peristiwa log yang berisi`requestId`.
Indeks bidang didukung hanya untuk format log terstruktur JSON dan log layanan.
CloudWatch Log menyediakan indeks bidang default untuk semua grup log di kelas log Standar. Indeks bidang default secara otomatis tersedia untuk bidang berikut:
+ `@logStream`
+ `@aws.region`
+ `@aws.account`
+ `@source.log`
+ `@data_source_name`
+ `@data_source_type`
+ `@data_format`
+ `traceId`
+ `severityText`
+ `attributes.session.id`
CloudWatch Log menyediakan indeks bidang default untuk nama sumber data tertentu dan kombinasi tipe juga. Indeks bidang default secara otomatis tersedia untuk kombinasi nama dan jenis sumber data berikut:
| Nama dan Jenis Sumber Data | Indeks Bidang Default |
| --- | --- |
| `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` |
Indeks bidang default merupakan tambahan dari indeks bidang kustom apa pun yang Anda tentukan dalam kebijakan Anda. Indeks bidang default tidak dihitung terhadap kuota [indeks bidang](CloudWatchLogs-Field-Indexing-Syntax.md) Anda.
CloudWatch Log hanya mengindeks peristiwa log yang dicerna setelah kebijakan indeks dibuat. Itu tidak mengindeks peristiwa log yang dicerna sebelum kebijakan dibuat. Setelah Anda membuat indeks bidang, setiap peristiwa log yang cocok tetap diindeks selama 30 hari dari waktu konsumsi peristiwa log.
**catatan**
Jika Anda membuat kebijakan indeks bidang di akun pemantauan, kebijakan tersebut tidak akan digunakan untuk grup log di akun sumber tertaut. Kebijakan indeks bidang hanya berlaku di akun tempat kebijakan itu dibuat.
Topik lainnya di bagian ini menjelaskan cara membuat indeks bidang. Untuk informasi tentang merujuk ke indeks bidang dalam kueri Anda, lihat [FilterIndex](CWL_QuerySyntax-FilterIndex.md) dan. [filter](CWL_QuerySyntax-Filter.md)
**Topics**
+ [Sintaks indeks bidang dan kuota](CloudWatchLogs-Field-Indexing-Syntax.md)
+ [Membuat kebijakan indeks bidang tingkat akun](CloudWatchLogs-Field-Indexing-CreateAccountLevel.md)
+ [Membuat kebijakan indeks bidang log-group](CloudWatchLogs-Field-Indexing-CreateLogGroupLevel.md)
+ [Opsi pemilihan grup log saat membuat kueri](Field-Indexing-Selection.md)
+ [Efek menghapus kebijakan indeks bidang](CloudWatchLogs-Field-Indexing-Deletion.md)
# Sintaks indeks bidang dan kuota
Anda membuat indeks bidang dengan membuat *kebijakan indeks bidang*. Anda dapat membuat kebijakan indeks tingkat akun yang berlaku untuk seluruh akun Anda, dan Anda juga dapat membuat kebijakan yang hanya berlaku untuk satu grup log. Untuk kebijakan indeks seluruh akun, Anda dapat memiliki kebijakan yang berlaku untuk semua grup log di akun. Anda juga dapat membuat kebijakan indeks tingkat akun yang berlaku untuk subset grup log di akun, yang dipilih berdasarkan awalan nama grup log mereka. Jika Anda memiliki beberapa kebijakan tingkat akun di akun yang sama, awalan nama grup log untuk kebijakan ini tidak dapat tumpang tindih. Demikian pula, Anda dapat membuat kebijakan indeks tingkat akun yang berlaku untuk nama sumber data tertentu dan kombinasi tipe. Hanya satu kebijakan akun yang dapat dibuat per nama sumber data dan kombinasi jenis.
Kebijakan indeks bidang tingkat grup log mengganti kebijakan indeks bidang tingkat akun: yang berlaku untuk grup log secara keseluruhan (seperti, kebijakan tingkat akun tanpa kriteria pemilihan atau dengan kriteria pemilihan berdasarkan awalan nama grup log). Kebijakan tingkat akun yang cocok di tingkat peristiwa log (seperti, untuk nama sumber data tertentu dan kombinasi jenis) akan berlaku selain kebijakan yang cocok dengan grup log secara keseluruhan. Jika Anda membuat kebijakan indeks tingkat log-grup, grup log tersebut tidak menggunakan kebijakan tingkat akun yang cocok di tingkat grup log.
Pencocokan peristiwa log dengan nama indeks bidang peka huruf besar/kecil. Misalnya, indeks bidang tidak `RequestId` akan cocok dengan peristiwa log yang berisi`requestId`.
Anda dapat memiliki sebanyak 40 kebijakan indeks tingkat akun, dari kebijakan ini 20 dapat menggunakan kriteria pemilihan awalan nama grup log dan 20 dapat menggunakan kriteria pemilihan berbasis sumber data. Jika Anda memiliki beberapa kebijakan indeks tingkat akun yang difilter untuk mencatat awalan nama grup, tidak ada dua dari mereka yang dapat menggunakan awalan nama grup log yang sama atau tumpang tindih. Misalnya, jika Anda memiliki satu kebijakan yang difilter untuk mencatat grup yang dimulai`my-log`, Anda tidak dapat memfilter kebijakan indeks bidang lain ke `my-logpprod` atau`my-logging`. Demikian pula, jika Anda memiliki beberapa kebijakan indeks tingkat akun yang difilter ke nama sumber data dan kombinasi tipe, tidak ada dua dari mereka yang dapat menggunakan nama dan jenis sumber data yang sama. Misalnya, jika Anda memiliki satu kebijakan yang difilter ke nama sumber data `amazon_vpc` dan tipe sumber data, `flow` Anda tidak dapat membuat kebijakan lain dengan kombinasi ini.
Jika Anda memiliki kebijakan indeks tingkat akun yang tidak memiliki awalan nama dan berlaku untuk semua grup log, maka tidak ada kebijakan indeks tingkat akun lain dengan filter awalan nama grup log yang dapat dibuat; Anda dapat membuat kebijakan indeks tingkat akun yang menggunakan nama sumber data dan jenis filter.
Setiap kebijakan indeks memiliki kuota dan batasan berikut:
+ Sebanyak 20 bidang dapat dimasukkan dalam kebijakan.
+ Setiap nama bidang dapat mencakup sebanyak 100 karakter.
+ Untuk membuat indeks bidang kustom di grup log Anda yang dimulai dengan`@`, Anda harus menentukan bidang dengan tambahan `@` di awal nama bidang. Misalnya, jika peristiwa log Anda menyertakan bidang bernama`@userId`, Anda harus menentukan `@@userId` untuk membuat indeks untuk bidang ini.
Untuk kebijakan indeks tingkat akun dengan nama sumber data dan kriteria pemilihan berdasarkan tipe, pembatasan tambahan berlaku: semua bidang harus berupa tipe data primitif, primitif bersarang hanya didukung untuk struct.
**Bidang yang dihasilkan dan bidang cadangan**
CloudWatch Wawasan Log secara otomatis menghasilkan bidang sistem di setiap peristiwa log. Bidang yang dihasilkan ini diawali dengan `@` Untuk informasi selengkapnya tentang bidang yang dihasilkan, lihat[Log yang didukung dan bidang yang ditemukan](CWL_AnalyzeLogData-discoverable-fields.md).
Dari bidang yang dihasilkan ini, berikut ini didukung untuk digunakan sebagai indeks bidang:
+ `@logStream`
+ `@ingestionTime`
+ `@requestId`
+ `@type`
+ `@initDuration`
+ `@duration`
+ `@billedDuration`
+ `@memorySize`
+ `@maxMemoryUsed`
+ `@xrayTraceId`
+ `@xraySegmentId`
Untuk mengindeks bidang yang dihasilkan ini, Anda tidak perlu menambahkan tambahan `@` saat menentukannya, seperti yang harus Anda lakukan untuk bidang khusus yang dimulai`@`. Misalnya, untuk membuat indeks bidang untuk`@logStream`, cukup tentukan `@logStream` sebagai indeks bidang.
CloudWatch Log menyediakan indeks bidang default untuk semua grup log di kelas log Standar. Indeks bidang default secara otomatis tersedia untuk bidang berikut:
+ `@logStream`
+ `@aws.region`
+ `@aws.account`
+ `@source.log`
+ `@data_source_name`
+ `@data_source_type`
+ `@data_format`
+ `traceId`
+ `severityText`
+ `attributes.session.id`
CloudWatch Log menyediakan indeks bidang default untuk nama sumber data tertentu dan kombinasi tipe juga. Indeks bidang default secara otomatis tersedia untuk kombinasi nama dan jenis sumber data berikut:
| Nama dan Jenis Sumber Data | Indeks Bidang Default |
| --- | --- |
| `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` |
Indeks bidang default merupakan tambahan dari indeks bidang kustom apa pun yang Anda tentukan dalam kebijakan Anda. Indeks bidang default tidak dihitung terhadap kuota [indeks bidang](#CloudWatchLogs-Field-Indexing-Syntax) Anda.
**Bidang anak dan bidang array di log JSON**
Anda dapat mengindeks bidang yang merupakan bidang turunan bersarang atau bidang array di log JSON.
Misalnya, Anda dapat membuat indeks bidang `accessKeyId` anak dalam `userIdentity` bidang dalam log ini:
```
{
"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"
}
}]
}
}
}
```
Untuk membuat bidang ini, Anda merujuknya menggunakan notasi titik (`userIdentity.accessKeyId`) baik saat membuat indeks bidang dan saat menentukannya dalam kueri. Kueri bisa terlihat seperti ini:
```
fields @timestamp, @message
| filterIndex userIdentity.accessKeyId = "11112222"
```
Dalam contoh peristiwa sebelumnya, `instanceId` bidang berada dalam array dalam `requestParameters.instancesSet.items` Untuk mewakili bidang ini baik saat membuat indeks bidang dan saat query, lihat itu sebagai `requestParameters.instancesSet.items.0.instanceId` 0 mengacu pada tempat bidang itu dalam array.
Maka kueri untuk bidang ini bisa menjadi sebagai berikut:
```
fields @timestamp, @message
| filterIndex requestParameters.instancesSet.items.0.instanceId="i-abcde123"
```
# Membuat kebijakan indeks bidang tingkat akun
Gunakan langkah-langkah di bagian ini untuk membuat kebijakan indeks bidang yang berlaku untuk semua grup log di akun, atau ke beberapa grup log yang memiliki nama grup log yang dimulai dengan string yang sama.
**Untuk membuat kebijakan indeks bidang tingkat akun**
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi kiri, pilih **Pengaturan** dan kemudian pilih tab **Log**.
1. Di bagian **Kebijakan indeks tingkat akun**, pilih **Kelola**.
1. Pilih **Buat kebijakan indeks**.
1. Untuk **nama Kebijakan**, masukkan nama untuk kebijakan baru Anda.
1. Untuk **Pilih lingkup kebijakan**, lakukan salah satu hal berikut:
+ Pilih **Semua grup log standar** agar kebijakan indeks berlaku untuk semua grup log Kelas Standar di akun.
+ Pilih **Pencocokan grup log menurut awalan** untuk menerapkan kebijakan ke subset grup log yang semuanya memiliki nama yang dimulai dengan string yang sama. Kemudian, masukkan awalan untuk grup log ini di **Masukkan nama awalan**.
Setelah memasukkan awalan, Anda dapat memilih **Pratinjau awalan grup log yang cocok** untuk mengonfirmasi bahwa awalan Anda cocok dengan grup log yang Anda harapkan.
Pilih **Log Data menurut Sumber data** untuk menerapkan kebijakan ke kombinasi nama dan tipe sumber data tertentu. Anda kemudian dapat memilih **Sumber data** dan **Jenis data** dari menu tarik-turun.
Setelah Anda memilih nama dan jenis sumber data, Anda dapat memilih **Dapatkan bidang** untuk mengisi bagian **Konfigurasikan indeks bidang dan aspek** dengan informasi yang relevan seperti bidang yang tersedia, termasuk grup log, serta indeks bidang default dan kustom.
1. Untuk **konfigurasi bidang indeks kustom**, pilih **Tambahkan jalur bidang** untuk memasukkan bidang pertama yang akan diindeks.
Kemudian masukkan string untuk digunakan sebagai nilai nama bidang atau pilih bidang dari menu drop-down. Ini harus menjadi kasus yang sama persis dengan apa yang muncul dalam peristiwa log. Misalnya, jika peristiwa log Anda termasuk`requestId`, Anda harus masuk `requestId` di sini. `RequestId`,`requestID`, dan `request Id` tidak akan cocok.
Jika Anda ingin mengindeks bidang log kustom yang dimulai dengan `@` karakter, Anda harus menyertakan `@` karakter tambahan saat memasukkan string indeks. Misalnya, jika Anda memiliki bidang log kustom`@emailname`, masukkan `@@emailname` di kotak **Tambah jalur bidang**.
Anda juga dapat membuat indeks untuk `@ingestionTime` dan `@logStream` bidang yang dihasilkan CloudWatch Log secara otomatis. Jika ya, Anda tidak perlu menambahkan tambahan `@` saat menentukannya.
1. (Opsional) Selain menentukan jalur bidang, Anda dapat memilih **Set sebagai faset** untuk membuat bidang sebagai faset.
1. Ulangi langkah sebelumnya untuk menambahkan sebanyak 20 indeks bidang.
1. Setelah selesai, pilih **Buat**.
# Membuat kebijakan indeks bidang log-group
Gunakan langkah-langkah di bagian ini untuk membuat kebijakan indeks bidang yang berlaku untuk satu grup log.
**Untuk membuat kebijakan indeks bidang tingkat log-group**
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi kiri, pilih **Logs**, **Log groups** (Grup log).
1. Pilih nama grup log.
1. Pilih tab **Indeks bidang**.
1. Pilih **Kelola indeks bidang untuk grup log ini**
1. Untuk **Mengelola indeks bidang tingkat grup log**, pilih **Tambahkan jalur bidang** untuk memasukkan bidang pertama yang akan diindeks.
Kemudian masukkan string untuk digunakan sebagai nilai nama bidang. Ini harus menjadi kasus yang sama persis dengan apa yang muncul dalam peristiwa log. Misalnya, jika peristiwa log Anda termasuk`requestId`, Anda harus masuk `requestId` di sini. `RequestId`,`requestID`, dan tidak `request Id` akan cocok.
Jika Anda ingin mengindeks bidang log kustom yang dimulai dengan `@` karakter, Anda harus menyertakan `@` karakter tambahan saat memasukkan string indeks. Misalnya, jika Anda memiliki bidang log kustom`@emailname`, masukkan `@@emailname` di kotak **Tambah jalur bidang**.
Anda juga dapat membuat indeks untuk `@ingestionTime` dan `@logStream` bidang yang dihasilkan CloudWatch Log secara otomatis. Jika Anda melakukannya, tidak perlu menambahkan tambahan `@` saat menentukannya.
1. (Opsional) Selain menentukan jalur bidang, Anda dapat memilih **Set sebagai faset** untuk membuat bidang sebagai faset.
1. Ulangi langkah sebelumnya untuk menambahkan sebanyak 20 indeks bidang.
1. Setelah Anda selesai, pilih **Simpan**.
# Opsi pemilihan grup log saat membuat kueri
Bagian ini menjelaskan berbagai cara Anda dapat memilih grup log untuk disertakan dalam kueri.
**Untuk memilih grup log untuk kueri di konsol**
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi, pilih **Log**, **Wawasan Log**.
1. Pilih bahasa kueri yang ingin Anda gunakan untuk kueri ini. **Anda dapat memilih: **Log Wawasan QL, OpenSearch PPL****, atau SQL**. OpenSearch **
1. Ada tiga cara untuk memilih grup log untuk kueri:
+ Gunakan kotak **nama grup Log**. Ini adalah metode pemilihan default. Anda dapat memasukkan sebanyak 50 nama grup log dengan metode ini. Jika ini adalah akun pemantauan dalam pengamatan CloudWatch lintas akun, Anda dapat memilih grup log di akun sumber serta akun pemantauan. Satu kueri dapat menanyakan log dari akun yang berbeda sekaligus.
+ Gunakan bagian **Kriteria grup Log**. Di bagian ini, Anda dapat memilih grup log berdasarkan awalan nama grup log. Anda dapat menyertakan sebanyak lima awalan dalam satu kueri. Grup log yang memiliki awalan ini dalam nama mereka akan dipilih. Atau, opsi **Semua grup log** memilih semua grup log dari akun.
+ Jika ini adalah akun pemantauan dalam pengamatan CloudWatch lintas akun, Anda dapat memilih **Semua akun** di menu tarik-turun akun untuk memilih grup log dari semua akun yang ditautkan. Atau, Anda dapat secara individual memilih akun mana yang harus disertakan untuk kueri ini.
Jika pilihan Anda cocok dengan lebih dari 10.000 grup log, Anda akan melihat kesalahan yang meminta Anda untuk mempersempit pilihan Anda.
1. Kelas log default untuk kueri adalah **Standar**. Anda dapat menggunakan **kelas Log** untuk mengubahnya menjadi **akses yang jarang**.
**Menggunakan AWS CLI**
Untuk membuat jenis pilihan ini ketika Anda memulai kueri dari baris perintah, Anda dapat menggunakan `source` perintah dalam kueri Anda. Untuk informasi selengkapnya dan contoh tambahan, lihat [SUMBER](CWL_QuerySyntax-Source.md).
# Efek menghapus kebijakan indeks bidang
Jika Anda menghapus kebijakan indeks bidang yang telah berlaku selama beberapa waktu, hal berikut akan terjadi:
+ Hingga 30 hari setelah kebijakan dihapus, kueri masih dapat memperoleh manfaat dari peristiwa log yang diindeks.
+ Jika Anda menghapus kebijakan indeks tingkat log-grup, dan sudah ada kebijakan tingkat akun yang akan berlaku untuk grup log tersebut, kebijakan tingkat akun pada akhirnya akan berlaku untuk grup log tersebut.
# Gunakan aspek untuk mengelompokkan dan menjelajahi log
Aspek berguna untuk menganalisis log karena memungkinkan Anda memfilter dan mengelompokkan data secara interaktif tanpa menjalankan kueri. Aspet adalah bidang di log Anda (seperti `ServiceName` atau`StatusCode`) yang memungkinkan penyaringan, agregasi, dan analisis di seluruh grup log. Anda dapat melihat daftar bidang faset di konsol Wawasan CloudWatch Log, bersama dengan jumlah peristiwa log untuk setiap nilai aspek berdasarkan rentang waktu yang Anda pilih. Saat Anda memilih berbagai aspek dan nilai, nilai dan jumlah faset diperbarui secara real-time, memungkinkan Anda menjelajahi log secara interaktif.
Setiap aspek menunjukkan nilai dan jumlah yang tersedia secara otomatis diekstrak dari bidang di log Anda berdasarkan rentang waktu dan cakupan kueri yang dipilih, dan dipertahankan selama 30 hari. Jumlah faset yang ditampilkan adalah perkiraan. Anda dapat menggunakan aspek default seperti nama sumber data atau tipe sumber data untuk menjelajahi log Anda, atau membuat aspek khusus pada salah satu bidang di log Anda. Nama Sumber Data adalah layanan AWS atau aplikasi yang menghasilkan log (misalnya, Route 53, Amazon VPC, atau CloudTrail) dan tipe Sumber Data adalah jenis log spesifik yang dihasilkan oleh layanan tersebut. Aspek default dibuat oleh CloudWatch dan termasuk`@aws.region`,, `@data_source_name``@data_source_type`, dan`@data_format`. Untuk informasi selengkapnya, lihat [Manajemen log](LogManagement.md). Aspek hanya tersedia untuk log yang dicerna di akun. Jika Anda telah menyiapkan observabilitas lintas akun, akun pemantauan tidak dapat melihat aspek berdasarkan log dari akun sumber.
Untuk membuat aspek tambahan, pilih bidang di log Anda yang relevan dengan pemecahan masalah Anda dan konfigurasikan menggunakan kebijakan indeks. Untuk aspek khusus, kami sarankan untuk membuatnya di bidang kardinalitas rendah (bidang yang memiliki kurang dari 100 nilai unik per hari seperti Status dan). ApplicationName Aspek dengan lebih dari 100 nilai unik per hari diklasifikasikan sebagai kardinalitas tinggi dan nilai untuk aspek-aspek ini tidak ditampilkan. Pilih satu atau beberapa aspek dan klik untuk menjalankan kueri di seluruh log Anda.
Untuk memulai dengan aspek di Wawasan CloudWatch Log:
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi, pilih **Log**, **Wawasan Log**.
1. (Opsional) Gunakan pemilih rentang waktu untuk memilih periode waktu yang ingin Anda analisis. Untuk rentang waktu yang dipilih, aspek dan nilai yang tersedia ditampilkan di panel.
1. Pilih aspek untuk menjelajahi data Anda dan melihat pembaruan real-time dari distribusi nilai di seluruh aspek.
Aspek dengan lebih dari 100 nilai unik tidak ditampilkan. Untuk menanyakan nilai tertentu, gunakan filter dalam kueri Anda sebagai gantinya.
## Untuk menjalankan kueri berbasis aspek
1. Pilih satu atau lebih nilai di seluruh aspek.
1. Jumlah acara akan diperbarui berdasarkan aspek dan nilai yang dipilih.
1. Saat nilai faset dipilih, cakupan kueri diperbarui untuk mencerminkan pemilihan.
1. Setelah memilih nilai faset, klik jalankan untuk menjalankan kueri Anda.
1. Jumlah maksimum nilai unik yang didukung per segi adalah 100. Misalnya, jika ada lebih dari 100 nilai untuk suatu segi, maka semua hitungan ditampilkan sebagai “-”, yang menunjukkan bahwa nilainya tidak diketahui.
## Untuk menyimpan kueri berbasis aspek
1. Buat kueri Anda menggunakan satu atau beberapa nilai facet.
1. Langkah-langkah lainnya sama dengan menyimpan kueri Wawasan Log. Lihat [kueri Menyimpan CloudWatch Log Wawasan](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_Insights-Saving-Queries.html).
1. Kueri tersimpan tersedia di bagian Kueri Tersimpan. Saat Anda mengambil kueri yang disimpan, itu akan secara otomatis menyertakan aspek dan nilai yang digunakan untuk kueri, sehingga mudah untuk menganalisis log Anda.
## Untuk membuat aspek tingkat akun
1. Untuk membuat faset, Anda harus terlebih dahulu membuat bidang sebagai indeks dan mengkonfigurasinya sebagai faset. Di panel navigasi, pilih **Pengaturan**, **Log**, **Kebijakan indeks tingkat akun**. Atau, Anda dapat memilih **Kelola aspek** pada panel faset.
1. Pilih **Buat kebijakan indeks baru**. Untuk detail tentang membuat kebijakan indeks, lihat[Membuat kebijakan indeks bidang tingkat akun](CloudWatchLogs-Field-Indexing-CreateAccountLevel.md).
1. Untuk membuat facet, centang **Set as facet** untuk bidang yang dipilih di halaman pembuatan kebijakan indeks.
## Manajemen Facet menggunakan APIs
Pengelolaan facet dapat dilakukan dengan menggunakan kebijakan indeks bidang. Lihat [https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_FieldIndex.html](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_FieldIndex.html) APIs untuk detail.
**Indeks Lapangan APIs**
| Tidak. | Nama | Deskripsi |
| --- | --- | --- |
| 1 | PutIndexPolicy | Membuat atau memperbarui kebijakan indeks bidang untuk grup log tertentu |
| 2 | PutAccountPolicy | Membuat kebijakan perlindungan data tingkat akun, kebijakan filter langganan, kebijakan indeks bidang, kebijakan transformator, atau kebijakan ekstraksi metrik yang berlaku untuk semua grup log atau subset grup log di akun |
| 3 | DeleteIndexPolicy | Menghapus kebijakan indeks bidang log-group yang diterapkan ke grup log tunggal |
| 4 | DeleteAccountPolicy | Menghapus kebijakan akun CloudWatch Log |
# Analisis pola
CloudWatch Logs Insights menggunakan algoritme pembelajaran mesin untuk menemukan *pola* saat Anda menanyakan log Anda. Pola adalah struktur teks bersama yang berulang di antara bidang log Anda. Saat melihat hasil kueri, Anda dapat memilih tab **Pola** untuk melihat pola yang ditemukan CloudWatch Log berdasarkan sampel hasil Anda. Atau, Anda dapat menambahkan `pattern` perintah ke kueri Anda untuk menganalisis pola di seluruh rangkaian peristiwa log yang cocok.
Pola berguna untuk menganalisis kumpulan log besar karena sejumlah besar peristiwa log sering dapat dikompresi menjadi beberapa pola.
Pertimbangkan contoh berikut dari tiga peristiwa log.
```
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
```
Dalam sampel sebelumnya, ketiga peristiwa log mengikuti satu pola:
```
[INFO] Calling DynamoDB to store for resource id
```
Bidang dalam pola disebut *token*. Bidang yang bervariasi dalam suatu pola, seperti ID permintaan atau stempel waktu, adalah token *dinamis*. Setiap token dinamis diwakili oleh``. *string*Ini adalah deskripsi dari jenis data yang diwakili oleh token. *number*Menunjukkan di mana dalam pola token ini muncul, dibandingkan dengan token dinamis lainnya.
Contoh umum token dinamis termasuk kode kesalahan, stempel waktu, dan permintaan. IDs *Nilai token* mewakili nilai tertentu dari token dinamis. Misalnya, jika token dinamis mewakili kode kesalahan HTTP, maka nilai token bisa jadi`501`.
Deteksi pola juga digunakan dalam detektor anomali CloudWatch Log dan fitur perbandingan. Untuk informasi selengkapnya, lihat [Deteksi anomali log](LogsAnomalyDetection.md) dan [Bandingkan (diff) dengan rentang waktu sebelumnya](CWL_AnalyzeLogData_Compare.md).
## Memulai dengan analisis pola
Deteksi pola dilakukan secara otomatis dalam kueri Wawasan CloudWatch Log apa pun. Kueri yang tidak menyertakan `pattern` perintah mendapatkan peristiwa log dan pola dalam hasil.
Jika Anda menyertakan `pattern` perintah dalam kueri Anda, analisis pola dilakukan pada seluruh rangkaian peristiwa log yang cocok. Ini memberi Anda hasil pola yang lebih akurat, tetapi peristiwa log mentah tidak dikembalikan saat Anda menggunakan `pattern` perintah. Ketika kueri tidak disertakan`pattern`, hasil pola didasarkan pada 1000 peristiwa log pertama yang dikembalikan, atau pada nilai batas yang Anda gunakan dalam kueri Anda. Jika Anda menyertakan `pattern` dalam kueri, maka hasil yang ditampilkan di tab **Pola** berasal dari semua peristiwa log yang cocok dengan kueri.
**Untuk memulai analisis pola di Wawasan CloudWatch Log**
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi, pilih **Log**, **Wawasan Log**.
Pada halaman **Wawasan Log**, editor kueri berisi kueri default yang menampilkan 20 peristiwa log terbaru.
1. Hapus `| limit 20` baris di kotak kueri, sehingga kueri terlihat seperti berikut:
```
fields @timestamp, @message, @logStream, @log
| sort @timestamp desc
```
1. Di menu drop-down **Pilih grup log**, pilih satu atau beberapa grup log untuk kueri.
1. (Opsional) Gunakan pemilih interval waktu untuk memilih periode waktu yang ingin Anda kueri.
Anda dapat memilih antara interval 5 menit dan 30 menit; Interval 1 jam, 3 jam, dan 12 jam; atau kerangka waktu khusus.
1. Pilih **Jalankan kueri** untuk memulai kueri.
Saat kueri selesai berjalan, tab **Log** menampilkan tabel peristiwa log yang dikembalikan oleh kueri. Di atas tabel adalah pesan tentang berapa banyak catatan yang cocok dengan kueri, mirip dengan **Menampilkan 10.000 dari 71.101** catatan yang cocok.
1. Pilih tab **Patterns**.
1. Tabel sekarang menampilkan pola yang ditemukan dalam kueri. Karena kueri tidak menyertakan `pattern` perintah, tab ini hanya menampilkan pola yang ditemukan di antara 10.000 peristiwa log yang ditampilkan dalam tabel di tab **Log**.
Untuk setiap pola, informasi berikut ditampilkan:
+ **Pola**, dengan setiap token dinamis ditampilkan sebagai``. *string*Ini adalah deskripsi dari jenis data yang diwakili oleh token. *number*Menunjukkan di mana dalam pola token ini muncul, dibandingkan dengan token dinamis lainnya.
+ **Hitungan Peristiwa**, yang merupakan berapa kali pola muncul dalam peristiwa log yang ditanyakan. Pilih judul kolom **Event count** untuk mengurutkan pola berdasarkan frekuensi.
+ **Rasio peristiwa**, yang merupakan persentase dari peristiwa log kueri yang berisi pola ini.
+ **Jenis Keparahan**, yang akan menjadi salah satu dari yang berikut:
+ **ERROR** jika pola berisi kata **Error**.
+ **PERINGATKAN** jika pola berisi kata **Warn** tetapi tidak mengandung **Error**.
+ **INFO** jika pola tidak mengandung **Warn** atau **Error**.
Pilih judul kolom **Info keparahan** untuk mengurutkan pola berdasarkan tingkat keparahan.
1. Sekarang ubah kueri. Ganti `| sort @timestamp desc` baris dalam kueri dengan`| pattern @message`, sehingga kueri lengkapnya adalah sebagai berikut:
```
fields @timestamp, @message, @logStream, @log
| pattern @message
```
1. Pilih **Run query** (Jalankan kueri).
Saat kueri selesai, tidak ada hasil di tab **Log**. Namun, tab **Patterns** kemungkinan memiliki jumlah pola yang lebih besar yang terdaftar, tergantung pada jumlah total peristiwa log yang ditanyakan.
1. Terlepas dari apakah Anda termasuk `pattern` dalam kueri Anda, Anda dapat memeriksa lebih lanjut pola yang dikembalikan kueri. Untuk melakukannya, pilih ikon di kolom **Inspect** untuk salah satu pola.
Panel **pemeriksaan Pola** muncul dan menampilkan yang berikut:
+ **Pola**. Pilih token dalam pola untuk menganalisis nilai token tersebut.
+ Histogram yang menunjukkan jumlah kemunculan pola selama rentang waktu yang ditanyakan. Ini dapat membantu Anda mengidentifikasi tren menarik seperti peningkatan tiba-tiba dalam terjadinya suatu pola.
+ Tab **Log samples** menampilkan beberapa peristiwa log yang cocok dengan pola yang dipilih.
+ Tab **Nilai Token** menampilkan nilai token dinamis yang dipilih, jika Anda telah memilihnya.
**catatan**
Maksimal 10 nilai token ditangkap untuk setiap token. Jumlah token mungkin tidak tepat. CloudWatch Log menggunakan penghitung probabilistik untuk menghasilkan jumlah token, bukan nilai absolut.
+ Tab **pola Terkait** menampilkan pola lain yang sering terjadi mendekati waktu yang sama dengan pola yang Anda periksa. Misalnya, jika pola untuk `ERROR` pesan biasanya disertai dengan peristiwa log lain yang ditandai `INFO` dengan detail tambahan, pola itu ditampilkan di sini.
## Detail tentang perintah pola
Bagian ini berisi rincian lebih lanjut tentang `pattern` perintah dan penggunaannya.
+ Dalam tutorial sebelumnya, kami menghapus `sort` perintah ketika kami menambahkan `pattern` karena kueri tidak valid jika menyertakan `pattern` perintah setelah `sort` perintah. Adalah sah untuk memiliki `pattern` sebelum a`sort`.
Untuk detail selengkapnya tentang `pattern` sintaks, lihat[pola](CWL_QuerySyntax-Pattern.md).
+ Bila Anda menggunakan `pattern` dalam query, `@message` harus menjadi salah satu bidang yang dipilih dalam `pattern` perintah.
+ Anda dapat menyertakan `filter` perintah sebelum `pattern` perintah untuk menyebabkan hanya kumpulan peristiwa log yang difilter untuk digunakan sebagai masukan untuk analisis pola.
+ Untuk melihat hasil pola untuk bidang tertentu, seperti bidang yang berasal dari `parse` perintah, gunakan`pattern @fieldname`.
+ Kueri dengan output non-log, seperti kueri dengan `stats` perintah, tidak mengembalikan hasil pola.
# Simpan dan jalankan kembali kueri CloudWatch Logs Insights
Setelah Anda membuat kueri, Anda dapat menyimpannya, dan menjalankannya lagi nanti. Kueri disimpan dalam struktur folder, sehingga Anda dapat mengaturnya. Anda dapat menyimpan sebanyak 1000 kueri per wilayah dan per akun.
Kueri disimpan pada tingkat khusus Wilayah, bukan tingkat khusus pengguna. Jika Anda membuat dan menyimpan kueri, pengguna lain yang memiliki akses ke CloudWatch Log di Wilayah yang sama dapat melihat semua kueri yang disimpan dan struktur foldernya di Wilayah.
Untuk menyimpan kueri, Anda harus masuk ke peran yang memiliki izin`logs:PutQueryDefinition`. Untuk melihat daftar kueri yang disimpan, Anda harus masuk ke peran yang memiliki izin`logs:DescribeQueryDefinitions`.
**catatan**
Anda dapat membuat dan menyimpan kueri dengan parameter — template yang dapat digunakan kembali dengan placeholder bernama. Alih-alih menyimpan beberapa variasi kueri yang sama dengan nilai yang berbeda, buat satu templat dan berikan nilai parameter yang berbeda saat Anda menjalankannya. Fungsionalitas ini saat ini didukung untuk kueri hanya menggunakan bahasa kueri Wawasan Log. Untuk informasi selengkapnya, lihat [Menggunakan kueri tersimpan dengan parameter](#CWL_Insights-Parameterized-Queries).
------
#### [ Console ]
**Untuk menyimpan kueri**
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi, pilih **Log**, lalu pilih **Wawasan Log**.
1. Buat kueri di editor kueri.
1. Pilih **Simpan**.
1. Masukkan nama untuk kueri.
1. (Opsional) Pilih folder tempat Anda ingin menyimpan kueri. Pilih **Create new** (Buat baru) untuk membuat folder. Jika Anda membuat folder baru, Anda dapat menggunakan karakter garis miring (/) dalam nama folder untuk menentukan struktur folder. Sebagai contoh, menamai folder baru dengan **folder-level-1/folder-level-2** akan membuat folder tingkat atas yang disebut **folder-level-1**, dengan folder lain yang bernama **folder-level-2** di dalam folder itu. Kueri disimpan dalam **folder-level-2**.
1. (Opsional) Ubah grup log kueri atau teks kueri.
1. (Opsional) Untuk menggunakan parameter dalam kueri Anda, ikuti langkah-langkah tambahan ini:
1. **Tambahkan parameter ke kueri Anda.** Ganti nilai statis dengan placeholder menggunakan `{{parameter}}` sintaks (tanda kurung ganda sebelum dan sesudah nama parameter).
Contoh: Kueri asli dengan nilai statis:
```
fields @timestamp, @message
| filter level = "Error"
| filter applicationName = "OrderService"
```
Kueri diperbarui dengan parameter:
```
fields @timestamp, @message
| filter level = {{logLevel}}
| filter applicationName = {{applicationName}}
```
1. **Tentukan parameter yang digunakan dalam kueri Anda.** Untuk setiap parameter placeholder, tentukan:
+ **Nama**: Harus sama persis dengan nama placeholder (misalnya,`logLevel`,`applicationName`).
+ **Nilai default** (opsional): Nilai yang akan digunakan jika tidak ada nilai parameter yang disediakan.
+ **Deskripsi** (opsional): Menjelaskan tujuan parameter.
1. Query dengan parameter dapat dijalankan dengan menggunakan nama query dengan `$` awalan dan meneruskan nama parameter sebagai pasangan kunci-nilai. Lihat **Untuk menjalankan kueri tersimpan** untuk detailnya.
1. Pilih **Simpan**.
------
#### [ AWS CLI ]
**Untuk menyimpan kueri**, gunakan`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
```
(Opsional) Untuk menyimpan kueri dengan parameter, tambahkan `--parameters` opsi dan gunakan `{{parameterName}}` placeholder dalam string kueri:
```
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
```
Untuk menyimpan kueri di folder, awali nama kueri dengan jalur folder:
```
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 ]
**Untuk menyimpan kueri**, hubungi [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"]
}
```
(Opsional) Untuk menyimpan kueri dengan parameter, sertakan `parameters` bidang dan gunakan `{{parameterName}}` placeholder dalam string kueri:
```
{
"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"
}
]
}
```
------
**Tip**
Anda dapat membuat folder untuk kueri yang disimpan dengan`PutQueryDefinition`. Untuk membuat folder untuk kueri yang disimpan, gunakan garis miring (/) untuk mengawali nama kueri yang Anda inginkan dengan nama folder yang Anda inginkan:. `/` Untuk informasi lebih lanjut tentang tindakan ini, lihat [PutQueryDefinition](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutQueryDefinition.html).
------
#### [ Console ]
**Untuk menjalankan kueri yang disimpan**
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi, pilih **Log**, lalu pilih **Wawasan Log**.
1. Di sebelah kanan, pilih **Queries** (Kueri).
1. Pilih kueri Anda dari daftar **Kueri tersimpan**. Teks kueri muncul di editor kueri.
1. (Opsional) Untuk menggunakan kueri dengan parameter:
1. Pilih **ikon\$1di** sebelah nama kueri di panel samping **Kueri tersimpan**.
1. Kueri dengan parameter muncul di editor kueri. Misalnya, jika Anda memilih ikon **\$1** di sebelah`ErrorsByLevel`, editor kueri diisi dengan: `$ErrorsByLevel(level=, applicationName=)`
1. Berikan nilai untuk parameter (level, applicationName) dan jalankan kueri. Misalnya: `$ErrorsByLevel(level= "ERROR", applicationName= "OrderService")`
1. Pilih **Jalankan**.
------
#### [ AWS CLI ]
**Untuk menjalankan kueri tersimpan dengan parameter**
Gunakan `start-query` dengan `$QueryName()` sintaks:
```
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 ]
**Untuk menjalankan kueri tersimpan dengan parameter**
Panggil [StartQuery](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_StartQuery.html)dengan `$QueryName()` sintaks di `queryString` lapangan:
```
{
"logGroupNames": ["/aws/lambda/my-function"],
"startTime": 1707566400,
"endTime": 1707570000,
"queryString": "$ErrorsByLevel(level=\"ERROR\", applicationName= \"OrderService\")"
}
```
------
**Untuk menyimpan versi baru dari kueri tersimpan**
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi, pilih **Log**, lalu pilih **Wawasan Log**.
1. Di sebelah kanan, pilih **Queries** (Kueri).
1. Pilih kueri dari daftar **Saved queries** (Kueri tersimpan). Itu akan muncul di editor kueri.
1. Modifikasi kueri. Jika Anda perlu menjalankannya untuk memeriksa pekerjaan Anda, pilih **Run query** (Jalankan kueri).
1. Saat Anda siap untuk menyimpan versi baru, pilih **Actions** (Tindakan), **Save as** (Simpan sebagai).
1. Masukkan nama untuk kueri.
1. (Opsional) Pilih folder tempat Anda ingin menyimpan kueri. Pilih **Create new** (Buat baru) untuk membuat folder. Jika Anda membuat folder baru, Anda dapat menggunakan karakter garis miring (/) dalam nama folder untuk menentukan struktur folder. Sebagai contoh, menamai folder baru dengan **folder-level-1/folder-level-2** akan membuat folder tingkat atas yang disebut **folder-level-1**, dengan folder lain yang bernama **folder-level-2** di dalam folder itu. Kueri disimpan dalam **folder-level-2**.
1. (Opsional) Ubah grup log kueri atau teks kueri.
1. Pilih **Simpan**.
Untuk menghapus kueri, Anda harus masuk ke peran yang memiliki izin `logs:DeleteQueryDefinition`.
**Untuk mengedit atau menghapus kueri tersimpan**
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi, pilih **Log**, lalu pilih **Wawasan Log**.
1. Di sebelah kanan, pilih **Queries** (Kueri).
1. Pilih kueri dari daftar **Saved queries** (Kueri tersimpan). Itu akan muncul di editor kueri.
1. Pilih **Actions** (Tindakan), **Edit** atau **Actions** (Tindakan), **Delete** (Hapus).
## Menggunakan kueri yang disimpan dengan parameter
Kueri tersimpan dengan parameter adalah templat kueri yang dapat digunakan kembali dengan placeholder bernama. Alih-alih mempertahankan beberapa salinan kueri yang hampir identik, Anda dapat menyimpan template dan memberikan nilai parameter yang berbeda saat menjalankan kueri. Parameter hanya didukung dalam bahasa kueri Wawasan CloudWatch Log.
**Cara kerjanya**
Saat menyimpan kueri, placeholder mengidentifikasi nilai yang dapat Anda berikan pada waktu eksekusi kueri. Placeholder menggunakan sintaks. `{{parameterName}}` Berikut ini adalah contoh dari query tersimpan bernama `ErrorsByLevel` dengan dua parameter `logLevel` dan`applicationName`.
```
fields @timestamp, @message
| filter level = {{logLevel}}
| filter applicationName = {{applicationName}}
```
Untuk menjalankan kueri tersimpan, Anda dapat memanggilnya menggunakan nama kueri yang diawali dengan `$` dan meneruskan nilai parameter. Mesin kueri CloudWatch Logs Insights menggantikan setiap placeholder. Jika parameter berisi nilai default, maka nilai-nilai tersebut digunakan jika tidak ada nilai lain yang disediakan.
```
# 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()
```
Nama kueri tersimpan yang berisi spasi atau karakter khusus harus diapit dengan backticks:
```
$`Errors By Level`(logLevel = "WARN")
```
### Contoh kueri yang disimpan dengan parameter
**Menambahkan batas hasil sebagai parameter**
Nama kueri: `ErrorsByLevel` dengan parameter `logLevel` (default:`"ERROR"`), `applicationName` (default:`"OrderService"`), dan `maxResults` (default:`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)
```
**Menggunakan beberapa kueri tersimpan dengan parameter**
Contoh di bawah ini menggunakan `ErrorsByLevel` dan kueri tersimpan kedua `RecentN` yang didefinisikan sebagai `sort @timestamp desc | limit {{count}}` (dengan parameter`count`, default`20`). Mesin kueri CloudWatch Logs Insights memperluas setiap kueri sebelum menjalankannya.
```
# 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
```
### Kuota dan penanganan kesalahan
**catatan**
Setiap kueri yang disimpan dapat memiliki maksimum 20 parameter.
String kueri yang diperluas tidak dapat melebihi 10.000 karakter. Nama parameter harus dimulai dengan huruf atau garis bawah. Kueri tersimpan tidak dapat mereferensikan kueri lain yang disimpan (pemanggilan bersarang tidak didukung).
**Kesalahan umum**
| Kesalahan | Penyebab |
| --- | --- |
| Parameter hanya didukung untuk bahasa kueri CWLI | Parameter hanya didukung dalam bahasa kueri Wawasan CloudWatch Log. |
| Parameter yang diperlukan tidak ditemukan di QueryString | Nama parameter di `--parameters` tidak memiliki pencocokan `{{placeholder}}` dalam string kueri. |
| Jumlah parameter melebihi maksimum 20 | Kueri yang disimpan saat ini hanya mendukung 20 parameter. |
| Nama parameter duplikat | Definisi kueri memiliki parameter duplikat di`parameters`. |
**catatan**
Untuk membuat atau memperbarui kueri yang disimpan dengan parameter, Anda memerlukan `logs:PutQueryDefinition` izin. Untuk menjalankannya, Anda perlu `logs:StartQuery` dan`logs:DescribeQueryDefinitions`.
# Tambahkan kueri ke dasbor atau ekspor hasil kueri
Setelah menjalankan kueri, Anda dapat menambahkan kueri ke CloudWatch dasbor atau menyalin hasilnya ke clipboard.
Kueri yang ditambahkan ke dasbor akan dijalankan setiap kali Anda memuat dasbor dan setiap kali dasbor disegarkan. Kueri ini dihitung terhadap batas 100 kueri Wawasan CloudWatch Log bersamaan.
**Untuk menambahkan hasil kueri ke dasbor**
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi, pilih **Log**, lalu pilih **Wawasan Log**.
1. Pilih satu atau beberapa grup log dan jalankan kueri.
1. Pilih **Tambahkan ke dasbor**.
1. Pilih dasbor, atau pilih **Create new** (Buat baru) untuk membuat dasbor untuk hasil kueri.
1. Pilih jenis widget yang akan digunakan untuk hasil kueri.
1. Masukkan nama untuk widget.
1. Pilih **Tambahkan ke dasbor**.
**Untuk menyalin hasil kueri ke clipboard atau mengunduh hasil kueri**
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi, pilih **Log**, lalu pilih **Wawasan Log**.
1. Pilih satu atau beberapa grup log dan jalankan kueri.
1. Pilih **Export results** (Ekspor hasil), lalu pilih opsi yang Anda inginkan.
# Lihat kueri atau riwayat kueri yang sedang berjalan
Anda dapat melihat kueri yang sedang berlangsung serta riwayat kueri terbaru Anda.
Kueri yang sedang berjalan mencakup kueri yang telah ditambahkan ke dasbor. Anda dibatasi hingga 100 kueri Wawasan CloudWatch Log bersamaan per akun, termasuk kueri yang ditambahkan ke dasbor. Selain itu, Anda dapat menjalankan 15 kueri bersamaan untuk OpenSearch Service PPL atau OpenSearch Service SQL.
**Untuk melihat riwayat kueri terbaru Anda**
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Di panel navigasi, pilih **Log**, lalu pilih **Wawasan Log**.
1. Pilih **Riwayat**, jika Anda menggunakan desain baru untuk konsol CloudWatch Log. Jika Anda menggunakan desain lama, pilih **Actions** (Tindakan), **View query history for this account** (Lihat riwayat kueri untuk akun ini).
Daftar kueri terbaru Anda akan muncul. Anda dapat menjalankan kembali salah satunya dengan memilih kueri dan memilih **Run** (Jalankan).
Di bawah **Status**, CloudWatch Log ditampilkan **Sedang berlangsung** untuk kueri apa pun yang sedang berjalan.
# Enkripsi hasil kueri dengan AWS Key Management Service
Secara default, CloudWatch Log mengenkripsi hasil tersimpan dari kueri Wawasan CloudWatch Log Anda menggunakan metode enkripsi sisi server CloudWatch Log default. Anda dapat memilih untuk menggunakan AWS KMS kunci untuk mengenkripsi hasil ini sebagai gantinya. Jika Anda mengaitkan AWS KMS kunci dengan hasil enkripsi Anda, maka CloudWatch Log menggunakan kunci tersebut untuk mengenkripsi hasil yang disimpan dari semua kueri di akun.
Jika nanti Anda memisahkan kunci dari hasil kueri, CloudWatch Log akan kembali ke metode enkripsi default untuk kueri selanjutnya. Tetapi kueri yang berjalan saat kunci dikaitkan masih dienkripsi dengan kunci itu. CloudWatch Log masih dapat mengembalikan hasil tersebut setelah kunci KMS dipisahkan, karena CloudWatch Log masih dapat terus mereferensikan kunci. Namun, jika kunci kemudian dinonaktifkan, maka CloudWatch Log tidak dapat membaca hasil kueri yang dienkripsi dengan kunci itu.
**penting**
CloudWatch Log hanya mendukung kunci KMS simetris. Jangan gunakan kunci asimetris untuk mengenkripsi hasil kueri Anda. Untuk informasi selengkapnya, lihat [Menggunakan Kunci Simetris dan Asimetris](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html).
## Batas
+ Untuk melakukan langkah-langkah berikut, Anda harus memiliki izin berikut: `kms:CreateKey`, `kms:GetKeyPolicy`, dan `kms:PutKeyPolicy`.
+ Setelah Anda mengaitkan atau memisahkan kunci dari hasil kueri Anda, diperlukan waktu hingga lima menit agar operasi diterapkan.
+ Jika Anda mencabut akses CloudWatch Log ke kunci terkait atau menghapus kunci KMS terkait, data terenkripsi Anda di CloudWatch Log tidak dapat diambil lagi.
+ Anda tidak dapat menggunakan CloudWatch konsol untuk mengaitkan kunci, Anda harus menggunakan AWS CLI atau CloudWatch Logs API.
## Langkah 1: Buat AWS KMS key
Untuk membuat kunci KMS gunakan perintah [create-key](https://docs.aws.amazon.com/cli/latest/reference/kms/create-key.html) berikut:
```
aws kms create-key
```
Output berisi ID kunci dan Amazon Resource Name (ARN) dari kunci. Berikut ini adalah output contoh:
```
{
"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"
]
}
}
```
## Langkah 2: Tetapkan izin pada tombol KMS
Secara default, semua kunci KMS bersifat pribadi. Hanya pemilik sumber daya yang dapat menggunakannya untuk mengenkripsi dan mendekripsi data. Namun, pemilik sumber daya dapat memberikan izin untuk mengakses kunci ke pengguna dan sumber daya lain. Dengan langkah ini, Anda memberikan izin utama layanan CloudWatch Log untuk menggunakan kunci. Prinsipal layanan ini harus berada di AWS Wilayah yang sama di mana kunci disimpan.
Sebagai praktik terbaik, kami menyarankan Anda membatasi penggunaan kunci hanya untuk AWS akun yang Anda tentukan.
Pertama, simpan kebijakan default untuk kunci KMS Anda seperti `policy.json` menggunakan [get-key-policy](https://docs.aws.amazon.com/cli/latest/reference/kms/get-key-policy.html)perintah berikut:
```
aws kms get-key-policy --key-id key-id --policy-name default --output text > ./policy.json
```
Buka file `policy.json` di editor teks dan tambahkan bagian dalam huruf tebal dari salah satu pernyataan berikut. Pisahkan pernyataan yang ada dari pernyataan baru dengan koma. Pernyataan ini menggunakan `Condition` bagian untuk meningkatkan keamanan AWS KMS kunci. Untuk informasi selengkapnya, lihat [AWS KMS kunci dan konteks enkripsi](encrypt-log-data-kms.md#encrypt-log-data-kms-policy).
`Condition`Bagian dalam contoh ini membatasi penggunaan AWS KMS kunci untuk hasil kueri Wawasan CloudWatch Log di akun yang ditentukan.
------
#### [ 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"
}
}
}
]
}
```
------
Terakhir, tambahkan kebijakan yang diperbarui menggunakan [put-key-policy](https://docs.aws.amazon.com/cli/latest/reference/kms/put-key-policy.html)perintah berikut:
```
aws kms put-key-policy --key-id key-id --policy-name default --policy file://policy.json
```
## Langkah 3: Kaitkan kunci KMS dengan hasil kueri Anda
**Untuk mengaitkan kunci KMS dengan hasil kueri di akun**
Gunakan [disassociate-kms-key](https://docs.aws.amazon.com/cli/latest/reference/logs/disassociate-kms-key.html)perintah sebagai berikut:
```
aws logs associate-kms-key --resource-identifier "arn:aws:logs:region:account-id:query-result:*" --kms-key-id "key-arn"
```
## Langkah 4: Lepaskan kunci dari hasil kueri di akun
Untuk memisahkan kunci KMS yang terkait dengan hasil kueri, gunakan perintah berikut: [disassociate-kms-key](https://docs.aws.amazon.com/cli/latest/reference/logs/disassociate-kms-key.html)
```
aws logs disassociate-kms-key --resource-identifier "arn:aws:logs:region:account-id:query-result:*"
```
# Hasilkan ringkasan bahasa alami dari hasil kueri CloudWatch Log Insights
Menganalisis data log sangat penting untuk memahami perilaku aplikasi Anda, tetapi menafsirkan volume besar entri log dapat memakan waktu. CloudWatch Logs Insights sekarang menawarkan kemampuan meringkas bahasa alami yang mengubah hasil kueri yang kompleks menjadi ringkasan yang jelas dan ringkas. Kemampuan ini membantu Anda mengidentifikasi masalah dengan cepat dan mendapatkan wawasan yang dapat ditindaklanjuti dari data log Anda.
## Cara kerjanya
CloudWatch Wawasan Log dapat menghasilkan ringkasan yang dapat dibaca manusia dari hasil kueri menggunakan Amazon Bedrock. Fitur ini mendukung semua bahasa kueri Wawasan CloudWatch Log dan memberikan wawasan yang jelas dan dapat ditindaklanjuti dari data log Anda.
## Ketersediaan regional dan pemrosesan data
**penting**
Saat Anda menggunakan fitur ini, hasil kueri Anda mungkin akan diproses dengan cara yang berbeda Wilayah AWS. Misalnya, jika Anda menjalankan kueri di US East (Virginia N.), ringkasan mungkin terjadi di AS Barat (Oregon).
Tabel berikut mencantumkan kemungkinan pemrosesan Wilayah AWS untuk geografi yang berbeda di mana fitur hasil kueri tersedia:
| Geografi CloudWatch Log yang Didukung | Wilayah Pemrosesan yang Mungkin |
| --- | --- |
| Amerika Serikat (US) | Wilayah AS Timur (N. Virginia) Wilayah AS Timur (Ohio) Wilayah AS Barat (Oregon) |
| Eropa | Wilayah Eropa (Frankfurt) Wilayah Eropa (Irlandia) Wilayah Eropa (Paris) Wilayah Eropa (Stockholm) Wilayah Eropa (London) |
| Asia Pasifik | Wilayah AS Timur (N. Virginia) Wilayah AS Timur (Ohio) Wilayah AS Barat (Oregon) |
| Amerika Selatan | Wilayah AS Timur (N. Virginia) Wilayah AS Timur (Ohio) Wilayah AS Barat (Oregon) |
## Memulai
**Untuk menghasilkan ringkasan bahasa alami**
1. Jalankan kueri Wawasan CloudWatch Log Anda.
1. Setelah kueri selesai, pilih **Ringkas hasil**.
## Izin
Anda harus memiliki salah satu dari yang berikut:
+ Izin `CloudWatchLogsFullAccess`
+ Izin `CloudWatchLogsReadOnlyAccess`
+ Kebijakan IAM khusus termasuk`cloudwatch:GenerateQueryResultsSummary`,`logs:GetQueryResults`, `logs:DescribeQueries` dan tindakan `logs:FilterLogEvents`
## Privasi data
Hasil kueri Anda diproses dengan aman dan tidak digunakan untuk melatih atau meningkatkan Wawasan CloudWatch Log atau Amazon Bedrock. Jika Anda memilih untuk memberikan umpan balik pada ringkasan hasil kueri menggunakan tombol umpan balik, umpan balik Anda menunjukkan tingkat kepuasan Anda dengan kemampuan yang disediakan dalam Wawasan CloudWatch Log.