Prerequisiti Passaggio 1: creare una funzione Lambda per iterare un conteggio Fase 2: Creare una funzione Restart Lambda per avviare una nuova esecuzione di Step Functions Fase 3: Creare una macchina a stati Fase 4: Aggiornare la policy IAM Fase 5: Esegui la macchina a stati

Utilizzo di una funzione Lambda per continuare una nuova esecuzione

È possibile creare una macchina a stati che utilizza una funzione Lambda per avviare una nuova esecuzione prima del termine dell'esecuzione corrente. L'utilizzo di questo approccio per continuare il lavoro in corso con una nuova esecuzione consente di disporre di una macchina a stati in grado di suddividere lavori di grandi dimensioni in flussi di lavoro più piccoli o di avere una macchina a stati che funziona all'infinito.

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 Lambda 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 `countindex`, 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 per assicurarti di avere familiarità con l'uso congiunto di Lambda e Step Functions.

Argomenti

Passaggio 1: creare una funzione Lambda per iterare un conteggio
Fase 2: Creare una funzione Restart Lambda per avviare una nuova esecuzione di Step Functions
Fase 3: Creare una macchina a stati
Fase 4: Aggiornare la policy IAM
Fase 5: Esegui la macchina a stati

Passaggio 1: creare una funzione Lambda per iterare un conteggio

Nota

Se hai completato il Iterare un ciclo con Lambda tutorial, puoi saltare questo passaggio e utilizzare la funzione Lambda.

Questa sezione e il Iterare un ciclo con Lambda 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 countindex, 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

Aprire la console Lambda, quindi scegliere Create function (Crea funzione).
Nella pagina Create function (Crea funzione), scegliere Author from scratch (Crea da zero).
Nella sezione Informazioni di base, configura la tua funzione Lambda come segue:
1. Nel campo Function name (Nome funzione), immettere Iterator.
2. Per Runtime scegli Node.js 16.x.
3. 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:us-east-1:123456789012:function:Iterator
```
Copia il codice seguente per la funzione Lambda nella sezione Codice sorgente della pagina Iterator 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.
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

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).
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.
Scegli Crea.
Nella pagina Iterator della console Lambda, TestIteratorassicurati che 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

Aprire la console Lambda, quindi scegliere Create function (Crea funzione).
Nella pagina Create function (Crea funzione), scegliere Author from scratch (Crea da zero).
Nella sezione Informazioni di base, configura la tua funzione Lambda come segue:
1. Nel campo Function name (Nome funzione), immettere Restart.
2. Per Runtime scegli Node.js 16.x.
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:us-east-1:123456789012:function:Iterator
```

Copia il codice seguente per la funzione Lambda nella sezione Codice sorgente della pagina Riavvia 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);
  });

}

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.

Esempio 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.

Esempio 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:us-east-1:123456789012:function:Restart",
  "Next": "Done"
},

Per creare la macchina a stati

Apri la console Step Functions e 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.
Nella finestra di dialogo Scegli un modello, seleziona Vuoto.
Scegli Seleziona. Questo apre Workflow Studio inModalità di progettazione.
Per questo tutorial, scriverai la definizione Amazon States Language (ASL) della tua macchina a stati in. Editor del codice Per fare ciò, scegli Codice.

Rimuovi il codice boilerplate esistente e incolla il codice seguente. Ricordati di sostituire gli ARN in questo codice con gli ARN delle 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:us-east-1: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:us-east-1:123456789012:function:Restart",
          "Next": "Done"
        },
        "Done": {
            "Type": "Pass",
            "End": true 
        }
    }
}

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.
(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 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.
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.
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 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:123456789012stateMachine: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.

Nella ContinueAsNewpagina, scegli Avvia esecuzione.

Viene visualizzata la finestra di dialogo Avvia esecuzione.
Nella finestra di dialogo Avvia esecuzione, effettuate le seguenti operazioni:
1. (Facoltativo) Per identificare l'esecuzione, potete specificarne un nome nella casella Nome. Per impostazione predefinita, Step Functions genera automaticamente un nome di esecuzione univoco.
  
  Nota
  Step Functions consente di creare nomi per macchine a stati, esecuzioni e attività ed etichette che contengono caratteri non ASCII. Questi nomi non ASCII non funzionano con Amazon. CloudWatch Per assicurarti di poter tenere traccia delle CloudWatch metriche, scegli un nome che utilizzi solo caratteri ASCII.
2. Nella casella Input, inserisci il seguente input JSON per eseguire il flusso di lavoro.
```
{
  "restart": {
    "StateMachineArn": "arn:aws:states:us-east-1:123456789012:stateMachine:ContinueAsNew",
    "executionCount": 4
  }
}
        
```
3. Aggiornare il campo StateMachineArn con l'ARN della macchina a stati ContinueAsNew.
4. Selezionare Start execution (Avvia esecuzione).
5. 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 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, vederePagina dei dettagli di esecuzione: panoramica dell'interfaccia.
  
  La vista Grafico mostra la prima delle quattro esecuzioni. Prima del completamento, passando per lo stato Restart verrà avviata una nuova esecuzione.
  
  Una volta completata questa esecuzione, puoi esaminare l'esecuzione successiva in esecuzione. Seleziona il ContinueAsNewlink 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.