[AWS] Play with Step Functions (SAM + Lambda) Part.3 (Branch)

Examen de la partie 2

Dans Part2, nous avons principalement fait ce qui suit.

• Essayez de transmettre un argument fixe à Lambda
• Essayez de transmettre un argument externe à Lambda
• Essayez de transmettre un objet de contexte à Lambda
• Essayez de transmettre la valeur de retour de Lambda à l'argument d'une autre tâche

Cette fois, je partirai de la suite. Si vous partez d'ici, https://github.com/hito-psv/sam-demo-005 C'est normal d'avoir le code de `git clone``, ou vous pouvez l'essayer depuis Part2.

L'objectif de cette fois

--Lambda renvoie des résultats aléatoires

• Changer la tâche à exécuter ensuite en fonction du résultat --Lorsque vous réessayez, réexécutez après un certain temps

Je voudrais cibler. Pour la partie Lambda, j'aimerais jouer avec la fonction "Hello World" créée dans Part2 et essayer diverses choses.

Préparation

Modifier la fonction Lambda

Je voudrais retourner quelques modèles de chaînes dans le code actuel avec des nombres aléatoires.

hello_world/app.py

import logging
import random

logger = logging.getLogger()
logger.setLevel(logging.INFO)

def lambda_handler(event, context):
    logger.info(event)

    message_array = [
        "hello world",
        "retry"
    ]
    message = random.choice(message_array)
    logger.info(message)

    return {
        "statusCode": 200,
        "body": {
            "message": message,
        }
    }

Maintenant, le message résultant sera

• hello_world
• retry

L'une ou l'autre chaîne de est renvoyée.

Construire / déployer

Dans cet état, exécutez sam build, sam deploy --guided pour déployer la fonction Lambda.

Changer le comportement en fonction de la valeur de retour de la fonction Lambda

Modifier la définition de la machine d'état

Tout d'abord, modifiez la définition de la machine à états. J'expliquerai le contenu de la correction plus tard, donc j'essaierai d'abord de le corriger comme ça.

step_functions/state_machine.json

{
  "StartAt": "hello world 1",
  "States": {
    "hello world 1": {
      "Type": "Task",
      "Resource": "${HelloWorldFunction}",
      "Parameters": {
        "p1.$": $.p1,
        "p2.$": "$.p2",
        "p3": {
          "p3-1": 20,
          "p3-2": "xyz"
        },
        "all.$": "$"
      },
      "ResultPath": "$.hello_world_result",
      "OutputPath": "$",
      "Next": "check state"
    },
    "retry lambda": {
      "Type": "Task",
      "Resource": "${HelloWorldFunction}",
      "InputPath": "$",
      "ResultPath": "$.hello_world_result",
      "OutputPath": "$",
      "Next": "check state"
    },
    "check state": {
      "Type" : "Choice",
      "Choices": [
        {
          "Variable": "$.hello_world_result.body.message",
          "StringEquals": "hello world",
          "Next": "hello world 2"
        },
        {
          "Variable": "$.hello_world_result.body.message",
          "StringEquals": "retry",
          "Next": "wait state"
        }
      ],
      "Default": "fail state"
    },
    "wait state": {
      "Type": "Wait",
      "Seconds": 5,
      "Next": "retry lambda"
    },
    "hello world 2": {
      "Type": "Task",
      "Resource": "${HelloWorldFunction}",
      "InputPath": "$",
      "End": true
    },
    "fail state": {
      "Type": "Fail",
      "Cause": "No Matches!"
    }
  }
}

1. "hello world 1" exécute l'état de "check state" vers l'état suivant
2. Pour "vérifier l'état", si la valeur de "$ .hello_world_result.body.message" est "hello world", exécutez "hello world 2" dans l'état suivant.
3. Pour "vérifier l'état", si la valeur de "$ .hello_world_result.body.message" est "réessayer", exécutez "état d'attente" à l'état suivant.
4. Pour "check state", si la valeur de "$ .hello_world_result.body.message" est différente de "hello world" et "retry", exécutez "fail state" dans l'état suivant (cette fois, cela ne peut pas arriver).
5. "wait state" exécute l'état "retry lambda" après 5 secondes.
6. "retry lambda" exécute l'état "check state" après avoir appelé la fonction lambda
7. "hello world 2" termine l'exécution de l'état après avoir appelé la fonction lambda
8. "l'état d'échec" met fin à l'exécution de l'état comme arrêt anormal

Il est décrit comme. Dans "Choices"

--Variable: vérifier la cible --StringEquals: Si la chaîne est la même que cette valeur --Next: état à exécuter ensuite

Est spécifié. Les opérations pouvant être spécifiées dans la section String Equals sont le [AWS Step Functions Developer Guide](https://docs.aws.amazon.com/ja_jp/step-functions/latest/dg/amazon-states-language-" Veuillez vous référer à choice-state.html).

Construire / déployer

Dans cet état, exécutez «sam build» et «sam deploy --guided» pour déployer.

Vérification de la machine d'état

Tout d'abord, voyons à quoi ressemble la machine à états visualisée en mettant à jour la définition de la machine à états.

Au fur et à mesure que vous avez changé, vous pouvez voir qu'il passe de "check state" et revient à "check state" après "retry lambda".

Essayez d'exécuter la machine d'état

Exécutons la machine d'état à partir de la console de gestion. Puisque les valeurs d'entrée p1 et p2 sont utilisées pour la correction de la partie 2, veuillez spécifier l'orchidée d'entrée comme suit.

• Spécifiez une valeur 9999 pour p1 --Spécifiez la chaîne "chaînes p2". Pour p2

Voyons le résultat

Commençons par vérifier le flux visuel. Tous les chemins passent à merveille (parce que c'est aléatoire, il peut y avoir un flux de "bonjour le monde 1" → "vérifier l'état" → "bonjour le monde 2").

Maintenant, vérifions si le processus Choice fonctionne correctement. Tout d'abord, voici le retour de la fonction Lambda appelée à partir de l'état "hello world 1".

Vous pouvez voir que la partie du message du corps est "réessayer". En conséquence, "l'état d'attente" est alors exécuté, et après 5 secondes (vérification des temps # 10 et # 11), "l'état lambda de réessai" est en cours d'exécution.

En fait, après cela, "retry" est renvoyé deux fois de suite, mais "hello world" est renvoyé la troisième fois.

Après cela, vous pouvez voir que l'état de "hello world 2" est exécuté.

Et l'État se termine tel qu'il est.

État "Choix" nouvellement ajouté

Il y a un contenu mis à jour le 13 août 2020.

Test de valeur (contrôle de type)

• IsNull
• IsString
• IsNumeric
• IsBoolean
• IsTimestamp

Vous permet de voir le type de «Variable» dans «Choix».

Exemple

   "Variable": "$.foo",
   "IsNull|IsString|IsNumeric|IsBoolean|IsTimestamp": true|false

Contrôle d'existence

• IsPresent

Vous permet de vérifier l'existence de «Variable» elle-même.

Exemple

  "Variable": "$.foo",
  "IsPresent": true|false

Vérification des caractères génériques

• StringMatches

Vous permet d'effectuer une vérification de jugement à l'aide d'un joker.

Exemple

  "Variable": "$.foo",
  "StringMatches": "log-*.txt"

Comparaison avec un autre champ de saisie

• StringEqualsPath

Vous permet de comparer un champ d'entrée avec un autre champ d'entrée. Il peut être utilisé pour vérifier les changements de statut.

Exemple

  "Variable": "$.foo",
  "StringEqualsPath": "$.bar"

Détails

Tu peux le vérifier ici.

AWS Step Functions adds updates to ‘choice’ state, global access to context object, dynamic timeouts, result selection, and intrinsic functions to Amazon States Language

Résumé

Cette fois, j'ai essayé de créer des branches avec Choice, mais à ce stade, cela ressemble enfin à un flux de travail. Je pense qu'il est possible de définir une certaine machine à états uniquement avec le contenu de Part.1 à Part.3 jusqu'à présent. La prochaine fois, j'aimerais appeler un service autre que Lambda avec une définition de tâche.

Exemple de référentiel de code

https://github.com/hito-psv/sam-demo-006