Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Koneksi DynamoDB Anda dapat menggunakan AWS Glue for Spark untuk membaca dan menulis ke tabel di DynamoDB di AWS Glue. Anda terhubung ke DynamoDB menggunakan izin IAM yang dilampirkan ke pekerjaan Glue Anda AWS . AWS Gluemendukung penulisan data ke tabel DynamoDB AWS akun lain. Untuk informasi selengkapnya, lihat [Akses lintas akun Lintas wilayah ke tabel DynamoDB](aws-glue-programming-etl-dynamo-db-cross-account.md). Konektor DynamoDB asli menggunakan DynamicFrame objek Glue untuk bekerja dengan data yang diekstrak dari DynamoDB. AWS Glue 5.0\+ memperkenalkan yang baru [Konektor DynamoDB dengan dukungan Spark DataFrame](aws-glue-programming-etl-connect-dynamodb-dataframe-support.md) yang menyediakan DataFrame dukungan Spark asli. Selain konektor AWS Glue DynamoDB ETL, Anda dapat membaca dari DynamoDB menggunakan konektor ekspor DynamoDB, yang memanggil `ExportTableToPointInTime` permintaan DynamoDB dan menyimpannya di lokasi Amazon S3 yang Anda berikan, dalam format DynamoDB JSON. [https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Output.html](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Output.html) AWS Gluekemudian membuat DynamicFrame objek dengan membaca data dari lokasi ekspor Amazon S3. Penulis DynamoDB tersedia dalam AWS Glue versi 1.0 atau versi yang lebih baru. Konektor ekspor AWS Glue DynamoDB tersedia dalam AWS Glue versi 2.0 atau versi yang lebih baru. Konektor DataFrame-based DynamoDB baru tersedia dalam AWS Glue versi 5.0 atau versi yang lebih baru. Untuk informasi selengkapnya tentang DynamoDB, lihat dokumentasi [ Amazon Dynam ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) oDB. **catatan** Pembaca DynamoDB ETL tidak mendukung filter atau predikat pushdown. ## Mengkonfigurasi koneksi DynamoDB Untuk menyambung ke DynamoDB dari AWS Glue, berikan peran IAM yang terkait dengan izin pekerjaan AWS Glue Anda untuk berinteraksi dengan DynamoDB. Untuk informasi selengkapnya tentang izin yang diperlukan untuk membaca atau menulis dari DynamoDB, lihat Tindakan[, sumber daya, dan kunci kondisi untuk DynamoDB ](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazondynamodb.html) dalam dokumentasi IAM. Dalam situasi berikut, Anda mungkin memerlukan konfigurasi tambahan: + Saat menggunakan konektor ekspor DynamoDB, Anda perlu mengkonfigurasi IAM sehingga pekerjaan Anda dapat meminta ekspor tabel DynamoDB. Selain itu, Anda perlu mengidentifikasi bucket Amazon S3 untuk ekspor dan memberikan izin yang sesuai di IAM agar DynamoDB dapat menulis ke dalamnya, dan agar pekerjaan AWS Glue Anda dapat membacanya darinya. Untuk informasi selengkapnya, lihat [ Meminta ekspor tabel di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/S3DataExport_Requesting.html). + Jika pekerjaan AWS Glue Anda memiliki persyaratan konektivitas Amazon VPC tertentu, gunakan jenis koneksi `NETWORK` AWS Glue untuk menyediakan opsi jaringan. Karena akses ke DynamoDB diotorisasi oleh IAM, tidak perlu jenis koneksi Glue Dynamo AWS DB. ## Membaca dari dan menulis ke DynamoDB Contoh kode berikut menunjukkan cara membaca dari (melalui konektor ETL) dan menulis ke tabel DynamoDB. Contoh-contoh tersebut menunjukkan pembacaan dari satu tabel dan penulisan ke tabel lain. ------ #### [ Python ] ``` import sys from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job from awsglue.utils import getResolvedOptions args = getResolvedOptions(sys.argv, ["JOB_NAME"]) glue_context= GlueContext(SparkContext.getOrCreate()) job = Job(glue_context) job.init(args["JOB_NAME"], args) dyf = glue_context.create_dynamic_frame.from_options( connection_type="dynamodb", connection_options={"dynamodb.input.tableName": {{test_source}}, "dynamodb.throughput.read.percent": "1.0", "dynamodb.splits": "100" } ) print(dyf.getNumPartitions()) glue_context.write_dynamic_frame_from_options( frame=dyf, connection_type="dynamodb", connection_options={"dynamodb.output.tableName": {{test_sink}}, "dynamodb.throughput.write.percent": "1.0" } ) job.commit() ``` ------ #### [ Scala ] ``` import com.amazonaws.services.glue.GlueContext 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.DynamoDbDataSink import org.apache.spark.SparkContext import scala.collection.JavaConverters._ object GlueApp { def main(sysArgs: Array[String]): Unit = { val glueContext = new GlueContext(SparkContext.getOrCreate()) val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray) Job.init(args("JOB_NAME"), glueContext, args.asJava) val dynamicFrame = glueContext.getSourceWithFormat( connectionType = "dynamodb", options = JsonOptions(Map( "dynamodb.input.tableName" -> {{test_source}}, "dynamodb.throughput.read.percent" -> "1.0", "dynamodb.splits" -> "100" )) ).getDynamicFrame() print(dynamicFrame.getNumPartitions()) val dynamoDbSink: DynamoDbDataSink = glueContext.getSinkWithFormat( connectionType = "dynamodb", options = JsonOptions(Map( "dynamodb.output.tableName" -> {{test_sink}}, "dynamodb.throughput.write.percent" -> "1.0" )) ).asInstanceOf[DynamoDbDataSink] dynamoDbSink.writeDynamicFrame(dynamicFrame) Job.commit() } } ``` ------ ## Menggunakan konektor ekspor DynamoDB Konektor ekspor berkinerja lebih baik daripada konektor ETL ketika ukuran tabel DynamoDB lebih besar dari 80 GB. Selain itu, mengingat permintaan ekspor dilakukan di luar dari proses Spark dalam suatu AWS Glue pekerjaan, Anda dapat mengaktifkan penskalaan [ otomatis pekerjaan AWS Glue ](https://docs.aws.amazon.com/glue/latest/dg/auto-scaling.html) untuk menyimpan penggunaan DPU selama permintaan ekspor. Dengan konektor ekspor, Anda juga tidak perlu mengonfigurasi jumlah split untuk paralelisme eksekutor Spark atau persentase baca throughput DynamoDB. **catatan** DynamoDB memiliki persyaratan khusus untuk memanggil permintaan. `ExportTableToPointInTime` Untuk informasi selengkapnya, lihat [ Meminta ekspor tabel di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Requesting.html). Misalnya, Point-in-Time-Restore (PITR) perlu diaktifkan pada tabel untuk menggunakan konektor ini. Konektor DynamoDB juga mendukung AWS KMS enkripsi untuk ekspor DynamoDB ke Amazon S3. Menyediakan konfigurasi keamanan Anda dalam konfigurasi pekerjaan AWS Glue memungkinkan AWS KMS enkripsi untuk ekspor DynamoDB. Kunci KMS harus berada di Wilayah yang sama dengan bucket Amazon S3. Perhatikan bahwa biaya tambahan untuk ekspor DynamoDB dan biaya penyimpanan Amazon S3 berlaku. Data yang diekspor di Amazon S3 tetap ada setelah proses pekerjaan selesai sehingga Anda dapat menggunakannya kembali tanpa ekspor DynamoDB tambahan. Persyaratan untuk menggunakan konektor ini adalah pemulihan point-in-time (PITR) diaktifkan untuk tabel. Konektor DynamoDB ETL atau konektor ekspor tidak mendukung filter atau predikat pushdown untuk diterapkan pada sumber DynamoDB. Contoh kode berikut menunjukkan cara membaca dari (melalui konektor ekspor) dan mencetak jumlah partisi. ------ #### [ Python ] ``` import sys from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job from awsglue.utils import getResolvedOptions args = getResolvedOptions(sys.argv, ["JOB_NAME"]) glue_context= GlueContext(SparkContext.getOrCreate()) job = Job(glue_context) job.init(args["JOB_NAME"], args) dyf = glue_context.create_dynamic_frame.from_options( connection_type="dynamodb", connection_options={ "dynamodb.export": "ddb", "dynamodb.tableArn": {{test_source}}, "dynamodb.s3.bucket": {{bucket_name}}, "dynamodb.s3.prefix": {{bucket_prefix}}, "dynamodb.s3.bucketOwner": {{account_id_of_bucket}}, } ) print(dyf.getNumPartitions()) job.commit() ``` ------ #### [ Scala ] ``` import com.amazonaws.services.glue.GlueContext 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.DynamoDbDataSink import org.apache.spark.SparkContext import scala.collection.JavaConverters._ object GlueApp { def main(sysArgs: Array[String]): Unit = { val glueContext = new GlueContext(SparkContext.getOrCreate()) val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray) Job.init(args("JOB_NAME"), glueContext, args.asJava) val dynamicFrame = glueContext.getSourceWithFormat( connectionType = "dynamodb", options = JsonOptions(Map( "dynamodb.export" -> "ddb", "dynamodb.tableArn" -> {{test_source}}, "dynamodb.s3.bucket" -> {{bucket_name}}, "dynamodb.s3.prefix" -> {{bucket_prefix}}, "dynamodb.s3.bucketOwner" -> {{account_id_of_bucket}}, )) ).getDynamicFrame() print(dynamicFrame.getNumPartitions()) Job.commit() } } ``` ------ Contoh-contoh ini menunjukkan bagaimana melakukan pembacaan dari (melalui konektor ekspor) dan mencetak jumlah partisi dari tabel Katalog Data AWS Glue yang memiliki `dynamodb` klasifikasi: ------ #### [ Python ] ``` import sys from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job from awsglue.utils import getResolvedOptions args = getResolvedOptions(sys.argv, ["JOB_NAME"]) glue_context= GlueContext(SparkContext.getOrCreate()) job = Job(glue_context) job.init(args["JOB_NAME"], args) dynamicFrame = glue_context.create_dynamic_frame.from_catalog( database={{catalog_database}}, table_name={{catalog_table_name}}, additional_options={ "dynamodb.export": "ddb", "dynamodb.s3.bucket": {{s3_bucket}}, "dynamodb.s3.prefix": {{s3_bucket_prefix}} } ) print(dynamicFrame.getNumPartitions()) job.commit() ``` ------ #### [ Scala ] ``` import com.amazonaws.services.glue.GlueContext 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.DynamoDbDataSink import org.apache.spark.SparkContext import scala.collection.JavaConverters._ object GlueApp { def main(sysArgs: Array[String]): Unit = { val glueContext = new GlueContext(SparkContext.getOrCreate()) val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray) Job.init(args("JOB_NAME"), glueContext, args.asJava) val dynamicFrame = glueContext.getCatalogSource( database = {{catalog_database}}, tableName = {{catalog_table_name}}, additionalOptions = JsonOptions(Map( "dynamodb.export" -> "ddb", "dynamodb.s3.bucket" -> {{s3_bucket}}, "dynamodb.s3.prefix" -> {{s3_bucket_prefix}} )) ).getDynamicFrame() print(dynamicFrame.getNumPartitions()) ) ``` ------ ## Menyederhanakan penggunaan JSON ekspor DynamoDB Ekspor DynamoDB dengan konektor ekspor AWS Glue DynamoDB menghasilkan file JSON dari struktur bersarang tertentu. Untuk informasi selengkapnya, lihat [ Objek data](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/S3DataExport.Output.html). AWS Gluemenyediakan DynamicFrame transformasi, yang dapat mengubah struktur tersebut menjadi bentuk yang lebih mudah digunakan untuk aplikasi hilir. Transformasi dapat dipanggil dengan salah satu dari dua cara. Anda dapat mengatur opsi koneksi `"dynamodb.simplifyDDBJson"` dengan nilai `"true"` saat memanggil metode untuk membaca dari DynamoDB. Anda juga dapat memanggil transformasi sebagai metode yang tersedia secara independen di perpustakaan AWS Glue. Pertimbangkan skema berikut yang dihasilkan oleh ekspor DynamoDB: ``` root |-- Item: struct | |-- parentMap: struct | | |-- M: struct | | | |-- childMap: struct | | | | |-- M: struct | | | | | |-- appName: struct | | | | | | |-- S: string | | | | | |-- packageName: struct | | | | | | |-- S: string | | | | | |-- updatedAt: struct | | | | | | |-- N: string | |-- strings: struct | | |-- SS: array | | | |-- element: string | |-- numbers: struct | | |-- NS: array | | | |-- element: string | |-- binaries: struct | | |-- BS: array | | | |-- element: string | |-- isDDBJson: struct | | |-- BOOL: boolean | |-- nullValue: struct | | |-- NULL: boolean ``` `simplifyDDBJson`Transformasi akan menyederhanakan ini menjadi: ``` root |-- parentMap: struct | |-- childMap: struct | | |-- appName: string | | |-- packageName: string | | |-- updatedAt: string |-- strings: array | |-- element: string |-- numbers: array | |-- element: string |-- binaries: array | |-- element: string |-- isDDBJson: boolean |-- nullValue: null ``` **catatan** `simplifyDDBJson`tersedia di AWS Glue 3.0 dan versi yang lebih baru. `unnestDDBJson`Transformasi juga tersedia untuk menyederhanakan JSON ekspor DynamoDB. Kami mendorong pengguna untuk beralih ke `simplifyDDBJson` dari`unnestDDBJson`. ## Mengkonfigurasi paralelisme dalam operasi DynamoDB Untuk meningkatkan kinerja, Anda dapat menyetel parameter tertentu yang tersedia untuk konektor DynamoDB. Tujuan Anda saat menyetel parameter paralelisme adalah untuk memaksimalkan penggunaan pekerja Glue yang disediakan. AWS Kemudian, jika Anda membutuhkan lebih banyak kinerja, kami sarankan Anda untuk meningkatkan skala pekerjaan Anda dengan meningkatkan jumlah DPU. Anda dapat mengubah paralelisme dalam operasi baca DynamoDB menggunakan `dynamodb.splits` parameter saat menggunakan konektor ETL. Saat membaca dengan konektor ekspor, Anda tidak perlu mengkonfigurasi jumlah split untuk paralelisme eksekutor Spark. Anda dapat mengubah paralelisme dalam operasi penulisan DynamoDB dengan. `dynamodb.output.numParallelTasks` **Membaca dengan konektor DynamoDB ETL ** Kami menyarankan Anda untuk menghitung `dynamodb.splits` berdasarkan jumlah maksimum pekerja yang ditetapkan dalam konfigurasi pekerjaan Anda dan `numSlots` perhitungan berikut. Jika penskalaan otomatis, jumlah aktual pekerja yang tersedia dapat berubah di bawah batas itu. Untuk informasi selengkapnya tentang menyetel jumlah maksimum pekerja, lihat ** Jumlah pekerja ** (`NumberOfWorkers`) di[Mengkonfigurasi properti pekerjaan untuk pekerjaan Spark di AWS Glue](add-job.md). + `numExecutors = NumberOfWorkers - 1` Untuk konteks, satu eksekutor dicadangkan untuk driver Spark; pelaksana lain digunakan untuk memproses data. + `numSlotsPerExecutor =` ------ #### [ AWS Glue 3.0 and later versions ] + `4` jika `WorkerType` adalah `G.1X` + `8` jika `WorkerType` adalah `G.2X` + `16` jika `WorkerType` adalah `G.4X` + `32` jika `WorkerType` adalah `G.8X` ------ #### [ AWS Glue 2.0 and legacy versions ] + `8` jika `WorkerType` adalah `G.1X` + `16` jika `WorkerType` adalah `G.2X` ------ + `numSlots = numSlotsPerExecutor * numExecutors` Kami sarankan Anda `dynamodb.splits` mengatur jumlah slot yang tersedia,`numSlots`. **Menulis ke DynamoDB ** `dynamodb.output.numParallelTasks`Parameter digunakan untuk menentukan WCU per tugas Spark, menggunakan perhitungan berikut: `permittedWcuPerTask = ( TableWCU * dynamodb.throughput.write.percent ) / dynamodb.output.numParallelTasks` Penulis DynamoDB akan berfungsi paling baik jika konfigurasi secara akurat mewakili jumlah tugas Spark yang menulis ke DynamoDB. Dalam beberapa kasus, Anda mungkin perlu mengganti perhitungan default untuk meningkatkan kinerja penulisan. Jika Anda tidak menentukan parameter ini, tugas WCU yang diizinkan per Spark akan dihitung secara otomatis dengan rumus berikut: + + `numPartitions = dynamicframe.getNumPartitions()` + `numSlots`(seperti yang didefinisikan sebelumnya di bagian ini) + `numParallelTasks = min(numPartitions, numSlots)` + Contoh 1 DPU = 10, = Standar. WorkerType Input DynamicFrame memiliki 100 partisi RDD. + `numPartitions = 100` + `numExecutors = (10 - 1) * 2 - 1 = 17` + `numSlots = 4 * 17 = 68` + `numParallelTasks = min(100, 68) = 68` + Contoh 2 DPU = 10, = Standar. WorkerType Input DynamicFrame memiliki 20 partisi RDD. + `numPartitions = 20` + `numExecutors = (10 - 1) * 2 - 1 = 17` + `numSlots = 4 * 17 = 68` + `numParallelTasks = min(20, 68) = 20` **catatan** Pekerjaan pada versi AWS Lem lama dan yang menggunakan pekerja Standar memerlukan metode yang berbeda untuk menghitung jumlah slot. Jika Anda perlu menyesuaikan kinerja pekerjaan ini, kami sarankan Anda beralih ke versi AWS Glue yang didukung. ## Referensi opsi koneksi DynamoDB Mengkhususkan koneksi ke Amazon DynamoDB. Pilihan koneksi berbeda untuk koneksi sumber dan koneksi sink. ### “connectionType”: “dynamodb” dengan konektor ETL sebagai sumber Gunakan opsi koneksi berikut `"connectionType": "dynamodb"` sebagai sumber, saat menggunakan konektor Glue Dynam AWS oDB ETL: + `"dynamodb.input.tableName"`: (Wajib) Tabel DynamoDB tempat untuk membaca. + `"dynamodb.throughput.read.percent"`: (Opsional) Persentase unit kapasitas baca (RCU) yang akan digunakan. Default diatur ke "0,5". Nilai yang dapat diterima adalah dari "0,1" hingga "1,5", inklusif. + `0.5`mewakili tingkat baca default, yang berarti AWS Glue akan mencoba mengkonsumsi setengah dari kapasitas baca tabel. Jika Anda meningkatkan nilai di atas`0.5`, AWS Glue meningkatkan tingkat permintaan; menurunkan nilai di bawah ini `0.5` menurunkan tingkat permintaan baca. (Tingkat baca sebenarnya akan bervariasi, tergantung pada faktor-faktor seperti apakah ada distribusi kunci seragam dalam tabel DynamoDB.) + Ketika tabel DynamoDB dalam mode on-demand, AWS Glue menangani kapasitas baca tabel sebagai 40000. Untuk mengekspor tabel besar, sebaiknya ubah tabel DynamoDB Anda ke mode sesuai permintaan. + `"dynamodb.splits"`: (Opsional) Mendefinisikan berapa banyak bagian partisi yang kita buat untuk tabel DynamoDB ini saat membaca. Default diatur ke "1". Nilai yang dapat diterima adalah dari "1" hingga "1.000.000", inklusif. `1` mewakili tidak ada paralelisme. Kami sangat menyarankan Anda menentukan nilai yang lebih besar untuk performa yang lebih baik dengan menggunakan rumus di bawah ini. Untuk informasi selengkapnya tentang pengaturan nilai dengan tepat, lihat[Mengkonfigurasi paralelisme dalam operasi DynamoDB](#aws-glue-programming-etl-connect-dynamodb-parallelism). + `"dynamodb.sts.roleArn"`: (Opsional) ARN IAM role yang akan diambil untuk akses lintas-akun. Parameter ini tersedia di AWS Glue 1.0 atau yang lebih baru. + `"dynamodb.sts.roleSessionName"`: (Opsional) Nama sesi STS. Default diatur ke "glue-dynamodb-read-sts-session". Parameter ini tersedia di AWS Glue 1.0 atau yang lebih baru. ### “connectionType”: “dynamodb” dengan AWS Lem Konektor ekspor DynamoDB sebagai sumber Gunakan opsi koneksi berikut dengan “ConnectionType”: “dynamodb” sebagai sumber, saat menggunakan konektor ekspor AWS Glue DynamoDB, yang hanya tersedia untuk versi 2.0 dan seterusnya: AWS Glue + `"dynamodb.export"`: (Diperlukan) Nilai string: + Jika disetel `ddb` untuk mengaktifkan konektor ekspor AWS Glue DynamoDB di mana yang baru `ExportTableToPointInTimeRequest` akan dipanggil selama pekerjaan. AWS Glue Ekspor baru akan dihasilkan dengan lokasi yang diteruskan dari `dynamodb.s3.bucket` dan`dynamodb.s3.prefix`. + Jika diset `s3` el untuk mengaktifkan konektor ekspor AWS Glue DynamoDB tetapi melewatkan pembuatan ekspor DynamoDB baru dan sebagai gantinya menggunakan `dynamodb.s3.bucket` dan `dynamodb.s3.prefix` sebagai lokasi Amazon S3 dari ekspor sebelumnya dari tabel tersebut. + `"dynamodb.tableArn"`: (Wajib) Tabel DynamoDB tempat untuk membaca. + `"dynamodb.unnestDDBJson"`: (Opsional) Default: false. Nilai yang valid: boolean. Jika disetel ke true, melakukan transformasi unnest dari struktur JSON DynamoDB yang ada dalam ekspor. Ini adalah kesalahan untuk mengatur `"dynamodb.unnestDDBJson"` dan `"dynamodb.simplifyDDBJson"` menjadi benar pada saat yang sama. Di AWS Glue 3.0 dan versi yang lebih baru, kami sarankan Anda menggunakan `"dynamodb.simplifyDDBJson"` untuk perilaku yang lebih baik saat menyederhanakan jenis Peta DynamoDB. Untuk informasi selengkapnya, lihat [Menyederhanakan penggunaan JSON ekspor DynamoDB](#etl-connect-dynamodb-traversing-structure). + `"dynamodb.simplifyDDBJson"`: (Opsional) Default: false. Nilai yang valid: boolean. Jika disetel ke true, melakukan transformasi untuk menyederhanakan skema struktur JSON DynamoDB yang ada dalam ekspor. Ini memiliki tujuan yang sama dengan `"dynamodb.unnestDDBJson"` opsi tetapi memberikan dukungan yang lebih baik untuk jenis Peta DynamoDB atau bahkan tipe Peta bersarang di tabel DynamoDB Anda. Opsi ini tersedia di AWS Glue 3.0 dan versi yang lebih baru. Ini adalah kesalahan untuk mengatur `"dynamodb.unnestDDBJson"` dan `"dynamodb.simplifyDDBJson"` menjadi benar pada saat yang sama. Untuk informasi selengkapnya, lihat [Menyederhanakan penggunaan JSON ekspor DynamoDB](#etl-connect-dynamodb-traversing-structure). + `"dynamodb.s3.bucket"`: (Opsional) Menunjukkan lokasi bucket Amazon S3 tempat `ExportTableToPointInTime` proses DynamoDB akan dilakukan. Format file untuk ekspor adalah DynamoDB JSON. + `"dynamodb.s3.prefix"`: (Opsional) Menunjukkan lokasi awalan Amazon S3 di dalam bucket Amazon S3 tempat pemuatan Dynamo `ExportTableToPointInTime` DB akan disimpan. Jika tidak `dynamodb.s3.prefix` `dynamodb.s3.bucket` ada atau tidak ditentukan, nilai-nilai ini akan default ke lokasi Direktori Sementara yang ditentukan dalam konfigurasi AWS Glue pekerjaan. Untuk informasi lebih lanjut, lihat Parameter [ Khusus yang Digunakan oleh AWS Lem](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html). + `"dynamodb.s3.bucketOwner"`: Menunjukkan pemilik bucket yang diperlukan untuk akses Amazon S3 lintas akun. + `"dynamodb.sts.roleArn"`: (Opsional) Peran IAM ARN akan diasumsikan untuk akses lintas akun Akses and/or lintas wilayah untuk tabel DynamoDB. Catatan: Peran IAM yang sama ARN akan digunakan untuk mengakses lokasi Amazon S3 yang ditentukan untuk `ExportTableToPointInTime` permintaan. + `"dynamodb.sts.roleSessionName"`: (Opsional) Nama sesi STS. Default diatur ke "glue-dynamodb-read-sts-session". + `"dynamodb.exportTime"`(Opsional) Nilai yang valid: string yang mewakili ISO-8601 instans. Titik waktu di mana ekspor harus dilakukan. + `"dynamodb.sts.region"`: (Diperlukan jika melakukan panggilan lintas wilayah menggunakan titik akhir regional) Wilayah yang menghosting tabel DynamoDB yang ingin Anda baca. ### “ConnectionType”: “dynamodb” dengan konektor ETL sebagai sink Gunakan opsi koneksi berikut dengan `"connectionType": "dynamodb"` sebagai sink: + `"dynamodb.output.tableName"`: (Wajib) Tabel DynamoDB tempat untuk menulis. + `"dynamodb.throughput.write.percent"`: (Opsional) Persentase unit kapasitas tulis (WCU) yang akan digunakan. Default diatur ke "0,5". Nilai yang dapat diterima adalah dari "0,1" hingga "1,5", inklusif. + `0.5`mewakili tingkat tulis default, yang berarti AWS Glue akan mencoba mengkonsumsi setengah dari kapasitas tulis tabel. Jika Anda meningkatkan nilai di atas 0,5, AWS Glue meningkatkan tingkat permintaan; menurunkan nilai di bawah 0,5 mengurangi tingkat permintaan tulis. (Tingkat tulis sebenarnya akan bervariasi, tergantung pada faktor-faktor seperti apakah ada distribusi kunci seragam dalam tabel DynamoDB). + Ketika tabel DynamoDB dalam mode on-demand, AWS Glue menangani kapasitas tulis tabel sebagai. `40000` Untuk mengimpor tabel besar, sebaiknya ubah tabel DynamoDB Anda ke mode sesuai permintaan. + `"dynamodb.output.numParallelTasks"`: (Opsional) Mendefinisikan berapa banyak tugas paralel yang menulis ke DynamoDB pada saat yang sama. Digunakan untuk menghitung WCU permisif untuk setiap tugas Spark. Dalam kebanyakan kasus, AWS Glue akan menghitung default yang wajar untuk nilai ini. Untuk informasi selengkapnya, lihat [Mengkonfigurasi paralelisme dalam operasi DynamoDB](#aws-glue-programming-etl-connect-dynamodb-parallelism). + `"dynamodb.output.retry"`: (Opsional) Mendefinisikan berapa banyak percobaan ulang yang kita lakukan ketika ada `ProvisionedThroughputExceededException` dari DynamoDB. Default diatur ke "10". + `"dynamodb.sts.roleArn"`: (Opsional) ARN IAM role yang akan diambil untuk akses lintas-akun. + `"dynamodb.sts.roleSessionName"`: (Opsional) Nama sesi STS. Default diatur ke "glue-dynamodb-write-sts-session".