Desarrollar y probar AWS Glue 5.0 Jobs localmente utilizando un contenedor Docker

AWS Glue es un servicio de integración de datos sin servidor que le permite procesar e integrar datos que se realizan a través de diferentes fuentes de datos a escalera. AWS Glue 5.0, la última lectura de AWS Glue for Apache Spark Jobs, proporciona una experiencia de tiempo de ejecución Apache 3.5 optimizada para el rendimiento para el procesamiento de lotes y transmisiones. Con AWS Glue 5.0, obtienes un rendimiento mejorado, decano seguridad, soporte para la próxima engendramiento de Amazon Sagemakery más. AWS Glue 5.0 le permite desarrollar, ejecutar y progresar sus cargas de trabajo de integración de datos y obtener información más rápido.

AWS Glue acomoda varias preferencias de progreso a través de múltiples enfoques de creación de empleo. Para los desarrolladores que prefieren la codificación directa, el progreso de Python o Scala está arreglado utilizando la Biblioteca AWS Glue ETL.

La creación de plataformas de datos listas para la producción requiere procesos de progreso sólidos y tuberías continuas de integración y entrega (CI/CD). Para apoyar diversas evacuación de progreso, ya sea en máquinas locales, Docker Containers on Aglomeración de cuenta elástica de Amazon (Amazon EC2) u otros entornos: AWS proporciona una imagen oficial de AWS Glue Docker a través del Museo pública de Amazon ECR. La imagen permite a los desarrolladores trabajar de forma capaz en su entorno preferido mientras usan la biblioteca AWS Glue ETL.

En esta publicación, mostramos cómo desarrollar y probar los trabajos de AWS Glue 5.0 localmente usando un contenedor Docker. Esta publicación es una lectura actualizada de la publicación. Desarrollar y probar los trabajos de AWS Glue lectura 3.0 y 4.0 localmente utilizando un contenedor Dockery usa AWS Glue 5.0.

Imágenes de Docker disponibles

Las siguientes imágenes de Docker están disponibles para el Museo pública de Amazon ECR:

AWS Glue lectura 5.0 – ecr.aws/glue/aws-glue-libs:5

Las imágenes de Docker de Glue AWS son compatibles con ambas x86_64 y arm64.

En esta publicación, usamos public.ecr.aws/glue/aws-glue-libs:5 y ejecute el contenedor en una máquina recinto (Mac, Windows o Linux). Esta imagen de contenedor ha sido probada para AWS Glue 5.0 Spark Jobs. La imagen contiene lo sucesivo:

Para configurar su contenedor, extraiga la imagen de la local pública ECR y luego ejecuta el contenedor. Demostramos cómo ejecutar su contenedor con los siguientes métodos, dependiendo de sus requisitos:

spark-submit
Caparazón de replica (pyspark)
pytest
Código de Visual Studio

Requisitos previos

Ayer de comenzar, asegúrese de que Docker esté instalado y Docker Daemon se esté ejecutando. Para las instrucciones de instalación, consulte la documentación de Docker para Impermeable, Windowso Linux. Igualmente asegúrese de tener al menos 7 GB de espacio en disco para la imagen en el host que ejecuta Docker.

Configurar las credenciales de AWS

Para habilitar las llamadas AWS API desde el contenedor, configure sus credenciales de AWS con los siguientes pasos:

Crear un perfil llamado AWS.
Bahía CMD en Windows o un terminal en Mac/Linux, y ejecute el sucesivo comando:

PROFILE_NAME="profile_name"

En las siguientes secciones, utilizamos este perfil llamado AWS.

Tire de la imagen de la Museo Pública de ECR

Si está ejecutando Docker en Windows, elija el icono Docker (haga clic derecho) y elija Cambiar a los contenedores de Linux antaño de tirar de la imagen.

Ejecute el sucesivo comando para extraer la imagen de la local pública ECR:

docker pull public.ecr.aws/glue/aws-glue-libs:5

Ejecute el contenedor

Ahora puede ejecutar un contenedor usando esta imagen. Puede designar cualquiera de los siguientes métodos basados en sus requisitos.

chispa

Puede ejecutar un raya de trabajo de pegamento de AWS ejecutando el spark-submit comando en el contenedor.

Escriba su raya de trabajo (sample.py en el sucesivo ejemplo) y guárdelo bajo el /local_path_to_workspace/src/ directorio usando los siguientes comandos:

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

Estas variables se utilizan en lo sucesivo docker run dominio. El código de muestra (sample.py) usado en el spark-submit El comando se incluye en el apéndice al final de esta publicación.

Ejecute el sucesivo comando para ejecutar el spark-submit Comando en el contenedor para mandar una nueva solicitud de Spark:

$ docker run -it --rm 
    -v ~/.aws:/home/hadoop/.aws 
    -v $WORKSPACE_LOCATION:/home/hadoop/workspace/ 
    -e AWS_PROFILE=$PROFILE_NAME 
    --name glue5_spark_submit 
    public.ecr.aws/glue/aws-glue-libs:5 
    spark-submit /home/hadoop/workspace/src/$SCRIPT_FILE_NAME

Shell repler (Pyspark)

Puede ejecutar un shell repler (lee-eval-hinting loop) para el progreso interactivo. Ejecute el sucesivo comando para ejecutar el comando pyspark en el contenedor para iniciar el shell repl:

$ docker run -it --rm 
    -v ~/.aws:/home/hadoop/.aws 
    -e AWS_PROFILE=$PROFILE_NAME 
    --name glue5_pyspark 
    public.ecr.aws/glue/aws-glue-libs:5 
    pyspark

Verá la sucesivo salida:

Python 3.11.6 (main, Jan  9 2025, 00:00:00) (GCC 11.4.1 20230605 (Red Hat 11.4.1-2)) on linux
Type "help", "copyright", "credits" or "license" for more information.
Setting default log level to "WARN".
To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
Welcome to
      ____              __
     / __/__  ___ _____/ /__
    _ / _ / _ `/ __/  '_/
   /__ / .__/_,_/_/ /_/_   version 3.5.2-amzn-1
      /_/

Using Python version 3.11.6 (main, Jan  9 2025 00:00:00)
Spark context Web UI available at None
Spark context available as 'sc' (master = recinto(*), app id = local-1740643079929).
SparkSession available as 'spark'.
>>>

Con este shell repl, puede codificar y probar de forma interactiva.

pytest

Para pruebas unitarias, puede usar pytest Para guiones de trabajo de Glue Glue Spark.

Ejecute los siguientes comandos 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}

Ahora invocemos pytest usando docker run:

$ docker run -i --rm 
    -v ~/.aws:/home/hadoop/.aws 
    -v $WORKSPACE_LOCATION:/home/hadoop/workspace/ 
    --workdir /home/hadoop/workspace 
    -e AWS_PROFILE=$PROFILE_NAME 
    --name glue5_pytest 
    public.ecr.aws/glue/aws-glue-libs:5 
    -c "python3 -m pytest --disable-warnings"

Cuando pytest Termina de ejecutar pruebas unitarias, su salida se verá como lo sucesivo:

============================= test session starts ==============================
platform linux -- Python 3.11.6, pytest-8.3.4, pluggy-1.5.0
rootdir: /home/hadoop/workspace
plugins: integration-mark-0.2.0
collected 1 item

tests/test_sample.py .                                                   (100%)

======================== 1 passed, 1 warning in 34.28s =========================

Código de Visual Studio

Para configurar el contenedor con el código Visual Studio, complete los siguientes pasos:

Instale el código Visual Studio.
Instalar Pitón.
Instalar Contenedores de progreso.
Bahía la carpeta del espacio de trabajo en el código Visual Studio.
Prensa Ctrl+Shift+P (Windows/Linux) o CMD+Shift+P (Impermeable).
Ingresar Preferences: Open Workspace Settings (JSON).
Prensa Ingresar.
Ingrese posteriormente de JSON y guárdelo:

{
    "python.defaultInterpreterPath": "/usr/bin/python3.11",
    "python.analysis.extraPaths": (
        "/usr/lib/spark/python/lib/py4j-0.10.9.7-src.zip:/usr/lib/spark/python/:/usr/lib/spark/python/lib/",
    )
}

Ahora estás preparado para configurar el contenedor.

Ejecute el contenedor Docker:

$ docker run -it --rm 
    -v ~/.aws:/home/hadoop/.aws 
    -v $WORKSPACE_LOCATION:/home/hadoop/workspace/ 
    -e AWS_PROFILE=$PROFILE_NAME 
    --name glue5_pyspark 
    public.ecr.aws/glue/aws-glue-libs:5 
    pyspark

Iniciar código de Visual Studio.
Designar Explorador remoto En el panel de navegación.
Elija el contenedor ecr.aws/glue/aws-glue-libs:5 (Haga clic derecho) y elija Adjuntar en la ventana contemporáneo.

Si aparece el sucesivo diálogo, elija Entiendo.

Rajado /home/hadoop/workspace/.

Crea un raya AWS Glue Pyspark y elige Pasar.

Debería ver la ejecución exitosa en el raya AWS Glue Pyspark.

Cambios entre la imagen de Docker de AWS Glue 4.0 y AWS Glue 5.0

Los siguientes son cambios importantes entre el AWS Glue 4.0 y la imagen de Glue 5.0 Docker:

En AWS Glue 5.0, hay una sola imagen de contenedor para trabajos por lotes y transmisión. Esto difiere de AWS Glue 4.0, donde había una imagen para el pedazo y otra para la transmisión.
En AWS Glue 5.0, el nombre de beneficiario predeterminado del contenedor es Hadoop. En AWS Glue 4.0, el nombre de beneficiario predeterminado fue Glue_user.
En AWS Glue 5.0, se han eliminado varias bibliotecas adicionales, incluidas Jupyterlab y Livy, de la imagen. Puedes instalarlos manualmente.
En AWS Glue 5.0, todas las bibliotecas de Iceberg, Hudi y Delta están precargadas de forma predeterminada, y la variable de entorno DATALAKE_FORMATS ya no es necesario. Hasta que AWS Glue 4.0, la variable de entorno DATALAKE_FORMATS se usó para especificar si el formato de tabla específico está cargado.

La cinta precursor es específica de la imagen Docker. Para obtener más información sobre las actualizaciones de AWS Glue 5.0, ver Introducir AWS Glue 5.0 para Apache Spark y Portar AWS Glue para Spark Jobs a AWS Glue Lectura 5.0.

Consideraciones

Tenga en cuenta que las siguientes características no son compatibles cuando se utilizan la imagen del contenedor de pegamento AWS para desarrollar scripts de trabajo localmente:

Conclusión

En esta publicación, exploramos cómo las imágenes de Docker de AWS Glue 5.0 proporcionan una colchoneta flexible para desarrollar y probar scripts de trabajo de pegamento AWS en su entorno preferido. Estas imágenes, fácilmente disponibles en la Museo Pública de Amazon ECR, agilizan el proceso de progreso al ofrecer un entorno consistente y portátil para el progreso de AWS Glue.

Para obtener más información sobre cómo construir la tubería de progreso de extremo a extremo, ver Ciclo de vida de progreso de extremo a extremo para que los ingenieros de datos creen una tubería de integración de datos utilizando AWS Glue. Le recomendamos que explore estas capacidades y comparta sus experiencias con la comunidad de AWS.

Apéndice A: Códigos de muestra de trabajo de pegamento AWS para pruebas

Este apéndice presenta tres scripts diferentes como códigos de muestra de trabajo de pegamento AWS para fines de prueba. Puedes usar cualquiera de ellos en el tutorial.

El sucesivo código Sample.py usa la biblioteca AWS Glue ETL con una Servicio de almacenamiento simple de Amazon (Amazon S3) Citación API. El código requiere permisos de Amazon S3 en Gobierno de identidad y camino de AWS (SOY). Debe otorgar la política administrada por IAM: AWS: IAM :: AWS: Policy/Amazons3ReadonlyAccess o Política personalizada IAM que le permite hacer ListBucket y GetObject API llamadas para la ruta 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 sucesivo código test_sample.py es una muestra para una prueba unitaria de sample.py:

The following test_sample.py code is a sample for a unit test of 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)

Apéndice B: Sumar controladores JDBC y bibliotecas Java

Para añadir un regulador JDBC actualmente arreglado en el contenedor, puede crear un nuevo directorio en su espacio de trabajo con los archivos JAR que necesita y sumar el directorio /opt/spark/jars/ en el docker run dominio. Archivos jar encontrados en /opt/spark/jars/ Interiormente del contenedor se agregan automáticamente a Spark ClassPath y estará arreglado para su uso durante la ejecución del trabajo.

Por ejemplo, puede usar lo sucesivo docker run Comando para añadir frascos de regulador JDBC a un shell replic de Pyspark:

$ docker run -it --rm 
    -v ~/.aws:/home/hadoop/.aws 
    -v $WORKSPACE_LOCATION:/home/hadoop/workspace/ 
    -v $WORKSPACE_LOCATION/jars/:/opt/spark/jars/ 
    --workdir /home/hadoop/workspace 
    -e AWS_PROFILE=$PROFILE_NAME 
    --name glue5_jdbc 
    public.ecr.aws/glue/aws-glue-libs:5 
    pyspark

Como se destacó anteriormente, el customJdbcDriverS3Path La opción de conexión no se puede usar para importar un regulador JDBC personalizado de Amazon S3 en las imágenes de contenedores de pegamento AWS.

Apéndice C: Sumar Livy y Jupyterlab

La imagen del contenedor AWS Glue 5.0 no tiene Livy instalada de forma predeterminada. Puede crear una nueva imagen de contenedor que extienda la imagen del contenedor AWS Glue 5.0 como colchoneta. El sucesivo DockerFile demuestra cómo puede extender la imagen de Docker para incluir componentes adicionales que necesita para mejorar su experiencia de progreso y prueba.

Para comenzar, cree un directorio en su tiempo de trabajo y coloque el Dockerfile.livy_jupyter Archivo en el directorio:

$ mkdir -p $WORKSPACE_LOCATION/jupyterlab/
$ cd $WORKSPACE_LOCATION/jupyterlab/
$ vim Dockerfile.livy_jupyter

El sucesivo código es Dockerfile.livy_jupyter:

FROM public.ecr.aws/glue/aws-glue-libs:5 AS glue-base

ENV LIVY_SERVER_JAVA_OPTS="--add-opens java.colchoneta/java.lang.invoke=ALL-UNNAMED --add-opens=java.colchoneta/java.nio=ALL-UNNAMED --add-opens=java.colchoneta/sun.nio.ch=ALL-UNNAMED --add-opens=java.colchoneta/sun.nio.cs=ALL-UNNAMED --add-opens=java.colchoneta/java.util.concurrent.atomic=ALL-UNNAMED"

# Download Livy
ADD --chown=hadoop:hadoop https://dlcdn.apache.org/incubator/livy/0.8.0-incubating/apache-livy-0.8.0-incubating_2.12-bin.zip ./

# Install and configure Livy
RUN unzip apache-livy-0.8.0-incubating_2.12-bin.zip && 
rm apache-livy-0.8.0-incubating_2.12-bin.zip && 
mv apache-livy-0.8.0-incubating_2.12-bin livy && 
mkdir -p livy/logs && 
cat <> livy/conf/livy.conf
livy.server.host = 0.0.0.0
livy.server.port = 8998
livy.spark.master = recinto
livy.repl.enable-hive-context = true
livy.spark.scala-version = 2.12
EOF && 
cat <> livy/conf/log4j.properties
log4j.rootCategory=INFO,console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.target=System.err
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n
log4j.logger.org.degeneración.jetty=WARN
EOF

# Switching to root user temporarily to install dev dependency packages
USER root 
RUN dnf update -y && dnf install -y krb5-devel gcc python3.11-devel
USER hadoop

# Install SparkMagic and JupyterLab
RUN export PATH=$HOME/.recinto/bin:$HOME/livy/bin/:$PATH && 
printf "numpy<2nIPython<=7.14.0n" > /tmp/constraint.txt && 
pip3.11 --no-cache-dir install --constraint /tmp/constraint.txt --user pytest boto==2.49.0 jupyterlab==3.6.8 IPython==7.14.0 ipykernel==5.5.6 ipywidgets==7.7.2 sparkmagic==0.21.0 jupyterlab_widgets==1.1.11 && 
jupyter-kernelspec install --user $(pip3.11 --no-cache-dir show sparkmagic | grep Location | cut -d" " -f2)/sparkmagic/kernels/sparkkernel && 
jupyter-kernelspec install --user $(pip3.11 --no-cache-dir show sparkmagic | grep Location | cut -d" " -f2)/sparkmagic/kernels/pysparkkernel && 
jupyter server extension enable --user --py sparkmagic && 
cat <> /home/hadoop/.recinto/bin/entrypoint.sh
#!/usr/bin/env bash
mkdir -p /home/hadoop/workspace/
livy-server start
sleep 5
jupyter lab --no-browser --ip=0.0.0.0 --allow-root --ServerApp.root_dir=/home/hadoop/workspace/ --ServerApp.token='' --ServerApp.password=''
EOF

# Setup Entrypoint script
RUN chmod +x /home/hadoop/.recinto/bin/entrypoint.sh

# Add default SparkMagic Config
ADD --chown=hadoop:hadoop https://raw.githubusercontent.com/jupyter-incubator/sparkmagic/refs/heads/master/sparkmagic/example_config.json .sparkmagic/config.json

# Update PATH var
ENV PATH=/home/hadoop/.recinto/bin:/home/hadoop/livy/bin/:$PATH

ENTRYPOINT ("/home/hadoop/.recinto/bin/entrypoint.sh")

Ejecute el comando Docker Build para construir la imagen:

docker build 
    -t glue_v5_livy 
    --file $WORKSPACE_LOCATION/jupyterlab/Dockerfile.livy_jupyter 
    $WORKSPACE_LOCATION/jupyterlab/

Cuando se completa la compilación de la imagen, puede usar el sucesivo comando Docker Run para iniciar la imagen recién construida:

docker run -it --rm 
    -v ~/.aws:/home/hadoop/.aws 
    -v $WORKSPACE_LOCATION:/home/hadoop/workspace/ 
    -p 8998:8998 
    -p 8888:8888 
    -e AWS_PROFILE=$PROFILE_NAME 
    --name glue5_jupyter  
    glue_v5_livy

Apéndice D: Sumar bibliotecas adicionales de Python

En esta sección, discutimos añadir bibliotecas adicionales de Python e instalar paquetes de Python usando

Bibliotecas locales de Python

Para añadir bibliotecas locales de Python, colóquelas bajo un directorio y asigne la ruta a $EXTRA_PYTHON_PACKAGE_LOCATION:

$ docker run -it --rm 
    -v ~/.aws:/home/hadoop/.aws 
    -v $WORKSPACE_LOCATION:/home/hadoop/workspace/ 
    -v $EXTRA_PYTHON_PACKAGE_LOCATION:/home/hadoop/workspace/extra_python_path/ 
    --workdir /home/hadoop/workspace 
    -e AWS_PROFILE=$PROFILE_NAME 
    --name glue5_pylib 
    public.ecr.aws/glue/aws-glue-libs:5 
    -c 'export PYTHONPATH=/home/hadoop/workspace/extra_python_path/:$PYTHONPATH; pyspark'

Para validar que se ha asociado la ruta PYTHONPATHpuede realizar su existencia en sys.path:

Python 3.11.6 (main, Jan  9 2025, 00:00:00) (GCC 11.4.1 20230605 (Red Hat 11.4.1-2)) on linux
Type "help", "copyright", "credits" or "license" for more information.
Setting default log level to "WARN".
To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
Welcome to
      ____              __
     / __/__  ___ _____/ /__
    _ / _ / _ `/ __/  '_/
   /__ / .__/_,_/_/ /_/_   version 3.5.2-amzn-1
      /_/

Using Python version 3.11.6 (main, Jan  9 2025 00:00:00)
Spark context Web UI available at None
Spark context available as 'sc' (master = recinto(*), app id = local-1740719582296).
SparkSession available as 'spark'.
>>> import sys
>>> "/home/hadoop/workspace/extra_python_path" in sys.path
True

Instalación de paquetes de Python con PIP

Para instalar paquetes de PYPI (o cualquier otro repositorio de artefactos) utilizando PIP, puede usar el sucesivo enfoque:

docker run -it --rm 
    -v ~/.aws:/home/hadoop/.aws 
    -v $WORKSPACE_LOCATION:/home/hadoop/workspace/ 
    --workdir /home/hadoop/workspace 
    -e AWS_PROFILE=$PROFILE_NAME 
    -e SCRIPT_FILE_NAME=$SCRIPT_FILE_NAME 
    --name glue5_pylib 
    public.ecr.aws/glue/aws-glue-libs:5 
    -c 'pip3 install snowflake==1.0.5; spark-submit /home/hadoop/workspace/src/$SCRIPT_FILE_NAME'

Sobre los autores

Subramanya vajiraya es un ingeniero de la aglomeración de Sr. (ETL) en AWS Sydney especializado en AWS Glue. Le apasiona ayudar a los clientes a resolver problemas relacionados con su carga de trabajo ETL e implementar el procesamiento de datos escalable y las tuberías de examen en AWS. Fuera del trabajo, le gusta ir en biciclo y caminar largos con su perro Ollie.

Noritaka sekiyama es un arquitecto principal de Big Data en el equipo de Glue de AWS. Trabaja con sede en Tokio, Japón. Es responsable de construir artefactos de software para ayudar a los clientes. En su tiempo desocupado, le gusta trastear en biciclo con su biciclo de carretera.

Etiquetado AWS, contenedor, desarrollar, Docker, Glue, jobs, localmente, probar, utilizando