# Trabajos de Spark y PySpark de AWS Glue AWS Glue admite trabajos de Spark y PySpark Un trabajo de Spark se ejecuta en un entorno Apache Spark administrado por AWS Glue. Procesa los datos en lotes. Un trabajo ETL de streaming es similar a un trabajo de Spark, excepto que realiza ETL en las transmisiones de datos. Utiliza el marco Apache Spark Structured Streaming. Algunas características de trabajo de Spark no están disponibles para los trabajos ETL de streaming. En las siguientes secciones, se ofrece información acerca de trabajos Spark y PySpark en AWS Glue. **Topics** + [Configuración de las propiedades de trabajos para trabajos de Spark en AWS Glue](add-job.md) + [Edición de scripts de Spark en la consola de AWS Glue](edit-script-spark.md) + [Trabajos (heredado)](console-edit-script.md) + [Seguimiento de los datos procesados mediante marcadores de trabajo](monitor-continuations.md) + [Almacenamiento de datos de mezclas aleatorias de Spark](monitor-spark-shuffle-manager.md) + [Supervisión de trabajos de Spark de AWS Glue](monitor-spark.md) + [Solución de problemas de IA generativa para Apache Spark en AWS Glue](troubleshoot-spark.md) + [Uso de vistas materializadas con AWS Glue](materialized-views.md) # Configuración de las propiedades de trabajos para trabajos de Spark en AWS Glue Cuando define su trabajo en la consola de AWS Glue, proporciona valores de propiedades para controlar el entorno en tiempo de ejecución de AWS Glue. ## Definición de propiedades de trabajo para trabajos de Spark En la siguiente lista se describen las propiedades de un trabajo de Spark. Para ver las propiedades de un trabajo de shell de Python, consulte [Definición de las propiedades de trabajos de shell de Python](add-job-python.md#create-job-python-properties). Para obtener información sobre las propiedades de un trabajo ETL de streaming, consulte [Definición de propiedades de trabajo para un trabajo ETL de streaming](add-job-streaming.md#create-job-streaming-properties). Las propiedades se muestran en el orden en que aparecen en el asistente **Add job (Agregar trabajo)** en la consola de AWS Glue. **Nombre** Proporciona una cadena UTF-8 con una longitud máxima de 255 caracteres **Descripción** Brinde una descripción adicional de hasta 2048 caracteres. **Rol de IAM** Especifique el rol de IAM que se utiliza para dar una autorización sobre los recursos que se utilizan para ejecutar el trabajo y obtener acceso a los almacenes de datos. Para obtener más información acerca de los permisos para ejecutar trabajos en AWS Glue, consulte [Administración de identidades y accesos para AWS Glue](security-iam.md). **Tipo** El tipo de trabajo de ETL. Este se establece de manera automática según el tipo de origen de datos que se seleccione. + **Spark** ejecuta un script de ETL de Apache Spark con el comando de trabajo `glueetl`. + **Spark Streaming** ejecuta un script de ETL de streaming de Apache Spark con el comando de trabajo `gluestreaming`. Para obtener más información, consulte [Trabajos ETL de streaming en AWS Glue](add-job-streaming.md). + **El intérprete de comandos de Python** ejecuta un script de Python con el comando de trabajo `pythonshell`. Para obtener más información, consulte [Configuración de las propiedades de trabajos del intérprete de comandos de Python en AWS Glue](add-job-python.md). ** versión de AWS Glue** AWS GlueLa versión de determina las versiones de Apache Spark y Python que están disponibles para el trabajo, como se especifica en la tabla a continuación. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/add-job.html) **Idioma** El código del script de ETL define la lógica del trabajo. El script se puede codificar en Python o en Scala. Puede elegir si AWS Glue genera el script que el flujo de trabajo ejecuta o bien si usted mismo lo proporciona. Proporcione el nombre del script y la ubicación en Amazon Simple Storage Service (Amazon S3). Compruebe que no haya un archivo con el mismo nombre que el directorio de script en la ruta. Para obtener más información acerca de cómo usar scripts, consulte [Guía de programación de AWS Glue](edit-script.md). **Tipo de empleado** Están disponibles los siguientes tipos de proceso de trabajo: Los recursos disponibles para los trabajadores de AWS Glue se miden en DPU. Una DPU es una medida relativa de la potencia de procesamiento que consta de 4 vCPU de capacidad de cómputo y 16 GB de memoria. + **G.025X**: al elegir este tipo, también debe proporcionar un valor para **Número de empleados**. Cada trabajador se asigna a 0,25 DPU (2 vCPU, 4 GB de memoria) con un disco de 84 GB (aproximadamente 34 GB libres). Le recomendamos este tipo de proceso de trabajo para trabajos de streaming de bajo volumen. Este tipo de proceso de trabajo solo está disponible para trabajos de transmisión con la versión 3.0 (o posterior) de AWS Glue. + **G.1X**: al elegir este tipo, también debe proporcionar un valor para **Número de empleados**. Cada trabajador se asigna a 1 DPU (4 vCPU, 16 GB de memoria) con un disco de 94 GB (aproximadamente 44 GB libres). Recomendamos este tipo de trabajador para cargas de trabajo como transformaciones de datos, uniones y consultas, ya que ofrece una forma escalable y rentable de ejecutar la mayoría de los trabajos. + **G.2X**: al elegir este tipo, también debe proporcionar un valor para **Número de empleados**. Cada trabajador se asigna a 2 DPU (8 vCPU, 32 GB de memoria) con un disco de 138 GB (aproximadamente 78 GB libres). Recomendamos este tipo de trabajador para cargas de trabajo como transformaciones de datos, uniones y consultas, ya que ofrece una forma escalable y rentable de ejecutar la mayoría de los trabajos. + **G.4X**: al elegir este tipo, también debe proporcionar un valor para **Número de empleados**. Cada trabajador se asigna a 4 DPU (16 vCPU, 64 GB de memoria) con un disco de 256 GB (aproximadamente 230 GB libres). Recomendamos este tipo de trabajador para los trabajos cuyas cargas de trabajo contengan las transformaciones, agregaciones, uniones y consultas más exigentes. + **G.8X**: al elegir este tipo, también debe proporcionar un valor para **Número de empleados**. Cada trabajador se asigna a 8 DPU (32 vCPU, 128 GB de memoria) con un disco de 512 GB (aproximadamente 485 GB libres). Recomendamos este tipo de trabajador para los trabajos cuyas cargas de trabajo contengan las transformaciones, agregaciones, uniones y consultas más exigentes. + **G.12X**: al elegir este tipo, también debe proporcionar un valor para **Número de empleados**. Cada trabajador se asigna a 12 DPU (48 vCPU, 192 GB de memoria) con un disco de 768 GB (aproximadamente 741 GB libres). Recomendamos este tipo de trabajador para trabajos con cargas de trabajo muy grandes que consumen muchos recursos y que requieren una capacidad de procesamiento significativa. + **G.16X**: al elegir este tipo, también debe proporcionar un valor para **Número de empleados**. Cada trabajador se asigna a 16 DPU (64 vCPU, 256 GB de memoria) con un disco de 1024 GB (aproximadamente 996 GB libres). Recomendamos este tipo de trabajador para los trabajos con las cargas de trabajo más grandes que consumen más recursos y que requieren la máxima capacidad de procesamiento. + **R.1X**: al elegir este tipo, también debe proporcionar un valor para **Número de empleados**. Cada trabajador se asigna a 1 DPU con una configuración optimizada para la memoria. Recomendamos este tipo de trabajador para las cargas de trabajo que consumen mucha memoria y que, con frecuencia, tienen errores de memoria insuficiente o requieren una alta relación entre memoria y CPU. + **R.2X**: al elegir este tipo, también debe proporcionar un valor para **Número de empleados**. Cada trabajador se asigna a 2 DPU con una configuración optimizada para la memoria. Recomendamos este tipo de trabajador para las cargas de trabajo que consumen mucha memoria y que, con frecuencia, tienen errores de memoria insuficiente o requieren una alta relación entre memoria y CPU. + **R.4X**: al elegir este tipo, también debe proporcionar un valor para **Número de empleados**. Cada trabajador se asigna a 4 DPU con una configuración optimizada para la memoria. Recomendamos este tipo de trabajador para cargas de trabajo grandes que consumen mucha memoria y que, con frecuencia, tienen errores de memoria insuficiente o requieren una alta relación entre memoria y CPU. + **R.8X**: al elegir este tipo, también debe proporcionar un valor para **Número de empleados**. Cada trabajador se asigna a 8 DPU con una configuración optimizada para la memoria. Recomendamos este tipo de trabajador para cargas de trabajo muy grandes que consumen mucha memoria y que, con frecuencia, tienen errores de memoria insuficiente o requieren una alta relación entre memoria y CPU. **Especificaciones del tipo de trabajador** La siguiente tabla proporciona especificaciones detalladas de todos los tipos de trabajadores G disponibles: **Especificaciones del tipo de trabajador G** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/add-job.html) **Importante:** Los tipos de trabajadores G.12X y G.16X, así como todos los tipos de trabajadores R (de R.1X a R.8X), tienen una latencia de inicio más alta. Se le cobra una tarifa por hora en función de la cantidad de DPU que se utilizan para ejecutar sus trabajos ETL. Para obtener más información, consulte la [página de precios de AWS Glue](https://aws.amazon.com/glue/pricing/). Para trabajos de AWS Glue versión 1.0 o anterior, cuando configura un trabajo con la consola y especifica un **Worker type (Tipo de empleado)** de **Standard (Estándar)**, se configura la **Maximum capacity (Capacidad máxima)** y el **Number of workers (Número de empleados)** se convierte en el valor de **Máximum capacity (Capacidad máxima)**: 1. Si utiliza AWS Command Line Interface (AWS CLI) o AWS SDK, puede especificar el parámetro **Max capacity (Capacidad máxima)** o puede especificar tanto **Worker type (Tipo de empleado)** como **Number of workers (Número de empleados)**. Para trabajos de versión 2.0 de AWS Glue o posterior, no puede especificar una **Capacidad máxima**. En su lugar, debe especificar un **Worker type (Tipo de empleado)** y el **Number of workers (Número de empleados)**. Los tipos de trabajo **G.4X** y **G.8X** solo están disponibles para la AWS Glue versión 3.0 de Spark ETL en las siguientes AWS regiones: Este de EE. UU. (Ohio), Este de EE. UU. (Norte de Virginia), Oeste de EE. UU. (Norte de California), Oeste de EE. UU. (Oregón), Asia-Pacífico (Bombay), Asia Pacífico (Seúl), Asia Pacífico (Singapur), Asia Pacífico (Sídney), Asia Pacífico (Tokio), Canadá (centro), Europa (Fráncfort), Europa (Irlanda), Europa (Londres), Europa (España), Europa (Estocolmo) y América del Sur (São Paulo). Los tipos de trabajadores **G.12X**, **G.16X** y de **R.1X** al **R.8X** están disponibles solo para los trabajos de Spark ETL de AWS Glue versión 4.0 o posterior en las siguientes regiones de AWS: Este de EE. UU. (Norte de Virginia), Oeste de EE. UU. (Oregón), Este de EE. UU. (Ohio), Europa (Irlanda) y Europa (Fráncfort). Se admitirán regiones adicionales en futuras versiones. **Número de trabajadores requerido** Para la mayoría de los tipos de trabajador, debe especificar el número de trabajadores que se asigna cuando se ejecuta el trabajo. **Job bookmark (Marcador de flujo de trabajo)** Especifique cómo AWS Glue procesará la información de estado cuando se ejecute el flujo de trabajo. Puede hacer que recuerde datos procesados previamente, actualice la información de estado o no tenga en cuenta dicha información. Para obtener más información, consulte [Seguimiento de los datos procesados mediante marcadores de trabajo](monitor-continuations.md). **Filas de trabajo ejecutadas** Especifica si las ejecuciones de trabajos se ponen en fila para ejecutarse más tarde cuando no pueden ejecutarse inmediatamente debido a las cuotas de servicio. Si está marcada, la fija de ejecución de trabajos está habilitada para las ejecuciones de trabajos. Si no se completa, los trabajos ejecutados no se considerarán para ponerlos en fila. Si esta configuración no coincide con el valor establecido en la ejecución del trabajo, se utilizará el valor proveniente del campo de ejecución del trabajo. **Ejecución flexible** Al configurar un trabajo mediante AWS Studio o la API, puede especificar una clase de ejecución de trabajos estándar o flexible. Sus trabajos pueden tener diferentes grados de prioridad y sensibilidad temporal. La clase de ejecución estándar es ideal para cargas de trabajo urgentes que requieren un inicio rápido de los trabajos y recursos dedicados. La clase de ejecución flexible es adecuada para trabajos no urgentes, como trabajos de preproducción, pruebas y cargas de datos únicas. Se admiten ejecuciones de trabajos flexibles para trabajos que utilizan AWS Glue versión 3.0 o posterior y tipos de empleados `G.1X` o `G.2X`. Los nuevos tipos de trabajadores (`G.12X`, `G.16X`, y de `R.1X` a `R.8X`) no admiten una ejecución flexible. [![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/FnHCoTuDLXU/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/FnHCoTuDLXU) Las ejecuciones de trabajos flexibles se facturan en función del número de empleados que se ejecutan en un momento dado. Se puede agregar o eliminar el número de trabajadores para una ejecución de trabajo flexible en ejecución. En lugar de facturar como un simple cálculo de `Max Capacity` \$1 `Execution Time`, cada trabajador contribuirá por el tiempo que ejecutó durante la ejecución del trabajo. La factura es la suma de (`Number of DPUs per worker` \$1 `time each worker ran`). Para obtener más información, consulte el panel de ayuda de AWS Studio o [Jobs](aws-glue-api-jobs-job.md) y [Ejecuciones de trabajo](aws-glue-api-jobs-runs.md). **Número de reintentos** Especifique el número de veces, entre 0 y 10, que AWS Glue debe reiniciar automáticamente el flujo de trabajo si se produce un error. Los trabajos que alcanzan el límite de tiempo de espera no se reinician. **Job timeout (Tiempo de espera de flujo de trabajo)** Establece el tiempo de ejecución máximo en minutos. El máximo es de 7 días o 10 080 minutos. De lo contrario, las tareas arrojarán una excepción. Si el valor se deja vacío, el tiempo de espera se establece de forma predeterminada en 2880 minutos. Cualquier trabajo de AWS Glue existente con un valor de tiempo de espera superior a 7 días se establecerá de forma predeterminada en 7 días. Por ejemplo, si especificó un tiempo de espera de 20 días para un trabajo por lotes, este se detendrá el séptimo día. **Prácticas recomendadas para los tiempos de espera de trabajo** Los trabajos se cobran de acuerdo a los tiempos de ejecución. Para evitar costes inesperados, configure los valores de tiempos de espera correctos para el tiempo de ejecución esperado del trabajo. **Propiedades avanzadas** **Nombre de archivo del script** Un nombre de script único para el trabajo. El nombre no puede ser **Trabajo sin nombre**. **Ruta del script** La ubicación del script de Amazon S3. La ruta debe tener el formato `s3://bucket/prefix/path/`. Debe terminar con una barra (`/`) y no debe incluir ningún archivo. **Job metrics (Métricas de trabajo)** Active o desactive la creación de métricas de Amazon CloudWatch cuando se ejecute este trabajo. Para ver los datos de perfiles, debe habilitar esta opción. Para obtener más información acerca de cómo habilitar y visualizar métricas, consulte [Monitorización y depuración de trabajo](monitor-profile-glue-job-cloudwatch-metrics.md). **Métricas de observabilidad de trabajos** Active la creación de métricas de observabilidad adicional de CloudWatch cuando se ejecute el trabajo. Para obtener más información, consulte [Monitorización con métricas de observabilidad de AWS Glue](monitor-observability.md). **Registro continuo** Active el registro continuo en Amazon CloudWatch. Si esta opción no está habilitada, los registros solo estarán disponibles después de que se complete el trabajo. Para obtener más información, consulte [Registro de trabajos de AWS Glue](monitor-continuous-logging.md). **Interfaz de usuario de Spark** Habilite el uso de la interfaz de usuario (UI) de Spark para monitorear este trabajo. Para obtener más información, consulte [Habilitación de la interfaz de usuario web de Apache Spark para trabajos de AWS Glue](monitor-spark-ui-jobs.md). **Ruta de los registros de la interfaz de usuario de Spark** La ruta para escribir registros mientras la interfaz de usuario de Spark está habilitada. **Configuración del registro y el monitoreo de la interfaz de Spark** Elija una de las siguientes opciones: + *Estándar*: escriba registros con la identificación de ejecución de trabajos de AWS Glue como nombre de archivo. Active el monitoreo de la interfaz de usuario de Spark en la consola de AWS Glue. + *Heredado*: escriba registros con el nombre “spark-application-\$1marca de tiempo\$1”. No active el monitoreo de la interfaz de usuario de Spark. + *Estándar y heredado*: escriba registros tanto en las ubicaciones estándar como heredadas. Active el monitoreo de la interfaz de usuario de Spark en la consola de AWS Glue. **Simultaneidad máxima** Establece el número máximo de ejecuciones simultáneas que están permitidas para este flujo de trabajo. El valor predeterminado es 1. Se produce un error cuando se llega a este umbral. El valor máximo que puede especificar se controla mediante un límite de servicio. Por ejemplo, si una ejecución anterior de un trabajo se sigue ejecutando cuando una nueva instancia se inicia, es posible que desee devolver un error al evitar dos instancias de la misma ejecución de trabajo de forma simultánea. **Ruta temporaria** Proporcione la ubicación de un directorio de trabajo en Amazon S3 donde los resultados intermedios temporales se escriben cuando AWS Glue ejecuta el script. Compruebe que no haya un archivo con el mismo nombre que el directorio temporal en la ruta. Este directorio se utiliza cuando AWS Glue lee y escribe en Amazon Redshift y mediante determinadas transformaciones de AWS Glue. AWS Glue crea un bucket temporal para los trabajos si aún no existe un bucket en la región. Este bucket podría permitir el acceso público. Puede modificar el bucket en Amazon S3 para establecer el bloque de acceso público o eliminar el bucket más tarde, después de que se hayan completado todos los trabajos de esa región. **Umbral de notificación de retraso (minutos)** Establece el umbral (en minutos) antes de que se envíe una notificación de retraso. Puede configurar este umbral para enviar notificaciones cuando una ejecución de flujo de trabajo `RUNNING`, `STARTING` o `STOPPING` dure más de un número previsto de minutos. **Configuración de seguridad** Elija una configuración de seguridad de la lista. Una configuración de seguridad especifica cómo se cifran los datos en el destino de Amazon S3: sin cifrado, cifrado del lado del servidor con claves administradas por AWS KMS (SSE-KMS) o claves de cifrado administradas por Amazon S3 (SSE-S3). **Cifrado en el servidor** Si selecciona esta opción, cuando el flujo de trabajo de ETL se escribe en Amazon S3, los datos se cifran en reposo mediante cifrado SSE-S3. Tanto el destino de datos de Amazon S3 como los datos que se escriben en un directorio temporal de Amazon S3 se cifran. Esta opción se pasa como parámetro de trabajo. Para obtener más información, consulte [Protecting Data Using Server-Side Encryption with Amazon S3-Managed Encryption Keys (SSE-S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingServerSideEncryption.html) (Protección de datos mediante el cifrado que se ejecuta en el servidor con las claves de cifrado administradas por Amazon S3 [SSE-S3]) en la *Guía del usuario de Amazon Simple Storage Service*. Esta opción se pasa por alto si se especifica una configuración de seguridad. **Use Glue Data Catalog as the Hive metastore (Utilizar el catálogo de datos de Glue como metaalmacén de Hive)** Seleccione esta opción para usar el AWS Glue Data Catalog como metaalmacén de Hive. El rol de IAM que se utiliza para el trabajo debe tener el permiso `glue:CreateDatabase`. Si no existe una base de datos, se crea una denominada “default (predeterminada)” en el Data Catalog. **Connections** Seleccione una configuración de VPC para acceder a los orígenes de datos de Amazon S3 ubicados en la nube privada virtual (VPC). En AWS Glue, puede crear y administrar la conexión de red. Para obtener más información, consulte [Conexión a datos](glue-connections.md). **Bibliotecas** **La ruta de la biblioteca de Python, la ruta de los archivos JAR dependientes y la ruta de archivos referenciados** Especifique estas opciones si el script las requiere. Puede definir las rutas de Amazon S3 separadas por comas para estas opciones al definir el trabajo. Puede omitir estas rutas al ejecutar el flujo de trabajo. Para obtener más información, consulte [Suministro de sus propios scripts personalizados](console-custom-created.md). **Parámetros del flujo de trabajo** Conjunto de pares de clave-valor que se pasan como parámetros de nombres al script. Estos son valores predeterminados que se utilizan cuando se ejecuta el script, pero se pueden invalidar en desencadenadores o cuando se ejecuta el trabajo. Debe agregar el prefijo `--` al nombre de clave; por ejemplo: `--myKey`. Los parámetros de trabajo se pasan como asignación cuando se utiliza la AWS Command Line Interface. Para obtener ejemplos, consulte los parámetros de Python en [Suministro y acceso a los parámetros de Python en AWS Glue](aws-glue-programming-python-calling.md#aws-glue-programming-python-calling-parameters). **Etiquetas** Etiquete su trabajo con una **Clave de etiqueta** y un **Valor de etiqueta** opcional. Una vez que se crean las claves de etiquetas, son de solo lectura. Utilice etiquetas en algunos recursos para que le resulte más fácil organizarlos e identificarlos. Para obtener más información, consulte [Etiquetas de AWS en AWS Glue](monitor-tags.md). ## Restricciones para trabajos que acceden a tablas administradas por Lake Formation Tenga en cuenta las siguientes notas y restricciones al crear trabajos que lean o escriban en tablas administradas por AWS Lake Formation: + Las siguientes funciones no se soportan en trabajos que acceden a tablas con filtros de nivel de celda: + [Marcadores de trabajo](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html) y [ejecución delimitada](https://docs.aws.amazon.com/glue/latest/dg/bounded-execution.html) + [Predicados de inserción](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html#aws-glue-programming-etl-partitions-pushdowns) + [Predicados de particiones de catálogo del lado del servidor](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html#aws-glue-programming-etl-partitions-cat-predicates) + [enableUpdateCatalog](https://docs.aws.amazon.com/glue/latest/dg/update-from-job.html) # Edición de scripts de Spark en la consola de AWS Glue Los scripts contienen código que extrae datos de orígenes, los transforma y los carga en destinos. AWS Glue ejecuta un script cuando inicia un flujo de trabajo. AWS GlueLos scripts de ETL de pueden codificarse en Python o Scala. Los scripts de Python utilizan un lenguaje que es una extensión del dialecto Python de PySpark para los trabajos de extraer, transformar y cargar (ETL). El script contiene *constructos ampliados* para gestionar las transformaciones de ETL. Al generar automáticamente lógica de código fuente para el flujo de trabajo, se crea un script. Puede editar este script o proporcionar su propio script para procesar el flujo de trabajo de ETL. Para obtener más información acerca de cómo definir y editar scripts en AWS Glue, consulte [Guía de programación de AWS Glue](edit-script.md). ## Bibliotecas o archivos adicionales Si su script requiere bibliotecas o archivos adicionales, puede especificarlos del modo siguiente: **Ruta de la biblioteca Python** Rutas de Amazon Simple Storage Service (Amazon S3) separadas por comas a las bibliotecas de Python requeridas por el script. Solo se pueden utilizar bibliotecas Python puras. Todavía no se admiten las bibliotecas que se basan en las extensiones de C, como la biblioteca de análisis de datos Python pandas. **Ruta de archivos JAR dependientes** Rutas de Amazon S3 separadas por comas a archivos JAR que requiere el script. Actualmente, solo se pueden usar bibliotecas Java o Scala (2.11). **Ruta de archivos a la que se hace referencia** Rutas de Amazon S3 separadas por comas a archivos adicionales (por ejemplo, archivos de configuración) requeridas por el script. # Trabajos (heredado) Los scripts contienen el código que lleva a cabo el flujo de trabajo de extraer, transformar y cargar (ETL). Puede suministrar su propio script o bien, AWS Glue puede generarlo con su ayuda. Para obtener información sobre la creación de sus propios scripts, consulte [Suministro de sus propios scripts personalizados](console-custom-created.md). Puede editar scripts en la consola de AWS Glue. Cuando edite scripts, podrá añadir orígenes, destinos y transformaciones. **Para editar un script** 1. Inicie sesión en la Consola de administración de AWS y abra la consola de AWS Glue en [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). Después, seleccione pestaña **Jobs** (Trabajos). 1. Seleccione un flujo de trabajo de la lista y, a continuación, seleccione **Action** (Acción), **Edit script** (Editar script) para abrir el editor de scripts. También puede acceder al editor de scripts desde la página de detalles del flujo de trabajo. Elija la pestaña **Script**, y luego elija **Edit script (Editar script)**. ## Editor de scripts Con el editor de scripts de AWS Glue, puede insertar, modificar y eliminar orígenes, destinos y transformaciones en el script. El editor de scripts muestra el script y un diagrama para ayudarle a visualizar el flujo de datos. Para crear un diagrama para el script, elija **Generate diagram (Genera diagrama)**. AWS Glue utiliza líneas de anotación en el script que comienzan con **\$1 \$1** para representar el diagrama. Para representar correctamente el script en el diagrama, debe tener sincronizados los parámetros de las anotaciones y los parámetros del código de Apache Spark. Con el editor de scripts, puede añadir plantillas de código cuando el cursor esté sobre el script. En la parte superior del editor, seleccione las opciones que correspondan: + Para agregar una tabla de orígenes al script, seleccione **Source** (Origen). + Para agregar una tabla de destinos al script, seleccione **Target** (Destino). + Para agregar una ubicación de destino al script, seleccione **Target location** (Ubicación de destino). + Para agregar una transformación al script, seleccione **Transform** (Transformación). Para obtener información sobre las funciones que se invocan en el script, consulte [Programación de scripts de ETL de AWS Glue en PySpark](aws-glue-programming-python.md). + Para agregar una transformación de espiga al script, seleccione **Spigot** (Espiga). En el código insertado, modifique `parameters` en las anotaciones y el código de Apache Spark. Por ejemplo, si añade una transformación **Spigot** (Espiga), compruebe que `path` se sustituirá tanto en la anotación `@args` como en la línea de código `output`. La pestaña **Logs** (Registros) muestra los registros que están asociados con el flujo de trabajo mientras se ejecuta. Aparecen las últimas 1000 líneas. La pestaña **Schema (Esquema)** muestra el esquema de los orígenes y los destinos seleccionados, cuando están disponibles en el Data Catalog. # Seguimiento de los datos procesados mediante marcadores de trabajo AWS Glue realiza un seguimiento de los datos que ya se han procesado durante una ejecución anterior de un trabajo de ETL mediante información de estado persistente de la ejecución del trabajo. Esta información de estado persistente se llama *marcador de flujo de trabajo*. Los marcadores de trabajo ayudan a AWS Glue a mantener la información de estado y evitar el reprocesamiento de los datos antiguos. Con los marcadores de trabajo, puede procesar datos nuevos al volver a realizar una ejecución en un intervalo programado. Un marcador de trabajo se compone de los estados de diversos elementos de trabajos, como orígenes, transformaciones y destinos. Por ejemplo, su trabajo de ETL podría leer nuevas particiones en un archivo de Amazon S3. AWS Glue hace el seguimiento de las particiones que el trabajo ha procesado correctamente para evitar procesamiento y datos duplicados en el almacén de datos de destino del trabajo. Los marcadores de trabajo se implementan para los orígenes de datos JDBC, la transformación Relationalize (Establecimiento de relaciones) y algunos orígenes Amazon Simple Storage Service (Amazon S3). En la siguiente tabla se muestran los formatos de origen Amazon S3 que AWS Glue soporta para los marcadores del trabajo. | Versión de AWS Glue | Formatos de origen de Amazon S3 | | --- | --- | | Versión 0.9 | JSON, CSV, Apache Avro, XML | | Versión 1.0 y posteriores. | JSON, CSV, Apache Avro, XML, Parquet, ORC | Para obtener información acerca de las versiones de AWS Glue, consulte [Definición de propiedades de trabajo para trabajos de Spark](add-job.md#create-job). La característica de marcadores de trabajo tiene funcionalidades adicionales cuando se accede a ella a través de scripts AWS Glue. Al navegar por el script generado, es posible que vea contextos de transformación relacionados con esta característica. Para obtener más información, consulte [Uso de marcadores de trabajo](programming-etl-connect-bookmarks.md). **Topics** + [Uso de marcadores de trabajo en AWS Glue](#monitor-continuations-implement) + [Detalles operativos de la característica de marcadores de trabajo](#monitor-continuations-script) ## Uso de marcadores de trabajo en AWS Glue La opción de marcador de trabajo se transfiere como parámetro al iniciarse el trabajo. En la siguiente tabla se describen las opciones para la configuración de marcadores de trabajo en la consola de AWS Glue. **** | Job bookmark (Marcador de flujo de trabajo) | Descripción | | --- | --- | | Habilitado | Hace que el trabajo actualice el estado después de una ejecución para realizar un seguimiento de datos procesados anteriormente. Si el trabajo tiene un origen con compatibilidad de marcador de trabajo, realizará un seguimiento de los datos procesados y cuando se ejecute un trabajo, procesará datos nuevos desde el último punto de control. | | Deshabilitado | Los marcadores de trabajo no se utilizan y el trabajo siempre procesa todo el conjunto de datos. Usted es responsable de administrar el resultado de las ejecuciones de trabajos anteriores. Esta es la opción predeterminada. | | Pause | Procesar los datos incrementales desde la última ejecución correcta o los datos en el rango identificado por las siguientes subopciones, sin actualizar el estado del último marcador. Usted es responsable de administrar el resultado de las ejecuciones de trabajos anteriores. Las dos subopciones son: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitor-continuations.html) El estado del marcador de trabajo no se actualiza cuando se especifica este conjunto de opciones. Las subopciones son opcionales; sin embargo, cuando se utilizan ambas opciones, se deben proporcionar. | Para obtener información detallada sobre los parámetros transferidos a un trabajo en la línea de comandos y para los marcadores de trabajo específicamente, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md). Para orígenes de entrada de Amazon S3, los marcadores de trabajo de AWS Glue comprueban la hora de última modificación de los objetos para verificar qué objetos deben volver a procesarse. Si los datos de origen de entrada se han modificado desde la última ejecución de trabajo, los archivos se vuelven a procesar al ejecutar el trabajo de nuevo. Para los orígenes JDBC, se aplican las reglas siguientes: + Para cada tabla, AWS Glue utiliza una o más columnas como claves de marcador para determinar los datos nuevos y procesados. Las claves de marcador se combinan para formar una única clave compuesta. + AWS Glue utiliza la clave principal como clave de marcador de forma predeterminada, siempre que aumente o disminuya secuencialmente (sin espacios). + Puede especificar las columnas que se van a utilizar como claves de marcador en el script de AWS Glue. Para obtener más información sobre el uso de marcadores de trabajo en scripts de AWS Glue, consulte [Uso de marcadores de trabajo](programming-etl-connect-bookmarks.md). + AWS Glue no admite el uso de columnas con nombres que distinguen mayúsculas de minúsculas como claves de marcadores de trabajo. Puede retroceder sus marcadores de trabajo para sus trabajos de Spark ETL de AWS Glue a cualquier ejecución de trabajo anterior. Puede admitir escenarios de reposición de datos mejor al rebobinar sus marcadores de trabajo a cualquier ejecución de trabajo anterior reprocesando los datos solo desde la ejecución del trabajo marcado. Si va a volver a procesar todos los datos utilizando el mismo trabajo, restablezca el marcador de trabajo. Para restablecer el estado del marcador de trabajo, utilice la consola de AWS Glue, la [Acción ResetJobBookmark (Python: reset\$1job\$1bookmark)](aws-glue-api-jobs-runs.md#aws-glue-api-jobs-runs-ResetJobBookmark)operación de API o AWS CLI. Por ejemplo, escriba el siguiente comando usando AWS CLI: ``` aws glue reset-job-bookmark --job-name my-job-name ``` Al retroceder o restablecer un marcador, AWS Glue no limpia los archivos de destino porque podría haber varios destinos y los destinos no se rastrean con marcadores de trabajo. Sólo los archivos de origen se rastrean con marcadores de trabajo. Puede crear diferentes destinos de salida al retroceder y reprocesar los archivos de origen para evitar datos duplicados en la salida. AWS Glue realiza el seguimiento de los marcadores de flujo de trabajo para cada flujo de trabajo. Si elimina un flujo de trabajo, el marcador de flujo de trabajo se elimina. En algunos casos, es posible que tenga habilitados marcadores de trabajo de AWS Glue, pero su trabajo de ETL está reprocesando los datos que ya se han procesado anteriormente. Para obtener información acerca de la resolución de causas comunes de este error, consulte [Solución de problemas de configuración comunes de Glue](glue-troubleshooting-errors.md). ## Detalles operativos de la característica de marcadores de trabajo En esta sección se describen más detalles operativos de utilizar marcadores de trabajo. Los marcadores de trabajo almacenan los estados de un trabajo. Cada instancia del estado está marcada con un nombre de trabajo y un número de versión. Cuando un script invoca `job.init`, recupera su estado y siempre obtiene la última versión. Dentro de un estado, hay varios elementos de estado, que son específicos de cada origen, transformación e instancia de receptor en el script. Estos elementos de estado se identifican mediante un contexto de transformación que se adjunta al elemento correspondiente (origen, transformación o receptor) en el script. Los elementos de estado se guardan de manera granular cuando `job.commit` se haya invocado desde el script de usuario. El script obtiene el nombre del trabajo y la opción de control de los marcadores de trabajo de los argumentos. Los elementos de estado del marcador de trabajo son datos específicos de origen, transformación o receptor. Por ejemplo, supongamos que desea leer los datos progresivos desde una ubicación de Amazon S3 a la que un proceso o trabajo ascendente escribe en forma constante. En este caso, el script debe determinar qué se ha procesado hasta el momento. La implementación de marcador de trabajo para el origen de Amazon S3 guarda la información para que cuando el trabajo se ejecute de nuevo, pueda filtrar solo los nuevos objetos mediante la información guardada y recalcular el estado para la próxima ejecución del trabajo. Se utiliza una marca temporal para filtrar los archivos nuevos. Además de los elementos de estado, los marcadores de trabajo tienen un *número de ejecución*, un *número de intentos* y un *número de versión*. El número de ejecución realiza un seguimiento de la ejecución del trabajo y el número de intentos registra los intentos de ejecución de un trabajo. El número de ejecuciones de un trabajo es un número que se incrementa de forma monotónica por cada ejecución correcta. El número de intentos realiza un seguimiento de los intentos de cada ejecución y solo se incrementa cuando hay una ejecución después de un intento fallido. El número de versión aumenta de forma monotónica y realiza un seguimiento de las actualizaciones de un marcador de trabajo. En la base de datos del servicio AWS Glue, los estados de favorito de todas las transformaciones se almacenan juntos como pares clave-valor: ``` { "job_name" : ..., "run_id": ..., "run_number": .., "attempt_number": ... "states": { "transformation_ctx1" : { bookmark_state1 }, "transformation_ctx2" : { bookmark_state2 } } } ``` **Prácticas recomendadas** A continuación, se indican las prácticas recomendadas para utilizar marcadores de trabajo. + *No cambie la propiedad del origen de datos con el favorito habilitado.* Por ejemplo, hay un origen de datos datasource0 que apunta a una ruta de entrada A de Simple Storage Service (Amazon S3), y el trabajo ha estado leyendo desde un origen que se ha estado ejecutando durante varias rondas con el favorito habilitado. Si cambia la ruta de entrada de datasource0 a la ruta B de Simple Storage Service (Amazon S3) sin cambiar `transformation_ctx`, el trabajo de AWS Glue utilizará el antiguo estado de favorito almacenado. Eso provocará que se omitan o falten archivos en la ruta de entrada B, ya que AWS Glue presupondrá que esos archivos se han procesado en ejecuciones anteriores. + *Utilice una tabla de catálogo con favoritos para mejorar la administración de particiones.* Los favoritos funcionan para orígenes de datos de Data Catalog o de opciones. No obstante, resulta difícil eliminar/agregar nuevas particiones con el enfoque de opciones. Utilizar una tabla de catálogo con rastreadores puede proporcionar una mejor automatización para realizar un seguimiento de las nuevas [particiones](https://docs.aws.amazon.com/glue/latest/dg/tables-described.html#tables-partition) agregadas, y ofrece flexibilidad para seleccionar particiones concretas con un [predicado de inserción](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html). + *Utilice el [enumerador de archivos de Simple Storage Service (Amazon S3) de AWS Glue](https://aws.amazon.com/premiumsupport/knowledge-center/glue-oom-java-heap-space-error/) para conjuntos de datos de gran tamaño.* Un favorito mostrará una lista de todos los archivos de cada partición de entrada y realizará el filtrado, de modo que, si hay demasiados archivos en una sola partición, puede que el controlador del favorito se quede sin suficiente memoria. Utilice el enumerador de archivos de Simple Storage Service (Amazon S3) de AWS Glue para evitar mostrar una lista de todos los archivos de la memoria a la vez. # Almacenamiento de datos de mezclas aleatorias de Spark El mezclado aleatorio es un paso importante en un trabajo de Spark siempre que los datos se reorganizan entre particiones. Esto es necesario porque transformaciones de gran extensión como `join`, ` groupByKey`, `reduceByKey`, y `repartition` requieren información de otras particiones para completar el procesamiento. Spark recopila los datos requeridos de cada partición y los combina en una nueva partición. Durante una mezcla aleatoria, los datos se escriben en el disco y se transfieren a través de la red. Como resultado, la operación de mezcla aleatoria está vinculada a la capacidad del disco local. Spark lanza un error `No space left on device` o ` MetadataFetchFailedException` cuando no queda suficiente espacio en disco en el ejecutor y no se puede realizar la recuperación. **nota** El complemento AWS Glue Spark shuffle de Amazon S3 solo es compatible con los trabajos de ETL AWS Glue. **Solución** Con AWS Glue, ahora puede utilizar Amazon S3 para almacenar datos de mezclas aleatorias de Spark. Amazon Simple Storage Service (Amazon S3) es un servicio de almacenamiento de objetos que ofrece escalabilidad, disponibilidad de datos, seguridad y rendimiento líderes del sector. Esta solución separa la informática y el almacenamiento para sus trabajos de Spark y proporciona una elasticidad completa y un almacenamiento de mezclas aleatorias de bajo costo, lo que le permite ejecutar con confianza sus cargas de trabajo con mayor cantidad de mezclas aleatorias. ![\[Spark workflow showing Map and Reduce stages using Amazon S3 for shuffle data storage.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/gs-s3-shuffle-diagram.png) Presentamos Cloud Shuffle Storage, un nuevo complemento para Apache Spark para usar Amazon S3. Puede habilitar la función de mezclado aleatorio de Amazon S3 para ejecutar sus trabajos de AWS Glue con confianza y sin errores si se sabe que están vinculados por la capacidad del disco local para operaciones de mezclas aleatorias grandes. En algunos casos, el mezclado aleatorio en Amazon S3 es ligeramente más lento que el disco local (o EBS) si tiene un gran número de pequeñas particiones o archivos de mezcla aleatoria escritos en Amazon S3. ## Requisitos previos para usar el complemento de almacenamiento de Cloud Shuffle Para usar el complemento de almacenamiento de Cloud Shuffle con trabajos de AWS Glue ETL, necesita lo siguiente: + Un bucket de Amazon S3 ubicado en la misma región en la que se ejecutó el trabajo, para almacenar los datos intermedios mezclados y volcados. El prefijo Amazon S3 del almacenamiento aleatorio se puede especificar con `--conf spark.shuffle.glue.s3ShuffleBucket=s3://shuffle-bucket/prefix/`, como en el siguiente ejemplo: ``` --conf spark.shuffle.glue.s3ShuffleBucket=s3://glue-shuffle-123456789-us-east-1/glue-shuffle-data/ ``` + Establezca las políticas de ciclo de vida de almacenamiento de Amazon S3 en el *prefijo* (como `glue-shuffle-data`) ya que el administrador de mezclas aleatorias no limpia los archivos una vez finalizado el trabajo. Los datos intermedios mezclados y volcados se deben eliminar una vez finalizado el trabajo. Los usuarios pueden establecer políticas de ciclo de vida breves en el prefijo. Las instrucciones para configurar la política de ciclo de vida de Amazon S3 están disponibles en [Configurar el ciclo de vida de un bucket](https://docs.aws.amazon.com//AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) en la Guía del usuario de Amazon Simple Storage Service. ## Uso del administrador de mezclas aleatorias de AWS Glue Spark desde la consola de AWS Para configurar el administrador de mezclas aleatorias de AWS Glue Spark con la consola de AWS Glue o AWS Glue Studio cuando configura un trabajo: elija el parámetro de trabajo: **--write-shuffle-files-to-s3** para habilitar el mezclado aleatorio de Amazon S3 para el trabajo. ![\[Job parameters interface showing --write-shuffle-files- parameter and option to add more.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/gs-s3-shuffle.png) ## Uso del complemento de mezclas aleatorias de AWS Glue Spark Los siguientes parámetros de trabajo activan y establecen los ajustes del administrador de mezclas aleatorias de AWS Glue. Estos parámetros son indicadores, por lo que no se tienen en cuenta los valores proporcionados. + `--write-shuffle-files-to-s3`: el valor de la marca principal habilita la opción del administrador de mezclas aleatorias de AWS Glue Spark para utilizar buckets de Amazon S3 para escribir y leer datos aleatorios. Cuando la marca no se especifica, no se utiliza el administrador de mezclas aleatorias. + `--write-shuffle-spills-to-s3`: (solo se admite en la versión 2.0 de AWS Glue). Una marca opcional que permite descargar archivos de volcado en buckets de Amazon S3, lo que proporciona resistencia adicional al trabajo de Spark. Esto solo es necesario para cargas de trabajo grandes que provocan grandes desbordamientos al disco. Cuando no se especifica la marca, no se graba ningún archivo de volcado intermedio. + ` --conf spark.shuffle.glue.s3ShuffleBucket=s3://`: otra marca opcional que especifica el bucket de Amazon S3 en el que se escriben los archivos de mezcla aleatoria. De forma predeterminada, `--TempDir`/shuffle-data. AWS Glue 3.0\$1 permite escribir archivos aleatorios en varios buckets al especificar los buckets con un delimitador de comas, como en `--conf spark.shuffle.glue.s3ShuffleBucket=s3://shuffle-bucket-1/prefix,s3://shuffle-bucket-2/prefix/`. El uso de varios buckets mejora el rendimiento. Debe proporcionar los ajustes de configuración de seguridad para habilitar el cifrado en reposo de los datos aleatorios. Para obtener más información sobre las configuraciones de seguridad, consulte [Configuración del cifrado en AWS Glue](set-up-encryption.md). AWS Glue admite todas las demás configuraciones relacionadas con mezclas aleatorias proporcionadas por Spark. **Archivos binarios del software para el complemento Cloud Shuffle Storage** También puede descargar los archivos binarios del software del complemento Cloud Shuffle Storage para Apache Spark bajo la licencia Apache 2.0 y ejecutarlo en cualquier entorno de Spark. El nuevo complemento incluye compatibilidad lista para usar con Amazon S3 y también se puede configurar fácilmente para usar otras formas de almacenamiento en la nube, como [Google Cloud Storage y Microsoft Azure Blob Storage](https://github.com/aws-samples/aws-glue-samples/blob/master/docs/cloud-shuffle-plugin/README.md). Para obtener más información, consulte [Cloud Shuffle Storage Plugin for Apache Spark](https://docs.aws.amazon.com/glue/latest/dg/cloud-shuffle-storage-plugin.html) (Complemento Cloud Shuffle Storage para Apache Spark). **Notas y limitaciones** Las siguientes son notas o limitaciones para el administrador de mezclas aleatorias de AWS Glue: + El administrador de mezclas aleatorias AWS Glue no elimina automáticamente los archivos de datos de mezcla aleatoria (temporales) almacenados en un bucket de Amazon S3 después de completar un trabajo. Para garantizar la protección de los datos, siga las instrucciones que se indican en [Requisitos previos para usar el complemento de almacenamiento de Cloud Shuffle](#monitor-spark-shuffle-manager-prereqs) antes de activar el complemento Cloud Shuffle Storage Plugin. + Puede utilizar esta característica si los datos están sesgados. # Complemento Cloud Shuffle Storage para Apache Spark El complemento Cloud Shuffle Storage es un complemento de Apache Spark compatible con la [API de `ShuffleDataIO`](https://github.com/apache/spark/blob/master/core/src/main/java/org/apache/spark/shuffle/api/ShuffleDataIO.java) que permite almacenar datos aleatorios en sistemas de almacenamiento en la nube (como Amazon S3). Ayuda a complementar o reemplazar la capacidad de almacenamiento del disco local para operaciones aleatorias de gran tamaño que suelen desencadenarse por transformaciones como `join`, `reduceByKey`, `groupByKey` y `repartition` en las aplicaciones de Spark, lo que reduce los errores comunes o la dislocación de precio y rendimiento de las canalizaciones y los trabajos de análisis de datos sin servidor. **AWS Glue** Las versiones 3.0 y 4.0 de AWS Glue incluyen el complemento preinstalado y listo para permitir la transferencia aleatoria a Amazon S3 sin ningún paso adicional. Para más información, consulte [Complemento de mezclas aleatorias de Spark para AWS Glue con Amazon S3](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-shuffle-manager.html) para habilitar la característica en las aplicaciones de Spark. **Otros entornos de Spark** El complemento requiere que se establezcan las siguientes configuraciones de Spark en otros entornos de Spark: + `--conf spark.shuffle.sort.io.plugin.class=com.amazonaws.spark.shuffle.io.cloud.ChopperPlugin`: esto indica a Spark que debe utilizar este complemento para Shuffle IO. + `--conf spark.shuffle.storage.path=s3://bucket-name/shuffle-file-dir`: la ruta en la que se almacenarán los archivos aleatorios. **nota** El complemento sobrescribe una clase principal de Spark. Como resultado, el contenedor del complemento debe cargarse antes que los contenedores de Spark. Para ello, utilice `userClassPathFirst` en entornos YARN locales si el complemento se utiliza fuera de AWS Glue. ## Agrupación del complemento con las aplicaciones de Spark Puede combinar el complemento con las aplicaciones de Spark y distribuciones de Spark (versiones 3.1 y posteriores) si agrega la dependencia del complemento en `pom.xml` de Maven mientras desarrolla las aplicaciones de Spark de manera local. Para más información acerca del complemento y las versiones de Spark, consulte [Versiones del complemento](#cloud-shuffle-storage-plugin-versions). ``` ... aws-glue-etl-artifacts https://aws-glue-etl-artifacts.s3.amazonaws.com/release/ ... com.amazonaws chopper-plugin 3.1-amzn-LATEST ``` También puede descargar los archivos binarios de los artefactos de Maven de AWS Glue directamente e incluirlos en la aplicación de Spark de la siguiente manera. ``` #!/bin/bash sudo wget -v https://aws-glue-etl-artifacts.s3.amazonaws.com/release/com/amazonaws/chopper-plugin/3.1-amzn-LATEST/chopper-plugin-3.1-amzn-LATEST.jar -P /usr/lib/spark/jars/ ``` Ejemplo spark-submit ``` spark-submit --deploy-mode cluster \ --conf spark.shuffle.storage.s3.path=s3:/// \ --conf spark.driver.extraClassPath= \ --conf spark.executor.extraClassPath= \ --class s3:/// \ ``` ## Opciones de configuración opcionales Estos son los valores de las opciones de configuración opcionales que controlan el comportamiento aleatorio de Amazon S3. + `spark.shuffle.storage.s3.enableServerSideEncryption`: habilita y desactiva SSE de S3 para ordenar aleatoriamente y volcar archivos. El valor predeterminado es `true`. + `spark.shuffle.storage.s3.serverSideEncryption.algorithm`: el algoritmo de SSE que se va a usar. El valor predeterminado es `AES256`. + `spark.shuffle.storage.s3.serverSideEncryption.kms.key`: el ARN de la clave de KMS cuando aws:kms de SSE está activado. Junto con estas configuraciones, es posible que deba establecer configuraciones como`spark.hadoop.fs.s3.enableServerSideEncryption`, y **otras configuraciones específicas del entorno** para garantizar que se aplique el cifrado adecuado para su caso de uso. ## Versiones del complemento Este complemento es compatible con las versiones de Spark asociadas a cada versión de AWS Glue. En la siguiente tabla, se muestra la versión de AWS Glue, la versión de Spark y la versión del complemento asociada a la ubicación de Amazon S3 del binario de software del complemento. | Versión de AWS Glue | Versión de Spark | Versión del complemento | Ubicación de Amazon S3 | | --- | --- | --- | --- | | 3.0 | 3.1 | 3.1-amzn-LATEST | s3://aws-glue-etl-artifacts/release/com/amazonaws/chopper-plugin/3.1-amzn-0/chopper-plugin-3.1-amzn-LATEST.jar | | 4.0 | 3.3 | 3.3-amzn-LATEST | s3://aws-glue-etl-artifacts/release/com/amazonaws/chopper-plugin/3.3-amzn-0/chopper-plugin-3.3-amzn-LATEST.jar | ## Licencia El binario de software de este complemento cuenta con la licencia de Apache-2.0. # Supervisión de trabajos de Spark de AWS Glue **Topics** + [Métricas de Spark disponibles en AWS Glue Studio](#console-jobs-details-metrics-spark) + [Monitorización de trabajos mediante la interfaz de usuario web de Apache Spark](monitor-spark-ui.md) + [Supervisión con Información de ejecuciones de trabajos de AWS Glue](monitor-job-insights.md) + [Supervisión con Amazon CloudWatch](monitor-cloudwatch.md) + [Monitorización y depuración de trabajo](monitor-profile-glue-job-cloudwatch-metrics.md) ## Métricas de Spark disponibles en AWS Glue Studio La pestaña **Metrics (Métricas)** muestra las métricas recopiladas cuando se ejecuta un trabajo y se habilita la creación de perfiles. En los trabajos de Spark se muestran los gráficos siguientes: + Movimiento de datos de ETL + Perfil de la memoria: controlador y ejecutores Elija **View additional metrics (Ver métricas adicionales)** para mostrar los siguientes gráficos: + Movimiento de datos de ETL + Perfil de la memoria: controlador y ejecutores + Mezcla de datos entre los ejecutores + Carga de la CPU: controlador y ejecutores + Ejecución de trabajo: ejecutores activos, etapas completadas y número máximo de ejecutores necesarios Los datos de estos gráficos se insertan en las métricas de CloudWatch si el trabajo se configura para recopilar métricas. Para obtener más información acerca de cómo habilitar métricas e interpretar los gráficos, consulte [Monitorización y depuración de trabajo](monitor-profile-glue-job-cloudwatch-metrics.md). **Example Gráfico de movimiento de datos de ETL** En el gráfico de movimiento de datos de ETL se muestran las siguientes métricas: + El número de bytes que leen todos los ejecutores de Amazon S3—[`glue.ALL.s3.filesystem.read_bytes`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) + El número de bytes que escriben todos los ejecutores en Amazon S3—[`glue.ALL.s3.filesystem.write_bytes`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes) ![\[El gráfico de movimiento de datos de ETL en la pestaña Metrics (Métricas) de la consola de AWS Glue.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/job_detailed_etl.png) **Example Gráfico de perfil de la memoria** En el gráfico de perfil de la memoria se muestran las siguientes métricas: + La fracción de la memoria usada por el montón de JVM para este controlador (escala: de 0 a 1), un ejecutor identificado por *executorId*, o todos los ejecutores. + [`glue.driver.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.jvm.heap.usage) + [`glue.executorId.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.usage) + [`glue.ALL.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage) ![\[El gráfico de perfil de la memoria en la pestaña Metrics (Métricas) de la consola de AWS Glue.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/job_detailed_mem.png) **Example Gráfico de mezcla de datos entre los ejecutores** En el gráfico Mezcla de datos entre los ejecutores se muestran las siguientes métricas: + El número de bytes que leen todos los ejecutores para mezclar los datos entre ellos: [`glue.driver.aggregate.shuffleLocalBytesRead`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleLocalBytesRead) + El número de bytes que escriben todos los ejecutores para mezclar los datos entre ellos: [`glue.driver.aggregate.shuffleBytesWritten`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleBytesWritten) ![\[El gráfico de mezcla de datos entre los ejecutores en la pestaña Metrics (Métricas) de la consola de AWS Glue.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/job_detailed_data.png) **Example Gráfico de carga de la CPU** En el gráfico de carga de la CPU se muestran las siguientes métricas: + La fracción de la carga del sistema de CPU usada (escala: de 0 a 1) por el controlador, un ejecutor identificado por *executorId*, o todos los ejecutores. + [`glue.driver.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.system.cpuSystemLoad) + [`glue.executorId.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.system.cpuSystemLoad) + [`glue.ALL.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.system.cpuSystemLoad) ![\[Gráfico de carga de la CPU en la pestaña Metrics (Métricas) de la consola de AWS Glue.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/job_detailed_cpu.png) **Example Gráfico de ejecución de trabajo** En el gráfico de ejecución de trabajo se muestran las siguientes métricas: + El número de ejecutores que se ejecutan activamente: [`glue.driver.ExecutorAllocationManager.executors.numberAllExecutors`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors) + El número de etapas completadas: [`glue.aggregate.numCompletedStages`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.numCompletedStages) + El número máximo de ejecutores necesarios: [`glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors) ![\[El gráfico de ejecución de trabajo en la pestaña Metrics (Métricas) de la consola de AWS Glue.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/job_detailed_exec.png) # Monitorización de trabajos mediante la interfaz de usuario web de Apache Spark Puede utilizar la interfaz de usuario web de Apache Spark para monitorizar y depurar trabajos de ETL AWS Glue que se ejecutan en el sistema de trabajos AWS Glue, así como aplicaciones de Spark que se ejecutan en puntos de enlace de desarrollo AWS Glue. La interfaz de usuario de Spark le permite comprobar lo siguiente para cada trabajo: + La escala de tiempo del evento de cada etapa de Spark + Un gráfico acíclico dirigido (DAG) del trabajo + Planes físicos y lógicos para consultas de SparkSQL + Las variables de entorno de Spark subyacentes para cada trabajo Para obtener más información sobre el uso de la interfaz de usuario web de Spark, consulta la [Interfaz de usuario web](https://spark.apache.org/docs/3.3.0/web-ui.html) en la documentación de Spark. Para obtener orientación sobre cómo interpretar los resultados de la interfaz de usuario de Spark para mejorar el rendimiento de su trabajo, consulte las [Prácticas recomendadas para ajustar el rendimiento de AWS Glue para los trabajos de Apache Spark](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/introduction.html) en las Recomendaciones de AWS. Puede ver la interfaz de usuario de Spark en la consola de AWS Glue. Está disponible cuando un trabajo de AWS Glue se ejecuta en la versión 3.0 o versiones posteriores de AWS Glue y los registros se generan en el formato estándar (en lugar del heredado), que es el predeterminado para los trabajos más recientes. Si tiene archivos de registro de más de 0,5 GB, puede activar la compatibilidad con el registro continuo para las ejecuciones de trabajos en la versión 4.0 o versiones posteriores de AWS Glue para simplificar el archivado de registros, el análisis y la solución de problemas. Puede habilitar la interfaz de usuario de Spark mediante la consola de AWS Glue o la AWS Command Line Interface (AWS CLI). Al habilitar la interfaz de usuario de Spark, los trabajos de ETL de AWS Glue y las aplicaciones de Spark en puntos de conexión de desarrollo de AWS Glue pueden hacer una copia de seguridad de los registros de eventos de Spark en una ubicación que especifique en Amazon Simple Storage Service (Amazon S3). Los registros de eventos respaldados en Amazon S3 se pueden utilizar con la interfaz de usuario de Spark tanto en tiempo real mientras se está ejecutando el trabajo como después de que se haya completado el trabajo. Mientras los registros permanezcan en Amazon S3, la interfaz de usuario de Spark de la consola de AWS Glue puede verlos. ## Permisos Para utilizar la interfaz de usuario de Spark en la consola de AWS Glue, puede utilizar `UseGlueStudio` o agregar todas las API de servicios individuales. Para utilizar la interfaz de Spark, todas las API son necesarias; sin embargo, los usuarios pueden acceder a las características de la interfaz de Spark al agregar sus API de servicio en el permiso de IAM para un acceso detallado. `RequestLogParsing` es la más importante, ya que realiza el análisis de los registros. Las API restantes realizan la lectura de los respectivos datos analizados. Por ejemplo, `GetStages` brinda acceso a los datos sobre las etapas de un trabajo de Spark. La lista de las API de servicio de la interfaz de usuario de Spark elaboradas para `UseGlueStudio` se encuentra a continuación, en la política de muestra. La política a continuación brinda acceso para que solo se utilicen las características de la interfaz de Spark. Para agregar más permisos, como Amazon S3 e IAM, consulte [Creación de políticas de IAM personalizadas para AWS Glue Studio.](https://docs.aws.amazon.com/glue/latest/dg/getting-started-min-privs.html#getting-started-all-gs-privs.html) La lista de las API de servicio de la interfaz de usuario de Spark elaboradas para `UseGlueStudio` se encuentra a continuación, en la política de muestra. Al utilizar una API de servicio de la interfaz de Spark, utilice el espacio de nombre `glue:`. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowGlueStudioSparkUI", "Effect": "Allow", "Action": [ "glue:RequestLogParsing", "glue:GetLogParsingStatus", "glue:GetEnvironment", "glue:GetJobs", "glue:GetJob", "glue:GetStage", "glue:GetStages", "glue:GetStageFiles", "glue:BatchGetStageFiles", "glue:GetStageAttempt", "glue:GetStageAttemptTaskList", "glue:GetStageAttemptTaskSummary", "glue:GetExecutors", "glue:GetExecutorsThreads", "glue:GetStorage", "glue:GetStorageUnit", "glue:GetQueries", "glue:GetQuery" ], "Resource": [ "*" ] } ] } ``` ------ ## Limitaciones + La interfaz de usuario de Spark en la consola de AWS Glue no está disponible para los trabajos ejecutados antes del 20 de noviembre de 2023, ya que están en el formato de registro heredado. + La interfaz de usuario de Spark en la consola de AWS Glue admite los registros continuos de la versión 4.0 de AWS Glue, como los que se generan de forma predeterminada en los trabajos de streaming. La suma máxima de todos los archivos de eventos de registro continuo generados es de 2 GB. Para los trabajos de AWS Glue que no admiten registros continuos, el tamaño máximo del archivo de eventos de registro que admite SparkUI es de 0,5 GB. + La interfaz de usuario de Spark sin servidor no está disponible para los registros de eventos de Spark almacenados en un bucket de Amazon S3 al que solo puede acceder su VPC. ## Ejemplo: interfaz de usuario web de Apache Spark Este ejemplo le muestra cómo utilizar la interfaz de usuario de Spark para entender su desempeño laboral. Las capturas de pantalla muestran la interfaz de usuario web de Spark proporcionada por un servidor de historial de Spark autogestionado. La interfaz de usuario de Spark en la consola de AWS Glue ofrece vistas similares. Para obtener más información sobre el uso de la interfaz de usuario web de Spark, consulta la [Interfaz de usuario web](https://spark.apache.org/docs/3.3.0/web-ui.html) en la documentación de Spark. A continuación, se muestra un ejemplo de una aplicación Spark que lee desde dos orígenes de datos, realiza una transformación de combinación y la escribe en Amazon S3 en formato Parquet. ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job from pyspark.sql.functions import count, when, expr, col, sum, isnull from pyspark.sql.functions import countDistinct from awsglue.dynamicframe import DynamicFrame args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME']) df_persons = spark.read.json("s3://awsglue-datasets/examples/us-legislators/all/persons.json") df_memberships = spark.read.json("s3://awsglue-datasets/examples/us-legislators/all/memberships.json") df_joined = df_persons.join(df_memberships, df_persons.id == df_memberships.person_id, 'fullouter') df_joined.write.parquet("s3://aws-glue-demo-sparkui/output/") job.commit() ``` La siguiente visualización del DAG muestra las diferentes etapas de este trabajo de Spark. ![\[Captura de pantalla de la interfaz de usuario de Spark que muestra 2 etapas completadas para el trabajo 0.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/spark-ui1.png) La siguiente escala de tiempo de eventos para un trabajo muestra el inicio, la ejecución y la terminación de diferentes ejecutores de Spark. ![\[Captura de pantalla de la interfaz de usuario de Spark que muestra las etapas completadas, fallidas y activas de los diferentes ejecutores de Spark.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/spark-ui2.png) En la siguiente pantalla se muestran los detalles de los planes de consulta de SparkSQL: + Plan lógico examinado + Plan lógico analizado + Plan lógico optimizado + Plan físico para la ejecución ![\[Planes de consulta de SparkSQL: planes físicos y planes físicos examinados, analizados y optimizados para su ejecución.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/spark-ui3.png) **Topics** + [Permisos](#monitor-spark-ui-limitations-permissions) + [Limitaciones](#monitor-spark-ui-limitations) + [Ejemplo: interfaz de usuario web de Apache Spark](#monitor-spark-ui-limitations-example) + [Habilitación de la interfaz de usuario web de Apache Spark para trabajos de AWS Glue](monitor-spark-ui-jobs.md) + [Lanzamiento del servidor de historial de Spark](monitor-spark-ui-history.md) # Habilitación de la interfaz de usuario web de Apache Spark para trabajos de AWS Glue Puede utilizar la interfaz de usuario web de Apache Spark para monitorizar y depurar trabajos de ETL AWS Glue que se ejecutan en el sistema de trabajos AWS Glue. Puede configurar la interfaz de usuario de Spark mediante la consola de AWS Glue o la AWS Command Line Interface (AWS CLI). Cada 30 segundos, AWS Glue hace una copia de seguridad de los registros de eventos de Spark a la ruta de Amazon S3 que especifique. **Topics** + [Configuración de la interfaz de usuario de Spark (consola)](#monitor-spark-ui-jobs-console) + [Configuración de la interfaz de usuario de Spark (AWS CLI)](#monitor-spark-ui-jobs-cli) + [Configuración de la interfaz de usuario de Spark para sesiones con cuadernos](#monitor-spark-ui-sessions) + [Activación de registros continuos](#monitor-spark-ui-rolling-logs) ## Configuración de la interfaz de usuario de Spark (consola) Siga estos pasos para configurar la interfaz de usuario de Spark mediante la Consola de administración de AWS. Cuando se crea un trabajo en AWS Glue, la interfaz de usuario de Spark se habilita de forma predeterminada. **Activar la interfaz de Spark al crear o editar un trabajo** 1. Inicie sesión en la Consola de administración de AWS y abra la consola de AWS Glue en [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). 1. En el panel de navegación, seleccione **Trabajos**. 1. Elija **Agregar trabajo** o seleccione uno existente. 1. En **Detalles del trabajo**, abra las **Propiedades avanzadas**. 1. En la pestaña **Interfaz de usuario de Spark**, seleccione **Escribir registros de interfaz de usuario de Spark en Amazon S3**. 1. Especifique una ruta de Amazon S3 para almacenar los registros de eventos de Spark para el trabajo. Tenga en cuenta que cuando utiliza una configuración de seguridad en el trabajo, el cifrado también se aplica al archivo de registro de la interfaz de usuario de Spark. Para obtener más información, consulte [Cifrado de datos escritos por AWS Glue](encryption-security-configuration.md). 1. En la **Configuración de registro y monitoreo de la interfaz de usuario de Spark**: + Si está generando registros para verlos en la consola de AWS Glue, seleccione **Estándar**. + Si está generando registros para verlos en un servidor de historial de Spark, seleccione **Heredado**. + También puede optar por generar ambos. ## Configuración de la interfaz de usuario de Spark (AWS CLI) Para generar registros y verlos con la interfaz de usuario de Spark en la consola de AWS Glue, utilice la AWS CLI y transfiera los siguientes parámetros de trabajo a los trabajos de AWS Glue. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md). ``` '--enable-spark-ui': 'true', '--spark-event-logs-path': 's3://s3-event-log-path' ``` Para distribuir los registros a sus ubicaciones antiguas, establezca el parámetro `--enable-spark-ui-legacy-path` en `"true"`. Si no desea generar registros en ambos formatos, elimine el parámetro `--enable-spark-ui`. ## Configuración de la interfaz de usuario de Spark para sesiones con cuadernos **aviso** Las sesiones interactivas de AWS Glue no admiten la interfaz de usuario de Spark en la consola. Configure un servidor de historial de Spark. Si utiliza cuadernos de AWS Glue, configure la interfaz de usuario de Spark antes de iniciar la sesión. Para ello, utilice el comando mágico celular `%%configure`: ``` %%configure { “--enable-spark-ui”: “true”, “--spark-event-logs-path”: “s3://path” } ``` ## Activación de registros continuos Activar SparkUI y los archivos de eventos de registro continuo para los trabajos de AWS Glue Glue ofrece varias ventajas: + Archivos de eventos de registro continuo: al activar los archivos de eventos de registro continuo, AWS Glue genera archivos de registro independientes para cada paso de la ejecución del trabajo, lo que facilita la identificación y la solución de problemas específicos de una etapa o transformación en particular. + Mejor administración del registro: los archivos de eventos de registro continuo ayudan a administrar los archivos de registro de manera más eficiente. En lugar de tener un único archivo de registro, potencialmente grande, los registros se dividen en archivos más pequeños y fáciles de administrar en función de las etapas de ejecución del trabajo. Esto puede simplificar el archivado, el análisis y la solución de problemas de los registros. + Tolerancia a errores mejorada: si un trabajo de AWS Glue falla o se interrumpe, los archivos de eventos de registro continuo pueden proporcionar información valiosa sobre la última etapa exitosa, lo que facilita la reanudación del trabajo desde ese punto en lugar de empezar desde cero. + Optimización de costos: al habilitar los archivos de eventos de registro continuo, puede ahorrar en los costos de almacenamiento asociados a los archivos de registro. En lugar de almacenar un único archivo de registro, potencialmente grande, se almacenan archivos de registro más pequeños y fáciles de administrar, lo que puede resultar más rentable, especialmente para trabajos complejos o de larga duración. En un entorno nuevo, los usuarios pueden habilitar de forma explícita la acumulación de registros mediante: ``` '—conf': 'spark.eventLog.rolling.enabled=true' ``` o ``` '—conf': 'spark.eventLog.rolling.enabled=true —conf spark.eventLog.rolling.maxFileSize=128m' ``` Cuando se activan los registros continuos, `spark.eventLog.rolling.maxFileSize` especifica el tamaño máximo del archivo de registro de eventos antes de transferirlo. El valor por defecto de este parámetro opcional, si no se especifica, es 128 MB. El mínimo es 10 MB. La suma máxima de todos los archivos de eventos de registro continuo generados es de 2 GB. Para los trabajos de AWS Glue que no admiten registros continuos, el tamaño máximo del archivo de eventos de registro que admite SparkUI es de 0,5 GB. Puede desactivar los registros acumulativos de un trabajo de streaming al introducir una configuración adicional. Tenga en cuenta que el mantenimiento de archivos de registro muy grandes puede resultar costoso. Para desactivar los registros continuos, proporcione la siguiente configuración: ``` '--spark-ui-event-logs-path': 'true', '--conf': 'spark.eventLog.rolling.enabled=false' ``` # Lanzamiento del servidor de historial de Spark Puede utilizar un servidor de historial de Spark para visualizar los registros de Spark en su propia infraestructura. Puede ver en la consola de AWS Glue las mismas visualizaciones del trabajo de AWS Glue que se ejecute en las versiones 4.0 o posteriores deAWS Glue , con registros generados en formato estándar (en lugar de tradicional). Para obtener más información, consulte [Monitorización de trabajos mediante la interfaz de usuario web de Apache Spark](monitor-spark-ui.md). Puede lanzar el servidor de historial de Spark mediante una plantilla AWS CloudFormation que aloja el servidor en una instancia EC2 o lanzar localmente mediante Docker. **Topics** + [Lanzamiento del servidor de historial de Spark y visualización de la interfaz de usuario de Spark mediante AWS CloudFormation](#monitor-spark-ui-history-cfn) + [Lanzamiento del servidor de historial de Spark y visualización de la interfaz de usuario de Spark mediante Docker](#monitor-spark-ui-history-local) ## Lanzamiento del servidor de historial de Spark y visualización de la interfaz de usuario de Spark mediante AWS CloudFormation Puede utilizar una plantilla de AWS CloudFormation para iniciar el servidor de historial de Apache Spark y ver la interfaz de usuario web de Spark. Estas plantillas son ejemplos que debe modificar para satisfacer sus requisitos. **Para iniciar el servidor de historial de Spark y ver la interfaz de usuario de Spark mediante CloudFormation** 1. Elija uno de los botones **Lanzar pila** de la siguiente tabla. Esto lanza la pila en la consola de CloudFormation. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitor-spark-ui-history.html) 1. En la página **Especificar plantilla** elija **Siguiente**. 1. En la página **Especificar detalles de pila**, escriba el **nombre de la pila**. Introduzca información adicional en **Parámetros**. 1. **Configuración de la interfaz de usuario de Spark** Proporcione la información siguiente: + **Rango de direcciones IP**: el rango de direcciones IP que se puede utilizar para ver la interfaz de usuario de Spark. Si desea restringir el acceso desde un rango de direcciones IP específico, debe utilizar un valor personalizado. + **Puerto de servidor de historial**: el puerto para la interfaz de usuario de Spark. Puede utilizar el valor predeterminado. + **Directorio de registro de eventos**: elija la ubicación en la que se almacenan los registros de eventos de Spark desde el trabajo o los puntos de enlace de desarrollo de AWS Glue. Debe utilizar **s3a://** para el esquema de ruta de los registros de eventos. + **Ubicación del paquete de Spark**: puede utilizar el valor predeterminado. + **Ruta del almacén de claves**: ruta del almacén de claves SSL/TLS para HTTPS. Si desea utilizar un archivo de almacén de claves personalizado, puede especificar la ruta de S3 `s3://path_to_your_keystore_file` aquí. Si deja este parámetro vacío, se genera y utiliza un almacén de claves basado en certificados autofirmados. + **Contraseña del almacén de claves**: ingrese una contraseña del almacén de claves SSL/TLS para HTTPS. 1. **Configuración de instancias EC2** Proporcione la información siguiente: + **Tipo de instancia**: el tipo de instancia de Amazon EC2 que aloja el servidor de historial de Spark. Dado que esta plantilla lanza una instancia de Amazon EC2 en su cuenta, el costo de Amazon EC2 se cobrará en su cuenta por separado. + **Último ID de AMI**: el ID de AMI de Amazon Linux 2 para la instancia del servidor de historial de Spark. Puede utilizar el valor predeterminado. + **ID de VPC**: el ID de la nube privada virtual (VPC) para la instancia del servidor de historial de Spark. Puede utilizar cualquiera de las VPC disponibles en su cuenta: no se recomienda utilizar una VPC predeterminada con una [ACL de red predeterminada](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html#default-network-acl) . Para obtener más información, consulte [VPC predeterminada y subredes predeterminadas](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html) y [Creación de una VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#Create-VPC) en la *Guía del usuario de Amazon VPC*. + **ID de subred**: el ID de la instancia del servidor de historial de Spark. Puede utilizar cualquiera de las subredes de su VPC. Debe poder acceder a la red desde su cliente a la subred. Si desea obtener acceso a a través de Internet, debe utilizar una subred pública que tenga la gateway de internet en la tabla de ruteo. 1. Elija **Siguiente**. 1. En la página **Configurar las opciones de pila**, para utilizar las credenciales de usuario actuales para determinar cómo CloudFormation puede crear, modificar o eliminar recursos de la pila, elija **Próximo**. También puede especificar un rol en la sección **Permisos** que utilizará en lugar de los permisos de usuario actuales y, a continuación, elija **Siguiente**. 1. En la página **Revisar**, examine la plantilla. Elija **Confirmo que CloudFormation puede crear recursos de IAM** y, a continuación, elija **Crear pila**. 1. Espere a que se cree la pila. 1. Haga clic en la pestaña **Salidas**. 1. Copie la URL de **SparkUiPublicUrl** si está utilizando una subred pública. 1. Copie la URL de **SparkUiPrivateUrl** si está utilizando una subred privada. 1. Abra un navegador web y pegue la URL. Esto le permite obtener acceso al servidor mediante HTTPS en el puerto especificado. Es posible que el navegador no reconozca el certificado del servidor, en cuyo caso tendrá que anular su protección y continuar. ## Lanzamiento del servidor de historial de Spark y visualización de la interfaz de usuario de Spark mediante Docker Si prefiere el acceso local (no tener una instancia EC2 para el servidor de historial de Apache Spark), también puede utilizar Docker para iniciar el servidor de historial de Apache Spark y ver la interfaz de usuario de Spark localmente. Este Dockerfile es un ejemplo que debe modificar para satisfacer sus requisitos. **Requisitos previos** Para obtener información acerca de cómo instalar Docker en su portátil, consulte la [comunidad de Docker Engine](https://docs.docker.com/install/). **Iniciar el servidor de historial de Spark y ver la interfaz de usuario de Spark localmente mediante Docker** 1. Descargue archivos desde GitHub. Descargue Dockerfile y `pom.xml` de las [muestras de código de AWS Glue](https://github.com/aws-samples/aws-glue-samples/tree/master/utilities/Spark_UI/). 1. Determine si desea utilizar las credenciales de usuario o credenciales de usuario federado para acceder a AWS. + Para utilizar las credenciales de usuario actuales para acceder a AWS, obtenga los valores que se van a utilizar para ` AWS_ACCESS_KEY_ID` y `AWS_SECRET_ACCESS_KEY` en el comando `docker run`. Para obtener más información, consulte [Administración de claves de acceso para usuarios de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) en la *Guía del usuario de IAM*. + Para utilizar usuarios federados SAML 2.0 para acceder a AWS, obtenga los valores de ` AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` y ` AWS_SESSION_TOKEN`. Para obtener más información, consulte [Solicitud de credenciales de seguridad temporales](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html) 1. Determine la ubicación del directorio de registro de eventos que se utilizará en el comando `docker run`. 1. Cree la imagen de Docker con los archivos del directorio local y utilice el nombre ` glue/sparkui` y la etiqueta `latest`. ``` $ docker build -t glue/sparkui:latest . ``` 1. Cree e inicie el contenedor de docker. En los siguientes comandos, utilice los valores obtenidos anteriormente en los pasos 2 y 3. 1. Para crear el contenedor de docker mediante las credenciales de usuario, utilice un comando similar al siguiente ``` docker run -itd -e SPARK_HISTORY_OPTS="$SPARK_HISTORY_OPTS -Dspark.history.fs.logDirectory=s3a://path_to_eventlog -Dspark.hadoop.fs.s3a.access.key=AWS_ACCESS_KEY_ID -Dspark.hadoop.fs.s3a.secret.key=AWS_SECRET_ACCESS_KEY" -p 18080:18080 glue/sparkui:latest "/opt/spark/bin/spark-class org.apache.spark.deploy.history.HistoryServer" ``` 1. Para crear el contenedor de docker mediante credenciales temporales, utilice ` org.apache.hadoop.fs.s3a.TemporaryAWSCredentialsProvider` como proveedor, y proporcione los valores de credenciales obtenidos en el paso 2. Para obtener más información, consulte [Uso de credenciales de sesión con TemporaryAWSCredentialsProvider](https://hadoop.apache.org/docs/stable/hadoop-aws/tools/hadoop-aws/index.html#Using_Session_Credentials_with_TemporaryAWSCredentialsProvider) en la documentación de *Hadoop: integración con Amazon Web Services*. ``` docker run -itd -e SPARK_HISTORY_OPTS="$SPARK_HISTORY_OPTS -Dspark.history.fs.logDirectory=s3a://path_to_eventlog -Dspark.hadoop.fs.s3a.access.key=AWS_ACCESS_KEY_ID -Dspark.hadoop.fs.s3a.secret.key=AWS_SECRET_ACCESS_KEY -Dspark.hadoop.fs.s3a.session.token=AWS_SESSION_TOKEN -Dspark.hadoop.fs.s3a.aws.credentials.provider=org.apache.hadoop.fs.s3a.TemporaryAWSCredentialsProvider" -p 18080:18080 glue/sparkui:latest "/opt/spark/bin/spark-class org.apache.spark.deploy.history.HistoryServer" ``` **nota** Estos parámetros de configuración proceden del [Módulo Hadoop-AWS](https://hadoop.apache.org/docs/stable/hadoop-aws/tools/hadoop-aws/index.html). Es posible que tenga que agregar configuración específica en función del caso de uso. Por ejemplo, los usuarios de regiones aisladas tendrán que configurar ` spark.hadoop.fs.s3a.endpoint`. 1. Abra `http://localhost:18080` en el navegador para ver la interfaz de usuario de Spark en forma local. # Supervisión con Información de ejecuciones de trabajos de AWS Glue Información de ejecuciones de trabajos de AWS Glue es una característica de AWS Glue que simplifica la depuración de trabajos y la optimización de los trabajos de AWS Glue. AWS Glue proporciona la [interfaz de usuario de Spark](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui.html) y las [métricas y registros de CloudWatch Logs](https://docs.aws.amazon.com/glue/latest/dg/monitor-cloudwatch.html) para la supervisión de los trabajos de AWS Glue. Con esta característica, obtiene esta información sobre la ejecución del trabajo de AWS Glue: + Número de línea del script del trabajo de AWS Glue con error. + Última acción de Spark que se ejecutó en el plan de consultas de Spark justo antes del error del trabajo. + Eventos de excepción de Spark relacionados con el error que se muestran en un flujo de registro ordenado por tiempo. + Análisis de causa raíz y acción recomendada (por ejemplo, ajustar el script) para solucionar el problema. + Eventos comunes de Spark (mensajes de registro relacionados con una acción de Spark) con una acción recomendada que aborda la causa raíz. Toda esta información está disponible mediante dos nuevos flujos de registro en CloudWatch Logs para sus trabajos de AWS Glue. ## Requisitos La característica de información sobre la ejecución de los trabajos de AWS Glue está disponible para las versiones 2.0 y posteriores de AWS Glue. Puede seguir la [guía de migración](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-30.html) para actualizar los trabajos existentes desde versiones anteriores de AWS Glue. ## Habilitación de información de ejecuciones de trabajos para un trabajo de ETL de AWS Glue Puede habilitar Información de ejecuciones de trabajos a través de AWS Glue Studio o la CLI. ### AWS Glue Studio Al crear un trabajo mediante AWS Glue Studio, puede habilitar o desactivar Información de ejecuciones de trabajos en la pestaña **Job Details** (Detalles del trabajo). Compruebe que la casilla **Generar información sobre el trabajo** esté seleccionada. ![\[Habilitación de Información de ejecuciones de trabajos en AWS Glue Studio.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-job-run-insights-1.png) ### Línea de comandos Si crea un trabajo a través de la CLI, puede iniciar una ejecución de trabajos con un único nuevo [parámetro de trabajo](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html): `--enable-job-insights = true`. De forma predeterminada, los flujos de registro de Información de ejecuciones de trabajos se crean en el mismo grupo de registros predeterminado que utiliza el [registro continuo de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging.html), es decir, `/aws-glue/jobs/logs-v2/`. Puede configurar un nombre de grupo de registros personalizado, filtros de registros y configuraciones de grupos de registros con el mismo conjunto de argumentos que el registro continuo. Para obtener más información, consulte [Habilitación del registro continuo para trabajos de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging-enable.html). ## Acceso a los flujos de registro de información de ejecuciones de trabajos en CloudWatch Con la característica Información de ejecuciones de trabajos habilitada, es posible que haya dos flujos de registro creados cuando falla la ejecución de un trabajo. Cuando un trabajo finaliza correctamente, no se genera ninguno de los flujos. 1. *Flujo de registro de análisis de excepciones*: `-job-insights-rca-driver`. Este flujo proporciona lo siguiente: + Número de línea del script del trabajo de AWS Glue que causó el error. + Última acción de Spark que se ejecutó en el plan de consultas de Spark (DAG). + Eventos concisos ordenados por tiempo del controlador de Spark y ejecutores relacionados con la excepción. Puede encontrar detalles como mensajes de error completos, la tarea de Spark con error y el ID de los ejecutores que le ayudan a centrarse en el flujo de registro del ejecutor específico para llevar a cabo una investigación en profundidad si es necesario. 1. *Flujo de información basado en reglas*: + Análisis de causa raíz y recomendaciones sobre cómo corregir los errores (por ejemplo, utilizar un parámetro de trabajo específico para optimizar el rendimiento). + Los eventos relevantes de Spark sirven de base para el análisis de causa raíz y una acción recomendada. **nota** El primer flujo solo existirá si hay eventos de excepción de Spark disponibles para una ejecución de trabajo con error, mientras que el segundo flujo solo existirá si hay información disponible para la ejecución del trabajo con error. Por ejemplo, si el trabajo finaliza correctamente, no se generará ninguno de los flujos; si el trabajo falla, pero no hay ninguna regla definida por el servicio que pueda coincidir con el escenario de error, solo se generará el primer flujo. Si el trabajo se crea en AWS Glue Studio, los enlaces a los flujos anteriores también están disponibles en la pestaña Job run details (Detalles de ejecuciones de trabajos, es decir, Información de ejecuciones de trabajos) como “Concise and consolidated error logs” (Registros de errores concisos y consolidados) y “Error analysis and guidance” (Análisis de errores y orientación). ![\[Página Job Run Details (Detalles de ejecuciones de trabajos) que contiene enlaces a los flujos de registro.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-job-run-insights-2.png) ## Ejemplo de Información de ejecuciones de trabajos de AWS Glue En esta sección, mostramos un ejemplo de cómo la característica Información de ejecuciones de trabajos puede ayudarle a resolver un problema en un trabajo con errores. En este ejemplo, un usuario olvidó importar el módulo obligatorio (tensorflow) en un trabajo de AWS Glue para analizar y crear un modelo de machine learning en sus datos. ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job from pyspark.sql.types import * from pyspark.sql.functions import udf,col args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME'], args) data_set_1 = [1, 2, 3, 4] data_set_2 = [5, 6, 7, 8] scoresDf = spark.createDataFrame(data_set_1, IntegerType()) def data_multiplier_func(factor, data_vector): import tensorflow as tf with tf.compat.v1.Session() as sess: x1 = tf.constant(factor) x2 = tf.constant(data_vector) result = tf.multiply(x1, x2) return sess.run(result).tolist() data_multiplier_udf = udf(lambda x:data_multiplier_func(x, data_set_2), ArrayType(IntegerType(),False)) factoredDf = scoresDf.withColumn("final_value", data_multiplier_udf(col("value"))) print(factoredDf.collect()) ``` Sin la característica Información de ejecuciones de trabajos, como el trabajo falla, solo verá este mensaje de Spark: `An error occurred while calling o111.collectToPython. Traceback (most recent call last):` El mensaje es ambiguo y limita la experiencia de depuración. En este caso, esta característica proporciona información adicional en dos flujos de registro de CloudWatch: 1. El flujo de registro `job-insights-rca-driver`: + *Eventos de excepción*: este flujo de registro proporciona los eventos de excepción de Spark relacionados con el error recopilado por el controlador de Spark y los distintos empleados distribuidos. Estos eventos le ayudan a comprender la propagación ordenada por tiempo de la excepción, ya que el código con error se ejecuta en las tareas, los ejecutores y las etapas de Spark distribuidos en los empleados de AWS Glue. + *Números de línea*: este flujo de registro identifica la línea 21, que hizo la llamada para importar el módulo de Python que falta que causó el error; también identifica la línea 24, la llamada a la acción de Spark `collect()`, como última línea ejecutada del script. ![\[El flujo de registro job-insights-rca-driver.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-job-run-insights-3.png) 1. El flujo de registro `job-insights-rule-driver`: + *Causa raíz y recomendación*: además del número de línea y el último número de línea ejecutado para el error del script, este flujo de registro muestra el análisis de causa raíz y la recomendación para que siga el documento de AWS Glue y configure los parámetros de trabajo necesarios para utilizar un módulo de Python adicional en su trabajo de AWS Glue. + *Evento base*: este flujo de registro también muestra el evento de excepción de Spark que se evaluó con la regla definida por el servicio para inferir la causa raíz y proporcionar una recomendación. ![\[El flujo de registro job-insights-rule-driver.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-job-run-insights-4.png) # Supervisión con Amazon CloudWatch Puede monitorear AWS Glue mediante Amazon CloudWatch, que recopila y procesa los datos sin procesar de AWS Glue en métricas legibles y casi en tiempo real. Estas estadísticas se registran durante un periodo de dos semanas, de forma que pueda disponer de información histórica y obtener una mejor perspectiva sobre el desempeño de la aplicación o servicio web. De forma predeterminada, los datos de las métricas de AWS Glue se envían a CloudWatch en forma automática. Para obtener más información, consulte [¿Qué es Amazon CloudWatch?](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/WhatIsCloudWatch.html) en la *Guía del usuario de Amazon Cloudwatch*, y [AWS Glue metrics](monitoring-awsglue-with-cloudwatch-metrics.md#awsglue-metrics). **Registro continuo** AWS Glue también admite el registro continuo en tiempo real para trabajos de AWS Glue. Cuando el registro continuo está habilitado para un trabajo, puede ver los registros en tiempo real en la consola de AWS Glue o en el panel de la consola de CloudWatch. Para obtener más información, consulte [Registro de trabajos de AWS Glue](monitor-continuous-logging.md). **Métricas de observabilidad** Cuando las **Métricas de observabilidad del trabajo** están habilitadas, se generan métricas Amazon CloudWatch adicionales cuando se ejecuta el trabajo. Use las métricas de observabilidad AWS Glue para obtener información sobre lo que sucede en el interior de AWS Glue y mejorar la clasificación y el análisis de los problemas. **Topics** + [Supervisión de AWS Glue con métricas de Amazon CloudWatch](monitoring-awsglue-with-cloudwatch-metrics.md) + [Configuración de alarmas de Amazon CloudWatch en perfiles de trabajo de AWS Glue](monitor-profile-glue-job-cloudwatch-alarms.md) + [Registro de trabajos de AWS Glue](monitor-continuous-logging.md) + [Monitorización con métricas de observabilidad de AWS Glue](monitor-observability.md) # Supervisión de AWS Glue con métricas de Amazon CloudWatch Puede proporcionar perfiles y supervisar las operaciones de AWS Glue con el generador de trabajos de AWS Glue. Recopila y procesa los datos sin procesar de AWS Glue para convertirlos en métricas legibles y casi en tiempo real en Amazon CloudWatch. Estas estadísticas se retienen y agregan en CloudWatch, de forma que pueda acceder a información histórica para obtener una mejor perspectiva sobre el rendimiento de su aplicación. **nota** Puede incurrir en cargos adicionales cuando habilita las métricas de trabajos y se crean métricas personalizadas de CloudWatch. Para obtener más información, consulte los [ precios de Amazon CloudWatch ](https://aws.amazon.com/cloudwatch/pricing/). ## Información general de métricas de AWS Glue Cuando usted interactúa con AWS Glue, este último envía métricas a CloudWatch. Puede ver estas métricas en la consola de AWS Glue (el método preferido), el panel de la consola de CloudWatch o AWS Command Line Interface (AWS CLI). **Para consultar las métricas mediante el panel de la consola de AWS Glue** Puede ver gráficos resumidos o detallados de métricas para un trabajo, o bien gráficos detallados para una ejecución de trabajo. 1. Inicie sesión en Consola de administración de AWS y abra la consola de AWS Glue en [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). 1. En el panel de navegación, seleccione **Monitoreo de ejecución de trabajos**. 1. En **Ejecuciones de trabajos**, elija **Acciones** para detener un trabajo que se ejecute actualmente, ver un trabajo o rebobinar el marcador del trabajo. 1. Seleccione un trabajo y, a continuación, elija **Ver detalles de la ejecución** para ver información adicional sobre la ejecución del trabajo. **Para ver las métricas a través del panel de consola de CloudWatch** Las métricas se agrupan en primer lugar por el espacio de nombres de servicio y, a continuación, por las diversas combinaciones de dimensiones dentro de cada espacio de nombres. 1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. En el panel de navegación, seleccione **Métricas**. 1. Seleccione el espacio de nombres **Glue**. **Para ver métricas mediante la AWS CLI** + En el símbolo del sistema, ejecute el siguiente comando. ``` 1. aws cloudwatch list-metrics --namespace Glue ``` AWS Glue notifica las métricas para CloudWatch cada 30 segundos y los paneles de métricas de CloudWatch se configuran para mostrarlas cada minuto. Las métricas de AWS Glue representan valores delta que se obtienen de los valores notificados con anterioridad. Si procede, los paneles de métricas acumulan (suman) los valores de 30 segundos para obtener un valor para el último minuto en su totalidad. ### Comportamiento de métricas de AWS Glue para trabajos de Spark Las métricas AWS Glue se habilitan en la inicialización de un `GlueContext` en un script y suelen actualizarse solo al final de una tarea de Apache Spark. Representan los valores de la suma en todas las tareas Spark hasta el momento. No obstante, las métricas de Spark que AWS Glue transfiere a CloudWatch suelen ser valores absolutos que representan el estado actual en el momento en que se notifican. AWS Glue los notifica a CloudWatch cada 30 segundos, y los paneles de métricas suelen mostrar la media en los puntos de datos recibidos en el último minuto. AWS GlueLos nombres de las métricas de están precedidos por uno de los siguientes tipos de prefijo: + `glue.driver.`: las métricas cuyos nombres comienzan con este prefijo representan las métricas de AWS Glue que provienen de todos los ejecutores en el controlador Spark, o bien las métricas de Spark correspondientes al controlador Spark. + `glue.`*Id de ejecutor*`.`: el *Id de ejecutor* es el número de un ejecutor de Spark especificado. Se corresponde con los ejecutores enumerados en los registros. + `glue.ALL.`: las métricas cuyos nombres empiezan por este prefijo agregan valores de todos los ejecutores de Spark. ## AWS Glue metrics AWS Glue crea perfiles y envía las siguientes métricas a CloudWatch cada 30 segundos, y el panel de métricas de AWS Glue los informa una vez por minuto: | Métrica | Descripción | | --- | --- | | `glue.driver.aggregate.bytesRead` | El número de bytes leídos desde todos los orígenes de datos por todas las tareas de Spark completadas que se ejecutan en todos los ejecutores. Dimensiones válidas: `JobName` (el nombre del trabajo de AWS Glue), `JobRunId` (el ID de JobRun o `ALL`) y `Type` (recuento). Estadísticas válidas: SUMA. Esta métrica es un valor delta desde el último valor notificado, por lo que en el panel de métricas de AWS Glue, se utiliza una estadística SUMA para la agregación. Unidades: bytes Se puede utilizar para monitorear lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Esta métrica se puede utilizar de la misma manera que la métrica `glue.ALL.s3.filesystem.read_bytes`, con la diferencia de que esta métrica se actualiza al final de una tarea de Spark y también captura orígenes de datos que no son S3. | | `glue.driver.aggregate.elapsedTime` | El tiempo transcurrido de ETL en milisegundos (no incluye los tiempos de arranque del trabajo). Dimensiones válidas: `JobName` (el nombre del trabajo de AWS Glue), `JobRunId` (el ID de JobRun o `ALL`) y `Type` (recuento). Estadísticas válidas: SUMA. Esta métrica es un valor delta desde el último valor notificado, por lo que en el panel de métricas de AWS Glue, se utiliza una estadística SUMA para la agregación. Unidad: milisegundos Puede utilizarse para determinar cuánto tiempo se tarda en ejecutar una ejecución de trabajo en promedio. Algunas formas de usar los datos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.numCompletedStages` | Número de etapas completadas en este trabajo. Dimensiones válidas: `JobName` (el nombre del trabajo de AWS Glue), `JobRunId` (el ID de JobRun o `ALL`) y `Type` (recuento). Estadísticas válidas: SUMA. Esta métrica es un valor delta desde el último valor notificado, por lo que en el panel de métricas de AWS Glue, se utiliza una estadística SUMA para la agregación. Unidad: recuento Se puede utilizar para monitorear lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algunas formas de usar los datos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.numCompletedTasks` | Número de etapas completadas en el trabajo. Dimensiones válidas: `JobName` (el nombre del trabajo de AWS Glue), `JobRunId` (el ID de JobRun o `ALL`) y `Type` (recuento). Estadísticas válidas: SUMA. Esta métrica es un valor delta desde el último valor notificado, por lo que en el panel de métricas de AWS Glue, se utiliza una estadística SUMA para la agregación. Unidad: recuento Se puede utilizar para monitorear lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.numFailedTasks` | El número de tareas de servicio que han presentado un error. Dimensiones válidas: `JobName` (el nombre del trabajo de AWS Glue), `JobRunId` (el ID de JobRun o `ALL`) y `Type` (recuento). Estadísticas válidas: SUMA. Esta métrica es un valor delta desde el último valor notificado, por lo que en el panel de métricas de AWS Glue, se utiliza una estadística SUMA para la agregación. Unidad: recuento Se puede utilizar para monitorear lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Los datos se pueden usar para establecer alarmas ante mayor cantidad de errores que podrían sugerir anomalías en los datos, clústeres o scripts. | | `glue.driver.aggregate.numKilledTasks` | El número de tareas eliminadas. Dimensiones válidas: `JobName` (el nombre del trabajo de AWS Glue), `JobRunId` (el ID de JobRun o `ALL`) y `Type` (recuento). Estadísticas válidas: SUMA. Esta métrica es un valor delta desde el último valor notificado, por lo que en el panel de métricas de AWS Glue, se utiliza una estadística SUMA para la agregación. Unidad: recuento Se puede utilizar para monitorear lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algunas formas de usar los datos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.recordsRead` | Número de registros leídos de todos los orígenes de datos por todas las tareas de Spark completadas que se ejecutan en todos los ejecutores. Dimensiones válidas: `JobName` (el nombre del trabajo de AWS Glue), `JobRunId` (el ID de JobRun o `ALL`) y `Type` (recuento). Estadísticas válidas: SUMA. Esta métrica es un valor delta desde el último valor notificado, por lo que en el panel de métricas de AWS Glue, se utiliza una estadística SUMA para la agregación. Unidad: recuento Se puede utilizar para monitorear lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Esta métrica se puede utilizar de manera similar que la métrica `glue.ALL.s3.filesystem.read_bytes`, con la diferencia de que esta métrica se actualiza al final de una tarea de Spark. | | `glue.driver.aggregate.shuffleBytesWritten` | El número de bytes que escriben todos los ejecutores para mezclar los datos en forma aleatoria entre ellos desde el informe anterior (acumulados por el panel de métricas de AWS Glue como el número de bytes escritos para este propósito durante el minuto anterior). Dimensiones válidas: `JobName` (el nombre del trabajo de AWS Glue), `JobRunId` (el ID de JobRun o `ALL`) y `Type` (recuento). Estadísticas válidas: SUMA. Esta métrica es un valor delta desde el último valor notificado, por lo que en el panel de métricas de AWS Glue, se utiliza una estadística SUMA para la agregación. Unidades: bytes Se puede utilizar para monitorear: mezclas aleatorias de datos en trabajos (combinaciones grandes, agrupados por, repartición, fusión). Algunas formas de usar los datos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.shuffleLocalBytesRead` | El número de bytes que leen todos los ejecutores para mezclar los datos en forma aleatoria entre ellos desde el informe anterior (acumulados por el panel de métricas de AWS Glue como el número de bytes leídos para este propósito durante el minuto anterior). Dimensiones válidas: `JobName` (el nombre del trabajo de AWS Glue), `JobRunId` (el ID de JobRun o `ALL`) y `Type` (recuento). Estadísticas válidas: SUMA. Esta métrica es un valor delta desde el último valor notificado, por lo que en el panel de métricas de AWS Glue, se utiliza una estadística SUMA para la agregación. Unidades: bytes Se puede utilizar para monitorear: mezclas aleatorias de datos en trabajos (combinaciones grandes, agrupados por, repartición, fusión). Algunas formas de usar los datos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.BlockManager.disk.diskSpaceUsed_MB` | Número de megabytes de espacio en disco utilizado en todos los ejecutores. Dimensiones válidas: `JobName` (el nombre del trabajo de AWS Glue), `JobRunId` (el ID de JobRun o `ALL`), y `Type` (calibre). Estadísticas válidas: promedio. Esta es una métrica de Spark, notificada como un valor absoluto. Unidades: megabytes Se puede utilizar para monitorear lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algunas formas de usar los datos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.ExecutorAllocationManager.executors.numberAllExecutors` | El número de ejecutores de trabajo que se ejecutan activamente. Dimensiones válidas: `JobName` (el nombre del trabajo de AWS Glue), `JobRunId` (el ID de JobRun o `ALL`), y `Type` (calibre). Estadísticas válidas: promedio. Esta es una métrica de Spark, notificada como un valor absoluto. Unidad: recuento Se puede utilizar para monitorear lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algunas formas de usar los datos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors` | Número máximo de ejecutores de trabajos (en ejecución activa y pendientes) necesarios para satisfacer la carga actual. Dimensiones válidas: `JobName` (el nombre del trabajo de AWS Glue), `JobRunId` (el ID de JobRun o `ALL`), y `Type` (calibre). Estadísticas válidas: máximo. Esta es una métrica de Spark, notificada como un valor absoluto. Unidad: recuento Se puede utilizar para monitorear lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algunas formas de usar los datos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.jvm.heap.usage` `glue.`*Id de ejecutor*`.jvm.heap.usage` `glue.ALL.jvm.heap.usage` | La fracción de memoria usada por el montón de JVM para este controlador (escala: 0-1), ejecutor identificado por el Id de ejecutor o TODOS los ejecutores. Dimensiones válidas: `JobName` (el nombre del trabajo de AWS Glue), `JobRunId` (el ID de JobRun o `ALL`), y `Type` (calibre). Estadísticas válidas: promedio. Esta es una métrica de Spark, notificada como un valor absoluto. Unidad: porcentaje Se puede utilizar para monitorear lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algunas formas de usar los datos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.jvm.heap.used` `glue.`*Id de ejecutor*`.jvm.heap.used` `glue.ALL.jvm.heap.used` | El número de bytes de memoria utilizados por el montón de JVM para el controlador, el ejecutor identificado por *Id de ejecutor*, o TODOS los ejecutores. Dimensiones válidas: `JobName` (el nombre del trabajo de AWS Glue), `JobRunId` (el ID de JobRun o `ALL`), y `Type` (calibre). Estadísticas válidas: promedio. Esta es una métrica de Spark, notificada como un valor absoluto. Unidades: bytes Se puede utilizar para monitorear lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algunas formas de usar los datos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.s3.filesystem.read_bytes` `glue.`*Id de ejecutor*`.s3.filesystem.read_bytes` `glue.ALL.s3.filesystem.read_bytes` | El número de bytes leídos desde Amazon S3 por el controlador, un ejecutor identificado por *Id de ejecutor*, o TODOS los ejecutores desde el informe anterior (acumulados por el panel de métricas de AWS Glue como número de bytes leídos durante el minuto anterior). Dimensiones válidas: `JobName`, `JobRunId`, y `Type` (calibre). Estadísticas válidas: SUMA. Esta métrica es un valor delta desde el último valor notificado, por lo que en el panel de métricas de AWS Glue, se utiliza una estadística SUM para la agregación. El área bajo la curva en el panel de métricas de AWS Glue se puede utilizar para comparar visualmente los bytes leídos por dos ejecuciones de trabajos diferentes. Unidad: bytes. Se puede utilizar para monitorear lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Los datos resultantes se pueden utilizar para lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.s3.filesystem.write_bytes` `glue.`*Id de ejecutor*`.s3.filesystem.write_bytes` `glue.ALL.s3.filesystem.write_bytes` | El número de bytes que escribe el controlador en Amazon S3, un ejecutor identificado por *Id de ejecutor*, o TODOS los ejecutores desde el informe anterior (agregados por el panel de métricas de AWS Glue como número de bytes escritos durante el minuto anterior). Dimensiones válidas: `JobName`, `JobRunId`, y `Type` (calibre). Estadísticas válidas: SUMA. Esta métrica es un valor delta desde el último valor notificado, por lo que en el panel de métricas de AWS Glue, se utiliza una estadística SUM para la agregación. El área bajo la curva en el panel de métricas de AWS Glue se puede utilizar para comparar visualmente los bytes escritos por dos ejecuciones de trabajos diferentes. Unidades: bytes Se puede utilizar para monitorear lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algunas formas de usar los datos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.streaming.numRecords` | El número de registros que se reciben en un microlote. Esta métrica solo está disponible para trabajos de streaming de AWS Glue con la versión AWS Glue 2.0 y superior. Dimensiones válidas: `JobName` (el nombre del trabajo de AWS Glue), `JobRunId` (el ID de JobRun o `ALL`), y `Type` (recuento). Estadísticas válidas: suma, máximo, mínimo, promedio, percentilo Unidad: recuento Se puede utilizar para monitorear lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.streaming.batchProcessingTimeInMs` | El tiempo que se tarda en procesar los lotes en milisegundos. Esta métrica solo está disponible para trabajos de streaming de AWS Glue con la versión AWS Glue 2.0 y superior. Dimensiones válidas: `JobName` (el nombre del trabajo de AWS Glue), `JobRunId` (el ID de JobRun o `ALL`), y `Type` (recuento). Estadísticas válidas: suma, máximo, mínimo, promedio, percentilo Unidad: recuento Se puede utilizar para monitorear lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.system.cpuSystemLoad` `glue.`*Id de ejecutor*`.system.cpuSystemLoad` `glue.ALL.system.cpuSystemLoad` | Fracción de la carga del sistema de CPU usada (escala: 0-1) por el controlador, un ejecutor identificado por *Id de ejecutor*, o TODOS los ejecutores. Dimensiones válidas: `JobName` (el nombre del trabajo de AWS Glue), `JobRunId` (el ID de JobRun o `ALL`), y `Type` (calibre). Estadísticas válidas: promedio. Esta métrica se notifica como un valor absoluto. Unidad: porcentaje Se puede utilizar para monitorear lo siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Algunas formas de usar los datos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | ## Dimensiones de las métricas de AWS Glue Las métricas de AWS Glue utilizan el espacio de nombres de AWS Glue y proporcionan métricas para las siguientes dimensiones: | Dimensión | Descripción | | --- | --- | | `JobName` | Esta dimensión filtra las métricas de todas las ejecuciones de trabajos de un trabajo de AWS Glue específico. | | `JobRunId` | Esta dimensión filtra las métricas de ejecución de un trabajo de AWS Glue específico por ID de JobRun, o `ALL`. | | `Type` | Esta dimensión filtra las métricas por `count` (un número acumulado) o `gauge` (un valor en un punto en el tiempo). | Para obtener más información, consulte la [Guía del usuario de Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/). # Configuración de alarmas de Amazon CloudWatch en perfiles de trabajo de AWS Glue AWS GlueLas métricas de también están disponibles en Amazon CloudWatch. Puede configurar alarmas en cualquier métrica de AWS Glue para trabajos programados. A continuación se muestran algunas situaciones comunes de configuración de alarmas: + Trabajos con problemas de falta de memoria (OOM): establezca una alarma cuando el uso de la memoria supere la media normal del controlador o un ejecutor de un trabajo de AWS Glue. + Ejecutores rezagados: establezca una alarma cuando el número de ejecutores caiga por debajo de un determinado umbral durante un largo periodo de tiempo en un trabajo de AWS Glue. + Reprocesamiento o tareas pendientes de datos: compare las métricas de trabajos individuales en un flujo de trabajo mediante una expresión matemática de CloudWatch. A continuación, puede activar una alarma en el valor de expresión resultante (como la relación de bytes escritos por un trabajo y bytes leídos por un trabajo posterior). Para obtener instrucciones detalladas acerca de cómo establecer alarmas, consulte [Crear o editar una alarma de CloudWatch Alarm](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ConsoleAlarms.html) en la *[Guía del usuario de Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/)*. Para monitorear y depurar escenarios con CloudWatch, consulte [Monitorización y depuración de trabajo](monitor-profile-glue-job-cloudwatch-metrics.md). # Registro de trabajos de AWS Glue En AWS Glue 5.0, todos los trabajos cuentan con capacidades de registro en tiempo real. Además, puede especificar opciones de configuración personalizadas para adaptar el comportamiento de registro. Estas opciones incluyen establecer el nombre del grupo de registro de Amazon CloudWatch, el prefijo del flujo de registro de Amazon CloudWatch (que antecede al ID de ejecución del trabajo de AWS Glue y al ID del controlador o ejecutor), y el patrón de conversión para los mensajes de registro. Estas configuraciones permiten agrupar los registros en grupos de registro personalizados de Amazon CloudWatch con diferentes políticas de expiración. Además, puede analizar los registros con mayor eficacia si define prefijos personalizados para los flujos de registro y patrones de conversión. Este nivel de personalización permite optimizar la administración y el análisis de registros según necesidades específicas. ## Comportamiento del registro en AWS Glue 5.0 De forma predeterminada, los registros del sistema, los registros de daemon de Spark y los registros del usuario generados con el registrador de AWS Glue se escriben en el grupo de registro `/aws-glue/jobs/error` de Amazon CloudWatch. Por otro lado, los registros de salida estándar (stdout) y de error estándar (stderr) del usuario se escriben de forma predeterminada en el grupo de registro `/aws-glue/jobs/output`. ## Registro personalizado Puede personalizar el grupo de registro y los prefijos de flujo de registro definidos de forma predeterminada mediante los siguientes argumentos de trabajo: + `--custom-logGroup-prefix`: permite especificar un prefijo personalizado para los grupos de registro `/aws-glue/jobs/error` y `/aws-glue/jobs/output`. Si especifica un prefijo personalizado, los nombres de los grupos de registro adoptarán el siguiente formato: + `/aws-glue/jobs/error` será `/error` + `/aws-glue/jobs/output ` será `/output` + `--custom-logStream-prefix`: permite especificar un prefijo personalizado para los nombres de los flujos de registro dentro de los grupos de registro. Si especifica un prefijo personalizado, los nombres de los flujos de registro adoptarán el siguiente formato: + `jobrunid-driver` será `-driver` + `jobrunid-executorNum` será `-executorNum` Reglas de validación y limitaciones para prefijos personalizados: + El nombre completo del flujo de registro debe tener entre 1 y 512 caracteres. + El prefijo personalizado, por sí solo, tiene un límite de 400 caracteres. + El prefijo personalizado debe coincidir con el patrón de expresión regular “[^:\$1]\$1” (los caracteres especiales permitidos son “\$1”, “-” y “/”). ## Registro de mensajes específicos de aplicación con el registrador de script personalizado Puede utilizar el registrador de AWS Glue para registrar todos los mensajes específicos de la aplicación en el script que se envían en tiempo real al flujo de registro del controlador. En el siguiente ejemplo se muestra un script de Python. ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) logger = glueContext.get_logger() logger.info("info message") logger.warn("warn message") logger.error("error message") ``` En el siguiente ejemplo se muestra un script de Scala. ``` import com.amazonaws.services.glue.log.GlueLogger object GlueApp { def main(sysArgs: Array[String]) { val logger = new GlueLogger logger.info("info message") logger.warn("warn message") logger.error("error message") } } ``` ## Habilitación de la barra de progreso para mostrar el progreso del trabajo AWS Glue proporciona una barra de progreso en tiempo real bajo el flujo de registro `JOB_RUN_ID-progress-bar` para comprobar el estado de ejecución de un trabajo de AWS Glue. En la actualidad se admiten únicamente los trabajos que inicializan `glueContext`. Si ejecuta un trabajo de Spark puro sin inicializar `glueContext`, la barra de progreso de AWS Glue no aparece. La barra de progreso muestra la siguiente actualización del progreso cada 5 segundos. ``` Stage Number (Stage Name): > (numCompletedTasks + numActiveTasks) / totalNumOfTasksInThisStage] ``` ## Configuración de seguridad con registro en Amazon CloudWatch Cuando se habilita una configuración de seguridad para los registros de Amazon CloudWatch, AWS Glue crea grupos de registro con patrones de nombres específicos que incorporan el nombre de la configuración de seguridad. ### Asignación de nombres a grupos de registro con configuración de seguridad Los grupos de registro predeterminados y personalizados serán de la siguiente manera: + **Grupo de registro de errores predeterminado:** `/aws-glue/jobs/Security-Configuration-Name-role/glue-job-role/error` + **Grupo de registro de salida predeterminado:** `/aws-glue/jobs/Security-Configuration-Name-role/glue-job-role/output` + **Grupo de registro de errores personalizado (AWS Glue 5.0):** `custom-log-group-prefix/Security-Configuration-Name-role/glue-job-role/error` + **Grupo de registro de salida personalizado (AWS Glue 5.0):** `custom-log-group-prefix/Security-Configuration-Name-role/glue-job-role/output` ### Permisos de IAM necesarios Debe agregar el permiso `logs:AssociateKmsKey` a los permisos del rol de IAM si habilita una configuración de seguridad con Registros de Amazon CloudWatch. Si no se incluye ese permiso, se deshabilitará el registro continuo. Además, para configurar el cifrado de los Registros de Amazon CloudWatch, siga las instrucciones en [Cifrar datos de registro en Registros de Amazon CloudWatch con AWS Key Management Service](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/encrypt-log-data-kms.html), disponible en la Guía del usuario de Registros de Amazon Amazon CloudWatch. ### Información adicional Para obtener más información sobre la creación de configuraciones de seguridad, consulte [Administración de configuraciones de seguridad en la consola de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-security-configurations.html). **Topics** + [Comportamiento del registro en AWS Glue 5.0](#monitor-logging-behavior-glue-50) + [Registro personalizado](#monitor-logging-custom) + [Registro de mensajes específicos de aplicación con el registrador de script personalizado](#monitor-logging-script) + [Habilitación de la barra de progreso para mostrar el progreso del trabajo](#monitor-logging-progress) + [Configuración de seguridad con registro en Amazon CloudWatch](#monitor-security-config-logging) + [Habilitación del registro continuo para trabajos de AWS Glue 4.0 y trabajos anteriores](monitor-continuous-logging-enable.md) + [Visualización de registros para trabajos de AWS Glue](monitor-continuous-logging-view.md) # Habilitación del registro continuo para trabajos de AWS Glue 4.0 y trabajos anteriores **nota** En AWS Glue 4.0 y versiones anteriores, el registro continuo era una característica disponible. Sin embargo, con la introducción de AWS Glue 5.0, todos los trabajos cuentan con capacidad de registro en tiempo real. Para obtener más información sobre las capacidades de registro y las opciones de configuración en AWS Glue 5.0, consulte la sección [Registro para trabajos de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging.html). Puede habilitar el registro continuo a través de la consola de AWS Glue o a través de la AWS Command Line Interface (AWS CLI). Puede habilitar el registro continuo al crear un trabajo nuevo, editar un trabajo existente o habilitarlo a través de AWS CLI. También puede especificar opciones de configuración personalizadas, como el nombre del grupo de registro de Amazon CloudWatch, el prefijo de flujo de registro de CloudWatch antes del ID de controlador/ID de ejecutor de ejecución del trabajo de AWS Glue, así como el patrón de conversión de registro para los mensajes de registro. Estas configuraciones le ayudan a establecer registros agregados en grupos de registros personalizados de CloudWatch con diferentes políticas de caducidad y a analizarlos con prefijos de flujo de registro personalizados y patrones de conversión. **Topics** + [Uso de Consola de administración de AWS](#monitor-continuous-logging-enable-console) + [Registro de mensajes específicos de aplicación con el registrador de script personalizado](#monitor-continuous-logging-script) + [Habilitación de la barra de progreso para mostrar el progreso del trabajo](#monitor-continuous-logging-progress) + [Configuración de seguridad con registro continuo.](#monitor-logging-encrypt-log-data) ## Uso de Consola de administración de AWS Siga estos pasos para usar la consola para habilitar el registro continuo al crear o editar un trabajo de AWS Glue. **Para crear un nuevo trabajo de AWS Glue con registro continuo** 1. Inicie sesión en Consola de administración de AWS y abra la consola de AWS Glue en [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). 1. En el panel de navegación, seleccione **Trabajos de ETL**. 1. Seleccione **Visual ETL**. 1. En la pestaña **Detalles del trabajo**, expanda la sección **Propiedades avanzadas**. 1. En la sección **Registro continuo**, seleccione **Habilitar registros en CloudWatch**. **Para habilitar el registro continuo para un trabajo de AWS Glue que ya tenga** 1. Abra la consola de AWS Glue en [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). 1. En el panel de navegación, seleccione **Trabajos**. 1. Elija el trabajo que ya tiene en la lista **Jobs (Trabajos)**. 1. Elija **Action (Acción)**, **Edit job (Editar trabajo)**. 1. En la pestaña **Detalles del trabajo**, expanda la sección **Propiedades avanzadas**. 1. En la sección **Registro continuo**, seleccione **Habilitar registros en CloudWatch**. ### Mediante AWS CLI Para habilitar el registro continuo debe transferir los parámetros de trabajo a un trabajo de AWS Glue. Transfiera los parámetros de trabajos especiales similares que figuran a continuación a otros parámetros de trabajo de AWS Glue. Para obtener más información, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md). ``` '--enable-continuous-cloudwatch-log': 'true' ``` Puede especificar un nombre de grupo de registro personalizado de Amazon CloudWatch. Si no se especifica, el nombre predeterminado del grupo de registro es `/aws-glue/jobs/logs-v2`. ``` '--continuous-log-logGroup': 'custom_log_group_name' ``` Puede especificar un prefijo de flujo de registro personalizado de Amazon CloudWatch. Si no se especifica, el prefijo de flujo de registro predeterminado es el ID de ejecución del trabajo. ``` '--continuous-log-logStreamPrefix': 'custom_log_stream_prefix' ``` Puede especificar un patrón de conversión de registro continuo personalizado. Si no se especifica, el patrón de conversión predeterminado es `%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n`. Tenga en cuenta que el patrón de conversión solo se aplica a los registros de controlador y ejecutor. No afecta a la barra de progreso de AWS Glue. ``` '--continuous-log-conversionPattern': 'custom_log_conversion_pattern' ``` ## Registro de mensajes específicos de aplicación con el registrador de script personalizado Puede utilizar el registrador de AWS Glue para registrar todos los mensajes específicos de la aplicación en el script que se envían en tiempo real al flujo de registro del controlador. En el siguiente ejemplo se muestra un script de Python. ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) logger = glueContext.get_logger() logger.info("info message") logger.warn("warn message") logger.error("error message") ``` En el siguiente ejemplo se muestra un script de Scala. ``` import com.amazonaws.services.glue.log.GlueLogger object GlueApp { def main(sysArgs: Array[String]) { val logger = new GlueLogger logger.info("info message") logger.warn("warn message") logger.error("error message") } } ``` ## Habilitación de la barra de progreso para mostrar el progreso del trabajo AWS Glue proporciona una barra de progreso en tiempo real bajo el flujo de registro `JOB_RUN_ID-progress-bar` para comprobar el estado de ejecución de un trabajo de AWS Glue. En la actualidad se admiten únicamente los trabajos que inicializan `glueContext`. Si ejecuta un trabajo de Spark puro sin inicializar `glueContext`, la barra de progreso de AWS Glue no aparece. La barra de progreso muestra la siguiente actualización del progreso cada 5 segundos. ``` Stage Number (Stage Name): > (numCompletedTasks + numActiveTasks) / totalNumOfTasksInThisStage] ``` ## Configuración de seguridad con registro continuo. Si se habilita una configuración de seguridad para los registros de CloudWatch, AWS Glue creará un grupo de registro llamado de la siguiente manera para los registros continuos: ``` - ``` Los grupos de registro predeterminados y personalizados serán de la siguiente manera: + El grupo de registro continuo predeterminado será `/aws-glue/jobs/error-` + El grupo de registro continuo personalizado será `-` Debe agregar `logs:AssociateKmsKey` a sus permisos de rol de IAM, si habilita una configuración de seguridad con CloudWatch Logs. Si no se incluye ese permiso, se deshabilitará el registro continuo. Además, para configurar el cifrado de CloudWatch Logs, siga las instrucciones en [Cifrar datos de registro en CloudWatch Logs mediante AWS Key Management Service](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/encrypt-log-data-kms.html) en la *Guía del usuario de Amazon CloudWatch Logs*. Para obtener más información sobre cómo crear una configuración de seguridad, consulte [Administración de las configuraciones de seguridad en la consola de AWS Glue](console-security-configurations.md). **nota** Es posible que se generen cargos adicionales al habilitar el registro y crear eventos de registro adicionales de CloudWatch. Para obtener más información, consulte los [ precios de Amazon CloudWatch ](https://aws.amazon.com/cloudwatch/pricing/). # Visualización de registros para trabajos de AWS Glue Puede ver registros en tiempo real mediante la consola de AWS Glue o la consola de Amazon CloudWatch. **Para ver registros en tiempo real mediante el panel de la consola de AWS Glue** 1. Inicie sesión en la Consola de administración de AWS y abra la consola de AWS Glue en [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). 1. En el panel de navegación, seleccione **Trabajos**. 1. Añada o inicie el trabajo que ya tiene. Elija **Action (Acción)**, **Run job (Ejecutar trabajo)**. Cuando inicia la ejecución de un trabajo, puede ir a una página que contiene información sobre el trabajo en ejecución: + La pestaña **Logs (Registros)** muestra los registros de la aplicación agregados más antiguos. + La pestaña **Registros** muestra una barra de progreso en tiempo real cuando el trabajo se ejecuta con `glueContext` inicializado. + La pestaña **Registros** también incluye los **Registros del controlador**, que capturan en tiempo real los registros del controlador de Apache Spark, así como los registros de la aplicación generados por el script mediante el registrador de la aplicación de AWS Glue cuando el trabajo está en ejecución. 1. Para trabajos más antiguos también puede ver los registros en tiempo real en la vista **Job History (Historial de trabajos)** eligiendo **Logs (Registros)**. Esta acción lo lleva a la consola de CloudWatch que muestra todos los flujos de registro del controlador de Spark, ejecutor y barra de progreso para ese trabajo ejecutado. **Para ver registros en tiempo real mediante el panel de la consola de CloudWatch** 1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. En el panel de navegación, elija **Log (Registro)**. 1. Elija el grupo de registro **/aws-glue/jobs/error/**. 1. En el cuadro **Filter (Filtro)**, pegue ID del trabajo en ejecución. Puede ver los registros del controlador, los registros del ejecutor y la barra de progreso (si utiliza el filtro **estándar**). # Monitorización con métricas de observabilidad de AWS Glue **nota** Las métricas de observabilidad de AWS Glue están disponibles en AWS Glue, versión 4.0 y versiones posteriores. Utilice las métricas de observabilidad de AWS Glue para obtener información sobre lo que ocurre dentro de sus trabajos de AWS Glue for Apache Spark y así mejorar la clasificación y el análisis de los problemas. Las métricas de observabilidad se visualizan a través de paneles de control Amazon CloudWatch y se pueden utilizar para analizar la causa raíz de los errores y diagnosticar los cuellos de botella en el rendimiento. Puede reducir el tiempo dedicado a depurar los problemas a gran escala para poder centrarse en resolverlos de forma más rápida y eficaz. La observabilidad de AWS Glue proporciona métricas Amazon CloudWatch clasificadas en los cuatro grupos siguientes: + **Fiabilidad (es decir, clases de errores)**: identifique fácilmente los motivos de error más comunes en un intervalo de tiempo determinado que desee abordar. + **Rendimiento (es decir, asimetría)**: identifique un obstáculo en el rendimiento y aplique técnicas de ajuste. Por ejemplo, si experimenta una disminución del rendimiento debido a la asimetría de los trabajos, es posible que desee activar Spark Adaptive Query Execution y ajustar el umbral de unión descompensado. + **Rendimiento (es decir, rendimiento por fuente/receptor)**: supervisa las tendencias de lectura y escritura de datos. También puede configurar alarmas Amazon CloudWatch para detectar anomalías. + **Utilización de los recursos (es decir, el personal, la utilización de la memoria y el disco)**: encuentre de manera eficiente los trabajos con un bajo uso de la capacidad. Es posible que desee habilitar el escalado automático de AWS Glue para esos trabajos. ## Cómo empezar con las métricas de observabilidad de AWS Glue **nota** Las nuevas métricas están habilitadas de forma predeterminada en la consola de AWS Glue Studio. **Para configurar las métricas de observabilidad en AWS Glue Studio:** 1. Inicie sesión en la consola AWS Glue y seleccione **Trabajos ETL** en el menú de la consola. 1. Elija un trabajo haciendo clic en el nombre del trabajo en la sección **Sus trabajos**. 1. Elija la pestaña **Detalles del trabajo**. 1. Desplácese hasta la parte inferior y seleccione **Propiedades avanzadas** y, a continuación, **Métricas de observabilidad del trabajo**. ![\[La captura de pantalla muestra la pestaña Detalles del trabajo, Propiedades avanzadas. La opción Métricas de observabilidad del trabajo está resaltada.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/job-details-observability-metrics.png) **Para habilitar las métricas de observabilidad de AWS Glue usando AWS CLI:** + Agregue al mapa `--default-arguments` el siguiente valor-clave en el archivo JSON de entrada: ``` --enable-observability-metrics, true ``` ## Uso de la observabilidad de AWS Glue Dado que las métricas de observabilidad de AWS Glue se proporcionan mediante Amazon CloudWatch, puede usar la consola Amazon CloudWatch, AWS CLI, el SDK o la API para consultar los puntos de datos de las métricas de observabilidad. Consulte [Uso de observabilidad de Glue para monitorear el uso de los recursos a fin de reducir el costo](https://aws.amazon.com/blogs/big-data/enhance-monitoring-and-debugging-for-aws-glue-jobs-using-new-job-observability-metrics/) para ver un ejemplo de caso práctico en el que se utilizan métricas de observabilidad de AWS Glue. ### Uso de la observabilidad de AWS Glue en la consola Amazon CloudWatch **Para consultar y visualizar las métricas en la consola Amazon CloudWatch:** 1. Abra la consola Amazon CloudWatch y seleccione **Todas las métricas**. 1. En Espacios de nombres personalizados, seleccione **AWS Glue**. 1. Elija **Métricas de observabilidad de trabajo, Métricas de observabilidad por origen o Métricas de observabilidad por receptor**. 1. Busque el nombre de la métrica, el nombre del trabajo o el identificador de ejecución específicos y selecciónelos. 1. En la pestaña **Métricas graficadas**, configure la estadística, el período y otras opciones que prefiera. ![\[La captura de pantalla muestra la consola Amazon CloudWatch y el gráfico de métricas.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/cloudwatch-console-metrics.png) **Para consultar una métrica de observabilidad mediante AWS CLI:** 1. Cree un archivo JSON de definición de métricas y reemplace `your-Glue-job-name` y `your-Glue-job-run-id`. ``` $ cat multiplequeries.json [ { "Id": "avgWorkerUtil_0", "MetricStat": { "Metric": { "Namespace": "Glue", "MetricName": "glue.driver.workerUtilization", "Dimensions": [ { "Name": "JobName", "Value": "" }, { "Name": "JobRunId", "Value": "" }, { "Name": "Type", "Value": "gauge" }, { "Name": "ObservabilityGroup", "Value": "resource_utilization" } ] }, "Period": 1800, "Stat": "Minimum", "Unit": "None" } }, { "Id": "avgWorkerUtil_1", "MetricStat": { "Metric": { "Namespace": "Glue", "MetricName": "glue.driver.workerUtilization", "Dimensions": [ { "Name": "JobName", "Value": "" }, { "Name": "JobRunId", "Value": "" }, { "Name": "Type", "Value": "gauge" }, { "Name": "ObservabilityGroup", "Value": "resource_utilization" } ] }, "Period": 1800, "Stat": "Minimum", "Unit": "None" } } ] ``` 1. Ejecute el comando `get-metric-data`: ``` $ aws cloudwatch get-metric-data --metric-data-queries file: //multiplequeries.json \ --start-time '2023-10-28T18: 20' \ --end-time '2023-10-28T19: 10' \ --region us-east-1 { "MetricDataResults": [ { "Id": "avgWorkerUtil_0", "Label": "", "Timestamps": [ "2023-10-28T18:20:00+00:00" ], "Values": [ 0.06718750000000001 ], "StatusCode": "Complete" }, { "Id": "avgWorkerUtil_1", "Label": "", "Timestamps": [ "2023-10-28T18:50:00+00:00" ], "Values": [ 0.5959183673469387 ], "StatusCode": "Complete" } ], "Messages": [] } ``` ## Métricas de observabilidad La observabilidad de AWS Glue crea perfiles y envía las siguientes métricas a Amazon CloudWatch cada 30 segundos, y algunas de estas métricas pueden estar visibles en la página de monitoreo de JobRuns de AWS Glue Studio. | Métrica | Descripción | Categoría | | --- | --- | --- | | glue.driver.skewness.stage | Categoría métrica: job\$1performance Spark clasifica la asimetría de la ejecución: esta métrica es un indicador de cuánto dura la actividad más larga en una determinada etapa en comparación con la duración media de las actividades en esa misma etapa. Captura la asimetría de la ejecución, que puede deberse a una asimetría de los datos de entrada o a una transformación (por ejemplo, una unión sesgada). Los valores de esta métrica se sitúan en el rango de [0, infinito [, donde 0 indica la relación entre el tiempo máximo y el tiempo medio de ejecución de las tareas; entre todas las tareas de la etapa, es inferior a un factor de asimetría de fase determinado. El factor de asimetría de fase predeterminado es 5 y se puede sobreescribir mediante spark conf: spark.metrics.conf.driver.source.glue.jobperformance.skewnessFactor Un valor de asimetría de fase igual a 1 significa que la relación es el doble del factor de asimetría de fase. El valor de la asimetría de fase se actualiza cada 30 segundos para reflejar la asimetría actual. El valor al final de la fase refleja la asimetría de fase final. Esta métrica a nivel de etapa se utiliza para calcular la métrica a nivel de trabajo. `glue.driver.skewness.job` Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre) y ObservAbilityGroup (job\$1performance) Estadísticas válidas: promedio, máximo, mínimo, percentilo Unidad: recuento | job\$1performance | | glue.driver.skewness.job | Categoría métrica: job\$1performance La asimetría del trabajo es el máximo de la asimetría ponderada de todas las etapas. La asimetría de la etapa (glue.driver.skewness.stage) se pondera con la duración de la etapa. El propósito de esto evitar el caso extremo en el que una etapa muy asimétrica dure muy poco tiempo en comparación con otras etapas (y, por lo tanto, su asimetría no sea significativa para el rendimiento general del trabajo y no valga la pena hacer el esfuerzo para tratar de corregir esa asimetría). Esta métrica se actualiza al finalizar cada etapa y, por lo tanto, el último valor refleja la asimetría general real del trabajo. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre) y ObservAbilityGroup (job\$1performance) Estadísticas válidas: promedio, máximo, mínimo, percentilo Unidad: recuento | job\$1performance | | glue.succeed.ALL | Categoría métrica: error Número total de tareas ejecutadas correctamente, para completar el panorama de las categorías de errores Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (recuento) y ObservAbilityGroup (error) Estadísticas válidas: SUMA Unidad: recuento | error | | glue.error.ALL | Categoría métrica: error Número total de errores al momento de ejecutar el trabajo, para completar el panorama de las categorías de errores Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (recuento) y ObservAbilityGroup (error) Estadísticas válidas: SUMA Unidad: recuento | error | | glue.error. [categoría de error] | Categoría métrica: error En realidad, se trata de un conjunto de métricas que se actualizan únicamente cuando se produce un error en la ejecución de un trabajo. La categorización de los errores ayuda a clasificar y depurar errores. Cuando se produce un error al ejecutar un trabajo, se clasifica el error que lo ha provocado y la métrica de la categoría de error correspondiente se define en 1. Esto ayuda a realizar un análisis de los errores a lo largo del tiempo, así como un análisis de los errores de todos los trabajos, para identificar las categorías de errores más comunes y empezar a abordarlas. AWS Glue tiene 28 categorías de error, incluidas las categorías de error OUT\$1OF\$1MEMORY (controlador y ejecutor), PERMISSION, SYNTAX y THROTTLING. Las categorías de error también incluyen las categorías COMPILATION, LAUNCH y TIMEOUT. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (recuento) y ObservAbilityGroup (error) Estadísticas válidas: SUMA Unidad: recuento | error | | glue.driver.workerUtilization | Categoría de métrica: resource\$1utilization El porcentaje de los trabajadores asignados que se utilizan realmente. Si no es bueno, el escalado automático puede ayudar. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre), y ObservAbilityGroup (resource\$1utilization) Estadísticas válidas: promedio, máximo, mínimo, percentilo Unidad: porcentaje | resource\$1utilization | | glue.driver.memory.heap. [disponible \$1 usado] | Categoría de métrica: resource\$1utilization La memoria de pila disponible o utilizada por el controlador durante la ejecución del trabajo. Esto ayuda a entender las tendencias de uso de la memoria, especialmente a lo largo del tiempo, lo que puede ayudar a evitar posibles fallos, además de depurar los errores relacionados con la memoria. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre), y ObservAbilityGroup (resource\$1utilization) Estadísticas válidas: Average Unidades: bytes | resource\$1utilization | | glue.driver.memory.heap.used.percentage | Categoría de métrica: resource\$1utilization El controlador utilizó (%) la memoria acumulada durante la ejecución del trabajo. Esto ayuda a entender las tendencias de uso de la memoria, especialmente a lo largo del tiempo, lo que puede ayudar a evitar posibles fallos, además de depurar los errores relacionados con la memoria. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre), y ObservAbilityGroup (resource\$1utilization) Estadísticas válidas: Average Unidad: porcentaje | resource\$1utilization | | glue.driver.memory.non-heap. [disponible \$1 usado] | Categoría de métrica: resource\$1utilization La memoria no acumulada disponible o utilizada por el controlador durante la ejecución del trabajo. Esto ayuda a entender las tendencias de uso de la memoria, especialmente a lo largo del tiempo, lo que puede ayudar a evitar posibles fallos, además de depurar los errores relacionados con la memoria. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre), y ObservAbilityGroup (resource\$1utilization) Estadísticas válidas: Average Unidades: bytes | resource\$1utilization | | glue.driver.memory.non-heap.used.percentage | Categoría de métrica: resource\$1utilization El controlador utilizó (%) memoria no acumulada durante la ejecución del trabajo. Esto ayuda a entender las tendencias de uso de la memoria, especialmente a lo largo del tiempo, lo que puede ayudar a evitar posibles fallos, además de depurar los errores relacionados con la memoria. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre), y ObservAbilityGroup (resource\$1utilization) Estadísticas válidas: Average Unidad: porcentaje | resource\$1utilization | | glue.driver.memory.total. [disponible \$1 usado] | Categoría de métrica: resource\$1utilization La memoria total disponible o utilizada por el controlador durante la ejecución del trabajo. Esto ayuda a entender las tendencias de uso de la memoria, especialmente a lo largo del tiempo, lo que puede ayudar a evitar posibles fallos, además de depurar los errores relacionados con la memoria. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre), y ObservAbilityGroup (resource\$1utilization) Estadísticas válidas: Average Unidades: bytes | resource\$1utilization | | glue.driver.memory.total.used.percentage | Categoría de métrica: resource\$1utilization El controlador utilizó (%) de la memoria total durante la ejecución del trabajo. Esto ayuda a entender las tendencias de uso de la memoria, especialmente a lo largo del tiempo, lo que puede ayudar a evitar posibles fallos, además de depurar los errores relacionados con la memoria. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre), y ObservAbilityGroup (resource\$1utilization) Estadísticas válidas: Average Unidad: porcentaje | resource\$1utilization | | Glue.all.memory.heap. [disponible \$1 usado] | Categoría de métrica: resource\$1utilization La memoria de pila utilizada/disponible de los ejecutores. ALL significa todos los ejecutores. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre), y ObservAbilityGroup (resource\$1utilization) Estadísticas válidas: Average Unidades: bytes | resource\$1utilization | | glue.ALL.memory.heap.used.percentage | Categoría de métrica: resource\$1utilization La memoria de pila utilizada por los ejecutores (%). ALL significa todos los ejecutores. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre), y ObservAbilityGroup (resource\$1utilization) Estadísticas válidas: Average Unidad: porcentaje | resource\$1utilization | | glue.ALL.memory.non-heap. [disponible \$1 usado] | Categoría de métrica: resource\$1utilization La memoria que no es de pila disponible/utilizada por los ejecutores. ALL significa todos los ejecutores. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre), y ObservAbilityGroup (resource\$1utilization) Estadísticas válidas: Average Unidades: bytes | resource\$1utilization | | glue.ALL.memory.non-heap.used.percentage | Categoría de métrica: resource\$1utilization Los ejecutores utilizaron (%) de memoria que no es de pila. ALL significa todos los ejecutores. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre), y ObservAbilityGroup (resource\$1utilization) Estadísticas válidas: Average Unidad: porcentaje | resource\$1utilization | | glue.ALL.memory.total. [disponible \$1 usado] | Categoría de métrica: resource\$1utilization La memoria total utilizada/disponible de los ejecutores. ALL significa todos los ejecutores. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre), y ObservAbilityGroup (resource\$1utilization) Estadísticas válidas: Average Unidades: bytes | resource\$1utilization | | glue.ALL.memory.total.used.percentage | Categoría de métrica: resource\$1utilization La memoria total (%) utilizada por los ejecutores. ALL significa todos los ejecutores. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre), y ObservAbilityGroup (resource\$1utilization) Estadísticas válidas: Average Unidad: porcentaje | resource\$1utilization | | glue.driver.disk. [disponible\$1GB \$1 usado\$1GB] | Categoría de métrica: resource\$1utilization El espacio en disco disponible o usado por el controlador durante la ejecución del trabajo. Esto ayuda a entender las tendencias de uso del disco, especialmente a lo largo del tiempo, lo que puede ayudar a evitar posibles fallos, además de depurar los errores relacionados con la falta de espacio en disco. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre), y ObservAbilityGroup (resource\$1utilization) Estadísticas válidas: Average Unidad: Gigabytes | resource\$1utilization | | glue.driver.disk.used.percentage] | Categoría de métrica: resource\$1utilization El espacio en disco disponible o usado por el controlador durante la ejecución del trabajo. Esto ayuda a entender las tendencias de uso del disco, especialmente a lo largo del tiempo, lo que puede ayudar a evitar posibles fallos, además de depurar los errores relacionados con la falta de espacio en disco. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre), y ObservAbilityGroup (resource\$1utilization) Estadísticas válidas: Average Unidad: porcentaje | resource\$1utilization | | glue.ALL.disk. [disponible\$1GB \$1 usado\$1GB] | Categoría de métrica: resource\$1utilization El espacio en disco usado/disponible de los ejecutores. ALL significa todos los ejecutores. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre), y ObservAbilityGroup (resource\$1utilization) Estadísticas válidas: Average Unidad: Gigabytes | resource\$1utilization | | glue.ALL.disk.used.percentage | Categoría de métrica: resource\$1utilization El espacio en disco disponible/usado/usado (%) de los ejecutores. ALL significa todos los ejecutores. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunId (el ID de JobRun o ALL), Type (calibre), y ObservAbilityGroup (resource\$1utilization) Estadísticas válidas: Average Unidad: porcentaje | resource\$1utilization | | glue.driver.bytesRead | Categoría métrica: rendimiento El número de bytes leídos por fuente de entrada en esta ejecución de trabajo, y en TODAS las fuentes. Esto ayuda a entender el volumen de datos y sus cambios a lo largo del tiempo, lo que ayuda a tratar problemas como la asimetría de los datos. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunID (el JobRun ID. o ALL), Type (calibre), ObservabilityGroup (resource\$1utilization) y Source (ubicación de los datos de origen) Estadísticas válidas: Average Unidades: bytes | rendimiento | | glue.driver. [Registros leídos \$1 Archivos leídos] | Categoría métrica: rendimiento El número de registros/archivos leídos por fuente de entrada en esta ejecución de trabajo, y en TODAS las fuentes. Esto ayuda a entender el volumen de datos y sus cambios a lo largo del tiempo, lo que ayuda a tratar problemas como la asimetría de los datos. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunID (el JobRun ID. o ALL), Type (calibre), ObservabilityGroup (resource\$1utilization) y Source (ubicación de los datos de origen) Estadísticas válidas: Average Unidad: recuento | rendimiento | | glue.driver.partitionsRead | Categoría métrica: rendimiento El número de particiones leídas por fuente de entrada de Amazon S3 en esta ejecución de trabajo, y para TODAS las fuentes. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunID (el JobRun ID. o ALL), Type (calibre), ObservabilityGroup (resource\$1utilization) y Source (ubicación de los datos de origen) Estadísticas válidas: Average Unidad: recuento | rendimiento | | glue.driver.bytesWrittten | Categoría métrica: rendimiento El número de bytes escritos por receptor de salida en esta ejecución de trabajo, y en TODOS los receptores. Esto ayuda a entender el volumen de datos y cómo evoluciona con el tiempo, lo que ayuda a tratar problemas como la asimetría del procesamiento. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunID (el JobRun ID. o ALL), Type (calibre), ObservabilityGroup (resource\$1utilization) y Sink (ubicación de los datos de sink) Estadísticas válidas: Average Unidades: bytes | rendimiento | | glue.driver. [Registros escritos \$1 Archivos escritos] | Categoría métrica: rendimiento El número de registros o archivos escritos por receptor de salida en esta ejecución de trabajo, y en TODOS los receptores. Esto ayuda a entender el volumen de datos y cómo evoluciona con el tiempo, lo que ayuda a tratar problemas como la asimetría del procesamiento. Dimensiones válidas: JobName (el nombre del trabajo de AWS Glue), JobRunID (el JobRun ID. o ALL), Type (calibre), ObservabilityGroup (resource\$1utilization) y Sink (ubicación de los datos de sink) Estadísticas válidas: Average Unidad: recuento | rendimiento | ## Categorías de errores | Categorías de errores | Descripción | | --- | --- | | COMPILATION\$1ERROR | Los errores surgen durante la compilación del código de Scala. | | CONNECTION\$1ERROR | Los errores se producen durante la conexión a un servicio remoto/servicio de host/base de datos, etc. | | DISK\$1NO\$1SPACE\$1ERROR | Los errores se producen cuando no queda espacio en el disco del controlador/ejecutor. | | OUT\$1OF\$1MEMORY\$1ERROR | Los errores se producen cuando no queda espacio en la memoria del controlador/ejecutor. | | IMPORT\$1ERROR | Los errores se producen al importar dependencias. | | INVALID\$1ARGUMENT\$1ERROR | Los errores se producen cuando los argumentos de entrada son inválidos o ilegales. | | PERMISSION\$1ERROR | Los errores se producen cuando no se tiene el permiso para acceder al servicio, los datos, etc. | | RESOURCE\$1NOT\$1FOUND\$1ERROR | Los errores se producen cuando los datos, la ubicación, etc. no existen. | | QUERY\$1ERROR | Los errores se producen por la ejecución de una consulta SQL de Spark. | | SYNTAX\$1ERROR | Los errores se producen cuando hay un error de sintaxis en el script. | | THROTTLING\$1ERROR | Los errores se producen cuando se alcanza el límite de simultaneidad del servicio o se supera el límite de la cuota de servicio. | | DATA\$1LAKE\$1FRAMEWORK\$1ERROR | Los errores se deben a un marco de lago de datos con soporte nativo de AWS Glue, como Hudi, Iceberg, etc. | | UNSUPPORTED\$1OPERATION\$1ERROR | Los errores se producen al realizar una operación no compatible. | | RESOURCES\$1ALREADY\$1EXISTS\$1ERROR | Los errores se producen cuando un recurso que se va a crear o añadir ya existe. | | GLUE\$1INTERNAL\$1SERVICE\$1ERROR | Los errores se producen cuando hay un problema de servicio interno de AWS Glue. | | GLUE\$1OPERATION\$1TIMEOUT\$1ERROR | Los errores se producen cuando se agota el tiempo de espera de una operación de AWS Glue. | | GLUE\$1VALIDATION\$1ERROR | Los errores se producen cuando no se ha podido validar un valor requerido para el trabajo de AWS Glue. | | GLUE\$1JOB\$1BOOKMARK\$1VERSION\$1MISMATCH\$1ERROR | Los errores se producen cuando ejecuta el mismo trabajo en el mismo bucket de origen y escribe en el mismo destino o en uno diferente simultáneamente (concurrencia >1) | | LAUNCH\$1ERROR | Los errores se producen durante la fase de inicio del trabajo de AWS Glue. | | DYNAMODB\$1ERROR | Los errores genéricos se deben al servicio de Amazon DynamoDB. | | GLUE\$1ERROR | Los errores genéricos se deben al servicio de AWS Glue. | | LAKEFORMATION\$1ERROR | Los errores genéricos se deben al servicio de AWS Lake Formation. | | REDSHIFT\$1ERROR | Los errores genéricos se deben al servicio de Amazon Redshift. | | S3\$1ERROR | Los errores genéricos se deben al servicio de Amazon S3. | | SYSTEM\$1EXIT\$1ERROR | Error genérico de salida del sistema. | | TIMEOUT\$1ERROR | Los errores genéricos se producen cuando el trabajo falla debido al tiempo de espera de la operación. | | UNCLASSIFIED\$1SPARK\$1ERROR | Los errores genéricos se deben a Spark. | | UNCLASSIFIED\$1ERROR | Categoría de errores predeterminada. | ## Limitaciones **nota** `glueContext` debe inicializarse para publicar las métricas. En la dimensión de origen, el valor es la ruta de Amazon S3 o el nombre de la tabla, según el tipo de fuente. Además, si la fuente es JDBC y se usa la opción de consulta, la cadena de consulta se establece en la dimensión de origen. Si el valor tiene más de 500 caracteres, se recorta hasta 500 caracteres. El valor tiene las siguientes limitaciones: + Se eliminarán los caracteres que no sean ASCII. + Si el nombre de la fuente no contiene ningún carácter ASCII, se convierte en . ### Limitaciones y consideraciones de las métricas de rendimiento + Se admiten DataFrame y DynamicFrame basado en DataFrame (por ejemplo, JDBC, lectura desde parquet en Amazon S3); sin embargo, no se admite DynamicFrame basado en RDD (por ejemplo, leer csv, json en Amazon S3, etc.). Técnicamente, se admiten todas las lecturas y escrituras visibles en la interfaz de usuario de Spark. + La métrica `recordsRead` se emitirá si el origen de datos es una tabla de catálogo y el formato es JSON, CSV, texto o Iceberg. + Las métricas `glue.driver.throughput.recordsWritten`, `glue.driver.throughput.bytesWritten` y `glue.driver.throughput.filesWritten` no están disponibles en las tablas JDBC e Iceberg. + Es posible que las métricas se retrasen. Si el trabajo finaliza en aproximadamente un minuto, es posible que no haya métricas de rendimiento en Amazon CloudWatch Metrics. # Monitorización y depuración de trabajo Puede recopilar métricas acerca de los trabajos de AWS Glue y visualizarlas en las consolas de AWS Glue y Amazon CloudWatch para identificar y solucionar problemas. La generación de perfiles en sus trabajos de AWS Glue requiere los siguientes pasos: 1. Habilitar las métricas: 1. Habilite la opción **Job metrics (Métricas del trabajo)** en la definición de trabajo. Puede habilitar la creación de perfiles en la consola de AWS Glue o como parámetro del trabajo. Para obtener más información, consulte [Definición de propiedades de trabajo para trabajos de Spark](add-job.md#create-job) o [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md). 1. Habilite la opción **Métricas de observabilidad AWS Glue** en la definición de trabajo. Puede habilitar la observabilidad en la consola de AWS Glue o como parámetro del trabajo. Para obtener más información consulte () [Monitorización con métricas de observabilidad de AWS Glue](monitor-observability.md). 1. Confirme que el script de trabajo inicializa `GlueContext`. Por ejemplo, el siguiente fragmento de script inicializa `GlueContext` y muestra en qué parte del script se sitúa el código con perfil. Este formato general se usa en las situaciones de depuración siguientes. ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job import time ## @params: [JOB_NAME] args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME'], args) ... ... code-to-profile ... ... job.commit() ``` 1. Ejecute el trabajo. 1. Visualización de las métricas: 1. Visualice las métricas de trabajo en la consola AWS Glue e identifique las métricas que están fuera de lo normal para el controlador o un ejecutor. 1. Compruebe las métricas de observabilidad en la página de monitorización de las ejecuciones de tareas, en la página de detalles de las ejecuciones de tareas o en Amazon CloudWatch. Para obtener más información, consulte [Monitorización con métricas de observabilidad de AWS Glue](monitor-observability.md). 1. Acote la causa raíz mediante la métrica identificada. 1. Opcionalmente, confirme la causa raíz mediante el flujo de registros del controlador o el ejecutor de trabajo identificado. **Casos de uso de las métricas de observabilidad de AWS Glue** + [Depuración de excepciones de memoria insuficiente e irregularidades relativas al trabajo](monitor-profile-debug-oom-abnormalities.md) + [Depuración de etapas exigentes y tareas rezagadas](monitor-profile-debug-straggler.md) + [Monitoreo del progreso de varios trabajos](monitor-debug-multiple.md) + [Monitorización de la planificación de la capacidad de DPU](monitor-debug-capacity.md) + [Uso de la observabilidad de AWS Glue para monitorear el uso de los recursos a fin de reducir los costos](https://aws.amazon.com/blogs/big-data/enhance-monitoring-and-debugging-for-aws-glue-jobs-using-new-job-observability-metrics) # Depuración de excepciones de memoria insuficiente e irregularidades relativas al trabajo Puede depurar excepciones de memoria insuficiente (OOM) e irregularidades relativas al trabajo en AWS Glue. En las siguientes secciones se describen situaciones de depuración de excepciones de memoria insuficiente del controlador Apache Spark o un ejecutor de Spark. + [Depuración de una excepción de memoria insuficiente del controlador](#monitor-profile-debug-oom-driver) + [Depuración de una excepción de memoria insuficiente del ejecutor](#monitor-profile-debug-oom-executor) ## Depuración de una excepción de memoria insuficiente del controlador En esta situación, un trabajo de Spark está leyendo un gran número de pequeños archivos desde Amazon Simple Storage Service (Amazon S3). Convierte los archivos al formato Apache Parquet y, a continuación, los escribe en Amazon S3. El controlador Spark se está quedando sin memoria. Los datos de Amazon S3 de entrada tienen más de un millón de archivos en diferentes particiones de Amazon S3. El código con perfil es el siguiente: ``` data = spark.read.format("json").option("inferSchema", False).load("s3://input_path") data.write.format("parquet").save(output_path) ``` ### Visualizar las métricas con perfil en la consola de AWS Glue En el siguiente gráfico se muestra el uso de la memoria como porcentaje del controlador y los ejecutores. Este uso se traza como un punto de datos que se promedia a lo largo de los valores notificados en el último minuto. En el perfil de la memoria del trabajo, puede ver que la [memoria del controlador](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.jvm.heap.usage) cruza el umbral seguro del 50 % de uso con rapidez. Por otra parte, el [uso medio de la memoria](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage) en todos los ejecutores sigue siendo inferior al 4 %. Esto es una clara muestra de irregularidad en la ejecución del controlador en el trabajo de Spark. ![\[El uso de la memoria en porcentaje del controlador y los ejecutores.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-oom-memoryprofile.png) La ejecución del trabajo produce un error enseguida y aparece el siguiente error en la pestaña **History (Historial)** de la consola de AWS Glue: Command Failed with Exit Code 1. Esta cadena de error significa que el trabajo falló debido a un error sistémico, que en este caso se trata de la falta de memoria del controlador. ![\[Mensaje de error mostrado en la consola de AWS Glue.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-oom-errorstring.png) En la consola, elija el enlace **Error logs (Registros de error)** en la pestaña **History (Historial)** para confirmar el hallazgo relativo a la falta de memoria del controlador desde CloudWatch Logs. Busque "**Error**" en los registros de errores del trabajo para confirmar que se trató, sin duda, de una excepción de memoria insuficiente que imposibilitó la realización del trabajo: ``` # java.lang.OutOfMemoryError: Java heap space # -XX:OnOutOfMemoryError="kill -9 %p" # Executing /bin/sh -c "kill -9 12039"... ``` En la pestaña **History (Historial)** del trabajo, elija **Logs (Registros)**. Puede encontrar el siguiente rastro de la ejecución del controlador en CloudWatch Logs al empezar el trabajo. El controlador Spark intenta listar todos los archivos en todos los directorios, crea `InMemoryFileIndex` y lanza una tarea por archivo. Esto, a su vez, hace que el controlador Spark tenga que mantener una gran cantidad de estado en memoria para realizar un seguimiento de todas las tareas. Almacena en caché la lista completa de un gran número de archivos para el índice en memoria, lo que da lugar a la falta de memoria de un controlador. ### Corregir el procesamiento de varios archivos mediante su agrupación Puede corregir el procesamiento de los numerosos archivos mediante la capacitación de *agrupación* en AWS Glue. La agrupación se habilita automáticamente al usar marcos dinámicos y cuando el conjunto de datos de entrada tiene un gran número de archivos (más de 50 000). La agrupación le permite fusionar varios archivos en un grupo y deja que una tarea procese todo el grupo en vez de un solo archivo. Como resultado, la cantidad de estado en memoria que almacena el controlador Spark es considerablemente más baja para realizar un seguimiento de menos tareas. Para obtener más información acerca de cómo habilitar manualmente la agrupación de su conjunto de datos, consulte [Lectura de archivos de entrada en grupos más grandes](grouping-input-files.md). Para comprobar el perfil de la memoria del trabajo de AWS Glue, genere perfiles en el siguiente código con la agrupación habilitada: ``` df = glueContext.create_dynamic_frame_from_options("s3", {'paths': ["s3://input_path"], "recurse":True, 'groupFiles': 'inPartition'}, format="json") datasink = glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet", transformation_ctx = "datasink") ``` Puede monitorear el perfil de la memoria y el movimiento de datos de ETL en el perfil de trabajo de AWS Glue. El controlador se ejecuta por debajo del umbral del 50 % de uso de la memoria durante todo el trabajo de AWS Glue. Los ejecutores transmiten los datos desde Amazon S3, los procesan y los escriben en Amazon S3. Como resultado, consumen un porcentaje de memoria inferior al 5 % en cualquier momento. ![\[El perfil de la memoria muestra que se ha corregido el problema.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-oom-memoryprofile-fixed.png) El perfil de movimiento de datos a continuación muestra el número total de bytes de Amazon S3 que todos los ejecutores [leen](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) y [escriben](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes) en el último minuto a medida que progresa el trabajo. Ambos siguen un patrón similar, puesto que todos los ejecutores transmiten los datos. El trabajo termina de procesar el millón de archivos en menos de tres horas. ![\[El perfil de movimiento de datos muestra que se ha corregido el problema.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-oom-etlmovement.png) ## Depuración de una excepción de memoria insuficiente del ejecutor En esta situación, puede aprender a depurar excepciones de memoria insuficiente que podrían producirse en los ejecutores Apache Spark. El siguiente código usa el lector de Spark MySQL para leer una gran tabla de unos 34 millones de filas en un DataFrame de Spark. A continuación, la escribe en Amazon S3 en formato Parquet. Puede proporcionar las propiedades de la conexión y usar las configuraciones de Spark predeterminadas para leer la tabla. ``` val connectionProperties = new Properties() connectionProperties.put("user", user) connectionProperties.put("password", password) connectionProperties.put("Driver", "com.mysql.jdbc.Driver") val sparkSession = glueContext.sparkSession val dfSpark = sparkSession.read.jdbc(url, tableName, connectionProperties) dfSpark.write.format("parquet").save(output_path) ``` ### Visualizar las métricas con perfil en la consola de AWS Glue Si la pendiente del gráfico de uso de memoria es positiva y supera el 50 por ciento, si se produce un error en el trabajo antes de que se emita la siguiente métrica, la causa bien se puede deber al agotamiento de memoria. En el siguiente gráfico se muestra que, transcurrido un minuto desde el inicio de la ejecución, el [uso medio de la memoria](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage) en todos los ejecutores aumenta rápidamente por encima del 50 %. El uso llega a alcanzar el 92 % y Apache Hadoop YARN cancela el contenedor que ejecuta el ejecutor. ![\[El uso medio de la memoria en todos los ejecutores.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-oom-2-memoryprofile.png) Tal como aparece en el siguiente gráfico, siempre hay un [único ejecutor](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors) en ejecución hasta que el trabajo produce un error. Esto se debe al lanzamiento de un nuevo ejecutor para reemplazar el ejecutor cancelado. Las lecturas del origen de datos JDBC no se paralelizan de forma predeterminada, ya que requeriría que se particionara la tabla en una columna y que se abrieran varias conexiones. Como resultado, solo un ejecutor lee la tabla completa de forma secuencial. ![\[La ejecución de trabajo muestra un único ejecutor en ejecución hasta que el trabajo produce un error.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-oom-2-execution.png) Tal como se muestra en el siguiente gráfico, Spark intenta lanzar una nueva tarea cuatro veces antes de producir el trabajo el error. Puede ver el [perfil de la memoria](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.used) de tres ejecutores. Cada ejecutor usa rápidamente toda su memoria. El cuarto ejecutor se queda sin memoria y el trabajo produce un error. Como resultado, su métrica no se notifica inmediatamente. ![\[Los perfiles de la memoria de los ejecutores.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-oom-2-exec-memprofile.png) Puede confirmar desde la cadena de error de la consola de AWS Glue que el trabajo produjo un error debido a excepciones de memoria insuficiente, como se muestra en la siguiente imagen. ![\[Mensaje de error mostrado en la consola de AWS Glue.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-oom-2-errorstring.png) **Registros de salida del trabajo:** para confirmar aún más su hallazgo de una excepción de memoria insuficiente, examine CloudWatch Logs. Al buscar **Error**, verá cómo se cancelan los cuatro ejecutores casi al mismo tiempo como se muestra en el panel de métricas. YARN termina todos, ya que superan sus límites de memoria. Ejecutor 1 ``` 18/06/13 16:54:29 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:54:29 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:54:29 ERROR YarnClusterScheduler: Lost executor 1 on ip-10-1-2-175.ec2.internal: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:54:29 WARN TaskSetManager: Lost task 0.0 in stage 0.0 (TID 0, ip-10-1-2-175.ec2.internal, executor 1): ExecutorLostFailure (executor 1 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. ``` Ejecutor 2 ``` 18/06/13 16:55:35 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:55:35 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:55:35 ERROR YarnClusterScheduler: Lost executor 2 on ip-10-1-2-16.ec2.internal: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:55:35 WARN TaskSetManager: Lost task 0.1 in stage 0.0 (TID 1, ip-10-1-2-16.ec2.internal, executor 2): ExecutorLostFailure (executor 2 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. ``` Ejecutor 3 ``` 18/06/13 16:56:37 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:56:37 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:56:37 ERROR YarnClusterScheduler: Lost executor 3 on ip-10-1-2-189.ec2.internal: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:56:37 WARN TaskSetManager: Lost task 0.2 in stage 0.0 (TID 2, ip-10-1-2-189.ec2.internal, executor 3): ExecutorLostFailure (executor 3 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. ``` Ejecutor 4 ``` 18/06/13 16:57:18 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:57:18 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:57:18 ERROR YarnClusterScheduler: Lost executor 4 on ip-10-1-2-96.ec2.internal: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:57:18 WARN TaskSetManager: Lost task 0.3 in stage 0.0 (TID 3, ip-10-1-2-96.ec2.internal, executor 4): ExecutorLostFailure (executor 4 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. ``` ### Corregir la configuración del tamaño de búsqueda mediante marcos dinámicos de AWS Glue El ejecutor se quedó sin memoria durante la lectura de la tabla de JDBC, ya que la configuración predeterminada del tamaño de búsqueda de JDBC de Spark es cero. Esto significa que el controlador JDBC del ejecutor de Spark intenta recuperar los 34 millones de filas de la base de datos de forma conjunta y almacenarlas en caché, aunque Spark se transmita a través de las filas de una en una. Con Spark, puede evitar esta situación estableciendo el parámetro de tamaño de búsqueda en un valor predeterminado distinto de cero. También puede solucionar este problema con marcos dinámicos de AWS Glue en su lugar. De forma predeterminada, los marcos dinámicos utilizan un tamaño de captura de 1000 filas, que suele ser un valor suficiente. Como resultado, el ejecutor no usa más del 7 % de su memoria total. El trabajo de AWS Glue finaliza en menos de dos minutos con un único ejecutor solamente. Aunque el enfoque recomendado es utilizar los marcos dinámicos de AWS Glue, también se puede definir el tamaño de captura con la propiedad `fetchsize` de Apache Spark. Consulte la [guía de Spark SQL, DataFrames y Datasets](https://spark.apache.org/docs/2.2.0/sql-programming-guide.html#jdbc-to-other-databases). ``` val (url, database, tableName) = { ("jdbc_url", "db_name", "table_name") } val source = glueContext.getSource(format, sourceJson) val df = source.getDynamicFrame glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet", transformation_ctx = "datasink") ``` **Métricas con perfil normales**: la [memoria del ejecutor](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage) con marcos dinámicos de AWS Glue nunca supera el umbral seguro, como se muestra en la siguiente imagen. Se transmite en las filas de la base de datos y almacena en caché solo 1000 filas en el controlador JDBC en cualquier momento. No se producen excepciones de memoria insuficiente. ![\[La consola de AWS Glue muestra que la memoria del ejecutor está por debajo del umbral seguro.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-oom-2-memoryprofile-fixed.png) # Depuración de etapas exigentes y tareas rezagadas Puede usar perfiles de trabajo de AWS Glue para identificar etapas exigentes y tareas rezagadas en sus trabajos de extracción, transformación y carga (ETL). Una tarea rezagada tarda mucho más que las demás tareas en una etapa de un trabajo de AWS Glue. Como resultado, la etapa tarda más en completarse, lo que también retrasa el tiempo de ejecución total del trabajo. ## Fusión de archivos de entrada pequeños en archivos de salida más grandes Una tarea rezagada puede producirse si hay una distribución no uniforme de trabajo entre las diferentes tareas, o un sesgo de datos da lugar a un mayor procesamiento de datos por parte de una tarea. Puede generar perfiles en el siguiente código, un patrón común en Apache Spark, para fusionar un gran número de archivos pequeños en archivos de salida más grandes. En este ejemplo, el conjunto de datos de entrada tiene 32 GB de archivos comprimidos Gzip JSON. El conjunto de datos de salida tiene casi 190 GB de archivos JSON sin comprimir. El código con perfil es el siguiente: ``` datasource0 = spark.read.format("json").load("s3://input_path") df = datasource0.coalesce(1) df.write.format("json").save(output_path) ``` ### Visualizar las métricas con perfil en la consola de AWS Glue Puede generar perfiles en su trabajo para examinar cuatro conjuntos de métricas diferentes: + Movimiento de datos de ETL + Mezcla de datos entre los ejecutores + Ejecución de trabajo + Perfil de la memoria **Movimiento de datos de ETL**: en el perfil **ETL Data Movement (Movimiento de datos de ETL)**, todos los ejecutores [leen](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) los bytes con bastante rapidez en la primera etapa que se completa en los primeros seis minutos. Sin embargo, el tiempo de ejecución del trabajo total es de aproximadamente una hora, componiéndose principalmente de las [escrituras](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes) de datos. ![\[En el gráfico se muestra el perfil ETL Data Movement (Movimiento de datos de ETL).\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-straggler-1.png) **Mezcla de datos entre los ejecutores:** el número de bytes [leídos](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleLocalBytesRead) y [escritos](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleBytesWritten) durante la mezcla también muestra un pico antes de finalizar la segunda etapa, como indican las métricas **Job Execution (Ejecución de trabajo)** y **Data Shuffle (Mezcla de datos)**. Una vez que se mezclan los datos de todos los ejecutores, las lecturas y escrituras siguen solo a partir del tercer ejecutor. ![\[Las métricas de mezcla de datos entre los ejecutores.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-straggler-2.png) **Ejecución de trabajo:** tal como se muestra en el gráfico a continuación, todos los demás ejecutores están inactivos y finalmente se renuncia a ellos por el tiempo 10:09. En este momento, el número total de ejecutores disminuye a solo uno. Esto muestra claramente que el tercer ejecutor se compone de la tarea rezagada que más tiempo de ejecución emplea y que contribuye a la mayor parte del tiempo de ejecución del trabajo. ![\[Las métricas de ejecución de los ejecutores activos.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-straggler-3.png) **Perfil de la memoria:** después de las primeras dos etapas, solo el [tercer ejecutor](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.used) consume memoria de forma activa para procesar los datos. Los demás ejecutores están simplemente inactivos o se ha renunciado a ellos poco después de completarse las primeras dos etapas. ![\[Las métricas del perfil de la memoria después de las primeras dos etapas.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-straggler-4.png) ### Corregir ejecutores rezagados mediante agrupación Puede evitar los ejecutores rezagados mediante la capacitación de *agrupación* en AWS Glue. Utilice la agrupación para distribuir los datos de manera uniforme entre todos los ejecutores y fusionar archivos en archivos más grandes mediante el uso de todos los ejecutores disponibles en el clúster. Para obtener más información, consulte [Lectura de archivos de entrada en grupos más grandes](grouping-input-files.md). Para comprobar los movimientos de datos de ETL en el trabajo de AWS Glue, genere perfiles en el siguiente código con la agrupación habilitada: ``` df = glueContext.create_dynamic_frame_from_options("s3", {'paths': ["s3://input_path"], "recurse":True, 'groupFiles': 'inPartition'}, format="json") datasink = glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "json", transformation_ctx = "datasink4") ``` **Movimiento de datos de ETL:** las escrituras de datos ahora se transmiten en paralelo con las lecturas de datos a lo largo del tiempo de ejecución del trabajo. Como resultado, el trabajo finaliza en ocho minutos, mucho más rápido que antes. ![\[Los movimientos de datos de ETL muestran que se ha corregido el problema.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-straggler-5.png) **Mezcla de datos entre los ejecutores:** como los archivos de entrada se fusionan durante las lecturas mediante la capacitación de agrupación, no hay ninguna mezcla de datos costosa después de las lecturas de datos. ![\[Las métricas de mezcla de datos muestran que se ha corregido el problema.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-straggler-6.png) **Ejecución de trabajo:** las métricas de ejecución de trabajo muestran que el número total de ejecutores activos que ejecutan y procesan datos permanecen bastante constantes. No hay ningún rezagado en el trabajo. Todos los ejecutores están activos y no se renuncia a ellos hasta completarse el trabajo. Como no hay mezcla de datos intermedia alguna entre los ejecutores, solo hay una única etapa en el trabajo. ![\[Las métricas del widget Job Execution muestran que no hay ningún rezagado en el trabajo.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-straggler-7.png) **Perfil de memoria:** las métricas muestran el [consumo de memoria activa](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.used) entre todos los ejecutores, lo que confirma una vez más que hay actividad en todos los ejecutores. Como los datos se reciben y escriben en paralelo, la huella de memoria total de todos los ejecutores es más o menos uniforme y está muy por debajo del umbral seguro de todos los ejecutores. ![\[Las métricas del perfil de la memoria muestran el consumo de memoria activa entre todos los ejecutores.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-straggler-8.png) # Monitoreo del progreso de varios trabajos Puede generar perfiles en varios trabajos de AWS Glue de forma conjunta y monitorear el flujo de datos entre ellos. Se trata de un patrón de flujo de trabajo habitual y requiere el monitoreo del progreso de trabajos individuales, las tareas pendientes de procesamiento de datos, el reprocesamiento de datos y los marcadores de trabajos. **Topics** + [Código con perfil](#monitor-debug-multiple-profile) + [Visualizar las métricas con perfil en la consola de AWS Glue](#monitor-debug-multiple-visualize) + [Corregir el procesamiento de los archivos](#monitor-debug-multiple-fix) ## Código con perfil En este flujo de trabajo, tiene dos trabajos: un trabajo de entrada y un trabajo de salida. El trabajo de entrada está programado para ejecutarse cada 30 minutos mediante un disparador periódico. El trabajo de salida está programado para ejecutarse tras cada ejecución correcta del trabajo de entrada. Estos trabajos programados se controlan mediante disparadores del trabajo. ![\[Captura de pantalla de la consola que muestra los disparadores del trabajo que controlan la programación de los trabajos de entrada y salida.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-multiple-1.png) **Trabajo de entrada**: este trabajo lee datos desde una ubicación de Amazon Simple Storage Service (Amazon S3), los transforma mediante `ApplyMapping` y los escribe en una ubicación de Amazon S3 provisional. El siguiente código es código con perfil para el trabajo de entrada: ``` datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": ["s3://input_path"], "useS3ListImplementation":True,"recurse":True}, format="json") applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [map_spec]) datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": staging_path, "compression": "gzip"}, format = "json") ``` **Trabajo de salida**: este trabajo lee la salida del trabajo de entrada desde la ubicación provisional en Amazon S3, la vuelve a transformar y la escribe en un destino: ``` datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [staging_path], "useS3ListImplementation":True,"recurse":True}, format="json") applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [map_spec]) datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": output_path}, format = "json") ``` ## Visualizar las métricas con perfil en la consola de AWS Glue El siguiente panel superpone la métrica escrita de bytes de Amazon S3 desde el trabajo de entrada en la métrica leída de bytes de Amazon S3 en la misma escala de tiempo del trabajo de salida. La escala de tiempo muestra diferentes ejecuciones de trabajo de los trabajos de entrada y salida. El trabajo de entrada (mostrado en rojo) comienza cada 30 minutos. El trabajo de salida (mostrado en marrón) comienza al finalizar el trabajo de entrada, con una simultaneidad máxima de 1. ![\[Gráfico donde se muestran los datos leídos y escritos.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-multiple-4.png) En este ejemplo, los [marcadores de trabajos](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html) no están habilitados. No se usa ningún contexto de transformación para habilitar marcadores de trabajos en el código de script. **Historial de trabajos**: los trabajos de entrada y salida tienen varias ejecuciones, como se muestra en la pestaña **History (Historial)**, las cuales comienzan a partir de las 12:00 h. El trabajo de entrada de la consola de AWS Glue tiene este aspecto: ![\[Captura de pantalla de la consola donde se muestra la pestaña History (Historial) del trabajo de entrada.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-multiple-2.png) En la siguiente imagen se muestra el trabajo de salida: ![\[Captura de pantalla de la consola donde se muestra la pestaña History (Historial) del trabajo de salida.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-multiple-3.png) **Primeras ejecuciones de trabajo**: como se muestra en el siguiente gráfico de bytes de datos leídos y escritos, las primeras ejecuciones de trabajo de los trabajos de entrada y salida entre las 12:00 y las 12:30 h muestran más o menos la misma área bajo las curvas. Esas áreas representan los bytes de Amazon S3 escritos por el trabajo de entrada y los bytes de Amazon S3 leídos por el trabajo de salida. Estos datos también están confirmados por la relación de bytes de Amazon S3 escritos (suma de más de 30 minutos, la frecuencia del desencadenador de trabajo para el trabajo de entrada). El punto de datos de la relación para la ejecución de trabajo de entrada que comenzó a las 12:00 h también es 1. En el siguiente gráfico se muestra la relación de flujo de datos entre todas las ejecuciones de trabajo: ![\[Gráfico donde se muestra la relación de flujo de datos: bytes escritos y bytes leídos.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-multiple-5.png) **Segundas ejecuciones de trabajo**: en la segunda ejecución de trabajo, existe una clara diferencia entre el número de bytes leídos por el trabajo de salida y el número de bytes escritos por el trabajo de entrada (compare el área bajo la curva entre las dos ejecuciones de trabajo para el trabajo de salida, o bien las áreas en la segunda ejecución de los trabajos de entrada y salida). La relación de los bytes leídos y escritos muestra que el trabajo de salida lee alrededor de 2,5 veces los datos escritos por el trabajo de entrada en el segundo periodo de 30 minutos de 12:30 a 13:00 h. Esto se debe a que el trabajo de salida reprocesó la salida de la primera ejecución de trabajo del trabajo de entrada porque los marcadores de trabajos no estaban habilitados. Una relación superior a 1 muestra que hay tareas pendientes adicionales de datos que el trabajo de salida procesó. **Terceras ejecuciones de trabajo**: el trabajo de entrada es bastante coherente en términos del número de bytes escritos (consulte el área bajo las curvas rojas). Sin embargo, la tercera ejecución de trabajo del trabajo de entrada se ejecutó más tiempo del que se había previsto (consulte la larga cola de la curva roja). Como resultado, la tercera ejecución de trabajo del trabajo de salida comenzó tarde. La tercera ejecución de trabajo procesó solo una fracción de los datos acumulados en la ubicación provisional durante los 30 minutos restantes entre las 13:00 y las 13:30 h. La relación del flujo de bytes muestra que solo procesó 0,83 de los datos escritos por la tercera ejecución de trabajo del trabajo de entrada (consulte la relación a las 13:00 h). **Solapamiento de los trabajos de entrada y salida**: la cuarta ejecución de trabajo del trabajo de entrada comenzó a las 13:30 h según el programa, antes de finalizar la tercera ejecución de trabajo del trabajo de salida. Existe un solapamiento parcial entre estas dos ejecuciones de trabajo. Sin embargo, la tercera ejecución de trabajo del trabajo de salida captura solo los archivos que listó en la ubicación provisional de Amazon S3 cuando empezó alrededor de las 13:17 h. Esta consta de la salida de todos los datos de las primeras ejecuciones de trabajo del trabajo de entrada. La relación real a las 13:30 h es de aproximadamente 2,75. La tercera ejecución de trabajo del trabajo de salida procesó alrededor de 2,75 veces los datos escritos por la cuarta ejecución de trabajo del trabajo de entrada de 13:00 a 14:00 h. Tal como muestran estas imágenes, el trabajo de salida reprocesa datos de la ubicación provisional de todas las ejecuciones de trabajo anteriores del trabajo de entrada. Como resultado, la cuarta ejecución de trabajo para el trabajo de salida es la más larga y se solapa con la quinta ejecución de trabajo al completo del trabajo de entrada. ## Corregir el procesamiento de los archivos Debe garantizar que el trabajo de salida procese solo los archivos que no han procesado las ejecuciones de trabajo anteriores del trabajo de salida. Para ello, habilite marcadores de trabajos y establezca el contexto de transformación en el trabajo de salida, como se indica a continuación: ``` datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [staging_path], "useS3ListImplementation":True,"recurse":True}, format="json", transformation_ctx = "bookmark_ctx") ``` Con los marcadores de trabajos habilitados, el trabajo de salida no reprocesa los datos en la ubicación provisional de todas las ejecuciones de trabajo anteriores del trabajo de entrada. En la siguiente imagen donde se muestran los datos leídos y escritos, el área bajo la curva marrón es bastante coherente y similar a la de las curvas rojas. ![\[Gráfico donde se muestran los datos leídos y escritos como líneas rojas y marrones.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-multiple-6.png) Las relaciones de flujo de bytes también permanecen más o menos próximas a 1 al no haber datos adicionales procesados. ![\[Gráfico donde se muestra la relación de flujo de datos: bytes escritos y bytes leídos\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-multiple-7.png) Una ejecución de trabajo para el trabajo de salida comienza y captura los archivos en la ubicación provisional antes de que la siguiente ejecución de trabajo de entrada comience a poner más datos en la ubicación provisional. Siempre que siga haciendo esto, procesará solo los archivos capturados de la ejecución de trabajo de entrada anterior, mientras que la relación permanece próxima a 1. ![\[Gráfico donde se muestra la relación de flujo de datos: bytes escritos y bytes leídos\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-multiple-7.png) Supongamos que el trabajo de entrada tarda más de lo esperado y, como resultado, el trabajo de salida captura archivos en la ubicación provisional de dos ejecuciones de trabajo de entrada. A continuación, la relación es mayor que 1 para esa ejecución de trabajo de salida. Sin embargo, las siguientes ejecuciones de trabajo del trabajo de salida no procesan ningún archivo que ya hayan procesado las ejecuciones de trabajo anteriores del trabajo de salida. # Monitorización de la planificación de la capacidad de DPU Puede usar las métricas de trabajos en AWS Glue para estimar el número de unidades de procesamiento de datos (DPU) que se puede utilizar para escalar en horizontal un trabajo de AWS Glue. **nota** Esta página solo corresponde para versiones 0.9 y 1.0 de AWS Glue. Las versiones posteriores de AWS Glue contienen funciones de ahorro de costos que introducen consideraciones adicionales a la hora de planificar la capacidad. **Topics** + [Código con perfil](#monitor-debug-capacity-profile) + [Visualizar las métricas con perfil en la consola de AWS Glue](#monitor-debug-capacity-visualize) + [Determinar la capacidad de DPU óptima](#monitor-debug-capacity-fix) ## Código con perfil El siguiente script lee una partición de Amazon Simple Storage Service (Amazon S3) que contiene 428 archivos gzip JSON. El script aplica un mapeo para cambiar los nombres de los campos y convertirlos y escribirlos en Amazon S3 en formato Apache Parquet. Aprovisione 10 DPU según el valor predeterminado y ejecute este trabajo. ``` datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [input_path], "useS3ListImplementation":True,"recurse":True}, format="json") applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [(map_spec]) datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet") ``` ## Visualizar las métricas con perfil en la consola de AWS Glue **Ejecución de trabajo 1:** en esta ejecución de trabajo, mostramos cómo encontrar si hay DPU de aprovisionamiento deficiente en el clúster. La funcionalidad de ejecución de trabajos de AWS Glue muestra el [número de ejecutores que se ejecutan activamente](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors) total, el [número de fases completadas](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.numCompletedStages) y el [número máximo de ejecutores necesarios](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors). El número máximo de ejecutores necesarios se calcula añadiendo el número total de tareas en ejecución y tareas pendientes, y dividiéndolo entre las tareas por ejecutor. Este resultado es una medida del número total de ejecutores necesarios para satisfacer la carga actual. Por contraste, el número de ejecutores que se ejecutan activamente mide cuántos ejecutores ejecutan tareas Apache Spark activas. A medida que progresa el trabajo, el número máximo de ejecutores necesarios puede cambiar y suele reducirse hacia el final del trabajo al disminuir la cola de tareas pendientes. La línea roja horizontal del siguiente gráfico muestra el número máximo de ejecutores asignados, que depende del número de DPU que asigna para el trabajo. En este caso, asigna 10 DPU para la ejecución de trabajo. Una DPU está reservada para administración. Nueve DPU ejecutan dos ejecutores cada una y un ejecutor se reserva para el controlador Spark. El controlador Spark se ejecuta dentro de la aplicación principal. Así pues, el número máximo de ejecutores asignados es 2 x 9 -1 = 17 ejecutores. ![\[Métricas de trabajos que muestran los ejecutores activos y el número máximo de ejecutores necesarios.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-capacity-1.png) Tal como se muestra en el gráfico, el número máximo de ejecutores necesarios parte de 107 al principio del trabajo, mientras que el número de ejecutores activos sigue siendo 17. Este es igual al número máximo de ejecutores asignados con 10 DPU. La relación entre el número máximo de ejecutores necesarios y el número máximo de ejecutores asignados (que añade 1 a ambos para el controlador Spark) le ofrece el factor de aprovisionamiento deficiente: 108/18 = 6x. Puede aprovisionar 6 (por debajo de la proporción de aprovisionamiento)\$1 9 (capacidad de DPU actual - 1)\$11 DPU = 55 DPU para escalar en horizontal el trabajo a fin de ejecutarlo con el máximo paralelismo y finalizar con mayor rapidez. La consola de AWS Glue muestra las métricas detalladas de trabajos como una línea estática que representa el número original de ejecutores máximos asignados. La consola calcula los ejecutores máximos asignados a partir de la definición de trabajo de las métricas. En cambio, para las métricas detalladas de ejecución de trabajos, la consola calcula los ejecutores máximos asignados a partir de la configuración de ejecución de trabajos, específicamente las DPU asignadas a la ejecución de trabajos. Para ver las métricas de una ejecución de trabajo individual, seleccione la ejecución de trabajo y elija **View run metrics (Ver métricas de ejecución)**. ![\[Métricas de trabajos que muestran el movimiento de datos de ETL.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-capacity-2.png) Al examinar los bytes de Amazon S3 [leídos](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) y [escritos](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes), observe que el trabajo dedica los seis minutos a la streaming de datos desde Amazon S3 y a escribir dichos datos en paralelo. Todos los núcleos de las DPU asignadas leen y escriben en Amazon S3. El número máximo de ejecutores necesarios, 107, también coincide con el número de archivos en la ruta de entrada de Amazon S3, 428. Cada ejecutor puede lanzar cuatro tareas Spark para procesar cuatro archivos de entrada (gzip JSON). ## Determinar la capacidad de DPU óptima En función de los resultados de la ejecución de trabajo anterior, puede aumentar el número total de DPU asignadas a 55, así como consultar el rendimiento del trabajo. El trabajo finaliza en menos de tres minutos, la mitad del tiempo que requería anteriormente. El escalado en horizontal del trabajo no es lineal en este caso porque se trata de un trabajo de corta ejecución. Los trabajos con tareas de larga duración o un gran número de tareas (un gran número correspondiente al máximo de ejecutores necesarios) se benefician de una aceleración de rendimiento de escalado en horizontal de DPU casi lineal. ![\[Gráfico donde se muestra el aumento del número total de DPU asignadas\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-capacity-3.png) Tal como se muestra en la imagen anterior, el número total de ejecutores activos alcanza el máximo asignado, 107 ejecutores. Del mismo modo, el número máximo de ejecutores necesarios nunca supera el número máximo de ejecutores asignados. El número máximo de ejecutores necesarios se calcula a partir de los recuentos de tareas pendientes y tareas que se ejecutan activamente, por lo que podría ser inferior al número de ejecutores activos. Esto se debe a que puede haber ejecutores que estén inactivos parcial o completamente durante un corto periodo de tiempo y no se hayan retirado aún. ![\[Gráfico donde se muestra el número total de ejecutores activos que alcanzan el máximo asignado.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-capacity-4.png) Esta ejecución de trabajo usa seis veces más ejecutores para leer y escribir desde Amazon S3 en paralelo. Como resultado, esta ejecución de trabajo usa más ancho de banda de Amazon S3 tanto para las lecturas como para las escrituras, y finaliza con mayor rapidez. ### Identificar DPU sobreaprovisionadas A continuación, puede determinar si escalar en horizontal el trabajo con 100 DPU (99 x 2 = 198 ejecutores) ayuda a escalar más en horizontal. Tal como se muestra en el siguiente gráfico, el trabajo sigue tardando tres minutos en finalizar. Del mismo modo, el trabajo no escala en horizontal más allá de 107 ejecutores (configuración de 55 DPU) y los 91 ejecutores restantes están sobreaprovisionados y no se han utilizado en absoluto. Esto muestra que es posible que aumentar el número de DPU no siempre mejore el rendimiento, como se desprende del número máximo de ejecutores necesarios. ![\[Gráfico donde se muestra que el rendimiento del trabajo no siempre aumenta al aumentar el número de DPU.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/monitor-debug-capacity-5.png) ### Comparar las diferencias de tiempo Las tres ejecuciones de trabajo mostradas en la siguiente tabla resumen los tiempos de ejecución de trabajo para 10 DPU, 55 DPU y 100 DPU. Puede encontrar la capacidad de DPU para mejorar el tiempo de ejecución de trabajo mediante las estimaciones que estableció monitorizando la primera ejecución de trabajo. | ID de tarea | Número de DPU | Hora de ejecución | | --- | --- | --- | | jr\$1c894524c8ef5048a4d9... | 10 | 6 min. | | jr\$11a466cf2575e7ffe6856... | 55 | 3 min. | | jr\$134fa1ed4c6aa9ff0a814... | 100 | 3 min. | # Solución de problemas de IA generativa para Apache Spark en AWS Glue La resolución de problemas mediante IA generativa para trabajos de Apache Spark en AWS Glue es una nueva funcionalidad que ayuda a los ingenieros y científicos de datos a diagnosticar y solucionar problemas en sus aplicaciones de Spark con facilidad. Al utilizar el machine learning y las tecnologías de IA generativa, esta característica analiza los problemas en los trabajos de Spark y proporciona un análisis detallado de la causa raíz junto con recomendaciones prácticas para resolverlos. La solución de problemas con IA generativa para Apache Spark está disponible para tareas que se ejecutan en la versión 4.0 de AWS Glue o posterior. | | | --- | | Transforme la resolución de problemas de Apache Spark con nuestro Agente de resolución de problemas impulsado por IA, ahora compatible con todos los modos de implementación principales, incluidos AWS Glue, Amazon EMR-EC2, Amazon EMR sin servidor y Amazon SageMaker AI Notebooks. Este potente agente elimina los procesos complejos de depuración al combinar interacciones en lenguaje natural, análisis de cargas de trabajo en tiempo real y recomendaciones inteligentes de código en una experiencia integrada y fluida. Para obtener información sobre los detalles de implementación, consulte [¿Qué es el agente de solución de problemas de Apache Spark para Amazon EMR?](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/spark-troubleshoot.html) Vea la segunda demostración en [Uso del agente de solución de problemas](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/spark-troubleshooting-using-troubleshooting-agent.html) para obtener ejemplos de solución de problemas de AWS Glue. | ## ¿Cómo funciona la solución de problemas de IA generativa para Apache Spark? En el caso de los trabajos con errores de Spark, la solución de problemas de IA generativa analiza los metadatos del trabajo y las métricas y registros precisos asociados a la firma del error para generar un análisis de la causa raíz y recomienda soluciones específicas y prácticas para solucionar los errores de los trabajos. ## Configuración de la solución de problemas de IA generativa para Apache Spark para los trabajos ### Configuración de permisos de IAM Para conceder permisos a las API utilizadas por la solución de problemas de Spark para los trabajos en AWS Glue, se requieren los permisos de IAM adecuados. Para obtener permisos, adjunte a su identidad de IAM (como el usuario, el rol o el grupo) la política de AWS personalizada que figura a continuación. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "glue:StartCompletion", "glue:GetCompletion" ], "Resource": [ "arn:aws:glue:*:*:completion/*", "arn:aws:glue:*:*:job/*" ] } ] } ``` ------ **nota** Las dos API siguientes se utilizan en la política de IAM para permitir esta experiencia a través de la consola de AWS Glue Studio: `StartCompletion` y `GetCompletion`. ### Asignación de permisos Para dar acceso, agregue permisos a los usuarios, grupos o roles: + Para los usuarios y los grupos en IAM Identity Center: creación de un conjunto de permisos. Siga las instrucciones que se detallan en [Creación de un conjunto de permisos](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtocreatepermissionset.html) en la Guía del usuario de IAM Identity Center. + Para los usuarios administrados en IAM a través de un proveedor de identidades: creación de un rol para la federación de identidades. Siga las instrucciones descritas en [Crear un rol para un proveedor de identidad de terceros (federación)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp.html) en la Guía del usuario de IAM. + Para los usuarios de IAM: creación de un rol que el usuario pueda asumir. Siga las instrucciones descritas en [Crear un rol para delegar permisos a un usuario de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) en la Guía del usuario de IAM. ## Ejecución de un análisis de solución de problemas a partir de una ejecución de trabajo con errores Puede acceder a la característica de solución de problemas a través de varias rutas en la consola de AWS Glue. A continuación, se explica cómo empezar: ### Opción 1: desde la página de lista de trabajos 1. Abra la consola de AWS Glue en [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). 1. En el panel de navegación, elija **Trabajos de extracción, transformación y carga (ETL)**. 1. Localice el trabajo con error en la lista de trabajos. 1. Seleccione la pestaña **Ejecuciones** en la sección de detalles del trabajo. 1. Haga clic en la ejecución de trabajo con error que quiere analizar. 1. Elija **Solucionar problemas con IA** para iniciar el análisis. 1. Cuando finalice el análisis de solución de problemas, podrá ver el análisis de la causa raíz y las recomendaciones en la pestaña **Análisis de solución de problemas** situada en la parte inferior de la pantalla. ![\[El GIF muestra una implementación integral de una ejecución con errores y la característica de resolución de problemas con la IA en ejecución.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/troubleshoot_spark_option_1_jobs_list.gif) ### Opción 2: uso de la página Supervisión de ejecución de trabajos 1. Vaya a la página **Supervisión de ejecución de trabajos**. 1. Localice la ejecución de trabajos con errores. 1. Elija el menú desplegable **Acciones**. 1. Elige **Solucionar problemas con IA**. ![\[El GIF muestra una implementación integral de una ejecución con errores y la característica de resolución de problemas con la IA en ejecución.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/troubleshoot_spark_option_2_job_monitoring.gif) ### Opción 3: desde la página Detalles de la ejecución del trabajo 1. Para ir a la página de detalles de la ejecución de un trabajo con errores, haga clic en **Ver detalles** de una ejecución con errores en la pestaña **Ejecuciones** o seleccione la ejecución del trabajo en la página **Supervisión de ejecución de trabajos**. 1. En la página de detalles de la ejecución del trabajo, busque la pestaña **Análisis de solución de problemas**. ## Categorías de resolución de problemas compatibles Este servicio se centra en tres categorías principales de problemas que los ingenieros y los desarrolladores de datos suelen encontrar en sus aplicaciones de Spark: + **Errores de configuración y acceso a los recursos**: cuando se ejecutan aplicaciones de Spark en AWS Glue, los errores de configuración y acceso a los recursos son algunos de los problemas más comunes pero difíciles de diagnosticar. Estos errores suelen producirse cuando la aplicación Spark intenta interactuar con los recursos de AWS, pero encuentra problemas con los permisos, la falta de recursos o problemas de configuración. + **Problemas con la memoria del controlador y el ejecutor de Spark**: los errores relacionados con la memoria en los trabajadores de Apache Spark pueden ser difíciles de diagnosticar y resolver. Estos errores suelen manifestarse cuando los requisitos de procesamiento de datos superan los recursos de memoria disponibles, ya sea en el nodo controlador o en los nodos ejecutores. + **Problemas de capacidad del disco de Spark**: los errores relacionados con el almacenamiento en los trabajos de Spark de AWS Glue suelen surgir durante las operaciones aleatorias, el derrame de datos o cuando se trata de transformaciones de datos a gran escala. Estos errores pueden ser particularmente complicados, ya que es posible que no se manifiesten hasta que el trabajo haya estado ejecutándose durante un tiempo, lo que podría desperdiciar valiosos recursos y tiempo de computación. + **Errores de ejecución de consultas:** los errores de consulta en las operaciones de SQL y DataFrame de Spark pueden ser difíciles de solucionar porque es posible que los mensajes de error no indiquen claramente la causa raíz, y las consultas que funcionan bien con conjuntos de datos pequeños pueden fallar repentinamente a escala. Estos errores se vuelven aún más complejos cuando se producen en canalizaciones de transformación complejas, donde el problema real puede deberse a problemas de calidad de los datos en las etapas iniciales y no a la propia lógica de la consulta. **nota** Antes de implementar los cambios sugeridos en su entorno de producción, revíselos detenidamente. El servicio ofrece recomendaciones basadas en patrones y prácticas recomendadas, pero su caso de uso específico puede requerir consideraciones adicionales. ## Regiones admitidas La solución de problemas con IA generativa para Apache Spark está disponible en las siguientes regiones: + **África**: (Ciudad del Cabo) (af-south-1) + **Asia Pacífico**: Hong Kong (ap-east-1), Tokio (ap-northeast-1), Seúl (ap-northeast-2), Osaka (ap-northeast-3), Mumbai (ap-south-1), Singapur (ap-southeast-1), Sídney (ap-southeast-2) y Yakarta (ap-southeast-3) + **Europa**: Fráncfort (eu-central-1), Estocolmo (eu-north-1), Milán (eu-south-1), Irlanda (eu-west-1), Londres (eu-west-2) y París (eu-west-3) + **Medio Oriente**: Baréin (me-south-1) y Emiratos Árabes Unidos (me-central-1) + **América del Norte**: Canadá (ca-central-1) + **América del Sur**: São Paulo (sa-east-1) + **Estados Unidos**: Virginia del Norte (us-east-1), Ohio (us-east-2), California del Norte (us-west-1) y Oregón (us-west-2) # Uso de vistas materializadas con AWS Glue La versión 5.1 y posteriores de AWS Glue admiten la creación y administración de vistas materializadas de Apache Iceberg en el catálogo de datos de AWS Glue. Una vista materializada es una tabla administrada que almacena el resultado precalculado de una consulta SQL en formato Apache Iceberg y se actualiza de forma incremental a medida que cambian las tablas de origen subyacentes. Puede utilizar las vistas materializadas para simplificar la canalización de transformación de datos y acelerar el rendimiento de las consultas para cargas de trabajo analíticas complejas. Cuando crea una vista materializada mediante Spark en AWS Glue, la definición de la vista y sus metadatos se almacenan en el catálogo de datos de AWS Glue. Los resultados precalculados se almacenan como tablas de Apache Iceberg en buckets de tablas de Amazon S3 o en buckets de uso general de Amazon S3 dentro de su cuenta. El catálogo de datos de AWS Glue supervisa automáticamente las tablas de origen y actualiza las vistas materializadas mediante infraestructura de cómputo administrada. **Topics** + [Cómo funcionan las vistas materializadas con AWS Glue](#materialized-views-how-they-work) + [Requisitos previos](#materialized-views-prerequisites) + [Configuración de Spark para usar vistas materializadas](#materialized-views-configuring-spark) + [Creación de vistas materializadas](#materialized-views-creating) + [Consulta de vistas materializadas](#materialized-views-querying) + [Actualización de vistas materializadas](#materialized-views-refreshing) + [Administración de vistas materializadas](#materialized-views-managing) + [Permisos para vistas materializadas](#materialized-views-permissions) + [Supervisión de las operaciones de vistas materializadas](#materialized-views-monitoring) + [Ejemplo: flujo de trabajo completo](#materialized-views-complete-workflow) + [Consideraciones y limitaciones](#materialized-views-considerations-limitations) ## Cómo funcionan las vistas materializadas con AWS Glue Las vistas materializadas se integran con AWS Glue mediante la compatibilidad con Iceberg de Apache Spark en tareas de AWS Glue y cuadernos de AWS Glue Studio. Cuando configura su sesión de Spark para usar el catálogo de datos de AWS Glue, puede crear vistas materializadas mediante sintaxis SQL estándar. El optimizador de Spark puede reescribir automáticamente las consultas para utilizar vistas materializadas cuando ofrecen un mejor rendimiento, lo que elimina la necesidad de modificar manualmente el código de la aplicación. El catálogo de datos de AWS Glue administra todos los aspectos operativos del mantenimiento de la vista materializada, incluidos: + Detección de cambios en las tablas fuente mediante la capa de metadatos de Apache Iceberg + Programación y ejecución de operaciones de actualización mediante cómputo Spark administrado + Cómo determinar si realizar una actualización completa o incremental en función de los cambios en los datos + Almacenamiento de resultados precalculados en formato Apache Iceberg para el acceso con múltiples motores Puede consultar vistas materializadas desde AWS Glue mediante las mismas interfaces de Spark SQL que utiliza para las tablas normales. También se puede acceder a los datos precalculados desde otros servicios, como Amazon Athena y Amazon Redshift. ## Requisitos previos Para utilizar vistas materializadas con AWS Glue, necesita: + Una cuenta de . + La versión 5.1 de AWS Glue, o posteriores + Tablas fuente en formato Apache Iceberg registradas en el catálogo de datos de AWS Glue + Permisos de AWS Lake Formation configurados para las tablas de origen y las bases de datos de destino + Un bucket de tablas de S3 o un bucket de uso general de Amazon S3 registrado en AWS Lake Formation para almacenar los datos de las vistas materializadas. + Un rol de IAM con permisos para acceder al catálogo de datos de AWS Glue y Amazon S3 ## Configuración de Spark para usar vistas materializadas Para crear y administrar vistas materializadas en AWS Glue, configure su sesión de Spark con las extensiones de Iceberg y la configuración del catálogo requeridas. El método de configuración varía en función de si utiliza tareas de AWS Glue o cuadernos de AWS Glue Studio. ### Configuración de tareas de AWS Glue Al crear o actualizar un trabajo de AWS Glue, añada los siguientes parámetros de configuración como parámetros del trabajo: #### Para buckets de tablas de S3 ``` job = glue.create_job( Name='materialized-view-job', Role='arn:aws:iam::111122223333:role/GlueServiceRole', Command={ 'Name': 'glueetl', 'ScriptLocation': 's3://amzn-s3-demo-bucket/scripts/mv-script.py', 'PythonVersion': '3' }, DefaultArguments={ '--enable-glue-datacatalog': 'true', '--conf': 'spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions ' '--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog ' '--conf spark.sql.catalog.glue_catalog.type=glue ' '--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse ' '--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 ' '--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 ' '--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 ', '--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true ', '--conf spark.sql.catalog.s3t_catalog=org.apache.iceberg.spark.SparkCatalog ' '--conf spark.sql.catalog.s3t_catalog.type=glue ' '--conf spark.sql.catalog.s3t_catalog.glue.id=111122223333:s3tablescatalog/my-table-bucket ', '--conf spark.sql.catalog.s3t_catalog.glue.account-id=111122223333 ', '--conf spark.sql.catalog.s3t_catalog.glue.lakeformation-enabled=true ', '--conf spark.sql.catalog.s3t_catalog.warehouse=s3://amzn-s3-demo-bucket/mv-warehouse ' '--conf spark.sql.catalog.s3t_catalog.glue.region=us-east-1 ' '--conf spark.sql.defaultCatalog=s3t_catalog ' '--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true ' '--conf spark.sql.materializedViews.metadataCache.enabled=true' }, GlueVersion='5.1' ) ``` #### Para buckets de uso general de S3 ``` job = glue.create_job( Name='materialized-view-job', Role='arn:aws:iam::111122223333:role/GlueServiceRole', Command={ 'Name': 'glueetl', 'ScriptLocation': 's3://amzn-s3-demo-bucket/scripts/mv-script.py', 'PythonVersion': '3' }, DefaultArguments={ '--enable-glue-datacatalog': 'true', '--conf': 'spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions ' '--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog ' '--conf spark.sql.catalog.glue_catalog.type=glue ' '--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse ' '--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 ' '--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 ', '--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 ', '--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true ', '--conf spark.sql.defaultCatalog=glue_catalog ' '--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true ' '--conf spark.sql.materializedViews.metadataCache.enabled=true' }, GlueVersion='5.1' ) ``` ### Configuración de cuadernos de AWS Glue Studio En los cuadernos de AWS Glue Studio, configure su sesión de Spark mediante el comando mágico %%configure al inicio del cuaderno: ``` %%configure { "conf": { "spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions", "spark.sql.catalog.glue_catalog": "org.apache.iceberg.spark.SparkCatalog", "spark.sql.catalog.glue_catalog.type": "glue", "spark.sql.catalog.glue_catalog.warehouse": "s3://amzn-s3-demo-bucket/warehouse", "spark.sql.catalog.glue_catalog.glue.region": "us-east-1", "spark.sql.catalog.glue_catalog.glue.id": "111122223333", "spark.sql.catalog.glue_catalog.glue.account-id": "111122223333", "spark.sql.catalog.glue_catalog.glue.lakeformation-enabled": "true", "spark.sql.defaultCatalog": "glue_catalog", "spark.sql.optimizer.answerQueriesWithMVs.enabled": "true", "spark.sql.materializedViews.metadataCache.enabled": "true" } } ``` ### Habilitación de la actualización incremental Para habilitar la optimización de la actualización incremental, añada las siguientes propiedades de configuración a los parámetros del trabajo o a la configuración del cuaderno: ``` --conf spark.sql.optimizer.incrementalMVRefresh.enabled=true --conf spark.sql.optimizer.incrementalMVRefresh.deltaThresholdCheckEnabled=false ``` ### Parámetros de configuración Los siguientes parámetros de configuración controlan el comportamiento de la vista materializada: + `spark.sql.extensions`: habilita las extensiones de sesión de Iceberg Spark necesarias para la compatibilidad con la vista materializada. + `spark.sql.optimizer.answerQueriesWithMVs.enabled`: habilita la reescritura automática de consultas para usar vistas materializadas. Establézcalo en «true» para activar esta optimización. + `spark.sql.materializedViews.metadataCache.enabled`: permite el almacenamiento en caché de los metadatos de las vistas materializadas para la optimización de las consultas. Establézcalo en «true» para mejorar el rendimiento de la reescritura de consultas. + `spark.sql.optimizer.incrementalMVRefresh.enabled`: permite la optimización de la actualización incremental. Establézcalo en «true» para procesar solo los datos modificados durante las operaciones de actualización. + `spark.sql.optimizer.answerQueriesWithMVs.decimalAggregateCheckEnabled`: controla la validación de las operaciones de agregación decimal en la reescritura de consultas. Establézcalo en «false» para desactivar determinadas comprobaciones de desbordamiento decimal. ## Creación de vistas materializadas Puede crear vistas materializadas mediante la instrucción SQL CREATE MATERIALIZED VIEW en tareas o en cuadernos de AWS Glue. La definición de vista especifica la lógica de transformación como una consulta SQL que hace referencia a una o más tablas de origen. ### Creación de una vista materializada básica en las tareas de AWS Glue En el siguiente ejemplo, se muestra cómo crear una vista materializada en un script de tarea de AWS Glue; utilice nombres de tabla totalmente calificados con la convención de nomenclatura de tres partes en la definición de la vista: ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session # Create materialized view spark.sql(""" CREATE MATERIALIZED VIEW customer_orders AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name """) ``` ### Creación de una vista materializada con actualización automática Para configurar la actualización automática, especifique un calendario de actualización al crear la vista y utilice nombres de tabla totalmente calificados con la convención de nomenclatura de tres partes en la definición de la vista: ``` spark.sql(""" CREATE MATERIALIZED VIEW customer_orders SCHEDULE REFRESH EVERY 1 HOUR AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name """) ``` ### Creación de una vista materializada con referencias entre catálogos Cuando las tablas de origen se encuentran en un catálogo distinto del de la vista materializada, utilice nombres de tabla totalmente calificados con la convención de nomenclatura de tres partes tanto en el nombre de la vista como en la definición de la vista: ``` spark.sql(""" CREATE MATERIALIZED VIEW s3t_catalog.analytics.customer_summary AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name """) ``` ### Creación de vistas materializadas en cuadernos de AWS Glue Studio En los cuadernos de AWS Glue Studio, puede usar el comando mágico %%sql para crear vistas materializadas y utilizar nombres de tabla totalmente calificados con la convención de nomenclatura de tres partes en la definición de la vista: ``` %%sql CREATE MATERIALIZED VIEW customer_orders AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name ``` ## Consulta de vistas materializadas Después de crear una vista materializada, puede consultarla como cualquier otra tabla mediante instrucciones SQL SELECT estándar en sus tareas o cuadernos de AWS Glue. ### Consultas en tareas de AWS Glue ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session # Query materialized view result = spark.sql("SELECT * FROM customer_orders") result.show() ``` ### Consultas en los cuadernos de AWS Glue Studio ``` %%sql SELECT * FROM customer_orders ``` ### Reescritura automática de consultas Cuando la reescritura automática de consultas está habilitada, el optimizador de Spark analiza las consultas y utiliza automáticamente las vistas materializadas para mejorar el rendimiento. Por ejemplo, la siguiente consulta no se ejecuta: ``` result = spark.sql(""" SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM orders GROUP BY customer_name """) ``` El optimizador de Spark reescribe automáticamente esta consulta para utilizar la vista materializada «customer\$1orders» en lugar de procesar la tabla base de pedidos, siempre que la vista materializada esté actualizada. ### Verificación de la reescritura automática de consultas Para verificar si una consulta utiliza la reescritura automática de consultas, use el comando EXPLAIN EXTENDED: ``` spark.sql(""" EXPLAIN EXTENDED SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM orders GROUP BY customer_name """).show(truncate=False) ``` En el plan de ejecución, busque el nombre de la vista materializada en la operación BatchScan. Si el plan muestra BatchScan glue\$1catalog.analytics.customer\$1orders en lugar de BatchScan glue\$1catalog.sales.orders, la consulta se ha reescrito automáticamente para usar la vista materializada. Tenga en cuenta que la reescritura automática de consultas requiere tiempo para que se complete la caché de metadatos de Spark después de crear una vista materializada. Este proceso suele completarse en un plazo de 30 segundos. ## Actualización de vistas materializadas Puede actualizar las vistas materializadas mediante dos métodos: actualización completa o actualización incremental. La actualización completa vuelve a calcular toda la vista materializada a partir de todos los datos de las tablas base, mientras que la actualización incremental procesa únicamente los datos que han cambiado desde la última actualización. ### Actualización completa manual en tareas de AWS Glue Para realizar una actualización completa de una vista materializada: ``` spark.sql("REFRESH MATERIALIZED VIEW customer_orders FULL") # Verify updated results result = spark.sql("SELECT * FROM customer_orders") result.show() ``` ### Actualización incremental manual en tareas de AWS Glue Para realizar una actualización incremental, asegúrese de que la actualización incremental esté habilitada en la configuración de su sesión de Spark y, a continuación, ejecute: ``` spark.sql("REFRESH MATERIALIZED VIEW customer_orders") # Verify updated results result = spark.sql("SELECT * FROM customer_orders") result.show() ``` El catálogo de datos de AWS Glue determina automáticamente si la actualización incremental es aplicable en función de la definición de la vista y de la cantidad de datos modificados. Si la actualización incremental no es posible, la operación recurre a una actualización completa. ### Actualización en los cuadernos de AWS Glue Studio En los cuadernos, use el comando mágico %%sql: ``` %%sql REFRESH MATERIALIZED VIEW customer_orders FULL ``` ### Verificación de la ejecución de la actualización incremental Para confirmar que la actualización incremental se ejecutó correctamente, habilite el registro de depuración en su tarea de AWS Glue: ``` from awsglue.context import GlueContext from pyspark.context import SparkContext import logging sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session # Enable debug logging logger = logging.getLogger('org.apache.spark.sql') logger.setLevel(logging.DEBUG) # Execute refresh spark.sql("REFRESH MATERIALIZED VIEW customer_orders") ``` Busque el siguiente mensaje en los registros de la tarea de AWS Glue: ``` DEBUG RefreshMaterializedViewExec: Executed Incremental Refresh ``` ## Administración de vistas materializadas AWS Glue proporciona comandos SQL para administrar el ciclo de vida de las vistas materializadas en sus tareas y cuadernos. ### Descripción de una vista materializada Para ver los metadatos de una vista materializada, incluida su definición, el estado de actualización y la marca de tiempo de la última actualización: ``` spark.sql("DESCRIBE EXTENDED customer_orders").show(truncate=False) ``` ### Modificación de una vista materializada Para modificar el calendario de actualización de una vista materializada existente: ``` spark.sql(""" ALTER MATERIALIZED VIEW customer_orders ADD SCHEDULE REFRESH EVERY 2 HOURS """) ``` Para eliminar la actualización automática: ``` spark.sql(""" ALTER MATERIALIZED VIEW customer_orders DROP SCHEDULE """) ``` ### Eliminación de una vista materializada Para eliminar una vista materializada: ``` spark.sql("DROP MATERIALIZED VIEW customer_orders") ``` Este comando elimina la definición de la vista materializada del catálogo de datos de AWS Glue y borra los datos de la tabla Iceberg subyacente de su bucket de Amazon S3. ### Listado de vistas materializadas Para enumerar todas las vistas materializadas de una base de datos: ``` spark.sql("SHOW VIEWS FROM analytics").show() ``` ## Permisos para vistas materializadas Para crear y administrar vistas materializadas, debe configurar los permisos de AWS Lake Formation. El rol de IAM que crea la vista materializada (la función de definición) requiere permisos específicos en las tablas de origen y las bases de datos de destino. ### Permisos requeridos para el rol definidor El rol definidor debe contar con los siguientes permisos de Lake Formation: + En las tablas de origen: permisos SELECT o ALL, sin filtros de filas, columnas ni celdas. + En la base de datos de destino: permiso CREATE\$1TABLE + En el catálogo de datos de AWS Glue: permisos de la API GetTable y CreateTable Cuando crea una vista materializada, el ARN del rol definidor se almacena en la definición de la vista. El catálogo de datos de AWS Glue asume este rol al ejecutar operaciones de actualización automática. Si el rol definidor pierde el acceso a las tablas de origen, las operaciones de actualización fallarán hasta que se restablezcan los permisos. ### Permisos de IAM para tareas de AWS Glue El rol de IAM de su tarea de AWS Glue requiere los siguientes permisos: ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "glue:GetCatalog", "glue:GetCatalogs", "glue:GetTable", "glue:GetTables", "glue:CreateTable", "glue:UpdateTable", "glue:DeleteTable", "glue:GetDatabase", "glue:GetDatabases", "cloudwatch:PutMetricData" ], "Resource": "*" }, { "Effect": "Allow", "Action": [ "s3:GetObject", "s3:PutObject", "s3:DeleteObject" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket/*" ] }, { "Effect": "Allow", "Action": [ "s3:ListBucket" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket" ] }, { "Effect": "Allow", "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents" ], "Resource": [ "arn:aws:logs:*:*:*:/aws-glue/*" ] }, { "Effect": "Allow", "Action": [ "lakeformation:GetDataAccess" ], "Resource": "*" } ] } ``` El rol que utilice para la actualización automática de vistas materializadas debe contar con el permiso iam:PassRole sobre dicho rol. ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::111122223333:role/materialized-view-role-name" ] } ] } ``` Para permitir que Glue actualice automáticamente la vista materializada, el rol también debe contar con la siguiente política de confianza, que habilita al servicio a asumir dicho rol. ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::111122223333:role/materialized-view-role-name" ] } ] } ``` Si la vista materializada se almacena en buckets de tablas de S3, también debe añadir el siguiente permiso al rol. ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3tables:PutTableMaintenanceConfiguration" ], "Resource": "arn:aws:s3tables:*:123456789012:*" } ] } ``` ### Concesión de acceso a vistas materializadas Para conceder a otros usuarios acceso para consultar una vista materializada, utilice AWS Lake Formation para otorgar el permiso SELECT sobre la tabla de la vista materializada. Los usuarios pueden consultar la vista materializada sin necesidad de tener acceso directo a las tablas de origen subyacentes. Para obtener información detallada sobre la configuración de los permisos de Lake Formation, consulte Concesión y revocación de permisos en recursos del catálogo de datos en la Guía para desarrolladores de AWS Lake Formation. ## Supervisión de las operaciones de vistas materializadas El catálogo de datos de AWS Glue publica métricas y registros para las operaciones de actualización de vistas materializadas en Amazon CloudWatch. Puede supervisar el estado de actualización, la duración y el volumen de datos procesados mediante métricas de CloudWatch. ### Visualización de registros de la tarea Para ver los registros de las tareas de AWS Glue que crean o actualizan vistas materializadas: 1. Abra la consola de AWS Glue. 1. En el panel de navegación, seleccione Tareas. 1. Seleccione su tarea y elija Ejecuciones. 1. Seleccione una ejecución específica y elija Registros para ver los registros de CloudWatch. ### Configuración de alarmas Para recibir notificaciones cuando las operaciones de actualización fallen o superen la duración prevista, cree alarmas de CloudWatch sobre las métricas de las vistas materializadas. También puede configurar reglas de Amazon EventBridge para activar respuestas automatizadas ante eventos de actualización. ## Ejemplo: flujo de trabajo completo En el siguiente ejemplo, se muestra un flujo de trabajo completo para crear y utilizar una vista materializada en AWS Glue. ### Ejemplo de script de tarea de AWS Glue ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME'], args) # Create database and base table spark.sql("CREATE DATABASE IF NOT EXISTS sales") spark.sql("USE sales") spark.sql(""" CREATE TABLE IF NOT EXISTS orders ( id INT, customer_name STRING, amount DECIMAL(10,2), order_date DATE ) """) # Insert sample data spark.sql(""" INSERT INTO orders VALUES (1, 'John Doe', 150.00, DATE('2024-01-15')), (2, 'Jane Smith', 200.50, DATE('2024-01-16')), (3, 'Bob Johnson', 75.25, DATE('2024-01-17')) """) # Create materialized view spark.sql(""" CREATE MATERIALIZED VIEW customer_summary AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name """) # Query the materialized view print("Initial materialized view data:") spark.sql("SELECT * FROM customer_summary").show() # Insert additional data spark.sql(""" INSERT INTO orders VALUES (4, 'Jane Smith', 350.00, DATE('2024-01-18')), (5, 'Bob Johnson', 100.25, DATE('2024-01-19')) """) # Refresh the materialized view spark.sql("REFRESH MATERIALIZED VIEW customer_summary FULL") # Query updated results print("Updated materialized view data:") spark.sql("SELECT * FROM customer_summary").show() job.commit() ``` ### Ejemplo de cuaderno de AWS Glue Studio ``` %%configure { "conf": { "spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions", "spark.sql.catalog.glue_catalog": "org.apache.iceberg.spark.SparkCatalog", "spark.sql.catalog.glue_catalog.type": "glue", "spark.sql.catalog.glue_catalog.warehouse": "s3://amzn-s3-demo-bucket/warehouse", "spark.sql.catalog.glue_catalog.glue.region": "us-east-1", "spark.sql.catalog.glue_catalog.glue.id": "111122223333", "spark.sql.catalog.glue_catalog.glue.account-id": "111122223333", "spark.sql.catalog.glue_catalog.glue.lakeformation-enabled": "true", "spark.sql.defaultCatalog": "glue_catalog", "spark.sql.optimizer.answerQueriesWithMVs.enabled": "true", "spark.sql.materializedViews.metadataCache.enabled": "true" } } ``` ``` %%sql CREATE DATABASE IF NOT EXISTS sales ``` ``` %%sql USE sales ``` ``` %%sql CREATE TABLE IF NOT EXISTS orders ( id INT, customer_name STRING, amount DECIMAL(10,2), order_date DATE ) ``` ``` %%sql INSERT INTO orders VALUES (1, 'John Doe', 150.00, DATE('2024-01-15')), (2, 'Jane Smith', 200.50, DATE('2024-01-16')), (3, 'Bob Johnson', 75.25, DATE('2024-01-17')) ``` ``` %%sql CREATE MATERIALIZED VIEW customer_summary AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name ``` ``` %%sql SELECT * FROM customer_summary ``` ``` %%sql INSERT INTO orders VALUES (4, 'Jane Smith', 350.00, DATE('2024-01-18')), (5, 'Bob Johnson', 100.25, DATE('2024-01-19')) ``` ``` %%sql REFRESH MATERIALIZED VIEW customer_summary FULL ``` ``` %%sql SELECT * FROM customer_summary ``` ## Consideraciones y limitaciones Tenga en cuenta lo siguiente al usar vistas materializadas con AWS Glue: + Las vistas materializadas requieren la versión 5.1 de AWS Glue, o posterior. + Las tablas de origen deben ser tablas de Apache Iceberg registradas en el catálogo de datos de AWS Glue. Las tablas de Apache Hive, Apache Hudi y Delta Lake de Linux Foundation no son compatibles en el lanzamiento. + Las tablas de origen deben residir en la misma región y en la misma cuenta que la vista materializada. + Todas las tablas de origen deben regirse por AWS Lake Formation. No se admiten los permisos exclusivos de IAM ni el acceso híbrido. + Las vistas materializadas no pueden hacer referencia a vistas del catálogo de datos de AWS Glue, vistas multidialecto ni otras vistas materializadas como tablas de origen. + El rol definidor de la vista debe contar con acceso de lectura completo (permisos SELECT o ALL) en todas las tablas de origen, sin aplicar filtros de filas, columnas ni celdas. + Las vistas materializadas son eventualmente coherentes con las tablas de origen. Durante la ventana de actualización, las consultas pueden devolver datos obsoletos. Ejecute una actualización manual para obtener consistencia inmediata. + El intervalo mínimo de actualización automática es de una hora. + La actualización incremental admite un conjunto limitado de operaciones SQL. La definición de la vista debe ser un único bloque SELECT-FROM-WHERE-GROUP BY-HAVING y no puede contener operaciones de conjunto, subconsultas, la palabra clave DISTINCT en SELECT o en funciones de agregación, funciones de ventana ni uniones distintas de INNER JOIN. + La actualización incremental no admite funciones definidas por el usuario ni determinadas funciones integradas. Solo se admite un subconjunto de las funciones integradas de Spark SQL. + La reescritura automática de consultas solo tiene en cuenta vistas materializadas cuyas definiciones pertenecen a un subconjunto restringido de SQL, similar a las restricciones de la actualización incremental. + Los identificadores que contienen caracteres especiales distintos de caracteres alfanuméricos y guiones bajos no son compatibles en las consultas CREAR VISTA MATERIALIZADA. Esto se aplica a todos los tipos de identificadores, incluidos los nombres de catálogo/espacio de nombres/tabla, los nombres de columnas y campos de estructuras, las CTE y los alias. + Las columnas de las vistas materializadas que comienzan con el prefijo \$1\$1ivm están reservadas para uso del sistema. Amazon se reserva el derecho de modificar o eliminar estas columnas en versiones futuras. + Las cláusulas SORT BY, LIMIT, OFFSET, CLUSTER BY y ORDER BY no son compatibles en las definiciones de vistas materializadas. + No se admiten tablas de origen entre regiones ni entre cuentas. + Las tablas a las que hace referencia la consulta de la vista deben utilizar la convención de nomenclatura de tres partes (por ejemplo, glue\$1catalog.my\$1db.my\$1table), ya que la actualización automática no utiliza la configuración predeterminada de catálogo ni de base de datos. + Las operaciones de actualización completa sobrescriben la tabla en su totalidad y hacen que las instantáneas anteriores dejen de estar disponibles. + Las funciones no deterministas, como rand() o current\$1timestamp(), no son compatibles en las definiciones de vistas materializadas.