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. # Utilisation de l'état de la carte en mode Inline dans les flux de travail Step Functions **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). Par défaut, `Map` les états s'exécutent en mode **Inline**. En mode Inline, l'état de la carte accepte uniquement un tableau JSON en entrée. Il reçoit ce tableau lors d'une étape précédente du flux de travail. Dans ce mode, chaque itération de l'`Map`état s'exécute dans le contexte du flux de travail qui contient l'`Map`état. Step Functions ajoute l'historique d'exécution de ces itérations à l'historique d'exécution du flux de travail parent. Dans ce mode, l'`Map`état prend en charge jusqu'à 40 itérations simultanées. Un `Map` état défini sur **Inline** est appelé état *Inline Map*. Utilisez l'`Map`état en mode Inline si l'historique d'exécution de votre flux de travail ne doit pas dépasser 25 000 entrées ou si vous n'avez pas besoin de plus de 40 itérations simultanées. Pour une introduction à l'utilisation de l'*état Inline Map*, consultez le didacticiel[Répéter les actions avec Inline Map](tutorial-map-inline.md). **Topics** + [Concepts clés de cette rubrique](#key-concepts-inline-map) + [Champs d'état de la carte intégrée](#map-state-inline-additional-fields) + [Champs déconseillés](#map-state-inline-deprecated-fields) + [Exemple d'état d'une carte intégrée () JSONPath](#inline-map-state-examples) + [Exemple d'état de la carte en ligne avec `ItemSelector`](#inline-map-state-example-params) + [Traitement d'entrée et de sortie d'`Map`état en ligne](#inline-map-state-output) ## Concepts clés de cette rubrique **Mode en ligne** Mode de simultanéité limité de l'État. `Map` Dans ce mode, chaque itération de l'`Map`état s'exécute dans le contexte du flux de travail qui contient l'`Map`état. Step Functions ajoute l'historique d'exécution de ces itérations à l'historique d'exécution du flux de travail parent. `Map`les états s'exécutent en mode Inline par défaut. Ce mode n'accepte qu'un tableau JSON en entrée et prend en charge jusqu'à 40 itérations simultanées. **État de la carte en ligne** `Map`État défini sur le mode **Inline**. **Flux de travail cartographique** Ensemble d'étapes que l'`Map`état exécute pour chaque itération. **Itération de l'état de la carte** Une répétition du flux de travail défini dans l'`Map`état. ## Champs d'état de la carte intégrée Pour utiliser l'*état Inline Map* dans vos flux de travail, spécifiez un ou plusieurs de ces champs. Vous spécifiez ces champs en plus des [champs d'état courants](statemachine-structure.md#amazon-states-language-common-fields). **`Type` (Obligatoire)** Définit le type d'état, tel que`Map`. **`ItemProcessor` (Obligatoire)** Contient les objets JSON suivants qui spécifient le mode et la définition de traitement de `Map` l'état. La définition contient l'ensemble des étapes à répéter pour traiter chaque élément du tableau. + `ProcessorConfig`— Objet JSON facultatif qui spécifie le mode de traitement de l'`Map`état. Cet objet contient le `Mode` sous-champ. La valeur par défaut de ce champ est`INLINE`, qui utilise l'`Map`état en mode Inline. Dans ce mode, l'échec d'une itération entraîne l'échec de l'`Map`état. Toutes les itérations s'arrêtent lorsque l'`Map`état échoue. + `StartAt`— Spécifie une chaîne qui indique le premier état d'un flux de travail. Cette chaîne distingue les majuscules et minuscules et doit correspondre au nom de l'un des objets d'état. Cet état s'exécute d'abord pour chaque élément de l'ensemble de données. Toute entrée d'exécution que vous fournissez à l'`Map`état passe d'abord à l'`StartAt`état. + `States`[— Objet JSON contenant un ensemble d'états séparés par des virgules.](workflow-states.md) Dans cet objet, vous définissez le[Map workflow](#mapwflow). **Note** Les États du `ItemProcessor` domaine ne peuvent que passer les uns aux autres. Aucun état situé en dehors du `ItemProcessor` champ ne peut passer à un état situé à l'intérieur de celui-ci. Le `ItemProcessor` champ remplace le champ désormais obsolète. `Iterator` Bien que vous puissiez continuer à inclure `Map` les états qui utilisent le `Iterator` champ, nous vous recommandons vivement de le remplacer par`ItemProcessor`. [Step Functions Local](sfn-local.md) ne prend actuellement pas en charge `ItemProcessor` ce domaine. Nous vous recommandons d'utiliser le `Iterator` champ avec Step Functions Local. **`Items`(Facultatif, JSONata uniquement)** Un tableau JSON ou une JSONata expression qui doit être évaluée en tableau. **`ItemsPath`(Facultatif, JSONPath uniquement)** Spécifie un [chemin de référence](amazon-states-language-paths.md#amazon-states-language-reference-paths) à l'aide de la [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/)syntaxe. Ce chemin sélectionne le nœud JSON qui contient le tableau d'éléments à l'intérieur de l'entrée d'état. Pour de plus amples informations, veuillez consulter [ItemsPath (Carte, JSONPath uniquement)](input-output-itemspath.md). **`ItemSelector` (facultatif)** Remplace les valeurs des éléments du tableau d'entrée avant qu'elles ne soient transmises à chaque itération `Map` d'état. Dans ce champ, vous spécifiez un JSON valide contenant une collection de paires clé-valeur. Ces paires peuvent contenir l'un des éléments suivants : + Valeurs statiques que vous définissez dans la définition de votre machine à états. + Valeurs sélectionnées à partir de l'entrée d'état à l'aide d'un [chemin](amazon-states-language-paths.md). + Valeurs accessibles depuis l'[objet de contexte](input-output-contextobject.md). Pour de plus amples informations, veuillez consulter [ItemSelector (Carte)](input-output-itemselector.md). Le `ItemSelector` champ remplace le champ désormais obsolète. `Parameters` Bien que vous puissiez continuer à inclure `Map` les états qui utilisent le `Parameters` champ, nous vous recommandons vivement de le remplacer par`ItemSelector`. **`MaxConcurrency` (facultatif)** Spécifie une valeur entière qui fournit la limite supérieure du nombre d'itérations d'`Map`états pouvant être exécutées en parallèle. Par exemple, une `MaxConcurrency` valeur de 10 limite l'`Map`état à 10 itérations simultanées exécutées simultanément. Dans JSONata les états, vous pouvez spécifier une JSONata expression dont la valeur est un entier. Les itérations simultanées peuvent être limitées. Dans ce cas, certaines itérations ne commenceront pas tant que les itérations précédentes ne seront pas terminées. La probabilité que cela se produise augmente lorsque votre tableau d'entrée comporte plus de 40 éléments. Pour obtenir une plus grande simultanéité, considérez[Mode distribué](state-map-distributed.md). La valeur par défaut est`0`, ce qui n'impose aucune limite à la simultanéité. Step Functions invoque des itérations aussi simultanément que possible. Une `MaxConcurrency` valeur de `1` invoque `ItemProcessor` une fois pour chaque élément du tableau. Les éléments du tableau sont traités dans l'ordre de leur apparition dans l'entrée. Step Functions ne démarre pas une nouvelle itération tant qu'elle n'a pas terminé l'itération précédente. **`MaxConcurrencyPath`(Facultatif, JSONPath uniquement)** Si vous souhaitez fournir une valeur de simultanéité maximale de manière dynamique à partir de l'entrée d'état à l'aide d'un chemin de référence, utilisez`MaxConcurrencyPath`. Une fois résolu, le chemin de référence doit sélectionner un champ dont la valeur est un entier non négatif. Un `Map` état ne peut pas inclure à la fois `MaxConcurrency` et`MaxConcurrencyPath`. **`ResultPath`(Facultatif, JSONPath uniquement)** Spécifie l'endroit de l'entrée où stocker la sortie des itérations de l'`Map`état. L'état de la carte filtre ensuite l'entrée comme spécifié par le [`OutputPath`](input-output-example.md#input-output-outputpath)champ, le cas échéant. Ensuite, il utilise l'entrée filtrée 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, dont les valeurs sont soit statiques, soit sélectionnées à partir du résultat. Pour de plus amples informations, veuillez consulter [ResultSelector](input-output-inputpath-params.md#input-output-resultselector). 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](input-output-inputpath-params.md#input-output-resultselector) champ. Pour de plus amples informations, veuillez consulter [Aplatir un tableau de tableaux](input-output-inputpath-params.md#flatten-array-of-arrays-result-selector). **`Retry` (facultatif)** Tableau d'objets, appelés Retriers, qui définit une politique de nouvelle tentative. Les États utilisent une politique de nouvelle tentative lorsqu'ils rencontrent 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). Si vous définissez des récupérateurs pour l'*état de la carte intégrée*, la politique de nouvelles tentatives s'applique à toutes les itérations d'`Map`état, et non aux seules itérations ayant échoué. Par exemple, votre `Map` état contient deux itérations réussies et une itération échouée. Si vous avez défini le `Retry` champ correspondant à l'`Map`état, la politique de nouvelle tentative s'applique aux trois itérations d'`Map`état et non uniquement à l'itération ayant échoué. **`Catch` (facultatif)** Tableau d'objets, nommés Receveurs, qui définissent un état de secours. Les États exécutent un catcher s'ils rencontrent des erreurs d'exécution et s'ils n'ont pas de politique de nouvelle tentative ou si leur politique de relance est épuisée. Pour plus d'informations, consultez [États de secours](concepts-error-handling.md#error-handling-fallback-states). **`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 de plus amples informations, veuillez consulter [Transformer les données avec JSONata in Step Functions](transforming-data.md). ** `Assign` (facultatif)** Utilisé pour stocker des variables. Le `Assign` champ accepte un objet JSON avec des key/value paires qui définissent les noms des variables et les valeurs qui leur sont attribuées. 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 caractères Pour de plus amples informations, veuillez consulter [Transmission de données entre états à l'aide de variables](workflow-variables.md). ## Champs déconseillés **Note** Bien que vous puissiez continuer à inclure `Map` les états qui utilisent les champs suivants, nous vous recommandons vivement de les `Iterator` remplacer par `ItemProcessor` et `Parameters` par`ItemSelector`. ** `Iterator`** Spécifie un objet JSON qui définit un ensemble d'étapes qui traitent chaque élément du tableau. **`Parameters`** Spécifie une collection de paires clé-valeur, dont les valeurs peuvent contenir l'un des éléments suivants : + Valeurs statiques que vous définissez dans la définition de votre machine à états. + Valeurs sélectionnées à partir de l'entrée à l'aide d'un [chemin](amazon-states-language-paths.md). ## Exemple d'état d'une carte intégrée () JSONPath Tenez compte des données d'entrée suivantes pour un `Map` état exécuté en mode **Inline**. ``` { "ship-date": "2016-03-14T01:59:00Z", "detail": { "delivery-partner": "UQS", "shipped": [ { "prod": "R31", "dest-code": 9511, "quantity": 1344 }, { "prod": "S39", "dest-code": 9511, "quantity": 40 }, { "prod": "R31", "dest-code": 9833, "quantity": 12 }, { "prod": "R40", "dest-code": 9860, "quantity": 887 }, { "prod": "R40", "dest-code": 9511, "quantity": 1220 } ] } } ``` Compte tenu de l'entrée précédente, l'`Map`état de l'exemple suivant invoque une AWS Lambda fonction nommée `ship-val` une fois pour chaque élément du tableau dans le `shipped` champ. ``` "Validate All": { "Type": "Map", "InputPath": "$.detail", "ItemProcessor": { "ProcessorConfig": { "Mode": "INLINE" }, "StartAt": "Validate", "States": { "Validate": { "Type": "Task", "Resource": "arn:aws:states:::lambda:invoke", "OutputPath": "$.Payload", "Parameters": { "FunctionName": "arn:aws:lambda:us-east-2:account-id:function:ship-val:$LATEST" }, "End": true } } }, "End": true, "ResultPath": "$.detail.shipped", "ItemsPath": "$.shipped" } ``` Chaque itération de l'`Map`état envoie un élément du tableau, sélectionné avec le [`ItemsPath`](input-output-itemspath.md)champ, en entrée de la fonction `ship-val` Lambda. Les valeurs suivantes sont un exemple d'entrée que l'`Map`état envoie à un appel de la fonction Lambda : ``` { "prod": "R31", "dest-code": 9511, "quantity": 1344 } ``` Une fois terminé, la sortie de l'état `Map` est un tableau JSON, où chaque élément est la sortie d'une itération. Dans ce cas, ce tableau contient la sortie de la fonction `ship-val` Lambda. ## Exemple d'état de la carte en ligne avec `ItemSelector` Supposons que la fonction `ship-val` Lambda de l'exemple précédent ait également besoin d'informations sur le transporteur de l'expédition. Ces informations s'ajoutent aux éléments du tableau pour chaque itération. Vous pouvez inclure des informations provenant de l'entrée, ainsi que des informations spécifiques à l'itération actuelle de l'`Map`état. Notez le `ItemSelector` champ dans l'exemple suivant : ``` "Validate-All": { "Type": "Map", "InputPath": "$.detail", "ItemsPath": "$.shipped", "MaxConcurrency": 0, "ResultPath": "$.detail.shipped", "ItemSelector": { "parcel.$": "$$.Map.Item.Value", "courier.$": "$.delivery-partner" }, "ItemProcessor": { "StartAt": "Validate", "States": { "Validate": { "Type": "Task", "Resource": "arn:aws:lambda:region:account-id:function:ship-val", "End": true } } }, "End": true } ``` Le `ItemSelector` bloc remplace l'entrée des itérations par un nœud JSON. Ce nœud contient à la fois les données de l'article actuel provenant de l'[objet Context](input-output-contextobject.md#contextobject-map) et les informations de messagerie provenant du `delivery-partner` champ de saisie de `Map` l'état. Voici un exemple de saisie pour une seule itération. L'`Map`état transmet cette entrée à un appel de la fonction `ship-val` Lambda. ``` { "parcel": { "prod": "R31", "dest-code": 9511, "quantity": 1344 }, "courier": "UQS" } ``` Dans l'exemple d'*état Inline Map* précédent, le `ResultPath` champ produit une sortie au même format que l'entrée. Cependant, il remplace le `detail.shipped` champ par un tableau dans lequel chaque élément est le résultat de l'appel Lambda `ship-val` de chaque itération. Pour plus d'informations sur l'utilisation de l'*état de la carte intégrée* et de ses champs, consultez ce qui suit. + [Répéter les actions avec Inline Map](tutorial-map-inline.md) + [Traitement des entrées et des sorties dans Step Functions](concepts-input-output-filtering.md) + [ItemsPath (Carte, JSONPath uniquement)](input-output-itemspath.md) + [Données d'objets contextuels pour les états de la carte](input-output-contextobject.md#contextobject-map) ## Traitement d'entrée et de sortie d'`Map`état en ligne Pour un `Map` état donné, [`InputPath`](input-output-inputpath-params.md#input-output-inputpath)sélectionne un sous-ensemble de l'entrée de l'état. L'entrée d'un `Map` état doit inclure un tableau JSON. L'`Map`état exécute la `ItemProcessor` section une fois pour chaque élément du tableau. Si vous spécifiez le [`ItemsPath`](input-output-itemspath.md)champ, l'`Map`état sélectionne l'endroit de l'entrée où se trouve le tableau à itérer. Si elle n'est pas spécifiée, la valeur de `ItemsPath` est `$`, et la section `ItemProcessor` s'attend à ce que le tableau soit la seule entrée. Si vous spécifiez le `ItemsPath` champ, sa valeur doit être un [chemin de référence](amazon-states-language-paths.md#amazon-states-language-reference-paths). L'`Map`État applique ce chemin à l'entrée effective après avoir appliqué le`InputPath`. Le `ItemsPath` doit identifier un champ dont la valeur est un tableau JSON. L'entrée de chaque itération, par défaut, est un élément unique du champ du tableau identifié par la `ItemsPath` valeur. Vous pouvez remplacer cette valeur par le `ItemSelector (Carte)` champ. Une fois terminé, la sortie de l'état `Map` est un tableau JSON, où chaque élément est la sortie d'une itération. Pour plus d'informations sur les entrées et sorties d'état d'Inline Map, consultez les rubriques suivantes : + [Répéter les actions avec Inline Map](tutorial-map-inline.md) + [Exemple d'état de la carte en ligne avec `ItemSelector`](#inline-map-state-example-params) + [Traitement des entrées et des sorties dans Step Functions](concepts-input-output-filtering.md) + [Données d'objets contextuels pour les états de la carte](input-output-contextobject.md#contextobject-map) + [Traitez les données d'une file d'attente avec un état cartographique dans Step Functions](sample-map-state.md)