# Gravar o código do esquema
<a name="developing-blueprints-code"></a>

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
<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.

# Criar o arquivo de configuração
<a name="developing-blueprints-code-config"></a>

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

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": {
    "<parameter_name>": {
      "type": "<parameter-type>",
      "collection": true|false, 
      "description": "<parameter-description>",
      "defaultValue": "<default value for the parameter if value not specified>"
      "allowedValues": "<list of allowed values>" 
    },
    "<parameter_name>": {    
       ...
    }
  }
```

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 <esquema> (Criar um fluxo de trabalho a partir de <esquema>) 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 <blueprint> (Criar um fluxo de trabalho a partir de <blueprint>). | 
| S3Bucket | Somente nome do bucket do Amazon S3. Gera um seletor de bucket na página Create a workflow from <blueprint> (Criar um fluxo de trabalho a partir de <blueprint>). | 
| 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 <blueprint> (Criar um fluxo de trabalho a partir de <blueprint>). | 
| IAMRoleName | Nome de uma função do IAM. Gera um seletor de função na página Create a workflow from <blueprint> (Criar um fluxo de trabalho a partir de <blueprint>). |