Kurs · Schulung · Workshop
Einführung in Spring Boot Microservices
Skalierbare und robuste Unternehmensanwendungen mit Spring Boot, Spring Modulith und Spring Cloud – vom klassischen Monolithen über den modularen Monolithen bis hin zu Microservices.
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.
Trainer
Stimmen unserer Teilnehmer:innen
The course was a good introduction to Microservices with Spring Boot. We can now start discussing how we want to build up our microservice structure and whether it is necessary to destructure existing monoliths
Full Stack Developer
Diese Kunden haben Kurse im gleichen Themen-Cluster bei uns gebucht.Mehr Kunden →
Inhalt
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.
Der effektive Kursinhalt kann, abhängig von Trainer, Durchführung, Dauer und Konstellation der Teilnehmer:innen, von obigen Angaben abweichen.
In-House Kurs anfragen
Öffentlichen Termin anfragen
Kein passender öffentlicher Termin dabei? Trag dich unverbindlich ein – sobald genug Interesse besteht, planen wir einen neuen öffentlichen Termin und informieren dich zuerst.
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.Weitere Ressourcen:
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.