Microservices with Spring Boot & Spring Cloud

Install the Spring Tool Suite, create a minimal Spring Boot project, and learn configuration options: XML files, YAML, properties, and Java configuration—plus starters, Maven, and bean overrides.

Install and configure Spring Tool Suite to accelerate building microservices with Spring Boot and Spring Cloud, using Maven integration and an Eclipse-based workspace setup.

Learn how to quickly set up a Spring Boot project, leveraging starter POMs, auto-configuration, and convention over configuration to streamline dependencies, beans, and project setup.

Generate a spring boot web project from start spring dot io, with auto-configured components such as the dispatcher servlet and dependencies like spring boot starter web, embedded tomcat, and jackson.

Discover how Spring Boot provides defaults and how to override them with application.properties or application.yaml, enabling auto configuration in a Spring MVC app.

Externalize bean configurations in Spring Boot by importing an XML configuration file with ImportResource, defining a circus list bean containing tiger and bear, and validating with a microservice request.

Explore how maven manages dependencies with starters and coordinates to pull transitive libraries like spring boot starter web and security via bom-based management.

Discover how Spring Boot auto configuration applies defaults like the dispatcher servlet and how to override them with beans, such as a servlet registration bean, for custom URL mapping.

Explore how Spring Cloud enables distributed microservices, comparing it with traditional architectures, and learn to design, build, and scale a microservices application using Spring Cloud features.

Explore how microservices redefine designing, building, and architecting software applications, and compare the monolith approach to a microservices approach to understand their differences.

Compare traditional monolithic architectures with microservices, where independent services run with embedded containers and communicate via http, enabling scalable, decoupled applications defined by logical boundaries.

Learn how microservice architecture uses lightweight, independent services with dedicated data stores, an API gateway, and stateless design to support a business capability.

Break the monolith into smaller microservices to enable loose coupling, independent deployments, and targeted scaling, while teams choose technologies and replace services without impacting others.

Set up a barebones microservices catalog by refactoring a monolith with Spring Boot, Spring Data REST, and an H2 datastore; expose a REST API for title search of books.

Launch and demonstrate a simple Spring Boot microservice, expose a book controller endpoint, and call the catalog microservice from a web front end using a RestTemplate over port 9999.

Examine the common challenges of a microservice architecture, from distributed processing and inter-service communication to configuration management, deployment, and security, noting how Spring Boot accelerates setup.

Explore how microservices scale from a single instance to hundreds by centralizing configuration, registering services, discovering endpoints, balancing load, monitoring health, and security with Spring Cloud.

Explore spring cloud config to centralize and externalize microservices configurations via a config server and git-backed repository, enabling on-the-fly refresh and encrypted properties.

Set up a Spring cloud config server and repository to store and expose client configurations. Configure a client to retrieve properties via a rest api and view them in json.

Create a Spring Cloud config client that fetches a message from the config server in a central repository, using a Spring starter project, config client dependency, and a rest controller.

Configure a config client to consult the config server using bootstrap properties and the development profile, then run the config server and client to retrieve the hello message.

Explore on the fly updates with spring cloud config and actuator using refresh scope annotation, a config client, and curl to refresh from git without restart.

Learn to configure Spring Cloud Config server to encrypt and decrypt property values, use the encrypt and decrypt endpoints, and set an encryption key in application properties.

Learn how the Spring cloud config server decrypts properties encrypted in git and serves decrypted values to clients using a cipher tag and the decrypt endpoint.

Explore Spring Cloud Netflix, the Netflix cloud platform for microservices, including Eureka service discovery, history circuit breaking and fault tolerance, Ribbon client-side load balancing, and Zoll Zone as edge service.

Eureka provides service registry and discovery for microservices, registering a service name to instances and enabling access by name rather than host and port.

Register microservices with a resilient Eureka server to enable service discovery, use Eureka clients and the RestTemplate to locate and communicate with other service instances across multiple hosts.

Create and configure a Eureka server that acts as a surface registry, a directory for all services, enabling registration and discovery in a spring boot cloud setup.

Configure a microservice to register with two Eureka servers for redundancy, by editing the hosts file, creating per-profile application properties, and setting each server's hostname and url accordingly.

Configure two Spring Boot Eureka server instances to provide redundancy by registering microservices as replicas across pier one and pier two, with separate run configurations and active profiles.

Learn to register a microservice with the Eureka service registry using Spring Boot and Spring Cloud, enable the Eureka client annotation, and verify registration in the service registry.

Learn to configure a Spring Boot Eureka client, register with the server, and use the client to discover services and instances via a service info endpoint.

Explore how to use RestTemplate with Eureka service discovery to enable inter-service communication in a Spring microservices architecture.

Demonstrate service discovery with Eureka by using RestTemplate to call a second microservice via its registered service name and retrieve its home page URL.

Learn how to isolate failures in microservices to prevent cascading, implement fault and latency tolerance with hysterics, and monitor system health via a comprehensive dashboard.

Develop two sample microservices and implement Hystrix circuit breaking, including a history dashboard, latency rules, and graceful failover to maintain service continuity during failures.

Build two spring boot microservices with a rest controller and endpoints, then use a rest template to call one service from the other, demonstrating inter-service communication.

Configure hystrix circuit breaking with a fallback method to return a default product list when a simple service fails, ensuring graceful failover in a two-microservice setup.

Learn how to configure Hystrix command properties to set a 500-millisecond timeout for methods and plan failover behavior in Spring Boot microservices, add time parameters, and ensure consistent method signatures.

Configure Hystrix to handle timeouts and failover by simulating delays and observing circuit breaker behavior for microservices, including execution strategies, thread versus semaphore, and threshold settings.

Discover how the district's dashboard visualizes circuit breakers across microservices, enabling monitoring of the history stream, health, and performance of a distributed system.

Explore client-side load balancing with Ribbon in a spring cloud microservices setup by configuring a Ribbon client, routing requests across multiple microservice instances, and optionally integrating with Eureka.

Create three Spring Boot microservice instances on separate ports, expose endpoints, and use Ribbon for client-side load balancing with a client calling the simple microservice.

Configure Ribbon client-side load balancing by creating a simple service configuration with a ping bean, an availability filtering rule, and properties for service nodes and a load-balanced rest template.

Explore Zuul as an edge service and API gateway that acts as a reverse proxy routing client requests to microservices through a single entry point, enabling dynamic routing and security.

Learn how to configure Zuul as a gateway proxy to route requests to a microservice behind a reverse proxy, enabling a stable API surface while masking internal endpoints.

Configure routing on the edge service by using the path property for explicit mapping and wildcard matching to the microservice. Add a prefix with the prefix property to versioned apis.

Develop and register a custom zul filter to run at the gateway API, using a pre-filter with a defined order and type, and implement its run method to process requests.

Secure microservices with OAuth and token-based access by establishing an authorization server, a resource server, and an OAuth client, using in-memory tokens before migrating to JDBC token store.

Explore the four actors in an authentication flow—the resource owner, resource server, client application, and authorization server—and examine how the password grant issues and validates access tokens.

Install and set up Postman as a Chrome app to test rest api endpoints and oauth infrastructure. Sign up with Google for access and practice sending requests to local endpoints.

Learn to set up an authorization server with Spring Security, enabling token creation, validation, and refresh, by configuring in‑memory clients and users and running on port 1990.

Stand up an OAuth authorization server and configure clients and end users, then use Postman to obtain an access token via the password grant with basic authentication.

Learn to set up an OAuth resource server in a Spring Boot microservice, protect a rest endpoint with an access token, and enforce admin access using the pre authorized annotation.

Configure an OAuth client in Spring Boot, secure a client project with web security, and access a protected resource using an OAuth rest template and resource owner password grant.

Learn to inject a user principal, cast to authentication, and build a user object to access a protected resource via an OAuth client on a resource server.

Learn to download, install, and configure an HSQLDB server to manage OAuth tokens across authorization and resource servers, including creating a test database and using a GUI.

Create and seed the database schema for OAuth clients and tokens in a Spring Boot microservices project, building security tables and adding two client entries.

Convert authorization server to use a JDBC token store, replacing in-memory clients; configure security to permit token access, and wire a data source and JDBC token store for token management.

Override the configure method to use a data source for JDBC-backed client details, enabling token management and access to a protected execute endpoint via the OAuth client.

Learn to separate an oauth resource server from the oauth authorization server using a dedicated Spring project, configure security, and use remote token services to validate tokens.

Configure a separated resource server and authorization server in a Spring Boot microservices setup, sharing a token store and data source to issue and validate tokens.

Build and integrate a library reservation system using Spring Cloud features, combining service registry and discovery, configuration, edge server, and load balancing with Ribbon for a cohesive distributed architecture.

We review the base application, a three-project microservice architecture, and demonstrate a library reservation flow by reserving Dracula and viewing your reservation details.

Explore a simple JavaScript UI that reserves titles, displays a catalog, and shows a user's reservations via microservice endpoints, while learning to decouple the UI with Spring Cloud.

Enable spring cloud config for the catalog service, add the config server dependency, and bootstrap from a git-backed properties file to set catalog.size to three.

Set up a Eureka server for service registry and discovery in a Spring Boot microservices library app, enable it, and register catalog and reservation services for discovery.

Configure a Zuul edge gateway that acts as a reverse proxy for library services, enabling Zuul proxy and Eureka client, with port 5005 and /catalog routing to the catalog service.

Configure the Zuul edge to route reservation calls through a wildcard path with strip prefix disabled, enabling reverse-proxy routing and dynamic service discovery with the Eureka registry.

Explore how Spring Cloud enables Ribbon load balancing with Eureka by running multiple reservation service instances behind an edge service, then observe registry-backed routing.

Summarizes how spring cloud enables a distributed microservices system using sub projects like config, service discovery, routing, and circuit breaking. Build on spring boot and the core spring framework.