État du flux de travail parallèle

Le Parallel state ("Type": "Parallel") peut être utilisé pour ajouter des branches d'exécution distinctes dans votre machine à états.

Outre les champs d'état courants, les états Parallel incluent les champs suivants :

Branches (Obligatoire)

Tableau d'objets qui spécifient les machines d'état à exécuter en parallèle. Chaque objet de ce type de la machine d'état doit avoir des champs nommés States et StartAt dont les significations sont exactement comme celles du niveau supérieur d'une machine d'état.

ResultPath (facultatif)

Indique où (dans l'entrée) placer la sortie des branches. Les entrées sont ensuite filtrées telles que spécifiées par le champ OutputPath (s'il est présent) avant d'être utilisées comme sortie de l'état. Pour plus d'informations, consultez Traitement des entrées et des sorties.

ResultSelector (facultatif)

Transmettez une collection de paires clé-valeur, où les valeurs sont statiques ou sélectionnées à partir du résultat. Pour de plus amples informations, veuillez consulter ResultSelector.

Retry (facultatif)

Tableau d'objets, nommés Réessayeurs, qui définissent une stratégie de nouvelle tentative si l'état rencontre des erreurs d'exécution. Pour de plus amples informations, veuillez consulter Exemples de machines à états utilisant Retry et Catch.

Catch (facultatif)

Tableau d'objets, nommés Receveurs, qui définissent un état de secours exécuté lorsque l'état rencontre des erreurs d'exécution et que sa stratégie de nouvelle tentative a été épuisée ou n'est pas définie. Pour plus d'informations, consultez États de secours.

Un Parallel état AWS Step Functions entraîne l'exécution de chaque branche, en commençant par l'état nommé dans le StartAt champ de cette branche, le plus simultanément possible, et l'attente que toutes les branches se terminent (atteignent un état terminal) avant de traiter le Next champ de Parallel l'état.

Exemple d'état 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
           }
         }
       }
      ]
    }
  }
}

Dans cet exemple, les branches LookupAddress et LookupPhone sont exécutées en parallèle. Voici à quoi ressemble le flux de travail visuel dans la console Step Functions.

Chaque branche doit être autonome. Un état dans une branche d'un état Parallel ne doit pas avoir de champ Next qui cible un champ à l'extérieur de cette branche, ni aucun autre état en dehors de la transition de branche vers cette branche.

Traitement des entrées et des sorties d’état Parallel

Un état Parallel fournit à chaque branche une copie de ses propres données d'entrée (soumises à modification par le champ InputPath). Il génère une sortie qui est un tableau avec un élément pour chaque branche contenant la sortie à partir de cette branche. Tous les éléments ne doivent pas nécessairement être du même type. Le tableau de sortie peut être inséré dans les données d'entrée (et l'ensemble envoyé en tant que sortie de l'état Parallel) en utilisant un champ ResultPath de façon classique (voir Traitement des entrées et des sorties).

{
  "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 l'état FunWithMath a reçu le tableau [3, 2] en tant qu'entrée, les deux états Add et Subtract reçoivent ce même tableau en entrée. Le résultat des Subtract tâches Add et serait la somme et la différence entre les éléments 3 et 2 du tableau, c'est-à-dire 5 et1, tandis que le résultat de l'Parallelétat serait un tableau.

[ 5, 1 ]

Astuce

Si l'état Parallel ou Map que vous utilisez dans vos machines d'état renvoie un tableau de tableaux, vous pouvez les transformer en tableau plat avec le ResultSelector champ. Pour de plus amples informations, veuillez consulter Aplatir un tableau de tableaux.

Gestion des erreurs

Si une branche échoue, en raison d'une erreur non gérée ou en passant à l'état Fail, tout l'état Parallel est considéré comme ayant échoué et toutes ses branches sont arrêtées. Si l'erreur n'est pas gérée par l'Parallelétat lui-même, Step Functions arrête l'exécution avec une erreur.

Note

Lorsqu'un état parallèle échoue, les fonctions Lambda invoquées continuent de s'exécuter et les opérateurs d'activité qui traitent un jeton de tâche ne sont pas arrêtés.

• Pour arrêter les activités de longue durée, utilisez les battements de cœur pour détecter si la succursale a été arrêtée par Step Functions et arrêtez les travailleurs en train de traiter des tâches. Le fait d'appeler SendTaskHeartbeat, SendTaskSuccess ou SendTaskFailure génère une erreur si l'état a échoué. Voir Erreurs de pulsation.

• L'exécution des fonctions Lambda ne peut pas être arrêtée. Si vous avez implémenté une solution de secours, utilisez un Wait état pour que le nettoyage soit effectué une fois la fonction Lambda terminée.