本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 日誌群組層級訂閱篩選條件
您可以搭配 Amazon Kinesis Data Streams AWS Lambda、Amazon Data Firehose 或 Amazon OpenSearch Service 使用訂閱篩選條件。透過訂閱篩選條件傳送到服務的日誌會以 gzip 格式進行 base64 編碼和壓縮。如果您搭配 使用集中式日誌 AWS Organizations，您可以選擇發出 `@aws.account`和 `@aws.region` 系統欄位，以識別哪些資料來自組織中的帳戶和區域。本節提供您可以遵循的範例，以建立 CloudWatch Logs 訂閱篩選條件，將日誌資料傳送至 Firehose、Lambda、Amazon Kinesis Data Streams 和 OpenSearch Service。
**注意**
如果您想要搜尋日誌資料，請參閱[篩選和模式語法](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html)。
**Topics**
+ [範例 1：使用 Amazon Kinesis Data Streams 的訂閱篩選條件](#DestinationKinesisExample)
+ [範例 2：使用 的訂閱篩選條件 AWS Lambda](#LambdaFunctionExample)
+ [範例 3：使用 Amazon Data Firehose 的訂閱篩選條件](#FirehoseExample)
+ [範例 4：使用 Amazon OpenSearch Service 的訂閱篩選條件](#OpenSearchExample)
## 範例 1：使用 Amazon Kinesis Data Streams 的訂閱篩選條件
下列範例將訂閱篩選條件與包含 AWS CloudTrail 事件的日誌群組建立關聯。訂閱篩選條件會將 "Root" AWS credentials 所做的每個記錄活動交付至 Amazon Kinesis Data Streams 中名為 "RootAccess." 如需如何將 AWS CloudTrail 事件傳送至 CloudWatch Logs 的詳細資訊，請參閱*AWS CloudTrail 《 使用者指南*》中的[將 CloudTrail 事件傳送至 CloudWatch Logs](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cw_send_ct_events.html)。
**注意**
在您建立 串流前，計算將產生的日誌資料磁碟區。請務必使用足夠碎片建立 串流，以處理此磁碟區。如果串流沒有足夠的碎片，日誌串流將受到限制。如需更多有關串流磁碟區限制的資訊，請參閱[配額與限制](https://docs.aws.amazon.com/streams/latest/dev/service-sizes-and-limits.html)。
限流的交付項目會持續重試，時間長達 24 小時。24 小時後，失敗的交付項目就會捨棄。
若要降低限流風險，您可以採取下步驟：
當您使用 [ PutSubscriptionFilter](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutSubscriptionFilter.html#CWL-PutSubscriptionFilter-request-distribution) 或 [ put-subscription-filter](https://awscli.amazonaws.com/v2/documentation/api/2.4.18/reference/logs/put-subscription-filter.html) 建立訂閱篩選條件`distribution`時，請指定 `random`的 。根據預設，串流篩選條件分佈是依日誌串流，這可能會導致限流。
使用 CloudWatch 指標監控您的串流。如此可協助您找出任何限流，並根據實際情況調整您的組態。例如，將資料轉送至訂閱目的地時，`DeliveryThrottling` 指標可用來追蹤 CloudWatch Logs 遭限流的日誌事件數量。如需監控的詳細資訊，請參閱[使用 CloudWatch 指標監控使用量](CloudWatch-Logs-Monitoring-CloudWatch-Metrics.md)。
在 Amazon Kinesis Data Streams 中為您的串流使用隨需容量模式。隨需模式會在您的工作負載上升或下降時，立即為您的工作負載調整所需的容量。有關隨需容量模式的詳細資訊，請參閱[隨需模式](https://docs.aws.amazon.com/streams/latest/dev/how-do-i-size-a-stream.html#ondemandmode)。
限制您的 CloudWatch 訂閱篩選條件模式，以符合 Amazon Kinesis Data Streams 中的串流容量。如果您傳送太多資料至串流，您可能需要減少篩選條件大小或調整篩選條件標準。
**建立 Amazon Kinesis Data Streams 的訂閱篩選條件**
1. 使用下列命令建立目的地 串流：
```
$ C:\> aws kinesis create-stream --stream-name "RootAccess" --shard-count 1
```
1. 等到 串流成為作用中 (這可能需要花費幾分鐘)。您可以使用下列 Amazon Kinesis Data Streams [describe-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/describe-stream.html) 命令來檢查 **StreamDescription.StreamStatus** 屬性。此外，請留意 **StreamDescription.StreamARN** 值，因您將在後續步驟需要此值：
```
aws kinesis describe-stream --stream-name "RootAccess"
```
下列為範例輸出：
```
{
"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. 建立將授予 CloudWatch Logs 許可以將資料放到串流中的 IAM 角色。首先，您將需要在檔案中建立信任政策 (例如，`~/TrustPolicyForCWL-Kinesis.json`)。請使用文字編輯器來建立此政策。請勿使用 IAM 主控台建立這一項。
此政策包含 `aws:SourceArn` 全域條件內容金鑰，以協助預防混淆代理人安全問題。如需詳細資訊，請參閱[預防混淆代理人](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. 使用 **create-role** 命令來建立 IAM 角色，並指定信任政策檔案。請注意傳回的 **Role.Arn** 值，因您將在後續步驟需要此值：
```
aws iam create-role --role-name CWLtoKinesisRole --assume-role-policy-document file://~/TrustPolicyForCWL-Kinesis.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": "CWLtoKinesisRole",
"Path": "/",
"Arn": "arn:aws:iam::123456789012:role/CWLtoKinesisRole"
}
}
```
1. 建立許可政策以定義 CloudWatch Logs 可在您的帳戶上執行哪些動作。首先，您將需要在檔案中建立許可政策 (例如，`~/PermissionsForCWL-Kinesis.json`)。請使用文字編輯器來建立此政策。請勿使用 IAM 主控台建立這一項。
```
{
"Statement": [
{
"Effect": "Allow",
"Action": "kinesis:PutRecord",
"Resource": "arn:aws:kinesis:region:123456789012:stream/RootAccess"
}
]
}
```
1. 使用以下 [put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html) 命令將許可政策與角色建立關聯：
```
aws iam put-role-policy --role-name CWLtoKinesisRole --policy-name Permissions-Policy-For-CWL --policy-document file://~/PermissionsForCWL-Kinesis.json
```
1. 在串流處於**作用中**狀態且您已建立 IAM 角色後，您就可以建立 CloudWatch Logs 訂閱篩選條件。訂閱篩選條件會立即開始將即時日誌資料從所選的日誌群組傳送到 串流：
```
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. 在您設定訂閱篩選條件後，CloudWatch Logs 會將所有符合篩選條件模式的傳入日誌事件轉送至串流。您可以透過抓取 Amazon Kinesis Data Streams 碎片迭代器，並使用 Amazon Kinesis Data Streams get-records 命令擷取一些 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"
```
請注意，您可能需要在 Amazon Kinesis Data Streams 開始傳回資料之前進行此呼叫幾次。
您應該預期會看到含一系列的記錄的回應。Amazon Kinesis Data Streams 記錄中**的資料**屬性是 base64 編碼並以 gzip 格式壓縮。您可以使用以下 Unix 命令來透過命令列檢查原始資料：
```
echo -n "" | base64 -d | zcat
```
Base64 解碼和解壓縮資料是以 JSON 形式並以下列結構進行格式化：
```
{
"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\"}"
}
]
}
```
在上述資料結構的關鍵元素如下：
**owner**
原始日誌資料 AWS 的帳戶 ID。
**logGroup**
原始日誌資料的日誌群組名稱。
**logStream**
原始日誌資料的日誌串流名稱。
**subscriptionFilters**
與原始日誌資料相符的訂閱篩選條件名稱清單。
**messageType**
資料訊息將使用「DATA\$1MESSAGE」類型。有時 CloudWatch Logs 可能會發出 "CONTROL\$1MESSAGE" 類型的 Amazon Kinesis Data Streams 記錄，主要用於檢查目的地是否可連線。
**logEvents**
實際的日誌資料，以一系列的日誌事件記錄呈現。「id」屬性是每個記錄事件的唯一識別符。
## 範例 2：使用 的訂閱篩選條件 AWS Lambda
在此範例中，您將建立 CloudWatch Logs 訂閱篩選條件，將日誌資料傳送至您的 AWS Lambda 函數。
**注意**
建立 Lambda 函數前，請計算將產生的日誌資料量。請務必建立可以處理此磁碟區的函數。如果函數沒有足夠的磁碟區，日誌串流將受到限制。如需 Lambda 限制的詳細資訊，請參閱 [AWS Lambda 限制](https://docs.aws.amazon.com/lambda/latest/dg/limits.html)。
**建立 Lambda 的訂閱篩選條件**
1. 建立 AWS Lambda 函數。
確保您已設定 Lambda 執行角色。如需詳細資訊，請參閱《AWS Lambda 開發人員指南》**中的[步驟 2.2：建立 IAM 角色 (執行角色)](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html)。
1. 開啟文字編輯器，並建立名為 `helloWorld.js` 的檔案，內含下列內容：
```
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. 壓縮檔案 helloWorld.js，並以名稱 `helloWorld.zip` 將其儲存。
1. 使用下列命令，其中角色是您在第一個步驟中設定的 Lambda 執行角色：
```
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. 授予 CloudWatch Logs 許可來執行函數。使用下列命令，將預留位置帳戶取代為您自己的帳戶且將預留位置日誌群組取代為要處理的日誌群組：
```
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. 使用下列命令建立訂閱篩選條件，將預留位置帳戶取代為您自己的帳戶且將預留位置日誌群組取代為要處理的日誌群組：
```
aws logs put-subscription-filter \
--log-group-name myLogGroup \
--filter-name demo \
--filter-pattern "" \
--destination-arn arn:aws:lambda:region:123456789123:function:helloworld
```
1. (選用) 使用範例日誌事件進行測試。在命令提示字元中執行下列命令，這會將簡單日誌訊息放置到訂閱的串流。
若要查看 Lambda 函數的輸出，請導覽至 Lambda 函數，其中您將會在 /aws/lambda/helloworld 中看到輸出：
```
aws logs put-log-events --log-group-name myLogGroup --log-stream-name stream1 --log-events "[{\"timestamp\": , \"message\": \"Simple Lambda Test\"}]"
```
預期會看到含一系列 Lambda 的回應。Lambda 記錄中的 **Data** (資料) 屬性是以 Base64 編碼並以 gzip 格式壓縮。Lambda 收到的實際酬載為以下格式：`{ "awslogs": {"data": "BASE64ENCODED_GZIP_COMPRESSED_DATA"} }`。您可以從命令列使用以下 Unix 命令來檢視原始資料：
```
echo -n "" | base64 -d | zcat
```
Base64 解碼和解壓縮資料是以 JSON 形式並以下列結構進行格式化：
```
{
"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\"}"
}
]
}
```
在上述資料結構的關鍵元素如下：
**owner**
原始日誌資料 AWS 的帳戶 ID。
**logGroup**
原始日誌資料的日誌群組名稱。
**logStream**
原始日誌資料的日誌串流名稱。
**subscriptionFilters**
與原始日誌資料相符的訂閱篩選條件名稱清單。
**messageType**
資料訊息將使用「DATA\$1MESSAGE」類型。有時 CloudWatch Logs 可能會發出 "CONTROL\$1MESSAGE" 類型的 Lambda 記錄，主要用於檢查是否可到達目的地。
**logEvents**
實際的日誌資料，以一系列的日誌事件記錄呈現。「id」屬性是每個記錄事件的唯一識別符。
## 範例 3：使用 Amazon Data Firehose 的訂閱篩選條件
在此範例中，您將建立 CloudWatch Logs 訂閱，將任何符合您定義篩選條件的傳入日誌事件傳送至 Amazon Data Firehose 交付串流。從 CloudWatch Logs 傳送至 Amazon Data Firehose 的資料已使用 gzip 第 6 級壓縮進行壓縮，因此您不需要在 Firehose 交付串流中使用壓縮。然後，您可以使用 Firehose 中的解壓縮功能自動解壓縮日誌。如需詳細資訊，請參閱[將 CloudWatch Logs 傳送至 Firehose](https://docs.aws.amazon.com/logs/SubscriptionFilters.html#FirehoseExample)。
**注意**
建立 Firehose 串流之前，請先計算要產生的日誌資料量。請務必建立可處理此磁碟區的 Firehose 串流。如果串流無法處理磁碟區、日誌串流將受到限制。如需 Firehose 串流磁碟區限制的詳細資訊，請參閱 [Amazon Data Firehose Data Limits](https://docs.aws.amazon.com/firehose/latest/dev/limits.html)。
**建立 Firehose 的訂閱篩選條件**
1. 建立 Amazon Simple Storage Service (Amazon S3) 儲存貯體。我們建議您使用專為 CloudWatch Logs 建立的儲存貯體。不過，如果您想要使用現有的儲存貯體，請跳到步驟 2。
執行以下命令，將預留位置 Region 換成您想要使用的區域：
```
aws s3api create-bucket --bucket amzn-s3-demo-bucket2 --create-bucket-configuration LocationConstraint=region
```
下列為範例輸出：
```
{
"Location": "/amzn-s3-demo-bucket2"
}
```
1. 建立 IAM 角色，授予 Amazon Data Firehose 將資料放入 Amazon S3 儲存貯體的許可。
如需詳細資訊，請參閱《[Amazon Data Firehose 開發人員指南》中的使用 Amazon Data Firehose 控制存取](https://docs.aws.amazon.com/firehose/latest/dev/controlling-access.html)。 **
首先，請按如下所示，使用文字編輯器來建立檔案 `~/TrustPolicyForFirehose.json` 中的信任政策：
```
{
"Statement": {
"Effect": "Allow",
"Principal": { "Service": "firehose.amazonaws.com" },
"Action": "sts:AssumeRole"
}
}
```
1. 使用 **create-role** 命令來建立 IAM 角色，並指定信任政策檔案。請注意傳回的 **Role.Arn** 值，因您將在後續步驟需要此值：
```
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. 建立許可政策，以定義 Firehose 可以在您的帳戶上執行的動作。首先，使用文字編輯器來建立檔案 `~/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. 使用以下 put-role-policy 命令將許可政策與角色建立關聯：
```
aws iam put-role-policy --role-name FirehosetoS3Role --policy-name Permissions-Policy-For-Firehose --policy-document file://~/PermissionsForFirehose.json
```
1. 如下所示建立目的地 Firehose 交付串流，將 **RoleARN** 和 **BucketARN** 的預留位置值取代為您建立的角色和儲存貯體 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"}'
```
請注意，Firehose 會自動為交付的 Amazon S3 物件使用 YYYY/MM/DD/HH UTC 時間格式的字首。您可以指定在時間格式前綴前要新增的額外前綴。如果字首結尾是斜線 (/)，則會在 Amazon S3 儲存貯體中顯示為資料夾。
1. 等到串流成為作用中 (這可能需要花費幾分鐘)。您可以使用 Firehose **describe-delivery-stream** 命令來檢查 **DeliveryStreamDescription.DeliveryStreamStatus** 屬性。此外，請留意 **DeliveryStreamDescription.DeliveryStreamARN** 值，因您將在後續步驟需要此值：
```
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. 建立 IAM 角色，授予 CloudWatch Logs 將資料放入 Firehose 交付串流的許可。首先，使用文字編輯器來建立檔案 `~/TrustPolicyForCWL.json` 中的信任政策：
此政策包含 `aws:SourceArn` 全域條件內容金鑰，以協助預防混淆代理人安全問題。如需詳細資訊，請參閱[預防混淆代理人](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. 使用 **create-role** 命令來建立 IAM 角色，並指定信任政策檔案。請注意傳回的 **Role.Arn** 值，因您將在後續步驟需要此值：
```
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. 建立許可政策以定義 CloudWatch Logs 可在您的帳戶上執行哪些動作。首先，使用文字編輯器來建立許可政策檔案 (例如，`~/PermissionsForCWL.json`)：
```
{
"Statement":[
{
"Effect":"Allow",
"Action":["firehose:PutRecord"],
"Resource":[
"arn:aws:firehose:region:account-id:deliverystream/delivery-stream-name"]
}
]
}
```
1. 使用 put-role-policy 命令將許可政策與角色建立關聯：
```
aws iam put-role-policy --role-name CWLtoKinesisFirehoseRole --policy-name Permissions-Policy-For-CWL --policy-document file://~/PermissionsForCWL.json
```
1. 在 Amazon Data Firehose 交付串流處於作用中狀態且您已建立 IAM 角色後，您可以建立 CloudWatch Logs 訂閱篩選條件。訂閱篩選條件會立即開始從所選日誌群組到 Amazon Data Firehose 交付串流的即時日誌資料流程：
```
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. 設定訂閱篩選條件後，CloudWatch Logs 會將符合篩選條件模式的所有傳入日誌事件轉送至您的 Amazon Data Firehose 交付串流。您的資料會根據 Amazon Data Firehose 交付串流上設定的時間緩衝間隔，開始出現在 Amazon S3 中。一旦經過足夠的時間，您就可以檢查 Amazon S3 儲存貯體來驗證資料。
```
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": {}
}
```
在 Amazon S3 物件中的資料會以 gzip 格式壓縮。您可以使用以下 Unix 命令來透過命令列檢查原始資料：
```
zcat testfile.gz
```
## 範例 4：使用 Amazon OpenSearch Service 的訂閱篩選條件
在此範例中，您將建立 CloudWatch Logs 訂閱，將符合您所定義篩選條件的傳入日誌事件傳送至 OpenSearch Service 網域。
**建立 OpenSearch Service 的訂閱篩選條件**
1. 建立 OpenSearch Service 網域 如需詳細資訊，請參閱[建立 OpenSearch Service 網域](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/createupdatedomains.html#createdomains)
1. 透過 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 開啟 CloudWatch 主控台。
1. 在導覽窗格中，選擇 **Log groups** (日誌群組)。
1. 選取日誌群組的名稱。
1. 選擇 **Actions** (動作)、**Subscription filters** (訂閱篩選條件)、**Create Amazon OpenSearch Service subscription filter** (建立 Amazon OpenSearch Service 訂閱篩選條件)。
1. 選擇您是否要串流至此帳戶或其他帳戶中的叢集。
+ 如果您選擇**此帳戶**，請選取您在步驟 1 中建立的網域。
+ 如果您選擇**另一個帳戶**，請輸入該網域的 ARN 和端點。
1. 如果您選擇其他帳戶，請提供網域 ARN 和端點。
1. 針對 Amazon OpenSearch Service 叢集，選擇將交付日誌群組資料的叢集名稱
1. 選擇日誌格式。
1. 針對**訂閱篩選條件模式**，輸入要在日誌事件中找到的術語或模式。這可確保您只將感興趣的資料傳送至 OpenSearch Service 叢集。如需詳細資訊，請參閱[指標篩選條件的篩選條件模式語法](FilterAndPatternSyntaxForMetricFilters.md)。
1. (選用) 針對 **Select log data to test** (選取要測試的日誌資料)，選擇一個日誌串流，然後選擇 **Test pattern** (測試模式)，以驗證您的搜尋篩選條件是否會傳回您預期的結果。
1. 選擇 **Start streaming** (開始串流)。