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

# Esame delle esecuzioni delle macchine a stati in Step Functions
<a name="debug-sm-exec-using-ui"></a>

In questo tutorial, imparerai come controllare le informazioni sull'esecuzione visualizzate nella pagina *Dettagli di esecuzione* e visualizzare il motivo di un'esecuzione non riuscita. Quindi, imparerai come accedere a diverse iterazioni di un'esecuzione di `Map` stato. Infine, imparerai come configurare le colonne nella **vista Tabella** e applicare filtri adeguati per visualizzare solo le informazioni di tuo interesse.

In questo tutorial, creerai una macchina a stati di tipo Standard, che ottiene il prezzo di un set di frutta. Per fare ciò, la macchina a stati utilizza tre AWS Lambda funzioni che restituiscono un elenco casuale di quattro frutti, il prezzo di ogni frutto e il costo medio dei frutti. Le funzioni Lambda sono progettate per generare un errore se il prezzo dei frutti è inferiore o uguale a un valore di soglia.

**Nota**  
Sebbene la procedura seguente contenga istruzioni su come esaminare i dettagli dell'esecuzione di un flusso di lavoro Standard, è possibile esaminare anche i dettagli per le esecuzioni del flusso di lavoro Express. Per informazioni sulle differenze tra i dettagli di esecuzione per i tipi di flusso di lavoro Standard ed Express, vedere[Differenze di esperienza tra console Standard ed Express](concepts-view-execution-details.md#console-exp-differences).

## Fase 1: Creare e testare le funzioni Lambda richieste
<a name="step-create-all-lambda-functions"></a>

1. Apri la [console Lambda](https://console.aws.amazon.com/lambda/home) ed esegui i passaggi da 1 a 4 della [Fase 1: creare una funzione Lambda](tutorial-creating-lambda-state-machine.md#create-lambda-function) sezione. Assicurati di assegnare un nome alla funzione Lambda. **GetListOfFruits**

1. Dopo aver creato la funzione Lambda, copia l'Amazon Resource Name (ARN) della funzione visualizzato nell'angolo in alto a destra della pagina. Per copiare l'ARN, fai clic sull'icona di copia per copiare l'Amazon Resource Name della funzione Lambda. Di seguito è riportato un esempio di ARN, dove *`function-name`* è il nome della funzione Lambda (in questo caso,): `GetListOfFruits`

   ```
   arn:aws:lambda:region:123456789012:function:function-name
   ```

1. Copia il codice seguente per la funzione Lambda nell'area **Codice sorgente** della **GetListOfFruits**pagina.

   ```
   function getRandomSubarray(arr, size) {
       var shuffled = arr.slice(0), i = arr.length, temp, index;
       while (i--) {
           index = Math.floor((i + 1) * Math.random());
           temp = shuffled[index];
           shuffled[index] = shuffled[i];
           shuffled[i] = temp;
       }
       return shuffled.slice(0, size);
   }
   
   exports.handler = async function(event, context) {
       
       const fruits = ['Abiu','Açaí','Acerola','Ackee','African cucumber','Apple','Apricot','Avocado','Banana','Bilberry','Blackberry','Blackcurrant','Jostaberry'];
   
       
        const errorChance = 45;
       
       const waitTime = Math.floor( 100 * Math.random() );
   
       await new Promise( r => setTimeout(() => r(), waitTime));
   
       const num = Math.floor( 100 * Math.random() );
       // const num = 51;
        if (num <= errorChance) {
            throw(new Error('Error'));
        }
   
       return getRandomSubarray(fruits, 4);
   };
   ```

1. Scegli **Deploy**, quindi scegli **Test**, per distribuire le modifiche e vedere l'output della tua funzione Lambda.

1. Crea due funzioni Lambda aggiuntive, denominate **GetFruitPrice** e **CalculateAverage** rispettivamente, con i seguenti passaggi:

   1. Copia il codice seguente nell'area **Codice sorgente** della funzione **GetFruitPrice**Lambda:

      ```
      exports.handler = async function(event, context) {
          
          const errorChance = 0;
          const waitTime = Math.floor( 100 * Math.random() );
      
          await new Promise( r => setTimeout(() => r(), waitTime));
      
          const num = Math.floor( 100 * Math.random() );
          if (num <= errorChance) {
              throw(new Error('Error'));
          }
      
          return Math.floor(Math.random()*100)/10;
      };
      ```

   1. Copia il codice seguente nell'area **Codice sorgente** della funzione **CalculateAverage**Lambda:

      ```
      function getRandomSubarray(arr, size) {
          var shuffled = arr.slice(0), i = arr.length, temp, index;
          while (i--) {
              index = Math.floor((i + 1) * Math.random());
              temp = shuffled[index];
              shuffled[index] = shuffled[i];
              shuffled[i] = temp;
          }
          return shuffled.slice(0, size);
      }
      
      const average = arr => arr.reduce( ( p, c ) => p + c, 0 ) / arr.length;
          
      exports.handler = async function(event, context) {
              const errors = [
              "Error getting data from DynamoDB",
              "Error connecting to DynamoDB",
              "Network error",
              "MemoryError - Low memory"
              ]
              
          const errorChance = 0;
          
          const waitTime = Math.floor( 100 * Math.random() );
      
          await new Promise( r => setTimeout(() => r(), waitTime));
      
          const num = Math.floor( 100 * Math.random() );
          if (num <= errorChance) {
              throw(new Error(getRandomSubarray(errors, 1)[0]));
          }
      
          return average(event);
      };
      ```

   1. **Assicurati ARNs di copiare queste due funzioni Lambda, quindi **distribuiscile** e testale.**

## Fase 2: Creare ed eseguire la macchina a stati
<a name="step-create-exec-sm"></a>

Usa la [console Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) per creare una macchina a stati che richiami le [funzioni Lambda che hai creato](#step-create-all-lambda-functions) nello Step 1. In questa macchina a stati, sono definiti tre `Map` stati. Ciascuno di questi `Map` stati contiene uno `Task` stato che richiama una delle tue funzioni Lambda. Inoltre, viene definito un `Retry` campo in ogni `Task` stato con un numero di tentativi di nuovo tentativo definiti per ogni stato. Se uno `Task` stato rileva un errore di runtime, viene eseguito nuovamente fino al numero di tentativi di nuovo tentativo definito per quello stato. `Task`

1. Apri la [console Step Functions](https://console.aws.amazon.com/states/home) e scegli **Scrivi il tuo flusso di lavoro nel codice**.
**Importante**  
Assicurati che la tua macchina a stati utilizzi lo stesso AWS account e la stessa regione della funzione Lambda che hai creato in precedenza.

1. Per **Tipo**, mantieni la selezione predefinita di **Standard**.

1. Copia la seguente definizione di Amazon States Language e incollala in **Definition**. Assicurati di sostituire le funzioni ARNs mostrate con quelle delle funzioni Lambda che hai creato in precedenza.

   ```
   {
       "StartAt": "LoopOverStores",
       "States": {
           "LoopOverStores": {
               "Type": "Map",
               "Iterator": {
                   "StartAt": "GetListOfFruits",
                   "States": {
                       "GetListOfFruits": {
                           "Type": "Task",
                           "Resource": "arn:aws:states:::lambda:invoke",
                           "OutputPath": "$.Payload",
                           "Parameters": {
                               "FunctionName": "arn:aws:lambda:region:123456789012:function:GetListofFruits:$LATEST",
                               "Payload": {
                                   "storeName.$": "$"
                               }
                           },
                           "Retry": [
                               {
                                   "ErrorEquals": [
                                       "States.ALL"
                                   ],
                                   "IntervalSeconds": 2,
                                   "MaxAttempts": 1,
                                   "BackoffRate": 1.3
                               }
                           ],
                           "Next": "LoopOverFruits"
                       },
                       "LoopOverFruits": {
                           "Type": "Map",
                           "Iterator": {
                               "StartAt": "GetFruitPrice",
                               "States": {
                                   "GetFruitPrice": {
                                       "Type": "Task",
                                       "Resource": "arn:aws:states:::lambda:invoke",
                                       "OutputPath": "$.Payload",
                                       "Parameters": {
                                           "FunctionName": "arn:aws:lambda:region:123456789012:function:GetFruitPrice:$LATEST",
                                           "Payload": {
                                               "fruitName.$": "$"
                                           }
                                       },
                                       "Retry": [
                                           {
                                               "ErrorEquals": [
                                                   "States.ALL"
                                               ],
                                               "IntervalSeconds": 2,
                                               "MaxAttempts": 3,
                                               "BackoffRate": 1.3
                                           }
                                       ],
                                       "End": true
                                   }
                               }
                           },
                           "ItemsPath": "$",
                           "End": true
                       }
                   }
               },
               "ItemsPath": "$.stores",
               "Next": "LoopOverStoreFruitsPrice",
               "ResultPath": "$.storesFruitsPrice"
           },
           "LoopOverStoreFruitsPrice": {
               "Type": "Map",
               "End": true,
               "Iterator": {
                   "StartAt": "CalculateAverage",
                   "States": {
                       "CalculateAverage": {
                           "Type": "Task",
                           "Resource": "arn:aws:states:::lambda:invoke",
                           "OutputPath": "$.Payload",
                           "Parameters": {
                               "FunctionName": "arn:aws:lambda:region:123456789012:function:Calculate-average:$LATEST",
                               "Payload.$": "$"
                           },
                           "Retry": [
                               {
                                   "ErrorEquals": [
                                       "States.ALL"
                                   ],
                                   "IntervalSeconds": 2,
                                   "MaxAttempts": 2,
                                   "BackoffRate": 1.3
                               }
                           ],
                           "End": true
                       }
                   }
               },
               "ItemsPath": "$.storesFruitsPrice",
               "ResultPath": "$.storesPriceAverage",
               "MaxConcurrency": 1
           }
       }
   }
   ```

1. Inserisci un nome per la tua macchina a stati. Mantieni le selezioni predefinite per le altre opzioni in questa pagina e scegli **Crea macchina a stati**.

1. Apri la pagina intitolata con il nome della tua macchina a stati. Eseguite i passaggi da 1 a 4 della [Fase 4: Esegui la macchina a stati](tutorial-creating-lambda-state-machine.md#start-lambda-function) sezione, ma utilizzate i seguenti dati come input per l'esecuzione:

   ```
   {
       "stores": [
         "Store A",
         "Store B",
         "Store C",
         "Store D"
       ]
   }
   ```

## Fase 3: Visualizzare i dettagli di esecuzione della macchina a stati
<a name="view-sm-exec-details"></a>

Nella pagina denominata con il tuo ID di esecuzione, puoi esaminare i risultati dell'esecuzione ed eseguire il debug di eventuali errori.

1. (Facoltativo) Scegliete tra le schede visualizzate nella pagina *Dettagli di esecuzione* per visualizzare le informazioni presenti in ciascuna di esse. Ad esempio, per visualizzare l'input della macchina a stati e il relativo output di esecuzione, scegliete **Input e output di esecuzione** nella sezione *[Riepilogo dell'esecuzione](concepts-view-execution-details.md#exec-details-intf-exec-summ)*.

1. Se l'esecuzione della macchina a stati non è riuscita, scegli **Causa** o **Mostra i dettagli del passaggio** nel messaggio di errore. I dettagli sull'errore sono visualizzati nella sezione *[Dettagli del passaggio](concepts-view-execution-details.md#exec-details-intf-step-details)*. Notate che il passaggio che ha causato l'errore, ovvero uno `Task` stato denominato **GetListofFruits**, è evidenziato nella **vista Grafico** e nella **vista Tabella**.
**Nota**  
Poiché il **GetListofFruits**passaggio è definito all'interno di uno `Map` stato e non è stato eseguito correttamente, il passaggio **`Map`Stato** dello stato viene visualizzato come **Non riuscito**.

## Fase 4: Esplora le diverse *modalità di visualizzazione*
<a name="sm-exec-details-exp-view-modes"></a>

È possibile scegliere una modalità preferita per visualizzare il flusso di lavoro della macchina a stati o la cronologia degli eventi di esecuzione. Alcune delle attività che è possibile eseguire in queste *modalità di visualizzazione* sono le seguenti:

### **Visualizzazione del grafico**: passa da un'iterazione di `Map` stato all'altra
<a name="graph-view-see-map-state-iterations"></a>

Se lo stato della **mappa** ha cinque iterazioni e desideri visualizzare i dettagli di esecuzione per la terza e la quarta iterazione, procedi come segue:

1. Scegli lo `Map` stato per cui desideri visualizzare i dati di iterazione.

1. Dal **Map Iteration Viewer**, scegli l'iterazione che desideri visualizzare. Le iterazioni vengono contate da zero. Per scegliere la terza iterazione su cinque, scegli **\$12** dall'elenco a discesa accanto al nome dello stato della **mappa**.
**Nota**  
Se la macchina a stati contiene `Map` stati nidificati, Step Functions visualizza le iterazioni `Map` dello stato principale e figlio come due elenchi a discesa separati che rappresentano i dati di iterazione per gli stati nidificati.

1. (Facoltativo) Se una o più iterazioni di `Map` stato non sono state eseguite o sono state interrotte in uno stato interrotto, è possibile visualizzare i dettagli sull'iterazione non riuscita. Per visualizzare questi dettagli, scegli i numeri di iterazione interessati in **Non riuscito** o **Interrotto** nell'elenco a discesa.

### **Visualizzazione a tabella**: passa da un'iterazione di stato all'altra `Map`
<a name="table-view-see-map-state-iterations"></a>

Se lo stato della **mappa** ha cinque iterazioni e desideri visualizzare i dettagli di esecuzione per l'iterazione numero tre e quattro, procedi come segue:

1. Scegli lo `Map` stato per il quale desideri visualizzare i diversi dati di iterazione.

1. Nella visualizzazione ad albero delle iterazioni di `Map` stato, scegliete la riga per l'iterazione denominata **\$12** per l'iterazione numero tre. Allo stesso modo, scegli la riga denominata **\$13** per l'iterazione numero quattro.

### **Visualizzazione tabella**: configura le colonne da visualizzare
<a name="table-view-cfg-display-cols"></a>

Scegli l'icona delle impostazioni. Quindi, nella finestra di dialogo **Preferenze**, scegli le colonne che desideri visualizzare in **Seleziona colonne visibili**.

Per impostazione predefinita, questa modalità visualizza le colonne **Nome**, **Tipo**, **Stato**, **Risorsa** e **Started After**.

### **Visualizzazione tabella**: filtra i risultati
<a name="table-view-filter-results"></a>

Limita la quantità di informazioni visualizzate applicando uno o più filtri in base a una proprietà, ad esempio **Status**, o a un intervallo di data e ora. Ad esempio, per visualizzare i passaggi che hanno avuto esito negativo nell'esecuzione, applica il seguente filtro:

1. Scegli **Filtra per proprietà o cerca per parola chiave**, quindi scegli **Stato** in **Proprietà**.

1. In **Operatori**, scegli **Status =**.

1. Scegliete **Status = Failed**.

1. (Facoltativo) Scegliete **Cancella filtri** per rimuovere i filtri applicati.

### **Visualizzazione degli eventi**: filtra i risultati
<a name="event-view-filter-results"></a>

Limita la quantità di informazioni visualizzate applicando uno o più filtri in base a una proprietà, ad esempio **Type**, o a un intervallo di data e ora. Ad esempio, per visualizzare i passaggi di `Task` stato che hanno avuto esito negativo nell'esecuzione, applica il seguente filtro:

1. Scegliete **Filtra per proprietà o Cerca per parola chiave**, quindi scegliete **Tipo** in **Proprietà**.

1. In **Operatori**, scegli **Tipo =**.

1. Scegliete **Tipo = TaskFailed**.

1. (Facoltativo) Scegliete **Cancella filtri** per rimuovere i filtri applicati.

### **Visualizzazione dell'evento**: esamina i dettagli di un **TaskFailed**evento
<a name="event-view-inspect-failed-task-details"></a>

Scegliete l'icona a forma di freccia accanto all'ID di un **TaskFailed**evento per esaminarne i dettagli, inclusi input, output e richiamo delle risorse visualizzati in una casella a discesa.