Conexiones a MongoDB - AWS Glue
Configuración de MongoDBLea desde MongoDBEscriba en MongoDBEscriba y lea en MongoDBConexión a MongoDB

Conexiones a MongoDB

Puede usar AWS Glue for Spark para leer y escribir en tablas de MongoDB y MongoDB Atlas en AWS Glue 4.0 y versiones posteriores. Puede conectarse a MongoDB con las credenciales de nombre de usuario y contraseña almacenadas en AWS Secrets Manager a través de una conexión de AWS Glue.

Para obtener más información sobre MongoDB, consulte la documentación de MongoDB.

Configuración de las conexiones MongoDB

Para conectarte a MongoDB desde AWS Glue, necesitará sus credenciales de MongoDB, mongodbUser y mongodbPass.

Para conectarse a MongoDB desde AWS Glue, es posible que necesite algunos requisitos previos:

  • Si su instancia de MongoDB está en una Amazon VPC, configure Amazon VPC para permitir que su trabajo de AWS Glue se comunique con la instancia de MongoDB sin que el tráfico atraviese la Internet pública.

    En Amazon VPC, identifique o cree una VPC, una subred y un grupo de seguridad que AWS Glue utilizará al ejecutar el trabajo. Además, debe asegurarse de que Amazon VPC esté configurada para permitir el tráfico de red entre su instancia de MongoDB y esta ubicación. Según el diseño de la red, esto puede requerir cambios en las reglas de los grupos de seguridad, las ACL de red, las puertas de enlace de NAT y las conexiones entre pares.

A continuación, puede proceder a configurar AWS Glue para su uso con MongoDB.

Para configurar una conexión a MongoDB:

  1. Si lo desea, en AWS Secrets Manager, cree un secreto con sus credenciales de MongoDB. Para crear un secreto en Secrets Manager, siga el tutorial disponible en Crear un secreto AWS Secrets Manager en la documentación AWS Secrets Manager. Después de crear el secreto, conserve el nombre secreto, secretName, para el siguiente paso.

    • Al seleccionar pares clave/valor, genere un par para la clave username con el valor mongodbUser.

      Al seleccionar pares clave/valor, genere un par para la clave password con el valor mongodbPass.

  2. En la consola de AWS Glue, genere una conexión mediante los pasos que se indican en Adición de una conexión de AWS Glue. Tras crear la conexión, conserve el nombre de la conexión, connectionName, para el uso futuro en AWS Glue.

    • Al seleccionar un tipo de conexión, seleccione MongoDB o MongoDB Atlas.

    • Al seleccionar la URL de MongoDB o la URL de MongoDB Atlas, proporciona el nombre de host de la instancia de MongoDB.

      Se proporciona una URL de MongoDB en este formato mongodb://mongoHost:mongoPort/mongoDBname.

      Se proporciona una URL de MongoDB Atlas en este formato mongodb+srv://mongoHost:mongoPort/mongoDBname.

      Proporcionar la base de datos predeterminada para la conexión, mongoDBname es opcional.

    • Si eligió crear un secreto de Secrets Manager, elija el tipo de credencial AWS Secrets Manager.

      Luego, en AWS Secret, ingrese secretName.

    • Si decide proporcionar el nombre de usuario y la contraseña, proporcione mongoDBuser y mongodbPass.

  3. En las siguientes situaciones, es posible que necesite una configuración adicional:

    • Para instancias de MongoDB alojadas AWS en una Amazon VPC

      • Deberá proporcionar la información de conexión de Amazon VPC a la conexión AWS Glue que define sus credenciales de seguridad de MongoDB. Al crear o actualizar la conexión, configure los VPC, Subred y los grupos de seguridad en Opciones de red.

Tras crear una conexión AWS Glue MongoDB, tendrá que realizar las siguientes acciones antes de llamar a su método de conexión:

  • Si ha decidido crear un secreto de Secrets Manager, conceda permiso al rol de IAM asociado a su trabajo de AWS Glue para leer secretName.

  • En la configuración del trabajo de Glue AWS, proporcione connectionName como una conexión de red adicional.

Para usar su conexión AWS Glue MongoDB en AWS Glue for Spark, proporcione la opción connectionName en su llamada al método de conexión. Como alternativa, puede seguir los pasos que se describen en Trabajar con conexiones MongoDB en trabajos de ETL para utilizar la conexión junto con el catálogo de datos de AWS Glue.

Lectura de MongoDB mediante una conexión a AWS Glue

Requisitos previos:

  • Una colección de MongoDB de la que quiera leer. Necesitará información de identificación para la colección.

    Una colección MongoDB se identifica mediante un nombre de base de datos y un nombre de colección, mongodbName, mongodbCollection.

  • Una conexión AWS Glue MongoDB configurada para proporcionar información de autenticación. Complete los pasos del procedimiento anterior, Para configurar una conexión a MongoDB para configurar su información de autenticación. Necesitará el nombre de la conexión de AWS Glue, connectionName.

Por ejemplo: 

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",
    }
)

Escribir en tablas de MongoDB

En este ejemplo se escribe información de un DynamicFrame existente, dynamicFrame en MongoDB.

Requisitos previos:

  • Una colección de MongoDB a la que desearía escribir. Necesitará información de identificación para la colección.

    Una colección MongoDB se identifica mediante un nombre de base de datos y un nombre de colección, mongodbName, mongodbCollection.

  • Una conexión AWS Glue MongoDB configurada para proporcionar información de autenticación. Complete los pasos del procedimiento anterior, Para configurar una conexión a MongoDB para configurar su información de autenticación. Necesitará el nombre de la conexión de AWS Glue, connectionName.

Por ejemplo: 

glueContext.write_dynamic_frame.from_options(
    frame=dynamicFrame,
    connection_type="mongodb",
    connection_options={
        "connectionName": "connectionName",
        "database": "mongodbName",
        "collection": "mongodbCollection",
        "disableUpdateUri": "false",
        "retryWrites": "false", 
    },
)

Leer y escribir en tablas de MongoDB

En este ejemplo se escribe información de un DynamicFrame existente, dynamicFrame en MongoDB.

Requisitos previos:

  • Una colección de MongoDB de la que quiera leer. Necesitará información de identificación para la colección.

    Una colección de MongoDB a la que desearía escribir. Necesitará información de identificación para la colección.

    Una colección MongoDB se identifica mediante un nombre de base de datos y un nombre de colección, mongodbName, mongodbCollection.

  • Información de autenticación de MongoDB, mongodbUser y mongodbPassword.

Por ejemplo:

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://<mongo-instanced-ip-address>:27017"
mongo_ssl_uri = "mongodb://<mongo-instanced-ip-address>:27017"
write_uri = "mongodb://<mongo-instanced-ip-address>: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://<mongo-instanced-ip-address>:27017"
  val WRITE_URI: String = "mongodb://<mongo-instanced-ip-address>: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)
  }
}

Referencia de opciones de conexión de MongoDB

Designa una conexión a MongoDB. Las opciones de conexión son distintas entre una conexión de origen y una conexión de receptor.

Estas propiedades de conexión se comparten entre las conexiones de origen y de receptor:

  • connectionName: se utiliza para lectura/escritura. El nombre de una conexión AWS Glue MongoDB configurada para proporcionar información de autenticación y red a su método de conexión. Cuando se configura una conexión AWS Glue como se describe en la sección anterior, Configuración de las conexiones MongoDB, el suministro connectionName sustituirá la necesidad de proporcionar las opciones de conexión "uri", "username" y "password".

  • "uri": (obligatorio) el host de MongoDB del que se va a leer, con formato mongodb://<host>:<port>. Se utiliza en las versiones de AWS Glue anteriores a AWS Glue 4.0.

  • "connection.uri": (obligatorio) el host de MongoDB del que se va a leer, con formato mongodb://<host>:<port>. Es compatible con la versión AWS Glue 4.0 y posteriores.

  • "username": (obligatorio) el nombre de usuario de MongoDB.

  • "password": (obligatorio) la contraseña de MongoDB.

  • "database": (obligatorio) la base de datos de MongoDB de la que se va a leer. Esta opción también se puede transferir a additional_options al llamar a glue_context.create_dynamic_frame_from_catalog en su script de trabajo.

  • "collection": (obligatorio) la colección de MongoDB de la que se va a leer. Esta opción también se puede transferir a additional_options al llamar a glue_context.create_dynamic_frame_from_catalog en su script de trabajo.

"connectionType": "mongodb" como origen

Utilice las siguientes opciones de conexión con "connectionType": "mongodb" como origen:

  • "ssl": (opcional) si es true, inicia una conexión SSL. El valor predeterminado es false.

  • "ssl.domain_match": (opcional) si es true y ssl es true, se realiza la comprobación de coincidencia de dominio. El valor predeterminado es true.

  • "batchSize": (opcional): el número de documentos que se deben devolver por lote, que se utilizan dentro del cursor de lotes internos.

  • "partitioner": (opcional): el nombre de la clase del particionador para leer los datos de entrada de MongoDB. El conector proporciona los siguientes particionadores:

    • MongoDefaultPartitioner (predeterminado) (No compatible con AWS Glue 4.0)

    • MongoSamplePartitioner (Requiere MongoDB 3.2 o posterior) (No es compatible con AWS Glue 4.0)

    • MongoShardedPartitioner (No es compatible con AWS Glue 4.0)

    • MongoSplitVectorPartitioner (No es compatible con AWS Glue 4.0)

    • MongoPaginateByCountPartitioner (No es compatible con AWS Glue 4.0)

    • MongoPaginateBySizePartitioner (No es compatible con 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" ( opcional): opciones para el particionador designado. Se admiten las siguientes opciones para cada particionador:

    • MongoSamplePartitioner: partitionKey, partitionSizeMB, samplesPerPartition

    • MongoShardedPartitioner: shardkey

    • MongoSplitVectorPartitioner: partitionKey, partitionSizeMB

    • MongoPaginateByCountPartitioner: partitionKey, numberOfPartitions

    • MongoPaginateBySizePartitioner: partitionKey, partitionSizeMB

    Para obtener más información acerca de estas opciones, consulte Partitioner Configuration en la documentación de MongoDB.

"connectionType": "mongodb" como receptor

Utilice las siguientes opciones de conexión con "connectionType": "mongodb" como receptor:

  • "ssl": (opcional) si es true, inicia una conexión SSL. El valor predeterminado es false.

  • "ssl.domain_match": (opcional) si es true y ssl es true, se realiza la comprobación de coincidencia de dominio. El valor predeterminado es true.

  • "extendedBsonTypes": (opcional) si es true, habilitan los tipos de BSON ampliados al escribir datos en MongoDB. El valor predeterminado es true.

  • "replaceDocument": (opcional) si es true, reemplaza todo el documento al guardar conjuntos de datos que contienen un campo _id. Si es false, solo se actualizan los campos del documento que coinciden con los campos del conjunto de datos. El valor predeterminado es true.

  • "maxBatchSize": (opcional): el tamaño máximo del lote para operaciones en bloque al guardar datos. El valor predeterminado es 512.

  • "retryWrites": (Opcional): reintenta automáticamente determinadas operaciones de escritura una sola vez si AWS Glue detecta un error de red.