Microservices with Spring Boot and Spring Cloud
Microservices with Spring Boot and Spring Cloud is a course in building a microservice system with Spring Boot 4 and Spring Cloud, covering Config Server, Eureka, Spring Cloud Gateway, Resilience4j fault tolerance, distributed tracing and OAuth2, then running it all with Docker Compose. It suits Java developers who already use Spring Boot, software architects and DevOps teams.
- Duration18 hours · 3 days
- FormatOnsite / live online
- Next roundOn request
- CertificateIncluded
Course overview
As a system grows and several teams work on it, a single monolithic application tends to become hard to change, slow to deploy and liable to fail as a whole when one part breaks. Microservices architecture splits the system into smaller services that can be developed and scaled independently, but it brings new problems: configuration, finding other services, coping when a downstream service fails and tracing issues that cross several services. Spring Boot and Spring Cloud provide tools for all of them.
This course builds on Spring Boot fundamentals to create a microservice system with Spring Boot 4.1, Spring Cloud 2025.1 and Java 25 LTS. It starts by defining service boundaries, building RESTful services with API documentation and health checks, then splitting them into several services that call each other through HTTP service clients. Learners then centralise configuration with Config Server, register services with Eureka and LoadBalancer, put Spring Cloud Gateway in front, add fault tolerance with Resilience4j and use Spring Cloud Bus with RabbitMQ. The course closes with distributed tracing, metrics, OAuth2 and running the whole system with Docker Compose. (3 days, 6 hours per day, 18 hours in total, Intermediate level.)
What you’ll gain
- Understand the benefits and limits of microservices and how to draw service boundaries
- Build RESTful services in Spring Boot 4.1 with validation, ProblemDetail, versioning and OpenAPI documentation
- Have services call each other through HTTP service clients and spread load with Spring Cloud LoadBalancer
- Centralise configuration with Spring Cloud Config Server and broadcast changes with Spring Cloud Bus
- Discover services with Eureka and put an API gateway in place with Spring Cloud Gateway
- Add fault tolerance with Resilience4j, including circuit breaker, retry and rate limiter
- Trace requests across services with Micrometer Tracing and Zipkin and collect metrics with Actuator
- Secure the system with OAuth2 and JWT and run it all with Docker Compose
Who this course is for
- Java developers who already use Spring Boot and want to move on to microservices
- Backend developers who need to split an existing system into several services
- Software architects and tech leads who design distributed systems
- DevOps teams and system administrators who run and monitor microservice systems
- Lecturers and students who want to see a complete microservice system built in Java
Prerequisites
- Object-oriented Java, and some experience building applications with Spring Boot
- An understanding of RESTful APIs, HTTP methods and JSON
- Basic use of a relational database such as MySQL, PostgreSQL or SQL Server
- A laptop that can run JDK 25, an IDE and Docker Desktop, with permission to install software
Curriculum
Course Details
This is the 2026 edition of the Building Microservices with Spring Boot and Spring Cloud course, rewritten for Spring Boot 4.1, Spring Cloud 2025.1 and Java 25 LTS. It runs for 3 days, 6 hours per day (18 hours in total, 09:00-16:00), as lectures with labs built on a single multi-service currency exchange and conversion system throughout. Intermediate level. The course follows on from Spring Framework 7 and Spring Boot 4 Basic to Advanced, so
it reviews RESTful basics in one section and then concentrates on multi-service systems. Compared with the previous edition it replaces OpenFeign with HTTP service clients, uses Spring Cloud Gateway Server WebMVC, and adds the full Resilience4j toolkit, OAuth2 with Keycloak, metrics and Docker Compose. All tools are open source or free and run on the learner's own machine with Docker. Learners take home a lab guide, source code for every service and docker-compose files for the whole system.
Day 1 From a RESTful Service to Many Services
Section 1: Lab: Introducing Microservices Architecture
- Monoliths compared with microservices, and when not to split a system yet
- Drawing service boundaries around business domains, and the database-per-service principle
- The challenges of distributed systems and the tools Spring Cloud provides
- How Spring Boot 4.1, Spring Cloud 2025.1 and Java 25 LTS fit together
- Lab: set up projects with Spring Initializr and Docker Compose for the databases
Section 2: Lab: RESTful Services with Spring Boot 4.1
- Review controllers, request mappings and correct HTTP status codes
- Validation and standard error responses with ProblemDetail
- Connect to the database with Spring Data JPA and entity relationships
- API versioning built into Spring Framework 7
- Lab: a user service ready to be called by other services
Section 3: Lab: API Documentation and Actuator
- Generate OpenAPI documentation and a Swagger UI page with springdoc-openapi
- The Richardson Maturity Model and good practice in API design
- Spring Boot Actuator: health, info and metrics endpoints
- Liveness and readiness probes for systems that run in containers
- Lab: publish API documentation and health checks for every service
Section 4: Lab: Splitting into Currency Exchange and Conversion Services
- Design a currency exchange service and a currency conversion service
- Standardise ports, URLs and service names
- Give each service its own database and seed data
- Return the instance and port in responses to test load balancing
- Lab: run several instances of the same service at once
Section 5: Lab: Calling Other Services with HTTP Service Clients
- RestClient and synchronous calls to a downstream service
- Declare clients as interfaces with @HttpExchange and group them with @ImportHttpServices
- Set base URLs and timeouts for each client group
- How this compares with Spring Cloud OpenFeign, which is in maintenance mode
- Lab: the conversion service fetches exchange rates from the other service
Day 2 Spring Cloud for Distributed Systems
Section 6: Lab: Spring Cloud Config Server
- The problem of configuration scattered across services
- Set up a Config Server backed by a Git repository
- Separate settings by service name and profile, such as dev and prod
- Connect services with spring.config.import and encrypt secret values
- Lab: move the settings of the limits and currency services into Config Server
Section 7: Lab: Eureka and Spring Cloud LoadBalancer
- Why a naming server is needed and how a service registry works
- Set up a Eureka server and register every service at start-up
- Call services by name instead of URL through a load-balanced RestClient
- Spread requests across instances and watch what happens when one disappears
- Lab: add and remove instances without changing any code
Section 8: Lab: An API Gateway with Spring Cloud Gateway
- The role of an API gateway in a microservice system
- How Spring Cloud Gateway Server WebMVC and Server WebFlux differ
- Define routes, predicates and filters to each service through Eureka
- Global filters for logging and limiting request rates
- Lab: route every external request through a single gateway
Section 9: Lab: Fault Tolerance with Resilience4j
- Cascading failures and why distributed systems must be designed to fail gracefully
- Circuit breakers through Spring Cloud CircuitBreaker with fallbacks
- Resilience4j retry, rate limiter, bulkhead and time limiter
- The new @Retryable and @ConcurrencyLimit in Spring Framework 7
- Lab: shut down a downstream service and watch the system answer with a fallback instead of failing
Section 10: Lab: Spring Cloud Bus and RabbitMQ
- The problem of refreshing configuration in every instance at once
- Run RabbitMQ with Docker and connect every service through Spring Cloud Bus
- Refresh settings across the whole system with a single busrefresh call
- An introduction to event-driven design and asynchronous communication
- Lab: change a value in Git and have every instance pick it up without a restart
Day 3 Observability, Security and Deployment
Section 11: Lab: Distributed Tracing
- How traces and spans reveal where a request slows down across services
- Micrometer Tracing and the Observation API in Spring Boot 4
- Send traces to Zipkin, with OpenTelemetry over OTLP as an alternative
- Add trace IDs to logs to connect problems across services
- Lab: follow a request from the gateway to the database in Zipkin
Section 12: Lab: Metrics and Dashboards
- Collect metrics with Micrometer and expose an endpoint for Prometheus
- Key microservice metrics: latency, error rate and throughput
- Build dashboards in Grafana and set up basic alerts
- Check circuit breaker state through Actuator and metrics
- Lab: a dashboard showing the health of every service
Section 13: Lab: Securing Microservices
- OAuth2 and OpenID Connect for multi-service systems
- Use Keycloak as the authorisation server that issues JWTs
- Configure each service as a resource server with Spring Security
- Check permissions at the gateway and relay the token to downstream services
- Lab: protect the whole system's APIs with JWT and role-based permissions
Section 14: Lab: Containers and Deployment
- Build images with a Dockerfile or Cloud Native Buildpacks
- Run the whole system with Docker Compose, with start-up order and health checks
- Java 25 virtual threads and handling many concurrent requests
- An overview of moving to Kubernetes and what can replace Eureka and Config Server there
Section 15: Workshop: Capstone Microservice System
- Add a new service with configuration, discovery and a gateway route
- Test resilience by shutting services down and adding latency on purpose
- Track down the cause of problems from traces, metrics and logs
- Present the work, review it together and wrap up with a pre-production checklist
Schedule & training options
For individuals — public rounds
No public rounds are open right now. Join the waiting list and we will contact you first when the next round opens, or ask us on LINE. Or call 02-570-8449 or 088-807-9770
For organisations — in-house / private
- Tailor the content to your team’s tools and projects
- Your dates, at your office or live online
- Quotation with tax ID for procurement
Instructors
Frequently asked questions
What is Spring Cloud Config Server used for?
Config Server is a central store for the configuration of every microservice, usually backed by a Git repository organised by service name and profile, such as dev or prod. Each service pulls its settings through spring.config.import at start-up instead of embedding them in the project, so values can change without a rebuild. Combined with Spring Cloud Bus, a single call can tell every instance to reload the new settings.
How does the Resilience4j circuit breaker work?
A circuit breaker counts failed calls to a downstream service. When the failure rate passes a threshold it switches to open and returns a fallback straight away without calling the service, stopping failures from cascading through the system. After a wait it moves to half-open and lets a few calls through, returning to closed if they succeed. In Spring Boot you use it through Spring Cloud CircuitBreaker or Resilience4j annotations, alongside retry, rate limiter and bulkhead.
Should I use OpenFeign or HTTP service clients to call other services?
Spring Cloud OpenFeign is feature-complete and receives only bug fixes, and the Spring team recommends HTTP service clients for new projects. You declare a client as an interface with @HttpExchange, Spring Boot 4 configures it automatically, you can group clients and set base URLs and timeouts through properties, and it works with LoadBalancer to call services by their Eureka name. This course therefore teaches HTTP service clients first and explains OpenFeign so you can read existing code.
Who is the Microservices with Spring Boot and Spring Cloud course for, and what should I know beforehand?
It suits Java developers who already use Spring Boot and want to move on to microservices, backend developers who need to split an existing system, software architects, tech leads and DevOps teams. You should know object-oriented Java, have built applications with Spring Boot, understand RESTful APIs and be able to use a relational database. If you have not used Spring Boot before, take Spring Framework 7 and Spring Boot 4 Basic to Advanced first.
What will I be able to do after the Microservices with Spring Boot and Spring Cloud course?
You will be able to draw service boundaries, build RESTful services in Spring Boot 4.1 with OpenAPI documentation and health checks, have services call each other through HTTP service clients, centralise configuration with Config Server, discover services with Eureka, put Spring Cloud Gateway in front, add fault tolerance with Resilience4j, trace requests with Micrometer Tracing and Zipkin, secure the system with OAuth2 and run it all with Docker Compose. Participants who complete the training receive a Certificate of Completion with its own number, which can be verified online.
Can the Microservices with Spring Boot and Spring Cloud course be run in-house for our team?
Yes. It can be run in-house for your team, with examples adapted to your own work, such as designing services around the Java systems your team already maintains. You can request a quotation from this page, or contact us on LINE @itgenius or by phone on 02-570-8449.