Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Utilisation d'Amazon Kinesis Data Streams comme cible pour AWS Database Migration Service

Vous pouvez l'utiliser AWS DMS pour migrer des données vers un flux de données Amazon Kinesis. Les flux de données Amazon Kinesis font partie du service Amazon Kinesis Data Streams. Vous pouvez utiliser des flux de données Kinesis pour collecter et traiter des flux volumineux d’enregistrements de données en temps réel.

Un flux de données Kinesis se compose de partitions. Les partitions sont des séquences d'enregistrements de données identifiées de manière unique dans un flux. Pour plus d’informations sur les partitions dans Amazon Kinesis Data Streams, consultez Partition dans le Guide du développeur Amazon Kinesis Data Streams.

AWS Database Migration Service publie des enregistrements dans un flux de données Kinesis à l'aide de JSON. Au cours de la conversion, AWS DMS sérialise chaque enregistrement de la base de données source dans une paire attribut-valeur au format JSON ou un format de message JSON_UNFORMATED. Un format de message JSON_UNFORMATED est une chaîne JSON à une seule ligne avec un délimiteur de nouvelle ligne. Il permet à Amazon Data Firehose de fournir des données Kinesis à une destination Amazon S3, puis de les interroger à l'aide de différents moteurs de requête, dont Amazon Athena.

Utilisez le mappage d'objet pour migrer vos données de n'importe quelle source de données prise en charge vers un flux cible. Avec le mappage d'objet, vous déterminez la façon de structurer les enregistrements de données dans le flux. Vous définissez également une clé de partition pour chaque table, que Kinesis Data Streams utilise pour regrouper les données dans ses partitions.

Lors de la AWS DMS création de tables sur un point de terminaison cible Kinesis Data Streams, il crée autant de tables que dans le point de terminaison de la base de données source. AWS DMS définit également plusieurs valeurs de paramètres Kinesis Data Streams. Le coût de création de la table dépend de la quantité de données et du nombre de tables à migrer.

L’exemple suivant illustre l’option kinesis-settings utilisée avec un exemple de commande create-endpoint émise à l’aide d’ AWS CLI.

aws dms create-endpoint --endpoint-identifier=$target_name --engine-name kinesis --endpoint-type target
--region us-east-1 --kinesis-settings ServiceAccessRoleArn=arn:aws:iam::333333333333:role/dms-kinesis-role,
StreamArn=arn:aws:kinesis:us-east-1:333333333333:stream/dms-kinesis-target-doc,MessageFormat=json-unformatted,
IncludeControlDetails=true,IncludeTransactionDetails=true,IncludePartitionValue=true,PartitionIncludeSchemaTable=true,
IncludeTableAlterOperations=true

Lorsque vous utilisez les paramètres de tâche ParallelApply*, la valeur par défaut partition-key-type est la valeur primary-key de la table, pas schema-name.table-name.

Utilisation d’une image antérieure pour afficher les valeurs d’origine des lignes CDC pour un flux de données Kinesis en tant que cible

Lorsque vous écrivez des mises à jour de CDC sur une cible de diffusion de données comme Kinesis, vous pouvez afficher les valeurs d’origine d’une ligne de base de données source avant de les modifier par une mise à jour. Pour ce faire, AWS DMS remplit une image antérieure des événements de mise à jour en fonction des données fournies par le moteur de base de données source.

Différents moteurs de base de données source fournissent différentes quantités d'informations pour une image antérieure :

Pour activer avant l'imagerie pour ajouter des valeurs d'origine de la base de données source à la sortie AWS DMS , utilisez le paramètre de tâche BeforeImageSettings ou le paramètre add-before-image-columns. Ce paramètre applique une règle de transformation de colonne.

BeforeImageSettings ajoute un nouvel attribut JSON à chaque opération de mise à jour avec des valeurs collectées à partir du système de base de données source, comme indiqué ci-dessous.

"BeforeImageSettings": {
    "EnableBeforeImage": boolean,
    "FieldName": string,  
    "ColumnFilter": pk-only (default) / non-lob / all (but only one)
}
        

Pour les options BeforeImageSettings, les conditions suivantes s'appliquent :

Utilisation d'une règle de transformation d'image antérieure

Au lieu des paramètres de tâche, vous pouvez utiliser le paramètre add-before-image-columns, qui applique une règle de transformation de colonne. Avec ce paramètre, vous pouvez activer la génération d’image antérieure pendant la CDC sur des cibles de streaming de données comme Kinesis.

En utilisant add-before-image-columns dans une règle de transformation, vous pouvez exercer un contrôle plus précis sur les résultats de l'image antérieure. Les règles de transformation vous permettent d'utiliser un localisateur d'objets qui vous fournit un contrôle sur les tables sélectionnées pour la règle. En outre, vous pouvez enchaîner les règles de transformation, ce qui permet d'appliquer différentes règles à différentes tables. Vous pouvez ensuite manipuler les colonnes produites à l'aide d'autres règles.

Un type de règle transformation avec le paramètre add-before-image-columns d'une colonne doit fournir une section before-image-def. Vous en trouverez un exemple ci-dessous.

    {
      "rule-type": "transformation",
      …
      "rule-target": "column",
      "rule-action": "add-before-image-columns",
      "before-image-def":{
        "column-filter": one-of  (pk-only / non-lob / all),
        "column-prefix": string,
        "column-suffix": string,
      }
    }

La valeur de column-prefix est ajoutée à un nom de colonne et la valeur par défaut de column-prefix est BI_. La valeur de column-suffix est ajoutée au nom de la colonne et la valeur par défaut est vide. Ne définissez pas les deux column-prefix et column-suffix sur des chaînes vides.

Choisissez une valeur pour column-filter. Pour ajouter uniquement les colonnes qui font partie des clés primaires de la table, choisissez pk-only . Choisissez non-lob d'ajouter uniquement des colonnes qui ne sont pas de type LOB. Ou choisissez all d'ajouter une colonne qui a une valeur d’image antérieure.

Exemple de règle de transformation d'image antérieure

La règle de transformation de l'exemple suivant ajoute une nouvelle colonne appelée BI_emp_no dans la cible. Ainsi, une instruction comme UPDATE employees SET emp_no = 3 WHERE emp_no = 1; remplit le champ BI_emp_no avec 1. Lorsque vous écrivez des mises à jour de CDC sur des cibles Amazon S3, la colonne BI_emp_no permet de savoir quelle ligne d’origine a été mise à jour.

{
  "rules": [
    {
      "rule-type": "selection",
      "rule-id": "1",
      "rule-name": "1",
      "object-locator": {
        "schema-name": "%",
        "table-name": "%"
      },
      "rule-action": "include"
    },
    {
      "rule-type": "transformation",
      "rule-id": "2",
      "rule-name": "2",
      "rule-target": "column",
      "object-locator": {
        "schema-name": "%",
        "table-name": "employees"
      },
      "rule-action": "add-before-image-columns",
      "before-image-def": {
        "column-prefix": "BI_",
        "column-suffix": "",
        "column-filter": "pk-only"
      }
    }
  ]
}

Pour plus d'informations sur l'utilisation de l'action de règle add-before-image-columns, consultez Règles et actions de transformation.

Conditions préalables à l'utilisation d'un flux de données Kinesis comme cible pour AWS Database Migration Service

Rôle IAM pour l'utilisation d'un flux de données Kinesis comme cible pour AWS Database Migration Service

Avant de configurer un flux de données Kinesis comme cible AWS DMS, assurez-vous de créer un rôle IAM. Ce rôle doit permettre d' AWS DMS assumer et d'accorder l'accès aux flux de données Kinesis vers lesquels la migration est en cours de migration. L'ensemble d'autorisations d'accès minimum est indiqué dans la stratégie IAM suivante.

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

        

Le rôle que vous utilisez pour la migration vers un flux de données Kinesis doit bénéficier des autorisations suivantes.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "kinesis:DescribeStream",
                "kinesis:PutRecord",
                "kinesis:PutRecords"
            ],
            "Resource": "arn:aws:kinesis:region:accountID:stream/streamName"
        }
    ]
}

Accès à un flux de données Kinesis en tant que cible pour AWS Database Migration Service

Dans les AWS DMS versions 3.4.7 et supérieures, pour vous connecter à un point de terminaison Kinesis, vous devez effectuer l'une des opérations suivantes :

Limitations liées à l'utilisation de Kinesis Data Streams comme cible pour AWS Database Migration Service

Les limitations suivantes s’appliquent lorsque vous utilisez Kinesis Data Streams en tant que cible :

Utilisation du mappage d’objet pour migrer les données vers un flux de données Kinesis

AWS DMS utilise des règles de mappage de tables pour mapper les données de la source vers le flux de données Kinesis cible. Pour mapper des données vers un flux cible, vous utilisez un type de règles de mappage de tables qu'on appelle le mappage d'objet. Utilisez le mappage d’objet pour définir la façon dont les enregistrements de données de la source sont mappés aux enregistrements de données publiés dans le flux de données Kinesis.

Les flux de données Kinesis ne disposent pas d’une structure prédéfinie autre que le fait d’avoir une clé de partition. Dans une règle de mappage d'objets, les valeurs possibles de partition-key-type pour un enregistrement de données sont schema-table, transaction-id, primary-key, constant et attribute-name.

Pour créer une règle de mappage d'objet, spécifiez rule-type comme object-mapping. Cette règle spécifie le type de mappage d'objet que vous souhaitez utiliser.

La structure de la règle est la suivante.

{
    "rules": [
        {
            "rule-type": "object-mapping",
            "rule-id": "id",
            "rule-name": "name",
            "rule-action": "valid object-mapping rule action",
            "object-locator": {
                "schema-name": "case-sensitive schema name",
                "table-name": ""
            }
        }
    ]
}

AWS DMS prend actuellement en charge map-record-to-record et map-record-to-document en tant que seules valeurs valides pour le rule-action paramètre. Ces paramètres affectent les valeurs qui ne sont pas exclues de la liste d’attributs exclude-columns. Les map-record-to-document valeurs map-record-to-record et indiquent le mode de AWS DMS gestion de ces enregistrements par défaut. Ces valeurs n'affectent en aucune façon les mappages d'attributs.

Utilisez map-record-to-record lors d’une migration d’une base de données relationnelle vers un flux de données Kinesis. Ce type de règle utilise la valeur taskResourceId.schemaName.tableName de la base de données relationnelle comme clé de partition dans le flux de données Kinesis et crée un attribut pour chaque colonne de la base de données source.

Lorsque vous utilisez map-record-to-record, notez ce qui suit :

Utilisez map-record-to-document pour placer des colonnes sources dans un document unique à plat du flux cible approprié en utilisant le nom d’attribut « _doc ». AWS DMS place les données dans un mappage unique à plat sur la source appelée « _doc ». Ce placement s'applique à toute colonne de la table source non listée dans la liste d'attributs exclude-columns.

Une manière de comprendre map-record-to-record est de le voir en action. Dans cet exemple, imaginons que vous commencez avec une ligne de table d'une base de données relationnelle, présentant la structure et les données suivantes :

Pour migrer ces informations d’un schéma nommé Test vers un flux de données Kinesis, vous créez des règles pour mapper les données au flux cible. La règle suivante illustre ce mappage.

{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "rule-action": "include",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "%"
            }
        },
        {
            "rule-type": "object-mapping",
            "rule-id": "2",
            "rule-name": "DefaultMapToKinesis",
            "rule-action": "map-record-to-record",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "Customers"
            }
        }
    ]
}

L’exemple qui suit illustre le format d’enregistrement résultant dans le flux de données Kinesis :

Supposons toutefois que vous utilisiez les mêmes règles, mais que vous redéfinissiez le paramètre rule-action sur map-record-to-document et que vous excluiez certaines colonnes. La règle suivante illustre ce mappage.

{
	"rules": [
	   {
			"rule-type": "selection",
			"rule-id": "1",
			"rule-name": "1",
			"rule-action": "include",
			"object-locator": {
				"schema-name": "Test",
				"table-name": "%"
			}
		},
		{
			"rule-type": "object-mapping",
			"rule-id": "2",
			"rule-name": "DefaultMapToKinesis",
			"rule-action": "map-record-to-document",
			"object-locator": {
				"schema-name": "Test",
				"table-name": "Customers"
			},
			"mapping-parameters": {
				"exclude-columns": [
					"homeaddress",
					"homephone",
					"workaddress",
					"workphone"
				]
			}
		}
	]
}                

Dans ce cas, les colonnes non répertoriées dans le paramètre exclude-columns, FirstName, LastName, StoreId et DateOfBirth, sont mappées à _doc. L’exemple qui suit illustre le format d’enregistrement résultant.

       {
            "data":{
                "_doc":{
                    "FirstName": "Randy",
                    "LastName": "Marsh",
                    "StoreId":  "5",
                    "DateOfBirth": "02/29/1988"
                }
            }
        }
            

Restructuration de données avec le mappage d'attribut

Vous pouvez restructurer les données lors de leur migration vers un flux de données Kinesis à l’aide d’un mappage d’attribut. Par exemple, vous pourriez vouloir regrouper plusieurs champs de la source en un seul champ dans la cible. Le mappage d'attribut suivant illustre comment restructurer les données.

{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "rule-action": "include",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "%"
            }
        },
        {
            "rule-type": "object-mapping",
            "rule-id": "2",
            "rule-name": "TransformToKinesis",
            "rule-action": "map-record-to-record",
            "target-table-name": "CustomerData",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "Customers"
            },
            "mapping-parameters": {
                "partition-key-type": "attribute-name",
                "partition-key-name": "CustomerName",
                "exclude-columns": [
                    "firstname",
                    "lastname",
                    "homeaddress",
                    "homephone",
                    "workaddress",
                    "workphone"
                ],
                "attribute-mappings": [
                    {
                        "target-attribute-name": "CustomerName",
                        "attribute-type": "scalar",
                        "attribute-sub-type": "string",
                        "value": "${lastname}, ${firstname}"
                    },
                    {
                        "target-attribute-name": "ContactDetails",
                        "attribute-type": "document",
                        "attribute-sub-type": "json",
                        "value": {
                            "Home": {
                                "Address": "${homeaddress}",
                                "Phone": "${homephone}"
                            },
                            "Work": {
                                "Address": "${workaddress}",
                                "Phone": "${workphone}"
                            }
                        }
                    }
                ]
            }
        }
    ]
}

Pour définir une valeur constante pour partition-key, spécifiez une valeur partition-key. Par exemple, vous pouvez le faire pour forcer le stockage de toutes les données dans une seule partition. Le mappage suivant illustre cette approche.

{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "object-mapping",
            "rule-id": "1",
            "rule-name": "TransformToKinesis",
            "rule-action": "map-record-to-document",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "Customer"
            },
            "mapping-parameters": {
                "partition-key": {
                    "value": "ConstantPartitionKey"
                },
                "exclude-columns": [
                    "FirstName",
                    "LastName",
                    "HomeAddress",
                    "HomePhone",
                    "WorkAddress",
                    "WorkPhone"
                ],
                "attribute-mappings": [
                    {
                        "attribute-name": "CustomerName",
                        "value": "${FirstName},${LastName}"
                    },
                    {
                        "attribute-name": "ContactDetails",
                        "value": {
                            "Home": {
                                "Address": "${HomeAddress}",
                                "Phone": "${HomePhone}"
                            },
                            "Work": {
                                "Address": "${WorkAddress}",
                                "Phone": "${WorkPhone}"
                            }
                        }
                    },
                    {
                        "attribute-name": "DateOfBirth",
                        "value": "${DateOfBirth}"
                    }
                ]
            }
        }
    ]
}

Format de message pour Kinesis Data Streams

La sortie JSON est simplement une liste de paires clé-valeur. Un format de message JSON_UNFORMATED est une chaîne JSON à une seule ligne avec un délimiteur de nouvelle ligne.

AWS DMS fournit les champs réservés suivants pour faciliter la consommation des données issues des Kinesis Data Streams :