Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
Uso de una base de datos de Amazon DynamoDB como destino paraAWS Database Migration Service
Puedes usarAWS DMSpara migrar datos a una tabla de Amazon DynamoDB. Amazon DynamoDB es un servicio de base de datos NoSQL totalmente administrado que proporciona un rendimiento rápido y predecible con una escalabilidad perfecta.AWS DMSadmite el uso de una base de datos relacional o MongoDB como fuente.
En DynamoDB se trabaja principalmente con tablas, elementos y atributos. UNmesaes una colección de objetos, y cadaítemes una colección de atributos. DynamoDB utiliza claves primarias, denominadas claves de partición, para identificar cada elemento de una tabla de forma unívoca. También puede utilizar claves e índices secundarios para proporcionar más flexibilidad a la hora de realizar consultas.
Puede utilizar el mapeo de objetos para migrar sus datos desde una base de datos de origen a una tabla de DynamoDB de destino. El mapeo de objetos le permite determinar dónde se encuentran los datos de origen en el destino.
¿Cuándo?AWS DMScrea tablas en un extremo de destino de DynamoDB, crea tantas tablas como en el extremo de la base de datos de origen.AWS DMStambién establece varios valores de parámetros de DynamoDB. El costo de la creación de la tabla depende de la cantidad de datos y del número de tablas que hay que migrar.
nota
ElModo SSLopción en elAWS DMSla consola o la API no se aplican a algunos servicios de transmisión de datos y NoSQL, como Kinesis y DynamoDB. Son seguros por defecto, por lo queAWS DMSmuestra que la configuración del modo SSL es igual a ninguna (Modo SSL = Ninguno). No necesita proporcionar ninguna configuración adicional para que su terminal utilice SSL. Por ejemplo, cuando se usa DynamoDB como punto final de destino, es seguro de forma predeterminada. Todas las llamadas a la API a DynamoDB utilizan SSL, por lo que no es necesaria una opción SSL adicional enAWS DMSpunto final. Puede colocar y recuperar datos de forma segura a través de puntos finales SSL mediante el protocolo HTTPS, queAWS DMSse usa de forma predeterminada cuando se conecta a una base de datos de DynamoDB.
Para ayudar a aumentar la velocidad de la transferencia,AWS DMSadmite una carga completa de subprocesos múltiples en una instancia de destino de DynamoDB. DMS admite este multriproceso con configuración de tareas que incluyen lo siguiente:
-
MaxFullLoadSubTasks— Utilice esta opción para indicar el número máximo de tablas de origen que se van a cargar en paralelo. DMS carga cada tabla en su tabla de destino de DynamoDB correspondiente mediante una subtarea dedicada. El valor predeterminado es 8. El valor máximo es 49. -
ParallelLoadThreads— Utilice esta opción para especificar el número de subprocesos queAWS DMSse usa para cargar cada tabla en su tabla de destino de DynamoDB. El valor predeterminado es 0 (subproceso único). El valor máximo es 200. Puede pedir que se incremente este límite máximo.nota
El DMS asigna cada segmento de una tabla a su propio subproceso para la carga. Por lo tanto, establezca
ParallelLoadThreadsen el número máximo de segmentos que especifique para una tabla en el origen. -
ParallelLoadBufferSize— Utilice esta opción para especificar el número máximo de registros que se deben almacenar en el búfer que los subprocesos de carga en paralelo utilizan para cargar datos en el destino de DynamoDB. El valor predeterminado es 50. El valor máximo es 1000. Utilice este parámetro conParallelLoadThreads.ParallelLoadBufferSizees válido solo cuando hay más de un subproceso. -
Configuración de mapeo de tablas para tablas individuales — Uso
table-settingsreglas para identificar tablas individuales de la fuente que desea cargar en paralelo. Use también estas reglas para especificar cómo segmentar la filas de cada tabla para cargas de multiprocesos. Para obtener más información, consulte Configuración, reglas y operaciones de tablas y colecciones.
nota
¿Cuándo?AWS DMSestablece los valores de los parámetros de DynamoDB para una tarea de migración; el valor predeterminado del parámetro Unidades de capacidad de lectura (RCU) está establecido en 200.
También se establece el valor del parámetro de las unidades de capacidad de escritura (WCU), pero su valor depende de otras configuraciones diferentes:
-
El valor predeterminado para el parámetro WCU es 200.
-
Si la configuración de la tarea
ParallelLoadThreadsse establece en un valor superior a 1 (el valor predeterminado es 0), entonces el parámetro WCU se establece en un valor 200 veces el valor deParallelLoadThreads. EstándarAWS DMSlas tarifas de uso se aplican a los recursos que utilice.
Migración de una base de datos relacional a una tabla de DynamoDB
AWS DMSadmite la migración de datos a tipos de datos escalares de DynamoDB. Al migrar desde una base de datos relacional como Oracle o MySQL a DynamoDB, puede reestructurar la manera de almacenar dichos datos.
En la actualidad, AWS DMS admite la reestructuración de una tabla en otra tabla con los atributos del tipo escalar de DynamoDB. Si migra datos a DynamoDB desde una tabla de base de datos relacional, toma los datos de una tabla y cambia su formato por atributos de tipo de datos escalares de DynamoDB. Estos atributos pueden aceptar datos de varias columnas y puede mapear una columna en un atributo directamente.
AWS DMS admite los siguientes tipos de datos escalares de DynamoDB:
-
Cadena
-
Número
-
Booleano
nota
Los datos NULL del origen se ignoran en el destino.
Requisitos previos para utilizar DynamoDB como destino paraAWS Database Migration Service
Antes de empezar a trabajar con una base de datos de DynamoDB como destino paraAWS DMS, asegúrese de crear un rol de IAM. Esta función de IAM debería permitirAWS DMSpara asumir y conceder acceso a las tablas de DynamoDB a las que se está migrando. El conjunto mínimo de permisos de acceso se muestra en la siguiente política de IAM.
{ "Version": "2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": "dms.amazonaws.com" }, "Action": "sts:AssumeRole" } ] }
El rol que utilice para la migración a DynamoDB debe tener los siguientes permisos.
{ "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": "*" } ] }
Limitaciones al utilizar DynamoDB como destino paraAWS Database Migration Service
Se aplican las siguientes limitaciones al utilizar DynamoDB como destino:
-
DynamoDB limita la precisión del tipo de datos Number a 38 espacios. Almacene todos los tipos de datos con una mayor precisión como cadena. Deberá indicarlo explícitamente empleando la característica de mapeo de objetos.
-
Como DynamoDB no tiene un tipo de datos de fecha, los datos que utilizan el tipo de datos de fecha se convierten en cadenas.
-
DynamoDB no permite actualizar los atributos de la clave principal. Esta restricción es importante cuando se utiliza la replicación continua con captura de datos de cambio (CDC), ya que puede resultar en la presencia de datos no deseados en el destino. En función del mapeo de objetos, una operación de CDC que actualiza la clave principal puede hacer una de estas dos opciones. Puede producir un error o insertar un nuevo elemento con la clave principal actualizada y datos incompletos.
-
AWS DMS solo admite la replicación de tablas con claves principales no compuestas. La excepción es si especifica un mapeo de objetos para la tabla de destino con una clave de partición personalizada, una clave de ordenación o ambas.
-
AWS DMSno admite datos de LOB a menos que sea un CLOB.AWS DMSconvierte los datos CLOB en una cadena de DynamoDB al migrar los datos.
-
Cuando se utiliza DynamoDB como destino, solo se admite la tabla de control Apply Exceptions (Aplicar excepciones) (
dmslogs.awsdms_apply_exceptions). Para obtener más información sobre las tablas de control, consulte Configuración de las tareas de la tabla de control. AWS DMSno admite la configuración de tareas
TargetTablePrepMode=TRUNCATE_BEFORE_LOADpara DynamoDB como objetivo.AWS DMSno admite la configuración de tareas
TaskRecoveryTableEnabledpara DynamoDB como objetivo.
Uso del mapeo de objetos para migrar datos a DynamoDB
AWS DMS usa las reglas de mapeo de tablas para asignar datos del origen a la tabla de DynamoDB de destino. Para asignar datos a un destino de DynamoDB, se utiliza un tipo de regla de mapeo de tabla denominado object-mapping. El mapeo de objetos le permite definir los nombres de atributo y los datos que se les puede migrar. Debe tener reglas de selección cuando utilice el mapeo de objetos.
DynamoDB no tiene una estructura preestablecida, aparte de tener una clave de partición y una clave de clasificación opcional. Si dispone de una clave principal no compuesta, AWS DMS la utiliza. Si tiene una clave principal compuesta o desea utilizar una clave de ordenación, defina estas claves y el resto de los atributos de su tabla de DynamoDB de destino.
Para crear una regla de mapeo de objetos, debe especificar rule-type como object-mapping. Esta regla indica el tipo de mapeo de objetos que desea utilizar.
La estructura de la regla es la siguiente:
{ "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 actualmente admite map-record-to-record y map-record-to-document como únicos valores válidos para el parámetro rule-action. Estos valores especifican qué hace AWS DMS de forma predeterminada con los registros que no se excluyen como parte de la lista de atributos exclude-columns. Estos valores no afectan a los mapeos de atributos en modo alguno.
-
Puedes usar
map-record-to-recordal migrar de una base de datos relacional a DynamoDB. Utiliza la clave principal de la base de datos relacional como clave de partición en DynamoDB y crea un atributo para cada columna de la base de datos de origen. Cuando se usamap-record-to-record, para cualquier columna de la tabla de origen que no figure en laexclude-columnslista de atributos,AWS DMScrea el atributo correspondiente en la instancia de DynamoDB de destino. Lo hace independientemente de si dicha columna de origen se utiliza en un mapeo de atributos. -
Usas
map-record-to-documentpara colocar las columnas de origen en un único mapa plano de DynamoDB en el destino mediante el nombre de atributo «_doc». Cuando se usamap-record-to-document,AWS DMScoloca los datos en un atributo de mapa de DynamoDB único y plano en la fuente. Este atributo se denomina "_doc". Esta colocación se aplica a cada columna de la tabla de origen que no se enumera en la lista de atributosexclude-columns.
Una forma de entender la diferencia entre los parámetros de rule-action map-record-to-record y map-record-to-document consiste en ver los dos parámetros en acción. En este ejemplo, imagine que empieza con una fila de una tabla de base de datos relacional con la estructura y los datos siguientes:
Para migrar esta información a DynamoDB, crea reglas para mapear los datos en un elemento de la tabla de DynamoDB. Tenga en cuenta las columnas listadas para el parámetro exclude-columns. Estas columnas no se mapean directamente en el destino. En cambio, el mapeo de atributos se utiliza para combinar los datos en nuevos elementos, como dóndeFirstNameyLastNamese agrupan para convertirse enCustomerNameen el destino de DynamoDB. NickNameyingresosno están excluidos.
{ "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}" } } } } } } ] } } ] }
Mediante el uso derule-actionparámetromap-record-to-record, los datos deNickNameyingresosse asignan a elementos del mismo nombre en el destino de DynamoDB.
Sin embargo, supongamos que usa las mismas reglas pero cambia larule-actionparámetro paramap-record-to-document. En este caso, las columnas que no figuran en laexclude-columnsparámetro,NickNameyingresos, están mapeados a_docartículo.
Uso de expresiones de condición personalizadas con mapeo de objetos
Puede utilizar una función de DynamoDB denominada expresiones condicionales para manipular los datos que se escriben en una tabla de DynamoDB. Para obtener más información sobre las expresiones de condiciones en DynamoDB, consulteExpresiones de condición.
Un miembro de una expresión de condición consta de:
-
una expresión (obligatorio)
-
los valores de los atributos de expresión (opcional). Especifica una estructura json de DynamoDB del valor del atributo
-
los nombres de los atributos de expresión (opcional)
-
las opciones sobre cuándo utilizar la expresión de condición (opcional). El valor predeterminado esapply-during-cdc= falso yapply-during-full-load= verdadero
La estructura de la regla es la siguiente:
"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> }
En el siguiente ejemplo se destacan las secciones que se utilizan para la expresión de condición.
Uso del mapeo de atributos con el mapeo de objetos
El mapeo de atributos le permite especificar una cadena de ejemplo utilizando nombres de columna del origen para reestructurar los datos en el destino. El formato se modifica en función de lo que especifique el usuario en la plantilla.
El siguiente ejemplo muestra la estructura de la base de datos de origen y la estructura deseada de destino en DynamoDB. En primer lugar se muestra la estructura de origen, en este caso, una base de datos de Oracle y, a continuación, la estructura deseada de los datos en DynamoDB. El ejemplo concluye con la estructura JSON utilizada para crear la estructura de destino deseada.
La estructura de los datos de Oracle es la siguiente:
| FirstName | LastName | StoreId | HomeAddress | HomePhone | WorkAddress | WorkPhone | DateOfBirth |
|---|---|---|---|---|---|---|---|
| Clave principal | N/A | ||||||
| Randy | Marsh | 5 | 221B Baker Street | 1234567890 | 31 Spooner Street, Quahog | 9876543210 | 02/29/1988 |
La estructura de los datos de DynamoDB es la siguiente:
| CustomerName | StoreId | ContactDetails | DateOfBirth |
|---|---|---|---|
| Clave de partición | Clave de ordenación | N/A | |
|
|
|
|
La siguiente estructura JSON muestra el mapeo de objetos y de columnas que se utiliza para conseguir la estructura de 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}\"}}" } ] } } ] }
Otro modo de utilizar el mapeo de columnas es utilizar el formato DynamoDB como su tipo de documento. El siguiente ejemplo de código utiliza dynamodb-map como el attribute-sub-type para el mapeo de atributos.
{ "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 alternativa adynamodb-map, puedes usardynamodb-listcomo elattribute-sub-typepara el mapeo de atributos, como se muestra en el siguiente ejemplo.
{ "target-attribute-name": "ContactDetailsList", "attribute-type": "document", "attribute-sub-type": "dynamodb-list", "value": { "L": [ { "N": "${FirstName}" }, { "N": "${HomeAddress}" }, { "N": "${HomePhone}" }, { "N": "${WorkAddress}" }, { "N": "${WorkPhone}" } ] } }
Ejemplo 1: Uso del mapeo de atributos con el mapeo de objetos
El siguiente ejemplo migra datos de dos tablas de bases de datos MySQL,datos_NFLyequipo_deportivo, a dos tablas de DynamoDB denominadasEquipos de la NFLySportTeams. A continuación se muestra la estructura de las tablas y la estructura JSON que se utilizan para mapear los datos de las tablas de la base de datos MySQL en las tablas de DynamoDB.
A continuación se muestra la estructura de la tabla de base de datos MySQL nfl_data:
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 continuación se muestra la estructura de la tabla de la base de datos MySQL sport_team:
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 | |
A continuación, se muestran las reglas de mapeo de tablas que se utilizan para asignar las dos tablas a las dos tablas de 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}\"}" } ] } } ] }
A continuación se muestra el resultado de ejemplo de la tabla NFLTeams de 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" }
El resultado de ejemplo paraSportsTeams DynamoDBla tabla se muestra a continuación:
{ "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 datos de destino para DynamoDB
El punto final de DynamoDB paraAWS DMSadmite la mayoría de los tipos de datos de DynamoDB. En la tabla siguiente se muestran los tipos de datos de destino de AWS DMS que se admiten cuando se utiliza AWS DMS y el mapeo predeterminado de los tipos de datos de AWS DMS.
Para obtener más información sobre los tipos de datos de AWS DMS, consulte Tipos de datos para elAWS Database Migration Service.
Cuando AWS DMS migra datos desde bases de datos heterogéneas, se mapean tipos de datos desde la base de datos de origen a tipos de datos intermedios llamados tipos de datos de AWS DMS. A continuación, se mapean los tipos de datos intermedios en los tipos de datos de destino. La tabla siguiente muestra cada tipo de datos de AWS DMS y el tipo de datos con el que se mapea en DynamoDB:
| Tipos de datos de AWS DMS | Tipo de dato de DynamoDB |
|---|---|
|
Cadena |
Cadena |
|
WString |
Cadena |
|
Booleano |
Booleano |
|
Fecha |
Cadena |
|
DateTime |
Cadena |
|
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 | Cadena |
