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 SQL Tanpa terkelola sepenuhnya yang memberikan kinerja yang cepat dan dapat diprediksi dengan skalabilitas yang mulus. AWS DMS mendukung menggunakan database 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, itu menciptakan tabel sebanyak di titik akhir database 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 multithreaded ke instance target DynamoDB. DMSmendukung multithreading ini dengan pengaturan tugas yang mencakup yang berikut:

Migrasi dari basis data relasional ke tabel DynamoDB

AWS DMS mendukung migrasi data ke tipe data skalar DynamoDB. Saat bermigrasi dari database relasional seperti Oracle atau My ke SQL DynamoDB, Anda mungkin ingin merestrukturisasi cara menyimpan data ini.

Saat ini AWS DMS mendukung tabel tunggal untuk restrukturisasi 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 AWS Database Migration Service

Sebelum Anda mulai bekerja dengan database DynamoDB sebagai target AWS DMS, pastikan Anda membuat peran. IAM IAMPeran ini harus memungkinkan AWS DMS untuk mengasumsikan dan memberikan akses ke tabel DynamoDB yang sedang dimigrasikan ke. Set minimum izin akses ditampilkan dalam IAM kebijakan 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 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 DynamoDB target. 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 gunakanlah. 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 yang valid untuk rule-action parameter. Nilai-nilai ini menentukan AWS DMS apa yang dilakukan secara default ke catatan yang tidak dikecualikan sebagai bagian dari daftar exclude-columns atribut. 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 yang JSON 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

Berikut ini JSON 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 alternatif untukdynamodb-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 SQL database Saya, nfl_data dan sport_team, ke dua tabel DynamoDB disebut dan. NFLTeamsSportTeams Struktur tabel dan JSON digunakan untuk memetakan data dari tabel SQL database Saya ke tabel DynamoDB ditampilkan sebagai berikut.

Struktur tabel SQL database saya 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 SQL database saya sport_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}\"}"
          }
        ]
      }
    }
  ]
}
            

Output sampel untuk tabel NFLTeamsDynamoDB 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 AWS DMS target Amazon yang didukung saat menggunakan AWS DMS dan pemetaan default dari tipe AWS DMS data.

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

Saat AWS DMS memigrasikan data dari database heterogen, kami memetakan tipe data dari database sumber ke tipe data perantara yang disebut AWS DMS tipe data. Kami kemudian memetakan tipe data perantara untuk tipe data target. Tabel berikut menunjukkan setiap tipe AWS DMS data dan tipe data yang dipetakan di DynamoDB: