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.
# Tutoriel : Écrire un script AWS Glue for Spark
Ce didacticiel vous présente le processus d'écriture des scripts AWS Glue. Vous pouvez exécuter des scripts selon un calendrier avec des tâches, ou de manière interactive avec des sessions interactives. Pour plus d’informations sur les tâches, consultez [Création de tâches ETL visuelles](author-job-glue.md). Pour plus d’informations sur les sessions interactives, consultez [Présentation de séances interactives AWS Glue](interactive-sessions-chapter.md#interactive-sessions-overview).
L'éditeur visuel AWS Glue Studio propose une interface graphique sans code pour créer des tâches AWS Glue. AWS Les scripts Glue soutiennent les tâches visuelles. Ils vous donnent accès à l’ensemble étendu d’outils disponibles pour travailler avec les programmes Apache Spark. Vous pouvez accéder aux bibliothèques natives Spark APIs et AWS Glue qui facilitent les flux de travail d'extraction, de transformation et de chargement (ETL) à partir d'un script AWS Glue.
Dans ce didacticiel, vous allez extraire, transformer et charger un jeu de données de tickets de stationnement. Le script qui effectue ce travail est identique en termes de forme et de fonction à celui généré dans [Making ETL easy with AWS Glue Studio](https://aws.amazon.com/blogs/big-data/making-etl-easier-with-aws-glue-studio/) sur le blog AWS Big Data, qui présente l'éditeur visuel AWS Glue Studio. En exécutant ce script dans une tâche, vous pouvez le comparer à des tâches visuelles et voir comment fonctionnent les scripts AWS Glue ETL. Cela vous prépare à utiliser des fonctionnalités supplémentaires qui ne sont pas encore disponibles dans les tâches visuels.
Vous utilisez le langage et les bibliothèques Python dans ce didacticiel. Des fonctionnalités similaires sont disponibles dans Scala. Après avoir suivi ce didacticiel, vous devriez être en mesure de générer et d'inspecter un exemple de script Scala pour comprendre comment exécuter le processus d'écriture de script Scala AWS Glue ETL.
## Conditions préalables
Ce didacticiel nécessite la configuration suivante :
+ Les mêmes prérequis que dans le billet de blog de AWS Glue Studio, qui vous demande d'exécuter un CloudFormation modèle.
Ce modèle utilise le catalogue de données AWS Glue pour gérer le jeu de données des tickets de stationnement disponible dans`s3://aws-bigdata-blog/artifacts/gluestudio/`. Il crée les ressources suivantes, qui seront référencées par la suite :
+ **Rôle AWS Glue Studio** – Rôle IAM à exécuter les tâchesAWS Glue
+ **Compartiment Amazon S3 AWS Glue Studio** – Nom du compartiment Amazon S3 pour stocker les fichiers liés aux blogs
+ **Billets YYZDB AWS Glue Studio** – Base de données du catalogue de données AWS Glue
+ **AWS Glue StudioTableTickets**— Table du catalogue de données à utiliser comme source
+ **AWS Glue StudioTableTrials**— Table du catalogue de données à utiliser comme source
+ **AWS Glue StudioParkingTicketCount **— Table du catalogue de données à utiliser comme destination
+ Le script généré dans le billet de blog de AWS Glue Studio. Si des modifications sont apportées au billet de blog, le script est également disponible dans le texte suivant.
### Génération d’un exemple de script
Vous pouvez utiliser l'éditeur visuel AWS Glue Studio comme un puissant outil de génération de code pour créer un échafaudage pour le script que vous souhaitez écrire. Vous allez utiliser cet outil pour créer un exemple de script.
Si vous voulez ignorer ces étapes, le script est fourni.
#### Exemple de script de didacticiel
```
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
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args["JOB_NAME"], args)
# Script generated for node S3 bucket
S3bucket_node1 = glueContext.create_dynamic_frame.from_catalog(
database="yyz-tickets", table_name="tickets", transformation_ctx="S3bucket_node1"
)
# Script generated for node ApplyMapping
ApplyMapping_node2 = ApplyMapping.apply(
frame=S3bucket_node1,
mappings=[
("tag_number_masked", "string", "tag_number_masked", "string"),
("date_of_infraction", "string", "date_of_infraction", "string"),
("ticket_date", "string", "ticket_date", "string"),
("ticket_number", "decimal", "ticket_number", "float"),
("officer", "decimal", "officer_name", "decimal"),
("infraction_code", "decimal", "infraction_code", "decimal"),
("infraction_description", "string", "infraction_description", "string"),
("set_fine_amount", "decimal", "set_fine_amount", "float"),
("time_of_infraction", "decimal", "time_of_infraction", "decimal"),
],
transformation_ctx="ApplyMapping_node2",
)
# Script generated for node S3 bucket
S3bucket_node3 = glueContext.write_dynamic_frame.from_options(
frame=ApplyMapping_node2,
connection_type="s3",
format="glueparquet",
connection_options={"path": "s3://DOC-EXAMPLE-BUCKET", "partitionKeys": []},
format_options={"compression": "gzip"},
transformation_ctx="S3bucket_node3",
)
job.commit()
```
**Générer un exemple de script**
1. Terminez le didacticiel AWS Glue Studio. Pour terminer ce didacticiel, voir [Création d'une tâche dans AWS Glue Studio à partir d'un exemple de tâche](https://docs.aws.amazon.com/glue/latest/dg/edit-nodes-chapter.html#create-jobs-start.html).
1. Accédez à l’onglet **Script**sur la page de la tâche, comme illustré dans la capture d’écran suivante :
![\[L'onglet Script d'une tâche AWS Glue.\]](http://docs.aws.amazon.com/fr_fr/glue/latest/dg/images/programming-intro-generated-script.png)
1. Copiez l’intégralité du contenu de l’onglet **Script**. En définissant le langage de script dans **Job details** (Détails de la tâche), vous pouvez alterner entre la génération de code Python ou Scala.
## Étape 1. Créer une tâche et coller votre script
Au cours de cette étape, vous allez créer une tâche AWS Glue dans le AWS Management Console. Cela permet de configurer une configuration qui permet à AWS Glue d'exécuter votre script. Elle crée également un espace dans lequel vous pouvez stocker et modifier votre script.
**Pour créer une tâche**
1. Dans le AWS Management Console, accédez à la page d'accueil de AWS Glue.
1. Dans le panneau de navigation, choisissez **Tâches**.
1. Choisissez **Spark script editor** (Éditeur de script Spark) dans **Create job** (Créer une tâche), puis **Create** (Créer).
1. **Facultatif** - Collez le texte intégral de votre script dans le volet **Script**. Vous pouvez également suivre le didacticiel.
## Étape 2. Importer des bibliothèques AWS Glue
Vous devez configurer votre script pour interagir avec le code et la configuration qui sont définis en dehors du script. Ce travail est réalisé dans les coulisses de AWS Glue Studio.
Dans cette étape, vous effectuez les actions suivantes.
+ Importer et initialiser un objet `GlueContext`. Il s’agit de l’importation la plus importante, du point de vue de l’écriture de scripts. Elle vous présente les méthodes standards pour définir les jeux de données source et cible, qui sont le point de départ de tout script ETL. Pour en savoir plus sur la classe `GlueContext`, consultez [GlueContext classe](aws-glue-api-crawler-pyspark-extensions-glue-context.md).
+ Initialisation d’un `SparkContext` et d’une `SparkSession`. Ils vous permettent de configurer le moteur Spark disponible dans le job AWS Glue. Vous n'aurez pas besoin de les utiliser directement dans les scripts d'introduction de AWS Glue.
+ Appelez `getResolvedOptions` pour préparer vos arguments de tâche à utiliser dans le script. Pour plus d’informations sur la résolution des paramètres de la tâche, consultez [Accès aux paramètres à l'aide de `getResolvedOptions`](aws-glue-api-crawler-pyspark-extensions-get-resolved-options.md).
+ Initialisation d’une `Job`. L'`Job`objet définit la configuration et suit l'état des différentes fonctionnalités optionnelles de AWS Glue. Votre script peut s’exécuter sans objet `Job`, mais il est recommandé de l’initialiser afin d’éviter toute confusion si ces fonctionnalités sont intégrées ultérieurement.
L’une de ces fonctionnalités concerne les signets de tâche, que vous pouvez éventuellement configurer dans ce didacticiel. Vous pouvez en savoir plus sur les signets de tâche dans la section suivante, [Facultatif : activer les signets de tâche](#aws-glue-programming-intro-tutorial-create-job-bookmarks).
Dans cette procédure, vous écrivez le code suivant. Ce code fait partie de l'exemple de script généré.
```
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args["JOB_NAME"], args)
```
**Pour importer des bibliothèques AWS Glue**
+ Copiez cette section de code et collez-la dans l’éditeur **Script**.
**Note**
Vous pourriez considérer la copie de code comme une mauvaise pratique d’ingénierie. Dans ce didacticiel, nous vous le suggérons pour vous encourager à nommer systématiquement vos variables principales dans tous les scripts AWS Glue ETL.
## Étape 3. Extraire des données d’une source
Dans tout processus ETL, vous devez d’abord définir le jeu de données source que vous voulez modifier. Dans l'éditeur visuel AWS Glue Studio, vous fournissez ces informations en créant un nœud **Source**.
Au cours de cette étape, vous devez fournir à la méthode `create_dynamic_frame.from_catalog` une `database` et un `table_name` pour extraire des données d’une source configurée dans le catalogue de données AWS Glue.
À l’étape précédente, vous avez initialisé un objet `GlueContext`. Vous utilisez cet objet pour rechercher les méthodes qui sont utilisées pour configurer les sources, telles que `create_dynamic_frame.from_catalog`.
Dans cette procédure, vous écrivez le code suivant à l'aide de `create_dynamic_frame.from_catalog`. Ce code fait partie de l'exemple de script généré.
```
S3bucket_node1 = glueContext.create_dynamic_frame.from_catalog(
database="yyz-tickets", table_name="tickets", transformation_ctx="S3bucket_node1"
)
```
**Extraire des données d’une source**
1. Consultez la documentation pour trouver une méthode permettant d'`GlueContext`extraire des données d'une source définie dans le AWS Glue Data Catalog. Ces méthodes sont documentées dans [GlueContext classe](aws-glue-api-crawler-pyspark-extensions-glue-context.md). Choisissez la méthode [create\$1dynamic\$1frame.from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog). Appelez cette méthode sur `glueContext`.
1. Consultez la documentation pour `create_dynamic_frame.from_catalog`. Cette méthode nécessite les paramètres `database` et `table_name`. Fournissez les paramètres nécessaires à `create_dynamic_frame.from_catalog`.
Le catalogue de données AWS Glue stocke des informations sur l'emplacement et le format de vos données sources. Il a été configuré dans la section des prérequis. Vous n’avez pas besoin de fournir ces informations directement à votre script.
1. **Facultatif** – fournissez le paramètre `transformation_ctx` à la méthode afin de prendre en charge les signets de tâche. Vous pouvez en savoir plus sur les signets de tâche dans la section suivante, [Facultatif : activer les signets de tâche](#aws-glue-programming-intro-tutorial-create-job-bookmarks).
**Note**
**Méthodes courantes d’extraction de données**
[create\$1dynamic\$1frame\$1from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_catalog)est utilisé pour se connecter aux tables du catalogue de données AWS Glue.
Si vous devez fournir directement à votre tâche une configuration qui décrit la structure et l’emplacement de votre source, consultez la méthode [create\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options). Vous devrez fournir des paramètres plus détaillés décrivant vos données que lorsque vous utilisez `create_dynamic_frame.from_catalog`.
Reportez-vous à la documentation supplémentaire sur `format_options` et `connection_parameters` pour identifier les paramètres requis. Pour savoir comment fournir à votre script des informations concernant le format de vos données sources, consultez [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md). Pour savoir comment fournir à votre script des informations concernant l’emplacement de vos données sources, consultez [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
Si vous lisez des informations provenant d’une source de streaming, vous fournissez des informations sources à votre tâche via les méthodes [create\$1data\$1frame\$1from\$1catalog](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-catalog) ou [create\$1data\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create-dataframe-from-options). Notez que ces méthodes renvoient Apache Spark `DataFrames`.
Notre code généré appelle `create_dynamic_frame.from_catalog`, tandis que la documentation de référence fait référence à `create_dynamic_frame_from_catalog`. Ces méthodes appellent finalement le même code et sont incluses afin que vous puissiez écrire du code plus propre. Vous pouvez le vérifier en consultant la source de notre wrapper Python, disponible sur [https://github.com/awslabs/aws-glue-libs/blob/master/awsglue/context.py](https://github.com/awslabs/aws-glue-libs/blob/master/awsglue/context.py).
## Étape 4 : Transformez les données avec AWS Glue
Après avoir extrait les données sources dans un processus ETL, vous devez décrire la manière dont vous souhaitez modifier vos données. Vous fournissez ces informations en créant un nœud **Transform** dans l'éditeur visuel AWS Glue Studio.
À cette étape, fournissez la méthode `ApplyMapping` avec une carte des noms et des types de champs actuels et souhaités pour transformer votre `DynamicFrame`.
Vous effectuez les transformations suivantes.
+ Supprimez les quatre clés `location` et `province`.
+ Modifiez le nom de `officer` en `officer_name`.
+ Modifiez le type de `ticket_number` et `set_fine_amount` en `float`.
`create_dynamic_frame.from_catalog` vous fournit un objet `DynamicFrame`. A `DynamicFrame` représente un ensemble de données dans AWS Glue. AWS Les transformations à la colle sont des opérations qui changent`DynamicFrames`.
**Note**
Qu’est-ce qu’un `DynamicFrame` ?
Un `DynamicFrame` est une abstraction qui vous permet de connecter un jeu de données à une description des noms et types d’entrées dans les données. Dans Apache Spark, il existe une abstraction similaire appelée DataFrame a. Pour une explication DataFrames, consultez le [guide Spark SQL](https://spark.apache.org/docs/latest/sql-programming-guide.html).
Avec `DynamicFrames`, vous pouvez décrire les schémas de jeux de données de manière dynamique. Prenons l'exemple d'un ensemble de données avec une colonne de prix, où certaines entrées stockent le prix sous forme de chaîne, tandis que d'autres le stockent sous forme de double. AWS Glue calcule un schéma on-the-fly : elle crée un enregistrement autodescriptif pour chaque ligne.
Les champs incohérents (comme le prix) sont explicitement représentés par un type (`ChoiceType`) dans le schéma du cadre. Vous pouvez corriger vos champs incohérents en les supprimant avec `DropFields` ou en les résolvant avec `ResolveChoice`. Il s’agit de transformations disponibles sur le `DynamicFrame`. Vous pouvez ensuite réécrire vos données dans votre lac de données avec `writeDynamicFrame`.
Vous pouvez appeler un grand nombre des mêmes transformations à partir des méthodes sur la classe `DynamicFrame`, ce qui peut conduire à des scripts plus lisibles. Pour plus d’informations sur `DynamicFrame`, consultez [DynamicFrame classe](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md).
Dans cette procédure, vous écrivez le code suivant à l'aide de `ApplyMapping`. Ce code fait partie de l'exemple de script généré.
```
ApplyMapping_node2 = ApplyMapping.apply(
frame=S3bucket_node1,
mappings=[
("tag_number_masked", "string", "tag_number_masked", "string"),
("date_of_infraction", "string", "date_of_infraction", "string"),
("ticket_date", "string", "ticket_date", "string"),
("ticket_number", "decimal", "ticket_number", "float"),
("officer", "decimal", "officer_name", "decimal"),
("infraction_code", "decimal", "infraction_code", "decimal"),
("infraction_description", "string", "infraction_description", "string"),
("set_fine_amount", "decimal", "set_fine_amount", "float"),
("time_of_infraction", "decimal", "time_of_infraction", "decimal"),
],
transformation_ctx="ApplyMapping_node2",
)
```
**Pour transformer les données avec AWS Glue**
1. Consultez la documentation pour identifier une transformation permettant de modifier et de supprimer des champs. Pour en savoir plus, consultez [GlueTransform classe de base](aws-glue-api-crawler-pyspark-transforms-GlueTransform.md). Choisissez la transformation `ApplyMapping`. Pour plus d’informations sur `ApplyMapping`, consultez [ApplyMapping classe](aws-glue-api-crawler-pyspark-transforms-ApplyMapping.md). Appelez `apply` sur l’objet de transformation `ApplyMapping`.
**Note**
Qu’est-ce qu’`ApplyMapping` ?
`ApplyMapping` prend un `DynamicFrame` et le transforme. Il prend une liste de tuples qui représentent des transformations sur des champs – un « mappage ». Les deux premiers éléments du tuple, un nom et un type de champ, sont utilisés pour identifier un champ du cadre. Les deux autres paramètres sont également un nom et un type de champ.
ApplyMapping convertit le champ source en nom cible et saisissez-en un nouveau`DynamicFrame`, qu'il renvoie. Les champs qui ne sont pas fournis sont supprimés dans la valeur de retour.
Plutôt que d’appeler `apply`, vous pouvez appeler la même transformation avec la méthode `apply_mapping` sur le `DynamicFrame`, pour créer un code plus fluide et lisible. Pour de plus amples informations, veuillez consulter [apply\$1mapping](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-apply_mapping).
1. Consultez la documentation pour `ApplyMapping` afin d’identifier les paramètres requis. Consultez [ApplyMapping classe](aws-glue-api-crawler-pyspark-transforms-ApplyMapping.md). Vous constaterez que cette méthode nécessite les paramètres `frame` et `mappings`. Fournissez les paramètres nécessaires à `ApplyMapping`.
1. **Facultatif** – fournissez `transformation_ctx` à la méthode afin de prendre en charge les signets de tâche. Vous pouvez en savoir plus sur les signets de tâche dans la section suivante, [Facultatif : activer les signets de tâche](#aws-glue-programming-intro-tutorial-create-job-bookmarks).
**Note**
**Fonctionnalité Apache Spark**
Nous proposons des transformations pour rationaliser les flux de travail ETL au sein de votre tâche. Vous avez également accès aux bibliothèques qui sont disponibles dans un programme Spark de votre tâche, conçues à des fins plus générales. Pour les utiliser, vous effectuez une conversion entre `DynamicFrame` et `DataFrame`.
Vous pouvez créer un `DataFrame` avec [toDF](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-toDF). Vous pouvez ensuite utiliser les méthodes disponibles sur le DataFrame pour transformer votre ensemble de données. Pour plus d'informations sur ces méthodes, consultez [DataFrame](https://spark.apache.org/docs/3.1.1/api/python/reference/api/pyspark.sql.DataFrame.html). Vous pouvez ensuite effectuer une conversion à l'[fromDF](aws-glue-api-crawler-pyspark-extensions-dynamic-frame.md#aws-glue-api-crawler-pyspark-extensions-dynamic-frame-fromDF)envers en utilisant les opérations AWS Glue pour charger votre cadre sur une cible.
## Étape 5. Charger des données dans une cible
Après avoir transformé vos données, vous les stockez généralement dans un endroit différent de la source. Vous effectuez cette opération en créant un nœud **cible** dans l'éditeur visuel AWS Glue Studio.
Au cours de cette étape, vous fournissez à la méthode des valeurs `write_dynamic_frame.from_options`, `connection_type`, `connection_options`, `format` et `format_options` pour charger des données dans un compartiment cible dans Amazon S3.
À l’étape 1, vous avez initialisé un objet `GlueContext`. Dans AWS Glue, vous trouverez ici les méthodes utilisées pour configurer les cibles, un peu comme les sources.
Dans cette procédure, vous écrivez le code suivant à l'aide de `write_dynamic_frame.from_options`. Ce code fait partie de l'exemple de script généré.
```
S3bucket_node3 = glueContext.write_dynamic_frame.from_options(
frame=ApplyMapping_node2,
connection_type="s3",
format="glueparquet",
connection_options={"path": "s3://amzn-s3-demo-bucket", "partitionKeys": []},
format_options={"compression": "gzip"},
transformation_ctx="S3bucket_node3",
)
```
**Charger des données dans une cible**
1. Consultez la documentation pour trouver une méthode pour charger des données dans un compartiment Amazon S3 cible. Ces méthodes sont documentées dans [GlueContext classe](aws-glue-api-crawler-pyspark-extensions-glue-context.md). Choisissez la méthode [write\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options). Appelez cette méthode sur `glueContext`.
**Note**
**Méthodes courantes pour le chargement de données**
`write_dynamic_frame.from_options` est la méthode la plus courante pour charger des données. Il prend en charge toutes les cibles disponibles dans AWS Glue.
Si vous écrivez sur une cible JDBC définie dans une connexion AWS Glue, utilisez cette méthode. [write\$1dynamic\$1frame\$1from\$1jdbc\$1conf](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_jdbc_conf) AWS Les connexions Glue stockent des informations sur la manière de se connecter à une source de données. Il n’est donc plus nécessaire de fournir ces informations dans `connection_options`. Cependant, vous devez toujours utiliser `connection_options` pour fournir `dbtable`.
`write_dynamic_frame.from_catalog` n’est pas une méthode courante pour charger des données. Cette méthode met à jour le catalogue de données AWS Glue sans mettre à jour le jeu de données sous-jacent et est utilisée en combinaison avec d'autres processus qui modifient le jeu de données sous-jacent. Pour de plus amples informations, veuillez consulter [Mise à jour du schéma et ajout de nouvelles partitions dans le catalogue de données à l’aide des tâches AWS Glue ETL](update-from-job.md).
1. Consultez la documentation pour [write\$1dynamic\$1frame\$1from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options). Cette méthode nécessite `frame`, `connection_type`, `format`, `connection_options` et `format_options`. Appelez cette méthode sur `glueContext`.
1. Reportez-vous à la documentation supplémentaire sur `format_options` et `format` pour identifier les paramètres dont vous avez besoin. Pour une explication des formats de données, consultez [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md).
1. Reportez-vous à la documentation supplémentaire sur `connection_type` et `connection_options` pour identifier les paramètres dont vous avez besoin. Pour une explication des connexions, consultez [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
1. Fournissez les paramètres nécessaires à `write_dynamic_frame.from_options`. Cette méthode a une configuration similaire à `create_dynamic_frame.from_options`.
1. **Facultatif** – fournissez `transformation_ctx` à `write_dynamic_frame.from_options` afin de prendre en charge les signets de tâche. Vous pouvez en savoir plus sur les signets de tâche dans la section suivante, [Facultatif : activer les signets de tâche](#aws-glue-programming-intro-tutorial-create-job-bookmarks).
## Étape 6. Valider l’objet `Job`
À l’étape 1, vous avez initialisé un objet `Job`. Vous devrez peut-être finaliser son cycle de vie manuellement à la fin de votre script si certaines fonctionnalités facultatives en ont besoin pour fonctionner correctement, par exemple lorsque vous utilisez les signets de tâche. Ce travail est réalisé dans les coulisses de AWS Glue Studio.
Dans cette étape, appelez la méthode `commit` sur l’objet `Job`.
Dans cette procédure, vous écrivez le code suivant. Ce code fait partie de l'exemple de script généré.
```
job.commit()
```
**Pour valider l’objet `Job`**
1. Si vous ne l’avez pas encore fait, suivez les étapes facultatives décrites dans les sections précédentes pour inclure `transformation_ctx`.
1. Appelez `commit`.
## Facultatif : activer les signets de tâche
À chaque étape précédente, il vous a été demandé de définir les paramètres `transformation_ctx`. Ceci est lié à une fonctionnalité appelée signets de tâche.
Avec les signets de tâche, vous pouvez gagner du temps et de l’argent grâce à des tâches qui s’exécutent de manière récurrente, par rapport à des jeux de données où il est possible de suivre facilement le travail précédent. Les signets de tâches suivent la progression d'une transformation AWS Glue dans un ensemble de données par rapport aux exécutions précédentes. En suivant la fin des séries précédentes, AWS Glue peut limiter son travail aux lignes qu'elle n'a jamais traitées auparavant. Pour plus d’informations sur les signets de tâche, consultez [Suivi des données traitées à l'aide de signets de tâche](monitor-continuations.md).
Pour activer les favoris des signets de tâche, ajoutez d’abord le `transformation_ctx` des déclarations sur les fonctions que nous fournissons, comme illustré dans les exemples précédents. L’état du signet de tâche est conservé au fil des exécutions. Les paramètres `transformation_ctx` sont des clés utilisées pour accéder à cet état. Seules, ces instructions ne servent à rien. Vous devez également activer la fonctionnalité dans la configuration de votre tâche.
Au cours de cette procédure, vous activez les signets de tâche à l’aide de la AWS Management Console.
**Définir les signets de tâche**
1. Accédez à la section **Détails de la tâche** de votre tâche correspondante.
1. Définissez **Job bookmark** (Signet de tâche) sur **Enable** (Activer).
## Étape 7. Exécution de votre code en tant que tâche
Dans cette étape, vous exécutez votre tâche pour vérifier que vous avez bien suivi ce didacticiel. Cela se fait en cliquant sur un bouton, comme dans l'éditeur visuel AWS Glue Studio.
**Exécuter votre code en tant que tâche**
1. Choisissez **Untitled job** (Tâche sans titre) dans la barre de titre pour modifier et définir le nom de votre tâche.
1. Accédez à l’onglet **Job details** (Informations de la tâche). Attribuez à votre tâche un **rôle IAM**. Vous pouvez utiliser celui créé par le CloudFormation modèle dans les prérequis du didacticiel AWS Glue Studio. Si vous avez terminé ce didacticiel, il devrait être disponible sous `AWS Glue StudioRole`.
1. Choisissez **Save** (Enregistrer) pour enregistrer votre script.
1. Choisissez **Run** (Exécuter) pour exécuter votre tâche.
1. Accédez à l’onglet **Runs** (Exécutions) pour vérifier que votre tâche est terminée.
1. Naviguez vers*amzn-s3-demo-bucket*, la cible pour`write_dynamic_frame.from_options`. Vérifiez que le résultat correspond à vos attentes.
Pour plus d’informations sur la configuration et la gestion des tâches, consultez [Fournir vos propres scripts personnalisés](console-custom-created.md).
## En savoir plus
Les bibliothèques et méthodes Apache Spark sont disponibles dans les scripts AWS Glue. Vous pouvez consulter la documentation Spark pour comprendre ce que vous pouvez faire avec les bibliothèques incluses. Pour de plus amples informations, consultez la [section des exemples du référentiel Spark source](https://github.com/apache/spark/tree/master/examples/src/main/python).
AWS Glue 2.0\$1 inclut plusieurs bibliothèques Python courantes par défaut. Il existe également des mécanismes pour charger vos propres dépendances dans une tâche AWS Glue dans un environnement Scala ou Python. Pour plus d’informations sur les dépendances Python, consultez [Utiliser les bibliothèques Python avec AWS Glue](aws-glue-programming-python-libraries.md).
Pour plus d'exemples d'utilisation des fonctionnalités de AWS Glue en Python, consultez[Exemples de code Python AWS Glue](aws-glue-programming-python-samples.md). Les tâches Scala et Python ont des fonctionnalités identiques, donc nos exemples Python devraient vous donner quelques idées sur la façon d’effectuer une tâche similaire dans Scala.