Créer un flux de travail sans serveur
avec AWS Step Functions et AWS Lambda
Dans ce didacticiel, vous allez découvrir comment utiliser AWS Step Functions pour concevoir et exécuter un flux de travail sans serveur qui coordonne plusieurs fonctions AWS Lambda. AWS Lambda vous permet d'exécuter du code sans avoir à provisionner ou à gérer des serveurs.
Dans notre exemple, vous êtes un développeur et il vous a été demandé de créer une application sans serveur pour automatiser la gestion des tickets de support d'un centre d'appels. Alors que vous pourriez avoir une fonction Lambda appelant l'autre, vous craignez que la gestion de toutes ces connexions se complique à mesure que l'application du centre d'appels devient plus sophistiquée. De plus, tout changement dans le flux de l'application nécessitera des changements dans plusieurs emplacements, et vous pourriez en arriver à écrire et réécrire sans cesse le même code.
Pour résoudre ce problème, vous décidez d'utiliser AWS Step Functions. 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. Vos fonctions Lambda ne nécessitent pas de logique supplémentaire grâce à Step Functions qui déclenche et suit chaque étape de votre application à votre place.
Dans les 10 prochaines minutes, vous allez créer une machine d'état Step Functions pour décrire le processus actuel du centre d'appels, créer quelques fonctions Lambda simples qui simulent les tâches de l'équipe de support, et transmettre les données entre chaque fonction Lambda pour suivre les progrès de la demande de support. Ensuite, vous effectuerez plusieurs tests de votre flux de travail pour observer la façon dont il répond à différentes entrées. Enfin, vous supprimerez les ressources AWS que vous avez utilisées dans le didacticiel.
Vous utiliserez AWS Step Functions et AWS Lambda dans ce didacticiel. Ces services sont inclus dans l'offre gratuite AWS.
Ce didacticiel nécessite d'avoir un compte AWS.
Il n'y a aucun frais supplémentaire pour Step Functions ou Lambda. Les ressources que vous créez dans ce didacticiel sont éligibles à l'offre gratuite.
Étape 1. Créer une machine d'état et un flux de travail sans serveur
Votre première étape consiste à concevoir un flux de travail qui décrit la façon dont vous souhaitez que les tickets de support soient pris en charge dans votre centre d'appels. Les flux de travail décrivent un processus comme une série de tâches discrètes qui peuvent être répétées à l'infini.
Vous pouvez discuter avec le responsable du centre d'appels pour expliquer les bonnes pratiques de gestion des demandes de support. En utilisant les flux de travail visuels dans Step Functions comme référence intuitive, vous définissez le flux de travail ensemble.
Vous concevrez ensuite votre flux de travail dans AWS Step Functions. Votre flux de travail appellera une fonction AWS Lambda pour créer une demande de support, invoquera une autre fonction pour attribuer la demande à un représentant du support afin de fournir une résolution, et ainsi de suite. Le flux transmettra aussi les données entre les fonctions Lambda pour suivre le statut de la demande de support en cours de résolution.
a. Ouvrez la console AWS Step Functions. Sélectionnez Author with code snippets (Créer des extraits de code). Dans la zone de texte Name (Nom), saisissez CallCenterStateMachine.
b. Remplacer le contenu de la fenêtre State machine definition (Définition de la machine d'état) par la définition de machine d'état Amazon States Language (ASL) ci-dessous. Amazon States Language est un langage structuré basé sur JSON utilisé pour définir votre machine d'état.
Cette machine d'état utilise une série d'états Task (Tâche) pour ouvrir, affecter et résoudre une demande de cas. Ensuite, un état Choice (Choix) est utilisé pour déterminer si la demande peut être fermée ou non. Enfin, deux autres états Task (Tâche) ferment ou font remonter la demande de support selon le cas.
{
"Comment": "A simple AWS Step Functions state machine that automates a call center support session.",
"StartAt": "Open Case",
"States": {
"Open Case": {
"Type": "Task",
"Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:FUNCTION_NAME",
"Next": "Assign Case"
},
"Assign Case": {
"Type": "Task",
"Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:FUNCTION_NAME",
"Next": "Work on Case"
},
"Work on Case": {
"Type": "Task",
"Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:FUNCTION_NAME",
"Next": "Is Case Resolved"
},
"Is Case Resolved": {
"Type" : "Choice",
"Choices": [
{
"Variable": "$.Status",
"NumericEquals": 1,
"Next": "Close Case"
},
{
"Variable": "$.Status",
"NumericEquals": 0,
"Next": "Escalate Case"
}
]
},
"Close Case": {
"Type": "Task",
"Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:FUNCTION_NAME",
"End": true
},
"Escalate Case": {
"Type": "Task",
"Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:FUNCTION_NAME",
"Next": "Fail"
},
"Fail": {
"Type": "Fail",
"Cause": "Engage Tier 2 Support." }
}
}
c. Cliquez sur le bouton Refresh (Actualiser) pour afficher la définition de la machine d'état ASL comme flux de travail visuel. Dans notre scénario, vous pouvez facilement vérifier que la procédure est correctement décrite en passant en revue le flux de travail visuel avec le responsable du centre d'appels.
d. Cliquez sur Suivant.
Étape 2. Créer un rôle AWS Identity and Access Management (IAM)
AWS IAM est un service web qui vous permet de contrôler en toute sécurité l'accès aux ressources AWS. Dans cette étape, vous allez créer un rôle IAM qui permet à Step Functions d'accéder à Lambda.
a. Dans une autre fenêtre du navigateur, ouvrez AWS Management Console. Lors du chargement de l'écran, saisissez IAM dans la barre de recherche, puis sélectionnez IAM pour ouvrir la console de service.
Étape 3. Ajouter le rôle IAM à la machine d'état
Ensuite, vous ajouterez l'ARN du rôle IAM créé à la machine d'état dans AWS Step Functions.
Étape 4. Créer votre fonction AWS Lambda
Maintenant que votre machine d'état est créée, vous pouvez choisir la manière dont vous voulez qu'elle effectue le travail. Vous pouvez connecter votre machine d'état aux fonctions AWS Lambda et à d'autres microservices qui existent déjà dans votre environnement, ou en créer d'autres. Dans ce didacticiel, vous allez créer quelques fonctions Lambda simples qui simulent diverses étapes pour gérer les appels de support, comme l'attribution de la demande à un représentant du service clientèle.
c. Sélectionnez Author from scratch (Créer à partir de zéro).
d. Configurez votre première fonction Lambda avec ces paramètres :
Nom – OpenCaseFunction.
Runtime – Node.js 4.3.
Rôle – Créez un rôle personnalisé.
Une nouvelle fenêtre IAM apparaît.
e. Pour Role name (Nom du rôle), conservez lambda_basic_execution et cliquez sur Allow (Autoriser).
Vous revenez automatiquement à la console Lambda.
f. Cliquez sur Create function (Créer une fonction).
g. Remplacez le contenu de la fenêtre Function code (Code de la fonction) par le code suivant, puis cliquez sur Save (Enregistrer).
exports.handler = (event, context, callback) => {
// Create a support case using the input as the case ID, then return a confirmation message
var myCaseID = event.inputCaseID;
var myMessage = "Case " + myCaseID + ": opened...";
var result = {Case: myCaseID, Message: myMessage};
callback(null, result);
};
i. Répétez les étapes 4b-4d pour créer 4 autres fonctions Lambda à l'aide du rôle IAM lambda_basic_execution créé à l'étape 4c.
Définissez AssignCaseFunction comme :
exports.handler = (event, context, callback) => {
// Assign the support case and update the status message
var myCaseID = event.Case;
var myMessage = event.Message + "assigned...";
var result = {Case: myCaseID, Message: myMessage};
callback(null, result);
};Définissez WorkOnCaseFunction comme :
exports.handler = (event, context, callback) => {
// Generate a random number to determine whether the support case has been resolved, then return that value along with the updated message.
var min = 0;
var max = 1;
var myCaseStatus = Math.floor(Math.random() * (max - min + 1)) + min;
var myCaseID = event.Case;
var myMessage = event.Message;
if (myCaseStatus == 1) {
// Support case has been resolved
myMessage = myMessage + "resolved...";
} else if (myCaseStatus == 0) {
// Support case is still open
myMessage = myMessage + "unresolved...";
}
var result = {Case: myCaseID, Status : myCaseStatus, Message: myMessage};
callback(null, result);
};Définissez CloseCaseFunction comme :
exports.handler = (event, context, callback) => {
// Close the support case
var myCaseStatus = event.Status;
var myCaseID = event.Case;
var myMessage = event.Message + "closed.";
var result = {Case: myCaseID, Status : myCaseStatus, Message: myMessage};
callback(null, result);
};Définissez EscalateCaseFunction comme :
exports.handler = (event, context, callback) => {
// Escalate the support case
var myCaseID = event.Case;
var myCaseStatus = event.Status;
var myMessage = event.Message + "escalating.";
var result = {Case: myCaseID, Status : myCaseStatus, Message: myMessage};
callback(null, result);
};Une fois terminé, vous devez avoir 5 fonctions Lambda.
Étape 5. Renseigner votre flux de travail
L'étape suivante consiste à renseigner les états de tâche dans votre flux de travail Step Functions avec les fonctions Lambda que vous venez de créer.
c. Dans la section State machine definition (Définition de la machine d'état), recherchez la ligne en dessous de l'état Open Case (Ouvrir une demande) qui commence par Resource.
Remplacez l'ARN par l'ARN de votre OpenCaseFunction.
Si vous cliquez sur l'exemple d'ARN, une liste des fonctions AWS Lambda dans votre compte apparaît et vous pouvez le sélectionner dans la liste.
d. Répétez l'étape précédente pour mettre à jour les ARN de la fonction Lambda pour les états de tâche Assign Case (Attribuer une demande), Work on Case (Résoudre la demande), Close Case (Fermer la demande) et Escalate Case (Faire remonter la demande) dans votre machine d'état, puis cliquez sur Save (Enregistrer).
Étape 6. Exécuter votre flux de travail
Votre flux de travail sans serveur est maintenant prêt à être exécuté. L'exécution d'une machine d'état est une instance de votre flux de travail et survient chaque fois qu'une machine d'état Step Functions est exécutée et effectue ses tâches. Chaque machine d'état Step Functions peut disposer de plusieurs exécutions simultanées que vous pouvez initier depuis la console Step Functions (ce que nous ferons ensuite) ou en utilisant les kits AWS SDK, les actions d'API Step Functions ou l'interface de ligne de commande AWS. Une exécution reçoit une entrée JSON et produit un résultat JSON.
b. Une boîte de dialogue New execution (Nouvelle exécution) apparaît. Pour fournir un ID pour votre dossier de support, entrez le contenu qui se trouve en-dessous de la boîte de dialogue New execution (Nouvelle exécution) dans la fenêtre Input (Entrée), puis cliquez sur Start execution (Démarrer l'exécution).
{
"inputCaseID": "001"
}
c. À mesure que votre flux de travail s'exécute, chaque étape changera de couleur dans le volet Visual workflow (Flux de travail visuel). Attendez quelques secondes pour que l'exécution se termine. Ensuite, dans le volet Execution details (Détails de l'exécution), cliquez sur Input (Entrée) et Output (Résultat) pour afficher les entrées et les résultats de votre flux de travail.
d. Step Functions vous permet d'inspecter chaque étape de l'exécution de votre flux de travail, y compris les entrées et les résultats de chaque état. Cliquez sur chaque tâche de votre flux de travail et développez les champs Input (Entrée) et Output (Résultat) sous Step details (Détails de l'étape). Vous constatez que l'ID de la demande que vous avez entré dans votre machine d'état est transmis d'une étape à l'autre et que les messages sont mis à jour à mesure que chaque fonction Lambda termine son travail.
f. Selon le résultat de votre WorkOnCaseFunction, votre flux de travail peut se terminer en résolvant la demande de support et en fermant le ticket, ou en faisant remonter le ticket vers le niveau suivant de support. Vous pouvez exécuter à nouveau l'exécution plusieurs fois pour observer ce comportement différent. Cette image montre une exécution du flux de travail où la demande de support a été remontée, entraînant le flux de travail à quitter avec un état Fail (Échec).
En situation réelle, vous pouvez décider de continuer à travailler sur la demande jusqu'à sa résolution au lieu d'abandonner votre flux de travail. Pour ce faire, vous pouvez supprimer l'état Fail (Échec) et modifier la tâche Escalate Case (Faire remonter la demande) dans votre machine d'état pour revenir à l'état Work On Case (Résoudre la demande). Aucune modification ne devra être apportée à vos fonctions Lambda. Les fonctions que nous créons pour ce didacticiel sont uniquement des exemples. Nous allons donc passer à l'étape suivante du didacticiel.
Étape 7. Résilier vos ressources
Dans cette étape, vous allez résilier vos ressources associées à AWS Step Functions et à AWS Lambda.
Important : il est conseillé de résilier les ressources qui ne sont pas activement utilisées afin de réduire les coûts. Des ressources non résiliées peuvent entraîner des frais.
b. Dans la fenêtre State machines (Machines d'état), sélectionnez CallCenterStateMachine et cliquez sur Delete (Supprimer). Pour confirmer que vous souhaitez supprimer la machine d'état, dans la boîte de dialogue qui apparaît, cliquez sur Delete state machine (Supprimer la machine d'état). Votre machine d'état sera supprimée dans une ou deux minutes, une fois que Step Functions a confirmé que toute exécution en cours était terminée.
Félicitations !
Beau travail ! Vous venez de créer un flux de travail sans serveur à l'aide d'AWS Step Functions qui déclenche plusieurs fonctions AWS Lambda. Votre flux de travail a coordonné toutes vos fonctions pour vous selon la logique que vous avez définie, et fait passer les données d'un état à l'autre, ce qui signifie que vous n'avez plus à écrire ce code dans chaque fonction individuelle.
Maintenant que vous avez appris à concevoir et à exécuter un flux de travail sans serveur, vous pouvez passer au didacticiel suivant où vous découvrirez comment utiliser Step Functions pour gérer les erreurs de fonctions Lambda. Vous créerez une machine d'état avec les champs Retry (Réessayer) et Catch (Attraper) qui répondent aux codes de réponse depuis une API fictive basée sur un type de message d'erreur, une méthode appelée gestion d'erreur de fonction.