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à. # Utilizzo di una funzione Lambda per continuare una nuova esecuzione in Step Functions **Suggerimento** L'approccio seguente utilizza una funzione Lambda per avviare una nuova esecuzione del flusso di lavoro. Si **consiglia di** utilizzare uno stato Step Functions Task per avviare nuove esecuzioni di workflow. Scopri come nel seguente tutorial: **[Continua i flussi di lavoro di lunga durata utilizzando l'API Step Functions (consigliato)](tutorial-continue-new.md)**. È possibile creare una macchina a stati che utilizza una funzione Lambda per avviare una nuova esecuzione prima del termine dell'esecuzione corrente. Con questo approccio per continuare il lavoro in corso in una nuova esecuzione, è possibile suddividere lavori di grandi dimensioni in flussi di lavoro più piccoli o eseguire un flusso di lavoro a tempo indeterminato. Questo tutorial si basa sul concetto di utilizzo di una funzione Lambda esterna per modificare il flusso di lavoro, come dimostrato nel [Iterare un ciclo con una funzione Lambda in Step Functions](tutorial-create-iterate-pattern-section.md) tutorial. Utilizzate la stessa funzione Lambda (`Iterator`) per iterare un ciclo per un numero specifico di volte. Inoltre, crei un'altra funzione Lambda per iniziare una nuova esecuzione del flusso di lavoro e per diminuire il conteggio ogni volta che inizia una nuova esecuzione. La macchina a stati terminerà e riavvierà un'esecuzione per il numero di volte specificato nei dati di input. La macchina a stati da creare implementa i seguenti stati. | Stato | Scopo | | --- | --- | | `ConfigureCount` | Uno `Pass` stato che configura i `step` valori `count``index`, e utilizzati dalla funzione `Iterator` Lambda per eseguire le iterazioni del lavoro. | | `Iterator` | Uno `Task` stato che fa riferimento alla funzione `Iterator` Lambda. | | `IsCountReached` | Uno Choice stato che utilizza un valore booleano della Iterator funzione per decidere se la macchina a stati deve continuare a funzionare l'esempio o passare allo stato. ShouldRestart | | `ExampleWork` | Uno Pass stato che rappresenta lo Task stato che eseguirebbe il lavoro in un'implementazione effettiva. | | `ShouldRestart` | Uno Choice stato che utilizza il executionCount valore per decidere se terminare un'esecuzione e iniziarne un'altra, o semplicemente terminare. | | `Restart` | Uno Task stato che utilizza una funzione Lambda per avviare una nuova esecuzione della macchina a stati. Anche questa funzione, come l'Iterator, decrementa i contatori. Lo Restart stato passa il valore decrementato del conteggio all'input della nuova esecuzione. | ## Prerequisiti Prima di iniziare, segui il [Creazione di una macchina a stati Step Functions che utilizza Lambda](tutorial-creating-lambda-state-machine.md) tutorial per assicurarti di avere familiarità con l'uso congiunto di Lambda e Step Functions. ## Passaggio 1: creare una funzione Lambda per iterare un conteggio **Nota** Se hai completato il [Iterare un ciclo con una funzione Lambda in Step Functions](tutorial-create-iterate-pattern-section.md) tutorial, puoi saltare questo passaggio e utilizzare la funzione Lambda. Questa sezione e il [Iterare un ciclo con una funzione Lambda in Step Functions](tutorial-create-iterate-pattern-section.md) tutorial mostrano come utilizzare una funzione Lambda per tenere traccia di un conteggio, ad esempio il numero di iterazioni di un ciclo nella macchina a stati. La seguente funzione Lambda riceve valori di input per `count``index`, e. `step` Restituisce quindi tali valori con un `index` aggiornato e un booleano denominato `continue`. La funzione Lambda viene impostata `continue` su `true` se `index` è minore di. `count` La macchina a stati quindi implementa uno stato `Choice` che esegue alcune logiche di applicazione se `continue` è `true` o passa a `ShouldRestart` se `continue` è `false`. ### Creare la funzione Iterate Lambda 1. Aprire la [console Lambda](https://console.aws.amazon.com/lambda/home), quindi scegliere **Create function (Crea funzione)**. 1. Nella pagina **Create function (Crea funzione)**, scegliere **Author from scratch (Crea da zero)**. 1. Nella sezione **Informazioni di base**, configura la tua funzione Lambda come segue: 1. Nel campo **Function name (Nome funzione)**, immettere `Iterator`. 1. Per **Runtime** scegli **Node.js 16.x**. 1. Mantieni tutte le selezioni predefinite sulla pagina, quindi scegli **Crea** funzione. Quando viene creata la funzione Lambda, prendi nota del relativo Amazon Resource Name (ARN) nell'angolo in alto a destra della pagina, ad esempio: ``` arn:aws:lambda:region:123456789012:function:Iterator ``` 1. Copia il codice seguente per la funzione Lambda nella sezione **Codice sorgente** della ***Iterator***pagina della console Lambda. ``` exports.handler = function iterator (event, context, callback) { let index = event.iterator.index; let step = event.iterator.step; let count = event.iterator.count; index = index + step; callback(null, { index, step, count, continue: index < count }) } ``` Questo codice ammette valori di input per `count`, `index` e `step`. Incrementa l'`index` del valore di `step` e restituisce tali valori e il valore booleano di `continue`. Il valore di `continue` è `true` se `index` è inferiore a `count`. 1. Scegli **Deploy** per distribuire il codice. ### Prova la funzione Iterate Lambda Per apprezzarne il funzionamento, basta eseguire la funzione `Iterate` con valori numerici. Puoi fornire valori di input per la tua funzione Lambda che imitano un'iterazione per vedere quale output ottieni con valori di input specifici. #### Per testare la tua funzione Lambda 1. Nella finestra di dialogo **Configure test event (Configura evento test)**, selezionare **Create new test event (Crea nuovo evento test)**, per poi specificare `TestIterator` come **Event name (Nome evento)**. 1. Sostituire i dati di esempio con quanto segue. ``` { "Comment": "Test my Iterator function", "iterator": { "count": 10, "index": 5, "step": 1 } } ``` Tali valori simulano quelli generati da una macchina a stati durante un'iterazione. La funzione Lambda incrementa l'indice e restituisce as. `continue` `true` Quando raggiunge un valore pari o superiore a `count`, l'indice restituisce `continue` come `false`. Per questo test, l'indice ha già subito un incremento a `5`. I risultati dovrebbero annoverare l'incremento dell'`index` a `6` e l'impostazione di `continue` su `true`. 1. Scegli **Create** (Crea). 1. **Nella ***Iterator*** pagina della console Lambda, assicurati che **TestIterator**sia elencato, quindi scegli Test.** I risultati del test vengono visualizzati nella parte superiore della pagina. Selezionare **Details (Dettagli)** ed esaminare i risultati. ``` { "index": 6, "step": 1, "count": 10, "continue": true } ``` **Nota** Un test eseguito con l'`index` impostato su `9` prevede l'incremento di tale `index` a `10` e l'impostazione di `continue` su `false`. ## Fase 2: Creare una funzione Restart Lambda per avviare una nuova esecuzione di Step Functions 1. Aprire la [console Lambda](https://console.aws.amazon.com/lambda/home), quindi scegliere **Create function (Crea funzione)**. 1. Nella pagina **Create function (Crea funzione)**, scegliere **Author from scratch (Crea da zero)**. 1. Nella sezione **Informazioni di base**, configura la tua funzione Lambda come segue: 1. Nel campo **Function name (Nome funzione)**, immettere `Restart`. 1. Per **Runtime** scegli **Node.js 16.x**. 1. Mantieni tutte le selezioni predefinite sulla pagina, quindi scegli **Crea** funzione. Quando viene creata la funzione Lambda, prendi nota del relativo Amazon Resource Name (ARN) nell'angolo in alto a destra della pagina, ad esempio: ``` arn:aws:lambda:region:123456789012:function:Iterator ``` 1. Copia il codice seguente per la funzione Lambda nella sezione **Codice sorgente** della ***Restart***pagina della console Lambda. Il codice seguente riduce il conteggio del numero di esecuzioni e avvia una nuova esecuzione della macchina a stati, includendo il valore ridotto. ``` var aws = require('aws-sdk'); var sfn = new aws.StepFunctions(); exports.restart = function(event, context, callback) { let StateMachineArn = event.restart.StateMachineArn; event.restart.executionCount -= 1; event = JSON.stringify(event); let params = { input: event, stateMachineArn: StateMachineArn }; sfn.startExecution(params, function(err, data) { if (err) callback(err); else callback(null,event); }); } ``` 1. Scegli **Deploy** per distribuire il codice. ## Fase 3: Creare una macchina a stati Ora che hai creato le tue due funzioni Lambda, crea una macchina a stati. In questa macchina a stati, gli stati `ShouldRestart` e `Restart` rispecchiano la suddivisione del lavoro in più esecuzioni. **Example ShouldRestart Stato della scelta** Il seguente estratto mostra lo stato. `ShouldRestart` `Choice` Questo stato determina se riavviare o meno l'esecuzione. ``` "ShouldRestart": { "Type": "Choice", "Choices": [ { "Variable": "$.restart.executionCount", "NumericGreaterThan": 1, "Next": "Restart" } ], ``` Il valore `$.restart.executionCount` è incluso nell'input dell'esecuzione iniziale. Cala di uno a ogni chiamata della funzione `Restart` e poi viene incluso nell'input dell'esecuzione successiva. **Example Stato Task Restart** Il seguente estratto mostra lo stato. `Restart` `Task` Questo stato utilizza la funzione Lambda creata in precedenza per riavviare l'esecuzione e per diminuire il conteggio per tenere traccia del numero rimanente di esecuzioni da avviare. ``` "Restart": { "Type": "Task", "Resource": "arn:aws:lambda:region:123456789012:function:Restart", "Next": "Done" }, ``` **Per creare la macchina a stati** 1. Apri la [console Step Functions](https://console.aws.amazon.com/states/home), scegli **Macchine a stati** dal menu, quindi scegli **Crea macchina a stati**. **Importante** [Assicurati che la tua macchina a stati utilizzi lo stesso AWS account e la stessa regione delle funzioni Lambda che hai creato in precedenza nei [passaggi 1 e 2](#tutorial-continue-new-step-1).](#tutorial-continue-new-step-3) 1. Scegli **Crea da vuoto**. 1. Assegna un nome alla tua macchina a stati, quindi scegli **Continua** per modificare la tua macchina a stati in Workflow Studio. 1. Per questo tutorial, scriverai la definizione [Lingua degli Stati di Amazon](concepts-amazon-states-language.md) (ASL) della tua macchina a stati in. [Editor del codice](workflow-studio.md#wfs-interface-code-editor) Per fare ciò, scegli **Codice.** 1. Rimuovi il codice boilerplate esistente e incolla il codice seguente. Ricordati di sostituirle ARNs in questo codice con le ARNs funzioni Lambda che hai creato. ``` { "Comment": "Continue-as-new State Machine Example", "StartAt": "ConfigureCount", "States": { "ConfigureCount": { "Type": "Pass", "Result": { "count": 100, "index": -1, "step": 1 }, "ResultPath": "$.iterator", "Next": "Iterator" }, "Iterator": { "Type": "Task", "Resource": "arn:aws:lambda:region:123456789012:function:Iterator", "ResultPath": "$.iterator", "Next": "IsCountReached" }, "IsCountReached": { "Type": "Choice", "Choices": [ { "Variable": "$.iterator.continue", "BooleanEquals": true, "Next": "ExampleWork" } ], "Default": "ShouldRestart" }, "ExampleWork": { "Comment": "Your application logic, to run a specific number of times", "Type": "Pass", "Result": { "success": true }, "ResultPath": "$.result", "Next": "Iterator" }, "ShouldRestart": { "Type": "Choice", "Choices": [ { "Variable": "$.restart.executionCount", "NumericGreaterThan": 0, "Next": "Restart" } ], "Default": "Done" }, "Restart": { "Type": "Task", "Resource": "arn:aws:lambda:region:123456789012:function:Restart", "Next": "Done" }, "Done": { "Type": "Pass", "End": true } } } ``` 1. Specificate un nome per la vostra macchina a stati. Per fare ciò, scegli l'icona di modifica accanto al nome della macchina a stati predefinita di **MyStateMachine**. Quindi, nella **configurazione della macchina a stati**, specifica un nome nella casella **Nome macchina a stati**. Per questo tutorial, inserisci il nome **ContinueAsNew**. 1. (Facoltativo) Nella **configurazione della macchina a stati**, specificate altre impostazioni del flusso di lavoro, come il tipo di macchina a stati e il relativo ruolo di esecuzione. Per questo tutorial, mantieni tutte le selezioni predefinite nelle **impostazioni della macchina a stati**. Se [in precedenza hai creato un ruolo IAM](procedure-create-iam-role.md) con le autorizzazioni corrette per la tua macchina a stati e desideri utilizzarlo, in **Autorizzazioni** seleziona **Scegli un ruolo esistente**, quindi seleziona un ruolo dall'elenco. Oppure seleziona **Inserisci un ruolo ARN** e quindi fornisci un ARN per quel ruolo IAM. 1. Nella finestra di dialogo **Conferma la creazione del ruolo**, scegli **Conferma** per continuare. Puoi anche scegliere **Visualizza le impostazioni del ruolo** per tornare alla **configurazione della macchina a stati**. **Nota** Se elimini il ruolo IAM creato da Step Functions, Step Functions non può ricrearlo in un secondo momento. Allo stesso modo, se modifichi il ruolo (ad esempio, rimuovendo Step Functions dai principi nella policy IAM), Step Functions non può ripristinare le impostazioni originali in un secondo momento. 1. Salva l'Amazon Resource Name (ARN) di questa macchina a stati in un file di testo. Dovrai fornire l'ARN mentre autorizzi la funzione Lambda per avviare una nuova esecuzione di Step Functions. ## Fase 4: Aggiornare la policy IAM Per assicurarti che la tua funzione Lambda disponga delle autorizzazioni necessarie per avviare una nuova esecuzione di Step Functions, allega una policy in linea al ruolo IAM che usi per la tua funzione Lambda. `Restart` *Per ulteriori informazioni, consulta [Embedding Inline Policies](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#embed-inline-policy-console) nella IAM User Guide.* **Nota** È possibile modificare la riga `Resource` dell'esempio precedente, affinché includa l'ARN della macchina a stati `ContinueAsNew`. Così facendo, si limita la policy in modo che vengano avviate solo esecuzioni di tale macchina a stati. **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Allow", "Action": [ "states:StartExecution" ], "Resource": "arn:aws:states:us-east-2:123456789012:stateMachine:ContinueAsNew" } ] } ``` ## Fase 5: Esegui la macchina a stati Per avviare un'esecuzione, bisogna fornire un input che includa l'ARN della macchina a stati e l'`executionCount`, che rappresenta il numero di volte in cui è necessario avviare una nuova esecuzione. 1. Nella **ContinueAsNew**pagina, scegli **Avvia esecuzione**. Viene visualizzata la finestra di dialogo **Avvia esecuzione**. 1. Nella finestra di dialogo **Avvia esecuzione**, effettuate le seguenti operazioni: 1. (Facoltativo) Inserite un nome di esecuzione personalizzato per sovrascrivere il valore predefinito generato. **Nomi e log non ASCII** Step Functions accetta nomi per macchine a stati, esecuzioni, attività ed etichette che contengono caratteri non ASCII. Poiché tali caratteri impediranno ad Amazon CloudWatch di registrare i dati, consigliamo di utilizzare solo caratteri ASCII per tenere traccia delle metriche di Step Functions. 1. Nella casella **Input**, inserisci il seguente input JSON per eseguire il flusso di lavoro. ``` { "restart": { "StateMachineArn": "arn:aws:states:region:account-id:stateMachine:ContinueAsNew", "executionCount": 4 } } ``` 1. Aggiornare il campo `StateMachineArn` con l'ARN della macchina a stati `ContinueAsNew`. 1. Selezionare **Start execution (Avvia esecuzione)**. 1. La console Step Functions ti indirizza a una pagina intitolata con il tuo ID di esecuzione. Questa pagina è nota come pagina dei *dettagli di esecuzione*. In questa pagina è possibile esaminare i risultati dell'esecuzione man mano che l'esecuzione procede o dopo il suo completamento. Per esaminare i risultati dell'esecuzione, scegliete i singoli stati nella **vista Grafico**, quindi scegliete le singole schede [Dettagli del passaggio](concepts-view-execution-details.md#exec-details-intf-step-details) nel riquadro per visualizzare i dettagli di ogni stato, inclusi rispettivamente input, output e definizione. Per i dettagli sulle informazioni sull'esecuzione che è possibile visualizzare nella pagina *Dettagli di esecuzione*, vedere[Panoramica dei dettagli di esecuzione](concepts-view-execution-details.md#exec-details-interface-overview). La **vista Grafico** mostra la prima delle quattro esecuzioni. Prima del completamento, passando per lo stato `Restart` verrà avviata una nuova esecuzione. ![\[Diagramma di esecuzione che mostra la prima esecuzione su quattro.\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/execution-test1.png) Una volta completata questa esecuzione, puoi esaminare l'esecuzione successiva in esecuzione. Seleziona il **ContinueAsNew**link in alto per visualizzare l'elenco delle esecuzioni. Dovresti vedere sia l'esecuzione chiusa di recente che l'esecuzione in corso avviata dalla funzione `Restart` Lambda. Una volta completate, tutte le quattro esecuzioni saranno visibili nell'elenco. L'esecuzione avviata per prima mostra il nome scelto dall'utente; le altre, invece, presentano un nome generato. ![\[Schermata illustrativa che mostra tutte le esecuzioni completate.\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/execution-test1-complete.png)