Implémentez le modèle de saga sans serveur en utilisant AWS Step Functions

Créé par Tabby Ward (AWS), Rohan Mehta (AWS) et Rimpy Tewani () AWS

Récapitulatif

Dans une architecture de microservices, l'objectif principal est de créer des composants découplés et indépendants afin de promouvoir l'agilité, la flexibilité et d'accélérer la mise sur le marché de vos applications. Grâce au découplage, chaque composant de microservice possède sa propre couche de persistance des données. Dans une architecture distribuée, les transactions commerciales peuvent couvrir plusieurs microservices. Comme ces microservices ne peuvent pas utiliser une seule transaction d'atomicité, de cohérence, d'isolation, de durabilité (ACID), vous risquez de vous retrouver avec des transactions partielles. Dans ce cas, une certaine logique de contrôle est nécessaire pour annuler les transactions déjà traitées. Le modèle de saga distribué est généralement utilisé à cette fin. 

Le modèle saga est un modèle de gestion des défaillances qui permet d'établir la cohérence dans les applications distribuées et de coordonner les transactions entre plusieurs microservices afin de maintenir la cohérence des données. Lorsque vous utilisez le modèle saga, chaque service qui effectue une transaction publie un événement qui déclenche les services suivants pour effectuer la transaction suivante de la chaîne. Cela continue jusqu'à ce que la dernière transaction de la chaîne soit terminée. Si une transaction commerciale échoue, Saga orchestre une série de transactions compensatoires qui annulent les modifications apportées par les transactions précédentes.

Ce modèle montre comment automatiser la configuration et le déploiement d'un exemple d'application (qui gère les réservations de voyages) à l'aide de technologies sans serveur telles que AWS Step Functions, AWS Lambda et Amazon DynamoDB. L'exemple d'application utilise également Amazon API Gateway et Amazon Simple Notification Service (AmazonSNS) pour implémenter un coordinateur d'exécution de saga. Le modèle peut être déployé avec un framework d'infrastructure en tant que code (IaC) tel que le AWS Cloud Development Kit (AWSCDK), le AWS Serverless Application Model (AWSSAM) ou Terraform.

Pour plus d'informations sur le modèle saga et les autres modèles de persistance des données, consultez le guide Activer la persistance des données dans les microservices sur le site Web du guide AWS prescriptif.

Conditions préalables et limitations

Prérequis

Versions du produit

Limites

Le sourcing d'événements est un moyen naturel d'implémenter le modèle d'orchestration de la saga dans une architecture de microservices où tous les composants sont faiblement couplés et ne se connaissent pas directement les uns les autres. Si votre transaction comporte un petit nombre d'étapes (trois à cinq), le modèle de la saga pourrait convenir parfaitement. Cependant, la complexité augmente avec le nombre de microservices et le nombre d'étapes. 

Les tests et le débogage peuvent devenir difficiles lorsque vous utilisez cette conception, car tous les services doivent être exécutés pour simuler le modèle de transaction.

Architecture

Architecture cible

L'architecture proposée utilise AWS Step Functions pour créer un modèle de saga permettant de réserver des vols, de réserver des locations de voitures et de traiter les paiements pour des vacances.

Le schéma de flux de travail suivant illustre le flux typique du système de réservation de voyages. Le flux de travail consiste à réserver un voyage en avion (« ReserveFlight »), à réserver une voiture (« ReserveCarRental »), à traiter les paiements (« ProcessPayment »), à confirmer les réservations de vol (« ConfirmFlight ») et à confirmer la location de voiture (« ConfirmCarRental »), suivis d'une notification de réussite lorsque ces étapes sont terminées. Cependant, si le système rencontre des erreurs lors de l'exécution de l'une de ces transactions, il commence à échouer en arrière. Par exemple, une erreur dans le traitement du paiement (« ProcessPayment ») déclenche un remboursement (« RefundPayment »), qui déclenche ensuite l'annulation de la voiture de location et du vol (« CancelRentalReservation » et « CancelFlightReservation »), mettant fin à l'ensemble de la transaction avec un message d'échec.

Ce modèle déploie des fonctions Lambda distinctes pour chaque tâche mise en évidence dans le diagramme, ainsi que trois tables DynamoDB pour les vols, les locations de voitures et les paiements. Chaque fonction Lambda crée, met à jour ou supprime les lignes des tables DynamoDB respectives, selon qu'une transaction est confirmée ou annulée. Le modèle utilise Amazon SNS pour envoyer des messages texte (SMS) aux abonnés, les informant de l'échec ou de la réussite des transactions. 

Automatisation et évolutivité

Vous pouvez créer la configuration de cette architecture à l'aide de l'un des frameworks IaC. Utilisez l'un des liens suivants pour accéder à votre iAc préféré.

Outils

AWSservices

Code

Le code d'un exemple d'application illustrant le modèle Saga, y compris le modèle IaC (AWSCDKAWSSAM,, ou Terraform), les fonctions Lambda et les tables DynamoDB se trouve dans les liens suivants. Suivez les instructions du premier épisode pour les installer.

Épopées

npm install

npm run build

npm run watch

npm run test

cdk bootstrap
cdk deploy

sam build
sam deploy --guided

terraform init
terraform apply

cdk diff

sam deploy

terraform plan

cdk destroy

sam delete

terraform destroy

Ressources connexes

Papiers techniques

AWSdocumentation de service

Didacticiels

Informations supplémentaires

Code

À des fins de test, ce modèle déploie API Gateway et une fonction Lambda de test qui déclenche la machine d'état Step Functions. Avec Step Functions, vous pouvez contrôler les fonctionnalités du système de réservation de voyages en transmettant un run_type paramètre pour imiter les défaillances dans «ReserveFlight, » «ReserveCarRental, » «ProcessPayment, » «ConfirmFlight, » et « »ConfirmCarRental.

La fonction saga Lambda (sagaLambda.ts) prend en compte les paramètres de requête de la API passerelleURL, crée l'JSONobjet suivant et le transmet à Step Functions pour exécution :

let input = {
"trip_id": tripID, //  value taken from query parameter, default is AWS request ID
"depart_city": "Detroit",
"depart_time": "2021-07-07T06:00:00.000Z",
"arrive_city": "Frankfurt",
"arrive_time": "2021-07-09T08:00:00.000Z",
"rental": "BMW",
"rental_from": "2021-07-09T00:00:00.000Z",
"rental_to": "2021-07-17T00:00:00.000Z",
"run_type": runType // value taken from query parameter, default is "success"
};

Vous pouvez expérimenter différents flux de la machine à états Step Functions en transmettant les URL paramètres suivants :

Modèles iAc

Les référentiels liés incluent des modèles IaC que vous pouvez utiliser pour créer l'intégralité de l'exemple d'application de réservation de voyages.

Tables DynamoDB

Voici les modèles de données pour les vols, les locations de voitures et les tableaux de paiements.

Flight Data Model:
 var params = {
      TableName: process.env.TABLE_NAME,
      Item: {
        'pk' : {S: event.trip_id},
        'sk' : {S: flightReservationID},
        'trip_id' : {S: event.trip_id},
        'id': {S: flightReservationID},
        'depart_city' : {S: event.depart_city},
        'depart_time': {S: event.depart_time},
        'arrive_city': {S: event.arrive_city},
        'arrive_time': {S: event.arrive_time},
        'transaction_status': {S: 'pending'}
      }
    };

Car Rental Data Model:
var params = {
      TableName: process.env.TABLE_NAME,
      Item: {
        'pk' : {S: event.trip_id},
        'sk' : {S: carRentalReservationID},
        'trip_id' : {S: event.trip_id},
        'id': {S: carRentalReservationID},
        'rental': {S: event.rental},
        'rental_from': {S: event.rental_from},
        'rental_to': {S: event.rental_to},
        'transaction_status': {S: 'pending'}
      }
    };

Payment Data Model:
var params = {
      TableName: process.env.TABLE_NAME,
      Item: {
        'pk' : {S: event.trip_id},
        'sk' : {S: paymentID},
        'trip_id' : {S: event.trip_id},
        'id': {S: paymentID},
        'amount': {S: "750.00"}, // hard coded for simplicity as implementing any monetary transaction functionality is beyond the scope of this pattern
        'currency': {S: "USD"},
        'transaction_status': {S: "confirmed"}
      }
    };

Fonctions Lambda

Les fonctions suivantes seront créées pour prendre en charge le flux et l'exécution de la machine à états dans Step Functions :

Amazon SNS

L'exemple d'application crée le sujet et l'abonnement suivants pour envoyer SMS des messages et informer le client de la réussite ou de l'échec des réservations. Si vous souhaitez recevoir des SMS pendant que vous testez l'exemple d'application, mettez à jour l'SMSabonnement avec votre numéro de téléphone valide dans le fichier de définition de la machine d'état.

AWSCDKextrait (ajoutez le numéro de téléphone dans la deuxième ligne du code suivant) :

const topic = new  sns.Topic(this, 'Topic');
topic.addSubscription(new subscriptions.SmsSubscription('+11111111111'));
const snsNotificationFailure = new tasks.SnsPublish(this ,'SendingSMSFailure', {
topic:topic,
integrationPattern: sfn.IntegrationPattern.REQUEST_RESPONSE,
message: sfn.TaskInput.fromText('Your Travel Reservation Failed'),
});
 
const snsNotificationSuccess = new tasks.SnsPublish(this ,'SendingSMSSuccess', {
topic:topic,
integrationPattern: sfn.IntegrationPattern.REQUEST_RESPONSE,
message: sfn.TaskInput.fromText('Your Travel Reservation is Successful'),
});

AWSSAMextrait (remplacez les +1111111111 chaînes par votre numéro de téléphone valide) :

  StateMachineTopic11111111111:
    Type: 'AWS::SNS::Subscription'
    Properties:
      Protocol: sms
      TopicArn:
        Ref: StateMachineTopic
      Endpoint: '+11111111111'
    Metadata:
      'aws:sam:path': SamServerlessSagaStack/StateMachine/Topic/+11111111111/Resource

Extrait de code Terraform (remplacez la +111111111 chaîne par votre numéro de téléphone valide) :

resource "aws_sns_topic_subscription" "sms-target" {
  topic_arn = aws_sns_topic.topic.arn
  protocol  = "sms"
  endpoint  = "+11111111111"
}

Réservations réussies

Le flux suivant illustre une réservation réussie avec «ReserveFlight, » «ReserveCarRental, » et « ProcessPayment » suivis de « ConfirmFlight » et « »ConfirmCarRental. Le client est informé de la réussite de la réservation par le biais de SMS messages envoyés à l'abonné du SNS sujet.

Réservations échouées

Ce flux est un exemple d'échec dans le schéma de la saga. Si, après avoir réservé des vols et des locations de voitures, « ProcessPayment » échoue, les étapes sont annulées dans l'ordre inverse.  Les réservations sont annulées et le client est informé de l'échec par le biais de SMS messages envoyés à l'abonné du SNS sujet.