Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# État du flux de travail des tâches
**Gestion de l'état et transformation des données**
Découvrez comment [transmettre des données entre états à l'aide de variables](workflow-variables.md) et [transformer des données avec JSONata](transforming-data.md).
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 en utilisant une activité ou une AWS Lambda fonction, en s'intégrant à d'autres fonctionnalités [prises en charge Services AWS](supported-services-awssdk.md#supported-services-awssdk-list) ou en invoquant une API HTTPS, telle que Stripe.
L'[Amazon States Language](concepts-amazon-states-language.md) 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é, la fonction Lambda ou le point de terminaison de l'API HTTPS.
**Invoquer une fonction avec des JSONata arguments**
La définition d'état de tâche (JSONata) suivante appelle une fonction Lambda nommée. `priceWatcher`
Notez l'utilisation d' JSONata expressions pour interroger les données d'entrée à utiliser dans Arguments et le résultat de la tâche dans le champ d'assignation.
```
"Get Current Price": {
"Type": "Task",
"QueryLanguage" : "JSONata",
"Resource": "arn:aws:states:::lambda:invoke",
"Next": "Check Price",
"Arguments": {
"Payload": {
"product": "{% $states.context.Execution.Input.product %}"
},
"FunctionName": "arn:aws:lambda::account-id:function:priceWatcher:$LATEST"
},
"Assign": {
"currentPrice": "{% $states.result.Payload.current_price %}"
}
}
```
**Invoquer une fonction avec des JSONPath paramètres**
La définition d'état de tâche (JSONPath) suivante appelle une fonction Lambda nommée. `HelloFunction`
```
"Lambda Invoke": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Parameters": {
"Payload.$": "$",
"FunctionName": "arn:aws:lambda:region:account-id:function:HelloFunction:$LATEST"
},
"End": true
}
```
## Types de tâche
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é](#state-task-activity)
+ [Fonctions Lambda](#state-task-lambda)
+ [A pris en charge Service AWS](#state-task-connector)
+ [Une tâche HTTP](call-https-apis.md)
Vous spécifiez un type de tâche en fournissant son 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 appelle une API HTTPS, utilisent la syntaxe suivante. Pour plus d'informations sur la syntaxe de la tâche HTTP, consultez[Appelez HTTPS APIs dans les flux de travail Step Functions](call-https-apis.md).
Dans la définition de l'état de votre tâche, remplacez le texte en italique dans la syntaxe suivante par les informations spécifiques à la AWS ressource.
```
arn:partition:service:region:account:task_type:name
```
La liste suivante décrit les différents composants de cette syntaxe :
+ `partition`est la AWS Step Functions partition à utiliser le plus souvent`aws`.
+ `service`indique la valeur Service AWS utilisée pour exécuter la tâche et peut prendre l'une des valeurs suivantes :
+ `states` pour une [activité](#state-task-activity).
+ `lambda`pour une fonction [Lambda](#state-task-lambda). Si vous effectuez une intégration avec d'autres Services AWS, par exemple Amazon SNS ou Amazon DynamoDB, utilisez ou. `sns` `dynamodb`
+ `region`est le [code de AWS région](https://docs.aws.amazon.com/general/latest/gr/rande.html) dans lequel l'activité Step Functions ou le type de machine à états, la fonction Lambda ou toute autre AWS ressource ont été créés.
+ `account`est l' Compte AWS ID sous lequel vous avez défini la ressource.
+ `task_type` est le type de tâche à exécuter. Cette option peut avoir l’une des valeurs suivantes :
+ `activity`— Une [activité](#state-task-activity).
+ `function`— Une fonction [Lambda](#state-task-lambda).
+ `servicename`— Le nom d'un service connecté pris en charge (voir[Intégrer les services avec Step Functions](integrate-optimized.md)).
+ `name`est le nom de la ressource enregistrée (nom de l'activité, nom de la fonction Lambda ou action de l'API 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](https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateActivity.html)action d'API ou de la [console Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/)) 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](concepts-activities.md).
### Fonctions Lambda
Les tâches Lambda exécutent une fonction en utilisant. AWS Lambda Pour spécifier une fonction Lambda, utilisez l'ARN de la fonction Lambda dans le champ. `Resource`
La forme de votre `Resource` champ de fonction Lambda varie en fonction du type d'intégration.
Pour une intégration standard du AWS SDK avec une fonction Lambda, `Resource` le champ contiendra la valeur suivante :
```
"arn:aws:states:::aws-sdk:lambda:invoke"
```
Nous **vous recommandons** d'utiliser l'intégration optimisée pour vos fonctions Lambda, en utilisant la valeur suivante pour le `Resource` champ :
```
"arn:aws:states:::lambda:invoke"
```
La définition `Task` d'état suivante montre un exemple d'intégration optimisée avec une fonction Lambda nommée `HelloWorld` using. JSONata
```
"Optimized call to Lambda function (JSONata)": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Output": "{% $states.result.Payload %}",
"Arguments": {
"FunctionName": "arn:aws:lambda:region:account-id:function:HelloWorld:$LATEST",
"Payload": {
"key": "{% $states.input.myKey %}"
}
},
"Next": "NextState"
}
```
### A pris en charge Service AWS
Lorsque vous référencez une ressource connectée, Step Functions appelle directement les actions d'API 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-id:servicename:APIname
```
**Note**
Pour créer une connexion synchrone à une ressource connectée, ajoutez-la `.sync` à l'*APIname*entrée dans l'ARN. Pour de plus amples informations, veuillez consulter [Intégration des services ](integrate-services.md).
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](statemachine-structure.md#amazon-states-language-common-fields), les états `Task` ont les champs suivants.
** `Resource` (Obligatoire)**
URI, en particulier un ARN qui identifie de manière unique la tâche spécifique à exécuter.
**`Arguments`(Facultatif, JSONata uniquement)**
Utilisé pour transmettre des informations aux actions d'API de ressources connectées. Les valeurs peuvent inclure JSONata des expressions. Pour de plus amples informations, veuillez consulter [Transformer les données avec JSONata in Step Functions](transforming-data.md).
**`Output`(Facultatif, JSONata uniquement)**
Utilisé pour spécifier et transformer la sortie de l'état. Lorsqu'elle est spécifiée, la valeur remplace la valeur par défaut de sortie de l'état.
Le champ de sortie accepte n'importe quelle valeur JSON (objet, tableau, chaîne, nombre, booléen, nul). Toute valeur de chaîne, y compris celles contenues dans des objets ou des tableaux, sera évaluée comme JSONata si elle était entourée de \$1% %\$1 caractères.
Output accepte également directement une JSONata expression, par exemple : « Output » : « \$1% jsonata expression %\$1 »
Pour plus d'informations, consultez [Traitement des entrées et des sorties](concepts-input-output-filtering.md).
**`Parameters`(Facultatif, JSONPath uniquement)**
Utilisé pour transmettre des informations aux actions d'API de ressources connectées. Les paramètres peuvent utiliser une combinaison de JSON statique et [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/). Pour de plus amples informations, veuillez consulter [Transmission de paramètres à une API de service dans Step Functions](connect-parameters.md).
**`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](intrinsic-functions.md) qui se résout en un ARN de rôle IAM au moment 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, consultez[Exemples de champs d'informations d'identification de l'état de la tâche](#task-state-example-credentials). Pour un exemple d'utilisation de ce champ pour accéder à une AWS ressource entre comptes depuis votre machine d'état, consultez[Accès aux AWS ressources multi-comptes dans Step Functions](tutorial-access-cross-acct-resources.md).
Ce champ est pris en charge par les fonctions Lambda [Types de tâche](#task-types) qui utilisent des [fonctions Lambda](#state-task-lambda) et [un service pris en charge AWS](integrate-services.md).
** `ResultPath`(Facultatif, JSONPath uniquement)**
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](concepts-input-output-filtering.md).
** `ResultSelector`(Facultatif, JSONPath uniquement)**
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](input-output-inputpath-params.md#input-output-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](concepts-error-handling.md#error-handling-examples).
** `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](concepts-error-handling.md#error-handling-fallback-states).
** `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.Timeout](concepts-error-handling.md#statestimeout)erreur 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 lorsque l'événement de démarrage est exécuté, par exemple lorsque `TaskStarted``ActivityStarted`, ou lorsque les `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 ayant échoué.
Le délai d'expiration des tâches HTTP est de 60 secondes au maximum, même s'il `TimeoutSeconds` dépasse cette limite. Consultez [Quotas liés à la tâche HTTP](service-quotas.md#service-limits-http-task)
** `TimeoutSecondsPath`(Facultatif, JSONPath uniquement)**
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, utilisez`TimeoutSecondsPath`. Une fois résolu, le chemin de référence doit sélectionner les champs dont les valeurs sont des entiers positifs.
Un `Task` état ne peut pas inclure à la fois `TimeoutSeconds` et`TimeoutSecondsPath`. Le délai d'expiration des tâches HTTP 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 cardiaques empêchent l'exécution d'une activité ou d'une tâche `TimeoutSeconds` pendant la durée prévue.
`HeartbeatSeconds`doit ê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](concepts-error-handling.md#statestimeout)
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, JSONPath uniquement)**
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, utilisez`HeartbeatSecondsPath`. Une fois résolu, le chemin de référence doit sélectionner les champs dont les valeurs sont des entiers positifs.
Un `Task` état ne peut pas inclure à la fois `HeartbeatSeconds` et`HeartbeatSecondsPath`.
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](#task-state-example-timeouts)
+ [Exemple de délai d'expiration statique et de notification du rythme cardiaque](#task-state-example-static)
+ [Exemple de délai d'expiration d'une tâche dynamique et de notification du rythme cardiaque](#task-state-example-dynamic)
+ [Utilisation du champ Informations d'identification](#task-state-example-credentials)
+ [Spécification de l'ARN du rôle IAM codé en dur](#example-credentials-specify-role-arn)
+ [Spécification en JSONPath tant qu'ARN du rôle IAM](#example-credentials-specify-dynamic-jsonpath)
+ [Spécification d'une fonction intrinsèque en tant qu'ARN du rôle IAM](#example-credentials-specify-dynamic-intrinsic-function)
### É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:region: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 le AWS Glue 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 la AWS Glue tâche, elle est marquée comme`failed`.
```
"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 de l'ARN du rôle IAM codé en dur
L'exemple suivant spécifie un rôle IAM 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, l'ARN du rôle cible 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 qu'ARN du rôle IAM
L'exemple suivant spécifie une JSONPath valeur, qui sera convertie en un ARN de rôle IAM lors de l'exécution.
```
{
"StartAt": "Lambda",
"States": {
"Lambda": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Credentials": {
"RoleArn.$": "$.roleArn"
},
...
}
}
}
```
#### Spécification d'une fonction intrinsèque en tant qu'ARN du rôle IAM
L'exemple suivant utilise la fonction [`States.Format`](intrinsic-functions.md#asl-intrsc-func-generic)intrinsèque, qui se résout en un ARN de rôle IAM au moment 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)"
},
...
}
}
}
```