Microservices with Spring Boot, Spring Cloud, Docker, K8s

Spring Boot is an abstraction layer on top of the Spring Framework that provides auto-configuration, reducing the need for extensive configuration and letting developers focus on business logic.

Learn how dependency injection in spring applies inversion of control to let the framework manage bean creation and injection, reducing manual object handling and garbage collection.

Use spring initializr to create a spring boot maven project in java, select packaging jar and dependencies like spring web, and learn to generate, explore, and share the url.

Install and open the IntelliJ IDEA community edition, open the downloaded Spring Boot project, install dependencies, and run the app on embedded Tomcat port 8880 to verify locally.

Create a hello world REST endpoint in Spring Boot by building a HomeController class in IntelliJ, using @Controller, @ResponseBody, and @RequestMapping on the root path to return hello world.

Explore embedded servers in Springboard, switching from default Tomcat to Jetty or Undertow, and configure server.port in application properties; learn dependency management with Maven Helper to refine Tomcat exclusions.

Explore how the Spring Boot actuator monitors Spring Boot apps by adding the actuator dependency, exposing endpoints under /actuator, including health, and configuring security to enable or restrict access.

Define web services, explain how they work, and introduce restful web services to lay the foundation for building numerous restful apis in this course.

Enhance the hello world service by creating a user object with id, name, and email, returning it as JSON at /user using get mapping.

Define mandatory path variables in Spring Boot routes, map dynamic segments with @PathVariable, support multiple path variables, and rename captured values to method parameters.

Explore how to use path variables and request parameters in Spring Boot endpoints, including mandatory versus optional data, default values, and query parameter handling.

Create an employee resource with a rest controller, a service interface and implementation, and an in-memory store; implement a post endpoint to save employees and generate IDs.

Create a custom employee not found exception and throw it when data is missing, then use a controller advice to return a 404 with status and message.

Implement a delete API in the employee controller to remove an employee by id, using a delete mapping, service method, and list removal with path variable.

Content negotiation lets a Spring Boot REST API return JSON or XML based on a media type parameter, defaulting to JSON, with a global WebConfig and Jackson XML dependency.

Learn how to filter data in rest APIs using JSON ignore annotations to hide fields like department during serialization, and apply class-level JSON ignore properties for multiple fields.

Learn to implement employee post methods with JPA by switching from in memory to database storage using two service implementations, a qualifier to choose between them, and repository-based persistence.

Learn to implement get all and get by id endpoints for employees using the repository, map employee entities to employee objects with copy properties, and test with postman.

Implement delete by id using JPA repository, expose delete employee by id API, verify deletion via Postman and console, demonstrating data removal from the database.

Explore a microservices architecture for shopping cart application with a product, order, and payment services, each with its own database, linked by a service registry, config server, and api gateway.

Create a product service using spring visualizer with maven and java, add web, jpa, mysql, lombok, cloud deps, switch to yaml configuration, and scaffold controller, service, repository, and entity layers.

Create a product service custom exception extending runtime exception with an error code, and implement a rest controller advice to return a structured error response when data is not found.

Learn how to wire a Eureka service registry client into a product service using Spring Cloud, add dependencies, configure application YAML, and verify discovery.

Implement a place order API by wiring the order controller to the order service, saving the order data in the repository, and returning the generated order id.

Create a centralized config server to eliminate redundant configuration across microservices, connecting product and order services to a GitHub-based repository, enabling consistent, scalable configuration management.

create a spring config server by scaffolding a boot project, adding the config server and eureka dependencies, enabling the server, and wiring a git-backed configuration repository.

Implement a reduce quantity API in the product service using Spring Boot. Expose a put endpoint with product id and quantity, validate existence and update the quantity in product repository.

Test the reduceQuantity api by restarting the product service, sending requests to /product/reduceQuantity with product id and quantity, and verify insufficient quantity and not found errors.

Declare and enable a Feign client to call the product service reduce quantity API from the place order service, mapping a product service client and invoking it before persisting orders.

Install zipkin via docker to enable end-to-end distributed tracing across microservices. Learn to start the Zipkin server, connect application logs, and trace requests through the system.

Implement doPayment api in the payment service using a payment request model, post mapping, and transactional persistence with a transaction details repository and logger.

Call doPayment API from the order service via a feign client to complete payment, build a payment request, and update the order status from created to placed or payment failed.

Implement a get payment details API in the payments service for order id, define a payment response model, and expose it to the order service via RestTemplate with load balancing.

Implement a resilience4j circuit breaker in the order service by wiring external circuit breaker for feign clients, adding a fallback, and configuring yaml thresholds and count-based sliding window.

Implement rate limiting in the api gateway using resilience4j and redis to cap requests per user per second, protecting apis from DDoS attacks.

Learn to secure microservices with spring security and oauth2 using okta as the authentication server, issuing jwt tokens and enforcing scopes and roles across gateway and services.

Add spring security and okta to a cloud gateway, configure issuer, audience, client id, secret, and scopes to obtain and validate JWTs.

Add interceptors to Feign client and RestTemplate to automatically attach OAuth2 tokens as authorization headers for requests to the payment and product services.

Implement security for payment and product services by adding springboard security and Okta springboard starter, then configure a web security filter chain enforcing JWT authentication with scope internal.

Implement Spring security across product and order services by configuring a web security filter chain, enabling global method security, and using pre authorize rules for admin, customer, and internal scope.

Test spring security across microservices by validating okta-based access tokens and auth-code based flows in request headers, enforcing role-based access, with postman verification and 401 errors for invalid tokens.

Register each service as a client to the authentication provider, implement Spring Security client and resource server, and validate tokens with Auth0 across the API gateway and resource services.

Configure Auth0 dashboard settings for your microservices by creating the application, defining callback URLs, and integrating roles and audiences into tokens via custom actions.

Migrate Spring Boot microservices to Java 21 and Spring Boot 3.4+ by upgrading all libraries, pom.xml, and Spring Cloud versions, then validate service startup and database connectivity.

Implement a login-based token workflow in the cloud gateway using Spring Security and an Auth0 OpenID Connect client. Configure client registration, audience, and a reactive token-printing endpoint.

Convert the product service into a resource server, validate tokens against Auth0, and enforce role-based access using a custom JWT decoder and admin or customer roles.

Implement a resource server in the payment service by mirroring the product service security: enable method security, secure endpoints with pre authorize for admin and customer, and validate tokens.

Create a Spring Boot service layer test for the order service by mocking repositories and external services, injecting mocks, and testing get order details with both success and failure scenarios.

Mock the order repository and rest calls to test the service layer, using any long, Optional<Order>, and tailored getForObject responses for product and payment services.

Implement the place order and test its success scenario by mocking product and payment services, then save and verify the order with the order service and repository.

Test the place-order failure scenario where payment fails but the order is placed, implementing tests and verifying payment error handling and final order status.

Learn to check and improve unit test coverage for your order service by running tests with coverage in IntelliJ, ensuring 100% method and line coverage, and integration tests for controller.

Annotate and generate an integration test for the order controller using Spring Boot, MockMvc, and test configurations, wiring a test service registry with payment and product service instances.

Explore configuring an integration test for the order controller by wiring order service and repository, setting up mock MVC, and using wiremock with an object mapper for JSON data.

Learn to test place order flows using mock MVC and JWT, validate data in the database, simulate reduce quantity and do payment, and debug content type and fallback return types.

Implement a test case for placing an order with admin authority, expecting a 403 forbidden response, using mock MVC to validate both forbidden and successful scenarios.