Migrating Spring Boot Monolithic API to Spring Microservices App

[akash-coded]

Refer to discussion #153 for context

1. Service Discovery: Incorporate tools like Eureka Server. Each microservice will then be a Eureka client. It helps in dynamic discovery without hardcoding service URLs.

2. Centralized Configuration: Integrate Spring Cloud Config server. Store configurations of all services in a central place.

3. Resilience and Latency: Use Hystrix or Resilience4J for circuit breaking. When one service fails or is slow, you can provide fallbacks.

4. API Gateway: Instead of direct communication between client and services, introduce an API Gateway (like Zuul) that routes requests to appropriate services.

5. Tracing and Logging: Use tools like Sleuth and Zipkin for distributed tracing. Centralize logs with the ELK stack.

6. Data Consistency: Add mechanisms for eventual consistency. For instance, when an author is deleted, ensure that related books are also addressed (either deleted or updated). This is where patterns like Saga can play a role.

7. Testing: Focus on writing unit tests with Mocks and integration tests for service interaction.

8. Continuous Deployment/Integration: Incorporate Jenkins or GitHub Actions to automate the deployment of services.

---

By breaking the monolithic application into microservices and incorporating the above-mentioned tools, you will not only understand the intricacies of microservice architecture but will also appreciate the advantages (and challenges) it brings in terms of scalability, maintainability, and resilience.

Advanced Stuff

Let's delve into more advanced configurations and considerations.

Advanced Considerations for Microservices Architecture:

4. Event-driven Communication:

Instead of directly calling another service, services can produce events that other services listen to. This can be achieved using a lightweight event broker.

4.1. Implementation:

You could use Spring Cloud Stream which abstracts event-driven communication. For the scope of this exercise, we can simplify by just setting up an in-memory event mechanism.

Add this to the pom.xml:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-stream</artifactId>
</dependency>

In book-service:

@EnableBinding(Source.class)
public class BookEventProducer {

    @Autowired
    private Source source;

    public void bookCreated(Book book) {
        source.output().send(MessageBuilder.withPayload(book).build());
    }
}

In borrowing-service:

@EnableBinding(Sink.class)
public class BookEventListener {

    @StreamListener(Sink.INPUT)
    public void handleBookCreated(Book book) {
        // Business logic when a book is created.
    }
}

5. API Versioning:

Over time, your microservices will evolve, and so will their APIs. It's essential to handle different API versions.

5.1. Implementation:

For simplicity, we can use URI versioning. For example:

/v1/books
/v2/books

In BookController.java:

@RestController
@RequestMapping("/v1/books")
public class BookControllerV1 {
    ...
}

@RestController
@RequestMapping("/v2/books")
public class BookControllerV2 {
    ...
}

6. Monitoring & Health Checks:

Services need regular health checks to ensure they're up and running.

6.1. Implementation:

Spring Boot Actuator provides health checks out-of-the-box:

Add to pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Configure in application.properties:

management.endpoints.web.exposure.include=*

Now, accessing /actuator/health will show the health status of the service.

7. Advanced Error Handling:

You can handle errors gracefully using @ControllerAdvice.

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(BookNotFoundException.class)
    public ResponseEntity<String> handleBookNotFoundException(BookNotFoundException e) {
        return new ResponseEntity<>(e.getMessage(), HttpStatus.NOT_FOUND);
    }
    
    ...
}

8. Securing Microservices:

Although this would be a more advanced topic, services should be secure. You can use Spring Security with OAuth2 for securing services.

For brevity, remember:

• Always use HTTPS.
• Authenticate services if they need to communicate.
• Authorize what each service, or user, can do.

Recap:

By following these steps, you'll create a comprehensive microservices architecture using Spring Boot. Your application will be modular, scalable, maintainable, and resilient. Breaking down a monolithic application and integrating these elements would provide an enriching learning experience for the learners, giving them both the depth and breadth of understanding microservices in a practical environment.

Let's continue our journey into the Microservices realm, diving deeper into further complexities and nuances, expanding on the scenario provided.

9. Inter-Service Communication:

In a microservices architecture, services often need to communicate with one another.

9.1. Implementation:

You can use Feign as an HTTP client to talk to other services:

Add to the pom.xml of the services that need to communicate with others:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

Activate Feign Clients in the Application:

@EnableFeignClients
@SpringBootApplication
public class Application {
    ...
}

Now, to call another service:

@FeignClient("book-service")
public interface BookClient {
    @GetMapping("/books/{id}")
    Book getBookById(@PathVariable("id") Long id);
}

10. Circuit Breaking with Hystrix:

In a distributed system, if a service fails, it might bring down other services with it. Use Hystrix to add fault tolerance.

10.1. Implementation:

Add this dependency:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

And, use the @EnableCircuitBreaker annotation in the main application class.

For Feign client:

@FeignClient("book-service")
public interface BookClient {
    @GetMapping("/books/{id}")
    @HystrixCommand(fallbackMethod = "defaultBook")
    Book getBookById(@PathVariable("id") Long id);

    default Book defaultBook(Long id) {
        return new Book("Default Book", "Default Author");
    }
}

11. Configuration Management with Spring Cloud Config:

You might want to externalize the configuration in a distributed system.

11.1. Implementation:

Add the Config Server dependency:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
</dependency>

Use @EnableConfigServer in the main class.

The application.properties of the config server should have:

spring.cloud.config.server.git.uri=YOUR_GIT_REPO_URL
server.port=8888

On the client side (all microservices), add:

spring.config.import=configserver:http://localhost:8888

Now, your microservices will fetch their configuration from the centralized server.

12. Tracing with Spring Cloud Sleuth:

In a distributed system, tracing requests can be challenging.

12.1. Implementation:

Include the Sleuth dependency:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>

That's it! Sleuth will automatically trace requests across your services.

For detailed logging, integrate it with Zipkin.

13. Service Discovery with Eureka:

Microservices need to know the network locations of other services.

13.1. Implementation:

Set up a Eureka server by adding the dependency:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

And use @EnableEurekaServer in the main class.

For the clients (all your microservices):

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

Include in application.properties:

eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

Now, your services will register with Eureka and discover other services through it.

Recap:

These steps provide a robust foundation in understanding and implementing microservices using Spring Boot and Spring Cloud. The learners, equipped with these skills and knowledge, will be empowered to design, build, and maintain scalable and resilient applications.

Alright, let's delve further into more advanced features and tools that make the microservices architecture more resilient, efficient, and scalable.

14. API Gateway with Zuul:

As we discussed earlier, an API Gateway is an essential component in a microservices architecture. Here, we'll see how to set up Zuul as the API Gateway.

14.1. Implementation:

To use Zuul, add the following dependency:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>

Then, enable Zuul with @EnableZuulProxy in the main class.

application.properties configuration:

zuul.routes.book-service.path=/book-api/**
zuul.routes.book-service.url=http://book-service-host:port

This reroutes any request with the prefix /book-api to the book-service.

15. Centralized Configuration with Consul:

While we discussed Spring Cloud Config earlier, Consul is another powerful tool for centralized configuration and service discovery.

15.1. Implementation:

Add the Consul dependency:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-consul-config</artifactId>
</dependency>

application.properties:

spring.cloud.consul.host=YOUR_CONSUL_HOST
spring.cloud.consul.port=8500

16. Distributed Tracing with Zipkin and Sleuth:

While Sleuth helps with tracing, Zipkin visualizes those traces.

16.1. Implementation:

Add the dependencies:

<!-- Sleuth -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>
<!-- Zipkin -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zipkin</artifactId>
</dependency>

application.properties:

spring.zipkin.baseUrl=http://ZIPKIN_SERVER_URL:9411/
spring.sleuth.sampler.probability=1.0

17. Rate Limiting with Zuul and Redis:

To prevent misuse of your APIs, you might want to rate-limit your clients.

17.1. Implementation:

Add Zuul and Redis dependencies:

<!-- Zuul -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>
<!-- Redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

application.properties:

zuul.ratelimit.enabled=true
zuul.ratelimit.repository=REDIS
spring.redis.host=YOUR_REDIS_HOST

Define the rate limits:

zuul.ratelimit.policy-list.book-service.limit=1000
zuul.ratelimit.policy-list.book-service.refresh-interval=60

This configuration will allow 1000 requests per minute for the book-service.

Reflection:

What we've done here is built on top of a basic microservices setup and introduced advanced tools and methodologies to make the system more resilient, efficient, and user-friendly. Each component plays a vital role in ensuring the microservices ecosystem functions smoothly, is easy to monitor, and can be scaled efficiently.

18. Circuit Breaker Pattern with Hystrix:

In a microservices architecture, it's essential to handle failures gracefully. Hystrix is a circuit breaker library from Netflix that helps prevent cascading failures in distributed systems.

18.1. Implementation:

To integrate Hystrix, add the dependency:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

Now, annotate your Spring Boot application class with @EnableCircuitBreaker.

Here's a simple method implementation using Hystrix:

@HystrixCommand(fallbackMethod = "fallbackMethodName")
public String someServiceMethod() {
    // ... call other services
}

public String fallbackMethodName() {
    return "Fallback response";
}

If someServiceMethod fails to respond, Hystrix will redirect the call to fallbackMethodName.

19. Service Discovery with Eureka:

Service discovery allows microservices to discover and communicate with each other. Eureka is a service discovery tool.

19.1. Implementation:

Add the Eureka server dependency:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

In your main Spring Boot application class, annotate it with @EnableEurekaServer.

In application.properties:

eureka.client.registerWithEureka=false
eureka.client.fetchRegistry=false

For client-side service registration:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

In application.properties for the client:

eureka.client.serviceUrl.defaultZone=http://EUREKA_HOST:8761/eureka/

20. Load Balancing with Ribbon:

Ribbon is a client-side load balancer which gives control over HTTP and TCP clients.

20.1. Implementation:

When you use the Eureka discovery with Spring Cloud, Ribbon is automatically included. No need for an extra dependency.

Use Ribbon:

@Autowired
private LoadBalancerClient loadBalancer;

public void doStuff() {
    ServiceInstance instance = loadBalancer.choose("some-service-id");
    URI serviceUri = URI.create(String.format("http://%s:%s", instance.getHost(), instance.getPort()));
    // ... do something with the URI
}

Reflection:

While diving deep into microservices with Spring Boot, it's vital to notice that while we add functionality, the complexity also rises. But each tool and pattern addresses a real-world problem in microservices:

• Hystrix ensures one service failure doesn't bring down other dependent services.
• Eureka allows smooth inter-service communication.
• Ribbon provides load balancing to distribute traffic and prevent overloading a single service instance.

For the developers, remember, it's not about using all these tools; it's about understanding their purpose and applying them judiciously. Always relate to real-world problems, like how Netflix uses Hystrix to ensure users always get recommendations, even if the primary recommendation service fails, a fallback provides generic recommendations. Understanding the "why" behind each tool is as crucial as the "how."

[jay4tech]

Hi @akash-coded
Name: Jay Prakash Kumar [2075419]

https://github.com/jay4tech/author-service
https://github.com/jay4tech/book-service
https://github.com/jay4tech/borrowing-service

[AnuragMishra58]

Hi @akash-coded
Name: Anurag Mishra
Emp Id: 550966
Find below event management assignment for book to be deleted after return
library-management-event-driven.zip

[aathira-ps]

session4_AathiraPS.zip

[zafvirinchi]

author-service.zip
book-service.zip
borrowing-service.zip
Hi @akash-coded Please find the attached project for 31st Aug 2023 it was left
Name:- Zafrul Islam
TCS Id:- 1974878