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 pour Spark pour lire et écrire dans des tables dans MongoDB et MongoDB Atlas dans la version 4.0 et ultérieure d'AWS Glue. Vous pouvez vous connecter à MongoDB à l’aide des informations d'identification (nom d'utilisateur et mot de passe) stockées dans 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, mongodbUser et mongodbPass.

Pour vous connecter à MongoDB depuis AWS Glue, vous aurez peut-être besoin de certaines conditions préalables :

  • 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 passer par 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 à utiliser avec MongoDB.

Pour configurer une connexion à MongoDB :

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

    • Lorsque vous sélectionnez Paires clé/valeur, créez une paire pour la clé username avec la valeur mongodbUser.

      Lorsque vous sélectionnez Paires clé/valeur, créez une paire pour la clé password avec la valeur mongodbPass.

  2. Dans la console AWS Glue, créez une connexion en suivant les étapes décrites dans Ajouter une AWS Glue connexion. Après avoir créé la connexion, conservez le nom de la connexion, connectionName, 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:mongoPort/mongoDBname.

      En fournissant la base de données par défaut pour la connexion, mongoDBname est facultatif.

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

      Ensuite, dans AWS Secret, saisissez secretName.

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

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

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

      • Vous devrez fournir les informations de connexion Amazon VPC à la connexion AWS Glue qui définit vos informations d'identification 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 devez effectuer les actions suivantes avant d'appeler votre méthode de connexion :

  • Si vous avez choisi de créer un secret Secrets Manager, accordez au rôle IAM associé à votre tâche AWS Glue l'autorisation de lire secretName.

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

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

Lecture à partir de MongoDB à l'aide d'une connexion Glue AWS

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 DynamicFrame existant, dynamicFrame, dans 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 DynamicFrame existant, dynamicFrame, dans 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.

  • Informations d'authentification MongoDB, mongodbUser et 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 la lecture/l'écriture. Nom d’une connexion AWS Glue Azure MongoDB configurée pour fournir des informations d'authentification et de mise en réseau à votre méthode de connexion. Lorsqu'une connexion AWS Glue est configurée comme décrit dans la section précédente, Configuration de connexions MongoDB, la fourniture du connectionName remplacera le besoin de fournir les options de connexion "uri", "username" et "password".

  • "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 les versions AWS Glue 4.0 et 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 une 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éessayer automatiquement certaines opérations d'écriture une seule fois si AWS Glue rencontre une erreur réseau.