Selecione suas preferências de cookies

Usamos cookies essenciais e ferramentas semelhantes que são necessárias para fornecer nosso site e serviços. Usamos cookies de desempenho para coletar estatísticas anônimas, para que possamos entender como os clientes usam nosso site e fazer as devidas melhorias. Cookies essenciais não podem ser desativados, mas você pode clicar em “Personalizar” ou “Recusar” para recusar cookies de desempenho.

Se você concordar, a AWS e terceiros aprovados também usarão cookies para fornecer recursos úteis do site, lembrar suas preferências e exibir conteúdo relevante, incluindo publicidade relevante. Para aceitar ou recusar todos os cookies não essenciais, clique em “Aceitar” ou “Recusar”. Para fazer escolhas mais detalhadas, clique em “Personalizar”.

Utilizar um banco de dados Amazon DynamoDB como destino do AWS Database Migration Service

Modo de foco
Utilizar um banco de dados Amazon DynamoDB como destino do AWS Database Migration Service - AWS Database Migration Service

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Você pode usar AWS DMS para migrar dados para uma tabela do Amazon DynamoDB. O Amazon DynamoDB é um serviço SQL sem banco de dados totalmente gerenciado que fornece desempenho rápido e previsível com escalabilidade perfeita. AWS DMS suporta o uso de um banco de dados relacional ou MongoDB como fonte.

No DynamoDB, tabelas, itens e atributos são os componentes principais com que você trabalha. Uma tabela é uma coleção de itens, e cada item é uma coleção de atributos. O DynamoDB utiliza chaves primárias, chamadas chaves de partição, para identificar de modo exclusivo cada item em uma tabela. Também é possível utilizar chaves e índices secundários para fornecer mais flexibilidade de consulta.

O mapeamento de objeto é utilizado para migrar os dados de um banco de dados de origem para uma tabela de destino do DynamoDB. O mapeamento de objetos permite que você determine onde os dados de origem estão localizados no destino.

Ao AWS DMS criar tabelas em um endpoint de destino do DynamoDB, ele cria tantas tabelas quanto no endpoint do banco de dados de origem. AWS DMS também define vários valores de parâmetros do DynamoDB. O custo de criação da tabela depende da quantidade de dados e do número de tabelas a serem migradas.

nota

A opção SSLModo no AWS DMS console ou API não se aplica a alguns SQL serviços de streaming de dados e No, como Kinesis e DynamoDB. Eles são seguros por padrão, então AWS DMS mostra que a configuração do SSL modo é igual a nenhuma (SSLMode=None). Você não precisa fornecer nenhuma configuração adicional para seu endpoint usar. SSL Por exemplo, ao utilizar o DynamoDB como um endpoint de destino, ele é seguro por padrão. Todas as API chamadas para o DynamoDB são SSL usadas, portanto, não há necessidade de uma opção SSL adicional no endpoint. AWS DMS Você pode inserir e recuperar dados com segurança por meio de SSL endpoints usando o HTTPS protocolo, que é AWS DMS usado por padrão ao se conectar a um banco de dados do DynamoDB.

Para ajudar a aumentar a velocidade da transferência, AWS DMS oferece suporte a uma carga completa multiencadeada em uma instância de destino do DynamoDB. DMSsuporta esse multithreading com configurações de tarefas que incluem o seguinte:

  • MaxFullLoadSubTasks— Use essa opção para indicar o número máximo de tabelas de origem a serem carregadas paralelamente. DMScarrega cada tabela em sua tabela de destino correspondente do DynamoDB usando uma subtarefa dedicada. O valor padrão é 8. O valor máximo é 49.

  • ParallelLoadThreads— Use essa opção para especificar o número de threads AWS DMS usados para carregar cada tabela em sua tabela de destino do DynamoDB. O valor padrão é 0 (segmento único). O valor máximo é 200. Você pode solicitar o aumento desse limite máximo.

    nota

    DMSatribui cada segmento de uma tabela ao seu próprio encadeamento para carregamento. Portanto, defina ParallelLoadThreads como o número máximo de segmentos que você especifica para uma tabela na origem.

  • ParallelLoadBufferSize: utilize essa opção para especificar o número máximo de registros a serem armazenados em buffer utilizado pelos threads paralelos para carregar dados no destino do DynamoDB. O valor padrão é 50. Valor máximo de 1.000. Use essa configuração com ParallelLoadThreads; ParallelLoadBufferSize é válido somente quando há mais de um thread.

  • Configurações de mapeamento de tabela para tabelas individuais: utilize as regras table-settings para identificar tabelas individuais da origem que você deseja carregar em paralelo. Além disso, utilize essas regras para especificar como segmentar as linhas de cada tabela para carregamento multithread. Para obter mais informações, consulte Regras e operações de configurações de tabelas e coleções.

nota

Quando AWS DMS define os valores dos parâmetros do DynamoDB para uma tarefa de migração, o valor padrão do parâmetro Read Capacity Units RCU () é definido como 200.

O valor do parâmetro Write Capacity Units (WCU) também está definido, mas seu valor depende de várias outras configurações:

  • O valor padrão para o WCU parâmetro é 200.

  • Se a configuração da ParallelLoadThreads tarefa for maior que 1 (o padrão é 0), o WCU parâmetro será definido como 200 vezes o ParallelLoadThreads valor.

  • As taxas AWS DMS de uso padrão se aplicam aos recursos que você usa.

Migração de um banco de dados relacional para uma tabela do DynamoDB

AWS DMS suporta a migração de dados para tipos de dados escalares do DynamoDB. Ao migrar de um banco de dados relacional como Oracle ou My para o SQL DynamoDB, talvez você queira reestruturar a forma como você armazena esses dados.

Atualmente, AWS DMS oferece suporte à reestruturação de tabela única para tabela única para atributos do tipo escalar do DynamoDB. Se você estivesse migrando dados para o DynamoDB a partir de uma tabela de banco de dados relacional, pegaria dados de uma tabela e os reformataria como atributos de tipo de dados escalares. Esses atributos podem aceitar dados de várias colunas, e é possível mapear uma coluna diretamente para um atributo.

AWS DMS é compatível com os seguintes tipos de dados escalares do DynamoDB:

  • String

  • Número

  • Booleano

nota

NULLos dados da fonte são ignorados no destino.

Pré-requisitos para usar o DynamoDB como destino para AWS Database Migration Service

Antes de começar a trabalhar com um banco de dados do DynamoDB como destino, certifique-se AWS DMS de criar uma função. IAM Essa IAM função deve permitir AWS DMS assumir e conceder acesso às tabelas do DynamoDB para as quais estão sendo migradas. O conjunto mínimo de permissões de acesso é mostrado na IAM política a seguir.

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

O perfil utilizado para a migração para o DynamoDB deve ter as seguintes permissões:

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

Limitações ao usar o DynamoDB como destino para AWS Database Migration Service

Aplicam-se as seguintes limitações ao utilizar o DynamoDB como destino:

  • O DynamoDB limita a precisão do tipo de dados Número a 38 locais. Armazene todos os tipos de dados com mais precisão como uma string. É necessário especificar isso explicitamente utilizando o recurso de mapeamento de objetos.

  • Como o DynamoDB não tem um tipo de dados Date, os dados que utilizam esse tipo Date são convertidos em strings.

  • O DynamoDB não permite atualizações nos atributos da chave primária. Essa restrição é importante ao usar a replicação contínua com change data capture (CDC) porque pode resultar em dados indesejados no destino. Dependendo de como você tem o mapeamento de objetos, uma CDC operação que atualiza a chave primária pode fazer uma das duas coisas. Pode falhar ou inserir um novo item com a chave primária atualizada e dados incompletos.

  • AWS DMS suporta somente a replicação de tabelas com chaves primárias não compostas. A exceção é se você especificar um mapeamento de objetos para a tabela de destino com uma chave de partição personalizada ou chave de classificação, ou ambas.

  • AWS DMS não suporta LOB dados, a menos que seja umCLOB. AWS DMS converte CLOB dados em uma string do DynamoDB ao migrar os dados.

  • Ao utilizar o DynamoDB como destino, somente a tabela de controle Aplicar exceções (dmslogs.awsdms_apply_exceptions) será compatível. Para obter mais informações sobre tabelas de controle, consulte Configurações de tarefa de tabela de controle.

  • AWS DMS não suporta a configuração TargetTablePrepMode=TRUNCATE_BEFORE_LOAD de tarefas do DynamoDB como destino.

  • AWS DMS não suporta a configuração TaskRecoveryTableEnabled de tarefas do DynamoDB como destino.

  • BatchApplynão é compatível com um endpoint do DynamoDB.

Utilizar o mapeamento de objetos para migrar dados para o DynamoDB

AWS DMS usa regras de mapeamento de tabelas para mapear dados da tabela de origem para a tabela do DynamoDB de destino. Para mapear dados para um destino do DynamoDB, utilize um tipo de regra de mapeamento de tabela chamada object-mapping. O mapeamento de objetos permite definir os nomes de atributos e os dados a serem migrados para eles. Você deve ter regras de seleção ao utilizar o mapeamento de objetos.

O DynamoDB não tem uma estrutura predefinida além de ter uma chave de partição e uma chave de classificação opcional. Se você tiver uma chave primária não composta, use-a AWS DMS . Se você tiver uma chave primária composta ou quiser utilizar uma chave de classificação, defina as chaves e os outros atributos na tabela de destino do DynamoDB.

Para criar uma regra de mapeamento de objetos, especifique rule-type como object-mapping. Essa regra especifica o tipo de mapeamento de objeto que você deseja usar.

A estrutura da regra é a seguinte:

{ "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 atualmente suporta map-record-to-record e map-record-to-document como os únicos valores válidos para o rule-action parâmetro. Esses valores especificam o que AWS DMS acontece por padrão com registros que não são excluídos como parte da lista de exclude-columns atributos. Esses valores não afetam os mapeamentos de atributos de forma alguma.

  • É possível utilizar map-record-to-record ao migrar de um banco de dados relacional para o DynamoDB. Ele utiliza a chave primária do banco de dados relacional como a chave de partição no DynamoDB e cria um atributo para cada coluna no banco de dados de origem. Ao usarmap-record-to-record, para qualquer coluna na tabela de origem não listada na lista de atributos, AWS DMS cria um exclude-columns atributo correspondente na instância do DynamoDB de destino. Isso é feito, independentemente de a coluna de origem ser utilizada ou não em um mapeamento de atributos.

  • Você utiliza map-record-to-document para colocar colunas de origem em um único mapa sem formatação do DynamoDB no destino, utilizando o nome de atributo "_doc". Ao usarmap-record-to-document, AWS DMS coloca os dados em um único atributo de mapa plano do DynamoDB na fonte. Esse atributo é chamado "_doc". Esse posicionamento se aplica a qualquer coluna na tabela de origem que não aparece na lista de atributos exclude-columns.

Uma maneira de compreender a diferença entre os parâmetros de rule-action, map-record-to-record e map-record-to-document, é ver os dois parâmetros em ação. Para este exemplo, suponha que você está começando com uma linha de tabela de banco de dados relacional com a seguinte estrutura e dados:

exemplo de banco de dados

Para migrar essas informações para o DynamoDB, você criaria regras para mapear os dados para um item de tabela do DynamoDB. Observe as colunas listadas para o parâmetro exclude-columns. Essas colunas não são mapeadas diretamente para o destino. Em vez disso, o mapeamento de atributos é usado para combinar os dados em novos itens, como onde FirstNamee LastNamesão agrupados para se tornarem CustomerNameno destino do DynamoDB. NickNamee a renda não está excluída.

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

Ao usar o rule-action parâmetro map-record-to-record, os dados NickNamee a receita são mapeados para itens com o mesmo nome no destino do DynamoDB.

Comece com AWS DMS

No entanto, suponha que você use as mesmas regras, mas altere o rule-action parâmetro para map-record-to-document. Nesse caso, as colunas não listadas no exclude-columns parâmetro NickNamee renda são mapeadas para um item _doc.

Comece com AWS DMS

Utilizar expressões de condição personalizadas com o mapeamento de objetos

É possível utilizar um recurso do DynamoDB chamado de expressões condicionais para manipular dados que estão sendo gravados em uma tabela do DynamoDB. Para obter mais informações sobre expressões condicionais no DynamoDB, consulte Expressões de condição.

Um membro de expressão condicional consiste em:

  • uma expressão (obrigatória)

  • valores de atributo de expressão (opcional). Especifica uma estrutura json do DynamoDB do valor de atributo

  • nomes de atributo de expressão (opcional)

  • opções para quando utilizar a expressão condicional (opcional). O padrão é apply-during-cdc = false e apply-during-full-load = true

A estrutura da regra é a seguinte:

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

O exemplo a seguir destaca as seções utilizadas para expressão condicional.

Comece com AWS DMS

Usar o mapeamento de atributo com mapeamento de objeto

O mapeamento de atributo permite especificar uma string de modelo utilizando nomes de colunas de origem para reestruturar dados no destino. Não há formatação feita além do que o usuário especifica no modelo.

O exemplo a seguir mostra a estrutura do banco de dados de origem e a estrutura desejada do destino do DynamoDB. Primeiramente, é mostrada a estrutura da origem: nesse caso um banco de dados Oracle, e, depois, a estrutura desejada dos dados no DynamoDB. O exemplo termina com o JSON usado para criar a estrutura de destino desejada.

A estrutura dos dados do Oracle é a seguinte:

FirstName LastName StoreId HomeAddress HomePhone WorkAddress WorkPhone DateOfBirth
Chave primária N/D
Randy Marsh 5 221B Baker Street 1234567890 31 Spooner Street, Quahog 9876543210 29/02/1988

A estrutura dos dados do DynamoDB é a seguinte:

CustomerName StoreId ContactDetails DateOfBirth
Chave de partição Chave de classificação N/D
Randy,Marsh
5
{ "Name": "Randy", "Home": { "Address": "221B Baker Street", "Phone": 1234567890 }, "Work": { "Address": "31 Spooner Street, Quahog", "Phone": 9876541230 } }
02/29/1988

Veja a seguir o JSON mapeamento de objetos e o mapeamento de colunas usados para alcançar a estrutura do 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}\"}}" } ] } } ] }

Outra maneira de utilizar o mapeamento de colunas é utilizar o formato do DynamoDB como o tipo de documento. O código a seguir utiliza dynamodb-map como attribute-sub-type para o mapeamento de atributo.

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

Como alternativadynamodb-map, você pode usar dynamodb-list como mapeamento attribute-sub-type de atributos, conforme mostrado no exemplo a seguir.

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

Exemplo 1: Usar o mapeamento de atributo com mapeamento de objeto

O exemplo a seguir migra dados de duas tabelas do My SQL database, nfl_data e sport_team, para duas tabelas do DynamoDB chamadas e. NFLTeamsSportTeams A estrutura das tabelas e o JSON uso para mapear os dados das tabelas do Meu SQL banco de dados para as tabelas do DynamoDB são mostradas a seguir.

A estrutura da tabela Meu SQL banco de dados nfl_data é mostrada abaixo:

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

A estrutura da tabela Meu SQL banco de dados sport_team é mostrada abaixo:

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

As regras de mapeamento de tabela utilizadas para mapear as duas tabelas para as duas tabelas do DynamoDB são mostradas abaixo:

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

O exemplo de saída da tabela do NFLTeamsDynamoDB é mostrado abaixo:

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

O exemplo de saída da tabela do SportsTeams DynamoDB é mostrado abaixo:

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

Tipos de dados de destino do DynamoDB

O endpoint do DynamoDB for é AWS DMS compatível com a maioria dos tipos de dados do DynamoDB. A tabela a seguir mostra os tipos de dados de AWS DMS destino da Amazon que são suportados durante o uso AWS DMS e o mapeamento padrão dos tipos de AWS DMS dados.

Para obter informações adicionais sobre AWS DMS os tipos de dados, consulteTipos de dados do AWS Database Migration Service.

Ao AWS DMS migrar dados de bancos de dados heterogêneos, mapeamos tipos de dados do banco de dados de origem para tipos de dados intermediários chamados AWS DMS tipos de dados. Em seguida, mapeamos os tipos de dados intermediários para os tipos de dados de destino. A tabela a seguir mostra cada tipo de AWS DMS dados e o tipo de dados para o qual ele é mapeado no DynamoDB:

AWS DMS tipo de dados Tipo de dados do DynamoDB

String

String

WString

String

Booleano

Booleano

Data

String

DateTime

String

INT1

Número

INT2

Número

INT4

Número

INT8

Número

Numérico

Número

Real4

Número

Real8

Número

UINT1

Número

UINT2

Número

UINT4

Número

UINT8 Número
CLOB String
PrivacidadeTermos do sitePreferências de cookies
© 2025, Amazon Web Services, Inc. ou suas afiliadas. Todos os direitos reservados.