Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Création du script de structure du plan
Le script de structure de modèle doit inclure une fonction qui génère les entités dans votre flux de travail. Vous pouvez nommer cette fonction comme vous le souhaitez. AWS Glue utilise le fichier de configuration pour déterminer le nom complet de la fonction.
Votre fonction de structure effectue les opérations suivantes :
+ (Facultatif) Instancie la classe `Job` pour créer des objets `Job`, et passe des arguments tels que `Command` et `Role`. Ce sont des propriétés de tâche que vous spécifieriez si vous créiez la tâche à l'aide de la console AWS Glue ou de l'API.
+ (Facultatif) Instancie la classe `Crawler` pour créer des objets `Crawler`, et passe les arguments nom, rôle et cible.
+ Pour indiquer les dépendances entre les objets (entités de flux de travail), transmet les arguments supplémentaires `DependsOn` et `WaitForDependencies` à `Job()` et `Crawler()`. Ces arguments sont expliqués plus loin dans cette section.
+ Instancie la classe `Workflow` pour créer l'objet de flux de travail qui est retourné à AWS Glue, en passant un argument `Name`, un argument `Entities`, et un argument facultatif `OnSchedule`. L'argument `Entities` spécifie tous les tâches et les crawlers à inclure dans le flux de travail. Pour voir comment construire un objet `Entities`, vous trouverez l'exemple de projet plus loin dans cette section.
+ Renvoie un objet `Workflow`.
Pour les définitions de classes `Job`, `Crawler` et `Workflow`, veuillez consulter [Référence des classes de plan AWS Glue](developing-blueprints-code-classes.md).
La fonction de structure doit accepter les arguments d'entrée suivants.
| Argument | Description |
| --- | --- |
| user\$1params | Dictionnaire Python des noms et valeurs de paramètres de modèle. Pour de plus amples informations, veuillez consulter [Spécifier les paramètres du plan](developing-blueprints-code-parameters.md). |
| system\$1params | Dictionnaire Python contenant deux propriétés : region et accountId. |
Voici un exemple de script générateur de structure dans un fichier nommé `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
```
L'exemple de script importe les bibliothèques de modèles requises et inclut une fonction `generate_layout` qui génère un flux de travail avec deux tâches. Ceci est un script très simple. Un script plus complexe pourrait utiliser une logique et des paramètres supplémentaires pour générer un flux de travail avec de nombreux crawlers et tâches, ou même un nombre variable de tâches et d'crawlers.
## Utilisation de l' DependsOn argument
L'argument `DependsOn` est une représentation sous forme de dictionnaire d'une dépendance que cette entité a sur d'autres entités dans le flux de travail. Elle se présente sous la forme suivante.
```
DependsOn = {dependency1 : state, dependency2 : state, ...}
```
Les clés de ce dictionnaire représentent la référence d'objet, et non le nom, de l'entité, tandis que les valeurs sont des chaînes qui correspondent à l'état à surveiller. AWS Glue déduit les déclencheurs appropriés. Pour connaître les états valides, veuillez consulter [Condition Structure (Structure des conditions)](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-trigger.html#aws-glue-api-jobs-trigger-Condition).
Par exemple, une tâche peut dépendre de la réussite d'un crawler. Si vous définissez un objet crawler nommé `crawler2` comme suit :
```
crawler2 = Crawler(Name="my_crawler", ...)
```
Ensuite, un objet dépendant de `crawler2` comprendrait un argument de constructeur tel que :
```
DependsOn = {crawler2 : "SUCCEEDED"}
```
Par exemple :
```
job1 = Job(Name="Job1", ..., DependsOn = {crawler2 : "SUCCEEDED", ...})
```
Si `DependsOn` est omis pour une entité, cette entité dépend du déclencheur de démarrage du flux de travail.
## Utilisation de l' WaitForDependencies argument
L'argument `WaitForDependencies` définit si une entité de tâche ou d'crawler doit attendre jusqu'à ce que *toutes* les entités dont elle dépend se terminent ou qu'*une seule d'entre elles* se termine.
Les valeurs autorisées sont « `AND` » ou « `ANY` ».
## Utilisation de l' OnSchedule argument
L'argument `OnSchedule` pour le constructeur de classe `Workflow` est une expression `cron` qui définit la définition de déclenchement de démarrage d'un flux de travail.
Si cet argument est spécifié, AWS Glue crée un déclencheur de planification avec la planification correspondante. Si elle n'est pas spécifiée, le déclencheur de démarrage du flux de travail est un déclencheur à la demande.