DynamoDB-Verbindungen

Sie können AWS Glue for Spark verwenden, um in DynamoDB in Glue aus Tabellen zu lesen und in sie zu schreiben. AWS Sie stellen mithilfe der IAM-Berechtigungen, die mit Ihrem AWS Glue-Job verknüpft sind, eine Verbindung zu DynamoDB her. AWS Glue unterstützt das Schreiben von Daten in die DynamoDB-Tabelle eines anderen AWS Kontos. Weitere Informationen finden Sie unter Konten- und regionenübergreifender Zugriff auf DynamoDB-Tabellen.

Zusätzlich zu AWS Glue DynamoDB-ETL-Konnektor, Sie können mithilfe des DynamoDB-Exportconnectors aus DynamoDB lesen, der eine ExportTableToPointInTime DynamoDB-Anfrage aufruft und sie an einem von Ihnen angegebenen Amazon S3 S3-Speicherort im Format von DynamoDB JSON speichert. AWS Glue erstellt dann ein DynamicFrame Objekt, indem die Daten vom Amazon S3 S3-Exportspeicherort gelesen werden.

Der DynamoDB-Writer ist verfügbar in AWS Glue Version 1.0 oder spätere Versionen. Das Tool AWS Glue Der DynamoDB-Exportconnector ist verfügbar in AWS Glue Version 2.0 oder spätere Versionen.

Weitere Informationen zu DynamoDB finden Sie in der Dokumentation zu Amazon DynamoDB.

Anmerkung

Der DynamoDB-ETL-Reader unterstützt keine Filter oder Pushdown-Prädikate.

Konfigurieren von DynamoDB-Verbindungen

Um von AWS Glue aus eine Verbindung zu DynamoDB herzustellen, erteilen Sie der mit Ihrem AWS Glue-Job verknüpften IAM-Rolle die Erlaubnis, mit DynamoDB zu interagieren. Weitere Informationen zu Berechtigungen auf Ressourcenebene, die zum Lesen und Schreiben in DynamoDB erforderlich sind, finden Sie unter Aktionen, Ressourcen und Bedingungsschlüssel für DynamoDB in der Dokumentation zu IAM.

In den folgenden Situationen ist möglicherweise eine zusätzliche Konfiguration erforderlich:

• Wenn Sie den DynamoDB-Export-Konnektor verwenden, müssen Sie IAM so konfigurieren, dass Ihr Auftrag DynamoDB-Tabellenexporte anfordern kann. Darüber hinaus müssen Sie einen Amazon S3 S3-Bucket für den Export identifizieren und die entsprechenden Berechtigungen in IAM bereitstellen, damit DynamoDB in diesen Bucket schreiben und Ihr AWS Glue-Job daraus lesen kann. Weitere Informationen finden Sie unter Anfordern eines Tabellenexports in DynamoDB.

• Wenn Ihr AWS Glue-Job spezielle Amazon VPC-Konnektivitätsanforderungen hat, verwenden Sie den NETWORK AWS Glue-Verbindungstyp, um Netzwerkoptionen bereitzustellen. Da der Zugriff auf DynamoDB von IAM autorisiert wird, ist kein AWS Glue DynamoDB-Verbindungstyp erforderlich.

Aus DynamoDB lesen und in DynamoDB schreiben

In den folgenden Codebeispielen wird gezeigt, wie DynamoDB-Tabellen (über den ETL Connector) gelesen und geschrieben werden. Sie demonstrieren das Lesen von einer Tabelle und das Schreiben in eine andere Tabelle.

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

}

Verwenden des DynamoDB-Export-Konnektors

Der Export-Konnektor funktioniert besser als der ETL-Konnektor, wenn die DynamoDB-Tabelle größer als 80 GB ist. Da die Exportanforderung außerdem außerhalb der Spark-Prozesse in einem AWS Glue Job, Sie können die auto Skalierung von AWS Glue-Jobs aktivieren, um die DPU-Nutzung während der Exportanforderung zu sparen. Mit dem Export-Konnektor müssen Sie auch nicht die Anzahl der Aufteilungen für die Parallelität des Spark-Executors oder den Prozentsatz des DynamoDB-Durchsatzes konfigurieren.

Anmerkung

DynamoDB hat spezifische Anforderungen, um ExportTableToPointInTime-Anforderungen aufzurufen. Weitere Informationen finden Sie unter Anfordern eines Tabellenexports in DynamoDB. Zum Beispiel muss Point-in-Time-Restore (PITR) in der Tabelle aktiviert sein, um diesen Konnektor verwenden zu können. Der DynamoDB-Connector unterstützt auch die AWS KMS Verschlüsselung von DynamoDB-Exporten nach Amazon S3. Wenn Sie Ihre Sicherheitskonfiguration in der AWS Glue-Job-Konfiguration angeben, wird die AWS KMS Verschlüsselung für einen DynamoDB-Export aktiviert. Der KMS-Schlüssel muss sich in derselben Region wie der Amazon-S3-Bucket befinden.

Beachten Sie, dass zusätzliche Gebühren für den DynamoDB-Export und Amazon-S3-Speicherkosten anfallen. Exportierte Daten in Amazon S3 bleiben bestehen, nachdem ein Auftrag ausgeführt wurde, sodass Sie sie ohne zusätzliche DynamoDB-Exporte wiederverwenden können. Voraussetzung für die Verwendung dieses Connectors ist, dass point-in-time Recovery (PITR) für die Tabelle aktiviert ist.

Der DynamoDB-ETL-Konnektor oder Export-Konnektor unterstützt keine Filter oder Pushdown-Prädikate, die an der DynamoDB-Quelle angewendet werden sollen.

In den folgenden Codebeispielen wird gezeigt, wie die Anzahl der Partitionen (über den Export-Konnektor) gelesen und gedruckt werden.

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

}

Diese Beispiele zeigen, wie aus einer AWS Glue Data Catalog-Tabelle, die eine dynamodb Klassifizierung hat, gelesen (über den Export-Connector) und wie die Anzahl der Partitionen gedruckt wird:

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

Vereinfachung der Verwendung einer DynamoDB-Export-JSON

Die DynamoDB-Exporte mit dem AWS Glue Der DynamoDB-Exportkonnektor führt zu JSON-Dateien mit bestimmten verschachtelten Strukturen. Weitere Informationen finden Sie unter Datenobjekte. AWS Glue stellt eine DynamicFrame Transformation bereit, mit der solche Strukturen in ein easier-to-use Formular für nachgelagerte Anwendungen umgewandelt werden können.

Die Transformation kann auf zwei Arten aufgerufen werden. Beim Aufrufen einer Methode zum Lesen aus DynamoDB können Sie die Verbindungsoption "dynamodb.simplifyDDBJson" mit dem Wert "true" festlegen. Sie können die Transformation auch als eigenständige Methode aufrufen, die in der AWS Glue-Bibliothek verfügbar ist.

Betrachten Sie das folgende Schema, das durch einen DynamoDB-Export generiert wurde:

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

Die Transformation simplifyDDBJson vereinfacht dies zu:

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

Anmerkung

simplifyDDBJsonist in AWS Glue 3.0 und späteren Versionen verfügbar. Mit der Transformation unnestDDBJson können Sie auch das JSON aus einem DynamoDB-Export vereinfachen. Wir empfehlen Benutzern, von unnestDDBJson auf simplifyDDBJson umzusteigen.

Konfigurieren der Parallelisierung bei DynamoDB-Vorgängen

Um die Leistung zu verbessern, können Sie bestimmte für den DynamoDB-Konnektor verfügbare Parameter anpassen. Ihr Ziel bei der Optimierung der Parallelitätsparameter besteht darin, die Nutzung der bereitgestellten AWS Glue-Worker zu maximieren. Wenn Sie dann mehr Leistung benötigen, empfehlen wir Ihnen, Ihren Job zu skalieren, indem Sie die Anzahl der Aufgaben erhöhen. DPUs

Sie können die Parallelisierung in einem DynamoDB-Lesevorgang mit dem Parameter dynamodb.splits ändern, wenn Sie den ETL-Konnektor verwenden. Wenn Sie den Export-Konnektor zum Lesen verwenden, müssen Sie die Anzahl der Splits für die Spark-Executor-Parallelisierung nicht konfigurieren. Sie können die Parallelisierung in einem DynamoDB-Schreibvorgang mit dynamodb.output.numParallelTasks ändern.

Lesen mit dem DynamoDB-ETL-Konnektor

Wir empfehlen Ihnen, die Berechnung von dynamodb.splits auf der Grundlage der in Ihrer Auftragskonfiguration festgelegten maximalen Anzahl von Workern und der folgenden numSlots-Berechnung durchzuführen. Bei einer automatischen Skalierung kann sich die tatsächliche Anzahl verfügbarer Worker unter dieser Obergrenze ändern. Weitere Informationen zur Festlegung der Höchstzahl an Workern finden Sie unter Anzahl der Worker (NumberOfWorkers) inKonfiguration der Auftragseigenschaften für Spark-Jobs in AWS Glue.

• numExecutors = NumberOfWorkers - 1

  Für den Kontext ist ein Executor für den Spark-Treiber reserviert; andere Executors werden für die Datenverarbeitung verwendet.

• numSlotsPerExecutor =

  AWS Glue 3.0 and later versions

  • 4 wenn WorkerType gleich G.1X

  • 8 wenn WorkerType gleich G.2X

  • 16 wenn WorkerType gleich G.4X

  • 32 wenn WorkerType gleich G.8X

  AWS Glue 2.0 and legacy versions

  • 8 wenn WorkerType gleich G.1X

  • 16 wenn WorkerType gleich G.2X

• numSlots = numSlotsPerExecutor * numExecutors

Wir empfehlen Ihnen dynamodb.splits auf die Anzahl der verfügbaren Slots einzustellen, numSlots.

In DynamoDB schreiben

Der Parameter dynamodb.output.numParallelTasks wird verwendet, um die WCU pro Spark-Aufgabe anhand der folgenden Berechnung zu bestimmen:

permittedWcuPerTask = ( TableWCU * dynamodb.throughput.write.percent ) / dynamodb.output.numParallelTasks

Der DynamoDB-Writer funktioniert am besten, wenn die Konfiguration die Anzahl der Spark-Aufgaben, die in DynamoDB schreiben, genau wiedergibt. In manchen Fällen müssen Sie die Standardberechnung außer Kraft setzen, um die Schreibleistung zu verbessern. Wenn Sie diesen Parameter nicht angeben, wird die zulässige WCU pro Spark-Aufgabe automatisch nach der folgenden Formel berechnet:

• • numPartitions = dynamicframe.getNumPartitions()

  • numSlots (wie zuvor in diesem Abschnitt definiert)

  • numParallelTasks = min(numPartitions, numSlots)

• Beispiel 1. DPU=10, =Standard. WorkerType Die Eingabe DynamicFrame hat 100 RDD-Partitionen.

  • numPartitions = 100

  • numExecutors = (10 - 1) * 2 - 1 = 17

  • numSlots = 4 * 17 = 68

  • numParallelTasks = min(100, 68) = 68

• Beispiel 2. DPU = 10, =Standard. WorkerType Die Eingabe DynamicFrame hat 20 RDD-Partitionen.

  • numPartitions = 20

  • numExecutors = (10 - 1) * 2 - 1 = 17

  • numSlots = 4 * 17 = 68

  • numParallelTasks = min(20, 68) = 20

Anmerkung

Jobs auf älteren AWS Glue-Versionen und solche, die Standard-Worker verwenden, erfordern unterschiedliche Methoden zur Berechnung der Anzahl der Slots. Wenn Sie die Leistung dieser Jobs optimieren müssen, empfehlen wir Ihnen, auf unterstützte AWS Glue-Versionen umzusteigen.

Referenz zur DynamoDB-Verbindungsoption

Bezeichnet eine Verbindung mit Amazon DynamoDB.

Die Anschlussmöglichkeiten bei einer Quellverbindung und eine Senkenverbindung unterscheiden sich.

„connectionType“: „dynamodb“ mit dem ETL-Konnektor als Quelle

Verwenden Sie die folgenden Verbindungsoptionen "connectionType": "dynamodb" als Quelle, wenn Sie den AWS Glue DynamoDB ETL-Konnektor verwenden:

• "dynamodb.input.tableName": (Erforderlich) Die zu lesende DynamoDB-Tabelle.

• "dynamodb.throughput.read.percent" (optional): Der Prozentsatz der zu verwendenden Lesekapazitätseinheiten (Read Capacity Units, RCU). Der Standard ist auf „0,5“ gesetzt. Zulässigen Werte sind „0,1“ bis „1,5“ inklusive.

  • 0.5steht für die Standard-Leserate, d. h. AWS Glue versucht, die Hälfte der Lesekapazität der Tabelle zu verbrauchen. Wenn Sie den obigen Wert erhöhen0.5, AWS Glue erhöht die Anforderungsrate. Wenn Sie den Wert unter diesen Wert verringern, 0.5 verringert sich die Leseanforderungsrate. (Die tatsächliche Leserate variiert abhängig von Faktoren wie der Tatsache, ob eine einheitliche Verteilung des Schlüssels in der DynamoDB-Tabelle vorliegt.)

  • Wenn sich die DynamoDB-Tabelle im On-Demand-Modus befindet, AWS Glue behandelt die Lesekapazität der Tabelle als 40000. Zum Exportieren einer großen Tabelle empfehlen wir, Ihre DynamoDB-Tabelle in den On-Demand-Modus zu ändern.

• "dynamodb.splits": (Optional) Definiert die Anzahl der Teile, in die diese DynamoDB-Tabelle beim Lesen partitioniert wird. Der Standard ist auf „1“ gesetzt. Zulässigen Werte sind „1“ bis „1,000,000“ inklusive.

  1 stellt dar, dass es keine Parallelität gibt. Es wird dringend empfohlen, dass Sie einen größeren Wert für eine bessere Leistung angeben, indem Sie die folgende Formel verwenden. Weitere Informationen zur korrekten Einstellung eines Werts finden Sie unter Konfigurieren der Parallelisierung bei DynamoDB-Vorgängen.

• "dynamodb.sts.roleArn": (Optional) Die IAM-Rolle ARN, die für den kontoübergreifenden Zugriff angenommen werden soll. Dieser Parameter ist verfügbar in AWS Glue 1.0 oder höher.

• "dynamodb.sts.roleSessionName": (Optional) Name der STS-Sitzung. Die Standardeinstellung ist "glue-dynamodb-read-sts-session“. Dieser Parameter ist verfügbar in AWS Glue 1.0 oder höher.

„connectionType“: „dynamodb“ mit dem AWS Glue DynamoDB-Exportkonnektor als Quelle

Verwenden Sie die folgenden Verbindungsoptionen mit „connectionType“: „dynamodb“ als Quelle, wenn Sie AWS Glue DynamoDB-Exportconnector, der nur verfügbar ist für AWS Glue ab Version 2.0:

• "dynamodb.export": (Erforderlich) Ein Zeichenfolgenwert:

  • Wenn auf gesetzt, ddb aktiviert AWS Glue DynamoDB-Exportconnector, bei dem ein neuer aufgerufen ExportTableToPointInTimeRequest wird während des AWS Glue Arbeit. Ein neuer Export wird mit dem Speicherort generiert, der von dynamodb.s3.bucket an dynamodb.s3.prefix übergeben wurde.

  • Wenn auf gesetzt, s3 aktiviert es AWS Glue DynamoDB-Exportconnector überspringt jedoch die Erstellung eines neuen DynamoDB-Exports und verwendet stattdessen dynamodb.s3.bucket und dynamodb.s3.prefix als Amazon S3 S3-Speicherort für einen früheren Export dieser Tabelle.

• "dynamodb.tableArn": (Erforderlich) Die zu lesende DynamoDB-Tabelle.

• "dynamodb.unnestDDBJson": (Optional) Standard: falsch. Zulässige Werte: Boolesch. Wenn der Wert auf „true“ festgelegt ist, wird die Verschachtelung der DynamoDB-JSON-Struktur, die in den Exporten vorhanden ist, durch eine Transformation aufgehoben. Es ist ein Fehler, "dynamodb.unnestDDBJson" und "dynamodb.simplifyDDBJson" gleichzeitig auf „true“ zu setzen. In AWS Glue 3.0 und späteren Versionen empfehlen wir die Verwendung"dynamodb.simplifyDDBJson", um das Verhalten bei der Vereinfachung von DynamoDB-Zuordnungstypen zu verbessern. Weitere Informationen finden Sie unter Vereinfachung der Verwendung einer DynamoDB-Export-JSON.

• "dynamodb.simplifyDDBJson": (Optional) Standard: falsch. Zulässige Werte: Boolesch. Wenn der Wert auf „true“ festgelegt ist, wird eine Transformation zur Vereinfachung der DynamoDB-JSON-Struktur, die in den Exporten vorhanden ist, durchgeführt. Dies hat den gleichen Zweck wie die Option "dynamodb.unnestDDBJson", bietet jedoch eine bessere Unterstützung für DynamoDB-Zuordnungstypen oder sogar verschachtelte Zuordnungstypen in Ihrer DynamoDB-Tabelle. Diese Option ist in AWS Glue 3.0 und späteren Versionen verfügbar. Es ist ein Fehler, "dynamodb.unnestDDBJson" und "dynamodb.simplifyDDBJson" gleichzeitig auf „true“ zu setzen. Weitere Informationen finden Sie unter Vereinfachung der Verwendung einer DynamoDB-Export-JSON.

• "dynamodb.s3.bucket": (Optional) Gibt den Speicherort des Amazon S3 Bucket an, in dem der DynamoDB ExportTableToPointInTime-Prozess durchgeführt werden soll. Das Dateiformat für den Export ist DynamoDB JSON.

  • "dynamodb.s3.prefix": (Optional) Gibt den Speicherort des Amazon S3-Präfixes im AmazonS3 Bucket an, in dem die DynamoDB ExportTableToPointInTime-Lasten gespeichert werden sollen. Wenn dynamodb.s3.prefix weder angegeben noch angegeben dynamodb.s3.bucket werden, werden diese Werte standardmäßig auf den Speicherort des temporären Verzeichnisses gesetzt, der in AWS Glue Auftragskonfiguration. Weitere Informationen finden Sie unter Von AWS Glue verwendete Spezialparameter.

  • "dynamodb.s3.bucketOwner": Zeigt den Bucket-Besitzer an, der für den kontoübergreifenden Amazon-S3-Zugriff benötigt wird.

• "dynamodb.sts.roleArn": (Optional) Der IAM-Rollen-ARN, der für den kontoübergreifenden Zugriff und/oder den regionsübergreifenden Zugriff auf die DynamoDB-Tabelle übernommen werden soll. Hinweis: Dieselbe IAM-Rolle ARN wird für den Zugriff auf den für die ExportTableToPointInTime-Anfrage angegebenen Amazon S3-Speicherort verwendet.

• "dynamodb.sts.roleSessionName": (Optional) Name der STS-Sitzung. Die Standardeinstellung ist "glue-dynamodb-read-sts-session“.

• "dynamodb.exportTime": (Optional) Gültige Werte: Zeichenfolgen, die ISO-8601-Instanzen darstellen. A, point-in-time an dem der Export erfolgen soll.

• "dynamodb.sts.region": (Erforderlich, wenn ein regionsübergreifender Aufruf über einen regionalen Endpunkt getätigt wird). Die Region, in der sich die DynamoDB-Tabelle befindet, die Sie lesen möchten.

„connectionType“: „dynamodb“ mit dem ETL-Konnektor als Senke

Verwenden Sie die folgenden Verbindungsoptionen mit "connectionType": "dynamodb" als Senke:

• "dynamodb.output.tableName": (Erforderlich) Die DynamoDB-Tabelle, in die geschrieben werden soll.

• "dynamodb.throughput.write.percent" (optional): Der Prozentsatz der zu verwendenden Schreibkapazitätseinheiten (Write Capacity Units, WCU). Der Standard ist auf „0,5“ gesetzt. Zulässigen Werte sind „0,1“ bis „1,5“ inklusive.

  • 0.5steht für die Standard-Schreibrate, was bedeutet, dass AWS Glue versucht, die Hälfte der Schreibkapazität der Tabelle zu verbrauchen. Wenn Sie den Wert über 0,5 erhöhen, AWS Glue erhöht die Anforderungsrate; wenn der Wert unter 0,5 sinkt, sinkt die Schreibanforderungsrate. (Die tatsächliche Schreibrate variiert abhängig von Faktoren wie der Tatsache, ob eine einheitliche Verteilung des Schlüssels in der DynamoDB-Tabelle vorliegt.)

  • Wenn sich die DynamoDB-Tabelle im On-Demand-Modus befindet, AWS Glue behandelt die Schreibkapazität der Tabelle als. 40000 Zum Importieren einer großen Tabelle empfehlen wir, Ihre DynamoDB-Tabelle in den On-Demand-Modus zu ändern.

• "dynamodb.output.numParallelTasks": (Optional) definiert, wie viele parallele Aufgaben gleichzeitig in DynamoDB geschrieben werden. Wird verwendet, um berechtigende WCU pro Spark-Aufgabe zu berechnen. In den meisten Fällen berechnet AWS Glue einen angemessenen Standardwert für diesen Wert. Weitere Informationen finden Sie unter Konfigurieren der Parallelisierung bei DynamoDB-Vorgängen.

• "dynamodb.output.retry": (Optional) Definiert die Anzahl erneuter Versuche, die durchgeführt werden, wenn es eine ProvisionedThroughputExceededException aus DynamoDB gibt. Der Standard ist auf „10“ gesetzt.

• "dynamodb.sts.roleArn": (Optional) Die IAM-Rolle ARN, die für den kontoübergreifenden Zugriff angenommen werden soll.

• "dynamodb.sts.roleSessionName": (Optional) Name der STS-Sitzung. Die Standardeinstellung ist auf "glue-dynamodb-write-sts-session“ gesetzt.