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. ](https://www.mongodb.com/docs/)
## 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 ](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) 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 nilai{{mongodbUser}}.
Saat memilih ** Key/value pasangan**, buat pasangan untuk kunci `password` dengan nilainya{{mongodbPass}}.
1. Di konsol AWS Glue, buat koneksi dengan mengikuti langkah-langkah di[Menambahkan AWS Glue koneksi](console-connections.md). 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 ** berikan{{secretName}}.
+ Jika Anda memilih untuk memberikan Nama ** Pengguna dan kata sandi**, berikan {{mongodbUser}} dan{{mongodbPass}}.
1. 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 membaca{{secretName}}.
+ 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](integrate-with-mongo-db.md) 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://:27017"
mongo_ssl_uri = "mongodb://:27017"
write_uri = "mongodb://: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://:27017"
val WRITE_URI: String = "mongodb://: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](#aws-glue-programming-etl-connect-mongodb-configure), penyediaan `connectionName` akan menggantikan kebutuhan untuk menyediakan`"uri"`, `"username"` dan opsi `"password"` koneksi.
+ `"uri"`: (Wajib) Host MongoDB tempat untuk membaca, diformat sebagai `mongodb://:`. Digunakan dalam versi AWS Lem sebelum AWS Glue 4.0.
+ `"connection.uri"`: (Wajib) Host MongoDB tempat untuk membaca, diformat sebagai `mongodb://:`. 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](https://docs.mongodb.com/spark-connector/master/configuration/#partitioner-conf) 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.