Einführung in Spring Boot Microservices
Schulung & Kurs

Drei Tage intensiver Einstieg in die Entwicklung skalierbarer und robuster Unternehmensanwendungen mit Spring Boot, Spring Modulith und ausgewählten Spring-Cloud-Komponenten. Schritt für Schritt entwickeln wir einen klassischen Monolithen weiter zu einem modularen Monolithen und – wo es sinnvoll ist – zu Microservices. So erhalten Sie das nötige Fundament, um bewusst zu entscheiden, welche Architektur in Ihrem Umfeld am besten passt.

Moderne Softwarearchitektur ist kein Entweder-oder, sondern ein Kontinuum: vom gut strukturierten Monolithen über den modularen Monolithen bis hin zu Microservices. In diesem Kurs erleben Sie diesen Weg konkret an einer gemeinsamen Beispielanwendung.

Das Spring-Ecosystem mit Spring Boot, Spring Data, Spring MVC und Spring Modulith hat sich als dominierendes Java-Framework für den Bau skalierbarer Unternehmensanwendungen etabliert. Mit Spring Modulith definieren und verifizieren Sie Modulgrenzen bereits zur Compile-Zeit. Mit ausgewählten Spring-Cloud-Komponenten (z. B. Service Discovery, Config Server, Circuit Breaker, Resilience) machen Sie verteilte Systeme produktionsreif.

Im Fokus steht nicht „Microservices um jeden Preis“, sondern das Verständnis, wann Monolith, modularer Monolith oder Microservices die passende Wahl sind – und wie Sie Ihre Architektur schrittweise dorthin weiterentwickeln.

Kurse für Teams:

Gerne führen wir zugeschnittene Kurse für euer Team durch - vor Ort, remote oder in unseren Kursräumen.

In-House Kurs Anfragen

Kurstermine:

 

  Rolf Jufer  

Kursinhalt:


Wir entwickeln gemeinsam inkrementell eine Unternehmensanwendung – beginnend bei einem klassischen Monolithen, über einen modularen Monolithen bis hin zu ausgewählten Microservices. Dabei beleuchten wir u. a. folgende Themen:

**Architektur & Design:**

* Monolithen, modulare Monolithen und Microservices – Vergleich, typische Einsatzszenarien und Entscheidungskriterien
* Domain-Driven Design und Modulgrenzen
* Wann passt welche Architektur? Evolution statt Big-Bang-Rewrite
* Twelve-Factor-App-Methode

**Spring Fundamentals:**

* Überblick über das Spring-Ecosystem und zentrale Konzepte (Inversion of Control, Dependency Injection)
* Spring 6/7 und Spring Boot 3.5/4 – relevante Features und Neuerungen für Enterprise-Anwendungen
* Aufsetzen und Konfigurieren von Spring-Boot-Anwendungen mit Spring Initializr, Maven, Profiles
* Produktiver entwickeln mit Spring Boot DevTools

**Modulare Monolithen mit Spring Modulith:**

* Spring Modulith – Strukturierung und Definition von Modulgrenzen
* Modular-First-Design und Verifikation zur Compile-Zeit
* Intra-Process-Communication mit Events
* Modul-Tests und automatische Modul-Dokumentation

**REST Services & Datenpersistenz:**

* REST-Services mit Spring MVC
* RESTful-API-Design Best Practices
* Datenpersistenz mit Spring Data JPA
* Validierung und Fehlermanagement

**OpenAPI & API-Generierung:**

* OpenAPI / Swagger-Spezifikation
* Spring-Boot-Starter für OpenAPI-Integration (springdoc-openapi)
* API-First-Development-Ansatz
* Code-Generierung aus OpenAPI-Spezifikationen
* Dokumentation und Client-Generierung

**Vom Monolithen zu Microservices:**

* Service-Decomposition-Strategien
* Inter-Service-Kommunikation (REST, asynchron)
* API-Gateways mit Spring Cloud Gateway
* Saga-Pattern für verteilte Transaktionen

**Spring Cloud & Resilience:**

* Service Discovery mit Spring Cloud Eureka
* Zentrale Konfiguration mit Spring Cloud Config
* Resilience-Patterns (Circuit Breaker, Retry, Timeout)
* Resilience4j über Spring Cloud CircuitBreaker
* Spring Cloud LoadBalancer

**Observability & Monitoring:**

* Monitoring, Logging und Health-Checks
* Spring Boot Actuator
* Metriken mit Micrometer
* Distributed Tracing (z. B. mit Micrometer Tracing / OpenTelemetry)

**Sicherheit:**

* Spring-Security-Grundlagen
* OAuth 2.0 und JWT in Microservices-Landschaften
* Service-zu-Service-Authentisierung

**Deployment & Containerisierung:**

* Docker für Spring Boot
* Containerisierung von Spring-Boot-Anwendungen
* Graceful Shutdown und Health-Probes
* Typische Deployment-Patterns

**Testing:**

* Testen mit Unit- und Integrationstests
* Spring-Boot-TestContext-Framework
* Contract-Tests mit Spring Cloud Contract
* End-to-End-Tests mit Testcontainers

Wir fokussieren uns auf eine bewusst ausgewählte Teilmenge dieser Themen und vertiefen diese anhand der gemeinsamen Kurs-Applikation – mit klarem Fokus auf produktionsreife Anwendungen.


Disclaimer: Der effektive Kursinhalt kann, abhängig vom Trainer, Durchführung, Dauer und Konstellation der Teilnehmer:innen von obigen Angaben abweichen.

Ob wir es Schulung, Kurs, Workshop, Seminar oder Training nennen, wir möchten Teilnehmer/innen an ihrem Punkt abholen und mit dem nötigen praktischen Wissen ausstatten, damit sie die Technologie nach der Schulung direkt anwenden und eigenständig vertiefen können.

Ziel:

Aufbau von praktischem Know-how und Schaffung eines umfassenden Verständnisses für die effiziente Verwendung des Spring-Ecosystems mit Fokus auf Spring Boot 3.5/4, Spring 6/7, Spring Modulith und ausgewählten Spring-Cloud-Komponenten. Die Teilnehmenden verstehen die Unterschiede zwischen Monolithen, modularen Monolithen und Microservices, kennen typische Einsatzszenarien und können bewusst die passende Architektur für ihre Projekte auswählen. Am Ende des Kurses können sie eigenständig produktionsreife Unternehmensanwendungen implementieren und wissen, wie sie bestehende Systeme evolutionär von Monolithen zu modularen Monolithen oder Microservices weiterentwickeln.


Dauer:

2 Tage (Wird bei In-House Kursen individuell angepasst.)


Form:

Bewährter Mix aus Erläuterung von Konzepten, Live-Coding und gemeinsamem, inkrementellem Aufbau einer umfassenden Kurs-Applikation. Diese entwickelt sich von einem klassischen Monolithen über einen modularen Monolithen bis hin zu ausgewählten Microservices und schliesslich zu einer produktionsreifen, containerisierten Lösung. Immer mit praktischem Fokus auf die Verwendung von Spring Boot in echten Projekten und in der Produktion.


Zielgruppe:

Softwareentwickler/innen, die moderne Spring-Boot-Anwendungen entwickeln und fundiert entscheiden möchten, ob Monolith, modularer Monolith oder Microservices zu ihrem Projekt passen. Entwicklungsteams, die von bestehenden Monolithen zu modularen oder verteilten Systemen übergehen. Architekt/innen und Tech Leads, die Architektur-Stile bewerten und entsprechende Entscheidungen vorbereiten oder treffen müssen.


Voraussetzungen:

Basiswissen in der Softwareentwicklung mit Java (mindestens 1–2 Jahre Erfahrung) und ein Grundverständnis von Datenbanken und SQL. Vertrautheit mit Maven oder Gradle ist von Vorteil. Interesse an Softwarearchitektur und modernen Entwicklungspraktiken wird vorausgesetzt.


Vorbereitung:

Nach der Anmeldung erhalten alle Teilnehmenden einen kurzen Fragebogen sowie eine detaillierte Installationsanleitung. Diese umfasst die Einrichtung von Java 17+, Maven, einer IDE (IntelliJ IDEA oder VS Code), Docker und weiteren Tools. Auf Basis der Antworten und des Vorbereitungstands geben wir individuelles Feedback und stellen bei Bedarf vorbereitende Materialien zur Verfügung.

In-House Kurs anfragen:

In-House Kurs Anfragen

Trage dich in die Warteliste ein für weitere öffentliche Kurs-Termine. Sobald wir genügend Personen auf der Warteliste haben, klären wir einen möglichst für alle passenden Termin ab und schalten einen neuen Termin auf. Falls du direkt mit zwei Kollegen oder Kolleginnen teilnehmen möchtest, können wir sogar direkt einen öffentlichen Kurs für euch planen.

Warteliste

(Falls ihr bereits mehr 3 Teilnehmer:innen oder mehr habt, klären wir mit euch direkt euren Wunschtermin ab und schreiben den Kurs aus.)

Mehr über Spring Boot und Microservices



Warum Sie an diesem Kurs teilnehmen sollten:

- Sie erhalten eine klare Entscheidungsbasis, wann Monolith, modularer Monolith oder Microservices die richtige Wahl sind.
- Sie bauen eine komplette, produktionsreife Kurs-Applikation auf – von der ersten Spring-Boot-App bis zur containerisierten, beobachtbaren Lösung.
- Sie lernen Spring Modulith in der Praxis kennen und machen Ihre bestehenden und neuen Anwendungen modular und wartbar.
- Sie arbeiten mit einem modernen Spring-Stack (Spring 6/7, Spring Boot 3.5/4, Spring Cloud, OpenAPI) und können dieses Wissen direkt in Ihren Projekten einsetzen.
- Sie verbinden Architekturkonzepte mit echtem Code und stärken damit Ihr Profil als Software-Ingenieur/in, Tech Lead oder Architekt/in.




History


Das Spring Framework wurde 2002 von Rod Johnson als Alternative zu komplexen Enterprise-Java-Frameworks entwickelt. Spring Boot entstand 2014 unter der Leitung von Phil Webb und dem Pivotal-Team, um die Entwicklung von Spring-Anwendungen radikal zu vereinfachen – mit Auto-Configuration, Starter-Dependencies und eingebettetem Server.


Spring Cloud entwickelte sich ab 2015 als Antwort auf die wachsende Microservices-Bewegung und integrierte Patterns wie Service Discovery, Config Management und Circuit Breaker. Spring Modulith wurde 2022 von Oliver Drotbohm eingeführt, um die Lücke zwischen Monolithen und Microservices zu schliessen – mit Fokus auf modulare Strukturen, die zur Compile-Zeit verifiziert werden.


Heute repräsentiert das Spring-Ecosystem die Evolution moderner Softwarearchitektur: vom klassischen Monolithen über den modularen Monolithen bis zu Microservices. Mit Spring Boot 3.x/4.x, Spring 6.x/7.x und Spring Modulith können Entwickler bewusst die passende Architektur wählen und Systeme evolutionär weiterentwickeln – ohne Big-Bang-Rewrites. Das Ecosystem wird von Millionen Entwicklern weltweit eingesetzt und prägt massgeblich die Entwicklung von Cloud-nativen Enterprise-Anwendungen.