# Criar o script de layout do esquema
<a name="developing-blueprints-code-layout"></a>

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
<a name="developing-blueprints-code-layout-depends-on"></a>

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
<a name="developing-blueprints-code-layout-wait-for-dependencies"></a>

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
<a name="developing-blueprints-code-layout-on-schedule"></a>

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.