Types de tâches Champs d'état des tâches Exemples de définition de l'état des tâches

État du flux de travail des tâches

Un état Task ("Type": "Task") représente une seule unité de travail effectuée par une machine d'état. Une tâche exécute un travail à l'aide d'une activité ou d'un AWS Lambda fonction, en s'intégrant à d'autres supports Services AWS, ou en faisant appel à un tiersAPI, tel que Stripe.

L'Amazon States Language représente les tâches en définissant le type d'état Task et en fournissant à la tâche le nom de ressource Amazon (ARN) de l'activité, de la fonction Lambda ou du point de terminaison tiersAPI. La définition d'état de tâche suivante invoque une fonction Lambda nommée. HelloFunction


"Lambda Invoke": {
  "Type": "Task",
  "Resource": "arn:aws:states:::lambda:invoke",
  "Parameters": {
    "Payload.$": "$",
    "FunctionName": "arn:aws:lambda:us-east-2:123456789012:function:HelloFunction:$LATEST"
  },
  "End": true
}

Types de tâches

Step Functions prend en charge les types de tâches suivants que vous pouvez spécifier dans une définition d'état de tâche :

Activité
Fonctions Lambda
A pris en charge Service AWS
Une HTTP tâche

Vous spécifiez un type de tâche en le fournissant ARN dans le Resource champ de définition de l'état d'une tâche. L'exemple suivant montre la syntaxe du Resource champ. Tous les types de tâches, à l'exception de celui qui invoque un tiersAPI, utilisent la syntaxe suivante. Pour plus d'informations sur la syntaxe de la HTTP tâche, consultezAppelez un tiers APIs dans les flux de travail Step Functions.

Dans la définition de l'état de votre tâche, remplacez le texte en italique dans la syntaxe suivante par AWS informations spécifiques aux ressources.


arn:partition:service:region:account:task_type:name

La liste suivante décrit les différents composants de cette syntaxe :

partitionest le AWS Step Functions partition à utiliser, le plus souventaws.
serviceindique le Service AWS utilisé pour exécuter la tâche, et peut prendre l'une des valeurs suivantes :
- states pour une activité.
- lambdapour une fonction Lambda. Si vous vous intégrez à d'autres Services AWS, par exemple, Amazon SNS ou Amazon DynamoDB, utilisez ou. sns dynamodb
regionest le AWS Code de région dans lequel l'activité ou le type de machine à états Step Functions, la fonction Lambda ou toute autre AWS une ressource a été créée.
accountest le Compte AWS ID dans lequel vous avez défini la ressource.
task_type est le type de tâche à exécuter. Il peut avoir l'une des valeurs suivantes :
- activity— Une activité.
- function— Une fonction Lambda.
- servicename— Le nom d'un service connecté pris en charge (voirIntégrer les services avec Step Functions).
nameest le nom de la ressource enregistrée (nom de l'activité, nom de la fonction Lambda ou API action de service).

Note

Step Functions ne prend pas en charge le référencement ARNs entre partitions ou régions. Par exemple, aws-cn impossible d'invoquer des tâches dans la aws partition, et inversement.

Les sections suivantes fournissent plus de détails sur chaque type.

Activité

Les activités représentent les applications de travail (procédés ou threads), implémentées et hébergées par vous, qui effectuent une tâche spécifique. Ils sont pris en charge uniquement par les workflows standard, mais pas par les workflows express.

L'activité Resource ARNs utilise la syntaxe suivante.


arn:partition:states:region:account:activity:name

Note

Vous devez créer des activités avec Step Functions (à l'aide d'une CreateActivity, API d'une action ou de la console Step Functions) avant leur première utilisation.

Pour plus d'informations sur la création d'une activité et la mise en œuvre de programmes exécutants, consultez la section Activités.

Fonctions Lambda

Les tâches Lambda exécutent une fonction en utilisant AWS Lambda. Pour spécifier une fonction Lambda, utilisez ARN la fonction Lambda dans le champ. Resource

En fonction du type d'intégration (intégration optimisée ou AWS SDKintegration) que vous utilisez pour spécifier une fonction Lambda, la syntaxe du champ de votre fonction Lambda varie. Resource

La syntaxe de Resource champ suivante est un exemple d'intégration optimisée avec une fonction Lambda.


"arn:aws:states:::lambda:invoke"

La syntaxe de Resource champ suivante est un exemple de AWS SDKintégration avec une fonction Lambda.


"arn:aws:states:::aws-sdk:lambda:invoke"

La définition Task d'état suivante montre un exemple d'intégration optimisée avec une fonction Lambda nommée. HelloWorld


"LambdaState": {
  "Type": "Task",
  "Resource": "arn:aws:states:::lambda:invoke",
  "OutputPath": "$.Payload",
  "Parameters": {
    "Payload.$": "$",
    "FunctionName": "arn:aws:lambda:us-east-1:function:HelloWorld:$LATEST"
  },
  "Next": "NextState"
}

Une fois que la fonction Lambda spécifiée dans le Resource champ est terminée, sa sortie est envoyée à l'état identifié dans le Next champ (» NextState «).

A pris en charge Service AWS

Lorsque vous référencez une ressource connectée, Step Functions appelle directement les API actions d'un service pris en charge. Spécifiez le service et l'action dans le champ Resource.

Le service connecté Resource ARNs utilise la syntaxe suivante.


arn:partition:states:region:account:servicename:APIname

Note

Pour créer une connexion synchrone à une ressource connectée, ajoutez à .sync APIname entrée dans leARN. Pour de plus amples informations, veuillez consulter Intégration des services .

Par exemple :


{
 "StartAt": "BATCH_JOB",
 "States": {
   "BATCH_JOB": {
     "Type": "Task",
     "Resource": "arn:aws:states:::batch:submitJob.sync",
     "Parameters": {  
       "JobDefinition": "preprocessing",
       "JobName": "PreprocessingBatchJob",
       "JobQueue": "SecondaryQueue",
       "Parameters.$": "$.batchjob.parameters",
       "RetryStrategy": {
          "attempts": 5
        }
     },
     "End": true
    }
  }
}

Champs d'état des tâches

Outre les champs d'état courants, les états Task ont les champs suivants.

Resource (Obligatoire)

AURI, en particulier ARN celui qui identifie de manière unique la tâche spécifique à exécuter.

Parameters (facultatif)

Utilisé pour transmettre des informations aux API actions des ressources connectées. Les paramètres peuvent utiliser un mélange de statique JSON et JsonPath. Pour de plus amples informations, veuillez consulter Transmission de paramètres à un service API dans Step Functions.

Credentials (facultatif)

Spécifie un rôle cible que le rôle d'exécution de la machine à états doit assumer avant d'invoquer le rôle spécifiéResource. Vous pouvez également spécifier une JSONPath valeur ou une fonction intrinsèque qui correspond à un IAM rôle ARN lors de l'exécution en fonction de l'entrée d'exécution. Si vous spécifiez une JSONPath valeur, vous devez la préfixer avec la $. notation.

Pour des exemples d'utilisation de ce champ dans l'TaskÉtat, consultezExemples de champs d'informations d'identification de l'état de la tâche. Pour un exemple d'utilisation de ce champ pour accéder à un compte croisé AWS ressource de votre machine d'état, voirAccès à plusieurs comptes AWS ressources dans Step Functions.

Note

Ce champ est pris en charge par les fonctions Lambda Types de tâches qui utilisent les fonctions Lambda et un AWS service.

ResultPath (facultatif)

Indique où (dans l'entrée) placer les résultats de l'exécution de la tâche spécifiée dans Resource. 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. Cet état est exécuté lorsque l'état rencontre des erreurs d'exécution et que sa stratégie de nouvelle tentative est épuisée ou n'est pas définie. Pour plus d'informations, consultez États de secours.

TimeoutSeconds (facultatif)

Spécifie la durée maximale pendant laquelle une activité ou une tâche peut s'exécuter avant qu'elle n'expire en raison de l'States.Timeouterreur et qu'elle échoue. La valeur du délai d'attente doit être un entier positif différent de zéro. La valeur par défaut est 99999999.

Le délai d'expiration commence après le démarrage d'une tâche, par exemple lorsque ActivityStarted des LambdaFunctionStarted événements sont enregistrés dans l'historique des événements d'exécution. Pour les activités, le décompte commence à la GetActivityTask réception d'un jeton et ActivityStarted est enregistré dans l'historique des événements d'exécution.

Lorsqu'une tâche démarre, Step Functions attend une réponse de réussite ou d'échec de la part du responsable de la tâche ou de l'activité dans le délai spécifiéTimeoutSeconds. Si le responsable de la tâche ou de l'activité ne répond pas dans ce délai, Step Functions marque l'exécution du flux de travail comme un échec.

Note

HTTPle délai d'expiration de la tâche est de 60 secondes au maximum, même s'il TimeoutSeconds dépasse cette limite. Consultez Quotas liés à la HTTP tâche.

TimeoutSecondsPath (facultatif)

Si vous souhaitez fournir une valeur de délai d'attente de manière dynamique à partir de l'entrée d'état à l'aide d'un chemin de référence, utilisezTimeoutSecondsPath. Une fois résolu, le chemin de référence doit sélectionner les champs dont les valeurs sont des entiers positifs.

Note

Un Task état ne peut pas inclure à la fois TimeoutSeconds etTimeoutSecondsPath. HTTPle délai d'expiration de la tâche est de 60 secondes au maximum, même si la TimeoutSecondsPath valeur dépasse cette limite.

HeartbeatSeconds (facultatif)

Détermine la fréquence des signaux de battement de cœur envoyés par un intervenant pendant l'exécution d'une tâche. Les battements de cœur indiquent qu'une tâche est toujours en cours d'exécution et qu'elle a besoin de plus de temps pour être terminée. Les battements de cœur empêchent l'exécution d'une activité ou d'une tâche TimeoutSeconds pendant le délai imparti.

HeartbeatSecondsdoit être un entier positif, différent de zéro, inférieur à la valeur du TimeoutSeconds champ. La valeur par défaut est 99999999. Si plus de temps que les secondes spécifiées s'écoulent entre les pulsations de la tâche, l'état de la tâche échoue avec une erreur. States.Timeout

Pour les activités, le décompte commence à la GetActivityTask réception d'un jeton et ActivityStarted est enregistré dans l'historique des événements d'exécution.

HeartbeatSecondsPath (facultatif)

Si vous souhaitez fournir une valeur de battement cardiaque de manière dynamique à partir de l'entrée d'état à l'aide d'un chemin de référence, utilisezHeartbeatSecondsPath. Une fois résolu, le chemin de référence doit sélectionner les champs dont les valeurs sont des entiers positifs.

Note

Un Task état ne peut pas inclure à la fois HeartbeatSeconds etHeartbeatSecondsPath.

Un état Task doit définir le champ End sur true si l'état termine l'exécution ou doit fournir un état dans le champ Next qui sera exécuté lors de la fin de l'état Task.

Exemples de définition de l'état des tâches

Les exemples suivants montrent comment vous pouvez spécifier la définition de l'état de la tâche en fonction de vos besoins.

Spécification de l'état des tâches, des délais d'expiration et des intervalles de pulsation
- Exemple de délai d'expiration statique et de notification du rythme cardiaque
- Exemple de délai d'expiration d'une tâche dynamique et de notification du rythme cardiaque
Utilisation du champ Informations d'identification

État des tâches, délais d'expiration et intervalles entre les pulsations

Il est recommandé de définir un délai d'expiration et un intervalle de pulsation pour les activités de longue durée. Cela peut être fait en spécifiant le délai d'expiration et les valeurs du rythme cardiaque, ou en les réglant dynamiquement.

Exemple de délai d'expiration statique et de notification du rythme cardiaque

Une fois HelloWorld terminé, l'état suivant (appelé ici NextState) est exécuté.

Si cette tâche échoue dans un délai de 300 secondes ou n'envoie pas de notifications relatives aux pulsations par intervalles de 60 secondes, la tâche est marquée comme failed.


"ActivityState": {
  "Type": "Task",
  "Resource": "arn:aws:states:us-east-1:123456789012:activity:HelloWorld",
  "TimeoutSeconds": 300,
  "HeartbeatSeconds": 60,
  "Next": "NextState"
}

Exemple de délai d'expiration d'une tâche dynamique et de notification du rythme cardiaque

Dans cet exemple, lorsque AWS Glue le travail est terminé, l'état suivant sera exécuté.

Si cette tâche ne s'exécute pas dans l'intervalle défini dynamiquement par le AWS Glue tâche, la tâche est marquée commefailed.


"GlueJobTask": {
  "Type": "Task",
  "Resource": "arn:aws:states:::glue:startJobRun.sync",
  "Parameters": {
    "JobName": "myGlueJob"
  },
  "TimeoutSecondsPath": "$.params.maxTime",
  "Next": "NextState"
}

Exemples de champs d'informations d'identification de l'état de la tâche

Spécification d'un rôle codé en dur IAM ARN

L'exemple suivant spécifie un IAM rôle cible que le rôle d'exécution d'une machine à états doit assumer pour accéder à une fonction Lambda entre comptes nommée. Echo Dans cet exemple, le rôle cible ARN est spécifié sous forme de valeur codée en dur.


{
  "StartAt": "Cross-account call",
  "States": {
    "Cross-account call": {
      "Type": "Task",
      "Resource": "arn:aws:states:::lambda:invoke",
      "Credentials": {
        "RoleArn": "arn:aws:iam::111122223333:role/LambdaRole"
      },
      "Parameters": {
        "FunctionName": "arn:aws:lambda:us-east-2:111122223333:function:Echo"
      },
      "End": true
    }
  }
}

Spécification en JSONPath tant que IAM rôle ARN

L'exemple suivant spécifie une JSONPath valeur, qui sera convertie en IAM rôle ARN lors de l'exécution.


{
  "StartAt": "Lambda",
  "States": {
    "Lambda": {
      "Type": "Task",
      "Resource": "arn:aws:states:::lambda:invoke",
      "Credentials": {
        "RoleArn.$": "$.roleArn"
      },
      ...
    }
  }
}

Spécifier une fonction intrinsèque en tant que IAM rôle ARN

L'exemple suivant utilise la fonction States.Formatintrinsèque, qui correspond à un IAM rôle ARN lors de l'exécution.


{
  "StartAt": "Lambda",
  "States": {
    "Lambda": {
      "Type": "Task",
      "Resource": "arn:aws:states:::lambda:invoke",
      "Credentials": {
        "RoleArn.$": "States.Format('arn:aws:iam::{}:role/ROLENAME', $.accountId)"
      },
      ...
    }
  }
}

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

États du flux de travail

Choice