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à.
# Connessioni ad Amazon DocumentDB
Puoi usare AWS Glue for Spark per leggere e scrivere su tabelle in Amazon DocumentDB. Puoi connetterti ad Amazon DocumentDB utilizzando le credenziali archiviate tramite Gestione dei segreti AWS una connessione AWS Glue.
Per ulteriori informazioni su Amazon DocumentDB, consulta la [documentazione di Amazon DocumentDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/what-is.html).
**Nota**
I cluster elastici di Amazon DocumentDB non sono attualmente supportati quando si utilizza il connettore AWS Glue. Per ulteriori informazioni sui cluster elastici, consulta la pagina [Using Amazon DocumentDB elastic clusters](https://docs.aws.amazon.com/documentdb/latest/developerguide/docdb-using-elastic-clusters.html).
## Lettura e scrittura nelle raccolte Amazon DocumentDB
**Nota**
Quando crei un processo ETL a cui si connette Amazon DocumentDB, per la proprietà del processo `Connections`, devi designare un oggetto connessione che specifica il cloud privato virtuale (VPC) in cui Amazon DocumentDB è in esecuzione. Per l'oggetto connessione, il tipo di connessione deve essere `JDBC`, e `JDBC URL` deve essere `mongo://:27017`.
**Nota**
Questi esempi di codice sono stati sviluppati per AWS Glue 3.0. Per migrare a AWS Glue 4.0, consulta[MongoDB](migrating-version-40.md#migrating-version-40-connector-driver-migration-mongodb). Il parametro `uri` è cambiato.
**Nota**
Quando si utilizza Amazon DocumentDB, `retryWrites` deve essere impostato su false in determinate situazioni, ad esempio quando il documento scritto specifica `_id`. Per ulteriori informazioni, consulta [Differenze funzionali con MongoDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/functional-differences.html#functional-differences.retryable-writes) nella documentazione di Amazon DocumentDB.
Il seguente script Python dimostra l'utilizzo di tipi e opzioni di connessione per la lettura e la scrittura su Amazon DocumentDB.
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext, SparkConf
from awsglue.context import GlueContext
from awsglue.job import Job
import time
## @params: [JOB_NAME]
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)
output_path = "s3://some_bucket/output/" + str(time.time()) + "/"
documentdb_uri = "mongodb://:27017"
documentdb_write_uri = "mongodb://:27017"
read_docdb_options = {
"uri": documentdb_uri,
"database": "test",
"collection": "coll",
"username": "username",
"password": "1234567890",
"ssl": "true",
"ssl.domain_match": "false",
"partitioner": "MongoSamplePartitioner",
"partitionerOptions.partitionSizeMB": "10",
"partitionerOptions.partitionKey": "_id"
}
write_documentdb_options = {
"retryWrites": "false",
"uri": documentdb_write_uri,
"database": "test",
"collection": "coll",
"username": "username",
"password": "pwd"
}
# Get DynamicFrame from DocumentDB
dynamic_frame2 = glueContext.create_dynamic_frame.from_options(connection_type="documentdb",
connection_options=read_docdb_options)
# Write DynamicFrame to MongoDB and DocumentDB
glueContext.write_dynamic_frame.from_options(dynamic_frame2, connection_type="documentdb",
connection_options=write_documentdb_options)
job.commit()
```
Il seguente script Scala dimostra l'utilizzo di tipi e opzioni di connessione per la lettura e la scrittura su Amazon DocumentDB.
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.MappingSpec
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamicFrame
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
val DOC_URI: String = "mongodb://:27017"
val DOC_WRITE_URI: String = "mongodb://:27017"
lazy val documentDBJsonOption = jsonOptions(DOC_URI)
lazy val writeDocumentDBJsonOption = jsonOptions(DOC_WRITE_URI)
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
// Get DynamicFrame from DocumentDB
val resultFrame2: DynamicFrame = glueContext.getSource("documentdb", documentDBJsonOption).getDynamicFrame()
// Write DynamicFrame to DocumentDB
glueContext.getSink("documentdb", writeJsonOption).writeDynamicFrame(resultFrame2)
Job.commit()
}
private def jsonOptions(uri: String): JsonOptions = {
new JsonOptions(
s"""{"uri": "${uri}",
|"database":"test",
|"collection":"coll",
|"username": "username",
|"password": "pwd",
|"ssl":"true",
|"ssl.domain_match":"false",
|"partitioner": "MongoSamplePartitioner",
|"partitionerOptions.partitionSizeMB": "10",
|"partitionerOptions.partitionKey": "_id"}""".stripMargin)
}
}
```
## Indicazioni di riferimento alle opzioni di connessione ad Amazon DocumentDB
Indica una connessione ad Amazon DocumentDB (con compatibilità MongoDB).
Le opzioni di connessione differiscono per una connessione sorgente e una connessione sink.
### "connectionType": "documentdb" come sorgente
Utilizzare le seguenti opzioni di connessione con `"connectionType": "documentdb"` come origine:
+ `"uri"`: (obbligatorio) l'host Amazon DocumentDB da cui leggere, formattato come `mongodb://:`.
+ `"database"`: (Obbligatorio) il database di Amazon DocumentDB da cui leggere.
+ `"collection"`: (Obbligatorio) la raccolta di Amazon DocumentDB da cui leggere.
+ `"username"`: (Obbligatorio) il nome utente di Amazon DocumentDB.
+ `"password"`: (Obbligatorio) la password di Amazon DocumentDB.
+ `"ssl"`: (Obbligatorio se si utilizza SSL) se la connessione utilizza SSL, è necessario includere questa opzione con il valore `"true"`.
+ `"ssl.domain_match"`: (Obbligatorio se si utilizza SSL) se la connessione utilizza SSL, è necessario includere questa opzione con il valore `"false"`.
+ `"batchSize"`: (Facoltativo): il numero di documenti da restituire per ogni batch, utilizzato all'interno del cursore dei batch interni.
+ `"partitioner"`: (Facoltativo): il nome della classe del partizionatore per la lettura dei dati di input da Amazon DocumentDB. Il connettore fornisce i seguenti partizionatori:
+ `MongoDefaultPartitioner`(impostazione predefinita) (non supportato in AWS Glue 4.0)
+ `MongoSamplePartitioner`(Non supportato in AWS Glue 4.0)
+ `MongoShardedPartitioner`
+ `MongoSplitVectorPartitioner`
+ `MongoPaginateByCountPartitioner`
+ `MongoPaginateBySizePartitioner`(Non supportato in AWS Glue 4.0)
+ `"partitionerOptions"` ( Facoltativo): opzioni per il partizionatore designato. Per ogni partizionatore sono supportate le seguenti opzioni:
+ `MongoSamplePartitioner`: `partitionKey`, `partitionSizeMB`, `samplesPerPartition`
+ `MongoShardedPartitioner`: `shardkey`
+ `MongoSplitVectorPartitioner`: `partitionKey`, partitionSizeMB
+ `MongoPaginateByCountPartitioner`: `partitionKey`, `numberOfPartitions`
+ `MongoPaginateBySizePartitioner`: `partitionKey`, partitionSizeMB
Per ulteriori informazioni su queste opzioni, vedere [Partitioner Configuration (Configurazione partizionatore)](https://docs.mongodb.com/spark-connector/master/configuration/#partitioner-conf) nella documentazione di MongoDB.
### "connectionType": "documentdb" come sink
Utilizzare le seguenti opzioni di connessione con `"connectionType": "documentdb"` come sink:
+ `"uri"`: (Obbligatorio) l'host Amazon DocumentDB su cui scrivere, formattato come `mongodb://:`.
+ `"database"`: (Obbligatorio) il database di Amazon DocumentDB su cui scrivere.
+ `"collection"`: (Obbligatorio) la raccolta di Amazon DocumentDB su cui scrivere.
+ `"username"`: (Obbligatorio) il nome utente di Amazon DocumentDB.
+ `"password"`: (Obbligatorio) la password di Amazon DocumentDB.
+ `"extendedBsonTypes"`: (Facoltativo) se il valore è `true`, abilita i tipi BSON estesi durante la scrittura dei dati su Amazon DocumentDB. Il valore predefinito è `true`.
+ `"replaceDocument"`: (Facoltativo) Se il valore è `true`, sostituisce l'intero documento quando si salvano set di dati che contengono un campo `_id`. Se il valore è `false`, vengono aggiornati solo i campi del documento che corrispondono ai campi del set di dati. Il valore predefinito è `true`.
+ `"maxBatchSize"`: (Facoltativo): la dimensione massima del batch per le operazioni in blocco durante il salvataggio dei dati. Il valore predefinito è 512.
+ `"retryWrites"`: (Facoltativo): Riprova automaticamente alcune operazioni di scrittura una sola volta se AWS Glue rileva un errore di rete.