Fonctions intrinsèques dans les workflows Amazon States Language for Step Functions

La fonction States.Array intrinsèque ne prend aucun argument ou plus. L'interpréteur renvoie un JSON tableau contenant les valeurs des arguments dans l'ordre indiqué. Par exemple, avec les données d'entrée suivantes :

{
  "Id": 123456
}

Vous pourriez utiliser

"BuildId.$": "States.Array($.Id)"

Ce qui renverrait le résultat suivant :

“BuildId”: [123456]

Utilisez la fonction States.ArrayPartition intrinsèque pour partitionner un grand tableau. Vous pouvez également utiliser cet élément intrinsèque pour découper les données, puis envoyer la charge utile en petits morceaux.

Cette fonction intrinsèque prend deux arguments. Le premier argument est un tableau, tandis que le second définit la taille du bloc. L'interpréteur découpe le tableau d'entrée en plusieurs tableaux de la taille spécifiée par la taille du morceau. La longueur du dernier segment de tableau peut être inférieure à la longueur des fragments de tableau précédents si le nombre d'éléments restants dans le tableau est inférieur à la taille du morceau.

Validation des entrées

Par exemple, étant donné le tableau d'entrée suivant :

{"inputArray": [1,2,3,4,5,6,7,8,9] }

Vous pouvez utiliser cette States.ArrayPartition fonction pour diviser le tableau en morceaux de quatre valeurs :

"inputArray.$": "States.ArrayPartition($.inputArray,4)"

Ce qui renverrait les fragments de tableau suivants :

{"inputArray": [ [1,2,3,4], [5,6,7,8], [9]] }

Dans l'exemple précédent, la States.ArrayPartition fonction produit trois tableaux. Les deux premiers tableaux contiennent chacun quatre valeurs, telles que définies par la taille des morceaux. Un troisième tableau contient la valeur restante et est inférieur à la taille de bloc définie.

Utilisez la fonction States.ArrayContains intrinsèque pour déterminer si une valeur spécifique est présente dans un tableau. Par exemple, vous pouvez utiliser cette fonction pour détecter s'il y a eu une erreur lors d'une itération d'Mapétat.

Cette fonction intrinsèque prend deux arguments. Le premier argument est un tableau, tandis que le second est la valeur à rechercher dans le tableau.

Validation des entrées

Par exemple, étant donné le tableau d'entrée suivant :

{
   "inputArray": [1,2,3,4,5,6,7,8,9],
   "lookingFor": 5
}

Vous pouvez utiliser la States.ArrayContains fonction pour trouver la lookingFor valeur dans inputArray :

"contains.$": "States.ArrayContains($.inputArray, $.lookingFor)"

Comme la valeur stockée dans lookingFor est incluse dans leinputArray, States.ArrayContains renvoie le résultat suivant :

{"contains": true }

Utilisez la fonction States.ArrayRange intrinsèque pour créer un nouveau tableau contenant une plage spécifique d'éléments. Le nouveau tableau peut contenir jusqu'à 1 000 éléments.

Cette fonction prend trois arguments. Le premier argument est le premier élément du nouveau tableau, le deuxième est le dernier élément du nouveau tableau et le troisième argument est la valeur d'incrément entre les éléments du nouveau tableau.

Validation des entrées

Par exemple, l'utilisation suivante de la States.ArrayRange fonction créera un tableau avec une première valeur de 1, une valeur finale de 9, et les valeurs comprises entre les première et dernière valeurs augmenteront de deux pour chaque élément :

"array.$": "States.ArrayRange(1, 9, 2)"

Ce qui renverrait le tableau suivant :

{"array": [1,3,5,7,9] }

Cette fonction intrinsèque renvoie la valeur d'un indice spécifié. Cette fonction prend deux arguments. Le premier argument est un tableau de valeurs et le second est l'index du tableau de la valeur à renvoyer.

Par exemple, utilisez les index valeurs inputArray et suivantes :

{
   "inputArray": [1,2,3,4,5,6,7,8,9],
   "index": 5
}

À partir de ces valeurs, vous pouvez utiliser la States.ArrayGetItem fonction pour renvoyer la valeur à la index position 5 dans le tableau :

"item.$": "States.ArrayGetItem($.inputArray, $.index)"

Dans cet exemple, States.ArrayGetItem renverrait le résultat suivant :

{ "item": 6 }

La fonction States.ArrayLength intrinsèque renvoie la longueur d'un tableau. Il a un argument, le tableau dont la longueur doit être renvoyée.

Par exemple, étant donné le tableau d'entrée suivant :

{
   "inputArray": [1,2,3,4,5,6,7,8,9]
}

Vous pouvez l'utiliser States.ArrayLength pour renvoyer la longueur de inputArray :

"length.$": "States.ArrayLength($.inputArray)"

Dans cet exemple, States.ArrayLength renverrait l'JSONobjet suivant qui représente la longueur du tableau :

{ "length": 9 }

La fonction States.ArrayUnique intrinsèque supprime les valeurs dupliquées d'un tableau et renvoie un tableau contenant uniquement des éléments uniques. Cette fonction prend un tableau, qui peut être détrié, comme seul argument.

Par exemple, le texte suivant inputArray contient une série de valeurs dupliquées :

{"inputArray": [1,2,3,3,3,3,3,3,4] }

Vous pouvez utiliser la States.ArrayUnique fonction as et spécifier le tableau dont vous souhaitez supprimer les doublons :

"array.$": "States.ArrayUnique($.inputArray)"

La States.ArrayUnique fonction renverrait le tableau suivant contenant uniquement des éléments uniques, en supprimant toutes les valeurs dupliquées :

{"array": [1,2,3,4] }

Utilisez la fonction States.Base64Encode intrinsèque pour coder les données selon le schéma de codage MIME Base64. Vous pouvez utiliser cette fonction pour transmettre des données à d'autres AWS services sans utiliser de AWS Lambda .

Cette fonction prend comme seul argument une chaîne de données de 10 000 caractères maximum à coder.

Par exemple, considérez la input chaîne suivante :

{"input": "Data to encode" }

Vous pouvez utiliser la States.Base64Encode fonction pour encoder la input chaîne en tant que chaîne MIME Base64 :

"base64.$": "States.Base64Encode($.input)"

La States.Base64Encode fonction renvoie les données codées suivantes en réponse :

{"base64": "RGF0YSB0byBlbmNvZGU=" }

Utilisez la fonction States.Base64Decode intrinsèque pour décoder les données selon le schéma de décodage MIME Base64. Vous pouvez utiliser cette fonction pour transmettre des données à d'autres AWS services sans utiliser de fonction Lambda.

Cette fonction prend comme seul argument une chaîne de données codée en Base64 de 10 000 caractères maximum à décoder.

Par exemple, avec les données d'entrée suivantes :

{"base64": "RGF0YSB0byBlbmNvZGU=" }

Vous pouvez utiliser la States.Base64Decode fonction pour décoder la chaîne base64 en une chaîne lisible par l'homme :

"data.$": "States.Base64Decode($.base64)"

Ils States.Base64Decode function renverraient les données décodées suivantes en réponse :

{"data": "Decoded data" }

Utilisez la fonction States.Hash intrinsèque pour calculer la valeur de hachage d'une entrée donnée. Vous pouvez utiliser cette fonction pour transmettre des données à d'autres AWS services sans utiliser de fonction Lambda.

Cette fonction prend deux arguments. Le premier argument concerne les données dont vous souhaitez calculer la valeur de hachage. Le deuxième argument est l'algorithme de hachage à utiliser pour effectuer le calcul du hachage. Les données que vous fournissez doivent être une chaîne d'objets contenant 10 000 caractères ou moins.

L'algorithme de hachage que vous spécifiez peut être l'un des algorithmes suivants :

Par exemple, vous pouvez utiliser cette fonction pour calculer la valeur de hachage de la Data chaîne à l'aide de la valeur spécifiée Algorithm :

{
   "Data": "input data", 
   "Algorithm": "SHA-1" 
}

Vous pouvez utiliser la States.Hash fonction pour calculer la valeur de hachage :

"output.$": "States.Hash($.Data, $.Algorithm)"

La States.Hash fonction renvoie la valeur de hachage suivante en réponse :

{"output": "aaff4a450a104cd177d28d18d7485e8cae074b7" }

Utilisez la fonction States.JsonMerge intrinsèque pour fusionner deux JSON objets en un seul. Cette fonction prend trois arguments. Les deux premiers arguments correspondent aux JSON objets que vous souhaitez fusionner. Le troisième argument est une valeur booléenne de. false Cette valeur booléenne détermine si le mode de fusion profonde est activé.

Step Functions ne prend actuellement en charge que le mode de fusion superficielle ; vous devez donc spécifier la valeur booléenne sous la forme. false En mode superficiel, si la même clé existe dans les deux JSON objets, la clé du dernier objet remplace la même clé dans le premier objet. En outre, les objets imbriqués dans un JSON objet ne sont pas fusionnés lorsque vous utilisez une fusion superficielle.

Par exemple, vous pouvez utiliser cette States.JsonMerge fonction pour fusionner les JSON objets suivants qui partagent la cléa.

{
   "json1": { "a": {"a1": 1, "a2": 2}, "b": 2 },
   "json2": { "a": {"a3": 1, "a4": 2}, "c": 3 }
}

Vous pouvez spécifier les objets json1 et json2 comme entrées dans la States.JsonMerge fonction pour les fusionner :

"output.$": "States.JsonMerge($.json1, $.json2, false)"

States.JsonMergeRenvoie l'JSONobjet fusionné suivant en tant que résultat. Dans l'JSONobjet fusionnéoutput, la clé de l'json2objet a remplace la clé de l'json1objeta. De plus, l'objet imbriqué dans la clé de json1 l'objet a est supprimé car le mode superficiel ne permet pas de fusionner des objets imbriqués.

{
   "output": {
      "a": {"a3": 1, "a4": 2},
      "b": 2, 
      "c": 3 
   }
}

La States.StringToJson fonction prend comme seul argument un chemin de référence vers une JSON chaîne échappée.

L'interpréteur applique un JSON analyseur et renvoie le formulaire analysé JSON de l'entrée. Par exemple, vous pouvez utiliser cette fonction pour échapper à la chaîne de saisie suivante :

{
 "escapedJsonString": "{\"foo\": \"bar\"}"
}
                

Utilisez la States.StringToJson fonction et spécifiez le escapedJsonString comme argument d'entrée :

States.StringToJson($.escapedJsonString)

La States.StringToJson fonction renvoie le résultat suivant :

{ "foo": "bar" }

La States.JsonToString fonction ne prend qu'un seul argument, à savoir le chemin contenant les JSON données à renvoyer sous forme de chaîne non échappée. L'interpréteur renvoie une chaîne contenant JSON du texte représentant les données spécifiées par le chemin. Par exemple, vous pouvez fournir le JSON chemin suivant contenant une valeur échappée :

{
  "unescapedJson": {
     "foo": "bar"
  }
}

Fournissez à la States.JsonToString fonction les données contenues dans unescapedJson :

States.JsonToString($.unescapedJson)
                

La States.JsonToString fonction renvoie la réponse suivante :

{\"foo\": \"bar\"}

Utilisez la fonction States.MathRandom intrinsèque pour renvoyer un nombre aléatoire compris entre le numéro de début (inclus) et le numéro de fin (exclusif) spécifiés.

Vous pouvez utiliser cette fonction pour répartir une tâche spécifique entre deux ressources ou plus.

Cette fonction prend trois arguments. Le premier argument est le numéro de début, le deuxième est le numéro de fin et le dernier argument contrôle la valeur initiale facultative. Notez que si vous utilisez cette fonction avec la même valeur initiale, elle renverra des nombres identiques.

Validation des entrées

Par exemple, pour générer un nombre aléatoire compris entre un et 999, vous pouvez utiliser les valeurs d'entrée suivantes :

{
   "start": 1,
   "end": 999
}

Pour générer le nombre aléatoire, fournissez les end valeurs start et à la States.MathRandom fonction :

"random.$": "States.MathRandom($.start, $.end)"

La States.MathRandom fonction renvoie le nombre aléatoire suivant en réponse :

{"random": 456 }

Utilisez la fonction States.MathAdd intrinsèque pour renvoyer la somme de deux nombres. Par exemple, vous pouvez utiliser cette fonction pour incrémenter des valeurs dans une boucle sans appeler de fonction Lambda.

Validation des entrées

Par exemple, vous pouvez utiliser les valeurs suivantes pour soustraire un de 111 :

{
   "value1": 111,
   "step": -1
}

Utilisez ensuite la States.MathAdd fonction définissant value1 comme valeur de départ et step comme valeur à incrémenter value1 de :

"value1.$": "States.MathAdd($.value1, $.step)"

La States.MathAdd fonction renverrait le nombre suivant en réponse :

{"value1": 110 }

Utilisez la fonction States.StringSplit intrinsèque pour diviser une chaîne en un tableau de valeurs. Cette fonction prend deux arguments. Le premier argument est une chaîne et le second est le caractère de délimitation que la fonction utilisera pour diviser la chaîne.

{
    "inputString": "1,2,3,4,5",
    "splitter": ","
}

"array.$": "States.StringSplit($.inputString, $.splitter)"

{"array":  ["1","2","3","4","5"] }

{
  "inputString": "This.is+a,test=string",
  "splitter": ".+,="
}

{
  "myStringArray.$": "States.StringSplit($.inputString, $.splitter)"
}

{"myStringArray": [
  "This",
  "is",
  "a",
  "test",
  "string"
]}

Utilisez la fonction States.UUID intrinsèque pour renvoyer un identifiant unique universel (v4UUID) de version 4 généré à l'aide de nombres aléatoires. Par exemple, vous pouvez utiliser cette fonction pour appeler d'autres AWS services ou ressources qui nécessitent un UUID paramètre ou l'insertion d'éléments dans une table DynamoDB.

La States.UUID fonction est appelée sans qu'aucun argument ne soit spécifié :

"uuid.$": "States.UUID()"

La fonction renvoie une donnée générée aléatoirementUUID, comme dans l'exemple suivant :

{"uuid": "ca4c1140-dcc1-40cd-ad05-7b4aa23df4a8" }

Utilisez la fonction States.Format intrinsèque pour construire une chaîne à partir de valeurs littérales et interpolées. Cette fonction prend un ou plusieurs arguments. La valeur du premier argument doit être une chaîne et peut inclure zéro ou plusieurs instances de la séquence de caractères{}. Il doit rester autant d'arguments dans l'invocation de la fonction intrinsèque qu'il y a d'occurrences de{}. L'interpréteur renvoie la chaîne définie dans le premier argument, chacune étant {} remplacée par la valeur de l'argument correspondant à la position dans l'invocation intrinsèque.

Par exemple, vous pouvez utiliser les entrées suivantes parmi celles d'un individuname, ainsi qu'une template phrase dans laquelle insérer son nom :

{
 "name": "Arnav",
 "template": "Hello, my name is {}."
}

Utilisez la States.Format fonction et spécifiez la template chaîne et la chaîne à insérer à la place des {} caractères :

States.Format('Hello, my name is {}.', $.name)

or

States.Format($.template, $.name)

Avec l'une des entrées précédentes, la States.Format fonction renvoie la chaîne complète en réponse :

Hello, my name is Arnav.