Menggunakan basis data Amazon DynamoDB sebagai target untuk AWS Database Migration Service

Anda dapat menggunakan AWS DMS untuk memigrasikan data ke tabel Amazon DynamoDB. Amazon DynamoDB adalah layanan basis data NoSQL yang terkelola penuh yang menyediakan performa cepat dan dapat diprediksi dengan skalabilitas mulus. AWS DMS mendukung penggunaan basis data relasional atau MongoDB sebagai sumber.

Dalam DynamoDB, tabel, item, dan atribut adalah komponen inti yang Anda kerjakan. Sebuah tabel adalah kumpulan item, dan setiap item adalah kumpulan atribut. DynamoDB menggunakan kunci primer, yang disebut kunci partisi, untuk mengidentifikasi secara unik setiap item dalam sebuah tabel. Anda juga dapat menggunakan kunci dan indeks sekunder untuk memberikan lebih banyak fleksibilitas kueri.

Anda menggunakan pemetaan objek untuk memigrasi data Anda dari basis data sumber ke tabel DynamoDB target. Pemetaan objek mengizinkann Anda menentukan letak sumber data di target.

Saat AWS DMS membuat tabel pada titik akhir target DynamoDB, tabel akan dibuat sebanyak di titik akhir basis data sumber. AWS DMS juga menetapkan beberapa nilai parameter DynamoDB. Biaya pembuatan tabel tergantung pada jumlah data dan jumlah tabel yang akan dimigrasi.

Untuk membantu meningkatkan kecepatan transfer, AWS DMS mendukung beban penuh multithread ke instans target DynamoDB. DMS mendukung multithreading ini dengan pengaturan tugas yang meliputi berikut ini:

Migrasi dari basis data relasional ke tabel DynamoDB

AWS DMS mendukung memigrasikan data ke tipe data skalar DynamoDB. Saat bermigrasi dari basis data relasional seperti Oracle atau MySQL ke DynamoDB, Anda mungkin ingin merestrukturisasi cara Anda menyimpan data ini.

Saat ini AWS DMS mendukung restrukturisasi antar tabel tunggal ke atribut tipe skalar DynamoDB. Jika Anda memigrasikan data ke DynamoDB dari tabel basis data relasional, Anda mengambil data dari tabel dan melakukan format ulang menjadi atribut tipe data skalar DynamoDB. Atribut ini dapat menerima data dari beberapa kolom, dan Anda dapat memetakan kolom ke atribut secara langsung.

AWS DMS mendukung tipe data skalar DynamoDB berikut:

Prasyarat untuk menggunakan DynamoDB sebagai target untuk AWS Database Migration Service

Sebelum Anda mulai bekerja dengan basis data DynamoDB sebagai target untuk AWS DMS, pastikan Anda membuat IAM role. Peran IAM ini harus memungkinkan AWS DMS untuk mengasumsikan dan memberikan akses ke tabel DynamoDB yang sedang dimigrasikan ke. Kumpulan izin akses minimum ditampilkan dalam kebijakan IAM berikut.

{
   "Version": "2012-10-17",
   "Statement": [
      {
         "Sid": "",
         "Effect": "Allow",
         "Principal": {
            "Service": "dms.amazonaws.com"
         },
         "Action": "sts:AssumeRole"
      }
   ]
} 

Peran yang Anda gunakan untuk migrasi ke DynamoDB harus memiliki izin berikut.

{
    "Version": "2012-10-17",
    "Statement": [
    {
        "Effect": "Allow",
        "Action": [
        "dynamodb:PutItem",
        "dynamodb:CreateTable",
        "dynamodb:DescribeTable",
        "dynamodb:DeleteTable",
        "dynamodb:DeleteItem",
        "dynamodb:UpdateItem"
    ],
    "Resource": [
    "arn:aws:dynamodb:us-west-2:account-id:table/name1",
    "arn:aws:dynamodb:us-west-2:account-id:table/OtherName*",
    "arn:aws:dynamodb:us-west-2:account-id:table/awsdms_apply_exceptions",
    "arn:aws:dynamodb:us-west-2:account-id:table/awsdms_full_load_exceptions"
    ]
    },
    {
        "Effect": "Allow",
        "Action": [
        "dynamodb:ListTables"
        ],
        "Resource": "*"
    }
    ]
}

Keterbatasan saat menggunakan DynamoDB sebagai target untuk AWS Database Migration Service

Batasan berikut berlaku saat menggunakan DynamoDB sebagai target:

Menggunakan pemetaan objek untuk migrasi data ke DynamoDB

AWS DMS menggunakan aturan pemetaan tabel untuk memetakan data dari sumber ke tabel target DynamoDB. Untuk memetakan data ke target DynamoDB, Anda menggunakan jenis aturan pemetaan tabel yang disebut Pemetaan objek. Pemetaan objek memungkinkan Anda menentukan nama atribut dan data yang akan dimigrasi ke mereka. Anda harus memiliki aturan seleksi ketika menggunakan pemetaan objek.

DynamoDB tidak memiliki struktur preset selain memiliki kunci partisi dan kunci pengurutan opsional. Jika Anda memiliki kunci primer nonkomposit, AWS DMS menggunakannya. Jika Anda memiliki kunci primer komposit atau Anda ingin menggunakan urutan kunci, definisikan kunci-kunci tersebut dan atribut lainnya dalam tabel target DynamoDB Anda.

Untuk membuat aturan pemetaan objek, Anda menentukan rule-type sebagai Pemetaan objek. Aturan ini menentukan jenis pemetaan objek yang ingin Anda gunakan.

Struktur aturannya adalah sebagai berikut:

{ "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": ""
      },
      "target-table-name": "<table_name>"
    }
  ]
}

AWS DMS saat ini mendukung map-record-to-record dan map-record-to-document sebagai satu-satunya nilai valid untuk parameter rule-action. Nilai-nilai ini menentukan apa yang AWS DMS lakukan secara default pada catatan yang tidak dikecualikan sebagai bagian dari daftar atribut exclude-columns. Nilai-nilai ini tidak mempengaruhi pemetaan atribut dengan cara apapun.

Salah satu cara untuk memahami perbedaan antara rule-action Parameter map-record-to-record dan map-record-to-document adalah untuk melihat dua parameter yang beraksi. Untuk contoh ini, anggap bahwa Anda memulai dengan baris tabel basis data relasional dengan struktur dan data berikut:

Untuk memigrasikan informasi ini ke DynamoDB, Anda membuat aturan untuk memetakan data ke item tabel DynamoDB. Perhatikan kolom yang tercantum untuk parameter exclude-columns. Kolom ini tidak langsung dipetakan ke target. Sebagai gantinya, pemetaan atribut digunakan untuk menggabungkan data menjadi item baru, seperti di mana FirstNamedan LastNamedikelompokkan bersama untuk menjadi CustomerNametarget DynamoDB. NickNamedan pendapatan tidak dikecualikan.

{
    "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",
                "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": "document",
                        "attribute-sub-type": "dynamodb-map",
                        "value": {
                            "M": {
                                "Home": {
                                    "M": {
                                        "Address": {
                                            "S": "${HomeAddress}"
                                        },
                                        "Phone": {
                                            "S": "${HomePhone}"
                                        }
                                    }
                                },
                                "Work": {
                                    "M": {
                                        "Address": {
                                            "S": "${WorkAddress}"
                                        },
                                        "Phone": {
                                            "S": "${WorkPhone}"
                                        }
                                    }
                                }
                            }
                        }
                    }
                ]
            }
        }
    ]
}
            

Dengan menggunakan rule-action parameter map-record-to-record, data untuk NickNamedan pendapatan dipetakan ke item dengan nama yang sama di target DynamoDB.

Namun, anggaplah Anda menggunakan aturan yang sama tetapi ubah rule-action parameternya menjadi map-record-to-document. Dalam hal ini, kolom yang tidak tercantum dalam exclude-columns parameter, NickNamedan pendapatan, dipetakan ke item _doc.

Menggunakan ekspresi kondisi kustom dengan pemetaan objek

Anda dapat menggunakan fitur DynamoDB yang disebut kondisi ekspresi untuk memanipulasi data yang sedang ditulis ke tabel DynamoDB. Untuk informasi lebih lanjut tentang kondisi ekspresi di DynamoDB, lihat Kondisi ekspresi.

Sebuah anggota kondisi ekspresi terdiri dari:

Struktur aturannya adalah sebagai berikut:

"target-table-name": "customer_t",
      "mapping-parameters": {
        "partition-key-name": "CustomerName",
        "condition-expression": {
          "expression":"<conditional expression>",
          "expression-attribute-values": [
              {
                "name":"<attribute name>",
                "value":<attribute value>
              }
          ],
          "apply-during-cdc":<optional Boolean value>,
          "apply-during-full-load": <optional Boolean value>
        }
                

Sampel berikut menyoroti bagian yang digunakan untuk kondisi ekspresi.

Menggunakan pemetaan atribut dengan pemetaan objek

Pemetaan atribut memungkinkan Anda menentukan string templat menggunakan nama kolom sumber untuk merestrikturisasi data pada target. Tidak ada pemformatan yang dilakukan selain yang ditentukan pengguna dalam templat.

Contoh berikut menunjukkan struktur basis data sumber dan struktur yang diinginkan dari target DynamoDB. Pertama ditunjukkan struktur sumbernya, dalam hal ini basis data Oracle, dan kemudian struktur data yang diinginkan di DynamoDB. Contoh diakhiri dengan JSON yang digunakan untuk membuat struktur target yang diinginkan.

Struktur data Oracle adalah sebagai berikut:

Struktur data DynamoDB adalah sebagai berikut:

Randy,Marsh

5

{
    "Name": "Randy",
    "Home": {
        "Address": "221B Baker Street",
        "Phone": 1234567890
    },
    "Work": {
        "Address": "31 Spooner Street, Quahog",
        "Phone": 9876541230
    }
}

02/29/1988

JSON berikut menunjukkan pemetaan objek dan pemetaan kolom yang digunakan untuk mencapai struktur 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}\"}}"
                    }
                ]
            }
        }
    ]
}
            

Cara lain menggunakan pemetaan kolom adalah dengan menggunakan format DynamoDB sebagai jenis dokumen Anda. Contoh kode berikut menggunakan peta dinamodb sebagai attribute-sub-type untuk pemetaan atribut.

{
    "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}"
                                        }
                                    }
                                }
                            }
                        }        
                    }
                ]
            }
        }
    ]
}
        

Sebagai alternatifdynamodb-map, Anda dapat menggunakan dynamodb-list sebagai attribute-sub-type for pemetaan atribut, seperti yang ditunjukkan pada contoh berikut.

{
"target-attribute-name": "ContactDetailsList",
"attribute-type": "document",
"attribute-sub-type": "dynamodb-list",
"value": {
    "L": [
            {
                "N": "${FirstName}"
            },
            {   
                "N": "${HomeAddress}"
            },
            {   
                "N": "${HomePhone}"
            },
            {
                "N": "${WorkAddress}"
            },
            {
                "N": "${WorkPhone}"
            }
        ]   
    }
}             
                

Contoh 1: Menggunakan pemetaan atribut dengan pemetaan objek

Contoh berikut memigrasikan data dari dua tabel database MySQL, nfl_data dan sport_team, ke dua tabel DynamoDB yang disebut NFLTeams dan. SportTeams Struktur tabel dan JSON yang digunakan untuk memetakan data dari tabel basis data MySQL ke tabel DynamoDB ditunjukkan sebagai berikut.

Struktur tabel basis data MySQL nfl_data ditunjukkan di bawah ini:

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    |       |
+---------------+-------------+------+-----+---------+-------+
            

Struktur tabel basis data MySQLsport_team ditunjukkan di bawah ini:

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    |                |
            

Aturan pemetaan tabel yang digunakan untuk memetakan dua tabel ke dua tabel DynamoDB adalah sebagai berikut:

{
  "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}\"}"
          }
        ]
      }
    }
  ]
}
            

Sampel keluaran untuk tabel DynamoDB NFlTeams ditunjukkan di bawah ini:

  "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"
}
            

Output sampel untuk tabel SportsTeams DynamoDB ditunjukkan di bawah ini:

{
  "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"
}
            

Target tipe data untuk DynamoDB

Titik akhir DynamoDB untuk AWS DMS mendukung sebagian besar tipe data DynamoDB. Tabel berikut menunjukkan tipe data target Amazon AWS DMS yang didukung saat menggunakan AWS DMS dan pemetaan default dari tipe data AWS DMS.

Untuk informasi tambahan tentang tipe data AWS DMS, lihat Tipe data untuk AWS Database Migration Service.

Saat AWS DMS memigrasi data dari basis data heterogen, kita memetakan tipe data dari basis data sumber ke tipe data perantara yang disebut tipe data AWS DMS. Kami kemudian memetakan tipe data perantara untuk tipe data target. Tabel berikut menunjukkan setiap tipe data AWS DMS dan tipe data yang dipetakannya di DynamoDB: