Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Scrittura del codice dello schema
Ogni piano creato deve contenere almeno i seguenti file:
+ Uno script di layout Python che definisce il flusso di lavoro. Lo script contiene una funzione che definisce le entità (processi e crawler) in un flusso di lavoro e le dipendenze tra di esse.
+ Un file di configurazione, `blueprint.cfg`, che definisce:
+ Il percorso completo della funzione di definizione del layout del flusso di lavoro.
+ I parametri accettati dal piano.
**Topics**
+ [Creazione dello script di layout dello schema](developing-blueprints-code-layout.md)
+ [Creare il file di configurazione](developing-blueprints-code-config.md)
+ [Specifica dei parametri dello schema](developing-blueprints-code-parameters.md)
# Creazione dello script di layout dello schema
Lo script di layout del piano deve includere una funzione che genera le entità nel flusso di lavoro. Puoi nominare questa funzione come preferisci. AWS Glue utilizza il file di configurazione per determinare il nome completo della funzione.
La funzione di layout svolge le operazioni seguenti:
+ (Facoltativo) Crea un'istanza della classe di `Job` per creare oggetti `Job` e passa argomenti come `Command` e `Role`. Si tratta di proprietà del processo da specificare se lo stai creando tramite la console o l'API AWS Glue.
+ (Facoltativo) Crea un'istanza della classe di `Crawler` per creare oggetti `Crawler` e passa argomenti come il nome, il ruolo e la destinazione.
+ Per indicare le dipendenze tra gli oggetti (entità del flusso di lavoro), passa gli argomenti aggiuntivi `DependsOn` e `WaitForDependencies` al `Job()` e al `Crawler()`. Questi argomenti sono descritti più avanti in questa sezione.
+ Crea un'istanza della classe di `Workflow` per creare l'oggetto di flusso di lavoro che viene restituito ad AWS Glue, passando un argomento `Name`, un argomento `Entities` e un argomento facoltativo `OnSchedule`. L'argomento `Entities` specifica tutti i processi e i crawler da includere nel flusso di lavoro. Per sapere come costruire un oggetto `Entities`, vedi il progetto di esempio più avanti in questa sezione.
+ Restituisce l'oggetto `Workflow`.
Per le definizioni delle classi `Job`, `Crawler` e`Workflow`, consulta [Riferimento alle classi di schema AWS Glue](developing-blueprints-code-classes.md).
La funzione di layout di deve accettare i seguenti argomenti.
| Argomento | Description |
| --- | --- |
| user\$1params | Dizionario Python di nomi e valori dei parametri del piano. Per ulteriori informazioni, consulta [Specifica dei parametri dello schema](developing-blueprints-code-parameters.md). |
| system\$1params | Dizionario Python contenente due proprietà: region e accountId. |
Ecco uno script generatore di layout di esempio in un file chiamato `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
```
Lo script di esempio importa le librerie del piano richieste e include un `generate_layout` che genera un flusso di lavoro con due processi. Si tratta di uno script molto semplice. Uno script più complesso potrebbe impiegare logica e parametri aggiuntivi per generare un flusso di lavoro con molti processi e crawler, o anche un numero variabile di processi e crawler.
## Utilizzo dell' DependsOn argomento
La'argomento `DependsOn` è una rappresentazione dizionario di una dipendenza di questa entità su altre entità all'interno del flusso di lavoro. Presenta il seguente formato.
```
DependsOn = {dependency1 : state, dependency2 : state, ...}
```
Le chiavi in questo dizionario rappresentano il riferimento all'oggetto dell'entità (non il nome), mentre i valori sono stringhe che corrispondono allo stato da controllare. AWS Glue deduce le attivazioni appropriate. Per gli stati validi, consulta [Struttura Condition](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-trigger.html#aws-glue-api-jobs-trigger-Condition).
Ad esempio, un processo potrebbe dipendere dal completamento corretto di un crawler. Se definisci un oggetto crawler denominato `crawler2` come segue:
```
crawler2 = Crawler(Name="my_crawler", ...)
```
Allora un oggetto dipendente da `crawler2` includerebbe un argomento del costruttore come:
```
DependsOn = {crawler2 : "SUCCEEDED"}
```
Ad esempio:
```
job1 = Job(Name="Job1", ..., DependsOn = {crawler2 : "SUCCEEDED", ...})
```
Se `DependsOn` viene omesso per un'entità, tale entità dipende dal trigger di avvio del flusso di lavoro.
## Usando l' WaitForDependencies argomento
L'argomento `WaitForDependencies` definisce se un processo o un'entità crawler deve attendere fino a che *tutte* le entità da cui dipende sono complete o fino a quando è completa una *qualsiasi*.
I valori consentiti sono "`AND`" o "`ANY`".
## Usando l' OnSchedule argomento
L'argomento `OnSchedule` per il costruttore della classe `Workflow` è un'espressione `cron` che indica la definizione del trigger iniziale per un flusso di lavoro.
Se questo argomento è specificato, AWS Glue crea un'attivazione di pianificazione con la pianificazione corrispondente. Se non è specificato, il trigger di attivazione del flusso di lavoro è un trigger on demand.
# Creare il file di configurazione
Il file di configurazione del piano è un file obbligatorio che definisce il punto di ingresso dello script per la generazione del flusso di lavoro e i parametri accettati dal piano. Il deve essere denominato `blueprint.cfg`.
Segue una configurazione di esempio.
```
{
"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
}
}
}
```
La proprietà `layoutGenerator` specifica il nome completo della funzione nello script che genera il layout.
La proprietà `parameterSpec` specifica i parametri accettati da questo piano. Per ulteriori informazioni, consulta [Specifica dei parametri dello schema](developing-blueprints-code-parameters.md).
**Importante**
Il file di configurazione deve includere il nome del flusso di lavoro come parametro del piano oppure è necessario generare un nome di flusso di lavoro univoco nello script di layout.
# Specifica dei parametri dello schema
Il file di configurazione contiene le specifiche dei parametri del piano in un oggetto JSON `parameterSpec`. `parameterSpec` contiene uno o più oggetti parametro.
```
"parameterSpec": {
"": {
"type": "",
"collection": true|false,
"description": "",
"defaultValue": ""
"allowedValues": ""
},
"": {
...
}
}
```
Di seguito sono riportate le regole per la codifica di ogni oggetto parametro:
+ Il nome e il `type` del parametro sono obbligatori. Tutte le altre proprietà sono facoltative.
+ Se si specifica la proprietà `defaultValue`, il parametro è facoltativo. In caso contrario, il parametro è obbligatorio e l'analista dei dati che sta creando un flusso di lavoro dal piano deve fornire un valore per esso.
+ Se si imposta la proprietà `collection` su `true`, il parametro può assumere un insieme di valori. Le raccolte possono essere di qualsiasi tipo di dati.
+ Se specifichi `allowedValues`, la console AWS Glue mostra un elenco a discesa di valori tra cui l'analista dei dati può scegliere durante la creazione di un flusso di lavoro dal progetto.
Di seguito sono elencati i valori consentiti per `type`:
| Tipo di dati dei parametri | Note |
| --- | --- |
| String | - |
| Integer | - |
| Double | - |
| Boolean | I valori possibili sono true e false. Genera una casella di controllo nella pagina Create a workflow from (Crea un flusso di lavoro da ), sulla console AWS Glue. |
| S3Uri | Completa il percorso Amazon S3, iniziando con s3://. Genera un campo di testo e un pulsante Browse (Sfoglia) nella pagina Create a workflow from (Crea un flusso di lavoro da ). |
| S3Bucket | Solo il nome del bucket Amazon S3. Genera un selettore bucket nella scheda Create a workflow from (Crea un flusso di lavoro da ). |
| IAMRoleArn | Amazon Resource Name (ARN) di un ruolo AWS Identity and Access Management (IAM). Genera un selettore ruolo nella pagina Create a workflow from (Crea un flusso di lavoro da ). |
| IAMRoleName | Nome di un ruolo IAM. Genera un selettore ruolo nella pagina Create a workflow from (Crea un flusso di lavoro da ). |