}
```
以下範例會重點介紹用於條件表達式的區段。
![\[開始使用 AWS DMS\]](http://docs.aws.amazon.com/zh_tw/dms/latest/userguide/images/datarep-Tasks-conditional1.png)
### 使用屬性映射與物件映射
屬性映射讓您使用來源資料行名稱指定範本字串，在目標中重組資料。除使用者在範本中指定的以外，沒有任何格式化。
以下範例顯示來源資料庫的結構以及 DynamoDB 目標所需的架構。首先顯示來源的結構 (本例中為 Oracle 資料庫)，然後顯示 DynamoDB 資料所需的架構。此範例以建立所需目標結構所使用的 JSON 作結。
Oracle 資料的結構如下：
****
| FirstName | LastName | StoreId | HomeAddress | HomePhone | WorkAddress | WorkPhone | DateOfBirth |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 主索引鍵 | N/A | |
| Randy | Marsh | 5 | 221B Baker Street | 1234567890 | 31 Spooner Street, Quahog | 9876543210 | 1988/02/29 |
DynamoDB 資料的結構如下：
****
| CustomerName | StoreId | ContactDetails | DateOfBirth |
| --- | --- | --- | --- |
| 分割區索引鍵 | 排序索引鍵 | N/A |
| Randy,Marsh
| 5
| {
"Name": "Randy",
"Home": {
"Address": "221B Baker Street",
"Phone": 1234567890
},
"Work": {
"Address": "31 Spooner Street, Quahog",
"Phone": 9876541230
}
} | 02/29/1988
|
下列 JSON 顯示完成 DynamoDB 結構所使用的物件映射和資料行映射：
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "object-mapping",
"rule-id": "2",
"rule-name": "TransformToDDB",
"rule-action": "map-record-to-record",
"object-locator": {
"schema-name": "test",
"table-name": "customer"
},
"target-table-name": "customer_t",
"mapping-parameters": {
"partition-key-name": "CustomerName",
"sort-key-name": "StoreId",
"exclude-columns": [
"FirstName",
"LastName",
"HomeAddress",
"HomePhone",
"WorkAddress",
"WorkPhone"
],
"attribute-mappings": [
{
"target-attribute-name": "CustomerName",
"attribute-type": "scalar",
"attribute-sub-type": "string",
"value": "${FirstName},${LastName}"
},
{
"target-attribute-name": "StoreId",
"attribute-type": "scalar",
"attribute-sub-type": "string",
"value": "${StoreId}"
},
{
"target-attribute-name": "ContactDetails",
"attribute-type": "scalar",
"attribute-sub-type": "string",
"value": "{\"Name\":\"${FirstName}\",\"Home\":{\"Address\":\"${HomeAddress}\",\"Phone\":\"${HomePhone}\"}, \"Work\":{\"Address\":\"${WorkAddress}\",\"Phone\":\"${WorkPhone}\"}}"
}
]
}
}
]
}
```
資料行映射的另一個使用方法是使用 DynamoDB 格式做為您的文件類型。以下程式碼範例使用 *dynamodb-map* 做為屬性映射的 `attribute-sub-type`。
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "object-mapping",
"rule-id": "2",
"rule-name": "TransformToDDB",
"rule-action": "map-record-to-record",
"object-locator": {
"schema-name": "test",
"table-name": "customer"
},
"target-table-name": "customer_t",
"mapping-parameters": {
"partition-key-name": "CustomerName",
"sort-key-name": "StoreId",
"exclude-columns": [
"FirstName",
"LastName",
"HomeAddress",
"HomePhone",
"WorkAddress",
"WorkPhone"
],
"attribute-mappings": [
{
"target-attribute-name": "CustomerName",
"attribute-type": "scalar",
"attribute-sub-type": "string",
"value": "${FirstName},${LastName}"
},
{
"target-attribute-name": "StoreId",
"attribute-type": "scalar",
"attribute-sub-type": "string",
"value": "${StoreId}"
},
{
"target-attribute-name": "ContactDetails",
"attribute-type": "document",
"attribute-sub-type": "dynamodb-map",
"value": {
"M": {
"Name": {
"S": "${FirstName}"
},
"Home": {
"M": {
"Address": {
"S": "${HomeAddress}"
},
"Phone": {
"S": "${HomePhone}"
}
}
},
"Work": {
"M": {
"Address": {
"S": "${WorkAddress}"
},
"Phone": {
"S": "${WorkPhone}"
}
}
}
}
}
}
]
}
}
]
}
```
作為 `dynamodb-map` 的替代方案，您可以如下列範例所示，使用 `dynamodb-list` 作為屬性映射的 attribute-sub-type。
```
{
"target-attribute-name": "ContactDetailsList",
"attribute-type": "document",
"attribute-sub-type": "dynamodb-list",
"value": {
"L": [
{
"N": "${FirstName}"
},
{
"N": "${HomeAddress}"
},
{
"N": "${HomePhone}"
},
{
"N": "${WorkAddress}"
},
{
"N": "${WorkPhone}"
}
]
}
}
```
### 範例 1：使用屬性映射與物件映射
以下範例會將資料從兩個 MySQL 資料庫資料表 *nfl\$1data* 和 *sport\$1team* 遷移到兩個 DynamoDB 資料表 *NFLTeams* 和 *SportTeams*。將資料從 MySQL 資料庫資料表映射到 DynamoDB 資料表所使用的資料表結構和 JSON，如下所示。
MySQL 資料庫資料表 *nfl\$1data* 的結構如下所示：
```
mysql> desc nfl_data;
+---------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+---------------+-------------+------+-----+---------+-------+
| Position | varchar(5) | YES | | NULL | |
| player_number | smallint(6) | YES | | NULL | |
| Name | varchar(40) | YES | | NULL | |
| status | varchar(10) | YES | | NULL | |
| stat1 | varchar(10) | YES | | NULL | |
| stat1_val | varchar(10) | YES | | NULL | |
| stat2 | varchar(10) | YES | | NULL | |
| stat2_val | varchar(10) | YES | | NULL | |
| stat3 | varchar(10) | YES | | NULL | |
| stat3_val | varchar(10) | YES | | NULL | |
| stat4 | varchar(10) | YES | | NULL | |
| stat4_val | varchar(10) | YES | | NULL | |
| team | varchar(10) | YES | | NULL | |
+---------------+-------------+------+-----+---------+-------+
```
MySQL 資料庫資料表 *sport\$1team* 的結構如下所示：
```
mysql> desc sport_team;
+---------------------------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+---------------------------+--------------+------+-----+---------+----------------+
| id | mediumint(9) | NO | PRI | NULL | auto_increment |
| name | varchar(30) | NO | | NULL | |
| abbreviated_name | varchar(10) | YES | | NULL | |
| home_field_id | smallint(6) | YES | MUL | NULL | |
| sport_type_name | varchar(15) | NO | MUL | NULL | |
| sport_league_short_name | varchar(10) | NO | | NULL | |
| sport_division_short_name | varchar(10) | YES | | NULL | |
```
將兩份資料表映射到兩份 DynamoDB 資料表所用的資料表映射規則，如下所示：
```
{
"rules":[
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "dms_sample",
"table-name": "nfl_data"
},
"rule-action": "include"
},
{
"rule-type": "selection",
"rule-id": "2",
"rule-name": "2",
"object-locator": {
"schema-name": "dms_sample",
"table-name": "sport_team"
},
"rule-action": "include"
},
{
"rule-type":"object-mapping",
"rule-id":"3",
"rule-name":"MapNFLData",
"rule-action":"map-record-to-record",
"object-locator":{
"schema-name":"dms_sample",
"table-name":"nfl_data"
},
"target-table-name":"NFLTeams",
"mapping-parameters":{
"partition-key-name":"Team",
"sort-key-name":"PlayerName",
"exclude-columns": [
"player_number", "team", "name"
],
"attribute-mappings":[
{
"target-attribute-name":"Team",
"attribute-type":"scalar",
"attribute-sub-type":"string",
"value":"${team}"
},
{
"target-attribute-name":"PlayerName",
"attribute-type":"scalar",
"attribute-sub-type":"string",
"value":"${name}"
},
{
"target-attribute-name":"PlayerInfo",
"attribute-type":"scalar",
"attribute-sub-type":"string",
"value":"{\"Number\": \"${player_number}\",\"Position\": \"${Position}\",\"Status\": \"${status}\",\"Stats\": {\"Stat1\": \"${stat1}:${stat1_val}\",\"Stat2\": \"${stat2}:${stat2_val}\",\"Stat3\": \"${stat3}:${
stat3_val}\",\"Stat4\": \"${stat4}:${stat4_val}\"}"
}
]
}
},
{
"rule-type":"object-mapping",
"rule-id":"4",
"rule-name":"MapSportTeam",
"rule-action":"map-record-to-record",
"object-locator":{
"schema-name":"dms_sample",
"table-name":"sport_team"
},
"target-table-name":"SportTeams",
"mapping-parameters":{
"partition-key-name":"TeamName",
"exclude-columns": [
"name", "id"
],
"attribute-mappings":[
{
"target-attribute-name":"TeamName",
"attribute-type":"scalar",
"attribute-sub-type":"string",
"value":"${name}"
},
{
"target-attribute-name":"TeamInfo",
"attribute-type":"scalar",
"attribute-sub-type":"string",
"value":"{\"League\": \"${sport_league_short_name}\",\"Division\": \"${sport_division_short_name}\"}"
}
]
}
}
]
}
```
*NFLTeams* DynamoDB 資料表的輸出範例如下所示：
```
"PlayerInfo": "{\"Number\": \"6\",\"Position\": \"P\",\"Status\": \"ACT\",\"Stats\": {\"Stat1\": \"PUNTS:73\",\"Stat2\": \"AVG:46\",\"Stat3\": \"LNG:67\",\"Stat4\": \"IN 20:31\"}",
"PlayerName": "Allen, Ryan",
"Position": "P",
"stat1": "PUNTS",
"stat1_val": "73",
"stat2": "AVG",
"stat2_val": "46",
"stat3": "LNG",
"stat3_val": "67",
"stat4": "IN 20",
"stat4_val": "31",
"status": "ACT",
"Team": "NE"
}
```
SportsTeams *DynamoDB* 資料表的輸出範例如下所示：
```
{
"abbreviated_name": "IND",
"home_field_id": 53,
"sport_division_short_name": "AFC South",
"sport_league_short_name": "NFL",
"sport_type_name": "football",
"TeamInfo": "{\"League\": \"NFL\",\"Division\": \"AFC South\"}",
"TeamName": "Indianapolis Colts"
}
```
## DynamoDB 的目標資料類型
的 DynamoDB 端點 AWS DMS 支援大多數 DynamoDB 資料類型。下表顯示使用 時支援的 Amazon AWS DMS 目標資料類型， AWS DMS 以及來自 AWS DMS 資料類型的預設映射。
如需 AWS DMS 資料類型的詳細資訊，請參閱 [AWS Database Migration Service 的資料類型](CHAP_Reference.DataTypes.md)。
當 從異質資料庫 AWS DMS 遷移資料時，我們會將資料類型從來源資料庫映射到稱為 AWS DMS 資料類型的中繼資料類型。然後，我們會將中繼資料類型映射到目標資料類型。下表顯示每個 AWS DMS 資料類型及其在 DynamoDB 中對應的資料類型：
| AWS DMS 資料類型 | DynamoDB 資料類型 |
| --- | --- |
| String | String |
| WString | String |
| Boolean | Boolean |
| 日期 | String |
| DateTime | String |
| INT1 | Number |
| INT2 | Number |
| INT4 | Number |
| INT8 | Number |
| 數值 | Number |
| Real4 | Number |
| Real8 | Number |
| UINT1 | Number |
| UINT2 | Number |
| UINT4 | Number |
| UINT8 | Number |
| CLOB | String |
# 使用 Amazon Kinesis Data Streams 作為 的目標 AWS Database Migration Service
您可以使用 AWS DMS 將資料遷移至 Amazon Kinesis 資料串流。Amazon Kinesis Data Streams 服務是 Amazon Kinesis Data Streams 服務的一部分。您可以使用 Kinesis 資料串流即時收集並處理大型的資料記錄串流。
Kinesis 資料串流是碎片構成。*碎片*是串流中資料記錄的唯一識別序列。如需 Amazon Kinesis Data Streams 中碎片的詳細資訊，請參閱《Amazon Kinesis Data Streams 開發人員指南》**中的[碎片](https://docs.aws.amazon.com/streams/latest/dev/key-concepts.html#shard)。
AWS Database Migration Service 使用 JSON 將記錄發佈至 Kinesis 資料串流。在轉換過程中， AWS DMS 會將來源資料庫中的每筆記錄序列化為 JSON 格式或 JSON\$1UNFORMATTED 訊息格式的屬性/值對。JSON\$1UNFORMATTED 訊息格式為含新行分隔符號的單行 JSON 字串。它允許 Amazon Data Firehose 將 Kinesis 資料交付至 Amazon S3 目的地，然後使用包括 Amazon Athena 在內的各種查詢引擎進行查詢。
您要使用物件映射將資料從任何受支援的資料來源遷移到目標串流。使用物件映射，您可以決定如何建構串流中的資料記錄。您也可以定義每份資料表的分割區索引鍵，Kinesis Data Stream 會用其將資料分組為碎片。
AWS DMS 也會設定數個 Kinesis Data Streams 參數值。資料表的建立成本取決於要遷移的資料量和資料表數量。
**注意**
AWS DMS 主控台或 API 上的 **SSL 模式**選項不適用於某些資料串流和 NoSQL 服務，例如 Kinesis 和 DynamoDB。根據預設，它們是安全的，因此 AWS DMS 顯示 SSL 模式設定等於無 (**SSL 模式=無**)。您無需為端點提供任何其他組態即可使用 SSL。例如，使用 Kinesis 作為目標端點時，預設情況下其是安全的。所有對 Kinesis 的 API 呼叫都使用 SSL，因此端點中不需要額外的 SSL 選項 AWS DMS 。您可以使用 HTTPS 通訊協定 ( AWS DMS 在連線到 Kinesis Data Stream 時預設使用的通訊協定)，透過 SSL 端點安全地放置和擷取資料。
**Kinesis Data Streams 端點設定**
當您使用 Kinesis Data Streams 目標端點時，您可以使用 AWS DMS API 中的 `KinesisSettings`選項來取得交易和控制詳細資訊。
您可透過以下任一種方式來設定連線設定：
+ 在 AWS DMS 主控台中，使用端點設定。
+ 在 CLI 中，使用 [CreateEndpoint](https://docs.aws.amazon.com/dms/latest/APIReference/API_CreateEndpoint.html) 命令的 `kinesis-settings` 選項。
在 CLI 中，使用 `kinesis-settings` 選項的以下請求參數：
**注意**
AWS DMS 3.4.1 版及更高版本中提供 `IncludeNullAndEmpty` 端點設定的支援。但是， 支援 Kinesis Data Streams 目標的其他下列端點設定 AWS DMS。
+ `MessageFormat` – 在端點建立之記錄的輸出格式。訊息格式為 `JSON` (預設) 或 `JSON_UNFORMATTED` (不含製表符的單行)。
+ `IncludeControlDetails`：在 Kinesis 訊息輸出中，顯示資料表定義、欄位定義以及資料表和欄位變更的詳細控制資訊。預設值為 `false`。
+ `IncludeNullAndEmpty`：包含目標中的 NULL 和空資料欄。預設值為 `false`。
+ `IncludePartitionValue`：除非磁碟分割類型為 `schema-table-type`，否則會在 Kinesis 訊息輸出中顯示磁碟分割值。預設值為 `false`。
+ `IncludeTableAlterOperations` – 包含變更控制資料中資料表的任何資料定義語言 (DDL) 操作，例如 `rename-table`、`drop-table`、`add-column`、`drop-column` 和 `rename-column`。預設值為 `false`。
+ `IncludeTransactionDetails` – 提供來源資料庫的詳細交易資訊。此資訊包括遞交時間戳記、記錄位置，以及 `transaction_id`、`previous_transaction_id`，和 `transaction_record_id ` (交易內的記錄位移) 的值。預設值為 `false`。
+ `PartitionIncludeSchemaTable` – 當磁碟分割類型為 `primary-key-type` 時，將結構描述和資料表名稱作為磁碟分割值的前綴。這樣做會增加 Kinesis 碎片之間的資料分佈。例如，假設 `SysBench` 結構描述有數千個資料表，而每個資料表的主索引鍵只有有限的範圍。在這種情況下，相同的主索引鍵會從數千個資料表發送到相同的碎片，而這將導致調節。預設值為 `false`。
+ `UseLargeIntegerValue` – 使用最多 18 位數的整數，而不是將整數轉換為雙位元，可從 3.5.4 AWS DMS 版取得。預設值為 false。
下列範例顯示使用中的 `kinesis-settings` 選項與使用 AWS CLI發出的範例 `create-endpoint` 命令。
```
aws dms \
create-endpoint \
--region \
--endpoint-identifier \
--endpoint-type target \
--engine-name kinesis \
--kinesis-settings ServiceAccessRoleArn=arn:aws:iam:::role/,StreamArn=arn:aws:kinesis:::stream/,MessageFormat=json-unformatted,
IncludeControlDetails=true,IncludeTransactionDetails=true,IncludePartitionValue=true,PartitionIncludeSchemaTable=true,
IncludeTableAlterOperations=true
```
**多執行緒完全載入任務設定**
為了協助提高傳輸速度， AWS DMS 支援對 Kinesis Data Streams 目標執行個體進行多執行緒完全載入。DMS 使用包括下列項目的任務設定來支援此多執行緒操作：
+ `MaxFullLoadSubTasks`：使用此選項，指出要平行載入的來源資料表數目上限。DMS 會使用專用子任務，將每個資料表載入到其對應的 Kinesis 目標資料表。預設值為 8；最大值為 49。
+ `ParallelLoadThreads` – 使用此選項指定 AWS DMS 用來將每個資料表載入其 Kinesis 目標資料表的執行緒數目。Kinesis Data Streams 目標的最大值為 32。您可以要求提高此上限。
+ `ParallelLoadBufferSize`：使用此選項，指定要在平行載入執行緒用來將資料載入至 Kinesis 目標的緩衝區中儲存的記錄數量上限。預設值為 50。最大值為 1000。使用此設定搭配 `ParallelLoadThreads`；`ParallelLoadBufferSize`，只有在有多個執行緒時才有效。
+ `ParallelLoadQueuesPerThread`：使用此選項指定每個並行執行緒存取的佇列數目，以便將資料記錄從佇列中取出，並為目標產生批次載入。預設為 1。但是，對於各種承載大小的 Kinesis 目標，有效範圍為每個執行緒 5–512 個佇列。
**多執行緒 CDC 載入任務設定**
您可以使用任務設定，提升 Kinesis 等即時資料串流目標端點的變更資料擷取 (CDC) 效能，從而修改 `PutRecords` API 呼叫行為。若要執行此操作，您可以指定並行執行緒數目、每個執行緒的佇列數，以及使用 `ParallelApply*` 任務設定儲存在緩衝區中的記錄數目。例如，假設您要執行 CDC 載入並平行套用 128 個執行緒。您也想要每個執行緒存取 64 個佇列，且每個緩衝區儲存 50 筆記錄。
為了提升 CDC 效能， AWS DMS 支援下列任務設定：
+ `ParallelApplyThreads` – 指定在 CDC 載入期間 AWS DMS 用來將資料記錄推送至 Kinesis 目標端點的並行執行緒數目。預設值為零 (0)，最大值為 32。
+ `ParallelApplyBufferSize`：指定每個緩衝區佇列中儲存的最大記錄數目，以便並行執行緒在 CDC 載入期間推送至 Kinesis 目標端點。預設值為 100，最大值為 1,000。`ParallelApplyThreads` 指定多個執行緒時，請使用此選項。
+ `ParallelApplyQueuesPerThread`：指定每個執行緒存取的佇列數目，以便從佇列中取出資料記錄，並在 CDC 期間產生 Kinesis 端點的批次載入。預設值為 １，最大值為 512。
在使用 `ParallelApply*` 任務設定時，`partition-key-type` 預設是資料表的 `primary-key`，而非 `schema-name.table-name`。
## 使用前映像檢視作為目標之 Kinesis 資料串流的 CDC 列原始值
將 CDC 更新寫入至 Kinesis 等資料串流目標時，您可以在更新進行變更前，檢視來源資料庫列的原始值。為了實現這一點， 會根據來源資料庫引擎提供的資料， AWS DMS 填入更新事件*之前的映像*。
不同的來源資料庫引擎可提供不同的前映像資訊量：
+ Oracle 僅提供欄更新 (如果有變更的話)。
+ PostgreSQL 僅提供屬於主索引鍵一部分的欄的資料 (無論是否有變更)。若要提供所有資料欄的資料 (無論是否已變更)，您需要將 `REPLICA_IDENTITY` 設為 `FULL` (而非 `DEFAULT`)。請注意，您應該仔細選擇每個資料表的 `REPLICA_IDENTITY` 設定。如果將 `REPLICA_IDENTITY` 設為 `FULL`，所有的資料欄值都會連續寫入預寫記錄 (WAL)。這可能會對經常更新的資料表造成效能或資源問題。
+ MySQL 一般會提供所有欄的資料，但 BLOB 和 CLOB 資料類型除外 (無論是否有變更)。
若要啟用前映像功能以從來源資料庫將原始值新增至 AWS DMS 輸出，請使用 `BeforeImageSettings` 任務設定或 `add-before-image-columns` 參數。此參數會套用欄轉換規則。
`BeforeImageSettings` 會使用從來源資料庫系統收集到的值，將新的 JSON 屬性新增至所有更新操作，如下所示。
```
"BeforeImageSettings": {
"EnableBeforeImage": boolean,
"FieldName": string,
"ColumnFilter": pk-only (default) / non-lob / all (but only one)
}
```
**注意**
僅適用於包含 CDC 元件`BeforeImageSettings` AWS DMS 的任務，例如完全載入加上 CDC 任務 （遷移現有資料並複寫持續變更），或僅適用於 CDC 的任務 （僅複寫資料變更）。請勿將 `BeforeImageSettings` 套用至僅限完全載入的任務。
針對 `BeforeImageSettings` 選項，適用的設定如下：
+ 將 `EnableBeforeImage` 選項設為 `true` 以啟用前映像功能。預設值為 `false`。
+ 使用 `FieldName` 選項，將名稱指派給新的 JSON 屬性。若 `EnableBeforeImage` 為 `true`，`FieldName` 則為必填，且不能留白。
+ `ColumnFilter` 選項會使用前映像來指定要新增的欄。若只要新增屬於資料表主索引鍵一部分的欄，請使用預設值 `pk-only`。若要新增任何具有前映像值的欄，請使用 `all`。請注意，前映像不包含具有 LOB 資料類型的資料欄，例如 CLOB 或 BLOB。
```
"BeforeImageSettings": {
"EnableBeforeImage": true,
"FieldName": "before-image",
"ColumnFilter": "pk-only"
}
```
**注意**
Amazon S3 目標不支援 `BeforeImageSettings`。針對 S3 目標，請僅使用 `add-before-image-columns` 轉換規則，以在 CDC 期間執行前映像功能。
### 使用前映像轉換規則
您可使用 `add-before-image-columns` 參數做為任務設定的替代方式，它會套用欄轉換規則。透過此參數，您可以在 Kinesis 等資料串流目標上，在 CDC 期間啟用前映像功能。
只要在轉換規則中使用 `add-before-image-columns`，即可套用前映像結果的更精細的控制。轉換規則可讓您使用物件定位器，以便掌控針對規則選取的資料表。此外，您可以將轉換規則鏈結在一起，讓不同的規則套用至不同的資料表。接著，您可以使用其他規則來操控產生的欄。
**注意**
請勿在同一個任務內將 `add-before-image-columns` 參數與 `BeforeImageSettings` 任務設定一起搭配使用。請改為將參數或設定 (擇一使用，而非兩者同時使用) 用於單一任務。
具有欄的 `add-before-image-columns` 參數的 `transformation` 規則類型必須提供 `before-image-def` 區段。下列顯示一個範例。
```
{
"rule-type": "transformation",
…
"rule-target": "column",
"rule-action": "add-before-image-columns",
"before-image-def":{
"column-filter": one-of (pk-only / non-lob / all),
"column-prefix": string,
"column-suffix": string,
}
}
```
`column-prefix` 的值會附加至欄名稱前，而`column-prefix` 的預設值為 `BI_`。`column-suffix` 的值會附加至欄名稱，而預設值為空白。請勿將 `column-prefix` 和 `column-suffix` 同時設為空白字串。
為 `column-filter` 選擇一個值。若只要新增屬於資料表主索引鍵一部分的欄，請選擇 `pk-only`。選擇 `non-lob` 以僅新增不屬於 LOB 類型的欄。或者，選擇 `all` 以新增任何具有前映像值的欄。
### 前映像轉換規則範例
下列範例中的轉換規則會在目標中新增名為 `BI_emp_no` 的欄。因此，`UPDATE employees SET emp_no = 3 WHERE emp_no = 1;` 等陳述式會以 1 填入 `BI_emp_no` 欄位。當您將 CDC 更新寫入至 Amazon S3 目標時，`BI_emp_no` 資料欄會讓它能夠分辨哪個原始列已更新。
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "employees"
},
"rule-action": "add-before-image-columns",
"before-image-def": {
"column-prefix": "BI_",
"column-suffix": "",
"column-filter": "pk-only"
}
}
]
}
```
如需使用 `add-before-image-columns` 規則動作的相關資訊，請參閱[轉換規則與動作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)。
## 使用 Kinesis 資料串流做為 目標的先決條件 AWS Database Migration Service
### 使用 Kinesis 資料串流做為 目標的 IAM 角色 AWS Database Migration Service
將 Kinesis 資料串流設定為 的目標之前 AWS DMS，請務必建立 IAM 角色。此角色必須允許 AWS DMS 擔任並授予要遷移至其中的 Kinesis 資料串流存取權。以下 IAM 政策顯示最低的存取許可集。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "1",
"Effect": "Allow",
"Principal": {
"Service": "dms.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
遷移到 Kinesis 資料串流所用的角色必須擁有下列許可。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:DescribeStream",
"kinesis:PutRecord",
"kinesis:PutRecords"
],
"Resource": "*"
}
]
}
```
------
### 存取 Kinesis 資料串流做為 的目標 AWS Database Migration Service
在 3.4.7 版和更新 AWS DMS 版本中，若要連線至 Kinesis 端點，您必須執行下列其中一項操作：
+ 將 DMS 設定為使用 VPC 端點。如需有關設定 DMS 以使用 VPC 端點的詳細資訊，請參閱 [設定 的 VPC 端點 AWS DMS](CHAP_VPC_Endpoints.md)。
+ 將 DMS 設定為使用公用路由，也就是將您的複寫執行個體設為公用。如需公用複寫執行個體的詳細資訊，請參閱 [公有和私有複寫執行個體](CHAP_ReplicationInstance.PublicPrivate.md)。
## 使用 Kinesis Data Streams 做為 目標的限制 AWS Database Migration Service
使用 Kinesis Data Streams 作為目標時，有下列限制：
+ AWS DMS 會將每個更新發佈至來源資料庫中的單一記錄，做為指定 Kinesis 資料串流中的一個資料記錄，無論交易為何。不過，您可以使用 `KinesisSettings` API 的相關參數來包含每個資料記錄的交易詳細資訊。
+ 不支援完全的 LOB 模式。
+ 支援的 LOB 大小上限是 1 MB。
+ Kinesis Data Streams 不支援刪除重複資料。取用串流資料的應用程式需要處理重複的記錄。如需的詳細資訊，請參閱《Amazon Kinesis Data Streams 開發人員指南》**中的[處理重複的記錄](https://docs.aws.amazon.com/streams/latest/dev/kinesis-record-processor-duplicates.html)。
+ AWS DMS 支援下列四種形式的分割區索引鍵：
+ `SchemaName.TableName`：結構描述和資料表名稱的組合。
+ `${AttributeName}`：JSON 其中一個欄位的值，或來源資料庫資料表的主索引鍵。
+ `transaction-id`：CDC 交易 ID。相同交易中的所有記錄都會移至相同的分割區。
+ `constant`：無論資料表或資料為何，每個記錄的固定常值。所有記錄都會傳送至相同的分割區索引鍵值「常數」，在所有資料表中提供嚴格的全域排序。
```
{
"rule-type": "object-mapping",
"rule-id": "2",
"rule-name": "PartitionKeyTypeExample",
"rule-action": "map-record-to-document",
"object-locator": {
"schema-name": "onprem",
"table-name": "it_system"
},
"mapping-parameters": {
"partition-key-type": "transaction-id | constant | attribute-name | schema-table"
}
}
```
+ 如需在 Kinesis Data Streams 中加密靜態資料的相關資訊，請參閱《AWS Key Management Service 開發人員指南》**中的 [Kinesis Data Streams 中的資料保護](https://docs.aws.amazon.com/streams/latest/dev/server-side-encryption.html.html)。
+ 只有在來源`IncludeTransactionDetails`端點為 Oracle、SQL Server、PostgreSQL 或 MySQL 時，才支援端點設定。對於其他來源端點類型，不會包含交易詳細資訊。
+ Kinesis 端點不支援 `BatchApply`。針對 Kinesis 目標使用批次套用 （例如，`BatchApplyEnabled`目標中繼資料任務設定） 會導致任務失敗和資料遺失。使用 Kinesis 做為目標端點`BatchApply`時，請勿啟用 。
+ Kinesis 目標僅支援相同 AWS 帳戶中與複寫執行個體相同的 AWS 區域 Kinesis 資料串流。
+ 從 MySQL 來源遷移時，BeforeImage 資料不包括 CLOB 和 BLOB 資料類型。如需詳細資訊，請參閱[使用前映像檢視作為目標之 Kinesis 資料串流的 CDC 列原始值](#CHAP_Target.Kinesis.BeforeImage)。
+ AWS DMS 不支援遷移超過 16 位數的`BigInt`資料類型值。若要解決此限制，您可以使用下列轉換規則將 `BigInt` 資料欄轉換為字串。如需轉換規則的詳細資訊，請參閱 [轉換規則與動作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)。
```
{
"rule-type": "transformation",
"rule-id": "id",
"rule-name": "name",
"rule-target": "column",
"object-locator": {
"schema-name": "valid object-mapping rule action",
"table-name": "",
"column-name": ""
},
"rule-action": "change-data-type",
"data-type": {
"type": "string",
"length": 20
}
}
```
+ 當單一交易中的多個 DML 操作修改來源資料庫上的大型物件 (LOB) 資料欄時，目標資料庫只會保留該交易中最後一個操作的最終 LOB 值。相同交易中先前操作所設定的中繼 LOB 值會被覆寫，這可能會導致潛在的資料遺失或不一致。由於複寫期間處理 LOB 資料的方式，因此會發生此行為。
+ AWS DMS 使用 Kinesis 做為目標端點時， 不支援包含內嵌`'\0'`字元的來源資料。包含內嵌`'\0'`字元的資料會在第一個`'\0'`字元被截斷。
## 使用物件映射將資料遷移到 Kinesis 資料串流
AWS DMS 使用資料表映射規則，將資料從來源映射到目標 Kinesis 資料串流。若要將資料映射到目標串流，您要使用一種稱為物件映射的資料表映射規則。您使用物件映射定義如何將來源資料記錄映射到發佈在 Kinesis 資料串流的資料記錄。
除了擁有分割區索引鍵外，Kinesis 資料串流沒有預設結構。在物件映射規則中，資料記錄 `partition-key-type` 的可能值為 `schema-table`、`transaction-id`、`primary-key`、`constant` 和 `attribute-name`。
若要建立物件映射規則，請將 `rule-type` 指定為 `object-mapping`。此規則指定您想要使用的物件映射類型。
規則的結構如下。
```
{
"rules": [
{
"rule-type": "object-mapping",
"rule-id": "id",
"rule-name": "name",
"rule-action": "valid object-mapping rule action",
"object-locator": {
"schema-name": "case-sensitive schema name",
"table-name": ""
}
}
]
}
```
AWS DMS 目前支援 `map-record-to-record`和 `map-record-to-document`做為 `rule-action` 參數的唯一有效值。這些設定會影響 `exclude-columns` 屬性清單中未排除的值。`map-record-to-record` 和 `map-record-to-document`值預設會指定 AWS DMS 如何處理這些記錄。這些值反正不會影響屬性映射。
從關聯式資料庫遷移到 Kinesis 資料串流時，請使用 `map-record-to-record`。此規則類型使用關聯式資料庫的 `taskResourceId.schemaName.tableName` 值作為 Kinesis 資料串流的分割區索引鍵，並為來源資料庫中的每一資料行建立一個屬性。
使用 `map-record-to-record` 時，請注意下列事項：
+ 此設定只會影響 `exclude-columns` 清單中排除的欄。
+ 對於每個這類資料欄， 會在目標主題中 AWS DMS 建立對應的屬性。
+ AWS DMS 無論屬性映射中是否使用來源資料欄， 都會建立此對應的屬性。
使用 `map-record-to-document` 將來源資料欄放入使用屬性名稱「\$1doc」的適當目標串流中的單一固定文件。 AWS DMS 將資料放置在名為 "`_doc`" 之來源上的單一固定對應中。此放置適用於來源資料表中未列在 `exclude-columns` 屬性清單的任何欄。
了解 `map-record-to-record` 的一種方法是查看它運作時的狀態。在本範例中，假設您開始使用之關聯式資料庫資料表資料列的結構和資料如下。
| FirstName | LastName | StoreId | HomeAddress | HomePhone | WorkAddress | WorkPhone | DateofBirth |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Randy | Marsh | 5 | 221B Baker Street | 1234567890 | 31 Spooner Street, Quahog | 9876543210 | 1988/02/29 |
若要將此資訊從名為 `Test` 的結構描述遷移到 Kinesis 資料串流，您要建立規則，以將資料映射到目標串流。以下規則說明映射。
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"rule-action": "include",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
}
},
{
"rule-type": "object-mapping",
"rule-id": "2",
"rule-name": "DefaultMapToKinesis",
"rule-action": "map-record-to-record",
"object-locator": {
"schema-name": "Test",
"table-name": "Customers"
}
}
]
}
```
以下說明在 Kinesis 資料串流中產生的記錄格式：
+ StreamName：XXX
+ PartitionKey：Test.Customers //schmaName.tableName
+ Data：//以下 JSON 訊息
```
{
"FirstName": "Randy",
"LastName": "Marsh",
"StoreId": "5",
"HomeAddress": "221B Baker Street",
"HomePhone": "1234567890",
"WorkAddress": "31 Spooner Street, Quahog",
"WorkPhone": "9876543210",
"DateOfBirth": "02/29/1988"
}
```
但是，假設您使用相同的規則，但將 `rule-action` 參數變更為 `map-record-to-document` 並排除某些資料欄。以下規則說明映射。
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"rule-action": "include",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
}
},
{
"rule-type": "object-mapping",
"rule-id": "2",
"rule-name": "DefaultMapToKinesis",
"rule-action": "map-record-to-document",
"object-locator": {
"schema-name": "Test",
"table-name": "Customers"
},
"mapping-parameters": {
"exclude-columns": [
"homeaddress",
"homephone",
"workaddress",
"workphone"
]
}
}
]
}
```
在本例中，未列在 `exclude-columns` 參數 `FirstName`、`LastName`、`StoreId` 和 `DateOfBirth` 中的資料欄會對應到 `_doc`。以下說明產生的記錄格式。
```
{
"data":{
"_doc":{
"FirstName": "Randy",
"LastName": "Marsh",
"StoreId": "5",
"DateOfBirth": "02/29/1988"
}
}
}
```
### 使用屬性映射重組資料
您可以在使用屬性映射將資料遷移到 Kinesis 資料串流的同時，重組資料。例如，您可能想要將來源的幾個欄位合併為目標的單一欄位。以下屬性映射說明如何重組資料。
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"rule-action": "include",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
}
},
{
"rule-type": "object-mapping",
"rule-id": "2",
"rule-name": "TransformToKinesis",
"rule-action": "map-record-to-record",
"target-table-name": "CustomerData",
"object-locator": {
"schema-name": "Test",
"table-name": "Customers"
},
"mapping-parameters": {
"partition-key-type": "attribute-name",
"partition-key-name": "CustomerName",
"exclude-columns": [
"firstname",
"lastname",
"homeaddress",
"homephone",
"workaddress",
"workphone"
],
"attribute-mappings": [
{
"target-attribute-name": "CustomerName",
"attribute-type": "scalar",
"attribute-sub-type": "string",
"value": "${lastname}, ${firstname}"
},
{
"target-attribute-name": "ContactDetails",
"attribute-type": "document",
"attribute-sub-type": "json",
"value": {
"Home": {
"Address": "${homeaddress}",
"Phone": "${homephone}"
},
"Work": {
"Address": "${workaddress}",
"Phone": "${workphone}"
}
}
}
]
}
}
]
}
```
若要設定 的常數值`partition-key`，請指定 `"partition-key-type: "constant"`，這會將分割區值設定為 `constant`。例如，您可以執行此操作，將所有資料強制儲存在單一碎片中。以下映射說明此方法。
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "object-mapping",
"rule-id": "2",
"rule-name": "TransformToKinesis",
"rule-action": "map-record-to-document",
"object-locator": {
"schema-name": "Test",
"table-name": "Customer"
},
"mapping-parameters": {
"partition-key-type": "constant",
"exclude-columns": [
"FirstName",
"LastName",
"HomeAddress",
"HomePhone",
"WorkAddress",
"WorkPhone"
],
"attribute-mappings": [
{
"target-attribute-name": "CustomerName",
"attribute-type": "scalar",
"attribute-sub-type": "string",
"value": "${FirstName},${LastName}"
},
{
"target-attribute-name": "ContactDetails",
"attribute-type": "scalar",
"attribute-sub-type": "string",
"value": {
"Home": {
"Address": "${HomeAddress}",
"Phone": "${HomePhone}"
},
"Work": {
"Address": "${WorkAddress}",
"Phone": "${WorkPhone}"
}
}
},
{
"target-attribute-name": "DateOfBirth",
"attribute-type": "scalar",
"attribute-sub-type": "string",
"value": "${DateOfBirth}"
}
]
}
}
]
}
```
**注意**
用於特定資料表的控制記錄 `partition-key` 值是 `TaskId.SchemaName.TableName`。用於特定任務的控制記錄 `partition-key` 值是該記錄的 `TaskId`。在物件映射中指定 `partition-key` 值對控制記錄的 `partition-key` 沒有影響。
在資料表映射規則`attribute-name`中`partition-key-type`將 設定為 時，您必須指定 `partition-key-name`，其必須參考來源資料表中的資料欄或映射中定義的自訂資料欄。此外，`attribute-mappings`必須提供 來定義來源資料欄如何對應至目標 Kinesis Stream。
### Kinesis Data Streams 的訊息格式
JSON 輸出僅是索引鍵/值對的清單。JSON\$1UNFORMATTED 訊息格式為含新行分隔符號的單行 JSON 字串。
AWS DMS 提供下列預留欄位，讓您更輕鬆地使用 Kinesis Data Streams 中的資料：
**RecordType**
記錄類型可以是資料或控制。*資料記錄*代表來源的實際資料列。*控制記錄*用於串流的重要事件，例如重新啟動任務。
**作業**
針對資料記錄，操作可以是 `load`、`insert`、`update` 或 `delete`。
針對控制記錄，操作可以是 `create-table`、`rename-table`、`drop-table`、`change-columns`、`add-column`、`drop-column`、`rename-column` 或 `column-type-change`。
**SchemaName**
記錄的來源結構描述。控制記錄的此欄位可以為空。
**TableName**
記錄的來源資料表。控制記錄的此欄位可以為空。
**時間戳記**
JSON 訊息建構時間的時間戳記。此欄位格式為 ISO 8601 格式。
# 使用 Apache Kafka 做為 的目標 AWS Database Migration Service
您可以使用 AWS DMS 將資料遷移至 Apache Kafka 叢集。Apache Kafka 是一個分散式串流平台。您可以使用 Apache Kafka 來即時擷取和處理串流資料。
AWS 也提供 Amazon Managed Streaming for Apache Kafka (Amazon MSK) 做為 AWS DMS 目標。Amazon MSK 是一個完全受管的 Apache Kafka 串流服務，用於簡化 Apache Kafka 執行個體的實作和管理。它適用於開放原始碼 Apache Kafka 版本，而且您可以像任何 Apache Kafka 執行個體一樣存取 Amazon MSK 執行個體做為 AWS DMS 目標。如需詳細資訊，請參閱《Amazon Managed Streaming for Apache Kafka 開發人員指南》**中的[什麼是 Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/what-is-msk.html)。
Kafka 叢集會記錄串流儲存在稱為主題的類別裡，其中具有分割區。*分割區*是主題中資料記錄 (訊息) 的唯一識別序列。分割區可以分佈在叢集中的多個中介裝置，以啟用主題記錄的平行處理。如需有關主題和分割區及其在 Apache Kafka 中分佈的詳細資訊，請參閱[主題和日誌](https://kafka.apache.org/documentation/#intro_topics)以及[分佈](https://kafka.apache.org/documentation/#intro_distribution)。
Kafka 叢集可以是 Amazon MSK 執行個體、Amazon EC2 執行個體上執行的叢集，或是內部部署叢集。Amazon MSK 執行個體或 Amazon EC2 執行個體上的叢集可以位於相同或不同的 VPC。如果您的叢集為內部部署，您可以針對複寫執行個體使用自己的內部部署名稱伺服器來解析叢集的主機名稱。如需為複寫執行個體設定名稱伺服器的相關資訊，請參閱 [使用自己的內部部署名稱伺服器](CHAP_BestPractices.md#CHAP_BestPractices.Rte53DNSResolver)。如需設定網路的詳細資訊，請參閱 [設定複寫執行個體的網路](CHAP_ReplicationInstance.VPC.md)。
使用 Amazon MSK 叢集時，請確定其安全群組允許來自複寫執行個體的存取。如需變更 Amazon MSK 叢集安全群組的相關資訊，請參閱[變更 Amazon MSK 叢集的安全群組](https://docs.aws.amazon.com/msk/latest/developerguide/change-security-group.html)。
AWS Database Migration Service 使用 JSON 將記錄發佈至 Kafka 主題。在轉換過程中， AWS DMS 會將來源資料庫中的每筆記錄序列化為 JSON 格式的屬性值對。
若要將資料從任何受支援的資料來源遷移到目標 Kafka 叢集，可以使用物件對應。您可以使用物件映射來決定如何建構目標主題中的資料記錄。您也可以定義每份資料表的分割區索引鍵，Apache Kafka 用它將資料分組為分割區。
目前， AWS DMS 支援每個任務的單一主題。對於具有多個資料表的單一任務，所有訊息都會傳送至同一主題。每個訊息都包含中繼資料區段，可識別目標結構描述和 table. AWS DMS versions 3.4.6 和更新版本，支援使用物件映射的多主題複寫。如需詳細資訊，請參閱[使用物件映射的多主題複製](#CHAP_Target.Kafka.MultiTopic)。
**Apache Kafka 端點設定**
您可以透過 AWS DMS 主控台中的端點設定或 CLI 中的 `--kafka-settings`選項來指定連線詳細資訊。每個設定的需求如下：
+ `Broker` — 以逗號分隔清單的形式指定 Kafka 叢集中一個或多個代理程式的位置。`broker-hostname:port`例如，`"ec2-12-345-678-901.compute-1.amazonaws.com:2345,ec2-10-987-654-321.compute-1.amazonaws.com:9876"`。此設定可以指定叢集中任意或所有代理程式的位置。叢集中介裝置全部都會進行通訊，以處理遷移到主題的資料記錄分割。
+ `Topic` – (選擇性) 指定主題名稱，長度上限為 255 個字母和符號。您可以使用句號 (.)、底線 (\$1) 和減號 (-)。具有句點 (.) 或底線 (\$1) 的主題名稱可能會在內部資料結構中發生衝突。在主題名稱中使用其中一個符號，不要同時使用這兩個符號。如果您未指定主題名稱， AWS DMS 會使用 `"kafka-default-topic"`做為遷移主題。
**注意**
若要讓 AWS DMS 建立您指定的遷移主題或預設主題，請將 `auto.create.topics.enable = true`設定為 Kafka 叢集組態的一部分。如需詳細資訊，請參閱[使用 Apache Kafka 做為 目標的限制 AWS Database Migration Service](#CHAP_Target.Kafka.Limitations)
+ `MessageFormat` – 在端點建立之記錄的輸出格式。訊息格式為 `JSON` (預設) 或 `JSON_UNFORMATTED` (不含製表符的單行)。
+ `MessageMaxBytes` – 在端點上建立之記錄的大小上限 (以位元組為單位)。預設值為 1,000,000。
**注意**
您只能使用 AWS CLI/SDK `MessageMaxBytes`變更為非預設值。例如，若要修改現有的 Kafka 端點並變更 `MessageMaxBytes`，請使用以下命令。
```
aws dms modify-endpoint --endpoint-arn your-endpoint
--kafka-settings Broker="broker1-server:broker1-port,broker2-server:broker2-port,...",
Topic=topic-name,MessageMaxBytes=integer-of-max-message-size-in-bytes
```
+ `IncludeTransactionDetails` – 提供來源資料庫的詳細交易資訊。此資訊包括遞交時間戳記、記錄位置，以及 `transaction_id`、`previous_transaction_id`，和 `transaction_record_id` (交易內的記錄位移) 的值。預設值為 `false`。
+ `IncludePartitionValue` – 在 Kafka 訊息輸出中顯示分割區值，除非分割區類型為 `schema-table-type`。預設值為 `false`。
+ `PartitionIncludeSchemaTable` – 當磁碟分割類型為 `primary-key-type` 時，將結構描述和資料表名稱作為磁碟分割值的前綴。這樣做會增加 Kafka 分割區之間的資料分佈。例如，假設 `SysBench` 結構描述有數千個資料表，而每個資料表的主索引鍵只有有限的範圍。在這種情況下，相同的主金鑰會從數千個資料表發送到相同的分割區，而這將導致調節。預設值為 `false`。
+ `IncludeTableAlterOperations` – 包含變更控制資料中資料表的任何資料定義語言 (DDL) 操作，例如 `rename-table`、`drop-table`、`add-column`、`drop-column` 和 `rename-column`。預設值為 `false`。
+ `IncludeControlDetails` – 在 Kafka 訊息輸出中顯示資料表定義、欄位定義以及資料表和欄位變更的詳細控制資訊。預設值為 `false`。
+ `IncludeNullAndEmpty`：包含目標中的 NULL 和空資料欄。預設值為 `false`。
+ `SecurityProtocol` – 使用 Transport Layer Security (TLS) 設定與 Kafka 目標端點的安全連線。選項包括 `ssl-authentication`、`ssl-encryption` 和 `sasl-ssl`。使用 `sasl-ssl` 將需要 `SaslUsername` 和 `SaslPassword`。
+ `SslEndpointIdentificationAlgorithm` – 設定憑證的主機名稱驗證。3.5.1 版和更新版本支援 AWS DMS 此設定。選項包括下列項目：
+ `NONE`：在用戶端連線中停用代理程式的主機名稱驗證。
+ `HTTPS`：在用戶端連線中啟用代理程式的主機名稱驗證。
+ `useLargeIntegerValue` – 使用最多 18 位數的整數，而不是將整數轉換為雙位元，可從 3.5.4 AWS DMS 版取得。預設值為 false。
您可以使用設定來協助提高傳輸速度。由於要執行此操作， AWS DMS 要支援對一個 Apache Kafka 目標叢集執行多執行緒完全載入。 AWS DMS 透過包含下列項目的任務設定以支援此多執行緒：
+ `MaxFullLoadSubTasks` – 使用此選項來指出要平行載入的來源資料表數量上限。 會使用專用子任務，將每個資料表 AWS DMS 載入其對應的 Kafka 目標資料表。預設值為 8；最大值為 49。
+ `ParallelLoadThreads` – 使用此選項指定 AWS DMS 用於將每個資料表載入其 Kafka 目標資料表的執行緒數目。Apache Kafka 目標的最大值為 32。您可以要求提高此上限。
+ `ParallelLoadBufferSize` – 使用此選項指定平行載入執行緒將資料載入至 Kafka 目標時，緩衝區中存放的記錄數量上限。預設值為 50。最大值為 1000。使用此設定搭配 `ParallelLoadThreads`；`ParallelLoadBufferSize`，只有在有多個執行緒時才有效。
+ `ParallelLoadQueuesPerThread`：使用此選項指定每個並行執行緒存取的佇列數目，以便將資料記錄從佇列中取出，並為目標產生批次載入。預設為 1。最多 512 個。
您可以透過調整平行執行緒和大量操作的任務設定，改善 Kafka 端點的變更資料擷取 (CDC) 效能。若要執行此操作，您可以指定並行執行緒數目、每個執行緒的佇列數，以及使用 `ParallelApply*` 任務設定儲存在緩衝區中的記錄數目。例如，假設您要執行 CDC 載入並平行套用 128 個執行緒。您也想要每個執行緒存取 64 個佇列，且每個緩衝區儲存 50 筆記錄。
為了提升 CDC 效能， AWS DMS 支援下列任務設定：
+ `ParallelApplyThreads` – 指定在 CDC 載入期間 AWS DMS 用來將資料記錄推送至 Kafka 目標端點的並行執行緒數目。預設值為零 (0)，最大值為 32。
+ `ParallelApplyBufferSize` – 指定每個緩衝區佇列中存放的最大記錄數目，以便並行執行緒在 CDC 載入期間推送至 Kafka 目標端點。預設值為 100，最大值為 1,000。`ParallelApplyThreads` 指定多個執行緒時，請使用此選項。
+ `ParallelApplyQueuesPerThread` – 指定每個執行緒存取的佇列數目，以便從佇列中取出資料記錄，並在 CDC 期間產生 Kafka 端點的批次載入。預設為 1。最多 512 個。
在使用 `ParallelApply*` 任務設定時，`partition-key-type` 預設是資料表的 `primary-key`，而非 `schema-name.table-name`。
## 使用 Transport Layer Security (TLS) 連線到 Kafka
Kafka 叢集只接受使用 Transport Layer Security (TLS) 的安全連線。透過 DMS，您可以使用以下三個安全通訊協定選項中的任一個來保護 Kafka 端點連線。
**SSL 加密 (`server-encryption`)**
用戶端會透過伺服器的憑證來驗證伺服器身分。接著在伺服器和用戶端之間建立加密連線。
**SSL 驗證 (`mutual-authentication`)**
伺服器和用戶端透過自己的憑證互相驗證身分。接著在伺服器和用戶端之間建立加密連線。
**SASL-SSL (`mutual-authentication`)**
簡單驗證和安全層 (SASL) 方法會以使用者名稱和密碼取代用戶端的憑證，用以驗證用戶端的身分。具體來說，您需要提供伺服器已註冊的使用者名稱和密碼，讓伺服器驗證用戶端的身分。接著在伺服器和用戶端之間建立加密連線。
**重要**
Apache Kafka 和 Amazon MSK 會接受已解析的憑證。這是 Kafka 和 Amazon MSK 的已知限制。如需詳細資訊，請參閱 [Apache Kafka 問題，KAFKA-3700](https://issues.apache.org/jira/browse/KAFKA-3700)。
如果您使用 Amazon MSK，請考慮使用存取控制清單 (ACL) 作為這項已知限制的解決方案。如需使用 ACL 的詳細資訊，請參閱《*Amazon Managed Streaming for Apache Kafka 開發人員指南*》的「[Apache Kafka ACL](https://docs.aws.amazon.com//msk/latest/developerguide/msk-acls.html)」一節。
如果您使用的是自我管理的 Kafka 叢集，請參閱 [2018 年 10 月 21 日的註解](https://issues.apache.org/jira/browse/KAFKA-3700?focusedCommentId=16658376)，以取得設定叢集的相關資訊。
### 使用 SSL 加密搭配 Amazon MSK 或自我管理 Kafka 叢集
您可以使用 SSL 加密來保護與 Amazon MSK 或自我管理 Kafka 叢集的端點連線。當您使用 SSL 加密驗證方法時，用戶端會透過伺服器憑證來驗證伺服器的身分。接著在伺服器和用戶端之間建立加密連線。
**使用 SSL 加密連線到 Amazon MSK**
+ 建立目標 Kafka 端點時，請使用 `ssl-encryption` 選項設定安全通訊協定端點設定 (`SecurityProtocol`)。
下列 JSON 範例會將安全協議設為 SSL 加密。
```
"KafkaSettings": {
"SecurityProtocol": "ssl-encryption",
}
```
**若要針對自我管理 Kafka 叢集使用 SSL 加密**
1. 如果您在內部部署 Kafka 叢集中使用私有憑證授權機構 (CA)，請上傳您的私有 CA 憑證並取得 Amazon Resource Name (ARN)。
1. 建立目標 Kafka 端點時，請使用 `ssl-encryption` 選項設定安全通訊協定端點設定 (`SecurityProtocol`)。下列 JSON 範例會將安全通訊協議設為 `ssl-encryption`。
```
"KafkaSettings": {
"SecurityProtocol": "ssl-encryption",
}
```
1. 如果您使用的是私有 CA，請在上述第一步取得的 ARN 中設定 `SslCaCertificateArn`。
### 使用 SSL 身分驗證
您可以使用 SSL 身分驗證來保護與 Amazon MSK 或自我管理 Kafka 叢集的端點連線。
若要在連線到 Amazon MSK 時使用 SSL 身份驗證進行用戶端身份驗證和加密，請執行下列動作：
+ 準備 Kafka 的私有金鑰和公有憑證。
+ 將憑證上傳到 DMS 憑證管理員：
+ 使用 Kafka 端點設定中指定的對應憑證 ARN 建立 Kafka 目標端點。
**若要準備 Amazon MSK 的私有金鑰和公有憑證**
1. 建立 EC2 執行個體並設定用戶端以使用身份驗證，如《*Amazon Managed Streaming for Apache Kafka 開發人員指南*》中「[用戶端身份驗證](https://docs.aws.amazon.com/msk/latest/developerguide/msk-authentication.html)」一節中的步驟 1 到 9 所述。
完成這些步驟之後，您將擁有憑證-ARN (儲存在 ACM 中的公用憑證 ARN)，以及 `kafka.client.keystore.jks` 檔案中包含的私有金鑰。
1. 使用下列命令取得公用憑證，並將憑證複製到 `signed-certificate-from-acm.pem` 檔案中：
```
aws acm-pca get-certificate --certificate-authority-arn Private_CA_ARN --certificate-arn Certificate_ARN
```
該命令會傳回類似於以下範例的資訊。
```
{"Certificate": "123", "CertificateChain": "456"}
```
然後，請將與 `"123"` 相等的項目複製到 `signed-certificate-from-acm.pem` 文件中。
1. 從 `kafka.client.keystore.jks to keystore.p12` 中匯入 `msk-rsa` 金鑰以取得私有金鑰，如下列範例所示。
```
keytool -importkeystore \
-srckeystore kafka.client.keystore.jks \
-destkeystore keystore.p12 \
-deststoretype PKCS12 \
-srcalias msk-rsa-client \
-deststorepass test1234 \
-destkeypass test1234
```
1. 使用以下命令將 `.pem` 匯出為 `keystore.p12` 格式。
```
Openssl pkcs12 -in keystore.p12 -out encrypted-private-client-key.pem –nocerts
```
**輸入 PEM 密碼短語**訊息隨即出現，並識別用於加密憑證的金鑰。
1. 從 `.pem` 檔案中移除 bag 屬性和 key 屬性，以確定第一行的開頭字串如下。
```
---BEGIN ENCRYPTED PRIVATE KEY---
```
**若要將公用憑證和私有金鑰上傳到 DMS 憑證管理員，並測試與 Amazon MSK 的連線**
1. 使用下列命令上傳至 DMS 憑證管理員。
```
aws dms import-certificate --certificate-identifier signed-cert --certificate-pem file://path to signed cert
aws dms import-certificate --certificate-identifier private-key —certificate-pem file://path to private key
```
1. 建立 Amazon MSK 目標端點並測試連線，以確保 TLS 身份驗證可正常運作。
```
aws dms create-endpoint --endpoint-identifier $endpoint-identifier --engine-name kafka --endpoint-type target --kafka-settings
'{"Broker": "b-0.kafka260.aaaaa1.a99.kafka.us-east-1.amazonaws.com:0000", "SecurityProtocol":"ssl-authentication",
"SslClientCertificateArn": "arn:aws:dms:us-east-1:012346789012:cert:",
"SslClientKeyArn": "arn:aws:dms:us-east-1:0123456789012:cert:","SslClientKeyPassword":"test1234"}'
aws dms test-connection -replication-instance-arn=$rep_inst_arn —endpoint-arn=$kafka_tar_arn_msk
```
**重要**
您可以使用 SSL 驗證來保護與自我管理 Kafka 叢集的連線。在某些情況下，您可能會在內部部署 Kafka 叢集中使用私有憑證授權機構 (CA)。若是如此，請將您的 CA 鏈結、公用憑證和私有金鑰上傳至 DMS 憑證管理員。接著，在建立內部部署 Kafka 目標端點時，在端點設定中使用對應的 Amazon Resource Name (ARN)。
**若要準備自我管理 Kafka 叢集的私有金鑰和簽署憑證**
1. 產生金鑰對，如下列範例所示。
```
keytool -genkey -keystore kafka.server.keystore.jks -validity 300 -storepass your-keystore-password
-keypass your-key-passphrase -dname "CN=your-cn-name"
-alias alias-of-key-pair -storetype pkcs12 -keyalg RSA
```
1. 產生憑證簽署請求 (CSR)。
```
keytool -keystore kafka.server.keystore.jks -certreq -file server-cert-sign-request-rsa -alias on-premise-rsa -storepass your-key-store-password
-keypass your-key-password
```
1. 使用叢集信任存放區中的 CA 來簽署 CSR。如果您沒有 CA，則可以建立自己的私有 CA。
```
openssl req -new -x509 -keyout ca-key -out ca-cert -days validate-days
```
1. 將 `ca-cert` 匯入至伺服器信任存放區和金鑰存放區。如果您沒有信任存放區，請使用下列命令建立信任存放區，並將 `ca-cert ` 匯入其中。
```
keytool -keystore kafka.server.truststore.jks -alias CARoot -import -file ca-cert
keytool -keystore kafka.server.keystore.jks -alias CARoot -import -file ca-cert
```
1. 簽署憑證。
```
openssl x509 -req -CA ca-cert -CAkey ca-key -in server-cert-sign-request-rsa -out signed-server-certificate.pem
-days validate-days -CAcreateserial -passin pass:ca-password
```
1. 將簽署的憑證匯入金鑰存放區。
```
keytool -keystore kafka.server.keystore.jks -import -file signed-certificate.pem -alias on-premise-rsa -storepass your-keystore-password
-keypass your-key-password
```
1. 使用以下命令將 `on-premise-rsa` 金鑰從 `kafka.server.keystore.jks` 匯入至 `keystore.p12`。
```
keytool -importkeystore \
-srckeystore kafka.server.keystore.jks \
-destkeystore keystore.p12 \
-deststoretype PKCS12 \
-srcalias on-premise-rsa \
-deststorepass your-truststore-password \
-destkeypass your-key-password
```
1. 使用以下命令將 `.pem` 匯出為 `keystore.p12` 格式。
```
Openssl pkcs12 -in keystore.p12 -out encrypted-private-server-key.pem –nocerts
```
1. 將 `encrypted-private-server-key.pem`、`signed-certificate.pem` 和 `ca-cert` 上傳至 DMS 憑證管理員。
1. 使用傳回的 ARN 建立端點。
```
aws dms create-endpoint --endpoint-identifier $endpoint-identifier --engine-name kafka --endpoint-type target --kafka-settings
'{"Broker": "b-0.kafka260.aaaaa1.a99.kafka.us-east-1.amazonaws.com:9092", "SecurityProtocol":"ssl-authentication",
"SslClientCertificateArn": "your-client-cert-arn","SslClientKeyArn": "your-client-key-arn","SslClientKeyPassword":"your-client-key-password",
"SslCaCertificateArn": "your-ca-certificate-arn"}'
aws dms test-connection -replication-instance-arn=$rep_inst_arn —endpoint-arn=$kafka_tar_arn_msk
```
### 使用 SASL-SSL 驗證連線到 Amazon MSK
簡單身分驗證和安全層 (SASL) 方法會透過使用者名稱和密碼來驗證用戶端身分，並在伺服器和用戶端之間建立加密連線。
若要使用 SASL，請先在設定 Amazon MSK 叢集時建立安全的使用者名稱和密碼。如需為 Amazon MSK 叢集設定安全使用者名稱和密碼的說明，請參閱《*Amazon Managed Streaming for Apache Kafka 開發人員指南*》中的「[為 Amazon MSK 叢集設定 SASL/SCRAM 驗證](https://docs.aws.amazon.com/msk/latest/developerguide/msk-password.html#msk-password-tutorial)」。
接著，當您建立 Kafka 目標端點時，請使用 `sasl-ssl` 選項設定安全通訊協定端點設定 (`SecurityProtocol`)。您還可以設定 `SaslUsername` 和 `SaslPassword` 選項。請確定這些欄位與您第一次設定 Amazon MSK 叢集時建立的安全使用者名稱和密碼一致，如以下 JSON 範例所示。
```
"KafkaSettings": {
"SecurityProtocol": "sasl-ssl",
"SaslUsername":"Amazon MSK cluster secure user name",
"SaslPassword":"Amazon MSK cluster secure password"
}
```
**注意**
目前， 僅 AWS DMS 支援公有 CA 支援的 SASL-SSL。DMS 不支援 SASL-SSL 搭配由私有 CA 支援的自我管理 Kafka 使用。
對於 SASL-SSL 身分驗證， 預設 AWS DMS 支援 SCRAM-SHA-512 機制。 AWS DMS 3.5.0 版和更新版本也支援純機制。若要支援 Plain 機制，請將 `KafkaSettings` API 資料類型的 `SaslMechanism` 參數設定為 `PLAIN`。Kafka `PLAIN`支援此資料類型，但 Amazon Kafka (MSK) 不支援。
## 使用前映像檢視做為目標之 Apache Kafka 的 CDC 列原始值
將 CDC 更新寫入至 Kafka 等資料串流目標時，您可以在更新進行變更前，檢視來源資料庫列的原始值。為了實現這一點， 會根據來源資料庫引擎提供的資料， AWS DMS 填入更新事件*之前的映像*。
不同的來源資料庫引擎可提供不同的前映像資訊量：
+ Oracle 僅提供欄更新 (如果有變更的話)。
+ PostgreSQL 僅提供屬於主索引鍵一部分的欄的資料 (無論是否有變更)。如果邏輯複寫正在使用中，且為來源資料表設定 REPLACY IDENTITY FULL，您可以取得列寫入 WALS 前後的完整資訊，並可在此處取得。
+ MySQL 一般會提供所有欄的資料 (無論是否有變更)。
若要啟用前映像功能以從來源資料庫將原始值新增至 AWS DMS 輸出，請使用 `BeforeImageSettings` 任務設定或 `add-before-image-columns` 參數。此參數會套用欄轉換規則。
`BeforeImageSettings` 會使用從來源資料庫系統收集到的值，將新的 JSON 屬性新增至所有更新操作，如下所示。
```
"BeforeImageSettings": {
"EnableBeforeImage": boolean,
"FieldName": string,
"ColumnFilter": pk-only (default) / non-lob / all (but only one)
}
```
**注意**
將 `BeforeImageSettings` 套用至完全載入以及 CDC 任務 (會遷移現有資料並複寫持續變更)，或僅套用至 CDC 任務 (只會複寫資料變更)。請勿將 `BeforeImageSettings` 套用至僅限完全載入的任務。
針對 `BeforeImageSettings` 選項，適用的設定如下：
+ 將 `EnableBeforeImage` 選項設為 `true` 以啟用前映像功能。預設值為 `false`。
+ 使用 `FieldName` 選項，將名稱指派給新的 JSON 屬性。若 `EnableBeforeImage` 為 `true`，`FieldName` 則為必填，且不能留白。
+ `ColumnFilter` 選項會使用前映像來指定要新增的欄。若只要新增屬於資料表主索引鍵一部分的欄，請使用預設值 `pk-only`。若只要新增不屬於 LOB 類型的欄，請使用 `non-lob`。若要新增任何具有前映像值的欄，請使用 `all`。
```
"BeforeImageSettings": {
"EnableBeforeImage": true,
"FieldName": "before-image",
"ColumnFilter": "pk-only"
}
```
### 使用前映像轉換規則
您可使用 `add-before-image-columns` 參數做為任務設定的替代方式，它會套用欄轉換規則。透過此參數，您可以在 Kafka 等資料串流目標上，在 CDC 期間啟用前映像功能。
只要在轉換規則中使用 `add-before-image-columns`，即可套用前映像結果的更精細的控制。轉換規則可讓您使用物件定位器，以便掌控針對規則選取的資料表。此外，您可以將轉換規則鏈結在一起，讓不同的規則套用至不同的資料表。接著，您可以使用其他規則來操控產生的欄。
**注意**
請勿在同一個任務內將 `add-before-image-columns` 參數與 `BeforeImageSettings` 任務設定一起搭配使用。請改為將參數或設定 (擇一使用，而非兩者同時使用) 用於單一任務。
具有欄的 `add-before-image-columns` 參數的 `transformation` 規則類型必須提供 `before-image-def` 區段。下列顯示一個範例。
```
{
"rule-type": "transformation",
…
"rule-target": "column",
"rule-action": "add-before-image-columns",
"before-image-def":{
"column-filter": one-of (pk-only / non-lob / all),
"column-prefix": string,
"column-suffix": string,
}
}
```
`column-prefix` 的值會附加至欄名稱前，而`column-prefix` 的預設值為 `BI_`。`column-suffix` 的值會附加至欄名稱，而預設值為空白。請勿將 `column-prefix` 和 `column-suffix` 同時設為空白字串。
為 `column-filter` 選擇一個值。若只要新增屬於資料表主索引鍵一部分的欄，請選擇 `pk-only`。選擇 `non-lob` 以僅新增不屬於 LOB 類型的欄。或者，選擇 `all` 以新增任何具有前映像值的欄。
### 前映像轉換規則範例
下列範例中的轉換規則會在目標中新增名為 `BI_emp_no` 的欄。因此，`UPDATE employees SET emp_no = 3 WHERE emp_no = 1;` 等陳述式會以 1 填入 `BI_emp_no` 欄位。當您將 CDC 更新寫入至 Amazon S3 目標時，`BI_emp_no` 資料欄會讓它能夠分辨哪個原始列已更新。
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "employees"
},
"rule-action": "add-before-image-columns",
"before-image-def": {
"column-prefix": "BI_",
"column-suffix": "",
"column-filter": "pk-only"
}
}
]
}
```
如需使用 `add-before-image-columns` 規則動作的相關資訊，請參閱[轉換規則與動作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)。
## 使用 Apache Kafka 做為 目標的限制 AWS Database Migration Service
使用 Apache Kafka 做為目標時，有下列限制：
+ AWS DMS Kafka 目標端點不支援 Amazon Managed Streaming for Apache Kafka (Amazon MSK) 的 IAM 存取控制。
+ 不支援完全的 LOB 模式。
+ 為您的叢集指定 Kafka 組態檔案，其中包含允許 AWS DMS 自動建立新主題的屬性。包括設定，`auto.create.topics.enable = true`。如果您正在使用 Amazon MSK，您可以在建立 Kafka 叢集時指定預設組態，然後將 `auto.create.topics.enable` 設定變更為 `true`。如需預設組態設定的詳細資訊，請參閱《[Amazon Managed Streaming for Apache Kafka 開發人員指南](https://docs.aws.amazon.com/msk/latest/developerguide/msk-default-configuration.html)》中的「*Amazon MSK 預設組態*」。如果您需要修改使用 Amazon MSK 建立的現有 Kafka 叢集，請執行 AWS CLI 命令`aws kafka create-configuration`來更新您的 Kafka 組態，如下列範例所示：
```
14:38:41 $ aws kafka create-configuration --name "kafka-configuration" --kafka-versions "2.2.1" --server-properties file://~/kafka_configuration
{
"LatestRevision": {
"Revision": 1,
"CreationTime": "2019-09-06T14:39:37.708Z"
},
"CreationTime": "2019-09-06T14:39:37.708Z",
"Name": "kafka-configuration",
"Arn": "arn:aws:kafka:us-east-1:111122223333:configuration/kafka-configuration/7e008070-6a08-445f-9fe5-36ccf630ecfd-3"
}
```
在此，`//~/kafka_configuration` 是您以必要屬性設定所建立的組態檔案。
如果您使用安裝在 Amazon EC2 上的自己的 Kafka 執行個體，請使用 `auto.create.topics.enable = true`設定修改 Kafka 叢集組態， AWS DMS 以允許 使用執行個體隨附的選項自動建立新主題。
+ AWS DMS 會將每個更新發佈至來源資料庫中的單一記錄，做為指定 Kafka 主題中的一個資料記錄 （訊息），無論交易為何。
+ AWS DMS 支援下列四種形式的分割區索引鍵：
+ `SchemaName.TableName`：結構描述和資料表名稱的組合。
+ `${AttributeName}`：JSON 其中一個欄位的值，或來源資料庫資料表的主索引鍵。
+ `transaction-id`：CDC 交易 ID。相同交易中的所有記錄都會移至相同的分割區。
+ `constant`：無論資料表或資料為何，每個記錄的固定常值。所有記錄都會傳送至相同的分割區索引鍵值「常數」，在所有資料表中提供嚴格的全域排序。
```
{
"rule-type": "object-mapping",
"rule-id": "2",
"rule-name": "TransactionIdPartitionKey",
"rule-action": "map-record-to-document",
"object-locator": {
"schema-name": "onprem",
"table-name": "it_system"
},
"mapping-parameters": {
"partition-key-type": "transaction-id | constant | attribute-name | schema-table"
}
}
```
+ 只有在來源`IncludeTransactionDetails`端點為 Oracle、SQL Server、PostgreSQL 或 MySQL 時，才支援端點設定。對於其他來源端點類型，不會包含交易詳細資訊。
+ Kafka 端點不支援 `BatchApply`。對 Kafka 目標使用批次套用 (例如 `BatchApplyEnabled` 目標中繼資料任務設定) 可能會導致資料遺失。
+ AWS DMS 不支援遷移超過 16 位數的`BigInt`資料類型值。若要解決此限制，您可以使用下列轉換規則將 `BigInt` 資料欄轉換為字串。如需轉換規則的詳細資訊，請參閱 [轉換規則與動作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)。
```
{
"rule-type": "transformation",
"rule-id": "id",
"rule-name": "name",
"rule-target": "column",
"object-locator": {
"schema-name": "valid object-mapping rule action",
"table-name": "",
"column-name": ""
},
"rule-action": "change-data-type",
"data-type": {
"type": "string",
"length": 20
}
}
```
+ AWS DMS Kafka 目標端點不支援 Amazon MSK servless。
+ 定義映射規則時，不支援同時具有物件映射規則和轉換規則。您必須只設定一個規則。
+ AWS DMS 支援最高 3.8 版的 Apache Kafka 的 SASL 身分驗證。如果您使用的是 Kafka 4.0 或更新版本，則只能在沒有 SASL 身分驗證的情況下連線。
+ AWS DMS 使用 Kafka 做為目標端點時， 不支援包含內嵌`'\0'`字元的來源資料。包含內嵌`'\0'`字元的資料會在第一個`'\0'`字元被截斷。
## 使用物件映射將資料遷移到 Kafka 主題
AWS DMS 使用資料表映射規則，將資料從來源映射到目標 Kafka 主題。若要將資料映射到目標主題，請使用一種稱為物件映射的資料表映射規則。您可以使用物件映射定義如何將來源中的資料記錄映射到發佈到 Kafka 主題的資料記錄。
除了擁有分割區索引鍵外，Kafka 主題沒有預設結構。
**注意**
您不一定要使用物件映射。您可以針對各種轉換使用一般資料表映射。不過，分割區索引鍵類型會遵循下列預設行為：
主索引鍵會作為「完全載入」的分割區索引鍵。
如果未使用平行套用任務設定，則 `schema.table` 會做為 CDC 的分割區索引鍵。
如果使用平行套用任務設定，則主索引鍵會做為 CDC 的分割區索引鍵。
若要建立物件映射規則，請將 `rule-type` 指定為 `object-mapping`。此規則指定您想要使用的物件映射類型。
規則的結構如下。
```
{
"rules": [
{
"rule-type": "object-mapping",
"rule-id": "id",
"rule-name": "name",
"rule-action": "valid object-mapping rule action",
"object-locator": {
"schema-name": "case-sensitive schema name",
"table-name": ""
}
}
]
}
```
AWS DMS 目前支援 `map-record-to-record`和 `map-record-to-document`做為 `rule-action` 參數的唯一有效值。這些設定會影響 `exclude-columns` 屬性清單中未排除的值。`map-record-to-record` 和 `map-record-to-document`值預設會指定 AWS DMS 如何處理這些記錄。這些值反正不會影響屬性映射。
從關聯式資料庫遷移到 Kafka 主題時，請使用 `map-record-to-record`。此規則類型使用關聯式資料庫的 `taskResourceId.schemaName.tableName` 值做為 Kafka 主題的分割區索引鍵，並會為來源資料庫中的每一欄建立一個屬性。
使用 `map-record-to-record` 時，請注意下列事項：
+ 此設定只會影響 `exclude-columns` 清單中排除的欄。
+ 對於每個這類資料欄， 會在目標主題中 AWS DMS 建立對應的屬性。
+ AWS DMS 無論屬性映射中是否使用來源資料欄， 都會建立此對應的屬性。
了解 `map-record-to-record` 的一種方法是查看它運作時的狀態。在本範例中，假設您開始使用之關聯式資料庫資料表資料列的結構和資料如下。
| FirstName | LastName | StoreId | HomeAddress | HomePhone | WorkAddress | WorkPhone | DateofBirth |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Randy | Marsh | 5 | 221B Baker Street | 1234567890 | 31 Spooner Street, Quahog | 9876543210 | 1988/02/29 |
若要將此資訊從名為 `Test` 的結構描述遷移至 Kafka 主題，您可以建立規則以將資料映射至目標主題。以下規則說明映射。
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"rule-action": "include",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
}
},
{
"rule-type": "object-mapping",
"rule-id": "2",
"rule-name": "DefaultMapToKafka",
"rule-action": "map-record-to-record",
"object-locator": {
"schema-name": "Test",
"table-name": "Customers"
}
}
]
}
```
指定 Kafka 主題和分割區索引鍵 (在本例中為 `taskResourceId.schemaName.tableName`)，下列說明使用我們在 Kafka 目標主題中的範例資料所產生的記錄格式：
```
{
"FirstName": "Randy",
"LastName": "Marsh",
"StoreId": "5",
"HomeAddress": "221B Baker Street",
"HomePhone": "1234567890",
"WorkAddress": "31 Spooner Street, Quahog",
"WorkPhone": "9876543210",
"DateOfBirth": "02/29/1988"
}
```
**Topics**
+ [使用屬性映射重組資料](#CHAP_Target.Kafka.AttributeMapping)
+ [使用物件映射的多主題複製](#CHAP_Target.Kafka.MultiTopic)
+ [Apache Kafka 訊息格式](#CHAP_Target.Kafka.Messageformat)
### 使用屬性映射重組資料
您可以在使用屬性映射將資料遷移到 Kafka 主題的同時重組資料。例如，您可能想要將來源的幾個欄位合併為目標的單一欄位。以下屬性映射說明如何重組資料。
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"rule-action": "include",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
}
},
{
"rule-type": "object-mapping",
"rule-id": "2",
"rule-name": "TransformToKafka",
"rule-action": "map-record-to-record",
"target-table-name": "CustomerData",
"object-locator": {
"schema-name": "Test",
"table-name": "Customers"
},
"mapping-parameters": {
"partition-key-type": "attribute-name",
"partition-key-name": "CustomerName",
"exclude-columns": [
"firstname",
"lastname",
"homeaddress",
"homephone",
"workaddress",
"workphone"
],
"attribute-mappings": [
{
"target-attribute-name": "CustomerName",
"attribute-type": "scalar",
"attribute-sub-type": "string",
"value": "${lastname}, ${firstname}"
},
{
"target-attribute-name": "ContactDetails",
"attribute-type": "document",
"attribute-sub-type": "json",
"value": {
"Home": {
"Address": "${homeaddress}",
"Phone": "${homephone}"
},
"Work": {
"Address": "${workaddress}",
"Phone": "${workphone}"
}
}
}
]
}
}
]
}
```
若要設定 的常數值`partition-key`，請指定 `"partition-key-type: "constant"`，這會將分割區值設定為 `constant`。例如，您可以執行此操作，將所有資料強制儲存在單一分割區中。以下映射說明此方法。
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "object-mapping",
"rule-id": "1",
"rule-name": "TransformToKafka",
"rule-action": "map-record-to-document",
"object-locator": {
"schema-name": "Test",
"table-name": "Customer"
},
"mapping-parameters": {
"partition-key-type": "constant",
"exclude-columns": [
"FirstName",
"LastName",
"HomeAddress",
"HomePhone",
"WorkAddress",
"WorkPhone"
],
"attribute-mappings": [
{
"attribute-name": "CustomerName",
"value": "${FirstName},${LastName}"
},
{
"attribute-name": "ContactDetails",
"value": {
"Home": {
"Address": "${HomeAddress}",
"Phone": "${HomePhone}"
},
"Work": {
"Address": "${WorkAddress}",
"Phone": "${WorkPhone}"
}
}
},
{
"attribute-name": "DateOfBirth",
"value": "${DateOfBirth}"
}
]
}
}
]
}
```
**注意**
用於特定資料表的控制記錄 `partition-key` 值是 `TaskId.SchemaName.TableName`。用於特定任務的控制記錄 `partition-key` 值是該記錄的 `TaskId`。在物件映射中指定 `partition-key` 值對控制記錄的 `partition-key` 沒有影響。
在資料表映射規則`attribute-name`中`partition-key-type`將 設定為 時，您必須指定 `partition-key-name`，其必須參考來源資料表中的資料欄或映射中定義的自訂資料欄。此外，`attribute-mappings`必須提供 來定義來源資料欄如何對應至目標 Kafka 主題。
### 使用物件映射的多主題複製
根據預設， AWS DMS 任務會將所有來源資料遷移至下列其中一個 Kafka 主題：
+ 如 AWS DMS 目標端點**的主題**欄位中所指定。
+ 如果目標端點的**主題**欄位未填寫，且 Kafka `auto.create.topics.enable` 設定為 `true`，則為 `kafka-default-topic` 指定的主題。
透過 AWS DMS 引擎 3.4.6 版和更新版本，您可以使用 `kafka-target-topic` 屬性，將每個遷移的來源資料表對應至個別主題。例如，物件映射規則隨後會將來源資料表 `Customer` 和 `Address` 分別遷移至 Kafka 主題 `customer_topic` 及 `address_topic`。同時， 會將所有其他來源資料表 AWS DMS 遷移至目標端點中指定的主題，包括`Test`結構描述中的`Bills`資料表。
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"rule-action": "include",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
}
},
{
"rule-type": "object-mapping",
"rule-id": "2",
"rule-name": "MapToKafka1",
"rule-action": "map-record-to-record",
"kafka-target-topic": "customer_topic",
"object-locator": {
"schema-name": "Test",
"table-name": "Customer"
},
"partition-key-type": "constant"
},
{
"rule-type": "object-mapping",
"rule-id": "3",
"rule-name": "MapToKafka2",
"rule-action": "map-record-to-record",
"kafka-target-topic": "address_topic",
"object-locator": {
"schema-name": "Test",
"table-name": "Address"
},
"partition-key-type": "constant"
},
{
"rule-type": "object-mapping",
"rule-id": "4",
"rule-name": "DefaultMapToKafka",
"rule-action": "map-record-to-record",
"object-locator": {
"schema-name": "Test",
"table-name": "Bills"
}
}
]
}
```
透過使用 Kafka 多主題複寫，您可以使用單一複寫任務將來源資料表來分組和遷移至個別 Kafka 主題。
### Apache Kafka 訊息格式
JSON 輸出僅是索引鍵/值對的清單。
**RecordType**
記錄類型可以是資料或控制。*資料記錄*代表來源的實際資料列。*控制記錄*用於串流的重要事件，例如重新啟動任務。
**作業**
針對資料記錄，操作可以是 `load`、`insert`、`update` 或 `delete`。
針對控制記錄，操作可以是 `create-table`、`rename-table`、`drop-table`、`change-columns`、`add-column`、`drop-column`、`rename-column` 或 `column-type-change`。
**SchemaName**
記錄的來源結構描述。控制記錄的此欄位可以為空。
**TableName**
記錄的來源資料表。控制記錄的此欄位可以為空。
**時間戳記**
JSON 訊息建構時間的時間戳記。此欄位格式為 ISO 8601 格式。
下列 JSON 訊息範例展示包含所有其他中繼資料的資料類型訊息。
```
{
"data":{
"id":100000161,
"fname":"val61s",
"lname":"val61s",
"REGION":"val61s"
},
"metadata":{
"timestamp":"2019-10-31T22:53:59.721201Z",
"record-type":"data",
"operation":"insert",
"partition-key-type":"primary-key",
"partition-key-value":"sbtest.sbtest_x.100000161",
"schema-name":"sbtest",
"table-name":"sbtest_x",
"transaction-id":9324410911751,
"transaction-record-id":1,
"prev-transaction-id":9324410910341,
"prev-transaction-record-id":10,
"commit-timestamp":"2019-10-31T22:53:55.000000Z",
"stream-position":"mysql-bin-changelog.002171:36912271:0:36912333:9324410911751:mysql-bin-changelog.002171:36912209"
}
}
```
下列 JSON 訊息範例展示控制類型訊息。
```
{
"control":{
"table-def":{
"columns":{
"id":{
"type":"WSTRING",
"length":512,
"nullable":false
},
"fname":{
"type":"WSTRING",
"length":255,
"nullable":true
},
"lname":{
"type":"WSTRING",
"length":255,
"nullable":true
},
"REGION":{
"type":"WSTRING",
"length":1000,
"nullable":true
}
},
"primary-key":[
"id"
],
"collation-name":"latin1_swedish_ci"
}
},
"metadata":{
"timestamp":"2019-11-21T19:14:22.223792Z",
"record-type":"control",
"operation":"create-table",
"partition-key-type":"task-id",
"schema-name":"sbtest",
"table-name":"sbtest_t1"
}
}
```
# 使用 Amazon OpenSearch Service 叢集做為 的目標 AWS Database Migration Service
您可以使用 AWS DMS 將資料遷移至 Amazon OpenSearch Service (OpenSearch Service)。OpenSearch Service 是一項受管服務，可讓您輕鬆地部署、操作和擴展 OpenSearch Service 叢集。
在 OpenSearch Service 中，您可以使用索引和文件。*索引*是文件的集合，而*文件*是包含純量值、陣列和其他物件的 JSON 物件。 OpenSearch 提供以 JSON 為基礎的查詢語言，讓您可以查詢索引中的資料並擷取對應的文件。
當 為 OpenSearch Service 的目標端點 AWS DMS 建立索引時，它會從來源端點為每個資料表建立一個索引。建立 OpenSearch Service 索引的成本因數項因素而異。這些是建立的索引數量、這些索引中的資料總量，以及為每個文件 OpenSearch 存放的少量中繼資料。
以適用於您遷移範圍的運算和儲存資源設定 OpenSearch Service 叢集。建議您考慮以下因素，視您想要使用的複寫任務而定：
+ 若為完全資料載入，請考慮您希望遷移的總資料量，以及傳輸速度。
+ 若為複寫持續的變更，請考慮更新頻率，以及您的端對端延遲要求。
此外，進行 OpenSearch 叢集的索引設定，密切注意文件計數。
**多執行緒完全載入任務設定**
為了協助提高傳輸速度， AWS DMS 支援對 OpenSearch Service 目標叢集的多執行緒完全載入。 AWS DMS 支援此多執行緒的任務設定包括下列項目：
+ `MaxFullLoadSubTasks`：使用此選項，指出要平行載入的來源資料表數目上限。DMS 會使用專用子任務，將每個資料表載入到其對應的 OpenSearch Service 目標索引。預設值為 8；最大值為 49。
+ `ParallelLoadThreads` – 使用此選項來指定 AWS DMS 用來將每個資料表載入其 OpenSearch Service 目標索引的執行緒數目。OpenSearch Service 目標的最大值為 32。您可以要求提高此上限。
**注意**
如果您未將 `ParallelLoadThreads` 變更為預設值 (0) 以外的值，則 AWS DMS 一次傳送單一記錄。此方法可將過度的載入放置在 OpenSearch Service 叢集上。確定您將此選項設定為 1 或以上。
+ `ParallelLoadBufferSize`：使用此選項指定平行載入執行緒，將資料載入至 OpenSearch Service 目標時，緩衝區中儲存的記錄數量上限。預設值為 50。最大值為 1000。使用此設定搭配 `ParallelLoadThreads`；`ParallelLoadBufferSize`，只有在有多個執行緒時才有效。
如需 DMS 如何使用多執行緒載入 OpenSearch Service 叢集的詳細資訊，請參閱 AWS 部落格文章 [Scale Amazon OpenSearch Service for AWS Database Migration Service migrations](https://aws.amazon.com/blogs/database/scale-amazon-elasticsearch-service-for-aws-database-migration-service-migrations/)。
**多執行緒 CDC 載入任務設定**
您可以使用任務設定來修改 `PutRecords` API 呼叫行為，改善 OpenSearch Service 目標叢集的變更資料擷取 (CDC) 效能。若要執行此操作，您可以指定並行執行緒數目、每個執行緒的佇列數，以及使用 `ParallelApply*` 任務設定儲存在緩衝區中的記錄數目。例如，假設您要執行 CDC 載入並平行套用 32 個執行緒。您也想要每個執行緒存取 64 個佇列，且每個緩衝區儲存 50 筆記錄。
**注意**
在 CDC 到 Amazon OpenSearch Service 目標端點期間使用`ParallelApply*`任務設定的支援可在 3.4.0 版和更高 AWS DMS 版本中使用。
為了提升 CDC 效能， AWS DMS 支援下列任務設定：
+ `ParallelApplyThreads` – 指定在 CDC 載入期間 AWS DMS 用來將資料記錄推送至 OpenSearch Service 目標端點的並行執行緒數目。預設值為零 (0)，最大值為 32。
+ `ParallelApplyBufferSize`：指定每個緩衝區佇列中儲存的最大記錄數目，以便並行執行緒在 CDC 載入期間推送至 OpenSearch Service 目標端點。預設值為 100，最大值為 1,000。`ParallelApplyThreads` 指定多個執行緒時，請使用此選項。
+ `ParallelApplyQueuesPerThread`：指定每個執行緒存取的佇列數目，以便從佇列中取出資料記錄，並在 CDC 期間產生 OpenSearch Service 端點的批次載入。
在使用 `ParallelApply*` 任務設定時，`partition-key-type` 預設是資料表的 `primary-key`，而非 `schema-name.table-name`。
## 從關聯式資料庫資料表遷移到 OpenSearch Service 索引
AWS DMS 支援將資料遷移至 OpenSearch Service 的純量資料類型。從 Oracle 或 MySQL 等關聯式資料庫遷移到 OpenSearch Service 時，您可能想要重組此資料的儲存方式。
AWS DMS 支援下列 OpenSearch Service 純量資料類型：
+ Boolean
+ Date
+ Float
+ Int
+ String
AWS DMS 將 Date 類型的資料轉換為 String 類型。您可以指定自訂映射解譯這些日期。
AWS DMS 不支援遷移 LOB 資料類型。
## 使用 Amazon OpenSearch Service 做為 目標的先決條件 AWS Database Migration Service
開始使用 OpenSearch Service 資料庫做為 的目標之前 AWS DMS，請務必建立 AWS Identity and Access Management (IAM) 角色。此角色應可讓 AWS DMS 存取目標端點上的 OpenSearch Service 索引。以下 IAM 政策顯示最低的存取許可集。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "1",
"Effect": "Allow",
"Principal": {
"Service": "dms.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
遷移到 OpenSearch Service 所用的角色必須擁有下列許可。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"es:ESHttpDelete",
"es:ESHttpGet",
"es:ESHttpHead",
"es:ESHttpPost",
"es:ESHttpPut"
],
"Resource": "*"
}
]
}
```
------
在上述範例中，將 取代`region`為 AWS 區域識別符、*`account-id`*將 取代為 AWS 您的帳戶 ID，並將 `domain-name`取代為 Amazon OpenSearch Service 網域名稱。範例為 `arn:aws:es:us-west-2:123456789012:domain/my-es-domain`
## 使用 OpenSearch Service 做為 目標時的端點設定 AWS DMS
您可以使用端點設定來設定 OpenSearch Service 目標資料庫，類似於使用額外的連線屬性。當您使用 AWS DMS 主控台或使用 中的 `create-endpoint`命令搭配 `--elasticsearch-settings '{"EndpointSetting": "value", ...}'` JSON 語法來建立目標端點時[AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html)，您可以指定設定。
下列資料表顯示您可以將 OpenSearch Service 作為目標使用的端點設定。
| 屬性名稱 | 有效值 | 預設值和描述 |
| --- | --- | --- |
| `FullLoadErrorPercentage` | 正整數大於 0，但不超過 100。 | 10 – 針對完全載入任務，此屬性決定判定任務失敗的錯誤閾值。例如，假設來源端點有 1,500 個資料列，而此參數設為 10。然後，如果寫入目標端點時 AWS DMS 遇到超過 150 個錯誤 （列計數的 10%)，任務會失敗。 |
| `ErrorRetryDuration` | 正整數大於 0。 | 300 – 如果目標端點發生錯誤， 會 AWS DMS 重試這幾秒鐘。否則，任務失敗。 |
| `UseNewMappingType` | true 或 false | `false`，但若要使用 opensearch v2.x，應設定為 。 `true` |
## 使用 Amazon OpenSearch Service 做為 目標的限制 AWS Database Migration Service
使用 Amazon OpenSearch Service 作為目標時，有下列限制：
+ OpenSearch Service 使用動態對應 (自動猜測)，以決定遷移資料所用的資料類型。
+ OpenSearch Service 會以不重複的 ID 儲存每個文件。以下是範例 ID。
```
"_id": "D359F8B537F1888BC71FE20B3D79EAE6674BE7ACA9B645B0279C7015F6FF19FD"
```
每個文件 ID 是都 64 位元組長，所以這預計為儲存需求。例如，如果您從 AWS DMS 來源遷移 100，000 個資料列，則產生的 OpenSearch Service 索引需要額外 6，400，000 個位元組的儲存空間。
+ 使用 OpenSearch Service 時，您無法更新主索引鍵屬性。此限制在使用變更資料擷取 (CDC) 進行中複寫時十分重要，因為它會導致目標出現不需要的資料。在 CDC 模式下，主索引鍵會映射到 SHA256 值，這有 32 位元組長。這些都會轉換成人類可讀的 64 位元組字串，作為 OpenSearch Service 文件 ID 使用。
+ 如果 AWS DMS 遇到任何無法遷移的項目，它會將錯誤訊息寫入 Amazon CloudWatch Logs。此行為與其他 AWS DMS 目標端點的行為不同，其會將錯誤寫入例外狀況資料表。
+ AWS DMS 不支援連線至使用主要使用者和密碼啟用精細存取控制的 Amazon ES 叢集。
+ AWS DMS 不支援 OpenSearch Service Serverless。
+ OpenSearch Service 不支援將資料寫入預先存在的索引。
+ 複寫任務設定`TargetTablePrepMode:TRUNCATE_BEFORE_LOAD`不支援與 OpenSearch 目標端點搭配使用。
+ 使用 將資料遷移至 Amazon Elasticsearch 時 AWS DMS，來源資料必須具有主索引鍵或唯一識別符欄。如果來源資料沒有主索引鍵或唯一識別符，您需要使用 define-primary-key 轉換規則來定義。
## Amazon OpenSearch Service 的目標資料類型
當 從異質資料庫 AWS DMS 遷移資料時，服務會將資料類型從來源資料庫映射到稱為 AWS DMS 資料類型的中繼資料類型。然後，此服務會將中繼資料類型映射到目標資料類型。下表顯示每個 AWS DMS 資料類型及其在 OpenSearch Service 中映射到的資料類型。
| AWS DMS 資料類型 | OpenSearch Service 資料類型 |
| --- | --- |
| Boolean | boolean |
| 日期 | string |
| 時間 | date |
| 時間戳記 | date |
| INT4 | integer |
| Real4 | float |
| UINT4 | integer |
如需 AWS DMS 資料類型的詳細資訊，請參閱 [AWS Database Migration Service 的資料類型](CHAP_Reference.DataTypes.md)。
# 使用 Amazon DocumentDB 做為 AWS Database Migration Service 的目標
如需 AWS DMS 支援的 Amazon DocumentDB 版本 （具有 MongoDB 相容性） 的相關資訊，請參閱 [的目標 AWS DMS](CHAP_Introduction.Targets.md)。您可以從 AWS DMS 支援的任何來源資料引擎，使用 AWS DMS 將資料遷移到 Amazon DocumentDB (with MongoDB compatibility)。來源引擎可以在 AWS 受管服務上，例如 Amazon RDS、Aurora 或 Amazon S3。或者，引擎可以在自我管理資料庫中，例如在 Amazon EC2 或內部部署上執行的 MongoDB。
您可以使用 AWS DMS 將來源資料複寫至 Amazon DocumentDB 資料庫、集合或文件。
**注意**
如果來源端點是 MongoDB 或 Amazon DocumentDB，請以**文件模式**執行遷移。
MongoDB 以二進位 JSON 格式 (BSON) 存放資料。 AWS DMS 支援 Amazon DocumentDB 支援的所有 BSON 資料類型。如需這些資料類型的清單，請參閱《Amazon DocumentDB 開發人員指南》**中[支援的 MongoDB API、操作和資料類型](https://docs.aws.amazon.com/documentdb/latest/developerguide/mongo-apis.html)。
如果來源端點是關聯式資料庫，請將資料庫物件 AWS DMS 映射至 Amazon DocumentDB，如下所示：
+ 關聯式資料庫或資料庫結構描述，會對應到 Amazon DocumentDB 資料庫**。
+ 關聯式資料庫中的資料表會對應至 Amazon DocumentDB 中的集合**。
+ 關聯式資料表中的記錄會對應至 Amazon DocumentDB 中的文件**。每個文件是從來源記錄中的資料建構而來。
如果來源端點是 Amazon S3，則產生的 Amazon DocumentDB 物件會對應到 Amazon S3 的 AWS DMS 對應規則。例如，請參閱下列 URI。
```
s3://amzn-s3-demo-bucket/hr/employee
```
在此情況下， 會將 中的物件 AWS DMS 映射`amzn-s3-demo-bucket`至 Amazon DocumentDB，如下所示：
+ 最上層 URI 部分 (`hr`) 會對應到 Amazon DocumentDB 資料庫。
+ 下一個 URI 部分 (`employee`) 會對應到 Amazon DocumentDB 集合。
+ `employee` 中的每個物件會對應到 Amazon DocumentDB 中的文件。
如需 Amazon S3 對應規則的詳細資訊，請參閱[使用 Amazon S3 做為 的來源 AWS DMS](CHAP_Source.S3.md)。
**Amazon DocumentDB 端點設定**
在 3.5.0 版及更高 AWS DMS 版本中，您可以透過調校平行執行緒和大量操作的任務設定，來改善 Amazon DocumentDB 端點的變更資料擷取 (CDC) 效能。若要執行此操作，您可以指定並行執行緒數目、每個執行緒的佇列數，以及使用 `ParallelApply*` 任務設定儲存在緩衝區中的記錄數目。例如，假設您要執行 CDC 載入並平行套用 128 個執行緒。您也想要每個執行緒存取 64 個佇列，且每個緩衝區儲存 50 筆記錄。
為了提升 CDC 效能， AWS DMS 支援下列任務設定：
+ `ParallelApplyThreads` – 指定在 CDC 載入期間 AWS DMS 用來將資料記錄推送至 Amazon DocumentDB 目標端點的並行執行緒數目。預設值為零 (0)，最大值為 32。
+ `ParallelApplyBufferSize`：指定每個緩衝區佇列中儲存的最大記錄數目，以便並行執行緒在 CDC 載入期間推送至 Amazon DocumentDB 目標端點。預設值為 100，最大值為 1,000。`ParallelApplyThreads` 指定多個執行緒時，請使用此選項。
+ `ParallelApplyQueuesPerThread`：指定每個執行緒存取的佇列數目，以便從佇列中取出資料記錄，並在 CDC 期間產生 Amazon DocumentDB 端點的批次載入。預設為 1。最多 512 個。
**注意**
對於 Amazon DocumentDB 目標，套用平行 CDC 可能會導致重複的金鑰錯誤，或套用停滯的 CDC 適用於使用次要唯一索引或需要嚴格排序變更的工作負載。使用這些工作負載的預設單執行緒 CDC 套用組態。
如需使用 Amazon DocumentDB 做為目標的其他詳細資訊 AWS DMS，請參閱下列章節：
**Topics**
+ [將資料從來源對應到 Amazon DocumentDB 目標](#CHAP_Target.DocumentDB.data-mapping)
+ [連線到 Amazon DocumentDB 彈性叢集作為目標](#CHAP_Target.DocumentDB.data-mapping.elastic-cluster-connect)
+ [以 Amazon DocumentDB 作為目標的進行中複寫](#CHAP_Target.DocumentDB.data-mapping.ongoing-replication)
+ [使用 Amazon DocumentDB 作為目標的限制](#CHAP_Target.DocumentDB.limitations)
+ [將端點設定與作為目標的 Amazon DocumentDB 搭配使用](#CHAP_Target.DocumentDB.ECAs)
+ [Amazon DocumentDB 的目標資料類型](#CHAP_Target.DocumentDB.datatypes)
**注意**
如需遷移程序的step-by-step演練，請參閱 AWS Database Migration Service Step-by-Step遷移指南中的[從 MongoDB 遷移至 Amazon DocumentDB](https://docs.aws.amazon.com/dms/latest/sbs/CHAP_MongoDB2DocumentDB.html)。
## 將資料從來源對應到 Amazon DocumentDB 目標
AWS DMS 從來源端點讀取記錄，並根據讀取的資料建構 JSON 文件。對於每個 JSON 文件， AWS DMS 必須決定要做為唯一識別符`_id`的欄位。接著會使用 `_id` 欄位作為主索引鍵，將 JSON 文件寫入 Amazon DocumentDB 集合。
### 單一資料行的來源資料
如果來源資料包含單一欄，則資料必須是字串類型。（視來源引擎而定，實際資料類型可能是 VARCHAR、NVARCHAR、TEXT、LOB、CLOB 或類似類型。) AWS DMS 假設資料是有效的 JSON 文件，並依原樣將資料複寫至 Amazon DocumentDB。
如果產生的 JSON 文件包含名為 `_id` 的欄位，則該欄位會用作 Amazon DocumentDB 中的唯一 `_id`。
如果 JSON 不包含 `_id` 欄位，則 Amazon DocumentDB 會自動產生 `_id` 值。
### 多個資料行的來源資料
如果來源資料包含多個資料欄，則 AWS DMS 會從所有這些資料欄建構 JSON 文件。若要判斷文件`_id`的欄位， AWS DMS 請執行下列操作：
+ 如果其中一欄名為 `_id`，則該欄中的資料會用做為目標 `_id`。
+ 如果沒有資料`_id`欄，但來源資料具有主索引鍵或唯一索引，則 AWS DMS 會使用該索引鍵或索引值做為`_id`值。主索引鍵或唯一索引的資料也會顯示為 JSON 文件中的明確欄位。
+ 如果沒有 `_id` 資料欄，也沒有主索引鍵或唯一索引，則 Amazon DocumentDB 會自動產生 `_id` 值。
### 在目標端點上強制轉換資料類型
AWS DMS 可以在寫入 Amazon DocumentDB 目標端點時修改資料結構。您可以藉由在來源端點重新命名欄和資料表，或在執行任務時提供套用的轉換規則，來請求這些變更。
#### 用巢狀 JSON 文件 (json\$1 prefix)
若要強制轉換資料類型，您可以透過手動方式或使用轉換，將 `json_` 加到來源欄名稱的字首 (也就是 `json_columnName`)。在這種情況下，該欄會建立為目標文件內的巢狀 JSON 文件，而非字串欄位。
例如，假設您希望從 MongoDB 來源端點遷移下列文件。
```
{
"_id": "1",
"FirstName": "John",
"LastName": "Doe",
"ContactDetails": "{"Home": {"Address": "Boston","Phone": "1111111"},"Work": { "Address": "Boston", "Phone": "2222222222"}}"
}
```
如果您不強制轉換任何來源資料類型，會以字串的形式將內嵌的 `ContactDetails` 文件加以遷移。
```
{
"_id": "1",
"FirstName": "John",
"LastName": "Doe",
"ContactDetails": "{\"Home\": {\"Address\": \"Boston\",\"Phone\": \"1111111\"},\"Work\": { \"Address\": \"Boston\", \"Phone\": \"2222222222\"}}"
}
```
不過，您可以新增轉換規則，以強制轉換 `ContactDetails` 為 JSON 物件。例如，假設原始的來源欄名稱為 `ContactDetails`。若要將資料類型強制設定為巢狀 JSON，必須將來源端點的資料欄重新命名為 json\$1ContactDetails”，方法是手動或透過轉換規則在來源上新增 “\$1json\$1\$1“ 前綴。例如，您可以使用下面的轉換規則：
```
{
"rules": [
{
"rule-type": "transformation",
"rule-id": "1",
"rule-name": "1",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "%",
"column-name": "ContactDetails"
},
"rule-action": "rename",
"value": "json_ContactDetails",
"old-value": null
}
]
}
```
AWS DMS 會將 ContactDetails 欄位複寫為巢狀 JSON，如下所示。
```
{
"_id": "1",
"FirstName": "John",
"LastName": "Doe",
"ContactDetails": {
"Home": {
"Address": "Boston",
"Phone": "1111111111"
},
"Work": {
"Address": "Boston",
"Phone": "2222222222"
}
}
}
```
#### 使用 JSON 陣列 (array\$1 prefix)
若要強制轉換資料類型，您可以透過手動方式或使用轉換，將 `array_` 加到欄名稱的字首 (也就是 `array_columnName`)。在此情況下， 會將資料欄 AWS DMS 視為 JSON 陣列，並在目標文件中以此方式建立資料欄。
假設您希望從 MongoDB 來源端點遷移下列文件。
```
{
"_id" : "1",
"FirstName": "John",
"LastName": "Doe",
"ContactAddresses": ["Boston", "New York"],
"ContactPhoneNumbers": ["1111111111", "2222222222"]
}
```
如果您不強制轉換任何來源資料類型，會以字串的形式將內嵌的 `ContactDetails` 文件加以遷移。
```
{
"_id": "1",
"FirstName": "John",
"LastName": "Doe",
"ContactAddresses": "[\"Boston\", \"New York\"]",
"ContactPhoneNumbers": "[\"1111111111\", \"2222222222\"]"
}
```
不過，您可以新增轉換規則，以將 `ContactAddress` 和 `ContactPhoneNumbers` 強制轉換為 JSON 陣列，如下表所示。
****
| 原始的來源資料行名稱 | 重新命名的來源資料行 |
| --- | --- |
| ContactAddress | array\$1ContactAddress |
| ContactPhoneNumbers | array\$1ContactPhoneNumbers |
AWS DMS 會複寫 `ContactAddress`和 `ContactPhoneNumbers`，如下所示。
```
{
"_id": "1",
"FirstName": "John",
"LastName": "Doe",
"ContactAddresses": [
"Boston",
"New York"
],
"ContactPhoneNumbers": [
"1111111111",
"2222222222"
]
}
```
### 使用 TLS 連接到 Amazon DocumentDB
依預設，新建立的 Amazon DocumentDB 叢集僅接受使用 Transport Layer Security (TLS) 的安全連線。啟用 TLS 時，每個 Amazon DocumentDB 連線都需要公有金鑰。
您可以從 AWS 託管的 Amazon S3 儲存貯體下載 檔案 ，以擷取 Amazon DocumentDB 的公有金鑰。 `rds-combined-ca-bundle.pem` Amazon S3 如需下載此檔案的相關資訊，請參閱《Amazon DocumentDB 開發人員指南》**中的[使用 TLS 加密連線](https://docs.aws.amazon.com/documentdb/latest/developerguide/security.encryption.ssl.html)
下載此 .pem 檔案後，您可以將其包含的公有金鑰匯入 AWS DMS ，如下所述。
#### AWS 管理主控台
**匯入公有金鑰 (.pem) 檔案**
1. 在 https：//[https://console.aws.amazon.com/dms](https://console.aws.amazon.com/dms) 開啟 AWS DMS 主控台。
1. 在導覽窗格中，選擇 **Certificates (憑證)**。
1. 選擇 **Import certificate (匯入憑證)** 並執行下列作業：
+ 針對 **Certificate identifier (憑證 ID)**，輸入憑證的唯一名稱，例如 `docdb-cert`。
+ 針對 **Import file (匯入檔案)**，導覽至 .pem 檔案的儲存位置。
當您滿意設定後，選擇 **Add new CA certificate (新增 CA 憑證)**。
#### AWS CLI
使用 `aws dms import-certificate` 命令，如下列範例所示。
```
aws dms import-certificate \
--certificate-identifier docdb-cert \
--certificate-pem file://./rds-combined-ca-bundle.pem
```
當您建立 AWS DMS 目標端點時，請提供憑證識別符 （例如 `docdb-cert`)。另外，將 SSL 模式參數設為 `verify-full`。
## 連線到 Amazon DocumentDB 彈性叢集作為目標
在 3.4.7 版和更新 AWS DMS 版本中，您可以將 Amazon DocumentDB 目標端點建立為彈性叢集。如果您將目標端點建立為彈性叢集，則需要將新的 SSL 憑證連接到 Amazon DocumentDB 彈性叢集端點，因為現有的 SSL 憑證無法運作。
**將新的 SSL 憑證連接到 Amazon DocumentDB 彈性叢集端點**
1. 例如，在瀏覽器中開啟 [https://www.amazontrust.com/repository/SFSRootCAG2.pem](https://www.amazontrust.com/repository/SFSRootCAG2.pem)，並將內容儲存到具有唯一檔案名稱的 `.pem` 檔案中，例如 `SFSRootCAG2.pem`。這是您在後續步驟中需要匯入的憑證檔案。
1. 建立 Elastic Clusters 端點並設定下列選項：
1. 在**端點組態**下，選擇**新增 CA 憑證**。
1. 然後，對於**憑證識別碼**，輸入 **SFSRootCAG2.pem**。
1. 對於**匯入憑證檔案**，選擇**選擇檔案**，然後瀏覽至您先前下載的 `SFSRootCAG2.pem` 檔案。
1. 選取檔案，然後開啟已下載的 `SFSRootCAG2.pem` 檔案。
1. 選擇 **Import certificate (匯入憑證)**。
1. 從**選擇憑證**下拉式清單中，選擇 **SFSRootCAG2.pem**。
下載 `SFSRootCAG2.pem` 檔案中的新 SSL 憑證現在會連接至 Amazon DocumentDB 彈性叢集端點。
## 以 Amazon DocumentDB 作為目標的進行中複寫
如果針對作為目標 Amazon DocumentDB 啟用進行中複寫 (變更資料擷取，CDC)，則 AWS DMS 3.5.0 版及更高版本的效能提升是舊版的二十倍。在先前的版本中， 每秒 AWS DMS 處理多達 250 筆記錄， AWS DMS 現在可有效率地每秒處理超過 5000 筆記錄。 AWS DMS 也確保 Amazon DocumentDB 中的文件與來源保持同步。建立或更新來源記錄時， AWS DMS 必須先執行下列動作來判斷哪些 Amazon DocumentDB 記錄受到影響：
+ 如果來源記錄的資料欄名為 `_id`，該資料欄的值可決定 Amazon DocumentDB 集合中對應的 `_id`。
+ 如果沒有資料`_id`欄，但來源資料具有主索引鍵或唯一索引，則 AWS DMS 會使用該索引鍵或索引值做為 Amazon DocumentDB 集合`_id`的 。
+ 如果來源記錄沒有資料`_id`欄、主索引鍵或唯一索引，則 會將所有來源資料欄 AWS DMS 比對至 Amazon DocumentDB 集合中的對應欄位。
建立新的來源記錄時， 會將對應的文件 AWS DMS 寫入 Amazon DocumentDB。如果現有來源記錄已更新， 會 AWS DMS 更新 Amazon DocumentDB 中目標文件中的對應欄位。存在於目標文件，但不在來源記錄中的任何欄位，會保持不變。
刪除來源記錄時， 會從 Amazon DocumentDB AWS DMS 刪除對應的文件。
### 來源的結構變更 (DDL)
使用進行中複寫時，對來源資料結構 (如資料表、資料欄等) 的任何變更會傳播到 Amazon DocumentDB 中的對應部分。在關聯式資料庫中，會使用資料定義語言 (DDL) 陳述式來初始化這些變更。您可以在下表中查看 如何將這些變更 AWS DMS 傳播至 Amazon DocumentDB。
****
| 來源的 DDL | 在 Amazon DocumentDB 目標的影響 |
| --- | --- |
| CREATE TABLE | 建立空集合。 |
| 重新命名資料表 (RENAME TABLE、ALTER TABLE...RENAME 等) 的陳述式 | 重新命名集合。 |
| TRUNCATE TABLE | 只有 HandleSourceTableTruncated 為 true 時，才會從集合中移除所有文件。如需詳細資訊，請參閱[變更處理 DDL 處理的任務設定](CHAP_Tasks.CustomizingTasks.TaskSettings.DDLHandling.md)。 |
| DROP TABLE | 只有 HandleSourceTableDropped 為 true 時，才會刪除集合。如需詳細資訊，請參閱[變更處理 DDL 處理的任務設定](CHAP_Tasks.CustomizingTasks.TaskSettings.DDLHandling.md)。 |
| 將欄新增到資料表 (ALTER TABLE...ADD 等) 的陳述式 | DDL 陳述式被忽略，並發出警告。當第一個 INSERT 在來源中執行，新欄位會新增到目標文件。 |
| ALTER TABLE...RENAME COLUMN | DDL 陳述式被忽略，並發出警告。當第一個 INSERT 在來源中執行，新命名的欄位會新增到目標文件。 |
| ALTER TABLE...DROP COLUMN | DDL 陳述式被忽略，並發出警告。 |
| 變更欄資料類型 (ALTER COLUMN...MODIFY 等) 的陳述式 | DDL 陳述式被忽略，並發出警告。當第一個 INSERT 與新的資料類型在來源中執行時，會使用該新資料類型的欄位來建立目標文件。 |
## 使用 Amazon DocumentDB 作為目標的限制
使用 Amazon DocumentDB 做為 的目標時，適用下列限制 AWS DMS：
+ 在 Amazon DocumentDB 中，集合名稱不能包含金錢符號 (\$1)。此外，資料庫名稱不能包含任何 Unicode 字元。
+ AWS DMS 不支援將多個來源資料表合併為單一 Amazon DocumentDB 集合。
+ 當 AWS DMS 程序從沒有主索引鍵的來源資料表變更時，該資料表中的任何 LOB 資料欄都會遭到忽略。
+ 如果 **Change table (變更資料表)** 選項已啟用，且 AWS DMS 遇到名為「*\$1id*」的來源欄，該欄會在變更資料表中顯示為「*\$1\$1id*」(兩個底線)。
+ 如果您選擇 Oracle 做為來源端點，則 Oracle 來源必須啟用完整的補充記錄。否則，如果來源中有未變更的資料欄，則資料會載入 Amazon DocumentDB 作為 Null 值。
+ 不支援將複寫任務設定 `TargetTablePrepMode:TRUNCATE_BEFORE_LOAD` 與 DocumentDB 目標端點搭配使用。
+ Amazon DocumentDB 不支援 MongoDB 上限集合。不過， AWS DMS 會自動遷移這類物件，例如目標 DocumentDB 上的無上限集合。
+ 平行 CDC 適用於 Amazon DocumentDB 目標可能會導致重複的金鑰錯誤或停滯的 CDC 適用於使用次要唯一索引或需要嚴格排序變更的工作負載。對於此類工作負載，請使用預設的單執行緒 CDC 套用組態。
## 將端點設定與作為目標的 Amazon DocumentDB 搭配使用
您可以使用端點設定來設定 Amazon DocumentDB 目標資料庫，類似於使用額外的連線屬性。當您使用 AWS DMS 主控台或使用 中的 `create-endpoint`命令搭配 `--doc-db-settings '{"EndpointSetting": "value", ...}'` JSON 語法來建立目標端點時[AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html)，您可以指定設定。
下列資料表顯示您可以在將 Amazon DocumentDB 作為目標搭配使用的端點設定。
| 屬性名稱 | 有效值 | 預設值和描述 |
| --- | --- | --- |
| `replicateShardCollections` | boolean `true` `false` | `true` 時，此端點設定會產生下列影響，並會施加下列限制： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/dms/latest/userguide/CHAP_Target.DocumentDB.html) |
## Amazon DocumentDB 的目標資料類型
在下表中，您可以找到使用 DMS 時支援的 Amazon DocumentDB AWS 目標資料類型，以及來自 DMS AWS 資料類型的預設映射。如需 AWS DMS 資料類型的詳細資訊，請參閱 [AWS Database Migration Service 的資料類型](CHAP_Reference.DataTypes.md)。
| AWS DMS 資料類型 | Amazon DocumentDB 資料類型 |
| --- | --- |
| BOOLEAN | Boolean |
| BYTES | 二進位資料 |
| DATE | Date |
| TIME | 字串 (UTF8) |
| DATETIME | Date |
| INT1 | 32 位元整數 |
| INT2 | 32 位元整數 |
| INT4 | 32 位元整數 |
| INT8 | 64 位元整數 |
| NUMERIC | 字串 (UTF8) |
| REAL4 | Double |
| REAL8 | Double |
| STRING | 如果資料辨識為 JSON，則 會將資料 AWS DMS 遷移至 Amazon DocumentDB 做為文件。否則，資料會映射到字串 (UTF8)。 |
| UINT1 | 32 位元整數 |
| UINT2 | 32 位元整數 |
| UINT4 | 64 位元整數 |
| UINT8 | 字串 (UTF8) |
| WSTRING | 如果資料辨識為 JSON，則 會將資料 AWS DMS 遷移至 Amazon DocumentDB 做為文件。否則，資料會映射到字串 (UTF8)。 |
| BLOB | 二進位 |
| CLOB | 如果資料辨識為 JSON，則 會將資料 AWS DMS 遷移至 Amazon DocumentDB 做為文件。否則，資料會映射到字串 (UTF8)。 |
| NCLOB | 如果資料辨識為 JSON，則 會將資料 AWS DMS 遷移至 Amazon DocumentDB 做為文件。否則，資料會映射到字串 (UTF8)。 |
# 使用 Amazon Neptune 做為 的目標 AWS Database Migration Service
Amazon Neptune 是快速、可靠、全受管的圖形資料庫服務，可讓您輕鬆建置和執行搭配高度連線資料集使用的應用程式。Neptune 的核心是專門打造的高效能圖形資料庫引擎。此引擎的專屬設計可儲存數十億筆關係，且查詢圖形時只會有數毫秒的延遲。Neptune 支援熱門圖形查詢語言 Apache TinkerPop Gremlin 和 W3C 的 SPARQL。如需有關 Amazon Neptune 的詳細資訊，請參閱《*Amazon Neptune 使用者指南*》中的「[什麼是 Amazon Neptune？](https://docs.aws.amazon.com/neptune/latest/userguide/intro.html) 」。
如果沒有 Neptune 這種圖形資料庫，您可能會在關聯式資料庫中模擬高度連線的資料。因為資料具有潛在的動態連線，所以使用這類資料來源的應用程式必須在 SQL 中模擬連線的資料查詢。此方法要求您編寫一個額外的圖層並將圖表查詢轉換為 SQL。此外，關聯式資料庫具有結構描述的剛性。結構描述中的任何變更以模擬變更連線，都需要停機時間和查詢轉換的額外維護，以支援新的結構描述。查詢性能也是在設計應用程式時要考慮的另一大限制。
圖形資料庫可以大幅簡化此情況。不含結構描述，豐富的圖形查詢層 (Gremlin 或 SPARQL) 和針對圖形查詢最佳化的索引提高了靈活性和性能。Amazon Neptune 圖形資料庫也具有企業功能，例如，靜態加密、安全授權層、預設備份、異地同步備份支援、僅供讀取複本支援等。
使用 AWS DMS，您可以將關聯式資料從任何支援的 SQL 資料庫的 DMS 來源端點，將高度連線圖形模型化至 Neptune 目標端點。
如需詳細資訊，請參閱下列內容。
**Topics**
+ [以 Amazon Neptune 為目標的遷移概觀](#CHAP_Target.Neptune.MigrationOverview)
+ [指定 Amazon Neptune 做為目標的端點設定](#CHAP_Target.Neptune.EndpointSettings)
+ [建立 IAM 服務角色以存取做為目標的 Amazon Neptune](#CHAP_Target.Neptune.ServiceRole)
+ [使用 Gremlin 和 R2RML 以 Amazon Neptune 做為目標指定圖形映射規則](#CHAP_Target.Neptune.GraphMapping)
+ [Amazon Neptune 做為目標遷移的 Gremlin 和 R2RML 資料類型](#CHAP_Target.Neptune.DataTypes)
+ [使用 Amazon Neptune 做為目標的限制](#CHAP_Target.Neptune.Limitations)
## 以 Amazon Neptune 為目標的遷移概觀
開始遷移至 Neptune 目標之前，請在 AWS 您的帳戶中建立下列資源：
+ 目標端點的 Neptune 叢集。
+ 來源端點支援的 SQL AWS DMS 關聯式資料庫。
+ 目標端點的 Amazon S3 儲存貯體。在與 Neptune 叢集相同的 AWS 區域中建立此 S3 儲存貯體。 會將 AWS DMS 此 S3 儲存貯體用作其大量載入至 Neptune 資料庫的目標資料的中繼檔案儲存體。如需有關建立 S3 儲存貯體的詳細資訊，請參閱《*Amazon Simple Storage Service 使用者指南*》中的「[建立儲存貯體](https://docs.aws.amazon.com/AmazonS3/latest/gsg/CreatingABucket.html)」。
+ 與 Neptune 叢集位於相同 VPC 中的 S3 虛擬私有雲端 (VPC) 端點。
+ 包含 IAM 政策的 AWS Identity and Access Management (IAM) 角色。此政策應為您的目標端點指定 S3 儲存貯體的`GetObject`、`PutObject`、`DeleteObject` 和 `ListObject` 權限。此角色由具有目標 S3 儲存貯體 AWS DMS 和 Neptune 資料庫之 IAM 存取權的 和 Neptune 擔任。如需詳細資訊，請參閱[建立 IAM 服務角色以存取做為目標的 Amazon Neptune](#CHAP_Target.Neptune.ServiceRole)。
擁有這些資源後，設定和啟動 Neptune 目標遷移與使用主控台或 DMS API 的任何完全載入遷移類似。不過，遷移至 Neptune 目標需要一些獨特的步驟。
**將 AWS DMS 關聯式資料庫遷移至 Neptune**
1. 如 [建立複寫執行個體](CHAP_ReplicationInstance.Creating.md) 所述，建立複寫執行個體。
1. 針對 AWS DMS 來源端點建立和測試 支援的 SQL 關聯式資料庫。
1. 為您的 Neptune 資料庫建立目標端點並進行測試。
若要將目標端點連接至 Neptune 資料庫，請指定 Neptune 叢集端點或 Neptune 寫入器執行個體端點的伺服器名稱。此外，請指定 的 S3 儲存貯體資料夾 AWS DMS ，以存放其中繼檔案，以便大量載入 Neptune 資料庫。
在遷移期間， 會將此 S3 儲存貯體資料夾中所有遷移的目標資料 AWS DMS 儲存到您指定的檔案大小上限。當此檔案儲存體達到此大小上限時， 會將儲存的 S3 資料 AWS DMS 大量載入目標資料庫。它會清除資料夾以啟用儲存任何其他目標資料，以便後續載入目標資料庫。如需指定這些設定的詳細資訊，請參閱 [指定 Amazon Neptune 做為目標的端點設定](#CHAP_Target.Neptune.EndpointSettings)。
1. 在步驟 1-3 中建立的資源建立完全載入複寫工作，並執行下列動作：
1. 像往常一樣使用任務資料表映射，以識別使用適當的選取項目和轉換規則從關聯式資料庫遷移的特定來源結構描述、資料表和檢視表。如需詳細資訊，請參閱[使用資料表映射指定任務設定](CHAP_Tasks.CustomizingTasks.TableMapping.md)。
1. 透過選擇以下選項之一指定目標映射，以指定來源資料表和檢視表到 Neptune 目標資料庫圖形的映射規則：
+ Gremlin JSON — 如需使用 Gemlin JSON 載入 Neptune 資料庫的相關資訊，請參閱《*Amazon Neptune 使用者指南*》中的「[Gemlin 載入資料格式](https://docs.aws.amazon.com/neptune/latest/userguide/bulk-load-tutorial-format-gremlin.html)」。
+ SPARQL RDB 到資源描述架構映射語言 (R2RML) 如需有關使用 SPARQL R2RML 的詳細資訊，請參閱《[W3C 規格 R2RML：RDB 到 RDF 映射語言](https://www.w3.org/TR/r2rml/)》。
1. 執行以下任意一項：
+ 使用 AWS DMS 主控台，在**建立資料庫遷移任務**頁面上使用圖形**映射規則指定圖形**映射選項。
+ 使用 AWS DMS API，使用 `CreateReplicationTask` API 呼叫的`TaskData`請求參數指定這些選項。
如需有關使用 Gremlin JSON 和 SPARQL R2RML 指定圖形映射規則的詳細資訊和範例，請參閱 [使用 Gremlin 和 R2RML 以 Amazon Neptune 做為目標指定圖形映射規則](#CHAP_Target.Neptune.GraphMapping)。
1. 啟動遷移任務的複寫。
## 指定 Amazon Neptune 做為目標的端點設定
若要建立或修改目標端點，您可以使用主控台或 `CreateEndpoint` 或 `ModifyEndpoint` API 作業。
對於 AWS DMS 主控台中的 Neptune 目標，請在**建立端點**或修改**端點**主控台頁面上指定**端點特定設定**。對於 `CreateEndpoint` 和 `ModifyEndpoint`，指定 `NeptuneSettings` 選項的請求參數。下列範例將示範如何使用 CLI 來做到這一點。
```
dms create-endpoint --endpoint-identifier my-neptune-target-endpoint
--endpoint-type target --engine-name neptune
--server-name my-neptune-db.cluster-cspckvklbvgf.us-east-1.neptune.amazonaws.com
--port 8192
--neptune-settings
'{"ServiceAccessRoleArn":"arn:aws:iam::123456789012:role/myNeptuneRole",
"S3BucketName":"amzn-s3-demo-bucket",
"S3BucketFolder":"amzn-s3-demo-bucket-folder",
"ErrorRetryDuration":57,
"MaxFileSize":100,
"MaxRetryCount": 10,
"IAMAuthEnabled":false}‘
```
在這裡，CLI `--server-name` 選項會指定 Neptune 叢集寫入器端點的服務器名稱。或者，您可以指定 Neptune 寫入器執行個體端點的伺服器名稱。
`--neptune-settings` 選項請求參數如下：
+ `ServiceAccessRoleArn` – (必要) 您為 Neptune 目標端點建立的服務角色的 Amazon Resource Name (ARN)。如需詳細資訊，請參閱[建立 IAM 服務角色以存取做為目標的 Amazon Neptune](#CHAP_Target.Neptune.ServiceRole)。
+ `S3BucketName` – (必要) S3 儲存貯體的名稱，此儲存貯體為 DMS 可以在將資料大量載入至 Neptune 目標資料庫之前，將遷移的圖形資料暫時儲存在 .csv 檔案的位置。DMS 會將 SQL 來源資料映射至圖形資料，然後再將其存放在這些 .csv 檔案中。
+ `S3BucketFolder` – (必要) 資料夾路徑，也就是您希望 DMS 將遷移的圖形資料儲存在 `S3BucketName` 指定的 S3 儲存貯體位置。
+ `ErrorRetryDuration` – (選用) 在引發錯誤前，DMS 等待重試將遷移圖形資料大量載入到 Neptune 目標資料庫的毫秒數。預設值為 250。
+ `MaxFileSize` – (選用) DMS 將資料大量載入到 Neptune 目標資料庫之前，儲存在 .csv 檔案中的遷移圖形資料大小上限 (以 KB 為單位)。預設值為 1,048,576 KB (1 GB)。如果成功，DMS 會清除儲存貯體，準備儲存下一批遷移的圖形資料。
+ `MaxRetryCount` – (選用) DMS 在重試將遷移圖形資料大量載入到 Neptune 目標資料庫後發生錯誤的毫秒數。預設值為 5。
+ `IAMAuthEnabled` – (選用) 如果您希望為此端點啟用 IAM 授權，請將此參數設定為 `true` 並將適當的 IAM 政策文件附加至 `ServiceAccessRoleArn` 指定的服務角色。預設值為 `false`。
## 建立 IAM 服務角色以存取做為目標的 Amazon Neptune
若要將 Neptune 作為目標存取，請使用 IAM 建立服務角色。根據您的 Neptune 端點組態，將下列部分或全部 IAM 政策和信任文件附加至此角色。建立 Neptune 端點時，您會提供此服務角色的 ARN。這樣做可讓 AWS DMS 和 Amazon Neptune 同時取得存取 Neptune 及其相關聯 Amazon S3 儲存貯體的許可。
如果您在 Neptune 端點組態將 `NeptuneSettings` 中的 `IAMAuthEnabled` 參數設定為 `true`，請將如下所示的 IAM 政策附加到您的服務角色。如果您設定 `IAMAuthEnabled` 為 `false`，則可以忽略此政策。
```
// Policy to access Neptune
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "neptune-db:*",
"Resource": "arn:aws:neptune-db:us-east-1:123456789012:cluster-CLG7H7FHK54AZGHEH6MNS55JKM/*"
}
]
}
```
上述 IAM 政策允許完整存取由 `Resource` 指定的 Neptune 目標叢集。
將如下所示的 IAM 政策附加到您的服務角色。此政策可以讓 DMS 暫時將遷移的圖形資料儲存在您為大量載入至 Neptune 目標資料庫而建立的 S3 儲存貯體中。
```
//Policy to access S3 bucket
{
"Version": "2012-10-17",
"Statement": [{
"Sid": "ListObjectsInBucket0",
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
},
{
"Sid": "AllObjectActions",
"Effect": "Allow",
"Action": ["s3:GetObject",
"s3:PutObject",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/"
]
},
{
"Sid": "ListObjectsInBucket1",
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/"
]
}
]
}
```
上述 IAM 政策允許您的帳戶查詢為 Neptune 目標建立的 S3 儲存貯體 (`arn:aws:s3:::amzn-s3-demo-bucket`) 內容。也允許您的帳戶完全操作所有儲存貯體檔案和文件夾（`arn:aws:s3:::amzn-s3-demo-bucket/`）的內容。
編輯信任關係，並將下列 IAM 角色連接至您的服務角色，以允許 AWS DMS 和 Amazon Neptune 資料庫服務擔任該角色。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "dms.amazonaws.com"
},
"Action": "sts:AssumeRole"
},
{
"Sid": "neptune",
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
如需為 Neptune 目標端點指定此服務角色的相關資訊，請參閱 [指定 Amazon Neptune 做為目標的端點設定](#CHAP_Target.Neptune.EndpointSettings)。
## 使用 Gremlin 和 R2RML 以 Amazon Neptune 做為目標指定圖形映射規則
您建立的圖形映射規則會指定如何將從 SQL 關聯式資料庫來源擷取的資料載入至 Neptune 資料庫叢集目標。這些映射規則的格式取決於，此規則是否使用 Apache TinkerPop Gremlin 載入屬性圖形或使用 R2RML 載入資源描述框架 (RDF) 資料。接下來，您可以尋找這些格式的相關資訊，以及在何處進一步了解。
當您使用主控台或 DMS API 建立遷移任務時，可以指定這些映射規則。
使用主控台，使用**建立資料庫遷移任務**頁面上的**圖形對應規則**來指定這些對應規則。在 **Graph mapping rules (圖形映射規則)** 中，您可以使用提供的編輯器直接輸入和編輯映射規則。或者，您可以瀏覽以適當的圖形映射格式包含映射規則的檔案。
使用 API，並使用 `CreateReplicationTask` API 呼叫的 `TaskData` 要求參數指定此選項。將檔案路徑設定為 `TaskData` 並以適當的圖形映射格式包含映射規則。
### 使用 Gremlin 產生屬性圖形資料的圖形映射規則
使用 Gremlin 產生屬性圖形資料，為即將根據來源資料產生的每個圖形實體提供映射規則指定一個 JSON 物件。此 JSON 的格式是專門針對大量載入 Amazon Neptune 所定義。下列範本顯示此物件中每個規則的外觀。
```
{
"rules": [
{
"rule_id": "(an identifier for this rule)",
"rule_name": "(a name for this rule)",
"table_name": "(the name of the table or view being loaded)",
"vertex_definitions": [
{
"vertex_id_template": "{col1}",
"vertex_label": "(the vertex to create)",
"vertex_definition_id": "(an identifier for this vertex)",
"vertex_properties": [
{
"property_name": "(name of the property)",
"property_value_template": "{col2} or text",
"property_value_type": "(data type of the property)"
}
]
}
]
},
{
"rule_id": "(an identifier for this rule)",
"rule_name": "(a name for this rule)",
"table_name": "(the name of the table or view being loaded)",
"edge_definitions": [
{
"from_vertex": {
"vertex_id_template": "{col1}",
"vertex_definition_id": "(an identifier for the vertex referenced above)"
},
"to_vertex": {
"vertex_id_template": "{col3}",
"vertex_definition_id": "(an identifier for the vertex referenced above)"
},
"edge_id_template": {
"label": "(the edge label to add)",
"template": "{col1}_{col3}"
},
"edge_properties":[
{
"property_name": "(the property to add)",
"property_value_template": "{col4} or text",
"property_value_type": "(data type like String, int, double)"
}
]
}
]
}
]
}
```
頂點標籤的存在意味著正在此處建立頂點。它的缺席意味著頂點是由不同的來源建立，並且這個定義只是新增頂點屬性。根據需要指定任意數目的頂點和邊緣定義，以指定整個關聯式資料庫來源的映射。
`employee` 資料表的範例規則如下。
```
{
"rules": [
{
"rule_id": "1",
"rule_name": "vertex_mapping_rule_from_nodes",
"table_name": "nodes",
"vertex_definitions": [
{
"vertex_id_template": "{emp_id}",
"vertex_label": "employee",
"vertex_definition_id": "1",
"vertex_properties": [
{
"property_name": "name",
"property_value_template": "{emp_name}",
"property_value_type": "String"
}
]
}
]
},
{
"rule_id": "2",
"rule_name": "edge_mapping_rule_from_emp",
"table_name": "nodes",
"edge_definitions": [
{
"from_vertex": {
"vertex_id_template": "{emp_id}",
"vertex_definition_id": "1"
},
"to_vertex": {
"vertex_id_template": "{mgr_id}",
"vertex_definition_id": "1"
},
"edge_id_template": {
"label": "reportsTo",
"template": "{emp_id}_{mgr_id}"
},
"edge_properties":[
{
"property_name": "team",
"property_value_template": "{team}",
"property_value_type": "String"
}
]
}
]
}
]
}
```
在這裡，頂點和邊緣定義映射從員工 ID (`EmpID`) 的 `employee` 節點和經理 ID (`managerId`) 的 `employee` 節點映射報告關係。
如需有關使用 Gemlin JSON 建立圖形映射規則的詳細資訊，請參閱《*Amazon Neptune 使用者指南*》中的「[Gemlin 載入資料格式](https://docs.aws.amazon.com/neptune/latest/userguide/bulk-load-tutorial-format-gremlin.html)」。
### 用於產生 RDF/SPARQL 資料的圖形映射規則
如果您要載入使用 SPARQL 查詢的 RDF 資料，請在 R2RML 編寫圖形映射規則。R2RML 是用於關係資料映射到 RDF 標準的 W3C 語言。在 R2RML 檔案中，*三倍映射* (例如，以下 `<#TriplesMap1>`) 指定用於將邏輯資料表中的每一行轉換為零或多個 RDF 三倍的規則。*主題映射* (例如，以下任何`rr:subjectMap`) 指定用於產生由三倍映射產生的 RDF 三倍物件的規則。*述詞物件映射* (例如，以下任何 `rr:predicateObjectMap`) 是為邏輯資料表的每個邏輯資料表行建立一個或多個述詞物件組。
`nodes` 資料表的簡單範例如下。
```
@prefix rr: .
@prefix ex: .
<#TriplesMap1>
rr:logicalTable [ rr:tableName "nodes" ];
rr:subjectMap [
rr:template "http://data.example.com/employee/{id}";
rr:class ex:Employee;
];
rr:predicateObjectMap [
rr:predicate ex:name;
rr:objectMap [ rr:column "label" ];
]
```
在前面的例子中，映射定義了從員工資料表映射的圖形節點。
`Student` 資料表的另一個簡單示例如下。
```
@prefix rr: .
@prefix ex: .
@prefix foaf: .
@prefix xsd: .
<#TriplesMap2>
rr:logicalTable [ rr:tableName "Student" ];
rr:subjectMap [ rr:template "http://example.com/{ID}{Name}";
rr:class foaf:Person ];
rr:predicateObjectMap [
rr:predicate ex:id ;
rr:objectMap [ rr:column "ID";
rr:datatype xsd:integer ]
];
rr:predicateObjectMap [
rr:predicate foaf:name ;
rr:objectMap [ rr:column "Name" ]
].
```
在前面的例子中，映射定義圖形節點映射 `Student` 資料表中的人與人之間的朋友關係。
如需有關使用 SPARQL R2RML 建立圖形映射規則的詳細資訊，請參閱 W3C 規格 [R2RML：RDB 至 RDF 映射語言](https://www.w3.org/TR/r2rml/)。
## Amazon Neptune 做為目標遷移的 Gremlin 和 R2RML 資料類型
AWS DMS 會以兩種方式之一，執行從 SQL 來源端點到 Neptune 目標的資料類型映射。您使用哪種方式取決於您用來載入 Neptune 資料庫的圖形映射格式：
+ Apache TinkerPop Gremlin，使用遷移資料的 JSON 表示形式。
+ W3C 的 SPARQL，使用遷移資料的 R2RML 表示形式。
如需這兩種圖形映射格式的詳細資訊，請參閱 [使用 Gremlin 和 R2RML 以 Amazon Neptune 做為目標指定圖形映射規則](#CHAP_Target.Neptune.GraphMapping)。
接下來，您可以找到每種格式的資料類型映射的描述。
### SQL 來源到 Gremlin 目標資料類型映射
以下資料表顯示從 SQL 來源到 Gremlin 格式化目標的資料類型映射。
AWS DMS 會將任何未列出的 SQL 來源資料類型映射至 Gremlin `String`。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/dms/latest/userguide/CHAP_Target.Neptune.html)
如需用於載入 Neptune 的 Gemlin 資料類型的詳細資訊，請參閱《*Neptune 使用者指南*》中的《[Gemlin 資料類型](https://docs.aws.amazon.com//neptune/latest/userguide/bulk-load-tutorial-format-gremlin.html#bulk-load-tutorial-format-gremlin-datatypes)》。
### SQL 來源到 R2RML (RDF) 目標資料類型映射
以下資料表顯示從 SQL 來源到 R2RML 格式化目標的資料類型映射。
所有列出的 RDF 資料類型都區分大小寫，但 RDF literal. AWS DMS maps 任何未列出的 SQL 來源資料類型到 RDF 常值。
*RDF 常值*是多種常值語彙形式和資料類型之一。如需詳細資訊，請參閱 W3C 規格*資源描述架構 (RDF)：概念和抽象語法*中的「[RDF 常值](https://www.w3.org/TR/2004/REC-rdf-concepts-20040210/#section-Graph-Literal)」。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/dms/latest/userguide/CHAP_Target.Neptune.html)
如需有關載入 Neptune 的 RDF 資料類型，及其對應至 SQL 來源資料類型的詳細資訊，請參閱 W3C 規格 *R2RML：RDB 至 RDF 對應語言*的「[資料類型轉換](https://www.w3.org/TR/r2rml/#datatype-conversions)」。
## 使用 Amazon Neptune 做為目標的限制
使用 Neptune 做為目標時，有下列限制：
+ AWS DMS 目前僅支援將完全載入任務遷移至 Neptune 目標。未支援變更資料擷取 (CDC) 遷移至 Neptune 目標。
+ 在啟動遷移任務之前，請確定您的目標 Neptune 資料庫已手動清除所有資料，如以下範例所示。
若要刪除圖形中的所有資料 (頂點和邊緣)，需運行以下 Gremlin 命令。
```
gremlin> g.V().drop().iterate()
```
若要刪除具有標籤 `'customer'` 的頂點，需運行以下 Gremlin 命令。
```
gremlin> g.V().hasLabel('customer').drop()
```
**注意**
需要一些時間來刪除大型資料集。您可能想要逐一查看 `drop()` 的一個限制，例如，`limit(1000)`。
若要刪除具有標籤 `'rated'` 的邊緣，需運行以下 Gremlin 命令。
```
gremlin> g.E().hasLabel('rated').drop()
```
**注意**
需要一些時間來刪除大型資料集。您可能想要逐一查看 `drop()` 的一個限制，例如，`limit(1000)`。
+ DMS API 作業 `DescribeTableStatistics` 可能會傳回有關給予資料表的不正確結果，因為 Neptune 圖形資料結構的性質。
在遷移期間， AWS DMS 會掃描每個來源資料表，並使用圖形映射將來源資料轉換為 Neptune 圖形。轉換後的資料會先儲存在為目標端點指定的 S3 儲存貯體資料夾中。如果掃描來源並成功產生此中繼 S3 資料，則 `DescribeTableStatistics` 會假設資料已成功載入至 Neptune 目標資料庫。但這並不是都是正確的。若要驗證給予資料表的資料已正確載入，請比較該資料表遷移兩端的 `count()` 傳回值。
在下列範例中， AWS DMS 已從來源資料庫載入`customer`資料表，並在目標 Neptune 資料庫圖表`'customer'`中指派標籤。您可以確認此標籤已寫入目標資料庫。若要執行此動作，請將來源資料庫中的可用 `customer` 列數與任務完成後載入 Neptune 目標資料庫中的 `'customer'` 標籤列數進行比較。
若要使用 SQL 從來源資料庫取得可用的客戶資料列數，請執行下列動作。
```
select count(*) from customer;
```
使用 Gremlin 載入至目標資料庫圖形中的 `'customer'` 標籤列數，請運行以下命令。
```
gremlin> g.V().hasLabel('customer').count()
```
+ 目前，如果任何單一資料表載入失敗，整個任務就會失敗。與關聯式資料庫目標不同，Neptune 中的資料是高度連線的，這使得在許多情況下無法繼續任務。如果因為這種類型的資料載入失敗而無法順利繼續任務，請建立新的任務以載入無法載入的資料表。在執行新任務之前，請從 Neptune 目標手動清除部分載入的資料表。
**注意**
如果失敗可復原 (例如，網路傳輸錯誤)，您可以繼續無法遷移至 Neptune 目標的任務。
+ AWS DMS 支援大多數 R2RML 標準。不過， AWS DMS 不支援某些 R2RML 標準，包括反向表達式、聯結和檢視。R2RML 檢視表的解決方法是在來源資料庫中建立對應的自訂 SQL 檢視表。在遷移任務中，使用資料表映射選擇檢視表做為輸入。然後將檢視表對應到 R2RML 消耗的資料表，以產生圖形資料。
+ 當您使用不支援的 SQL 資料類型遷移來源資料時，產生的目標資料可能會遺失精確度。如需詳細資訊，請參閱[Amazon Neptune 做為目標遷移的 Gremlin 和 R2RML 資料類型](#CHAP_Target.Neptune.DataTypes)。
+ AWS DMS 不支援將 LOB 資料遷移至 Neptune 目標。
# 使用 Redis OSS 做為 的目標 AWS Database Migration Service
Redis OSS 是開放原始碼的記憶體內資料結構存放區，用作資料庫、快取和訊息中介裝置。在記憶體內管理資料可讓讀取或寫入操作僅需不到一毫秒的時間，而且每秒能執行數億個操作。作為記憶體內資料存放區，Redis OSS 支援需要低於毫秒回應時間的最嚴苛應用程式。
使用 AWS DMS，您可以將資料從任何支援的來源資料庫遷移到目標 Redis OSS 資料存放區，並將停機時間降至最低。如需 Redis OSS 的詳細資訊，請參閱 [Redis OSS 文件](https://redis.io/documentation)。
除了現場部署 Redis OSS 之外， AWS Database Migration Service 還支援下列項目：
+ [Amazon ElastiCache (Redis OSS)](https://aws.amazon.com/elasticache/redis/) 做為目標資料存放區。ElastiCache (Redis OSS) 可與 Redis OSS 用戶端搭配使用，並使用開啟的 Redis OSS 資料格式來存放您的資料。
+ [Amazon MemoryDB](https://aws.amazon.com/memorydb/) 做為目標資料存放區。MemoryDB 與 Redis OSS 相容，可讓您使用目前使用的所有 Redis OSS 資料結構、APIs和命令來建置應用程式。
如需使用 Redis OSS 做為 目標的其他資訊 AWS DMS，請參閱下列章節：
**Topics**
+ [使用 Redis OSS 叢集做為 目標的先決條件 AWS DMS](#CHAP_Target.Redis.Prerequisites)
+ [使用 Redis 做為 目標的限制 AWS Database Migration Service](#CHAP_Target.Redis.Limitations)
+ [從關聯式或非關聯式資料庫將資料遷移至 Redis OSS 目標](#CHAP_Target.Redis.Migrating)
+ [將 Redis OSS 的端點設定指定為目標](#CHAP_Target.Redis.EndpointSettings)
## 使用 Redis OSS 叢集做為 目標的先決條件 AWS DMS
DMS 支援獨立組態中的內部部署 Redis OSS 目標，或做為 Redis OSS 叢集，其中資料會自動*分片*到多個節點。碎片化是將資料分成較小區塊 (稱為碎片) 的過程，這些區塊會分散在多個服務器或節點上。實際上，碎片是一個資料分割區，其中包含總資料集的子集，並負責整體工作負載的一部分。
由於 Redis OSS 是 NoSQL 資料存放區的鍵值，因此當您的來源是關聯式資料庫時，要使用的 Redis OSS 金鑰命名慣例為 **schema-name.table-name.primary-key**。在 Redis OSS 中，索引鍵和值不得包含特殊字元 %。否則，DMS 會略過該記錄。
**注意**
如果您使用 ElastiCache (Redis OSS) 做為目標，DMS 僅支援*啟用叢集模式*的組態。如需使用 ElastiCache (Redis OSS) 6.x 版或更新版本來建立啟用叢集模式的目標資料存放區的詳細資訊，請參閱《*Amazon ElastiCache (Redis OSS) 使用者指南*》中的[入門](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/GettingStarted.html)。
開始資料庫遷移之前，請使用下列條件啟動 Redis OSS 叢集。
+ 您的叢集有一個或多個碎片。
+ 如果您使用的是 ElastiCache (Redis OSS) 目標，請確定您的叢集未使用 IAM 角色型存取控制。反之，請使用 Redis OSS 身分驗證來驗證使用者。
+ 啟用異地同步備份 (可用區域)。
+ 請確定叢集有足夠的記憶體容量，可儲存從資料庫遷移過來的資料。
+ 在開始初始遷移任務之前，請確定您的目標 Redis OSS 叢集沒有所有資料。
在建立叢集組態之前，您應該先決定資料遷移的安全性需求。DMS 支援遷移至目標複寫群組，無論其加密組態為何。但是，您只能在建立叢集組態時啟用或停用加密。
## 使用 Redis 做為 目標的限制 AWS Database Migration Service
使用 Redis OSS 做為目標時，適用下列限制：
+ 由於 Redis OSS 是金鑰值 no-sql 資料存放區，因此當您的來源是關聯式資料庫時，要使用的 Redis OSS 金鑰命名慣例為 `schema-name.table-name.primary-key`。
+ 在 Redis OSS 中，索引鍵值不能包含特殊字元 `%`。否則，DMS 會略過該記錄。
+ DMS 不會遷移包含 `%` 字元的資料列。
+ DMS 不會遷移包含欄位名稱中`%`字元的欄位。
+ 不支援完全的 LOB 模式。
+ 使用 ElastiCache (Redis OSS) 做為目標時，不支援私有憑證授權機構 (CA)。
+ AWS DMS 使用 Redis 做為目標端點時， 不支援包含內嵌`'\0'`字元的來源資料。包含內嵌`'\0'`字元的資料會在第一個`'\0'`字元被截斷。
## 從關聯式或非關聯式資料庫將資料遷移至 Redis OSS 目標
您可以將資料從任何來源 SQL 或 NoSQL 資料存放區直接遷移至 Redis OSS 目標。設定和開始遷移至 Redis OSS 目標類似於使用 DMS 主控台或 API 的任何完全載入和變更資料擷取遷移。若要執行資料庫遷移至 Redis OSS 目標，請執行下列動作。
+ 建立複寫執行個體，以執行遷移的所有程序。如需詳細資訊，請參閱[建立複寫執行個體](CHAP_ReplicationInstance.Creating.md)。
+ 指定來源端點。如需詳細資訊，請參閱[來源與目標端點](CHAP_Endpoints.Creating.md)。
+ 尋找叢集的 DNS 名稱和連接埠號碼。
+ 下載憑證套件，可用其來驗證 SSL 連線。
+ 指定目標端點，如下所述。
+ 建立單一任務或一組任務來定義您希望使用的資料表和複寫程序。如需詳細資訊，請參閱[建立任務](CHAP_Tasks.Creating.md)。
+ 將來源資料庫中的資料遷移至目標叢集。
開始資料庫遷移的方法有兩種：
1. 您可以選擇 AWS DMS 主控台，並在其中執行每個步驟。
1. 您可以使用 AWS Command Line Interface (AWS CLI)。如需搭配 使用 CLI 的詳細資訊 AWS DMS，請參閱 [AWS CLI for AWS DMS](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html)。
**若要尋找叢集的 DNS 名稱和連接埠號碼**
+ 使用以下 AWS CLI 命令為 提供複寫群組`replication-group-id`的名稱。
```
aws elasticache describe-replication-groups --replication-group-id myreplgroup
```
此處的輸出會顯示 `Address` 屬性中的 DNS 名稱，以及叢集中主節點 `Port` 屬性中的連接埠號碼。
```
...
"ReadEndpoint": {
"Port": 6379,
"Address": "myreplgroup-
111.1abc1d.1111.uuu1.cache.example.com"
}
...
```
如果您使用 MemoryDB 做為目標，請使用下列 AWS CLI 命令將端點地址提供給 Redis OSS 叢集。
```
aws memorydb describe-clusters --clusterid clusterid
```
**下載憑證套件以用於驗證 SSL 連線**
+ 在命令列輸入下列 `wget` 命令。Wget 是一個免費的 GNU 命令行公用程式工具，用於從網路下載文件。
```
wget https://s3.aws-api-domain/rds-downloads/rds-combined-ca-bundle.pem
```
在此， 會`aws-api-domain`完成您 AWS 區域中存取指定 S3 儲存貯體所需的 Amazon S3 網域，以及其提供的 rds-combined-ca-bundle.pem 檔案。
**使用 AWS DMS 主控台建立目標端點**
此端點適用於已在執行的 Redis OSS 目標。
+ 在主控台中，在導覽窗格中選擇**端點**，然後選擇**建立端點**。下表說明相關設定。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/dms/latest/userguide/CHAP_Target.Redis.html)
當您完成提供端點的所有資訊時， AWS DMS 會建立您的 Redis OSS 目標端點，以便在資料庫遷移期間使用。
如需建立遷移任務和開始資料庫遷移的相關資訊，請參閱 [建立任務](CHAP_Tasks.Creating.md)。
## 將 Redis OSS 的端點設定指定為目標
若要建立或修改目標端點，您可以使用主控台或 `CreateEndpoint` 或 `ModifyEndpoint` API 作業。
對於 AWS DMS 主控台中的 Redis OSS 目標，請在**建立端點**或修改**端點**主控台頁面上指定**端點特定設定**。
使用 `CreateEndpoint` 和 `ModifyEndpoint` API 操作時，請指定 `RedisSettings` 選項的要求參數。以下的範例示範如何使用 AWS CLI進行此設定。
```
aws dms create-endpoint --endpoint-identifier my-redis-target
--endpoint-type target --engine-name redis --redis-settings
'{"ServerName":"sample-test-sample.zz012zz.cluster.eee1.cache.bbbxxx.com","Port":6379,"AuthType":"auth-token",
"SslSecurityProtocol":"ssl-encryption", "AuthPassword":"notanactualpassword"}'
{
"Endpoint": {
"EndpointIdentifier": "my-redis-target",
"EndpointType": "TARGET",
"EngineName": "redis",
"EngineDisplayName": "Redis",
"TransferFiles": false,
"ReceiveTransferredFiles": false,
"Status": "active",
"KmsKeyId": "arn:aws:kms:us-east-1:999999999999:key/x-b188188x",
"EndpointArn": "arn:aws:dms:us-east-1:555555555555:endpoint:ABCDEFGHIJKLMONOPQRSTUVWXYZ",
"SslMode": "none",
"RedisSettings": {
"ServerName": "sample-test-sample.zz012zz.cluster.eee1.cache.bbbxxx.com",
"Port": 6379,
"SslSecurityProtocol": "ssl-encryption",
"AuthType": "auth-token"
}
}
}
```
`--redis-settings` 參數如下：
+ `ServerName`–（必要） 在類型 中`string`，指定資料將遷移到的 Redis OSS 叢集，並位於相同的 VPC 中。
+ `Port`–(必要) 類型為 `number`，用於存取端點的連接埠值。
+ `SslSecurityProtocol`–(選用) 有效值包括 `plaintext` 和 `ssl-encryption`。預設值為 `ssl-encryption`。
`plaintext` 選項不為端點和資料庫之間的流量提供 Transport Layer Security (TLS) 加密。
使用 `ssl-encryption` 建立加密連線。 `ssl-encryption` 不需要 SSL 憑證授權機構 (CA) ARN 來驗證伺服器的憑證，但可以選擇使用 `SslCaCertificateArn` 設定進行身分識別。如果未提供憑證授權機構 ARN，DMS 會使用 Amazon 根 CA。
使用內部部署 Redis OSS 目標時，您可以使用 `SslCaCertificateArn` 將公有或私有憑證授權機構 (CA) 匯入 DMS，並提供該 ARN 進行伺服器身分驗證。使用 ElastiCache (Redis OSS) 做為目標時，不支援私有 CA。
+ `AuthType`–（必要） 指出連線至 Redis OSS 時要執行的身分驗證類型。有效值包括 `none`、`auth-token` 與 `auth-role`。
`auth-token` 選項需要提供「*AuthPassword*」，而 `auth-role` 選項需要提供「*AuthUserName*」和「*AuthPassword*」。
# 使用 Babelfish 做為 的目標 AWS Database Migration Service
您可以使用 將資料從 Microsoft SQL Server 來源資料庫遷移至 Babelfish 目標 AWS Database Migration Service。
Babelfish for Aurora PostgreSQL 會擴展您的 Amazon Aurora PostgreSQL 相容版本，使其能夠接受來自 Microsoft SQL Server 用戶端的資料庫連線。這樣做可讓原本為 SQL Server 建置的應用程式直接使用 Aurora PostgreSQL，相較於傳統遷移，程式碼只需稍微變更，不需要變更資料庫驅動程式。
如需 AWS DMS 支援做為目標的 Babelfish 版本資訊，請參閱 [的目標 AWS DMS](CHAP_Introduction.Targets.md)。在 Aurora PostgreSQL 上使用舊版的 Babelfish 需要升級，然後才能使用 Babelfish 端點。
**注意**
Aurora PostgreSQL 目標端點是將資料遷移至 Babelfish 的慣用方式。如需詳細資訊，請參閱[使用 Babelfish for Aurora PostgreSQL 作為目標](CHAP_Target.PostgreSQL.md#CHAP_Target.PostgreSQL.Babelfish)。
如需使用 Babelfish 作為資料庫端點的相關資訊，請參閱《適用於 Aurora 的 Amazon Aurora 使用者指南》**中的 [Babelfish for Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html)
## 使用 Babelfish 做為 目標的先決條件 AWS DMS
您必須在遷移資料之前建立資料表，以確保 AWS DMS 使用正確的資料類型和資料表中繼資料。如果您在執行遷移之前未在目標上建立資料表， AWS DMS 可能會建立具有不正確資料類型和許可的資料表。例如， 會改為將時間戳記欄 AWS DMS 建立為二進位 (8)，且 不提供預期的時間戳記/rowversion 功能。
**在遷移前準備和建立資料表**
1. 執行包含任何唯一限制、主索引鍵或預設限制的建立資料表 DDL 陳述式。
請勿包含外部索引鍵限制，或是檢視、預存程序、函數或觸發程序等物件的任何 DDL 陳述式。您可以在遷移來源資料庫之後套用這些項目。
1. 識別任何身分識別資料欄、計算的資料欄或內含資料表之資料列版本或時間戳記資料類型的資料欄。然後，建立必要的轉換規則，以處理執行遷移任務時的已知問題。如需更多詳細資訊，請參閱[轉換規則與動作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)。
1. 識別具有 Babelfish 不支援之資料類型的資料欄。然後，變更目標資料表中受影響的資料欄，以使用支援的資料類型，或建立轉換規則以在遷移任務期間移除這些資料欄。如需更多詳細資訊，請參閱[轉換規則與動作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)。
下表列出 Babelfish 不支援的來源資料類型，以及要使用的對應建議目標資料類型。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/dms/latest/userguide/CHAP_Target.Babelfish.html)
**為 Aurora PostgreSQL Serverless V2 來源資料庫設定 Aurora 容量單位 (ACU)**
您可以透過設定最小 ACU 值，在執行 AWS DMS 遷移任務之前改善遷移任務的效能。
+ 在 **Serverless v2 容量設定**視窗中，將**最小 ACU** 設定為 **2**，或為 Aurora 資料庫叢集設定合理層級。
如需設定 Aurora 容量單位的詳細資訊，請參閱《Amazon Aurora 使用者指南》**中的[選擇 Aurora 叢集的 Aurora Serverless v2 容量範圍](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/aurora-serverless-v2.setting-capacity.html)
執行 AWS DMS 遷移任務後，您可以將 ACUs的最小值重設為 Aurora PostgreSQL Serverless V2 來源資料庫的合理層級。
## 使用 Babelfish 做為 目標時的安全需求 AWS Database Migration Service
以下說明 AWS DMS 搭配 Babelfish 目標使用 的安全需求：
+ 用來建立資料庫的管理員使用者名稱 (管理員使用者)。
+ PSQL 登入和具有充足 SELECT、INSERT、UPDATE、DELETE 和 REFERENCES 許可的使用者。
## 使用 Babelfish 做為 目標的使用者許可 AWS DMS
**重要**
基於安全考量，用於資料遷移的使用者帳戶必須是您作為目標使用之任何 Babelfish 資料庫的註冊使用者。
Babelfish 目標端點需要最基本使用者許可才能執行 AWS DMS 遷移。
**若要建立登入和低權限 Transact-SQL (T-SQL) 使用者**
1. 建立連線至伺服器時要使用的登入和密碼。
```
CREATE LOGIN dms_user WITH PASSWORD = 'password';
GO
```
1. 為 Babelfish 叢集建立虛擬資料庫。
```
CREATE DATABASE my_database;
GO
```
1. 建立目標資料庫的 T-SQL 使用者。
```
USE my_database
GO
CREATE USER dms_user FOR LOGIN dms_user;
GO
```
1. 對於 Babelfish 資料庫中的每個資料表，對這些資料表的 GRANT 許可。
```
GRANT SELECT, DELETE, INSERT, REFERENCES, UPDATE ON [dbo].[Categories] TO dms_user;
```
## 使用 Babelfish 做為 目標的限制 AWS Database Migration Service
使用 Babelfish 資料庫作為 AWS DMS目標時有下列限制：
+ 僅支援資料表準備模式「**不執行任何操作**」。
+ ROWVERSION 資料類型需要資料表對應規則，該規則會在遷移任務期間將資料欄名稱從資料表中移除。
+ 不支援 sql\$1variant 資料類型。
+ 不支援完整 LOB 模式。使用 SQL Server 作為來源端點時，必須設定 SQL Server 端點連線屬性設定 `ForceFullLob=True`，才能將 LOB 遷移至目標端點。
+ 複寫任務設定具有下列限制：
```
{
"FullLoadSettings": {
"TargetTablePrepMode": "DO_NOTHING",
"CreatePkAfterFullLoad": false,
}.
}
```
+ Babelfish 中的 TIME(7)、DATETIME2(7) 和 DATETIMEOFFSET(7) 資料類型會將時間秒部分的精確度值限制為 6 位數。使用這些資料類型時，請考慮為目標資料表使用精確度值 6。對於 Babelfish 2.2.0 版及更高版本，當使用 TIME(7) 和 DATETIME2(7) 時，精確度的第七位數字始終為零。
+ 在 DO\$1NOTHING 模式下，DMS 會檢查資料表是否已存在。如果資料表不存在於目標結構描述中，DMS 會根據來源資料表定義建立資料表，並將任何使用者定義的資料類型對應至其基底資料類型。
+ Babelfish 目標的 AWS DMS 遷移任務不支援具有使用 ROWVERSION 或 TIMESTAMP 資料類型之資料欄的資料表。您可以使用資料表對應規則，在轉移過程中將資料欄名稱從資料表中移除。以下轉換規則範例中，會轉換來源中名為 `Actor` 的資料表，以將所有開頭為 `col` 字元的資料欄從目標中的 `Actor` 資料表中移除。
```
{
"rules": [{
"rule-type": "selection",is
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "test",
"table-name": "%"
},
"rule-action": "include"
}, {
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-action": "remove-column",
"rule-target": "column",
"object-locator": {
"schema-name": "test",
"table-name": "Actor",
"column-name": "col%"
}
}]
}
```
+ 對於具有身分識別或計算資料欄的資料表，其中目標資料表使用混合大小寫名稱 (例如類別)，您必須建立轉換規則動作，將 DMS 任務的資料表名稱轉換為小寫。下列範例示範如何建立轉換規則動作，使用 AWS DMS 主控台**進行小寫**。如需詳細資訊，請參閱[轉換規則與動作](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Transformations.md)。
![\[Babelfish 轉換規則\]](http://docs.aws.amazon.com/zh_tw/dms/latest/userguide/images/datarep-babelfish-transform-1.png)
+ 在 Babelfish 版本 2.2.0 之前，DMS 會將您可複製到 Babelfish 目標端點的資料欄數量限制為二十 (20) 個資料欄。使用 Babelfish 2.2.0 時，上限提高到 100 個資料欄。但是在 Babelfish 2.4.0 版及更高版本中，您可以複寫的資料欄數再次提高。您可以針對 SQL Server 資料庫執行下列程式碼範例，以判斷哪些資料表太長。
```
USE myDB;
GO
DECLARE @Babelfish_version_string_limit INT = 8000; -- Use 380 for Babelfish versions before 2.2.0
WITH bfendpoint
AS (
SELECT
[TABLE_SCHEMA]
,[TABLE_NAME]
, COUNT( [COLUMN_NAME] ) AS NumberColumns
, ( SUM( LEN( [COLUMN_NAME] ) + 3)
+ SUM( LEN( FORMAT(ORDINAL_POSITION, 'N0') ) + 3 )
+ LEN( TABLE_SCHEMA ) + 3
+ 12 -- INSERT INTO string
+ 12) AS InsertIntoCommandLength -- values string
, CASE WHEN ( SUM( LEN( [COLUMN_NAME] ) + 3)
+ SUM( LEN( FORMAT(ORDINAL_POSITION, 'N0') ) + 3 )
+ LEN( TABLE_SCHEMA ) + 3
+ 12 -- INSERT INTO string
+ 12) -- values string
>= @Babelfish_version_string_limit
THEN 1
ELSE 0
END AS IsTooLong
FROM [INFORMATION_SCHEMA].[COLUMNS]
GROUP BY [TABLE_SCHEMA], [TABLE_NAME]
)
SELECT *
FROM bfendpoint
WHERE IsTooLong = 1
ORDER BY TABLE_SCHEMA, InsertIntoCommandLength DESC, TABLE_NAME
;
```
## Babelfish 的目標資料類型
下表顯示使用 時支援的 Babelfish 目標資料類型， AWS DMS 以及來自 AWS DMS 資料類型的預設映射。
如需 AWS DMS 資料類型的詳細資訊，請參閱 [AWS Database Migration Service 的資料類型](CHAP_Reference.DataTypes.md)。
| AWS DMS 資料類型 | Babelfish 資料類型 |
| --- | --- |
| BOOLEAN | TINYINT |
| BYTES | VARBINARY (長度) |
| DATE | DATE |
| TIME | TIME |
| INT1 | SMALLINT |
| INT2 | SMALLINT |
| INT4 | INT |
| INT8 | BIGINT |
| NUMERIC | NUMERIC(p,s) |
| REAL4 | REAL |
| REAL8 | FLOAT |
| STRING | 如果資料行是日期或時間資料行，請執行下列動作： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/dms/latest/userguide/CHAP_Target.Babelfish.html) 如果資料行不是日期或時間資料行，請使用 VARCHAR (長度)。 |
| UINT1 | TINYINT |
| UINT2 | SMALLINT |
| UINT4 | INT |
| UINT8 | BIGINT |
| WSTRING | NVARCHAR(length) |
| BLOB | VARBINARY(max) 若要在 DMS 使用此資料類型，您必須針對特定任務使用 BLOB。DMS 只在有主索引鍵的資料表中支援 BLOB 資料類型。 |
| CLOB | VARCHAR(max) 若要在 DMS 使用此資料類型，您必須針對特定任務使用 CLOB。 |
| NCLOB | NVARCHAR(max) 若要在 DMS 使用此資料類型，您必須針對特定任務使用 NCLOB。在 CDC 期間，DMS 只在包含主索引鍵的資料表中支援 NCLOB 資料類型。 |
# 使用 Amazon Timestream 做為 的目標 AWS Database Migration Service
您可以使用 AWS Database Migration Service 將資料從來源資料庫遷移至 Amazon Timestream 目標端點，並支援完全載入和 CDC 資料遷移。
Amazon Timestream 是一項專為大量資料擷取而建置之快速、可擴展且無伺服器的時間序列資料庫服務。時間序列資料是在一段時間間隔內收集的資料點序列，用於測量隨時間變更的事件。它可用來收集、儲存和分析來自 IoT 應用程式、DevOps 應用程式和分析應用程式的指標。在 Timestream 中取得資料後，您可以近乎即時地視覺化並識別資料中的趨勢和模式。如需 Amazon Timestream 的相關資訊，請參閱《Amazon Timestream 開發人員指南》**中的[什麼是 Amazon Timestream？](https://docs.aws.amazon.com/timestream/latest/developerguide/what-is-timestream.html)。
**Topics**
+ [使用 Amazon Timestream 做為 目標的先決條件 AWS Database Migration Service](#CHAP_Target.Timestream.Prerequisites)
+ [多執行緒完全載入任務設定](#CHAP_Target.Timestream.FLTaskSettings)
+ [多執行緒 CDC 載入任務設定](#CHAP_Target.Timestream.CDCTaskSettings)
+ [使用 Timestream 做為 目標時的端點設定 AWS DMS](#CHAP_Target.Timestream.ConnectionAttrib)
+ [建立和修改 Amazon Timestream 目標端點](#CHAP_Target.Timestream.CreateModifyEndpoint)
+ [使用物件映射將資料遷移到 Timestream 主題](#CHAP_Target.Timestream.ObjectMapping)
+ [使用 Amazon Timestream 做為 目標的限制 AWS Database Migration Service](#CHAP_Target.Timestream.Limitations)
## 使用 Amazon Timestream 做為 目標的先決條件 AWS Database Migration Service
將 Amazon Timestream 設定為 的目標之前 AWS DMS，請務必建立 IAM 角色。此角色必須允許 AWS DMS 存取要遷移至 Amazon Timestream 的資料。下列 IAM 政策顯示您用來遷移至 Timestream 之角色的最低存取權限集。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowDescribeEndpoints",
"Effect": "Allow",
"Action": [
"timestream:DescribeEndpoints"
],
"Resource": "*"
},
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"timestream:ListTables",
"timestream:DescribeDatabase"
],
"Resource": "arn:aws:timestream:us-east-1:123456789012:database/DATABASE_NAME"
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"timestream:DeleteTable",
"timestream:WriteRecords",
"timestream:UpdateTable",
"timestream:CreateTable"
],
"Resource": "arn:aws:timestream:us-east-1:123456789012:database/DATABASE_NAME/table/TABLE_NAME"
}
]
}
```
------
如果您要遷移所有資料表，請在上述範例中使用 `*` 做為 *TABLE\$1NAME*。
請注意以下有關使用 Timestream 做為目標的事項：
+ 如果您想要擷取時間戳記超過 1 年的歷史資料，建議使用 AWS DMS 並以逗號分隔值 (csv) 格式將資料寫入 Amazon S3。然後，使用 Timestream 的批次載入將資料擷取至 Timestream。如需詳細資訊，請參閱《Amazon Timestream 開發人員指南》[https://docs.aws.amazon.com/timestream/latest/developerguide/what-is-timestream.html](https://docs.aws.amazon.com/timestream/latest/developerguide/what-is-timestream.html)中的[在 Timestream 中使用批次載入](https://docs.aws.amazon.com/timestream/latest/developerguide/batch-load.html)。
+ 對於 1 年以內資料的完全載入資料遷移，我們建議將 Timestream 資料表的記憶體存放區保留期設定為大於或等於最舊的時間戳記。然後，當完成遷移後，將資料表的記憶體存放區保留編輯為所需的值。例如，若要遷移最舊時間戳記為 2 個月的資料，請執行下列動作：
+ 將 Timestream 目標資料表的記憶體存放區保留時間設定為 2 個月。
+ 使用 開始資料遷移 AWS DMS。
+ 完成資料遷移後，請將目標 Timestream 資料表的保留期變更為所需的值。
建議您使用下列頁面上的資訊，在遷移之前先預估記憶體存放區成本：
+ [Amazon Timestream 定價](https://aws.amazon.com/timestream/pricing)
+ [AWS 定價計算器](https://calculator.aws/#/addService)
+ 對於 CDC 資料遷移，建議您設定目標資料表的記憶體存放區保留期，使擷取的資料處於記憶體存放區保留限制內。如需詳細資訊，請參閱《Amazon Timestream 開發人員指南》[https://docs.aws.amazon.com/timestream/latest/developerguide/what-is-timestream.html](https://docs.aws.amazon.com/timestream/latest/developerguide/what-is-timestream.html)中的[寫入最佳實務](https://docs.aws.amazon.com/timestream/latest/developerguide/data-ingest.html)。
## 多執行緒完全載入任務設定
為了協助提高資料傳輸速度， AWS DMS 使用以下任務設定，支援多執行緒完全載入遷移任務到 Timestream 目標端點：
+ `MaxFullLoadSubTasks`：使用此選項，指出要平行載入的來源資料表數目上限。DMS 會使用專用子任務，將每個資料表載入到其對應的 Amazon Timestream 目標資料表。預設值為 8；最大值為 49。
+ `ParallelLoadThreads` – 使用此選項指定 AWS DMS 用來將每個資料表載入其 Amazon Timestream 目標資料表的執行緒數目。Timestream 目標的最大值為 32。您可以要求提高此上限。
+ `ParallelLoadBufferSize`：使用此選項，指定要在平行載入執行緒用來將資料載入至 Amazon Timestream 目標的緩衝區中存放的記錄數量上限。預設值為 50。最大值為 1000。使用此設定搭配 `ParallelLoadThreads`；`ParallelLoadBufferSize`，只有在有多個執行緒時才有效。
+ `ParallelLoadQueuesPerThread`：使用此選項指定每個並行執行緒存取的佇列數目，以便將資料記錄從佇列中取出，並為目標產生批次載入。預設為 1。但是，對於各種承載大小的 Amazon Timestream 目標，有效範圍為每個執行緒 5–512 個佇列。
## 多執行緒 CDC 載入任務設定
為了提升 CDC 效能， AWS DMS 支援下列任務設定：
+ `ParallelApplyThreads` – 指定在 CDC 載入期間 AWS DMS 用來將資料記錄推送至 Timestream 目標端點的並行執行緒數目。預設值為 0，最大值為 32。
+ `ParallelApplyBufferSize`：指定每個緩衝區佇列中存放的最大記錄數目，以便並行執行緒在 CDC 載入期間推送至 Timestream 目標端點。預設值為 100，最大值為 1,000。`ParallelApplyThreads` 指定多個執行緒時，請使用此選項。
+ `ParallelApplyQueuesPerThread`：指定每個執行緒存取的佇列數目，以便從佇列中取出資料記錄，並在 CDC 期間產生 Timestream 端點的批次載入。預設值為 １，最大值為 512。
## 使用 Timestream 做為 目標時的端點設定 AWS DMS
您可以使用端點設定來設定您的 Timestream 目標資料庫，類似於使用額外的連線屬性。當您使用 AWS DMS 主控台或使用 中的 `create-endpoint`命令搭配 `--timestream-settings '{"EndpointSetting": "value", ...}'` JSON 語法來建立目標端點時[AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html)，您可以指定設定。
下列資料表顯示您可搭配 Timestream 做為目標使用的端點設定。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/dms/latest/userguide/CHAP_Target.Timestream.html)
## 建立和修改 Amazon Timestream 目標端點
建立 IAM 角色並建立最低限度的存取許可後，您可以使用 AWS DMS 主控台建立 Amazon Timestream 目標端點，或使用 中的 `create-endpoint`命令[AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html)搭配 `--timestream-settings '{"EndpointSetting": "value", ...}'` JSON 語法。
以下範例示範如何使用 AWS CLI建立和修改 Timestream 目標端點。
**建立 Timestream 目標端點命令**
```
aws dms create-endpoint —endpoint-identifier timestream-target-demo
--endpoint-type target —engine-name timestream
--service-access-role-arn arn:aws:iam::123456789012:role/my-role
--timestream-settings
{
"MemoryDuration": 20,
"DatabaseName":"db_name",
"MagneticDuration": 3,
"CdcInsertsAndUpdates": true,
"EnableMagneticStoreWrites": true,
}
```
**修改 Timestream 目標端點命令**
```
aws dms modify-endpoint —endpoint-identifier timestream-target-demo
--endpoint-type target —engine-name timestream
--service-access-role-arn arn:aws:iam::123456789012:role/my-role
--timestream-settings
{
"MemoryDuration": 20,
"MagneticDuration": 3,
}
```
## 使用物件映射將資料遷移到 Timestream 主題
AWS DMS 使用資料表映射規則，將資料從來源映射到目標 Timestream 主題。若要將資料映射到目標主題，請使用一種稱為物件映射的資料表映射規則。您可以使用物件映射定義如何將來源中的資料記錄映射到發佈到 Timestream 主題的資料記錄。
除了擁有分割區索引鍵外，Timestream 主題沒有預設結構。
**注意**
您不一定要使用物件映射。您可以針對各種轉換使用一般資料表映射。不過，分割區索引鍵類型會遵循下列預設行為：
主索引鍵會作為「完全載入」的分割區索引鍵。
如果未使用平行套用任務設定，則 `schema.table` 會做為 CDC 的分割區索引鍵。
如果使用平行套用任務設定，則主索引鍵會做為 CDC 的分割區索引鍵。
若要建立物件映射規則，請將 `rule-type` 指定為 `object-mapping`。此規則指定您想要使用的物件映射類型。規則的結構如下。
```
{
"rules": [
{
"rule-type": "object-mapping",
"rule-id": "id",
"rule-name": "name",
"rule-action": "valid object-mapping rule action",
"object-locator": {
"schema-name": "case-sensitive schema name",
"table-name": ""
}
}
]
}
```
```
{
"rules": [
{
"rule-type": "object-mapping",
"rule-id": "1",
"rule-name": "timestream-map",
"rule-action": "map-record-to-record",
"target-table-name": "tablename",
"object-locator": {
"schema-name": "",
"table-name": ""
},
"mapping-parameters": {
"timestream-dimensions": [
"column_name1",
"column_name2"
],
"timestream-timestamp-name": "time_column_name",
"timestream-multi-measure-name": "column_name1or2",
"timestream-hash-measure-name": true or false,
"timestream-memory-duration": x,
"timestream-magnetic-duration": y
}
}
]
}
```
AWS DMS 目前支援 `map-record-to-record`和 `map-record-to-document`做為 `rule-action` 參數的唯一有效值。`map-record-to-record` 和 `map-record-to-document`值會指定預設對`exclude-columns`屬性清單中未排除的記錄 AWS DMS 執行的動作。這些值反正不會影響屬性映射。
從關聯式資料庫遷移到 Timestream 主題時，請使用 `map-record-to-record`。此規則類型使用關聯式資料庫的 `taskResourceId.schemaName.tableName` 值做為 Timestream 主題的分割區索引鍵，並會為來源資料庫中的每一欄建立一個屬性。使用 時`map-record-to-record`，對於來源資料表中未列於`exclude-columns`屬性清單中的任何資料欄， 會在目標主題中 AWS DMS 建立對應的屬性。無論屬性映射中是否使用該來源資料行，都會建立此對應的屬性。
了解 `map-record-to-record` 的一種方法是查看它運作時的狀態。在本範例中，假設您開始使用之關聯式資料庫資料表資料列的結構和資料如下。
| FirstName | LastName | StoreId | HomeAddress | HomePhone | WorkAddress | WorkPhone | DateofBirth |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Randy | Marsh | 5 | 221B Baker Street | 1234567890 | 31 Spooner Street, Quahog | 9876543210 | 1988/02/29 |
若要將此資訊從名為 `Test` 的結構描述遷移至 Timestream 主題，您可以建立規則以將資料映射至目標主題。以下規則說明映射。
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"rule-action": "include",
"object-locator": {
"schema-name": "Test",
"table-name": "%"
}
},
{
"rule-type": "object-mapping",
"rule-id": "2",
"rule-name": "DefaultMapToTimestream",
"rule-action": "map-record-to-record",
"object-locator": {
"schema-name": "Test",
"table-name": "Customers"
}
}
]
}
```
指定 Timestream 主題和分割區索引鍵 (在本例中為 `taskResourceId.schemaName.tableName`)，下列說明使用我們在 Timestream 目標主題中的範例資料所產生的記錄格式：
```
{
"FirstName": "Randy",
"LastName": "Marsh",
"StoreId": "5",
"HomeAddress": "221B Baker Street",
"HomePhone": "1234567890",
"WorkAddress": "31 Spooner Street, Quahog",
"WorkPhone": "9876543210",
"DateOfBirth": "02/29/1988"
}
```
## 使用 Amazon Timestream 做為 目標的限制 AWS Database Migration Service
使用 Amazon Timestream 做為目標時，有下列限制：
+ **維度和時間戳記：**Timestream 會如同使用複合主鍵一樣使用來源資料中的維度和時間戳記，而且也不允許您更新插入這些值。這表示，如果您變更來源資料庫中記錄的時間戳記或維度，Timestream 資料庫會嘗試建立新記錄。因此，如果您變更記錄的維度或時間戳記，使其與其他現有記錄的維度或時間戳記相符，則 會 AWS DMS 更新其他記錄的值，而不是建立新的記錄或更新先前的對應記錄。
+ **DDL 命令：** 的目前版本 AWS DMS 僅支援 `CREATE TABLE`和 `DROP TABLE` DDL 命令。
+ **記錄限制：**Timestream 對記錄大小和度量大小等記錄有限制。如需詳細資訊，請參閱《[Amazon Timestream 開發人員指南](https://docs.aws.amazon.com/)》中的[配額](https://docs.aws.amazon.com/timestream/latest/developerguide/what-is-timestream.html)。
+ **刪除記錄和空值：**Timestream 不支援刪除記錄。為了支援遷移從來源刪除的記錄， 會 AWS DMS 清除 Timestream 目標資料庫中記錄中的對應欄位。將對應目標記錄欄位中的值 AWS DMS 變更為數字欄位為 **0**、文字欄位為 **null**，以及布林值欄位為 **false**。
+ 做為目標的 Timestream 不支援非關聯式資料庫 (RDBMS) 的來源。
+ AWS DMS 僅支援 Timestream 做為下列區域中的目標：
+ 美國東部 (維吉尼亞北部)
+ 美國東部 (俄亥俄)
+ 美國西部 (奧勒岡)
+ 歐洲 (愛爾蘭)
+ 歐洲 (法蘭克福)
+ 亞太地區 (雪梨)
+ 亞太地區 (東京)
+ 做為目標的 Timestream 不支援將 `TargetTablePrepMode` 設定為 `TRUNCATE_BEFORE_LOAD`。我們建議針對此設定使用 `DROP_AND_CREATE`。
# 使用 Amazon RDS for Db2 和 IBM Db2 LUW 作為 的目標 AWS DMS
您可以使用 AWS Database Migration Service () 將資料從 Db2 LUW 資料庫遷移至 Amazon RDS for Db2 或內部部署 Db2 資料庫AWS DMS。
如需 AWS DMS 支援做為目標之 Db2 LUW 版本的資訊，請參閱 [的目標 AWS DMS](CHAP_Introduction.Targets.md)。
您可以使用 Secure Sockets Layer (SSL) 加密您 Db2 LUW 端點與複寫執行個體之間的連線。如需有關 搭配 Db2 LUW 端點使用 SSL 的詳細資訊，請參閱 [搭配 使用 SSL AWS Database Migration Service](CHAP_Security.SSL.md)。
## 使用 Db2 LUW 做為 目標的限制 AWS DMS
使用 Db2 LUW 資料庫做為目標時，適用下列限制 AWS DMS。使用 Db2 LUW 做為來源時，請參閱 [使用 Db2 LUW 做為 來源的限制 AWS DMS](CHAP_Source.DB2.md#CHAP_Source.DB2.Limitations)。
+ AWS DMS 當來源為 z/OS 的 Db2 LUW 或 Db2 時， 僅支援 Db2 LUW 做為目標。
+ 若使用 Db2 LUW 做為目標，並不支援具有完整 LOB 模式的複寫。
+ 若使用 Db2 LUW 做為目標，並不會在完全載入階段支援 XML 資料類型。這是 IBM dbload 公用程式的限制。如需詳細資訊，請參閱 *IBM Informix 伺服器*文件中的 [dbload 公用程式](https://www.ibm.com/docs/en/informix-servers/14.10?topic=utilities-dbload-utility)。
+ AWS DMS 使用對應於雙引號字元 (") 的值截斷 BLOB 欄位。這是 IBM dbload 公用程式的限制。
+ AWS DMS 在 DMS 3.5.3 版中遷移至 Db2 LUW 目標時， 不支援平行完全載入選項。此選項可從 DMS 3.5.4 版或更新版本取得。
## 使用 Db2 LUW 做為 目標時的端點設定 AWS DMS
您可以使用端點設定來設定您的 Db2 LUW 目標資料庫，類似於使用額外的連線屬性。當您使用 AWS DMS 主控台或使用 中的 `create-endpoint`命令搭配 `--ibm-db2-settings '{"EndpointSetting": "value", ...}'` JSON 語法來建立目標端點時[AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html)，您可以指定設定。
下列資料表顯示可以搭配使用做為目標之 Db2 LUW 的端點設定。
| 名稱 | 描述 |
| --- | --- |
| `KeepCsvFiles` | 如果為 true， AWS DMS 會將任何 .csv 檔案儲存至用於複寫資料的 Db2 LUW 目標。DMS 使用這些檔案進行分析和疑難排解。 |
| `LoadTimeout` | DMS 在 Db2 目標上執行的 AWS DMS 逾時操作之前的時間量 （以毫秒為單位）。預設值為 1200 (20 分鐘)。 |
| `MaxFileSize` | 針對用來將資料傳輸到 Db2 LUW 的任何 .csv 檔案，指定其大小上限 (KB)。 |
| `WriteBufferSize` | 在 DMS 複寫執行個體的本機磁碟上產生 .csv 檔案時，所使用的記憶體內檔案寫入緩衝區的大小 (KB)。預設值為 1024 (1 MB)。 |