Learn Microservices with Spring Boot – Real Project Course

Explore the theory and principles of microservices and compare advantages and drawbacks with other architectures. Learn to implement, deploy, secure, and monitor microservices using a monitoring system.

Explore monolithic, service oriented or SOA, event driven or Ada, and microservices architectures for web applications, comparing their characteristics, advantages, and disadvantages; note serverless architecture and AWS Lambda for learning.

Explore monolithic architecture, where the user interface, backend, and database form a single unit. Learn how this design offers simplicity and performance but poses maintainability and scalability challenges.

SOA architecture uses reusable services as lego blocks to build enterprise applications like a website, a mobile app, and an internal system. It enables reuse but introduces complexity.

Explore event-driven architecture, where components communicate via events and commands, subscribe to streams, and process events asynchronously, gaining low coupling and reactivity while managing event complexity.

Microservices are small, independently running services that communicate via lightweight protocols. In an e-commerce app, user, product, order, and payment services show modularity and scalable communication.

Master the characteristics of microservices, including modularity, independence, polyglot architecture, and own databases with lightweight communication. Automate deployment and scaling with containers and Kubernetes to improve resilience and maintainability.

Explore the advantages of microservices, including flexibility, rapid deployment, resilience, scalability, and autonomous teams, and examine the drawbacks such as increased complexity, data management challenges, and deployment overhead.

Deploy microservices with containerization and orchestration to ensure reliability, availability, and scalability, using Docker, Kubernetes, and automated CI/CD pipelines.

Learn to monitor microservices with Prometheus, Grafana, Jaeger, Zipkin, ELK stack, and Datadog to ensure performance, health, tracing, and centralized logs across infrastructure.

Explore how Spring Boot simplifies configuration and startup for Java applications, letting you focus on business logic while leveraging Spring ecosystem and modules like dependency management, security, and data management.

Explore Spring Boot's auto configuration that adapts to your dependencies, its production-ready monitoring and metrics, and its self-sufficient, embedded server deployment via java -jar.

Utilize spring boot for microservices to build independent, lightweight services that deploy easily to containers and cloud platforms, and scale efficiently through dynamic configuration, service discovery, and security vulnerability management.

Create a Spring Boot project with Initializr, selecting Maven, Java, and Spring Boot 3.2.7, configure group and artifact, add Web, Mongo, Lombok, then import generated project into your IDE.

Automatically configures spring boot apps by detecting classpath dependencies and setting up components like embedded tomcat, spring mvc, and h2 data sources with jpa entities and repositories.

Spring Boot starters simplify dependency configuration by bundling web-related libraries into a single starter, enabling auto configuration with an embedded Tomcat server and reducing setup time and errors.

Learn how Spring Boot binds properties from application.properties to a configuration bean using a prefix, enables this with @EnableConfigurationProperties, and shows how pojo configs like MongoDB and PostgreSQL organize connections.

Discover how Spring Boot profiles separate configurations for dev and prod, load environment-specific properties, and activate profiles at startup to switch between H2 and MySQL.

Explore how Spring Boot embeds servers inside the application, using Tomcat, Jetty, Undertow, and Netty for traditional web apps and reactive spring flux, with Tomcat default on port 8080.

Explore Spring Boot actuator for microservices, exposing endpoints for health, info, metrics, logs, and Prometheus metrics, all without interrupting the running app.

Consolidate your Spring Boot knowledge by reviewing the remaining theory, then explore official resources—Spring Boot website, Spring Guide, tutorials, GitHub, and Spring initializer—to deepen understanding.

Explore the theory behind Spring Cloud and its integration with Spring Boot, and discover service discovery, centralized configuration, and API gateway for distributed microservices.

Learn the main components of Spring Cloud, including Spring Cloud Config, Eureka service discovery, Spring Cloud Gateway for routing, Hystrix resilience, and Spring Cloud Stream for event management.

Centralize configuration in a microservices setup using Spring Cloud Config. Understand how the config server and client retrieve from git, databases, or other storage, and update without restarts.

Explore Eureka's service discovery in a Spring Cloud Netflix microservices setup, where services register with the Eureka server to enable automatic discovery and communication.

Learn to enable inter-service communication with Openfeint in a Spring Boot microservice architecture, using declarative clients, json serialization, and Eureka service discovery between the user and offer services.

Explore Spring Cloud Gateway as an API gateway for routing to microservices using predicates and filters, enabling centralized security, API management, rate limiting, and request tracing.

Analyze the Operis case study requirements, compare the advantages and disadvantages of monolithic versus microservices architectures, and design the best solution for the project.

Summarize Opry's case study as a web app for managing projects with a freemium model, featuring accounts, profiles, projects, members, tasks, task assignments, and exporting project summaries.

Assess the monolithic architecture for a real project, showing single project simplicity and easier debugging, but slower builds, longer startup times, and limited horizontal scaling.

Assess whether a microservices architecture fits operas by breaking the system into autonomous services, including user accounts, tasks, members or user profiles, projects, exports as paid features, and subscription management.

Identify application domains for microservices by asking five key questions about responsibility, autonomy, independence, complexity, and scaling. This framework guides analysis of domain candidates in upcoming sessions.

Analyze the user accounts domain to define its security responsibilities, including account creation, login and permissions, assess autonomy, and envision evolution toward oauth2 as a dedicated microservice.

Explore the user profiles domain, covering creation, modification, and deletion of profiles with first and last names, and its autonomous, email-linked evolution with hr integrations and no heavy scaling.

Analyze the tasks domain in a microservices context, covering creation, modification, deletion, project linkage, member assignment, status management, and scalability considerations for independent vs shared services.

Analyze how a dedicated projects domain handles creation, modification, deletion, and member assignment, while depending on tasks and members for autonomy.

Analyze grouping projects and tasks into a single application domain, detailing its functional responsibilities, autonomy, and scaling needs for tasks in a real-world microservice context.

Export domain manages project and task data exports in CSV, including progress and status. It can evolve to charts and detailed reports while exports remain gated by premium subscriptions.

Analyze the subscriptions domain as the autonomous microservice handling freemium and premium transitions. Link it to user accounts and support multiple subscription types, promotions, and discounts.

Microservices offer better separation of responsibilities, flexibility, scalability, and maintainability, despite added deployment and management complexity. Each service can evolve independently, optimizing resources and reducing costs when demand rises.

Define four business microservices: user account, user profiles, projects, and subscriptions, and group related domains to simplify architecture while defining boundaries, with a premium subscription enabling project exports.

Introduce an API gateway to centralize security and route requests from clients to the appropriate microservices, reducing the need for consumers to know each service URL.

Learn how service discovery lets microservices locate each other using Spring Cloud Eureka, with a server and client to register services and fetch connection info for export and subscriptions.

Centralize and modify microservice configurations on the fly with spring cloud config service, reducing redeploys across dev, staging, and production.

Configure a load balancer to distribute requests across multiple microservice instances using round robin and spring cloud load balancer with Eureka service discovery for exports.

Explore data modeling and design for the project domain by identifying key entities and their relationships, including user accounts, profiles, projects, tasks, subscriptions, and exports.

Explore the user account domain, its role in authentication and logins, and the user account entity with id, email, password (hashed), created at, and updated at.

Model the user profiles domain separate from user accounts, capturing personal information such as id, first name, last name, birth date, and email, linked to the accounts domain.

Explore the projects data model, detailing the project, task, and task status history entities, their attributes and relationships, and how they support project management, task tracking, and progress accountability.

Explore the subscription domain in Operis, highlighting the premium plan that exports a project summary. Model the subscription and user subscription entities, with id, name, description, benefits, and user linkage.

Set up a microservice architecture with Spring Boot, establish a parent Maven module, and implement an API gateway, service management, service discovery, central config, and load balancing for media microservices.

Set up a complete development environment for Spring Boot microservices, using IntelliJ or Eclipse, Java 22, Git, Maven, Docker Compose, and Postman for testing APIs.

Create a parent Maven pom for the Operis monorepo, centralizing dependencies and plugins for all microservice submodules with the Spring Boot starter parent, in a public GitHub repository.

Explore hexagonal and multi-layer architectures and modular layers, including presentation, service, and data access layers. Assess advantages like modularity, maintainability, and testability, and drawbacks like coupling and flexibility for microservices.

Implement the operis-project microservice in a hexagonal architecture by adding two submodules: operis project core for domain logic and operis project service for adapters and APIs, within a monorepo.

Implement the project creation use case in a spring boot microservice using hexagonal architecture, wiring domain, ports, adapters, a REST API with DTOs, payloads, and JWT-based authorization.

Learn to implement robust API error handling for the project creation endpoint with a custom API error format, Spring rest controller advice, and detailed validation messaging.

Implement unit and integration tests for a Spring Boot microservice, validating domain rules, wiring mocks with Mockito, and testing controllers with Web MVC and H2 plus parameterized tests.

Set up a MySQL database with Docker Compose, run the Opolis project microservice, and validate the create project API with Postman, including name validation via the Isvalid annotation.

Explore hexagonal architecture, or ports and adapters, to decouple the business core from external technologies, enhance testability and maintainability, and accommodate evolving databases and APIs in microservices.

Document a project creation API with OpenAPI Swagger, detailing endpoints, payloads, responses, and errors for clear cross-team use. Demonstrate JWT authentication in Swagger and test interactively.

Learn to set up a Spring Boot discovery service with a Eureka server, create the operas discovery module under the opus parent, and verify the running service.

Learn how to enable service discovery with Eureka by registering the operis-project service and fetching the registry, enabling the gateway to locate and call other microservices like subscriptions.

Configure a spring cloud gateway in a new operas gateway module, wire in Eureka client settings, and establish port 8080 to route requests to microservices.

Configure the api gateway to route requests to the Operis project service through Eureka, using load balancer resolution and route predicates, with a gateway header for monitoring.

Create the openrisc config server module with spring cloud config server and Eureka client to centralize configurations, configure main class and application.yml (port 8888, git repo), and verify Eureka registration.

Learn to centralize and externalize the configurations of the project service and gateway with Spring Cloud Config stored in a Git repository, using service discovery for resilient config access.

Explore containerization of Spring Boot microservices with Docker and Docker Compose, build Docker images via Maven, and orchestrate four microservices on a shared network with actuator health checks.

Review crucial code areas not covered in depth. Examine security, inter service communication, load balancing, and traceability across the operate gateway, operate, discovery, and operate config microservices.

Explore opera microservices, notably opera project, using hexagonal and layered architectures with ports, adapters, and payloads. Learn about validations, 201 status for create, 404 not found, and testing and monitoring.

Learn how feign client streamlines calls between microservices using Eureka for service discovery and spring boot, including enabling feign clients and calling a user profile service.

Scale a microservice by load balancing between two user profile service instances, using Feign client with Spring Cloud Load Balancer and Eureka for routing.

Track a user request across microservices with a correlation ID generated at the gateway and propagated via HTTP headers to enable logs and debugging.

Improve request traceability in a microservices architecture by implementing filters that log incoming requests and feign client calls, leveraging correlation id-based tracing for debugging and monitoring.

Learn to secure apis through the api gateway by implementing a jwt token filter, updating the Spring Security context, and enforcing role-based access on endpoints.

Import the Postman json file, authenticate with a jwt bearer token, configure header inheritance, and perform basic project and subscription operations against the gateway at localhost 8080.

Wrap up your microservices journey with Spring Boot and apply concrete tools to your projects. Thank collaborators and put the lessons into practice in your projects.