Jump-Start Microservices on Spring Boot and Spring Cloud

Explore Springboard, a bootstrapping framework that simplifies creating Spring applications with opinionated configuration, embedded Tomcat or Undertow, and no war deployment. Enjoy externalized configuration and production-ready features.

Download and install the sts plugin or ide on Windows, create a spring starter project with dependencies, then set the server port to 80 or 81 and run the application.

Docker separates applications from infrastructure by packaging them into lightweight containers, enabling containerisation, rapid testing and deployment, and consistent environments across teams.

Install Docker from Docker Hub by signing up, verifying your email, signing in, downloading the Windows installer, and running it to install Docker on your system.

Explore the Docker ecosystem—host, images, containers, and the daemon; pull and push images from registries like Docker Hub, and deploy containers with networks and storage.

Use the DOCA dashboard and Docker CLI to view, start, stop, and delete images, then pull from the central repository and run images locally to see outputs.

Create a Spring Boot project called Local Demo, add a Spring Web page and a controller with mapping, build a jar, and prepare a Docker setup to run it.

Execute docker build steps to build the project from the command prompt, tag the image with a repository name, and verify the created docker image in the local image list.

Run the dockerized spring boot image with docker run and proper port mappings. Check the created image, then test the service at localhost:882/dogood to verify.

Push and pull Docker images by logging into Docker Hub, tagging images with your user ID, and pushing to the correct repository, then pull and verify locally with Docker commands.

Learn how to run a Spring Boot microservice on Docker, connect to a local MySQL database using a secret, and pull the latest MySQL image from Docker Hub.

Check the latest docker images, then create a mysql container with port mapping and credentials. Test access by entering the container and verifying the database.

Link and run a Spring Boot app with a MySQL container by building a docker image, starting containers, and hitting localhost:8080 to fetch data.

Explore how Spring cloud config server centralizes externalized configuration across environments, manages name-value properties from a git repository, supports encryption, and enables runtime refresh without client restarts.

Learn to set up a Spring Cloud Config server and client by adding web and config server dependencies, configuring properties, and exposing actuator endpoints for refresh.

Create a Spring Boot cloud config server by setting the group and package, selecting the config server dependency, and running the Spring Boot application.

Configure a Spring Boot config server by adding a message in application.properties, reading it with @Value in a configuration class, and printing hello from server on startup via CommandLineRunner.

Create a spring cloud config client by duplicating server properties into the client, adjusting application properties, and troubleshooting startup errors from port conflicts while observing a hello from cloned message.

Configure a Spring Boot client to read from a cloud config server using a local git repository and enable refresh scope with actuator exposure for on-the-fly updates.

Download git for Windows, accept default settings, and locate its install folder. Add git to path via environmental variables, create a Repo folder, open cmd, and initialize the local repository.

Create a rest controller with a get mapping at /message that returns the current config message, and demonstrate fetching the latest message from the repository without restarting the client.

sign in to github, create a new remote repository (optionally with a readme), then create a file named config-clomp.properties, add a sample message, commit, and push to the remote repository.

Learn to sync a remote git repository with your local project using GitHub Desktop, resolve conflicts, commit and push changes, and verify updates to properties and mappings.

Explore a REST producer and consumer pattern with a book catalog: a producer retrieves ISBN-based details and price, while a consumer supplies quantity to compute the total.

Create a producer service application with Spring Boot, naming it producer and adding Web and JPA dependencies; configure the port, connect to a database, and run the service.

Create a rest controller in a package, annotate the class, and map a get endpoint at /book that returns a string message.

Create a service layer for a producer application and wire a book service into the controller using autowire, returning a message.

Connect to an in-memory H2 database with Spring Boot, map a book entity to a book table using JPA annotations, and auto insert two records via data.sql on startup.

Create a JPA repository for the book entity, using repository methods like find all to retrieve books from the database and expose them via a service.

Implement the findById method in a JPA repository to fetch a book by ID or ISBN, handle the optional result, and route retrieval through the service and controller.

Create a consumer service with dev web, copy the producer’s book entity and lombok dependency, remove database use, and implement a get endpoint for purchased books by isbn and quantity.

Consumer service uses RestTemplate to call the producer service and fetch a book by ISBN, passing isbn and quantity in a map and building the object with a template builder.

Learn how Feign enables a declarative rest client by declaring an interface and getting a runtime-provisioned implementation, with configuration via properties to control logging and rest calls.

Create a spring boot starter project for a books consumer service, add spring web, openfeign, and ribbon for load balancing, and implement a feign client interface named BookFeign.

Create a Feign client interface for the bookstore producer service, configure its application name in application.properties, and expose a get purchased book method via a get mapping.

Call the producer service using a Feign client by creating a get book method with ISBN and quantity, then compute the amount from price and quantity and return the book.

Configure a new producer run in the Springboard app, select the project and main class, set the port with an environment variable, and verify the result in the browser.

Enable client side balancing with the ribbon pattern in the consumer, using multiple producer instances. Observe load balancing across ports 1882 and 1892 as requests cycle to available producers.

Zuul OSS pattern acts as a gateway, applying authentication, security, monitoring, dynamic throttling, and static response handling through filters before requests reach backend services, with load shedding and capacity allocation.

Understand how Hystrix's circuit breaker isolates failing services, enables fallbacks, and improves resilience and latency tolerance to prevent cascading failures in microservices.

Create a Spring Boot and Spring Cloud app using Zuul and Hystrix, wire a consumer service to call a producer service, and implement a Hystrix fallback with required dependencies.

Demonstrate calling the producer service from the consumer, handle missing ISBN scenarios, and prevent white label errors by implementing Hystrix fallbacks in a Spring Boot microservices setup.

Enable a circuit breaker and implement a default fallback in Hystrix to return a default book object when a fault occurs, to handle white label errors.

Create a Zuul filter by implementing pre, post, and error filters, set its order, and log a before-request message with a logger.

Learn how to route requests to a bookstore producer service through the Zuul API gateway, implement simple filters, and observe pre- and post-request behavior.

See how service x registers with the Eureka server and service y locates service x through the registry.

Create a Yuriko Eureka server, add the spring cloud netflix Eureka server dependency, and run on port 8761 to use the Eureka dashboard with properties in application.properties or application.yaml.

Register the Eureka client by adding web and Eureka discovery client dependencies and enabling discovery client. Set the server to localhost:8761 and name the client client1.

Register a producer with the Eureka server by configuring the discovery client and dependencies, set up a training database and book table, and initialize data to enable retrieval of records.

Register the producer with the Eureka server by enabling the discovery client, then run both apps and verify the producer instance is registered.

Learn how to perform client-side load balancing with Ribbon and Feign by using Eureka service discovery to auto-discover multiple producer instances, enabling resilient microservice communication.

Explore Zipkin and Sleuth for distributed tracing in a microservices ecosystem, measure latency across components, and identify slow services to speed debugging and optimize performance.

Register a Spring Boot app with Eureka and Zipkin, run a Zipkin server, and view distributed traces in the Zipkin console using Sleuth and Zipkin dependencies.

Trace a book order workflow with ribbon load balancing, Eureka service discovery, and Zipkin to diagnose a producer service fault across order and producer services.

Introduce reactive programming in Spring, highlighting asynchronous non-blocking, event-driven data processing with observable data streams, and reacting to changes while contrasting with blocking synchronous processing.

Explore non-blocking, asynchronous request processing: a thread pool delegates incoming requests, immediately processes others, and uses the callback function to deliver responses when the work completes.

Master Mono and Flux in Spring's reactive streams, detailing publisher and subscriber roles and back pressure. Learn how Mono emits zero or one element and Flux emits zero to many.

Create a Spring Boot app to test reactive web by wiring Spring Reactive and MongoDB Reactive dependencies, using Project Reactor, and exposing a Flux-based get users stream.

Explore blocking versus reactive data processing in Spring Boot by adding a half-second sleep, using flux versus list, and mapping users to expose an endpoint.

Demonstrate Spring Boot and reactive web concepts by building user endpoints, contrasting blocking and reactive streams, and configuring media type mappings to stream data with onNext and processing logs.

Build a reactive web service using a MongoDB reactive repository to return a flux of users, with endpoints and controller logic that subscribes and saves records.

Discover how to route multiple services with Spring Cloud Gateway by building two hello services on ports 888 and 1889, each with a rest controller mapped to hello1 and hello2.

Create a spring cloud gateway application by adding the cloud starter gateway dependency, configuring routes to the hello service instances, and enabling the gateway to route requests.

Configure the gateway by defining a bean method to add a request header and a response header. Read the request header in the hello service and verify flow with Postman.

Create a custom gateway filter by extending AbstractGatewayFilterFactory, add a static config class, and implement a pre and post filter via a lambda, chaining filters for a gateway application.

Run the custom filter to observe how it prints the pre filter and the second service method invoked through the gateway.

Create a global filter for all gateway services by returning a global filter method that accepts exchange and chain, and observe the first and second global filter messages.

Create and sequence global filters to process requests in Spring Boot microservices, demonstrating a first global filter followed by a second global filter message.

Explore resilience4j, a lightweight Java 8 resilience library that decorates functional interfaces with circuit breaker, rate limiter, and retry, plus a sample consumer service with fallback.

Demonstrates how a required parameter defaults when missing and prints the given value when present, illustrating resilience in application behavior.