¿Por qué mi trabajo de ETL de AWS Glue se ejecuta durante mucho tiempo?

Resolución

Los factores comunes que pueden hacer que los trabajos de AWS Glue se ejecuten durante mucho tiempo incluyen los ajustes de configuración y la estructura de los datos y los scripts.

Los pasos siguientes ayudan a optimizar el rendimiento.

Configuración de métricas y registros

Para identificar problemas y optimizar el rendimiento, usa las herramientas de supervisión integradas de AWS Glue, como Amazon CloudWatch y las métricas de observabilidad de trabajos.

Además, configura alertas para detectar anomalías y activa la interfaz de usuario de Apache Spark para obtener más información sobre el funcionamiento del trabajo de AWS Glue. Puedes usar la característica de ](https://docs.aws.amazon.com/glue/latest/dg/monitor-job-insights.html)análisis de ejecución de trabajos de AWS Glue[ para comprender en detalle el comportamiento del trabajo mientras se ejecuta.

Para activar las métricas, completa una de las siguientes acciones.

Desde la consola de AWS Glue

1. Abre la consola de AWS Glue.
2. En el panel de navegación, elige Trabajos de ETL.
3. Selecciona el trabajo para el que quieres activar las métricas.
4. Elige Acción y, a continuación, Editar trabajo.
5. En la pestaña Detalles del trabajo, en Opciones avanzadas, elige Métricas del trabajo, Métricas de observabilidad del trabajo, Registro continuo e Interfaz de usuario de Spark.
6. Selecciona Guardar.

Desde la CLI o el SDK

Nota: Si se muestran errores al ejecutar comandos de la Interfaz de la línea de comandos de AWS (AWS CLI), consulta Solución de problemas de AWS CLI. Además, asegúrate de utilizar la versión más reciente de la AWS CLI.

Desde las llamadas a la API o la CLI, pasa los siguientes parámetros al parámetro DefaultArguments:

'--enable-metrics' : 'true'
'--enable-observability-metrics' : 'true'
'--enable-continuous-cloudwatch-log' : 'true'
'--enable-spark-ui' : 'true'
'--spark-event-logs-path' : '<s3://path/to/log/>'

Identificación de los cuellos de botella

Para encontrar cuellos de botella, usa los registros de controladores de CloudWatch generados por la ejecución del trabajo o usa los registros de la interfaz de usuario de Spark. AWS Glue 3.0 y versiones posteriores pueden gestionar uniones sesgadas con características nativas de Spark, como la ejecución adaptativa de consultas (AQE). Para obtener más información, consulta Interfaz de usuario web en el sitio web de Apache.

Registros de controladores

Para comprobar los registros de los controladores:

1. Abre el trabajo desde la consola de AWS Glue.
2. En la pestaña Ejecuciones, selecciona la ejecución de trabajo para la que deseas comprobar los registros.
3. En el grupo de registros /aws-glue/jobs/error, selecciona la secuencia de registro que tenga el mismo nombre que el ID de ejecución del trabajo para cual abriste los registros. Busca secuencias que tengan nombres con el sufijo «_g-xxxxxx»; estos son los registros del ejecutor.
4. En los registros del controlador, comprueba si hay tareas que tardan mucho en ejecutarse antes de completarse. En el siguiente ejemplo, una tarea se ejecutó durante 34 minutos y el trabajo de Spark para el que se creó la tarea finalizó en 35 minutos.

   2024-09-13 10:06:13,847 INFO [task-result-getter-0] scheduler.TaskSetManager (Logging.scala:logInfo(61)): Finished task 0.0 in stage 0.0 (TID 0) in 2054673 ms on 172.35.184.56 (executor 1) (1/1)
   2024-09-13 10:06:13,894 INFO [Thread-13] scheduler.DAGScheduler (Logging.scala:logInfo(61)): Job 0 finished: save at DataSink.scala:666, took 2164.67 s

Registros de la interfaz de usuario de Spark

En los registros de la interfaz de usuario de Spark, en las pestañas Trabajos y Etapas, busca las etapas y tareas que se ejecutaron durante mucho tiempo.

Solución de problemas de los cuellos de botella

Cree particiones de los datos de manera más eficiente. Los trabajos de AWS Glue se basan en el procesamiento distribuido. Si no se crean particiones de los datos de manera eficiente, es posible que los trabajadores de Spark tengan que procesar particiones grandes y desequilibradas. Este tiempo de procesamiento provoca retrasos. Para controlar el número de particiones, usa las funciones repartition() o coalesce() en Spark. Asegúrate de que se hayan creado particiones correctas de los datos para aprovechar la naturaleza distribuida de Spark. También puedes configurar AWS Glue DynamicFrame para crear particiones de los datos con splitFields o claves de partición personalizadas.

Para aumentar la capacidad, agrega nodos de trabajo. Si no hay suficientes nodos de trabajo para gestionar el volumen de datos, el trabajo se ejecuta con lentitud debido al paralelismo limitado. Aumenta la cantidad de nodos de trabajo o cambia a un tipo de trabajador más grande. Asegúrate de utilizar el tamaño de trabajador correcto y de haber asignado suficientes DPU (unidades de procesamiento de datos) para procesar los datos de manera eficiente. La cantidad de tareas gestionadas por ejecutor equivale a cuatro veces la cantidad de DPU. Por ejemplo, un tipo de trabajador G.1X tiene una DPU y gestiona cuatro tareas por ejecutor. Ten en cuenta que los tipos de trabajo G.4X y G.8X solo están disponibles para los trabajos de ETL de Spark de AWS Glue versión 3.0 o posteriores.

Redistribuye los datos para reducir el sesgo entre las particiones. El sesgo de datos se produce cuando las particiones tienen cantidades de datos significativamente diferentes. Los nodos con más datos están sobrecargados de trabajo mientras que otros están inactivos. Identifica las claves sesgadas mediante el análisis de la distribución de los datos. Redistribuye o equilibra los datos entre las particiones o utilice la técnica de salazón para distribuir las teclas de acceso rápido. AWS Glue 3.0 y versiones posteriores pueden gestionar uniones sesgadas con características nativas de Spark, como la ejecución adaptativa de consultas (AQE) en el sitio web de Apache. Para ello, activa la ejecución adaptativa de consultas (AQE) y define spark.sql.adaptive.skewJoin.enabled en true. AQE está activado de forma predeterminada a partir de Spark 3.2.0. Para activar AQE para Glue 3.0, agrega un parámetro spark.sql.adaptive.enabled y establécelo en true.

Sustituye las UDF por funciones nativas de Spark. Las funciones personalizadas definidas por el usuario (UDF) o las transformaciones complejas pueden resultar caras de ejecutar y pueden ralentizar los trabajos de Spark. Evita las UDF siempre que sea posible y confía en las funciones nativas de Spark que están optimizadas para el rendimiento. Si son necesarias las UDF, vuelve a escribirlas en Scala en lugar de en Python, ya que las UDF de Scala suelen funcionar mejor. Además, para una mejor optimización, aplica transformaciones con DataFrames o DynamicFrames.

Minimiza las operaciones aleatorias. Las operaciones aleatorias, como groupBy, join u orderBy, transfieren datos entre nodos. Estos pueden convertirse en cuellos de botella si se usan en exceso o si no se administran adecuadamente. Para minimizar las operaciones aleatorias, filtra y agrega datos lo antes posible en el proceso de transformación. Para evitar una transferencia de datos innecesaria, usa combinaciones de transmisión cuando corresponda. Además, asegúrate de que se creen particiones de los datos aleatorios de manera eficiente.

Elimina el almacenamiento en caché innecesario. El uso excesivo o incorrecto del almacenamiento en caché puede aumentar el consumo de memoria y ralentizar el trabajo. Use cache() o persist() solo cuando reutilices un conjunto de datos varias veces en un flujo de trabajo. Ten en cuenta la memoria disponible y borra cualquier conjunto de datos en caché con unpersist() cuando esos conjuntos de datos ya no sean necesarios.

Divide las cadenas de dependencia largas. Si tu trabajo tiene una cadena larga de transformaciones, Spark vuelve a calcular toda la cadena de dependencias. Estas acciones pueden ralentizar el procesamiento. Divide los trabajos complejos en tareas más pequeñas. Si es necesario, mantén los resultados intermedios. Esto reduce la sobrecarga de recálculo y te ayuda a depurar y supervisar el rendimiento de cada paso de forma individual.

Reduce la latencia de la red y las operaciones de E/S. La lectura y escritura de datos en orígenes externos, como Amazon Simple Storage Service (Amazon S3), Amazon Relational Database Service (Amazon RDS) o Amazon Redshift, puede introducir latencia, especialmente con conjuntos de datos de gran tamaño. Utiliza los conectores integrados de AWS Glue. Almacena los datos en un formato que permita una lectura y escritura más rápidas, como Parquet u ORC. Activa S3 Transfer Acceleration para obtener velocidades de transferencia de datos más rápidas y utiliza el catálogo de datos de AWS Glue para optimizar la recuperación de metadatos.

Optimiza las operaciones nativas. Las operaciones nativas de Glue, incluidos los marcadores de trabajo y los conectores de exportación de DynamoDB, pueden aumentar los tiempos de ejecución de un trabajo de AWS Glue. Para comprobar los tiempos de ejecución, identifica en los registros de los controladores cuándo se inició el trabajo de AWS Glue y cuándo finalizó el trabajo de marcado de tareas o la exportación desde DynamoDB. Para DynamoDB, comprueba si hay mensajes similares a los del ejemplo siguiente:

2024-08-24 03:33:37.000Z connections.DynamoExportConnection (DynamoExportConnection.scala:dynamodbexport(129)): Dynamodb Export complete...exported 712948751 item(s) or 4859215204353 byte(s)

Reduce el efecto de los marcadores de trabajo

• Para reducir la cantidad de archivos analizados, consolida los archivos pequeños en archivos más grandes.
• Elimina las particiones y colócalas en una ubicación de archivo cuando el procesamiento ya haya finalizado.
• Utiliza estrategias de partición eficaces para que AWS Glue pueda omitir particiones enteras que no se hayan modificado.
• Para filtrar los datos de forma temprana, utiliza predicados de apilado.
• Desactiva temporalmente los marcadores de trabajo si no agregan valor al proceso de trabajo.

Reduce el efecto de los conectores de DynamoDB

• Cuando sea posible, reduce el volumen de datos exportados.
• Para identificar los problemas que causan los retrasos en la exportación, supervisa DynamoDB y AWS Glue.
• Para acelerar los tiempos de exportación, optimiza las configuraciones de tablas de DynamoDB.
• Cuando sea posible, exporta los datos fuera del trabajo principal o ajusta las programaciones para evitar cuellos de botella.

Información relacionada

Uso de parámetros de trabajo en trabajos de AWS Glue

Supervisión de trabajos mediante la interfaz de usuario web de Apache Spark

Monitorización de la planificación de DPU