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.
# Utiliser Amazon S3 comme cible pour AWS Database Migration Service
Vous pouvez migrer des données vers Amazon S3 à AWS DMS partir de l'une des sources de base de données prises en charge. Lorsque vous utilisez Amazon S3 comme cible dans une AWS DMS tâche, les données de chargement complet et de capture des données de modification (CDC) sont écrites au format de valeurs séparées par des virgules (.csv) par défaut. Pour plus d'options de stockage compact et de requêtes plus rapides, vous avez également la possibilité d'écrire les données au format Apache Parquet (.parquet).
AWS DMS nomme les fichiers créés lors d'un chargement complet à l'aide d'un compteur hexadécimal incrémentiel, par exemple LOAD00001 .csv,... LOAD00002 LOAD00009, LOAD0000 A, etc. pour les fichiers .csv. AWS DMS nomme les fichiers CDC à l'aide d'horodatages, par exemple 20141029-1134010000.csv. Pour chaque table source contenant des enregistrements, AWS DMS crée un dossier sous le dossier cible spécifié (si la table source n'est pas vide). AWS DMS écrit tous les fichiers CDC et à chargement complet dans le compartiment Amazon S3 spécifié. Vous pouvez contrôler la taille des fichiers créés à l'aide du paramètre du [MaxFileSize](https://docs.aws.amazon.com/dms/latest/APIReference/API_S3Settings.html#DMS-Type-S3Settings-MaxFileSize)point de terminaison. AWS DMS
Le paramètre `bucketFolder` contient l'emplacement où les fichiers .csv ou .parquet sont stockés avant d'être téléchargés vers le compartiment S3. Avec les fichiers .csv, les données de la table sont stockées dans le compartiment S3 au format suivant (l’exemple s’applique à des fichiers de chargement complet).
```
database_schema_name/table_name/LOAD00000001.csv
database_schema_name/table_name/LOAD00000002.csv
...
database_schema_name/table_name/LOAD00000009.csv
database_schema_name/table_name/LOAD0000000A.csv
database_schema_name/table_name/LOAD0000000B.csv
...database_schema_name/table_name/LOAD0000000F.csv
database_schema_name/table_name/LOAD00000010.csv
...
```
Vous pouvez spécifier le délimiteur de colonne, le délimiteur de ligne et d'autres paramètres à l'aide des attributs de connexion supplémentaires. Pour obtenir plus d'informations sur les attributs de connexion supplémentaires, consultez [Paramètres du point de terminaison lors de l'utilisation d'Amazon S3 comme cible pour AWS DMS](#CHAP_Target.S3.Configuring) à la fin de cette section.
Pour éviter toute usurpation d'identité, AWS DMS valide la propriété du bucket avant d'effectuer des opérations. Par défaut, lorsque le paramètre du point de terminaison `ExpectedBucketOwner` Amazon S3 n'est pas spécifié, il AWS DMS utilise l'ID de AWS compte qui détient le rôle de AWS DMS service en tant que propriétaire attendu du compartiment.
Pour migrer des données vers un compartiment S3 appartenant à un autre AWS compte, vous devez spécifier explicitement le propriétaire réel du compartiment dans le paramètre du point de terminaison `ExpectedBucketOwner` Amazon S3, comme indiqué ci-dessous. Dans le cas contraire, la tâche de réplication entre comptes échouera.
```
--s3-settings '{"ExpectedBucketOwner": "AWS_Account_ID"}'
```
Lorsque vous répliquez les modifications de données AWS DMS à l'aide d'une tâche CDC, la première colonne du fichier de sortie .csv ou .parquet indique comment les données de ligne ont été modifiées, comme indiqué dans le fichier .csv suivant.
```
I,101,Smith,Bob,4-Jun-14,New York
U,101,Smith,Bob,8-Oct-15,Los Angeles
U,101,Smith,Bob,13-Mar-17,Dallas
D,101,Smith,Bob,13-Mar-17,Dallas
```
Pour cet exemple, supposons qu'il existe une `EMPLOYEE` table dans la base de données source. AWS DMS écrit des données dans le fichier .csv ou .parquet, en réponse aux événements suivants :
+ Un nouvel employé (Bob Smith, ID employé 101) est engagé le 4 juin 2014 au bureau de New York. Dans le fichier .csv ou .parquet, la valeur `I` dans la première colonne indique qu'une nouvelle ligne a fait l'objet d'une opération `INSERT` dans la table EMPLOYEE de la base de données source.
+ Le 8 octobre 2015, Bob est transféré au bureau de Los Angeles. Dans le fichier .csv ou .parquet, la valeur `U` indique que la ligne correspondante de la table EMPLOYEE a fait l'objet d'une opération `UPDATE` pour refléter le nouvel emplacement du bureau de Bob. Le reste reflète la ligne de la table EMPLOYEE telle qu'elle apparaît après l'opération `UPDATE`.
+ Le 13 mars 2017, Bob Dallas est à nouveau transféré au bureau de Dallas. Dans le fichier .csv ou .parquet, la valeur `U` indique que cette ligne a fait de nouveau l'objet d'une opération `UPDATE`. Le reste reflète la ligne de la table EMPLOYEE telle qu'elle apparaît après l'opération `UPDATE`.
+ Après avoir travaillé quelque temps à Dallas, Bob quitte l'entreprise. Dans le fichier .csv ou .parquet, la valeur `D` indique que la ligne a fait l'objet d'une opération `DELETE` dans la table source. Le reste reflète la ligne de la table EMPLOYEE telle qu'elle apparaît avant la suppression.
Notez que par défaut pour CDC, AWS DMS stocke les modifications de ligne pour chaque table de base de données sans tenir compte de l'ordre des transactions. Si vous souhaitez stocker les modifications de ligne dans les fichiers de CDC en fonction de l’ordre des transactions, vous devez utiliser les paramètres de point de terminaison S3 pour le spécifier ainsi que le chemin du dossier dans lequel vous souhaitez que les fichiers de transaction CDC soient stockés sur la cible S3. Pour de plus amples informations, veuillez consulter [Capture des données de modification (CDC) avec l’ordre des transactions sur la cible S3](#CHAP_Target.S3.EndpointSettings.CdcPath).
Pour contrôler la fréquence des écritures sur une cible Amazon S3 lors d’une tâche de réplication de données, vous pouvez configurer les attributs de connexion supplémentaires `cdcMaxBatchInterval` et `cdcMinFileSize`. Cela peut améliorer les performances lors de l’analyse des données sans aucune surcharge supplémentaire. Pour de plus amples informations, consultez [Paramètres du point de terminaison lors de l'utilisation d'Amazon S3 comme cible pour AWS DMS](#CHAP_Target.S3.Configuring).
**Topics**
+ [Prérequis pour l’utilisation d’Amazon S3 en tant que cible](#CHAP_Target.S3.Prerequisites)
+ [Limitations de l’utilisation d’Amazon S3 en tant que cible](#CHAP_Target.S3.Limitations)
+ [Sécurité](#CHAP_Target.S3.Security)
+ [Utilisation d’Apache Parquet pour stocker des objets Amazon S3](#CHAP_Target.S3.Parquet)
+ [Balisage d’objets Amazon S3](#CHAP_Target.S3.Tagging)
+ [Création de AWS KMS clés pour chiffrer les objets cibles d'Amazon S3](#CHAP_Target.S3.KMSKeys)
+ [Utilisation du partitionnement de dossiers basé sur la date](#CHAP_Target.S3.DatePartitioning)
+ [Chargement parallèle de sources partitionnées lors de l'utilisation d'Amazon S3 comme cible pour AWS DMS](#CHAP_Target.S3.ParallelLoad)
+ [Paramètres du point de terminaison lors de l'utilisation d'Amazon S3 comme cible pour AWS DMS](#CHAP_Target.S3.Configuring)
+ [Utilisation AWS Glue Data Catalog avec une cible Amazon S3 pour AWS DMS](#CHAP_Target.S3.GlueCatalog)
+ [Utilisation du chiffrement des données, des fichiers Parquet et de la CDC sur votre cible Amazon S3](#CHAP_Target.S3.EndpointSettings)
+ [Indication des opérations de base de données source dans des données S3 migrées](#CHAP_Target.S3.Configuring.InsertOps)
+ [Types de données cibles pour S3 Parquet](#CHAP_Target.S3.DataTypes)
## Prérequis pour l’utilisation d’Amazon S3 en tant que cible
Avant d’utiliser Amazon S3 en tant que cible, vérifiez que les conditions suivantes sont réunies :
+ Le compartiment S3 que vous utilisez comme cible se trouve dans la même AWS région que l'instance de réplication DMS que vous utilisez pour migrer vos données.
+ Le AWS compte que vous utilisez pour la migration possède un rôle IAM avec accès en écriture et en suppression au compartiment S3 que vous utilisez comme cible.
+ Ce rôle dispose d'un accès de balisage afin que vous pouvez baliser tous les objets S3 écrits sur le compartiment cible.
+ DMS (dms.amazonaws.com) a été ajouté au rôle IAM en tant qu’*entité de confiance*.
+ Pour les AWS DMS versions 3.4.7 et supérieures, DMS doit accéder au compartiment source via un point de terminaison VPC ou une route publique. Pour plus d'informations sur les points de terminaison VPC, consultez. [Configuration des points de terminaison VPC pour AWS DMS](CHAP_VPC_Endpoints.md)
Pour définir cet accès de compte, assurez-vous que le rôle affecté au compte utilisateur utilisé pour créer la tâche de migration bénéficie de l'ensemble d'autorisations suivant.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:DeleteObject",
"s3:PutObjectTagging"
],
"Resource": [
"arn:aws:s3:::buckettest2/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::buckettest2"
]
}
]
}
```
------
Pour connaître les conditions préalables à l’utilisation de la validation avec S3 en tant que cible, consultez [Conditions préalables à la validation des cibles S3](CHAP_Validating_S3.md#CHAP_Validating_S3_prerequisites).
## Limitations de l’utilisation d’Amazon S3 en tant que cible
Les limitations suivantes s’appliquent lorsque vous utilisez Amazon S3 en tant que cible :
+ N’activez pas la gestion des versions pour S3. Si vous avez besoin de la gestion des versions S3, utilisez des politiques de cycle de vie pour supprimer les anciennes versions de manière active. Dans le cas contraire, la connexion de test du point de terminaison risque d’échouer en raison du délai d’attente d’appel `list-object` S3. Pour créer une politique de cycle de vie pour un compartiment S3, consultez [Gestion du cycle de vie de votre stockage](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html). Pour supprimer une version d’un objet S3, consultez [Suppression des versions d’objet d’un compartiment activé pour la gestion des versions](https://docs.aws.amazon.com/AmazonS3/latest/dev/DeletingObjectVersions.html).
+ Un compartiment S3 compatible VPC (VPC de passerelle) est pris en charge dans les versions 3.4.7 et ultérieures.
+ Les commandes de langage de définition de données (DDL) suivantes sont prises en charge pour la capture des données de modification (CDC) : tronquer une table, supprimer une table, créer une table, renommer une table, ajouter une colonne, supprimer une colonne, renommer une colonne et modifier le type de données de colonne. Notez que lorsqu'une colonne est ajoutée, supprimée ou renommée dans la base de données source, aucune instruction ALTER n'est enregistrée dans le compartiment S3 cible et AWS DMS ne modifie pas les enregistrements créés précédemment pour qu'ils correspondent à la nouvelle structure. Après la modification, AWS DMS crée de nouveaux enregistrements à l'aide de la nouvelle structure de table.
**Note**
Une opération DDL de troncation supprime tous les fichiers et les dossiers de table correspondants d’un compartiment S3. Vous pouvez utiliser les paramètres de tâche pour désactiver ce comportement et configurer la façon dont DMS gère le comportement DDL lors de la capture des données de modification (CDC). Pour de plus amples informations, veuillez consulter [Paramètres de tâche pour la gestion du DDL de traitement des modifications](CHAP_Tasks.CustomizingTasks.TaskSettings.DDLHandling.md).
+ Le Mode LOB complet n'est pas pris en charge.
+ Les modifications apportées à la structure de la table source lors du chargement complet ne sont pas prises en charge. Les modifications apportées aux données sont prises en charge pendant le chargement complet.
+ Lorsque plusieurs tâches répliquent des données d'une même table source vers le même compartiment de point de terminaison S3 cible, ces tâches écrivent dans le même fichier. Nous vous recommandons de spécifier des points de terminaison (compartiments) cibles différents si votre source de données est de la même table.
+ `BatchApply` n’est pas pris en charge pour un point de terminaison S3. L’utilisation de l’application par lots (par exemple, le paramètre de tâche de métadonnées cible `BatchApplyEnabled`) pour une cible S3 peut entraîner une perte de données.
+ Vous ne pouvez pas utiliser `DatePartitionEnabled` ou `addColumnName` ensemble avec `PreserveTransactions` ou `CdcPath`.
+ AWS DMS ne permet pas de renommer plusieurs tables sources dans le même dossier cible à l'aide de règles de transformation.
+ En cas d’écriture intensive dans la table source pendant la phase de chargement complet, DMS peut écrire des enregistrements dupliqués dans le compartiment S3 ou des modifications mises en cache.
+ Si vous configurez la tâche avec `TargetTablePrepMode` défini sur `DO_NOTHING`, DMS peut écrire des enregistrements dupliqués dans le compartiment S3 si la tâche s’arrête et reprend brusquement pendant la phase de chargement complet.
+ Si vous configurez le point de terminaison cible avec le paramètre `PreserveTransactions` défini sur `true`, le rechargement d’une table n’efface pas les fichiers CDC générés précédemment. Pour de plus amples informations, veuillez consulter [Capture des données de modification (CDC) avec l’ordre des transactions sur la cible S3](#CHAP_Target.S3.EndpointSettings.CdcPath).
Pour connaître les limitations de l’utilisation de la validation avec S3 en tant que cible, consultez [Limitations liées à l’utilisation de la validation des cibles S3](CHAP_Validating_S3.md#CHAP_Validating_S3_limitations).
## Sécurité
Pour utiliser Amazon S3 en tant que cible, le compte utilisé pour la migration doit bénéficier d’un accès pour l’écriture et la suppression au compartiment Amazon S3 qui est utilisé comme cible. Spécifiez l’Amazon Resource Name (ARN) du rôle IAM qui bénéficie des autorisations requises pour accéder à Amazon S3.
AWS DMS prend en charge un ensemble d'autorisations prédéfinies pour Amazon S3, appelées listes de contrôle d'accès prédéfinies (ACLs). Chaque liste ACL prédéfinie possède un ensemble de bénéficiaires et d’autorisations que vous pouvez utiliser pour définir les autorisations du compartiment Amazon S3. Vous pouvez spécifier une liste ACL prédéfinie à l'aide de l'attribut `cannedAclForObjects` de la chaîne de connexion de votre point de terminaison cible S3. Pour plus d'informations sur l'utilisation de l'attribut de connexion supplémentaire `cannedAclForObjects`, consultez [Paramètres du point de terminaison lors de l'utilisation d'Amazon S3 comme cible pour AWS DMS](#CHAP_Target.S3.Configuring). Pour plus d'informations sur Amazon S3 scanné ACLs, consultez la section [Caned ACL](https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl).
Le rôle IAM que vous utilisez pour la migration doit être en mesure d'effectuer l'opération d'API `s3:PutObjectAcl`.
## Utilisation d’Apache Parquet pour stocker des objets Amazon S3
Le format .csv (valeurs séparées par des virgules) est le format de stockage par défaut pour les objets cibles Amazon S3. Pour un stockage plus compact et des requêtes plus rapides, vous pouvez utiliser le format de stockage Apache Parquet (.parquet).
Apache Parquet est un format de stockage de fichiers open source, initialement conçu pour Hadoop. Pour plus d'informations sur Apache Parquet, consultez [https://parquet.apache.org/](https://parquet.apache.org/).
Pour définir .parquet comme format de stockage pour vos objets cibles S3 migrés, vous pouvez utiliser les mécanismes suivants :
+ Paramètres de point de terminaison que vous fournissez sous forme de paramètres d'objet JSON lorsque vous créez le point de terminaison à l'aide de l' AWS CLI ou de l'API pour AWS DMS. Pour de plus amples informations, veuillez consulter [Utilisation du chiffrement des données, des fichiers Parquet et de la CDC sur votre cible Amazon S3](#CHAP_Target.S3.EndpointSettings).
+ Attributs de connexion supplémentaires que vous fournissez sous forme de liste séparée par des points-virgules lorsque vous créez le point de terminaison. Pour de plus amples informations, veuillez consulter [Paramètres du point de terminaison lors de l'utilisation d'Amazon S3 comme cible pour AWS DMS](#CHAP_Target.S3.Configuring).
## Balisage d’objets Amazon S3
Vous pouvez baliser des objets Amazon S3 créés par une instance de réplication en spécifiant les objets JSON appropriés dans le cadre des règles de mappage des tâches aux tables. Pour plus d’informations sur les exigences et les options du balisage d’objets S3, y compris les noms de balise valides, consultez [Balisage d’objets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-tagging.html) dans le *Guide de l’utilisateur Amazon Simple Storage Service*. Pour plus d'informations sur le mappage de table avec JSON, consultez [Spécification des règles de sélection de table et de transformation à l’aide de JSON](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.md).
Vous pouvez baliser des objets S3 créés pour des tables et des schémas spécifiés à l'aide d'un ou plusieurs objets JSON du type de règle `selection`. Vous pouvez faire suivre cet objet (ou ces objets) `selection` d'un ou plusieurs objets JSON du type de règle `post-processing` avec l'action `add-tag`. Ces règles de post-traitement identifient les objets S3 que vous souhaitez baliser et spécifient les noms et les valeurs des balises que vous souhaitez ajouter à ces objets S3.
Vous trouverez les paramètres à spécifier dans les objets JSON du type de règle `post-processing` dans le tableau suivant.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/dms/latest/userguide/CHAP_Target.S3.html)
Lorsque vous spécifiez plusieurs types de règle `post-processing` pour baliser une sélection d'objets S3, chaque objet S3 est balisé à l'aide d'un seul objet `tag-set` à partir d'une règle de post-traitement. L'ensemble de balises utilisé pour baliser un objet S3 donné est celui issu de la règle de post-traitement dont le localisateur d'objet associé correspond le mieux à l'objet S3.
Par exemple, supposons que deux règles de post-traitement identifient le même objet S3. Supposons également que le localisateur d'objet d'une règle utilise des caractères génériques et que le localisateur d'objet de l'autre règle utilise une correspondance exacte pour identifier l'objet S3 (sans caractères génériques). Dans ce cas, l'ensemble de balises associé à la règle de post-traitement avec la correspondance exacte est utilisé pour baliser l'objet S3. Si plusieurs règles de post-traitement correspondent de manière identique à un objet S3, l'ensemble de balises associé à la première règle de post-traitement est utilisé pour baliser l'objet.
**Example Ajout de balises statiques à un objet S3 créé pour une table et un schéma unique**
Les règles de sélection et de post-traitement suivantes ajoutent trois balises (`tag_1`, `tag_2` et `tag_3` avec leurs valeurs statiques correspondantes `value_1`, `value_2` et `value_3`) à un objet S3 créé. Cet objet S3 correspond à une table unique dans la source nommée `STOCK` avec un schéma nommé `aat2`.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "5",
"rule-name": "5",
"object-locator": {
"schema-name": "aat2",
"table-name": "STOCK"
},
"rule-action": "include"
},
{
"rule-type": "post-processing",
"rule-id": "41",
"rule-name": "41",
"rule-action": "add-tag",
"object-locator": {
"schema-name": "aat2",
"table-name": "STOCK"
},
"tag-set": [
{
"key": "tag_1",
"value": "value_1"
},
{
"key": "tag_2",
"value": "value_2"
},
{
"key": "tag_3",
"value": "value_3"
}
]
}
]
}
```
**Example Ajout de balises statiques et dynamiques à des objets S3 créés pour plusieurs tables et schémas**
L'exemple suivant présente une règle de sélection et deux règles de post-traitement, où l'entrée de la source inclut toutes les tables et tous leurs schémas.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "include"
},
{
"rule-type": "post-processing",
"rule-id": "21",
"rule-name": "21",
"rule-action": "add-tag",
"object-locator": {
"schema-name": "%",
"table-name": "%",
},
"tag-set": [
{
"key": "dw-schema-name",
"value":"${schema-name}"
},
{
"key": "dw-schema-table",
"value": "my_prefix_${table-name}"
}
]
},
{
"rule-type": "post-processing",
"rule-id": "41",
"rule-name": "41",
"rule-action": "add-tag",
"object-locator": {
"schema-name": "aat",
"table-name": "ITEM",
},
"tag-set": [
{
"key": "tag_1",
"value": "value_1"
},
{
"key": "tag_2",
"value": "value_2"
} ]
}
]
}
```
La première règle de post-traitement ajoute deux balises (`dw-schema-name` et `dw-schema-table`) avec les valeurs dynamiques correspondantes (`${schema-name}` et `my_prefix_${table-name}`) pour presque tous les objets S3 créés dans la cible. L'exception est l'objet S3 identifié et balisé avec la seconde règle de post-traitement. Par conséquent, chaque objet S3 cible identifié par le localisateur d'objet utilisant des caractères génériques est créé avec des balises qui identifient le schéma et la table auxquels il correspond dans la source.
La deuxième règle de post-traitement ajoute `tag_1` et `tag_2` avec les valeurs statiques correspondantes `value_1` et `value_2` à un objet S3 qui est identifié par un localisateur d'objet utilisant une correspondance exacte. Cet objet S3 créé correspond donc à la table unique dans la source nommée `ITEM` avec un schéma nommé `aat`. En raison de la correspondance exacte, ces balises remplacent toutes les balises sur cet objet ajouté à partir de la première règle de post-traitement, qui correspond à des objets S3 par caractère générique uniquement.
**Example Ajout de noms et de valeurs de balise dynamique à des objets S3**
L'exemple suivant comporte deux règles de sélection et une règle de post-traitement. Ici, l'entrée à partir de la source comprend seulement la table `ITEM` dans le schéma `retail` ou `wholesale`.
```
{
"rules": [
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "retail",
"table-name": "ITEM"
},
"rule-action": "include"
},
{
"rule-type": "selection",
"rule-id": "1",
"rule-name": "1",
"object-locator": {
"schema-name": "wholesale",
"table-name": "ITEM"
},
"rule-action": "include"
},
{
"rule-type": "post-processing",
"rule-id": "21",
"rule-name": "21",
"rule-action": "add-tag",
"object-locator": {
"schema-name": "%",
"table-name": "ITEM",
},
"tag-set": [
{
"key": "dw-schema-name",
"value":"${schema-name}"
},
{
"key": "dw-schema-table",
"value": "my_prefix_ITEM"
},
{
"key": "${schema-name}_ITEM_tag_1",
"value": "value_1"
},
{
"key": "${schema-name}_ITEM_tag_2",
"value": "value_2"
}
]
]
}
```
L'ensemble de balises pour la règle de post-traitement ajoute deux balises (`dw-schema-name` et `dw-schema-table`) à tous les objets S3 créés pour la table `ITEM` dans la cible. La première balise a la valeur dynamique `"${schema-name}"` et la deuxième balise a une valeur statique, `"my_prefix_ITEM"`. Par conséquent, chaque objet S3 cible est créé avec des balises qui identifient le schéma et la table auxquels il correspond dans la source.
En outre, l'ensemble de balises ajoute deux balises supplémentaires avec des noms dynamiques (`${schema-name}_ITEM_tag_1` et `"${schema-name}_ITEM_tag_2"`). Ces derniers ont les valeurs statiques correspondantes `value_1` et `value_2`. Ainsi, chacune de ces balises est nommée pour le schéma actuel, `retail` ou `wholesale`. Vous ne pouvez pas créer un nom de balise dynamique dupliqué dans cet objet, car chaque objet est créé pour un nom de schéma unique. Le nom de schéma est utilisé pour créer un autre nom de balise unique.
## Création de AWS KMS clés pour chiffrer les objets cibles d'Amazon S3
Vous pouvez créer et utiliser des AWS KMS clés personnalisées pour chiffrer vos objets cibles Amazon S3. Après avoir créé une clé KMS, vous pouvez l'utiliser pour chiffrer des objets à l'aide de l'une des approches suivantes lorsque vous créez le point de terminaison cible S3 :
+ Utilisez les options suivantes pour les objets cibles S3 (avec le format de stockage de fichiers .csv par défaut) lorsque vous exécutez la commande `create-endpoint` à l'aide de l' AWS CLI.
```
--s3-settings '{"ServiceAccessRoleArn": "your-service-access-ARN",
"CsvRowDelimiter": "\n", "CsvDelimiter": ",", "BucketFolder": "your-bucket-folder",
"BucketName": "your-bucket-name", "EncryptionMode": "SSE_KMS",
"ServerSideEncryptionKmsKeyId": "your-KMS-key-ARN"}'
```
Ici, votre- `your-KMS-key-ARN` est le nom de ressource Amazon (ARN) de votre clé KMS et il est nécessaire que votre rôle IAM dispose d'autorisations d'accès, voir[Utilisation du chiffrement des données, des fichiers Parquet et de la CDC sur votre cible Amazon S3](#CHAP_Target.S3.EndpointSettings).
+ Définissez l'attribut de connexion supplémentaire `encryptionMode` à la valeur `SSE_KMS` et l'attribut de connexion supplémentaire `serverSideEncryptionKmsKeyId` à l'ARN de votre clé KMS. Pour de plus amples informations, veuillez consulter [Paramètres du point de terminaison lors de l'utilisation d'Amazon S3 comme cible pour AWS DMS](#CHAP_Target.S3.Configuring).
Pour chiffrer des objets cibles Amazon S3 à l’aide d’une clé KMS, vous avez besoin d’un rôle IAM qui dispose des autorisations d’accès au compartiment Amazon S3. Ce rôle IAM est ensuite accessible dans une stratégie (stratégie de clé) attachée à la clé de chiffrement que vous créez. Pour ce faire, créez les éléments suivants dans votre console IAM :
+ Une stratégie avec les autorisations d’accès au compartiment Amazon S3.
+ Un rôle IAM avec cette stratégie.
+ Une clé de chiffrement de clé KMS avec une stratégie de clé qui fait référence à ce rôle.
Les procédures suivantes décrivent la marche à suivre.
**Pour créer une politique IAM avec les autorisations d’accès au compartiment Amazon S3**
1. Ouvrez la console IAM à l’adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Dans le volet de navigation, choisissez **Stratégies**. La page **Stratégies** s'ouvre.
1. Choisissez **Create Policy** (Créer une politique). La page **Créer une politique** s'ouvre.
1. Choisissez **Service**, puis **S3**. Une liste d'autorisations d'action s'affiche.
1. Choisissez **Développer tout** pour développer la liste et choisissez au moins les autorisations suivantes :
+ **ListBucket**
+ **PutObject**
+ **DeleteObject**
Choisissez toute autre autorisation dont vous avez besoin, puis sélectionnez **Réduire tout** pour réduire la liste.
1. Choisissez **Ressources** pour spécifier les ressources auxquelles vous souhaitez accéder. Choisissez au moins **Toutes les ressources** pour fournir un accès général aux ressources Amazon S3.
1. Ajoutez toute autre condition ou autorisation dont vous avez besoin, puis choisissez **Examiner une stratégie**. Vérifiez vos résultats sur la page **Examiner une stratégie**.
1. Si les paramètres vous conviennent, entrez un nom pour la stratégie (par exemple, `DMS-S3-endpoint-access`) et une description, puis choisissez **Créer une stratégie**. La page **Stratégies** s'ouvre et affiche un message indiquant que votre stratégie a été créée.
1. Recherchez et choisissez le nom de la stratégie dans la liste **Stratégies**. La page **Récapitulatif** affiche la stratégie au format JSON comme ci-après.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:ListBucket",
"s3:DeleteObject"
],
"Resource": "*"
}
]
}
```
------
Vous avez créé une nouvelle stratégie pour accéder à des ressources Amazon S3 en vue du chiffrement avec un nom spécifié, par exemple `DMS-S3-endpoint-access`.
**Pour créer un rôle IAM avec cette stratégie**
1. Dans votre console IAM, choisissez **Rôles** dans le volet de navigation. La page détaillée **Rôles** s'ouvre.
1. Choisissez **Créer un rôle**. La page **Créer un rôle** s'ouvre.
1. Lorsque le AWS service est sélectionné comme entité de confiance, choisissez **DMS** comme service pour utiliser le rôle IAM.
1. Choisissez **Suivant : Autorisations**. La vue **Attacher des stratégies d'autorisation** s'affiche dans la page **Créer un rôle**.
1. Recherchez et sélectionnez la stratégie IAM pour le rôle IAM que vous avez créé dans la procédure précédente (`DMS-S3-endpoint-access`).
1. Choisissez **Suivant : Balises**. La vue **Ajouter des balises** s'affiche dans la page **Créer un rôle**. Ici, vous pouvez ajouter toutes les balises souhaitées.
1. Choisissez **Suivant : Vérification**. La vue **Vérifier** s'affiche dans la page **Créer un rôle**. Ici, vous pouvez vérifier les résultats.
1. Si les paramètres vous conviennent, entrez un nom pour le rôle (par exemple, `DMS-S3-endpoint-access-role`) et une description, puis choisissez **Créer un rôle**. La page détaillée **Rôles** s'ouvre et affiche un message indiquant que votre rôle a été créé.
Vous avez désormais créé le nouveau rôle pour accéder aux ressources Amazon S3 en vue du chiffrement avec un nom spécifié, par exemple `DMS-S3-endpoint-access-role`.
**Pour créer une clé de chiffrement de clé KMS avec une stratégie de clé qui fait référence à votre rôle IAM**
**Note**
Pour plus d'informations sur le AWS DMS fonctionnement des clés de AWS KMS chiffrement, consultez[Configuration d'une clé de chiffrement et spécification AWS KMS des autorisations](CHAP_Security.md#CHAP_Security.EncryptionKey).
1. Connectez-vous à la console AWS Key Management Service (AWS KMS) AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/kms.](https://console.aws.amazon.com/kms)
1. Pour modifier le Région AWS, utilisez le sélecteur de région dans le coin supérieur droit de la page.
1. Dans le panneau de navigation, choisissez **Clés gérées par le client**.
1. Choisissez **Create key**. La page **Configurer la clé** s'ouvre.
1. Pour **Type de clé**, choisissez **Symétrique**.
**Note**
Lorsque vous créez cette clé, vous ne pouvez créer qu'une clé symétrique, car tous les AWS services, tels qu'Amazon S3, ne fonctionnent qu'avec des clés de chiffrement symétriques.
1. Choisissez **Options avancées**. Pour **Origine des éléments de clé**, assurez-vous que **KMS** est choisi, puis choisissez **Suivant**. La page **Ajouter des étiquettes** s'ouvre.
1. Dans **Créer un alias et une description**, entrez un alias pour la clé (par exemple, `DMS-S3-endpoint-encryption-key`) et toute description supplémentaire.
1. Pour **Balises**, ajoutez les balises que vous souhaitez pour vous aider à identifier la clé et suivre son utilisation, puis choisissez **Suivant**. La page **Définir des autorisations d'administration de clé** s'ouvre et affiche une liste d'utilisateurs et de rôles parmi lesquels vous pouvez choisir.
1. Ajoutez les utilisateurs et les rôles que vous souhaitez voir gérer la clé. Assurez-vous que ces utilisateurs et ces rôles ont les autorisations requises pour gérer la clé.
1. Pour **Suppression de clé**, choisissez si les administrateurs de clé peuvent supprimer celle-ci, puis choisissez **Suivant**. La page **Définir des autorisations d'utilisation de clé** s'ouvre et affiche une liste supplémentaire d'utilisateurs et de rôles parmi lesquels vous pouvez choisir.
1. Pour **Ce compte**, choisissez les utilisateurs disponibles pour lesquels vous souhaitez effectuer des opérations de chiffrement sur des cibles Amazon S3. Choisissez également le rôle que vous avez créé précédemment dans **Rôles** pour activer l’accès au chiffrement des objets cibles Amazon S3, par exemple `DMS-S3-endpoint-access-role`.
1. Si vous souhaitez ajouter d'autres comptes ne figurant pas dans la liste pour avoir ce même accès, dans **Autres AWS comptes**, choisissez **Ajouter un autre AWS compte**, puis cliquez sur **Suivant**. La page **Réviser et modifier la stratégie de clé** s'ouvre, affichant le JSON de la stratégie de clé que vous pouvez réviser et modifier en saisissant les informations dans le JSON existant. Ici, vous pouvez voir où la stratégie clé fait référence au rôle et aux utilisateurs (par exemple, `Admin` et `User1`) que vous avez choisis à l'étape précédente. Vous pouvez également voir les actions clés autorisées pour les différents mandataires (utilisateurs et rôles), comme illustré dans l'exemple suivant.
------
#### [ JSON ]
****
```
{
"Id": "key-consolepolicy-3",
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Enable IAM User Permissions",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:root"
]
},
"Action": "kms:*",
"Resource": "*"
},
{
"Sid": "Allow access for Key Administrators",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:role/Admin"
]
},
"Action": [
"kms:Create*",
"kms:Describe*",
"kms:Enable*",
"kms:List*",
"kms:Put*",
"kms:Update*",
"kms:Revoke*",
"kms:Disable*",
"kms:Get*",
"kms:Delete*",
"kms:TagResource",
"kms:UntagResource",
"kms:ScheduleKeyDeletion",
"kms:CancelKeyDeletion"
],
"Resource": "*"
},
{
"Sid": "Allow use of the key",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:role/DMS-S3-endpoint-access-role",
"arn:aws:iam::111122223333:role/Admin",
"arn:aws:iam::111122223333:role/User1"
]
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "*"
},
{
"Sid": "Allow attachment of persistent resources",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:role/DMS-S3-endpoint-access-role",
"arn:aws:iam::111122223333:role/Admin",
"arn:aws:iam::111122223333:role/User1"
]
},
"Action": [
"kms:CreateGrant",
"kms:ListGrants",
"kms:RevokeGrant"
],
"Resource": "*",
"Condition": {
"Bool": {
"kms:GrantIsForAWSResource": true
}
}
}
]
}
```
------
1. Choisissez **Finish** (Terminer). La page **Clés de chiffrement** s’ouvre et affiche un message indiquant que votre clé KMS a été créée.
Vous venez de créer une nouvelle clé KMS avec un alias spécifié (par exemple, `DMS-S3-endpoint-encryption-key`). Cette clé permet AWS DMS de chiffrer les objets cibles d'Amazon S3.
## Utilisation du partitionnement de dossiers basé sur la date
AWS DMS prend en charge les partitions de dossiers S3 en fonction de la date de validation de la transaction lorsque vous utilisez Amazon S3 comme point de terminaison cible. Avec le partitionnement de dossiers basé sur la date, vous pouvez écrire des données à partir d’une table source unique dans une structure de dossiers hiérarchisée dans le temps dans un compartiment S3. En partitionnant des dossiers lors de la création d’un point de terminaison cible S3, vous pouvez :
+ Mieux gérer vos objets S3
+ Limiter la taille de chaque dossier S3
+ Optimiser les requêtes du lac de données ou les autres opérations ultérieures
Vous pouvez activer le partitionnement de dossiers basé sur la date lorsque vous créez un point de terminaison cible S3. Vous pouvez l’activer lorsque vous migrez des données existantes et que vous répliquez les modifications continues (chargement complet \$1 CDC) ou lorsque vous répliquez uniquement les modifications de données (CDC uniquement). Lorsque vous migrez des données existantes et que vous répliquez les modifications en cours, seules les modifications en cours seront partitionnées. Utilisez les paramètres de point de terminaison cible suivants :
+ `DatePartitionEnabled` : spécifie le partitionnement en fonction des dates. Définissez cette option booléenne sur `true` pour partitionner les dossiers de compartiment S3 en fonction des dates de validation des transactions.
Vous ne pouvez pas utiliser ce paramètre avec `PreserveTransactions` ou `CdcPath`.
La valeur par défaut est `false`.
+ `DatePartitionSequence` : identifie la séquence du format de date à utiliser lors du partitionnement des dossiers. Définissez cette option ENUM sur `YYYYMMDD`, `YYYYMMDDHH`, `YYYYMM`, `MMYYYYDD` ou `DDMMYYYY`. La valeur par défaut est `YYYYMMDD`. Utilisez ce paramètre lorsque `DatePartitionEnabled` est défini sur `true.`.
+ `DatePartitionDelimiter` : spécifie un délimiteur de date à utiliser lors du partitionnement des dossiers. Définissez cette option ENUM sur `SLASH`, `DASH`, `UNDERSCORE` ou `NONE`. La valeur par défaut est `SLASH`. Utilisez ce paramètre lorsque `DatePartitionEnabled` est défini sur `true`.
+ `DatePartitionTimezone`— Lorsque vous créez un point de terminaison cible S3, configurez-le `DatePartitionTimezone` pour convertir l'heure UTC actuelle dans un fuseau horaire spécifié. La conversion a lieu lorsqu'un dossier de partition de dates est créé et qu'un nom de fichier CDC est généré. Le format du fuseau horaire est Zone/Lieu. Utilisez ce paramètre lorsqu'il `DatePartitionedEnabled` est défini sur`true`, comme indiqué dans l'exemple suivant :
```
s3-settings='{"DatePartitionEnabled": true, "DatePartitionSequence": "YYYYMMDDHH", "DatePartitionDelimiter": "SLASH", "DatePartitionTimezone":"Asia/Seoul", "BucketName": "dms-nattarat-test"}'
```
L’exemple suivant montre comment activer le partitionnement de dossiers basé sur la date, avec les valeurs par défaut pour la séquence de partition de données et le délimiteur. Il utilise l'`--s3-settings '{json-settings}'`option du AWS CLI. `create-endpoint`commande.
```
--s3-settings '{"DatePartitionEnabled": true,"DatePartitionSequence": "YYYYMMDD","DatePartitionDelimiter": "SLASH"}'
```
## Chargement parallèle de sources partitionnées lors de l'utilisation d'Amazon S3 comme cible pour AWS DMS
Vous pouvez configurer un chargement complet parallèle de sources de données partitionnées sur les cibles Amazon S3. Cette approche améliore les temps de chargement lors de la migration des données partitionnées à partir des moteurs de base de données source pris en charge vers la cible S3. Pour améliorer les temps de chargement des données sources partitionnées, vous créez des sous-dossiers cibles S3 mappés aux partitions de chaque table de la base de données source. Ces sous-dossiers liés à une partition permettent d' AWS DMS exécuter des processus parallèles pour remplir chaque sous-dossier de la cible.
Pour configurer le chargement complet parallèle d’une cible S3, S3 prend en charge trois types de règles `parallel-load` pour la règle `table-settings` de mappage de table :
+ `partitions-auto`
+ `partitions-list`
+ `ranges`
Pour plus d’informations sur ces types de règles de chargement parallèle, consultez [Règles des paramètres de table et de collection et opérations](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md).
Pour les types de règles `partitions-auto` et `partitions-list`, AWS DMS utilise le nom de chaque partition depuis le point de terminaison source pour identifier la structure des sous-dossiers cibles, comme suit.
```
bucket_name/bucket_folder/database_schema_name/table_name/partition_name/LOADseq_num.csv
```
Ici, le chemin du sous-dossier où les données sont migrées et stockées sur la cible S3 inclut un sous-dossier `partition_name` supplémentaire qui correspond à une partition source portant le même nom. Ce sous-dossier `partition_name` stocke ensuite un ou plusieurs fichiers `LOADseq_num.csv` contenant des données migrées depuis la partition source spécifiée. Ici, `seq_num` est le suffixe du numéro de séquence sur le nom du fichier .csv, comme `00000001` dans le fichier .csv portant le nom `LOAD00000001.csv`.
Cependant, certains moteurs de base de données, tels que MongoDB et DocumentDB, n’utilisent pas le concept de partitions. Pour ces moteurs de base de données, AWS DMS ajoute l'index du segment source en cours d'exécution en tant que préfixe au nom du fichier .csv cible, comme suit.
```
.../database_schema_name/table_name/SEGMENT1_LOAD00000001.csv
.../database_schema_name/table_name/SEGMENT1_LOAD00000002.csv
...
.../database_schema_name/table_name/SEGMENT2_LOAD00000009.csv
.../database_schema_name/table_name/SEGMENT3_LOAD0000000A.csv
```
Ici, les fichiers `SEGMENT1_LOAD00000001.csv` et `SEGMENT1_LOAD00000002.csv` sont nommés avec le même préfixe d’index de segment source en cours d’exécution, `SEGMENT1`. Ils portent ce nom, car les données sources migrées pour ces deux fichiers .csv sont associées au même index de segment source en cours d’exécution. D’autre part, les données migrées stockées dans chacun des fichiers cibles `SEGMENT2_LOAD00000009.csv` et `SEGMENT3_LOAD0000000A.csv` sont associées à différents index de segment source en cours d’exécution. Le nom de chaque fichier est préfixé avec le nom de son index de segment en cours d’exécution, `SEGMENT2` et `SEGMENT3`.
Pour le type de chargement parallèle `ranges`, vous définissez les noms et les valeurs de colonne à l’aide des paramètres `columns` et `boundaries` des règles `table-settings`. Avec ces règles, vous pouvez spécifier des partitions correspondant aux noms de segment, comme suit.
```
"parallel-load": {
"type": "ranges",
"columns": [
"region",
"sale"
],
"boundaries": [
[
"NORTH",
"1000"
],
[
"WEST",
"3000"
]
],
"segment-names": [
"custom_segment1",
"custom_segment2",
"custom_segment3"
]
}
```
Ici, le paramètre `segment-names` définit les noms de trois partitions pour migrer les données en parallèle sur la cible S3. Les données migrées sont chargées en parallèle et stockées dans des fichiers .csv sous les sous-dossiers de partition, comme suit.
```
.../database_schema_name/table_name/custom_segment1/LOAD[00000001...].csv
.../database_schema_name/table_name/custom_segment2/LOAD[00000001...].csv
.../database_schema_name/table_name/custom_segment3/LOAD[00000001...].csv
```
Ici, AWS DMS stocke une série de fichiers .csv dans chacun des trois sous-dossiers de partition. La série de fichiers .csv de chaque sous-dossier de partition est nommée de manière incrémentielle à partir de `LOAD00000001.csv` jusqu’à ce que toutes les données soient migrées.
Dans certains cas, il se peut que vous ne nommiez pas explicitement les sous-dossiers de partition pour un type de chargement parallèle `ranges` à l’aide du paramètre `segment-names`. Dans ce cas, AWS DMS applique la valeur par défaut qui consiste à créer chaque série de fichiers .csv dans son `table_name` sous-dossier. Ici, AWS DMS préfixe les noms de fichier de chaque série de fichiers .csv avec le nom de l’index du segment source en cours d’exécution, comme suit.
```
.../database_schema_name/table_name/SEGMENT1_LOAD[00000001...].csv
.../database_schema_name/table_name/SEGMENT2_LOAD[00000001...].csv
.../database_schema_name/table_name/SEGMENT3_LOAD[00000001...].csv
...
.../database_schema_name/table_name/SEGMENTZ_LOAD[00000001...].csv
```
## Paramètres du point de terminaison lors de l'utilisation d'Amazon S3 comme cible pour AWS DMS
Vous pouvez utiliser des paramètres de point de terminaison pour configurer la base de données cible Amazon S3 comme si vous utilisiez des attributs de connexion supplémentaires. Vous spécifiez les paramètres lorsque vous créez le point de terminaison cible à l'aide de la AWS DMS console ou à l'aide de la `create-endpoint` commande dans le [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/dms/index.html), avec la syntaxe `--s3-settings '{"EndpointSetting": "value", ...}'` JSON.
**Note**
DMS écrit les modifications dans les fichiers Parquet en fonction de l'ordre de validation de la base de données source, mais lors de la migration de plusieurs tables, l'ordre de transaction d'origine n'est pas conservé en raison du partitionnement au niveau de la table. Pour conserver les informations de séquence de transactions, configurez le paramètre du point de `TimestampColumnName` terminaison pour inclure l'horodatage de validation source pour chaque ligne, que vous pouvez ensuite utiliser lors du traitement en aval pour reconstruire la séquence de transaction d'origine. Contrairement au format CSV, qui propose ce `PreserveTransactions` paramètre, les fichiers Parquet gèrent les transactions différemment en raison de leur structure de stockage en colonnes, mais cette approche permet un suivi précis des temps de validation de la source, prend en charge la reconstruction des ordres de transaction après la migration et permet un traitement efficace des données tout en préservant la cohérence des données.
Les paramètres de point de terminaison que vous pouvez utiliser avec Amazon S3 en tant que cible sont indiqués dans le tableau suivant.
| **Option** | **Description** |
| --- | --- |
| CsvNullValue | Paramètre facultatif qui indique le mode de AWS DMS traitement des valeurs nulles. Lors de la gestion de la valeur null (nulle), vous pouvez utiliser ce paramètre pour transmettre une chaîne définie par l'utilisateur comme nulle lors de l'écriture sur la cible. Par exemple, lorsque les colonnes cibles peuvent être définies comme nulles (nullable), vous pouvez utiliser cette option pour différencier la valeur de chaîne vide de la valeur nulle. Valeur par défaut : `""` Valeurs valides : toutes les chaînes valides Exemple : `--s3-settings '{"CsvNullValue": "NULL"}'` Si la valeur de la colonne de la base de données source est nulle, dans le fichier CSV S3, la valeur de colonne est `NULL` au lieu de la chaîne « ». |
| AddColumnName | Paramètre facultatif qui lorsqu’il est défini sur `true` ou `y` vous permet d'ajouter les informations de nom de colonne dans le fichier de sortie .csv. Vous ne pouvez pas utiliser ce paramètre avec `PreserveTransactions` ou `CdcPath`. Valeur par défaut : `false` Valeurs valides : `true`, `false`, `y`, `n` Exemple : `--s3-settings '{"AddColumnName": true}'` |
| AddTrailingPaddingCharacter | Utilisez le paramètre de point de terminaison cible S3 `AddTrailingPaddingCharacter` pour ajouter un remplissage aux données de chaîne. La valeur par défaut est `false`. Type : Boolean Exemple : `--s3-settings '{"AddTrailingPaddingCharacter": true}'` |
| BucketFolder | Un paramètre facultatif pour définir le nom d'un dossier dans le compartiment S3. S'il est fourni, les objets cibles sont créés en tant que fichiers .csv ou .parquet dans le chemin `BucketFolder/schema_name/table_name/`. Si ce paramètre n'est pas spécifié, le chemin utilisé est `schema_name/table_name/`. Exemple : `--s3-settings '{"BucketFolder": "testFolder"}'` |
| BucketName | Nom du compartiment S3 dans lequel les objets cibles S3 sont créés en tant que fichiers .csv ou .parquet. Exemple : `--s3-settings '{"BucketName": "buckettest"}'` |
| CannedAclForObjects | Valeur qui permet de AWS DMS spécifier une liste de contrôle d'accès prédéfinie (prédéfinie) pour les objets créés dans le compartiment S3 sous forme de fichiers .csv ou .parquet. Pour plus d'informations sur le scan Amazon S3 ACLs, consultez la section [Caned ACL](https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl) dans le *manuel du développeur Amazon S3.* Valeur par défaut : NONE Les valeurs valides pour cet attribut sont : NONE ; PRIVATE ; PUBLIC\$1READ ; PUBLIC\$1READ\$1WRITE ; AUTHENTICATED\$1READ ; \$1READ ; BUCKET\$1OWNER\$1READ ; BUCKET\$1OWNER\$1FULL\$1CONTROL. AWS\$1EXEC Exemple : `--s3-settings '{"CannedAclForObjects": "PUBLIC_READ"}'` |
| CdcInsertsOnly | Paramètre facultatif lors d’une capture de données de modification (CDC) pour écrire uniquement des opérations INSERT dans les fichiers de sortie .csv (valeurs séparées par des virgules) ou .parquet (stockage en colonnes). Par défaut (le paramètre `false`), le premier champ d'un enregistrement .csv ou .parquet contient la lettre I (INSERT), U (UPDATE) ou D (DELETE). Cette lettre indique si la ligne a été insérée, mise à jour ou supprimée dans la base de données source pour une charge CDC vers la cible. S'il `cdcInsertsOnly` est défini sur `true` ou`y`, seuls les fichiers .csv ou .parquet sont migrés INSERTs depuis la base de données source. Pour le format .csv uniquement, l’enregistrement de de ces commandes INSERT dépend de la valeur de `IncludeOpForFullLoad`. Si `IncludeOpForFullLoad` est défini sur `true`, le premier champ de chaque enregistrement CDC est défini sur I pour indiquer l'opération INSERT à la source. Si `IncludeOpForFullLoad` est défini sur `false`, chaque enregistrement CDC est écrit sans premier champ pour indiquer l'opération INSERT à la source. Pour plus d'informations sur le fonctionnement de ces paramètres utilisés conjointement, consultez [Indication des opérations de base de données source dans des données S3 migrées](#CHAP_Target.S3.Configuring.InsertOps). Valeur par défaut : `false` Valeurs valides : `true`, `false`, `y`, `n` Exemple : `--s3-settings '{"CdcInsertsOnly": true}'` |
| CdcInsertsAndUpdates | Permet une charge CDC (Change Data Capture) pour écrire des opérations INSERT et UPDATE dans des fichiers de sortie .csv ou .parquet (stockage en colonnes). Le paramètre par défaut est`false`, mais quand `cdcInsertsAndUpdates` est défini sur `true` ou`y`, INSERTs et UPDATEs depuis la base de données source sont migrés vers le fichier .csv ou .parquet. Pour le format de fichier .csv uniquement, la manière dont UPDATEs ils sont enregistrés dépend de la valeur du `includeOpForFullLoad` paramètre. INSERTs Si la valeur `includeOpForFullLoad` est définie sur `true`, le premier champ de chaque enregistrement CDC est défini sur `I` ou `U` pour indiquer les opérations INSERT et UPDATE à la source. Mais si `includeOpForFullLoad` est défini sur `false`, les enregistrements CDC sont écrits sans indication des opérations INSERT ou UPDATE à la source. Pour plus d'informations sur le fonctionnement de ces paramètres utilisés conjointement, consultez [Indication des opérations de base de données source dans des données S3 migrées](#CHAP_Target.S3.Configuring.InsertOps). `CdcInsertsOnly` et `cdcInsertsAndUpdates` ne peuvent pas tous les deux être définis sur true pour le même point de terminaison. Définissez `cdcInsertsOnly` ou `cdcInsertsAndUpdates` sur `true` pour le même point de terminaison, mais pas les deux. Valeur par défaut : `false` Valeurs valides : `true`, `false`, `y`, `n` Exemple : `--s3-settings '{"CdcInsertsAndUpdates": true}'` |
| `CdcPath` | Spécifie le chemin du dossier des fichiers CDC. Pour une source S3, cet attribut est requis si une tâche capture les données modifiées. Dans le cas contraire, il est facultatif. Si `CdcPath` est défini, DMS lit les fichiers CDC à partir de ce chemin et réplique les modifications des données sur le point de terminaison cible. Pour une cible S3, si vous définissez `PreserveTransactions` sur true, DMS vérifie que vous avez défini ce paramètre sur un chemin de dossier de votre cible S3 où DMS peut enregistrer l’ordre des transactions pour le chargement CDC. DMS crée ce chemin de dossier CDC soit dans votre répertoire de travail cible S3, soit dans l’emplacement cible S3 spécifié par `BucketFolder` et `BucketName`. Vous ne pouvez pas utiliser ce paramètre avec `DatePartitionEnabled` ou `AddColumnName`. Type : Chaîne Par exemple, si vous définissez `CdcPath` sur `MyChangedData` et `BucketName` sur `MyTargetBucket`, mais que vous ne spécifiez pas `BucketFolder`, DMS crée le chemin du dossier CDC suivant : `MyTargetBucket/MyChangedData`. Si vous définissez la même valeur pour `CdcPath` et que vous définissez `BucketName` sur `MyTargetBucket` et `BucketFolder` sur `MyTargetData`, DMS crée le chemin du dossier CDC suivant : `MyTargetBucket/MyTargetData/MyChangedData`. Ce paramètre est pris en charge dans AWS DMS les versions 3.4.2 et supérieures. Lors de la capture des modifications de données dans l'ordre des transactions, DMS enregistre toujours les modifications de ligne dans des fichiers .csv, quelle que soit la valeur du paramètre DataFormat S3 sur la cible. |
| `CdcMaxBatchInterval` | Condition de durée maximale de l’intervalle, définie en secondes, à laquelle envoyer un fichier vers Amazon S3. Valeur par défaut : 60 secondes Lorsque `CdcMaxBatchInterval` et `CdcMinFileSize` sont spécifiés, l’écriture du fichier est déclenchée dès que l’une des conditions de paramètre est remplie. À partir de AWS DMS la version 3.5.3, lorsque vous utilisez PostgreSQL ou Aurora PostgreSQL comme source et Amazon S3 avec Parquet comme cible`confirmed_flush_lsn`, la fréquence des mises à jour dépend de la quantité de données que le point de terminaison cible est configuré pour conserver en mémoire. AWS DMS `confirmed_flush_lsn`renvoie le message à la source uniquement une fois que les données en mémoire ont été écrites sur Amazon S3. Si vous configurez le `CdcMaxBatchInterval` paramètre sur une valeur supérieure, vous pouvez observer une augmentation de l'utilisation des emplacements de réplication dans la base de données source. |
| `CdcMinFileSize` | Condition de taille minimale de fichier, définie en kilo-octets, à laquelle envoyer un fichier vers Amazon S3. Valeur par défaut : 32 000 Ko Lorsque `CdcMinFileSize` et `CdcMaxBatchInterval` sont spécifiés, l’écriture du fichier est déclenchée dès que l’une des conditions de paramètre est remplie. |
| `PreserveTransactions` | Lorsque la valeur est `true`, DMS enregistre l’ordre des transactions pour une capture des données de modification (CDC) sur la cible Amazon S3 spécifiée par `CdcPath`. Vous ne pouvez pas utiliser ce paramètre avec `DatePartitionEnabled` ou `AddColumnName`. Type : Boolean Lors de la capture des modifications de données dans l'ordre des transactions, DMS enregistre toujours les modifications de ligne dans des fichiers .csv, quelle que soit la valeur du paramètre DataFormat S3 sur la cible. Ce paramètre est pris en charge dans AWS DMS les versions 3.4.2 et supérieures. |
| IncludeOpForFullLoad | Paramètre facultatif lors d’un chargement complet pour écrire les opérations INSERT dans les fichiers de sortie .csv (valeurs séparées par des virgules) uniquement. Pour le chargement complet, les enregistrements peuvent être insérés uniquement. Par défaut (paramètre `false`), avec un chargement complet, aucune information n’est enregistrée dans ces fichiers de sortie pour indiquer que les lignes ont été ajoutées à la base de données source. Si `IncludeOpForFullLoad` est défini sur `true` ou `y`, l’opération INSERT est enregistrée en tant que annotation I dans le premier champ du fichier .csv. Ce paramètre fonctionne conjointement avec `CdcInsertsOnly` ou `CdcInsertsAndUpdates` pour une sortie dans des fichiers .csv uniquement. Pour plus d'informations sur le fonctionnement de ces paramètres utilisés conjointement, consultez [Indication des opérations de base de données source dans des données S3 migrées](#CHAP_Target.S3.Configuring.InsertOps). Valeur par défaut : `false` Valeurs valides : `true`, `false`, `y`, `n` Exemple : `--s3-settings '{"IncludeOpForFullLoad": true}'` |
| CompressionType | Paramètre facultatif lorsqu'il est défini sur `GZIP` utilise GZIP pour compresser les fichiers .csv cibles. Lorsque ce paramètre est défini sur la valeur par défaut, les fichiers demeurent non compressés. Valeur par défaut : `NONE` Valeurs valides : `GZIP` ou `NONE` Exemple : `--s3-settings '{"CompressionType": "GZIP"}'` |
| CsvDelimiter | Délimiteur utilisé pour séparer les colonnes des fichiers sources .csv. La valeur par défaut est une virgule (,). Exemple : `--s3-settings '{"CsvDelimiter": ","}'` |
| CsvRowDelimiter | Délimiteur utilisé pour séparer les lignes des fichiers sources .csv. La valeur par défaut est un caractère de saut de ligne (\$1 n). Exemple : `--s3-settings '{"CsvRowDelimiter": "\n"}'` |
| `MaxFileSize` | Une valeur qui spécifie la taille maximale (en Ko) des fichiers .csv à créer lors de la migration vers une cible S3 pendant le chargement complet. Valeur par défaut : 1 048 576 Ko (1 Go) Valeurs valides : 1 à 1 048 576 Exemple : `--s3-settings '{"MaxFileSize": 512}'` |
| Rfc4180 | Paramètre facultatif utilisé pour définir le comportement afin de se conformer à RFC pour les données migrées vers Amazon S3 à l’aide du format de fichier .csv uniquement. Lorsque cette valeur est définie sur `true` ou `y` en utilisant Amazon S3 comme cible, si les données contiennent des guillemets, des virgules ou des caractères de nouvelle ligne, AWS DMS la colonne entière est entourée d'une paire supplémentaire de guillemets doubles («). Chaque point d'interrogation contenu dans les données est répété deux fois. Ce format est conforme à RFC 4180. Valeur par défaut : `true` Valeurs valides : `true`, `false`, `y`, `n` Exemple : `--s3-settings '{"Rfc4180": false}'` |
| EncryptionMode | Mode de chiffrement côté serveur que vous souhaitez utiliser pour chiffrer vos fichiers d'objets .csv ou .parquet copiés dans S3. Les valeurs valides sont `SSE_S3` (chiffrement côté serveur S3) ou `SSE_KMS` (chiffrement de clé KMS). Si vous choisissez `SSE_KMS`, définissez le paramètre `ServerSideEncryptionKmsKeyId` sur l'Amazon Resource Name (ARN) de la clé KMS à utiliser pour le chiffrement. Vous pouvez également utiliser la commande CLI `modify-endpoint` pour modifier la valeur de l’attribut `EncryptionMode` d’un point de terminaison existant de `SSE_KMS` à `SSE_S3`. Vous ne pouvez pas modifier la valeur `EncryptionMode` de `SSE_S3` à `SSE_KMS`. Valeur par défaut : `SSE_S3` Valeurs valides : `SSE_S3` ou `SSE_KMS` Exemple : `--s3-settings '{"EncryptionMode": SSE_S3}'` |
| ServerSideEncryptionKmsKeyId | Si vous définissez `EncryptionMode` sur `SSE_KMS`, définissez ce paramètre sur l’Amazon Resource Name (ARN) de la clé KMS. Vous pouvez trouver cet ARN en sélectionnant l'alias de clé dans la liste des AWS KMS clés créées pour votre compte. Lorsque vous créez la clé, vous devez associer les stratégies et les rôles spécifiques associés à cette clé KMS. Pour de plus amples informations, veuillez consulter [Création de AWS KMS clés pour chiffrer les objets cibles d'Amazon S3](#CHAP_Target.S3.KMSKeys). Exemple : `--s3-settings '{"ServerSideEncryptionKmsKeyId":"arn:aws:kms:us-east-1:111122223333:key/11a1a1a1-aaaa-9999-abab-2bbbbbb222a2"}'` |
| DataFormat | Format de sortie des fichiers AWS DMS utilisés pour créer des objets S3. Pour les cibles Amazon S3, AWS DMS prend en charge les fichiers .csv ou .parquet. Les fichiers .parquet ont un format de stockage par colonnes binaire avec des options de compression efficaces et des performances de requête plus rapides. Pour plus d'informations sur les fichiers .parquet, consultez [https://parquet.apache.org/](https://parquet.apache.org/). Valeur par défaut : `csv` Valeurs valides : `csv` ou `parquet` Exemple : `--s3-settings '{"DataFormat": "parquet"}'` |
| EncodingType | Type d'encodage Parquet. Parmi les options de type d'encodage, on trouve : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/dms/latest/userguide/CHAP_Target.S3.html) Valeur par défaut : `rle-dictionary` Valeurs valides : `rle-dictionary`, `plain` ou `plain-dictionary` Exemple : `--s3-settings '{"EncodingType": "plain-dictionary"}'` |
| DictPageSizeLimit | Taille maximale autorisée, en octets, pour une page de dictionnaire dans un fichier .parquet. Si une page de dictionnaire dépasse cette valeur, elle utilise l'encodage brut. Valeur par défaut : 1 024 000 (1 Mo) Valeurs valides : Toute valeur entière valide Exemple : `--s3-settings '{"DictPageSizeLimit": 2,048,000}'` |
| RowGroupLength | Nombre de lignes dans un groupe de lignes d'un fichier .parquet. Valeur par défaut : 10 024 (10 Ko) Valeurs valides : tout entier valide Exemple : `--s3-settings '{"RowGroupLength": 20,048}'` |
| DataPageSize | Taille maximale autorisée, en octets, pour une page de données dans un fichier .parquet. Valeur par défaut : 1 024 000 (1 Mo) Valeurs valides : tout entier valide Exemple : `--s3-settings '{"DataPageSize": 2,048,000}'` |
| ParquetVersion | Version du format de fichier .parquet. Valeur par défaut : `PARQUET_1_0` Valeurs valides : `PARQUET_1_0` ou `PARQUET_2_0` Exemple : `--s3-settings '{"ParquetVersion": "PARQUET_2_0"}'` |
| EnableStatistics | Définissez ce paramètre sur `true` ou `y` pour activer les statistiques sur les pages et les groupes de lignes des fichiers .parquet. Valeur par défaut : `true` Valeurs valides : `true`, `false`, `y`, `n` Exemple : `--s3-settings '{"EnableStatistics": false}'` |
| TimestampColumnName | Paramètre facultatif permettant d’inclure une colonne d'horodatage dans les données de point de terminaison cible S3. AWS DMS inclut une `STRING` colonne supplémentaire dans les fichiers objets .csv ou .parquet de vos données migrées lorsque vous définissez `TimestampColumnName` une valeur non vide. Pour un chargement complet, chaque ligne de cette colonne d'horodatage contient une valeur d’horodatage correspondant au moment où les données ont été transférées de la source vers la cible par DMS. Pour un chargement CDC, chaque ligne de la colonne d'horodatage contient la valeur d'horodatage correspondant au moment de la validation de cette ligne dans la base de données source. Le format chaîne pour la valeur de cette colonne d'horodatage est `yyyy-MM-dd HH:mm:ss.SSSSSS`. Par défaut, la précision de cette valeur est en microsecondes. Pour un chargement de CDC, l'arrondi de la précision dépend de l’horodatage de validation pris en charge par DMS pour la base de données source. Lorsque le paramètre `AddColumnName` est défini sur `true`, DMS inclut également le nom de la colonne d’horodatage que vous définissez en tant que valeur non vide pour `TimestampColumnName`. Exemple : `--s3-settings '{"TimestampColumnName": "TIMESTAMP"}'` |
| UseTaskStartTimeForFullLoadTimestamp | Lorsqu’il est défini sur `true`, ce paramètre utilise l’heure de début de la tâche comme valeur de colonne d’horodatage au lieu de l’heure à laquelle les données sont écrites dans la cible. Pour un chargement complet, lorsque `UseTaskStartTimeForFullLoadTimestamp` est défini sur `true`, chaque ligne de la colonne d'horodatage contient l'heure de début de la tâche. Pour les chargements CDC, chaque ligne de la colonne d'horodatage contient l'heure de validation de la transaction. Lorsque `UseTaskStartTimeForFullLoadTimestamp` est défini sur `false`, l'horodatage de chargement complet dans la colonne d'horodatage augmente avec l'heure à laquelle les données arrivent sur la cible. Valeur par défaut : `false` Valeurs valides : `true`, `false` Exemple : `--s3-settings '{"UseTaskStartTimeForFullLoadTimestamp": true}'` `UseTaskStartTimeForFullLoadTimestamp: true` fait en sorte que la colonne `TimestampColumnName` de la cible S3 pour un chargement complet puisse être triée avec `TimestampColumnName` pour un chargement CDC. |
| ParquetTimestampInMillisecond | Paramètre facultatif qui spécifie la précision des valeurs de colonne `TIMESTAMP` écrites dans un fichier d'objet S3 au format .parquet. Lorsque cet attribut est défini sur `true` ou`y`, AWS DMS écrit toutes les `TIMESTAMP` colonnes dans un fichier au format .parquet avec une précision de la milliseconde. Sinon, DMS les écrit avec une précision à la microseconde. Actuellement, Amazon Athena et ne AWS Glue peut gérer que des millisecondes de précision pour les valeurs. `TIMESTAMP` Définissez cet attribut sur true pour les fichiers d’objet de point de terminaison S3 au format .parquet uniquement si vous prévoyez d’interroger ou de traiter les données avec Athena ou AWS Glue. AWS DMS écrit toutes les valeurs de `TIMESTAMP` colonne écrites dans un fichier S3 au format .csv avec une précision de la microseconde. La valeur de cet attribut n'a aucun effet sur le format chaîne de la valeur de colonne d'horodatage insérée en définissant l'attribut `TimestampColumnName`. Valeur par défaut : `false` Valeurs valides : `true`, `false`, `y`, `n` Exemple : `--s3-settings '{"ParquetTimestampInMillisecond": true}'` |
| GlueCatalogGeneration | Pour générer un AWS Glue Data Catalog, définissez ce paramètre de point de terminaison sur`true`. Valeur par défaut : `false` Valeurs valides : `true`, `false` Exemple : `--s3-settings '{"GlueCatalogGeneration": true}'` **Remarque :** n’utilisez pas `GlueCatalogGeneration` avec `PreserveTransactions` et `CdcPath`. |
## Utilisation AWS Glue Data Catalog avec une cible Amazon S3 pour AWS DMS
AWS Glue est un service qui fournit des méthodes simples pour classer les données et consiste en un référentiel de métadonnées appelé AWS Glue Data Catalog. Vous pouvez intégrer AWS Glue Data Catalog votre point de terminaison cible Amazon S3 et interroger les données Amazon S3 via d'autres AWS services tels qu'Amazon Athena. Amazon Redshift fonctionne avec cette option AWS Glue prédéfinie, mais AWS DMS ne la prend pas en charge.
Pour générer le catalogue de données, définissez le paramètre du point de `GlueCatalogGeneration` terminaison sur`true`, comme indiqué dans l' AWS CLI exemple suivant.
```
aws dms create-endpoint --endpoint-identifier s3-target-endpoint
--engine-name s3 --endpoint-type target--s3-settings '{"ServiceAccessRoleArn":
"your-service-access-ARN", "BucketFolder": "your-bucket-folder", "BucketName":
"your-bucket-name", "DataFormat": "parquet", "GlueCatalogGeneration": true}'
```
Pour une tâche de réplication à chargement complet incluant le type de données `csv`, définissez `IncludeOpForFullLoad` sur `true`.
N’utilisez pas `GlueCatalogGeneration` avec `PreserveTransactions` et `CdcPath`. Le AWS Glue robot d'exploration ne parvient pas à concilier les différents schémas des fichiers stockés sous le paramètre spécifié. `CdcPath`
Pour qu’Amazon Athena puisse indexer vos données Amazon S3 et pour que vous puissiez interroger vos données à l’aide de requêtes SQL standard via Amazon Athena, le rôle IAM attaché au point de terminaison doit posséder la politique suivante :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetBucketLocation",
"s3:GetObject",
"s3:ListBucket",
"s3:ListBucketMultipartUploads",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": [
"arn:aws:s3:::bucket123",
"arn:aws:s3:::bucket123/*"
]
},
{
"Effect": "Allow",
"Action": [
"glue:CreateDatabase",
"glue:GetDatabase",
"glue:CreateTable",
"glue:DeleteTable",
"glue:UpdateTable",
"glue:GetTable",
"glue:BatchCreatePartition",
"glue:CreatePartition",
"glue:UpdatePartition",
"glue:GetPartition",
"glue:GetPartitions",
"glue:BatchGetPartition"
],
"Resource": [
"arn:aws:glue:*:111122223333:catalog",
"arn:aws:glue:*:111122223333:database/*",
"arn:aws:glue:*:111122223333:table/*"
]
},
{
"Effect": "Allow",
"Action": [
"athena:StartQueryExecution",
"athena:GetQueryExecution",
"athena:CreateWorkGroup"
],
"Resource": "arn:aws:athena:*:111122223333:workgroup/glue_catalog_generation_for_task_*"
}
]
}
```
------
**Références**
+ Pour plus d'informations AWS Glue, consultez la section [Concepts](https://docs.aws.amazon.com//glue/latest/dg/components-key-concepts.html) du *guide du AWS Glue développeur*.
+ Pour plus d'informations sur la AWS Glue Data Catalog section [Composants](https://docs.aws.amazon.com/glue/latest/dg/components-overview.html) du *Guide du AWS Glue développeur*.
## Utilisation du chiffrement des données, des fichiers Parquet et de la CDC sur votre cible Amazon S3
Vous pouvez utiliser les paramètres de point de terminaison cible S3 pour configurer les éléments suivants :
+ Une clé KMS personnalisée pour chiffrer vos objets cibles S3.
+ Des fichiers Parquet comme format de stockage pour les objets cibles S3.
+ La capture des données de modification (CDC) avec l’ordre des transactions sur la cible S3.
+ AWS Glue Data Catalog Intégrez votre point de terminaison cible Amazon S3 et interrogez les données Amazon S3 via d'autres services tels qu'Amazon Athena.
### AWS KMS paramètres clés pour le chiffrement des données
Les exemples suivants illustrent la configuration d'une clé KMS personnalisée pour chiffrer vos objets cibles S3. Pour commencer, vous pouvez exécuter la commande CLI `create-endpoint` suivante.
```
aws dms create-endpoint --endpoint-identifier s3-target-endpoint --engine-name s3 --endpoint-type target
--s3-settings '{"ServiceAccessRoleArn": "your-service-access-ARN", "CsvRowDelimiter": "\n",
"CsvDelimiter": ",", "BucketFolder": "your-bucket-folder",
"BucketName": "your-bucket-name",
"EncryptionMode": "SSE_KMS",
"ServerSideEncryptionKmsKeyId": "arn:aws:kms:us-east-1:111122223333:key/72abb6fb-1e49-4ac1-9aed-c803dfcc0480"}'
```
Ici, l'objet JSON spécifié par l'option `--s3-settings` définit deux paramètres. Le premier est le paramètre `EncryptionMode` avec la valeur `SSE_KMS`. L'autre est un paramètre `ServerSideEncryptionKmsKeyId` avec la valeur `arn:aws:kms:us-east-1:111122223333:key/72abb6fb-1e49-4ac1-9aed-c803dfcc0480`. Cette valeur est un Amazon Resource Name (ARN) pour votre clé KMS personnalisée. Pour une cible S3, vous spécifiez également des paramètres supplémentaires. Ces paramètres identifient le rôle d'accès au serveur, fournissent des délimiteurs pour le format de stockage d'objet CSV par défaut et attribuent l'emplacement et le nom du compartiment pour stocker les objets cibles S3.
Par défaut, le chiffrement de données S3 a lieu à l’aide du chiffrement côté serveur S3. Pour la cible S3 de l'exemple précédent, cela équivaut à spécifier ses paramètres de point de terminaison, comme dans l'exemple suivant.
```
aws dms create-endpoint --endpoint-identifier s3-target-endpoint --engine-name s3 --endpoint-type target
--s3-settings '{"ServiceAccessRoleArn": "your-service-access-ARN", "CsvRowDelimiter": "\n",
"CsvDelimiter": ",", "BucketFolder": "your-bucket-folder",
"BucketName": "your-bucket-name",
"EncryptionMode": "SSE_S3"}'
```
Pour de plus amples informations sur l’utilisation du chiffrement côté serveur S3, veuillez consulter [Protection des données à l'aide du chiffrement côté serveur](https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html).
**Note**
Vous pouvez également utiliser la commande CLI `modify-endpoint` pour modifier la valeur du paramètre `EncryptionMode` d’un point de terminaison existant de `SSE_KMS` à `SSE_S3`. Vous ne pouvez pas modifier la valeur `EncryptionMode` de `SSE_S3` à `SSE_KMS`.
### Paramètres pour l'utilisation de fichiers .parquet en vue du stockage d'objets cibles S3
Le format par défaut pour la création d'objets cibles S3 est le fichier .csv. Les exemples suivants illustrent certains paramètres de point de terminaison pour spécifier des fichiers .parquet comme format de création d'objets cibles S3. Vous pouvez spécifier le format des fichiers .parquet avec toutes les valeurs par défaut, comme dans l'exemple suivant.
```
aws dms create-endpoint --endpoint-identifier s3-target-endpoint --engine-name s3 --endpoint-type target
--s3-settings '{"ServiceAccessRoleArn": "your-service-access-ARN", "DataFormat": "parquet"}'
```
Ici, le paramètre `DataFormat` est défini sur `parquet` pour activer le format avec toutes les valeurs par défaut de S3. Ces valeurs par défaut comprennent un encodage par dictionnaire (`"EncodingType: "rle-dictionary"`) qui utilise une combinaison d'encodage par compression de bits et longueur d'exécution pour stocker de manière plus efficace les valeurs répétitives.
Vous pouvez ajouter des paramètres supplémentaires pour les options autres que les valeurs par défaut, comme dans l'exemple suivant.
```
aws dms create-endpoint --endpoint-identifier s3-target-endpoint --engine-name s3 --endpoint-type target
--s3-settings '{"ServiceAccessRoleArn": "your-service-access-ARN", "BucketFolder": "your-bucket-folder",
"BucketName": "your-bucket-name", "DataFormat": "parquet", "EncodingType: "plain-dictionary", "DictPageSizeLimit": 3,072,000,
"EnableStatistics": false }'
```
Ici, en plus des paramètres requis pour plusieurs options de compartiment S3 standard et le paramètre `DataFormat`, les paramètres de fichier .parquet supplémentaires suivants sont définis :
+ `EncodingType` : permet de définir un encodage par dictionnaire (`plain-dictionary`) qui stocke les valeurs rencontrées dans chaque colonne dans un bloc par colonne de la page de dictionnaire.
+ `DictPageSizeLimit` : permet de définir une taille de page de dictionnaire de 3 Mo maximum.
+ `EnableStatistics` : désactive la valeur par défaut qui permet la collecte des statistiques sur les pages et les groupes de lignes du fichier Parquet.
### Capture des données de modification (CDC) avec l’ordre des transactions sur la cible S3
Par défaut, lors de l' AWS DMS exécution d'une tâche CDC, elle stocke toutes les modifications de ligne enregistrées dans votre base de données source (ou vos bases de données) dans un ou plusieurs fichiers pour chaque table. Chaque ensemble de fichiers contenant des modifications pour la même table réside dans un répertoire cible unique associé à cette table. AWS DMS crée autant de répertoires cibles que de tables de base de données migrées vers le point de terminaison cible Amazon S3. Les fichiers sont stockés sur la cible S3 dans ces répertoires sans tenir compte de l’ordre des transactions. Pour plus d’informations sur les conventions de dénomination des fichiers, le contenu des données et le format, consultez [Utiliser Amazon S3 comme cible pour AWS Database Migration Service](#CHAP_Target.S3).
Pour capturer les modifications de la base de données source d'une manière qui capture également l'ordre des transactions, vous pouvez spécifier des paramètres de point de terminaison S3 qui indiquent AWS DMS de stocker les modifications de ligne pour *toutes les* tables de base de données dans un ou plusieurs fichiers .csv créés en fonction de la taille de la transaction. Ces *fichiers de transaction* .csv contiennent toutes les modifications de ligne répertoriées séquentiellement dans l’ordre des transactions pour toutes les tables impliquées dans chaque transaction. Ces fichiers de transaction résident ensemble dans un *répertoire de transactions* unique que vous spécifiez également sur la cible S3. Dans chaque fichier de transaction, l’opération de transaction et l’identité de la base de données et de la table source pour chaque modification de ligne sont stockées dans le cadre des données de ligne, comme suit.
```
operation,table_name,database_schema_name,field_value,...
```
Ici, `operation` est l’opération de transaction sur la ligne modifiée, `table_name` est le nom de la table de base de données où la ligne est modifiée, `database_schema_name` est le nom du schéma de base de données dans lequel se trouve la table et `field_value` est la première d’une ou de plusieurs valeurs de champ qui spécifient les données de la ligne.
L’exemple suivant d’un fichier de transaction illustre les lignes modifiées pour une ou plusieurs transactions impliquant deux tables.
```
I,Names_03cdcad11a,rdsTempsdb,13,Daniel
U,Names_03cdcad11a,rdsTempsdb,23,Kathy
D,Names_03cdcad11a,rdsTempsdb,13,Cathy
I,Names_6d152ce62d,rdsTempsdb,15,Jane
I,Names_6d152ce62d,rdsTempsdb,24,Chris
I,Names_03cdcad11a,rdsTempsdb,16,Mike
```
Ici, l’opération de transaction sur chaque ligne est indiquée par `I` (insérer), `U` (mettre à jour) ou `D` (supprimer) dans la première colonne. Le nom de la table est la valeur de la deuxième colonne (par exemple, `Names_03cdcad11a`). Le nom du schéma de base de données est la valeur de la troisième colonne (par exemple, `rdsTempsdb`). Et les colonnes restantes sont remplies avec vos propres données de ligne (par exemple, `13,Daniel`).
En outre, AWS DMS nomme les fichiers de transaction qu'il crée sur la cible Amazon S3 à l'aide d'un horodatage conformément à la convention de dénomination suivante.
```
CDC_TXN-timestamp.csv
```
Ici, `timestamp` est l’heure à laquelle le fichier de transaction a été créé, comme dans l’exemple suivant.
```
CDC_TXN-20201117153046033.csv
```
Cet horodatage dans le nom du fichier garantit que les fichiers de transaction sont créés et répertoriés dans l’ordre des transactions lorsque vous les répertoriez dans leur répertoire de transactions.
**Note**
Lorsque vous capturez des modifications de données dans l'ordre des transactions, les modifications de ligne sont AWS DMS toujours enregistrées dans des fichiers .csv, quelle que soit la valeur du paramètre `DataFormat` S3 sur la cible.
Pour contrôler la fréquence des écritures sur une cible Amazon S3 lors d’une tâche de réplication de données, vous pouvez configurer les paramètres `CdcMaxBatchInterval` et `CdcMinFileSize`. Cela peut améliorer les performances lors de l’analyse des données sans aucune surcharge supplémentaire. Pour de plus amples informations, consultez [Paramètres du point de terminaison lors de l'utilisation d'Amazon S3 comme cible pour AWS DMS](#CHAP_Target.S3.Configuring).
**Pour indiquer AWS DMS de stocker toutes les modifications de ligne dans l'ordre de transaction**
1. Définissez le paramètre S3 `PreserveTransactions` sur la cible sur `true`.
1. Définissez le paramètre `CdcPath` S3 sur la cible sur un chemin de dossier relatif dans lequel vous AWS DMS souhaitez stocker les fichiers de transaction .csv.
AWS DMS crée ce chemin soit sous le compartiment cible et le répertoire de travail S3 par défaut, soit sous le compartiment et le dossier de compartiments que vous spécifiez à l'aide des paramètres `BucketName` et `BucketFolder` S3 sur la cible.
## Indication des opérations de base de données source dans des données S3 migrées
Lors de AWS DMS la migration d'enregistrements vers une cible S3, il est possible de créer un champ supplémentaire dans chaque enregistrement migré. Ce champ supplémentaire indique l'opération appliquée à l'enregistrement au niveau de la base de données source. AWS DMS Le mode de création et de définition de ce premier champ dépend du type de tâche de migration et des paramètres de `includeOpForFullLoad``cdcInsertsOnly`, et`cdcInsertsAndUpdates`.
Pour un chargement complet, lorsque la valeur de `includeOpForFullLoad` est `true`, AWS DMS crée toujours un premier champ supplémentaire dans chaque enregistrement .csv. Ce champ contient la lettre I (INSERT) pour indiquer que la ligne a été insérée au niveau de la base de données source. Pour un chargement CDC, quand `cdcInsertsOnly` est `false` (valeur par défaut), crée AWS DMS également toujours un premier champ supplémentaire dans chaque enregistrement .csv ou .parquet. Ce champ contient la lettre I (INSERT), U (UPDATE) ou D (DELETE) pour indiquer si la ligne a été insérée, mise à jour ou supprimée au niveau de la base de données source.
Dans le tableau suivant, vous pouvez voir comment les paramètres des attributs `includeOpForFullLoad` et `cdcInsertsOnly` fonctionnent ensemble pour modifier la configuration des enregistrements migrés.
| Avec ces valeurs de paramètres | DMS définit les enregistrements cibles comme suit pour la sortie .csv et .parquet | includeOpForFullLoad | cdcInsertsOnly | Pour un chargement complet | Pour un chargement CDC |
| --- | --- | --- | --- | --- | --- |
| true | true | Ajout de la valeur du premier champ définie sur I | Ajout de la valeur du premier champ définie sur I |
| false | false | Aucun champ ajoutée | Ajout de la valeur du premier champ définie définie sur I, U ou D |
| false | true | Aucun champ ajoutée | Aucun champ ajoutée |
| true | false | Ajout de la valeur du premier champ définie sur I | Ajout de la valeur du premier champ définie définie sur I, U ou D |
Lorsque `includeOpForFullLoad` et `cdcInsertsOnly` sont définis sur la même valeur, les enregistrements cibles sont définis en fonction de l'attribut qui contrôle les paramètres d'enregistrement pour le type de migration actuel. Cet attribut est `includeOpForFullLoad` pour les chargements complets et `cdcInsertsOnly` pour les chargements CDC.
Lorsque `includeOpForFullLoad` et `cdcInsertsOnly` sont définis sur des valeurs différentes, les paramètres AWS DMS d'enregistrement cible sont cohérents à la fois pour le CDC et pour le chargement complet. Pour ce faire, il met en conformité les paramètres d’enregistrement pour un chargement CDC avec ceux du chargement complet précédent spécifié par `includeOpForFullLoad`.
En d'autres termes, supposons qu'un chargement complet soit défini de façon à ajouter un premier champ pour indiquer un enregistrement inséré. Dans ce cas, un chargement CDC suivant est défini de façon à ajouter un premier champ qui indique un enregistrement inséré, mis à jour ou supprimé (selon l'enregistrement au niveau de la source). En revanche, supposons qu'un chargement complet soit défini de façon à *ne pas* ajouter un premier champ pour indiquer un enregistrement inséré. Dans ce cas, un chargement CDC est également défini de façon à ne pas ajouter un premier champ pour chaque enregistrement, quelle que soit l’opération d’enregistrement correspondante au niveau de la source.
De même, la façon dont DMS crée et définit un premier champ supplémentaire dépend des paramètres de `includeOpForFullLoad` et `cdcInsertsAndUpdates`. Dans le tableau suivant, vous pouvez voir comment les paramètres des attributs `includeOpForFullLoad` et `cdcInsertsAndUpdates` fonctionnent ensemble pour modifier la configuration des enregistrements migrés sous ce format.
| Avec ces valeurs de paramètres | DMS définit les enregistrements cibles comme suit pour la sortie .csv | includeOpForFullLoad | cdcInsertsAndmises à jour | Pour un chargement complet | Pour un chargement CDC |
| --- | --- | --- | --- | --- | --- |
| true | true | Ajout de la valeur du premier champ définie sur I | Ajout de la valeur du premier champ définie sur I ou U |
| false | false | Aucun champ ajoutée | Ajout de la valeur du premier champ définie définie sur I, U ou D |
| false | true | Aucun champ ajoutée | Ajout de la valeur du premier champ définie sur I ou U |
| true | false | Ajout de la valeur du premier champ définie sur I | Ajout de la valeur du premier champ définie définie sur I, U ou D |
## Types de données cibles pour S3 Parquet
Le tableau suivant indique les types de données cibles Parquet pris en charge lors de l'utilisation AWS DMS et le mappage par défaut à partir AWS DMS des types de données.
Pour plus d'informations sur AWS DMS les types de données, consultez[Types de données pour AWS Database Migration Service](CHAP_Reference.DataTypes.md).
| AWS DMS type de données | fType de données S3 Parquet |
| --- | --- |
| BYTES | BINARY |
| DATE | DATE32 |
| TIME | TIME32 |
| DATETIME | TIMESTAMP |
| INT1 | INT8 |
| INT2 | INT16 |
| INT4 | INT32 |
| INT8 | INT64 |
| NUMERIC | DECIMAL |
| REAL4 | FLOAT |
| REAL8 | DOUBLE |
| STRING | STRING |
| UINT1 | UINT8 |
| UINT2 | UINT16 |
| UINT4 | UINT32 |
| UINT8 | UINT64 |
| WSTRING | STRING |
| BLOB | BINARY |
| NCLOB | STRING |
| CLOB | STRING |
| BOOLEAN | BOOL |