本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# 帳戶層級訂閱篩選條件
<a name="SubscriptionFilters-AccountLevel"></a>

**重要**  
存在使用訂閱篩選條件造成無限遞迴迴圈的風險，如果未解決，可能會導致擷取計費大幅增加。為了降低此風險，建議您在帳戶層級訂閱篩選條件中使用選擇條件，以排除從訂閱交付工作流程一部分的資源擷取日誌資料的日誌群組。如需此問題和決定要排除哪些日誌群組的詳細資訊，請參閱 [日誌遞迴預防](Subscriptions-recursion-prevention.md)。

 您可以設定帳戶層級訂閱政策，其中包含帳戶中的日誌群組子集。帳戶訂閱政策可以使用 Amazon Kinesis Data Streams AWS Lambda或 Amazon Data Firehose。透過帳戶層級訂閱政策傳送至服務的日誌會以 gzip 格式進行 base64 編碼和壓縮。本節提供您可以遵循的範例，為 Amazon Kinesis Data Streams、Lambda 和 Firehose 建立帳戶層級訂閱。

**注意**  
若要檢視您帳戶中所有訂閱篩選條件政策的清單，請使用 `--policy-type` 參數值為 `SUBSCRIPTION_FILTER_POLICY`的 `describe-account-policies`命令。如需詳細資訊，請參閱 [ describe-account-policies](https://docs.aws.amazon.com/cli/latest/reference/logs/describe-account-policies.html)¶。

**Topics**
+ [範例 1：使用 Amazon Kinesis Data Streams 的訂閱篩選條件](#DestinationKinesisExample-AccountLevel)
+ [範例 2：使用 的訂閱篩選條件 AWS Lambda](#LambdaFunctionExample-AccountLevel)
+ [範例 3：使用 Amazon Data Firehose 的訂閱篩選條件](#FirehoseExample-AccountLevel)

## 範例 1：使用 Amazon Kinesis Data Streams 的訂閱篩選條件
<a name="DestinationKinesisExample-AccountLevel"></a>

在您建立要與帳戶層級訂閱政策搭配使用的 Amazon Kinesis Data Streams 資料串流之前，請計算將產生的日誌資料量。請務必使用足夠碎片建立 串流，以處理此磁碟區。如果串流沒有足夠的碎片，則會調節。如需串流磁碟區限制的詳細資訊，請參閱 Amazon Kinesis Data Streams 文件中的[配額和限制](https://docs.aws.amazon.com/streams/latest/dev/service-sizes-and-limits.html)。

**警告**  
由於多個日誌群組的日誌事件會轉送至目的地，因此存在限流風險。限流的交付項目會持續重試，時間長達 24 小時。24 小時後，失敗的交付項目就會捨棄。  
若要降低限流風險，您可以採取下步驟：  
使用 CloudWatch 指標監控 Amazon Kinesis Data Streams 串流。這可協助您識別限流，並相應地調整您的組態。例如， `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 Logs 訂閱篩選條件模式，以符合 Amazon Kinesis Data Streams 中的串流容量。如果您傳送太多資料至串流，您可能需要減少篩選條件大小或調整篩選條件標準。

下列範例使用帳戶層級訂閱政策，將所有日誌事件轉送至 Amazon Kinesis Data Streams 中的串流。篩選條件模式會將任何日誌事件與文字相符，`Test`並將其轉送至 Amazon Kinesis Data Streams 中的串流。

**為 Amazon Kinesis Data Streams 建立帳戶層級訂閱政策**

1. 使用下列命令建立目的地 串流：

   ```
   $ C:\>  aws kinesis create-stream —stream-name "TestStream" —shard-count 1
   ```

1. 等待幾分鐘讓串流變成作用中。您可以使用 [describe-stream](https://docs.aws.amazon.com/cli/latest/reference/kinesis/describe-stream.html) 命令來檢查 **StreamDescription.StreamStatus** 屬性，以驗證串流是否處於作用中狀態。

   ```
   aws kinesis describe-stream --stream-name "TestStream"
   ```

   下列為範例輸出：

   ```
   {
       "StreamDescription": {
           "StreamStatus": "ACTIVE",
           "StreamName": "TestStream",
           "StreamARN": "arn:aws:kinesis:region:123456789012:stream/TestStream",
           "Shards": [
               {
                   "ShardId": "shardId-000000000000",
                   "HashKeyRange": {
                       "EndingHashKey": "EXAMPLE8463463374607431768211455",
                       "StartingHashKey": "0"
                   },
                   "SequenceNumberRange": {
                       "StartingSequenceNumber":
                       "EXAMPLE688818456679503831981458784591352702181572610"
                   }
               }
           ]
       }
   }
   ```

1. 建立將授予 CloudWatch Logs 許可以將資料放到串流中的 IAM 角色。首先，您將需要在檔案中建立信任政策 (例如，`~/TrustPolicyForCWL-Kinesis.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 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": "EXAMPLE450GAB4HC5F431",
           "CreateDate": "2023-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/TestStream"
       }
     ]
   }
   ```

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 訂閱篩選條件政策。此政策會立即開始將即時日誌資料傳送至串流的流程。在此範例中，所有包含字串的日誌事件`ERROR`都會串流，但名為 `LogGroupToExclude1`和 的日誌群組中的日誌事件除外`LogGroupToExclude2`。

   ```
   aws logs put-account-policy \
       --policy-name "ExamplePolicy" \
       --policy-type "SUBSCRIPTION_FILTER_POLICY" \
       --policy-document '{"RoleArn":"arn:aws:iam::123456789012:role/CWLtoKinesisRole", "DestinationArn":"arn:aws:kinesis:region:123456789012:stream/TestStream", "FilterPattern": "Test", "Distribution": "Random"}' \
       --selection-criteria 'LogGroupName NOT IN ["LogGroupToExclude1", "LogGroupToExclude2"]' \
       --scope "ALL"
   ```

1. 設定訂閱篩選條件後，CloudWatch Logs 會將符合篩選條件模式和選取條件的所有傳入日誌事件轉送到您的串流。

   欄位是選用`selection-criteria`的，但對於排除可能導致訂閱篩選條件無限日誌遞迴的日誌群組非常重要。如需此問題和決定要排除哪些日誌群組的詳細資訊，請參閱 [日誌遞迴預防](Subscriptions-recursion-prevention.md)。目前， NOT IN 是 唯一支援的運算子`selection-criteria`。

   您可以使用 Amazon Kinesis Data Streams 碎片迭代器和使用 Amazon Kinesis Data Streams `get-records`命令擷取一些 Amazon Kinesis Data Streams 記錄，來驗證日誌事件的流程：

   ```
   aws kinesis get-shard-iterator --stream-name TestStream --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 "<Content of Data>" | base64 -d | zcat
   ```

   Base64 解碼和解壓縮資料是以 JSON 形式並以下列結構進行格式化：

   ```
   { 
       "messageType": "DATA_MESSAGE",
       "owner": "123456789012",
       "logGroup": "Example1",
       "logStream": "logStream1",
       "subscriptionFilters": [ 
           "ExamplePolicy" 
       ],
       "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\"}" 
           } 
       ],
       "policyLevel": "ACCOUNT_LEVEL_POLICY"
   }
   ```

   資料結構中的關鍵元素如下：  
**messageType**  
資料訊息將使用「DATA\$1MESSAGE」類型。有時 CloudWatch Logs 可能會發出 "CONTROL\$1MESSAGE" 類型的 Amazon Kinesis Data Streams 記錄，主要用於檢查目的地是否可連線。  
**owner**  
原始日誌資料 AWS 的帳戶 ID。  
**logGroup**  
原始日誌資料的日誌群組名稱。  
**logStream**  
原始日誌資料的日誌串流名稱。  
**subscriptionFilters**  
與原始日誌資料相符的訂閱篩選條件名稱清單。  
**logEvents**  
實際的日誌資料，以一系列的日誌事件記錄呈現。「id」屬性是每個記錄事件的唯一識別符。  
**policyLevel**  
強制執行政策的層級。"ACCOUNT\$1LEVEL\$1POLICY" 是帳戶層級訂閱篩選條件政策`policyLevel`的 。

## 範例 2：使用 的訂閱篩選條件 AWS Lambda
<a name="LambdaFunctionExample-AccountLevel"></a>

在此範例中，您將建立 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 nodejs18.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:123456789012:log-group:*" \
       --source-account "123456789012"
   ```

1. 使用下列命令建立帳戶層級訂閱篩選條件政策，將預留位置帳戶取代為您自己的帳戶。在此範例中，所有包含字串的日誌事件`ERROR`都會串流，但名為 `LogGroupToExclude1`和 的日誌群組中的日誌事件除外`LogGroupToExclude2`。

   ```
   aws logs put-account-policy \
       --policy-name "ExamplePolicyLambda" \
       --policy-type "SUBSCRIPTION_FILTER_POLICY" \
       --policy-document '{"DestinationArn":"arn:aws:lambda:region:123456789012:function:helloWorld", "FilterPattern": "Test", "Distribution": "Random"}' \
       --selection-criteria 'LogGroupName NOT IN ["LogGroupToExclude1", "LogGroupToExclude2"]' \
       --scope "ALL"
   ```

   設定訂閱篩選條件後，CloudWatch Logs 會將符合篩選條件模式和選取條件的所有傳入日誌事件轉送到您的串流。

   欄位是選用`selection-criteria`的，但對於排除可能導致訂閱篩選條件無限日誌遞迴的日誌群組非常重要。如需此問題和決定要排除哪些日誌群組的詳細資訊，請參閱 [日誌遞迴預防](Subscriptions-recursion-prevention.md)。目前， NOT IN 是 唯一支援的運算子`selection-criteria`。

1. (選用) 使用範例日誌事件進行測試。在命令提示字元中執行下列命令，這會將簡單日誌訊息放置到訂閱的串流。

   若要查看 Lambda 函數的輸出，請導覽至 Lambda 函數，其中您將會在 /aws/lambda/helloworld 中看到輸出：

   ```
   aws logs put-log-events --log-group-name Example1 --log-stream-name logStream1 --log-events "[{\"timestamp\":CURRENT TIMESTAMP MILLIS , \"message\": \"Simple Lambda Test\"}]"
   ```

   預期會看到含一系列 Lambda 的回應。Lambda 記錄中的 **Data** (資料) 屬性是以 Base64 編碼並以 gzip 格式壓縮。Lambda 收到的實際酬載為以下格式：`{ "awslogs": {"data": "BASE64ENCODED_GZIP_COMPRESSED_DATA"} }`。您可以從命令列使用以下 Unix 命令來檢視原始資料：

   ```
   echo -n "<BASE64ENCODED_GZIP_COMPRESSED_DATA>" | base64 -d | zcat
   ```

   Base64 解碼和解壓縮資料是以 JSON 形式並以下列結構進行格式化：

   ```
   { 
       "messageType": "DATA_MESSAGE",
       "owner": "123456789012",
       "logGroup": "Example1",
       "logStream": "logStream1",
       "subscriptionFilters": [ 
           "ExamplePolicyLambda" 
       ],
       "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\"}" 
           } 
       ],
       "policyLevel": "ACCOUNT_LEVEL_POLICY"
   }
   ```
**注意**  
帳戶層級訂閱篩選條件不會套用至目的地 Lambda 函數的日誌群組。這是為了防止無限日誌遞迴，這可能會導致擷取帳單增加。如需此問題的詳細資訊，請參閱 [日誌遞迴預防](Subscriptions-recursion-prevention.md) 。

   資料結構中的關鍵元素如下：  
**messageType**  
資料訊息將使用「DATA\$1MESSAGE」類型。有時 CloudWatch Logs 可能會發出 "CONTROL\$1MESSAGE" 類型的 Amazon Kinesis Data Streams 記錄，主要用於檢查目的地是否可連線。  
**owner**  
原始日誌資料 AWS 的帳戶 ID。  
**logGroup**  
原始日誌資料的日誌群組名稱。  
**logStream**  
原始日誌資料的日誌串流名稱。  
**subscriptionFilters**  
與原始日誌資料相符的訂閱篩選條件名稱清單。  
**logEvents**  
實際的日誌資料，以一系列的日誌事件記錄呈現。「id」屬性是每個記錄事件的唯一識別符。  
**policyLevel**  
強制執行政策的層級。"ACCOUNT\$1LEVEL\$1POLICY" 是帳戶層級訂閱篩選條件政策`policyLevel`的 。

## 範例 3：使用 Amazon Data Firehose 的訂閱篩選條件
<a name="FirehoseExample-AccountLevel"></a>

在此範例中，您將建立 CloudWatch Logs 帳戶層級訂閱篩選條件政策，將符合您所定義篩選條件的傳入日誌事件傳送至 Amazon Data Firehose 交付串流。從 CloudWatch Logs 傳送至 Amazon Data Firehose 的資料已使用 gzip 第 6 級壓縮進行壓縮，因此您不需要在 Firehose 交付串流中使用壓縮。然後，您可以使用 Firehose 中的解壓縮功能自動解壓縮日誌。如需詳細資訊，請參閱[使用 CloudWatch Logs 寫入 Kinesis Data Firehose](https://docs.aws.amazon.com/firehose/latest/dev/writing-with-cloudwatch-logs.html)。

**警告**  
建立 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": "EXAMPLE50GAB4HC5F431",
           "CreateDate": "2023-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"}'
   ```

   NFirehose 會自動為交付的 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-account-policy \
       --policy-name "ExamplePolicyFirehose" \
       --policy-type "SUBSCRIPTION_FILTER_POLICY" \
       --policy-document '{"RoleArn":"arn:aws:iam::123456789012:role/CWLtoKinesisFirehoseRole", "DestinationArn":"arn:aws:firehose:us-east-1:123456789012:deliverystream/delivery-stream-name", "FilterPattern": "Test", "Distribution": "Random"}' \
       --selection-criteria 'LogGroupName NOT IN ["LogGroupToExclude1", "LogGroupToExclude2"]' \
       --scope "ALL"
   ```

1. 設定訂閱篩選條件後，CloudWatch Logs 會將符合篩選條件模式的傳入日誌事件轉送至您的 Amazon Data Firehose 交付串流。

   欄位是選用`selection-criteria`的，但對於排除可能導致訂閱篩選條件無限日誌遞迴的日誌群組非常重要。如需此問題和決定要排除哪些日誌群組的詳細資訊，請參閱 [日誌遞迴預防](Subscriptions-recursion-prevention.md)。目前， NOT IN 是 唯一支援的運算子`selection-criteria`。

   您的資料會根據 Amazon Data Firehose 交付串流上設定的時間緩衝間隔，開始出現在 Amazon S3 中。一旦經過足夠的時間，您就可以檢查 Amazon S3 儲存貯體來驗證資料。

   ```
   aws s3api list-objects --bucket 'amzn-s3-demo-bucket2' --prefix 'firehose/'
   {
       "Contents": [
           {
               "LastModified": "2023-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/2023/10/29/00/my-delivery-stream-2023-10-29-00-35-40-EXAMPLE-7e66-49bc-9fd4-fc9819cc8ed3",
               "Owner": {
                   "DisplayName": "cloudwatch-logs",
                   "ID": "EXAMPLE6be062b19584e0b7d84ecc19237f87b6"
               },
               "Size": 5752
           }
       ]
   }
   ```

   ```
   aws s3api get-object --bucket 'amzn-s3-demo-bucket2' --key 'firehose/2023/10/29/00/my-delivery-stream-2023-10-29-00-01-21-a188030a-62d2-49e6-b7c2-b11f1a7ba250' testfile.gz
   
   {
       "AcceptRanges": "bytes",
       "ContentType": "application/octet-stream",
       "LastModified": "Thu, 29 Oct 2023 00:07:06 GMT",
       "ContentLength": 593,
       "Metadata": {}
   }
   ```

   在 Amazon S3 物件中的資料會以 gzip 格式壓縮。您可以使用以下 Unix 命令來透過命令列檢查原始資料：

   ```
   zcat testfile.gz
   ```