Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Filter langganan tingkat grup log
Anda dapat menggunakan filter langganan dengan Amazon Kinesis Data AWS Lambda Streams, Amazon Data Firehose, atau Amazon Service. OpenSearch Log yang dikirim ke layanan melalui filter langganan dikodekan base64 dan dikompresi dengan format gzip. Jika Anda menggunakan log terpusat dengan Anda AWS Organizations, Anda dapat memilih untuk memancarkan bidang `@aws.account` dan `@aws.region` sistem untuk mengidentifikasi data mana yang berasal dari akun dan wilayah mana di organisasi Anda. Bagian ini memberikan contoh yang dapat Anda ikuti untuk membuat filter langganan CloudWatch Log yang mengirimkan data log ke Firehose, Lambda, Amazon Kinesis Data Streams, dan Layanan. OpenSearch
**catatan**
Jika Anda ingin mencari data log Anda, lihat [Filter dan sintaks pola](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html).
**Topics**
+ [Contoh 1: Filter langganan dengan Amazon Kinesis Data Streams](#DestinationKinesisExample)
+ [Contoh 2: Filter berlangganan dengan AWS Lambda](#LambdaFunctionExample)
+ [Contoh 3: Filter berlangganan dengan Amazon Data Firehose](#FirehoseExample)
+ [Contoh 4: Filter berlangganan dengan OpenSearch Layanan Amazon](#OpenSearchExample)
## Contoh 1: Filter langganan dengan Amazon Kinesis Data Streams
Contoh berikut mengaitkan filter langganan dengan grup log yang berisi AWS CloudTrail peristiwa. Filter langganan mengirimkan setiap aktivitas yang dicatat yang dibuat oleh AWS kredensi “Root” ke aliran di Amazon Kinesis Data Streams yang disebut ".” RootAccess Untuk informasi selengkapnya tentang cara mengirim AWS CloudTrail peristiwa ke CloudWatch Log, lihat [Mengirim CloudTrail Acara ke CloudWatch Log](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cw_send_ct_events.html) di *Panduan AWS CloudTrail Pengguna*.
**catatan**
Sebelum Anda membuat aliran, hitung volume data log yang akan dihasilkan. Pastikan untuk membuat aliran dengan pecahan yang cukup untuk menangani volume ini. Jika pengaliran tidak memiliki serpihan yang cukup, pengaliran log akan mengalami throttling. Untuk informasi selengkapnya tentang batas volume streaming, lihat [Kuota dan Batas](https://docs.aws.amazon.com/streams/latest/dev/service-sizes-and-limits.html).
Kiriman yang dibatasi dicoba ulang hingga 24 jam. Setelah 24 jam, kiriman yang gagal dijatuhkan.
Untuk mengurangi risiko pelambatan, Anda dapat mengambil langkah-langkah berikut:
Tentukan `random` `distribution` kapan Anda membuat filter langganan dengan [ PutSubscriptionFilter](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutSubscriptionFilter.html#CWL-PutSubscriptionFilter-request-distribution)atau [ put-subscription-filter](https://awscli.amazonaws.com/v2/documentation/api/2.4.18/reference/logs/put-subscription-filter.html). Secara default, distribusi filter aliran adalah dengan aliran log dan ini dapat menyebabkan pelambatan.
Pantau streaming Anda menggunakan CloudWatch metrik. Ini membantu Anda mengidentifikasi pelambatan apa pun dan menyesuaikan konfigurasi Anda sesuai dengan itu. Misalnya, `DeliveryThrottling` metrik dapat digunakan untuk melacak jumlah peristiwa CloudWatch log yang Log dibatasi saat meneruskan data ke tujuan langganan. Untuk informasi selengkapnya tentang pemantauan, lihat [Pemantauan dengan CloudWatch metrik](CloudWatch-Logs-Monitoring-CloudWatch-Metrics.md).
Gunakan mode kapasitas sesuai permintaan untuk streaming Anda di Amazon Kinesis Data Streams. Mode sesuai permintaan langsung mengakomodasi beban kerja Anda saat naik atau turun. Informasi selengkapnya tentang mode kapasitas sesuai permintaan, lihat Mode [sesuai permintaan](https://docs.aws.amazon.com/streams/latest/dev/how-do-i-size-a-stream.html#ondemandmode).
Batasi pola filter CloudWatch langganan agar sesuai dengan kapasitas streaming Anda di Amazon Kinesis Data Streams. Jika Anda mengirim terlalu banyak data ke aliran, Anda mungkin perlu mengurangi ukuran filter atau menyesuaikan kriteria filter.
**Untuk membuat filter langganan untuk Amazon Kinesis Data Streams**
1. Buat aliran tujuan menggunakan perintah berikut:
```
$ C:\> aws kinesis create-stream --stream-name "RootAccess" --shard-count 1
```
1. Tunggu hingga aliran menjadi Aktif (ini mungkin memakan waktu satu atau dua menit). **Anda dapat menggunakan perintah Amazon Kinesis [Data](https://docs.aws.amazon.com/cli/latest/reference/kinesis/describe-stream.html) Streams describe-stream berikut untuk memeriksa. StreamDescription StreamStatus**properti. Selain itu, perhatikan **StreamDescriptionnilai.streaMarn**, karena Anda akan membutuhkannya di langkah selanjutnya:
```
aws kinesis describe-stream --stream-name "RootAccess"
```
Berikut ini adalah output contoh:
```
{
"StreamDescription": {
"StreamStatus": "ACTIVE",
"StreamName": "RootAccess",
"StreamARN": "arn:aws:kinesis:us-east-1:123456789012:stream/RootAccess",
"Shards": [
{
"ShardId": "shardId-000000000000",
"HashKeyRange": {
"EndingHashKey": "340282366920938463463374607431768211455",
"StartingHashKey": "0"
},
"SequenceNumberRange": {
"StartingSequenceNumber":
"49551135218688818456679503831981458784591352702181572610"
}
}
]
}
}
```
1. Buat peran IAM yang akan memberikan izin CloudWatch Log untuk memasukkan data ke aliran Anda. Pertama, Anda harus membuat kebijakan kepercayaan dalam file (misalnya, `~/TrustPolicyForCWL-Kinesis.json`). Gunakan editor teks untuk membuat kebijakan ini. Jangan gunakan konsol IAM untuk membuatnya.
Kebijakan ini mencakup kunci konteks kondisi `aws:SourceArn` global untuk membantu mencegah masalah keamanan wakil yang membingungkan. Untuk informasi selengkapnya, lihat [Pencegahan Deputi Bingung](Subscriptions-confused-deputy.md).
```
{
"Statement": {
"Effect": "Allow",
"Principal": { "Service": "logs.amazonaws.com" },
"Action": "sts:AssumeRole",
"Condition": {
"StringLike": { "aws:SourceArn": "arn:aws:logs:region:123456789012:*" }
}
}
}
```
1. Gunakan perintah **create-role** untuk membuat IAM role, dengan menentukan file kebijakan kepercayaan. Perhatikan nilai **Role.Arn** yang dihasilkan, karena Anda juga akan membutuhkannya untuk langkah selanjutnya:
```
aws iam create-role --role-name CWLtoKinesisRole --assume-role-policy-document file://~/TrustPolicyForCWL-Kinesis.json
```
Berikut adalah contoh output.
```
{
"Role": {
"AssumeRolePolicyDocument": {
"Statement": {
"Action": "sts:AssumeRole",
"Effect": "Allow",
"Principal": {
"Service": "logs.amazonaws.com"
},
"Condition": {
"StringLike": {
"aws:SourceArn": { "arn:aws:logs:region:123456789012:*" }
}
}
}
},
"RoleId": "AAOIIAH450GAB4HC5F431",
"CreateDate": "2015-05-29T13:46:29.431Z",
"RoleName": "CWLtoKinesisRole",
"Path": "/",
"Arn": "arn:aws:iam::123456789012:role/CWLtoKinesisRole"
}
}
```
1. Buat kebijakan izin untuk menentukan tindakan apa yang dapat dilakukan CloudWatch Log di akun Anda. Pertama, Anda akan membuat kebijakan izin dalam file (misalnya, `~/PermissionsForCWL-Kinesis.json`). Gunakan editor teks untuk membuat kebijakan ini. Jangan gunakan konsol IAM untuk membuatnya.
```
{
"Statement": [
{
"Effect": "Allow",
"Action": "kinesis:PutRecord",
"Resource": "arn:aws:kinesis:region:123456789012:stream/RootAccess"
}
]
}
```
1. Kaitkan kebijakan izin dengan peran menggunakan [put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)perintah berikut:
```
aws iam put-role-policy --role-name CWLtoKinesisRole --policy-name Permissions-Policy-For-CWL --policy-document file://~/PermissionsForCWL-Kinesis.json
```
1. Setelah streaming dalam status **Aktif** dan Anda telah membuat peran IAM, Anda dapat membuat filter langganan CloudWatch Log. Filter langganan segera memulai aliran data log waktu nyata dari grup log yang dipilih ke aliran Anda:
```
aws logs put-subscription-filter \
--log-group-name "CloudTrail/logs" \
--filter-name "RootAccess" \
--filter-pattern "{$.userIdentity.type = Root}" \
--destination-arn "arn:aws:kinesis:region:123456789012:stream/RootAccess" \
--role-arn "arn:aws:iam::123456789012:role/CWLtoKinesisRole"
```
1. Setelah Anda mengatur filter langganan, CloudWatch Log meneruskan semua peristiwa log masuk yang cocok dengan pola filter ke aliran Anda. Anda dapat memverifikasi bahwa ini terjadi dengan mengambil iterator pecahan Amazon Kinesis Data Streams dan menggunakan perintah Amazon Kinesis Data Streams get-records untuk mengambil beberapa rekaman Amazon Kinesis Data Streams:
```
aws kinesis get-shard-iterator --stream-name RootAccess --shard-id shardId-000000000000 --shard-iterator-type TRIM_HORIZON
```
```
{
"ShardIterator":
"AAAAAAAAAAFGU/kLvNggvndHq2UIFOw5PZc6F01s3e3afsSscRM70JSbjIefg2ub07nk1y6CDxYR1UoGHJNP4m4NFUetzfL+wev+e2P4djJg4L9wmXKvQYoE+rMUiFq+p4Cn3IgvqOb5dRA0yybNdRcdzvnC35KQANoHzzahKdRGb9v4scv+3vaq+f+OIK8zM5My8ID+g6rMo7UKWeI4+IWiK2OSh0uP"
}
```
```
aws kinesis get-records --limit 10 --shard-iterator "AAAAAAAAAAFGU/kLvNggvndHq2UIFOw5PZc6F01s3e3afsSscRM70JSbjIefg2ub07nk1y6CDxYR1UoGHJNP4m4NFUetzfL+wev+e2P4djJg4L9wmXKvQYoE+rMUiFq+p4Cn3IgvqOb5dRA0yybNdRcdzvnC35KQANoHzzahKdRGb9v4scv+3vaq+f+OIK8zM5My8ID+g6rMo7UKWeI4+IWiK2OSh0uP"
```
Perhatikan bahwa Anda mungkin perlu melakukan panggilan ini beberapa kali sebelum Amazon Kinesis Data Streams mulai mengembalikan data.
Anda akan melihat respons dengan array catatan. Atribut **Data** dalam catatan Amazon Kinesis Data Streams dikodekan base64 dan dikompresi dengan format gzip. Anda dapat memeriksa data mentah dari baris perintah menggunakan perintah Unix berikut:
```
echo -n "" | base64 -d | zcat
```
Data yang didekode dan didekompresi base64 diformat sebagai JSON dengan struktur berikut:
```
{
"owner": "111111111111",
"logGroup": "CloudTrail/logs",
"logStream": "111111111111_CloudTrail/logs_us-east-1",
"subscriptionFilters": [
"Destination"
],
"messageType": "DATA_MESSAGE",
"logEvents": [
{
"id": "31953106606966983378809025079804211143289615424298221568",
"timestamp": 1432826855000,
"message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}"
},
{
"id": "31953106606966983378809025079804211143289615424298221569",
"timestamp": 1432826855000,
"message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}"
},
{
"id": "31953106606966983378809025079804211143289615424298221570",
"timestamp": 1432826855000,
"message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}"
}
]
}
```
Elemen kunci dalam struktur data di atas adalah sebagai berikut:
**owner**
ID AWS Akun dari data log asal.
**logGroup**
Nama grup log dari data log asal.
**logStream**
Nama pengaliran log dari data log asal.
**subscriptionFilters**
Daftar nama filter langganan yang cocok dengan data log asal.
**messageType**
Pesan data akan menggunakan tipe "DATA\$1MESSAGE". Terkadang CloudWatch Log dapat memancarkan catatan Amazon Kinesis Data Streams dengan tipe “CONTROL\$1MESSAGE”, terutama untuk memeriksa apakah tujuan dapat dijangkau.
**logEvents**
Data log yang sebenarnya, direpresentasikan sebagai array catatan log acara. Properti "id" adalah pengenal unik untuk setiap log acara.
## Contoh 2: Filter berlangganan dengan AWS Lambda
Dalam contoh ini, Anda akan membuat filter langganan CloudWatch Log yang mengirimkan data log ke AWS Lambda fungsi Anda.
**catatan**
Sebelum membuat fungsi Lambda, hitung volume data log yang akan dihasilkan. Pastikan untuk membuat fungsi yang dapat menangani volume ini. Jika fungsi tidak memiliki volume yang cukup, pengaliran log akan mengalami throttling. Untuk informasi selengkapnya tentang batas Lambda, lihat [Batas AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/limits.html).
**Untuk membuat filter langganan untuk Lambda**
1. Buat AWS Lambda fungsinya.
Pastikan bahwa Anda telah mengatur peran eksekusi Lambda. Untuk informasi selengkapnya, lihat: [Langkah 2.2: Buat IAM role (peran eksekusi)](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) dalam *Panduan Developer AWS Lambda *.
1. Buka editor teks dan buat file bernama `helloWorld.js`dengan isi sebagai berikut:
```
var zlib = require('zlib');
exports.handler = function(input, context) {
var payload = Buffer.from(input.awslogs.data, 'base64');
zlib.gunzip(payload, function(e, result) {
if (e) {
context.fail(e);
} else {
result = JSON.parse(result.toString());
console.log("Event Data:", JSON.stringify(result, null, 2));
context.succeed();
}
});
};
```
1. Buat zip file helloWorld.js dan simpan dengan nama `helloWorld.zip`.
1. Gunakan perintah berikut, di mana perannya adalah peran eksekusi Lambda yang Anda atur di langkah pertama:
```
aws lambda create-function \
--function-name helloworld \
--zip-file fileb://file-path/helloWorld.zip \
--role lambda-execution-role-arn \
--handler helloWorld.handler \
--runtime nodejs12.x
```
1. Berikan CloudWatch Log izin untuk menjalankan fungsi Anda. Gunakan perintah berikut, dengan mengganti akun placeholder dengan akun Anda sendiri dan grup log placeholder dengan grup log yang akan diproses:
```
aws lambda add-permission \
--function-name "helloworld" \
--statement-id "helloworld" \
--principal "logs.amazonaws.com" \
--action "lambda:InvokeFunction" \
--source-arn "arn:aws:logs:region:123456789123:log-group:TestLambda:*" \
--source-account "123456789012"
```
1. Buat filter langganan menggunakan perintah berikut, dengan mengganti akun placeholder dengan akun Anda sendiri dan grup log placeholder dengan grup log yang akan diproses:
```
aws logs put-subscription-filter \
--log-group-name myLogGroup \
--filter-name demo \
--filter-pattern "" \
--destination-arn arn:aws:lambda:region:123456789123:function:helloworld
```
1. (Opsional) Uji menggunakan contoh log acara. Di jendela perintah, jalankan perintah berikut, yang akan menempatkan pesan log sederhana ke dalam pengaliran langganan.
Untuk melihat output dari fungsi Lambda Anda, navigasikan ke fungsi Lambda di mana Anda akan melihat output di/: aws/lambda/helloworld
```
aws logs put-log-events --log-group-name myLogGroup --log-stream-name stream1 --log-events "[{\"timestamp\": , \"message\": \"Simple Lambda Test\"}]"
```
Anda akan melihat respons dengan array Lambda. Atribut **Data** dalam catatan Lambda adalah base64 dikodekan dan dikompresi dengan format gzip. Muatan sebenarnya yang diterima oleh Lambda memiliki format berikut `{ "awslogs": {"data": "BASE64ENCODED_GZIP_COMPRESSED_DATA"} }` Anda dapat memeriksa data mentah dari baris perintah menggunakan perintah Unix berikut:
```
echo -n "" | base64 -d | zcat
```
Data yang didekode dan didekompresi base64 diformat sebagai JSON dengan struktur berikut:
```
{
"owner": "123456789012",
"logGroup": "CloudTrail",
"logStream": "123456789012_CloudTrail_us-east-1",
"subscriptionFilters": [
"Destination"
],
"messageType": "DATA_MESSAGE",
"logEvents": [
{
"id": "31953106606966983378809025079804211143289615424298221568",
"timestamp": 1432826855000,
"message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}"
},
{
"id": "31953106606966983378809025079804211143289615424298221569",
"timestamp": 1432826855000,
"message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}"
},
{
"id": "31953106606966983378809025079804211143289615424298221570",
"timestamp": 1432826855000,
"message": "{\"eventVersion\":\"1.03\",\"userIdentity\":{\"type\":\"Root\"}"
}
]
}
```
Elemen kunci dalam struktur data di atas adalah sebagai berikut:
**owner**
ID AWS Akun dari data log asal.
**logGroup**
Nama grup log dari data log asal.
**logStream**
Nama pengaliran log dari data log asal.
**subscriptionFilters**
Daftar nama filter langganan yang cocok dengan data log asal.
**messageType**
Pesan data akan menggunakan tipe "DATA\$1MESSAGE". Terkadang CloudWatch Log dapat memancarkan catatan Lambda dengan tipe “CONTROL\$1MESSAGE”, terutama untuk memeriksa apakah tujuan dapat dijangkau.
**logEvents**
Data log yang sebenarnya, direpresentasikan sebagai array catatan log acara. Properti "id" adalah pengenal unik untuk setiap log acara.
## Contoh 3: Filter berlangganan dengan Amazon Data Firehose
Dalam contoh ini, Anda akan membuat langganan CloudWatch Log yang mengirimkan peristiwa log masuk yang cocok dengan filter yang Anda tentukan ke aliran pengiriman Amazon Data Firehose Anda. Data yang dikirim dari CloudWatch Log ke Amazon Data Firehose sudah dikompresi dengan kompresi gzip level 6, jadi Anda tidak perlu menggunakan kompresi dalam aliran pengiriman Firehose Anda. Anda kemudian dapat menggunakan fitur dekompresi di Firehose untuk mendekompresi log secara otomatis. Untuk informasi selengkapnya, lihat [Mengirim CloudWatch Log ke Firehose](https://docs.aws.amazon.com/logs/SubscriptionFilters.html#FirehoseExample).
**catatan**
Sebelum Anda membuat aliran Firehose, hitung volume data log yang akan dihasilkan. Pastikan untuk membuat aliran Firehose yang dapat menangani volume ini. Jika pengaliran tidak dapat menangani volume, pengaliran log akan mengalami throttling. Untuk informasi selengkapnya tentang batas volume aliran Firehose, lihat Batas Data [Firehose Amazon](https://docs.aws.amazon.com/firehose/latest/dev/limits.html) Data.
**Untuk membuat filter langganan untuk Firehose**
1. Buat bucket Amazon Simple Storage Service (Amazon S3). Kami menyarankan Anda menggunakan bucket yang dibuat khusus untuk CloudWatch Log. Namun, jika Anda ingin menggunakan bucket yang sudah ada, lewati ke langkah 2.
Jalankan perintah berikut, dengan mengganti Wilayah placeholder dengan Wilayah yang ingin Anda gunakan:
```
aws s3api create-bucket --bucket amzn-s3-demo-bucket2 --create-bucket-configuration LocationConstraint=region
```
Berikut ini adalah output contoh:
```
{
"Location": "/amzn-s3-demo-bucket2"
}
```
1. Buat peran IAM yang memberikan izin Amazon Data Firehose untuk memasukkan data ke dalam bucket Amazon S3 Anda.
Untuk informasi selengkapnya, lihat [Mengontrol Akses dengan Amazon Data Firehose di Panduan Pengembang](https://docs.aws.amazon.com/firehose/latest/dev/controlling-access.html) *Amazon Data Firehose*.
Pertama, gunakan editor teks untuk membuat kebijakan kepercayaan dalam file `~/TrustPolicyForFirehose.json` sebagai berikut:
```
{
"Statement": {
"Effect": "Allow",
"Principal": { "Service": "firehose.amazonaws.com" },
"Action": "sts:AssumeRole"
}
}
```
1. Gunakan perintah **create-role** untuk membuat IAM role, dengan menentukan file kebijakan kepercayaan. Perhatikan nilai **Role.Arn** yang dihasilkan, karena Anda akan membutuhkannya dalam langkah selanjutnya:
```
aws iam create-role \
--role-name FirehosetoS3Role \
--assume-role-policy-document file://~/TrustPolicyForFirehose.json
{
"Role": {
"AssumeRolePolicyDocument": {
"Statement": {
"Action": "sts:AssumeRole",
"Effect": "Allow",
"Principal": {
"Service": "firehose.amazonaws.com"
}
}
},
"RoleId": "AAOIIAH450GAB4HC5F431",
"CreateDate": "2015-05-29T13:46:29.431Z",
"RoleName": "FirehosetoS3Role",
"Path": "/",
"Arn": "arn:aws:iam::123456789012:role/FirehosetoS3Role"
}
}
```
1. Buat kebijakan izin untuk menentukan tindakan apa yang dapat dilakukan Firehose di akun Anda. Pertama, gunakan editor teks untuk membuat kebijakan izin dalam file `~/PermissionsForFirehose.json`:
```
{
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:AbortMultipartUpload",
"s3:GetBucketLocation",
"s3:GetObject",
"s3:ListBucket",
"s3:ListBucketMultipartUploads",
"s3:PutObject" ],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket2",
"arn:aws:s3:::amzn-s3-demo-bucket2/*" ]
}
]
}
```
1. Kaitkan kebijakan izin dengan peran menggunakan put-role-policy perintah berikut:
```
aws iam put-role-policy --role-name FirehosetoS3Role --policy-name Permissions-Policy-For-Firehose --policy-document file://~/PermissionsForFirehose.json
```
1. Buat aliran pengiriman Firehose tujuan sebagai berikut, ganti nilai placeholder untuk **RoLearn** dan **BucketArn dengan peran dan bucket** yang Anda buat: ARNs
```
aws firehose create-delivery-stream \
--delivery-stream-name 'my-delivery-stream' \
--s3-destination-configuration \
'{"RoleARN": "arn:aws:iam::123456789012:role/FirehosetoS3Role", "BucketARN": "arn:aws:s3:::amzn-s3-demo-bucket2"}'
```
Perhatikan bahwa Firehose secara otomatis menggunakan awalan dalam format waktu YYYY/MM/DD/HH UTC untuk objek Amazon S3 yang dikirimkan. Anda dapat menentukan prefiks tambahan untuk ditambahkan di depan prefiks format waktu. Jika prefiks berakhir dengan garis miring (/), itu akan muncul sebagai folder dalam bucket Amazon S3.
1. Tunggu sampai pengaliran menjadi aktif (ini mungkin memakan waktu beberapa menit). **Anda dapat menggunakan **describe-delivery-stream**perintah Firehose untuk memeriksa. DeliveryStreamDescription DeliveryStreamStatus**properti. Selain itu, perhatikan **DeliveryStreamDescription. DeliveryStreamNilai ARN**, karena Anda akan membutuhkannya di langkah selanjutnya:
```
aws firehose describe-delivery-stream --delivery-stream-name "my-delivery-stream"
{
"DeliveryStreamDescription": {
"HasMoreDestinations": false,
"VersionId": "1",
"CreateTimestamp": 1446075815.822,
"DeliveryStreamARN": "arn:aws:firehose:us-east-1:123456789012:deliverystream/my-delivery-stream",
"DeliveryStreamStatus": "ACTIVE",
"DeliveryStreamName": "my-delivery-stream",
"Destinations": [
{
"DestinationId": "destinationId-000000000001",
"S3DestinationDescription": {
"CompressionFormat": "UNCOMPRESSED",
"EncryptionConfiguration": {
"NoEncryptionConfig": "NoEncryption"
},
"RoleARN": "delivery-stream-role",
"BucketARN": "arn:aws:s3:::amzn-s3-demo-bucket2",
"BufferingHints": {
"IntervalInSeconds": 300,
"SizeInMBs": 5
}
}
}
]
}
}
```
1. Buat peran IAM yang memberikan izin CloudWatch Log untuk memasukkan data ke aliran pengiriman Firehose Anda. Pertama, gunakan editor teks untuk membuat kebijakan kepercayaan dalam file `~/TrustPolicyForCWL.json`:
Kebijakan ini mencakup kunci konteks kondisi `aws:SourceArn` global untuk membantu mencegah masalah keamanan wakil yang membingungkan. Untuk informasi selengkapnya, lihat [Pencegahan Deputi Bingung](Subscriptions-confused-deputy.md).
```
{
"Statement": {
"Effect": "Allow",
"Principal": { "Service": "logs.amazonaws.com" },
"Action": "sts:AssumeRole",
"Condition": {
"StringLike": {
"aws:SourceArn": "arn:aws:logs:region:123456789012:*"
}
}
}
}
```
1. Gunakan perintah **create-role** untuk membuat IAM role, dengan menentukan file kebijakan kepercayaan. Perhatikan nilai **Role.Arn** yang dihasilkan, karena Anda akan membutuhkannya dalam langkah selanjutnya:
```
aws iam create-role \
--role-name CWLtoKinesisFirehoseRole \
--assume-role-policy-document file://~/TrustPolicyForCWL.json
{
"Role": {
"AssumeRolePolicyDocument": {
"Statement": {
"Action": "sts:AssumeRole",
"Effect": "Allow",
"Principal": {
"Service": "logs.amazonaws.com"
},
"Condition": {
"StringLike": {
"aws:SourceArn": "arn:aws:logs:region:123456789012:*"
}
}
}
},
"RoleId": "AAOIIAH450GAB4HC5F431",
"CreateDate": "2015-05-29T13:46:29.431Z",
"RoleName": "CWLtoKinesisFirehoseRole",
"Path": "/",
"Arn": "arn:aws:iam::123456789012:role/CWLtoKinesisFirehoseRole"
}
}
```
1. Buat kebijakan izin untuk menentukan tindakan apa yang dapat dilakukan CloudWatch Log di akun Anda. Pertama, gunakan editor teks untuk membuat file kebijakan izin (misalnya, `~/PermissionsForCWL.json`):
```
{
"Statement":[
{
"Effect":"Allow",
"Action":["firehose:PutRecord"],
"Resource":[
"arn:aws:firehose:region:account-id:deliverystream/delivery-stream-name"]
}
]
}
```
1. Kaitkan kebijakan izin dengan peran menggunakan put-role-policy perintah:
```
aws iam put-role-policy --role-name CWLtoKinesisFirehoseRole --policy-name Permissions-Policy-For-CWL --policy-document file://~/PermissionsForCWL.json
```
1. Setelah aliran pengiriman Amazon Data Firehose dalam keadaan aktif dan Anda telah membuat peran IAM, Anda dapat membuat filter langganan CloudWatch Log. Filter langganan segera memulai aliran data log waktu nyata dari grup log yang dipilih ke aliran pengiriman Amazon Data Firehose Anda:
```
aws logs put-subscription-filter \
--log-group-name "CloudTrail" \
--filter-name "Destination" \
--filter-pattern "{$.userIdentity.type = Root}" \
--destination-arn "arn:aws:firehose:region:123456789012:deliverystream/my-delivery-stream" \
--role-arn "arn:aws:iam::123456789012:role/CWLtoKinesisFirehoseRole"
```
1. Setelah Anda mengatur filter langganan, CloudWatch Log akan meneruskan semua peristiwa log masuk yang cocok dengan pola filter ke aliran pengiriman Amazon Data Firehose Anda. Data Anda akan mulai muncul di Amazon S3 berdasarkan interval buffer waktu yang ditetapkan pada aliran pengiriman Amazon Data Firehose Anda. Setelah waktu tertentu berlalu, Anda dapat memverifikasi data dengan memeriksa Bucket Amazon S3 Anda.
```
aws s3api list-objects --bucket 'amzn-s3-demo-bucket2' --prefix 'firehose/'
{
"Contents": [
{
"LastModified": "2015-10-29T00:01:25.000Z",
"ETag": "\"a14589f8897f4089d3264d9e2d1f1610\"",
"StorageClass": "STANDARD",
"Key": "firehose/2015/10/29/00/my-delivery-stream-2015-10-29-00-01-21-a188030a-62d2-49e6-b7c2-b11f1a7ba250",
"Owner": {
"DisplayName": "cloudwatch-logs",
"ID": "1ec9cf700ef6be062b19584e0b7d84ecc19237f87b5"
},
"Size": 593
},
{
"LastModified": "2015-10-29T00:35:41.000Z",
"ETag": "\"a7035b65872bb2161388ffb63dd1aec5\"",
"StorageClass": "STANDARD",
"Key": "firehose/2015/10/29/00/my-delivery-stream-2015-10-29-00-35-40-7cc92023-7e66-49bc-9fd4-fc9819cc8ed3",
"Owner": {
"DisplayName": "cloudwatch-logs",
"ID": "1ec9cf700ef6be062b19584e0b7d84ecc19237f87b6"
},
"Size": 5752
}
]
}
```
```
aws s3api get-object --bucket 'amzn-s3-demo-bucket2' --key 'firehose/2015/10/29/00/my-delivery-stream-2015-10-29-00-01-21-a188030a-62d2-49e6-b7c2-b11f1a7ba250' testfile.gz
{
"AcceptRanges": "bytes",
"ContentType": "application/octet-stream",
"LastModified": "Thu, 29 Oct 2015 00:07:06 GMT",
"ContentLength": 593,
"Metadata": {}
}
```
Data dalam objek Amazon S3 dikompresi dengan format gzip. Anda dapat memeriksa data mentah dari baris perintah menggunakan perintah Unix berikut:
```
zcat testfile.gz
```
## Contoh 4: Filter berlangganan dengan OpenSearch Layanan Amazon
Dalam contoh ini, Anda akan membuat langganan CloudWatch Log yang mengirimkan peristiwa log masuk yang cocok dengan filter yang ditentukan ke domain OpenSearch Layanan Anda.
**Untuk membuat filter langganan untuk OpenSearch Layanan**
1. Buat domain OpenSearch Layanan. Untuk informasi selengkapnya, lihat [Membuat domain OpenSearch Layanan](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/createupdatedomains.html#createdomains)
1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Pada panel navigasi, pilih **Grup log**.
1. Pilih nama grup log.
1. Pilih **Tindakan**, **Filter langganan**, **Buat filter langganan OpenSearch Layanan Amazon**.
1. Pilih apakah Anda ingin melakukan pengaliran ke klaster di akun ini atau akun lain.
+ Jika Anda memilih **Akun ini**, pilih domain yang Anda buat di langkah 1.
+ Jika Anda memilih **Akun lain**, masukkan ARN dan titik akhir domain tersebut.
1. Jika Anda memilih akun lain, berikan domain ARN dan endpoint.
1. Untuk Amazon OpenSearch Service cluster pilih nama cluster tempat data grup log akan dikirimkan
1. Pilih format log.
1. Untuk **pola filter Langganan**, masukkan istilah atau pola yang akan ditemukan di peristiwa log Anda. Ini memastikan bahwa Anda hanya mengirim data yang Anda minati ke kluster OpenSearch Layanan Anda. Untuk informasi selengkapnya, lihat [Filter sintaks pola untuk filter metrik](FilterAndPatternSyntaxForMetricFilters.md).
1. (Opsional) Untuk **Pilih data log yang akan diuji**, pilih aliran log lalu pilih **Pola uji** untuk memverifikasi bahwa filter pencarian Anda mengembalikan hasil yang Anda harapkan.
1. Pilih **Mulai streaming**.