Implemente o padrão de saga sem servidor usando Step Functions AWS

Criado por Tabby Ward (AWS), Rohan Mehta () e Rimpy Tewani (AWS) AWS

Resumo

Em uma arquitetura de microsserviços, o objetivo principal é criar componentes desacoplados e independentes para promover agilidade, flexibilidade e menor tempo de comercialização de seus aplicativos. Como resultado do desacoplamento, cada componente de microsserviço tem sua própria camada de persistência de dados. Em uma arquitetura distribuída, as transações comerciais podem abranger vários microsserviços. Como esses microsserviços não podem usar uma única transação de atomicidade, consistência, isolamento e durabilidade (ACID), você pode acabar com transações parciais. Nesse caso, alguma lógica de controle é necessária para desfazer as transações que já foram processadas. O padrão de saga distribuída é normalmente usado para essa finalidade. 

O padrão saga é um padrão de gerenciamento de falhas que ajuda a estabelecer a consistência em aplicativos distribuídos e coordena as transações entre vários microsserviços para manter a consistência de dados. Quando você usa o padrão de saga, cada serviço que realiza uma transação publica um evento que aciona serviços subsequentes para realizar a próxima transação na cadeia. Isso continua até que a última transação na cadeia seja concluída. Se uma transação comercial falhar, a saga orquestra uma série de transações compensatórias que desfazem as alterações feitas pelas transações anteriores.

Esse padrão demonstra como automatizar a configuração e a implantação de um aplicativo de amostra (que lida com reservas de viagens) com tecnologias sem servidor, como Step AWS Functions, Lambda AWS e Amazon DynamoDB. O aplicativo de amostra também usa o Amazon API Gateway e o Amazon Simple Notification Service (AmazonSNS) para implementar um coordenador de execução da saga. O padrão pode ser implantado com uma estrutura de infraestrutura como código (IaC), como o AWS Cloud Development Kit (AWSCDK), o AWS Serverless Application Model (AWSSAM) ou o Terraform.

Para obter mais informações sobre o padrão da saga e outros padrões de persistência de dados, consulte o guia Habilitando a persistência de dados em microsserviços no site Prescriptive Guidance. AWS

Pré-requisitos e limitações

Pré-requisitos

Versões do produto

Limitações

O fornecimento de eventos é uma forma natural de implementar o padrão de orquestração da saga em uma arquitetura de microsserviços em que todos os componentes estão com acoplamento fraco e não têm conhecimento direto uns dos outros. Se sua transação envolver um pequeno número de etapas (três a cinco), o padrão da saga pode ser uma ótima opção. No entanto, a complexidade aumenta com o número de microsserviços e o número de etapas. 

Testar e depurar podem se tornar difíceis quando você usa esse design, porque você precisa ter todos os serviços em execução para simular o padrão da transação.

Arquitetura

Arquitetura de destino

A arquitetura proposta usa AWS Step Functions para criar um padrão de saga para reservar voos, reservar aluguéis de carros e processar pagamentos de férias.

O diagrama de fluxo de trabalho a seguir ilustra o fluxo típico do sistema de reserva de viagens. O fluxo de trabalho consiste em reservar viagens aéreas (“ReserveFlight”), reservar um carro (“ReserveCarRental”), processar pagamentos (“ProcessPayment”), confirmar reservas de voos (“ConfirmFlight”) e confirmar aluguéis de carros (“”), seguido por uma notificação de sucesso quando essas etapas forem concluídas. ConfirmCarRental No entanto, se o sistema encontrar algum erro na execução de qualquer uma dessas transações, ele começará a falhar para trás. Por exemplo, um erro no processamento do pagamento (“ProcessPayment”) aciona um reembolso (“RefundPayment”), que então aciona o cancelamento do carro e do voo alugados (“CancelRentalReservation” e “CancelFlightReservation”), o que encerra toda a transação com uma mensagem de falha.

Esse padrão implanta funções do Lambda separadas para cada tarefa destacada no diagrama, bem como três tabelas do DynamoDB para voos, aluguel de carros e pagamentos. Cada função do Lambda cria, atualiza ou exclui as linhas nas respectivas tabelas do DynamoDB, dependendo se uma transação é confirmada ou revertida. O padrão usa SNS a Amazon para enviar mensagens de texto (SMS) aos assinantes, notificando-os sobre transações malsucedidas ou malsucedidas. 

Automação e escala

Você pode criar a configuração para essa arquitetura usando uma das estruturas do IaC. Para se conectar no IaC de sua preferência, use um dos links a seguir.

Ferramentas

AWSserviços

Código

O código de um aplicativo de amostra que demonstra o padrão da saga, incluindo o modelo IaC (,, ou Terraform) AWS CDK AWSSAM, as funções Lambda e as tabelas do DynamoDB, pode ser encontrado nos links a seguir. Siga as instruções no primeiro épico para instalá-los.

Épicos

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

Recursos relacionados

Artigos técnicos

AWSdocumentação de serviço

Tutoriais

Mais informações

Código

Para fins de teste, esse padrão implanta o API Gateway e uma função Lambda de teste que aciona a máquina de estado Step Functions. Com o Step Functions, você pode controlar a funcionalidade do sistema de reserva de viagens passando um run_type parâmetro para simular falhas em “ReserveFlight,” “ReserveCarRental,” “ProcessPayment,” “ConfirmFlight,” e “”ConfirmCarRental.

A função saga Lambda (sagaLambda.ts) recebe a entrada dos parâmetros de consulta no API GatewayURL, cria o seguinte JSON objeto e o passa para Step Functions para execução:

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"
};

Você pode experimentar diferentes fluxos da máquina de estado Step Functions passando os seguintes URL parâmetros:

Modelos IaC

Os repositórios vinculados incluem modelos de IaC que você pode usar para criar toda a amostra do aplicativo de reserva de viagens.

Tabelas do DynamoDB

Aqui estão os modelos de dados para as tabelas de voos, aluguéis de carros e pagamentos.

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"}
      }
    };

Funções do Lambda

As seguintes funções serão criadas para suportar o fluxo e a execução da máquina de estado no Step Functions:

Amazon SNS

O aplicativo de amostra cria o tópico e a assinatura a seguir para enviar SMS mensagens e notificar o cliente sobre reservas bem-sucedidas ou malsucedidas. Se você quiser receber mensagens de texto enquanto testa o aplicativo de amostra, atualize a SMS assinatura com seu número de telefone válido no arquivo de definição da máquina de estado.

AWSCDKtrecho (adicione o número de telefone na segunda linha do código a seguir):

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'),
});

AWSSAMtrecho (substitua as +1111111111 sequências pelo seu número de telefone válido):

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

Trecho do Terraform (substitua a string +111111111 pelo seu número de telefone válido):

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

Reservas bem-sucedidas

O fluxo a seguir ilustra uma reserva bem-sucedida com “ReserveFlight,” “ReserveCarRental,” e “ProcessPayment” seguidos por “ConfirmFlight” e “”ConfirmCarRental. O cliente é notificado sobre a reserva bem-sucedida por meio de SMS mensagens enviadas ao assinante do SNS tópico.

Reservas malsucedidas

Esse fluxo é um exemplo de falha no padrão da saga. Se, após a reserva de voos e aluguel de carros, “ProcessPayment” falhar, as etapas serão canceladas na ordem inversa.  As reservas são liberadas e o cliente é notificado da falha por meio de SMS mensagens que são enviadas ao assinante do SNS tópico.