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à.
# 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 delle[Stati di fallback](concepts-error-handling.md#error-handling-fallback-states), 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/](https://console.aws.amazon.com/lambda/)
1. Scegli **Crea funzione**.
1. Scegli **Usa un blueprint**`Step Functions`, cerca e scegli **Lancia un errore personalizzato**.
1. Nel campo **Function name (Nome funzione)**, immettere `ThrowErrorFunction`.
1. In **Role (Ruolo)**, scegliere **Create a new role with basic Lambda permissions (Crea un nuovo ruolo con le autorizzazioni Lambda di base)**.
1. 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**.
1. **Scegli **Crea un nuovo evento e mantieni l'evento** JSON predefinito**
1. Scegli **Test** per richiamare la tua funzione con il tuo evento di test.
1. 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à](state-task.md) 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](https://console.aws.amazon.com/states/home), scegli **Macchine a stati** dal menu, quindi scegli **Crea macchina a stati**.
1. Scegliete **Crea da vuoto** e, per il **nome della macchina a stati**, immettete*CatchErrorStateMachine*.
1. Accetta il tipo predefinito (Standard), quindi scegli **Continua** per modificare la tua macchina a stati in Workflow Studio.
1. 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**
1. Nella scheda **Configurazione**, cerca **API** Arguments. Per **Nome funzione** scegli la funzione Lambda che hai creato in precedenza.
1. 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**.
1. Nella finestra di dialogo **Avvia esecuzione**, accettate l'ID generato e, per **Input**, immettete il seguente codice JSON:
```
{ "Cause" : "Custom Function Error" }
```
1. 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](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 tua macchina a stati richiama la funzione Lambda, che genera un. `CustomError` Scegliete il **CreateAccount**passaggio nella **vista Grafico** per vedere l'output dello stato. L'output della macchina a stati dovrebbe essere simile alla seguente illustrazione:
![\[Schermata illustrativa del flusso di lavoro che rileva l'errore personalizzato.\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/tutorial-console-retry-state-machine-error-output.png)
**Complimenti\$1**
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](concepts-error-handling.md#error-handling-retrying-after-an-error) 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](concepts-error-handling.md#error-handling-examples).