Conexões do MongoDB

O AWS Glue para Spark pode ser usado para ler e gravar em tabelas no MongoDB e MongoDB Atlas no AWS Glue 4.0 e versões posteriores. Conecte-se ao MongoDB usando credenciais de nome de usuário e senha armazenadas no AWS Secrets Manager via conexão do AWS Glue.

Para obter mais informações sobre o MongoDB, consulte a Documentação do MongoDB.

Configurar conexões do MongoDB

Para se conectar ao MongoDB via AWS Glue, você precisará de suas credenciais do MongoDB, mongodbUser e mongodbPass.

Para se conectar ao MongoDB via AWS Glue, talvez seja necessário atender a alguns pré-requisitos:

• Se a sua instância do MongoDB estiver em uma Amazon VPC, configure a Amazon VPC para permitir que seu trabalho do AWS Glue se comunique com a instância do MongoDB sem que o tráfego passe pela Internet pública.

  Na Amazon VPC, identifique ou crie uma VPC, uma Sub-rede e um Grupo de segurança que o AWS Glue usará durante a execução do trabalho. Além disso, você precisa garantir que a Amazon VPC esteja configurada para permitir o tráfego de rede entre sua instância do MongoDB e esse local. Com base no layout da rede, isso pode exigir alterações em regras do grupo de segurança, ACLs de rede, gateways de NAT e conexões de emparelhamento.

Em seguida, você pode continuar com a configuração do AWS Glue para usá-lo com o MongoDB.

Para configurar uma conexão com o MongoDB:

1. Opcionalmente, no AWS Secrets Manager, crie um segredo usando suas credenciais do MongoDB. Para criar um segredo no Secrets Manager, siga o tutorial disponível em Criar uma AWS Secrets Manager segredo na documentação do AWS Secrets Manager. Depois de criar o segredo, guarde o nome secreto, SecretName, para a próxima etapa.

   • Ao selecionar Pares chave/valor, crie um par para a chave username com o valor mongodbUser.

     Ao selecionar Pares chave/valor, crie um par para a chave password com o valor mongodbPass.

2. No console do AWS Glue, crie uma conexão seguindo as etapas em Adicionar uma conexão do AWS Glue. Depois de criar a conexão, guarde o nome da conexão, connectionName, para uso futuro no AWS Glue.

   • Ao selecionar um Tipo de conexão, selecione MongoDB ou MongoDB Atlas.

   • Ao selecionar o URL do MongoDB ou o URL do MongoDB Atlas, forneça o nome de host da sua instância do MongoDB.

     Um URL do MongoDB é fornecido no formato mongodb://mongoHost:mongoPort/mongoDBname.

     Um URL do MongoDB Atlas é fornecido no formato mongodb+srv://mongoHost:mongoPort/mongoDBname.

     Fornecer o banco de dados padrão mongoDBname para a conexão é opcional.

   • Se você optar por criar um segredo do Secrets Manager, escolha o Tipo de credencial do AWS Secrets Manager.

     Em seguida, em Segredo do AWS, forneça o secretName.

   • Se você optar por fornecer Nome de usuário e senha, forneça também o mongodbUser e o mongodbPass.

3. Nas seguintes situações, configurações adicionais podem ser necessárias:

   • Para instâncias do MongoDB hospedadas na AWS em uma Amazon VPC

     • Será necessário fornecer informações de conexão da Amazon VPC à conexão do AWS Glue que define suas credenciais de segurança do MongoDB. Ao criar ou atualizar sua conexão, defina VPC, Sub-rede e Grupos de segurança em Opções de rede.

Depois de criar uma conexão AWS Glue MongoDB, siga estas etapas a seguir antes de chamar seu método de conexão.

• Se você optar por criar um segredo do Secrets Manager, conceda ao perfil do IAM associado ao seu trabalho do AWS Glue permissão para ler secretName.

• Na configuração do trabalho do AWS Glue, forneça connectionName como uma conexão de rede adicional.

Para usar sua conexão AWS Glue MongoDB no AWS Glue para Spark, forneça a opção connectionName na chamada ao método de conexão. Como alternativa, você pode seguir as etapas Trabalhar com conexões MongoDB em trabalhos de ETL para usar a conexão em conjunto com o AWS Glue Data Catalog.

Ler do MongoDB usando uma conexão do AWS Glue

Pré-requisitos:

• Uma coleção do MongoDB da qual você gostaria de ler. Você precisará de informações de identificação para a coleção.

  Uma coleção do MongoDB é identificada por um nome de banco de dados e um nome de coleção, mongodbName e mongodbCollection.

• Uma conexão AWS Glue MongoDB configurada para fornecer informações de autenticação. Conclua as etapas do procedimento anterior, Para configurar uma conexão com o MongoDB para configurar suas informações de autenticação. Você precisará do nome da conexão AWS Glue, ConnectionName.

Por exemplo:

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

Escrever em tabelas do MongoDB

Este exemplo escreve informações de um DynamicFrame existente, dynamicFrame, no MongoDB.

Pré-requisitos:

• Uma coleção do MongoDB na qual você gostaria de escrever. Você precisará de informações de identificação para a coleção.

  Uma coleção do MongoDB é identificada por um nome de banco de dados e um nome de coleção, mongodbName e mongodbCollection.

• Uma conexão AWS Glue MongoDB configurada para fornecer informações de autenticação. Conclua as etapas do procedimento anterior, Para configurar uma conexão com o MongoDB para configurar suas informações de autenticação. Você precisará do nome da conexão AWS Glue, ConnectionName.

Por exemplo:

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

Leitura e escrita em tabelas no MongoDB

Este exemplo escreve informações de um DynamicFrame existente, dynamicFrame, no MongoDB.

Pré-requisitos:

• Uma coleção do MongoDB da qual você gostaria de ler. Você precisará de informações de identificação para a coleção.

  Uma coleção do MongoDB na qual você gostaria de escrever. Você precisará de informações de identificação para a coleção.

  Uma coleção do MongoDB é identificada por um nome de banco de dados e um nome de coleção, mongodbName e mongodbCollection.

• Informações de autenticação do MongoDB, mongodbUser e mongodbPassword.

Por exemplo:

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

Referência de opções de conexão do MongoDB

Designa uma conexão com o MongoDB. As opções de conexão diferem para uma conexão da fonte e uma conexão do coletor.

Essas propriedades de conexão são compartilhadas entre as conexões de origem e coletor:

• connectionName: usado para leitura/gravação. O nome de uma conexão do AWS Glue MongoDB configurada para fornecer informações de autenticação e rede ao seu método de conexão. Quando uma conexão do AWS Glue é configurada conforme descrito na seção Configurar conexões do MongoDB anterior, fornecer connectionName substituirá a necessidade de fornecer as opções de conexão "uri", "username" e "password".

• "uri": (obrigatório) o host do MongoDB do qual fazer a leitura, formatado como mongodb://<host>:<port>. Usado nas versões do AWS Glue anteriores ao AWS Glue 4.0.

• "connection.uri": (obrigatório) o host do MongoDB do qual fazer a leitura, formatado como mongodb://<host>:<port>. Usado no AWS Glue 4.0 e versões posteriores.

• "username": (obrigatório) o nome de usuário do MongoDB.

• "password": (obrigatório) a senha do MongoDB.

• "database": (obrigatório) o banco de dados MongoDB do qual fazer a leitura. Essa opção também pode ser passada em additional_options ao chamar glue_context.create_dynamic_frame_from_catalog em seu script de trabalho.

• "collection": (obrigatório) a coleção do MongoDB da qual fazer a leitura. Essa opção também pode ser passada em additional_options ao chamar glue_context.create_dynamic_frame_from_catalog em seu script de trabalho.

“connectionType”: “mongodb” como fonte

Use as seguintes opções de conexão com "connectionType": "mongodb" como fonte:

• "ssl": (opcional) se for true, iniciará uma conexão SSL. O padrão é false.

• "ssl.domain_match": (opcional) se for true e se ssl for true, será realizada a verificação de correspondência do domínio. O padrão é true.

• "batchSize": (opcional) o número de documentos que devem ser retornados por lote, usado no cursor de lotes internos.

• "partitioner": (opcional) o nome da classe do particionador do qual fazer a leitura de dados de entrada do MongoDB. O conector fornece os seguintes particionadores:

  • MongoDefaultPartitioner (padrão) (sem suporte no AWS Glue 4.0)

  • MongoSamplePartitioner (requer o MongoDB 3.2 ou posterior) (Sem suporte no AWS Glue 4.0)

  • MongoShardedPartitioner (sem suporte no AWS Glue 4.0)

  • MongoSplitVectorPartitioner (sem suporte no AWS Glue 4.0)

  • MongoPaginateByCountPartitioner (sem suporte no AWS Glue 4.0)

  • MongoPaginateBySizePartitioner (sem suporte no 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) opções para o particionador designado. As seguintes opções são compatíveis com cada particionador:

  • MongoSamplePartitioner: partitionKey, partitionSizeMB, samplesPerPartition

  • MongoShardedPartitioner: shardkey

  • MongoSplitVectorPartitioner: partitionKey, partitionSizeMB

  • MongoPaginateByCountPartitioner: partitionKey, numberOfPartitions

  • MongoPaginateBySizePartitioner: partitionKey, partitionSizeMB

  Para obter mais informações sobre essas opções, consulte Partitioner Configuration na documentação do MongoDB.

“connectionType”: “mongodb” como coletor

Use as seguintes opções de conexão com "connectionType": "mongodb" como coletor:

• "ssl": (opcional) se for true, iniciará uma conexão SSL. O padrão é false.

• "ssl.domain_match": (opcional) se for true e se ssl for true, será realizada a verificação de correspondência do domínio. O padrão é true.

• "extendedBsonTypes": (opcional) se for true, permite tipos de BSON estendidos ao gravar dados no MongoDB. O padrão é true.

• "replaceDocument": (opcional) se for true, substituirá todo o documento ao salvar conjuntos de dados que contêm um campo _id. Se for false, serão atualizados somente os campos do documento que correspondam aos campos do conjunto de dados. O padrão é true.

• "maxBatchSize": (opcional) o tamanho máximo do lote para operações em massa ao salvar dados. O padrão é 512.

• "retryWrites": (Opcional): repita automaticamente determinadas operações de escrita uma única vez se o AWS Glue encontrar um erro de rede.