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.
# GlueContext classe
Encapsule l'[SparkContext](https://spark.apache.org/docs/latest/api/java/org/apache/spark/SparkContext.html)objet Apache Spark et fournit ainsi des mécanismes permettant d'interagir avec la plateforme Apache Spark.
## \_\_init\_\_
**`__init__(sparkContext)`**
+ `sparkContext` – Contexte Apache Spark à utiliser.
## Création
+ [\_\_init\_\_](#aws-glue-api-crawler-pyspark-extensions-glue-context-__init__)
+ [getSource](#aws-glue-api-crawler-pyspark-extensions-glue-context-get-source)
+ [create\_dynamic\_frame\_from\_rdd](#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_rdd)
+ [create\_dynamic\_frame\_from\_catalog](#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog)
+ [create\_dynamic\_frame\_from\_options](#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options)
+ [create\_sample\_dynamic\_frame\_from\_catalog](#aws-glue-api-crawler-pyspark-extensions-glue-context-create-sample-dynamic-frame-from-catalog)
+ [create\_sample\_dynamic\_frame\_from\_options](#aws-glue-api-crawler-pyspark-extensions-glue-context-create-sample-dynamic-frame-from-options)
+ [add\_ingestion\_time\_columns](#aws-glue-api-crawler-pyspark-extensions-glue-context-add-ingestion-time-columns)
+ [create\_data\_frame\_from\_catalog](#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-catalog)
+ [create\_data\_frame\_from\_options](#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-options)
+ [forEachBatch](#aws-glue-api-crawler-pyspark-extensions-glue-context-forEachBatch)
## getSource
**`getSource(connection_type, transformation_ctx = "", **options)`**
Crée un objet `DataSource` qui peut être utilisé pour lire `DynamicFrames` à partir de sources externes.
+ `connection_type` – type de connexion à utiliser, tel qu’Amazon Simple Storage Service (Amazon S3), Amazon Redshift et JDBC. Les valeurs valides sont les suivantes : `s3`, `mysql`, `postgresql`, `redshift`, `sqlserver`, `oracle` et `dynamodb`.
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif).
+ `options` – Ensemble de paires nom-valeur facultatives. Pour plus d'informations, consultez [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
Voici un exemple d’utilisation de : `getSource`.
```
>>> data_source = context.getSource("file", paths=["/in/path"])
>>> data_source.setFormat("json")
>>> myFrame = data_source.getFrame()
```
## create\_dynamic\_frame\_from\_rdd
**`create_dynamic_frame_from_rdd(data, name, schema=None, sample_ratio=None, transformation_ctx="")`**
Renvoie un objet `DynamicFrame` créé à partir d’un RDD (Resilient Distributed Dataset) Apache Spark.
+ `data` –- La source de données à utiliser.
+ `name` – Nom des données à utiliser.
+ `schema` – Schéma à utiliser (facultatif).
+ `sample_ratio` – Exemple de ratio à utiliser (facultatif).
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif).
## create\_dynamic\_frame\_from\_catalog
**`create_dynamic_frame_from_catalog(database, table_name, redshift_tmp_dir, transformation_ctx = "", push_down_predicate= "", additional_options = {}, catalog_id = None)`**
Renvoie un objet `DynamicFrame` créé à l’aide d’un nom de table et de base de données Data Catalog. Lorsque vous utilisez cette méthode, vous fournissez des `format_options` propriétés de table sur la table AWS Glue Data Catalog spécifiée et d'autres options via l'`additional_options`argument.
+ `Database` – Base de données à partir de laquelle lire.
+ `table_name` – Nom de la table à partir de laquelle lire.
+ `redshift_tmp_dir` – répertoire Amazon Redshift temporaire à utiliser (facultatif).
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif).
+ `push_down_predicate` – filtre les partitions sans avoir à répertorier ni lire tous les fichiers de votre jeu de données. Pour connaître les sources prises en charge et les limites, consultez [Optimisation des lectures avec pushdown dans AWS Glue ETL](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-pushdown.html). Pour de plus amples informations, veuillez consulter [Préfiltrage à l'aide des prédicats pushdown](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-pushdowns).
+ `additional_options` — Ensemble de paires nom-valeur facultatives. Les options possibles comprennent celles répertoriées dans [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md), sauf pour `endpointUrl`, `streamName`, `bootstrap.servers`, `security.protocol`, `topicName`, `classification` et `delimiter`. Est une autre option prise en charge `catalogPartitionPredicate`:
`catalogPartitionPredicate` – Vous pouvez passer une expression de catalogue à filtrer en fonction des colonnes d'index. Cela envoie le filtrage du côté serveur. Pour en savoir plus, consultez [AWS Glue Indexes de partition](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html). Notez que `push_down_predicate` et `catalogPartitionPredicate` utilisent des syntaxes différentes. Le premier utilise la syntaxe standard SQL Spark et le dernier utilise l'analyseur JSQL.
+ `catalog_id` – ID du catalogue (ID du compte) Data Catalog auquel vous accédez. Lorsque la valeur est Aucun, l'ID de compte par défaut de l'appelant est utilisé.
## create\_dynamic\_frame\_from\_options
**`create_dynamic_frame_from_options(connection_type, connection_options={}, format=None, format_options={}, transformation_ctx = "")`**
Renvoie un `DynamicFrame` créé avec la connexion et le format spécifiés.
+ `connection_type` – type de connexion, tel qu'Amazon S3, Amazon Redshift et JDBC. Les valeurs valides sont les suivantes : `s3`, `mysql`, `postgresql`, `redshift`, `sqlserver`, `oracle` et `dynamodb`.
+ `connection_options` – options de connexion, telles que les chemins et la table de base de données (facultatif). Pour un `connection_type` de `s3`, une liste de chemins Amazon S3 est définie.
```
connection_options = {"paths": ["{{s3://aws-glue-target/temp}}"]}
```
Pour les connexions JDBC, plusieurs propriétés doivent être définies. Notez que le nom de base de données doit être inclus dans l’URL. Il peut éventuellement être inclus dans les options de connexion.
**Avertissement**
Il n’est pas recommandé de stocker des mots de passe dans votre script. Envisagez de les utiliser `boto3` pour les récupérer depuis AWS Secrets Manager le catalogue de données AWS Glue.
```
connection_options = {"url": "{{jdbc-url/database}}", "user": "{{username}}", "password": {{passwordVariable}},"dbtable": "{{table-name}}", "redshiftTmpDir": "{{s3-tempdir-path}}"}
```
La propriété `dbtable` est le nom de la table JDBC. Pour les magasins de données JDBC qui prennent en charge les schémas dans une base de données, spécifiez `schema.table-name`. Si aucun schéma n'est fourni, c'est le schéma « public » par défaut qui est utilisé.
Pour de plus amples informations, veuillez consulter [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
+ `format` : une spécification de format. Utilisée pour une connexion Amazon S3 ou AWS Glue prenant en charge plusieurs formats. Consultez [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md) pour connaître les formats pris en charge.
+ `format_options` – options de format pour le format spécifié. Consultez [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md) pour connaître les formats pris en charge.
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif).
+ `push_down_predicate` – filtre les partitions sans avoir à répertorier ni lire tous les fichiers de votre jeu de données. Pour connaître les sources prises en charge et les limites, consultez [Optimisation des lectures avec pushdown dans AWS Glue ETL](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-pushdown.html). Pour plus d’informations, consultez [Pre-Filtering Using Pushdown Predicates](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html#aws-glue-programming-etl-partitions-pushdowns).
## create\_sample\_dynamic\_frame\_from\_catalog
**`create_sample_dynamic_frame_from_catalog(database, table_name, num, redshift_tmp_dir, transformation_ctx = "", push_down_predicate= "", additional_options = {}, sample_options = {}, catalog_id = None)`**
Retourne un objet `DynamicFrame` créé à l’aide d’un nom de tableau et de base de données Data Catalog. Le `DynamicFrame` ne contient que les premiers enregistrements `num` provenant d'une source de données.
+ `database` – Base de données à partir de laquelle lire.
+ `table_name` – Nom de la table à partir de laquelle lire.
+ `num` – Nombre maximal d'enregistrements dans la trame dynamique d'échantillon renvoyée.
+ `redshift_tmp_dir` – répertoire Amazon Redshift temporaire à utiliser (facultatif).
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif).
+ `push_down_predicate` – filtre les partitions sans avoir à répertorier ni lire tous les fichiers de votre jeu de données. Pour plus d'informations, consultez [Préfiltrage à l'aide des prédicats pushdown](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-pushdowns).
+ `additional_options` — Ensemble de paires nom-valeur facultatives. Les options possibles comprennent celles répertoriées dans [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md), sauf pour `endpointUrl`, `streamName`, `bootstrap.servers`, `security.protocol`, `topicName`, `classification` et `delimiter`.
+ `sample_options` — Paramètres permettant de contrôler le comportement d'échantillonnage (facultatif). Paramètres disponibles actuels pour les sources Amazon S3 :
+ `maxSamplePartitions` — Nombre maximal de partitions que l'échantillonnage lira. Valeur par défaut : 10
+ `maxSampleFilesPerPartition` — Nombre maximal de fichiers que l'échantillonnage lira dans une partition. Valeur par défaut : 10.
Ces paramètres permettent de réduire le temps consommé par la liste des fichiers. Par exemple, supposons que le jeu de données comporte 1 000 partitions et que chaque partition comporte 10 fichiers. Si vous définissez `maxSamplePartitions` = 10, et `maxSampleFilesPerPartition` = 10, au lieu de répertorier les 10 000 fichiers, l'échantillonnage ne listera et ne lira que les 10 premières partitions avec les 10 premiers fichiers de chacun : 10\*10 = 100 au total.
+ `catalog_id` – ID du catalogue Data Catalog auquel vous accédez (ID du compte Data Catalog). Valeur définie sur `None` par défaut. `None` correspond par défaut à l'ID de catalogue du compte ayant initié l'appel dans le service.
## create\_sample\_dynamic\_frame\_from\_options
**`create_sample_dynamic_frame_from_options(connection_type, connection_options={}, num, sample_options={}, format=None, format_options={}, transformation_ctx = "")`**
Renvoie un `DynamicFrame` créé avec la connexion et le format spécifiés. Le `DynamicFrame` ne contient que les premiers enregistrements `num` provenant d'une source de données.
+ `connection_type` – type de connexion, tel qu'Amazon S3, Amazon Redshift et JDBC. Les valeurs valides sont les suivantes : `s3`, `mysql`, `postgresql`, `redshift`, `sqlserver`, `oracle` et `dynamodb`.
+ `connection_options` – options de connexion, telles que les chemins et la table de base de données (facultatif). Pour plus d'informations, consultez [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
+ `num` – Nombre maximal d'enregistrements dans la trame dynamique d'échantillon renvoyée.
+ `sample_options` — Paramètres permettant de contrôler le comportement d'échantillonnage (facultatif). Paramètres disponibles actuels pour les sources Amazon S3 :
+ `maxSamplePartitions` — Nombre maximal de partitions que l'échantillonnage lira. Valeur par défaut : 10
+ `maxSampleFilesPerPartition` — Nombre maximal de fichiers que l'échantillonnage lira dans une partition. Valeur par défaut : 10.
Ces paramètres permettent de réduire le temps consommé par la liste des fichiers. Par exemple, supposons que le jeu de données comporte 1 000 partitions et que chaque partition comporte 10 fichiers. Si vous définissez `maxSamplePartitions` = 10, et `maxSampleFilesPerPartition` = 10, au lieu de répertorier les 10 000 fichiers, l'échantillonnage ne listera et ne lira que les 10 premières partitions avec les 10 premiers fichiers de chacun : 10\*10 = 100 au total.
+ `format` : une spécification de format. Utilisée pour une connexion Amazon S3 ou AWS Glue prenant en charge plusieurs formats. Consultez [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md) pour connaître les formats pris en charge.
+ `format_options` – options de format pour le format spécifié. Consultez [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md) pour connaître les formats pris en charge.
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif).
+ `push_down_predicate` – filtre les partitions sans avoir à répertorier ni lire tous les fichiers de votre jeu de données. Pour plus d'informations, consultez [Préfiltrage à l'aide des prédicats pushdown](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-pushdowns).
## add\_ingestion\_time\_columns
**`add_ingestion_time_columns(dataFrame, timeGranularity = "")`**
Ajoute des colonnes de temps d’ingestion, telles que `ingest_year`, `ingest_month`, `ingest_day`, `ingest_hour`, `ingest_minute` à l’entrée `DataFrame`. Cette fonction est automatiquement générée dans le script généré par AWS Glue lorsque vous spécifiez une table Data Catalog avec Amazon S3 comme cible. Cette fonction met automatiquement à jour la partition avec les colonnes de temps d’ingestion sur la table de sortie. Cela permet aux données de sortie d’être automatiquement partitionnées à l’heure d’ingestion sans nécessiter de colonnes d’heure d’ingestion explicites dans les données d’entrée.
+ `dataFrame` – `dataFrame` auquel ajouter les colonnes de temps d’ingestion.
+ `timeGranularity` — granularité des colonnes de temps. Les valeurs valides sont « `day` », « `hour` » et « `minute` ». Par exemple, si « `hour` » est transmis à la fonction, les colonnes de temps « `ingest_year` », « `ingest_month` », « `ingest_day` » et « `ingest_hour` » seront ajoutées à l’original « `dataFrame` ».
Renvoie le bloc de données après l’ajout des colonnes de granularité temporelle.
Exemple :
```
dynamic_frame = DynamicFrame.fromDF(glueContext.add_ingestion_time_columns(dataFrame, "hour"))
```
## create\_data\_frame\_from\_catalog
**`create_data_frame_from_catalog(database, table_name, transformation_ctx = "", additional_options = {})`**
Renvoie un objet `DataFrame` créé à l’aide d’un nom de table et de base de données Data Catalog.
+ `database` – base de données Data Catalog à lire.
+ `table_name` – nom de la table Data Catalogà partir de laquelle lire.
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif).
+ `additional_options` – Ensemble de paires nom-valeur facultatives. Les options possibles incluent celles répertoriées dans [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md) pour les sources de streaming, telles que `startingPosition`, `maxFetchTimeInMs` et `startingOffsets`.
+ `useSparkDataSource`— Lorsque ce paramètre est défini sur true, force AWS Glue à utiliser l'API native de source de données Spark pour lire le tableau. L’API Spark Data Source prend en charge les formats suivants : AVRO, binaire, CSV, JSON, ORC, Parquet et texte. Dans une table Data Catalog, vous spécifiez le format à l’aide de la propriété `classification`. Pour en savoir plus sur l’API Spark Data Source, consultez la [documentation officielle d’Apache Spark](https://spark.apache.org/docs/latest/sql-data-sources-load-save-functions.html).
L’utilisation de `create_data_frame_from_catalog` avec `useSparkDataSource` offre les avantages suivants :
+ Renvoie directement un `DataFrame` et fournit une alternative à `create_dynamic_frame.from_catalog().toDF()`.
+ Prend en charge le contrôle des autorisations AWS Lake Formation au niveau de la table pour les formats natifs.
+ Prend en charge la lecture des formats de lacs de données sans contrôle des autorisations AWS Lake Formation au niveau de la table. Pour de plus amples informations, veuillez consulter [Utilisation de frameworks de lacs de données avec des tâches AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
Lorsque vous l'activez`useSparkDataSource`, vous pouvez également ajouter n'importe laquelle des [options de source de données Spark](https://spark.apache.org/docs/latest/sql-data-sources.html) `additional_options` selon vos besoins. AWS Glue transmet ces options directement au lecteur Spark.
+ `useCatalogSchema`— Lorsqu'il est défini sur true, AWS Glue applique le schéma du catalogue de données au résultat`DataFrame`. Sinon, le lecteur déduit le schéma à partir des données. Lorsque vous activez `useCatalogSchema`, vous devez également définir `useSparkDataSource` sur true.
**Limites**
Lorsque vous utilisez l'option `useSparkDataSource`, tenez compte des restrictions suivantes :
+ Lorsque vous l'utilisez`useSparkDataSource`, AWS Glue en crée une nouvelle `DataFrame` dans une session Spark distincte, différente de la session Spark d'origine.
+ Le filtrage des DataFrame partitions Spark ne fonctionne pas avec les fonctionnalités de AWS Glue suivantes.
+ [Signets de tâche](monitor-continuations.md)
+ [Exclusion des classes de stockage Amazon S3](aws-glue-programming-etl-storage-classes.md#aws-glue-programming-etl-storage-classes-dynamic-frame)
+ [Prédicats de partition de catalogue](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-cat-predicates)
Pour utiliser le filtrage des partitions avec ces fonctionnalités, vous pouvez utiliser le prédicat AWS Glue pushdown. Pour de plus amples informations, veuillez consulter [Préfiltrage à l'aide des prédicats pushdown](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-pushdowns). Le filtrage sur les colonnes non partitionnées n’est pas concerné.
L’exemple de script suivant illustre un filtrage de partition inadéquat à l’aide de l’option `excludeStorageClasses`.
```
// Incorrect partition filtering using Spark filter with excludeStorageClasses
read_df = glueContext.create_data_frame.from_catalog(
database=database_name,
table_name=table_name,
additional_options = {
"useSparkDataSource": True,
"excludeStorageClasses" : ["GLACIER", "DEEP_ARCHIVE"]
}
)
// Suppose year and month are partition keys.
// Filtering on year and month won't work, the filtered_df will still
// contain data with other year/month values.
filtered_df = read_df.filter("year == '2017 and month == '04' and 'state == 'CA'")
```
L’exemple de script suivant illustre l’utilisation adéquate d’un prédicat pushdown dans le cadre d’un filtrage de partition à l’aide de l’option `excludeStorageClasses`.
```
// Correct partition filtering using the AWS Glue pushdown predicate
// with excludeStorageClasses
read_df = glueContext.create_data_frame.from_catalog(
database=database_name,
table_name=table_name,
// Use AWS Glue pushdown predicate to perform partition filtering
push_down_predicate = "(year=='2017' and month=='04')"
additional_options = {
"useSparkDataSource": True,
"excludeStorageClasses" : ["GLACIER", "DEEP_ARCHIVE"]
}
)
// Use Spark filter only on non-partitioned columns
filtered_df = read_df.filter("state == 'CA'")
```
**Exemple : Création d’une table CSV à l’aide du lecteur de source de données Spark**
```
// Read a CSV table with '\t' as separator
read_df = glueContext.create_data_frame.from_catalog(
database={{}},
table_name={{}},
additional_options = {"useSparkDataSource": True, "sep": '\t'}
)
```
## create\_data\_frame\_from\_options
**`create_data_frame_from_options(connection_type, connection_options={}, format=None, format_options={}, transformation_ctx = "")`**
Cette API est désormais obsolète. Utilisez plutôt les API `getSource()`. Renvoie un `DataFrame` créé avec la connexion et le format spécifiés. Utilisez cette fonction uniquement avec les sources de streaming AWS Glue.
+ `connection_type` – type de connexion en streaming. Les valeurs valides sont `kinesis` et `kafka`.
+ `connection_options` – options de connexion, qui sont différentes pour Kinesis et Kafka. Vous trouverez la liste de toutes les options de connexion pour chaque source de données de streaming sur la page [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md). Notez les différences suivantes dans les options de connexion en streaming :
+ Les sources de streaming Kinesis nécessitent `streamARN`, `startingPosition`, `inferSchema` et `classification`.
+ Les sources de streaming Kafka nécessitent `connectionName`, `topicName`, `startingOffsets`, `inferSchema` et `classification`.
+ `format` : une spécification de format. Utilisée pour une connexion Amazon S3 ou AWS Glue prenant en charge plusieurs formats. Pour plus d’informations sur les formats pris en charge, consultez [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md).
+ `format_options` – options de format pour le format spécifié. Pour de plus amples informations sur les options de formats pris en charge, veuillez consulter [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md).
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif).
Exemple pour la source de streaming Amazon Kinesis :
```
kinesis_options =
{ "streamARN": "arn:aws:kinesis:us-east-2:777788889999:stream/fromOptionsStream",
"startingPosition": "TRIM_HORIZON",
"inferSchema": "true",
"classification": "json"
}
data_frame_datasource0 = glueContext.create_data_frame.from_options(connection_type="kinesis", connection_options=kinesis_options)
```
Exemple pour la source de streaming Kafka :
```
kafka_options =
{ "connectionName": "ConfluentKafka",
"topicName": "kafka-auth-topic",
"startingOffsets": "earliest",
"inferSchema": "true",
"classification": "json"
}
data_frame_datasource0 = glueContext.create_data_frame.from_options(connection_type="kafka", connection_options=kafka_options)
```
## forEachBatch
**`forEachBatch(frame, batch_function, options)`**
S’applique à `batch_function` transmis à chaque micro-lot lu à partir de la source de streaming.
+ `frame`— Le DataFrame contenant le microlot actuel.
+ `batch_function` — fonction qui sera appliquée à chaque micro-lot.
+ `options` — collection de paires clé-valeur qui contient des informations sur le traitement de micro-lots. Les options suivantes sont requises :
+ `windowSize` — durée de traitement de chaque lot.
+ `checkpointLocation` — emplacement dans lequel les points de contrôle sont stockés pour la tâche ETL en streaming.
+ `batchMaxRetries` – nombre maximum de nouvelles tentatives pour ce lot en cas d’échec. La valeur par défaut est 3. Cette option n’est configurable que pour Glue version 2.0 et ultérieure.
**Exemple :**
```
glueContext.forEachBatch(
frame = data_frame_datasource0,
batch_function = processBatch,
options = {
"windowSize": "100 seconds",
"checkpointLocation": "s3://kafka-auth-dataplane/confluent-test/output/checkpoint/"
}
)
def processBatch(data_frame, batchId):
if (data_frame.count() > 0):
datasource0 = DynamicFrame.fromDF(
glueContext.add_ingestion_time_columns(data_frame, "hour"),
glueContext, "from_data_frame"
)
additionalOptions_datasink1 = {"enableUpdateCatalog": True}
additionalOptions_datasink1["partitionKeys"] = ["ingest_yr", "ingest_mo", "ingest_day"]
datasink1 = glueContext.write_dynamic_frame.from_catalog(
frame = datasource0,
database = "tempdb",
table_name = "kafka-auth-table-output",
transformation_ctx = "datasink1",
additional_options = additionalOptions_datasink1
)
```
## Utilisation des jeux de données dans Amazon S3
+ [purge\_table](#aws-glue-api-crawler-pyspark-extensions-glue-context-purge_table)
+ [purge\_s3\_path](#aws-glue-api-crawler-pyspark-extensions-glue-context-purge_s3_path)
+ [transition\_table](#aws-glue-api-crawler-pyspark-extensions-glue-context-transition_table)
+ [transition\_s3\_path](#aws-glue-api-crawler-pyspark-extensions-glue-context-transition_s3_path)
## purge\_table
**`purge_table(catalog_id=None, database="", table_name="", options={}, transformation_ctx="")`**
Supprime les fichiers d’Amazon S3 pour la base de données et la table spécifiés pour le catalogue. Si tous les fichiers d’une partition sont supprimés, cette partition est également éliminée du catalogue. Nous ne prenons pas en charge l’action purge\_table sur les tables enregistrées auprès de Lake Formation.
Pour pouvoir récupérer des objets supprimés, vous pouvez activer la [gestion des versions d'objet](https://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectVersioning.html) au niveau du compartiment Amazon S3. Lorsqu'un objet est supprimé d'un compartiment pour lequel la gestion des versions d'objet n'est pas activée, il ne peut pas être récupéré. Pour plus d’informations sur la récupération d’objets supprimés dans un compartiment pour lequel la gestion des versions est activée, consultez [Comment récupérer un objet Amazon S3 qui a été supprimé ?](https://aws.amazon.com/premiumsupport/knowledge-center/s3-undelete-configuration/) dans le Centre de connaissances AWS Support .
+ `catalog_id` – ID du catalogue Data Catalog auquel vous accédez (ID du compte Data Catalog). Valeur définie sur `None` par défaut. `None` correspond par défaut à l'ID de catalogue du compte ayant initié l'appel dans le service.
+ `database` – Base de données à utiliser.
+ `table_name` – nom de la table à utiliser.
+ `options` – options destinées au filtrage des fichiers à supprimer et à la génération des fichiers manifestes.
+ `retentionPeriod` – spécifie une période de conservation des fichiers, en nombre d'heures. Les dossiers dont la date est postérieure à cette période sont conservés. Par défaut, elle est réglée sur 168 heures (7 jours).
+ `partitionPredicate` – les partitions satisfaisant à ce prédicat sont supprimées. Les fichiers qui se situent dans la période de conservation pour ces partitions ne sont pas supprimés. Valeur définie sur `""` – vide par défaut.
+ `excludeStorageClasses` – les fichiers avec classe de stockage dans le jeu `excludeStorageClasses` ne sont pas supprimés. La valeur par défaut est `Set()` – jeu vide.
+ `manifestFilePath` – chemin facultatif pour la génération du fichier manifeste. Tous les fichiers qui ont été purgés avec succès sont enregistrés dans `Success.csv`, et ceux qui ont échoué dans `Failed.csv`
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif). Utilisé dans le chemin du fichier manifeste.
**Example**
```
glueContext.purge_table("database", "table", {"partitionPredicate": "(month=='march')", "retentionPeriod": 1, "excludeStorageClasses": ["STANDARD_IA"], "manifestFilePath": "s3://bucketmanifest/"})
```
## purge\_s3\_path
**`purge_s3_path(s3_path, options={}, transformation_ctx="")`**
Supprime les fichiers du chemin Amazon S3 spécifié de manière récursive.
Pour pouvoir récupérer des objets supprimés, vous pouvez activer la [gestion des versions d'objet](https://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectVersioning.html) au niveau du compartiment Amazon S3. Lorsqu'un objet est supprimé d'un compartiment pour lequel la gestion des versions d'objet n'est pas activée, il ne peut pas être récupéré. Pour plus d'informations sur la façon de récupérer des objets supprimés dans un compartiment avec gestion des versions, consultez [Comment puis-je récupérer un objet Amazon S3 qui a été supprimé ?](https://aws.amazon.com/premiumsupport/knowledge-center/s3-undelete-configuration/) dans le Support Knowledge Center.
+ `s3_path` – chemin Amazon S3 des fichiers à supprimer dans le format `s3://<{{bucket}}>/<{{prefix}}>/`
+ `options` – options destinées au filtrage des fichiers à supprimer et à la génération des fichiers manifestes.
+ `retentionPeriod` – spécifie une période de conservation des fichiers, en nombre d'heures. Les dossiers dont la date est postérieure à cette période sont conservés. Par défaut, elle est réglée sur 168 heures (7 jours).
+ `excludeStorageClasses` – les fichiers avec classe de stockage dans le jeu `excludeStorageClasses` ne sont pas supprimés. La valeur par défaut est `Set()` – jeu vide.
+ `manifestFilePath` – chemin facultatif pour la génération du fichier manifeste. Tous les fichiers qui ont été purgés avec succès sont enregistrés dans `Success.csv`, et ceux qui ont échoué dans `Failed.csv`
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif). Utilisé dans le chemin du fichier manifeste.
**Example**
```
glueContext.purge_s3_path("s3://bucket/path/", {"retentionPeriod": 1, "excludeStorageClasses": ["STANDARD_IA"], "manifestFilePath": "s3://bucketmanifest/"})
```
## transition\_table
**`transition_table(database, table_name, transition_to, options={}, transformation_ctx="", catalog_id=None)`**
Transition de la classe de stockage des fichiers stockés sur Amazon S3 pour la base de données et la table spécifiés pour le catalogue.
Vous pouvez effectuer une transition entre deux classes de stockage. Pour les classes de stockage `GLACIER` et `DEEP_ARCHIVE`, vous pouvez effectuer la transition vers ces classes. Cependant, vous devez utiliser `S3 RESTORE` pour effectuer la transition des classes de stockage `GLACIER` et `DEEP_ARCHIVE`.
Si vous exécutez des tâches ETL AWS Glue qui lisent des fichiers ou des partitions à partir d'Amazon S3, vous pouvez exclure certains types de classe de stockage Amazon S3. Pour plus d'informations, consultez [Exclusion des classes de stockage Amazon S3](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-storage-classes.html).
+ `database` – Base de données à utiliser.
+ `table_name` – nom de la table à utiliser.
+ `transition_to` – [classe de stockage Amazon S3](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/s3/model/StorageClass.html) vers laquelle effectuer la transition.
+ `options` – options destinées au filtrage des fichiers à supprimer et à la génération des fichiers manifestes.
+ `retentionPeriod` – spécifie une période de conservation des fichiers, en nombre d'heures. Les dossiers dont la date est postérieure à cette période sont conservés. Par défaut, elle est réglée sur 168 heures (7 jours).
+ `partitionPredicate` – une transition est effectuée pour les partitions satisfaisant à ce prédicat. Aucune transition n'a lieu pour les fichiers qui se trouvent dans la période de conservation. Valeur définie sur `""` – vide par défaut.
+ `excludeStorageClasses` – aucune transition n'a lieu pour les fichiers avec classe de stockage dans le jeu `excludeStorageClasses`. La valeur par défaut est `Set()` – jeu vide.
+ `manifestFilePath` – chemin facultatif pour la génération du fichier manifeste. Tous les fichiers dont la transition a été effectuée avec succès sont enregistrés dans `Success.csv`, et ceux qui ont échoué dans `Failed.csv`
+ `accountId` – ID de compte Amazon Web Services permettant d'exécuter la transformation de la transition. Obligatoire pour cette transformation.
+ `roleArn`— Le AWS rôle d'exécuter la transformation de transition. Obligatoire pour cette transformation.
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif). Utilisé dans le chemin du fichier manifeste.
+ `catalog_id` – ID du catalogue Data Catalog auquel vous accédez (ID du compte Data Catalog). Valeur définie sur `None` par défaut. `None` correspond par défaut à l'ID de catalogue du compte ayant initié l'appel dans le service.
**Example**
```
glueContext.transition_table("database", "table", "STANDARD_IA", {"retentionPeriod": 1, "excludeStorageClasses": ["STANDARD_IA"], "manifestFilePath": "s3://bucketmanifest/", "accountId": "12345678901", "roleArn": "arn:aws:iam::123456789012:user/example-username"})
```
## transition\_s3\_path
**`transition_s3_path(s3_path, transition_to, options={}, transformation_ctx="")`**
Transition récursive de la classe de stockage des fichiers dans le chemin Amazon S3 spécifié.
Vous pouvez effectuer une transition entre deux classes de stockage. Pour les classes de stockage `GLACIER` et `DEEP_ARCHIVE`, vous pouvez effectuer la transition vers ces classes. Cependant, vous devez utiliser `S3 RESTORE` pour effectuer la transition des classes de stockage `GLACIER` et `DEEP_ARCHIVE`.
Si vous exécutez des tâches ETL AWS Glue qui lisent des fichiers ou des partitions à partir d'Amazon S3, vous pouvez exclure certains types de classe de stockage Amazon S3. Pour plus d'informations, consultez [Exclusion des classes de stockage Amazon S3](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-storage-classes.html).
+ `s3_path` – chemin Amazon S3 des fichiers à passer au format `s3://<{{bucket}}>/<{{prefix}}>/`
+ `transition_to` – [classe de stockage Amazon S3](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/s3/model/StorageClass.html) vers laquelle effectuer la transition.
+ `options` – options destinées au filtrage des fichiers à supprimer et à la génération des fichiers manifestes.
+ `retentionPeriod` – spécifie une période de conservation des fichiers, en nombre d'heures. Les dossiers dont la date est postérieure à cette période sont conservés. Par défaut, elle est réglée sur 168 heures (7 jours).
+ `partitionPredicate` – une transition est effectuée pour les partitions satisfaisant à ce prédicat. Aucune transition n'a lieu pour les fichiers qui se trouvent dans la période de conservation. Valeur définie sur `""` – vide par défaut.
+ `excludeStorageClasses` – aucune transition n'a lieu pour les fichiers avec classe de stockage dans le jeu `excludeStorageClasses`. La valeur par défaut est `Set()` – jeu vide.
+ `manifestFilePath` – chemin facultatif pour la génération du fichier manifeste. Tous les fichiers dont la transition a été effectuée avec succès sont enregistrés dans `Success.csv`, et ceux qui ont échoué dans `Failed.csv`
+ `accountId` – ID de compte Amazon Web Services permettant d'exécuter la transformation de la transition. Obligatoire pour cette transformation.
+ `roleArn`— Le AWS rôle d'exécuter la transformation de transition. Obligatoire pour cette transformation.
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif). Utilisé dans le chemin du fichier manifeste.
**Example**
```
glueContext.transition_s3_path("s3://bucket/prefix/", "STANDARD_IA", {"retentionPeriod": 1, "excludeStorageClasses": ["STANDARD_IA"], "manifestFilePath": "s3://bucketmanifest/", "accountId": "12345678901", "roleArn": "arn:aws:iam::123456789012:user/example-username"})
```
## Extraction
+ [extract\_jdbc\_conf](#aws-glue-api-crawler-pyspark-extensions-glue-context-extract_jdbc_conf)
## extract\_jdbc\_conf
**`extract_jdbc_conf(connection_name, catalog_id = None)`**
Retourne un `dict` dont les clés contiennent les propriétés de configuration de l’objet de connexion AWS Glue dans le catalogue de données.
+ `user` – Nom d’utilisateur de la base de données.
+ `password` – Le mot de passe de la base de données.
+ `vendor` – Spécifie un fournisseur (`mysql`, `postgresql`, `oracle`, `sqlserver`, etc.).
+ `enforceSSL` – Chaîne booléenne indiquant si une connexion sécurisée est requise.
+ `customJDBCCert` – Utilise un certificat client spécifique à partir du chemin Amazon S3 indiqué.
+ `skipCustomJDBCCertValidation` – Chaîne booléenne indiquant si le `customJDBCCert` doit être validé par une autorité de certification.
+ `customJDBCCertString` – Informations supplémentaires sur le certificat personnalisé, spécifique au type de pilote.
+ `url` – (Obsolète) URL JDBC avec uniquement le protocole, le serveur et le port.
+ `fullUrl` – URL JDBC telle qu’elle a été saisie lors de la création de la connexion (disponible dans la version AWS Glue 3.0 ou ultérieure).
Exemple de récupération de configurations JDBC :
```
jdbc_conf = glueContext.extract_jdbc_conf(connection_name="your_glue_connection_name")
print(jdbc_conf)
>>> {'enforceSSL': 'false', 'skipCustomJDBCCertValidation': 'false', 'url': 'jdbc:mysql://myserver:3306', 'fullUrl': 'jdbc:mysql://myserver:3306/mydb', 'customJDBCCertString': '', 'user': 'admin', 'customJDBCCert': '', 'password': '1234', 'vendor': 'mysql'}
```
## Transactions
+ [start\_transaction](#aws-glue-api-pyspark-extensions-glue-context-start-transaction)
+ [commit\_transaction](#aws-glue-api-pyspark-extensions-glue-context-commit-transaction)
+ [cancel\_transaction](#aws-glue-api-pyspark-extensions-glue-cancel-transaction)
## start\_transaction
**`start_transaction(read_only)`**
Démarrez une nouvelle transaction. Appelle en interne l’API [Démarrer la transaction](https://docs.aws.amazon.com/lake-formation/latest/dg/aws-lake-formation-api-aws-lake-formation-api-transactions.html#aws-lake-formation-api-aws-lake-formation-api-transactions-StartTransaction) Lake Formation.
+ `read_only` – Valeur booléenne indiquant si cette transaction doit être en lecture seule ou en lecture et en écriture. Les écritures effectuées à l’aide d’un ID de transaction en lecture seule seront rejetées. Les transactions en lecture seule n’ont pas besoin d’être validées.
Retourne l’ID de transaction.
## commit\_transaction
**`commit_transaction(transaction_id, wait_for_commit = True)`**
Tentative de validation de la transaction spécifiée.`commit_transaction` peut être renvoyé avant la fin de la validation de la transaction. Appelle en interne la Lake Formation [commitTransaction](https://docs.aws.amazon.com/lake-formation/latest/dg/aws-lake-formation-api-aws-lake-formation-api-transactions.html#aws-lake-formation-api-aws-lake-formation-api-transactions-CommitTransaction) API.
+ `transaction_id ` – (Chaîne) La transaction à valider.
+ `wait_for_commit` – (Booléen) Détermine si le `commit_transaction` retourne immédiatement. La valeur par défaut est True. Si elle est false,`commit_transaction` interroge et attend que la transaction soit validée. Le temps d’attente est limité à 1 minute en utilisant le backoff exponentiel avec un maximum de 6 tentatives de nouvelle tentative.
Renvoie une valeur de type Boolean pour indiquer si la validation est effectuée ou non.
## cancel\_transaction
**`cancel_transaction(transaction_id)`**
Tentative d’annulation de la transaction spécifiée. Retourne une exception `TransactionCommittedException` si la transaction a déjà été validée. Appelle en interne l'[CancelTransaction](https://docs.aws.amazon.com/lake-formation/latest/dg/aws-lake-formation-api-aws-lake-formation-api-transactions.html#aws-lake-formation-api-aws-lake-formation-api-transactions-CancelTransaction)API Lake Formation.
+ `transaction_id` – (Chaîne) La transaction à annuler.
## Ecriture
+ [getSink](#aws-glue-api-crawler-pyspark-extensions-glue-context-get-sink)
+ [write\_dynamic\_frame\_from\_options](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options)
+ [write\_from\_options](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_from_options)
+ [write\_dynamic\_frame\_from\_catalog](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_catalog)
+ [write\_data\_frame\_from\_catalog](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_data_frame_from_catalog)
+ [write\_dynamic\_frame\_from\_jdbc\_conf](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_jdbc_conf)
+ [write\_from\_jdbc\_conf](#aws-glue-api-crawler-pyspark-extensions-glue-context-write_from_jdbc_conf)
## getSink
**`getSink(connection_type, format = None, transformation_ctx = "", **options)`**
Obtient un objet `DataSink` qui peut être utilisé pour écrire `DynamicFrames` sur des sources externes. Vérifiez d’abord le `format` SparkSQL pour être sûr d’obtenir le récepteur escompté.
+ `connection_type` – type de connexion à utiliser, telle qu’Amazon S3, Amazon Redshift et JDBC. Les valeurs valides sont les suivantes : `s3`, `mysql`, `postgresql`, `redshift`, `sqlserver`, `oracle`, `kinesis` et `kafka`.
+ `format` – Format SparkSQL à utiliser (facultatif).
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif).
+ `options` –Ensemble de paires nom-valeur utilisées pour spécifier les options de connexion. Certaines des valeurs possibles sont les suivantes :
+ `user` et `password` : Pour autorisation
+ `url` : Point de terminaison du magasin de données
+ `dbtable` :Nom de la table cible
+ `bulkSize`: Degré de parallélisme pour les opérations d’insertion
Les options que vous pouvez spécifier dépendent du type de connexion. Pour obtenir d’autres conseils et d’autres exemples, veuillez consulter [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
Exemple :
```
>>> data_sink = context.getSink("s3")
>>> data_sink.setFormat("json"),
>>> data_sink.writeFrame(myFrame)
```
## write\_dynamic\_frame\_from\_options
**`write_dynamic_frame_from_options(frame, connection_type, connection_options={}, format=None, format_options={}, transformation_ctx = "")`**
Écrit et retourne un `DynamicFrame` à l’aide de la connexion et du format spécifiés.
+ `frame` – Objet `DynamicFrame` à écrire.
+ `connection_type` – type de connexion, tel qu'Amazon S3, Amazon Redshift et JDBC. Les valeurs valides sont les suivantes : `s3`, `mysql`, `postgresql`, `redshift`, `sqlserver`, `oracle`, `kinesis` et `kafka`.
+ `connection_options` – Options de connexion, telles que le chemin et la table de base de données (facultatif). Pour un `connection_type` de `s3`, un chemin Amazon S3 est défini.
```
connection_options = {"path": "{{s3://aws-glue-target/temp}}"}
```
Pour les connexions JDBC, plusieurs propriétés doivent être définies. Notez que le nom de base de données doit être inclus dans l’URL. Il peut éventuellement être inclus dans les options de connexion.
**Avertissement**
Il n’est pas recommandé de stocker des mots de passe dans votre script. Envisagez de les utiliser `boto3` pour les récupérer depuis AWS Secrets Manager le catalogue de données AWS Glue.
```
connection_options = {"url": "{{jdbc-url/database}}", "user": "{{username}}", "password": {{passwordVariable}},"dbtable": "{{table-name}}", "redshiftTmpDir": "{{s3-tempdir-path}}"}
```
La propriété `dbtable` est le nom de la table JDBC. Pour les magasins de données JDBC qui prennent en charge les schémas dans une base de données, spécifiez `schema.table-name`. Si aucun schéma n'est fourni, c'est le schéma « public » par défaut qui est utilisé.
Pour de plus amples informations, veuillez consulter [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
+ `format` : une spécification de format. Utilisée pour une connexion Amazon S3 ou AWS Glue prenant en charge plusieurs formats. Consultez [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md) pour connaître les formats pris en charge.
+ `format_options` – options de format pour le format spécifié. Consultez [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md) pour connaître les formats pris en charge.
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif).
## write\_from\_options
**`write_from_options(frame_or_dfc, connection_type, connection_options={}, format={}, format_options={}, transformation_ctx = "")`**
Écrit et renvoie un `DynamicFrame` ou `DynamicFrameCollection` qui est créé avec la connexion et les informations de format spécifiées.
+ `frame_or_dfc` – Objet `DynamicFrame` ou `DynamicFrameCollection` à écrire.
+ `connection_type` – type de connexion, tel qu'Amazon S3, Amazon Redshift et JDBC. Les valeurs valides sont `s3`, `mysql`, `postgresql`, `redshift`, `sqlserver` et `oracle`.
+ `connection_options` – Options de connexion, telles que le chemin et la table de base de données (facultatif). Pour un `connection_type` de `s3`, un chemin Amazon S3 est défini.
```
connection_options = {"path": "{{s3://aws-glue-target/temp}}"}
```
Pour les connexions JDBC, plusieurs propriétés doivent être définies. Notez que le nom de base de données doit être inclus dans l’URL. Il peut éventuellement être inclus dans les options de connexion.
**Avertissement**
Il n’est pas recommandé de stocker des mots de passe dans votre script. Envisagez de les utiliser `boto3` pour les récupérer depuis AWS Secrets Manager le catalogue de données AWS Glue.
```
connection_options = {"url": "{{jdbc-url/database}}", "user": "{{username}}", "password": {{passwordVariable}},"dbtable": "{{table-name}}", "redshiftTmpDir": "{{s3-tempdir-path}}"}
```
La propriété `dbtable` est le nom de la table JDBC. Pour les magasins de données JDBC qui prennent en charge les schémas dans une base de données, spécifiez `schema.table-name`. Si aucun schéma n'est fourni, c'est le schéma « public » par défaut qui est utilisé.
Pour de plus amples informations, veuillez consulter [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
+ `format` : une spécification de format. Utilisée pour une connexion Amazon S3 ou AWS Glue prenant en charge plusieurs formats. Consultez [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md) pour connaître les formats pris en charge.
+ `format_options` – options de format pour le format spécifié. Consultez [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md) pour connaître les formats pris en charge.
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif).
## write\_dynamic\_frame\_from\_catalog
**`write_dynamic_frame_from_catalog(frame, database, table_name, redshift_tmp_dir, transformation_ctx = "", additional_options = {}, catalog_id = None)`**
Écrit et renvoie un objet `DynamicFrame` utilisant des informations provenant d'une table et d'une base de données Data Catalog.
+ `frame` – Objet `DynamicFrame` à écrire.
+ `Database` – base de données Data Catalog contenant la table.
+ `table_name` – nom de la table Data Catalog associée à la cible.
+ `redshift_tmp_dir` – répertoire Amazon Redshift temporaire à utiliser (facultatif).
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif).
+ `additional_options` – Ensemble de paires nom-valeur facultatives.
+ `catalog_id` – ID du catalogue (ID du compte) Data Catalog auquel vous accédez. Lorsque la valeur est Aucun, l'ID de compte par défaut de l'appelant est utilisé.
## write\_data\_frame\_from\_catalog
**`write_data_frame_from_catalog(frame, database, table_name, redshift_tmp_dir, transformation_ctx = "", additional_options = {}, catalog_id = None)`**
Écrit et renvoie un objet `DataFrame` utilisant des informations provenant d'une table et d'une base de données Data Catalog. Cette méthode prend en charge l’écriture dans les formats de lac de données (Hudi, Iceberg et Delta Lake). Pour plus d'informations, consultez [Utilisation de frameworks de lacs de données avec des tâches AWS Glue ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
+ `frame` – Objet `DataFrame` à écrire.
+ `Database` – base de données Data Catalog contenant la table.
+ `table_name` – nom de la table Data Catalog qui est associée à la cible.
+ `redshift_tmp_dir` – répertoire Amazon Redshift temporaire à utiliser (facultatif).
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif).
+ `additional_options` – Ensemble de paires nom-valeur facultatives.
+ `useSparkDataSink`— Lorsque ce paramètre est défini sur true, force AWS Glue à utiliser l'API native de Spark Data Sink pour écrire dans la table. Lorsque vous activez cette option, vous pouvez ajouter toutes les [options de source de données Spark](https://spark.apache.org/docs/latest/sql-data-sources.html) selon `additional_options` vos besoins. AWS Glue transmet ces options directement au Spark Writer.
+ `catalog_id` – ID de catalogue (ID de compte) du catalogue de données auquel vous accédez. Si vous ne spécifiez aucune valeur, l’ID de compte par défaut de l’appelant est utilisé.
**Limites**
Lorsque vous utilisez l'option `useSparkDataSink`, tenez compte des restrictions suivantes :
+ L’option [`enableUpdateCatalog`](update-from-job.md) n’est pas prise en charge lorsque vous utilisez l’option `useSparkDataSink`.
**Exemple : Écriture dans une table Hudi à l’aide de l’enregistreur de source de données Spark**
```
hudi_options = {
'useSparkDataSink': True,
'hoodie.table.name': {{}},
'hoodie.datasource.write.storage.type': 'COPY_ON_WRITE',
'hoodie.datasource.write.recordkey.field': 'product_id',
'hoodie.datasource.write.table.name': {{}},
'hoodie.datasource.write.operation': 'upsert',
'hoodie.datasource.write.precombine.field': 'updated_at',
'hoodie.datasource.write.hive_style_partitioning': 'true',
'hoodie.upsert.shuffle.parallelism': 2,
'hoodie.insert.shuffle.parallelism': 2,
'hoodie.datasource.hive_sync.enable': 'true',
'hoodie.datasource.hive_sync.database': {{}},
'hoodie.datasource.hive_sync.table': {{}},
'hoodie.datasource.hive_sync.use_jdbc': 'false',
'hoodie.datasource.hive_sync.mode': 'hms'}
glueContext.write_data_frame.from_catalog(
frame = {{}},
database = {{}},
table_name = {{}},
additional_options = hudi_options
)
```
## write\_dynamic\_frame\_from\_jdbc\_conf
**`write_dynamic_frame_from_jdbc_conf(frame, catalog_connection, connection_options={}, redshift_tmp_dir = "", transformation_ctx = "", catalog_id = None)`**
Écrit et retourne un `DynamicFrame` à l’aide des informations de connexion JDBC spécifiées.
+ `frame` – Objet `DynamicFrame` à écrire.
+ `catalog_connection` – Connexion de catalogue à utiliser.
+ `connection_options` – Options de connexion, telles que le chemin et la table de base de données (facultatif). Pour plus d'informations, consultez [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
+ `redshift_tmp_dir` – répertoire Amazon Redshift temporaire à utiliser (facultatif).
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif).
+ `catalog_id` – ID du catalogue (ID du compte) Data Catalog auquel vous accédez. Lorsque la valeur est Aucun, l'ID de compte par défaut de l'appelant est utilisé.
## write\_from\_jdbc\_conf
**`write_from_jdbc_conf(frame_or_dfc, catalog_connection, connection_options={}, redshift_tmp_dir = "", transformation_ctx = "", catalog_id = None)`**
Écrit et retourne un objet `DynamicFrame` ou `DynamicFrameCollection` à l’aide des informations de connexion JDBC spécifiées.
+ `frame_or_dfc` – Objet `DynamicFrame` ou `DynamicFrameCollection` à écrire.
+ `catalog_connection` – Connexion de catalogue à utiliser.
+ `connection_options` – Options de connexion, telles que le chemin et la table de base de données (facultatif). Pour plus d'informations, consultez [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
+ `redshift_tmp_dir` – répertoire Amazon Redshift temporaire à utiliser (facultatif).
+ `transformation_ctx` – Contexte de transformation à utiliser (facultatif).
+ `catalog_id` – ID du catalogue (ID du compte) Data Catalog auquel vous accédez. Lorsque la valeur est Aucun, l'ID de compte par défaut de l'appelant est utilisé.