Développement et test AWS Glue scripts de tâches en local - AWS Glue
Développer en utilisant AWS Glue StudioDéveloppement à l'aide de sessions interactivesDéveloppement à l'aide d'une image DockerDéveloppement à l'aide du AWS Glue ETLbibliothèque

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.

Développement et test AWS Glue scripts de tâches en local

Lorsque vous développez et testez votre AWS Glue pour les scripts de tâches Spark, plusieurs options sont disponibles :

  • AWS Glue Studio console

    • Visual editor (Éditeur visuel)

    • Éditeur de script

    • AWS Glue Studio bloc-notes

  • Sessions interactives

    • Bloc-notes Jupyter

  • Image Docker

    • Développement local

    • Développement à distance

  • AWS Glue Studio ETLbibliothèque

    • Développement local

Vous pouvez choisir l'une des options ci-dessus en fonction de vos besoins.

Si vous préférez ne pas coder ou moins d'expérience en matière de code, AWS Glue Studio l'éditeur visuel est un bon choix.

Si vous préférez une expérience de bloc-notes interactive, AWS Glue Studio un ordinateur portable est un bon choix. Pour plus d'informations, voir Utilisation de blocs-notes avec AWS Glue Studio and AWS Glue. Si vous souhaitez utiliser votre propre environnement local, les sessions interactives sont un bon choix. Pour plus d'informations, voir Utilisation de sessions interactives avec AWS Glue.

Si vous préférez une expérience de développement local/à distance, l'image Docker est un bon choix. Cela vous permet de développer et de tester les scripts de travail AWS Glue for Spark où vous le souhaitez, sans avoir à vous engager AWS Glue coût.

Si vous préférez le développement local sans Docker, installez AWS Glue ETLle répertoire local de la bibliothèque est un bon choix.

Développer en utilisant AWS Glue Studio

Le AWS Glue Studio l'éditeur visuel est une interface graphique qui facilite la création, l'exécution et le suivi de tâches d'extraction, de transformation et de chargement (ETL) dans AWS Glue. Vous pouvez composer visuellement des flux de travail de transformation des données et les exécuter de manière fluide sur AWS Glueest le moteur sans serveur ETL basé sur Apache Spark. Vous pouvez inspecter le schéma et les résultats des données à chaque étape de la tâche. Pour de plus amples informations, veuillez consulter le .AWS Glue Studio Guide de l'utilisateur

Développement à l'aide de sessions interactives

Les sessions interactives vous permettent de créer et de tester des applications à partir de l'environnement de votre choix. Pour plus d'informations, voir Utilisation de sessions interactives avec AWS Glue.

Développement à l'aide d'une image Docker

Note

Les instructions de cette section n'ont pas été testées sur les systèmes d'exploitation Microsoft Windows.

Pour le développement local et les tests sur les plateformes Windows, consultez le blog Building an AWS Glue ETLpipeline local sans AWS compte

Pour une plate-forme de données prête pour la production, le processus de développement et le pipeline CI/CD pour AWS Glue l'emploi est un sujet clé. Vous pouvez développer et tester de manière flexible AWS Glue jobs dans un conteneur Docker. AWS Glue héberge des images Docker sur Docker Hub pour configurer votre environnement de développement avec des utilitaires supplémentaires. Vous pouvez utiliser votre bloc-notes préféré IDE ou REPL en utilisant AWS Glue ETLbibliothèque. Cette rubrique décrit comment développer et tester AWS Glue jobs version 4.0 dans un conteneur Docker à l'aide d'une image Docker.

Les images Docker suivantes sont disponibles pour AWS Glue sur Docker Hub.

  • Dans AWS Glue version 4.0 : amazon/aws-glue-libs:glue_libs_4.0.0_image_01

  • Dans AWS Glue version 3.0 : amazon/aws-glue-libs:glue_libs_3.0.0_image_01

  • Dans AWS Glue version 2.0 : amazon/aws-glue-libs:glue_libs_2.0.0_image_01

Ces images sont pour x86_64. Il est recommandé de tester sur cette architecture. Cependant, il peut être possible de retravailler une solution de développement locale sur des images de base non prises en charge.

Cet exemple décrit l'utilisation d'amazon/aws-glue-libs:glue_libs_4.0.0_image_01 et l'exécution du conteneur sur une machine locale. Cette image de conteneur a été testée pour AWS Glue version 3.3 Tâches Spark. Cette image contient les éléments suivants :

  • Amazon Linux

  • AWS Glue ETLbibliothèque (aws-glue-libs)

  • Apache Spark 3.3.0

  • Serveur d'historique Spark

  • Jupyter Lab

  • Livy

  • Autres dépendances de bibliothèque (le même ensemble que celles de AWS Glue système d'emploi)

Complétez l'une des sections suivantes en fonction de vos besoins :

  • Configurer le conteneur pour utiliser spark-submit

  • Configurez le conteneur pour utiliser REPL shell (PySpark)

  • Configurer le conteneur pour utiliser Pytest

  • Configurer le conteneur pour utiliser Jupyter Lab

  • Configurer le conteneur pour utiliser Visual Studio Code

Prérequis

Avant de commencer, assurez-vous que Docker est installé et que le démon Docker est en cours d'exécution. Pour obtenir des instructions d'installation, consultez la documentation Docker pour Mac ou Linux. La machine qui exécute le Docker héberge le AWS Glue contenant. Assurez-vous également que vous disposez d'au moins 7 Go d'espace disque pour l'image sur l'hôte exécutant Docker.

Pour plus d'informations sur les restrictions lors du développement AWS Glue codez localement, voir Restrictions de développement locales.

Configuration AWS

Pour activer AWS API les appels depuis le conteneur, configurez les AWS informations d'identification en suivant les étapes suivantes. Dans les sections suivantes, nous utiliserons ce profil AWS nommé.

  1. Configurez le AWS CLI, en configurant un profil nommé. Pour plus d'informations sur AWS CLI la configuration, consultez la section Configuration et paramètres des fichiers d'identification dans la AWS CLI documentation.

  2. Exécutez la commande suivante dans un terminal :

    PROFILE_NAME="<your_profile_name>"

Vous devrez peut-être également définir la variable d'AWS_REGIONenvironnement pour spécifier Région AWS à qui envoyer les demandes.

Configuration et exécution du conteneur

La configuration du conteneur pour exécuter PySpark du code via la commande spark-submit inclut les étapes de haut niveau suivantes :

  1. Extraire l'image de Docker Hub.

  2. Exécuter le conteneur.

Extraction de l'image depuis Docker Hub

Exécutez la commande suivante pour extraire l'image de Docker Hub :

docker pull amazon/aws-glue-libs:glue_libs_4.0.0_image_01

Exécution du conteneur

Vous pouvez maintenant exécuter un conteneur en utilisant cette image. Vous pouvez choisir l'une des options suivantes en fonction de vos besoins.

spark-submit

Vous pouvez exécuter un AWS Glue script de travail en exécutant la spark-submit commande sur le conteneur.

  1. Écrivez le script et enregistrez-le sous le nom sample1.py dans le répertoire /local_path_to_workspace. Un exemple de code est inclus en annexe de cette rubrique.

    $ WORKSPACE_LOCATION=/local_path_to_workspace
$ SCRIPT_FILE_NAME=sample.py
$ mkdir -p ${WORKSPACE_LOCATION}/src
$ vim ${WORKSPACE_LOCATION}/src/${SCRIPT_FILE_NAME}

  2. Exécutez la commande suivante pour exécuter la commande spark-submit sur le conteneur afin de soumettre une nouvelle application Spark :

    $ docker run -it -v ~/.aws:/home/glue_user/.aws -v $WORKSPACE_LOCATION:/home/glue_user/workspace/ -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 --name glue_spark_submit amazon/aws-glue-libs:glue_libs_4.0.0_image_01 spark-submit /home/glue_user/workspace/src/$SCRIPT_FILE_NAME
...22/01/26 09:08:55 INFO DAGScheduler: Job 0 finished: fromRDD at DynamicFrame.scala:305, took 3.639886 s
root
|-- family_name: string
|-- name: string
|-- links: array
| |-- element: struct
| | |-- note: string
| | |-- url: string
|-- gender: string
|-- image: string
|-- identifiers: array
| |-- element: struct
| | |-- scheme: string
| | |-- identifier: string
|-- other_names: array
| |-- element: struct
| | |-- lang: string
| | |-- note: string
| | |-- name: string
|-- sort_name: string
|-- images: array
| |-- element: struct
| | |-- url: string
|-- given_name: string
|-- birth_date: string
|-- id: string
|-- contact_details: array
| |-- element: struct
| | |-- type: string
| | |-- value: string
|-- death_date: string

...

  3. (Facultatif) Configurez spark-submit pour qu’il corresponde à votre environnement. Par exemple, vous pouvez transmettre vos dépendances à la configuration --jars. Pour plus d'informations, consultez la section Chargement dynamique des propriétés de Spark dans la documentation de Spark.

REPLcoque (Pyspark)

Vous pouvez exécuter un shell REPL (en read-eval-print boucles) pour le développement interactif.

Exécutez la commande suivante pour exécuter la PySpark commande sur le conteneur afin de démarrer le REPL shell :

$ docker run -it -v ~/.aws:/home/glue_user/.aws -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 --name glue_pyspark amazon/aws-glue-libs:glue_libs_4.0.0_image_01 pyspark
...
 ____ __
 / __/__ ___ _____/ /__
 _\ \/ _ \/ _ `/ __/ '_/
 /__ / .__/\_,_/_/ /_/\_\  version 3.1.1-amzn-0
 /_/

Using Python version 3.7.10 (default, Jun 3 2021 00:02:01)
Spark context Web UI available at http://56e99d000c99:4040
Spark context available as 'sc' (master = local[*], app id = local-1643011860812).
SparkSession available as 'spark'.
>>>
Pytest

Pour les tests unitaires, vous pouvez utiliser pytest pour AWS Glue Scripts de tâches Spark.

Exécutez les commandes suivantes pour la préparation.

$ WORKSPACE_LOCATION=/local_path_to_workspace
$ SCRIPT_FILE_NAME=sample.py
$ UNIT_TEST_FILE_NAME=test_sample.py
$ mkdir -p ${WORKSPACE_LOCATION}/tests
$ vim ${WORKSPACE_LOCATION}/tests/${UNIT_TEST_FILE_NAME}

Exécutez la commande suivante pour exécuter pytest sur la suite de tests :

$ docker run -it -v ~/.aws:/home/glue_user/.aws -v $WORKSPACE_LOCATION:/home/glue_user/workspace/ -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 --name glue_pytest amazon/aws-glue-libs:glue_libs_4.0.0_image_01 -c "python3 -m pytest"
starting org.apache.spark.deploy.history.HistoryServer, logging to /home/glue_user/spark/logs/spark-glue_user-org.apache.spark.deploy.history.HistoryServer-1-5168f209bd78.out
*============================================================= test session starts =============================================================
*platform linux -- Python 3.7.10, pytest-6.2.3, py-1.11.0, pluggy-0.13.1
rootdir: /home/glue_user/workspace
plugins: anyio-3.4.0
*collected 1 item  *

tests/test_sample.py . [100%]

============================================================== warnings summary ===============================================================
tests/test_sample.py::test_counts
 /home/glue_user/spark/python/pyspark/sql/context.py:79: DeprecationWarning: Deprecated in 3.0.0. Use SparkSession.builder.getOrCreate() instead.
 DeprecationWarning)

-- Docs: https://docs.pytest.org/en/stable/warnings.html
======================================================== 1 passed, *1 warning* in 21.07s ========================================================
Jupyter Lab

Vous pouvez démarrer Jupyter pour le développement interactif et les requêtes ad-hoc sur des blocs-notes.

  1. Exécutez la commande suivante pour démarrer Jupyter Lab :

    $ JUPYTER_WORKSPACE_LOCATION=/local_path_to_workspace/jupyter_workspace/
$ docker run -it -v ~/.aws:/home/glue_user/.aws -v $JUPYTER_WORKSPACE_LOCATION:/home/glue_user/workspace/jupyter_workspace/ -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 -p 8998:8998 -p 8888:8888 --name glue_jupyter_lab amazon/aws-glue-libs:glue_libs_4.0.0_image_01 /home/glue_user/jupyter/jupyter_start.sh
...
[I 2022-01-24 08:19:21.368 ServerApp] Serving notebooks from local directory: /home/glue_user/workspace/jupyter_workspace
[I 2022-01-24 08:19:21.368 ServerApp] Jupyter Server 1.13.1 is running at:
[I 2022-01-24 08:19:21.368 ServerApp] http://faa541f8f99f:8888/lab
[I 2022-01-24 08:19:21.368 ServerApp] or http://127.0.0.1:8888/lab
[I 2022-01-24 08:19:21.368 ServerApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).

  2. Ouvrez http://127.0.0.1:8888/lab dans votre navigateur Web sur votre machine locale, pour voir l'interface utilisateur de Jupyter Lab.

    L'interface utilisateur de Jupyter Lab.

  3. Choisissez Glue Spark Local (PySpark) sous Notebook. Vous pouvez commencer à développer du code dans l'interface utilisateur interactive du bloc-notes Jupyter.

    Développement du code dans le bloc-notes.

Configuration du conteneur pour utiliser Visual Studio Code

Prérequis :

  1. Installez Visual Studio Code.

  2. Installez Python.

  3. Installez Visual Studio Code Remote - Containers

  4. Ouvrez le dossier de l'espace de travail dans Visual Studio Code.

  5. Sélectionnez Settings (Paramètres).

  6. Choisissez Workspace (Espace de travail).

  7. Choisissez Ouvrir les paramètres (JSON).

  8. Collez ce qui suit JSON et enregistrez-le.

    {
    "python.defaultInterpreterPath": "/usr/bin/python3",
    "python.analysis.extraPaths": [
        "/home/glue_user/aws-glue-libs/PyGlue.zip:/home/glue_user/spark/python/lib/py4j-0.10.9.5-src.zip:/home/glue_user/spark/python/",
    ]
}

Étapes :

  1. Exécutez le conteneur Docker.

    $ docker run -it -v ~/.aws:/home/glue_user/.aws -v $WORKSPACE_LOCATION:/home/glue_user/workspace/ -e AWS_PROFILE=$PROFILE_NAME -e DISABLE_SSL=true --rm -p 4040:4040 -p 18080:18080 --name glue_pyspark amazon/aws-glue-libs:glue_libs_4.0.0_image_01 pyspark

  2. Démarrez Visual Studio Code.

  3. Choisissez Remote Explorer (Explorateur distant) dans le menu de gauche, puis amazon/aws-glue-libs:glue_libs_4.0.0_image_01.

    La bibliothèque dans Visual Studio Code.

  4. Faites un clic droit et choisissez Attach to Container (Attacher au conteneur). Si une boîte de dialogue s'affiche, choisissez Got it (J'ai compris).

  5. Ouvrir /home/glue_user/workspace/.

  6. Créez un PySpark script Glue et choisissez Run.

    Vous verrez l'exécution réussie du script.

    L'exécution réussie du script.

Annexe : AWS Glue exemple de code de tâche pour les tests

Cette annexe fournit des scripts sous la forme AWS Glue exemple de code de tâche à des fins de test.

sample.py : exemple de code pour utiliser le AWS Glue ETLbibliothèque avec un API appel Amazon S3

import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions


class GluePythonSampleTest:
    def __init__(self):
        params = []
        if '--JOB_NAME' in sys.argv:
            params.append('JOB_NAME')
        args = getResolvedOptions(sys.argv, params)

        self.context = GlueContext(SparkContext.getOrCreate())
        self.job = Job(self.context)

        if 'JOB_NAME' in args:
            jobname = args['JOB_NAME']
        else:
            jobname = "test"
        self.job.init(jobname, args)

    def run(self):
        dyf = read_json(self.context, "s3://awsglue-datasets/examples/us-legislators/all/persons.json")
        dyf.printSchema()

        self.job.commit()


def read_json(glue_context, path):
    dynamicframe = glue_context.create_dynamic_frame.from_options(
        connection_type='s3',
        connection_options={
            'paths': [path],
            'recurse': True
        },
        format='json'
    )
    return dynamicframe


if __name__ == '__main__':
    GluePythonSampleTest().run()

Le code ci-dessus nécessite des autorisations Amazon S3 pour entrer AWS IAM. Vous devez accorder la politique IAM gérée arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess ou une politique IAM personnalisée qui vous permet d'appeler ListBucket et GetObject pour le chemin Amazon S3.

test_sample.py : Exemple de code pour le test unitaire de sample.py.

import pytest
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
import sys
from src import sample


@pytest.fixture(scope="module", autouse=True)
def glue_context():
    sys.argv.append('--JOB_NAME')
    sys.argv.append('test_count')

    args = getResolvedOptions(sys.argv, ['JOB_NAME'])
    context = GlueContext(SparkContext.getOrCreate())
    job = Job(context)
    job.init(args['JOB_NAME'], args)

    yield(context)

    job.commit()


def test_counts(glue_context):
    dyf = sample.read_json(glue_context, "s3://awsglue-datasets/examples/us-legislators/all/persons.json")
    assert dyf.toDF().count() == 1961

Développement à l'aide du AWS Glue ETLbibliothèque

Le AWS Glue ETLla bibliothèque est disponible dans un compartiment Amazon S3 public et peut être utilisée par le système de compilation Apache Maven. Cela vous permet de développer et de tester vos scripts Python et Scala d'extraction, de transformation et de chargement (ETL) localement, sans avoir besoin d'une connexion réseau. Le développement local avec l’image Docker est recommandé, car il fournit un environnement correctement configuré pour l’utilisation de cette bibliothèque.

Le développement local est accessible à tous AWS Glue versions, y compris AWS Glue versions 0.9, 1.0, 2.0 et ultérieures. Pour plus d'informations sur les versions de Python et d'Apache Spark disponibles avec AWS Glue, voir leGlue version job property.

La bibliothèque est publiée avec la licence Amazon Software (https://aws.amazon.com/asl).

Restrictions relatives au développement local

Tenez compte des restrictions suivantes lors de l'utilisation du AWS Glue Bibliothèque Scala à développer localement.

Développement local avec Python

Effectuez certaines étapes préalables, puis utilisez AWS Glue utilitaires pour tester et soumettre votre ETL script Python.

Prérequis pour le développement Python local

Procédez comme suit pour préparer un développement Python local :

  1. Clonez le AWS Glue Référentiel Python depuis GitHub (https://github.com/awslabs/aws-glue-libs).

  2. Effectuez l’une des actions suivantes :

    • Dans AWS Glue version 0.9, consultez la brancheglue-0.9.

    • Dans AWS Glue versions 1.0, consultez la brancheglue-1.0. Toutes les versions ci-dessus AWS Glue La version 0.9 supporte Python 3.

    • Dans AWS Glue versions 2.0, consultez la brancheglue-2.0.

    • Dans AWS Glue versions 3.0, consultez la brancheglue-3.0.

    • Dans AWS Glue version 4.0, consultez la master branche.

  3. Installez Apache Maven à partir de l'emplacement suivant : https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-common/apache-maven-3.6.0-bin.tar.gz.

  4. Installez la distribution Apache Spark à partir d'un des emplacements suivants :

  5. Exportez la variable d'environnement SPARK_HOME, en la définissant sur l'emplacement racine extrait de l'archive Spark. Par exemple :

    • Dans AWS Glue version 0.9 : export SPARK_HOME=/home/$USER/spark-2.2.1-bin-hadoop2.7

    • Dans AWS Glue versions 1.0 et 2.0 : export SPARK_HOME=/home/$USER/spark-2.4.3-bin-spark-2.4.3-bin-hadoop2.8

    • Dans AWS Glue version 3.0 : export SPARK_HOME=/home/$USER/spark-3.1.1-amzn-0-bin-3.2.1-amzn-3

    • Dans AWS Glue version 4.0 : export SPARK_HOME=/home/$USER/spark-3.3.0-amzn-1-bin-3.3.3-amzn-0

Exécution de votre ETL script Python

Avec le plugin AWS Glue fichiers jar disponibles pour le développement local, vous pouvez exécuter AWS Glue Package Python local.

Utilisez les utilitaires et infrastructures suivants pour tester et exécuter votre script Python. Les commandes répertoriées dans le tableau suivant sont exécutées à partir du répertoire racine du AWS Glue Package Python.

Utilitaire Command Description
AWS Glue Coquille ./bin/gluepyspark Entrez et exécutez des scripts Python dans un shell qui s'intègre à AWS Glue ETLbibliothèques.
AWS Glue Soumettre ./bin/gluesparksubmit Soumettre un script Python complet pour l'exécution.
Pytest ./bin/gluepytest Écrire et exécuter des tests unitaires de votre code Python. Le module pytest doit être installé et disponible dans le PATH. Pour plus d'informations, consultez la documentation pytest.

Développement local avec Scala

Effectuez certaines étapes préalables, puis émettez une commande Maven pour exécuter votre ETL script Scala localement.

Prérequis pour le développement local Scala

Procédez comme suit pour vous préparer au développement local Scala.

Étape 1 : Installer le logiciel

Au cours de cette étape, vous installez le logiciel et définissez la variable d'environnement requise.

  1. Installez Apache Maven à partir de l'emplacement suivant : https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-common/apache-maven-3.6.0-bin.tar.gz.

  2. Installez la distribution Apache Spark à partir d'un des emplacements suivants :

  3. Exportez la variable d'environnement SPARK_HOME, en la définissant sur l'emplacement racine extrait de l'archive Spark. Par exemple :

    • Dans AWS Glue version 0.9 : export SPARK_HOME=/home/$USER/spark-2.2.1-bin-hadoop2.7

    • Dans AWS Glue versions 1.0 et 2.0 : export SPARK_HOME=/home/$USER/spark-2.4.3-bin-spark-2.4.3-bin-hadoop2.8

    • Dans AWS Glue version 3.0 : export SPARK_HOME=/home/$USER/spark-3.1.1-amzn-0-bin-3.2.1-amzn-3

    • Dans AWS Glue version 4.0 : export SPARK_HOME=/home/$USER/spark-3.3.0-amzn-1-bin-3.3.3-amzn-0

Étape 2 : Configurer votre projet Maven

Utilisez le pom.xml fichier suivant comme modèle pour votre AWS Glue Applications Scala. Il contient les éléments dependencies, repositories et plugins requis. Remplacez la chaîne Glue version par l'une des actions suivantes :

  • 4.0.0pour AWS Glue version 4.0

  • 3.0.0pour AWS Glue version 3.0

  • 1.0.0pour AWS Glue version 1.0 ou 2.0

  • 0.9.0pour AWS Glue version 0.9

  <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.amazonaws</groupId>
    <artifactId>AWSGlueApp</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>${project.artifactId}</name>
    <description>AWS ETL application</description>

        <properties>
            <scala.version>2.11.1 for AWS Glue 2.0 or below, 2.12.7 for AWS Glue 3.0 and 4.0</scala.version>
            <glue.version>Glue version with three numbers (as mentioned earlier)</glue.version>
        </properties>
    <dependencies>
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
			<!-- A "provided" dependency, this will be ignored when you package your application -->
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>AWSGlueETL</artifactId>
			<version>${glue.version}</version>
            <!-- A "provided" dependency, this will be ignored when you package your application -->
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <repositories>
        <repository>
            <id>aws-glue-etl-artifacts</id>
            <url>https://aws-glue-etl-artifacts.s3.amazonaws.com/release/</url>
        </repository>
    </repositories>
    <build>
        <sourceDirectory>src/main/scala</sourceDirectory>
        <plugins>
            <plugin>
                <!-- see http://davidb.github.com/scala-maven-plugin -->
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.4.0</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.6.0</version>
                <executions>
                    <execution>
                        <goals>
                        <goal>java</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                <systemProperties>
                    <systemProperty>
                        <key>spark.master</key>
                        <value>local[*]</value>
                    </systemProperty>
                    <systemProperty>
                        <key>spark.app.name</key>
                        <value>localrun</value>
                    </systemProperty>
                    <systemProperty>
                        <key>org.xerial.snappy.lib.name</key>
                        <value>libsnappyjava.jnilib</value>
                    </systemProperty>
                </systemProperties>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-enforcer-plugin</artifactId>
                <version>3.0.0-M2</version>
                <executions>
                    <execution>
                        <id>enforce-maven</id>
                        <goals>
                            <goal>enforce</goal>
                        </goals>
                        <configuration>
                            <rules>
                                <requireMavenVersion>
                                    <version>3.5.3</version>
                                </requireMavenVersion>
                            </rules>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
			<!-- The shade plugin will be helpful in building a uberjar or fatjar.
			You can use this jar in the AWS Glue runtime environment. For more information, see https://maven.apache.org/plugins/maven-shade-plugin/ -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.4</version>
                <configuration>
                    <!-- any other shade configurations -->
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Exécution de votre script Scala ETL

Exécutez la commande suivante depuis le répertoire racine du projet Maven pour exécuter votre script ScalaETL.

mvn exec:java -Dexec.mainClass="mainClass" -Dexec.args="--JOB-NAME jobName"

Remplacez mainClass avec le nom de classe complet de la classe principale du script. Remplacez jobName avec le nom de tâche souhaité.

Configuration d'un environnement de test

Pour des exemples de configuration d'un environnement de test local, consultez les articles de blog suivants :

Si vous souhaitez utiliser des terminaux de développement ou des blocs-notes pour tester vos ETL scripts, consultez. Développement de scripts à l'aide de points de terminaison de développement

Note

Les points de terminaison de développement ne sont pas pris en charge pour une utilisation avec AWS Glue jobs en version 2.0. Pour plus d'informations, consultez Exécution de ETL tâches Spark avec des temps de démarrage réduits.