Utilisation de MongoDB comme source pour AWS DMS

Pour en savoir plus sur les versions de MongoDB qui sont prises en charge par AWS DMS en tant que source, consultez Sources pour AWS DMS.

Notez les éléments suivants concernant la prise en charge des versions de MongoDB :

Si vous n'êtes pas encore familiarisé avec MongoDB, soyez conscient des concepts importants suivants relatifs aux bases de données MongoDB :

AWS DMS prend en charge deux modes de migration lorsque MongoDB est utilisé en tant que source : le mode document ou le mode table. Vous spécifiez le mode de migration à utiliser lorsque vous créez le point de terminaison MongoDB ou en définissant le paramètre Mode métadonnées à partir de la console AWS DMS. Vous pouvez éventuellement créer une deuxième colonne nommée _id qui fait office de clé primaire en cochant la case _id en tant que colonne séparée dans le panneau de configuration du point de terminaison.

Le mode de migration que vous choisissez affecte le format résultant des données cibles, comme indiqué ci-après.

Autorisations nécessaires lors de l'utilisation de MongoDB comme source pour AWS DMS

Pour une migration AWS DMS avec une source MongoDB, vous pouvez créer un compte utilisateur avec des privilèges racine ou un utilisateur avec des autorisations uniquement sur la base de données à migrer.

Le code suivant permet de créer un utilisateur qui sera le compte racine.

use admin
db.createUser(
  {
    user: "root",
    pwd: "password",
    roles: [ { role: "root", db: "admin" } ]
  }
)

Pour une source MongoDB 3.x, le code suivant permet de créer un utilisateur avec des autorisations minimales sur la base de données à migrer.

use database_to_migrate
db.createUser( 
{ 
    user: "dms-user",
    pwd: "password",
    roles: [ { role: "read", db: "local" }, "read"] 
})

Pour une source MongoDB 4.x, le code suivant permet de créer un utilisateur avec des privilèges minimum.

{ resource: { db: "", collection: "" }, actions: [ "find", "changeStream" ] }

Par exemple, créez le rôle suivant dans la base de données « admin ».

use admin
db.createRole(
{
role: "changestreamrole",
privileges: [
{ resource: { db: "", collection: "" }, actions: [ "find","changeStream" ] }
],
roles: []
}
)

Une fois le rôle créé, créez un utilisateur dans la base de données à migrer.

> use test
> db.createUser( 
{ 
user: "dms-user12345",
pwd: "password",
roles: [ { role: "changestreamrole", db: "admin" }, "read"] 
})

Configuration d'un ensemble de réplicas MongoDB pour la CDC

Pour utiliser la réplication continue ou la CDC avec MongoDB, AWS DMS a besoin d'accéder au journal des opérations MongoDB (oplog). Pour créer le journal oplog, vous devez déployer un ensemble de réplicas, s'il n'en existe pas encore. Pour obtenir plus d'informations, consultez la documentation MongoDB.

Vous pouvez utiliser la capture des données modifiées (CDC) avec le nœud principal ou secondaire d'un ensemble de réplicas MongoDB comme point de terminaison source.

Si vous prévoyez d'effectuer une migration en mode document, sélectionnez l'option _id as a separate column lors de la création du point de terminaison MongoDB. La sélection de cette option permet de créer une seconde colonne nommée _id, qui agit en tant que clé primaire. Cette deuxième colonne est nécessaire pour qu'AWS DMS puisse prendre en charge les opérations de langage de manipulation de données (DML).

Exigences de sécurité lors de l'utilisation de MongoDB comme source pour AWS DMS

AWS DMS prend en charge deux méthodes d'authentification pour MongoDB. Les deux méthodes d'authentification sont utilisées pour chiffrer le mot de passe. Elles sont donc utilisées uniquement lorsque le paramètre authType est défini sur PASSWORD.

Les méthodes d'authentification MongoDB sont les suivantes :

Si aucune méthode d'authentification n'est spécifiée, AWS DMS utilise la méthode par défaut pour la version de la source MongoDB.

Segmentation des collections MongoDB et migration en parallèle

Pour améliorer les performances d'une tâche de migration, les points de terminaison source MongoDB prennent en charge deux options de chargement complet en parallèle dans le mappage de table.

En d'autres termes, vous pouvez migrer une collection en parallèle en utilisant la segmentation automatique ou la segmentation par plage avec le mappage de table pour un chargement complet en parallèle dans les paramètres JSON. Avec la segmentation automatique, vous pouvez spécifier les critères permettant à AWS DMS de segmenter automatiquement votre source pour la migration dans chaque thread. Avec la segmentation par plage, vous pouvez indiquer à AWS DMS la plage spécifique de chaque segment que DMS doit migrer dans chaque thread. Pour plus d'informations sur ces paramètres, consultez Règles des paramètres de table et de collection et opérations.

Migration d'une base de données MongoDB en parallèle à l'aide de plages de segmentation automatique

Vous pouvez migrer vos documents en parallèle en spécifiant les critères permettant à AWS DMS de partitionner (segmenter) automatiquement vos données pour chaque thread. Vous spécifiez notamment le nombre de documents à migrer par thread. En utilisant cette approche, AWS DMS tente d'optimiser les limites de segment pour augmenter les performances par thread.

Vous pouvez spécifier les critères de segmentation à l'aide des options table-settings suivantes dans table-mapping.

L'exemple suivant illustre un mappage de table pour la segmentation automatique.

{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "admin",
                "table-name": "departments"
            },
            "rule-action": "include",
            "filters": []
        },
        {
            "rule-type": "table-settings",
            "rule-id": "2",
            "rule-name": "2",
            "object-locator": {
                "schema-name": "admin",
                "table-name": "departments"
            },
            "parallel-load": {
                "type": "partitions-auto",
                "number-of-partitions": 5,
                "collection-count-from-metadata": "true",
                "max-records-skip-per-page": 1000000,
                "batch-size": 50000
            }
        }
    ]
}

La segmentation automatique présente les limitations suivantes. Pour chaque segment, la migration extrait séparément le nombre de collections et la valeur minimale de _id pour la collection. Elle ignore ensuite un certain nombre d'enregistrements par page pour calculer la limite minimale pour ce segment.

Par conséquent, assurez-vous que la valeur minimale de _id reste constante pour chaque collection, jusqu'à ce que toutes les limites de segment de la collection soient calculées. Si vous modifiez la valeur minimale de _id d'une collection lors du calcul de ses limites de segment, cela peut entraîner une perte de données ou des erreurs de lignes en double.

Migration d'une base de données MongoDB en parallèle à l'aide de la segmentation par plage

Vous pouvez migrer vos documents en parallèle en spécifiant les plages pour chaque segment d'un thread. En utilisant cette approche, vous indiquez à AWS DMS les documents à migrer dans chaque thread en fonction des plages de documents que vous avez choisies par thread.

L'image suivante illustre une collection MongoDB composée de sept éléments, qui utilise _id comme clé primaire.

Pour diviser la collection en trois segments spécifiques qu'AWS DMS va migrer en parallèle, vous pouvez ajouter des règles de mappage de table à votre tâche de migration. Cette approche est illustrée dans l'exemple de code JSON suivant.

{ // Task table mappings:
  "rules": [
    {
      "rule-type": "selection",
      "rule-id": "1",
      "rule-name": "1",
      "object-locator": {
        "schema-name": "testdatabase",
        "table-name": "testtable"
      },
      "rule-action": "include"
    }, // "selection" :"rule-type"
    {
      "rule-type": "table-settings",
      "rule-id": "2",
      "rule-name": "2",
      "object-locator": {
        "schema-name": "testdatabase",
        "table-name": "testtable"
      },
      "parallel-load": {
        "type": "ranges",
        "columns": [
           "_id",
           "num"
        ],
        "boundaries": [
          // First segment selects documents with _id less-than-or-equal-to 5f805c97873173399a278d79
          // and num less-than-or-equal-to 2.
          [
             "5f805c97873173399a278d79",
             "2"
          ],
          // Second segment selects documents with _id > 5f805c97873173399a278d79 and
          // _id less-than-or-equal-to 5f805cc5873173399a278d7c and
          // num > 2 and num less-than-or-equal-to 5.
          [
             "5f805cc5873173399a278d7c",
             "5"
          ]                                   
          // Third segment is implied and selects documents with _id > 5f805cc5873173399a278d7c.
        ] // :"boundaries"
      } // :"parallel-load"
    } // "table-settings" :"rule-type"
  ] // :"rules"
} // :Task table mappings

Cette définition de mappage de table divise la collection source en trois segments et la migre en parallèle. Les limites de segmentation sont les suivantes.

Data with _id less-than-or-equal-to "5f805c97873173399a278d79" and num less-than-or-equal-to 2 (2 records)
Data with _id > "5f805c97873173399a278d79" and num > 2 and _id  less-than-or-equal-to "5f805cc5873173399a278d7c" and num less-than-or-equal-to 5 (3 records)
Data with _id > "5f805cc5873173399a278d7c" and num > 5 (2 records)    
            

Une fois la tâche de migration terminée, vous pouvez vérifier dans les journaux de tâches que les tables sont chargées en parallèle, comme indiqué dans l'exemple suivant. Vous pouvez également vérifier la clause find de MongoDB utilisée pour décharger chaque segment de la table source.

[TASK_MANAGER    ] I:  Start loading segment #1 of 3 of table 'testdatabase'.'testtable' (Id = 1) by subtask 1. Start load timestamp 0005B191D638FE86  (replicationtask_util.c:752)

[SOURCE_UNLOAD   ] I:  Range Segmentation filter for Segment #0 is initialized.   (mongodb_unload.c:157)

[SOURCE_UNLOAD   ] I:  Range Segmentation filter for Segment #0 is: { "_id" : { "$lte" : { "$oid" : "5f805c97873173399a278d79" } }, "num" : { "$lte" : { "$numberInt" : "2" } } }  (mongodb_unload.c:328)

[SOURCE_UNLOAD   ] I: Unload finished for segment #1 of segmented table 'testdatabase'.'testtable' (Id = 1). 2 rows sent.

[TASK_MANAGER    ] I: Start loading segment #1 of 3 of table 'testdatabase'.'testtable' (Id = 1) by subtask 1. Start load timestamp 0005B191D638FE86 (replicationtask_util.c:752)
 
[SOURCE_UNLOAD   ] I: Range Segmentation filter for Segment #0 is initialized. (mongodb_unload.c:157) 

[SOURCE_UNLOAD   ] I: Range Segmentation filter for Segment #0 is: { "_id" : { "$lte" : { "$oid" : "5f805c97873173399a278d79" } }, "num" : { "$lte" : { "$numberInt" : "2" } } } (mongodb_unload.c:328)
 
[SOURCE_UNLOAD   ] I: Unload finished for segment #1 of segmented table 'testdatabase'.'testtable' (Id = 1). 2 rows sent.

[TARGET_LOAD     ] I: Load finished for segment #1 of segmented table 'testdatabase'.'testtable' (Id = 1). 1 rows received. 0 rows skipped. Volume transfered 480.

[TASK_MANAGER    ] I: Load finished for segment #1 of table 'testdatabase'.'testtable' (Id = 1) by subtask 1. 2 records transferred.
            

Actuellement, AWS DMS prend en charge les types de données MongoDB suivants sous forme de colonne de clé de segment :

Migration de plusieurs bases de données lors de l'utilisation de MongoDB en tant que source pour AWS DMS

AWS DMS versions 3.4.5 et ultérieures prennent en charge la migration de plusieurs bases de données en une seule tâche pour toutes les versions de MongoDB prises en charge. Si vous souhaitez migrer plusieurs bases de données, procédez comme suit :

Vous pouvez par exemple spécifier le code JSON suivant pour migrer trois bases de données MongoDB.

{
    "rules": [
        {
            "rule-type": "selection",
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "Customers",
                "table-name": "%"
            },
            "rule-action": "include",
            "filters": []
        },
        {
            "rule-type": "selection",
            "rule-id": "2",
            "rule-name": "2",
            "object-locator": {
                "schema-name": "Orders",
                "table-name": "%"
            },
            "rule-action": "include",
            "filters": []
        },
        {
            "rule-type": "selection",
            "rule-id": "3",
            "rule-name": "3",
            "object-locator": {
                "schema-name": "Inventory",
                "table-name": "%"
            },
            "rule-action": "include",
            "filters": []
        }
    ]
}                

Limites d’utilisation de MongoDB comme source pour AWS DMS

Les limites suivantes s'appliquent lorsque MongoDB est utilisé comme source pour AWS DMS :

Paramètres de configuration de point de terminaison lors de l'utilisation de MongoDB en tant que source pour AWS DMS

Lorsque vous configurez le point de terminaison source MongoDB, vous pouvez spécifier plusieurs paramètres de configuration de point de terminaison à l'aide de la console AWS DMS.

Le tableau suivant décrit les paramètres de configuration disponibles lorsque vous utilisez les bases de données MongoDB en tant que source AWS DMS.

Si vous choisissez Document comme Mode métadonnées, différentes options sont disponibles.

Si le point de terminaison cible est DocumentDB, assurez-vous d'exécuter la migration en Mode document. Modifiez également le point de terminaison source et sélectionnez l'option _id en tant que colonne séparée. Il s'agit d'un prérequis obligatoire si votre charge de travail MongoDB source implique des transactions.

Types de données sources pour MongoDB

La migration des données qui utilise MongoDB comme source pour AWS DMS prend en charge la plupart des types de données MongoDB. Dans le tableau suivant, vous pouvez trouver les types de données sources MongoDB qui sont pris en charge lorsque vous utilisez AWS DMS et le mappage par défaut des types de données AWS DMS. Pour de plus amples informations sur les types de données MongoDB, veuillez consulter Types BSON dans la documentation MongoDB.

Pour obtenir des informations sur la façon d'afficher le type de données qui est mappé dans la cible, consultez la section relative au point de terminaison cible que vous utilisez.

Pour de plus amples informations sur les types de données AWS DMS, veuillez consulter Types de données pour AWS Database Migration Service.