本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 監控 Amazon Aurora 資料庫叢集中的事件、日誌和串流
當您監控 Amazon Aurora 資料庫和其他 AWS 解決方案時，您的目標是維護下列項目：
+ 可靠性
+ 可用性
+ 效能
+ 安全
[在 Amazon Aurora 叢集中監控指標](MonitoringAurora.md) 解釋如何使用指標監控叢集。完整的解決方案也必須監控資料庫事件、日誌檔案和活動串流。 AWS 為您提供下列監控工具：
+ *Amazon EventBridge* 為無伺服器事件匯流排服務，可讓您輕鬆將應用程式與來自各種來源的資料互相連線。EventBridge 可從您自己的應用程式、Software-as-a-Service(SaaS) 應用程式 AWS 和服務提供即時資料串流。EventBridge 會將該資料路由傳送至目標，例如 AWS Lambda。如此一來，您可以監控在服務中發生的事件，並建置事件導向的架構。如需詳細資訊，請參閱[「Amazon EventBridge 使用者指南」](https://docs.aws.amazon.com/eventbridge/latest/userguide/)。
+ *Amazon CloudWatch Logs* 提供一種方法來監控、存放和存取來自 Amazon Aurora 執行個體 AWS CloudTrail和其他來源的日誌檔案。Amazon CloudWatch Logs 可監控日誌檔案中的資訊，並在達到特定閾值時通知您。您也可以將日誌資料存檔在高耐用性的儲存空間。如需詳細資訊，請參閱 [Amazon CloudWatch Logs 使用者指南](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/)。
+ *AWS CloudTrail* 會擷取來自或代表 AWS 帳戶發出的 API 呼叫和相關事件。CloudTrail 會將日誌檔案交付到您指定的 Amazon S3 儲存貯體。您可以識別呼叫的使用者和帳戶 AWS、進行呼叫的來源 IP 地址，以及呼叫的時間。如需詳細資訊，請參閱[「AWS CloudTrail 使用者指南」](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/)。
+ *資料庫活動串流*是一項 Amazon Aurora 功能，提供有關您資料庫叢集的近乎即時活動串流。Amazon Aurora 會將活動推送至 Amazon Kinesis 資料串流。系統會自動建立 Kinesis 串流。從 Kinesis，您可以設定 Amazon Data Firehose 和 等 AWS 服務 AWS Lambda ，以取用串流並存放資料。
**Topics**
+ [在 Amazon RDS 主控台中檢視日誌、事件和串流](logs-events-streams-console.md)
+ [監控 Amazon Aurora 事件](working-with-events.md)
+ [監控 Amazon Aurora 日誌檔案](USER_LogAccess.md)
+ [在 AWS CloudTrail 中監控 Amazon Aurora API 呼叫](logging-using-cloudtrail.md)
+ [使用資料庫活動串流來監控 Amazon Aurora](DBActivityStreams.md)
+ [使用 Amazon GuardDuty RDS Protection for Amazon Aurora監控威脅](guard-duty-rds-protection.md)
# 在 Amazon RDS 主控台中檢視日誌、事件和串流
Amazon RDS 與 整合 AWS 服務 ，以在 RDS 主控台中顯示日誌、事件和資料庫活動串流的相關資訊。
Aurora 資料庫叢集的**日誌和事件**索引標籤會顯示以下資訊：
+ **自動擴展政策和活動**：顯示與 Aurora 自動擴展功能相關的政策和活動。此資訊僅顯示在叢集層級的 **Logs & events** (日誌和事件) 索引標籤中。
+ **Amazon CloudWatch alarms** (Amazon CloudWatch 警示)：顯示您為 Aurora 叢集中的資料庫執行個體設定的任何指標警示。如果您尚未設定警示，則可以在 RDS 主控台中加以建立。
+ **Recent events** (最近事件)：顯示 Aurora 資料庫執行個體或叢集的事件摘要 (環境變更)。如需詳細資訊，請參閱[檢視 Amazon RDS 事件](USER_ListEvents.md)。
+ **Logs** (日誌)：顯示 Aurora 叢集中的資料庫執行個體產生的資料庫日誌檔案。如需詳細資訊，請參閱[監控 Amazon Aurora 日誌檔案](USER_LogAccess.md)。
**Configuration** (組態) 索引標籤會顯示資料庫活動串流的資訊。
**在 RDS 主控台中檢視 Aurora 資料庫叢集的日誌、事件和串流**
1. 登入 AWS 管理主控台 ，並在 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)：// 開啟 Amazon RDS 主控台。
1. 在導覽窗格中，選擇 **Databases** (資料庫)。
1. 選擇您想要監控的 Aurora 資料庫叢集的名稱。
資料庫頁面隨即出現。下列範例顯示名為 `apga` 的 Amazon Aurora PostgreSQL 資料庫叢集。
![\[顯示「監控」索引標籤的資料庫頁面\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/images/cluster-with-monitoring-tab.png)
1. 向下捲動並選擇 **Configuration** (組態)。
下列範例顯示叢集的資料庫活動串流的狀態。
![\[Enhanced Monitoring (增強型監控)\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/images/cluster-das.png)
1. 選擇 **Logs & events (日誌和事件)**。
此時將顯示「日誌和事件」區段。
![\[顯示「日誌和事件」索引標籤的資料庫頁面\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/images/cluster-logs-and-events-subpage.png)
1. 在 Aurora 叢集中選擇資料庫執行個體，然後選擇執行個體的 **Logs & events** (日誌和事件)。
以下範例顯示資料庫執行個體頁面和資料庫叢集頁面之間的內容有所不同。資料庫執行個體頁面顯示日誌和警示。
![\[日誌 & 事件頁面\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/images/cluster-instance-logs-and-events-subpage.png)
# 監控 Amazon Aurora 事件
*事件*表示環境中有變更的事件。這可以是 AWS 環境、SaaS 合作夥伴服務或應用程式，或是自訂應用程式或服務。有關 Aurora 事件的說明，請參閱 [Aurora 的 Amazon RDS 事件類別和事件訊息](USER_Events.Messages.md)。
**Topics**
+ [Aurora 的事件概觀](#rds-cloudwatch-events.sample)
+ [檢視 Amazon RDS 事件](USER_ListEvents.md)
+ [使用 Amazon RDS 事件通知](USER_Events.md)
+ [建立由 Amazon Aurora 事件觸發的規則](rds-cloud-watch-events.md)
+ [Aurora 的 Amazon RDS 事件類別和事件訊息](USER_Events.Messages.md)
## Aurora 的事件概觀
*RDS 事件*表示 Aurora 環境中的變更。例如，當修補資料庫叢集時，Amazon Aurora 會產生一個事件。Amazon Aurora 會近乎即時地將事件傳遞至 EventBridge。
**注意**
Amazon RDS 會全力發出事件。我們建議您避免編寫會根據通知事件的順序或存在的程式，因為這些事件可能會被移出序列或遺漏。
Amazon RDS 記錄與下列資源相關的事件：
+ 資料庫叢集
如需叢集事件的清單，請參閱 [資料庫叢集事件](USER_Events.Messages.md#USER_Events.Messages.cluster)。
+ 資料庫執行個體
如需資料庫執行個體事件清單，請參閱 [資料庫執行個體事件](USER_Events.Messages.md#USER_Events.Messages.instance)。
+ 資料庫參數群組
如需有關資料庫參數群組事件的列表，請參閱 [資料庫參數群組事件](USER_Events.Messages.md#USER_Events.Messages.parameter-group)。
+ 資料庫安全群組
如需有關資料庫安全群組事件的清單，請參閱 [資料庫安全群組事件](USER_Events.Messages.md#USER_Events.Messages.security-group)。
+ 資料庫叢集快照
如需資料庫叢集快照事件的清單，請參閱 [資料庫叢集快照事件](USER_Events.Messages.md#USER_Events.Messages.cluster-snapshot)。
+ RDS Proxy 事件
如需 RDS Proxy 事件的清單，請參閱 [RDS Proxy 事件](USER_Events.Messages.md#USER_Events.Messages.rds-proxy)。
+ 藍/綠部署事件
如需藍/綠部署事件的清單，請參閱 [藍/綠部署事件](USER_Events.Messages.md#USER_Events.Messages.BlueGreenDeployments)。
此資訊包含下列項目：
+ 事件的日期和時間
+ 事件的來源名稱和來源類型
+ 與事件相關聯的訊息
+ 事件通知包括訊息傳送時的標籤，可能不會反映事件發生時的標籤
# 檢視 Amazon RDS 事件
您可以擷取資料庫 (主機台會顯示資訊)Amazon Aurora 資源以下的版本資訊：
+ 資源名稱
+ 資源類型
+ 事件的時間
+ 活動的訊息摘要
您可以在 AWS 管理主控台 的下列部分存取事件：
+ **事件**索引標籤，顯示過去 24 小時內發生的事件。
+ **資料庫**索引標籤中**日誌與事件**區段中的**最近事件**資料表，可顯示過去 2 週內發生的事件。
您還可使用 [describe-events](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-events.html) AWS CLI 命令或 [DescribeEvents](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeEvents.html) RDS API 作業來擷取事件。若您是使用 AWS CLI 或 RDS API 檢視事件，則最多可擷取過去 14 天內的事件。
**注意**
如果您需要長時間儲存事件，則可將 Amazon RDS 事件傳送至 EventBridge。如需詳細資訊，請參閱[建立由 Amazon Aurora 事件觸發的規則](rds-cloud-watch-events.md)
如需有關 Amazon Aurora 事件的說明，請參閱 [Aurora 的 Amazon RDS 事件類別和事件訊息](USER_Events.Messages.md)。
若要使用 AWS CloudTrail 存取事件的詳細資訊，包括請求參數，請參閱 [CloudTrail 事件](logging-using-cloudtrail.md#service-name-info-in-cloudtrail.events)。
## 主控台
**如要檢視過去 24 小時內的所有 Amazon RDS 事件**
1. 登入 AWS 管理主控台，開啟位於 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/) 的 Amazon RDS 主控台。
1. 在導覽窗格中，選擇 **Events** (事件)。
可用的事件隨即會出現在清單中。
1. (選用) 輸入搜尋詞來篩選結果。
下列範例所顯示的事件清單，是依字元 **apg** 篩選的結果。
![\[列出資料庫事件\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/images/ListEventsAPG.png)
## AWS CLI
如要檢視過去一小時內產生的所有事件，請呼叫不含參數的 [describe-events](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-events.html)。
```
aws rds describe-events
```
下列範例輸出顯示資料庫叢集執行個體已開始復原。
```
{
"Events": [
{
"EventCategories": [
"recovery"
],
"SourceType": "db-instance",
"SourceArn": "arn:aws:rds:us-east-1:123456789012:db:mycluster-instance-1",
"Date": "2022-04-20T15:02:38.416Z",
"Message": "Recovery of the DB instance has started. Recovery time will vary with the amount of data to be recovered.",
"SourceIdentifier": "mycluster-instance-1"
}, ...
```
如要檢視過去 10080 分鐘 (7 天) 內的所有 Amazon RDS 事件，請呼叫 [describe-events](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-events.html) AWS CLI 命令，並將 `--duration` 參數設定為 `10080`。
```
1. aws rds describe-events --duration 10080
```
下列範例顯示資料庫執行個體 *test-instance* 在指定時間範圍內的事件。
```
aws rds describe-events \
--source-identifier test-instance \
--source-type db-instance \
--start-time 2022-03-13T22:00Z \
--end-time 2022-03-13T23:59Z
```
下列範例輸出顯示備份的狀態。
```
{
"Events": [
{
"SourceType": "db-instance",
"SourceIdentifier": "test-instance",
"EventCategories": [
"backup"
],
"Message": "Backing up DB instance",
"Date": "2022-03-13T23:09:23.983Z",
"SourceArn": "arn:aws:rds:us-east-1:123456789012:db:test-instance"
},
{
"SourceType": "db-instance",
"SourceIdentifier": "test-instance",
"EventCategories": [
"backup"
],
"Message": "Finished DB Instance backup",
"Date": "2022-03-13T23:15:13.049Z",
"SourceArn": "arn:aws:rds:us-east-1:123456789012:db:test-instance"
}
]
}
```
## API
如果要檢視過去 14 天內的所有 Amazon RDS 執行個體事件，請呼叫 [DescribeEvents](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeEvents.html) RDS API 操作，並將 `Duration` 參數設定為 `20160`。
# 使用 Amazon RDS 事件通知
Amazon RDS 使用 Amazon Simple Notification Service (Amazon SNS) 在 Amazon RDS 事件發生時提供通知。這些通知可以採用任何 Amazon SNS 在 AWS 區域中支援的通知形式，例如電子郵件、文字訊息或呼叫 HTTP 端點。
**Topics**
+ [Amazon RDS 事件通知概觀](USER_Events.overview.md)
+ [授予將通知發佈至 Amazon SNS 主題的許可](USER_Events.GrantingPermissions.md)
+ [訂閱 Amazon RDS 事件通知](USER_Events.Subscribing.md)
+ [Amazon RDS 事件通知標籤與屬性](USER_Events.TagsAttributesForFiltering.md)
+ [列出 Amazon RDS 事件通知訂閱](USER_Events.ListSubscription.md)
+ [修改 Amazon RDS 事件通知訂閱](USER_Events.Modifying.md)
+ [將來源識別碼新增至 Amazon RDS 事件通知訂閱](USER_Events.AddingSource.md)
+ [將來源識別碼從 Amazon RDS 事件通知訂閱中移除](USER_Events.RemovingSource.md)
+ [列出 Amazon RDS 事件通知類別](USER_Events.ListingCategories.md)
+ [刪除 Amazon RDS 事件通知訂閱](USER_Events.Deleting.md)
# Amazon RDS 事件通知概觀
Amazon RDS 將事件分成幾個類別供您訂閱，讓您在該類別的事件發生時收到通知。
**Topics**
+ [符合事件訂閱資格的 RDS 資源](#USER_Events.overview.resources)
+ [訂閱 Amazon RDS 事件通知的基本程序](#USER_Events.overview.process)
+ [RDS 事件通知的傳遞](#USER_Events.overview.subscriptions)
+ [Amazon RDS 事件通知的帳單](#USER_Events.overview.billing)
+ [使用 Amazon EventBridge 的 Aurora 事件範例](#events-examples)
## 符合事件訂閱資格的 RDS 資源
對 Amazon Aurora 來說，事件發生於資料庫叢集和資料庫執行個體層級。您可以針對下列資源訂閱事件類別：
+ 資料庫執行個體
+ 資料庫叢集
+ 資料庫叢集快照
+ DB parameter group (資料庫參數群組)
+ 資料庫安全群組
+ RDS Proxy
+ 自訂引擎版本
例如，如果您訂閱指定資料庫執行個體的備份類別，當發生會影響資料庫執行個體的備份相關事件時，您將會收到通知。如果您訂閱資料庫執行個體的組態變更類別，當資料庫執行個體變更時，您將會收到通知。當事件通知訂閱變更時，您也會收到通知。
您可能會想要建立數個不同的訂閱。例如，您可能會建立一個訂閱以接收所有資料庫執行個體的所有事件通知，並建立另一個訂閱以僅包含資料庫執行個體子集的重要事件。對於第二個訂閱，請在篩選條件中指定一或多個資料庫執行個體。
## 訂閱 Amazon RDS 事件通知的基本程序
訂閱 Amazon RDS 事件通知的程序如下：
1. 您可以使用 Amazon RDS 主控台 AWS CLI或 API 建立 Amazon RDS 事件通知訂閱。
Amazon RDS 使用 Amazon SNS 主題的 ARN 來識別每個訂閱。Amazon RDS 主控台會在您建立訂閱時為您建立 ARN。使用 Amazon SNS 主控台 AWS CLI、 或 Amazon SNS API 建立 ARN。
1. Amazon RDS 會將核准電子郵件或 SMS 訊息傳送至您在訂閱時提交的地址。
1. 您可以選擇收到的通知中的連結，以確認訂閱。
1. Amazon RDS 主控台會以您的訂閱狀態更新 **My Event Subscriptions** (我的事件訂閱) 區段。
1. Amazon RDS 會將通知傳送到您在建立訂閱時提供的地址。
若要了解使用 Amazon SNS 時的 Identity and Access Management，請參閱《*Amazon Simple Notification Service 開發人員指南*》中的 [Amazon SNS 中的 Identity and Access Management](https://docs.aws.amazon.com/sns/latest/dg/sns-authentication-and-access-control.html)。
您可以使用 AWS Lambda 來處理資料庫執行個體的事件通知。如需詳細資訊，請參閱《 *AWS Lambda 開發人員指南*》中的[搭配使用 AWS Lambda 與 Amazon RDS](https://docs.aws.amazon.com/lambda/latest/dg/services-rds.html)。
## RDS 事件通知的傳遞
Amazon RDS 會將通知傳送到您在建立訂閱時提供的地址。通知可以包含訊息屬性，其會提供有關訊息的結構化中繼資料。如需訊息屬性的詳細資訊，請參閱 [Aurora 的 Amazon RDS 事件類別和事件訊息](USER_Events.Messages.md)
事件通知的傳送可能需要 5 分鐘。
**重要**
Amazon RDS 不保證事件串流中傳送事件的順序。事件順序可能會改變。
當 Amazon SNS 傳送通知至已訂閱之 HTTP 或 HTTPS 端點時，已傳送至端點的 POST 訊息具有包含 JSON 文件的訊息內文。如需詳細資訊，請參閱《Amazon Simple Notification Service 開發人員指南》**中的 [Amazon SNS 訊息與 JSON 格式](https://docs.aws.amazon.com/sns/latest/dg/sns-message-and-json-formats.html)。
您可以將 SNS 設定為以簡訊通知您。如需詳細資訊，請參閱《*Amazon Simple Notification Service 開發人員指南*》中的[手機簡訊 (SMS)](https://docs.aws.amazon.com/sns/latest/dg/sns-mobile-phone-number-as-subscriber.html)。
若要關閉通知而不刪除訂閱項目，請在 Amazon RDS 主控台中，為 **Enabled** (啟用) 選擇 **No** (否)。或者，您可以使用 AWS CLI 或 Amazon RDS API `false` 將 `Enabled` 參數設定為 。
## Amazon RDS 事件通知的帳單
Amazon RDS 事件通知的帳單是透過 Amazon SNS 傳送。使用事件通知需要支付 Amazon SNS 費用。如需 Amazon SNS 帳單的詳細資訊，請參閱 [Amazon Simple Notification Service 定價](https://aws.amazon.com/sns/#pricing)。
## 使用 Amazon EventBridge 的 Aurora 事件範例
下列範例以 JSON 格式說明不同類型的 Aurora 事件。如需演示如何擷取和檢視 JSON 格式事件的教學課程，請參閱 [教學課程：使用 Amazon EventBridge 來記錄資料庫執行個體狀態變更](rds-cloud-watch-events.md#log-rds-instance-state)。
**Topics**
+ [資料庫叢集事件範例](#rds-cloudwatch-events.db-clusters)
+ [資料庫參數群組事件的範例](#rds-cloudwatch-events.db-parameter-groups)
+ [資料庫叢集快照事件範例](#rds-cloudwatch-events.db-cluster-snapshots)
### 資料庫叢集事件範例
以下是 JSON 格式的資料庫叢集事件範例。此事件顯示名為 `my-db-cluster` 的叢集已修補。事件 ID 是 `RDS-EVENT-0173`。
```
{
"version": "0",
"id": "844e2571-85d4-695f-b930-0153b71dcb42",
"detail-type": "RDS DB Cluster Event",
"source": "aws.rds",
"account": "123456789012",
"time": "2018-10-06T12:26:13Z",
"region": "us-east-1",
"resources": [
"arn:aws:rds:us-east-1:123456789012:cluster:my-db-cluster"
],
"detail": {
"EventCategories": [
"notification"
],
"SourceType": "CLUSTER",
"SourceArn": "arn:aws:rds:us-east-1:123456789012:cluster:my-db-cluster",
"Date": "2018-10-06T12:26:13.882Z",
"Message": "Database cluster has been patched",
"SourceIdentifier": "my-db-cluster",
"EventID": "RDS-EVENT-0173"
}
}
```
### 資料庫參數群組事件的範例
以下是 JSON 格式的資料庫參數群組事件範例。事件顯示參數群組 `time_zone` 的參數 `my-db-param-group` 已更新。事件 ID 是 RDS-EVENT-0037。
```
{
"version": "0",
"id": "844e2571-85d4-695f-b930-0153b71dcb42",
"detail-type": "RDS DB Parameter Group Event",
"source": "aws.rds",
"account": "123456789012",
"time": "2018-10-06T12:26:13Z",
"region": "us-east-1",
"resources": [
"arn:aws:rds:us-east-1:123456789012:pg:my-db-param-group"
],
"detail": {
"EventCategories": [
"configuration change"
],
"SourceType": "DB_PARAM",
"SourceArn": "arn:aws:rds:us-east-1:123456789012:pg:my-db-param-group",
"Date": "2018-10-06T12:26:13.882Z",
"Message": "Updated parameter time_zone to UTC with apply method immediate",
"SourceIdentifier": "my-db-param-group",
"EventID": "RDS-EVENT-0037"
}
}
```
### 資料庫叢集快照事件範例
以下是 JSON 格式的資料庫叢集快照事件範例。此事件會顯示建立名為 `my-db-cluster-snapshot` 的快照。事件 ID 是 RDS-EVENT-0074。
```
{
"version": "0",
"id": "844e2571-85d4-695f-b930-0153b71dcb42",
"detail-type": "RDS DB Cluster Snapshot Event",
"source": "aws.rds",
"account": "123456789012",
"time": "2018-10-06T12:26:13Z",
"region": "us-east-1",
"resources": [
"arn:aws:rds:us-east-1:123456789012:cluster-snapshot:rds:my-db-cluster-snapshot"
],
"detail": {
"EventCategories": [
"backup"
],
"SourceType": "CLUSTER_SNAPSHOT",
"SourceArn": "arn:aws:rds:us-east-1:123456789012:cluster-snapshot:rds:my-db-cluster-snapshot",
"Date": "2018-10-06T12:26:13.882Z",
"SourceIdentifier": "my-db-cluster-snapshot",
"Message": "Creating manual cluster snapshot",
"EventID": "RDS-EVENT-0074"
}
}
```
# 授予將通知發佈至 Amazon SNS 主題的許可
若要授予 Amazon RDS 將通知發佈至 Amazon Simple Notification Service (Amazon SNS) 主題的許可，請將 AWS Identity and Access Management(IAM) 政策附加至目的地主題。有關許可的詳細資訊，請參閱《*Amazon Simple Notification Service 開發人員指南*》中的 [Amazon Simple Notification Service 存取控制的範例案例](https://docs.aws.amazon.com/sns/latest/dg/sns-access-policy-use-cases.html)。
依預設，Amazon SNS 主題具有一項政策，可允許同一帳戶內的所有 Amazon RDS 資源向其發佈通知。您可以連接自訂政策以允許跨帳戶通知，或限制對特定資源的存取權。
以下是您連接至目的地 Amazon SNS 主題之 IAM 政策的範例。它將主題限制為名稱符合指定字首的資料庫執行個體。若要使用此政策，請指定下列值：
+ `Resource` – Amazon SNS 主題的 Amazon Resource Name (ARN)
+ `SourceARN` – 您的 RDS 資源 ARN
+ `SourceAccount` – 您的 AWS 帳戶ID
若要查看資源類型清單及其 ARN，請參閱*服務授權參考*中的 [Amazon RDS 定義的資源](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonrds.html#amazonrds-resources-for-iam-policies)。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "events.rds.amazonaws.com"
},
"Action": [
"sns:Publish"
],
"Resource": "arn:aws:sns:us-east-1:123456789012:topic_name",
"Condition": {
"ArnLike": {
"aws:SourceArn": "arn:aws:rds:us-east-1:123456789012:db:prefix-*"
},
"StringEquals": {
"aws:SourceAccount": "123456789012"
}
}
}
]
}
```
------
# 訂閱 Amazon RDS 事件通知
建立訂閱最簡單的方式是使用 RDS 主控台。如果您選擇使用 CLI 或 API 建立事件通知訂閱，您必須建立 Amazon Simple Notification Service 主題，並使用 Amazon SNS 主控台或 Amazon SNS API 訂閱該主題。您也將必須保留主題的 Amazon Resource Name (ARN)，因為在提交 CLI 命令或 API 操作時會用到它。如需建立和訂閱 SNS 主題的詳細資訊，請參閱《Amazon Simple Notification Service 開發人員指南》**中的 [Amazon SNS 入門](https://docs.aws.amazon.com/sns/latest/dg/GettingStarted.html)。
您可以指定想要收到通知的來源類型，以及觸發事件的 Amazon RDS 來源。
**Source type** (來源類型)
來源類型。例如：**Source type** (來源類型) 可能是 **Instances** (執行個體)。您必須選擇來源類型。
**要包含的*資源***
正在產生事件的 Amazon RDS 資源。例如，您可以選擇 **Select specific instances** (選取特定執行個體) 然後選擇 **myDBInstane1**。
下表說明了指定或不指定**要包含的*資源***時的結果。
| 要包含的資源 | 描述 | 範例 |
| --- | --- | --- |
| 指定 | RDS 只會通知您指定資源的所有資料庫執行個體事件。 | 如果您的 Source type (來源類型) 是 Instances (執行個體)，您的資源是 myDBInstance1，RDS 只會通知您有關 myDBInstance1。 |
| 未指定 | 您會收到所有 Amazon RDS 資源中指定來源類型事件的通知。 | 如果您的 **Source type** (來源類型) 是 **Instances** (執行個體)，RDS 會通知您帳戶中所有與執行個體相關的事件。 |
根據預設，Amazon SNS 主題訂閱者會接收發佈到主題的每個訊息。若要僅接收一部分的訊息，訂閱者必須將篩選政策指派給主題訂閱。如需有關 SNS 訊息篩選的詳細資訊，請參閱《Amazon Simple Notification Service 開發人員指南》**中的 [Amazon SNS 訊息篩選](https://docs.aws.amazon.com/sns/latest/dg/sns-message-filtering.html)
## 主控台
**訂閱 RDS 事件通知**
1. 登入 AWS 管理主控台，開啟位於 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/) 的 Amazon RDS 主控台。
1. 在導覽窗格中，選擇 **Event subscriptions** (事件訂閱)。
1. 在 **Event subscriptions (事件訂閱)** 窗格中，選擇 **Create event subscription (建立事件訂閱)**。
1. 輸入您的訂閱詳細資訊，如下所示：
1. 在 **Name (名稱)** 中，輸入事件通知訂閱的名稱。
1. 對於 **Send notification to:** (傳送通知給：)，執行以下其中一項：
+ 選擇 **New email topic** (新的電子郵件主題)。輸入電子郵件主題的名稱和收件者清單。建議您將事件訂閱設定為與主要帳戶聯絡人相同的電子郵件地址。建議、服務事件和個人健康訊息會使用不同的通道傳送。訂閱相同電子郵件地址可確保所有郵件都合併在一個位置。
+ 選擇 **Amazon Resource Name (ARN)**。然後在 Amazon SNS 主題中選擇現有 Amazon SNS ARN。
如果您想要使用已為伺服器端加密 (SSE) 啟用的主題，請授予 Amazon RDS 存取 AWS KMS key 所需的許可。如需詳細資訊，請參閱《*Amazon Simple Notification Service 開發人員指南*》中的[啟用 AWS 服務的事件來源與加密主題之間的相容性](https://docs.aws.amazon.com/sns/latest/dg/sns-key-management.html#compatibility-with-aws-services)。
1. 在 **Source type (來源類型)** 中選擇來源類型。例如，選擇 **Cluster** (叢集) 或 **Cluster snapshots** (叢集快照)。
1. 選擇您要接收通知的事件類型和資源。
下列範例設定名為 `testinst` 之資料庫執行個體的事件通知。
![\[輸入來源類型\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/images/event-source.png)
1. 選擇 **Create** (建立)。
Amazon RDS 主控台顯示正在建立訂閱。
![\[列出資料庫事件通知訂閱\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/images/EventNotification-Create2.png)
## AWS CLI
使用 AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/create-event-subscription.html](https://docs.aws.amazon.com/cli/latest/reference/rds/create-event-subscription.html) 命令來訂閱 RDS 事件通知。包含下列必要參數：
+ `--subscription-name`
+ `--sns-topic-arn`
**Example**
對於 Linux、macOS 或 Unix：
```
aws rds create-event-subscription \
--subscription-name myeventsubscription \
--sns-topic-arn arn:aws:sns:us-east-1:123456789012:myawsuser-RDS \
--enabled
```
在 Windows 中：
```
aws rds create-event-subscription ^
--subscription-name myeventsubscription ^
--sns-topic-arn arn:aws:sns:us-east-1:123456789012:myawsuser-RDS ^
--enabled
```
## API
如要訂閱 Amazon RDS 事件通知，請呼叫 Amazon RDS API 函數 [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateEventSubscription.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateEventSubscription.html)。包含下列必要參數：
+ `SubscriptionName`
+ `SnsTopicArn`
# Amazon RDS 事件通知標籤與屬性
當 Amazon RDS 將事件通知傳送至 Amazon Simple Notification Service (SNS) 或 Amazon EventBridge 時，通知會包含訊息屬性和事件標籤。RDS 會隨訊息單獨傳送訊息屬性，而事件標籤位於訊息內文中。使用訊息屬性和 Amazon RDS 標籤，將中繼資料新增至資源。您可以使用關於資料庫執行個體、Aurora 叢集等的表示法。如需標記 Amazon RDSAurora 資源的詳細資訊，請參閱 [標記 Amazon Aurora 和 Amazon RDS 資源](USER_Tagging.md)。
根據預設，Amazon SNS 和 Amazon EventBridge 會接收傳送給它們的每則訊息。SNS 和 EventBridge 可以篩選訊息並將通知傳送到偏好的通訊模式，例如電子郵件、簡訊或呼叫 HTTP 端點。
**注意**
透過電子郵件或簡訊傳送的通知不會有事件標籤。
下表顯示傳送到主題訂閱者的 RDS 事件的訊息屬性。
| Amazon RDS 事件屬性 | Description |
| --- | --- |
| EventID | RDS 事件訊息的識別碼，例如 RDS-EVENT-0006。 |
| 資源 | 發出事件之資源的 ARN 識別符，例如 `arn:aws:rds:ap-southeast-2:123456789012:db:database-1`。 |
RDS 標籤提供受服務事件影響之資源的相關資料。當通知傳送至 SNS 或 EventBridge 時，RDS 會在訊息內文中新增標籤的目前狀態。
如需有關 SNS 訊息篩選屬性的詳細資訊，請參閱《Amazon Simple Notification Service 開發人員指南》**中的 [Amazon SNS 訊息篩選](https://docs.aws.amazon.com/sns/latest/dg/sns-message-filtering.html)
如需為 EventBridge 篩選事件標籤的詳細資訊，請參閱《Amazon EventBridge 使用者指南》**中的[在 Amazon EventBridge 中用於事件模式的比較運算子](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-patterns-content-based-filtering.html)。
如需篩選 SNS 承載型標籤的詳細資訊，請參閱 [Amazon SNS 承載型訊息篩選簡介](https://aws.amazon.com/blogs/compute/introducing-payload-based-message-filtering-for-amazon-sns/)
# 列出 Amazon RDS 事件通知訂閱
您可以列出您目前的 Amazon RDS 事件通知訂閱。
## 主控台
**列出您目前的 Amazon RDS 事件通知訂閱**
1. 登入 AWS 管理主控台，開啟位於 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/) 的 Amazon RDS 主控台。
1. 在導覽窗格中，選擇 **Event subscriptions** (事件訂閱)。**Event subscriptions (事件訂閱)** 窗格顯示所有事件通知訂閱。
![\[列出資料庫事件通知訂閱\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/images/EventNotification-ListSubs.png)
## AWS CLI
使用 AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/describe-event-subscriptions.html](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-event-subscriptions.html) 命令來列出您目前的 Amazon RDS 事件通知訂閱。
**Example**
以下範例說明所有事件訂閱。
```
aws rds describe-event-subscriptions
```
以下範例說明 `myfirsteventsubscription`。
```
aws rds describe-event-subscriptions --subscription-name myfirsteventsubscription
```
## API
呼叫 Amazon RDS API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeEventSubscriptions.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeEventSubscriptions.html) 動作來列出您目前的 Amazon RDS 事件通知訂閱。
# 修改 Amazon RDS 事件通知訂閱
在您建立訂閱之後，您可以變更訂閱名稱、來源識別碼、類別或主題 ARN。
## 主控台
**修改 Amazon RDS 事件通知訂閱**
1. 登入 AWS 管理主控台，開啟位於 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/) 的 Amazon RDS 主控台。
1. 在導覽窗格中，選擇 **Event subscriptions** (事件訂閱)。
1. 在 **Event subscriptions (事件訂閱)** 窗格中，選擇您要修改的訂閱，然後選擇 **Edit (編輯)**。
1. 在 **Target (目標)** 或 **Source (來源)** 區段中，對訂閱進行變更。
1. 選擇**編輯**。Amazon RDS 主控台顯示正在修改訂閱。
![\[列出資料庫事件通知訂閱\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/images/EventNotification-Modify2.png)
## AWS CLI
使用 AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/modify-event-subscription.html](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-event-subscription.html) 命令來修改 Amazon RDS 事件通知訂閱。包含下列必要參數：
+ `--subscription-name`
**Example**
下列範例程式碼啟動 `myeventsubscription`。
對於 Linux、macOS 或 Unix：
```
aws rds modify-event-subscription \
--subscription-name myeventsubscription \
--enabled
```
在 Windows 中：
```
aws rds modify-event-subscription ^
--subscription-name myeventsubscription ^
--enabled
```
## API
若要修改 Amazon RDS 事件，請呼叫 Amazon RDS API 操作 [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyEventSubscription.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyEventSubscription.html)。包含下列必要參數：
+ `SubscriptionName`
# 將來源識別碼新增至 Amazon RDS 事件通知訂閱
您可以將來源識別碼 (產生事件的 Amazon RDS 來源) 新增至現有的訂閱。
## 主控台
您可以在修改訂閱時，使用 Amazon RDS 主控台選取或取消選取來源識別碼，以輕鬆地新增或移除來源識別碼。如需更多詳細資訊，請參閱 [修改 Amazon RDS 事件通知訂閱](USER_Events.Modifying.md)。
## AWS CLI
若要將來源識別符新增至 Amazon RDS 事件通知訂閱，請使用 AWS CLI [https://docs.aws.amazon.com/](https://docs.aws.amazon.com/)命令。包含下列必要參數：
+ `--subscription-name`
+ `--source-identifier`
**Example**
下列範例將來源識別碼 `mysqldb` 新增至 `myrdseventsubscription` 訂閱。
對於 Linux、macOS 或 Unix：
```
aws rds add-source-identifier-to-subscription \
--subscription-name myrdseventsubscription \
--source-identifier mysqldb
```
在 Windows 中：
```
aws rds add-source-identifier-to-subscription ^
--subscription-name myrdseventsubscription ^
--source-identifier mysqldb
```
## API
呼叫 Amazon RDS API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_AddSourceIdentifierToSubscription.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_AddSourceIdentifierToSubscription.html) 將來源識別碼新增至 Amazon RDS 事件通知訂閱。包含下列必要參數：
+ `SubscriptionName`
+ `SourceIdentifier`
# 將來源識別碼從 Amazon RDS 事件通知訂閱中移除
如果您不再希望收到某個來源的事件通知，您可以從訂閱中移除該來源識別碼 (產生事件的 Amazon RDS 來源)。
## 主控台
您可以在修改訂閱時，使用 Amazon RDS 主控台選取或取消選取來源識別碼，以輕鬆地新增或移除來源識別碼。如需更多詳細資訊，請參閱 [修改 Amazon RDS 事件通知訂閱](USER_Events.Modifying.md)。
## AWS CLI
若要從 Amazon RDS 事件通知訂閱中移除來源識別符，請使用 AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/remove-source-identifier-from-subscription.html](https://docs.aws.amazon.com/cli/latest/reference/rds/remove-source-identifier-from-subscription.html)命令。包含下列必要參數：
+ `--subscription-name`
+ `--source-identifier`
**Example**
下列範例將來源識別碼 `mysqldb` 從 `myrdseventsubscription` 訂閱中移除。
對於 Linux、macOS 或 Unix：
```
aws rds remove-source-identifier-from-subscription \
--subscription-name myrdseventsubscription \
--source-identifier mysqldb
```
在 Windows 中：
```
aws rds remove-source-identifier-from-subscription ^
--subscription-name myrdseventsubscription ^
--source-identifier mysqldb
```
## API
使用 Amazon RDS API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RemoveSourceIdentifierFromSubscription.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RemoveSourceIdentifierFromSubscription.html) 命令將來源識別碼從 Amazon RDS 事件通知訂閱中移除。包含下列必要參數：
+ `SubscriptionName`
+ `SourceIdentifier`
# 列出 Amazon RDS 事件通知類別
一種資源類型的所有事件會群組為各種類別。若要查看可用的類別清單，請使用下列程序。
## 主控台
當您建立或修改事件通知訂閱時，事件類別會顯示在 Amazon RDS 主控台。如需更多詳細資訊，請參閱 [修改 Amazon RDS 事件通知訂閱](USER_Events.Modifying.md)。
![\[列出資料庫事件通知類別\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/images/EventNotification-Categories.png)
## AWS CLI
使用 AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/describe-event-categories.html](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-event-categories.html) 命令來列出 Amazon RDS 事件通知訂閱類別。此命令沒有要求的參數。
**Example**
```
aws rds describe-event-categories
```
## API
使用 Amazon RDS API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeEventCategories.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeEventCategories.html) 命令來列出 Amazon RDS 事件通知訂閱類別。此命令沒有要求的參數。
# 刪除 Amazon RDS 事件通知訂閱
您可以刪除不再需要的訂閱。該主題的所有訂閱者將不會再收到該訂閱指定的事件通知。
## 主控台
**刪除 Amazon RDS 事件通知訂閱**
1. 登入 AWS 管理主控台，開啟位於 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/) 的 Amazon RDS 主控台。
1. 在導覽窗格中，選擇 **DB Event Subscriptions** (資料庫事件訂閱)。
1. 在 **My DB Event Subscriptions (我的資料庫事件訂閱)** 窗格中，選擇您要刪除的訂閱。
1. 選擇 **刪除**。
1. Amazon RDS 主控台顯示正在刪除訂閱。
![\[刪除事件通知訂閱\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/images/EventNotification-Delete.png)
## AWS CLI
使用 AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/delete-event-subscription.html](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-event-subscription.html) 命令來刪除 Amazon RDS 事件通知訂閱。包含下列必要參數：
+ `--subscription-name`
**Example**
以下範例刪除訂閱 `myrdssubscription`。
```
aws rds delete-event-subscription --subscription-name myrdssubscription
```
## API
使用 RDS API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteEventSubscription.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DeleteEventSubscription.html) 命令來刪除 Amazon RDS 事件通知訂閱。包含下列必要參數：
+ `SubscriptionName`
# 建立由 Amazon Aurora 事件觸發的規則
使用 Amazon EventBridge，您可以自動化 AWS 服務並回應系統事件，例如應用程式可用性問題或資源變更。
**Topics**
+ [教學課程：使用 Amazon EventBridge 來記錄資料庫執行個體狀態變更](#log-rds-instance-state)
## 教學課程：使用 Amazon EventBridge 來記錄資料庫執行個體狀態變更
在本教學課程中，您會建立 AWS Lambda 函數，記錄 執行個體的狀態變更。然後，您建立一個規則，在現有 RDS 資料庫執行個體的狀態變更時執行該函數。本教學假設您擁有可以暫時關閉的小型執行中測試執行個體。
**重要**
請勿在執行生產資料庫執行個體上執行本教學課程。
**Topics**
+ [步驟 1：建立 AWS Lambda 函數](#rds-create-lambda-function)
+ [步驟 2：建立規則](#rds-create-rule)
+ [步驟 3：測試規則](#rds-test-rule)
### 步驟 1：建立 AWS Lambda 函數
建立 Lambda 函數以記錄狀態變更事件。當您在建立規則時指定此函數。
**建立 Lambda 函數**
1. 在 https：//[https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/) 開啟 AWS Lambda 主控台。
1. 如果您是第一次使用 Lambda，將會看到歡迎頁面。選擇 **Get Started Now (立即開始)**。否則，請選擇 **Create function (建立函數)**。
1. 選擇 **Author from scratch** (從頭開始撰寫)。
1. 在 **Create function (建立函數)** 頁面上，執行下列動作：
1. 輸入 Lambda 函數的名稱和描述。例如，將函數命名為 **RDSInstanceStateChange**。
1. 在 **Runtime** (執行時間) 中，選取 **Node.js 16x**。
1. 對於 **Architecture** (架構)，選擇 **x86\$164**。
1. 對於 **Execution role** (執行角色)，執行下列任何一項：
+ 選擇 **Create a new role with basic Lambda permissions (建立具備基本 Lambda 許可的新角色)**。
+ 針對 **Existing role (現有角色)**，選擇 **Use an existing role** (使用現有的角色)。選擇您想使用的角色。
1. 選擇 **Create function** (建立函式)。
1. 在 **RDSInstanceStateChange** 頁面，執行下列動作：
1. 在 **Code source** (程式碼來源) 中，選取 **index.js**。
1. 在 **index.js** 窗格中，刪除現有的程式碼。
1. 輸入下列程式碼︰
```
console.log('Loading function');
exports.handler = async (event, context) => {
console.log('Received event:', JSON.stringify(event));
};
```
1. 選擇 **Deploy (部署)**。
### 步驟 2：建立規則
建立規則，在您啟動 Amazon RDS 執行個體時，執行您的 Lambda 函數。
**若要建立 EventBridge 規則**
1. 在 [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/) 開啟 Amazon EventBridge 主控台。
1. 在導覽窗格中，選擇**規則**。
1. 選擇**建立規則**。
1. 輸入規則的名稱和描述。例如，輸入 **RDSInstanceStateChangeRule**。
1. 選擇 **Rule with an event pattern** (具有事件模式的規則)，然後選擇 **Next** (下一步)。
1. 在**事件來源**欄位中，選擇 **AWS 事件或 EventBridge 合作夥伴事件**。
1. 向下捲動到 **Event pattern** (事件模式) 區段中。
1. 在 **Event source (事件來源)**，選擇 **AWS 服務**。
1. 對於 **AWS Service** (服務)，選擇 **Relational Database Service (RDS)** (關聯式資料庫服務)。
1. 對於 **Event type** (事件類型)，選擇 **RDS DB Instance Event** (RDS 資料庫執行個體事件)。
1. 保留預設事件模式。然後選擇**下一步**。
1. 在**目標類型**欄位中，選擇 **AWS 服務**。
1. 對於 **Select a target** (選取目標)，選擇 **Lambda function** (Lambda 函數)。
1. 針對 **Function** (函數)，選擇您建立的 Lambda 函數。然後選擇**下一步**。
1. 在 **Configure tags** (設定標籤) 中，選擇 **Next** (下一步)。
1. 檢閱規則中的步驟。然後，選擇 **Create role** (建立角色)。
### 步驟 3：測試規則
若要測試您的規則，請關閉 RDS 資料庫執行個體。等待幾分鐘讓執行個體關閉，驗證您的 Lambda 函數是否被叫用。
**停用資料庫執行個體以測試您的規則**
1. 前往 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)，開啟 Amazon RDS 主控台。
1. 停止 RDS 資料庫執行個體。
1. 在 [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/) 開啟 Amazon EventBridge 主控台。
1. 在導覽窗格中，選擇 **Rules** (規則)，然後選擇您建立的規則名稱。
1. 在**規則詳細資料**中，選擇**監控**。
您會被重新導向至 Amazon CloudWatch 主控台。如果您未重新導向，請按一下**在 CloudWatch 中檢視指標**。
1. 在 **All metrics** (所有指標) 中，選擇您建立的規則名稱。
該圖表應指示已叫用的規則。
1. 在導覽窗格中，選擇 **Log groups** (日誌群組)。
1. 選擇您的 Lambda 函數的日誌群組名稱 (**/aws/lambda/*function-name***)。
1. 選擇日誌串流名稱以檢視函數為您啟動的執行個體所提供的資料。您應該會看到類似以下接收的事件：
```
{
"version": "0",
"id": "12a345b6-78c9-01d2-34e5-123f4ghi5j6k",
"detail-type": "RDS DB Instance Event",
"source": "aws.rds",
"account": "111111111111",
"time": "2021-03-19T19:34:09Z",
"region": "us-east-1",
"resources": [
"arn:aws:rds:us-east-1:111111111111:db:testdb"
],
"detail": {
"EventCategories": [
"notification"
],
"SourceType": "DB_INSTANCE",
"SourceArn": "arn:aws:rds:us-east-1:111111111111:db:testdb",
"Date": "2021-03-19T19:34:09.293Z",
"Message": "DB instance stopped",
"SourceIdentifier": "testdb",
"EventID": "RDS-EVENT-0087"
}
}
```
如需更多 JSON 格式的 RDS 事件範例，請參閱 [Aurora 的事件概觀](working-with-events.md#rds-cloudwatch-events.sample)。
1. (選用) 完成後，您可以開啟 Amazon RDS 主控台並啟用您停止的執行個體。
# Aurora 的 Amazon RDS 事件類別和事件訊息
Amazon RDS 在您可以使用 Amazon RDS 主控台 AWS CLI或 API 訂閱的類別中產生大量事件。
**Topics**
+ [資料庫叢集事件](#USER_Events.Messages.cluster)
+ [資料庫叢集快照事件](#USER_Events.Messages.cluster-snapshot)
+ [資料庫執行個體事件](#USER_Events.Messages.instance)
+ [資料庫參數群組事件](#USER_Events.Messages.parameter-group)
+ [資料庫安全群組事件](#USER_Events.Messages.security-group)
+ [資料庫碎片群組事件](#USER_Events.Messages.shard-group)
+ [RDS Proxy 事件](#USER_Events.Messages.rds-proxy)
+ [藍/綠部署事件](#USER_Events.Messages.BlueGreenDeployments)
## 資料庫叢集事件
下表顯示當資料庫叢集為來源類型時的事件類別和事件清單。
**注意**
資料庫叢集事件類型中不存在 Aurora Serverless 的事件類別。Aurora 無伺服器事件範圍從 RDS-EVENT-0141 到 RDS-EVENT-0149。
| 類別 | RDS 事件 ID | 訊息 | 備註 |
| --- | --- | --- | --- |
| 組態變更 | RDS-EVENT-0016 | 重設主要憑證。 | 無 |
| 組態變更 | RDS-EVENT-0179 | 資料庫叢集上的資料庫活動串流已啟動。 | 如需更多詳細資訊，請參閱 [使用資料庫活動串流來監控 Amazon Aurora](DBActivityStreams.md)。 |
| 設定更改 | RDS-EVENT-0180 | 資料庫叢集上的資料庫活動串流已停止。 | 如需更多詳細資訊，請參閱 [使用資料庫活動串流來監控 Amazon Aurora](DBActivityStreams.md)。 |
| 建立 | RDS-EVENT-0170 | 已建立資料庫叢集。 | 無 |
| 刪除 | RDS-EVENT-0171 | 資料庫叢集已刪除。 | 無 |
| 容錯移轉 | RDS-EVENT-0069 | 叢集容錯移轉失敗，請檢查叢集執行個體的運作狀態，然後再試一次。 | 無 |
| 容錯移轉 | RDS-EVENT-0070 | 再次提升上一個主要項目：*name*。 | 無 |
| 容錯移轉 | RDS-EVENT-0071 | 已完成容錯移轉至資料庫執行個體：*name*。 | 無 |
| 容錯移轉 | RDS-EVENT-0072 | 已啟動相同的 AZ 容錯移轉至資料庫執行個體：*name*。 | 無 |
| 容錯移轉 | RDS-EVENT-0073 | 已啟動跨 AZ 容錯移轉至資料庫執行個體：*name*。 | 無 |
| 失敗 | RDS-EVENT-0083 | Amazon RDS 無法建立憑證，為您的資料庫叢集 *name* 存取您的 Amazon S3 儲存貯體。這是因為您的帳戶中未正確設定 S3 快照擷取 IAM 角色，或找不到指定的 Amazon S3 儲存貯體。如需進一步的詳細資訊，請參閱 Amazon RDS 文件中的疑難排解一節。 | 如需詳細資訊，請參閱[使用 Percona XtraBackup 和 Amazon S3 從 MySQL 進行實體遷移](AuroraMySQL.Migrating.ExtMySQL.S3.md) 。 |
| 失敗 | RDS-EVENT-0143 | 由於以下原因，資料庫叢集無法從 *units* 擴展至 *units*：*reason*。 | Aurora Serverless 資料庫叢集擴展失敗。 |
| 失敗 | RDS-EVENT-0354 | 由於資源不相容，您無法建立資料庫叢集。*訊息*。 | 該*訊息*包含有關故障的詳細資料。 |
| 失敗 | RDS-EVENT-0355 | 由於資源限制不足，無法建立資料庫叢集。*訊息*。 | 該*訊息*包含有關故障的詳細資料。 |
| 失敗 | RDS-EVENT-0387 | 無法在資料庫叢集*名稱*中分割資料庫執行個體以進行修補。 | 資料庫叢集中資料庫執行個體的作業系統升級失敗。 |
| 全域容錯移轉 | RDS-EVENT-0181 | 已啟動區域 *name* 中的全球轉換至資料庫叢集 *name*。 | 此為轉換操作的事件 (舊稱為「受管計畫容錯移轉」)。 因為其他作業正在資料庫叢集上執行，所以此程序可能延遲。 |
| 全域容錯移轉 | RDS-EVENT-0182 | 區域 *name* 中的舊主要資料庫叢集 *name* 成功關閉。 | 此為轉換操作的事件 (舊稱為「受管計畫容錯移轉」)。 全域資料庫中的舊主要執行個體不接受寫入。所有磁碟區都會同步化。 |
| 全域容錯移轉 | RDS-EVENT-0183 | 等待跨全域叢集成員的資料同步。目前落後於主要資料庫叢集：`reason`。 | 此為轉換操作的事件 (舊稱為「受管計畫容錯移轉」)。 複寫延遲發生在全域資料庫容錯移轉的同步階段期間。 |
| 全域容錯移轉 | RDS-EVENT-0184 | 區域 *name* 中的新主要資料庫叢集 *name* 成功提升。 | 此為轉換操作的事件 (舊稱為「受管計畫容錯移轉」)。 全域資料庫的磁碟區拓撲會以新的主要磁碟區重新建立。 |
| 全域容錯移轉 | RDS-EVENT-0185 | 已完成區域 *name* 中的全球轉換至資料庫叢集 *name*。 | 此為轉換操作的事件 (舊稱為「受管計畫容錯移轉」)。 已在主要資料庫叢集上完成全球資料庫轉換。容錯移轉完成後，複本可能需要很長時間才能上線。 |
| 全域容錯移轉 | RDS-EVENT-0186 | 已取消區域 *name* 中的全球轉換至資料庫叢集 *name*。 | 此為轉換操作的事件 (舊稱為「受管計畫容錯移轉」)。 |
| 全域容錯移轉 | RDS-EVENT-0187 | 區域 *name* 中的全球轉換至資料庫叢集 *name* 失敗。 | 此為轉換操作的事件 (舊稱為「受管計畫容錯移轉」)。 |
| 全域容錯移轉 | RDS-EVENT-0238 | 已完成區域 *name* 中的全球容錯移轉至資料庫叢集 *name*。 | 無 |
| 全域容錯移轉 | RDS-EVENT-0239 | 區域 *name* 中的全域容錯移轉至資料庫叢集 *name* 失敗。 | 無 |
| 全域容錯移轉 | RDS-EVENT-0240 | 全球容錯移轉後，已開始重新同步處理區域 *name* 中資料庫叢集 *name* 的成員。 | 無 |
| 全域容錯移轉 | RDS-EVENT-0241 | 全球容錯移轉後，已完成重新同步處理區域 *name* 中資料庫叢集 *name* 的成員。 | 無 |
| 全域容錯移轉 | RDS-EVENT-0397 | Aurora 已完成變更全域寫入器端點解析的 DNS 名稱。 | 無 |
| 全域容錯移轉 | RDS-EVENT-0423 | 等待與目標資料庫叢集的資料同步。目前目標資料庫叢集落後於主要資料庫叢集：`%s`。 | 此為轉換操作的事件 (舊稱為「受管計畫容錯移轉」)。 複寫延遲發生在全域資料庫容錯移轉的同步階段期間。 |
| 維護 | RDS-EVENT-0156 | 資料庫叢集有可用的資料庫引擎次要版本升級。 | 無 |
| 維護 | RDS-EVENT-0173 | 資料庫叢集引擎版本已升級。 | 已完成資料庫叢集的修補。 |
| 維護 | RDS-EVENT-0174 | 資料庫叢集處於無法升級的狀態。 | 無 |
| 維護 | RDS-EVENT-0176 | 資料庫叢集引擎主要版本已升級。 | 無 |
| 維護 | RDS-EVENT-0177 | 資料庫叢集升級正在進行中。 | 無 |
| 維護 | RDS-EVENT-0286 | 資料庫叢集引擎 *version\$1number* 版本升級已開始。叢集保持線上狀態。 | 無 |
| 維護 | RDS-EVENT-0287 | 偵測到作業系統升級需求。 | 無 |
| 維護 | RDS-EVENT-0288 | 叢集作業系統升級開始中。 | 無 |
| 維護 | RDS-EVENT-0289 | 叢集作業系統升級已完成。 | 無 |
| 維護 | RDS-EVENT-0290 | 已修補資料庫叢集：來源版本 *version\$1number* => *new\$1version\$1number*。 | 無 |
| 維護 | RDS-EVENT-0363 | 升級準備進行中：*cluster\$1name* | 資料庫叢集的升級前檢查已開始。 |
| 維護 | RDS-EVENT-0388 | 在資料庫叢集*名稱*的分割區*名稱*/*名稱*中啟動資料庫執行個體的離線修補程式：*partition\$1n*。 | 啟動資料庫叢集中資料庫執行個體的作業系統升級。 |
| 維護 | RDS-EVENT-0389 | 我們無法升級您的資料庫叢集作業系統。您可以等待下一個維護時段，也可以手動升級資料庫叢集作業系統。 | 無 |
| 維護 | RDS-EVENT-0424 | 資料庫叢集*名稱*正在執行版本*版本*，此版本高於全域叢集的目標升級版本*版本*。我們不建議在高於全域叢集的版本上使用次要叢集，因為它可能會在容錯移轉或轉換期間造成問題。請考慮升級您的全域叢集以符合條件。 | 無 |
| notification | RDS-EVENT-0076 | 無法從 *name* 遷移至 *name*。原因：*reason*。 | 遷移至 Aurora 資料庫叢集失敗。 |
| 則通知 | RDS-EVENT-0077 | 無法將 *name*.*name* 轉換為 InnoDB。原因：*reason*。 | 在遷移至 Aurora 資料庫叢集時，嘗試從來源資料庫將資料表轉換為 InnoDB 失敗。 |
| 則通知 | RDS-EVENT-0085 | 無法升級資料庫叢集 *name*，因為執行個體 *name* 的狀態為 *name*。解決問題或刪除執行個體，然後再試一次。 | 嘗試修補 Aurora 資料庫叢集時發生錯誤。檢查您的執行個體狀態，解決問題，然後再試一次。如需更多詳細資訊，請參閱 [維持 為 Amazon Aurora 資料庫叢集](USER_UpgradeDBInstance.Maintenance.md)。 |
| 則通知 | RDS-EVENT-0141 | 由於以下原因，正在將資料庫叢集從 *units* 擴展至 *units*：*reason*。 | Aurora Serverless 資料庫叢集已起始擴展。 |
| 則通知 | RDS-EVENT-0142 | 資料庫叢集已從 *units* 擴展至 *units*。 | Aurora Serverless 資料庫叢集已完成擴展。 |
| 則通知 | RDS-EVENT-0144 | 資料庫叢集正在暫停。 | 已針對 Aurora Serverless 資料庫叢集啟動自動暫停。 |
| notification | RDS-EVENT-0145 | 資料庫叢集已暫停。 | Aurora Serverless 資料庫叢集已暫停。 |
| notification | RDS-EVENT-0146 | 已取消暫停資料庫叢集。 | 已取消暫停 Aurora Serverless 資料庫叢集。 |
| notification | RDS-EVENT-0147 | 正在恢復資料庫叢集。 | 已啟動 Aurora Serverless 資料庫叢集的恢復操作。 |
| notification | RDS-EVENT-0148 | 已恢復資料庫叢集。 | 已完成 Aurora Serverless 資料庫叢集的恢復操作。 |
| notification | RDS-EVENT-0149 | 資料庫叢集已從 *units* 擴展至 *units*，但由於以下原因，擴展並不順輰：*reason*。 | 使用 Aurora Serverless 資料庫叢集強制選項完成無縫擴展。可能已依要求中斷連線。 |
| 則通知 | RDS-EVENT-0150 | 資料庫叢集已停止。 | 無 |
| notification | RDS-EVENT-0151 | 資料庫叢集已啟動。 | 無 |
| notification | RDS-EVENT-0152 | 資料庫叢集停止失敗。 | 無 |
| notification | RDS-EVENT-0153 | 資料庫叢集正在啟動，因為它超過允許停止的時間上限。 | 無 |
| notification | RDS-EVENT-0172 | 叢集已從 *name* 重新命名為 *name*。 | 無 |
| notification | RDS-EVENT-0234 | 匯出任務失敗。 | 資料庫叢集匯出任務失敗。 |
| notification | RDS-EVENT-0235 | 已取消匯出任務。 | 已取消資料庫叢集匯出任務。 |
| notification | RDS-EVENT-0236 | 已完成匯出任務。 | 已完成資料庫叢集匯出任務。 |
| notification | RDS-EVENT-0386 | 資料庫叢集*名稱*中的資料庫執行個體已分割：*list\$1of\$1partitions*。資料庫叢集已上線。 | 資料庫叢集中資料庫執行個體的作業系統升級成功。 |
| notification | RDS-EVENT-0426 | 由於交易閒置或長時間執行，RDS 無法將資料庫叢集*名稱*設定為複寫來源。等待交易完成或取消它們，然後再試一次。 | 無 |
## 資料庫叢集快照事件
下表顯示當資料庫叢集快照為來源類型時的事件類別和事件清單。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/USER_Events.Messages.html)
## 資料庫執行個體事件
下表顯示當資料庫執行個體為來源類型時的事件類別和事件清單。
| Category | RDS 事件 ID | 訊息 | 備註 |
| --- | --- | --- | --- |
| 可用性 | RDS-EVENT-0004 | 資料庫執行個體關機。 | 無 |
| 可用性 | RDS-EVENT-0006 | 資料庫執行個體已重新啟動。 | 無 |
| 可用性 | RDS-EVENT-0022 | 重新啟動 mysql 時發生錯誤：*message*。 | 重新啟動 Aurora MySQL 或 RDS for MariaDB 時發生錯誤。 |
| 可用性 | RDS-EVENT-0419 | Amazon RDS 無法存取資料庫執行個體*名稱*的 KMS 加密金鑰。此資料庫將進入無法存取的狀態。如需進一步的詳細資訊，請參閱 Amazon RDS 文件中的疑難排解一節。 | 無 |
| 恢復 | RDS-EVENT-0131 | 實際恢復時段比您指定的目標恢復時段還小。請考量減少目標恢復時段中的時數。 | 如需更多有關恢復的資訊，請參閱 [恢復 Aurora 資料庫叢集](AuroraMySQL.Managing.Backtrack.md)。 |
| 恢復 | RDS-EVENT-0132 | 實際恢復時段與目標恢復時段相同。 | 無 |
| 設定更改 | RDS-EVENT-0011 | 已更新為使用 DBParameterGroup *名稱*。 | 無 |
| 組態變更 | RDS-EVENT-0012 | 套用修改至資料庫執行個體類別。 | 無 |
| 組態變更 | RDS-EVENT-0014 | 將修改套用至資料庫執行個體類別已完成。 | 無 |
| 組態變更 | RDS-EVENT-0017 | 將修改套用至配置的儲存已完成。 | 無 |
| 組態變更 | RDS-EVENT-0025 | 套用修改以轉換為多可用區域資料庫執行個體已完成。 | 無 |
| 組態變更 | RDS-EVENT-0029 | 套用修改以轉換為標準 (單一可用區域) 資料庫執行個體已完成。 | 無 |
| 組態變更 | RDS-EVENT-0033 | 有 *number* 個使用者符合主要使用者名稱；僅重設未繫結至特定主機的使用者。 | 無 |
| 組態變更 | RDS-EVENT-0067 | 無法重設您的密碼。錯誤資訊：*message*。 | 無 |
| 組態變更 | RDS-EVENT-0078 | 監控間隔已變更為 *number*。 | 增強型監控組態已變更。 |
| 組態變更 | RDS-EVENT-0092 | 已完成資料庫參數群組的更新。 | 無 |
| 建立 | RDS-EVENT-0005 | 已建立資料庫執行個體。 | 無 |
| 刪除 | RDS-EVENT-0003 | 已刪除資料庫執行個體。 | 無 |
| 失敗 | RDS-EVENT-0035 | 資料庫執行個體進入 *state*。*message*。 | 資料庫執行個體有無效的參數。例如，如果此執行個體類別與記憶體相關的參數設定過高造成資料庫叢集無法啟動，則您的動作將為修改記憶體參數並重新啟動資料庫執行個體。 |
| 失敗 | RDS-EVENT-0036 | 資料庫執行個體處於 *state*。*message*。 | 資料庫執行個體位於不相容的網路中。部分指定的子網路 ID 無效或不存在。 |
| 失敗 | RDS-EVENT-0079 | Amazon RDS 無法建立用於增強型監控的憑證，且此功能已停用。這可能是因為 rds-monitoring-role 不存在，且未在您的帳戶中正確設定所致。如需進一步的詳細資訊，請參閱 Amazon RDS 文件中的疑難排解一節。 | 若沒有增強型監控 IAM 角色，無法啟用增強型監控。如需建立 IAM 角色的相關資訊，請參閱 [為 Amazon RDS 增強型監控建立 IAM 角色](USER_Monitoring.OS.Enabling.md#USER_Monitoring.OS.IAMRole)。 |
| 失敗 | RDS-EVENT-0080 | Amazon RDS 無法在您的執行個體上設定增強型監控：*name*，且此功能已停用。這可能是因為 rds-monitoring-role 不存在，且未在您的帳戶中正確設定所致。如需進一步的詳細資訊，請參閱 Amazon RDS 文件中的疑難排解一節。 | 因為組態變更期間發生錯誤，所以增強型監控已停用。可能是未正確設定增強型監控 IAM 角色。如需建立增強型監控 IAM 角色的相關資訊，請參閱 [為 Amazon RDS 增強型監控建立 IAM 角色](USER_Monitoring.OS.Enabling.md#USER_Monitoring.OS.IAMRole)。 |
| 失敗 | RDS-EVENT-0082 | Amazon RDS 無法建立憑證，為您的資料庫執行個體 *name* 存取您的 Amazon S3 儲存貯體。這是因為您的帳戶中未正確設定 S3 快照擷取 IAM 角色，或找不到指定的 Amazon S3 儲存貯體。如需進一步的詳細資訊，請參閱 Amazon RDS 文件中的疑難排解一節。 | Aurora 無法從 Amazon S3 儲存貯體複製備份資料。可能是 Aurora 存取 Amazon S3 儲存貯體的權限設定不正確。如需更多詳細資訊，請參閱[使用 Percona XtraBackup 和 Amazon S3 從 MySQL 進行實體遷移](AuroraMySQL.Migrating.ExtMySQL.S3.md) 。 |
| 失敗 | RDS-EVENT-0353 | 由於資源限制不足，無法建立資料庫執行個體。*訊息*。 | 該*訊息*包含有關故障的詳細資料。 |
| 失敗 | RDS-EVENT-0418 | Amazon RDS 無法存取資料庫執行個體*名稱*的 KMS 加密金鑰。這可能是由於金鑰遭停用或 Amazon RDS 無法存取該金鑰。如果繼續執行，資料庫將進入無法存取的狀態。如需進一步的詳細資訊，請參閱 Amazon RDS 文件中的疑難排解一節。 | 無 |
| 失敗 | RDS-EVENT-0420 | Amazon RDS 現在可成功存取資料庫執行個體*名稱*的 KMS 加密金鑰。 | 無 |
| 低儲存 | RDS-EVENT-0007 | 配置的儲存已用盡。請配置額外的儲存來解決此問題。 | 已經使用為資料庫執行個體分配的儲存。若要解決此問題，為此資料庫執行個體分配額外儲存空間。如需詳細資訊，請參閱 [RDS 常見問答集](https://aws.amazon.com/rds/faqs)。您可以使用 **Free Storage Space (可用儲存空間)** 指標來監控資料庫執行個體的儲存空間。 |
| 低儲存 | RDS-EVENT-0089 | 資料庫執行個體 *name* 的可用儲存容量低至所佈建儲存體的 *percentage* [佈建的儲存體：*size*，可用的儲存體：*size*]。您可能想要增加已佈建的儲存體來解決此問題。 | 資料庫執行個體已消耗超過其分配儲存容量的 90%。您可以使用 **Free Storage Space (可用儲存空間)** 指標來監控資料庫執行個體的儲存空間。 |
| 低儲存 | RDS-EVENT-0227 | Aurora 叢集的儲存體極低，只剩下 *amount* TB。請採取措施來減少叢集上的儲存負載。 | Aurora 儲存子系統的空間不足。 |
| 維護 | RDS-EVENT-0026 | 正在將離線修補程式套用至資料庫執行個體。 | 資料庫執行個體的離線維護正在進行。資料庫執行個體目前無法使用。 |
| 維護 | RDS-EVENT-0027 | 已完成將離線修補程式套用至資料庫執行個體。 | 資料庫執行個體的離線維護已完成。資料庫執行個體現在可用。 |
| 維護 | RDS-EVENT-0047 | 已修補資料庫執行個體。 | 無 |
| 維護 | RDS-EVENT-0155 | 資料庫執行個體有可用的資料庫引擎次要版本升級。 | 無 |
| 維護 | RDS-EVENT-0178 | 資料庫執行個體升級正在進行中。 | 無 |
| 維護 | RDS-EVENT-0422 | 由於待定維護動作，RDS 將取代資料庫執行個體*名稱*的主機。 | 無 |
| notification | RDS-EVENT-0044 | *message* | 這是操作員發出的通知。如需詳細資訊，請參閱事件訊息。 |
| 則通知 | RDS-EVENT-0048 | 延遲資料庫引擎升級，因為此執行個體具有需要先升級的僅供讀取複本。 | 資料庫執行個體的修補作業已延遲。 |
| 則通知 | RDS-EVENT-0087 | 資料庫執行個體已停止。 | 無 |
| notification | RDS-EVENT-0088 | 資料庫執行個體已啟動。 | 無 |
| notification | RDS-EVENT-0365 | 時區檔案已更新。重新啟動 RDS 執行個體，讓變更生效。 | 無 |
| 通知、無伺服器 | RDS-EVENT-0370 | 已起始資料庫執行個體的暫停。 | 已啟動暫停閒置 Aurora Serverless v2 資料庫執行個體的新嘗試。 |
| 通知、無伺服器 | RDS-EVENT-0371 | 已取消暫停資料庫執行個體。 | 由於工作負載，嘗試暫停閒置 Aurora Serverless v2 資料庫執行個體失敗。 |
| 通知、無伺服器 | RDS-EVENT-0372 | 成功暫停資料庫執行個體。 | Aurora Serverless v2 資料庫執行個體已暫停。 |
| 通知、無伺服器 | RDS-EVENT-0373 | 已起始資料庫執行個體的繼續。 | 由於新的工作負載或管理或維護活動，Aurora Serverless v2 資料庫執行個體開始繼續。 |
| 通知、無伺服器 | RDS-EVENT-0374 | 已成功繼續資料庫執行個體。 | Aurora Serverless v2 資料庫執行個體已繼續。 |
| notification | RDS-EVENT-0385 | 叢集拓撲已更新。 | 資料庫執行個體的資料庫叢集有 DNS 變更。這包括新增或刪除新的資料庫執行個體，或發生容錯移轉時。 |
| 通知、全域資料庫 | RDS-EVENT-0390 | 嘗試封鎖區域 *region\$1id* 中資料庫叢集 *cluster\$1id* 的寫入成功。 | Aurora 開始封鎖儲存體層級的寫入，以準備 Aurora 全域資料庫的轉換或容錯移轉。 |
| 通知、全域資料庫 | RDS-EVENT-0391 | 嘗試封鎖區域 *region\$1id* 中資料庫叢集 *cluster\$1id* 的寫入逾時。 | Aurora 無法封鎖儲存體層級的寫入，以準備 Aurora 全域資料庫的轉換或容錯移轉。轉換或容錯移轉會繼續進行，但您可能需要從原始主要叢集的快照復原最近寫入的資料。 |
| 僅供讀取複本 | RDS-EVENT-0045 | 複寫已停止。 | 當複寫期間發生錯誤時，會顯示此訊息。若要判斷錯誤類型，請參閱[針對 MySQL 僅供讀取複本問題進行疑難排解](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ReadRepl.Troubleshooting.html)。 |
| 僅供讀取複本 | RDS-EVENT-0046 | 僅供讀取複本已恢復複寫。 | 此訊息會在您首次建立僅供讀取複本時出現，或做為確認複寫正常運作的監控訊息顯示。如果此訊息出現在 `RDS-EVENT-0045` 通知之後，則在錯誤或複寫停止之後已恢復複寫。 |
| 僅供讀取複本 | RDS-EVENT-0057 | 已終止複寫串流。 | 無 |
| 復原 | RDS-EVENT-0020 | 資料庫執行個體的復原已啟動。復原時間依據恢復的資料量而有不同。 | 無 |
| 復原 | RDS-EVENT-0021 | 資料庫執行個體的復原已完成。 | 無 |
| 復原 | RDS-EVENT-0023 | 緊急快照請求：*message*。 | 已請求手動備份，但 Amazon RDS 目前正在建立資料庫快照。請在 Amazon RDS 完成資料庫快照後，再次提交請求。 |
| 復原 | RDS-EVENT-0052 | 多可用區域執行個體復原已啟動。 | 復原時間依據恢復的資料量而有不同。 |
| 復原 | RDS-EVENT-0053 | 多可用區域執行個體復原已完成。擱置容錯移轉或啟動。 | 此訊息表示 Amazon RDS 已備妥您的資料庫執行個體，以在必要時啟動次要執行個體的容錯移轉。 |
| 復原 | RDS-EVENT-0361 | 待命資料庫執行個體的復原已啟動。 | 待命資料庫執行個體會在復原程序期間重建。資料庫效能會在復原程序期間受到影響。 |
| 復原 | RDS-EVENT-0362 | 待命資料庫執行個體的復原已完成。 | 待命資料庫執行個體會在復原程序期間重建。資料庫效能會在復原程序期間受到影響。 |
| 還原 | RDS-EVENT-0019 | 已從資料庫執行個體 *name* 還原至 *name*。 | 資料庫執行個體已從時間點備份還原。 |
| 安全性修補程式 | RDS-EVENT-0230 | 系統更新適用於您的資料庫執行個體。如需套用更新的相關資訊，請參閱《RDS 使用者指南》中的「維護資料庫執行個體」。 | 新的次要版本作業系統修補程式適用於您的資料庫執行個體。如需套用更新的相關資訊，請參閱 [Aurora 資料庫叢集的作業系統更新](USER_UpgradeDBInstance.Maintenance.md#Aurora_OS_updates)。 |
| 維護 | RDS-EVENT-0425 | Amazon RDS 無法執行作業系統升級，因為指定的子網路中沒有可用的 IP 地址。選擇具有可用 IP 地址的子網路，然後再試一次。 | 無 |
| 維護 | RDS-EVENT-0429 | 由於*區域*可用區域中*類型*執行個體類型的可用容量不足，Amazon RDS 無法執行作業系統升級 | 無 |
| 維護 | RDS-EVENT-0501 | Amazon RDS 資料庫執行個體的伺服器憑證需要輪換待定的維護動作。 | 資料庫執行個體的伺服器憑證需要輪換待定的維護動作。Amazon RDS 會在此維護期間重新啟動資料庫，以完成憑證輪換。若要排程此維護，請前往**維護與備份**索引標籤，然後選擇**立即套用**或**排程下一個維護時段**。如果未排定變更，Amazon RDS 會在您的維護動作中顯示的自動套用日期，自動將其套用至您的維護時段。 |
| 維護 | RDS-EVENT-0502 | Amazon RDS 已在下一個維護時段排定資料庫執行個體的伺服器憑證輪換。此維護需要重新啟動資料庫。 | 無 |
## 資料庫參數群組事件
下表顯示當資料庫參數群組為來源類型時的事件類別和事件清單。
| 類別 | RDS 事件 ID | 訊息 | 備註 |
| --- | --- | --- | --- |
| 組態變更 | RDS-EVENT-0037 | 已將參數 *name* 更新為 *value*，套用方法為 *method*。 | 無 |
## 資料庫安全群組事件
下表顯示當資料庫安全群組為來源類型時的事件類別和事件清單。
**注意**
資料庫安全群組是 EC2-Classic 的資源。EC2-Classic 在 2022 年 8 月 15 日淘汰。如果您還沒有從 EC2-Classic 遷移至 VPC，建議您盡快這麼做。如需詳細資訊，請參閱《Amazon EC2 使用者指南》**中的[從 EC2-Classic 遷移至 VPC](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/vpc-migrate.html)，以及部落格文章 [EC2-Classic Networking is Retiring – Here’s How to Prepare ](https://aws.amazon.com/blogs/aws/ec2-classic-is-retiring-heres-how-to-prepare/)。
| Category | RDS 事件 ID | 訊息 | 備註 |
| --- | --- | --- | --- |
| 組態變更 | RDS-EVENT-0038 | 已將變更套用至安全群組。 | 無 |
| 失敗 | RDS-EVENT-0039 | 正以 *user* 身分撤銷授權。 | 由 *user* 擁有的安全群組不存在。已撤銷安全群組的授權，因為它無效。 |
## 資料庫碎片群組事件
下表顯示當資料庫碎片群組為來源類型時的事件類別和事件清單。
| Category | RDS 事件 ID | 訊息 | 備註 |
| --- | --- | --- | --- |
| 失敗 | RDS-EVENT-0324 | 資料載入任務失敗。 | 由於錯誤訊息中出現的原因，資料載入任務失敗。 |
| 維護 | RDS-EVENT-0302 | 需要您的動作才能完成資料庫碎片群組*名稱*中子叢集 ID *號碼*的待定分割碎片任務 *job\$1ID*。 若要完成操作調用 SQL： SELECT rds_aurora.limitless_finalize_split_shard(job_ID);
| 無 |
| 維護 | RDS-EVENT-0303 | 針對資料庫碎片群組*名稱*中的子叢集 ID *號碼*，已開始完成分割碎片任務 *job\$1ID*。 | 無 |
| 維護 | RDS-EVENT-0304 | 資料庫碎片群組*名稱*中子叢集 ID *號碼*的分割碎片任務 *job\$1ID* 已成功完成。具有子叢集 ID *號碼*的新碎片已新增至資料庫碎片群組*名稱*。 | 無 |
| 維護 | RDS-EVENT-0305 | 資料庫碎片群組*名稱*中子叢集 ID *號碼*的分割碎片任務 *job\$1ID* 已失敗。 | 無 |
| 維護 | RDS-EVENT-0366 | 資料庫碎片群組*名稱*中子叢集 ID *號碼*的分割碎片任務 *job\$1ID* 已開始。 | 無 |
| 維護 | RDS-EVENT-0367 | 在資料庫碎片群組*名稱*中新增路由器任務 *job\$1ID* 已啟動。 | 無 |
| 維護 | RDS-EVENT-0368 | 新增路由器任務 *job\$1ID* 已成功完成。具有子叢集 ID *號碼*的新路由器已新增至資料庫碎片群組*名稱*。 | 無 |
| 維護 | RDS-EVENT-0369 | 在資料庫碎片群組*名稱*中新增路由器任務 *job\$1ID* 已失敗。 | 無 |
| 維護 | RDS-EVENT-0394 | 在資料庫碎片群組*名稱*中新增路由器任務 *job\$1ID* 已取消。 | 無 |
| 維護 | RDS-EVENT-0395 | 在資料庫碎片群組*名稱*中分割碎片任務 *job\$1ID* 已取消。 | 無 |
| notification | RDS-EVENT-0321 | 初始化資料載入任務的基礎設施。 | 無 |
| notification | RDS-EVENT-0322 | 資料載入任務正在進行中。 | 無 |
| notification | RDS-EVENT-0323 | 資料載入任務已成功完成。 | 無 |
| notification | RDS-EVENT-0325 | 根據客戶的請求取消資料載入任務。 | 無 |
| notification | RDS-EVENT-0326 | 資料載入任務已取消。 | 無 |
## RDS Proxy 事件
下表顯示 RDS Proxy 為來源類型時的事件類別和事件清單。
| Category | RDS 事件 ID | 訊息 | 備註 |
| --- | --- | --- | --- |
| 組態變更 | RDS-EVENT-0204 | RDS 已修改資料庫代理 *name*。 | 無 |
| 組態變更 | RDS-EVENT-0207 | RDS 已修改資料庫代理 *name* 的端點。 | 無 |
| 組態變更 | RDS-EVENT-0213 | RDS 偵測到新增了資料庫執行個體，並自動將其新增到資料庫代理 *name* 的目標群組。 | 無 |
| 組態變更 | RDS-EVENT-0214 | RDS 偵測到刪除了資料庫執行個體 *name*，並自動將其從資料庫代理 *name* 的目標群組 *name* 中移除。 | 無 |
| 組態變更 | RDS-EVENT-0215 | RDS 偵測到刪除了資料庫叢集 *name*，並自動將其從資料庫代理 *name* 的目標群組 *name* 中移除。 | 無 |
| 建立 | RDS-EVENT-0203 | RDS 已建立資料庫代理 *name*。 | 無 |
| 建立 | RDS-EVENT-0206 | RDS 已建立資料庫代理 *name* 的端點 *name*。 | 無 |
| 刪除 | RDS-EVENT-0205 | RDS 已刪除資料庫代理 *name*。 | 無 |
| 刪除 | RDS-EVENT-0208 | RDS 已刪除資料庫代理 *name* 的端點 *name*。 | 無 |
| 失敗 | RDS-EVENT-0243 | RDS 無法佈建代理 *name* 的容量，因為您的子網路中沒有足夠的可用 IP 地址：*name*。若要修正此問題，請確定您的子網路具有最低數量的未使用 IP 地址，如 RDS Proxy 文件所建議。 | 若要確定執行個體類別的建議數量，請參閱 [規劃 IP 地址容量](rds-proxy-network-prereqs.md#rds-proxy-network-prereqs.plan-ip-address)。 |
| 失敗 | RDS-EVENT-0275 | RDS 對部分連往資料庫代理*名稱*的連線進行限流。從用戶端到代理的同時連線要求數目已超過限制。 | 無 |
## 藍/綠部署事件
下表顯示當藍/綠部署為來源類型時的事件類別和事件清單。
如需藍/綠部署的詳細資訊，請參閱 [使用 Amazon Aurora 藍/綠部署進行資料庫更新](blue-green-deployments.md)。
| Category | Amazon RDS 事件 ID | 訊息 | 備註 |
| --- | --- | --- | --- |
| 建立 | RDS-EVENT-0244 | 藍/綠部署任務已完成。您可以在部署之後，於綠色環境中對資料庫進行其他修改。 | 無 |
| 失敗 | RDS-EVENT-0245 | 因為*原因*，建立藍/綠部署失敗。 | 無 |
| 刪除 | RDS-EVENT-0246 | 已刪除藍/綠部署。 | 無 |
| notification | RDS-EVENT-0247 | 從 *blue* 至 *green* 的轉換已開始。 | 無 |
| notification | RDS-EVENT-0248 | 已完成藍/綠部署上的切換。 | 無 |
| 失敗 | RDS-EVENT-0249 | 已取消藍/綠部署上的切換。 | 無 |
| notification | RDS-EVENT-0259 | 從資料庫叢集 *blue* 至 *green* 的轉換已開始。 | 無 |
| notification | RDS-EVENT-0260 | 從資料庫叢集 *blue* 至 *green* 的轉換已完成。已將 *blue* 重新命名為 *blue-old*，並將 *green* 重新命名為 *blue*。 | 無 |
| 失敗 | RDS-EVENT-0261 | 由於 *reason*，已取消從資料庫叢集 *blue* 至 *green* 的轉換。 | 無 |
| notification | RDS-EVENT-0311 | 將 資料庫叢集 *blue* 轉換至 *green* 的序列同步已啟動。使用序列時轉換可能會導致停機時間延長。 | 無 |
| notification | RDS-EVENT-0312 | 將 資料庫叢集 *blue* 轉換至 *green* 的序列同步已完成。 | 無 |
| 失敗 | RDS-EVENT-0314 | 由於序列同步失敗，已取消將資料庫叢集 *blue* 轉換至 *green* 的序列同步。 | 無 |
| notification | RDS-EVENT-0409 | *message* | 無 |
# 監控 Amazon Aurora 日誌檔案
每個 RDS 資料庫引擎都會產生日誌，供您存取以進行稽核和疑難排解。日誌檔類型視您的資料庫引擎而定。
您可以使用 AWS 管理主控台、AWS Command Line Interface (AWS CLI) 或 Amazon RDS API 來存取資料庫執行個體的資料庫日誌。您無法檢視、觀看或下載交易日誌。
**注意**
在部分案例中，日誌包含隱藏的資料。因此，AWS 管理主控台 可能顯示出日誌檔案中的內容，但您下載日誌檔案時可能是空的。
**Topics**
+ [檢視並列出資料庫日誌檔案](USER_LogAccess.Procedural.Viewing.md)
+ [下載資料庫日誌檔案](USER_LogAccess.Procedural.Downloading.md)
+ [查看資料庫日誌檔案](USER_LogAccess.Procedural.Watching.md)
+ [將資料庫日誌發佈至 Amazon CloudWatch Logs](USER_LogAccess.Procedural.UploadtoCloudWatch.md)
+ [使用 REST 讀取日誌檔案內容](DownloadCompleteDBLogFile.md)
+ [Aurora MySQL資料庫日誌檔案](USER_LogAccess.Concepts.MySQL.md)
+ [Aurora PostgreSQL 資料庫日誌檔案](USER_LogAccess.Concepts.PostgreSQL.md)
# 檢視並列出資料庫日誌檔案
您可使用 AWS 管理主控台 來檢視 Amazon Aurora DB 引擎的資料庫日誌檔案。您可以使用 AWS CLI 或 Amazon RDS API 來列出可用於下載或監控的記錄檔案。
**注意**
您無法在 RDS 主控台中檢視 Aurora Serverless v1 資料庫叢集的日誌檔。然而，您可以在 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 的 Amazon CloudWatch 主控台進行檢視。
## 主控台
**檢視資料庫日誌檔案**
1. 前往 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)，開啟 Amazon RDS 主控台。
1. 在導覽窗格中，選擇 **Databases** (資料庫)。
1. 選擇您想檢視的日誌檔案所在的資料庫執行個體的名稱。
1. 選擇 **Logs & events (日誌與事件)** 標籤。
1. 向下捲動至 **Logs (日誌)** 區段。
1. (選用) 輸入搜尋詞來篩選結果。
下列範例列出由文字 **error** 篩選的日誌。
![\[列出資料庫日誌\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/images/ListEventsAMS.png)
1. 選擇您想要檢視的日誌，然後選擇 **View (檢視)**。
## AWS CLI
若要檢視資料庫執行個體的可用執行個體日誌檔案，請使用 AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-log-files.html](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-log-files.html) 命令。
下列範例會回傳名為 `my-db-instance` 的資料庫執行個體之日誌檔案列表。
**Example**
```
1. aws rds describe-db-log-files --db-instance-identifier my-db-instance
```
## RDS API
若要列出資料庫執行個體的可用資料庫日誌檔案，請使用 Amazon RDS API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBLogFiles.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBLogFiles.html) 動作。
# 下載資料庫日誌檔案
您可以使用 AWS 管理主控台、AWS CLI 或 API 來下載資料庫日誌檔案。
## 主控台
**下載資料庫日誌檔案**
1. 前往 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)，開啟 Amazon RDS 主控台。
1. 在導覽窗格中，選擇 **Databases** (資料庫)。
1. 選擇您想檢視的日誌檔案所在的資料庫執行個體的名稱。
1. 選擇 **Logs & events (日誌與事件)** 標籤。
1. 向下捲動至 **Logs (日誌)** 區段。
1. 在 **Logs (日誌)** 區段中，選擇您想要下載的日誌旁的按鈕，然後選擇 **Download (下載)**。
1. 開啟提供之連結的內容 (右鍵) 功能表，然後選擇 **Save Link As** (另存連結為)。輸入您要儲存日誌檔案的位置，然後選擇 **Save (儲存)**。
![\[檢視日誌檔案\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/images/log_download2.png)
## AWS CLI
若要下載資料庫日誌檔案，請使用 AWS CLI 命令 [https://docs.aws.amazon.com/cli/latest/reference/rds/download-db-log-file-portion.html](https://docs.aws.amazon.com/cli/latest/reference/rds/download-db-log-file-portion.html)。在預設情況下，這個命令只會下載日誌檔案的最新部分。不過，您可以指定參數 `--starting-token 0` 來下載整個檔案。
下列範例顯示下載名為 *log/ERROR.4* 之日誌檔案的完整內容方法，並將該檔案儲存於名為 *errorlog.txt* 的本機檔案中。
**Example**
對於 Linux、macOS 或 Unix：
```
1. aws rds download-db-log-file-portion \
2. --db-instance-identifier myexampledb \
3. --starting-token 0 --output text \
4. --log-file-name log/ERROR.4 > errorlog.txt
```
在 Windows 中：
```
1. aws rds download-db-log-file-portion ^
2. --db-instance-identifier myexampledb ^
3. --starting-token 0 --output text ^
4. --log-file-name log/ERROR.4 > errorlog.txt
```
## RDS API
若要下載資料庫日誌檔案，請使用 Amazon RDS API [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DownloadDBLogFilePortion.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DownloadDBLogFilePortion.html) 動作。
# 查看資料庫日誌檔案
監視資料庫日誌檔等同於在 UNIX 或 Linux 系統上追蹤檔案。您可以使用 AWS 管理主控台 來觀看日誌檔。RDS 每 5 秒會重新整理日誌的結尾。
**查看資料庫日誌檔案**
1. 前往 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)，開啟 Amazon RDS 主控台。
1. 在導覽窗格中，選擇 **Databases** (資料庫)。
1. 選擇您想檢視的日誌檔案所在的資料庫執行個體的名稱。
1. 選擇 **Logs & events (日誌與事件)** 標籤。
![\[選擇 Logs & events (日誌與事件) 標籤\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/images/Monitoring_logsEvents.png)
1. 在 **Logs (日誌)** 區段中，選擇日誌檔案，然後選擇 **Watch (監看)**。
![\[選擇日誌\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/images/Monitoring_LogsEvents_watch.png)
RDS 會顯示日誌檔的尾端，如下列 MySQL 範例所示。
![\[日誌檔的尾部\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/images/Monitoring_LogsEvents_watch_content.png)
# 將資料庫日誌發佈至 Amazon CloudWatch Logs
在內部部署資料庫中，資料庫日誌位於檔案系統上。Amazon RDS 不提供對資料庫叢集的檔案系統上資料庫日誌的主機存取。因此，Amazon RDS 可讓您將資料庫日誌匯出至 [Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html)。您可以使用 CloudWatch Logs，執行日誌資料的即時分析。您也可以將資料存放在高耐久的儲存體中，並使用 CloudWatch Logs 代理程式來管理資料。
**Topics**
+ [RDS 與 CloudWatch Logs 整合概觀](#rds-integration-cw-logs)
+ [決定要發佈到 CloudWatch Logs 的日誌](#engine-specific-logs)
+ [指定要發佈到 CloudWatch Logs 的日誌](#integrating_cloudwatchlogs.configure)
+ [在 CloudWatch Logs 中搜尋和篩選您的日誌](#accessing-logs-in-cloudwatch)
## RDS 與 CloudWatch Logs 整合概觀
在 CloudWatch Logs *日誌串流*是一系列共用相同來源的日誌事件。CloudWatch Logs 中的每個單獨日誌來源組成單獨的日誌串流。*日誌群組*是共用相同保留、監控和存取控制設定的日誌串流群組。
Amazon Aurora 持續將您的資料庫叢集日誌串流至日誌群組。例如，您所發佈每種類型的日誌都有一個日誌群組 `/aws/rds/cluster/cluster_name/log_type`。此日誌群組與產生日誌的資料庫執行個體位於相同的 AWS 區域中。
AWS 會長期保留發佈至 CloudWatch Logs 的日誌資料，除非您指定保留期間。如需詳細資訊，請參閱[更改在 CloudWatch Logs 中的日誌資料保留期](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention)。
## 決定要發佈到 CloudWatch Logs 的日誌
每個 RDS 資料庫引擎都支援自己的日誌集。若要瞭解資料庫引擎適用的選項，請檢閱下列主題：
+ [將 Amazon Aurora MySQL 日誌發佈至 Amazon CloudWatch Logs](AuroraMySQL.Integrating.CloudWatch.md)
+ [將 Aurora PostgreSQL 日誌發佈至 Amazon CloudWatch Logs](AuroraPostgreSQL.CloudWatch.md)
## 指定要發佈到 CloudWatch Logs 的日誌
您可以指定要在主控台中發佈的日誌。確定您在 AWS Identity and Access Management (IAM) 中有服務連結角色。如需服務連結角色的詳細資訊，請參閱[使用 Amazon Aurora 的服務連結角色](UsingWithRDS.IAM.ServiceLinkedRoles.md)。
**若要指定要發佈的日誌**
1. 前往 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)，開啟 Amazon RDS 主控台。
1. 在導覽窗格中，選擇 **Databases** (資料庫)。
1. 執行下列任何一項：
+ 選擇**建立資料庫**。
+ 從清單中，選擇您的資料庫，然後選擇 **Modify** (修改)。
1. 在 **Logs exports** (日誌匯出) 中，選擇要發佈的日誌。
下列範例指定稽核日誌、錯誤日誌、一般日誌、執行個體日誌、IAM 資料庫身分驗證錯誤日誌，以及 Aurora MySQL 資料庫叢集的慢速查詢日誌。
## 在 CloudWatch Logs 中搜尋和篩選您的日誌
您可以使用 CloudWatch Logs 主控台搜尋與指定條件相符的日誌項目。您可以透過導向 CloudWatch Logs 主控台的 RDS 主控台存取日誌，或從 CloudWatch Logs 主控台直接存取。
**若要使用 RDS 主控台搜尋 RDS 日誌**
1. 前往 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)，開啟 Amazon RDS 主控台。
1. 在導覽窗格中，選擇 **Databases** (資料庫)。
1. 選擇一個資料庫叢集或資料庫執行個體。
1. 選擇 **Configuration (組態)**。
1. 在 **Published logs** (發佈日誌) 下方，選擇您要檢視的資料庫日誌。
**使用 CloudWatch Logs 主控台搜尋 RDS 日誌**
1. 透過 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 開啟 CloudWatch 主控台。
1. 在導覽窗格中，選擇 **Log groups** (日誌群組)。
1. 在篩選方塊中，輸入 **/aws/rds**。
1. 針對 **Log Groups** (日誌群組)，輸入包含要搜尋之日誌串流的日誌群組名稱。
1. 對於 **Log Streams** (日誌串流)，選擇要搜尋的日誌串流名稱。
1. 在 **Log events (日誌事件)** 下方，輸入要使用的篩選條件語法。
如需詳細資訊，請參閱《*Amazon CloudWatch Logs 使用者指南*》中的[搜尋和篩選日誌資料](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/MonitoringLogData.html)。如需說明如何監控 RDS 日誌的教學課程，請參閱[使用 Amazon CloudWatch Logs、AWS Lambda 和 Amazon SNS 為 Amazon RDS 建置主動資料庫監控](https://aws.amazon.com/blogs/database/build-proactive-database-monitoring-for-amazon-rds-with-amazon-cloudwatch-logs-aws-lambda-and-amazon-sns/)。
# 使用 REST 讀取日誌檔案內容
Amazon RDS 提供允許存取資料庫執行個體日誌檔案的 REST 端點。若您需要編寫應用程式來串流 Amazon RDS 日誌檔案內容，此操作非常有幫助。
語法是：
```
GET /v13/downloadCompleteLogFile/DBInstanceIdentifier/LogFileName HTTP/1.1
Content-type: application/json
host: rds.region.amazonaws.com
```
下列是必要參數：
+ `DBInstanceIdentifier` — 含有您想要下載之日誌檔案的資料庫執行個體名稱。
+ `LogFileName` — 要下載的日誌檔案名稱。
回應包括要求之日誌檔案的內容，做為串流形式。
下列範例下載名為 *log/ERROR.6* 的日誌檔案供名為 *sample-sql* 的資料庫執行個體使用，位於 *us-west-2* 區域中。
```
GET /v13/downloadCompleteLogFile/sample-sql/log/ERROR.6 HTTP/1.1
host: rds.us-west-2.amazonaws.com
X-Amz-Security-Token: AQoDYXdzEIH//////////wEa0AIXLhngC5zp9CyB1R6abwKrXHVR5efnAVN3XvR7IwqKYalFSn6UyJuEFTft9nObglx4QJ+GXV9cpACkETq=
X-Amz-Date: 20140903T233749Z
X-Amz-Algorithm: AWS4-HMAC-SHA256
X-Amz-Credential: AKIADQKE4SARGYLE/20140903/us-west-2/rds/aws4_request
X-Amz-SignedHeaders: host
X-Amz-Content-SHA256: e3b0c44298fc1c229afbf4c8996fb92427ae41e4649b934de495991b7852b855
X-Amz-Expires: 86400
X-Amz-Signature: 353a4f14b3f250142d9afc34f9f9948154d46ce7d4ec091d0cdabbcf8b40c558
```
若您指定不存在的資料庫執行個體，回應會包含下列錯誤：
+ `DBInstanceNotFound` —`DBInstanceIdentifier` 不代表現有的資料庫執行個體。(HTTP 狀態碼：404)
# Aurora MySQL資料庫日誌檔案
您可以透過 Amazon RDS 主控台、Amazon RDS API AWS CLI或 AWS SDKs 直接監控 Aurora MySQL 日誌。您可以將日誌指向主要資料庫中的資料庫表並查詢該表格，藉此存取 MySQL 日誌。您可以使用 mysqlbinlog 公用程式來下載二進位日誌。
如需關於檢視、下載與查看資料庫日誌檔案的資訊，請參閱[監控 Amazon Aurora 日誌檔案](USER_LogAccess.md)。
**Topics**
+ [Aurora MySQL 資料庫日誌概觀](USER_LogAccess.MySQL.LogFileSize.md)
+ [將 Aurora MySQL日誌輸出傳送至資料表](Appendix.MySQL.CommonDBATasks.Logs.md)
+ [為單一可用區資料庫設定 Aurora MySQL 二進位記錄](USER_LogAccess.MySQL.BinaryFormat.md)
+ [存取 MySQL 二進位日誌](USER_LogAccess.MySQL.Binarylog.md)
# Aurora MySQL 資料庫日誌概觀
您可以監控下列類型的 Aurora MySQL 日誌檔案：
+ 錯誤日誌
+ 慢查詢日誌
+ 一般日誌
+ 稽核日誌
+ 執行個體日誌
+ IAM 資料庫身分驗證錯誤日誌
預設情況下會產生 Aurora MySQL 錯誤日誌。透過在資料庫參數群組中設定參數，產生慢查詢日誌和一般日誌。
**Topics**
+ [Aurora MySQL 錯誤日誌](#USER_LogAccess.MySQL.Errorlog)
+ [Aurora MySQL 慢查詢與一般查詢](#USER_LogAccess.MySQL.Generallog)
+ [Aurora MySQL 稽核日誌](#ams-audit-log)
+ [Aurora MySQL 執行個體日誌](#ams-instance-log)
+ [Aurora MySQL 的日誌輪換與保留](#USER_LogAccess.AMS.LogFileSize.retention)
+ [將 Aurora MySQL 日誌發佈至 Amazon CloudWatch Logs](#USER_LogAccess.MySQLDB.PublishAuroraMySQLtoCloudWatchLogs)
## Aurora MySQL 錯誤日誌
Aurora MySQL 會將錯誤寫入 `mysql-error.log` 檔案中。每個日誌檔案的產生時間 (UTC 時區) 皆會附加於檔案名稱中。日誌檔案也有時間戳記，可協助您判定日誌項目寫入的時間。
只有在開機、當機以及發生錯誤時，Aurora MySQL 才會寫入錯誤日誌。資料庫執行個體可在未寫入新項目到錯誤日誌的情況下持續執行數小時或數日。若您沒有看到最近的項目，這是因為伺服器未遇到需寫入日誌項目的錯誤。
根據設計，系統會篩選錯誤日誌，以僅顯示未預期的事件，例如錯誤。不過，錯誤日誌還包含一些其他未顯示的資料庫資訊，例如查詢進度。因此即使沒有任何實際錯誤，但錯誤日誌的大小可能會因為在進行的資料庫活動而增加。雖然您可能會在 中看到錯誤日誌的特定位元組或 KB 大小 AWS 管理主控台，但當您下載它們時，它們可能會有 0 個位元組。
Aurora MySQL 每 5 分鐘將 `mysql-error.log` 寫入磁碟一次。這會將日誌的內容追加到 `mysql-error-running.log`。
Aurora MySQL 每小時會輪換 `mysql-error-running.log` 檔案一次。
**注意**
Amazon RDS 和 Aurora 的日誌保留期間不同。
## Aurora MySQL 慢查詢與一般查詢
您可以將 Aurora MySQL 慢查詢日誌與一般日誌寫入至檔案或資料庫表格。若要這樣做，請在您的資料庫參數群組中設定參數。如需建立和修改資料庫參數群組的詳細資訊，請參閱[Amazon Aurora 的參數群組](USER_WorkingWithParamGroups.md)。您必須先設定這些參數，才能在 Amazon RDS 主控台或使用 Amazon RDS API、Amazon RDS CLI 或 AWS SDKs來檢視慢查詢日誌或一般日誌。
您可以使用清單中的參數來控制 Aurora MySQL 日誌記錄：
+ `slow_query_log`：若要建立慢查詢，請設為 1。預設為 0。
+ `general_log`：若要建立一般日誌，請設為 1。預設值為 0。
+ `long_query_time`：若要避免快速執行查詢記錄於慢查詢日誌中，請為需記錄之最短查詢執行時間指定一個值，以秒為單位。預設為 10 秒，最短時間為 0。若 log\$1output = FILE，您可以指定以毫秒解析度為單位的浮點值。若 log\$1output = TABLE，您必須指定以秒為單位的整數值。只會記錄執行時間超過 `long_query_time` 值的查詢。例如，將 `long_query_time` 設為 0.1 可避免記錄任何在 100 毫秒內執行之查詢。
+ `log_queries_not_using_indexes`：若要將所有不使用索引的查詢記錄於慢查詢日誌中，請設為 1。系統會記錄不使用索引的查詢，即使其執行時間低於 `long_query_time` 參數的值。預設值為 0。
+ `log_output option`：您可為 `log_output` 參數指定下列其中一個選項。
+ **TABLE** – 將一般查詢寫入 `mysql.general_log` 表格，而慢查詢則寫入 `mysql.slow_log` 表格。
+ **FILE** – 同時將一般與慢查詢日誌寫入檔案系統中。
+ **NONE** – 停用日誌記錄。
對於 Aurora MySQL 第 2 版和第 3 版，`log_output` 的預設值為 `FILE`。
若要讓慢速查詢資料出現在 Amazon CloudWatch Logs 中，必須符合下列條件：
+ CloudWatch Logs 必須設定為包含慢速查詢日誌。
+ 必須啟用 `slow_query_log`。
+ `log_output` 必須設定為 `FILE`。
+ 查詢必須花費超過為 `long_query_time` 設定的時間。
如需慢查詢與一般日誌的詳細資訊，請參閱 MySQL 文件中的下列主題：
+ [慢查詢日誌](https://dev.mysql.com/doc/refman/8.0/en/slow-query-log.html)
+ [一般查詢日誌](https://dev.mysql.com/doc/refman/8.0/en/query-log.html)
## Aurora MySQL 稽核日誌
Aurora MySQL 的稽核日誌稱為進階稽核。若要開啟進階稽核，請設定某些資料庫叢集參數。如需詳細資訊，請參閱[使用進階稽核與 Amazon Aurora MySQL 資料庫叢集搭配](AuroraMySQL.Auditing.md)。
## Aurora MySQL 執行個體日誌
Aurora 會為已啟用自動暫停的資料庫執行個體建立單獨的日誌檔案。此 instance.log 檔案會記錄這些資料庫執行個體無法如預期暫停的任何原因。如需執行個體日誌檔案行為和 Aurora 自動暫停功能的詳細資訊，請參閱[監控 Aurora Serverless v2 暫停和繼續活動](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless-v2-administration.html#autopause-logging-instance-log)。
## Aurora MySQL 的日誌輪換與保留
日誌記錄功能啟用時，Amazon Aurora 會定期輪換或刪除日誌檔案。此方法為預防措施，可降低大型日誌檔封鎖資料庫使用或影響效能的可能性。Aurora MySQL 會處理輪換與刪除，如下所示：
+ Aurora MySQL 錯誤日誌檔案的大小限制為不能超過資料庫執行個體本機儲存空間的 15%。為保持此閾值，日誌會每小時自動輪換。Aurora MySQL 會在 30 天後或達到磁碟空間的 15% 時移除日誌。若在移除舊日誌檔案後總日誌檔案大小仍超過閾值，將會從最舊的日誌檔案開始刪除，直到日誌檔案大小不再超過閾值為止。
+ Aurora MySQL 會在 24 小時後或在儲存空間使用量達 15% 時，移除稽核、一般和慢查詢日誌。
+ 當 `FILE` 日誌記錄啟用時，每個小時將檢視一般日誌與慢查詢日誌檔一次，而超過 24 小時的日誌檔將會刪除。在部分情況下，刪除後剩餘的總日誌檔案大小可能超過資料庫執行個體本機空間的 15% 閾值。於這些狀況中，最舊的日誌檔將遭刪除，直到日誌檔大小不再超過閾值。
+ 當 `TABLE` 日誌已啟用時，不會輪換或刪除日誌資料表。當所有日誌合併後的大小過大時，日誌資料表將被截斷。您可訂閱 `low storage` 事件類別，當應手動輪換或刪除日誌資料表以釋放空間時就會通知您。如需詳細資訊，請參閱[使用 Amazon RDS 事件通知](USER_Events.md)。
您可以呼叫 `mysql.rds_rotate_general_log` 程序來手動輪換 `mysql.general_log` 表格。您可以呼叫 `mysql.slow_log` 程序來輪換 `mysql.rds_rotate_slow_log` 表格。
手動輪換日誌資料表時，目前日誌資料表會複製到備份日誌資料表，並移除目前日誌資料表中的項目。如果備份日誌資料表已存在，則其會在目前日誌資料表複製到備份之前刪除。如有需要，您可以查詢備份日誌資料表。`mysql.general_log` 資料表的備份日誌資料表名為 `mysql.general_log_backup`。`mysql.slow_log` 資料表的備份日誌資料表名為 `mysql.slow_log_backup`。
+ 當檔案大小達到 100 MB 時，會輪換 Aurora MySQL 稽核日誌，並在 24 小時後刪除。
+ Amazon RDS 會輪換大於 10 MB 的 IAM 資料庫身分驗證錯誤日誌檔案。Amazon RDS 會移除超過五天或大於 100 MB 的 IAM 資料庫身分驗證錯誤日誌檔案。
若要使用來自 Amazon RDS 主控台、Amazon RDS API、Amazon RDS CLI 或 AWS SDKs日誌，請將 `log_output` 參數設定為 FILE。如同 Aurora MySQL 錯誤日誌，這些日誌檔案也會每小時輪換。前 24 小時之間產生的日誌檔案將會保留。請注意，Amazon RDS 和 Aurora 的保留期間不同。
## 將 Aurora MySQL 日誌發佈至 Amazon CloudWatch Logs
您可以設定 Aurora MySQL 資料庫叢集，以將日誌資料發佈至 Amazon CloudWatch Logs 中的日誌群組。使用 CloudWatch Logs，您可以執行日誌資料的即時分析，並使用 CloudWatch 來建立警示和檢視指標。您可以使用 CloudWatch Logs 將日誌記錄存放在高耐用性的儲存裝置中。如需詳細資訊，請參閱[將 Amazon Aurora MySQL 日誌發佈至 Amazon CloudWatch Logs](AuroraMySQL.Integrating.CloudWatch.md)。
# 將 Aurora MySQL日誌輸出傳送至資料表
您可以建立資料庫參數群組，並將 `log_output` 伺服器參數設為 `TABLE`，將一般與慢查詢日誌導向資料庫執行個體上的表格。一般查詢會記錄於 `mysql.general_log` 表格，而慢查詢會記錄至 `mysql.slow_log` 表格。您可以查詢表格來存取日誌資訊。啟用此日誌記錄會增加寫入至資料庫的資料總數量，可能造成效能降低。
一般日誌和慢查詢日誌根據預設將會停用。為啟用日誌記錄至表格，您也必須將 `general_log` 與 `slow_query_log` 伺服器參數設為 `1`。
日誌表格將持續擴增，直到重設適用參數為 `0` 時，各日誌記錄活動才會關閉。大量資料通常會隨時間累積，可能會佔用配得之儲存空間的大量比例。Amazon Aurora Amazon RDS 不允許截斷記錄資料表，但是您可以移動其中的內容。輪換表格可將其內容儲存至備份表格，然後建立新的空白日誌表格。您可以透過以下命令列程序來手動輪換日誌表格，命令提示由 `PROMPT>` 表示：
```
PROMPT> CALL mysql.rds_rotate_slow_log;
PROMPT> CALL mysql.rds_rotate_general_log;
```
為完全移除舊資料並重新取得磁碟空間，請連續呼叫兩次適用的程序。
# 為單一可用區資料庫設定 Aurora MySQL 二進位記錄
*二進位日誌*是一組日誌檔案，其中包含對 AuroraMySQL 伺服器執行個體所做資料修正的相關資訊。二進位日誌包含的資訊如下：
+ 描述資料庫變更的事件 (如建立資料表或修改資料列)
+ 有關更新了資料的每個陳述式持續時間的資訊
+ 本應更新資料但未更新的陳述式事件
二進位日誌會記錄複寫過程中傳送的陳述式。某些復原操作也需要這些日誌。如需詳細資訊，請參閱 MySQL 文件中的[二進位日誌](https://dev.mysql.com/doc/refman/8.0/en/binary-log.html)。
二進位日誌只能從主要資料庫執行個體存取，而不能從複本存取。
Amazon Aurora 上的 MySQL 支援 *row-based* (列型)、*statement-based* (陳述式型)，和 *mixed* (混和式) 二進位記錄格式。除非需要特定的 binlog 格式，否則我們建議混合使用。如需各種 Aurora MySQL 二進位日誌格式的詳細資訊，請參閱 MySQL 說明文件中的[二進位記錄格式](https://dev.mysql.com/doc/refman/8.0/en/binary-log-formats.html)。
如果您打算使用複寫，二進位日誌記錄格式很重要，因為這決定資料變更的記錄，而此記錄會記錄在來源中並傳送到複寫目標。如需有關複寫時各種二進位日誌記錄格式的優缺點的資訊，請參閱 MySQL 文件中的[基於陳述式和基於列的複寫的優缺點](https://dev.mysql.com/doc/refman/8.0/en/replication-sbr-rbr.html)。
**重要**
使用 MySQL 8.0.34 時，MySQL 已棄用 `binlog_format` 參數。在較新的 MySQL 版本中，MySQL 計劃移除參數，並僅支援資料列型複寫。因此，我們建議將資料列型記錄用於新的 MySQL 複寫設定。如需詳細資訊，請參閱 MySQL 文件中的 [binlog\$1format](https://dev.mysql.com/doc/refman/8.0/en/replication-options-binary-log.html#sysvar_binlog_format)。
MySQL 8.0 版和 8.4 版接受參數 `binlog_format`。使用此參數時，MySQL 會發出棄用警告。在未來的主要版本中，MySQL 會移除參數 `binlog_format`。
基於陳述式的複寫可能會造成來源資料庫叢集與僅供讀取複本不一致。如需詳細資訊，請參閱 MySQL 文件中的[二進位日誌記錄中安全和不安全陳述式的判定](https://dev.mysql.com/doc/refman/8.0/en/replication-rbr-safe-unsafe.html)。
啟用二進位記錄會增加資料庫叢集的寫入磁碟 I/O 操作次數。您可以使用 ```VolumeWriteIOPs` CloudWatch 指標來監控 IOPS 使用情況。
**設定 MySQL 二進位記錄格式**
1. 前往 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)，開啟 Amazon RDS 主控台。
1. 在導覽窗格中，選擇 **Parameter groups** (參數群組)。
1. 選擇您想要修改的與資料庫叢集相關聯的資料庫叢集參數群組。
您無法修改預設參數群組。如果資料庫叢集使用預設參數群組，請建立新的參數群組，並將它與資料庫叢集建立關聯。
如需參數群組的詳細資訊，請參閱[Amazon Aurora 的參數群組](USER_WorkingWithParamGroups.md)。
1. 在**動作**中選擇**編輯**。
1. 將 `binlog_format` 參數設為您選擇的二進位日誌記錄格式 (`ROW`、`STATEMENT` 或 `MIXED`)。您還可使用值 `OFF`，來關閉二進位記錄。
**注意**
在資料庫叢集參數群組中將 `binlog_format` 設定為 `OFF` 會停用 `log_bin` 工作階段變數。這會停用 Aurora MySQL 資料庫叢集上的二進位記錄，進而在資料庫中將 `binlog_format` 工作階段變數重設為 `ROW` 的預設值。
1. 選擇 **Save changes (儲存變更)** 來儲存對資料庫叢集參數群組的更新。
執行這些步驟後，您必須重新啟動資料庫叢集中的寫入器執行個體，才能套用變更。在 Aurora MySQL 2.09 版和更低版本中，當您將寫入器執行個體重新開機時，資料庫叢集中的所有讀取器執行個體也會重新開機。在 Aurora MySQL 2.10 版及更新版本中，您必須手動將所有讀取器執行個體重新開機。如需詳細資訊，請參閱[重新啟動 Amazon Aurora 資料庫叢集或 Amazon Aurora 資料庫執行個體](USER_RebootCluster.md)。
**重要**
變更資料庫叢集參數群組會影響使用該參數群組的所有資料庫叢集。如果您想要為 AWS 區域中的不同 Aurora MySQL 資料庫叢集指定不同的二進位記錄格式，資料庫叢集必須使用不同的資料庫叢集參數群組。這些參數群組會識別不同的記錄格式。將適當的資料庫叢集參數群組指派給每個資料庫叢集。如需 Aurora MySQL 參數的詳細資訊，請參閱 [Aurora MySQL 組態參數](AuroraMySQL.Reference.ParameterGroups.md)。
# 存取 MySQL 二進位日誌
您可使用 mysqlbinlog 公用程式，從 RDS for MySQL 資料庫執行個體下載或串流二進位日誌。二進位日誌會下載至您的本機電腦，您可於此執行動作，例如使用 mysql 公用程式來重新執行日誌。如需使用 mysqlbinlog 公用程式的詳細資訊，請參閱 MySQL 文件中的[使用 mysqlbinlog 備份二進位日誌檔案](https://dev.mysql.com/doc/refman/8.0/en/mysqlbinlog-backup.html)。
若要在 Amazon RDS 執行個體上執行 mysqlbinlog 公用程式，請使用下列選項：
+ `--read-from-remote-server` - 必要。
+ `--host` – 來自執行個體端點的 DNS 名稱。
+ `--port` – 執行個體使用的連接埠。
+ `--user` – 已授予 `REPLICATION SLAVE` 許可的 MySQL 使用者。
+ `--password` – MySQL 使用者的密碼，或者省略密碼值，讓公用程式提示您密碼。
+ `--raw` – 以二進位格式下載檔案。
+ `--result-file` – 接收列輸出的本機檔案。
+ `--stop-never` – 串流二進位日誌檔。
+ `--verbose` – 當您使用 `ROW` binlog 格式時，請加入此選項，將資料列事件視為虛擬 SQL 陳述式。如需 `--verbose` 選項的詳細資訊，請參閱 MySQL 文件中的 [mysqlbinlog row event display](https://dev.mysql.com/doc/refman/8.0/en/mysqlbinlog-row-events.html)。
+ 指定一個或一個以上的二進位日誌檔案名稱。若要取得可用日誌清單，請使用 SQL 命令 `SHOW BINARY LOGS`。
如需 mysqlbinlog 選項的詳細資訊，請參閱 MySQL 文件中的 [mysqlbinlog — 處理二進位日誌檔案的公用程式](https://dev.mysql.com/doc/refman/8.0/en/mysqlbinlog.html)。
下列範例顯示如何使用 mysqlbinlog 公用程式。
對於 Linux、macOS 或 Unix：
```
mysqlbinlog \
--read-from-remote-server \
--host=MySQLInstance1.cg034hpkmmjt.region.rds.amazonaws.com \
--port=3306 \
--user ReplUser \
--password \
--raw \
--verbose \
--result-file=/tmp/ \
binlog.00098
```
在 Windows 中：
```
mysqlbinlog ^
--read-from-remote-server ^
--host=MySQLInstance1.cg034hpkmmjt.region.rds.amazonaws.com ^
--port=3306 ^
--user ReplUser ^
--password ^
--raw ^
--verbose ^
--result-file=/tmp/ ^
binlog.00098
```
二進位日誌必須在資料庫執行個體上保持可用，mysqlbinlog 公用程式才能存取它們。若要確保其可用性，請使用 [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) 預存程序，並指定有足夠時間供您下載日誌的期間。如果未設定此組態，Amazon RDS 會盡快清除二進位日誌，導致 mysqlbinlog 公用程式擷取的二進位日誌出現差距。
下列範例將保留期間設定為 1 天。
```
call mysql.rds_set_configuration('binlog retention hours', 24);
```
若要顯示目前設定，請使用 [mysql.rds\$1show\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_show_configuration) 預存程序。
```
call mysql.rds_show_configuration;
```
# Aurora PostgreSQL 資料庫日誌檔案
您可以監控以下 Aurora PostgreSQL 日誌檔案類型：
+ PostgreSQL 日誌
+ 執行個體日誌
+ IAM 資料庫身分驗證錯誤日誌
**注意**
若要啟用 IAM 資料庫身分驗證錯誤日誌，您必須先為 Aurora PostgreSQL 資料庫叢集啟用 IAM 資料庫身分驗證。如需啟用 IAM 資料庫身分驗證的詳細資訊，請參閱 [啟用和停用 IAM 資料庫身分驗證](UsingWithRDS.IAMDBAuth.Enabling.md)。
Aurora PostgreSQL 會將資料庫活動記錄到預設的 PostgreSQL 日誌檔。對於內部部署 PostgreSQL 資料庫執行個體，這些訊息會在本機存放於 `log/postgresql.log` 中。對於 Aurora PostgreSQL 資料庫叢集，日誌檔可在 Aurora 叢集上取得。這些日誌也可以透過 存取 AWS 管理主控台，您可以在其中檢視或下載。預設的記錄層級會擷取登入失敗、嚴重的伺服器錯誤、死鎖和查詢失敗。
如需有關如何檢視、下載和監看檔案型資料庫日誌的詳細資訊，請參閱 [監控 Amazon Aurora 日誌檔案](USER_LogAccess.md)。若要進一步了解 PostgreSQL 日誌，請參閱 [Working with Amazon RDS and Aurora PostgreSQL logs: Part 1](https://aws.amazon.com/blogs/database/working-with-rds-and-aurora-postgresql-logs-part-1/) (使用 Amazon RDS 和 Aurora PostgreSQL 日誌：第 1 部分) 以及 [Working with Amazon RDS and Aurora PostgreSQL logs: Part 2](https://aws.amazon.com/blogs/database/working-with-rds-and-aurora-postgresql-logs-part-2/) (使用 Amazon RDS 和 Aurora PostgreSQL 日誌：第 2 部分)。
除了本主題中討論的標準 PostgreSQL 日誌之外，Aurora PostgreSQL 也支援 PostgreSQL 稽核擴充功能 (`pgAudit`)。大多數受管制的產業和政府機構都需要維護對資料所做變更的稽核日誌或稽核線索，以符合法律要求。如需安裝與使用 pgAudit 的資訊，請參閱 [使用 PgAudit 記錄資料庫活動](Appendix.PostgreSQL.CommonDBATasks.pgaudit.md)。
Aurora 會為已啟用自動暫停的資料庫執行個體建立單獨的日誌檔案。此 instance.log 檔案會記錄這些資料庫執行個體無法如預期暫停的任何原因。如需執行個體日誌檔案行為和 Aurora 自動暫停功能的詳細資訊，請參閱[監控 Aurora Serverless v2 暫停和繼續活動](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless-v2-administration.html#autopause-logging-instance-log)。
**Topics**
+ [用於在 Aurora PostgreSQL 中進行記錄的參數](USER_LogAccess.Concepts.PostgreSQL.overview.parameter-groups.md)
+ [開啟 Aurora PostgreSQL 資料庫叢集 的查詢記錄](USER_LogAccess.Concepts.PostgreSQL.Query_Logging.md)
# 用於在 Aurora PostgreSQL 中進行記錄的參數
您可以修改各種參數，為 Aurora PostgreSQL 資料庫叢集自訂記錄行為。在下表中，您可以找到影響日誌檔存放時間、何時輪換日誌，以及是否以 CSV (逗號分隔值) 格式輸出日誌。您也可以找到已傳送至 STDERR 的文字輸出，以及其他設定。若要變更可修改之參數的設定，請將自訂資料庫叢集參數群組用於 Aurora PostgreSQL 資料庫叢集。如需詳細資訊，請參閱 [Amazon Aurora 的參數群組](USER_WorkingWithParamGroups.md)。
| 參數 | 預設 | Description |
| --- | --- | --- |
| log\$1destination | stderr | 設定日誌的輸出格式。預設值是 `stderr`，但您也可以將 `csvlog` 新增至設定來指定逗號分隔值 (CSV)。如需詳細資訊，請參閱[設定日誌目標 (`stderr`、`csvlog`)](#USER_LogAccess.Concepts.PostgreSQL.Log_Format)。 |
| log\$1filename | postgresql.log.%Y-%m-%d-%H%M | 指定日誌檔名稱的模式。除了預設值之外，此參數還支援檔案名稱模式的 `postgresql.log.%Y-%m-%d` 和 `postgresql.log.%Y-%m-%d-%H`。對於 Aurora PostgreSQL 17.4 版和更新版本，您無法修改此參數。 |
| log\$1line\$1prefix | %t:%r:%u@%d:[%p]: | 定義寫入至 `stderr` 的每個日誌行的字首，以記錄時間 (%t)、遠端主機 (%r)、使用者 (%u)、資料庫 (%d) 和程序 ID (%p)。 |
| log\$1rotation\$1age | 60 | 日誌檔會多少分鐘後自動轉換。您可以在 1 到 1440 分鐘的範圍內變更此值。如需詳細資訊，請參閱[設定日誌檔案輪換](#USER_LogAccess.Concepts.PostgreSQL.log_rotation)。 |
| log\$1rotation\$1size | – | 日誌檔自動轉換的大小 (kB)。您可以在 50,000 到 1,000,000 KB 的範圍內變更此值。如需詳細資訊，請參閱 [設定日誌檔案輪換](#USER_LogAccess.Concepts.PostgreSQL.log_rotation)。 |
| rds.log\$1retention\$1period | 4320 | 早於指定分鐘數的 PostgreSQL 日誌將遭到刪除。預設值 4320 分鐘將在 3 天後刪除日誌檔案。如需詳細資訊，請參閱[設定日誌保留期間](#USER_LogAccess.Concepts.PostgreSQL.log_retention_period)。 |
如要識別應用程式問題，您可在日誌中尋找查詢失敗、登入失敗、鎖死和致命的伺服器錯誤。例如，假設您已將舊版應用程式從 Oracle 轉換為 Aurora PostgreSQL，但並非所有查詢都已正確轉換。這些格式不正確的查詢會產生您可在日誌中尋找的錯誤訊息，以協助識別問題。如需記錄查詢的詳細資訊，請參閱 [開啟 Aurora PostgreSQL 資料庫叢集 的查詢記錄](USER_LogAccess.Concepts.PostgreSQL.Query_Logging.md)。
在下列主題中，您可以找到如何設定各種參數的相關資訊，這些參數控制 PostgreSQL 日誌的基本詳細資訊。
**Topics**
+ [設定日誌保留期間](#USER_LogAccess.Concepts.PostgreSQL.log_retention_period)
+ [設定日誌檔案輪換](#USER_LogAccess.Concepts.PostgreSQL.log_rotation)
+ [設定日誌目標 (`stderr`、`csvlog`)](#USER_LogAccess.Concepts.PostgreSQL.Log_Format)
+ [了解 log\$1line\$1prefix 參數](#USER_LogAccess.Concepts.PostgreSQL.Log_Format.log-line-prefix)
## 設定日誌保留期間
`rds.log_retention_period` 參數指定 Aurora PostgreSQL 資料庫叢集保留其日誌檔的時間長度。預設設定為 3 天 (4,320 分鐘)，但您可以將此值設為 1 天 (1,440 分鐘) 至 7 天 (10,080 分鐘)。請確定您的 Aurora PostgreSQL 資料庫叢集具有足夠的儲存空間來保留日誌檔一段時間。
我們建議您定期將日誌發佈至 Amazon CloudWatch Logs 中，如此，您便可在日誌從 Aurora PostgreSQL 資料庫叢集中移除後的很長時間內檢視並分析系統資料。如需詳細資訊，請參閱 [將 Aurora PostgreSQL 日誌發佈至 Amazon CloudWatch Logs](AuroraPostgreSQL.CloudWatch.md)。設定 CloudWatch 發佈之後，Aurora 在日誌發佈至 CloudWatch Logs 之前不會將其刪除。
在資料庫執行個體的儲存體達到臨界值時，Amazon Aurora 會壓縮較舊的 PostgreSQL 記錄。Aurora 會使用 gzip 壓縮公用程式來壓縮檔案。如需詳細資訊，請參閱 [gzip](https://www.gzip.org) 網站。
當資料庫執行個體的儲存體不足且所有可用的日誌皆已壓縮時，您會收到類似如下的警告：
```
Warning: local storage for PostgreSQL log files is critically low for
this Aurora PostgreSQL instance, and could lead to a database outage.
```
若儲存體不足，Aurora 可能會在指定的保留期間結束之前刪除壓縮的 PostgreSQL 日誌。若發生這種狀況，您會看到類似下列內容的訊息：
```
The oldest PostgreSQL log files were deleted due to local storage constraints.
```
## 設定日誌檔案輪換
依預設，Aurora 每小時都會建立新的日誌檔。時間由 `log_rotation_age` 參數控制。此參數的預設值為 60 (分鐘)，但您可以將其設為從 1 分鐘至 24 小時 (1,440 分鐘) 的任何時間。在輪換時，會建立一個新的不同日誌檔案。該檔案的命名是依據 `log_filename` 參數所指定的模式。
日誌檔案也可依其大小進行旋轉，如 `log_rotation_size` 參數中所指定。此參數指定當日誌達到指定大小 (以 KB 為單位) 時應輪換日誌。Aurora PostgreSQL 資料庫叢集的預設 `log_rotation_size` 為 100000 KB，但您可將此值設為 50,000 到 1,000,000 KB 間的任意值。
日誌檔案名稱會以 `log_filename` 參數中指定的檔案名稱模式為基礎。此參數的可用設定如下所示：
+ `postgresql.log.%Y-%m-%d` – 日誌檔名稱的預設格式。在日誌檔的名稱中包含年、月和日期。
+ `postgresql.log.%Y-%m-%d-%H` – 在日誌檔名稱格式中包括小時。
+ `postgresql.log.%Y-%m-%d-%H%M` – 在日誌檔名稱格式中包括小時:分鐘。
如果您將 `log_rotation_age` 參數設為少於 60 分鐘，請將 `log_filename` 參數設為分鐘格式：
如需詳細資訊，請參閱 PostgreSQL 文件中的 [https://www.postgresql.org/docs/current/runtime-config-logging.html#GUC-LOG-ROTATION-AGE](https://www.postgresql.org/docs/current/runtime-config-logging.html#GUC-LOG-ROTATION-AGE) 和 [https://www.postgresql.org/docs/current/runtime-config-logging.html#GUC-LOG-ROTATION-SIZE](https://www.postgresql.org/docs/current/runtime-config-logging.html#GUC-LOG-ROTATION-SIZE)。
## 設定日誌目標 (`stderr`、`csvlog`)
預設情況下，Aurora PostgreSQL 生成標準錯誤 (stderr) 格式的日誌。此格式為 `log_destination` 參數的預設設定。每則訊息都會使用 `log_line_prefix` 參數中指定的模式作為字首。如需詳細資訊，請參閱[了解 log\$1line\$1prefix 參數](#USER_LogAccess.Concepts.PostgreSQL.Log_Format.log-line-prefix)。
Aurora PostgreSQL 也會以 `csvlog` 格式產生日誌檔。將日誌資料當作逗號分隔值 (CSV) 進行分析時，`csvlog` 很有用。例如，假設您使用 `log_fdw` 延伸模組，將日誌作為外部資料表處理。在 `stderr` 日誌檔案上建立的外部資料表包含一個具日誌事件資料的單一欄。透過將 `csvlog` 新增至 `log_destination` 參數，您可以取得 CSV 格式的日誌檔，其中包含外部資料表的多個資料欄的分界。您現在可以更輕鬆地排序和分析日誌。
如果您為此參數指定 `csvlog`，請注意會同時產生 `stderr` 和 `csvlog` 檔案。請務必監控日誌所使用的儲存體，同時考慮 `rds.log_retention_period` 及影響日誌儲存體和更換的其他設定。使用 `stderr` 和 `csvlog` 會使日誌所使用的儲存體空間增加一倍以上。
如果您將 `csvlog` 新增至 `log_destination`，並且想要單獨還原為 `stderr`，則需要重設參數。若要這麼做，請開啟 Amazon RDS 主控台，然後您的執行個體開啟自訂資料庫叢集參數群組。選擇 `log_destination` 參數、選擇 **Edit parameter** (編輯參數]，然後選擇 **Reset** (重設)。
如需有關設定日誌記錄的詳細資訊，請參閱[使用 Amazon RDS 和 Aurora PostgreSQL 日誌：第 1 部分](https://aws.amazon.com/blogs/database/working-with-rds-and-aurora-postgresql-logs-part-1/)。
## 了解 log\$1line\$1prefix 參數
`stderr` 日誌格式會將 `log_line_prefix` 參數指定的詳細資訊作為每個日誌訊息的字首。預設值為：
```
%t:%r:%u@%d:[%p]:t
```
從 Aurora PostgreSQL 第 16 版開始，您也可以選擇：
```
%m:%r:%u@%d:[%p]:%l:%e:%s:%v:%x:%c:%q%a
```
每個傳送至 stderr 的日誌項目都包含根據所選取值的下列資訊：
+ `%t` – 不到毫秒的日誌項目時間
+ `%m` – 毫秒的日誌項目時間
+ `%r` – 遠端主機地址
+ `%u@%d` – 使用者名稱 @ 資料庫名稱
+ `[%p]` – 程序 ID (若可用)
+ `%l` – 每個工作階段的日誌行號
+ `%e` – SQL 錯誤代碼
+ `%s` – 程序開始時間戳記
+ `%v` – 虛擬交易 ID
+ `%x` – 交易 ID
+ `%c` – 工作階段 ID
+ `%q` – 非工作階段結束字元
+ `%a` – 應用程式名稱
# 開啟 Aurora PostgreSQL 資料庫叢集 的查詢記錄
您可以設定下表中列出的一些參數，來收集有關資料庫活動的詳細資訊，包括查詢、等待鎖定的查詢、檢查點，以及許多其他詳細資訊。本主題著重於記錄查詢。
| 參數 | 預設 | Description |
| --- | --- | --- |
| log\$1connections | – | 記錄每個成功連線。若要了解如何使用此參數搭配 `log_disconnections` 來偵測連線流失，請參閱 [使用集區管理 Aurora PostgreSQL 連線流失](AuroraPostgreSQL.BestPractices.connection_pooling.md)。 |
| log\$1disconnections | – | 記錄每個工作階段的結束及其持續時間。若要了解如何使用此參數搭配 `log_connections` 來偵測連線流失，請參閱 [使用集區管理 Aurora PostgreSQL 連線流失](AuroraPostgreSQL.BestPractices.connection_pooling.md)。 |
| log\$1checkpoints | – | 不適用於 Aurora PostgreSQL |
| log\$1lock\$1waits | – | 記錄長鎖定等待。根據預設，不會設定此參數。 |
| log\$1min\$1duration\$1sample | – | (毫秒) 設定執行時間下限，超出此時間就會記錄陳述式樣本。使用 log\$1statement\$1sample\$1rate 參數設定範例大小。 |
| log\$1min\$1duration\$1statement | – | 至少執行指定時間或更長時間的任何 SQL 陳述式都會被記錄下來。根據預設，不會設定此參數。開啟此參數可以協助您尋找未最佳化的查詢。 |
| log\$1statement | – | 設定已記錄的陳述式類型。依預設，不會設定此參數，但您可以將其變更為 `all`、`ddl` 或 `mod`，以指定您要記錄的 SQL 陳述式類型。如果您針對這個參數指定了 `none` 以外的任何值，您也應該採取額外的步驟，以防止在日誌檔中暴露密碼。如需詳細資訊，請參閱[降低使用查詢記錄時密碼暴露的風險降低密碼暴露風險](#USER_LogAccess.Concepts.PostgreSQL.Query_Logging.mitigate-risk)。 |
| log\$1statement\$1sample\$1rate | – | 超過要記錄之 `log_min_duration_sample` 中所指定時間的陳述式百分比，以介於 0.0 與 1.0 之間的浮點值表示。 |
| log\$1statement\$1stats | – | 將累積效能統計資訊寫入至伺服器日誌。 |
## 使用記錄來尋找執行緩慢的查詢
您可以記錄 SQL 陳述式和查詢，以協助尋找執行緩慢的查詢。您可以依照本節所述修改 `log_statement` 和 `log_min_duration` 參數中的設定來開啟此功能。在針對您的 Aurora PostgreSQL 資料庫叢集 開啟查詢記錄之前，您應該注意到日誌檔中可能暴露密碼，以及如何降低風險。如需詳細資訊，請參閱[降低使用查詢記錄時密碼暴露的風險降低密碼暴露風險](#USER_LogAccess.Concepts.PostgreSQL.Query_Logging.mitigate-risk)。
接下來，您可以尋找有關 `log_statement` 和 `log_min_duration` 參數的參考資訊。log\$1statement
此參數指定應該傳送至日誌的 SQL 陳述式類型。預設值為 `none`。如果您將此參數變更為 `all`、`ddl` 或 `mod`，請務必套用建議的動作，以降低在日誌檔中暴露密碼的風險。如需詳細資訊，請參閱[降低使用查詢記錄時密碼暴露的風險降低密碼暴露風險](#USER_LogAccess.Concepts.PostgreSQL.Query_Logging.mitigate-risk)。
**全部**
記錄所有陳述式。此設定是基於偵錯用途而建議的。
**DDL**
記錄所有資料定義語言 (DDL) 陳述式，例如 CREATE、ALTER、DROP 等。
**MOD**
記錄所有 DDL 陳述式和資料操作語言 (DML) 陳述式，例如 INSERT、UPDATE 和 DELETE)，這些陳述式會修改資料。
**無**
不會記錄任何 SQL 陳述式。建議您使用此設定，以避免在日誌中暴露密碼的風險。log\$1min\$1duration\$1statement
至少執行指定時間或更長時間的任何 SQL 陳述式都會被記錄下來。根據預設，不會設定此參數。開啟此參數可以協助您尋找未最佳化的查詢。
**–1–2147483647**
記錄陳述式之執行時間的毫秒數。
**設定查詢記錄**
這些步驟假設您的 Aurora PostgreSQL 資料庫叢集使用自訂資料庫叢集參數群組。
1. 將 `log_statement` 參數設為 `all`。下列範例顯示使用此參數設定寫入至 `postgresql.log` 檔案的資訊。
```
2022-10-05 22:05:52 UTC:52.95.4.1(11335):postgres@labdb:[3639]:LOG: statement: SELECT feedback, s.sentiment,s.confidence
FROM support,aws_comprehend.detect_sentiment(feedback, 'en') s
ORDER BY s.confidence DESC;
2022-10-05 22:05:52 UTC:52.95.4.1(11335):postgres@labdb:[3639]:LOG: QUERY STATISTICS
2022-10-05 22:05:52 UTC:52.95.4.1(11335):postgres@labdb:[3639]:DETAIL: ! system usage stats:
! 0.017355 s user, 0.000000 s system, 0.168593 s elapsed
! [0.025146 s user, 0.000000 s system total]
! 36644 kB max resident size
! 0/8 [0/8] filesystem blocks in/out
! 0/733 [0/1364] page faults/reclaims, 0 [0] swaps
! 0 [0] signals rcvd, 0/0 [0/0] messages rcvd/sent
! 19/0 [27/0] voluntary/involuntary context switches
2022-10-05 22:05:52 UTC:52.95.4.1(11335):postgres@labdb:[3639]:STATEMENT: SELECT feedback, s.sentiment,s.confidence
FROM support,aws_comprehend.detect_sentiment(feedback, 'en') s
ORDER BY s.confidence DESC;
2022-10-05 22:05:56 UTC:52.95.4.1(11335):postgres@labdb:[3639]:ERROR: syntax error at or near "ORDER" at character 1
2022-10-05 22:05:56 UTC:52.95.4.1(11335):postgres@labdb:[3639]:STATEMENT: ORDER BY s.confidence DESC;
----------------------- END OF LOG ----------------------
```
1. 設定 `log_min_duration_statement` 參數。下列範例說明此參數設定為 `postgresql.log` 時寫入至 `1` 檔案的資訊：
系統會記錄超過 `log_min_duration_statement` 參數中所指定持續時間的查詢。下列顯示一個範例。您可以在 Amazon RDS 主控台中檢視 Aurora PostgreSQL 資料庫叢集的日誌檔。
```
2022-10-05 19:05:19 UTC:52.95.4.1(6461):postgres@labdb:[6144]:LOG: statement: DROP table comments;
2022-10-05 19:05:19 UTC:52.95.4.1(6461):postgres@labdb:[6144]:LOG: duration: 167.754 ms
2022-10-05 19:08:07 UTC::@:[355]:LOG: checkpoint starting: time
2022-10-05 19:08:08 UTC::@:[355]:LOG: checkpoint complete: wrote 11 buffers (0.0%); 0 WAL file(s) added, 0 removed, 0 recycled; write=1.013 s, sync=0.006 s, total=1.033 s; sync files=8, longest=0.004 s, average=0.001 s; distance=131028 kB, estimate=131028 kB
----------------------- END OF LOG ----------------------
```
### 降低使用查詢記錄時密碼暴露的風險
建議您保持 `log_statement` 設定為 `none` 以避免密碼暴露。如果您將 `log_statement` 設定為 `all`、`ddl` 或 `mod`，建議您採取下列一或多個步驟。
+ 對於用戶端，請加密敏感資訊。如需的詳細資訊，請參閱 PostgreSQL 文件中的[加密選項](https://www.postgresql.org/docs/current/encryption-options.html)。使用 `CREATE` 和 `ALTER` 陳述式的 `ENCRYPTED` (和 `UNENCRYPTED`) 選項。如需詳細資訊，請參閱 PostgreSQL 文件中的 [CREATE USER](https://www.postgresql.org/docs/current/sql-createuser.html)。
+ 對於您的 Aurora 資料庫叢集，請設定並使用 PostgreSQL 稽核 (pgAudit) 擴充功能。此擴充功能會刪減傳送至日誌的 CREATE 和 ALTER 陳述式中的敏感資訊。如需詳細資訊，請參閱[使用 PgAudit 記錄資料庫活動](Appendix.PostgreSQL.CommonDBATasks.pgaudit.md)。
+ 限制對 CloudWatch 日誌的存取。
+ 使用更強大的身分驗證機制，例如 IAM。
# 在 AWS CloudTrail 中監控 Amazon Aurora API 呼叫
AWS CloudTrail 是一項可協助您稽核 AWS 帳戶的 AWS 服務。AWS CloudTrail 會在您建立 AWS 帳戶時開啟。如需有關 CloudTrail 的相關資訊，請參閱 [AWS CloudTrail 使用者指南](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/)。
**Topics**
+ [CloudTrail 與 Amazon Aurora 整合](#service-name-info-in-cloudtrail)
+ [Amazon Aurora 日誌檔案項目](#understanding-service-name-entries)
## CloudTrail 與 Amazon Aurora 整合
CloudTrail 會記錄所有 Amazon Aurora 動作。對於使用者、角色或 AWS 服務在 Amazon Aurora 中採取的動作，CloudTrail 會提供記錄。
### CloudTrail 事件
CloudTrail 會擷取 Amazon Aurora 的 API 呼叫當作事件。一個事件為任何來源提出的單一請求，並包含請求動作、請求的日期和時間、請求參數等資訊。事件包括從 Amazon RDS 主控台的呼叫，以及對 Amazon RDS API 操作的程式碼呼叫。
Amazon Aurora 活動會記錄在 **Event history** (事件歷史記錄) 的 CloudTrail 事件中。您可以使用 CloudTrail 主控台檢視 AWS 區域中過去 90 天所記錄的 API 活動和事件。如需詳細資訊，請參閱[使用 CloudTrail 事件歷程記錄檢視事件](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html)。
### CloudTrail 線索
如需 AWS 帳戶中正在記錄事件 (包括 Amazon Aurora 的事件)，請建立 trail (追蹤)。權杖是一種組態，能讓事件交付到指定的 Amazon S3 儲存貯體。CloudTrail 通常會在帳戶活動的 15 分鐘內交付日誌檔案。
**注意**
即使您未設定權仗，依然可以透過 CloudTrail 主控台中的 **Event history** (事件歷史記錄) 檢視最新事件。
您可以為 AWS 帳戶建立兩種類型的追蹤：套用至所有區域的追蹤，或套用至一個區域的追蹤。根據預設，當您在主控台建立線索時，線索會套用到所有 區域。
此外，您可以設定其他 AWS 服務，以進一步分析和處理 CloudTrail 日誌中所收集的事件資料。如需詳細資訊，請參閱：
+ [建立追蹤的概觀](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [CloudTrail 支援的服務和整合](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations)
+ [設定 CloudTrail 的 Amazon SNS 通知](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html)
+ [接收多個區域的 CloudTrail 日誌檔案](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html)及[接收多個帳戶的 CloudTrail 日誌檔案](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html)
## Amazon Aurora 日誌檔案項目
CloudTrail 日誌檔案包含一或多個日誌專案。CloudTrail 日誌檔案並非依公有 API 呼叫追蹤記錄的堆疊排序，因此不會以任何特定順序出現。
以下範例顯示的是展示 `CreateDBInstance` 動作的 CloudTrail 日誌項目。
```
{
"eventVersion": "1.04",
"userIdentity": {
"type": "IAMUser",
"principalId": "AKIAIOSFODNN7EXAMPLE",
"arn": "arn:aws:iam::123456789012:user/johndoe",
"accountId": "123456789012",
"accessKeyId": "AKIAI44QH8DHBEXAMPLE",
"userName": "johndoe"
},
"eventTime": "2018-07-30T22:14:06Z",
"eventSource": "rds.amazonaws.com",
"eventName": "CreateDBInstance",
"awsRegion": "us-east-1",
"sourceIPAddress": "192.0.2.0",
"userAgent": "aws-cli/1.15.42 Python/3.6.1 Darwin/17.7.0 botocore/1.10.42",
"requestParameters": {
"enableCloudwatchLogsExports": [
"audit",
"error",
"general",
"slowquery"
],
"dBInstanceIdentifier": "test-instance",
"engine": "mysql",
"masterUsername": "myawsuser",
"allocatedStorage": 20,
"dBInstanceClass": "db.m1.small",
"masterUserPassword": "****"
},
"responseElements": {
"dBInstanceArn": "arn:aws:rds:us-east-1:123456789012:db:test-instance",
"storageEncrypted": false,
"preferredBackupWindow": "10:27-10:57",
"preferredMaintenanceWindow": "sat:05:47-sat:06:17",
"backupRetentionPeriod": 1,
"allocatedStorage": 20,
"storageType": "standard",
"engineVersion": "8.0.28",
"dbInstancePort": 0,
"optionGroupMemberships": [
{
"status": "in-sync",
"optionGroupName": "default:mysql-8-0"
}
],
"dBParameterGroups": [
{
"dBParameterGroupName": "default.mysql8.0",
"parameterApplyStatus": "in-sync"
}
],
"monitoringInterval": 0,
"dBInstanceClass": "db.m1.small",
"readReplicaDBInstanceIdentifiers": [],
"dBSubnetGroup": {
"dBSubnetGroupName": "default",
"dBSubnetGroupDescription": "default",
"subnets": [
{
"subnetAvailabilityZone": {"name": "us-east-1b"},
"subnetIdentifier": "subnet-cbfff283",
"subnetStatus": "Active"
},
{
"subnetAvailabilityZone": {"name": "us-east-1e"},
"subnetIdentifier": "subnet-d7c825e8",
"subnetStatus": "Active"
},
{
"subnetAvailabilityZone": {"name": "us-east-1f"},
"subnetIdentifier": "subnet-6746046b",
"subnetStatus": "Active"
},
{
"subnetAvailabilityZone": {"name": "us-east-1c"},
"subnetIdentifier": "subnet-bac383e0",
"subnetStatus": "Active"
},
{
"subnetAvailabilityZone": {"name": "us-east-1d"},
"subnetIdentifier": "subnet-42599426",
"subnetStatus": "Active"
},
{
"subnetAvailabilityZone": {"name": "us-east-1a"},
"subnetIdentifier": "subnet-da327bf6",
"subnetStatus": "Active"
}
],
"vpcId": "vpc-136a4c6a",
"subnetGroupStatus": "Complete"
},
"masterUsername": "myawsuser",
"multiAZ": false,
"autoMinorVersionUpgrade": true,
"engine": "mysql",
"cACertificateIdentifier": "rds-ca-2015",
"dbiResourceId": "db-ETDZIIXHEWY5N7GXVC4SH7H5IA",
"dBSecurityGroups": [],
"pendingModifiedValues": {
"masterUserPassword": "****",
"pendingCloudwatchLogsExports": {
"logTypesToEnable": [
"audit",
"error",
"general",
"slowquery"
]
}
},
"dBInstanceStatus": "creating",
"publiclyAccessible": true,
"domainMemberships": [],
"copyTagsToSnapshot": false,
"dBInstanceIdentifier": "test-instance",
"licenseModel": "general-public-license",
"iAMDatabaseAuthenticationEnabled": false,
"performanceInsightsEnabled": false,
"vpcSecurityGroups": [
{
"status": "active",
"vpcSecurityGroupId": "sg-f839b688"
}
]
},
"requestID": "daf2e3f5-96a3-4df7-a026-863f96db793e",
"eventID": "797163d3-5726-441d-80a7-6eeb7464acd4",
"eventType": "AwsApiCall",
"recipientAccountId": "123456789012"
}
```
如上述範例中的 `userIdentity` 元素所示，每個事件或記錄項目都包含產生要求者的相關資訊。身分資訊可協助您判斷下列事項：
+ 該請求是否使用根或 IAM 使用者憑證提出。
+ 提出該請求時，是否使用了特定角色或聯合身分使用者的暫時安全憑證。
+ 該請求是否由另一項 AWS 服務提出。
如需 `userIdentity` 的詳細資訊，請參閱 [CloudTrail userIdentity 元素](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html)。如需有關 `CreateDBInstance` 和其他 Amazon Aurora 動作的詳細資訊，請參閱《[Amazon RDS API 參考](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/)》。
# 使用資料庫活動串流來監控 Amazon Aurora
透過使用資料庫活動串流，您就可以監控資料庫活動的近乎即時的串流。
**Topics**
+ [資料庫活動串流概觀](#DBActivityStreams.Overview)
+ [Aurora MySQL 資料庫活動串流的聯網先決條件](DBActivityStreams.Prereqs.md)
+ [開始資料庫活動串流](DBActivityStreams.Enabling.md)
+ [取得資料庫活動串流的狀態](DBActivityStreams.Status.md)
+ [停用資料庫活動串流](DBActivityStreams.Disabling.md)
+ [監控資料庫活動串流](DBActivityStreams.Monitoring.md)
+ [資料庫活動串流的 IAM 政策範例](DBActivityStreams.ManagingAccess.md)
## 資料庫活動串流概觀
作為 Amazon Aurora 資料庫管理員，您需要保護資料庫並遵守合規與法規要求。其中一項策略是整合資料庫活動串流與監控工具。透過此方式，您可以監控 Amazon Aurora 叢集中的稽核活動，並設定警示。
外部和內部都有安全威脅。若要防範內部威脅，您可以設定資料庫活動串流功能來控制管理員對資料串流的存取。 資料庫管理員沒有存取收集、傳輸、儲存和處理串流的權限。
**Contents**
+ [資料庫活動串流運作方式](#DBActivityStreams.Overview.how-they-work)
+ [資料庫活動串流的非同步和同步模式](#DBActivityStreams.Overview.sync-mode)
+ [資料庫活動串流的要求與限制](#DBActivityStreams.Overview.requirements)
+ [區域和版本可用性](#DBActivityStreams.Overview.Availability)
+ [支援資料庫活動串流的資料庫執行個體類別](#DBActivityStreams.Overview.requirements.classes)
### 資料庫活動串流運作方式
於 Amazon Aurora 中，您可在叢集層級啟動資料庫活動串流。叢集中的所有資料庫執行個體皆啟用了資料庫活動串流。
您的 Aurora 資料庫叢集 會近乎即時地將活動推送至 Amazon Kinesis 資料串流。系統會自動建立 Kinesis 串流。從 Kinesis，您可以設定 Amazon Data Firehose 和 等 AWS 服務 AWS Lambda ，以取用串流並存放資料。
**重要**
在 Amazon Aurora 中使用資料庫活動串流功能是一項免費功能，但 Amazon Kinesis 會收取資料串流費用。如需詳細資訊，請參閱 [Amazon Kinesis Data Streams 定價](https://aws.amazon.com/kinesis/data-streams/pricing/)。
若您使用 Aurora 全域資料庫，請在每個資料庫叢集上分別啟動資料庫活動串流。每個叢集在其自己的 AWS 區域中將稽核資料傳送至其自己的 Kinesis 串流。在容錯移轉期間，活動串流的作業方式不會有所不同。其繼續像往常一樣稽核您的全域資料庫。
您可為合規管理設定應用程式以使用資料庫活動串流。若為 Aurora PostgreSQL，合規應用程式包括 IBM 的 Security Guardium 和 Imperva 的 SecureSphere Database Audit and Protection。這些應用程式可以使用串流來產生警示，並稽核您的 Aurora 資料庫叢集。
下圖展示使用 Amazon Data Firehose 設定的 Aurora 資料庫叢集。
![\[架構圖顯示 Firehose 使用之 Aurora 資料庫叢集的資料庫活動串流\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/images/aurora-das.png)
### 資料庫活動串流的非同步和同步模式
您可以選擇讓資料庫工作階段使用以下任一模式來處理資料庫活動事件：
+ **非同步模式** – 在資料庫工作階段產生活動串流事件時，工作階段會立即傳回正常的活動。系統會在背景中將活動串流事件變成耐久的記錄。如果背景任務中發生錯誤，就會傳送 RDS 事件。此事件會指出活動串流事件記錄可能遺失的任何時段的開頭和結尾。
非同步模式對資料庫效能的幫助較大，對活動串流精準度的幫助較小。
**注意**
非同步模式適用於 Aurora PostgreSQL 和 Aurora MySQL。
+ **同步模式** – 在資料庫工作階段產生活動串流事件時，在該事件變得耐久前工作階段都會封鎖。如果事件因故而無法變得耐久，資料庫工作階段會傳回正常的活動。然而，系統會傳送 RDS 事件，指出活動串流記錄可能已遺失一段時間。在系統回到運作良好的狀態後，就會傳送第二個 RDS 事件。
同步模式對活動串流精準度的幫助較大，對資料庫效能的幫助較小。
**注意**
同步模式可用於 Aurora PostgreSQL。您不能搭配 Aurora MySQL 使用同步模式。
### 資料庫活動串流的要求與限制
在 Aurora 中，資料庫活動串流具有以下要求和限制：
+ 資料庫活動串流需要使用 Amazon Kinesis。
+ AWS Key Management Service 資料庫活動串流需要 (AWS KMS)，因為它們一律會加密。
+ 將其他加密套用至 Amazon Kinesis 資料串流與已使用 AWS KMS 金鑰加密的資料庫活動串流不相容。
+ 在資料庫叢集層級啟動資料庫活動串流。若您將資料庫執行個體新增至叢集，則無需在執行個體上啟動活動串流：其會自動進行稽核。
+ 在 Aurora 全域資料庫中，請確保個別在每個資料庫叢集上啟動活動串流。每個叢集在其自己的 AWS 區域中將稽核資料傳送至其自己的 Kinesis 串流。
+ 在 Aurora PostgreSQL 中，請務必在主要版本升級之前停止資料庫活動串流。升級完成後，您可以啟動資料庫活動串流。
### 區域和版本可用性
功能可用性和支援會因每個 Aurora 資料庫引擎的特定版本以及 AWS 區域而有所不同。如需有關 Aurora 和資料庫活動串流版本和區域可用性的詳細資訊，請參閱 [資料庫活動串流的支援區域和 Aurora 資料庫引擎](Concepts.Aurora_Fea_Regions_DB-eng.Feature.DBActivityStreams.md)。
### 支援資料庫活動串流的資料庫執行個體類別
針對 Aurora MySQL,您可以搭配下列資料庫執行個體類別來使用資料庫活動串流：
+ db.r8g.\$1large
+ db.r7g.\$1large
+ db.r7i.\$1large
+ db.r6g.\$1large
+ db.r6i.\$1large
+ db.r5.\$1large
+ db.x2g.\$1
針對 Aurora PostgreSQL,您可以搭配下列資料庫執行個體類別來使用資料庫活動串流：
+ db.r8g.\$1large
+ db.r7i.\$1large
+ db.r7g.\$1large
+ db.r6g.\$1large
+ db.r6i.\$1large
+ db.r6id.\$1large
+ db.r5.\$1large
+ db.r4.\$1large
+ db.x2g.\$1
# Aurora MySQL 資料庫活動串流的聯網先決條件
在下文中，您可以了解如何設定 Virtual Private Cloud (VPC) 以與資料庫活動串流搭配使用。
**注意**
Aurora MySQL 網路先決條件適用於下列引擎版本：
Aurora MySQL 第 2 版，最高至 2.11.3
Aurora MySQL 第 2.12.0 版
Aurora MySQL 第 3 版，最高至 3.04.2
**Topics**
+ [AWS KMS 端點的先決條件](#DBActivityStreams.Prereqs.KMS)
+ [公開可用性的先決條件](#DBActivityStreams.Prereqs.Public)
+ [私有可用性的先決條件](#DBActivityStreams.Prereqs.Private)
## AWS KMS 端點的先決條件
Aurora MySQL 叢集中使用活動串流的執行個體必須能夠存取 AWS KMS 端點。在啟用 Aurora MySQL 叢集的資料庫活動串流之前，請確定已滿足此需求。如果 Aurora 叢集可公開使用，則會自動滿足此要求。
**重要**
如果 Aurora MySQL 資料庫叢集無法存取 AWS KMS 端點，活動串流便會停止。在這種情況下，Aurora 會使用 RDS 事件通知您有關此問題。
## 公開可用性的先決條件
Aurora 資料庫叢集必須符合下列條件才能公開：
+ AWS 管理主控台叢集詳細資訊頁面中的 **Publicly Accessible** (可公開存取) 為 **Yes** (是)。
+ 資料庫叢集位於 Amazon VPC 公有子網路中。如需可公開存取之資料庫執行個體的詳細資訊，請參閱[在 VPC 中使用資料庫叢集](USER_VPC.WorkingWithRDSInstanceinaVPC.md)。如需有關公有 Amazon VPC 子網路的更多資訊，請參閱[您的 VPC 與子網路](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html)。
## 私有可用性的先決條件
如果您的 Aurora 資料庫叢集位於 VPC 公有子網路中且不可公開存取，則為私有。若要將您的叢集保持為私有狀態，並將其與資料庫活動串流一起使用，您有下列選項：
+ 在 VPC 中設定網路位址轉譯 (NAT)。如需更多詳細資訊，請參閱 [NAT 閘道](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html)。
+ 在 VPC 中建立 AWS KMS 端點。建議使用此選項，因為設定更容易。
**在 VPC 中建立 AWS KMS 端點**
1. 在 [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/) 開啟 Amazon VPC 主控台。
1. 在導覽窗格中選擇 **Endpoints (端點)**。
1. 選擇**建立端點**。
**Create Endpoint** (建立端點) 頁面隨即出現。
1. 請執行下列操作：
+ 在 **Service category** (服務類別) 中，選擇 **AWS services** ( 服務)。
+ 在 **Service Name** (服務名稱) 中，選擇 **com.amazonaws.*region*.kms**，其中 *region* 是叢集所在的 AWS 區域。
+ 在 **VPC** 中，選擇叢集所在的 VPC。
1. 選擇**建立端點**。
如需設定 VPC 端點的詳細資訊，請參閱 [VPC 端點](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html)。
# 開始資料庫活動串流
如要監控您 Aurora 資料庫叢集中所有執行個體的資料庫活動，請在叢集層級開始活動串流。您新增至該叢集的任何資料庫執行個體也會自動受到監控。若您使用 Aurora 全域資料庫，請在每個資料庫叢集上分別啟動資料庫活動串流。每個叢集在其自己的 AWS 區域 中將稽核資料傳送至其自己的 Kinesis 串流。
在開啟的活動串流時，您在稽核政策中設定的每個資料庫活動事件都會產生活動串流事件。`CONNECT` 和 `SELECT` 之類的 SQL 命令會產生存取事件。`CREATE` 和 `INSERT` 之類的 SQL 命令會產生變更事件。
------
#### [ Console ]
**若要開始資料庫活動串流**
1. 前往 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)，開啟 Amazon RDS 主控台。
1. 在導覽窗格中，選擇 **Databases** (資料庫)。
1. 選擇您要在其上啟動活動串流的資料庫叢集 。
1. 針對 **Actions** (動作)，選擇 **Start activity stream** (啟動活動串流)。
**Start database activity stream: ***name* (開始資料庫活動串流：name) 視窗隨即出現，其中 *name* 是您的 資料庫叢集。
1. 輸入以下設定：
+ 對於 **AWS KMS key**，請從 AWS KMS keys清單中選擇一個金鑰。
**注意**
如果您的 Aurora MySQL 叢集無法存取 KMS 金鑰，請依照 [Aurora MySQL 資料庫活動串流的聯網先決條件](DBActivityStreams.Prereqs.md) 中的指示，先啟用此類存取。
Aurora 會使用 KMS 金鑰來加密金鑰，此金鑰會依序加密資料庫活動。請選擇預設金鑰以外的 KMS 金鑰。如需更多有關加密金鑰和 AWS KMS 的資訊，請參閱 *AWS Key Management Service 開發人員指南*中的[什麼是 AWS Key Management Service ?](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)。
+ 對於 **Database activity stream mode (資料庫活動串流模式)**，選擇 **Asynchronous (非同步)** 或 **Synchronous (同步)**。
**注意**
此選項僅適用於 Aurora PostgreSQL。針對 Aurora MySQL，您只能使用非同步模式。
+ 選擇 **Immediately** (立即)。
在您選擇 **Immediately** (立即) 時，資料庫叢集會立即重新啟動。如果您選擇 **During the next maintenance window** (下個維護時段期間)，則資料庫叢集不會立即重新啟動。在這種情況下直到下一個維護時段前，資料庫活動串流都不會啟動。
1. 選擇 **Start database activity stream** (啟動資料庫活動串流)。
資料庫叢集的狀態會顯示活動串流正在開始。
**注意**
如果收到錯誤訊息 `You can't start a database activity stream in this configuration`，請檢查 [支援資料庫活動串流的資料庫執行個體類別](DBActivityStreams.md#DBActivityStreams.Overview.requirements.classes) 以查看 資料庫叢集是否使用支援的執行個體類別。
------
#### [ AWS CLI ]
若要開始資料庫叢集的資料庫活動串流，請使用 [start-activity-stream](https://docs.aws.amazon.com/cli/latest/reference/rds/start-activity-stream.html) AWS CLI 命令來設定資料庫叢集。
+ `--resource-arn arn`– 指定資料庫的 Amazon 資源名稱 (ARN) 叢集。
+ `--mode sync-or-async` – 指定同步 (`sync`) 或非同步 (`async`) 模式。對於 Aurora PostgreSQL，您可以選擇其中一個值。針對 Aurora MySQL，請指定 `async`。
+ `--kms-key-id key` – 指定用於加密資料庫活動串流中訊息的 KMS 金鑰識別碼。AWS KMS 金鑰識別碼是 AWS KMS key的金鑰 ARN、金鑰 ID、別名 ARN 或別名。
下列範例會在非同步模式下開始資料庫叢集的活動串流。
對於 Linux、macOS 或 Unix：
```
aws rds start-activity-stream \
--mode async \
--kms-key-id my-kms-key-arn \
--resource-arn my-cluster-arn \
--apply-immediately
```
在 Windows 中：
```
aws rds start-activity-stream ^
--mode async ^
--kms-key-id my-kms-key-arn ^
--resource-arn my-cluster-arn ^
--apply-immediately
```
------
#### [ Amazon RDS API ]
若要開始資料庫叢集的資料庫活動串流，請使用 [StartActivityStream](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_StartActivityStream.html) 操作來設定叢集。
使用以下參數呼叫動作：
+ `Region`
+ `KmsKeyId`
+ `ResourceArn`
+ `Mode`
------
**注意**
如果您收到錯誤，指出無法使用目前版本的 Aurora PostgreSQL 資料庫啟動資料庫活動串流，請在啟動資料庫活動串流之前套用 Aurora PostgreSQL 的最新修補程式。如需升級 Aurora PostgreSQL 資料庫的詳細資訊，請參閱[升級 Amazon Aurora 資料庫叢集](Aurora.VersionPolicy.Upgrading.md)。
以下是使用 Aurora PostgreSQL 啟動資料庫活動串流的最低修補程式版本。
3.4.15 (11.9.15)、11.21.10
12.9.15、12.15.9、12.16.10、12.17.7、12.18.5、12.19.4、12.20.3、12.22.3
13.9.12、13.11.9、13.12.10、13.13.7、13.14.5、13.15.4、13.16.3、13.18.3
14.6.12、14.8.9、14.9.10、14.10.7、14.11.5、、14.12.4、14.13.3、14.15.3
15.3.9、15.4.10、15.5.7、15.6.5、、15.7.4、15.8.3、、15.10.3
16.1.7、16.2.5、16.3.4、16.4.3、、16.6.3
# 取得資料庫活動串流的狀態
您可以使用主控台或 AWS CLI 來取得 的活動串流狀態。
## 主控台
**取得資料庫活動串流的狀態**
1. 前往 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)，開啟 Amazon RDS 主控台。
1. 在導覽窗格中，選擇 **Databases** (資料庫)，然後選擇 DB cluster (資料庫叢集) (資料庫執行個體) 連結。
1. 選擇 **Configuration (組態)** 標籤，然後確認 **Database activity stream (資料庫活動串流)** 的狀態。
## AWS CLI
您可以取得資料庫叢集的活動串流組態，作為對 [describe-db-clusters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-clusters.html) CLI 請求的回應。
以下範例描述 *my-cluster*。
```
aws rds --region my-region describe-db-clusters --db-cluster-identifier my-cluster
```
JSON 回應如以下範例所示。下列欄位會顯示：
+ `ActivityStreamKinesisStreamName`
+ `ActivityStreamKmsKeyId`
+ `ActivityStreamStatus`
+ `ActivityStreamMode`
+
這些欄位對於 Aurora PostgreSQL 和 Aurora MySQL 是相同的，除非 `ActivityStreamMode` 對於 Aurora MySQL 一律是 `async`，而對於 Aurora PostgreSQL，它可能是 `sync` 或 `async`。
```
{
"DBClusters": [
{
"DBClusterIdentifier": "my-cluster",
...
"ActivityStreamKinesisStreamName": "aws-rds-das-cluster-A6TSYXITZCZXJHIRVFUBZ5LTWY",
"ActivityStreamStatus": "starting",
"ActivityStreamKmsKeyId": "12345678-abcd-efgh-ijkl-bd041f170262",
"ActivityStreamMode": "async",
"DbClusterResourceId": "cluster-ABCD123456"
...
}
]
}
```
## RDS API
您可以取得資料庫叢集的活動串流組態，作為對 [DescribeDBClusters](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBClusters.html) 操作的回應。
# 停用資料庫活動串流
您可以使用主控台或 AWS CLI 來停止活動串流。
若您刪除資料庫叢集 ，則會停止活動串流，並自動刪除底層的 Amazon Kinesis 串流。
## 主控台
**關閉活動串流**
1. 前往 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)，開啟 Amazon RDS 主控台。
1. 在導覽窗格中，選擇 **Databases** (資料庫)。
1. 選擇您要停止資料庫活動串流的資料庫叢集。
1. 針對 **Actions** (動作)，選擇 **Stop activity stream** (停止活動串流)。**Database Activity Stream (資料庫活動串流)** 即會顯示。
1. 選擇 **Immediately** (立即)。
在您選擇 **Immediately** (立即) 時，資料庫叢集會立即重新啟動。如果您選擇 **During the next maintenance window** (下個維護時段期間)，則資料庫叢集 不會立即重新啟動。在此情況下，直到下一個維護時段前，資料庫活動串流都不會被停用。
1. 選擇 **Continue (繼續)**。
## AWS CLI
若要停止您資料庫叢集的資料庫活動串流，請使用 AWS CLI 命令 [stop-activity-stream](https://docs.aws.amazon.com/cli/latest/reference/rds/stop-activity-stream.html) 來設定資料庫叢集。使用 `--region` 參數來識別資料庫叢集的 AWS 區域。`--apply-immediately` 為選用參數。
對於 Linux、macOS 或 Unix：
```
aws rds --region MY_REGION \
stop-activity-stream \
--resource-arn MY_CLUSTER_ARN \
--apply-immediately
```
在 Windows 中：
```
aws rds --region MY_REGION ^
stop-activity-stream ^
--resource-arn MY_CLUSTER_ARN ^
--apply-immediately
```
## RDS API
若要停止您的資料庫叢集的資料庫活動串流，請使用 [StopActivityStream](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_StopActivityStream.html) 操作來設定叢集。使用 `Region` 參數來識別資料庫叢集的 AWS 區域。`ApplyImmediately` 為選用參數。
# 監控資料庫活動串流
資料庫活動串流會監控和報告活動。活動資料串流會收集並傳送至 Amazon Kinesis。從 Kinesis 中，您可以監視活動串流，或者其他服務和應用程式可以使用活動串流以供進一步分析。您可以使用 AWS CLI 命令 `describe-db-clusters` 或 RDS API `DescribeDBClusters` 操作來尋找基礎 Kinesis 串流名稱。
Aurora 會為您管理 Kinesis 串流，如下所示：
+ Aurora 會自動建立保留時間為 24 小時的 Kinesis 串流。
+ 如有必要，Aurora 可擴展 Kinesis 串流。
+ 如果您停止資料庫活動串流或刪除資料庫叢集，則 Aurora 會刪除 Kinesis 串流。
系統會監控以下類別的活動並將其放在活動串流稽核日誌中：
+ **SQL 命令** – 所有 SQL 命令都經稽核，也是預備陳述式、內建函數和 PL/SQL 函數。對預存程序的呼叫會進行稽核。在儲存的程序或函數中發出的任何 SQL 語句也被稽核。
+ **其他資料庫資訊** – 監控的活動包含完整的 SQL 陳述式、因 DML 命令而受影響的資料列數、經存取的物件和唯一的資料庫名稱。若為 Aurora PostgreSQL，資料庫活動串流還會監控連結變數和已儲存的程序參數。
**重要**
活動資料串流稽核記錄中會顯示每個陳述式的完整 SQL 文字，包括任何敏感資料。但是，如果 Aurora 可以從內容 (例如下列 SQL 陳述式) 判斷資料庫使用者密碼，則該密碼將會被修訂。
```
ALTER ROLE role-name WITH password
```
+ **連線資訊** – 監控的活動包含工作階段和網路資訊、伺服器程序 ID 和結束代碼。
如果活動串流在監控資料庫執行個體時失敗，系統會透過 RDS 事件來通知您。
在下列各節中，您可以存取、稽核和處理資料庫活動串流。
**Topics**
+ [透過 Amazon Kinesis 存取活動串流](DBActivityStreams.KinesisAccess.md)
+ [資料庫活動串流的稽核日誌內容和範例](DBActivityStreams.AuditLog.md)
+ [適用於資料庫活動串流的 databaseActivityEventList JSON 陣列](DBActivityStreams.AuditLog.databaseActivityEventList.md)
+ [使用 AWS SDK 來處理資料庫活動串流](DBActivityStreams.CodeExample.md)
# 透過 Amazon Kinesis 存取活動串流
在您啟用資料庫叢集的活動串流時，系統就會為您建立 Kinesis 串流。透過 Kinesis，您就可以即時監控資料庫活動。若要進一步分析資料庫活動，您可以將 Kinesis 串流連線至消費者應用程式。您也可以將串流連線至合規性管理應用程式，例如 IBM 的 Security Guardium 或 Imperva 的 SecureSphere Database Audit and Protection。
您可以從 RDS 主控台或 Kinesis 主控台存取 Kinesis 串流。
**使用 RDS 主控台從 Kinesis 存取活動串流**
1. 前往 [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/)，開啟 Amazon RDS 主控台。
1. 在導覽窗格中，選擇 **Databases** (資料庫)。
1. 選擇已在其上啟動活動串流的資料庫叢集。
1. 選擇 **Configuration (組態)**。
1. 在 **Database activity stream** (資料庫活動串流) 下，選擇 **Kinesis stream** (Kinesis 串流) 下的連結。
1. 在 Kinesis 主控台中，選擇 **Monitoring** (監控) 來開始觀察資料庫活動。
**使用 Kinesis 主控台從 Kinesis 存取活動串流**
1. 在 [https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis) 上開啟 Kinesis 主控台。
1. 從 Kinesis 串流清單中選擇活動串流。
活動串流的名稱包含字首 `aws-rds-das-cluster-`，後接資料庫叢集的資源 ID。以下是範例。
```
aws-rds-das-cluster-NHVOV4PCLWHGF52NP
```
若要使用 Amazon RDS 主控台來尋找資料庫叢集的資源 ID，請從資料庫清單中選擇您的資料庫叢集，然後選擇**Configuration (組態)** 索引標籤。
若要使用 AWS CLI 來尋找活動串流的完整 Kinesis 串流名稱，請使用 [describe-db-clusters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-clusters.html) CLI 請求，並記下回應中的 `ActivityStreamKinesisStreamName` 值。
1. 選擇 **Monitoring (監控)** 來開始觀察資料庫活動。
如需使用 Amazon Kinesis 的詳細資訊，請參閱[什麼是 Amazon Kinesis Data Streams？](https://docs.aws.amazon.com/streams/latest/dev/introduction.html)。
# 資料庫活動串流的稽核日誌內容和範例
受監控的事件會以 JSON 字串的形式在資料庫活動串流中顯示。此結構包含 JSON 物件，內含的 `DatabaseActivityMonitoringRecord` 會依序包含活動事件的 `databaseActivityEventList` 陣列。
**注意**
對於資料庫活動串流，`paramList` JSON 陣列不包含休眠應用程式的 null 值。
**Topics**
+ [活動串流的稽核記錄範例](#DBActivityStreams.AuditLog.Examples)
+ [DatabaseActivityMonitoringRecords JSON 物件](#DBActivityStreams.AuditLog.DatabaseActivityMonitoringRecords)
+ [databaseActivityEvents JSON 物件](#DBActivityStreams.AuditLog.databaseActivityEvents)
## 活動串流的稽核記錄範例
以下是活動事件記錄的範例解密 JSON 稽核日誌。
**Example Aurora PostgreSQL CONNECT SQL 陳述式的活動事件記錄**
以下活動事件記錄顯示 psql 用戶端 (`clientApplication`) 使用 `CONNECT` SQL 陳述式 (`command`) 登入。
```
{
"type":"DatabaseActivityMonitoringRecords",
"version":"1.1",
"databaseActivityEvents":
{
"type":"DatabaseActivityMonitoringRecord",
"clusterId":"cluster-4HNY5V4RRNPKKYB7ICFKE5JBQQ",
"instanceId":"db-FZJTMYKCXQBUUZ6VLU7NW3ITCM",
"databaseActivityEventList":[
{
"startTime": "2019-10-30 00:39:49.940668+00",
"logTime": "2019-10-30 00:39:49.990579+00",
"statementId": 1,
"substatementId": 1,
"objectType": null,
"command": "CONNECT",
"objectName": null,
"databaseName": "postgres",
"dbUserName": "rdsadmin",
"remoteHost": "172.31.3.195",
"remotePort": "49804",
"sessionId": "5ce5f7f0.474b",
"rowCount": null,
"commandText": null,
"paramList": [],
"pid": 18251,
"clientApplication": "psql",
"exitCode": null,
"class": "MISC",
"serverVersion": "2.3.1",
"serverType": "PostgreSQL",
"serviceName": "Amazon Aurora PostgreSQL-Compatible edition",
"serverHost": "172.31.3.192",
"netProtocol": "TCP",
"dbProtocol": "Postgres 3.0",
"type": "record",
"errorMessage": null
}
]
},
"key":"decryption-key"
}
```
**Example Aurora MySQL CONNECT SQL 陳述式的活動事件記錄**
以下是 mysql 用戶端 (`clientApplication`) 使用 `CONNECT` SQL 陳述式 (`command`) 登入的活動事件記錄。
```
{
"type":"DatabaseActivityMonitoringRecord",
"clusterId":"cluster-some_id",
"instanceId":"db-some_id",
"databaseActivityEventList":[
{
"logTime":"2020-05-22 18:07:13.267214+00",
"type":"record",
"clientApplication":null,
"pid":2830,
"dbUserName":"rdsadmin",
"databaseName":"",
"remoteHost":"localhost",
"remotePort":"11053",
"command":"CONNECT",
"commandText":"",
"paramList":null,
"objectType":"TABLE",
"objectName":"",
"statementId":0,
"substatementId":1,
"exitCode":"0",
"sessionId":"725121",
"rowCount":0,
"serverHost":"master",
"serverType":"MySQL",
"serviceName":"Amazon Aurora MySQL",
"serverVersion":"MySQL 5.7.12",
"startTime":"2020-05-22 18:07:13.267207+00",
"endTime":"2020-05-22 18:07:13.267213+00",
"transactionId":"0",
"dbProtocol":"MySQL",
"netProtocol":"TCP",
"errorMessage":"",
"class":"MAIN"
}
]
}
```
**Example Aurora PostgreSQL CREATE TABLE 陳述式的活動事件記錄**
以下是 Aurora PostgreSQL 的 `CREATE TABLE` 事件範例。
```
{
"type":"DatabaseActivityMonitoringRecords",
"version":"1.1",
"databaseActivityEvents":
{
"type":"DatabaseActivityMonitoringRecord",
"clusterId":"cluster-4HNY5V4RRNPKKYB7ICFKE5JBQQ",
"instanceId":"db-FZJTMYKCXQBUUZ6VLU7NW3ITCM",
"databaseActivityEventList":[
{
"startTime": "2019-05-24 00:36:54.403455+00",
"logTime": "2019-05-24 00:36:54.494235+00",
"statementId": 2,
"substatementId": 1,
"objectType": null,
"command": "CREATE TABLE",
"objectName": null,
"databaseName": "postgres",
"dbUserName": "rdsadmin",
"remoteHost": "172.31.3.195",
"remotePort": "34534",
"sessionId": "5ce73c6f.7e64",
"rowCount": null,
"commandText": "create table my_table (id serial primary key, name varchar(32));",
"paramList": [],
"pid": 32356,
"clientApplication": "psql",
"exitCode": null,
"class": "DDL",
"serverVersion": "2.3.1",
"serverType": "PostgreSQL",
"serviceName": "Amazon Aurora PostgreSQL-Compatible edition",
"serverHost": "172.31.3.192",
"netProtocol": "TCP",
"dbProtocol": "Postgres 3.0",
"type": "record",
"errorMessage": null
}
]
},
"key":"decryption-key"
}
```
**Example Aurora MySQL CREATE TABLE 陳述式的活動事件記錄**
以下範例顯示 Aurora MySQL 的 `CREATE TABLE` 陳述式。該操作會以兩個不同的事件記錄表示。一個活動具有 `"class":"MAIN"`。另一個活動具有 `"class":"AUX"`。這些訊息可能以任何順序到達。`logTime` 事件的 `MAIN` 欄位永遠早於任何對應 `logTime` 事件的 `AUX` 欄位。
下列範例會顯示 `class` 值為 `MAIN` 的事件。
```
{
"type":"DatabaseActivityMonitoringRecord",
"clusterId":"cluster-some_id",
"instanceId":"db-some_id",
"databaseActivityEventList":[
{
"logTime":"2020-05-22 18:07:12.250221+00",
"type":"record",
"clientApplication":null,
"pid":2830,
"dbUserName":"master",
"databaseName":"test",
"remoteHost":"localhost",
"remotePort":"11054",
"command":"QUERY",
"commandText":"CREATE TABLE test1 (id INT)",
"paramList":null,
"objectType":"TABLE",
"objectName":"test1",
"statementId":65459278,
"substatementId":1,
"exitCode":"0",
"sessionId":"725118",
"rowCount":0,
"serverHost":"master",
"serverType":"MySQL",
"serviceName":"Amazon Aurora MySQL",
"serverVersion":"MySQL 5.7.12",
"startTime":"2020-05-22 18:07:12.226384+00",
"endTime":"2020-05-22 18:07:12.250222+00",
"transactionId":"0",
"dbProtocol":"MySQL",
"netProtocol":"TCP",
"errorMessage":"",
"class":"MAIN"
}
]
}
```
下列範例會顯示 `class` 值為 `AUX` 的對應事件。
```
{
"type":"DatabaseActivityMonitoringRecord",
"clusterId":"cluster-some_id",
"instanceId":"db-some_id",
"databaseActivityEventList":[
{
"logTime":"2020-05-22 18:07:12.247182+00",
"type":"record",
"clientApplication":null,
"pid":2830,
"dbUserName":"master",
"databaseName":"test",
"remoteHost":"localhost",
"remotePort":"11054",
"command":"CREATE",
"commandText":"test1",
"paramList":null,
"objectType":"TABLE",
"objectName":"test1",
"statementId":65459278,
"substatementId":2,
"exitCode":"",
"sessionId":"725118",
"rowCount":0,
"serverHost":"master",
"serverType":"MySQL",
"serviceName":"Amazon Aurora MySQL",
"serverVersion":"MySQL 5.7.12",
"startTime":"2020-05-22 18:07:12.226384+00",
"endTime":"2020-05-22 18:07:12.247182+00",
"transactionId":"0",
"dbProtocol":"MySQL",
"netProtocol":"TCP",
"errorMessage":"",
"class":"AUX"
}
]
}
```
**Example Aurora PostgreSQLSELECT 陳述式的活動事件記錄**
下列範例顯示 的 `SELECT` 事件。
```
{
"type":"DatabaseActivityMonitoringRecords",
"version":"1.1",
"databaseActivityEvents":
{
"type":"DatabaseActivityMonitoringRecord",
"clusterId":"cluster-4HNY5V4RRNPKKYB7ICFKE5JBQQ",
"instanceId":"db-FZJTMYKCXQBUUZ6VLU7NW3ITCM",
"databaseActivityEventList":[
{
"startTime": "2019-05-24 00:39:49.920564+00",
"logTime": "2019-05-24 00:39:49.940668+00",
"statementId": 6,
"substatementId": 1,
"objectType": "TABLE",
"command": "SELECT",
"objectName": "public.my_table",
"databaseName": "postgres",
"dbUserName": "rdsadmin",
"remoteHost": "172.31.3.195",
"remotePort": "34534",
"sessionId": "5ce73c6f.7e64",
"rowCount": 10,
"commandText": "select * from my_table;",
"paramList": [],
"pid": 32356,
"clientApplication": "psql",
"exitCode": null,
"class": "READ",
"serverVersion": "2.3.1",
"serverType": "PostgreSQL",
"serviceName": "Amazon Aurora PostgreSQL-Compatible edition",
"serverHost": "172.31.3.192",
"netProtocol": "TCP",
"dbProtocol": "Postgres 3.0",
"type": "record",
"errorMessage": null
}
]
},
"key":"decryption-key"
}
```
```
{
"type": "DatabaseActivityMonitoringRecord",
"clusterId": "",
"instanceId": "db-4JCWQLUZVFYP7DIWP6JVQ77O3Q",
"databaseActivityEventList": [
{
"class": "TABLE",
"clientApplication": "Microsoft SQL Server Management Studio - Query",
"command": "SELECT",
"commandText": "select * from [testDB].[dbo].[TestTable]",
"databaseName": "testDB",
"dbProtocol": "SQLSERVER",
"dbUserName": "test",
"endTime": null,
"errorMessage": null,
"exitCode": 1,
"logTime": "2022-10-06 21:24:59.9422268+00",
"netProtocol": null,
"objectName": "TestTable",
"objectType": "TABLE",
"paramList": null,
"pid": null,
"remoteHost": "local machine",
"remotePort": null,
"rowCount": 0,
"serverHost": "172.31.30.159",
"serverType": "SQLSERVER",
"serverVersion": "15.00.4073.23.v1.R1",
"serviceName": "sqlserver-ee",
"sessionId": 62,
"startTime": null,
"statementId": "0x03baed90412f564fad640ebe51f89b99",
"substatementId": 1,
"transactionId": "4532935",
"type": "record",
"engineNativeAuditFields": {
"target_database_principal_id": 0,
"target_server_principal_id": 0,
"target_database_principal_name": "",
"server_principal_id": 2,
"user_defined_information": "",
"response_rows": 0,
"database_principal_name": "dbo",
"target_server_principal_name": "",
"schema_name": "dbo",
"is_column_permission": true,
"object_id": 581577110,
"server_instance_name": "EC2AMAZ-NFUJJNO",
"target_server_principal_sid": null,
"additional_information": "",
"duration_milliseconds": 0,
"permission_bitmask": "0x00000000000000000000000000000001",
"data_sensitivity_information": "",
"session_server_principal_name": "test",
"connection_id": "AD3A5084-FB83-45C1-8334-E923459A8109",
"audit_schema_version": 1,
"database_principal_id": 1,
"server_principal_sid": "0x010500000000000515000000bdc2795e2d0717901ba6998cf4010000",
"user_defined_event_id": 0,
"host_name": "EC2AMAZ-NFUJJNO"
}
}
]
}
```
**Example Aurora MySQL SELECT 陳述式的活動事件記錄**
下列範例顯示 `SELECT` 事件。
下列範例會顯示 `class` 值為 `MAIN` 的事件。
```
{
"type":"DatabaseActivityMonitoringRecord",
"clusterId":"cluster-some_id",
"instanceId":"db-some_id",
"databaseActivityEventList":[
{
"logTime":"2020-05-22 18:29:57.986467+00",
"type":"record",
"clientApplication":null,
"pid":2830,
"dbUserName":"master",
"databaseName":"test",
"remoteHost":"localhost",
"remotePort":"11054",
"command":"QUERY",
"commandText":"SELECT * FROM test1 WHERE id < 28",
"paramList":null,
"objectType":"TABLE",
"objectName":"test1",
"statementId":65469218,
"substatementId":1,
"exitCode":"0",
"sessionId":"726571",
"rowCount":2,
"serverHost":"master",
"serverType":"MySQL",
"serviceName":"Amazon Aurora MySQL",
"serverVersion":"MySQL 5.7.12",
"startTime":"2020-05-22 18:29:57.986364+00",
"endTime":"2020-05-22 18:29:57.986467+00",
"transactionId":"0",
"dbProtocol":"MySQL",
"netProtocol":"TCP",
"errorMessage":"",
"class":"MAIN"
}
]
}
```
下列範例會顯示 `class` 值為 `AUX` 的對應事件。
```
{
"type":"DatabaseActivityMonitoringRecord",
"instanceId":"db-some_id",
"databaseActivityEventList":[
{
"logTime":"2020-05-22 18:29:57.986399+00",
"type":"record",
"clientApplication":null,
"pid":2830,
"dbUserName":"master",
"databaseName":"test",
"remoteHost":"localhost",
"remotePort":"11054",
"command":"READ",
"commandText":"test1",
"paramList":null,
"objectType":"TABLE",
"objectName":"test1",
"statementId":65469218,
"substatementId":2,
"exitCode":"",
"sessionId":"726571",
"rowCount":0,
"serverHost":"master",
"serverType":"MySQL",
"serviceName":"Amazon Aurora MySQL",
"serverVersion":"MySQL 5.7.12",
"startTime":"2020-05-22 18:29:57.986364+00",
"endTime":"2020-05-22 18:29:57.986399+00",
"transactionId":"0",
"dbProtocol":"MySQL",
"netProtocol":"TCP",
"errorMessage":"",
"class":"AUX"
}
]
}
```
## DatabaseActivityMonitoringRecords JSON 物件
資料庫活動事件記錄位於 JSON 物件中，其中包含下列資訊。
****
| JSON 欄位 | 資料類型 | 描述 |
| --- | --- | --- |
| `type` | string | JSON 記錄類型。值為 `DatabaseActivityMonitoringRecords`。 |
| version | string | 資料庫活動監控記錄的版本。產生的資料庫活動記錄版本取決於資料庫叢集的引擎版本： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/DBActivityStreams.AuditLog.html)除非特別註明，否則下列所有欄位都在 1.0 版和 1.1 版中。 |
| [databaseActivityEvents](#DBActivityStreams.AuditLog.databaseActivityEvents) | string | 包含活動事件的 JSON 物件。 |
| 金鑰 | string | 您用來解密 [databaseActivityEventList JSON 陣列](DBActivityStreams.AuditLog.databaseActivityEventList.md) 的加密金鑰 |
## databaseActivityEvents JSON 物件
`databaseActivityEvents` JSON 物件包含以下資訊。
### JSON 記錄中的最上層欄位
稽核記錄檔中的每個事件都會包裝在 JSON 格式的記錄中。此記錄包含下列欄位。
**type**
此欄位永遠具有值 `DatabaseActivityMonitoringRecords`。
**version**
此欄位代表資料庫活動串流資料通訊協定或合約的版本。其會定義哪些欄位可用。
1.0 版代表 Aurora PostgreSQL 10.7 和 11.4 版的原始資料活動串流支援。1.1 版代表 Aurora PostgreSQL 10.10 及更高版本和 Aurora PostgreSQL 11.5 及更高版本的資料活動串流支援。1.1 版包含其他欄位 `errorMessage` 和 `startTime`。1.2 版代表 Aurora MySQL 2.08 及更高版本的資料活動串流支援。1.2 版包含其他欄位 `endTime` 和 `transactionId`。
**databaseActivityEvents**
代表一或多個活動事件的加密字串。它被表示為一個 base64 位元組陣列。在您解密字串時，結果會是 JSON 格式的記錄，其中包含欄位，如本節範例所示。
**金鑰**
用來加密 `databaseActivityEvents` 字串的加密資料金鑰。這與您啟動資料庫活動串流時 AWS KMS key 提供的相同。
下列範例顯示此記錄的格式。
```
{
"type":"DatabaseActivityMonitoringRecords",
"version":"1.1",
"databaseActivityEvents":"encrypted audit records",
"key":"encrypted key"
}
```
採取下列步驟來解密 `databaseActivityEvents` 欄位的內容：
1. 使用您在啟動資料庫活動串流時提供的 KMS 金鑰，解密 `key` JSON 欄位中的值。這麼做會以純文字傳回資料加密金鑰。
1. Base64 解碼 `databaseActivityEvents` JSON 欄位中的值，以取得稽核承載的二進位格式的加密文字。
1. 使用您在第一個步驟中解碼的資料加密金鑰來解密二進位密文。
1. 解壓縮已解密的承載。
+ 加密的承載在 `databaseActivityEvents` 欄位。
+ 該 `databaseActivityEventList` 欄位包含稽核記錄的陣列。陣列中的 `type` 欄位可以是 `record` 或 `heartbeat`。
稽核日誌活動事件記錄是包含以下資訊的 JSON 物件。
****
| JSON 欄位 | 資料類型 | 描述 |
| --- | --- | --- |
| `type` | string | JSON 記錄類型。值為 `DatabaseActivityMonitoringRecord`。 |
| clusterId | string | 資料庫叢集資源識別符。其對應於資料庫叢集屬性 DbClusterResourceId。 |
| instanceId | string | 資料庫執行個體資源識別符。它對應於資料庫執行個體屬性 DbiResourceId。 |
| [databaseActivityEventList JSON 陣列](DBActivityStreams.AuditLog.databaseActivityEventList.md) | string | 活動稽核記錄或活動訊號訊息的陣列。 |
# 適用於資料庫活動串流的 databaseActivityEventList JSON 陣列
稽核日誌承載是加密的 `databaseActivityEventList` JSON 陣列。以下資料表列出稽核記錄中已解密 `DatabaseActivityEventList` 陣列中，每個活動事件的欄位 (按英文字母順序列出)。這些欄位會根據您使用 Aurora PostgreSQL 或 Aurora MySQL 而有所不同。請參閱適用於資料庫引擎的表格。
**重要**
事件結構可能會改變。Aurora 可能會在未來將新的欄位新增至活動事件。在剖析 JSON 資料的應用程式中，請確定程式碼可以忽略，或針對未知欄位名稱採取適當的動作。
## Aurora PostgreSQL 的 databaseActivityEventList 欄位
以下是 Aurora PostgreSQL 的 `databaseActivityEventList` 欄位。
| 欄位 | 資料類型 | 描述 |
| --- | --- | --- |
| class | string | 活動事件的類別。Aurora PostgreSQL 的有效值如下： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/DBActivityStreams.AuditLog.databaseActivityEventList.html) |
| clientApplication | string | 用戶端報告用來連接的應用程式。用戶端不需提供此資訊，因此此值可以是 Null。 |
| command | string | SQL 命令名稱，其中不含任何命令詳細資訊。 |
| commandText | string | 使用者傳遞的實際 SQL 陳述式。針對 Aurora PostgreSQL，該值與原始 SQL 陳述式相同。此欄位可用於連接或中斷連接記錄以外的所有記錄類型，在前述兩種例外類型中值為 Null。 活動資料串流稽核記錄中會顯示每個陳述式的完整 SQL 文字，包括任何敏感資料。但是，如果 Aurora 可以從內容 (例如下列 SQL 陳述式) 判斷資料庫使用者密碼，則會編寫密文。 ALTER ROLE role-name WITH password
|
| databaseName | string | 使用者連接的資料庫。 |
| dbProtocol | string | 資料庫通訊協定，例如 Postgres 3.0。 |
| dbUserName | string | 用戶端驗證所用的資料庫使用者。 |
| errorMessage(僅限 1.1 版資料庫活動記錄) | string | 如果有任何錯誤，該欄位會填入由資料庫伺服器產生的錯誤訊息。對於未導致錯誤的正常陳述式，此 `errorMessage` 值為 null。 錯誤是定義為任何會產生用戶端可見 PostgreSQL 錯誤日誌事件的活動，其嚴重性層級為 `ERROR` 或更高。如需詳細資訊，請參閱 [PostgreSQL 訊息嚴重性等級](https://www.postgresql.org/docs/current/runtime-config-logging.html#RUNTIME-CONFIG-SEVERITY-LEVELS)。例如，語法錯誤和查詢取消會產生錯誤訊息。 內部 PostgreSQL 伺服器錯誤，例如背景檢查點指標處理程序錯誤，並不會產生錯誤訊息。不過，無論日誌嚴重性層級的設定為何，仍會發出這類事件的記錄。這可以防止攻擊者關閉記錄日誌以嘗試避免偵測。 另請參閱 `exitCode` 欄位。 |
| exitCode | int | 工作階段結束記錄所用的值。清除結束時，此會包含結束代碼。在某些失敗狀況下可能無法隨時取得結束代碼。範例為 PostgreSQL 執行 exit() 或運算子執行 kill -9 之類的命令。如果發生任何錯誤，此 `exitCode` 欄位會顯示 SQL 錯誤代碼 `SQLSTATE`，如 [PostgreSQL 錯誤代碼](https://www.postgresql.org/docs/current/errcodes-appendix.html)中所列。另請參閱 `errorMessage` 欄位。 |
| logTime | string | 在稽核程式碼路徑中記錄的時間戳記。這代表 SQL 陳述式執行結束時間。另請參閱 startTime 欄位。 |
| netProtocol | string | 網路通訊協定。 |
| objectName | string | SQL 陳述式在其中操作的資料庫物件名稱。僅在 SQL 陳述式在資料庫物件上操作時才會使用此欄位。如果 SQL 陳述式沒有在物件上操作，則此值為 Null。 |
| objectType | string | 資料表、索引、檢視等之類的資料庫物件類型。僅在 SQL 陳述式在資料庫物件上操作時才會使用此欄位。如果 SQL 陳述式沒有在物件上操作，則此值為 Null。有效值包括以下項目：[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/DBActivityStreams.AuditLog.databaseActivityEventList.html) |
| paramList | string | 傳遞至 SQL 陳述式的參數陣列 (以逗號分隔)。如果 SQL 陳述式沒有任何參數，此值會是空的陣列。 |
| pid | int | 後端程序的程序 ID，此程序的配置是用來提供用戶端連線。 |
| remoteHost | string | 用戶端 IP 地址或主機名稱。針對 Aurora PostgreSQL，使用哪一個取決於資料庫的 log\$1hostname 參數設定。此 remoteHost 值也包含 [local]，且 localhost 表示來自 rdsadmin 使用者的活動。 |
| remotePort | string | 用戶端連接埠號碼。 |
| rowCount | int | SQL 陳述式影響或擷取的資料列數。僅會對資料處理語言 (DML) 陳述式的 SQL 陳述式使用此欄位。如果 SQL 陳述式不是 DML 陳述式，則此值為 Null。 |
| serverHost | string | 資料庫伺服器主機 IP 地址。此 serverHost 值也包含 [local]，且 localhost 表示來自 rdsadmin 使用者的活動。 |
| serverType | string | 資料庫伺服器類型，例如 PostgreSQL。 |
| serverVersion | string | 資料庫伺服器版本，例如 Aurora PostgreSQL 的 2.3.1。 |
| serviceName | string | 服務名稱，例如 Amazon Aurora PostgreSQL-Compatible edition。 |
| sessionId | int | 虛擬唯一的工作階段識別符。 |
| sessionId | int | 虛擬唯一的工作階段識別符。 |
| startTime(僅限 1.1 版資料庫活動記錄) | string | SQL 陳述式開始執行的時間。 若要計算 SQL 陳述式大約的執行時間，請使用 `logTime - startTime`。另請參閱 `logTime` 欄位。 |
| statementId | int | 用戶端 SQL 陳述式的識別符。記數器是使用工作階段層級，且會隨著用戶端輸入的每個 SQL 陳述式遞增。 |
| substatementId | int | SQL 子陳述式的識別符。此值會計算由 statementId 欄位識別的每個 SQL 陳述式包含的子陳述式。 |
| type | string | 事件類型。有效值為 record 或 heartbeat。 |
## Aurora MySQL 的 databaseActivityEventList 欄位
以下是 Aurora MySQL 的 `databaseActivityEventList` 欄位。
| 欄位 | 資料類型 | 描述 |
| --- | --- | --- |
| class | string | 活動事件的類別。 Aurora MySQL 的有效值如下： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/DBActivityStreams.AuditLog.databaseActivityEventList.html) |
| clientApplication | string | 用戶端報告用來連接的應用程式。用戶端不需提供此資訊，因此此值可以是 Null。 |
| command | string | SQL 陳述式的一般類別。此欄位的值取決於 `class` 的值。 當 `class` 為 `MAIN` 時的值包括以下內容： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/DBActivityStreams.AuditLog.databaseActivityEventList.html) 當 `class` 為 `AUX` 時的值包括以下內容： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/DBActivityStreams.AuditLog.databaseActivityEventList.html) |
| commandText | string | 對於 `class` 值為 `MAIN` 的事件，此欄位代表使用者傳入的實際 SQL 陳述式。此欄位可用於連接或中斷連接記錄以外的所有記錄類型，在前述兩種例外類型中值為 Null。 對於 `class` 值為 `AUX` 的事件，此欄位包含有關事件涉及之物件的補充資訊。 針對 Aurora MySQL，引號之類的字元前面加上反斜線，代表逸出字元。 稽核記錄中會顯示每個陳述式的完整 SQL 文字，包括任何敏感資料。但是，如果 Aurora 可以從內容 (例如下列 SQL 陳述式) 判斷資料庫使用者密碼，則會編寫密文。 mysql> SET PASSWORD = 'my-password';
指定此處所顯示提示以外的密碼，作為安全最佳實務。 |
| databaseName | string | 使用者連接的資料庫。 |
| dbProtocol | string | 資料庫通訊協定。目前，Aurora MySQL 的這個值永遠是 MySQL。 |
| dbUserName | string | 用戶端驗證所用的資料庫使用者。 |
| endTime(僅限 1.2 版資料庫活動記錄) | string | SQL 陳述式結束執行的時間。以國際標準時間 (UTC) 格式表示。 若要計算 SQL 陳述式的執行時間，請使用 `endTime - startTime`。另請參閱 `startTime` 欄位。 |
| errorMessage(僅限 1.1 版資料庫活動記錄) | string | 如果有任何錯誤，該欄位會填入由資料庫伺服器產生的錯誤訊息。對於未導致錯誤的正常陳述式，此 `errorMessage` 值為 null。 錯誤是定義為任何會產生用戶端可見 MySQL 錯誤日誌事件的活動，其嚴重性層級為 `ERROR` 或更高。如需更多資訊，請參閱 *MySQL 參考手冊*中的[錯誤記錄](https://dev.mysql.com/doc/refman/5.7/en/error-log.html)。例如，語法錯誤和查詢取消會產生錯誤訊息。 內部 MySQL 伺服器錯誤，例如背景檢查點指標處理程序錯誤，並不會產生錯誤訊息。不過，無論日誌嚴重性層級的設定為何，仍會發出這類事件的記錄。這可以防止攻擊者關閉記錄日誌以嘗試避免偵測。 另請參閱 `exitCode` 欄位。 |
| exitCode | int | 工作階段結束記錄所用的值。清除結束時，此會包含結束代碼。在某些失敗狀況下可能無法隨時取得結束代碼。在這種情況下，此值可能是零，也可能是空白。 |
| logTime | string | 在稽核程式碼路徑中記錄的時間戳記。以國際標準時間 (UTC) 格式表示。如需計算陳述式持續時間的最準確方式，請參閱 startTime 和 endTime 欄位。 |
| netProtocol | string | 網路通訊協定。目前，Aurora MySQL 的這個值永遠是 TCP。 |
| objectName | string | SQL 陳述式在其中操作的資料庫物件名稱。僅在 SQL 陳述式在資料庫物件上操作時才會使用此欄位。如果 SQL 陳述式沒有在物件上操作，則此值為空白。若要建構物件的完整名稱，請結合 databaseName 和 objectName。如果查詢涉及多個物件，則此欄位可以是以逗號分隔的名稱清單。 |
| objectType | string | 資料表、索引、檢視等之類的資料庫物件類型。僅在 SQL 陳述式在資料庫物件上操作時才會使用此欄位。如果 SQL 陳述式沒有在物件上操作，則此值為 Null。 Aurora MySQL 的有效值包括以下項目： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/AmazonRDS/latest/AuroraUserGuide/DBActivityStreams.AuditLog.databaseActivityEventList.html) |
| paramList | string | 此欄位不會用於 Aurora MySQL 且一律為空。 |
| pid | int | 後端程序的程序 ID，此程序的配置是用來提供用戶端連線。重新啟動資料庫伺服器時，pid 變更和 statementId 欄位的計數器會重新啟動。 |
| remoteHost | string | 發出 SQL 陳述式之用戶端的 IP 地址或主機名稱。針對 Aurora MySQL，使用哪一個取決於資料庫的 skip\$1name\$1resolve 參數設定。localhost 的值表示來自 rdsadmin 特殊使用者的活動。 |
| remotePort | string | 用戶端連接埠號碼。 |
| rowCount | int | SQL 陳述式傳回的資料列數目。例如，如果一個 SELECT 陳述式傳回 10 個資料列，則 rowCount 為 10。對於 INSERT 或 UPDATE 陳述式，rowCount 為 0。 |
| serverHost | string | 資料庫伺服器執行個體識別符。 |
| serverType | string | 資料庫伺服器類型，例如 MySQL。 |
| serverVersion | string | 資料庫伺服器版本。目前，Aurora MySQL 的這個值永遠是 MySQL 5.7.12。 |
| serviceName | string | 服務的名稱。目前，Aurora MySQL 的這個值永遠是 Amazon Aurora MySQL。 |
| sessionId | int | 虛擬唯一的工作階段識別符。 |
| startTime(僅限 1.1 版資料庫活動記錄) | string | SQL 陳述式開始執行的時間。以國際標準時間 (UTC) 格式表示。 若要計算 SQL 陳述式的執行時間，請使用 `endTime - startTime`。另請參閱 `endTime` 欄位。 |
| statementId | int | 用戶端 SQL 陳述式的識別符。計數器會隨著用戶端輸入的每個 SQL 陳述式而增加。當資料庫執行個體重新啟動時，計數器會重設。 |
| substatementId | int | SQL 子陳述式的識別符。對於具有類別 MAIN 的事件此值是 1，對於具有類別 AUX 的事件則為 2。使用此 statementId 欄位可識別由相同陳述式產生的所有事件。 |
| transactionId(僅限 1.2 版資料庫活動記錄) | int | 交易的識別符。 |
| type | string | 事件類型。有效值為 record 或 heartbeat。 |
# 使用 AWS SDK 來處理資料庫活動串流
您可以透過使用 AWS 開發套件來以程式設計的方式處理活動串流。以下是功能完整的 Java 和 Python 範例，其示範您可以如何處理 Kinesis 資料串流。
------
#### [ Java ]
```
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Security;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.zip.GZIPInputStream;
import javax.crypto.Cipher;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.SecretKeySpec;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.encryptionsdk.AwsCrypto;
import com.amazonaws.encryptionsdk.CryptoInputStream;
import com.amazonaws.encryptionsdk.jce.JceMasterKey;
import com.amazonaws.services.kinesis.clientlibrary.exceptions.InvalidStateException;
import com.amazonaws.services.kinesis.clientlibrary.exceptions.ShutdownException;
import com.amazonaws.services.kinesis.clientlibrary.exceptions.ThrottlingException;
import com.amazonaws.services.kinesis.clientlibrary.interfaces.IRecordProcessor;
import com.amazonaws.services.kinesis.clientlibrary.interfaces.IRecordProcessorCheckpointer;
import com.amazonaws.services.kinesis.clientlibrary.interfaces.IRecordProcessorFactory;
import com.amazonaws.services.kinesis.clientlibrary.lib.worker.InitialPositionInStream;
import com.amazonaws.services.kinesis.clientlibrary.lib.worker.KinesisClientLibConfiguration;
import com.amazonaws.services.kinesis.clientlibrary.lib.worker.ShutdownReason;
import com.amazonaws.services.kinesis.clientlibrary.lib.worker.Worker;
import com.amazonaws.services.kinesis.clientlibrary.lib.worker.Worker.Builder;
import com.amazonaws.services.kinesis.model.Record;
import com.amazonaws.services.kms.AWSKMS;
import com.amazonaws.services.kms.AWSKMSClientBuilder;
import com.amazonaws.services.kms.model.DecryptRequest;
import com.amazonaws.services.kms.model.DecryptResult;
import com.amazonaws.util.Base64;
import com.amazonaws.util.IOUtils;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.annotations.SerializedName;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public class DemoConsumer {
private static final String STREAM_NAME = "aws-rds-das-[cluster-external-resource-id]";
private static final String APPLICATION_NAME = "AnyApplication"; //unique application name for dynamo table generation that holds kinesis shard tracking
private static final String AWS_ACCESS_KEY = "[AWS_ACCESS_KEY_TO_ACCESS_KINESIS]";
private static final String AWS_SECRET_KEY = "[AWS_SECRET_KEY_TO_ACCESS_KINESIS]";
private static final String DBC_RESOURCE_ID = "[cluster-external-resource-id]";
private static final String REGION_NAME = "[region-name]"; //us-east-1, us-east-2...
private static final BasicAWSCredentials CREDENTIALS = new BasicAWSCredentials(AWS_ACCESS_KEY, AWS_SECRET_KEY);
private static final AWSStaticCredentialsProvider CREDENTIALS_PROVIDER = new AWSStaticCredentialsProvider(CREDENTIALS);
private static final AwsCrypto CRYPTO = new AwsCrypto();
private static final AWSKMS KMS = AWSKMSClientBuilder.standard()
.withRegion(REGION_NAME)
.withCredentials(CREDENTIALS_PROVIDER).build();
class Activity {
String type;
String version;
String databaseActivityEvents;
String key;
}
class ActivityEvent {
@SerializedName("class") String _class;
String clientApplication;
String command;
String commandText;
String databaseName;
String dbProtocol;
String dbUserName;
String endTime;
String errorMessage;
String exitCode;
String logTime;
String netProtocol;
String objectName;
String objectType;
List paramList;
String pid;
String remoteHost;
String remotePort;
String rowCount;
String serverHost;
String serverType;
String serverVersion;
String serviceName;
String sessionId;
String startTime;
String statementId;
String substatementId;
String transactionId;
String type;
}
class ActivityRecords {
String type;
String clusterId;
String instanceId;
List databaseActivityEventList;
}
static class RecordProcessorFactory implements IRecordProcessorFactory {
@Override
public IRecordProcessor createProcessor() {
return new RecordProcessor();
}
}
static class RecordProcessor implements IRecordProcessor {
private static final long BACKOFF_TIME_IN_MILLIS = 3000L;
private static final int PROCESSING_RETRIES_MAX = 10;
private static final long CHECKPOINT_INTERVAL_MILLIS = 60000L;
private static final Gson GSON = new GsonBuilder().serializeNulls().create();
private static final Cipher CIPHER;
static {
Security.insertProviderAt(new BouncyCastleProvider(), 1);
try {
CIPHER = Cipher.getInstance("AES/GCM/NoPadding", "BC");
} catch (NoSuchAlgorithmException | NoSuchPaddingException | NoSuchProviderException e) {
throw new ExceptionInInitializerError(e);
}
}
private long nextCheckpointTimeInMillis;
@Override
public void initialize(String shardId) {
}
@Override
public void processRecords(final List records, final IRecordProcessorCheckpointer checkpointer) {
for (final Record record : records) {
processSingleBlob(record.getData());
}
if (System.currentTimeMillis() > nextCheckpointTimeInMillis) {
checkpoint(checkpointer);
nextCheckpointTimeInMillis = System.currentTimeMillis() + CHECKPOINT_INTERVAL_MILLIS;
}
}
@Override
public void shutdown(IRecordProcessorCheckpointer checkpointer, ShutdownReason reason) {
if (reason == ShutdownReason.TERMINATE) {
checkpoint(checkpointer);
}
}
private void processSingleBlob(final ByteBuffer bytes) {
try {
// JSON $Activity
final Activity activity = GSON.fromJson(new String(bytes.array(), StandardCharsets.UTF_8), Activity.class);
// Base64.Decode
final byte[] decoded = Base64.decode(activity.databaseActivityEvents);
final byte[] decodedDataKey = Base64.decode(activity.key);
Map context = new HashMap<>();
context.put("aws:rds:dbc-id", DBC_RESOURCE_ID);
// Decrypt
final DecryptRequest decryptRequest = new DecryptRequest()
.withCiphertextBlob(ByteBuffer.wrap(decodedDataKey)).withEncryptionContext(context);
final DecryptResult decryptResult = KMS.decrypt(decryptRequest);
final byte[] decrypted = decrypt(decoded, getByteArray(decryptResult.getPlaintext()));
// GZip Decompress
final byte[] decompressed = decompress(decrypted);
// JSON $ActivityRecords
final ActivityRecords activityRecords = GSON.fromJson(new String(decompressed, StandardCharsets.UTF_8), ActivityRecords.class);
// Iterate throught $ActivityEvents
for (final ActivityEvent event : activityRecords.databaseActivityEventList) {
System.out.println(GSON.toJson(event));
}
} catch (Exception e) {
// Handle error.
e.printStackTrace();
}
}
private static byte[] decompress(final byte[] src) throws IOException {
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(src);
GZIPInputStream gzipInputStream = new GZIPInputStream(byteArrayInputStream);
return IOUtils.toByteArray(gzipInputStream);
}
private void checkpoint(IRecordProcessorCheckpointer checkpointer) {
for (int i = 0; i < PROCESSING_RETRIES_MAX; i++) {
try {
checkpointer.checkpoint();
break;
} catch (ShutdownException se) {
// Ignore checkpoint if the processor instance has been shutdown (fail over).
System.out.println("Caught shutdown exception, skipping checkpoint." + se);
break;
} catch (ThrottlingException e) {
// Backoff and re-attempt checkpoint upon transient failures
if (i >= (PROCESSING_RETRIES_MAX - 1)) {
System.out.println("Checkpoint failed after " + (i + 1) + "attempts." + e);
break;
} else {
System.out.println("Transient issue when checkpointing - attempt " + (i + 1) + " of " + PROCESSING_RETRIES_MAX + e);
}
} catch (InvalidStateException e) {
// This indicates an issue with the DynamoDB table (check for table, provisioned IOPS).
System.out.println("Cannot save checkpoint to the DynamoDB table used by the Amazon Kinesis Client Library." + e);
break;
}
try {
Thread.sleep(BACKOFF_TIME_IN_MILLIS);
} catch (InterruptedException e) {
System.out.println("Interrupted sleep" + e);
}
}
}
}
private static byte[] decrypt(final byte[] decoded, final byte[] decodedDataKey) throws IOException {
// Create a JCE master key provider using the random key and an AES-GCM encryption algorithm
final JceMasterKey masterKey = JceMasterKey.getInstance(new SecretKeySpec(decodedDataKey, "AES"),
"BC", "DataKey", "AES/GCM/NoPadding");
try (final CryptoInputStream decryptingStream = CRYPTO.createDecryptingStream(masterKey, new ByteArrayInputStream(decoded));
final ByteArrayOutputStream out = new ByteArrayOutputStream()) {
IOUtils.copy(decryptingStream, out);
return out.toByteArray();
}
}
public static void main(String[] args) throws Exception {
final String workerId = InetAddress.getLocalHost().getCanonicalHostName() + ":" + UUID.randomUUID();
final KinesisClientLibConfiguration kinesisClientLibConfiguration =
new KinesisClientLibConfiguration(APPLICATION_NAME, STREAM_NAME, CREDENTIALS_PROVIDER, workerId);
kinesisClientLibConfiguration.withInitialPositionInStream(InitialPositionInStream.LATEST);
kinesisClientLibConfiguration.withRegionName(REGION_NAME);
final Worker worker = new Builder()
.recordProcessorFactory(new RecordProcessorFactory())
.config(kinesisClientLibConfiguration)
.build();
System.out.printf("Running %s to process stream %s as worker %s...\n", APPLICATION_NAME, STREAM_NAME, workerId);
try {
worker.run();
} catch (Throwable t) {
System.err.println("Caught throwable while processing data.");
t.printStackTrace();
System.exit(1);
}
System.exit(0);
}
private static byte[] getByteArray(final ByteBuffer b) {
byte[] byteArray = new byte[b.remaining()];
b.get(byteArray);
return byteArray;
}
}
```
------
#### [ Python ]
```
import base64
import json
import zlib
import aws_encryption_sdk
from aws_encryption_sdk import CommitmentPolicy
from aws_encryption_sdk.internal.crypto import WrappingKey
from aws_encryption_sdk.key_providers.raw import RawMasterKeyProvider
from aws_encryption_sdk.identifiers import WrappingAlgorithm, EncryptionKeyType
import boto3
REGION_NAME = '' # us-east-1
RESOURCE_ID = '' # cluster-ABCD123456
STREAM_NAME = 'aws-rds-das-' + RESOURCE_ID # aws-rds-das-cluster-ABCD123456
enc_client = aws_encryption_sdk.EncryptionSDKClient(commitment_policy=CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT)
class MyRawMasterKeyProvider(RawMasterKeyProvider):
provider_id = "BC"
def __new__(cls, *args, **kwargs):
obj = super(RawMasterKeyProvider, cls).__new__(cls)
return obj
def __init__(self, plain_key):
RawMasterKeyProvider.__init__(self)
self.wrapping_key = WrappingKey(wrapping_algorithm=WrappingAlgorithm.AES_256_GCM_IV12_TAG16_NO_PADDING,
wrapping_key=plain_key, wrapping_key_type=EncryptionKeyType.SYMMETRIC)
def _get_raw_key(self, key_id):
return self.wrapping_key
def decrypt_payload(payload, data_key):
my_key_provider = MyRawMasterKeyProvider(data_key)
my_key_provider.add_master_key("DataKey")
decrypted_plaintext, header = enc_client.decrypt(
source=payload,
materials_manager=aws_encryption_sdk.materials_managers.default.DefaultCryptoMaterialsManager(master_key_provider=my_key_provider))
return decrypted_plaintext
def decrypt_decompress(payload, key):
decrypted = decrypt_payload(payload, key)
return zlib.decompress(decrypted, zlib.MAX_WBITS + 16)
def main():
session = boto3.session.Session()
kms = session.client('kms', region_name=REGION_NAME)
kinesis = session.client('kinesis', region_name=REGION_NAME)
response = kinesis.describe_stream(StreamName=STREAM_NAME)
shard_iters = []
for shard in response['StreamDescription']['Shards']:
shard_iter_response = kinesis.get_shard_iterator(StreamName=STREAM_NAME, ShardId=shard['ShardId'],
ShardIteratorType='LATEST')
shard_iters.append(shard_iter_response['ShardIterator'])
while len(shard_iters) > 0:
next_shard_iters = []
for shard_iter in shard_iters:
response = kinesis.get_records(ShardIterator=shard_iter, Limit=10000)
for record in response['Records']:
record_data = record['Data']
record_data = json.loads(record_data)
payload_decoded = base64.b64decode(record_data['databaseActivityEvents'])
data_key_decoded = base64.b64decode(record_data['key'])
data_key_decrypt_result = kms.decrypt(CiphertextBlob=data_key_decoded,
EncryptionContext={'aws:rds:dbc-id': RESOURCE_ID})
print (decrypt_decompress(payload_decoded, data_key_decrypt_result['Plaintext']))
if 'NextShardIterator' in response:
next_shard_iters.append(response['NextShardIterator'])
shard_iters = next_shard_iters
if __name__ == '__main__':
main()
```
------
# 資料庫活動串流的 IAM 政策範例
具有資料庫活動串流適當 AWS Identity and Access Management(IAM) 角色權限的任何使用者可以建立、啟動、停止和修改資料庫叢集的活動串流設定。這些動作會包含在串流的稽核日誌中。為了達到最佳合規實務，我們建議您不要將這些權限提供給 DBA。
您可以使用 IAM 政策來設定資料庫活動串流的存取。如需更多有關 Aurora 身分驗證的資訊，請參閱 [Amazon Aurora 的 Identity and access management](UsingWithRDS.IAM.md)。如需建立 IAM 政策的詳細資訊，請參閱 [建立並使用 IAM 政策進行 IAM 資料庫存取](UsingWithRDS.IAMDBAuth.IAMPolicy.md)。
**Example 允許資料庫活動串流設定的原則**
若要提供使用者更精細的存取權來修改活動串流，請在 IAM 政策中使用服務特定操作內容金鑰 `rds:StartActivityStream` 與 `rds:StopActivityStream` 。以下 IAM 政策範例會允許使用者或角色設定活動串流。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ConfigureActivityStreams",
"Effect": "Allow",
"Action": [
"rds:StartActivityStream",
"rds:StopActivityStream"
],
"Resource": "*"
}
]
}
```
**Example 允許資料庫活動串流開始的原則**
以下 IAM 政策範例會允許使用者或角色開始活動串流。
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"AllowStartActivityStreams",
"Effect":"Allow",
"Action":"rds:StartActivityStream",
"Resource":"*"
}
]
}
```
**Example 允許資料庫活動串流停用的原則**
以下 IAM 政策範例會允許使用者或角色停止活動串流。
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"AllowStopActivityStreams",
"Effect":"Allow",
"Action":"rds:StopActivityStream",
"Resource":"*"
}
]
}
```
**Example 拒絕資料庫活動串流開始的原則**
以下 IAM 政策範例會防止使用者或角色開始活動串流。
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"DenyStartActivityStreams",
"Effect":"Deny",
"Action":"rds:StartActivityStream",
"Resource":"*"
}
]
}
```
**Example 拒絕資料庫活動串流停用的原則**
以下 IAM 政策範例會防止使用者或角色停止活動串流。
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"DenyStopActivityStreams",
"Effect":"Deny",
"Action":"rds:StopActivityStream",
"Resource":"*"
}
]
}
```
# 使用 Amazon GuardDuty RDS Protection for Amazon Aurora監控威脅
Amazon GuardDuty 是一種威脅偵測服務，可協助保護您的帳戶、容器、工作負載和 AWS 環境中的資料。GuardDuty 使用機器學習 (ML) 模型，以及異常和威脅偵測功能，持續監控不同的日誌來源和執行時期活動，以識別環境中的潛在安全風險和惡意活動和排定其優先順序。
GuardDuty RDS 保護會分析和描述登入事件，以找出 Amazon Aurora 資料庫的潛在存取威脅。當您開啟 RDS 保護時，GuardDuty 會從 Aurora 資料庫取用 RDS 登入事件。RDS Protection 會監控這些事件並描述它們，以找出潛在的內部威脅或外部演員。
如需了解如何啟用 GuardDuty RDS Protection，請參閱《Amazon GuardDuty 使用者指南》**中的 [GuardDuty RDS Protection](https://docs.aws.amazon.com/guardduty/latest/ug/rds-protection.html)。
當 RDS Protection 偵測到潛在威脅 (例如成功或失敗登入嘗試中的異常模式) 時，GuardDuty 會產生新的問題清單，其中包含可能洩露之資料庫的詳細資訊。您可以在 Amazon GuardDuty 主控台的問題清單摘要區段中檢視問題清單的詳細資料。問題清單的詳細資料會根據問題清單類型而有所不同。主要詳細資訊、資源類型和資源角色會決定所有問題清單可用的資訊種類。如需有關問題清單和問題清單類型的常用詳細資訊，請分別參閱《Amazon GuardDuty 使用者指南》**中的[問題清單詳細資訊](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_findings-summary.html)和 [GuardDuty RDS Protection 問題清單類型](https://docs.aws.amazon.com/guardduty/latest/ug/findings-rds-protection.html)。
您可以在可使用 AWS 區域 此功能的任何 AWS 帳戶 中，開啟或關閉任何 的 RDS 保護功能。RDS 保護未啟用時，GuardDuty 不會偵測可能洩露的 Aurora 資料庫，也不會提供洩露的詳細資訊。
現有的 GuardDuty 帳戶可以在 30 天試用期內啟用 RDS Protection。新 GuardDuty 帳戶的 RDS Protection 已啟用，且包含在 30 天免費試用期內。如需詳細資訊，請參閱《Amazon GuardDuty 使用者指南》**中的[估算 GuardDuty 成本](https://docs.aws.amazon.com/guardduty/latest/ug/monitoring_costs.html)。
如需有關 GuardDuty 尚未支援 RDS 保護 AWS 區域 的 的資訊，請參閱《*Amazon GuardDuty 使用者指南*》中的[區域特定功能可用性](https://docs.aws.amazon.com/guardduty/latest/ug/guardduty_regions.html#gd-regional-feature-availability)。
如需 GuardDuty RDS 保護支援的 Aurora 資料庫版本的資訊，請參閱《Amazon GuardDuty 使用者指南》**中的[支援的 Amazon Aurora、Amazon RDS 和 Aurora Limitless 資料庫](https://docs.aws.amazon.com/guardduty/latest/ug/rds-protection.html#rds-pro-supported-db)。