[NEW] Master Microservices with SpringBoot,Docker,Kubernetes

Learn how to build microservices inside a project using Spring Boot, overcoming the time-consuming packaging and deployment of Java-based monolithic and SOA architectures.

Explore humorous memes about Spring Boot and learn how it simplifies Java development. Build microservices by grounding in dependency injection and autowiring, with Docker and cloud integrations.

Learn how to build REST services for microservices using HTTP methods for CRUD operations, perform input validation and robust exception handling, and document APIs with OpenAPI/Swagger.

Master the DTO pattern to transfer data between layers using DTOs instead of entities. Use a CustomerDetails DTO to combine customer and accounts data, decoupling layers and reducing network traffic.

Create and use data transfer objects for accounts and customers in the accounts microservice, with response and error DTOs, mapping entities to client-ready data using Lombok.

Build a rest api in the accounts microservice to create a new account and customer details using a dto pattern, a service layer, and dto to entity mappers.

Update account API in the accounts microservice enables updating name, email, mobile, account type, and branch address using the account number as the key, without changing the account number.

Enhance rest api documentation by using swagger annotations @Tag, @Operation, and @ApiResponse to add controller and api level summaries, descriptions, and precise response details in Swagger UI.

Apply @Schema annotations to DTOs to create business-friendly names, descriptions, and examples in swagger/openapi, and document ApiResponse with ErrorResponseDto for 500 errors.

Explore how to right-size and define microservice boundaries using domain-driven sizing and event-storming, including stakeholder collaboration and iterative refinement for a scalable architecture.

Explore migrating a monolithic ecommerce app to microservices, emphasizing right sizing boundaries. Learn how API gateway, separate databases, and containerized microservices in Kubernetes enable agile teams and event-driven communication.

Compare containers with virtual machines by showing Docker-based isolation, portability, and rapid deployment for microservices. Learn why containers offer lightweight, isolated environments that simplify scaling and deployment.

Explore Docker's architecture by understanding the Docker client and server, the CLI and remote API, and how images become containers and are stored in Docker Hub or private registries.

Build the accounts microservice image from its dockerfile, tag it as your-docker-username/accounts:S4, and inspect the resulting image to verify the use of openjdk17-slim as the base.

Run a Docker container from a prebuilt image, map ports, and deploy multiple instances to illustrate portability and scalability.

Learn how buildpacks generate production-ready Docker images for spring boot microservices using mvn spring-boot:build-image, without Dockerfiles, and how this approach improves image size and aligns with Docker standards.

Explore google jib to generate a production-ready docker image for the java-based cards microservice using Maven, including configuring pom.xml and running mvn compile jib:dockerBuild.

Push locally built docker images to a remote docker hub repository to enable deployment. Push uses docker push with your username and tag; pull validates by downloading from docker hub.

Master docker compose up to create containers from scratch and down to stop and remove them, then compare start and stop for reusing existing containers.

Master day-to-day Docker commands for images and containers, including build, run, inspect by id, remove, and manage with docker ps, start, stop, kill, restart, logs, and compose up/down/start/stop.

Demonstrates how to activate spring boot profiles using command line arguments, JVM options, and environment variables with overrides for build.version across prod and qa deployments.

Store all microservice configurations in the config server classpath and name files by service, enable the native profile, and validate with config server endpoints for accounts, cards, and loans.

Show how to read microservice properties from config server by updating loans and cards' application.yml with spring.config.import and spring.application.name, and updating pom.xml with spring-cloud-starter-config 2022.0.3, then validate via postman.

Configure the spring cloud config server to read properties from a file system location, replacing classpath with file, and validate prod configurations for accounts, loans, and cards.

Optimize docker-compose by extracting repetitive networks, deploy settings, and spring_profiles_active into a common-config.yml, then extend across microservices and config server via spring_config_import.

Shows end-to-end testing of a docker-compose spring boot config server with the default profile, validating rabbitmq connectivity and property refresh across accounts, loans, and cards.

Update docker compose to connect microservices to mysql databases via environment variables, replacing localhost, configure spring datasource url and credentials, and regenerate images with jib.

Update docker compose to use s7 images and fix the config server dependency on rabbit, then run docker compose up in detached mode to validate microservices and MySQL connections.

Discover how accounts, loans, and cards microservices share a network behind an api gateway, handling external traffic and securing entry with firewall, auditing, and logging, while addressing internal communication challenges.

Explore how microservices locate and register with each other in dynamic containers, and learn the basics of service discovery, service registration, and load balancing.

Understand why traditional load balancers fail for microservices, lacking service discovery and registration, as IPs and DNS mappings churn in dynamic cloud environments.

Explains client side service discovery and load balancing with a service registry, where services register at startup and clients use Spring Cloud to select backing service instances.

Implement client-side service discovery and registration in a Spring Boot microservices network using Spring Cloud components: Eureka, Spring Cloud Load Balancer, and Netflix Feign for inter-service calls.

Set up a Spring Boot Eureka server as a service discovery agent, enable the Eureka server, and wire config client and actuator to load properties from the config server.

Leverage open feign with Eureka for service discovery and client-side load balancing to enable the accounts microservice to fetch and aggregate cards and loans data via declarative Feign clients.

Discover how Eureka self-preservation mode protects the service registry during temporary network glitches. It avoids evicting healthy instances by using heartbeats, a renewal threshold, and safeguards in the Eureka dashboard.

Update docker compose to enable Eureka service discovery by removing rabbitmq, renaming to Eureka server, switching to eurekaserver:s8, and wiring accounts, loans, and cards to the config server at 8070.

Demonstrate client-side service discovery and load balancing by running two loans microservice instances registered with Eureka. The test shows requests routing between instances via docker-compose with distinct ports and containers.

Learn to manage external traffic in microservices using a single entry point with an edge server or API gateway, and centralize cross-cutting concerns like logging, auditing, tracing, and security.

Enable a lowercase serviceId property in the gateway discovery locator to accept lowercase service names, validate with postman, and avoid 404 errors from capitalized paths.

Demonstrates adding X-Response-Time with the AddResponseHeader gateway filter in Spring Cloud Gateway, and routing via path predicates with rewrite path using Java and YAML configurations.

Learn how to build resilient microservices with resiliency4j, preventing cascading failures and enabling self-healing through circuit breaker, fallback, retry, time limiter, rate limiter, and bulkhead.

Explore a typical microservices scenario where a slow cards service causes ripple effects to accounts and edge gateway, underscoring the need for resiliency with a secured breaker.

Explore how the circuit breaker pattern controls traffic to microservices by using closed, open, and half-open states with a failure-rate threshold, enabled by Resiliency4j and Spring Boot.

Implement a circuit breaker pattern in a gateway with a fallback REST API to gracefully handle service timeouts. Use Mono-based reactive handling and forward to a contact support endpoint.

Learn how circuit breaker with Feign client activates fallbacks across accounts, cards, and loans microservices, using resilience4j, actuator insights, and a resilient gateway with Eureka registration.

Explore Http timeout configurations in Spring Cloud Gateway to prevent long waits by configuring connection and response timeouts, with global settings and per-route overrides demonstrated using loans and accounts microservices.

Explore the retry pattern in microservices, using exponential backoff for transient failures and applying retries only to idempotent operations, with optional circuit breaker integration.

Explore how the rate limiter pattern controls incoming requests in microservices, preventing DoS and 429 errors, and ensuring fair access with strategies by session, IP, user, tenant, and subscription tier.

Learn to implement a Redis rate limiter in Spring Cloud Gateway using a request rate limiter, key resolver, and token bucket settings such as replenishRate, burst capacity, and requested tokens.

Explore the bulkhead pattern to isolate and limit failures in microservices, allocate dedicated resources per API, and boost resiliency with resiliency4j's bulkhead settings and @Bulkhead annotations.

Demonstrates resiliency patterns in a six-service microservices stack deployed with Docker and Docker Compose, including Redis-backed rate limiter, gateway server integration, and updating service tags to s10.