# Orquestração no AWS Glue
As seções a seguir fornecem mais informações sobre a orquestração de trabalhos no AWS Glue.
**Topics**
+ [Iniciar trabalhos e crawlers usando acionadores](trigger-job.md)
+ [Realizar atividades de ETL complexas usando esquemas e fluxos de trabalho no AWS Glue](orchestrate-using-workflows.md)
+ [Desenvolver esquemas no AWS Glue](orchestrate-using-blueprints.md)
# Iniciar trabalhos e crawlers usando acionadores
No AWS Glue, você pode criar objetos do Data Catalog chamados acionadores, que podem ser usados para iniciar manual ou automaticamente um ou mais crawlers, ou extrair, transformar e carregar (ETL) trabalhos. Ao usar gatilhos, você pode projetar uma cadeia de trabalhos e crawlers dependentes.
**nota**
É possível fazer a mesma coisa definindo *fluxos de trabalho*. Os fluxos de trabalho são preferidos para a criação de operações ETL complexas com vários trabalhos. Para obter mais informações, consulte [Realizar atividades de ETL complexas usando esquemas e fluxos de trabalho no AWS Glue](orchestrate-using-workflows.md).
**Topics**
+ [Gatilhos do AWS Glue](about-triggers.md)
+ [Adição de acionadores](console-triggers.md)
+ [Ativar e desativar acionadores](activate-triggers.md)
# Gatilhos do AWS Glue
Quando *acionado*, um gatilho pode iniciar trabalhos e crawlers especificados. Um gatilho é acionado sob demanda, com base em uma programação ou em uma combinação de eventos.
**nota**
Apenas dois crawlers podem ser ativados por um único acionador. Se você quiser realizar crawling em vários armazenamentos de dados, use várias fontes para cada crawler, em vez de executar vários crawlers simultaneamente.
Um gatilho pode existir em um de vários estados. Um gatilho é `CREATED`, `ACTIVATED` ou `DEACTIVATED`. Existem também estados transitórios, como `ACTIVATING`. Para impedir temporariamente que um gatilho seja acionado, é possível desabilitá-lo. Você pode reabilitá-lo posteriormente.
Existem três tipos de gatilhos:
**Programado**
Um gatilho de tempo baseado em `cron`.
Você pode criar um gatilho para um conjunto de trabalhos ou crawlers com base em uma programação. Você pode especificar restrições, como a frequência de execução ou em quais dias da semana e a que horas os trabalhos ou crawlers são executados. Essas restrições são feitas com base no `cron`. Ao configurar a programação de um gatilho, considere os recursos e as limitações do cron. Por exemplo, se você optar por executar seu crawler no dia 31 de cada mês, lembre-se de que alguns meses não têm 31 dias. Para obter mais informações sobre o cron, consulte [Programações baseadas em hora para trabalhos e crawlers](monitor-data-warehouse-schedule.md).
**Condicional**
Um gatilho que é acionado quando um ou vários trabalhos ou crawlers satisfazem uma lista de condições.
Ao criar um gatilho condicional, você especifica uma lista de trabalhos e uma lista de crawlers a serem monitorados. Para cada trabalho ou crawler monitorado, você especifica um status a monitorar, como succeeded (bem-sucedido), failed (com falha), timed out (com tempo limite excedido) e assim por diante. O gatilho será acionado se os trabalhos ou crawlers monitorados forem finalizados com os status especificados. Você pode configurar o gatilho de modo a ser acionado quando um ou todos os eventos monitorados ocorrerem.
Por exemplo, você pode configurar um gatilho T1 para iniciar o trabalho J3 quando o trabalho J1 e J2 forem concluídos com êxito, e outro gatilho T2 para iniciar o trabalho J4 se houver falha no trabalho J1 ou no J2.
A tabela a seguir lista os estados de conclusão do trabalho e do crawler (eventos) que acionam a gatilho.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/about-triggers.html)
**Sob demanda**
Um gatilho que é acionado quando é ativado. Os gatilhos sob demanda nunca entram no estado `ACTIVATED` ou `DEACTIVATED`. Eles sempre permanecem no estado `CREATED`.
Para que eles estejam prontos para serem acionados assim que existirem, você pode definir um sinalizador para ativar gatilhos programados e condicionais ao criá-los.
**Importante**
Os trabalhos ou crawlers executados como resultado da conclusão de outros trabalhos ou crawlers são chamados de *dependentes*. Os trabalhos ou crawlers dependentes só serão iniciados se o trabalho ou o crawler concluído tiver sido iniciado por um gatilho. Todos os trabalhos ou crawlers em uma cadeia de dependência devem ser descendentes de um único gatilho **scheduled (programado)** ou **on-demand (sob demanda)**.
**Transmitir parâmetros de trabalho com acionadores**
Um gatilho pode transmitir parâmetros para os trabalhos que inicia. Os parâmetros incluem argumentos de trabalho, valor de tempo limite, configuração de segurança e muito mais. Se o gatilho iniciar vários trabalhos, os parâmetros serão transmitidos para cada trabalho.
Veja a seguir as regras para argumentos de trabalho transmitidos por um gatilho:
+ Se a chave no par de chave/valor corresponder a um argumento de trabalho padrão, o argumento transmitido substituirá o argumento padrão. Se a chave não corresponder a um argumento padrão, o argumento será transmitido como um argumento adicional para o trabalho.
+ Se a chave no par de chave/valor corresponder a um argumento não substituível, o argumento transmitido será ignorado.
Para obter mais informações, consulte [Acionadores](aws-glue-api-jobs-trigger.md) na API do AWS Glue.
# Adição de acionadores
É possível adicionar um gatilho usando o console do AWS Glue, a AWS Command Line Interface (AWS CLI) ou a API do AWS Glue.
**Como adicionar um gatilho (console)**
1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. No painel de navegação, em **ETL**, selecione **Triggers (Gatilhos)**. Escolha **Add trigger (Adicionar gatilhos)**.
1. Forneça as seguintes propriedades:
**Name**
Atribua um nome exclusivo ao gatilho.
**Tipos de gatilho**
Especifique um dos seguintes:
+ **Schedule (Programação):** o gatilho é acionado em uma frequência e hora específicas.
+ **Job events (Eventos de trabalho):** um gatilho condicional. O gatilho é acionado quando um ou todos os trabalhos na lista correspondem ao seu status designado. Para que o gatilho seja acionado, os trabalhos monitorados devem ter sido iniciados por um gatilho. Para qualquer trabalho que você escolher, só é possível observar um evento de trabalho (status de conclusão).
+ **On-demand (Sob demanda):** o gatilho é acionado quando habilitado.
1. Executar o assistente de gatilho. Na página **Review (Revisar)** você pode ativar gatilhos **Schedule (Programados)** e de **Job events (Eventos de trabalho)** (condicionais) imediatamente selecionando **Enable trigger on creation (Habilitar gatilho na criação)**.
**Como adicionar um gatilho (AWS CLI)**
+ Digite um comando semelhante ao seguinte:
```
aws glue create-trigger --name MyTrigger --type SCHEDULED --schedule "cron(0 12 * * ? *)" --actions CrawlerName=MyCrawler --start-on-creation
```
Esse comando cria um gatilho programado chamado `MyTrigger`, que é executado todos os dias às 12h UTC e inicia um crawler chamado `MyCrawler`. O gatilho é criado no estado ativado.
Para obter mais informações, consulte [Gatilhos do AWS Glue](about-triggers.md).
# Programações baseadas em hora para trabalhos e crawlers
Você pode definir uma programação baseada em hora para seus crawlers e trabalhos no AWS Glue. A definição dessas programações usa a sintaxe [cron](http://en.wikipedia.org/wiki/Cron) semelhante à do Unix. Você especifica a hora em [Tempo Universal Coordenado (UTC)](http://en.wikipedia.org/wiki/Coordinated_Universal_Time). Além disso, a precisão mínima para uma programação é de 5 minutos.
Para saber mais sobre como configurar trabalhos e crawlers para serem executados usando uma programação, consulte [Iniciar trabalhos e crawlers usando acionadores](trigger-job.md).
## Expressão cron
Expressões cron têm seis campos obrigatórios, que são separados por um espaço em branco.
**Sintaxe**
```
cron(Minutes Hours Day-of-month Month Day-of-week Year)
```
| **Campos** | **Valores** | **Curingas** |
| --- | --- | --- |
| Minutos | 0–59 | , - \$1 / |
| Horas | 0–23 | , - \$1 / |
| Dia do mês | 1–31 | , - \$1 ? / L W |
| Mês | 1-12 ou JAN-DEZ | , - \$1 / |
| Dia da semana | 1-7 ou SUN-SAT | , - \$1 ? / L |
| Ano | 1970–2199 | , - \$1 / |
**Curingas**
+ A **,** (vírgula) curinga inclui valores adicionais. No campo `Month`, `JAN,FEB,MAR` incluirá janeiro, fevereiro e março.
+ O **-** (traço) curinga especifica intervalos. No campo `Day`, 1-15 incluiria os dias 1 a 15 do mês especificado.
+ O **\$1** (asterisco) curinga inclui todos os valores no campo. No campo `Hours`, **\$1** incluirá cada hora.
+ A **/** (barra) curinga especifica incrementos. No campo `Minutes`, você pode inserir **1/10** para especificar cada décimo minuto a partir do primeiro minuto da hora (por exemplo, o 11º, 21º e 31º minuto, etc).
+ O curinga **?** (interrogação) especifica um ou outro. No campo `Day-of-month`, você pode inserir **7** e, se não se importar com qual dia da semana era o sétimo, pode inserir **?** no campo Dia da semana.
+ O curinga **L** nos campos `Day-of-month` ou `Day-of-week` especifica o último dia do mês ou da semana.
+ O curinga **W** no campo `Day-of-month` especifica um dia da semana. No campo `Day-of-month`, `3W` especifica o dia mais próximo do terceiro dia da semana do mês.
**Limites**
+ Não é possível especificar os campos `Day-of-month` e `Day-of-week` na mesma expressão cron. Se você especificar um valor em um dos campos, deverá usar um **?** (ponto de interrogação) no outro.
+ As expressões cron que levam a taxas mais rápidas do que 5 minutos não têm suporte.
**Exemplos**
Ao criar uma programação, você pode usar os seguintes exemplos de strings cron.
| Minutos | Horas | Dia do mês | Mês | Dia da semana | Ano | Significado |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | 10 | \$1 | \$1 | ? | \$1 | Executada às 10h (UTC) todos os dias |
| 15 | 12 | \$1 | \$1 | ? | \$1 | Executada às 12h15 (UTC) todos os dias |
| 0 | 18 | ? | \$1 | SEG-SEX | \$1 | Executada às 18h (UTC) de segunda a sexta |
| 0 | 8 | 1 | \$1 | ? | \$1 | Executada às 8h (UTC) todo o primeiro dia do mês |
| 0/15 | \$1 | \$1 | \$1 | ? | \$1 | Executada a cada 15 minutos |
| 0/10 | \$1 | ? | \$1 | SEG-SEX | \$1 | Executada a cada 10 minutos de segunda a sexta |
| 0/5 | 8-17 | ? | \$1 | SEG-SEX | \$1 | Executada a cada 5 minutos de segunda a sexta entre 8h e 17h55 (UTC) |
Por exemplo, para executar uma programação todos os dias às 12h15 UTC, especifique:
```
cron(15 12 * * ? *)
```
# Ativar e desativar acionadores
Você pode ativar ou desativar um gatilho usando o console do AWS Glue, a AWS Command Line Interface (AWS CLI) ou a API do AWS Glue.
**Como ativar ou desativar um gatilho (console)**
1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. No painel de navegação, em **ETL**, selecione **Triggers (Gatilhos)**.
1. Marque a caixa de seleção ao lado do gatilho desejado e, no menu **Action (Ação)**, escolha **Enable trigger (Habilitar gatilho)** para ativar o gatilho ou **Disable trigger (Desabilitar gatilho)** para desativar o gatilho.
**Como ativar ou desativar um gatilho (AWS CLI)**
+ Insira um dos seguintes comandos:
```
aws glue start-trigger --name MyTrigger
aws glue stop-trigger --name MyTrigger
```
Ao iniciar um gatilho ele é ativado e ao interromper um gatilho ele é desativado. Quando você ativa um gatilho sob demanda, ele é acionado imediatamente.
Para obter mais informações, consulte [Gatilhos do AWS Glue](about-triggers.md).
# Realizar atividades de ETL complexas usando esquemas e fluxos de trabalho no AWS Glue
Alguns dos processos complexos de extração, transformação e carregamento (ETL) da sua organização podem ser melhor implantados usando vários crawlers e trabalhos dependentes do AWS Glue. Usando *fluxos de trabalho* do AWS Glue, você pode projetar um processo complexo de ETL com vários trabalhos e crawlers, que o AWS Glue pode executar e rastrear como uma entidade única. Depois de criar um fluxo de trabalho e especificar os trabalhos, crawlers e acionadores no fluxo de trabalho, você pode executá-lo sob demanda ou em uma programação.
**Topics**
+ [Visão geral de fluxos de trabalho no AWS Glue](workflows_overview.md)
+ [Criar e desenvolver um fluxo de trabalho manualmente no AWS Glue](creating_running_workflows.md)
+ [Iniciar um fluxo de trabalho do AWS Glue com um evento do Amazon EventBridge](starting-workflow-eventbridge.md)
+ [Visualizar os eventos do EventBridge que iniciaram um fluxo de trabalho](viewing-start-event-info.md)
+ [Executar e monitorar um fluxo de trabalho no AWS Glue](running_monitoring_workflow.md)
+ [Interromper uma execução de fluxo de trabalho](workflow-stopping.md)
+ [Reparar e retomar uma execução de fluxo de trabalho](resuming-workflow.md)
+ [Obter e configurar as propriedades de execução de fluxo de trabalho no AWS Glue](workflow-run-properties-code.md)
+ [Consultar fluxos de trabalho usando o AWS Glue API](workflows_api_concepts.md)
+ [Restrições de esquema e fluxo de trabalho no AWS Glue](blueprint_workflow_restrictions.md)
+ [Solucionar erros de esquema no AWS Glue](blueprint_workflow_troubleshoot.md)
+ [Permissões para pessoas e funções de esquemas do AWS Glue](blueprints-personas-permissions.md)
# Visão geral de fluxos de trabalho no AWS Glue
No AWS Glue, você pode usar fluxos de trabalho para criar e visualizar atividades complexas de extração, transformação e carregamento (ETL) que envolvem vários crawlers, trabalhos e gatilhos. Cada fluxo de trabalho gerencia a execução e o monitoramento de todos os seus trabalhos e crawlers. À medida que um fluxo de trabalho executa cada componente, ele registra o progresso e o status de execução. Isso fornece a você uma visão geral das tarefa maior e os detalhes de cada etapa. O console do AWS Glue fornece uma representação visual de um fluxo de trabalho como um gráfico.
Você pode criar um fluxo de trabalho a partir de um blueprint do AWS Glue ou pode construir um fluxo de trabalho manualmente, um componente de cada vez, usando o Console de gerenciamento da AWS ou a AWS Glue API. Para obter mais informações sobre esquemas, consulte [Visão geral dos esquemas no AWS Glue](blueprints-overview.md).
Os *acionadores* nos fluxos de trabalho podem ser acionar trabalhos e crawlers e podem ser disparados quando trabalhos e crawlers são concluídos. Usando acionadores, é possível criar grandes cadeias de trabalhos e crawlers interdependentes. Além dos acionadores em um fluxo de trabalho que definem dependências de trabalhos e crawlers, cada fluxo de trabalho tem um *acionador de início*. Existem três tipos de acionadores de início:
+ **Schedule** (Programação): o fluxo de trabalho é iniciado de acordo com a programação definida por você. A programação pode ser diária, semanal, mensal e assim por diante, ou pode ser uma programação personalizada com base em uma expressão `cron`.
+ **On demand** (Sob demanda): o fluxo de trabalho é iniciado manualmente pelo console do AWS Glue, API ou AWS CLI.
+ **EventBridge event** (Evento do EventBridge): o fluxo de trabalho é iniciado após a ocorrência de um único evento do Amazon EventBridge ou de um lote de eventos do Amazon EventBridge. Com esse tipo de acionador, o AWS Glue pode ser um consumidor de eventos em uma arquitetura orientada por eventos. Qualquer evento do EventBridge pode iniciar um fluxo de trabalho. O mais provável caso de uso é a chegada de um novo objeto em um bucket do Amazon S3 (a operação `PutObject` do S3).
Iniciar um fluxo de trabalho com um lote de eventos significa esperar até que um número especificado de eventos tenha sido recebido ou até que um determinado período de tempo tenha passado. Ao criar o acionador de evento do EventBridge, você pode, opcionalmente, especificar condições de lote. Se você especificar condições de lote, deverá especificar o tamanho do lote (número de eventos) e, opcionalmente, poderá especificar uma janela de lote (número de segundos). A janela padrão e máxima do lote é 900 segundos (15 minutos). A condição de lote que é atendida primeiro inicia o fluxo de trabalho. A janela de lote é iniciada quando o primeiro evento chega. Se você não especificar condições de lote ao criar um acionador, o tamanho do lote assumirá como padrão 1.
Quando o fluxo de trabalho é iniciado, as condições de lote são redefinidas e o acionador de evento começa a observar a próxima condição de lote a ser atendida para iniciar o fluxo de trabalho novamente.
A tabela a seguir mostra como o tamanho do lote e a janela do lote operam juntos para acionar um fluxo de trabalho.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/workflows_overview.html)
A operação de API `GetWorkflowRun` retorna a condição de lote que acionou o fluxo de trabalho.
Independentemente de como um fluxo de trabalho é iniciado, você pode especificar o número máximo de execuções de fluxo de trabalho simultâneas ao criar o fluxo de trabalho.
Se um evento ou lote de eventos iniciar uma execução de fluxo de trabalho que falha em algum momento, esse evento ou lote de eventos não será mais considerado para iniciar uma execução de fluxo de trabalho. Uma nova execução de fluxo de trabalho é iniciada somente quando o próximo evento ou lote de eventos chega.
**Importante**
Limite o número total de trabalhos, crawlers e acionadores em um fluxo de trabalho a 100 ou menos. Se você incluir mais de 100, poderá receber erros ao tentar retomar ou interromper as execuções do fluxo de trabalho.
Uma execução de fluxo de trabalho não será iniciada se exceder o limite de simultaneidade definido para o fluxo de trabalho, mesmo que a condição do evento seja atendida. É aconselhável ajustar os limites de simultaneidade do fluxo de trabalho com base no volume de eventos esperado. O AWS Glue não tenta executar novamente o fluxo de trabalho que falha por causa de limites de simultaneidade excedidos. Da mesma forma, é aconselhável ajustar os limites de simultaneidade para trabalhos e crawlers dentro de fluxos de trabalho com base no volume de eventos esperado.
**Propriedades de execução do fluxo de trabalho**
Para compartilhar e gerenciar estados em uma execução de fluxo de trabalho, defina as propriedades de execução de fluxo de trabalho padrão. Essas propriedades, que são pares de nome/valor, estão disponíveis para todos os trabalhos no fluxo de trabalho. Usando o AWS Glue API, os trabalhos podem recuperar as propriedades de execução do fluxo de trabalho e modificá-las para trabalhos fornecidos posteriormente no fluxo de trabalho.
**Grafo do fluxo de trabalho**
A imagem a seguir mostra o gráfico de um fluxo de trabalho básico no console do AWS Glue. Seu fluxo de trabalho poderia ter dezenas de componentes.
![\[Captura de tela do console mostrando a guia Graph (Gráfico) de um fluxo de trabalho. O gráfico contém cinco ícones que representa um acionador de programação, dois trabalhos, um acionador de êxito de evento e um crawler que atualiza o esquema.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/graph-complete-with-tabs.png)
Esse fluxo de trabalho é iniciado por um acionador de programação, `Month-close1`, que inicia dois trabalhos, `De-duplicate` e `Fix phone numbers`. Após a conclusão bem-sucedida de ambos os trabalhos, um acionador de evento, `Fix/De-dupe succeeded`, inicia um crawler, `Update schema`.
**Visualizações estáticas e dinâmicas do fluxo de trabalho**
Para cada fluxo de trabalho, existe o conceito de visualização *estática* e *dinâmica*. A visualização estática indica o design do fluxo de trabalho. A visualização dinâmica é uma visualização do runtime que inclui as informações mais recentes de execução de cada um dos trabalhos e crawlers. As informações de execução incluem o status de sucesso e os detalhes de erros.
Quando um fluxo de trabalho estiver em execução, o console exibirá a visualização dinâmica graficamente, indicando os trabalhos que foram concluídos e os que ainda não foram executados. Também é possível recuperar uma visualização dinâmica de um fluxo de trabalho em execução usando o AWS Glue API. Para obter mais informações, consulte [Consultar fluxos de trabalho usando o AWS Glue API](workflows_api_concepts.md).
**Consulte também**
[Criar um fluxo de trabalho com base em um esquema no AWS Glue](creating_workflow_blueprint.md)
[Criar e desenvolver um fluxo de trabalho manualmente no AWS Glue](creating_running_workflows.md)
[Fluxos de trabalho](aws-glue-api-workflow.md) (para a API de fluxos de trabalho)
# Criar e desenvolver um fluxo de trabalho manualmente no AWS Glue
Use o console do AWS Glue para criar e construir manualmente um fluxo de trabalho um nó por vez.
Um fluxo de trabalho contém tarefas, crawlers e gatilhos. Antes de criar manualmente um fluxo de trabalho, crie os trabalhos e crawlers que o fluxo de trabalho deve incluir. É melhor especificar crawlers com execução sob demanda para fluxos de trabalho. É possível criar gatilhos durante o desenvolvimento do fluxo de trabalho ou *clonar* gatilhos existentes no fluxo de trabalho. Quando você clona um acionador, todos os objetos do catálogo associados ao acionador (os trabalhos ou crawlers que o acionam e os trabalhos ou crawlers que ele inicia) são adicionados ao fluxo de trabalho.
**Importante**
Limite o número total de trabalhos, crawlers e acionadores em um fluxo de trabalho a 100 ou menos. Se você incluir mais de 100, poderá receber erros ao tentar retomar ou interromper as execuções do fluxo de trabalho.
Desenvolva o fluxo de trabalho ao adicionar gatilhos ao gráfico do fluxo de trabalho e ao definir os eventos monitorados e as ações para cada gatilho. Comece com um *gatilho de início*, que pode ser um gatilho sob demanda ou programado e conclua o gráfico adicionando gatilhos de evento (condicionais).
## Etapa 1: Criar o fluxo de trabalho
1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. No painel de navegação, em **ETL**, selecione **Workflows (Fluxos de trabalho)**.
1. Selecione **Add workflow (Adicionar fluxo de trabalho)** e preencha o formulário **Add a new ETL workflow (Adicionar um novo fluxo de trabalho de ETL)**.
As propriedades de execução padrão opcional que você adicionar são disponibilizadas como argumentos para todas as tarefas no fluxo de trabalho. Para obter mais informações, consulte [Obter e configurar as propriedades de execução de fluxo de trabalho no AWS Glue](workflow-run-properties-code.md).
1. Selecione **Add workflow (Adicionar fluxo de trabalho)**.
O novo fluxo de trabalho é exibido na lista da página **Workflows (Fluxos de trabalho)**.
## Etapa 2: Adicionar um gatilho de início
1. Na página **Workflows (Fluxos de trabalho)**, selecione o novo fluxo de trabalho. Em seguida, na parte inferior da página, certifique-se de que a guia **Graph** (Gráfico) esteja selecionada.
1. Selecione **Add trigger (Adicionar gatilho)** e na caixa de diálogo **Add trigger (Adicionar gatilho)**, execute uma das seguintes ações:
+ Selecione **Clone existing (Clonar existente)**, e escolha um gatilho para ser clonado. Em seguida, escolha **Adicionar**.
O gatilho é exibido no gráfico com as tarefas e os crawlers que ele monitora e as tarefas e os crawlers que ele inicia.
Se você selecionou o gatilho errado por engano, selecione o gatilho no gráfico e selecione **Remove (Remover)**.
+ Selecione **Add new (Adicionar novo)** e preencha o formulário **Add trigger (Adicionar gatilho)**.
1. Para **Trigger type** (Tipo de acionador), selecione **Schedule** (Programação), **On demand** (Sob demanda) ou **EventBridge event** (Evento do EventBridge).
Para o tipo de acionador **Schedule** (Programação), escolha uma das opções de **Frequency** (Frequência). Escolha **Custom** (Personalizado) para inserir uma expressão `cron`.
Para o tipo de acionador **EventBridge event** (Evento do EventBridge), insira o **Number of events** (Número de eventos; tamanho do lote) e, opcionalmente, insira o **Time delay** (Tempo de atraso; janela de lote). Se você omitir o **Time delay** (Tempo de atraso), o padrão da janela do lote será 15 minutos. Para obter mais informações, consulte [Visão geral de fluxos de trabalho no AWS Glue](workflows_overview.md).
1. Escolha **Adicionar**.
O gatilho é exibido no gráfico com um nó de espaço reservado (identificado como **Add node (Adicionar nó)**). No exemplo abaixo, o acionador de início é um acionador de programação chamado `Month-close1`.
Neste momento, o acionador ainda não está salvo.
![\[Um gráfico com dois nós retangulares: um nó de gatilho e um nó de espaço reservado. Uma seta aponta do nó do acionador para o nó de espaço reservado.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/graph-start-trigger.png)
1. Se você adicionou um novo gatilho, execute estas etapas:
1. Execute um destes procedimentos:
+ Escolha o nó de espaço reservado (**Add node (Adicionar nó)**).
+ Certifique-se de que o gatilho de início esteja selecionado e, no menu **Action (Ação)** acima do gráfico, selecione **Add jobs/crawlers to trigger (Adicionar tarefas/crawlers ao gatilho)**.
1. Na caixa de diálogo **Add job(s) and crawler(s) to trigger (Adicionar tarefas e crawlers ao gatilho)**, selecione uma ou mais tarefas ou crawlers e selecione **Add (Adicionar)**.
O gatilho é salvo e as tarefas ou crawlers selecionados são exibidos no gráfico com conectores do gatilho.
Se você adicionou tarefas ou crawlers errados por engano, pode selecionar o gatilho ou um conector e selecionar **Remove (Remover)**.
## Etapa 3: adicionar mais acionadores
Continue a construir o fluxo de trabalho adicionando mais acionadores do tipo **Event** (Evento). Para aumentar ou diminuir o zoom ou para ampliar a tela do gráfico, use os ícones à direita do gráfico. Para cada gatilho a ser adicionado, conclua as seguintes etapas:
**nota**
Não há nenhuma ação para salvar o fluxo de trabalho. Depois de adicionar o último acionador e atribuir ações a ele, o fluxo de trabalho será concluído e salvo. Você pode voltar a qualquer momento e adicionar mais nós.
1. Execute um destes procedimentos:
+ Para clonar um gatilho existente, certifique-se de que nenhum nó do gráfico esteja selecionado e, no menu **Action (Ação)**, selecione **Add trigger (Adicionar gatilho)**.
+ Para adicionar um novo gatilho que monitora uma tarefa ou um crawler específico no gráfico, selecione o nó da tarefa ou do crawler e selecione o nó do espaço reservado **Add trigger (Adicionar gatilho)**.
É possível adicionar mais tarefas ou crawlers a serem monitorados por esse gatilho em uma etapa posterior.
1. Na caixa de diálogo **Add trigger (Adicionar gatilho)**, siga um destes procedimentos:
+ Selecione **Add new (Adicionar novo)** e preencha o formulário **Add trigger (Adicionar gatilho)**. Em seguida, escolha **Adicionar**.
O gatilho é exibido no gráfico. Você concluirá o gatilho em uma etapa posterior.
+ Selecione **Clone existing (Clonar existente)**, e escolha um gatilho para ser clonado. Em seguida, escolha **Adicionar**.
O gatilho é exibido no gráfico com as tarefas e os crawlers que ele monitora e as tarefas e os crawlers que ele inicia.
Se você escolheu o gatilho errado por engano, selecione-o no gráfico e selecione **Remove (Remover)**.
1. Se você adicionou um novo gatilho, execute estas etapas:
1. Selecione o novo gatilho.
Como mostra o gráfico a seguir, o acionador `De-dupe/fix succeeded` está selecionado, e os nós de espaço reservado aparecem para (q) evento a ser monitorado e (2) ações.
![\[Um gráfico com vários nós, dois dos quais são nós de espaço reservados destacados como números 1 e 2.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/graph-dual-placeholders.png)
1. (Opcional caso o gatilho já esteja monitorando um evento e você queira adicionar mais tarefas ou crawlers para serem monitorados.) Escolha o nó de espaço reservado de eventos a serem monitorados e, na caixa de diálogo **Add job(s) and crawler(s) to watch (Adicionar tarefas e crawlers a serem monitorados)**, selecione uma ou mais tarefas ou crawlers. Escolha um evento a ser monitorado (BEM-SUCEDIDO, COM FALHA, etc.) e selecione **Add (Adicionar)**.
1. Certifique-se de que o gatilho esteja selecionado e escolha o nó de espaço reservado de ações.
1. Na caixa de diálogo **Add job(s) and crawler(s) to watch (Adicionar tarefas e crawlers a serem monitorados)**, selecione uma ou mais tarefas e crawlers e selecione **Add (Adicionar)**.
As tarefas e os crawlers selecionados são exibidos no gráfico com conectores do gatilho.
Para obter mais informações sobre fluxos de trabalho e esquemas, consulte os tópicos a seguir.
+ [Visão geral de fluxos de trabalho no AWS Glue](workflows_overview.md)
+ [Executar e monitorar um fluxo de trabalho no AWS Glue](running_monitoring_workflow.md)
+ [Criar um fluxo de trabalho com base em um esquema no AWS Glue](creating_workflow_blueprint.md)
# 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](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html).
**Para iniciar um fluxo de trabalho com um evento do EventBridge**
**nota**
Nos comandos a seguir, substitua:
** pelo nome a ser atribuído ao fluxo de trabalho.
** pelo nome a ser atribuído ao acionador.
** pelo nome do bucket do Amazon S3.
** por um ID da conta da AWS válido.
** pelo nome da região (por exemplo, `us-east-1`).
** pelo nome a ser atribuído à regra do EventBridge.
1. 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.
------
#### [ 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. 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**.
1. Conclua o assistente **Create role** (Criar função). O assistente anexa automaticamente as políticas `CloudWatchEventsBuiltInTargetExecutionAccess` e `CloudWatchEventsInvocationAccess`.
1. Anexe a política em linha a seguir à função. Esta política permite que o produto EventBridge direcione eventos para o 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. Insira o comando a seguir para criar o fluxo de trabalho.
Consulte [criar fluxo de trabalho](https://docs.aws.amazon.com/cli/latest/reference/glue/create-workflow.html) 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
```
1. 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 ** pelas ações a serem executadas (os trabalhos e os crawlers a serem iniciados).
Consulte [criar trigger](https://docs.aws.amazon.com/cli/latest/reference/glue/create-trigger.html) na *Referência de comandos da AWS CLI* para obter informações sobre como codificar o argumento `actions`.
```
aws glue create-trigger --workflow-name --type EVENT --name --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 --type EVENT --name --event-batching-condition BatchSize=,BatchWindow= --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.
**Example**
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
```
1. Crie uma regra no Amazon EventBridge.
1. 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": [
""
]
}
}
}
```
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": [
""
]
"key" : [{ "prefix" : "//*"}}]
}
```
1. 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 \"\"\n ]\n }\n }\n}
```
1. 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 --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](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-skeleton.html) 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": ""
}
```
1. 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": "",
"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**
É melhor deixar a regra desabilitada até terminar de criar o fluxo de trabalho.
1. Insira o seguinte comando `put-rule`, que lê os parâmetros de entrada do arquivo `ruleCommand`.
```
aws events put-rule --name --cli-input-json file://ruleCommand
```
A seguinte saída indica sucesso.
```
{
"RuleArn": ""
}
```
1. Insira o comando a seguir para anexar a regra a um destino. O destino é o fluxo de trabalho no AWS Glue. Substitua ** pela função criada por você no início deste procedimento.
```
aws events put-targets --rule --targets "Id"="1","Arn"="arn:aws:glue:::workflow/","RoleArn"="arn:aws:iam:::role/" --region
```
A seguinte saída indica sucesso.
```
{
"FailedEntryCount": 0,
"FailedEntries": []
}
```
1. 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:::workflow/
```
A seguinte saída indica sucesso, em que ** é o nome da regra que você criou.
```
{
"RuleNames": [
""
]
}
```
1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. 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](creating_running_workflows.md#workflow-step3). Ou adicione mais componentes ao fluxo de trabalho usando a API do AWS Glue ou AWS Command Line Interface.
1. Quando o fluxo de trabalho estiver completamente especificado, habilite a regra.
```
aws events enable-rule --name
```
O fluxo de trabalho agora está pronto para ser iniciado por um evento do EventBridge ou lote de eventos.
**Consulte também**
[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)
[Visão geral de fluxos de trabalho no AWS Glue](workflows_overview.md)
[Criar e desenvolver um fluxo de trabalho manualmente no AWS Glue](creating_running_workflows.md)
# Visualizar os eventos do EventBridge que iniciaram um fluxo de trabalho
Você pode visualizar o ID do evento do Amazon EventBridge que iniciou seu fluxo de trabalho. Se o fluxo de trabalho foi iniciado por um lote de eventos, você pode exibir os IDs de evento de todos os eventos no lote.
Para fluxos de trabalho com um tamanho de lote maior que um, você também pode ver qual condição de lote iniciou o fluxo de trabalho: a chegada do número de eventos no tamanho do lote ou a validade da janela do lote.
**Para exibir os eventos do EventBridge que iniciaram um fluxo de trabalho (console)**
1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. No painel de navegação, escolha **Workflows** (Fluxos de trabalho).
1. Selecione o fluxo de trabalho. Em seguida, na parte inferior, escolha a guia **History** (Histórico).
1. Selecione uma execução de fluxo de trabalho e escolha **View run details** (Visualizar detalhes da execução).
1. Na página de detalhes da execução, localize o campo **Run properties** (Propriedades de execução) e procure a chave **aws:eventIds**.
O valor dessa chave é uma lista de IDs de eventos do EventBridge.
**Para exibir os eventos do EventBridge que iniciaram um fluxo de trabalho (API da AWS)**
+ Inclua o seguinte código em seu script 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á uma lista de strings, em que cada string é um ID de evento.
**Consulte também**
[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)
[Visão geral de fluxos de trabalho no AWS Glue](workflows_overview.md)
# Executar e monitorar um fluxo de trabalho no AWS Glue
Se o gatilho de início de um fluxo de trabalho for um gatilho sob demanda, será possível iniciar o fluxo de trabalho no console do AWS Glue. Conclua as etapas a seguir para executar e monitorar um fluxo de trabalho. Se o fluxo de trabalho falhar, é possível visualizar o gráfico de execução para determinar o nó que falhou. Para ajudar a solucionar problemas, se o fluxo de trabalho tiver sido criado de um blueprint, você poderá exibir a execução do blueprint para ver os valores dos parâmetros do blueprint usados para criar o fluxo de trabalho. Para obter mais informações, consulte [Visualizar execuções de esquemas no AWS Glue](viewing_blueprint_runs.md).
Você executar e monitorar um fluxo de trabalho usando o console do AWS Glue, API ou o AWS Command Line Interface (AWS CLI).
**Para executar e monitorar um fluxo de trabalho (console)**
1. Abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. No painel de navegação, em **ETL**, selecione **Workflows (Fluxos de trabalho)**.
1. Selecione um fluxo de trabalho. No menu **Actions (Ações)**, selecione **Run (Executar)**.
1. Confira a coluna **Last run status** (Status da última execução) na lista de fluxos de trabalho. Escolha o botão de atualização para exibir o status do fluxo de trabalho em andamento.
1. Enquanto o fluxo de trabalho estiver em execução, ou após a conclusão (ou falha), visualize os detalhes da execução concluindo as etapas a seguir.
1. Certifique-se de que o fluxo de trabalho esteja selecionado e escolha a guia **History** (Histórico).
1. Escolha a execução do fluxo de trabalho atual ou mais recente e escolha **View run details** (Visualizar detalhes da execução).
O gráfico de runtime do fluxo de trabalho mostra o status de execução atual.
1. Escolha qualquer nó no gráfico para exibir os detalhes e status dele.
![\[O gráfico de execução mostra um acionador inicial, que inicia um trabalho. Outro acionador observa a conclusão do trabalho. O nó do trabalho (um retângulo que inclui um ícone da área de transferência e um nome de trabalho) é selecionado e os detalhes do trabalho são mostrados em um painel à direita. Os detalhes incluem ID e status da execução do trabalho.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/workflow-pre-select-resume.png)
**Para executar e monitorar um fluxo de trabalho (AWS CLI)**
1. Insira o comando a seguir. Substitua ** pelo fluxo de trabalho a ser executado.
```
aws glue start-workflow-run --name
```
Se o fluxo de trabalho for iniciado com êxito, o comando retornará o ID de execução.
1. Visualize o status de execução do fluxo de trabalho usando o comando `get-workflow-run`. Forneça o nome do fluxo de trabalho e o ID de execução.
```
aws glue get-workflow-run --name myWorkflow --run-id wr_d2af14217e8eae775ba7b1fc6fc7a42c795aed3cbcd8763f9415452e2dbc8705
```
Este é um exemplo de saída de 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
}
}
}
```
**Consulte também:**
[Visão geral de fluxos de trabalho no AWS Glue](workflows_overview.md)
[Visão geral dos esquemas no AWS Glue](blueprints-overview.md)
# Interromper uma execução de fluxo de trabalho
É possível usar o console do AWS Glue, a AWS Command Line Interface (AWS CLI) ou a API do AWS Glue para interromper uma execução de fluxo de trabalho. Quando você interrompe uma execução de fluxo de trabalho, todos os crawlers e os trabalhos em execução são imediatamente encerrados, e os que ainda não foram iniciados nunca serão. Pode levar até um minuto para que todos os crawlers e os trabalhos em execução sejam interrompidos. O status de execução do fluxo de trabalho passa de **Em execução** para **Interrompendo** e, quando a execução do fluxo de trabalho é completamente interrompida, o status passa para **Interrompido**.
Depois que a execução do fluxo de trabalho é interrompida, é possível visualizar o gráfico de execução para saber quais trabalhos e crawlers foram concluídos e quais nunca começaram. Assim, você pode determinar se é necessário executar alguma etapa para garantir a integridade dos dados. Interromper uma execução de fluxo de trabalho faz com que nenhuma operação de reversão automática seja executada.
**Como interromper uma execução de fluxo de trabalho (console)**
1. Abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. No painel de navegação, em **ETL**, selecione **Workflows (Fluxos de trabalho)**.
1. Escolha um fluxo de trabalho em execução e selecione a guia **Histórico**.
1. Escolha a execução do fluxo de trabalho e selecione **Interromper execução**.
O status da execução muda para **Interrompendo**.
1. (Opcional) Escolha a execução do fluxo de trabalho, selecione **Visualizar detalhes da execução** e revise o gráfico de execução.
**Como interromper uma execução de fluxo de trabalho (AWS CLI)**
+ Insira o comando da a seguir. Substitua ** pelo nome do fluxo de trabalho e ** pelo ID da execução do fluxo de trabalho a ser interrompida.
```
aws glue stop-workflow-run --name --run-id
```
Veja a seguir um exemplo do comando **stop-workflow-run**.
```
aws glue stop-workflow-run --name my-workflow --run-id wr_137b88917411d128081069901e4a80595d97f719282094b7f271d09576770354
```
# Reparar e retomar uma execução de fluxo de trabalho
Se um ou mais nós (trabalhos ou crawlers) em um fluxo de trabalho não forem concluídos com êxito, isso significa que o fluxo de trabalho foi executado apenas parcialmente. Depois de localizar as causas raiz e fazer correções, você pode selecionar um ou mais nós de onde retomar a execução do fluxo de trabalho e, em seguida, retomá-la. Os nós selecionados e todos os nós que estão a jusante desses nós são então executados.
**Topics**
+ [Retomar uma execução de fluxo de trabalho: como funciona](#resume-workflow-howitworks)
+ [Retomar uma execução de fluxo de trabalho](#how-to-resume-workflow)
+ [Observações e limitações para retomar execuções de fluxo de trabalho](#resume-workflow-notes)
## Retomar uma execução de fluxo de trabalho: como funciona
Considere o fluxo de trabalho W1 no diagrama a seguir.
![\[Os acionadores são mostrados em retângulos e os trabalhos são mostrados em círculos. O acionador T1 à esquerda inicia o fluxo de trabalho executando o trabalho J1. Existem acionadores e trabalhos subsequentes, mas os trabalhos J2 e J3 falham, portanto, os acionadores e os trabalhos a jusante são mostrados como não executados.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/workflow_W1.png)
A execução do fluxo de trabalho prossegue da seguinte forma:
1. O acionador T1 inicia o trabalho J1.
1. A conclusão bem-sucedida de J1 aciona T2 e T3, que executam os trabalhos J2 e J3, respectivamente.
1. Os trabalhos J2 e J3 falham.
1. Os acionadores T4 e T5 dependem da conclusão bem-sucedida de J2 e J3, então eles não disparam, e os trabalhos J4 e J5 não são executados. O fluxo de trabalho W1 é executado apenas parcialmente.
Agora, suponha que os problemas que causaram a falha de J2 e J3 sejam corrigidos. J2 e J3 são selecionados como os pontos de partida para retomar a execução do fluxo de trabalho.
![\[Os trabalhos J2 e J3 são sinalizados como nós a serem retomados. Os acionadores e os trabalhos a jusante são mostrados como executados com êxito.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/workflow_W1_resumed.png)
A execução do fluxo de trabalho é retomada da seguinte forma:
1. Os trabalhos J2 e J3 são executados com êxito.
1. Os acionadores T4 e T5 disparam.
1. Os trabalhos J4 e J5 são executados com êxito.
A execução do fluxo de trabalho retomado é rastreada como uma execução de fluxo de trabalho separada com um novo ID de execução. Ao exibir o histórico do fluxo de trabalho, você pode exibir o ID de execução anterior para qualquer execução do fluxo de trabalho. No exemplo na captura de tela a seguir, o fluxo de trabalho executado com o ID de execução `wr_c7a22...` (a segunda linha) tinha um nó que não foi concluído. O usuário corrigiu o problema e retomou a execução do fluxo de trabalho, o que resultou no ID de execução `wr_a07e55...` (a primeira linha).
![\[Uma tabela na guia History (Histórico) de um fluxo de trabalho contém duas linhas, uma para cada execução do fluxo de trabalho. A primeira linha tem um ID de execução e um ID de execução anterior. A segunda linha tem apenas um ID de execução. O ID de execução anterior na primeira linha é o mesmo que o ID de execução na 2.ª linha.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/previous-run-id.png)
**nota**
Para o resto desta discussão, o termo “execução do fluxo de trabalho retomado” refere-se à execução do fluxo de trabalho que foi criada quando a execução do fluxo de trabalho anterior foi retomada. A “execução do fluxo de trabalho original” refere-se à execução do fluxo de trabalho que foi executada apenas parcialmente e que precisava ser retomada.
**Grafo de execução de fluxo de trabalho retomada**
Em uma execução de fluxo de trabalho retomada, embora apenas um subconjunto de nós seja executado, o gráfico de execução é um gráfico completo. Ou seja, os nós que não foram executados no fluxo de trabalho retomado são copiados do gráfico de execução da execução do fluxo de trabalho original. Os nós de trabalho e crawler copiados executados na execução do fluxo de trabalho original incluem os detalhes da execução.
Considere novamente o fluxo de trabalho W1 no diagrama anterior. Quando a execução do fluxo de trabalho é retomada começando com J2 e J3, o gráfico para a execução do fluxo de trabalho retomado mostra todos os trabalhos, J1 a J5, e todos os acionadores, T1 a T5. Os detalhes da execução para J1 são copiados da execução do fluxo de trabalho original.
**Snapshots da execução do fluxo de trabalho**
Quando uma execução de fluxo de trabalho é iniciada, o AWS Glue tira um snapshot do gráfico de design do fluxo de trabalho naquele ponto no tempo. Esse snapshot é usado durante a execução do fluxo de trabalho. Se você fizer alterações em quaisquer acionadores após o início da execução, essas alterações não afetarão a execução do fluxo de trabalho atual. Os snapshots garantem que as execuções do fluxo de trabalho prossigam de maneira consistente.
Os snapshots tornam apenas os acionadores imutáveis. As alterações feitas em trabalhos e crawlers a jusante durante a execução do fluxo de trabalho entram em vigor para a execução atual.
## Retomar uma execução de fluxo de trabalho
Siga estas etapas para retomar uma execução de fluxo de trabalho. Você pode retomar uma execução de fluxo de trabalho usando o console do AWS Glue, a API ou o AWS Command Line Interface (AWS CLI).
**Como retomar a execução de um fluxo de trabalho (console)**
1. Abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Faça login como um usuário que tem permissões para exibir fluxos de trabalho e retomar execuções de fluxo de trabalho.
**nota**
Para retomar execuções de fluxo de trabalho, você precisa da permissão `glue:ResumeWorkflowRun` do AWS Identity and Access Management (IAM).
1. No painel de navegação, escolha **Workflows** (Fluxos de trabalho).
1. Selecione um fluxo de trabalho e escolha a guia **History** (Histórico).
1. Selecione a execução do fluxo de trabalho que foi executada apenas parcialmente e escolha **View run details** (Visualizar detalhes da execução).
1. No gráfico de execução, selecione o primeiro (ou único) nó que deseja reiniciar e do qual deseja retomar a execução do fluxo de trabalho.
1. No painel de detalhes à direita do gráfico, selecione a caixa de seleção **Resume** (Retomar).
![\[O gráfico de execução mostra três nós, incluindo um nó de trabalho com falha. O painel de detalhes do trabalho à direita inclui uma caixa de seleção Resume (Retomar).\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/workflow-pre-select-resume.png)
O nó muda de cor e mostra um pequeno ícone de retomada no canto superior direito.
![\[A alteração no gráfico de execução é descrita no texto. A caixa de seleção Resume (Retomar) está marcada.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/workflow-post-select-resume.png)
1. Conclua as duas etapas anteriores para que todos os nós adicionais reiniciem.
1. Selecione **Resume run** (Retomar execução).
**Para retomar a execução de um fluxo de trabalho (AWS CLI)**
1. Verifique se você tem a permissão `glue:ResumeWorkflowRun` do IAM.
1. Recupere os IDs de nós dos nós que você deseja reiniciar.
1. Execute o comando `get-workflow-run` para a execução do fluxo de trabalho original. Forneça o nome do fluxo de trabalho e o ID de execução, e adicione a opção `--include-graph`, conforme mostrado no exemplo a seguir. Obtenha o ID de execução na guia **History** (Histórico) no console, ou executando o comando `get-workflow`.
```
aws glue get-workflow-run --name cloudtrailtest1 --run-id wr_a07e55f2087afdd415a404403f644a4265278f68b13ba3da08c71924ebe3c3a8 --include-graph
```
O comando retorna os nós e as bordas do gráfico como um objeto JSON grande.
1. Localize os nós de interesse pelas propriedades `Type` e `Name` dos objetos de nó.
A seguir, está um exemplo de objeto de nó da saída.
```
{
"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. Obtenha o ID do nó da propriedade `UniqueId` do objeto de nó.
1. Execute o comando `resume-workflow-run`. Forneça o nome do fluxo de trabalho, o ID da execução e a lista de IDs de nós separados por espaços, conforme mostrado no exemplo a seguir.
```
aws glue resume-workflow-run --name cloudtrailtest1 --run-id wr_a07e55f2087afdd415a404403f644a4265278f68b13ba3da08c71924ebe3c3a8 --node-ids wnode_ca1f63e918fb855e063aed2f42ec5762ccf71b80082ae2eb5daeb8052442f2f3 wnode_d1b2563c503078b153142ee76ce545fe5ceef66e053628a786ddd74a05da86fd
```
O comando gera o ID de execução do fluxo de trabalho retomado (novo) e uma lista de nós que serão iniciados.
```
{
"RunId": "wr_2ada0d3209a262fc1156e4291134b3bd643491bcfb0ceead30bd3e4efac24de9",
"NodeIds": [
"wnode_ca1f63e918fb855e063aed2f42ec5762ccf71b80082ae2eb5daeb8052442f2f3"
]
}
```
Note que, apesar do comando de exemplo `resume-workflow-run` ter listado dois nós para reiniciar, a saída de exemplo indicou que apenas um nó seria reiniciado. Isso ocorre porque um nó estava a jusante do outro, e o nó a jusante seria reiniciado de qualquer maneira pelo fluxo normal do fluxo de trabalho.
## Observações e limitações para retomar execuções de fluxo de trabalho
Tenha em mente as seguintes observações e limitações ao retomar as execuções do fluxo de trabalho.
+ Você pode retomar uma execução de fluxo de trabalho somente se ele estiver no estado `COMPLETED`.
**nota**
Mesmo que um ou mais nós em uma execução de fluxo de trabalho não sejam concluídos, o estado de execução do fluxo de trabalho é mostrado como `COMPLETED`. Certifique-se de verificar o gráfico de execução para descobrir todos os nós que não foram concluídos com êxito.
+ Você pode retomar uma execução de fluxo de trabalho de qualquer nó de trabalho ou crawler que a execução do fluxo de trabalho original tenha tentado executar. Não é possível retomar uma execução de fluxo de trabalho de um nó de acionador.
+ Reiniciar um nó não redefine seu estado. Todos os dados que foram parcialmente processados não são revertidos.
+ Você pode retomar uma execução de fluxo de trabalho com falha várias vezes. No entanto, uma execução retomada só pode ser retomada mais uma vez. Para novas tentativas, em vez disso, retome a execução original com falha
+ Se você selecionar dois nós a serem reiniciados e eles dependerem um do outro, o nó a montante será executado antes do nó a jusante. Na verdade, selecionar o nó a montante é redundante, pois ele será executado de acordo com o fluxo normal do fluxo de trabalho.
# Obter e configurar as propriedades de execução de fluxo de trabalho no AWS Glue
Use as propriedades da execução de fluxo de trabalho para compartilhar e gerenciar o estado entre os trabalhos no seu fluxo de trabalho do AWS Glue. Você pode definir as propriedades padrão da execução quando criar o fluxo de trabalho. Depois, enquanto os trabalhos são executados, eles podem recuperar os valores de propriedade da execução e, opcionalmente, modificá-los para a entrada de trabalhos que estarão no fluxo de trabalho mais tarde. Quando um trabalho modifica uma propriedade da execução, o novo valor existe somente para a execução do fluxo de trabalho. As propriedades de execução padrão não são afetadas.
Se sua tarefa do AWS Glue não fizer parte de um fluxo de trabalho, essas propriedades não serão definidas.
O seguinte exemplo de código Python de um trabalho de extração, transformação e carregamento (ETL) demonstra como obter as propriedades da execução do fluxo de trabalho.
```
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']
```
O código a seguir continua definindo a propriedade da execução `target_format` como `'csv'`.
```
workflow_params['target_format'] = 'csv'
glue_client.put_workflow_run_properties(Name=workflow_name, RunId=workflow_run_id, RunProperties=workflow_params)
```
Para saber mais, consulte:
+ [Ação GetWorkflowRunProperties (Python: get\$1workflow\$1run\$1properties)](aws-glue-api-workflow.md#aws-glue-api-workflow-GetWorkflowRunProperties)
+ [Ação PutWorkflowRunProperties (Python: put\$1workflow\$1run\$1properties)](aws-glue-api-workflow.md#aws-glue-api-workflow-PutWorkflowRunProperties)
# Consultar fluxos de trabalho usando o AWS Glue API
AWS GlueO fornece uma API avançada para gerenciar fluxos de trabalho. É possível recuperar uma visualização estática do fluxo de trabalho ou uma visualização dinâmica de um fluxo de trabalho em execução usando o AWS Glue API. Para obter mais informações, consulte [Fluxos de trabalho](aws-glue-api-workflow.md).
**Topics**
+ [Consultar visualizações estáticas](#workflows_api_concepts_static)
+ [Consultar visualizações dinâmicas](#workflows_api_concepts_dynamic)
## Consultar visualizações estáticas
Use a operação de API `GetWorkflow` para obter uma visualização estática que indica o design de um fluxo de trabalho. Essa operação retorna um gráfico direcionado que consiste em nós e bordas, onde um nó representa um gatilho, uma tarefa ou um crawler. As bordas definem as relações entre os nós. Eles são representados por conectores (setas) no gráfico no console do AWS Glue.
Também é possível usar essa operação com bibliotecas populares de processamento de gráficos, como NetworkX, igraph, JGraphT e a Java Universal Network/Graph (JUNG) Framework. Como todas essas bibliotecas representam gráficos de forma semelhante, são necessárias transformações mínimas.
A visualização estática retornada por essa API é a visualização mais atualizada de acordo com a definição mais recente de gatilhos associados ao fluxo de trabalho.
### Definição do grafo
Um gráfico do fluxo de trabalho G é um par ordenado (N, E), onde N é um conjunto de nós e E, um conjunto de bordas. O *nó* é um vértice no gráfico identificado por um número exclusivo. Um nó pode ser do tipo acionador, de trabalho ou crawler. Por exemplo: `{name:T1, type:Trigger, uniqueId:1}, {name:J1, type:Job, uniqueId:2}`.
A *borda* é uma tupla de pares do formulário (`src, dest`), onde `src` e `dest` são nós e há uma borda direcionada de `src` para `dest`.
### Exemplo de como consultar uma visualização estática
Considere um gatilho condicional T, que aciona a tarefa J2 após a conclusão da tarefa J1.
```
J1 ---> T ---> J2
```
Nós: J1, T, J2
Bordas: (J1, T), (T, J2)
## Consultar visualizações dinâmicas
Use a operação de API `GetWorkflowRun` para obter uma visualização dinâmica de um fluxo de trabalho em execução. Essa operação retorna a mesma visualização estática do gráfico com os metadados relacionados à execução do fluxo de trabalho.
Para a execução, nós que representam trabalhos na chamada `GetWorkflowRun` têm uma lista de execuções de trabalhos iniciadas como parte da última execução do fluxo de trabalho. É possível usar essa lista para exibir o status de execução de cada tarefa no próprio gráfico. Para dependências downstream que ainda não foram executadas, esse campo é definido como `null`. As informações no gráfico deixam você ciente do estado atual de qualquer fluxo de trabalho em determinado momento.
A visualização dinâmica retornada por essa API é baseada na visualização estática que estava presente quando a execução do fluxo de trabalho foi iniciada.
*Exemplo de nós de runtime:* `{name:T1, type: Trigger, uniqueId:1}`, `{name:J1, type:Job, uniqueId:2, jobDetails:{jobRuns}}`, `{name:C1, type:Crawler, uniqueId:3, crawlerDetails:{crawls}}`
### Exemplo 1: visualização dinâmica
O exemplo a seguir ilustra um fluxo de trabalho simples de dois gatilhos.
+ Nós: t1, j1, t2, j2
+ Bordas: (t1, j1), (j1, t2), (t2, j2)
A resposta `GetWorkflow` contém o seguinte.
```
{
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
}
}
```
A resposta `GetWorkflowRun` contém o seguinte.
```
{
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
}
}
```
### Exemplo 2: vários trabalhos com um acionador condicional
O exemplo a seguir mostra um fluxo de trabalho com várias tarefas e um gatilho 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)
```
# Restrições de esquema e fluxo de trabalho no AWS Glue
Veja a seguir as restrições de blueprint e fluxos de trabalho.
## Restrições de esquema
Tenha em mente as seguintes restrições de blueprint:
+ O blueprint deve ser registrado na mesma região da AWS em que reside o bucket do Amazon S3.
+ Para compartilhar blueprints entre contas da AWS, você deve conceder as permissões de leitura no arquivo ZIP do blueprint no Amazon S3. Os clientes que tiverem permissão de leitura em um arquivo ZIP de blueprint podem registrar o blueprint em suas contas da AWS e usá-lo.
+ O conjunto de parâmetros do blueprint é armazenado como um único objeto JSON. O comprimento máximo deste objeto é de 128 KB.
+ O tamanho máximo do arquivo ZIP do blueprint descompactado é de 5 MB. O tamanho máximo compactado é de 1 MB.
+ Limite o número total de trabalhos, crawlers e acionadores em um fluxo de trabalho a 100 ou menos. Se você incluir mais de 100, poderá receber erros ao tentar retomar ou interromper as execuções do fluxo de trabalho.
## Restrições do fluxo de trabalho
Tenha em mente as seguintes restrições do fluxo de trabalho: Alguns desses comentários são mais direcionados a um usuário que esteja criando fluxos de trabalho manualmente.
+ O tamanho máximo do lote para um acionador de evento do Amazon EventBridge é 100. O valor máximo da janela é 900 segundos (15 minutos).
+ Um gatilho pode ser associado a somente um fluxo de trabalho.
+ Somente um gatilho de início (sob demanda ou programação) é permitido.
+ Se um trabalho ou crawler em um fluxo de trabalho for iniciado por um gatilho que está fora do fluxo de trabalho, nenhum gatilho interno do fluxo de trabalho que depender da conclusão do trabalho ou do crawler (com êxito ou não) será acionado.
+ Da mesma forma, se um trabalho ou crawler em um fluxo de trabalho tiver acionadores que dependam da conclusão do trabalho ou do crawler (com êxito ou não), tanto dentro quanto fora do fluxo de trabalho, e se o trabalho ou o crawler for iniciado dentro de um fluxo de trabalho, somente os acionadores internos desse fluxo de trabalho serão acionados após a conclusão do trabalho ou do crawler.
# Solucionar erros de esquema no AWS Glue
Se você encontrar erros ao usar blueprints do AWS Glue, utilize as seguintes soluções para ajudar a encontrar a fonte dos problemas e corrigi-los.
**Topics**
+ [Erro: módulo PySpark ausente](#blueprint-workflow-error-1)
+ [Erro: arquivo de configuração do blueprint ausente](#blueprint-workflow-error-2)
+ [Erro: arquivo importado ausente](#blueprint-workflow-error-3)
+ [Error: not authorized to perform iamPassRole on resource (Erro: não autorizado a executar iamPassRole no recurso)](#blueprint-workflow-error-4)
+ [Erro: programação cron. inválida](#blueprint-workflow-error-5)
+ [Erro: já existe um acionador com o mesmo nome](#blueprint-workflow-error-6)
+ [Erro: workflow with name: foo already exists (o fluxo de trabalho com nome: foo já existe).](#blueprint-workflow-error-7)
+ [Erro: módulo não encontrado no caminho layoutGenerator especificado](#blueprint-workflow-error-8)
+ [Erro: erro de validação no campo Connections (Conexões)](#blueprint-workflow-error-9)
## Erro: módulo PySpark ausente
AWS GlueO retorna o erro “Unknown error executing layout generator function ModuleNotFoundError: No module named ‘pyspark’” (Erro desconhecido ao executar a função do gerador de layout ModuleNotFounderror: nenhum módulo chamado “pyspark”).
Ao descompactar o arquivo de blueprint, ele pode ser como um dos seguintes:
```
$ 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
```
No primeiro caso, todos os arquivos relacionados ao blueprint foram colocados em uma pasta chamada compactação e foi então convertido em um arquivo zip chamado *compaction.zip*.
No segundo caso, todos os arquivos necessários para o blueprint não foram incluídos em uma pasta e foram adicionados como arquivos raiz no arquivo zip *compaction.zip*.
Criar um arquivo em qualquer um dos formatos acima é permitido. No entanto, certifique-se de que `blueprint.cfg` tenha o caminho correto para o nome da função no script que gera o layout.
**Exemplos**
No caso 1: `blueprint.cfg` deve ter `layoutGenerator` como o seguinte:
```
layoutGenerator": "compaction.layout.generate_layout"
```
No caso 2: `blueprint.cfg` deve ter `layoutGenerator` como o seguinte:
```
layoutGenerator": "layout.generate_layout"
```
Se esse caminho não estiver incluído corretamente, você poderá ver um erro conforme indicado. Por exemplo, se tiver a estrutura de pastas conforme mencionado no caso 2 e tiver `layoutGenerator` indicado como no caso 1, você poderá ver o erro acima.
## Erro: arquivo de configuração do blueprint ausente
AWS GlueO retorna o erro “Unknown error executing layout generator function FileNotFoundError: [Errno 2] No such file or directory: ‘/tmp/compaction/blueprint.cfg’” (Erro desconhecido executando a função do gerador de layout FileNotFoundError: [Errno 2] Nenhum arquivo ou diretório: “/tmp/compaction/blueprint.cfg”).
O blueprint.cfg deve ser colocado no nível raiz do arquivo ZIP ou dentro de uma pasta que tenha o mesmo nome que o arquivo ZIP.
Quando extraímos o arquivo ZIP do blueprint, blueprint.cfg deve ser encontrado em um dos seguintes caminhos. Se não for encontrado em um dos seguintes caminhos, você poderá ver o erro acima.
```
$ unzip compaction.zip
Archive: compaction.zip
creating: compaction/
inflating: compaction/blueprint.cfg
$ unzip compaction.zip
Archive: compaction.zip
inflating: blueprint.cfg
```
## Erro: arquivo importado ausente
AWS GlueO retorna o erro “Unknown error executing layout generator function FileNotFoundError: [Errno 2] No such file or directory: ‘demo-project/foo.py’” (Erro desconhecido executando a função do gerador de layout FileNotFoundError: [Errno 2] Nenhum arquivo ou diretório: “demo-project/foo.py”).
Se o script de geração de layout tiver funcionalidade para ler outros arquivos, certifique-se de fornecer um caminho completo para que o arquivo seja importado. Por exemplo, o script Conversion.py pode ser referenciado em Layout.py. Para obter mais informações, consulte [Projeto de esquema de exemplo](https://docs.aws.amazon.com/glue/latest/dg/developing-blueprints-sample.html).
## Error: not authorized to perform iamPassRole on resource (Erro: não autorizado a executar iamPassRole no recurso)
AWS GlueO retorna o erro “User: arn:aws:sts:: 123456789012:Assumed-Role/AWSGlueservicerole/Gluesession is not authorized to perform: iam:PassRole on resource: arn:aws:iam:: 123456789012:Role/AWSGlueservicerole” (Usuário: arn:aws:sts:: 123456789012:Assumed-Role/AWSGlueservicerole/Gluesession não está autorizado a realizar: iam:PassRole no recurso: arn:aws:iam:: 123456789012:Role/AWSGlueservicerole)
Se os trabalhos e os crawlers no fluxo de trabalho assumirem a mesma função que aquela passada para criar o fluxo de trabalho do blueprint, a função do blueprint precisará incluir a permissão `iam:PassRole` em si mesma.
Se os trabalhos e os crawlers no fluxo de trabalho assumirem uma função diferente da função passada para criar as entidades do fluxo de trabalho do blueprint, a função do blueprint precisará incluir a propriedade `iam:PassRole` nessa outra função em vez de na função do blueprint.
Para obter mais informações, consulte [Permissões para perfis de esquema](https://docs.aws.amazon.com/glue/latest/dg/blueprints-personas-permissions.html#blueprints-role-permissions).
## Erro: programação cron. inválida
AWS GlueO retorna o erro “The schedule cron(0 0 \$1 \$1 \$1 \$1) is invalid” (A programação cron(0 0 \$1 \$1 \$1 \$1) é inválida).
Forneça uma expressão [cron.](https://en.wikipedia.org/wiki/Cron) válida. Para obter mais informações, consulte [Programações baseadas em hora para tarefas e crawlers](https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html).
## Erro: já existe um acionador com o mesmo nome
AWS GlueO retorna o erro “Trigger with name 'foo\$1starting\$1trigger' already submitted with different configuration” (Acionador com o nome ‘foo\$1starting\$1trigger’ já enviado com configuração diferente).
Um blueprint não exige que você defina acionadores no script de layout para a criação do fluxo de trabalho. A criação do acionador é gerenciada pela biblioteca do blueprint com base nas dependências definidas entre duas ações.
A nomeação para os acionadores é a seguinte:
+ Para o acionador inicial no fluxo de trabalho, a nomeação é \$1starting\$1trigger.
+ Para um nó (trabalho/crawler) no fluxo de trabalho que depende da conclusão de um ou vários nós upstream, o AWS Glue define um acionador com o nome \$1\$1trigger
Este erro significa que já existe um acionador com o mesmo nome. Você pode excluir o acionador existente e executar novamente a criação do fluxo de trabalho.
**nota**
Excluir um fluxo de trabalho não exclui os nós dentro do fluxo de trabalho. É possível que, embora o fluxo de trabalho seja excluído, os acionadores sejam deixados para trás. Devido a isso, você pode não receber um erro “workflow already exists” (o fluxo de trabalho já existe), mas você pode receber um erro “trigger already exists” (o acionador já existe) em um caso em que você cria um fluxo de trabalho, exclui e, em seguida, tenta recriá-lo com o mesmo nome do mesmo blueprint.
## Erro: workflow with name: foo already exists (o fluxo de trabalho com nome: foo já existe).
O nome do fluxo de trabalho deve ser exclusivo. Tente com outro nome.
## Erro: módulo não encontrado no caminho layoutGenerator especificado
AWS GlueO retorna o erro “Unknown error executing layout generator function ModuleNotFoundError: No module named ‘crawl\$1s3\$1locations’” (Erro desconhecido ao executar a função do gerador de layout ModuleNotFounderror: nenhum módulo chamado “crawl\$1s3\$1locations”).
```
layoutGenerator": "crawl_s3_locations.layout.generate_layout"
```
Por exemplo, se você tiver o caminho layoutGenerator acima, quando descompactar o arquivo de blueprint, ele precisará se parecer com o seguinte:
```
$ 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
```
Ao descompactar o arquivo, se o arquivo de blueprint se parecer com o seguinte, então você poderá obter o erro acima.
```
$ unzip crawl_s3_locations.zip
Archive: crawl_s3_locations.zip
inflating: blueprint.cfg
inflating: layout.py
inflating: README.md
```
Você pode ver que não há nenhuma pasta chamada `crawl_s3_locations` e, quando o caminho `layoutGenerator` refere-se ao arquivo de layout por meio do módulo `crawl_s3_locations`, você pode obter o erro acima.
## Erro: erro de validação no campo Connections (Conexões)
AWS GlueO retorna o erro “Unknown error executing layout generator function TypeError: Value ['foo'] for key Connections should be of type \$1” (Erro desconhecido ao executar a função do gerador de layout TypeError: Valor ['foo'] para chave Conexões deve ser do tipo \$1).
Este é um erro de validação. O campo `Connections` na classe `Job` está esperando um dicionário e, em vez disso, uma lista de valores é fornecida, causando o erro.
```
User input was list of values
Connections= ['string']
Should be a dict like the following
Connections*=*{'Connections': ['string']}
```
Para evitar esses erros de runtime ao criar um fluxo de trabalho de um esquema, você pode validar as definições de fluxo de trabalho, trabalho e crawler, conforme descrito em [Testar um esquema](https://docs.aws.amazon.com/glue/latest/dg/developing-blueprints-testing.html).
Consulte a sintaxe na [Referência de classes de esquema do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/developing-blueprints-code-classes.html) para definir o trabalho, crawler e fluxo de trabalho do AWS Glue no script de layout.
# Permissões para pessoas e funções de esquemas do AWS Glue
A seguir estão as pessoas típicas e as políticas de permissões do AWS Identity and Access Management (IAM) sugeridas para pessoas e funções para os esquemas do AWS Glue.
**Topics**
+ [Pessoas de esquemas](#blueprints-personas)
+ [Permissões para pessoas de esquemas](#blueprints-permssions)
+ [Permissões para perfis de esquema](#blueprints-role-permissions)
## Pessoas de esquemas
A seguir estão as pessoas normalmente envolvidas no ciclo de vida dos esquemas do AWS Glue.
| Pessoa | Descrição |
| --- | --- |
| AWS GlueDesenvolvedor do | Desenvolve, testa e publica blueprints. |
| AWS GlueAdministrador da | Regista, mantém e concede permissões em blueprints. |
| Analista de dados | Executa blueprints para criar fluxos de trabalho. |
Para obter mais informações, consulte [Visão geral dos esquemas no AWS Glue](blueprints-overview.md).
## Permissões para pessoas de esquemas
A seguir estão as permissões sugeridas para cada pessoa do blueprint.
### Permissões de desenvolvedor do AWS Glue para esquemas
O desenvolvedor do AWS Glue deve ter permissões de gravação no bucket do Amazon S3 usado para publicar o esquema. Muitas vezes, o desenvolvedor registra o blueprint depois de carregá-lo. Nesse caso, o desenvolvedor precisa das permissões listadas em [Permissões de administrador do AWS Glue para esquemas](#bp-persona-admin). Além disso, se o desenvolvedor desejar testar o blueprint após seu registro, ele ou ela também precisará das permissões listadas em [Permissões de analista de dados para esquemas](#bp-persona-analyst).
### Permissões de administrador do AWS Glue para esquemas
A política a seguir concede permissões para registrar, visualizar e manter esquemas do AWS Glue.
**Importante**
Na política a seguir, substitua ** e ** com o caminho do Amazon S3 dos arquivos ZIP de blueprint carregados a serem registrados.
------
#### [ 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/*"
}
]
}
```
------
### Permissões de analista de dados para esquemas
A política a seguir concede permissões para executar blueprints e exibir o fluxo de trabalho resultante e seus componentes. Ela também concede `PassRole` para a função que o AWS Glue assume para criar o fluxo de trabalho resultante e seus componentes.
A política concede permissões em qualquer recurso. Se você deseja configurar o acesso minucioso a blueprints individuais, use o seguinte formato para ARNs de blueprint:
```
arn:aws:glue:::blueprint/
```
**Importante**
Na política a seguir, substitua ** por uma conta da AWS válida e substitua ** pelo nome da função usada para executar um blueprint. Consulte [Permissões para perfis de esquema](#blueprints-role-permissions) para obter as permissões que essa função requer.
------
#### [ 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"
}
]
}
```
------
## Permissões para perfis de esquema
A seguir estão as permissões sugeridas para a função do IAM usada para criar um fluxo de trabalho a partir de um blueprint. A função deve ter uma relação de confiança com o `glue.amazonaws.com`.
**Importante**
Na política a seguir, substitua ** por uma conta da AWS válida e substitua ** pelo nome da função.
------
#### [ 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**
Se os trabalhos e crawlers no fluxo de trabalho assumirem uma função diferente dessa, tal política deverá incluir a permissão `iam:PassRole` nessa outra função, em vez de na função de blueprint.
# Desenvolver esquemas no AWS Glue
Sua organização pode ter um conjunto de casos de uso de ETL semelhantes que poderiam se beneficiar da capacidade de parametrizar um único fluxo de trabalho para lidar com todos eles. Para atender a essa necessidade, o AWS Glue permite que você defina *esquemas*, que você pode usar para gerar fluxos de trabalho. Um blueprint aceita parâmetros, de modo que, a partir de um único blueprint, um analista de dados possa criar fluxos de trabalho diferentes para lidar com casos de uso de ETL semelhantes. Depois de criar um blueprint, é possível reutilizá-lo em departamentos, equipes e projetos diferentes.
**Topics**
+ [Visão geral dos esquemas no AWS Glue](blueprints-overview.md)
+ [Desenvolver esquemas no AWS Glue](developing-blueprints.md)
+ [Registrar um esquema no AWS Glue](registering-blueprints.md)
+ [Visualizar esquemas no AWS Glue](viewing_blueprints.md)
+ [Atualizar um esquema no AWS Glue](updating_blueprints.md)
+ [Criar um fluxo de trabalho com base em um esquema no AWS Glue](creating_workflow_blueprint.md)
+ [Visualizar execuções de esquemas no AWS Glue](viewing_blueprint_runs.md)
# Visão geral dos esquemas no AWS Glue
**nota**
No momento, o recurso de esquemas não está disponível no console do AWS Glue nas seguintes regiões: Ásia-Pacífico (Jacarta) e Oriente Médio (EAU).
Os esquemas do AWS Glue fornecem uma maneira de criar e compartilhar fluxos de trabalho do AWS Glue. Quando há um processo de ETL complexo que poderia ser usado para casos de uso semelhantes, em vez de criar um fluxo de trabalho do AWS Glue para cada caso de uso, você pode criar um único esquema.
O blueprint especifica os trabalhos e crawlers a serem incluídos em um fluxo de trabalho e especifica os parâmetros que o usuário do fluxo fornece ao executar o blueprint para criar um fluxo de trabalho. O uso de parâmetros permite que um único blueprint gere fluxos de trabalho para os vários casos de uso semelhantes. Para obter mais informações sobre fluxos de trabalho, consulte [Visão geral de fluxos de trabalho no AWS Glue](workflows_overview.md).
Veja a seguir exemplos de casos de uso de blueprints:
+ Você deseja particionar um conjunto de dados existente. Os parâmetros de entrada para o blueprint são caminhos de fonte e de destino do Amazon Simple Storage Service (Amazon S3) e uma lista de colunas de partição.
+ Você deseja fazer um snapshot de uma tabela do Amazon DynamoDB em um armazenamento de dados SQL, como o Amazon RedShift. Os parâmetros de entrada para o esquema são o nome da tabela do DynamoDB e uma conexão do AWS Glue, que designa um cluster do Amazon RedShift e um banco de dados de destino.
+ Você deseja converter dados em CSV em vários caminhos do Amazon S3 para Parquet. Você deseja que o fluxo de trabalho do AWS Glue inclua um crawler e um trabalho separados para cada caminho. Os parâmetros de entrada são o banco de dados de destino no catálogo de dados do AWS Glue e uma lista delimitada por vírgulas de caminhos do Amazon S3. Observe que nesse caso, o número de crawlers e trabalhos criados pelo fluxo de trabalho é variável.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/s3Bm8ay53Ms)
**Componentes do esquema**
Um blueprint é um arquivo ZIP que contém os seguintes componentes:
+ Um script gerador de layout Python
Contém uma função que especifica o *layout* do fluxo de trabalho. Os crawlers e trabalhos a serem criados para o fluxo de trabalho, as propriedades do trabalho e do crawler e as dependências entre eles. A função aceita parâmetros de esquema e retorna uma estrutura de fluxo de trabalho (objeto JSON) que o AWS Glue usa para gerar o fluxo de trabalho. Como você usa um script Python para gerar o fluxo de trabalho, pode adicionar sua própria lógica adequada a seus casos de uso.
+ Um arquivo de configuração
Especifica o nome totalmente qualificado da função Python que gera o layout do fluxo de trabalho. Especifica também os nomes, tipos de dados e outras propriedades de todos os parâmetros do blueprint usados pelo script.
+ (Opcional) scripts de ETL e arquivos complementares
Como um caso de uso avançado, você pode parametrizar a localização dos scripts de ETL que seus trabalhos usam. Você pode incluir arquivos de script de trabalho no arquivo ZIP e especificar um parâmetro de blueprint para um local do Amazon S3 para o qual os scripts devem ser copiados. O script gerador de layout pode copiar os scripts de ETL para o local designado e especificá-lo como a propriedade de local do script do trabalho. Você também pode incluir quaisquer bibliotecas ou outros arquivos complementares, desde que seu script os manipule.
![\[A caixa rotulada Blueprint contém duas caixas menores: uma rotulada Python Script e outra rotulada Config File (Arquivo de configuração).\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/blueprint.png)
**Execuções de blueprint**
Quando você cria um fluxo de trabalho a partir de um esquema, o AWS Glue executa o esquema, que inicia um processo assíncrono para criar o fluxo de trabalho e os trabalhos, crawlers e acionadores que o fluxo de trabalho encapsula. O AWS Glue usa a execução do esquema para orquestrar a criação do fluxo de trabalho e seus componentes. Você visualizar o status do processo de criação exibindo o status de execução do blueprint. A execução do blueprint também armazena os valores que você forneceu para os parâmetros do blueprint.
![\[A caixa rotulada Blueprint run (Execução do blueprint) contém ícones rotulados como Workflow (Fluxo de trabalho) e Parameter Values (Valores de parâmetro).\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/blueprint-run.png)
Você pode exibir execuções de esquemas usando o console do AWS Glue ou a AWS Command Line Interface (AWS CLI). Ao exibir ou solucionar problemas de um fluxo de trabalho, você sempre pode retornar à execução do blueprint para exibir os valores de parâmetro do blueprint usados para criar o fluxo de trabalho.
**Ciclo de vida de um esquema**
Os esquemas são desenvolvidos, testados e registrados com o AWS Glue e executados para criar fluxos de trabalho. Normalmente, há três pessoas envolvidas no ciclo de vida do blueprint.
| Pessoa | Tarefas |
| --- | --- |
| Desenvolvedor do AWS Glue | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/blueprints-overview.html) |
| Administrador da AWS Glue | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/blueprints-overview.html) |
| Analista de dados | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/blueprints-overview.html) |
**Consulte também**
[Desenvolver esquemas no AWS Glue](developing-blueprints.md)
[Criar um fluxo de trabalho com base em um esquema no AWS Glue](creating_workflow_blueprint.md)
[Permissões para pessoas e funções de esquemas do AWS Glue](blueprints-personas-permissions.md)
# Desenvolver esquemas no AWS Glue
Como um desenvolvedor do AWS Glue, você pode criar e publicar esquemas que os analistas de dados podem usar para gerar fluxos de trabalho.
**Topics**
+ [Visão geral do desenvolvimento de esquemas](developing-blueprints-overview.md)
+ [Pré-requisitos para desenvolvimento de esquemas](developing-blueprints-prereq.md)
+ [Gravar o código do esquema](developing-blueprints-code.md)
+ [Projeto de esquema de exemplo](developing-blueprints-sample.md)
+ [Testar um esquema](developing-blueprints-testing.md)
+ [Publicar um esquema](developing-blueprints-publishing.md)
+ [Referência de classes de esquema do AWS Glue](developing-blueprints-code-classes.md)
+ [Esquemas de exemplo](developing-blueprints-samples.md)
**Consulte também**
[Visão geral dos esquemas no AWS Glue](blueprints-overview.md)
# Visão geral do desenvolvimento de esquemas
A primeira etapa em seu processo de desenvolvimento é identificar um caso de uso comum que se beneficiaria de um blueprint. Um caso de uso típico envolve um problema de ETL recorrente que você acredita que deve ser resolvido de forma geral. Em seguida, projete um blueprint que implante o caso de uso generalizado e defina os parâmetros de entrada do blueprint que juntos podem definir um caso de uso específico a partir do caso de uso generalizado.
Um blueprint consiste em um projeto que contém um arquivo de configuração de parâmetros do blueprint e um script que define o *layout* do fluxo de trabalho a ser gerado. O layout define os trabalhos e crawlers (ou *entidades* na terminologia do script de blueprint) a serem criados.
Você não especifica diretamente nenhum acionador no script de layout. Em vez disso, você escreve um código para especificar as dependências entre os trabalhos e os crawlers criados pelo script. O AWS Glue gera os acionadores com base em suas especificações de dependências. A saída do script de layout é um objeto de fluxo de trabalho que contém especificações para todas as entidades de fluxo de trabalho.
Você constrói seu objeto de fluxo de trabalho usando as seguintes bibliotecas de esquema do AWS Glue:
+ `awsglue.blueprint.base_resource`: uma biblioteca de recursos básicos usados pelas bibliotecas.
+ `awsglue.blueprint.workflow`: uma biblioteca para definir uma classe `Workflow`.
+ `awsglue.blueprint.job`: uma biblioteca para definir uma classe `Job`.
+ `awsglue.blueprint.crawler`: uma biblioteca para definir uma classe `Crawler`.
As únicas outras bibliotecas que são suportadas para geração de layout são aquelas que estão disponíveis para o shell do Python.
Antes de publicar seu blueprint, você pode usar métodos definidos nas bibliotecas de blueprint para testá-lo localmente.
Quando estiver tudo pronto para você disponibilizar o blueprint aos analistas de dados, você empacota o script, o arquivo de configuração de parâmetros e quaisquer arquivos complementares, como scripts e bibliotecas adicionais, em um único ativo implantável. Em seguida, carrega o ativo no Amazon S3 e pede a um administrador para registrá-lo no AWS Glue.
Para obter mais informações sobre amostras de projetos de blueprint, consulte [Projeto de esquema de exemplo](developing-blueprints-sample.md) e [Esquemas de exemplo](developing-blueprints-samples.md).
# Pré-requisitos para desenvolvimento de esquemas
Para desenvolver esquemas, você deve ter familiaridade com o uso do AWS Glue e com a criação de scripts para trabalhos de ETL do Apache Spark ou trabalhos de shell do Python. Além disso, é necessário concluir as seguintes tarefas de configuração.
+ Baixe quatro bibliotecas Python da AWS para usar em seus scripts de layout de blueprint.
+ Configure os AWS SDKs.
+ Configurar a AWS CLI.
## Baixar bibliotecas Python
Baixe as seguintes bibliotecas do GitHub e instale-as em seu projeto:
+ [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)
## Configurar o AWS Java SDK
Para o AWS Java SDK, você deve adicionar um arquivo `jar` que inclui a API para blueprints.
1. Se você ainda não fez isso, configure o AWS SDK for Java.
+ Para Java 1.x, siga as instruções em [Configurar o AWS SDK para Java](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html) no *Guia do desenvolvedor do AWS SDK para Java*.
+ Para Java 2.x, siga as instruções em [Configurar o AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html) no *Guia do desenvolvedor do AWS SDK for Java 2.x*.
1. Baixe o arquivo de cliente `jar` que tem acesso às APIs para blueprints.
+ 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. Adicione o cliente `jar` na frente do classpath Java para substituir o cliente do AWS Glue fornecido peloAWS Java SDK.
```
export CLASSPATH=:$CLASSPATH
```
1. (Opcional) teste o SDK com a seguinte aplicação Java. A aplicação deve exibir uma lista vazia.
Substitua `accessKey` e `secretKey` com suas credenciais e `us-east-1` com a sua região.
```
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));
}
}
```
## Configurar o AWS Python SDK
As seguintes etapas supõem que você tenha o Python versão 2.7 ou posterior, ou a versão 3.9 ou posterior, instalada no computador.
1. Baixe o seguinte arquivo wheel do boto3. Se solicitado a abrir ou salvar, salve o arquivo. s3://awsglue-custom-blueprints-preview-artifacts/aws-python-sdk-preview/boto3-1.17.31-py2.py3-none-any.whl
1. Baixe o seguinte arquivo wheel do botocore: s3://awsglue-custom-blueprints-preview-artifacts/aws-python-sdk-preview/botocore-1.20.31-py2.py3-none-any.whl
1. Verifique a versão do Python.
```
python --version
```
1. Dependendo da sua versão do Python, insira os seguintes comandos (para Linux):
+ Para Python 2.7 ou posterior.
```
python3 -m pip install --user virtualenv
source env/bin/activate
```
+ Para Python 3.9 ou posterior.
```
python3 -m venv python-sdk-test
source python-sdk-test/bin/activate
```
1. Instale o arquivo wheel do botocore.
```
python3 -m pip install /botocore-1.20.31-py2.py3-none-any.whl
```
1. Instale o arquivo wheel do boto3.
```
python3 -m pip install /boto3-1.17.31-py2.py3-none-any.whl
```
1. Configure suas credenciais e a região padrão nos arquivos `~/.aws/credentials` e `~/.aws/config`. Para obter mais informações, consulte [Configuração da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) no *Guia do usuário da AWS Command Line Interface*.
1. (Opcional) teste a configuração. Os comandos a seguir devem retornar uma lista vazia.
Substitua `us-east-1` pela sua região.
```
$ python
>>> import boto3
>>> glue = boto3.client('glue', 'us-east-1')
>>> glue.list_blueprints()
```
## Configurar a pré-visualização da AWS CLI
1. Se você ainda o fez, instale e/ou atualize a AWS Command Line Interface (AWS CLI) em seu computador. A maneira mais fácil de fazer isso é com o `pip`, o utilitário de instalação do Python:
```
pip install awscli --upgrade --user
```
Você pode encontrar instruções completas de instalação da AWS CLI aqui: [Instalar a AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html).
1. Baixe o arquivo wheel da AWS CLI em: s3://awsglue-custom-blueprints-preview-artifacts/awscli-preview-build/awscli-1.19.31-py2.py3-none-any.whl
1. Instale o arquivo wheel da AWS CLI.
```
python3 -m pip install awscli-1.19.31-py2.py3-none-any.whl
```
1. Execute o comando `aws configure`. Configure as credenciais da AWS (incluindo chave de acesso e chave secreta) e a região da AWS. Você pode encontrar informações sobre a configuração da AWS CLI aqui: [Configurar a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).
1. Teste a AWS CLI. O comando a seguir deve retornar uma lista vazia.
Substitua `us-east-1` pela sua região.
```
aws glue list-blueprints --region us-east-1
```
# Gravar o código do esquema
Cada projeto de blueprint criado deve conter, no mínimo, os seguintes arquivos:
+ Um script de layout Python que define o fluxo de trabalho. O script contém uma função que define as entidades (trabalhos e crawlers) em um fluxo de trabalho e as dependências entre elas.
+ Um arquivo de configuração, `blueprint.cfg`, que define:
+ O caminho completo da função de definição de layout de fluxo de trabalho.
+ Os parâmetros que o blueprint aceita.
**Topics**
+ [Criar o script de layout do esquema](developing-blueprints-code-layout.md)
+ [Criar o arquivo de configuração](developing-blueprints-code-config.md)
+ [Especificar parâmetros de esquema](developing-blueprints-code-parameters.md)
# Criar o script de layout do esquema
O script de layout do blueprint deve incluir uma função que gera as entidades em seu fluxo de trabalho. Você pode atribuir o nome que quiser a esta função. O AWS Glue usa o arquivo de configuração para determinar o nome totalmente qualificado da função.
Sua função de layout faz o seguinte:
+ (Opcional) instancia a classe `Job` para criar objetos `Job` e transmite argumentos, como `Command` e `Role`. Essas são as propriedades de trabalho que você especificaria se estivesse criando o trabalho usando o console ou a API do AWS Glue.
+ (Opcional) instancia a classe `Crawler` para criar objetos `Crawler` e transmite argumentos de nome, função e destino.
+ Para indicar dependências entre os objetos (entidades de fluxo de trabalho), transmite os argumentos adicionais `DependsOn` e `WaitForDependencies` para `Job()` e `Crawler()`. Esses argumentos são explicados posteriormente nesta seção.
+ Instancia a classe `Workflow` para criar o objeto de fluxo de trabalho que é retornado para o AWS Glue, transmitindo um argumento `Name`, um argumento `Entities` e um argumento opcional `OnSchedule`. O argumento `Entities` especifica todos os trabalhos e crawlers a serem incluídos no fluxo de trabalho. Para ver como construir um objeto `Entities`, consulte o projeto de exemplo mais adiante nesta seção.
+ Retorna um objeto `Workflow`.
Para obter definições das classes `Job`, `Crawler` e `Workflow`, consulte [Referência de classes de esquema do AWS Glue](developing-blueprints-code-classes.md).
A função de layout aceita os seguintes argumentos:
| Argumento | Descrição |
| --- | --- |
| user\$1params | Dicionário Python de nomes e valores de parâmetros do blueprint. Para obter mais informações, consulte [Especificar parâmetros de esquema](developing-blueprints-code-parameters.md). |
| system\$1params | Dicionário Python contendo duas propriedades: region e accountId. |
Aqui está um exemplo de script gerador de layout em um arquivo chamado `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
```
O script de exemplo importa as bibliotecas de blueprint necessárias e inclui uma função `generate_layout` que gera um fluxo de trabalho com dois trabalhos. Esse é um script muito simples. Um script mais complexo poderia empregar lógica e parâmetros adicionais para gerar um fluxo de trabalho com muitos trabalhos e crawlers, ou até mesmo um número variável de trabalhos e crawlers.
## Usar o argumento DependsOn
O argumento `DependsOn` é uma representação de dicionário de uma dependência que esta entidade tem em outras entidades dentro do fluxo de trabalho. Ele tem o seguinte formato:
```
DependsOn = {dependency1 : state, dependency2 : state, ...}
```
As chaves nesse dicionário representam a referência ao objeto, e não o nome da entidade, enquanto os valores são strings que correspondem ao estado a ser vigiado. O AWS Glue infere os acionadores adequados. Para obter os estados válidos, consulte [Estrutura de condição](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-trigger.html#aws-glue-api-jobs-trigger-Condition).
Por exemplo, um trabalho pode depender da conclusão bem-sucedida de um crawler. Se você definir um objeto de crawler chamado `crawler2` como segue:
```
crawler2 = Crawler(Name="my_crawler", ...)
```
Em seguida, um objeto dependendo de `crawler2` incluiria um argumento construtor, como:
```
DependsOn = {crawler2 : "SUCCEEDED"}
```
Por exemplo:
```
job1 = Job(Name="Job1", ..., DependsOn = {crawler2 : "SUCCEEDED", ...})
```
Se `DependsOn` for omitido para uma entidade, essa entidade dependerá do acionador de início do fluxo de trabalho.
## Usar o argumento WaitForDependencies
O argumento `WaitForDependencies` define se um trabalho ou entidade de crawler deve esperar até que *todas* as entidades das quais depende sejam concluídas ou até que *qualquer uma* seja concluída.
Os valores permitidos são “`AND`” ou “`ANY`”.
## Usar o argumento OnSchedule
O argumento `OnSchedule` para o construtor de classe `Workflow` é uma expressão `cron` que determina a definição do acionador inicial para um fluxo de trabalho.
Se esse argumento for especificado, o AWS Glue criará um acionador de programação com a programação correspondente. Se ele não for especificado, o acionador de início do fluxo de trabalho será um acionador sob demanda.
# Criar o arquivo de configuração
O arquivo de configuração do blueprint é um arquivo obrigatório que define o ponto de entrada do script para gerar o fluxo de trabalho e os parâmetros que o blueprint aceita. O deve ser nomeado `blueprint.cfg`.
Veja a seguir um arquivo de configuração de exemplo.
```
{
"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
}
}
}
```
A propriedade `layoutGenerator` especifica o nome totalmente qualificado da função no script que gera o layout.
A propriedade `parameterSpec` especifica os parâmetros que esse blueprint aceita. Para obter mais informações, consulte [Especificar parâmetros de esquema](developing-blueprints-code-parameters.md).
**Importante**
Seu arquivo de configuração deve incluir o nome do fluxo de trabalho como um parâmetro de blueprint ou você deve gerar um nome de fluxo de trabalho exclusivo no script de layout.
# Especificar parâmetros de esquema
O arquivo de configuração contém especificações de parâmetro do blueprint em um objeto JSON `parameterSpec`. `parameterSpec` contém um ou mais objetos de parâmetro.
```
"parameterSpec": {
"": {
"type": "",
"collection": true|false,
"description": "",
"defaultValue": ""
"allowedValues": ""
},
"": {
...
}
}
```
A seguir estão as regras para codificar cada objeto de parâmetro:
+ O nome e o `type` do parâmetro são obrigatórios. Todas as outras propriedades são opcionais.
+ Se você especificar a propriedade `defaultValue`, o parâmetro será opcional. Caso contrário, o parâmetro é obrigatório e o analista de dados que cria um fluxo de trabalho a partir do blueprint deve fornecer um valor para ele.
+ Se você definir a propriedade `collection` como `true`, o parâmetro poderá ter uma coleção de valores. Coleções podem ser de qualquer tipo de dados.
+ Se você especificar `allowedValues`, o console do AWS Glue exibirá uma lista suspensa de valores para o analista de dados escolher ao criar um fluxo de trabalho a partir do esquema.
Os seguintes valores são permitidos para o `type`:
| Tipos de dados de parâmetro | Observações |
| --- | --- |
| String | - |
| Integer | - |
| Double | - |
| Boolean | Os possíveis valores são true e false. Gera uma caixa de seleção na página Create a workflow from (Criar um fluxo de trabalho a partir de ) no console do AWS Glue. |
| S3Uri | Caminho completo do Amazon S3, começando com s3://. Gera um campo de texto e o botão Browse (Navegar) na página Create a workflow from (Criar um fluxo de trabalho a partir de ). |
| S3Bucket | Somente nome do bucket do Amazon S3. Gera um seletor de bucket na página Create a workflow from (Criar um fluxo de trabalho a partir de ). |
| IAMRoleArn | O nome do recurso da Amazon (ARN) da função do AWS Identity and Access Management (IAM). Gera um seletor de função na página Create a workflow from (Criar um fluxo de trabalho a partir de ). |
| IAMRoleName | Nome de uma função do IAM. Gera um seletor de função na página Create a workflow from (Criar um fluxo de trabalho a partir de ). |
# Projeto de esquema de exemplo
Uma conversão de formato de dados é um caso de uso frequente de extração, transformação e carregamento (ETL). Em workloads analíticas típicas, formatos de arquivo baseados em colunas, como Parquet ou ORC, são preferidos em relação a formatos de texto, como CSV ou JSON. Esse blueprint de exemplo permite converter dados de CSV/JSON/etc. em Parquet para arquivos no Amazon S3.
Esse blueprint obtém uma lista de caminhos do S3 definidos por um parâmetro de blueprint, converte os dados no formato Parquet e os grava no local do S3 especificado por outro parâmetro de blueprint. O script de layout cria um crawler e um trabalho para cada caminho. O script de layout também carrega o script de ETL no `Conversion.py` para um bucket do S3 especificado por outro parâmetro do blueprint. Em seguida, o script de layout especifica o script carregado como o script de ETL para cada trabalho. O arquivo ZIP do projeto contém o script de layout, o script de ETL e o arquivo de configuração do blueprint.
Para obter mais informações sobre exemplos de projetos de blueprint, consulte [Esquemas de exemplo](developing-blueprints-samples.md).
A seguir está o script de layout, no arquivo `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
```
A seguir está o arquivo de configuração do blueprint correspondente `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."
}
}
}
```
O script a seguir no arquivo `Conversion.py` é o script de ETL carregado. Observe que ele preserva o esquema de particionamento durante a conversão.
```
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**
Somente dois caminhos do Amazon S3 podem ser fornecidos como uma entrada para o blueprint de exemplo. Isso porque os acionadores do AWS Glue podem invocar apenas duas ações de crawler.
# Testar um esquema
Enquanto você desenvolve seu código, você deve executar testes locais para verificar se o layout do fluxo de trabalho está correto.
Testes locais não geram trabalhos, crawlers ou acionadores do AWS Glue. Em vez disso, execute o script de layout localmente e use os métodos `to_json()` e `validate()` para imprimir objetos e encontrar erros. Esses métodos estão disponíveis em todas as três classes definidas nas bibliotecas.
Há duas maneiras de lidar com os argumentos `user_params` e `system_params` que o AWS Glue transmite para sua função de layout. Seu código de banco de teste pode criar um dicionário de valores de parâmetro de blueprint de exemplo e transmiti-lo para a função de layout como o argumento `user_params`. Ou você pode remover as referências a `user_params` e substituí-las por strings em código fixo.
Se o seu código usar as propriedades `region` e `accountId` no argumento `system_params`, você pode transmitir seu próprio dicionário para `system_params`.
**Para testar um blueprint**
1. Inicie um interpretador Python em um diretório com as bibliotecas ou carregue os arquivos de blueprint e as bibliotecas fornecidas em seu ambiente de desenvolvimento integrado (IDE) preferido.
1. Certifique-se de que o código importe as bibliotecas fornecidas.
1. Adicione código à sua função de layout para chamar `validate()` ou `to_json()` em qualquer entidade ou no objeto `Workflow`. Por exemplo, se o seu código criar um objeto `Crawler` chamado `mycrawler`, é possível chamar `validate()` como a seguir.
```
mycrawler.validate()
```
Você pode imprimir `mycrawler` como a seguir:
```
print(mycrawler.to_json())
```
Se você chamar `to_json` em um objeto, não há necessidade de também chamar `validate()`, pois ` to_json()` chama `validate()`.
É mais útil chamar esses métodos no objeto de fluxo de trabalho. Supondo que seu script nomeie o objeto de fluxo de trabalho `my_workflow`, valide e imprima o objeto de fluxo de trabalho da seguinte forma:
```
print(my_workflow.to_json())
```
Para obter mais informações sobre `to_json()` e `validate()`, consulte [Classe Methods](developing-blueprints-code-classes.md#developing-blueprints-code-methods).
Você também pode importar `pprint` e formatar o estilo do objeto do fluxo de trabalho, conforme mostrado no exemplo mais adiante nesta seção.
1. Execute o código, corrija erros e, finalmente, remova quaisquer chamadas para `validate()` ou `to_json()`.
**Example**
O exemplo a seguir mostra como construir um dicionário de parâmetros de blueprint de exemplo e transmiti-lo como o argumento `user_params` para a função de layout `generate_compaction_workflow`. Ele também mostra como formatar o estilo do objeto de fluxo de trabalho gerado.
```
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)
```
# Publicar um esquema
Depois de desenvolver um blueprint, você deve carregá-lo no Amazon S3. Você deve ter permissões de gravação no bucket do Amazon S3 usado para publicar o blueprint. Você também deve se certificar de que o administrador do AWS Glue, que registrará o esquema, tenha acesso de leitura ao bucket do Amazon S3. Sobre políticas de permissões do AWS Identity and Access Management (IAM) sugeridas para pessoas e funções para esquemas do AWS Glue, consulte [Permissões para pessoas e funções de esquemas do AWS Glue](blueprints-personas-permissions.md).
**Para publicar um blueprint**
1. Crie os scripts, os recursos e o arquivo de configuração do blueprint necessários.
1. Adicione todos os arquivos a um arquivo ZIP e carregue-o no Amazon S3. Use um bucket do S3 que esteja na mesma região na qual os usuários se registrarão e executarão o blueprint.
Você pode criar um arquivo ZIP a partir da linha de comando usando o seguinte comando.
```
zip -r folder.zip folder
```
1. Adicione uma política de bucket que conceda permissões de leitura à conta da AWS desejada. Veja a seguir um exemplo de política.
------
#### [ 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 a permissão do IAM `s3:GetObject` no bucket do Amazon S3 para o administrador do AWS Glue ou para quem quer que esteja registrando esquemas. Para obter uma política de exemplo a conceder aos administradores, consulte [Permissões de administrador do AWS Glue para esquemas](blueprints-personas-permissions.md#bp-persona-admin).
Depois de concluir o teste local do seu esquema, você também pode querer testar um esquema no AWS Glue. Para testar um esquema no AWS Glue, ele deve ser registrado. Você pode limitar quem vê o blueprint registrado usando a autorização do IAM ou usando contas de teste separadas.
**Consulte também:**
[Registrar um esquema no AWS Glue](registering-blueprints.md)
# Referência de classes de esquema do AWS Glue
As bibliotecas para esquemas do AWS Glue definem três classes que você pode usar no script de layout do fluxo de trabalho: `Job`, `Crawler` e `Workflow`.
**Topics**
+ [Classe Job](#developing-blueprints-code-jobclass)
+ [Classe Crawler](#developing-blueprints-code-crawlerclass)
+ [Classe Workflow](#developing-blueprints-code-workflowclass)
+ [Classe Methods](#developing-blueprints-code-methods)
## Classe Job
A classe `Job` representa um trabalho de ETL do AWS Glue.
**Argumentos construtores obrigatórios**
Veja os argumentos construtores obrigatórios para a classe `Job`.
| Nome do argumento | Tipo | Descrição |
| --- | --- | --- |
| Name | str | O nome a ser atribuído ao trabalho. O AWS Glue adiciona um sufixo gerado aleatoriamente ao nome para distinguir o trabalho daqueles criados por outras execuções de esquema. |
| Role | str | O nome do recurso da Amazon (ARN) da função que o trabalho deve assumir ao executar. |
| Command | dict | Comando Job (Trabalho), conforme especificado em [Estrutura JobCommand](aws-glue-api-jobs-job.md#aws-glue-api-jobs-job-JobCommand) na documentação da API. |
**Argumentos construtores opcionais**
Veja os argumentos construtores opcionais para a classe `Job`.
| Nome do argumento | Tipo | Descrição |
| --- | --- | --- |
| DependsOn | dict | Lista de entidades de fluxo de trabalho das quais o trabalho depende. Para obter mais informações, consulte [Usar o argumento DependsOn](developing-blueprints-code-layout.md#developing-blueprints-code-layout-depends-on). |
| WaitForDependencies | str | Indica se o trabalho deve esperar até que todas as entidades das quais depende sejam concluídas antes de executar ou até que qualquer uma seja concluída. Para obter mais informações, consulte [Usar o argumento WaitForDependencies](developing-blueprints-code-layout.md#developing-blueprints-code-layout-wait-for-dependencies). Omita, se o trabalho depender de apenas uma entidade. |
| (Propriedades do trabalho) | - | Qualquer uma das propriedades do trabalho listadas em [Estrutura do trabalho](aws-glue-api-jobs-job.md#aws-glue-api-jobs-job-Job) na documentação da API do AWS Glue (exceto CreatedOn e LastModifiedOn). |
## Classe Crawler
A classe `Crawler` representa um crawler do AWS Glue.
**Argumentos construtores obrigatórios**
Veja os argumentos construtores obrigatórios para a classe `Crawler`.
| Nome do argumento | Tipo | Descrição |
| --- | --- | --- |
| Name | str | O nome a ser atribuído ao crawler. O AWS Glue adiciona um sufixo gerado aleatoriamente ao nome para distinguir o trabalho daqueles criados por outras execuções de esquema. |
| Role | str | ARN da função que o crawler deve assumir ao executar. |
| Targets | dict | Coleção de destinos a serem rastreados. Os argumentos construtores da classe Targets são definidos em [Estrutura CrawlerTargets](aws-glue-api-crawler-crawling.md#aws-glue-api-crawler-crawling-CrawlerTargets) na documentação da API. Todos os argumentos construtores de Targets são opcionais, mas você deve informar pelo menos um. |
**Argumentos construtores opcionais**
Veja os argumentos construtores opcionais para a classe `Crawler`.
| Nome do argumento | Tipo | Descrição |
| --- | --- | --- |
| DependsOn | dict | Lista de entidades de fluxo de trabalho das quais o crawler depende. Para obter mais informações, consulte [Usar o argumento DependsOn](developing-blueprints-code-layout.md#developing-blueprints-code-layout-depends-on). |
| WaitForDependencies | str | Indica se o crawler deve esperar até que todas as entidades das quais depende sejam concluídas antes de executar ou até que qualquer uma seja concluída. Para obter mais informações, consulte [Usar o argumento WaitForDependencies](developing-blueprints-code-layout.md#developing-blueprints-code-layout-wait-for-dependencies). Omita, se o crawler depender de apenas uma entidade. |
| (Propriedades do crawler) | - | Qualquer uma das propriedades do crawler listadas em [Estrutura Crawler](aws-glue-api-crawler-crawling.md#aws-glue-api-crawler-crawling-Crawler) na documentação da API do AWS Glue, com as seguintes exceções:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/developing-blueprints-code-classes.html) |
## Classe Workflow
A classe `Workflow` representa um fluxo de trabalho do AWS Glue. O script de layout de fluxo de trabalho retorna um objeto `Workflow`. AWS Glue cria um fluxo de trabalho com base nesse objeto.
**Argumentos construtores obrigatórios**
Veja os argumentos construtores obrigatórios para a classe `Workflow`.
| Nome do argumento | Tipo | Descrição |
| --- | --- | --- |
| Name | str | O nome a ser atribuído ao fluxo de trabalho. |
| Entities | Entities | Uma coleção de entidades (trabalhos e crawlers) a serem incluídas no fluxo de trabalho. O construtor da classe Entities aceita um argumento Jobs, que é uma lista de objetos Job, e um argumento Crawlers, que é uma lista de objetos Crawler. |
**Argumentos construtores opcionais**
Veja os argumentos construtores opcionais para a classe `Workflow`.
| Nome do argumento | Tipo | Descrição |
| --- | --- | --- |
| Description | str | Consulte [Estrutura Workflow](aws-glue-api-workflow.md#aws-glue-api-workflow-Workflow). |
| DefaultRunProperties | dict | Consulte [Estrutura Workflow](aws-glue-api-workflow.md#aws-glue-api-workflow-Workflow). |
| OnSchedule | str | Uma expressão cron. |
## Classe Methods
Todas as três classes incluem os seguintes métodos.
**validate()**
Valida as propriedades do objeto e, se forem encontrados erros, emite uma mensagem e sai. Não gera saída se não houver erros. Para a classe `Workflow`, chama a si mesma em cada entidade no fluxo de trabalho.
**to\$1json()**
Serializa o objeto em JSON. Também chama `validate()`. Para a classe `Workflow`, o objeto JSON inclui listas de trabalhos e crawlers e uma lista de acionadores gerados pelas especificações de dependência de trabalho e de crawler.
# Esquemas de exemplo
Diversos projetos de esquema de exemplo estão disponíveis no [repositório do Github de esquemas do AWS Glue](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/samples). Tais amostras são apenas para referência e não se destinam à produção.
Os títulos dos projetos de exemplo são:
+ Compaction (Compactação): esse blueprint cria um trabalho que compacta arquivos de entrada em blocos maiores com base no tamanho de arquivo desejado.
+ Conversion (Conversão): esse blueprint converte arquivos de entrada em vários formatos de arquivo padrão no formato Apache Parquet, que é otimizado para workloads analíticas.
+ Crawling Amazon S3 locations (Crawling de locais do Amazon S3): esse blueprint rastreia vários locais do Amazon S3 para adicionar tabelas de metadados ao Data Catalog.
+ Custom connection to Data Catalog (Conexão personalizada com o Data Catalog): esse esquema acessa os armazenamentos de dados usando conectores personalizados do AWS Glue, lê os registros e preenche as definições no AWS Glue Data Catalog no esquema de registro.
+ Encoding (Codificação): esse blueprint converte seus arquivos não UTF em arquivos codificados em UTF.
+ Partitioning (Particionamento): esse blueprint cria um trabalho de particionamento que coloca os arquivos de saída em partições com base em chaves de partição específicas.
+ Importing Amazon S3 data into a DynamoDB table (Importação de dados do Amazon S3 em uma tabela do DynamoDB): esse blueprint importa dados do Amazon S3 para uma tabela do DynamoDB.
+ Standard table to governed (Tabela padrão a ser controlada): esse esquema importa uma tabela do AWSGlue Data Catalog para uma tabela do Lake Formation.
# Registrar um esquema no AWS Glue
Após o desenvolvedor do AWS Glue codificar o esquema e carregar um arquivo ZIP no Amazon Simple Storage Service (Amazon S3), um administrador do AWS Glue deve registrar o esquema. Registrar o blueprint o torna disponível para uso.
Quando você registra um esquema, o AWS Glue copia o arquivo de esquema para um local reservado do Amazon S3. Em seguida, você pode excluir o arquivo do local de onde foi carregado.
Para registrar um blueprint, você precisa de permissões de leitura no local do Amazon S3 que contém o arquivo carregado. Você também precisa da permissão do AWS Identity and Access Management (IAM) `glue:CreateBlueprint`. Para obter as permissões sugeridas para um administrador do AWS Glue que deve registrar, visualizar e manter esquemas, consulte [Permissões de administrador do AWS Glue para esquemas](blueprints-personas-permissions.md#bp-persona-admin).
Você pode registrar um esquema usando o console do AWS Glue, a API do AWS Glue ou a AWS Command Line Interface (AWS CLI).
**Para registrar um blueprint (console)**
1. Verifique se você tem permissões de leitura (`s3:GetObject`) no arquivo ZIP de blueprint no Amazon S3.
1. Abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Faça login como um usuário que tem permissões para registrar um blueprint. Mude para a mesma região da AWS do bucket do Amazon S3 que contém o arquivo ZIP de esquema.
1. No painel de navegação, escolha **Blueprints** (Esquemas). Em seguida, na página **Blueprints** (Esquemas), escolha **Add blueprint** (Adicionar esquema).
1. Insira um nome de blueprint e uma descrição opcional.
1. Para o **local do arquivo ZIP (S3)**, insira o caminho do Amazon S3 do arquivo ZIP de blueprint carregado. Inclua o nome do arquivo no caminho e o inicie com `s3://`.
1. (Opcional) adicione uma ou mais tags.
1. Escolha **Add blueprint** (Adicionar blueprint).
A página **Blueprints** (Esquemas) retorna e mostra que o status do esquema é `CREATING`. Escolha o botão de atualização até que o status mude para `ACTIVE` ou `FAILED`.
1. Se o status for `FAILED`, selecione o blueprint e, no menu **Actions** (Ações), escolha **View** (Exibir).
A página de detalhes mostra o motivo da falha. Se a mensagem do erro for “Unable to access object at location…” (Não foi possível acessar o objeto no local…) ou “Access denied on object at location…” (Acesso negado no objeto no local…), analise os seguintes requisitos:
+ O usuário ao qual você está conectado deve ter permissão de leitura no arquivo ZIP de blueprint no Amazon S3.
+ O bucket do Amazon S3 que contém o arquivo ZIP deve ter uma política de bucket que conceda permissão de leitura no objeto ao seu ID da conta da AWS. Para obter mais informações, consulte [Desenvolver esquemas no AWS Glue](developing-blueprints.md).
+ O bucket do Amazon S3 que você está usando deve estar na mesma região em que você se conectou no console.
1. Certifique-se de que os analistas de dados tenham permissões no blueprint.
A política do IAM sugerida para analistas de dados é mostrada em [Permissões de analista de dados para esquemas](blueprints-personas-permissions.md#bp-persona-analyst). Essa política concede `glue:GetBlueprint` em qualquer recurso. Se sua política for mais minuciosa no nível do recurso, conceda permissões aos analistas de dados nesse recurso recém-criado.
**Para registrar um blueprint (AWS CLI)**
1. Insira o comando da a seguir.
```
aws glue create-blueprint --name [--description ] --blueprint-location s3:///
```
1. Para verificar o status do blueprint, insira o comando a seguir. Repita o comando até que o status vá para `ACTIVE` ou `FAILED`.
```
aws glue get-blueprint --name
```
Se o status for `FAILED` e a mensagem de erro for “Unable to access object at location…” (Não foi possível acessar o objeto no local…) ou “Access denied on object at location…” (Acesso negado no objeto no local…), analise os seguintes requisitos:
+ O usuário ao qual você está conectado deve ter permissão de leitura no arquivo ZIP de blueprint no Amazon S3.
+ O bucket do Amazon S3 que contém o arquivo ZIP deve ter uma política de bucket que conceda permissão de leitura no objeto ao seu ID da conta da AWS. Para obter mais informações, consulte [Publicar um esquema](developing-blueprints-publishing.md).
+ O bucket do Amazon S3 que você está usando deve estar na mesma região em que você se conectou no console.
**Consulte também:**
[Visão geral dos esquemas no AWS Glue](blueprints-overview.md)
# Visualizar esquemas no AWS Glue
Exiba um blueprint para revisar a descrição, o status e as especificações de parâmetros dele, e fazer o download do arquivo ZIP de esquema.
Você pode visualizar uma execução de esquema usando o console do AWS Glue, a API do AWS Glue ou a AWS Command Line Interface (AWS CLI).
**Para exibir um blueprint (console)**
1. Abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. No painel de navegação, escolha **Blueprints** (Esquemas).
1. Na página **Blueprints** (Esquemas), selecione um esquema. Em seguida, no menu **Actions** (Ações), escolha **View** (Exibir).
**Para exibir um blueprint (AWS CLI)**
+ Insira o comando a seguir para exibir apenas o nome, a descrição e o status do blueprint. Substitua ** pelo nome do blueprint a ser exibido.
```
aws glue get-blueprint --name
```
A saída do comando é semelhante à seguinte.
```
{
"Blueprint": {
"Name": "myDemoBP",
"CreatedOn": 1587414516.92,
"LastModifiedOn": 1587428838.671,
"BlueprintLocation": "s3://amzn-s3-demo-bucket1/demo/DemoBlueprintProject.zip",
"Status": "ACTIVE"
}
}
```
Insira o seguinte comando para visualizar também as especificações de parâmetros.
```
aws glue get-blueprint --name --include-parameter-spec
```
A saída do comando é semelhante à seguinte.
```
{
"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"
}
}
```
Adicione o argumento `--include-blueprint` para incluir um URL na saída que você pode colar em seu navegador para baixar o arquivo ZIP de esquema que o AWS Glue armazenou.
**Consulte também:**
[Visão geral dos esquemas no AWS Glue](blueprints-overview.md)
# Atualizar um esquema no AWS Glue
Você pode atualizar um blueprint se tiver um script de layout revisado, um conjunto revisado de parâmetros do blueprint ou arquivos de suporte revisados. Atualizar um blueprint cria uma nova versão.
A atualização de um blueprint não afeta os fluxos de trabalho existentes criados dele.
Você pode atualizar um esquema usando o console do AWS Glue, a API do AWS Glue ou a AWS Command Line Interface (AWS CLI).
O procedimento a seguir pressupõe que o desenvolvedor do AWS Glue criou e carregou um arquivo ZIP de esquema atualizado no Amazon S3.
**Para atualizar um blueprint (console)**
1. Verifique se você tem permissões de leitura (`s3:GetObject`) no arquivo ZIP de blueprint no Amazon S3.
1. Abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Faça login como um usuário que tem permissões para atualizar um blueprint. Mude para a mesma região da AWS do bucket do Amazon S3 que contém o arquivo ZIP de blueprint.
1. No painel de navegação, escolha **Blueprints** (Esquemas).
1. Na página **Blueprints** (Esquemas), selecione um esquema e, no menu **Actions** (Ações), escolha **Edit** (Editar).
1. Na página **Edit a blueprint** (Editar um blueprint), atualize **Description** (Descrição) ou **ZIP archive location (S3)** (Localização do arquivo ZIP [S3]) do blueprint. Certifique-se de incluir o nome do arquivo no caminho.
1. Escolha **Salvar**.
A página **Blueprints** (Esquemas) retorna e mostra que o status do esquema é `UPDATING`. Escolha o botão de atualização até que o status mude para `ACTIVE` ou `FAILED`.
1. Se o status for `FAILED`, selecione o blueprint e, no menu **Actions** (Ações), escolha **View** (Exibir).
A página de detalhes mostra o motivo da falha. Se a mensagem do erro for “Unable to access object at location…” (Não foi possível acessar o objeto no local…) ou “Access denied on object at location…” (Acesso negado no objeto no local…), analise os seguintes requisitos:
+ O usuário ao qual você está conectado deve ter permissão de leitura no arquivo ZIP de blueprint no Amazon S3.
+ O bucket do Amazon S3 que contém o arquivo ZIP deve ter uma política de bucket que conceda permissão de leitura no objeto ao seu ID da conta da AWS. Para obter mais informações, consulte [Publicar um esquema](developing-blueprints-publishing.md).
+ O bucket do Amazon S3 que você está usando deve estar na mesma região em que você se conectou no console.
**nota**
Se a atualização falhar, a próxima execução do blueprint usará a versão mais recente dele que tenha sido registrada ou atualizada com êxito.
**Para atualizar um blueprint (AWS CLI)**
1. Insira o comando da a seguir.
```
aws glue update-blueprint --name [--description ] --blueprint-location s3:///
```
1. Para verificar o status do blueprint, insira o comando a seguir. Repita o comando até que o status vá para `ACTIVE` ou `FAILED`.
```
aws glue get-blueprint --name
```
Se o status for `FAILED` e a mensagem de erro for “Unable to access object at location…” (Não foi possível acessar o objeto no local…) ou “Access denied on object at location…” (Acesso negado no objeto no local…), analise os seguintes requisitos:
+ O usuário ao qual você está conectado deve ter permissão de leitura no arquivo ZIP de blueprint no Amazon S3.
+ O bucket do Amazon S3 que contém o arquivo ZIP deve ter uma política de bucket que conceda permissão de leitura no objeto ao seu ID da conta da AWS. Para obter mais informações, consulte [Publicar um esquema](developing-blueprints-publishing.md).
+ O bucket do Amazon S3 que você está usando deve estar na mesma região em que você se conectou no console.
**Consulte também**
[Visão geral dos esquemas no AWS Glue](blueprints-overview.md)
# Criar um fluxo de trabalho com base em um esquema no AWS Glue
É possível criar um fluxo de trabalho do AWS Glue manualmente, adicionando um componente de cada vez, ou você pode criar um fluxo de trabalho a partir de um [esquema](blueprints-overview.md) do AWS Glue. O AWS Glue inclui esquemas para casos de uso comuns. Seus desenvolvedores do AWS Glue podem criar esquemas adicionais.
**Importante**
Limite o número total de trabalhos, crawlers e gatilhos em um fluxo de trabalho para 100 ou menos. Se você incluir mais de 100, poderá receber erros ao tentar retomar ou interromper as execuções do fluxo de trabalho.
Ao usar um blueprint, você pode gerar rapidamente um fluxo de trabalho para um caso de uso específico com base no caso de uso generalizado definido pelo blueprint. Você define o caso de uso específico fornecendo valores para os parâmetros do blueprint. Por exemplo, um blueprint que particiona um conjunto de dados pode ter os caminhos de fonte e de destino do Amazon S3 como parâmetros.
O AWS Glue cria um fluxo de trabalho a partir de um esquema *executando* o esquema. A execução do blueprint salva os valores de parâmetro fornecidos e é usada para rastrear o progresso e o resultado da criação do fluxo de trabalho e de seus componentes. Ao solucionar problemas de um fluxo de trabalho, você pode exibir a execução do blueprint para determinar os valores de parâmetro do blueprint usados para criar um fluxo de trabalho.
Para criar e exibir fluxos de trabalho, você precisa de determinadas permissões do IAM. Para ver uma sugestão de política do IAM, consulte [Permissões de analista de dados para esquemas](blueprints-personas-permissions.md#bp-persona-analyst).
Você pode criar um fluxo de trabalho a partir de um esquema usando o console do AWS Glue, a API do AWS Glue ou a AWS Command Line Interface (AWS CLI).
**Para criar um fluxo de trabalho a partir de um blueprint (console)**
1. Abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Faça login como um usuário que tem permissões para criar um fluxo de trabalho.
1. No painel de navegação, escolha **Blueprints** (Esquemas).
1. Selecione um blueprint e, no menu **Actions** (Ações), escolha **Create workflow** (Criar fluxo de trabalho).
1. Na página **Create a workflow from ** (Criar um fluxo de trabalho a partir de ), insira as seguintes informações:
**Parâmetros do blueprint**
Estes variam dependendo do design do blueprint. Para dúvidas sobre os parâmetros, consulte o desenvolvedor. Os esquemas geralmente contêm um parâmetro para o nome do fluxo de trabalho.
**perfil do IAM**
A função que o AWS Glue assume para criar o fluxo de trabalho e seus componentes. A função deve ter permissões para criar e excluir fluxos de trabalho, trabalhos, crawlers e acionadores. Para obter uma política sugerida para a função, consulte [Permissões para perfis de esquema](blueprints-personas-permissions.md#blueprints-role-permissions).
1. Selecione **Enviar**.
A página **Blueprint Details** (Detalhes do blueprint) é exibida, mostrando uma lista de execuções do blueprint na parte inferior.
1. Na lista de execuções do blueprint, verifique a execução do blueprint mais alta quanto ao status de criação do fluxo de trabalho.
O status inicial é `RUNNING`. Escolha o botão de atualização até que o status mude para `SUCCEEDED` ou `FAILED`.
1. Execute um destes procedimentos:
+ Se o status de conclusão for `SUCCEEDED`, você pode ir para a página **Workflows** (Fluxos de trabalho), selecionar o fluxo de trabalho recém-criado e executá-lo. Antes de executar o fluxo de trabalho, você pode revisar o gráfico de design.
+ Se o status de conclusão for `FAILED`, selecione a execução do blueprint e, no menu **Actions** (Ações), escolha **View** (Exibir), para visualizar a mensagem de erro.
Para obter mais informações sobre fluxos de trabalho e esquemas, consulte os tópicos a seguir.
+ [Visão geral de fluxos de trabalho no AWS Glue](workflows_overview.md)
+ [Atualizar um esquema no AWS Glue](updating_blueprints.md)
+ [Criar e desenvolver um fluxo de trabalho manualmente no AWS Glue](creating_running_workflows.md)
# Visualizar execuções de esquemas no AWS Glue
Exiba uma execução de blueprint para ver as seguintes informações:
+ Nome do fluxo de trabalho que foi criado.
+ Valores de parâmetro do esquema que foram usados para criar o fluxo de trabalho.
+ O status da operação de criação do fluxo de trabalho.
Você pode exibir uma execução de esquema usando o console do AWS Glue, a API do AWS Glue ou a AWS Command Line Interface (AWS CLI).
**Para exibir uma execução de blueprint (console)**
1. Abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. No painel de navegação, escolha **Blueprints** (Esquemas).
1. Na página **Blueprints** (Esquemas), selecione um esquema. Em seguida, no menu **Actions** (Ações), escolha **View** (Exibir).
1. Na parte inferior da página **Blueprint Details** (Detalhes do blueprint), selecione uma execução de blueprint e, no menu **Actions** (Ações), escolha **View** (Exibir).
**Para exibir uma execução de blueprint (AWS CLI)**
+ Insira o comando da a seguir. Substitua ** pelo nome do blueprint. Substitua ** pelo ID de execução do blueprint.
```
aws glue get-blueprint-run --blueprint-name --run-id
```
**Consulte também:**
[Visão geral dos esquemas no AWS Glue](blueprints-overview.md)