View a markdown version of this page

Connexions MongoDB - AWS Glue
Configuration de MongoDBLecture à partir de MongoDBÉcrire dans MongoDBLire et écrire dans MongoDBConnexion MongoDB

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Connexions MongoDB

Vous pouvez utiliser AWS Glue for Spark pour lire et écrire dans des tables dans MongoDB et MongoDB Atlas dans AWS Glue 4.0 et versions ultérieures. Vous pouvez vous connecter à MongoDB à l'aide des informations d'identification par nom d'utilisateur et mot de passe stockées AWS Secrets Manager via une connexion AWS Glue.

Pour plus d'informations sur MongoDB, consultez la documentation MongoDB.

Configuration de connexions MongoDB

Pour vous connecter à MongoDB depuis AWS Glue, vous aurez besoin de vos informations d'identification MongoDB, etmongodbUser. mongodbPass

Pour vous connecter à MongoDB depuis AWS Glue, certaines conditions peuvent être requises :

  • Si votre instance MongoDB se trouve dans un Amazon VPC, configurez Amazon VPC pour permettre à votre tâche AWS Glue de communiquer avec l'instance MongoDB sans trafic via l'Internet public.

    Dans Amazon VPC, identifiez ou créez un VPC, un sous-réseau et un groupe de sécurité que AWS Glue utilisera lors de l'exécution de la tâche. En outre, vous devez vous assurer qu'Amazon VPC est configuré pour autoriser le trafic réseau entre votre instance MongoDB et cet emplacement. Selon la configuration de votre réseau, cela peut nécessiter des modifications des règles du groupe de sécurité, des ACL réseau, des passerelles NAT et des connexions d'appairage.

Vous pouvez ensuite configurer AWS Glue pour l'utiliser avec MongoDB.

Pour configurer une connexion à MongoDB :

  1. Si vous le souhaitez AWS Secrets Manager, créez un secret à l'aide de vos informations d'identification MongoDB. Pour créer un secret dans Secrets Manager, suivez le didacticiel disponible dans la section Créer un AWS Secrets Manager secret de la AWS Secrets Manager documentation. Après avoir créé le secret, conservez le nom du secret secretName pour l'étape suivante.

    • Lorsque vous sélectionnez des Key/value paires, créez une paire pour la clé username avec la valeurmongodbUser.

      Lorsque vous sélectionnez des Key/value paires, créez une paire pour la clé password avec la valeurmongodbPass.

  2. Dans la console AWS Glue, créez une connexion en suivant les étapes décrites dansAjouter une AWS Glue connexion. Après avoir créé la connexion, conservez le nom de la connexionconnectionName, pour une utilisation ultérieure dans AWS Glue.

    • Lorsque vous sélectionnez un type de connexion, sélectionnez MongoDB ou MongoDB Atlas.

    • Lorsque vous sélectionnez une URL MongoDB ou une URL MongoDB Atlas, indiquez le nom d'hôte de votre instance MongoDB.

      Une URL MongoDB est fournie au format mongodb://mongoHost:mongoPort/mongoDBname.

      Une URL MongoDB Atlas est fournie au format mongodb+srv://mongoHost/mongoDBname.

    • Si vous avez choisi de créer un secret Secrets Manager, choisissez le type AWS Secrets Manager d'identification.

      Ensuite, dans AWS Secret, fournissezsecretName.

    • Si vous choisissez de fournir un nom d'utilisateur et un mot de passe, indiquez mongodbUser etmongodbPass.

  3. Dans les situations suivantes, vous pouvez avoir besoin d'une configuration supplémentaire :

    • Pour les instances MongoDB hébergées sur AWS un Amazon VPC

      • Vous devrez fournir les informations de connexion Amazon VPC à la connexion AWS Glue qui définit vos informations de sécurité MongoDB. Lorsque vous créez ou mettez à jour votre connexion, définissez le VPC, le sous-réseau et les groupes de sécurité dans les options réseau.

Après avoir créé une connexion AWS Glue MongoDB, vous devrez effectuer les actions suivantes avant d'appeler votre méthode de connexion :

  • Si vous avez choisi de créer un secret Secrets Manager, autorisez le rôle IAM associé à votre job AWS Glue à liresecretName.

  • Dans la configuration de votre tâche AWS Glue, indiquez connectionName comme connexion réseau supplémentaire.

Pour utiliser votre connexion AWS Glue MongoDB dans AWS Glue for Spark, indiquez l'connectionNameoption dans l'appel de votre méthode de connexion. Vous pouvez également suivre les étapes décrites Utilisation des connexions MongoDB dans les tâches ETL pour utiliser la connexion conjointement avec le catalogue de données AWS Glue.

Lecture depuis MongoDB à l'aide d'un AWS Connexion par colle

Prérequis :

  • Une collection MongoDB à partir de laquelle vous souhaitez lire. Vous aurez besoin des informations d'identification pour la collection.

    Une collection MongoDB est identifiée par un nom de base de données et un nom de collection,mongodbName,mongodbCollection.

  • Une connexion AWS Glue MongoDB configurée pour fournir des informations d'authentification. Suivez les étapes de la procédure précédente Pour configurer une connexion à MongoDB afin de configurer vos informations d'authentification. Vous aurez besoin du nom de la connexion AWS Glue,connectionName.

Par exemple : 

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

Écrire dans des tables MongoDB

Cet exemple écrit des informations à partir d'un existant DynamicFrame dynamicFrame vers MongoDB.

Prérequis :

  • Une collection MongoDB sur laquelle vous souhaitez écrire. Vous aurez besoin des informations d'identification pour la collection.

    Une collection MongoDB est identifiée par un nom de base de données et un nom de collection,mongodbName,mongodbCollection.

  • Une connexion AWS Glue MongoDB configurée pour fournir des informations d'authentification. Suivez les étapes de la procédure précédente Pour configurer une connexion à MongoDB afin de configurer vos informations d'authentification. Vous aurez besoin du nom de la connexion AWS Glue,connectionName.

Par exemple : 

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

Lire et écrire dans des tables MongoDB

Cet exemple écrit des informations à partir d'un existant DynamicFrame dynamicFrame vers MongoDB.

Prérequis :

  • Une collection MongoDB à partir de laquelle vous souhaitez lire. Vous aurez besoin des informations d'identification pour la collection.

    Une collection MongoDB sur laquelle vous souhaitez écrire. Vous aurez besoin des informations d'identification pour la collection.

    Une collection MongoDB est identifiée par un nom de base de données et un nom de collection,mongodbName,mongodbCollection.

  • les informations d'authentification de MongoDB, etmongodbUser. mongodbPassword

Par exemple :

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

Référence des options de connexion MongoDB

Désigne une connexion à MongoDB. Les options de connexion sont différentes pour une connexion source et une connexion collecteur.

Les propriétés de connexion suivantes sont partagées entre les connexions source et récepteur :

  • connectionName— Utilisé pour Read/Write. Le nom d'une connexion AWS Glue MongoDB configurée pour fournir des informations d'authentification et de réseau à votre méthode de connexion. Lorsqu'une connexion AWS Glue est configurée comme décrit dans la section précédenteConfiguration de connexions MongoDB, la fourniture connectionName remplacera la nécessité de fournir "uri" les options de "password" connexion "username" et.

  • "uri": (Obligatoire) L'hôte MongoDB à lire, formaté comme mongodb://<host>:<port>. Utilisé dans les versions de AWS Glue antérieures à AWS Glue 4.0.

  • "connection.uri": (Obligatoire) L'hôte MongoDB à lire, formaté comme mongodb://<host>:<port>. Utilisé dans AWS Glue 4.0 et versions ultérieures.

  • "username" : (Obligatoire) Le nom d'utilisateur MongoDB.

  • "password" : (Obligatoire) Le mot de passe MongoDB.

  • "database": (Obligatoire) La base de données MongoDB à lire. Cette option peut également être transmise dans additional_options lors de l'appel à glue_context.create_dynamic_frame_from_catalog dans votre script de tâche.

  • "collection" : (Obligatoire) La collection MongoDB à lire. Cette option peut également être transmise dans additional_options lors de l'appel à glue_context.create_dynamic_frame_from_catalog dans votre script de tâche.

« connectionType »: « mongodb » comme source

Utilisez les options de connexion suivantes avec "connectionType": "mongodb" comme source :

  • "ssl" : (Facultatif) Si true, lance une connexion SSL. La valeur par défaut est false.

  • "ssl.domain_match" : (Facultatif) Si true et ssl est true, la vérification de la correspondance de domaine est effectuée. La valeur par défaut est true.

  • "batchSize" : (Facultatif) : Nombre de documents à renvoyer par lot, utilisé dans le curseur des lots internes.

  • "partitioner" : (Facultatif) : Le nom de classe du partitionneur pour lire les données d'entrée de MongoDB. Le connecteur fournit les partitionneurs suivants :

    • MongoDefaultPartitioner(par défaut) (Non pris en charge dans AWS Glue 4.0)

    • MongoSamplePartitioner(Nécessite MongoDB 3.2 ou version ultérieure) (Non pris en charge dans AWS Glue 4.0)

    • MongoShardedPartitioner(Non pris en charge dans AWS Glue 4.0)

    • MongoSplitVectorPartitioner(Non pris en charge dans AWS Glue 4.0)

    • MongoPaginateByCountPartitioner(Non pris en charge dans AWS Glue 4.0)

    • MongoPaginateBySizePartitioner(Non pris en charge dans 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" ( Facultatif) : Options pour le partitionneur désigné. Les options suivantes sont prises en charge pour chaque partitionneur :

    • MongoSamplePartitioner: partitionKey, partitionSizeMB, samplesPerPartition

    • MongoShardedPartitioner: shardkey

    • MongoSplitVectorPartitioner: partitionKey, partitionSizeMB

    • MongoPaginateByCountPartitioner: partitionKey, numberOfPartitions

    • MongoPaginateBySizePartitioner: partitionKey, partitionSizeMB

    Pour plus d'informations sur ces options, consultez Configuration du partitionneur dans la documentation MongoDB.

« connectionType »: « mongodb » comme collecteur

Utilisez les options de connexion suivantes avec "connectionType": "mongodb" comme collecteur :

  • "ssl" : (Facultatif) Si true, lance une connexion SSL. La valeur par défaut est false.

  • "ssl.domain_match" : (Facultatif) Si true et ssl est true, la vérification de la correspondance de domaine est effectuée. La valeur par défaut est true.

  • "extendedBsonTypes" : (facultatif) si la valeur est true, cela active les types BSON étendus lors de l'écriture de données dans MongoDB. La valeur par défaut est true.

  • "replaceDocument" : (Facultatif) Si true, remplace l'ensemble du document lors de l'enregistrement de jeux de données contenant un champ _id. Si false, seuls les champs du document qui correspondent aux champs du jeu de données sont mis à jour. La valeur par défaut est true.

  • "maxBatchSize" : (Facultatif) : Taille maximale du lot pour les opérations en bloc lors de l'enregistrement des données. La valeur par défaut est 512.

  • "retryWrites": (Facultatif) : Réessayez automatiquement certaines opérations d'écriture une seule fois si AWS Glue rencontre une erreur réseau.