# Orquestación en AWS Glue
En las siguientes secciones, se ofrece información acerca de la orquestación de los trabajos en AWS Glue.
**Topics**
+ [Inicio de trabajos y rastreadores mediante desencadenadores](trigger-job.md)
+ [Realización de actividades de ETL complejas mediante esquemas y flujos de trabajo en AWS Glue](orchestrate-using-workflows.md)
+ [Desarrollo de esquemas en AWS Glue](orchestrate-using-blueprints.md)
# Inicio de trabajos y rastreadores mediante desencadenadores
En AWS Glue, puede crear objetos del Data Catalog denominados desencadenadores, que puede utilizar para iniciar en forma manual o automática uno o más rastreadores o trabajos de extracción, transformación y carga (ETL). Mediante los desencadenadores, puede diseñar una cadena de trabajos y rastreadores dependientes.
**nota**
Esto mismo se puede conseguir definiendo *flujos de trabajo*. Los flujos de trabajo son el método preferido para crear operaciones ETL multitarea complejas. Para obtener más información, consulte [Realización de actividades de ETL complejas mediante esquemas y flujos de trabajo en AWS Glue](orchestrate-using-workflows.md).
**Topics**
+ [Disparadores de AWS Glue](about-triggers.md)
+ [Agregado de desencadenadores](console-triggers.md)
+ [Activación y desactivación de desencadenadores](activate-triggers.md)
# Disparadores de AWS Glue
Cuando está *activo*, un desencadenador puede iniciar trabajos y rastreadores especificados. Un desencadenador se activa bajo demanda, en función de un calendario o en función de una combinación de eventos.
**nota**
Solo se pueden habilitar dos rastreadores con un solo desencadenador. Si desea rastrear varios almacenes de datos, utilice múltiples orígenes para cada rastreador en lugar de ejecutar varios rastreadores en forma simultánea.
Un desencadenador puede tener uno de varios estados. Los estados de un desencadenador son `CREATED`, `ACTIVATED` o `DEACTIVATED`. También hay estados de transición, como `ACTIVATING`. Para detener temporalmente la activación de un desencadenador, puede desactivarlo. Podrá reactivarlo más adelante.
Existen tres tipos de desencadenadores:
**Programados**
Un desencadenador con límite de tiempo basado en `cron`.
Puede crear un desencadenador para un conjunto de trabajos o rastreadores en función de un calendario. Puede especificar restricciones, como la frecuencia de ejecución de los trabajos o rastreadores, qué días de la semana se ejecutan y a qué hora. Estas restricciones se basan en `cron`. Al configurar un calendario para un desencadenador, debe tener en cuenta las características y limitaciones de cron. Por ejemplo, si decide ejecutar su rastreador el día 31 de cada mes, tenga en cuenta que algunos meses no tienen 31 días. Para obtener más información acerca de Cron, consulte [Programaciones basadas en tiempo para trabajos y rastreadores](monitor-data-warehouse-schedule.md).
**Condicional**
Desencadenador que se activa cuando un trabajo o rastreador anterior o varios trabajos o rastreadores satisfacen una lista de condiciones.
Cuando se crea un desencadenador condicional, se especifica una lista de trabajos y una lista de rastreadores que se deben vigilar. Para cada trabajo o rastreador vigilado, se especifica un estado de vigilancia, como éxito, error, tiempo de espera agotado, etc. El desencadenador se activa si los trabajos o los rastreadores observados terminan con los estados especificados. Puede configurar el desencadenador para que se active cuando se produzca alguno o todos los eventos observados.
Por ejemplo, podría configurar un desencadenador D1 para iniciar el trabajo T3 cuando tanto el trabajo T1 como el trabajo T2 se completen correctamente, y otro desencadenador D2 para iniciar el trabajo T4 si se produce un error en el trabajo T1 o en el trabajo T2.
En la tabla siguiente se enumeran los estados de finalización del trabajo y del rastreador (eventos) que los desencadenadores vigilan.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/about-triggers.html)
**Bajo demanda**
Un desencadenador que se pone en marcha cuando se activa. Los desencadenadores bajo demanda nunca alcanzan el estado `DEACTIVATED` o `ACTIVATED`. Siempre permanecen en el estado `CREATED`.
Para que estén listos para activarse en cuanto se creen, puede configurar un indicador para activar los desencadenadores programados y condicionales en el momento de crearlos.
**importante**
Los trabajos o rastreadores que se ejecutan como resultado de la finalización de otros trabajos o rastreadores se denominan *dependientes*. Los trabajos o los rastreadores dependientes solo se inician si el trabajo o el rastreador que se completa se inició con un desencadenador. Todos los trabajos o rastreadores de una cadena de dependencia deben ser descendientes de un único desencadenador **programado** o **bajo demanda**.
**Pasar parámetros de trabajo con desencadenadores**
Un desencadenador puede pasar parámetros a los trabajos que inicia. Los parámetros incluyen argumentos de trabajo, valor de tiempo de espera y configuración de seguridad, entre otros. Si el desencadenador inicia varios trabajos, los parámetros se pasan a cada trabajo.
Estas son las reglas para los argumentos de trabajo pasados por un desencadenador:
+ Si la clave del par de clave-valor coincide con un argumento de trabajo predeterminado, el argumento pasado invalida el argumento predeterminado. Si la clave no coincide con un argumento predeterminado, el argumento se pasa como un argumento adicional al trabajo.
+ Si la clave del par de clave-valor coincide con un argumento no invalidable, se omite el argumento pasado.
Para obtener más información, consulte [Desencadenadores](aws-glue-api-jobs-trigger.md) en la API de AWS Glue.
# Agregado de desencadenadores
Puede agregar un desencadenador mediante la consola de AWS Glue, la AWS Command Line Interface (AWS CLI) o la API de AWS Glue.
**Para agregar un desencadenador (consola)**
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, en **ETL**, elija **Triggers (Desencadenadores)**. A continuación, elija **Add trigger (Añadir desencadenador)**.
1. Proporcione las siguientes propiedades:
**Nombre**
Asigne un nombre único al disparador.
**Trigger type (Tipo de disparador)**
Especifique uno de los siguientes valores:
+ **Schedule (Calendario):** el desencadenador se activa a una frecuencia y hora específicas.
+ **Job events (Eventos de trabajo):** un desencadenador condicional. El desencadenador se activa cuando alguno o todos los trabajos de la lista coinciden con sus estados designados. Para que el desencadenador se active, un desencadenador debe haber iniciado los trabajos vigilados. Para cualquier trabajo que elija, solo puede vigilar un evento de trabajo (estado de finalización).
+ **On-demand (Bajo demanda):** el desencadenador se pone en marcha cuando se activa.
1. Complete el asistente para desencadenadores. En la página **Review (Revisar)**, puede activar inmediatamente los desencadenadores de tipo **Schedule (Calendario)** y **Job events (Eventos de trabajo)** (condicional) seleccionando **Enable trigger on creation (Habilitar desencadenador al crearlo)**.
**Para añadir un desencadenador (AWS CLI)**
+ Introduzca un comando similar al siguiente.
```
aws glue create-trigger --name MyTrigger --type SCHEDULED --schedule "cron(0 12 * * ? *)" --actions CrawlerName=MyCrawler --start-on-creation
```
Este comando crea un desencadenador de programación llamado `MyTrigger`, que se ejecuta todos los días a las 12:00 h UTC e inicia un rastreador llamado `MyCrawler`. El desencadenador se crea en el estado activado.
Para obtener más información, consulte [Disparadores de AWS Glue](about-triggers.md).
# Programaciones basadas en tiempo para trabajos y rastreadores
Puede definir programaciones basadas en tiempo para los rastreadores y los trabajos en AWS Glue. La definición de estas programaciones utiliza sintaxis [cron](http://en.wikipedia.org/wiki/Cron) del tipo Unix. Debe utilizar el formato de [hora universal coordinada (UTC)](http://en.wikipedia.org/wiki/Coordinated_Universal_Time) y la precisión mínima para una programación es 5 minutos.
Para obtener más información sobre cómo configurar trabajos y rastreadores para que se ejecuten en forma programada, consulte [Inicio de trabajos y rastreadores mediante desencadenadores](trigger-job.md).
## Expresiones cron
Las expresiones Cron tienen seis campos obligatorios, que están separados por un espacio en blanco.
**Sintaxis**
```
cron(Minutes Hours Day-of-month Month Day-of-week Year)
```
| **Campos** | **Valores** | **Caracteres comodín** |
| --- | --- | --- |
| Minutos | 0–59 | , - \$1 / |
| Horas | 0–23 | , - \$1 / |
| Día del mes | 1–31 | , - \$1 ? / L W |
| Mes | 1–12 o ENE-DIC | , - \$1 / |
| Día de la semana | 1–7 o DOM-SÁB | , - \$1 ? / L |
| Año | 1970-2199 | , - \$1 / |
**Caracteres comodín**
+ El carácter comodín **,** (coma) incluye valores adicionales. En el campo `Month`, `JAN,FEB,MAR` incluiría enero, febrero y marzo.
+ El carácter comodín **-** (guion) especifica los intervalos. En el campo `Day`, 1-15 incluiría los días del 1 al 15 del mes especificado.
+ El **\$1** (asterisco) incluye todos los valores del campo. En el campo `Hours`, **\$1** incluiría cada hora.
+ El comodín **/** (barra inclinada) especifica incrementos. En el campo `Minutes`, puede escribir **1/10** para especificar cada décimo minuto, empezando desde el primer minuto de la hora (por ejemplo, los minutos 11, 21 y 31, etc.).
+ El comodín **?** (signo de interrogación) especifica uno u otro. En el campo `Day-of-month` puede escribir **7** y si no le importa qué día de la semana era el séptimo, podría escribir **?** en el campo Day-of-week.
+ El comodín **L** en los campos `Day-of-month` o `Day-of-week` especifica el último día del mes o de la semana.
+ El comodín **W** en el campo `Day-of-month` especifica un día de la semana. En el campo `Day-of-month`, `3W` especifica el día más cercano al tercer día de semana del mes.
**Límites**
+ No se pueden especificar los campos `Day-of-month` y `Day-of-week` en la misma expresión Cron. Si especifica un valor en uno de los campos, debe utilizar un **?** (signo de interrogación) en el otro.
+ No se admiten las expresiones Cron que producen frecuencias superiores a 5 minutos.
**Ejemplos**
Cuando cree una programación, puede utilizar las siguientes cadenas Cron de ejemplo.
| Minutos | Horas | Día del mes | Mes | Día de la semana | Año | Significado |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | 10 | \$1 | \$1 | ? | \$1 | Ejecutar a las 10:00 h (UTC) todos los días |
| 15 | 12 | \$1 | \$1 | ? | \$1 | Ejecutar a las 12:15 h (UTC) todos los días |
| 0 | 18 | ? | \$1 | MON-FRI | \$1 | Ejecutar a las 18:00 h (UTC) de lunes a viernes |
| 0 | 8 | 1 | \$1 | ? | \$1 | Ejecutar a las 08:00 horas (UTC) todos los primeros de mes |
| 0/15 | \$1 | \$1 | \$1 | ? | \$1 | Ejecutar cada 15 minutos |
| 0/10 | \$1 | ? | \$1 | MON-FRI | \$1 | Ejecutar cada 10 minutos de lunes a viernes |
| 0/5 | 8-17 | ? | \$1 | MON-FRI | \$1 | Ejecutar cada 5 minutos de lunes a viernes entre las 8.00 y las 17.55 h (UTC) |
Por ejemplo, para ejecutarse en un programa diario a las 12:15 UTC, especifique:
```
cron(15 12 * * ? *)
```
# Activación y desactivación de desencadenadores
Puede activar o desactivar un desencadenador mediante la consola de AWS Glue, la AWS Command Line Interface (AWS CLI) o la API de AWS Glue.
**Para activar o desactivar un desencadenador (consola)**
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, en **ETL**, elija **Triggers (Desencadenadores)**.
1. Active la casilla de verificación situada junto al desencadenador que desee y, en el menú **Action (Acción)** elija **Enable trigger (Activar desencadenador)** para activar el desencadenador o **Disable trigger (Desactivar desencadenador)** para desactivarlo.
**Para activar o desactivar un desencadenador (AWS CLI)**
+ Especifique uno de los siguientes comandos.
```
aws glue start-trigger --name MyTrigger
aws glue stop-trigger --name MyTrigger
```
Al iniciar un desencadenador se activa y al detenerlo se desactiva. Cuando activa un desencadenador bajo demanda, este se activa inmediatamente.
Para obtener más información, consulte [Disparadores de AWS Glue](about-triggers.md).
# Realización de actividades de ETL complejas mediante esquemas y flujos de trabajo en AWS Glue
Es posible que algunos de los procesos complejos del servicio ETL (extracción, transformación y carga) de su organización se implementen de mejor manera con múltiples trabajos y rastreadores dependientes de AWS Glue. Con los *flujos de trabajo* de AWS Glue, puede diseñar un proceso de ETL complejo de múltiples trabajos, múltiples rastreadores que AWS Glue puede ejecutar y rastrear como una sola entidad. Después de crear un flujo de trabajo y especificar los trabajos, rastreadores y desencadenadores del flujo de trabajo, puede ejecutar el flujo de trabajo bajo demanda o en función de una programación.
**Topics**
+ [Información general de los flujos de trabajo en AWS Glue](workflows_overview.md)
+ [Creación y desarrollo manual de un flujo de trabajo en AWS Glue](creating_running_workflows.md)
+ [Inicio de un flujo de trabajo de AWS Glue a partir de un evento de Amazon EventBridge](starting-workflow-eventbridge.md)
+ [Visualizar los eventos de EventBridge que iniciaron un flujo de trabajo](viewing-start-event-info.md)
+ [Ejecución y supervisión de un flujo de trabajo en AWS Glue](running_monitoring_workflow.md)
+ [Detener una ejecución de flujo de trabajo](workflow-stopping.md)
+ [Reparar y reanudar la ejecución de un flujo de trabajo](resuming-workflow.md)
+ [Obtención y configuración de propiedades de ejecución de flujo de trabajo en AWS Glue](workflow-run-properties-code.md)
+ [Consulta de flujos de trabajo mediante la AWS Glue API](workflows_api_concepts.md)
+ [Restricciones de esquemas y flujos de trabajo en AWS Glue](blueprint_workflow_restrictions.md)
+ [Solución de errores de esquema en AWS Glue](blueprint_workflow_troubleshoot.md)
+ [Permisos de personas y roles para esquemas de AWS Glue](blueprints-personas-permissions.md)
# Información general de los flujos de trabajo en AWS Glue
En AWS Glue, puede utilizar flujos de trabajo para crear y visualizar actividades de extracción, transformación y carga (ETL) complejas que implican varios rastreadores, trabajos y desencadenadores. Cada flujo de trabajo administra la ejecución y monitoreo de todos sus trabajos y rastreadores. Un flujo de trabajo registra el progreso de ejecución y el estado, ya que ejecuta cada componente. Esto le proporciona información general de la tarea de mayor envergadura y los detalles de cada paso. La consola de AWS Glue ofrece una representación visual de un flujo de trabajo en forma de gráfico.
Puede crear un flujo de trabajo desde un proyecto de AWS Glue, o puede crear manualmente un flujo de trabajo un componente a la vez mediante la herramienta Consola de administración de AWS o AWS Glue API. Para obtener más información acerca de los esquemas, consulte [Información general de los esquemas en AWS Glue](blueprints-overview.md).
Los *desencadenadores* dentro de los flujos de trabajo pueden habilitar los trabajos y rastreadores y pueden iniciarse cuando se completan los trabajos y rastreadores. Al usar desencadenadores, puede crear grandes cadenas de trabajos y rastreadores interdependientes. Además de los desencadenadores dentro de un flujo de trabajo que definen las dependencias de los trabajos y rastreadores, cada flujo de trabajo tiene un *desencadenador de inicio*. Existen tres tipos de desencadenadores de inicio:
+ **Programación**: el flujo de trabajo se inicia según la programación que defina. La programación puede ser diaria, semanal, mensual, etc., o puede ser una programación personalizada basada en una expresión `cron`.
+ **Bajo demanda**: el flujo de trabajo se inicia manualmente desde la consola de AWS Glue, la API o AWS CLI.
+ **Evento de EventBridge**: el flujo de trabajo se inicia cuando se produce un único evento de Amazon EventBridge o un lote de eventos de Amazon EventBridge. Con este tipo de desencadenador, AWS Glue puede ser un consumidor de eventos en una arquitectura basada en eventos. Cualquier tipo de evento de EventBridge puede iniciar un flujo de trabajo. Un caso de uso común es la llegada de un nuevo objeto en un bucket de Amazon S3 (la operación `PutObject` de S3).
Iniciar un flujo de trabajo con un lote de eventos significa esperar hasta que se haya recibido un número especificado de eventos o hasta que haya transcurrido un tiempo especificado. Al crear el desencadenador de eventos EventBridge, puede especificar condiciones de lote de forma opcional. Si especifica condiciones de lote, debe especificar el tamaño del lote (número de eventos) y puede especificar una ventana de lote (número de segundos) si lo desea. La ventana por lotes predeterminada y máxima es de 900 segundos (15 minutos). La condición del lote que se cumpla primero inicia el flujo de trabajo. La ventana del lote se inicia cuando llega el primer evento. Si no especifica las condiciones de lote al crear un desencadenador, el tamaño predeterminado del lote es 1.
Cuando se inicia el flujo de trabajo, las condiciones del lote se restablecen y el desencadenador de eventos comienza a comprobar si se cumple la siguiente condición de lote para volver a iniciar el flujo de trabajo.
En la siguiente tabla se muestra cómo el tamaño del lote y la ventana del lote funcionan juntos para habilitar un flujo de trabajo.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/workflows_overview.html)
La operación de la API `GetWorkflowRun` devuelve la condición de lote que desencadenó el flujo de trabajo.
Independientemente de cómo se inicie un flujo de trabajo, puede especificar el número máximo de ejecuciones concurrentes de flujo de trabajo al crear el flujo de trabajo.
Si un evento o lote de eventos inicia una ejecución de flujo de trabajo que eventualmente falla, ese evento o lote de eventos ya no se considera para iniciar una ejecución de flujo de trabajo. Una nueva ejecución de flujo de trabajo se inicia sólo cuando llega el siguiente evento o lote de eventos.
**importante**
Limite la cantidad total de trabajos, rastreadores y desencadenadores de un flujo de trabajo a 100 o menos. Si incluye más de 100, es posible que se produzcan errores al intentar reanudar o detener las ejecuciones del flujo de trabajo.
No se iniciará una ejecución de flujo de trabajo si excede el límite de concurrencia establecido para el flujo de trabajo, aunque se cumpla la condición del evento. Se aconseja ajustar los límites de concurrencia del flujo de trabajo en función del volumen de eventos esperado. AWS Glue no reintenta ejecutar los flujos de trabajo que presentan errores debido a límites de concurrencia excedidos. Del mismo modo, se aconseja ajustar los límites de concurrencia para trabajos y rastreadores dentro de flujos de trabajo en función del volumen de eventos esperado.
**Propiedades de ejecución del flujo de trabajo**
Para compartir y administrar el estado en toda la ejecución de flujo de trabajo, puede definir propiedades de ejecución de flujo de trabajo predeterminadas. Estas propiedades, que son pares nombre-valor, están disponibles para todos los trabajos en el flujo de trabajo. Utilice la AWS Glue API para recuperar las propiedades de ejecución de flujo de trabajo y modifíquelas para los trabajos que vengan después en el flujo de trabajo.
**Gráfico del flujo de trabajo**
La imagen siguiente muestra el gráfico de un flujo de trabajo básico en la consola de AWS Glue. Su flujo de trabajo podría tener decenas de componentes.
![\[Captura de pantalla que muestra la pestaña Graph (Gráfico) de un flujo de trabajo. El gráfico contiene cinco íconos que representan un desencadenador de programación, dos trabajos, un desencadenador de eventos correcto y un rastreador que actualiza el esquema.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/graph-complete-with-tabs.png)
Este flujo de trabajo se inicia mediante un desencadenador de programación, `Month-close1`, que inicia dos trabajos, `De-duplicate` y `Fix phone numbers`. Tras la realización completa de ambos trabajos, un desencadenador de eventos, `Fix/De-dupe succeeded`, inicia un rastreador, `Update schema`.
**Vistas de flujo de trabajo estáticas y dinámicas**
Para cada flujo de trabajo hay una noción de vista *estática* y *dinámica*. La vista estática indica el diseño del flujo de trabajo. La vista dinámica es una vista de tiempo de ejecución que incluye la información de ejecución más reciente para cada uno de los trabajos y rastreadores. La información de ejecución incluye detalles sobre el error y el estado de success (correcto).
Cuando un flujo de trabajo se encuentra en ejecución, la consola muestra la vista dinámica, que indica gráficamente los trabajos completados y que todavía se tienen que ejecutar. También puede recuperar una vista dinámica de un flujo de trabajo en ejecución mediante la AWS Glue API. Para obtener más información, consulte [Consulta de flujos de trabajo mediante la AWS Glue API](workflows_api_concepts.md).
**Véase también**
[Creación de un flujo de trabajo a partir de un esquema en AWS Glue](creating_workflow_blueprint.md)
[Creación y desarrollo manual de un flujo de trabajo en AWS Glue](creating_running_workflows.md)
[Flujos de trabajo](aws-glue-api-workflow.md) (para la API de flujos de trabajo)
# Creación y desarrollo manual de un flujo de trabajo en AWS Glue
Puede usar la consola de AWS Glue para crear y construir un flujo de trabajo un nodo a la vez de forma manual.
Un flujo de trabajo contiene trabajos, rastreadores y desencadenadores. Antes de crear un flujo de trabajo de forma manual, cree los trabajos y rastreadores que el flujo de trabajo vaya a incluir. Es mejor especificar rastreadores de ejecución bajo demanda para los flujos de trabajo. Puede crear nuevos desencadenadores mientras se desarrolla su flujo de trabajo o puede *clonar* desencadenadores existentes en el flujo de trabajo. Al clonar un desencadenador, se agregan al flujo de trabajo todos los objetos del catálogo asociados al desencadenador (los trabajos o rastreadores que lo activan y los trabajos o rastreadores que lo inician).
**importante**
Limite la cantidad total de trabajos, rastreadores y desencadenadores de un flujo de trabajo a 100 o menos. Si incluye más de 100, es posible que se produzcan errores al intentar reanudar o detener las ejecuciones del flujo de trabajo.
Puede diseñar su propio flujo de trabajo añadiendo desencadenadores al gráfico de flujo de trabajo y definiendo los eventos vistos y las acciones para cada desencadenador. Comience con un *desencadenador de arranque*, que puede ser un desencadenador bajo demanda o programado, y complete el gráfico añadiendo desencadenadores de eventos (condicional).
## Paso 1: Crear el flujo de 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, en **ETL**, elija **Workflows** (Flujos de trabajo).
1. Seleccione **Add workflow** (Añadir flujo de trabajo) y complete el formulario **Add a new ETL workflow** (Añadir un nuevo flujo de trabajo de ETL).
Las propiedades de ejecución predeterminadas opcionales que añada estarán disponibles como argumentos para todos los trabajos en el flujo de trabajo. Para obtener más información, consulte [Obtención y configuración de propiedades de ejecución de flujo de trabajo en AWS Glue](workflow-run-properties-code.md).
1. Seleccione **Add workflow** (Añadir flujo de trabajo).
El nuevo flujo de trabajo aparecerá en la lista en la página **Workflows** (Flujos de trabajo).
## Paso 2: Añadir un desencadenador de arranque
1. En la página **Workflows** (Flujos de trabajo), seleccione el nuevo flujo de trabajo. A continuación, en la parte inferior de la página, asegúrese de seleccionar la pestaña **Graph (Gráfico)**.
1. Seleccione **Add trigger** (Añadir desencadenador), y en el cuadro de diálogo **Add trigger** (Añadir desencadenador), realice uno de los siguientes procedimientos:
+ Elija **Clone existing** (Clonación existente) y seleccione un desencadenador que clonar. A continuación, elija **Add (Añadir)**.
El desencadenador aparece en el gráfico, junto con los trabajos y los rastreadores que ve e inicia.
Si ha seleccionado por error el desencadenador erróneo, seleccione el desencadenador en el gráfico y, a continuación, elija **Remove** (Eliminar).
+ Elija **Add new** (Añadir nuevo) y complete el formulario **Add trigger** (Añadir desencadenador).
1. Para **Trigger type (Tipo de desencadenador)**, seleccione **Schedule (Programación)**, **On demand (Bajo demanda)**, o bien **EventBridge event (Evento de EventBridge)**.
Para el tipo de desencadenador **Schedule (Programación)**, elija una de las opciones en **Frequency (Frecuencia)**. Seleccione **Custom (Personalizado)** e ingrese una expresión `cron`.
Para el tipo de desencadenador **EventBridge**, ingrese **Number of events (Número de eventos)** (tamaño del lote) y, opcionalmente, ingrese **Time delay (Tiempo de retraso)** (ventana por lotes). Si omite **Time delay (Tiempo de retraso)**, la ventana por lotes tiene un valor predeterminado de 15 minutos. Para obtener más información, consulte [Información general de los flujos de trabajo en AWS Glue](workflows_overview.md).
1. Elija **Add (Agregar)**.
El desencadenador aparece en el gráfico, junto con un nodo de marcador de posición (con la etiqueta **Add node** [Añadir nodo]). En el ejemplo a continuación, el desencadenador de inicio es un desencadenador de programación denominado `Month-close1`.
En este momento, el desencadenador no está guardado aún.
![\[Un gráfico con dos nodos rectangulares: un desencadenador y un nodo de marcador de posición. Una flecha señala desde el nodo del desencadenador hasta el nodo de marcador de posición.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/graph-start-trigger.png)
1. Si ha añadido un nuevo desencadenador, complete estos pasos:
1. Realice una de las siguientes acciones:
+ Elija el nodo del marcador de posición (**Add node** [Añadir nodo]).
+ Asegúrese de que el desencadenador de arranque esté seleccionado, y en el menú **Action** (Acción) de arriba del gráfico, elija **Add jobs/crawlers to trigger** (Añadir trabajos/rastreadores al desencadenador).
1. En el cuadro de diálogo **Add jobs(s) and crawler(s) to trigger** (Añadir trabajos y rastreadores al desencadenador), seleccione uno o más trabajos o desencadenadores y, a continuación, elija **Add** (Añadir).
El desencadenador se guarda y los trabajos y rastreadores seleccionados aparecen en el gráfico con los conectores del desencadenador.
Si ha añadido por error los trabajos y rastreadores erróneos, puede seleccionar el desencadenador o un conector y elegir **Remove** (Eliminar).
## Paso 3: Agregar más desencadenadores
Continúe construyendo su flujo de trabajo al agregar más desencadenadores de tipo **Event (Evento)**. Para ampliar o reducir la imagen, o para agrandar el lienzo del gráfico, utilice los iconos a la derecha del gráfico. Para agregar los desencadenadores, complete los siguientes pasos:
**nota**
No hay ninguna acción para guardar el flujo de trabajo. Después de agregar el último desencadenador y asignar acciones al desencadenador, el flujo de trabajo se completa y se guarda. Siempre puede volver más tarde y agregar más nodos.
1. Realice una de las siguientes acciones:
+ Para clonar un desencadenador existente, asegúrese de que no se selecciona ningún nodo en el gráfico y, en el menú **Action** (Acción), elija **Add trigger** (Añadir desencadenador).
+ Para añadir un nuevo desencadenador que vea un trabajo o rastreador determinado en el gráfico, seleccione el nodo de trabajo o rastreador y, a continuación, elija el nodo de marcador de posición **Add trigger** (Añadir desencadenador).
Puede añadir más trabajos o rastreadores para ver este desencadenador en un paso posterior.
1. En el cuadro de diálogo **Add trigger** (Añadir desencadenador), realice una de las acciones siguientes:
+ Elija **Add new** (Añadir nuevo) y complete el formulario **Add trigger** (Añadir desencadenador). A continuación, elija **Add (Añadir)**.
El desencadenador aparece en el gráfico. Se completará el desencadenador en un paso posterior.
+ Elija **Clone existing** (Clonación existente) y seleccione un desencadenador que clonar. A continuación, elija **Add (Añadir)**.
El desencadenador aparece en el gráfico, junto con los trabajos y los rastreadores que ve e inicia.
Si ha elegido por error el desencadenador erróneo, seleccione el desencadenador en el gráfico y, a continuación, elija **Remove** (Eliminar).
1. Si ha añadido un nuevo desencadenador, complete estos pasos:
1. Seleccione el nuevo desencadenador.
Como se muestra en el siguiente gráfico, se selecciona el desencadenador `De-dupe/fix succeeded`, y los nodos de marcador de posición aparecen para (1) eventos para ver y (2) acciones.
![\[Un gráfico con muchos nodos, dos de los cuales son nodos de marcador de posición que se denominan números 1 y 2.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/graph-dual-placeholders.png)
1. (Opcional si el desencadenador ya ve un evento y desea añadir más trabajos o rastreadores que ver). Elija el nodo de marcador de posición de eventos que ver y, en el cuadro de diálogo **Add job(s) and crawler(s) to watch** (Añadir trabajos y rastreadores que ver), seleccione uno o más trabajos o rastreadores. Elija un evento que ver (SUCCEEDED (Correcto), FAILED (Erróneo), etc.), y elija **Add** (Añadir).
1. Asegúrese de que se seleccione el desencadenador y elija el nodo de marcador de posición de acciones.
1. En el cuadro de diálogo **Add jobs(s) and crawler(s) to watch** (Añadir trabajos y rastreadores que ver), seleccione uno o más trabajos o desencadenadores y, a continuación, elija **Add** (Añadir).
Los trabajos y rastreadores seleccionados aparecen en el gráfico con los conectores del desencadenador.
Para obtener más información sobre flujos de trabajo y esquemas, consulte los siguientes temas.
+ [Información general de los flujos de trabajo en AWS Glue](workflows_overview.md)
+ [Ejecución y supervisión de un flujo de trabajo en AWS Glue](running_monitoring_workflow.md)
+ [Creación de un flujo de trabajo a partir de un esquema en AWS Glue](creating_workflow_blueprint.md)
# Inicio de un flujo de trabajo de AWS Glue a partir de un evento de Amazon EventBridge
Amazon EventBridge, también conocido como CloudWatch Events, le permite automatizar los servicios de AWS y responder automáticamente a eventos del sistema, como problemas de disponibilidad de aplicaciones o cambios de 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.
Con el soporte de EventBridge, AWS Glue puede funcionar como productor y consumidor de eventos en una arquitectura basada en eventos. Para los flujos de trabajo, AWS Glue soporta cualquier tipo de evento de EventBridge como consumidor. Es probable que el caso de uso más común sea la llegada de un nuevo objeto en un bucket de Amazon S3. Si tiene datos que llegan a intervalos irregulares o indefinidos, puede procesar estos datos lo más rápido posible luego de su llegada.
**nota**
AWS Glue no garantiza la entrega de mensajes de EventBridge. AWS Glue no realiza desduplicación si EventBridge entrega mensajes duplicados. Debe administrar la idempotencia en función del caso de uso.
Asegúrese de configurar las reglas de EventBridge en forma correcta para evitar el envío de eventos no deseados.
**Antes de empezar**
Si desea iniciar un flujo de trabajo con eventos de datos de Amazon S3, debe asegurarse de que los eventos del bucket de S3 de interés se registren en AWS CloudTrail y EventBridge. Para ello, debe crear un seguimiento de CloudTrail. Para obtener más información, consulte [Crear un seguimiento para su cuenta de AWS](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html).
**Para iniciar un flujo de trabajo con un evento de EventBridge**
**nota**
En los siguientes comandos, sustituya:
** con el nombre que se va a asignar al flujo de trabajo.
** con el nombre que se va a asignar al desencadenador.
** con el nombre del bucket de Amazon S3.
** con un ID de cuenta de AWS válido.
** con el nombre de la región (por ejemplo, `us-east-1`).
** con el nombre que se asignará a la regla de EventBridge.
1. Asegúrese de tener permisos de AWS Identity and Access Management (IAM) para crear y ver reglas y destinos de EventBridge. A continuación, se muestra una política de ejemplo que puede asociar. Es posible que desee reducir el alcance para poner límites a las operaciones y los recursos.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"events:PutRule",
"events:DisableRule",
"events:DeleteRule",
"events:PutTargets",
"events:RemoveTargets",
"events:EnableRule",
"events:List*",
"events:Describe*"
],
"Resource": "*"
}
]
}
```
------
1. Cree un rol de IAM que el servicio EventBridge pueda asumir al enviar un evento a AWS Glue.
1. En la página **Crear rol** de la consola de IAM, elija **Servicio de AWS**. A continuación, elija el servicio **CloudWatch Events (Eventos de CloudWatch)**.
1. Finalice el asistente **Create role (Creación de rol)**. El asistente adjunta automáticamente las políticas `CloudWatchEventsBuiltInTargetExecutionAccess` y `CloudWatchEventsInvocationAccess`.
1. Asocie la siguiente política en línea al rol. Esta política permite que el servicio EventBridge dirija eventos a AWS Glue.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:notifyEvent"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:workflow/workflow-name"
]
}
]
}
```
------
1. Ingrese el siguiente comando para crear el flujo de trabajo.
Consulte [crear flujo de trabajo](https://docs.aws.amazon.com/cli/latest/reference/glue/create-workflow.html) en la *Referencia de comandos de AWS CLI* para obtener información acerca de los parámetros adicionales de línea de comandos opcionales.
```
aws glue create-workflow --name
```
1. Ingrese el siguiente comando para crear un desencadenador de eventos de EventBridge para el flujo de trabajo. Este será el desencadenador de inicio del flujo de trabajo. Reemplace ** con las acciones a realizar (los trabajos y los rastreadores de inicio).
Consulte [crear un desencadenador](https://docs.aws.amazon.com/cli/latest/reference/glue/create-trigger.html) en la *Referencia de comandos de AWS CLI* para obtener información acerca de cómo codificar el argumento de `actions`.
```
aws glue create-trigger --workflow-name --type EVENT --name --actions
```
Si desea que el flujo de trabajo se desencadene mediante un lote de eventos en lugar de un solo evento EventBridge, ingrese el siguiente comando en su lugar.
```
aws glue create-trigger --workflow-name --type EVENT --name --event-batching-condition BatchSize=,BatchWindow= --actions
```
Para el argumento de `event-batching-condition`, se requiere el `BatchSize`, mientras que la `BatchWindow` es opcional. Si se omite `BatchWindow`, el valor predeterminado de la ventana es 900 segundos, que es el tamaño máximo de la ventana.
**Example**
En el ejemplo siguiente se crea un desencadenador que inicia el flujo de trabajo de `eventtest`, después de que hayan llegado tres eventos de EventBridge, o cinco minutos después de que llegue el primer evento, lo que ocurra primero.
```
aws glue create-trigger --workflow-name eventtest --type EVENT --name objectArrival --event-batching-condition BatchSize=3,BatchWindow=300 --actions JobName=test1
```
1. Cree una regla en Amazon EventBridge.
1. Cree el objeto JSON para los detalles de la regla en el editor de texto que prefiera.
El ejemplo a continuación indica que Amazon S3 es el origen del evento, `PutObject` es el nombre del evento y el nombre del bucket aparece como parámetro de solicitud. Esta regla inicia un flujo de trabajo cuando llega un nuevo objeto al bucket.
```
{
"source": [
"aws.s3"
],
"detail-type": [
"AWS API Call via CloudTrail"
],
"detail": {
"eventSource": [
"s3.amazonaws.com"
],
"eventName": [
"PutObject"
],
"requestParameters": {
"bucketName": [
""
]
}
}
}
```
Para iniciar el flujo de trabajo cuando un nuevo objeto llega a una carpeta dentro del bucket, puede sustituir el código siguiente por `requestParameters`.
```
"requestParameters": {
"bucketName": [
""
]
"key" : [{ "prefix" : "//*"}}]
}
```
1. Utilice su herramienta preferida para convertir el objeto JSON de regla en una cadena de escape.
```
{\n \"source\": [\n \"aws.s3\"\n ],\n \"detail-type\": [\n \"AWS API Call via CloudTrail\"\n ],\n \"detail\": {\n \"eventSource\": [\n \"s3.amazonaws.com\"\n ],\n \"eventName\": [\n \"PutObject\"\n ],\n \"requestParameters\": {\n \"bucketName\": [\n \"\"\n ]\n }\n }\n}
```
1. Ejecute el siguiente comando para crear una plantilla de parámetros JSON que pueda editar para especificar los parámetros de entrada a un comando de `put-rule` posterior. Guarde el resultado en un archivo. En este ejemplo, el archivo se llama `ruleCommand`.
```
aws events put-rule --name --generate-cli-skeleton >ruleCommand
```
Para obtener más información sobre el parámetro `--generate-cli-skeleton`, consulte [Generar esqueleto y parámetros de entrada de AWS CLI a partir de un archivo de entrada JSON o YAML](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-skeleton.html) en la *Guía del usuario de la interfaz de línea de comandos de AWS*.
El archivo resultante debe tener el siguiente aspecto.
```
{
"Name": "",
"ScheduleExpression": "",
"EventPattern": "",
"State": "ENABLED",
"Description": "",
"RoleArn": "",
"Tags": [
{
"Key": "",
"Value": ""
}
],
"EventBusName": ""
}
```
1. Edite el archivo para eliminar parámetros de manera opcional y para especificar como mínimo los parámetros de `Name`, `EventPattern` y `State`. Para el parámetro `EventPattern`, proporcione la cadena de escape para los detalles de la regla que creó en un paso anterior.
```
{
"Name": "",
"EventPattern": "{\n \"source\": [\n \"aws.s3\"\n ],\n \"detail-type\": [\n \"AWS API Call via CloudTrail\"\n ],\n \"detail\": {\n \"eventSource\": [\n \"s3.amazonaws.com\"\n ],\n \"eventName\": [\n \"PutObject\"\n ],\n \"requestParameters\": {\n \"bucketName\": [\n \"\"\n ]\n }\n }\n}",
"State": "DISABLED",
"Description": "Start an AWS Glue workflow upon new file arrival in an Amazon S3 bucket"
}
```
**nota**
Es mejor dejar la regla deshabilitada hasta que termine de crear el flujo de trabajo.
1. Ingrese el siguiente comando `put-rule`, que lee los parámetros de entrada del `ruleCommand` del archivo.
```
aws events put-rule --name --cli-input-json file://ruleCommand
```
El siguiente resultado indica éxito.
```
{
"RuleArn": ""
}
```
1. Ingrese el siguiente comando para adjuntar la regla a un destino. El destino es el flujo de trabajo en AWS Glue. Reemplace ** con el rol que ha creado al principio de este procedimiento.
```
aws events put-targets --rule --targets "Id"="1","Arn"="arn:aws:glue:::workflow/","RoleArn"="arn:aws:iam:::role/" --region
```
El siguiente resultado indica éxito.
```
{
"FailedEntryCount": 0,
"FailedEntries": []
}
```
1. Confirme la conexión correcta de la regla y el destino al introducir el siguiente comando.
```
aws events list-rule-names-by-target --target-arn arn:aws:glue:::workflow/
```
El siguiente resultado indica el éxito, donde ** es el nombre de la regla que creó.
```
{
"RuleNames": [
""
]
}
```
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. Seleccione el flujo de trabajo y compruebe que el desencadenador de inicio y sus acciones (los trabajos o rastreadores que inicia) aparezcan en el gráfico del flujo de trabajo. Luego, continúe con el procedimiento en [Paso 3: Agregar más desencadenadores](creating_running_workflows.md#workflow-step3). O agregue más componentes al flujo de trabajo mediante la API de AWS Glue o AWS Command Line Interface.
1. Cuando el flujo de trabajo esté completamente especificado, habilite la regla.
```
aws events enable-rule --name
```
El flujo de trabajo está ahora listo para ser iniciado por un evento de EventBridge o un lote de eventos.
**Véase también**
[https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html](https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html)
[Información general de los flujos de trabajo en AWS Glue](workflows_overview.md)
[Creación y desarrollo manual de un flujo de trabajo en AWS Glue](creating_running_workflows.md)
# Visualizar los eventos de EventBridge que iniciaron un flujo de trabajo
Puede ver el ID del evento de Amazon EventBridge que inició el flujo de trabajo. Si el flujo de trabajo se inició mediante un lote de eventos, puede ver los ID de eventos de todos los eventos del lote.
Para flujos de trabajo con un tamaño de lote mayor que uno, también puede ver qué condición de lote inició el flujo de trabajo: la llegada del número de eventos en el tamaño del lote o el vencimiento de la ventana del lote.
**Para visualizar los eventos de EventBridge que iniciaron un flujo de trabajo (consola)**
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, elija **Workflows (Flujos de trabajo)**.
1. Seleccione el flujo de trabajo. Luego, en la parte inferior, elija la pestaña **History (Historial)**.
1. Seleccione una ejecución de flujo de trabajo y, a continuación, elija **View run details (Visualizar detalles de la ejecución)**.
1. En la página de detalles de la ejecución, localice el campo **Run properties (Propiedades de la ejecución)** y busque la clave **was:eventIds**.
El valor de esa clave es una lista de ID de eventos de EventBridge.
**Para visualizar los eventos de EventBridge que iniciaron un flujo de trabajo (API de AWS)**
+ Incluya el siguiente código en su script de Python.
```
workflow_params = glue_client.get_workflow_run_properties(Name=workflow_name,RunId=workflow_run_id)
batched_events = workflow_params['aws:eventIds']
```
`batched_events` será una lista de cadenas, donde cada cadena es un ID de evento.
**Véase también**
[https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html](https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html)
[Información general de los flujos de trabajo en AWS Glue](workflows_overview.md)
# Ejecución y supervisión de un flujo de trabajo en AWS Glue
Si el desencadenador de inicio de un flujo de trabajo es un desencadenador bajo demanda, puede iniciar el flujo de trabajo desde la consola de AWS Glue. Siga los pasos a continuación para ejecutar y monitorear un flujo de trabajo. Si se produce un error en el flujo de trabajo, puede ver el gráfico de ejecución para determinar el nodo fallido. Para solucionar problemas, si el flujo de trabajo se creó a partir de un proyecto, puede visualizar la ejecución del proyecto para conocer los valores de parámetros del proyecto que se utilizaron para crear el flujo de trabajo. Para obtener más información, consulte [Visualización de las ejecuciones de esquema en AWS Glue](viewing_blueprint_runs.md).
Puede ejecutar y monitorear un flujo de trabajo mediante la consola de AWS Glue, la API o AWS Command Line Interface (AWS CLI).
**Para ejecutar y monitorear un flujo de trabajo (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 **ETL**, elija **Workflows** (Flujos de trabajo).
1. Seleccione un flujo de trabajo. En el menú **Actions** (Acciones), elija **Run** (Ejecutar).
1. Compruebe la columna **Last run status (Estado de la última ejecución)** en la lista de flujos de trabajo. Elija el botón de actualización para ver el estado del flujo de trabajo en curso.
1. Mientras el flujo de trabajo se está ejecutando o después de que se haya completado (o haya fallado), vea los detalles de ejecución a través de los pasos siguientes.
1. Asegúrese de que se seleccione el flujo de trabajo y elija la pestaña **History (Historial)**.
1. Elija la ejecución del flujo de trabajo actual o más reciente y, a continuación, elija **View run details (Ver detalles de la ejecución)**.
El gráfico de tiempo de ejecución del flujo de trabajo muestra el estado actual de ejecución.
1. Elija cualquier nodo del gráfico para ver los detalles y el estado del nodo.
![\[El gráfico de ejecución muestra un desencadenador de inicio, que inicia un trabajo. Otro desencadenador controla que el trabajo se haya completado. Se selecciona el nodo de trabajo (un rectángulo que contiene un ícono de portapapeles y un nombre de trabajo) y los detalles del trabajo se muestran en el panel de la derecha. Los detalles del trabajo incluyen el ID de ejecución y el estado del trabajo.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/workflow-pre-select-resume.png)
**Para ejecutar y monitorear un flujo de trabajo (AWS CLI)**
1. Escriba el siguiente comando. Reemplace ** con el flujo de trabajo que se va a ejecutar.
```
aws glue start-workflow-run --name
```
Si el flujo de trabajo se inicia correctamente, el comando devuelve el ID de ejecución.
1. Visualice el estado de ejecución del flujo de trabajo mediante el comando `get-workflow-run`. Proporcione el nombre e ID de ejecución del flujo de trabajo.
```
aws glue get-workflow-run --name myWorkflow --run-id wr_d2af14217e8eae775ba7b1fc6fc7a42c795aed3cbcd8763f9415452e2dbc8705
```
A continuación, se muestra un ejemplo del resultado del comando.
```
{
"Run": {
"Name": "myWorkflow",
"WorkflowRunId": "wr_d2af14217e8eae775ba7b1fc6fc7a42c795aed3cbcd8763f9415452e2dbc8705",
"WorkflowRunProperties": {
"run_state": "COMPLETED",
"unique_id": "fee63f30-c512-4742-a9b1-7c8183bdaae2"
},
"StartedOn": 1578556843.049,
"CompletedOn": 1578558649.928,
"Status": "COMPLETED",
"Statistics": {
"TotalActions": 11,
"TimeoutActions": 0,
"FailedActions": 0,
"StoppedActions": 0,
"SucceededActions": 9,
"RunningActions": 0,
"ErroredActions": 0
}
}
}
```
**Véase también:**
[Información general de los flujos de trabajo en AWS Glue](workflows_overview.md)
[Información general de los esquemas en AWS Glue](blueprints-overview.md)
# Detener una ejecución de flujo de trabajo
Puede usar la consola de AWS Glue, AWS Command Line Interface (AWS CLI) o la API de AWS Glue para detener una ejecución de flujo de trabajo. Cuando detiene una ejecución de flujo de trabajo, todos los trabajos y rastreadores en ejecución finalizan inmediatamente y los trabajos y rastreadores que aún no se han iniciado nunca se llegan a iniciar. Puede tardar hasta un minuto para que todos los trabajos en ejecución y rastreadores se detengan. El estado de ejecución del flujo de trabajo pasa de **Running (Ejecución)** a **Stopping (Detención)** y cuando la ejecución del flujo de trabajo está completamente detenida, el estado pasa a **Stopped (Detenido)**.
Después de detener la ejecución del flujo de trabajo, puede ver el gráfico de ejecución para ver qué trabajos y rastreadores se han completado y cuáles nunca se han iniciado. A continuación, puede determinar si debe realizar algún paso para garantizar la integridad de los datos. Detener una ejecución de flujo de trabajo hace que no se realicen operaciones de restauración automática.
**Para detener una ejecución de flujo de trabajo (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 **ETL**, elija **Workflows** (Flujos de trabajo).
1. Elija un flujo de trabajo en ejecución y, a continuación, elija la pestaña **History (Historial)**.
1. Elija la ejecución del flujo de trabajo y, a continuación, elija **Stop run (Detener ejecución)**.
El estado de ejecución cambia a **Stopping (Detención)**.
1. (Opcional) seleccione la ejecución del flujo de trabajo, elija **View run details (Ver detalles de la ejecución)** y revise el gráfico de ejecución.
**Para detener una ejecución de flujo de trabajo (AWS CLI)**
+ Escriba el siguiente comando. Reemplace ** por el nombre del flujo de trabajo y * * por el ID de ejecución del flujo de trabajo que se va a detener.
```
aws glue stop-workflow-run --name --run-id
```
A continuación, se muestra un ejemplo del comando **stop-workflow-run**.
```
aws glue stop-workflow-run --name my-workflow --run-id wr_137b88917411d128081069901e4a80595d97f719282094b7f271d09576770354
```
# Reparar y reanudar la ejecución de un flujo de trabajo
Si uno o más nodos (trabajos o rastreadores) de un flujo de trabajo no se completan en forma correcta, esto significa que el flujo de trabajo sólo se ejecutó en forma parcial. Después de encontrar las causas raíz y realizar correcciones, puede seleccionar uno o varios nodos a partir de los cuales reanudará la ejecución del flujo de trabajo y, a continuación, retomar la ejecución del flujo de trabajo. Se ejecutarán los nodos seleccionados y todos los nodos descendentes.
**Topics**
+ [Reanudar la ejecución de un flujo de trabajo: funcionamiento](#resume-workflow-howitworks)
+ [Reanudar una ejecución de flujo de trabajo](#how-to-resume-workflow)
+ [Notas y limitaciones para reanudar las ejecuciones de flujos de trabajo](#resume-workflow-notes)
## Reanudar la ejecución de un flujo de trabajo: funcionamiento
Considere el flujo de trabajo W1 en el siguiente diagrama.
![\[Los desencadenadores se muestran en rectángulos y los trabajos se muestran en círculos. El desencadenador T1 a la izquierda inicia el flujo de trabajo con la ejecución del trabajo J1. Quedan desencadenadores y trabajos por ejecutar, pero los trabajos J2 y J3 fallan, por lo que los desencadenadores y los trabajos descendentes se muestran como no ejecutados.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/workflow_W1.png)
La ejecución del flujo de trabajo continúa de la siguiente manera:
1. El desencadenador T1 inicia el trabajo J1.
1. La finalización exitosa de J1 activa los desencadenadores T2 y T3, que ejecutan los trabajos J2 y J3, respectivamente.
1. Los trabajos J2 y J3 fallan.
1. Los desencadenadores T4 y T5 no se activan ya que dependen de la finalización exitosa de J2 y J3, por lo tanto, los trabajos J4 y J5 no se ejecutan. El flujo de trabajo W1 sólo se ejecuta en forma parcial.
Suponga que se corrigen los problemas que causaron que J2 y J3 fallaran. J2 y J3 se seleccionan como puntos de partida para reanudar la ejecución del flujo de trabajo.
![\[Los trabajos J2 y J3 se marcan como nodos que se reanudarán. Los desencadenadores y los trabajos descendentes se muestran como ejecutados en forma correcta.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/workflow_W1_resumed.png)
La ejecución del flujo de trabajo se reanuda de la siguiente manera:
1. Los trabajos J2 y J3 se ejecutan con éxito.
1. Se activan los desencadenadores T4 y T5.
1. Los trabajos J4 y J5 se ejecutan con éxito.
La ejecución del flujo de trabajo reanudado se realiza como una ejecución de flujo de trabajo independiente con un nuevo ID de ejecución. Cuando visualice el historial del flujo de trabajo, puede ver el ID de ejecución anterior para cualquier ejecución de flujo de trabajo. En el ejemplo de la siguiente captura de pantalla, la ejecución del flujo de trabajo con el ID de ejecución `wr_c7a22...` (segunda fila) tenía un nodo que no se completó. El usuario solucionó el problema y reanudó la ejecución del flujo de trabajo, lo que dio lugar a un ID de ejecución `wr_a07e55...` (primera fila).
![\[La pestaña History (Historial) de un flujo de trabajo incluye una tabla que contiene dos filas, una por cada ejecución del flujo de trabajo. La primera fila incluye un ID de ejecución y un ID de ejecución anterior. La segunda fila sólo tiene un ID de ejecución. El ID de ejecución anterior en la primera fila es el mismo que el ID de ejecución de la segunda fila.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/previous-run-id.png)
**nota**
De aquí en adelante, el término “ejecución de flujo de trabajo reanudado” hace referencia a la ejecución del flujo de trabajo que se creó cuando se reanudó la ejecución del flujo de trabajo anterior. La “ejecución de flujo de trabajo original” se refiere a la ejecución del flujo de trabajo que sólo se ejecutó en forma parcial y que debió reanudarse.
**Gráfico de ejecución de flujo de trabajo reanudado**
En una ejecución de flujo de trabajo reanudado, aunque sólo se ejecuta un subconjunto de nodos, el gráfico de ejecución es un gráfico completo. Es decir, los nodos que no se ejecutaron en el flujo de trabajo reanudado se copian del gráfico de ejecución de flujo de trabajo original. Los nodos de trabajo y rastreador copiados que se ejecutaron en la ejecución de flujo de trabajo original incluyen detalles de la ejecución.
Considere una vez más el flujo de trabajo W1 en el diagrama anterior. Cuando se reanuda la ejecución del flujo de trabajo a partir de J2 y J3, el gráfico de ejecución de flujo de trabajo reanudado muestra todos los trabajos, de J1 a J5, y todos los desencadenadores, de T1 a T5. Los detalles de la ejecución de J1 se copian desde la ejecución de flujo de trabajo original.
**Instantáneas de flujos de trabajo**
Cuando se inicia una ejecución de flujo de trabajo, AWS Glue toma una instantánea del gráfico de diseño del flujo de trabajo en ese momento. Esa instantánea se utiliza durante toda la ejecución del flujo de trabajo. Si realiza cambios en los desencadenadores después de que se inicie la ejecución, esos cambios no afectan la ejecución del flujo de trabajo actual. Las instantáneas garantizan que las ejecuciones de flujo de trabajo se realicen de manera coherente.
Las instantáneas hacen que solo los desencadenadores sean inmutables. Los cambios que realice en los trabajos y rastreadores descendentes durante la ejecución del flujo de trabajo surtirán efecto para la ejecución actual.
## Reanudar una ejecución de flujo de trabajo
Siga estos pasos para reanudar una ejecución de flujo de trabajo. Puede reanudar una ejecución de flujo de trabajo mediante la consola de AWS Glue, la API, o AWS Command Line Interface (AWS CLI).
**Para reanudar un flujo de trabajo (consola)**
1. Abra la consola de AWS Glue en [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Inicie sesión como usuario con permisos para visualizar flujos de trabajo y reanudar ejecuciones de flujos de trabajo.
**nota**
Para reanudar ejecuciones de flujo de trabajo, necesita el permiso `glue:ResumeWorkflowRun` de AWS Identity and Access Management (IAM).
1. En el panel de navegación, elija **Workflows (Flujos de trabajo)**.
1. Seleccione un flujo de trabajo y, a continuación, elija la pestaña **History (Historial)**.
1. Seleccione la ejecución de flujo de trabajo que se ejecutó sólo en forma parcial y, a continuación, elija **View run details (Visualizar los detalles de la ejecución)**.
1. En el gráfico de ejecución, seleccione el primer (o único) nodo que desea reiniciar y desde el que desea reanudar la ejecución del flujo de trabajo.
1. En el panel de detalles situado a la derecha del gráfico, seleccione la casilla de verificación **Resume (Reanudar)**.
![\[El gráfico de ejecución muestra tres nodos, incluido un nodo de trabajo fallido. El panel de detalles del trabajo a la derecha incluye la casilla de verificación Resume (Reanudar).\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/workflow-pre-select-resume.png)
El nodo cambia de color y muestra un pequeño ícono de reanudación en la parte superior derecha.
![\[En el texto se describe el cambio al gráfico de ejecución. La casilla de verificación Resume (Reanudar) está activada.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/workflow-post-select-resume.png)
1. Complete los dos pasos anteriores para reiniciar cualquier otro nodo adicional.
1. Elija **Resume run (Reanudar ejecución)**.
**Para retomar la ejecución de un flujo de trabajo (AWS CLI)**
1. Asegúrese de que dispone del permiso `glue:ResumeWorkflowRun` de IAM.
1. Recupere los ID de nodo para los nodos que desee reiniciar.
1. Ejecute el comando `get-workflow-run` para la ejecución del flujo de trabajo original. Proporcione el nombre del flujo de trabajo y el ID de ejecución, y agregue la opción `--include-graph`, como se muestra en el ejemplo a continuación. Obtenga el ID de ejecución de la pestaña **History (Historial)** en la consola, o ejecute el comando `get-workflow`.
```
aws glue get-workflow-run --name cloudtrailtest1 --run-id wr_a07e55f2087afdd415a404403f644a4265278f68b13ba3da08c71924ebe3c3a8 --include-graph
```
El comando devuelve los nodos y los bordes del gráfico como un objeto JSON grande.
1. Localice los nodos de interés en función de las propiedades de `Type` y `Name` de los objetos del nodo.
A continuación, se muestra un resultado de objeto de nodo a modo de ejemplo.
```
{
"Type": "JOB",
"Name": "test1_post_failure_4592978",
"UniqueId": "wnode_d1b2563c503078b153142ee76ce545fe5ceef66e053628a786ddd74a05da86fd",
"JobDetails": {
"JobRuns": [
{
"Id": "jr_690b9f7fc5cb399204bc542c6c956f39934496a5d665a42de891e5b01f59e613",
"Attempt": 0,
"TriggerName": "test1_aggregate_failure_649b2432",
"JobName": "test1_post_failure_4592978",
"StartedOn": 1595358275.375,
"LastModifiedOn": 1595358298.785,
"CompletedOn": 1595358298.785,
"JobRunState": "FAILED",
"PredecessorRuns": [],
"AllocatedCapacity": 0,
"ExecutionTime": 16,
"Timeout": 2880,
"MaxCapacity": 0.0625,
"LogGroupName": "/aws-glue/python-jobs"
}
]
}
}
```
1. Obtenga el ID del nodo de la propiedad `UniqueId` del objeto del nodo.
1. Ejecute el comando `resume-workflow-run`. Especifique el nombre del flujo de trabajo, el ID de ejecución y la lista de ID de nodos separados por espacios, como se muestra en el siguiente ejemplo.
```
aws glue resume-workflow-run --name cloudtrailtest1 --run-id wr_a07e55f2087afdd415a404403f644a4265278f68b13ba3da08c71924ebe3c3a8 --node-ids wnode_ca1f63e918fb855e063aed2f42ec5762ccf71b80082ae2eb5daeb8052442f2f3 wnode_d1b2563c503078b153142ee76ce545fe5ceef66e053628a786ddd74a05da86fd
```
El comando arroja el ID de ejecución de la ejecución del flujo de trabajo reanudado (nuevo) y una lista de los nodos que se iniciarán.
```
{
"RunId": "wr_2ada0d3209a262fc1156e4291134b3bd643491bcfb0ceead30bd3e4efac24de9",
"NodeIds": [
"wnode_ca1f63e918fb855e063aed2f42ec5762ccf71b80082ae2eb5daeb8052442f2f3"
]
}
```
Tenga en cuenta que aunque el comando `resume-workflow-run` de ejemplo enumeró dos nodos que se reiniciarán, el resultado de ejemplo indicaba que sólo se reiniciaría un nodo. Esto se debe a que un nodo era descendente al otro, y el nodo descendente se reiniciaría de todos modos como resultado de los pasos habituales del flujo de trabajo.
## Notas y limitaciones para reanudar las ejecuciones de flujos de trabajo
Tenga en cuenta las siguientes notas y limitaciones al reanudar las ejecuciones de flujos de trabajo.
+ Puede reanudar la ejecución de un flujo de trabajo sólo si se encuentra en el estado `COMPLETED`.
**nota**
Incluso si uno o más nodos en la ejecución de un flujo de trabajo no se completan, el estado de ejecución del flujo de trabajo se muestra como `COMPLETED`. Asegúrese de verificar el gráfico de ejecución para detectar los nodos que no se completaron en forma correcta.
+ Puede reanudar la ejecución de un flujo de trabajo desde cualquier nodo de trabajo o rastreador que la ejecución de flujo de trabajo original haya intentado ejecutar. No se puede reanudar la ejecución de un flujo de trabajo desde un nodo de desencadenador.
+ Al reiniciar un nodo no se restablece su estado. Los datos que se hayan procesado parcialmente no se revertirán.
+ Puede reanudar varias veces la ejecución de un flujo de trabajo que haya fallado. Sin embargo, una ejecución reanudada solo puede reanudarse una vez más. Para reintentos adicionales, reanude la ejecución original que falló.
+ Si selecciona dos nodos para reiniciar y dependen uno del otro, el nodo ascendente se ejecuta antes que el nodo descendente. De hecho, seleccionar el nodo descendente es redundante, ya que se ejecutará de acuerdo con los pasos habituales del flujo de trabajo.
# Obtención y configuración de propiedades de ejecución de flujo de trabajo en AWS Glue
Utilice propiedades de ejecución de flujo de trabajo para compartir y administrar el estado entre los trabajos en su flujo de trabajo de AWS Glue. Puede definir propiedades de ejecución predeterminadas cuando cree el flujo de trabajo. Por lo tanto, a medida que se ejecutan los trabajos, puede recuperar los valores de propiedad de ejecución y modificarlos opcionalmente para la introducción en trabajos que estén después en el flujo de trabajo. Cuando un trabajo modifica una propiedad de ejecución, el nuevo valor existe solo para la ejecución del flujo de trabajo. Las propiedades de ejecución predeterminadas no se ven afectadas.
Si su trabajo de AWS Glue no forma parte de un flujo de trabajo, estas propiedades no se establecerán.
El siguiente código de Python de ejemplo de un trabajo de extracción, transformación y carga (ETL) muestra cómo obtener las propiedades de ejecución de flujo de trabajo.
```
import sys
import boto3
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from awsglue.context import GlueContext
from pyspark.context import SparkContext
glue_client = boto3.client("glue")
args = getResolvedOptions(sys.argv, ['JOB_NAME','WORKFLOW_NAME', 'WORKFLOW_RUN_ID'])
workflow_name = args['WORKFLOW_NAME']
workflow_run_id = args['WORKFLOW_RUN_ID']
workflow_params = glue_client.get_workflow_run_properties(Name=workflow_name,
RunId=workflow_run_id)["RunProperties"]
target_database = workflow_params['target_database']
target_s3_location = workflow_params['target_s3_location']
```
El siguiente código continúa con la configuración de la propiedad de ejecución `target_format` en `'csv'`.
```
workflow_params['target_format'] = 'csv'
glue_client.put_workflow_run_properties(Name=workflow_name, RunId=workflow_run_id, RunProperties=workflow_params)
```
Para obtener más información, consulte los siguientes temas:
+ [Acción GetWorkflowRunProperties (Python: get\$1workflow\$1run\$1properties)](aws-glue-api-workflow.md#aws-glue-api-workflow-GetWorkflowRunProperties)
+ [PutWorkflowRunProperties Action (Python: put\$1workflow\$1run\$1properties)](aws-glue-api-workflow.md#aws-glue-api-workflow-PutWorkflowRunProperties)
# Consulta de flujos de trabajo mediante la AWS Glue API
AWS Glue proporciona una API enriquecida para administrar flujos de trabajo. Puede recuperar una vista estática de un flujo de trabajo o una vista dinámica de un flujo de trabajo en ejecución mediante la AWS Glue API. Para obtener más información, consulte [Flujos de trabajo](aws-glue-api-workflow.md).
**Topics**
+ [Consulta de vistas estáticas](#workflows_api_concepts_static)
+ [Consulta de vistas dinámicas](#workflows_api_concepts_dynamic)
## Consulta de vistas estáticas
Utilice la operación de la API de `GetWorkflow` para obtener una vista estática que indique el diseño de un flujo de trabajo. Esta operación devuelve un gráfico dirigido que consiste en nodos y perímetros en los que el nodo representa un desencadenador, un trabajo o un rastreador. Los perímetros definen las relaciones entre nodos. Se representan mediante conectores (flechas) en el gráfico en la consola de AWS Glue.
También puede utilizar esta operación con bibliotecas de procesamiento de gráficos conocidas, como NetworkX, igraph, JGraphT y el marco de trabajo Java Universal Network/Graph (JUNG). Puesto que todas estas bibliotecas representan gráficos de forma similar, se precisan transformaciones mínimas.
La vista estática devuelta por esta API es la vista más actualizada según la última definición de desencadenadores asociados a este flujo de trabajo.
### Definición de gráfico
Un gráfico de flujo de trabajo G es un par ordenador (N, E), donde N es un conjunto de nodos y E un conjunto de perímetros. Un *nodo* es un vértice en el gráfico identificado mediante un número único. Un nodo puede ser de tipo desencadenador, trabajo o rastreador. Por ejemplo: `{name:T1, type:Trigger, uniqueId:1}, {name:J1, type:Job, uniqueId:2}`.
Un *perímetro* es una tupla doble del formulario (`src, dest`), donde `src` y `dest` son los nodos y hay un perímetro dirigido desde `src` a `dest`.
### Ejemplo de consulta de una vista estática
Considere un desencadenador condicional T, que desencadena el trabajo J2 una vez que se completa el trabajo J1.
```
J1 ---> T ---> J2
```
Nodos: J1, T, J2
Perímetros: (J1, T), (T, J2)
## Consulta de vistas dinámicas
Utilice la operación de la API de `GetWorkflowRun` para obtener una vista dinámica de un flujo de trabajo en ejecución. Esta operación devuelve la misma vista estática del gráfico junto con metadatos relacionados con la ejecución de flujo de datos.
Para la ejecución, los nodos que representan trabajos en la llamada de `GetWorkflowRun` tienen una lista de ejecuciones de trabajo iniciadas como parte de la última ejecución del flujo de trabajo. Puede utilizar esta lista para mostrar el estado de ejecución de cada trabajo en el propio gráfico. Para dependencias descendentes que no se están ejecutando aún, este campo se establece en `null`. La información del gráfico le permitirá conocer el estado actual de cualquier flujo de trabajo en cualquier momento.
La vista dinámica devuelta por esta API se basa en la vista estática que estuviera presente cuando se inició la ejecución de flujo de trabajo.
*Ejemplo de nodos de tiempo de ejecución:* `{name:T1, type: Trigger, uniqueId:1}`, `{name:J1, type:Job, uniqueId:2, jobDetails:{jobRuns}}`, `{name:C1, type:Crawler, uniqueId:3, crawlerDetails:{crawls}}`
### Ejemplo 1: Vista dinámica
En el siguiente ejemplo se muestra un flujo de trabajo de dos desencadenadores simple.
+ Nodos: t1, j1, t2, j2
+ Perímetros: (t1, j1), (j1, t2), (t2, j2)
La respuesta `GetWorkflow` contiene lo siguiente.
```
{
Nodes : [
{
"type" : Trigger,
"name" : "t1",
"uniqueId" : 1
},
{
"type" : Job,
"name" : "j1",
"uniqueId" : 2
},
{
"type" : Trigger,
"name" : "t2",
"uniqueId" : 3
},
{
"type" : Job,
"name" : "j2",
"uniqueId" : 4
}
],
Edges : [
{
"sourceId" : 1,
"destinationId" : 2
},
{
"sourceId" : 2,
"destinationId" : 3
},
{
"sourceId" : 3,
"destinationId" : 4
}
}
```
La respuesta `GetWorkflowRun` contiene lo siguiente.
```
{
Nodes : [
{
"type" : Trigger,
"name" : "t1",
"uniqueId" : 1,
"jobDetails" : null,
"crawlerDetails" : null
},
{
"type" : Job,
"name" : "j1",
"uniqueId" : 2,
"jobDetails" : [
{
"id" : "jr_12334",
"jobRunState" : "SUCCEEDED",
"errorMessage" : "error string"
}
],
"crawlerDetails" : null
},
{
"type" : Trigger,
"name" : "t2",
"uniqueId" : 3,
"jobDetails" : null,
"crawlerDetails" : null
},
{
"type" : Job,
"name" : "j2",
"uniqueId" : 4,
"jobDetails" : [
{
"id" : "jr_1233sdf4",
"jobRunState" : "SUCCEEDED",
"errorMessage" : "error string"
}
],
"crawlerDetails" : null
}
],
Edges : [
{
"sourceId" : 1,
"destinationId" : 2
},
{
"sourceId" : 2,
"destinationId" : 3
},
{
"sourceId" : 3,
"destinationId" : 4
}
}
```
### Ejemplo 2: Varios trabajos con desencadenador condicional
En el siguiente ejemplo se muestra un flujo de trabajo con varios trabajos y un desencadenador condicional (t3).
```
Consider Flow:
T(t1) ---> J(j1) ---> T(t2) ---> J(j2)
| |
| |
>+------> T(t3) <-----+
|
|
J(j3)
Graph generated:
Nodes: t1, t2, t3, j1, j2, j3
Edges: (t1, j1), (j1, t2), (t2, j2), (j1, t3), (j2, t3), (t3, j3)
```
# Restricciones de esquemas y flujos de trabajo en AWS Glue
A continuación se incluyen las restricciones correspondientes a los proyectos y flujos de trabajo.
## Restricciones de esquemas
Tenga en cuenta las siguientes restricciones de proyectos:
+ El proyecto debe estar registrado en la misma región de AWS donde reside el bucket de Amazon S3.
+ Para compartir proyectos entre cuentas de AWS debe conceder permisos de lectura en el archivo ZIP del proyecto en Amazon S3. Los clientes que tengan permiso de lectura en el archivo ZIP de un proyecto pueden registrar el proyecto en su cuenta de AWS y utilizarlo.
+ El conjunto de parámetros del proyecto se almacena como un único objeto JSON. La longitud máxima de este objeto es de 128 KB.
+ El tamaño máximo sin comprimir del archivo ZIP del proyecto es de 5 MB. El tamaño máximo de compresión es de 1 MB.
+ Limite la cantidad total de trabajos, rastreadores y desencadenadores de un flujo de trabajo a 100 o menos. Si incluye más de 100, es posible que se produzcan errores al intentar reanudar o detener las ejecuciones del flujo de trabajo.
## Restricciones del flujo de datos
Tenga en cuenta las siguientes restricciones de flujos de trabajo. Algunos de estos comentarios están dirigidos a un usuario que crea flujos de trabajo en forma manual.
+ El tamaño máximo de lote para un desencadenador de eventos de Amazon EventBridge es 100. El tamaño máximo de la ventana es de 900 segundos (15 minutos).
+ Un desencadenador se puede asociar solo a un flujo de trabajo.
+ Solo se permite un desencadenador de arranque (bajo demanda o de programación).
+ Si un desencadenador externo a un flujo de trabajo inicia un trabajo o rastreador dentro del flujo, no se activarán los desencadenadores incluidos en el flujo de trabajo que dependan de la finalización del trabajo o del rastreador (correcta o no).
+ Del mismo modo, si un trabajo o rastreador de un flujo de trabajo tiene desencadenadores que dependen de la finalización del trabajo o del rastreador (correcta o no), tanto dentro del flujo de trabajo como fuera de este, si el trabajo o el rastreador se inicia desde dentro de un flujo de trabajo, solo los desencadenadores incluidos en el flujo de trabajo se activan al finalizar el trabajo o el rastreador.
# Solución de errores de esquema en AWS Glue
Si detecta errores al utilizar proyectos en AWS Glue, utilice las siguientes soluciones como ayuda para encontrar la fuente de los problemas y corregirlos.
**Topics**
+ [Error: falta el módulo PySpark](#blueprint-workflow-error-1)
+ [Error: falta el archivo de configuración del proyecto](#blueprint-workflow-error-2)
+ [Error: falta archivo importado](#blueprint-workflow-error-3)
+ [Error: no autorizado a realizar iamPassRole en el recurso](#blueprint-workflow-error-4)
+ [Error: programación cron no válida](#blueprint-workflow-error-5)
+ [Error: ya existe un desencadenador con ese nombre](#blueprint-workflow-error-6)
+ [Error: el flujo de trabajo con el nombre: foo ya existe.](#blueprint-workflow-error-7)
+ [Error: no se encontró el módulo en la ruta de LayoutGenerator especificada](#blueprint-workflow-error-8)
+ [Error: error de validación en el campo Connections (Conexiones)](#blueprint-workflow-error-9)
## Error: falta el módulo PySpark
AWS Glue devuelve el error “Unknown error executing layout generator function ModuleNotFoundError: No module named 'pyspark' (Error desconocido al ejecutar la función del generador de diseño ModuleNotFounderError: no hay módulo llamado 'pyspark')”.
Cuando descomprime el archivo del proyecto, podría suceder cualquiera de los dos casos que figuran a continuación:
```
$ unzip compaction.zip
Archive: compaction.zip
creating: compaction/
inflating: compaction/blueprint.cfg
inflating: compaction/layout.py
inflating: compaction/README.md
inflating: compaction/compaction.py
$ unzip compaction.zip
Archive: compaction.zip
inflating: blueprint.cfg
inflating: compaction.py
inflating: layout.py
inflating: README.md
```
En el primer caso, todos los archivos relacionados con el proyecto se colocaron en una carpeta denominada compaction y luego se convirtió en un archivo zip llamado *compaction.zip*.
En el segundo caso, todos los archivos necesarios para el proyecto no se incluyeron en una carpeta y se agregaron como archivos raíz en el archivo zip *compaction.zip*.
Se permite crear un archivo en cualquiera de los formatos anteriores. Sin embargo, asegúrese de que `blueprint.cfg` tiene la ruta correcta al nombre de la función en el script que genera el diseño.
**Ejemplos**
En el caso 1: `blueprint.cfg` debería tener `layoutGenerator` como lo siguiente:
```
layoutGenerator": "compaction.layout.generate_layout"
```
En el caso 2: `blueprint.cfg` debería tener `layoutGenerator` como lo siguiente
```
layoutGenerator": "layout.generate_layout"
```
Si esta ruta no se incluye en forma correcta, podría ver un error como el que se indica. Por ejemplo, si tiene la estructura de carpetas como se menciona en el caso 2 y tiene el `layoutGenerator` indicado como en el caso 1, puede ver el error anterior.
## Error: falta el archivo de configuración del proyecto
AWS Glue devuelve el error “Unknown error executing layout generator function FileNotFoundError: [Errno 2] No such file or directory: '/tmp/compaction/blueprint.cfg' (Error desconocido al ejecutar la función del generador de diseño FileNotFoundError: [Errno 2] no existe tal archivo o directorio: '/tmp/compaction/blueprint.cfg')”.
El blueprint.cfg debe colocarse en el nivel raíz del archivo ZIP o dentro de una carpeta que tenga el mismo nombre que el archivo ZIP.
Cuando extraemos el archivo ZIP del proyecto, se espera que blueprint.cfg se encuentre en una de las siguientes rutas. Si no se encuentra en una de las siguientes rutas, puede ver el error anterior.
```
$ unzip compaction.zip
Archive: compaction.zip
creating: compaction/
inflating: compaction/blueprint.cfg
$ unzip compaction.zip
Archive: compaction.zip
inflating: blueprint.cfg
```
## Error: falta archivo importado
AWS Glue devuelve el error “Unknown error executing layout generator function FileNotFoundError: [Errno 2] No such file or directory:\$1 \$1'demo-project/foo.py' (Error desconocido al ejecutar la función del generador de diseño FileNotFoundError: [Errno 2] no existe tal archivo o directorio:\$1 \$1'demo-project/foo.py')”.
Si el script de generación de diseño tiene funcionalidad para leer otros archivos, asegúrese de proporcionar una ruta completa para el archivo que se va a importar. Por ejemplo, se puede hacer referencia al script Conversion.py en Layout.py. Para obtener más información, consulte [Esquema de ejemplo](https://docs.aws.amazon.com/glue/latest/dg/developing-blueprints-sample.html).
## Error: no autorizado a realizar iamPassRole en el recurso
AWS Glue devuelve el error “User: arn:aws:sts::123456789012:assumed-role/AWSGlueServiceRole/GlueSession is not authorized to perform: iam:PassRole on resource: arn:aws:iam::123456789012:role/AWSGlueServiceRole (Usuario: arn:aws:sts::123456789012:assumed-role/AWSGlueServiceRole/GlueSession no está autorizado para realizar: iam:PassRole en el recurso: arn:aws:iam:: 123456789012:role/AWSGlueServicerole)”
Si los trabajos y rastreadores del flujo de trabajo asumen el mismo rol que el rol transferido para crear el flujo de trabajo a partir del proyecto, el rol del proyecto debe incluir el permiso `iam:PassRole`.
Si los trabajos y rastreadores del flujo de trabajo asumen un rol distinto que el rol transferido para crear las entidades del flujo de trabajo a partir del proyecto, el rol del proyecto debe incluir el permiso `iam:PassRole` en ese otro rol, en lugar de en el rol del proyecto.
Para obtener más información, consulte [Permisos para roles de esquema](https://docs.aws.amazon.com/glue/latest/dg/blueprints-personas-permissions.html#blueprints-role-permissions).
## Error: programación cron no válida
AWS Glue devuelve el error “The schedule cron(0 0 \$1 \$1 \$1 \$1) is invalid [El cron de programación (0 0 \$1 \$1 \$1 \$1) no es válido]”.
Proporcione una expresión [cron](https://en.wikipedia.org/wiki/Cron) válida. Para obtener más información, consulte [Programaciones basadas en tiempo para trabajos y rastreadores](https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html).
## Error: ya existe un desencadenador con ese nombre
AWS Glue devuelve el error “Trigger with name 'foo\$1starting\$1trigger' already submitted with different configuration (Desencadenador con nombre 'foo\$1starting\$1trigger' ya enviado con una configuración diferente)”.
Un proyecto no requiere que defina desencadenadores en el script de diseño para la creación del flujo de trabajo. La creación de desencadenadores es administrada por la biblioteca de proyectos en función de las dependencias definidas entre dos acciones.
La denominación de los desencadenadores es la siguiente:
+ Para el desencadenador de inicio en el flujo de trabajo, la denominación es \$1starting\$1trigger.
+ Para un nodo (trabajo/rastreador) en el flujo de trabajo que depende de la finalización de uno o varios nodos ascendentes; AWS Glue define un desencadenador con el nombre \$1\$1trigger
Este error significa que ya existe un desencadenador con ese nombre. Puede eliminar el desencadenador existente y volver a ejecutar la creación del flujo de trabajo.
**nota**
Al eliminar un flujo de trabajo no se eliminan los nodos del flujo de trabajo. Es posible que aunque se elimine el flujo de trabajo, los desencadenadores permanezcan. Debido a esto, es posible que no reciba un error de “workflow already exists (el flujo de trabajo ya existe)”, pero puede recibir un error de “trigger already exists (el desencadenador ya existe)” en un caso en el que cree un flujo de trabajo, lo elimine y luego intente volver a crearlo con el mismo nombre y a partir del mismo proyecto.
## Error: el flujo de trabajo con el nombre: foo ya existe.
El nombre del flujo de trabajo debe ser único. Inténtelo con un nombre diferente.
## Error: no se encontró el módulo en la ruta de LayoutGenerator especificada
AWS Glue devuelve el error “Unknown error executing layout generator function ModuleNotFoundError: No module named 'crawl\$1s3\$1locations' (Error desconocido al ejecutar la función del generador de diseño ModuleNotFoundError: no hay módulo llamado 'crawl\$1s3\$1locations')”.
```
layoutGenerator": "crawl_s3_locations.layout.generate_layout"
```
Por ejemplo, si tiene la ruta de acceso LayoutGenerator anterior, cuando descomprima el archivo del proyecto, debe tener el siguiente aspecto:
```
$ unzip crawl_s3_locations.zip
Archive: crawl_s3_locations.zip
creating: crawl_s3_locations/
inflating: crawl_s3_locations/blueprint.cfg
inflating: crawl_s3_locations/layout.py
inflating: crawl_s3_locations/README.md
```
Cuando descomprime el archivo, si el archivo del proyecto se ve de la siguiente manera, entonces puede obtener el error anterior.
```
$ unzip crawl_s3_locations.zip
Archive: crawl_s3_locations.zip
inflating: blueprint.cfg
inflating: layout.py
inflating: README.md
```
Puede ver que no hay ninguna carpeta llamada `crawl_s3_locations` y cuando la ruta `layoutGenerator` se refiere al archivo de diseño a través del módulo `crawl_s3_locations`, puede obtener el error anterior.
## Error: error de validación en el campo Connections (Conexiones)
AWS Glue devuelve el error “Unknown error executing layout generator function TypeError: Value ['foo'] for key Connections should be of type \$1 (Error desconocido al ejecutar la función del generador de diseño TypeError: el valor ['foo'] para las conexiones clave debe ser de tipo \$1)”.
Este es un error de validación. El campo `Connections` en la clase `Job` espera un diccionario y en su lugar se proporciona una lista de valores que causan el error.
```
User input was list of values
Connections= ['string']
Should be a dict like the following
Connections*=*{'Connections': ['string']}
```
Para evitar estos errores de tiempo de ejecución al crear un flujo de trabajo a partir de un proyecto, puede validar las definiciones de flujo de trabajo, trabajo y rastreador como se describe en [Realizar pruebas de un esquema](https://docs.aws.amazon.com/glue/latest/dg/developing-blueprints-testing.html).
Consulte la sintaxis en [Referencia a clases de proyectos de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/developing-blueprints-code-classes.html) para definir el trabajo, rastreador y flujo de trabajo de AWS Glue en el script de diseño.
# Permisos de personas y roles para esquemas de AWS Glue
Las siguientes son las personas típicas y las políticas de permisos de AWS Identity and Access Management (IAM) sugeridas para personas y roles en relación con esquemas de AWS Glue.
**Topics**
+ [Personas para esquemas](#blueprints-personas)
+ [Permisos de personas para esquemas](#blueprints-permssions)
+ [Permisos para roles de esquema](#blueprints-role-permissions)
## Personas para esquemas
Las siguientes son las personas generalmente involucradas en el ciclo de vida de un esquema de AWS Glue.
| Persona | Descripción |
| --- | --- |
| AWS GlueDesarrollador de | Desarrolla, prueba y publica proyectos. |
| AWS GlueAdministrador de | Registra, mantiene y concede permisos para proyectos. |
| Analista de datos | Ejecuta proyectos para crear flujos de trabajo. |
Para obtener más información, consulte [Información general de los esquemas en AWS Glue](blueprints-overview.md).
## Permisos de personas para esquemas
Los siguientes son los permisos sugeridos para cada persona del proyecto.
### Permisos de desarrollador de AWS Glue para esquemas
El desarrollador de AWS Glue debe tener permisos de escritura en el bucket de Amazon S3 que se utiliza para publicar el esquema. A general, el desarrollador registra el proyecto después de cargarlo. En ese caso, el desarrollador necesita los permisos enumerados en [Permisos de administrador de AWS Glue para esquemas](#bp-persona-admin). Además, si el desarrollador desea probar el proyecto después de su registro, también necesita los permisos enumerados en [Permisos de analista de datos para esquemas](#bp-persona-analyst).
### Permisos de administrador de AWS Glue para esquemas
La política siguiente concede permisos para registrar, ver y mantener esquemas de AWS Glue.
**importante**
En la siguiente política , reemplace ** y ** con la ruta de Amazon S3 a los archivos ZIP de proyecto cargados que se registrarán.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:CreateBlueprint",
"glue:UpdateBlueprint",
"glue:DeleteBlueprint",
"glue:GetBlueprint",
"glue:ListBlueprints",
"glue:BatchGetBlueprints"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/prefix/*"
}
]
}
```
------
### Permisos de analista de datos para esquemas
La siguiente política concede permisos para ejecutar proyectos y ver el flujo de trabajo y sus componentes resultantes. También concede `PassRole` al rol que AWS Glue asume para crear el flujo de trabajo y sus componentes.
La política concede permisos sobre cualquier recurso. Si desea configurar el acceso detallado a proyectos individuales, utilice el siguiente formato para los ARN de proyecto:
```
arn:aws:glue:::blueprint/
```
**importante**
En la siguiente política, reemplace ** por una cuenta de AWS válida y reemplace ** por el nombre del rol utilizado para ejecutar un proyecto. Consulte [Permisos para roles de esquema](#blueprints-role-permissions) para obtener los permisos que requiere este rol.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:ListBlueprints",
"glue:GetBlueprint",
"glue:StartBlueprintRun",
"glue:GetBlueprintRun",
"glue:GetBlueprintRuns",
"glue:GetCrawler",
"glue:ListTriggers",
"glue:ListJobs",
"glue:BatchGetCrawlers",
"glue:GetTrigger",
"glue:BatchGetWorkflows",
"glue:BatchGetTriggers",
"glue:BatchGetJobs",
"glue:BatchGetBlueprints",
"glue:GetWorkflowRun",
"glue:GetWorkflowRuns",
"glue:ListCrawlers",
"glue:ListWorkflows",
"glue:GetJob",
"glue:GetWorkflow",
"glue:StartWorkflowRun"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::111122223333:role/role-name"
}
]
}
```
------
## Permisos para roles de esquema
Los siguientes son los permisos sugeridos para el rol de IAM utilizado para crear un flujo de trabajo a partir de un proyecto. El rol debe tener una relación de confianza con `glue.amazonaws.com`.
**importante**
En la siguiente política, reemplace ** por una cuenta de AWS válida y reemplace ** por el nombre del rol.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:CreateJob",
"glue:GetCrawler",
"glue:GetTrigger",
"glue:DeleteCrawler",
"glue:CreateTrigger",
"glue:DeleteTrigger",
"glue:DeleteJob",
"glue:CreateWorkflow",
"glue:DeleteWorkflow",
"glue:GetJob",
"glue:GetWorkflow",
"glue:CreateCrawler"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::111122223333:role/role-name"
}
]
}
```
------
**nota**
Si los trabajos y los rastreadores del flujo de trabajo asumen un rol distinto de este rol, esta política debe incluir el permiso `iam:PassRole` en ese otro rol en lugar de en el rol del proyecto.
# Desarrollo de esquemas en AWS Glue
Es posible que su organización tenga un conjunto de casos de uso de ETL similares que podrían beneficiarse al poder parametrizar un único flujo de trabajo para manejarlos todos. Para esto, AWS Glue permite definir *esquemas*, que se pueden utilizar para generar flujos de trabajo. Un proyecto acepta parámetros, de modo que a partir de un único proyecto, un analista de datos puede crear diferentes flujos de trabajo para manejar casos de uso de ETL similares. Después de crear un proyecto, puede reutilizarlo para diferentes departamentos, equipos y proyectos.
**Topics**
+ [Información general de los esquemas en AWS Glue](blueprints-overview.md)
+ [Desarrollo de esquemas en AWS Glue](developing-blueprints.md)
+ [Registrar un esquema en AWS Glue](registering-blueprints.md)
+ [Visualización de esquemas en AWS Glue](viewing_blueprints.md)
+ [Actualizar un esquema en AWS Glue](updating_blueprints.md)
+ [Creación de un flujo de trabajo a partir de un esquema en AWS Glue](creating_workflow_blueprint.md)
+ [Visualización de las ejecuciones de esquema en AWS Glue](viewing_blueprint_runs.md)
# Información general de los esquemas en AWS Glue
**nota**
En este momento, la característica de esquemas no está disponible en las siguientes regiones de la consola de AWS Glue: Asia Pacífico (Yakarta) y Medio Oriente (Emiratos Árabes Unidos).
Los esquemas de AWS Glue proporcionan una forma de crear y compartir flujos de trabajo de AWS Glue. Cuando hay un proceso de ETL complejo que podría utilizarse para casos de uso similares, en lugar de crear un flujo de trabajo de AWS Glue para cada caso de uso, puede crear un único esquema.
El proyecto especifica los trabajos y rastreadores que se incluirán en un flujo de trabajo, y especifica los parámetros que el usuario del flujo de trabajo proporciona al ejecutar el proyecto para crear un flujo de trabajo. El uso de parámetros permite que un único proyecto genere flujos de trabajo para los distintos casos de uso similares. Para obtener más información acerca de los flujos de trabajo, consulte [Información general de los flujos de trabajo en AWS Glue](workflows_overview.md).
A continuación, se muestran ejemplos de casos de uso de proyectos:
+ El usuario desea crear una partición de un conjunto de datos existente. Los parámetros de entrada al proyecto son las rutas de origen y destino de Amazon Simple Storage Service (Amazon S3) y una lista de columnas de partición.
+ El usuario desea realizar una instantánea de una tabla de Amazon DynamoDB en un almacén de datos SQL como Amazon Redshift. Los parámetros de entrada del esquema son el nombre de la tabla de DynamoDB y una conexión de AWS Glue, que designa un clúster de Amazon Redshift y una base de datos de destino.
+ El usuario desea convertir datos CSV en varias rutas de Amazon S3 a Parquet. El usuario desea que el flujo de trabajo de AWS Glue incluya un rastreador y un trabajo independientes para cada ruta. Los parámetros de entrada son la base de datos de destino en el catálogo de datos de AWS Glue y una lista delimitada por comas de rutas de Amazon S3. Tenga en cuenta que, en este caso, el número de rastreadores y trabajos que crea el flujo de trabajo es variable.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/s3Bm8ay53Ms)
**Componentes del esquema**
Un proyecto es un archivo ZIP que tiene los siguientes componentes:
+ Un script del generador de diseño Python
Contiene una función que especifica el *diseño* del flujo de trabajo: los rastreadores y trabajos que se van a crear para el flujo de trabajo, las propiedades del trabajo y del rastreador, y las dependencias entre los trabajos y los rastreadores. La función acepta los parámetros del esquema y devuelve una estructura de flujo de trabajo (objeto JSON) que AWS Glue utiliza para generar el flujo de trabajo. Dado que usted utiliza un script de Python para generar el flujo de trabajo, puede agregar su propia lógica que sea adecuada para sus casos de uso.
+ Archivo de configuración
Especifica el nombre completo de la función de Python que genera el diseño del flujo de trabajo. También especifica los nombres, tipos de datos y otras propiedades de todos los parámetros del proyecto utilizados por el script.
+ (Opcional) scripts de ETL y archivos auxiliares
Como caso de uso avanzado, puede parametrizar la ubicación de los scripts de ETL que utilizan sus trabajos. Puede incluir archivos de script de trabajo en el archivo ZIP y especificar un parámetro del proyecto para una ubicación de Amazon S3 en la que se copiarán los scripts. El script del generador de diseño puede copiar los scripts de ETL en la ubicación designada y especificar esa ubicación como propiedad de ubicación del script de trabajo. También puede incluir bibliotecas u otros archivos auxiliares, siempre que el script los maneje.
![\[La caja con la etiqueta Blueprint (Proyecto) contiene dos cajas más pequeñas, una con la etiqueta Python Script (Script de Python) y la otra con la etiqueta Config File (Archivo de config).\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/blueprint.png)
**Ejecuciones del proyecto**
Cuando crea un flujo de trabajo a partir de un esquema, AWS Glue ejecuta el esquema, que inicia un proceso asíncrono para crear el flujo de trabajo y los trabajos, rastreadores y desencadenadores que el flujo de trabajo encapsula. AWS Glue utiliza la ejecución del esquema para orquestar la creación del flujo de trabajo y sus componentes. Para ver el estado del proceso de creación, consulte el estado de ejecución del proyecto. La ejecución del proyecto también almacena los valores que ha proporcionado para los parámetros del proyecto.
![\[La caja con la etiqueta Blueprint run (Ejecución del proyecto) contiene íconos etiquetados como Workflow (Flujo de trabajo) y Parameter Values (Valores de parámetros).\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/blueprint-run.png)
Puede visualizar ejecuciones de esquemas con la consola de AWS Glue o AWS Command Line Interface (AWS CLI). Al ver o solucionar problemas de un flujo de trabajo, siempre puede volver a la ejecución del proyecto para ver los valores de parámetro de proyecto que se utilizaron para crear el flujo de trabajo.
**Ciclo de vida de un esquema**
Los esquemas se desarrollan, prueban y registran con AWS Glue, y se ejecutan para crear flujos de trabajo. En general, hay tres personas involucradas en el ciclo de vida de un proyecto.
| Persona | Tareas |
| --- | --- |
| Desarrollador de AWS Glue | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/blueprints-overview.html) |
| Administrador de AWS Glue | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/blueprints-overview.html) |
| Analista de datos | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/blueprints-overview.html) |
**Véase también**
[Desarrollo de esquemas en AWS Glue](developing-blueprints.md)
[Creación de un flujo de trabajo a partir de un esquema en AWS Glue](creating_workflow_blueprint.md)
[Permisos de personas y roles para esquemas de AWS Glue](blueprints-personas-permissions.md)
# Desarrollo de esquemas en AWS Glue
Como desarrollador de AWS Glue, puede crear y publicar esquemas que los analistas de datos pueden utilizar para generar flujos de trabajo.
**Topics**
+ [Información general sobre el desarrollo de esquemas](developing-blueprints-overview.md)
+ [Requisitos previos para desarrollar esquemas](developing-blueprints-prereq.md)
+ [Escritura del código del esquema](developing-blueprints-code.md)
+ [Proyecto de esquema de ejemplo](developing-blueprints-sample.md)
+ [Pruebas a un esquema](developing-blueprints-testing.md)
+ [Publicación de un esquema](developing-blueprints-publishing.md)
+ [Referencia de clases de esquemas de AWS Glue](developing-blueprints-code-classes.md)
+ [Esquemas de ejemplo](developing-blueprints-samples.md)
**Véase también**
[Información general de los esquemas en AWS Glue](blueprints-overview.md)
# Información general sobre el desarrollo de esquemas
El primer paso en su proceso de desarrollo es identificar un caso de uso común que se beneficiaría de un proyecto. Un caso de uso típico implica un problema de ETL recurrente que cree que debe resolverse de manera general. Diseñe un proyecto que implemente el caso de uso generalizado y defina los parámetros de entrada del proyecto que, en conjunto, pueden definir un caso de uso específico a partir del caso de uso generalizado.
Un proyecto contiene un archivo de configuración de parámetros del proyecto y un script que define el *diseño* del flujo de trabajo que se va a generar. El diseño define los trabajos y los rastreadores (o *entidades* en la terminología del script del proyecto) que se crearán.
No se especifica directamente ningún desencadenador en el script de diseño. En su lugar, se escribe el código para especificar las dependencias entre los trabajos y los rastreadores que crea el script. AWS Glue genera los desencadenadores en función de las especificaciones de dependencia. El resultado del script de diseño es un objeto de flujo de trabajo, que contiene especificaciones para todas las entidades del flujo de trabajo.
Cree el objeto de flujo de trabajo con las siguientes bibliotecas de esquema de AWS Glue:
+ `awsglue.blueprint.base_resource`: una biblioteca de recursos básicos utilizados por las bibliotecas.
+ `awsglue.blueprint.workflow`: una biblioteca para definir una clase de `Workflow`.
+ `awsglue.blueprint.job`: una biblioteca para definir una clase de `Job`.
+ `awsglue.blueprint.crawler`: una biblioteca para definir una clase de `Crawler`.
Las únicas otras bibliotecas que se soportan para la generación de diseños son aquellas bibliotecas que están disponibles para el shell de Python.
Antes de publicar el proyecto, puede utilizar los métodos definidos en las bibliotecas del proyecto para probarlo a nivel local.
Cuando esté listo para poner el proyecto a disposición de los analistas de datos, empaquete el script, el archivo de configuración de parámetros y cualquier archivo auxiliar, como scripts y bibliotecas adicionales, en un único activo de implementación. A continuación, cargue el recurso en Amazon S3 y pida a un administrador que lo registre con AWS Glue.
Para obtener más información sobre proyectos de ejemplo, consulte [Proyecto de esquema de ejemplo](developing-blueprints-sample.md) y [Esquemas de ejemplo](developing-blueprints-samples.md).
# Requisitos previos para desarrollar esquemas
Para desarrollar esquemas, debe conocer el uso de AWS Glue y la escritura de scripts para trabajos de ETL de Apache Spark o trabajos de shell de Python. Además, debe completar las siguientes tareas de configuración.
+ Descargue cuatro bibliotecas de AWS Python para usar en sus scripts de diseño de proyecto.
+ Configure los SDK de AWS.
+ Cómo configurar la AWS CLI.
## Descargar las bibliotecas de Python
Descargue las siguientes bibliotecas de GitHub e instálelas en su proyecto:
+ [https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/base\$1resource.py](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/base_resource.py)
+ [https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/workflow.py](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/workflow.py)
+ [https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/crawler.py](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/crawler.py)
+ [https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/job.py](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/job.py)
## Configure el AWS Java SDK
Para el SDK de AWS Java , debe agregar un archivo `jar` que incluya la API para proyectos.
1. Si aún no lo ha hecho, configure el SDK de AWS para Java.
+ Para Java 1.x, siga las instrucciones en [Configurar AWS SDK para Java](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html) en la *Guía para desarrolladores de AWS SDK para Java*.
+ Para Java 2.x, siga las instrucciones en [Configurar AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html) en la *Guía para desarrolladores de AWS SDK for Java 2.x*.
1. Descargue el archivo `jar` del cliente que tiene acceso a las API para proyectos.
+ Para Java 1.x: s3: //awsglue-custom-blueprints-preview-artifacts/awsglue-java-sdk-preview/awsglueJavaclient-1.11.x.jar
+ Para Java 2.x: s3: //awsglue-custom-blueprints-preview-artifacts/awsglue-java-sdk-v2-preview/awsjavasdk-glue-2.0.jar
1. Agregue el `jar` del cliente al frente de la ruta de clases de Java para anular el cliente de AWS Glue proporcionado por el SDK de AWS Java.
```
export CLASSPATH=:$CLASSPATH
```
1. (Opcional) pruebe el SDK con la siguiente aplicación Java. La aplicación debe generar una lista vacía.
Reemplace `accessKey` y `secretKey` con sus credenciales y reemplace `us-east-1` con su región.
```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.services.glue.AWSGlue;
import com.amazonaws.services.glue.AWSGlueClientBuilder;
import com.amazonaws.services.glue.model.ListBlueprintsRequest;
public class App{
public static void main(String[] args) {
AWSCredentials credentials = new BasicAWSCredentials("accessKey", "secretKey");
AWSCredentialsProvider provider = new AWSStaticCredentialsProvider(credentials);
AWSGlue glue = AWSGlueClientBuilder.standard().withCredentials(provider)
.withRegion("us-east-1").build();
ListBlueprintsRequest request = new ListBlueprintsRequest().withMaxResults(2);
System.out.println(glue.listBlueprints(request));
}
}
```
## Configuración de AWS Python SDK
En los siguientes pasos se supone que tiene la versión 2.7 o posterior de Python, o la versión 3.9 o una posterior instalada en el equipo.
1. Descargue el siguiente archivo wheel boto3. Si se le solicita abrir o guardar, guarde el archivo. s3: //awsglue-custom-blueprints-preview-artifacts/aws-python-sdk-preview/boto3-1.17.31-py2.py3-none-any.whl
1. Descargue el siguiente archivo wheel de botocore: s3: //awsglue-custom-blueprints-preview-artifacts/aws-python-sdk-preview/botocore-1.20.31-py2.py3-none-any.whl
1. Compruebe su versión de Python.
```
python --version
```
1. En función de su versión de Python, ingrese los siguientes comandos (para Linux):
+ Para Python 2.7 o posterior.
```
python3 -m pip install --user virtualenv
source env/bin/activate
```
+ Para Python 3.9 o posterior.
```
python3 -m venv python-sdk-test
source python-sdk-test/bin/activate
```
1. Instale el archivo wheel de botocore.
```
python3 -m pip install /botocore-1.20.31-py2.py3-none-any.whl
```
1. Instale el archivo wheel boto3.
```
python3 -m pip install /boto3-1.17.31-py2.py3-none-any.whl
```
1. Configure las credenciales y la región predeterminada en los archivos `~/.aws/credentials` y `~/.aws/config`. Para obtener más información, consulte [Configuración de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) en la *Guía del usuario de AWS Command Line Interface*.
1. (Opcional) pruebe su configuración. Los siguientes comandos deben devolver una lista vacía.
Reemplace la `us-east-1` por su región.
```
$ python
>>> import boto3
>>> glue = boto3.client('glue', 'us-east-1')
>>> glue.list_blueprints()
```
## Configuración de la previsualización de AWS CLI
1. Si aún no lo ha hecho, instale o actualice la AWS Command Line Interface (AWS CLI) en su equipo. La manera más sencilla de hacerlo es con `pip`, la utilidad del instalador de Python:
```
pip install awscli --upgrade --user
```
Puede encontrar instrucciones de instalación completas para AWS CLI aquí: [Instalación de AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html).
1. Descargue el archivo wheel AWS CLI desde: s3: //awsglue-custom-blueprints-preview-artifacts/awscli-preview-build/awscli-1.19.31-py2.py3-none-any.whl
1. Instale el archivo wheel de la AWS CLI.
```
python3 -m pip install awscli-1.19.31-py2.py3-none-any.whl
```
1. Ejecute el comando `aws configure`. Configure sus credenciales de AWS (incluida la clave de acceso y la clave secreta) y la región de AWS. Puede encontrar información acerca de cómo configurar la AWS CLI aquí: [Configuración de AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).
1. Pruebe la AWS CLI. El siguiente comando debe devolver una lista vacía.
Reemplace la `us-east-1` por su región.
```
aws glue list-blueprints --region us-east-1
```
# Escritura del código del esquema
Cada proyecto que cree debe contener como mínimo los siguientes archivos:
+ Un script de diseño de Python que define el flujo de trabajo. El script contiene una función que define las entidades (trabajos y rastreadores) en un flujo de trabajo y las dependencias entre ellos.
+ Un archivo de configuración, `blueprint.cfg`, que define:
+ La ruta completa de la función de definición de diseño del flujo de trabajo.
+ Los parámetros que acepta el proyecto.
**Topics**
+ [Creación del script de diseño del esquema](developing-blueprints-code-layout.md)
+ [Creación del archivo de configuración](developing-blueprints-code-config.md)
+ [Especificación de parámetros del esquema](developing-blueprints-code-parameters.md)
# Creación del script de diseño del esquema
El script de diseño del proyecto debe incluir una función que genere las entidades en el flujo de trabajo. Puede nombrar esta función como quiera. AWS Glue utiliza el archivo de configuración para determinar el nombre completo de la función.
La función de diseño hace lo siguiente:
+ (Opcional) genera instancias de clase `Job` para crear objetos `Job`, y transfiere argumentos como `Command` y `Role`. Estas son propiedades de trabajo que especificaría al crear el trabajo mediante la consola de AWS Glue o la API.
+ (Opcional) genera instancias de clase `Crawler` para crear objetos `Crawler`, y transfiere nombre, rol y argumentos de destino.
+ Para indicar dependencias entre los objetos (entidades de flujo de trabajo), transfiere los argumentos adicionales `DependsOn` y `WaitForDependencies` a `Job()` y `Crawler()`. Estos argumentos se explican más adelante en esta sección.
+ Inicia la clase `Workflow` para crear el objeto de flujo de trabajo que se devuelve a AWS Glue, al transferir un argumento `Name`, un argumento `Entities` y un argumento opcional `OnSchedule`. El argumento `Entities` especifica todos los trabajos y rastreadores que se incluirán en el flujo de trabajo. Para ver cómo construir un objeto `Entities`, consulte el proyecto de ejemplo más adelante en esta sección.
+ Devuelve un objeto `Workflow`.
Para conocer las definiciones de las clases `Job`, `Crawler` y `Workflow`, consulte [Referencia de clases de esquemas de AWS Glue](developing-blueprints-code-classes.md).
La función de diseño debe aceptar los siguientes argumentos de entrada.
| Argumento | Descripción |
| --- | --- |
| user\$1params | Diccionario de Python de nombres y valores de parámetros del proyecto. Para obtener más información, consulte [Especificación de parámetros del esquema](developing-blueprints-code-parameters.md). |
| system\$1params | Diccionario de Python que contiene dos propiedades: region y accountId. |
Aquí hay un script de generador de diseño de ejemplo en un archivo denominado `Layout.py`:
```
import argparse
import sys
import os
import json
from awsglue.blueprint.workflow import *
from awsglue.blueprint.job import *
from awsglue.blueprint.crawler import *
def generate_layout(user_params, system_params):
etl_job = Job(Name="{}_etl_job".format(user_params['WorkflowName']),
Command={
"Name": "glueetl",
"ScriptLocation": user_params['ScriptLocation'],
"PythonVersion": "2"
},
Role=user_params['PassRole'])
post_process_job = Job(Name="{}_post_process".format(user_params['WorkflowName']),
Command={
"Name": "pythonshell",
"ScriptLocation": user_params['ScriptLocation'],
"PythonVersion": "2"
},
Role=user_params['PassRole'],
DependsOn={
etl_job: "SUCCEEDED"
},
WaitForDependencies="AND")
sample_workflow = Workflow(Name=user_params['WorkflowName'],
Entities=Entities(Jobs=[etl_job, post_process_job]))
return sample_workflow
```
El script de ejemplo importa las bibliotecas del proyecto requeridas e incluye una función `generate_layout` que genera un flujo de trabajo con dos trabajos. Este es un script muy sencillo. Un script más complejo podría emplear lógica y parámetros adicionales para generar un flujo de trabajo con muchos trabajos y rastreadores, o incluso un número variable de trabajos y rastreadores.
## Uso del argumento DependsOn (Depende de)
El argumento `DependsOn` es una representación de diccionario de una dependencia que esta entidad tiene en otras entidades dentro del flujo de trabajo. Tiene el formato siguiente.
```
DependsOn = {dependency1 : state, dependency2 : state, ...}
```
Las claves de este diccionario representan la referencia del objeto, no el nombre de la entidad, mientras que los valores son cadenas que corresponden al estado que se debe controlar. AWS Glue infiere los desencadenantes adecuados. Para conocer los estados válidos, consulte [Estructura de condiciones](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-trigger.html#aws-glue-api-jobs-trigger-Condition).
Por ejemplo, un trabajo puede depender de la finalización correcta de un rastreador. Si define un objeto de rastreador llamado `crawler2` de la siguiente manera:
```
crawler2 = Crawler(Name="my_crawler", ...)
```
Un objeto que dependa de `crawler2` incluiría un argumento constructor como:
```
DependsOn = {crawler2 : "SUCCEEDED"}
```
Por ejemplo:
```
job1 = Job(Name="Job1", ..., DependsOn = {crawler2 : "SUCCEEDED", ...})
```
Si se omite `DependsOn` para una entidad, esa entidad depende del desencadenador de inicio del flujo de trabajo.
## Uso del argumento WaitForDependencies (Esperar a las dependencias)
El argumento `WaitForDependencies` define si una entidad de trabajo o rastreador debe esperar hasta que *todas* las entidades de las que depende se completen o hasta que *alguna* se complete.
Los valores permitidos son “`AND`” o “`ANY`”.
## Uso del argumento OnSchedule (Programado)
El argumento `OnSchedule` para el constructor de clase `Workflow` es una expresión `cron` que establece la definición del desencadenador inicial para un flujo de trabajo.
Si se especifica este argumento, AWS Glue crea un desencadenador de programación con la programación correspondiente. Si no se especifica, el desencadenador de inicio del flujo de trabajo es un desencadenador bajo demanda.
# Creación del archivo de configuración
El archivo de configuración del proyecto es un archivo necesario que define el punto de entrada del script para generar el flujo de trabajo, y los parámetros que acepta el proyecto. El archivo debe denominarse `blueprint.cfg`.
A continuación se ofrece un archivo de configuración de ejemplo.
```
{
"layoutGenerator": "DemoBlueprintProject.Layout.generate_layout",
"parameterSpec" : {
"WorkflowName" : {
"type": "String",
"collection": false
},
"WorkerType" : {
"type": "String",
"collection": false,
"allowedValues": ["G1.X", "G2.X"],
"defaultValue": "G1.X"
},
"Dpu" : {
"type" : "Integer",
"allowedValues" : [2, 4, 6],
"defaultValue" : 2
},
"DynamoDBTableName": {
"type": "String",
"collection" : false
},
"ScriptLocation" : {
"type": "String",
"collection": false
}
}
}
```
La propiedad `layoutGenerator` especifica el nombre completo de la función en el script que genera el diseño.
La propiedad `parameterSpec` especifica los parámetros que acepta este proyecto. Para obtener más información, consulte [Especificación de parámetros del esquema](developing-blueprints-code-parameters.md).
**importante**
El archivo de configuración debe incluir el nombre del flujo de trabajo como parámetro del proyecto, o debe generar un nombre de flujo de trabajo único en el script de diseño.
# Especificación de parámetros del esquema
El archivo de configuración contiene especificaciones de parámetros del proyecto en un objeto JSON `parameterSpec`. `parameterSpec` contiene uno o varios objetos de parámetro.
```
"parameterSpec": {
"": {
"type": "",
"collection": true|false,
"description": "",
"defaultValue": ""
"allowedValues": ""
},
"": {
...
}
}
```
Las siguientes son las reglas para codificar cada objeto de parámetro:
+ El nombre y `type` de parámetro son obligatorios. Todas las demás propiedades son opcionales.
+ Si especifica la propiedad `defaultValue`, el parámetro es opcional. De lo contrario, el parámetro es obligatorio y el analista de datos que está creando un flujo de trabajo a partir del proyecto debe proporcionar un valor para él.
+ Si establece la propiedad `collection` a `true`, el parámetro puede tomar una recopilación de valores. Las recopilaciones pueden ser de cualquier tipo de datos.
+ Si especifica `allowedValues`, la consola de AWS Glue muestra una lista desplegable de valores para que el analista de datos elija al crear un flujo de trabajo a partir del esquema.
Se permiten los siguientes valores para `type`:
| Tipos de datos de los parámetros | Notas |
| --- | --- |
| String | - |
| Integer | - |
| Double | - |
| Boolean | Los posibles valores son true y false. Genera una casilla de verificación en la página Create a workflow from (Crear un flujo de trabajo a partir de ) en la consola de AWS Glue. |
| S3Uri | Complete la ruta de Amazon S3. Comience con s3://. Genera un campo de texto y el botón Browse (Examinar) en la página Create a workflow from (Crear un flujo de trabajo a partir de ). |
| S3Bucket | Solo el nombre del bucket de Amazon S3. Genera un selector de buckets en la página Create a workflow from (Crear un flujo de trabajo a partir de ). |
| IAMRoleArn | El nombre de recurso de Amazon (ARN) del rol de AWS Identity and Access Management (IAM). Genera un selector de roles en la página Create a workflow from (Crear un flujo de trabajo a partir de ). |
| IAMRoleName | El nombre de un rol de IAM. Genera un selector de roles en la página Create a workflow from (Crear un flujo de trabajo a partir de ). |
# Proyecto de esquema de ejemplo
La conversión de formato de datos es un caso de uso frecuente de extracción, transformación y carga (ETL). En cargas de trabajo analíticas típicas, se prefieren los formatos de archivo basados en columnas como Parquet u ORC sobre los formatos de texto como CSV o JSON. Este proyecto de ejemplo le permite convertir datos de CSV/JSON/etc. a Parquet para archivos en Amazon S3.
Este proyecto toma una lista de rutas S3 definidas por un parámetro del proyecto, convierte los datos al formato Parquet y los escribe en la ubicación S3 especificada por otro parámetro del proyecto. El script de diseño crea un rastreador y un trabajo para cada ruta. El script de diseño también carga el script de ETL en `Conversion.py` a un bucket S3 especificado por otro parámetro del proyecto. Luego, el script de diseño especifica el script cargado como el script de ETL para cada trabajo. El archivo ZIP del proyecto contiene el script de diseño, el script de ETL y el archivo de configuración del proyecto.
Para obtener más información sobre más proyectos de ejemplo, consulte [Esquemas de ejemplo](developing-blueprints-samples.md).
El siguiente es el script de diseño en el archivo `Layout.py`.
```
from awsglue.blueprint.workflow import *
from awsglue.blueprint.job import *
from awsglue.blueprint.crawler import *
import boto3
s3_client = boto3.client('s3')
# Ingesting all the S3 paths as Glue table in parquet format
def generate_layout(user_params, system_params):
#Always give the full path for the file
with open("ConversionBlueprint/Conversion.py", "rb") as f:
s3_client.upload_fileobj(f, user_params['ScriptsBucket'], "Conversion.py")
etlScriptLocation = "s3://{}/Conversion.py".format(user_params['ScriptsBucket'])
crawlers = []
jobs = []
workflowName = user_params['WorkflowName']
for path in user_params['S3Paths']:
tablePrefix = "source_"
crawler = Crawler(Name="{}_crawler".format(workflowName),
Role=user_params['PassRole'],
DatabaseName=user_params['TargetDatabase'],
TablePrefix=tablePrefix,
Targets= {"S3Targets": [{"Path": path}]})
crawlers.append(crawler)
transform_job = Job(Name="{}_transform_job".format(workflowName),
Command={"Name": "glueetl",
"ScriptLocation": etlScriptLocation,
"PythonVersion": "3"},
Role=user_params['PassRole'],
DefaultArguments={"--database_name": user_params['TargetDatabase'],
"--table_prefix": tablePrefix,
"--region_name": system_params['region'],
"--output_path": user_params['TargetS3Location']},
DependsOn={crawler: "SUCCEEDED"},
WaitForDependencies="AND")
jobs.append(transform_job)
conversion_workflow = Workflow(Name=workflowName, Entities=Entities(Jobs=jobs, Crawlers=crawlers))
return conversion_workflow
```
El siguiente es el archivo de configuración del proyecto correspondiente, `blueprint.cfg`.
```
{
"layoutGenerator": "ConversionBlueprint.Layout.generate_layout",
"parameterSpec" : {
"WorkflowName" : {
"type": "String",
"collection": false,
"description": "Name for the workflow."
},
"S3Paths" : {
"type": "S3Uri",
"collection": true,
"description": "List of Amazon S3 paths for data ingestion."
},
"PassRole" : {
"type": "IAMRoleName",
"collection": false,
"description": "Choose an IAM role to be used in running the job/crawler"
},
"TargetDatabase": {
"type": "String",
"collection" : false,
"description": "Choose a database in the Data Catalog."
},
"TargetS3Location": {
"type": "S3Uri",
"collection" : false,
"description": "Choose an Amazon S3 output path: ex:s3:///."
},
"ScriptsBucket": {
"type": "S3Bucket",
"collection": false,
"description": "Provide an S3 bucket name(in the same AWS Region) to store the scripts."
}
}
}
```
El siguiente script en el archivo `Conversion.py` es el script de ETL cargado. Tenga en cuenta que el esquema de partición se conserva durante la conversión.
```
import sys
from pyspark.sql.functions import *
from pyspark.context import SparkContext
from awsglue.transforms import *
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
import boto3
args = getResolvedOptions(sys.argv, [
'JOB_NAME',
'region_name',
'database_name',
'table_prefix',
'output_path'])
databaseName = args['database_name']
tablePrefix = args['table_prefix']
outputPath = args['output_path']
glue = boto3.client('glue', region_name=args['region_name'])
glue_context = GlueContext(SparkContext.getOrCreate())
spark = glue_context.spark_session
job = Job(glue_context)
job.init(args['JOB_NAME'], args)
def get_tables(database_name, table_prefix):
tables = []
paginator = glue.get_paginator('get_tables')
for page in paginator.paginate(DatabaseName=database_name, Expression=table_prefix+"*"):
tables.extend(page['TableList'])
return tables
for table in get_tables(databaseName, tablePrefix):
tableName = table['Name']
partitionList = table['PartitionKeys']
partitionKeys = []
for partition in partitionList:
partitionKeys.append(partition['Name'])
# Create DynamicFrame from Catalog
dyf = glue_context.create_dynamic_frame.from_catalog(
name_space=databaseName,
table_name=tableName,
additional_options={
'useS3ListImplementation': True
},
transformation_ctx='dyf'
)
# Resolve choice type with make_struct
dyf = ResolveChoice.apply(
frame=dyf,
choice='make_struct',
transformation_ctx='resolvechoice_' + tableName
)
# Drop null fields
dyf = DropNullFields.apply(
frame=dyf,
transformation_ctx="dropnullfields_" + tableName
)
# Write DynamicFrame to S3 in glueparquet
sink = glue_context.getSink(
connection_type="s3",
path=outputPath,
enableUpdateCatalog=True,
partitionKeys=partitionKeys
)
sink.setFormat("glueparquet")
sink.setCatalogInfo(
catalogDatabase=databaseName,
catalogTableName=tableName[len(tablePrefix):]
)
sink.writeFrame(dyf)
job.commit()
```
**nota**
Sólo se pueden suministrar dos rutas de Amazon S3 como entrada al proyecto de ejemplo. Esto se debe a que los desencadenadores de AWS Glue se limitan a invocar solo dos acciones de rastreador.
# Pruebas a un esquema
Mientras desarrolla el código, debe realizar pruebas locales para verificar que el diseño del flujo de trabajo es correcto.
Las pruebas locales no generan trabajos, rastreadores o desencadenadores de AWS Glue. En su lugar, ejecute el script de diseño a nivel local y utilice los métodos `to_json()` y `validate()` para imprimir objetos y buscar errores. Estos métodos están disponibles en las tres clases definidas en las bibliotecas.
Hay dos formas de manejar los argumentos `user_params` y `system_params` que AWS Glue transfiere a la función de diseño. Su código de banco de pruebas puede crear un diccionario de valores de parámetros del proyecto de ejemplo y transferirlo a la función de diseño como el argumento `user_params`. O bien, puede eliminar las referencias a `user_params` y reemplazarlas con cadenas codificadas.
Si su código hace uso de las propiedades `region` y `accountId` en el argumento `system_params`, puede transferir su propio diccionario para `system_params`.
**Para realizar pruebas a un proyecto**
1. Inicie un intérprete de Python en un directorio con las bibliotecas, o cargue los archivos del proyecto y las bibliotecas suministradas en su entorno de desarrollo integrado (IDE) preferido.
1. Asegúrese de que el código importe las bibliotecas suministradas.
1. Agregue código a su función de diseño para realizar llamadas a `validate()` o `to_json()` en cualquier entidad o en el objeto de `Workflow`. Por ejemplo, si su código crea un objeto de `Crawler` denominado `mycrawler`, puede llamar a `validate()` de la siguiente manera.
```
mycrawler.validate()
```
Puede imprimir `mycrawler` de la siguiente manera:
```
print(mycrawler.to_json())
```
Si llama a `to_json` en un objeto, no hay necesidad de llamar también a `validate()`, ya que ` to_json()` llama a `validate()`.
Es muy útil llamar a estos métodos en el objeto de flujo de trabajo. Suponiendo que el script nombra el objeto de flujo de trabajo `my_workflow`, valide e imprima el objeto de flujo de trabajo de la siguiente manera.
```
print(my_workflow.to_json())
```
Para obtener más información sobre `to_json()` y `validate()`, consulte [Métodos de clase](developing-blueprints-code-classes.md#developing-blueprints-code-methods).
También puede importar `pprint` e imprimir el objeto de flujo de trabajo, tal y como se muestra en el ejemplo que se encuentra a continuación en esta sección.
1. Ejecute el código, corrija los errores y, por último, elimine cualquier llamada a `validate()` o `to_json()`.
**Example**
El siguiente ejemplo muestra cómo construir un diccionario de parámetros del proyecto de ejemplo y transferirlo como el argumento `user_params` a la función de diseño `generate_compaction_workflow`. También muestra cómo imprimir el objeto de flujo de trabajo generado.
```
from pprint import pprint
from awsglue.blueprint.workflow import *
from awsglue.blueprint.job import *
from awsglue.blueprint.crawler import *
USER_PARAMS = {"WorkflowName": "compaction_workflow",
"ScriptLocation": "s3://amzn-s3-demo-bucket/scripts/threaded-compaction.py",
"PassRole": "arn:aws:iam::111122223333:role/GlueRole-ETL",
"DatabaseName": "cloudtrial",
"TableName": "ct_cloudtrail",
"CoalesceFactor": 4,
"MaxThreadWorkers": 200}
def generate_compaction_workflow(user_params: dict, system_params: dict) -> Workflow:
compaction_job = Job(Name=f"{user_params['WorkflowName']}_etl_job",
Command={"Name": "glueetl",
"ScriptLocation": user_params['ScriptLocation'],
"PythonVersion": "3"},
Role="arn:aws:iam::111122223333:role/AWSGlueServiceRoleDefault",
DefaultArguments={"DatabaseName": user_params['DatabaseName'],
"TableName": user_params['TableName'],
"CoalesceFactor": user_params['CoalesceFactor'],
"max_thread_workers": user_params['MaxThreadWorkers']})
catalog_target = {"CatalogTargets": [{"DatabaseName": user_params['DatabaseName'], "Tables": [user_params['TableName']]}]}
compacted_files_crawler = Crawler(Name=f"{user_params['WorkflowName']}_post_crawl",
Targets = catalog_target,
Role=user_params['PassRole'],
DependsOn={compaction_job: "SUCCEEDED"},
WaitForDependencies="AND",
SchemaChangePolicy={"DeleteBehavior": "LOG"})
compaction_workflow = Workflow(Name=user_params['WorkflowName'],
Entities=Entities(Jobs=[compaction_job],
Crawlers=[compacted_files_crawler]))
return compaction_workflow
generated = generate_compaction_workflow(user_params=USER_PARAMS, system_params={})
gen_dict = generated.to_json()
pprint(gen_dict)
```
# Publicación de un esquema
Después de crear un proyecto, debe cargarlo en Amazon S3. Debe disponer de permisos de escritura en el bucket de Amazon S3 que utilice para publicar el proyecto. También debe asegurarse de que el administrador de AWS Glue, que registrará el esquema, dispone de acceso de lectura al bucket de Amazon S3. Para las políticas de permiso de AWS Identity and Access Management (IAM) sugeridas para personas y roles para esquemas de AWS Glue, consulte [Permisos de personas y roles para esquemas de AWS Glue](blueprints-personas-permissions.md).
**Para publicar un proyecto**
1. Cree los scripts, recursos y archivo de configuración del proyecto necesarios.
1. Agregue todos los archivos a un archivo ZIP y cargue el archivo ZIP a Amazon S3. Utilice un bucket de S3 que se encuentre en la misma región que la región en la que los usuarios se registrarán y ejecutarán el proyecto.
Puede crear un archivo ZIP desde la línea de comandos con el siguiente comando.
```
zip -r folder.zip folder
```
1. Agregue una política de bucket que otorgue permisos de lectura a la cuenta deseada de AWS. La siguiente es una política de ejemplo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::my-blueprints/*"
}
]
}
```
------
1. Conceda el permiso `s3:GetObject` de IAM en el bucket de Amazon S3 al administrador de AWS Glue o a quien registrará los esquemas. Para obtener una política de ejemplo para conceder a los administradores, consulte [Permisos de administrador de AWS Glue para esquemas](blueprints-personas-permissions.md#bp-persona-admin).
Después de haber completado las pruebas locales del esquema, es posible que también desee realizar pruebas a un esquema en AWS Glue. Para realizar pruebas a un esquema en AWS Glue, este debe estar registrado. Puede restringir quién verá el proyecto registrado mediante la autorización de IAM o mediante cuentas de prueba independientes.
**Véase también:**
[Registrar un esquema en AWS Glue](registering-blueprints.md)
# Referencia de clases de esquemas de AWS Glue
Las bibliotecas para los esquemas de AWS Glue definen tres clases que se utilizan en el script de diseño del flujo de trabajo: `Job`, `Crawler` y `Workflow`.
**Topics**
+ [Clase de trabajo](#developing-blueprints-code-jobclass)
+ [Clase de rastreador](#developing-blueprints-code-crawlerclass)
+ [Clase de flujo de trabajo](#developing-blueprints-code-workflowclass)
+ [Métodos de clase](#developing-blueprints-code-methods)
## Clase de trabajo
La clase de `Job` representa un trabajo de ETL de AWS Glue.
**Argumentos obligatorios del constructor**
A continuación, se indican los argumentos obligatorios del constructor para la clase de `Job`.
| Nombre del argumento | Tipo | Descripción |
| --- | --- | --- |
| Name | str | Nombre a asignar al trabajo. AWS Glue agrega un sufijo generado en forma aleatoria al nombre para distinguir el trabajo de los creados por otras ejecuciones del esquema. |
| Role | str | El nombre de recurso de Amazon (ARN) del rol que el trabajo debe asumir mientras se ejecuta. |
| Command | dict | Comando de trabajo, tal como se especifica en [Estructura JobCommand](aws-glue-api-jobs-job.md#aws-glue-api-jobs-job-JobCommand) en la documentación de la API. |
**Argumentos opcionales del constructor**
A continuación, se indican los argumentos opcionales del constructor para la clase de `Job`.
| Nombre del argumento | Tipo | Descripción |
| --- | --- | --- |
| DependsOn | dict | Lista de entidades de flujo de trabajo de las que depende el trabajo. Para obtener más información, consulte [Uso del argumento DependsOn (Depende de)](developing-blueprints-code-layout.md#developing-blueprints-code-layout-depends-on). |
| WaitForDependencies | str | Indica si el trabajo debe esperar hasta que todas las entidades de las que depende se completen antes de ejecutarse o hasta que alguna se complete. Para obtener más información, consulte [Uso del argumento WaitForDependencies (Esperar a las dependencias)](developing-blueprints-code-layout.md#developing-blueprints-code-layout-wait-for-dependencies). Omitir si el trabajo depende de una sola entidad. |
| (Propiedades del trabajo) | - | Cualquiera de las propiedades del trabajo enumeradas en [Estructura de trabajo](aws-glue-api-jobs-job.md#aws-glue-api-jobs-job-Job) en la documentación de la API de AWS Glue (excepto CreatedOn y LastModifiedOn). |
## Clase de rastreador
La clase de `Crawler` representa un rastreador de AWS Glue.
**Argumentos obligatorios del constructor**
A continuación, se indican los argumentos obligatorios del constructor para la clase de `Crawler`.
| Nombre del argumento | Tipo | Descripción |
| --- | --- | --- |
| Name | str | Nombre a asignar al rastreador. AWS Glue agrega un sufijo generado en forma aleatoria al nombre para distinguir el rastreador de los creados por otras ejecuciones del esquema. |
| Role | str | ARN del rol que el rastreador debe asumir durante la ejecución. |
| Targets | dict | Recopilación de destinos que se rastrearán. Los argumentos del constructor de clase de Targets se definen en [Estructura CrawlerTargets](aws-glue-api-crawler-crawling.md#aws-glue-api-crawler-crawling-CrawlerTargets) en la documentación de la API. Todos los argumentos del constructor de Targets son opcionales, pero debe transferir al menos uno. |
**Argumentos opcionales del constructor**
A continuación, se indican los argumentos opcionales del constructor para la clase de `Crawler`.
| Nombre del argumento | Tipo | Descripción |
| --- | --- | --- |
| DependsOn | dict | Lista de entidades del flujo de trabajo de las que depende el rastreador. Para obtener más información, consulte [Uso del argumento DependsOn (Depende de)](developing-blueprints-code-layout.md#developing-blueprints-code-layout-depends-on). |
| WaitForDependencies | str | Indica si el rastreador debe esperar hasta que todas las entidades de las que depende se completen antes de ejecutarse o hasta que alguna se complete. Para obtener más información, consulte [Uso del argumento WaitForDependencies (Esperar a las dependencias)](developing-blueprints-code-layout.md#developing-blueprints-code-layout-wait-for-dependencies). Omitir si el rastreador depende de una sola entidad. |
| (Propiedades del rastreador) | - | Cualquiera de las propiedades del rastreador enumeradas en [Estructura de rastreador](aws-glue-api-crawler-crawling.md#aws-glue-api-crawler-crawling-Crawler) en la documentación de la API de AWS Glue, con las siguientes excepciones:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/developing-blueprints-code-classes.html) |
## Clase de flujo de trabajo
La clase de `Workflow` representa un flujo de trabajo de AWS Glue. El script de diseño del flujo de trabajo devuelve un objeto `Workflow`. AWS Gluecrea un flujo de trabajo basado en este objeto.
**Argumentos obligatorios del constructor**
A continuación, se indican los argumentos obligatorios del constructor para la clase de `Workflow`.
| Nombre del argumento | Tipo | Descripción |
| --- | --- | --- |
| Name | str | El nombre que se asignará al flujo de trabajo. |
| Entities | Entities | Conjunto de entidades (trabajos y rastreadores) que se incluirán en el flujo de trabajo. El constructor de clase de Entities acepta un argumento de Jobs, que es una lista de objetos de Job, y un argumento de Crawlers, que es una lista de objetos de Crawler. |
**Argumentos opcionales del constructor**
A continuación, se indican los argumentos opcionales del constructor para la clase de `Workflow`.
| Nombre del argumento | Tipo | Descripción |
| --- | --- | --- |
| Description | str | Consulte [Estructura de flujo de trabajo](aws-glue-api-workflow.md#aws-glue-api-workflow-Workflow). |
| DefaultRunProperties | dict | Consulte [Estructura de flujo de trabajo](aws-glue-api-workflow.md#aws-glue-api-workflow-Workflow). |
| OnSchedule | str | Una expresión cron. |
## Métodos de clase
Las tres clases incluyen los métodos siguientes.
**validate() [validar()]**
Valida las propiedades del objeto y, si se encuentran errores, genera un mensaje y sale. No genera resultados si no hay errores. Para la clase de `Workflow`, se llama a sí mismo en cada entidad en el flujo de trabajo.
**to\$1json() [a\$1json()]**
Serializa el objeto a JSON. También llama a `validate()`. Para la clase de `Workflow`, el objeto JSON incluye listas de trabajos y rastreadores, y una lista de desencadenadores generados por las especificaciones de dependencia del trabajo y del rastreador.
# Esquemas de ejemplo
Hay una serie de esquemas de ejemplo disponibles en el [repositorio de Github de esquemas de AWS Glue](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/samples). Estas muestras son solo de referencia y no están destinadas a su uso en producción.
Los títulos de los proyectos de ejemplo son:
+ Compaction (Compactación): este proyecto crea un trabajo que compacta los archivos de entrada en segmentos más grandes en función del tamaño de archivo deseado.
+ Conversion (Conversión): este proyecto convierte archivos de entrada en varios formatos de archivo estándar en formato Apache Parquet, que está optimizado para cargas de trabajo analíticas.
+ Crawling Amazon S3 locations (Rastreo de ubicaciones de Amazon S3): este proyecto rastrea varias ubicaciones de Amazon S3 para agregar tablas de metadatos al Data Catalog.
+ Custom connection to Data Catalog (Conexión personalizada a Data Catalog): este esquema accede a los almacenes de datos mediante conectores personalizados de AWS Glue, lee los registros y completa las definiciones de tabla en el catálogo de datos de AWS Glue en función del esquema de registros.
+ Encoding (Codificación): este proyecto convierte sus archivos no UTF en archivos codificados UTF.
+ Partitioning (Particionamiento): este proyecto crea un trabajo de partición que coloca los archivos de salida en particiones en función de claves de partición específicas.
+ Importing Amazon S3 data into a DynamoDB table (Importación de datos de Amazon S3 en una tabla de DynamoDB): este proyecto importa datos de Amazon S3 en una tabla de DynamoDB.
+ Standard table to governed (Tabla estándar que regirá): este esquema importa una tabla de Data Catalog de AWS Glue a una tabla de Lake Formation.
# Registrar un esquema en AWS Glue
Después de que el desarrollador de AWS Glue ha codificado el esquema y ha cargado un archivo ZIP a Amazon Simple Storage Service (Amazon S3), un administrador de AWS Glue debe registrar el esquema. Registrar el proyecto hace que esté disponible para su uso.
Cuando registra un esquema, AWS Glue copia el archivo de esquemas en una ubicación reservada de Amazon S3. Podrá eliminar el archivo de la ubicación de carga.
Para registrar un proyecto, necesita permisos de lectura en la ubicación de Amazon S3 que contiene el archivo cargado. También necesita el permiso de AWS Identity and Access Management (IAM), `glue:CreateBlueprint`. Para obtener los permisos sugeridos para un administrador de AWS Glue que debe registrar, ver y mantener los esquemas, consulte [Permisos de administrador de AWS Glue para esquemas](blueprints-personas-permissions.md#bp-persona-admin).
Puede registrar un esquema con la consola de AWS Glue, la API de AWS Glue o AWS Command Line Interface (AWS CLI).
**Para registrar un proyecto (consola)**
1. Asegúrese de que dispone de permisos de lectura (`s3:GetObject`) en el archivo ZIP del proyecto en Amazon S3.
1. Abra la consola de AWS Glue en [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Inicie sesión como usuario con permisos para registrar un proyecto. Cambie a la misma región de AWS que el bucket de Amazon S3 que contiene el archivo ZIP del proyecto.
1. En el panel de navegación, elija **Blueprints (Esquemas)**. Luego, en la página **Blueprints** (Esquemas), elija **Add blueprint** (Agregar esquema).
1. Escriba un nombre de proyecto y una descripción opcional.
1. Para **ZIP archive location (S3) [Ubicación del archivo ZIP (S3)]**, ingrese la ruta de Amazon S3 del archivo ZIP del proyecto que se subió. Incluya el nombre del archivo en la ruta y comience la ruta con `s3://`.
1. (Opcional) agregue una o más etiquetas.
1. Elija **Add blueprint (Agregar proyecto)**.
La página **Blueprints** (Esquemas) vuelve a aparecer y muestra que el estado del proyecto es `CREATING`. Elija el botón de actualización hasta que el estado cambie a `ACTIVE` o `FAILED`.
1. Si el estado es `FAILED`, seleccione el proyecto y, en el menú **Actions (Acciones)**, elija **View (Visualizar)**.
En la página de detalles se muestra el motivo del error. Si el mensaje de error es “Unable to access object at location... (No se puede acceder al objeto en la ubicación...)” o “Access denied on object at location... (Acceso denegado al objeto en la ubicación...)”, revise los siguientes requisitos:
+ El usuario con el que ha iniciado sesión debe tener permiso de lectura en el archivo ZIP del proyecto en Amazon S3.
+ El bucket de Amazon S3 que contiene el archivo ZIP debe tener una política de bucket que otorgue permiso de lectura sobre el objeto a su ID de cuenta de AWS. Para obtener más información, consulte [Desarrollo de esquemas en AWS Glue](developing-blueprints.md).
+ El bucket de Amazon S3 que está utilizando debe estar en la misma región que la región en la que ha iniciado sesión en la consola.
1. Asegúrese de que los analistas de datos tengan permisos sobre el proyecto.
La política de IAM sugerida para analistas de datos se muestra en [Permisos de analista de datos para esquemas](blueprints-personas-permissions.md#bp-persona-analyst). Esta política concede `glue:GetBlueprint` sobre cualquier recurso. Si su política está más detallada al nivel de recursos, otorgue permisos a los analistas de datos sobre este recurso recién creado.
**Para registrar un proyecto (AWS CLI)**
1. Escriba el siguiente comando.
```
aws glue create-blueprint --name [--description ] --blueprint-location s3:///
```
1. Ingrese el siguiente comando para comprobar el estado del proyecto. Repita el comando hasta que el estado cambie a `ACTIVE` o `FAILED`.
```
aws glue get-blueprint --name
```
Si el estado es `FAILED` y el mensaje de error es “Unable to access object at location... (No se puede acceder al objeto en la ubicación...)” o “Access denied on object at location... (Acceso denegado al objeto en la ubicación...)”, revise los siguientes requisitos:
+ El usuario con el que ha iniciado sesión debe tener permiso de lectura en el archivo ZIP del proyecto en Amazon S3.
+ El bucket de Amazon S3 que contiene el archivo ZIP debe tener una política de bucket que otorgue permiso de lectura sobre el objeto a su ID de cuenta de AWS. Para obtener más información, consulte [Publicación de un esquema](developing-blueprints-publishing.md).
+ El bucket de Amazon S3 que está utilizando debe estar en la misma región que la región en la que ha iniciado sesión en la consola.
**Véase también:**
[Información general de los esquemas en AWS Glue](blueprints-overview.md)
# Visualización de esquemas en AWS Glue
Visualice un proyecto para revisar la descripción, el estado y las especificaciones de parámetros del proyecto, y para descargar el archivo ZIP del proyecto.
Puede visualizar un esquema con la consola de AWS Glue, la API de AWS Glue o AWS Command Line Interface (AWS CLI).
**Para visualizar un proyecto (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, elija **Blueprints (Esquemas)**.
1. En la página **Blueprints** (Esquemas), seleccione un esquema. Luego, en el menú **Actions (Acciones)**, seleccione **View (Visualización)**.
**Para visualizar un proyecto (AWS CLI )**
+ Ingrese el siguiente comando para ver sólo el nombre, la descripción y el estado del proyecto. Reemplace ** con el nombre del proyecto que se va a visualizar.
```
aws glue get-blueprint --name
```
El resultado del comando es similar al siguiente.
```
{
"Blueprint": {
"Name": "myDemoBP",
"CreatedOn": 1587414516.92,
"LastModifiedOn": 1587428838.671,
"BlueprintLocation": "s3://amzn-s3-demo-bucket1/demo/DemoBlueprintProject.zip",
"Status": "ACTIVE"
}
}
```
Ingrese el siguiente comando para ver también las especificaciones del parámetro.
```
aws glue get-blueprint --name --include-parameter-spec
```
El resultado del comando es similar al siguiente.
```
{
"Blueprint": {
"Name": "myDemoBP",
"CreatedOn": 1587414516.92,
"LastModifiedOn": 1587428838.671,
"ParameterSpec": "{\"WorkflowName\":{\"type\":\"String\",\"collection\":false,\"description\":null,\"defaultValue\":null,\"allowedValues\":null},\"PassRole\":{\"type\":\"String\",\"collection\":false,\"description\":null,\"defaultValue\":null,\"allowedValues\":null},\"DynamoDBTableName\":{\"type\":\"String\",\"collection\":false,\"description\":null,\"defaultValue\":null,\"allowedValues\":null},\"ScriptLocation\":{\"type\":\"String\",\"collection\":false,\"description\":null,\"defaultValue\":null,\"allowedValues\":null}}",
"BlueprintLocation": "s3://awsexamplebucket1/demo/DemoBlueprintProject.zip",
"Status": "ACTIVE"
}
}
```
Agregue el argumento `--include-blueprint` a fin de incluir una URL en el resultado que puede pegar en el navegador para descargar el archivo ZIP del esquema que AWS Glue almacenó.
**Véase también:**
[Información general de los esquemas en AWS Glue](blueprints-overview.md)
# Actualizar un esquema en AWS Glue
Puede actualizar un proyecto si tiene un script de diseño revisado, un conjunto revisado de parámetros del proyecto o archivos de soporte revisados. Al actualizar un proyecto, se crea una versión nueva.
La actualización de un proyecto no afecta los flujos de trabajo existentes creados a partir del proyecto.
Puede actualizar un esquema con la consola de AWS Glue, la API de AWS Glue o AWS Command Line Interface (AWS CLI).
En el siguiente procedimiento se supone que el desarrollador de AWS Glue ha creado y cargado un archivo ZIP del esquema actualizado en Amazon S3.
**Para actualizar un proyecto (consola)**
1. Asegúrese de que dispone de permisos de lectura (`s3:GetObject`) en el archivo ZIP del proyecto en Amazon S3.
1. Abra la consola de AWS Glue en [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Inicie sesión como usuario con permisos para actualizar un proyecto. Cambie a la misma región de AWS que el bucket de Amazon S3 que contiene el archivo ZIP del proyecto.
1. En el panel de navegación, elija **Blueprints (Esquemas)**.
1. En la página **Blueprints** (Esquemas), seleccione un proyecto y, en el menú **Actions** (Acciones), elija **Edit** (Editar).
1. En la página **Edit a blueprint (Editar un proyecto)**, actualice la **Description (Descripción)** o **ZIP archive location (S3) [Ubicación del archivo ZIP (S3)]** del proyecto. Asegúrese de incluir el nombre del archivo en la ruta.
1. Elija **Save (Guardar)**.
La página **Blueprints** (Esquemas) vuelve a aparecer y muestra que el estado del proyecto es `UPDATING`. Elija el botón de actualización hasta que el estado cambie a `ACTIVE` o `FAILED`.
1. Si el estado es `FAILED`, seleccione el proyecto y, en el menú **Actions (Acciones)**, elija **View (Visualizar)**.
En la página de detalles se muestra el motivo del error. Si el mensaje de error es “Unable to access object at location... (No se puede acceder al objeto en la ubicación...)” o “Access denied on object at location... (Acceso denegado al objeto en la ubicación...)”, revise los siguientes requisitos:
+ El usuario con el que ha iniciado sesión debe tener permiso de lectura en el archivo ZIP del proyecto en Amazon S3.
+ El bucket de Amazon S3 que contiene el archivo ZIP debe tener una política de bucket que otorgue permiso de lectura sobre el objeto a su ID de cuenta de AWS. Para obtener más información, consulte [Publicación de un esquema](developing-blueprints-publishing.md).
+ El bucket de Amazon S3 que está utilizando debe estar en la misma región que la región en la que ha iniciado sesión en la consola.
**nota**
Si se produce un error en la actualización, la siguiente ejecución del proyecto utiliza la versión más reciente del proyecto que se registró o actualizó correctamente.
**Para actualizar un proyecto (AWS CLI)**
1. Ingrese el siguiente comando.
```
aws glue update-blueprint --name [--description ] --blueprint-location s3:///
```
1. Ingrese el siguiente comando para comprobar el estado del proyecto. Repita el comando hasta que el estado cambie a `ACTIVE` o `FAILED`.
```
aws glue get-blueprint --name
```
Si el estado es `FAILED` y el mensaje de error es “Unable to access object at location... (No se puede acceder al objeto en la ubicación...)” o “Access denied on object at location... (Acceso denegado al objeto en la ubicación...)”, revise los siguientes requisitos:
+ El usuario con el que ha iniciado sesión debe tener permiso de lectura en el archivo ZIP del proyecto en Amazon S3.
+ El bucket de Amazon S3 que contiene el archivo ZIP debe tener una política de bucket que otorgue permiso de lectura sobre el objeto a su ID de cuenta de AWS. Para obtener más información, consulte [Publicación de un esquema](developing-blueprints-publishing.md).
+ El bucket de Amazon S3 que está utilizando debe estar en la misma región que la región en la que ha iniciado sesión en la consola.
**Véase también**
[Información general de los esquemas en AWS Glue](blueprints-overview.md)
# Creación de un flujo de trabajo a partir de un esquema en AWS Glue
Puede crear un flujo de trabajo de AWS Glue en forma manual al agregar un componente a la vez, o puede crear un flujo de trabajo desde un [esquema de AWS Glue](blueprints-overview.md). AWS Glue incluye esquemas para casos de uso habituales. Los desarrolladores de AWS Glue pueden crear esquemas adicionales.
**importante**
Limite la cantidad total de trabajos, rastreadores y desencadenadores de un flujo de trabajo a 100 o menos. Si incluye más de 100, es posible que se produzcan errores al intentar reanudar o detener las ejecuciones del flujo de trabajo.
Cuando utiliza un esquema, puede generar rápidamente un flujo de trabajo para un caso de uso específico basado en el caso de uso generalizado definido por el esquema. Defina el caso de uso específico al proporcionar valores para los parámetros del esquema. Por ejemplo, un esquema que particiona un conjunto de datos podría tener como parámetros las rutas de origen y destino de Amazon S3.
AWS Glue crea un flujo de trabajo a partir de un esquema al *ejecutar* el esquema. La ejecución del esquema guarda los valores de parámetro proporcionados y se utiliza para realizar un seguimiento del progreso y el resultado de la creación del flujo de trabajo y sus componentes. Al solucionar problemas de un flujo de trabajo, puede visualizar la ejecución del esquema a fin de determinar los valores de los parámetros del esquema que se utilizaron para crear el flujo de trabajo.
Para crear y visualizar flujos de trabajo, necesita determinados permisos de IAM. Si desea ver una política de IAM sugerida, consulte [Permisos de analista de datos para esquemas](blueprints-personas-permissions.md#bp-persona-analyst).
Puede crear un flujo de trabajo a partir de un esquema mediante la consola de AWS Glue, la API de AWS Glue o la AWS Command Line Interface (AWS CLI).
**Para crear un flujo de trabajo a partir de un esquema (consola)**
1. Abra la consola de AWS Glue en [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Inicie sesión como usuario con permisos para crear un flujo de trabajo.
1. En el panel de navegación, elija **Blueprints (Esquemas)**.
1. Seleccione un esquema y, en el menú **Actions (Acciones)**, elija **Create workflow (Crear flujo de trabajo)**.
1. En la página **Create a workflow from (Crear un flujo de trabajo a partir de )**, ingrese la siguiente información:
**Parámetros del esquema**
Estos varían en función del diseño del esquema. Si tiene preguntas sobre los parámetros, consulte al desarrollador. Los esquemas generalmente incluyen un parámetro para el nombre del flujo de trabajo.
**rol de IAM**
El rol que asume AWS Glue para crear el flujo de trabajo y sus componentes. El rol debe tener permisos para crear y eliminar flujos de trabajo, trabajos, rastreadores y desencadenadores. Para obtener una política sugerida para el rol, consulte [Permisos para roles de esquema](blueprints-personas-permissions.md#blueprints-role-permissions).
1. Elija **Enviar**.
Aparece la página **Blueprint details (Detalles del esquema)**, que muestra una lista de ejecuciones del esquema en la parte inferior.
1. En la lista de ejecuciones del esquema, verifique el estado de creación del flujo de trabajo en la última ejecución del esquema.
El estado inicial es `RUNNING`. Elija el botón de actualización hasta que el estado pase a `SUCCEEDED` o `FAILED`.
1. Realice alguna de las siguientes acciones:
+ Si el estado de finalización es `SUCCEEDED`, puede ir a la página **Workflows (Flujos de trabajo)**, seleccionar el flujo de trabajo recién creado y ejecutarlo. Antes de ejecutar el flujo de trabajo, puede revisar el gráfico de diseño.
+ Si el estado de finalización es `FAILED`, seleccione la ejecución del esquema y, en el menú **Actions (Acciones)**, elija **View (Visualizar)** para ver el mensaje de error.
Para obtener más información sobre flujos de trabajo y esquemas, consulte los siguientes temas.
+ [Información general de los flujos de trabajo en AWS Glue](workflows_overview.md)
+ [Actualizar un esquema en AWS Glue](updating_blueprints.md)
+ [Creación y desarrollo manual de un flujo de trabajo en AWS Glue](creating_running_workflows.md)
# Visualización de las ejecuciones de esquema en AWS Glue
Visualice una ejecución de proyecto para ver la siguiente información:
+ Nombre del flujo de trabajo que se creó.
+ Valores de parámetros del esquema que se utilizaron para crear el flujo de trabajo.
+ El estado de la operación de creación del flujo de trabajo.
Puede visualizar la ejecución de un esquema con la consola de AWS Glue, la API de AWS Glue o AWS Command Line Interface (AWS CLI).
**Para visualizar una ejecución del proyecto (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, elija **Blueprints (Esquemas)**.
1. En la página **Blueprints** (Esquemas), seleccione un esquema. Luego, en el menú **Actions (Acciones)**, seleccione **View (Visualización)**.
1. En la parte inferior de la página **Blueprint Details (Detalles del proyecto)**, seleccione una ejecución de proyecto y, en el menú **Actions (Acciones)**, elija **View (Visualizaciones)**.
**Para visualizar la ejecución de un proyecto (AWS CLI)**
+ Ingrese el siguiente comando. Reemplace ** con el nombre del proyecto. Reemplace ** con el ID de ejecución del proyecto.
```
aws glue get-blueprint-run --blueprint-name --run-id
```
**Véase también:**
[Información general de los esquemas en AWS Glue](blueprints-overview.md)