View a markdown version of this page

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 for Spark verwenden, um aus Tabellen in MongoDB und MongoDB Atlas in AWS Glue 4.0 und späteren Versionen zu lesen und in sie zu schreiben. Sie können eine Verbindung zu MongoDB herstellen, indem Sie Anmeldeinformationen für Benutzername und Passwort verwenden, die AWS Secrets Manager über eine AWS Glue-Verbindung 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 und. mongodbUser mongodbPass

Um von AWS Glue aus eine Verbindung zu MongoDB herzustellen, benötigen Sie möglicherweise einige Voraussetzungen:

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

    Identifizieren oder erstellen Sie in Amazon VPC eine VPC, ein Subnetz und eine Sicherheitsgruppe , die Glue bei der Ausführung des Jobs verwenden wird. AWS 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.

Anschließend können Sie AWS Glue für die Verwendung mit MongoDB konfigurieren.

Eine Verbindung zu MongoDB konfigurieren Sie wie folgt:

  1. Erstellen Sie optional unter AWS Secrets Manager ein Secret mit Ihren MongoDB-Anmeldeinformationen. Um ein Geheimnis in Secrets Manager zu erstellen, folgen Sie dem Tutorial unter Create an AWS Secrets Manager Secret in der AWS Secrets Manager Dokumentation. Nachdem Sie das Geheimnis erstellt haben, behalten Sie den Namen des Geheimnisses secretName für den nächsten Schritt bei.

    • Erstellen Sie bei der Auswahl von Key/value Paaren ein Paar für den Schlüssel username mit dem WertmongodbUser.

      Erstellen Sie bei der Auswahl von Key/value Paaren ein Paar für den Schlüssel password mit dem WertmongodbPass.

  2. Erstellen Sie in der AWS Glue-Konsole eine Verbindung, indem Sie den Schritten unter folgenAWS Glue Verbindung hinzufügen. Nachdem Sie die Verbindung hergestellt haben, behalten Sie den Verbindungsnamen für die zukünftige Verwendung in AWS Glue bei. connectionName

    • 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/mongoDBname bereitgestellt.

    • Wenn Sie sich dafür entschieden haben, ein Secrets Manager-Geheimnis zu erstellen, wählen Sie den AWS Secrets Manager Anmeldeinformationstyp.

      Geben Sie dann unter AWS Secret Folgendes einsecretName.

    • Wenn Sie sich dafür entscheiden, Benutzername und Passwort anzugeben, geben Sie mongodbUser und einmongodbPass.

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

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

      • Sie müssen Amazon VPC-Verbindungsinformationen für die AWS Glue-Verbindung angeben, die Ihre MongoDB-Sicherheitsanmeldeinformationen definieren. 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 sich dafür entschieden haben, ein Secrets Manager-Geheimnis zu erstellen, gewähren Sie der IAM-Rolle, die Ihrem AWS Glue-Job zugeordnet ist, die Leseberechtigung. secretName

  • Geben connectionName Sie in Ihrer AWS Glue-Job-Konfiguration eine zusätzliche Netzwerkverbindung an.

Um Ihre AWS Glue-MongoDB-Verbindung in AWS Glue for Spark zu verwenden, geben Sie die connectionName Option in Ihrem Verbindungsmethodenaufruf an. Alternativ können Sie die Schritte unter Arbeiten mit MongoDB-Verbindungen in ETL-Aufträgen So verwenden Sie die Verbindung in Verbindung mit dem AWS Glue-Datenkatalog verwenden.

Lesen aus MongoDB mit einem AWS Verbindung kleben

Voraussetzungen:

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

    Eine MongoDB-Sammlung wird durch einen Datenbanknamen und einen Sammlungsnamen identifiziert,mongodbName,mongodbCollection.

  • Eine AWS Glue-MongoDB-Verbindung, 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

Beispiel: 

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 einer vorhandenen DynamicFrame in MongoDB geschrieben. dynamicFrame

Voraussetzungen:

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

    Eine MongoDB-Sammlung wird durch einen Datenbanknamen und einen Sammlungsnamen,, mongodbName identifiziert. mongodbCollection

  • Eine AWS Glue-MongoDB-Verbindung, 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

Beispiel: 

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 einer vorhandenen DynamicFrame in MongoDB geschrieben. dynamicFrame

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 durch einen Datenbanknamen und einen Sammlungsnamen,, mongodbName identifiziert. mongodbCollection

  • MongoDB-Authentifizierungsinformationen, und. mongodbUser mongodbPassword

Beispiel:

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— Verwendet für. Read/Write Der Name einer AWS Glue-MongoDB-Verbindung, die so konfiguriert ist, dass sie Authentifizierungs- und Netzwerkinformationen für Ihre Verbindungsmethode bereitstellt. Wenn eine AWS Glue-Verbindung wie im vorherigen Abschnitt beschrieben konfiguriert connectionName wirdKonfigurieren von MongoDB-Verbindungen, ersetzt die Bereitstellung der "password" Verbindungsoptionen"uri", "username" und die Bereitstellung.

  • "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 späteren 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): Versuchen Sie bestimmte Schreibvorgänge automatisch ein einziges Mal, wenn AWS Glue auf einen Netzwerkfehler stößt.