Koneksi MongoDB - AWS Glue
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 AWS MongoDB Atlas di Glue 4.0 dan versi yang lebih baru. Anda dapat terhubung ke MongoDB menggunakan kredensional nama pengguna dan kata sandi yang disimpan melalui koneksi Glue. AWS Secrets Manager AWS

Untuk informasi lebih lanjut tentang MongoDB, lihat dokumentasi MongoDB.

Mengkonfigurasi koneksi MongoDB

Untuk terhubung ke MongoDB AWS dari Glue, Anda akan memerlukan kredensi MongoDB Anda, MongoDbuser dan MongoDBPass.

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

  • Jika instans MongoDB Anda ada di VPC Amazon, konfigurasikan Amazon VPC untuk memungkinkan pekerjaan Glue AWS 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, Gateway NAT, dan koneksi Peering.

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

Untuk mengkonfigurasi koneksi ke MongoDB:

  1. Secara opsional, diAWS Secrets Manager, buat rahasia menggunakan kredensyal 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 pasangan kunci/nilai, buat pasangan untuk kunci username dengan nilai MongoDbuser.

      Saat memilih pasangan kunci/nilai, buat pasangan untuk kunci password dengan nilai MongoDBPass.

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

    • 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 Atlas MongoDB disediakan dalam format. mongodb+srv://mongoHost:mongoPort/mongoDBname

      Menyediakan database default untuk koneksi, MongoDBName adalah opsional.

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

      Kemudian, di AWSSecret berikan secretName.

    • Jika Anda memilih untuk memberikan Nama Pengguna dan kata sandi, berikan MongoDbuser dan MongoDBPass.

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

    • Untuk instance MongoDB yang dihosting di VPC Amazon AWS

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

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

  • Jika Anda memilih untuk membuat rahasia Secrets Manager, berikan peran IAM yang terkait dengan izin pekerjaan AWS Glue Anda untuk membaca secretName.

  • Dalam konfigurasi pekerjaan AWS Glue Anda, berikan ConnectionName sebagai koneksi jaringan Tambahan.

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

Membaca dari MongoDB menggunakan koneksi Glue AWS

Prasyarat:

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

    Koleksi MongoDB diidentifikasi oleh 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 memerlukan nama koneksi AWS Glue, ConnectionName.

Misalnya: 

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 DynamicFrame yang sudah ada DynamicFrame ke MongoDB.

Prasyarat:

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

    Koleksi MongoDB diidentifikasi oleh 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 memerlukan nama koneksi AWS Glue, ConnectionName.

Misalnya: 

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 DynamicFrame yang sudah ada DynamicFrame ke MongoDB.

Prasyarat:

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

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

    Koleksi MongoDB diidentifikasi oleh nama database dan nama koleksi, MongoDBName, MongoDBCollection.

  • Informasi autentikasi MongoDB, MongoDbuser dan MongoDBPassword.

Misalnya:

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 Membaca/Menulis. Nama koneksi AWS Glue MongoDB dikonfigurasi untuk memberikan informasi auth dan jaringan ke metode koneksi Anda. Ketika koneksi AWS Glue dikonfigurasi seperti yang dijelaskan di bagian sebelumnyaMengkonfigurasi koneksi MongoDB,, menyediakan 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 Glue 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. Defaultnya adalah false.

  • "ssl.domain_match": (Opsional) Jika true dan ssl adalah true, maka pemeriksaan kecocokan domain dilakukan. Defaultnya adalah 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(Memerlukan 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. Defaultnya adalah false.

  • "ssl.domain_match": (Opsional) Jika true dan ssl adalah true, maka pemeriksaan kecocokan domain dilakukan. Defaultnya adalah true.

  • "extendedBsonTypes": (Opsional) Jika true, memungkinkan jenis BSON yang diperpanjang saat menulis data ke MongoDB. Defaultnya adalah 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. Defaultnya adalah 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.