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.

Para iniciar un flujo de trabajo con un evento de EventBridge

nota

En los siguientes comandos, sustituya:

<workflow-name> con el nombre que se va a asignar al flujo de trabajo.
<trigger-name> con el nombre que se va a asignar al desencadenador.
<bucket-name> con el nombre del bucket de Amazon S3.
<account-id> con un ID de cuenta de AWS válido.
<region> con el nombre de la región (por ejemplo, us-east-1).
<rule-name> con el nombre que se asignará a la regla de EventBridge.

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.


{
    "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": "*"
        }
    ]
}

Cree un rol de IAM que el servicio EventBridge pueda asumir al enviar un evento a AWS Glue.
1. En la página Create role (Crear rol) de la consola de IAM, elija AWS Service (Servicio de AWS). A continuación, elija el servicio CloudWatch Events (Eventos de CloudWatch).
2. Finalice el asistente Create role (Creación de rol). El asistente adjunta automáticamente las políticas CloudWatchEventsBuiltInTargetExecutionAccess y CloudWatchEventsInvocationAccess.
3. Asocie la siguiente política en línea al rol. Esta política permite que el servicio EventBridge dirija eventos a AWS Glue.
```
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "glue:notifyEvent"
      ],
      "Resource": [
        "arn:aws:glue:<region>:<account-id>:workflow/<workflow-name>"
      ]
    }
  ]
}
```
Ingrese el siguiente comando para crear el flujo de trabajo.

Consulte crear flujo de trabajo 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 <workflow-name>
```
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 <actions> con las acciones a realizar (los trabajos y los rastreadores de inicio).

Consulte crear un desencadenador 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 <workflow-name> --type EVENT --name <trigger-name> --actions <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 <workflow-name> --type EVENT --name <trigger-name> --event-batching-condition BatchSize=<number-of-events>,BatchWindow=<seconds> --actions <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.
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
```

Cree una regla en Amazon EventBridge.

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": [
        "<bucket-name>"
      ]
    }
  }
}
```
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": [
        "<bucket-name>"
      ]
      "key" : [{ "prefix" : "<folder1>/<folder2>/*"}}]
  }
```

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        \"<bucket-name>\"\n      ]\n    }\n  }\n}

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 <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 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": ""
}
```

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": "<rule-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        \"<bucket-name>\"\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.

Ingrese el siguiente comando put-rule, que lee los parámetros de entrada del ruleCommand del archivo.
```
aws events put-rule --name <rule-name> --cli-input-json file://ruleCommand
```
El siguiente resultado indica éxito.
```
{
    "RuleArn": "<rule-arn>"
}
```

Ingrese el siguiente comando para adjuntar la regla a un destino. El destino es el flujo de trabajo en AWS Glue. Reemplace <role-name> con el rol que ha creado al principio de este procedimiento.


aws events put-targets --rule <rule-name> --targets "Id"="1","Arn"="arn:aws:glue:<region>:<account-id>:workflow/<workflow-name>","RoleArn"="arn:aws:iam::<account-id>:role/<role-name>" --region <region>

El siguiente resultado indica éxito.

{
    "FailedEntryCount": 0,
    "FailedEntries": []
}

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:<region>:<account-id>:workflow/<workflow-name>
```
El siguiente resultado indica el éxito, donde <rule-name> es el nombre de la regla que creó.
```
{
    "RuleNames": [
        "<rule-name>"
    ]
}
```
Inicie sesión en AWS Management Console y abra la consola de AWS Glue en https://console.aws.amazon.com/glue/.
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. O agregue más componentes al flujo de trabajo mediante la API de AWS Glue o AWS Command Line Interface.
Cuando el flujo de trabajo esté completamente especificado, habilite la regla.
```
aws events enable-rule --name <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

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Creación y desarrollo manual de un flujo de trabajo

Visualizar los eventos de EventBridge que iniciaron un flujo de trabajo