MongoDB-Verbindungen - AWS Glue
Konfigurieren von MongoDBLesen aus MongoDBSchreiben in MongoDBLesen und Schreiben in MongoDBMongoDB-Verbindung

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

MongoDB-Verbindungen

Sie können AWS Glue für Spark zum Lesen und Schreiben in Tabellen in MongoDB und MongoDB Atlas in AWS Glue 4.0 und späteren Versionen verwenden. Sie können eine Verbindung zu MongoDB herstellen, indem Sie Benutzernamen und Passwörter verwenden, die über eine AWS-Glue-Verbindung in AWS Secrets Manager gespeichert sind.

Weitere Informationen über MongoDB finden Sie in der MongoDB-Dokumentation.

Konfigurieren von MongoDB-Verbindungen

Um von AWS Glue aus eine Verbindung zu MongoDB herzustellen, benötigen Sie Ihre MongoDB-Anmeldeinformationen, mongodbUser und mongodbPass.

Voraussetzungen zum Herstellen einer Verbindung von AWS Glue und MongoDB:

  • Wenn sich Ihre MongoDB-Instance in einer Amazon-VPC befindet, konfigurieren Sie Amazon VPC so, dass Ihr AWS-Glue-Auftrag mit der MongoDB-Instance kommunizieren kann, ohne dass der Datenverkehr über das öffentliche Internet übertragen wird.

    Identifizieren oder erstellen Sie in Amazon VPC eine VPC, ein Subnetz und eine Sicherheitsgruppe, die AWS Glue bei der Ausführung des Auftrags verwendet. Darüber hinaus muss Amazon VPC so konfiguriert sein, dass der Netzwerkdatenverkehr zwischen Ihrer MongoDB-Instance und diesem Standort zugelassen wird. Je nach Netzwerklayout kann dies Änderungen an den Sicherheitsgruppenregeln, Netzwerk-ACLs, NAT-Gateways und Peering-Verbindungen erfordern.

Sie können dann mit der Konfiguration von AWS Glue für die Verwendung mit MongoDB fortfahren.

Eine Verbindung zu MongoDB konfigurieren Sie wie folgt:

  1. Optional können Sie in AWS Secrets Manager ein Secret mit Ihren MongoDB-Anmeldeinformationen erstellen. Um ein Geheimnis im Secrets Manager zu erstellen, befolgen Sie das Tutorial unter Erstellen eines AWS Secrets Manager-Secrets in der AWS Secrets Manager-Dokumentation. Behalten Sie nach dem Erstellen des Secrets den Namen des Secrets, secretName für den nächsten Schritt bei.

    • Erstellen Sie bei der Auswahl von Schlüssel/Wert-Paaren ein Paar für den Schlüssel username mit dem Wert mongodbUser.

      Erstellen Sie bei der Auswahl von Schlüssel/Wert-Paaren ein Paar für den Schlüssel password mit dem Wert mongodbPass.

  2. Erstellen Sie in der AWS-Glue-Konsole eine Verbindung, indem Sie die Schritte in AWS Glue Verbindung hinzufügen befolgen. Behalten Sie nach dem Erstellen der Verbindung den Verbindungsnamen connectionName zur künftigen Verwendung in AWS Glue bei.

    • Wählen Sie als Verbindungstyp die Option MongoDB oder MongoDB Atlas aus.

    • Geben Sie als MongoDB-URL oder MongoDB-Atlas-URL den Hostnamen Ihrer MongoDB-Instance an.

      Eine MongoDB-URL wird im Format mongodb://mongoHost:mongoPort/mongoDBname bereitgestellt.

      Eine MongoDB-Atlas-URL wird im Format mongodb+srv://mongoHost:mongoPort/mongoDBname bereitgestellt.

      Der Wert mongoDBname gibt die Standarddatenbank für die Verbindung an und ist optional.

    • Wenn Sie ein Secrets-Manager-Secret erstellt haben, wählen Sie den Anmeldeinformationstyp für AWS Secrets Manager aus.

      Geben Sie dann im Feld AWS-Secret einen secretName ein.

    • Wenn Sie einen Benutzernamen und ein Passwort angeben, verwenden Sie mongodbUser und mongodbPass.

  3. In den folgenden Situationen ist möglicherweise eine zusätzliche Konfiguration erforderlich:

    • Für MongoDB-Instances in einer Amazon-VPC, die in AWS gehostet werden

      • Sie müssen Amazon-VPC-Verbindungsinformationen für die AWS-Glue-Verbindung eingeben, die Ihre MongoDB-Sicherheitsanmeldeinformationen definiert. Wenn Sie Ihre Verbindung erstellen oder aktualisieren, legen Sie VPC, Subnetz und Sicherheitsgruppen in den Netzwerkoptionen fest.

Nachdem Sie eine AWS-Glue-MongoDB-Verbindung hergestellt haben, müssen Sie die folgenden Aktionen ausführen, bevor Sie Ihre Verbindungsmethode aufrufen:

  • Wenn Sie ein Secrets-Manager-Secret erstellt haben, gewähren Sie der mit Ihrem AWS-Glue-Auftrag verknüpften IAM-Rolle die Berechtigung, secretName zu lesen.

  • Geben Sie in Ihrer AWS-Glue-Auftragskonfiguration connectionName als zusätzliche Netzwerkverbindung an.

Um Ihre Verbindung von AWS Glue und MongoDB in AWS Glue for Spark zu verwenden, geben Sie die Option connectionName in Ihrem Verbindungsmethodenaufruf an. Alternativ können Sie den Schritten unter Arbeiten mit MongoDB-Verbindungen in ETL-Aufträgen folgen, um die Verbindung zusammen mit dem AWS Glue Data Catalog zu verwenden.

Lesen aus MongoDB mit einer AWS-Glue-Verbindung

Voraussetzungen:

  • Eine MongoDB-Sammlung, aus der Sie lesen möchten. Sie benötigen Identifikationsinformationen für die Sammlung.

    Eine MongoDB-Sammlung wird anhand eines Datenbanknamens und eines Sammlungsnamens identifiziert, mongodbName und mongodbCollection.

  • Eine Verbindung von AWS Glue und MongoDB, die für die Bereitstellung von Authentifizierungsinformationen konfiguriert ist. Gehen Sie wie im vorherigen Verfahren beschrieben vor, um eine Verbindung zu MongoDB zu konfigurieren, um Ihre Authentifizierungsinformationen zu konfigurieren. Sie benötigen den Namen der AWS-Glue-Verbindung, connectionName.

Beispiele: 

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

Schreiben in MongoDB-Tabellen

In diesem Beispiel werden Informationen aus einem vorhandenen DynamicFrame, dynamicFrame, in MongoDB geschrieben.

Voraussetzungen:

  • Eine MongoDB-Sammlung, in der Sie schreiben möchten. Sie benötigen Identifikationsinformationen für die Sammlung.

    Eine MongoDB-Sammlung wird anhand eines Datenbanknamens und eines Sammlungsnamens identifiziert, mongodbName und mongodbCollection.

  • Eine Verbindung von AWS Glue und MongoDB, die für die Bereitstellung von Authentifizierungsinformationen konfiguriert ist. Gehen Sie wie im vorherigen Verfahren beschrieben vor, um eine Verbindung zu MongoDB zu konfigurieren, um Ihre Authentifizierungsinformationen zu konfigurieren. Sie benötigen den Namen der AWS-Glue-Verbindung, connectionName.

Beispiele: 

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

Lesen und Schreiben von Tabellen in MongoDB-Tabellen

In diesem Beispiel werden Informationen aus einem vorhandenen DynamicFrame, dynamicFrame, in MongoDB geschrieben.

Voraussetzungen:

  • Eine MongoDB-Sammlung, aus der Sie lesen möchten. Sie benötigen Identifikationsinformationen für die Sammlung.

    Eine MongoDB-Sammlung, in der Sie schreiben möchten. Sie benötigen Identifikationsinformationen für die Sammlung.

    Eine MongoDB-Sammlung wird anhand eines Datenbanknamens und eines Sammlungsnamens identifiziert, mongodbName und mongodbCollection.

  • MongoDB-Authentifizierungsinformationen, mongodbUser und mongodbPassword.

Beispiele:

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

Referenz zur MongoDB-Verbindungsoption

Bezeichnet eine Verbindung mit MongoDB. Die Anschlussmöglichkeiten bei einer Quellverbindung und eine Senkenverbindung unterscheiden sich.

Diese Verbindungseigenschaften werden von Quell- und Senkenverbindungen gemeinsam genutzt:

  • connectionName – Wird zum Lesen/Schreiben verwendet. Der Name einer Verbindung von AWS Glue und MongoDB, die so konfiguriert ist, dass sie Authentifizierungs- und Netzwerkinformationen für Ihre Verbindungsmethode bereitstellt. Wenn eine AWS-Glue-Verbindung wie im vorherigen Abschnitt (Konfigurieren von MongoDB-Verbindungen) beschrieben konfiguriert ist, sind die Verbindungsoptionen "uri", "username" und "password" nicht mehr nötig, wenn connectionName angegeben wird.

  • "uri": (Erforderlich) Der als mongodb://<host>:<port> formatierte MongoDB-Host, von dem gelesen werden soll. Wird in AWS-Glue-Versionen vor AWS Glue 4.0 verwendet.

  • "connection.uri": (Erforderlich) Der als mongodb://<host>:<port> formatierte MongoDB-Host, von dem gelesen werden soll. Wird in AWS Glue 4.0 und neueren Versionen verwendet.

  • "username": (Erforderlich) Der MongoDB-Benutzername.

  • "password": (Erforderlich) Das MongoDB-Passwort.

  • "database": (Erforderlich) Die MongoDB-Datenbank, aus der gelesen werden soll. Diese Option kann auch in additional_options beim Aufruf von glue_context.create_dynamic_frame_from_catalog in Ihrem Auftragsskript übergeben werden.

  • "collection": (Erforderlich) Die MongoDB-Sammlung, aus der gelesen werden soll. Diese Option kann auch in additional_options beim Aufruf von glue_context.create_dynamic_frame_from_catalog in Ihrem Auftragsskript übergeben werden.

„connectionType“: „mongodb“ als Quelle

Verwenden Sie die folgenden Verbindungsoptionen mit "connectionType": "mongodb" als Quelle:

  • "ssl": (Optional) Wenn true, wird eine SSL-Verbindung initiiert. Der Standardwert ist false.

  • "ssl.domain_match": (Optional) Wenn true und wenn ssl „true“ ist, wird die Prüfung der Domainübereinstimmung durchgeführt. Der Standardwert ist true.

  • "batchSize": (Optional): Die Anzahl der pro Batch zurückzugebenden Dokumente, die innerhalb des Cursors interner Batches verwendet werden.

  • "partitioner": (Optional): Der Klassenname des Partitionierers zum Lesen von Eingabedaten aus MongoDB. Der Konnektor stellt die folgenden Partitionierer bereit:

    • MongoDefaultPartitioner (Standard) (In AWS Glue 4.0 nicht unterstützt)

    • MongoSamplePartitioner (erfordert MongoDB 3.2 oder höher) (wird in AWS Glue 4.0 nicht unterstützt)

    • MongoShardedPartitioner (In AWS Glue 4.0 nicht unterstützt)

    • MongoSplitVectorPartitioner (In AWS Glue 4.0 nicht unterstützt)

    • MongoPaginateByCountPartitioner (In AWS Glue 4.0 nicht unterstützt)

    • MongoPaginateBySizePartitioner (In AWS Glue 4.0 nicht unterstützt)

    • 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" (Optional): Optionen für den angegebenen Partitionierer. Die folgenden Optionen werden für jeden Partitionierer unterstützt:

    • MongoSamplePartitioner: partitionKey, partitionSizeMB, samplesPerPartition

    • MongoShardedPartitioner: shardkey

    • MongoSplitVectorPartitioner: partitionKey, partitionSizeMB

    • MongoPaginateByCountPartitioner: partitionKey, numberOfPartitions

    • MongoPaginateBySizePartitioner: partitionKey, partitionSizeMB

    Weitere Informationen zu diesen Optionen finden Sie unter Partitioner-Konfiguration in der MongoDB-Dokumentation.

„connectionType“: „mongodb“ als Sink

Verwenden Sie die folgenden Verbindungsoptionen mit "connectionType": "mongodb" als Senke:

  • "ssl": (Optional) Wenn true, wird eine SSL-Verbindung initiiert. Der Standardwert ist false.

  • "ssl.domain_match": (Optional) Wenn true und wenn ssl „true“ ist, wird die Prüfung der Domainübereinstimmung durchgeführt. Der Standardwert ist true.

  • "extendedBsonTypes": (Optional) Wenn true, werden beim Schreiben von Daten in MongoDB erweiterte BSON-Typen erlaubt. Der Standardwert ist true.

  • "replaceDocument": (Optional) Wenn true, wird das gesamte Dokument beim Speichern von Datasets, die ein _id-Feld enthalten, ersetzt. Wenn false, werden nur Felder im Dokument aktualisiert, die mit den Feldern im Dataset übereinstimmen. Der Standardwert ist true.

  • "maxBatchSize": (Optional): Die maximale Batchgröße für Massenvorgänge bei der Datenspeicherung. Der Standardwert ist 512.

  • "retryWrites": (Optional): Bestimmte Schreibvorgänge werden automatisch ein einziges Mal wiederholt, wenn AWS Glue auf einen Netzwerkfehler stößt.