Sviluppo e test degli script di lavoro AWS Glue a livello locale - AWS Glue
Sviluppo con AWS Glue StudioSviluppo tramite le sessioni interattiveSviluppo tramite un'immagine DockerSviluppo utilizzando la libreria AWS Glue ETL

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Sviluppo e test degli script di lavoro AWS Glue a livello locale

Quando sviluppi e testi gli script di lavoro di AWS Glue for Spark, sono disponibili diverse opzioni:

  • AWS Console Glue Studio

    • Visual editor (Editor visivo)

    • Editor di script

    • AWS Taccuino Glue Studio

  • Sessioni interattive

    • Jupyter Notebook

  • immagine Docker

    • Sviluppo locale

    • Sviluppo remoto

  • AWS Libreria ETL Glue Studio

    • Sviluppo locale

Puoi scegliere una delle opzioni sopra elencate in base alle tue esigenze.

Se preferisci l'assenza di codice o una minore esperienza di programmazione, l'editor visivo di AWS Glue Studio è una buona scelta.

Se preferisci un'esperienza di notebook interattiva, il notebook AWS Glue Studio è una buona scelta. Per ulteriori informazioni, vedere Uso dei notebook con Glue Studio e AWS Glue. AWS Se desideri utilizzare il tuo ambiente locale, le sessioni interattive sono un'ottima scelta. Per ulteriori informazioni, consulta Utilizzo di sessioni interattive con AWS Glue.

Se preferisci un'esperienza di sviluppo locale/remoto, l'immagine Docker è un'ottima scelta. Questo ti aiuta a sviluppare e testare gli script di lavoro di AWS Glue for Spark ovunque preferisci senza incorrere nei costi di Glue AWS .

Se preferisci lo sviluppo locale senza Docker, installare localmente la directory della libreria AWS Glue ETL è una buona scelta.

Sviluppo con AWS Glue Studio

L'editor visivo di AWS Glue Studio è un'interfaccia grafica che semplifica la creazione, l'esecuzione e il monitoraggio di lavori di estrazione, trasformazione e caricamento (ETL) in AWS Glue. Puoi comporre visivamente flussi di lavoro di trasformazione dei dati ed eseguirli senza problemi sul motore ETL serverless basato su Apache AWS Spark di Glue. È possibile esaminare lo schema e i risultati dei dati in ogni fase del processo. Per ulteriori informazioni, consulta la Guida per l'utente di AWS Glue Studio.

Sviluppo tramite le sessioni interattive

Le sessioni interattive consentono di creare e testare le applicazioni dall'ambiente che preferisci. Per ulteriori informazioni, consulta Utilizzo di sessioni interattive con AWS Glue.

Sviluppo tramite un'immagine Docker

Nota

Le istruzioni contenute in questa sezione non sono state testate sui sistemi operativi Microsoft Windows.

Per lo sviluppo e il test locali su piattaforme Windows, consulta il blog Building an AWS Glue ETL pipeline localmente senza un account AWS

Per una piattaforma dati pronta per la produzione, il processo di sviluppo e la pipeline CI/CD per i lavori AWS Glue sono un argomento chiave. Puoi sviluppare e testare in modo flessibile i lavori AWS Glue in un contenitore Docker. AWS Glue ospita immagini Docker su Docker Hub per configurare l'ambiente di sviluppo con utilità aggiuntive. Puoi usare il tuo IDE, notebook o REPL preferito utilizzando la libreria AWS Glue ETL. Questo argomento descrive come sviluppare e testare i job AWS Glue versione 4.0 in un contenitore Docker utilizzando un'immagine Docker.

Le seguenti immagini Docker sono disponibili per AWS Glue on Docker Hub.

  • Per la versione 4.0 di AWS Glue: amazon/aws-glue-libs:glue_libs_4.0.0_image_01

  • Per la versione 3.0 di AWS Glue: amazon/aws-glue-libs:glue_libs_3.0.0_image_01

  • Per la versione 2.0 di AWS Glue: amazon/aws-glue-libs:glue_libs_2.0.0_image_01

Queste immagini sono per x86_64. Si consiglia di eseguire il test su questa architettura. Tuttavia, potrebbe essere possibile rielaborare una soluzione di sviluppo locale su immagini di base non supportate.

In questo esempio viene descritto l'utilizzo di amazon/aws-glue-libs:glue_libs_4.0.0_image_01 e l'esecuzione del container su un computer locale. Questa immagine del contenitore è stata testata per i job Spark della versione 3.3 di AWS Glue. Questa immagine contiene quanto segue:

  • Amazon Linux

  • AWS Libreria ETL Glue () aws-glue-libs

  • Apache Spark 3.3.0

  • Spark History Server

  • Jupyter Lab

  • Livy

  • Altre dipendenze della libreria (lo stesso set di quelle del sistema di lavoro AWS Glue)

Completa una delle seguenti sezioni in base alle tue esigenze:

  • Configurazione del container per l'utilizzo di spark-submit

  • Imposta il contenitore per utilizzare la shell REPL () PySpark

  • Configurazione del container per l'utilizzo di Pytest

  • Configurazione del container per l'utilizzo di Jupyter Lab

  • Configurazione del container per l'utilizzo di Visual Studio Code

Prerequisiti

Prima di iniziare, verifica che Docker sia installato e che il daemon Docker sia in esecuzione. Per istruzioni sull'installazione, consulta la documentazione Docker per Mac o Linux. La macchina che esegue Docker ospita il contenitore AWS Glue. Inoltre, verifica di avere almeno 7 GB di spazio su disco per l'immagine sull'host su cui è in esecuzione Docker.

Per ulteriori informazioni sulle restrizioni relative allo sviluppo locale del codice AWS Glue, consulta Restrizioni allo sviluppo locale.

Configurazione AWS

Per abilitare le chiamate AWS API dal contenitore, configura AWS le credenziali seguendo i passaggi seguenti. Nelle sezioni seguenti, utilizzeremo questo profilo AWS denominato.

  1. Configura la AWS CLI, configurando un profilo denominato. Per ulteriori informazioni sulla AWS CLI configurazione, consulta Configurazione e impostazioni dei file di credenziali nella documentazione. AWS CLI

  2. Esegui il comando seguente in un terminale:

    PROFILE_NAME="<your_profile_name>"

Potrebbe anche essere necessario impostare la variabile di AWS_REGION ambiente per specificare a chi Regione AWS inviare le richieste.

Configurazione ed esecuzione del container

La configurazione del contenitore per l'esecuzione del PySpark codice tramite il comando spark-submit include i seguenti passaggi di alto livello:

  1. Estrarre l'immagine da Docker Hub.

  2. Eseguire il container.

Estrazione dell'immagine da Docker Hub

Esegui il comando seguente per estrarre l'immagine da Docker Hub:

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

Esecuzione del container

Ora puoi eseguire un container utilizzando questa immagine. Puoi scegliere una delle opzioni seguenti in base alle tue esigenze.

spark-submit

È possibile eseguire uno script di lavoro AWS Glue eseguendo il spark-submit comando sul contenitore.

  1. Scrivi lo script e salvalo come sample1.py nella directory /local_path_to_workspace. Il codice di esempio è incluso come appendice in questo argomento.

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

  2. Esegui il comando seguente per eseguire il comando spark-submit sul container per inviare una nuova applicazione 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. (Facoltativo) Configura spark-submit in modo che corrisponda all'ambiente in uso. Ad esempio, puoi trasferire le dipendenze con la configurazione --jars. Per ulteriori informazioni, consulta Dynamically Loading Spark Properties nella documentazione di Spark.

Shell REPL (Pyspark)

Puoi eseguire la shell REPL (read-eval-print loops) per lo sviluppo interattivo.

Esegui il comando seguente per eseguire il PySpark comando sul contenitore per avviare la shell REPL:

$ 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

Per i test unitari, puoi usare pytest per gli script di lavoro di AWS Glue Spark.

Esegui i comandi seguenti per la preparazione.

$ 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}

Esegui il comando seguente per eseguire pytest nella suite di test:

$ 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

Puoi avviare Jupyter per lo sviluppo interattivo e le query ad hoc sui notebook.

  1. Esegui il comando seguente per avviare 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. Apri http://127.0.0.1:8888/lab nel browser web del tuo computer locale, per visualizzare l'interfaccia utente di Jupyter lab.

    L'interfaccia utente di Jupyter Lab.

  3. Scegliete Glue Spark Local (PySpark) sotto Notebook. Puoi iniziare a sviluppare codice nell'interfaccia utente interattiva del notebook Jupyter.

    Sviluppare il codice nel notebook.

Configurazione del container per l'utilizzo di Visual Studio Code

Prerequisiti:

  1. Installare Visual Studio Code.

  2. Installare Python.

  3. Installare Visual Studio Code Remote - Containers (Visual Studio Code Remote - Container)

  4. Aprire la cartella del WorkSpace in Visual Studio Code.

  5. Selezionare Settings (Impostazioni).

  6. Scegliere WorkSpace.

  7. Scegliere Open Settings (JSON) (Apri impostazioni [JSON]).

  8. Incollare il seguente codice JSON e salvarlo.

    {
    "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/",
    ]
}

Fasi:

  1. Eseguire il container 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. Avviare Visual Studio Code.

  3. Scegliere Remote Explorer nel menu a sinistra, quindi amazon/aws-glue-libs:glue_libs_4.0.0_image_01.

    La libreria in Visual Studio Code.

  4. Cliccare con il tasto destro e scegliere Attach to Container (Allega al container). Se viene visualizzata una finestra di dialogo, scegliere Got it (Fatto).

  5. Aprire /home/glue_user/workspace/.

  6. Crea uno PySpark script Glue e scegli Esegui.

    Visualizzerai l'esecuzione corretta dello script.

    L'esecuzione corretta dello script.

Appendice: Codice di esempio di AWS Glue Job per il test

Questa appendice fornisce script come codice di esempio di AWS Glue job a scopo di test.

sample.py: codice di esempio per utilizzare la libreria AWS Glue ETL con una chiamata API 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()

Il codice precedente richiede le autorizzazioni Amazon S3 in IAM. AWS È necessario concedere la policy gestita da IAM arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess o una policy personalizzata IAM che consente di chiamare ListBucket e GetObject per il percorso Amazon S3.

test_sample.py: codice di esempio per l'unit test di 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

Sviluppo utilizzando la libreria AWS Glue ETL

La libreria AWS Glue ETL è disponibile in un bucket Amazon S3 pubblico e può essere utilizzata dal sistema di build Apache Maven. Questo consente di sviluppare e testare gli script di estrazione, trasformazione e caricamento (ETL) Python e Scala in locale, senza la necessità di una connessione di rete. Consigliamo lo sviluppo locale con l'immagine Docker, in quanto fornisce un ambiente correttamente configurato per l'uso di questa libreria.

Lo sviluppo locale è disponibile per tutte le AWS versioni di AWS Glue, inclusa la versione 0.9, 1.0, 2.0 e successive. Per informazioni sulle versioni di Python e Apache Spark disponibili con AWS Glue, consulta la. Glue version job property

La libreria viene rilasciata con la licenza software Amazon (https://aws.amazon.com/asl).

Limitazioni di sviluppo locali

Tieni a mente le seguenti restrizioni quando usi la libreria AWS Glue Scala per sviluppare localmente.

Sviluppo in locale con Python

Completa alcuni passaggi preliminari e poi usa le utilità AWS Glue per testare e inviare lo script ETL in Python.

Prerequisiti per lo sviluppo in locale con Python

Completa queste fasi per preparare allo sviluppo di Python locale:

  1. Clona il repository AWS GitHub Glue Python da (). https://github.com/awslabs/aws-glue-libs

  2. Esegui una di queste operazioni:

    • Per la versione 0.9 di AWS Glue, dai un'occhiata a branchglue-0.9.

    • Per le versioni 1.0 di AWS Glue, dai un'occhiata a branchglue-1.0. Tutte le versioni precedenti a AWS Glue 0.9 supportano Python 3.

    • Per le versioni 2.0 di AWS Glue, dai un'occhiata a branchglue-2.0.

    • Per le versioni 3.0 di AWS Glue, dai un'occhiata a branchglue-3.0.

    • Per la versione 4.0 di AWS Glue, dai un'occhiata al master ramo.

  3. Installa Apache Maven dal seguente percorso: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-common/apache-maven-3.6.0-bin.tar.gz.

  4. Installa la distribuzione Apache Spark da uno dei seguenti percorsi:

  5. Esporta la variabile di ambiente SPARK_HOME impostandola sulla posizione della radice estratta dall'archivio Spark. Per esempio:

    • Per la versione 0.9 di AWS Glue: export SPARK_HOME=/home/$USER/spark-2.2.1-bin-hadoop2.7

    • Per le versioni 1.0 e 2.0 di AWS Glue: export SPARK_HOME=/home/$USER/spark-2.4.3-bin-spark-2.4.3-bin-hadoop2.8

    • Per la versione 3.0 di AWS Glue: export SPARK_HOME=/home/$USER/spark-3.1.1-amzn-0-bin-3.2.1-amzn-3

    • Per la versione 4.0 di AWS Glue: export SPARK_HOME=/home/$USER/spark-3.3.0-amzn-1-bin-3.3.3-amzn-0

Esecuzione dello script ETL Python

Con i file jar AWS Glue disponibili per lo sviluppo locale, puoi eseguire il pacchetto AWS Glue Python localmente.

Utilizza le seguenti utilità e framework per testare ed eseguire lo script Python. I comandi elencati nella tabella seguente vengono eseguiti dalla directory root del pacchetto AWS Glue Python.

Utility Comando Descrizione
AWS Glue Shell ./bin/gluepyspark Inserisci ed esegui script Python in una shell che si integra con le librerie ETL AWS Glue.
AWS Glue Invia ./bin/gluesparksubmit Invia uno script Python completo per l'esecuzione.
Pytest ./bin/gluepytest Scrivi ed esegui unit test del codice Python. Il modulo pytest deve essere installato e disponibile in PATH. Per ulteriori informazioni, consulta la documentazione del pytest.

Sviluppo in locale con Scala

Completa alcune fasi preliminari, quindi emetti un comando Maven per eseguire lo script ETL Scala in locale.

Prerequisiti per lo sviluppo in locale con Scala

Completa queste fasi per la preparazione allo sviluppo Scala locale.

Fase 1: installare il software

In questa fase devi installare il software e impostare la variabile di ambiente richiesta.

  1. Installa Apache Maven dal seguente percorso: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-common/apache-maven-3.6.0-bin.tar.gz.

  2. Installa la distribuzione Apache Spark da uno dei seguenti percorsi:

  3. Esporta la variabile di ambiente SPARK_HOME impostandola sulla posizione della radice estratta dall'archivio Spark. Per esempio:

    • Per la versione 0.9 di AWS Glue: export SPARK_HOME=/home/$USER/spark-2.2.1-bin-hadoop2.7

    • Per le versioni 1.0 e 2.0 di AWS Glue: export SPARK_HOME=/home/$USER/spark-2.4.3-bin-spark-2.4.3-bin-hadoop2.8

    • Per la versione 3.0 di AWS Glue: export SPARK_HOME=/home/$USER/spark-3.1.1-amzn-0-bin-3.2.1-amzn-3

    • Per la versione 4.0 di AWS Glue: export SPARK_HOME=/home/$USER/spark-3.3.0-amzn-1-bin-3.3.3-amzn-0

Fase 2: configurare il progetto Maven

Utilizza il file pom.xml seguente come un modello per le applicazioni Scala AWS Glue. Contiene gli elementi obbligatori plugins, dependencies e repositories. Sostituisci la stringa Glue version con uno dei seguenti:

  • 4.0.0per AWS Glue versione 4.0

  • 3.0.0per AWS Glue versione 3.0

  • 1.0.0per AWS Glue versione 1.0 o 2.0

  • 0.9.0per AWS Glue versione 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>

Esecuzione dello script ETL Scala

Esegui il comando seguente dalla directory root del progetto Maven per eseguire lo script ETL Scala.

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

Sostituisci mainClass con il nome completo della classe principale dello script. Sostituisci jobName con il nome del lavoro desiderato.

Configurazione di un ambiente di test

Per esempi di configurazione di un ambiente di test locale, consulta i seguenti articoli del blog:

Per utilizzare endpoint di sviluppo o notebook per testare gli script ETL, consulta Utilizzo di endpoint per lo sviluppo di script.

Nota

Gli endpoint di sviluppo non sono supportati per l'uso con i job di AWS Glue versione 2.0. Per ulteriori informazioni, consulta Esecuzione di processi ETL Spark con tempi di avvio ridotti.