# Creación del script de diseño del esquema
<a name="developing-blueprints-code-layout"></a>

El script de diseño del proyecto debe incluir una función que genere las entidades en el flujo de trabajo. Puede nombrar esta función como quiera. AWS Glue utiliza el archivo de configuración para determinar el nombre completo de la función.

La función de diseño hace lo siguiente:
+ (Opcional) genera instancias de clase `Job` para crear objetos `Job`, y transfiere argumentos como `Command` y `Role`. Estas son propiedades de trabajo que especificaría al crear el trabajo mediante la consola de AWS Glue o la API.
+ (Opcional) genera instancias de clase `Crawler` para crear objetos `Crawler`, y transfiere nombre, rol y argumentos de destino.
+ Para indicar dependencias entre los objetos (entidades de flujo de trabajo), transfiere los argumentos adicionales `DependsOn` y `WaitForDependencies` a `Job()` y `Crawler()`. Estos argumentos se explican más adelante en esta sección.
+ Inicia la clase `Workflow` para crear el objeto de flujo de trabajo que se devuelve a AWS Glue, al transferir un argumento `Name`, un argumento `Entities` y un argumento opcional `OnSchedule`. El argumento `Entities` especifica todos los trabajos y rastreadores que se incluirán en el flujo de trabajo. Para ver cómo construir un objeto `Entities`, consulte el proyecto de ejemplo más adelante en esta sección.
+ Devuelve un objeto `Workflow`.

Para conocer las definiciones de las clases `Job`, `Crawler` y `Workflow`, consulte [Referencia de clases de esquemas de AWS Glue](developing-blueprints-code-classes.md).

La función de diseño debe aceptar los siguientes argumentos de entrada.


| Argumento | Descripción | 
| --- | --- | 
| user\$1params | Diccionario de Python de nombres y valores de parámetros del proyecto. Para obtener más información, consulte [Especificación de parámetros del esquema](developing-blueprints-code-parameters.md). | 
| system\$1params | Diccionario de Python que contiene dos propiedades: region y accountId. | 

Aquí hay un script de generador de diseño de ejemplo en un archivo denominado `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
```

El script de ejemplo importa las bibliotecas del proyecto requeridas e incluye una función `generate_layout` que genera un flujo de trabajo con dos trabajos. Este es un script muy sencillo. Un script más complejo podría emplear lógica y parámetros adicionales para generar un flujo de trabajo con muchos trabajos y rastreadores, o incluso un número variable de trabajos y rastreadores.

## Uso del argumento DependsOn (Depende de)
<a name="developing-blueprints-code-layout-depends-on"></a>

El argumento `DependsOn` es una representación de diccionario de una dependencia que esta entidad tiene en otras entidades dentro del flujo de trabajo. Tiene el formato siguiente. 

```
DependsOn = {dependency1 : state, dependency2 : state, ...}
```

Las claves de este diccionario representan la referencia del objeto, no el nombre de la entidad, mientras que los valores son cadenas que corresponden al estado que se debe controlar. AWS Glue infiere los desencadenantes adecuados. Para conocer los estados válidos, consulte [Estructura de condiciones](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-trigger.html#aws-glue-api-jobs-trigger-Condition).

Por ejemplo, un trabajo puede depender de la finalización correcta de un rastreador. Si define un objeto de rastreador llamado `crawler2` de la siguiente manera:

```
crawler2 = Crawler(Name="my_crawler", ...)
```

Un objeto que dependa de `crawler2` incluiría un argumento constructor como: 

```
DependsOn = {crawler2 : "SUCCEEDED"}
```

Por ejemplo: 

```
job1 = Job(Name="Job1", ..., DependsOn = {crawler2 : "SUCCEEDED", ...})
```

Si se omite `DependsOn` para una entidad, esa entidad depende del desencadenador de inicio del flujo de trabajo.

## Uso del argumento WaitForDependencies (Esperar a las dependencias)
<a name="developing-blueprints-code-layout-wait-for-dependencies"></a>

El argumento `WaitForDependencies` define si una entidad de trabajo o rastreador debe esperar hasta que *todas* las entidades de las que depende se completen o hasta que *alguna* se complete.

Los valores permitidos son “`AND`” o “`ANY`”.

## Uso del argumento OnSchedule (Programado)
<a name="developing-blueprints-code-layout-on-schedule"></a>

El argumento `OnSchedule` para el constructor de clase `Workflow` es una expresión `cron` que establece la definición del desencadenador inicial para un flujo de trabajo.

Si se especifica este argumento, AWS Glue crea un desencadenador de programación con la programación correspondiente. Si no se especifica, el desencadenador de inicio del flujo de trabajo es un desencadenador bajo demanda.