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à.
# Sviluppo di schemi in AWS Glue
L'organizzazione potrebbe avere un set di casi di utilizzo ETL simili che potrebbero trarre vantaggio dalla possibilità di definire i parametri di un singolo flusso di lavoro in grado di gestirli tutti. A questo scopo, AWS Glue ti consente di definire dei *progetti*, che puoi utilizzare per generare i flussi di lavoro. Un progetto accetta i parametri, in modo che da un singolo progetto, un analista di dati possa creare diversi flussi di lavoro per gestire casi di utilizzo ETL simili. Una volta creato un progetto, puoi riutilizzarlo per reparti, team e progetti diversi.
**Topics**
+ [Panoramica degli schemi in AWS Glue](blueprints-overview.md)
+ [Sviluppo di schemi in AWS Glue](developing-blueprints.md)
+ [Registrazione di uno schema in AWS Glue](registering-blueprints.md)
+ [Visualizzazione degli schemi in AWS Glue](viewing_blueprints.md)
+ [Aggiornamento di uno schema in AWS Glue](updating_blueprints.md)
+ [Creazione di un flusso di lavoro da uno schema in AWS Glue](creating_workflow_blueprint.md)
+ [Visualizzazione delle esecuzioni dello schema in AWS Glue](viewing_blueprint_runs.md)
# Panoramica degli schemi in AWS Glue
**Nota**
La funzionalità blueprints non è attualmente disponibile nelle seguenti regioni della console AWS Glue: Asia Pacifico (Giacarta) e Medio Oriente (Emirati Arabi Uniti).
I progetti AWS Glue offrono un modo per creare e condividere i flussi di lavoro AWS Glue. Quando esiste un processo ETL complesso che potrebbe essere utilizzato per casi d'uso simili, piuttosto che creare un flusso di lavoro AWS Glue per ogni caso d'uso, è possibile creare un singolo progetto.
Il piano specifica i processi e i crawler da includere in un flusso di lavoro e specifica i parametri che l'utente fornisce quando esegue il piano per creare un flusso di lavoro. L'uso di parametri consente a un singolo piano di generare flussi di lavoro per vari casi d'uso simili. Per ulteriori informazioni sui flussi di lavoro, consulta [Panoramica di flussi di lavoro in AWS Glue](workflows_overview.md).
Di seguito sono riportati esempi di casi d'uso per i piani:
+ Vuoi partizionare un set di dati esistente. I parametri di input del piano sono i percorsi di origine e di destinazione Amazon Simple Storage Service (Amazon S3) e un elenco di colonne di partizione.
+ Vuoi creare uno snapshot di una tabella Amazon DynamoDB in un archivio dati SQL come Amazon Redshift. I parametri di input per il progetto sono il nome della tabella DynamoDB e una connessione AWS Glue, che indica un cluster Amazon Redshift e un database di destinazione.
+ Vuoi convertire i dati CSV in più percorsi Amazon S3 in Parquet. È consigliabile che il flusso di lavoro AWS Glue includa un crawler e un processo separati per ogni percorso. I parametri di input sono il database di destinazione in AWS Glue Data Catalog e un elenco di percorsi Amazon S3 delimitati da virgola. In questo caso, il numero di crawler e processi creati dal flusso di lavoro è variabile.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/s3Bm8ay53Ms)
**Componenti dello schema**
Un piano è un archivio ZIP contenente i seguenti componenti:
+ Uno script generatore di layout Python
Contiene una funzione che specifica il *layout* del flusso di lavoro: i crawler e i processi da creare per il flusso di lavoro, le proprietà del processo e del crawler e le dipendenze tra i processi e i crawler. La funzione accetta i parametri di progetto e restituisce una struttura del flusso di lavoro (oggetto JSON) che AWS Glue utilizza per generare il flusso di lavoro. Utilizzando uno script Python per generare il flusso di lavoro, puoi aggiungere la logica adatta ai tuoi casi d'uso.
+ Un file di configurazione
Specifica il nome completo della funzione Python che genera il layout del flusso di lavoro. Specifica inoltre i nomi, i tipi di dati e le altre proprietà di tutti i parametri del piano utilizzati dallo script.
+ (Facoltativo) Script ETL e file di supporto
Come caso d'uso avanzato, è possibile definire i parametri della posizione degli script ETL utilizzati dai processi. Puoi includere i file di script di processo nell'archivio ZIP e specificare un parametro del piano per una posizione Amazon S3 in cui gli script devono essere copiati. Lo script generatore di layout può copiare gli script ETL nella posizione indicata e specificare tale posizione come proprietà della posizione dello script di processo. È inoltre possibile includere qualsiasi libreria o altri file di supporto, a condizione che lo script li gestisca.
![\[Riquadro denominato Blueprint (Piano) contiene due caselle più piccole, una denominata Python Script (Script Python) e l'altra Config File (File di configurazione).\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/blueprint.png)
**Esecuzioni del piano**
Quando crei un flusso di lavoro da un progetto, AWS Glue lo esegue, il che avvia un processo asincrono per creare il flusso di lavoro e i processi, i crawler e i trigger incapsulati dal flusso di lavoro. AWS Glue usa l'esecuzione del progetto per orchestrare la creazione del flusso di lavoro e dei suoi componenti. Puoi vedere lo stato del processo di creazione attraverso lo stato di esecuzione del piano. L'esecuzione del piano memorizza anche i valori forniti per i parametri del piano.
![\[Riquadro denominato Blueprint run (Esecuzione piano) che contiene delle icone denominate (Workflow) Flusso di lavoro e Parameter Values (Valori dei parametri).\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/blueprint-run.png)
È possibile visualizzare le esecuzioni dei blueprint utilizzando la AWS Glue console o (). AWS Command Line Interface AWS CLI Durante la visualizzazione o la risoluzione dei problemi di un flusso di lavoro, puoi sempre tornare all'esecuzione del piano per visualizzare i valori dei parametri del piano utilizzati per creare il flusso di lavoro.
**Ciclo di vita di uno schema**
Gli schemi sono sviluppati, testati, registrati con AWS Glue ed eseguiti per creare flussi di lavoro. In genere tre utenti sono coinvolti nel ciclo di vita del piano.
| Utente | Processi |
| --- | --- |
| Sviluppatore AWS Glue | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/blueprints-overview.html) |
| Amministratore di AWS Glue | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/blueprints-overview.html) |
| Analista dei dati | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/blueprints-overview.html) |
**Consulta anche**
[Sviluppo di schemi in AWS Glue](developing-blueprints.md)
[Creazione di un flusso di lavoro da uno schema in AWS Glue](creating_workflow_blueprint.md)
[Autorizzazioni per utenti e ruoli per gli schemi AWS Glue](blueprints-personas-permissions.md)
# Sviluppo di schemi in AWS Glue
In qualità di sviluppatore AWS Glue, puoi creare e pubblicare progetti che gli analisti di dati potranno utilizzare per generare flussi di lavoro.
**Topics**
+ [Panoramica sullo sviluppo di schemi](developing-blueprints-overview.md)
+ [Prerequisiti per lo sviluppo degli schemi](developing-blueprints-prereq.md)
+ [Scrittura del codice dello schema](developing-blueprints-code.md)
+ [Progetto di schema di esempio](developing-blueprints-sample.md)
+ [Test di uno schema](developing-blueprints-testing.md)
+ [Pubblicazione di uno schema](developing-blueprints-publishing.md)
+ [Riferimento alle classi di schema AWS Glue](developing-blueprints-code-classes.md)
+ [Esempi di schema](developing-blueprints-samples.md)
**Consulta anche**
[Panoramica degli schemi in AWS Glue](blueprints-overview.md)
# Panoramica sullo sviluppo di schemi
Il primo passo del processo di sviluppo consiste nell'identificare un caso d'uso comune che possa trarre vantaggio da un piano. Un tipico caso d'uso comporta un problema ETL ricorrente che ritieni debba essere risolto in modo generale. Quindi, progetta un piano che implementi il caso d'uso generalizzato e definisci i parametri di input del piano che insieme possono definire un caso d'uso specifico a partire dal caso d'uso generalizzato.
Un piano è costituito da un progetto che contiene un file di configurazione dei parametri del piano e uno script che definisce la proprietà di *layout* del flusso di lavoro da generare. Il layout definisce i processi e i crawler (o *entità*, nella terminologia dello script del piano) da creare.
Non è possibile specificare direttamente alcun trigger nello script di layout. È invece possibile scrivere codice per specificare le dipendenze tra i processi e i crawler creati dallo script. AWS Glue genera le attivazioni basate sulle specifiche delle dipendenze. L'output dello script di layout è un oggetto di flusso di lavoro che contiene le specifiche per tutte le entità del flusso di lavoro.
È possibile costruire l'oggetto flusso di lavoro utilizzando le seguenti librerie dei progetti AWS Glue:
+ `awsglue.blueprint.base_resource`— Una libreria di risorse di base utilizzate dalle librerie.
+ `awsglue.blueprint.workflow`— Una libreria per definire una classe di `Workflow`.
+ `awsglue.blueprint.job`— Una libreria per definire una classe di `Job`.
+ `awsglue.blueprint.crawler`— Una libreria per definire una classe di `Crawler`.
Le uniche altre librerie supportate per la generazione del layout sono quelle disponibili per la shell Python.
Prima di pubblicare il piano, è possibile utilizzare i metodi definiti nelle librerie dei piani per testarlo localmente.
Quando si è pronti a rendere il piano disponibile agli analisti dei dati, è possibile creare un pacchetto dello script, del file di configurazione dei parametri e di tutti i file di supporto, ad esempio script e librerie aggiuntivi, in un'unica risorsa distribuibile. Quindi si carica la risorsa su Amazon S3 e si chiede a un amministratore di registrarla su AWS Glue.
Per ulteriori informazioni su altri piani di esempio, consulta [Progetto di schema di esempio](developing-blueprints-sample.md) e [Esempi di schema](developing-blueprints-samples.md).
# Prerequisiti per lo sviluppo degli schemi
Per sviluppare i progetti, è bene avere familiarità con AWS Glue e con la scrittura di script per i processi Apache Spark ETL o di shell Python. È inoltre necessario completare le seguenti attività di configurazione.
+ Scarica quattro librerie AWS Python da usare negli script di layout dei tuoi blueprint.
+ Configura il. AWS SDKs
+ Configura il AWS CLI.
## Scaricare le librerie Python
Scarica le seguenti librerie da GitHub e installale nel tuo progetto:
+ [https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/base\$1resource.py](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/base_resource.py)
+ [https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/workflow.py](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/workflow.py)
+ [https://github.com/awslabs/aws-glue-blueprint-libs/.py tree/master/awsglue/blueprint/crawler](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/crawler.py)
+ [https://github.com/awslabs/aws-glue-blueprint-libs/.py tree/master/awsglue/blueprint/job](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/awsglue/blueprint/job.py)
## Configura AWS Java SDK
Per AWS Java SDK, è necessario aggiungere un `jar` file che includa l'API per i blueprint.
1. Se non l'hai già fatto, configura l' AWS SDK for Java.
+ Per Java 1.x, segui le istruzioni in [Impostare AWS SDK per Java](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html) nella *Guida per gli sviluppatori di AWS SDK per Java *.
+ Per Java 2.x, segui le istruzioni in [Configurazione di AWS SDK for Java 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup.html) nella *AWS SDK for Java 2.x Guida per gli sviluppatori di *.
1. Scarica il `jar` file client che ha accesso ai progetti APIs for.
+ Per Java 1.x: s3://- -1.11.x.jar awsglue-custom-blueprints-preview artifacts/awsglue-java-sdk-preview/AWSGlueJavaClient
+ Per Java 2.x: s3://awsglue-custom-blueprints-preview- -Glue-2.0.jar artifacts/awsglue-java-sdk-v2-preview/AwsJavaSdk
1. Aggiungi il client `jar` all'inizio del classpath Java per sovrascrivere il client AWS Glue fornito da Java SDK. AWS
```
export CLASSPATH=:$CLASSPATH
```
1. (Facoltativo) Testa l'SDK con la seguente applicazione Java. L'applicazione dovrebbe produrre un elenco vuoto.
Sostituisci `accessKey` e `secretKey` con le tue credenziali e sostituisci `us-east-1` con la tua regione.
```
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSCredentialsProvider;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.services.glue.AWSGlue;
import com.amazonaws.services.glue.AWSGlueClientBuilder;
import com.amazonaws.services.glue.model.ListBlueprintsRequest;
public class App{
public static void main(String[] args) {
AWSCredentials credentials = new BasicAWSCredentials("accessKey", "secretKey");
AWSCredentialsProvider provider = new AWSStaticCredentialsProvider(credentials);
AWSGlue glue = AWSGlueClientBuilder.standard().withCredentials(provider)
.withRegion("us-east-1").build();
ListBlueprintsRequest request = new ListBlueprintsRequest().withMaxResults(2);
System.out.println(glue.listBlueprints(request));
}
}
```
## Configura l' AWS SDK Python
I passaggi seguenti presuppongono che sul computer sia installato Python versione 2.7 o successiva oppure versione 3.9 o successiva.
1. Scarica il seguente file boto3 wheel. Se viene richiesto di aprire o salvare, salvate il file. s3://- 3-1.17.31-py2.py3-none-any.whl awsglue-custom-blueprints-preview artifacts/aws-python-sdk-preview/boto
1. Scaricate il seguente file awsglue-custom-blueprints-preview botocore wheel: artifacts/aws-python-sdk-preview/botocore s3://- -1.20.31-py2.py3-none-any.whl
1. Controlla la tua versione Python.
```
python --version
```
1. A seconda della versione di Python, immetti seguenti comandi (per Linux):
+ Per Python 2.7 o versioni successive.
```
python3 -m pip install --user virtualenv
source env/bin/activate
```
+ Per Python 3.9 o successivo.
```
python3 -m venv python-sdk-test
source python-sdk-test/bin/activate
```
1. Installa il file botocore wheel.
```
python3 -m pip install /botocore-1.20.31-py2.py3-none-any.whl
```
1. Installa il file boto3 wheel.
```
python3 -m pip install /boto3-1.17.31-py2.py3-none-any.whl
```
1. Configura le credenziali e la regione predefinita nei file `~/.aws/credentials` e `~/.aws/config`. Per ulteriori informazioni, consulta [Configurazione della AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) nella *Guida per l'utente di AWS Command Line Interface *.
1. (Facoltativo) Esegui il test della configurazione. I seguenti comandi devono restituire un elenco vuoto.
Sostituisci `us-east-1` con la tua regione.
```
$ python
>>> import boto3
>>> glue = boto3.client('glue', 'us-east-1')
>>> glue.list_blueprints()
```
## Imposta l'anteprima AWS CLI
1. Se non l'hai già fatto, installa l' and/or aggiornamento AWS Command Line Interface (AWS CLI) sul tuo computer. Il modo più semplice per eseguire questa operazione è utilizzare `pip`, l'utility di installazione Python:
```
pip install awscli --upgrade --user
```
Puoi trovare le istruzioni di installazione complete per AWS CLI qui: [Installazione di AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html).
1. Scarica il file AWS CLI wheel da: s3://awsglue-custom-blueprints-preview- artifacts/awscli-preview-build/awscli -1.19.31-py2.py3-none-any.whl
1. Installa il file AWS CLI wheel.
```
python3 -m pip install awscli-1.19.31-py2.py3-none-any.whl
```
1. Esegui il comando `aws configure`. Configura AWS le tue credenziali (inclusa la chiave di accesso e la chiave segreta) e la AWS regione. Puoi trovare informazioni sulla configurazione AWS CLI qui: [Configurazione](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) di. AWS CLI
1. Prova il. AWS CLI Il seguente comando dovrebbe restituire un elenco vuoto.
Sostituisci `us-east-1` con la tua regione.
```
aws glue list-blueprints --region us-east-1
```
# 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 ). |
# Progetto di schema di esempio
La conversione del formato dei dati è un caso d'uso frequente di estrazione, trasformazione e caricamento (ETL). Nei carichi di lavoro analitici tipici, i formati di file basati su colonne come Parquet o ORC sono preferiti rispetto ai formati di testo come CSV o JSON. Questo modello di esempio consente di convertire i dati da.in Parquet per i file su Amazon S3CSV/JSON/etc.
Questo piano accetta un elenco di percorsi S3 definiti da un parametro del piano, converte i dati in formato Parquet e li scrive nella posizione S3 specificata da un altro parametro del piano. Lo script di layout crea un crawler e un processo per ogni percorso. Lo script di layout carica anche lo script ETL in `Conversion.py` in un bucket S3 specificato da un altro parametro del piano. Lo script di layout specifica quindi lo script caricato come script ETL per ogni processo. L'archivio ZIP del progetto contiene lo script di layout, lo script ETL e il file di configurazione del piano.
Per ulteriori informazioni su altri piani di esempio, consulta [Esempi di schema](developing-blueprints-samples.md).
Di seguito è riportato lo script di layout, nel file `Layout.py`.
```
from awsglue.blueprint.workflow import *
from awsglue.blueprint.job import *
from awsglue.blueprint.crawler import *
import boto3
s3_client = boto3.client('s3')
# Ingesting all the S3 paths as Glue table in parquet format
def generate_layout(user_params, system_params):
#Always give the full path for the file
with open("ConversionBlueprint/Conversion.py", "rb") as f:
s3_client.upload_fileobj(f, user_params['ScriptsBucket'], "Conversion.py")
etlScriptLocation = "s3://{}/Conversion.py".format(user_params['ScriptsBucket'])
crawlers = []
jobs = []
workflowName = user_params['WorkflowName']
for path in user_params['S3Paths']:
tablePrefix = "source_"
crawler = Crawler(Name="{}_crawler".format(workflowName),
Role=user_params['PassRole'],
DatabaseName=user_params['TargetDatabase'],
TablePrefix=tablePrefix,
Targets= {"S3Targets": [{"Path": path}]})
crawlers.append(crawler)
transform_job = Job(Name="{}_transform_job".format(workflowName),
Command={"Name": "glueetl",
"ScriptLocation": etlScriptLocation,
"PythonVersion": "3"},
Role=user_params['PassRole'],
DefaultArguments={"--database_name": user_params['TargetDatabase'],
"--table_prefix": tablePrefix,
"--region_name": system_params['region'],
"--output_path": user_params['TargetS3Location']},
DependsOn={crawler: "SUCCEEDED"},
WaitForDependencies="AND")
jobs.append(transform_job)
conversion_workflow = Workflow(Name=workflowName, Entities=Entities(Jobs=jobs, Crawlers=crawlers))
return conversion_workflow
```
Di seguito è riportato il corrispondente file `blueprint.cfg` di configurazione del piano.
```
{
"layoutGenerator": "ConversionBlueprint.Layout.generate_layout",
"parameterSpec" : {
"WorkflowName" : {
"type": "String",
"collection": false,
"description": "Name for the workflow."
},
"S3Paths" : {
"type": "S3Uri",
"collection": true,
"description": "List of Amazon S3 paths for data ingestion."
},
"PassRole" : {
"type": "IAMRoleName",
"collection": false,
"description": "Choose an IAM role to be used in running the job/crawler"
},
"TargetDatabase": {
"type": "String",
"collection" : false,
"description": "Choose a database in the Data Catalog."
},
"TargetS3Location": {
"type": "S3Uri",
"collection" : false,
"description": "Choose an Amazon S3 output path: ex:s3:///."
},
"ScriptsBucket": {
"type": "S3Bucket",
"collection": false,
"description": "Provide an S3 bucket name(in the same AWS Region) to store the scripts."
}
}
}
```
Il seguente script nel file `Conversion.py` è lo script ETL caricato. Nota che durante la conversione mantiene lo schema di partizionamento.
```
import sys
from pyspark.sql.functions import *
from pyspark.context import SparkContext
from awsglue.transforms import *
from awsglue.context import GlueContext
from awsglue.job import Job
from awsglue.utils import getResolvedOptions
import boto3
args = getResolvedOptions(sys.argv, [
'JOB_NAME',
'region_name',
'database_name',
'table_prefix',
'output_path'])
databaseName = args['database_name']
tablePrefix = args['table_prefix']
outputPath = args['output_path']
glue = boto3.client('glue', region_name=args['region_name'])
glue_context = GlueContext(SparkContext.getOrCreate())
spark = glue_context.spark_session
job = Job(glue_context)
job.init(args['JOB_NAME'], args)
def get_tables(database_name, table_prefix):
tables = []
paginator = glue.get_paginator('get_tables')
for page in paginator.paginate(DatabaseName=database_name, Expression=table_prefix+"*"):
tables.extend(page['TableList'])
return tables
for table in get_tables(databaseName, tablePrefix):
tableName = table['Name']
partitionList = table['PartitionKeys']
partitionKeys = []
for partition in partitionList:
partitionKeys.append(partition['Name'])
# Create DynamicFrame from Catalog
dyf = glue_context.create_dynamic_frame.from_catalog(
name_space=databaseName,
table_name=tableName,
additional_options={
'useS3ListImplementation': True
},
transformation_ctx='dyf'
)
# Resolve choice type with make_struct
dyf = ResolveChoice.apply(
frame=dyf,
choice='make_struct',
transformation_ctx='resolvechoice_' + tableName
)
# Drop null fields
dyf = DropNullFields.apply(
frame=dyf,
transformation_ctx="dropnullfields_" + tableName
)
# Write DynamicFrame to S3 in glueparquet
sink = glue_context.getSink(
connection_type="s3",
path=outputPath,
enableUpdateCatalog=True,
partitionKeys=partitionKeys
)
sink.setFormat("glueparquet")
sink.setCatalogInfo(
catalogDatabase=databaseName,
catalogTableName=tableName[len(tablePrefix):]
)
sink.writeFrame(dyf)
job.commit()
```
**Nota**
Solo due percorsi Amazon S3 possono essere forniti come input per il piano di esempio. Questo perché le attivazioni di AWS Glue possono richiamare solo due operazioni crawler.
# Test di uno schema
Durante lo sviluppo del codice, è necessario eseguire test locali per verificare che il layout del flusso di lavoro sia corretto.
Il test locale non genera processi, crawler o attivazioni AWS Glue. Invece, esegui lo script di layout localmente e utilizzi i metodi `to_json()` e `validate()` per stampare gli oggetti e trovare gli errori. Questi metodi sono disponibili in tutte e tre le classi definite nelle librerie.
Sono disponibili due modi per gestire gli argomenti `user_params` e `system_params` cheAWS Glue passa alla funzione di layout. Il codice test-bench può creare un dizionario di valori di esempio dei parametri del piano e passarli alla funzione di layout come argomento `user_params`. In alternativa, puoi rimuovere i riferimenti a `user_params` e sostituirli con stringhe hardcoded.
Se il tuo codice utilizza proprietà `region` e `accountId` nell'argomento `system_params`, puoi passare nel tuo dizionario per `system_params`.
**Per testare un piano**
1. Avvia un interprete Python in una directory con le librerie o carica i file del piano e le librerie fornite nel tuo ambiente di sviluppo integrato (IDE) preferito.
1. Assicurati che il tuo codice importi le librerie fornite.
1. Aggiungi codice alla tua funzione di layout per chiamare `validate()` o `to_json()` su qualsiasi entità o sull'oggetto `Workflow`. Ad esempio, se il codice crea un oggetto `Crawler` denominato `mycrawler`, è possibile chiamare `validate()` come segue.
```
mycrawler.validate()
```
Puoi stampare `mycrawler` come segue:
```
print(mycrawler.to_json())
```
Se chiami `to_json` su un oggetto, non è necessario chiamare anche `validate()`, perché ` to_json()` chiama `validate()`.
È molto utile chiamare questi metodi sull'oggetto flusso di lavoro. Supponendo che lo script denomini l'oggetto flusso di lavoro `my_workflow`, convalida e stampa l'oggetto flusso di lavoro come segue.
```
print(my_workflow.to_json())
```
Per ulteriori informazioni su `to_json()` e `validate()`, consulta [Metodi di classe](developing-blueprints-code-classes.md#developing-blueprints-code-methods).
Puoi anche importare `pprint` e stampare con precisione l'oggetto flusso di lavoro, come illustrato nell'esempio più avanti in questa sezione.
1. Esegui il codice, correggi gli errori e infine rimuovi tutte le chiamate a `validate()` o `to_json()`.
**Example**
L'esempio seguente mostra come costruire un dizionario di parametri di esempio del piano e passarli come argomento `user_params` alla funzione di layout `generate_compaction_workflow`. Viene inoltre illustrato come stampare con precisione l'oggetto flusso di lavoro generato.
```
from pprint import pprint
from awsglue.blueprint.workflow import *
from awsglue.blueprint.job import *
from awsglue.blueprint.crawler import *
USER_PARAMS = {"WorkflowName": "compaction_workflow",
"ScriptLocation": "s3://amzn-s3-demo-bucket/scripts/threaded-compaction.py",
"PassRole": "arn:aws:iam::111122223333:role/GlueRole-ETL",
"DatabaseName": "cloudtrial",
"TableName": "ct_cloudtrail",
"CoalesceFactor": 4,
"MaxThreadWorkers": 200}
def generate_compaction_workflow(user_params: dict, system_params: dict) -> Workflow:
compaction_job = Job(Name=f"{user_params['WorkflowName']}_etl_job",
Command={"Name": "glueetl",
"ScriptLocation": user_params['ScriptLocation'],
"PythonVersion": "3"},
Role="arn:aws:iam::111122223333:role/AWSGlueServiceRoleDefault",
DefaultArguments={"DatabaseName": user_params['DatabaseName'],
"TableName": user_params['TableName'],
"CoalesceFactor": user_params['CoalesceFactor'],
"max_thread_workers": user_params['MaxThreadWorkers']})
catalog_target = {"CatalogTargets": [{"DatabaseName": user_params['DatabaseName'], "Tables": [user_params['TableName']]}]}
compacted_files_crawler = Crawler(Name=f"{user_params['WorkflowName']}_post_crawl",
Targets = catalog_target,
Role=user_params['PassRole'],
DependsOn={compaction_job: "SUCCEEDED"},
WaitForDependencies="AND",
SchemaChangePolicy={"DeleteBehavior": "LOG"})
compaction_workflow = Workflow(Name=user_params['WorkflowName'],
Entities=Entities(Jobs=[compaction_job],
Crawlers=[compacted_files_crawler]))
return compaction_workflow
generated = generate_compaction_workflow(user_params=USER_PARAMS, system_params={})
gen_dict = generated.to_json()
pprint(gen_dict)
```
# Pubblicazione di uno schema
Dopo aver sviluppato un piano, devi caricarlo su Amazon S3. Devi disporre delle autorizzazioni di scrittura sul bucket Amazon S3 utilizzato per pubblicare il piano. Devi inoltre assicurarti che l'amministratore AWS Glue, che registrerà il progetto disponga dell'accesso in lettura al bucket Amazon S3. Per le politiche di autorizzazione suggerite AWS Identity and Access Management (IAM) per i personaggi e i ruoli per i AWS Glue blueprint, vedere. [Autorizzazioni per utenti e ruoli per gli schemi AWS Glue](blueprints-personas-permissions.md)
**Per pubblicare un piano**
1. Crea gli script, le risorse e il file di configurazione del piano necessari.
1. Aggiungi tutti i file a un archivio ZIP e carica il file ZIP su Amazon S3. Utilizza un bucket S3 che si trova nella regione in cui gli utenti registreranno ed eseguiranno il piano.
È possibile creare un file ZIP dalla riga di comando utilizzando il comando seguente.
```
zip -r folder.zip folder
```
1. Aggiungi una policy bucket che conceda le autorizzazioni di lettura all'account desiderato. AWS Di seguito è riportata una policy di esempio.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::my-blueprints/*"
}
]
}
```
------
1. Concedi l'autorizzazione `s3:GetObject` IAM sul bucket Amazon S3 all'amministratore AWS Glue o a chiunque registrerà i progetti. Per un esempio di policy da concedere agli amministratori, consulta [Autorizzazioni per i progetti per l'amministratore di AWS Glue per gli schemi](blueprints-personas-permissions.md#bp-persona-admin).
Dopo aver completato il test locale del progetto, potresti anche voler testare un progetto su AWS Glue. Per testare un progetto su AWS Glue, questo deve essere registrato. È possibile limitare chi vede il piano registrato utilizzando l'autorizzazione IAM o account di test separati.
**Consulta anche:**
[Registrazione di uno schema in AWS Glue](registering-blueprints.md)
# Riferimento alle classi di schema AWS Glue
Le librerie per i piani AWS Glue definiscono tre classi da utilizzare nello script di layout del flusso di lavoro: `Job`, `Crawler` e `Workflow`.
**Topics**
+ [Classe di processo](#developing-blueprints-code-jobclass)
+ [Classe di crawler](#developing-blueprints-code-crawlerclass)
+ [Classe di flusso di lavoro](#developing-blueprints-code-workflowclass)
+ [Metodi di classe](#developing-blueprints-code-methods)
## Classe di processo
La classe `Job` rappresenta un processo ETL AWS Glue.
**Argomenti dei costruttori obbligatori**
Di seguito sono illustrati gli argomenti dei costruttori obbligatori per la classe di `Job`.
| Nome argomento | Tipo | Description |
| --- | --- | --- |
| Name | str | Nome da assegnare al processo. AWS Glue aggiunge un suffisso generato casualmente al nome per distinguere il processo da quelli creati da altre esecuzioni del progetto. |
| Role | str | L'Amazon Resource Name (ARN) del ruolo che deve assumere il processo durante l'esecuzione. |
| Command | dict | Comando del processo, come specificato nella documentazione API in [JobCommand struttura](aws-glue-api-jobs-job.md#aws-glue-api-jobs-job-JobCommand). |
**Argomenti dei costruttori facoltativi**
Di seguito sono illustrati gli argomenti dei costruttori facoltativi per la classe di `Job`.
| Nome argomento | Tipo | Description |
| --- | --- | --- |
| DependsOn | dict | Elenco delle entità del flusso di lavoro da cui dipende il processo. Per ulteriori informazioni, consulta [Utilizzo dell' DependsOn argomento](developing-blueprints-code-layout.md#developing-blueprints-code-layout-depends-on). |
| WaitForDependencies | str | Indica se il processo deve attendere fino a che tutte le entità da cui dipende sono complete prima dell'esecuzione o fino a quando è completa una qualsiasi. Per ulteriori informazioni, consulta [Usando l' WaitForDependencies argomento](developing-blueprints-code-layout.md#developing-blueprints-code-layout-wait-for-dependencies). Ometti se il processo dipende da una sola entità. |
| (Proprietà processo) | - | Qualsiasi proprietà del processo elencate in [Struttura del processo](aws-glue-api-jobs-job.md#aws-glue-api-jobs-job-Job) nella documentazione API AWS Glue (eccetto CreatedOn e LastModifiedOn). |
## Classe di crawler
La classe `Crawler` rappresenta un crawler AWS Glue.
**Argomenti dei costruttori obbligatori**
Di seguito sono illustrati gli argomenti dei costruttori obbligatori per la classe di `Crawler`.
| Nome argomento | Tipo | Description |
| --- | --- | --- |
| Name | str | Nome da assegnare al crawler. AWS Glue aggiunge un suffisso generato casualmente al nome per distinguere il crawler da quelli creati da altre esecuzioni del progetto. |
| Role | str | ARN del ruolo che il crawler deve assumere durante l'esecuzione. |
| Targets | dict | Raccolta di destinazioni da sottoporre al crawling. Gli argomenti dei costruttori della classe Targets sono definiti in [CrawlerTargets struttura](aws-glue-api-crawler-crawling.md#aws-glue-api-crawler-crawling-CrawlerTargets) nella documentazione API. Tutti gli argomenti dei costruttori Targets sono facoltativi, ma è necessario passarne almeno uno. |
**Argomenti dei costruttori facoltativi**
Di seguito sono illustrati gli argomenti dei costruttori facoltativi per la classe di `Crawler`.
| Nome argomento | Tipo | Description |
| --- | --- | --- |
| DependsOn | dict | Elenco delle entità del flusso di lavoro da cui dipende il crawler. Per ulteriori informazioni, consulta [Utilizzo dell' DependsOn argomento](developing-blueprints-code-layout.md#developing-blueprints-code-layout-depends-on). |
| WaitForDependencies | str | Indica se il crawler deve attendere fino a che tutte le entità da cui dipende sono complete prima dell'esecuzione o fino a quando è completa una qualsiasi. Per ulteriori informazioni, consulta [Usando l' WaitForDependencies argomento](developing-blueprints-code-layout.md#developing-blueprints-code-layout-wait-for-dependencies). Ometti se il crawler dipende da una sola entità. |
| (Proprietà dei crawler) | - | Qualsiasi proprietà del crawler elencata in [Struttura dei crawler](aws-glue-api-crawler-crawling.md#aws-glue-api-crawler-crawling-Crawler) nella documentazione API AWS Glue, con le seguenti eccezioni:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/developing-blueprints-code-classes.html) |
## Classe di flusso di lavoro
La classe `Workflow` rappresenta un flusso di lavoro AWS Glue. Lo script layout del flusso di lavoro restituisce un `Workflow`. AWS Glue crea un flusso di lavoro basato su questo oggetto.
**Argomenti dei costruttori obbligatori**
Di seguito sono illustrati gli argomenti dei costruttori obbligatori per la classe di `Workflow`.
| Nome argomento | Tipo | Description |
| --- | --- | --- |
| Name | str | Nome da assegnare al flusso di lavoro. |
| Entities | Entities | Insieme di entità (processi e crawler) da includere nel flusso di lavoro. Il costruttore di classi Entities accetta un argomento Jobs, che è un elenco di oggetti Job e un argomento Crawlers, che è un elenco di oggetti Crawler. |
**Argomenti dei costruttori facoltativi**
Di seguito sono illustrati gli argomenti dei costruttori facoltativi per la classe di `Workflow`.
| Nome argomento | Tipo | Description |
| --- | --- | --- |
| Description | str | Per informazioni, consulta [Struttura flusso di lavoro](aws-glue-api-workflow.md#aws-glue-api-workflow-Workflow). |
| DefaultRunProperties | dict | Per informazioni, consulta [Struttura flusso di lavoro](aws-glue-api-workflow.md#aws-glue-api-workflow-Workflow). |
| OnSchedule | str | Un'espressione cron. |
## Metodi di classe
Tutte e tre le classi includono i seguenti metodi.
**validate()**
Convalida le proprietà dell'oggetto e, se vengono rilevati errori, genera un messaggio ed esce. Non genera alcun output se non ci sono errori. Per la classe di `Workflow`, si richiama su ogni entità nel flusso di lavoro.
**to\$1json()**
Serializza l'oggetto in JSON. Chiama anche `validate()`. Per la classe di `Workflow`, l'oggetto JSON include elenchi di processi e crawler e un elenco di trigger generati dalle specifiche di dipendenza del processo e del crawler.
# Esempi di schema
Nel [Repository Github per i progetti AWS Glue](https://github.com/awslabs/aws-glue-blueprint-libs/tree/master/samples), sono disponibili diversi progetti di esempio . Questi esempi sono solo di riferimento e non sono destinati all'utilizzo.
I titoli dei progetti di esempio sono:
+ Compattazione: questo piano crea un lavoro che compatta i file di input in blocchi più grandi in base alla dimensione di file desiderata.
+ Conversione: questo piano converte i file di input in vari formati di file standard in formato Apache Parquet, ottimizzato per i carichi di lavoro analitici.
+ Crawling di posizioni Amazon S3: questo piano esegue il crawling di più posizioni Amazon S3 per aggiungere tabelle di metadati al catalogo dati.
+ Connessione personalizzata a Data Catalog: questo blueprint accede agli archivi dati utilizzando connettori AWS Glue personalizzati, legge i record e compila le definizioni delle tabelle nel AWS Glue Data Catalog in base allo schema dei record.
+ Codifica: questo piano converte i file non UTF in file codificati UTF.
+ Partizionamento: questo piano crea un processo di partizionamento che inserisce i file di output in partizioni basate su chiavi di partizione specifiche.
+ Importazione di dati Amazon S3 in una tabella DynamoDB: questo progetto importa i dati da Amazon S3 in una tabella DynamoDB.
+ Da tabella standard a governata: questo progetto importa una tabella AWS Glue Data Catalog in una tabella Lake Formation.
# Registrazione di uno schema in AWS Glue
Dopo che lo sviluppatore di AWS Glue ha codificato il progetto e caricato un archivio in formato ZIP su Amazon Simple Storage Service (Amazon S3), un amministratore di AWS Glue dovrà registrarlo. La registrazione del piano lo rende disponibile per l'uso.
Quando si registra un progetto, AWS Glue ne copia l'archivio in una posizione Amazon S3 riservata. È quindi possibile eliminare l'archivio dalla posizione di caricamento.
Per registrare un piano, hai bisogno delle autorizzazioni di lettura per la posizione Amazon S3 che contiene l'archivio caricato. È inoltre necessaria l'autorizzazione AWS Identity and Access Management (IAM)`glue:CreateBlueprint`. Per le autorizzazioni suggerite da concedere a un amministratore di AWS Glue che deve registrare, visualizzare e gestire i progetti, consulta [Autorizzazioni per i progetti per l'amministratore di AWS Glue per gli schemi](blueprints-personas-permissions.md#bp-persona-admin).
Puoi registrare un progetto utilizzando la console AWS Glue, l'API AWS Glue o la AWS Command Line Interface (AWS CLI).
**Per registrare un piano (console)**
1. Accertati di disporre delle autorizzazioni di lettura (`s3:GetObject`) per l'archivio ZIP del piano in Amazon S3.
1. Apri la console AWS Glue all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Accedi come un utente che dispone delle autorizzazioni per registrare un piano. Passa alla stessa regione AWS del bucket Amazon S3 che contiene l'archivio ZIP del piano.
1. Nel pannello di navigazione seleziona **schemi**. Quindi, nella pagina **schemi**, seleziona **Add blueprint** (aggiungi schema).
1. Immetti un nome e, facoltativamente, una descrizione.
1. Per **ZIP archive location (S3)** (Posizione archivio ZIP [S3]), inserisci il percorso Amazon S3 dell'archivio ZIP del piano caricato. Includi il nome del file di archivio nel percorso e inizia il percorso con `s3://`.
1. (Facoltativo) Aggiungi uno o più tag.
1. Scegli **Add blueprint** (Aggiungi piano).
La pagina **schemi** restituisce e mostra che lo stato del piano è `CREATING`. Seleziona il pulsante di aggiornamento fino a quando lo stato non cambia in `ACTIVE` o `FAILED`.
1. Se lo stato è `FAILED`, seleziona il piano e nella scheda **Actions** (Operazioni), scegli **View** (Visualizza).
La pagina dei dettagli mostra il motivo dell'errore. Se il messaggio dell'errore indica che è impossibile accedere all'oggetto nella posizione... o che è negato l'accesso sull'oggetto nella posizione..., verifica i requisiti seguenti:
+ L'utente con cui hai effettuato l'accesso deve disporre dell'autorizzazione di lettura per l'archivio ZIP del piano in Amazon S3.
+ Il bucket Amazon S3 che contiene l'archivio ZIP deve avere una policy sui bucket che conceda l'autorizzazione di lettura sull'oggetto all'ID del tuo account. AWS Per ulteriori informazioni, consulta [Sviluppo di schemi in AWS Glue](developing-blueprints.md).
+ Il bucket Amazon S3 che stai utilizzando deve trovarsi nella stessa regione di quella alla quale hai eseguito l'accesso sulla console.
1. Assicurati che gli analisti dei dati dispongano delle autorizzazioni per il piano.
La policy IAM suggerita per gli analisti di dati è mostrata in [Autorizzazioni per gli schemi per l'analista dati](blueprints-personas-permissions.md#bp-persona-analyst). Questa policy concede `glue:GetBlueprint` su qualsiasi risorsa. Se i criteri sono più granulari a livello di risorsa, concedi agli analisti di dati le autorizzazioni per questa risorsa appena creata.
**Per registrare un blueprint (AWS CLI)**
1. Inserisci il comando seguente.
```
aws glue create-blueprint --name [--description ] --blueprint-location s3:///
```
1. Immetti il seguente comando per verificare lo stato del piano. Ripeti il comando fino a quando lo stato non diventa `ACTIVE` o `FAILED`.
```
aws glue get-blueprint --name
```
Se lo stato è `FAILED` e il messaggio dell'errore indica che è impossibile accedere all'oggetto nella posizione... o che è negato l'accesso sull'oggetto nella posizione..., verifica i requisiti seguenti:
+ L'utente con cui hai effettuato l'accesso deve disporre dell'autorizzazione di lettura per l'archivio ZIP del piano in Amazon S3.
+ Il bucket Amazon S3 contenente l'archivio ZIP deve avere una policy sui bucket che conceda l'autorizzazione di lettura sull'oggetto all'ID del tuo account. AWS Per ulteriori informazioni, consulta [Pubblicazione di uno schema](developing-blueprints-publishing.md).
+ Il bucket Amazon S3 che stai utilizzando deve trovarsi nella stessa regione di quella alla quale hai eseguito l'accesso sulla console.
**Consulta anche:**
[Panoramica degli schemi in AWS Glue](blueprints-overview.md)
# Visualizzazione degli schemi in AWS Glue
Visualizza un piano per esaminare la descrizione, lo stato e le specifiche dei parametri del piano e scaricare l'archivio ZIP del piano.
Puoi visualizzare un progetto utilizzando la console AWS Glue, l'API AWS Glue o la AWS Command Line Interface (AWS CLI).
**Per visualizzare un piano (console)**
1. Apri la console AWS Glue all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Nel pannello di navigazione scegli **schemi**.
1. Nella pagina **schemi** seleziona uno schema. Quindi nel menu **Actions** (Operazioni), scegli **View** (Visualizza).
**Per visualizzare un blueprint (AWS CLI)**
+ Immetti il comando seguente per visualizzare solo il nome, la descrizione e lo stato del piano. Sostituisci ** con il nome del blueprint da visualizzare.
```
aws glue get-blueprint --name
```
L'output dei comandi è simile al seguente.
```
{
"Blueprint": {
"Name": "myDemoBP",
"CreatedOn": 1587414516.92,
"LastModifiedOn": 1587428838.671,
"BlueprintLocation": "s3://amzn-s3-demo-bucket1/demo/DemoBlueprintProject.zip",
"Status": "ACTIVE"
}
}
```
Immetti il seguente comando per visualizzare anche le specifiche di parametro.
```
aws glue get-blueprint --name --include-parameter-spec
```
L'output dei comandi è simile al seguente.
```
{
"Blueprint": {
"Name": "myDemoBP",
"CreatedOn": 1587414516.92,
"LastModifiedOn": 1587428838.671,
"ParameterSpec": "{\"WorkflowName\":{\"type\":\"String\",\"collection\":false,\"description\":null,\"defaultValue\":null,\"allowedValues\":null},\"PassRole\":{\"type\":\"String\",\"collection\":false,\"description\":null,\"defaultValue\":null,\"allowedValues\":null},\"DynamoDBTableName\":{\"type\":\"String\",\"collection\":false,\"description\":null,\"defaultValue\":null,\"allowedValues\":null},\"ScriptLocation\":{\"type\":\"String\",\"collection\":false,\"description\":null,\"defaultValue\":null,\"allowedValues\":null}}",
"BlueprintLocation": "s3://awsexamplebucket1/demo/DemoBlueprintProject.zip",
"Status": "ACTIVE"
}
}
```
Aggiungi l'argomento `--include-blueprint` per includere nell'output un URL che è possibile incollare nel browser per scaricare l'archivio ZIP del progetto archiviato in AWS Glue.
**Consulta anche:**
[Panoramica degli schemi in AWS Glue](blueprints-overview.md)
# Aggiornamento di uno schema in AWS Glue
Puoi aggiornare un piano se si hai uno script di layout revisionato, un set di parametri del piano revisionato o file di supporto revisionati. L'aggiornamento di un piano crea una nuova versione.
L'aggiornamento di un piano non influisce sui flussi di lavoro esistenti creati dal piano.
Puoi aggiornare un progetto utilizzando la console AWS Glue, l'API AWS Glue o la AWS Command Line Interface (AWS CLI).
La procedura seguente presuppone che lo sviluppatore di AWS Glue abbia creato e caricato un archivio in formato ZIP del progetto aggiornato su Amazon S3.
**Per aggiornare un piano (console)**
1. Accertati di disporre delle autorizzazioni di lettura (`s3:GetObject`) per l'archivio ZIP del piano in Amazon S3.
1. Apri la console AWS Glue all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Accedi come utente che dispone delle autorizzazioni per aggiornare un piano. Passa alla stessa regione AWS del bucket Amazon S3 che contiene l'archivio ZIP del piano.
1. Nel pannello di navigazione scegli **schemi**.
1. Nella pagina **schemi**, seleziona un piano e nella scheda **Actions** (operazioni) scegli **Edit** (modifica).
1. Nella pagina **Edit a blueprint** (Modifica un piano), aggiorna la **Description** (Descrizione) del piano o la **ZIP archive location (S3)** (Posizione dell'archivio ZIP [S3]). Assicurati di includere il nome del file di archivio nel percorso.
1. Seleziona **Save** (Salva).
La pagina **schemi** restituisce e mostra che lo stato dello schema è `UPDATING`. Seleziona il pulsante di aggiornamento fino a quando lo stato non cambia in `ACTIVE` o `FAILED`.
1. Se lo stato è `FAILED`, seleziona il piano e nella scheda **Actions** (Operazioni), scegli **View** (Visualizza).
La pagina dei dettagli mostra il motivo dell'errore. Se il messaggio dell'errore indica che è impossibile accedere all'oggetto nella posizione... o che è negato l'accesso sull'oggetto nella posizione..., verifica i requisiti seguenti:
+ L'utente con cui hai effettuato l'accesso deve disporre dell'autorizzazione di lettura per l'archivio ZIP del piano in Amazon S3.
+ Il bucket Amazon S3 che contiene l'archivio ZIP deve avere una policy sui bucket che conceda l'autorizzazione di lettura sull'oggetto all'ID del tuo account. AWS Per ulteriori informazioni, consulta [Pubblicazione di uno schema](developing-blueprints-publishing.md).
+ Il bucket Amazon S3 che stai utilizzando deve trovarsi nella stessa regione di quella alla quale hai eseguito l'accesso sulla console.
**Nota**
Se l'aggiornamento non riesce, l'esecuzione successiva del piano utilizza la versione più recente del piano correttamente registrata o aggiornata.
**Per aggiornare un piano (AWS CLI)**
1. Inserisci il comando seguente.
```
aws glue update-blueprint --name [--description ] --blueprint-location s3:///
```
1. Immetti il seguente comando per verificare lo stato del piano. Ripeti il comando fino a quando lo stato non diventa `ACTIVE` o `FAILED`.
```
aws glue get-blueprint --name
```
Se lo stato è `FAILED` e il messaggio dell'errore indica che è impossibile accedere all'oggetto nella posizione... o che è negato l'accesso sull'oggetto nella posizione..., verifica i requisiti seguenti:
+ L'utente con cui hai effettuato l'accesso deve disporre dell'autorizzazione di lettura per l'archivio ZIP del piano in Amazon S3.
+ Il bucket Amazon S3 contenente l'archivio ZIP deve avere una policy sui bucket che conceda l'autorizzazione di lettura sull'oggetto all'ID del tuo account. AWS Per ulteriori informazioni, consulta [Pubblicazione di uno schema](developing-blueprints-publishing.md).
+ Il bucket Amazon S3 che stai utilizzando deve trovarsi nella stessa regione di quella alla quale hai eseguito l'accesso sulla console.
**Consulta anche**
[Panoramica degli schemi in AWS Glue](blueprints-overview.md)
# Creazione di un flusso di lavoro da uno schema in AWS Glue
Puoi creare un flusso di lavoro AWS Glue manualmente, aggiungendo un componente alla volta, oppure puoi creare un flusso di lavoro da un [progetto](blueprints-overview.md) AWS Glue. AWS Glue include progetti per casi d'uso comuni. Gli sviluppatori di AWS Glue possono creare progetti aggiuntivi.
**Importante**
Limita il numero totale di processi, crawler e attivazioni all'interno di un flusso di lavoro a 100 o meno. Se includi più di 100, potresti riscontrare errori durante il tentativo di riprendere o interrompere l'esecuzione del flusso di lavoro.
Quando utilizzi un progetto, puoi generare rapidamente un flusso di lavoro per uno specifico caso d'uso basato sul caso d'uso generalizzato definito dal progetto. Puoi definire il caso d'uso specifico fornendo valori per i parametri del progetto. Ad esempio, un progetto che partiziona un set di dati potrebbe avere i percorsi di origine e destinazione di Amazon S3 come parametri.
AWS Glue crea un flusso di lavoro da un progetto *eseguendo* il progetto. L'esecuzione del progetto salva i valori dei parametri forniti e viene utilizzata per tenere traccia dell'avanzamento e dell'esito della creazione del flusso di lavoro e dei relativi componenti. Durante la risoluzione dei problemi di un flusso di lavoro, puoi sempre visualizzare l'esecuzione del progetto per determinare i valori dei parametri del progetto utilizzati per creare un flusso di lavoro.
Per creare e visualizzare i flussi di lavoro, è necessario disporre di determinate autorizzazioni IAM. Per la policy IAM suggerita, consulta [Autorizzazioni per gli schemi per l'analista dati](blueprints-personas-permissions.md#bp-persona-analyst).
Puoi creare un piano utilizzando la console AWS Glue, l'API AWS Glue o la AWS Command Line Interface (AWS CLI).
**Per creare un flusso di lavoro da un progetto (console)**
1. Apri la console AWS Glue all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Accedi come un utente che dispone delle autorizzazioni per creare un flusso di lavoro.
1. Nel pannello di navigazione seleziona **schemi**.
1. Seleziona un progetto e nel menu **Actions (Operazioni)**, scegli **Create workflow (Crea flusso di lavoro)**.
1. Nella pagina **Create a workflow from ** (Crea un flusso di lavoro da ), inserisci le seguenti informazioni:
**Parametri del progetto**
Questi variano in base alla progettazione del progetto. Per domande sui parametri, consulta lo sviluppatore. Gli schemi in genere includono un parametro per il nome del flusso di lavoro.
**Ruolo IAM**
Il ruolo che AWS Glue assume per creare il flusso di lavoro e i relativi componenti. Il ruolo deve disporre delle autorizzazioni per creare ed eliminare flussi di lavoro, processi, crawler e trigger. Per una policy suggerita per il ruolo, consulta [Autorizzazioni per i ruoli degli schemi](blueprints-personas-permissions.md#blueprints-role-permissions).
1. Seleziona **Invia**.
Viene visualizzata la pagina **Blueprint Details (Dettagli progetto)**, che mostra un elenco di esecuzioni del piano nella parte inferiore.
1. Nell'elenco delle esecuzioni del progetto, controlla lo stato della creazione del flusso di lavoro nell'esecuzione del progetto che si trova più in alto.
Lo stato iniziale è `RUNNING`. Seleziona il pulsante di aggiornamento fino a quando lo stato non diventa `SUCCEEDED` o `FAILED`.
1. Scegli una delle seguenti operazioni:
+ Se lo stato di completamento è `SUCCEEDED`, puoi passare alla pagina **Workflows** (Flussi di lavoro), selezionare il flusso di lavoro appena creato ed eseguirlo. Prima di eseguire il flusso di lavoro, è possibile esaminare il grafico di progettazione.
+ Se lo stato di completamento è `FAILED`, seleziona l'esecuzione del progetto e nel menu **Actions (Operazioni)**, scegli **View (Visualizza)** per vedere il messaggio di errore.
Per ulteriori informazioni sui flussi di lavoro e sui progetti, consulta i seguenti argomenti.
+ [Panoramica di flussi di lavoro in AWS Glue](workflows_overview.md)
+ [Aggiornamento di uno schema in AWS Glue](updating_blueprints.md)
+ [Creazione e costruzione manuale di un flusso di lavoro in AWS Glue](creating_running_workflows.md)
# Visualizzazione delle esecuzioni dello schema in AWS Glue
Visualizza l'esecuzione di un piano per vedere le seguenti informazioni:
+ Nome del flusso di lavoro che è stato creato.
+ Valori dei parametri dello schema utilizzati per creare il flusso di lavoro.
+ Stato dell'operazione di creazione del flusso di lavoro.
Puoi visualizzare l'esecuzione di un progetto utilizzando la console AWS Glue, l'API AWS Glue o la AWS Command Line Interface (AWS CLI).
**Per visualizzare l'esecuzione di un piano (console)**
1. Apri la console AWS Glue all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Nel pannello di navigazione scegli **schemi**.
1. Nella pagina **schemi** seleziona uno schema. Quindi nel menu **Actions** (Operazioni), scegli **View** (Visualizza).
1. Nella parte inferiore della finestra **Blueprint Details** (Dettagli piano), seleziona un'esecuzione del piano e nel menu **Actions** (Operazioni), scegli **View** (Visualizza).
**Per visualizzare l'esecuzione di un piano (AWS CLI)**
+ Inserire il seguente comando. Sostituisci ** con il nome del blueprint. Sostituisci ** con l'ID di esecuzione del blueprint.
```
aws glue get-blueprint-run --blueprint-name --run-id
```
**Consulta anche:**
[Panoramica degli schemi in AWS Glue](blueprints-overview.md)