Koneksi DynamoDB - AWS Glue
Mengkonfigurasi DynamoDBMenggunakan DynamoDBKonektor ekspor DynamoDBMenyederhanakan penggunaan DynamoDB ekspor JSONParalelisme DynamoDBKoneksi DynamoDB

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 Glue. AWS 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.

Selain konektor AWS Glue DynamoDB ETL, Anda dapat membaca dari DynamoDB menggunakan konektor ekspor DynamoDB, yang memanggil permintaan DynamoDB dan menyimpannya di lokasi Amazon S3 yang Anda suplai, dalam ExportTableToPointInTime format DynamoDB JSON. AWS Gluekemudian membuat DynamicFrame objek dengan membaca data dari lokasi ekspor Amazon S3.

Penulis DynamoDB tersedia AWS Glue dalam versi 1.0 atau versi yang lebih baru. Konektor ekspor AWS Glue DynamoDB tersedia AWS Glue dalam versi 2.0 atau versi yang lebih baru.

Untuk informasi selengkapnya tentang DynamoDB, lihat dokumentasi Amazon DynamoDB.

catatan

Pembaca DynamoDB ETL tidak mendukung filter atau predikat pushdown.

Mengkonfigurasi koneksi DynamoDB

Untuk terhubung ke DynamoDB AWS dari Glue, berikan peran IAM yang terkait dengan izin pekerjaan Glue AWS 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 dalam dokumentasi IAM.

Dalam situasi berikut, Anda mungkin memerlukan konfigurasi tambahan:

  • Saat menggunakan konektor ekspor DynamoDB, Anda harus 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 menulis kepadanya, dan agar tugas Glue Anda AWS dapat membacanya. Untuk informasi lebih lanjut, lihat Minta ekspor tabel di DynamoDB.

  • Jika pekerjaan AWS Glue Anda memiliki persyaratan konektivitas VPC Amazon tertentu, gunakan jenis koneksi NETWORK AWS Glue untuk menyediakan opsi jaringan. Karena akses ke DynamoDB diotorisasi oleh IAM, tidak perlu jenis koneksi AWS Glue DynamoDB.

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 proses Spark dalam suatu AWS Glue pekerjaan, Anda dapat mengaktifkan penskalaan otomatis pekerjaan AWS Glue untuk menghemat penggunaan DPU selama permintaan ekspor. Dengan konektor ekspor, Anda juga tidak perlu mengonfigurasi jumlah split untuk paralelisme pelaksana Spark atau persentase pembacaan throughput DynamoDB.

catatan

DynamoDB memiliki persyaratan khusus untuk memanggil permintaan. ExportTableToPointInTime Untuk informasi selengkapnya, lihat Meminta ekspor tabel di DynamoDB. Misalnya, Point-in-Time-Restore (PITR) perlu diaktifkan di atas meja 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 pekerjaan selesai sehingga Anda dapat menggunakannya kembali tanpa ekspor DynamoDB tambahan. Persyaratan untuk menggunakan konektor ini adalah point-in-time pemulihan (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 DynamoDB ekspor JSON

Ekspor DynamoDB dengan AWS Glue konektor ekspor DynamoDB menghasilkan file JSON dari struktur bersarang tertentu. Untuk informasi selengkapnya, lihat Objek data. AWS Gluememasok DynamicFrame transformasi, yang dapat membuat struktur seperti itu menjadi easier-to-use bentuk 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

simplifyDDBJsonTransformasi 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

simplifyDDBJsontersedia dalam AWS Glue 3.0 dan versi yang lebih baru. unnestDDBJsonTransformasi ini juga tersedia untuk menyederhanakan DynamoDB ekspor JSON. Kami mendorong pengguna untuk beralih ke simplifyDDBJson dariunnestDDBJson.

Mengkonfigurasi paralleisme dalam operasi DynamoDB

Untuk meningkatkan kinerja, Anda dapat menyetel parameter tertentu yang tersedia untuk konektor DynamoDB. Tujuan Anda saat menyetel parameter paralleisme adalah 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 parameter saat menggunakan konektor ETL. dynamodb.splits Saat membaca dengan konektor ekspor, Anda tidak perlu mengkonfigurasi jumlah split untuk paralelisme pelaksana 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 pengaturan jumlah maksimum pekerja, lihat Jumlah pekerja (NumberOfWorkers) diMengkonfigurasi properti pekerjaan untuk pekerjaan Spark di AWS Glue.

  • 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 mengatur dynamodb.splits ke jumlah slot yang tersedia,numSlots.

Menulis ke DynamoDB

dynamodb.output.numParallelTasksParameter ini 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 ditulis ke DynamoDB. Dalam beberapa kasus, Anda mungkin perlu mengganti perhitungan default untuk meningkatkan kinerja penulisan. Jika Anda tidak menentukan parameter ini, tugas WCU per Spark yang diizinkan akan dihitung secara otomatis dengan rumus berikut:

    • numPartitions = dynamicframe.getNumPartitions()

    • numSlots(seperti yang dijelaskan 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 Glue 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 AWS Glue DynamoDB 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.5mewakili tingkat baca default, artinya AWS Glue akan mencoba mengkonsumsi setengah dari kapasitas baca tabel. Jika Anda meningkatkan nilai di atas0.5, AWS Glue meningkatkan tingkat permintaan; mengurangi nilai di bawah ini 0.5 mengurangi 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-demandAWS 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, lihatMengkonfigurasi paralleisme dalam operasi DynamoDB.

  • "dynamodb.sts.roleArn": (Opsional) ARN IAM role yang akan diambil untuk akses lintas-akun. Parameter ini tersedia dalam 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 dalam AWS Glue 1.0 atau yang lebih baru.

“ConnectionType”: “dynamodb” dengan konektor ekspor DynamoDB AWS Glue 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 diatur untuk ddb mengaktifkan konektor ekspor AWS Glue DynamoDB di mana yang ExportTableToPointInTimeRequest baru akan dipanggil selama pekerjaan. AWS Glue Ekspor baru akan dihasilkan dengan lokasi yang dilewatkan dari dynamodb.s3.bucket dandynamodb.s3.prefix.

    • Jika diatur untuk s3 mengaktifkan konektor ekspor AWS Glue DynamoDB tetapi melewatkan pembuatan ekspor DynamoDB baru dan sebagai gantinya menggunakan dan dynamodb.s3.bucket sebagai lokasi Amazon S3 dari ekspor sebelumnya dari tabel dynamodb.s3.prefix 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 DynamoDB JSON yang hadir dalam ekspor. Ini adalah kesalahan untuk mengatur "dynamodb.unnestDDBJson" dan "dynamodb.simplifyDDBJson" menjadi true 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 DynamoDB ekspor JSON.

  • "dynamodb.simplifyDDBJson": (Opsional) Default: false. Nilai yang valid: boolean. Jika disetel ke true, melakukan transformasi untuk menyederhanakan skema struktur DynamoDB JSON yang hadir dalam ekspor. Ini memiliki tujuan yang sama dengan "dynamodb.unnestDDBJson" opsi tetapi memberikan dukungan yang lebih baik untuk jenis Peta DynamoDB atau bahkan jenis 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 true pada saat yang sama. Untuk informasi selengkapnya, lihat Menyederhanakan penggunaan DynamoDB ekspor JSON.

  • "dynamodb.s3.bucket": (Opsional) Menunjukkan lokasi bucket Amazon S3 di mana proses DynamoDB akan dilakukanExportTableToPointInTime. Format file untuk ekspor adalah DynamoDB JSON.

    • "dynamodb.s3.prefix": (Opsional) Menunjukkan lokasi awalan Amazon S3 di dalam bucket Amazon S3 tempat pemuatan DynamoDB akan disimpan. ExportTableToPointInTime Jika tidak dynamodb.s3.bucket ada dynamodb.s3.prefix atau 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 Glue.

    • "dynamodb.s3.bucketOwner": Menunjukkan pemilik bucket yang diperlukan untuk akses Amazon S3 lintas akun.

  • "dynamodb.sts.roleArn": (Opsional) ARN peran IAM akan diasumsikan untuk akses lintas akun dan/atau akses lintas wilayah untuk tabel DynamoDB. Catatan: ARN peran IAM yang sama akan digunakan untuk mengakses lokasi Amazon S3 yang ditentukan untuk permintaan tersebut. ExportTableToPointInTime

  • "dynamodb.sts.roleSessionName": (Opsional) Nama sesi STS. Default diatur ke "glue-dynamodb-read-sts-session”.

  • "dynamodb.exportTime"(Opsional) Nilai yang valid: string yang mewakili instan ISO-8601. A point-in-time 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 wastafel

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.5mewakili tingkat tulis default, yang berarti bahwa AWS Glue akan mencoba untuk 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-demandAWS 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 masuk akal untuk nilai ini. Untuk informasi selengkapnya, lihat Mengkonfigurasi paralleisme dalam operasi DynamoDB.

  • "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”.