spring-microservices-v3: a course repository tracking Spring Boot 3 migrations

This is a course repository with sample services, not a distributed framework

The first thing to understand about in28minutes/spring-microservices-v3 is that it is a teaching repository. The README is the course page: it advertises a Udemy course whose homepage is linked from the repository, it lists course updates by month and year, and it enumerates more than seventy numbered steps across three modules. What it does not do is expose a library you would add to your build, a plugin, or a starter template.

The top-level entries confirm that reading. Instead of `src/` and a build file for a single artifact, the repository is organised as a set of numbered course folders: `02.restful-web-services/`, `03.microservices/`, `04.docker/`, `05.kubernetes/`, `91.docker/`, `97.new-features/`, `98.microservices-starting-point-for-v1-learners/` and `99.presentation/`. There is also a `prep/` folder and several top-level notes files: `text-lectures.md`, `todo.md`, `v2-upgrade.md`, `v3-upgrade.md`, `v3-vv-upgrade-recording-notes.md` and `v3-zz-course-updates.md`.

The services the course builds are named in the step list rather than defined at the root: a limits service, a currency exchange service, a currency conversion service, a Eureka naming server, a Spring Cloud API gateway and a Zipkin instance. The interesting engineering content is in the progression between those services, not in a reusable artifact you could depend on.

Four upgrade markers date the course to the Spring Boot 3 era

The Course Updates section of the README is short and gives the version history a reader needs. In Jan 2021 Docker and Kubernetes were added to the course. In Aug 2022 the REST API V2 section was recorded with Spring Boot 3. In Feb 2023 Microservices V2 was upgraded to Spring Boot 3. In Aug 2024 the Microservices and REST API introductions were re-recorded.

Those four markers tell you how the course was refreshed rather than rewritten. The service code was upgraded in place, and the explanatory videos were re-recorded later. Anyone who watched the earlier videos is looking at a course whose code has moved forward while the narration still uses the old vocabulary, which is exactly the situation the two upgrade notes files at the top of the repository are there to address.

The stack the README lists is Spring Boot 2.4.x+ and Spring Cloud 2020.x+. The repository name carries the v3 label, and the topics listed for it include `springboot3`, which lines up with the update log rather than with a separate framework version.

There are no GitHub releases for this repository. Any reference to a fixed point in the course therefore comes from a commit rather than a tag, which matters if you plan to follow the course over time and want to return to the state you watched.

Ribbon, Zuul and Hystrix are gone, replaced by LoadBalancer, Gateway and Resilience4j

The clearest signal of what changed between the versions of this course is the component list. The README names a service registry using Eureka Naming Server, load balancing with Spring Cloud LoadBalancer, which it marks as replacing Ribbon, an API gateway with Spring Cloud Gateway, which it says is instead of Zuul, and a circuit breaker with Resilience4j, which it says is instead of Hystrix. Distributed tracing is handled with Zipkin and asynchronous communication with Rabbit MQ.

That is the real alternative story in this repository, and it is a comparison of approaches rather than of brands. Ribbon was a client-side load balancer with its own configuration model, and the replacement puts load balancing behind Spring Cloud's own abstraction. Zuul was built around filters and a Netty based proxy, and the replacement is the gateway implementation that the course itself drives through route exploration and a logging filter. Hystrix was the Netflix circuit breaker that came with its own dashboard ecosystem, and the replacement is a library integrated with the Spring configuration model, which is why the step list can cover retry, fallback methods, rate limiting and bulkhead behaviour as ordinary application concerns.

If you are deciding which of these stacks to learn, that substitution list is the argument for the current course version. If you maintain an older system, the same list tells you exactly which three libraries you will have to replace when you move to Spring Boot 3.

The MySQL container is the one command the README expects you to run first

The README gives a single concrete command, in a section titled Launch MySQL as Docker Container. It starts MySQL with a root password, a named application user and password, and a named database, publishes the container port on the host, and uses the `mysql:8-oracle` image.

docker run --detach --env MYSQL_ROOT_PASSWORD=dummypassword --env MYSQL_USER=social-media-user --env MYSQL_PASSWORD=dummypassword --env MYSQL_DATABASE=social-media-database --name mysql --publish 3306:3306 mysql:8-oracle

The database name it creates matches the example domain of the course, so the credentials here are meant to be used as written in the later configuration steps rather than treated as a template to secure. The environment variables named in the command, `MYSQL_ROOT_PASSWORD`, `MYSQL_USER`, `MYSQL_PASSWORD` and `MYSQL_DATABASE`, are the ones to expect to see referenced again when the JPA and initialised data steps configure the currency services.

That single command is the extent of the setup documentation. The README does not give a Compose file, a Kubernetes manifest, or a script to bootstrap the whole environment, even though the Docker and Kubernetes modules cover exactly that. Anyone following the course will create those artefacts themselves as the steps progress, which is a deliberate teaching choice but also a real friction point for a reader who wants a running system rather than a lesson.

Java 17 or later is the hard prerequisite, and the tooling advice is thin

The Installing Tools section recommends the latest version of Java, the latest version of Eclipse IDE for Enterprise Java Developers or IntelliJ Community Edition, and states the key constraint plainly: Spring Boot 3 works only with Java 17 and later.

That single line rules out a lot of environments, and it is worth stating before anything else. A team on Java 8 or 11, which was the common baseline when the earlier Microservices V1 and V2 courses were recorded, cannot run any of this code without a toolchain change first. The README does not discuss a compatibility path for older Java versions, and the presence of `98.microservices-starting-point-for-v1-learners/` suggests that earlier starting points exist for learners who began with the previous version of the course, but it does not describe running the V1 lessons on an older JDK.

The rest of the setup guidance is a set of links to YouTube videos for installing Java and Eclipse on Windows, Linux and Mac, plus troubleshooting videos for the same tasks. That is a reasonable choice for a video course, and it is a thin one for a repository. There is no documented dependency list for the sample services at the root, no stated container base image for the applications, and no configuration sample for the Eureka server, the gateway or the Zipkin instance in the README itself.

The topic tags list `microservices`, `spring`, `springboot`, `springboot3` and `springcloud`, which is a fair summary of the scope and a reminder that the Docker and Kubernetes lessons are a supporting module rather than the core of the repository.

The step list shows the learning order, including where the course starts with hard coded values

The Microservices with Spring Cloud V2 section runs to twenty-nine steps and reads as a curriculum rather than a description of a finished system. It opens by setting up a limits microservice, then deliberately creating a hard coded limits service before enhancing it to pick up configuration from application properties. The same pattern recurs for currency exchange: a simple hard coded currency exchange service first, then dynamic port in the response, then JPA and initialised data, a JPA repository, and finally the currency conversion service that invokes it.

That ordering is a deliberate teaching device, and it is the single most useful thing in the repository for a self-learner. Starting from hard coded values means you can see what each infrastructure piece actually replaces. The configuration steps then walk through Spring Cloud Config Server, a local Git repository, connecting the config server to it, connecting the limits service to the config server, and profiles.

The later steps cover the pieces that make the services behave as a system: Feign as the REST client, Eureka as the naming server, load balancing across Eureka with Feign and Spring Cloud LoadBalancer, the API gateway with the discovery locator enabled, and then Resilience4j in three passes covering retry and fallback, further circuit breaker features, and rate limiting with bulkhead.

The Docker module covers image and container fundamentals, the Docker client and engine architecture, a Zipkin container, and Compose runs for the currency exchange service, Eureka, the currency conversion service, the gateway and Zipkin. The Kubernetes module then moves to Google Kubernetes Engine, pods, replica sets, deployments and services, container images for the two currency services, service discovery in the cluster, declarative YAML configuration, and enabling logging and tracing APIs on Google Cloud Platform.

The README is truncated in the listing above, so the final Kubernetes steps are not fully visible, but the direction of the course is clear: it ends with the same three services running on a managed Kubernetes cluster rather than on Compose.

Editorial conclusion

Adopt spring-microservices-v3 as a learning resource when you want a worked path from a hard coded limits service through Eureka discovery, Feign calls, an API gateway and container deployment, and when you need to see the Spring Boot 3 versions of those pieces side by side. Do not treat it as a production framework: it carries no releases, its licence is not identified in the README, and it is a companion to a paid course rather than a maintained library. Before you build on any of it, check the `v3-upgrade.md` and `v2-upgrade.md` notes against your own Spring Cloud version, and confirm Java 17 is available, since the README states Spring Boot 3 works only with Java 17 or later.

Frequently asked questions

Official sources

1. in28minutes/spring-microservices-v3 on GitHub
2. Issues
3. Project website
4. README