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](aws-glue-programming-etl-connect-dynamodb-home.md) | [Amazon-DynamoDB-Datenbank](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) | | [kinesis](aws-glue-programming-etl-connect-kinesis-home.md) | [Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/introduction.html) | | [S3](aws-glue-programming-etl-connect-s3-home.md) | [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/dev/) | | [documentdb](aws-glue-programming-etl-connect-documentdb-home.md#aws-glue-programming-etl-connect-documentdb) | [Amazon-DocumentDB-Datenbank (mit MongoDB-Kompatibilität)](https://docs.aws.amazon.com/documentdb/latest/developerguide/) | | [opensearch](aws-glue-programming-etl-connect-opensearch-home.md) | [ OpenSearch Amazon-Dienst](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/). | | [redshift](aws-glue-programming-etl-connect-redshift-home.md) | [Amazon Redshift](https://aws.amazon.com/redshift/)-Datenbank | | [kafka](aws-glue-programming-etl-connect-kafka-home.md) | [Kafka](https://kafka.apache.org/) oder [Amazon Managed Streaming for Apache Kafka](https://docs.aws.amazon.com/msk/latest/developerguide/what-is-msk.html) | | [azurecosmos](aws-glue-programming-etl-connect-azurecosmos-home.md) | Azure Cosmos for NoSQL. | | [azuresql](aws-glue-programming-etl-connect-azuresql-home.md) | Azure SQL. | | [bigquery](aws-glue-programming-etl-connect-bigquery-home.md) | Google BigQuery. | | [mongodb](aws-glue-programming-etl-connect-mongodb-home.md) | [MongoDB](https://www.mongodb.com/what-is-mongodb)-Datenbank, einschließlich MongoDB Atlas. | | [sqlserver](aws-glue-programming-etl-connect-jdbc-home.md) | Microsoft SQL Server-Datenbank (siehe [JDBC-Verbindungen](aws-glue-programming-etl-connect-jdbc-home.md)) | | [mysql-](aws-glue-programming-etl-connect-jdbc-home.md) | [MySQL](https://www.mysql.com/)-Datenbankserver (siehe [JDBC-Verbindungen](aws-glue-programming-etl-connect-jdbc-home.md)). | | [oracle](aws-glue-programming-etl-connect-jdbc-home.md) | [Oracle](https://www.oracle.com/database/)-Datenbank (siehe [JDBC-Verbindungen](aws-glue-programming-etl-connect-jdbc-home.md)) | | [postgresql](aws-glue-programming-etl-connect-jdbc-home.md) | [PostgreSQL](https://www.postgresql.org/)-Datenbank (siehe [JDBC-Verbindungen](aws-glue-programming-etl-connect-jdbc-home.md)) | | [saphana](aws-glue-programming-etl-connect-saphana-home.md) | SAP HANA. | | [snowflake](aws-glue-programming-etl-connect-snowflake-home.md) | [Snowflake](https://www.snowflake.com/) Data Lake | | [teradata](aws-glue-programming-etl-connect-teradata-home.md) | Teradata Vantage. | | [vertica](aws-glue-programming-etl-connect-vertica-home.md) | Vertica. | | [benutzerdefiniert.\*](#aws-glue-programming-etl-connect-market) | Spark-, Athena- oder JDBC-Datenspeicher (siehe [Custom- und AWS Marketplace ConnectionType-Werte](#aws-glue-programming-etl-connect-market) | | [marketplace.\*](#aws-glue-programming-etl-connect-market) | Spark-, Athena- oder JDBC-Datenspeicher (siehe [Custom- und AWS Marketplace ConnectionType-Werte](#aws-glue-programming-etl-connect-market)) | ## 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-Connector `ClassName` + Datenquellen-Verbindung `Options` In ähnlicher Weise sind dieselben erforderlich, DataFrame um in eine von Glue unterstützte Datensenke zu schreiben: + Datensenke-Connector `ClassName` + Datensenke-Verbindung `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](https://spark.apache.org/docs/3.5.2/api/python/reference/pyspark.sql/dataframe.html). ### Den Konnektor angeben ClassName Um die `ClassName` Daten anzugeben source/sink, verwenden Sie die `.format` Option, um den entsprechenden Konnektor bereitzustellen`ClassName`, der die Daten definiert source/sink. **JDBC-Konnektoren** Geben Sie für JDBC-Connectors `jdbc` als Wert der Option `.format` an und geben Sie den JDBC-Treiber `ClassName` in der `driver`-Option an. ``` df = spark.read.format("jdbc").option("driver", "")... df.write.format("jdbc").option("driver", "")... ``` 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. SQLServerDriver | | MySQL | com.mysql.jdbc.Treiber | | SAP Hana | com.sap.db.jdbc.Treiber | | Teradata | com.teradata.jdbc. TeraDriver | **Spark-Connectors** Geben Sie für Spark-Connectors den `ClassName` des Connectors als Wert der `.format`-Option an. ``` df = spark.read.format("")... df.write.format("")... ``` 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 | ### Angeben der Verbindungsoptionen Um die `Options` Verbindung zu Daten anzugeben source/sink, verwenden Sie die, `.option(, )` um einzelne Optionen oder `.options()` mehrere Optionen als Schlüssel-Wert-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. + [JDBC](https://spark.apache.org/docs/3.5.2/sql-data-sources-jdbc.html) + [MongoDB/DocumentDB](https://www.mongodb.com/docs/spark-connector/v10.4/) + [Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) + [AzureCosmos](https://github.com/Azure/azure-cosmosdb-spark) + [AzureSQL](https://learn.microsoft.com/en-us/sql/connect/spark/connector?view=sql-server-ver16) + [BigQuery](https://cloud.google.com/dataproc/docs/tutorials/bigquery-connector-spark-example) + [OpenSearch](https://github.com/opensearch-project/opensearch-hadoop/blob/main/USER_GUIDE.md#apache-spark) + [Snowflake](https://docs.snowflake.com/en/user-guide/spark-connector-use#setting-configuration-options-for-the-connector) + [Vertica](https://github.com/vertica/spark-connector) ### 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": "", "user": "", "password": "", "dbtable": "", } dataframe = spark.read.format(className).options(**options).load() dataSinkClassName = "net.snowflake.spark.snowflake" dataSinkOptions = { "sfUrl": "", "sfUsername": "", "sfPassword": "", "sfDatabase" -> "", "sfSchema" -> "", "sfWarehouse" -> "" } 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" -> "", "user" -> "", "password" -> "", "dbtable" -> "" ) val dataframe = spark.read.format(dataSourceClassName).options(dataSourceOptions).load() val dataSinkClassName = "net.snowflake.spark.snowflake" val dataSinkOptions = Map( "sfUrl" -> "", "sfUsername" -> "", "sfPassword" -> "", "sfDatabase" -> "", "sfSchema" -> "", "sfWarehouse" -> "" ) 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, der vollständig qualifizierte Java-Klassenname des JDBC-Treibers (z. B.). `com.mysql.cj.jdbc.Driver` Sie müssen diese Option angeben, wenn Sie einen benutzerdefinierten Konnektor oder AWS Marketplace einen JDBC-Connector verwenden. Wenn Sie diese Option weglassen, schlägt der Job möglicherweise mit einem `No suitable driver` Fehler fehl, insbesondere wenn parametrisierte JDBC-URLs verwendet werden. + `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](https://spark.apache.org/docs/latest/sql-data-sources-jdbc.html) SQL and Datasets Guide. DataFrames 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: + DATE + STRING + TIMESTAMP (ZEITSTEMPEL) + INT + FLOAT + LONG + BIGDECIMAL + BYTE + SHORT + DOUBLE Die unterstützten JDBC-Datentypen sind [Java8 java.sql.types](https://docs.oracle.com/javase/8/docs/api/java/sql/Types.html). 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://{{}}/", "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://{{}}/", "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 Athena-CloudWatch Konnektor verwenden, ist dieser Parameterwert das Präfix des Klassennamens (z. B.). `"com.amazonaws.athena.connectors"` Der Athena-CloudWatch Konnektor besteht aus zwei Klassen: einem Metadaten-Handler und einem Datensatz-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](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-cloudwatch) 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://{{}}/", "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://{{}}/", "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äfix`es`, wie in der [Elasticsearch for Apache](https://www.elastic.co/guide/en/elasticsearch/hadoop/current/configuration.html) Hadoop-Dokumentation beschrieben. Spark-Verbindungen zu Snowflake verwenden Optionen wie `sfUser` und `sfPassword`, wie unter [Using the Spark Connector (Verwenden des Spark-Connectors)](https://docs.snowflake.com/en/user-guide/spark-connector-use.html) 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://{{}}", "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://{{}}","connectionName": "test-spark-es","es.port":"443"}, transformation_ctx = "DataSource0") ## @type: DataSink ## @args: [connection_type = "s3", format = "json", connection_options = {"path": "s3://{{}}/", "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://{{}}/", "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](programming-etl-connect-bookmarks.md). + `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](https://aws.amazon.com/blogs/big-data/optimize-memory-management-in-aws-glue/).