Verbindungstypen und Optionen für ETL in AWS Glue für Spark - AWS Glue
DataFrame OptionenBenutzerdefiniert und Verbindungen AWS Marketplace Allgemeine Optionen

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Verbindungstypen und Optionen für ETL in AWS Glue für Spark

In AWS Glue Spark spezifizieren verschiedene PySpark und Scala-Methoden und Transformationen den Verbindungstyp mithilfe eines connectionType Parameters. Sie geben Verbindungsoptionen mit einem connectionOptions- oder options-Parameter an.

Der connectionType-Parameter kann die in der folgenden Tabelle angegebenen Werte annehmen. Die zugehörigen connectionOptions- (oder options)-Parameterwerte für jeden Typ sind in den folgenden Abschnitten dokumentiert. Sofern nicht anders angegeben, gelten die Parameter, wenn die Verbindung als Quelle oder Senke verwendet wird.

Beispielcode, der das Festlegen und Verwenden von Verbindungsoptionen veranschaulicht, finden Sie auf der Homepage für jeden Verbindungstyp.

connectionType Verbindet mit
dynamodb Amazon-DynamoDB-Datenbank
kinesis Amazon Kinesis Data Streams
S3 Amazon S3
documentdb Amazon-DocumentDB-Datenbank (mit MongoDB-Kompatibilität)
opensearch OpenSearch Amazon-Dienst.
redshift Amazon Redshift-Datenbank
kafka Kafka oder Amazon Managed Streaming for Apache Kafka
azurecosmos Azure Cosmos for NoSQL.
azuresql Azure SQL.
bigquery Google BigQuery.
mongodb MongoDB-Datenbank, einschließlich MongoDB Atlas.
sqlserver Microsoft SQL Server-Datenbank (siehe JDBC-Verbindungen)
mysql- MySQL-Datenbankserver (siehe JDBC-Verbindungen).
oracle Oracle-Datenbank (siehe JDBC-Verbindungen)
postgresql PostgreSQL-Datenbank (siehe JDBC-Verbindungen)
saphana SAP HANA.
snowflake Snowflake Data Lake
teradata Teradata Vantage.
vertica Vertica.
benutzerdefiniert.* Spark-, Athena- oder JDBC-Datenspeicher (siehe Custom- und AWS Marketplace ConnectionType-Werte
marketplace.* Spark-, Athena- oder JDBC-Datenspeicher (siehe Custom- und AWS Marketplace ConnectionType-Werte)

DataFrame Optionen für ETL in AWS Glue 5.0 für Spark

A DataFrame ist ein Datensatz, der ähnlich einer Tabelle in benannte Spalten organisiert ist und Operationen im Funktionsstil (map/reduce/filter/etc.) und SQL-Operationen (Select, Project, Aggregate) unterstützt.

Um eine DataFrame für eine von Glue unterstützte Datenquelle zu erstellen, ist Folgendes erforderlich:

  • Datenquellen-Konnektor ClassName

  • Datenquellenverbindung Options

In ähnlicher Weise sind dieselben erforderlich, DataFrame um in eine von Glue unterstützte Datensenke zu schreiben:

  • Anschluss für eine Datensenke ClassName

  • Datensenkenverbindung Options

Beachten Sie, dass AWS Glue-Funktionen wie Job-Lesezeichen und DynamicFrame Optionen wie in nicht unterstützt connectionName werden DataFrame. Weitere Informationen zu DataFrame und den unterstützten Vorgängen finden Sie in der Spark-Dokumentation für DataFrame.

Den Konnektor angeben ClassName

Um die ClassName einer Datenquelle/Datensenke anzugeben, verwenden Sie die .format Option, um den entsprechenden Konnektor ClassName bereitzustellen, der die Datenquelle/Senke definiert.

JDBC-Konnektoren

Geben Sie für JDBC-Konnektoren den Wert der Option an und geben Sie jdbc den JDBC-Treiber in der .format Option an. ClassName driver

df = spark.read.format("jdbc").option("driver", "<DATA SOURCE JDBC DRIVER CLASSNAME>")...

df.write.format("jdbc").option("driver", "<DATA SINK JDBC DRIVER CLASSNAME>")...

In der folgenden Tabelle ist der JDBC-Treiber ClassName der unterstützten Datenquelle in AWS Glue for aufgeführt. DataFrames

Datenquelle Treiber ClassName
PostgreSQL org.postgresql.Driver
Oracle oracle.jdbc.driver. OracleDriver
SQLServer com.microsoft.sqlserver.jdbc. SQLServerTreiber
MySQL com.mysql.jdbc.Driver
SAPHana com.sap.db.jdbc.Treiber
Teradata com.teradata.jdbc. TeraDriver
Spark-Steckverbinder

Geben Sie für Funkenstecker den Wert ClassName des Steckers als Wert der .format Option an.

df = spark.read.format("<DATA SOURCE CONNECTOR CLASSNAME>")...

df.write.format("<DATA SINK CONNECTOR CLASSNAME>")...

In der folgenden Tabelle ist der Spark-Konnektor ClassName der unterstützten Datenquelle in AWS Glue for aufgeführt DataFrames.

Datenquelle ClassName
MongoDB/DocumentDB glue.spark.mongodb
Redshift io.github.spark_redshift_community.spark.redshift
AzureCosmos kosmos.oltp
AzureSQL com.microsoft.sqlserver.jdbc.spark
BigQuery com.google.cloud.spark.bigquery
OpenSearch org.opensearch.spark.sql
Snowflake net.snowflake.spark.snowflake
Vertica com.vertica.spark.Datenquelle. VerticaSource

Angabe der Verbindungsoptionen

Um die Options Verbindung zu einer Datenquelle/Datensenke anzugeben, verwenden Sie die, .option(<KEY>, <VALUE>) um einzelne Optionen oder .options(<MAP>) mehrere Optionen als Key-Value-Map bereitzustellen.

Jede Datei source/sink unterstützt ihren eigenen Verbindungssatz. Options Einzelheiten zu den verfügbaren Options Verbindungen finden Sie in der öffentlichen Dokumentation des jeweiligen source/sink Daten-Spark-Konnektors, der in der folgenden Tabelle aufgeführt ist.

Beispiele

Die folgenden Beispiele lesen aus PostgreSQL und schreiben hinein: SnowFlake

Python

Beispiel:

from awsglue.context import GlueContext
from pyspark.sql import SparkSession

spark = SparkSession.builder.getOrCreate()

dataSourceClassName = "jdbc"
dataSourceOptions = {
  "driver": "org.postgresql.Driver",
  "url": "<url>",
  "user": "<user>",
  "password": "<password>",
  "dbtable": "<dbtable>",
}

dataframe = spark.read.format(className).options(**options).load()

dataSinkClassName = "net.snowflake.spark.snowflake"
dataSinkOptions = {
  "sfUrl": "<url>",
  "sfUsername": "<username>",
  "sfPassword": "<password>",
  "sfDatabase" -> "<database>",                              
  "sfSchema" -> "<schema>",                       
  "sfWarehouse" -> "<warehouse>"  
}

dataframe.write.format(dataSinkClassName).options(**dataSinkOptions).save()
Scala

Beispiel:

import org.apache.spark.sql.SparkSession

val spark = SparkSession.builder().getOrCreate()

val dataSourceClassName = "jdbc"
val dataSourceOptions = Map(
  "driver" -> "org.postgresql.Driver",
  "url" -> "<url>",
  "user" -> "<user>",
  "password" -> "<password>",
  "dbtable" -> "<dbtable>"
)

val dataframe = spark.read.format(dataSourceClassName).options(dataSourceOptions).load()

val dataSinkClassName = "net.snowflake.spark.snowflake"
val dataSinkOptions = Map(
  "sfUrl" -> "<url>",
  "sfUsername" -> "<username>",
  "sfPassword" -> "<password>",
  "sfDatabase" -> "<database>",
  "sfSchema" -> "<schema>",
  "sfWarehouse" -> "<warehouse>"
)

dataframe.write.format(dataSinkClassName).options(dataSinkOptions).save()

Custom- und AWS Marketplace ConnectionType-Werte

Diese umfassen u. a. folgende:

  • "connectionType": "marketplace.athena": Bezeichnet eine Verbindung zu einem Amazon-Athena-Datenspeicher. Die Verbindung verwendet einen Konnektor von AWS Marketplace.

  • "connectionType": "marketplace.spark": Bezeichnet eine Verbindung zu einem Apache-Spark-Datenspeicher. Die Verbindung verwendet einen Anschluss von AWS Marketplace.

  • "connectionType": "marketplace.jdbc": Bezeichnet eine Verbindung zu einem JDBC-Datenspeicher. Die Verbindung verwendet einen Anschluss von AWS Marketplace.

  • "connectionType": "custom.athena": Bezeichnet eine Verbindung zu einem Amazon-Athena-Datenspeicher. Die Verbindung verwendet einen benutzerdefinierten Konnektor, den Sie in AWS Glue Studio hochladen.

  • "connectionType": "custom.spark": Bezeichnet eine Verbindung zu einem Apache-Spark-Datenspeicher. Die Verbindung verwendet einen benutzerdefinierten Konnektor, den Sie in AWS Glue Studio hochladen.

  • "connectionType": "custom.jdbc": Bezeichnet eine Verbindung zu einem JDBC-Datenspeicher. Die Verbindung verwendet einen benutzerdefinierten Konnektor, den Sie in AWS Glue Studio hochladen.

Verbindungsoptionen für den Typ custom.jdbc oder marketplace.jdbc

  • className – Zeichenfolge, erforderlich, Name der Treiberklasse.

  • connectionName – Zeichenfolge, erforderlich, Name der Verbindung, die dem Konnektor zugeordnet ist.

  • url – Zeichenfolge, erforderlich, JDBC-URL mit Platzhaltern (${}), die verwendet werden, um die Verbindung zur Datenquelle herzustellen. Der Platzhalter ${secretKey} wird durch das Secret des gleichen Namens in AWS Secrets Manager ersetzt. Weitere Informationen zum Erstellen der URL finden Sie in der Dokumentation zum Datenspeicher.

  • secretId oder user/password – Zeichenfolge, erforderlich, zum Abrufen der Anmeldeinformationen für die URL.

  • dbTable oder query – Zeichenfolge, erforderlich, die Tabelle oder SQL-Abfrage, aus der die Daten abgerufen werden. Sie können dbTable oder query angeben, aber nicht beides.

  • partitionColumn – Zeichenfolge, optional, der Name einer Ganzzahlspalte, die für die Partitionierung verwendet wird. Diese Option funktioniert nur, wenn sie in lowerBound, upperBound und numPartitions enthalten ist. Diese Option funktioniert auf die gleiche Weise wie im Spark SQL JDBC Reader. Weitere Informationen finden Sie unter JDBC To Other Databases im Apache Spark SQL DataFrames and Datasets Guide.

    Die Werte für lowerBound und upperBound werden verwendet, um den Partitionsschritt zu bestimmen, nicht zum Filtern der Zeilen in der Tabelle. Alle Zeilen der Tabelle werden partitioniert und zurückgegeben.

    Anmerkung

    Wenn Sie eine Abfrage anstelle eines Tabellennamens verwenden, sollten Sie überprüfen, ob die Abfrage mit der angegebenen Partitionierungsbedingung funktioniert. Zum Beispiel:

    • Wenn Ihr Abfrageformat "SELECT col1 FROM table1" lautet, dann testen Sie die Abfrage, indem Sie eine WHERE-Klausel am Ende der Abfrage stellen, die die Partitionsspalte verwendet.

    • Wenn Ihr Abfrageformat SELECT col1 FROM table1 WHERE col2=val" lautet, dann testen Sie die Abfrage, indem Sie die WHERE-Klausel mit AND und einem Ausdruck erweitern, der die Partitionsspalte verwendet.

  • lowerBound – Ganzzahl, optional, der Mindestwert von partitionColumn, der verwendet wird, um Partitionsschritte festzulegen.

  • upperBound – Ganzzahl, optional, der Maximalwert von partitionColumn, der verwendet wird, um Partitionsschritte festzulegen.

  • numPartitions – Ganzzahl, optional, die Anzahl der Partitionen. Dieser Wert, zusammen mit lowerBound (inklusive) und upperBound (exklusiv), bilden Partitionsschritte für generierte WHERE-Klauselausdrücke, die verwendet werden, um die partitionColumn aufzuteilen.

    Wichtig

    Seien Sie vorsichtig mit der Anzahl der Partitionen, da zu viele Partitionen Probleme auf Ihren externen Datenbanksystemen verursachen können.

  • filterPredicate – Zeichenfolge, optional, zusätzliche Bedingungsklausel zum Filtern von Daten aus der Quelle. Zum Beispiel: 

    BillingCity='Mountain View'

    Wenn Sie eine Abfrage anstelle eines Tabellennamens verwenden, sollten Sie überprüfen, ob die Abfrage mit dem angegebenen filterPredicate funktioniert. Zum Beispiel:

    • Wenn Ihr Abfrageformat "SELECT col1 FROM table1" lautet, dann testen Sie die Abfrage, indem Sie eine WHERE-Klausel am Ende der Abfrage stellen, die das Filterprädikat verwendet.

    • Wenn Ihr Abfrageformat "SELECT col1 FROM table1 WHERE col2=val" lautet, dann testen Sie die Abfrage, indem Sie die WHERE-Klausel mit AND und einem Ausdruck erweitern, der das Filterprädikat verwendet.

  • dataTypeMapping – Wörterbuch, optional, benutzerdefiniertes Datentyp-Mapping, das ein Mapping aus einem JDBC-Datentyp auf einen Glue-Datentyp durchführt. Beispielsweise ordnet die Option "dataTypeMapping":{"FLOAT":"STRING"}-Datenfelder des JDBC-Typs FLOAT in den Java-Typ String zu, indem die ResultSet.getString()-Methode des Treibers abgerufen und für die Entwicklung des AWS Glue-Datensatzes verwendet wird. Das ResultSet-Objekt wird von jedem Treiber implementiert, sodass das Verhalten spezifisch für den von Ihnen verwendeten Treiber ist. Informieren Sie sich in der Dokumentation für Ihren JDBC-Treiber, um zu verstehen, wie der Treiber die Konvertierungen durchführt.

  • Die derzeit unterstützten AWS Glue-Datentypen sind:

    • DATUM

    • STRING

    • TIMESTAMP (ZEITSTEMPEL)

    • INT

    • FLOAT

    • LONG

    • BIGDECIMAL

    • BYTE

    • SHORT

    • DOUBLE

    Die unterstützten JDBC-Datentypen sind Java8 java.sql.types.

    Die Standard-Datentyp-Mappings (von JDBC zu AWS Glue) sind:

    • DATUM -> DATUM

    • VARCHAR -> ZEICHENFOLGE

    • CHAR -> ZEICHENFOLGE

    • LONGNVARCHAR -> ZEICHENFOLGE

    • TIMESTAMP -> ZEITSTEMPEL

    • INTEGER -> INT

    • FLOAT -> FLOAT

    • REAL -> FLOAT

    • BIT -> BOOLESCHER WERT

    • BOOLEAN -> BOOLESCHER WERT

    • BIGINT -> LANG

    • DECIMAL -> BIGDECIMAL

    • NUMERIC -> BIGDECIMAL

    • TINYINT -> KURZ

    • SMALLINT -> KURZ

    • DOUBLE -> DOPPELT

    Wenn Sie ein benutzerdefiniertes Datentyp-Mapping mit der Option dataTypeMapping verwenden, können Sie ein Standard-Datentyp-Mapping überschreiben. Nur die JDBC-Datentypen, die in der Option dataTypeMapping betroffen sind. Das Standardmapping wird für alle anderen JDBC-Datentypen verwendet. Sie können bei Bedarf Mappings für zusätzliche JDBC-Datentypen hinzufügen. Wenn ein JDBC-Datentyp weder im Standard-Mapping noch in einem benutzerdefinierten Mapping enthalten ist, wird der Datentyp standardmäßig in den Datentyp AWS Glue STRING umgewandelt.

Das folgende Python-Codebeispiel zeigt, wie mit AWS Marketplace JDBC-Treibern aus JDBC-Datenbanken gelesen wird. Es demonstriert das Lesen aus einer Datenbank und das Schreiben in einen S3-Speicherort. 

    import sys
    from awsglue.transforms import *
    from awsglue.utils import getResolvedOptions
    from pyspark.context import SparkContext
    from awsglue.context import GlueContext
    from awsglue.job import Job
     
    ## @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)
    ## @type: DataSource
    ## @args: [connection_type = "marketplace.jdbc", connection_options = 
     {"dataTypeMapping":{"INTEGER":"STRING"},"upperBound":"200","query":"select id, 
       name, department from department where id < 200","numPartitions":"4",
       "partitionColumn":"id","lowerBound":"0","connectionName":"test-connection-jdbc"},
        transformation_ctx = "DataSource0"]
    ## @return: DataSource0
    ## @inputs: []
    DataSource0 = glueContext.create_dynamic_frame.from_options(connection_type = 
      "marketplace.jdbc", connection_options = {"dataTypeMapping":{"INTEGER":"STRING"},
      "upperBound":"200","query":"select id, name, department from department where 
       id < 200","numPartitions":"4","partitionColumn":"id","lowerBound":"0",
       "connectionName":"test-connection-jdbc"}, transformation_ctx = "DataSource0")
    ## @type: ApplyMapping
    ## @args: [mappings = [("department", "string", "department", "string"), ("name", "string",
      "name", "string"), ("id", "int", "id", "int")], transformation_ctx = "Transform0"]
    ## @return: Transform0
    ## @inputs: [frame = DataSource0]
    Transform0 = ApplyMapping.apply(frame = DataSource0, mappings = [("department", "string",
      "department", "string"), ("name", "string", "name", "string"), ("id", "int", "id", "int")], 
       transformation_ctx = "Transform0")
    ## @type: DataSink
    ## @args: [connection_type = "s3", format = "json", connection_options = {"path": 
     "s3://<S3 path>/", "partitionKeys": []}, transformation_ctx = "DataSink0"]
    ## @return: DataSink0
    ## @inputs: [frame = Transform0]
    DataSink0 = glueContext.write_dynamic_frame.from_options(frame = Transform0, 
      connection_type = "s3", format = "json", connection_options = {"path": 
      "s3://<S3 path>/", "partitionKeys": []}, transformation_ctx = "DataSink0")
    job.commit()

Verbindungsoptionen für den Typ custom.athena oder marketplace.athena

  • className – Zeichenfolge, erforderlich, Name der Treiberklasse. Wenn Sie den CloudWatch Athena-Konnektor verwenden, ist dieser Parameterwert das Präfix des Klassennamens (z. B."com.amazonaws.athena.connectors"). Der CloudWatch Athena-Connector besteht aus zwei Klassen: einem Metadaten-Handler und einem Record-Handler. Wenn Sie hier das allgemeine Präfix angeben, lädt die API die richtigen Klassen basierend auf diesem Präfix.

  • tableName— Zeichenfolge, erforderlich, der Name des zu CloudWatch lesenden Log-Streams. Dieses Codefragment verwendet den speziellen Ansichtsnamen all_log_streams, was bedeutet, dass der zurückgegebene dynamische Datenrahmen Daten aus allen Protokollstreams in der Protokollgruppe enthält.

  • schemaName— Zeichenfolge, erforderlich, der Name der CloudWatch Protokollgruppe, aus der gelesen werden soll. Beispiel, /aws-glue/jobs/output.

  • connectionName – Zeichenfolge, erforderlich, Name der Verbindung, die dem Konnektor zugeordnet ist.

Weitere Optionen für diesen Connector finden Sie in der Amazon Athena CloudWatch Connector-README-Datei unter. GitHub

Im folgenden Python-Codebeispiel wird gezeigt, wie aus einem Athena-Datenspeicher mithilfe eines AWS Marketplace -Konnektoren gelesen wird. Es demonstriert das Lesen aus Athena und das Schreiben in einen S3-Speicherort. 

    import sys
    from awsglue.transforms import *
    from awsglue.utils import getResolvedOptions
    from pyspark.context import SparkContext
    from awsglue.context import GlueContext
    from awsglue.job import Job
     
    ## @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)
    ## @type: DataSource
    ## @args: [connection_type = "marketplace.athena", connection_options = 
     {"tableName":"all_log_streams","schemaName":"/aws-glue/jobs/output",
      "connectionName":"test-connection-athena"}, transformation_ctx = "DataSource0"]
    ## @return: DataSource0
    ## @inputs: []
    DataSource0 = glueContext.create_dynamic_frame.from_options(connection_type = 
      "marketplace.athena", connection_options = {"tableName":"all_log_streams",,
      "schemaName":"/aws-glue/jobs/output","connectionName":
      "test-connection-athena"}, transformation_ctx = "DataSource0")
    ## @type: ApplyMapping
    ## @args: [mappings = [("department", "string", "department", "string"), ("name", "string",
      "name", "string"), ("id", "int", "id", "int")], transformation_ctx = "Transform0"]
    ## @return: Transform0
    ## @inputs: [frame = DataSource0]
    Transform0 = ApplyMapping.apply(frame = DataSource0, mappings = [("department", "string",
      "department", "string"), ("name", "string", "name", "string"), ("id", "int", "id", "int")], 
       transformation_ctx = "Transform0")
    ## @type: DataSink
    ## @args: [connection_type = "s3", format = "json", connection_options = {"path": 
     "s3://<S3 path>/", "partitionKeys": []}, transformation_ctx = "DataSink0"]
    ## @return: DataSink0
    ## @inputs: [frame = Transform0]
    DataSink0 = glueContext.write_dynamic_frame.from_options(frame = Transform0, 
      connection_type = "s3", format = "json", connection_options = {"path": 
      "s3://<S3 path>/", "partitionKeys": []}, transformation_ctx = "DataSink0")
    job.commit()

Verbindungsoptionen für den Typ custom.spark oder marketplace.spark

  • className – Zeichenfolge, erforderlich, Konnektor-Klassenname.

  • secretId – Zeichenfolge, optional, wird zum Abrufen der Anmeldeinformationen für die Konnektor-Verbindung verwendet.

  • connectionName – Zeichenfolge, erforderlich, Name der Verbindung, die dem Konnektor zugeordnet ist.

  • Andere Optionen hängen vom Datenspeicher ab. Beispielsweise beginnen die OpenSearch Konfigurationsoptionen mit dem Präfixes, wie in der Elasticsearch for Apache Hadoop-Dokumentation beschrieben. Spark-Verbindungen zu Snowflake verwenden Optionen wie sfUser und sfPassword, wie unter Using the Spark Connector (Verwenden des Spark-Connectors) im Handbuch Connecting to Snowflake (Verbindung mit Snowflake herstellen) beschrieben.

Das folgende Python-Codebeispiel zeigt, wie mithilfe einer marketplace.spark Verbindung aus einem OpenSearch Datenspeicher gelesen wird.

    import sys
    from awsglue.transforms import *
    from awsglue.utils import getResolvedOptions
    from pyspark.context import SparkContext
    from awsglue.context import GlueContext
    from awsglue.job import Job
     
    ## @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)
    ## @type: DataSource
    ## @args: [connection_type = "marketplace.spark", connection_options = {"path":"test",
      "es.nodes.wan.only":"true","es.nodes":"https://<AWS endpoint>",
      "connectionName":"test-spark-es","es.port":"443"}, transformation_ctx = "DataSource0"]
    ## @return: DataSource0
    ## @inputs: []
    DataSource0 = glueContext.create_dynamic_frame.from_options(connection_type = 
      "marketplace.spark", connection_options = {"path":"test","es.nodes.wan.only":
      "true","es.nodes":"https://<AWS endpoint>","connectionName":
      "test-spark-es","es.port":"443"}, transformation_ctx = "DataSource0")
    ## @type: DataSink
    ## @args: [connection_type = "s3", format = "json", connection_options = {"path": 
         "s3://<S3 path>/", "partitionKeys": []}, transformation_ctx = "DataSink0"]
    ## @return: DataSink0
    ## @inputs: [frame = DataSource0]
    DataSink0 = glueContext.write_dynamic_frame.from_options(frame = DataSource0, 
       connection_type = "s3", format = "json", connection_options = {"path": 
       "s3://<S3 path>/", "partitionKeys": []}, transformation_ctx = "DataSink0")
    job.commit()

Allgemeine Optionen

Die Optionen in diesem Abschnitt werden als connection_options bereitgestellt, gelten jedoch nicht speziell für einen Konnektor.

Die folgenden Parameter werden im Allgemeinen bei der Konfiguration von Lesezeichen verwendet. Sie können für Amazon-S3- oder JDBC-Workflows gelten. Weitere Informationen finden Sie unter Verwenden von Auftragslesezeichen.

  • jobBookmarkKeys – Ein Array von Spaltennamen.

  • jobBookmarkKeysSortOrder – Zeichenfolge, die definiert, wie Werte basierend auf der Sortierreihenfolge verglichen werden. Zulässige Werte: "asc", "desc".

  • useS3ListImplementation – Wird zur Verwaltung der Speicherleistung beim Auflisten von Amazon-S3-Bucket-Inhalten verwendet. Weitere Informationen finden Sie unter Optimieren der Speicherverwaltung in AWS Glue.