As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Examinar execuções de máquinas de estado no Step Functions
<a name="debug-sm-exec-using-ui"></a>

Neste tutorial, você aprenderá como inspecionar as informações de execução exibidas na página *Detalhes da execução* e ver o motivo de uma falha na execução. Em seguida, você vai aprender como acessar diferentes iterações de uma execução de estado `Map`. Por fim, você aprenderá como configurar as colunas na **Visualização em tabela** e aplicar filtros adequados para visualizar somente as informações de seu interesse.

Neste tutorial, você cria uma máquina de estado do tipo Padrão, que obtém o preço de um conjunto de frutas. Para fazer isso, a máquina de estado usa três funções AWS Lambda que retornam uma lista aleatória de quatro frutas, o preço de cada fruta e o custo médio das frutas. As funções do Lambda foram projetadas para gerar um erro se o preço das frutas for menor ou igual a um valor limite.

**nota**  
Embora o procedimento a seguir contenha instruções sobre como examinar os detalhes da execução de um fluxo de trabalho Padrão, você também pode examinar os detalhes das execuções do Fluxo de trabalho expresso. Para obter informações sobre as diferenças entre os detalhes de execução dos tipos de fluxo de trabalho Padrão e Expresso, consulte [Diferenças na experiência do console padrão e expresso](concepts-view-execution-details.md#console-exp-differences).

## Etapa 1: criar e testar as funções do Lambda necessárias
<a name="step-create-all-lambda-functions"></a>

1. Abra o [console do Lambda](https://console.aws.amazon.com/lambda/home) e execute as etapas de 1 a 4 na seção [Etapa 1: criar uma função do Lambda](tutorial-creating-lambda-state-machine.md#create-lambda-function). Certifique-se de nomear a função do Lambda **GetListOfFruits**.

1. Depois de criar a função do Lambda, copie o nome do recurso da Amazon (ARN) da função exibido no canto superior direito da página. Para copiar o ARN, clique no ícone de cópia para copiar o nome do recurso da Amazon da função do Lambda. Veja a seguir um exemplo de ARN, em que *`function-name`* é o nome da função do Lambda (nesse caso, `GetListOfFruits`):

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

1. Copie o seguinte código para a função do Lambda na área de **Origem do código** da página **GetListOfFruits**.

   ```
   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. Escolha **Implantar** e, em seguida, escolha **Testar**, para implantar as alterações e ver a saída da função do Lambda.

1. Crie duas funções do Lambda adicionais, nomeadas **GetFruitPrice** e **CalculateAverage** respectivamente, com as seguintes etapas:

   1. Copie o seguinte código na área de **Origem do código** da função do Lambda **GetFruitPrice**:

      ```
      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. Copie o seguinte código na área de **Origem do código** da função do Lambda **CalculateAverage**:

      ```
      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. Certifique-se de copiar os ARNs dessas duas funções do Lambda e, em seguida, **Implante-os** e **Teste-os**.

## Etapa 2: criar e executar a máquina de estado
<a name="step-create-exec-sm"></a>

Use o [console do Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) para criar uma máquina de estado que invoca as [funções do Lambda que você criou na Etapa 1](#step-create-all-lambda-functions). Nessa máquina de estado, três estados `Map` são definidos. Cada um desses estados `Map` contém um estado `Task` que invoca uma das funções do Lambda. Além disso, um campo `Retry` é definido em cada estado `Task` com várias tentativas definidas para cada estado. Se um estado `Task` encontrar um erro de runtime, ele será executado novamente até o número de novas tentativas definido para esse `Task`.

1. Abra o [console do Step Functions](https://console.aws.amazon.com/states/home) e escolha **Gravar o fluxo de trabalho no código**.
**Importante**  
Certifique-se de que a máquina de estado esteja na mesma conta e região da AWS da função do Lambda que você criou anteriormente.

1. Para **Tipo**, mantenha a seleção padrão de **Padrão**.

1. Copie a seguinte definição de Amazon States Language e cole-a em **Definição**. Substitua os ARNs mostrados pelos das funções do Lambda que você criou anteriormente.

   ```
   {
       "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. Insira um nome para a máquina de estado. Mantenha as seleções padrão para outras opções desta página e escolha **Criar máquina de estado**.

1. Abra a página intitulada com o nome da máquina de estado. Execute as etapas de 1 a 4 na seção [Etapa 4: Executar a máquina de estado](tutorial-creating-lambda-state-machine.md#start-lambda-function), mas use os seguintes dados como entrada de execução:

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

## Etapa 3: visualizar os detalhes da execução da máquina de estado
<a name="view-sm-exec-details"></a>

Na página intitulada com o ID de execução, você pode revisar os resultados da execução e depurar quaisquer erros.

1. (Opcional) Escolha entre as guias exibidas na página *Detalhes da execução* para ver as informações presentes em cada uma delas. Por exemplo, para visualizar a entrada da máquina de estado e a saída de execução, escolha **Entrada e saída da execução** na seção *[Resumo de execução](concepts-view-execution-details.md#exec-details-intf-exec-summ)*.

1. Se a execução da máquina de estado falhar, escolha **Causa** ou **Mostrar detalhes da etapa** na mensagem de erro. Detalhes sobre o erro são exibidos na seção *[Detalhes da etapa](concepts-view-execution-details.md#exec-details-intf-step-details)*. Observe que a etapa que causou o erro, que é um estado `Task` chamado **GetListofFruits**, está destacada na **Exibição em gráfico** e na **Visualização de tabela**.
**nota**  
Como a etapa **GetListOfFruits** está definida dentro de um estado `Map`, e a etapa não foi executada com êxito, o **Status** do estado `Map` é exibido como **Falha**.

## Etapa 4: explorar os diferentes *Modos de visualização*
<a name="sm-exec-details-exp-view-modes"></a>

Você pode escolher um modo preferido para visualizar o fluxo de trabalho da máquina de estado ou o histórico de eventos de execução. Algumas das tarefas que você pode executar nesses *Modos de visualização* são as seguintes:

### **Exibição em gráfico** — Alterne entre diferentes iterações de estado `Map`
<a name="graph-view-see-map-state-iterations"></a>

Se o estado **Mapa** tiver cinco iterações, e você quiser visualizar os dados de execução da terceira e quarta iterações, faça o seguinte:

1. Escolha o estado `Map` cujos dados de iteração você deseja visualizar.

1. No **Visualizador de iteração do mapa**, escolha a iteração que você deseja visualizar. As iterações são contadas a partir de zero. Para escolher a terceira iteração entre cinco, escolha **nº 2** na lista suspensa ao lado do nome do estado **Mapa**.
**nota**  
Se a máquina de estado contiver estados `Map` aninhados, o Step Functions exibirá as iterações de estado `Map` principal e secundário como duas listas suspensas separadas que representam os dados de iteração para os estados aninhados.

1. (Opcional) Se uma ou mais de suas iterações de estado `Map` falharam na execução ou foram interrompidas em um estado interrompido, você poderá ver detalhes sobre a iteração com falha. Para ver esses detalhes, escolha os números de iteração afetados em **Falha** ou **Interrompido** na lista suspensa.

### **Visualização em tabela** — Alterne entre diferentes iterações de estado `Map`
<a name="table-view-see-map-state-iterations"></a>

Se o estado **Mapa** tiver cinco iterações, e você quiser visualizar os detalhes de execução da terceira e quarta iterações, faça o seguinte:

1. Escolha o estado `Map` cujos dados de iteração diferentes você deseja visualizar.

1. Na exibição em árvore das iterações de estado `Map`, escolha a linha da iteração chamada **nº 2** para a iteração número três. Da mesma forma, escolha a linha chamada **nº 3** para a iteração número quatro.

### **Visualização em tabela** — Configure as colunas a serem exibidas
<a name="table-view-cfg-display-cols"></a>

Escolha o ícone de configurações. Em seguida, na caixa de diálogo **Preferências**, escolha as colunas que você deseja exibir em **Selecionar colunas visíveis**.

Por padrão, esse modo exibe as colunas **Nome**, **Tipo**, **Status**, **Recurso** e **Iniciado depois**.

### **Visualização em tabela** — Filtrar os resultados
<a name="table-view-filter-results"></a>

Limite a quantidade de informações exibidas aplicando um ou mais filtros com base em uma propriedade, como **Status**, ou em um intervalo de data e hora. Por exemplo, para visualizar as etapas que falharam na execução, aplique o seguinte filtro:

1. Escolha **Filtrar por propriedades ou pesquisar por palavra-chave** e escolha **Status** em **Propriedades**.

1. Em **Operadores**, escolha **Status =**.

1. Escolha **Status = Falha**.

1. (Opcional) Escolha **Limpar filtros** para remover os filtros aplicados.

### **Visualização do evento** — Filtre os resultados
<a name="event-view-filter-results"></a>

Limite a quantidade de informações exibidas aplicando um ou mais filtros com base em uma propriedade, como **Tipo**, ou em um intervalo de data e hora. Por exemplo, para visualizar as etapas do estado `Task` que falharam na execução, aplique o seguinte filtro:

1. Escolha **Filtrar por propriedades ou pesquisar por palavra-chave** e escolha **Tipo** em **Propriedades**.

1. Em **Operadores**, escolha **Tipo =**.

1. Escolha **Tipo = TaskFailed**.

1. (Opcional) Escolha **Limpar filtros** para remover os filtros aplicados.

### **Visualização do evento** — Inspecione um detalhe do evento **TaskFailed**
<a name="event-view-inspect-failed-task-details"></a>

Escolha o ícone de seta ao lado do ID de um evento **TaskFailed** para inspecionar os detalhes, bem como entrada, saída e invocação de recursos que aparecem em uma caixa suspensa.