Guided Exercise - Principles of Microservices (With Twelve Factor Addendum) - Online Bookstore System

[akash-coded]

This exercise will be scenario-based, leveraging only Spring Boot concepts, JPA with an H2 database, Rest Template, Feign Client, SLF4J with Logback for logging, and Spring Actuator. The exercise is designed to be complex yet understandable and should take a learner a day or more to complete.

Scenario: Online Bookstore System

Overview:

You are tasked with developing an Online Bookstore System using a microservice architecture. The system will consist of several independent microservices communicating with each other.

Services:

1. Book Service: Manages book inventory.
2. Order Service: Handles customer orders.
3. User Service: Manages user information.
4. Review Service: Handles book reviews and ratings.

Exercise Objectives:

• Understand and implement the eight principles of microservice architecture.
• Develop each service as an independent Spring Boot application.
• Use JPA with an H2 database for data persistence.
• Employ Rest Template and Feign Client for inter-service communication.
• Implement SLF4J with Logback for logging.
• Utilize Spring Actuator for monitoring.

Principles & Tasks:

1. Single Responsibility: Each microservice (Book, Order, User, Review) must have a single responsibility and operate independently.

2. Loose Coupling: Services should be loosely coupled. Implement APIs for communication between services using Rest Template and Feign Client.

3. Service Autonomy: Ensure each service is autonomous and can operate independently of others.

4. Service Discoverability: Implement API documentation using Swagger for easy discoverability.

5. Scalability: Design each service to handle varying loads, demonstrating horizontal scaling.

6. Fault Tolerance: Handle failures gracefully. Implement basic fallback methods in Feign Clients.

7. Data Isolation: Each service should have its own database schema in H2.

8. Evolutionary Design: Design your microservices to be open for extension but closed for modification.

Implementation Steps:

1. Setup Basic Structure:

   • Create separate Spring Boot projects for each service.
   • Configure JPA and H2 database for each service.

2. Define Models and Repositories:

   • Model your entities (e.g., Book, Order, User, Review) and create repositories for each service.

3. Create Service APIs:

   • Develop RESTful endpoints for each service.
   • Implement business logic in services.

4. Inter-Service Communication:

   • Use Rest Template and Feign Client for communication between services.

5. Logging and Monitoring:

   • Implement logging in each service using SLF4J and Logback.
   • Use Spring Actuator for health checks and metrics.

6. API Documentation:

   • Integrate Swagger for documenting your APIs.

7. Testing:

   • Write unit and integration tests for each service.

8. Execution and Observation:

   • Run the services together and test the complete system.
   • Observe the interaction, fault tolerance, and logging.

Deliverables:

• Source code for each service.
• API documentation.
• Test cases and results.
• A report documenting your observations on how each principle was implemented and its impact.

This exercise provides a hands-on experience with the core principles of microservice architecture using Spring Boot, promoting a deep understanding of the subject.

---

Continuing with the elaboration on each principle of microservice architecture, I'll explain what each principle is, why it's important for our Online Bookstore System, how to implement it, and the benefits and drawbacks. At the end, I'll highlight how all these principles work together.

1. Single Responsibility

• What it is: Each microservice should have a single, well-defined responsibility.
• Implementation in App: In our Online Bookstore, each service (Book, Order, User, Review) focuses on a specific function.
• Benefits: Simplifies the design, development, and maintenance of each service.
• Drawbacks: Over-segmentation can lead to too many microservices, increasing complexity.
• Why it's used: Ensures clarity in service functionality and boundaries.

2. Loose Coupling

• What it is: Services should be independent with minimal dependencies on each other.
• Implementation in App: Use Rest Template and Feign Client for loosely coupled communication.
• Benefits: Changes in one service have minimal impact on others, easier scaling and maintenance.
• Drawbacks: Can lead to duplication of effort and data consistency challenges.
• Why it's used: Increases flexibility and resilience of the system.

3. Service Autonomy

• What it is: Each service is independent and self-contained.
• Implementation in App: Services operate and can be deployed independently.
• Benefits: Improves fault tolerance and allows for independent scaling and development.
• Drawbacks: Complexity in managing multiple independent services.
• Why it's used: Enhances system stability and agility.

4. Service Discoverability

• What it is: Services should be easily discoverable and accessible.
• Implementation in App: Use Swagger for documenting APIs for easy discoverability.
• Benefits: Enhances developer productivity and service usability.
• Drawbacks: Requires additional effort to maintain documentation.
• Why it's used: Facilitates easier integration and use of services.

5. Scalability

• What it is: Ability to handle increased load by scaling resources.
• Implementation in App: Design services for horizontal scaling to handle varying loads.
• Benefits: System can accommodate growth and peak demands.
• Drawbacks: Can be cost-intensive and requires efficient load balancing.
• Why it's used: Ensures system performance under varying loads.

6. Fault Tolerance

• What it is: The system’s ability to continue operating even when parts fail.
• Implementation in App: Implement fallback methods in Feign Clients for graceful degradation.
• Benefits: Enhances system reliability and user experience during partial failures.
• Drawbacks: Adds complexity in implementation and testing.
• Why it's used: Essential for maintaining service availability.

7. Data Isolation

• What it is: Each service manages its own database and data model.
• Implementation in App: Separate H2 database schemas for each service.
• Benefits: Prevents data conflicts and promotes data security.
• Drawbacks: Data management complexity and challenges in data aggregation.
• Why it's used: Protects integrity and confidentiality of data.

8. Evolutionary Design

• What it is: Designing systems to accommodate changes and extensions over time.
• Implementation in App: Design services to be open for extension but closed for modification.
• Benefits: Makes the system adaptable and future-proof.
• Drawbacks: May require more initial planning and abstract thinking.
• Why it's used: Addresses the changing needs and technologies.

Integrating the Principles:

• Synergy: These principles, when implemented together, create a robust, scalable, and maintainable microservice architecture.
• Balanced Approach: Each principle complements the others, balancing flexibility, independence, and interconnectedness.
• Result: The Online Bookstore System becomes a cohesive yet flexible system that is adaptable to change, easy to maintain, and resilient to failures.

In conclusion, each principle plays a critical role in the architecture of the Online Bookstore System. While they each have their benefits and drawbacks, together they form a harmonious and efficient microservice ecosystem, showcasing the power of a well-structured microservice architecture.

---

Below are step-by-step instructions, including hints, code snippets, repository structure, dependencies, and configurations for each service.

General Setup

Repository Structure

• Root Directory: OnlineBookstore
  • BookService
  • OrderService
  • UserService
  • ReviewService

Common Dependencies (for all services)

Include these in your pom.xml (for Maven) or build.gradle (for Gradle):

• Spring Boot Starter Web
• Spring Boot Starter Data JPA
• H2 Database
• Spring Boot Starter Actuator
• OpenFeign (for Feign Client)
• SLF4J with Logback (for logging)
• Springfox Swagger 2 (for API documentation)

Application Properties

• Configure application.properties for each service with appropriate server port, database configurations, and logging settings.

Book Service

Tasks & Hints

1. Entity & Repository: Create Book entity and repository.
2. REST Controller: Expose CRUD operations via a REST controller.
3. Logging: Implement logging for each method.

Code Snippet

@RestController
@RequestMapping("/books")
public class BookController {
    // Autowire repository and add methods for CRUD operations
}

Order Service

Tasks & Hints

1. Entity & Repository: Create Order entity and repository.
2. REST Controller: Expose endpoints to place and track orders.
3. Inter-Service Communication: Use Feign Client to interact with Book Service for book details.

Code Snippet

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

User Service

Tasks & Hints

1. Entity & Repository: Create User entity and repository.
2. REST Controller: Expose endpoints for user management.
3. Data Validation: Implement validation for user data.

Code Snippet

@Entity
public class User {
    // User attributes with validation annotations
}

Review Service

Tasks & Hints

1. Entity & Repository: Create Review entity and repository.
2. REST Controller: Expose endpoints for posting and reading reviews.
3. Inter-Service Communication: Use RestTemplate to interact with Book Service.

Code Snippet

@Autowired
private RestTemplate restTemplate;

public Book getBook(Long bookId) {
    return restTemplate.getForObject("http://book-service/books/" + bookId, Book.class);
}

Common Configurations

Logging (logback.xml)

• Configure logback.xml for logging format and levels.

Swagger Configuration

• Implement Swagger configuration in each service for API documentation.

Building and Running

• Use Maven or Gradle to build each service.
• Run each service independently.
• Test inter-service communication.

Additional Hints

• Version Control: Use Git for version control, creating branches for each major change.
• Testing: Write unit tests for each service, focusing on service functionality and data layer.
• Error Handling: Implement global exception handling in each service.
• Performance Tuning: Monitor performance using Spring Actuator and tune accordingly.

Conclusion

Following these steps will give you a hands-on experience in building a microservice architecture using Spring Boot. Each service should be developed and tested individually before integrating them to form the complete system. Remember, the key is to understand the principles behind each task and how they contribute to a robust microservice architecture.

[arulsudarvizhi1]

Hi Akash,

Please find below the completion status:

1. book service - Complete with API to check availability and update inventory count, retrieve all book details, create
2. Order servcie - View all orders, create order of book by calling update book inventory [Code done, feign client post call giving an issue debugging the same. Earlier hands on was with feign client get which worked but post call giving issue] / Issue with post input for restTemplate too need to find the solution
3. Other services in progress

Microservice_Principles.zip

Enhancing the above code for circuit breaker pattern. Circuit breaker to be tested yet. Using this section to upload intermediate code version
circuitbreaker.zip

[samik2023]

Hi Akash,

I have sent you the link to repo for the 4 microservices. The junit test is added for Order service only. Rest of the features have been added in all other microservices.

The swagger endpoints are:
http://localhost:8081/swagger-ui/index.html
http://localhost:8082/swagger-ui/index.html
http://localhost:8083/swagger-ui/index.html
http://localhost:8084/swagger-ui/index.html

Regards
Samik

[bijumedayil]

onlinestore.zip

Implemented with Swagger and Log Stash , Bok http://localhost:8081/swagger-ui/index.html
Order : http://localhost:8082/swagger-ui/index.html
User : http://localhost:8083/swagger-ui/index.html
Review :http://localhost:8084/swagger-ui/index.html

[akash-coded]

Expanding the Online Bookstore System exercise to include the Twelve-Factor App methodology provides a comprehensive framework for building scalable and maintainable applications. Below is an explanation of each factor, its importance for the Online Bookstore System, implementation strategies, benefits, drawbacks, and how they integrate with the principles of microservice architecture.

1. Codebase

• What it is: One codebase tracked in version control with many deploys.
• Importance: Ensures consistency across different deployment environments.
• Implementation: Use Git for version control. Have separate branches for development, testing, and production.
• Benefits: Streamlines development and deployment processes.
• Drawbacks: Requires strict version control practices.
• Integration with Principles: Complements the evolutionary design principle.

2. Dependencies

• What it is: Explicitly declare and isolate dependencies.
• Importance: Prevents conflicts and ensures consistency across environments.
• Implementation: Use Maven or Gradle for dependency management in each service.
• Benefits: Simplifies dependency management and app deployment.
• Drawbacks: Requires careful management of dependencies.
• Integration with Principles: Aligns with service autonomy.

3. Config

• What it is: Store config in the environment.
• Importance: Separates config from code for security and flexibility.
• Implementation: Use environment variables or a config server for sensitive and environment-specific configurations.
• Benefits: Enhances security and application portability.
• Drawbacks: Additional management of environment-specific configurations.
• Integration with Principles: Supports scalability and fault tolerance.

4. Backing Services

• What it is: Treat backing services as attached resources.
• Importance: Ensures flexibility and interchangeability of services.
• Implementation: Use H2 database in development and a production-grade database in production. Abstract database access.
• Benefits: Makes it easy to swap out services without code changes.
• Drawbacks: Requires a well-designed service abstraction layer.
• Integration with Principles: Ties in with loose coupling.

5. Build, Release, Run

• What it is: Strictly separate build, release, and run stages.
• Importance: Provides control and traceability in the deployment process.
• Implementation: Use CI/CD pipelines for automated build, release, and deployment processes.
• Benefits: Streamlines and automates application deployments.
• Drawbacks: Complexity in setting up and maintaining CI/CD pipelines.
• Integration with Principles: Complements service autonomy and evolutionary design.

6. Processes

• What it is: Execute the app as one or more stateless processes.
• Importance: Ensures reliability and scalability.
• Implementation: Design each microservice to be stateless and scalable.
• Benefits: Improves fault tolerance and horizontal scalability.
• Drawbacks: Challenges with stateful features like sessions.
• Integration with Principles: Aligns with the scalability principle.

7. Port Binding

• What it is: Export services via port binding.
• Importance: Enables services to become self-contained.
• Implementation: Each microservice should have its own server port.
• Benefits: Enhances service independence and scalability.
• Drawbacks: Managing multiple ports across services.
• Integration with Principles: Supports service autonomy.

8. Concurrency

• What it is: Scale out via the process model.
• Importance: Facilitates handling increased load efficiently.
• Implementation: Use Spring Boot’s embedded server to manage service instances.
• Benefits: Improved load handling and resilience.
• Drawbacks: Increased resource consumption.
• Integration with Principles: Essential for scalability and fault tolerance.

9. Disposability

• What it is: Maximize robustness with fast startup and graceful shutdown.
• Importance: Enhances system resilience and availability.
• Implementation: Implement health checks and graceful shutdown procedures in Spring Boot applications.
• Benefits: Quick recovery from crashes and smooth deployment.
• Drawbacks: Requires careful handling of in-flight transactions.
• Integration with Principles: Ties in with fault tolerance.

10. Dev/Prod Parity

• What it is: Keep development, staging, and production as similar as possible.
• Importance: Minimizes deployment issues and bugs.
• Implementation: Use Docker containers to maintain consistency across environments.
• Benefits: Reduces the "works on my machine" problem.
• Drawbacks: Overhead in managing containerized environments.
• Integration with Principles: Complements evolutionary design.

11. Logs

• What it is: Treat logs as event streams.
• Importance: Simplifies monitoring and debugging.
• Implementation: Implement centralized logging using SLF4J and external log management tools.
• Benefits: Easier tracking of issues across services.
• Drawbacks: Complexity in setting up and maintaining log aggregation.
• Integration with Principles: Enhances service discoverability and fault tolerance.

12. Admin Processes

• What it is: Run admin/management tasks as one-off processes.
• Importance: Provides a structured way to execute administrative tasks.
• Implementation: Use Spring Boot’s Actuator endpoints for management tasks.
• Benefits: Simplifies execution of maintenance operations.
• Drawbacks: Requires secure access control.
• Integration with Principles: Supports service autonomy.

Integration with Microservice Principles

• Complementary Relationship: The Twelve-Factor App methodology complements the principles of microservice architecture by providing a practical framework for building and deploying services.
• Enhanced Robustness and Flexibility: By following both sets of guidelines, the Online Bookstore System becomes more robust, scalable, maintainable, and flexible.
• Holistic Approach: Combining these methodologies offers a holistic approach to building modern, cloud-native applications that are well-suited for the evolving needs of businesses and technologies.

Implementing the Twelve-Factor App methodology alongside the principles of microservice architecture in the Online Bookstore System exercise provides a comprehensive learning experience, illustrating best practices in modern application development.

---

To transform the integration of the Twelve-Factor App methodology with the principles of microservice architecture into a structured exercise for the Online Bookstore System, we'll outline specific tasks and provide implementation guidelines for each factor. This exercise will help in gaining hands-on experience and a deeper understanding of building scalable and resilient microservices.

Exercise Outline

Task 1: Implement Codebase Factor

• Objective: Set up a version-controlled codebase for your microservices.
• Implementation:
  • Initialize a Git repository for each service.
  • Create separate branches for development, testing, and production.

Task 2: Manage Dependencies

• Objective: Explicitly declare and isolate dependencies.
• Implementation:
  • Use Maven or Gradle files to manage dependencies.
  • Ensure that no dependencies are system-wide.

Task 3: Configuration Management

• Objective: Externalize configuration from the code.
• Implementation:
  • Store configuration data like database URLs and credentials in environment variables.
  • Access these configurations in your application through Spring’s @Value annotation.

Task 4: Backing Services as Resources

• Objective: Treat all backing services as attached resources.
• Implementation:
  • Use Spring profiles to switch between different database instances (H2 for dev and another for prod).
  • Ensure that switching databases does not require changes in the codebase.

Task 5: Separate Build, Release, Run

• Objective: Clearly separate the build, release, and run stages.
• Implementation:
  • Set up a CI/CD pipeline.
  • Ensure that once a build is created, it does not change at the release and run stages.

Task 6: Stateless Processes

• Objective: Build stateless applications.
• Implementation:
  • Ensure your services do not rely on in-memory state.
  • Store session data externally if needed.

Task 7: Port Binding

• Objective: Expose services through port binding.
• Implementation:
  • Use Spring Boot’s embedded server for your services.
  • Each service should run on its own port.

Task 8: Concurrency Through Process Model

• Objective: Scale out your application via the process model.
• Implementation:
  • Design your services so that they can be scaled horizontally by running multiple instances.

Task 9: Fast Startup and Graceful Shutdown

• Objective: Ensure your application can be started quickly and shut down gracefully.
• Implementation:
  • Optimize initialization code for quick startup.
  • Implement graceful shutdown to handle in-flight requests when stopping the service.

Task 10: Dev/Prod Parity

• Objective: Keep development, staging, and production environments as similar as possible.
• Implementation:
  • Use Docker to containerize your services.
  • Ensure that all environments use the same versions of external services.

Task 11: Logs as Event Streams

• Objective: Treat logs as event streams.
• Implementation:
  • Use a logging framework like Logback.
  • Stream logs to a central logging service like ELK or Splunk.

Task 12: Admin Processes as Jobs

• Objective: Run admin/management tasks as one-off processes.
• Implementation:
  • Create scripts for database migration, batch jobs, etc., and run them separately from the main application.

Integration with Microservice Principles

• Task: Integrate the Twelve-Factor App methodology with the principles of microservice architecture.
• Implementation:
  • As you work through each task, reflect on how it aligns with the microservice principles like single responsibility, loose coupling, service autonomy, etc.
  • Document your observations on how each factor enhances or challenges these principles.

Conclusion

This exercise is designed to provide practical experience in implementing the Twelve-Factor App methodology in a microservice architecture. The tasks will guide you through each factor, helping you understand their application and impact on a real-world project like the Online Bookstore System. This comprehensive approach ensures a well-rounded learning experience in modern software architecture and development practices.

[HarshDPandya]

Hi @akash-coded , Sharing my code in zip file for Guided Exercise - Principles of Microservices (With Twelve Factor Addendum) with Logback and Actuator
Name: Harsh Pandya
microservice-ecommerce-with-logback-actuator-HarshPandya-2066481.zip