Desarrollo y prueba de scripts de trabajos de AWS Glue a nivel local - AWS Glue
Desarrollo mediante AWS Glue StudioDesarrollo mediante sesiones interactivasDesarrollo mediante una imagen de DockerDesarrollo mediante la biblioteca de ETL de AWS Glue

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Desarrollo y prueba de scripts de trabajos de AWS Glue a nivel local

Cuando desarrolle y pruebe sus scripts de trabajo Spark de AWS Glue, hay varias opciones disponibles:

  • Consola de AWS Glue Studio

    • Visual editor (Editor visual)

    • Editor de scripts

    • Cuaderno de AWS Glue Studio

  • Sesiones interactivas

    • Cuadernos de Jupyter

  • imagen de Docker

    • Desarrollo local

    • Desarrollo remoto

  • Biblioteca de ETL AWS Glue Studio

    • Desarrollo local

Puede elegir cualquiera de las opciones anteriores en función de sus requisitos.

Si prefiere no tener código o menos experiencia en código, el editor visual de AWS Glue Studio es una buena opción.

Si prefiere una experiencia de cuaderno interactiva, el cuaderno de AWS Glue Studio es una buena opción. Para obtener más información, consulte Uso de los cuadernos con AWS Glue Studio y AWS Glue. Si desea utilizar su propio entorno local, las sesiones interactivas son una buena opción. Para obtener más información, consulte Uso de sesiones interactivas con AWS Glue.

Si prefiere la experiencia de desarrollo local o remoto, la imagen de Docker es una buena opción. Esto le ayuda a desarrollar y probar el script de trabajo Spark de AWS Glue en cualquier lugar que prefiera sin tener que incurrir en costos de AWS Glue.

Si prefiere el desarrollo local sin Docker, instalar el directorio de bibliotecas ETL de AWS Glue en forma local es una buena opción.

Desarrollo mediante AWS Glue Studio

El editor visual AWS Glue Studio es una interfaz gráfica que facilita la creación, ejecución y supervisión de los trabajos de extracción, transformación y carga (ETL) en AWS Glue. Puede componer visualmente flujos de trabajo de transformación de datos y ejecutarlos sin problemas en el motor de ETL sin servidor basado en Apache Spark de AWS Glue. Puede inspeccionar los resultados de esquema y datos en cada paso del trabajo. Para más información, consulte la Guía del usuario de AWS Glue Studio.

Desarrollo mediante sesiones interactivas

Las sesiones interactivas le permiten crear y probar aplicaciones desde el entorno que elija. Para obtener más información, consulte Uso de sesiones interactivas con AWS Glue.

Desarrollo mediante una imagen de Docker

nota

No se han realizado pruebas de las instrucciones de esta sección en los sistemas operativos Microsoft Windows.

Para el desarrollo local y las pruebas en plataformas Windows, consulte el blog Building an AWS Glue ETL pipeline locally without an AWS account (Creación de una canalización de ETL de AWS Glue en forma local sin una cuenta AWS).

Para una plataforma de datos lista para producción, el proceso de desarrollo y la canalización de CI/CD para trabajos de AWS Glue es un tema clave. Puede desarrollar y probar trabajos de AWS Glue de manera flexible en un contenedor de Docker. AWS Glue aloja las imágenes de Docker en Docker Hub para configurar el entorno de desarrollo con utilidades adicionales. Puede utilizar su IDE, cuaderno o REPL preferidos mediante la biblioteca de ETL de AWS Glue. En este tema, se describe cómo desarrollar y probar trabajos de versión 4.0 AWS Glue en un contenedor de Docker mediante la utilización de una imagen de Docker.

Las siguientes imágenes de Docker están disponibles para AWS Glue en Docker Hub.

  • Para la versión 4.0 AWS Glue: amazon/aws-glue-libs:glue_libs_4.0.0_image_01

  • Para la versión 3.0 de AWS Glue: amazon/aws-glue-libs:glue_libs_3.0.0_image_01

  • Para la versión 2.0 de AWS Glue: amazon/aws-glue-libs:glue_libs_2.0.0_image_01

Estas imágenes son para x86_64. Se recomienda realizar pruebas en esta arquitectura. Sin embargo, es posible rediseñar una solución de desarrollo local a partir de imágenes base no compatibles.

Este ejemplo describe el uso de amazon/aws-glue-libs:glue_libs_4.0.0_image_01 y la ejecución del contenedor en un equipo local. Esta imagen de contenedor ha sido probada para trabajos de versión 3.3 de Spark de AWS Glue. Esta imagen contiene lo siguiente:

  • Amazon Linux

  • Biblioteca de ETL de AWS Glue (aws-glue-libs)

  • Apache Spark 3.3.0

  • Servidor de historial de Spark

  • Laboratorio de Jupyter

  • Livy

  • Otras dependencias de biblioteca (el mismo conjunto que las del sistema de trabajo de AWS Glue)

Complete una de las siguientes secciones de acuerdo con sus requisitos:

  • Configurar el contenedor para usar spark-submit

  • Configurar el contenedor para usar el intérprete de comandos REPL (PySpark)

  • Configurar el contenedor para utilizar Pytest

  • Configurar el contenedor para usar Jupyter Lab

  • Configurar el contenedor para utilizar Visual Studio Code

Requisitos previos

Antes de empezar, asegúrese de que Docker esté instalado y que el daemon Docker se esté ejecutando. Para ver las instrucciones de instalación, consulte la documentación de Docker para Mac o Linux. La máquina que ejecuta Docker aloja el contenedor de AWS Glue. Asegúrese también de tener al menos 7 GB de espacio en disco para la imagen del host que ejecuta Docker.

Para obtener más información sobre las restricciones en el momento de desarollar el código AWS Glue en forma local, consulte Restricciones de desarrollo local.

Configuración de AWS

Para habilitar llamadas a la API de AWS desde el contenedor, configure las credenciales de AWS siguiendo estos pasos. En las siguientes secciones, utilizaremos este perfil con nombre AWS.

  1. Configure la AWS CLI, con un perfil con nombre. Para obtener más información sobre la configuración de AWS CLI, consulte Opciones de los archivos de configuración y credenciales en la documentación de AWS CLI.

  2. Ejecute el siguiente comando en un terminal:

    PROFILE_NAME="<your_profile_name>"

Es posible que también necesite configurar la variable de entorno AWS_REGION para especificar la Región de AWS a la cual se enviarán las solicitudes.

Configuración y ejecución del contenedor

La configuración del contenedor para que ejecute el código de PySpark a través del comando spark-submit incluye los siguientes pasos de alto nivel:

  1. Para extraer la imagen de Docker Hub.

  2. Ejecute el contenedor.

Extracción de la imagen desde Docker Hub

Ejecute el siguiente comando para extraer la imagen del Docker Hub:

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

Ejecución del contenedor

Ahora puede ejecutar un contenedor mediante esta imagen. Puede elegir cualquiera de los siguientes según sus requisitos.

spark-submit

Puede ejecutar un script de trabajo de AWS Glue ejecutando el comando spark-submit en el contenedor.

  1. Escriba el script y guárdelo como sample1.py en el directorio /local_path_to_workspace. El código de muestra se incluye como apéndice de este tema.

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

  2. Ejecute el siguiente comando para ejecutar el comando spark-submit en el contenedor para enviar una nueva aplicación 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. (Opcionalmente) Configure spark-submit para que se adapte a su entorno. Por ejemplo, puede transferir sus dependencias con la configuración de --jars. Para obtener más información, consulte Launching Applications with spark-submit en la documentación de Spark.

Intérprete de comandos REPL (Pyspark)

Puede ejecutar el intérprete de comandos REPL (bucles de read-eval-print) para desarrollo interactivo.

Ejecute el siguiente comando para ejecutar el comando PySpark en el contenedor e iniciar el intérprete de comandos 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

Para pruebas de unidad, puede utilizar pytest para scripts de trabajo Spark de AWS Glue.

Ejecute los comandos siguientes para la preparación.

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

Ejecute el siguiente comando para ejecutar pytest en el conjunto de pruebas:

$ 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 ========================================================
Laboratorio de Jupyter

Puede iniciar Jupyter para desarrollo interactivo y consultas ad hoc en los cuadernos.

  1. Ejecute el siguiente comando para iniciar 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. Abra http://127.0.0.1:8888/lab en el navegador web de su máquina local para ver la interfaz de usuario de Jupyter lab.

    La interfaz de usuario de Jupyter Lab.

  3. Elija Glue Spark Local (PySpark) en Notebook (Cuaderno). Puede comenzar a desarrollar el código en la interfaz de usuario interactiva del cuaderno de Jupyter.

    Desarrollo de código en el cuaderno.

Configuración del contenedor para utilizar Visual Studio Code

Requisitos previos:

  1. Instale Visual Studio Code.

  2. Instalación de Python.

  3. Instalar Visual Studio Code Remote: contenedores

  4. Abra la carpeta de WorkSpace en Visual Studio Code.

  5. Elija Configuraciones.

  6. Elija WorkSpace.

  7. Elija Abrir Settings (JSON) (Abrir configuración).

  8. Pegue el siguiente JSON y guárdelo.

    {
    "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-src.zip:/home/glue_user/spark/python/",
    ]
}

Pasos:

  1. Ejecute el contenedor 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. Inicie Visual Studio Code.

  3. Elija Remote Explorer (Explorador remoto) en el menú de la izquierda y elija amazon/aws-glue-libs:glue_libs_4.0.0_image_01.

    La biblioteca de Visual Studio Code.

  4. Haga clic con el botón derecho y elija Attach to Container (Adjuntar al contenedor). Si aparece un cuadro de diálogo, elija Got it (Entendido).

  5. Abrir /home/glue_user/workspace/.

  6. Cree un script de Glue PySpark y elija Run (Ejecutar).

    Verá la ejecución correcta del script.

    La ejecución correcta del script.

Apéndice: código de muestra de trabajo de AWS Glue para pruebas

Este apéndice proporciona scripts como código de muestra de trabajo de AWS Glue para fines de prueba.

sample.py: código de muestra para utilizar la biblioteca de ETL de AWS Glue con una llamada a la API de 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()

El código anterior requiere permisos de Amazon S3 en IAM de AWS. Debe conceder la política administrada de IAM de arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess o una política personalizada de IAM que le permite llamar a ListBucket y GetObject para la ruta de Amazon S3.

test_sample.py: Código de muestra para la prueba de unidad 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

Desarrollo mediante la biblioteca de ETL de AWS Glue

La biblioteca ETL de AWS Glue se encuentra disponible en un bucket público de Amazon S3, y puede utilizarla el sistema de compilación Apache Maven. Esto le permite desarrollar y probar localmente sus scripts de extracción, transformación y carga (ETL) de Python y Scala, sin necesidad de una conexión de red. Se recomienda el desarrollo local con la imagen de Docker, ya que proporciona un entorno correctamente configurado para el uso de esta biblioteca.

El desarrollo local se encuentra disponible para todas las versiones de AWS Glue, incluso las versiones 0.9, 1.0, 2.0 y posteriores de AWS Glue. Para obtener información acerca de las versiones de Python y Apache Spark que están disponibles con AWS Glue, consulte la Glue version job property.

La biblioteca es accesible entrega con la licencia de software de Amazon (https://aws.amazon.com/asl).

Restricciones de desarrollo local

Tenga en cuenta las siguientes restricciones al utilizar la biblioteca Scala de AWS Glue para desarrollar localmente.

Desarrollo a nivel local con Python

Complete algunos pasos de requisitos previos y, a continuación, use las utilidades de AWS Glue para probar y enviar el script de ETL de Python.

Requisitos previos para el desarrollo local de Python

Complete estos pasos para prepararse para el desarrollo local de Python:

  1. Clonar el repositorio de AWS Glue Python desde GitHub (https://github.com/awslabs/aws-glue-libs).

  2. Lleve a cabo una de las siguientes acciones:

    • Para la versión 0.9 de AWS Glue, consulte la ramificación glue-0.9.

    • Para las versiones 1.0 de AWS Glue, consulte la ramificación glue-1.0. Todas las versiones de AWS Glue posteriores a 0.9 admiten Python 3.

    • Para las versiones 2.0 de AWS Glue, consulte la ramificación glue-2.0.

    • Para las versiones 3.0 de AWS Glue, consulte la ramificación glue-3.0.

    • Para la versión 4.0 de AWS Glue, consulte la ramificación master.

  3. Instale Apache Maven desde la siguiente ubicación: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-common/apache-maven-3.6.0-bin.tar.gz.

  4. Instale la distribución de Apache Spark desde una de las siguientes ubicaciones:

  5. Exporte la variable de entorno SPARK_HOME, estableciéndola en la ubicación raíz extraída del archivo Spark. Por ejemplo:

    • Para la versión 0.9 de AWS Glue: export SPARK_HOME=/home/$USER/spark-2.2.1-bin-hadoop2.7

    • Para las versiones 1.0 y 2.0 de AWS Glue: export SPARK_HOME=/home/$USER/spark-2.4.3-bin-spark-2.4.3-bin-hadoop2.8

    • Para la versión 3.0 de AWS Glue: export SPARK_HOME=/home/$USER/spark-3.1.1-amzn-0-bin-3.2.1-amzn-3

    • Para la versión 4.0 AWS Glue: export SPARK_HOME=/home/$USER/spark-3.3.0-amzn-1-bin-3.3.3-amzn-0

Ejecución del script de ETL de Python

Con los archivos jar de AWS Glue disponibles para desarrollo local, puede ejecutar localmente el paquete AWS Glue Python.

Utilice las siguientes utilidades y marcos de trabajo para probar y ejecutar el script de Python. Los comandos enumerados en la siguiente tabla se ejecutan desde el directorio raíz del paquete AWS Glue Python.

Utilidad Comando Descripción
Intérprete de comandos de AWS Glue ./bin/gluepyspark Escribe y ejecuta scripts de Python en un intérprete de comandos que se integra con bibliotecas de ETL de AWS Glue.
AWS Glue Submit (Enviar). ./bin/gluesparksubmit Envía un script de Python completo para su ejecución.
Pytest ./bin/gluepytest Escribe y ejecuta pruebas unitarias de su código Python. El módulo pytest debe estar instalado y disponible en PATH. Para obtener más información, consulte la documentación de pytest.

Desarrollo a nivel local con Scala

Complete algunos pasos de requisitos de previos y, a continuación, emita un comando Maven para ejecutar localmente el script de ETL de Scala.

Requisitos previos para el desarrollo local de Scala

Complete estos pasos a fin de prepararse para el desarrollo local de Scala.

Paso 1: Instalar el software

En este paso, instalará el software y establecerá la variable de entorno necesaria.

  1. Instale Apache Maven desde la siguiente ubicación: https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-common/apache-maven-3.6.0-bin.tar.gz.

  2. Instale la distribución de Apache Spark desde una de las siguientes ubicaciones:

  3. Exporte la variable de entorno SPARK_HOME, estableciéndola en la ubicación raíz extraída del archivo Spark. Por ejemplo:

    • Para la versión 0.9 de AWS Glue: export SPARK_HOME=/home/$USER/spark-2.2.1-bin-hadoop2.7

    • Para las versiones 1.0 y 2.0 de AWS Glue: export SPARK_HOME=/home/$USER/spark-2.4.3-bin-spark-2.4.3-bin-hadoop2.8

    • Para la versión 3.0 de AWS Glue: export SPARK_HOME=/home/$USER/spark-3.1.1-amzn-0-bin-3.2.1-amzn-3

    • Para la versión 4.0 AWS Glue: export SPARK_HOME=/home/$USER/spark-3.3.0-amzn-1-bin-3.3.3-amzn-0

Paso 2: Configurar su proyecto de Maven

Utilice el siguiente archivo pom.xml como plantilla para sus aplicaciones de Scala de AWS Glue. Contiene los elementos dependencies, repositories y plugins necesarios. Reemplace la cadena de Glue version por uno de los siguientes valores:

  • 4.0.0 para la versión 4.0 de AWS Glue

  • Para la versión 3.0 de AWS Glue: 3.0.0

  • Para las versiones 1.0 y 2.0 de AWS Glue: 1.0.0

  • Para la versión 0.9 de AWS Glue: 0.9.0

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

Ejecución del script de ETL de Scala

Ejecute el siguiente comando desde el directorio raíz del proyecto Maven para ejecutar el script de ETL de Scala.

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

Sustituya mainClass por el nombre de clase completo de la clase principal del script. Sustituya jobName por el nombre de trabajo que desee.

Configuración de un entorno de pruebas

Para obtener ejemplos acerca de cómo configurar un entorno local de pruebas, consulte los siguientes artículos de blog:

Si desea utilizar puntos de enlace de desarrollo o cuaderno para probar sus scripts ETL, consulte Desarrollo de scripts usando puntos de conexión de desarrollo.

nota

Los trabajos de la versión 2.0 de AWS Glue no soportan el uso de puntos de enlace desarrollo. Para obtener más información, consulte Ejecución de trabajos de ETL de Spark con tiempos de inicio reducidos.