Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Examen de ejecuciones de máquinas de estado en Step Functions
<a name="debug-sm-exec-using-ui"></a>

En este tutorial, aprenderá a inspeccionar la información de ejecución que se muestra en la página *Detalles de la ejecución* y a ver el motivo de una ejecución con error. A continuación, aprenderá a acceder a las distintas iteraciones de una ejecución de estado `Map`. Por último, aprenderá a configurar las columnas en la **Vista de tabla** y a aplicar los filtros adecuados para ver solo la información que le interese.

En este tutorial, creará una máquina de estado de tipo estándar que obtiene el precio de un conjunto de frutas. Para ello, la máquina de estado usa tres funciones de AWS Lambda que devuelven una lista aleatoria de cuatro frutas, el precio de cada fruta y el costo promedio de las frutas. Las funciones de Lambda están diseñadas para arrojar un error si el precio de las frutas es inferior o igual a un valor de umbral.

**nota**  
Aunque el siguiente procedimiento contiene instrucciones sobre cómo examinar los detalles de la ejecución de un flujo de trabajo estándar, también puede examinar los detalles de las ejecuciones de flujos de trabajo rápidos. Para obtener información acerca de las diferencias entre los detalles de la ejecución para tipos de flujos de trabajo estándar y rápidos, consulte [Diferencias de experiencia entre las consolas estándar y rápidas](concepts-view-execution-details.md#console-exp-differences).

## Paso 1: Crear y probar las funciones de Lambda requerida
<a name="step-create-all-lambda-functions"></a>

1. Abra la [consola de Lambda](https://console.aws.amazon.com/lambda/home) y, a continuación, realice los pasos 1 a 4 de la sección [Paso 1: Crear una función de Lambda](tutorial-creating-lambda-state-machine.md#create-lambda-function). Asegúrese de asignar un nombre a la función de Lambda **GetListOfFruits**.

1. Tras crear la función de Lambda, copie el Nombre de recurso de Amazon (ARN) de la función que aparece en la esquina superior derecha de la página. Para copiar el ARN, haga clic en el icono de copiar para copiar el nombre del recurso de Amazon de la función de Lambda. A continuación se muestra un ejemplo de ARN, donde *`function-name`* es el nombre de la función de Lambda (en este caso, `GetListOfFruits`):

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

1. Copie el siguiente código para la función de Lambda en el área **Código fuente** de la 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. Seleccione **Implementar** y luego **Probar** para implementar los cambios y ver el resultado de la función de Lambda.

1. Cree dos funciones de Lambda adicionales, denominadas **GetFruitPrice** y **CalculateAverage** respectivamente, siguiendo estos pasos:

   1. Copie el siguiente código en el área **Código fuente** de la función de 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 el siguiente código en el área **Código fuente** de la función de 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. Asegúrese de copiar los ARN de estas dos funciones de Lambda y, a continuación, **impleméntelas** y **pruébelas**.

## Paso 2: Crear y ejecutar la máquina de estado
<a name="step-create-exec-sm"></a>

Use la [consola de Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/) para crear una máquina de estado que invoque las [funciones de Lambda que creó en el paso 1](#step-create-all-lambda-functions). En esta máquina de estado, se definen tres estados `Map`. Cada uno de estos estados `Map` contiene un estado `Task` que invoca una de las funciones de Lambda. Además, se define un campo `Retry` en cada estado `Task` con un número de reintentos definidos para cada estado. Si un estado `Task` detecta un error de tiempo de ejecución, se vuelve a ejecutar hasta el número de reintentos definido para ese estado `Task`.

1. Abra la [consola de Step Functions](https://console.aws.amazon.com/states/home) y seleccione **Escribir el flujo de trabajo en código**.
**importante**  
Asegúrese de que la máquina de estado se encuentra en la misma cuenta y región de AWS que la función de Lambda que ha creado anteriormente.

1. En **Tipo**, mantenga la selección predeterminada de **Estándar**.

1. Copie la siguiente definición de Amazon States Language y péguela en **Definición**. Asegúrese de sustituir los ARN que se muestran por los de las funciones de Lambda que creó 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. Introduzca un nombre para la máquina de estado. Mantenga las selecciones predeterminadas para el resto de opciones de esta página y elija **Crear máquina de estados**.

1. Abra la página cuyo título es el nombre de su máquina de estado. Realice los pasos 1 a 4 de la sección [Paso 4: Ejecutar la máquina de estado](tutorial-creating-lambda-state-machine.md#start-lambda-function), pero use los siguientes datos como entrada de ejecución:

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

## Paso 3: Visualizar los detalles de la ejecución de la máquina de estado
<a name="view-sm-exec-details"></a>

En la página cuyo título es su ID de ejecución, puede revisar los resultados de la ejecución y depurar cualquier error.

1. (Opcional) Seleccione una de las pestañas que aparecen en la página *Detalles de la ejecución* para ver la información presente en cada una de ellas. Por ejemplo, para ver la entrada de la máquina de estado y su salida de ejecución, seleccione **Entrada y salida de ejecución** en la sección *[Resumen de ejecución](concepts-view-execution-details.md#exec-details-intf-exec-summ)*.

1. Si la ejecución de la máquina de estado produce un error, seleccione **Causa** o **Mostrar detalles del paso** en el mensaje de error. Los detalles acerca del error aparecen en la sección *[Detalles del paso](concepts-view-execution-details.md#exec-details-intf-step-details)*. Observe que el paso que provocó el error, que es un estado `Task` denominado **GetListofFruits**, aparece resaltado en la **Vista de gráfico** y en la **Vista de tabla**.
**nota**  
Dado que el paso **GetListofFruits** está definido dentro de un estado `Map` y el paso no se ha podido ejecutar correctamente, el paso **Estado** de `Map` aparece como **Con error**.

## Paso 4: Explorar los diferentes *modos de visualización*
<a name="sm-exec-details-exp-view-modes"></a>

Puede elegir el modo que prefiera para ver el flujo de trabajo de la máquina de estado o el historial de eventos de ejecución. A continuación se indican algunas de las tareas que puede realizar en estos *modos de visualización*:

### **Vista de gráfico**: cambiar entre diferentes iteraciones de estado `Map`
<a name="graph-view-see-map-state-iterations"></a>

Si el estado **Map** tiene cinco iteraciones y desea ver los detalles de la ejecución de la tercera y la cuarta iteraciones, haga lo siguiente:

1. Seleccione el estado `Map` para el que desea ver los datos de iteración.

1. En el **visor de iteraciones de Map**, seleccione la iteración que desee ver. Las iteraciones se cuentan desde cero. Para elegir la tercera iteración de cinco, seleccione **\$12** en la lista desplegable que aparece junto al nombre del estado **Map**.
**nota**  
Si la máquina de estado contiene estados `Map` anidados, Step Functions muestra las iteraciones de estado `Map` principal y secundaria en dos listas desplegables independientes que representan los datos de iteración para los estados anidados.

1. (Opcional) Si una o varias de las iteraciones de estado `Map` no se pudieron ejecutar o se detuvieron en un estado interrumpido, puede ver los detalles de la iteración con error. Para ver estos detalles, seleccione los números de iteración afectados en **Con error** o **Interrumpido** en la lista desplegable.

### **Vista de tabla**: cambiar entre diferentes iteraciones de estado `Map`
<a name="table-view-see-map-state-iterations"></a>

Si el estado **Map** tiene cinco iteraciones y desea ver los detalles de la ejecución de las iteraciones número tres y cuatro, haga lo siguiente:

1. Seleccione el estado `Map` para el que desea ver los distintos datos de iteración.

1. En la vista en árbol de las iteraciones de estado `Map`, seleccione la fila de la iteración denominada **\$12** para la iteración número tres. Del mismo modo, elija la fila denominada **\$13** para la iteración número cuatro.

### **Vista de tabla**: configurar las columnas que se van a mostrar
<a name="table-view-cfg-display-cols"></a>

Seleccione el icono de configuración. A continuación, en el cuadro de diálogo **Preferencias**, escoja las columnas que desee mostrar en **Seleccionar las columnas visibles**.

De forma predeterminada, este modo muestra las columnas **Nombre**, **Tipo**, **Estado**, **Recurso** e **Iniciado después de**.

### **Vista de tabla**: filtrar los resultados
<a name="table-view-filter-results"></a>

Limite la cantidad de información que se muestra aplicando uno o varios filtros basados en una propiedad, como **Estado**, o un intervalo de fechas y horas. Por ejemplo, para ver los pasos que no se ejecutaron correctamente, aplique el siguiente filtro:

1. Seleccione **Filtrar por propiedades o buscar por palabra clave** y, a continuación, **Estado** en **Propiedades**.

1. En **Operadores**, seleccione **Estado =**.

1. Seleccione **Estado = Con error**.

1. (Opcional) Seleccione **Borrar filtros** para eliminar los filtros aplicados.

### **Vista de eventos**: filtrar los resultados
<a name="event-view-filter-results"></a>

Limite la cantidad de información que se muestra aplicando uno o varios filtros basados en una propiedad, como **Tipo**, o un intervalo de fechas y horas. Por ejemplo, para ver los pasos del estado `Task` que no se ejecutaron correctamente, aplique el siguiente filtro:

1. Seleccione **Filtrar por propiedades o buscar por palabra clave** y, a continuación, **Tipo** en **Propiedades**.

1. En **Operadores**, seleccione **Tipo =**.

1. Seleccione **Tipo = TaskFailed**.

1. (Opcional) Seleccione **Borrar filtros** para eliminar los filtros aplicados.

### **Vista de eventos**: inspeccionar los detalles de un evento **TaskFailed**
<a name="event-view-inspect-failed-task-details"></a>

Seleccione el icono de la flecha junto al ID de un evento **TaskFailed** para inspeccionar sus detalles, incluida la entrada, la salida y la invocación de recursos, que aparecen en un cuadro desplegable.