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 MongoDB Puoi usare AWS Glue for Spark per leggere e scrivere su tabelle in MongoDB e MongoDB Atlas in Glue 4.0 e versioni successive AWS . È possibile connettersi a MongoDB utilizzando le credenziali di nome utente e password archiviate tramite una connessione Glue. Gestione dei segreti AWS AWS Per ulteriori informazioni su MongoDB, consulta [la documentazione di MongoDB](https://www.mongodb.com/docs/). ## Configurazione delle connessioni MongoDB Per connetterti a MongoDB AWS da Glue, avrai bisogno delle tue credenziali MongoDB e. *mongodbUser* *mongodbPass* Per connetterti a MongoDB AWS da Glue, potresti aver bisogno di alcuni prerequisiti: + Se la tua istanza MongoDB si trova in un Amazon VPC, configura Amazon VPC per consentire al job Glue di comunicare con l'istanza MongoDB senza che AWS il traffico attraversi la rete Internet pubblica. In Amazon VPC, identifica o crea un **VPC**, una **sottorete** e un **gruppo di sicurezza che** AWS Glue utilizzerà durante l'esecuzione del lavoro. Inoltre, assicurati che Amazon VPC sia configurato per consentire il traffico di rete tra l'istanza MongoDB e questa posizione. In base al layout della rete, ciò potrebbe richiedere modifiche alle regole del gruppo di sicurezza, alla rete ACLs, ai gateway NAT e alle connessioni peering. Puoi quindi procedere alla configurazione di AWS Glue per l'uso con MongoDB. **Per configurare una connessione a MongoDB:** 1. Facoltativamente Gestione dei segreti AWS, crea un segreto usando le tue credenziali MongoDB. Per creare un segreto in Secrets Manager, segui il tutorial disponibile in [Crea un Gestione dei segreti AWS segreto](https://docs.aws.amazon.com//secretsmanager/latest/userguide/create_secret.html) nella Gestione dei segreti AWS documentazione. Dopo aver creato il segreto, mantieni il nome del segreto *secretName* per il passaggio successivo. + Quando selezionate le **coppie chiave/valore**, create una coppia per la chiave `username` con il valore. *mongodbUser* Quando selezionate le **coppie chiave/valore**, create una coppia per la chiave `password` con il valore. *mongodbPass* 1. Nella console AWS Glue, crea una connessione seguendo i passaggi riportati di seguito[Aggiungere una AWS Glue connessione](console-connections.md). Dopo aver creato la connessione, mantieni il nome della connessione*connectionName*, per utilizzi futuri in AWS Glue. + Quando selezioni un **tipo di connessione**, seleziona **MongoDB** o **MongoDB Atlas**. + Quando selezioni l'**URL MongoDB** o **URL MongoDB Atlas**, fornisci il nome host dell'istanza MongoDB. Un URL MongoDB viene fornito nel formato `mongodb://mongoHost:mongoPort/mongoDBname`. Un URL MongoDB Atlas viene fornito nel formato `mongodb+srv://mongoHost/mongoDBname`. + Se hai scelto di creare un segreto di Secrets Manager, scegli il **tipo di Gestione dei segreti AWS credenziale**. Quindi, in **AWS Secret** fornisci*secretName*. + Se scegli di fornire **nome utente e password**, fornisci *mongodbUser* e*mongodbPass*. 1. Nelle seguenti situazioni, potresti aver bisogno di una configurazione aggiuntiva: + Per le istanze MongoDB ospitate su AWS un Amazon VPC + Dovrai fornire le informazioni di connessione Amazon VPC alla connessione AWS Glue che definisce le tue credenziali di sicurezza MongoDB. Durante la creazione o l'aggiornamento della connessione, imposta **VPC**, **sottorete** e **Gruppi di sicurezza** nelle **opzioni di rete**. Dopo aver creato una connessione AWS Glue MongoDB, dovrai eseguire le seguenti azioni prima di chiamare il tuo metodo di connessione: + Se hai scelto di creare un segreto di Secrets Manager, concedi al ruolo IAM associato al tuo lavoro AWS Glue il permesso di lettura*secretName*. + Nella configurazione del lavoro AWS Glue, fornisci *connectionName* una **connessione di rete aggiuntiva**. Per utilizzare la tua connessione AWS Glue MongoDB in AWS Glue for Spark, fornisci `connectionName` l'opzione nella chiamata al metodo di connessione. In alternativa, puoi seguire i passaggi [Lavorare con le connessioni MongoDB nei processi ETL](integrate-with-mongo-db.md) per utilizzare la connessione insieme al AWS Glue Data Catalog. ## Lettura da MongoDB utilizzando una connessione Glue AWS **Prerequisiti:** + Una raccolta MongoDB da cui desideri leggere. Avrai bisogno delle informazioni di identificazione per la raccolta. Una raccolta MongoDB è identificata da un nome di database e da un nome di raccolta,,. *mongodbName* *mongodbCollection* + Una connessione AWS Glue MongoDB configurata per fornire informazioni di autenticazione. Completa i passaggi della procedura precedente, *Per configurare una connessione a MongoDB* per configurare le informazioni di autenticazione. Avrai bisogno del nome della connessione AWS Glue,*connectionName*. Esempio: ``` mongodb_read = glueContext.create_dynamic_frame.from_options( connection_type="mongodb", connection_options={ "connectionName": "connectionName", "database": "mongodbName", "collection": "mongodbCollection", "partitioner": "com.mongodb.spark.sql.connector.read.partitioner.SinglePartitionPartitioner", "partitionerOptions.partitionSizeMB": "10", "partitionerOptions.partitionKey": "_id", "disableUpdateUri": "false", } ) ``` ## Scrittura su tabelle MongoDB Questo esempio scrive informazioni da un file esistente DynamicFrame *dynamicFrame* a MongoDB. **Prerequisiti:** + Una raccolta MongoDB su cui desideri scrivere. Avrai bisogno delle informazioni di identificazione per la raccolta. Una raccolta MongoDB è identificata da un nome di database e da un nome di raccolta,,. *mongodbName* *mongodbCollection* + Una connessione AWS Glue MongoDB configurata per fornire informazioni di autenticazione. Completa i passaggi della procedura precedente, *Per configurare una connessione a MongoDB* per configurare le informazioni di autenticazione. Avrai bisogno del nome della connessione AWS Glue,*connectionName*. Esempio: ``` glueContext.write_dynamic_frame.from_options( frame=dynamicFrame, connection_type="mongodb", connection_options={ "connectionName": "connectionName", "database": "mongodbName", "collection": "mongodbCollection", "disableUpdateUri": "false", "retryWrites": "false", }, ) ``` ## Lettura e scrittura in tabelle su tabelle MongoDB Questo esempio scrive informazioni da un file esistente DynamicFrame *dynamicFrame* a MongoDB. **Prerequisiti:** + Una raccolta MongoDB da cui desideri leggere. Avrai bisogno delle informazioni di identificazione per la raccolta. Una raccolta MongoDB su cui desideri scrivere. Avrai bisogno delle informazioni di identificazione per la raccolta. Una raccolta MongoDB è identificata da un nome di database e da un nome di raccolta,,. *mongodbName* *mongodbCollection* + Informazioni di autenticazione MongoDB e. *mongodbUser* *mongodbPassword* Esempio: ------ #### [ Python ] ``` 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()) + "/" mongo_uri = "mongodb://:27017" mongo_ssl_uri = "mongodb://:27017" write_uri = "mongodb://:27017" read_mongo_options = { "uri": mongo_uri, "database": "mongodbName", "collection": "mongodbCollection", "username": "mongodbUsername", "password": "mongodbPassword", "partitioner": "MongoSamplePartitioner", "partitionerOptions.partitionSizeMB": "10", "partitionerOptions.partitionKey": "_id"} ssl_mongo_options = { "uri": mongo_ssl_uri, "database": "mongodbName", "collection": "mongodbCollection", "ssl": "true", "ssl.domain_match": "false" } write_mongo_options = { "uri": write_uri, "database": "mongodbName", "collection": "mongodbCollection", "username": "mongodbUsername", "password": "mongodbPassword", } # Get DynamicFrame from MongoDB dynamic_frame = glueContext.create_dynamic_frame.from_options(connection_type="mongodb", connection_options=read_mongo_options) # Write DynamicFrame to MongoDB glueContext.write_dynamic_frame.from_options(dynamicFrame, connection_type="mongodb", connection_options=write_mongo_options) job.commit() ``` ------ #### [ Scala ] ``` 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 DEFAULT_URI: String = "mongodb://:27017" val WRITE_URI: String = "mongodb://:27017" lazy val defaultJsonOption = jsonOptions(DEFAULT_URI) lazy val writeJsonOption = jsonOptions(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 MongoDB val dynamicFrame: DynamicFrame = glueContext.getSource("mongodb", defaultJsonOption).getDynamicFrame() // Write DynamicFrame to MongoDB glueContext.getSink("mongodb", writeJsonOption).writeDynamicFrame(dynamicFrame) Job.commit() } private def jsonOptions(uri: String): JsonOptions = { new JsonOptions( s"""{"uri": "${uri}", |"database":"mongodbName", |"collection":"mongodbCollection", |"username": "mongodbUsername", |"password": "mongodbPassword", |"ssl":"true", |"ssl.domain_match":"false", |"partitioner": "MongoSamplePartitioner", |"partitionerOptions.partitionSizeMB": "10", |"partitionerOptions.partitionKey": "_id"}""".stripMargin) } } ``` ------ ## Indicazioni di riferimento alle opzioni di connessione a MongoDB Designa una connessione a MongoDB. Le opzioni di connessione differiscono per una connessione sorgente e una connessione sink. Queste proprietà di connessione sono condivise tra le connessioni di origine e sink: + `connectionName`: utilizzato per la lettura/scrittura. Il nome di una connessione AWS Glue MongoDB configurata per fornire informazioni di autenticazione e di rete al metodo di connessione. Quando una connessione AWS Glue è configurata come descritto nella sezione precedente[Configurazione delle connessioni MongoDB](#aws-glue-programming-etl-connect-mongodb-configure), la fornitura `connectionName` sostituirà la necessità di fornire le `"uri"` opzioni di `"password"` connessione `"username"` e. + `"uri"`: (Obbligatorio) L'host MongoDB da cui leggere, formattato come `mongodb://:`. Utilizzato nelle versioni AWS Glue precedenti a AWS Glue 4.0. + `"connection.uri"`: (Obbligatorio) L'host MongoDB da cui leggere, formattato come `mongodb://:`. Utilizzato in AWS Glue 4.0 e versioni successive. + `"username"`: (Obbligatorio) Il nome utente MongoDB. + `"password"`: (Obbligatorio) La password di MongoDB. + `"database"`: (Obbligatorio) Il database MongoDB da cui leggere. Questa opzione può anche essere trasmessa in `additional_options` quando si chiama `glue_context.create_dynamic_frame_from_catalog` nello script di processo. + `"collection"`: (Obbligatorio) La raccolta MongoDB da cui leggere. Questa opzione può anche essere trasmessa in `additional_options` quando si chiama `glue_context.create_dynamic_frame_from_catalog` nello script di processo. ### "connectionType": "mongodb" come sorgente Utilizzare le seguenti opzioni di connessione con `"connectionType": "mongodb"` come origine: + `"ssl"`: (Facoltativo) Se il valore è `true`, avvia una connessione SSL. Il valore predefinito è `false`. + `"ssl.domain_match"`: (Facoltativo) Se i valori `true` e `ssl` sono `true`, viene eseguito il controllo della corrispondenza del dominio. Il valore predefinito è `true`. + `"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 MongoDB. Il connettore fornisce i seguenti partizionatori: + `MongoDefaultPartitioner`(impostazione predefinita) (non supportato in AWS Glue 4.0) + `MongoSamplePartitioner`(Richiede MongoDB 3.2 o successivo) (non supportato in AWS Glue 4.0) + `MongoShardedPartitioner`(Non supportato in AWS Glue 4.0) + `MongoSplitVectorPartitioner`(Non supportato in AWS Glue 4.0) + `MongoPaginateByCountPartitioner`(Non supportato in AWS Glue 4.0) + `MongoPaginateBySizePartitioner`(Non supportato in AWS Glue 4.0) + `com.mongodb.spark.sql.connector.read.partitioner.SinglePartitionPartitioner` + `com.mongodb.spark.sql.connector.read.partitioner.ShardedPartitioner` + `com.mongodb.spark.sql.connector.read.partitioner.PaginateIntoPartitionsPartitioner` + `"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": "mongodb" come sink Utilizzare le seguenti opzioni di connessione con `"connectionType": "mongodb"` come sink: + `"ssl"`: (Facoltativo) Se il valore è `true`, avvia una connessione SSL. Il valore predefinito è `false`. + `"ssl.domain_match"`: (Facoltativo) Se i valori `true` e `ssl` sono `true`, viene eseguito il controllo della corrispondenza del dominio. Il valore predefinito è `true`. + `"extendedBsonTypes"`: (Facoltativo) Se il valore è`true`, permette i tipi BSON estesi durante la scrittura di dati su MongoDB. 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.