Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Usare MongoDB come fonte per AWS DMS
Per informazioni sulle versioni di MongoDB AWS DMS supportate come sorgente, consulta. [Fonti per AWS DMS](CHAP_Introduction.Sources.md)
Tieni presente quanto segue in relazione al supporto delle versioni di MongoDB:
+ Le versioni AWS DMS 3.4.5 e successive supportano le versioni di MongoDB 4.2 e 4.4.
+ Le versioni AWS DMS 3.4.5 e successive e le versioni di MongoDB 4.2 e successive supportano le transazioni distribuite. Per ulteriori informazioni sulle transazioni distribuite MongoDB, consulta [Transactions](https://docs.mongodb.com/manual/core/transactions/) nella [documentazione di MongoDB.](https://www.mongodb.com/docs/)
+ Le versioni AWS DMS 3.5.0 e successive non supportano le versioni di MongoDB precedenti alla 3.6.
+ Le versioni AWS DMS 3.5.1 e successive supportano la versione 5.0 di MongoDB.
+ Le versioni AWS DMS 3.5.2 e successive supportano la versione 6.0 di MongoDB.
+ Le versioni AWS DMS 3.5.4 e successive supportano le versioni 7.0 e 8.0 di MongoDB.
Se non conosci MongoDB, è necessario avere familiarità con i seguenti importanti concetti del database MongoDB:
+ Un record in MongoDB è un *documento* che è una struttura di dati costituita da coppie di campi e di valori. Il valore di un campo può includere altri documenti, matrici e matrici di documenti. Un documento è approssimativamente equivalente a una riga di una tabella di database relazionali.
+ Una *raccolta* in MongoDB è un gruppo di documenti ed è approssimativamente equivalente a una tabella di database relazionale.
+ Un *database* in MongoDB è un set di raccolte ed è approssimativamente equivalente a uno schema di database relazionale.
+ Internamente, un documento MongoDB viene memorizzato come un file JSON binario (BSON) in un formato compresso che include un tipo per ogni campo del documento. Ogni documento ha un ID univoco.
AWS DMS *supporta due modalità di migrazione quando si utilizza MongoDB come sorgente*, la modalità Document* o la modalità Table.* È possibile specificare la modalità di migrazione da utilizzare quando si crea l'endpoint MongoDB o impostando il parametro **Modalità metadati** dalla console AWS DMS . Facoltativamente, puoi creare una seconda colonna denominata `_id` che funge da chiave primaria selezionando il pulsante con il segno di spunta per **\$1id come colonna separata** nel pannello di configurazione dell'endpoint.
La scelta della modalità di migrazione influenza il formato risultante dei dati di destinazione come descritto di seguito.
**Modalità documento**
In modalità documento, il documento MongoDB viene migrato così com'è, vale a dire che i dati del documento vengono consolidati in una singola colonna denominata `_doc` in una tabella di destinazione. La modalità documento è l'impostazione predefinita quando si utilizza MongoDB come endpoint di origine.
Ad esempio, considera i seguenti documenti in una raccolta MongoDB denominata myCollection.
```
db.myCollection.find()
{ "_id" : ObjectId("5a94815f40bd44d1b02bdfe0"), "a" : 1, "b" : 2, "c" : 3 }
{ "_id" : ObjectId("5a94815f40bd44d1b02bdfe1"), "a" : 4, "b" : 5, "c" : 6 }
```
Una volta completata la migrazione dei dati a una tabella di database relazionale utilizzando la modalità documento, i dati vengono strutturati come segue. I campi dei dati nel documento MongoDB sono consolidati nella colonna` _doc`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/dms/latest/userguide/CHAP_Source.MongoDB.html)
Puoi impostare facoltativamente l'attributo di connessione aggiuntivo `extractDocID` su *true* per creare una seconda colonna denominata `"_id"` che agisca come chiave primaria. Se prevedi di utilizzare CDC, imposta questo parametro su *true*.
*Quando si utilizza CDC con fonti che producono [transazioni con più documenti](https://www.mongodb.com/docs/manual/reference/method/Session.startTransaction/#mongodb-method-Session.startTransaction), il `ExtractDocId` parametro **deve essere** impostato su true.* Se questo parametro non è abilitato, l' AWS DMS operazione avrà esito negativo quando rileva una transazione con più documenti.
In modalità documento, AWS DMS gestisce la creazione e la ridenominazione di raccolte in questo modo:
+ Se aggiungi una nuova raccolta al database di origine, AWS DMS crea una nuova tabella di destinazione per la raccolta e replica tutti i documenti.
+ Se rinomini una raccolta esistente nel database di origine, AWS DMS non rinomina la tabella di destinazione.
Se l'endpoint di destinazione è Amazon DocumentDB, esegui la migrazione in **modalità documento**.
**Modalità tabella**
In modalità tabella, AWS DMS trasforma ogni campo di primo livello in un documento MongoDB in una colonna nella tabella di destinazione. Se un campo è nidificato, AWS DMS appiattisce i valori nidificati in una singola colonna. AWS DMS quindi aggiunge un campo chiave e i tipi di dati al set di colonne della tabella di destinazione.
Per ogni documento MongoDB AWS DMS , aggiunge ogni chiave e tipo al set di colonne della tabella di destinazione. Ad esempio, utilizzando la modalità tabella, AWS DMS migra l'esempio precedente nella tabella seguente.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/dms/latest/userguide/CHAP_Source.MongoDB.html)
I valori nidificati sono appiattiti in una colonna contenente nomi di chiavi separati da punti. La colonna è denominata dalla concatenazione dei nomi di campo appiattiti separati da punti. Ad esempio, AWS DMS migra un documento JSON con un campo di valori annidati, ad esempio in una colonna `{"a" : {"b" : {"c": 1}}}` denominata `a.b.c.`
Per creare le colonne di destinazione, AWS DMS analizza un numero specificato di documenti MongoDB e crea un set di tutti i campi e i relativi tipi. AWS DMS quindi utilizza questo set per creare le colonne della tabella di destinazione. Se crei o modifichi l'endpoint di origine di MongoDB utilizzando la console, è possibile specificare il numero di documenti per la scansione. Il valore predefinito è 1000 documenti. Se si utilizza il AWS CLI, è possibile utilizzare l'attributo di connessione extra`docsToInvestigate`.
In modalità tabella, AWS DMS gestisce documenti e raccolte in questo modo:
+ Quando aggiungi un documento in una raccolta esistente, il documento viene replicato. Se ci sono campi che non esistono nella destinazione, tali campi non vengono replicati.
+ Quando aggiorni un documento, il documento aggiornato viene replicato. Se ci sono campi che non esistono nella destinazione, tali campi non vengono replicati.
+ L'eliminazione di un documento è supportata integralmente.
+ L'aggiunta di una nuova raccolta non ha come risultato una nuova tabella nella destinazione durante un'attività CDC.
+ Nella fase Change Data Capture (CDC), AWS DMS non supporta la ridenominazione di una raccolta.
**Topics**
+ [Autorizzazioni necessarie quando si utilizza MongoDB come fonte per AWS DMS](#CHAP_Source.MongoDB.PrerequisitesCDC)
+ [Configurazione di un set di repliche MongoDB per CDC](#CHAP_Source.MongoDB.PrerequisitesCDC.ReplicaSet)
+ [Requisiti di sicurezza per l'utilizzo di MongoDB come fonte per AWS DMS](#CHAP_Source.MongoDB.Security)
+ [Segmentazione delle raccolte MongoDB e migrazione in parallelo](#CHAP_Source.MongoDB.ParallelLoad)
+ [Migrazione di più database quando si utilizza MongoDB come fonte per AWS DMS](#CHAP_Source.MongoDB.Multidatabase)
+ [Limitazioni nell'utilizzo di MongoDB come fonte per AWS DMS](#CHAP_Source.MongoDB.Limitations)
+ [Impostazioni di configurazione degli endpoint quando si utilizza MongoDB come fonte per AWS DMS](#CHAP_Source.MongoDB.Configuration)
+ [Tipi di dati di origine per MongoDB](#CHAP_Source.MongoDB.DataTypes)
## Autorizzazioni necessarie quando si utilizza MongoDB come fonte per AWS DMS
Per una AWS DMS migrazione con una fonte MongoDB, puoi creare un account utente con privilegi di root o un utente con autorizzazioni solo sul database da migrare.
Il codice seguente crea un utente come account root.
```
use admin
db.createUser(
{
user: "root",
pwd: "password",
roles: [ { role: "root", db: "admin" } ]
}
)
```
Per un'origine MongoDB 3.x, il codice seguente crea un utente con privilegi minimi sul database da migrare.
```
use database_to_migrate
db.createUser(
{
user: "dms-user",
pwd: "password",
roles: [ { role: "read", db: "local" }, "read"]
})
```
Per un'origine MongoDB 4.x, il codice seguente crea un utente con privilegi minimi.
```
{ resource: { db: "", collection: "" }, actions: [ "find", "changeStream" ] }
```
Ad esempio, crea il seguente ruolo nel database "admin".
```
use admin
db.createRole(
{
role: "changestreamrole",
privileges: [
{ resource: { db: "", collection: "" }, actions: [ "find","changeStream" ] }
],
roles: []
}
)
```
Una volta creato il ruolo, crea un utente nel database da migrare.
```
use test
> db.createUser(
{
user: "dms-user12345",
pwd: "password",
roles: [ { role: "changestreamrole", db: "admin" }, "read"]
})
```
## Configurazione di un set di repliche MongoDB per CDC
Per utilizzare la replica continua o CDC con MongoDB, è necessario l' AWS DMS accesso al registro delle operazioni di MongoDB (oplog). Per creare l'oplog, devi distribuire un set di repliche se non esiste già. Per ulteriori informazioni, consulta la [ documentazione di MongoDB](https://docs.mongodb.com/manual/tutorial/deploy-replica-set/).
Puoi utilizzare il CDC con il nodo primario o secondario di un set di repliche MongoDB come endpoint di origine.
**Per convertire un'istanza autonoma in un set di repliche**
1. Utilizzando la riga di comando, collegati a `mongo`.
```
mongo localhost
```
1. Arresta il servizio `mongod`.
```
service mongod stop
```
1. Riavvia `mongod` utilizzando il seguente comando:
```
mongod --replSet "rs0" --auth -port port_number
```
1. Verifica la connessione al set di repliche utilizzando i comandi seguenti:
```
mongo -u root -p password --host rs0/localhost:port_number
--authenticationDatabase "admin"
```
Se prevedi di eseguire una migrazione in modalità documento, seleziona l'opzione `_id as a separate column` quando crei l'endpoint di MongoDB. Se selezioni questa opzione, viene creata una seconda colonna denominata `_id` che agisce come chiave primaria. Questa seconda colonna è necessaria per supportare le operazioni DML (Data Manipulation AWS DMS Language).
**Nota**
AWS DMS utilizza il registro delle operazioni (oplog) per acquisire le modifiche durante la replica in corso. Se MongoDB elimina i record dall'oplog AWS DMS prima di leggerli, le tue attività falliranno. Ti consigliamo di dimensionare l'oplog in modo da mantenere le modifiche per almeno 24 ore.
## Requisiti di sicurezza per l'utilizzo di MongoDB come fonte per AWS DMS
AWS DMS supporta due metodi di autenticazione per MongoDB. I due metodi di autenticazione vengono utilizzati per crittografare la password, in modo che vengano utilizzati solo quando il parametro `authType` è impostato su *PASSWORD*.
I metodi autenticazione di MongoDB sono i seguenti:
+ **MONGODB-CR**: per la compatibilità con le versioni precedenti
+ **SCRAM-SHA-1**: l'impostazione predefinita quando si utilizza MongoDB versione 3.x e 4.0
Se non viene specificato un metodo di autenticazione, AWS DMS utilizza il metodo predefinito per la versione del sorgente MongoDB.
## Segmentazione delle raccolte MongoDB e migrazione in parallelo
Per migliorare le prestazioni di un'attività di migrazione, gli endpoint di origine MongoDB supportano due opzioni per il pieno carico parallelo nella mappatura delle tabelle.
In altre parole, è possibile migrare una raccolta in parallelo utilizzando la segmentazione automatica o la segmentazione degli intervalli con la mappatura delle tabelle per il pieno carico parallelo nelle impostazioni JSON. Con la segmentazione automatica, puoi specificare i criteri per AWS DMS segmentare automaticamente la fonte per la migrazione in ogni thread. Con la segmentazione degli intervalli, puoi indicare AWS DMS l'intervallo specifico di ogni segmento che DMS deve migrare in ogni thread. Per ulteriori informazioni su queste impostazioni, consulta [Regole e operazioni delle impostazioni di tabella e raccolta](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Tablesettings.md).
### Migrazione di un database MongoDB in parallelo utilizzando gli intervalli di segmentazione automatica
Puoi migrare i tuoi documenti in parallelo specificando i criteri che AWS DMS utilizza per partizionare (segmentare) automaticamente i dati per ogni thread. In particolare, si specifica il numero di documenti da migrare per thread. Utilizzando questo approccio, AWS DMS tenta di ottimizzare i confini dei segmenti per ottenere le massime prestazioni per thread.
È possibile specificare i criteri di segmentazione utilizzando le opzioni di impostazione della tabella riportate di seguito nella mappatura delle tabelle.
| Opzione delle impostazioni della tabella | Description |
| --- | --- |
| `"type"` | (Obbligatoria) Impostata su `"partitions-auto"` per MongoDB come origine. |
| `"number-of-partitions"` | (Facoltativa) Numero totale di partizioni (segmenti) utilizzate per la migrazione. Il valore predefinito è 16. |
| `"collection-count-from-metadata"` | (Facoltativa) Se questa opzione è impostata su `true`, AWS DMS utilizza un conteggio di raccolte stimato per determinare il numero di partizioni. Se questa opzione è impostata su`false`, AWS DMS utilizza il conteggio effettivo delle raccolte. Il valore predefinito è `true`. |
| `"max-records-skip-per-page"` | (Facoltativo) Il numero di record da saltare contemporaneamente quando si determinano i limiti di ogni partizione. AWS DMS utilizza un approccio di salto impaginato per determinare il limite minimo per una partizione. Il valore predefinito è 10.000. L'impostazione di un valore relativamente elevato può causare timeout del cursore e errori delle attività. L'impostazione di un valore relativamente basso comporta un numero maggiore di operazioni per pagina e un pieno carico più lento. |
| `"batch-size"` | (Facoltativa) Limita il numero di documenti restituiti in un batch. Ogni batch richiede un round trip al server. Se la dimensione del batch è zero (0), il cursore utilizza la dimensione massima del batch definita dal server. Il valore predefinito è 0. |
L'esempio seguente mostra una mappatura delle tabelle per la segmentazione automatica.
```
{
"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 segmentazione automatica presenta le seguenti limitazioni. La migrazione di ogni segmento recupera separatamente il conteggio di raccolte e il valore `_id` minimo della raccolta. Quindi utilizza l'approccio per ignorare con impaginazione per calcolare il limite minimo del segmento.
Pertanto, assicurati che il valore `_id` minimo di ogni raccolta rimanga costante fino al calcolo di tutti i limiti del segmento della raccolta. La modifica del valore `_id` minimo di una raccolta durante il calcolo dei limiti del segmento può causare la perdita di dati o errori di riga duplicata.
### Migrazione di un database MongoDB in parallelo utilizzando la segmentazione degli intervalli
Puoi migrare i documenti in parallelo specificando gli intervalli per ogni segmento di un thread. Utilizzando questo approccio, si dice AWS DMS ai documenti specifici di migrare in ogni thread in base alla scelta degli intervalli di documenti per thread.
L'immagine seguente mostra una raccolta MongoDB con sette elementi e `_id` come chiave primaria.
![\[Raccolta MongoDB con sette elementi.\]](http://docs.aws.amazon.com/it_it/dms/latest/userguide/images/datarep-docdb-collection.png)
Per suddividere la raccolta in tre segmenti specifici AWS DMS da migrare in parallelo, puoi aggiungere regole di mappatura delle tabelle all'attività di migrazione. Questo approccio è mostrato nel seguente esempio JSON.
```
{ // 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
```
Questa definizione di mappatura delle tabelle divide la raccolta di origine in tre segmenti ed esegue la migrazione in parallelo. Di seguito sono riportati i limiti della segmentazione.
```
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)
```
Una volta completata l'attività di migrazione, è possibile verificare nei log delle attività che le tabelle siano state caricate in parallelo, come illustrato nell'esempio seguente. Puoi anche verificare la clausola `find` MongoDB utilizzata per scaricare ogni segmento dalla tabella di origine.
```
[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.
```
Attualmente, AWS DMS supporta i seguenti tipi di dati MongoDB come colonna chiave del segmento:
+ Double
+ Stringa
+ ObjectId
+ Intero a 32 bit
+ Intero a 64 bit
## Migrazione di più database quando si utilizza MongoDB come fonte per AWS DMS
AWS DMS le versioni 3.4.5 e successive supportano la migrazione di più database in un'unica attività per tutte le versioni di MongoDB supportate. Se desideri migrare più database, procedi nel modo seguente:
1. Quando crei l'endpoint di origine MongoDB, esegui una delle seguenti operazioni:
+ Nella pagina **Crea endpoint** della console DMS, assicurati che il campo **Nome del database** sia vuoto nella sezione **Configurazione dell'endpoint**.
+ Utilizzando il AWS CLI `CreateEndpoint` comando, assegnate un valore di stringa vuoto al parametro in. `DatabaseName` `MongoDBSettings`
1. Per ogni database che desideri migrare da un'origine MongoDB, specifica il nome del database come nome dello schema nella mappatura della tabella per l'attività. Puoi farlo utilizzando l'input guidato nella console o direttamente in JSON. Per ulteriori informazioni sull'input guidato, consulta [Specifica della selezione delle tabelle e delle regole di trasformazione dalla console](CHAP_Tasks.CustomizingTasks.TableMapping.Console.md). Per ulteriori informazioni sul JSON, consulta [Operazioni e regole di selezione](CHAP_Tasks.CustomizingTasks.TableMapping.SelectionTransformation.Selections.md).
Ad esempio, puoi specificare il codice JSON seguente per migrare tre database MongoDB.
**Example Migrazione di tutte le tabelle in uno schema**
Il codice JSON seguente esegue la migrazione di tutte le tabelle dai database `Customers`, `Orders` e `Suppliers` dell'endpoint di origine all'endpoint di destinazione.
```
{
"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": []
}
]
}
```
## Limitazioni nell'utilizzo di MongoDB come fonte per AWS DMS
Di seguito sono riportate le limitazioni relative all'utilizzo di MongoDB come fonte per: AWS DMS
+ In modalità tabella, i documenti di una raccolta devono essere coerenti nel tipo di dati utilizzato per il valore nello stesso campo. Ad esempio, se il documento di una raccolta include `'{ a:{ b:value ... }'`, tutti i documenti della raccolta che fanno riferimento a `value` del campo `a.b` devono utilizzare lo stesso tipo di dati per `value`, ovunque appaia nella raccolta.
+ Quando l'opzione `_id` è impostata come una colonna separata, la stringa ID non deve superare i 200 caratteri.
+ L'ID oggetto e le chiavi del tipo di matrice vengono convertiti in colonne con prefisso `oid` e `array` in modalità tabella.
Internamente, viene fatto riferimento a queste colonne con i nomi con prefisso. Se utilizzi regole di trasformazione AWS DMS che fanno riferimento a queste colonne, assicurati di specificare la colonna con prefisso. Ad esempio, devi specificare `${oid__id}` e non `${_id}`, oppure `${array__addresses}` e non `${_addresses}`.
+ I nomi delle raccolte e delle chiavi non possono includere il simbolo del dollaro (\$1).
+ AWS DMS non supporta raccolte contenenti lo stesso campo con lettere maiuscole e minuscole diverse (maiuscole, minuscole) in modalità tabella con destinazione RDBMS. Ad esempio, non AWS DMS supporta la presenza di due raccolte `Field1` denominate e. `field1`
+ La modalità tabella e la modalità documento presentano le limitazioni illustrate in precedenza.
+ La migrazione in parallelo utilizzando la segmentazione automatica comporta le limitazioni descritte in precedenza.
+ I filtri di origine non sono supportati per MongoDB.
+ AWS DMS non supporta documenti in cui il livello di nidificazione è maggiore di 97.
+ AWS DMS richiede dati di origine con codifica UTF-8 durante la migrazione verso destinazioni non DocumentDB. Per le sorgenti con caratteri non UTF-8, convertile in UTF-8 prima della migrazione o esegui invece la migrazione ad Amazon DocumentDB.
+ AWS DMS non supporta le seguenti funzionalità della versione 5.0 di MongoDB:
+ Ripartizionamento live
+ Crittografia a livello di campo lato client
+ Migrazione della raccolta di serie temporali
**Nota**
Una raccolta di serie temporali migrata nella fase di pieno carico viene convertita in una normale raccolta in Amazon DocumentDB perché DocumentDB non supporta le raccolte di serie temporali.
## Impostazioni di configurazione degli endpoint quando si utilizza MongoDB come fonte per AWS DMS
Quando configuri il tuo endpoint sorgente MongoDB, puoi specificare più impostazioni di configurazione dell'endpoint utilizzando la console. AWS DMS
La tabella seguente descrive le impostazioni di configurazione disponibili quando si utilizzano i database MongoDB come origine. AWS DMS
| Impostazione (attributo) | Valori validi | Valore predefinito e descrizione |
| --- | --- | --- |
| **Modalità di autenticazione** | `"none"` `"password"` | Il valore `"password"` richiede un nome utente e una password. Quando si specifica `"none"`, i parametri nome utente e password non vengono utilizzati. |
| **Origine di autenticazione** | Un nome di database MongoDB valido. | Il nome del database MongoDB che desideri utilizzare per convalidare le credenziali di autenticazione. Il valore predefinito è `"admin"`. |
| **Meccanismo di autenticazione** | `"default"` `"mongodb_cr"` `"scram_sha_1"` | Il meccanismo di autenticazione. Il valore di ` "default"` è `"scram_sha_1"`. Questa impostazione non viene utilizzata quando `authType` è impostato su `"no"`. |
| **Modalità metadati** | Documento e tabella | Scegli la modalità documento o la modalità tabella. |
| **Numero di documenti da analizzare** (`docsToInvestigate`) | Un numero intero positivo maggiore di `0`. | Utilizza questa opzione in modalità tabella solo per specificare la definizione della tabella di destinazione. |
| **\$1id come colonna separata** | Segno di spunta nella casella | Casella di spunta facoltativa che crea una seconda colonna denominata `_id` che agisce come chiave primaria. |
| `ExtractDocID` | `true` `false` | `false`: utilizza questo attributo quando `NestingLevel` è impostato su `"none"`. Quando si utilizza CDC con fonti che producono [transazioni con più documenti](https://www.mongodb.com/docs/manual/reference/method/Session.startTransaction/#mongodb-method-Session.startTransaction), il `ExtractDocId` parametro **deve essere** impostato su. `true` Se questo parametro non è abilitato, l' AWS DMS operazione avrà esito negativo quando rileva una transazione con più documenti. |
| `socketTimeoutMS` | Un numero intero maggiore o uguale a 0. Solo attributo aggiuntivo di connessione. | Questa impostazione è espressa in millisecondi e configura il timeout di connessione per i client MongoDB. Se il valore è minore o uguale a zero, viene utilizzato il client MongoDB predefinito. |
| `UseUpdateLookUp` | `true` `false` | Se impostato su true, durante gli eventi di aggiornamento del CDC, AWS DMS copia l'intero documento aggiornato nella destinazione. Se impostato su false, AWS DMS utilizza il comando MongoDB update per aggiornare solo i campi modificati nel documento sulla destinazione. |
| `ReplicateShardCollections` | `true` `false` | Se impostato su true, AWS DMS replica i dati in raccolte di frammenti. AWS DMS utilizza questa impostazione solo se l'endpoint di destinazione è un cluster elastico DocumentDB. Quando questa impostazione è true, è importante tenere presenti le seguenti informazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/dms/latest/userguide/CHAP_Source.MongoDB.html) |
| `useTransactionVerification` | `true` `false` | Quando`false`, disabilita la verifica tra il flusso di modifiche e gli oplogs. È possibile che le operazioni non vengano eseguite se si verificano discrepanze tra i flussi di modifica e le voci degli oplog, poiché il comportamento predefinito del DMS prevede il fallimento dell'operazione in tali scenari. Default: `true`. |
| `useOplog` | `true` `false` | When`true`, consente all'attività DMS di leggere direttamente da 'oplog' anziché utilizzare il flusso di modifiche. Default: `false`. |
Se scegli **Documento** come **Modalità metadati**, sono disponibili diverse opzioni.
Se l'endpoint di destinazione è DocumentDB, assicurati di eseguire la migrazione in **modalità documento**. Inoltre, modifica l'endpoint di origine e seleziona l'opzione **\$1id come colonna separata**. Questo è un prerequisito obbligatorio se il carico di lavoro MongoDB di origine include transazioni.
## Tipi di dati di origine per MongoDB
La migrazione dei dati che utilizza MongoDB come fonte AWS DMS supporta la maggior parte dei tipi di dati MongoDB. Nella tabella seguente, puoi trovare i tipi di dati di origine MongoDB supportati durante l' AWS DMS utilizzo e la AWS DMS mappatura predefinita dei tipi di dati. Per ulteriori informazioni sui tipi di dati MongoDB, consulta la sezione relativa ai [ tipi BSON](https://docs.mongodb.com/manual/reference/bson-types) nella documentazione di MongoDB.
Per informazioni su come visualizzare il tipo di dati mappato nella destinazione, consulta la sezione relativa all'endpoint di destinazione che stai utilizzando.
Per ulteriori informazioni sui tipi di AWS DMS dati, vedere. [Tipi di dati per AWS Database Migration Service](CHAP_Reference.DataTypes.md)
| Tipi di dati MongoDB | AWS DMS tipi di dati |
| --- | --- |
| Booleano | Bool |
| Binario | BLOB |
| Data | Data |
| Timestamp | Data |
| Int | INT4 |
| Long | INT8 |
| Double | REAL8 |
| String (UTF-8) | CLOB |
| Array | CLOB |
| OID | Stringa |
| REGEX | CLOB |
| CODE | CLOB |