Gestione delle condizioni di errore in una macchina a stati Step Functions

In questo tutorial, crei una macchina a AWS Step Functions stati con uno stato Task che richiama una funzione Lambda di esempio creata per generare un errore personalizzato.

Le attività sono una delleStati di fallback, per le quali è possibile configurare un campo. Catch Quando l'integrazione riceve degli errori, i passaggi successivi vengono scelti dal campo catch in base al nome dell'errore.

Passaggio 1: creare una funzione Lambda che genera un errore

Usa una funzione Lambda per simulare una condizione di errore.

1. Apri la AWS Lambda console all'indirizzo. https://console.aws.amazon.com/lambda/

2. Scegli Crea funzione.

3. Scegli Usa un blueprintStep Functions, cerca e scegli Lancia un errore personalizzato.

4. Nel campo Function name (Nome funzione), immettere ThrowErrorFunction.

5. In Role (Ruolo), scegliere Create a new role with basic Lambda permissions (Crea un nuovo ruolo con le autorizzazioni Lambda di base).

6. Scegli Crea funzione.

   Il codice seguente dovrebbe essere visualizzato nel riquadro del codice.

   export const handler = async () => {
       function CustomError(message) {
           this.name = 'CustomError';
           this.message = message;
       }
       CustomError.prototype = new Error();
   
       throw new CustomError('This is a custom error!');
   };
   

Fase 2: Verifica la tua funzione Lambda

Prima di creare una macchina a stati, verifica che la funzione Lambda generi la tua CustomError quando viene richiamata.

1. Seleziona la scheda Test.

2. Scegli Crea un nuovo evento e mantieni l'evento JSON predefinito

3. Scegli Test per richiamare la tua funzione con il tuo evento di test.

4. Espandi la funzione Executing per esaminare i dettagli dell'errore generato.

Ora hai una funzione Lambda pronta a generare un errore personalizzato.

Nel passaggio successivo, configurerai una macchina a stati per catturare e riprovare quell'errore.

Passaggio 3: crea la tua macchina a stati

Usa la console Step Functions per creare una macchina a stati che utilizza una Catch configurazione Stato del flusso di lavoro delle attività con una. La macchina a stati invocherà la funzione Lambda, che hai creato per simulare l'emissione di un errore quando la funzione viene richiamata. Step Functions riprova la funzione utilizzando un backoff esponenziale tra un tentativo e l'altro.

1. Apri la console Step Functions, scegli Macchine a stati dal menu, quindi scegli Crea macchina a stati.

2. Scegliete Crea da vuoto e, per il nome della macchina a stati, immetteteCatchErrorStateMachine.

3. Accetta il tipo predefinito (Standard), quindi scegli Continua per modificare la tua macchina a stati in Workflow Studio.

4. Scegli Codice per passare all'editor ASL, quindi sostituisci il codice con la seguente definizione di macchina a stati:

   {
     "Comment": "Example state machine that can catch a custom error thrown by a function integration.",
     "StartAt": "CreateAccount",
     "States": {
       "CreateAccount": {
         "Type": "Task",
         "Resource": "arn:aws:states:::lambda:invoke",
         "Output": "{% $states.result.Payload %}",
         "Arguments": {
           "FunctionName": "arn:aws:lambda:region:account-id:function:ThrowErrorFunction:$LATEST",
           "Payload": "{% $states.input %}"
         },
         "Catch": [
           {
             "ErrorEquals": [
               "CustomError"
             ],
             "Next": "CustomErrorFallback"
           },
           {
             "ErrorEquals": [
               "States.ALL"
             ],
             "Next": "CatchAllFallback"
           }
         ],
         "End": true,
         "Retry": [
           {
             "ErrorEquals": [
               "CustomError",
               "Lambda.ServiceException",
               "Lambda.AWSLambdaException",
               "Lambda.SdkClientException",
               "Lambda.TooManyRequestsException"
             ],
             "IntervalSeconds": 1,
             "MaxAttempts": 3,
             "BackoffRate": 2,
             "JitterStrategy": "FULL"
           }
         ]
       },
       "CustomErrorFallback": {
         "Type": "Pass",
         "End": true,
         "Output": {
           "Result": "Fallback from a custom error function."
         }
       },
       "CatchAllFallback": {
         "Type": "Pass",
         "End": true,
         "Output": {
           "Result": "Fallback from all other error codes."
         }
       }
     },
     "QueryLanguage": "JSONata"
   }

Passaggio 4: configura la tua macchina a stati

Prima di avviare la macchina a stati, è necessario connettersi alla funzione Lambda creata in precedenza.

1. Tornate alla modalità Progettazione e selezionate lo stato dell'attività Lambda: Invoke denominato. CreateAccount

2. Nella scheda Configurazione, cerca API Arguments. Per Nome funzione scegli la funzione Lambda che hai creato in precedenza.

3. Scegli Crea, esamina i ruoli, quindi scegli Conferma per creare la tua macchina a stati.

Passaggio 5: Esegui la macchina a stati

Dopo aver creato e configurato la macchina a stati, puoi eseguirla ed esaminare il flusso.

1. Nell'editor, scegli Esegui.

   In alternativa, dall'elenco delle macchine a stati, scegli Avvia esecuzione.

2. Nella finestra di dialogo Avvia esecuzione, accettate l'ID generato e, per Input, immettete il seguente codice JSON:

   { "Cause" : "Custom Function Error" }

3. Selezionare Start execution (Avvia esecuzione).

La console Step Functions ti indirizza a una pagina intitolata con il tuo ID di esecuzione, nota come pagina Execution Details. È possibile esaminare i risultati dell'esecuzione man mano che il flusso di lavoro procede e 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, vederePanoramica dei dettagli di esecuzione.

La tua macchina a stati richiama la funzione Lambda, che genera un. CustomError Scegliete il CreateAccountpassaggio nella vista Grafico per vedere l'output dello stato. L'output della macchina a stati dovrebbe essere simile alla seguente illustrazione:

Complimenti!

Ora hai una macchina a stati in grado di catturare e gestire le condizioni di errore generate da una funzione Lambda. È possibile utilizzare questo modello per implementare una solida gestione degli errori nei flussi di lavoro.

Nota

È inoltre possibile creare macchine a stati che riprovano in base ai timeout o quelle utilizzate Catch per passare a uno stato specifico quando si verifica un errore o un timeout. Per esempi di queste tecniche di gestione degli errori, consultare Esempi di utilizzo di Retry e di Catch.