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à.
# Orchestrazione in AWS Glue
Nelle sezioni seguenti vengono fornite informazioni sull’orchestrazione dei processi in AWS Glue.
**Topics**
+ [Avvio di lavori e crawler utilizzando i trigger](trigger-job.md)
+ [Esecuzione di attività ETL complesse utilizzando gli schemi e i flussi di lavoro in AWS Glue](orchestrate-using-workflows.md)
+ [Sviluppo di schemi in AWS Glue](orchestrate-using-blueprints.md)
# Avvio di lavori e crawler utilizzando i trigger
In AWS Glue, è possibile creare oggetti del catalogo dati chiamati trigger, che è possibile utilizzare per avviare manualmente o automaticamente uno o più crawler o estrarre, trasformare e caricare lavori (ETL). Utilizzando i trigger, è possibile progettare una catena di crawler e lavori dipendenti.
**Nota**
È possibile eseguire la stessa procedura definendo i *flussi di lavoro*. I flussi di lavoro sono i preferiti nella creazione di complesse operazioni ETL multi-processo. Per ulteriori informazioni, consulta [Esecuzione di attività ETL complesse utilizzando gli schemi e i flussi di lavoro in AWS Glue](orchestrate-using-workflows.md).
**Topics**
+ [Trigger di AWS Glue](about-triggers.md)
+ [Aggiunta di trigger](console-triggers.md)
+ [Attivazione e disattivazione dei trigger](activate-triggers.md)
# Trigger di AWS Glue
Quando viene *attivato*, un trigger può avviare processi e crawler specificati. Un trigger viene attivato on demand, in base a una pianificazione o in base a una combinazione di eventi.
**Nota**
Solo due crawler possono essere attivati da un singolo trigger. Se vuoi eseguire il crawling di più datastore, utilizza più fonti per ogni crawler anziché eseguire più crawler contemporaneamente.
Esistono diversi stati di trigger. Un trigger è `CREATED`, `ACTIVATED` o `DEACTIVATED`. Esistono anche stati transitori, come ad esempio `ACTIVATING`. Per interrompere temporaneamente l'attivazione di un trigger, è possibile disattivarlo. È quindi possibile riattivarlo in un secondo momento.
Esistono tre tipi di trigger:
**Pianificato**
Un trigger basato sul tempo in `cron`.
È possibile creare un trigger per un set di lavori o crawler in base a una pianificazione. È possibile specificare i vincoli, ad esempio la frequenza in cui vengono eseguiti i lavori o i crawler, i giorni della settimana in cui vengono eseguiti e a che ora. Questi vincoli si basano sul comando `cron`. Quando si configura una pianificazione per un trigger, tenere conto delle caratteristiche e delle limitazioni del cron. Ad esempio, se vuoi eseguire il crawler il giorno 31 di ogni mese, devi ricordare che alcuni mesi non sono di 31 giorni. Per ulteriori informazioni sul cron, consulta [Pianificazioni basate sul tempo per processi e crawler](monitor-data-warehouse-schedule.md).
**Condizionale**
Un trigger che viene attivato quando un lavoro o crawler o più lavori o crawler precedenti soddisfano un elenco di condizioni.
Quando si crea un trigger condizionale, si specificano un elenco di lavori e un elenco di crawler da controllare. Per ogni lavoro o crawler controllato, è necessario specificare uno stato da controllare, ad esempio riuscito, non riuscito, timeout e così via. Il trigger viene attivato se i lavori o i crawler controllati terminano con gli stati specificati. È possibile configurare il trigger per l'attivazione quando si verificano uno o tutti gli eventi osservati.
Ad esempio, è possibile configurare un trigger T1 per avviare il lavoro J3 quando entrambi i lavori J1 e J2 vengono completati correttamente e un altro trigger T2 per avviare il lavoro J4 se il lavoro J1 o J2 non riesce.
Nella tabella seguente sono elencati gli stati di completamento del lavoro e del crawler (eventi) controllati dai trigger.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/about-triggers.html)
**On demand**
Un trigger che si attiva quando viene acceso. I trigger su richiesta non entrano mai nello stato `ACTIVATED` o `DEACTIVATED`. Rimangono sempre nello stato `CREATED`.
Affinché si attivino non appena creati, è possibile impostare un flag per attivare i trigger pianificati e condizionali al momento della creazione.
**Importante**
I lavori o i crawler eseguiti dopo il completamento di altri processi o crawler vengono definiti *dipendenti*. I lavori o i crawler dipendenti vengono avviati solo se il lavoro o il crawler completato è stato avviato da un trigger. Tutti i lavori o i crawler in una catena di dipendenze devono discendere da una singola **pianificazione** o da un singolo trigger **on-demand**.
**Passare i parametri del lavoro con i trigger**
Un trigger può passare parametri ai lavori che avvia. I parametri includono argomenti del lavoro, valore di timeout, configurazione di sicurezza e altro ancora. Se il trigger avvia più lavori, i parametri vengono passati a ciascun lavoro.
Di seguito sono riportate le regole per argomenti di lavoro passati da un trigger:
+ Se la chiave nella coppia chiave-valore corrisponde a un argomento di lavoro predefinito, l'argomento passato sostituisce l'argomento predefinito. Se la chiave non corrisponde a un argomento predefinito, l'argomento viene passato come argomento aggiuntivo al lavoro.
+ Se la chiave nella coppia chiave-valore corrisponde a un argomento non sovrascrivibile, l'argomento passato viene ignorato.
Per ulteriori informazioni, consulta [Triggers](aws-glue-api-jobs-trigger.md) nell'API AWS Glue.
# Aggiunta di trigger
Puoi aggiungere un trigger utilizzando la AWS Glue console, il AWS Command Line Interface (AWS CLI) o l'AWS GlueAPI.
**Per aggiungere un trigger (console)**
1. Accedi a Console di gestione AWS e apri la AWS Glue console all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Nel riquadro di navigazione, in **ETL**, scegliere **Triggers (Trigger)**. Selezionare **Add trigger (Aggiungi trigger)**.
1. Specificare le proprietà seguenti:
**Name**
Assegna al trigger un nome univoco.
**Tipo di trigger**
Specifica una delle seguenti proprietà:
+ **Schedule (Pianifica):** il trigger si attiva a una frequenza e un tempo specifici.
+ **Job events (Eventi di lavoro):** un trigger condizionale. Il trigger viene attivato quando uno o tutti i lavori nell'elenco corrispondono agli stati designati. Per consentire l'attivazione del trigger, il lavoro in questione deve essere stato avviato da un trigger. Per qualsiasi lavoro selezionato, è possibile osservare un solo evento (stato di completamento).
+ **On-demand (On demand):** il trigger funziona se attivato.
1. Completare la procedura guidata del trigger. Nella pagina **Review (Revisione)** è possibile attivare immediatamente i trigger **Schedule (Pianifica)** e **Job events (Eventi di lavoro)** (condizionali), selezionando **Enable trigger on creation (Attiva trigger alla creazione)**.
**Per aggiungere un trigger (AWS CLI)**
+ Utilizzare un comando simile al seguente:
```
aws glue create-trigger --name MyTrigger --type SCHEDULED --schedule "cron(0 12 * * ? *)" --actions CrawlerName=MyCrawler --start-on-creation
```
Questo comando crea un trigger di pianificazione denominato `MyTrigger`, che viene eseguito ogni giorno alle 12:00 UTC e avvia un crawler denominato `MyCrawler`. Il trigger viene creato nello stato attivato.
Per ulteriori informazioni, consulta [Trigger di AWS Glue](about-triggers.md).
# Pianificazioni basate sul tempo per processi e crawler
Puoi definire una pianificazione basata sul tempo per i crawler e i processi in AWS Glue. La definizione di queste pianificazioni usa la sintassi [cron](http://en.wikipedia.org/wiki/Cron) di tipo Unix. Specifichi il tempo in [Coordinated Universal Time (UTC)](http://en.wikipedia.org/wiki/Coordinated_Universal_Time) e la precisione minima per una pianificazione è 5 minuti.
Per ulteriori informazioni sulla configurazione di processi e crawler da eseguire utilizzando una pianificazione, consulta [Avvio di lavori e crawler utilizzando i trigger](trigger-job.md).
## Espressioni Cron
Le espressioni Cron hanno sei campi obbligatori separati da uno spazio vuoto.
**Sintassi**
```
cron(Minutes Hours Day-of-month Month Day-of-week Year)
```
| **Campi** | **Valori** | **Caratteri jolly** |
| --- | --- | --- |
| Minuti | 0-59 | , - \$1 / |
| Ore | 0-23 | , - \$1 / |
| D ay-of-month | 1-31 | , - \$1 ? / L W |
| Mese | 1-12 o JAN-DEC | , - \$1 / |
| D ay-of-week | 1-7 o SUN-SAT | , - \$1 ? / L |
| Anno | 1970–2199 | , - \$1 / |
**Caratteri jolly**
+ Il carattere jolly **,** (virgola) include valori aggiuntivi. Nel campo `Month`, `JAN,FEB,MAR` includono gennaio, febbraio e marzo.
+ Il carattere jolly **-** (trattino) specifica gli intervalli. Nel campo `Day`, 1-15 include i giorni dall'1 al 15 del mese specificato.
+ Il carattere jolly **\$1** (asterisco) include tutti i valori nel campo. Nel campo `Hours`, **\$1** include ogni ora.
+ Il carattere jolly **/** (barra) specifica gli incrementi. Nel campo `Minutes` puoi immettere **1/10** per specificare ogni decimo minuto, a partire dal primo minuto dell'ora (ad esempio, l'11°, il 21° e il 31° minuto).
+ Il carattere jolly **?** (punto interrogativo) specifica un valore. **Nel `Day-of-month` campo puoi inserire **7**, e se non ti interessa in che giorno della settimana è il settimo, puoi inserire?** sul Day-of-week campo.
+ Il carattere jolly **L** nel campo `Day-of-month` o `Day-of-week` specifica l'ultimo giorno del mese o della settimana.
+ Il carattere jolly **W** nel campo `Day-of-month` specifica un giorno feriale. Nel campo `Day-of-month`, `3W` specifica il giorno più vicino al terzo giorno feriale del mese.
**Limits**
+ Non puoi specificare i campi `Day-of-month` e `Day-of-week` nella stessa espressione cron. Se specifichi un valore in uno dei campi, devi usare un carattere **?** nell'altro campo.
+ Le espressioni cron che indicano frequenze più rapide di 5 minuti non sono supportate.
**Esempi**
Quando crei una pianificazione puoi utilizzare le seguenti stringhe cron di esempio.
| Minuti | Ore | Giorno del mese | Mese | Giorno della settimana | Anno | Significato |
| --- | --- | --- | --- | --- | --- | --- |
| 0 | 10 | \$1 | \$1 | ? | \$1 | Esegui ogni giorno alle 10:00 (UTC) |
| 15 | 12 | \$1 | \$1 | ? | \$1 | Esegui ogni giorno alle 12:15 (UTC) |
| 0 | 18 | ? | \$1 | LUN-VEN | \$1 | Esegui dal lunedì al venerdì alle 18:00 (UTC) |
| 0 | 8 | 1 | \$1 | ? | \$1 | Esegui ogni primo giorno del mese alle 8.00 (UTC) |
| 0/15 | \$1 | \$1 | \$1 | ? | \$1 | Esegui ogni 15 minuti |
| 0/10 | \$1 | ? | \$1 | LUN-VEN | \$1 | Esegui dal lunedì al venerdì ogni 10 minuti |
| 0/5 | 8-17 | ? | \$1 | LUN-VEN | \$1 | Esegui dal lunedì al venerdì dalle 8:00 alle 17:55 (UTC) ogni 5 minuti |
Ad esempio, per eseguire una pianificazione ogni giorno alle 12:15 UTC, specifica:
```
cron(15 12 * * ? *)
```
# Attivazione e disattivazione dei trigger
Puoi attivare o disattivare un trigger utilizzando la AWS Glue console, il AWS Command Line Interface (AWS CLI) o l'AWS GlueAPI.
**Per attivare o disattivare un trigger (console)**
1. Accedi Console di gestione AWS e apri la AWS Glue console all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Nel riquadro di navigazione, in **ETL**, scegliere **Triggers (Trigger)**.
1. Selezionare la casella di controllo accanto al trigger desiderato e nel menu **Action (Operazione)** scegliere **Enable trigger (Abilita trigger)** per attivare il trigger o **Disable trigger (Disattiva trigger)** per disattivare il trigger.
**Per attivare o disattivare un trigger (AWS CLI)**
+ Inserisci uno dei comandi seguenti.
```
aws glue start-trigger --name MyTrigger
aws glue stop-trigger --name MyTrigger
```
Un trigger viene attivato con l'avvio e viene disattivato con l'arresto. Quando un trigger si attiva on demand, il funzionamento è immediato.
Per ulteriori informazioni, consulta [Trigger di AWS Glue](about-triggers.md).
# Esecuzione di attività ETL complesse utilizzando gli schemi e i flussi di lavoro in AWS Glue
Alcuni dei processi di estrazione, trasformazione e caricamento (ETL) della tua organizzazione potrebbero essere implementati utilizzando più processi e crawler dipendenti AWS Glue. Con i *flussi di lavoro* di AWS Glue, puoi progettare una complessa operazione ETL multi-processo e multi-crawler che AWS Glue può eseguire e tracciare come singola entità. Dopo aver creato un flusso di lavoro e averne specificato i processi, i crawler e i trigger, puoi eseguire il flusso di lavoro on demand o in base a una pianificazione.
**Topics**
+ [Panoramica di flussi di lavoro in AWS Glue](workflows_overview.md)
+ [Creazione e costruzione manuale di un flusso di lavoro in AWS Glue](creating_running_workflows.md)
+ [Avvio di un AWS Glue flusso di lavoro con un EventBridge evento Amazon](starting-workflow-eventbridge.md)
+ [Visualizzazione degli EventBridge eventi che hanno avviato un flusso di lavoro](viewing-start-event-info.md)
+ [Esecuzione e monitoraggio di un flusso di lavoro in AWS Glue](running_monitoring_workflow.md)
+ [Arresto dell'esecuzione di un flusso di lavoro](workflow-stopping.md)
+ [Ripresa e ripristino dell'esecuzione di un flusso di lavoro](resuming-workflow.md)
+ [Recupero e impostazione delle proprietà di esecuzione del flusso di lavoro in AWS Glue](workflow-run-properties-code.md)
+ [Interrogazione dei flussi di lavoro utilizzando AWS Glue API](workflows_api_concepts.md)
+ [Restrizioni dei flussi di lavoro e degli schemi in AWS Glue](blueprint_workflow_restrictions.md)
+ [Risoluzione degli errori relativi agli schemi in AWS Glue](blueprint_workflow_troubleshoot.md)
+ [Autorizzazioni per utenti e ruoli per gli schemi AWS Glue](blueprints-personas-permissions.md)
# Panoramica di flussi di lavoro in AWS Glue
In AWS Glue, è possibile utilizzare i flussi di lavoro per creare e visualizzare complesse attività di estrazione, trasformazione e caricamento (ETL) che coinvolgono più crawler, processi e trigger. Ogni flusso di lavoro gestisce l'esecuzione e il monitoraggio di tutti i suoi processi e crawler. Poiché un flusso di lavoro esegue ogni componente, registra l'avanzamento e lo stato di esecuzione. In questo modo viene fornita una panoramica dell'attività complessiva e i dettagli di ciascuna fase. La console di AWS Glue offre una rappresentazione visiva di un flusso di lavoro sotto forma di diagramma.
È possibile creare un flusso di lavoro da un AWS Glue blueprint oppure è possibile creare manualmente un flusso di lavoro un componente alla volta utilizzando Console di gestione AWS o il AWS Glue API. Per ulteriori informazioni sui piani, consulta [Panoramica degli schemi in AWS Glue](blueprints-overview.md).
I *trigger* all'interno dei flussi di lavoro possono attivare sia processi che crawler e possono attivarsi quando i processi o i crawler vengono completati. Utilizzando i trigger è possibile creare grandi catene di processi e crawler interdipendenti. Oltre ai trigger all'interno di un flusso di lavoro che definiscono le dipendenze dei processi e dei crawler, ogni flusso di lavoro dispone di un *trigger di avvio*. Esistono tre tipi di trigger di avvio:
+ **Pianificazione**: il flusso di lavoro viene avviato secondo una pianificazione definita. La pianificazione può essere giornaliera, settimanale, mensile e così via oppure può essere una personalizzata in base a un'espressione `cron`.
+ **Su richiesta**: il flusso di lavoro viene avviato manualmente dalla AWS Glue console, dall'API o AWS CLI.
+ **EventBridge evento**: il flusso di lavoro viene avviato al verificarsi di un singolo EventBridge evento Amazon o di un batch di EventBridge eventi Amazon. Con questo tipo di trigger, AWS Glue può essere un consumer di eventi in un'architettura basata su eventi. Qualsiasi tipo di EventBridge evento può avviare un flusso di lavoro. Un caso d'uso ìcomune è l'arrivo di un nuovo oggetto in un bucket Amazon S3 (l'operazione `PutObject` di S3).
Avviare un flusso di lavoro con un batch di eventi significa attendere fino a quando non è stato ricevuto un numero specificato di eventi o fino a quando non è trascorso un determinato periodo di tempo. Quando crei il trigger EventBridge dell'evento, puoi facoltativamente specificare le condizioni del batch. Se si specificano le condizioni del batch, è necessario specificare la dimensione del batch (numero di eventi) e, facoltativamente, è possibile specificare una finestra batch (numero di secondi). La dimensione massima di default della finestra è di 900 secondi (15 minuti). La condizione batch che viene soddisfatta per prima avvia il flusso di lavoro. La finestra batch si avvia all'arrivo del primo evento. Se durante la creazione di un trigger non si specificano le condizioni di batch, la dimensione del batch viene impostata automaticamente su 1.
All'avvio del flusso di lavoro, le condizioni di batch vengono reimpostate e il trigger di evento inizia a monitorare la condizione di batch successiva da soddisfare per avviare nuovamente il flusso di lavoro.
Nella tabella seguente viene illustrato il modo in cui le dimensioni batch e la finestra batch operano insieme per attivare un flusso di lavoro.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/workflows_overview.html)
L'operazione API `GetWorkflowRun` restituisce la condizione batch che ha attivato il flusso di lavoro.
Indipendentemente dalla modalità di avvio di un flusso di lavoro, è possibile specificare il numero massimo di esecuzioni simultanee durante la creazione del flusso di lavoro.
Se un evento o un batch di eventi avvia un'esecuzione del flusso di lavoro che alla fine ha esito negativo, tale evento o batch di eventi non viene più considerato per l'avvio di un'esecuzione del flusso di lavoro. Un nuovo flusso di lavoro viene avviato solo quando arriva l'evento o il batch di eventi successivo.
**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.
Un'esecuzione del flusso di lavoro non verrà avviata se supererà il limite di concorrenza impostato per il flusso di lavoro, anche se la condizione dell'evento è soddisfatta. È consigliabile modificare i limiti di simultaneità del flusso di lavoro in base al volume degli eventi previsti. AWS Glue non ritenta le esecuzioni del flusso di lavoro che non riescono a causa di limiti di simultaneità superati. Allo stesso modo, è consigliabile modificare i limiti di simultaneità per i processi e i crawler all'interno dei flussi di lavoro in base al volume degli eventi previsto.
**Proprietà esecuzione flusso di lavoro**
Per condividere e gestire lo stato di un flusso di lavoro in esecuzione, è possibile definire le proprietà dell'esecuzione di flussi di lavoro di default. Queste proprietà, che sono name/value coppie, sono disponibili per tutti i lavori del flusso di lavoro. Utilizzando AWS Glue API, i job possono recuperare le proprietà di esecuzione del flusso di lavoro e modificarle per i lavori successivi nel flusso di lavoro.
**Grafico del flusso di lavoro**
L'immagine seguente mostra il grafico di un flusso di lavoro basato sulla console di AWS Glue. Un flusso di lavoro potrebbe essere composto da dozzine di componenti.
![\[Schermata della console che mostra la scheda Graph (Grafico) di un flusso di lavoro. Il grafico contiene cinque icone che rappresentano un trigger di pianificazione, due processi, un trigger basato su un evento di completamento corretto e un crawler che aggiorna lo schema.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/graph-complete-with-tabs.png)
Questo flusso di lavoro viene avviato da un trigger di pianificazione, `Month-close1`, che avvia due processi, `De-duplicate` e `Fix phone numbers`. Al corretto completamento di entrambi i processi, un trigger di evento, `Fix/De-dupe succeeded`, avvia un crawler, `Update schema`.
**Visualizzazioni del flusso di lavoro statica e dinamica**
Per ogni flusso di lavoro, esiste il concetto di *visualizzazione statica* e *visualizzazione dinamica*. La visualizzazione statica descrive la struttura del flusso di lavoro. La visualizzazione dinamica è una visualizzazione in fase di runtime che include le informazioni sull'ultima esecuzione di ognuno dei processi e dei crawler. Le informazioni sull'esecuzione includono l'esito finale e i dettagli degli errori.
Quando un flusso di lavoro è in esecuzione, la console mostra la visualizzazione dinamica, che indica graficamente i processi che si sono conclusi e quelli che devono ancora essere eseguiti. È anche possibile recuperare una visualizzazione dinamica di un flusso di lavoro in esecuzione utilizzando la AWS Glue API. Per ulteriori informazioni, consulta [Interrogazione dei flussi di lavoro utilizzando AWS Glue API](workflows_api_concepts.md).
**Consulta anche**
[Creazione di un flusso di lavoro da uno schema in AWS Glue](creating_workflow_blueprint.md)
[Creazione e costruzione manuale di un flusso di lavoro in AWS Glue](creating_running_workflows.md)
[Flussi di lavoro](aws-glue-api-workflow.md) (per l'API dei flussi di lavoro)
# Creazione e costruzione manuale di un flusso di lavoro in AWS Glue
Puoi utilizzare la console AWS Glue per creare e costruire manualmente un flusso di lavoro, un nodo alla volta.
Un flusso di lavoro contiene processi, crawler e trigger. Prima di creare un flusso di lavoro manualmente, è necessario creare i processi e i crawler che devono essere inclusi nel flusso di lavoro. È preferibile specificare i run-on-demand crawler per i flussi di lavoro. È possibile creare nuovi trigger durante la creazione del flusso di lavoro oppure è possibile *clonare* i trigger già esistenti nel flusso di lavoro. Quando si clona un trigger, tutti gli oggetti catalogo associati al trigger, ovvero i processi o i crawler che lo attivano e i processi o crawler che avvia, vengono aggiunti al flusso di lavoro.
**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.
È possibile creare il proprio flusso di lavoro aggiungendo trigger al diagramma del flusso di lavoro e definendo gli eventi osservati e le operazioni di ogni trigger. Si inizia con un *trigger di attivazione*, che può essere un trigger on demand o pianificato, e si completa il diagramma aggiungendo trigger basati su evento (condizionali).
## Fase 1: creazione del flusso di lavoro
1. Accedi a Console di gestione AWS e apri la console all' AWS Glue indirizzo. [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)
1. Nel pannello di navigazione, in **ETL**, scegliere **Workflows (Flussi di lavoro)**.
1. Scegliere **Add workflow (Aggiungi flusso di lavoro)** e completare il modulo **Add a new ETL workflow (Aggiungi un nuovo flusso di lavoro ETL)**.
Qualsiasi proprietà opzionale di default per l'esecuzione aggiuntiva viene resa disponibile come argomento a tutti i processi del flusso di lavoro. Per ulteriori informazioni, consulta [Recupero e impostazione delle proprietà di esecuzione del flusso di lavoro in AWS Glue](workflow-run-properties-code.md).
1. Scegliere **Add workflow (Aggiungi flusso di lavoro)**.
Il nuovo flusso di lavoro verrà visualizzato nell'elenco sulla pagina **Workflows (Flussi di lavoro)**.
## Fase 2: aggiunta di un trigger di attivazione
1. Nella pagina **Workflows (Flussi di lavoro)**, selezionare il nuovo flusso di lavoro. Quindi, nella parte inferiore della pagina, assicurarsi che **grafico ** sia selezionato.
1. Scegliere **Add trigger (Aggiungi trigger)** e nella finestra di dialogo **Add trigger (Aggiungi trigger)**, procedere in uno dei seguenti modi:
+ Scegliere **Clone existing (Clona esistente)** e scegliere un trigger da clonare. Quindi scegliere **Add (Aggiungi)**.
Il trigger viene visualizzato sul diagramma, insieme ai processi e ai crawler che lo attivano e i processi o i crawler che lancia.
Se è stato selezionato inavvertitamente il trigger sbagliato, selezionare il trigger nel diagramma e quindi scegliere **Remove (Rimuovi)**.
+ Scegliere **Add new (Aggiungi nuovo)** e completare il modulo **Add trigger (Aggiungi trigger)**.
1. Per il **tipo di trigger**, seleziona **Pianificazione**, **Su richiesta** o **EventBridgeEvento**.
Per il tipo di trigger **Schedule (Pianificazione)**, scegliere una delle opzioni di **Frequency (Frequenza)**. Scegliere **Custom (Personalizza)** per immettere un'espressione `cron`.
Per l'**EventBridge evento** di tipo trigger, inserisci **Numero di eventi** (dimensione del batch) e, facoltativamente, inserisci **Ritardo temporale** (finestra del batch). Omettendo **Time delay (Ritardo)**, la finestra batch viene impostata per impostazione predefinita su 15 minuti. Per ulteriori informazioni, consulta [Panoramica di flussi di lavoro in AWS Glue](workflows_overview.md).
1. Scegliere **Aggiungi**.
Il trigger viene visualizzato sul diagramma, insieme a un nodo segnaposto nodo (etichettato **Add node (Aggiungi nodo)**). Nell'esempio seguente, il trigger di avvio è un trigger di pianificazione denominato `Month-close1`.
A questo punto, il trigger non è ancora salvato.
![\[Un diagramma con due nodi rettangolari: un trigger e un nodo segnaposto. Una freccia va dal nodo trigger al nodo segnaposto.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/graph-start-trigger.png)
1. Se è stato aggiunto un nuovo trigger, completare i seguenti passaggi:
1. Esegui una delle seguenti operazioni:
+ Scegliere il nodo segnaposto (**Add node (Aggiungi nodo)**).
+ Assicurati che il trigger di avvio sia selezionato e nel menu **Azione** sopra il grafico, scegli **Aggiungi jobs/crawlers al trigger**.
1. Nella finestra di dialogo **Add jobs(s) and crawler(s) to trigger (Aggiungi processo/i e crawler al trigger)** selezionare uno o più processi o crawler e quindi scegliere **Add (Aggiungi)**.
Il trigger viene salvato e i processi o crawler selezionati vengono visualizzati sul diagramma con connettori che hanno origine dal trigger.
Se sono stati aggiunti inavvertitamente processi o crawler sbagliati, è possibile selezionare il trigger o un connettore e scegliere **Remove (Rimuovi)**.
## Fase 3: aggiunta di più trigger
Continuare a creare il flusso di lavoro aggiungendo ulteriori trigger di tipo **Event (Evento)**. Per incrementare o ridurre il livello di dettaglio o per ingrandire l'area di disegno del diagramma, utilizzare le icone a destra. Per ogni trigger da aggiungere, completare i seguenti passaggi:
**Nota**
Non viene eseguita alcuna azione per salvare il flusso di lavoro. Dopo aver aggiunto l'ultimo trigger e assegnato azioni al trigger, il flusso di lavoro è completato e salvato. È sempre possibile tornare successivamente e aggiungere altri nodi.
1. Esegui una delle seguenti operazioni:
+ Per clonare un trigger esistente, accertarsi che non sia selezionato nessun nodo del diagramma e, nel menu **Action (Operazione)**, scegliere **Add trigger (Aggiungi trigger)**.
+ Per aggiungere un nuovo trigger che monitori un determinato processo o crawler del diagramma, selezionare il nodo del processo o del crawler e quindi scegliere il nodo segnaposto **Add trigger (Aggiungi trigger)**.
È possibile aggiungere ulteriori processi o crawler da far monitorare a questo trigger in un secondo momento.
1. Nella finestra di dialogo **Add Folder (Aggiungi cartella)**, effettuare una delle operazioni indicate di seguito:
+ Scegliere **Add new (Aggiungi nuovo)** e completare il modulo **Add trigger (Aggiungi trigger)**. Quindi scegliere **Add (Aggiungi)**.
Il trigger viene visualizzato sul diagramma. È possibile completare il trigger in un secondo momento.
+ Scegliere **Clone existing (Clona esistente)** e scegliere un trigger da clonare. Quindi scegliere **Add (Aggiungi)**.
Il trigger viene visualizzato sul diagramma, insieme ai processi e ai crawler che lo attivano e i processi o i crawler che lancia.
Se è stato selezionato inavvertitamente il trigger sbagliato, selezionare il trigger nel diagramma e quindi scegliere **Remove (Rimuovi)**.
1. Se è stato aggiunto un nuovo trigger, completare i seguenti passaggi:
1. Selezionare il nuovo trigger.
Come mostra il seguente diagramma, il trigger `De-dupe/fix succeeded` è selezionato e i nodi segnaposto appaiono per (1) eventi da monitorare e (2) operazioni.
![\[Un diagramma con molti nodi, due dei quali sono nodi segnaposto che sono indicati con i numeri 1 e 2.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/graph-dual-placeholders.png)
1. (Facoltativo se il trigger monitora già un evento e si desidera aggiungere ulteriori processi o crawler da monitorare) Scegliete il nodo events-to-watch segnaposto e nella finestra di dialogo **Aggiungi lavori e crawler da visualizzare**, selezionate uno o più lavori o crawler. Scegli un evento da monitorare (SUCCEEDED, FAILED, ecc.) e scegliere **Add (Aggiungi)**.
1. Verificare che il trigger sia selezionato e scegliere il nodo segnaposto delle operazioni.
1. Nella finestra di dialogo **Add job(s) and crawler(s) to watch (Aggiungi processo/i e crawler da monitorare)**, selezionare uno o più processi o crawler e scegliere **Add (Aggiungi)**.
I processi e crawler selezionati vengono visualizzati sul diagramma con connettori che hanno origine dal trigger.
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)
+ [Esecuzione e monitoraggio di un flusso di lavoro in AWS Glue](running_monitoring_workflow.md)
+ [Creazione di un flusso di lavoro da uno schema in AWS Glue](creating_workflow_blueprint.md)
# Avvio di un AWS Glue flusso di lavoro con un EventBridge evento Amazon
Amazon EventBridge, noto anche come CloudWatch Events, ti consente di automatizzare AWS i tuoi servizi e rispondere automaticamente a eventi di sistema come problemi di disponibilità delle applicazioni o modifiche delle risorse. Gli eventi dei AWS servizi vengono forniti quasi EventBridge in tempo reale. Puoi compilare regole semplici che indichino quali eventi sono considerati di interesse per te e quali azioni automatizzate intraprendere quando un evento corrisponde a una regola.
Con EventBridge il supporto, AWS Glue può fungere da produttore e consumatore di eventi in un'architettura basata sugli eventi. Per quanto riguarda i flussi di lavoro, AWS Glue supporta qualsiasi tipo di EventBridge evento come consumatore. Il caso d'uso più comune è l'arrivo di un nuovo oggetto in un bucket Amazon S3. Se si dispone di dati che arrivano a intervalli irregolari o non definiti, è possibile elaborare questi dati il più vicino possibile al loro arrivo.
**Nota**
AWS Gluenon fornisce la consegna garantita dei EventBridge messaggi. AWS Gluenon esegue alcuna deduplicazione se EventBridge recapita messaggi duplicati. È necessario gestire l'idempotenza in base al proprio caso d'uso.
Assicurati di configurare correttamente EventBridge le regole per evitare l'invio di eventi indesiderati.
**Prima di iniziare**
Se desideri avviare un flusso di lavoro con gli eventi relativi ai dati di Amazon S3, devi assicurarti che gli eventi per il bucket S3 di interesse siano registrati su e. AWS CloudTrail EventBridge A tale scopo, è necessario creare un percorso. CloudTrail Per ulteriori informazioni, vedi [Creazione di un percorso per il tuo AWS account](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html).
**Per avviare un flusso di lavoro con un EventBridge evento**
**Nota**
Nei comandi seguenti, sostituisci:
**con il nome da assegnare al flusso di lavoro.
**con il nome da assegnare al trigger.
**con il nome del bucket Amazon S3.
**con un ID AWS account valido.
**con il nome della regione (ad esempio,`us-east-1`).
**con il nome da assegnare alla EventBridge regola.
1. Assicurati di disporre delle autorizzazioni AWS Identity and Access Management (IAM) per creare e visualizzare EventBridge regole e obiettivi. Di seguito è riportato una policy di esempio che è possibile allegare. Potresti ridurre il suo ambito per applicare restrizioni alle operazioni e alle risorse.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"events:PutRule",
"events:DisableRule",
"events:DeleteRule",
"events:PutTargets",
"events:RemoveTargets",
"events:EnableRule",
"events:List*",
"events:Describe*"
],
"Resource": "*"
}
]
}
```
------
1. Crea un ruolo IAM che il EventBridge servizio possa assumere quando trasmette un evento. AWS Glue
1. Nella pagina **Create role** (Crea ruolo) della console IAM, seleziona **Service AWS ** (Servizio AWS ). Quindi scegli il servizio **CloudWatch Eventi**.
1. Completa la procedura guidata **Create role** (Crea ruolo). La procedura guidata allega automaticamente il `CloudWatchEventsBuiltInTargetExecutionAccess` e le policy `CloudWatchEventsInvocationAccess`.
1. Allega la seguente policy inline al ruolo. Questa politica consente al EventBridge servizio di indirizzare gli eventi versoAWS Glue.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:notifyEvent"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:workflow/workflow-name"
]
}
]
}
```
------
1. Inserisci il seguente comando per creare il flusso di lavoro.
Per ulteriori informazioni sui parametri della riga di comando aggiuntivi, consulta [create-workflow](https://docs.aws.amazon.com/cli/latest/reference/glue/create-workflow.html) nel *Riferimento ai comandi AWS CLI *.
```
aws glue create-workflow --name
```
1. Immettere il comando seguente per creare un trigger di EventBridge evento per il flusso di lavoro. Questo sarà il trigger di avvio per il flusso di lavoro. Sostituiscilo ** con le azioni da eseguire (i job e i crawler da avviare).
Consulta [create-trigger](https://docs.aws.amazon.com/cli/latest/reference/glue/create-trigger.html) nel *Riferimento ai comandi AWS CLI * per informazioni su come codificare l'argomento `actions`.
```
aws glue create-trigger --workflow-name --type EVENT --name --actions
```
Se desideri che il flusso di lavoro venga attivato da un batch di eventi anziché da un singolo EventBridge evento, inserisci invece il comando seguente.
```
aws glue create-trigger --workflow-name --type EVENT --name --event-batching-condition BatchSize=,BatchWindow= --actions
```
Per l'argomento `event-batching-condition`, `BatchSize` è obbligatorio e `BatchWindow` è facoltativo. Se `BatchWindow` viene omesso, il valore predefinito della finestra è 900 secondi, ovvero la dimensione massima della finestra.
**Example**
L'esempio seguente crea un trigger che avvia il `eventtest` flusso di lavoro dopo l'arrivo di tre EventBridge eventi o cinque minuti dopo l'arrivo del primo evento, a seconda dell'evento che si verifica per primo.
```
aws glue create-trigger --workflow-name eventtest --type EVENT --name objectArrival --event-batching-condition BatchSize=3,BatchWindow=300 --actions JobName=test1
```
1. Crea una regola in Amazon EventBridge.
1. Crea l'oggetto JSON per i dettagli della regola nell'editor di testo che preferisci.
Nell'esempio seguente viene specificato Amazon S3 come origine evento, `PutObject`come nome dell'evento e il nome del bucket come parametro di richiesta. Questa regola avvia un flusso di lavoro quando un nuovo oggetto arriva nel bucket.
```
{
"source": [
"aws.s3"
],
"detail-type": [
"AWS API Call via CloudTrail"
],
"detail": {
"eventSource": [
"s3.amazonaws.com"
],
"eventName": [
"PutObject"
],
"requestParameters": {
"bucketName": [
""
]
}
}
}
```
Per avviare il flusso di lavoro quando un nuovo oggetto arriva in una cartella all'interno del bucket, è possibile sostituire il codice seguente con `requestParameters`.
```
"requestParameters": {
"bucketName": [
""
]
"key" : [{ "prefix" : "//*"}}]
}
```
1. Utilizza lo strumento che preferisci per convertire l'oggetto JSON regola in una stringa di escape.
```
{\n \"source\": [\n \"aws.s3\"\n ],\n \"detail-type\": [\n \"AWS API Call via CloudTrail\"\n ],\n \"detail\": {\n \"eventSource\": [\n \"s3.amazonaws.com\"\n ],\n \"eventName\": [\n \"PutObject\"\n ],\n \"requestParameters\": {\n \"bucketName\": [\n \"\"\n ]\n }\n }\n}
```
1. Esegui il comando seguente per creare un modello di parametro JSON che puoi modificare per specificare i parametri di input in un comando `put-rule`successivo. Salva l'output in un file. Per questo esempio, il file è denominato `ruleCommand`.
```
aws events put-rule --name --generate-cli-skeleton >ruleCommand
```
Per ulteriori informazioni sul parametro `--generate-cli-skeleton`, consulta [Generazione di parametri di input e skeleton AWS CLI da un file di input JSON o YAML](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-skeleton.html) nella *Guida per l'utente di AWS *.
Il file di output deve essere simile al seguente.
```
{
"Name": "",
"ScheduleExpression": "",
"EventPattern": "",
"State": "ENABLED",
"Description": "",
"RoleArn": "",
"Tags": [
{
"Key": "",
"Value": ""
}
],
"EventBusName": ""
}
```
1. Modifica il file per rimuovere facoltativamente i parametri e specificare come minimo i parametri `Name`, `EventPattern`, e`State`. Per il parametro `EventPattern`, specifica la stringa di escape per i dettagli della regola creati in un passaggio precedente.
```
{
"Name": "",
"EventPattern": "{\n \"source\": [\n \"aws.s3\"\n ],\n \"detail-type\": [\n \"AWS API Call via CloudTrail\"\n ],\n \"detail\": {\n \"eventSource\": [\n \"s3.amazonaws.com\"\n ],\n \"eventName\": [\n \"PutObject\"\n ],\n \"requestParameters\": {\n \"bucketName\": [\n \"\"\n ]\n }\n }\n}",
"State": "DISABLED",
"Description": "Start an AWS Glue workflow upon new file arrival in an Amazon S3 bucket"
}
```
**Nota**
È consigliabile lasciare disabilitata la regola fino a quando non si completa la creazione del flusso di lavoro.
1. Immetti la seguente comando `put-rule`, che legge i parametri di input dal file `ruleCommand`.
```
aws events put-rule --name --cli-input-json file://ruleCommand
```
Il seguente output indica il successo.
```
{
"RuleArn": ""
}
```
1. Immetti il seguente comando per collegare la regola alla destinazione. La destinazione è il flusso di lavoro in AWS Glue. Sostituiscila ** con il ruolo che hai creato all'inizio di questa procedura.
```
aws events put-targets --rule --targets "Id"="1","Arn"="arn:aws:glue:::workflow/","RoleArn"="arn:aws:iam:::role/" --region
```
Il seguente output indica il successo.
```
{
"FailedEntryCount": 0,
"FailedEntries": []
}
```
1. Conferma la corretta connessione della regola e della destinazione inserendo il comando seguente.
```
aws events list-rule-names-by-target --target-arn arn:aws:glue:::workflow/
```
L'output seguente indica l'esito positivo, ** dov'è il nome della regola creata.
```
{
"RuleNames": [
""
]
}
```
1. Accedi a Console di gestione AWS e apri la AWS Glue console all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Seleziona il flusso di lavoro e verifica che il trigger di avvio e le relative azioni, ovvero i processi o i crawler che avvia, vengano visualizzati nel grafico del flusso di lavoro. Poi, continua con la procedura in [Fase 3: aggiunta di più trigger](creating_running_workflows.md#workflow-step3). In alternativa, aggiungi altri componenti al flusso di lavoro utilizzando l'API AWS Glue o AWS Command Line Interface.
1. Quando il flusso di lavoro è specificato completamente, abilita la regola.
```
aws events enable-rule --name
```
Il flusso di lavoro è ora pronto per essere avviato da un EventBridge evento o da un batch di eventi.
**Consulta anche**
[https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html](https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html)
[Panoramica di flussi di lavoro in AWS Glue](workflows_overview.md)
[Creazione e costruzione manuale di un flusso di lavoro in AWS Glue](creating_running_workflows.md)
# Visualizzazione degli EventBridge eventi che hanno avviato un flusso di lavoro
Puoi visualizzare l'ID evento dell' EventBridge evento Amazon che ha avviato il tuo flusso di lavoro. Se il flusso di lavoro è stato avviato da un batch di eventi, puoi visualizzare l'evento IDs di tutti gli eventi del batch.
Per i flussi di lavoro con una dimensione batch maggiore di uno, è inoltre possibile verificare quale condizione batch ha avviato il flusso di lavoro: l'arrivo del numero di eventi nella dimensione batch o la scadenza del periodo batch.
**Per visualizzare gli EventBridge eventi che hanno avviato un flusso di lavoro (console)**
1. Accedi a Console di gestione AWS e apri la AWS Glue console all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Nel pannello di navigazione, scegli **Workflows** (Flussi di lavoro).
1. Seleziona un flusso di lavoro. Quindi, nella parte inferiore, scegli la scheda **History** (Cronologia).
1. Seleziona un'esecuzione del flusso di lavoro, quindi scegli **View run details** (Visualizza i dettagli dell'esecuzione).
1. Nella pagina dei dettagli di esecuzione, individua il campo **Run properties**e cerca il campo** (Proprietà di esecuzione) e cerca la chiave aws:eventIds**.
Il valore di quella chiave è un elenco di EventBridge eventi IDs.
**Per visualizzare gli EventBridge eventi che hanno avviato un flusso di lavoro (AWS API)**
+ Includi il seguente codice nello script Python.
```
workflow_params = glue_client.get_workflow_run_properties(Name=workflow_name,RunId=workflow_run_id)
batched_events = workflow_params['aws:eventIds']
```
`batched_events` sarà un elenco di stringhe, in cui ogni stringa è un ID evento.
**Consulta anche**
[https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html](https://docs.aws.amazon.com/eventbridge/latest/userguide/what-is-amazon-eventbridge.html)
[Panoramica di flussi di lavoro in AWS Glue](workflows_overview.md)
# Esecuzione e monitoraggio di un flusso di lavoro in AWS Glue
Se il trigger di attivazione di un flusso di lavoro è un trigger on-demand, è possibile avviare il flusso di lavoro dalla console di AWS Glue. Utilizza la procedura seguente per eseguire e monitorare un flusso di lavoro. Se il flusso di lavoro non riesce, puoi visualizzare il grafico di esecuzione per individuare il nodo non riuscito. Per facilitare la risoluzione dei problemi, se il flusso di lavoro è stato creato da un piano, puoi visualizzare l'esecuzione del piano per vedere i valori dei parametri del piano utilizzati per creare il flusso di lavoro. Per ulteriori informazioni, consulta [Visualizzazione delle esecuzioni dello schema in AWS Glue](viewing_blueprint_runs.md).
Puoi eseguire e monitorare l'esecuzione di un flusso di lavoro utilizzando la console AWS Glue, l'API o AWS Command Line Interface (AWS CLI).
**Per eseguire e monitorare un flusso di lavoro (console)**
1. Apri la AWS Glue console all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Nel pannello di navigazione, in **ETL**, scegliere **Workflows (Flussi di lavoro)**.
1. Selezionare un flusso di lavoro. Nel menu **Actions (Operazioni)**, scegliere **Run (Esegui)**.
1. Controlla la colonna **Last run status** (Stato dell'ultima esecuzione) nell'elenco dei flussi di lavoro. Scegli il pulsante di aggiornamento per visualizzare lo stato del flusso di lavoro in corso.
1. Mentre il flusso di lavoro è in esecuzione o dopo che è stato completato (o non riuscito), visualizza i dettagli dell'esecuzione completando la procedura seguente.
1. Verifica che il flusso di lavoro sia selezionato e scegli la scheda **History** (Cronologia).
1. Seleziona l'esecuzione del flusso di lavoro corrente o più recente, quindi seleziona **View run details** (Visualizza i dettagli dell'esecuzione).
Il grafico del tempo di esecuzione del flusso di lavoro mostra lo stato corrente dell'esecuzione.
1. Scegli un nodo nel grafico per visualizzare relativi i dettagli e lo stato.
![\[Il grafico di esecuzione mostra un trigger di avvio, che avvia un processo. Un altro trigger controlla il completamento del lavoro. È selezionato il nodo di processo (un rettangolo che racchiude un'icona degli appunti e un nome di processo) e i dettagli del processo vengono visualizzati in un riquadro a destra. I dettagli del processo includono l'ID di esecuzione del processo e lo stato.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/workflow-pre-select-resume.png)
**Per eseguire e monitorare un flusso di lavoro (AWS CLI)**
1. Inserire il seguente comando. Sostituisci ** con il flusso di lavoro da eseguire.
```
aws glue start-workflow-run --name
```
Se il flusso di lavoro viene avviato correttamente, il comando restituisce l'ID di esecuzione.
1. Visualizza lo stato di esecuzione del flusso di lavoro utilizzando il comando `get-workflow-run`. Specifica il nome del flusso di lavoro e l'ID di esecuzione.
```
aws glue get-workflow-run --name myWorkflow --run-id wr_d2af14217e8eae775ba7b1fc6fc7a42c795aed3cbcd8763f9415452e2dbc8705
```
Di seguito è riportato un output del comando di esempio.
```
{
"Run": {
"Name": "myWorkflow",
"WorkflowRunId": "wr_d2af14217e8eae775ba7b1fc6fc7a42c795aed3cbcd8763f9415452e2dbc8705",
"WorkflowRunProperties": {
"run_state": "COMPLETED",
"unique_id": "fee63f30-c512-4742-a9b1-7c8183bdaae2"
},
"StartedOn": 1578556843.049,
"CompletedOn": 1578558649.928,
"Status": "COMPLETED",
"Statistics": {
"TotalActions": 11,
"TimeoutActions": 0,
"FailedActions": 0,
"StoppedActions": 0,
"SucceededActions": 9,
"RunningActions": 0,
"ErroredActions": 0
}
}
}
```
**Consulta anche:**
[Panoramica di flussi di lavoro in AWS Glue](workflows_overview.md)
[Panoramica degli schemi in AWS Glue](blueprints-overview.md)
# Arresto dell'esecuzione di un flusso di lavoro
Puoi utilizzare la AWS Glue console, AWS Command Line Interface (AWS CLI) o l'AWS GlueAPI per interrompere l'esecuzione di un flusso di lavoro. Quando si interrompe l'esecuzione di un flusso di lavoro, tutti i processi e i crawler in esecuzione vengono immediatamente terminati e i processi e i crawler non ancora avviati non vengono mai avviati. Potrebbe essere necessario fino a un minuto prima che tutti i processi in esecuzione e i crawler si fermino. Lo stato di esecuzione del flusso di lavoro passa da **Running (In esecuzione)** a **Stopping (Arresto in corso)**, e quando l'esecuzione del flusso di lavoro è completamente interrotta, lo stato passa a **Stopped (Arrestato)**.
Dopo l'interruzione dell'esecuzione del flusso di lavoro, è possibile visualizzare il grafico di esecuzione per verificare quali processi e crawler sono stati completati e quali non sono mai stati avviati. È quindi possibile determinare se è necessario eseguire qualsiasi procedura per garantire l'integrità dei dati. L'arresto di un'esecuzione del flusso di lavoro non comporta l'esecuzione di operazioni di rollback automatico.
**Per interrompere l'esecuzione di un flusso di lavoro (console)**
1. Apri la AWS Glue console all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Nel pannello di navigazione, in **ETL**, scegliere **Workflows (Flussi di lavoro)**.
1. Scegliere un flusso di lavoro in esecuzione, quindi scegliere la scheda **History (Cronologia)** .
1. Scegliere l'esecuzione del flusso di lavoro, quindi scegliere **Stop run (Arresta esecuzione)**.
Lo stato di esecuzione cambia in **Stopping (Arresto in corso)**.
1. (Facoltativo) Scegliere l'esecuzione del flusso di lavoro, scegliere **View run details (Visualizza dettagli esecuzione)**, ed esaminare il grafico di esecuzione.
**Per interrompere l'esecuzione di un flusso di lavoro (AWS CLI)**
+ Inserire il seguente comando. Sostituisci ** con il nome del flusso di lavoro e ** con l'ID di esecuzione del flusso di lavoro esegui per interrompere.
```
aws glue stop-workflow-run --name --run-id
```
Di seguito è riportato un comando **stop-workflow-run** di esempio.
```
aws glue stop-workflow-run --name my-workflow --run-id wr_137b88917411d128081069901e4a80595d97f719282094b7f271d09576770354
```
# Ripresa e ripristino dell'esecuzione di un flusso di lavoro
Se uno o più nodi (processi o crawler) in un flusso di lavoro non vengono completati correttamente, ciò significa che il flusso di lavoro è stato eseguito solo parzialmente. Dopo aver individuato le cause principali e apportato le correzioni, è possibile selezionare uno o più nodi da cui riprendere l'esecuzione del flusso di lavoro e quindi riprendere l'esecuzione del flusso di lavoro. Vengono eseguiti i nodi selezionati e tutti i nodi che sono a valle dei nodi selezionati.
**Topics**
+ [Riprendere un'esecuzione del flusso di lavoro: come funziona](#resume-workflow-howitworks)
+ [Riprendere un'esecuzione di flusso di lavoro](#how-to-resume-workflow)
+ [Note e limitazioni per la ripresa delle esecuzioni del flusso di lavoro](#resume-workflow-notes)
## Riprendere un'esecuzione del flusso di lavoro: come funziona
Considera il flusso di lavoro W1 nel diagramma seguente.
![\[I trigger sono rappresentati come rettangoli e i processi rappresentati come cerchi. Il trigger T1 a sinistra avvia il flusso di lavoro eseguendo il processo J1. I trigger e i processi successivi esistono, ma i processi J2 e J3 non riescono, quindi i trigger e i processi a valle vengono visualizzati come non eseguiti.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/workflow_W1.png)
L'esecuzione del flusso di lavoro si svolge come segue:
1. Il trigger T1 avvia il processo J1.
1. Il completamento riuscito di J1 attiva i trigger T2 e T3, che eseguono i processi J2 e J3, rispettivamente.
1. I processi J2 e J3 non riescono.
1. I trigger T4 e T5 dipendono dal completamento riuscito di J2 e J3, quindi non si attivano e i processi J4 e J5 non vengono eseguiti. Il flusso di lavoro W1 viene eseguito solo parzialmente.
Ora supponiamo che i problemi che hanno causato la non riuscita di J2 e J3 vengano corretti. J2 e J3 sono selezionati come punti di partenza da cui riprendere l'esecuzione del flusso di lavoro.
![\[I processi J2 e J3 sono contrassegnati come nodi da riprendere. I trigger e i processi a valle vengono visualizzati come eseguiti correttamente.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/workflow_W1_resumed.png)
L'esecuzione del flusso di lavoro riprende come segue:
1. I processi J2 e J3 vengono eseguiti correttamente.
1. I trigger T4 e T5 si attivano.
1. I processi J4 e J5 vengono eseguiti correttamente.
L'esecuzione del flusso di lavoro ripreso viene registrata come un'esecuzione separata del flusso di lavoro con un nuovo ID di esecuzione. Nella cronologia del flusso di lavoro, è possibile visualizzare l'ID dell' esecuzione precedente per qualsiasi esecuzione del flusso di lavoro. Nell'esempio nello screenshot seguente, un nodo dell'esecuzione del flusso di lavoro con ID di esecuzione `wr_c7a22...` (la seconda riga) non è stato completato. L'utente ha risolto il problema e ha ripreso l'esecuzione del flusso di lavoro, con ID di esecuzione `wr_a07e55...` (la prima riga).
![\[Una tabella nella scheda History (Cronologia) di un flusso di lavoro contiene due righe, una per ogni esecuzione del flusso di lavoro. La prima riga ha un ID di esecuzione e un ID di esecuzione precedente. La seconda riga ha solo un ID di esecuzione. L'ID di esecuzione precedente nella prima riga corrisponde all'ID di esecuzione nella seconda riga.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/previous-run-id.png)
**Nota**
Per il resto di questo articolo, il termine "esecuzione del flusso di lavoro ripreso" si riferisce all'esecuzione del flusso di lavoro creata quando è stata ripresa l'esecuzione precedente del flusso di lavoro. L'"esecuzione del flusso di lavoro originale" indica l'esecuzione del flusso di lavoro che è stata eseguita solo parzialmente e che doveva essere ripresa.
**Grafico dell'esecuzione del flusso di lavoro ripreso**
In un'esecuzione del flusso di lavoro ripreso, nonostante venga eseguito solo un sottoinsieme di nodi, il grafico di esecuzione è un grafico completo. Cioè, i nodi che non sono stati eseguiti nel flusso di lavoro ripreso vengono copiati dal grafico dell'esecuzione del flusso di lavoro originale. I nodi del processo e del crawler copiati eseguiti nell'esecuzione del flusso di lavoro originale includono dettagli di esecuzione.
Considera nuovamente il flusso di lavoro W1 nel diagramma precedente. Quando l'esecuzione del flusso di lavoro viene ripresa a partire da J2 e J3, il grafico di esecuzione per l'esecuzione del flusso di lavoro ripreso mostra tutti i processi, da J1 a J5, e tutti i trigger, da T1 a T5. I dettagli del processo per J1 vengono copiati dall'esecuzione del flusso di lavoro originale.
**Snapshot dell'esecuzione del flusso di lavoro**
All'avvio di un'esecuzione del flusso di lavoro, AWS Glue acquisisce uno snapshot del grafico di progettazione del flusso di lavoro in quel momento. Lo snapshot viene utilizzato per la durata dell'esecuzione del flusso di lavoro. Se si apportano modifiche a qualsiasi trigger dopo l'avvio dell'esecuzione, tali modifiche non influiscono sull'esecuzione del flusso di lavoro corrente. Gli snapshot garantiscono che le esecuzioni del flusso di lavoro procedano in modo coerente.
Gli snapshot rendono immutabili solo i trigger. Le modifiche apportate ai processi a valle e ai crawler durante l'esecuzione del flusso di lavoro diventano effettive per l'esecuzione corrente.
## Riprendere un'esecuzione di flusso di lavoro
Segui questi passaggi per riprendere un'esecuzione di flusso di lavoro. Puoi riprendere l'esecuzione di un flusso di lavoro utilizzando la AWS Glue console, l'API o AWS Command Line Interface (AWS CLI).
**Per riprendere un flusso di lavoro (console)**
1. Apri la AWS Glue console all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
Accedi come utente che dispone delle autorizzazioni per visualizzare i flussi di lavoro e riprendere le esecuzioni dei flussi di lavoro.
**Nota**
Per riprendere l'esecuzione del flusso di lavoro, è necessaria l'autorizzazione `glue:ResumeWorkflowRun` AWS Identity and Access Management (IAM).
1. Nel pannello di navigazione, scegli **Workflows** (Flussi di lavoro).
1. Seleziona un flusso di lavoro, quindi la scheda **History (Cronologia)**.
1. Seleziona un'esecuzione del flusso di lavoro eseguita solo parzialmente, quindi seleziona **View run details** (Visualizza i dettagli dell'esecuzione).
1. Nel grafico di esecuzione seleziona il primo (o solo) nodo da riavviare e da cui riprendere l'esecuzione del flusso di lavoro.
1. Nel riquadro dei dettagli a destra del grafico, seleziona la casella di controllo**Resume** (Riprendi).
![\[Il grafico di esecuzione mostra tre nodi, incluso un nodo di processo non riuscito. Il riquadro dei dettagli processo a destra include una casella di controllo Resume (Riprendi).\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/workflow-pre-select-resume.png)
Il nodo cambia colore e mostra una piccola icona di ripresa in alto a destra.
![\[La modifica al grafico di esecuzione è descritta nel testo. La casella di controllo Riprendi (Resume) è selezionata.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/workflow-post-select-resume.png)
1. Completa i due passaggi precedenti per riavviare eventuali nodi aggiuntivi.
1. Seleziona **Resume (Riprendi)**.
**Per riprendere un flusso di lavoro (AWS CLI)**
1. Assicurati di disporre dell'autorizzazione `glue:ResumeWorkflowRun` IAM.
1. Recupera il nodo IDs per i nodi che desideri riavviare.
1. Esegui il comando `get-workflow-run` per l'esecuzione del flusso di lavoro originale. Fornisci il nome del flusso di lavoro e l'ID di esecuzione e aggiungi l'opzione `--include-graph`, come mostrato nell'esempio seguente. Recupera l'ID di esecuzione dalla scheda **History** (Cronologia) sulla console o eseguendo il comando `get-workflow`.
```
aws glue get-workflow-run --name cloudtrailtest1 --run-id wr_a07e55f2087afdd415a404403f644a4265278f68b13ba3da08c71924ebe3c3a8 --include-graph
```
Il comando restituisce i nodi e gli estremi del grafico come un oggetto JSON di grandi dimensioni.
1. Individua i nodi di interesse dalle proprietà `Type` e `Name` degli oggetti nodo.
Il seguente è un esempio di oggetto nodo dell'output.
```
{
"Type": "JOB",
"Name": "test1_post_failure_4592978",
"UniqueId": "wnode_d1b2563c503078b153142ee76ce545fe5ceef66e053628a786ddd74a05da86fd",
"JobDetails": {
"JobRuns": [
{
"Id": "jr_690b9f7fc5cb399204bc542c6c956f39934496a5d665a42de891e5b01f59e613",
"Attempt": 0,
"TriggerName": "test1_aggregate_failure_649b2432",
"JobName": "test1_post_failure_4592978",
"StartedOn": 1595358275.375,
"LastModifiedOn": 1595358298.785,
"CompletedOn": 1595358298.785,
"JobRunState": "FAILED",
"PredecessorRuns": [],
"AllocatedCapacity": 0,
"ExecutionTime": 16,
"Timeout": 2880,
"MaxCapacity": 0.0625,
"LogGroupName": "/aws-glue/python-jobs"
}
]
}
}
```
1. Recupera l'ID nodo dalla proprietà `UniqueId` dell'oggetto nodo.
1. Esegui il comando `resume-workflow-run`. Fornite il nome del flusso di lavoro, l'ID di esecuzione e l'elenco dei nodi IDs separati da spazi, come illustrato nell'esempio seguente.
```
aws glue resume-workflow-run --name cloudtrailtest1 --run-id wr_a07e55f2087afdd415a404403f644a4265278f68b13ba3da08c71924ebe3c3a8 --node-ids wnode_ca1f63e918fb855e063aed2f42ec5762ccf71b80082ae2eb5daeb8052442f2f3 wnode_d1b2563c503078b153142ee76ce545fe5ceef66e053628a786ddd74a05da86fd
```
Il comando restituisce l'ID di esecuzione della (nuova) esecuzione del flusso di lavoro ripresa e un elenco di nodi che verranno avviati.
```
{
"RunId": "wr_2ada0d3209a262fc1156e4291134b3bd643491bcfb0ceead30bd3e4efac24de9",
"NodeIds": [
"wnode_ca1f63e918fb855e063aed2f42ec5762ccf71b80082ae2eb5daeb8052442f2f3"
]
}
```
Nota che anche se l'esempio `resume-workflow-run` elencava due nodi da riavviare, l'output di esempio indicava che un solo nodo sarebbe stato riavviato. Questo perché un nodo era a valle dell'altro nodo e il nodo a valle viene comunque riavviato dal flusso normale del flusso di lavoro.
## Note e limitazioni per la ripresa delle esecuzioni del flusso di lavoro
Tieni presente le seguenti note e limitazioni per la ripresa delle esecuzioni del flusso di lavoro.
+ È possibile riprendere l'esecuzione di un flusso di lavoro solo se si trova nello stato `COMPLETED`.
**Nota**
Anche se uno o più nodi in un'esecuzione del flusso di lavoro non vengono completati, lo stato di esecuzione del flusso di lavoro viene visualizzato come `COMPLETED`. Accertati di controllare il grafico di esecuzione per individuare eventuali nodi che non sono stati completati correttamente.
+ È possibile riprendere l'esecuzione di un flusso di lavoro da qualsiasi nodo del processo o del crawler che il flusso di lavoro originale ha tentato di eseguire. Non è possibile riprendere l'esecuzione di un flusso di lavoro da un nodo trigger.
+ Il riavvio di un nodo non ne reimposta lo stato. Tutti i dati parzialmente elaborati non vengono ripristinati.
+ È possibile riprendere un workflow non riuscito eseguito più volte. Tuttavia, un'esecuzione ripresa può essere ripresa solo un'altra volta. Per ulteriori tentativi, riprendi invece l'esecuzione originale non riuscita
+ Se si selezionano due nodi da riavviare e dipendono l'uno dall'altro, il nodo a monte viene eseguito prima del nodo a valle. Di fatto, la selezione del nodo a valle è ridondante, perché viene eseguito in base al normale flusso di lavoro.
# Recupero e impostazione delle proprietà di esecuzione del flusso di lavoro in AWS Glue
Utilizzare le proprietà di esecuzione dei flussi di lavoro per condividere e gestire lo stato tra i processi del flusso di lavoro di AWS Glue. È possibile impostare proprietà di esecuzione di default al momento della creazione del flusso di lavoro. Quindi, nel momento in cui i processi sono eseguiti, è possibile recuperare i valori delle proprietà di esecuzione e, se necessario, modificarli come input per i processi successivi nel flusso di lavoro. Quando un processo modifica una proprietà di esecuzione, il nuovo valore esiste solo per il flusso di lavoro in esecuzione. Le proprietà di esecuzione predefinite non sono interessate.
Se il lavoro AWS Glue non fa parte di un workflow, queste proprietà non verranno impostate.
Il codice Python di esempio seguente relativo a un processo di estrazione, trasformazione e caricamento (ETL) mostra come recuperare le proprietà di esecuzione del flusso di lavoro.
```
import sys
import boto3
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from awsglue.context import GlueContext
from pyspark.context import SparkContext
glue_client = boto3.client("glue")
args = getResolvedOptions(sys.argv, ['JOB_NAME','WORKFLOW_NAME', 'WORKFLOW_RUN_ID'])
workflow_name = args['WORKFLOW_NAME']
workflow_run_id = args['WORKFLOW_RUN_ID']
workflow_params = glue_client.get_workflow_run_properties(Name=workflow_name,
RunId=workflow_run_id)["RunProperties"]
target_database = workflow_params['target_database']
target_s3_location = workflow_params['target_s3_location']
```
Il codice seguente prosegue impostando la proprietà di esecuzione `target_format` al valore `'csv'`.
```
workflow_params['target_format'] = 'csv'
glue_client.put_workflow_run_properties(Name=workflow_name, RunId=workflow_run_id, RunProperties=workflow_params)
```
Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [GetWorkflowRunProperties azione (Python: get\$1workflow\$1run\$1properties)](aws-glue-api-workflow.md#aws-glue-api-workflow-GetWorkflowRunProperties)
+ [PutWorkflowRunProperties azione (Python: put\$1workflow\$1run\$1properties)](aws-glue-api-workflow.md#aws-glue-api-workflow-PutWorkflowRunProperties)
# Interrogazione dei flussi di lavoro utilizzando AWS Glue API
AWS Glue fornisce una ricca API per la gestione dei flussi di lavoro. Utilizzando la AWS Glue APIè possibile recuperare una visualizzazione statica o dinamica di un flusso di lavoro in esecuzione. Per ulteriori informazioni, consulta [Flussi di lavoro](aws-glue-api-workflow.md).
**Topics**
+ [Eseguire query sulle visualizzazioni statiche](#workflows_api_concepts_static)
+ [Eseguire query sulle visualizzazioni dinamiche](#workflows_api_concepts_dynamic)
## Eseguire query sulle visualizzazioni statiche
Per ottenere una visualizzazione statica che descrive la configurazione di un flusso di lavoro, utilizzare l'operazione API `GetWorkflow`. Questa operazione restituisce un diagramma orientato composto da nodi e archi, nel quale ogni nodo rappresenta un trigger, un processo o un crawler. Gli archi definiscono le relazioni tra i nodi. Sono rappresentati da connettori (frecce) all'interno del diagramma visualizzato nella console di AWS Glue.
È inoltre possibile utilizzare questa operazione con le librerie di elaborazione grafica più diffuse come NetworkX, igraph, JGraph T e Java Universal (JUNG) Framework. Network/Graph Poiché tutte queste librerie rappresentano i diagrammi in modo analogo, sono necessarie trasformazioni minime.
La visualizzazione statica restituita da questa API è la più up-to-date visualizzata secondo l'ultima definizione di trigger associati al flusso di lavoro.
### Definizione del diagramma
Un diagramma di un flusso di lavoro G è una coppia ordinata (N, E), dove N è costituito da un insieme di nodi ed E è costituito da un insieme di archi. Un *Nodo* è un vertice del diagramma identificato da un numero univoco. Un nodo può essere di tipo trigger, processo o crawler. Ad esempio: `{name:T1, type:Trigger, uniqueId:1}, {name:J1, type:Job, uniqueId:2}`.
Un *Edge* è una tupla nella forma (`src, dest`), dove `src` e `dest` sono nodi ed è presente un arco diretto che va da `src` a `dest`.
### Esempio di esecuzione di query di una visualizzazione statica.
Considerare un trigger condizionale T, che attiva il processo J2 al completamento del processo J1.
```
J1 ---> T ---> J2
```
Nodi: J1, T, J2
Archi: (J1, T), (T, J2)
## Eseguire query sulle visualizzazioni dinamiche
Per ottenere una visualizzazione dinamica di un flusso di lavoro in esecuzione, utilizzare l'operazione API `GetWorkflowRun`. Questa operazione restituisce una visualizzazione identica a quella statica con i metadati correlati all'esecuzione del flusso di lavoro.
Per l'esecuzione, i nodi che rappresentano i processi nella chiamata `GetWorkflowRun` sono associati a un elenco di esecuzioni dei processi derivanti dall'ultima esecuzione del flusso di lavoro. È possibile usare questo elenco per visualizzare lo stato di esecuzione di ogni processo nel diagramma stesso. Per dipendenze a valle non ancora eseguite, questo campo è impostato su `null`. Le informazioni rappresentate sul diagramma permettono di conoscere lo stato attuale di qualsiasi flusso di lavoro in qualsiasi momento.
La visualizzazione dinamica restituita da questa API si basa sulla visualizzazione statica presente al momento dell'avvio dell'esecuzione del flusso di lavoro.
*Esempio del tempo di esecuzione dei nodi:* `{name:T1, type: Trigger, uniqueId:1}`, `{name:J1, type:Job, uniqueId:2, jobDetails:{jobRuns}}`, `{name:C1, type:Crawler, uniqueId:3, crawlerDetails:{crawls}}`
### Esempio 1: visualizzazione dinamica
L'esempio seguente illustra un semplice flusso di lavoro costituito da due trigger.
+ Nodi: t1, j1, t2, j2
+ Archi: (t1, j1), (j1, t2), (t2, j2)
La risposta di `GetWorkflow` contiene quanto segue.
```
{
Nodes : [
{
"type" : Trigger,
"name" : "t1",
"uniqueId" : 1
},
{
"type" : Job,
"name" : "j1",
"uniqueId" : 2
},
{
"type" : Trigger,
"name" : "t2",
"uniqueId" : 3
},
{
"type" : Job,
"name" : "j2",
"uniqueId" : 4
}
],
Edges : [
{
"sourceId" : 1,
"destinationId" : 2
},
{
"sourceId" : 2,
"destinationId" : 3
},
{
"sourceId" : 3,
"destinationId" : 4
}
}
```
La risposta di `GetWorkflowRun` contiene quanto segue.
```
{
Nodes : [
{
"type" : Trigger,
"name" : "t1",
"uniqueId" : 1,
"jobDetails" : null,
"crawlerDetails" : null
},
{
"type" : Job,
"name" : "j1",
"uniqueId" : 2,
"jobDetails" : [
{
"id" : "jr_12334",
"jobRunState" : "SUCCEEDED",
"errorMessage" : "error string"
}
],
"crawlerDetails" : null
},
{
"type" : Trigger,
"name" : "t2",
"uniqueId" : 3,
"jobDetails" : null,
"crawlerDetails" : null
},
{
"type" : Job,
"name" : "j2",
"uniqueId" : 4,
"jobDetails" : [
{
"id" : "jr_1233sdf4",
"jobRunState" : "SUCCEEDED",
"errorMessage" : "error string"
}
],
"crawlerDetails" : null
}
],
Edges : [
{
"sourceId" : 1,
"destinationId" : 2
},
{
"sourceId" : 2,
"destinationId" : 3
},
{
"sourceId" : 3,
"destinationId" : 4
}
}
```
### Esempio 2: processi multipli con un trigger condizionale.
L'esempio seguente mostra un flusso di lavoro con processi multipli e un trigger condizionale (t3).
```
Consider Flow:
T(t1) ---> J(j1) ---> T(t2) ---> J(j2)
| |
| |
>+------> T(t3) <-----+
|
|
J(j3)
Graph generated:
Nodes: t1, t2, t3, j1, j2, j3
Edges: (t1, j1), (j1, t2), (t2, j2), (j1, t3), (j2, t3), (t3, j3)
```
# Restrizioni dei flussi di lavoro e degli schemi in AWS Glue
Di seguito sono riportate le restrizioni imposte sui piani e sui flussi di lavoro.
## Restrizioni degli schemi
Tieni a mente le seguenti restrizioni relative al piano:
+ Il blueprint deve essere registrato nella stessa AWS regione in cui risiede il bucket Amazon S3.
+ Per condividere i blueprint tra AWS account, devi fornire le autorizzazioni di lettura sull'archivio ZIP del blueprint in Amazon S3. I clienti che dispongono dell'autorizzazione di lettura su un archivio ZIP del blueprint possono registrare il blueprint nel proprio account e utilizzarlo. AWS
+ L'insieme di parametri del piano viene memorizzato come un singolo oggetto JSON. La lunghezza massima di questo oggetto è 128 KB.
+ La dimensione massima non compressa dell'archivio ZIP del piano è 5 MB. La dimensione massima compressa è 1 MB.
+ 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.
## Restrizioni dei flussi di lavoro
Tieni a mente le seguenti restrizioni relative ai flussi di lavoro. Alcuni di questi commenti sono principalmente indirizzati a utenti che creano flussi di lavoro manualmente.
+ La dimensione massima del batch per un trigger di EventBridge eventi Amazon è 100. La dimensione massima della finestra è di 900 secondi (15 minuti).
+ Un trigger può essere associato a un solo flusso di lavoro.
+ È permessa la configurazione di un solo trigger di attivazione (on demand o pianificato).
+ Se un processo o un crawler in un flusso di lavoro viene avviato da un trigger esterno al flusso di lavoro, eventuali trigger all'interno del flusso di lavoro che dipendono dal completamento del processo o del crawler (completato o meno) non vengono attivati.
+ Analogamente, se un processo o crawler in un flusso di lavoro dispone di trigger che dipendono dal completamento del processo o del crawler (completato o meno) sia all'interno del flusso di lavoro che all'esterno del flusso di lavoro e se il processo o il crawler viene avviato da un flusso di lavoro, solo i trigger all'interno del flusso di lavoro si attivano al completamento del processo o del crawler.
# Risoluzione degli errori relativi agli schemi in AWS Glue
Se riscontri errori durante l'utilizzo dei piani AWS Glue, usa le seguenti soluzioni per trovare l'origine dei problemi e correggerli.
**Topics**
+ [Errore: PySpark modulo mancante](#blueprint-workflow-error-1)
+ [Errore: file di configurazione del piano mancante](#blueprint-workflow-error-2)
+ [Errore: file importato mancante](#blueprint-workflow-error-3)
+ [Errore: non autorizzato a iamPassRole eseguire sulla risorsa](#blueprint-workflow-error-4)
+ [Errore: pianificazione cron non valida](#blueprint-workflow-error-5)
+ [Errore: esiste già un trigger con questo nome](#blueprint-workflow-error-6)
+ [Errore: un flusso di lavoro con nome “foo” esiste già.](#blueprint-workflow-error-7)
+ [Errore: modulo non trovato nel percorso layoutGenerator specificato](#blueprint-workflow-error-8)
+ [Errore: errore di convalida nel campo Connections (Connessioni)](#blueprint-workflow-error-9)
## Errore: PySpark modulo mancante
AWS Gluerestituisce l'errore «Errore sconosciuto nell'esecuzione della funzione del generatore di layout ModuleNotFoundError: nessun modulo chiamato 'pyspark'».
Quando si decomprime l'archivio del piano, potrebbe verificarsi uno dei seguenti casi:
```
$ unzip compaction.zip
Archive: compaction.zip
creating: compaction/
inflating: compaction/blueprint.cfg
inflating: compaction/layout.py
inflating: compaction/README.md
inflating: compaction/compaction.py
$ unzip compaction.zip
Archive: compaction.zip
inflating: blueprint.cfg
inflating: compaction.py
inflating: layout.py
inflating: README.md
```
Nel primo caso, tutti i file relativi al piano sono stati collocati in una cartella denominata compattazione convertita poi in un file zip denominato *compaction.zip*.
Nel secondo caso, tutti i file necessari per il piano non sono stati inclusi in una cartella e sono stati aggiunti come file root sotto il file zip *compaction.zip*.
È consentita la creazione di un file in uno dei formati sopra indicati. Accertati che `blueprint.cfg` abbia il percorso corretto al nome della funzione nello script che genera il layout.
**Esempi**
Nel caso 1: `blueprint.cfg` deve avere `layoutGenerator` come segue:
```
layoutGenerator": "compaction.layout.generate_layout"
```
Nel caso 2: `blueprint.cfg` deve avere `layoutGenerator` come segue
```
layoutGenerator": "layout.generate_layout"
```
Se questo percorso non è incluso correttamente, è possibile che venga visualizzato l'errore indicato. Ad esempio, se disponi della struttura di cartelle come indicato nel caso 2 e `layoutGenerator` come indicato come nel caso 1, potresti visualizzare l'errore di cui sopra.
## Errore: file di configurazione del piano mancante
AWS Gluerestituisce l'errore «Errore sconosciuto nell'esecuzione della funzione del generatore di layout FileNotFoundError: [Errno 2] Nessun file o directory di questo tipo: tmp/compaction/blueprint '/ .cfg'».
blueprint.cfg deve essere posizionato al livello root dell'archivio ZIP o all'interno di una cartella che ha lo stesso nome dell'archivio ZIP.
Quando si estrae l'archivio ZIP del piano, blueprint.cfg deve essere trovato in uno dei seguenti percorsi. Se non viene trovato in uno dei seguenti percorsi, potresti visualizzare l'errore di cui sopra.
```
$ unzip compaction.zip
Archive: compaction.zip
creating: compaction/
inflating: compaction/blueprint.cfg
$ unzip compaction.zip
Archive: compaction.zip
inflating: blueprint.cfg
```
## Errore: file importato mancante
AWS Gluerestituisce l'errore «Errore sconosciuto nell'esecuzione della funzione del generatore di layout FileNotFoundError: [Errno 2] Nessun file o directory di questo tipo: \$1 \$1'demo-project/foo.py'».
Se lo script di generazione del layout dispone di funzionalità per leggere altri file, accertati di fornire un percorso completo per il file da importare. Ad esempio, Layout.py potrebbe fare riferimento allo script Conversion.py. Per ulteriori informazioni, consulta [Progetto di schema di esempio](https://docs.aws.amazon.com/glue/latest/dg/developing-blueprints-sample.html).
## Errore: non autorizzato a iamPassRole eseguire sulla risorsa
AWS Gluerestituisce l'errore «User: arn:aws:sts: :123456789012:assumed-» role/AWSGlueServiceRole/GlueSession is not authorized to perform: iam:PassRole on resource: arn:aws:iam::123456789012:role/AWSGlueServiceRole
Se i processi e i crawler nel flusso di lavoro assumono lo stesso ruolo del ruolo passato per creare il flusso di lavoro dal piano, il ruolo del piano deve includere l'autorizzazione `iam:PassRole` su se stesso.
Se i processi e i crawler nel flusso di lavoro assumono un ruolo diverso da quello passato per creare le entità del flusso di lavoro dal piano, il ruolo del piano deve includere l'autorizzazione `iam:PassRole` sull'altro ruolo invece che sul ruolo del piano.
Per ulteriori informazioni, consulta [Autorizzazioni per i ruoli degli schemi](https://docs.aws.amazon.com/glue/latest/dg/blueprints-personas-permissions.html#blueprints-role-permissions).
## Errore: pianificazione cron non valida
AWS Glue restituisce l'errore "The schedule cron(0 0 \$1 \$1 \$1 \$1) is invalid." (La pianificazione cron(0 0 \$1 \$1 \$1 \$1) non è valida)
Fornisci un'espressione [cron](https://en.wikipedia.org/wiki/Cron) valida. Per ulteriori informazioni, consulta [Pianificazioni basate sul tempo per processi e crawler](https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html).
## Errore: esiste già un trigger con questo nome
AWS Glue restituisce l'errore "Trigger with name 'foo\$1starting\$1trigger' already submitted with different configuration" (Trigger con nome foo\$1starting\$1trigger' già inviato con configurazione diversa).
Un piano non richiede la definizione dei trigger nello script di layout per la creazione del flusso di lavoro. La creazione dei trigger viene gestita dalla libreria del piano in base alle dipendenze definite tra due operazioni.
La denominazione per i trigger è la seguente:
+ Per il trigger iniziale nel flusso di lavoro, la denominazione è \$1starting\$1trigger.
+ Per un nodo (processo/crawler) nel flusso di lavoro che dipende dal completamento di uno o più nodi a monte; AWS Glue definisce un trigger con il nome \$1\$1trigger
Questo errore indica che esiste già un trigger con lo stesso nome. È possibile eliminare il trigger esistente ed eseguire nuovamente la creazione del flusso di lavoro.
**Nota**
L'eliminazione di un flusso di lavoro non comporta l'eliminazione dei nodi all'interno del flusso di lavoro. È possibile che i trigger vengano lasciati anche se il flusso di lavoro viene eliminato. Per questo motivo, nel caso in cui crei un flusso di lavoro, lo elimini e quindi provi a ricrearlo con lo stesso nome dallo stesso piano, potresti non ricevere un errore che indica che il flusso di lavoro esiste già, ma potresti ricevere un errore che indica che il trigger esiste già.
## Errore: un flusso di lavoro con nome “foo” esiste già.
Il nome del flusso di lavoro deve essere univoco. Prova con un nome diverso.
## Errore: modulo non trovato nel percorso layoutGenerator specificato
AWS Gluerestituisce l'errore «Errore sconosciuto nell'esecuzione della funzione del generatore di layout: nessun modulo denominato 'crawl\$1s3\$1locations'». ModuleNotFoundError
```
layoutGenerator": "crawl_s3_locations.layout.generate_layout"
```
Ad esempio, disponi del percorso LayoutGenerator di cui sopra, quando decomprimi l'archivio del piano, questo deve essere simile al seguente:
```
$ unzip crawl_s3_locations.zip
Archive: crawl_s3_locations.zip
creating: crawl_s3_locations/
inflating: crawl_s3_locations/blueprint.cfg
inflating: crawl_s3_locations/layout.py
inflating: crawl_s3_locations/README.md
```
Quando decomprimi l'archivio, se l'archivio del piano è simile al seguente, potresti visualizzare l'errore precedente.
```
$ unzip crawl_s3_locations.zip
Archive: crawl_s3_locations.zip
inflating: blueprint.cfg
inflating: layout.py
inflating: README.md
```
Non esiste una cartella denominata `crawl_s3_locations` e quando il percorso `layoutGenerator` fa riferimento al file di layout tramite il modulo `crawl_s3_locations`, potresti visualizzare l'errore di cui sopra.
## Errore: errore di convalida nel campo Connections (Connessioni)
AWS Gluerestituisce l'errore «Errore sconosciuto nell'esecuzione della funzione del generatore di layout TypeError: il valore ['foo'] per le connessioni chiave dovrebbe essere di tipo\$1».
Si tratta di un errore di convalida. Il campo `Connections` nella classe `Job` si aspetta un dizionario e invece viene fornito un elenco di valori che causa l'errore.
```
User input was list of values
Connections= ['string']
Should be a dict like the following
Connections*=*{'Connections': ['string']}
```
Per evitare questi errori di runtime durante la creazione di un flusso di lavoro da uno schema, puoi convalidare le definizioni del flusso di lavoro, del processo e del crawler come descritto in [Test di uno schema](https://docs.aws.amazon.com/glue/latest/dg/developing-blueprints-testing.html).
Fai riferimento alla sintassi in [Riferimento alle classi di schemaAWS Glue](https://docs.aws.amazon.com/glue/latest/dg/developing-blueprints-code-classes.html) per definire processo, crawler e flusso di lavoro AWS Glue nello script di layout.
# Autorizzazioni per utenti e ruoli per gli schemi AWS Glue
Di seguito sono riportati i personaggi tipici e le politiche di autorizzazione suggerite AWS Identity and Access Management (IAM) per i personaggi e i ruoli per i blueprint. AWS Glue
**Topics**
+ [Utenti dello schema](#blueprints-personas)
+ [Autorizzazioni per gli utenti dei piani](#blueprints-permssions)
+ [Autorizzazioni per i ruoli degli schemi](#blueprints-role-permissions)
## Utenti dello schema
Di seguito sono riportati i utenti generalmente coinvolti nel ciclo di vita dei piani AWS Glue.
| Utente | Description |
| --- | --- |
| Sviluppatore AWS Glue | Sviluppa, verifica e pubblica progetti. |
| Amministratore di AWS Glue | Registra, mantiene e concede le autorizzazioni per i piani. |
| Analista dei dati | Esegue i piani per creare flussi di lavoro. |
Per ulteriori informazioni, consulta [Panoramica degli schemi in AWS Glue](blueprints-overview.md).
## Autorizzazioni per gli utenti dei piani
Di seguito sono riportate le autorizzazioni suggerite per ogni utente del piano.
### Autorizzazioni per i progetti per lo sviluppatore di AWS Glue per gli schemi
Lo sviluppatore di AWS Glue deve disporre delle autorizzazioni di scrittura sul bucket Amazon S3 utilizzato per pubblicare il progetto. Spesso, lo sviluppatore registra il piano dopo averlo caricato. In tal caso, lo sviluppatore necessita delle autorizzazioni elencate in [Autorizzazioni per i progetti per l'amministratore di AWS Glue per gli schemi](#bp-persona-admin). Inoltre, se lo sviluppatore desidera testare il piano dopo la registrazione, ha bisogno anche delle autorizzazioni elencate in [Autorizzazioni per gli schemi per l'analista dati](#bp-persona-analyst).
### Autorizzazioni per i progetti per l'amministratore di AWS Glue per gli schemi
La policy seguente concede le autorizzazioni per la registrazione, la visualizzazione e la gestione dei progetti AWS Glue.
**Importante**
Nella seguente politica, sostituisci ** e ** con il percorso Amazon S3 per caricare gli archivi ZIP del blueprint da registrare.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:CreateBlueprint",
"glue:UpdateBlueprint",
"glue:DeleteBlueprint",
"glue:GetBlueprint",
"glue:ListBlueprints",
"glue:BatchGetBlueprints"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/prefix/*"
}
]
}
```
------
### Autorizzazioni per gli schemi per l'analista dati
Il criterio seguente concede le autorizzazioni per eseguire i piani e per visualizzare il flusso di lavoro e i relativi i componenti risultanti. Concede inoltre `PassRole` al ruolo che AWS Glue assume per creare il flusso di lavoro e i relativi componenti.
La policy concede le autorizzazioni su qualsiasi risorsa. Se desideri configurare un accesso granulare ai singoli blueprint, utilizza il seguente formato per il blueprint: ARNs
```
arn:aws:glue:::blueprint/
```
**Importante**
Nella seguente politica, sostituiscilo ** con un AWS account valido e sostituiscilo ** con il nome del ruolo usato per eseguire un blueprint. Consulta [Autorizzazioni per i ruoli degli schemi](#blueprints-role-permissions) per le autorizzazioni richieste da questo ruolo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:ListBlueprints",
"glue:GetBlueprint",
"glue:StartBlueprintRun",
"glue:GetBlueprintRun",
"glue:GetBlueprintRuns",
"glue:GetCrawler",
"glue:ListTriggers",
"glue:ListJobs",
"glue:BatchGetCrawlers",
"glue:GetTrigger",
"glue:BatchGetWorkflows",
"glue:BatchGetTriggers",
"glue:BatchGetJobs",
"glue:BatchGetBlueprints",
"glue:GetWorkflowRun",
"glue:GetWorkflowRuns",
"glue:ListCrawlers",
"glue:ListWorkflows",
"glue:GetJob",
"glue:GetWorkflow",
"glue:StartWorkflowRun"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::111122223333:role/role-name"
}
]
}
```
------
## Autorizzazioni per i ruoli degli schemi
Di seguito sono riportate le autorizzazioni suggerite per il ruolo IAM utilizzato per creare un flusso di lavoro da un piano. Il ruolo deve avere una relazione di trust con `glue.amazonaws.com`.
**Importante**
Nella seguente politica, sostituiscilo ** con un AWS account valido e ** sostituiscilo con il nome del ruolo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:CreateJob",
"glue:GetCrawler",
"glue:GetTrigger",
"glue:DeleteCrawler",
"glue:CreateTrigger",
"glue:DeleteTrigger",
"glue:DeleteJob",
"glue:CreateWorkflow",
"glue:DeleteWorkflow",
"glue:GetJob",
"glue:GetWorkflow",
"glue:CreateCrawler"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::111122223333:role/role-name"
}
]
}
```
------
**Nota**
Se i processi e i crawler nel flusso di lavoro assumono un ruolo diverso da questo, questa policy deve includere l'autorizzazione `iam:PassRole` su quel ruolo invece che sul ruolo del piano.
# 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)