easylearn.ing
Easy Learning with Learn Spring Modulith: Monolith to Microservices Seamlessly
Development > Software Engineering
15.5 h
£34.99 Free for 3 days
4.6 ★★★★★
6926 students

Enroll Now

Language: English

Sale Ends: 20 Jan

Master Spring Modulith: Microservices from Monolith Architecture

What you will learn:

  • Build modular Spring applications with Spring Modulith.
  • Migrate from monolithic to microservices architecture seamlessly.
  • Master Spring Events for efficient inter-module communication.
  • Utilize Spring Data JPA for database mirroring.
  • Implement robust exception handling and validation.
  • Create and manage CI/CD pipelines with Git Actions.
  • Containerize applications using Docker (three different approaches).
  • Deploy and manage applications on Kubernetes.
  • Optimize performance with GraalVM native images.
  • Write effective integration tests for modular applications.
  • Document your Modulith application effectively.
  • Leverage Spring Boot Starter Docker Compose for efficient development.

Description

Transform your monolithic application into a robust microservices architecture with ease! This comprehensive course provides a hands-on, step-by-step guide to mastering Spring Modulith.

Learn to modularize your Spring Boot 3 application, effectively separating concerns and paving the way for seamless microservices transition. We'll cover best practices for entity decomposition, leveraging Spring Data JPA for efficient database mirroring, and harnessing Spring Events for inter-module communication.

Dive deep into practical techniques for managing events, including strategies for handling successful and failed events. Discover how to build custom solutions for retrieving, retrying, and monitoring event processing. You will learn to create a custom class incorporating a scheduler to automatically rerun failed events and create exposed APIs for manual triggering.

This course extends beyond core Modulith principles; we will explore essential DevOps practices, including containerization with Docker (three different techniques covered!), CI/CD pipeline implementation using Git Actions, and efficient Kubernetes deployment. You'll gain proficiency with PostgresDB, custom exception handling, and validation techniques.

Further enhance your application’s performance and deployment efficiency by learning about Modulith metrics, implementing Java records, and effectively utilizing Spring Boot Starter Docker Compose for development and integration testing. We conclude by demonstrating the creation of native images using GraalVM for enhanced performance and optimizing your deployment workflow to Kubernetes.

Curriculum

Modulith Fundamentals

This introductory section sets the stage, comparing monolithic and microservices architectures. You'll get a clear overview of the project we'll build and explore the course resources. We then delve into setting up the project with the necessary Maven dependencies, focusing on the crucial `spring-boot-starter-docker-compose` and the core Modulith dependency.

Entity Modeling and Data Management

Here, we define our entities, addressing considerations for data modeling in a modular environment. The section covers two main entities, and explores restricting repository access levels. We also implement robust prepopulation of initial inventory data which forms the basis of the application's functionality.

Module Integration Testing

Thorough integration testing ensures seamless communication between your application modules. This section will walk you through building comprehensive integration tests demonstrating successful communication and interactions between modules.

Implementing Services and Named Interfaces

You will learn to design robust and maintainable services through the use of named interfaces. This section provides a practical hands-on experience in building an order service as an example and will cover the design and implementation of a well-structured service, showing you how to implement the service in stages, showcasing different aspects such as event handling and data access.

Mastering Spring Events and Listeners

This section delves into the heart of inter-module communication with Spring Events. We'll cover event publishing, handling both successful and failed events, and building a mechanism to retry failed events. We also explain techniques for handling events such as using a scheduler (cronjob) and exposed APIs for manual triggering of failed events and creating a mirrored database table for event tracking. We will also be creating integration tests for events.

Payment and Email Processing

This section expands on event handling by incorporating listeners for payment processing and email notifications. Learn how to integrate external services, manage asynchronous operations, and ensure reliable event delivery. The implementation will build on previous event handling knowledge, introducing a real-world application scenario.

Exception Handling and Validation

Robust error handling is crucial. This section teaches you how to implement custom exceptions and validation rules to maintain data integrity and improve application stability. We’ll cover strategies for handling various error conditions and providing informative error messages.

Modulith Documentation

Well-documented code is essential for maintainability and collaboration. This section guides you through using the Spring Modulith Documenter to generate comprehensive documentation for your modular application.

Production Deployment: Docker, Kubernetes, and GraalVM

This section covers deployment best practices, from containerization with Docker (exploring three different techniques) to Kubernetes deployment. We'll also explore externalized properties, testing, and the use of the Spring Boot Actuator. Finally, we'll leverage GraalVM to build native images, significantly improving application performance and deployment efficiency, and deploying the Native image to Kubernetes.

CI/CD Pipeline with Git Actions

This section walks you through creating a complete CI/CD pipeline using Git Actions. You'll learn how to automate your build, test, and deployment processes, ensuring efficient and reliable releases. We will explore variables and secrets, handling build errors, and managing artifacts throughout the deployment process.

Kubernetes Deep Dive

This section provides a comprehensive guide to deploying your application on Kubernetes. You’ll learn how to set up your environment, manage namespaces, create deployments, and utilize services to ensure your application's scalability and resilience. We'll explore different deployment strategies, manage resources, and troubleshoot common issues.

GraalVM Native Image Optimization

This section focuses on leveraging GraalVM to create native images, resulting in improved startup times and reduced memory footprint. Learn how to set up GraalVM, configure your project, and optimize your application for native execution. This will also cover testing the native image and deploying it to Kubernetes.

Course Conclusion

This final section summarizes the key concepts covered throughout the course and congratulates you on completing the learning journey. It provides a roadmap for further exploration and continued development in this exciting area.

Deal Source: real.discount