Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Types et options de connexion pour ETL dans AWS Glue pour Spark Dans AWS Glue Spark, diverses méthodes PySpark et transformations Scala spécifient le type de connexion à l'aide d'un `connectionType` paramètre. Ils spécifient des options de connexion à l'aide d'un paramètre `connectionOptions` ou `options`. Le paramètre `connectionType` peut prendre les valeurs indiquées dans le tableau suivant. Les valeurs de paramètre associées `connectionOptions` (ou `options`) pour chaque type sont documentées dans les sections suivantes. Sauf indication contraire, les paramètres s'appliquent lorsque la connexion est utilisée comme source ou comme collecteur. Pour obtenir un exemple de code qui illustre le paramétrage et l’utilisation des options de connexion, consultez la page d’accueil de chaque type de connexion. | `connectionType` | Se connecte à | | --- | --- | | [dynamodb](aws-glue-programming-etl-connect-dynamodb-home.md) | Base de données [Amazon DynamoDB](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) | Base de données [Amazon DocumentDB (compatible avec MongoDB)](https://docs.aws.amazon.com/documentdb/latest/developerguide/) | | [openSearch](aws-glue-programming-etl-connect-opensearch-home.md) | [Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/). | | [redshift](aws-glue-programming-etl-connect-redshift-home.md) | Base de données [Amazon Redshift](https://aws.amazon.com/redshift/) | | [kafka](aws-glue-programming-etl-connect-kafka-home.md) | [Kafka](https://kafka.apache.org/) ou [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 pour 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) | Base de données [MongoDB](https://www.mongodb.com/what-is-mongodb), y compris MongoDB Atlas. | | [sqlserver](aws-glue-programming-etl-connect-jdbc-home.md) | Base de données Microsoft SQL Server (consultez [Connexions JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) | | [mysql](aws-glue-programming-etl-connect-jdbc-home.md) | Base de données [MySQL](https://www.mysql.com/) (consultez [Connexions JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) | | [oracle](aws-glue-programming-etl-connect-jdbc-home.md) | Base de données [Oracle](https://www.oracle.com/database/) (consultez [Connexions JDBC](aws-glue-programming-etl-connect-jdbc-home.md)) | | [postgresql](aws-glue-programming-etl-connect-jdbc-home.md) | Base de données [PostgreSQL](https://www.postgresql.org/) (consultez [Connexions JDBC](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) | Lac de données [Snowflake](https://www.snowflake.com/) | | [teradata](aws-glue-programming-etl-connect-teradata-home.md) | Teradata Vantage. | | [vertica](aws-glue-programming-etl-connect-vertica-home.md) | Vertica. | | [personnalisé.\*](#aws-glue-programming-etl-connect-market) | Magasins de données Spark, Athena ou JDBC (voir [Valeurs personnalisées et AWS Marketplace ConnectionType](#aws-glue-programming-etl-connect-market) | | [marketplace.\*](#aws-glue-programming-etl-connect-market) | Magasins de données Spark, Athena ou JDBC (voir [Valeurs personnalisées et AWS Marketplace ConnectionType](#aws-glue-programming-etl-connect-market)) | ## DataFrame options pour l'ETL dans AWS Glue 5.0 pour Spark A DataFrame est un ensemble de données organisé en colonnes nommées semblables à une table et prenant en charge les opérations de style fonctionnel (map/reduce/filter/etc.) et les opérations SQL (sélection, projet, agrégation). Pour créer un DataFrame pour une source de données prise en charge par Glue, les éléments suivants sont requis : + connecteur de source de données `ClassName` + connexion de source de données `Options` De même, pour écrire un dans DataFrame un récepteur de données supporté par Glue, il en va de même : + connecteur de récepteur de données `ClassName` + connexion au récepteur de données `Options` Notez que les fonctionnalités de AWS Glue telles que les signets de tâches et les DynamicFrame options telles que celles-ci ne `connectionName` sont pas prises en charge dans DataFrame. Pour plus de détails sur les opérations prises en charge DataFrame et pour en savoir plus, consultez la documentation de Spark pour [DataFrame](https://spark.apache.org/docs/3.5.2/api/python/reference/pyspark.sql/dataframe.html). ### Spécification du connecteur ClassName Pour spécifier une donnée source/sink, utilisez l'`.format`option permettant de fournir le connecteur correspondant `ClassName` qui définit les données source/sink. `ClassName` **Connecteurs JDBC** Pour les connecteurs JDBC, indiquez `jdbc` en tant que valeur de l’option `.format` et fournissez le pilote JDBC `ClassName` dans l’option `driver`. ``` df = spark.read.format("jdbc").option("driver", "")... df.write.format("jdbc").option("driver", "")... ``` Le tableau suivant répertorie le pilote JDBC de la source `ClassName` de données prise en charge dans AWS Glue for. DataFrames | Source de données | Chauffeur ClassName | | --- |--- | | PostgreSQL | pilote org.postgreSQL | | Oracle | oracle.jdbc.driver. OracleDriver | | SQLServer | com.microsoft.sqlserver.jdbc. SQLServerDriver | | MySQL | com.mysql.jdbc.driver | | Saphana | com.sap.db.jdbc.driver | | Teradata | com.teradata.jdbc. TeraDriver | **Connecteurs Spark** Pour les connecteurs Spark, spécifiez le `ClassName` du connecteur en tant que valeur de l’option `.format`. ``` df = spark.read.format("")... df.write.format("")... ``` Le tableau suivant répertorie le connecteur Spark `ClassName` de la source de données prise en charge dans AWS Glue for DataFrames. | Source de données | ClassName | | --- |--- | | MongoDB/DocumentDB | glue.spark.mongodb | | Redshift | io.github.spark\_redshift\_community.spark.redshift | | AzureCosmos | cosmos.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.datasource. VerticaSource | ### Spécification des options de connexion Pour spécifier `Options` la connexion à une donnée source/sink, utilisez le `.option(, )` pour fournir des options individuelles ou `.options()` pour fournir plusieurs options sous forme de carte clé-valeur. Chaque donnée source/sink prend en charge son propre ensemble de connexions`Options`. Pour plus de détails sur les connecteurs disponibles`Options`, reportez-vous à la documentation publique du connecteur de données source/sink Spark spécifique répertorié dans le tableau suivant. + [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) ### Exemples Les exemples suivants sont extraits de PostgreSQL et écrivent dans : SnowFlake **Python** Exemple : ``` 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** Exemple : ``` 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() ``` ## Valeurs personnalisées et AWS Marketplace ConnectionType Cela inclut les éléments suivants : + `"connectionType": "marketplace.athena"` : désigne une connexion à un magasin de données Amazon Athena. La connexion utilise un connecteur provenant de AWS Marketplace. + `"connectionType": "marketplace.spark"` : désigne une connexion à un magasin de données Apache Spark. La connexion utilise un connecteur provenant de AWS Marketplace. + `"connectionType": "marketplace.jdbc"` : désigne une connexion à un magasin de données JDBC. La connexion utilise un connecteur provenant de AWS Marketplace. + `"connectionType": "custom.athena"` : désigne une connexion à un magasin de données Amazon Athena. La connexion utilise un connecteur personnalisé que vous chargez sur AWS Glue Studio. + `"connectionType": "custom.spark"` : désigne une connexion à un magasin de données Apache Spark. La connexion utilise un connecteur personnalisé que vous chargez sur AWS Glue Studio. + `"connectionType": "custom.jdbc"` : désigne une connexion à un magasin de données JDBC. La connexion utilise un connecteur personnalisé que vous chargez sur AWS Glue Studio. ### Options de connexion pour le type custom.jdbc ou marketplace.jdbc + `className`— Chaîne, obligatoire, nom de classe Java complet du pilote JDBC (par exemple,). `com.mysql.cj.jdbc.Driver` Vous devez spécifier cette option lorsque vous utilisez un connecteur personnalisé ou AWS Marketplace JDBC. Si vous omettez cette option, la tâche peut échouer avec une `No suitable driver` erreur, en particulier lors de l'utilisation d'URL JDBC paramétrées. + `connectionName` — chaîne, obligatoire, nom de la connexion associée au connecteur. + `url` — chaîne, obligatoire, URL JDBC avec des espaces réservés (`${}`) qui sont utilisés pour créer la connexion à la source de données. L'espace réservé `${secretKey}` est remplacé par le secret du même nom dans AWS Secrets Manager. Reportez-vous à la documentation du magasin de données pour plus d'informations sur la construction de l'URL. + `secretId` ou `user/password` — chaîne, obligatoire, utilisée pour récupérer les informations d'identification de l'URL. + `dbTable` ou `query` — chaîne, obligatoire, la table ou la requête SQL à partir de laquelle obtenir les données. Vous pouvez préciser `dbTable` ou `query`, mais pas les deux. + `partitionColumn` — chaîne, facultatif, nom d'une colonne entière utilisée pour le partitionnement. Cette option fonctionne uniquement lorsqu'elle est incluse dans `lowerBound`, `upperBound` et `numPartitions`. Cette option fonctionne de la même manière que dans le lecteur JDBC SQL Spark. Pour plus d'informations, consultez la section [JDBC vers d'autres bases de données](https://spark.apache.org/docs/latest/sql-data-sources-jdbc.html) dans le guide *Apache Spark SQL DataFrames et Datasets*. Les valeurs `lowerBound` et `upperBound` sont utilisées pour décider de la progression de la partition, pas pour filtrer les lignes de la table. Toutes les lignes de la table sont partitionnées et renvoyées. **Note** Lorsque vous utilisez une requête au lieu d'un nom de table, vous devez valider que la requête fonctionne avec la condition de partitionnement spécifiée. Par exemple : Si le format de votre requête est `"SELECT col1 FROM table1"`, testez la requête en ajoutant une clause `WHERE` à la fin de la requête qui utilise la colonne de partition. Si le format de votre requête est `SELECT col1 FROM table1 WHERE col2=val"`, testez la requête en étendant la clause `WHERE` avec `AND` et une expression qui utilise la colonne de partition. + `lowerBound` — entier, facultatif, valeur minimale de `partitionColumn` qui est utilisée pour décider de la progression de la partition. + `upperBound` — entier, facultatif, valeur maximale de `partitionColumn` qui est utilisée pour décider de la progression de la partition. + `numPartitions` — entier, facultatif, nombre de partitions. Cette valeur, ainsi que `lowerBound` (inclusive) et `upperBound` (exclusive) forment les progressions de partition pour les expressions de clause `WHERE` générées qui sont utilisées pour diviser le fichier `partitionColumn`. **Important** Soyez prudent avec le nombre de partitions, car avoir un trop grand nombre de partitions peut causer des problèmes sur vos systèmes de bases de données externes. + `filterPredicate` — chaîne, facultative, clause de condition supplémentaire pour filtrer les données à partir de la source. Par exemple : ``` BillingCity='Mountain View' ``` Lorsque vous utilisez une *requête* au lieu d'un nom de *table*, vous devez vérifier que la requête fonctionne avec le `filterPredicate` spécifié. Par exemple : + Si le format de votre requête est `"SELECT col1 FROM table1"`, testez la requête en ajoutant une clause `WHERE` à la fin de la requête qui utilise le prédicat de filtre. + Si le format de votre requête est `"SELECT col1 FROM table1 WHERE col2=val"`, testez la requête en étendant la clause `WHERE` avec `AND` et une expression qui utilise le prédicat de filtre. + `dataTypeMapping` — dictionnaire, facultatif, mappage de type de données personnalisé qui crée un mappage d'un type de données **JDBC** à un type de données **Glue**. Par exemple, l'option `"dataTypeMapping":{"FLOAT":"STRING"}` mappe les champs de données du type JDBC `FLOAT` sur le type Java `String` en appelant la méthode `ResultSet.getString()` du pilote, et l'utilise pour créer les enregistrements AWS Glue. L'objet est `ResultSet` implémenté par chaque pilote, donc le comportement est spécifique au pilote que vous utilisez. Reportez-vous à la documentation de votre pilote JDBC pour comprendre comment le pilote effectue les conversions. + Les types de données AWS Glue actuellement pris en charge sont les suivants : + DATE + CHAÎNE + TIMESTAMP + INT + FLOAT + LONG + BIGDECIMAL + BYTE + SHORT + DOUBLE Les types de données JDBC pris en charge sont [Java8 java.sql.types](https://docs.oracle.com/javase/8/docs/api/java/sql/Types.html). Les mappages de type de données par défaut (de JDBC à AWS Glue) sont les suivants : + DATE -> DATE + VARCHAR -> STRING + CHAR -> STRING + LONGNVARCHAR -> STRING + TIMESTAMP -> TIMESTAMP + INTEGER -> INT + FLOAT -> FLOAT + REAL -> FLOAT + BIT -> BOOLEAN + BOOLEAN -> BOOLEAN + BIGINT -> LONG + DECIMAL -> BIGDECIMAL + NUMERIC -> BIGDECIMAL + TINYINT -> SHORT + SMALLINT -> SHORT + DOUBLE -> DOUBLE Si vous utilisez un mappage de type de données personnalisé avec l'option `dataTypeMapping`, vous pouvez remplacer un mappage de type de données par défaut. Seuls les types de données JDBC répertoriés dans l'option `dataTypeMapping` sont affectés ; le mappage par défaut est utilisé pour tous les autres types de données JDBC. Vous pouvez ajouter des mappages pour des types de données JDBC supplémentaires si nécessaire. Si un type de données JDBC n'est inclus ni dans le mappage par défaut ni dans un mappage personnalisé, le type de données est converti en type de données AWS Glue `STRING` par défaut. L'exemple de code Python suivant montre comment lire à partir de bases de données JDBC avec des pilotes AWS Marketplace JDBC. Il montre la lecture à partir d'une base de données et l'écriture dans un emplacement S3. ``` 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() ``` ### Options de connexion pour le type custom.athena ou marketplace.athena + `className` — chaîne, obligatoire, nom de la classe du pilote. Lorsque vous utilisez le Athena-CloudWatch connecteur, cette valeur de paramètre est le préfixe de la classe Name (par exemple,`"com.amazonaws.athena.connectors"`). Le Athena-CloudWatch connecteur est composé de deux classes : un gestionnaire de métadonnées et un gestionnaire d'enregistrements. Si vous fournissez le préfixe commun ici, l'API charge les classes correctes en fonction de ce préfixe. + `tableName`— Chaîne, obligatoire, nom du flux de CloudWatch journal à lire. Cet extrait de code utilise le nom de vue spécial `all_log_streams`, ce qui signifie que la trame de données dynamique renvoyée contiendra les données de tous les flux de journaux du groupe de journaux. + `schemaName`— Chaîne, obligatoire, nom du groupe de CloudWatch journaux à partir duquel la lecture doit être effectuée. Par exemple, `/aws-glue/jobs/output`. + `connectionName` — chaîne, obligatoire, nom de la connexion associée au connecteur. Pour des options supplémentaires pour ce connecteur, consultez le [fichier README du CloudWatch connecteur Amazon Athena](https://github.com/awslabs/aws-athena-query-federation/tree/master/athena-cloudwatch) sur. GitHub L'exemple de code Python suivant montre comment lire à partir d'un magasin de données Athena à l'aide d'un connecteur AWS Marketplace . Il montre la lecture à partir d'Athena et l'écriture dans un emplacement S3. ``` 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() ``` ### Options de connexion pour le type custom.spark ou marketplace.spark + `className` — chaîne, obligatoire, nom de la classe du connecteur. + `secretId` — chaîne, facultative, utilisée pour récupérer les informations d'identification pour la connexion du connecteur. + `connectionName` — chaîne, obligatoire, nom de la connexion associée au connecteur. + D'autres options dépendent du magasin de données. Par exemple, les options OpenSearch de configuration commencent par le préfixe`es`, comme décrit dans la documentation d'[Elasticsearch pour Apache](https://www.elastic.co/guide/en/elasticsearch/hadoop/current/configuration.html) Hadoop. Les connexions Spark à Snowflake utilisent des options telles que `sfUser` et `sfPassword`, comme décrit dans [Using the Spark Connector](https://docs.snowflake.com/en/user-guide/spark-connector-use.html) dans le guide *Connecting to Snowflake*. L'exemple de code Python suivant montre comment lire depuis un magasin de OpenSearch données à l'aide d'une `marketplace.spark` connexion. ``` 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() ``` ## Options générales Les options de cette section sont fournies en tant que `connection_options`, mais ne s'appliquent pas à un connecteur en particulier. Les paramètres suivants sont généralement utilisés lors de la configuration de signets. Ils peuvent s'appliquer aux flux de travail Amazon S3 ou JDBC. Pour de plus amples informations, veuillez consulter [Utilisation des marque-pages de tâche](programming-etl-connect-bookmarks.md). + `jobBookmarkKeys` : un tableau des noms des colonnes. + `jobBookmarkKeysSortOrder` : chaîne définissant comment comparer les valeurs en fonction de l'ordre de tri. Valeurs valides : `"asc"`, `"desc"`. + `useS3ListImplementation` : utilisé pour gérer les performances de la mémoire lors de la liste du contenu du compartiment Amazon S3. Pour plus d'informations, consultez la section [Optimisation de la gestion de la mémoire dans AWS Glue](https://aws.amazon.com/blogs/big-data/optimize-memory-management-in-aws-glue/).