View a markdown version of this page

Koneksi MongoDB - AWS Lem
Mengkonfigurasi MongoDBBaca dari MongoDBMenulis ke MongoDBBaca dan tulis ke MongoDBKoneksi MongoDB

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Koneksi MongoDB

Anda dapat menggunakan AWS Glue for Spark untuk membaca dan menulis ke tabel di MongoDB dan MongoDB Atlas di AWS Glue 4.0 dan versi yang lebih baru. Anda dapat terhubung ke MongoDB menggunakan kredenSIAL nama pengguna dan kata sandi yang disimpan AWS Secrets Manager melalui koneksi AWS Glue.

Untuk informasi lebih lanjut tentang MongoDB, lihat dokumentasi MongoDB.

Mengkonfigurasi koneksi MongoDB

Untuk terhubung ke MongoDB dari AWS Glue, Anda memerlukan kredenSIAL MongoDB Anda, dan. mongodbUser mongodbPass

Untuk terhubung ke MongoDB dari AWS Glue, Anda mungkin memerlukan beberapa prasyarat:

  • Jika instance MongoDB Anda berada di Amazon VPC, konfigurasikan Amazon VPC untuk mengizinkan pekerjaan AWS Glue Anda berkomunikasi dengan instans MongoDB tanpa lalu lintas melintasi internet publik.

    Di Amazon VPC, identifikasi atau buat grup VPC, Subnet, dan Keamanan yang akan digunakan AWS Glue saat menjalankan pekerjaan. Selain itu, Anda perlu memastikan Amazon VPC dikonfigurasi untuk mengizinkan lalu lintas jaringan antara instans MongoDB Anda dan lokasi ini. Berdasarkan tata letak jaringan Anda, ini mungkin memerlukan perubahan pada aturan grup keamanan, ACL Jaringan, Gerbang NAT, dan koneksi Peering.

Anda kemudian dapat melanjutkan untuk mengkonfigurasi AWS Glue untuk digunakan dengan MongoDB.

Untuk mengkonfigurasi koneksi ke MongoDB:

  1. Secara opsional, di AWS Secrets Manager, buat rahasia menggunakan kredenSIAL MongoDB Anda. Untuk membuat rahasia di Secrets Manager, ikuti tutorial yang tersedia di Buat AWS Secrets Manager rahasia dalam AWS Secrets Manager dokumentasi. Setelah membuat rahasia, simpan nama Rahasia, secretName untuk langkah selanjutnya.

    • Saat memilih Key/value pasangan, buat pasangan untuk kunci username dengan nilaimongodbUser.

      Saat memilih Key/value pasangan, buat pasangan untuk kunci password dengan nilainyamongodbPass.

  2. Di konsol AWS Glue, buat koneksi dengan mengikuti langkah-langkah diMenambahkan AWS Glue koneksi. Setelah membuat koneksi, simpan nama koneksi,connectionName, untuk digunakan di masa mendatang di AWS Glue.

    • Saat memilih jenis koneksi, pilih MongoDB atau MongoDB Atlas.

    • Saat memilih URL MongoDB atau URL MongoDB Atlas, berikan nama host instance MongoDB Anda.

      URL MongoDB disediakan dalam format. mongodb://mongoHost:mongoPort/mongoDBname

      URL MongoDB Atlas disediakan dalam format. mongodb+srv://mongoHost/mongoDBname

    • Jika Anda memilih untuk membuat rahasia Manajer Rahasia, pilih jenis AWS Secrets Manager Credential.

      Kemudian, secara AWS rahasia berikansecretName.

    • Jika Anda memilih untuk memberikan Nama Pengguna dan kata sandi, berikan mongodbUser danmongodbPass.

  3. Dalam situasi berikut, Anda mungkin memerlukan konfigurasi tambahan:

    • Untuk instans MongoDB yang dihosting AWS di Amazon VPC

      • Anda harus memberikan informasi koneksi Amazon VPC ke koneksi Glue yang menentukan AWS kredenSIAL keamanan MongoDB Anda. Saat membuat atau memperbarui koneksi Anda, atur grup VPC, Subnet, dan Keamanan di opsi Jaringan.

Setelah membuat koneksi AWS Glue MongoDB, Anda harus melakukan tindakan berikut sebelum memanggil metode koneksi Anda:

  • Jika Anda memilih untuk membuat rahasia Manajer Rahasia, berikan peran IAM yang terkait dengan izin pekerjaan AWS Glue Anda untuk membacasecretName.

  • Dalam konfigurasi pekerjaan AWS Glue Anda, berikan connectionName sebagai koneksi jaringan tambahan.

Untuk menggunakan koneksi Glu AWS e MongoDB Anda di AWS Glue for Spark, berikan connectionName opsi dalam panggilan metode koneksi Anda. Atau, Anda dapat mengikuti langkah-langkah Bekerja dengan koneksi MongoDB dalam pekerjaan ETL untuk menggunakan koneksi bersama dengan Katalog Data AWS Lem.

Membaca dari MongoDB menggunakan a AWS Koneksi lem

Prasyarat:

  • Koleksi MongoDB yang ingin Anda baca. Anda akan memerlukan informasi identifikasi untuk pengumpulan.

    Koleksi MongoDB diidentifikasi dengan nama database dan nama koleksi,,mongodbName. mongodbCollection

  • Koneksi AWS Glue MongoDB dikonfigurasi untuk memberikan informasi autentikasi. Selesaikan langkah-langkah dalam prosedur sebelumnya, Untuk mengkonfigurasi koneksi ke MongoDB untuk mengkonfigurasi informasi autentikasi Anda. Anda akan membutuhkan nama koneksi AWS Glue,connectionName.

Contoh: 

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

Menulis ke tabel MongoDB

Contoh ini menulis informasi dari yang sudah ada DynamicFrame, dynamicFrame ke MongoDB.

Prasyarat:

  • Koleksi MongoDB yang ingin Anda tulis. Anda akan memerlukan informasi identifikasi untuk pengumpulan.

    Koleksi MongoDB diidentifikasi dengan nama database dan nama koleksi,,mongodbName. mongodbCollection

  • Koneksi AWS Glue MongoDB dikonfigurasi untuk memberikan informasi autentikasi. Selesaikan langkah-langkah dalam prosedur sebelumnya, Untuk mengkonfigurasi koneksi ke MongoDB untuk mengkonfigurasi informasi autentikasi Anda. Anda akan membutuhkan nama koneksi AWS Glue,connectionName.

Contoh: 

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

Membaca dan menulis ke tabel MongoDB

Contoh ini menulis informasi dari yang sudah ada DynamicFrame, dynamicFrame ke MongoDB.

Prasyarat:

  • Koleksi MongoDB yang ingin Anda baca. Anda akan memerlukan informasi identifikasi untuk pengumpulan.

    Koleksi MongoDB yang ingin Anda tulis. Anda akan memerlukan informasi identifikasi untuk pengumpulan.

    Koleksi MongoDB diidentifikasi dengan nama database dan nama koleksi,,mongodbName. mongodbCollection

  • Informasi autentikasi MongoDB, dan. mongodbUser mongodbPassword

Contoh:

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

Referensi opsi koneksi MongoDB

Mengkhususkan koneksi ke MongoDB. Pilihan koneksi berbeda untuk koneksi sumber dan koneksi sink.

Properti koneksi ini dibagi antara koneksi sumber dan sink:

  • connectionName— Digunakan untuk Read/Write. Nama koneksi AWS Glue MongoDB dikonfigurasi untuk memberikan informasi autentikasi dan jaringan ke metode koneksi Anda. Ketika koneksi AWS Glue dikonfigurasi seperti yang dijelaskan di bagian sebelumnya,Mengkonfigurasi koneksi MongoDB, penyediaan connectionName akan menggantikan kebutuhan untuk menyediakan"uri", "username" dan opsi "password" koneksi.

  • "uri": (Wajib) Host MongoDB tempat untuk membaca, diformat sebagai mongodb://<host>:<port>. Digunakan dalam versi AWS Lem sebelum AWS Glue 4.0.

  • "connection.uri": (Wajib) Host MongoDB tempat untuk membaca, diformat sebagai mongodb://<host>:<port>. Digunakan dalam AWS Glue 4.0 dan versi yang lebih baru.

  • "username": (Wajib) Nama pengguna MongoDB.

  • "password": (Wajib) Kata sandi MongoDB.

  • "database": (Wajib) Basis data MongoDB untuk dibaca. Pilihan ini juga bisa diberikan di additional_options ketika memanggil glue_context.create_dynamic_frame_from_catalog dalam skrip tugas Anda.

  • "collection": (Wajib) Kumpulan MongoDB untuk dibaca. Pilihan ini juga bisa diberikan di additional_options ketika memanggil glue_context.create_dynamic_frame_from_catalog dalam skrip tugas Anda.

“connectionType”: “mongodb” sebagai sumber

Gunakan opsi koneksi berikut dengan "connectionType": "mongodb" sebagai sumber:

  • "ssl": (Opsional) Jika true, maka memulai koneksi SSL. Nilai default-nya false.

  • "ssl.domain_match": (Opsional) Jika true dan ssl adalah true, maka pemeriksaan kecocokan domain dilakukan. Nilai default-nya true.

  • "batchSize": (Opsional): Jumlah dokumen yang akan dikembalikan per batch, digunakan dalam kursor batch internal.

  • "partitioner": (Opsional): Nama kelas pemartisi untuk membaca input data dari MongoDB. Konektor menyediakan pemartisi berikut:

    • MongoDefaultPartitioner(default) (Tidak didukung di AWS Glue 4.0)

    • MongoSamplePartitioner(Membutuhkan MongoDB 3.2 atau yang lebih baru) (Tidak didukung di AWS Glue 4.0)

    • MongoShardedPartitioner(Tidak didukung di AWS Glue 4.0)

    • MongoSplitVectorPartitioner(Tidak didukung di AWS Glue 4.0)

    • MongoPaginateByCountPartitioner(Tidak didukung di AWS Glue 4.0)

    • MongoPaginateBySizePartitioner(Tidak didukung di 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" (Opsional): Opsi untuk pemartisi yang ditunjuk. Opsi berikut didukung untuk setiap pemartisi:

    • MongoSamplePartitioner: partitionKey, partitionSizeMB, samplesPerPartition

    • MongoShardedPartitioner: shardkey

    • MongoSplitVectorPartitioner: partitionKey, partitionSizeMB

    • MongoPaginateByCountPartitioner: partitionKey, numberOfPartitions

    • MongoPaginateBySizePartitioner: partitionKey, partitionSizeMB

    Untuk informasi lebih lanjut tentang opsi ini, lihat Konfigurasi Partisi dalam dokumentasi MongoDB.

“connectionType”: “mongodb” sebagai wastafel

Gunakan opsi koneksi berikut dengan "connectionType": "mongodb" sebagai sink:

  • "ssl": (Opsional) Jika true, maka memulai koneksi SSL. Nilai default-nya false.

  • "ssl.domain_match": (Opsional) Jika true dan ssl adalah true, maka pemeriksaan kecocokan domain dilakukan. Nilai default-nya true.

  • "extendedBsonTypes": (Opsional) Jika true, memungkinkan jenis BSON yang diperpanjang saat menulis data ke MongoDB. Nilai default-nya true.

  • "replaceDocument": (Opsional) Jika true, menggantikan seluruh dokumen ketika menyimpan set data yang berisi bidang _id. Jika false, hanya bidang dalam dokumen yang cocok dengan bidang dalam set data saja yang diperbarui. Nilai default-nya true.

  • "maxBatchSize": (Opsional): Ukuran batch maksimum untuk operasi massal saat menyimpan data. Default-nya adalah 512.

  • "retryWrites": (Opsional): Secara otomatis mencoba kembali operasi penulisan tertentu satu kali jika AWS Glue menemukan kesalahan jaringan.