

# Desarrollo y prueba de scripts de trabajos de AWS a nivel local
<a name="aws-glue-programming-etl-libraries"></a>

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

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

Si prefiere no tener código o utilizar el código menos, 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](https://docs.aws.amazon.com/glue/latest/ug/notebooks-chapter.html). Si desea utilizar su propio entorno local, las sesiones interactivas son una buena opción. Para obtener más información, consulte [Uso de las sesiones interactivas con AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-chapter.html).

Si prefiere la experiencia de desarrollo local o remoto, la imagen de Docker es una buena opción. Esto le permitirá 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 DE forma local es una buena opción.

## Desarrollo mediante AWS Glue Studio
<a name="develop-using-studio"></a>

El editor visual de 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 obtener más información, consulte [Guía del usuario de AWS Glue Studio](https://docs.aws.amazon.com/glue/latest/ug/what-is-glue-studio.html).

## Desarrollo mediante sesiones interactivas
<a name="develop-using-interactive-sessions"></a>

Las sesiones interactivas le permiten crear y probar aplicaciones desde el entorno que elija. Para obtener más información, consulte [Uso de las sesiones interactivas con AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-chapter.html).

# Desarrolle y pruebe trabajos de AWS Glue localmente mediante una imagen de Docker.
<a name="develop-local-docker-image"></a>

 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 5.0 de AWS Glue en un contenedor de Docker mediante la utilización de una imagen de Docker.

## Imágenes de Docker disponibles
<a name="develop-local-available-docker-images-ecr"></a>

 Las siguientes imágenes de Docker están disponibles para AWS Glue en [Amazon ECR:](https://gallery.ecr.aws/glue/aws-glue-libs). 
+  Para la versión 5.0 de AWS Glue: `public.ecr.aws/glue/aws-glue-libs:5` 
+ Para la versión 4.0 AWS Glue: `public.ecr.aws/glue/aws-glue-libs:glue_libs_4.0.0_image_01`
+ Para la versión 3.0 de AWS Glue: `public.ecr.aws/glue/aws-glue-libs:glue_libs_3.0.0_image_01`
+ Para la versión 2.0 de AWS Glue: `public.ecr.aws/glue/aws-glue-libs:glue_libs_2.0.0_image_01`

**nota**  
 Las imágenes de Docker de AWS Glue son compatibles con x86\$164 y arm64. 

 En este ejemplo, usamos `public.ecr.aws/glue/aws-glue-libs:5` y ejecutamos el contenedor en una máquina local (Mac, Windows o Linux). Esta imagen de contenedor ha sido probada para trabajos de la versión 5.0 de Spark de AWS Glue. La imagen contiene lo siguiente: 
+  Amazon Linux 2023 
+  Biblioteca de ETL de AWS Glue 
+  Apache Spark 3.5.4 
+  Bibliotecas de formato de tabla abierta: Apache Iceberg 1.7.1, Apache Hudi 0.15.0 y Delta Lake 3.3.0 
+  Cliente del Catálogo de datos de AWS Glue 
+  Conector Amazon Redshift para Apache Spark 
+  Conector Amazon DynamoDB para Apache Hadoop 

 Para configurar su contenedor, extraiga la imagen de la Galería Pública de ECR y, a continuación, ejecute el contenedor. Este tema demuestra cómo ejecutar su contenedor con los siguientes métodos, según sus requisitos: 
+ `spark-submit`
+ Intérprete de comandos de REPL `(pyspark)`
+ `pytest`
+ Visual Studio Code

## Requisitos previos
<a name="develop-local-docker-image-prereq"></a>

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](https://docs.docker.com/docker-for-mac/install/) o [Linux](https://docs.docker.com/engine/install/). 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](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-libraries.html#local-dev-restrictions). 

### Configuración de AWS
<a name="develop-local-docker-image-config-aws-credentials"></a>

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.  [Cree un perfil con el nombre AWS](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-files.html). 

1.  Abra `cmd` en Windows o en una terminal en Mac/Linux y ejecute el siguiente comando en la terminal: 

   ```
   PROFILE_NAME="<your_profile_name>"
   ```

En las siguientes secciones, utilizaremos este perfil con el nombre AWS.

### 
<a name="develop-local-docker-pull-image-from-ecr-public"></a>

 Si está ejecutando Docker en Windows, elija el ícono de Docker (clic con el botón derecho) y elija **Cambiar a contenedores Linux…** antes de extraer la imagen. 

Ejecute el siguiente comando para extraer la imagen de la galería pública de ECR:

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

## Ejecute el contenedor
<a name="develop-local-docker-image-setup-run"></a>

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

### spark-submit
<a name="develop-local-docker-image-setup-run-spark-submit"></a>

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

1.  Escriba su script y guárdelo como `sample.py` en el ejemplo siguiente y guárdelo en el directorio `/local_path_to_workspace/src/` con 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}
   ```

1.  Estas variables se utilizan en el comando docker run que aparece a continuación. El código de ejemplo (sample.py) utilizado en el siguiente comando spark-submit se incluye en el apéndice al final de este tema. 

    Ejecute el siguiente comando para ejecutar el comando `spark-submit` en el contenedor para enviar una nueva aplicación 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
   ```

1. (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 [Carga dinámica de propiedades de Spark](https://spark.apache.org/docs/latest/configuration.html) en la documentación de Spark. 

### Intérprete de comandos REPL (Pyspark)
<a name="develop-local-docker-image-setup-run-repl-shell"></a>

 Puede ejecutar el intérprete de comandos de REPL (`read-eval-print loops`) para el 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 --rm \
    -v ~/.aws:/home/hadoop/.aws \
    -e AWS_PROFILE=$PROFILE_NAME \
    --name glue5_pyspark \
    public.ecr.aws/glue/aws-glue-libs:5 \
    pyspark
```

 Verá el siguiente resultado: 

```
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.4-amzn-0
      /_/

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 = local[*], app id = local-1740643079929).
SparkSession available as 'spark'.
>>>
```

 Con este intérprete de comandos de REPL, puede programar y probar de forma interactiva. 

### Pytest
<a name="develop-local-docker-image-setup-run-pytest"></a>

 Para las pruebas unitarias, 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` mediante `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"
```

 Una vez que `pytest` termine de ejecutar las pruebas unitarias, el resultado tendrá un aspecto parecido al siguiente: 

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

### Configuración del contenedor para utilizar Visual Studio Code
<a name="develop-local-docker-image-setup-visual-studio"></a>

 Para configurar el contenedor con Visual Studio Code, complete los siguientes pasos: 

1. Instale Visual Studio Code.

1. Instalación de [Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python).

1. Instalar [Visual Studio Code Remote: contenedores](https://code.visualstudio.com/docs/remote/containers)

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

1. Pulse `Ctrl+Shift+P` (Windows/Linux) o `Cmd+Shift+P` (Mac).

1. Tipo: `Preferences: Open Workspace Settings (JSON)`.

1. Pulse Intro.

1. Pegue el siguiente 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/",
       ]
   }
   ```

 Para configurar el contenedor: 

1. 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
   ```

1. Inicie Visual Studio Code.

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

1.  Haga clic con el botón derecho y elija **Adjuntar en la ventana actual**.   
![\[Al hacer clic con el botón derecho, se presenta una ventana con la opción de Adjuntar en la ventana actual.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/vs-code-other-containers.png)

1.  Si aparece el siguiente cuadro de diálogo, elija **Entendido**.   
![\[Aparece una ventana de advertencia con el mensaje “Adjuntar a un contenedor puede ejecutar código arbitrario”.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/vs-code-warning-got-it.png)

1. Abra . `/home/handoop/workspace/`.  
![\[Aparece resaltada una ventana desplegable con la opción “espacio de trabajo”.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/vs-code-open-workspace.png)

1.  Cree un script de PySpark de AWS Glue y elija **Ejecutar**. 

   Verá la ejecución correcta del script.  
![\[La ejecución correcta del script.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/vs-code-run-successful-script.png)

## Cambios entre la imagen de Docker de AWS Glue 4.0 y de AWS Glue 5.0
<a name="develop-local-docker-glue4-glue5-changes"></a>

 Los principales cambios entre la imagen de Docker de AWS Glue 4.0 y de AWS Glue 5.0: 
+  En AWS Glue 5.0, hay una sola imagen de contenedor para los trabajos por lotes y los de streaming. Esto difiere de Glue 4.0, donde había una imagen para los trabajos por lotes y otra para los de streaming. 
+  En AWS Glue 5.0, el nombre de usuario predeterminado del contenedor es `hadoop`. En AWS Glue 4.0, el nombre de usuario predeterminado era `glue_user`. 
+  En AWS Glue 5.0, se han eliminado de la imagen varias bibliotecas adicionales, incluidas JupyterLab y Livy. Puede instalarlas manualmente. 
+  En la versión 5.0 de AWS Glue, todas las bibliotecas de Iceberg, Hudi y Delta vienen precargadas de forma predeterminada y la variable de entorno `DATALAKE_FORMATS` ya no es necesaria. Antes de la versión 4.0 de AWS Glue, la variable de entorno `DATALAKE_FORMATS` se utilizaba para especificar qué formatos de tabla específicos se debían cargar. 

 La lista anterior es específica de la imagen de Docker. Para obtener más información sobre las actualizaciones de la versión 5.0 de AWS Glue, consulte [Introducción a la versión 5.0 de AWS Glue para Apache Spark](https://aws.amazon.com/blogs/big-data/introducing-aws-glue-5-0-for-apache-spark/) y [Migración de AWS Glue para trabajos de Spark a la versión 5.0 de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-50.html). 

## Consideraciones
<a name="develop-local-docker-considerations"></a>

 Tenga en cuenta que las siguientes funciones no se admiten cuando se utiliza la imagen del contenedor de AWS Glue para desarrollar scripts de trabajo de forma local. 
+  [Marcadores de trabajo](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html) 
+  AWS GlueEscritora de parquet ([utiliza el formato Parquet en AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-parquet-home.html)) 
+  [ Transforma FillMissingValues ](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-pyspark-transforms-fillmissingvalues.html) 
+  [Transformación FindMatches](https://docs.aws.amazon.com/glue/latest/dg/machine-learning.html#find-matches-transform) 
+  [ Lector CSV SIMD vectorizado ](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-csv-home.html#aws-glue-programming-etl-format-simd-csv-reader) 
+  La propiedad [customJdbcDriverS3Path](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-connect.html#aws-glue-programming-etl-connect-jdbc) para cargar el controlador JDBC desde la ruta Amazon S3 
+  [AWS Glue Calidad de datos de](https://docs.aws.amazon.com/glue/latest/dg/glue-data-quality.html) 
+  [Detección de datos confidenciales](https://docs.aws.amazon.com/glue/latest/dg/detect-PII.html) 
+  Venta de credenciales basada en permisos de AWS Lake Formation 

## Anexo: Agregar controladores JDBC y bibliotecas Java
<a name="develop-local-docker-image-appendix"></a>

 Para agregar un controlador JDBC que actualmente no está disponible en el contenedor, puede crear un nuevo directorio en su espacio de trabajo con los archivos JAR que necesite y montar el directorio en `/opt/spark/jars/` en el comando docker run. Los archivos JAR que se encuentran en `/opt/spark/jars/` dentro del contenedor se agregan automáticamente a Spark Classpath y estarán disponibles para su uso durante la ejecución del trabajo. 

 Por ejemplo, utilice el siguiente comando docker run para agregar los archivos jar del controlador JDBC al intérprete de comandos REPL 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 destaca en **Consideraciones**, la opción de conexión `customJdbcDriverS3Path` no se puede utilizar para importar un controlador JDBC personalizado desde Amazon S3 en imágenes de contenedores de AWS Glue. 