Parallel

El estado Parallel ("Type": "Parallel") puede utilizarse para añadir ramificaciones de ejecución separadas en la máquina de estado.

Además de los campos de estado comunes, los estados Parallel incluyen los campos adicionales que se detallan a continuación.

Branches (Obligatorio)

Matriz de objetos que especifica las máquinas de estado que se van a ejecutar en paralelo. Cada uno de estos objetos de máquina de estado debe tener los campos States y StartAt, cuyos significados son exactamente iguales a los del nivel superior de una máquina de estado.

ResultPath (Opcional)

Especifica en qué lugar (de los datos de entrada) se va a situar la salida de las ramificaciones. La entrada se filtra según el contenido del campo OutputPath (si existe) antes de utilizarla como salida del estado. Para obtener más información, consulte Procesamiento de entrada y salida.

ResultSelector (Opcional)

Pase un conjunto de pares clave-valor, donde los valores sean estáticos o se seleccionen del resultado. Para obtener más información, consulte ResultSelector.

Retry (Opcional)

Una matriz de objetos, llamados "reintentadores", que definen una política de reintentos en caso de que el estado encuentre errores en tiempo de ejecución. Para obtener más información, consulte Ejemplos de máquina de estado que usan Retry y Catch.

Catch (Opcional)

Una matriz de objetos, denominados "receptores", que definen un estado alternativo que se ejecuta si el estado encuentra errores en tiempo de ejecución y su política de reintentos está agotada o no se ha definido. Para obtener más información, consulte Estados alternativos.

Un Parallel estado hace AWS Step Functions que cada rama se ejecute, empezando por el estado nombrado en el StartAt campo de esa rama, de la forma más simultánea posible, y que espere hasta que todas las ramas terminen (alcancen un estado terminal) antes de procesar el Next campo del Parallel estado.

Ejemplo del estado Parallel

{
  "Comment": "Parallel Example.",
  "StartAt": "LookupCustomerInfo",
  "States": {
    "LookupCustomerInfo": {
      "Type": "Parallel",
      "End": true,
      "Branches": [
        {
         "StartAt": "LookupAddress",
         "States": {
           "LookupAddress": {
             "Type": "Task",
             "Resource":
               "arn:aws:lambda:us-east-1:123456789012:function:AddressFinder",
             "End": true
           }
         }
       },
       {
         "StartAt": "LookupPhone",
         "States": {
           "LookupPhone": {
             "Type": "Task",
             "Resource":
               "arn:aws:lambda:us-east-1:123456789012:function:PhoneFinder",
             "End": true
           }
         }
       }
      ]
    }
  }
}

En este ejemplo, las ramificaciones LookupAddress y LookupPhone se ejecutan en paralelo. A continuación, se muestra el aspecto del flujo de trabajo visual en la consola de Step Functions.

Cada una de las ramificaciones debe ser autónoma. Los estados de una ramificación de un estado Parallel no deben incluir un campo Next que tenga como destino un campo que está fuera de la ramificación ni ningún otro estado fuera de la ramificación puede cambiar a esa ramificación.

Procesamiento de entrada y salida del estado Parallel

El estado Parallel proporciona a cada ramificación una copia de sus propios datos de entrada (sujetos a las modificaciones realizadas por el campo InputPath). Genera una salida que es una matriz con un elemento para cada ramificación, que contiene la salida de dicha ramificación. No es necesario que todos los elementos sean del mismo tipo. La matriz de salida puede insertarse en los datos de entrada (y el conjunto enviado como salida del estado Parallel) a través del campo ResultPath de la forma habitual (consulte Procesamiento de entrada y salida).

{
  "Comment": "Parallel Example.",
  "StartAt": "FunWithMath",
  "States": {
    "FunWithMath": {
      "Type": "Parallel",
      "End": true,
      "Branches": [
        {
          "StartAt": "Add",
          "States": {
            "Add": {
              "Type": "Task",
              "Resource": "arn:aws:states:us-east-1:123456789012:activity:Add",
              "End": true
            }
          }
        },
        {
          "StartAt": "Subtract",
          "States": {
            "Subtract": {
              "Type": "Task",
              "Resource": "arn:aws:states:us-east-1:123456789012:activity:Subtract",
              "End": true
            }
          }
        }
      ]
    }
  }
}

Si al estado FunWithMath se le proporcionó como entrada la matriz [3, 2], tanto el estado Add como el estado Subtract recibirán esa matriz como datos de entrada. El resultado de las tareas Add y Subtract sería la suma y la diferencia entre los elementos de la matriz 3 y 2, es decir, 5 y 1, mientras que la salida del estado Parallel sería una matriz.

[ 5, 1 ]

sugerencia

Si el estado Parallel o Map que utiliza en sus máquinas de estado devuelve una matriz de matrices, puede transformarlas en una matriz plana con el campo ResultSelector. Para obtener más información, consulte Aplanamiento de una matriz de matrices.

Control de errores

Si alguna ramificación no se ejecuta correctamente debido a un error no controlado o porque cambia a un estado Fail, se considera que el error afecta a todo el estado Parallel y se detienen todas las ramificaciones. Si el propio estado Parallel no controla el error, Step Functions detendrá la ejecución con un error.

nota

Cuando un estado Parallel no se ejecuta correctamente, las funciones de Lambda invocadas se siguen ejecutando y los procesos de trabajo de actividad que procesan un token de tarea no se detienen.

• Para detener actividades de ejecución prolongada, utilice latidos para detectar si Step Functions ha detenido su ramificación y detener los procesos de trabajo que están procesando tareas. Llamar a SendTaskHeartbeat, SendTaskSuccess o SendTaskFailure generará un error si el estado ha producido un error. Consulte Errores de latido.

• La ejecución de funciones de Lambda no se puede detener. Si ha implementado una alternativa, utilice un estado Wait de modo que el trabajo de limpieza se realice una vez finalizada la función de Lambda.