Dans ce didacticiel, vous apprendrez à utiliser AWS Step Functions pour gérer les erreurs d'exécution du flux de travail. AWS Step Functions est un service d'orchestration sans serveur qui vous permet de facilement coordonner plusieurs fonctions Lambda dans des flux de travail flexibles faciles à déboguer et à modifier. AWS Lambda vous permet d'exécuter du code sans avoir à allouer ou à gérer des serveurs. 

Les fonctions Lambda peuvent parfois échouer, par exemple, lorsqu'une exception non gérée est déclenchée, lorsqu'elles s'exécutent plus longtemps que le délai d'expiration configuré ou lorsqu'elles manquent de mémoire. L'écriture et la maintenance de la logique de gestion des erreurs dans chacune de vos fonctions Lambda pour gérer des situations telles que la limitation de l'API ou les délais d'expiration des sockets peuvent être longues et complexes, en particulier pour les applications distribuées. L'incorporation de ce code dans chaque fonction Lambda crée des dépendances entre elles, et il peut être difficile de conserver toutes ces connexions à mesure que la situation évolue.

Pour éviter ces problèmes et réduire la quantité de code de gestion des erreurs que vous écrivez, vous pouvez utiliser AWS Step Functions pour créer un flux de travail sans serveur qui prend en charge la gestion des erreurs de fonction. Qu'importe si l'erreur est une exception de fonction créée par le développeur (par exemple fichier introuvable) ou imprévue (par exemple mémoire saturée), vous pouvez configurer AWS Step Functions de sorte à réagir en adoptant une logique conditionnelle basée sur le type de message d'erreur reçu. En séparant ainsi votre logique de flux de travail de votre logique métier, vous pouvez modifier la manière dont votre flux de travail répond aux erreurs sans altérer la logique métier de vos fonctions Lambda.

Dans le cadre de ce didacticiel, vous concevrez et exécuterez un flux de travail sans serveur à l'aide d'AWS Step Functions qui gèrera aisément ces erreurs. Vous créerez une fonction AWS Lambda qui simulera les appels vers une API RESTful et renverra divers codes de réponse et exceptions. Ensuite, vous utiliserez AWS Step Functions pour créer une machine d'état grâce aux capacités de nouvelle tentative et d'interception, qui répond avec une logique différente en fonction de l'exception levée.

a.  Lancez AWS Management Console. Vous pouvez garder ce guide étape par étape ouvert. Lorsque cet écran se charge, saisissez votre nom d'utilisateur et votre mot de passe pour commencer. Saisissez ensuite Lambda dans la barre de recherche, puis sélectionnez Lambda pour ouvrir la console de service.

b. Sélectionnez Créer une fonction.

c. Laissez l'option Créer à partir de zéro cochée. Configurez à présent votre fonction Lambda comme suit :

Dans le champ Nom, saisissez MockAPIFunction.
Dans le champ Exécution, sélectionnez Python 3.6.
Dans le champ Rôle, sélectionnez Créer un rôle personnalisé.

Une nouvelle fenêtre IAM s'ouvrira. Laissez le champ Nom du rôle avec la valeur lambda_basic_execution, puis cliquez sur Autoriser. Vous serez automatiquement renvoyé à la console Lambda.

Cliquez sur Créer une fonction.

d. Dans l'écran MockAPIFunction, faites défiler la page vers le bas jusqu'à la section Code de fonction. Dans ce didacticiel, vous créerez une fonction qui utilise le modèle de programmation pour créer des fonctions Lambda en Python. Dans la fenêtre de code, remplacez tout le code par ce qui suit, puis sélectionnez Enregistrer.

class TooManyRequestsException(Exception): pass
class ServerUnavailableException(Exception): pass
class UnknownException(Exception): pass

def lambda_handler(event, context):
    statuscode = event["statuscode"]    
    if statuscode == "429":
        raise TooManyRequestsException('429 Too Many Requests')
    elif statuscode == "503":
        raise ServerUnavailableException('503 Server Unavailable')
    elif statuscode == "200":
        return '200 OK'
    else:
        raise UnknownException('Unknown error')

e. Une fois votre fonction Lambda créée, faites défiler l'écran vers le haut de la fenêtre et notez l'Amazon Resource Name (ARN) de la fonction qui apparaît dans le coin supérieur droit de la page. Les Amazon Resource Names (ARN) identifient de manière unique les ressources AWS et vous aident à suivre et à utiliser les éléments et les stratégies AWS dans les services AWS et les appels d'API. Un ARN est requis lorsque vous devez référencer une ressource spécifique à partir de Step Functions.

a. Dans une autre fenêtre de navigateur, accédez à AWS Management Console et saisissez IAM dans la barre de recherche. Cliquez sur IAM pour ouvrir la console de service.

b. Cliquez sur Rôles, puis sélectionnez Créer un rôle.

c. Depuis la page Sélectionner le type d'entité de confiance, sous service AWS, sélectionnez Step Functions dans la liste, puis Suivant : Autorisations.

d. Sur la page Attacher une stratégie d'autorisation, sélectionnez Suivant : Vérification.

 

e. Sur la page Vérification, saisissez step_functions_basic_execution pour le champ Nom du rôle, puis cliquez sur Créer un rôle.

f. Votre nouveau rôle IAM est créé et apparaît dans la liste sous le rôle IAM de votre fonction Lambda.

a. Ouvrez la console AWS Step Functions. Sur la page Créer une machine d'état, sélectionnez Créer à partir de zéro. Dans la section Détails, nommez votre machine d'état MyAPIStateMachine, puis sélectionnez J'utiliserai un rôle existant.

b. Ensuite, vous créez une machine d'état qui effectuera différentes actions en fonction de la réponse de votre API fictive. Si l'API est inaccessible, le flux de travail réessaiera. Les nouvelles tentatives sont un moyen utile de résoudre les erreurs transitoires. Le flux de travail intercepte également différentes exceptions levées par l'API fictive.

Remplacez le contenu de la section Définition de la machine d'état par le code suivant :

{
  "Comment": "An example of using retry and catch to handle API responses",
  "StartAt": "Call API",
  "States": {
    "Call API": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:FUNCTION_NAME",
      "Next" : "OK",
      "Comment": "Catch a 429 (Too many requests) API exception, and resubmit the failed request in a rate-limiting fashion.",
      "Retry" : [ {
        "ErrorEquals": [ "TooManyRequestsException" ],
        "IntervalSeconds": 1,
        "MaxAttempts": 2
      } ],
      "Catch": [ 
        {
          "ErrorEquals": ["TooManyRequestsException"],
          "Next": "Wait and Try Later"
        }, {
          "ErrorEquals": ["ServerUnavailableException"],
          "Next": "Server Unavailable"
        }, {
          "ErrorEquals": ["States.ALL"],
          "Next": "Catch All"
        }
      ]
    },
    "Wait and Try Later": {
      "Type": "Wait",
      "Seconds" : 1,
      "Next" : "Change to 200"
    },
    "Server Unavailable": {
      "Type": "Fail",
      "Error":"ServerUnavailable",
      "Cause": "The server is currently unable to handle the request."
    },
    "Catch All": {
      "Type": "Fail",
      "Cause": "Unknown error!",
      "Error": "An error of unknown type occurred"
    },
    "Change to 200": {
      "Type": "Pass",
      "Result": {"statuscode" :"200"} ,
      "Next": "Call API"
    },
    "OK": {
      "Type": "Pass",
      "Result": "The request has succeeded.",
      "End": true
    }
  }
}

c. Recherchez la ligne « Resource » dans l'état de la tâche « Appeler l'API » (ligne 7). Pour mettre à jour cet ARN vers l'ARN de la fonction Lambda de l'API fictive que vous venez de créer, cliquez sur le texte ARN, puis sélectionnez l'ARN dans la liste.

d. Cliquez sur le bouton d'actualisation en regard du volet de flux de travail visuel pour que Step Functions crée un diagramme de machine d'état qui correspond au flux de travail que vous venez de concevoir. Après avoir examiné le flux de travail visuel, cliquez sur Créer une machine d'état.

a. Cliquez sur Démarrer l'exécution.

b. Une nouvelle boîte de dialogue d'exécution apparaît, dans laquelle vous pouvez saisir une entrée pour votre machine d'état. Vous jouerez le rôle de l'API et indiquerez le code d'erreur que nous souhaitons voir l'API fictive renvoyer. Remplacez le texte existant par le code ci-dessous, puis sélectionnez Démarrer l'exécution :

{
    "statuscode": "200"
}

c. Dans l'écran Détails d'exécution, cliquez sur Entrée pour voir l'entrée que vous avez fournie à votre machine d'état. Cliquez ensuite sur Sortie pour voir le résultat de l'exécution de votre machine d'état. Vous pouvez voir que le flux de travail a interprété le code d'état 200 comme un appel d'API réussi.

d. Sous Flux de travail visuel, vous pouvez voir le chemin d'exécution de chaque exécution, affiché en vert dans le flux de travail. Cliquez sur l'état Tâche « Appeler l'API », puis développez les champs Entrée et Sortie dans l'écran Détails de l'étape.

Vous pouvez voir que cet état Tâche a réussi à invoquer votre fonction Lambda de l'API fictive avec l'entrée que vous avez fournie et à capturer la sortie de cette fonction Lambda, « 200 OK ».

e. Ensuite, cliquez sur l'état de la tâche « OK » dans le flux de travail visuel. Sous Détails de l'étape, vous pouvez voir que la sortie de l'étape précédente (l'état Tâche de l'API d'appel) a été transmise comme entrée de cette étape. L'état OK est un état Passe, qui a simplement transmis son entrée à sa sortie, sans effectuer de travail. Les états de passe sont utiles lors de la construction et du débogage de machines d’état.

a. Faites défiler la page jusqu’en haut de l'écran Détails de l'exécution et cliquez sur MyAPIStateMachine.

b. Cliquez à nouveau sur Démarrer l'exécution, mais cette fois, indiquez l'entrée suivante, puis cliquez sur Démarrer l'exécution.

{
    "statuscode": "503"
}

c. Dans la section Historique des événements d'exécution, développez chaque étape d'exécution pour confirmer que votre flux de travail s'est comporté comme prévu. Il était prévu que cette exécution échoue, alors ne vous inquiétez pas ! Vous remarquerez les éléments suivants :

1. Step Functions a capturé votre entrée.
2. Cette entrée est passée à l'état Tâche de l'API d'appel.
3. L'état Tâche d'API d'appel a appelé votre fonction MockAPIFunction en utilisant cette entrée.
   
4. La fonction MockAPIFunction a été exécutée.
5. La fonction MockAPIFunction a échoué avec une exception ServerUnavailableException.
6. L'instruction d'interception dans votre état Tâche d'API d'appel a intercepté cette exception.
7. L'instruction d'interception a fait échouer le flux de travail.
   
8. Votre machine d'état a terminé son exécution.
   

d. Vous simulerez ensuite une exception 429. Faites défiler la page jusqu’en haut de l'écran Détails de l'exécution et cliquez sur MyAPIStateMachine. Cliquez sur Démarrer l'exécution, indiquez l'entrée suivante, puis cliquez sur Démarrer l'exécution :

{
    "statuscode": "429"
}

e. À présent, inspectez le comportement de nouvelle tentative de votre flux de travail. Dans la section Historique des événements d'exécution, développez à nouveau chaque étape d'exécution pour confirmer que Step Functions a essayé d'appeler la fonction MockAPILambda deux fois de plus, et que ces deux tentatives ont échoué. À ce stade, votre flux de travail est passé à l'état Attendre et Essayer ultérieurement (illustré dans l'image de droite), dans l'espoir que l'absence de réponse de l'API n'était que temporaire.

Ensuite, l'état Attendre a utilisé la force brute pour changer le code de réponse en 200 et l'exécution de votre flux de travail a réussi. Ce ne serait probablement pas de cette manière que vous auriez géré une exception 429 dans une application réelle, mais nous préférons faire simple pour ce didacticiel.

f. Exécutez une autre instance de votre flux de travail, mais cette fois, fournissez une réponse d'API aléatoire qui n'est pas gérée par votre machine d'état :

{
    "statuscode": "999"
}

Inspectez à nouveau l'exécution à l'aide de l'Historique des événements d'exécution. Une fois l'opération terminée, cliquez à nouveau sur MyAPIStateMachine . Dans le volet Exécutions, vous pouvez voir l'historique de toutes les exécutions de votre flux de travail et accéder à chacune d'entre elles à votre guise.

a. En haut de la fenêtre de la console AWS Step Functions, cliquez sur Machines d'état.

b. Dans la fenêtre Machines d'état, cliquez sur MyAPIStateMachine, puis sélectionnez Supprimer. Confirmez l'action en sélectionnant Supprimer la machine d'état dans la boîte de dialogue. Votre machine d'état sera supprimée en l’espace d’une minute ou deux, une fois que Step Functions aura confirmé que toute exécution en cours était terminée.

c. Ensuite, vous allez supprimer vos fonctions Lambda. Cliquez sur Services dans le menu AWS Management Console, puis sélectionnez Lambda.

d. Dans l'écran Fonctions, cliquez sur votre fonction MockAPIFunction, puis sélectionnez Actions et enfin Supprimer. Confirmez la suppression en cliquant de nouveau sur Supprimer.

e. Enfin, vous allez supprimer vos rôles IAM. Cliquez sur Services dans le menu AWS Management Console, puis sélectionnez IAM.

f. Sélectionnez les deux rôles IAM créés pour ce didacticiel, puis cliquez sur Supprimer le rôle. Confirmez la suppression en cliquant sur Oui, supprimer dans la boîte de dialogue.

Vous pouvez désormais vous déconnecter d’AWS Management Console.