Practise Exercise - Microservices - Saga Pattern - Implementing the Saga Pattern in E-commerce Platform

[akash-coded]

Let's create a simple yet meaningful exercise to help learners understand the Saga pattern using a simplified e-commerce platform consisting of an Order Service and a Payment Service.

Scenario:
Imagine a user wants to buy a product. They place an order, and the system should then check if there's stock, reserve the stock, make a payment, and then finalize the order. If any step fails, appropriate compensating actions should be taken.

Exercise: Implementing the Saga Pattern in E-commerce Platform

1. Set Up:

1. Create two new Spring Boot projects using the Spring Initializer: OrderService and PaymentService.
2. Add the necessary dependencies (Web, JPA, H2, RabbitMQ, Cloud Stream) to each project.

2. Define the Domains:

• OrderService:

  • Order entity with attributes: id, productId, userId, status (PLACED, PAID, FAILED).
  • OrderRepository to interact with the database.

• PaymentService:

  • Payment entity with attributes: id, orderId, status (PENDING, COMPLETED, FAILED).
  • PaymentRepository to handle database interactions.

3. Implement the Saga Workflow:

1. A user places an order in OrderService.
2. OrderService checks stock and reserves the product.
3. OrderService sends a message (event) to PaymentService to initiate payment.
4. PaymentService tries to process the payment.
5. If payment is successful, PaymentService sends a success message back to OrderService.
6. If payment fails, PaymentService sends a failure message to OrderService.

4. Implementing the Messaging:

• Set up RabbitMQ (or any messaging service) and configure Spring Cloud Stream bindings for both services.
• OrderService should listen for payment success and failure events.
• PaymentService should listen for order placement events.

5. Handle Compensating Transactions:

1. If PaymentService receives a failure event:

• Mark the related order as FAILED.
• Release the reserved stock.
• Notify the user of the failure.

2. If PaymentService processes payment successfully:

• Mark the related payment as COMPLETED.
• Send a success event to OrderService.

6. Testing:

1. Test a successful order and payment flow.
2. Intentionally make the payment fail (e.g., insufficient funds) and observe if the compensating transactions in OrderService work correctly.

Tips:

• Use @StreamListener in Spring Cloud Stream to handle incoming messages.
• Keep the business logic simple for this exercise. For instance, the payment can be a dummy logic that randomly fails or succeeds.
• Remember, the aim is to ensure data consistency across services without using 2PC (two-phase commit).

Further Enhancements:

1. Introduce a StockService to manage product stock. Extend the saga to communicate with this service too.
2. Add exception handling and edge case handling.
3. Incorporate user notifications using email or SMS when an order is successful or fails.

This exercise gives a basic yet comprehensive understanding of the Saga pattern.

Hints/Tips:

1. Set Up:

Dependencies:

Use the Spring Initializer to generate the basic projects. Ensure you include the following dependencies for both services:

• Spring Web
• Spring Data JPA
• H2 Database
• Spring Cloud Stream
• RabbitMQ binder (or Kafka if you prefer)

2. Application Properties:

For both OrderService and PaymentService, in src/main/resources/application.properties:

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

Note: Install RabbitMQ locally or use Docker.

3. Define the Domains:

• OrderService:

  Order Entity

  @Entity
  public class Order {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private Long id;
      private Long productId;
      private Long userId;
      private String status; // Consider using an Enum here
  
      // Getter, setters, and constructors
  }

  OrderRepository

  @Repository
  public interface OrderRepository extends JpaRepository<Order, Long> {}

• PaymentService:

  Payment Entity

  @Entity
  public class Payment {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private Long id;
      private Long orderId;
      private String status; // Consider using an Enum here
  
      // Getter, setters, and constructors
  }

  PaymentRepository

  @Repository
  public interface PaymentRepository extends JpaRepository<Payment, Long> {}

4. Implement the Saga Workflow:

For simplification, you can use the synchronous HTTP request-response model.

5. Other Points to Note:

• To set up RestTemplate bean, add the following to your main @SpringBootApplication class:

  @Bean
  public RestTemplate restTemplate(RestTemplateBuilder builder) {
      return builder.build();
  }

• It might be beneficial to use service discovery like Eureka in a more complex scenario, so services can discover each other rather than hardcoding URLs.

• The above steps demonstrate a simple, synchronous saga. In a real-world scenario, using events and asynchronous communication is more resilient and scalable.

• Make sure RabbitMQ is running. If you're using Docker, the command might be: docker run -d --name rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:management.

• Use the H2 console to verify data at http://localhost:<port>/h2-console.

[akash-coded]

1. Set Up:

Dependencies:

Use the Spring Initializer to generate the basic projects. Ensure you include the following dependencies for both services:

• Spring Web
• Spring Data JPA
• H2 Database
• Spring Cloud Stream
• RabbitMQ binder (or Kafka if you prefer)

2. Application Properties:

For both OrderService and PaymentService, in src/main/resources/application.properties:

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

Note: Install RabbitMQ locally or use Docker.

3. Define the Domains:

• OrderService:

  Order Entity

  @Entity
  public class Order {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private Long id;
      private Long productId;
      private Long userId;
      private String status; // Consider using an Enum here
  
      // Getter, setters, and constructors
  }

  OrderRepository

  @Repository
  public interface OrderRepository extends JpaRepository<Order, Long> {}

• PaymentService:

  Payment Entity

  @Entity
  public class Payment {
      @Id
      @GeneratedValue(strategy = GenerationType.IDENTITY)
      private Long id;
      private Long orderId;
      private String status; // Consider using an Enum here
  
      // Getter, setters, and constructors
  }

  PaymentRepository

  @Repository
  public interface PaymentRepository extends JpaRepository<Payment, Long> {}

4. Implement the Saga Workflow:

For simplification, you can use the synchronous HTTP request-response model.

OrderService:

@RestController
@RequestMapping("/orders")
public class OrderController {

    @Autowired
    private OrderRepository orderRepository;
    @Autowired
    private RestTemplate restTemplate; // Ensure you've this bean created

    @PostMapping
    public ResponseEntity<String> placeOrder(@RequestBody Order order) {
        order.setStatus("PLACED");
        orderRepository.save(order);
        
        // Communicate with the PaymentService
        String paymentResult = restTemplate.postForObject("http://localhost:8081/payments", order.getId(), String.class);

        if ("SUCCESS".equals(paymentResult)) {
            order.setStatus("PAID");
            orderRepository.save(order);
            return ResponseEntity.ok("Order placed and payment processed successfully!");
        } else {
            order.setStatus("FAILED");
            orderRepository.save(order);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Payment processing failed.");
        }
    }
}

PaymentService:

@RestController
@RequestMapping("/payments")
public class PaymentController {

    @Autowired
    private PaymentRepository paymentRepository;

    @PostMapping
    public ResponseEntity<String> processPayment(@RequestBody Long orderId) {
        Payment payment = new Payment();
        payment.setOrderId(orderId);
        
        // Dummy logic to simulate payment processing
        if (new Random().nextBoolean()) {  // Randomly succeeds or fails
            payment.setStatus("COMPLETED");
            paymentRepository.save(payment);
            return ResponseEntity.ok("SUCCESS");
        } else {
            payment.setStatus("FAILED");
            paymentRepository.save(payment);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("FAILED");
        }
    }
}

5. Handle Compensating Transactions:

This is primarily handled in the OrderService by checking the response of the PaymentService.

6. Testing:

To test, run both services. Use Postman or any API testing tool to place an order via the OrderService and see if the PaymentService processes the payment. Note that the payment might randomly fail or succeed due to the dummy logic.

Hints/Tips:

• To set up RestTemplate bean, add the following to your main @SpringBootApplication class:

  @Bean
  public RestTemplate restTemplate(RestTemplateBuilder builder) {
      return builder.build();
  }

• It might be beneficial to use service discovery like Eureka in a more complex scenario, so services can discover each other rather than hardcoding URLs.

• The above steps demonstrate a simple, synchronous saga. In a real-world scenario, using events and asynchronous communication is more resilient and scalable.

• Make sure RabbitMQ is running. If you're using Docker, the command might be: docker run -d --name rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:management.

• Use the H2 console to verify data at http://localhost:<port>/h2-console.

This exercise provides a practical, hands-on understanding of the Saga pattern with Spring Boot, even for beginners. After grasping this, learners can explore more advanced saga implementations using event-driven architectures.

[jay4tech]

Hi @akash-coded

Name: Jay Prakash Kumar

Implemented SAGA Pattren using event-driven messaging architecture with RabbitMQ in order and payment service. Payment status will be updated whenever a new order gets placed. If payment is not found order status will updated to failed.

Here are the repositories -
https://github.com/jay4tech/order-service-saga
https://github.com/jay4tech/payment-service-saga

[Prasadpoojary]

Hi
SAGA Pattern.
Name : Prasad
SAGA Pattern.zip

Thanks

[Rajashree-Ravi]

Hi @akash-coded

Please find below the implementation for Saga pattern

ecommerce-microservice-saga-pattern.zip

[shriramram]

Hi @akash-coded
Description - Saga pattern implementation
Microservices Saga Pattern.zip

[arulsudarvizhi1]

Hi Akash ( @akash-coded ),

Please find the code base attached for saga pattern - Coreography approach
order-service ( 8084 port) http://localhost:8084/order , payment-service (8082) http://localhost:8082/payment
If payment fails (simulated if payment amount >1000 explicit exception thrown) reverse order will happen. Implemented using kafka based event driven approach
saga_pattern.zip

Saga orchestration pattern:

1. orderservice --> orderorch -->payment queue --> orderorch --> updateinventory queue
   if payment fail --> orderOrch --> reverse orderservice
   Code Implementation done.

saga_pattern_orch.zip

CQRS Pattern:
Hi @akash-coded ,
Please find attached the CQRS implementation: Dev complete and testing done:

1. order-queryservice : findAll, FindById [Read APIs], Kafka queue to listen event to create order]
2. order-service : Only for creation no read based APIs. for each create updates the queue in query service to sync the data
   cqrs_pattern.zip

Placeholder code for capstone. To avoid losing of code done, storing it in temporary location once completed to be updated in 149 / lms

capstone_hotel_reservation_system.zip

Name: Arul
Batch: Nov 7 to Dec 6 7.30 am batch

[samik2023]

Hi Akash,

Here are the two repos,
https://github.com/samik2023/saga-order-service
https://github.com/samik2023/saga-payment-service

Order service URL as below:
http://localhost:8081/swagger-ui/index.html

Regards
Samik (TCS morning 7.30 Nov 7th batch)

[misriya-git]

Hi Akash,

Please find the choreography codebase below for 151:
Misriya-151.zip
http://localhost:8082/swagger-ui/index.html (Order Service)
http://localhost:8081/swagger-ui/index.html (Payment Service)

The Orchestrator code base is:
Misriya-151-Saga-Orchestrator.zip
http://localhost:8081/swagger-ui/index.html (Payment Service)
http://localhost:8082/swagger-ui/index.html (Order Service)
http://localhost:8083/swagger-ui/index.html (Shipment Service)
http://localhost:8084/swagger-ui/index.html (Order Fulfillment Service - as the Orchestrator for the above three services using Kafka)

Thanks,
Misriya

[sowmyagardas]

Hi Akash,
I have implemented saga choreography pattern. Please check.

saga_pattern_choreography_1.zip

Thanks,
Sowmya.

[HarshDPandya]

Hi @akash-coded , Sharing my code in zip file for Practise Exercise - Microservices - Saga Pattern - Implementing the Saga Pattern in E-commerce Platform

Name: Harsh Pandya
TCS Emp Id: 2066481
microservice-ecommerce-saga-pattern-HarshPandya-2066481.zip

[Aditi-12092024]

Hi Akash,
Please find implementation of saga choreography pattern.

SAGA.zip
Thanks
Aditi Sharma