[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 how Spring Boot enables fast Java-based microservices with auto configuration, embedded servers, and self-contained jars, then containerize with Docker and deploy to Kubernetes.

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.

Create microservices with Spring Boot by configuring a start.spring.io project, selecting Maven and Java, then add Spring Web, H2, Spring Data JPA, Actuator, DevTools, Lombok, and Validation for accounts microservice.

Create a hello world rest API in a spring boot web application using @RestController and GetMapping, exposing an accounts controller that returns hello world.

Configure an internal H2 database in Spring Boot using YAML properties, enable the H2 console, and auto-create schema with schema.sql and data.sql, and run on port 8080 for microservices.

Learn to model database tables as Spring Data JPA entities and interact with them through repositories, using a base entity for metadata and Lombok to reduce boilerplate.

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.

Create an accounts api by mapping customer dto to entity, persisting customer and account via Spring Data JPA, and handling duplicate mobile numbers with a global exception handler.

Fetch account and customer details by mobile number in the accounts microservice, returning a customer dto with embedded accounts dto via the /fetch endpoint using getmapping and requestparam.

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.

Create a delete api in the accounts microservice that uses a mobile number to locate a customer and delete records from accounts and customer tables via transactional, custom repository methods.

Implement global runtime exception handling for rest APIs using controller advice to catch all exceptions, returning a structured error response with the invoked path and internal server error.

Enforce input validations in the accounts microservice using Spring Boot validation annotations on DTOs, with an exception handler to return field errors for create, update, fetch, and delete endpoints.

use spring data jpa auditing to auto update created and updated metadata fields via annotations and a custom auditor, removing manual code and enabling automatic tracking.

Document your rest apis using the OpenAPI specification with Springdoc OpenAPI, generating Swagger UI that reveals request and response formats, validations, and embedded dto schemas for external consumers.

Enhance REST API documentation by using OpenAPI definition with info, contact, license, and external documentation in the spring boot accounts application.

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.

Enhance REST API documentation with @Schema and example data, and document error responses using ErrorResponseDto, while using 417 for update and delete failures instead of 500.

Explore key Spring Boot annotations and classes for building REST services, including RestController, GetMapping, PostMapping, ResponseEntity, RequestHeader, ControllerAdvice, ExceptionHandler, and RequestBody, with practical use in the Accounts microservice.

Build cards and loans microservices with the same standards as accounts, implementing h2 database, entities, jpa repositories, dto pattern, CRUD APIs, exception handling, auditing, and REST documentation.

Master the loans microservice with create, fetch, update, and delete operations using Postman against a Spring Boot application on port 8090, featuring DTO mapping, OpenAPI, and validation.

Explore the cards microservice setup and code, including pom validation, H2 configuration, port 9000, entities and dtos, repositories, and four apis (create, fetch, update, delete) with swagger.

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.

Identify microservice boundaries for a bank app using domain-driven and event-driven sizing. Compare three team proposals and adopt team2’s independent services for saving, trading, cards, and loans.

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.

Use the strangler fig pattern to gradually replace a legacy monolith with microservices, using domain-driven design to rightsize services, enable coexistence, and safely migrate cards, accounts, and loans.

explores the deployment, portability, and scalability challenges of microservices and shows how containerization with Docker enables consistent, scalable deployments across environments.

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 what containers are and how Docker enables containerization through container images and containers, using Linux namespaces and cgroups for isolated, OS-level virtualization across hosts.

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.

Install and set up Docker on your local system, access Docker Hub, and explore images and repositories to practice microservice concepts.

Explore three common approaches to generating Docker images for Spring Boot microservices: Dockerfile, Buildpacks, and Jib, highlighting portability, scalability, and a chosen path for the course.

Write a dockerfile for the accounts microservice using openjdk:17-jdk-slim as the base image, copy the accounts-0.0.1-SNAPSHOT.jar from the target folder, and set an entrypoint to run it with java -jar.

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.

Explore the drawbacks of the Dockerfile approach for generating Docker images, including learning curves, maintenance for many microservices, and security concerns, and compare Buildpacks and Google Jib as automated alternatives.

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.

Compare Dockerfile, buildpacks, and jib approaches to generate Docker images for microservices, highlighting the advantages and tradeoffs and why this course uses jib.

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.

Use docker compose to start several microservices from a single yaml file. Define services, images, ports, memory limits, and a shared easybank network for interservice communication.

Run all microservices with a single docker compose up from the docker compose yaml file, then stop and remove them with docker compose down in detached mode.

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.

Install the docker desktop logs explorer extension to view and filter logs for running and stopped containers, using color-coded microservice logs and stdout or stderr options.

Master containerizing web apps with Docker, using dockerfiles and docker-compose for microservices accounts, cards, and loans. Align Maven configurations and GitHub code references.

Define cloud native applications and their characteristics, including 12-factor and 15-factor methodologies, and explain how containers, service meshes, microservices, immutable infrastructure, and declarative APIs enable scalable, observable, vendor-agnostic cloud deployments.

Identify cloud-native applications by their microservices architecture and containerization with Docker, ensuring portability across cloud platforms. Use Kubernetes for horizontal scalability, DevOps-driven CI/CD, and resilient, fault-tolerant deployment with automated pipelines.

Compare cloud-native applications with traditional enterprise apps, highlighting predictable behavior and easier issue tracking. See how Docker and Kubernetes enable OS abstraction, sizing, and DevOps-driven continuous delivery with automated recovery.

Explore the 12-factor and 15-factor methodologies for cloud native applications, from Heroku's original guidelines to Kevin Hoffman's expanded framework, and their role in scalable, portable deployments.

Understand the first five 15-factor principles for microservices: one code base per application, api-first design, explicit dependency management, design-build-run-release, and externalized configuration.

Explore the 15-factor methodology focusing on logs routed to standard output, log aggregation, disposability, and environment parity for cloud native microservices.

Explore the 15 factor methodology for cloud native microservices, covering port binding, stateless design, concurrency, telemetry, and zero trust authentication using OAuth 2.1 and OpenID Connect.

Explore configuration management challenges in microservices. Separate configurations from business logic to reuse a single docker image across environments using Spring Boot, external config, or Spring Cloud Config Server.

Learn how Spring Boot externalizes configuration for microservices using properties, yaml, environment variables, and command line arguments; explore priority and approaches like @Value, the Environment interface, and @ConfigurationProperties.

Read build.version from application.yml with the @Value annotation and Spring expression language, and expose a build-info REST endpoint in the accounts microservice.

Read environment properties using the spring environment interface by autowiring it into a controller and exposing a java-version endpoint that returns JAVA_HOME.

Use spring boot's @ConfigurationProperties with an accounts prefix to map multiple properties into a single accounts contact info dto, exposing a /contact-info rest api.

Explore how Spring Boot profiles group configurations into environment-specific files, enabling dev, QA, and prod to share code while using different properties activated by spring.profiles.active.

Implement spring boot profiles inside the accounts microservice by creating and activating application_qa.yml and application_prod.yml alongside the default profile, then override values and test with postman.

Externalize configurations in Spring Boot via command line, JVM properties, and environment variables to activate a specific profile, aligning with the 15 factor methodology, with command line precedence highest.

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.

Apply spring boot profiles and application.yml properties to the cards and loans microservices, mirroring accounts microservice rest apis, using the eazybytes/microservice GitHub repo for reference.

Demonstrates switching Spring Boot profiles in the loans and cards microservices by exposing build-info, java-home, and contact-info APIs, using application.yml files and qa/prod profiles.

Explore drawbacks of externalizing Spring Boot configurations with cli, jvm properties, and environment variables, including security risks and manual setup. Learn how Spring Cloud Config Server centralizes versioning and auditing.

Introduce spring cloud config to centralize externalized configurations for microservices; set up a centralized config server backed by git, filesystem, or database, with config clients loading properties at startup.

Create a dedicated config server using Spring Cloud Config to centralize configurations for accounts, cards, and loans in the v2-spring-cloud-config setup, and compare classpath, file system, and GitHub approaches.

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.

Connect accounts microservice to a config server, remove local yaml files, configure spring.config.import and spring.application name accounts, and verify prod and qa profiles load from the config server.

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.

Learn how to store configuration properties in a GitHub repository and have the config server load them at startup using the git backend, with default-label, clone-on-start, and force-pull.

Learn to encrypt and decrypt sensitive properties with spring cloud config server, using a complex secret key and a cipher prefix, so plain text values stay protected in GitHub.

Explore refreshing configuration at runtime without restarting microservices using spring boot actuator refresh, exposing management endpoints, and converting records to classes for dynamic updates from the config server.

Learn how to refresh configuration at runtime across microservices using spring cloud bus with RabbitMQ, config server, and actuator bus refresh, avoiding per-instance restarts.

Automate runtime configuration refresh by wiring GitHub webhooks to the config server's /monitor endpoint, using Spring Cloud Config Monitor with Spring Cloud Bus and RabbitMQ.

Learn containerizing microservices with docker compose, creating environment-specific files for default, qa, and prod, and linking config server to accounts, loans, and cards.

Explore liveness and readiness probes in microservices, showing how docker and kubernetes with spring boot actuator expose health status via /actuator/health, liveness, and readiness for config servers.

Configure a docker compose health check for the config server via actuator and rabbitmq, and define depends_on with service healthy so accounts, loans, and cards wait for config server startup.

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.

Generate docker images for accounts, cards, loans, and the config server using mvn compile jib:dockerBuild, tag them as S6, and push to docker hub after logging in.

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.

Learn to create prod and qa docker compose files from a default template, toggle Spring profiles via commonconfig.yml, and validate multi-environment deployments with docker compose.

migrate microservices from h2 to mysql by creating separate mysql containers for accounts, loans, and cards, using docker with ports 3306, 3307, and 3308, and updating configs.

Update accounts, cards, and loans microservices to use a local MySQL database instead of H2 by replacing dependencies and configuring application.yml with MySQL URLs and sql init mode always.

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.

Demonstrates docker network concepts with a live demo in the EasyBank qa network, showing how detaching databases breaks inter-service communication.

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.

Coordinate service discovery and registration with a central registry to manage dynamic microservice instances. Implement client-side discovery with load balancing across multiple instances.

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.

Add the Eureka client dependency and configure the accounts microservice to register with the Eureka server, enable heartbeats every 30 seconds, and expose info and shutdown endpoints via the actuator.

Connect loans and cards microservices to the Eureka server to enable service discovery and registration. Validate registrations via the Eureka dashboard and ensure proper configuration in pom.xml and application.yml.

Shutdown microservices deregister themselves from the Eureka server and remove their details from the service registry, via the actuator shutdown path using http post, with a grace period before stopping.

Demonstrate microservices registering with the Eureka server and sending heartbeats every 30 seconds to maintain a healthy service registry, with automatic unregister on shutdown and discovery for load balancing.

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.

Wire Feign clients for loans and cards, implement CustomerDetailsDto to consolidate accounts, loans, and cards data, and expose a fetchCustomerDetails rest api via a new controller and service layer.

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.

Generate docker images for config, Eureka server, and microservices with jib:dockerBuild, push to docker hub, validate service discovery, and prepare docker compose to start all services.

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.

Start all microservices, config server, and Eureka with a single Docker Compose command. Validate container health and correct environment variables and profiles to ensure successful startup and registration.

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.

Understand why a separate edge server or api gateway sits between clients and microservices, enforcing security, auditing, logging, routing, retries, quotas, and fault tolerance.

Spring Cloud Gateway acts as the edge API gateway and gatekeeper for inbound traffic to microservices, enabling dynamic routing, security, and cross-cutting concerns with a non-blocking, Spring reactive architecture.

Discover the internal architecture of Spring Cloud Gateway, including gateway handler mapping, predicates, and pre- and post-filters, and learn how routes and predefined filters forward requests to microservices.

Build an edge server with spring cloud gateway, connect the gateway to eureka discovery and config servers, enable actuator, and set up section nine with docker-ready maven and yaml properties.

Demonstrates a gateway edge server routing traffic to accounts, cards, and loans microservices via Eureka service discovery and a config server, with rewrite path filtering and load-balanced forwarding.

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.

Define a Java-based RouteLocator bean in the gateway using RouteLocatorBuilder to map easybank/accounts, easybank/loans, and easybank/cards with rewrite path filters and load-balanced URIs.

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.

Implement cross cutting concerns tracing and logging with gateway by creating RequestTraceFilter and ResponseTraceFilter to generate and propagate a correlation ID across services using easybank-correlation-id headers, with a filter utility.

Propagate the easybank-correlation-id header through the gateway to accounts, loans, and cards microservices, and enable debug logging to verify the correlation id appears in end-to-end logs.

Explore API gateway design patterns built with Spring Cloud Gateway, including edge servers, routing, offloading cross-cutting concerns, backend for frontend, and gateway aggregation for multi-service data.

Generate six section9 docker images for accounts, loans, cards, config server, eureka server, and gateway, enabling health, readiness, and liveliness probes, then push the S9 tag to Docker Hub.

Update docker compose to adapt spring cloud gateway changes by adding gateway server with image gatewayserver:S9 and port 8072:9000, and define health checks for accounts, loans, and cards.

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 the circuit breaker pattern to prevent cascading failures in microservices by failing fast, monitoring remote calls, and enabling graceful recovery with fallbacks and partial traffic checks.

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 circuit breaker pattern with resiliency4j in the gateway and accounts microservice, configuring edge server resilience and open, half-open states to demonstrate fault tolerance.

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.

Implement a circuit breaker for the accounts microservice using feign client, spring cloud circuit breaker resiliency4j, and openfeign fallbacks to handle slow or down cards and loans microservices.

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.

Implement a retry pattern using Spring Cloud Gateway to retry idempotent http get operations with configurable retries and backoff, demonstrated on the loans microservice behind the gateway.

Implement retry inside the accounts microservice using resiliency4j with @Retry and a getBuildInfoFallback, configure in application.yml, add logging, and compare with gateway-level retry and circuit breaker time limiter behavior.

Explore how to implement the retry pattern in microservices using resiliency4j, including ignore exceptions like NullPointerException and retry exceptions, such as TimeoutException, with configuration in application.yml.

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.

Implement a Redis-backed rate limiter in the gateway server using a user-based KeyResolver and RedisRateLimiter configured for replenish rate 1 and burst 1.

Implement a resilience4j rate limiter inside a spring boot accounts microservice with @RateLimiter and application.yml settings, including a fallback using getJavaVersion() to return Java 17.

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.

Learn how Resilience4j applies a default aspect order for resiliency patterns like bulkhead, time limiter, rate limiter, circuit breaker, and retry, with options to customize via application.yml.

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.