Iniciar um fluxo de trabalho do AWS Glue com um evento do Amazon EventBridge

O Amazon EventBridge, também conhecido como CloudWatch Events, permite que você automatize seus produtos da AWS e responda automaticamente aos eventos do sistema, como problemas de disponibilidade da aplicação ou alterações de recursos. Os eventos dos serviços da AWS são entregues ao EventBridge quase em tempo real. Você pode escrever regras simples para indicar quais eventos são do seu interesse, e as ações automatizadas a serem tomadas quando um evento corresponder à regra.

Com suporte a EventBridge, o AWS Glue pode servir como produtor e consumidor de eventos em uma arquitetura orientada por eventos. Para fluxos de trabalho, o AWS Glue suporta qualquer tipo de evento do EventBridge como consumidor. O mais provável caso de uso é a chegada de um novo objeto em um bucket do Amazon S3. Se você tiver dados chegando em intervalos irregulares ou indefinidos, você poderá processar esses dados o mais próximo possível de suas chegadas.

nota

O AWS Glue não fornece entrega garantida de mensagens do EventBridge. O AWS Glue não realizará a eliminação de duplicação se o EventBridge fornecer mensagens duplicadas. Você deve gerenciar a idempotência com base no seu caso de uso.

Certifique-se de configurar as regras do EventBridge corretamente para evitar o envio de eventos indesejados.

Antes de começar

Se você quiser iniciar um fluxo de trabalho com eventos de dados do Amazon S3, certifique-se de que os eventos do bucket do S3 de interesse sejam registrados no AWS CloudTrail e no EventBridge. Para fazer isso, você deve criar uma trilha do CloudTrail. Para obter mais informações, consulte Criar uma trilha para sua conta da AWS.

Para iniciar um fluxo de trabalho com um evento do EventBridge

nota

Nos comandos a seguir, substitua:

<workflow-name> pelo nome a ser atribuído ao fluxo de trabalho.
<trigger-name> pelo nome a ser atribuído ao acionador.
<bucket-name> pelo nome do bucket do Amazon S3.
<account-id> por um ID da conta da AWS válido.
<region> pelo nome da região (por exemplo, us-east-1).
<rule-name> pelo nome a ser atribuído à regra do EventBridge.

Verifique se você tem permissões do AWS Identity and Access Management (IAM) para criar e exibir regras e destinos do EventBridge. Veja a seguir um exemplo de política que você pode anexar. Você pode querer restringir o escopo para impor limites nas operações e 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": "*"
        }
    ]
}

Crie uma função do IAM que o produto EventBridge possa assumir ao passar um evento para o AWS Glue.
1. Na página Criar perfil do console do IAM, escolha Serviço da AWS. Em seguida, escolha o produto CloudWatch Events.
2. Conclua o assistente Create role (Criar função). O assistente anexa automaticamente as políticas CloudWatchEventsBuiltInTargetExecutionAccess e CloudWatchEventsInvocationAccess.
3. Anexe a política em linha a seguir à função. Esta política permite que o produto EventBridge direcione eventos para o AWS Glue.
```
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "glue:notifyEvent"
      ],
      "Resource": [
        "arn:aws:glue:<region>:<account-id>:workflow/<workflow-name>"
      ]
    }
  ]
}
```
Insira o comando a seguir para criar o fluxo de trabalho.

Consulte criar fluxo de trabalho na Referência de comandos da AWS CLI para obter informações sobre mais parâmetros opcionais da linha de comando.
```
aws glue create-workflow --name <workflow-name>
```
Insira o seguinte comando para criar um acionador de evento do EventBridge para o fluxo de trabalho. Este será o acionador inicial para o fluxo de trabalho. Substitua <actions> pelas ações a serem executadas (os trabalhos e os crawlers a serem iniciados).

Consulte criar trigger na Referência de comandos da AWS CLI para obter informações sobre como codificar o argumento actions.
```
aws glue create-trigger --workflow-name <workflow-name> --type EVENT --name <trigger-name> --actions <actions>
```
Se desejar que o fluxo de trabalho seja acionado por um lote de eventos em vez de um único evento do EventBridge, insira o seguinte comando.
```
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 o argumento event-batching-condition, BatchSize é necessário e BatchWindow é opcional. Se BatchWindow for omitido, o padrão da janela será 900 segundos, que é a duração máxima da janela.
O exemplo a seguir cria um acionador que inicia o fluxo de trabalho eventtest após a chegada de três eventos do EventBridge ou cinco minutos após a chegada do primeiro evento, o que ocorrer primeiro.
```
aws glue create-trigger --workflow-name eventtest --type EVENT --name objectArrival --event-batching-condition BatchSize=3,BatchWindow=300 --actions JobName=test1
```

Crie uma regra no Amazon EventBridge.

Crie o objeto JSON para os detalhes da regra no editor de texto de sua preferência.

O exemplo a seguir especifica o Amazon S3 como a origem do evento, PutObject como o nome do evento e o nome do bucket como um parâmetro de solicitação. Essa regra inicia um fluxo de trabalho quando um novo objeto chega ao bucket.
```
{
  "source": [
    "aws.s3"
  ],
  "detail-type": [
    "AWS API Call via CloudTrail"
  ],
  "detail": {
    "eventSource": [
      "s3.amazonaws.com"
    ],
    "eventName": [
      "PutObject"
    ],
    "requestParameters": {
      "bucketName": [
        "<bucket-name>"
      ]
    }
  }
}
```
Para iniciar o fluxo de trabalho quando um novo objeto chega a uma pasta dentro do bucket, você pode substituir o seguinte código por requestParameters.
```
    "requestParameters": {
      "bucketName": [
        "<bucket-name>"
      ]
      "key" : [{ "prefix" : "<folder1>/<folder2>/*"}}]
  }
```

Use sua ferramenta preferida para converter o objeto JSON de regra em uma string 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}

Execute o seguinte comando para criar um modelo de parâmetro JSON que você pode editar para especificar parâmetros de entrada para um comando put-rule. Salve a saída em um arquivo. Para este exemplo, o arquivo é chamado ruleCommand.
```
aws events put-rule --name <rule-name> --generate-cli-skeleton >ruleCommand
```
Para obter mais informações sobre o parâmetro --generate-cli-skeleton, consulte Gerar um esqueleto da AWS CLI e parâmetros de entrada usando um arquivo de entrada JSON ou YAML no Manual do usuário da interface da AWS Command Line.

O arquivo de saída deve ser como o a seguir.
```
{
    "Name": "",
    "ScheduleExpression": "",
    "EventPattern": "",
    "State": "ENABLED",
    "Description": "",
    "RoleArn": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "EventBusName": ""
}
```

Edite o arquivo para opcionalmente remover parâmetros e especificar, no mínimo, os parâmetros Name, EventPattern e State. Para o parâmetro EventPattern, forneça a string de escape para os detalhes da regra que você criou em uma etapa 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

É melhor deixar a regra desabilitada até terminar de criar o fluxo de trabalho.

Insira o seguinte comando put-rule, que lê os parâmetros de entrada do arquivo ruleCommand.
```
aws events put-rule --name <rule-name> --cli-input-json file://ruleCommand
```
A seguinte saída indica sucesso.
```
{
    "RuleArn": "<rule-arn>"
}
```

Insira o comando a seguir para anexar a regra a um destino. O destino é o fluxo de trabalho no AWS Glue. Substitua <role-name> pela função criada por você no início deste procedimento.


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>

A seguinte saída indica sucesso.

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

Confirme a conexão bem-sucedida da regra e do destino inserindo o seguinte comando.
```
aws events list-rule-names-by-target --target-arn arn:aws:glue:<region>:<account-id>:workflow/<workflow-name>
```
A seguinte saída indica sucesso, em que <rule-name> é o nome da regra que você criou.
```
{
    "RuleNames": [
        "<rule-name>"
    ]
}
```
Faça logon no AWS Management Console e abra o console do AWS Glue em https://console.aws.amazon.com/glue/.
Selecione o fluxo de trabalho e verifique se o acionador inicial e suas ações, os trabalhos ou crawlers que ele inicia, aparecem no gráfico do fluxo de trabalho. Em seguida, vá para o procedimento em Etapa 3: adicionar mais acionadores. Ou adicione mais componentes ao fluxo de trabalho usando a API do AWS Glue ou AWS Command Line Interface.
Quando o fluxo de trabalho estiver completamente especificado, habilite a regra.
```
aws events enable-rule --name <rule-name>
```
O fluxo de trabalho agora está pronto para ser iniciado por um evento do EventBridge ou lote de eventos.

Consulte também

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Criar e desenvolver um fluxo de trabalho manualmente

Visualizar os eventos do EventBridge que iniciaram um fluxo de trabalho