# Trabajar con tareas en AWS Glue
En las siguientes secciones, se ofrece información acerca de los trabajos de ETL y Ray en AWS Glue.
**Topics**
+ [AWS GlueVersiones de](release-notes.md)
+ [Trabajar con trabajos de Spark en AWS Glue](etl-jobs-section.md)
+ [Trabajar con tareas de Ray en AWS Glue](ray-jobs-section.md)
+ [Configuración de las propiedades de trabajos del intérprete de comandos de Python en AWS Glue](add-job-python.md)
+ [Supervisión de AWS Glue](monitor-glue.md)
# AWS GlueVersiones de
Puede configurar el parámetro de versión de AWS Glue al agregar o actualizar un trabajo. La versión de AWS Glue determina las versiones de Apache Spark y Python que admite AWS Glue. La versión de Python indica la versión admitida para trabajos de tipo Spark. En la siguiente tabla se muestran las versiones de AWS Glue disponibles, las versiones de Spark y Python correspondientes y otros cambios en la funcionalidad.
Puede utilizar las [actualizaciones con IA generativa para Apache Spark](upgrade-analysis.md) para actualizar sus tareas de ETL de Glue desde versiones anteriores de Glue (≥ 2.0) a la versión más reciente de Glue.
## AWS GlueVersiones de
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/release-notes.html)
**nota**
Las siguientes versiones de Glue son compatibles con estas versiones de PythonShell:
PythonShell v3.6 es compatible con la versión 1.0 de Glue.
PythonShell v3.9 es compatible con la versión 3.0 de Glue.
Además, los puntos de conexión de desarrollo solo son compatibles con las versiones 1.0 y 0.9 de Glue.
# Política de compatibilidad de versiones de AWS Glue
AWS Glue es un servicio de integración de datos sin servidor que facilita la detección, preparación y combinación de datos para el análisis, machine learning y desarrollo de aplicaciones. Un *trabajo de AWS Glue* contiene la lógica empresarial que realiza el trabajo de integración de datos en AWS Glue. Existen dos tipos de trabajos en AWS Glue: *Spark (por lotes y streaming)*, *Ray* e *intérprete de comandos de Python*. Al definir un trabajo, debe especificar la versión de AWS Glue que configura las versiones en el entorno en tiempo de ejecución de Spark, Ray o Python subyacente. Por ejemplo: un trabajo de AWS Glue de la versión 5.0 de Spark admite Spark 3.5.4 y Python 3.11.
## Política de soporte
Las versiones de AWS Glue se crean a partir de una combinación de sistema operativo, lenguaje de programación y bibliotecas de software que están sujetos a actualizaciones de mantenimiento y seguridad. La política de compatibilidad de la versión de AWS Glue consiste en finalizar la compatibilidad de una versión cuando algún componente importante de la versión llegue al final del soporte comunitario a largo plazo (LTS) y las actualizaciones de seguridad ya no estén disponibles. La política de soporte de versiones de AWS Glue incluye los siguientes estados:
**Fin del soporte (EOS):** cuando una versión de AWS Glue llega al EOS:
+ AWS Glue dejará de aplicar parches de seguridad u otras actualizaciones a las versiones en EOS.
+ Los trabajos de AWS Glue en versiones en EOS no son aptos para soporte técnico.
+ AWS Glue puede no cumplir con los SLA cuando los trabajos se ejecuten en versiones en EOS.
**Fin de vida útil (EOL):** cuando una versión de AWS Glue alcanza su EOL:
+ Ya no puede crear nuevos trabajos o sesiones interactivas de AWS Glue en versiones en EOL.
+ Ya no puede iniciar ejecuciones de trabajos en estas versiones de AWS Glue.
+ AWS Glue detendrá las ejecuciones de trabajos existentes y las sesiones interactivas en versiones en EOL.
+ Las versiones en EOL se eliminarán de los SDK y las API de AWS Glue.
Las siguientes versiones de AWS Glue han llegado al fin del soporte y dejarán de estar disponibles después de la fecha de fin de vida útil. Los cambios en el estado de soporte de una versión comienzan a la medianoche (zona horaria del Pacífico) en la fecha especificada.
| **Tipo** | **Versión de Glue** | **Fin del soporte** | **Fin de vida útil** |
| --- | --- | --- | --- |
| **Tipo** | **Versión de Python** | **Fin del soporte** | **Fin de vida útil** |
| --- | --- | --- | --- |
| **Tipo** | **Versión del bloc de notas** | **Fin del soporte** | **Fin de vida útil** |
| --- | --- | --- | --- |
| Spark | Versión de Glue 0.9 (Spark 2.2, Scala 2, Python 2) | 6/1/2022 | 1/4/2026 |
| Spark | Versión de Glue 1.0 (Spark 2.4, Python 2) | 6/1/2022 | 1/4/2026 |
| Spark | Versión de Glue 1.0 (Spark 2.4, Scala 2, Python 3) | 9/30/2022 | 1/4/2026 |
| Spark | Versión de Glue 2.0 (Spark 2.4, Python 3) | 31/1/2024 | 1/4/2026 |
| Shell de Python | Python 2 (AWS Glue versión 1.0) | 6/1/2022 | 1/4/2026 |
| Shell de Python | PythonShell 3.6 (versión de Glue 1.0) | 31/3/2026 | N/D |
| Punto de enlace de desarrollo | Bloc de notas de Zeppelin | 9/30/2022 | N/D |
**nota**
No podrá crear nuevos trabajos de AWS Glue Python Shell 3.6 una vez que finalice el soporte el 31 de marzo de 2026, pero podrá seguir actualizando y ejecutando los trabajos existentes. Sin embargo, los trabajos que se ejecutan en versiones discontinuadas ya no cuentan con el respaldo del soporte técnico. AWS Glue no hará revisiones de seguridad ni otras actualizaciones de las versiones discontinuadas. AWS Glue tampoco estará sujeto a los SLA cuando los trabajos se ejecuten en versiones discontinuadas.
AWS recomienda encarecidamente migrar los trabajos a versiones compatibles.
Para obtener información sobre la migración de los trabajos de Spark a la versión más reciente de AWS Glue, consulte [Migración de trabajos de AWS Glue a la versión 5.1 de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-51.html).
Para migrar los trabajos de shell de Python a la versión más reciente de AWS Glue:
+ En la consola, elija `Python 3 (Glue Version 4.0)`.
+ En la API de [CreateJob](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateJob.html)/[UpdateJob](https://docs.aws.amazon.com/glue/latest/webapi/API_UpdateJob.html), establezca el parámetro `GlueVersion` en `2.0` y `PythonVersion` en `3` en el parámetro `Command`. La configuración de `GlueVersion` no afecta al comportamiento de los trabajos del intérprete de comandos de Python, por lo que el incremento de `GlueVersion` no supone ninguna ventaja.
+ Necesita que el script de su trabajo sea compatible con Python 3.
# Migración de trabajos de Spark para AWS Glue a la versión 5.1 de AWS Glue
En este tema se describen los cambios entre las versiones 0.9, 1.0, 2.0, 3.0, 4.0 y 5.0 de AWS Glue para permitirle migrar sus aplicaciones de Spark y trabajos de ETL a la versión 5.1 de AWS Glue. También se describen las características de la versión 5.1 de AWS Glue y las ventajas de usarla.
Para usar esta función con sus trabajos de ETL de AWS Glue, elija **5.1** para la `Glue version` cuando cree sus trabajos.
**Topics**
+ [Nuevas características](#migrating-version-51-features)
+ [Acciones para migrar a AWS Glue 5.1](#migrating-version-51-actions)
+ [Lista de comprobación de migración](#migrating-version-51-checklist)
+ [Migración de AWS Glue 5.0 a AWS Glue 5.1](#migrating-version-51-from-50)
+ [Migración desde versiones anteriores de AWS Glue a AWS Glue 5.1](#migrating-older-versions-to-51)
+ [Migración de conectores y controladores JDBC para AWS Glue 5.1](#migrating-version-51-connector-driver-migration)
## Nuevas características
En esta sección se describen las nuevas características y ventajas de la versión 5.1 de AWS Glue.
+ Actualización de Apache Spark de la versión 3.5.4 en AWS Glue 5.0 a la versión 3.5.6 en AWS Glue 5.1.
+ Los formatos de tabla abierta (OTF) se actualizaron a Hudi 1.0.2, Iceberg 1.10.0 y Delta Lake 3.3.2
+ **Vistas materializadas de iceberg**: cree y administre vistas materializadas (MV) de Iceberg. Para obtener más información, consulte la [publicación del blog](https://aws.amazon.com/blogs/big-data/introducing-apache-iceberg-materialized-views-in-aws-glue-data-catalog/).
+ **Formato Iceberg versión 3.0**: amplía los tipos de datos y las estructuras de metadatos existentes para añadir nuevas capacidades. Para obtener más información, consulte [Especificación de tablas de Iceberg](https://iceberg.apache.org/spec/).
+ **Acceso completo a la tabla de Hudi**: control de acceso completo a la tabla (FTA) para Apache Hudi en Apache Spark conforme a las políticas definidas en AWS Lake Formation. Esta característica habilita operaciones de lectura y escritura desde trabajos de ETL de AWS Glue en tablas registradas en AWS Lake Formation cuando el rol del trabajo cuenta con acceso completo a la tabla.
+ **Compatibilidad con control de acceso detallado nativo de Spark (FGAC) mediante AWS Lake Formation**: operaciones DDL/DML (como CREATE, ALTER, DELETE y DROP) con control de acceso detallado para tablas de Apache Hive, Apache Iceberg y Delta Lake registradas en AWS Lake Formation.
+ **Contexto de auditoría para trabajos de Spark**: el contexto de auditoría para los trabajos de ETL de AWS Glue estará disponible para las llamadas a las API de AWS Glue y AWS Lake Formation en los registros de AWS CloudTrail.
**Problemas conocidos y limitaciones**
Tenga en cuenta los siguientes problemas y limitaciones conocidos:
+ Compatibilidad limitada con la visualización de la cláusula de SQL para la creación de vistas materializadas, la reescritura de consultas y la actualización incremental. Puede encontrar más información en la [página de documentación de características de las vistas materializadas de Iceberg](https://docs.aws.amazon.com/lake-formation/latest/dg/materialized-views.html#materialized-views-considerations-limitations).
+ Las **escrituras de FTA de Hudi** requieren el uso de HoodieCredentialedHadoopStorage para la venta de credenciales durante la ejecución del trabajo. Establezca la siguiente configuración cuando ejecute los trabajos de Hudi:
`hoodie.storage.class=org.apache.spark.sql.hudi.storage.HoodieCredentialedHadoopStorage`
+ La compatibilidad con la escritura de FTA de Hudi solo funciona con las configuraciones predeterminadas de Hudi. Los ajustes de Hudi personalizados o no predeterminados podrían no ser totalmente compatibles y podrían causar un comportamiento inesperado. Tampoco es compatible la agrupación en clústeres para las tablas Fusionar al leer (MOR) en el modo de escritura de FTA.
**Cambios bruscos**
Tenga en cuenta los siguientes cambios importantes:
+ El sistema de archivos S3A reemplazó el EMRFS como conector S3 predeterminado. Para obtener información acerca de cómo realizar la migración, consulte [Migración de AWS Glue 5.0 a AWS Glue 5.1](#migrating-version-51-from-50).
## Acciones para migrar a AWS Glue 5.1
Para los trabajos existentes, cambie la `Glue version` de la versión anterior a `Glue 5.1` en la configuración del trabajo.
+ En AWS Glue Studio, elija `Glue 5.1 - Supports Spark 3.5.6, Scala 2, Python 3` en `Glue version`.
+ En la API, elija **5.1** en el parámetro `GlueVersion` de la operación de la API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob).
Para nuevos trabajos, elija `Glue 5.1` cuando cree un trabajo.
+ En la consola, elija `Spark 3.5.6, Python 3 (Glue Version 5.1) or Spark 3.5.6, Scala 2 (Glue Version 5.1)` en `Glue version`.
+ En AWS Glue Studio, elija `Glue 5.1 - Supports Spark 3.5.6, Scala 2, Python 3` en `Glue version`.
+ En la API, elija **5.1** en el parámetro `GlueVersion` de la operación de la API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob).
Para ver los registros de eventos de Spark de AWS Glue 5.1 procedentes de AWS Glue 2.0 o una versión anterior, [active un servidor de historial de Spark actualizado para AWS Glue 5.1 mediante CloudFormation o Docker](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-history.html).
## Lista de comprobación de migración
Revise esta lista de comprobación para la migración:
+ [Python] Actualización de las referencias a boto de 1.34 a 1.40.
## Migración de AWS Glue 5.0 a AWS Glue 5.1
Todos los parámetros de trabajo existentes y las principales características que existen en AWS Glue 5.0 existirá en AWS Glue 5.1. Tenga en cuenta los siguientes cambios al migrar:
+ En AWS Glue 5.1, el sistema de archivos S3A reemplazó el EMRFS como conector S3 predeterminado. Si no se establecen `spark.hadoop.fs.s3a.endpoint` y `spark.hadoop.fs.s3a.endpoint.region`, la región predeterminada utilizada por S3A es `us-east-2`. Esto puede provocar problemas, como errores de tiempo de espera de carga en S3, especialmente en los trabajos de VPC. Para mitigar los problemas ocasionados por este cambio, establezca la configuración `spark.hadoop.fs.s3a.endpoint.region` de Spark cuando utilice el sistema de archivos S3A en AWS Glue 5.1.
+ Para seguir utilizando el EMRFS en lugar del S3A, establezca las siguientes configuraciones de Spark:
```
--conf spark.hadoop.fs.s3.impl=com.amazon.ws.emr.hadoop.fs.EmrFileSystem
--conf spark.hadoop.fs.s3n.impl=com.amazon.ws.emr.hadoop.fs.EmrFileSystem
--conf spark.hadoop.fs.AbstractFileSystem.s3.impl=org.apache.hadoop.fs.s3.EMRFSDelegate
```
Consulte la documentación de migración de Spark:
+ [Migration Guide: Spark Core](https://spark.apache.org/docs/3.5.6/core-migration-guide.html)
+ [Migration Guide: SQL, Datasets and DataFrame](https://spark.apache.org/docs/3.5.6/sql-migration-guide.html)
+ [Migration Guide: Structured Streaming](https://spark.apache.org/docs/3.5.6/ss-migration-guide.html)
+ [Upgrading PySpark](https://spark.apache.org/docs/3.5.6/api/python/migration_guide/pyspark_upgrade.html)
## Migración desde versiones anteriores de AWS Glue a AWS Glue 5.1
+ Para conocer los pasos de migración relacionados con la versión de AWS Glue 4.0 a AWS Glue 5.0, consulte [Migración de la versión de AWS Glue 4.0 a AWS Glue 5.0](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-50.html#migrating-version-50-from-40).
+ Para conocer los pasos de migración relacionados con la versión de AWS Glue 3.0 a AWS Glue 5.0, consulte [Migración de la versión de AWS Glue 3.0 a AWS Glue 5.0](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-50.html#migrating-version-50-from-30).
+ Para conocer los pasos de migración relacionados con la versión de AWS Glue 2.0 a AWS Glue 5.0 y una lista de las diferencias de migración entre las versiones de AWS Glue 2.0 y 4.0, consulte [Migración de la versión de AWS Glue 2.0 a AWS Glue 5.0](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-50.html#migrating-version-50-from-20).
## Migración de conectores y controladores JDBC para AWS Glue 5.1
Para ver las versiones de los conectores de lago de datos y JDBC que se actualizaron, consulte:
+ [Apéndice B: actualizaciones de controladores JDBC](#migrating-version-51-appendix-jdbc-driver)
+ [Apéndice C: actualizaciones del conector](#migrating-version-51-appendix-connector)
+ [Apéndice D: actualizaciones del formato de tabla abierta](#migrating-version-51-appendix-open-table-formats)
Los siguientes cambios se aplican a las actualizaciones de las versiones de OTF identificadas en [Apéndice D: actualizaciones del formato de tabla abierta](#migrating-version-51-appendix-open-table-formats) para AWS Glue 5.1.
**Apache Hudi**
Tenga en cuenta los siguientes cambios:
+ Compatibilidad con el acceso a la lectura y escritura de FTA en las tablas registradas en Lake Formation.
**Apache Iceberg**
Tenga en cuenta los siguientes cambios:
+ Compatibilidad con el formato Iceberg versión 3. Se admiten las siguientes características:
+ Transformaciones con varios argumentos para la partición y clasificación.
+ Seguimiento del linaje de filas.
+ Vectores de eliminación. Puede obtener más información en la [publicación del blog](https://aws.amazon.com/blogs/big-data/unlock-the-power-of-apache-iceberg-v3-deletion-vectors-on-amazon-emr/).
+ Claves de cifrado de tablas.
+ Compatibilidad con valores predeterminados para las columnas.
+ Compatibilidad con operaciones de escritura con control de acceso detallado (FGAC) nativo de Spark en tablas registradas en AWS Lake Formation.
+ Compatibilidad con SQL de Athena: no se pueden leer las tablas de Iceberg V3 creadas por Spark en EMR debido a un error: `GENERIC_INTERNAL_ERROR: Cannot read unsupported version 3`.
**Delta Lake**
Tenga en cuenta los siguientes cambios:
+ Compatibilidad con el acceso a la lectura y escritura de FTA en las tablas registradas en Lake Formation.
### Apéndice A: actualizaciones de dependencias importantes
Las siguientes son las actualizaciones de dependencias:
| Dependencia | Versión en AWS Glue 5.1 | Versión en AWS Glue 5.0 | Versión en AWS Glue 4.0 | Versión en AWS Glue 3.0 | Versión en AWS Glue 2.0 | Versión en AWS Glue 1.0 |
| --- | --- | --- | --- | --- | --- | --- |
| Java | 17 | 17 | 8 | 8 | 8 | 8 |
| Spark | 3.5.6 | 3.5.4 | 3.3.0-amzn-1 | 3.1.1-amzn-0 | 2.4.3 | 2.4.3 |
| Hadoop | 3.4.1 | 3.4.1 | 3.3.3-amzn-0 | 3.2.1-amzn-3 | 2.8.5-amzn-5 | 2.8.5-amzn-1 |
| Scala | 2.12.18 | 2.12.18 | 2.12 | 2.12 | 2.11 | 2.11 |
| Jackson | 2.15.2 | 2.15.2 | 2.12 | 2.12 | 2.11 | 2.11 |
| Hive | 2.3.9-amzn-4 | 2.3.9-amzn-4 | 2.3.9-amzn-2 | 2.3.7-amzn-4 | 1.2 | 1.2 |
| EMRFS | 2.73.0 | 2.69.0 | 2.54.0 | 2.46.0 | 2.38.0 | 2.30.0 |
| Json4s | 3.7.0-M11 | 3.7.0-M11 | 3.7.0-M11 | 3.6.6 | 3.5.x | 3.5.x |
| Arrow | 12.0.1 | 12.0.1 | 7.0.0 | 2.0.0 | 0.10.0 | 0.10.0 |
| AWS GlueCliente del Catálogo de datos de | 4.9.0 | 4.5.0 | 3.7.0 | 3.0.0 | 1.10.0 | N/A |
| AWS SDK para Java | 2.35.5 | 2.29.52 | 1.12 | 1.12 | | |
| Python | 3.11 | 3.11 | 3.10 | 3.7 | 2.7 y 3.6 | 2.7 y 3.6 |
| Boto | 1.40.61 | 1.34.131 | 1.26 | 1.18 | 1.12 | N/A |
| Conector de DynamoDB para EMR | 5.7.0 | 5.6.0 | 4.16.0 | | | |
### Apéndice B: actualizaciones de controladores JDBC
Las siguientes son las actualizaciones de controladores JDBC:
| Controlador | Versión del controlador JDBC en AWS Glue 5.1 | Versión del controlador JDBC en AWS Glue 5.0 | Versión del controlador JDBC en AWS Glue 4.0 | Versión del controlador JDBC en AWS Glue 3.0 | Versión del controlador JDBC en las versiones de AWS Glue anteriores |
| --- | --- | --- | --- | --- | --- |
| MySQL | 8.0.33 | 8.0.33 | 8.0.23 | 8.0.23 | 5.1 |
| Microsoft SQL Server | 10.2.0 | 10.2.0 | 9.4.0 | 7.0.0 | 6.1.0 |
| Oracle Database | 23.3.0.23.09 | 23.3.0.23.09 | 21.7 | 21.1 | 11.2 |
| PostgreSQL | 42.7.3 | 42.7.3 | 42.3.6 | 42.2.18 | 42.1.0 |
| Amazon Redshift | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.16 | redshift-jdbc41-1.2.12.1017 | redshift-jdbc41-1.2.12.1017 |
| SAP Hana | 2.20.17 | 2.20.17 | 2.17.12 | | |
| Teradata | 20.00.00.33 | 20.00.00.33 | 20.00.00.06 | | |
### Apéndice C: actualizaciones del conector
A continuación se indican las actualizaciones del conector:
| Controlador | Versión del conector en AWS Glue 5.1 | Versión del conector en AWS Glue 5.0 | Versión del conector en AWS Glue 4.0 | Versión del conector en AWS Glue 3.0 |
| --- | --- | --- | --- | --- |
| Conector de DynamoDB para EMR | 5.7.0 | 5.6.0 | 4.16.0 | |
| Amazon Redshift | 6.4.2 | 6.4.0 | 6.1.3 | |
| OpenSearch | 1.2.0 | 1.2.0 | 1.0.1 | |
| MongoDB | 10.3.0 | 10.3.0 | 10.0.4 | 3.0.0 |
| Snowflake | 3.1.1 | 3.0.0 | 2.12.0 | |
| Google BigQuery | 0.32.2 | 0.32.2 | 0.32.2 | |
| AzureCosmos | 4.33.0 | 4.33.0 | 4.22.0 | |
| AzureSQL | 1.3.0 | 1.3.0 | 1.3.0 | |
| Vertica | 3.3.5 | 3.3.5 | 3.3.5 | |
### Apéndice D: actualizaciones del formato de tabla abierta
A continuación, puede ver las actualizaciones del formato de tabla abierta:
| OTF | Versión del conector en AWS Glue 5.1 | Versión del conector en AWS Glue 5.0 | Versión del conector en AWS Glue 4.0 | Versión del conector en AWS Glue 3.0 |
| --- | --- | --- | --- | --- |
| Hudi | 1.0.2 | 0.15.0 | 0.12.1 | 0.10.1 |
| Delta Lake | 3.3.2 | 3.3.0 | 2.1.0 | 1.0.0 |
| Iceberg | 1.10.0 | 1.7.1 | 1.0.0 | 0.13.1 |
# Migración de trabajos de Spark para AWS Glue a la versión 5.0 de AWS Glue
En este tema se describen los cambios entre las versiones 0.9, 1.0, 2.0, 3.0 y 4.0 de AWS Glue para permitirle migrar sus aplicaciones de Spark y trabajos de ETL a la versión 5.0 de AWS Glue. También se describen las características de la versión 5.0 de AWS Glue y las ventajas de usarla.
Para usar esta función con sus trabajos de ETL de AWS Glue, elija **5.0** para la `Glue version` cuando cree sus trabajos.
**Topics**
+ [Nuevas características](#migrating-version-50-features)
+ [Acciones para migrar a AWS Glue 5.0](#migrating-version-50-actions)
+ [Lista de comprobación de migración](#migrating-version-50-checklist)
+ [Características de AWS Glue 5.0](#migrating-version-50-features)
+ [Migración de AWS Glue 4.0 a AWS Glue 5.0](#migrating-version-50-from-40)
+ [Migración de AWS Glue 3.0 a AWS Glue 5.0](#migrating-version-50-from-30)
+ [Migración de AWS Glue 2.0 a AWS Glue 5.0](#migrating-version-50-from-20)
+ [Cambios en el comportamiento del registro en AWS Glue 5.0](#enable-continous-logging-changes-glue-50)
+ [Migración de conectores y controladores JDBC para AWS Glue 5.0](#migrating-version-50-connector-driver-migration)
## Nuevas características
En esta sección se describen las nuevas características y ventajas de la versión 5.0 de AWS Glue.
+ Actualización de Apache Spark de la versión 3.3.0 en AWS Glue 4.0 a la versión 3.5.4 en AWS Glue 5.0. Consulte [Mejoras principales de Spark 3.3.0 a Spark 3.5.4](#migrating-version-50-features-spark).
+ Control de acceso detallado (FGAC) nativo de Spark mediante Lake Formation. Esto incluye el FGAC para las tablas de Iceberg, Delta y Hudi. Para obtener más información, consulte [Uso de AWS Glue con AWS Lake Formation para el control de acceso detallado](https://docs.aws.amazon.com/glue/latest/dg/security-lf-enable.html).
Tenga en cuenta las siguientes consideraciones o limitaciones para el FGAC nativo de Spark:
+ Actualmente, no se admiten las escrituras de datos.
+ Para escribir en Iceberg mediante `GlueContext` con Lake Formation hay que usar el control de acceso de IAM en su lugar
Para obtener una lista completa de las limitaciones y consideraciones al usar el FGAC nativo de Spark, consulte [Consideraciones y limitaciones](security-lf-enable-considerations.md).
+ La compatibilidad de las Concesiones de acceso a Amazon S3 son una solución de control de acceso escalable para los datos de Amazon S3 desde AWS Glue. Para obtener más información, consulte [Uso de Concesiones de acceso a Amazon S3 con AWS Glue](security-s3-access-grants.md).
+ Los formatos de tabla abierta (OTF) se actualizaron a Hudi 0.15.0, Iceberg 1.7.1 y Delta Lake 3.3.0
+ Compatibilidad con Estudio unificado de Amazon SageMaker.
+ Integración de Amazon SageMaker Lakehouse y la abstracción de datos. Para obtener más información, consulte [Consulta de catálogos de datos del metastore con ETL en AWS Glue](#migrating-version-50-features-metastore).
+ Compatibilidad para instalar bibliotecas de Python adicionales mediante `requirements.txt`. Para obtener más información, consulte [Instalación de bibliotecas de Python adicionales en AWS Glue 5.0 o versiones posteriores mediante requirements.txt](aws-glue-programming-python-libraries.md#addl-python-modules-requirements-txt).
+ La versión 5.0 de AWS Glue admite el linaje de datos en Amazon DataZone. Puede configurar AWS Glue para recopilar automáticamente información sobre el linaje durante la ejecución de los trabajos de Spark y enviar los eventos de linaje para verlos en Amazon DataZone. Para obtener más información, consulte [Linaje de datos en Amazon DataZone](https://docs.aws.amazon.com/datazone/latest/userguide/datazone-data-lineage.html).
Para configurarlo en la consola de AWS Glue, active **Generar eventos de linaje** e introduzca el ID de dominio de Amazon DataZone en la pestaña **Detalles del trabajo**.
![\[Captura de pantalla que muestra la activación del linaje de datos de Amazon DataZone para AWS Glue.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/glue-50-data-lineage.png)
Como alternativa, puede proporcionar el siguiente parámetro de trabajo (proporcione su ID de dominio de DataZone):
+ Clave: : `--conf`
+ Valor
```
extraListeners=io.openlineage.spark.agent.OpenLineageSparkListener
—conf spark.openlineage.transport.type=amazon_datazone_api
-conf spark.openlineage.transport.domainId=
```
+ Actualizaciones del conector y del controlador JDBC. Para obtener más información, consulte [Apéndice B: actualizaciones de controladores JDBC](#migrating-version-50-appendix-jdbc-driver) y [Apéndice C: actualizaciones del conector](#migrating-version-50-appendix-connector).
+ Actualización de Java de la versión 8 a la 17.
+ Mayor capacidad de almacenamiento para los procesos de trabajo `G.1X` y `G.2X` de AWS Glue, con un espacio en disco de 94 GB y 138 GB, respectivamente. Además, los nuevos tipos de trabajadores `G.12X`, `G.16X` y las versiones optimizadas para la memoria `R.1X`, `R.2X`, `R.4X` y `R.8X` están disponibles en AWS Glue versión 4.0 y versiones posteriores. Para obtener más información, consulte [Jobs](aws-glue-api-jobs-job.md)
+ **Compatibilidad con el SDK de AWS para Java (versión 2)**: los trabajos de AWS Glue 5.0 pueden usar las versiones de Java [1.12.569](https://github.com/aws/aws-sdk-java/tree/1.12.569) o [2.28.8](https://github.com/aws/aws-sdk-java-v2/tree/2.28.8) de si el trabajo es compatible con la versión 2. AWS SDK para Java 2.x es un cambio importante con respecto a la base de código de la versión 1.x. Se basa en Java 8 y agrega varias características solicitadas con frecuencia. Entre estas se incluyen la compatibilidad con operaciones de E/S sin bloqueo y la capacidad de conectar una implementación HTTP diferente en tiempo de ejecución. Para obtener más información, incluida una guía de migración del SDK para Java de la versión 1 a la 2, consulte la guía [SDK de AWSpara Java (versión 2)](https://docs.aws.amazon.com/sdk-for-java).
**Cambios bruscos**
Tenga en cuenta los siguientes cambios importantes:
+ En la versión 5.0 de AWS Glue, si se usa el sistema de archivos S3A y si tanto `fs.s3a.endpoint` como `fs.s3a.endpoint.region` no están configurados, la región predeterminada utilizada por S3A es `us-east-2`. Esto puede provocar problemas, como errores de tiempo de espera de carga en S3, especialmente en los trabajos de VPC. Para mitigar los problemas ocasionados por este cambio, establezca la configuración `fs.s3a.endpoint.region` de Spark cuando utilice el sistema de archivos S3A en AWS Glue 5.0.
+ Control de acceso detallado de Lake Formation (FGAC)
+ AWS Glue 5.0 solo admite el nuevo FGAC nativo de Spark (FGAC) mediante Spark DataFrames. No admite FGAC mediante AWS Glue DynamicFrames.
+ Para usar FGAC en la versión 5.0, es necesario migrar de AWS Glue DynamicFrames a Spark DataFrames.
+ Si no necesita FGAC, no hace falta migrar a Spark DataFrame. Las características de GlueContext, como los marcadores de trabajos y los predicados trasladados a la fuente, se mantienen disponibles.
+ Los trabajos con FGAC nativo de Spark requieren un mínimo de 4 nodos de procesamiento: un controlador de usuario, un controlador del sistema, un ejecutor del sistema y un ejecutor de usuario en espera.
+ Para obtener más información, consulte [Uso de AWS Glue con AWS Lake Formation para el control de acceso detallado](https://docs.aws.amazon.com/glue/latest/dg/security-lf-enable.html).
+ Acceso completo a la tabla (FTA) de Lake Formation
+ AWS Glue 5.0 admite FTA con DataFrames nativo de Spark (nuevo) y con DynamicFrames de GlueContext (heredado, con ciertas limitaciones)
+ FTA nativo de Spark
+ Si el script de la versión 4.0 utiliza GlueContext, migre al uso nativo de Spark.
+ Esta característica está disponible únicamente para tablas Hive e Iceberg
+ Para obtener más información sobre cómo configurar un trabajo en la versión 5.0 con FTA nativo de Spark, consulte
+ FTA con DynamicFrame de GlueContext
+ No es necesario modificar el código
+ Esta característica se limita a tablas que no se generan en tiempo real (no OTF) y no es compatible con Iceberg, Delta Lake ni Hudi.
+ No se admite el [lector SIMD CSV vectorizado](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-csv-home.html#aws-glue-programming-etl-format-simd-csv-reader).
+ No se admite el [registro continuo](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging-enable.html) en el grupo de registro de salida. En su lugar, utilice un grupo de registro de `error`.
+ El `job-insights-rule-driver` de información de ejecución de trabajos de AWS Glue ha quedado obsoleto. El flujo de registro `job-insights-rca-driver` ahora se encuentra en el grupo de registro de errores.
+ No se admiten los conectores personalizados o de Marketplace basados en Athena.
+ No se admiten los conectores de Adobe Marketo Engage, Facebook Ads, Google Analytics 4, Hojas de cálculo de Google, Hubspot, Instagram Ads, Intercom, Jira Cloud, Oracle NetSuite, Salesforce, Salesforce Marketing Cloud, Salesforce Marketing Cloud Account Engagement, SAP OData, ServiceNow, Slack, Snapchat Ads, Stripe, Zendesk ni Zoho CRM.
+ Las propiedades personalizadas de log4j no son compatibles con AWS Glue 5.0.
### Mejoras principales de Spark 3.3.0 a Spark 3.5.4
Tenga en cuenta las siguientes mejoras:
+ Cliente de Python para Spark Connect ([SPARK-39375](https://issues.apache.org/jira/browse/SPARK-39375)).
+ Posibilidad de establecer valores predeterminados para las columnas de las tablas ([SPARK-38334](https://issues.apache.org/jira/browse/SPARK-38334)).
+ Compatibilidad con las “referencias de alias de columnas laterales” ([SPARK-27561](https://issues.apache.org/jira/browse/SPARK-27561)).
+ Endurecimiento del uso de SQLSTATE para las clases de error ([SPARK-41994](https://issues.apache.org/jira/browse/SPARK-41994)).
+ Habilitación de las uniones con el filtro Bloom de forma predeterminada ([SPARK-38841](https://issues.apache.org/jira/browse/SPARK-38841)).
+ [Mejora de la escalabilidad de la interfaz de usuario de Spark y de la estabilidad de los controladores para aplicaciones de gran tamaño (SPARK-41053](https://issues.apache.org/jira/browse/SPARK-41053)).
+ Seguimiento asíncrono del progreso en Structured Streaming ([SPARK-39591](https://issues.apache.org/jira/browse/SPARK-39591)).
+ Procesamiento arbitrario con estado de Python en Structured Streaming ([SPARK-40434](https://issues.apache.org/jira/browse/SPARK-40434)).
+ Mejoras en la cobertura de la API de Pandas ([SPARK-42882](https://issues.apache.org/jira/browse/SPARK-42882)) y compatibilidad con entradas de NumPy en PySpark ([SPARK-39405](https://issues.apache.org/jira/browse/SPARK-39405)).
+ Generador de perfiles de memoria para las funciones definidas por el usuario de PySpark ([SPARK-40281](https://issues.apache.org/jira/browse/SPARK-40281)).
+ Implementación de un distribuidor de PyTorch ([SPARK-41589](https://issues.apache.org/jira/browse/SPARK-41589)).
+ Publicación de los artefactos de SBOM ([SPARK-41893](https://issues.apache.org/jira/browse/SPARK-41893)).
+ Compatibilidad con entornos exclusivos de IPv6 ([SPARK-39457](https://issues.apache.org/jira/browse/SPARK-39457)).
+ Disponibilidad general de programadores de K8s personalizados (Apache YuniKorn y Volcano) ([SPARK-42802](https://issues.apache.org/jira/browse/SPARK-42802)).
+ Compatibilidad para clientes de Scala and Go en Spark Connect ([SPARK-42554](https://issues.apache.org/jira/browse/SPARK-42554) y [SPARK-43351](https://issues.apache.org/jira/browse/SPARK-43351)).
+ Compatibilidad con machine learning distribuido basado en Pytorch para Spark Connect ([SPARK-42471](https://issues.apache.org/jira/browse/SPARK-42471)).
+ Compatibilidad con Structured Streaming para Spark Connect en Python y Scala ([SPARK-42938](https://issues.apache.org/jira/browse/SPARK-42938)).
+ Compatibilidad con la API de Pandas para el cliente de Python Spark Connect ([SPARK-42497](https://issues.apache.org/jira/browse/SPARK-42497)).
+ Incorporación de UDF en Python con Arrow ([SPARK-40307](https://issues.apache.org/jira/browse/SPARK-40307)).
+ Compatibilidad con funciones de tabla definidas por el usuario en Python ([SPARK-43798](https://issues.apache.org/jira/browse/SPARK-43798)).
+ Migración de los errores de PySpark a clases de error ([SPARK-42986](https://issues.apache.org/jira/browse/SPARK-42986)).
+ Marco de pruebas de PySpark ([SPARK-44042](https://issues.apache.org/jira/browse/SPARK-44042)).
+ Compatibilidad con Datasketches HLLSketch ([SPARK-16484](https://issues.apache.org/jira/browse/SPARK-16484)).
+ Mejora de las funciones SQL integradas ([SPARK-41231](https://issues.apache.org/jira/browse/SPARK-41231)).
+ Cláusula IDENTIFIER ([SPARK-43205](https://issues.apache.org/jira/browse/SPARK-43205)).
+ Incorporación de funciones SQL a la API de Scala, Python y R ([SPARK-43907](https://issues.apache.org/jira/browse/SPARK-43907)).
+ Compatibilidad con argumentos con nombre para las funciones SQL ([SPARK-43922](https://issues.apache.org/jira/browse/SPARK-43922)).
+ Posibilidad de evitar que se vuelvan a ejecutar tareas innecesarias en un ejecutor retirado perdido si se han migrado los datos de aleatorización ([SPARK-41469](https://issues.apache.org/jira/browse/SPARK-41469)).
+ Machine learning distribuido <> Spark Connect ([SPARK-42471](https://issues.apache.org/jira/browse/SPARK-42471)).
+ Distribuidor de DeepSpeed ([SPARK-44264](https://issues.apache.org/jira/browse/SPARK-44264)).
+ Implementación de puntos de control del registro de cambios para el almacenamiento de estado de RocksDB ([SPARK-43421](https://issues.apache.org/jira/browse/SPARK-43421)).
+ Introducción de propagación de marcas de agua entre los operadores ([SPARK-42376](https://issues.apache.org/jira/browse/SPARK-42376)).
+ Introducción de dropDuplicatesWithinWatermark ([SPARK-42931](https://issues.apache.org/jira/browse/SPARK-42931)).
+ Mejoras en la administración de memoria del proveedor de almacenamiento de estado de RocksDB ([SPARK-43311](https://issues.apache.org/jira/browse/SPARK-43311)).
## Acciones para migrar a AWS Glue 5.0
Para los trabajos existentes, cambie la `Glue version` de la versión anterior a `Glue 5.0` en la configuración del trabajo.
+ En AWS Glue Studio, elija `Glue 5.0 - Supports Spark 3.5.4, Scala 2, Python 3` en `Glue version`.
+ En la API, elija **5.0** en el parámetro `GlueVersion` de la operación de la API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob).
Para nuevos trabajos, elija `Glue 5.0` cuando cree un trabajo.
+ En la consola, elija `Spark 3.5.4, Python 3 (Glue Version 5.0) or Spark 3.5.4, Scala 2 (Glue Version 5.0)` en `Glue version`.
+ En AWS Glue Studio, elija `Glue 5.0 - Supports Spark 3.5.4, Scala 2, Python 3` en `Glue version`.
+ En la API, elija **5.0** en el parámetro `GlueVersion` de la operación de la API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob).
Para ver los registros de eventos de Spark de AWS Glue 5.0 procedentes de AWS Glue 2.0 o una versión anterior, [active un servidor de historial de Spark actualizado para AWS Glue 5.0 mediante CloudFormation o Docker](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-history.html).
## Lista de comprobación de migración
Revise esta lista de comprobación para la migración:
+ Actualizaciones de Java 17
+ [Scala] Actualización de las llamadas del SDK de AWS de la versión 1 a la versión 2
+ Migración de Python 3.10 a 3.11
+ [Python] Actualización de las referencias a boto de 1.26 a 1.34
## Características de AWS Glue 5.0
En esta sección, se describen las características de AWS Glue con más detalle.
### Consulta de catálogos de datos del metastore con ETL en AWS Glue
Puede registrar su trabajo de AWS Glue para acceder a AWS Glue Data Catalog, que pone tablas y otros recursos del metastore a disposición de consumidores dispares. El catálogo de datos admite una jerarquía de varios catálogos, que unifica todos los datos de los lagos de datos de Amazon S3. También proporciona una API del metastore de Hive y una API de Apache Iceberg de código abierto para acceder a los datos. Estas características están disponibles para AWS Glue y otros servicios orientados a los datos, como Amazon EMR, Amazon Athena y Amazon Redshift.
Al crear recursos en el catálogo de datos, puede acceder a ellos desde cualquier motor SQL compatible con la API de REST de Apache Iceberg. AWS Lake Formation se encarga de administrar los permisos. Tras la configuración, puede aprovechar las funcionalidades de AWS Glue para consultar datos dispares consultando estos recursos del metastore con aplicaciones conocidas. Entre estas se incluyen Apache Spark y Trino.
#### Cómo se organizan los recursos de metadatos
Los datos se organizan en una jerarquía lógica de catálogos, bases de datos y tablas, mediante AWS Glue Data Catalog:
+ Catálogo: contenedor lógico que contiene objetos de un almacén de datos, como esquemas o tablas.
+ Base de datos: organiza los objetos de datos de un catálogo, como tablas y vistas.
+ Tablas y vistas: objetos de datos de una base de datos que proporcionan una capa de abstracción con un esquema comprensible. Facilitan el acceso a los datos subyacentes, que pueden estar en varios formatos y ubicaciones.
## Migración de AWS Glue 4.0 a AWS Glue 5.0
Todos los parámetros de trabajo existentes y las principales características que existen en AWS Glue 4.0 existirán en AWS Glue 5.0, a excepción de las transformaciones de machine learning.
Se han añadido los siguientes parámetros nuevos:
+ `--enable-lakeformation-fine-grained-access`: habilita la característica de control de acceso detallado (FGAC) en las tablas de AWS Lake Formation.
Consulte la documentación de migración de Spark:
+ [Migration Guide: Spark Core](https://spark.apache.org/docs/3.5.6/core-migration-guide.html)
+ [Migration Guide: SQL, Datasets and DataFrame](https://spark.apache.org/docs/3.5.6/sql-migration-guide.html)
+ [Migration Guide: Structured Streaming](https://spark.apache.org/docs/3.5.6/ss-migration-guide.html)
+ [Upgrading PySpark](https://spark.apache.org/docs/3.5.6/api/python/migration_guide/pyspark_upgrade.html)
## Migración de AWS Glue 3.0 a AWS Glue 5.0
**nota**
Para conocer los pasos de migración relacionados con AWS Glue 4.0, consulte [Migración de AWS Glue 3.0 a AWS Glue 4.0](migrating-version-40.md#migrating-version-40-from-30).
Todos los parámetros de trabajo existentes y las principales características que existen en AWS Glue 3.0 existirán en AWS Glue 5.0, a excepción de las transformaciones de machine learning.
## Migración de AWS Glue 2.0 a AWS Glue 5.0
**nota**
Para ver los pasos de migración relacionados con AWS Glue 4.0 y una lista de las diferencias de migración entre las versiones 3.0 y 4.0 de AWS Glue, consulte [Migración de AWS Glue 3.0 a AWS Glue 4.0](migrating-version-40.md#migrating-version-40-from-30).
Tenga en cuenta también las siguientes diferencias de migración entre las versiones 3.0 y 2.0 de AWS Glue:
+ Todos los parámetros de trabajo existentes y las principales características que existen en AWS Glue 2.0 existirán en AWS Glue 5.0, a excepción de las transformaciones de machine learning.
+ Varios cambios de Spark por sí solos pueden requerir la revisión de sus scripts para garantizar que no se haga referencia a las características eliminadas. Por ejemplo, Spark 3.1.1 (y versiones posteriores) no habilita UDF sin tipo Scala, pero Spark 2.4 sí los permite.
+ No es compatible con Python 2.7.
+ Cualquier archivo JAR adicional suministrado en trabajos de AWS Glue 2.0 puede traer dependencias conflictivas, ya que hubo actualizaciones en varias dependencias. Puede evitar conflictos de classpath con el parámetro de trabajo de `--user-jars-first`.
+ Cambios en el comportamiento de cargar o guardar marcas de tiempo desde archivos de parquet y hacia ellos. Para obtener más información, consulte Actualización de Spark SQL 3.0 a 3.1
+ Diferente paralelismo de tareas de Spark para la configuración del controlador/ejecutor. Puede ajustar el paralelismo de tareas pasando el argumento del trabajo `--executor-cores`.
## Cambios en el comportamiento del registro en AWS Glue 5.0
A continuación se presentan los cambios en el comportamiento del registro en AWS Glue 5.0. Para obtener más información, consulte la sección [Registro para trabajos de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging.html).
+ Todos los registros (registros del sistema, registros de los daemon de Spark, registros del usuario y registros de Glue Logger) ahora se escriben de forma predeterminada en el grupo de registro `/aws-glue/jobs/error`.
+ El grupo de registro `/aws-glue/jobs/logs-v2` que se usaba para el registro continuo en versiones anteriores ya no se utiliza.
+ Ya no es posible cambiar ni personalizar los nombres de los grupos o flujos de registro mediante los argumentos de registro continuo que han sido eliminados. En su lugar, consulte los nuevos argumentos de trabajo disponibles en AWS Glue 5.0.
### En AWS Glue 5.0 se han incorporado dos nuevos 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`.
+ `––custom-logStream-prefix`: permite especificar un prefijo personalizado para los nombres de los flujos de registro dentro de los grupos de registro.
Las reglas y limitaciones de validación de los prefijos personalizados incluyen:
+ El nombre completo del flujo de registro debe tener entre 1 y 512 caracteres.
+ El prefijo personalizado de los nombres de los flujos de registro tiene un límite de 400 caracteres.
+ Los caracteres permitidos en los prefijos incluyen letras, números, guiones bajos (\$1), guiones (-) y barras diagonales (/).
### Argumentos de registro continuo obsoletos en AWS Glue 5.0
Los siguientes argumentos de trabajo para el registro continuo se han declarado obsoletos en AWS Glue 5.0.
+ `––enable-continuous-cloudwatch-log`
+ `––continuous-log-logGroup`
+ `––continuous-log-logStreamPrefix`
+ `––continuous-log-conversionPattern`
+ `––enable-continuous-log-filter`
## Migración de conectores y controladores JDBC para AWS Glue 5.0
Para ver las versiones de los conectores de lago de datos y JDBC que se actualizaron, consulte:
+ [Apéndice B: actualizaciones de controladores JDBC](#migrating-version-50-appendix-jdbc-driver)
+ [Apéndice C: actualizaciones del conector](#migrating-version-50-appendix-connector)
+ [Apéndice D: actualizaciones del formato de tabla abierta](#migrating-version-50-appendix-open-table-formats)
Los siguientes cambios se aplican a las versiones de conector o controlador que se identifican en los apéndices de Glue 5.0.
**Amazon Redshift**
Tenga en cuenta los siguientes cambios:
+ Compatibilidad con los nombres de tablas de tres partes para permitir que el conector consulte las tablas de intercambio de datos de Redshift.
+ Corrección de la asignación de Spark `ShortType` para usar Redshift `SMALLINT` en lugar de `INTEGER` a fin de ajustarse mejor al tamaño de datos esperado.
+ Compatibilidad con los nombres de clúster personalizados (CNAME) para Amazon Redshift sin servidor.
**Apache Hudi**
Tenga en cuenta los siguientes cambios:
+ Compatibilidad con el índice de nivel de registro.
+ Compatibilidad con la generación automática de claves de registro. Ya no es necesario especificar el campo de claves de registro.
**Apache Iceberg**
Tenga en cuenta los siguientes cambios:
+ Compatibilidad con el control de acceso detallado con AWS Lake Formation.
+ Compatibilidad con la ramificación y el etiquetado, que reciben nombres que hacen referencia a instantáneas con sus propios ciclos de vida independientes.
+ Incorporación de un procedimiento de visualización del registro de cambios que genera una vista que contiene los cambios realizados en una tabla durante un período específico o entre instantáneas específicas.
**Delta Lake**
Tenga en cuenta los siguientes cambios:
+ Compatibilidad con el formato universal Delta (UniForm), que permite un acceso sin problemas a través de Apache Iceberg y Apache Hudi.
+ Compatibilidad con los vectores de eliminación que implementan un paradigma de tipo Fusionar al leer.
**AzureCosmos**
Tenga en cuenta los siguientes cambios:
+ Compatibilidad con claves de partición jerárquicas.
+ Incorporación de la opción de usar un esquema personalizado con StringType (JSON sin procesar) para una propiedad anidada.
+ Incorporación de la opción de configuración `spark.cosmos.auth.aad.clientCertPemBase64` para permitir el uso de la autenticación SPN (nombre de ServicePrincipal) con certificado en lugar de secreto de cliente.
Para obtener más información, consulte [Azure Cosmos DB Spark connector change log](https://github.com/Azure/azure-sdk-for-java/blob/main/sdk/cosmos/azure-cosmos-spark_3-2_2-12/CHANGELOG.md).
**Microsoft SQL Server**
Tenga en cuenta los siguientes cambios:
+ El cifrado de TLS está habilitado de manera predeterminada.
+ Si se establece encrypt = false, pero el servidor requiere cifrado, el certificado se valida en función de la configuración de conexión `trustServerCertificate`.
+ `aadSecurePrincipalId` y `aadSecurePrincipalSecret` obsoletos.
+ Se ha eliminado la API `getAADSecretPrincipalId`.
+ Se agregó la resolución CNAME cuando se especifica el dominio.
**MongoDB**
Tenga en cuenta los siguientes cambios:
+ Compatibilidad con el modo de microlotes con Spark Structured Streaming.
+ Compatibilidad con tipos de datos BSON.
+ Se agregó compatibilidad para leer varias colecciones cuando se utilizan los modos de transmisión continua o por microlotes.
+ Si en la opción de configuración `collection` se incluye una colección con una coma en el nombre, el conector de Spark la tratará como dos colecciones diferentes. Para evitar esto, debe aplicar un carácter de escape a la coma: antepóngale una barra invertida (\$1).
+ Si en la opción de configuración `collection` se incluye una colección con el nombre “\$1”, el conector de Spark lo interpretará como una especificación para examinar todas las colecciones. Para evitar esto, debe aplicar un carácter de escape al asterisco; para ello, antepóngale una barra invertida (\$1).
+ Si en la opción de configuración `collection` se incluye una colección con una barra invertida (\$1) en el nombre, el conector de Spark tratará la barra invertida como un carácter de escape, lo que puede cambiar la interpretación del valor. Para evitar esto, debe aplicar un carácter de escape a la barra invertida; para ello, antepóngale otra barra invertida (\$1).
Para obtener más información, consulte las [notas de la versión del conector de MongoDB para Spark](https://www.mongodb.com/docs/spark-connector/current/release-notes/).
**Snowflake**
Tenga en cuenta los siguientes cambios:
+ Se ha introducido un nuevo parámetro `trim_space` que puede usar para recortar automáticamente los valores de las columnas `StringType` al guardarlas en una tabla de Snowflake. Valor predeterminado: `false`.
+ Se ha deshabilitado el parámetro `abort_detached_query` en el nivel de sesión de forma predeterminada.
+ Se ha eliminado el requisito del parámetro `SFUSER` cuando se utiliza OAUTH.
+ Se ha eliminado la característica de delegación avanzada de consultas. Tiene disponibles varias alternativas a esta característica. Por ejemplo, en lugar de cargar datos de las tablas de Snowflake, los usuarios pueden cargar directamente los datos de las consultas SQL de Snowflake.
Para obtener más información, consulte las [notas de la versión de Spark para el conector de Snowflake](https://docs.snowflake.com/en/release-notes/clients-drivers/spark-connector-2024).
### Apéndice A: actualizaciones de dependencias importantes
Las siguientes son las actualizaciones de dependencias:
| Dependencia | Versión en AWS Glue 5.0 | Versión en AWS Glue 4.0 | Versión en AWS Glue 3.0 | Versión en AWS Glue 2.0 | Versión en AWS Glue 1.0 |
| --- | --- | --- | --- | --- | --- |
| Java | 17 | 8 | 8 | 8 | 8 |
| Spark | 3.5.4 | 3.3.0-amzn-1 | 3.1.1-amzn-0 | 2.4.3 | 2.4.3 |
| Hadoop | 3.4.1 | 3.3.3-amzn-0 | 3.2.1-amzn-3 | 2.8.5-amzn-5 | 2.8.5-amzn-1 |
| Scala | 2.12.18 | 2.12 | 2.12 | 2.11 | 2.11 |
| Jackson | 2.15.2 | 2.12 | 2.12 | 2.11 | 2.11 |
| Hive | 2.3.9-amzn-4 | 2.3.9-amzn-2 | 2.3.7-amzn-4 | 1.2 | 1.2 |
| EMRFS | 2.69.0 | 2.54.0 | 2.46.0 | 2.38.0 | 2.30.0 |
| Json4s | 3.7.0-M11 | 3.7.0-M11 | 3.6.6 | 3.5.x | 3.5.x |
| Arrow | 12.0.1 | 7.0.0 | 2.0.0 | 0.10.0 | 0.10.0 |
| AWS GlueCliente del Catálogo de datos de | 4.5.0 | 3.7.0 | 3.0.0 | 1.10.0 | N/A |
| AWS SDK para Java | 2.29.52 | 1.12 | 1.12 | | |
| Python | 3.11 | 3.10 | 3.7 | 2.7 y 3.6 | 2.7 y 3.6 |
| Boto | 1.34.131 | 1.26 | 1.18 | 1.12 | N/A |
| Conector de DynamoDB para EMR | 5.6.0 | 4.16.0 | | | |
### Apéndice B: actualizaciones de controladores JDBC
Las siguientes son las actualizaciones de controladores JDBC:
| Controlador | Versión del controlador JDBC en AWS Glue 5.0 | Versión del controlador JDBC en AWS Glue 4.0 | Versión del controlador JDBC en AWS Glue 3.0 | Versión del controlador JDBC en las versiones de AWS Glue anteriores |
| --- | --- | --- | --- | --- |
| MySQL | 8.0.33 | 8.0.23 | 8.0.23 | 5.1 |
| Microsoft SQL Server | 10.2.0 | 9.4.0 | 7.0.0 | 6.1.0 |
| Oracle Database | 23.3.0.23.09 | 21.7 | 21.1 | 11.2 |
| PostgreSQL | 42.7.3 | 42.3.6 | 42.2.18 | 42.1.0 |
| Amazon Redshift | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.16 | redshift-jdbc41-1.2.12.1017 | redshift-jdbc41-1.2.12.1017 |
| SAP Hana | 2.20.17 | 2.17.12 | | |
| Teradata | 20.00.00.33 | 20.00.00.06 | | |
### Apéndice C: actualizaciones del conector
A continuación se indican las actualizaciones del conector:
| Controlador | Versión del conector en AWS Glue 5.0 | Versión del conector en AWS Glue 4.0 | Versión del conector en AWS Glue 3.0 |
| --- | --- | --- | --- |
| Conector de DynamoDB para EMR | 5.6.0 | 4.16.0 | |
| Amazon Redshift | 6.4.0 | 6.1.3 | |
| OpenSearch | 1.2.0 | 1.0.1 | |
| MongoDB | 10.3.0 | 10.0.4 | 3.0.0 |
| Snowflake | 3.0.0 | 2.12.0 | |
| Google BigQuery | 0.32.2 | 0.32.2 | |
| AzureCosmos | 4.33.0 | 4.22.0 | |
| AzureSQL | 1.3.0 | 1.3.0 | |
| Vertica | 3.3.5 | 3.3.5 | |
### Apéndice D: actualizaciones del formato de tabla abierta
A continuación, puede ver las actualizaciones del formato de tabla abierta:
| OTF | Versión del conector en AWS Glue 5.0 | Versión del conector en AWS Glue 4.0 | Versión del conector en AWS Glue 3.0 |
| --- | --- | --- | --- |
| Hudi | 0.15.0 | 0.12.1 | 0.10.1 |
| Delta Lake | 3.3.0 | 2.1.0 | 1.0.0 |
| Iceberg | 1.7.1 | 1.0.0 | 0.13.1 |
# Migración de trabajos de AWS Glue para Spark a la versión 4.0 de AWS Glue
En este tema se describen los cambios entre las versiones 0.9, 1.0, 2.0 y 3.0 de AWS Glue para permitirle migrar sus aplicaciones de Spark y trabajos de ETL a AWS Glue 4.0. También se describen las características de la versión 4.0 de AWS Glue y las ventajas de usarla.
Para usar esta función con sus trabajos de ETL de AWS Glue, elija **4.0** para la `Glue version` cuando cree sus trabajos.
**Topics**
+ [Características nuevas admitidas](#migrating-version-40-features)
+ [Acciones que migrar a AWS Glue 4.0](#migrating-version-40-actions)
+ [Lista de comprobación de migración](#migrating-version-40-checklist)
+ [Migración de AWS Glue 3.0 a AWS Glue 4.0](#migrating-version-40-from-30)
+ [Migración de AWS Glue 2.0 a AWS Glue 4.0](#migrating-version-40-from-20)
+ [Migración de AWS Glue 1.0 a AWS Glue 4.0](#migrating-version-40-from-10)
+ [Migración de AWS Glue 0.9 a AWS Glue 4.0](#migrating-version-40-from-09)
+ [Migración de conectores y controladores JDBC para AWS Glue 4.0](#migrating-version-40-connector-driver-migration)
+ [Apéndice A: actualizaciones de dependencias importantes](#migrating-version-40-appendix-dependencies)
+ [Apéndice B: actualizaciones de controladores JDBC](#migrating-version-40-appendix-jdbc-driver)
+ [Apéndice C: actualizaciones del conector](#migrating-version-40-appendix-connector)
## Características nuevas admitidas
En esta sección se describen las nuevas características y ventajas de la versión 4.0 de AWS Glue.
+ Se basa en Apache Spark 3.3.0, pero incluye optimizaciones en AWS Glue y Amazon EMR, tales como ejecuciones de consultas adaptativas, lectores vectorizados y combinación de particiones y mezclas aleatorias optimizadas.
+ Controladores JDBC actualizados para todos los orígenes nativos de AWS Glue, que incluyen MySQL, Microsoft SQL Server, Oracle, PostgreSQL, MongoDB, y bibliotecas y dependencias de Spark actualizadas introducidas por Spark 3.3.0.
+ Actualización con un nuevo conector de Amazon Redshift y un controlador JDBC.
+ Acceso optimizado a Amazon S3 con el sistema de archivos EMR (EMRFS) actualizado y confirmadores de salida optimizados de Amazon S3 habilitados de forma predeterminada.
+ Acceso optimizado al Catálogo de datos con índices de partición, predicados de inserción, lista de particiones y un cliente de metaalmacén de Hive actualizado.
+ Integración con Lake Formation para tablas de catálogo gobernadas con filtrado a nivel de celda y transacciones de lago de datos.
+ Reducción de la latencia de inicio para mejorar los tiempos generales de finalización del trabajo y la interactividad.
+ Los trabajos de Spark se facturan en incrementos de 1 segundo con una duración mínima de facturación 10 veces menor, de un mínimo de 10 minutos a un mínimo de 1 minuto.
+ Compatibilidad nativa con marcos de lagos de datos de código abierto con Apache Hudi, Delta Lake y Apache Iceberg.
+ Compatibilidad nativa con el complemento Cloud Shuffle Storage basado en Amazon S3 (un complemento de Apache Spark) a fin de usar Amazon S3 para la mezcla aleatoria y la capacidad de almacenamiento elástica.
**Mejoras principales de Spark 3.1.1 a Spark 3.3.0**
Tenga en cuenta las siguientes mejoras:
+ Filtrado en tiempo de ejecución de fila ([SPARK-32268](https://issues.apache.org/jira/browse/SPARK-32268)).
+ Mejoras de ANSI ([SPARK-38860](https://issues.apache.org/jira/browse/SPARK-38860)).
+ Mejoras de los mensajes de error ([SPARK-38781](https://issues.apache.org/jira/browse/SPARK-38781)).
+ Compatibilidad de tipos complejos con el lector vectorizado de Parquet ([SPARK-34863](https://issues.apache.org/jira/browse/SPARK-34863)).
+ Compatibilidad de metadatos de archivos ocultos con Spark SQL ([SPARK-37273](https://issues.apache.org/jira/browse/SPARK-37273)).
+ Se proporciona un generador de perfiles para las UDF de Python o Pandas ([SPARK-37443](https://issues.apache.org/jira/browse/SPARK-37443)).
+ Se introduce Trigger.AvailableNow para ejecutar consultas de transmisión como Trigger.Once en varios lotes ([SPARK-36533](https://issues.apache.org/jira/browse/SPARK-36533)).
+ Capacidades de inserción de Datasource V2 más completas ([SPARK-38788](https://issues.apache.org/jira/browse/SPARK-38788)).
+ Migración de log4j 1 a log4j 2 ([SPARK-37814](https://issues.apache.org/jira/browse/SPARK-37814)).
**Otros cambios notables**
Tenga en cuenta los siguientes cambios:
+ Cambios bruscos
+ Se eliminan las referencias a la compatibilidad con Python 3.6 en los documentos y documentación de Python ([SPARK-36977](https://issues.apache.org/jira/browse/SPARK-36977)).
+ Se elimina el truco de tupla con nombre al reemplazar el objeto pickle integrado por cloudpickle ([SPARK-32079](https://issues.apache.org/jira/browse/SPARK-32079)).
+ Se incrementa la versión mínima de Pandas a la 1.0.5 ([SPARK-37465](https://issues.apache.org/jira/browse/SPARK-37465)).
## Acciones que migrar a AWS Glue 4.0
Para los trabajos existentes, cambie la `Glue version` de la versión anterior a `Glue 4.0` en la configuración del trabajo.
+ En AWS Glue Studio, elija `Glue 4.0 - Supports Spark 3.3, Scala 2, Python 3` en `Glue version`.
+ En la API, elija **4.0** en el parámetro `GlueVersion` de la operación de la API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob).
Para nuevos trabajos, elija `Glue 4.0` cuando cree un trabajo.
+ En la consola, elija `Spark 3.3, Python 3 (Glue Version 4.0) or Spark 3.3, Scala 2 (Glue Version 3.0)` en `Glue version`.
+ En AWS Glue Studio, elija `Glue 4.0 - Supports Spark 3.3, Scala 2, Python 3` en `Glue version`.
+ En la API, elija **4.0** en el parámetro `GlueVersion` de la operación de la API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob).
Para ver los registros de eventos de Spark de AWS Glue 4.0 procedentes de AWS Glue 2.0 o una versión anterior, [lance un servidor de historial de Spark actualizado para AWS Glue 4.0 mediante CloudFormation o Docker](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-history.html).
## Lista de comprobación de migración
+ ¿Las bibliotecas externas de Python de su trabajo dependen de Python 2.7/3.6?
+ Actualice las bibliotecas dependientes de Python 2.7 o 3.6 a Python 3.10, ya que Spark 3.3.0 eliminó por completo la compatibilidad con Python 2.7 y 3.6.
## Migración de AWS Glue 3.0 a AWS Glue 4.0
Tenga en cuenta los siguientes cambios al migrar:
+ Todos los parámetros de trabajo existentes y las principales características que existen en AWS Glue 3.0 existirán en AWS Glue 4.0.
+ AWS Glue 3.0 utiliza Spark 3.1.1 optimizado para Amazon EMR y AWS Glue 4.0 utiliza Spark 3.3.0 optimizado para Amazon EMR.
Es posible que varios cambios de Spark por sí solos requieran la revisión de sus scripts para garantizar que no se haga referencia a las características eliminadas.
+ AWS Glue 4.0 también incluye una actualización de EMRFS y Hadoop. Para saber la versión específica, consulte [Apéndice A: actualizaciones de dependencias importantes](#migrating-version-40-appendix-dependencies).
+ La versión de AWS SDK que se proporciona en los trabajos de ETL ahora se ha actualizado de la 1.11 a la 1.12.
+ Todos los trabajos de Python utilizarán la versión 3.10 de Python. Anteriormente, Python 3.7 se usaba en AWS Glue 3.0.
Como resultado, se actualizan algunos pymodules que AWS Glue incluye listos para usar.
+ Log4j se ha actualizado a Log4j2.
+ Para obtener información sobre la ruta de migración de Log4j2, consulte la [documentación de Log4j](https://logging.apache.org/log4j/2.x/manual/migration.html#Log4j2API).
+ En su lugar, debe cambiar el nombre de cualquier archivo log4j.properties personalizado a un archivo log4j2.properties, con las propiedades de log4j2 adecuadas.
+ Para migrar determinados conectores, consulte [Migración de conectores y controladores JDBC para AWS Glue 4.0](#migrating-version-40-connector-driver-migration).
+ Se actualizó el SDK de cifrado de AWS de 1.x a 2.x. Se ven afectados los trabajos de AWS Glue que utilizan configuraciones de seguridad de AWS Glue y los trabajos que dependen de la dependencia del SDK de cifrado de AWS proporcionada en tiempo de ejecución. Consulte las instrucciones para la migración de trabajos de AWS Glue.
Puede actualizar de forma segura un trabajo de AWS Glue 2.0 o 3.0 a un trabajo de AWS Glue 4.0 porque AWS Glue 2.0 o 3.0 ya contiene la versión puente del SDK de cifrado de AWS.
Consulte la documentación de migración de Spark:
+ [Upgrading from Spark SQL 3.1 to 3.2](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-31-to-32) (Actualización de Spark SQL 3.1 a 3.2)
+ [Upgrading from Spark SQL 3.2 to 3.3](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-32-to-33) (Actualización de Spark SQL 3.2 a 3.3)
## Migración de AWS Glue 2.0 a AWS Glue 4.0
Tenga en cuenta los siguientes cambios al migrar:
**nota**
Para conocer los pasos de migración relacionados con AWS Glue 3.0, consulte [Migración de AWS Glue 3.0 a AWS Glue 4.0](#migrating-version-40-from-30).
+ Todos los parámetros de trabajo existentes y las principales características que existen en AWS Glue 2.0 existirán en AWS Glue 4.0.
+ El confirmador optimizado para S3 de EMRFS para la escritura de datos de Parquet en Amazon S3 está habilitado de forma predeterminada a partir de AWS Glue 3.0. Sin embargo, todavía puede desactivarlo mediante la configuración de `--enable-s3-parquet-optimized-committer` a `false`.
+ AWS Glue 2.0 utiliza la versión 2.4 de Spark de código abierto y AWS Glue 4.0, la versión 3.3.0 optimizada para Amazon EMR.
+ Varios cambios de Spark por sí solos pueden requerir la revisión de sus scripts para garantizar que no se haga referencia a las características eliminadas.
+ Por ejemplo, Spark 3.3.0 no permite las UDF sin tipo Scala, pero Spark 2.4 sí.
+ La versión de AWS SDK que se proporciona en los trabajos de ETL ahora se ha actualizado de la 1.11 a la 1.12.
+ AWS Glue 4.0 también incluye una actualización de EMRFS, controladores JDBC actualizados e inclusiones de optimizaciones adicionales en Spark proporcionadas por AWS Glue.
+ Scala se actualiza a la versión 2.12 desde la 2.11, y Scala 2.12 no es compatible con Scala 2.11.
+ Python 3.10 es la versión predeterminada utilizada para los scripts de Python, ya que AWS Glue 2.0 solo utilizaba Python 3.7 y 2.7.
+ Python 2.7 no es compatible con Spark 3.3.0. Cualquier trabajo que solicite Python 2 en la configuración del trabajo producirá un error con IllegalArgumentException.
+ Hay disponible un nuevo mecanismo para instalar módulos adicionales de Python a partir de AWS Glue 2.0.
+ Varias actualizaciones de dependencias, destacadas en . [Apéndice A: actualizaciones de dependencias importantes](#migrating-version-40-appendix-dependencies).
+ Cualquier archivo JAR adicional suministrado en trabajos existentes de AWS Glue 2.0 puede traer dependencias conflictivas, ya que hubo actualizaciones en varias dependencias en la versión 4.0 con respecto a la 2.0. Puede evitar conflictos de classpath en AWS Glue 4.0 con el parámetro de trabajo `--user-jars-first` de AWS Glue.
+ AWS Glue 4.0 usa Spark 3.3. A partir de Spark 3.1, se produjo un cambio en el comportamiento de cargar/guardar marcas de tiempo desde archivos de parquet y hacia estos. Para obtener más información, consulte [Actualización de Spark SQL 3.0 a 3.1](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-30-to-31)
Recomendamos establecer los siguientes parámetros al leer y escribir datos de parquet que contengan columnas de marca temporal. La configuración de estos parámetros puede resolver el problema de incompatibilidad del calendario que se produce durante la actualización de Spark 2 a Spark 3, tanto para el marco dinámico de AWS Glue como para el marco de datos de Spark. Utilice la opción CORRECTED para leer el valor de fecha y hora tal como está; y la opción LEGACY para rebasar los valores de fecha y hora con respecto a la diferencia de calendario durante la lectura.
```
- Key: --conf
- Value: spark.sql.legacy.parquet.int96RebaseModeInRead=[CORRECTED|LEGACY] --conf spark.sql.legacy.parquet.int96RebaseModeInWrite=[CORRECTED|LEGACY] --conf spark.sql.legacy.parquet.datetimeRebaseModeInRead=[CORRECTED|LEGACY]
```
+ Para migrar determinados conectores, consulte [Migración de conectores y controladores JDBC para AWS Glue 4.0](#migrating-version-40-connector-driver-migration).
+ Se actualizó el SDK de cifrado de AWS de 1.x a 2.x. Se ven afectados los trabajos de AWS Glue que utilizan configuraciones de seguridad de AWS Glue y los trabajos que dependen de la dependencia del SDK de cifrado de AWS proporcionada en tiempo de ejecución. Consulte estas instrucciones para la migración de trabajos de AWS Glue:
+ Puede actualizar de forma segura un trabajo de AWS Glue 2.0 a un trabajo de AWS Glue 4.0 porque AWS Glue 2.0 ya contiene la versión puente del SDK de cifrado de AWS.
Consulte la documentación de migración de Spark:
+ [Upgrading from Spark SQL 2.4 to 3.0 (Actualización de Spark SQL 2.4 a 3.0](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-24-to-30)
+ [Upgrading from Spark SQL 3.1 to 3.2 (Actualización de Spark SQL 3.1 a 3.2](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-31-to-32)
+ [Upgrading from Spark SQL 3.2 to 3.3 (Actualización de Spark SQL 3.2 a 3.3](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-32-to-33)
+ [Changes in Datetime behavior to be expected since Spark 3.0 (Cambios en el comportamiento de Datetime que se esperan a partir de Spark 3.0.](https://issues.apache.org/jira/browse/SPARK-31408)
## Migración de AWS Glue 1.0 a AWS Glue 4.0
Tenga en cuenta los siguientes cambios al migrar:
+ AWS Glue 1.0 utiliza la versión 2.4 de Spark de código abierto y AWS Glue 4.0, la versión 3.3.0 optimizada para Amazon EMR.
+ Varios cambios de Spark por sí solos pueden requerir la revisión de sus scripts para garantizar que no se haga referencia a las características eliminadas.
+ Por ejemplo, Spark 3.3.0 no permite las UDF sin tipo Scala, pero Spark 2.4 sí.
+ Todos los trabajos de AWS Glue 4.0 se ejecutarán con tiempos de inicio significativamente mejorados. Los trabajos de Spark se facturarán en incrementos de 1 segundo con una duración mínima de facturación 10 veces menor, ya que la latencia de inicio pasará de 10 minutos máximo a 1 minuto máximo.
+ El comportamiento del registro cambió significativamente en AWS Glue 4.0; Spark 3.3.0 tiene un requisito mínimo de Log4j2.
+ Varias actualizaciones de dependencias, que se destacan en el apéndice.
+ Scala también se actualiza a la versión 2.12 desde la 2.11, y Scala 2.12 no es compatible con Scala 2.11.
+ Python 3.10 es también la versión predeterminada utilizada para los scripts de Python, ya que AWS Glue 0.9 solo utilizaba Python 2.
Python 2.7 no es compatible con Spark 3.3.0. Cualquier trabajo que solicite Python 2 en la configuración del trabajo producirá un error con IllegalArgumentException.
+ Hay disponible un nuevo mecanismo para instalar módulos adicionales de Python mediante pip a partir de AWS Glue 2.0. Para obtener más información, consulte [Instalación de módulos de Python adicionales con pip en AWS Glue 2.0\$1](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-libraries.html#addl-python-modules-support).
+ AWS Glue 4.0 no se ejecuta en Apache YARN, por lo que la configuración de YARN no se aplica.
+ AWS Glue 4.0 no tiene un Sistema de archivos distribuido de Hadoop (HDFS).
+ Cualquier archivo JAR adicional suministrado en trabajos existentes de AWS Glue 1.0 puede traer dependencias conflictivas, ya que hubo actualizaciones en varias dependencias en la versión 4.0 con respecto a la 1.0. Habilitamos AWS Glue 4.0 con el parámetro de trabajo de AWS Glue `--user-jars-first` de forma predeterminada para evitar este problema.
+ AWS Glue 4.0 admite el escalado automático. Por lo tanto, la métrica ExecutorAllocationManager estará disponible cuando se habilite el escalado automático.
+ Para trabajos de la versión 4.0 de AWS Glue, debe especificar el número de procesos de trabajo y el tipo de proceso de trabajo, pero no un valor de `maxCapacity`.
+ AWS GlueLos trabajos de 4.0 todavía no admiten transformaciones de machine learning.
+ Para migrar determinados conectores, consulte [Migración de conectores y controladores JDBC para AWS Glue 4.0](#migrating-version-40-connector-driver-migration).
+ Se actualizó el SDK de cifrado de AWS de 1.x a 2.x. Se ven afectados los trabajos de AWS Glue que utilizan configuraciones de seguridad de AWS Glue y los trabajos que dependen de la dependencia del SDK de cifrado de AWS proporcionada en tiempo de ejecución. Consulte estas instrucciones para la migración de trabajos de AWS Glue.
+ No puede migrar ningún trabajo de AWS Glue 0.9 o 1.0 a un trabajo de AWS Glue 4.0 directamente. Esto se debe a que, al actualizar directamente a la versión 2.x o una posterior y habilitar todas las características nuevas de inmediato, el SDK de cifrado de AWS no podrá descifrar el texto cifrado en versiones anteriores del SDK de cifrado de AWS.
+ Para llevar a cabo la actualización de forma segura, primero le recomendamos que migre a un trabajo de AWS Glue 2.0 o 3.0 que contenga la versión puente del SDK de cifrado de AWS. Ejecute el trabajo una vez para utilizar la versión puente del SDK de cifrado de AWS.
+ Al finalizar, puede migrar de forma segura el trabajo de AWS Glue 2.0 o 3.0 a AWS Glue 4.0.
Consulte la documentación de migración de Spark:
+ [Upgrading from Spark SQL 2.4 to 3.0 (Actualización de Spark SQL 2.4 a 3.0](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-24-to-30)
+ [Upgrading from Spark SQL 3.0 to 3.1 (Actualización de Spark SQL 3.0 a 3.1](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-30-to-31)
+ [Upgrading from Spark SQL 3.1 to 3.2 (Actualización de Spark SQL 3.1 a 3.2](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-31-to-32)
+ [Upgrading from Spark SQL 3.2 to 3.3 (Actualización de Spark SQL 3.2 a 3.3](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-32-to-33)
+ [Changes in Datetime behavior to be expected since Spark 3.0 (Cambios en el comportamiento de Datetime que se esperan a partir de Spark 3.0.](https://issues.apache.org/jira/browse/SPARK-31408)
## Migración de AWS Glue 0.9 a AWS Glue 4.0
Tenga en cuenta los siguientes cambios al migrar:
+ AWS Glue 0.9 utiliza la versión 2.2.1 de Spark de código abierto y AWS Glue 4.0, la versión 3.3.0 optimizada para Amazon EMR.
+ Es posible que varios cambios de Spark por sí solos requieran la revisión de sus scripts para garantizar que no se haga referencia a las características eliminadas.
+ Por ejemplo, Spark 3.3.0 no permite las UDF sin tipo Scala, pero Spark 2.2 sí.
+ Todos los trabajos de AWS Glue 4.0 se ejecutarán con tiempos de inicio significativamente mejorados. Los trabajos de Spark se facturarán en incrementos de 1 segundo con una duración mínima de facturación 10 veces menor, porque la latencia de inicio pasará de un máximo de 10 minutos a un máximo de 1 minuto.
+ El comportamiento del registro cambió significativamente a partir de AWS Glue 4.0; Spark 3.3.0 tiene un requisito mínimo de Log4j2, como se menciona aquí (https://spark.apache.org/docs/latest/core-migration-guide.html\$1upgrading-from-core-32-to-33).
+ Varias actualizaciones de dependencias, que se destacan en el apéndice.
+ Scala también se actualiza a la versión 2.12 desde la 2.11, y Scala 2.12 no es compatible con Scala 2.11.
+ Python 3.10 es también la versión predeterminada utilizada para los scripts de Python, ya que AWS Glue 0.9 solo utilizaba Python 2.
+ Python 2.7 no es compatible con Spark 3.3.0. Cualquier trabajo que solicite Python 2 en la configuración del trabajo producirá un error con IllegalArgumentException.
+ Hay disponible un nuevo mecanismo para instalar módulos adicionales de Python mediante pip.
+ AWS Glue 4.0 no se ejecuta en Apache YARN, por lo que la configuración de YARN no se aplica.
+ AWS Glue 4.0 no tiene un Sistema de archivos distribuido de Hadoop (HDFS).
+ Cualquier archivo JAR adicional suministrado en trabajos existentes de AWS Glue 0.9 puede traer dependencias conflictivas, ya que hubo actualizaciones en varias dependencias en la versión 3.0 con respecto a la 0.9. Puede evitar conflictos de classpath en AWS Glue 3.0 con el parámetro de trabajo `--user-jars-first` de AWS Glue.
+ AWS Glue 4.0 admite el escalado automático. Por lo tanto, la métrica ExecutorAllocationManager estará disponible cuando se habilite el escalado automático.
+ Para trabajos de la versión 4.0 de AWS Glue, debe especificar el número de procesos de trabajo y el tipo de proceso de trabajo, pero no un valor de `maxCapacity`.
+ AWS GlueLos trabajos de 4.0 todavía no admiten transformaciones de machine learning.
+ Para migrar determinados conectores, consulte [Migración de conectores y controladores JDBC para AWS Glue 4.0](#migrating-version-40-connector-driver-migration).
+ Se actualizó el SDK de cifrado de AWS de 1.x a 2.x. Se ven afectados los trabajos de AWS Glue que utilizan configuraciones de seguridad de AWS Glue y los trabajos que dependen de la dependencia del SDK de cifrado de AWS proporcionada en tiempo de ejecución. Consulte estas instrucciones para la migración de trabajos de AWS Glue.
+ No puede migrar ningún trabajo de AWS Glue 0.9 o 1.0 a un trabajo de AWS Glue 4.0 directamente. Esto se debe a que, al actualizar directamente a la versión 2.x o una posterior y habilitar todas las características nuevas de inmediato, el SDK de cifrado de AWS no podrá descifrar el texto cifrado en versiones anteriores del SDK de cifrado de AWS.
+ Para llevar a cabo la actualización de forma segura, primero le recomendamos que migre a un trabajo de AWS Glue 2.0 o 3.0 que contenga la versión puente del SDK de cifrado de AWS. Ejecute el trabajo una vez para utilizar la versión puente del SDK de cifrado de AWS.
+ Al finalizar, puede migrar de forma segura el trabajo de AWS Glue 2.0 o 3.0 a AWS Glue 4.0.
Consulte la documentación de migración de Spark:
+ [Upgrading from Spark SQL 2.2 to 2.3 (Actualización de Spark SQL 2.2 a 2.3](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-22-to-23)
+ [Upgrading from Spark SQL 2.3 to 2.4 (Actualización de Spark SQL 2.3 a 2.4](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-23-to-24)
+ [Upgrading from Spark SQL 2.4 to 3.0 (Actualización de Spark SQL 2.4 a 3.0](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-24-to-30)
+ [Upgrading from Spark SQL 3.0 to 3.1 (Actualización de Spark SQL 3.0 a 3.1](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-30-to-31)
+ [Upgrading from Spark SQL 3.1 to 3.2 (Actualización de Spark SQL 3.1 a 3.2](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-31-to-32)
+ [Upgrading from Spark SQL 3.2 to 3.3 (Actualización de Spark SQL 3.2 a 3.3](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-32-to-33)
+ [Changes in Datetime behavior to be expected since Spark 3.0 (Cambios en el comportamiento de Datetime que se esperan a partir de Spark 3.0](https://issues.apache.org/jira/browse/SPARK-31408).
## Migración de conectores y controladores JDBC para AWS Glue 4.0
Para ver las versiones de los conectores de lago de datos y JDBC que se actualizaron, consulte:
+ [Apéndice B: actualizaciones de controladores JDBC](#migrating-version-40-appendix-jdbc-driver)
+ [Apéndice C: actualizaciones del conector](#migrating-version-40-appendix-connector)
### Hudi
+ Mejoras de compatibilidad de Spark SQL:
+ A través del comando `Call Procedure`, se agrega compatibilidad para actualizar, degradar, arrancar, limpiar y reparar. La sintaxis `Create/Drop/Show/Refresh Index` es posible en Spark SQL.
+ Se cerró una laguna de rendimiento entre el uso mediante un DataSource de Spark en comparación con Spark SQL. En el pasado, las escrituras en orígenes de datos solían ser más rápidas que en SQL.
+ Todos los generadores de claves integrados implementan operaciones de API específicas de Spark de mayor rendimiento.
+ Se sustituyó la transformación de UDF en la operación masiva `insert` por transformaciones de RDD para reducir los costos de uso de SerDe.
+ Spark SQL con Hudi requiere que se especifique un campo `primaryKey` mediante `tblproperites` u opciones en la instrucción SQL. En el caso de las operaciones de actualización y eliminación, también se requiere el campo `preCombineField`.
+ Cualquier tabla de Hudi creada antes de la versión 0.10.0 sin un campo `primaryKey` tiene que volver a crearse con un campo `primaryKey` a partir de la versión 0.10.0.
### PostgreSQL
+ Se corrigieron varias vulnerabilidades (CVE).
+ Java 8 es compatible de forma nativa.
+ Si el trabajo utiliza matrices de matrices, con la excepción de las matrices de bytes, dicho escenario se puede tratar como matrices multidimensionales.
### MongoDB
+ El conector de MongoDB actual es compatible con la versión 3.1 o posteriores de Spark y con la versión 4.0 o posteriores de MongoDB.
+ Debido a la actualización del conector, se modificaron los nombres de algunas propiedades. Por ejemplo, el nombre de la propiedad de URI se cambió a `connection.uri`. Para obtener más información sobre las opciones actuales, consulte el [blog sobre el conector de Spark de MongoDB](https://www.mongodb.com/docs/spark-connector/current/configuration/).
+ El uso de la versión 4.0 de MongoDB alojada por Amazon DocumentDB presenta algunas diferencias funcionales. Para obtener más información, consulte estos temas:
+ [Functional Differences: Amazon DocumentDB and MongoDB (Diferencias funcionales: Amazon DocumentDB y MongoDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/functional-differences.html)
+ [API, operaciones y tipos de datos de MongoDB compatibles](https://docs.aws.amazon.com/documentdb/latest/developerguide/mongo-apis.html).
+ La opción “partitioner” se restringe a `ShardedPartitioner`, `PaginateIntoPartitionsPartitioner` y `SinglePartitionPartitioner`. No puede usar los valores predeterminados `SamplePartitioner` y `PaginateBySizePartitioner` para Amazon DocumentDB porque el operador de etapas no admite la API de MongoDB. Para obtener más información, consulte [Supported MongoDB APIs, Operations, and Data Types](https://docs.aws.amazon.com/documentdb/latest/developerguide/mongo-apis.html) (API, operaciones y tipos de datos de MongoDB admitidos).
### Delta Lake
+ Delta Lake ahora admite [viajes en el tiempo en SQL](https://docs.delta.io/2.1.0/delta-batch.html#query-an-older-snapshot-of-a-table-time-travel) para consultar datos antiguos con facilidad. Con esta actualización, los viajes en el tiempo ahora están disponibles tanto en Spark SQL como a través de la API de DataFrame. Se agregó compatibilidad con la versión actual de TIMESTAMP en SQL.
+ Spark 3.3 presenta [Trigger.AvailableNow](https://issues.apache.org/jira/browse/SPARK-36533) para ejecutar consultas de transmisión como equivalente a `Trigger.Once` para las consultas por lotes. Esta compatibilidad también está disponible cuando se utilizan tablas Delta como origen de transmisión.
+ Compatibilidad con SHOW COLUMNS para devolver la lista de columnas de una tabla.
+ Compatibilidad con [DESCRIBE DETAIL](https://docs.delta.io/2.1.0/delta-utility.html#retrieve-delta-table-details) en la API de DeltaTable de Python y Scala. Recupera información detallada sobre una tabla Delta mediante la API de DeltaTable o Spark SQL.
+ Compatibilidad para devolver métricas de operaciones de los comandos [Delete](https://github.com/delta-io/delta/pull/1328), [Merge](https://github.com/delta-io/delta/pull/1327) y [Update](https://github.com/delta-io/delta/pull/1331) de SQL. Anteriormente, estos comandos de SQL devolvían un DataFrame vacío y ahora devuelven un DataFrame con métricas útiles sobre la operación hecha.
+ Optimice las mejoras de rendimiento:
+ Defina la opción de configuración `spark.databricks.delta.optimize.repartition.enabled=true` para usar `repartition(1)` en lugar de `coalesce(1)` en el comando Optimize para obtener un mejor rendimiento al compactar muchos archivos pequeños.
+ [Rendimiento mejorado](https://github.com/delta-io/delta/pull/1315) mediante el uso de un enfoque basado en colas para paralelizar los trabajos de compactación.
+ Otros cambios notables:
+ [Compatibilidad con el uso de variables](https://github.com/delta-io/delta/issues/1267) en los comandos de SQL VACUUM y OPTIMIZE.
+ Mejoras para CONVERT TO DELTA con tablas de catálogo que incluyen lo siguiente:
+ [Rellenado automático del esquema de particiones](https://github.com/delta-io/delta/commit/18d4d12ed06f973006501f6c39c8785db51e2b1f) a partir del catálogo cuando no se proporciona.
+ [Uso de la información de particiones](https://github.com/delta-io/delta/commit/ebff29904f3ababb889897343f8f8f7a010a1f71) del catálogo para buscar los archivos de datos que se van a confirmar en lugar de analizar el directorio por completo. En lugar de enviar todos los archivos de datos del directorio de tablas, solo se confirmarán los archivos de datos de los directorios de las particiones activas.
+ [Compatibilidad con las lecturas por lotes de cambio de fuente de datos (CDF)](https://github.com/delta-io/delta/issues/1349) en las tablas habilitadas para la asignación de columnas cuando no se utilizaron DROP COLUMN y RENAME COLUMN. Para obtener más información, consulte la [documentación de Delta Lake](https://docs.delta.io/2.1.0/delta-change-data-feed.html#known-limitations).
+ [Mejora del rendimiento del comando Update](https://github.com/delta-io/delta/pull/1202) al habilitar la eliminación de esquemas en la primera aprobación.
### Apache Iceberg
+ Se agregaron varias [mejoras de rendimiento](https://iceberg.apache.org/releases/#performance-improvements) para la planificación de análisis y las consultas de Spark.
+ Se agregó un cliente de catálogo REST común que usa confirmaciones basadas en cambios para resolver conflictos de confirmación en el lado del servicio.
+ Se admite la sintaxis `AS OF` para las consultas de viajes en el tiempo de SQL.
+ Se agregó compatibilidad de combinación en lectura para las consultas MERGE y UPDATE.
+ Se agregó compatibilidad para reescribir particiones con el orden Z.
+ Se agregaron una especificación y una implementación para Puffin, un formato para estadísticas y blobs de índice grandes, como [bocetos de Theta](https://datasketches.apache.org/docs/Theta/InverseEstimate.html) o filtros de Bloom.
+ Se agregaron nuevas interfaces para consumir datos de forma incremental (análisis de registros de cambios y anexos).
+ Se agregó compatibilidad con operaciones masivas y lecturas por intervalos en las interfaces de FileIO.
+ Se agregaron más tablas de metadatos para mostrar los archivos eliminados en el árbol de metadatos.
+ El comportamiento de eliminación de tabla cambió. En Iceberg 0.13.1, la ejecución de `DROP TABLE` elimina la tabla del catálogo, así como su contenido. En Iceberg 1.0.0, `DROP TABLE` solo elimina la tabla del catálogo. Para eliminar el contenido de la tabla, utilice `DROP TABLE PURGE`.
+ Las lecturas vectorizadas de Parquet están habilitadas de forma predeterminada en Iceberg 1.0.0. Si desea deshabilitar las lecturas vectorizadas, establezca el valor de `read.parquet.vectorization.enabled` en `false`.
### Oracle
Se hicieron pequeños cambios.
### MySQL
Se hicieron pequeños cambios.
### Amazon Redshift
AWS Glue 4.0 incluye un nuevo conector de Amazon Redshift con un nuevo controlador JDBC. Para obtener información sobre las mejoras y sobre cómo llevar a cabo la migración desde versiones anteriores de AWS Glue, consulte [Conexiones Redshift](aws-glue-programming-etl-connect-redshift-home.md).
## Apéndice A: actualizaciones de dependencias importantes
Las siguientes son las actualizaciones de dependencias:
| Dependencia | Versión en AWS Glue 4.0 | Versión en AWS Glue 3.0 | Versión en AWS Glue 2.0 | Versión en AWS Glue 1.0 |
| --- | --- | --- | --- | --- |
| Spark | 3.3.0-amzn-1 | 3.1.1-amzn-0 | 2.4.3 | 2.4.3 |
| Hadoop | 3.3.3-amzn-0 | 3.2.1-amzn-3 | 2.8.5-amzn-5 | 2.8.5-amzn-1 |
| Scala | 2.12 | 2.12 | 2.11 | 2.11 |
| Jackson | 2.13.3 | 2.10.x | 2.7.x | 2.7.x |
| Hive | 2.3.9-amzn-2 | 2.3.7-amzn-4 | 1.2 | 1.2 |
| EMRFS | 2.54.0 | 2.46.0 | 2.38.0 | 2.30.0 |
| Json4s | 3.7.0-M11 | 3.6.6 | 3.5.x | 3.5.x |
| Arrow | 7.0.0 | 2.0.0 | 0.10.0 | 0.10.0 |
| AWS GlueCliente del Catálogo de datos de | 3.7.0 | 3.0.0 | 1.10.0 | N/A |
| Python | 3.10 | 3.7 | 2.7 y 3.6 | 2.7 y 3.6 |
| Boto | 1.26 | 1.18 | 1.12 | N/A |
## Apéndice B: actualizaciones de controladores JDBC
Las siguientes son las actualizaciones de controladores JDBC:
| Controlador | Versión del controlador JDBC en las versiones de AWS Glue anteriores | Versión del controlador JDBC en AWS Glue 3.0 | Versión del controlador JDBC en AWS Glue 4.0 |
| --- | --- | --- | --- |
| MySQL | 5.1 | 8.0.23 | 8.0.23 |
| Microsoft SQL Server | 6.1.0 | 7.0.0 | 9.4.0 |
| Oracle Database | 11.2 | 21.1 | 21.7 |
| PostgreSQL | 42.1.0 | 42.2.18 | 42.3.6 |
| MongoDB | 2.0.0 | 4.0.0 | 4.7.2 |
| Amazon Redshift | redshift-jdbc41-1.2.12.1017 | redshift-jdbc41-1.2.12.1017 | redshift-jdbc42-2.1.0.16 |
## Apéndice C: actualizaciones del conector
A continuación se indican las actualizaciones del conector:
| Controlador | Versión del conector en AWS Glue 3.0 | Versión del conector en AWS Glue 4.0 |
| --- | --- | --- |
| MongoDB | 3.0.0 | 10.0.4 |
| Hudi | 0.10.1 | 0.12.1 |
| Delta Lake | 1.0.0 | 2.1.0 |
| Iceberg | 0.13.1 | 1.0.0 |
| DynamoDB | 1.11 | 1.12 |
# Actualizaciones de IA generativa para Apache Spark en AWS Glue
La función Actualizaciones de Spark en AWS Glue permite que los ingenieros de datos y desarrolladores actualicen y migren sus trabajos actuales de Spark de AWS Glue a las versiones más recientes de Spark mediante la IA generativa. Los ingenieros de datos pueden utilizarla para escanear sus trabajos de Spark de AWS Glue, generar planes de actualización, ejecutar planes y validar los resultados. Reduce el tiempo y el costo de las actualizaciones de Spark al automatizar el trabajo indiferenciado de identificar y actualizar los scripts, las configuraciones, las dependencias, los métodos y las características de Spark.
![\[El GIF muestra una implementación integral de un ejemplo de flujo de trabajo de análisis de actualizaciones.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/demo_lumos.gif)
## Funcionamiento
Cuando utiliza el análisis de actualizaciones, AWS Glue identifica las diferencias entre las versiones y las configuraciones en el código del trabajo para generar un plan de actualización. El plan de actualización detalla todos los cambios de código y los pasos de migración necesarios. A continuación, AWS Glue crea y ejecuta la aplicación actualizada en un entorno para validar los cambios y genera una lista de cambios de código para que pueda migrar el trabajo. Puede ver el script actualizado junto con el resumen que detalla los cambios propuestos. Tras ejecutar pruebas propias, acepte los cambios y el trabajo de AWS Glue se actualizará automáticamente a la última versión con el nuevo script.
El proceso de análisis de la actualización puede tardar un tiempo en completarse, en función de la complejidad del trabajo y la carga de trabajo. Los resultados del análisis de la actualización se almacenarán en la ruta de Amazon S3 especificada, que se puede revisar para comprender la actualización y cualquier posible problema de compatibilidad. Tras revisar los resultados del análisis de la actualización, puede decidir si desea continuar con la actualización propiamente dicha o hacer los cambios necesarios en el trabajo antes de la actualización.
## Requisitos previos
Estos son los requisitos previos necesarios para utilizar la IA generativa para actualizar trabajos en AWS Glue:
+ Trabajos de PySpark de AWS Glue 2: solo los trabajos de AWS Glue 2 se pueden actualizar a AWS Glue 5.
+ Se necesitan permisos de IAM para iniciar el análisis, revisar los resultados y actualizar el trabajo. Para obtener más información, consulte los ejemplos de la sección [Permisos](#auto-upgrade-permissions) a continuación.
+ Si se utiliza AWS KMS para cifrar artefactos de análisis, se necesitan permisos adicionales de AWS AWS KMS. Para obtener más información, consulte los ejemplos de la sección [AWS KMSPolítica de](#auto-upgrade-kms-policy) a continuación.
### Permisos
#### Para iniciar un nuevo análisis de actualización, necesita los siguientes permisos:
1. Actualice la política de IAM del intermediario con el siguiente permiso:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:StartJobUpgradeAnalysis",
"glue:StartJobRun",
"glue:GetJobRun",
"glue:GetJob",
"glue:BatchStopJobRun"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:job/jobName"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/script-location/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/results/*"
]
},
{
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey"
],
"Resource": "arn:aws:kms:us-east-1:111122223333:key/key-id"
}
]
}
```
------
1. Actualice el rol de ejecución del trabajo que vaya a actualizar para incluir la siguiente política en línea:
```
{
"Effect": "Allow",
"Action": ["s3:GetObject"],
"Resource": [
"ARN of the Amazon S3 path provided on API",
"ARN of the Amazon S3 path provided on API/*"
]
}
```
Por ejemplo, si utiliza la ruta de Amazon S3 `s3://amzn-s3-demo-bucket/upgraded-result`, la política será:
```
{
"Effect": "Allow",
"Action": ["s3:GetObject"],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/upgraded-result/",
"arn:aws:s3:::amzn-s3-demo-bucket/upgraded-result/*"
]
}
```
#### Para recuperar los detalles de un análisis, necesita los siguientes permisos:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetJobUpgradeAnalysis"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:job/jobName"
]
}
]
}
```
------
#### Para detener un análisis en curso, necesita los siguientes permisos:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:StopJobUpgradeAnalysis",
"glue:BatchStopJobRun"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:job/jobName"
]
}
]
}
```
------
#### Para mostrar todos los análisis enviados en relación con un trabajo específico, necesita los siguientes permisos:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:ListJobUpgradeAnalyses"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:job/jobName"
]
}
]
}
```
------
#### Para aceptar los cambios de un análisis y actualizar un trabajo, necesita los siguientes permisos:
### AWS KMSPolítica de
Para transferir su propia clave personalizada de AWS KMS al iniciar un análisis, consulte la siguiente sección para configurar los permisos adecuados para las claves de AWS KMS.
#### Configuración del cifrado del artefacto resultante mediante una clave de AWS KMS:
Esta política garantiza que tiene los permisos de cifrado y descifrado de la clave de AWS KMS.
```
{
"Effect": "Allow",
"Principal":{
"AWS": ""
},
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey",
],
"Resource": ""
}
```
## Ejecución de un análisis de actualización y aplicación del script de actualización
Puede ejecutar un análisis de actualización, que generará un plan de actualización para un trabajo que seleccione en la vista **Trabajos**.
1. En **Trabajos**, seleccione un trabajo de AWS Glue 2.0 y, a continuación, elija **Ejecutar análisis de actualización** en el menú **Acciones**.
![\[La captura de pantalla muestra el análisis de actualizaciones con IA desde el menú de acciones.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/upgrade-analysis-run-action-menu.png)
1. En el modal, seleccione una ruta para almacenar el plan de mejoras generado en **Ruta de resultados**. Debe ser un bucket de Amazon S3 al que pueda acceder y en el que pueda escribir.
![\[En la captura de pantalla se muestra el análisis de actualización completado. Se puede visualizar el botón Aplicar el script actualizado.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/upgrade-analysis-configuration-options.png)
1. Configure las opciones adicionales si es necesario:
+ **Configuración de ejecución**: (opcional): la configuración de ejecución es una configuración opcional que permite personalizar varios aspectos de las ejecuciones de validación hechas durante el análisis de la actualización. Esta configuración se utiliza para ejecutar el script actualizado y permite seleccionar las propiedades del entorno de computación (tipo de proceso de trabajo, número de procesos de trabajo, etc.). Tenga en cuenta que debe utilizar sus cuentas de desarrollador ajenas a la producción para hacer las validaciones de los conjuntos de datos de muestra antes de revisar, aceptar los cambios y aplicarlos a los entornos de producción. La configuración de ejecución incluye los siguientes parámetros personalizables:
+ Tipo de trabajador: puede especificar el tipo de trabajador que se utilizará en las ejecuciones de validación, lo que le permitirá elegir los recursos de computación adecuados en función de sus requisitos.
+ Número de trabajadores: puede definir el número de procesos de trabajo que se van a aprovisionar para las ejecuciones de validación, lo que le permite escalar los recursos en función de sus necesidades de carga de trabajo.
+ Tiempo de espera del trabajo (en minutos): este parámetro le permite establecer un límite de tiempo para las ejecuciones de validación, lo que garantiza que los trabajos finalicen después de un periodo específico para evitar un consumo excesivo de recursos.
+ Configuración de seguridad: puede configurar los parámetros de seguridad, como el cifrado y el control de acceso, para garantizar la protección de los datos y los recursos durante las ejecuciones de validación.
+ Parámetros de trabajo adicionales: si es necesario, puede agregar nuevos parámetros de trabajo para personalizar aún más el entorno de ejecución de las ejecuciones de validación.
Al aprovechar la configuración de las ejecuciones, puede personalizar las ejecuciones de validación para que se adapten a sus requisitos específicos. Por ejemplo, puede configurar las ejecuciones de validación para usar un conjunto de datos más pequeño, lo que permite que el análisis se complete más rápidamente y optimiza los costos. Este enfoque garantiza que el análisis de actualización se haga de manera eficiente y, al mismo tiempo, minimiza la utilización de los recursos y los costos asociados durante la fase de validación.
+ **Configuración de cifrado** (opcional):
+ **Habilitar el cifrado de los artefactos de actualización**: habilite el cifrado en reposo al escribir los datos en la ruta de resultados. Si no quiere cifrar los artefactos de actualización, deje esta opción sin marcar.
1. Seleccione **Ejecutar** para iniciar el análisis de la actualización. Mientras se ejecuta el análisis, puede ver los resultados en la pestaña **Análisis de actualización**. La ventana de detalles del análisis le mostrará información sobre el análisis, así como enlaces a los artefactos de la actualización.
+ **Ruta de resultados**: aquí es donde se almacenan el resumen de los resultados y el script de actualización.
+ **Script actualizado en Amazon S3**: ubicación del script de actualización en Amazon S3. Puede ver el script antes de aplicar la actualización.
+ **Resumen de la actualización en Amazon S3**: la ubicación del resumen de la actualización en Amazon S3. Puede ver el resumen de la actualización antes de aplicarla.
1. Cuando el análisis de actualización se haya completado correctamente, puede aplicar el script de actualización para actualizar automáticamente el trabajo mediante la selección de la opción **Aplicar el script actualizado**.
Una vez aplicada, la versión de AWS Glue se actualizará a la versión 4.0. Puede ver el nuevo script en la pestaña **Script**.
![\[En la captura de pantalla se muestra el análisis de actualización completado. Se puede visualizar el botón Aplicar el script actualizado.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/upgrade-analysis-analysis-details-preview.png)
## Descripción del resumen de la actualización
En este ejemplo, se muestra el proceso de actualización de un trabajo de AWS Glue de la versión 2.0 a la versión 4.0. El trabajo de muestra lee los datos del producto de un bucket de Amazon S3, aplica varias transformaciones a los datos mediante Spark SQL y, a continuación, guarda los resultados transformados en un bucket de Amazon S3.
### Código original (AWS Glue 2.0): antes de la actualización
```
from awsglue.transforms import *
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from pyspark.sql.types import *
from pyspark.sql.functions import *
from awsglue.job import Job
import json
from pyspark.sql.types import StructType
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
gdc_database = "s3://aws-glue-scripts-us-east-1-gamma/demo-database/"
schema_location = (
"s3://aws-glue-scripts-us-east-1-gamma/DataFiles/"
)
products_schema_string = spark.read.text(
f"{schema_location}schemas/products_schema"
).first()[0]
product_schema = StructType.fromJson(json.loads(products_schema_string))
products_source_df = (
spark.read.option("header", "true")
.schema(product_schema)
.option(
"path",
f"{gdc_database}products/",
)
.csv(f"{gdc_database}products/")
)
products_source_df.show()
products_temp_view_name = "spark_upgrade_demo_product_view"
products_source_df.createOrReplaceTempView(products_temp_view_name)
query = f"select {products_temp_view_name}.*, format_string('%0$s-%0$s', category, subcategory) as unique_category from {products_temp_view_name}"
products_with_combination_df = spark.sql(query)
products_with_combination_df.show()
products_with_combination_df.createOrReplaceTempView(products_temp_view_name)
product_df_attribution = spark.sql(
f"""
SELECT *,
unbase64(split(product_name, ' ')[0]) as product_name_decoded,
unbase64(split(unique_category, '-')[1]) as subcategory_decoded
FROM {products_temp_view_name}
"""
)
product_df_attribution.show()
product_df_attribution.write.mode("overwrite").option("header", "true").option(
"path", f"{gdc_database}spark_upgrade_demo_product_agg/"
).saveAsTable("spark_upgrade_demo_product_agg", external=True)
spark_upgrade_demo_product_agg_table_df = spark.sql(
f"SHOW TABLE EXTENDED in default like 'spark_upgrade_demo_product_agg'"
)
spark_upgrade_demo_product_agg_table_df.show()
job.commit()
```
### Código nuevo (Glue 4.0): tras la actualización
```
from awsglue.transforms import *
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from pyspark.sql.types import *
from pyspark.sql.functions import *
from awsglue.job import Job
import json
from pyspark.sql.types import StructType
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
# change 1
spark.conf.set("spark.sql.adaptive.enabled", "false")
# change 2
spark.conf.set("spark.sql.legacy.pathOptionBehavior.enabled", "true")
job = Job(glueContext)
gdc_database = "s3://aws-glue-scripts-us-east-1-gamma/demo-database/"
schema_location = (
"s3://aws-glue-scripts-us-east-1-gamma/DataFiles/"
)
products_schema_string = spark.read.text(
f"{schema_location}schemas/products_schema"
).first()[0]
product_schema = StructType.fromJson(json.loads(products_schema_string))
products_source_df = (
spark.read.option("header", "true")
.schema(product_schema)
.option(
"path",
f"{gdc_database}products/",
)
.csv(f"{gdc_database}products/")
)
products_source_df.show()
products_temp_view_name = "spark_upgrade_demo_product_view"
products_source_df.createOrReplaceTempView(products_temp_view_name)
# change 3
query = f"select {products_temp_view_name}.*, format_string('%1$s-%1$s', category, subcategory) as unique_category from {products_temp_view_name}"
products_with_combination_df = spark.sql(query)
products_with_combination_df.show()
products_with_combination_df.createOrReplaceTempView(products_temp_view_name)
# change 4
product_df_attribution = spark.sql(
f"""
SELECT *,
try_to_binary(split(product_name, ' ')[0], 'base64') as product_name_decoded,
try_to_binary(split(unique_category, '-')[1], 'base64') as subcategory_decoded
FROM {products_temp_view_name}
"""
)
product_df_attribution.show()
product_df_attribution.write.mode("overwrite").option("header", "true").option(
"path", f"{gdc_database}spark_upgrade_demo_product_agg/"
).saveAsTable("spark_upgrade_demo_product_agg", external=True)
spark_upgrade_demo_product_agg_table_df = spark.sql(
f"SHOW TABLE EXTENDED in default like 'spark_upgrade_demo_product_agg'"
)
spark_upgrade_demo_product_agg_table_df.show()
job.commit()
```
### Explicación del resumen del análisis
![\[En la captura de pantalla se muestra el resumen del análisis de la actualización.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/upgrade-analysis-explanation-summary.png)
Según el resumen, hay cuatro cambios propuestos por AWS Glue para actualizar correctamente el script de AWS Glue 2.0 a AWS Glue 4.0:
1. **Configuración de Spark SQL (spark.sql.adaptive.enabled)**: este cambio tiene por objeto restaurar el comportamiento de la aplicación. A partir de Spark 3.2, se ha introducido una nueva característica para la ejecución adaptativa de consultas de Spark SQL. Puede inspeccionar este cambio de configuración y habilitarlo o deshabilitarlo según sus preferencias.
1. **Cambio de la API de DataFrame**: la opción de ruta no puede coexistir con otras operaciones de DataFrameReader como `load()`. Para retener el comportamiento anterior, AWS Glue actualizó el script para agregar una nueva configuración de SQL **(spark.sql.legacy.pathOptionBehavior.enabled)**.
1. **Cambio de la API de Spark SQL**: se ha actualizado el comportamiento de `strfmt` en `format_string(strfmt, obj, ...)` para que no se permita `0$` como primer argumento. Para garantizar la compatibilidad, AWS Glue ha modificado el script para usar `1$` como primer argumento.
1. **Cambio de la API de SQL de Spark**: la función `unbase64` no permite ingresar cadenas mal formadas. Para retener el comportamiento anterior, AWS Glue actualizó el script para usar la función `try_to_binary`.
## Detención de un análisis de actualización en curso
Puede cancelar un análisis de actualización en curso o simplemente detenerlo.
1. Elija la pestaña **Análisis de actualizaciones**.
1. Seleccione el trabajo que se está ejecutando y, a continuación, elija **Detener**. Esto detendrá el análisis. A continuación, puede ejecutar otro análisis de actualizaciones en el mismo trabajo.
![\[La captura de pantalla muestra la pestaña Análisis de actualizaciones con un trabajo seleccionado. El trabajo se sigue ejecutando.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/upgrade-analysis-tab.png)
## Consideraciones
Al comenzar a usar las actualizaciones de Spark, hay varios aspectos importantes que debe tener en cuenta para un uso óptimo del servicio.
+ **Alcance y limitaciones del servicio**: la versión actual se centra en la actualización de código PySpark desde la versión 2.0 hasta la versión 5.0 de AWS Glue. En este momento, el servicio gestiona el código de PySpark que no depende de dependencias de biblioteca adicionales. Puede ejecutar actualizaciones automatizadas de hasta 10 trabajos simultáneamente en una cuenta de AWS, lo que le permite actualizar varios trabajos de manera eficiente y, al mismo tiempo, mantener la estabilidad del sistema.
+ Solo se admiten trabajos de PySpark.
+ El tiempo de espera del análisis de actualizaciones se agota después de 24 horas.
+ Solo se puede ejecutar un análisis de actualización activo a la vez para un trabajo. Se pueden ejecutar hasta 10 análisis de actualización activos a la vez por cuenta.
+ **Optimización de los costos durante el proceso de actualización**: dado que las actualizaciones de Spark utilizan IA generativa para validar el plan de actualización en varias iteraciones, y cada iteración se ejecuta como una tarea de AWS Glue en su cuenta, es esencial optimizar las configuraciones de ejecución de las tareas de validación para lograr una mayor rentabilidad. Para lograrlo, le recomendamos que especifique una configuración de ejecución al iniciar un análisis de actualización de la siguiente manera:
+ Utilice cuentas de desarrolladores que no sean de producción y seleccione conjuntos de datos simulados de muestra que representen los datos de producción, pero que sean más pequeños para validarlos con la función Actualizaciones de Spark.
+ Utilice recursos de computación del tamaño adecuado, como los trabajadores de G.1X, y seleccione un número adecuado de procesos de trabajo para procesar los datos de la muestra.
+ Habilite el escalado automático de los trabajos de AWS Glue cuando sea aplicable para ajustar automáticamente los recursos en función de la carga de trabajo.
Por ejemplo, si el trabajo de producción procesa terabytes de datos con 20 procesos de trabajo de G.2X, puede configurar el trabajo de actualización para procesar unos pocos gigabytes de datos representativos con 2 procesos de trabajo de G.2X y activar el escalado automático para la validación.
+ **Prácticas recomendadas**: se recomienda iniciar el proceso de actualización con trabajos que no estén en producción. Este enfoque le permite familiarizarse con el flujo de trabajo de actualización y entender cómo el servicio gestiona los distintos tipos de patrones de código de Spark.
+ **Alarmas y notificaciones**: cuando utilice la característica de actualizaciones con IA generativa en un trabajo, asegúrese de que estén desactivadas las alarmas o notificaciones en caso de ejecución con errores de un trabajo. Durante el proceso de actualización, es posible que se produzcan errores al ejecutar hasta 10 trabajos en su cuenta antes de que se proporcionen los artefactos actualizados.
+ **Reglas de detección de anomalías**: desactive también las reglas de detección de anomalías en el trabajo que se está actualizando, ya que los datos escritos en las carpetas de salida durante las ejecuciones intermedias del trabajo podrían no tener el formato esperado mientras la validación de la actualización se encuentra en curso.
+ **Utilice el análisis de actualización con trabajos de idempotencia**: utilice el análisis de actualización con trabajos de idempotencia para garantizar que cada intento de ejecución posterior de un trabajo de validación sea similar al anterior y no presente problemas. Los trabajos de idempotencia son trabajos que se pueden ejecutar varias veces con los mismos datos de entrada y que producirán el mismo resultado cada vez. Cuando se utilicen las actualizaciones de IA generativa para Apache Spark en AWS Glue, el servicio ejecutará varias iteraciones de su trabajo como parte del proceso de validación. Durante cada iteración, realizará cambios en el código y las configuraciones de Spark para validar el plan de actualización. Si su trabajo de Spark no es de idempotencia, ejecutarlo varias veces con los mismos datos de entrada podría provocar problemas.
## Regiones admitidas
Las actualizaciones con IA generativa para Apache Spark están disponibles en las siguientes regiones:
+ **Asia-Pacífico**: Tokio (ap-northeast-1), Seúl (ap-northeast-2), Mumbai (ap-south-1), Singapur (ap-southeast-1) y Sídney (ap-southeast-2)
+ **América del Norte**: Canadá (ca-central-1)
+ **Europa**: Fráncfort (eu-central-1), Estocolmo (eu-north-1), Irlanda (eu-west-1), Londres (eu-west-2) y París (eu-west-3)
+ **América del Sur**: São Paulo (sa-east-1)
+ **Estados Unidos**: norte de Virginia (us-east-1), Ohio (us-east-2) y Oregón (us-west-2)
## Inferencia entre regiones en Spark Upgrades
Spark Upgrades funciona con Amazon Bedrock y aprovecha la inferencia entre regiones (CRIS). Con CRIS, Spark Upgrades seleccionará automáticamente la región óptima de su zona geográfica (tal y como se describe con más detalle [aquí](https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html)) para procesar su solicitud de inferencia, maximizar los recursos de computación disponibles y la disponibilidad del modelo, además de ofrecer la mejor experiencia al cliente. El uso de la inferencia entre regiones no conlleva ningún costo adicional.
Las solicitudes de inferencia entre regiones se mantienen dentro de las regiones de AWS que forman parte de la zona geográfica en la que se encuentran originalmente los datos. Por ejemplo, una solicitud realizada en EE. UU. se mantiene dentro de las regiones de AWS de EE. UU. Si bien los datos solo permanecen almacenados en la región principal, cuando utiliza la inferencia entre regiones, las peticiones de entrada y los resultados de salida pueden llevarse fuera de la región principal. Todos los datos se transmitirán cifrados a través de la red segura de Amazon.
# Trabajar con trabajos de Spark en AWS Glue
Proporciona información sobre los trabajos de ETL de AWS Glue para Spark.
**Topics**
+ [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md)
+ [Trabajos de Spark y PySpark de AWS Glue](spark_and_pyspark.md)
+ [Tipos de trabajadores de AWS Glue](worker-types.md)
+ [Trabajos ETL de streaming en AWS Glue](add-job-streaming.md)
+ [Coincidencia de registros con FindMatches de AWS Lake Formation](machine-learning.md)
+ [Migrar programas de Apache Spark a AWS Glue](glue-author-migrate-apache-spark.md)
# Uso de los parámetros de trabajo en los trabajos de AWS Glue
Al crear un trabajo de Glue AWS, establece algunos campos estándar, como `Role` y`WorkerType`. Puede proporcionar información de configuración adicional a través de los campos `Argument` (**Parámetros del trabajo** en la consola). En estos campos, puede proporcionar los trabajos de Glue AWS con los argumentos (parámetros) que se enumeran en este tema.
Para obtener más información acerca de la API de trabajo de Glue AWS, consulte [Jobs](aws-glue-api-jobs-job.md).
**nota**
Los argumentos de trabajo tienen un límite de tamaño máximo de 260 KB. Una comprobación de validación generará un error si el tamaño del argumento es superior a 260 KB.
## Configuración de los parámetros del trabajo
Puede configurar un trabajo a través de la consola, en la pestaña **Job details** (Detalles del trabajo), en el encabezado **Job Parameters** (Parámetro del trabajo). Para configurar un trabajo a través de AWS CLI, establezca `DefaultArguments` o `NonOverridableArguments` en un trabajo, o `Arguments` en la ejecución de un trabajo. Los argumentos establecidos en el trabajo se pasarán cada vez que se ejecute el trabajo, mientras que los argumentos establecidos en la ejecución del trabajo solo se pasarán para esa ejecución individual.
Por ejemplo, a continuación se muestra la sintaxis para ejecutar un trabajo con `--arguments` para configurar un parámetro de trabajo.
```
$ aws glue start-job-run --job-name "CSV to CSV" --arguments='--scriptLocation="s3://my_glue/libraries/test_lib.py"'
```
## Acceder a los parámetros del trabajo
Al escribir scripts de Glue AWS, es posible que desee acceder a los valores de los parámetros del trabajo para modificar el comportamiento de su propio código. Proporcionamos métodos auxiliares para hacerlo en nuestras bibliotecas. Estos métodos resuelven los valores de los parámetros de ejecución del trabajo que anulan los valores de los parámetros del trabajo. Al resolver los parámetros establecidos en varios lugares, el trabajo `NonOverridableArguments` anulará el trabajo ejecutado `Arguments`, que anulará el trabajo `DefaultArguments`.
**En Python:**
En los trabajos de Python, proporcionamos una función llamada `getResolvedParameters`. Para obtener más información, consulte [Acceso a los parámetros mediante `getResolvedOptions`](aws-glue-api-crawler-pyspark-extensions-get-resolved-options.md). Los parámetros del trabajo están disponibles en la variable `sys.argv`.
**En Scala:**
En los trabajos de Scala, proporcionamos un objeto llamado `GlueArgParser`. Para obtener más información, consulte [AWS GlueAPI GlueArgParser Scala de](glue-etl-scala-apis-glue-util-glueargparser.md). Los parámetros del trabajo están disponibles en la variable `sysArgs`.
## Referencia de parámetros de trabajo
**AWS Glue reconoce los siguientes nombres de argumentos que se pueden utilizar para configurar el entorno de scripts para los trabajos y las ejecuciones de trabajos:**
**`--additional-python-modules`**
Lista delimitada por comas que representa un conjunto de paquetes de Python que se deben instalar. Puede instalar los paquetes desde PyPI o proporcionar una distribución personalizada. Una entrada de paquete de PyPI tendrá el formato `package==version`, con el nombre y la versión del paquete de destino de PyPI. Una entrada de distribución personalizada es la ruta de S3 a la distribución.
Las entradas utilizan la coincidencia de versiones de Python para hacer coincidir el paquete y la versión. Eso significa que tendrá que usar dos signos igual: `==`. Existen otros operadores de coincidencia de versiones; para obtener más información, consulte [PEP 440](https://peps.python.org/pep-0440/#version-matching).
Para pasar las opciones de instalación del módulo a `pip3`, utilice el parámetro [--python-modules-installer-option](#python-modules-installer-option).
**`--auto-scale-within-microbatch`**
El valor predeterminado es true. Este parámetro solo se puede usar para los trabajos de transmisión de Glue AWS, que procesan los datos de transmisión en una serie de microlotes y el escalado automático debe estar habilitado. Al establecer este valor en falso, calcula la media móvil exponencial de la duración del lote de los microlotes completados y lo compara con el tamaño de la ventana para determinar si se debe escalar verticalmente o reducir verticalmente el número de ejecutores. El escalado solo se produce cuando se completa un microlote. Al establecer este valor en verdadero, durante un microlote, escala verticalmente cuando el número de tareas de Spark permanece igual durante 30 segundos o cuando el procesamiento por lotes actual es superior al tamaño de la ventana. El número de ejecutores disminuirá si un ejecutor ha estado inactivo durante más de 60 segundos o si la media móvil exponencial de la duración del lote es baja.
**`--class`**
La clase de Scala que sirve de punto de entrada del script de Scala. Esto solo se aplica si `--job-language` está establecido en `scala`.
**`--continuous-log-conversionPattern`**
Especifica un patrón de registro de conversión personalizado para un trabajo habilitado para el registro continuo. El patrón de conversión solo se aplica a los registros de controlador y de ejecutor. No afecta la barra de progreso de AWS Glue.
**`--continuous-log-logGroup`**
Especifica el nombre de un grupo de registro personalizado de Amazon CloudWatch para un trabajo habilitado para el registro continuo.
**`--continuous-log-logStreamPrefix`**
Especifica el prefijo de un flujo de registro personalizado de CloudWatch para un trabajo habilitado para el registro continuo.
**`--customer-driver-env-vars` y `--customer-executor-env-vars`**
Estos parámetros establecen variables de entorno en sistemas operativos de manera respectiva para cada trabajador (controlador o ejecutor). Puede utilizar estos parámetros al crear plataformas o esquemas personalizados además de AWS Glue para permitir a los usuarios poder escribir por encima. Al activar estos dos marcadores, podrá establecer distintas variables de entorno para el controlador y para el ejecutor respectivamente sin tener que inyectar la misma lógica en el propio script del trabajo.
**Ejemplo de uso**
A continuación se muestra un ejemplo de la utilización de estos parámetros:
```
"—customer-driver-env-vars", "CUSTOMER_KEY1=VAL1,CUSTOMER_KEY2=\"val2,val2 val2\"",
"—customer-executor-env-vars", "CUSTOMER_KEY3=VAL3,KEY4=VAL4"
```
El establecimiento de estos en el argumento del trabajo equivale a la ejecución de los siguientes comandos:
En el controlador:
+ exportar CUSTOMER\$1KEY1=VAL1
+ exportar CUSTOMER\$1KEY2="val2,val2 val2"
En el ejecutor:
+ exportar CUSTOMER\$1KEY3=VAL3
Luego, en el propio script de trabajo, se pueden recuperar las variables de entorno con `os.environ.get("CUSTOMER_KEY1")` o `System.getenv("CUSTOMER_KEY1")`.
**Sintaxis de uso obligatorio**
Controle los siguientes estándares al definir las variables del entorno:
+ Cada clave debe contener el `CUSTOMER_ prefix`.
Por ejemplo: para `"CUSTOMER_KEY3=VAL3,KEY4=VAL4"`, se ignorará `KEY4=VAL4` y no se establecerá.
+ Cada par de clave y valor debe estar delimitado por una coma simple.
Por ejemplo: .: `"CUSTOMER_KEY3=VAL3,CUSTOMER_KEY4=VAL4"`
+ Si el valor contiene espacios o comas, debe encerrarse entre comillas.
Por ejemplo: .: `CUSTOMER_KEY2=\"val2,val2 val2\"`
Esta sintaxis modela con precisión los estándares de configuración de las variables de entorno de bash.
**`--datalake-formats` **
Es compatible con la versión 3.0 y posteriores de AWS Glue.
Especifica el marco de lago de datos que se va a utilizar. AWS Glue agrega los archivos JAR necesarios para los marcos que especifique en `classpath`. Para obtener más información, consulte [Uso de marcos de lagos de datos con trabajos de ETL de AWS Glue](aws-glue-programming-etl-datalake-native-frameworks.md).
Puede especificar uno o varios de los siguientes valores, separados por una coma:
+ `hudi`
+ `delta`
+ `iceberg`
Por ejemplo, pase el siguiente argumento para especificar los tres marcos.
```
'--datalake-formats': 'hudi,delta,iceberg'
```
**`--disable-proxy-v2`**
Deshabilita el proxy de servicio para permitir llamadas de servicio de AWS a Amazon S3, CloudWatch y AWS Glue originadas desde su script a través de la VPC. Para obtener más información, consulte [Configuración de las llamadas de AWS para que pasen a través de su VPC](https://docs.aws.amazon.com/glue/latest/dg/connection-VPC-disable-proxy.html). Para deshabilitar el proxy del servicio, defina el valor de este parámetro en `true`.
**`--enable-auto-scaling`**
Cuando este valor se configura en `true`, se activa el escalado automático y la facturación por proceso de trabajo.
**`--enable-continuous-cloudwatch-log`**
Permite un registro continuo en tiempo real de los trabajos de AWS Glue. Puede ver los registros de trabajos de Apache Spark en tiempo real en CloudWatch.
**`--enable-continuous-log-filter`**
Especifica un filtro estándar (`true`) o ningún filtro (`false`) al crear o editar un trabajo habilitado para el registro continuo. Si se elige Standard filter (Filtro estándar), se filtran los mensajes de registro de estado de Apache Hadoop YARN y de controlador/ejecutor de Apache Hadoop YARN no útiles. Si se elige sin filtro, se verán todos los mensajes de registro.
**`--enable-glue-datacatalog`**
Permite utilizar el Catálogo de datos de AWS Glue como metaalmacén de Apache Spark Hive. Para habilitar esta característica, establezca el valor como `true`.
**`--enable-job-insights`**
Permite la supervisión adicional del análisis de errores con la información de ejecución de trabajos de AWS Glue. Para obtener más información, consulte [Supervisión con Información de ejecuciones de trabajos de AWS Glue](monitor-job-insights.md). De forma predeterminada, el valor se establece en `true` y la información de ejecución de trabajos está habilitada.
Esta opción está disponible para AWS Glule versión 2.0 y 3.0.
**`--enable-lakeformation-fine-grained-access`**
Permite un control de acceso detallado para trabajos con AWS Glue. Para obtener más información, consulte [Uso de AWS Glue con AWS Lake Formation para obtener un control de acceso detallado](security-lf-enable.md).
**`--enable-metrics`**
Permite recopilar métricas para generar perfiles de trabajo en la ejecución de este trabajo. Estas métricas se encuentran disponibles en la consola de AWS Glue y en la consola de Amazon CloudWatch. El valor de este parámetro no es relevante. Para activar esta característica, puede proporcionar a este parámetro cualquier valor, pero se recomienda `true` para mayor claridad. Para deshabilitar esta característica, elimine este parámetro de la configuración de su trabajo.
**`--enable-observability-metrics`**
Permite un conjunto de métricas de observabilidad para generar información sobre lo que sucede dentro de cada trabajo que se ejecuta en la página Job Runs Monitoring en la consola AWS Glue y la consola Amazon CloudWatch. Para habilitar esta característica, establezca el valor como true (verdadero). Para deshabilitar esta característica, defínala en `false` o elimine este parámetro de la configuración de su trabajo.
**`--enable-rename-algorithm-v2`**
Establece la versión del algoritmo de cambio de nombre de EMRFS a la versión 2. Cuando un trabajo de Spark utiliza el modo de sobrescritura de partición dinámica, existe la posibilidad de que se cree una partición duplicada. Por ejemplo, puede tener como resultado una partición duplicada como `s3://bucket/table/location/p1=1/p1=1`. Aquí, P1 es la partición que se está sobrescribiendo. El algoritmo de cambio de nombre versión 2 corrige este problema.
La opción solo está disponible en la versión 1.0 de AWS Glue.
**`--enable-s3-parquet-optimized-committer`**
Habilita el confirmador optimizado para S3 de EMRFS de forma que puedan escribirse datos de Parquet en Amazon S3. Puede suministrar el par parámetro/valor a través de la consola de AWS Glue cuando cree o actualice un trabajo de AWS Glue. Al establecer el valor en **true**, se habilita el confirmador. De forma predeterminada, la marca está activada en AWS Glue 3.0 y desactivada en AWS Glue 2.0.
Para obtener más información, consulte este artículo sobre el [uso del confirmador optimizado para S3 de EMRFS](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-s3-optimized-committer.html).
**`--enable-spark-ui`**
Cuando se establece en `true`, activa la característica para usar la interfaz de usuario de Spark para monitorear y depurar trabajos de ETL de AWS Glue.
**`--executor-cores`**
Número de tareas de Spark que se pueden ejecutar en paralelo. Esta opción es compatible con Glue 3.0\$1 AWS. El valor no debe superar el doble de la cantidad de vCPU en el tipo de trabajador, es decir, 8 en `G.1X`, 16 en `G.2X`, 32 en `G.4X`, 64 en `G.8X`, 96 en `G.12X`, 128 en `G.16X`, y 8 en `R.1X`, 16 en `R.2X`, 32 en `R.4X`, 64 en `R.8X`. Debe tener cuidado al actualizar esta configuración, ya que podría afectar al rendimiento laboral porque el aumento del paralelismo entre las tareas provoca presión en la memoria y el disco y podría limitar los sistemas de origen y destino (por ejemplo, provocaría más conexiones simultáneas en Amazon RDS).
**`--extra-files`**
Las rutas de Amazon S3 a archivos adicionales, por ejemplo, archivos de configuración que AWS Glue copia en el directorio de trabajo de su script en el nodo del controlador antes de ejecutarlo. Varios valores deben ser rutas completas separadas por una coma (`,`). El valor puede ser archivos individuales o ubicaciones de directorios. Esta opción no es compatible con los tipos de trabajo de intérprete de comandos de Python.
**`--extra-jars`**
Amazon S3 lleva a archivos adicionales que AWS Glue copia al controlador y a los ejecutores. AWS Glue también añade estos archivos a la ruta de clases de Java antes de ejecutar el script. Varios valores deben ser rutas completas separadas por una coma (`,`). No es necesario que la extensión sea `.jar`
**`--extra-py-files`**
Las rutas de Amazon S3 a módulos de Python adicionales que AWS Glule agrega a la ruta de Python en el nodo del controlador antes de ejecutar el script. Varios valores deben ser rutas completas separadas por una coma (`,`). Solo se admiten archivos individuales, no una ruta de directorio.
**`--job-bookmark-option`**
Controla el comportamiento de un marcador de trabajo. Se pueden establecer los siguientes valores de opciones.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html)
Por ejemplo, para habilitar un marcador de trabajo, transfiera el argumento siguiente.
```
'--job-bookmark-option': 'job-bookmark-enable'
```
**`--job-language`**
El lenguaje de programación del script. Este valor debe ser `scala` o `python`. Si no está presente este parámetro, el valor predeterminado es `python`.
**`--python-modules-installer-option`**
Una cadena de texto simple que define las opciones que se van a pasar a `pip3` al instalar módulos con [--additional-python-modules](#additional-python-modules). Proporcione opciones como lo haría en la línea de comandos, separadas por espacios y prefijadas por guiones. Para obtener más información acerca del uso de una VPC, consulte [Instalación de módulos adicionales de Python en AWS Glue 2.0 (o posterior) con pip](aws-glue-programming-python-libraries.md#addl-python-modules-support).
Esta opción no es compatible con los trabajos de AWS Glue cuando se utiliza Python 3.9.
**`--scriptLocation`**
La ubicación de Amazon Simple Storage Service (Amazon S3) donde se encuentra su script de ETL (en formato `s3://path/to/my/script.py`). Este parámetro invalida una ubicación del script establecida en el objeto `JobCommand`.
**`--spark-event-logs-path`**
Especifica una ruta de Amazon S3. Al utilizar la función de monitoreo de la interfaz de usuario de Spark, AWS Glue vacía los registros de eventos de Spark a esta ruta de Amazon S3 cada 30 segundos, en un bucket que se puede usar como directorio temporal para almacenar eventos de la interfaz de usuario de Spark.
**`--TempDir`**
Especifica una ruta de Amazon S3 a un bucket que se puede utilizar como directorio temporal para el trabajo.
Por ejemplo, para establecer un directorio temporal, transfiera el argumento siguiente.
```
'--TempDir': 's3-path-to-directory'
```
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 bloqueo del acceso público o eliminar el bucket más tarde, después de que se hayan completado todos los trabajos de esa región.
**`--use-postgres-driver`**
Al establecer este valor en `true`, se prioriza el controlador JDBC de Postgre en la ruta de clases para evitar un conflicto con el controlador JDBC de Amazon Redshift. La opción solo está disponible en la versión 2.0 de AWS Glue.
**`--user-jars-first`**
Al establecer este valor en `true`, se priorizan los archivos JAR adicionales del cliente en el classpath. Esta opción solo se encuentra disponible en AWS Glue versión 2.0 o posterior.
**`--conf`**
Controla los parámetros de configuración de Spark. Es para casos de uso avanzados.
**`--encryption-type`**
Parámetro heredado. El comportamiento correspondiente debe configurarse mediante configuraciones de seguridad. Para obtener más información sobre las configuraciones de seguridad, consulte [Cifrado de datos escritos por AWS Glue](encryption-security-configuration.md).
AWS Glue usa los siguientes argumentos a nivel interno y el usuario nunca debe usarlos:
+ `--debug`: interno de AWS Glue. No lo establezca.
+ `--mode`: interno de AWS Glue. No lo establezca.
+ `--JOB_NAME`: interno de AWS Glue. No lo establezca.
+ `--endpoint`: interno de AWS Glue. No lo establezca.
##
AWS Glue admite el inicio de un entorno con el módulo `site` de Python que utiliza `sitecustomize` para realizar personalizaciones específicas del sitio. Se recomienda iniciar sus propias funciones de inicialización únicamente para casos de uso avanzados y, si se hace todo lo posible, se admite en la versión 4.0 de AWS Glue.
El prefijo de la variable de entorno, `GLUE_CUSTOMER`, está reservado para el uso de los clientes.
# 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.
[](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.
# Tipos de trabajadores de AWS Glue
## Descripción general
AWS Glue proporciona varios tipos de trabajadores para adaptarse a diferentes requisitos de carga de trabajo, desde pequeños trabajos de transmisión hasta tareas de procesamiento de datos a gran escala que consumen mucha memoria. En esta sección se proporciona información completa sobre todos los tipos de trabajadores disponibles, sus especificaciones y recomendaciones de uso.
### Categorías de tipos de trabajadores
AWS Glue ofrece dos categorías principales de tipos de trabajadores:
+ **Tipos de trabajadores G**: trabajador informáticos de uso general optimizados para cargas de trabajo de ETL estándar
+ **Tipos de trabajadores R**: trabajadores con memoria optimizada diseñados para aplicaciones Spark con un gran consumo de memoria
### Unidades de procesamiento de datos (DPU)
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.
**DPU optimizadas para memoria (M-DPU)**: los trabajador de tipo R utilizan M-DPU, que proporcionan el doble de asignación de memoria para un tamaño determinado en comparación con las DPU estándar. Esto significa que, si bien una DPU estándar proporciona 16 GB de memoria, una M-DPU en trabajador de tipo R proporciona 32 GB de memoria optimizada para aplicaciones Spark con un gran consumo de memoria.
## Tipos de trabajadores disponibles
### G.1 X
+ **DPU**: 1 DPU (4 vCPU, 16 GB de memoria)
+ **Almacenamiento**: disco de 94 GB (aproximadamente 44 GB libres)
+ **Caso de uso**: consultas, uniones y transformaciones de datos; escalables y rentables para la mayoría de los trabajos
### G.2 X
+ **DPU**: 2 DPU (8 vCPU, 32 GB de memoria)
+ **Almacenamiento**: disco de 138 GB (aproximadamente 78 GB libres)
+ **Caso de uso**: consultas, uniones y transformaciones de datos; escalables y rentables para la mayoría de los trabajos
### G.4X
+ **DPU**: 4 DPU (16 vCPU, 64 GB de memoria)
+ **Almacenamiento**: disco de 256 GB (aproximadamente 230 GB libres)
+ **Caso de uso**: transformaciones, agregaciones, uniones y consultas exigentes
### G.8X
+ **DPU**: 8 DPU (32 vCPU, 128 GB de memoria)
+ **Almacenamiento**: disco de 512 GB (aproximadamente 485 GB libres)
+ **Caso de uso**: transformaciones, agregaciones, uniones y consultas exigentes
### G.12X
+ **DPU**: 12 DPU (48 vCPU, 192 GB de memoria)
+ **Almacenamiento**: disco de 768 GB (aproximadamente 741 GB libres)
+ **Caso de uso**: cargas de trabajo muy grandes que consumen muchos recursos y requieren una capacidad informática significativa
### G.16X
+ **DPU**: 16 DPU (64 vCPU, 256 GB de memoria)
+ **Almacenamiento**: disco de 1024 GB (aproximadamente 996 GB libres)
+ **Caso de uso**: las cargas de trabajo más grandes que consumen la mayor cantidad de recursos y requieren la capacidad informática máxima
### R.1X: optimizado para la memoria\$1
+ **DPU**: 1 M-DPU (4 vCPU, 32 GB de memoria)
+ **Caso de uso**: cargas de trabajo con una gran consumo de memoria y con errores frecuentes de falta de memoria o que requieren una alta relación entre memoria y CPU
### R.2X: optimizado para la memoria\$1
+ **DPU**: 2 M-DPU (8 vCPU, 64 GB de memoria)
+ **Caso de uso**: cargas de trabajo con una gran consumo de memoria y con errores frecuentes de falta de memoria o que requieren una alta relación entre memoria y CPU
### R.4X: optimizado para la memoria\$1
+ **DPU**: 4 M-DPU (16 vCPU, 128 GB de memoria)
+ **Caso de uso**: cargas de trabajo grandes con un gran consumo de memoria y con errores frecuentes de falta de memoria o que requieren una alta relación entre memoria y CPU
### R.8X: optimizado para la memoria\$1
+ **DPU**: 8 M-DPU (32 vCPU, 256 GB de memoria)
+ **Caso de uso**: cargas de trabajo muy grandes con una gran consumo de memoria y con errores frecuentes de falta de memoria o que requieren una alta relación entre memoria y CPU
**\$1** Puede tener una mayor latencia de inicio con estos trabajadores. Para resolver este problema, pruebe lo siguiente:
+ Espere unos minutos y después envíe el trabajo de nuevo.
+ Envíe un nuevo trabajo con menos trabajadores.
+ Envíe un nuevo trabajo con un tipo o tamaño de trabajador diferente.
## Tabla de especificaciones del tipo de trabajador
**Especificaciones del tipo de trabajador**
| Tipo de trabajador | DPU por nodo | vCPU | Memoria (GB) | Disco (GB) | Espacio libre en el disco aproximado (GB) | Ejecutores de Spark por nodo |
| --- | --- | --- | --- | --- | --- | --- |
| G.1 X | 1 | 4 | 16 | 94 | 44 | 1 |
| G.2 X | 2 | 8 | 32 | 138 | 78 | 1 |
| G.4X | 4 | 16 | 64 | 256 | 230 | 1 |
| G.8X | 8 | 32 | 128 | 512 | 485 | 1 |
| G.12X | 12 | 48 | 192 | 768 | 741 | 1 |
| G.16X | 16 | 64 | 256 | 1024 | 996 | 1 |
| R.1X | 1 | 4 | 32 | 94 | 44 | 1 |
| R.2X | 2 | 8 | 64 | 138 | 78 | 1 |
| R.4X | 4 | 16 | 128 | 256 | 230 | 1 |
| R.8X | 8 | 32 | 256 | 512 | 485 | 1 |
*Nota*: Los tipos de trabajadores R tienen configuraciones optimizadas para cargas de trabajo que consumen mucha memoria.
## Consideraciones importantes
### Latencia de inicio
**importante**
Los tipos de trabajadores G.12X y G.16X, así como todos los tipos de trabajadores R (de R.1X a R.8X), pueden tener una latencia de inicio más alta. Para resolver este problema, pruebe lo siguiente:
Espere unos minutos y después envíe el trabajo de nuevo.
Envíe un nuevo trabajo con menos trabajadores.
Envíe un nuevo trabajo con un tipo y tamaño de trabajador diferente.
## Elección del tipo de trabajador correcto
### Para cargas de trabajo de ETL estándar
+ **G.1X o G.2X**: los más rentables para las típicas uniones, consultas y transformaciones de datos
+ **G.4X o G.8X**: para cargas de trabajo más exigentes con conjuntos de datos más grandes
### Para cargas de trabajo a gran escala
+ **G.12X**: para conjuntos de datos muy grandes que requieren recursos informáticos considerables
+ **G.16X**: la capacidad informática máxima para las cargas de trabajo más exigentes
### Para cargas de trabajo con un gran consumo de memoria
+ **R.1X o R.2X**: trabajos con un gran consumo de memoria de tamaño pequeño a mediano
+ **R.4X o R.8X**: grandes cargas de trabajo con un gran consumo de memoria y frecuentes errores de falta de memoria
## Consideraciones sobre optimización de costos
+ **Trabajadores estándar G**: proporcionan un equilibrio entre los recursos informáticos, de memoria y de red, y se pueden usar para una variedad de cargas de trabajo diversas a un costo menor.
+ **Trabajadores R**: están especializados para tareas con un gran consumo de memoria con un rendimiento rápido para cargas de trabajo que procesan grandes conjuntos de datos en la memoria.
## Prácticas recomendadas
### Directrices de selección de trabajadores
1. **Comience con los trabajadores estándar** (G.1X, G.2X) para la mayoría de las cargas de trabajo.
1. **Use trabajadores R** cuando reciba errores de falta de memoria frecuentes o tenga cargas de trabajo con operaciones que consumen mucha memoria, como el almacenamiento en caché, la mezcla de datos y las agregaciones.
1. **Considere usar G.12X/G.16X** para cargas de trabajo con requisitos informáticos altos que requieren el máximo de recursos.
1. **Tenga en cuenta las limitaciones de capacidad** al usar nuevos tipos de trabajadores en flujos de trabajo con restricciones de tiempo.
### Optimización del rendimiento
+ Supervise las métricas de CloudWatch para comprender la utilización de los recursos.
+ Use los recuentos de trabajadores adecuados en función del tamaño y la complejidad de los datos.
+ Considere usar estrategias de partición de datos para optimizar la eficiencia de los trabajadores.
# Trabajos ETL de streaming en AWS Glue
Puede crear trabajos de extracción, transformación y carga (ETL) de streaming que se ejecuten continuamente, consuman datos de orígenes de streaming como Amazon Kinesis Data Streams, Apache Kafka y Amazon Managed Streaming for Apache Kafka (Amazon MSK). Los trabajos limpian y transforman los datos y, a continuación, cargan los resultados en los lagos de datos de Amazon S3 o en los almacenes de datos JDBC.
Además, puede generar datos para los flujos de Amazon Kinesis Data Streams. Esta característica solo está disponible al escribir scripts de AWS Glue. Para obtener más información, consulte [Conexión de Kinesis](aws-glue-programming-etl-connect-kinesis-home.md).
De forma predeterminada, AWS Glue procesa y escribe datos en periodos de 100 segundos. Esto permite que los datos se procesen de forma eficiente y permite que las agregaciones se realicen en los datos que lleguen más tarde de lo previsto. Puede modificar este tamaño de ventana para aumentar la puntualidad o la precisión de la agregación. Los trabajos de streaming de AWS Glue utilizan puntos de control en lugar de marcadores de trabajo para rastrear los datos leídos.
**nota**
AWS Glue factura por hora para trabajos de ETL de streaming mientras se están ejecutando.
Este video analiza los desafíos de costos de ETL de streaming y las funciones de ahorro de costos en AWS Glue.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/6ggTFOtfUxU)
La creación de un trabajo ETL de streaming consta de los siguientes pasos:
1. Para un origen de streaming de Apache Kafka, cree una conexión de AWS Glue al origen de Kafka o al clúster de Amazon MSK.
1. Cree manualmente una tabla del Catálogo de datos para el origen de streaming.
1. Cree un trabajo ETL para el origen de datos de streaming. Defina propiedades de trabajo específicas de streaming y proporcione su propio script o también puede modificar el script generado.
Para obtener más información, consulte [ETL de streaming en AWS Glue](components-overview.md#streaming-etl-intro).
Al crear un trabajo de ETL de streaming para Amazon Kinesis Data Streams, no es necesario crear una conexión de AWS Glue. Sin embargo, si hay una conexión asociada al trabajo de ETL de streaming de AWS Glue que tenga Kinesis Data Streams como origen, se requiere un punto de enlace de la nube privada virtual (VPC) para Kinesis. Para obtener más información, consulte [Creación de un punto de conexión de interfaz](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#create-interface-endpoint) en la *Guía del usuario de Amazon VPC*. Al especificar un flujo de Amazon Kinesis Data Streams en otra cuenta, debe configurar los roles y las políticas para permitir el acceso entre cuentas. Para obtener más información, consulte [Ejemplo: leer desde un flujo de Kinesis en una cuenta diferente](https://docs.aws.amazon.com/kinesisanalytics/latest/java/examples-cross.html).
AWS GlueLos trabajos de ETL de streaming en pueden detectar automáticamente datos comprimidos, descomprimir de forma transparente los datos de streaming, realizar las transformaciones habituales en el origen de entrada y cargarlos en el almacén de salida.
AWS Glue admite la descompresión automática para los siguientes tipos de compresión dado el formato de entrada:
| Tipo de compresión | Archivo Avro | Datos de Avro | JSON | CSV | Grok |
| --- | --- | --- | --- | --- | --- |
| BZIP2 | Sí | Sí | Sí | Sí | Sí |
| GZIP | No | Sí | Sí | Sí | Sí |
| SNAPPY | Sí (Snappy sin formato) | Sí (con encuadre de Snappy) | Sí (con encuadre de Snappy) | Sí (con encuadre de Snappy) | Sí (con encuadre de Snappy) |
| XZ | Sí | Sí | Sí | Sí | Sí |
| ZSTD | Sí | No | No | No | No |
| DEFLATE | Sí | Sí | Sí | Sí | Sí |
**Topics**
+ [Creación de una conexión de AWS Glue para un flujo de datos Apache Kafka](#create-conn-streaming)
+ [Creación de una tabla del Catálogo de datos para un origen de streaming](#create-table-streaming)
+ [Notas y restricciones para orígenes de streaming de Avro](#streaming-avro-notes)
+ [Aplicación de patrones Grok a orígenes de streaming](#create-table-streaming-grok)
+ [Definición de propiedades de trabajo para un trabajo ETL de streaming](#create-job-streaming-properties)
+ [Notas y restricciones de ETL de streaming](#create-job-streaming-restrictions)
## Creación de una conexión de AWS Glue para un flujo de datos Apache Kafka
Para leer en una transmisión de Apache Kafka, debe crear una conexión de AWS Glue.
**Para crear una conexión de AWS Glue para un origen de Kafka (consola)**
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, en **Data catalog** (Catálogo de datos), elija **Connections (Conexiones)**.
1. Elija **Agregar conexión** y, en la página **Configurar las propiedades de la conexión** escriba un nombre de conexión.
**nota**
Para obtener más información acerca de cómo especificar propiedades de conexión, consulte [Propiedades de conexión de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-connections).
1. En **Tipo de conexión**, elija **Kafka**.
1. Para **Kafka bootstrap servers URLs (URL de servidores de arranque Kafka)**, ingrese el host y el número de puerto de los agentes de arranque para su clúster de Amazon MSK o Apache Kafka. Utilice sólo los puntos de enlace de Transport Layer Security (TLS) para establecer la conexión inicial con el clúster de Kafka. No se admiten puntos de enlace de texto no cifrado.
A continuación se ofrece una lista de pares de nombre de host y número de puerto para un clúster de Amazon MSK a modo de ejemplo.
```
myserver1.kafka.us-east-1.amazonaws.com:9094,myserver2.kafka.us-east-1.amazonaws.com:9094,
myserver3.kafka.us-east-1.amazonaws.com:9094
```
Para obtener más información sobre cómo obtener la información del agente de arranque, consulte [Obtener los agentes de arranque para un clúster de Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/msk-get-bootstrap-brokers.html) en la *Guía para desarrolladores de Amazon Managed Streaming for Apache Kafka*.
1. Si desea una conexión segura al origen de datos de Kafka, seleccione **Require SSL connection (Solicitar conexión SSL)**, y para **Kafka private CA certificate location (Ubicación del certificado de CA privado de Kafka)**, ingrese una ruta válida de Amazon S3 a un certificado SSL personalizado.
Para una conexión SSL a Kafka autoadministrado, el certificado personalizado es obligatorio. Es opcional para Amazon MSK.
Para obtener más información sobre cómo especificar un certificado personalizado para Kafka, consulte [AWS GluePropiedades de las conexiones SSL de](connection-properties.md#connection-properties-SSL).
1. Use AWS Glue Studio o CLI AWS para especificar un método de autenticación de cliente Kafka. Para obtener acceso a AWS Glue Studio, seleccione **AWS Glue** en el menú **ETL** en el panel de navegación izquierdo.
Para obtener más información acerca de los métodos de autenticación de cliente Kafka, consulte [Propiedades de conexión de AWS Glue Kafka para autenticación de clientes](#connection-properties-kafka-client-auth).
1. Si lo desea, escriba una descripción y, a continuación, elija **Next (Siguiente)**.
1. Para un clúster de Amazon MSK, especifique la nube virtual privada (VPC), su subred y el grupo de seguridad. La información de la VPC es opcional para Kafka autoadministrado.
1. Elija **Next (Siguiente)** para revisar todas las propiedades de conexión y, a continuación, elija **Finish (Finalizar)**.
Para obtener más información acerca de las conexiones de AWS Glue, consulte [Conexión a datos](glue-connections.md).
### Propiedades de conexión de AWS Glue Kafka para autenticación de clientes
**Autenticación SASL/GSSAPI (Kerberos)**
La elección de este método de autenticación le permitirá especificar propiedades de Kerberos.
**Keytab de Kerberos**
Seleccione la ubicación del archivo keytab. Una keytab almacena claves a largo plazo para uno o varias entidades principales. Para obtener más información, consulte [MIT Kerberos Documentation: Keytab](https://web.mit.edu/kerberos/krb5-latest/doc/basic/keytab_def.html) (Documentación de MIT Kerberos: Keytab).
**Archivo Kerberos krb5.conf**
Seleccione el archivo krb5.conf. Contiene el dominio predeterminado (una red lógica, similar a un dominio, que define un grupo de sistemas bajo el mismo KDC) y la ubicación del servidor KDC. Para obtener más información, consulte [MIT Kerberos Documentation: krb5.conf](https://web.mit.edu/kerberos/krb5-1.12/doc/admin/conf_files/krb5_conf.html) (Documentación de MIT Kerberos: krb5.conf).
**Nombre principal y nombre de servicio de Kerberos**
Ingrese el nombre principal y el de servicio de Kerberos. Para obtener más información, consulte la [documentación de Kerberos de MIT: principal de Kerberos](https://web.mit.edu/kerberos/krb5-1.5/krb5-1.5.4/doc/krb5-user/What-is-a-Kerberos-Principal_003f.html).
**Autenticación SASL/SCRAM-SHA-512**
La elección de este método de autenticación le permitirá especificar credenciales de autenticación.
**AWS Secrets Manager**
Busque el token en el cuadro de búsqueda mediante el nombre o ARN.
**Nombre de usuario y contraseña del proveedor directamente**
Busque el token en el cuadro de búsqueda mediante el nombre o ARN.
**Autenticación SSL del cliente**
La elección de este método de autenticación le permite seleccionar la ubicación del almacén de claves del cliente Kafka navegando por Amazon S3. Opcionalmente, puede ingresar la contraseña del almacén de claves del cliente Kafka y la contraseña de clave de cliente Kafka.
**Autenticación de IAM**
Este método de autenticación no requiere especificaciones adicionales y solo se aplica cuando la fuente de streaming es Kafka para MSK.
**Autenticación de SASL/PLAIN**
Al elegir este método de autenticación, puede especificar las credenciales de autenticación.
## Creación de una tabla del Catálogo de datos para un origen de streaming
Es posible crear de forma manual una tabla del Catálogo de datos que especifique las propiedades del flujo de datos de origen, incluido el esquema de datos, para un origen de streaming. Esta tabla se utiliza como origen de datos para el trabajo ETL de streaming.
Si no conoce el esquema de los datos en el flujo de datos de origen, puede crear la tabla sin un esquema. A continuación, cuando cree el trabajo de ETL de streaming, puede habilitar la función detección de esquema de AWS Glue. AWS Glue determinará el esquema a partir de los datos de streaming.
Utilice la [consola de AWS Glue](https://console.aws.amazon.com/glue/), la AWS Command Line Interface (AWS CLI) o la API de AWS Glue para crear la tabla. Para obtener información sobre cómo crear una tabla manualmente con la consola de AWS Glue, consulte [Creación de tablas](tables-described.md).
**nota**
No puede usar la consola de AWS Lake Formation para crear la tabla; debe usar la consola de AWS Glue.
Tenga en cuenta también la siguiente información para los orígenes de streaming en formato Avro o para los datos de registro a los que puede aplicar patrones Grok.
+ [Notas y restricciones para orígenes de streaming de Avro](#streaming-avro-notes)
+ [Aplicación de patrones Grok a orígenes de streaming](#create-table-streaming-grok)
**Topics**
+ [Origen de datos de Kinesis](#kinesis-source)
+ [Origen de datos de Kafka](#kafka-source)
+ [AWS GlueOrigen de tablas de Schema Registry](#schema-registry-table)
### Origen de datos de Kinesis
Al crear la tabla, configure las siguientes propiedades de ETL de streaming (consola).
**Tipo de origen**
**Kinesis**
**Para un origen de Kinesis en la misma cuenta:**
**Región**
La región de AWS en la que reside el servicio Amazon Kinesis Data Streams. La región y el nombre del flujo de Kinesis se traducen juntos a un ARN de flujo.
Ejemplo: https://kinesis.us-east-1.amazonaws.com
**Nombre de flujo de Kinesis**
Nombre de la transmisión, tal como se describe en [Creación de una transmisión](https://docs.aws.amazon.com/streams/latest/dev/kinesis-using-sdk-java-create-stream.html) en la *Guía para desarrolladores de Amazon Kinesis Data Streams*.
**Para un origen de Kinesis en otra cuenta, consulte [este ejemplo](https://docs.aws.amazon.com/kinesisanalytics/latest/java/examples-cross.html) para configurar los roles y políticas que permitan el acceso entre cuentas. Configure estas opciones:**
**ARN de flujo**
El ARN del flujo de datos de Kinesis con el que está registrado el consumidor. Para obtener más información, consulte [Nombres de recursos de Amazon (ARNs) y espacios de nombres de servicios de AWS](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) en la *Referencia general de AWS*.
**ARN de rol asumido**
El nombre de recurso de Amazon (ARN) del rol que se asignará.
**Nombre de la sesión (opcional)**
Un identificador para la sesión del rol asumido.
Utilice el nombre de la sesión del rol para identificar de forma única una sesión cuando el mismo rol es asumido por diferentes entidades o por diferentes razones. En escenarios entre cuentas, el nombre de la sesión del rol es visible para la cuenta que es titular del rol. Esta cuenta podrá registrar el rol. El nombre de la sesión del rol también se utiliza en el ARN de la entidad principal del rol asumido. Esto significa que las solicitudes posteriores de API entre cuentas que utilizan las credenciales de seguridad temporales expondrán el nombre de la sesión del rol a la cuenta externa en sus registros de AWS CloudTrail.
**Para configurar las propiedades de ETL de streaming para Amazon Kinesis Data Streams (API de AWS Glue o AWS CLI)**
+ Para configurar las propiedades de ETL de streaming para un origen de Kinesis en la misma cuenta, especifique los parámetros `streamName` y `endpointUrl` en la estructura `StorageDescriptor` de la operación de la API `CreateTable` o el comando de la CLI `create_table`.
```
"StorageDescriptor": {
"Parameters": {
"typeOfData": "kinesis",
"streamName": "sample-stream",
"endpointUrl": "https://kinesis.us-east-1.amazonaws.com"
}
...
}
```
O bien, especifique `streamARN`.
**Example**
```
"StorageDescriptor": {
"Parameters": {
"typeOfData": "kinesis",
"streamARN": "arn:aws:kinesis:us-east-1:123456789:stream/sample-stream"
}
...
}
```
+ Para configurar las propiedades de ETL de streaming para un origen de Kinesis en otra cuenta, especifique los parámetros `streamARN`, `awsSTSRoleARN` y `awsSTSSessionName` (opcional) en la estructura `StorageDescriptor` en la operación de la API `CreateTable` o el comando de la CLI `create_table`.
```
"StorageDescriptor": {
"Parameters": {
"typeOfData": "kinesis",
"streamARN": "arn:aws:kinesis:us-east-1:123456789:stream/sample-stream",
"awsSTSRoleARN": "arn:aws:iam::123456789:role/sample-assume-role-arn",
"awsSTSSessionName": "optional-session"
}
...
}
```
### Origen de datos de Kafka
Al crear la tabla, configure las siguientes propiedades de ETL de streaming (consola).
**Tipo de origen**
**Kafka**
**Para un origen de Kafka:**
**Nombre del tema**
Nombre del tema como se especifica en Kafka.
**Connection**
Una conexión de AWS Glue que hace referencia a un origen de Kafka, como se describe en [Creación de una conexión de AWS Glue para un flujo de datos Apache Kafka](#create-conn-streaming).
### AWS GlueOrigen de tablas de Schema Registry
A fin de utilizar AWS Glue Schema Registry para trabajos de streaming, siga las instrucciones de [Caso de uso: AWS Glue Data Catalog](schema-registry-integrations.md#schema-registry-integrations-aws-glue-data-catalog) para crear o actualizar una tabla de Schema Registry.
Actualmente, el streaming de AWS Glue solo soporta el formato Avro de Glue Schema Registry con inferencia de esquema establecida en `false`.
## Notas y restricciones para orígenes de streaming de Avro
Las siguientes notas y restricciones corresponden a los orígenes de streaming en formato Avro:
+ Cuando se activa la detección de esquemas, el esquema de Avro debe incluirse en la carga. Cuando se desactiva, la carga debe contener solo datos.
+ Algunos tipos de datos de Avro no se admiten en marcos dinámicos. No se pueden especificar estos tipos de datos al definir el esquema con la página **Define a schema (Definir un esquema)** en el asistente de creación de tabla en la consola de AWS Glue. Durante la detección de esquemas, los tipos no soportados en el esquema Avro se convierten en tipos soportados de la siguiente manera:
+ `EnumType => StringType`
+ `FixedType => BinaryType`
+ `UnionType => StructType`
+ Si define el esquema de tabla mediante la página **Define a schema (Definir un esquema)** en la consola, el tipo de elemento raíz implícito para el esquema es `record`. Si desea un tipo de elemento raíz distinto de `record`, por ejemplo, `array` or `map`, no puede especificar el esquema mediante la página **Define a schema (Definir un esquema)**. En su lugar, debe omitir esa página y especificar el esquema como propiedad de tabla o dentro del script de ETL.
+ Para especificar el esquema en las propiedades de la tabla, complete el asistente de creación de tabla, edite los detalles de la tabla y agregue un nuevo par clave-valor en **Table properties (Propiedades de la tabla)**. Utilice la clave `avroSchema`, e ingrese un objeto JSON de esquema para el valor, tal y como se muestra en la siguiente captura de pantalla.
![\[En el encabezado Table properties (Propiedades de la tabla), hay dos columnas de campos de texto. El encabezado de la columna de la izquierda es Key (Clave) y el encabezado de la columna de la derecha es Value (Valor). El par clave/valor en la primera fila es clasificación/avro. El par clave/valor de la segunda fila es avroSchema/{“type”:“array”,“items”:“string”}.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/table_properties_avro.png)
+ Para especificar el esquema en el script de ETL, modifique la instrucción de asignación `datasource0` y agregue la clave `avroSchema` a la instrucción `additional_options`, tal y como se muestra en los siguientes ejemplos de Python y Scala.
------
#### [ Python ]
```
SCHEMA_STRING = ‘{"type":"array","items":"string"}’
datasource0 = glueContext.create_data_frame.from_catalog(database = "database", table_name = "table_name", transformation_ctx = "datasource0", additional_options = {"startingPosition": "TRIM_HORIZON", "inferSchema": "false", "avroSchema": SCHEMA_STRING})
```
------
#### [ Scala ]
```
val SCHEMA_STRING = """{"type":"array","items":"string"}"""
val datasource0 = glueContext.getCatalogSource(database = "database", tableName = "table_name", redshiftTmpDir = "", transformationContext = "datasource0", additionalOptions = JsonOptions(s"""{"startingPosition": "TRIM_HORIZON", "inferSchema": "false", "avroSchema":"$SCHEMA_STRING"}""")).getDataFrame()
```
------
## Aplicación de patrones Grok a orígenes de streaming
Puede crear un trabajo de ETL de streaming para un origen de datos de registro y utilizar patrones Grok para convertir los registros en datos estructurados. Luego, el trabajo de ETL procesa los datos como un origen de datos estructurados. Especifique los patrones Grok que se aplicarán al crear la tabla del Catálogo de datos para el origen de streaming.
Para obtener información acerca de los patrones Grok y los valores de la cadena de patrones personalizados, consulte [Escritura de clasificadores personalizados de Grok](custom-classifier.md#custom-classifier-grok).
**Para agregar patrones Grok a la tabla del Catálogo de datos (consola)**
+ Utilice el asistente de creación de tablas y cree la tabla con los parámetros especificados en [Creación de una tabla del Catálogo de datos para un origen de streaming](#create-table-streaming). Especifique el formato de datos como Grok, complete el campo **Grok pattern (Patrón de Grok)** y, opcionalmente, agregue patrones personalizados en **Custom patterns (Patrones personalizados) (opcional)**.
![\[*\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/grok-data-format-create-table.png)
Presione **Enter (Intro)** después de cada patrón personalizado.
**Para agregar patrones grok a la tabla del Catálogo de datos (API de AWS Glue o AWS CLI)**
+ Agregue el parámetro `GrokPattern` y, opcionalmente, el parámetro `CustomPatterns` a la operación de API `CreateTable` o al comando de la CLI `create_table`.
```
"Parameters": {
...
"grokPattern": "string",
"grokCustomPatterns": "string",
...
},
```
Indique `grokCustomPatterns` como una cadena y use “\$1n” como separador entre patrones.
El siguiente ejemplo muestra cómo especificar estos parámetros.
**Example**
```
"parameters": {
...
"grokPattern": "%{USERNAME:username} %{DIGIT:digit:int}",
"grokCustomPatterns": "digit \d",
...
}
```
## Definición de propiedades de trabajo para un trabajo ETL de streaming
Cuando defina un trabajo de ETL de streaming en la consola de AWS Glue, proporcione las siguientes propiedades específicas de los flujos. Para obtener propiedades de trabajo adicionales, consulte [Definición de propiedades de trabajo para trabajos de Spark](add-job.md#create-job).
**rol de IAM**
Especifique el rol AWS Identity and Access Management (IAM) que se usa para dar una autorización a los recursos que se utilizan para ejecutar un trabajo, acceder a orígenes de streaming y acceder a almacenes de datos de destino.
Para acceder a Amazon Kinesis Data Streams, asocie la política `AmazonKinesisFullAccess` administrada por AWS al rol o asocie una política IAM similar que permita un acceso más detallado. Para obtener información sobre políticas de ejemplo, consulte [Control del acceso a los recursos de Amazon Kinesis Data Streams mediante IAM](https://docs.aws.amazon.com/streams/latest/dev/controlling-access.html).
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**
Elija **Spark Streaming**.
**AWS GlueVersión **
La versión de AWS Glue determina las versiones de Apache Spark y Python o Scala que están disponibles para el trabajo. Elija una selección que especifique la versión de Python o Scala disponible para el trabajo. AWS Glue La versión 2.0 con soporte de Python 3 es la predeterminada para los trabajos de ETL de streaming.
**período de mantenimiento**
Especifica una ventana en la que se puede reiniciar un trabajo de streaming. Consulte [Ventanas de mantenimiento para AWS Glue Streaming](glue-streaming-maintenance.md).
**Job timeout (Tiempo de espera de flujo de trabajo)**
Si lo desea, escriba una duración en minutos. El valor predeterminado está en blanco.
+ Los trabajos de streaming deben tener un valor de tiempo de espera inferior a 7 días o 10 080 minutos.
+ Si el valor se deja en blanco, el trabajo se reiniciará después de 7 días, si no ha establecido un periodo de mantenimiento. Si ha configurado un periodo de mantenimiento, el trabajo se reiniciará durante el periodo de mantenimiento después de 7 días.
**Origen de datos**
Elimine la tabla que creó en [Creación de una tabla del Catálogo de datos para un origen de streaming](#create-table-streaming).
**Destino de datos**
Realice una de las siguientes acciones:
+ Elija **Crear tablas en el destino de datos** y especifique las siguientes propiedades de destino de datos.
**Almacén de datos**
Seleccione Amazon S3 o JDBC.
**Formato**
Elija cualquier formato. Todos son compatibles para streaming.
+ Elija **Use tables in the data catalog and update your data target (Utilizar tablas en el Catálogo de datos y actualizar el destino de los datos)** y elija una tabla para un almacén de datos JDBC.
**Definición de esquema de salida**
Realice una de las siguientes acciones:
+ Seleccione **Automatically detect schema of each record (Detectar automáticamente el esquema de cada registro)** para habilitar la detección de esquemas. AWS Glue determina el esquema a partir de los datos de streaming.
+ Seleccione **Specify output schema for all records (Especificar esquema de salida para todos los registros)** para utilizar la transformación de la función de aplicar mapeo a fin de definir el esquema de salida.
**Script**
Si lo desea, proporcione su propio script o modifique el script generado para realizar operaciones compatibles con el motor Apache Spark Structured Streaming. Para obtener información sobre las operaciones disponibles, consulte [Operaciones en DataFrames/conjuntos de datos de streaming](https://spark.apache.org/docs/latest/structured-streaming-programming-guide.html#operations-on-streaming-dataframesdatasets).
## Notas y restricciones de ETL de streaming
Tenga en cuenta las siguientes notas y restricciones:
+ La descompresión automática para los trabajos de ETL de streaming en AWS Glue solo está disponible para los tipos de compresión admitidos. Tenga también en cuenta lo siguiente:
+ Con encuadre de Snappy se refiere al [formato de encuadre](https://github.com/google/snappy/blob/main/framing_format.txt) oficial para Snappy.
+ Deflate es compatible con la versión 3.0 de Glue, no con la versión 2.0.
+ Cuando se utiliza la detección de esquemas, no se pueden realizar combinaciones de datos de streaming.
+ Los trabajos ETL de streaming de AWS Glue no admiten el tipo de datos de la Unión para el Registro de esquemas de AWS Glue con formato Avro.
+ Su script de ETL puede usar las transformaciones incorporadas de AWS Glue y las transformaciones nativas de Apache Spark Structured Streaming. Para obtener más información, consulte [Operaciones en DataFrames/conjuntos de datos de streaming](https://spark.apache.org/docs/latest/structured-streaming-programming-guide.html#operations-on-streaming-dataframesdatasets) en el sitio web de Apache Spark o [Referencia de transformaciones de PySpark de AWS Glue](aws-glue-programming-python-transforms.md).
+ AWS GlueLos trabajos de ETL de streaming de utilizan puntos de comprobación para realizar un seguimiento de los datos que se han leído. Por lo tanto, un trabajo detenido y reiniciado comienza donde lo dejó en la transmisión. Si desea volver a procesar los datos, puede eliminar la carpeta de puntos de control a la que se hace referencia en el script.
+ No se admiten los marcadores de trabajo.
+ Para la función de distribución mejorada de Kinesis Data Streams en un trabajo, consulte [Uso de una distribución mejorada en los trabajos de streaming de Kinesis](aws-glue-programming-etl-connect-kinesis-efo.md).
+ Si utiliza una tabla del Catálogo de datos creada a partir de AWS Glue Schema Registry, cuando se encuentre disponible una versión de esquema nueva, para reflejar el esquema nuevo, debe realizar lo siguiente:
1. Detenga los trabajos asociados a la tabla.
1. Actualice el esquema de la tabla del Catálogo de datos.
1. Reinicie los trabajos asociados a la tabla.
# Coincidencia de registros con FindMatches de AWS Lake Formation
**nota**
La coincidencia de registros no está disponible por el momento en las siguientes regiones de la consola de AWS Glue: Medio Oriente (EAU), Europa (España), Asia-Pacífico (Yakarta) y Europa (Zúrich).
AWS Lake Formation proporciona las capacidades de machine learning para crear transformaciones personalizadas para borrar sus datos. En la actualidad, hay una transformación disponible denominada FindMatches. La transformación FindMatches le permite identificar registros duplicados o coincidentes en el conjunto de datos, incluso cuando los registros no tienen un identificador único común y no coinciden exactamente los campos. Esto no requiere escribir ningún código ni saber cómo funciona machine learning. FindMatches puede resultar útil en muchos problemas diferentes, como:
+ **Coincidencia de clientes**: vinculación de registros de clientes en diferentes bases de datos de clientes, incluso cuando muchos campos de clientes no coincidan exactamente en las bases de datos (por ejemplo, ortografía de nombres diferentes, diferencias de direcciones, datos que faltan o no son precisos, etc.).
+ **Coincidencia de productos**: cotejar los productos del catálogo con otros orígenes de productos, como el catálogo de productos con el catálogo de un competidor, donde las entradas se estructuran de forma diferente.
+ **Mejora de la detección de fraudes**: identificar cuentas de cliente duplicadas, determinar cuándo una cuenta recién creada es (o podría ser) una coincidencia para un usuario fraudulento conocido anteriormente.
+ **Otros problemas de coincidencia**: coincidencia de direcciones, películas, listas de partes, etc. En general, si un ser humano pudiera examinar las filas de la base de datos y determinar que eran una coincidencia, existe una muy buena posibilidad de que la transformación FindMatches pueda ayudarle.
Puede crear estas transformaciones cuando cree un trabajo. La transformación que se crea se basa en un esquema de almacén de datos de origen y datos de ejemplo del conjunto de datos de origen que se etiquetan (a este proceso se lo denomina “enseñar” a una transformación). Los registros que se etiquetan deben estar presentes en el conjunto de datos de origen. En este proceso, se genera un archivo que se etiqueta y que luego se vuelve a cargar, y del que la transformación aprende en cierto modo. Después de enseñar a su transformación, puede invocarla desde su trabajo de AWS Glue basado en Spark (PySpark o Scala Spark) y utilizarla en otros scripts con un almacén de datos de origen compatible.
Una vez que se crea la transformación, se almacena en AWS Glue. En la consola de AWS Glue, puede administrar las transformaciones que cree. En el panel de navegación, en **Integración de datos y ETL**, en **Herramientas de clasificación de datos > Coincidencia de registros**, puede editar y entrenar su transformación de machine learning. Para obtener más información sobre la administración de transformaciones en la consola, consulte [Uso de transformaciones de machine learning](console-machine-learning-transforms.md).
**nota**
Los trabajos de FindMatches de AWS Glue versión 2.0 utilizan el bucket de Amazon S3 `aws-glue-temp--` para almacenar archivos temporales mientras la transformación procesa datos. Puede eliminar estos datos una vez finalizada la ejecución, ya sea en forma manual o mediante la configuración de una regla de ciclo de vida de Amazon S3.
## Tipos de transformaciones de machine learning
Puede crear transformaciones de machine learning para limpiar sus datos. Puede llamar a estas transformaciones desde el script de ETL. Los datos pasan de transformación en transformación en una estructura de datos denominada *DynamicFrame*, que es una extensión de `DataFrame` de Apache Spark SQL. `DynamicFrame` contiene sus datos y usted hace referencia a su esquema para procesar los datos.
Los tipos de transformaciones de machine learning disponibles son los siguientes:
*Búsqueda de coincidencias*
Permite buscar registros duplicados en los datos de origen. Enseñe esta transformación de machine learning mediante el etiquetado de conjuntos de datos de ejemplo para indicar las filas que coinciden. La transformación de machine learning aprende qué filas deben ser coincidencias a medida que usted se lo va enseñando utilizando datos etiquetados de ejemplo. En función de cómo configure la transformación, se genera una de las siguientes salidas:
+ Una copia de la tabla de entrada además de una columna `match_id` completada con valores que indican conjuntos de coincidencia de registros. La columna `match_id` es un identificador arbitrario. Cualquier registro que tenga el mismo `match_id` se ha identificado como coincidente entre sí. Los registros con diferentes `match_id`no coinciden.
+ Una copia de la tabla de entrada con las filas duplicadas eliminadas. Si se detectan varios duplicados, se guarda el registro con el menor clave principal.
*Búsqueda de coincidencias progresivas*
La transformación Buscar coincidencias también se puede configurar para buscar coincidencias en los fotogramas existentes y progresivos y devolver como salida una columna que contiene un ID único por grupo de coincidencias.
Para obtener más información, consulte: [Búsqueda de coincidencias progresivas](machine-learning-incremental-matches.md)
### Uso de la transformación FindMatches
Puede utilizar la transformación `FindMatches` para buscar registros duplicados en los datos de origen. Se genera un archivo de etiquetado o se proporciona para ayudar a enseñar a la transformación.
**nota**
En la actualidad, las transformaciones de `FindMatches` que utilizan una clave de cifrado personalizada no se soportan en las siguientes regiones:
Asia-Pacífico (Osaka): `ap-northeast-3`
Para empezar con la transformación FindMatches, puede seguir los pasos que se indican a continuación. Para obtener un ejemplo más avanzado y detallado, consulte el **blog sobre macrodatos de AWS**: [Armonizar los datos con la ML de FindMatches AWS Glue y AWS Lake Formation para crear una vista 360 del cliente](https://aws.amazon.com/blogs/big-data/harmonize-data-using-aws-glue-and-aws-lake-formation-findmatches-ml-to-build-a-customer-360-view/).
#### Introducción al uso de la transformación de FindMatches
Siga estos pasos para iniciar la transformación de `FindMatches`:
1. Cree una tabla en AWS Glue Data Catalog para los datos de origen que tienen que borrarse. Para obtener información sobre cómo crear un rastreador, consulte [Trabajar de rastreadores en la consola de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-crawlers.html).
Si los datos de origen son un archivo basado en texto como un archivo de valores separados por comas (CSV), tenga en cuenta lo siguiente:
+ Mantenga el archivo de etiquetado y el archivo CSV de registro de entrada en carpetas independientes. De lo contrario, el rastreador de AWS Glue podría considerarlos como varias partes de la misma tabla y crear tablas en el Catálogo de datos de forma incorrecta.
+ A menos que su archivo CSV incluya únicamente caracteres ASCII, asegúrese de que se utiliza UTF-8 sin codificación BOM (byte order mark, marca de orden de bytes) para los archivos CSV. Microsoft Excel a menudo añade una BOM al principio de archivos CSV UTF-8. Para eliminarlo, abra el archivo CSV en un editor de texto y vuelva a guardar el archivo como **UTF-8 sin BOM**.
1. En la consola AWS Glue, cree un trabajo y elija el tipo de transformación de **búsqueda de coincidencias**.
**importante**
La tabla de origen de datos que elija para el trabajo no puede tener más de 100 columnas.
1. AWS Glue Indique a que genere un archivo de etiquetado eligiendo **Generate labeling file (Generar archivo de etiquetado)**. AWS Glue realiza la primera pasada al agrupar registros similares para cada uno de ellos para que `labeling_set_id` pueda revisar esas agrupaciones. Las coincidencias se etiquetan en la columna `label`.
+ Si ya tiene un archivo de etiquetado, es decir, un ejemplo de registros que indican filas de coincidencia, cargue el archivo en Amazon Simple Storage Service (Amazon S3). Para obtener más información sobre el formato del archivo de etiquetado, consulte [Formato de archivo de etiquetado](#machine-learning-labeling-file). Continúe con el paso 4.
1. Descargue el archivo de etiquetado y etiquete el archivo tal y como se describe en la sección [Etiquetado](#machine-learning-labeling).
1. Cargue el archivo de etiquetado corregido. AWS Glue ejecuta tareas para enseñar a la transformación cómo encontrar coincidencias.
En la página de lista **Machine learning transforms** (Transformaciones de machine learning), elija la pestaña **History** (Historial). Esta página indica cuándo AWS Glue realiza las siguientes tareas:
+ **Importar etiquetas**
+ **Exportar etiquetas**
+ **Generar etiquetas**
+ **Estimar calidad**
1. Para crear una mejor transformación, puede descargar, etiquetar y cargar de forma iterativa el archivo de etiquetado. En las ejecuciones iniciales, es posible que una gran cantidad de registros no coincidan. Sin embargo, AWS Glue aprende a medida que sigue enseñándole mediante la comprobación del archivo de etiquetado.
1. Evalúe y ajuste su transformación mediante la evaluación del rendimiento y resultados de búsqueda de coincidencias. Para obtener más información, consulte [Ajuste de transformaciones de machine learning en AWS Glue](add-job-machine-learning-transform-tuning.md).
#### Etiquetado
Cuando `FindMatches` genera un archivo de etiquetado, los registros se seleccionan en la tabla de origen. En función del entrenamiento anterior, `FindMatches` identifica los registros más valiosos de los que puede aprender.
La acción de *etiquetado* consiste en editar un archivo (le recomendamos que utilice una hoja de cálculo como Microsoft Excel) y agregar en la columna `label` identificadores o etiquetas que identifiquen los registros coincidentes y no coincidentes. Es importante disponer de una definición clara y coherente de las coincidencias en los datos de origen. `FindMatches` aprende a partir de los registros que se designan (o no) como coincidencias y utiliza estas decisiones para aprender a buscar registros duplicados.
Cuando `FindMatches` genere un archivo de etiquetado, se generarán aproximadamente 100 registros. Estos 100 registros normalmente se dividen en 10 *conjuntos de etiquetado*, cada uno de los cuales se identifica mediante un `labeling_set_id` único generado por `FindMatches`. Cada conjunto de etiquetado debe considerarse como una tarea de etiquetado independiente de los demás conjuntos de etiquetado. Su tarea consiste en identificar registros coincidentes y no coincidentes dentro de cada conjunto de etiquetado.
##### Sugerencias para editar archivos de etiquetado en una hoja de cálculo.
Cuando edite el archivo de etiquetado en una aplicación de hoja de cálculo, tenga en cuenta lo siguiente:
+ Es posible que el archivo no se abra con los campos de columna totalmente expandidos. Puede que tenga que expandir las columnas `labeling_set_id` y `label` para ver el contenido de esas celdas.
+ Si la columna de clave principal es un nombre, como un tipo de datos `long`, es posible que la hoja de cálculo la interprete como un número y cambie el valor. Este valor de la clave debe tratarse como texto. Para solucionar este problema, dé formato a todas las celdas en la columna de clave principal como **datos de texto**.
#### Formato de archivo de etiquetado
El archivo de etiquetado que AWS Glue genera para enseñar a su transformación `FindMatches` utiliza el siguiente formato. Si genera su propio archivo de AWS Glue, también debe utilizar este formato:
+ Es un archivo de valores separados por comas (CSV).
+ Debe estar codificado en `UTF-8`. Si edita el archivo con Microsoft Windows, se puede codificar con `cp1252`.
+ Debe ser una ubicación de Amazon S3 para transferirlo a AWS Glue.
+ Use una cantidad de filas moderada para cada tarea de etiquetado. Se recomiendan entre 10 y 20 filas por tarea, aunque se considera aceptable utilizar entre 2 y 30 filas. No se recomiendan tareas de más de 50 filas, ya que pueden generar resultados deficientes o errores en el sistema.
+ Si dispone de datos que ya están etiquetados y que se componen de pares de registros etiquetados como «coincidencia» o «no coincidencia», puede utilizarlos. Estos pares etiquetados pueden representarse como conjuntos de etiquetado de tamaño 2. En este caso, etiquete los dos registros, por ejemplo, con una letra «A» si coinciden y, si no coinciden, etiquete uno como «A» y otro como «B».
**nota**
Puesto que dispone de columnas adicionales, el archivo de etiquetado dispone de un esquema diferente de un archivo que contiene sus datos de origen. Coloque el archivo de etiquetado en una carpeta diferente de cualquier archivo CSV de entrada de transformación de manera que el rastreador de AWS Glue no lo tenga en cuenta cuando cree las tablas en el Catálogo de datos. De lo contrario, las tablas creadas por el rastreador de AWS Glue podrían representar incorrectamente sus datos.
+ AWS Glue requiere las dos primeras columnas (`labeling_set_id` y `label`). Las columnas restantes deben coincidir con el esquema de los datos que se van a procesar.
+ En cada `labeling_set_id`, debe identificar todos los registros coincidentes utilizando la misma etiqueta. Una etiqueta es una cadena única que se incluye en la columna `label`. Le recomendamos utilizar etiquetas que contengan caracteres simples, como A, B, C, etc. Las etiquetas distinguen mayúsculas y minúsculas y se colocan en la columna `label`.
+ Se entiende que las filas que contienen el mismo `labeling_set_id` y la misma etiqueta se etiquetan como coincidencia.
+ Se entiende que las filas que contienen el mismo `labeling_set_id` y una etiqueta diferente se etiquetan como *no* coincidencia.
+ Se entiende que las filas que contienen un `labeling_set_id` diferente no transmiten información que permita determinar si es o no una coincidencia.
A continuación se muestra un ejemplo de etiquetado de los datos:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/machine-learning.html)
+ En el ejemplo anterior identificamos a John/Johnny/Jon Doe como una coincidencia y enseñamos al sistema que estos registros no coinciden con Jane Smith. Por otro lado, enseñamos al sistema que Richard y Rich Jones son la misma persona, pero que estos registros no coinciden con Sarah Jones/Jones-Walker ni Richie Jones Jr.
+ Como puede ver, el alcance de las etiquetas está limitado por el `labeling_set_id`. Por lo tanto, las etiquetas no superan los límites de `labeling_set_id`. Por ejemplo, una etiqueta "A" en `labeling_set_id` 1 no tiene ninguna relación con la etiqueta "A" en `labeling_set_id` 2.
+ Si un registro no tiene coincidencias dentro de un conjunto de etiquetado, debe asignarle una etiqueta única. Por ejemplo, Jane Smith no coincide con ningún registro del conjunto de etiquetado ABC123, por lo que es el único registro de ese conjunto de etiquetado con la etiqueta B.
+ El conjunto de etiquetado «GHI678" demuestra que un conjunto de etiquetado puede componerse exclusivamente de dos registros a los que se les da la misma etiqueta para indicar que coinciden. Del mismo modo, «XYZABC» muestra dos registros con etiquetas diferentes para indicar que no coinciden.
+ Tenga en cuenta que a veces los conjuntos de etiquetado pueden no contener coincidencias (es decir, cada registro del conjunto de etiquetado tiene una etiqueta diferente) o tener todos los registros iguales (todos con la misma etiqueta). Esto es correcto siempre que, colectivamente, los conjuntos de etiquetado contengan ejemplos de registros que sean iguales y diferentes, según sus criterios.
**importante**
Confirme que el rol de IAM que transfiere a AWS Glue tenga acceso al bucket de Amazon S3 que contiene el archivo de etiquetado. Convencionalmente, las políticas de AWS Glue conceden permiso a buckets o carpetas de Amazon S3 cuyos nombres tienen el prefijo **aws-glue-**. Si sus archivos de etiquetado están en una ubicación distinta, agregue permiso a esa ubicación en el rol de IAM.
# Ajuste de transformaciones de machine learning en AWS Glue
Puede ajustar las transformaciones de machine learning en AWS Glue para mejorar los resultados de sus trabajos de limpieza de datos para cumplir sus objetivos. Para mejorar su transformación, puede enseñarle mediante la generación de un conjunto de etiquetas, la adición de etiquetas y, a continuación, la repetición de estos pasos varias veces hasta que disponga de los resultados deseados. También puede realizar el ajuste al modificar algunos parámetros de machine learning.
Para obtener más información sobre las transformaciones de machine learning, consulte [Coincidencia de registros con FindMatches de AWS Lake Formation](machine-learning.md).
**Topics**
+ [Mediciones de machine learning](machine-learning-terminology.md)
+ [Decidir entre precisión y exhaustividad](machine-learning-precision-recall-tradeoff.md)
+ [Decisión entre exactitud y costo](machine-learning-accuracy-cost-tradeoff.md)
+ [Estimación de la calidad de coincidencias mediante las puntuaciones de confianza de las coincidencias](match-scoring.md)
+ [Enseñanza de la transformación de búsqueda de coincidencias](machine-learning-teaching.md)
# Mediciones de machine learning
Para comprender las mediciones que se utilizan para ajustar la transformación de machine learning, debe estar familiarizado con la siguiente terminología:
**Verdadero positivo (VP)**
Una coincidencia en los datos que ha encontrado la transformación correctamente. Se denomina a veces "*acierto*".
**Verdadero negativo (VN)**
Una no coincidencia en los datos que la transformación ha rechazado correctamente.
**Falso positivo (FP)**
Una no coincidencia en los datos que la transformación clasificó erróneamente como una coincidencia, que, en ocasiones, se denomina *falsa alarma*.
**Falso negativo (FN)**
Una coincidencia en los datos que la transformación no encontró. Se denomina a veces "*fallo*".
Para obtener más información sobre la terminología que se utiliza en el machine learning, consulte [Confusion matrix (Matriz de confusión)](https://en.wikipedia.org/wiki/Confusion_matrix) en Wikipedia.
Para ajustar sus transformaciones de machine learning, puede cambiar el valor de las siguientes mediciones en la sección de **propiedades avanzadas** de la transformación.
+ **Precisión** mide qué tan bien la transformación encuentra verdaderos positivos entre el número total de registros que identifica como positivos (verdaderos positivos y falsos positivos). Para obtener más información, consulte [Precisión y exhaustividad](https://en.wikipedia.org/wiki/Precision_and_recall) en Wikipedia.
+ La **exhaustividad** mide la facilidad con la que de la transformación encuentra verdaderos positivos en los registros totales en los datos de origen. Para obtener más información, consulte [Precisión y exhaustividad](https://en.wikipedia.org/wiki/Precision_and_recall) en Wikipedia.
+ La**exactitud ** mide la facilidad con la que la transformación encuentra verdaderos positivos y verdaderos negativos. El aumento de la exactitud requiere más recursos informáticos y costos. Sin embargo, también genera una mayor exhaustividad. Para obtener más información, consulte [Precisión y exactitud](https://en.wikipedia.org/wiki/Accuracy_and_precision#In_information_systems) en Wikipedia.
+ El **costo** mide la cantidad de recursos informáticos y, por lo tanto, dinero, necesario para ejecutar la transformación.
# Decidir entre precisión y exhaustividad
Cada transformación`FindMatches` contiene un parámetro `precision-recall`. Utilice este parámetro para especificar una de las siguientes opciones:
+ Si está más preocupado por la transformación que indica falsamente que dos registros coinciden cuando realmente no lo hace, debe hacer hincapié en *precisión*.
+ Si está más preocupado por la transformación que no detecta correctamente los registros que coinciden, debe hacer hincapié en *exhaustividad*.
Puede realizar esta compensación en la consola de AWS Glue o mediante las operaciones de la API de machine learning de AWS Glue.
**Cuándo favorecer la precisión**
Favorezca la precisión si está más preocupado por el resigo que genera `FindMatches` en un par de registros que coinciden cuando realmente no coinciden. Para favorecer la precisión, elija un valor de compensación de precisión-exhaustividad *superior*. Con un valor más alto, la transformación `FindMatches` requiere más evidencias para decidir que un par de registros debe coincidir. La transformación se ajusta para sesgarse hacia una situación en la que los registros no coinciden.
Por ejemplo, supongamos que va a utilizar `FindMatches` para detectar elementos duplicados en un catálogo de vídeo y proporciona un valor de precisión-exhaustividad más alto para la transformación. Si su transformación detecta incorrectamente que *Star Wars: Una nueva esperanza* es igual que *Star Wars: El imperio contraataca*, es posible que el cliente que quiere *Una nueva esperanza* vea *El imperio contraataca*. Esto sería una experiencia del cliente deficiente.
Sin embargo, si la transformación no es capaz de detectar que *Star Wars: Una nueva esperanza* y *Star Wars: Episodio IV - Una nueva esperanza* son el mismo elemento, el cliente podría confundirse al principio pero podría reconocerlos como el mismo. Sería un error, pero no tan grave como la situación anterior.
**Cuándo favorecer la exhaustividad**
Favorezca la exhaustividad si está más preocupado por el riesgo de que se puedan producir errores en los resultados de la transformación `FindMatches` al detectar un par de registros que en realidad no coinciden. Para favorecer la exhaustividad, elija un valor de compensación de precisión-exhaustividad *inferior*. Con un valor más bajo, la transformación `FindMatches` requiere menos evidencias para decidir que un par de registros debe coincidir. La transformación se ajusta para sesgarse hacia una situación en la que los registros coinciden.
Por ejemplo, esto podría ser una prioridad para una organización de seguridad. Supongamos que quiere disponer de coincidencias de clientes en relación con una lista de defraudadores conocidos y es importante determinar si un cliente es un defraudador. Está utilizando `FindMatches` para que la lista de defraudadores coincida con la lista de clientes. Cada vez que `FindMatches` detecta una coincidencia entre las dos listas, se asigna un auditor humano para comprobar que la persona es, de hecho, un defraudador. Es posible que su organización prefiera para elegir la exhaustividad en lugar de la precisión. Es decir, puede emplear auditores para que revisen y rechacen manualmente algunos casos cuando el cliente no sea un defraudador en lugar de no poder identificar que un cliente está, de hecho, en la lista de defraudadores.
**Cómo favorecer tanto la precisión como la exhaustividad**
La mejor forma de mejorar tanto la precisión como la exhaustividad es etiquetar más datos. A medida que etiqueta más datos, mejora la exactitud global de la transformación `FindMatches` y, por lo tanto, tanto la precisión como la exhaustividad son superiores. Sin embargo, incluso con la transformación más precisa, siempre hay un área en gris que necesita experimentar para el favorecimiento de la precisión o la exhaustividad, o elegir un valor intermedio.
# Decisión entre exactitud y costo
Cada transformación `FindMatches` contiene un parámetro `accuracy-cost`. Puede utilizar este parámetro para especificar una de las siguientes opciones:
+ Si está más preocupado en que la transformación informe de forma exacta de que los dos registros coinciden, debe hacer hincapié en *exactitud*.
+ Si está más preocupado por el costo o la velocidad de ejecución de la transformación, debe hacer hincapié en *costo menor*.
Puede realizar esta compensación en la consola de AWS Glue o mediante las operaciones de la API de machine learning de AWS Glue.
**Cuando favorecer la exactitud**
Favorezca la exactitud si está más preocupado por el riesgo de que los resultados de `find matches` no contengan coincidencias. Para favorecer la exactitud, elija un valor de compensación de exactitud-costo *superior*. Con un volumen más alto, la transformación `FindMatches` requiere más tiempo para realizar una búsqueda más exhaustiva para que los registros coincidan correctamente. Tenga en cuenta que con este parámetro no es menos probable que se trate incorrectamente un par de registro no coincidente como coincidencia. La transformación se ajusta para sesgarse hacia una situación de dedicación de más tiempo a buscar coincidencias.
**Cuándo favorecer el costo**
Favorezca el costo si está más preocupado por el costo de ejecución de la transformación `find matches` y menos por la cantidad de coincidencias encontradas. Para favorecer el costo, elija un valor de compensación de exactitud-costo *inferior*. Con un valor inferior, la transformación `FindMatches` requiere menos recursos que ejecutar. La transformación se ajusta para sesgarse hacia una situación de búsqueda de menos coincidencias. Si los resultados son aceptables cuando se favorece el costo inferior, utilice esta configuración.
**Cómo favorecer tanto la exactitud como el costo bajo**
Es necesario más tiempo de procesamiento para examinar más pares de registros y determinar si deben ser coincidencias. Si desea reducir el costo sin reducir la calidad, estas son algunas medidas que puede adoptar:
+ Eliminación de registros en el origen de datos para el que lo le preocupa la coincidencia.
+ Eliminación de columnas de origen de datos de las que esté seguro de que no son útiles para crear una decisión de coincidencia/no coincidencia. Una buena forma de decidir esto es eliminar columnas que cree que no afectan a su propia decisión sobre si un conjunto de registros es "el mismo".
# Estimación de la calidad de coincidencias mediante las puntuaciones de confianza de las coincidencias
Las puntuaciones de confianza de coincidencias proporcionan una estimación de la calidad de las coincidencias encontradas por FindMatches para distinguir entre registros coincidentes en los que el modelo de machine learning es muy confiable, incierto o improbable. Una puntuación de confianza de coincidencia estará entre 0 y 1, donde una puntuación más alta significa mayor similitud. El análisis de las puntuaciones de confianza de coincidencias le permite distinguir entre grupos de coincidencias en los que el sistema tiene mucha confianza (que puede decidir fusionar), clústeres sobre los que el sistema no está seguro (que puede decidir hacer revisar por un humano) y clústeres que el sistema considera improbables (que puede decidir rechazar).
Es posible que quiera ajustar sus datos de formación en situaciones en las que vea una puntuación de confianza alta, pero determine que no hay coincidencias, o en las que vea una puntuación baja pero determine que sí hay, de hecho, coincidencias.
Las puntuaciones de confianza son especialmente útiles cuando hay conjuntos de datos industriales de gran tamaño, en los que no es factible revisar todas las decisiones de FindMatches.
Las puntuaciones de confianza de coincidencias están disponibles en AWS Glue, versión 2.0 o posterior.
## Generación de puntuaciones de confianza de coincidencias
Puede generar puntuaciones de confianza de coincidencias al establecer el valor booleano de `computeMatchConfidenceScores` a verdadero cuando llama a la API `FindMatches` o `FindIncrementalMatches`.
AWS Glue agrega una nueva `column match_confidence_score` al resultado.
## Ejemplos de puntuación de coincidencias
Por ejemplo, considere los siguientes registros coincidentes:
**Puntuación >=0,9**
Resumen de registros coincidentes:
```
primary_id | match_id | match_confidence_score
3281355037663 85899345947 0.9823658302132061
1546188247619 85899345947 0.9823658302132061
```
Detalles:
![\[Ejemplo de una tabla de ruteo con una gateway de Internet.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/match_score1.png)
En este ejemplo, podemos ver que dos registros son muy similares y comparten `display_position`, `primary_name` y `street name`.
**Puntuación >=0,8 y puntuación <0,9**
Resumen de registros coincidentes:
```
primary_id | match_id | match_confidence_score
309237680432 85899345928 0.8309852373674638
3590592666790 85899345928 0.8309852373674638
343597390617 85899345928 0.8309852373674638
249108124906 85899345928 0.8309852373674638
463856477937 85899345928 0.8309852373674638
```
Detalles:
![\[Ejemplo de una tabla de ruteo con una gateway de Internet.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/match_score2.png)
En este ejemplo, podemos ver que estos registros comparten el mismo `primary_name` y `country`.
**Puntuación >=0,6 y puntuación <0,7**
Resumen de registros coincidentes:
```
primary_id | match_id | match_confidence_score
2164663519676 85899345930 0.6971099896480333
317827595278 85899345930 0.6971099896480333
472446424341 85899345930 0.6971099896480333
3118146262932 85899345930 0.6971099896480333
214748380804 85899345930 0.6971099896480333
```
Detalles:
![\[Ejemplo de una tabla de ruteo con una gateway de Internet.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/match_score3.png)
En este ejemplo, podemos ver que estos registros comparten solo el mismo `primary_name`.
Para obtener más información, consulte:
+ [Paso 5: Agregar y ejecutar un trabajo con su transformación de machine learning.](machine-learning-transform-tutorial.md#ml-transform-tutorial-add-job)
+ PySpark: [Clase FindMatches](aws-glue-api-crawler-pyspark-transforms-findmatches.md)
+ PySpark: [Clase FindIncrementalMatches](aws-glue-api-crawler-pyspark-transforms-findincrementalmatches.md)
+ Scala: [Clase FindMatches](glue-etl-scala-apis-glue-ml-findmatches.md)
+ Scala: [Clase FindIncrementalMatches](glue-etl-scala-apis-glue-ml-findincrementalmatches.md)
# Enseñanza de la transformación de búsqueda de coincidencias
A las transformaciones `FindMatches` se les debe enseñar qué debe considerarse una coincidencia y qué no. Puede enseñar a su transformación mediante la adición de etiquetas en un archivo y la carga de sus opciones a AWS Glue.
Puede organizar esta etiqueta en la consola de AWS Glue o mediante las operaciones de la API de machine learning de AWS Glue.
**¿Cuántas veces debo añadir etiquetas? ¿Cuántas etiquetas necesito?**
Las respuestas a estas preguntas dependen principalmente de usted. Debe evaluar si `FindMatches` ofrece el nivel de exactitud que necesita y si cree que el esfuerzo de etiquetado adicional merece la pena. La mejor manera de decidir esto es analizar las métricas "Precisión", "Exhaustividad" y "Área bajo la curva de precisión-exhaustividad" que puede generar cuando elije **Estimate quality** (Estimar calidad) en la consola de AWS Glue. Después de etiquetar más conjuntos de tareas, vuelva a ejecutar esas métricas y compruebe si han mejorado. Si después del etiquetado de algunos conjuntos de tareas, no observa una mejora en la métrica en la que se está centrando, es posible que la calidad de la transformación se haya estabilizado.
**¿Por qué las etiquetas de verdadero positivo y verdadero negativo son necesarias?**
La transformación `FindMatches` precisa ejemplos positivos y negativos para aprender lo que cree que es una coincidencia. Si está etiquetando datos de entrenamiento generados por `FindMatches` (por ejemplo, mediante la opción **I do not have labels** [No tengo etiquetas]), `FindMatches` intenta generar un conjunto de "ID de conjuntos de etiquetas" para usted. Dentro de cada tarea, proporcione la misma "etiqueta" a algunos registros y diferentes "etiquetas" a otros. Es decir, por lo general, las tareas no son todas iguales o todas diferentes (pero es correcto si una tarea determinada es totalmente igual o es totalmente diferente).
Si está enseñando a su transformación `FindMatches` a usar la opción **Upload labels from S3** (Cargar etiquetas desde S3), intente incluir ambos ejemplos de registros de coincidencia y no coincidencia. Es aceptable disponer de solo un tipo. Estas etiquetas le ayudan a crear una transformación `FindMatches` más exacta, pero sigue necesitando etiquetas algunos registros que genera mediante la opción **Generate labeling file** (Generar archivo de etiquetado).
**¿Cómo puedo hacer que la transformación coincida exactamente de la forma que le he enseñado?**
La transformación `FindMatches` aprende a partir de las etiquetas que proporciona, por lo que puede generar pares de registros que no respeten las etiquetas proporcionadas. Para hacer que la transformación `FindMatches` respete las etiquetas, seleccione **EnforceProvidedLabels** en **FindMatchesParameter**.
**¿Qué técnicas puede usar cuando una transformación ML identifica elementos como coincidencias que no son coincidencias reales?**
Puede utilizar las siguientes técnicas:
+ Aumente `precisionRecallTradeoff` a un valor superior. Esto provoca finalmente que se encuentren menos coincidencias, pero también debe fragmentar su clúster de gran tamaño cuando alcance un valor lo suficientemente alto.
+ Elija las filas de salida correspondientes a los resultados incorrectos y vuelva a darles formato como conjunto de etiquetas (quitando la columna `match_id` y añadiendo una columna `labeling_set_id` y `label`). Si es necesario, fragmente (subdivida) en varios conjuntos de etiquetas para garantizar que la etiquetadora pueda mantener cada conjunto de etiquetas en cuenta mientras asigna etiquetas. A continuación, etiquete correctamente los conjuntos de coincidencia y cargue el archivo de etiquetas y anéxelo a sus etiquetas existentes. Esto podría enseñar a su transformador lo que necesita sobre lo que está buscando para entender el patrón.
+ (Avanzado) Por último, observe los datos para ver si existe un patrón del que el sistema no informa. Preprocese esos datos mediante funciones de AWS Glue estándar para *normalizar* los datos. Resalte lo que desee que el algoritmo aprenda mediante la separación de datos que sepa que tienen una importancia distinta en sus propias columnas. También puede crear columnas combinadas a partir de columnas con datos que sepa que están relacionados.
# Uso de transformaciones de machine learning
Puede utilizar AWS Glue para crear transformaciones de machine learning personalizadas que puedan utilizarse para limpiar sus datos. Puede usar estas transformaciones cuando cree un trabajo en la consola de AWS Glue.
Para obtener información sobre cómo crear una transformación de machine learning, consulte [Coincidencia de registros con FindMatches de AWS Lake Formation](machine-learning.md).
**Topics**
+ [Propiedades de transformación](#console-machine-learning-properties)
+ [Agregado y edición de transformaciones de machine learning](#console-machine-learning-transforms-actions)
+ [Visualización de los detalles de la transformación](#console-machine-learning-transforms-details)
+ [Cómo enseñar a las transformaciones mediante el uso de etiquetas](#console-machine-learning-transforms-teaching-transforms)
## Propiedades de transformación
Para ver una transformación de machine learning existente, 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/). En el panel de navegación, en **Integración de datos y ETL**, elija **Herramientas de clasificación de datos > Coincidencia de registros**.
Las propiedades de cada transformación:
**Transform name (Nombre de transformación)**
El nombre único que asignó a la transformación cuando la creó.
**ID**
Un ID único de la transformación.
**Recuento de etiquetas**
La cantidad de etiquetas en el archivo de etiquetado que se proporcionó para ayudar a enseñar a la transformación.
**Status**
Indica si la transformación tiene el estado **Ready (Listo)** o **Needs teaching (Necesita formación)**. Para ejecutar una transformación de machine learning correctamente en un trabajo, el estado debe ser **Ready (Listo)**.
**Created (Creado)**
La fecha en que se creó la transformación.
**Modificado**
La fecha en la que se actualizó por última vez la transformación.
**Descripción**
La descripción suministrada para la transformación, si se ha proporcionado una.
**AWS GlueVersión **
La versión de AWS Glue usada.
**ID de ejecución**
El nombre único que asignó a la transformación cuando la creó.
**Tipo de tarea**
El tipo de transformación de machine learning; por ejemplo, **Find matching records** (Búsqueda de registros de coincidencia).
**Status**
Indica el estado de la ejecución de la tarea. Entre las causas posibles se incluyen las siguientes:
+ Inicio
+ Ejecutar
+ Detención
+ Stopped
+ Realizado correctamente
+ Failed
+ Tiempo de espera
**Error**
Si el estado es Con error, aparece un mensaje de error que describe el motivo.
## Agregado y edición de transformaciones de machine learning
Puede ver, eliminar, configurar y enseñar, o ajustar una transformación en la consola de AWS Glue. Active la casilla de verificación junto a la transformación en la lista, elija **Action** (Acción) y, a continuación, seleccione la acción que desee realizar.
### Crear una nueva transformación de ML
Para agregar una nueva transformación de machine learning, elija **Crear transformación**. Siga las instrucciones en el asistente **Agregar trabajo**. Para obtener más información, consulte [Coincidencia de registros con FindMatches de AWS Lake Formation](machine-learning.md).
#### Paso 1. Configure propiedades de transformación
1. Ingrese el nombre y la descripción (opcional).
1. Si lo desea, establezca la configuración de seguridad. Consulte [Uso de cifrado de datos con transformaciones de machine learning](#ml_transform_sec_config).
1. Si lo desea, establezca la configuración de ejecución de tareas. La configuración de ejecución de tareas permite personalizar la forma en que se ejecuta la tarea. Seleccione el tipo de trabajador, el número de trabajadores, el tiempo de espera de la tarea (en minutos), el número de reintentos y la versión de AWS Glue.
1. Si lo desea, defina las etiquetas. Las etiquetas son marcas que asigna a un recurso de AWS. Cada etiqueta consta de una clave y un valor opcional. Las etiquetas se pueden usar para buscar y filtrar los recursos o hacer un seguimiento de los costos de AWS.
#### Paso 2. Elija la tabla y la clave principal.
1. Elija la base de datos y la tabla del catálogo de AWS Glue.
1. Elija una clave principal de la tabla seleccionada. La columna de clave principal normalmente contiene un identificador único para cada registro del origen de datos.
#### Paso 3. Seleccione las opciones de ajuste.
1. Para **Exhaustividad vs. precisión**, elija el valor de ajuste para la transformación y así favorecer la exhaustividad o la precisión. De forma predeterminada, está seleccionada la opción **Equilibrado**, pero puede elegir entre favorecer la exhaustividad o la precisión o bien elegir **Personalizado** e ingresar un valor entre 0,0 y 1,0 (ambos incluidos).
1. Para **menor costo vs. precisión**, elija el valor de ajuste que favorezca una reducción del costo o la precisión o bien elija **Personalizado** e ingrese un valor entre 0,0 y 1,0 (ambos incluidos).
1. Para **Forzar la coincidencia**, seleccione **Forzar la salida para que coincida con las etiquetas** si quiere enseñarle a la transformación de ML a que la salida coincida con las etiquetas utilizadas.
#### Paso 4. Revisar y crear.
1. Revise las opciones de los pasos 1 a 3.
1. Seleccione **Editar** para cualquier paso que necesite modificarse. Seleccione **Crear transformación** para completar el asistente de creación de transformaciones.
### Uso de cifrado de datos con transformaciones de machine learning
Al agregar una transformación de machine learning a AWS Glue, puede especificar opcionalmente una configuración de seguridad asociada con el origen de datos o el destino de datos. Si el bucket de Amazon S3 utilizado para almacenar los datos está cifrado con una configuración de seguridad, especifique la misma configuración de seguridad al crear la transformación.
También puede elegir utilizar el cifrado del lado del servidor con AWS KMS (SSE-KMS) para cifrar el modelo y las etiquetas, y así evitar la inspección de parte de personas no autorizadas. Si elige esta opción, se le pedirá que elija la opción AWS KMS key por nombre, o puede elegir **Enter a key ARN (Ingresar una clave de ARN)**. Si elige ingresar el ARN para la clave KMS, aparecerá un segundo campo en el que puede introducir el ARN de la clave KMS.
**nota**
En la actualidad, las transformaciones de ML que utilizan una clave de cifrado personalizada no son compatibles en las siguientes regiones:
Asia-Pacífico (Osaka): `ap-northeast-3`
## Visualización de los detalles de la transformación
### Visualización de las propiedades de transformación
La página de **Propiedades de la transformación** incluye los atributos de la transformación. Muestra los detalles sobre la definición de transformación, incluidos los siguientes:
+ **Transform name** (Nombre de transformación) muestra el nombre de la transformación.
+ **Type** (Tipo) muestra el tipo de transformación.
+ **Status** (Estado) muestra si la transformación ya se está usando en un script o trabajo.
+ **Force output to match labels** (Forzar resultado para que las etiquetas coincidan) muestra si la transformación fuerza el resultado para que las etiquetas proporcionadas por el usuario coincidan.
+ La **Spark version (versión de Spark)** se relaciona con la versión de AWS Glue que eligió en **Task run properties (Propiedades de ejecución de tarea)** al agregar la transformación. Se recomienda AWS Glue 1.0 y Spark 2.4 para la mayoría de los clientes. Para obtener más información, consulte [Versiones de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/release-notes.html#release-notes-versions).
### Pestañas Historial, Estimación de la calidad y Etiquetas
Los detalles de la transformación incluirán la información que definió al crear la transformación. Para ver los detalles de una transformación, seleccione la transformación en la lista **Machine learning transforms** (Transformaciones de machine learning) y revise la información en las siguientes pestañas:
+ Historial
+ Estimar calidad
+ Etiquetas
#### Historial
La pestaña **History** (Historial) muestra su historial de ejecuciones de tareas de transformación. Se ejecutan varios tipos de tareas para enseñar a una transformación. Para cada tarea, las métricas de ejecución incluyen lo siguiente:
+ El **Run ID** (ID de ejecución) es un identificador creado por AWS Glue para cada una de las ejecuciones de esta tarea.
+ **Task type** (Tipo de tarea) muestra el tipo de ejecución de tareas.
+ **Status** (Estado) muestra el éxito de cada tarea que aparece con la ejecución más reciente en la parte superior.
+ En **Error**, se muestran los detalles de un mensaje de error si la ejecución no se ha realizado correctamente.
+ En **Start time** (Hora de inicio) se muestra la fecha y la hora (hora local) en que se inició la tarea.
+ En **Hora de finalización** se muestra la fecha y la hora (hora local) en que finalizó la tarea.
+ **Logs (Registros)** se vincula a los registros escritos en `stdout` para esta ejecución de trabajo.
El enlace **Logs (Registros)** lo dirigirá a Amazon CloudWatch Logs. Aquí podrá ver los detalles sobre las tablas que creó en AWS Glue Data Catalog y los errores detectados. Puede administrar su periodo de retención de registros en la consola de CloudWatch. La retención de registros predeterminada es `Never Expire`. Para obtener más información sobre cómo cambiar el periodo de retención, consulte [Cambiar la retención de datos de registro en CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention) en la *Guía del usuario de Amazon CloudWatch Logs*.
+ En **Archivo de etiqueta** se muestra un enlace a Amazon S3 para un archivo de etiquetado generado.
#### Estimar calidad
La pestaña **Estimate quality** (Estimar calidad) muestra las métricas que utiliza para medir la calidad de la transformación. Las estimaciones se calculan al comparar las predicciones de coincidencia de transformación obtenidas a partir de un subconjunto de sus datos etiquetados con las etiquetas que ha proporcionado. Estas estimaciones son aproximadas. Puede invocar una ejecución de tareas de **estimación de calidad** para esta pestaña.
La pestaña **Estimar calidad** muestra las métricas de la última ejecución de **Estimar calidad** incluidas las siguientes propiedades:
+ **El área bajo la curva Precision-Recall (Precisión-exhaustividad)** es un único número que calcula el límite superior de la calidad general de la transformación. Es independiente de la elección realizada para el parámetro precisión-exhaustividad. Los valores más altos indican que cuenta con una compensación de precisión-exhaustividad más atractiva.
+ **Precision** (Precisión) indica la frecuencia con la que la transformación es correcta cuando predice una coincidencia.
+ **Recall upper limit** (Límite superior de exhaustividad) indica la frecuencia con la que la transformación predice la coincidencia en una coincidencia real.
+ **F1** indica la exactitud de la transformación entre 0 y 1, donde 1 es la mejor exactitud. Para obtener más información, consulte [Valor-F](https://en.wikipedia.org/wiki/F1_score) en Wikipedia.
+ La tabla **Column importance (Importancia de columnas)** muestra los nombres de columna y la puntuación de importancia para cada columna. La importancia de columna ayuda a comprender cómo contribuyen las columnas al modelo, al identificar qué columnas de los registros se están utilizando con mayor frecuencia para hacer la coincidencia. Estos datos pueden solicitarle que agregue o cambie el conjunto de etiquetas para aumentar o reducir la importancia de las columnas.
La columna Importance (Importancia) proporciona una puntuación numérica para cada columna, como un decimal no mayor que 1,0.
Para obtener más información sobre cómo comprender las estimaciones de calidad frente a verdadera calidad, consulte [Estimaciones de calidad frente a calidad integral (verdadero)](#console-machine-learning-quality-estimates-true-quality).
Para obtener más información sobre cómo ajustar su transformación, consulte [Ajuste de transformaciones de machine learning en AWS Glue](add-job-machine-learning-transform-tuning.md).
#### Estimaciones de calidad frente a calidad integral (verdadero)
AWS Glue estima la calidad de su transformación al presentar el modelo de machine learning interno con un número de pares de registros que proporcionó para las etiquetas de coincidencia, pero que el modelo no ha visto antes. Estas estimaciones de calidad son una función de la calidad del modelo de machine learning (que está influenciado por el número de registros que etiqueta para "enseñar" a la transformación). La recuperación integral o *verdadera* (que no se calcula automáticamente mediante la `ML transform`) también se ve influenciada por el mecanismo de filtrado de `ML transform` que propone una amplia variedad de posibles coincidencias con el modelo de machine learning.
Puede ajustar este método de filtrado principalmente al especificar el valor de ajuste **Costo inferior-exactitud**. A medida que este valor de ajuste se acerca al valor que favorece la **Exactitud**, el sistema realiza una búsqueda más completa y más cara de pares de registro que pueden ser coincidencias. Se ofrecen más pares de registro a su modelo de machine learning y la exhaustividad de verdad o integral de su `ML transform` se acerca a la métrica de exhaustividad estimada. Como resultado, los cambios en la calidad integral de las coincidencias, como resultado de los cambios en la compensación de costo/precisión de las coincidencias, normalmente no se verán reflejados en la estimación de calidad.
#### Etiquetas
Las etiquetas son marcas que asigna a un recurso de AWS. Cada etiqueta consta de una clave y un valor opcional. Las etiquetas se pueden usar para buscar y filtrar los recursos o hacer un seguimiento de los costos de AWS.
## Cómo enseñar a las transformaciones mediante el uso de etiquetas
Puede enseñar a la transformación de ML mediante etiquetas (ejemplos) al seleccionar **Enseñar transformación** en la página de detalles de la transformación de ML. Si enseña a su algoritmo de machine learning con ejemplos (denominados “etiquetas”), puede elegir las etiquetas existentes para usarlas o crear un archivo de etiquetado.
![\[La captura de pantalla muestra una pantalla de asistente para Enseñar a la transformación mediante el uso de etiquetas.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/machine-learning-teach-transform.png)
+ **Etiquetado**: si tiene etiquetas, elija **Tengo etiquetas**. Si no tiene etiquetas, puede continuar con el siguiente paso, es decir, generar un archivo de etiquetado.
+ **Generar un archivo de etiquetado**: AWS Glue extrae los registros de los datos de origen y sugiere posibles registros de coincidencias. Usted elige el bucket de Amazon S3 para almacenar el archivo de etiquetas generado. Elija **Generar archivo de etiquetado** para iniciar el proceso. Cuando haya terminado, elija **Descargar archivo de etiquetado**. El archivo descargado tendrá una columna de etiquetas en la que podrá rellenar las etiquetas.
+ **Cargar etiquetas desde Amazon S3**: elija el archivo de etiquetado completo del bucket de Amazon S3 en el que está almacenado el archivo de etiquetas. A continuación, elija agregar las etiquetas a las etiquetas existentes o sobrescribirlas. Seleccione **Cargar archivo de etiquetado desde Amazon S3**.
# Tutorial: creación de una transformación de machine learning con AWS Glue
Este tutorial le guiará a través de las acciones para crear y administrar una transformación de machine learning (ML) con AWS Glue. Antes de utilizar este tutorial, debe estar familiarizado con el uso de la consola de AWS Glue para añadir rastreadores y trabajos, y editar scripts. También debe estar familiarizado con la búsqueda y descarga de archivos en la consola de Amazon Simple Storage Service (Amazon S3).
En este ejemplo, se creará una transformación `FindMatches` para encontrar los registros coincidentes, enseñarle cómo identificar registros de coincidencia y no coincidencia, y utilizarla en un trabajo de AWS Glue. El trabajo de AWS Glue escribe un nuevo archivo de Amazon S3 con una columna adicional denominada `match_id`.
En este tutorial se ha utilizado un archivo denominado como dato de origen `dblp_acm_records.csv`. Este archivo es una versión modificada de publicaciones académicas (DBLP y ACM) disponible a partir del [conjunto de datos de DBLP y ACM](https://doi.org/10.3886/E100843V2) original. El archivo `dblp_acm_records.csv` es un archivo de valores separados por comas (CSV) en formato UTF-8 sin marca de orden de bytes (BOM).
El segundo archivo `dblp_acm_labels.csv`, es un archivo de etiquetado de ejemplo que contiene registros de coincidencia y no coincidencia utilizados para enseñar a la transformación como parte del tutorial.
**Topics**
+ [Paso 1: Rastrear los datos de origen](#ml-transform-tutorial-crawler)
+ [Paso 2: Agregar una transformación de machine learning](#ml-transform-tutorial-create)
+ [Paso 3: Agregar una transformación de machine learning](#ml-transform-tutorial-teach)
+ [Paso 4: Calcular la calidad de su transformación de machine learning](#ml-transform-tutorial-estimate-quality)
+ [Paso 5: Agregar y ejecutar un trabajo con su transformación de machine learning.](#ml-transform-tutorial-add-job)
+ [Paso 6: Verificar los datos de salida desde Amazon S3](#ml-transform-tutorial-data-output)
## Paso 1: Rastrear los datos de origen
En primer lugar, rastree el archivo CSV de Amazon S3 de origen para crear una tabla de metadatos correspondiente en el Data Catalog.
**importante**
Para dirigir el rastreador para crear una tabla únicamente para el archivo CSV, almacene los datos de origen de CSV en una carpeta de Amazon S3 diferente de los demás archivos.
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, elija **Crawlers** (Rastreadores) y **Add crawler** (Añadir rastreador).
1. Siga el asistente para crear y ejecutar un rastreador denominado `demo-crawl-dblp-acm` con salida a la base de datos `demo-db-dblp-acm`. Cuando ejecute el asistente, cree la base de datos `demo-db-dblp-acm` si no existe todavía. Elija una ruta de inclusión de Amazon S3 a los datos de ejemplo en la región de AWS actual. Por ejemplo, en el caso de `us-east-1`, la ruta de inclusión de Amazon S3 para el archivo de origen es `s3://ml-transforms-public-datasets-us-east-1/dblp-acm/records/dblp_acm_records.csv`.
Si se ejecuta correctamente, el rastreador crea la tabla `dblp_acm_records_csv` con las siguientes columnas: id, title (título), authors (autores), venue (lugar), year (año) y source (origen).
## Paso 2: Agregar una transformación de machine learning
A continuación, agregue una transformación de machine learning que se base en el esquema de la tabla de origen de datos creada por el rastreador denominada `demo-crawl-dblp-acm`.
1. En la consola de AWS Glue, en el panel de navegación, en la sección **Integración de datos y ETL**, seleccione **Herramientas de clasificación de datos > Coincidencia de registros** y, a continuación, **Agregar transformación**. Siga el asistente para crear una transformación `Find matches` con las siguientes propiedades.
1. En **Transform name** (Nombre de transformación), escriba **demo-xform-dblp-acm**. Este es el nombre de la transformación que se utiliza para buscar coincidencias en los datos de origen.
1. En **IAM role (Rol de IAM)** elija un rol de IAM que tenga permiso para los datos de origen de Amazon S3, el archivo de etiquetado y las operaciones de la API de AWS Glue. Para obtener más información, consulte [Creación de un rol de IAM para AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/create-an-iam-role.html) en la *Guía para desarrolladores de AWS Glue*.
1. En **Data source** (Origen de datos), elija la tabla denominada **dblp\$1acm\$1records\$1csv** en la base de datos **demo-db-dblp-acm**.
1. En **Primary key** (Clave principal), elija la columna de clave principal para la tabla, **id**.
1. En el asistente, elija **Finish** (Finalizar) y vuelva a la lista **ML transforms** (Transformaciones de ML).
## Paso 3: Agregar una transformación de machine learning
A continuación, debe enseñar a su transformación de machine learning a usar el archivo de etiquetado de ejemplo del tutorial.
No puede utilizar una transformación de lenguaje automático en un trabajo de extracción, transformación y carga (ETL) hasta que el estado sea **Ready for use** (Listo para su uso). Para que la transformación esté preparada, debe enseñarle cómo identificar registros de coincidencia y no coincidencia mediante el ofrecimiento de ejemplos de registros de coincidencia y no coincidencia. Para enseñar a su transformación, puede **generar un archivo de etiquetas**, añadir etiquetas y, a continuación, **subir un archivo de etiquetas**. En este tutorial, puede utilizar el archivo de etiquetado de ejemplo denominado `dblp_acm_labels.csv`. Para obtener más información sobre el proceso de etiquetado, consulte [Etiquetado](machine-learning.md#machine-learning-labeling).
1. En el panel de navegación de la consola de AWS Glue, elija **Coincidencia de registros**.
1. Elija la transformación `demo-xform-dblp-acm` y, a continuación, elija **Action** (Acción) y **Teach** (Enseñar). Siga el asistente para enseñar a su transformación `Find matches`.
1. En la página de propiedades de transformación, elija **I have labels** (Tengo etiquetas). Elija una ruta de Amazon S3 al archivo de etiquetado de ejemplo en la región de AWS actual. Por ejemplo, para `us-east-1`, cargue el archivo de etiquetado proporcionado de la ruta de Amazon S3 `s3://ml-transforms-public-datasets-us-east-1/dblp-acm/labels/dblp_acm_labels.csv` con la opción **overwrite (sobreescribir)** las etiquetas existentes. El archivo de etiquetado debe estar ubicado en Amazon S3 en la misma región que la consola de AWS Glue.
Al cargar un archivo de etiquetado, se inicia una tarea en AWS Glue para añadir o sobrescribir las etiquetas utilizadas para enseñar a la transformación cómo procesar el origen de datos.
1. En la última página del asistente, elija **Finish** (Finalizar), y vuelva a la lista **ML transforms** (Transformaciones de ML).
## Paso 4: Calcular la calidad de su transformación de machine learning
A continuación, puede estimar la calidad de su transformación de machine learning. La calidad depende de la cantidad de etiquetado que acaba de realizar. Para obtener más información sobre la calidad de estimación, consulte [Estimar calidad](console-machine-learning-transforms.md#console-machine-learning-transforms-metrics).
1. En la consola de AWS Glue, en el panel de navegación, en **Integración de datos y ETL**, seleccione **Herramientas de clasificación de datos > Coincidencia de registros**.
1. Elija la transformación `demo-xform-dblp-acm` y elija la pestaña **Estimate quality** (Estimar calidad). Esta pestaña muestra las estimaciones de calidad actuales, si estuvieran disponibles, para la transformación.
1. Elija **Estimate quality** (Estimar calidad) para iniciar una tarea para estimar la calidad de la transformación. La exactitud de la estimación de calidad se basa en el etiquetado de los datos de origen.
1. Diríjase a la pestaña **History** (Historial). En este panel, aparecen las ejecuciones de tareas para la transformación, incluida la tarea de **Estimating quality** (Estimación de calidad). Para obtener más información sobre la ejecución, elija **Logs** (Registros). Compruebe que el estado de ejecución sea **Suceeded** (Correcto) cuando finalice.
## Paso 5: Agregar y ejecutar un trabajo con su transformación de machine learning.
En este paso, utilice la transformación de machine learning para agregar y ejecutar un trabajo en AWS Glue. Cuando la transformación `demo-xform-dblp-acm` esté **lista para su uso**, podrá utilizarla en un trabajo de ETL.
1. En el panel de navegación de la consola de AWS Glue, seleccione **Jobs** (Trabajos).
1. Elija **Add job** (Añadir trabajo) y siga los pasos en el asistente para crear un trabajo de ETL Spark con un script generado. Elija los siguientes valores de propiedad para su transformación:
1. En **Name** (Nombre), elija el trabajo de ejemplo en este tutorial, **demo-etl-dblp-acm**.
1. En **IAM role (Rol de IAM)**, elija un rol de IAM con permiso para los datos de origen de Amazon S3, el archivo de etiquetado y las operaciones de la API de AWS Glue. Para obtener más información, consulte [Creación de un rol de IAM para AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/create-an-iam-role.html) en la *Guía para desarrolladores de AWS Glue*.
1. En **ETL language** (Lenguaje de ETL), elija **Scala**. Este es el lenguaje de programación en el script de ETL.
1. En **Script file name** (Nombre de archivo de script), elija **demo-etl-dblp-acm**. Este es el nombre de archivo del script de Scala (mismo nombre de archivo).
1. En **Data source** (Origen de datos), elija **dblp\$1acm\$1records\$1csv**. El origen de datos que elija debe coincidir con el esquema de origen de datos de transformación de machine learning.
1. En **Transform type** (Tipo de transformación), elija **Find matching records** (Buscar registros de coincidencia) para crear un trabajo mediante una transformación de machine learning.
1. Borre **Remove duplicate records** (Eliminar registros duplicados). No quiere eliminar registros duplicados porque los registros de salida escritos disponen de un campo `match_id` adicional añadido.
1. En **Transform** (Transformación), elija **demo-xform-dblp-acm**, la transformación de machine learning utilizada por el trabajo.
1. En **Create tables in your data target** (Crear tablas en su destino de datos), elija crear tablas con las siguientes propiedades:
+ **Data store type (Tipo de almacén de datos** — **Amazon S3**
+ **Format** (Formato): **CSV**
+ **Compression type (Tipo de compresión** — **None**
+ **Target path (Ruta de destino)**: la ruta de Amazon S3 donde se escribe la salida del trabajo (en la región de AWS de la consola actual)
1. Elija **Save job and edit script** (Guardar trabajo y editar script) para mostrar la página del editor de scripts.
1. Edite el script para añadir una instrucción para que la salida del trabajo en **Target path** (Ruta de destino) se sobrescriba en un archivo de partición único. Añada esta instrucción inmediatamente después de la instrucción que ejecuta la transformación `FindMatches`. La instrucción es similar a la siguiente.
```
val single_partition = findmatches1.repartition(1)
```
Debe modificar la instrucción `.writeDynamicFrame(findmatches1)` para escribir la salida como `.writeDynamicFrame(single_partion)`.
1. Después de editar el script, elija **Save** (Guardar). El script modificado tiene un aspecto similar al siguiente código, pero se personaliza para su entorno.
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.ml.FindMatches
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]) {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
// @params: [JOB_NAME]
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
// @type: DataSource
// @args: [database = "demo-db-dblp-acm", table_name = "dblp_acm_records_csv", transformation_ctx = "datasource0"]
// @return: datasource0
// @inputs: []
val datasource0 = glueContext.getCatalogSource(database = "demo-db-dblp-acm", tableName = "dblp_acm_records_csv", redshiftTmpDir = "", transformationContext = "datasource0").getDynamicFrame()
// @type: FindMatches
// @args: [transformId = "tfm-123456789012", emitFusion = false, survivorComparisonField = "", transformation_ctx = "findmatches1"]
// @return: findmatches1
// @inputs: [frame = datasource0]
val findmatches1 = FindMatches.apply(frame = datasource0, transformId = "tfm-123456789012", transformationContext = "findmatches1", computeMatchConfidenceScores = true)
// Repartition the previous DynamicFrame into a single partition.
val single_partition = findmatches1.repartition(1)
// @type: DataSink
// @args: [connection_type = "s3", connection_options = {"path": "s3://aws-glue-ml-transforms-data/sal"}, format = "csv", transformation_ctx = "datasink2"]
// @return: datasink2
// @inputs: [frame = findmatches1]
val datasink2 = glueContext.getSinkWithFormat(connectionType = "s3", options = JsonOptions("""{"path": "s3://aws-glue-ml-transforms-data/sal"}"""), transformationContext = "datasink2", format = "csv").writeDynamicFrame(single_partition)
Job.commit()
}
}
```
1. Elija **Run job** (Ejecutar trabajo) para iniciar la ejecución de trabajo. Compruebe el estado del trabajo en la lista de trabajos. Cuando el trabajo finaliza, en **ML transform** (Transformación ML), en la pestaña **History** (Historial), habrá una nueva fila **Run ID** (ID de ejecución) añadida al tipo **ETL job** (Trabajo de ETL).
1. Diríjase a **Jobs** (Trabajos), pestaña **History** (Historial). En este panel, aparecen las ejecuciones de trabajo. Para obtener más información sobre la ejecución, elija **Logs** (Registros). Compruebe que el estado de ejecución sea **Suceeded** (Correcto) cuando finalice.
## Paso 6: Verificar los datos de salida desde Amazon S3
En este paso, verificará la salida de la ejecución de trabajo en el bucket de Amazon S3 que elija cuando agregue el trabajo. Puede descargar el archivo de salida en su máquina local y verificar que se identificaron los registros de coincidencia.
1. Abra la consola de Amazon S3 en [https://console.aws.amazon.com/s3](https://console.aws.amazon.com/s3/).
1. Descargue el archivo de salida de destino del trabajo `demo-etl-dblp-acm`. Abra el archivo en una aplicación de hoja de cálculo (es posible que tenga que añadir una extensión de archivo `.csv` para que el archivo se abra correctamente).
La imagen siguiente muestra un fragmento de la salida en Microsoft Excel.
![\[Hoja de cálculo de Excel que muestra la salida de la transformación.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/demo_output_dblp_acm.png)
El archivo de origen y destino de datos tiene 4911 registros. Sin embargo, la transformación `Find matches` añade otra columna denominada `match_id` para identificar registros de coincidencia en la salida. Las filas con el mismo `match_id` se consideran registros de coincidencia. La `match_confidence_score` es un número entre 0 y 1 que proporciona una estimación de la calidad de las coincidencias encontradas por `Find matches`.
1. Ordene el archivo de salida por `match_id` para ver fácilmente qué registros son coincidencias. Compare los valores en las demás columnas para ver si acepta los resultados de la transformación `Find matches`. Si no es así, puede seguir enseñando a la transformación mediante la adición de más etiquetas.
También puede ordenar el archivo por otro campo, como `title`, para ver si los registros con títulos similares tienen el mismo `match_id`.
# Búsqueda de coincidencias progresivas
La característica de búsqueda de coincidencias permite identificar registros duplicados o coincidentes en el conjunto de datos, incluso cuando los registros no tienen un identificador único común y no coinciden exactamente los campos. La versión inicial de búsqueda de coincidencia transforma los registros coincidentes identificados dentro de un único conjunto de datos. Cuando agregó datos nuevos al conjunto de datos, tuvo que fusionarlo con el conjunto de datos limpio existente y volver a ejecutar la coincidencia con el conjunto de datos fusionado completo.
La característica de coincidencia progresiva facilita la coincidencia con los registros progresivos con respecto a los conjuntos de datos coincidentes existentes. Suponga que desea asociar los datos de los clientes potenciales con los conjuntos de datos de clientes existentes. La capacidad de coincidencia progresiva proporciona la flexibilidad de asociar cientos de miles de nuevos clientes potenciales con una base de datos existente de clientes potenciales y clientes existentes mediante la fusión de los resultados en una única base de datos o tabla. Al hacer coincidir solo entre los conjuntos de datos nuevos y existentes, la optimización de búsqueda de coincidencias progresivas reduce el tiempo de cálculo, lo que también reduce los costos.
La utilización de la coincidencia progresiva es similar a la búsqueda de coincidencias tal como se describe en [Tutorial: creación de una transformación de machine learning con AWS Glue](machine-learning-transform-tutorial.md). En este tema, se identifican únicamente las diferencias con la coincidencia progresiva.
Para obtener más información, consulte la publicación del blog de [Coincidencia progresiva de datos](https://aws.amazon.com/blogs/big-data/incremental-data-matching-using-aws-lake-formation/).
## Ejecución de un trabajo de coincidencia progresiva
Para el siguiente procedimiento, suponga lo siguiente:
+ Se ha rastreado el conjunto de datos existente y los resultados se han pasado a la tabla *first\$1records*. El conjunto de datos de *first\$1records* debe ser un conjunto de datos coincidente, o bien el resultado del trabajo coincidente.
+ Se ha creado y entrenado una transformación de FindMatches con AWS Glue versión 2.0. Esta es la única versión de AWS Glue que soporta coincidencias progresivas.
+ El lenguaje de ETL es Scala. Tenga en cuenta que también se soporta Python.
+ El modelo ya generado se denomina `demo-xform`.
1. Rastree el conjunto de datos progresivo hasta la tabla *second\$1records*.
1. En el panel de navegación de la consola de AWS Glue, seleccione **Jobs** (Trabajos).
1. Elija **Add job** (Añadir trabajo) y siga los pasos en el asistente para crear un trabajo de ETL Spark con un script generado. Elija los siguientes valores de propiedad para su transformación:
1. Para **Name (Nombre)**, elija **demo-etl**.
1. En **IAM role (Rol de IAM)**, elija un rol de IAM con permiso para los datos de origen de Amazon S3, el archivo de etiquetado y las [operaciones de la API de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/create-an-iam-role.html).
1. En **ETL language** (Lenguaje de ETL), elija **Scala**.
1. En **Script file name (Nombre de archivo de script)**, elija **demo-etl**. Este es el nombre de archivo del script de Scala.
1. Para **Data source (Origen de datos)**, elija **first\$1records**. El origen de datos que elija debe coincidir con el esquema de origen de datos de transformación de machine learning.
1. En **Transform type** (Tipo de transformación), elija **Find matching records** (Buscar registros de coincidencia) para crear un trabajo mediante una transformación de machine learning.
1. Seleccione la opción de coincidencia progresiva y para **Data source (Origen de datos)**, seleccione la tabla denominada **second\$1records**.
1. En **Transform (Transformación)**, elija **demo-xform**, la transformación de machine learning utilizada por el trabajo.
1. Elija **Create tables in your data target (Crear tablas en el destino de datos)** o **Use tables in the data catalog and update your data target (Utilizar tablas en el Catálogo de datos y actualizar el destino de datos)**.
1. Elija **Save job and edit script** (Guardar trabajo y editar script) para mostrar la página del editor de scripts.
1. Elija **Run job** (Ejecutar trabajo) para iniciar la ejecución de trabajo.
# Uso de FindMatches en un trabajo visual
Para usar la transformación **FindMatches** en AWS Glue Studio, puede usar el nodo **Custom Transform** que invoca la API FindMatches. Para obtener más información sobre cómo usar una transformación personalizada, consulte [Crear una transformación personalizada](https://docs.aws.amazon.com/glue/latest/ug/transforms-custom.html).
**nota**
Actualmente, la API FindMatches solo funciona con `Glue 2.0`. Para ejecutar un trabajo con la transformación personalizada que invoca la API FindMatches, asegúrese de que la versión de AWS Glue sea `Glue 2.0` en la pestaña **Detalles del trabajo**. Si la versión de AWS Glue no es `Glue 2.0`, el trabajo fallará en tiempo de ejecución y mostrará el siguiente mensaje de error: “no se puede importar el nombre 'FindMatches' de 'awsglueml.transforms'”.
## Requisitos previos
+ Para utilizar la transformación **FindMatches** abra la consola de AWS Glue Studio en [https://console.aws.amazon.com/gluestudio/](https://console.aws.amazon.com/gluestudio/).
+ Cree una transformación de machine learning. Cuando se crea, se genera un transformld. Para realizar los pasos que se indican a continuación, necesitará este ID. Para obtener más información sobre cómo crear una transformación de machine learning, consulte [Agregar y editar transformaciones de machine learning](https://docs.aws.amazon.com/glue/latest/dg/console-machine-learning-transforms.html#console-machine-learning-transforms-actions).
## Agregar una transformación de FindMatches
**Para agregar una transformación de FindMatches:**
1. En el editor de trabajos de AWS Glue Studio, abra el panel de recursos mediante un clic en el símbolo de la cruz situado en la esquina superior izquierda del gráfico visual del trabajo y elija un origen de datos en la **pestaña Datos**. Este es el origen de datos en el que desea comprobar si hay coincidencias.
![\[En la captura de pantalla se muestra un símbolo de cruz dentro de un círculo. Al hacer clic en él en el editor visual de tareas, se abre el panel de recursos.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/resource-panel-blank-canvas.png)
1. Seleccione el nodo del origen de datos y, a continuación, abra el panel de recursos mediante un clic en el símbolo de la cruz situado en la esquina superior izquierda del gráfico visual del trabajo y busque “transformación personalizada”. Elija el nodo **Transformación personalizada** para agregarlo al gráfico. La **transformación personalizada** está vinculada al nodo de origen de datos. Si no lo está, puede hacer clic en el nodo **Transformación personalizada** y elegir la pestaña **Propiedades del nodo** y, a continuación, en **Nodos principales**, elegir el origen de datos.
1. Haga clic en el nodo **Transformación personalizada** del gráfico visual y, a continuación, seleccione la pestaña **Propiedades del nodo** y asigne un nombre a la transformación personalizada. Se recomienda cambiar el nombre de la transformación para que el nombre de la transformación sea fácilmente identificable en el gráfico visual.
1. Seleccione la pestaña **Transformación**, donde podrá editar el bloque de código. Aquí es donde se puede agregar el código para invocar la API FindMatches.
![\[En la captura de pantalla, se muestra el bloque de código en la pestaña Transformar cuando se selecciona el nodo Transformación personalizada.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/custom-transform-code-block.png)
El bloque de código contiene código rellenado previamente para que pueda empezar. Sobrescriba el código rellenado previamente con la plantilla que se muestra a continuación. La plantilla tiene un marcador de posición para el **transformId**, que puede proporcionar.
```
def MyTransform (glueContext, dfc) -> DynamicFrameCollection:
dynf = dfc.select(list(dfc.keys())[0])
from awsglueml.transforms import FindMatches
findmatches = FindMatches.apply(frame = dynf, transformId = "")
return(DynamicFrameCollection({"FindMatches": findmatches}, glueContext))
```
1. Haga clic en el nodo **Transformación personalizada** en el gráfico visual y, a continuación, abra el panel de recursos mediante un clic en el símbolo de la cruz situado en la esquina superior izquierda del gráfico visual del trabajo y busque “Seleccionar de la colección”. No es necesario cambiar la selección predeterminada, ya que solo hay un DynamicFrame en la colección.
1. Puede seguir agregando transformaciones o almacenar el resultado, que ahora está enriquecido con las columnas adicionales de búsqueda de coincidencias. Si desea hacer referencia a esas nuevas columnas en las transformaciones posteriores, debe agregarlas al esquema de salida de la transformación. La forma más sencilla de hacerlo es elegir la pestaña de **vista previa de datos** y, a continuación, en la pestaña de esquema, elegir “Usar esquema de vista previa de datos”.
1. Para personalizar FindMatches, puede agregar parámetros adicionales para pasarlos al método 'aplicar'. Consulte [Clase FindMatches](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-pyspark-transforms-findmatches.html).
## Agregar una transformación de FindMatches de forma incremental
En el caso de coincidencias incrementales, el proceso es el mismo que el de **Agregar una transformación FindMatches** con las siguientes diferencias:
+ En lugar de un nodo principal para la transformación personalizada, necesita dos nodos principales.
+ El primer nodo principal debe ser el conjunto de datos.
+ El segundo nodo principal debe ser el conjunto de datos incremental.
Sustituya `transformId` con su `transformId` en la plantilla de bloque de código:
```
def MyTransform (glueContext, dfc) -> DynamicFrameCollection:
dfs = list(dfc.values())
dynf = dfs[0]
inc_dynf = dfs[1]
from awsglueml.transforms import FindIncrementalMatches
findmatches = FindIncrementalMatches.apply(existingFrame = dynf, incrementalFrame = inc_dynf,
transformId = "")
return(DynamicFrameCollection({"FindMatches": findmatches}, glueContext))
```
+ Para ver los parámetros opcionales, consulte [Clase FindIncrementalMatches](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-pyspark-transforms-findincrementalmatches.html).
# Migrar programas de Apache Spark a AWS Glue
Apache Spark es una plataforma de código abierto para cargas de trabajo de computación distribuidas que se realizan en conjuntos de datos de gran tamaño. AWS Glue aprovecha las capacidades de Spark para ofrecer una experiencia de ETL optimizada. Puede migrar programas de Spark a AWS Glue para aprovechar nuestras características. AWS Glue proporciona las mismas mejoras de rendimiento que cabría esperar de Apache Spark en Amazon EMR.
## Ejecutar código Spark
El código nativo Spark se puede ejecutar en un entorno de AWS Glue directamente. Los scripts a menudo se desarrollan al cambiar iterativamente un fragmento de código, un flujo de trabajo adecuado para una sesión interactiva. No obstante, el código existente es más adecuado para su ejecución en un trabajo de AWS Glue, que permite programar y obtener sistemáticamente registros y métricas para cada ejecución de script. Puede cargar y editar un script existente mediante la consola.
1. Adquiera el origen de su script. Para este ejemplo, utilizará un script de muestra del repositorio de Apache Spark. [Ejemplo de binarizer](https://github.com/apache/spark/blob/master/examples/src/main/python/ml/binarizer_example.py)
1. En la consola de AWS Glue, expanda el panel de navegación izquierdo y seleccione **ETL** > **Jobs** (Trabajos)
En el panel **Create job** (Crear trabajo), seleccione**Spark script editor** (Editor de scripts de Spark). Aparecerá la sección **Options** (Opciones). En **Options** (Opciones), elija **Upload and edit an existing script** (Cargar y editar un script existente).
Aparecerá la sección **File upload** (Cargar archivo). En **File upload** (Cargar archivo), haga clic en **Choose file** (Elegir archivo). Aparecerá el selector de archivos del sistema. Vaya hasta la ubicación donde guardó `binarizer_example.py`, selecciónelo y confirme la opción elegida.
Aparecerá el botón **Create** (Crear) en el encabezado del panel **Create job** (Crear trabajo). Haga clic allí.
![\[Página Jobs (Trabajos) de AWS Glue Studio con el panel del editor de scripts de Spark seleccionado.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/migrate-apache-spark-01-upload-job.png)
1. El navegador irá hasta el editor de scripts. En el encabezado, haga clic en la pestaña **Job details** (Detalles del trabajo). Defina el **nombre** y el **Rol de IAM**. Para obtener información sobre los roles de IAM de AWS Glue, consulte [Configuración de permisos de IAM para AWS Glue](set-up-iam.md).
Opcionalmente: configure **Requested number of workers** (Cantidad solicitada de trabajadores) en `2` y **Number of retries** (Cantidad de reintentos) en `1`. Estas opciones son valiosas a la hora de ejecutar trabajos de producción, pero rechazarlas agilizará la experiencia mientras prueba una función.
En la barra de navegación, haga clic en **Save** (Guardar), luego en **Run** (Ejecutar)
![\[La página de detalles del trabajo con las opciones establecidas según las instrucciones.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/migrate-apache-spark-02-job-details.png)
1. Vaya a la pestaña **Runs ** (Ejecuciones). Verá un panel correspondiente a la ejecución de su trabajo. Espere unos minutos y la página deberá actualizarse automáticamente para mostrar **Succeeded** (Exitoso) en **Run status** (Estado de la ejecución).
![\[La página de ejecuciones de trabajos con una ejecución de trabajo exitosa.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/migrate-apache-spark-03-job-runs.png)
1. Deberá examinar la salida para confirmar que el script de Spark se ejecutó según lo previsto. Este script de ejemplo de Apache Spark debe escribir una cadena en la secuencia de salida. Puede encontrarlo yendo a **Output logs** (Registros de salida) en **Registros de Cloudwatch** (Cloudwatch logs) en el panel para la ejecución correcta del trabajo. Tenga en cuenta el id de ejecución de trabajo, un id generado en la etiqueta **Id** (Identificador) que comienza con `jr_`.
Esto abrirá la consola de CloudWatch, configurada para visualizar el contenido del AWS Gluegrupo de registro`/aws-glue/jobs/output` predeterminado, filtrado al contenido de los flujos de registro para el identificador de ejecución del trabajo. Cada trabajador habrá generado un flujo de registro, que se muestra como filas en **Log streams** (Flujos de registro). Un trabajador debería haber ejecutado el código solicitado. Deberá abrir todos los flujos de registro para identificar al trabajador correcto. Una vez que encuentre el trabajador correcto, se debería ver la salida del script, como se ve en la siguiente imagen:
![\[La página de la consola de CloudWatch con la salida del programa Spark.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/migrate-apache-spark-04-log-output.png)
## Procedimientos comunes necesarios para migrar programas Spark
### Evaluar el soporte de la versión de Spark
Las versiones de AWS Glue determinan la versión de Apache Spark y Python disponible para el trabajo de AWS Glue. Puede encontrar nuestras versiones de AWS Glue y lo que admiten en [AWS GlueVersiones de](release-notes.md#release-notes-versions). Es posible que tenga que actualizar el programa de Spark para que sea compatible con una versión más reciente de Spark con el fin de acceder a determinadas características de AWS Glue.
### Incluir bibliotecas de terceros
Muchos programas de Spark existentes tendrán dependencias, tanto en artefactos privados como públicos. AWS Glue admite dependencias de estilo JAR para trabajos de Scala, así como dependencias Wheel y de origen puro de Python para trabajos de Python.
**Python**: para obtener información sobre las dependencias de Python, consulte [Uso de bibliotecas de Python con AWS Glue](aws-glue-programming-python-libraries.md)
Las dependencias habituales de Python se proporcionan en el entorno de AWS Glue, incluida la biblioteca [Pandas](https://pandas.pydata.org/) que se suele solicitar. Estas dependencias se incluyen en AWS Glue versión 2.0\$1. Para obtener más información sobre los módulos proporcionados, consulte [Módulos de Python que ya se proporcionaron en AWS](aws-glue-programming-python-libraries.md#glue-modules-provided). Si necesita suministrar un trabajo con una versión diferente de una dependencia incluida de manera predeterminada, puede utilizar `--additional-python-modules`. Para obtener información sobre argumentos de trabajo, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md).
Puede proporcionar dependencias de Python adicionales con el argumento de trabajo `--extra-py-files`. Si va a migrar un trabajo desde un programa de Spark, este parámetro es una buena opción porque equivale funcionalmente al indicador `--py-files` de PySpark y está sujeto a las mismas limitaciones. Para obtener más información sobre el parámetro `--extra-py-files`, consulte [Inclusión de archivos de Python con características nativas de PySpark](aws-glue-programming-python-libraries.md#extra-py-files-support)
Para los nuevos trabajos, puede administrar las dependencias de Python con el argumento de trabajo `--additional-python-modules`. El uso de este argumento permite una experiencia de administración de dependencias más completa. Este parámetro admite dependencias de estilo Wheel, incluidas aquellas con enlaces de código nativo compatibles con Amazon Linux 2.
**Scala**
Puede proporcionar dependencias de Scala adicionales con el argumento de trabajo `--extra-jars`. Las dependencias deben estar alojadas en Amazon S3 y el valor del argumento debe ser una lista delimitada por comas de rutas de Amazon S3 sin espacios. Puede que le resulte más fácil administrar la configuración si reagrupa las dependencias antes de alojarlas y configurarlas. AWS Glue Las dependencias JAR contienen código de bytes de Java, que se puede generar desde cualquier lenguaje JVM. Puede usar otros lenguajes de JVM, como Java, para escribir dependencias personalizadas.
### Administrar credenciales de origen de datos.
Los programas Spark existentes pueden incluir una configuración compleja o personalizada para extraer datos de sus fuentes de datos. Los flujos de autenticación de orígenes de datos habituales son compatibles con conexiones de AWS Glue. Para obtener más información acerca de las conexiones de AWS Glue, consulte [Conexión a datos](glue-connections.md).
Las conexiones de AWS Glue facilitan la conexión de un trabajo a diversos tipos de almacenes de datos principalmente de dos formas: mediante llamadas de métodos a nuestras bibliotecas y configurando **Additional network connection** (Conexión de red adicional) en la consola de AWS. También puede llamar al AWS SDK desde su trabajo para recuperar información de una conexión.
**Llamada de métodos**: las conexiones de AWS Glue están estrechamente integradas con el Catálogo de datos de AWS Glue, un servicio que permite seleccionar información sobre los conjuntos de datos, y los métodos disponibles para interactuar con las conexiones de AWS Glue así lo reflejan. Si tiene una configuración de autenticación existente que le gustaría reutilizar, para conexiones JDBC, puede acceder a la configuración de conexión de AWS Glue mediante el método `extract_jdbc_conf` en `GlueContext`. Para obtener más información, consulte [extract\$1jdbc\$1conf](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-extract_jdbc_conf).
**Configuración de la consola**: los trabajos de AWS Glue utilizan las conexiones de AWS Glue asociadas para configurar conexiones a subredes de Amazon VPC. Si administra directamente sus materiales de seguridad, es posible que tenga que proporcionar una **Additional network connection** (Conexión de red adicional) de tipo `NETWORK` en la consola de AWS para configurar el enrutamiento. Para obtener más información sobre la API de conexión de AWS Glue, consulte [API de conexión](aws-glue-api-catalog-connections.md).
Si sus programas Spark tienen un flujo de autenticación personalizado o poco común, es posible que tenga que gestionar los materiales de seguridad de forma manual. Si las conexiones de AWS Glue no resultan adecuadas, se puede alojar de manera segura los materiales de seguridad en Secrets Manager y acceder a ellos a través de boto3 o el AWS SDK, que se proporcionan en el trabajo.
### Configurar Apache Spark
Las migraciones complejas a menudo alteran la configuración de Spark para adaptarse a sus cargas de trabajo. Las versiones modernas de Apache Spark permiten configurar el tiempo de ejecución con `SparkSession`. AWS Glue Se proporciona un `SparkSession` a los trabajos 3.0\$1, que se puede modificar para establecer la configuración del tiempo de ejecución. [Configuración Apache Spark](https://spark.apache.org/docs/latest/configuration.html). Ajustar Spark es complejo, y AWS Glue no garantiza asistencia para realizar toda la configuración de Spark. Si la migración requiere una configuración importante en el nivel de Spark, contacte con el servicio de asistencia.
### Establecer configuración personalizada
Los programas de Spark migrados se pueden diseñar para que adopten una configuración personalizada. AWS Glue permite establecer la configuración en el nivel del trabajo y la ejecución del trabajo, mediante los argumentos del trabajo. Para obtener información sobre argumentos de trabajo, consulte [Uso de los parámetros de trabajo en los trabajos de AWS Glue](aws-glue-programming-etl-glue-arguments.md). Puede acceder a los argumentos del trabajo dentro del contexto de un trabajo a través de nuestras bibliotecas. AWS Glue proporciona una función de utilidad para ofrecer una vista coherente de los argumentos establecidos en el trabajo y aquellos establecidos en la ejecución del trabajo. Consulte [Acceso a los parámetros mediante `getResolvedOptions`](aws-glue-api-crawler-pyspark-extensions-get-resolved-options.md) en Python y [AWS GlueAPI GlueArgParser Scala de](glue-etl-scala-apis-glue-util-glueargparser.md) en Scala.
### Migración de código Java
Como se explica en [Incluir bibliotecas de terceros](#glue-author-migrate-apache-spark-third-party-libraries), sus dependencias pueden contener clases generadas por lenguajes JVM, como Java o Scala. Sus dependencias pueden incluir un método de `main`. Puede usar un método de `main` en una dependencia como punto de entrada para un trabajo de Scala de AWS Glue. Esto permite escribir su método de `main` en Java, o reutilizar un método de `main` empaquetado según los estándares de su propia biblioteca.
Para usar un método de `main` de una dependencia, realice lo siguiente: borre el contenido del panel de edición proporcionando el objeto predeterminado `GlueApp`. Proporcione el nombre completo de una clase en una dependencia como argumento de trabajo con la clave de `--class`. Luego, podrá activar una ejecución de trabajo.
No se puede configurar el orden ni la estructura de los argumentos que AWS Glue pasa al método `main`. Si el código existente necesita leer la configuración establecida en AWS Glue, es probable que esto provoque incompatibilidad con el código anterior. Si usa `getResolvedOptions`, tampoco tendrá un buen lugar para llamar a este método. Considere la posibilidad de invocar la dependencia directamente desde un método main generado por AWS Glue. El siguiente script de ETL de AWS Glue muestra un ejemplo de esto.
```
import com.amazonaws.services.glue.util.GlueArgParser
object GlueApp {
def main(sysArgs: Array[String]) {
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
// Invoke static method from JAR. Pass some sample arguments as a String[], one defined inline and one taken from the job arguments, using getResolvedOptions
com.mycompany.myproject.MyClass.myStaticPublicMethod(Array("string parameter1", args("JOB_NAME")))
// Alternatively, invoke a non-static public method.
(new com.mycompany.myproject.MyClass).someMethod()
}
}
```
# Trabajar con tareas de Ray en AWS Glue
**importante**
AWS Glue para Ray ya no estará disponible para nuevos clientes a partir del 30 de abril de 2026. Si desea utilizar AWS Glue para Ray, regístrese antes de esa fecha. Los clientes existentes pueden seguir utilizando el servicio con normalidad. Para obtener capacidades similares a AWS Glue para Ray, explore Amazon EKS. Para obtener más información, consulte [Finalización del soporte de AWS Glue para Ray](https://docs.aws.amazon.com/glue/latest/dg/awsglue-ray-jobs-availability-change.html).
En esta sección se proporciona información sobre el uso de AWS Glue para trabajos de Ray. Para obtener más información sobre cómo escribir scripts de AWS Glue para Ray, consulte la sección [Programación de scripts de Ray](aws-glue-programming-ray.md).
**Topics**
+ [Introducción a AWS Glue para Ray](#author-job-ray-using)
+ [Entornos de tiempo de ejecución de Ray compatibles](#author-job-ray-runtimes)
+ [Contabilidad de los trabajadores en los trabajos de Ray](#author-job-ray-worker-accounting)
+ [Uso de los parámetros de trabajo en los trabajos de Ray](author-job-ray-job-parameters.md)
+ [Supervisión de trabajos de Ray con métricas](author-job-ray-monitor.md)
## Introducción a AWS Glue para Ray
Para trabajar con AWS Glue para Ray, se utilizan los mismos trabajos de AWS Glue y las mismas sesiones interactivas que se usan con AWS Glue para Spark. Los trabajos de AWS Glue están diseñados para ejecutar el mismo script de forma periódica, mientras que las sesiones interactivas están diseñadas para permitir ejecutar fragmentos de código de forma secuencial con los mismos recursos aprovisionados.
AWS Glue ETL y Ray son diferentes en el fondo, por lo que en el script tendrá acceso a diferentes herramientas, características y configuraciones. Como nuevo marco de cálculo administrado por AWS Glue, Ray tiene una arquitectura diferente y usa un vocabulario diferente para describir lo que hace. Para más información, consulte [Architecture Whitepapers](https://docs.ray.io/en/latest/ray-contribute/whitepaper.html) (Documentos técnicos sobre la arquitectura) en la documentación sobre Ray.
**nota**
AWS Glue para Ray está disponible en el Este de EE. UU. (Norte de Virginia), Este de EE. UU. (Ohio), Oeste de EE. UU. (Oregón), Asia Pacífico (Tokio) y Europa (Irlanda).
### Trabajos de Ray en la consola de AWS Glue Studio
En la página **Trabajos** de la consola de AWS Glue Studio, puede seleccionar una nueva opción al crear un trabajo en el **editor de scripts AWS Glue Studio Ray**. Seleccione esta opción para crear un trabajo de Ray en la consola. Para más información sobre los trabajos y cómo se utilizan, consulte [Creación de trabajos de ETL visual](author-job-glue.md).
![\[La página Trabajos en AWS Glue Studio con la opción del editor de scripts de Ray seleccionada.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/ray_job_setup.png)
### Trabajos de Ray en la AWS CLI y SDK
Los trabajos de Ray en la AWS CLI utilizan las mismas acciones y parámetros del SDK que los demás trabajos. AWS Glue para Ray introduce nuevos valores para determinados parámetros. Para más información sobre la API de trabajos, consulte [Jobs](aws-glue-api-jobs-job.md).
## Entornos de tiempo de ejecución de Ray compatibles
En los trabajos de Spark, `GlueVersion` determina las versiones de Apache Spark y Python disponibles en un trabajo de AWS Glue para Spark. La versión de Python indica la versión admitida para trabajos de tipo Spark. No es así como se configuran los entornos de tiempo de ejecución de Ray.
Para los trabajos de Ray, debe configurar `GlueVersion` en `4.0` o superior. Sin embargo, las versiones de Ray, Python y bibliotecas adicionales que están disponibles en el trabajo de Ray vienen determinadas por el campo `Runtime` de la definición del trabajo.
El entorno de tiempo de ejecución de `Ray2.4` estará disponible durante un mínimo de 6 meses después del lanzamiento. A medida que Ray evolucione rápidamente, podrá incorporar actualizaciones y mejoras de Ray en futuras versiones del entorno de tiempo de ejecución.
Valores válidos: -.: `Ray2.4`
| Valor de tiempo de ejecución | Versiones de Ray y Python |
| --- | --- |
| Ray2.4 (para AWS Glue 4.0\$1) | Ray 2.4.0 Python 3.9 |
**Información adicional**
+ Para ver las notas de la versión que acompañan a las versiones de AWS Glue para Ray, consulte [AWS GlueVersiones de](release-notes.md#release-notes-versions).
+ Para ver las bibliotecas de Python que se proporcionan en un entorno de tiempo de ejecución, consulte [Módulos incluidos con los trabajos de Ray](edit-script-ray-env-dependencies.md#edit-script-ray-modules-provided).
## Contabilidad de los trabajadores en los trabajos de Ray
AWS Glue ejecuta los trabajos de Ray en los nuevos tipos de trabajadores de EC2 basados en Graviton, que solo están disponibles para los trabajos de Ray. Para aprovisionar adecuadamente a estos trabajadores para las cargas de trabajo para las que Ray está diseñado, ofrecemos una proporción diferente entre los recursos de cómputo y los recursos de memoria que la mayoría de los trabajadores. Para tener en cuenta estos recursos, utilizamos la unidad de procesamiento de datos optimizada para la memoria (M-DPU) en lugar de la unidad de procesamiento de datos (DPU) estándar.
+ Una M-DPU corresponde a 4 vCPU y 32 GB de memoria.
+ Una DPU corresponde a 4 vCPU y 16 GB de memoria. Las DPU se utilizan para contabilizar los recursos en AWS Glue con los trabajos de Spark y los trabajadores correspondientes.
Actualmente, los trabajos de Ray tienen acceso a un tipo de trabajador, `Z.2X`. El trabajador `Z.2X` se asigna a 2 M-DPU (8 vCPU, 64 GB de memoria) y tiene 128 GB de espacio en disco. Una máquina `Z.2X` proporciona 8 trabajadores de Ray (uno por vCPU).
La cantidad de M-DPU que puede utilizar simultáneamente en una cuenta está sujeta a una cuota de servicio. Para más información acerca de los límites de su cuenta de AWS Glue, consulte [Puntos de conexión y cuotas de AWS Glue](https://docs.aws.amazon.com/general/latest/gr/glue.html).
La cantidad de nodos de trabajo que están disponibles para un trabajo de Ray con `--number-of-workers (NumberOfWorkers)` se especifica en la definición de trabajo. Para obtener más información acerca de los valores Ray en la API de trabajos, consulte [Jobs](aws-glue-api-jobs-job.md).
También puede especificar un número mínimo de trabajadores que un trabajo de Ray debe asignar con el parámetro de trabajo de `--min-workers`. Para obtener más información acerca de la configuración de parámetros de trabajos, consulte [Referencia](author-job-ray-job-parameters.md#author-job-ray-parameters-reference).
# Uso de los parámetros de trabajo en los trabajos de Ray
**importante**
AWS Glue para Ray ya no estará disponible para nuevos clientes a partir del 30 de abril de 2026. Si desea utilizar AWS Glue para Ray, regístrese antes de esa fecha. Los clientes existentes pueden seguir utilizando el servicio con normalidad. Para obtener capacidades similares a AWS Glue para Ray, explore Amazon EKS. Para obtener más información, consulte [Finalización del soporte de AWS Glue para Ray](https://docs.aws.amazon.com/glue/latest/dg/awsglue-ray-jobs-availability-change.html).
Establece los argumentos para los trabajos de Ray AWS Glue de la misma manera que establece los argumentos para AWS Glue para los trabajos de Spark. Para obtener más información sobre la API de AWS Glue, consulte [Jobs](aws-glue-api-jobs-job.md). Puede configurar los trabajos de Ray AWS Glue con diferentes argumentos, que se enumeran en esta referencia. También puede presentar sus propios argumentos.
Puede configurar un trabajo en la consola, en la pestaña **Job details** (Detalles del trabajo), en el encabezado **Job Parameters** (Parámetros del trabajo). También puede configurar un trabajo mediante la AWS CLI al establecer `DefaultArguments` en un trabajo o `Arguments` en una ejecución de trabajos. Los parámetros de los trabajos y los argumentos predeterminados permanecerán con el trabajo durante varias ejecuciones.
Por ejemplo, a continuación se muestra la sintaxis para ejecutar un trabajo con `--arguments` para configurar un parámetro especial.
```
$ aws glue start-job-run --job-name "CSV to CSV" --arguments='--scriptLocation="s3://my_glue/libraries/test_lib.py",--test-environment="true"'
```
Después de establecer los argumentos, puede acceder a los parámetros del trabajo desde su trabajo de Ray mediante variables de entorno. Esto permite configurar el trabajo para cada ejecución. El nombre de la variable de entorno será el nombre del argumento del trabajo sin el prefijo `--`.
Por ejemplo, en el anterior, los nombres de las variables serían `scriptLocation` y `test-environment`. Luego, recuperaría el argumento mediante los métodos disponibles en la biblioteca estándar: `test_environment = os.environ.get('test-environment')`. Para más información sobre el acceso a las variables de entorno con Python, consulte [módulo del sistema operativo](https://docs.python.org/3/library/os.html) en la documentación de Python.
## Configure la forma en que los trabajos de Ray generan registros
De forma predeterminada, los trabajos de Ray generan registros y métricas que se envían a CloudWatch y Amazon S3. Puede usar el parámetro `--logging_configuration` para modificar la forma en que se generan los registros; actualmente, puede usarlo para evitar que los trabajos de Ray generen varios tipos de registros. Este parámetro toma un objeto JSON, cuyas claves corresponden a los registros o comportamientos que desea modificar. Admite las siguientes claves:
+ `CLOUDWATCH_METRICS`: configura las series de métricas de CloudWatch que se pueden usar para visualizar el estado del trabajo. Para obtener más información sobre las métricas, consulte [Supervisión de trabajos de Ray con métricas](author-job-ray-monitor.md).
+ `CLOUDWATCH_LOGS`: configura los registros de CloudWatch que proporcionan detalles a nivel de aplicación de Ray acerca del estado de ejecución del trabajo. Para obtener más información acerca de los logs, consulte [Solución de problemas AWS Glue de errores de Ray en los registros](troubleshooting-ray.md).
+ `S3`: configura lo que AWS Glue escribe en Amazon S3, principalmente información similar a la de los registros de CloudWatch, pero como archivos y no como flujos de registros.
Para deshabilitar un comportamiento de registro de Ray, indique el valor `{\"IS_ENABLED\": \"False\"}`. Por ejemplo, para deshabilitar las métricas y los registros de CloudWatch, proporcione la siguiente configuración:
```
"--logging_configuration": "{\"CLOUDWATCH_METRICS\": {\"IS_ENABLED\": \"False\"}, \"CLOUDWATCH_LOGS\": {\"IS_ENABLED\": \"False\"}}"
```
## Referencia
Los trabajos de Ray reconocen los siguientes nombres de argumentos que se pueden usar para configurar el entorno de scripts para los trabajos de Ray y las ejecuciones de trabajos:
+ `--logging_configuration`: se usa para detener la generación de varios registros creados por trabajos de Ray. Estos registros se generan de forma predeterminada en todos los trabajos de Ray. Formato: objeto JSON incluido en una cadena de escape. Para obtener más información, consulte [Configure la forma en que los trabajos de Ray generan registros](#author-job-ray-logging-configuration).
+ `--min-workers`: la cantidad mínima de nodos de trabajo que se asignan a un trabajo de Ray. Un nodo de trabajo puede ejecutar varias réplicas, una por CPU virtual. Formato: entero. Mínimo: 0. Máximo: valor especificado en `--number-of-workers (NumberOfWorkers)` en la definición del trabajo. Para obtener más información sobre la contabilidad de los nodos de trabajo, consulte [Contabilidad de los trabajadores en los trabajos de Ray](ray-jobs-section.md#author-job-ray-worker-accounting).
+ `--object_spilling_config`: AWS Glue porque Ray admite el uso de Amazon S3 como una forma de ampliar el espacio disponible para el almacén de objetos de Ray. Para habilitar este comportamiento, puede proporcionar a Ray un *objeto* que vuelque un objeto de configuración de JSON con este parámetro. Para obtener más información sobre la configuración de volcado de objetos de Ray, consulte [Derrame de objetos](https://docs.ray.io/en/latest/ray-core/objects/object-spilling.html) en la documentación de Ray. Formato: objeto JSON.
AWS Glue para Ray solo admite el volcado en el disco o en Amazon S3 a la vez. Puede proporcionar varios lugares para el volcado, siempre y cuando respeten esta limitación. Cuando vuelque a Amazon S3, también necesitará agregar permisos de IAM al trabajo para este bucket.
Al proporcionar un objeto JSON como configuración con la CLI, debe proporcionarlo como una cadena, con el objeto JSON incluido en una cadena de escape. Por ejemplo, un valor de cadena para volcar en una ruta de Amazon S3 tendría el siguiente aspecto: `"{\"type\": \"smart_open\", \"params\": {\"uri\":\"s3path\"}}"`. En AWS Glue Studio, proporcione este parámetro como un objeto JSON sin formato adicional.
+ `--object_store_memory_head`: la memoria asignada al almacén de objetos de Plasma en el nodo principal de Ray. Esta instancia ejecuta servicios de administración de clústeres, así como réplicas de procesos de trabajo. El valor representa un porcentaje de memoria libre en la instancia después de un inicio en caliente. Este parámetro se utiliza para ajustar las cargas de trabajo de uso intensivo de la memoria. Los valores predeterminados son aceptables para la mayoría de los casos de uso. Formato: entero positivo. Mínimo: 1. Máximo: 100.
Para más información sobre Plasma, consulte [The Plasma In-Memory Object Store](https://ray-project.github.io/2017/08/08/plasma-in-memory-object-store.html) (Almacén de objetos en memoria de Plasma) en la documentación de Ray.
+ `--object_store_memory_worker`: memoria asignada al almacén de objetos de Plasma en los nodos de trabajo de Ray. Estas instancias solo ejecutan réplicas de procesos de trabajo. El valor representa un porcentaje de memoria libre en la instancia después de un inicio en caliente. Este parámetro se utiliza para ajustar las cargas de trabajo de uso intensivo de la memoria. Los valores predeterminados son aceptables para la mayoría de los casos de uso. Formato: entero positivo. Mínimo: 1. Máximo: 100.
Para más información sobre Plasma, consulte [The Plasma In-Memory Object Store](https://ray-project.github.io/2017/08/08/plasma-in-memory-object-store.html) (Almacén de objetos en memoria de Plasma) en la documentación de Ray.
+ `--pip-install`: un conjunto de paquetes de Python para instalar. Puede instalar paquetes desde PyPI con este argumento. Formato: lista delimitada por comas.
Una entrada de paquete de PyPI tiene el formato `package==version`, con el nombre y la versión de PyPI del paquete de destino. Las entradas utilizan la coincidencia de versiones de Python para hacer coincidir el paquete y la versión, como `==`, no la igualdad simple `=`. Hay otros operadores de coincidencia de versión. Para más información, consulte [PEP 440](https://peps.python.org/pep-0440/#version-matching) en el sitio web de Python. También puede proporcionar módulos personalizados con `--s3-py-modules`.
+ `--s3-py-modules`: un conjunto de rutas de Amazon S3 que alojan distribuciones de módulos de Python. Formato: lista delimitada por comas.
Puede usar esto para distribuir sus propios módulos en el trabajo de Ray. También puede proporcionar módulos desde PyPI con `--pip-install`. A diferencia de ETL de AWS Glue, los módulos personalizados no se configuran mediante pip, sino que se pasan a Ray para ser distribuidos. Para obtener más información, consulte [Módulos de Python adicionales para trabajos de Ray](edit-script-ray-env-dependencies.md#edit-script-ray-python-libraries-additional).
+ `--working-dir`: una ruta a un archivo .zip alojado en Amazon S3 que contiene archivos que se van a distribuir a todos los nodos que ejecutan el trabajo de Ray. Formato: cadena. Para obtener más información, consulte [Proporcionar archivos a su trabajo de Ray](edit-script-ray-env-dependencies.md#edit-script-ray-working-directory).
# Supervisión de trabajos de Ray con métricas
**importante**
AWS Glue para Ray ya no estará disponible para nuevos clientes a partir del 30 de abril de 2026. Si desea utilizar AWS Glue para Ray, regístrese antes de esa fecha. Los clientes existentes pueden seguir utilizando el servicio con normalidad. Para obtener capacidades similares a AWS Glue para Ray, explore Amazon EKS. Para obtener más información, consulte [Finalización del soporte de AWS Glue para Ray](https://docs.aws.amazon.com/glue/latest/dg/awsglue-ray-jobs-availability-change.html).
Puede supervisar los trabajos de Ray mediante AWS Glue Studio y Amazon CloudWatch. CloudWatch recopila y procesa las métricas sin formato desde AWS Glue con Ray, lo que las hace disponibles para el análisis. Estas métricas se visualizan en la consola de AWS Glue Studio, por lo que puede supervisar el trabajo a medida que se ejecuta.
Para obtener información general sobre cómo supervisar AWS Glue, consulte [Supervisión de AWS Glue con métricas de Amazon CloudWatch](monitoring-awsglue-with-cloudwatch-metrics.md). Para obtener una descripción general de cómo utilizar las métricas de CloudWatch publicadas por AWS Glue, consulte [Supervisión con Amazon CloudWatch](monitor-cloudwatch.md).
## Supervisión de los trabajos de Ray en la consola de AWS Glue
En la página de detalles para una ejecución de trabajo, debajo de la sección **Detalles de ejecución**, puede consultar los gráficos agregados prediseñados que visualizan las métricas de trabajo disponibles. AWS Glue Studio envía las métricas del trabajo a CloudWatch para cada ejecución de trabajo. Con ellas, puede crear un perfil del clúster y las tareas y acceder a información detallada sobre cada nodo.
Para obtener más información sobre los gráficos de métricas disponibles, consulte [Visualización de métricas de Amazon CloudWatch para una ejecución de trabajo de Ray](view-job-runs.md#monitoring-job-run-metrics-ray).
## Información general de las métricas de trabajos de Ray en CloudWatch
Publicamos las métricas de Ray cuando la supervisión detallada está habilitada en CloudWatch. Las métricas se publican en el espacio de nombres de CloudWatch `Glue/Ray`.
+ **Métricas de la instancia**
Publicamos métricas acerca del uso de la CPU, la memoria y el disco de las instancias asignadas a un trabajo. Estas métricas se identifican mediante características como `ExecutorId`, `ExecutorType` y `host`. Estas métricas son un subconjunto de las métricas estándar de los agentes de CloudWatch de Linux. Puede encontrar información sobre los nombres y características de las métricas en la documentación de CloudWatch. Para más información, consulte [Métricas que el agente de CloudWatch ha recopilado](https://docs.aws.amazon.com//AmazonCloudWatch/latest/monitoring/metrics-collected-by-CloudWatch-agent.html).
+ **Métricas del clúster de Ray**
Reenviamos las métricas de los procesos de Ray que ejecutan el script en este espacio de nombres, luego proporcionamos los más críticos. Las métricas disponibles pueden diferir según la versión de Ray. Para más información sobre qué versión de Ray está en ejecución en su trabajo, consulte [AWS GlueVersiones de](release-notes.md).
Ray recopila métricas al nivel de instancia. También proporciona métricas para las tareas y el clúster. Para obtener más información sobre la estrategia de métricas subyacente de Ray, consulte [Métricas](https://docs.ray.io/en/latest/ray-observability/ray-metrics.html#system-metrics) en la documentación de Ray.
**nota**
No publicamos las métricas de Ray en el espacio de nombres de `Glue/Job Metrics/`, que solo se usa para trabajos de ETL de AWS Glue.
# Configuración de las propiedades de trabajos del intérprete de comandos de Python en AWS Glue
Un trabajo de shell de Python puede usarse para ejecutar scripts de Python como un shell en AWS Glue. Con un trabajo del intérprete de comandos de Python puede ejecutar scripts compatibles con Python 3.6 o Python 3.9.
**nota**
La compatibilidad con Pyshell v3.6 finalizará el 1 de marzo de 2026. Para migrar sus cargas de trabajo, consulte [Migrar desde trabajos de la shell de Python de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/pyshell-migration.html). Si desea continuar con el intérprete de comandos de Python v3.9, consulte [Migración del intérprete de comandos de Python 3.6 al intérprete de comandos de Python 3.9](#migrating-version-pyshell36-to-pyshell39).
**Topics**
+ [Limitaciones](#python-shell-limitations)
+ [Entorno de ejecución](#python-shell-execution-environment)
+ [Definición de las propiedades de trabajos de shell de Python](#create-job-python-properties)
+ [Bibliotecas compatibles con trabajos de shell de Python](#python-shell-supported-library)
+ [Proporcionar su propia biblioteca de Python](#create-python-extra-library)
+ [Use AWS CloudFormation con los trabajos del intérprete de comandos de Python en AWS Glue](#python-shell-jobs-cloudformation)
+ [Migración del intérprete de comandos de Python 3.6 al intérprete de comandos de Python 3.9](#migrating-version-pyshell36-to-pyshell39)
+ [Migrar desde trabajos de shell de AWS Glue Python](pyshell-migration.md)
## Limitaciones
Tenga en cuenta las siguientes limitaciones de los trabajos de Python Shell:
+ No se pueden utilizar marcadores de trabajos con los trabajos de shell de Python.
+ No se puede empaquetar ninguna biblioteca de Python como archivos `.egg` en Python 3.9 y superiores. En su lugar, utilice `.whl`.
+ No se puede usar la opción `--extra-files` debido a una limitación en las copias temporales de los datos de S3.
## Entorno de ejecución
Los trabajos del intérprete de comandos de Python se ejecutan en un entorno de ejecución administrado que proporciona acceso al almacenamiento local para el procesamiento temporal de datos:
**Almacenamiento temporal local**
El directorio `/tmp` está disponible para el almacenamiento temporal durante la ejecución del trabajo. Este directorio proporciona aproximadamente 14 GiB de espacio libre que puede utilizar para:
+ Procesamiento de archivos temporales
+ Almacenamiento de datos intermedios
+ Almacenamiento en caché de pequeños conjuntos de datos
El directorio `/tmp` es efímero y se limpia una vez finalizado el trabajo. No lo utilice para el almacenamiento persistente de datos importantes.
## Definición de las propiedades de trabajos de shell de Python
Estas secciones describen la definición de propiedades de trabajo en AWS Glue Studio, o mediante el CLI de AWS.
### AWS Glue Studio
Al definir su trabajo de shell de Python en AWS Glue Studio, debe proporcionar algunas de las siguientes propiedades:
**rol de IAM**
Especifique el rol de AWS Identity and Access Management (IAM) que se usa para dar una autorización a los recursos que se utilizan para ejecutar el flujo de 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**
Elija **Python shell (Shell de Python)** para ejecutar un script de Python con el comando de trabajo llamado `pythonshell`.
**Versión de Python**
Elija la versión de Python. El valor por defecto es Python 3.9. Las versiones válidas son Python 3.6 y Python 3.9.
**Cargar bibliotecas de análisis comunes (recomendado)**
Elija esta opción para incluir bibliotecas comunes para Python 3.9 en el shell de Python.
Si sus bibliotecas son personalizadas o entran en conflicto con las preinstaladas, puede optar por no instalar bibliotecas comunes. Sin embargo, puede instalar bibliotecas adicionales además de las bibliotecas comunes.
Si selecciona esta opción, la opción `library-set` se establece en `analytics`. Al anular la selección de esta opción, la opción `library-set` se establece en `none`.
**Nombre de archivo de script y ruta de script**
El código del script define la lógica de procedimiento del trabajo. 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).
**Script**
El código del script define la lógica de procedimiento del trabajo. Puede codificar el script en Python 3.6 o Python 3.9. Puede editar scripts en AWS Glue Studio.
**Unidades de procesamiento de datos**
El número máximo de unidades de procesamiento de datos (DPU) de AWS Glue que se pueden asignar cuando se ejecute este trabajo. 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. Para más información, consulte [Precios de AWS Glue](https://aws.amazon.com/glue/pricing/).
Puede establecer el valor en 0.0625 o 1. El valor predeterminado es 0.0625. En cualquier caso, el disco local para la instancia será de 20 GB.
### CLI
También puede crear un trabajo de **shell de Python** con la AWS CLI, como en el siguiente ejemplo.
```
aws glue create-job --name python-job-cli --role Glue_DefaultRole
--command '{"Name" : "pythonshell", "PythonVersion": "3.9", "ScriptLocation" : "s3://amzn-s3-demo-bucket/scriptname.py"}'
--max-capacity 0.0625
```
**nota**
No es necesario especificar la versión de AWS Glue ya que el parámetro `--glue-version` no se aplica a los trabajos del intérprete de comandos de AWS Glue. Se ignorará cualquier versión especificada.
Trabajos que crea con el valor AWS CLI predeterminado en Python 3. Las versiones válidas de Python son 3 (que corresponden a 3.6) y 3.9. Para especificar Python 3.6, agregue esta tupla al parámetro `--command`: `"PythonVersion":"3"`
Para especificar Python 3.9, agregue esta tupla al parámetro `--command`: `"PythonVersion":"3.9"`
Para establecer la capacidad máxima utilizada por un trabajo de shell de Python, proporcione el parámetro `--max-capacity`. En los trabajos de shell de Python, no se puede utilizar el parámetro `--allocated-capacity`.
## Bibliotecas compatibles con trabajos de shell de Python
En el shell de Python con Python 3.9, puede elegir el conjunto de bibliotecas para usar los conjuntos de bibliotecas preempaquetados según sus necesidades. Puede utilizar la opción `library-set` para elegir el conjunto de bibliotecas. Los valores válidos son `analytics` y `none`.
El entorno para la ejecución de un trabajo de shell de Python admite las siguientes bibliotecas:
| Versión de Python | Python 3.6 | Python 3.9 |
| --- | --- | --- |
| Conjunto de bibliotecas | N/A | análisis | none |
| avro | | 1.11.0 | |
| awscli | 116.242 | 1.23.5 | 1.23.5 |
| awswrangler | | 2.15.1 | |
| botocore | 1.12.232 | 1.24.21 | 1.23.5 |
| boto3 | 1.9.203 | 1.21.21 | |
| elasticsearch | | 8.2.0 | |
| numpy | 1.16.2 | 1.22.3 | |
| pandas | 0.24.2 | 1.4.2 | |
| psycopg2 | | 2.9.3 | |
| pyathena | | 2.5.3 | |
| PyGreSQL | 5.0.6 | | |
| PyMySQL | | 1.0.2 | |
| pyodbc | | 4.0.32 | |
| pyorc | | 0.6.0 | |
| redshift-connector | | 2.0.907 | |
| solicitudes | 2.22.0 | 2.27.1 | |
| scikit-learn | 0.20.3 | 1.0.2 | |
| scipy | 1.2.1 | 1.8.0 | |
| SQLAlchemy | | 1.4.36 | |
| s3fs | | 2022.3.0 | |
Puede utilizar la biblioteca `NumPy` en un trabajo de shell de Python para cálculos científicos. Para obtener más información, consulte [NumPy](http://www.numpy.org). En el siguiente ejemplo se muestra un script NumPy que puede utilizarse en un trabajo de shell de Python. El script imprime “Hello world” y los resultados de varios cálculos matemáticos.
```
import numpy as np
print("Hello world")
a = np.array([20,30,40,50])
print(a)
b = np.arange( 4 )
print(b)
c = a-b
print(c)
d = b**2
print(d)
```
## Proporcionar su propia biblioteca de Python
### Uso de PIP
El shell de Python que usa Python 3.9 también le permite proporcionar módulos de Python adicionales o versiones diferentes al nivel de trabajo. Puede utilizar la opción `--additional-python-modules` con una lista de módulos Python separados por comas para agregar un nuevo módulo o cambiar la versión de un módulo existente. No puede proporcionar módulos de Python personalizados alojados en Amazon S3 con este parámetro al usar trabajos de intérprete de comandos de Python.
Por ejemplo, para actualizar o agregar un nuevo módulo `scikit-learn`, utilice la siguiente clave y valor: `"--additional-python-modules", "scikit-learn==0.21.3"`.
AWS Glue utiliza el instalador de paquetes de Python (pip3) para instalar los módulos adicionales. Puede incluir opciones de pip3 adicionales dentro del valor `--additional-python-modules`. Por ejemplo, `"scikit-learn==0.21.3 -i https://pypi.python.org/simple/"`. Se aplican incompatibilidades o limitaciones de pip3.
**nota**
Para evitar incompatibilidades en el futuro, recomendamos usar bibliotecas creadas para Python 3.9.
### Uso de un archivo Egg o Whl
Es posible que ya tenga una o varias bibliotecas de Python empaquetadas como un archivo `.egg` o `.whl`. En caso afirmativo, puede especificarlos en su trabajo utilizando la AWS Command Line Interface (AWS CLI) bajo la marca “`--extra-py-files`“, como en el siguiente ejemplo.
```
aws glue create-job --name python-redshift-test-cli --role role --command '{"Name" : "pythonshell", "ScriptLocation" : "s3://MyBucket/python/library/redshift_test.py"}'
--connections Connections=connection-name --default-arguments '{"--extra-py-files" : ["s3://amzn-s3-demo-bucket/EGG-FILE", "s3://amzn-s3-demo-bucket/WHEEL-FILE"]}'
```
Si no está seguro de cómo crear un archivo `.egg` o `.whl` desde una biblioteca de Python, siga estos pasos. Este ejemplo es aplicable en macOS, Linux y Windows Subsystem for Linux (WSL).
**Para crear un archivo .egg o.whl de Python**
1. Cree un clúster de Amazon Redshift en una nube virtual privada (VPC) y agregue algunos datos a una tabla.
1. Cree una conexión de AWS Glue para la combinación VPC-GrupoDeSeguridad-Subred que utilizó para crear el clúster. Compruebe que la conexión se realiza correctamente.
1. Cree un directorio llamado `redshift_example` y cree un archivo denominado `setup.py`. Pegue el siguiente código en `setup.py`.
```
from setuptools import setup
setup(
name="redshift_module",
version="0.1",
packages=['redshift_module']
)
```
1. En el directorio `redshift_example`, cree un directorio `redshift_module`. En el directorio `redshift_module`, cree los archivos `__init__.py` y `pygresql_redshift_common.py`.
1. Deje vacío el archivo `__init__.py`. En `pygresql_redshift_common.py`, pegue el siguiente código: Sustituya *port*, *db\$1name*, *user*, y *password\$1for\$1user* con los detalles específicos de su clúster de Amazon Redshift. Sustituya *table\$1name* por el nombre de la tabla en Amazon Redshift.
```
import pg
def get_connection(host):
rs_conn_string = "host=%s port=%s dbname=%s user=%s password=%s" % (
host, port, db_name, user, password_for_user)
rs_conn = pg.connect(dbname=rs_conn_string)
rs_conn.query("set statement_timeout = 1200000")
return rs_conn
def query(con):
statement = "Select * from table_name;"
res = con.query(statement)
return res
```
1. Si no está ya en él, cambie al directorio `redshift_example`.
1. Realice una de las siguientes acciones:
+ Ejecute el siguiente comando para crear un archivo `.egg`.
```
python setup.py bdist_egg
```
+ Ejecute el siguiente comando para crear un archivo `.whl`.
```
python setup.py bdist_wheel
```
1. Instale las dependencias necesarias para el comando anterior.
1. El comando crea un archivo en el directorio `dist`:
+ Si ha creado un archivo egg, se llamará `redshift_module-0.1-py2.7.egg`.
+ Si ha creado un archivo wheel, se llamará `redshift_module-0.1-py2.7-none-any.whl`.
Cargue este archivo en Amazon S3.
En este ejemplo, la ruta del archivo cargado es *s3://amzn-s3-demo-bucket/EGG-FILE* o *s3://amzn-s3-demo-bucket/WHEEL-FILE*.
1. Cree un archivo de Python que se debe usar como script para el trabajo de AWS Glue y añada el siguiente código al archivo.
```
from redshift_module import pygresql_redshift_common as rs_common
con1 = rs_common.get_connection(redshift_endpoint)
res = rs_common.query(con1)
print "Rows in the table cities are: "
print res
```
1. Cargue el archivo anterior en Amazon S3. En este ejemplo, la ruta del archivo cargado es *s3://amzn-s3-demo-bucket/scriptname.py*.
1. Cree un trabajo de shell de Python con este script. En la consola de AWS Glue, en la página **Job properties (Propiedades del trabajo)**, especifique la ruta del archivo `.egg/.whl` en el cuadro **Python library path (Ruta de la biblioteca Python)**. Si tiene varios archivos `.egg/.whl` y archivos de Python, proporcione una lista separada por comas en este cuadro.
Al modificar o cambiar el nombre de los archivos `.egg`, los nombres de archivo deben usar los nombres predeterminados generados por el comando “python setup.py bdist\$1egg” o deben cumplir con las convenciones de nomenclatura del módulo Python. Para obtener más información, consulte [Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/).
Con la AWS CLI, cree un trabajo con un comando, como en el siguiente ejemplo.
```
aws glue create-job --name python-redshift-test-cli --role Role --command '{"Name" : "pythonshell", "ScriptLocation" : "s3://amzn-s3-demo-bucket/scriptname.py"}'
--connections Connections="connection-name" --default-arguments '{"--extra-py-files" : ["s3://amzn-s3-demo-bucket/EGG-FILE", "s3://amzn-s3-demo-bucket/WHEEL-FILE"]}'
```
Cuando se ejecuta el trabajo, el script imprime las filas creadas en la tabla *table\$1name* en el clúster de Amazon Redshift.
## Use AWS CloudFormation con los trabajos del intérprete de comandos de Python en AWS Glue
Puede usar AWS CloudFormation con los trabajos del intérprete de comandos de Python en AWS Glue. A continuación, se muestra un ejemplo:
```
AWSTemplateFormatVersion: 2010-09-09
Resources:
Python39Job:
Type: 'AWS::Glue::Job'
Properties:
Command:
Name: pythonshell
PythonVersion: '3.9'
ScriptLocation: 's3://bucket/location'
MaxRetries: 0
Name: python-39-job
Role: RoleName
```
El grupo de Amazon CloudWatch Logs para la salida de los trabajos de shell de Python es `/aws-glue/python-jobs/output`. En el caso de los errores, consulte el grupo de registros `/aws-glue/python-jobs/error`.
## Migración del intérprete de comandos de Python 3.6 al intérprete de comandos de Python 3.9
Para migrar sus trabajos del intérprete de comandos de Python a la versión AWS Glue más reciente:
1. En la consola de AWS Glue ([https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)), elija su trabajo del intérprete de comandos de Python existente.
1. En la pestaña **Detalles del trabajo**, establezca la versión de Python en `Python 3.9` y seleccione **Guardar**.
1. Asegúrese de que su script de trabajo sea compatible con Python 3.9 y de que se ejecute correctamente.
# Migrar desde trabajos de shell de AWS Glue Python
AWS lanzó los trabajos de shell deAWS Glue Python en 2018 AWS lanzó los trabajos de shell de AWS Glue Python en 2018 con el fin de ofrecer a los clientes una forma sencilla de ejecutar scripts de Python para trabajos ETL de tamaño pequeño a mediano y activar consultas SQL. Sin embargo, ahora hay opciones más modernas y flexibles para abordar las cargas de trabajo que se ejecutan actualmente en PythonShell. En este tema se explica cómo migrar las cargas de trabajo de los trabajos de shell de AWS Glue Python a una de estas opciones alternativas para aprovechar las nuevas capacidades disponibles.
En este tema se explica cómo hacer la migración de trabajos de shell de AWS Glue Python a opciones alternativas.
## Migración de la carga de trabajo a los trabajos de AWS Glue Spark
Los [trabajos de AWS Glue Spark y PySpark](https://docs.aws.amazon.com/glue/latest/dg/spark_and_pyspark.html) le permiten ejecutar sus cargas de trabajo de forma distribuida. Dado que tanto los trabajos de shell de AWS Glue Python como los de AWS Glue Spark se ejecutan en la misma plataforma, es fácil migrarlos y puede seguir utilizando las características de AWS Glue existentes que utiliza con los trabajos de shell de Python, como AWS Glue Workflows, AWS Glue Triggers, la integración de Amazon EventBridge de AWS Glue, la instalación de paquetes basada en PIP, etc.
Sin embargo, los trabajos de AWS Glue Spark están diseñados para ejecutar cargas de trabajo de Spark y el número mínimo de trabajadores es de 2. Si migra desde trabajos de shell de Python sin modificar sus scripts, se utilizará en realidad un solo elemento de trabajo y los demás permanecerán inactivos. Esto aumentará sus costos.
Para que sea eficiente, reescriba su script de trabajo de Python para utilizar las capacidades de Spark y distribuir la carga de trabajo entre varios trabajadores. Si su script de Python está basado en Pandas, es fácil migrarlo con la nueva API de Pandas en Spark. Obtenga más información sobre esto en [AWS Big Data Blog: análisis profundo de AWS Glue 4.0 para Apache Spark](https://aws.amazon.com/blogs/big-data/dive-deep-into-aws-glue-4-0-for-apache-spark/).
## Migración de una carga de trabajo a AWS Lambda
AWS Lambda es un servicio informático sin servidor que permite ejecutar código sin aprovisionar ni administrar servidores. Como AWS Lambda tiene tiempos de inicio más cortos y opciones de capacidad de cómputo más flexibles, puede aprovechar estas ventajas. Para administrar bibliotecas de Python adicionales, los trabajos de shell deAWS Glue Python utilizan una instalación basada en PIP. Sin embargo, para AWS Lambda, debe elegir una de las siguientes opciones: un archivo zip, una imagen de contenedor o capas Lambda.
Por otro lado, el tiempo de espera máximo de AWS Lambda es de 900 segundos (15 minutos). Si la duración de su carga de trabajo actual del trabajo de shell de AWS Glue Python es mayor, o si su carga de trabajo tiene un patrón de picos que puede provocar una mayor duración de los trabajos, le recomendamos que explore otras opciones en lugar de AWS Lambda.
## Migración de la carga de trabajo a Amazon ECS/Fargate
Amazon Elastic Container Service (Amazon ECS) es un servicio completamente administrado que simplifica la implementación, la administración y el escalado de aplicaciones en contenedores. AWS Fargate es un motor de cómputo sin servidor para cargas de trabajo en contenedores que se ejecutan en Amazon ECS y Amazon Elastic Kubernetes Service (Amazon EKS). No hay un tiempo de espera máximo en Amazon ECS y Fargate, por lo que es una buena opción para trabajos de larga duración. Dado que tiene el control total sobre la imagen de su contenedor, puede incluir su script de Python y las bibliotecas de Python adicionales en el contenedor y usarlas. Sin embargo, debe colocar su script de Python en contenedores para utilizar este enfoque.
## Migración de la carga de trabajo al operador Python de Amazon Managed Workflows para Apache Airflow
Amazon Managed Workflows para Apache Airflow (MWAA) es un servicio de orquestación administrada para Apache Airflow que facilita la configuración y el funcionamiento de canalizaciones de datos integrales en la nube a escala. Si ya dispone de un entorno MWAA, le resultará sencillo utilizar el operador Python en lugar de los trabajos de shell de AWS Glue Python. El operador Python es un operador que ejecuta código Python dentro de un flujo de trabajo de Airflow. Sin embargo, si no cuenta con un entorno MWAA existente, le recomendamos que explore otras opciones.
## Migración de la carga de trabajo a trabajos de entrenamiento de Amazon SageMaker AI AI
Amazon SageMaker AI Training es un servicio de machine learning (ML) totalmente administrado que Amazon SageMaker AI ofrece y que le ayuda a entrenar de manera eficaz una amplia gama de modelos de ML a escala. El núcleo de los trabajos de Amazon SageMaker AI AI es la creación de contenedores de las cargas de trabajo de ML y la capacidad de administrar los recursos de computación de AWS. Si prefiere un entorno sin servidor en el que no haya un tiempo de espera máximo, los trabajos de entrenamiento de Amazon SageMaker AI AI podrían ser una buena opción para usted. Sin embargo, la latencia de inicio tiende a ser mayor que la de los trabajos de shell de AWS Glue Python. Para trabajos sensibles a la latencia, le recomendamos explorar otras opciones.
# Supervisión de AWS Glue
El monitoreo es una parte importante del mantenimiento de la fiabilidad, la disponibilidad y el desempeño de AWS Glue y otras soluciones de AWS. AWS ofrece herramientas de monitorización que puede utilizar para controlar a AWS Glue, informar cuando algo no funciona y realizar acciones automáticamente cuando proceda:
Puede utilizar las siguientes herramientas de monitorización automatizado para vigilar AWS Glue e informar cuando haya algún problema:
+ **Amazon CloudWatch Events** proporciona un flujo de eventos de sistema casi en tiempo real que describe cambios en los recursos de AWS. CloudWatch Events habilita una informática basada en eventos automatizada. Puede escribir reglas que vigilan determinados eventos y activan acciones automatizadas en otros servicios de AWS cuando estos eventos se producen. Para obtener más información, consulte la [Guía del usuario de los Eventos de Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/).
+ **Amazon CloudWatch Logs** le permite monitorear, almacenar y tener acceso a los archivos de registro desde instancias de Amazon EC2, AWS CloudTrail u otros orígenes. Los registros de CloudWatch pueden monitorear información en los registros y enviarle una notificación cuando se llega a determinados umbrales. También se pueden archivar los datos del registro en un almacenamiento de larga duración. Para obtener más información, consulte la [Guía del usuario de Registros de Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/).
+ **AWS CloudTrail** captura llamadas a la API y eventos relacionados efectuados por su cuenta de AWS o en su nombre, y entrega los archivos de registro al bucket de Amazon S3 que se haya especificado. También se puede identificar qué usuarios y cuentas llaman a AWS, la dirección IP de origen desde la que se realizan las llamadas y el momento en que se efectúan las llamadas. Para obtener más información, consulte la [Guía del usuario de AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
Además, tiene acceso a la siguiente información de la consola de AWS Glue que le ayudará a depurar y perfilar los trabajos:
+ Trabajos de Spark: puede visualizar series de métricas seleccionadas de CloudWatch y los trabajos más nuevos tienen acceso a la interfaz de usuario de Spark. Para obtener más información, consulte [Supervisión de trabajos de Spark de AWS Glue](monitor-spark.md).
+ Trabajos de Ray: puede visualizar las series de métricas seleccionadas de CloudWatch. Para obtener más información, consulte [Supervisión de trabajos de Ray con métricas](author-job-ray-monitor.md).
**Topics**
+ [Etiquetas de AWS en AWS Glue](monitor-tags.md)
+ [Automatizar AWS Glue con EventBridge](automating-awsglue-with-cloudwatch-events.md)
+ [Monitorización de recursos de AWS Glue](monitor-resource-metrics.md)
+ [Registro de llamadas a la API de AWS Glue con AWS CloudTrail](monitor-cloudtrail.md)
# Etiquetas de AWS en AWS Glue
Para que le resulte más fácil administrar los recursos de AWS Glue, también puede asignar sus propias etiquetas a algunos tipos de recursos de AWS Glue. Una etiqueta es una marca que se asigna a un recurso de AWS. Cada etiqueta está formada por una clave y un valor opcional, ambos definidos por el usuario. Puede utilizar etiquetas de AWS Glue para organizar e identificar los recursos. Las etiquetas se pueden utilizar para crear informes de contabilidad de costos y restringir el acceso a los recursos. Si utiliza AWS Identity and Access Management, puede controlar qué usuarios de su cuenta de AWS tienen permiso para crear, editar o eliminar etiquetas. Además de los permisos para llamar a las API relacionadas con etiquetas, también necesita el permiso `glue:GetConnection` para llamar a las API de etiquetado en las conexiones y el permiso `glue:GetDatabase` para llamar a las API de etiquetado en las bases de datos. Para obtener más información, consulte [ABAC con AWS Glue](security_iam_service-with-iam.md#security_iam_service-with-iam-tags).
En AWS Glue, se pueden etiquetar los siguientes recursos:
+ Connection
+ Database
+ Rastreador
+ Sesión interactiva
+ Punto de enlace de desarrollo
+ Trabajo
+ Desencadenador
+ Flujo de trabajo
+ Esquema
+ Transformación de machine learning
+ Conjunto de reglas de calidad de datos
+ Esquemas de streaming
+ Registros de esquemas de streaming
**nota**
Como práctica recomendada, para permitir el etiquetado de estos recursos de AWS Glue, incluya siempre la acción `glue:TagResource` en sus políticas.
Cuando utilice etiquetas con , tenga en cuenta lo siguiente: AWS Glue.
+ Se permite un máximo de 50 etiquetas por entidad.
+ En AWS Glue, debe especificar etiquetas como una lista de pares clave-valor con el formato `{"string": "string" ...}`
+ Al crear una etiqueta en un objeto, la clave de etiqueta es obligatoria y el valor de la etiqueta es opcional.
+ La clave y el valor de la etiqueta distinguen entre mayúsculas y minúsculas.
+ La clave de etiqueta y el valor de etiqueta no deben contener el prefijo *aws*. No se permiten operaciones en este tipo de etiquetas.
+ La longitud máxima de la clave de etiqueta es de 128 caracteres Unicode en UTF-8. La clave de etiqueta no debe estar vacía ni ser nula.
+ La longitud máxima del valor de etiqueta es de 256 caracteres Unicode en UTF-8. El valor de etiqueta puede estar vacío o ser nulo.
## Compatibilidad con el etiquetado en conexiones de AWS Glue
Puede restringir los permisos de la acción `CreateConnection`, `UpdateConnection`, `GetConnection` y `DeleteConnection` en función de la etiqueta de recurso. Esto permite implementar el control de acceso de privilegio mínimo en trabajos de AWS Glue con orígenes de datos JDBC que necesitan obtener información de conexión JDBC de Data Catalog.
**Ejemplo de uso**
Creación de una conexión AWS Glue con la etiqueta ["connection-category", "dev-test"].
Especifique la condición de etiqueta para la acción `GetConnection` en la política de IAM.
```
{
"Effect": "Allow",
"Action": [
"glue:GetConnection"
],
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:ResourceTag/tagKey": "dev-test"
}
}
}
```
## Ejemplos
Los siguientes ejemplos crean un trabajo con etiquetas asignadas.
**AWS CLI**
```
aws glue create-job --name job-test-tags --role MyJobRole --command Name=glueetl,ScriptLocation=S3://aws-glue-scripts//prod-job1
--tags key1=value1,key2=value2
```
**CloudFormation JSON**
```
{
"Description": "AWS Glue Job Test Tags",
"Resources": {
"MyJobRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"glue.amazonaws.com"
]
},
"Action": [
"sts:AssumeRole"
]
}
]
},
"Path": "/",
"Policies": [
{
"PolicyName": "root",
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "*",
"Resource": "*"
}
]
}
}
]
}
},
"MyJob": {
"Type": "AWS::Glue::Job",
"Properties": {
"Command": {
"Name": "glueetl",
"ScriptLocation": "s3://aws-glue-scripts//prod-job1"
},
"DefaultArguments": {
"--job-bookmark-option": "job-bookmark-enable"
},
"ExecutionProperty": {
"MaxConcurrentRuns": 2
},
"MaxRetries": 0,
"Name": "cf-job1",
"Role": {
"Ref": "MyJobRole",
"Tags": {
"key1": "value1",
"key2": "value2"
}
}
}
}
}
}
```
**CloudFormation YAML**
```
Description: AWS Glue Job Test Tags
Resources:
MyJobRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Principal:
Service:
- glue.amazonaws.com
Action:
- sts:AssumeRole
Path: "/"
Policies:
- PolicyName: root
PolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Action: "*"
Resource: "*"
MyJob:
Type: AWS::Glue::Job
Properties:
Command:
Name: glueetl
ScriptLocation: s3://aws-glue-scripts//prod-job1
DefaultArguments:
"--job-bookmark-option": job-bookmark-enable
ExecutionProperty:
MaxConcurrentRuns: 2
MaxRetries: 0
Name: cf-job1
Role:
Ref: MyJobRole
Tags:
key1: value1
key2: value2
```
Para obtener más información, consulte [Estrategias de etiquetado de AWS](https://aws.amazon.com/answers/account-management/aws-tagging-strategies/).
Para obtener más información acerca de cómo controlar el acceso con etiquetas, consulte [ABAC con AWS Glue](security_iam_service-with-iam.md#security_iam_service-with-iam-tags).
# Automatizar AWS Glue con EventBridge
Puede utilizar Amazon EventBridge para automatizar los servicios de AWS y responder automáticamente a eventos del sistema, como problemas de disponibilidad de las aplicaciones o cambios en los recursos. Los eventos de los servicios de AWS se envían a EventBridge casi en tiempo real. Puede crear reglas sencillas para indicar qué eventos le resultan de interés, así como qué acciones automatizadas se van a realizar cuando un evento cumple una de las reglas. Entre las acciones que se pueden activar automáticamente se incluyen las siguientes:
+ Invocar una función de AWS Lambda
+ Invocar Ejecutar comando de Amazon EC2
+ Desviar el evento a Amazon Kinesis Data Streams
+ Activar una máquina de estado de AWS Step Functions
+ Notificar un tema de Amazon SNS o una cola de Amazon SQS
Algunos ejemplos del uso de EventBridge con AWS Glue incluyen los siguientes:
+ Activar una función de Lambda cuando se realiza correctamente un trabajo de ETL
+ Notificar un tema de Amazon SNS cuando un trabajo de ETL produce error
El siguiente EventBridge es generado por AWS Glue.
+ Se generan eventos de `"detail-type":"Glue Job State Change"` para `SUCCEEDED`, `FAILED`, `TIMEOUT` y `STOPPED`.
+ Se generan eventos de `"detail-type":"Glue Job Run Status"` para ejecuciones de trabajos `RUNNING`, `STARTING` o `STOPPING` cuando superan el umbral de notificación de retraso de flujo de trabajo. Debe configurar la propiedad de umbral de notificación de retraso en el trabajo para recibir estos eventos.
Solo se genera un evento por estado de ejecución de un trabajo cuando se supera el umbral de notificación de retraso en el trabajo.
+ Se generan eventos de `"detail-type":"Glue Crawler State Change"` para `Started`, `Succeeded` y `Failed`.
+ Los eventos para `“detail_type”:“Glue Scheduled Crawler Invocation Failure”` se generan cuando el rastreador programado no se inicia. En los detalles de la notificación:
+ `customerId` contiene el ID de la cuenta del cliente.
+ `crawlerName` contiene el nombre del rastreador que no se pudo iniciar.
+ `errorMessage` contiene el mensaje de excepción del error de invocación.
+ Los eventos para `“detail_type”:“Glue Auto Statistics Invocation Failure“` se generan cuando la ejecución de la tarea de estadísticas de columnas gestionada automáticamente no se inicia. En los detalles de la notificación:
+ `catalogId` contiene el ID asociado a un catálogo.
+ `databaseName` contiene el nombre de la base de datos afectada.
+ `tableName` contiene el nombre de la tabla afectada.
+ `errorMessage` contiene el mensaje de excepción del error de invocación.
+ Los eventos para `“detail_type”:“Glue Scheduled Statistics Invocation Failure”` se generan cuando falla el inicio de la tarea programada (cron) de estadísticas de columnas. En los detalles de la notificación:
+ `catalogId` contiene el ID asociado a un catálogo.
+ `databaseName` contiene el nombre de la base de datos afectada.
+ `tableName` contiene el nombre de la tabla afectada.
+ `errorMessage` contiene el mensaje de excepción del error de invocación.
+ Los eventos para `“detail_type”:“Glue Statistics Task Started”` se generan cuando se inicia la ejecución de la tarea de estadísticas de columnas.
+ Los eventos para `“detail_type”:“Glue Statistics Task Succeeded”` se generan cuando la ejecución de la tarea de estadísticas de columnas finaliza correctamente.
+ Los eventos para `“detail_type”:“Glue Statistics Task Failed”` se generan cuando falla la ejecución de la tarea de estadísticas de columnas.
+ Se generan eventos de `"detail-type":"Glue Data Catalog Database State Change"` para `CreateDatabase`, `DeleteDatabase`, `CreateTable`, `DeleteTable` y `BatchDeleteTable`. Por ejemplo, si se crea o elimina una tabla, se envía una notificación a EventBridge. Tenga en cuenta que no puede escribir un programa que dependa del orden o de la existencia de eventos de notificación, ya que pueden no estar ordenados o faltar. Los eventos se emiten en la medida de lo posible. En los detalles de la notificación:
+ `typeOfChange` contiene el nombre de una operación API.
+ `databaseName` contiene el nombre de la base de datos afectada.
+ `changedTables` contiene hasta 100 nombres de tablas afectadas por notificación. Cuando los nombres de las tablas son largos, podrían crearse varias notificaciones.
+ Se generan eventos de `"detail-type":"Glue Data Catalog Table State Change"` para `UpdateTable`, `CreatePartition`, `BatchCreatePartition`, `UpdatePartition`, `DeletePartition`, `BatchUpdatePartition` y `BatchDeletePartition`. Por ejemplo, si se actualiza una tabla o partición, se envía una notificación a EventBridge. Tenga en cuenta que no puede escribir un programa que dependa del orden o de la existencia de eventos de notificación, ya que pueden no estar ordenados o faltar. Los eventos se emiten en la medida de lo posible. En los detalles de la notificación:
+ `typeOfChange` contiene el nombre de una operación API.
+ `databaseName` contiene el nombre de la base de datos que contiene los recursos afectados.
+ `tableName` contiene el nombre de la tabla afectada.
+ `changedPartitions` especifica hasta 100 particiones afectadas en una notificación. Cuando los nombres de las particiones son largos, podrían crearse varias notificaciones.
Por ejemplo, si hay dos claves de partición, `Year` y `Month`, `"2018,01", "2018,02"` modifica la partición donde `"Year=2018" and "Month=01"` y la partición donde `"Year=2018" and "Month=02"`.
```
{
"version":"0",
"id":"abcdef00-1234-5678-9abc-def012345678",
"detail-type":"Glue Data Catalog Table State Change",
"source":"aws.glue",
"account":"123456789012",
"time":"2017-09-07T18:57:21Z",
"region":"us-west-2",
"resources":["arn:aws:glue:us-west-2:123456789012:database/default/foo"],
"detail":{
"changedPartitions": [
"2018,01",
"2018,02"
],
"databaseName": "default",
"tableName": "foo",
"typeOfChange": "BatchCreatePartition"
}
}
```
Para obtener más información, consulte la [Guía del usuario de los Eventos de Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/). Para eventos específicos de AWS Glue consulte [Eventos de AWS Glue](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types).
# Monitorización de recursos de AWS Glue
AWS Glue tiene límites de servicio para proteger a los clientes de un aprovisionamiento excesivo inesperado y de acciones malintencionadas destinadas a aumentar la factura. Los límites también protegen el servicio. Al iniciar sesión en la consola de Service Quotas de AWS, los clientes pueden ver sus límites de recursos actuales y solicitar un aumento (si procede).
AWS Glue permite ver el uso de los recursos del servicio como un porcentaje en Amazon CloudWatch y configurar las alarmas de CloudWatch para supervisar el uso. Amazon CloudWatch supervisa los recursos de AWS y las aplicaciones de los clientes que se ejecutan en la infraestructura de Amazon. Las métricas son gratuitas para usted. Las siguientes métricas son compatibles:
+ Número de flujos de trabajo por cuenta
+ Número de disparadores por cuenta
+ Número de trabajos por cuenta
+ Número de ejecuciones de flujo de trabajo simultáneas por cuenta
+ Número de esquemas por cuenta
+ Número de sesiones interactivas por cuenta
## Configuración y uso de métricas de recursos
Para utilizar esta característica, puede ir a la consola de Amazon CloudWatch para ver las métricas y configurar las alarmas. Las métricas se encuentran en el espacio de nombres AWS/Glue y son un porcentaje del recuento real de uso de recursos dividido por la cuota de recursos. Las métricas de CloudWatch se envían a sus cuentas, lo que no supondrá ningún costo. Por ejemplo, si ha creado 10 flujos de trabajo y la cuota de servicio permite tener 200 flujos de trabajo como máximo, el uso es de 10/200 = 5 % y, en el gráfico, verá un punto de datos de 5 como porcentaje. Para ser más específicos:
```
Namespace: AWS/Glue
Metric name: ResourceUsage
Type: Resource
Resource: Workflow (or Trigger, Job, JobRun, Blueprint, InteractiveSession)
Service: Glue
Class: None
```
![\[Métricas de recursos\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/resource_monitoring_1.png)
Creación de una alarma en una métrica en la consola de CloudWatch:
1. Una vez que haya localizado la métrica, vaya a **Métricas gráficas**.
1. Haga clic en **Crear alarma** en **Acciones**.
1. Configure la alarma según sea necesario.
Emitimos métricas cada vez que se produce un cambio en el uso de los recursos (por ejemplo, un aumento o una disminución). Sin embargo, si el uso de sus recursos no cambia, emitimos métricas cada hora para que tenga un gráfico continuo de CloudWatch. Para evitar que falten puntos de datos, no recomendamos que configure un periodo inferior a 1 hora.
También puede configurar las alarmas con AWS CloudFormation, tal como en el siguiente ejemplo. En este ejemplo, cuando el uso de los recursos del flujo de trabajo alcanza el 80 %, activa una alarma para enviar un mensaje al tema de SNS existente, donde puede suscribirse para recibir notificaciones.
```
{
"Type": "AWS::CloudWatch::Alarm",
"Properties": {
"AlarmName": "WorkflowUsageAlarm",
"ActionsEnabled": true,
"OKActions": [],
"AlarmActions": [
"arn:aws:sns:af-south-1:085425700061:Default_CloudWatch_Alarms_Topic"
],
"InsufficientDataActions": [],
"MetricName": "ResourceUsage",
"Namespace": "AWS/Glue",
"Statistic": "Maximum",
"Dimensions": [{
"Name": "Type",
"Value": "Resource"
},
{
"Name": "Resource",
"Value": "Workflow"
},
{
"Name": "Service",
"Value": "Glue"
},
{
"Name": "Class",
"Value": "None"
}
],
"Period": 3600,
"EvaluationPeriods": 1,
"DatapointsToAlarm": 1,
"Threshold": 80,
"ComparisonOperator": "GreaterThanThreshold",
"TreatMissingData": "notBreaching"
}
}
```
# Registro de llamadas a la API de AWS Glue con AWS CloudTrail
AWS Glue se integra con AWS CloudTrail, un servicio que proporciona un registro de las acciones hechas por un usuario, un rol o un servicio de AWS en AWS Glue. CloudTrail captura todas las llamadas a la API de AWS Glue como eventos. Las llamadas capturadas incluyen las llamadas desde la consola de AWS Glue y las llamadas desde el código a las operaciones de la API de AWS Glue. Si crea un registro de seguimiento, puede habilitar la entrega continua de eventos de CloudTrail a un bucket de Amazon S3, incluidos los eventos para AWS Glue. Si no configura un registro de seguimiento, puede ver los eventos más recientes en la consola de CloudTrail en el **Event history (Historial de eventos)**. Mediante la información recopilada por CloudTrail, puede determinar la solicitud que se realizó a AWS Glue, la dirección IP desde la que se realizó, quién la realizó y cuándo, etc.
Para obtener más información sobre CloudTrail, consulte la [Guía del usuario de AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
## AWS GlueInformación de en CloudTrail
CloudTrail se habilita en su cuenta de AWS cuando la crea. Cuando se produce una actividad en AWS Glue, esa actividad se registra en un evento de CloudTrail junto con otros eventos de servicio de AWS en **Historial de eventos**. Se puede ver, buscar y descargar los últimos eventos de la cuenta de AWS. Para obtener más información, consulte [Visualización de eventos con el historial de eventos de CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html).
Para mantener un registro continuo de eventos en la cuenta de AWS, incluidos los eventos de AWS Glue, cree un registro de seguimiento. Un *registro de seguimiento* permite a CloudTrail enviar archivos de registro a un bucket de Amazon S3. De manera predeterminada, cuando se crea un registro de seguimiento en la consola, el registro de seguimiento se aplica a todas las regiones de AWS. El registro de seguimiento registra los eventos de todas las regiones de la partición de AWS y envía los archivos de registro al bucket de Amazon S3 especificado. También es posible configurar otros servicios de AWS para analizar en profundidad y actuar en función de los datos de eventos recopilados en los registros de CloudTrail. Para más información, consulte los siguientes temas:
+ [Creación de un seguimiento para su cuenta de AWS](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [Servicios e integraciones compatibles con CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations)
+ [Configuración de notificaciones de Amazon SNS para CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html)
+ [Recepción de archivos de registro de CloudTrail de varias regiones](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html) y [Recepción de archivos de registro de CloudTrail de varias cuentas](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html)
CloudTrail registra todas las acciones de AWS Glue y se documentan en [API de AWS Glue](aws-glue-api.md) . Por ejemplo, las llamadas a las acciones `CreateDatabase`, `CreateTable` y `CreateScript` generan entradas en los archivos de registros de CloudTrail.
Cada entrada de registro o evento contiene información sobre quién generó la solicitud. La información de identidad del usuario lo ayuda a determinar lo siguiente:
+ Si la solicitud se realizó con las credenciales raíz o del usuario de IAM.
+ Si la solicitud se realizó con credenciales de seguridad temporales de un rol o fue un usuario federado.
+ Si la solicitud la realizó otro servicio de AWS.
Para obtener más información, consulte el [Elemento userIdentity de CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html).
Sin embargo, CloudTrail no registra toda la información referente a las llamadas. Por ejemplo, no registra determinada información confidencial como `ConnectionProperties`, que se utiliza en las solicitudes de conexión, y registra `null` en lugar de las respuestas que envían las API siguientes:
```
BatchGetPartition GetCrawlers GetJobs GetTable
CreateScript GetCrawlerMetrics GetJobRun GetTables
GetCatalogImportStatus GetDatabase GetJobRuns GetTableVersions
GetClassifier GetDatabases GetMapping GetTrigger
GetClassifiers GetDataflowGraph GetObjects GetTriggers
GetConnection GetDevEndpoint GetPartition GetUserDefinedFunction
GetConnections GetDevEndpoints GetPartitions GetUserDefinedFunctions
GetCrawler GetJob GetPlan
```
## Descripción de las entradas de los archivos de registro de AWS Glue
Un registro de seguimiento es una configuración que permite la entrega de eventos como archivos de registro a un bucket de Amazon S3 que especifique. Los archivos de registro de CloudTrail pueden contener una o varias entradas de registro. Un evento representa una solicitud específica realizada desde un origen cualquiera y contiene información sobre la acción solicitada, la fecha y la hora de la acción, los parámetros de la solicitud, etc. Los archivos de registro de CloudTrail no rastrean el orden en la pila de las llamadas públicas a la API, por lo que estas no aparecen en ningún orden específico.
En el siguiente ejemplo, se muestra una entrada de registro de CloudTrail que ilustra la acción `DeleteCrawler`.
```
{
"eventVersion": "1.05",
"userIdentity": {
"type": "IAMUser",
"principalId": "AKIAIOSFODNN7EXAMPLE",
"arn": "arn:aws:iam::123456789012:user/johndoe",
"accountId": "123456789012",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "johndoe"
},
"eventTime": "2017-10-11T22:29:49Z",
"eventSource": "glue.amazonaws.com",
"eventName": "DeleteCrawler",
"awsRegion": "us-east-1",
"sourceIPAddress": "72.21.198.64",
"userAgent": "aws-cli/1.11.148 Python/3.6.1 Darwin/16.7.0 botocore/1.7.6",
"requestParameters": {
"name": "tes-alpha"
},
"responseElements": null,
"requestID": "b16f4050-aed3-11e7-b0b3-75564a46954f",
"eventID": "e73dd117-cfd1-47d1-9e2f-d1271cad838c",
"eventType": "AwsApiCall",
"recipientAccountId": "123456789012"
}
```
Este ejemplo muestra una entrada de registro de CloudTrail que ilustra la acción `CreateConnection`.
```
{
"eventVersion": "1.05",
"userIdentity": {
"type": "IAMUser",
"principalId": "AKIAIOSFODNN7EXAMPLE",
"arn": "arn:aws:iam::123456789012:user/johndoe",
"accountId": "123456789012",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "johndoe"
},
"eventTime": "2017-10-13T00:19:19Z",
"eventSource": "glue.amazonaws.com",
"eventName": "CreateConnection",
"awsRegion": "us-east-1",
"sourceIPAddress": "72.21.198.66",
"userAgent": "aws-cli/1.11.148 Python/3.6.1 Darwin/16.7.0 botocore/1.7.6",
"requestParameters": {
"connectionInput": {
"name": "test-connection-alpha",
"connectionType": "JDBC",
"physicalConnectionRequirements": {
"subnetId": "subnet-323232",
"availabilityZone": "us-east-1a",
"securityGroupIdList": [
"sg-12121212"
]
}
}
},
"responseElements": null,
"requestID": "27136ebc-afac-11e7-a7d6-ab217e5c3f19",
"eventID": "e8b3baeb-c511-4597-880f-c16210c60a4a",
"eventType": "AwsApiCall",
"recipientAccountId": "123456789012"
}
```